Page	58,132
	Title	PRINTF.ASM	Generic Printf Module
;******************************************************************************
;
;   Name:	PRINTF.ASM	Generic Printf Module
;
;   Revision:	1.00
;
;   Date:	November 30, 1988
;
;   Author:	Randy Spurlock
;
;******************************************************************************
;
;  Module Functional Description:
;
;	Printf - Prints a formatted string of arguments to
;		 the requested handle.
;
;	Calling Sequence:
;
;		mov	al,HANDLE	; Get the desired handle to print on
;		lea	bx,ds:[args]	; Get a pointer to the arguments
;		lea	si,ds:[format]	; Get a pointer to the format string
;		call	printf		; Call the printf routine
;
;	The conversion characters are as follows:
;
;		%% - Print percent sign to handle
;		%c - Output the next argument as a character
;		%s - Output the next argument as a string
;		%x - Output the next argument as a hex number using abcdef
;		%X - Output the next argument as a hex number using ABCDEF
;		%h - Output the next argument as a hex number using abcdef
;		%H - Output the next argument as a hex number using ABCDEF
;		%d - Output the next argument as a decimal number (Signed)
;		%u - Output the next argument as a decimal number (Unsigned)
;		%o - Output the next argument as a octal number
;		%b - Output the next argument as a binary number
;		%f - Output the next argument as a fractional number (Signed)
;
;	Other format specifiers may precede the conversion character:
;
;		-  - Left justify the field
;		+  - Set signed field
;		n  - Specify the field width/precision
;		t  - Specify short value
;		l  - Specify long value
;		#  - Specify far argument pointer
;		&  - Specify indirect argument pointer
;		$  - Specify immediate argument value
;		*  - Variable precision/width value (From argument list)
;
;	All arguments must be pointers to the actual values.
;
;	The following escape sequences are also handled:
;
;		\\   -	Backslash
;		\n   -	Newline
;		\t   -	Horizontal Tab
;		\v   -	Vertical Tab
;		\b   -	Backspace
;		\r   -	Carriage Return
;		\f   -	Form Feed
;		\ddd -	ASCII Character (Octal Notation)
;		\xdd -	ASCII Character (Hexadecimal Notation)
;
;******************************************************************************
;
;  Changes:
;
;    DATE     REVISION				DESCRIPTION
;  --------   --------	-------------------------------------------------------
;  11/30/88	1.00	Original				Randy Spurlock
;
;******************************************************************************
	Page
;
;  Public Declarations
;
	Public	Printf			; Generic Printf routine
;
;  Define the Local Equates
;
FORMAT_CHAR	Equ	"%"             ; Format specification character
ESCAPE_CHAR	Equ	"\"             ; Escape sequence character
BASE_HEX	Equ	16		; Base 16 - Hexadecimal
BASE_DECIMAL	Equ	10		; Base 10 - Decimal
BASE_OCTAL	Equ	8		; Base 8  - Octal
BASE_BINARY	Equ	2		; Base 2  - Binary
FORMAT_LENGTH	Equ	5		; Maximum format number width
ESCAPE_LENGTH	Equ	3		; Escape sequence number width (Decimal)
HEX_LENGTH	Equ	2		; Escape sequence number width (Hex)
MAX_WORD	Equ	0FFFFh		; Maximum 16-bit count value
MAX_BYTE	Equ	0FFh		; Maximum 8-bit count value
SPACE_PAD	Equ	" "             ; Space pad character
ZERO_PAD	Equ	"0"             ; Zero pad character
LEFT_JUST	Equ	8000h		; Left justification flag
SHORT_SPEC	Equ	4000h		; Short specification flag
LONG_SPEC	Equ	2000h		; Long specification flag
UPPER_CASE	Equ	1000h		; Upper case hexadecimal flag
SIGNED_CONV	Equ	0800h		; Signed conversion flag
SIGNED_TYPE	Equ	0400h		; Signed type flag
SIGNED_VAL	Equ	0200h		; Signed value flag
PRE_PAD 	Equ	0100h		; Pre-pad sign character flag
FAR_SPEC	Equ	0080h		; Far argument specification flag
OVER_FLOW	Equ	0040h		; Field overflow flag
FRACTIONAL	Equ	0020h		; Fractional integer flag
VAR_WIDTH	Equ	0010h		; Variable width flag
VAR_PRE 	Equ	0008h		; Variable precision flag
PAD_CHAR	Equ	0004h		; Pad character flag (0=Space, 1=Zero)
INDIRECT	Equ	0002h		; Indirection flag (1 = Indirect)
IMMEDIATE	Equ	0001h		; Immediate flag (1 = Immediate)
SIGNED		Equ	8000h		; Sign flag test mask
DECIMAL_ADJUST	Equ	30h		; ASCII decimal to binary adjust value
HEX_ADJUST	Equ	07h		; ASCII hex to binary adjust value
UPPER_MASK	Equ	0DFh		; Lower to upper case mask value
FAR_SIZE	Equ	4h		; Far argument pointer size   (4 bytes)
NEAR_SIZE	Equ	2h		; Near argument pointer size  (2 bytes)
LONG_SIZE	Equ	4h		; Long numeric argument size  (4 bytes)
NORMAL_SIZE	Equ	2h		; Normal numeric argument size(2 bytes)
SHORT_SIZE	Equ	1h		; Short numeric argument size (1 bytes)
BUFF_SIZE	Equ	64		; Numeric build buffer size
DIGIT_MAX	Equ	39h		; Maximum ASCII digit value
DOS_FUNCTION	Equ	21h		; MS-DOS function request interrupt
WRITE_FILE	Equ	40h		; Write file function code
;
;  Define any ASCII characters needed
;
PLUS		Equ	"+"             ; Plus sign character
MINUS		Equ	"-"             ; Minus sign character
EQUAL		Equ	"="             ; Equal sign character
ASTERISK	Equ	"*"             ; Asterisk character
POINT		Equ	"."             ; Decimal point character
NULL		Equ	00h		; ASCII code for null
BS		Equ	08h		; ASCII code for backspace
HT		Equ	09h		; ASCII code for horizontal tab
LF		Equ	0Ah		; ASCII code for line feed
VT		Equ	0Bh		; ASCII code for vertical tab
FF		Equ	0Ch		; ASCII code for form feed
CR		Equ	0Dh		; ASCII code for carriage return
;
;  Define any Macros needed
;
	Page
;******************************************************************************
;
;	Save(Regs)
;
;		While there are registers in the list (Left to right)
;			Push this register onto the stack
;		Endwhile
;
;******************************************************************************
Save		Macro	a,b,c,d,e,f,g,h,i,j,k,l,m,n,o
	Irp	x,<a,b,c,d,e,f,g,h,i,j,k,l,m,n,o>
		Ifnb	<x>
		    push    x
		Endif
	Endm
		Endm
	Page
;******************************************************************************
;
;	Restore(Regs)
;
;		While there are registers in the list (Right to left)
;			Pop this register from the stack
;		Endwhile
;
;******************************************************************************
Restore 	Macro	a,b,c,d,e,f,g,h,i,j,k,l,m,n,o
	Irp	x,<o,n,m,l,k,j,i,h,g,f,e,d,c,b,a>
		Ifnb	<x>
		    pop     x
		Endif
	Endm
		Endm
	Page
;
;  Define the standard code segment
;
Code	Segment Word Public 'CODE'      ; Define the standard code segment
	Assume	cs:Code, ds:Nothing, es:Nothing
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Printf(Format_String, Arguments, Handle)
;
;		Save the required registers
;		While next character from Format_String <> 0
;			If next character is a format character (percent sign)
;				Get the next character from Format_String
;				If a format specifier (+,-,n,l,#,&,$,*)
;					Set the appropriate specifier flag
;				Else not a format specifier
;					If a conversion character (c,s,x,d,o,b)
;						Print argument using conversion
;						Increment argument pointer
;					Else not a conversion character
;						Ignore this format
;					Endif
;				Endif
;			Else the character is not a format character
;				If character is a escape character (backslash)
;					Get next character from Format_String
;					If a valid escape sequence
;						Handle the escape sequence
;					Else an invalid escape sequence
;						Print the character to Handle
;					Endif
;				Else the character is not an escape character
;					Print the character to Handle
;				Endif
;			Endif
;		Endwhile
;		Restore the required registers
;		Return to the caller
;
;	Registers on Entry:
;
;		AL    - File Handle to Print on
;		DS:BX - Pointer to Argument List
;		DS:SI - Pointer to Format String
;
;	Registers on Exit:
;
;		FL    - DR flag is cleared (Move forward)
;
;******************************************************************************
Printf		Proc	Near		; Generic printf procedure
	Save	ax,bx,cx,dx,si,di,bp,ds,es
	mov	ah,al			; Save print handle in AH
	cld				; Clear the direction flag (Forward)
;
;  Get a character from format string and decide what to do with it
;
Get_Char:
	call	Clear_Flags		; Clear all of the specifier flags
	lodsb				; Get a character from format string
	cmp	al,FORMAT_CHAR		; Check for a format character (%)
	je	Do_Format		; Jump if a format character
	cmp	al,ESCAPE_CHAR		; Check for an escape character (\)
	je	Do_Escape		; Jump if a escape character
	or	al,al			; Check for end of the format string
	jnz	Normal_Output		; Jump if a normal character to output
	jmp	Printf_Exit		; Jump if end of the format string
;
;  It is a escape character, get the next character and check it
;
Do_Escape:
	lodsb				; Get next character from format string
	push	cs			; Put copy of CS onto the stack
	pop	es			; Put copy of current CS into ES
	lea	di,cs:[Escape_Table]	; Setup the escape character table
	mov	cx,ESCAPE_SIZE		; Get the escape character table size
	repne	scasb			; Scan the escape table for a match
	je	Go_Escape		; Jump if an there was a table match
	mov	ch,BASE_OCTAL		; Set the current base value to OCTAL
	mov	cl,ESCAPE_LENGTH	; Set the escape maximum number count
	call	Check_Digit		; Check for numeric digit (Character)
	jc	Normal_Output		; Jump if an unknown escape character
Get_Code:
	dec	si			; Backup to the start of the number
	push	dx			; Save the field width/precision
	call	Get_Number		; Call routine to get the number
	mov	al,dl			; Put the character number into AL
	pop	dx			; Restore the field width/precision
	jmp	Short Normal_Output	; Go get next format string character
Go_Escape:
	mov	di,ESCAPE_SIZE		; Get the escape table size
	sub	di,cx			; Compute the matching entry number
	dec	di			; Convert number to zero based
	shl	di,1			; Make number into jump table index
	call	cs:[di+Escape_Jump]	; Call the correct routine
	jmp	Short Get_Char		; Go get the next character
Normal_Output:
	call	Output			; Not a special character, output it
	jmp	Short Get_Char		; Go get next format string character
;
;  Not a valid format specifier, check for a conversion character
;
Do_Convert:
	lea	di,cs:[Convert_Table]	; Setup the convert character table
	mov	cx,CONVERT_SIZE 	; Get the convert character table size
	repne	scasb			; Scan the convert table for a match
	jne	Get_Char		; Jump if an unknown convert character
	mov	di,CONVERT_SIZE 	; Get the convert table size
	sub	di,cx			; Compute the matching entry number
	dec	di			; Convert number to zero based
	shl	di,1			; Make number into jump table index
	call	cs:[di+Convert_Jump]	; Call the correct routine
	jmp	Short Get_Char		; Go get the next character
;
;  It is a format character, get the next character and check it
;
Do_Format:
	lodsb				; Get next character from format string
	push	cs			; Put copy of CS onto the stack
	pop	es			; Put copy of current CS into ES
	lea	di,cs:[Format_Table]	; Setup the format character table
	mov	cx,FORMAT_SIZE		; Get the format character table size
	repne	scasb			; Scan the format table for a match
	je	Go_Format		; Jump if an there was a table match
	mov	ch,BASE_DECIMAL 	; Set the current base value to DECIMAL
	mov	cl,FORMAT_LENGTH	; Set the format maximum number count
	cmp	al,POINT		; Check for a decimal point
	jne	Chk_Var 		; Jump if no decimal point found
	dec	si			; Correct pointer for no width value
	xor	dh,dh			; Setup a width value of zero
	jmp	Short Chk_Pre		; Go check for a precision value
Chk_Var:
	cmp	al,ASTERISK		; Check for variable width field
	jne	Do_Width		; Jump if not a variable width field
	or	bp,VAR_WIDTH		; Set variable width flag bit
	mov	dh,MAX_BYTE		; Set width value as already set
	jmp	Short Chk_Pre		; Go check for a precision value
Do_Width:
	call	Check_Digit		; Check for numeric digit (Field width)
	jc	Do_Convert		; Jump if an unknown format character
	dec	si			; Backup to the start of the number
	or	al,al			; Check for a leading zero
	jnz	Get_Width		; Jump if first digit not a zero
	or	bp,PAD_CHAR		; First digit zero, use zero pad
	or	bp,PRE_PAD		; Set pre-pad sign character flag
Get_Width:
	call	Get_Number		; Call routine to get the field width
	mov	dh,dl			; Save the field width in DH
	cmp	Byte Ptr ds:[si],ASTERISK
	jne	Chk_Pre 		; Jump if not a variable width field
	inc	si			; Increment past variable character
	or	bp,VAR_WIDTH		; Set variable width flag bit
	mov	dh,MAX_BYTE		; Set width value as already set
Chk_Pre:
	xor	dl,dl			; Setup a precision of zero
	cmp	Byte Ptr ds:[si],POINT	; Check for a decimal point
	jne	Do_Format		; Jump if no precision given
	or	bp,FRACTIONAL		; Set the fractional conversion flag
	dec	dl			; Set precision as already set
	inc	si			; Increment past the decimal point
	cmp	Byte Ptr ds:[si],ASTERISK
	jne	Get_Pre 		; Jump if not a variable precision
	inc	si			; Increment past variable character
	or	bp,VAR_PRE		; Set variable precision flag bit
	jmp	Short Do_Format 	; Go check for more format characters
Get_Pre:
	call	Get_Number		; Call routine to get the precision
	adc	dl,0			; Setup correct precision value
	jmp	Short Do_Format 	; Go check for more format characters
Go_Format:
	mov	di,FORMAT_SIZE		; Get the format table size
	sub	di,cx			; Compute the matching entry number
	dec	di			; Convert number to zero based
	shl	di,1			; Make number into jump table index
	call	cs:[di+Format_Jump]	; Call the correct routine
	jmp	Short Do_Format 	; Go check for more format characters
;
;  Restore the registers and return to the caller
;
Printf_Exit:
	Restore ax,bx,cx,dx,si,di,bp,ds,es
	ret				; Return to the caller
	Page
;
;  Define the format specifier character and jump tables
;
Format_Table	Label	Byte
		Db	'-'             ; Left justify format specifier
		Db	'+'             ; Set signed specifier
		Db	't'             ; Short format specifier
		Db	'T'             ; Short format specifier
		Db	'l'             ; Long format specifier
		Db	'L'             ; Long format specifier
		Db	'#'             ; Far format specifier
		Db	'&'             ; Indirect format specifier
		Db	'$'             ; Immediate format specifier
FORMAT_SIZE	Equ	This Byte - Format_Table
Format_Jump	Label	Word
		Dw	Left_Justify
		Dw	Set_Signed
		Dw	Short_Specify
		Dw	Short_Specify
		Dw	Long_Specify
		Dw	Long_Specify
		Dw	Far_Specify
		Dw	Set_Indirect
		Dw	Set_Immediate
;
;  Define the escape character and jump tables
;
Escape_Table	Label	Byte
		Db	'n'             ; Newline escape character
		Db	't'             ; Horizontal tab escape character
		Db	'v'             ; Vertical tab escape character
		Db	'b'             ; Backspace escape character
		Db	'r'             ; Carriage return escape character
		Db	'f'             ; Form feed escape character
		Db	'x'             ; Output character (Hex representation)
ESCAPE_SIZE	Equ	This Byte - Escape_Table
Escape_Jump	Label	Word
		Dw	New_Line
		Dw	Horz_Tab
		Dw	Vert_Tab
		Dw	Back_Space
		Dw	Carr_Ret
		Dw	Form_Feed
		Dw	Out_Hex
;
;  Define the convert character and jump tables
;
Convert_Table	Label	Byte
		Db	'%'             ; Print the percent sign
		Db	'c'             ; Print next argument as a character
		Db	'C'             ; Print next argument as a character
		Db	's'             ; Print next argument as a string
		Db	'S'             ; Print next argument as a string
		Db	'x'             ; Print next argument as HEX (abcdef)
		Db	'X'             ; Print next argument as HEX (ABCDEF)
		Db	'h'             ; Print next argument as HEX (abcdef)
		Db	'H'             ; Print next argument as HEX (ABCDEF)
		Db	'd'             ; Print next argument as DECIMAL (+/-)
		Db	'D'             ; Print next argument as DECIMAL (+/-)
		Db	'u'             ; Print next argument as UNSIGNED
		Db	'U'             ; Print next argument as UNSIGNED
		Db	'o'             ; Print next argument as OCTAL
		Db	'O'             ; Print next argument as OCTAL
		Db	'b'             ; Print next argument as BINARY
		Db	'B'             ; Print next argument as BINARY
		Db	'f'             ; Print next argument as FRACTIONAL
		Db	'F'             ; Print next argument as FRACTIONAL
CONVERT_SIZE	Equ	This Byte - Convert_Table
Convert_Jump	Label	Word
		Dw	Print_Format	; Print format routine
		Dw	Do_Char 	; Print character routine
		Dw	Do_Char 	; Print character routine
		Dw	Do_String	; Print string routine
		Dw	Do_String	; Print string routine
		Dw	Do_Hex_Lower	; Print lowercase hexadecimal routine
		Dw	Do_Hex_Upper	; Print uppercase hexadecimal routine
		Dw	Do_Hex_Lower	; Print lowercase hexadecimal routine
		Dw	Do_Hex_Upper	; Print uppercase hexadecimal routine
		Dw	Do_Decimal	; Print signed decimal routine
		Dw	Do_Decimal	; Print signed decimal routine
		Dw	Do_Unsigned	; Print unsigned decimal routine
		Dw	Do_Unsigned	; Print unsigned decimal routine
		Dw	Do_Octal	; Print octal routine
		Dw	Do_Octal	; Print octal routine
		Dw	Do_Binary	; Print binary routine
		Dw	Do_Binary	; Print binary routine
		Dw	Do_Fractional	; Print decimal fractional routine
		Dw	Do_Fractional	; Print decimal fractional routine
;
;  Define the end of the printf procedure
;
Printf		Endp			 ; End of the Printf procedure
	Page
;******************************************************************************
;
;	Format Specificer Routines
;
;
;		These routines handle the following format specifiers:
;
;
;	Specifier		Action Taken
;	---------		------------
;
;	    -		The following field will be left justified.
;
;	    +		The following field will be have a sign (+/-)
;			if it is a signed type field (d).
;
;	    t		The following field is a short value.
;
;	    T		The following field is a short value.
;
;	    l		The following field is a long value.
;
;	    L		The following field is a long value.
;
;	    #		The following argument has a far address.
;
;	    &		The following argument has an indirect address.
;
;	    $		The following argument is an immediate value.
;
;		These routines simply set or reset flags which are
;	used later during actual conversion to perform the special
;	formatting options.
;
;******************************************************************************
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Left_Justify()
;
;		Set the left justification flag
;		Return to the caller
;
;	Registers on Entry:
;
;		None
;
;	Registers on Exit:
;
;		BP    - Left justification flag set
;
;******************************************************************************
Left_Justify	Proc	Near		; Left justify procedure
	or	bp,LEFT_JUST		; Set the left justification flag
	ret				; Return to the caller
Left_Justify	Endp			; End of the Left_Justify procedure
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Set_Signed()
;
;		Set the signed flag
;		If the field width is non-zero
;			Set the pre-pad sign flag
;		Endif
;		Return to the caller
;
;	Registers on Entry:
;
;		DH    - Field width (Not given if zero)
;
;	Registers on Exit:
;
;		BP    - Signed flag set
;
;******************************************************************************
Set_Signed	Proc	Near		; Set signed procedure
	or	bp,SIGNED_CONV		; Set the signed conversion flag
	or	dh,dh			; Check the field width
	jz	Sign_Ret		; Jump if field width not set
	or	bp,PRE_PAD		; Set the pre-pad sign flag
Sign_Ret:
	ret				; Return to the caller
Set_Signed	Endp			; End of the Set_Signed procedure
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Short_Specify()
;
;		Set the short specification flag
;		Return to the caller
;
;	Registers on Entry:
;
;		None
;
;	Registers on Exit:
;
;		BP    - Short specification flag set
;
;******************************************************************************
Short_Specify	Proc	Near		; Short specify procedure
	or	bp,SHORT_SPEC		; Set the short specification flag
	ret				; Return to the caller
Short_Specify	Endp			; End of the Short_Specify procedure
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Long_Specify()
;
;		Set the long specification flag
;		Return to the caller
;
;	Registers on Entry:
;
;		None
;
;	Registers on Exit:
;
;		BP    - Long specification flag set
;
;******************************************************************************
Long_Specify	Proc	Near		; Long specify procedure
	or	bp,LONG_SPEC		; Set the long specification flag
	ret				; Return to the caller
Long_Specify	Endp			; End of the Long_Specify procedure
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Far_Specify()
;
;		Set the far specification flag
;		Return to the caller
;
;	Registers on Entry:
;
;		None
;
;	Registers on Exit:
;
;		BP    - Far specification flag set
;
;******************************************************************************
Far_Specify	Proc	Near		; Far specify procedure
	or	bp,FAR_SPEC		; Set the far specification flag
	ret				; Return to the caller
Far_Specify	Endp			; End of the Far_Specify procedure
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Set_Indirect()
;
;		Set the indirect flag
;		Return to the caller
;
;	Registers on Entry:
;
;		None
;
;	Registers on Exit:
;
;		BP    - Indirection flag set
;
;******************************************************************************
Set_Indirect	Proc	Near		; Set indirect procedure
	or	bp,INDIRECT		; Set the indirection flag
	ret				; Return to the caller
Set_Indirect	Endp			; End of the Set_Indirect procedure
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Set_Immediate()
;
;		Set the immediate flag
;		Return to the caller
;
;	Registers on Entry:
;
;		None
;
;	Registers on Exit:
;
;		BP    - Immediate flag set
;
;******************************************************************************
Set_Immediate	Proc	Near		; Set immediate procedure
	or	bp,IMMEDIATE		; Set the immediate flag
	ret				; Return to the caller
Set_Immediate	Endp			; End of the Set_Immediate procedure
	Page
;******************************************************************************
;
;	Escape Sequence Routines
;
;
;		These routines handle the following escape sequences:
;
;
;	Character		Escape Sequence
;	---------		---------------
;
;	    n		Newline is output to requested handle
;
;	    t		Horizontal tab is output to requested handle
;
;	    v		Vertical tab is output to requested handle
;
;	    b		Backspace is output to requested handle
;
;	    r		Carriage return is output to requested handle
;
;	    f		Form feed is output to requested handle
;
;	    x		Character is output to requested handle (Hex code)
;
;
;		All of these routines except for the "x" escape
;	sequence simply send the desired character(s) out to the
;	requested handle. The "x" routine get the hexadecimal
;	number given and outputs the corresponding character to
;	the requested handle.
;
;******************************************************************************
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	New_Line(Handle)
;
;		Output carriage return to handle
;		Output line feed to handle
;		Return to the caller
;
;	Registers on Entry:
;
;		AH    - Handle
;
;	Registers on Exit:
;
;		AL    - Destroyed
;
;******************************************************************************
New_Line	Proc	Near		; Output new line procedure
	mov	al,CR			; Get carriage return ASCII character
	call	Output			; Output the carriage return to handle
	mov	al,LF			; Get a line feed ASCII character
	call	Output			; Output the line feed to handle
	ret				; Return to the caller
New_Line	Endp			; End of the New_Line procedure
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Horz_Tab(Handle)
;
;		Output horizontal tab to handle
;		Return to the caller
;
;	Registers on Entry:
;
;		AH    - Handle
;
;	Registers on Exit:
;
;		AL    - Destroyed
;
;******************************************************************************
Horz_Tab	Proc	Near		; Output horizontal tab procedure
	mov	al,HT			; Get horizontal tab ASCII character
	call	Output			; Output the horizontal tab to handle
	ret				; Return to the caller
Horz_Tab	Endp			; End of the Horz_Tab procedure
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Vert_Tab(Handle)
;
;		Output vertical tab to handle
;		Return to the caller
;
;	Registers on Entry:
;
;		AH    - Handle
;
;	Registers on Exit:
;
;		AL    - Destroyed
;
;******************************************************************************
Vert_Tab	Proc	Near		; Output vertical tab procedure
	mov	al,VT			; Get vertical tab ASCII character
	call	Output			; Output the vertical tab to handle
	ret				; Return to the caller
Vert_Tab	Endp			; End of the Vert_Tab procedure
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Back_Space(Handle)
;
;		Output backspace to handle
;		Return to the caller
;
;	Registers on Entry:
;
;		AH    - Handle
;
;	Registers on Exit:
;
;		AL    - Destroyed
;
;******************************************************************************
Back_Space	Proc	Near		; Output backspace procedure
	mov	al,BS			; Get backspace ASCII character
	call	Output			; Output the backspace to handle
	ret				; Return to the caller
Back_Space	Endp			; End of the Back_Space procedure
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Carr_Ret(Handle)
;
;		Output carriage return to handle
;		Return to the caller
;
;	Registers on Entry:
;
;		AH    - Handle
;
;	Registers on Exit:
;
;		AL    - Destroyed
;
;******************************************************************************
Carr_Ret	Proc	Near		; Output carriage return procedure
	mov	al,CR			; Get carriage return ASCII character
	call	Output			; Output the carriage return to handle
	ret				; Return to the caller
Carr_Ret	Endp			; End of the Carr_Ret procedure
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Form_Feed(Handle)
;
;		Output form feed to handle
;		Return to the caller
;
;	Registers on Entry:
;
;		AH    - Handle
;
;	Registers on Exit:
;
;		AL    - Destroyed
;
;******************************************************************************
Form_Feed	Proc	Near		; Output form feed procedure
	mov	al,FF			; Get form feed ASCII character
	call	Output			; Output the form feed to handle
	ret				; Return to the caller
Form_Feed	Endp			; End of the Form_Feed procedure
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Out_Hex(String, Handle)
;
;		Set number base to hexadecimal
;		Set maximum number length
;		Call routine to get the number
;		Output the number (Character) to handle
;		Return to the caller
;
;	Registers on Entry:
;
;		AH    - Handle
;		DS:SI - Pointer to number
;
;	Registers on Exit:
;
;		AL    - Destroyed
;		CX    - Destroyed
;		DL    - Destroyed
;		DS:SI - Pointer set to first character past number
;
;******************************************************************************
Out_Hex 	Proc	Near		; Output hex character procedure
	mov	ch,BASE_HEX		; Set number base to hexadecimal
	mov	cl,HEX_LENGTH		; Set maximum hex digit length
	call	Get_Number		; Call routine to get the number
	jc	Out_Exit		; Jump if no number present
	mov	al,dl			; Move the number value into AL
	call	Output			; Output the corresponding character
Out_Exit:
	ret				; Return to the caller
Out_Hex 	Endp			; End of the Out_Hex procedure
	Page
;******************************************************************************
;
;	Conversion Formatting Routines
;
;
;		These routines handle the following conversion types:
;
;
;	Character		Conversion Done
;	---------		---------------
;
;	    c		Convert next argument as a character
;
;	    s		Convert next argument as a string
;
;	    x		Convert next argument as a hex number using abcdef
;
;	    X		Convert next argument as a hex number using ABCDEF
;
;	    d		Convert next argument as a decimal number (Signed)
;
;	    u		Convert next argument as a decimal number (Unsigned)
;
;	    o		Convert next argument as a octal number
;
;	    b		Convert next argument as a binary number
;
;
;		These routines format the arguments passed to them.
;	Numeric arguments can be either word or double word (long)
;	values and for the decimal option it can be formatted as
;	signed or unsigned. All arguments are passed as pointers,
;	either near or far, to the actual argument value.
;
;******************************************************************************
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Do_Char(Argument, Handle, Flags)
;
;		Save the required registers
;		Call routine to check for variable width/precision
;		Call routine to get the character address
;		If field width is not set (Zero)
;			Set field width to character value (1)
;		Endif
;		If character length (1) > field width
;			Set the field overflow flag
;			Set character length to field width
;		Endif
;		Set pad character to a space
;		Call routine to calculate pad counts
;		Call routine to output pre-string pad characters
;		Get character to output
;		Call routine to output character to handle
;		Call routine to output post-string pad characters
;		Restore the required registers
;		Return to the caller
;
;	Registers on Entry:
;
;		AH    - Handle
;		DS:BX - Pointer to argument
;		DH    - Current field width
;		BP    - Formatting flags
;
;	Registers on Exit:
;
;		AL    - Destroyed
;		BX    - Points to next argument
;		CX    - Destroyed
;		DL    - Destroyed
;		DI    - Destroyed
;		ES    - Destroyed
;
;******************************************************************************
Do_Char 	Proc	Near		; Character formatting procedure
	Save	si,ds			; Save the required registers
	call	Variable		; Call routine to check width/precision
	call	Get_Address		; Call routine to get argument address
	mov	cl,1			; Set actual width to character value
	or	dh,dh			; Check the current field width
	jnz	Width_Chk		; Jump if field width specified
	mov	dh,1			; Set field width to character length
Width_Chk:
	cmp	cl,dh			; Compare actual width to given width
	jbe	Send_Pre		; Jump if string fits in field width
	or	bp,OVER_FLOW		; Set the field overflow flag
	mov	cl,dh			; Clip string to the field width
Send_Pre:
	mov	al,cl			; Save the actual string length
	and	bp,Not PAD_CHAR 	; Set current pad character to a space
	call	Calculate		; Call routine to calculate pad values
	call	Pad			; Call routine to send pad characters
Send_Char:
	lodsb				; Get the character to output
	call	Output			; Call routine to output the character
Send_Post:
	mov	cl,ch			; Get the calculated pad counts
	call	Pad			; Call routine to send pad characters
	Restore si,ds			; Restore the required registers
	ret				; Return to the caller
Do_Char 	Endp			; End of the Do_Char routine
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Do_String(Argument, Handle, Width, Flags)
;
;		Save the required registers
;		Call routine to check for variable width/precision
;		Call routine to get the string address
;		Call routine to compute string length
;		If field width is not set (Zero)
;			Set field width to string length
;		Endif
;		If string length > field width
;			Set the field overflow flag
;			Set string length to field width
;		Endif
;		Set pad character to a space
;		Call routine to calculate pad counts
;		Call routine to output pre-string pad characters
;		Output the string characters
;		Call routine to output post-string pad characters
;		Restore the required registers
;		Return to the caller
;
;	Registers on Entry:
;
;		AH    - Handle
;		DS:BX - Pointer to argument
;		DH    - Current field width
;		BP    - Formatting flags
;
;	Registers on Exit:
;
;		AL    - Destroyed
;		BX    - Points to next argument
;		CX    - Destroyed
;		DL    - Destroyed
;		DI    - Destroyed
;		ES    - Destroyed
;
;******************************************************************************
Do_String	Proc	Near		; String formatting procedure
	Save	si,ds			; Save the required registers
	call	Variable		; Call routine to check width/precision
	call	Get_Address		; Call routine to get argument address
	call	Get_Length		; Call routine to get string length
	jz	String_Exit		; Jump if nothing to output
	or	dh,dh			; Check the current field width
	jnz	Chk_Width		; Jump if field width specified
	mov	dh,cl			; Set field width to string length
Chk_Width:
	cmp	cl,dh			; Compare actual width to given width
	jbe	Do_Pre			; Jump if string fits in field width
	or	bp,OVER_FLOW		; Set the field overflow flag
	mov	cl,dh			; Clip string to the field width
Do_Pre:
	mov	al,cl			; Save the actual string length
	and	bp,Not PAD_CHAR 	; Set current pad character to a space
	call	Calculate		; Call routine to calculate pad values
	mov	dl,al			; Setup the string output length
	call	Pad			; Call routine to send pad characters
Send_String:
	Save	ax,bx,cx,dx		; Save the required registers
	mov	cl,dl			; Get the computed string length
	xor	ch,ch			; Convert string length to a full word
	mov	dx,si			; Get pointer to the character string
	mov	bl,ah			; Get the file handle value
	xor	bh,bh			; Convert file handle to a full word
	mov	ah,WRITE_FILE		; Get write file function code
	int	DOS_FUNCTION		; Try to write the string to the file
	Restore ax,bx,cx,dx		; Restore the required registers
Do_Post:
	mov	cl,ch			; Get the calculated pad counts
	call	Pad			; Call routine to send pad characters
String_Exit:
	Restore si,ds			; Restore the required registers
	ret				; Return to the caller
Do_String	Endp			; End of the Do_String routine
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Do_Hex(Argument, Handle, Width, Precision, Flags, Type)
;
;		Save the required registers
;		If type is uppercase
;			Set the uppercase format flag
;		Endif
;		Call routine to check for variable width/precision
;		Set current number base to hexadecimal
;		Call routine to get the argument address
;		Call routine to output the numeric string
;		Restore the required registers
;		Return to the caller
;
;	Registers on Entry:
;
;		AH    - Handle
;		DS:BX - Pointer to argument
;		DH    - Current field width
;		DL    - Current field precision
;		BP    - Formatting flags
;
;	Registers on Exit:
;
;		BX    - Points to next argument
;
;******************************************************************************
Do_Hex		Proc	Near		; Hexadecimal formatting procedure
Do_Hex_Upper	Label	Near		; Do_Hex_Upper entry point (ABCDEF)
	or	bp,UPPER_CASE		; Set uppercase formatting flag
Do_Hex_Lower	Label	Near		; Do_Hex_Lower entry point (abcdef)
	Save	si,ds			; Save the required registers
	call	Variable		; Call routine to check width/precision
	mov	ch,BASE_HEX		; Set the current number base to hex
	call	Get_Address		; Call routine to get argument address
	call	Compute 		; Call routine to output number
	Restore si,ds			; Restore the required registers
	ret				; Return to the caller
Do_Hex		Endp			; End of the Do_Hex routine
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Do_Decimal(Argument, Handle, Width, Precision, Flags)
;
;		Save the required registers
;		Call routine to check for variable width/precision
;		Set the signed type formatting flag
;		Set current number base to decimal
;		Call routine to get the argument address
;		Call routine to output the numeric string
;		Restore the required registers
;		Return to the caller
;
;	Registers on Entry:
;
;		AH    - Handle
;		DS:BX - Pointer to argument
;		DH    - Current field width
;		DL    - Current field precision
;		BP    - Formatting flags
;
;	Registers on Exit:
;
;		BX    - Points to next argument
;
;******************************************************************************
Do_Decimal	Proc	Near		; Decimal formatting procedure
	Save	si,ds			; Save the required registers
	call	Variable		; Call routine to check width/precision
	or	bp,SIGNED_TYPE		; Set signed type formatting flag
	mov	ch,BASE_DECIMAL 	; Set current number base to decimal
	call	Get_Address		; Call routine to get argument address
	call	Compute 		; Call routine to output number
	Restore si,ds			; Restore the required registers
	ret				; Return to the caller
Do_Decimal	Endp			; End of the Do_Decimal routine
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Do_Unsigned(Argument, Handle, Width, Precision, Flags)
;
;		Save the required registers
;		Call routine to check for variable width/precision
;		Set current number base to decimal
;		Call routine to get the argument address
;		Call routine to output the numeric string
;		Restore the required registers
;		Return to the caller
;
;	Registers on Entry:
;
;		AH    - Handle
;		DS:BX - Pointer to argument
;		DH    - Current field width
;		DL    - Current field precision
;		BP    - Formatting flags
;
;	Registers on Exit:
;
;		BX    - Points to next argument
;
;******************************************************************************
Do_Unsigned	Proc	Near		; Unsigned decimal formatting procedure
	Save	si,ds			; Save the required registers
	call	Variable		; Call routine to check width/precision
	mov	ch,BASE_DECIMAL 	; Set current number base to decimal
	call	Get_Address		; Call routine to get argument address
	call	Compute 		; Call routine to output number
	Restore si,ds			; Restore the required registers
	ret				; Return to the caller
Do_Unsigned	Endp			; End of the Do_Unsigned routine
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Do_Octal(Argument, Handle, Width, Precision, Flags)
;
;		Save the required registers
;		Call routine to check for variable width/precision
;		Set current number base to octal
;		Call routine to get the argument address
;		Call routine to output the numeric string
;		Restore the required registers
;		Return to the caller
;
;	Registers on Entry:
;
;		AH    - Handle
;		DS:BX - Pointer to argument
;		DH    - Current field width
;		DL    - Current field precision
;		BP    - Formatting flags
;
;	Registers on Exit:
;
;		BX    - Points to next argument
;
;******************************************************************************
Do_Octal	Proc	Near		; Octal formatting procedure
	Save	si,ds			; Save the required registers
	call	Variable		; Call routine to check width/precision
	mov	ch,BASE_OCTAL		; Set current number base to octal
	call	Get_Address		; Call routine to get argument address
	call	Compute 		; Call routine to output number
	Restore si,ds			; Restore the required registers
	ret				; Return to the caller
Do_Octal	Endp			; End of the Do_Octal routine
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Do_Binary(Argument, Handle, Width, Precision, Flags)
;
;		Save the required registers
;		Call routine to check for variable width/precision
;		Set current number base to binary
;		Call routine to get the argument address
;		Call routine to output the numeric string
;		Retore the required registers
;		Return to the caller
;
;	Registers on Entry:
;
;		AH    - Handle
;		DS:BX - Pointer to argument
;		DH    - Current field width
;		DL    - Current field precision
;		BP    - Formatting flags
;
;	Registers on Exit:
;
;		BX    - Points to next argument
;
;******************************************************************************
Do_Binary	Proc	Near		; Binary formatting procedure
	Save	si,ds			; Save the required registers
	call	Variable		; Call routine to check width/precision
	mov	ch,BASE_BINARY		; Set current number base to binary
	call	Get_Address		; Call routine to get argument address
	call	Compute 		; Call routine to output number
	Restore si,ds			; Restore the required registers
	ret				; Return to the caller
Do_Binary	Endp			; End of the Do_Binary routine
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Do_Fractional(Argument, Handle, Width, Precision, Flags)
;
;		Save the required registers
;		Call routine to check for variable width/precision
;		Set the signed type formatting flag
;		Set current number base to decimal
;		Call routine to get the argument address
;		Call routine to output the numeric string
;		Restore the required registers
;		Return to the caller
;
;	Registers on Entry:
;
;		AH    - Handle
;		DS:BX - Pointer to argument
;		DH    - Current field width
;		DL    - Current field precision
;		BP    - Formatting flags
;
;	Registers on Exit:
;
;		BX    - Points to next argument
;
;******************************************************************************
Do_Fractional	Proc	Near		; Fractional formatting procedure
	Save	si,ds			; Save the required registers
	call	Variable		; Call routine to check width/precision
	or	bp,SIGNED_TYPE		; Set signed type formatting flag
	or	bp,FRACTIONAL		; Set the fractional formatting flag
	mov	ch,BASE_DECIMAL 	; Set current number base to decimal
	call	Get_Address		; Call routine to get argument address
	call	Compute 		; Call routine to output number
	Restore si,ds			; Restore the required registers
	ret				; Return to the caller
Do_Fractional	Endp			; End of the Do_Fractional routine
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Get_Address(Argument, Flags)
;
;		Save the required registers
;		If immediate specifier has been set
;			Set DS:SI to current value of DS:BX
;			Increment BX to next argument (1,2,4)
;		Else no immediate specifier
;			If far format specifier has been set
;				Set DS:SI to far pointer at DS:BX
;				If indirect format specifier has been set
;					Set DS:SI to far pointer at DS:SI
;				Endif
;				Increment BX to next argument (4)
;			Else no far specifier
;				Set SI to near pointer at DS:BX
;				If indirect format specifier has been set
;					Set SI to near pointer at DS:SI
;				Endif
;				Increment BX to next argument (2)
;			Endif
;		Endif
;		Restore the required registers
;		Return to the caller
;
;	Registers on Entry:
;
;		DS:BX - Pointer to argument list
;		BP    - Formatting flags
;
;	Registers on Exit:
;
;		DS:SI - New address pointer (Character or string)
;		BX    - Points to the next argument
;
;******************************************************************************
Get_Address	Proc	Near		; Get address procedure
	Save	ax			; Save the required registers
	test	bp,IMMEDIATE		; Check for immediate specifier set
	jz	Check_Specifier 	; Jump if no immediate specifier
	mov	si,bx			; Setup the address into DS:SI
	mov	ax,NORMAL_SIZE		; Default to normal size argument
Check_Short:
	test	bp,SHORT_SPEC		; Check for a short immediate argument
	jz	Check_Long		; Jump if not a short argument
	mov	ax,SHORT_SIZE		; Setup to short size argument
	jmp	Short Immediate_Fixup	; Go perform the address fixup
Check_Long:
	test	bp,LONG_SPEC		; Check for a long immeidate argument
	jz	Immediate_Fixup 	; Jump if not a long argument
	mov	ax,LONG_SIZE		; Setup to long size argument
Immediate_Fixup:
	add	bx,ax			; Update the argument pointer value
	jmp	Short Get_Exit		; Go return control to the caller
Check_Specifier:
	test	bp,FAR_SPEC		; Check for far specifier set
	jz	Near_Addr		; Jump if a normal near address
Far_Addr:
	lds	si,Dword Ptr ds:[bx]	; Load the far address into DS:SI
	test	bp,INDIRECT		; Check for indirect address
	jz	Far_Fixup		; Jump if no indirection specified
	lds	si,Dword Ptr ds:[si]	; Get the indirect far address
Far_Fixup:
	add	bx,FAR_SIZE		; Update the argument pointer value
	jmp	Short Get_Exit		; Go return to the caller
Near_Addr:
	mov	si,Word Ptr ds:[bx]	; Load the near address into SI
	test	bp,INDIRECT		; Check for indirect address
	jz	Near_Fixup		; Jump if no indirection specified
	mov	si,Word Ptr ds:[si]	; Get the indirect near address
Near_Fixup:
	add	bx,NEAR_SIZE		; Update the argument pointer value
Get_Exit:
	Restore ax			; Restore the required registers
	ret				; Return to the caller
Get_Address	Endp			; End of the Get_Address procedure
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Variable(Width, Precision, Flags)
;
;		Save the required registers
;		If variable width specified
;			Get the actual width value (Byte)
;		Endif
;		If variable precision specified
;			Get the actual precision value (Byte)
;		Endif
;		Restore the required registers
;		Return to the caller
;
;	Registers on Entry:
;
;		DS:BX - Pointer to argument list
;		BP    - Formatting flags
;
;	Registers on Exit:
;
;		DH    - Actual width value
;		DL    - Actual precision value
;		BX    - Points to the next argument
;
;******************************************************************************
Variable	Proc	Near		; Get variable width/precision procedure
	Save	si			; Save the required registers
	test	bp,VAR_WIDTH		; Check for a variable width value
	jz	Pre_Chk 		; Jump if no variable width
	mov	si,Word Ptr ds:[bx]	; Load the near address into SI
	add	bx,NEAR_SIZE		; Update the argument pointer value
	mov	dh,Byte Ptr ds:[si]	; Get the actual field width value
Pre_Chk:
	test	bp,VAR_PRE		; Check for a variable precision value
	jz	Var_Exit		; Jump if no variable precision
	mov	si,Word Ptr ds:[bx]	; Load the near address into SI
	add	bx,NEAR_SIZE		; Update the argument pointer value
	mov	dl,Byte Ptr ds:[si]	; Get the actual precision value
Var_Exit:
	Restore si			; Restore the required registers
	ret				; Return to the caller
Variable	Endp			; End of the Variable procedure
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Get_Length(String)
;
;		Calculate the length of the string (Null terminator)
;		Return to the caller
;
;	Registers on Entry:
;
;		DS:SI - Pointer to string
;
;	Registers on Exit:
;
;		AL    - Destroyed
;		CX    - String length
;		DI    - Destroyed
;		ES    - Destroyed
;		ZR    - Zero set if zero length
;
;******************************************************************************
Get_Length	Proc	Near		; Get string length procedure
	push	ds			; Put a copy of DS onto the stack
	pop	es			; Set ES to the current DS value
	mov	di,si			; Set DI to the current SI value
	mov	al,NULL 		; Setup to scan for null terminator
	mov	cx,MAX_WORD		; Setup to scan for maximum length
	repne	scasb			; Scan for the string terminator
	not	cx			; Correct the count value
	dec	cx			; Adjust to get actual string length
	ret				; Return to the caller
Get_Length	Endp			; End of the Get_Length routine
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Calculate(Width, Length)
;
;		Save the required registers
;		Calculate total pad length
;		If total pad length > 0
;			If left justification is not requested
;				Set pre pad count to total
;				Zero post pad count
;			Else left justification requested
;				Set post pad count to total
;				Zero pre pad count
;			Endif
;		Else total pad length < 0
;			Set pre pad count to zero
;			Set post pad count to zero
;		Endif
;		Restore the required registers
;		Return to the caller
;
;	Registers on Entry:
;
;		CL    - Length of the string
;		DH    - Field width
;		BP    - Formatting flags
;
;	Registers on Exit:
;
;		CH    - Post string pad count
;		CL    - Pre string pad count
;
;******************************************************************************
Calculate	Proc	Near		; Calculate pad length procedure
	Save	ax			; Save the required registers
	mov	al,dh			; Get the current field width
	mov	ah,cl			; Get the length of the output string
	xor	cx,cx			; Default pre/post pad counts to zero
	sub	al,ah			; Compute the total pad count
	jbe	Calc_Exit		; Jump if no pad necessary
	mov	cl,al			; Default to right justification
	test	bp,LEFT_JUST		; Check if left justify was specified
	jz	Calc_Exit		; Jump if no left justification
	mov	ch,cl			; Make post pad count the total count
	xor	cl,cl			; Zero the pre pad count value
Calc_Exit:
	Restore ax			; Restore the required registers
	ret				; Return to the caller
Calculate	Endp			; End of the Calculate procedure
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Pad(Handle, Pad, Count)
;
;		Save the required registers
;		While count > 0
;			Output the current pad character
;			Decrement the count
;		Endwhile
;		Restore the required registers
;		Return to the caller
;
;	Registers on Entry:
;
;		AH    - Handle
;		CL    - Pad count
;
;	Registers on Exit:
;
;		CL    - Destroyed
;
;******************************************************************************
Pad		Proc	Near		; Pad character procedure
	Save	ax			; Save the required registers
	or	cl,cl			; Check for no padding required
	jz	Pad_Exit		; Jump if no padding is required
	mov	al,SPACE_PAD		; Default to a space pad character
	test	bp,PAD_CHAR		; Check for a zero pad character
	jz	Pad_Loop		; Jump if using a space pad character
	mov	al,ZERO_PAD		; Setup to use a zero pad character
Pad_Loop:
	call	Output			; Call routine to output pad character
	dec	cl			; Decrement the pad count
	jnz	Pad_Loop		; Jump if more pad characters to send
Pad_Exit:
	Restore ax			; Restore the required registers
	ret				; Return to the caller
Pad		Endp			; End of the Pad procedure
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Clear_Flags(Flags)
;
;		Clear the formatting flags
;		Default to space padding
;		Zero the current field width
;		Clear direction flag (All string operations forward)
;		Return to the caller
;
;	Registers on Entry:
;
;		None
;
;	Registers on Exit:
;
;		BP    - Destroyed (BP contains the flags and is zeroed)
;		DH    - Set to zero (Current field width)
;		DL    - Set to zero (Current field precision)
;
;******************************************************************************
Clear_Flags	Proc	Near		; Clear formatting flags procedure
	xor	bp,bp			; Clear all of the formatting flags
	xor	dh,dh			; Zero the current field width
	xor	dl,dl			; Zero the current field precision
	cld				; Clear the direction flag
	ret				; Return to the caller
Clear_Flags	Endp			; End of the Clear_Flags procedure
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Print_Format(Handle)
;
;		Save the required registers
;		Output format specification character to handle
;		Restore the required registers
;		Return to the caller
;
;	Registers on Entry:
;
;		AH    - Handle
;
;	Registers on Exit:
;
;		AL    - Destroyed
;
;******************************************************************************
Print_Format	Proc	Near		; Output format specifier procedure
	mov	al,FORMAT_CHAR		; Get format specifier character
	call	Output			; Output the format specifier to handle
	ret				; Return to the caller
Print_Format	Endp			; End of the Print_Format procedure
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Check_Digit(Base, Character)
;
;		Save the required registers
;		Call routine to convert character to binary
;		If the character can be converted
;			If value is greater than base
;				Set carry flag (Character not a digit)
;			Endif
;		Else character cannot be converted
;			Set carry flag (Character not a digit)
;		Endif
;		Restore the required registers
;		Return to the caller
;
;	Registers on Entry:
;
;		AL    - Digit to check (ASCII)
;		CH    - Number system base
;
;	Registers on Exit:
;
;		AL    - Binary value of digit (If it is a digit)
;		FL    - CY set if character is not a digit in current base
;
;******************************************************************************
Check_Digit	Proc	Near		; Check digit procedure
	Save	bx			; Save the required registers
	Save	ax			; Save the original digit value
	call	Convert 		; Call routine to convert character
	mov	bl,al			; Save converted value in BL
	Restore ax			; Restore the original digit value
	jc	Check_Exit		; Jump if could not be converted
	cmp	bl,ch			; Check against current number base
	cmc				; Set correct carry flag state
	jc	Check_Exit		; Jump if not valid for this base
	mov	al,bl			; Digit is valid, save binary value
Check_Exit:
	Restore bx			; Restore the required registers
	ret				; Return to the caller
Check_Digit	Endp			; End of the Check_Digit procedure
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Convert(Character)
;
;		If character is a decimal digit (0 to 9)
;			Convert ASCII digit to binary (Subtract 30h)
;			Clear the carry flag (Character could be converted)
;		Else character is not a decimal digit
;			Convert character to uppercase
;			If character is a hex digit (A to F)
;				Convert ASCII digit to binary (Subtract 37h)
;				Clear carry flag (Character could be converted)
;			Else character is not a hex digit
;				Set carry flag (Could not be converted)
;			Endif
;		Endif
;		Return to the caller
;
;	Registers on Entry:
;
;		AL    - Digit to check (ASCII)
;		CH    - Number system base
;
;	Registers on Exit:
;
;		AL    - Binary value of digit (If it is a digit)
;		FL    - CY set if character is not a digit in current base
;
;******************************************************************************
Convert 	Proc	Near		; Convert character procedure
	sub	al,DECIMAL_ADJUST	; Adjust character for ASCII decimal
	jc	Convert_Exit		; Jump if below decimal limit
	cmp	al,BASE_DECIMAL 	; Check for a valid decimal character
	cmc				; Set carry flag to correct state
	jnc	Convert_Exit		; Jump if there is a valid digit
	and	al,UPPER_MASK		; Convert anything else to uppercase
	sub	al,HEX_ADJUST		; Adjust character for ASCII hexadecimal
	cmp	al,BASE_DECIMAL 	; Check for a valid hex character
	jc	Convert_Exit		; Jump if below hexadecimal limit
	cmp	al,BASE_HEX		; Check against upper hex limit
	cmc				; Set carry flag to correct state
Convert_Exit:
	ret				; Return to caller with value and flag
Convert 	Endp			; End of the Convert routine
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Output(Character, Handle)
;
;		Save the required registers
;		Output the character to requested handle
;		Restore the required registers
;		Return to the caller
;
;	Registers on Entry:
;
;		AL    - Character to output
;		AH    - Handle (For output)
;
;	Registers on Exit:
;
;		None
;
;******************************************************************************
Output		Proc	Near		; Output character procedure
	Save	bx,cx,dx,ds		; Save the required registers
	push	ss			; Put a copy of SS onto the stack
	pop	ds			; Setup DS to the current SS value
	Save	ax			; Save the character and handle values
	mov	dx,sp			; Setup buffer pointer into stack
	xchg	al,ah			; Put requested handle into AL
	cbw				; Convert handle to full word
	mov	bx,ax			; Move handle number to BX
	mov	cx,1			; Setup to write one character
	mov	ah,WRITE_FILE		; Get the write file function code
	int	DOS_FUNCTION		; Attempt to write the character
	Restore ax			; Restore the character/handle values
	Restore bx,cx,dx,ds		; Restore required registers
	ret				; Return to the caller
Output		Endp			; End of the Output procedure
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Get_Number(String, Base, Length)
;
;		Save the required registers
;		While length > 0
;			Decrement the length
;			Get the next character from string
;			Call routine to check for a valid digit
;			If character is a valid digit
;				Add new value into total
;			Endif
;		Endwhile
;		Decrement pointer back to last character
;		Restore the required registers
;		Return to the caller
;
;	Registers on Entry:
;
;		CH    - Number Base
;		CL    - Maximum number length
;		DS:SI - Current string pointer
;
;	Registers on Exit:
;
;		CL    - Destroyed
;		DL    - Number retrieved (Zero if none)
;		DS:SI - Pointer to character following number
;		FL    - CY set if no number was found
;			ZR set if zero number found
;
;******************************************************************************
Get_Number	Proc	Near		; Get number procedure
	Save	ax,bx			; Save the required registers
	mov	dl,MAX_BYTE		; Get maximum value for a byte
	xor	ax,ax			; Initialize the current total
Get_Loop:
	mov	bx,ax			; Save current total in BX register
	lodsb				; Get the next string character
	call	Check_Digit		; Call routine to check for digit
	jc	Number_Done		; Jump if this is not a valid digit
	inc	dl			; Increment no number present flag
	cbw				; Convert binary value into full word
	xchg	ax,bx			; Move total to AX, digit value in BX
	mul	ch			; Multiply current total by number base
	add	ax,bx			; Add in the new digit to current total
	dec	cl			; Decrement the number length count
	jnz	Get_Loop		; Jump if more digits are allowed
	mov	bx,ax			; Move the current total into BX
	inc	si			; Increment to next character
Number_Done:
	dec	si			; Decrement back to non-digit character
	add	dl,1			; Set carry to indicate presence
	jc	Number_Exit		; Jump if no number was present
	mov	dl,bl			; Save the computed number in DL
	or	dl,dl			; Set zero flag for zero result
Number_Exit:
	Restore ax,bx			; Restore the required registers
	ret				; Return to the caller
Get_Number	Endp			; End of the Get_Number procedure
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Compute(Argument, Handle, Width, Precision, Base, Flags)
;
;		Save the required registers
;		Allocate buffer space on the stack
;		If argument value is long
;			Get the long numeric value (4 bytes)
;		Else if argument value is short
;			Get the short numeric value (1 byte)
;			Convert short to long value
;		Else argument value is normal
;			Get the normal numeric value (2 bytes)
;			Convert normal to long value
;		Endif
;		If signed type is specified
;			If the value is signed
;				Set the signed value flag
;				Take the twos complement of the value
;			Endif
;		Endif
;		Zero the fraction value (Integer default)
;		If fractional type conversion
;			Separate number into integer and fraction
;		Endif
;		Convert integer to ASCII string in buffer
;		If fractional type conversion
;			Convert fraction to ASCII string in buffer
;		Endif
;		Calculate the numeric string length
;		Default to no sign character
;		If signed type conversion
;			If numeric value was signed (Negative)
;				Setup minus sign as sign character
;				Increment the string length (For sign character)
;			Else numeric value was not signed
;				If signed conversion was specified
;					Setup plus sign as sign character
;					Increment the string length
;				Endif
;			Endif
;		Endif
;		If field width is not set (Zero)
;			Set field width to string length
;		Endif
;		If string length > field width
;			Set the field overflow flag
;			Set string length to field width - 1
;		Endif
;		Call routine to calculate pad counts
;		If sign character is present
;			If pre-pad sign character
;				Output sign character to handle
;				Call routine to output pre-string pad characters
;			Else post-pad sign character
;				Call routine to output pre-string pad characters
;				Output sign character to handle
;			Endif
;		Else sign character is not present
;			Call routine to output pre-string pad characters
;		Endif
;		While length > 0
;			Get next character of string
;			Call routine to output character to handle
;			Decrement the length
;		Endwhile
;		Set current pad character to a space
;		Call routine to output post-string pad characters
;		If the field overflow flag is set
;			Output the overflow character
;		Endif
;		Restore the required registers
;		Return to the caller
;
;	Registers on Entry:
;
;		AH    - Handle
;		DS:SI - Pointer to argument
;		CH    - Current number base
;		DH    - Current field width
;		DL    - Current field precision
;		BP    - Formatting flags
;
;	Registers on Exit:
;
;		FL    - DR flag is cleared (Move Forward)
;
;******************************************************************************
Compute 	Proc	Near		; Output numeric string procedure
	Save	bx,si,ds		; Save the required registers
;
;  Allocate the buffer area on the current stack
;
	sub	sp,BUFF_SIZE		; Allocate buffer space on the stack
	mov	di,sp			; Setup the buffer pointer
	add	di,BUFF_SIZE/2		; Set the starting buffer position
	push	ax			; Save the output handle value
	push	dx			; Save the field width/precision
	xor	dh,dh			; Convert precision to a full word
	push	dx			; Save the field precision
	mov	cl,ch			; Move current base value into CL
	xor	ch,ch			; Make current base value into a word
	xor	ax,ax			; Default to an unsigned
	xor	dx,dx			;			 non-long value
	test	bp,SHORT_SPEC		; Check for short value specified
	jnz	Get_Short		; Jump if short value specified
	test	bp,LONG_SPEC		; Check for long value specified
	jnz	Get_Long		; Jump if long value specified
	mov	ax,ds:[si]		; Get the normal value (2 Bytes)
	test	bp,SIGNED_TYPE		; Check for a signed conversion
	jz	Chk_Frac		; Jump if not a signed conversion
	cwd				; Signed conversion, do sign extension
	jmp	Short Chk_Sign		; Go check for signed argument
Get_Short:
	mov	al,ds:[si]		; Get the short value (1 Byte)
	test	bp,SIGNED_TYPE		; Check for a signed conversion
	jz	Chk_Frac		; Jump if not a signed conversion
	cbw				; Signed conversion,
	cwd				;		     do sign extension
	jmp	Short Chk_Sign		; Go check for signed argument
Get_Long:
	mov	ax,ds:[si]		; Get the
	mov	dx,ds:[si + 2]		;	  long value (4 Bytes)
;
;  If a signed type and a signed number, take the twos complement
;
Chk_Sign:
	test	bp,SIGNED_TYPE		; Check for a signed type
	jz	Chk_Frac		; Jump if not signed
	test	dx,SIGNED		; Check the number for signed
	jz	Chk_Frac		; Jump if number is not signed
	or	bp,SIGNED_VAL		; Set the signed value flag
	not	ax			; Ones complement of the LSW
	not	dx			; Ones complement of the MSW
	add	ax,1			; Twos complement of the LSW
	adc	dx,0			; Twos complement of the MSW
;
;  If a fractional type, separate the integer and the fraction
;
Chk_Frac:
	mov	si,ss			; Get the current stack segment
	mov	ds,si			; Setup DS to current stack segment
	mov	es,si			; Setup ES to current stack segment
	xor	bx,bx			; Zero fraction value (Integer default)
	test	bp,FRACTIONAL		; Check for fractional conversion
	jz	Do_Integer		; Jump if standard integer conversion
	test	bp,SHORT_SPEC		; Check for short value specified
	jnz	Do_Short		; Jump if a short fractional value
	test	bp,LONG_SPEC		; Check for long value specified
	jnz	Do_Long 		; Jump if a long fractional value
	mov	bh,al			; Move fraction value to MSB (BH)
	xor	bl,bl			; Zero the lower LSB of fraction (BL)
	mov	al,ah			; Move integer value to LSB (AL)
	xor	ah,ah			; Zero the upper MSB of integer (AH)
	xor	dx,dx			; Zero the upper MSW of integer (DX)
	jmp	Short Do_Integer	; Go convert the integer portion
Do_Long:
	mov	bx,ax			; Move fraction value to BX
	mov	ax,dx			; Move integer value to LSW (AX)
	xor	dx,dx			; Zero the upper MSW of integer (DX)
	jmp	Short Do_Integer	; Go convert the integer portion
Do_Short:
	mov	bh,al			; Move fraction value to MSB (BH)
	xor	bl,bl			; Zero the lower LSB of fraction (BL)
	xor	ax,ax			; Zero the lower LSW of integer (AX)
	xor	dx,dx			; Zero the upper MSW of integer (DX)
;
;  Convert the integer to ASCII and store in the buffer
;
Do_Integer:
	push	di			; Save the starting position
	cld				; Clear direction flag (Move forward)
Integer_Loop:
	mov	si,ax			; Save LSW of value in SI register
	mov	ax,dx			; Move MSW of value into AX
	xor	dx,dx			; Setup to do the first divide
	div	cx			; Divide the MSW by the current base
	xchg	ax,si			; Setup for the second division
	div	cx			; Divide the result by the current base
	xchg	ax,dx			; Put the remainder into AX
	call	Digit			; Call routine to convert it to a digit
	stosb				; Store the ASCII digit into buffer
	xchg	ax,dx			; Restore quotient of second division
	mov	dx,si			; Restore quotient of first division
	or	si,ax			; Check for a zero result
	jnz	Integer_Loop		; Jump if more digits to get
;
;  Convert the fraction (If any) to ASCII and store in the buffer
;
Do_Fraction:
	pop	dx			; Restore the starting position
	pop	si			; Restore the field precision
	mov	ax,bx			; Get the fraction value into AX
	mov	bx,di			; Save the final position in BX
	mov	di,dx			; Get the starting position
	test	bp,FRACTIONAL		; Check for fractional conversion
	jz	Calc_Length		; Jump if standard integer conversion
	pop	dx			; Restore the field width/precision
	push	dx			; Save the field width/precision
	or	dh,dh			; Check for a zero field width value
	jnz	Set_Position		; Jump if field width was given
	mov	dx,bx			; Get the final position value
	sub	dx,di			; Compute the actual string length
	dec	dx			; Check for a single digit
	jnz	Set_Position		; Jump if more than a single digit
	cmp	Byte Ptr es:[di],ZERO_PAD
	jne	Set_Position		; Jump if single digit is NOT a zero
	test	bp,PAD_CHAR		; Check for zero character pad
	jz	Set_Direction		; Jump if a blank character pad
Set_Position:
	dec	di			; Decrement to get new start position
Set_Direction:
	std				; Set direction flag (Move Backward)
	mov	Byte Ptr es:[di],POINT	; Put a decimal point into buffer
	or	si,si			; Check for zero precision
	jz	Calc_Length		; Jump if no digits to compute
	dec	di			; Update pointer for decimal point
Fraction_Loop:
	mul	cx			; Multiply by the current base
	xchg	ax,dx			; Put the MSW of result into AX
	call	Digit			; Call routine to convert it to a digit
	stosb				; Store the ASCII digit into buffer
	xchg	ax,dx			; Restore fraction from multiply
	dec	si			; Decrement the precision count
	jnz	Fraction_Loop		; Jump if more digits left to do
	inc	di			; Correct for length calculation
Do_Round:
	mul	cx			; Compute the next actual digit
	shl	dx,1			; Multiply digit value by two
	cmp	dx,cx			; Compare value to current base
	jb	Calc_Length		; Jump if below current base value
	push	di			; Save the current position
	mov	ch,cl			; Move current base to CH
Round_Loop:
	mov	al,es:[di]		; Get the digit to round
	call	Convert 		; Convert the ASCII to binary
	inc	al			; Round the digit up
	mov	ah,al			; Save the rounded value in AH
	call	Digit			; Convert the binary digit to ASCII
	cmp	ah,ch			; Check the value against current base
	jb	Round_Done		; Jump if rounding is complete
	xor	al,al			; Zero the AL register value
	call	Digit			; Convert to an ASCII zero value
	mov	es:[di],al		; Zero the current digit value
	inc	di			; Increment to the next digit position
	cmp	di,bx			; Check against final position
	jbe	Round_Loop		; Jump if more digits to round with
	mov	bx,di			; Update the new final position
	xor	al,al			; Zero the AL register value
	inc	al			; Increment AL to a one value
	call	Digit			; Convert the one value to ASCII
Round_Done:
	mov	es:[di],al		; Save the last rounded digit
	pop	di			; Restore the current position
;
;  Calculate the length of the numeric ASCII string
;
Calc_Length:
	pop	dx			; Restore field width/precision
	pop	ax			; Restore the file handle
	mov	cx,bx			; Get the final buffer pointer
	sub	cx,di			; Compute the numeric string length
;
;  Determine whether or not a sign character is needed for the value
;
	xor	al,al			; Default to no sign character
	test	bp,SIGNED_TYPE		; Check for signed type
	jz	Do_Check		; Jump if not a signed type
	test	bp,SIGNED_VAL		; Check for a signed value
	jz	Chk_Conv		; Jump if not a signed value
	mov	al,MINUS		; Setup minus as sign character
	inc	cx			; Increment the string length
	jmp	Short Do_Check		; Go check the field width
Chk_Conv:
	test	bp,SIGNED_CONV		; Check for a signed conversion
	jz	Do_Check		; Jump if not a signed type
	mov	al,PLUS 		; Setup plus as sign character
	inc	cx			; Increment the string length
;
;  Setup the correct field width based on string length
;
Do_Check:
	or	dh,dh			; Check the current field width
	jnz	Width_Check		; Jump if field width specified
	mov	dh,cl			; Set field width to string length
Width_Check:
	cmp	cl,dh			; Check actual width to field width
	jbe	Do_Calc 		; Jump if string fits in the field
	or	bp,OVER_FLOW		; Set the field overflow flag
	mov	cl,dh			; Set string width to field width
	dec	cl			; Adjust for the overflow character
	jz	Compute_Exit		; Jump if no more room in the field
;
;  Calculate the pad counts and handle outputting a sign if necessary
;
Do_Calc:
	push	ax			; Save the sign character (If any)
	mov	al,cl			; Save the actual string length
	call	Calculate		; Call routine to calculate pad values
	mov	dl,al			; Setup the string output length
	pop	ax			; Restore the sign character (If any)
	test	bp,PRE_PAD		; Check for pre pad sign character
	jz	Do_Pad			; Jump if not pre pad sign character
	or	al,al			; Check for a sign needed
	jz	Do_Pad			; Jump if no sign is needed
	call	Output			; Call routine to output sign character
	dec	dl			; Decrement the output count
	jz	Compute_Exit		; Jump if no more room in field
Do_Pad:
	call	Pad			; Call routine to output pad characters
	test	bp,PRE_PAD		; Check for post pad sign character
	jnz	Do_Setup		; Jump if not post pad sign character
	or	al,al			; Check for a sign needed
	jz	Do_Setup		; Jump if no sign character needed
	call	Output			; Call routine to output the sign
	dec	dl			; Decrement the output count
	jz	Compute_Exit		; Jump if no more room in field
Do_Setup:
	mov	si,bx			; Setup the source pointer to buffer
	dec	si			; Point back to first character
	std				; Set direction flag (Reverse order)
;
;  Send the string characters to the output handle
;
Send_Loop:
	lodsb				; Get the next character to output
	call	Output			; Call routine to output character
	dec	dl			; Decrement the output count
	jnz	Send_Loop		; Jump if more characters to output
	mov	cl,ch			; Get the calculated pad counts
;
;  Change pad character, output pad characters and deallocate buffer
;
	and	bp,Not PAD_CHAR 	; Set pad character to a space
	call	Pad			; Call routine to send pad characters
;
;  Restore the registers and return to the caller
;
Compute_Exit:
	test	bp,OVER_FLOW		; Check for field overflow
	jz	Compute_Done		; Jump if no field overflow
	mov	al,ASTERISK		; Get the field overflow character (*)
	call	Output			; Output the field overflow character
Compute_Done:
	add	sp,BUFF_SIZE		; Deallocate the buffer area
	Restore bx,si,ds		; Restore the required registers
	cld				; Clear the direction flag
	ret				; Return to the caller
Compute 	Endp			; End of the Compute procedure
	Page
;******************************************************************************
;
;  Routine Functional Description
;
;	Digit(Value, Flags)
;
;		Save the required registers
;		Translate character to ASCII value
;		If uppercase flag is set
;			If ASCII value is not a digit (abcdef)
;				Convert to uppercase  (ABCDEF)
;			Endif
;		Endif
;		Restore the required registers
;		Return to the caller
;
;	Registers on Entry:
;
;		AL    - Binary value (0 - 15)
;
;	Registers on Exit:
;
;		AL    - ASCII character
;
;******************************************************************************
Digit		Proc	Near		; Convert to ASCII digit procedure
	Save	bx			; Save the required registers
	lea	bx,cs:[Digit_Table]	; Get pointer to digit translate table
	xlat	byte ptr cs:[bx]	; Translate to ASCII digit
	test	bp,UPPER_CASE		; Check for uppercase flag
	jz	Digit_Exit		; Jump if no uppercase flag set
	cmp	al,DIGIT_MAX		; Check for uppercase adjust needed
	jbe	Digit_Exit		; Jump if adjustment not needed
	and	al,UPPER_MASK		; Convert character to uppercase
Digit_Exit:
	Restore bx			; Restore the required registers
	ret				; Return to the caller
Digit		Endp			; End of the Digit procedure
;
;  Define the ASCII digit translation table
;
Digit_Table	Label	Byte		; Digit translation table
	Db	"0123456789abcdef"
;
;  Define the end of the standard code segment
;
Code	Ends				; End of the standard code segment
	End				; End of the Printf module

  .