Oakland CPM Archive/oakcpm.iso/sigm/vol123/mathlib.src

Text File | 1984-04-29 | 10.5 KB | 488 lines

;
; MATHLIB: a 16 Bit Arithmetic Package for 8048
; Sourced Nov-Dec '80 by Trevor Marshall
;            SYSOP, Thousand Oaks Tech RBBS
;
; This package may be freely distributed but not for profit
; (C) 1980 Trevor Marshall
;-----------------------------------------------
;
; This S/R shifts the register pair whose LSB
;   is being pointed at by R0 right one position
; All registers are preserved
ROTATERIGHTR0: CLR C
SHIFTRIGHTR0: INC R0    ;R0 points to the LSB
    MOV    A,@R0    ;get MSB
    RRC    A
    MOV    @R0,A    ;Result MSB
    DEC    R0    ;point at LSB
    MOV    A,@R0    ;get it
    RRC    A
    MOV    @R0,A    ;Store result LSB
    RET
;
;----------------------------------------------
;
; This S/R shifts the register pair whose LSB
;   is being pointed at by R1 right one position
; All registers are preserved
ROTATERIGHTR1: CLR C
SHIFTRIGHTR1: INC R1    ;R1 points to the LSB
    MOV    A,@R1    ;get MSB
    RRC    A
    MOV    @R1,A    ;Result MSB
    DEC    R1    ;point at LSB
    MOV    A,@R1    ;get it
    RRC    A
    MOV    @R1,A    ;Store result LSB
    RET
;
;-----------------------------------------------
;
; This S/R shifts the register pair whose LSB is
;  being indicated by R0 left one position
; All registers are preserved
ROTATELEFTR0: CLR C
SHIFTLEFTR0: MOV A,@R0 ;get LSB
    RLC    A
    MOV    @R0,A    ;Result LSB
    INC    R0    ;Point at MSB
    MOV    A,@R0
    RLC    A
    MOV    @R0,A    ;store MSB
    DEC    R0    ;restore R0
    RET
;
;------------------------------------------------
;
; This S/R shifts the register pair whose LSB is
;  being indicated by R1 left one position
; All registers are preserved
ROTATELEFTR1: CLR C
SHIFTLEFTR1: MOV A,@R1 ;get LSB
    RLC    A
    MOV    @R1,A    ;Result LSB
    INC    R1    ;Point at MSB
    MOV    A,@R1
    RLC    A
    MOV    @R1,A    ;store MSB
    DEC    R1    ;restore R1
    RET
;
;---------------------------------------------------
;
; This S/R, ADD, adds a 16 Bit number pointed at by R1
;  to a sum indicated by R0. The sum (@R0) is updated
;  @R1 is not changed
; All registers preserved
ADD:    CLR    C    ;Add without carry, or with it:
ADDC:    MOV    A,@R0    ;LSB of sum
    ADDC    A,@R1    ; + LSB of number
    MOV    @R0,A    ;New sum LSB to @R0
    INC    R0
    INC    R1    ;point at MSBs
    MOV    A,@R0    ;MSB of sum
    ADDC    A,@R1    ; + MSB of number
    MOV    @R0,A    ;New sum MSB to @R0
    DEC    R0    ;Restore R0, R1
    DEC    R1
    RET
;
;----------------------------------------------------
;
; A S/R to complement a 16 Bit number indicated by R0
; All registers preserved
COMPLEMENTR0: INC R0
    MOV    A,@R0    ;get MSB
    CPL    A
    MOV    @R0,A    ;store its compl
    DEC    R0
    MOV    A,@R0    ;get LSB
    CPL    A    ;Have 1s complemented it, add 1
    CLR    C
    ADD    A,#1
    MOV    @R0,A    ;Store LSB
    INC    R0
    MOV    A,@R0    ;get MSB
    ADDC    A,#0    ;use carry
    MOV    @R0,A    ;store MSB
    DEC    R0    ;restore R0
    RET
;
;------------------------------------------------------
;
;MULTIPLY:  16 x 16 Bit multiplication
;
;result (@R0) = multiplicand (@R1) x multiplier (@R0)
;
; It overflows safely, but without indication
; Registers R4,R5,R6,R7 are destroyed
;
;    Example: 5 x 3
;        101
;         x  011
;    ----------------
;        101    (Shifted LSBit=1)
;           101    (Shifted LSBit=1)
;          000    (Shifted LSBit=0,no add)
;    ----------------
;          01111    (Result)
;
MULTIPLY: MOV    R7,#16    ;Loop count in R7
    CLR    A    ;Clear result
    MOV    R6,A    ;R6 is result MSB
    MOV    R5,A    ;R5 is LSB
; shift and test if multiplier LSBit = 1
ZZMULT:    CALL    ROTATERIGHTR0 ;0-> MSBit,LSBit-> C
    JNC    ZZNOADD ;LSBit not 1, Don't add
;
    MOV    A,R0    ;Save R0 in
    MOV    R4,A    ; R4
    MOV    R0,#5    ;Point at the result R5,R6
    CALL    ADD    ;Add result, multiplicand @R1
    MOV    A,R4    ;Restore
    MOV    R0,A    ;R0
; (Could test for overflow here:)
;
;Now we shift left the multiplicand
ZZNOADD: CALL    ROTATELEFTR1 ;0->LSBit, MSBit->Carry
;
    DJNZ    R7,ZZMULT    ;Loop for 16 Bits
; Now shift the result to @R0
    MOV    A,R1    ;Save R1
    MOV    R4,A    ;in R4
    MOV    R1,#5    ;Point to R5,R6
    MOV    A,@R1    ;Get LSB
    MOV    @R0,A    ;Put LSB
    INC    R0
    INC    R1
    MOV    A,@R1    ;Get MSB
    MOV    @R0,A    ;Put MSB
    DEC    R0    ;Restore R0
    MOV    A,R4    ;Restore R1
    MOV    R1,A
;
    RET    ; ***** DONE *****
;
;-------------------------------------------------------
; MPY8X8, 8 x 8 multiply, 16 Bit product
;
; On Entry
;    R6    contains multiplicand
;    R7       "    multiplier
; On Exit
;    A    contains the result LSB
;    R2       "            MSB
;
; DESTROYS R5, USES A,R5,R6,R7
;
MPY8X8:    CLR    A    ;Clear Result LSB
    MOV    R2,A    ;  "     "    MSB
    MOV    R5,#8    ;Bit cntr
;
SHIFT:    CLR    C    ;Shift multiplicand 16 Bits
    RLC    A
    XCH    A,R2    ;Prepare to
    RLC    A    ;RLC R2
    XCH    A,R2
; Shift left multiplicand
    XCH    A,R6
    RLC    A
    XCH    A,R6
;Test carry
    JNC    DECR
;Else add multiplier
    ADD    A,R7
    XCH    A,R6
    ADDC    A,#0
    XCH    A,R6
DECR:    DJNZ    R5,SHIFT
    RET
;
;-------------------------------------------------------
; DIVIDE  Low byte count 15 / 15 divide
;         the MSBs must not be 1
;
;            divisor(@R1)
;    result(R6,R7) = ---------------
;            dividend(@R0)
;
;Operands are in reverse order to improve efficiency
;DESTROYS divisor(@R0),dividend(@R1),R0,R1,R6,R7
;The dividend is successively subtracted fromthe divisor
;First check if dividend is 0
DIVIDE: MOV    A,@R0    ;Is LSByte=0 ?
    JNZ    OK    ;Skip if OK
    INC    R0    ;Otherwise test MSByte
    ORL    A,@R0    ;A was 0
    JZ    DIVIDEBYZERO
    DEC    R0
;First form the complement of @R0 IN @R0
OK:    CALL    COMPLEMENT    ;@R0
;Now clear result area
    CLR    A
    MOV    R7,A
    MOV    R6,A
;ADD destroys @R0, so swap R1,R0
    MOV    A,R0
    XCH    A,R1
    MOV    R0,A
;
DIVLOOP: CALL    ADD ;Add (subtract) once
    INC    R0
    MOV    A,@R0    ;if MSBit is 1, negative, done
    DEC    R0
    JB7    DONEDIVIDE   ;Done if -ve result
;Else increment R6,R7
; (Trick courtesy of SIGNETICS 2650)
    INC    R6    ;Increment LSB, but dont
    MOV    A,R6
    JNZ    NXT9
    INC    R7    ;incr MSB unless new LSB is 0
;
NXT9:    JMP    DIVLOOP    ;And try to subtract again
;
DIVIDEBYZERO: MOV    R6,#0FCH ;nearly infinite
    MOV    R7,#0FFH
DONEDIVIDE:    RET
;
;------------------------------------------------
;
; BINTOBCD: Converts an 8 Bit Binary value to BCD
;
;------------------------------------------------
;
; The Binary value is in A
; R0 is pointer to the packed BCD string storage
; DESTROYS R1, R5, R6, R7
BINTOBCD: XCH    A,R0    ;Get R0 to R1
    MOV    R1,A    ;without changing A
    XCH    A,R0
;
    MOV    R7,#2    ;2 is digit byte count
;            ;  extension register
;
BINLP1: MOV    @R1,#0    ;Clear the BCD area
    INC    R1
    DJNZ    R7,BINLP1
;
    MOV    R6,#8    ;Bit count
; now do A = A*2
; to get the MSBit into the carry
BINLP2:    CLR    C
    RLC    A
; now do  BCD = BCD*2 + Carry
    XCH    A,R0    ;Get R0
    MOV    R1,A    ;to R1
    XCH    A,R0
    MOV    R7,#2    ;2 is digit byte count
    MOV    R5,A    ;save A in R5
BINLP3:    MOV    A,@R1    ;fetch LSByte of BCD
    ADDC    A,@R1    ;double it + carry
    DA    A
    MOV    @R1,A    ;store it back
    INC    R1    ;point at next BCD byte
    DJNZ    R7,BINLP3 ;process it too
    MOV    A,R5    ;Retrieve A
; If carry from BCDacc could GOTO error exit
    JC    BINERROR
; Count=count-1, until count=0 :
    DJNZ    R6,BINLP2
    CLR    C ;Reset Indicates normal termination
BINERROR: RET      ; C set if error termination
;
;-------------------------------------------------------
;
; BCDTOBIN: Converts a 3 digit BCD value to 8 Bit Binary
;
;-------------------------------------------------------
;
;at entry R0 points to the LSByte of a packed BCD string
;
;at exit A has the result
;     Carry is set if overflow has occurred
; DESTROYS R4,R5,R6,R7
;
; Point at most significant digitpair
; R0 = R0 + #digitpairs - 1
    MOV    A,R0
    ADD    A,#1    ; 2 packed bytes - 1
    MOV    R0,A
; count = #digitpairs
    MOV    R7,#2
; BIN = 0
    CLR    A
    MOV    R4,A
; BIN = BIN*10
BCDLP1:    CALL    MUL10
    JC    CONVERSIONERROR
; BIN = BIN + MSNibble(@R0)
    MOV    R5,A    ;save BIN*10
    MOV    A,@R0    ;get MSDigitpair
    SWAP    A    ;mask except
    ANL    A,#0FH    ;the MSNibble
; Now have the most significant BCD nibble in A
    ADD    A,R5    ;Add BIN*10
    XCH    A,R4    ;to A in
    ADDC    A,#0    ;double
    XCH    A,R4    ;precision
    JC    CONVERSIONERROR
; BIN = BIN * 10
    CALL    MUL10
    JC    CONVERSIONERROR
; bin = bin + LSNibble(@R0)
    MOV    R5,A    ;save R5
    MOV    A,@R0
    ANL    A,#0FH ;get LSNibble of MSDigit
    ADD    A,R5    ;add it to BIN
    XCH    A,R4    ;in
    ADDC    A,#0    ;double
    XCH    A,R4    ;precision
    JC    CONVERSIONERROR
; point now to the next lower digitpair
    DEC    R0
; count = count-1 until 0 repeat proceedure
    DJNZ    R7,BCDLP1
CONVERSIONERROR: RET    ; C cleared normal return
;            ;   set if error return
;
; Utility to multiply BIN by 10
MUL10:    MOV    R5,A    ;save A
    XCH    A,R4    ;save R4
    MOV    R6,A
    XCH    A,R4
; BIN = BIN * 2
    CLR    C
    RLC    A
    XCH    A,R4
    RLC    A
    XCH    A,R4
    JC    MUL10ERROR
; BIN = BIN * 4
    RLC    A
    XCH    A,R4
    RLC    A
    XCH    A,R4
    JC    MUL10ERROR
; BIN = BIN * 5
    ADD    A,R5
    XCH    A,R4
    ADDC    A,R6
    XCH    A,R4
    JC    MUL10ERROR
; BIN = BIN * 10
    RLC    A
    XCH    A,R4
    RLC    A
    XCH    A,R4
;
MUL10ERROR: RET    ; C set if error on return
;
;--------------------------------------------
;
;*************THIS ROUTINE DID NOT WORK*****************
;
;DIVIDE: 16 Bit by 16 Bit Integer Division
;
;          dividend (@R0)
;  result (@R0) = --------------  + remainder (@R6)
;          divisor (@R1)
;
; DESTROYS ALL REGISTERS except R0,R1, in MB0
;    and DESTROYS  R7' (R31) in MB1
; DO NOT CALL THIS ROUTINE WHILST IN MB1
;
; The divisor is successively subtracted from the high
;   order bits of the dividend. After each subtraction
;   the result is used instead of the initial dividend
; The result is increased by 1 each time.
; When the result of the subtraction is negative the
;   partial result is restored by adding the divisor
;   back to it.
; The result is simulataneously decremented by 1
;
;First check if divisor is 0
;
;*************THIS ROUTINE DID NOT WORK*****************
;
DIVIDE:    MOV    A,@R1    ;Is LSByte=0 ?
    JNZ    OK    ;Skip if OK
    INC    R1    ;Otherwise test MSByte
    ORL    A,@R1    ;A was 0
    JZ    DIVIDEBYZEROERROR
    DEC    R1
; Dividend is @R0
;clear result register pair
OK:    CLR    A
    MOV    R7,A ;Use R6, R7 as result pair
    MOV    R6,A
;loop counter,R5
    MOV    R5,#16
;
    CLR    C
;Rotate Dividend left
ZZDIV1:    CALL    SHIFTLEFTR0 ; C  -> LSBit
;                MSBit -> Carry
;Rotate Remainder left
    MOV    A,R0    ;Save R0 in
    MOV    R4,A    ; R4
    MOV    R0,#6    ;Point at R6,R7
    CALL    SHIFTLEFTR0 ;C -> LSBit, MSBit-> C
;Trial subtraction of divisor from result
; Problems here, as need to complement (& change)
;  divisor before we can subtract it.
; So have to use R2,R3 as scratch
    MOV    A,@R1 ;get divisor in R2,R3
    MOV    R2,A
    INC    R1
    MOV    A,@R1
    MOV    R3,A
    DEC    R1  ;still points at divisor
; Now we could do:
;    MOV    R0,#2    ;Point at R2,R3
;    MOV    R1,#6    ;Point at R6,R7
; !!!! CLANG !!!! have destroyed pointer R1
; So we must destroy R7' (R31)
    MOV    R0,#31
    MOV    A,R1    ;Save R1
    MOV    @R0,A    ; in R31
    MOV    R0,#2
    MOV    R1,#6
    CALL    COMPLEMENTR0
    CALL    ADD    ;Result in scratch R2,R3
    MOV    A,R2    ;Copy result to R6,7
    MOV    R6,A
    MOV    A,R3
    MOV    R7,A
;
    MOV    R0,#31
    MOV    A,@R0    ;Get divisor pointer
    MOV    R1,A    ;to R1 again
; Carry must be 1 if borrow occurred (@R0 >= @R1)
    JNC    ZZPOS
;otherwise negative, restore dividend
    MOV    R0,#6    ;remainder regs
    CALL    ADD
;
ZZPOS:    CPL    C ;Calc result bit
;Restore R0
    MOV    A,R4
    MOV    R0,A
;
    DJNZ    R5,ZZDIV1 ;Loop for 16 bits
;
; Shift in last result bit
    CALL    SHIFTLEFTR0
; On exit the result is in @R0, the remainder in R6,R7
;
    RET    ; ***** DONE ****
;
DIVIDEBYZEROERROR: MOV A,#0FFH ;Move #infinity to
    MOV    @R0,A    ;@R0
    INC    R0
    MOV    @R0,A
    DEC    R0
; Output a diagnostic message if desired
    RET
;