; GetShow.asm
; A package of 2 assembler procedures for performing decimal IO
; with the keyboard and a DOS window, written by Alan T. Pinck.
;
; Unlike Alan's original code, in this version no newlines or carriage
; returns are added. You will need to add them yourself to format your
; output nicely. -IAN!
;
; getNum accepts keyboard input and assuming
; decimal characters representing a decimal number
; in the range 0 to 9999, converts the input
; into a binary number which is returned in
; the AX register. Leading whitespace is skipped.
; getNum returns with the Carry flag off if
; it was successful and with the Carry flag on
; if it was not (if the keyboard input did not
; start with something that could be interpretted
; as a number, or if the number exceeds 4 digits)
;
; showNum displays the contents of AX (assumed to be
; a number in 2's complement form) as a decimal value
;
; This file must be INCLUDEd
; in any source file that uses the subroutines:
;
; INCLUDE getshow.asm
;
; Original by Alan T. Pinck; modified by Ian Allen April 2000
; -Ian! D. Allen - idallen@idallen.ca - www.idallen.com
;
;--- data which is local to this package ---
diolastc db 00
dionum dw ?
dionewl db 0Dh,0Ah,"$"
;==========================================
; showNum displays the 2's complement number
; in AX as a decimal number
;
showNum proc near
push ax ;save working registers
push bx
push cx
push dx
;X Ian! removed the newline output here:
;X push ax
;X mov dx,offset dionewl ;ensure display is on a newline
;X mov ah,09
;X int 21h
;X pop ax
cmp ax,0 ;test for negative
jge positive;skip ahead if positive
mov ah,02h ;display character code
mov dl,'-' ; minus sign
int 21h
mov bx,ax
sub ax,bx ;ax now zero
sub ax,bx ;ax now positive
positive:
mov bx,10 ;divide by 10 (decimal!) to convert to decimal
mov cl,0 ;count of number of digits produced
div_loop:
mov dx,0 ;setup to divide dx|ax by bx
idiv bx ;unsigned division:
;quotient in ax, remainder in dx
push dx ;save the digit (remainder)
inc cl ;keep track of number of digits
cmp ax,0 ;until nothing left to divide
jnz div_loop; loop back
show_digit:
pop dx
add dl,30h ;convert digit to ASCII code
mov ah,02h ;display character
int 21h
dec cl ;loop until all digits shown
jnz show_digit
pop dx ;restore working registers
pop cx
pop bx
pop ax
ret
showNum endp
;==========================================
; getNum returns number input (converted to
; binary) in ax
; input is assumed to be a positive, decimal
; value with a maximum of 4 digits, terminated
; with an ASCII non-digit code
; Carry flag is set (on) if an input error is
; detected (Carry flag is clear (off) if the
; input is valid
getNum proc near
push bx ;save working registers
push cx
push dx
mov dionum,0
mov bh,'9' ;setup for valid range testing
mov bl,'0'
mov cl,4 ;maximum number of digits acceptable
mov al,diolastc
cmp al,00 ;check if we no previous char available
jne gotchar ; skip input if one already here
skipwhite:
mov ah,01h ;input a char
int 21h
gotchar:
mov diolastc,al ;skip over leading blanks and
cmp al,20h
je skipwhite
cmp al,0Dh ;carriage returns
je skipwhite
cmp al,0Ah ;and newlines
je skipwhite
notwhite:
; check initial character to ensure it is a digit
cmp bh,al ; check that it's < '9'
jc bad_digit ; error if its not
sub al,bl ; subtract '0' from it
jc bad_digit ; error if its < '0'
get_loop:
mov ah,0
push ax
mov ax,dionum
mov dx,10 ; decimal based system
imul dx ; multiply ax by dx results in dx|ax
mov dionum,ax ; value of prior digits times 10
pop ax ; add this digit's value
add dionum,ax
mov ah,01 ;input a character
int 21h
mov diolastc,al ;save it incase we're finished digits
cmp bh,al ;exit getting digits if not a digit
jc get_exit
sub al,bl
jc get_exit
dec cl ;if this is not more than
jnz get_loop ; 4 digits add this digit to num
sub cl,1 ;otherwise exit with carry set
jmp bad_digit
get_exit:
mov ax,dionum ; "good" number
cmp ax,ax ; clear carry
bad_digit: ;-- if we get here something is wrong
;-- by careful coding we have ensured that
;-- the carry flag will be set
;-- this is the "error" return indicator
pop dx ;restore working registers
pop cx
pop bx
ret
getNum endp