;======================================================================
; HEXEDIT * 1.00 Copyright (c) 1992, Robert L. Hummel
; PC Magazine Assembly Language Lab Notes
;----------------------------------------------------------------------
CSEG SEGMENT PARA PUBLIC 'CODE'
ASSUME CS:CSEG, DS:CSEG, ES:CSEG, SS:CSEG
ORG 100H ;COM file format
ENTPT: JMP MAIN
;======================================================================
; Program data area.
;----------------------------------------------------------------------
CR EQU 13 ;ASCII carriage return
LF EQU 10 ;ASCII line feed
BLANK EQU 32 ;ASCII blank
RARROW EQU 4DH ;Move forward 1 char
DARROW EQU 50H ;Move forward 1 row
PGDN EQU 51H ;Move forward 1 screen
LARROW EQU 4BH ;Move backward 1 char
UARROW EQU 48H ;Move backward 1 row
PGUP EQU 49H ;Move backward 1 screen
F7KEY EQU 41H ;Exit the editor
F8KEY EQU 42H ;Switch between HEX and ASCII displays
;----------------------------------------------------------------------
; Messages.
;----------------------------------------------------------------------
COPYRIGHT$ DB CR,LF,"HEXEDIT 1.00 ",254," Copyright (c) 1992"
DB ", Robert L. Hummel",CR,LF
DB "PC Magazine Assembly Language Lab Notes",LF
CRLF$ DB CR,LF,"$"
USAGE$ DB "Usage: HEXEDIT [d:][path]filename.ext$"
CONFIRM$ DB "Exiting. Make changes permanent? (Y/N) $"
ERR_VIDEO$ DB "Video mode must be text, 80 or more columns$"
ERR_MEM$ DB "There's not enough memory to execute$"
ERR_DRIVE$ DB "Drive is invalid$"
ERR_FIND$ DB "Can't find the file$"
ERR_TMP$ DB "Trouble with HEXEDIT~.@@@ scratch file$"
ERR_SRC$ DB "Trouble reading/writing the file$"
ERR_REN$ DB "Can't rename file. Changes in HEXEDIT~.@@@$"
;----------------------------------------------------------------------
; File data.
;----------------------------------------------------------------------
SRC_HANDLE DW 0 ;Source file handle
SRC_NAME DW 0 ;Pointer to file name
TMP_NAMEZ DB "HEXEDIT~.@@@",0 ;Scratch file name
TMP_HANDLE DW 0 ;Scratch file handle
;----------------------------------------------------------------------
; Buffer and display window data.
;----------------------------------------------------------------------
FILE_ALTERED DB 0 ;>0 if changes were made to file
BUF_ANCHOR DD 0 ;Pos in file of 1st byte of buffer
BUF_ANCHOR_MAX DD 0 ;Furthest forward buffer can start
BUF_SIZE DW 0 ;Maximum number bytes buffer can hold
BUF_BYTES DW 0 ;# valid bytes in buffer
FULLY_BUFFERED DB 0 ;>0 if entire file fits in buffer
BUF_ALTERED DB 0 ;>0 if buffer has been altered
REDO_BUF DB 0 ;>0 if buffer has moved wrt file
GRID_ANCHOR DW 0 ;Offset into buffer of 1st dislay byte
REDO_GRID DB 0 ;Non-zero if need to redraw grid fm buf
GRIDROW DB 0 ;Current grid row
GRIDROWMAX EQU 15
GRIDCOL DB 0 ;Current grid column
GRIDCOLMAX EQU 15
GRID_LEN EQU (GRIDCOLMAX + 1)*(GRIDROWMAX+1)
LEFT EQU 0F0H ;HEX mode, left digit
RIGHT EQU 00FH ;HEX mode, right digit
MODE_MASK EQU 13H ;Tri-state mask
MODE DB 0 ;Mode, 0 = ASCII
;----------------------------------------------------------------------
; Video data.
;----------------------------------------------------------------------
ROW_0 EQU 5 ;Screen row for grid row 0
OFF_COL EQU 2 ;Starting screen column for offset
HEX_COL EQU 12 ;Starting screen column for hex display
ASC_COL EQU 61 ;Starting screen column for ASCII chars
VPAGE DB 0 ;Active video page
VATTR DB 07H ;Attribute for display (mono default)
ATTR_COLOR EQU 17H ;Attribute for color displays
VCURSOR DW 0 ;Holds row/column for screen cursor
;======================================================================
; MAIN procedure.
;----------------------------------------------------------------------
MAIN PROC NEAR
ASSUME CS:CSEG, DS:CSEG, ES:CSEG, SS:CSEG
;----------------------------------------------------------------------
; Initialize.
;----------------------------------------------------------------------
CLD ;String moves forward
MOV CL,AL ;Save drive status
;----------------------------------------------------------------------
; Check the video mode and initialize the display variables.
;----------------------------------------------------------------------
CALL VIDEO_SETUP ;Examine video hardware
MOV DX,OFFSET ERR_VIDEO$ ;Assume an error
JC M_1
;----------------------------------------------------------------------
; Make sure there's enough room for the stack and relocate it to the
; end of the code.
;----------------------------------------------------------------------
MOV DX,OFFSET ERR_MEM$ ;Assume error
MOV AX,OFFSET STACK_TOP ;We want stack here
CMP SP,AX ;Are we beyond it?
JBE M_1
CLI ;Disable interrupts
XCHG AX,SP ; and re-position stack
STI ;Allow interrupts
;----------------------------------------------------------------------
; Determine how many bytes can be allocated in the remainder of the
; segment. We must have at least 512 bytes.
;----------------------------------------------------------------------
SUB AX,SP ;Free bytes
CMP AX,512 ;Minimum allowed
JB M_1
AND AL,0FEH ;Make number even
MOV [BUF_SIZE],AX ;Save buffer size
;----------------------------------------------------------------------
; Check if an invalid drive was specified on the command line.
;----------------------------------------------------------------------
MOV DX,OFFSET ERR_DRIVE$ ;Assume an error
INC CL ;If was FF, now 00
JNZ M_2
;----------------------------------------------------------------------
; Exit the program, displaying the message passed in DX and the
; copyright notice.
;----------------------------------------------------------------------
M_1:
MOV AH,9 ;Display string
INT 21H ; thru DOS
M_EXIT:
MOV AH,9 ;Display string
MOV DX,OFFSET CRLF$ ;New line
INT 21H ; thru DOS
MOV AH,9 ;Display string fn
MOV DX,OFFSET COPYRIGHT$ ; located here
INT 21H ; thru DOS
MOV AH,4CH ;Terminate process
INT 21H ; thru DOS
;----------------------------------------------------------------------
; If no characters are in the command tail, show the usage message.
;----------------------------------------------------------------------
M_2:
MOV DX,OFFSET USAGE$ ;Assume no characters
MOV SI,80H ;Point to tail length
LODSB ;Get length in AL
OR AL,AL ;Any chars?
JZ M_1
CBW ;Change length to word
MOV DI,SI ;Starting offset
ADD DI,AX ; + length = end offset
MOV [DI],AH ;Convert to ASCIIZ
;----------------------------------------------------------------------
; Find the first non-blank char. If it's a zero, show usage message.
;----------------------------------------------------------------------
M_3A:
LODSB ;Get char in AL
CMP AL,BLANK ;Leading blank?
JE M_3A
OR AL,AL ;If 0, no chars
JZ M_1
DEC SI ;Point to 1st non-blank
MOV DI,SI ;Save it in DI
;----------------------------------------------------------------------
; Find the end of the string as indicated by a blank or the zero.
;----------------------------------------------------------------------
M_3B:
LODSB ;Get next char
OR AL,AL ;Stop if zero
JZ M_3C
CMP AL,BLANK ;Continue unless blank
JNE M_3B
M_3C:
DEC SI ;Point to last char
MOV [SI],AH ;Make ASCIIZ
MOV [SRC_NAME],DI ;Save pointer to name
;----------------------------------------------------------------------
; Attempt to open the file found on the command line.
;----------------------------------------------------------------------
MOV AX,3D00H ;Open file for reading
MOV DX,DI ;Point DS:DX to name
INT 21H ; thru DOS
MOV DX,OFFSET ERR_FIND$ ;Assume error
JC M_1
MOV [SRC_HANDLE],AX ;Save source handle
;----------------------------------------------------------------------
; Create a scratch file and copy the file over.
;----------------------------------------------------------------------
MOV AH,3CH ;Create file
SUB CX,CX ;Normal attributes
MOV DX,OFFSET TMP_NAMEZ ;This name
INT 21H ; thru DOS
MOV DX,OFFSET ERR_TMP$ ;Assume error
JC M_1
MOV [TMP_HANDLE],AX ;Save file handle
;----------------------------------------------------------------------
; Read data from the source file and write it to the destination file
; until the entire file has been copied.
;----------------------------------------------------------------------
M_4A:
MOV AH,3FH ;Read file
MOV BX,[SRC_HANDLE] ; from this handle
MOV CX,[BUF_SIZE] ; CX bytes
MOV DX,OFFSET BUFFER ;Put data here
INT 21H ; thru DOS
JNC M_4C
M_4B:
MOV DX,OFFSET ERR_SRC$ ;Error reading file
JMP M_1
M_4C:
OR AX,AX ;No bytes read?
JZ M_4F
MOV CX,AX ;Write the same #
MOV AH,40H ;Write file
MOV BX,[TMP_HANDLE] ; to this handle
INT 21H ; thru DOS
JNC M_4A
M_4D:
MOV DX,OFFSET ERR_TMP$ ;Error writing file
M_4E:
JMP M_1
M_4F:
;----------------------------------------------------------------------
; Close the source file; we won't need it again.
;----------------------------------------------------------------------
MOV AH,3EH ;Close handle fn
MOV BX,[SRC_HANDLE] ;Handle for source file
INT 21H ; thru DOS
JC M_4B
;----------------------------------------------------------------------
; Get the size of the file by seeking to the end of the file.
;----------------------------------------------------------------------
MOV AX,4202H ;Seek, offset from end
MOV BX,[TMP_HANDLE] ;Handle for the file
SUB CX,CX ;CX:DX =
SUB DX,DX ; offset from end
INT 21H ; thru DOS
JC M_4D
;----------------------------------------------------------------------
; If the number of bytes in the file is smaller or equal to the number
; of bytes the buffer can hold, all moves can be handled in the buffer.
;----------------------------------------------------------------------
MOV BX,[BUF_SIZE] ;Buffer capacity
OR DX,DX ;If not 0, file > 64k
JNZ M_5A
CMP AX,BX ;Fit in buffer?
JA M_5A
INC [FULLY_BUFFERED] ;Yes, set flag
JMP SHORT M_5B
;----------------------------------------------------------------------
; If the file is larger than the buffer, calculate the maximum buffer
; anchor value so we don't have to do it repeatedly later.
;----------------------------------------------------------------------
M_5A:
PUSH AX ;Save file length
PUSH DX ; in DX:AX
SUB AX,BX ;Figure max anchor
SBB DX,CX ;(CX is 0)
MOV WORD PTR [BUF_ANCHOR_MAX][0],AX ;Max BUF_ANCHOR
MOV WORD PTR [BUF_ANCHOR_MAX][2],DX ; position
POP DX ;Restore file length
POP AX
M_5B:
;----------------------------------------------------------------------
; Draw the graphics characters that make up the window background.
;----------------------------------------------------------------------
CALL DRAW_BKGND
;----------------------------------------------------------------------
; Invoke the editor. If it returns with the carry flag set, a file
; error was encountered. Print a message and abort the edit.
;----------------------------------------------------------------------
CALL EDIT ;Edit the file
JC M_4E
;----------------------------------------------------------------------
; Close the temporary file to commit the changes to disk.
;----------------------------------------------------------------------
MOV AH,3EH ;Close file handle
MOV BX,[TMP_HANDLE] ;This handle
INT 21H ; thru DOS
JC M_4D
;----------------------------------------------------------------------
; Clear the screen and position the cursor to the top left corner.
;----------------------------------------------------------------------
MOV AX,0700H ;Scroll window fn
MOV BH,[VATTR] ; clear to this color
SUB CX,CX ;Topleft row,col
MOV DX,(24 SHL 8 + 79) ;Lowright row,col
INT 10H ; thru BIOS
MOV AH,2 ;Position cursor
MOV BH,[VPAGE] ;On this video page
SUB DX,DX ;Row 0, col 0
INT 10H ; thru BIOS
;----------------------------------------------------------------------
; If changes were made to the file, ask if they should be permanent.
;----------------------------------------------------------------------
CMP [FILE_ALTERED],0 ;Flag 0 if no changes
JE M_7
MOV AH,9 ;Display string fn
MOV DX,OFFSET CONFIRM$ ;Make permanent?
INT 21H ; thru DOS
M_6:
MOV AH,8 ;Get a key
INT 21H ; thru DOS
AND AL,NOT 20H ;Capitalize it
CMP AL,"Y" ;If Yes, jump
JE M_8A
CMP AL,"N" ;If not No, try again
JNE M_6
;----------------------------------------------------------------------
; Don't save the changes, just delete the temporary file and exit.
;----------------------------------------------------------------------
M_7:
MOV AH,41H ;Delete file handle
MOV DX,OFFSET TMP_NAMEZ ;This name
INT 21H ; thru DOS
JNC M_8D
JMP M_4D
;----------------------------------------------------------------------
; Make the changes permanent. Delete the original file. If the original
; file can't be renamed, leave the temporary file intact.
;----------------------------------------------------------------------
M_8A:
MOV AH,41H ;Delete file handle
MOV DX,[SRC_NAME] ;This name
INT 21H ; thru DOS
JNC M_8C
M_8B:
MOV AH,9 ;Display string fn
MOV DX,OFFSET CRLF$ ;Go to new line
INT 21H ; thru DOS
MOV DX,OFFSET ERR_REN$ ;Renaming error
JMP M_1
;----------------------------------------------------------------------
; Rename the temp file to the original name.
;----------------------------------------------------------------------
M_8C:
MOV AH,56H ;Rename file
MOV DX,OFFSET TMP_NAMEZ ;Old name at DS:DX
MOV DI,[SRC_NAME] ;New name at ES:DI
INT 21H ; thru DOS
JC M_8B
M_8D:
JMP M_EXIT
MAIN ENDP
;======================================================================
; VIDEO_SETUP (Near)
;
; This procedure ensures that we're in a text mode and that the number
; of columns on the screen is 80 or greater and gets the current video
; page. It also adjusts the screen attribute for monochrome screens. It
; will allow the program to run in graphics mode, but won't guarantee a
; pretty screen. Return with carry set if display is in an incompatible
; mode.
;----------------------------------------------------------------------
; Entry: None
; Exit:
; NC = Video mode and screen size is okay
; CY = Can't use this video mode or not enough columns
;----------------------------------------------------------------------
; Changes: AX BX
;----------------------------------------------------------------------
VIDEO_SETUP PROC NEAR
ASSUME CS:CSEG, DS:CSEG, ES:NOTHING, SS:CSEG
MOV AH,0FH ;Get video mode
INT 10H ; thru BIOS
;----------------------------------------------------------------------
; Now make sure we're in a text mode.
;----------------------------------------------------------------------
CMP AL,7 ;7 = monochrome
JE VS_1
MOV [VATTR],ATTR_COLOR ;Assume color mode
CMP AL,4 ;Carry clear if NG
JNB VS_2
VS_1:
;----------------------------------------------------------------------
; Make sure there are at least 80 columns.
;----------------------------------------------------------------------
CMP AH,80 ;Enough columns?
JB VS_EXIT ;JB=JC=carry set
MOV [VPAGE],BH ;Save current page
STC ;Set carry...
VS_2:
CMC ;...then reverse it
VS_EXIT:
RET
VIDEO_SETUP ENDP
;======================================================================
; DRAW_BKGND (Near)
;
; Clear the screen and draw the framework for the editing window.
;----------------------------------------------------------------------
; Entry: None
; Exit : None
;----------------------------------------------------------------------
; Changes: AX BX CX DX SI
;----------------------------------------------------------------------
TITLE$ DB "HEXEDIT 1.00 ",254," PC Magazine Assembly "
DB "Language Lab Notes ",254," Robert L. Hummel$"
TITLE_LEN EQU $-OFFSET TITLE$
HELP$ DB "Editing Keys: ",27,32,32,26,32,32,24,32,32,25
DB " PgUp PgDn F7 = Save/Abort F8=Hex/ASCII$"
HELP_LEN EQU $-OFFSET HELP$
OFFSET$ DB "OFFSET$"
OFFSET_POS EQU 0303H
HEX$ DB "HEX DATA$"
HEX_POS EQU 0320H
ASCII$ DB "ASCII DATA$"
ASCII_POS EQU 0340H
WIN_CHARS DB 1,201,205,205,187
DB 1,186, 32, 32,186
DB 1,199,196,194,182
DB 18,186, 32,179,186
DB 1,199,196,193,182
DB 2,186, 32, 32,186
DB 1,200,205,205,188
DB -1
DRAW_BKGND PROC NEAR
ASSUME CS:CSEG, DS:CSEG, ES:NOTHING, SS:CSEG
;----------------------------------------------------------------------
; Clear the box area to set the attribute for the characters.
;----------------------------------------------------------------------
MOV AX,0700H ;Scroll window fn
MOV BH,[VATTR] ;Clear to this color
SUB CX,CX ;Topleft row,col
MOV DX,(24 SHL 8 + 79) ;Lowright row,col
INT 10H ; thru BIOS
;----------------------------------------------------------------------
; Prepare to draw the screen.
;----------------------------------------------------------------------
MOV BH,[VPAGE] ;Get active page
MOV SI,OFFSET WIN_CHARS ;Point to array
SUB DH,DH ;Starting row = 0
;----------------------------------------------------------------------
; The first byte indicates how many rows to draw with this set of
; characters. If -1, we're done.
;----------------------------------------------------------------------
DB_1:
LODSB ;Get # rows to draw
OR AL,AL ;Check if -1
JS DB_3
CBW ;Convert count to word
MOV CX,AX ;Put in count register
;----------------------------------------------------------------------
; Repeat this procedure once for each row.
;----------------------------------------------------------------------
DB_2:
PUSH CX ;Save row counter
;----------------------------------------------------------------------
; Position to the current row, column 0 and write the leftmost char.
; Write TTY automatically advances the cursor.
;----------------------------------------------------------------------
MOV AH,2 ;Position cursor
SUB DL,DL ; to column 0
INT 10H ; thru BIOS
MOV AL,[SI] ;Get leftmost char
MOV AH,0EH ;Write 1 char TTY
INT 10H ; thru BIOS
;----------------------------------------------------------------------
; Fill the middle 78 chars with the next char in the array.
;----------------------------------------------------------------------
MOV AL,[SI+1] ;Get middle char
MOV AH,0AH ;Write repeated char
MOV CX,78 ; this many
INT 10H ; thru BIOS
;----------------------------------------------------------------------
; Position the cursor to the two interior partition spots and draw the
; character required.
;----------------------------------------------------------------------
MOV AH,2 ;Position cursor
MOV DL,10 ; to first partition
INT 10H ; thru BIOS
MOV AL,[SI+2] ;Get partition char
MOV AH,0EH ;Write 1 char TTY
INT 10H ; thru BIOS
MOV AH,2 ;Position cursor
MOV DL,60 ; to first partition
INT 10H ; thru BIOS
MOV AH,0EH ;Write 1 char TTY
INT 10H ; thru BIOS
;----------------------------------------------------------------------
; Position to the right side of the screen and draw the final character
; for this row. Don't use Write TTY because it scrolls the screen.
;----------------------------------------------------------------------
MOV AH,2 ;Position cursor
MOV DL,79 ; to far right
INT 10H ; thru BIOS
MOV AL,[SI+3] ;Get rightmost char
MOV AH,0AH ;Write char
MOV CX,1 ;1 copy
INT 10H ; thru BIOS
INC DH ;Next row
POP CX ;Restore counter
LOOP DB_2
;----------------------------------------------------------------------
; Move to the next array row and continue.
;----------------------------------------------------------------------
ADD SI,4
JMP DB_1
;----------------------------------------------------------------------
; Display the title, column headings, and help prompt.
;----------------------------------------------------------------------
DB_3:
MOV AH,2 ;Position cursor
MOV DX,100H+(80-TITLE_LEN)/2 ; to this row,col
INT 10H ; thru BIOS
MOV AH,9 ;Display string
MOV DX,OFFSET TITLE$ ; showing title
INT 21H ; thru DOS
MOV AH,2 ;Position cursor
MOV DX,OFFSET_POS
INT 10H ; thru BIOS
MOV AH,9 ;Display string
MOV DX,OFFSET OFFSET$ ;Offset heading
INT 21H ; thru DOS
MOV AH,2 ;Position cursor
MOV DX,HEX_POS
INT 10H ; thru BIOS
MOV AH,9 ;Display string
MOV DX,OFFSET HEX$ ;Hex data heading
INT 21H ; thru DOS
MOV AH,2 ;Position cursor
MOV DX,ASCII_POS
INT 10H ; thru BIOS
MOV AH,9 ;Display string
MOV DX,OFFSET ASCII$ ;ASCII data heading
INT 21H ; thru DOS
MOV AH,2 ;Position cursor
MOV DX,1700H+(80-HELP_LEN)/2 ; to this row/col
INT 10H ; thru BIOS
MOV AH,9 ;Display string
MOV DX,OFFSET HELP$ ; showing help
INT 21H ; thru DOS
RET
DRAW_BKGND ENDP
;======================================================================
; EDIT (Near)
;
; On entry, the background editing screen has been drawn and the buffer
; has been initialized to hold the first portion of the file.
;----------------------------------------------------------------------
; Entry: None
; Exit :
; CY - indicates a file error occurred while buffering
; NC - everything went okay
;----------------------------------------------------------------------
; Changes: AX BX CX DX
;----------------------------------------------------------------------
EDIT PROC NEAR
ASSUME CS:CSEG, DS:CSEG, ES:CSEG, SS:CSEG
;----------------------------------------------------------------------
; Set the flags so the buffer will be filled and the display updated.
;----------------------------------------------------------------------
INC [REDO_BUF] ;Fill buffer
INC [REDO_GRID] ;Draw display
JMP SHORT EDIT_0B
;----------------------------------------------------------------------
; The move couldn't be performed within the grid. Move the grid so
; that the desired byte is visible.
;----------------------------------------------------------------------
EDIT_0A:
CALL MOVE_GRID
JNC EDIT_0B
;----------------------------------------------------------------------
; If MOVE_GRID returned with CY, a file error occurred.
;----------------------------------------------------------------------
EDIT_EXIT:
RET
;----------------------------------------------------------------------
; If required, FILL_BUFFER will refresh the buffer.
;----------------------------------------------------------------------
EDIT_0B:
CALL FILL_BUFFER ;Refresh the buffer
JC EDIT_EXIT ;Exit if error
;----------------------------------------------------------------------
; If required, translate the visible portion of the buffer to the screen.
;----------------------------------------------------------------------
EDIT_0C:
CALL DISPLAY_GRID ;Refresh screen
;----------------------------------------------------------------------
; Set the cursor so it appears under the correct screen character.
;----------------------------------------------------------------------
EDIT_0D:
CALL SET_CURSOR ;Place cursor
;----------------------------------------------------------------------
; Get a key from the keyboard and act on it.
;----------------------------------------------------------------------
EDIT_1A:
SUB AH,AH ;Fetch a key
INT 16H ; thru BIOS
OR AL,AL ;If AL=0, is extended
JZ EDIT_1B
JMP EDIT_11
EDIT_1B:
;----------------------------------------------------------------------
; *** Right arrow.
;----------------------------------------------------------------------
CMP AH,RARROW ;Right arrow
JNE EDIT_3A
EDIT_1C:
TEST [MODE],MODE_MASK ;Check hex/ascii
JZ EDIT_2C ;Jump if ASCII
JPE EDIT_2B ;Jump if RIGHT
;----------------------------------------------------------------------
; HEX mode. If cursor is on left hex digit, move to right hex digit.
;----------------------------------------------------------------------
NOT [MODE] ;Mode = right hex digit
MOV AL,1 ;Move right 1 column
EDIT_2A:
CALL MOVE_CURSOR ;Move cursor
JMP EDIT_0C
;----------------------------------------------------------------------
; If cursor is on right hex digit, move to left hex digit, then...
;----------------------------------------------------------------------
EDIT_2B:
MOV [MODE],LEFT ;Change to left digit
;----------------------------------------------------------------------
; Move to next grid byte.
;----------------------------------------------------------------------
EDIT_2C:
CMP [GRIDCOL],GRIDCOLMAX ;Are we at far right?
JE EDIT_2E
INC [GRIDCOL] ;No - move to next byte
JMP EDIT_0C ;Recalc cursor
EDIT_2E:
CMP [GRIDROW],GRIDROWMAX ;Are we at bottom?
JE EDIT_2G
MOV [GRIDCOL],0 ;Move to first byte
EDIT_2F:
INC [GRIDROW] ; in next row
JMP EDIT_0C ;Recalc cursor
EDIT_2G:
MOV AX,1 ;Move buffer +1 byte
JMP EDIT_0A ;Redo buffer
;----------------------------------------------------------------------
; *** Down arrow.
;----------------------------------------------------------------------
EDIT_3A:
CMP AH,DARROW
JNE EDIT_4A
CMP [GRIDROW],GRIDROWMAX ;Are we at bottom?
JNE EDIT_2F
MOV AX,16 ;Move 1 row
JMP EDIT_0A ;Redo buffer
;----------------------------------------------------------------------
; *** PgDn.
;----------------------------------------------------------------------
EDIT_4A:
CMP AH,PGDN
JNE EDIT_5A
MOV AX,GRID_LEN ;Move 1 full screen
JMP EDIT_0A ;Redo buffer
;----------------------------------------------------------------------
; *** Left arrow.
;----------------------------------------------------------------------
EDIT_5A:
CMP AH,LARROW ;Left arrow
JNE EDIT_6A
TEST [MODE],MODE_MASK ;Check hex/ascii
JZ EDIT_5C ;Jump if ASCII
JPO EDIT_5B ;Jump if LEFT
;----------------------------------------------------------------------
; If cursor is on right hex digit, move to left hex digit.
;----------------------------------------------------------------------
NOT [MODE] ;Change to left digit
MOV AL,-1 ;Back up cursor 1 col
JMP EDIT_2A
;----------------------------------------------------------------------
; If cursor is on left hex digit, move to right hex digit, then...
;----------------------------------------------------------------------
EDIT_5B:
MOV [MODE],RIGHT ;Reset to right digit
;----------------------------------------------------------------------
; Move to previous grid byte.
;----------------------------------------------------------------------
EDIT_5C:
CMP [GRIDCOL],0 ;Far left column?
JE EDIT_5D
DEC [GRIDCOL] ;No - back up
JMP EDIT_0C ;Recalc cursor
EDIT_5D:
CMP [GRIDROW],0 ;Top of grid?
JE EDIT_5F
MOV [GRIDCOL],GRIDCOLMAX ;No - back around
EDIT_5E:
DEC [GRIDROW] ;Previous row
JMP EDIT_0C ;Recalc cursor
EDIT_5F:
MOV AX,-1 ;Back up buffer 1 byte
JMP EDIT_0A ;Redo buffer
;----------------------------------------------------------------------
; *** Up arrow.
;----------------------------------------------------------------------
EDIT_6A:
CMP AH,UARROW
JNE EDIT_7A
CMP [GRIDROW],0 ;At top row?
JNE EDIT_5E
MOV AX,-16 ;Back up 16 bytes
JMP EDIT_0A ;Redo buffer
;----------------------------------------------------------------------
; *** PgUp.
;----------------------------------------------------------------------
EDIT_7A:
CMP AH,PGUP
JNE EDIT_8A
MOV AX,-(GRID_LEN) ;Back up 1 screen
JMP EDIT_0A ;Redo buffer
;----------------------------------------------------------------------
; F8 - switch modes.
;----------------------------------------------------------------------
EDIT_8A:
CMP AH,F8KEY
JNE EDIT_9
SUB AL,AL ;Create 0 (ascii mode)
CMP AL,[MODE] ;Is mode 0 (ascii)?
JNE EDIT_8B
MOV AL,LEFT ;Make hex
EDIT_8B:
MOV [MODE],AL ;Save mode
JMP EDIT_0D ;Recalc cursor
;----------------------------------------------------------------------
; F7 - Exit the editor.
;----------------------------------------------------------------------
EDIT_9:
CMP AH,F7KEY
JNE EDIT_10
CALL COMMIT_BUFFER ;Flush if needed
JMP EDIT_EXIT
;----------------------------------------------------------------------
; If here, was not a recognized keystroke. Ignore it and continue.
;----------------------------------------------------------------------
EDIT_10:
JMP EDIT_1A
;----------------------------------------------------------------------
; Key dispatch for non-extended keys.
; If HEX mode, only 0-9 and A-F are accepted.
; In ASCII mode, anything goes!
;
; First, determine the offset into the buffer of the active grid byte.
;----------------------------------------------------------------------
EDIT_11:
MOV DL,AL ;Put char in DL
MOV AL,[GRIDROW] ;Current row
MOV AH,GRIDCOLMAX+1 ;* row length
MUL AH
ADD AL,[GRIDCOL] ;+ current column
MOV BX,[GRID_ANCHOR] ;+ anchor
ADD BX,AX ;= offset of byte
ADD BX,OFFSET BUFFER ;= addr of byte
MOV CH,[MODE] ;Save mode
OR CH,CH
JNZ EDIT_12B
;----------------------------------------------------------------------
; ASCII mode. Substitute the character in DL for the current byte.
; The byte will always be in the buffer, even if not visible!
;----------------------------------------------------------------------
MOV [BX],DL ;Place char in buf
EDIT_12A:
MOV [BUF_ALTERED],1 ;Say buffer is changed
INC [REDO_GRID] ;Request redraw
JMP EDIT_1C ;Goto right arrow
;----------------------------------------------------------------------
; HEX MODE: Check if character is a hex digit.
;----------------------------------------------------------------------
EDIT_12B:
CMP DL,"0" ;Below this, leave
JB EDIT_10
CMP DL,"9" ;Above this, check A-F
JA EDIT_12D
SUB DL,"0" ;Convert char to number
;----------------------------------------------------------------------
; Mask the digit in the lower 4 bits of DL into the current byte.
;----------------------------------------------------------------------
EDIT_12C:
MOV CL,4
MOV DH,DL
SHL DH,CL
OR DL,DH
AND DL,CH ;Mask appropriate bit
NOT CH ;Reverse mask
AND [BX],CH ;Clear old digit
OR [BX],DL ; and substitute new
JMP EDIT_12A
;----------------------------------------------------------------------
; See if A-F.
;----------------------------------------------------------------------
EDIT_12D:
OR DL,20H ;Make lowercase
CMP DL,"a" ;Ignore if below "a"
JB EDIT_10
CMP DL,"f" ; or above "f"
JA EDIT_10
SUB DL,57H ;Convert to digit
JMP EDIT_12C
EDIT ENDP
;======================================================================
; MOVE_GRID (Near)
;
; This routine moves the grid so that the desired data is visible.
;----------------------------------------------------------------------
; Entry:
; AX = integer number of bytes to move the grid
; Exit :
; CY - file error during I/O
; NC - no file errors
;----------------------------------------------------------------------
; Changes: AX BX CX DX SI DI BP
;----------------------------------------------------------------------
MOVE_GRID PROC NEAR
ASSUME CS:CSEG, DS:CSEG, ES:NOTHING, SS:CSEG
;----------------------------------------------------------------------
; Load some needed values into registers for speed.
;----------------------------------------------------------------------
MOV BX,[BUF_BYTES] ;Bytes in buffer
MOV BP,[GRID_ANCHOR] ;Grid anchor
MOV SI,WORD PTR [BUF_ANCHOR][0] ;Buffer anchor
MOV DI,WORD PTR [BUF_ANCHOR][2]
;----------------------------------------------------------------------
; If the entire file is smaller than 1 grid, we can just leave now as
; no buffer movement is possible.
;----------------------------------------------------------------------
CMP BX,GRID_LEN ;File < 1 display?
JBE MG_2
;----------------------------------------------------------------------
; Branch depending on the direction of the move.
;----------------------------------------------------------------------
OR AX,AX ;Which direction?
JS MG_1A
;----------------------------------------------------------------------
; FWD: Can this move be performed within the current buffer?
;----------------------------------------------------------------------
SUB BX,GRID_LEN ;Max grid anchor
ADD BP,AX ;Desired grid anchor
CMP BP,BX ;Desired <= maximum?
JBE MG_1D
;----------------------------------------------------------------------
; The desired grid anchor exceeds the maximum grid anchor.
; If file is larger than the buffer, jump to the more complex
; buffer-moving routines. Otherwise, just use the maximum anchor.
;----------------------------------------------------------------------
CMP [FULLY_BUFFERED],0 ;0=larger than buffer
JE MG_3A ;Go to buffer routines
MOV BP,BX ;Use max anchor
JMP SHORT MG_1D
;----------------------------------------------------------------------
; Determine if this backward move can be performed within the buffer.
; (Backing up is hard to do...)
;----------------------------------------------------------------------
MG_1A:
NEG AX ;Make AX positive
CMP AX,BP ;Back up past anchor?
JA MG_1B
SUB BP,AX ;No, set new anchor
JMP SHORT MG_1D
MG_1B:
;----------------------------------------------------------------------
; If the file is larger than the buffer, jump to the more complex
; buffer-moving routines. Otherwise, just move to the buffer start.
;----------------------------------------------------------------------
CMP [FULLY_BUFFERED],0 ;0 = larger than buffer
JNE MG_1C
JMP SHORT MG_4A ;Go to buffer routines
MG_1C:
OR BP,BP ;If already at start
JZ MG_2 ; do no more
SUB BP,BP ;Else go to start
;----------------------------------------------------------------------
; If we're not moving the anchor, just ignore the request.
;----------------------------------------------------------------------
MG_1D:
CMP BP,[GRID_ANCHOR]
JE MG_2
MOV [GRID_ANCHOR],BP ;Set new anchor
MG_1E:
INC [REDO_GRID] ;Request grid redraw
;----------------------------------------------------------------------
; Exit to caller.
;----------------------------------------------------------------------
MG_2:
CLC ;Signal success
U_EXIT:
RET
;----------------------------------------------------------------------
; If we get here, we know:
; 1. we've been asked to move forward past the end of the buffer.
; 2. the file size is greater than the buffer size.
; 3. the buffer is filled to capacity.
;----------------------------------------------------------------------
MG_3A:
MOV DX,WORD PTR [BUF_ANCHOR_MAX][0] ;Get value
MOV CX,WORD PTR [BUF_ANCHOR_MAX][2] ; in registers
;----------------------------------------------------------------------
; If the current buffer anchor is as far forward as it can go, we can't
; move it any farther forward.
;----------------------------------------------------------------------
CMP DI,CX ;Test hi offset
JNE MG_3B
CMP SI,DX ; and lo offset
JNE MG_3B
;----------------------------------------------------------------------
; The end of the buffer is already at the EOF. Move the grid anchor so
; the last byte in the buffer is the last byte shown on the grid.
;----------------------------------------------------------------------
CMP BX,[GRID_ANCHOR] ;Are we already there?
JE MG_2
MOV [GRID_ANCHOR],BX ;Move to last
JMP MG_1E
;----------------------------------------------------------------------
; The buffer anchor is not at its maximum forward point and is
; definitely going to be moved forward.
;
; We can move the buffer forward BUF_SIZE/2 bytes only if:
; BUF_ANCHOR + BUF_SIZE/2 < BUF_ANCHOR_MAX
;----------------------------------------------------------------------
MG_3B:
MOV BX,[BUF_SIZE] ;Get BUF_SIZE
SHR BX,1 ; and divide by 2
ADD SI,BX ;Calc new 32-bit
ADC DI,0 ; buf anchor
CMP DI,CX ;Test hi offset
JA MG_3C
JB MG_3D
CMP SI,DX ; and lo offset
JBE MG_3D
MG_3C:
;----------------------------------------------------------------------
; The new anchor would be beyond the maximum. Set it to the maximum
; and exit.
;----------------------------------------------------------------------
MOV DI,CX ;Set to maximum
MOV SI,DX ; buffer anchor
;----------------------------------------------------------------------
; Save the new buffer anchor.
;----------------------------------------------------------------------
MG_3D:
MOV CX,DI ;Save new anchor
MOV DX,SI ; in CX:DX
XCHG SI,WORD PTR [BUF_ANCHOR][0] ;Get old anchor
XCHG DI,WORD PTR [BUF_ANCHOR][2] ; in DI:SI
SUB CX,DI ;Figure difference
SBB DX,SI
;----------------------------------------------------------------------
; If we didn't move as far as requested, maximize the grid anchor.
;----------------------------------------------------------------------
CMP AX,DX ;Request <= move?
JBE MG_3E
MOV AX,[BUF_BYTES] ;Bytes in buffer
SUB AX,GRID_LEN ;-bytes on screen
MOV [GRID_ANCHOR],AX ;is new anchor
INC [REDO_BUF] ;Request buffer fill
JMP MG_1E
MG_3E:
SUB DX,AX ;Account for DISP
SUB [GRID_ANCHOR],DX ;Adjust anchor
INC [REDO_BUF] ;Refill buffer
JMP MG_1E
;----------------------------------------------------------------------
; If we get here, we know:
; 1. we've been asked to move back past the beginning of the buffer.
; 2. the file size is greater than the buffer size.
; 3. the buffer is filled to capacity.
;----------------------------------------------------------------------
MG_4A:
;----------------------------------------------------------------------
; If the current buffer anchor is as far back as it can go (0:0), we
; can't move the buffer.
;----------------------------------------------------------------------
OR DI,DI ;Test hi offset
JNZ MG_4B
;----------------------------------------------------------------------
; After this, we know that DI is 0; so we work only with SI.
;----------------------------------------------------------------------
OR SI,SI ;And lo
JNZ MG_4E
;----------------------------------------------------------------------
; The start of the buffer is at 0:0 (BOF). Move the grid anchor so the
; first byte in the buffer is the first byte shown on the grid.
;----------------------------------------------------------------------
CMP [GRID_ANCHOR],0 ;Already at 0?
JE MG_2
MOV [GRID_ANCHOR],0 ;Make it 0
JMP MG_1E
;----------------------------------------------------------------------
; Backing up is easy to do when the buf anchor > 64k.
;----------------------------------------------------------------------
MG_4B:
SUB SI,BX ;Back up 1/2 buffer
SBB DI,0 ; (32-bit)
MG_4C:
SUB BX,AX ;Now move the disp
ADD [GRID_ANCHOR],BX ; and save new anchor
MG_4D:
MOV WORD PTR [BUF_ANCHOR][0],SI ;Save new
MOV WORD PTR [BUF_ANCHOR][2],DI ; buf anchor
INC [REDO_BUF] ;Request buffer refill
JMP MG_1E
;----------------------------------------------------------------------
; The buffer anchor is not at the start of the file, so we can move the
; buffer backward in the file.
;
; Move to either SI-BX or 0, whichever is farther forward in the file.
;----------------------------------------------------------------------
MG_4E:
SHR BX,1 ;BUF_BYTES/2
CMP SI,BX ;Buf anchor > buf/2?
JAE MG_4F
;----------------------------------------------------------------------
; Since we can't back up the full amount, back up to BOF.
;----------------------------------------------------------------------
SUB SI,SI ;Zero lower anchor
MOV [GRID_ANCHOR],SI ;Set anchor to 0
JMP MG_4D
;----------------------------------------------------------------------
; If the current buffer anchor is > buffer size/2, back it up by
; buffer size/2.
;----------------------------------------------------------------------
MG_4F:
SUB SI,BX ;SI = new buf anchor
JMP MG_4C
MOVE_GRID ENDP
;======================================================================
; FILL_BUFFER (Near)
;
; Copies data from the file to the buffer. Up to BUF_SIZE bytes are
; copied from the file beginning at offset BUF_ANCHOR.
;----------------------------------------------------------------------
; Entry: None
; Exit :
; CY - if file error
; NC - no file error
;----------------------------------------------------------------------
; Changes: AX BX CX DX
;----------------------------------------------------------------------
FILL_BUFFER PROC NEAR
ASSUME CS:CSEG, DS:CSEG, ES:NOTHING, SS:CSEG
SUB CX,CX ;Create a zero
XCHG CL,[REDO_BUF] ;Swap for flag
JCXZ FB_EXIT ;Exit if 0
;----------------------------------------------------------------------
; If the current buffer data has changed, write it out to the file.
;----------------------------------------------------------------------
CALL COMMIT_BUFFER
JC FB_EXIT
;----------------------------------------------------------------------
; Position the scratch file to the byte specified in BUF_ANCHOR.
;----------------------------------------------------------------------
FB_2A:
MOV AX,4200H ;Position file pointer
MOV BX,[TMP_HANDLE] ; for this handle
MOV DX,WORD PTR [BUF_ANCHOR][0] ;Lo word
MOV CX,WORD PTR [BUF_ANCHOR][2] ;Hi word
INT 21H ; thru DOS
JC FB_EXIT
;----------------------------------------------------------------------
; Attempt to fill the buffer from the file.
;----------------------------------------------------------------------
MOV AH,3FH ;Read file
MOV BX,[TMP_HANDLE] ; from this handle
MOV CX,[BUF_SIZE] ; this many bytes
MOV DX,OFFSET BUFFER ;Put data here
INT 21H ; thru DOS
;----------------------------------------------------------------------
; After a successful read, AX contains the number of bytes actually
; read. If carry set, the calling program just ignores it.
;----------------------------------------------------------------------
MOV [BUF_BYTES],AX ;Save # bytes in buffer
FB_EXIT:
RET
FILL_BUFFER ENDP
;======================================================================
; COMMIT_BUFFER (Near)
;
; If the data in the buffer has been changed, write the buffer back to
; the file beginning at offset BUF_ANCHOR.
;----------------------------------------------------------------------
; Entry: None
; Exit :
; CY - if file error
; NC - no file error
;----------------------------------------------------------------------
; Changes: AX BX CX DX
;----------------------------------------------------------------------
COMMIT_BUFFER PROC NEAR
ASSUME CS:CSEG, DS:CSEG, ES:NOTHING, SS:CSEG
SUB CX,CX ;Create a zero
XCHG CL,[BUF_ALTERED] ;Fetch/clear flag
JCXZ CB_EXIT
MOV [FILE_ALTERED],CL ;Non-zero = altered
;----------------------------------------------------------------------
; Position the scratch file to the byte specified in BUF_ANCHOR.
;----------------------------------------------------------------------
MOV AX,4200H ;Position file pointer
MOV BX,[TMP_HANDLE] ; for this handle
MOV DX,WORD PTR [BUF_ANCHOR][0] ;Lo word
MOV CX,WORD PTR [BUF_ANCHOR][2] ;Hi word
INT 21H ; thru DOS
JC CB_EXIT
;----------------------------------------------------------------------
; Write the buffer contents to the file.
;----------------------------------------------------------------------
MOV AH,40H ;Write to file fn
MOV BX,[TMP_HANDLE] ;To this handle
MOV CX,[BUF_BYTES] ;This many bytes
MOV DX,OFFSET BUFFER ;Get data from here
INT 21H ; thru DOS
JC CB_EXIT
;----------------------------------------------------------------------
; After a successful write, AX contains the number of bytes actually
; written. If it doesn't match the number we tried to write, error.
;----------------------------------------------------------------------
CMP AX,CX ;Write them all?
JB CB_EXIT ;JB = JC = carry set
CB_EXIT:
RET
COMMIT_BUFFER ENDP
;======================================================================
; DISPLAY_GRID (Near)
;
; Starting with the current pointer into the buffer, put as many chars
; as possible on the screen.
;----------------------------------------------------------------------
; Entry: None
; Exit : None
;----------------------------------------------------------------------
; Changes: CX DX
;----------------------------------------------------------------------
DISPLAY_GRID PROC NEAR
ASSUME CS:CSEG, DS:CSEG, ES:NOTHING, SS:CSEG
SUB CX,CX ;Create a zero
XCHG CL,[REDO_GRID] ;Get/reset flag
JCXZ DG_EXIT
;----------------------------------------------------------------------
; Draw rows 0 through 15 on the screen
;----------------------------------------------------------------------
MOV CX,16 ;Row counter
SUB DX,DX ;Row # to draw
DG_1:
CALL DISPLAY_ROW ;Display row
INC DX ;Next row, please
LOOP DG_1
DG_EXIT:
RET
DISPLAY_GRID ENDP
;======================================================================
; DISPLAY_ROW (Near)
;
; Display one row of the grid on the display.
;----------------------------------------------------------------------
; Entry:
; DX = # of row to display
; Exit: None
;----------------------------------------------------------------------
; Changes: AX BX SI DI BP
;----------------------------------------------------------------------
DISPLAY_ROW PROC NEAR
ASSUME CS:CSEG, DS:CSEG, ES:NOTHING, SS:CSEG
PUSH CX ;Save used registers
PUSH DX
MOV BH,[VPAGE] ;Active video page
;----------------------------------------------------------------------
; From the row number, figure out how far we are into the display
; buffer. From that figure out how far we are into the file buffer.
;----------------------------------------------------------------------
MOV SI,DX ;Put row in SI and
MOV CL,4 ; multiply by 16
SHL SI,CL ; offset into display
ADD SI,[GRID_ANCHOR] ; -> offset into buffer
MOV CX,SI ;Save in CX
MOV BP,OFFSET BUFFER ;Addr of buffer in mem
ADD SI,BP ;SI -> memory addr
MOV DI,SI ;Save it in DI
ADD BP,[BUF_BYTES] ;BP -> last valid byte
;----------------------------------------------------------------------
; Calculate the current screen row.
;----------------------------------------------------------------------
ADD DL,ROW_0 ;Bias by screen row
MOV BL,DL ; and save it
;----------------------------------------------------------------------
; Position the cursor to display the offset.
;----------------------------------------------------------------------
MOV DH,OFF_COL ;Column for OFFSET
XCHG DH,DL ;Row,col order
MOV AH,2 ;Position cursor
INT 10H ; thru BIOS
;----------------------------------------------------------------------
; Does the first byte in this row point to a byte that is actually
; part of the file? If not, just blank out this entire row.
;----------------------------------------------------------------------
CMP SI,BP ;Current < invalid?
JBE DR_1A
MOV AX,0A00H+254 ;Write repeated char
MOV CX,8 ; this many
INT 10H ; thru BIOS
JMP SHORT DR_1B
;----------------------------------------------------------------------
; Calculate and show the file offset of the first byte in this row.
;----------------------------------------------------------------------
DR_1A:
MOV DX,WORD PTR [BUF_ANCHOR][0] ;Get buffer
MOV AX,WORD PTR [BUF_ANCHOR][2] ; offset
ADD DX,CX ;Add current byte
ADC AX,0 ; to 32-bit #
CALL HEX4 ;Display high part
MOV AX,DX ; and
CALL HEX4 ;Display low part
DR_1B:
;----------------------------------------------------------------------
; Display the hex bytes for this row.
;----------------------------------------------------------------------
MOV AH,2 ;Position cursor
MOV DH,BL ;To row
MOV DL,HEX_COL ; and column
INT 10H ; thru BIOS
MOV CX,16 ;Bytes in a row
DR_2A:
CMP SI,BP ;Past valid bytes?
JBE DR_2B
MOV AX,0E00H+254 ;Put a block
INT 10H ; thru BIOS
MOV AX,0E00H+254 ; and again
INT 10H ; also thru BIOS
JMP SHORT DR_2C
DR_2B:
LODSB ;Get hex byte
CALL HEX2 ;Display it TTY
DR_2C:
MOV AX,0E00H+BLANK ;Write a blank
INT 10H ; thru BIOS
LOOP DR_2A ;Repeat
;----------------------------------------------------------------------
; Display the ASCII characters for this row.
;----------------------------------------------------------------------
MOV DH,BL ;To row
MOV DL,ASC_COL ; and column
MOV SI,DI ;Point to start of row
MOV CX,16 ;Bytes in a row
DR_3A:
MOV AH,2 ;Position cursor
INT 10H ; thru BIOS
CMP SI,BP ;Past valid bytes?
JBE DR_3B
MOV AX,0E00H+BLANK ;Write a blank
INT 10H ; thru BIOS
JMP SHORT DR_3C
DR_3B:
PUSH CX
MOV AH,0AH ;Write char at cursor
LODSB ;Get hex byte
MOV CX,1 ;Write 1 copy
INT 10H ; thru BIOS
POP CX
INC DL ;Next column
DR_3C:
LOOP DR_3A ;Repeat
;----------------------------------------------------------------------
; Return to caller
;----------------------------------------------------------------------
POP DX ;Restore registers
POP CX
RET
DISPLAY_ROW ENDP
;======================================================================
; HEX4 (Near)
;
; Write AX as 4 hex digits using BIOS Write TTY.
;----------------------------------------------------------------------
; Entry:
; AX = value to display
; Exit : None
;----------------------------------------------------------------------
; CHANGES: None
;----------------------------------------------------------------------
HEX4 PROC NEAR
ASSUME CS:CSEG, DS:CSEG, ES:NOTHING, SS:CSEG
PUSH CX ;Save used registers
PUSH DX
MOV CX,4 ;Number of digits
JMP SHORT H_1
;======================================================================
; HEX2 (Near, nested)
;
; Write AX as 2 hex digits using BIOS Write TTY.
;----------------------------------------------------------------------
; Entry:
; AL = value to display
; Exit : None
;----------------------------------------------------------------------
; CHANGES: AX
;----------------------------------------------------------------------
HEX2 PROC NEAR
ASSUME CS:CSEG, DS:CSEG, ES:NOTHING, SS:CSEG
PUSH CX ;Save used registers
PUSH DX
MOV AH,AL ;Put byte in AH
MOV CX,2 ;Number of digits
H_1:
PUSH CX ;(Save count)
MOV CL,4 ;Shift count
ROL AX,CL ;Rotate into position
POP CX ;(Restore count)
PUSH AX ;Preserve digits
AND AL,0FH ;Mask off single digit
ADD AL,90H ;Convert digit to ASCII
DAA ; using a small
ADC AL,40H ; code sequence
DAA ; that's tricky
MOV AH,2 ;Display char
MOV DL,AL ; in DL
INT 21H ; thru DOS
POP AX ;Restore digits
LOOP H_1 ;Repeat until done
POP DX ;Restore registers
POP CX
RET
HEX2 ENDP
HEX4 ENDP
;======================================================================
; MOVE_CURSOR (Near)
;
; Move the screen cursor the number of columns specified in AL. If AL>0
; cursor is moved to the right. Result is not checked.
;----------------------------------------------------------------------
; Entry:
; AL = columns to move
; Exit:
; None
;----------------------------------------------------------------------
; Changes: AX BX DX
;----------------------------------------------------------------------
MOVE_CURSOR PROC NEAR
ASSUME CS:CSEG, DS:CSEG, ES:NOTHING, SS:CSEG
ADD BYTE PTR [VCURSOR],AL ;Adjust columns
MOV AH,2 ;Position cursor
MOV BH,[VPAGE] ; on this page
MOV DX,[VCURSOR] ; to these coordinates
INT 10H ; thru BIOS
RET
MOVE_CURSOR ENDP
;======================================================================
; SET_CURSOR (Near)
;
; Position the cursor under the correct character on the screen.
;----------------------------------------------------------------------
; Entry: None
; Exit : None
;----------------------------------------------------------------------
; Changes: AX BX DX
;----------------------------------------------------------------------
SET_CURSOR PROC NEAR
ASSUME CS:CSEG, DS:CSEG, ES:NOTHING, SS:CSEG
;----------------------------------------------------------------------
; Figure the screen column based on whether the mode is hex or ascii.
;----------------------------------------------------------------------
MOV DL,[GRIDCOL] ;Get grid column
TEST [MODE],MODE_MASK ;Check flag for mode
JNZ SC_2A
ADD DL,ASC_COL ;Bias for ASCII column
SC_1:
;----------------------------------------------------------------------
; Figure the screen row.
;----------------------------------------------------------------------
MOV DH,[GRIDROW] ;Get grid row
ADD DH,ROW_0 ;Bias to screen row
MOV [VCURSOR],DX ;Save current cursor
MOV BH,[VPAGE] ;Use current page
MOV AH,2 ;Set cursor position
INT 10H ; thru BIOS
RET
;----------------------------------------------------------------------
; Figure the column for the hex display.
;----------------------------------------------------------------------
SC_2A:
MOV AL,DL ;Grid column
ADD DL,DL ; *2
ADD DL,AL ; total is *3
ADD DL,HEX_COL ;Add start of hex cols
CMP [MODE],LEFT ;What digit?
JE SC_1
INC DL ;Add 1 if right digit
JMP SC_1
SET_CURSOR ENDP
;======================================================================
; Allocated after program loads.
;----------------------------------------------------------------------
PC = $ ;End of code
PC = PC + 512
STACK_TOP = PC ;Top of stack
BUFFER = PC ;Bottom of buffer
CSEG ENDS
END ENTPT
