Add original unix v6

This commit is contained in:
memnoth
2018-01-27 22:35:41 +09:00
commit 2c7099ee50
664 changed files with 106254 additions and 0 deletions
+212
View File
@@ -0,0 +1,212 @@
ldfps = 170100^tst
stfps = 170200^tst
/
.globl atan, _atan
.globl atan2, _atan2
/
/ floating-point arctangent
/
/ atan replaces the value in fr0 by its arctangent
/ in the range [-pi/2,pi/2].
/
/ atan2 places in fr0 the arctangent of fr0/fr1
/ in the range [-pi,pi].
/
/ there are no error exits
/
/ coefficients are #5076 from Hart & Cheney.
/
/
_atan:
mov r5,-(sp)
mov sp,r5
movf 4(r5),fr0
jsr pc,atan
br 1f
_atan2:
mov r5,-(sp)
mov sp,r5
movf 4(r5),fr0
movf 12.(r5),fr1
jsr pc,atan2
1:
mov (sp)+,r5
rts pc
atan:
jsr r0,save
tstf fr0
cfcc
blt 1f
jsr pc,satan
br ret
1:
negf fr0
jsr pc,satan
negf fr0
br ret
/
atan2:
jsr r0,save
clr -(sp)
tstf fr0
cfcc
bge 1f
inc (sp)
negf fr0
1:
tstf fr1
cfcc
beq 2f
bgt 1f
add $2,(sp)
negf fr1
1:
divf fr1,fr0
jsr pc,satan
br 1f
2:
movf pi2,fr0
1:
bit $2,(sp)
beq 1f
negf fr0
addf pi2,fr0
addf pi2,fr0
1:
bit $1,(sp)+
beq 1f
negf fr0
1:
ret:
ldfps (sp)+
movf (sp)+,fr3
movf (sp)+,fr2
movf (sp)+,fr1
mov (sp)+,r0
rts pc
save:
movf fr1,-(sp)
movf fr2,-(sp)
movf fr3,-(sp)
stfps -(sp)
ldfps $40200 / DP, no interrupt
jmp (r0)
satan:
cmpf sq2m1,fr0
cfcc
bge arctan
cmpf sq2p1,fr0
cfcc
bgt 1f
movf one,fr1
divf fr0,fr1
movf fr1,fr0
jsr pc,arctan
negf fr0
addf pi2,fr0
rts pc
1:
movf fr0,fr1
subf one,fr0
addf one,fr1
divf fr1,fr0
jsr pc,arctan
addf pi4,fr0
rts pc
arctan:
mov $p4p,r0
mov $4,-(sp)
movf fr0,fr3
mulf fr3,fr3
movf *(r0)+,fr1
1:
mulf fr3,fr1
addf *(r0)+,fr1
dec (sp)
bne 1b
mov $4,(sp)
movf fr3,fr2
br 2f
1:
mulf fr3,fr2
2:
addf *(r0)+,fr2
dec (sp)
bne 1b
tst (sp)+
divf fr2,fr1
mulf fr1,fr0
rts pc
.data
p4p:
p4;p3;p2;p1;p0
q3;q2;q1;p0
one: 40200;0;0;0
pi2: 40311;7732;121041;64302
pi4: 40111;7732;121041;64302
sq2p1: 40432
101171
114774
167461
sq2m1: 37724
11714
147747
74621
p4: 37442
145026
75504
15621
p3: 40725
21566
115517
50305
p2: 41443
160206
172714
25441
p1: 41632
172223
76027
56645
p0: 41462
25125
6152
126064
q3: 41170
10112
141724
64324
q2: 41573
53776
25372
71522
q1: 41670
123114
51576
75020
/ one = 1.00000 00000 00000 00000 d0
/ sq2p1=2.41421 35623 73095 04880 d0
/ sq2m1= .41421 35623 73095 04880 d0
/ pi2 = 1.57079 63267 94896 61923 d0
/ p4 = .15897 40288 48230 7048 d0
/ p3 = .66605 79017 00926 2658 d1
/ p2 = .40969 26483 21022 5637 d2
/ p1 = .77477 68771 92042 0862 d2
/ p0 = .44541 34005 92906 8032 d2
/ q4 = .10000 00000 00000 0000 d1
/ q3 = .15503 97755 14219 8753 d2
/ q2 = .62835 93051 10323 7683 d2
/ q1 = .92324 80107 23009 7484 d2
/ q0 = .44541 34005 92906 8044 d2
+155
View File
@@ -0,0 +1,155 @@
/ crypt -- password incoding
/ mov $key,r0
/ jsr pc,crypt
.globl crypt, _crypt
.globl savr5
_crypt:
mov r5,-(sp)
mov sp,r5
mov r5,savr5
mov 4(r5),r0
jsr pc,crypt
clr savr5
mov (sp)+,r5
rts pc
crypt:
mov r1,-(sp)
mov r2,-(sp)
mov r3,-(sp)
mov r4,-(sp)
mov r5,-(sp)
mov r0,r1
mov $key,r0
movb $004,(r0)+
movb $034,(r0)+
1:
cmp r0,$key+64.
bhis 1f
movb (r1)+,(r0)+
bne 1b
1:
dec r0
/
/
/ fill out key space with clever junk
/
mov $key,r1
1:
movb -1(r0),r2
movb (r1)+,r3
xor r3,r2
movb r2,(r0)+
cmp r0,$key+128.
blo 1b
/
/
/ establish wheel codes and cage codes
/
mov $wheelcode,r4
mov $cagecode,r5
mov $256.,-(sp)
2:
clr r2
clr (r4)
mov $wheeldiv,r3
3:
clr r0
mov (sp),r1
div (r3)+,r0
add r1,r2
bic $40,r2
bis shift(r2),(r4)
cmp r3,$wheeldiv+6.
bhis 4f
bis shift+4(r2),(r5)
4:
cmp r3,$wheeldiv+10.
blo 3b
sub $2,(sp)
tst (r4)+
tst (r5)+
cmp r4,$wheelcode+256.
blo 2b
tst (sp)+
/
.data
shift: 1;2;4;10;20;40;100;200;400;1000;2000;4000;10000;20000;40000;100000
1;2
wheeldiv: 32.; 18.; 10.; 6.; 4.
.bss
cagecode: .=.+256.
wheelcode: .=.+256.
.text
/
/
/ make the internal settings of the machine
/ both the lugs on the 128 cage bars and the lugs
/ on the 16 wheels are set from the expanded key
/
mov $key,r0
mov $cage,r2
mov $wheel,r3
1:
movb (r0)+,r1
bic $!177,r1
asl r1
mov cagecode(r1),(r2)+
mov wheelcode(r1),(r3)+
cmp r0,$key+128.
blo 1b
/
/
/ now spin the cage against the wheel to produce output.
/
mov $word,r4
mov $wheel+128.,r3
3:
mov -(r3),r2
mov $cage,r0
clr r5
1:
bit r2,(r0)+
beq 2f
incb r5
2:
cmp r0,$cage+256.
blo 1b
/
/ we have a piece of output from current wheel
/ it needs to be folded to remove lingering hopes of
/ inverting the function
/
mov r4,-(sp)
clr r4
div $26.+26.+10.,r4
add $'0,r5
cmp r5,$'9
blos 1f
add $'A-'9-1,r5
cmp r5,$'Z
blos 1f
add $'a-'Z-1,r5
1:
mov (sp)+,r4
movb r5,(r4)+
cmp r4,$word+8.
blo 3b
/
mov (sp)+,r5
mov (sp)+,r4
mov (sp)+,r3
mov (sp)+,r2
mov (sp)+,r1
mov $word,r0
rts pc
.bss
key: .=.+128.
word: .=.+32.
cage: .=.+256.
wheel: .=.+256.
+19
View File
@@ -0,0 +1,19 @@
/ C library -- signed dp add
/ dpadd(l, i)
/ int l[2];
/ l =+ i;
.globl _dpadd
_dpadd:
mov r5,-(sp)
mov sp,r5
mov 4(r5),r0
tst 6(r5)
sxt r1
add r1,(r0)+
add 6(r5),(r0)
adc -(r0)
mov (sp)+,r5
rts pc
+176
View File
@@ -0,0 +1,176 @@
ldfps = 170100^tst
stfps = 170200^tst
/ ftoa -- basic g fp conversion
.globl _ndigit
.globl ecvt
.globl fcvt
/ ecvt converts fr0 into decimal
/ the string of converted digits is pointed to by r0.
/ the number of digits are specified by _ndigit
/ r2 contains the decimal point
/ r1 contains the sign
.globl _ecvt, _fcvt
_ecvt:
mov r5,-(sp)
mov sp,r5
mov r2,-(sp)
movf 4(r5),fr0
mov 14(r5),_ndigit
jsr pc,ecvt
br 1f
_fcvt:
mov r5,-(sp)
mov sp,r5
mov r2,-(sp)
movf 4(r5),fr0
mov 14(r5),_ndigit
jsr pc,fcvt
1:
mov r2,*16(r5)
mov r1,*20(r5)
mov (sp)+,r2
mov (sp)+,r5
rts pc
fcvt:
clr eflag
br 1f
ecvt:
mov $1,eflag
1:
stfps -(sp)
ldfps $200
movf fr0,-(sp)
movf fr1,-(sp)
mov r3,-(sp)
mov $buf,r1
clr r2
clr sign
tstf fr0
cfcc
beq zer
bgt 1f
inc sign
negf fr0
1:
modf $one,fr0
tstf fr1
cfcc
beq lss
gtr:
movf fr0,-(sp)
movf fr1,fr0
1:
mov $buftop,r3
1:
modf tenth,fr0
movf fr0,fr2
movf fr1,fr0
addf $epsilon,fr2
modf $ten,fr2
movfi fr3,r0
add $'0,r0
movb r0,-(r3)
inc r2
tstf fr0
cfcc
bne 1b
/
mov $buf,r1
1:
movb (r3)+,(r1)+
cmp r3,$buftop
blo 1b
/
movf (sp)+,fr0
br pad
zer:
inc r2
br pad
lss:
dec r2
modf $ten,fr0
tstf fr1
cfcc
beq lss
inc r2
jsr pc,digit1
pad:
jsr pc,digit
br out
br pad
digit:
cmp r1,$buftop
bhis 1f
add $2,(sp)
modf $ten,fr0
digit1:
movfi fr1,r0
add $'0,r0
movb r0,(r1)+
1:
rts pc
/
out:
mov $buf,r0
add _ndigit,r0
tst eflag
bne 1f
add r2,r0
1:
cmp r0,$buf
blo outout
movb (r0),r3
add $5,r3
movb r3,(r0)
1:
cmpb (r0),$'9
ble 1f
movb $'0,(r0)
cmp r0,$buf
blos 2f
incb -(r0)
br 1b
2:
movb $'1,(r0)
inc r2
1:
outout:
mov sign,r1
mov _ndigit,r0
tst eflag
bne 1f
add r2,r0
1:
clrb buf(r0)
mov $buf,r0
mov (sp)+,r3
movf (sp)+,fr1
movf (sp)+,fr0
ldfps (sp)+
rts pc
epsilon = 037114
one = 40200
ten = 41040
.data
tenth: 037314; 146314; 146314; 146315
_ndigit:10.
.bss
buf: .=.+40.
buftop:
sign: .=.+2
eflag: .=.+2
.text
+117
View File
@@ -0,0 +1,117 @@
.globl exp, _exp
/
ldfps = 170100^tst
stfps = 170200^tst
ldexp = 176400^movif
stexp = 175000^movfi
/
/ exp accepts its argument and returns its result
/ in fr0. The carry bit is set if the result overflows.
/ The coefficients are #1067 from Hart & Cheney.
/
/ movf arg,fr0
/ jsr pc,exp
/ movf fr0,result
/
_exp:
mov r5,-(sp)
mov sp,r5
mov 4(r5),fr0
jsr pc,exp
mov (sp)+,r5
rts pc
exp:
stfps -(sp)
ldfps $200 /di mode
movf fr2,-(sp)
movf fr1,-(sp)
tstf fr0
cfcc
bne 1f
movf $one,fr0 /exp(0)
clc
br out
1:
modf log2e,fr0 /exp(x) = 2^(x*log2(e))
cfcc
bmi 2f
movfi fr1,-(sp) /save integer part
subf $half,fr0
br 3f
2:
movfi fr1,-(sp)
dec (sp)
addf $half,fr0
3:
movf fr0,fr1 / -.5 < x < +.5
mulf fr1,fr1 /arg**2
/
movf P2,fr2
mulf fr1,fr2
addf P1,fr2
mulf fr1,fr2
addf P0,fr2
mulf fr2,fr0 /xP(x**2)
/
movf fr1,fr2
addf Q1,fr2
mulf fr1,fr2
addf Q0,fr2 /Q(x**2)
/
movf fr2,fr1
subf fr0,fr1
addf fr2,fr0
divf fr1,fr0 /(Q+xP)/(Q-xP)
mulf sqrt2,fr0
/
stexp fr0,-(sp)
add (sp)+,(sp)
/
cmp (sp),$177
ble 2f
tst (sp)+
movf big,fr0 /overflow
sec
br 1f
2:
cmp (sp),$-177
bge 2f
tst (sp)+
clrf fr0 /underflow
clc
br 1f
2:
ldexp (sp)+,fr0
clc
1:
out:
movf (sp)+,fr1
movf (sp)+,fr2
ldfps (sp)+
rts pc
/
/
.data
P0: 42675; 36404; 77563; 46675
P1: 41241; 116724; 114237; 60333
P2: 36675; 27102; 125560; 136652
Q0: 43210; 100661; 76072; 62453
Q1: 42151; 27450; 75350; 112503
log2e: 40270; 125073; 24534; 13761
sqrt2: 40265; 02363; 31771; 157144
half = 40000
one = 40200
/
big: 77777; 177777; 177777; 177777
/
/ P0 = .15139 06799 05433 89158 94328 d4
/ P1 = .20202 06565 12869 27227 886 d2
/ P2 = .23093 34775 37502 33624 d-1
/
/ Q0 = .43682 11662 72755 84984 96814 d4
/ Q1 = .23318 42114 27481 62379 0295 d3
/ Q2 = .1 d1
/
/ log2e = 1.44269 50408 88963 40735 99246
/ sqrt2 = 1.41421 35623 73095 04880 16887
+10
View File
@@ -0,0 +1,10 @@
/ fakefp -- fake floating point simulator
.globl fptrap
fptrap:
sub $2,(sp)
mov r0,-(sp)
sys signal; 4; 0
mov (sp)+,r0
2 / rti
+40
View File
@@ -0,0 +1,40 @@
.globl _floor, _ceil
.globl floor, ceil
one = 40200
_floor:
mov r5,-(sp)
mov sp,r5
movf 4(r5),fr0
jsr pc,floor
br 1f
_ceil:
mov r5,-(sp)
mov sp,r5
movf 4(r5),fr0
jsr pc,ceil
1:
mov (sp)+,r5
rts pc
floor:
tstf fr0
cfcc
bge 1f
modf $one,fr0
cfcc
beq 2f
subf $one,fr1
br 2f
1:
modf $one,fr0
2:
movf fr1,fr0
rts pc
ceil:
negf fr0
jsr pc,floor
negf fr0
rts pc
+17
View File
@@ -0,0 +1,17 @@
/ C floating mod
/ fmod(a,b) returns a number n such that
/ i*b + n is a and 0 <= n < b
.globl _fmod
_fmod:
mov r5,-(sp)
mov sp,r5
movf 4(r5),fr0
divf 12.(r5),fr0
modf $one,fr0
mulf 12.(r5),fr1
movf 4(r5),fr0
subf fr1,fr0
mov (sp)+,r5
rts pc
one = 40200
+427
View File
@@ -0,0 +1,427 @@
/ fp1 -- floating point simulator
rti = 2
bpt = 3
m.ext = 200 / long mode bit
m.lngi = 100 / long integer mode
.globl fptrap
.globl ac0, ac1, ac2, ac3
fptrap:
dec reenter
bge 1f
4 / reentered!
1:
mov (sp)+,spc
mov (sp)+,sps
mov r0,sr0
mov $sr1,r0
mov r1,(r0)+
mov r2,(r0)+
mov r3,(r0)+
mov r4,(r0)+
mov r5,(r0)+
mov sp,(r0)+
sub $8,sp / room for double push
mov (r0),r5 / pc
clr trapins
mov -(r5),r5 / trapped instruction
mov r5,r4
bic $7777,r4
cmp r4,$170000
beq 1f
jmp badins
1:
bic $100000,fpsr / clear fp error
bic $170000,r5
mov r5,r4
bit $7000,r4
bne class3
bit $700,r4
bne class2
cmp r4,$12
blos 1f
jmp badins
1:
asl r4
jmp *1f(r4)
.data
1:
i.cfcc / 170000
i.setf / 170001
i.seti / 170002
badins
badins
badins
badins
badins
badins
i.setd / 170011
i.setl / 170012
.text
class2:
cmp r5,$400
bge 1f
jsr r1,fsrc; mod0rx; mod242
br 2f
1:
jsr r1,fsrc; mod0f; mod24f
2:
mov r3,r5
asl r4
asl r4
clrb r4
swab r4
asl r4
jsr pc,*1f(r4)
jmp sret
.data
1:
badins / 1700xx
i.ldfps / 1701xx
i.stfps / 1702xx
badins / 1703xx - stst
i.clrx / 1704xx
i.tstx / 1705xx
i.absx / 1706xx
i.negx / 1707xx
.text
class3:
cmp r5,$5000
blt 1f
mov r5,r2
clrb r2
cmp r2,$6400
blt 2f
sub $1400,r2
2:
cmp r2,$5000
bne 2f
jsr r1,fsrc; mod0rx; mod242
br 3f
2:
cmp r2,$5400
bne 2f
jsr r1,fsrc; mod0ra; mod24i
br 3f
2:
jsr r1,fsrc; mod0f; mod24d
br 3f
1:
jsr r1,fsrc; mod0f; mod24f
3:
jsr pc,freg
mov r2,r5
clrb r4
swab r4
asl r4
jsr pc,*1f(r4)
br sret
.data
1:
badins / 1700xx
badins / 1704xx
i.mulx / 1710xx
i.modx / 1714xx
i.addx / 1720xx
i.ldx / 1724xx
i.subx / 1730xx
i.cmpx / 1734xx
i.stx / 1740xx
i.divx / 1744xx
i.stexp / 1750xx
i.stcxj / 1754xx
i.stcxy / 1760xx
i.ldexp / 1764xx
i.ldcjx / 1770xx
i.ldcyx / 1774xx
.text
i.cfcc:
mov fpsr,r0
bic $!17,r0
mov r0,sps
br ret
i.setf:
bic $m.ext,fpsr
br ret
i.setd:
bis $m.ext,fpsr
br ret
i.seti:
bic $m.lngi,fpsr
br ret
i.setl:
bis $m.lngi,fpsr
br ret
badins:
inc trapins
br ret
sret:
mov $fpsr,r0
bic $17,(r0)
tst (r5)
bpl 1f
bis $10,(r0)
br ret
1:
bne ret
bis $4,(r0)
ret:
mov $sr1,r0
mov (r0)+,r1
mov (r0)+,r2
mov (r0)+,r3
mov (r0)+,r4
mov (r0)+,r5
mov (r0)+,sp
mov sr0,r0
mov sps,-(sp)
mov spc,-(sp)
tst trapins
bne 1f
inc reenter
rti
1:
bpt
freg:
mov r5,r2
bic $!300,r2
asr r2
asr r2
asr r2
add $ac0,r2
rts pc
fsrc:
mov r5,r3
bic $!7,r3 / register
asl r3
add $sr0,r3
mov r5,r0
bic $!70,r0 / mode
asr r0
asr r0
jmp *1f(r0)
.data
1:
mod0
mod1
mod2
mod3
mod4
mod5
mod6
mod7
.text
mod24f:
mov $4,r0
bit $m.ext,fpsr
beq 1f
add $4,r0
1:
rts pc
mod24d:
mov $8,r0
bit $m.ext,fpsr
beq 1f
sub $4,r0
1:
rts pc
mod242:
mov $2,r0
rts pc
mod24i:
mov $2,r0
bit $m.lngi,fpsr
beq 1f
add $2,r0
1:
rts pc
mod0:
jmp *(r1)+
mod0f:
sub $sr0,r3 / get fp ac
cmp r3,$6*2
bhis badi1
asl r3
asl r3
add $ac0,r3
tst (r1)+
rts r1
mod0ra:
bit $m.lngi,fpsr
bne badi1
mod0r:
cmp r3,$ssp
bhis badi1
mod0rx:
tst (r1)+
rts r1
mod1:
cmp r3,$spc
beq badi1
mov (r3),r3
br check
mod2:
mov (r3),-(sp)
jsr pc,*2(r1)
cmp r3,$spc
bne 1f
mov $2,r0
mov *(r3),pctmp
mov $pctmp,(sp)
1:
add r0,(r3)
mov (sp)+,r3
br check
mod3:
mov *(r3),-(sp)
add $2,(r3)
mov (sp)+,r3
br check
mod4:
cmp r3,$spc / test pc
beq badi1
jsr pc,*2(r1)
sub r0,(r3)
mov (r3),r3
br check
mod5:
cmp r3,$spc
beq badi1
sub $2,(r3)
mov *(r3),r3
br check
mod6:
mov *spc,-(sp)
add $2,spc
add (r3),(sp)
mov (sp)+,r3
br check
mod7:
jsr r1,mod6; ..; ..
mov (r3),r3
br check
badi1:
jmp badins
check:
bit $1,r3
bne badi1
cmp (r1)+,(r1)+
rts r1
setab:
mov $asign,r0
jsr pc,seta
mov r3,r2
mov $bsign,r0
seta:
clr (r0)
mov (r2)+,r1
mov r1,-(sp)
beq 1f
blt 2f
inc (r0)+
br 3f
2:
dec (r0)+
3:
bic $!177,r1
bis $200,r1
br 2f
1:
clr (r0)+
2:
mov r1,(r0)+
mov (r2)+,(r0)+
bit $m.ext,fpsr
beq 2f
mov (r2)+,(r0)+
mov (r2)+,(r0)+
br 3f
2:
clr (r0)+
clr (r0)+
3:
mov (sp)+,r1
asl r1
clrb r1
swab r1
sub $200,r1
mov r1,(r0)+ / exp
rts pc
norm:
mov $areg,r0
mov (r0)+,r1
mov r1,-(sp)
mov (r0)+,r2
bis r2,(sp)
mov (r0)+,r3
bis r3,(sp)
mov (r0)+,r4
bis r4,(sp)+
bne 1f
clr asign
rts pc
1:
bit $!377,r1
beq 1f
clc
ror r1
ror r2
ror r3
ror r4
inc (r0)
br 1b
1:
bit $200,r1
bne 1f
asl r4
rol r3
rol r2
rol r1
dec (r0)
br 1b
1:
mov r4,-(r0)
mov r3,-(r0)
mov r2,-(r0)
mov r1,-(r0)
rts pc
+194
View File
@@ -0,0 +1,194 @@
/ fp2 -- floating point simulation
i.ldx:
mov (r3)+,(r2)+
mov (r3)+,(r2)+
bit $m.ext,fpsr
beq 1f
mov (r3)+,(r2)+
mov (r3)+,(r2)+
rts pc
1:
clr (r2)+
clr (r2)+
rts pc
i.stx:
mov (r2)+,(r3)+
mov (r2)+,(r3)+
bit $m.ext,fpsr
beq 1f
mov (r2)+,(r3)+
mov (r2)+,(r3)+
1:
rts pc
i.clrx:
clr (r3)+
clr (r3)+
bit $m.ext,fpsr
beq 1f
clr (r3)+
clr (r3)+
1:
rts pc
i.negx:
tst (r3)
beq 1f
add $100000,(r3)
1:
rts pc
i.absx:
bic $!77777,(r3)
rts pc
i.tstx:
rts pc
i.cmpx:
mov $areg,r5
tst (r2)
bge 1f
tst (r3)
bge 1f
cmp (r2),(r3)
bgt 4f
blt 3f
1:
cmp (r2)+,(r3)+
bgt 3f
blt 4f
cmp (r2)+,(r3)+
bne 1f
bit $m.ext,fpsr
beq 2f
cmp (r2)+,(r3)+
bne 1f
cmp (r2)+,(r3)+
beq 2f
1:
bhi 3f
4:
mov $1,(r5)
rts pc
3:
mov $-1,(r5)
rts pc
2:
clr (r5)
rts pc
i.ldcyx:
mov (r3)+,(r2)+
mov (r3)+,(r2)+
bit $m.ext,fpsr
bne 1f
mov (r3)+,(r2)+
mov (r3)+,(r2)+
rts pc
1:
clr (r2)+
clr (r2)+
rts pc
i.stcxy:
mov (r2)+,(r3)+
mov (r2)+,(r3)+
bit $m.ext,fpsr
bne 1f
clr (r3)+
clr (r3)+
1:
rts pc
i.ldcjx:
mov $asign,r0
mov $1,(r0)+
mov (r3)+,(r0)+
bit $m.lngi,fpsr
beq 1f
mov (r3)+,(r0)+
clr (r0)+
clr (r0)+
mov $32.-8,(r0)+
jmp saret
1:
clr (r0)+
clr (r0)+
clr (r0)+
mov $16.-8,(r0)
jmp saret
i.stcxj:
mov r3,r5
mov $asign,r0
jsr pc,seta
mov $areg,r0
mov (r0)+,r1
mov (r0)+,r2
mov (r0)+,r3
mov aexp,r0
1:
cmp r0,$48.-8
bge 1f
clc
ror r1
ror r2
ror r3
inc r0
br 1b
1:
bgt xoflo
tst r1
bne xoflo
1:
bit $m.lngi,fpsr
beq 1f
tst asign
bge 2f
neg r3
adc r2
bcs 2f
neg r2
2:
mov r2,(r5)
mov r3,2(r5)
rts pc
1:
tst r2
bne xoflo
tst asign
bge 2f
neg r3
2:
mov r3,(r5)
rts pc
xoflo:
bis $1,fpsr / set fixed overflow (carry)
jmp ret
i.ldexp:
mov $asign,r0
jsr pc,seta
mov (r3),aexp
jsr pc,reta
jmp sret
i.stexp:
mov $asign,r0
jsr pc,seta
mov aexp,(r3)
mov r3,r5
jmp sret
i.ldfps:
mov (r3),fpsr
jmp ret
i.stfps:
mov fpsr,(r3)
jmp ret
+335
View File
@@ -0,0 +1,335 @@
/ fp3 -- floating simulation
i.addx:
jsr pc,setab
br 1f
i.subx:
jsr pc,setab
neg bsign
1:
tst bsign
beq reta
tst asign
beq retb
mov areg+8,r1
sub breg+8,r1
blt 1f
beq 2f
cmp r1,$56.
bge reta
mov $breg,r0
br 4f
1:
neg r1
cmp r1,$56.
bge retb
mov $areg,r0
4:
mov r1,-(sp)
mov (r0)+,r1
mov (r0)+,r2
mov (r0)+,r3
mov (r0)+,r4
add (sp),(r0)
1:
clc
ror r1
ror r2
ror r3
ror r4
dec (sp)
bgt 1b
mov r4,-(r0)
mov r3,-(r0)
mov r2,-(r0)
mov r1,-(r0)
tst (sp)+
2:
mov $areg+8,r1
mov $breg+8,r2
mov $4,r0
cmp asign,bsign
bne 4f
clc
1:
adc -(r1)
bcs 3f
add -(r2),(r1)
2:
dec r0
bne 1b
br 5f
3:
add -(r2),(r1)
sec
br 2b
br 5f
4:
clc
1:
sbc -(r1)
bcs 3f
sub -(r2),(r1)
2:
dec r0
bne 1b
br 5f
3:
sub -(r2),(r1)
sec
br 2b
saret:
mov $areg,r1
5:
tst (r1)
bge 3f
mov $areg+8,r1
mov $4,r0
clc
1:
adc -(r1)
bcs 2f
neg (r1)
2:
dec r0
bne 1b
neg -(r1)
3:
jsr pc,norm
br reta
retb:
mov $bsign,r1
mov $asign,r2
mov $6,r0
1:
mov (r1)+,(r2)+
dec r0
bne 1b
reta:
mov r5,r2
mov $asign,r0
tst (r0)
beq unflo
mov aexp,r1
cmp r1,$177
bgt ovflo
cmp r1,$-177
blt unflo
add $200,r1
swab r1
clc
ror r1
tst (r0)+
bge 1f
bis $100000,r1
1:
bic $!177,(r0)
bis (r0)+,r1
mov r1,(r2)+
mov (r0)+,(r2)+
bit $m.ext,fpsr
beq 1f
mov (r0)+,(r2)+
mov (r0)+,(r2)+
1:
rts pc
unflo:
clr (r2)+
clr (r2)+
bit $m.ext,fpsr
beq 1f
clr (r2)+
clr (r2)+
1:
rts pc
ovflo:
bis $2,fpsr / set v-bit (overflow)
jmp ret
i.mulx:
jsr pc,i.mul
br saret
i.modx:
jsr pc,i.mul
jsr pc,norm
mov $asign,r0
mov $bsign,r1
mov $6,r2
1:
mov (r0)+,(r1)+
dec r2
bne 1b
clr r0 / count
mov $200,r1 / bit
clr r2 / reg offset
1:
cmp r0,aexp
bge 2f / in fraction
bic r1,areg(r2)
br 3f
2:
bic r1,breg(r2)
3:
inc r0
clc
ror r1
bne 1b
mov $100000,r1
add $2,r2
cmp r2,$8
blt 1b
jsr pc,norm
jsr pc,reta
cmp r5,$ac1
beq 1f
cmp r5,$ac3
beq 1f
bit $200,breg
bne 2f
clr bsign
2:
add $8,r5
jsr pc,retb
sub $8,r5
1:
rts pc
i.divx:
jsr pc,setab
tst bsign
beq ovflo
sub bexp,aexp
jsr pc,xorsign
mov r5,-(sp)
mov $areg,r0
mov (r0),r1
clr (r0)+
mov (r0),r2
clr (r0)+
mov (r0),r3
clr (r0)+
mov (r0),r4
clr (r0)+
mov $areg,r5
mov $400,-(sp)
1:
mov $breg,r0
cmp (r0)+,r1
blt 2f
bgt 3f
cmp (r0)+,r2
blo 2f
bhi 3f
cmp (r0)+,r3
blo 2f
bhi 3f
cmp (r0)+,r4
bhi 3f
2:
mov $breg,r0
sub (r0)+,r1
clr -(sp)
sub (r0)+,r2
adc (sp)
clr -(sp)
sub (r0)+,r3
adc (sp)
sub (r0)+,r4
sbc r3
adc (sp)
sub (sp)+,r2
adc (sp)
sub (sp)+,r1
bis (sp),(r5)
3:
asl r4
rol r3
rol r2
rol r1
clc
ror (sp)
bne 1b
mov $100000,(sp)
add $2,r5
cmp r5,$areg+8
blo 1b
tst (sp)+
mov (sp)+,r5
jmp saret
i.mul:
jsr pc,setab
add bexp,aexp
dec aexp
jsr pc,xorsign
mov r5,-(sp)
mov $breg+4,r5
bit $m.ext,fpsr
beq 1f
add $4,r5
1:
clr r0
clr r1
clr r2
clr r3
clr r4
1:
asl r0
bne 2f
inc r0
tst -(r5)
2:
cmp r0,$400
bne 2f
cmp r5,$breg
bhi 2f
mov $areg,r0
mov r1,(r0)+
mov r2,(r0)+
mov r3,(r0)+
mov r4,(r0)+
mov (sp)+,r5
rts pc
2:
clc
ror r1
ror r2
ror r3
ror r4
bit r0,(r5)
beq 1b
mov r0,-(sp)
mov $areg,r0
add (r0)+,r1
clr -(sp)
add (r0)+,r2
adc (sp)
clr -(sp)
add (r0)+,r3
adc (sp)
add (r0)+,r4
adc r3
adc (sp)
add (sp)+,r2
adc (sp)
add (sp)+,r1
mov (sp)+,r0
br 1b
xorsign:
cmp asign,bsign
beq 1f
mov $-1,asign
rts pc
1:
mov $1,asign
rts pc
+34
View File
@@ -0,0 +1,34 @@
/ fpx -- floating point simulation
.data
reenter: 1
.bss
asign: .=.+2
areg: .=.+8
aexp: .=.+2
bsign: .=.+2
breg: .=.+8
bexp: .=.+2
fpsr: .=.+2
trapins: .=.+2
ac0: .=.+8.
ac1: .=.+8.
ac2: .=.+8.
ac3: .=.+8.
ac4: .=.+8.
ac5: .=.+8.
sr0: .=.+2
sr1: .=.+2
.=.+2
.=.+2
.=.+2
.=.+2
ssp: .=.+2
spc: .=.+2
sps: .=.+2
pctmp: .=.+8
+329
View File
@@ -0,0 +1,329 @@
.globl gamma, _gamma, signgam, _signgam
.globl log, sin
half = 040000
one = 40200
two = 40400
eight = 41000
large = 77777
ldfps = 170100^tst
stfps = 170200^tst
/
/ gamma computes the log of the abs of the gamma function.
/ gamma accepts its argument and returns its result
/ in fr0. The carry bit is set if the result is
/ too large to represent.
/ The sign of the gamma function is
/ returned in the globl cell signgam.
/
/ The coefficients for expansion around zero
/ are #5243 from Hart & Cheney; for expansion
/ around infinity they are #5404.
/
/ movf arg,fr0
/ jsr pc,gamma
/ movf fr0,...
/
_gamma:
mov r5,-(sp)
mov sp,r5
movf 4(r5),fr0
jsr pc,gamma
mov (sp)+,r5
rts pc
gamma:
stfps -(sp)
ldfps $200
clr signgam
movf fr1,-(sp)
tstf fr0
cfcc
ble negative
cmpf $eight,fr0
cfcc
blt asymptotic
jsr pc,regular
/
lret:
jsr pc,log
bec ret
4
ret:
movf (sp)+,fr1
ldfps (sp)+
clc
rts pc
/
erret:
movf $large,fr0
movf (sp)+,fr1
ldfps (sp)+
sec
rts pc
/
/ here for positive x > 8
/ the log of the gamma function is
/ approximated directly by the asymptotic series.
/
asymptotic:
movf fr0,-(sp)
movf fr0,fr1
jsr pc,log
subf $half,fr1
mulf fr1,fr0
subf (sp),fr0
addf goobie,fr0
/
movf $one,fr1
divf (sp)+,fr1
movf fr0,-(sp)
movf fr1,-(sp)
mulf fr1,fr1
/
mov r0,-(sp)
mov $p5p,r0
mov $5,-(sp)
movf *(r0)+,fr0
1:
mulf fr1,fr0
addf *(r0)+,fr0
dec (sp)
bne 1b
tst (sp)+
mov (sp)+,r0
mulf (sp)+,fr0
addf (sp)+,fr0
br ret
/
/ here on negative
/ the negative gamma is computed
/ in terms of the pos gamma.
/
negative:
absf fr0
movf fr0,fr1
mulf pi,fr0
jsr pc,sin
negf fr0
cfcc
beq erret
bgt 1f
inc signgam
absf fr0
1:
mov signgam,-(sp)
mulf fr1,fr0
divf pi,fr0
jsr pc,log
movf fr0,-(sp)
movf fr1,fr0
jsr pc,gamma
addf (sp)+,fr0
negf fr0
mov (sp)+,signgam
br ret
/
/ control comes here for arguments less than 8.
/ if the argument is 2<x<3 then compute by
/ a rational approximation.
/ if x<2 or x>3 then the argument
/ is reduced in range by the formula
/ gamma(x+1) = x*gamma(x)
/
regular:
subf $two,fr0
cfcc
bge 1f
addf $two,fr0
movf fr0,-(sp)
addf $one,fr0
movf fr0,-(sp)
addf $one,fr0
jsr pc,regular
divf (sp)+,fr0
divf (sp)+,fr0
rts pc
1:
cmpf $one,fr0
cfcc
bgt 1f
addf $one,fr0
movf fr0,-(sp)
subf $two,fr0
jsr pc,1b
mulf (sp)+,fr0
rts pc
1:
movf fr2,-(sp)
mov r0,-(sp)
mov $p4p,r0
mov $6,-(sp)
movf fr0,fr2
movf *(r0)+,fr0
1:
mulf fr2,fr0
addf *(r0)+,fr0
dec (sp)
bne 1b
mov $7,(sp)
movf fr2,fr1
br 2f
1:
mulf fr2,fr1
2:
addf *(r0)+,fr1
dec (sp)
bne 1b
tst (sp)+
mov (sp)+,r0
divf fr1,fr0
movf (sp)+,fr2
rts pc
/
.data
p4p:
p6;p5;p4;p3;p2;p1;p0
q6;q5;q4;q3;q2;q1;q0
/ p6 = -.67449 50724 59252 89918 d1
/ p5 = -.50108 69375 29709 53015 d2
/ p4 = -.43933 04440 60025 67613 d3
/ p3 = -.20085 27401 30727 91214 d4
/ p2 = -.87627 10297 85214 89560 d4
/ p1 = -.20886 86178 92698 87364 d5
/ p0 = -.42353 68950 97440 89647 d5
/ q7 = 1.0 d0
/ q6 = -.23081 55152 45801 24562 d2
/ q5 = +.18949 82341 57028 01641 d3
/ q4 = -.49902 85266 21439 04834 d3
/ q3 = -.15286 07273 77952 20248 d4
/ q2 = +.99403 07415 08277 09015 d4
/ q1 = -.29803 85330 92566 49932 d4
/ q0 = -.42353 68950 97440 90010 d5
p1:
143643
26671
36161
72154
p2:
143410
165327
54121
172630
p3:
142773
10340
74264
152066
p4:
142333
125113
176657
75740
p5:
141510
67515
65111
24263
p6:
140727
153242
163350
32217
p0:
144045
70660
101665
164444
q1:
143072
43052
50302
136745
q2:
43433
50472
145404
175462
q3:
142677
11556
144553
154177
q4:
142371
101646
141245
11264
q5:
42075
77614
43022
27573
q6:
141270
123404
76130
12650
q0:
144045
70660
101665
164444
p5p:
s5;s4;s3;s2;s1;s0
/
/ s5 = -.16334 36431 d-2
/ s4 = +.83645 87892 2 d-3
/ s3 = -.59518 96861 197 d-3
/ s2 = +.79365 05764 93454 d-3
/ s1 = -.27777 77777 35865 004 d-2
/ s0 = +.83333 33333 33331 01837 d-1
/ goobie = 0.91893 85332 04672 74178 d0
s5:
135726
14410
15074
17706
s4:
35533
42714
111634
76770
s3:
135434
3200
171173
156141
s2:
35520
6375
12373
111437
s1:
136066
5540
132625
63540
s0:
37252
125252
125252
125047
goobie:
40153
37616
41445
172645
pi:
40511
7732
121041
64302
.bss
_signgam:
signgam:.=.+2
+92
View File
@@ -0,0 +1,92 @@
/ getw/getc -- get words/characters from input file
/ fopen -- open a file for use by get(c|w)
/
/ calling sequences --
/
/ mov $filename,r0
/ jsr r5,fopen; ioptr
/
/ on return ioptr buffer is set up or error bit is set if
/ file could not be opened.
/
/ jsr r5,get(c|w)1; ioptr
/
/ on return char/word is in r0; error bit is
/ set on error or end of file.
/
/ ioptr is the address of a 518-byte buffer
/ whose layout is as follows:
/
/ ioptr: .=.+2 / file descriptor
/ .=.+2 / charact+2 / pointer to next character (reset if no. chars=0)
/ .=.+512. / the buffer
.globl getc,getw,fopen
fopen:
mov r1,-(sp)
mov (r5)+,r1
mov r0,0f
sys 0; 9f
.data
9:
sys open; 0:..; 0
.text
bes 1f
mov r0,(r1)+
clr (r1)+
mov (sp)+,r1
rts r5
1:
mov $-1,(r1)
mov (sp)+,r1
sec
rts r5
.data
getw:
mov (r5),9f
mov (r5)+,8f
jsr r5,getc; 8:..
bec 1f
rts r5
1:
mov r0,-(sp)
jsr r5,getc; 9:..
swab r0
bis (sp)+,r0
rts r5
.text
getc:
mov r1,-(sp)
mov (r5)+,r1
dec 2(r1)
bge 1f
mov r1,r0
add $6,r0
mov r0,0f
mov r0,4(r1)
mov (r1),r0
sys 0; 9f
.data
9:
sys read; 0:..; 512.
.text
bes 2f
tst r0
bne 3f
2:
mov (sp)+,r1
sec
rts r5
3:
dec r0
mov r0,2(r1)
1:
clr r0
bisb *4(r1),r0
inc 4(r1)
mov (sp)+,r1
rts r5
+21
View File
@@ -0,0 +1,21 @@
/ C library-- long divide/remainder
.globl _ldiv, _ldivr
.globl _lrem
_ldiv:
mov 2(sp),r0
mov 4(sp),r1
div 6(sp),r0
mov r1,_ldivr
rts pc
_lrem:
mov 2(sp),r0
mov 4(sp),r1
div 6(sp),r0
mov r1,r0
rts pc
.bss
_ldivr: .=.+2
+105
View File
@@ -0,0 +1,105 @@
.globl log, _log
ldfps = 170100^tst
stfps = 170200^tst
ldexp = 176400^movif
stexp = 175000^movfi
/
/ log accepts its argument and returns its result
/ in fr0. The carry bit is set if the argument is
/ zero or negative.
/ The coefficients are #2705 from Hart & Cheney.
/
/ movf arg,fr0
/ jsr pc,log
/ movf fr0,...
/
_log:
mov r5,-(sp)
mov sp,r5
movf 4(r5),fr0
jsr pc,log
mov (sp)+,r5
rts pc
log:
tstf fr0
cfcc
bgt 1f
movf $bigneg,fr0 /return -(big) on error
sec
rts pc
1:
stfps -(sp)
ldfps $200 /di mode
movf fr2,-(sp)
movf fr1,-(sp)
/
stexp fr0,-(sp) /scale
ldexp $0,fr0
cmpf sqrt2o2,fr0
cfcc
blt 1f
ldexp $1,fr0
dec (sp)
1:
movf fr0,fr1 /(1/2)^(1/2) < x < 2^(1/2)
subf $one,fr0
addf $one,fr1
divf fr1,fr0 /z = (x-1)/(x+1)
movf fr0,fr1
mulf fr0,fr1 /z^2
/
movf p3,fr2
mulf fr1,fr2
addf p2,fr2
mulf fr1,fr2
addf p1,fr2
mulf fr1,fr2
addf p0,fr2
mulf fr2,fr0 /zP(z)
/
movf fr1,fr2
addf q2,fr2
mulf fr1,fr2
addf q1,fr2
mulf fr1,fr2
addf q0,fr2 /Q(z)
/
divf fr2,fr0 /zP(z)/Q(z)
movif (sp)+,fr1
mulf log2,fr1
addf fr1,fr0
/
movf (sp)+,fr1
movf (sp)+,fr2
ldfps (sp)+
rts pc
/
/
one = 40200
bigneg = 177777
/
.data
sqrt2o2: 40065; 02363; 31771; 157145
log2: 40061; 71027;173721;147572
/
p0: 141300; 16201; 02154; 10216
p1: 41367;124211; 21611;114442
p2: 141032; 31773; 64222; 40261
p3: 37727;114303;110107;114145
/
q0: 141100; 16201; 02154; 10216
q1: 41233;154404;136454; 22153
q2: 141016;111747; 07541; 52530
/
/
/p0 = -.24013 91795 59210 50986 8484 d2
/p1 = .30957 29282 15376 50062 264 d2
/p2 = -.96376 90933 68686 59324 d1
/p3 = .42108 73712 17979 7145 d0
/
/q0 = -.12006 95897 79605 25471 7525 d2
/q1 = .19480 96607 00889 73051 623 d2
/q2 = -.89111 09027 93783 12337 d1
/q3 = .1 d1
/
+32
View File
@@ -0,0 +1,32 @@
.globl mesg
/ usage:
/ jsr r5,mesg
/ <string ending in \0>
/ .even
/ ...
/
/ string is output onto $1
/
mesg:
mov r0,-(sp)
mov r5,r0
mov r5,0f
1:
tstb (r5)+
bne 1b
sub r5,r0
com r0
mov r0,0f+2
mov $1,r0
sys 0; 9f
.data
9:
sys write; 0:..; ..
.text
inc r5
bic $1,r5
mov (sp)+,r0
rts r5
+60
View File
@@ -0,0 +1,60 @@
.globl pow, _pow
.globl log, exp
_pow:
mov r5,-(sp)
mov sp,r5
movf 4(r5),fr0
movf 12.(r5),fr1
jsr pc,pow
mov (sp)+,r5
rts pc
pow:
/ 0^0~ is 0
tstf fr0
cfcc
bne 1f
tstf fr1
cfcc
beq bad
rts pc
1:
/ -^i is +^i fixed sign
bpl 1f
movf fr1,-(sp)
modf $one,fr1
cfcc
bne bad1
movf (sp)+,fr1
absf fr0
jsr pc,1f
bes bad
movf fr1,-(sp)
modf $half,fr1
cfcc
beq 2f
negf fr0
2:
movf (sp)+,fr1
rts pc
1:
jsr pc,log
bes 1f
mulf fr1,fr0
jsr pc,exp
1:
rts pc
bad1:
movf (sp)+,fr1
bad:
sec
rts pc
one = 40200
half = 40000
+102
View File
@@ -0,0 +1,102 @@
/ putw/putc -- write words/characters on output file
/
/ fcreat -- create an output file for use by put(w|c)
/
/ calling sequences --
/
/ mov $filename,r0
/ jsr r5,fcreat; ioptr
/
/ on return ioptr is set up for use by put or error
/ bit is set if file could not be created.
/
/ mov(b) thing,r0
/ jsr r5,put(w|c)1; ioptr
/
/ the character or word is written out.
/
/ jsr r5,flush; ioptr
/
/ the buffer is fled.
/
.globl putc, putw, flush, fcreat
fcreat:
mov r1,-(sp)
mov (r5)+,r1
mov r0,0f
sys 0; 9f
.data
9:
sys creat; 0:..; 666
.text
bes 1f
mov r0,(r1)+
2:
clr (r1)+
clr (r1)+
mov (sp)+,r1
rts r5
1:
mov $-1,(r1)+
mov (sp)+,r1
sec
rts r5
.data
putw:
mov (r5),8f
mov (r5)+,9f
mov r0,-(sp)
jsr r5,putc; 8:..
mov (sp)+,r0
swab r0
jsr r5,putc; 9:..
rts r5
.text
putc:
mov r1,-(sp)
mov (r5)+,r1
1:
dec 2(r1)
bge 1f
mov r0,-(sp)
jsr pc,fl
mov (sp)+,r0
br 1b
1:
movb r0,*4(r1)
inc 4(r1)
mov (sp)+,r1
rts r5
flush:
mov r0,-(sp)
mov r1,-(sp)
mov (r5)+,r1
jsr pc,fl
mov (sp)+,r1
mov (sp)+,r0
rts r5
fl:
mov r1,r0
add $6,r0
mov r0,-(sp)
mov r0,0f
mov 4(r1),0f+2
beq 1f
sub (sp),0f+2
mov (r1),r0
sys 0; 9f
.data
9:
sys write; 0:..; ..
.text
1:
mov (sp)+,4(r1)
mov $512.,2(r1)
rts pc
+27
View File
@@ -0,0 +1,27 @@
/ random fixed point number generator
.globl rand, srand
.globl _rand, _srand
_srand:
mov 2(sp),ranx
rts pc
srand:
mov r0,ranx
rts pc
_rand:
rand:
mov r1,-(sp)
mov ranx,r1
mpy $13077.,r1
add $6925.,r1
mov r1,r0
mov r0,ranx
bic $100000,r0
mov (sp)+,r1
rts pc
.data
ranx: 1
+24
View File
@@ -0,0 +1,24 @@
as atan.s; mv a.out atan.o
as crypt.s; mv a.out crypt.o
as dpadd.s; mv a.out dpadd.o
as ecvt.s; mv a.out ecvt.o
as exp.s; mv a.out exp.o
as floor.s; mv a.out floor.o
as fmod.s; mv a.out fmod.o
as fp?.s; mv a.out fp.o
: as fakfp.s: mv a.out fp.o
as gamma.s; mv a.out gamma.o
as get.s; mv a.out get.o
as ldiv.s; mv a.out ldiv.o
as log.s; mv a.out log.o
as mesg.s; mv a.out mesg.o
as pow.s; mv a.out pow.o
as put.s; mv a.out put.o
as rand.s; mv a.out rand.o
as savr5.s; mv a.out savr5.o
as sin.s; mv a.out sin.o
as sqrt.s; mv a.out sqrt.o
as switch.s; mv a.out switch.o
as ttyn.s; mv a.out ttyn.o
ar r /lib/liba.a
rm *.o
+5
View File
@@ -0,0 +1,5 @@
/ savr5 - for as progs that call c-callable entries
.globl savr5
.bss
savr5: .=.+2
+125
View File
@@ -0,0 +1,125 @@
ldfps = 170100^tst
stfps = 170200^tst
/
.globl sin, _sin
.globl cos, _cos
/
/ floating point sin/cos
/ replaces the value in fr0 by its sin/cos
/ there are no error exits
/ coefficients are #3370 from Hart & Cheney
/
_sin:
mov r5,-(sp)
mov sp,r5
movf 4(r5),fr0
jsr pc,sin
br 1f
_cos:
mov r5,-(sp)
mov sp,r5
movf 4(r5),fr0
jsr pc,cos
1:
mov (sp)+,r5
rts pc
cos:
absf fr0
mov $1,-(sp)
br 1f
sin:
clr -(sp)
1:
stfps -(sp)
ldfps $200
movf fr1,-(sp)
movf fr2,-(sp)
mov r0,-(sp)
/
/ quadrant reduction - arg = (2/J)x
/ -1 < arg < 1
/
movf fr0,-(sp)
absf fr0
modf frpi2,fr0
modf $fourth,fr1
mulf $four,fr1
movfi fr1,r0
add 34(sp),r0
movf $one,fr1
inc r0
ror r0
bcs 1f
subf $one,fr0
1:
ror r0
bcc 1f
negf fr0
1:
tstf (sp)+
cfcc
bpl 1f
negf fr0
1:
movf fr0,fr1
mulf fr0,fr1 /arg^2
/
movf p4,fr2
mulf fr1,fr2
addf p3,fr2
mulf fr1,fr2
addf p2,fr2
mulf fr1,fr2
addf p1,fr2
mulf fr1,fr2
addf p0,fr2
mulf fr2,fr0 / zP(z^2)
/
movf fr1,fr2
addf q3,fr2
mulf fr1,fr2
addf q2,fr2
mulf fr1,fr2
addf q1,fr2
mulf fr1,fr2
addf q0,fr2 / Q(z^2)
/
divf fr2,fr0 / zP(z^2)/Q(z^2)
/
mov (sp)+,r0
movf (sp)+,fr2
movf (sp)+,fr1
ldfps (sp)+
tst (sp)+
/ clc /tst clears carry
rts pc
/
fourth = 37600
one = 40200
four = 40600
/
.data
frpi2: 40042;174603; 67116; 42025
/
p0: 046117;031130;175220;165273
p1: 145626;154170;031651;104637
p2: 044726;162341;133224;052302
p3: 143530;056427;005061;125021
p4: 042021;174005;170441;175607
q0: 046003;163716;123445;167144
q1: 044707;047147;032436;120046
q2: 043423;156142;064161;007314
q3: 042004;123513;026637;160477
/
/p0 = .13578 84097 87737 56690 92680 d8
/p1 = -.49429 08100 90284 41611 58627 d7
/p2 = .44010 30535 37526 65019 44918 d6
/p3 = -.13847 27249 98245 28730 54457 d5
/p4 = .14596 88406 66576 87222 26959 d3
/q0 = .86445 58652 92253 44299 15149 d7
/q1 = .40817 92252 34329 97493 95779 d6
/q2 = .94630 96101 53820 81805 71257 d4
/q3 = .13265 34908 78613 63589 11494 d3
/q4 = .1 d1
+58
View File
@@ -0,0 +1,58 @@
ldfps = 170100^tst
stfps = 170200^tst
/
/ sqrt replaces the f.p. number in fr0 by its
/ square root. newton's method
/
.globl sqrt, _sqrt
/
/
_sqrt:
mov r5,-(sp)
mov sp,r5
movf 4(r5),fr0
jsr pc,sqrt
mov (sp)+,r5
rts pc
sqrt:
tstf fr0
cfcc
bne 1f
clc
rts pc /sqrt(0)
1:
bgt 1f
clrf fr0
sec
rts pc / sqrt(-a)
1:
mov r0,-(sp)
stfps -(sp)
mov (sp),r0
bic $!200,r0 / retain mode
ldfps r0
movf fr1,-(sp)
movf fr2,-(sp)
/
movf fr0,fr1
movf fr0,-(sp)
asr (sp)
add $20100,(sp)
movf (sp)+,fr0 /initial guess
mov $4,r0
1:
movf fr1,fr2
divf fr0,fr2
addf fr2,fr0
mulf $half,fr0 / x = (x+a/x)/2
sob r0,1b
2:
movf (sp)+,fr2
movf (sp)+,fr1
ldfps (sp)+
mov (sp)+,r0
clc
rts pc
/
half = 40000
+40
View File
@@ -0,0 +1,40 @@
/ switch -- switch on contents of r0
/
/
/ calling sequence --
/
/ jsr r5,switch; swtab
/
/ r0 is looked up in swtab and if found
/ control is returned to the corresponding place
/ if r0 is not found, the next inline instruction is
/ executed
/
/ swtab format --
/
/ swtab:
/ val1; ret1
/ val2; ret2
/ ...
/ valn; retn
/ ..; 0
/
.globl switch
switch:
mov r1,-(sp)
mov (r5)+,r1
1:
cmp r0,(r1)+
beq 1f
tst (r1)+
bne 1b
2:
mov (sp)+,r1
rts r5
1:
mov (r1)+,r1
beq 2b
mov r1,r5
br 2b
+57
View File
@@ -0,0 +1,57 @@
/ return name of current tty
.globl ttyn, _ttyn
_ttyn:
mov r5,-(sp)
mov sp,r5
mov 4(r5),r0
jsr pc,1f
mov (sp)+,r5
rts pc
ttyn:
clr r0
1:
mov $'x,name
tst -(sp)
sys fstat; buf
bes er1
mov buf+2,(sp)
sys open; dev; 0
bes er1
mov r0,r1
1:
mov r1,r0
sys read; buf; 16.
bes er
cmp r0,$16.
bne er
mov $buf,r0
cmp (r0)+,(sp)
bne 1b
cmp (r0)+,$"tt
bne 1b
cmpb (r0)+,$'y
bne 1b
tstb (r0)+
beq 1b
cmpb (r0),$'\0
bne 1b
movb -(r0),name
er:
mov r1,r0
sys close
er1:
tst (sp)+
movb name,r0
rts pc
.data
dev: </dev\0>
.even
.bss
buf: .=.+40.
name: .=.+2