| /drivers/imports.inc |
|---|
| 0,0 → 1,151 |
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| ;; ;; |
| ;; Copyright (C) KolibriOS team 2004-2007. All rights reserved. ;; |
| ;; Distributed under terms of the GNU General Public License ;; |
| ;; ;; |
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; |
| ; all exported kernel functions and data |
| if used RegService |
| extrn RegService |
| end if |
| if used GetService |
| extrn GetService |
| end if |
| if used ServiceHandler |
| extrn ServiceHandler |
| end if |
| if used AttachIntHandler |
| extrn AttachIntHandler |
| end if |
| if used FpuSave |
| extrn FpuSave |
| end if |
| if used FpuRestore |
| extrn FpuRestore |
| end if |
| if used PciApi |
| extrn PciApi |
| end if |
| if used PciRead32 |
| extrn PciRead32 |
| end if |
| if used PciRead8 |
| extrn PciRead8 |
| end if |
| if used PciWrite8 |
| extrn PciWrite8 |
| end if |
| if used AllocPage |
| extrn AllocPage |
| end if |
| if used AllocPages |
| extrn AllocPages |
| end if |
| if used FreePage |
| extrn FreePage |
| end if |
| if used MapPage |
| extrn MapPage |
| end if |
| if used MapSpace |
| extrn MapSpace |
| end if |
| if used GetPgAddr |
| extrn GetPgAddr |
| end if |
| if used CommitPages |
| extrn CommitPages |
| end if |
| if used ReleasePages |
| extrn ReleasePages |
| end if |
| if used AllocKernelSpace |
| extrn AllocKernelSpace |
| end if |
| if used FreeKernelSpace |
| extrn FreeKernelSpace |
| end if |
| if used KernelAlloc |
| extrn KernelAlloc |
| end if |
| if used KernelFree |
| extrn KernelFree |
| end if |
| if used UserAlloc |
| extrn UserAlloc |
| end if |
| if used UserFree |
| extrn UserFree |
| end if |
| if used Kmalloc |
| extrn Kmalloc |
| end if |
| if used Kfree |
| extrn Kfree |
| end if |
| if used CreateObject |
| extrn CreateObject |
| end if |
| if used DestroyObject |
| extrn DestroyObject |
| end if |
| if used CreateEvent |
| extrn CreateEvent |
| end if |
| if used RaiseEvent |
| extrn RaiseEvent |
| end if |
| if used WaitEvent |
| extrn WaitEvent |
| end if |
| if used DestroyEvent |
| extrn DestroyEvent |
| end if |
| if used ClearEvent |
| extrn ClearEvent |
| end if |
| if used LoadCursor |
| extrn LoadCursor |
| end if |
| if used SetHwCursor |
| extrn SetHwCursor |
| end if |
| if used HwCursorRestore |
| extrn HwCursorRestore |
| end if |
| if used HwCursorCreate |
| extrn HwCursorCreate |
| end if |
| if used SysMsgBoardStr |
| extrn SysMsgBoardStr |
| end if |
| if used GetCurrentTask |
| extrn GetCurrentTask |
| end if |
| if used LoadFile |
| extrn LoadFile |
| end if |
| if used SendEvent |
| extrn SendEvent |
| end if |
| if used SetMouseData |
| extrn SetMouseData |
| end if |
| if used Sleep |
| extrn Sleep |
| end if |
| if used GetTimerTicks |
| extrn GetTimerTicks |
| end if |
| if used LFBAddress |
| extrn LFBAddress |
| end if |
| /drivers/mouse/ps2mouse4d/trunk/ps2m_iofuncs.inc |
|---|
| 0,0 → 1,141 |
| kbd_read: |
| push ecx edx |
| mov ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's |
| kr_loop: |
| in al,0x64 |
| test al,1 |
| jnz kr_ready |
| loop kr_loop |
| mov ah,1 |
| jmp kr_exit |
| kr_ready: |
| push ecx |
| mov ecx,32 |
| kr_delay: |
| loop kr_delay |
| pop ecx |
| in al,0x60 |
| xor ah,ah |
| kr_exit: |
| pop edx ecx |
| ret |
| kbd_write: |
| push ecx edx |
| mov dl,al |
| in al,0x60 |
| mov ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's |
| kw_loop: |
| in al,0x64 |
| test al,2 |
| jz kw_ok |
| loop kw_loop |
| mov ah,1 |
| jmp kw_exit |
| kw_ok: |
| mov al,dl |
| out 0x60,al |
| mov ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's |
| kw_loop3: |
| in al,0x64 |
| test al,2 |
| jz kw_ok3 |
| loop kw_loop3 |
| mov ah,1 |
| jmp kw_exit |
| kw_ok3: |
| mov ah,8 |
| kw_loop4: |
| mov ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's |
| kw_loop5: |
| in al,0x64 |
| test al,1 |
| jnz kw_ok4 |
| loop kw_loop5 |
| dec ah |
| jnz kw_loop4 |
| kw_ok4: |
| xor ah,ah |
| kw_exit: |
| pop edx ecx |
| ret |
| kbd_cmd: |
| mov ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's |
| c_wait: |
| in al,0x64 |
| test al,2 |
| jz c_send |
| loop c_wait |
| jmp c_error |
| c_send: |
| mov al,bl |
| out 0x64,al |
| mov ecx,0x1ffff ; last 0xffff, new value in view of fast CPU's |
| c_accept: |
| in al,0x64 |
| test al,2 |
| jz c_ok |
| loop c_accept |
| c_error: |
| mov ah,1 |
| jmp c_exit |
| c_ok: |
| xor ah,ah |
| c_exit: |
| ret |
| mouse_cmd: |
| mov [mouse_cmd_byte], al |
| mov [mouse_nr_resends], 5 |
| .resend: |
| mov bl, 0xd4 |
| call kbd_cmd |
| cmp ah,1 |
| je .fail |
| mov al, [mouse_cmd_byte] |
| call kbd_write |
| cmp ah, 1 |
| je .fail |
| call mouse_read |
| cmp al, 0xFA |
| jne .noack |
| clc |
| ret |
| .noack: |
| cmp al, 0xFE ; resend |
| jne .noresend |
| dec [mouse_nr_resends] |
| jnz .resend |
| .noresend: |
| .fail: |
| stc |
| ret |
| mouse_read: |
| mov [mouse_nr_tries], 100 |
| .repeat: |
| call kbd_read |
| cmp ah, 1 |
| jne .fin |
| mov esi, 10 |
| call Sleep |
| dec [mouse_nr_tries] |
| jnz .repeat |
| stc |
| ret |
| .fin: |
| clc |
| ret |
| /drivers/mouse/ps2mouse4d/trunk/ps2m_irqh.inc |
|---|
| 0,0 → 1,135 |
| ;************************************** |
| ;* IRQ HANDLER FOR PS/2 MOUSE * |
| ;************************************** |
| proc irq_handler |
| call Wait8042BufferEmpty ;clear buffer |
| in al,0x60 ;get scan-code |
| cmp [mouse_byte],0 |
| je .byte1 |
| cmp [mouse_byte],1 |
| je .byte2 |
| cmp [mouse_byte],2 |
| je .byte3 |
| cmp [mouse_byte],3 |
| je .byte4 |
| jmp .error |
| .byte1: |
| test al,1000b ;first byte? |
| jz .error |
| mov [first_byte],al |
| inc [mouse_byte] |
| jmp .exit |
| .byte2: |
| mov [second_byte],al |
| inc [mouse_byte] |
| jmp .exit |
| .byte3: |
| mov [third_byte],al |
| cmp [MouseType],MT_3B |
| je .full_packet |
| inc [mouse_byte] |
| jmp .exit |
| .byte4: |
| mov [fourth_byte],al |
| .full_packet: |
| mov [mouse_byte],0 |
| mov al,byte [first_byte] |
| and eax,7 |
| mov byte [ButtonState],al |
| cmp [MouseType],MT_3B |
| je .xy_moving |
| mov al,[fourth_byte] |
| cmp [MouseType],MT_3BScroll |
| je .z_moving |
| mov ah,al |
| and ah,00110000b |
| shr ah,1 |
| or byte [ButtonState],ah |
| and al,00001111b |
| bt eax,3 |
| jnc .z_moving |
| or al,11110000b |
| .z_moving: |
| movsx eax,al |
| mov [ZMoving],eax |
| .xy_moving: |
| mov ah,0 |
| mov al,[first_byte] |
| test al,10000b |
| jz @f |
| mov ah,0FFh |
| @@: |
| mov al,[second_byte] |
| cwde |
| mov [XMoving],eax |
| mov ah,0 |
| mov al,[first_byte] |
| test al,100000b |
| jz @f |
| mov ah,0FFh |
| @@: |
| mov al,[third_byte] |
| cwde |
| @@: |
| mov [YMoving],eax |
| mov eax,[ZMoving] |
| test eax,1 |
| jnz .vert |
| sar eax,1 |
| push eax |
| push 0 |
| jmp @f |
| .vert: |
| push 0 |
| push eax |
| @@: |
| stdcall SetMouseData, [ButtonState], [XMoving], [YMoving] |
| jmp .exit |
| .error: |
| mov [mouse_byte],0 |
| .exit: |
| ret |
| endp |
| ;*********************************************** |
| ;* Waiting for clearing I8042 buffer * |
| ;* Retutned state: * |
| ;* ZF is set - good ending, * |
| ;* ZF is cleared - time-out error. * |
| ;*********************************************** |
| Wait8042BufferEmpty: |
| push ecx |
| xor ecx,ecx |
| @@: |
| in al,64h |
| test al,00000010b |
| loopnz @b |
| pop ecx |
| ret |
| /drivers/mouse/ps2mouse4d/trunk/ps2mouse.asm |
|---|
| 0,0 → 1,268 |
| format MS COFF |
| include '../../../proc32.inc' |
| include '../../../imports.inc' |
| struc IOCTL |
| { .handle dd ? |
| .io_code dd ? |
| .input dd ? |
| .inp_size dd ? |
| .output dd ? |
| .out_size dd ? |
| } |
| virtual at 0 |
| IOCTL IOCTL |
| end virtual |
| public START |
| public version |
| DRV_ENTRY equ 1 |
| DRV_EXIT equ -1 |
| MT_3B equ 0 |
| MT_3BScroll equ 3 |
| MT_5BScroll equ 4 |
| PS2_DRV_VER equ 1 |
| section '.flat' code readable align 16 |
| proc START stdcall, state:dword |
| cmp [state], DRV_ENTRY |
| jne .fin |
| .init: |
| call detect_mouse |
| test eax,eax |
| jnz .exit |
| mov [MouseType],MT_3B |
| call try_mode_ID3 |
| test eax,eax |
| jnz .stop_try |
| mov [MouseType],MT_3BScroll |
| call try_mode_ID4 |
| test eax,eax |
| jnz .stop_try |
| mov [MouseType],MT_5BScroll |
| .stop_try: |
| mov bl, 0x20 ; read command byte |
| call kbd_cmd |
| cmp ah,1 |
| je .exit |
| call kbd_read |
| cmp ah,1 |
| je .exit |
| or al, 10b |
| push eax |
| mov bl, 0x60 ; write command byte |
| call kbd_cmd |
| cmp ah,1 |
| je .exit |
| pop eax |
| call kbd_write |
| cmp ah,1 |
| je .exit |
| mov al, 0xF4 ; enable data reporting |
| call mouse_cmd |
| mov bl, 0xAE ; enable keyboard interface |
| call kbd_cmd |
| stdcall AttachIntHandler, 12, irq_handler |
| stdcall RegService, my_service, service_proc |
| ret |
| .fin: |
| ;stdcall DetachIntHandler, 12, irq_handler |
| mov bl, 0xA7 ; disable mouse interface |
| call kbd_cmd |
| xor eax, eax |
| ret |
| .exit: |
| mov bl, 0xA7 ; disable mouse interface |
| call kbd_cmd |
| mov bl, 0xAE ; enable keyboard interface |
| call kbd_cmd |
| xor eax, eax |
| ret |
| endp |
| proc service_proc stdcall, ioctl:dword |
| mov edi, [ioctl] |
| mov eax, [edi+IOCTL.io_code] |
| test eax, eax |
| jz .getversion |
| cmp eax,1 |
| jz .gettype |
| .err: |
| or eax, -1 |
| ret |
| .ok: |
| xor eax, eax |
| ret |
| .getversion: |
| cmp [edi+IOCTL.out_size], 4 |
| jb .err |
| mov edi, [edi+IOCTL.output] |
| mov dword [edi], PS2_DRV_VER ; version of driver |
| jmp .ok |
| .gettype: |
| cmp [edi+IOCTL.out_size], 4 |
| jb .err |
| mov edi, [edi+IOCTL.output] |
| mov eax,[MouseType] |
| mov dword [edi], eax ; mouse type |
| jmp .ok |
| endp |
| detect_mouse: |
| mov bl, 0xAD ; disable keyboard interface |
| call kbd_cmd |
| cmp ah,1 |
| je .fail |
| mov bl, 0xA8 ; enable mouse interface |
| call kbd_cmd |
| cmp ah,1 |
| je .fail |
| mov al, 0xFF ; reset |
| call mouse_cmd |
| jc .fail |
| call mouse_read |
| jc .fail |
| cmp al, 0xAA |
| jne .fail ; dead mouse |
| ; get device ID |
| call mouse_read |
| jc .fail |
| cmp al, 0x00 |
| jne .fail ; unknown device |
| xor eax,eax |
| ret |
| .fail: |
| or eax,-1 |
| ret |
| try_mode_ID3: |
| mov al, 0xF3 ;Set Sample Rate |
| call mouse_cmd |
| jc .fail |
| mov al, 0xC8 ;200d |
| call mouse_cmd |
| jc .fail |
| mov al, 0xF3 ;Set Sample Rate |
| call mouse_cmd |
| jc .fail |
| mov al, 0x64 ;100d |
| call mouse_cmd |
| jc .fail |
| mov al, 0xF3 ;Set Sample Rate |
| call mouse_cmd |
| jc .fail |
| mov al, 0x50 ;80d |
| call mouse_cmd |
| jc .fail |
| mov al, 0xF2 ;Get device id |
| call mouse_cmd |
| jc .fail |
| call mouse_read |
| jc .fail |
| cmp al, 0x03 |
| jne .fail |
| xor eax,eax |
| ret |
| .fail: |
| or eax,-1 |
| ret |
| try_mode_ID4: |
| mov al, 0xF3 ;Set Sample Rate |
| call mouse_cmd |
| jc .fail |
| mov al, 0xC8 ;200d |
| call mouse_cmd |
| jc .fail |
| mov al, 0xF3 ;Set Sample Rate |
| call mouse_cmd |
| jc .fail |
| mov al, 0xC8 ;100d |
| call mouse_cmd |
| jc .fail |
| mov al, 0xF3 ;Set Sample Rate |
| call mouse_cmd |
| jc .fail |
| mov al, 0x50 ;80d |
| call mouse_cmd |
| jc .fail |
| mov al, 0xF2 ;Get device id |
| call mouse_cmd |
| jc .fail |
| call mouse_read |
| jc .fail |
| cmp al, 0x04 |
| jne .fail |
| xor eax,eax |
| ret |
| .fail: |
| or eax,-1 |
| ret |
| include 'ps2m_iofuncs.inc' |
| include 'ps2m_irqh.inc' |
| section '.data' data readable writable align 16 |
| version dd 0x00050005 |
| my_service db 'ps2mouse',0 |
| ;iofuncs data |
| mouse_cmd_byte db 0 |
| mouse_nr_tries db 0 |
| mouse_nr_resends db 0 |
| ;hid data |
| mouse_byte dd 0 |
| first_byte db 0 |
| second_byte db 0 |
| third_byte db 0 |
| fourth_byte db 0 |
| ;main data |
| MouseType dd 0 |
| XMoving dd 0 |
| YMoving dd 0 |
| ZMoving dd 0 |
| ButtonState dd 0 |
| ;timerTicks dd 0 |
| /drivers/proc32.inc |
|---|
| 0,0 → 1,268 |
| ; Macroinstructions for defining and calling procedures |
| macro stdcall proc,[arg] ; directly call STDCALL procedure |
| { common |
| if ~ arg eq |
| reverse |
| pushd arg |
| common |
| end if |
| call proc } |
| macro invoke proc,[arg] ; indirectly call STDCALL procedure |
| { common |
| if ~ arg eq |
| reverse |
| pushd arg |
| common |
| end if |
| call [proc] } |
| macro ccall proc,[arg] ; directly call CDECL procedure |
| { common |
| size@ccall = 0 |
| if ~ arg eq |
| reverse |
| pushd arg |
| size@ccall = size@ccall+4 |
| common |
| end if |
| call proc |
| if size@ccall |
| add esp,size@ccall |
| end if } |
| macro cinvoke proc,[arg] ; indirectly call CDECL procedure |
| { common |
| size@ccall = 0 |
| if ~ arg eq |
| reverse |
| pushd arg |
| size@ccall = size@ccall+4 |
| common |
| end if |
| call [proc] |
| if size@ccall |
| add esp,size@ccall |
| end if } |
| macro proc [args] ; define procedure |
| { common |
| match name params, args> |
| \{ define@proc name,<params \} } |
| prologue@proc equ prologuedef |
| macro prologuedef procname,flag,parmbytes,localbytes,reglist |
| { if parmbytes | localbytes |
| push ebp |
| mov ebp,esp |
| if localbytes |
| sub esp,localbytes |
| end if |
| end if |
| irps reg, reglist \{ push reg \} } |
| epilogue@proc equ epiloguedef |
| macro epiloguedef procname,flag,parmbytes,localbytes,reglist |
| { irps reg, reglist \{ reverse pop reg \} |
| if parmbytes | localbytes |
| leave |
| end if |
| if (flag and 10000b) | (parmbytes=0) |
| retn |
| else |
| retn parmbytes |
| end if } |
| macro define@proc name,statement |
| { local params,flag,regs,parmbytes,localbytes,current |
| if used name |
| name: |
| match =stdcall args, statement \{ params equ args |
| flag = 11b \} |
| match =stdcall, statement \{ params equ |
| flag = 11b \} |
| match =c args, statement \{ params equ args |
| flag = 10001b \} |
| match =c, statement \{ params equ |
| flag = 10001b \} |
| match =params, params \{ params equ statement |
| flag = 0 \} |
| virtual at ebp+8 |
| match =uses reglist=,args, params \{ regs equ reglist |
| params equ args \} |
| match =regs =uses reglist, regs params \{ regs equ reglist |
| params equ \} |
| match =regs, regs \{ regs equ \} |
| match =,args, params \{ defargs@proc args \} |
| match =args@proc args, args@proc params \{ defargs@proc args \} |
| parmbytes = $ - (ebp+8) |
| end virtual |
| name # % = parmbytes/4 |
| all@vars equ |
| current = 0 |
| match prologue:reglist, prologue@proc:<regs> \{ prologue name,flag,parmbytes,localbytes,reglist \} |
| macro locals |
| \{ virtual at ebp-localbytes+current |
| macro label . \\{ deflocal@proc .,:, \\} |
| struc db [val] \\{ \common deflocal@proc .,db,val \\} |
| struc dw [val] \\{ \common deflocal@proc .,dw,val \\} |
| struc dp [val] \\{ \common deflocal@proc .,dp,val \\} |
| struc dd [val] \\{ \common deflocal@proc .,dd,val \\} |
| struc dt [val] \\{ \common deflocal@proc .,dt,val \\} |
| struc dq [val] \\{ \common deflocal@proc .,dq,val \\} |
| struc rb cnt \\{ deflocal@proc .,rb cnt, \\} |
| struc rw cnt \\{ deflocal@proc .,rw cnt, \\} |
| struc rp cnt \\{ deflocal@proc .,rp cnt, \\} |
| struc rd cnt \\{ deflocal@proc .,rd cnt, \\} |
| struc rt cnt \\{ deflocal@proc .,rt cnt, \\} |
| struc rq cnt \\{ deflocal@proc .,rq cnt, \\} \} |
| macro endl |
| \{ purge label |
| restruc db,dw,dp,dd,dt,dq |
| restruc rb,rw,rp,rd,rt,rq |
| restruc byte,word,dword,pword,tword,qword |
| current = $-(ebp-localbytes) |
| end virtual \} |
| macro ret operand |
| \{ match any, operand \\{ retn operand \\} |
| match , operand \\{ match epilogue:reglist, epilogue@proc:<regs> |
| \\\{ epilogue name,flag,parmbytes,localbytes,reglist \\\} \\} \} |
| macro finish@proc \{ localbytes = (((current-1) shr 2)+1) shl 2 |
| end if \} } |
| macro defargs@proc [arg] |
| { common |
| if ~ arg eq |
| forward |
| local ..arg,current@arg |
| match argname:type, arg |
| \{ current@arg equ argname |
| label ..arg type |
| argname equ ..arg |
| if dqword eq type |
| dd ?,?,?,? |
| else if tbyte eq type |
| dd ?,?,? |
| else if qword eq type | pword eq type |
| dd ?,? |
| else |
| dd ? |
| end if \} |
| match =current@arg,current@arg |
| \{ current@arg equ arg |
| arg equ ..arg |
| ..arg dd ? \} |
| common |
| args@proc equ current@arg |
| forward |
| restore current@arg |
| common |
| end if } |
| macro deflocal@proc name,def,[val] |
| { common |
| match vars, all@vars \{ all@vars equ all@vars, \} |
| all@vars equ all@vars name |
| forward |
| local ..var,..tmp |
| ..var def val |
| match =?, val \{ ..tmp equ \} |
| match any =dup (=?), val \{ ..tmp equ \} |
| match tmp : value, ..tmp : val |
| \{ tmp: end virtual |
| initlocal@proc ..var,def value |
| virtual at tmp\} |
| common |
| match first rest, ..var, \{ name equ first \} } |
| macro initlocal@proc name,def |
| { virtual at name |
| def |
| size@initlocal = $ - name |
| end virtual |
| position@initlocal = 0 |
| while size@initlocal > position@initlocal |
| virtual at name |
| def |
| if size@initlocal - position@initlocal < 2 |
| current@initlocal = 1 |
| load byte@initlocal byte from name+position@initlocal |
| else if size@initlocal - position@initlocal < 4 |
| current@initlocal = 2 |
| load word@initlocal word from name+position@initlocal |
| else |
| current@initlocal = 4 |
| load dword@initlocal dword from name+position@initlocal |
| end if |
| end virtual |
| if current@initlocal = 1 |
| mov byte [name+position@initlocal],byte@initlocal |
| else if current@initlocal = 2 |
| mov word [name+position@initlocal],word@initlocal |
| else |
| mov dword [name+position@initlocal],dword@initlocal |
| end if |
| position@initlocal = position@initlocal + current@initlocal |
| end while } |
| macro endp |
| { purge ret,locals,endl |
| finish@proc |
| purge finish@proc |
| restore regs@proc |
| match all,args@proc \{ restore all \} |
| restore args@proc |
| match all,all@vars \{ restore all \} } |
| macro local [var] |
| { common |
| locals |
| forward done@local equ |
| match varname[count]:vartype, var |
| \{ match =BYTE, vartype \\{ varname rb count |
| restore done@local \\} |
| match =WORD, vartype \\{ varname rw count |
| restore done@local \\} |
| match =DWORD, vartype \\{ varname rd count |
| restore done@local \\} |
| match =PWORD, vartype \\{ varname rp count |
| restore done@local \\} |
| match =QWORD, vartype \\{ varname rq count |
| restore done@local \\} |
| match =TBYTE, vartype \\{ varname rt count |
| restore done@local \\} |
| match =DQWORD, vartype \\{ label varname dqword |
| rq count+count |
| restore done@local \\} |
| match , done@local \\{ virtual |
| varname vartype |
| end virtual |
| rb count*sizeof.\#vartype |
| restore done@local \\} \} |
| match :varname:vartype, done@local:var |
| \{ match =BYTE, vartype \\{ varname db ? |
| restore done@local \\} |
| match =WORD, vartype \\{ varname dw ? |
| restore done@local \\} |
| match =DWORD, vartype \\{ varname dd ? |
| restore done@local \\} |
| match =PWORD, vartype \\{ varname dp ? |
| restore done@local \\} |
| match =QWORD, vartype \\{ varname dq ? |
| restore done@local \\} |
| match =TBYTE, vartype \\{ varname dt ? |
| restore done@local \\} |
| match =DQWORD, vartype \\{ label varname dqword |
| dq ?,? |
| restore done@local \\} |
| match , done@local \\{ varname vartype |
| restore done@local \\} \} |
| match ,done@local |
| \{ var |
| restore done@local \} |
| common |
| endl } |