Category : Files from Magazines
Archive   : VOL9N10.ZIP
Filename : COMPUTE.ASM

;--------------------------------------------------------------------;
; COMPUTE * PC Magazine * Michael J. Mefford ;
; Command line five function math calculator. ;
;--------------------------------------------------------------------;

_TEXT SEGMENT PUBLIC 'CODE'
ASSUME CS:_TEXT,DS:_TEXT,ES:_TEXT,SS:_TEXT
ORG 100H
START: JMP MAIN


; DATA AREA
; ---------
SIGNATURE DB CR,SPACE,SPACE,SPACE,CR,LF

COPYRIGHT DB "COMPUTE 1.0 (C) 1990 Ziff Communications Co.",CR,LF
PROGRAMMER DB "PC Magazine ",BOX," Michael J. Mefford",CR,LF,LF,"$"
SYNTAX DB "Syntax: COMPUTE arithmetic expression",CR,LF
DB "Operators supported are + - * / % ( ) [ ] 0-9 x",CR,LF
DB "Note: % = modulo, remainder of integer division.",CR,LF
DB " x = answer of last compute."
CRLFLF DB LF
CRLF DB CR,LF
DB "$",CTRL_Z

CR EQU 13
LF EQU 10
CTRL_Z EQU 26
SPACE EQU 32
BOX EQU 254
COMMA EQU ","

INTEGER_PRECISION = 20
DECIMAL_PRECISION = 20
PRECISION = INTEGER_PRECISION + DECIMAL_PRECISION

NUMBER STRUC
SIGN DB 0
INTEGER DB INTEGER_PRECISION DUP (0)
DECIMAL DB DECIMAL_PRECISION DUP (0)
NUMBER ENDS

SIZE_MANTISSA = SIZE INTEGER + SIZE DECIMAL
SIZE_DIVIDEND = SIZE_MANTISSA + SIZE DECIMAL + 1

OPERAND DW INITIAL_VALUE
OPERATORS DB "+-"
UNARY_PREFIXES LABEL BYTE
PRECEDENCE DB "*/%"
PRECEDENCE_CNT = $ - PRECEDENCE
OPERATOR_CNT = $ - OPERATORS
DB "([",0
PREFIXES_CNT = $ - UNARY_PREFIXES

LAST_CHAR DB ?

PAREN_CNT DW 0
PAREN_TYPE DB 50 DUP (0)
WORKSPACE DB 2 * SIZE_MANTISSA DUP (?)
WORKSPACE_END EQU $ - 1
DB ? ;Dividend overflow.
DIVIDEND DB SIZE_DIVIDEND DUP (?)
ANSWER DB SIZE NUMBER DUP (0)

DECIMAL_PLACES DW 0 ;Significant decimal digits.
SAVE_SIGN DB ?
MODULO_FLAG DB 0 ; =1 if modulo division.

COMPUTE DB "COMPUTE.COM",0
COMPUTE_LEN EQU $ - COMPUTE
PATH DB "PATH="
PATH_LEN EQU $ - PATH
NOT_FOUND DB CR,LF,"Could not save answer in Compute.com",CR,LF
DB "Compute.com must be in current directory",CR,LF
DB "or in DOS PATH= directory.",CR,LF,"$"
RESULT_MSG DB "Result is $"
UNRECOGNIZED DB "Unrecognized character$"
MISSING_PAREN DB "Missing parenthesis or bracket$"
UNMATCHED DB "Miss-matched parenthesis with bracket$"
ZERO_DIVIDE DB "Divide by zero$"
OVERFLOW DB "Overflow$"
LOGICAL DB "Logic error$"
MEMORY DB "Requires 10K of memory$"
ERROR1 DB "Error ^",CR,LF,"$"
ERROR2 DB "^ Error$",CR,LF,"$"


; CODE AREA
; ---------
MAIN PROC NEAR
CLD ;Strings forward.

MOV DX,OFFSET SIGNATURE ;Announce ourselves.
CALL PRINT_STRING

MOV BX,10 / 16 * 1024 ;Minimum of 10K required.
MOV AH,4AH ;Request via DOS.
INT 21H
MOV DX,OFFSET MEMORY
JC ERROR_EXIT ;Exit with message if not enough.

MOV SP,16 * 1024 - 2 ;Else, setup stack at end of seg.

MOV SI,81H ;Point to command line.
XOR AX,AX ;No characters yet.
XOR DX,DX ;Not unary.
CALL PARSE ;Parse command line.
CALL PARSE_DELIMIT ;See if reached end.
MOV DX,OFFSET LOGICAL ;If not, logical error.
JNC ERROR_EXIT

CMP OPERAND,OFFSET INITIAL_VALUE
JNZ CK_PARENS
MOV DX,OFFSET SYNTAX ;Did we get a value.
CALL PRINT_STRING ;If not, print syntax and exit.
JMP SHORT ERROR_END

CK_PARENS: MOV DX,OFFSET MISSING_PAREN
CMP PAREN_CNT,0 ;Did we match all parenthesis
JNZ ERROR_EXIT ; and brackets?

CALL RESULT ;Every thing seems OK so
; display result.
EXIT: MOV AX,4C00H ;Exit with ErrorLevel=0
INT 21H
MAIN ENDP

;----------------------------------------------;
ERROR_EXIT: PUSH DX ;Save error message.
MOV DX,OFFSET SYNTAX ;Display syntax.
CALL PRINT_STRING
POP DX
CALL PRINT_STRING ;Display error.
MOV DX,OFFSET CRLFLF
CALL PRINT_STRING
MOV BX,SI ;Current command line pointer.
MOV SI,81H ;Point at start of command line.
CLD ;Make strings are forward.

NEXT_LINE: MOV CX,79 ;1 less than 80 char. display.
NEXT_ERROR: LODSB
CMP AL,CR ;End of command line?
JZ PRINT_POINTER
CALL PRINT_CHAR ;If no, print character.
CMP SI,BX ;Pointing to error position?
JZ PRINT_POINTER ;If yes, done here.
LOOP NEXT_ERROR ;Else, continue.
MOV DX,OFFSET CRLF ;Filled on line; new line.
CALL PRINT_STRING
JMP NEXT_LINE

PRINT_POINTER: MOV DX,OFFSET CRLF ;New line.
CALL PRINT_STRING
SUB CX,79 ;Calculate chars. on line above.
NEG CX
MOV BX,OFFSET ERROR1 ;Assume left side of display.
CMP CX,40
JB LEFT_ARROW
SUB CX,6
JMP SHORT NEXT_SPACE
LEFT_ARROW: MOV BX,OFFSET ERROR2

NEXT_SPACE: MOV AL,SPACE ;Pad with spaces over to error.
CALL PRINT_CHAR
LOOP NEXT_SPACE
MOV DX,BX ;Display "Error ^".
CALL PRINT_STRING

ERROR_END: MOV AX,4C01H ;Exit with ErrorLevel = 1.
INT 21H

;----------------------------------------------;
; Recursive parsing routine. ;
;----------------------------------------------;
PARSE: PUSH BP ;Preserve stack index.
PUSH DX ;Unary flag.
PUSH AX ;Operator.
MOV BP,SP ;Point to local vars.
NEXT_PARSE: CALL PARSE_DELIMIT ;Parse white space.
JNC GET_CHAR ;If command line end, exit.
JMP PARSE_END

GET_CHAR: LODSB ;Else, get the character.
MOV DI,OFFSET OPERATORS ;Is it a function operator?
MOV CX,OPERATOR_CNT
REPNZ SCASB
JNZ CK_NUM ;If no, check if number.

XOR DL,DL ;Assume not unary.
CMP AL,"+" ;Is it plus or minus?
JZ CK_UNARY
CMP AL,"-"
JNZ GET_OPERAND2 ;If no, not unary.
CK_UNARY: PUSH AX
MOV AL,LAST_CHAR ;Else, does previous char
MOV DI,OFFSET UNARY_PREFIXES ; suggest unary?
MOV CX,PREFIXES_CNT
REPNZ SCASB
POP AX
JNZ GET_OPERAND2
INC DL ;If yes, it's unary.

GET_OPERAND2: PUSH WORD PTR LAST_CHAR ;Save last char.
MOV LAST_CHAR,AL ;Store current char.
PUSH OPERAND ;Save operand pointer.
CALL PARSE ;Get second operand.
POP BX ;First operand.
POP CX ;Last character.
MOV DH,AL ;Save operator.
MOV DI,OPERAND ;Second operand.
MOV AL,[DI] ;Get signs.
MOV AH,[BX]
CMP DH,"*" ;Check which operator.
JZ DO_MULT
CMP DH,"/"
JZ DO_DIV
CMP DH,"%"
JZ DO_MOD
;Must be plus or minus.
OR DL,DL ;Was it unary.
JZ DO_ADD ;If no, add operands.
MOV AL,CL ;Else, was last character
CALL CK_PRECEDENCE ; "*", "/" or "%" ?
JNZ NEXT_PARSE ;If no, just continue parsing.
JMP PARSE_END ;Else, return second operand.

DO_ADD: CALL ADD_IT ;Add operands.
MOV AL,LAST_CHAR
CMP AL,")" ;Is this an equantity?
JZ PARSE_DONE ;Is yes, return it.
CMP AL,"]"
JZ PARSE_DONE
JMP NEXT_PARSE ;Else, continue parsing.

DO_MULT: CALL MULTIPLY
JMP NEXT_PARSE

DO_DIV: CALL DIVIDE
JMP NEXT_PARSE

DO_MOD: CALL MODULO
JMP NEXT_PARSE

PARSE_DONE: JMP PARSE_END ;Lilly pad for return.

CK_NUM: MOV LAST_CHAR,AL ;Store current character.
CMP AL,"X" ;Is it "answer" character?
JZ DO_ANS
CMP AL,"x"
JNZ CK_DIGIT
DO_ANS: PUSH SI
MOV SI,OFFSET ANSWER ;If yes copy answer to operand.
ADD OPERAND,SIZE NUMBER ;Point to next operand storage.
MOV DI,OPERAND
PUSH DI
MOV CX,SIZE NUMBER
REP MOVSB
POP DI
MOV AL,[BP] ;Get sign
CMP AL,"-"
JZ ANS_SIGN
XOR AL,AL ; and store.
ANS_SIGN: XOR [DI],AL
POP SI
JMP SHORT CK_UNARY_NUM ;Check if return or not.

CK_DIGIT: CMP AL,"." ;Is char a num char?
JZ DO_NUM
CMP AL,"0"
JB CK_PAREN
CMP AL,"9"
JA CK_PAREN
DO_NUM: DEC SI ;If yes, point to it.
ADD OPERAND,SIZE NUMBER ;Point to next operand storage.
CALL GET_NUMBER ;Get the number.
CK_UNARY_NUM: CMP BYTE PTR [BP + 2],1 ;Is this a unary number?
JZ PARSE_END ;If yes, return the number.
MOV AL,[BP] ;Get operator.
CALL CK_PRECEDENCE ;If high precedence, go do it.
JZ PARSE_END
JMP NEXT_PARSE ;Else, continue parsing.

CK_PAREN: MOV AH,")"
CMP AL,"(" ;Is it an open parenthesis
JZ FOUND_PAREN ; or bracket?
CMP AL,AH
JZ CK_OPEN
MOV AH,"]"
CMP AL,"["
JZ FOUND_PAREN
CMP AL,AH ;Was it a close parenthesis or
MOV DX,OFFSET UNRECOGNIZED ; or bracket?
JNZ PARSE_ERROR ;If no, must be invalid char.

CK_OPEN: DEC PAREN_CNT ;If close, decrement level.
MOV DX,OFFSET MISSING_PAREN ;If overflow then had no
JC PARSE_ERROR ; open.
MOV BX,PAREN_CNT ;Retrieve level index
MOV PAREN_TYPE[BX],AH ; and store close type.
JMP SHORT PARSE_END ;Return results.

FOUND_PAREN: PUSH PAREN_CNT ;Save level index.
INC PAREN_CNT ;Next level.
XOR DX,DX ;Not unary flag.
CALL PARSE ;Parse the equantity.
POP BX ;Retrieve level.
CMP AH,PAREN_TYPE[BX] ;Did we close with matching
MOV DX,OFFSET UNMATCHED ; parenthesis or bracket?
JNZ PARSE_ERROR
MOV AL,[BP] ;Retrieve, prefix operator.
CALL CK_PRECEDENCE ;Was it priority operator?
JZ PARSE_END ;If yes, return value.
CMP AL,"-" ;Else store sign.
JNZ PAREN_END
MOV BX,OPERAND
XOR [BX],AL
PAREN_END: JMP NEXT_PARSE ;And parse next.

PARSE_END: POP AX
POP DX
POP BP
RET

PARSE_ERROR: JMP ERROR_EXIT
RET

;-------------------------------------------------------------------;
; INPUT: SI -> string ;
; OUTPUT SI -> first non-white space and CY=0 or SI -> CR and CY=1. ;
;-------------------------------------------------------------------;
PARSE_DELIMIT: LODSB ;Get a byte.
CMP AL,CR
JZ STRING_END
CMP AL,SPACE ;Is it a space char or below?
JBE PARSE_DELIMIT
DEC SI ;Else, adjust pointer to
CLC
RET ; string start.

STRING_END: DEC SI
STC
RET

;----------------------------------------------;
CK_PRECEDENCE: MOV DI,OFFSET PRECEDENCE
MOV CX,PRECEDENCE_CNT
REPNZ SCASB
RET

;----------------------------------------------;
GET_NUMBER: MOV DI,OFFSET WORKSPACE ;Store integer temporarily
MOV CX,SIZE INTEGER + 1 ; so can store right justified.
NEXT_INTEGER: LODSB
CMP AL,COMMA ;Ignore commas.
JZ NEXT_INTEGER
CMP AL,"." ;Decimal point; end of integer.
JZ STORE_INTEGER

GET_NUM2: SUB AL,"0"
JC INTEGER_END
CMP AL,9
JA INTEGER_END
STOSB ;Store the number.
LOOP NEXT_INTEGER
MOV DX,OFFSET OVERFLOW ;If got here, number too big.
JMP ERROR_EXIT

INTEGER_END: DEC SI
STORE_INTEGER: PUSH SI ;Save command line pointer.
MOV SI,DI
DEC SI ;End of workspace.
PUSHF
STD
MOV DI,OPERAND
ADD DI,SIZE INTEGER

MOV DX,CX
DEC DX ;Zero pad count.

NEG CX
ADD CX,SIZE INTEGER + 1
JCXZ PAD_INTEGER
REP MOVSB ;Store integer part in operand.

PAD_INTEGER: MOV CX,DX
JCXZ INTEGER_DONE
XOR AL,AL
REP STOSB ;Pad balance of integer with 0.
INTEGER_DONE: MOV AL,[BP] ;Get sign
CMP AL,"-"
JZ INT_SIGN
XOR AL,AL ; and store.
INT_SIGN: STOSB
POPF


DO_DECIMAL: POP SI ;Restore command line pointer.

MOV DI,OPERAND
ADD DI,SIZE SIGN + SIZE INTEGER ;Decimal operand storage.
MOV CX,SIZE DECIMAL + 1 ;Left justified.
XOR DX,DX ;Decimal counter.
NEXT_DECIMAL: LODSB
SUB AL,"0"
JC DECIMAL_END
CMP AL,9
JA DECIMAL_END
STOSB
INC DX ;Increment decimal count.
LOOP NEXT_DECIMAL
MOV DX,OFFSET OVERFLOW ;If got here, number too big.
JMP ERROR_EXIT

DECIMAL_END: DEC SI ;Adjust command line pointer.
CMP DX,DECIMAL_PLACES ;Store significant decimal
JBE PAD_DECIMAL ; places.
MOV DECIMAL_PLACES,DX

PAD_DECIMAL: DEC CX ;Pad balance with zeros.
JCXZ DECIMAL_DONE
XOR AL,AL
REP STOSB
DECIMAL_DONE: RET

;----------------------------------------------;
; INPUT: BX -> 1st and AH=sign; DI -> 2nd and AL=sign.
; OUTPUT: Result stored in DI.

ADD_IT: PUSHF
PUSH SI
STD ;Add or subtract right to left.
MOV SAVE_SIGN,0 ;Assume sign positive.

MOV DX,BX ;Save operand 2 pointer.
MOV CX,SIZE_MANTISSA ;Point to end of operands.
ADD DI,CX
ADD BX,CX
MOV SI,BX

CMP AL,AH ;If both plus or minus, then
JZ ADD_SIGN ; go ahead and add, else subtract
CMP AL,"-" ;If first operand
JZ SUB_IT ; negative and second positive
XCHG DI,SI ; swap operands before subtract.
MOV OPERAND,DX

SUB_IT: MOV BX,DI ;Save destination operand.
CLC ;Start with no carry.
NEXT_SUB: LODSB ;Get operand1
SBB AL,[DI] ;Subtract operand2 and the carry.
AAS ;ASCII adjust after subtraction.
STOSB ;Store it.
LOOP NEXT_SUB ;Subtract next byte.
MOV AL,0 ;If no carry, then positive.
JNC STORE_SIGN

MOV DI,BX ;Else negative so negate by
CLC ; subtracting result from zero.
MOV CX,SIZE_MANTISSA
NEXT_NEGATE: MOV AL,CH ;Zero.
SBB AL,[DI] ;Subtract the byte.
AAS ;ASCII adjust after subtraction.
STOSB ;Store it.
LOOP NEXT_NEGATE
MOV AL,"-" ;Store negative sign.
JMP SHORT STORE_SIGN

; Add procedure.
;----------------------------------------------;
ADD_SIGN: MOV SAVE_SIGN,AL ;Either 2 +'s or 2 -'s; save it.
CLC ;Start with no carry.
NEXT_ADD: LODSB
ADC AL,[DI] ;Add operand two and carry.
AAA ;ASCII adjust.
STOSB
LOOP NEXT_ADD
JC ADD_ERROR ;If carry out of number, overflow
MOV AL,SAVE_SIGN ;Else, store sign.

STORE_SIGN: STOSB
POP SI
POPF
RET

ADD_ERROR: MOV DX,OFFSET OVERFLOW
POP SI
JMP ERROR_EXIT

;----------------------------------------------;
; INPUT: BX -> 1st and AH=sign; DI -> 2nd and AL=sign.
; OUTPUT: Result stored in DI.

MULTIPLY: PUSH BP
PUSHF
PUSH SI
XOR DL,DL ;Assume plus result.
CMP AL,AH ;Signs the same?
JZ MULT_SIGN ;If yes, assumed right.
MOV DL,"-" ;Else, negative.
MULT_SIGN: MOV SAVE_SIGN,DL

STD ;Right to left.
ADD DI,SIZE_MANTISSA ;Point to end of numbers.
ADD BX,SIZE_MANTISSA
MOV BP,DI ;Save destination.

MOV DI,OFFSET WORKSPACE_END
MOV DX,DI
XOR AX,AX ;Zero out scratch pad area.
MOV CX,SIZE WORKSPACE
REP STOSB

MOV DI,DX ;Point to workspace.
MOV CX,SIZE_MANTISSA ;Number of digits to multiply.

NEXT_MULT: PUSH DI ;Save current product place.
MOV AL,[BX] ;Current multiplier digit zero?
OR AL,AL
JZ LOOP_MULT ;If yes, no need to multiply.

PUSH CX ;Else, save multiplier counter.
MOV CX,SIZE_MANTISSA ;Size of multiplicand size.
MOV DL,AL ;Multiplier.
MOV SI,BP ;Multiplicand pointer.
XOR DH,DH ;No carry yet.

NEXT_MULT2: LODSB
MUL DL ;Multiply them.
AAM ;Adjust BCD multiplication.
ADD AL,[DI] ;Accumulate as we go.
AAA ;ASCII adjust.
ADD AL,DH ;Add the carry.
AAA ;ASCII adjust.
STOSB ;And store.
MOV DH,AH ;Save the carry.
LOOP NEXT_MULT2
MOV [DI],AH ;Store the carry.
POP CX ;Multiply by all digits.

LOOP_MULT: POP DI
DEC BX ;Next multiplier.
DEC DI ;Next product.
LOOP NEXT_MULT

MOV DI,OFFSET WORKSPACE_END - SIZE DECIMAL + 1
MOV CX,SIZE_MANTISSA
CALL ROUND ;Round up product.

MOV SI,OFFSET WORKSPACE_END - SIZE DECIMAL
MOV DI,BP ;Place decimal in product
MOV CX,SIZE_MANTISSA ; by storing in destination.
REP MOVSB
MOV AL,SAVE_SIGN ;Add the sign.
STOSB

MOV CX,SIZE INTEGER ;Check for overflow.
NEXT_OVER: LODSB
OR AL,AL
JNZ MULT_ERROR
LOOP NEXT_OVER

POP SI
POPF
POP BP
RET

MULT_ERROR: MOV DX,OFFSET OVERFLOW
POP SI
JMP ERROR_EXIT


;----------------------------------------------;
; INPUT: BX -> 1st and AH=sign; DI -> 2nd and AL=sign.
; OUTPUT: Result stored in DI.

DIVIDE: PUSH BP
PUSHF
PUSH SI
XOR DL,DL ;Assume plus result.
CMP AL,AH ;Signs the same?
JZ DIV_SIGN ;Is yes, assumed right.
MOV DL,"-" ;Else, negative.
DIV_SIGN: MOV SAVE_SIGN,DL

MOV BP,DI ;BP -> divisor.
INC BP ;Bump past sign.
MOV DI,OFFSET WORKSPACE ;Quotient scratch pad.
XOR AL,AL
MOV CX,SIZE_DIVIDEND
REP STOSB ;Zero out quotient to start.

MOV DI,OFFSET DIVIDEND - 1 ;Move dividend to scratch pad.
STOSB ;Zero in overflow byte.
MOV SI,BX ;Dividend.
INC SI ;Bump past sign.
MOV CX,SIZE_MANTISSA
REP MOVSB
MOV CX,SIZE_DIVIDEND - SIZE_MANTISSA
REP STOSB ;Zero out dividend underflow.

MOV DI,BP ;Look for zero divisor.
MOV CX,SIZE_MANTISSA
REPZ SCASB
JNZ DIVISOR_SIZE
MOV DX,OFFSET ZERO_DIVIDE ;Can't divide by zero.
POP SI ;Command line pointer.
JMP ERROR_EXIT

DIVISOR_SIZE: MOV DI,OFFSET WORKSPACE ;Quotient.
ADD DI,CX ;Point to first quotient storage.
ADD BP,SIZE_MANTISSA - 1
SUB BP,CX ;First non-zero divisor digit.
INC CX ;DH = subtraction counter.
MOV DX,CX ;DL = significant divisor digits.
MOV SI,OFFSET DIVIDEND
MOV CX,SIZE_DIVIDEND + 1
SUB CX,DX ;Number of times to divide.

NEXT_DIVIDE: CMP MODULO_FLAG,1 ;Is this a modulo division?
JNZ NO_MODULO
CMP DI,OFFSET WORKSPACE + SIZE_MANTISSA
JAE DIVIDE_END ;If yes, divide integer only.

NO_MODULO: PUSH CX ;Division count.
PUSH DI ;Quotient.
MOV BX,SI ;Save dividend pointer.
XOR DH,DH ;Initialize sub counter to zero.

NEXT_DIVIDE2: CMP BYTE PTR [SI - 1],0 ;Overflow in remainder?
JNZ SUB_DIVISOR ;If yes, divisor fits.
MOV CL,DL ;Divisor length.
XOR CH,CH ;Zero high half.
MOV DI,BP ;Divisor.
NEXT_DIV: CMPSB ;Does it fit in remainder?
JA SUB_DIVISOR ;If yes, subtract.
JB DIV_TOO_BIG ;If no, save subtraction count.
LOOP NEXT_DIV

SUB_DIVISOR: INC DH ;Sub counter.
MOV SI,BP ;Divisor position.
MOV DI,BX ;Dividend position.
MOV CL,DL ;Significant divisor digits.
XOR CH,CH ;Zero in high half.
DEC CX ;Adjust for a moment.
ADD SI,CX ;Point to current position.
ADD DI,CX
INC CX

STD ;Subtract right to left.
CLC ;Start with no carry.
NEXT_DIV_SUB: LODSB
MOV AH,AL ;Divisor digit.
MOV AL,[DI] ;Remainder digit.
SBB AL,AH ;Subtract.
AAS ;ASCII adjust. (BCD)
STOSB ;Store in dividend.
LOOP NEXT_DIV_SUB
SBB BYTE PTR [DI],0 ;Subtract the carry, if any.

CLD ;Back to forward.
MOV SI,BX
JMP NEXT_DIVIDE2 ;Next divisor.

DIV_TOO_BIG: MOV SI,BX ;Next dividend.
POP DI
POP CX
MOV AL,DH ;Store quotient.
STOSB
INC SI
LOOP NEXT_DIVIDE

MOV DI,OFFSET WORKSPACE + SIZE_DIVIDEND - 1
MOV CX,SIZE_MANTISSA
STD
CALL ROUND ;Round quotient.
JC DIVIDE_ERROR

MOV CX,SIZE_MANTISSA
MOV SI,OFFSET WORKSPACE + SIZE_DIVIDEND - 2
MOV DI,OPERAND ;Store quotient in operand.
ADD DI,CX
REP MOVSB
MOV AL,SAVE_SIGN ;Add the sign.
STOSB

MOV CX,SIZE DECIMAL ;Check for overflow.
NEXT_OVER2: LODSB
OR AL,AL
JNZ DIVIDE_ERROR
LOOP NEXT_OVER2

DIVIDE_END: POP SI
POPF
POP BP
RET

DIVIDE_ERROR: MOV DX,OFFSET OVERFLOW
POP SI
JMP ERROR_EXIT

;----------------------------------------------;
; INPUT: BX -> 1st and AH=sign; DI -> 2nd and AL=sign.
; OUTPUT: Result stored in DI.

MODULO: PUSH AX ;Save sign of dividend.
PUSH DI ;Divisor pointer.
ADD DI,SIZE INTEGER + 1
MOV CX,SIZE INTEGER
STD
CALL ROUND ;Round divisor.
JC MODULO_ERROR
POP DI
PUSH DI
CALL MAKE_INTEGER ;Truncate to integer.

MOV DI,BX
ADD DI,SIZE INTEGER + 1
MOV CX,SIZE INTEGER
CALL ROUND ;Round dividend.
JC MODULO_ERROR
MOV DI,BX
CALL MAKE_INTEGER ;Truncate to integer.

POP DI
MOV MODULO_FLAG,1 ;Do modulo division.
CLD
CALL DIVIDE
MOV MODULO_FLAG,0
MOV DI,OPERAND
POP AX ;Sign of dividend.
MOV AL,AH
STOSB ;Store it.
PUSH SI
MOV SI,OFFSET DIVIDEND ;Dividend has remainder.
MOV CX,SIZE_MANTISSA
REP MOVSB ;Store it in operand.
POP SI
RET

MODULO_ERROR: MOV DX,OFFSET OVERFLOW
JMP ERROR_EXIT

;----------------------------------------------;
; INPUT: DI -> Start of mantissa.

MAKE_INTEGER: PUSHF
CLD
ADD DI,SIZE INTEGER + 1
MOV CX,SIZE DECIMAL
XOR AL,AL
REP STOSB
POPF
RET

;----------------------------------------------;
; INPUT: DI -> End of mantissa + 1; Direction flag reversed.
; CX = number of bytes to round.
; OUTPUT: CY=1 if overflow.

ROUND: CMP BYTE PTR [DI],5 ; 5 or greater?
JB ROUND_DONE ;If no, done here.
DEC DI ;Else, move left one digit.
STC ;Start with carry.
NEXT_ROUND: MOV AL,[DI]
ADC AL,0 ;Add carry.
AAA ;ASCII adjust.
STOSB
JNC ROUND_END ;If no carry, done.
LOOP NEXT_ROUND
JMP SHORT ROUND_END
ROUND_DONE: CLC ;Return overflow.
ROUND_END: RET

;----------------------------------------------;
RESULT: MOV DX,OFFSET RESULT_MSG ;Display "Result is ".
CALL PRINT_STRING
MOV SI,OPERAND ;Point to result.
LODSB
OR AL,AL ;Print sign if negative.
JZ PRINT_INTEGER
CALL PRINT_CHAR

PRINT_INTEGER: XOR DH,DH ;Non-zero digit flag.
MOV BL,3 ;Comma every third digit.
MOV CX,INTEGER_PRECISION
JMP SHORT NEXT_INT2 ;Skip prefacing comma.

NEXT_INT: OR DH,DH ;Non-zero digit yet?
JZ NEXT_INT2 ;If no, skip.
MOV AX,CX ;Is position MOD 3 = 0?
DIV BL
OR AH,AH
JNZ NEXT_INT2 ;If no, no comma.
MOV AL,"," ;Else, delimiting comma.
CALL PRINT_CHAR

NEXT_INT2: LODSB
OR AL,AL ;Is digit zero?
JNZ PRINT_INT ;If no, print it.
OR DH,DH ;Else, non-zero digit yet?
JZ LOOP_INTEGER ;If no, skip.
PRINT_INT: OR DH,AL
CALL PRINT_NUMBER
LOOP_INTEGER: LOOP NEXT_INT

PUSH SI ;Save pointer.
MOV CX,DECIMAL_PRECISION ;Count the significant decimal
MOV BX,CX ; places.
INC BX
NEXT_FRACTION: LODSB
OR AL,AL
JZ LOOP_FRACTION
MOV BX,CX ;If non-zero, save count.
LOOP_FRACTION: LOOP NEXT_FRACTION
POP SI ;Restore pointer.
NEG BX ;Get count of significant.
ADD BX,DECIMAL_PRECISION + 1
MOV CX,DECIMAL_PLACES ;Use the larger of significant
CMP CX,BX ; digits; number entered or
JAE DO_FRACTION ; result.
MOV CX,BX

DO_FRACTION: JCXZ CK_NULL ;If no significant, done here.
OR DH,DH ;Else, was there a non-zero
JNZ PRINT_DECIMAL ; integer?
XOR AL,AL ;If no, preface with zero.
CALL PRINT_NUMBER
PRINT_DECIMAL: MOV AL,"." ;Display delimiting decimal.
CALL PRINT_CHAR

XOR BL,BL ;Comma counter.
NEXT_DEC: CMP BL,3
JNZ NEXT_DEC2
MOV AL,","
CALL PRINT_CHAR
XOR BL,BL
NEXT_DEC2: LODSB ;Display decimal digits.
CALL PRINT_NUMBER
INC BL
LOOP_DEC: LOOP NEXT_DEC
JMP SHORT RESULT_END

CK_NULL: OR DH,DH ;Was there a non-zero integer?
JNZ RESULT_END ;If yes, done here.
XOR AL,AL ;Else, display solitary, zero.
CALL PRINT_NUMBER
RESULT_END: MOV DX,OFFSET CRLF ;New line.
CALL PRINT_STRING

;----------------------------------------------;
SAVE_ANSWER: MOV SI,OPERAND ;Copy operand to answer.
MOV DI,OFFSET ANSWER
MOV CX,SIZE NUMBER
REP MOVSB

MOV AH,30H ;Get DOS version.
INT 21H
CMP AL,3 ;Filename in environment
JB TRY_CURRENT ; not support before DOS 3.x.

MOV DS,DS:[2CH] ;Segment of environment.
XOR SI,SI
FIND_ENV_END: LODSB ;Find end of environment.
OR AL,AL
JNZ FIND_ENV_END
LODSB
OR AL,AL
JNZ FIND_ENV_END

INC SI ;Bump pointer past word count.
INC SI
MOV DI,OFFSET WORKSPACE ;Copy our name.
CALL COPY_NAME
PUSH CS
POP DS
MOV DX,OFFSET WORKSPACE ;Try to write answer.
CALL WRITE_ANS
JNC ANSWER_END

TRY_CURRENT: MOV DX,OFFSET COMPUTE ;Try current directory.
CALL WRITE_ANS
JNC ANSWER_END

; See if PATH= is in environment.
MOV DS,DS:[2CH] ;Segment of environment.
LOOK_AT_PATH: MOV BX,-1 ;Offset zero in environment.
NEXT_PATH: INC BX
MOV SI,BX
CMP BYTE PTR [SI],0 ;Terminating null?
JNZ PATH_SEARCH
CMP BYTE PTR [SI+1],0 ;Double null?
JNZ NEXT_PATH
JMP SHORT CANT_SAVE ;If so, end of environment.

PATH_SEARCH: MOV DI,OFFSET PATH ;Search for "PATH=".
MOV CX,PATH_LEN
REP CMPSB
JNZ NEXT_PATH

; PATH= found; search for paths.
NEXT_STRING: CMP BYTE PTR [SI],0 ;Terminating null?
JZ CANT_SAVE
CMP BYTE PTR [SI-1],0 ;Double null?
JZ CANT_SAVE

MOVE_STRING: MOV DI,OFFSET WORKSPACE ;Get path.
NEXT_BYTE: LODSB
OR AL,AL
JZ SEARCH_PATH
CMP AL,";"
JZ SEARCH_PATH
STOSB
JMP NEXT_BYTE

SEARCH_PATH: CALL COPY_PATH ;Create filespec.
PUSH DS
PUSH CS
POP DS
MOV DX,OFFSET WORKSPACE
CALL WRITE_ANS ;Try to write answer.
POP DS
JC NEXT_STRING ;If failed, try next path.
JMP SHORT ANSWER_END ;Else, done.

CANT_SAVE: PUSH CS
POP DS
MOV DX,OFFSET NOT_FOUND ;Answer write error message.
CALL PRINT_STRING

ANSWER_END: RET

;----------------------------------------------;
COPY_NAME: LODSB
STOSB
OR AL,AL
JNZ COPY_NAME
RET

;----------------------------------------------;
COPY_PATH: PUSH SI
PUSH DS
CMP DI,OFFSET WORKSPACE
JZ MOVE_NAME
CMP BYTE PTR ES:[DI-1],"\" ;Filespec delimiter?
JZ MOVE_NAME
CMP BYTE PTR ES:[DI-1],":"
JZ MOVE_NAME
MOV AL,"\" ;If no, add one.
STOSB

MOVE_NAME: PUSH CS
POP DS
MOV SI,OFFSET COMPUTE ;Tack on "COMPUTE.COM".
MOV CX,COMPUTE_LEN
REP MOVSB

COPY_END: POP DS
POP SI
RET

;----------------------------------------------;
; INPUT: DX -> Compute.com filespec.
; OUTPUT: CY=0 if successful; CY=1 if failed.

WRITE_ANS: PUSH SI
MOV AX,3D02H ;Open for reading and writing.
INT 21H
JC WRITE_END
MOV BX,AX
MOV DX,OFFSET WORKSPACE
MOV CX,SIZE WORKSPACE
MOV AH,3FH ;Read signature.
INT 21H
JC WRITE_END

MOV SI,100H ;Make sure we found correct
MOV DI,OFFSET WORKSPACE ; Compute.com.
REP CMPSB
STC
JNZ WRITE_END

XOR CX,CX
MOV DX,OFFSET ANSWER - 100H
MOV AX,4200H ;Seek offset of answer.
INT 21H
JC WRITE_END

MOV DX,OFFSET ANSWER
MOV CX,SIZE ANSWER
MOV AH,40H ;Write answer to disk.
INT 21H
JC WRITE_END

MOV AH,3EH ;Close file.
INT 21H
WRITE_END: POP SI
RET

;----------------------------------------------;
PRINT_NUMBER: ADD AL,"0" ;Binary to ASCII.
PRINT_CHAR: MOV DL,AL
MOV AH,2 ;Print char via DOS.
INT 21H
RET

;----------------------------------------------;
PRINT_STRING: MOV AH,9 ;Print string via DOS.
INT 21H
RET

;----------------------------------------------;
; HEAP

INITIAL_VALUE NUMBER <>

_TEXT ENDS
END START