# Prnum32.asm

### From Intellivision Wiki

(Difference between revisions)

m (Protected "Prnum32.asm" ([edit=autoconfirmed] (indefinite) [move=autoconfirmed] (indefinite))) |

## Latest revision as of 09:06, 4 December 2010

## Contents |

# Functions Provided

Entry point | Function provided | Notes |
---|---|---|

PRNUM32.l | Print a 32-bit decimal number | Prints the number left-justified. (The name is PRNUM32.l with a lower-case L at the end, not a 1.) |

PRNUM32.b | Prints the number with leading blanks, right justified in a fixed-width field. | |

PRNUM32.z | Prints the number with leading zeros, right justified in a fixed-width field. |

See source code below for calling convention.

# Examples

(todo... please contribute!)

# Notes

This function uses prnum16.asm. Therefore, you will need to include both this and prnum16.asm in your application if you're printing 32-bit numbers.

# Source Code

;* ======================================================================== *; ;* These routines are placed into the public domain by their author. All *; ;* copyright rights are hereby relinquished on the routines and data in *; ;* this file. -- Joseph Zbiciak, 2008 *; ;* ======================================================================== *; IF (DEFINED PRNUM16) AND ((DEFINED _WITH_PRNUM32)) = 0 ERR "Must INCLUDE PRNUM16 after PRNUM32." ENDI ;; ======================================================================== ;; ;; PRNUM32.l -- Print an unsigned 32-bit number left-justified. ;; ;; PRNUM32.b -- Print an unsigned 32-bit number with leading blanks. ;; ;; PRNUM32.z -- Print an unsigned 32-bit number with leading zeros. ;; ;; ;; ;; AUTHOR ;; ;; Joseph Zbiciak <im14u2c AT globalcrossing DOT net> ;; ;; ;; ;; REVISION HISTORY ;; ;; 30-Mar-2003 Initial complete revision ;; ;; ;; ;; INPUTS for all variants ;; ;; R0 Lower 16 bits of number to print ;; ;; R1 Upper 16 bits of number to print ;; ;; R2 Width of field. Must be >= 5. Ignored by PRNUM32.l. ;; ;; R3 Format word, added to digits to set the color, etc. ;; ;; Note: Bit 15 is ignored and manipulated internally. ;; ;; R4 Pointer to location on screen to print number ;; ;; R5 Return address ;; ;; ;; ;; OUTPUTS ;; ;; R0 Zeroed ;; ;; R1 Trashed ;; ;; R2 Unmodified ;; ;; R3 Unmodified, except for bit 15, which may be set. ;; ;; R4 Points to first character after field. ;; ;; R5 Trashed ;; ;; ;; ;; DESCRIPTION ;; ;; These routines print unsigned 32-bit numbers in a field 5 to 10 ;; ;; positions wide. The number is printed either in left-justified ;; ;; or right-justified format. Right-justified numbers are padded ;; ;; with leading blanks or leading zeros. Left-justified numbers ;; ;; are not padded on the right. ;; ;; ;; ;; See PRNUM16 for a table illustrating output formats. ;; ;; ;; ;; TECHNIQUES ;; ;; This routine uses a 32-by-16 integer divide to cut the 32-bit ;; ;; number into two 5-digit segments. It divides the initial number ;; ;; by 100000. The quotient provides the upper half, and the ;; ;; remainder provides the lower half. ;; ;; ;; ;; Both halves are printed by reusing the PRNUM16 routines. The ;; ;; lower half is always printed using PRNUM16.z. The upper half is ;; ;; printed using one of PRNUM16.l, PRNUM16.b, or PRNUM16.z, based on ;; ;; which entry point the caller used for invoking PRNUM32. ;; ;; ;; ;; The number in the lower half can be in the range 00000...99999. ;; ;; Some of this range is outside the range of a 16-bit value. We ;; ;; handle this by passing a special flag to PRNUM16 in bit 15 of ;; ;; the format word. When set, PRNUM16 will add '5' to the leading ;; ;; digit of the number. When clear, it leaves it unmodified. ;; ;; Thus, when our lower half is in the range 65536...99999, we cope ;; ;; by adding 15536 to the lower 16 bits and setting the "add 5" flag. ;; ;; This works, because the lower 16 bits are in the range 0 - 34463. ;; ;; After the 'tweak', they're in the range 15536 - 49999. ;; ;; ;; ;; NOTES ;; ;; The left-justified variant ignores the field width. ;; ;; ;; ;; This code is fully reentrant, although it has a significant stack ;; ;; footprint. ;; ;; ;; ;; This code does not handle numbers which are too large to be ;; ;; displayed in the provided field. If the number is too large, ;; ;; non-digit characters will be displayed in the initial digit ;; ;; position. Also, the run time of this routine may get excessively ;; ;; large, depending on the magnitude of the overflow. ;; ;; ;; ;; This code requires PRNUM16. Since PRNUM16 requires a minor tweak ;; ;; to support PRNUM32, it must either be included after PRNUM32, or ;; ;; assembled with the symbol "_WITH_PRNUM32" set. ;; ;; ;; ;; CODESIZE ;; ;; 81 words (not including PRNUM16.) ;; ;; ;; ;; To save code size, you can define the following symbols to omit ;; ;; some variants: ;; ;; ;; ;; _NO_PRNUM32.l: Disables PRNUM32.l. Saves 8 words. ;; ;; _NO_PRNUM32.b: Disables PRNUM32.b. Saves 8 words. ;; ;; ;; ;; Defining both symbols saves 18 words total, because it omits ;; ;; some code shared by both routines. ;; ;; ;; ;; STACK USAGE ;; ;; This function uses up to 8 words of stack space. That includes ;; ;; 4 words of stack space consumed by PRNUM16 when printing the ;; ;; two halves of the number. ;; ;; ======================================================================== ;; IF (DEFINED PRNUM32) = 0 PRNUM32 PROC IF (DEFINED _NO_PRNUM32.l) = 0 ;; ---------------------------------------------------------------- ;; ;; PRNUM32.l: Print unsigned, left-justified. ;; ;; ---------------------------------------------------------------- ;; @@l: TSTR R1 BEQ PRNUM16.l PSHR R5 MVII #PRNUM16.l, R5 B @@com ENDI IF (DEFINED _NO_PRNUM32.b) = 0 ;; ---------------------------------------------------------------- ;; ;; PRNUM32.b: Print unsigned with leading blanks. ;; ;; ---------------------------------------------------------------- ;; @@b: TSTR R1 BEQ PRNUM16.b PSHR R5 MVII #PRNUM16.b, R5 B @@com ENDI ;; ---------------------------------------------------------------- ;; ;; PRNUM32.z: Print unsigned with leading zeros. ;; ;; ---------------------------------------------------------------- ;; @@z: TSTR R1 BEQ PRNUM16.z PSHR R5 IF NOT ((DEFINED _NO_PRNUM32.l) AND (DEFINED _NO_PRNUM32.b)) MVII #PRNUM16.z, R5 ENDI @@com PSHR R2 ; save our field width PSHR R3 ; save our format word ;; ---------------------------------------------------------------- ;; ;; Divide the 32-bit number by 100000, and remember the remainder. ;; ;; This will give us two 5-digit numbers for the two halves. ;; ;; The upper half will always be in the range 0 to 42949, and so ;; ;; we can print it with one of the PRNUM16 routines. The lower ;; ;; half is in the range 0...99999, so we have to do some fancy ;; ;; footwork in the case that it's above 65535. ;; ;; ;; ;; The loop below looks like it divides by 50000, but really we've ;; ;; aligned the divisor within a 16-bit number. ;; ;; ---------------------------------------------------------------- ;; MVII #50000, R2 ; 100000, right shifted by 1. MVII #1, R3 ; Divide is done when this bit falls out of R3 B @@div1 ; jump to the first divide step. @@div: RLC R0, 1 ;\__ 32 bit left shift of numerator. RLC R1, 1 ;/ BC @@divf ; last shift overflowed, force a subtract @@div1: CMPR R2, R1 ; can we subtract from upper half? BNC @@divn ; nope, then don't subtract. @@divf: SUBR R2, R1 ; subtract upper half. SETC ; usu. the SUBR sets carry, except when forced @@divn: RLC R3, 1 ; left-shift the quotient, including new bit BNC @@div ; loop until quotient is full. ;; ---------------------------------------------------------------- ;; ;; At this point, R1:R0 is our remainder, and R3 is our quotient. ;; ;; The remainder occupies the upper 17 bits of the R1:R0 pair. ;; ;; For now, hide this on the stack. We do this dance carefully ;; ;; since we need to restore two items from the stack as well, ;; ;; and we don't want to lose the values in R4 or R5 either. ;; ;; ;; ;; If there was no "upper half" (eg. our value is 65536...99999) ;; ;; go handle that case specially. Urgl. ;; ;; ---------------------------------------------------------------- ;; SLLC R0, 1 ; put 17th bit into carry MOVR R3, R0 ; save quotient into R0 PULR R3 ; recall our format word into R3 PULR R2 ; recall our field width RLC R1, 1 ; R1 is bits 15 downto 0 of remainder SLL R3, 1 ; \_ Force bit 15 of format word to 1 or 0. RRC R3, 1 ; / This will add 5 to leading digit. TSTR R3 ; BPL @@lt64k ; if there was no carry, rmdr is 0...65535 ADDI #15536, R1 ; add "15536" to rest of digits @@lt64k: TSTR R0 BEQ @@notop ; convert bottom into top if top = 0. PSHR R2 ; save field width on stack PSHR R3 ; save format word for bottom half PSHR R1 ; save quotient for bottom half ;; ---------------------------------------------------------------- ;; ;; Go ahead and print the first 5 digits of the result. ;; ;; ---------------------------------------------------------------- ;; SUBI #5, R2 ; bottom accounts for 5 digits of field width ANDI #$7FFF, R3 ; force bit 15 of R3 clear. IF (DEFINED _NO_PRNUM32.l) AND (DEFINED _NO_PRNUM32.b) CALL PRNUM16.z ELSE MOVR R5, R1 ; R5 contains branch target. MVII #@@ret, R5 ; remember return address. MOVR R1, PC ; call one of PRNUM16.z, .b, or .l as needed @@ret: ENDI ;; ---------------------------------------------------------------- ;; ;; Print the bottom half of the number. We branch into the ;; ;; heart of PRNUM16, which effectively always leads with zeros. ;; ;; ---------------------------------------------------------------- ;; MVII #4, R2 ; bottom is always exactly 5 digits. PULR R0 ; get bits 15 downto 0 of remainder PULR R3 ; get format word. INCR SP ; save garbage in R1 slot on stack MVII #_PW10, R1 ; need to set up power-of-10 pointer first B PRNUM16.dig1 ; chain return via PRNUM16.digit ;; ---------------------------------------------------------------- ;; ;; If there was no "upper half", convert the "lower half" into an ;; ;; upper half. This actually isn't too gross. ;; ;; ---------------------------------------------------------------- ;; @@notop: MOVR R1, R0 ; convert bottom half to top half IF (DEFINED _NO_PRNUM32.l) AND (DEFINED _NO_PRNUM32.b) PULR R5 B PRNUM16.z ELSE MOVR R5, R1 ; \ PULR R5 ; |__ chain return via target PRNUM16 routine JR R1 ; / ENDI ENDP ENDI ;; ======================================================================== ;; ;; End of File: prnum32.asm ;; ;; ======================================================================== ;;