mac-rom/OS/DispatchHelper.a

314 lines
12 KiB
Plaintext
Raw Normal View History

;
; File: DispatchHelper.a
;
; Written by: Jeff Miller
;
; Contains: Code implementing the generic dispatcher (DispatchHelper) and generic procedure
; dispatcher (ProcHelper). Both are installed as OSTraps, but they should always
; be called from the low memory vector rather than through the trap mechanism.
;
; Copyright: <09> 1990-1991 by Apple Computer, Inc., all rights reserved.
;
; Change History (most recent first):
;
; <8> 8/29/91 JSM Cleanup header.
; <7> 10/22/90 JSM <dba> Use dispatchFlags equates and DispatchUnimplementedRoutine
; macro, add support for more efficient linked patch dispatching
; with absolute addresses, don't support NULL dispatch table
; entries anymore for more efficient dispatching, misc. other
; optimizations.
; <6> 9/25/90 KIP Change it back to a linked patch.
; <5> 8/9/90 gbm LinkPatch REALLY hates main modules...
; <4> 8/8/90 SAM Making DispatchHelper & ProcHelper load as an old style ptch.
; <09><><EFBFBD>---> Temporary <---<2D><><EFBFBD> remove this when the Sound Mgr code is
; converted to a linked patch (as it should be).
; <3> 7/12/90 STB Moved _ProcHelper & _DispatchHelper patch installation code from
; MiscPatches.a to here.
; <2> 7/8/90 JSM ProcHelper takes a pointer to use count instead of an offset
; now.
; <1> 7/7/90 JSM First checked in.
;
LOAD 'StandardEqu.d'
INCLUDE 'DispatchHelperPriv.a'
INCLUDE 'LinkedPatchMacros.a'
;___________________________________________________________________________________
; These linked patches are installed on all ROM families
;
ROMs Plus,SE,II,Portable,IIci
;___________________________________________________________________________________
; DispatchHelper
;
; A generic dispatcher. Assumes all routines it dispatches to are
; Pascal functions returning an OSErr. Installed as OS trap $A0EC, but
; should always be called directly through the vector at $7B0.
;
; Selectors are in D0.W, with the low byte containing the actual selector
; and the high byte containing the number of words of parameters on the
; stack.
;
; Uses a standard DispatchHelperTable specifying the valid selector range and
; offsets to each routine.
;
; If the low byte of D0 is out of range, DispatchHelper strips the parameters
; off the stack and returns paramErr.
;
; If bit 1 (dhAbsoluteEntries) of dispatchFlags in the DispatchHelperTable is set,
; DispatchHelper assumes that the entries in the dispatch table are 4 byte absolute
; addresses (used mainly in linked patches). Otherwise, entries in the dispatch
; table are 2 byte offsets from the beginning of the table to the actual routine.
;
; If bit 0 (dhSelectorsEven) of dispatchFlags in the DispatchHelperTable is set,
; DispatchHelper assumes that the selector in D0 is already even and doesn't multiply
; it by two to get to the offset. Note that all even selectors are currently unsupported
; for absolute address dispatch tables.
;
; General implementation strategy: since absolute addresses are used by linked patches in
; some very common cases (for example: dialogs, windows, and menus), we want that case to
; execute the fastest (i.e. with the fewest branches). Note that trying to overload
; dispatchFlags too much goes against the original intent of DispatchHelper, which is
; speed.
;
; Inputs:
; A0 Pointer to DispatchHelperTable.
; D0.W Low byte is selector, high byte is number of words of parameters.
;
; Outputs:
; D0.W untouched
;
; Destroys:
; D1, A0
;
;___________________________________________________________________________________
DispatchHelper PatchProc _DispatchHelperTrap
WITH DispatchHelperTable
MOVE.W D0,D1 ; get selector in D1 so we don't touch D0
;
; Make sure the selector is in range
;
CMP.B lastSelector(A0),D1 ; is selector too large?
BGT.S DispatchHelperBadSelector ; yes, cleanup and return
SUB.B firstSelector(A0),D1 ; get absolute zero-based selector
BLT.S DispatchHelperBadSelector ; if too small, cleanup and return
;
; Selector is in range, now dispatch
; Since we only support dhAbsoluteEntries or dhSelectorsEven, but never both
; at the same time, we can do a CMP, which is faster than a BTST.
;
EXT.W D1 ; selector OK, make it a word
CMP.W #(1<<dhAbsoluteEntries),dispatchFlags(A0) ; are entries absolute addresses?
BNE.S @offsetEntries ; no, they're word offsets
;
; Entries in DispatchHelperTable are absolute addresses (used in linked patches)
;
ASL.W #2,D1 ; convert to offset from firstAddress
MOVE.L firstAddress(A0,D1.W),A0 ; A0 = absolute address of routine entry point
JMP (A0) ; jump to entry point
;
; Entries in DispatchHelperTable are word offsets from beginning
;
@offsetEntries
CMP.W #(1<<dhSelectorsEven),dispatchFlags(A0) ; are selectors even?
BEQ.S @D1IsOffset ; yes, no need to double D1
ADD.W D1,D1 ; convert to offset from firstOffset
@D1IsOffset
MOVE.W firstOffset(A0,D1.W),D1 ; D1.W = routine offset from DispatchHelperTable
ADD.W D1,A0 ; A0 = actual routine entry point
JMP (A0) ; jump to entry point
ENDWITH ; DispatchHelperTable
;
; Selector is out of range, clean up stack and return paramErr
;
EXPORT DispatchHelperBadSelector ; so Dispatcher linked patch macro can reference it
DispatchHelperBadSelector
DispatchUnimplementedRoutine ; cleans up stack and returns to caller
ENDPROC ; DispatchHelper
;___________________________________________________________________________________
; ProcHelper
;
; A resource-based procedure dispatcher. Assumes all routines it dispatches
; to are Pascal functions returning an OSErr. Originally designed for
; use with PACKs, but will work with all resource-based code of the correct
; format. Installed as OS trap $A09A, but should always be called directly
; through the vector at $668.
;
; Uses DispatchHelper, so selectors are in D0.W, with the low byte containing
; the actual selector and the high byte containing the number of words of
; parameters on the stack.
;
; A0 should be a handle to the procedure resource ('PACK', 'proc', or
; whatever) that begins with a ProcHelperHeader. If the handle is NIL,
; returns memFullErr. If the handle has been purged, and LoadResource fails,
; returns ResError. In either case, the parameters are stripped of the stack
; before returning.
;
; For maximum memory usage benefits, procedure resources should be purgeable.
;
; A1 should be a pointer to a word of globals ProcHelper can use to store a
; use count for this resource. The word should be initialized to 0 before
; ProcHelper is called the first time for a resource. ProcHelper uses this
; count to handle locking and unlocking the resource. ProcHelper updates
; this use count be changing the return address to always come back through
; ProcHelperReturn. See the ERS for more details on the stack manipulation
; used to do this, but here is an example of what happens to the stack
; when there are three words of parameters:
;
; On entry to called routine
;
; +--------+--------+
; | ProcHelperReturn|
; +--------+--------+
; | param3 | param2 |
; On entry to ProcHelper +--------+--------+
; | param1 | OSErr |
; +--------+--------+ +--------+--------+
; | return address | | return address |
; +--------+--------+ +--------+--------+
; | param3 | param2 | | use count ptr |
; +--------+--------+ +--------+--------+
; | param1 | OSErr | | proc handle |
; +--------+--------+ +--------+--------+
;
; Inputs:
; D0.W Low byte is selector, high byte is number of words of parameters.
; A1 Pointer to the use count global for this procedure
; A0 Handle to procedure resource
;
; Outputs:
; When branching to DispatchHelper:
; A0 Pointer to DispatchHelperTable.
; D0.W Low byte is selector, high byte is number of words of parameters.
;
; When returning to application:
; None
;
; Destroys:
; When branching to DispatchHelper:
; D1, D2, A1
;
;___________________________________________________________________________________
ProcHelper PatchProc _ProcHelperTrap
;
; Reload procedure resource, if necessary
;
MOVE.L A0,D1 ; is the procedure handle NIL?
BEQ.S ResHandleNil ; no handle -> resource gone
TST.L (A0) ; is procedure pointer NIL?
BNE.S @resLoaded ; no, we're OK
MOVE.L A0,-(SP) ; push handle for LoadResource
MOVE.W #MapTrue,ROMMapInsert ; use ROM map as well ???
_LoadResource ; Note: preserves ALL registers
TST.L (A0) ; Did load fail?
BEQ.S ResNotLoaded ; NIL handle -> could not load
@resLoaded
;
; Check use count to see if there is already a call in progress
;
TST.W (A1) ; is there a call in process (count <> 0)?
BNE.S @procNowLocked ; yes, not first time through
;
; This is the first call, so lock down the procedure resource
;
MOVE.W D0,-(SP) ; save selector on stack across HLock
_HLock ; lock down resource
MOVE.W (SP)+,D0 ; restore selector
@procNowLocked
ADDQ.W #1,(A1) ; increment use count
MOVE.L A1,D2 ; save ptr to use count
;
; Make space on stack for moving parameters down and saving of
; old return address, use count pointer, and resource handle
;
SUBQ #8,SP ; need two longs for use count ptr and proc handle
PEA ProcHelperReturn ; return to this address after call
MOVE.L 12(SP),-(SP) ; save off real return address
;
; Loop through number of words of parameters, moving them down each time
;
MOVE.W D0,D1 ; D1.W = selector
LSR.W #8,D1 ; D1.W = words of parameters
LEA 8(SP),A1 ; get ptr to place to put parameters
@moveLoop
MOVE.W 12(A1),(A1)+ ; D0.W = current parameter
DBRA D1,@moveLoop ; continue moving parameters
;
; Save off needed values underneath the parameters we just moved
;
MOVE.L (SP)+,(A1)+ ; save real return address
MOVE.L D2,(A1)+ ; save ptr to use count
MOVE.L A0,(A1)+ ; save handle to proc
;
; Set up A0 to point to DispatchTable, then branch to dispatcher
;
MOVE.L (A0),A0 ; A0 = pointer to proc header
ADD.L #ProcHelperHeader.ProcDispTable,A0 ; A0 = pointer to start of dispatch table
_DispatchHelper ; call DispatchHelper through vector
;
; Procedure called through DispatchHelper returns to here
;
ProcHelperReturn
MOVE.W (SP)+,D1 ; D1.W = returned OSErr
MOVE.L (SP)+,A1 ; get real return address
MOVE.L (SP)+,A0 ; get pointer to use count
SUBQ.W #1,(A0) ; decrement use count
MOVE.L (SP)+,A0 ; get handle to procedure resource
BNE.S @stillInUse ; if use count not zero, still calls processing
_HUnlock ; unlock procedure resorce in A0
@stillInUse
MOVE.W D1,-(SP) ; restore returned OSErr
JMP (A1) ; return to proc caller
ResHandleNil
;
; No handle for procedure, return memFullErr
;
MOVE.W #memFullErr,D1 ; put error in D1.W
BRA.S ProcHelperError ; and return
ResNotLoaded
;
; Could not reload the procedure resource, return ResError
;
MOVE.W ResErr,D1 ; get ResError() in D1.W
;BRA.S ProcHelperError ; fall through to ProcHelperError
;
; An error occurred before the dispatch could happen.
; Clean up the stack, and return to caller with error code in D1.W.
;
ProcHelperError
MOVE.L (SP)+,A0 ; get caller's return address
LSR.W #8,D0 ; D0.W = words of parameters
LSL.W #1,D0 ; D0.W = bytes of parameters
ADD.W D0,SP ; strip off parameters
MOVE.W D1,(SP) ; return error in D1.W
JMP (A0) ; return to caller
ENDPROC ; ProcHelper
END