home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Amiga ACS 1998 #6
/
amigaacscoverdisc1998-061998.iso
/
games
/
descent
/
source
/
bios
/
key1.asm
< prev
next >
Wrap
Assembly Source File
|
1998-06-08
|
31KB
|
1,069 lines
;THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
;SOFTWARE CORPORATION ("PARALLAX"). PARALLAX, IN DISTRIBUTING THE CODE TO
;END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
;ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
;IN USING, DISPLAYING, AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
;SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
;FREE PURPOSES. IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
;CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES. THE END-USER UNDERSTANDS
;AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
;COPYRIGHT 1993-1998 PARALLAX SOFTWARE CORPORATION. ALL RIGHTS RESERVED.
;
; $Source: f:/miner/source/bios/rcs/key.asm $
; $Revision: 1.20 $
; $Author: john $
; $Date: 1994/01/18 10:58:55 $
;
; Contains routines to get, buffer, and check key presses.
;
; $Log: key.asm $
; Revision 1.20 1994/01/18 10:58:55 john
; *** empty log message ***
;
; Revision 1.19 1993/12/22 13:28:40 john
; Added back changes Matt made in r1.14
;
; Revision 1.18 1993/12/22 13:18:32 john
; *** empty log message ***
;
; Revision 1.17 1993/12/20 16:48:47 john
; Put cli/sti around clear keybuffer in key_close
;
; Revision 1.16 1993/12/20 15:39:13 john
; Tried to neaten handler code... also, moved some cli's and sti's around
; trying to find bug. Made the code call key_get_milliseconds instead
; of timer_get_milliseconds, because we don't want the cli and sti
; stuff in the interrupt handler.
;
; Revision 1.15 1993/12/02 10:54:48 john
; Made the Ctrl,Shift,Alt keys buffer like all the other keys.
;
; Revision 1.14 1993/10/29 11:25:18 matt
; Made key_down_time() not accumulate time if shift,alt,ctrl down
;
; Revision 1.13 1993/10/29 10:47:00 john
; *** empty log message ***
;
; Revision 1.12 1993/10/16 19:24:16 matt
; Added new function key_clear_times() & key_clear_counts()
;
; Revision 1.11 1993/10/15 10:16:49 john
; bunch of stuff, mainly with detecting debugger.
;
; Revision 1.10 1993/10/04 13:25:57 john
; Changed the way extended keys are processed.
;
; Revision 1.9 1993/09/28 11:35:32 john
; added key_peekkey
;
; Revision 1.8 1993/09/23 18:09:23 john
; fixed bug checking for DBG
;
; Revision 1.7 1993/09/23 17:28:01 john
; made debug check look for DBG> instead of CONTROL
;
; Revision 1.6 1993/09/20 17:08:19 john
; Made so that keys pressed in debugger don't get passed through to
; the keyboard handler. I also discovered, but didn't fix a error
; (page fault) caused by jumping back and forth between the debugger
; and the program...
;
; Revision 1.5 1993/09/17 09:58:12 john
; Added checks for already installed, not installed, etc.
;
; Revision 1.4 1993/09/15 17:28:00 john
; Fixed bug in FlushBuffer that used CX before a REP instead of ECX.
;
; Revision 1.3 1993/09/08 14:48:00 john
; made getch() return an int instead of a char that has shift states, etc.
;
; Revision 1.2 1993/07/22 13:12:23 john
; fixed comment
; ,.
;
; Revision 1.1 1993/07/10 13:10:42 matt
; Initial revision
;
;
;
;***************************************************************************
;***************************************************************************
;***** *****
;***** *****
;***** K E Y . A S M *****
;***** *****
;***** Contains routines to get, buffer, and check key presses. *****
;***** *****
;***** *****
;***** PROCEDURES *****
;***** *****
;***** key_init() - Activates the keyboard package. *****
;***** key_close() - Deactivates the keyboard package. *****
;***** key_check() - Returns 1 if a buffered key is waiting. *****
;***** key_getch() - Waits for and returns a buffered keypress. *****
;***** key_flush() - Clears buffers and state array. *****
;***** key_time() - Index by scan code. Contains the time key has been *****
;***** held down. NOT DONE YET. *****
;***** *****
;***** *****
;***** VARIABLES *****
;***** *****
;***** keyd_buffer_type -Set to 0 and key_getch() always returns 0. *****
;***** Set to 1 to so that ASCII codes are returned *****
;***** by key_getch(). Set to 2 and key_getch() returns*****
;***** the buffered keyboard scan codes. *****
;***** keyd_repeat - Set to 0 to not allow repeated keys in the *****
;***** keyboard buffer. Set to 1 to allow repeats. *****
;***** keyd_pressed[] -Index by scan code. Contains 1 if key down else 0*****
;***** *****
;***** *****
;***** CONSTANTS *****
;***** *****
;***** Setting the DEBUG to 1 at compile time passes SysReq through *****
;***** to the debugger, and when the debugger is active, it will give *****
;***** the debugger any keys that are pressed. Note that this only *****
;***** works with the Watcom VIDEO debugger at this time. Setting *****
;***** DEBUG to 0 takes out all the debugging stuff. *****
;***** *****
;***************************************************************************
;***************************************************************************
DEBUG EQU 1
.386
;************************************************************************
;**************** FLAT MODEL DATA SEGMENT STUFF *************************
;************************************************************************
_DATA SEGMENT BYTE PUBLIC USE32 'DATA'
rcsid db "$Id: key.asm 1.20 1994/01/18 10:58:55 john Exp $"
PUBLIC _keyd_pressed ; Must start with a _ so C can see the variable.
_keyd_pressed db 256 dup (?)
keybuffer dw 256 dup (?) ; Use 256 so an inc wraps around
TimeKeyWentDown dd 256 dup(0)
TimeKeyHeldDown dd 256 dup(0)
NumDowns dd 256 dup(0)
NumUps dd 256 dup(0)
MyCodeSegment dw ?
PUBLIC _keyd_editor_mode
_keyd_editor_mode db 0
PUBLIC _keyd_use_bios
_keyd_use_bios db 1
PUBLIC _keyd_last_pressed
_keyd_last_pressed db 0
PUBLIC _keyd_last_released
_keyd_last_released db 0
PUBLIC _keyd_dump_key_array
_keyd_dump_key_array db 0
org_int_sel dw ?
org_int_off dd ?
interrupted_cs dw ?
interrupted_eip dd ?
keyhead db ?
keytail db ?
PUBLIC _keyd_buffer_type
PUBLIC _keyd_repeat
_keyd_buffer_type db ? ; 0=No buffer, 1=buffer ASCII, 2=buffer scans
_keyd_repeat db ?
E0Flag db 0
Installed db 0
INCLUDE KEYS.INC
_DATA ENDS
DGROUP GROUP _DATA
;************************************************************************
;**************** FLAT MODEL CODE SEGMENT STUFF *************************
;************************************************************************
_TEXT SEGMENT BYTE PUBLIC USE32 'CODE'
ASSUME ds:_DATA
ASSUME cs:_TEXT
key_get_milliseconds:
EXTERNDEF timer_get_stamp64:NEAR
push ebx
push edx
call timer_get_stamp64
; Timing in milliseconds
; Can be used for up to 1000 hours
shld edx, eax, 21 ; Keep 32+11 bits
shl eax, 21
mov ebx, 2502279823 ; 2^21*1193180/1000
div ebx
pop edx
pop ebx
ret
;************************************************************************
;************************************************************************
;***** *****
;***** K E Y _ T O _ A S C I I _ *****
;***** *****
;************************************************************************
;************************************************************************
PUBLIC key_to_ascii_
key_to_ascii_:
; EAX = scancode
push ebx
mov bl, ah
and bl, 011111110b
cmp bl, 0
jne CantDoKey
cmp al, 127
jae CantDoKey
and ah, 01b ; take away ctrl and alt codes
shl al, 1
shr eax, 1
and eax, 0ffh
mov al, byte ptr key1[eax]
pop ebx
ret
CantDoKey:
pop ebx
mov eax, 255
ret
public key_clear_times_,key_clear_counts_
;clear the array of key down times.
key_clear_times_:
cli
push eax
push ecx
push edi
xor eax,eax
mov ecx,256
lea edi,TimeKeyHeldDown
rep stosd ;clear array
pop edi
pop ecx
pop eax
sti
ret
;clear the arrays of key down counts
key_clear_counts_:
cli
push eax
push ecx
push edi
xor eax,eax
mov ecx,256
lea edi,NumDowns
rep stosd ;clear array
mov ecx,256
lea edi,NumUps
rep stosd ;clear array
pop edi
pop ecx
pop eax
sti
ret
PUBLIC key_down_time_
key_down_time_:
cli
push edx
push ecx
push ebx
mov ebx, eax
xor eax, eax
cmp _keyd_pressed[ebx], 0
je NotPressed
cmp _keyd_editor_mode, 0
je read_time
call get_modifiers ;shift,alt,ctrl?
or ah,ah
jz read_time
xor eax,eax
jmp NotPressed
read_time: mov ecx, TimeKeyWentDown[ebx*4]
call key_get_milliseconds
mov TimeKeyWentDown[ebx*4], eax
sub eax, ecx ; EAX = time held since last
NotPressed:
add eax, TimeKeyHeldDown[ebx*4]
mov TimeKeyHeldDown[ebx*4], 0
pop ebx
pop ecx
pop edx
sti
ret
PUBLIC key_down_count_
key_down_count_:
cli
push ebx
mov ebx, eax
mov eax, NumDowns[ebx*4]
mov NumDowns[ebx*4], 0
pop ebx
sti
ret
PUBLIC key_up_count_
key_up_count_:
cli
push ebx
mov ebx, eax
mov eax, NumUps[ebx*4]
mov NumUps[ebx*4], 0
pop ebx
sti
ret
;************************************************************************
;************************************************************************
;***** *****
;***** K E Y _ F L U S H *****
;***** *****
;************************************************************************
;************************************************************************
PUBLIC key_flush_
key_flush_:
cli
push eax
push ecx
push edi
mov keyhead,0
mov keytail,255
mov E0Flag, 0
; Clear the keyboard array
mov edi, offset _keyd_pressed
mov ecx, 32
mov eax,0
rep stosd
pop edi
pop ecx
pop eax
sti
ret
;************************************************************************
;************************************************************************
;***** *****
;***** K E Y _ I N I T *****
;***** *****
;************************************************************************
;************************************************************************
PUBLIC key_init_
key_init_:
push eax
push ebx
push ds
push es
;**************************************************************
;******************* INITIALIZE key QUEUE **********************
;**************************************************************
mov _keyd_buffer_type,1
mov _keyd_repeat,1
mov E0Flag, 0
; Clear the keyboard array
call key_flush_
cmp Installed, 0
jne AlreadyInstalled
;**************************************************************
;******************* SAVE OLD INT9 HANDLER ********************
;**************************************************************
mov Installed, 1
mov eax, 03509h ; DOS Get Vector 09h
int 21h ; Call DOS
mov org_int_sel, es ; Save old interrupt selector
mov org_int_off, ebx ; Save old interrupt offset
;**************************************************************
;***************** INSTALL NEW INT9 HANDLER *******************
;**************************************************************
mov eax, 02509h ; DOS Set Vector 09h
mov edx, offset key_handler ; Point DS:EDX to new handler
mov bx, cs
mov MyCodeSegment, bx
mov ds, bx
int 21h
AlreadyInstalled:
pop es
pop ds
pop ebx
pop eax
ret
;************************************************************************
;************************************************************************
;***** *****
;***** K E Y _ C L O S E _ *****
;***** *****
;************************************************************************
;************************************************************************
PUBLIC key_close_
key_close_:
push eax
push ebx
push edx
push ds
cmp Installed, 0
je @f
;**************************************************************
;***************** RESTORE OLD INT9 HANDLER *******************
;**************************************************************
mov Installed, 0
; Clear the BIOS buffer
cli
mov ebx, 041ch
mov al, byte ptr [ebx]
mov ebx, 041ah
mov byte ptr [ebx], al
sti
mov eax, 02509h ; DOS Set Vector 09h
mov edx, org_int_off
mov ds, org_int_sel
int 21h
@@: pop ds
pop edx
pop ebx
pop eax
ret
;************************************************************************
;************************************************************************
;***** *****
;***** K E Y _ C H E C K _ *****
;***** *****
;************************************************************************
;************************************************************************
PUBLIC key_checkch_ ; Must end with a _ so C can see the function.
key_checkch_:
cli
push ebx
xor eax, eax
cmp Installed, 0
je NoKey
mov bl, keytail
inc bl
cmp bl, keyhead
je Nokey
mov eax, 1
Nokey:
pop ebx
sti
ret
;************************************************************************
;************************************************************************
;***** *****
;***** K E Y _ D E B U G *****
;***** *****
;************************************************************************
;************************************************************************
PUBLIC key_debug_
key_debug_:
int 3h
ret
;************************************************************************
;************************************************************************
;***** *****
;***** K E Y _ G E T C H _ *****
;***** *****
;************************************************************************
;************************************************************************
PUBLIC key_getch_ ; Must end with a _ so C can see the function.
key_getch_:
push ebx
xor eax, eax
xor ebx, ebx
cmp Installed, 0
jne StillNoKey
pop ebx
ret
StillNoKey:
cli ; Critical section
mov bl, keytail
inc bl
cmp bl, keyhead
sti
je StillNoKey
cli ; Critical section
xor ebx, ebx
mov bl, keyhead
mov ax, word ptr keybuffer[ebx*2]
inc BYTE PTR keyhead
sti
pop ebx
ret
;************************************************************************
;************************************************************************
;***** *****
;***** K E Y _ I N K E Y _ *****
;***** *****
;************************************************************************
;************************************************************************
PUBLIC key_inkey_ ; Must end with a _ so C can see the function.
key_inkey_:
push ebx
xor eax, eax
xor ebx, ebx
cmp Installed, 0
je NoInkey
cli ; Critical section
mov bl, keytail
inc bl
cmp bl, keyhead
sti
je NoInkey
cli ; Critical section
mov bl, keyhead
mov ax, word ptr keybuffer[ebx*2]
inc BYTE PTR keyhead
sti
NoInkey:
pop ebx
ret
PUBLIC key_peekkey_ ; Must end with a _ so C can see the function.
key_peekkey_:
push ebx
xor eax, eax
xor ebx, ebx
cli ; Critical section
cmp Installed, 0
je NoPeek
mov bl, keytail
inc bl
cmp bl, keyhead
je NoPeek
mov bl, keyhead
mov ax, word ptr keybuffer[ebx*2]
NoPeek: sti
pop ebx
ret
;************************************************************************
;************************************************************************
;***** *****
;***** K E Y _ H A N D L E R *****
;***** *****
;************************************************************************
;************************************************************************
PUBLIC key_handler ; Must end with a _ so C can see the function.
key_handler:
pushfd ; Save flags in case we have to chain to original
push eax
push ebx
push ecx
push edx
push ds
mov ax, DGROUP ; Point to our data segment, since this is an
mov ds, ax ; interrupt and we don't know where we were.
mov eax, (0b0000h+76*2)
mov byte ptr [eax], '1'
IFDEF DEBUG
call CheckForDebugger
jnc @f
mov eax, 0b0000h+78*2
mov byte ptr [eax], 'D'
jmp PassToBios ; If debugger is active, then skip buffer
@@: mov eax, 0b0000h+78*2
mov byte ptr [eax], 'I'
; Clear the BIOS buffer
;**mov ebx, 041ch
;**mov al, byte ptr [ebx]
;**mov ebx, 041ah
;**mov byte ptr [ebx], al
ENDIF
xor eax, eax
xor ebx, ebx
in al, 060h ; Get scan code from keyboard
cmp al, 0E0h
jne NotE0Code
E0Code: mov E0Flag, 010000000b
jmp LeaveHandler ; If garbage key, then don't buffer it
NotE0Code: mov bl, al ; Put break bit into bl ; 0 = pressed, 1=released
and al, 01111111b ; AL = scancode
or al, E0Flag ; AL = extended scancode
mov E0Flag,0 ; clear E0 flag
cmp al, 029h
je pause_execution
shl bl, 1 ; put upper bit into carry flag
jc key_mark_released ; if upper bit of bl was set, then it was a release code
;**************************************************************
;****************** HANDLE A NEWLY PRESSED KEY ****************
;**************************************************************
;Marks the key press in EAX in the scancode array.
key_mark_pressed:
;cmp al, 0eh ; backspace
;je pause_execution
mov _keyd_last_pressed, al
; Check if the key is repeating or if it just got pressed.
cmp byte ptr _keyd_pressed[eax], 1
je AlreadyDown
;------------------------------- Code for a key pressed for the first time ------------------------
mov byte ptr _keyd_pressed[eax], 1
; Set the time
push edx
push eax
call key_get_milliseconds
mov edx, eax
pop eax
mov TimeKeyWentDown[eax*4], edx
pop edx
inc NumDowns[eax*4]
jmp BufferAX
;------------------------------- Code for a key that is already pressed ------------------------
AlreadyDown:
cmp _keyd_repeat, 0
je DoneMarkingPressed
BufferAX:
cmp _keyd_buffer_type, 0
je SkipBuffer ; Buffer = 0 means don't buffer anything.
cmp al, 0AAh ; garbage key
je SkipBuffer
call get_modifiers ;returns ah
xor ebx, ebx
mov bl, keytail
inc bl
inc bl
; If the buffer is full then don't buffer this key
cmp bl, keyhead
je SkipBuffer
dec bl
mov word ptr keybuffer[ebx*2], ax
mov keytail, bl
SkipBuffer:
;---------------------------------- Exit function -----------------------------
DoneMarkingPressed:
jmp LeaveHandler
;**************************************************************
;******************* HANDLE A RELEASED KEY ********************
;**************************************************************
; Unmarks the key press in EAX from the scancode array.
key_mark_released:
mov _keyd_last_released, al
mov byte ptr _keyd_pressed[eax], 0
inc NumUps[eax*4]
cmp _keyd_editor_mode, 0
je NotInEditorMode
push eax
xor ah,ah
call get_modifiers
or ah,ah ;check modifiers
pop eax
jnz skip_time
NotInEditorMode:
push eax
call timer_get_stamp64
; Timing in milliseconds
; Can be used for up to 1000 hours
shld edx, eax, 21 ; Keep 32+11 bits
shl eax, 21
mov ebx, 2502279823 ; 2^21*1193180/1000
div ebx
mov edx, eax
pop eax
sub edx, TimeKeyWentDown[eax*4]
add TimeKeyHeldDown[eax*4], edx
skip_time: ;**jmp LeaveHandler
;**************************************************************
;*************** FINISH UP THE KEYBOARD INTERRUPT *************
;**************************************************************
LeaveHandler:
mov eax, (0b0000h+76*2)
mov byte ptr [eax], '2'
;; cmp _keyd_dump_key_array, 0
;; je DontPassToBios
jmp PassToBios
mov ecx, 256
mov ebx, 0
showdown: mov al, _keyd_pressed[ebx]
add al, '0'
mov [ebx*2+ 0b0000h], al
inc ebx
loop showdown
mov eax, 0b0000h
mov byte ptr [ eax+(036h*2+1) ], 070h
mov byte ptr [ eax+(02Ah*2+1) ], 070h
mov byte ptr [ eax+(038h*2+1) ], 070h
mov byte ptr [ eax+(0B8h*2+1) ], 070h
mov byte ptr [ eax+(01Dh*2+1) ], 070h
mov byte ptr [ eax+(09dh*2+1) ], 070h
mov byte ptr [ eax+(0AAh*2+1) ], 07Fh
mov byte ptr [ eax+(0E0h*2+1) ], 07Fh
jmp DontPassToBios
; If in debugger, pass control to dos interrupt.
PassToBios: pop ds ; Nothing left on stack but flags
pop edx
pop ecx
pop ebx
pop eax
sub esp, 8 ; Save space for IRETD frame
push ds ; Save registers we use.
push eax
mov ax, DGROUP
mov ds, ax ; Set DS to our data segment
mov eax, org_int_off ; put original handler address
mov [esp+8], eax ; in the IRETD frame
movzx eax, org_int_sel
mov [esp+12], eax
pop eax ; Restore registers
pop ds
iretd ; Chain to previous handler
pause_execution:
in al, 61h ; Get current port 61h state
or al, 10000000b ; Turn on bit 7 to signal clear keybrd
out 61h, al ; Send to port
and al, 01111111b ; Turn off bit 7 to signal break
out 61h, al ; Send to port
mov al, 20h ; Reset interrupt controller
out 20h, al
sti ; Reenable interrupts
pop ds
pop edx ; Restore all of the saved registers.
pop ecx
pop ebx
pop eax
sub esp, 8 ; Save space for IRETD frame
push ds ; Save registers we use.
push eax
mov ax, DGROUP
mov ds, ax ; Set DS to our data segment
mov eax, org_int_off ; put original handler address
mov [esp+8], eax ; in the IRETD frame
movzx eax, org_int_sel
mov [esp+12], eax
pop eax ; Restore registers
pop ds
iretd ; Interrupt must return with IRETD
DontPassToBios:
; Resets the keyboard, PIC, restores stack, returns.
in al, 61h ; Get current port 61h state
or al, 10000000b ; Turn on bit 7 to signal clear keybrd
out 61h, al ; Send to port
and al, 01111111b ; Turn off bit 7 to signal break
out 61h, al ; Send to port
mov al, 20h ; Reset interrupt controller
out 20h, al
sti ; Reenable interrupts
pop ds
pop edx ; Restore all of the saved registers.
pop ecx
pop ebx
pop eax
popfd
iretd ; Interrupt must return with IRETD
;returns ah=bitmask of shift,ctrl,alt keys
get_modifiers: push ecx
xor ah,ah
; Check the shift keys
mov cl, _keyd_pressed[ 036h ]
or cl, _keyd_pressed[ 02ah ]
or ah, cl
; Check the alt key
mov cl, _keyd_pressed[ 038h ]
or cl, _keyd_pressed[ 0b8h ]
shl cl, 1
or ah, cl
; Check the ctrl key
mov cl, _keyd_pressed[ 01dh ]
or cl, _keyd_pressed[ 09dh ]
shl cl, 2
or ah, cl
pop ecx
ret
IFDEF DEBUG
CheckForDebugger:
; Returns CF=0 if debugger isn't active
; CF=1 if debugger is active
;*************************** DEBUG ******************************
; When we're in the VIDEO debugger, we want to pass control to
; the original interrupt. So, to tell if the debugger is active,
; I check if video page 1 is the active page since that is what
; page the debugger uses, and if that works, I check the top of
; the screen to see if the texxt "Control" is there, which should
; only be there when we're in the debugger.
push eax
;mov eax, 0462h ; Address 0462 stores BIOS current page
;cmp BYTE PTR [eax], 1
;jne NoDebuggerOnColor
;mov eax, 0b8000h+4096 ; 4096 = offset to 2nd video mem page
;cmp BYTE PTR [eax+2],'C'
;jne NoDebuggerOnColor
;cmp BYTE PTR [eax+4],'o'
;jne NoDebuggerOnColor
;cmp BYTE PTR [eax+6],'n'
;jne NoDebuggerOnColor
;cmp BYTE PTR [eax+8],'t'
;jne NoDebuggerOnColor
;cmp BYTE PTR [eax+10],'r'
;jne NoDebuggerOnColor
;cmp BYTE PTR [eax+12],'o'
;jne NoDebuggerOnColor
;cmp BYTE PTR [eax+14],'l'
;jne NoDebuggerOnColor
;jmp ActiveDebugger
;NoDebuggerOnColor:
; First, see if there is a mono debugger...
;mov eax, 0b0000h ; 4096 = offset to mono video mem
;cmp BYTE PTR [eax+2],'C'
;jne NoActiveDebugger
;cmp BYTE PTR [eax+4],'o'
;jne NoActiveDebugger
;cmp BYTE PTR [eax+6],'n'
;jne NoActiveDebugger
;cmp BYTE PTR [eax+8],'t'
;jne NoActiveDebugger
;cmp BYTE PTR [eax+10],'r'
;jne NoActiveDebugger
;cmp BYTE PTR [eax+12],'o'
;jne NoActiveDebugger
;cmp BYTE PTR [eax+14],'l'
;jne NoActiveDebugger
mov eax, 0b0000h ; 4096 = offset to mono video mem
add eax, 24*80*2
cmp BYTE PTR [eax+0],'D'
jne NextTest
cmp BYTE PTR [eax+2],'B'
jne NextTest
cmp BYTE PTR [eax+4],'G'
jne NextTest
cmp BYTE PTR [eax+6],'>'
jne NextTest
;Found DBG>, so consider debugger active:
jmp ActiveDebugger
NextTest:
cmp BYTE PTR [eax+14],'<'
jne NextTest1
cmp BYTE PTR [eax+16],'i'
jne NextTest1
cmp BYTE PTR [eax+18],'>'
jne NextTest1
cmp BYTE PTR [eax+20],' '
jne NextTest1
cmp BYTE PTR [eax+22],'-'
jne NextTest1
; Found <i> - , so consider debugger active:
jmp ActiveDebugger
NextTest1:
cmp BYTE PTR [eax+0], 200
jne NextTest2
cmp BYTE PTR [eax+2], 27
jne NextTest2
cmp BYTE PTR [eax+4], 17
jne NextTest2
; Found either the help screen or view screen, so consider
; debugger active
jmp ActiveDebugger
NextTest2:
; Now we see if its active by looking for the "Executing..."
; text on the bottom of the mono screen
;mov eax, 0b0000h ; 4096 = offset to mono video mem
;add eax, 24*80*2
;cmp BYTE PTR [eax+0],'E'
;je NoActiveDebugger
;cmp BYTE PTR [eax+2],'x'
;je NoActiveDebugger
;cmp BYTE PTR [eax+4],'e'
;je NoActiveDebugger
;cmp BYTE PTR [eax+6],'c'
;je NoActiveDebugger
NoActiveDebugger:
pop eax
clc
ret
ActiveDebugger:
pop eax
stc
ret
ENDIF
_TEXT ENDS
END