|
DataMuseum.dkPresents historical artifacts from the history of: Bogika Butler |
This is an automatic "excavation" of a thematic subset of
See our Wiki for more about Bogika Butler Excavated with: AutoArchaeologist - Free & Open Source Software. |
top - metrics - download
Length: 8704 (0x2200)
Types: TextFile
Names: »DVJMODJ.SA«
└─⟦909f4eb2b⟧ Bits:30009789/_.ft.Ibm2.50006622.imd Mogens Pelles Zilog 80,000 / EOS projekt
└─⟦this⟧ »DVJMODJ.SA«
└─⟦ddcd65152⟧ Bits:30009789/_.ft.Ibm2.50006617.imd Mogens Pelles Zilog 80,000 / EOS projekt
└─⟦this⟧ »DVJMODJ.SA«
NOLIST
INCLUDE RR.RTEQU.SA
INCLUDE RR.MACROS.SA
LIST
*
* FILE RR.RTEQU.SA HAS BEEN INCLUDED
* FILE RR.MACROS.SA HAS BEEN INCLUDED
*
TTL V 0.01 68K EOS PASCAL 32 BIT INTEGER DIVIDE AND MOD SUBROUTINE
DVJMODJ IDNT 0,01 68K EOS PASCAL 32 BIT INTEGER DIVIDE AND MOD SUBROUTINE
SECTION 8
*
* COPYRIGHTED 1980 BY MOTOROLA, INC.
*
* 1980-06-02 : JOHN KAUFMANN
*
* UPDATED FOR EOS PASCAL USE
*
* DVJ - DIVIDE A SIGNED (TWO'S COMPLEMENT)
* LONG INTEGER BY A SIGNED LONG
* INTEGER GIVING A SIGNED LONG
* INTEGER QUOTIENT
*
* MODIFIES REGISTERS: 0 1 2 3 4 5 6 7
* D ? ? ? ? ?
* A
*
* ON ENTRY:
* THE OPERANDS ARE IN ADJACENT D REGISTERS IN
* THE RANGE 0 THROUGH 4. D0 IS ADJACENT TO
* D4. THE NUMBER OF THE REGISTER CONTAINING
* THE DIVIDEND IS CONTAINED IN THE WORD
* FOLLOWING THE CALL TO DVJ. THE DIVISOR IS
* IN THE FOLLOWING REGISTER. D0 FOLLOWS D4.
*
* ON EXIT:
* THE SIGNED LONG INTEGER QUOTIENT
* IS RETURNED IN THE REGISTER SPECIFIED IN THE
* WORD FOLLOWING THE CALL TO DVJ.
* THE V BIT OF THE CONDITION CODE REGISTER IS
* SET IF THE QUOTIENT OVERFLOWED 32 BITS.
* NO OTHER REGISTERS ARE MODIFIED.
*
* ALGORITHM:
* BOTH DIVIDE AND MODULUS USE THE SAME DIVISION
* SUBROUTINE. THE DIVISION ALGORITHM IS DESCRIBED
* AT THE SUBROUTINE.
*
* EXTERNALS
*
XDEF .PDVJ
******
* ENTRY POINT
******
.PDVJ EQU *
MOVEM.L D0-D4/D7/A0-A1,-(A7) ; SAVE REGS
MOVE.L 32(A7),D7 ; GET RETURN ADDR FOR ERROR
ADDQ.L #2,32(A7) ; UPDATE RETURN ADDR ON STACK
BSR.S DIVSUB ; DO DIVISION
MOVE.L D2,(A0) ; PUT QUO ON STACK
MOVE D1,CCR ; UPDATE V BIT
MOVEM.L (A7)+,D0-D4/D7/A0-A1 ; RESTORE REGISTERS
RTS ; DONE
PAGE
*
* COPYRIGHTED 1980 BY MOTOROLA, INC.
*
* 1980-06-02 : JOHN KAUFMANN
*
* MODJ - DIVIDE A SIGNED (TWO'S COMPLEMENT)
* LONG INTEGER BY A SIGNED LONG
* INTEGER GIVING A SIGNED LONG
* INTEGER REMAINDER (MODULUS)
*
* MODIFIES REGISTERS: 0 1 2 3 4 5 6 7
* D ? ? ? ? ?
* A
*
* ON ENTRY:
* THE OPERANDS ARE IN ADJACENT D REGISTERS IN
* THE RANGE 0 THROUGH 4. D0 IS ADJACENT TO
* D4. THE NUMBER OF THE REGISTER CONTAINING
* THE DIVIDEND IS CONTAINED IN THE WORD
* FOLLOWING THE CALL TO MODJ. THE DIVISOR IS
* IN THE FOLLOWING REGISTER. D0 FOLLOWS D4.
*
* ON EXIT:
* THE SIGNED LONG INTEGER REMAINDER
* IS RETURNED IN THE REGISTER SPECIFIED IN THE
* WORD FOLLOWING THE CALL TO MODJ.
* THE V BIT OF THE CONDITION CODE REGISTER IS
* SET IF THE QUOTIENT OF THE DIVISION
* OVERFLOWED 32 BITS.
* NO OTHER REGISTERS ARE MODIFIED.
*
* ALGORITHM:
* BOTH DIVIDE AND MODULUS USE THE SAME DIVISION
* SUBROUTINE. THE DIVISION ALGORITHM IS DESCRIBED
* AT THE SUBROUTINE.
*
* EXTERNALS
*
XDEF .PMODJ
******
* ENTRY POINT
******
.PMODJ EQU *
MOVEM.L D0-D4/D7/A0-A1,-(A7) ; SAVE REGS
MOVE.L 32(A7),D7 ; GET RETURN ADDR FOR ERROR
ADDQ.L #2,32(A7) ; UPDATE RETURN ADDR ON STACK
BSR.S DIVSUB ; DO DIVISION
ASL.L #1,D3 ; IF REMAINDER SHOULD BE NEGATIVE
BPL.S XMODJ1
NEG.L D0 ; .REM := -REM
XMODJ1 EQU * ; FI
MOVE.L D0,(A0) ; PUT REM ON STACK
MOVE D1,CCR ; UPDATE V BIT
MOVEM.L (A7)+,D0-D4/D7/A0-A1 ; RESTORE REGISTERS
RTS ; DONE
PAGE
*
* 1980-06-03 : JOHN KAUFMANN
*
* DIVSUB - LONG INTEGER DIVIDE SUBROUTINE
* DIVIDES A 32-BIT SIGNED (TWO'S
* COMPLEMENT) INTEGER INTO A 32-BIT
* INTEGER GIVING A 32-BIT QUOTIENT
* AND A 32-BIT REMAINDER
*
* MODIFIES REGISTERS: 0 1 2 3 4 5 6 7
* D * * * *
* A * *
*
* ON ENTRY:
* THE REGISTERS D0-D4 AND A0-A1 HAVE
* BEEN SAVED ON THE STACK BEFORE THE
* CALL TO DIVSUB. BEFORE THIS THEY
* WERE SET UP LIKE ON ENTRY TO MODJ
* OR DVJ.
* D7.L POINTS TO WORD CONTAINING REGISTER
* NUMBER OF REGISTER CONTAINING DIVIDEND
*
* ON EXIT:
* D0.L UNSIGNED REMAINDER
* D1.B $FF IF QUOTIENT OVERFLOWED 32 BITS,
* 0 OTHERWISE
* D2.L SIGNED QUOTIENT
* D3 BIT 31 SIGN OF QUOTIENT (1=NEGATIVE)
* BIT 30 SIGN OF REMAINDER (1=NEGATIVE)
* A0.L ADDRESS OF LOCATION ON STACK TO STORE
* RESULT
*
* ALGORITHM:
* THE DIVISION IS PERFORMED BY SHIFTING AND
* SUBTRACTING. FIRST THE SIGNS OF THE QUOTIENT
* AND REMAINDER ARE DETERMINED AND THE DIVIDEND
* AND DIVISOR ARE BOTH MADE POSITIVE. NEXT THE
* DIVISOR IS CHECKED FOR ZERO. IF IT IS ZERO
* THAN THE DIVISION IS ABORTED WITH A DIVIDE BY
* ZERO ERROR. NEXT THE DIVISOR IS SHIFTED LEFT
* UNTIL IT IS GREATER THAN OR EQUAL THE DIVIDEND.
* THE NUMBER OF SHIFTS REQUIRED TO DO THIS IS THE
* NUMBER OF PLACES THE QUOTIENT CAN HAVE AND
* THEREFORE THE NUMBER OF TIMES THE DIVISOR IS
* SHIFTED RIGHT DURING THE DIVISION PROCESS.
* WHICH IS ALSO THE NUMBER OF TIMES THE QUOTIENT
* IS SHIFTED LEFT DURING THE DIVISION. IN THE
* DIVISION LOOP THE DIVISOR IS SUBTRACTED FROM
* THE DIVIDEND. IF THE CARRY IS THEN SET
* (DIVIDEND < DIVISOR) THE DIVISOR IS ADDED BACK
* TO THE DIVIDEND AGAIN SETTING CARRY. THE
* CARRY BIT IS ROTATED INTO THE QUOTIENT. THUS
* THE QUOTIENT ACCUMULATED IS THE ONE'S COMPLEMENT
* OF THE ACTUAL QUOTIENT.
* THE SIGN OF THE QUOTIENT IS THE EXCLUSIVE OR
* OF THE SIGNS OF THE DIVISOR AND DIVIDEND.
* THE SIGN OF THE REMAINDER IS THE SAME AS THE
* SIGN IF THE DIVIDEND.
*
DIVSUB EQU *
MOVE.L D7,A0 ; GET REGISTER NUMBER
MOVE.W (A0),D0
ASL.W #2,D0 ; CONVERT IT TO POINTER
LEA 4(A7,D0),A0
ADDQ.W #4,D0 ; GET ADDR OF DIVISOR
CMP.W #20,D0
BNE.S DIVS1
CLR.W D0
DIVS1 LEA 4(A7,D0),A1
MOVE.L (A0),D0 ; GET DIVIDEND IN D0
MOVE.L (A1),D1 ; GET DIVISOR IN D1
BNE.S DIVS8 ; IF DIVISOR = 0 THEN
MOVEQ.L #4,D1 ; .GIVE DIV BY 0 ERROR
TRAP #14 ; .ABORT
DC.W 0
DIVS8 EQU * ; FI
MOVE.L D0,D3 ; SAVE SIGN OF DIVIDEND
ASR.L #1,D3
BPL.S DIVS2 ; IF DIVIDEND < 0 THEN
NEG.L D0 ; .DIVID := -DIVID
DIVS2 EQU * ; FI
EOR.L D1,D3 ; CALC SIGN OF QUOTIENT
TST.L D1 ; IF DIVISOR < 0 THEN
BPL.S DIVS3
NEG.L D1 ; .DIVIS := -DIVIS
DIVS3 EQU * ; FI
MOVEQ.L #-1,D2 ; INIT QUO := NOT(0)
CLR.B D3 ; SHIFT COUNT := 0
DIVS4 EQU * ; DO
CMP.L D0,D1 ; .WHILE DIVIS < DIVID
BCC.S DIVS5
LSL.L #1,D1 ; .DIVIS := 2*DIVIS
ADDQ.B #1,D3 ; .COUNT := COUNT+1
BRA.S DIVS4 ; OD
DIVS5 EQU *
DIVS7 EQU * ; DO
SUB.L D1,D0 ; .DIVID := DIVID-DIVIS
BCC.S DIVS6 ; .IF DIVID < 0 THEN
ADD.L D1,D0 ; ..DIVID := DIVID+DIVIS
DIVS6 EQU * ; .FI
ROXL.L #1,D2 ; .QUO := 2*QUO+X (ONE'S COMP)
LSR.L #1,D1 ; .DIVIS := DIVIS/2
SUBQ.B #1,D3 ; .COUNT := COUNT-1
BCC.S DIVS7 ; UNTIL COUNT < 0
NOT.L D2 ; CORRECT QUO
MOVE.L D3,D1 ; SAVE SIGN INFO
BPL.S DIVS9 ; IF QUO SHOULD BE NEG THEN
NEG.L D2 ; .QUO := -QUO
DIVS9 EQU * ; FI
NOT.L D1 ; OV := NOT(CALC SIGN) AND QUO SIGN
AND.L D2,D1
SMI D1
RTS ; DONE
END
«eof»