You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1154 lines
34 KiB
1154 lines
34 KiB
;;;;;;;;;;;;;;;;;;;;;; START OF SOURCE FILE SPECIFICATION ;;;;;;;;;;;;;;;;;;;;
|
|
COMMENT $ HEADER
|
|
|
|
SOURCE FILE NAME: winq
|
|
|
|
DESCRIPTIVE NAME: queue management module
|
|
|
|
FUNCTION: This module contains routines for creating and
|
|
deleting queues and reading and writing messages
|
|
to queues. The circular queue data structure (struct Q
|
|
defined in user.h) consists of a header followed by a
|
|
sequence of messages
|
|
|
|
ENTRY POINTS: InitSysQ, CreateQueue, DeleteQueue, WriteMessage, ReadMessage,
|
|
FQueueNotFull, DelQEntry, UnlinkQ
|
|
$
|
|
;;;;;;;;;;;;;;;;;;;;;; END OF SOURCE FILE SPECIFICATION ;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
;% MOVEDS - NK (no change)
|
|
|
|
norasterops = 1
|
|
notext = 1
|
|
.xlist
|
|
include user.inc
|
|
.list
|
|
|
|
ExternFP <LocalAlloc, LocalFree>
|
|
|
|
createSeg _TEXT,CODE,WORD,PUBLIC,CODE
|
|
createSeg _DATA,DATA,WORD,PUBLIC,DATA,DGROUP
|
|
defgrp DGROUP,DATA
|
|
|
|
assumes cs,CODE
|
|
assumes ds,DATA
|
|
|
|
;============================================================================
|
|
|
|
sBegin DATA
|
|
|
|
ifndef WOW
|
|
ExternW idSysPeek ; id in sys queue of message being looked at.
|
|
endif
|
|
|
|
sEnd DATA
|
|
|
|
;============================================================================
|
|
|
|
ExternFP <GetSystemMsecCount>
|
|
ExternFP <GetCurrentTask>
|
|
ExternFP <SetTaskQueue>
|
|
ExternFP <GlobalAlloc, GlobalFree>
|
|
ExternFP <PostEvent>
|
|
ExternFP <PostMessage>
|
|
ExternFP <GetExeVersion>
|
|
|
|
sBegin CODE
|
|
|
|
; CS variables:
|
|
ifndef WOW ; WOW doesn't use these
|
|
ExternNP <CheckMsgFilter2>
|
|
ExternNP <CheckHwndFilter2>
|
|
ExternNP <SetWakeBit>
|
|
ExternNP <WakeSomeone>
|
|
ExternNP <SetWakeBit2>
|
|
ExternNP <SkipSysMsg>
|
|
ExternNP <PostMove>
|
|
ExternNP <HqCur2ES, HqCur2DS>
|
|
ExternFP <HqCurrent>
|
|
else
|
|
ExternFP <GetTaskQueueES>
|
|
endif ; WOW doesn't use these
|
|
|
|
ifdef WOW ; These functions stolen from winloop3.asm
|
|
|
|
;*--------------------------------------------------------------------------*
|
|
;* *
|
|
;* HqCur2ES() - *
|
|
;* *
|
|
;*--------------------------------------------------------------------------*
|
|
|
|
; Get hqCurrent in ES.
|
|
|
|
LabelNP <PUBLIC, HqCur2ES>
|
|
call GetTaskQueueES ; Another wonderful KERNEL routine
|
|
ret
|
|
|
|
;*--------------------------------------------------------------------------*
|
|
;* *
|
|
;* HqCurrent() - *
|
|
;* *
|
|
;*--------------------------------------------------------------------------*
|
|
|
|
; Get handle of current queue and return in AX.
|
|
|
|
LabelFP <PUBLIC, HqCurrent>
|
|
call HqCur2ES ; Code depends on both ES and AX
|
|
mov ax,es
|
|
or ax,ax ; Set flags
|
|
retf
|
|
|
|
endif ; WOW These functions stolen from winloop3.asm
|
|
|
|
|
|
ifndef WOW ; No InitSysQueue for WOW
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;; START OF SPECIFICATION ;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
COMMENT $ LOCAL
|
|
InitSysQueue () - Create and initialize the system queue.
|
|
|
|
LINKAGE: FAR PLM
|
|
|
|
ENTRY: WORD cQEntries - number of entries in system queue
|
|
|
|
EXIT: hSysQueue contains handle for system queue (Shared global object.)
|
|
|
|
EFFECTS: all registers modified.
|
|
|
|
INTERNAL: CreateQueue2
|
|
|
|
EXTERNAL: none
|
|
|
|
WARNINGS: none
|
|
|
|
REVISION HISTORY:
|
|
|
|
IMPLEMENTATION:
|
|
Set up register linkage for CreateQueue2 and let it do the work.
|
|
$
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;; END OF SPECIFICATION ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
cProc InitSysQueue,<PUBLIC,FAR>,<DS>
|
|
cBegin
|
|
mov ax,_INTDS
|
|
mov ds,ax
|
|
assumes ds,INTDS
|
|
mov ax,ds:[cQEntries] ; number of entries
|
|
push ax
|
|
mov ax,size INTERNALSYSMSG ; size of entry
|
|
push ax
|
|
call CreateQueue2 ; create system queue
|
|
mov ds:[hqSysQueue],ax
|
|
assumes ds,NOTHING
|
|
cEnd
|
|
endif ; No InitSysQueue for WOW
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;; START OF SPECIFICATION ;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
COMMENT $ LOCAL
|
|
CreateQueue (cMsgs) - Create a queue.
|
|
|
|
Create a queue for the currently executing task and stick its handle
|
|
in the task header and the queue list.
|
|
|
|
LINKAGE: FAR PLM
|
|
|
|
ENTRY: WORD cMsgs(parm1) - count of messages that can be stored in
|
|
queue
|
|
|
|
EXIT: ax - handle to queue (shared global object.)
|
|
|
|
Newly created queue is linked to list of queues pointed
|
|
to by hqList.
|
|
|
|
EXIT - ERROR: ax hqCurrent, hqCurrentShadow contain 0.
|
|
|
|
EFFECTS: all registers modified.
|
|
|
|
INTERNAL: CreateQueue2
|
|
|
|
EXTERNAL: SetTaskQueue
|
|
|
|
WARNINGS: Running out of memory when trying to CreateQueue will
|
|
init current queue to 0.
|
|
|
|
REVISION HISTORY:
|
|
|
|
IMPLEMENTATION:
|
|
Set up register linkage for CreateQueue2 and let it create the queue.
|
|
Then add to linked list and then SetTaskQueue(NULL, hqCreated).
|
|
$
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;; END OF SPECIFICATION ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
cProc CreateQueue,<PUBLIC, FAR>,<DS>
|
|
ParmW cMsgs
|
|
cBegin
|
|
push cMsgs
|
|
mov ax,size INTERNALMSG
|
|
push ax
|
|
call CreateQueue2
|
|
or ax,ax
|
|
jz errexit ; CreateQueue2 failed
|
|
|
|
EnterCrit
|
|
|
|
mov es,ax
|
|
push ax
|
|
mov ax,_INTDS
|
|
mov ds,ax
|
|
pop ax
|
|
assumes ds,INTDS
|
|
xchg ds:[hqList],ax ; Link us in and get old head of list
|
|
mov es:[qHqNext],ax ; store ptr to next queue
|
|
push es ; save hq for return
|
|
|
|
xor ax,ax ; SetTaskQueue(NULL, es)
|
|
push ax
|
|
push es ; push queue handle
|
|
call SetTaskQueue ; and ram it in there
|
|
pop ax ; return queue handle
|
|
|
|
LeaveCrit
|
|
assumes ds,DATA
|
|
errexit:
|
|
cEnd
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;; START OF SPECIFICATION ;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
COMMENT $ PRIVATE
|
|
CreateQueue2 (cMsgs, cbEntry) - Create a queue.
|
|
|
|
Allocate a shared global object and initialize the header for the Q
|
|
Data structure.
|
|
|
|
LINKAGE: NEAR PLM
|
|
|
|
ENTRY: WORD cMsgs(parm1) - count of messages that can be stored in
|
|
queue
|
|
|
|
WORD cbEntry(parm2) - count of bytes in single message entry.
|
|
|
|
EXIT: ax - handle to queue (shared global object.)
|
|
|
|
|
|
EXIT - ERROR: ax contains 0
|
|
|
|
EFFECTS: all registers except DI modified.
|
|
wAppVersion gets current exe version.
|
|
|
|
INTERNAL:
|
|
|
|
EXTERNAL: GlobalAlloc
|
|
|
|
WARNINGS: cbEntry better not be less than 5.
|
|
|
|
REVISION HISTORY:
|
|
|
|
IMPLEMENTATION:
|
|
Allocate a shared global object, initialize header with following
|
|
fields: Current Task, cbEntry, cMsgs,pmsgRead, pmsgWrite,
|
|
pmsgRead = pmsgWrite = rgMsg,
|
|
pmsgMax = queue size
|
|
wVersion = GetExeVersion
|
|
WakeBits = QS_SMPARAMSFREE | (SYSQ empty ? QS_INPUT : 0).
|
|
lpfnMsgFilter = cs:OldMsgFilter
|
|
$
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;; END OF SPECIFICATION ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
cProc CreateQueue2,<PUBLIC, NEAR>,<DI>
|
|
ParmW cMsgs
|
|
ParmW cbEntry
|
|
|
|
cBegin
|
|
call GetCurrentTask ; get current task
|
|
push ax ; and save it
|
|
|
|
mov ax,cMsgs
|
|
mov cx,cbEntry
|
|
mul cx
|
|
add ax,size Q - size INTERNALMSG
|
|
push ax ; save size of queue
|
|
|
|
; Alloc(GPTR, cMsgs * size INTERNALMSG + size Q)
|
|
push GPTR+GMEM_SHAREALL
|
|
push 0 ; hi word == 0
|
|
push ax
|
|
call GlobalAlloc
|
|
mov es,ax ; stick hq in es
|
|
|
|
pop cx ; pop queue size
|
|
pop bx ; and task handle
|
|
|
|
or ax,ax ; error on alloc?
|
|
jz cqexit ; yes, quit
|
|
xchg bx,ax ; get task handle into ax
|
|
|
|
cld
|
|
mov di,qHTask ; point at hTask
|
|
stosw ; store task handle
|
|
errnz qHTask-2
|
|
mov ax,cbEntry ; store size of entry
|
|
stosw
|
|
errnz qCbEntry-4
|
|
inc di ; cMsgs = 0 (cleared by alloc)
|
|
inc di
|
|
errnz qCMsgs-6
|
|
mov ax,qRgmsg
|
|
stosw ; init read/write pointers
|
|
errnz qPmsgRead-8
|
|
stosw
|
|
errnz qPmsgWrite-10
|
|
mov ax,cx ; get size of queue (ptr to end)
|
|
stosw ; and store it
|
|
errnz qPmsgMax-12
|
|
|
|
push es ; save hq
|
|
call GetExeVersion ; returns sys version in dx, app in ax
|
|
pop es
|
|
|
|
mov es:[qWVersion],ax ; set up app version number
|
|
mov es:[qWakeBits],QS_SMPARAMSFREE ; default ON flags.
|
|
mov es:[qFlags],QF_INIT ; indicate initialization is in progress
|
|
|
|
mov ax,es ; Save hq in ax.
|
|
push ax
|
|
mov ax,_INTDS
|
|
mov es,ax
|
|
pop ax
|
|
assumes es,INTDS
|
|
cmp es:[hqList],0 ; If we are the first queue and
|
|
jnz cq100 ; there is input waiting for us,
|
|
|
|
mov es:[hqCursor],ax ; Initialize this guy for WakeSomeone.
|
|
cmp es:[hqSysQueue],0 ; System queue set yet???
|
|
jz cq100 ; Nope, don't touch it
|
|
mov bx,es:[hqSysQueue] ; set the input flag.
|
|
or bx,bx
|
|
jz cq100
|
|
mov es,bx
|
|
cmp es:[qCMsgs],0 ; Any messages in the system queue?
|
|
mov es,ax
|
|
jz cq100 ; No messages.
|
|
or es:[qWakeBits],QS_INPUT ; Yes - tell the guy he has input.
|
|
|
|
cq100:
|
|
;
|
|
; Return queue handle in ax.
|
|
;
|
|
cqexit:
|
|
cEnd
|
|
|
|
;============================================================================
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;; START OF SPECIFICATION ;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
COMMENT $ LOCAL
|
|
DeleteQueue() - Remove current queue from queue list
|
|
|
|
Unlink Queue from all lists, Delete the Q global object, then wake
|
|
someone else.
|
|
|
|
LINKAGE: NEAR PLM
|
|
|
|
ENTRY:
|
|
|
|
EFFECTS: current queue is removed from queue list and object is deleted.
|
|
New task wakes up.
|
|
|
|
hqSysLock = 0
|
|
|
|
all registers modified.
|
|
|
|
INTERNAL: UnlinkQ, SetWakeBit, WakeSomeone
|
|
|
|
EXTERNAL: GlobalFree,
|
|
|
|
WARNINGS: none
|
|
|
|
REVISION HISTORY:
|
|
|
|
IMPLEMENTATION:
|
|
Unlink the queue from list of queues then unlink from all send lists.
|
|
Then set the result bit for every queue with sendmessage waiting on
|
|
this guy. Then free queue global object, and wakesomeone.
|
|
$
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;; END OF SPECIFICATION ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
cProc DeleteQueue,<PUBLIC, NEAR>, <SI>
|
|
cBegin
|
|
call HqCurrent
|
|
mov si,ax ; si = hqCurrent.
|
|
|
|
mov dx,_INTDS
|
|
push dx ; Save for later
|
|
mov ax,OFFSET hqList
|
|
push dx
|
|
push ax
|
|
push si
|
|
mov ax,qHqNext
|
|
push ax
|
|
call UnlinkQ ; UnlinkQ(lphqStart, hqCurrent, cbHqNext)
|
|
pop es ; get INTDS
|
|
jz dqexit ; if bad unlink, exit.
|
|
ifndef WOW ; WOW doesn't have most USER16 structures to worry about.
|
|
assumes es,INTDS
|
|
EnterCrit
|
|
xor bx,bx ; zero hqSysLock.
|
|
mov es:[hqSysLock],bx
|
|
mov es:[hqMouse],bx ; zero hqMouse.
|
|
mov es:[hqKeyboard],bx ; zero hqKeyboard.
|
|
mov bx,es:[hqList] ; Get the first guy in the list for
|
|
mov es:[hqCursor],bx ; hqCursor.
|
|
LeaveCrit
|
|
;
|
|
; Unlink this guy from everyone's hqSendList.
|
|
;
|
|
mov cx,es:[hqList]
|
|
assumes es,NOTHING
|
|
dq100:
|
|
mov es,cx
|
|
jcxz dq200
|
|
|
|
push es:[qHqNext]
|
|
push cx ; Unlink this queue from all send
|
|
mov ax,qHqSendList ; lists.
|
|
push ax
|
|
push si
|
|
mov ax,qHqSendNext
|
|
push ax ; UnlinkQ(lphqStart, hqUnlink, cbLink)
|
|
call UnlinkQ
|
|
|
|
pop cx ; Get the next hq.
|
|
jmps dq100
|
|
|
|
dq200:
|
|
;
|
|
; Now set the result bit of everyone waiting on a SendMsg response from
|
|
; this guy.
|
|
;
|
|
mov es,si ; es = hqCurrent.
|
|
mov cx,es:[qHqSendList]
|
|
dq300:
|
|
mov es,cx
|
|
jcxz dq400 ; Are we at the end of the list?
|
|
|
|
push es:[qHqSendNext]
|
|
|
|
xor bx,bx
|
|
mov word ptr es:[qResult],bx ; Zero out the result.
|
|
mov word ptr es:[qResult+2],bx
|
|
|
|
mov ax,QS_SMRESULT ; Tell this guy to wake up and
|
|
call SetWakeBit2 ; get the result.
|
|
|
|
pop cx
|
|
jmps dq300
|
|
|
|
endif ; WOW doesn't have most USER16 structures to worry about.
|
|
|
|
dq400:
|
|
xor ax,ax
|
|
push ax
|
|
push ax ; Set NULL queue
|
|
call SetTaskQueue ; SetTaskQueue(NULL, NULL)
|
|
|
|
push si
|
|
call GlobalFree ; throw away the queue
|
|
|
|
xor cx,cx
|
|
ifndef WOW ; No need - user32 takes care of this for WOW
|
|
call WakeSomeone ; wake someone up to process events
|
|
endif ;WOW
|
|
; if anyone jumps here, he better do it with ints enabled!
|
|
dqexit:
|
|
cEnd
|
|
|
|
|
|
ifndef WOW ; WOW doesn't ever put anything in the 16-bit Queue
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;; START OF SPECIFICATION ;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
COMMENT $ LOCAL
|
|
WriteMessage (hq, lParam, wParam, message, hwnd, dwExtra) - Write a message
|
|
to hq.
|
|
|
|
If queue not full, Write message record at pmsgWrite, then advance pmsgWrite.
|
|
SetWakeBit(hq) to tell him he has input.
|
|
|
|
LINKAGE: NEAR PLM
|
|
|
|
ENTRY: WORD hq handle to queue that gets message
|
|
DWORD lParam lParam of message
|
|
WORD wParam wParam of message
|
|
WORD message message
|
|
WORD hwnd associated window
|
|
DWORD dwExtra dwExtraMsgInfo of the message
|
|
|
|
|
|
EXIT: zero flag not set
|
|
AX = pmsgWrite
|
|
|
|
EXIT ERROR: zero flag set
|
|
|
|
EFFECTS: Write pointer (pmsgWrite) to hq advanced to next message.
|
|
QS_POSTMESSAGE set for hq.
|
|
|
|
All registers changed
|
|
|
|
INTERNAL: FQueueNotFull, SetWakeBit2
|
|
|
|
EXTERNAL: none
|
|
|
|
WARNINGS: the order of params on stack is assumed so we can do
|
|
a rep movsb
|
|
|
|
REVISION HISTORY:
|
|
|
|
IMPLEMENTATION:
|
|
Call FQueueNotFull which sets di = pmsgwrite if queue not full.
|
|
Blt message bytes to queue at di, advance the write pointer,
|
|
then SetWakeBit(hq, QS_POSTMESSAGE).
|
|
$
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;; END OF SPECIFICATION ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
cProc WriteMessage,<PUBLIC, NEAR>, <SI,DI,DS>
|
|
ParmW hq
|
|
ParmD lParam
|
|
ParmW wParam
|
|
ParmW message
|
|
ParmW hwnd
|
|
ParmD dwExtraInfo
|
|
cBegin WriteMessage
|
|
|
|
NewEnterCrit ax ; This trashes ax register
|
|
|
|
push ds ; See if queue is full.
|
|
mov ax,hq
|
|
mov ds,ax
|
|
mov es,ax
|
|
assumes ds,NOTHING
|
|
assumes es,NOTHING
|
|
call FQueueNotFull ; Z flag set if FULL.
|
|
jz pmexit
|
|
push di ; Save Message pointer.
|
|
|
|
pm30:
|
|
mov cx,ds:[qCbEntry] ; Copy message into queue.
|
|
shr cx,1
|
|
|
|
push ds
|
|
|
|
lea si,dwExtraInfo
|
|
push ss
|
|
pop ds
|
|
cld
|
|
errnz <size INTERNALSYSMSG - 7*2>
|
|
errnz msgTime-10
|
|
errnz imMsg-4
|
|
movsw
|
|
movsw
|
|
movsw
|
|
movsw
|
|
movsw ; Store away the message.
|
|
movsw
|
|
movsw
|
|
|
|
errnz <size INTERNALSYSMSG - 7*2>
|
|
errnz msgTime-10
|
|
errnz imMsg-4
|
|
sub cx,7
|
|
jcxz pm40 ; If have room, store time.
|
|
|
|
push es
|
|
call GetSystemMsecCount ; Tick count in dx:ax.
|
|
pop es
|
|
|
|
push ax
|
|
mov ax,_INTDS
|
|
mov ds,ax
|
|
pop ax
|
|
assumes ds,INTDS
|
|
stosw
|
|
mov ax,dx
|
|
stosw
|
|
|
|
sub cx,2
|
|
jcxz pm40
|
|
|
|
mov ax,word ptr ds:[ptCursor] ; If have room, store pt.
|
|
stosw
|
|
mov ax,word ptr ds:[ptCursor+2]
|
|
stosw
|
|
|
|
pm40:
|
|
pop ds
|
|
assumes ds,DATA
|
|
|
|
pop bx ; reget ptr to msg
|
|
push bx
|
|
call rtestwrap ; advance pointer
|
|
|
|
mov ds:[qPmsgWrite],bx
|
|
inc ds:[qCMsgs] ; advance count
|
|
|
|
mov ax,QS_POSTMESSAGE
|
|
call SetWakeBit2 ; Tell this guy he has input.
|
|
pm75:
|
|
pop ax ; get back message ID
|
|
pmexit:
|
|
pop ds
|
|
|
|
NewLeaveCrit dx, cx ; This trashes dx and cx registers
|
|
|
|
cEnd WriteMessage
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;; START OF SPECIFICATION ;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
COMMENT $ LOCAL
|
|
FQueueNotFull - IsQueueFull?
|
|
|
|
If queue not full, get pmsgWrite and return TRUE.
|
|
otherwise return FALSE.
|
|
|
|
LINKAGE: register
|
|
|
|
ENTRY: WORD ax - hq
|
|
|
|
EXIT: ax - non zero. zero flag clear
|
|
di - pmsgWrite (pointer to next write record.)
|
|
|
|
EXIT ERROR: ax - 0; zero flag set
|
|
|
|
EFFECTS: no other registers
|
|
|
|
INTERNAL: none
|
|
|
|
EXTERNAL: none
|
|
|
|
WARNINGS: none
|
|
|
|
REVISION HISTORY:
|
|
|
|
IMPLEMENTATION:
|
|
Advance write pointer. Error condition occurs only if
|
|
pmsgWrite == pmsgRead && cMsg != 0.
|
|
$
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;; END OF SPECIFICATION ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;
|
|
; FQueueNotFull - zero in ax and Z flag if FULL, else cMsgLeft in ax, NZ
|
|
; flag set. Returns write pointer in di.
|
|
; AX has DS on entry.
|
|
;
|
|
LabelNP <PUBLIC, FQueueNotFull>
|
|
push ds
|
|
assumes ds,NOTHING
|
|
mov ds,ax
|
|
mov di,ds:[qPmsgWrite] ; get write pointer and advance
|
|
cmp di,ds:[qPmsgRead] ; if read == write, then we're either
|
|
jnz qfNotFull
|
|
xor ax,ax
|
|
cmp ax,ds:[qCMsgs] ; cMsgs != 0 if empty
|
|
jnz qfexit ; Jump if Full.
|
|
qfNotFull:
|
|
push es
|
|
mov ax,_INTDS
|
|
mov es,ax
|
|
assumes es,INTDS
|
|
mov ax,es:[cQEntries] ; See how many messages are left.
|
|
assumes es,NOTHING
|
|
pop es
|
|
sub ax,ds:[qCMsgs] ; number of messages left
|
|
qfexit:
|
|
or ax,ax
|
|
pop ds
|
|
assumes ds,DATA
|
|
ret
|
|
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;; START OF SPECIFICATION ;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
COMMENT $ LOCAL
|
|
ReadMessage (hq, lpMsg, hwndFilter, msgMinFilter, msgMaxFilter, fRemoveMsg)
|
|
Read a message from hq.
|
|
|
|
If queue not empty, read message satisfying filter conditions from hq to *lpMsg.
|
|
|
|
LINKAGE: FAR PLM
|
|
|
|
ENTRY: WORD hq handle to queue to read from
|
|
MSG *lpMsg far pointer to message buffer
|
|
NOTE: This points to MSG struct and not INTERNALMSG.
|
|
WORD hwndFilter Window filter
|
|
WORD msgMinFilter min filter spec for message number
|
|
WORD msgMaxFilter max filter spec for message number
|
|
WORD fRemoveMsg Remove message if non-zero
|
|
|
|
EXIT: zero flag not set
|
|
ax = Non-Zero - we have a message.
|
|
ax = 0 - we don't have a message.
|
|
|
|
EXIT ERROR: zero flag set
|
|
|
|
EFFECTS: All registers trashed
|
|
QS_POSTMESSAGE wakebit cleared if no msgs left in app queue.
|
|
|
|
INTERNAL: none
|
|
|
|
EXTERNAL: none
|
|
|
|
WARNINGS:
|
|
|
|
REVISION HISTORY:
|
|
SRL - 4/12 Fixed bug where if system queue was locked by someone else,
|
|
it was being unlocked.
|
|
SRL - 4/18 Fixed journalling.
|
|
SRL - 5/4 Changed system queue journalling to call ScanSysQueue.
|
|
(which used to be called FindMsgHq. It now does all the
|
|
message enumeration).
|
|
|
|
IMPLEMENTATION:
|
|
If not quitting, look through the specified queue starting at pmsgRead
|
|
for message that matches filters. Blt message to lpmsg, advance the read
|
|
pointer. If out of queue messages, clear the input bit.
|
|
Message matches hwndFilter if hwndFilter == 0 or hwndFilter == msgHwnd.
|
|
Message matches msgMinFilter, msgMaxFilter if both are zero or
|
|
msgMinFilter <= msg <= msgMaxFilter.
|
|
|
|
$
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;; END OF SPECIFICATION ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
;
|
|
; ReadMessage(hq, lpMsg, hwndFilter, msgMinFilter, msgMaxFilter, fRemoveMsg)
|
|
;
|
|
; NOTE: lpMsg points to MSG structure and not INTERNALMSG.
|
|
;
|
|
cProc ReadMessage, <PUBLIC, FAR>, <SI, DI,DS>
|
|
ParmW hq
|
|
ParmD lpMsg
|
|
ParmW hwndFilter
|
|
ParmW msgMinFilter
|
|
ParmW msgMaxFilter
|
|
ParmW fRemoveMsg
|
|
cBegin
|
|
push hq ; set ds to queue pointer
|
|
pop ds
|
|
assumes ds,NOTHING
|
|
|
|
mov bx,fRemoveMsg ; pass this to rmquit
|
|
call rmquit ; Must we quit?
|
|
jnz rmexit ; Exit and be sure to leave the
|
|
; QS_POSTMESSAGE bit still set.
|
|
;
|
|
; Run through the queue and find a message that matches the filters.
|
|
;
|
|
rm150:
|
|
xor ax,ax
|
|
cmp ds:[qCMsgs],ax
|
|
jz rm500 ; nothing in queue: exit
|
|
|
|
mov si,ds:[qPmsgRead] ; Get current read pointer.
|
|
|
|
rm200:
|
|
call rmcheckappqueue ; Check the app queue for a message
|
|
jnz rm500 ; fitting the filters.
|
|
|
|
rm400:
|
|
call rtestwrap ; increment pointer in bx and copy to si
|
|
mov si,bx
|
|
jnz rm200 ; at end of queue if Z set
|
|
xor ax,ax ; return FALSE
|
|
rm500:
|
|
EnterCrit
|
|
cmp ds:[qCMsgs],0 ; If no messages left, and out the
|
|
jnz rm600 ; input bit.
|
|
cmp ds:[qCQuit],0 ; But only if not quitting
|
|
jnz rm600
|
|
and ds:[qWakeBits],NOT QS_POSTMESSAGE
|
|
rm600:
|
|
LeaveCrit
|
|
rmexit:
|
|
assumes es,NOTHING
|
|
assumes ds,DATA
|
|
cEnd
|
|
|
|
assumes ds,NOTHING
|
|
|
|
; bx = fRemoveMsg
|
|
rmquit:
|
|
mov ax,ds:[qCQuit] ; Are we in the middle of quiting?
|
|
or ax,ax ; if cQuit == 0, then continue
|
|
jz rmq200 ; return Z.
|
|
|
|
; dec al ; if al == 2, then send quit msg
|
|
; jnz rmq100
|
|
cmp ds:[qCMsgs],0 ; if queue not empty, don't send quit
|
|
jnz rmq200
|
|
; inc ds:[qCQuit] ; set sticky quit & send quit msg
|
|
or bx,bx
|
|
jz rmq100 ; if PM_NOREMOVE, multiple WM_QUIT's
|
|
mov ds:[qCQuit],0 ; give only one WM_QUIT(raor)
|
|
rmq100:
|
|
les bx,lpMsg
|
|
mov es:[bx].msgMessage,WM_QUIT ; send a WM_QUIT
|
|
mov es:[bx].msgHwnd,NULL ; null window handle
|
|
mov ax,ds:[qExitCode] ; stick the exit code in wParam
|
|
mov es:[bx].msgWParam,ax
|
|
or al,TRUE
|
|
ret
|
|
rmq200:
|
|
xor ax,ax
|
|
ret
|
|
;
|
|
; If the hq is an app queue, we can filter immediately.
|
|
;
|
|
rmcheckappqueue:
|
|
mov bx,ds:[si].ismMsg.msgHwnd ; see if hwnd satisfies hwndFilter
|
|
mov cx,hwndFilter
|
|
call CheckHwndFilter2
|
|
mov bx,si ; copy read ptr into bx
|
|
jz rmc200 ; bad luck - try next one
|
|
mov ax,ds:[si].ismMsg.msgMessage ; see if msgMinFilter <= msg <= msgMaxFilter
|
|
mov cx,msgMinFilter ; cx = msgMinFilter
|
|
mov dx,msgMaxFilter ; dx = msgMaxFilter
|
|
call CheckMsgFilter2 ; Z if no message.
|
|
jz rmc200
|
|
;
|
|
; We've found a message -- read it into lpMsg
|
|
;
|
|
les di,lpMsg ; get pointer to event block
|
|
mov cx,ds:[qCbEntry]
|
|
sub cx, size INTERNALMSG - size MSG
|
|
push si ; preserve ptr to ExtraMsgInfo
|
|
add si, size INTERNALMSG - size MSG
|
|
cld
|
|
rep movsb ; copy message structure & advance rd ptr
|
|
;
|
|
; save away time, id, and position of this event in queue header
|
|
;
|
|
; NOTE: this code doesn't work for the system queue, but that's ok since we
|
|
; don't use the queue's time anyway.
|
|
;
|
|
sub si,size MSG - msgTime ; point at saved time
|
|
mov di,qTimeLast ;
|
|
push ds ; copy into ES too
|
|
pop es
|
|
movsw ; copy time and position
|
|
movsw
|
|
errnz qPtLast-qTimeLast-4
|
|
movsw
|
|
movsw
|
|
mov ax,bx ; store position of msg in q header
|
|
stosw
|
|
errnz qIdLast-qPtLast-4
|
|
pop si ; Restore ptr to ExtraMsgInfo
|
|
errnz qdwExtraInfoLast-qIdLast-2
|
|
errnz <size INTERNALMSG - size MSG - 4>
|
|
movsw
|
|
movsw
|
|
|
|
cmp fRemoveMsg,0 ; are we supposed to yank the message?
|
|
jnz rmc100 ; yes: take it out
|
|
mov ds:[qIdLast],1 ; stick something random in qidLast
|
|
jmps rmc150 ; so we don't reply until it's yanked
|
|
rmc100:
|
|
call DelQEntry ; delete queue entry & update ptrs
|
|
rmc150:
|
|
mov ax,bx ; return ID value, TRUE, NZ.
|
|
or ax,ax
|
|
rmc200:
|
|
ret
|
|
|
|
assumes ds,DATA
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;; START OF SPECIFICATION ;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
COMMENT $ PRIVATE
|
|
DelQEntry - Delete a queue message entry.
|
|
|
|
Delete message entry from queue. Adjust pmsgRead, pmsgWrite
|
|
and cMsgs.
|
|
|
|
LINKAGE: register
|
|
|
|
ENTRY: WORD bx - pointer to entry to delete
|
|
WORD ds - hq
|
|
|
|
EXIT: void
|
|
|
|
EFFECTS: pmsgRead and pmsgWrite are adjusted, and part of rgMsg
|
|
is blt'ed to fill hole left by deleted message.
|
|
|
|
Trashes es, si, di
|
|
|
|
INTERNAL: none
|
|
|
|
EXTERNAL: none
|
|
|
|
WARNINGS: none
|
|
|
|
REVISION HISTORY:
|
|
|
|
IMPLEMENTATION:
|
|
disable interrupts, change cMsgs, pmsgRead, pmsgWrite, then
|
|
rep movsb from bottom up.
|
|
$
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;; END OF SPECIFICATION ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
LabelNP <PUBLIC, DelQEntry>
|
|
|
|
assumes DS,NOTHING
|
|
|
|
EnterCrit
|
|
push ds
|
|
pop es
|
|
dec ds:[qCMsgs] ; decrement count
|
|
mov ax,ds:[qCbEntry]
|
|
mov si,ds:[qPmsgRead]
|
|
mov di,ds:[qPmsgWrite]
|
|
cmp si,bx ; compare sptr to dptr
|
|
ja de500
|
|
;
|
|
; rptr < dptr: blt stuff below up
|
|
; move(rptr, rptr+1, dptr-rptr)
|
|
; rptr++;
|
|
;
|
|
std ; blt backwards
|
|
mov cx,bx ; cb = dptr-rptr
|
|
sub cx,si
|
|
mov si,bx ; src = dptr
|
|
dec si ; point at first byte to copy
|
|
mov di,si ; dest = src + size(entry)
|
|
add di,ax
|
|
rep movsb ; copy those bytes
|
|
inc di ; readjust DI
|
|
cmp di,ds:[qPmsgMax] ; update read pointer
|
|
jb de200 ; checking for wraparound
|
|
mov di,qRgmsg
|
|
de200:
|
|
mov ds:[qPmsgRead],di
|
|
cld
|
|
LeaveCrit
|
|
ret
|
|
;
|
|
; rptr > dptr: blt stuff above down
|
|
; wptr--;
|
|
; move(dptr + 1, dptr, wptr - dptr)
|
|
;
|
|
de500:
|
|
cld
|
|
mov si,bx ; src = dptr + size(entry)
|
|
add si,ax
|
|
mov cx,di ; cb = (wptr - (dptr + size(entry)))
|
|
sub cx,si
|
|
mov di,bx ; dest = dptr
|
|
rep movsb ; copy those bytes
|
|
mov ds:[qPmsgWrite],di ; update write pointer
|
|
LeaveCrit
|
|
ret
|
|
;
|
|
; increment read ptr in bx, testing for wraparound
|
|
;
|
|
LabelNP <PUBLIC, rtestwrap>
|
|
add bx,ds:[qCbEntry] ; advance pointer
|
|
cmp bx,ds:[qPmsgMax] ; wrap around if needed
|
|
jb tw50
|
|
mov bx,qRgmsg
|
|
tw50:
|
|
cmp bx,ds:[qPmsgWrite] ; set CC's if end of queue
|
|
ret
|
|
|
|
assumes ds,DATA
|
|
|
|
endif ; WOW doesn't ever put anything in the 16-bit Queue
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;; START OF SPECIFICATION ;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
COMMENT $ LOCAL
|
|
LinkQ (lphqStart, hqLink, ibLink) - Add Q to linked list.
|
|
|
|
Add new queue entry to END of linked list starting at lphqStart and
|
|
linked by ibLink. ibLink can be qHqNext or qHqSendNext.
|
|
|
|
LINKAGE: NEAR PLM
|
|
|
|
ENTRY: DWORD lphqStart (parm1) - far pointer to start of queue list
|
|
WORD hqLink (parm2) - handle of queue to be linked
|
|
WORD ibLink (parm3) - byte index to link to be used in
|
|
Q structure.
|
|
|
|
EXIT: ax contains hqLink
|
|
|
|
EFFECTS: all registers modified.
|
|
|
|
INTERNAL: none
|
|
|
|
EXTERNAL: none
|
|
|
|
WARNINGS: none
|
|
|
|
REVISION HISTORY:
|
|
|
|
IMPLEMENTATION:
|
|
Walk the linked list starting at lphqStart till hqNext is NULL indicating
|
|
end of list. Add new entry to list there.
|
|
$
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;; END OF SPECIFICATION ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
LabelNP <PUBLIC, LinkQ>
|
|
; ret = 0+2 (saved si)
|
|
; ibLink = 2+2
|
|
; hqLink = 4+2
|
|
; lpHqStart = 6+2
|
|
;
|
|
push si
|
|
mov si,sp
|
|
|
|
EnterCrit
|
|
|
|
les bx,ss:[si+8] ; Get lpHqStart
|
|
|
|
lnk100:
|
|
mov cx,word ptr es:[bx] ; Check for end of the list.
|
|
jcxz lnk200
|
|
|
|
mov es,cx ; Get Next Link.
|
|
mov bx,ss:[si+4] ; BX = ibLink.
|
|
jmps lnk100
|
|
|
|
lnk200:
|
|
mov ax,ss:[si+6] ; Store hqLink at end of list.
|
|
mov word ptr es:[bx],ax
|
|
|
|
mov es,ax ; AX = hqLink.
|
|
mov bx,ss:[si+4]
|
|
mov word ptr es:[bx],cx ; CX = 0. Zero out pNext.
|
|
|
|
LeaveCrit
|
|
pop si
|
|
ret 8
|
|
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;; START OF SPECIFICATION ;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
COMMENT $ LOCAL
|
|
UnlinkQ (lphqStart, hqLink, ibLink) - Unlink Q from list.
|
|
|
|
Unlink queue specified by hqLink from linked list starting at lphqStart and
|
|
linked by ibLink. ibLink can be qHqNext or qHqSendNext.
|
|
|
|
LINKAGE: NEAR PLM
|
|
|
|
|
|
ENTRY: DWORD lphqStart (parm1) - far pointer to start of queue list
|
|
WORD hqLink (parm2) - handle of queue to be unlinked
|
|
WORD ibLink (parm3) - byte index to link to be used in
|
|
Q structure.
|
|
|
|
EXIT: ax contains handle of unlinked queue, zero flag clear
|
|
|
|
EXIT ERROR - zero flag is set
|
|
|
|
EFFECTS: all registers modified.
|
|
|
|
INTERNAL: none
|
|
|
|
EXTERNAL: none
|
|
|
|
WARNINGS: none
|
|
|
|
REVISION HISTORY:
|
|
|
|
IMPLEMENTATION:
|
|
Walk the linked list starting at lphqStart till hqLink is found and
|
|
unlink.
|
|
$
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;; END OF SPECIFICATION ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
LabelNP <PUBLIC, UnlinkQ>
|
|
;
|
|
;
|
|
; ret = 0+2+ (pushed si)
|
|
; cbLink = 2+2
|
|
; hq = 4+2
|
|
; lpHqStart = 6+2
|
|
;
|
|
assumes ds,NOTHING
|
|
push si
|
|
mov si,sp
|
|
push di
|
|
push ds
|
|
|
|
EnterCrit
|
|
|
|
les di,ss:[si+8] ; Get lpHqStart.
|
|
mov bx,ss:[si+6] ; Get hqUnlink.
|
|
|
|
ulq100:
|
|
mov cx,es:[di] ; Exit with zero if at end of list.
|
|
jcxz ulqExit
|
|
|
|
cmp cx,bx ; Have we found the guy that points
|
|
jz ulq200 ; to hqUnlink?
|
|
|
|
mov es,cx ; Point to the next guy and continue.
|
|
mov di,ss:[si+4]
|
|
jmps ulq100
|
|
|
|
ulq200:
|
|
mov ds,bx ; Get the hq that hqUnlink points to.
|
|
mov bx,ss:[si+4]
|
|
mov bx,ds:[bx]
|
|
|
|
mov es:[di],bx ; Store in hqLinkNext of the guy
|
|
; previous to hqUnlink.
|
|
ulqExit:
|
|
LeaveCrit
|
|
|
|
or cx,cx
|
|
pop ds
|
|
pop di
|
|
pop si
|
|
ret 8
|
|
assumes DS,DATA
|
|
|
|
ifndef WOW ; WOW thunks SetMessageQueue
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;; START OF SPECIFICATION ;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
COMMENT $ LOCAL
|
|
BOOL SetMessageQueue(cMsg)
|
|
|
|
This function is available to the task that desires a larger message
|
|
queue than the default. This routine must be called from the
|
|
applications' WinMain routine as soon as possible. It must not be
|
|
called after any operation that could generate messages (such as
|
|
a CreateWindow). Any messages currently in the queue will be
|
|
destroyed. By default, the system creates a default queue with room
|
|
for 8 messages.
|
|
|
|
LINKAGE: FAR PLM
|
|
|
|
|
|
ENTRY: WORD cMsg - The size of the new queue in messages.
|
|
|
|
EXIT: ax contains:
|
|
TRUE: If new queue is sucessfully created.
|
|
FALSE: If there was an error creating the new queue. In this case,
|
|
the application has no queue associated with it (since the
|
|
origional queue is deleted first). The application MUST
|
|
call SetMessageQueue with a smaller size until a TRUE is
|
|
returned (or the application may terminate itself).
|
|
|
|
EFFECTS: SI, DI preserved.
|
|
|
|
INTERNAL: none
|
|
|
|
EXTERNAL: none
|
|
|
|
WARNINGS: none
|
|
|
|
REVISION HISTORY:
|
|
|
|
IMPLEMENTATION:
|
|
Call DeleteQueue()
|
|
Call CreateQueue(cMsg)
|
|
$
|
|
;;;;;;;;;;;;;;;;;;;;;;;;;; END OF SPECIFICATION ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
|
|
|
|
|
cProc SetMessageQueue, <PUBLIC, FAR, EXPORTED>, <SI, DI>
|
|
ParmW cMsg
|
|
cBegin
|
|
call DeleteQueue
|
|
mov ax,cMsg
|
|
push ax
|
|
call CreateQueue
|
|
cEnd
|
|
|
|
endif ; WOW thunks SetMessageQueue
|
|
|
|
sEnd CODE
|
|
end
|