.titl PressMl
;DoubleAdd(a,b) -- a,b pointers to double-precision numbers
;DoubleAddV(a,i) -- a = a+i; where 'i' is a single-precision value
;DoubleSub(a,b) -- a-b
;DoubleShr(a) -- shift a right (arithmetically) by one bit
;DoubleCop(a,b) -- a←b
;MulDiv(a,b,c) returns (unsigned) a*b/c without losing intermediate precision
;MulMod(a,b,c) returns (unsigned) (a*b) rem c
;MulFull(a,b,v) v!0 and v!1 stuffed with (signed) double result a*b
;DivFull(a,b) -- returns (signed) a/b; where 'a' is a double-precision value
;Ugt(a,b) returns true if a>b unsigned 16-bit
;TGr(a,b) returns true if a>b using "true compare"
;BitBLT(table) -- calls BITBLT
savedPC=1
temp=2
extraArguments=3
SWAT=401 ;should be 77400 for real SWAT call
BITBLT=61024
.srel
DoubleAdd: .DoubleAdd
DoubleSub: .DoubleSub
DoubleShr: .DoubleShr
DoubleCop: .DoubleCop
MulDiv: .UMulDiv
MulMod: .MulMod
MulFull: .MulFull
DivFull: .DivFull
DoubleAddV: .DoubleAddImmediate
Ugt: .Ugt
TGr: .TGr
BitBLT: .BitBLT
.ent DoubleAdd,DoubleSub,DoubleShr,DoubleCop,MulDiv,MulMod,MulFull,DoubleAddV,DivFull,Ugt,TGr,BitBLT
.nrel
0
.BitBLT: sta 3 savedPC,2
sta 2,saved2
mov 0,2
sub 1,1 ;AC1←0
BITBLT
lda 2,saved2
lda 3 savedPC,2
jmp 1,3
.DoubleAdd:
sta 3 savedPC,2
sta 1 temp,2 ; => first word of arg 2
mov 1,3
lda 1,1,3 ; word 2 of arg 2
mov 0 3
lda 0,1,3 ; word 2 of arg 1
addz 1,0
sta 0,1,3 ; word 2 of arg 1
lda 0,0,3 ; word 1 of arg 1
lda 1 @temp,2 ; word 1 of arg 2
mov 0,0,szc
inc 0,0
add 1,0
sta 0,0,3 ; word 1 of arg 1
lda 3 savedPC,2
jmp 1,3
.DoubleAddImmediate:
sta 3 savedPC,2
sta 2,saved2
mov 0 3 ; save arg 1
movl# 1 1,snc ; generate high order word of i
sub 2 2,skp ; 0 if positive
adc 2 2 ; -1 if negative
lda 0 1 3 ; word 2 of arg 1
addz 1 0 szc ; add integer
inc 2,2 ; add in carry
sta 0 1 3 ; replace word 2 of arg 1
lda 0 0 3 ; word 1 of arg 1
add 2 0 ; result to ac0
sta 0 0 3 ; store result
lda 2,saved2
lda 3 savedPC,2
jmp 1 3
saved2: 0
.DoubleSub:
sta 3 savedPC,2
sta 1 temp,2 ; => first word of arg 2
mov 1 3
lda 1,1,3 ; word 2 of arg 2
mov 0 3
lda 0,1,3 ; word 2 of arg 1
subz 1,0
sta 0,1,3 ; word 2 of arg 1
lda 0,0,3 ; word 1 of arg 1
lda 1 @temp,2 ; word 1 of arg 2
mov 0,0,szc
inc 0,0
adc 1,0
sta 0,0,3 ; word 1 of arg 1
lda 3 savedPC,2
jmp 1,3
.DoubleShr:
sta 3 savedPC,2
MOV 0,3 ;SAVE POINTER TO NUMBER
LDA 0,0,3 ;HIGH ORDER PART
MOVL# 0,0,SZC ;TEST SIGN BIT
MOVOR 0,0,SKP ;SHIFT IN A 1
MOVZR 0,0 ;SHIFT IN A 0
STA 0,0,3
LDA 1,1,3 ;LOW ORDER
MOVR 1,1 ;SHIFT CARRY BIT IN
STA 1,1,3 ;AND REPLACE
lda 3 savedPC,2
jmp 1,3 ;RETURN INTEGER PART...
.DoubleCop:
sta 3 savedPC,2
mov 0 3 ; destination address
sta 1 temp,2
lda 0 @temp,2 ; high order
sta 0 0,3 ; save it
isz temp,2
lda 0 @temp,2
sta 0 1,3 ; low order
lda 3 savedPC,2
jmp 1,3 ;RETURN INTEGER PART...
.UMulDiv:
sta 3 savedPC,2
mov 2,3 ; stack pointer
mov 0 2 ; a
lda 0 extraArguments,3 ; c
movzr 0 0 ; c/2 for rounding
mul ; go multiply
lda 2 extraArguments,3 ; c
div
mov# 0,0
mov 1 0 ; answer
mov 3 2
lda 3 savedPC,2
jmp 1,3
.MulMod:
sta 3 savedPC,2
mov 2,3 ; stack pointer
mov 0 2 ; a
sub 0 0
mul ; go multiply
lda 2 extraArguments,3 ; c
div
mov# 0,0
mov 3 2 ;div returns remainder in AC0
lda 3 savedPC,2
jmp 1,3
.MulFull:
;this routine uses the following trick. In two's complement notation, -k
; is represented as 2↑16 - k. Thus, for example, an unsigned multiply
; of (2↑16 - k)*(2↑16 - m) would yield 2↑32 - (k + m)*2↑16 + k*m.
; This routine calculates the correction factor k + m and adds it to the
; high order word of the product. Similarly if only one operand is negative.
sta 3 savedPC,2
mov 2 3 ; stack pointer
mov 0 2 ; a
movl# 1,1,snc ; leave a as correction factor if b is negative
sub 0,0 ; otherwise zero correction factor
movl# 2,2,szc ; if a is negative ...
add 1,0 ; ... add b to the correction factor
sta 0,temp,3 ; finally save correction
sub 0,0 ; and clear 0 for multiplication
mul
lda 2,temp,3 ;pick up correction factor
sub 2,0 ; subtract it from high order word
lda 2,extraArguments,3
sta 0,0,2 ;give high order to user
sta 1,1,2 ; and low order
mov 3,2
lda 3,savedPC,2
jmp 1,3
.DivFull:
sta 3 savedPC,2
mov 2 3 ; stack pointer
sta 1,temp,3 ; stash divisor for now
movz 0,2 ; => dividend (and clear carry)
lda 0,0,2 ; high order dividend
lda 1,1,2 ; low order dividend
lda 2,temp,3 ; divisor again
movl# 0,0,snc ; skip if dividend is negative
jmp .+5 ; don't bother with next if positive
neg 1,1,szr ; negate double word dividend
com 0,0,skp
neg 0,0
negz 2,2 ; also negate divisor (leave carry clear)
movl# 2,2,szc ; is divisor negative?
nego 2,2 ; if so, negate it and set carry
div ; div preserves carry
SWAT ; SWAT
mov 1,0,szc ; answer and if carry was set ...
neg 0,0 ; ... negate it
mov 3 2
lda 3 savedPC,2
jmp 1 3
.Ugt: sgtu 0,1
mkzero 0,0,skp
mkminusone 0,0
jmp 1,3
.TGr: sta 3 savedPC,2
subzr 3,3
and 1,3
addl 0,3
adc# 1,0,snc
sub 0,0,skp ; false
adc 0,0 ; true
lda 3 savedPC,2
jmp 1,3
.END