ProfitPress Mega CDROM2 Shareware Freeware (MSDOS)(1992)(Eng)

home *** CD-ROM | disk | FTP | other *** search

/ ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng) / ProfitPress-MegaCDROM2.B6I / UTILITY / MISC / HILOAD10.ZIP / HILOAD.ASM next >

Wrap

Assembly Source File | 1990-06-18 | 21.2 KB | 895 lines

; This is version 1.01 of HILOAD ; ; See accompanying .DOC file for theory of ; operation and instructions ; ; No guarantees, but the author would appreciate ; information on bugs. ; ; Larry Shannon 18 Jun 89 ; ; Equates ; CR EQU 0D LF EQU 0A SPACE EQU 020 MON EQU MOV ; Common typo ONE EQU 1 TWO EQU 2 DOLLAR EQU 024 ZERO EQU 0 BELL EQU 07 ;..... ; ; Macros ; PRINT MACRO ; Usage: print MSG1 PUSH AX ; All registers preserved PUSH DX MOV AH,9 LEA DX, #1 INT 021 POP DX POP AX #EM ; PRINT$ MACRO ; Usage: print$,"MESSAGE" PUSH AX ; Prints at current cursor position PUSH DX JMP >M1 M0: DB #1 DB "$" M1: MOV AH,9 ; All registers preserved LEA DX,M0 INT 021 POP DX POP AX #EM ; QUIT MACRO ; Usage: quit 0 MOV AH,04C ; Must give some value MOV AL,#1 INT 021 #EM ; NEWLINE MACRO ; Equivalent to CR,LF PUSH AX ; Scrolls if off screen PUSH DX JMP > M1 M0: DB 0D,0A,'$' M1: LEA DX,M0 MOV AH,9 INT 021 POP DX POP AX #EM ; SPLIT MACRO AAM 16 #EM ; Be careful with these with ; ; Nec v-20/v-30 chips! UNSPLIT MACRO ; This macro will effectively PUSH CX ; Do the same thing, and should be MOV CX,4 ; Compatible with all pc's ROL AH,CL AND AH,0F0 OR AL,AH POP CX #EM ; HEX_TO_PRNT MACRO ; Changes an 8-bit register quantity OR #1,030 ; From 0-f to the ascii equivalent CMP #1,039 ; Register must be in form 00 to 0f ; IF A ADD #1,7 #EM ; PRINT_REG MACRO ; Used to print a register (or any 16-bit JMP > M1 ; Quantity) at the current cursor position M0: DB 5 DUP ('$') M1: PUSH AX ; Usage - print_reg AX MOV AX,#1 ; Prints the 16-bit quantity in hex XCHG AH,AL PUSH AX MAKE_HEX_ASCII XCHG AH,AL MOV W[M0],AX POP AX XCHG AH,AL MAKE_HEX_ASCII XCHG AH,AL MOV W[M0+2],AX PRINT M0 POP AX #EM ; PRINT_32_DEC MACRO ; Macro to print a 32-bit hex number PUSH AX ; As a decimal string PUSH DX ; Enter with si pointing to two-word PUSH DI ; (four byte) quantity to be converted MOV DX,W[SI] ; Most significant word first MOV AX,W[SI+2] ; Prints at current cursor position JMP > M1 ; All registers restored M0: DB 11 DUP ('$') M1: LEA DI,M0 ADD DI,9 CALL LARGE_HEX_TO_ASCII MOV DX,DI MOV AH,9 INT 021 POP DI POP DX POP AX #EM ; REG_TO_PRINT MACRO ; Converts a 16-bit quantity to ascii PUSH AX ; And puts the resultant string in a PUSH BX ; Place pointed to by ds:si MOV BX,#1 ; All registers restored MOV AL,BH CALL HEX2PRNT MOV [SI],AX MOV AL,BL CALL HEX2PRNT MOV [SI+2],AX POP BX POP AX #EM ; MAKE_CAP MACRO ; Makes letters capitals CMP #1,061 ; Useage make_cap AH JB > M1 ; Ah contains a candidate ascii letter CMP #1,07A ; From A-Z or a-z JA > M1 ; Returns A-Z AND #1,0DF M1: NOP #EM ; MAKE_HEX_ASCII MACRO ; Makes al in hex into two ascii SPLIT ; Characters in ah:al HEX_TO_PRNT AH HEX_TO_PRNT AL #EM ;..... ; ; Data and strings ; ; ORG 0100 ; ; HILOAD: JMP LONG > L0 LOAD_BLOCK DW 0,0 FILE_STRING DB 65 DUP('$') TAIL_PTR DW 0 FILE_PTR DW 0 OLD_INT_27 DW 0,0 OLD_INT_21 DW 0,0 START_ADDR DW 0100,0 TAIL_BFR DB 127 DUP ('020') SW2127 DB 0 TEMPWRDS DW 0,0 BAR DB 40 DUP ('*'),'$' RESET_MSG DB CR,LF,'Resetting ICA area',CR,LF,'$' DEFAULT_ENV DB 'HILOAD',0 INT_MSG DB 'Interupt ' INT_NUM DB 0,0,'H is now located at ' INT_SEG DB 0,0,0,0,':' INT_OFF DB 0,0,0,0,CR,LF,'$' TEMP DW 0 LOAD_POINT DW 0,0 LP_PLUS_BYTES DW 0,0 INT_ADDR_1 DW 0 INT_ADDR_2 DW 0 ; NEW_INT21: CMP AH,031 ; New address for int 21h JE > Z21 ; Is it TSR termination? CMP AX,02521 ; Setting vector for int 21h? JE > Z25 ; If so, save it CMP AX,03521 ; Request for int 21h address? JE > Z35 ; If so, give him original address CS JMP D[OLD_INT_21] ; Otherwise, do real int 21h Z25: CS MOV OLD_INT_21,DX ; Here we save int 21h address info CS MOV OLD_INT_21+2,DS IRET ; And return to caller Z35: CS MOV BX,[OLD_INT_21] ; Here we give him original address CS MOV ES,[OLD_INT_21+2] IRET ; And return to caller Z21: CS MOV SW2127,0 ; Exiting via int 21 - set switch for JMP > Z22 ; Storage return handling ;..... ; NEW_INT27: CS MOV SW2127,1 ; Trap for int 27h - set switch Z22: MOV AX,CS ; Get our code segment MOV BX,DX ; Save return size info MOV DS,AX ; Set up local addressability MOV ES,AX ; Make sure other registers are MOV SS,AX ; What they should be MOV DX,[OLD_INT_27] ; Find original address of int 27h MOV AX,[OLD_INT_27+2] ; Segment portion MOV ES,0 ; Addressing bottom page ES MOV W[09C],DX ; Store vector addresses directly ES MOV W[09E],AX ; Since int 21h cannot be used to do MOV DX,[OLD_INT_21] ; The job - we've trapped it above! MOV AX,[OLD_INT_21 + 2] ; Do the same with int 21h MOV ES,0 ES MOV W[084],DX ; And store its address in the ES MOV W[086],AX ; Proper place in the table NEWLINE ; Space a line PRINT$ 'Saved bytes = ' ; Start of message CMP SW2127,1 ; See how we terminated; 1=int 27h so JE > Q2 ; Returns bytes - int 21h returns para- MOV AX,BX ; Graphs - here we're converting XOR DX,DX ; Paragraphs to bytes by multiplying MOV CX,4 ; By 4 (shift left 4 places) Q1: RCL AX,1 ; Have to allow for greater than 64k PUSHF ; Save flags with state of carry bit ROL DX,1 POPF ; Get flags back ADC DX,0 ; Add in and include carry LOOP Q1 ; Carry on JMP > Q3 Q2: MOV AX,BX ; Size info in bx - do setup for XOR DX,DX ; Conversion Q3: MOV TEMPWRDS,DX ; Temporarily store upper and lower MOV TEMPWRDS + 2,AX ; Halves of return size info (32 bits) PUSH DX ; Save dx MOV DX,[LOAD_POINT] ; Get where we started MOV LP_PLUS_BYTES,DX ; Put it here POP DX ; Retrieve dx ADD LP_PLUS_BYTES,DX ; Add size info MOV LP_PLUS_BYTES+2,AX ; Store upper half here LEA SI,TEMPWRDS ; Point to temporary storage PRINT_32_DEC ; Print out size in bytes NEWLINE ; Do new line MOV DX,[TEMPWRDS] ; Get back size info MOV AX,[TEMPWRDS+2] CLC ; Clear the carry MOV CX,4 ; We're going to convert to a 32-bit Q7: SHR DX,1 ; Number here and store it in PUSHF ; The ica area RCR AX,1 POPF LOOP Q7 MOV ES,040 ; Point to segment of ica ES MOV BX,[0F0] ; Get what was there ADD DX,BX ; Add new size ES MOV [0F0],DX ; And put it back ES MOV BX,[0F2] ; Get old lower half ADD AX,BX ; Add new bytes saved data INC AX ; Allow for truncation ES MOV [0F2],AX ; And put it back NEWLINE ; Start of trap info PRINT$ 'This TSR traps the following interrupts:' NEWLINE ; Some spaces NEWLINE ; ; Here is where we look to see what interrupts are trapped ; MOV CX,0FF ; Look at 256 interrupts MOV AX,03500 ; Set up call H1: PUSH CX ; Save registers PUSH AX INT 021 ; Get interrupt addresses MOV AX,BX ; Ax is offset MOV DX,ES ; Dx:ax is addr of interrupt MOV INT_ADDR_1,AX ; Store offset away MOV INT_ADDR_2,DX ; Store segment CALL ADD_SEG_OFF ; Convert to 32-bit number XCHG BX,DX ; Now bx:cx is int addr XCHG CX,AX ; In 32-bit form MOV DX,[LOAD_POINT] ; Where do we start XOR AX,AX ; No offset from start CALL ADD_SEG_OFF ; Make 32-bitter CALL CMP_32 ; Is int address beyond start point? JNC > H2 ; If below, can't be us - get out MOV DX,[LP_PLUS_BYTES] MOV AX,[LP_PLUS_BYTES + 2] ; Dx:ax now address of end of pgm CALL ADD_SEG_OFF ; Make 32-bits CALL CMP_32 ; Compare them JC > H2 ; If greater - beyond me POP AX ; We got one - retrieve interrupt PUSH AX ; And save function and int number CALL HEX2PRNT ; Get interrupt number in ascii LEA SI,INT_NUM ; Point to proper place MOV W[SI],AX ; Store it LEA SI,INT_SEG ; Point to place REG_TO_PRINT [INT_ADDR_2] ; Get segment in ascii LEA SI,INT_OFF ; Point to place REG_TO_PRINT [INT_ADDR_1] ; Print offset in ascii PRINT INT_MSG ; Print whole message H2: POP AX ; Get registers back INC AX POP CX DEC CX JCXZ > H3 ; Are we done? JMP LONG H1 ; No - go back for more H3: QUIT 0 ; We're done - exit ;..... ; ;======================================================================= ; Main program starts here ;======================================================================= ; L0: NEWLINE ; Give us some space PRINT BAR ; Print banner bar NEWLINE ; Another space MOV AH,[080] ; See if any comand tail CMP AH,1 JA > L1 L00: MOV ES,040 ; If no tail, reset ica ES MOV W[0F0],0 ES MOV W[0F2],0 PRINT RESET_MSG ; Write message QUIT 0 ; And get out - normal exit L1: MOV DI,080 ; Point to command tail L22: INC DI MOV AH,[DI] CMP AH,020 ; Bumping past the spaces here JE L22 MOV FILE_PTR,DI ; Point to file name L222: MOV AH,[DI] CMP AH,SPACE JE > L555 CMP AH,CR JE > L555 INC DI JMP L222 MOV AL,CR ; Look for carriage return MOV CX,0100 ; Look for a long time! CLD REPNE SCASB JCXZ L00 ; Get out if no find one DEC DI L555: MOV TAIL_PTR,DI ; Save pointer to command tail PUSH DI LEA BX,TAIL_BFR ; Point to command tail (saved) L16: MOV AH,[DI] ; Get element CMP AH,CR ; End of tail? JE > L17 MOV [BX],AH ; Stuff it away INC DI ; Bump pointers INC BX JMP L16 ; Do again L17: MOV B[BX],CR ; Terminate tail POP DI LEA BX,FILE_STRING ; Point to buffer to store file name MOV DI,[FILE_PTR] ; Get pointer to program in command tail L33: MOV AH,[DI] ; Build the name, char by char MAKE_CAP AH ; Make sure all caps MOV [BX],AH ; Stuff it away INC BX ; Bump pointers INC DI CMP DI,[TAIL_PTR] ; Are we done? JB L33 ; If not, carry on MOV W[BX],'C.' ; Stick in ".COM" extension MOV W[BX+2],'MO' ; Reversed - that's the way intel works MOV B[BX+4],0 ; End with 0 to make asciiz string LEA DX,FILE_STRING ; Point dx to the file MOV AH,04E ; Find file MOV CX,027 ; File attribute byte - this works INT 021 ; Do it JC > L77 ; Did we find it? JMP LONG L78 ; Got it! go process it L77: NEWLINE ; Couldn't find file NEWLINE PRINT$ 'Cant find file ' ; So say so MOV B[DI-1],'$' ; Put in string delimiter and print PRINT FILE_STRING ; What we were looking for PRINT$ ' ...ABORTING' ; Sorry charlie NEWLINE NEWLINE QUIT 3 ; Quit with error level = 3 L78: MOV AL,' ' ; Looking for a space MOV CX,100 ; Up to 256 bytes back STD ; Scan backwards REPNE SCASB ; And search LEA DX,FILE_STRING ; Ok, now at start of file string PUSH DI ; Save pointer MOV B[DI-1],0 ; Make asciiz string PUSH BX PUSH CX MOV AH,030 ; Check dos version level INT 021 POP CX POP BX CMP AL,2 ; At least version 2? JAE > V1 NEWLINE ; If not, dump out PRINT$ 'Requires DOS 2.0 or above ... ABORTING' NEWLINE QUIT 2 ; Bad dos version - error level = 2 V1: CMP AL,3 ; Version 3.0 or above? JAE > V2 ; If it is, we're ok LEA SI,DEFAULT_ENV ; Set up default envir var name JMP > V3 V2: CALL WHOAMI ; Find out this programs'name V3: CALL GET_ENV_VAR ; Get the environment value JC > L88 ; Did we get a match? JMP LONG L888 ; Yes, we did L88: NEWLINE ; No we didn't PRINT$ 'No address given ... ABORTING' QUIT 1 ; Bad environment variable - error L888: PUSH DS PUSH ES POP DS CALL ASC_2_NUMS ; Convert the ascii to hex values POP DS MOV START_ADDR+2,AX ; That's our starting address MOV ES,040 ES ADD AX,[0F0] ; Add the last loads' space ES ADD AX,[0F2] ADD AX,010 ; Allow for psp MOV LOAD_BLOCK,AX ; This is out new loading address SUB AX,010 ; Remove psp allowance NEWLINE ; Starting load message PRINT$ 'Loading ' POP DI MOV B[DI-1],'$' ; Make printable PRINT FILE_STRING ; And print it PRINT$ 'at segment ' PRINT_REG AX ; Print segment address LEA BX,LOAD_BLOCK ; Where we load PUSH ES PUSH DS POP ES MOV AH,04B ; Dos exec function MOV AL,3 ; Load but don't execute INT 021 ; Do it POP ES MOV AX,[LOAD_BLOCK] ; Loading address again SUB AX,010 ; Allow for psp MOV START_ADDR + 2,AX ; Stuff it away MOV LOAD_POINT,AX ; And here MOV LP_PLUS_BYTES,AX ; And here, too MOV ES,AX ; Segment of where tsr is loaded MOV CX,0100 ; Going to transfer 256 bytes XOR SI,SI ; Of the psp (we're using the one XOR DI,DI ; We got from dos) CLD ; Set direction flag REP MOVSB ; Transfer it MOV DI,081 ; Point to com tail in new psp LEA SI,TAIL_BFR XOR AL,AL ; Count of command tail length L98: MOV AH,[SI] CMP AH,CR ; Any command tail at all? JE > L99 ES MOV [DI],AH ; If so, start transferring the INC AL ; Tsr's command tail - he might INC DI ; Need it INC SI JMP L98 L99: MOV B[SI],'$' ; Again, for dos int 21h printing NEWLINE PRINT$ 'Command tail = ' ; Printing out the supplied PRINT TAIL_BFR ; Command tail MOV B[SI],CR ; Terminate ES MOV B[DI],CR ; Terminate new tail ES MOV [080],AL ; Put in count ES MOV B[081],SPACE ; And normal space ; ; Here we start revectoring the appropriate interrupts ; MOV AH,035 ; The 'gimme address' function MOV AL,027 ; For interrupt 27h INT 021 ; Go get it MOV AX,ES ; Its segment MOV OLD_INT_27,BX ; Store offset value MOV (OLD_INT_27 + 2),AX ; Store segment value LEA DX,NEW_INT27 ; Where we're going to point to MOV AH,025 ; Tell dos about it MOV AL,027 ; For int 27h INT 021 ; Do it MOV AH,035 ; Get address function again MOV AL,021 ; This time for int 21h INT 021 ; Do it MOV AX,ES MOV OLD_INT_21,BX ; Save offset MOV (OLD_INT_21 + 2),AX ; And segment LEA DX,NEW_INT21 ; Point to my routine MOV AH,025 ; And tell dos MOV AL,021 INT 021 MOV AX,[START_ADDR+2] ; Get address of routine MOV ES,AX ; Set up registers MOV DS,AX ; But don't change stack reg (ss)!! CS JMP D[START_ADDR] ; And execute the program ;... ; ; This is the end of the regular program. We exit when the TSR executes ; and INT 27H or an INT 21H with function 31H. ; ; The following are the various subroutines used ; ; routine to compare two 32-bit quantities ; if BX:CX > DX:AX, carry bit is set ; if BX:CX < DX:AX, carry bit is cleared ; if BX:CX = DX:AX, zero flag is set ; ; all registers unchanged ; CMP_32: CMP BX,DX JAE > L0 JMP > L1 L0: JA > L2 CMP CX,AX JB > L1 L2: STC RET L1: CLC RET ;..... ; ; Routine to form 32-bit sum of (typically) a segment and offset pair ; ; enter with "segment" value in DX, "offset" in AX ; returns with sum in DX:AX ; ; all other registers restored ; ADD_SEG_OFF: PUSH BX,CX XOR BX,BX MOV CX,4 L0: SHL BX,1 SHL DX,1 ADC BX,0 LOOP L0 ADD AX,DX ADC BX,0 MOV DX,BX POP CX,BX RET ;..... ; ; Routine to convert a HEX digit to a two byte word containing the ; equivalent ASCII characters ; ; Enter with the byte to be converted in AL ; Return with the ASCII string in AX in 'backwords' format ; i.e., an AL value of 47 would return AX = 3734 ; so a MOV W[SI],AX for example would store the values ; in memory in the proper order ; ; All other registers restored ; ; This is essentially identical to the macro MAKE_HEX_ASCII ; except the macro does not interchange AH and AL ; HEX2PRNT: XOR AH,AH ; Zero out upper half AAM 16 ; Split into two ADD AX,03030 ; Make ASCII CMP AH,039 ; Check for a - f IF A ADD AH,7 CMP AL,039 IF A ADD AL,7 XCHG AH,AL ; Put in proper order RET ; For a MOV innstruction ;..... ; ; Routine to find out the program name. ; no parameters on entry. ; return with SI pointing to a string containing the file name ; with no extent or period. ; the string is terminated with a 0. ; all registers (except SI) are restored ; WHOAMI: JMP > L0 MY_NAME: DB 9 DUP (0) L0: PUSH AX PUSH BX PUSH CX PUSH ES PUSH DI MOV BX,[02C] ; Get seg addr of env MOV ES,BX ; Put in es XOR DI,DI ; Zero out di XOR AX,AX ; Looking for double zeros MOV CX,08000 ; Max environment length = 32k CLD ; Set direction flag L3: REPNE SCASB ; Look for zero ES MOV BX,W[DI-1] CMP BX,0 ; Got two bytes of zero? JNE L3 MOV AL,'.' REPNE SCASB ; Looking for extent MOV BX,DI ; Save end of string pointer L6: ES MOV AL,[DI] CMP AL,'\' JE > L7 CMP AL,0 JE > L7 DEC DI JMP L6 L7: MOV SI,DI INC SI ; Point to first byte of asciiz LEA DI,MY_NAME ; Will store it in this segment L2: ES MOV AH,[SI] CMP AH,'.' JE > L1 MAKE_CAP AH ; Make sure all names are capitals MOV [DI],AH INC DI INC SI JMP L2 L1: LEA SI,MY_NAME POP DI POP ES POP CX POP BX POP AX RET ;..... ; ; Routine to find a match between a given string and an environment ; variable. ; ; Enter with DS:SI pointing to a string, terminated by a 0, ; which contains the string to be matched. ; ; Returns with SI pointing to the end of the matching ; string in in the environment. ; ; The environment variables are of the form NAME=string ; This routine returns SI pointing to the string, just ; after the equal sign. ; ; ES points to the environment segment on return ; ; If a matching string is found, the carry bit will be ; clear. If no match is found, the carry will be set. ; ; All other registers are restored; SI not guaranteed. ; GET_ENV_VAR: JMP > L0 STRING_COUNT: DW 0 L0: PUSH AX PUSH CX PUSH DI XOR CX,CX ; Zero out counter PUSH SI ; Save pointer L1: MOV AL,[SI] CMP AL,0 ; At end of string? JE > L2 INC SI ; Bump pointer INC CX ; Bump counter JMP L1 L2: CS MOV STRING_COUNT,CX ; Save counter POP SI ; Restore pointer CALL GET_ENV_LENGTH ; Get length of environment MOV CX,AX ; Set up count XOR DI,DI ; Start at beginning MOV AX,[02C] ; Environment segment MOV ES,AX CLD ; Scan forward MOV AL,[SI] ; Look for first letter L3: REPNE SCASB ; Scan for it DEC DI ; Back off to point to match JCXZ > L99 ; Get out if not there PUSH CX ; Save counter CS MOV CX,[STRING_COUNT] PUSH SI ; Save my old place REPE CMPSB ; See if they're all equal POP SI ; Restore my place JZ > L4 POP CX ; No match, so carry on JMP L3 L99: STC ; Set the carry JMP > L5 L4: POP CX ; Clear stack MOV SI,DI ; Put pointer in si INC SI ; Skip past equal sign CLC ; Clear carry L5: POP DI POP CX POP AX RET ;..... ; ; Routine to find length of environment ; ; IF CARRY IS CLEAR, RESULT RETURNED IN AX ; IF CARRY IS SET, ERROR CONDITION ; ; IN EITHER EVENT, ALL REGISTERS OTHER THAN AX ARE RESTORED ; GET_ENV_LENGTH: PUSH CX PUSH ES PUSH DI MOV AX,[02C] ; Get segment of environment MOV ES,AX XOR DI,DI ; Start at beginning of env MOV CX,08000 ; Maximum env string = 32k L9: ES MOV AX,W[DI] CMP AX,0 JE > L0 INC DI LOOP L9 JCXZ >L1 ; If cx=0, we're in big trouble L0: MOV AX,DI ; Si is length of env - put it in ax CLC ; Clear carry bit - result ok JMP > L2 L1: STC ; Set the carry - error L2: POP DI POP ES POP CX RET ;..... ; ; Routine to convert a 2-digit ASCII pair into a hex number e.g., ; convert 3741 into 7A. ; ; Enter with the ASCII pair in AX, return with the hex digit ; in AL ; ; If all is well, the carry bit is clear ; If the carry bit is set, at least one of the proposed digits ; was not in the range (0-9) snd (A-F) (Routine accepts small ; letters and makes them caps) ; ; All other registers unaffected. ; ASC_2_HEX: XCHG AH,AL CMP AH,039 JBE > L0 AND AH,0DF ; Make caps CMP AH,'F' JA > L3 SUB AH,7 L0: CMP AH,030 JB > L3 CMP AL,039 JBE > L1 AND AL,0DF CMP AL,'F' JA > L3 SUB AL,7 L1: CMP AL,030 JB > L3 SUB AX,03030 UNSPLIT CLC RET L3: STC RET ;..... ; ; Routine to convert a 4-digit ASCII number representation into a ; 4-digit hex number e.g., 31374230 -> 17B0 ; ; Enter with DS:SI pointing to the string. ; Return with the number in AX, in the proper order ; i.e., 31374230 -> AH = 17, AL = B0 ; ; Carry bit set indicates bad ASCII number (out of range) see above ; ASC_2_NUMS: PUSH BX MOV AX,W[SI] CALL ASC_2_HEX JC > L1 MOV BX,AX MOV AX,W[SI+2] CALL ASC_2_HEX JC > L1 MOV AH,BL POP BX CLC L1: RET ;..... ; ; Routine to convert a 32-bit number to a decimal ASCII string enter ; with the number to be converted in DX:AX and DI pointing to the last ; byte of the result string area. Return with DI pointing to first ; non-zero character of resultant conversion. ; ; BX, CX, and SI unchanged ; ; This routine was cribbed from FREE by Art Merrill - I don't really ; understand it all, but it works! ; LARGE_HEX_TO_ASCII: PUSH BX PUSH CX XCHG CX,DX MOV BX,10 L1: CMP CX,0 JE > L2 XCHG AX,CX XOR DX,DX DIV BX XCHG AX,CX DIV BX OR DL,030 MOV [DI],DL DEC DI JMP L1 L2: XOR DX,DX DIV BX OR DL,030 MOV [DI],DL DEC DI CMP AX,0 JNE L2 INC DI ; Back up pointer to first char POP CX POP BX RET ; end