mac-rom/OS/OSEventMgr.a

627 lines
23 KiB
Plaintext
Raw Normal View History

;
; File: OSEventMgr.a
;
; Contains: Macintosh OS Event Manager
;
; Written by: Andy Hertzfeld 02-Nov-81
;
; Copyright: <09> 1981-1993 by Apple Computer, Inc. All rights reserved.
;
; Change History (most recent first):
;
; <SM12> 12/13/93 PN Roll in KAOs and Horror changes to support Malcom and AJ
; machines.
; <SM11> 11/11/93 rab Added the label OldOSEventAvail at the original entry point for
; OSEventAvail. Changed GetOSEvent to bsr to the old entry point
; and bypass the rolled in HelpMgr Patch. This fixes bug# 1123113.
; Also backed out SM7 since it is no longer necessary.
; <SM10> 5/18/93 rab Fix Radar #1082829. Change GetOSEvent so that it doesn't do
; smgrpostmunging if smgrCore hasn't been set up (= -1).
; <SM9> 12/30/92 rab Made a change to InitEvents so that it does nothing if the
; EventQueue has already been set up. This keeps DiskInsertEvents
; from getting lost if the boot fails.
; <SM8> 12/16/92 SWC Moved InitEvents here from StartBoot.
; <SM7> 12/09/92 HI Modified the HelpMgr patch code in OSEventAvail to check for the
; emIsDragging field of ExpandMem; if set, then the patch is
; bypassed. This prevents HelpMgr from removing/displaying another
; help balloon and altering the WMgrPort's clipRgn, penPat, and
; penMode and allows DragTheRgn to properly remove the drag region.
; (Hoon Im)
; <SM6> 6/22/92 RB Rolled-in the Help Manager patch to OSEventAvail from
; BalloonPthc28.a, HMOSEventAvailPatch.
; <SM5> 6/12/92 CS Roll-in Reality Changes:
; <6> 6/12/92 FM Change the BigJmp to SMgrPostMunging to be a jsr through the
; internal scriptmgr vector.
; <SM4> 5/21/92 kc Append "Trap" to the names of
; PostEvent,GetOSEvent,OSEventAvail,Enqueue and Dequeue to avoid
; name conflict with the glue.
; <SM3> 5/17/92 kc Remove "With PmgrRec."
; <5> 4/27/92 JSM Get rid of conditionals: hasIdle and isUniversal are always
; true, onMac is always false. This file now has no conditionals.
; <4> 8/30/91 JSM Cleanup header.
; <3> 6/12/91 LN Changed #include 'HardwareEqu.a' to 'HardwarePrivateEqu.a'
; <2> 3/29/90 MSH Add universal run time test for IdleUpdate call.
; <1.6> 11/1/89 MSH Rolling in changes from HcMac Reality sources: Pmgr equates now
; in record format.
; <1.5> 8/22/89 SES Removed references to nFiles.
; <1.4> 3/31/89 MSH Bump LastAct if an event is available.
; <1.3> 2/21/89 PKE Rearranged GetOSEvent so DeleteEvt doesn't return through
; SMgrPostMunging (this also fixes a FlushEvents bug caused by
; BigJMP), and so A0 is correctly set up when GetOSEvent returns
; through SMgrPostMunging.
; <1.2> 1/16/89 GGD Added a scratch register parameter to the BigJMP macro calls
; since it will be needed when they change to use PC relative
; addressing.
; <1.1> 11/10/88 CCH Fixed Header.
; <1.0> 11/9/88 CCH Adding to EASE.
; <1.4> 10/27/88 PKE added support for script manager
; <<3C>1.3> 9/23/88 CCH Got rid of inc.sum.d and empty nFiles
; <1.2> 9/8/88 MSH New version of sleep/idle support.
; <1.1> 4/18/88 CSL Add support for SLEEP & IDLE in PostEvent
; <1.0> 2/10/88 BBM Adding file for the first time into EASE<53>
; <C517> 12/12/86 EMT Shuffle keyboard globals for Excel. Affects OSEventMgr.a, kbd.a,
; nSysEqu.a
; <C206> 10/9/86 bbm Modified to mpw aincludes.
; <C173> 9/24/86 EMT Changed interrupt mask in PostEvent and company to disable SCC
; as well as VIA interrupts.
; <C89> 7/28/86 EMT Changed to use long word NewKeyLast instead of KeyLast for Apple
; Desktop Bus machines
; 2/19/86 BBM Made some modifications to work under MPW
; 10/28/85 DLD Changed FlushEvents to put a -1 into LastSPExtra for FontMGR
; 7/24/85 RDC Changed interrupt level settings to use equate Added spearate
; include statement for HWequ file (no longer in systlqk.sym)
; 6/7/85 JTC Make results of os routines long. <07Jun85>
; 3/3/85 LAK Don't flush events masked out by FlEvtMask in FlushEvents (this
; is a new mask, initialized at SysInit time to $FF7F, i.e., all
; events except DIP events). This is an attempt to correct the
; problem that -1 is a common parameter given to FlushEvents at
; the start of a program, even though a flush of DIP is probably
; not intended.
; 1/31/85 LAK Removed false RTE.
; 1/23/85 LAK Adapted for new equate files. Added equate for NoEvtAvail
; (equate was deleted from SysErr.Text)
; 8/17/83 LAK PostEvent now uses EvtBufCnt instead of hardwired EvtMax.
; 2/22/83 LAK made all routines observe Pascal regsave conventions.
; 1/3/83 AJH Got rid of update event, changed names of GetNextEvent and
; EventAvail
; 10/16/82 LAK Update events return 0 in D0 now for GetNextEvent and
; EventAvail.
; 10/1/82 LAK A0 saved over checkupdate call now . . .
; 7/26/82 LAK FLUSHEVENTS returns # of event type it stopped on, if any Added
; update events . . .
; 6/9/82 LAK Moved keyboard auto-repeat function here
;
;
; This is the event manager for the MacIntosh Operating
; system. It manipulates events on the system event queue.
; Its major routines are "PostEvent" which adds an event to the
; event queue, and "GetNextEvent" which returns the next event
; in the queue. PostEvent may be called from an interrupt (level 1)
; or completion routine; all other routines in the event
; manager must be called from the main thread of execution. There are
; two other Event Manager routines, "FlushEvents" and "EventAvail",
; giving a total of 4 routines. Some of these routines call other ones,
; and all are accessible via operating system calls:
;
; os call --> GetNextEvent os call --> FlushEvents
; |
; v
; os call --> EventAvail
; |
; (auto-key event generation)
; |
; v
; os call --> PostEvent
;
; The Event Manager manages its own private buffer to get storage for the
; event queueing elements. It does this because PostEvent runs at interrupt
; level and thus cannot call the standard storage allocator.
;
BLANKS ON
STRING ASIS
LOAD 'StandardEqu.d'
INCLUDE 'HardwarePrivateEqu.a'
INCLUDE 'UniversalEqu.a'
INCLUDE 'ScriptPriv.a'
INCLUDE 'Balloons.a' ;
INCLUDE 'BalloonsPriv.a' ;
INCLUDE 'PowerPrivEqu.a' ;
INCLUDE 'Processes.a'
Events PROC EXPORT
EXPORT InitEvents,PostEventTrap,GetOSEventTrap,OSEventAvailTrap,FlushEvents,NewEMFunction
IMPORT EnqueueTrap,DequeueTrap,SMgrPostMunging
NoEvtAvail EQU -1 ; (moved from SysErr.Text)
EvtOffset EQU 6 ; event record offset from start of
; event queue element
;_______________________________________________________________________
;
; Routine: InitEvents afe0
;
; Arguments: D0 (input) -- number of elements in the event queue
; D0 (output) -- result code
;
; Function: This routine initializes the event queue to the size
; specified in D0.
;
; Other: uses D0,D1,D2,A0,A1
;_______________________________________________________________________
InitEvents move.w EventQueue,d2 ; check the first word of the EventQ <SM9>
bge.s @exit ; if <20>-1 it's set up, leave it alone <SM9>
MOVE.W D0,D2
MOVEQ #EvtQBlkSize,D0
MULU D2,D0
MOVE.L D0,D1 ; save a copy of the size
_NewPtr ,SYS,CLEAR ; get memory for storage allocator
LEA EvtBufCnt,A1
SUBQ #1,D2 ; set up lo mem event buffer count (-1)
MOVE.W D2,(A1) ; EvtBufCnt
CLR.L -(A1) ; EventQueue QTail
CLR.L -(A1) ; EventQueue QHead
CLR.W -(A1) ; EventQueue QFlags
MOVE.L A0,-(A1) ; SysEvtBuf
; fill buffer with all ones
@InitEvLoop NOT.W (A0)+ ; 0000 -> FFFF
SUBQ #2,D1 ; more to do?
BNE.S @InitEvLoop ; size must have been divisible by 4
MOVE.W #$FFEF,-(A1) ; SysEvtMask - enable all events except key up
CLR.W KeyLast ; initialize keyboard repeat stuff
@exit RTS ; <SM9>
;_______________________________________________________________________
;
; Routine: PostEvent b010
;
; Arguments: A0 (input) -- event number (16-bit)
; D0 (input) -- event message (32-bit)
; D0 (output) -- result: 0=event posted, 1=not posted
; A0 (output) -- ptr to event queue element if posted (used
; internally by Eventavail)
;
; Function: This routine adds an event to the system event queue. The
; specified eventnumber and event message are logged for the
; event. The current time, mouse position, state of command
; key, option key, shift key, alpha lock key, and mouse button
; are additional event queueing elements included in
; each event. An event is only posted if enabled by the System
; Event Mask; if not enabled, a result code of 1 is returned.
; This routine will delete the first element of the event queue
; (the oldest element), if the queue is full, to make room for
; the new event: this guarantees that an enabled event will be
; posted.
;
; So that events of the same type are received and
; logged in correct time order of occurrance, the calling routine
; should disable further interrupts from the same source until
; the event has been posted. This works since each event type
; typically has but one source. All interrupts are disabled
; during this routine, first to guarantee the integrity of the
; free buffer allocation and second to enforce the time-ordering
; of events. Currently, only level 1 interrupts are masked because
; SCC interrupts do not generate any events; if that changes (e.g.,
; and SCC system error event is defined), SCC interrupts would
; also have to be masked.
;
; PostEvent can be called by EventAvail to post an auto-key event;
; it is never called to post an update event.
;
; Calling sequence: MOVE.W #eventnumber,A0
; MOVE.L #message,D0
; _PostEvent
;
; Other: uses D0,D1,D2,A0,A1
;_______________________________________________________________________
PostEventTrap
with PowerDispRec
TestFor SupportsIdle
BEQ.S @notsupported
MOVE.L D0,-(SP)
_UsrIdleUpdate ; user update activity log
MOVE.L (SP)+,D0
@notsupported
MOVE.W SysEvtMask,D2 ; system event mask
MOVE.W A0,D1 ; event number
BTST D1,D2 ; is this event enabled?
BNE.S GetFreeOne
MOVEQ #EvtNotEnb,D0 ; if not, skip all this stuff
RTS
GetFreeOne MOVE SR,-(SP) ; save interrupt state
MOVE.L D0,-(SP) ; event message
MOVE.W A0,-(SP) ; event number
MOVE.L SysEvtBuf,A0 ; get address of system event buffer
ADDQ.L #EvtOffset,A0 ; point to event record ($FFFF=free)
MOVEQ #EvtQBlkSize,D0 ; for speed
MOVEQ #-1,D1 ; ibid
SUB D0,A0 ; back pointer down one
MOVE.W EvtBufCnt,D2 ; event buffer count - 1
ORI #HiIntMask,SR ; no interrupts, please <C173 24Sep86>
GetEbufLoop ADD D0,A0 ; bump to next event queue element
CMP.W EvtNum(A0),D1 ; is this element free?
DBEQ D2,GetEbufLoop ; loop till we get one or no more left
LEA EventQueue,A1 ; point A1 to queue header
BEQ.S GotEvtElement ; Z-flag set from CMP only
; no more event buffers available. remove first queue element for a wraparound
; (queue elements are added at the end of the queue, so the first element
; has been around the longest . . .); there must be >1 elements in the queue
; since there are no free elements and given that 29 interrupting processes cannot
; grab elements and not post them into the queue.
MOVE.L QHead(A1),A0 ; point A0 to first queue element
MOVE.L QLink(A0),QHead(A1) ; special case delete: first element
; of a queue of length > 1
; now A0 points to a free element
ADDQ.L #EvtOffset,A0 ; point to event record part
; We got an event queueing element, so fill in the system info and queue it up
GotEvtElement MOVE.W (SP)+,EvtNum(A0) ; set up the event number
MOVE.L (SP)+,EvtMessage(A0) ; set up the message
BSR.S FillRecord ; fill out the rest of the record
SUBQ.L #EvtOffset,A0 ; and point to start of queue element
MOVE #EvType,QType(A0) ; set up the q-element type field
JSR EnqueueTrap ; let queueing routines queue it up
MOVE (SP)+,SR ; restore interrupt state
MOVEQ #0,D0 ; zero result code
RTS ; and return
; FillRecord fills out the standard fields in an event record pointed to by A0
FillRecord MOVE.L Ticks,EvtTicks(A0) ; fill in the current time
MOVE.L Mouse,EvtMouse(A0) ; and the current mouse point
MOVE KeyMap+6,D1 ; get meta-key states
ROL.W #1,D1 ; rotate around
MOVE.B D1,EvtMeta(A0) ; update metakey field
MOVE.B MBState,EvtMBut(A0) ; get mouse button state
EndWith
RTS
;_______________________________________________________________________
;
; Routine: OSEventavail b09c
;
; Arguments: A0 (input) -- pointer to user event record (32-bit)
; D0 (input) -- set of events desired (event mask)
; D0 (output) -- 0=non-null event returned, -1=null event
; returned
; A0 (output) -- pointer to user event record
; A1 (output) -- pointer to event queue element when D0=0
; (used internally by GetNextEvent)
;
; Function: This routine polls for availability of certain types of events.
; The user-specified event record format is identical to that of
; the queue element, except for the queue header fields. If no
; events are available, the null event is returned along with
; a -1 result code in D0.
;
; EventAvail is also called by GetNextEvent.
;
; Calling sequence: MOVE.W #EventMask,D0
; LEA EventBuffer,A0
; _EventAvail
;
; Other: uses D0,D1,D2,A0,A1
;_______________________________________________________________________
OSEventAvailTrap
ANDI.L #$FFFF,D0
OSEventAvailSkippingAndi
with PowerDispRec
MOVEM.L A0-A1/D0-D2,-(SP) ; we need to save these regs
MOVE.L ExpandMem,A0 ; point to the expand mem ptr
TST.B ExpandMemRec.emIsDragging(A0) ; called from DragTheRgn? <SM7>
BNE.S @DoNothing ; yes, skip HelpMgr patch code <SM7>
MOVE.L ExpandMemRec.emHelpGlobals(A0),A0 ; A0 = global ptr
TST.B hmgWhatIs(A0) ; is Balloon help mode on?
BEQ.S @DoNothing ; no, let's not scan for a content window
TST.W hmgOSEventReentrantCount(A0) ; test the reentrant count
BNE.S @DoNothing ; do nothing on the reentrant case
ST hmgOSEventReentrantCount(A0) ; say that we're busy
; from BalloonExtensions.a: ptchHMCallTrackerInContext
SUBQ #$8, SP
SUBQ #$2, SP
PEA.L $2(SP)
MOVEQ.L #-$1, D0 ; like _GetFrontProcess but not quite
MOVE.L D0, -(SP)
MOVE #$39, -(SP)
_OSDispatch
TST (SP)+
BNE.B @wasError
SUBQ #$2, SP
PEA.L $2(SP)
_WakeUpProcess
TST (SP)+
BNE.B @wasError
SUBQ #$2, SP
MOVE #$FC, D0 ; from Balloonptch28.p: HMBalloonBulk
_Pack14
TST (SP)+
@wasError AddQ #$8, SP
; from BalloonExtensions.a: ptchHMGetHelpGlobal
MOVE.L ExpandMem,A0 ; point to the expand mem ptr
MOVE.L ExpandMemRec.emHelpGlobals(A0),A0 ; return the global ptr on the stack
CLR hmgOSEventReentrantCount(A0)
@DoNothing
MOVEM.L (SP)+,A0-A1/D0-D2 ; restore 'em, <SM6> rb, end
OldOSEventAvail ; <SM11>
LEA EventQueue,A1 ; get address of event queue
; Since PostEvent could dequeue the first element at any time, the event you
; are on may suddenly be recycled and you may end up dequeueing a different event
; or suddenly find yourself at the end of the queue when you were just at the
; beginning. By disabling interrupts during the search, this is avoided.
MOVE SR,-(SP) ; save interrupt state
ORI #HiIntMask,SR ; no event-generating interrupts <C173 24Sep86>
MOVE.L QHead(A1),D1 ; get address of 1st element
BEQ.S TstAutoEvent ; if nil, check for auto events
EventALoop MOVE.L D1,A1 ; get pointer into A-reg
MOVE EvtNum+EvtOffset(A1),D1 ; get its event number
BTST D1,D0 ; is it one we want?
BNE.S GotEventAvail ; if so, we got one!
MOVE.L QLink(A1),D1 ; follow the link to the next one
BNE.S EventALoop ; if we got one, check it out
; there wasn't an event in the queue for us, so check for auto events
TstAutoEvent AND.W SysEvtMask,D0 ; figure in system mask for pseudo-evts
BTST #AutoKeyEvt,D0 ; do we want this kind? <C517/12Dec86>
BEQ.S NoEventAvail ; go on if not <C517/12Dec86>
MOVE.W HiKeyLast, D0 ; <C517/12Dec86>
SWAP D0 ; <C517/12Dec86>
MOVE.W KeyLast, D0 ; <C517/12Dec86>
TST.L D0 ; key down to autorepeat? <C517/12Dec86>
BEQ.S NoEventAvail ; if not, return null event
MOVE.L Ticks,D1 ; check first threshold
MOVE.L D1,D2
SUB.L KeyTime,D1
CMPI.L #$8000,D1
BGE @skip
CMP KeyThresh,D1
BLT.S NoEventAvail ; br if not time yet
@skip
SUB.L KeyRepTime,D2 ; check second threshold
CMP KeyRepThresh,D2
BLT.S NoEventAvail ; br if not time yet
MOVE.L Ticks,KeyRepTime ; repeat it: first note the time
MOVE.L A0,-(SP) ; save pointer to user's buffer
MOVE #AutoKeyEvt,A0 ; get event number
; D0 already contains the correct event message <C517/12Dec86>
BSR PostEventTrap ; go post it
MOVE.L A0,A1 ; get pointer to event queue element
MOVE.L (SP)+,A0 ; restore pointer to user's buffer
; and return the event
GotEventAvail
MOVE (SP)+,SR ; restore interrupt state
MOVEQ #(EvtBlkSize/4),D0 ; get size of evt record in longwords
MOVEM.L A0-A1,-(SP) ; preserve regs
ADD.L #EvtOffset,A1 ; bump to record part of event element
TestFor SupportsIdle
BEQ.S @notsupported
MOVE.L D0,-(SP)
_IdleUpdateDispatch ; set for overall activity
MOVE.L (SP)+,D0
@notsupported
@1 MOVE.L (A1)+,(A0)+ ; move it into user's buffer
SUBQ #1,D0
BNE.S @1 ; loop till done
MOVEM.L (SP)+,A0-A1 ; get regs back
RTS ; D0 is zero
; there wasn't any event available so return the null event in the users event
; record and a flag in D0
NoEventAvail BSR.S FillRecord ; fill in record for null events
MOVE (SP)+,SR ; restore interrupt state
CLR.W EvtNum(A0) ; return the null event
CLR.L EvtMessage(A0) ; zero message for null events
MOVEQ #NoEvtAvail,D0 ; and D0 non-zero
EndWith
RTS
;_______________________________________________________________________
;
; Routine: GetOSEvent b1aa
;
; Arguments: A0 (input) -- pointer to user event buffer (32-bit)
; D0 (input) -- type of event desired (event mask)
; D0 (output) -- 0=non-null event returned, -1=null event
; returned
;
; Function: This routine returns the next event in the system event queue.
; The returned event is dequeued, thereby freeing up the space
; which holds that queue element. If no events of the types
; enabled by the mask exist, the null event is returned.
;
; Calling sequence: MOVE.W #EventMask,D0
; LEA EventBuffer,A0
; _GetNextEvent
;
; Other: uses D0,D1,D2,A0,A1
;_______________________________________________________________________
GetOSEventTrap ANDI.L #$FFFF,D0
GetOSEventSkippingAndi
BSR.S OldOSEventAvail ; first find the event <SM11>
BNE.S @EventDone ; don't dequeue null or update events
MOVE.L A0,-(SP) ; save user's event record ptr
MOVE.L A1,A0 ; pointer to event queue element
LEA EventQueue,A1 ; A1 points to the queue
BSR.S DeleteEvt ; get rid of it
MOVE.L (SP)+,A0 ; restore user's event record ptr
; (needed by SMgrPostMunging)
MOVEQ #0,D0 ; exit with result code 0
; Check for ScripMgr related events and do some processing on them
movem.l a0/a2,-(sp) ; save a0/a2
GetSMgrCore a2 ; load SMgr globals.
cmpa.l #-1,a2 ; see if smgrCore is set up yet <SM10>
beq.s @tooEarly ; bail out if it isn't <SM10>
move.l smgrRecord.sVectSMgrPostMunging(a2),a2 ; get SMgrPostMunging <4/26/88ldc>
jsr (a2) ; Expects an EventPtr in a0
@tooEarly movem.l (sp)+,a0/a2 ; restore a0/a2 <SM10>
@EventDone
rts
DeleteEvt JSR DequeueTrap ; dequeue it (D0 destroyed)
MOVE #$FFFF,EvtNum+EvtOffset(A0) ; and release its storage
RTS
;_______________________________________________________________________
;
; Routine: FlushEvents b1ea
;
; Arguments: D0 (input) -- low word: events to remove (event mask)
; high word: events on which to stop (event mask)
; D0 (output) -- event type of event which terminated search
;
; Function: This routine removes events of type specified by the caller. On
; entry, D0 contains a long word of two 16-bit event masks. The
; low-order 16 bits contains a mask of events to remove, and the
; high-order 16 bits contains a mask of events that, once
; encountered, terminate the event removal process.
;
; Calling sequence: MOVE.L #EventMasks,D0
; _FlushEvents
;
; Other: uses D0,D1,D2,A0,A1
;_______________________________________________________________________
FlushEvents MOVE SR,-(SP) ; save interrupt state
MOVEM.L D3-D4,-(SP) ; preserve Pascal regs
; put a -1 into LastSPExtra (long) for the FontMGR (fixes a bug when under Switcher).
MOVEQ #-1,D1 ; <28-Oct-85>
MOVE.L D1,LastSPExtra ; <28-Oct-85>
MOVE.L D0,D1
SWAP D1 ; mask of events to stop on
MOVE.W D0,D4 ; mask of events to remove
AND.W FlEvtMask,D4 ; only flush masked events <03Mar85>
LEA EventQueue,A1 ; A1 points to the queue
; Since PostEvent could dequeue the first element at any time, the event you
; are on may suddenly be recycled and you may end up dequeueing a different event
; or suddenly find yourself at the end of the queue when you were just at the
; beginning. By disabling interrupts during the search, this is avoided.
ORI #HiIntMask,SR ; no event-generating interrupts <C173 24Sep86>
MOVE.L QHead(A1),D3 ; get pointer to first element
BEQ.S AllFlushed ; if nothing there, we're done
FEventLoop MOVE.L D3,A0 ; get pointer into A-reg
MOVE.L QLink(A0),D3 ; save the link
MOVE EvtNum+EvtOffset(A0),D2 ; get number of current event
BTST D2,D1 ; is it in the stop mask?
BNE.S FlushStop ; if so, stop
BTST D2,D4 ; is it one to delete?
BEQ.S NoFlush ; if not, skip
BSR.S DeleteEvt ; otherwise, delete it (clobbers D0)
NoFlush TST.L D3 ; any more to do?
BNE.S FEventLoop ; if so, loop
AllFlushed MOVEQ #0,D2 ; exit with 0 result code
FlushStop MOVEM.L (SP)+,D3-D4 ; restore regs
MOVE D2,D0 ; exit with number of event we stopped
EXT.L D0 ; make result long <07Jun85>
MOVE.W (SP)+, SR ; on as our result
RTS
NewEMFunction
; b232
MoveA.L (A7)+, A1
CmpI #$1, D0
BEQ.B L13
CmpI #$2, D0
BEQ.B L14
CmpI #$3, D0
BEQ.B L15
MoveQ.L #$C, D0
DC.W $A9C9
L13 Move.L (A7)+, D0
MoveA (A7)+, A0
Move.L A1, -(A7)
Bsr GetFreeOne
Bra.B L16
L14 MoveA.L (A7)+, A0
Move.L (A7)+, D0
Move.L A1, -(A7)
Bsr OSEventAvailSkippingAndi
Not.L D0
AndI.L #$101, D0
Bra.B L16
L15 MoveA.L (A7)+, A0
Move.L (A7)+, D0
Move.L A1, -(A7)
Bsr GetOSEventSkippingAndi
Not.L D0
AndI.L #$101, D0
L16 Move.L D0, $4(A7)
Rts
END