github.com/DoctorWkt.unix-jun72
1
0
Fork 0
mirror of https://github.com/DoctorWkt/unix-jun72.git synced 2026-04-11 23:12:59 +00:00
Code Issues Releases Wiki Activity

Warren and Doug Merritt have worked on rebuilding the code fragments from

Browse Source 
the s1-bits tape. Doug has provided as11.s as12.s as13.s as14.s as15.s as16.s
as17.s as18.s as19.s as21.s as22.s as23.s as24.s as25.s as26.s as27.s as28.s
as29.s, and Warren has compared against his production, and against V5 (to
determine the correct trailing blank line). These files can be considered
authentic. The other file's are Warren's production only, so we need to
compare against Doug's versions to ensure correctness.
This commit is contained in:
warren.toomey
2008-05-15 00:59:49 +00:00
parent 98dab3fc19
commit 45ebdd66d8
63 changed files with 14377 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files

413
src/cmd/acct.s Normal file
View File

@@ -0,0 +1,413 @@
/ acct -- time accounting
.globl mesg, qsort, fopen, getw
mov (sp)+,r5
tst (sp)+
1:
cmp r5,$2
blt 1f
mov (sp),r0
cmpb (r0),$'-
bne 1f
cmpb 1(r0),$'d
bne 2f
inc byday
dec r5
tst (sp)+
br 1b
2:
cmpb 1(r0),$'p
bne 2f
inc pflg
dec r5
tst (sp)+
br 1b
2:
cmpb 1(r0),$'w
bne 1f
dec r5
tst (sp)+
cmp r5,$2
blt 1b
dec r5
mov (sp)+,filnam
br 1b
1:
dec r5
mov r5,argc
mov sp,argp
mov filnam,r0
jsr r5,fopen; fbuf
bec 1f
jsr r5,mesg
<Cannot open wtmp\n\0>; .even
sys exit
1:
setd
1:
mov $ibuf,r1
2:
jsr r5,getw; fbuf
bes 1f
mov r0,(r1)+
cmp r1,$ibuf+16.
blo 2b
jsr pc,loop
br 1b
1:
sys time
mov r0,i.time
mov r1,i.time+2
clr ibuf
mov $'x,i.tty
jsr pc,loop
jsr pc,print
sys exit
loop:
clc
ror i.time
ror i.time+2
setl
movif i.time,fr0
tst byday
beq 1f
cmpf midnight,fr0
cfcc
bgt 1f
movf fr0,-(sp)
movf midnight,fr0
jsr pc,upall
jsr pc,print
jsr pc,clru
movf (sp)+,fr0
jsr pc,newday
1:
movb i.tty,r0
mov $ttyf,r1
cmp r0,$'x
bne 1f
jsr pc,upall
jsr pc,clrt
rts pc
1:
cmp r0,(r1)
beq 1f
add $18.,r1
cmp r1,$et
blo 1b
br 2f
1:
jsr pc,update
clr (r1)
2:
cmp ibuf,$"\0\0
bne 1f
rts pc
1:
mov $ttyf,r1
1:
tst (r1)
beq 1f
add $18.,r1
br 1b
1:
mov r0,(r1)+
mov ibuf,(r1)+
mov ibuf+2,(r1)+
mov ibuf+4,(r1)+
mov ibuf+6,(r1)+
movf fr0,(r1)+
rts pc
clrt:
mov $ttyf,r1
1:
clr (r1)+
cmp r1,$et
blo 1b
rts pc
clru:
mov $usrf,r1
1:
clr (r1)+
cmp r1,$eu
blo 1b
rts pc
print:
jsr pc,upall
mov $usrf,r1
mov r1,r2
mov $16.,r3
1:
tst (r2)
beq 1f
add r3,r2
br 1b
1:
jsr pc,qsort
clrf fr0
jsr r5,select; 1f
tstf fr0
cfcc
beq 3f
jsr pc,pdate
mov $total,r2
jsr pc,ptime
tst pflg
beq 3f
jsr r5,select; 2f
3:
rts pc
1:
addf 8(r2),fr0
rts pc
2:
movf 8(r2),fr0
jsr pc,pblank
jsr pc,ptime
rts pc
pdate:
tst byday
bne 1f
rts pc
1:
mov r2,-(sp)
movf fr0,-(sp)
movf midnight,fr0
divf day,fr0
seti
movfi fr0,r0
mov $montab,r1
1:
sub (r1)+,r0
bgt 1b
add -(r1),r0
cmp r1,$montab+24.
blt 1f
sub $24.,r1
1:
sub $montab,r1
mov r1,-(sp)
asr r1
add (sp)+,r1
add $monasc,r1
mov $obuf,r2
movb (r1)+,(r2)+
movb (r1)+,(r2)+
movb (r1)+,(r2)+
movb $' ,(r2)+
mov r0,r1
clr r0
dvd $10.,r0
tst r0
beq 1f
add $'0,r0
movb r0,(r2)+
1:
add $'0,r1
movb r1,(r2)+
movb $'\t,(r2)+
sub $obuf,r2
mov r2,0f
mov $1,r0
sys write; obuf; 0:..
movf (sp)+,fr0
mov (sp)+,r2
rts pc
pblank:
tst byday
beq 1f
mov $1,r0
sys write; blank; 1
1:
rts pc
upall:
mov $ttyf,r1
1:
mov (r1),r0
beq 1f
jsr pc,update
add $18.,r1
br 1b
1:
rts pc
update:
mov r1,-(sp)
mov $usrf,r2
1:
mov (sp),r1
tst (r1)+
tst (r2)
beq 1f
cmp (r1)+,(r2)
bne 2f
cmp (r1)+,2(r2)
bne 2f
cmp (r1)+,4(r2)
bne 2f
cmp (r1)+,6(r2)
beq 1f
2:
add $16.,r2
br 1b
1:
mov (sp),r1
tst (r1)+
mov (r1)+,(r2)+
mov (r1)+,(r2)+
mov (r1)+,(r2)+
mov (r1)+,(r2)+
movf fr0,fr1
subf (r1),fr1
cfcc
blt 1f
cmpf maxpd,fr1
cfcc
blt 1f
addf (r2),fr1
movf fr1,(r2)+
1:
movf fr0,(r1)+
mov (sp)+,r1
rts pc
newday:
movf midnight,fr1
1:
cmpf fr0,fr1
cfcc
blt 1f
addf day,fr1
br 1b
1:
movf fr1,midnight
rts pc
select:
mov $usrf,r2
1:
tst (r2)
beq 1f
mov argc,r1
beq 2f
mov argp,r3
3:
mov r2,r0
mov (r3)+,r4
4:
cmpb (r0)+,(r4)+
beq 4b
tstb -(r4)
bne 4f
cmpb -(r0),$' /
beq 2f
4:
sob r1,3b
br 3f
2:
jsr pc,*(r5)
3:
add $16.,r2
br 1b
1:
tst (r5)+
rts r5
ptime:
mov $obuf,r1
mov r2,r0
1:
movb (r0)+,(r1)
cmpb (r1)+,$' /
bne 1b
movb $'\t,-1(r1)
mov r1,-(sp)
seti
divf thous,fr0
jsr pc,digit
jsr pc,digit
jsr pc,digit
jsr pc,digit
movb $':,(r1)+
mulf sixth,fr0
jsr pc,digit
jsr pc,digit
movb $'\n,(r1)+
sub $obuf,r1
mov r1,0f
mov (sp)+,r1
1:
cmpb (r1),$'0
bne 1f
movb $' ,(r1)+
br 1b
1:
cmpb (r1),$':
bne 1f
movb $'0,-(r1)
1:
mov $1,r0
sys write; obuf; 0:..
rts pc
digit:
modf ten,fr0
movfi fr1,r0
add $'0,r0
movb r0,(r1)+
rts pc
filnam: wtmp
montab:
31.; 28.; 31.; 30.; 31.; 30.; 31.; 31.; 30.; 31.; 30.; 31.
31.; 29.; 31.; 30.; 31.; 30.; 31.; 31.; 30.; 31.; 30.; 31.
monasc:
<Jan>
<Feb>
<Mar>
<Apr>
<May>
<Jun>
<Jul>
<Aug>
<Sep>
<Oct>
<Nov>
<Dec>
day: 45436;32000;0;0
thous: 47600;137374;0;0
maxpd: 45636;032001;0;0
sixth: 40031;114631;114631;114631
ten: 41040;0;0;0
total: <total >
blank: < >
wtmp: </usr/adm/wtmp\0>
.even
.bss
midnight:.=.+8.
byday: .=.+2
argc: .=.+2
argp: .=.+2
ibuf: .=.+16.
fbuf: .=.+520.
i.tty = ibuf+8.
i.time = ibuf+10.
fi: .=.+2
ttyf: .=.+[20.*18.]; et:
usrf: .=.+[200.*16.]; eu:
obuf: .=.+20.
pflg: .=.+2

539
src/cmd/ar.s Normal file
View File

@@ -0,0 +1,539 @@
/ ar -- archive/library
mov (sp)+,r0
sub $2,r0
ble userr
tst (sp)+
mov (sp)+,r1
clr r2
1:
tstb (r1)
beq 1f
cmpb (r1),$'v
bne 2f
inc r1
incb vflg
br 1b
2:
tst r2
bne userr
movb (r1)+,r2
br 1b
1:
tst r2
beq userr
mov $arglst,r1
1:
mov (sp)+,(r1)+
dec r0
bgt 1b
clr (r1)+
mov $swlst,r1
1:
cmp r2,(r1)+
beq 1f
tst (r1)+
bne 1b
br userr
1:
jmp *(r1)
swlst:
'r; comr
'u; comu
'd; comd
'x; comx
't; comt
0; 0
userr:
jsr r5,diag
<bad usage\n\0>
.even
putc:
movb r0,ch
mov $1,r0
sys write; ch; 1
rts r5
print:
movb (r1)+,r0
beq 1f
jsr r5,putc
br print
1:
rts r5
diag:
mov r5,r1
jsr r5,print
tst tfo
beq 1f
sys unlink; tfil
1:
sys exit
getaf:
mov arglst,0f
sys open; 0:..; 0
bes 1f
mov r0,afi
sys read; buf; 2
cmp buf,magic
bne magerr
tst (r5)+
1:
rts r5
magerr:
mov arglst,r1
jsr r5,print
jsr r5,diag
< -- not in archive format\n\0>
.even
mktmp:
sys stat; tfil; buf
bes 1f
incb tfil+8
cmpb tfil+8,$'z
blo mktmp
br tferr
1:
sys intr; done
sys creat; tfil; 14
bes tferr
mov r0,tfo
sys open; tfil; 0
bes tferr
mov r0,tfi
rts r5
tferr:
jsr r5,diag
<cannot open temp file\n\0>
.even
getdir:
mov afi,r0
sys read; dir; 16.
cmp r0,$16.
bne 1f
jsr r5,mvname
tst (r5)+
1:
rts r5
mvname:
mov name,rname
mov name+2,rname+2
mov name+4,rname+4
mov name+6,rname+6
rts r5
skip:
mov size,r0
inc r0
bic $1,r0
mov r0,0f
mov afi,r0
sys seek; 0:..; 1
rts r5
trim:
mov r0,r2
1:
tstb (r0)
beq 1f
cmpb (r0)+,$'/
beq trim
br 1b
1:
rts r5
match:
mov $arglst+2,r1
1:
mov (r1)+,r0
beq 1f
blt 1b
jsr r5,trim
mov $name,r0
2:
cmp r0,$name+8.
beq 2f
cmpb (r0),(r2)+
bne 1b
tstb (r0)+
bne 2b
2:
cmp (r5)+,-(r1)
1:
rts r5
mvfil:
mov (r1),9f
mov (r1),0f
sys stat; 0:..; buf
bes operr
sys open; 9:..; 0
bes operr
mov r0,fio
mov (r1),r0
mov $-1,(r1)
jsr r5,trim
mov $name,r0
1:
cmp r0,$name+8.
beq 1f
movb (r2)+,(r0)+
bne 1b
1:
mov buf+28.,mtim
mov buf+30.,mtim+2
movb buf+5,ouid
movb buf+2,mode
mov buf+6,size
mov tfo,r0
sys write; dir; 16.
mov size,r2
1:
mov fio,r0
sys read; buf; 512.
sub r0,r2
mov r0,0f
beq 1f
mov tfo,r0
sys write; buf; 0:..
br 1b
1:
tst r2
bne phserr
bit $1,size
beq 1f
mov tfo,r0
sys seek; 1; 1
1:
mov fio,r0
sys close
jsr r5,mvname
rts r5
operr:
mov 9b,r1
jsr r5,print
jsr r5,diag
< -- cannot open\n\0>
.even
phserr:
mov 9b,r1
jsr r5,print
jsr r5,diag
< -- phase error\n\0>
.even
copyfl:
mov tfo,r0
sys write; dir; 16.
mov size,r1
mov $rname,9b
1:
mov r1,0f
beq 1f
cmp r1,$512.
blo 2f
mov $512.,0f
2:
mov afi,r0
sys read; buf; 0:..
sub r0,r1
mov r0,0f
beq phserr
mov tfo,r0
sys write; buf; 0:..
br 1b
1:
bit $1,size
beq 1f
mov afi,r0
sys seek; 1; 1
mov tfo,r0
sys seek; 1; 1
1:
rts r5
xtract:
movb mode,0f
sys creat; rname; 0:..
bes noxerr
mov r0,fio
mov size,r1
mov $rname,9b
1:
mov r1,0f
beq 1f
cmp r1,$512.
blo 2f
mov $512.,0f
2:
mov afi,r0
sys read; buf; 0:..
sub r0,r1
mov r0,0f
beq phserr
mov fio,r0
sys write; buf; 0:..
br 1b
1:
mov fio,r0
sys close
bit $1,size
beq 1f
mov afi,r0
sys seek; 1; 1
1:
mov r0,-(sp)
mov r1,-(sp)
mov mtim+2,r1
mov mtim,r0
sys mdate
mov (sp)+,r1
mov (sp)+,r1
rts r5
noxerr:
mov $rname,r1
jsr r5,print
jsr r5,diag
< -- cannot create\n\0>
.even
table:
mov $rname,r1
jsr r5,print
mov $'\n,r0
jsr r5,putc
rts r5
mesg:
mov r1,-(sp)
mov (r5)+,r0
tstb vflg
beq 1f
jsr r5,putc
mov $' ,r0
jsr r5,putc
mov $rname,r1
jsr r5,print
mov $'\n,r0
jsr r5,putc
1:
mov (sp)+,r1
rts r5
oldnew:
sys stat; rname; buf
bes 1f
cmp buf+28.,mtim
blo 1f
bhi 2f
cmp buf+30.,mtim+2
blos 1f
2:
tst (r5)+
mov $rname,tname
mov $tname,r1
1:
rts r5
comr:
jsr r5,mktmp
jsr r5,getaf
br copfl
1:
jsr r5,getdir
br copfl
jsr r5,match
br 2f
jsr r5,mesg; 'r
jsr r5,skip
jsr r5,mvfil
br 1b
2:
jsr r5,copyfl
jsr r5,mesg; 'c
br 1b
comu:
jsr r5,mktmp
jsr r5,getaf
br noaf
1:
jsr r5,getdir
br copfl
tst arglst+2
beq 2f
jsr r5,match
br 3f
mov $-1,(r1)
2:
jsr r5,oldnew
br 3f
jsr r5,mesg; 'r
jsr r5,skip
jsr r5,mvfil
br 1b
3:
jsr r5,copyfl
jsr r5,mesg; 'c
br 1b
comd:
jsr r5,mktmp
jsr r5,getaf
br noaf
1:
jsr r5,getdir
br 1f
jsr r5,match
br 2f
mov $-1,(r1)
jsr r5,skip
jsr r5,mesg; 'd
br 1b
2:
jsr r5,copyfl
jsr r5,mesg; 'c
br 1b
1:
jsr r5,nfound
br copfl
noaf:
jsr r5,diag
<no archive file\n\0>
.even
crterr:
jsr r5,diag
<cannot create archive file\n\0>
.even
copfl:
mov $arglst,r1
mov (r1)+,0f
1:
tst (r1)+
beq 1f
blt 1b
tst -(r1)
jsr r5,mvfil
jsr r5,mesg; 'a
br 1b
1:
sys intr; 0 / no interrups during copy back
sys creat; 0:..; 17
bes crterr
mov r0,afo
sys write; magic; 2
1:
mov tfi,r0
sys read; buf; 512.
mov r0,0f
beq done
mov afo,r0
sys write; buf; 0:..
br 1b
done:
jsr r5,diag
<\0>
.even
comx:
jsr r5,getaf
br noaf
1:
jsr r5,getdir
br 1f
tst arglst+2
beq 3f
jsr r5,match
br 2f
3:
mov $-1,(r1)
jsr r5,xtract
jsr r5,mesg; 'x
br 1b
2:
jsr r5,skip
br 1b
1:
jsr r5,nfound
br done
comt:
jsr r5,getaf
br noaf
1:
jsr r5,getdir
br 1f
tst arglst+2
beq 2f
jsr r5,match
br 3f
mov $-1,(r1)
2:
jsr r5,table
3:
jsr r5,skip
br 1b
1:
jsr r5,nfound
br done
nfound:
mov $arglst+2,r2
1:
mov (r2)+,r1
beq 1f
blt 1b
mov $-1,-(r2)
jsr r5,print
mov $notfnd,r1
jsr r5,print
br 1b
1:
rts r5
notfnd:
< -- not found\n\0>
.even
tfil: </tmp/vtma\0>
.even
magic: -147.
.bss
afi: .=.+2
afo: .=.+2
tfi: .=.+2
tfo: .=.+2
fio: .=.+2
rname: .=.+9.
ch: .=.+1
vflg: .=.+1
.even
tname: .=.+2
dir:
name: .=.+8.
mtim: .=.+4
ouid: .=.+1
mode: .=.+1
size: .=.+2
arglst: .=.+200.
buf: .=.+512.

90
src/cmd/as11.s Normal file
View File

@@ -0,0 +1,90 @@
/ a1 -- pdp-11 assembler pass 1
main:
ecore = main+8192.
jmp start
go:
jsr pc,assem
movb pof,r0
sys write; outbuf; 512.
movb pof,r0
sys close
movb fbfil,r0
sys close
tstb errflg
bne aexit
jsr r5,fcreat; a.tmp3
mov $txtsiz,r1 / even up
inc (r1)
bic $1,(r1)+
inc (r1)
bic $1,(r1)+
inc (r1)
bic $1,(r1)+
mov r0,r1
sys write; txtsiz; 6
mov symend,0f
sub $usymtab,0f
mov r1,r0
sys write; usymtab; 0:..
mov r1,r0
sys close
sys exec; 2f; 1f
aexit:
sys unlink; a.tmp1
sys unlink; a.tmp2
sys unlink; a.tmp3
sys exit
1:
2f
a.tmp1
a.tmp2
a.tmp3
unglob:
3f
0
2:
</etc/as2\0>
3:
<-g\0>
.even
filerr:
mov r4,-(sp)
mov (r5)+,r4
mov r4,0f
clr r0
1:
tstb (r4)+
beq 1f
inc r0
br 1b
1:
mov r0,1f
mov $1,r0
sys write; 0:0; 1:0
mov r5,0f
mov $1,r0
sys write; 0:0; 2
tst (r5)+
mov (sp)+,r4
rts r5
fcreat:
mov r4,-(sp)
mov (r5)+,r4
mov r4,0f
1:
sys creat; 0:..; 12
bes 2f
mov (sp)+,r4
rts r5
2:
incb 9.(r4)
cmpb 9.(r4),$'z
blos 1b
mov 0b,0f
jsr r5,filerr; 0:..; "?\n
sys exit

75
src/cmd/as12.s Normal file
View File

@@ -0,0 +1,75 @@
/ a2 -- pdp-11 assembler pass 1
error:
incb errflg
mov r0,-(sp)
mov r1,-(sp)
mov (r5)+,r0
mov *curarg,0f
beq 1f
clr *curarg
mov r0,-(sp)
jsr r5,filerr; 0:0; '\n
mov (sp)+,r0
1:
mov r2,-(sp)
mov r3,-(sp)
mov line,r3
movb r0,1f
mov $1f+6,r0
mov $4,r1
2:
clr r2
dvd $10.,r2
add $'0,r3
movb r3,-(r0)
mov r2,r3
sob r1,2b
mov $1,r0
sys write; 1f; 7
mov (sp)+,r3
mov (sp)+,r2
mov (sp)+,r1
mov (sp)+,r0
rts r5
1: <f xxxx\n>
.even
betwen:
cmp r0,(r5)+
blt 1f
cmp (r5)+,r0
blt 2f
1:
tst (r5)+
2:
rts r5
putw:
tst ifflg
beq 1f
cmp r4,$'\n
bne 2f
1:
jsr pc,putc1
swab r4
jsr pc,putc1
swab r4
2:
rts pc
putc:
tst ifflg
bne 1f
putc1:
movb r4,*obufp
inc obufp
cmp obufp,$outbuf+512.
blo 1f
mov $outbuf,obufp
movb pof,r0
sys write; outbuf; 512.
1:
rts pc

134
src/cmd/as13.s Normal file
View File

@@ -0,0 +1,134 @@
/ a3 -- pdp-11 assembler pass 1
assem:
jsr pc,readop
jsr pc,checkeos
br ealoop
tst ifflg
beq 3f
cmp r4,$200
blos assem
cmpb (r4),$21 /if
bne 2f
inc ifflg
2:
cmpb (r4),$22 /endif
bne assem
dec ifflg
br assem
3:
mov r4,-(sp)
jsr pc,readop
cmp r4,$'=
beq 4f
cmp r4,$':
beq 1f
mov r4,savop
mov (sp)+,r4
jsr pc,opline
dotmax:
movb dotrel,r0
asl r0
cmp dot,txtsiz-4(r0)
blos ealoop
mov dot,txtsiz-4(r0)
br ealoop
1:
mov (sp)+,r4
cmp r4,$200
bhis 1f
cmp r4,$1
beq 3f
jsr r5,error; 'x
br assem
1:
bitb $37,(r4)
beq 1f
jsr r5,error; 'm
1:
bisb dot-2,(r4)
mov dot,2(r4)
br assem
3:
mov numval,r0
jsr pc,fbcheck
movb dotrel,curfbr(r0)
asl r0
movb dotrel,nxtfb+1
mov dot,nxtfb+2
movb r0,nxtfb
mov dot,curfb(r0)
movb fbfil,r0
sys write; nxtfb; 4
br assem
4:
jsr pc,readop
jsr pc,expres
mov (sp)+,r1
cmp r1,$200
bhis 1f
jsr r5,error; 'x
br ealoop
1:
cmp r1,$dotrel
bne 2f
bic $40,r3
cmp r3,dotrel
bne 1f
2:
bicb $37,(r1)
bic $!37,r3
bne 2f
clr r2
2:
bisb r3,(r1)
mov r2,2(r1)
br dotmax
1:
jsr r5,error; '.
movb $2,dotrel
ealoop:
cmp r4,$';
beq assem1
cmp r4,$'\n
bne 1f
inc line
br assem1
1:
cmp r4,$'\e
bne 2f
tst ifflg
beq 1f
jsr r5,error; 'x
1:
rts pc
2:
jsr r5,error; 'x
2:
jsr pc,checkeos
br assem1
jsr pc,readop
br 2b
assem1:
jmp assem
fbcheck:
cmp r0,$9.
bhi 1f
rts pc
1:
jsr r5,error; 'f
clr r0
rts pc
checkeos:
cmp r4,$'\n
beq 1f
cmp r4,$';
beq 1f
cmp r4,$'\e
beq 1f
add $2,(sp)
1:
rts pc

206
src/cmd/as14.s Normal file
View File

@@ -0,0 +1,206 @@
/ a4 -- pdp-11 assembler pass1
rname:
mov r1,-(sp)
mov r2,-(sp)
mov r3,-(sp)
mov $2,r5
mov $symbol,r2
clr -(sp)
1:
jsr pc,rnch
mov r3,r1
mpy $40.,r1
jsr pc,rnch
add r3,r1
mpy $40.,r1
jsr pc,rnch
add r1,r3
add r3,(sp)
mov r3,(r2)+
sob r5,1b
jsr pc,rnch
mov r3,r1
add r3,(sp)
als $10.,r1
mov r1,(r2)
1:
jsr pc,rnch
tst r3
bne 1b
mov (sp)+,r1
clr r0
dvd $hshsiz,r0
mov r1,r0
asl r0
add $hshtab,r0
1:
cmp r0,$hshtab
bhi 2f
mov $2*hshsiz+hshtab,r0
2:
mov $symbol,r2
mov -(r0),r4
beq 3f
cmp (r2)+,(r4)+
bne 1b
cmp (r2)+,(r4)+
bne 1b
cmpb 1(r4),1(r2)
bne 1b
br 1f
3:
mov symend,r4
mov r4,(r0)
mov r4,-(sp)
add $20,r4
cmp r4,0f
blos 4f
add $512.,0f
sys break; 0:end
4:
mov (sp)+,r4
mov (r2)+,(r4)+
mov (r2)+,(r4)+
mov (r2)+,(r4)+
clr (r4)+
mov r4,symend
sub $4,r4
1:
mov r4,-(sp)
sub $symtab-374,r4
asr r4
jsr pc,putw
mov (sp)+,r4
mov (sp)+,r3
mov (sp)+,r2
tst (sp)+
mov (sp)+,r1
rts pc
rnch:
jsr pc,rch
movb chartab(r0),r3
ble 1f
rts pc
1:
movb r0,ch
clr r3
rts pc
number:
mov r2,-(sp)
mov r3,-(sp)
mov r5,-(sp)
clr r1
clr r5
1:
jsr pc,rch
jsr r5,betwen; '0; '9
br 1f
sub $'0,r0
mpy $10.,r5
add r0,r5
als $3,r1
add r0,r1
br 1b
1:
cmp r0,$'b
beq 1f
cmp r0,$'f
beq 1f
cmp r0,$'.
bne 2f
mov r5,r1
clr r0
2:
movb r0,ch
mov r1,r0
mov (sp)+,r5
mov (sp)+,r3
mov (sp)+,r2
rts pc
1:
mov r0,r3
mov r5,r0
jsr pc,fbcheck
add $141,r0
cmp r3,$'b
beq 1f
add $10.,r0
1:
mov r0,r4
mov (sp)+,r5
mov (sp)+,r3
mov (sp)+,r2
add $2,(sp)
rts pc
rch:
movb ch,r0
beq 1f
clrb ch
rts pc
1:
dec inbfcnt
blt 2f
movb *inbfp,r0
inc inbfp
bic $!177,r0
beq 1b
rts pc
2:
movb fin,r0
beq 3f
sys read; inbuf;512.
bcs 2f
tst r0
beq 2f
mov r0,inbfcnt
mov $inbuf,inbfp
br 1b
2:
movb fin,r0
clrb fin
sys close
3:
decb nargs
bgt 2f
mov $'\e,r0
rts pc
2:
tst ifflg
beq 2f
jsr r5,error; 'i
jmp aexit
2:
mov curarg,r0
tst (r0)+
mov (r0),0f
mov r0,curarg
incb fileflg
sys open; 0:0; 0
bec 2f
mov 0b,0f
jsr r5,filerr; 0:0; <?\n>
jmp aexit
2:
movb r0,fin
mov $1,line
mov r4,-(sp)
mov r1,-(sp)
mov $5,r4
jsr pc,putw
mov *curarg,r1
2:
movb (r1)+,r4
beq 2f
jsr pc,putw
br 2b
2:
mov $-1,r4
jsr pc,putw
mov (sp)+,r1
mov (sp)+,r4
br 1b

166
src/cmd/as15.s Normal file
View File

@@ -0,0 +1,166 @@
/ a5 -- pdp-11 assembler pass 1
readop:
mov savop,r4
beq 1f
clr savop
rts pc
1:
jsr pc,8f
jsr pc,putw
rts pc
8:
jsr pc,rch
mov r0,r4
movb chartab(r0),r1
bgt rdname
jmp *1f-2(r1)
fixor
escp
8b
retread
dquote
garb
squote
rdname
skip
rdnum
retread
string
1:
escp:
jsr pc,rch
mov $esctab,r1
1:
cmpb r0,(r1)+
beq 1f
tstb (r1)+
bne 1b
rts pc
1:
movb (r1),r4
rts pc
esctab:
.byte '/, '/
.byte '\<, 035
.byte '>, 036
.byte '%, 037
.byte 0, 0
fixor:
mov $037,r4
retread:
rts pc
rdname:
movb r0,ch
cmp r1,$26.
ble 1f
cmp r1,$37.
blt rdnum
1:
jmp rname
rdnum:
jsr pc,number
br 1f
rts pc
squote:
jsr pc,rsch
br 1f
dquote:
jsr pc,rsch
mov r0,-(sp)
jsr pc,rsch
swab r0
bis (sp)+,r0
1:
mov r0,numval
mov $1,r4
jsr pc,putw
mov numval,r4
jsr pc,putw
mov $1,r4
tst (sp)+
rts pc
skip:
jsr pc,rch
mov r0,r4
cmp r0,$'\e
beq 1f
cmp r0,$'\n
bne skip
1:
rts pc
garb:
jsr r5,error; 'g
br 8b
string:
mov $'<,r4
jsr pc,putw
clr numval
1:
jsr pc,rsch
tst r1
bne 1f
mov r0,r4
bis $400,r4
jsr pc,putw
inc numval
br 1b
1:
mov $-1,r4
jsr pc,putw
mov $'<,r4
tst (sp)+
rts pc
rsch:
jsr pc,rch
cmp r0,$'\e
beq 4f
cmp r0,$'\n
beq 4f
clr r1
cmp r0,$'\\
bne 3f
jsr pc,rch
mov $schar,r2
1:
cmpb (r2)+,r0
beq 2f
tstb (r2)+
bpl 1b
rts pc
2:
movb (r2)+,r0
clr r1
rts pc
3:
cmp r0,$'>
bne 1f
inc r1
1:
rts pc
4:
jsr r5,error; '<
jmp aexit
schar:
.byte 'n, 012
.byte 't, 011
.byte 'e, 004
.byte '0, 000
.byte 'r, 015
.byte 'a, 006
.byte 'p, 033
.byte 0, -1

264
src/cmd/as16.s Normal file
View File

@@ -0,0 +1,264 @@
/ a6 -- pdp-11 assembler pass 1
opline:
mov r4,r0
jsr r5,betwen; 0; 200
br 1f
cmp r0,$'<
bne xpr
jmp opl17
xpr:
jsr pc,expres
add $2,dot
rts pc
1:
movb (r4),r0
cmp r0,$24
beq xpr
jsr r5,betwen; 5; 32
br xpr
mov r0,-(sp)
jsr pc,readop
mov (sp)+,r0
asl r0
jmp *1f-12(r0)
1:
opl13 / map fop freg,fdst to double
opl6
opl7
opl10
opl11
opl13 / map fld/fst to double
opl13
opl13 / map fop fsrc,freg to double
opl15
opl16
opl17
opl20
opl21
opl22
opl23
xpr
opl25
opl26
opl27
opl13 / map mul s,r to double
opl31
opl32
/double
opl13:
opl7:
jsr pc,addres
op2:
cmp r4,$',
beq 1f
jsr pc,errora
rts pc
1:
jsr pc,readop
opl15: / single operand
jsr pc,addres
add $2,dot
rts pc
opl31: / sob
jsr pc,expres
cmp r4,$',
beq 1f
jsr pc,errora
1:
jsr pc,readop
/branch
opl6:
opl10:
opl11:
jsr pc,expres
add $2,dot
rts pc
/ .byte
opl16:
jsr pc,expres
inc dot
cmp r4,$',
bne 1f
jsr pc,readop
br opl16
1:
rts pc
/ < (.ascii)
opl17:
add numval,dot
jsr pc,readop
rts pc
/.even
opl20:
inc dot
bic $1,dot
rts pc
/.if
opl21:
jsr pc,expres
tst r3
bne 1f
jsr r5,error; 'U
1:
tst r2
bne opl22
inc ifflg
opl22: /endif
rts pc
/.globl
opl23:
cmp r4,$200
blo 1f
bisb $40,(r4)
jsr pc,readop
cmp r4,$',
bne 1f
jsr pc,readop
br opl23
1:
rts pc
opl25:
opl26:
opl27:
mov dotrel,r1
asl r1
mov dot,savdot-4(r1)
mov savdot-52(r0),dot
asr r0
sub $25-2,r0
mov r0,dotrel
rts pc
/ .common
opl32:
cmp r4,$200
blo 1f
bis $40,(r4)
jsr pc,readop
cmp r4,$',
bne 1f
jsr pc,readop
jsr pc,expres
rts pc
1:
jsr r5,error; 'x
rts pc
addres:
cmp r4,$'(
beq alp
cmp r4,$'-
beq amin
cmp r4,$'$
beq adoll
cmp r4,$'*
beq astar
getx:
jsr pc,expres
cmp r4,$'(
bne 2f
jsr pc,readop
jsr pc,expres
jsr pc,checkreg
jsr pc,checkrp
add $2,dot
clr r0
rts pc
2:
cmp r3,$24 / register type
bne 1f
jsr pc,checkreg
clr r0
rts pc
1:
add $2,dot
clr r0
rts pc
alp:
jsr pc,readop
jsr pc,expres
jsr pc,checkrp
jsr pc,checkreg
cmp r4,$'+
bne 1f
jsr pc,readop
clr r0
rts pc
1:
mov $2,r0
rts pc
amin:
jsr pc,readop
cmp r4,$'(
beq 1f
mov r4,savop
mov $'-,r4
br getx
1:
jsr pc,readop
jsr pc,expres
jsr pc,checkrp
jsr pc,checkreg
clr r0
rts pc
adoll:
jsr pc,readop
jsr pc,expres
add $2,dot
clr r0
rts pc
astar:
jsr pc,readop
cmp r0,$'*
beq 1f
jsr pc,addres
add r0,dot
rts pc
2:
jsr r5,error; '*
rts pc
errora:
jsr r5,error; 'a
rts pc
checkreg:
cmp r2,$7
bhi 1f
cmp r3,$1
beq 2f
cmp r3,$4
bhi 2f
1:
jsr pc,errora
2:
rts pc
errore:
jsr r5,error; 'e
rts pc
checkrp:
cmp r4,$')
beq 1f
jsr r5,error; ')
rts pc
1:
jsr pc,readop
rts pc

217
src/cmd/as17.s Normal file
View File

@@ -0,0 +1,217 @@
/ a7 -- pdp-11 assembler pass 1
expres:
mov r5,-(sp)
mov $'+,-(sp)
clr opfound
clr r2
mov $1,r3
br 1f
advanc:
jsr pc,readop
1:
mov r4,r0
jsr r5,betwen; 0; 177
br .+4
br 7f
movb (r4),r0
mov 2(r4),r1
br oprand
7:
cmp r4,$141
blo 1f
cmp r4,$141+10.
bhis 2f
movb curfbr-141(r4),r0
asl r4
mov curfb-[2*141](r4),r2
bpl oprand
jsr r5,error; 'f
br oprand
2:
clr r3
clr r2
br oprand
1:
mov $esw1,r1
1:
cmp (r1)+,r4
beq 1f
tst (r1)+
bne 1b
tst opfound
bne 2f
jsr pc,errore
2:
tst (sp)+
mov (sp)+,r5
rts pc
1:
jmp *(r1)
esw1:
'+; binop
'-; binop
'*; binop
'/; binop
'&; binop
037; binop
035; binop
036; binop
'%; binop
'[; brack
'^; binop
1; exnum
'!; binop
0; 0
binop:
cmpb (sp),$'+
beq 1f
jsr pc,errore
1:
movb r4,(sp)
br advanc
exnum:
mov numval,r1
mov $1,r0
br oprand
brack:
mov r2,-(sp)
mov r3,-(sp)
jsr pc,readop
jsr pc,expres
cmp r4,$']
beq 1f
jsr r5,error; ']
1:
mov r3,r0
mov r2,r1
mov (sp)+,r3
mov (sp)+,r2
oprand:
inc opfound
mov $exsw2,r5
1:
cmp (sp),(r5)+
beq 1f
tst (r5)+
bne 1b
br eoprnd
1:
jmp *(r5)
exsw2:
'+; exadd
'-; exsub
'*; exmul
'/; exdiv
037; exor
'&; exand
035;exlsh
036;exrsh
'%; exmod
'!; exnot
'^; excmbin
0; 0
excmbin:
mov r0,r3 / give left flag of right
br eoprnd
exrsh:
neg r1
beq exlsh
inc r1
clc
ror r2
exlsh:
jsr r5,combin; 0
als r1,r2
br eoprnd
exmod:
jsr r5,combin; 0
mov r1,-(sp)
mov r2,r1
clr r0
dvd (sp)+,r0
mov r1,r2
br eoprnd
exadd:
jsr r5,combin; 0
add r1,r2
br eoprnd
exsub:
jsr r5,combin; 1
sub r1,r2
br eoprnd
exand:
jsr r5,combin; 0
com r1
bic r1,r2
br eoprnd
exor:
jsr r5,combin; 0
bis r1,r2
br eoprnd
exmul:
jsr r5,combin; 0
mpy r2,r1
mov r1,r2
br eoprnd
exdiv:
jsr r5,combin; 0
mov r1,-(sp)
mov r2,r1
clr r0
dvd (sp)+,r0
mov r0,r2
br eoprnd
exnot:
jsr r5,combin; 0
com r1
add r1,r2
br eoprnd
eoprnd:
mov $'+,(sp)
jmp advanc
combin:
mov r0,-(sp)
bis r3,(sp)
bic $!40,(sp)
bic $!37,r0
bic $!37,r3
cmp r0,r3
ble 1f
mov r0,-(sp)
mov r3,r0
mov (sp)+,r3
1:
tst r0
beq 1f
tst (r5)+
beq 2f
cmp r0,r3
bne 2f
mov $1,r3
br 2f
1:
tst (r5)+
clr r3
2:
bis (sp)+,r3
rts r5

61
src/cmd/as18.s Normal file
View File

@@ -0,0 +1,61 @@
/ a8 -- pdp-11 assembler pass 1
chartab:
.byte -14,-14,-14,-14,-02,-14,-14,-14
.byte -14,-22, -2,-14,-14,-22,-14,-14
.byte -14,-14,-14,-14,-14,-14,-14,-14
.byte -14,-14,-14,-14,-14,-14,-14,-14
.byte -22,-20,-16,-14,-20,-20,-20,-12
.byte -20,-20,-20,-20,-20,-20,38.,-06
.byte 27.,28.,29.,30.,31.,32.,33.,34.
.byte 35.,36.,-20,-02,-00,-20,-14,-14
.byte -14,01.,02.,03.,04.,05.,06.,07.
.byte 08.,09.,10.,11.,12.,13.,14.,15.
.byte 16.,17.,18.,19.,20.,21.,22.,23.
.byte 24.,25.,26.,-20,-24,-20,-20,37.
.byte -14,01.,02.,03.,04.,05.,06.,07.
.byte 08.,09.,10.,11.,12.,13.,14.,15.
.byte 16.,17.,18.,19.,20.,21.,22.,23.
.byte 24.,25.,26.,-14,-26,-14,-14,-14
errflg: .byte 0
namedone: .byte 0
ch: .byte 0
a.tmp1: </tmp/atm1a\0>
a.tmp2: </tmp/atm2a\0>
a.tmp3: </tmp/atm3a\0>
qi: <I\n>
.even
curfb:
-1;-1;-1;-1;-1;-1;-1;-1;-1;-1
obufp: outbuf
symend: usymtab
txtsiz: .=.+2
datsiz: .=.+2
bsssiz: .=.+2
curfbr: .=.+10.
savdot: .=.+6
bufcnt: .=.+2
hshsiz = 1000.
hshtab: .=2*hshsiz+.
pof: .=.+1
wordf: .=.+1
fin: .=.+1
fbfil: .=.+1
fileflg: .=.+1
.even
symbol: .=.+6
inbuf: .=.+512.
obufc: .=.+2
outbuf: .=.+512.
line: .=.+2
inbfcnt: .=.+2
ifflg: .=.+2
inbfp: .=.+2
nargs: .=.+2
curarg: .=.+2
opfound: .=.+2
savop: .=.+2
numval: .=.+2
nxtfb: .=.+4

328
src/cmd/as19.s Normal file
View File

@@ -0,0 +1,328 @@
/ a9 -- pdp-11 assembler pass 1
eae = 0
/ key to types
/ 0 undefined
/ 1 absolute
/ 2 text
/ 3 data
/ 4 bss
/ 5 flop freg,dst (movfo, = stcfd)
/ 6 branch
/ 7 jsr
/ 10 rts
/ 11 sys
/ 12 movf (=ldf,stf)
/ 13 double operand (mov)
/ 14 flop fsrc,freg (addf)
/ 15 single operand (clr)
/ 16 .byte
/ 17 string (.ascii, "<")
/ 20 .even
/ 21 .if
/ 22 .endif
/ 23 .globl
/ 24 register
/ 25 .text
/ 26 .data
/ 27 .bss
/ 30 mul,div, etc
/ 31 sob
/ 32 .comm
symtab:
/ special variables
166600; 000000; dotrel: 02; dot:000000 /.
171560; 000000; 01; dotdot:000000 /..
/ register
072270;000000;24;000000 /r0
072340;000000;24;000001 /r1
072410;000000;24;000002 /r2
072460;000000;24;000003 /r3
072530;000000;24;000004 /r4
072600;000000;24;000005 /r5
074500;000000;24;000006 /sp
062170;000000;24;000007 /pc
.if eae
/eae & switches
012717;000000;01;177570 /csw
015176;000000;01;177300 /div
003270;000000;01;177302 /ac
051750;000000;01;177304 /mq
052224;000000;01;177306 /mul
073470;000000;01;177310 /sc
074620;000000;01;177311 /sr
054752;000000;01;177312 /nor
047000;000000;01;177314 /lsh
004500;000000;01;177316 /ash
.endif
/ system calls
021411;076400;01;0000001 /exit
023752;042300;01;0000002 /fork
070511;014400;01;0000003 /read
111231;076710;01;0000004 /write
060105;053600;01;0000005 /open
012257;073610;01;0000006 /close
107761;076400;01;0000007 /wait
012625;004540;01;0000010 /creat
046166;042300;01;0000011 /link
102574;035173;01;0000012 /unlink
021405;011300;01;0000013 /exec
012004;035420;01;0000014 /chdir
077165;017500;01;0000015 /time
050563;015172;01;0000016 /makdir
012015;057140;01;0000017 /chmod
012017;110760;01;0000020 /chown
007525;003770;01;0000021 /break
074741;076400;01;0000022 /stat
073615;042300;01;0000023 /seek
076724;045400;01;0000024 /tell
051655;055240;01;0000025 /mount
102527;102604;01;0000026 /umount
073634;102254;01;0000027 /setuid
026234;102254;01;0000030 /getuid
074751;051010;01;0000031 /stime
066621;076400;01;0000032 /quit
035204;070200;01;0000033 /intr
024214;004540;01;0000034 /fstat
011625;076400;01;0000035 /cemt
050741;076710;01;0000036 /mdate
074764;116100;01;0000037 /stty
027364;116100;01;0000040 /gtty
035047;035203;01;0000041 /ilgins
054353;017500;01;0000042 /nice
/ double operand
051656;000000;13;0010000 /mov
051656;006200;13;0110000 /movb
012330;000000;13;0020000 /cmp
012330;006200;13;0120000 /cmpb
006774;000000;13;0030000 /bit
006774;006200;13;0130000 /bitb
006753;000000;13;0040000 /bic
006753;006200;13;0140000 /bicb
006773;000000;13;0050000 /bis
006773;006200;13;0150000 /bisb
003344;000000;13;0060000 /add
075012;000000;13;0160000 /sub
/ branch
007520;000000;06;0000400 /br
007265;000000;06;0001000 /bne
006531;000000;06;0001400 /beq
006635;000000;06;0002000 /bge
007164;000000;06;0002400 /blt
006654;000000;06;0003000 /bgt
007145;000000;06;0003400 /ble
007414;000000;06;0100000 /bpl
007221;000000;06;0100400 /bmi
006711;000000;06;0101000 /bhi
007157;073300;06;0101400 /blos
007763;000000;06;0102000 /bvc
010003;000000;06;0102400 /bvs
006711;073300;06;0103000 /bhis
006513;000000;06;0103000 /bec
006373;000000;06;0103000 /bcc
007157;000000;06;0103400 /blo
006413;000000;06;0103400 /bcs
006533;000000;06;0103400 /bes
/ single operand
012262;000000;15;0005000 /clr
012262;006200;15;0105000 /clrb
012445;000000;15;0005100 /com
012445;006200;15;0105100 /comb
035163;000000;15;0005200 /inc
035163;006200;15;0105200 /incb
014713;000000;15;0005300 /dec
014713;006200;15;0105300 /decb
054117;000000;15;0005400 /neg
054117;006200;15;0105400 /negb
003343;000000;15;0005500 /adc
003343;006200;15;0105500 /adcb
073423;000000;15;0005600 /sbc
073423;006200;15;0105600 /sbcb
100014;000000;15;0005700 /tst
100014;006200;15;0105700 /tstb
071352;000000;15;0006000 /ror
071352;006200;15;0106000 /rorb
071344;000000;15;0006100 /rol
071344;006200;15;0106100 /rolb
004512;000000;15;0006200 /asr
004512;006200;15;0106200 /asrb
004504;000000;15;0006300 /asl
004504;006200;15;0106300 /aslb
040230;000000;15;0000100 /jmp
075131;006200;15;0000300 /swab
/ jsr
040612;000000;07;0004000 /jsr
/ rts
071663;000000;010;000200 /rts
/ simple operand
075273;000000;011;104400 /sys
/ flag-setting
012243;000000;01;0000241 /clc
012266;000000;01;0000242 /clv
012272;000000;01;0000244 /clz
012256;000000;01;0000250 /cln
073613;000000;01;0000261 /sec
073636;000000;01;0000262 /sev
073642;000000;01;0000264 /sez
073626;000000;01;0000270 /sen
/ floating point ops
011663;011300;01;170000 / cfcc
073634;022600;01;170001 / setf
073634;014400;01;170011 / setd
073634;034100;01;170002 / seti
073634;045400;01;170012 / setl
012262;022600;15;170400 / clrf
054117;022600;15;170700 / negf
003243;022600;15;170600 / absf
100014;022600;15;170500 / tstf
051656;022600;12;172400 / movf
051656;034460;14;177000 / movif
051656;023350;05;175400 / movfi
051656;057260;14;177400 / movof
051656;023730;05;176000 / movfo
003344;022600;14;172000 / addf
075012;022600;14;173000 / subf
052224;022600;14;171000 / mulf
015176;022600;14;174400 / divf
012330;022600;14;173400 / cmpf
051634;022600;14;171400 / modf
024153;000000;24;000000 / fr0
024154;000000;24;000001 / fr1
024155;000000;24;000002 / fr2
024156;000000;24;000003 / fr3
024157;000000;24;000004 / fr4
024160;000000;24;000005 / fr5
/ 11/45 operations
004063;000000;30;072000 /als (ash)
004063;011300;30;073000 /alsc (ashc)
051731;000000;30;070000 /mpy
.if eae-1
052224;000000;30;070000 /mul (=mpy)
015176;000000;30;071000 / div (=dvd)
004500;000000;30;072000 / ash (=als)
004500;011300;30;073000 / ashc
.endif
016164;000000;30;071000 /dvd
114152;000000;07;074000 /xor
075224;000000;15;006700 /sxt
050572;042300;11;006400 /mark
074432;000000;31;077000 /sob
/ specials
166751;076710;16;000000 /.byte
167136;020560;20;000000 /.even
167356;000000;21;000000 /.if
167126;015156;22;000000 /.endif
167244;057034;23;000000 /.globl
170245;114440;25;000000 /.text
167041;076450;26;000000 /.data
166743;073300;27;000000 /.bss
167007;051510;32;000000 /.comm
usymtab:
0;0;0;0
start:
sys intr; aexit
mov sp,r5
mov (r5)+,r0
cmpb *2(r5),$'-
bne 1f
tst (r5)+
dec r0
br 2f
1:
clr unglob
2:
movb r0,nargs
mov r5,curarg
jsr r5,fcreat; a.tmp1
movb r0,pof
jsr r5,fcreat; a.tmp2
movb r0,fbfil
jsr pc,setup
mov $1,r0
sys write; qi; 2
jmp go
setup:
mov $symtab,r1
1:
mov $symbol,r0
mov (r1)+,(r0)+
beq 3f
mov (r1)+,(r0)+
mov (r1)+,r2
bic $37,r2
mov r2,(r0)+
mov r1,-(sp)
jsr pc,slot
mov (sp)+,r1
mov r1,(r0)
sub $6,(r0)
tst (r1)+
br 1b
3:
rts pc
slot:
mov symbol,r1
add symbol+2,r1
add symbol+4,r1
clr r0
dvd $hshsiz,r0
asl r1
add $hshtab,r1
1:
cmp r1,$hshtab
bhi 2f
mov $2*hshsiz+hshtab,r1
2:
mov -(r1),r2
beq 3f
mov $symbol,r3
cmp (r2)+,(r3)+
bne 1b
cmp (r2)+,(r3)+
bne 1b
mov (r2)+,r0
bic $37,r0
cmp r0,(r3)+
bne 1b
3:
mov r1,r0
rts pc
end:

194
src/cmd/as21.s Normal file
View File

@@ -0,0 +1,194 @@
/ a21 -- pdp-11 assembler pass 2
main:
sys intr; aexit
jmp start
/ set up sizes and origins
go:
jsr pc,getw
mov r4,txtsiz
mov r4,r1
jsr pc,getw
mov r4,datsiz
mov r4,r2
jsr pc,getw
mov r4,bsssiz
mov r1,r3
mov r3,datbase / txtsiz
mov r3,savdot+2
add r2,r3
mov r3,bssbase / txtsiz+datsiz
mov r3,savdot+4
asl r3
add $20,r3
mov r3,symseek / 2*txtsiz+2*datsiz+20
sub r2,r3
mov r3,drelseek / 2*txtsiz+datsiz
sub r1,r3
mov r3,trelseek / txtsiz+datsiz+20
sub r2,r3
mov r3,datseek / txtsiz+20
/ read in symbol table itself
mov $usymtab,r1
1:
jsr pc,getw
bvs 1f
add $14,symsiz / count symbols
jsr pc,getw
jsr pc,getw
bic $!377,r4
bne 2f
mov defund,r4 / (perhaps) globalize undef.
2:
mov r4,(r1)+
jsr r5,doreloc
jsr pc,getw
add r3,r4
mov r4,(r1)+
jsr pc,setbrk
br 1b
1:
/ read in f-b definitions
mov r1,fbbufp
movb fbfil,fin
clr ibufc
1:
jsr pc,getw
bvs 1f
mov r4,(r1)+
swab r4
jsr r5,doreloc
jsr pc,getw
add r3,r4
mov r4,(r1)+
jsr pc,setbrk
br 1b
1:
mov $-1,(r1)+
/ set up input text file; initialize f-b table
mov txtfil,fin
clr ibufc
clr r4
1:
jsr pc,fbadv
tstb (r4)+
cmp r4,$10.
blt 1b
/ go
clr r0
jsr r5,oset; txtp
mov trelseek,r0
jsr r5,oset; relp
mov $8.,r2
mov $txtmagic,r1
1:
mov (r1)+,r0
jsr r5,putw; txtp
dec r2
bne 1b
jsr pc,assem
/polish off text and relocation
jsr r5,flush; txtp
jsr r5,flush; relp
/ append full symbol table
mov symf,r0
mov r0,fin
clr ibufc
sys seek; 6; 0
mov symseek,r0
jsr r5,oset; txtp
mov $usymtab,r1
1:
jsr pc,getw
bvs 1f
jsr pc,convs
jsr pc,getw
jsr pc,convs
jsr pc,getw
mov r4,r0
als $-10.,r0
bic $!77,r0
movb chartab(r0),r0
jsr r5,putw; txtp
mov (r1)+,r0
jsr r5,putw; txtp
jsr pc,getw
mov (r1)+,r0
jsr r5,putw; txtp
br 1b
1:
jsr r5,flush; txtp
aexit:
mov a.tmp1,0f
sys unlink; 0:..
mov a.tmp2,0f
sys unlink; 0:..
mov a.tmp3,0f
sys unlink; 0:..
sys chmod; a.out; outmod: 37
sys exit
filerr:
mov *(r5),r5
1:
movb (r5)+,ch
beq 1f
mov $1,r0
sys write; ch; 1
br 1b
1:
mov $1,r0
sys write; qnl; 2
br aexit
doreloc:
clr r3
bic $!37,r4
cmp r4,$5
bhis 1f
cmp r4,$3
blo 1f
beq 2f
mov bssbase,r3
br 1f
2:
mov datbase,r3
1:
rts r5
setbrk:
mov r1,-(sp)
add $20,r1
cmp r1,0f
blo 1f
add $512.,0f
sys break; 0: end
1:
mov (sp)+,r1
rts pc
mov a.tmp1,0f
sys unlink; 0:..
mov a.tmp2,0f
sys unlink; 0:..
mov a.tmp3,0f
sys unlink; 0:..
sys chmod; a.out; outmod: 37
sys exit

130
src/cmd/as22.s Normal file
View File

@@ -0,0 +1,130 @@
/ a2 -- pdp-11 assembler pass 2
outw:
cmp dot-2,$4
beq 9f
bit $1,dot
bne 1f
add $2,dot
clr -(sp)
rol r3
adc (sp)
asr r3 / get relative pc bit
cmp r3,$40
bne 2f
/ external references
mov $17,outmod / make nonexecutable
mov xsymbol,r3
sub $usymtab-symtab,r3
asl r3
bis $4,r3 / external relocation
br 3f
2:
bic $40,r3 / clear any ext bits
cmp r3,$5
blo 4f
mov $1,r3 / make absolute
4:
cmp r3,$2
blo 5f
cmp r3,$4
bhi 5f
tst (sp)
bne 4f
add dotdot,r2
br 4f
5:
tst (sp)
beq 4f
sub dotdot,r2
4:
dec r3
bpl 3f
clr r3
3:
asl r3
bis (sp)+,r3
mov r2,r0
jsr r5,putw; txtp
add $2,*tseekp
mov r3,r0
jsr r5,putw; relp
add $2,*rseekp
rts pc
1:
jsr r5,error; 'o
clr r3
jsr pc,outb
rts pc
9:
jsr r5,error; 'x
rts pc
outb:
cmp dot-2,$4 / test bss mode
beq 9b
cmp r3,$1
blos 1f
jsr r5,error; 'r
1:
mov r2,r0
jsr r5,putc; txtp
bit $1,dot
bne 1f
clr r0
jsr r5,putw; relp
add $2,*rseekp
1:
inc dot
inc *tseekp
rts pc
error:
mov $17,outmod / make nonexecutable
mov r3,-(sp)
mov r2,-(sp)
mov r1,-(sp)
mov r0,-(sp)
mov $argb,r1
1:
movb (r1),ch
beq 1f
clrb (r1)+
mov $1,r0
sys write; ch; 1
br 1b
1:
mov (r5)+,r0
movb r0,0f
mov line,r3
mov $0f+6,r0
mov $4,r1
2:
clr r2
dvd $10.,r2
add $'0,r3
movb r3,-(r0)
mov r2,r3
sob r1,2b
mov $1,r0
sys write; 0f; 7
mov (sp)+,r0
mov (sp)+,r1
mov (sp)+,r2
mov (sp)+,r3
rts r5
0: <f xxxx\n>
.even
betwen:
cmp r0,(r5)+
blt 1f
cmp (r5)+,r0
blt 2f
1:
tst (r5)+
2:
rts r5

128
src/cmd/as23.s Normal file
View File

@@ -0,0 +1,128 @@
/ a3 -- pdp-11 assembler pass 2
assem:
jsr pc,readop
jsr pc,checkeos
br ealoop
mov r4,-(sp)
jsr pc,readop
cmp (sp),$1
bne 1f
mov $2,(sp)
mov r4,numval
jsr pc,readop
1:
cmp r4,$'=
beq 4f
cmp r4,$':
beq 1f
mov r4,savop
mov (sp)+,r4
jsr pc,opline
br ealoop
1:
mov (sp)+,r4
cmp r4,$200
bhis 1f
cmp r4,$2
beq 3f
jsr r5,error; 'x
br assem
1:
cmp dot,symtab+2(r4)
beq assem
jsr r5,error; 'p
br assem
3:
mov numval,r4
jsr pc,fbadv
br assem
4:
jsr pc,readop
jsr pc,expres
mov (sp)+,r1
cmp r1,$200 /test for dot
bne 1f
bic $40,r3
cmp r3,dot-2 / can't change relocation
bne 2f
cmp r3,$4 / bss
bne 3f
mov r2,dot
br ealoop
3:
sub dot,r2
bmi 2f
mov r2,-(sp)
3:
dec (sp)
bmi 3f
clr r2
mov $1,r3
jsr pc,outb
br 3b
3:
tst (sp)+
br ealoop
2:
jsr r5,error; '.
br ealoop
1:
cmp r3,$40
bne 1f
jsr r5,error; 'r
1:
bic $37,symtab(r1)
bic $!37,r3
bne 1f
clr r2
1:
bisb r3,symtab(r1)
mov r2,symtab+2(r1)
ealoop:
cmp r4,$'\n
beq 1f
cmp r4,$'\e
bne assem
rts pc
1:
inc line
br assem
checkeos:
cmp r4,$'\n
beq 1f
cmp r4,$';
beq 1f
cmp r4,$'\e
beq 1f
add $2,(sp)
1:
rts pc
fbadv:
movb nxtfbr(r4),curfbr(r4)
asl r4
mov nxtfb(r4),curfb(r4)
mov nxtfbp(r4),r1
bne 1f
mov fbbufp,r1
1:
cmpb r4,(r1)+
beq 1f
tstb (r1)+
bpl 2f
dec r1
br 1f
2:
tst (r1)+
br 1b
1:
movb (r1)+,r0
mov (r1)+,nxtfb(r4)
mov r1,nxtfbp(r4)
asr r4
movb r0,nxtfbr(r4)
rts pc

126
src/cmd/as24.s Normal file
View File

@@ -0,0 +1,126 @@
/ a4 -- pdp-11 assembler pass 2
oset:
mov r2,-(sp)
mov (r5)+,r1
mov r0,r2
bic $!777,r0
add r1,r0
add $6,r0
mov r0,(r1)+ / next slot
mov r1,r0
add $1004,r0
mov r0,(r1)+ / buf max
mov r2,(r1)+ / seek addr
mov (sp)+,r2
rts r5
putw:
mov (r5),0f
jsr r5,putc; 0:..
swab r0
putc:
mov r1,-(sp)
mov r2,-(sp)
mov (r5)+,r2
mov (r2)+,r1 / slot
cmp r1,(r2) / buf max
bhis 1f
movb r0,(r1)+
mov r1,-(r2)
br 2f
1:
tst (r2)+
mov r0,-(sp)
jsr r5,flush1
mov (sp)+,r0
movb r0,*(r2)+
inc -(r2)
2:
mov (sp)+,r2
mov (sp)+,r1
rts r5
flush:
mov (r5)+,r2
cmp (r2)+,(r2)+
flush1:
mov (r2)+,r1
mov r1,0f / seek address
mov fout,r0
sys seek; 0:..; 0
bic $!777,r1
add r2,r1 / write address
mov r1,0f
mov r2,r0
bis $777,-(r2)
inc (r2) / new seek addr
cmp -(r2),-(r2)
sub (r2),r1
neg r1
mov r1,0f+2 / count
mov r0,(r2) / new next slot
mov fout,r0
sys write; 0:..; ..
rts r5
getc:
dec ibufc
bgt 1f
movb fin,r0
sys read; inbuf; 512.
mov r0,ibufc
bne 2f
sev
rts pc
2:
mov $inbuf,ibufp
1:
clr r4
bisb *ibufp,r4
inc ibufp
rts pc
readop:
mov savop,r4
beq getw
clr savop
rts pc
getw:
jsr pc,getc
bvs 1f
mov r4,-(sp)
jsr pc,getc
bvs 2f
swab r4
bis (sp)+,r4
rts pc
2:
tst (sp)+
1:
mov $4,r4
sev
rts pc
convs:
mov r5,-(sp)
mov r4,r5
clr r4
dvd $40.,r4
mov r5,-(sp)
mov r4,r5
clr r4
dvd $40.,r4
mov r5,-(sp)
movb chartab(r4),r0
jsr r5,putc; txtp
mov (sp)+,r4
movb chartab(r4),r0
jsr r5,putc; txtp
mov (sp)+,r4
movb chartab(r4),r0
jsr r5,putc; txtp
mov (sp)+,r5
rts pc

1
src/cmd/as25.s Normal file
View File

@@ -0,0 +1 @@
/ as25 is empty

450
src/cmd/as26.s Normal file
View File

@@ -0,0 +1,450 @@
/ a6 -- pdp-11 assembler pass 2
opline:
mov r4,r0
jsr r5,betwen; 0; 177
br 2f
cmp r4,$5
beq opeof
cmp r4,$'<
bne xpr
jmp opl17
xpr:
jsr pc,expres
jsr pc,outw
rts pc
2:
movb symtab(r4),r0
cmp r0,$24
beq xpr
jsr r5,betwen; 5; 32
br xpr
mov symtab+2(r4),-(sp)
mov r0,-(sp)
jsr pc,readop
mov (sp)+,r0
asl r0
mov $adrbuf,r5
clr swapf
mov $-1,rlimit
jmp *1f-10.(r0)
1:
opl5
opl6
opl7
opl10
opl11
opl12
opl13
opl14
opl15
opl16
opl17
opl20
opl21
opl22
opl23
xpr
opl25
opl26
opl27
opl30
opl31
opl32
opeof:
mov $1,line
mov $20,-(sp)
mov $argb,r1
1:
jsr pc,readop
tst r4
bmi 1f
movb r4,(r1)+
dec (sp)
bgt 1b
tstb -(r1)
br 1b
1:
movb $'\n,(r1)+
clrb (r1)+
tst (sp)+
rts pc
opl30: / mpy, dvd etc
inc swapf
mov $1000,rlimit
br opl13
opl14: / flop freg,fsrc
inc swapf
opl5: / flop src,freg
mov $400,rlimit
/double
opl13:
jsr pc,addres
op2a:
mov r2,-(sp)
jsr pc,readop
op2b:
jsr pc,addres
tst swapf
beq 1f
mov (sp),r0
mov r2,(sp)
mov r0,r2
1:
swab (sp)
asr (sp)
asr (sp)
cmp (sp),rlimit
blo 1f
jsr r5,error; 'x
1:
bis (sp)+,r2
bis (sp)+,r2
clr r3
jsr pc,outw
mov $adrbuf,r1
1:
cmp r1,r5
bhis 1f
mov (r1)+,r2
mov (r1)+,r3
mov (r1)+,xsymbol
jsr pc,outw
br 1b
1:
rts pc
opl15: / single operand
clr -(sp)
br op2b
opl12: / movf
mov $400,rlimit
jsr pc,addres
cmp r2,$4 / see if source is fregister
blo 1f
inc swapf
br op2a
1:
mov $174000,(sp)
br op2a
/sob
opl31: / sob
jsr pc,expres
jsr pc,checkreg
swab r2
asr r2
asr r2
bis r2,(sp)
jsr pc,readop
jsr pc,expres
sub dot,r2
neg r2
mov r2,r0
jsr r5,betwen; -2; 175
br 2f
add $4,r2
br 1f
/branch
opl6:
jsr pc,expres
sub dot,r2
mov r2,r0
jsr r5,betwen; -254.; 256.
br 2f
1:
bit $1,r2
bne 2f
cmp r3,dot-2 / same relocation as .
bne 2f
asr r2
dec r2
bic $177400,r2
1:
bis (sp)+,r2
clr r3
jsr pc,outw
rts pc
2:
jsr r5,error; 'b
clr r2
br 1b
/jsr
opl7:
jsr pc,expres
jsr pc,checkreg
br op2a
/ rts
opl10:
jsr pc,expres
jsr pc,checkreg
br 1f
/ sys, emt etc
opl11:
jsr pc,expres
cmp r2,$64.
bhis 0f
cmp r3,$1
ble 1f
0:
jsr pc,errora
1:
bis (sp)+,r2
jsr pc,outw
rts pc
/ .byte
opl16:
jsr pc,expres
jsr pc,outb
cmp r4,$',
bne 1f
jsr pc,readop
br opl16
1:
tst (sp)+
rts pc
/ < (.ascii)
opl17:
jsr pc,readop
mov $1,r3
mov r4,r2
bmi 2f
bic $!377,r2
jsr pc,outb
br opl17
2:
jsr pc,readop
rts pc
/.even
opl20:
bit $1,dot
beq 1f
cmp dot-2,$4
beq 2f / bss mode
clr r2
clr r3
jsr pc,outb
br 1f
2:
inc dot
1:
tst (sp)+
rts pc
opl21: /if
jsr pc,expres
opl22:
oplret:
tst (sp)+
rts pc
/.globl
opl23:
cmp r4,$200
blo 1f
bisb $40,symtab(r4)
jsr pc,readop
cmp r4,$',
bne 1f
jsr pc,readop
br opl23
1:
tst (sp)+
rts pc
opl25:
opl26:
opl27:
mov r0,-(sp)
mov dot-2,r1
asl r1
mov dot,savdot-4(r1)
jsr r5,flush; txtp
jsr r5,flush; relp
mov (sp),r2
add $txtseek-[2*25],r2
mov r2,tseekp
mov (r2),r0
jsr r5,oset; txtp
add $trelseek-txtseek,r2
mov (r2),r0
mov r2,rseekp
jsr r5,oset; relp
mov (sp)+,r0
mov savdot-[2*25](r0),dot
asr r0
sub $25-2,r0
mov r0,dot-2 / new . relocation
tst (sp)+
rts pc
opl32:
cmp r4,$200
blo 1f
mov r4,-(sp)
jsr pc,readop
jsr pc,readop
jsr pc,expres
mov (sp)+,r0
bit $37,symtab(r0)
bne 1f
bis $40,symtab(r0)
mov r2,symtab+2(r0)
1:
tst (sp)+
rts pc
addres:
clr -(sp)
4:
cmp r4,$'(
beq alp
cmp r4,$'-
beq amin
cmp r4,$'$
beq adoll
cmp r4,$'*
bne getx
jmp astar
getx:
jsr pc,expres
cmp r4,$'(
bne 2f
jsr pc,readop
mov r2,(r5)+
mov r3,(r5)+
mov xsymbol,(r5)+
jsr pc,expres
jsr pc,checkreg
jsr pc,checkrp
bis $60,r2
bis (sp)+,r2
rts pc
2:
cmp r3,$24
bne 1f
jsr pc,checkreg
bis (sp)+,r2
rts pc
1:
mov r3,-(sp)
bic $40,r3
mov (sp)+,r3
bis $100000,r3
sub dot,r2
sub $4,r2
cmp r5,$adrbuf
beq 1f
sub $2,r2
1:
mov r2,(r5)+ / index
mov r3,(r5)+ / index reloc.
mov xsymbol,(r5)+ / index global
mov $67,r2 / address mode
bis (sp)+,r2
rts pc
alp:
jsr pc,readop
jsr pc,expres
jsr pc,checkrp
jsr pc,checkreg
cmp r4,$'+
beq 1f
tst (sp)+
beq 2f
bis $70,r2
clr (r5)+
clr (r5)+
mov xsymbol,(r5)+
rts pc
2:
bis $10,r2
rts pc
1:
jsr pc,readop
bis $20,r2
bis (sp)+,r2
rts pc
amin:
jsr pc,readop
cmp r4,$'(
beq 1f
mov r4,savop
mov $'-,r4
br getx
1:
jsr pc,readop
jsr pc,expres
jsr pc,checkrp
jsr pc,checkreg
bis (sp)+,r2
bis $40,r2
rts pc
adoll:
jsr pc,readop
jsr pc,expres
mov r2,(r5)+
mov r3,(r5)+
mov xsymbol,(r5)+
mov (sp)+,r2
bis $27,r2
rts pc
astar:
tst (sp)
beq 1f
jsr r5,error; '*
1:
mov $10,(sp)
jsr pc,readop
jmp 4b
errora:
jsr r5,error; 'a
rts pc
checkreg:
cmp r2,$7
bhi 1f
cmp r1,$1
blos 2f
cmp r3,$5
blo 1f
2:
rts pc
1:
jsr pc,errora
clr r2
clr r3
rts pc
errore:
jsr r5,error; 'e
rts pc
checkrp:
cmp r4,$')
beq 1f
jsr r5,error; ')
rts pc
1:
jsr pc,readop
rts pc

260
src/cmd/as27.s Normal file
View File

@@ -0,0 +1,260 @@
/ a7 -- pdp-11 assembler
expres:
clr xsymbol
expres1:
mov r5,-(sp)
mov $'+,-(sp)
clr r2
mov $1,r3
br 1f
advanc:
jsr pc,readop
1:
mov r4,r0
jsr r5,betwen; 0; 177
br .+4
br 7f
movb symtab(r4),r0
tst r0
bne 1f
jsr r5,error; 'u
1:
cmp r0,$40
bne 1f
mov r4,xsymbol
clr r1
br oprand
1:
mov symtab+2(r4),r1
br oprand
7:
cmp r4,$141
blo 1f
movb curfbr-141(r4),r0
asl r4
mov curfb-[2*141](r4),r1
br oprand
1:
mov $esw1,r1
1:
cmp (r1)+,r4
beq 1f
tst (r1)+
bne 1b
tst (sp)+
mov (sp)+,r5
rts pc
1:
jmp *(r1)
esw1:
'+; binop
'-; binop
'*; binop
'/; binop
'&; binop
037; binop
035; binop
036; binop
'%; binop
'[; brack
'^; binop
1; exnum
2; exnum1
'!; binop
200; 0
binop:
cmpb (sp),$'+
beq 1f
jsr pc,errore
1:
movb r4,(sp)
br advanc
exnum1:
mov numval,r1
br 1f
exnum:
jsr pc,readop
mov r4,r1
1:
mov $1,r0
br oprand
brack:
mov r2,-(sp)
mov r3,-(sp)
jsr pc,readop
jsr pc,expres1
cmp r4,$']
beq 1f
jsr r5,error; ']
1:
mov r3,r0
mov r2,r1
mov (sp)+,r3
mov (sp)+,r2
oprand:
mov $exsw2,r5
1:
cmp (sp),(r5)+
beq 1f
tst (r5)+
bne 1b
br eoprnd
1:
jmp *(r5)
exsw2:
'+; exadd
'-; exsub
'*; exmul
'/; exdiv
037; exor
'&; exand
035;exlsh
036;exrsh
'%; exmod
'^; excmbin
'!; exnot
200; 0
excmbin:
mov r0,r3
br eoprnd
exrsh:
neg r1
beq exlsh
inc r1
clc
ror r2
exlsh:
jsr r5,combin; relte2
als r1,r2
br eoprnd
exmod:
jsr r5,combin; relte2
mov r3,r0
mov r2,r3
clr r2
dvd r1,r2
mov r3,r2
mov r0,r3
br eoprnd
exadd:
jsr r5,combin; reltp2
add r1,r2
br eoprnd
exsub:
jsr r5,combin; reltm2
sub r1,r2
br eoprnd
exand:
jsr r5,combin; relte2
com r1
bic r1,r2
br eoprnd
exor:
jsr r5,combin; relte2
bis r1,r2
br eoprnd
exmul:
jsr r5,combin; relte2
mpy r2,r1
mov r1,r2
br eoprnd
exdiv:
jsr r5,combin; relte2
mov r3,r0
mov r2,r3
clr r2
dvd r1,r2
mov r0,r3
br eoprnd
exnot:
jsr r5,combin; relte2
com r1
add r1,r2
br eoprnd
eoprnd:
mov $'+,(sp)
jmp advanc
combin:
mov r1,-(sp)
clr maxtyp
jsr pc,maprel
mov r0,r1
mpy $6,r1
mov r3,r0
jsr pc,maprel
add (r5)+,r0
add r1,r0
movb (r0),r3
bpl 1f
cmp r3,$-1
beq 2f
jsr r5,error; 'r
2:
mov maxtyp,r3
1:
mov (sp)+,r1
rts r5
maprel:
cmp r0,$40
bne 1f
mov $5,r0
rts pc
1:
bic $!37,r0
cmp r0,maxtyp
blos 1f
mov r0,maxtyp
1:
cmp r0,$5
blos 1f
mov $1,r0
1:
rts pc
X = -2
M = -1
reltp2:
.byte 0, 0, 0, 0, 0, 0
.byte 0, M, 2, 3, 4,40
.byte 0, 2, X, X, X, X
.byte 0, 3, X, X, X, X
.byte 0, 4, X, X, X, X
.byte 0,40, X, X, X, X
reltm2:
.byte 0, 0, 0, 0, 0, 0
.byte 0, M, 2, 3, 4,40
.byte 0, X, 1, X, X, X
.byte 0, X, X, 1, X, X
.byte 0, X, X, X, 1, X
.byte 0, X, X, X, X, X
relte2:
.byte 0, 0, 0, 0, 0, 0
.byte 0, M, X, X, X, X
.byte 0, X, X, X, X, X
.byte 0, X, X, X, X, X
.byte 0, X, X, X, X, X
.byte 0, X, X, X, X, X

74
src/cmd/as28.s Normal file
View File

@@ -0,0 +1,74 @@
/ as8 -- PDP-11 assembler pass 2
chartab:
<\0abcdefg>
<hijklmno>
<pqrstuvw>
<xyz012345>
<6789_.>
qnl: <?\n>
qii:
<II\n>
a.out: <a.out\0>
badfil: <//\0> / a file which should never exist
.even
a.outp: a.out
a.tmp1: badfil
a.tmp2: badfil
a.tmp3: badfil
tseekp: txtseek
rseekp: trelseek
txtmagic:
br .+20
txtsiz: .=.+2
datsiz: .=.+2
bsssiz: .=.+2
symsiz: .=.+2
stksiz: .=.+2
exorig: .=.+2
.=.+2
txtseek: 20
datseek: .=.+2
.=.+2
trelseek: .=.+2
drelseek: .=.+2
.=.+2
symseek: .=.+2
fbbufp: .=.+2
defund: .=.+2
savdot: .=.+6
datbase: .=.+2
bssbase: .=.+2
fbfil: .=.+2
fin: .=.+2
ibufc: .=.+2
txtfil: .=.+2
symf: .=.+2
adrbuf: .=.+12.
xsymbol: .=.+2
fout: .=.+2
ch: .=.+2
wordf: .=.+2
argb: .=.+22.
line: .=.+2
savop: .=.+2
curfb: .=.+20.
nxtfb: .=.+20.
nxtfbp: .=.+20.
curfbr: .=.+10.
nxtfbr: .=.+10.
numval: .=.+2
maxtyp: .=.+2
relfil: .=.+2
ibufp: .=.+2
inbuf: .=.+512.
txtp: .=.+6+512.
relp: .=.+6+512.
swapf: .=.+2
rlimit: .=.+2

263
src/cmd/as29.s Normal file
View File

@@ -0,0 +1,263 @@
/ as9 -- PDP-11 assembler pass 2
eae = 0
symtab = .-200
/ special variables
02; dot:000000 /.
01; dotdot:000000 /..
/ register
24;000000 /r0
24;000001 /r1
24;000002 /r2
24;000003 /r3
24;000004 /r4
24;000005 /r5
24;000006 /sp
24;000007 /pc
.if eae
/eae & switches
01;177570 /csw
01;177300 /div
01;177302 /ac
01;177304 /mq
01;177306 /mul
01;177310 /sc
01;177311 /sr
01;177312 /nor
01;177314 /lsh
01;177316 /ash
.endif
/ system calls
01;0000001 /exit
01;0000002 /fork
01;0000003 /read
01;0000004 /write
01;0000005 /open
01;0000006 /close
01;0000007 /wait
01;0000010 /creat
01;0000011 /link
01;0000012 /unlink
01;0000013 /exec
01;0000014 /chdir
01;0000015 /time
01;0000016 /makdir
01;0000017 /chmod
01;0000020 /chown
01;0000021 /break
01;0000022 /stat
01;0000023 /seek
01;0000024 /tell
01;0000025 /mount
01;0000026 /umount
01;0000027 /setuid
01;0000030 /getuid
01;0000031 /stime
01;0000032 /quit
01;0000033 /intr
01;0000034 /fstat
01;0000035 /cemt
01;0000036 /mdate
01;0000037 /stty
01;0000040 /gtty
01;0000041 /ilgins
01;0000042 /nice
/ double operand
13;0010000 /mov
13;0110000 /movb
13;0020000 /cmp
13;0120000 /cmpb
13;0030000 /bit
13;0130000 /bitb
13;0040000 /bic
13;0140000 /bicb
13;0050000 /bis
13;0150000 /bisb
13;0060000 /add
13;0160000 /sub
/ branch
06;0000400 /br
06;0001000 /bne
06;0001400 /beq
06;0002000 /bge
06;0002400 /blt
06;0003000 /bgt
06;0003400 /ble
06;0100000 /bpl
06;0100400 /bmi
06;0101000 /bhi
06;0101400 /blos
06;0102000 /bvc
06;0102400 /bvs
06;0103000 /bhis
06;0103000 /bec
06;0103000 /bcc
06;0103400 /blo
06;0103400 /bcs
06;0103400 /bes
/ single operand
15;0005000 /clr
15;0105000 /clrb
15;0005100 /com
15;0105100 /comb
15;0005200 /inc
15;0105200 /incb
15;0005300 /dec
15;0105300 /decb
15;0005400 /neg
15;0105400 /negb
15;0005500 /adc
15;0105500 /adcb
15;0005600 /sbc
15;0105600 /sbcb
15;0005700 /tst
15;0105700 /tstb
15;0006000 /ror
15;0106000 /rorb
15;0006100 /rol
15;0106100 /rolb
15;0006200 /asr
15;0106200 /asrb
15;0006300 /asl
15;0106300 /aslb
15;0000100 /jmp
15;0000300 /swab
/ jsr
07;0004000 /jsr
/ rts
10;000200 /rts
/ simple operand
11;104400 /sys
/ flag-setting
01;0000241 /clc
01;0000242 /clv
01;0000244 /clz
01;0000250 /cln
01;0000261 /sec
01;0000262 /sev
01;0000264 /sez
01;0000270 /sen
/ floating point ops
01;170000 / cfcc
01;170001 / setf
01;170011 / setd
01;170002 / seti
01;170012 / setl
15;170400 / clrf
15;170700 / negf
15;170600 / absf
15;170500 / tstf
12;172400 / movf
14;177000 / movif
05;175400 / movfi
14;177400 / movof
05;176000 / movfo
14;172000 / addf
14;173000 / subf
14;171000 / mulf
14;174400 / divf
14;173400 / cmpf
14;171400 / modf
24;000000 / fr0
24;000001 / fr1
24;000002 / fr2
24;000003 / fr3
24;000004 / fr4
24;000005 / fr5
/ 11/45 operations
30;072000 /als (ash)
30;073000 /alsc (ashc)
30;070000 /mpy
.if eae-1
30;070000/ mul
30;071000 / div
30;072000 / ash
30;073000 /ashc
.endif
30;071000 /dvd
07;074000 /xor
15;006700 /sxt
11;006400 /mark
31;077000 /sob
/ specials
16;000000 /.byte
20;000000 /.even
21;000000 /.if
22;000000 /.endif
23;000000 /.globl
25;000000 /.text
26;000000 /.data
27;000000 /.bss
32;000000 /.comm
usymtab:
start:
mov $1,r0
sys write; qii; 3
cmp (sp),$4
bge 1f
jmp aexit
1:
cmp (sp)+,$5
blt 1f
mov $40,defund / globalize all undefineds
1:
tst (sp)+
mov (sp)+,a.tmp1
mov (sp)+,a.tmp2
mov (sp)+,a.tmp3
jsr r5,ofile; a.tmp1
movb r0,txtfil
jsr r5,ofile; a.tmp2
movb r0,fbfil
jsr r5,ofile; a.tmp3
movb r0,symf
movb r0,fin
sys creat; a.out; 12
bec 1f
jsr r5,filerr; a.outp
1:
movb r0,fout
jmp go
ofile:
mov *(r5),0f
sys open; 0:..; 0
bes 1f
tst (r5)+
rts r5
1:
jmp filerr
end:

346
src/cmd/bas0.s Normal file
View File

@@ -0,0 +1,346 @@
/ bas0 -- basic
.globl main
.globl sin, cos, log, exp, atan, pow
.globl atoi, atof, ftoa, ftoo
.globl rand, srand
one = 40200
main:
setd
sys time
mov r1,r0
mov r0,randx
jsr pc,srand
sys intr; intrup
mov sp,gsp
clr seeka
mov $'a,r1
1:
movb r1,tmpf+8
sys stat; tmpf; line
bes 1f
inc r1
cmp r1,$'z
blos 1b
br 2f
1:
sys creat; tmpf; 14
bes 2f
mov r0,tfo
sys open; tmpf; 0
bec 1f
2:
mov $3f,r0
jsr pc,print
sys exit
3:
<Tmp file?\n\0>; .even
1:
mov r0,tfi
jsr pc,isymtab
cmp (sp),$2
blt loop
mov 4(sp),0f
sys open; 0:..; 0
bes 1f
mov r0,fi
br loop
1:
mov $1f,r0
jsr pc,print
br loop
1:
<Cannot open file\n\0>; .even
intrup:
mov $'\n,r0
jsr r5,putc
jsr r5,error
<ready\n\0>; .even
loop:
mov gsp,sp
clr lineno
jsr pc,rdline
mov $line,r3
1:
movb (r3),r0
jsr pc,digit
br 1f
jsr r5,atoi; nextc
cmp r0,$' /
bne 1f
mov $lintab,r3
mov r1,r0
bgt 2f
jsr pc,serror
2:
cmp r0,(r3)
beq 2f
tst (r3)
beq 2f
add $6,r3
br 2b
2:
cmp r3,$elintab-12.
blo 2f
jsr r5,error
<too many lines\n\0>; .even
2:
mov r0,(r3)+
mov seeka,(r3)+
mov tfo,r0
sys seek; seeka:..; 0
mov $line,r0
jsr pc,size
inc r0
add r0,seeka
mov r0,0f
mov tfo,r0
sys write; line; 0:..
br loop
1:
mov $line,r3
jsr pc,singstat
br loop
nextc:
movb (r3)+,r0
rts r5
size:
clr -(sp)
1:
inc (sp)
cmpb (r0)+,$'\n
bne 1b
mov (sp)+,r0
rts pc
rdline:
mov $line,0f
1:
mov fi,r0
sys read; 0:..; 1
bes 2f
tst r0
beq 2f
cmp 0b,$line+99.
bhis 2f / bad check, but a check
movb *0b,r0
inc 0b
cmp r0,$'\n
bne 1b
clrb *0b
rts pc
2:
mov fi,r0
beq 1f
sys close
clr fi
br 1b
1:
jmp _done
error:
tst fi
beq 1f
sys close
clr fi
1:
tst lineno
beq 1f
jsr pc,nextlin
br 1f
mov $line,r0
jsr pc,print
1:
mov r5,r0
jsr pc,print
jmp loop
serror:
dec r3
tst fi
beq 1f
sys close
clr fi
1:
mov $line,r1
1:
cmp r1,r3
bne 2f
mov $'_,r0
jsr r5,putc
mov $10,r0
jsr r5,putc
2:
movb (r1),r0
jsr r5,putc
cmpb (r1)+,$'\n
bne 1b
jmp loop
print:
mov r0,0f
jsr pc,size
mov r0,0f+2
mov $1,r0
sys write; 0:..; ..
rts pc
digit:
cmp r0,$'0
blo 1f
cmp r0,$'9
bhi 1f
add $2,(sp)
1:
rts pc
alpha:
cmp r0,$'a
blo 1f
cmp r0,$'z
bhi 1f
add $2,(sp)
1:
rts pc
name:
mov $nameb,r1
clr (r1)
clr 2(r1)
1:
cmp r1,$nameb+4
bhis 2f
movb r0,(r1)+
2:
movb (r3)+,r0
jsr pc,alpha
br 2f
br 1b
2:
jsr pc,digit
br 2f
br 1b
2:
mov $resnam,r1
1:
cmp nameb,(r1)
bne 2f
cmp nameb+2,2(r1)
bne 2f
sub $resnam,r1
asr r1
add $2,(sp)
rts pc
2:
add $4,r1
cmp r1,$eresnam
blo 1b
mov $symtab,r1
1:
tst (r1)
beq 1f
cmp nameb,(r1)
bne 2f
cmp nameb+2,2(r1)
bne 2f
rts pc
2:
add $14.,r1
br 1b
1:
cmp r1,$esymtab-28.
blo 1f
jsr r5,error
<out of symbol space\n\0>; .even
1:
mov nameb,(r1)
mov nameb+2,2(r1)
clr 4(r1)
clr 14.(r1)
rts pc
skip:
cmp r0,$' /
bne 1f
movb (r3)+,r0
br skip
1:
rts pc
putc:
tstb drflg
beq 1f
jsr pc,drput
rts r5
1:
mov r0,ch
mov $1,r0
sys write; ch; 1
rts r5
nextlin:
clr -(sp)
mov $lintab,r1
1:
tst (r1)
beq 1f
cmp lineno,(r1)
bhi 2f
mov (sp),r0
beq 3f
cmp (r0),(r1)
blos 2f
3:
mov r1,(sp)
2:
add $6,r1
br 1b
1:
mov (sp)+,r1
beq 1f
mov (r1)+,lineno
mov (r1)+,0f
mov tfi,r0
sys seek; 0:..; 0
mov tfi,r0
sys read; line; 100.
add $2,(sp)
1:
rts pc
getloc:
mov $lintab,r1
1:
tst (r1)
beq 1f
cmp r0,(r1)
beq 2f
add $6,r1
br 1b
1:
jsr r5,error
<label not found\n\0>; .even
2:
rts pc
isymtab:
mov $symtab,r0
mov $symtnam,r1
clrf fr0
movf $one,fr1
1:
mov (r1)+,(r0)+
mov (r1)+,(r0)+
mov $1,(r0)+
subf r1,r0
movf r0,(r0)+
cmp r1,$esymtnam
blo 1b
clr (r0)+
rts pc

284
src/cmd/bas1.s Normal file
View File

@@ -0,0 +1,284 @@
/ bas1 -- compile
compile:
clr forp
mov $space,r4
tst lineno
beq 1f
rts pc
1:
jsr pc,nextlin
br 1f
mov lineno,r0
jsr pc,getloc
mov r4,4(r1)
jsr pc,statement
br .+2
inc lineno
cmp r4,$espace-20.
blo 1b
jsr r5,error
<out of code space\n\0>; .even
1:
tst forp
bne 2f
mov $loop,(r4)+
rts pc
singstat:
clr forp
mov $exline,r4
jsr pc,statement
br 1f
cmp -2(r4),$_asgn
beq 1f
mov $_print,(r4)+
mov $_nline,(r4)+
1:
tst forp
bne 2f
cmp r4,$eexline
blo 1f
jsr r5,error
<out of code space\n\0>; .even
1:
mov $loop,(r4)+
mov r4,exprloc
mov $exline,r4
jmp execute
2:
jmp forer
statement:
mov $line,r3
movb (r3)+,r0
jsr pc,digit
br stat1
dec r3
jsr r5,atoi; nextc
cmp r0,$' /
beq 1f
mov $line,r3
movb (r3)+,r0
br stat1
1:
mov $_line,(r4)+
mov r1,(r4)+
stat1:
jsr pc,skip
cmp r0,$'\n
bne .+4
rts pc
mov r3,-(sp)
jsr pc,alpha
br 1f
jsr pc,name
br 1f
tst (sp)+
jsr pc,skip
dec r3
jmp *2f(r1)
2:
stlist
stdone
strun
stprint
stdisp
stif
stgoto
streturn
stfor
stnext
stoctl
stdraw
steras
1:
mov (sp)+,r3
dec r3
jsr pc,expr
cmp r0,$'\n
bne joe
add $2,(sp)
rts pc
stlist:
cmp r0,$'\n
bne 1f
clrf r0
jsr pc,const
movif $77777,r0
jsr pc,const
br 2f
1:
jsr pc,expr
cmp r0,$'\n
bne 1f
mov $_dup,(r4)+
br 2f
1:
dec r3
jsr pc,expr
cmp r0,$'\n
bne joe
2:
mov $_list,(r4)+
rts pc
stdone:
cmp r0,$'\n
bne joe
mov $_done,(r4)+
rts pc
strun:
cmp r0,$'\n
bne joe
mov $_run,(r4)+
rts pc
stdisp:
mov $_sdisp,(r4)+
jsr pc,stprint
mov $_fdisp,(r4)+
rts pc
stprint:
jsr pc,skip
cmp r0,$'\n
beq 2f
cmp r0,$'"
beq 1f
dec r3
jsr pc,expr
mov $_print,(r4)+
dec r3
br stprint
1:
mov $_ascii,(r4)+
inc r3
1:
movb (r3)+,(r4)
cmpb (r4),$'"
beq 1f
cmpb (r4)+,$'\n
bne 1b
br joe
1:
add $2,r4
bic $1,r4
movb (r3)+,r0
br stprint
2:
mov $_nline,(r4)+
rts pc
stif:
jsr pc,expr
mov $_if,(r4)+
mov r4,-(sp)
tst (r4)+
jsr pc,stat1
br .+2
mov (sp)+,r1
mov r4,(r1)
rts pc
stgoto:
jsr pc,expr
mov $_goto,(r4)+
rts pc
streturn:
cmp r0,$'\n
beq 1f
jsr pc,expr
cmp r0,$'\n
bne joe
br 2f
1:
clrf r0
jsr pc,const
2:
mov $_return,(r4)+
rts pc
joe:
jsr pc,serror
stfor:
mov r4,-(sp)
jsr pc,e2
mov r4,-(sp)
cmp r0,$'=
bne joe
tst val
bne joe
jsr pc,expr
mov forp,(r4)+ / overlay w _asgn
mov r4,forp
cmp (r4)+,(r4)+ / _tra ..
mov (sp)+,r0
mov (sp)+,r1
1:
mov (r1)+,(r4)+
cmp r1,r0
blo 1b
mov $_fori,(r4)+
mov forp,r1
mov $_tra,(r1)+
mov r4,(r1)+
dec r3
jsr pc,expr
mov $_lesseq,(r4)+
mov $_if,(r4)+
mov forp,(r4)+
mov r4,forp
cmp r0,$'\n
beq 1f
jsr pc,stat1
br .+2
br stnext
1:
rts pc
forer:
jsr r5,error; <for/next imbalance\n\0>; .even
stnext:
mov forp,r1
beq forer
mov -(r1),r0
mov -(r0),forp
mov $_ptra,(r4)+
mov $_asgn,(r0)+
cmp (r0)+,(r0)+
mov r0,(r4)+
mov r4,(r1)+
rts pc
stoctl:
jsr pc,expr
mov $_octal,(r4)+
rts pc
stdraw:
jsr pc,expr
dec r3
jsr pc,expr
cmp r0,$'\n
bne 1f
movf $one,r0
jsr pc,const
br 2f
1:
dec r3
jsr pc,expr
2:
mov $_draw,(r4)+
rts pc
steras:
mov $_erase,(r4)+
rts pc

64
src/cmd/cat.s Normal file
View File

@@ -0,0 +1,64 @@
/ cat -- concatinate files
mov (sp)+,r5
tst (sp)+
mov $obuf,r2
cmp r5,$1
beq 3f
loop:
dec r5
ble done
mov (sp)+,r0
cmpb (r0),$'-
bne 2f
clr fin
br 3f
2:
mov r0,0f
sys open; 0:..; 0
bes loop
mov r0,fin
3:
mov fin,r0
sys read; ibuf; 512.
bes 3f
mov r0,r4
beq 3f
mov $ibuf,r3
4:
movb (r3)+,r0
jsr pc,putc
dec r4
bne 4b
br 3b
3:
mov fin,r0
beq loop
sys close
br loop
done:
sub $obuf,r2
beq 1f
mov r2,0f
mov $1,r0
sys write; obuf; 0:..
1:
sys exit
putc:
movb r0,(r2)+
cmp r2,$obuf+512.
blo 1f
mov $1,r0
sys write; obuf; 512.
mov $obuf,r2
1:
rts pc
.bss
ibuf: .=.+512.
obuf: .=.+512.
fin: .=.+2
.text

268
src/cmd/cc.c Normal file
View File

@@ -0,0 +1,268 @@
/* C command */
char *tmp0 "//";
char *tmp1 "//";
char *tmp2 "//";
char *tmp3 "//";
char *tmp4 "//";
char ts[500];
char *tsp ts;
char *av[50];
char *clist[50];
char *llist[50];
main(argc, argv)
char *argv[]; {
char *t, *pref;
int nc, nl, cflag, i, j, c, f20;
i = nc = nl = cflag = f20 = 0;
pref = "/lib/crt0.o";
while(++i < argc) {
if(*argv[i] == '-')
switch (argv[i][1]) {
default:
goto passa;
case 'c':
cflag++;
break;
case '2':
pref = "/lib/crt20.o";
f20 = 1;
}
else {
passa:
t = copy(argv[i]);
if(getsuf(t)=='c') {
clist[nc++] = t;
t = setsuf(copy(t));
if (dup(llist, t))
continue;
}
llist[nl++] = t;
}
}
if(nc==0)
goto nocom;
tmp0 = copy("/tmp/ctm0a");
while((c=open(tmp0, 0))>=0) {
close(c);
tmp0[9]++;
}
while((creat(tmp0, 012))<0)
tmp0[9]++;
intr(delfil);
(tmp1 = copy(tmp0))[8] = '1';
(tmp2 = copy(tmp0))[8] = '2';
(tmp3 = copy(tmp0))[8] = '3';
(tmp4 = copy(tmp0))[8] = '4';
for (i=0; i<nc; i++) {
if (nc>1)
printf("%s:\n", clist[i]);
av[0] = "c0";
av[1] = expand(clist[i]);
if (av[1] == 0) {
cflag++;
continue;
}
av[2] = tmp1;
av[3] = tmp2;
av[4] = 0;
if (callsys("/lib/c0", av)) {
cflag++;
continue;
}
av[0] = "c1";
av[1] = tmp1;
av[2] = tmp2;
av[3] = tmp3;
av[4] = 0;
if(callsys("/lib/c1", av)) {
cflag++;
continue;
}
av[0] = "as";
av[1] = "-";
if(f20) {
av[2] = "/lib/20.s";
av[3] = tmp3;
av[4] = 0;
} else {
av[2] = tmp3;
av[3] = 0;
}
callsys("/bin/as", av);
t = setsuf(clist[i]);
unlink(t);
if(link("a.out", t) | unlink("a.out")) {
printf("move failed: %s\n", t);
cflag++;
}
}
nocom:
if (cflag==0 & nl!=0) {
i = 0;
av[0] = "ld";
av[1] = pref;
j = 2;
while(i<nl)
av[j++] = llist[i++];
if(f20) {
av[j++] = "-l2";
av[j++] = 0;
} else {
av[j++] = "/lib/libc.a";
av[j++] = "-l";
av[j++] = 0;
}
if(f20) {
callsys("/usr/lib/ld20", av);
} else {
callsys("/bin/ld", av);
}
if (nc==1 & nl==1)
unlink(llist[0]);
}
delfil:
dexit();
}
dexit()
{
unlink(tmp1);
unlink(tmp2);
unlink(tmp3);
unlink(tmp4);
unlink(tmp0);
exit();
}
expand(file)
char *file;
{
int ibuf1[259], ibuf2[259], obuf[259];
char *hdrp, hdr[64];
int nlflg, c;
if (fopen(file, ibuf1)<0)
return(file);
if (getc(ibuf1) != '%') {
close(ibuf1[0]);
return(file);
}
ibuf1[1]++; /* back up over % */
ibuf1[2]--;
if (fcreat(tmp4, obuf) < 0) {
printf("Can't creat %s\n", tmp4);
dexit();
}
nlflg = 1;
while (c = getc(ibuf1)) {
if (c == '%' & nlflg) {
hdrp = hdr;
while ((c = getc(ibuf1)) != '\n')
if (c!=' ')
*hdrp++ = c;
*hdrp = '\0';
if (hdr[0] == '\0')
goto nohdr;
if (fopen(hdr, ibuf2) < 0) {
printf("Missing file %s\n", hdr);
close(ibuf1[0]);
return(0);
}
while (c = getc(ibuf2)) {
if (nlflg)
putc(1, obuf); /* SOH */
nlflg = c=='\n';
putc(c, obuf);
}
close(ibuf2[0]);
c = '\n';
}
nohdr:
nlflg = c=='\n';
putc(c, obuf);
}
fflush(obuf);
close(obuf[0]);
close(ibuf1[0]);
return(tmp4);
}
getsuf(s)
char s[];
{
int c;
char t, *os;
c = 0;
os = s;
while(t = *s++)
if (t=='/')
c = 0;
else
c++;
s =- 3;
if (c<=8 & c>2 & *s++=='.' & *s=='c')
return('c');
return(0);
}
setsuf(s)
char s[];
{
char *os;
os = s;
while(*s++);
s[-2] = 'o';
return(os);
}
callsys(f, v)
char f[], *v[]; {
int t, status;
if ((t=fork())==0) {
execv(f, v);
printf("Can't find %s\n", f);
exit(1);
} else
if (t == -1) {
printf("Try again\n");
return(1);
}
while(t!=wait(&status));
if ((t=(status&0377)) != 0 & t!=14) {
if (t!=12) /* interrupt */
printf("Fatal error in %s\n", f);
dexit();
}
return((status>>8) & 0377);
}
copy(s)
char s[]; {
char *otsp;
otsp = tsp;
while(*tsp++ = *s++);
return(otsp);
}
dup(l, s)
char **l, s[]; {
char *t, *os, c;
os = s;
while(t = *l++) {
s = os;
while(c = *s++)
if (c != *t++)
break;
if (*t++ == '\0') return (1);
}
return(0);
}

42
src/cmd/chmod.s Normal file
View File

@@ -0,0 +1,42 @@
/ chmod - change mode
chmode:
mov sp,r5
mov (r5),r4
cmp r4,$3
blt chmerr
add $4,r5
mov (r5)+,r1
clr 0f
1:
movb (r1)+,r0
beq 1f
asl 0f
asl 0f
asl 0f
bic $!7,r0
bis r0,0f
br 1b
1:
mov (r5)+,0f-2
sys chmod; ..; 0:..
bes chmerr
dec r4
cmp r4,$3
bge 1b
sys exit
chmerr:
mov $1,r0
sys write; 1f; 2
sys exit
1: <?\n>
q 1f
jsr pc,1b
1:
mov (sp)+,r0
add $'0,r0
jsr pc,putc
rts pc

101
src/cmd/chown.s Normal file
View File

@@ -0,0 +1,101 @@
/ chown -- change owner
.globl fopen, getc, mesg
mov sp,r5
mov (r5),r4
cmp r4,$3
bge 1f
jsr r5,mesg; <chown uid f1 ...\n\0>; .even
1:
add $4,r5
mov (r5),r3
cmpb (r3),$'0
blt 1f
cmpb (r3),$'9
bgt 1f
jsr r5,cvnum; geta
br do
1:
mov $uids,r0
jsr r5,fopen; ubuf
bec 1f
jsr r5,mesg; <Can't open /etc/uids\n\0>; .even
sys exit
1:
mov r3,r2
2:
jsr r5,getc; ubuf
bcc 3f
who:
jsr r5,mesg; <Who?\n\0>; .even
sys exit
3:
cmp r0,$':
beq 3f
cmpb (r2)+,r0
beq 2b
2:
jsr r5,getc; ubuf
bcs who
cmp r0,$'\n
bne 2b
br 1b
3:
tstb (r2)
bne 2b
3:
jsr r5,getc; ubuf
cmpb r0,$':
bne 3b
jsr r5,cvnum; getc
do:
sub $2,r4
mov r1,0f+2
tst (r5)+
1:
mov (r5)+,0f
sys chown; 0:..; 0
bec 2f
mov 0b,r0
mov r0,0f
clr 0f+2
3:
tstb (r0)+
beq 3f
inc 0f+2
br 3b
3:
mov $1,r0
sys write; 0:..; ..
jsr r5,mesg; <?\n\0>; .even
2:
dec r4
bgt 1b
sys exit
cvnum:
clr r1
1:
jsr r5,*(r5); ubuf
bcs 1f
sub $'0,r0
cmp r0,$9.
bhi 1f
mpy $10.,r1
add r0,r1
br 1b
1:
tst (r5)+
rts r5
geta:
movb (r3)+,r0
tst (r5)+
rts r5
uids: </etc/passwd\0>
.bss
ubuf: .=.+518.

122
src/cmd/cmp.s Normal file
View File

@@ -0,0 +1,122 @@
/ cmp -- compare files
cmp (sp)+,$3
beq 1f
jsr r5,mesg; <Usage: cmp arg1 arg2\n\0>; .even
sys exit
1:
tst (sp)+
mov (sp)+,0f
sys open; 0:..; 0
bec 1f
jsr r5,mesg; <Can't open arg1.\n\0>; .even
sys exit
1:
mov r0,f1
mov (sp)+,0f
sys open; 0:..; 0
bec 1f
jsr r5,mesg; <Can't open arg2.\n\0>; .even
sys exit
1:
mov r0,f2
clr r2
1:
jsr r5,getw; f1
bvs eof1
mov r0,r3
jsr r5,getw; f2
bvs eof2
cmp r0,r3
beq 2f
mov r0,r4
mov r2,r0
jsr pc,octal
jsr r5,mesg; <: \0>; .even
mov r3,r0
jsr pc,octal
jsr r5,mesg; < \0>;
mov r4,r0
jsr pc,octal
jsr r5,mesg; <\n\0>
2:
add $2,r2
br 1b
eof1:
jsr r5,getw; f2
bvs 1f
jsr r5,mesg; <EOF on arg1.\n\0>; .even
sys exit
1:
sys exit
eof2:
jsr r5,mesg; <EOF on arg2.\n\0>; .even
sys exit
mesg:
movb (r5)+,ch
beq 1f
mov $1,r0
sys write; ch; 1
br mesg
1:
inc r5
bic $1,r5
rts r5
getw:
mov (r5)+,r1
cmp 2(r1),$1
bne 1f
mov *4(r1),r0
bic $!377,r0
dec 2(r1)
rts r5
1:
sub $2,2(r1)
bge 1f
mov (r1),r0
mov r1,0f
add $6,0f
sys read; 0:..; 512.
mov r0,2(r1)
bne 2f
sev
rts r5
2:
mov r1,4(r1)
add $6,4(r1)
sub $2,2(r1)
1:
mov *4(r1),r0
add $2,4(r1)
rts r5
octal:
mov r4,-(sp)
mov r0,r5
mov $6,-(sp)
1:
clr r4
alsc $1,r4
cmp (sp),$6
beq 2f
alsc $2,r4
2:
add $'0,r4
mov r4,ch
mov $1,r0
sys write; ch; 1
dec (sp)
bne 1b
tst (sp)+
mov (sp)+,r4
rts pc
.bss
ch: .=.+2
f1: .=.+6; .=.+512.
f2: .=.+6; .=.+512.

33
src/cmd/colon.s Normal file
View File

@@ -0,0 +1,33 @@
/ colon -- do nothing
sys exit
; 9:
mov r1,frlist(r0)
mov exp2(r0),r0
add $strbuf,r0
mov r0,l(r1)
mov $frlist-2,r1
1: mov (r1),r1
tst r1
beq 1f
mov $strbuf,a(r1)
mov $strbuf,l(r1)
br 1b
1:
mov (sp)+,r1
mov (sp)+,r0
rts pc
/
/
.bss
stats: .=.+16.
useful: .=.+2
hdrptr: .=.+2 /do not move me
frlist: .=hdrptr+32.
frend:
headers:.=hdrptr+512.
headend:
strbuf: .=.+4000
strend:
end:

4
src/cmd/cp.c
View File

@@ -1,9 +1,9 @@
main(argc,argv)
char argv[][];
char **argv;
{
char buf[512];
int fold, fnew, n;
char p1[], p2[], bp[];
char *p1, *p2, *bp;
int mode;
if(argc != 3) {
write(1,"Usage: cp oldfile newfile\n",26);

119
src/cmd/date.s Normal file
View File

@@ -0,0 +1,119 @@
/ get date -- date
/ set date -- date mmddhhmm
.globl ptime
cmp (sp)+,$2
blt prdate
tst (sp)+
mov (sp),r0
setd
seti
jsr r5,tmul; 0
jsr r5,tmul; 10.
movfi fr1,r1 / months in r2
asl r1
jsr r5,tmul; 0
jsr r5,tmul; 10.
movfi fr1,r3 / days in r3
dec r3
add mtab-2(r1),r3
cmp r1,$6 / march or later?
blt 1f
add yr1972,r3 / leap year correction
1:
mpy $24.,r3 / days to hours
jsr r5,tmul; 0
jsr r5,tmul; 10.
movif r3,fr0
addf fr0,fr1 / total hours
jsr r5,tmul; 6.
jsr r5,tmul; 10.
movif $3600.,fr0
mulf fr0,fr1
tstb (r0)
bne error
setl
tst yr1972
beq 1f
movif yrtime,fr0
addf fr0,fr1
1:
movif two,fr0
divf fr0,fr1
movfi fr1,-(sp)
mov (sp)+,r0
mov (sp)+,r1
alsc $1,r0
sys stime
br 1f
prdate:
sys time
1:
alsc $-8,r0
bic $!377,r0
dvd $20250.,r0
add $0.,r0
mov r0,r1
clr r0
dvd $7.,r0
mpy $5.,r1
add $days,r1
mov r1,0f
mov $1,r0
sys write; 0:..; 5
sys time
mov $1,r2
jsr pc,ptime
mov $1,r0
sys write; nl; 1
sys exit
error:
mov $1,r0
sys write; 1f; 2
sys exit
1: <?>
nl: <\n>
tmul:
movif (r5)+,fr2
mulf fr2,fr1
movb (r0)+,r2
beq error
sub $'0,r2
cmp r2,$10.
bhis error
movif r2,fr2
addf fr2,fr1
rts r5
yrtime:
28872.; 4608.
mtab:
0
31.
59.
90.
120.
151.
181.
212.
243.
273.
304.
334.
0
yr1972: 1
two: 0; 2
days: <Sun \0>
<Mon \0>
<Tue \0>
<Wed \0>
<Thur >
<Fri \0>
<Sat \0>
.even

721
src/cmd/db1.s Normal file
View File

@@ -0,0 +1,721 @@
/ db1 -- debugger
fpp = 1
eae = 0
ldfps = 170100^tst
db:
mov sp,r5
mov (r5)+,r4
tst (r5)+
cmp r4,$2
blt 1f
mov (r5),dbfile
mov (r5),odbfil
mov (r5)+,namfil
cmp r4,$2
beq 1f
mov (r5)+,namfil
1:
sys open; dbfile: core; 0
bec 9f
jmp fnfnd
9:
mov r0,dbfin
clr dbfout
sys open; odbfil:core; 1
bes 1f
mov r0,dbfout
1:
sys open; namfil: a.out; 0
bes 1f
mov r0,r1
sys read; nambuf; 20
cmp nambuf,objmagic
bne 1f
mov nambuf+2,r0 / text
add nambuf+4,r0 / data
cmp nambuf+16,$1 / relocation?
beq 6f
asl r0 / sym origin
6:
add $20,r0
mov r0,0f
mov r1,r0
sys seek; 0:..; 0
mov nambuf+10,r0 / symbol size
cmp r0,$maxsym
blos 3f
mov $maxsym,r0
3:
add r0,0f
sys break; 0: nambuf
mov r0,0f
mov r1,r0
sys read; nambuf; 0:..
add $nambuf,r0
mov r0,namsiz
mov r1,r0
sys close
1:
jsr r5,get; zero / test new object
cmp r0,$407 / br .+20
bne 1f
mov $20,getoff
1:
mov sp,savsp
sys intr; errexit
cmp r4,$2 / arg count
beq 9f / not core image
cmp r4,$4 / no-core image flag
beq 9f
mov dbfin,r0
sys fstat; regbuf
mov regbuf+6,r0
sub $512.,r0
mov r0,f.size
mov dbfin,r0
sys seek; -512.; 2
mov dbfin,r0
sys read; regbuf; 512.
mov u.uusp, u.pusp
sub u.core,u.break
.if fpp
mov u.sp,r0
sub u.core,r0
mov 6*eae+512.+regbuf(r0),r0
bic $!200,r0 / floating double mode
mov r0,fpsr
beq loop
mov $fregnames+12,r0 / bias for double mode
mov $4,r1
2:
sub r1,(r0)
add $4,r1
add $14,r0
cmp r0,$ereg
blo 2b
.endif
br loop
9:
mov $-1,u.break / no remapping
loop:
clr error
jsr pc,readlin
jsr pc,readexp
tst error
bne errexit
mov $1,count
cmpb r0,$',
bne 2f
movb (r4)+,r0
mov addres,-(sp)
mov adrflg,-(sp)
jsr pc,readexp
mov addres,count
mov (sp)+,adrflg
mov (sp)+,addres
tst error
bne errexit
2:
movb (r4),r0
jsr pc,command
tst error
beq loop
errexit:
mov savsp,sp
jsr r5,mesg; <?\n\0>; .even
br loop
fnfnd:
jsr r5,mesg; <File not found.\n\0>; .even
ex:
sys exit
readlin:
mov $inbuf,r4
1:
mov ttyfin,r0
sys read; ch; 1
tst r0
beq ex
cmpb ch,$'\n
beq 1f
movb ch,(r4)+
br 1b
1:
clrb (r4)
mov $inbuf,r4
rts pc
switch:
mov (r5)+,r1
2:
cmp r0,(r1)+
bne 1f
tst (sp)+
jmp *(r1)
1:
tst (r1)+
bne 2b
rts r5
readexp:
mov $'+,lastop
clr addres
clr starmod
clr taddr
clr adrflg
nextxp:
movb (r4)+,r0
cmp r0,$'0
blt 1f
cmp r0,$'9
ble numin
cmp r0,$'a
blt 1f
cmp r0,$'z
bgt 1f
jmp letin
1:
cmp r0,$'a-40
blt 1f
cmp r0,$'z-40
ble letin
1:
jsr r5,switch; expsw
tstb -(r4)
tst starmod
beq 1f
mov dot,taddr
br operand
1:
rts pc
expsw:
'+; opex
'-; opex
' ; nextxp
'.; letin
'_; letin
'^; circumf
'*; star
-1; 0
star:
mov pc,starmod
br nextxp
operand:
inc adrflg
tst starmod
beq 1f
clr starmod
bis bytemod,error
jsr r5,get; taddr
tst error
bne 1f
mov r0,taddr
1:
cmp lastop,$'+
beq 1f
sub taddr,addres
br 2f
1:
add taddr,addres
2:
mov $'+,lastop
br nextxp
circumf:
mov dot,taddr
dec taddr
tst bytemod
bne operand
dec taddr
br operand
numin:
clr r1
clr r3
1:
sub $'0,r0
asl r1
asl r1
asl r1
mpy $10.,r3
bis r0,r1
add r0,r3
movb (r4)+,r0
cmp r0,$'0
blo 1f
cmp r0,$'9
blos 1b
1:
cmp r0,$'.
bne 1f
mov r3,r1
inc r4
1:
mov r1,taddr
dec r4
br operand
letin:
dec r4
mov $nambuf,namstrt
letin1:
mov $symbol,r1
clr (r1)+
clr (r1)+
clr (r1)+
clr (r1)
mov $symbol,r1
mov $8.,-(sp)
br 2f
1:
tstb (r4)+
cmpb (r4),$'.
beq 2f
cmpb (r4),$'0
blo 3f
cmpb (r4),$'9
blos 2f
cmpb (r4),$'a-40
blo 3f
cmpb (r4),$'z-40
bhi 4f
bisb $40,(r4)
br 2f
4:
cmpb (r4),$'_
beq 2f
cmpb (r4),$'a
blo 3f
cmpb (r4),$'z
bhi 3f
2:
dec (sp)
ble 1b
movb (r4),(r1)+
br 1b
3:
tst (sp)+
jsr pc,lookupn
tst error
bne 1f
cmpb (r4),$';
beq 2f
1:
jmp operand
2:
tstb (r4)+
mov r1,namstrt
br letin1
opex:
mov r0,lastop
jmp nextxp
command:
jsr r5,switch; comsw
inc error
rts pc
comsw:
'/; slash
'\\; bslash
'?; quest
'\0; newln
'^; circumf
'=; equal
':; colon
'!; excla
''; squote
'"; dquote
'$; dolr
'&; amper
'%; ex
'`; grave
-1; 0
dolr:
mov u.savps,r1
bic $!17,r1
asl r1
mov traptab(r1),r1
jsr pc,string
jsr pc,pnl
mov $doltab,r5
mov $u.pusp+2,r4
1:
mov (r5)+,r1
beq 1f
jsr pc,*(r5)+
br 1b
.if fpp
1:
mov (r5)+,r1
beq 1f
ldfps fpsr
jsr pc,*(r5)+
br 1b
1:
mov (r5)+,r1
jsr pc,*(r5)+
.endif
.if eae
1:
mov (r5)+,r1
beq 1f
jsr pc,*(r5)+
br 1b
.endif
1:
rts pc
traptab:
1f; .data; 1:<?0\0>; .text
1f; .data; 1:<bus\0>; .text
1f; .data; 1:<ill inst\0>; .text
1f; .data; 1:<trace or bpt\0>; .text
1f; .data; 1:<iot\0>; .text
1f; .data; 1:<power fail\0>; .text
1f; .data; 1:<emt\0>; .text
1f; .data; 1:<bad sys call\0>; .text
1f; .data; 1:<programmed interrupt\0>; .text
1f; .data; 1:<FP exception\0>; .text
1f; .data; 1:<memory fault\0>; .text
1f; .data; 1:<quit\0>; .text
1f; .data; 1:<interrupt\0>; .text
1f; .data; 1:<killed\0>; .text
1f; .data; 1:<?16\0>; .text
1f; .data; 1:<?17\0>; .text
doltab:
1f; prgreg; .data; 1:<sp \0>; .text
1f; proct; .data; 1:<ps \0>; .text
1f; prgreg; .data; 1:<pc \0>; .text
1f; prgreg; .data; 1:<r0 \0>; .text
1f; prgreg; .data; 1:<r1 \0>; .text
1f; prgreg; .data; 1:<r2 \0>; .text
1f; prgreg; .data; 1:<r3 \0>; .text
1f; prgreg; .data; 1:<r4 \0>; .text
1f; prgreg; .data; 1:<r5 \0>; .text
0
.if fpp
1f; prfreg; .data; 1:<fr0 \0>; .text
1f; prfreg; .data; 1:<fr1 \0>; .text
1f; prfreg; .data; 1:<fr2 \0>; .text
1f; prfreg; .data; 1:<fr3 \0>; .text
1f; prfreg; .data; 1:<fr4 \0>; .text
1f; prfreg; .data; 1:<fr5 \0>; .text
0
1f; proct; .data; 1:<fpsr \0>; .text
.endif
.if eae
1f; proct; .data; 1:<sc \0>; .text
1f; proct; .data; 1:<ac \0>; .text
1f; proct; .data; 1:<mq \0>; .text
0
.endif
.data
.even
.text
.if fpp
prfreg:
movf -(r4),fr0
cfcc
beq 1f
jsr pc,string
jsr pc,printf
jsr pc,pnl
1:
rts pc
.endif
prgreg:
jsr pc,string
mov -(r4),r0
jsr pc,printo
mov (r4),r0
jsr pc,lookupv
tst r2
beq 1f
jsr r5,mesg; < \0>; .even
mov (r4),r0
jsr pc,pname
1:
jsr pc,pnl
rts pc
proct:
jsr pc,string
mov -(r4),r0
jsr pc,printo
jsr pc,pnl
rts pc
string:
movb (r1)+,r0
beq 1f
jsr pc,putc
br string
1:
rts pc
putc:
mov r0,och
mov $1,r0
sys write; och; 1
rts pc
equal:
jsr r5,coleq; printo
rts pc
amper:
clr bytemod
mov $2,incdot
jsr r5,cycle; asymp
rts pc
asymp:
jsr pc,pname
jsr pc,pnl
rts pc
bslash:
inc bytemod
mov $1,incdot
br 1f
slash:
clr bytemod
mov $2,incdot
1:
jsr r5,cycle; octp
rts pc
grave:
clr bytemod
mov $2,incdot
jsr r5,cycle; decp
rts pc
quest:
clr bytemod
jsr r5,cycle; psym
rts pc
decp:
jsr pc,printd
jsr r5,mesg; <.\n\0>; .even
rts pc
octp:
jsr pc,printo
jsr pc,pnl
rts pc
newln:
tst adrflg
bne 1f
add incdot,dot
1:
mov nlcom,r0
jmp command
excla:
tst adrflg
bne 1f
2:
inc error
rts pc
1:
bit $1,dot
beq 1f
tst bytemod
beq 2b
1:
jsr r5,put; dot; addres
rts pc
squote:
inc bytemod
mov $1,incdot
br 2f
dquote:
clr bytemod
mov $2,incdot
2:
jsr r5,cycle; ascp
rts pc
ascp:
mov r0,-(sp)
jsr pc,ascp1
mov (sp)+,r0
tst bytemod
bne 1f
swab r0
jsr pc,ascp1
1:
cmp count,$1
bgt 1f
jsr pc,pnl
1:
rts pc
ascp1:
bic $!377,r0
cmp r0,$'\n
beq 2f
cmp r0,$011
beq 2f
cmp r0,$40
blo 1f
cmp r0,$177
bhis 1f
2:
jsr pc,putc
rts pc
1:
mov r0,r1
jsr r5,mesg; <\\\0>
clr r0
alsc $10.,r0
add $'0,r0
jsr pc,putc
clr r0
alsc $3,r0
add $'0,r0
jsr pc,putc
clr r0
alsc $3,r0
add $'0,r0
jsr pc,putc
rts pc
colon:
jsr r5,coleq; pname
rts pc
coleq:
jsr pc,setadr
mov addres,r0
jsr pc,*(r5)+
jsr pc,pnl
rts r5
cycle:
mov r0,nlcom
jsr pc,setadr
mov addres,dot
tst bytemod
bne 1f
bic $1,dot
1:
jsr r5,get; dot
tst error
bne 1f
tst bytemod
beq 2f
bic $!377,r0
2:
jsr pc,*(r5)
tst error
bne 1f
dec count
ble 1f
add incdot,dot
br 1b
1:
tst (r5)+
rts r5
setadr:
tst adrflg
bne 1f
mov dot,addres
1:
rts pc
.if fpp
printf:
ldfps $200 / round+double
mov r4,-(sp)
mov r3,-(sp)
movif $10.,r3
movif $1,r2
clr r4
tstf r0
cfcc
beq 2f
bge 1f
negf r0
mov $'-,r0
jsr pc,putc
1:
cmpf r3,r0
cfcc
bgt 1f
inc r4
divf r3,r0
br 1b
1:
cmpf r2,r0
cfcc
ble 2f
dec r4
mulf r3,r0
br 1b
2:
modf r2,r0
movfi r1,r0
add $'0,r0
jsr pc,putc
mov $'.,r0
jsr pc,putc
mov $8.,r3
1:
modf r3,r0
movfi r1,r0
add $'0,r0
jsr pc,putc
dec r3
bgt 1b
mov $'E,r0
jsr pc,putc
mov r4,r0
mov (sp)+,r3
mov (sp)+,r4
br printd
.endif
printd:
mov r1,-(sp)
mov r0,r1
bpl 1f
neg r1
mov $'-,r0
jsr pc,putc
1:
jsr pc,1f
mov (sp)+,r1
rts pc
1:
clr r0
dvd $10.,r0
mov r1,-(sp)
mov r0,r1
beq 1f
jsr pc,1b
1:
mov (sp)+,r0
add $'0,r0
jsr pc,putc
rts pc

367
src/cmd/db2.s Normal file
View File

@@ -0,0 +1,367 @@
/ db2 -- debugger
lookupn:
cmp symbol,$'.
bne 1f
mov dot,taddr
rts pc
1:
tst error
beq 1f
rts pc
1:
mov r2,-(sp)
mov $regnames,r1
mov $ereg,r2
jsr pc,1f
tst error
beq 2f
clr error
mov namstrt,r1
mov namsiz,r2
jsr pc,1f
2:
mov (sp)+,r2
rts pc
1:
mov $symbol,r0
cmp (r0)+,(r1)+
bne 2f
cmp (r0)+,(r1)+
bne 3f
cmp (r0)+,(r1)+
bne 4f
cmp (r0)+,(r1)+
bne 5f
tst (r1)+
mov (r1)+,taddr
rts pc
2:
tst (r1)+
3:
tst (r1)+
4:
tst (r1)+
5:
cmp (r1)+,(r1)+
cmp r1,r2
blo 1b
inc error
clr taddr
rts pc
lookupv:
mov r5,-(sp)
mov $nambuf,r5
clr r2
mov $177777,r3
1:
cmp r5,namsiz
bhis 4f
mov 12(r5),r1
sub r0,r1
neg r1
blt 3f
cmp r1,r3
bhi 3f
cmp r1,$4000
bhis 3f
cmp r2,r5
bhi 3f
mov r1,r3
mov r5,r2
3:
add $14,r5
br 1b
4:
mov (sp)+,r5
rts pc
get:
mov *(r5)+,r0
add getoff,r0
jsr r5,remap
br 3f
mov r0,0f
mov dbfin,r0
sys seek; 0:0; 0
bec 1f
2:
inc error
rts r5
1:
mov dbfin,r0
sys read; temp; 2
bes 2b
tst r0
beq 2b
mov temp,r0
rts r5
3:
clr -(sp)
movb (r0),(sp)
movb 1(r0),1(sp)
mov (sp)+,r0
rts r5
remap:
cmp r0,u.break
blo 1f
cmp r0,u.uusp
blo 2f
cmp r0,$160000
bhis 3f
sub u.uusp,r0
add u.break,r0
br 1f
3:
sub $160000,r0
cmp r0,$512.+2
bhis 2f
add $regbuf,r0
rts r5
1:
tst (r5)+
rts r5
2:
inc error
rts r5
printo:
mov $obuf+6,r1
clr r2
1:
inc r2
movb r0,-(r1)
bicb $!7,(r1)
bisb $'0,(r1)
clc
ror r0
asr r0
asr r0
bne 1b
mov r2,0f+2
mov r1,0f
mov $1,r0
sys write; 0:obuf; 6
rts pc
mesg:
movb (r5)+,r0
beq 1f
jsr pc,putc
br mesg
1:
inc r5
bic $1,r5
rts r5
pnl:
jsr r5,mesg; <\n\0>
rts pc
psp:
jsr r5,mesg; < \0>
rts pc
pstar:
jsr r5,mesg; <*\0>
rts pc
plp:
jsr r5,mesg; <(\0>
rts pc
prp:
jsr r5,mesg; <)\0>
rts pc
pb:
jsr r5,mesg; <b\0>
rts pc
pcom:
jsr r5,mesg; <,\0>
rts pc
put:
mov *(r5)+,r0
add getoff,r0
jsr r5,remap
br 3f
mov r0,0f
mov dbfout,r0
bne 1f
2:
tst (r5)+
3:
inc error
rts r5
1:
tst error
bne 3b
sys seek; 0:0; 0
bes 2b
mov (r5)+,0f
mov dbfout,r0
tst bytemod
beq 1f
mov $1,0f+2
br 2f
1:
mov $2,0f+2
2:
sys write; 0:0; 2
bes 3b
rts r5
decodadr:
mov r0,r3
mov r3,-(sp)
bic $!10,(sp)
bic $!7,r0
cmp r0,$7
beq pcadr
7:
mov r3,r0
asr r0
asr r0
asr r0
bic $!6,r0
jmp *1f(r0)
1:
simp
incr
decr
indx
simp:
tst (sp)
beq 1f
jsr pc,plp
1:
jsr pc,preg
tst (sp)+
beq 9f
jsr pc,prp
br 9f
incr:
tst (sp)+
beq 1f
jsr pc,pstar
1:
jsr pc,plp
jsr pc,preg
jsr r5,mesg; <)+\0>; .even
br 9f
decr:
tst (sp)+
beq 1f
jsr pc,pstar
1:
jsr r5,mesg; <-(\0>; .even
jsr pc,preg
jsr pc,prp
br 9f
indx:
tst (sp)+
beq 1f
jsr pc,pstar
1:
jsr pc,get1
jsr pc,pname
jsr pc,plp
jsr pc,preg
jsr pc,prp
br 5f
pcadr:
mov r3,r0
bit $20,r3
beq 7b
tst (sp)+
beq 1f
jsr pc,pstar
1:
bit $40,r3
bne 6f
jsr r5,mesg; <$\0>
jsr pc,get1
jsr pc,pname
br 5f
6:
jsr pc,get1
add $2,r0
add r1,r0
mov $3,r1
jsr pc,pname
br 5f
9:
tst (r5)+
clr r0
rts r5
5:
mov $2,r0
rts r5
preg:
mov r3,r0
bic $!7,r0
asl r0
mov regtab(r0),obuf
mov $1,r0
sys write; obuf; 2
rts pc
regtab:
"r0
"r1
"r2
"r3
"r4
"r5
"sp
"pc
pname:
mov r5,-(sp)
mov r3,-(sp)
mov r1,-(sp)
jsr pc,lookupv
tst r2
beq 5f
cmp (sp),$1
bne 1f
tst r3
bne 5f
1:
mov r2,r1
mov r0,r5
jsr pc,string
cmp 12(r2),r5
beq 1f
blt 2f
jsr r5,mesg; <-\0>
br 3f
2:
jsr r5,mesg; <+\0>
3:
mov r3,r0
5:
jsr pc,printo
1:
tst (sp)+
mov (sp)+,r3
mov (sp)+,r5
rts pc
get1:
mov *(r5)+,r1
add $2,r1
mov r1,temp
jsr r5,get; temp
rts pc

330
src/cmd/db3.s Normal file
View File

@@ -0,0 +1,330 @@
/ db3 -- debugger
psym:
mov $2,incdot
jsr pc,prints
jsr pc,pnl
rts pc
prints:
mov r0,-(sp)
mov $optab,r1
1:
mov (sp),r0
bic (r1)+,r0
cmp (r1)+,r0
bne 2f
mov (r1)+,-(sp)
jsr pc,string
jmp *(sp)+
2:
add $8.,r1
br 1b
optab:
107777; 010000; double; <mov\0\0\0>
107777; 020000; double; <cmp\0\0\0>
107777; 030000; double; <bit\0\0\0>
107777; 040000; double; <bic\0\0\0>
107777; 050000; double; <bis\0\0\0>
007777; 060000; double; <add\0\0\0>
007777; 160000; double; <su\0\0\0\0>
100077; 005000; single; <clr\0\0\0>
100077; 005100; single; <com\0\0\0>
100077; 005200; single; <inc\0\0\0>
100077; 005300; single; <dec\0\0\0>
100077; 005400; single; <neg\0\0\0>
100077; 005500; single; <adc\0\0\0>
100077; 005600; single; <sbc\0\0\0>
100077; 005700; single; <tst\0\0\0>
100077; 006000; single; <ror\0\0\0>
100077; 006100; single; <rol\0\0\0>
100077; 006200; single; <asr\0\0\0>
100077; 006300; single; <asl\0\0\0>
000077; 000100; single; <jmp\0\0\0>
000077; 000300; single; <swab\0\0>
000077; 170100; singlw; <ldfps\0>
000077; 170200; singlw; <stfps\0>
000077; 170300; singlw; <stst\0\0>
000077; 170400; singlw; <clrf\0\0>
000077; 170500; singlw; <tstf\0\0>
000077; 170600; singlw; <absf\0\0>
000077; 170700; singlw; <negf\0\0>
000077; 006700; singlw; <sxt\0\0\0>
000077; 006600; singlw; <mtpi\0\0>
000077; 106600; singlw; <mtpd\0\0>
000077; 006500; singlw; <mfpi\0\0>
000077; 106500; singlw; <mfpd\0\0>
000777; 070000; muldiv; <mul\0\0\0>
000777; 071000; muldiv; <div\0\0\0>
000777; 072000; muldiv; <ash\0\0\0>
000777; 073000; muldiv; <ashc\0\0>
000377; 000400; branch; <br\0\0\0\0>
000377; 001000; branch; <bne\0\0\0>
000377; 001400; branch; <beq\0\0\0>
000377; 002000; branch; <bge\0\0\0>
000377; 002400; branch; <blt\0\0\0>
000377; 003000; branch; <bgt\0\0\0>
000377; 003400; branch; <ble\0\0\0>
000377; 100000; branch; <bpl\0\0\0>
000377; 100400; branch; <bmi\0\0\0>
000377; 101000; branch; <bhi\0\0\0>
000377; 101400; branch; <blos\0\0>
000377; 102000; branch; <bvc\0\0\0>
000377; 102400; branch; <bvs\0\0\0>
000377; 103000; branch; <bhis\0\0>
000377; 103400; branch; <blo\0\0\0>
000000; 000000; noaddr; <halt\0\0>
000000; 000001; noaddr; <wait\0\0>
000000; 000002; noaddr; <rti\0\0\0>
000000; 000004; noaddr; <iot\0\0\0>
000000; 000005; noaddr; <reset\0>
000377; 171000; fltrev; <mulf\0\0>
000377; 171400; fltrev; <modf\0\0>
000377; 172000; fltrev; <addf\0\0>
000377; 172400; fltrev; <movf\0\0>
000377; 173000; fltrev; <subf\0\0>
000377; 173400; fltrev; <cmpf\0\0>
000377; 174000; fltnor; <movf\0\0>
000377; 174400; fltrev; <divf\0\0>
000377; 175000; fltnor; <movei\0>
000377; 175400; fltnor; <movfi\0>
000377; 176000; fltnor; <movfo\0>
000377; 176400; fltrev; <movie\0>
000377; 177000; fltrev; <movif\0>
000377; 177400; fltrev; <movof\0>
000000; 170000; noaddr; <cfcc\0\0>
000000; 170001; noaddr; <setf\0\0>
000000; 170002; noaddr; <seti\0\0>
000000; 170011; noaddr; <setd\0\0>
000000; 170012; noaddr; <setl\0\0>
000777; 004000; specl1; <jsr\0\0\0>
000777; 074000; specl1; <xor\0\0\0>
000007; 000200; specl2; <rts\0\0\0>
000017; 000240; specl3; <cflg\0\0>
000017; 000260; specl3; <sflg\0\0>
000377; 104000; specl4; <emt\0\0\0>
000377; 104400; specl5; <sys\0\0\0>
000077; 006400; specl7; <mark\0\0>
000777; 077000; specl8; <sob\0\0\0>
000007; 000230; specl9; <spl\0\0\0>
177777; 000000; specl6; <oct\0\0\0>
fltrev:
bic $!377,(sp)
muldiv:
jsr pc,psp
mov (sp)+,r0
asl r0
asl r0
swab r0
aslb r0
aslb r0
aslb r0
aslb r0
asr r0
asr r0
asr r0
asr r0
bic $!7707,r0
mov r0,-(sp)
br fltnor1
fltnor:
bic $!377,(sp)
br 1f
double:
tst (sp)
bge 1f
jsr pc,pb
1:
jsr pc,psp
mov (sp),r0
fltnor1:
als $-6,r0
jsr r5,decodadr; dot
add r0,incdot
add dot,r0
mov r0,temp
jsr pc,pcom
mov (sp)+,r0
jsr r5,decodadr; temp
add r0,incdot
rts pc
single:
tst (sp)
bge singlw
jsr pc,pb
singlw:
jsr pc,psp
mov (sp)+,r0
jsr r5,decodadr; dot
add r0,incdot
rts pc
specl8: / sob
jsr pc,psp
mov (sp),r3
als $-6,r3
jsr pc,preg
jsr pc,pcom
mov (sp)+,r0
bic $!77,r0
neg r0
br 1f
branch:
jsr pc,psp
mov (sp)+,r0
bic $!377,r0
bit $200,r0
beq 1f
bis $177400,r0
1:
inc r0
asl r0
add dot,r0
jsr pc,pname
rts pc
noaddr:
tst (sp)+
rts pc
specl1: / jsr
jsr pc,psp
mov (sp),r3
als $-6,r3
jsr pc,preg
jsr pc,pcom
mov (sp)+,r0
jsr r5,decodadr; dot
add r0,incdot
rts pc
specl2: / rts
jsr pc,psp
mov (sp)+,r3
jsr pc,preg
rts pc
specl3: / opr
jsr pc,psp
mov (sp)+,r2
mov $3f,r1
1:
bit $17,r2
beq 1f
bit $10,r2
beq 2f
movb (r1),r0
jsr pc,putc
2:
inc r1
asl r2
br 1b
1:
rts pc
3:
<nzvc>
specl7: / mark
bic $!77,(sp)
br specl4
specl9: / spl
bic $!7,(sp)
br specl4
specl4: / emt
jsr pc,psp
mov (sp)+,r0
bic $!377,r0
8:
jsr pc,printo
rts pc
specl5: / sys
jsr pc,psp
mov (sp)+,r2
bic $!377,r2
mov r2,r0
asl r2
asl r2
cmp r2,$esystab-systab
bhis 8b
mov systab(r2),r1
jsr pc,string
mov systab+2(r2),-(sp)
mov dot,temp1
1:
dec (sp)
bge 2f
tst (sp)+
rts pc
2:
jsr r5,mesg; <;\0>
add $2,temp1
add $2,incdot
jsr r5,get; temp1
jsr pc,pname
br 1b
systab:
1f; 0; .data; 1:<rele\0>; .text
1f; 0; .data; 1:<exit\0>; .text
1f; 0; .data; 1:<fork\0>; .text
1f; 2; .data; 1:<read\0>; .text
1f; 2; .data; 1:<write\0>; .text
1f; 2; .data; 1:<open\0>; .text
1f; 0; .data; 1:<close\0>; .text
1f; 0; .data; 1:<wait\0>; .text
1f; 2; .data; 1:<creat\0>; .text
1f; 2; .data; 1:<link\0>; .text
1f; 1; .data; 1:<unlink\0>; .text
1f; 2; .data; 1:<exec\0>; .text
1f; 1; .data; 1:<chdir\0>; .text
1f; 0; .data; 1:<time\0>; .text
1f; 1; .data; 1:<makdir\0>; .text
1f; 2; .data; 1:<chmod\0>; .text
1f; 2; .data; 1:<chown\0>; .text
1f; 1; .data; 1:<break\0>; .text
1f; 2; .data; 1:<stat\0>; .text
1f; 2; .data; 1:<seek\0>; .text
1f; 2; .data; 1:<tell\0>; .text
1f; 2; .data; 1:<mount\0>; .text
1f; 1; .data; 1:<umount\0>; .text
1f; 0; .data; 1:<setuid\0>; .text
1f; 0; .data; 1:<getuid\0>; .text
1f; 0; .data; 1:<stime\0>; .text
1f; 1; .data; 1:<quit\0>; .text
1f; 1; .data; 1:<intr\0>; .text
1f; 1; .data; 1:<fstat\0>; .text
1f; 1; .data; 1:<emt\0>; .text
1f; 1; .data; 1:<smdate\0>; .text
1f; 1; .data; 1:<stty\0>; .text
1f; 1; .data; 1:<gtty\0>; .text
1f; 1; .data; 1:<ilgins\0>; .text
1f; 0; .data; 1:<hog\0>; .text
1f; 0; .data; 1:<sleep\0>; .text
1f; 0; .data; 1:<sync\0>; .text
1f; 0; .data; 1:<kill\0>; .text
1f; 0; .data; 1:<switches\0>; .text
1f; 0; .data; 1:<boot\0>; .text
esystab:
.data
.even
.text
specl6: / unknown
jsr pc,psp
mov (sp)+,r0
jsr pc,printo
rts pc

77
src/cmd/db4.s Normal file
View File

@@ -0,0 +1,77 @@
/ db4 -- debugger
maxsym = 24000.
core:
<core\0>
a.out:
<a.out\0>
.even
zero: 0
.bss
regbuf:
u.sp: .=.+2
u.usp: .=.+2
u.uusp: .=.+2
u.break:.=.+2
u.r0: .=.+2
u.savps:.=.+2
u.core: .=.+2
.=regbuf+512.
u.pusp: .=.+2
.data
objmagic: br .+20
namsiz: nambuf
incdot: 2
nlcom: '/
regnames:
<sp\0\0\0\0\0\0>; 1; 161000
<ps\0\0\0\0\0\0>; 1; 160776
<pc\0\0\0\0\0\0>; 1; 160774
<r0\0\0\0\0\0\0>; 1; 160772
<r1\0\0\0\0\0\0>; 1; 160770
<r2\0\0\0\0\0\0>; 1; 160766
<r3\0\0\0\0\0\0>; 1; 160764
<r4\0\0\0\0\0\0>; 1; 160762
<r5\0\0\0\0\0\0>; 1; 160760
.if fpp
fregnames:
<fr0\0\0\0\0\0>; 1; 160754
<fr1\0\0\0\0\0>; 1; 160750
<fr2\0\0\0\0\0>; 1; 160744
<fr3\0\0\0\0\0>; 1; 160740
<fr4\0\0\0\0\0>; 1; 160734
<fr5\0\0\0\0\0>; 1; 160730
.endif
ereg:
.bss
starmod:.=.+2
symbol: .=.+10.
getoff: .=.+2
namstrt: .=.+2
bytemod: .=.+2
savsp: .=.+2
error: .=.+2
ttyfin: .=.+2
dbfin: .=.+2
dbfout: .=.+2
ch: .=.+2
lastop: .=.+2
addres: .=.+2
taddr: .=.+2
adrflg: .=.+2
f.size: .=.+2
fpsr: .=.+2
och: .=.+2
dot: .=.+2
count: .=.+2
syscnt: .=.+2
temp: .=.+2
temp1: .=.+2
obuf: .=.+8.
ecore = db+8192.
inbuf: .=.+128.
nambuf: .=.+20

329
src/cmd/dc2.s Normal file
View File

@@ -0,0 +1,329 @@
/
/
/ routine to add the two centennial numbers
/ pointed to by r2 and r3.
/ a pointer to the result is returned in r1
/ r2 and r3 are preserved
/
/ mov ptr1,r2
/ mov ptr2,r3
/ jsr pc,add3
/ mov r1,...
/
add3: mov r0,-(sp)
mov r4,-(sp)
mov r5,-(sp)
mov r3,-(sp)
mov r2,-(sp)
/
/ allocate a new string whose length is
/ the max of the two addends.
/
mov w(r2),r0
sub a(r2),r0
mov w(r3),r4
sub a(r3),r4
cmp r0,r4
bgt 1f
mov r4,r0
1: mov r0,r4
jsr pc,allocate
mov r1,-(sp)
/
/ get everything ready
/
mov 2(sp),r1
jsr pc,rewind
mov 4(sp),r1
jsr pc,rewind
clr carry
/
/ now add them
/
2: dec r4
blt 3f
mov 2(sp),r1 /r2
jsr pc,getchar
mov r0,r5
mov 4(sp),r1 /r3
jsr pc,getchar
add r5,r0
add carry,r0
clr carry
cmp r0,$100.
blt 1f
sub $100.,r0
mov $1,carry
1:
tstb r0
bpl 1f
add $100.,r0
mov $-1,carry
1: mov (sp),r1 /r1
jsr pc,putchar
br 2b
/
/ perhaps there is an extra digit
/
3: mov carry,r0
beq 2f
mov (sp),r1 /r1
jsr pc,putchar
/
/ strip leading zeros
/
2:
jsr pc,fsfile
2: jsr pc,backspace
bes 2f
beq 2b
inc r(r1)
2: mov r(r1),w(r1)
/
/ strip leading 99's
/
jsr pc,fsfile
jsr pc,backspace
cmpb r0,$-1
bne 1f
2:
jsr pc,backspace
bes 2f
cmpb r0,$99.
beq 2b
jsr pc,getchar
2:
mov $-1,r0
jsr pc,alterchar
mov r(r1),w(r1)
/
/ restore and return
/
1:
mov (sp)+,r1
mov (sp)+,r2
mov (sp)+,r3
mov (sp)+,r5
mov (sp)+,r4
mov (sp)+,r0
rts pc
/
carry: .=.+2
/
/
/ routine to change the sign of the centennial number
/ pointed to by r1.
/ negative numbers are stored in 100's complement form with
/ -1 as the high order digit; the second digit is not 99.
/
/ mov ...,r1
/ jsr pc,chsign
/
chsign:
mov r1,-(sp)
mov r0,-(sp)
jsr pc,rewind
clr chcarry
/
1:
jsr pc,lookchar
bes 1f
negb r0
sub chcarry,r0
mov $1,chcarry
add $100.,r0
cmpb $100.,r0
bgt 2f
sub $100.,r0
clr chcarry
2:
jsr pc,alterchar
br 1b
/
1:
clr r0
sub chcarry,r0
beq 2f
jsr pc,putchar
jsr pc,fsfile
jsr pc,backspace
jsr pc,backspace
cmp r0,$99.
bne 1f
mov r(r1),w(r1)
mov $-1,r0
jsr pc,putchar
br 1f
/
2:
jsr pc,fsfile
jsr pc,backspace
bne 1f
mov r(r1),w(r1)
/
1:
mov (sp)+,r0
mov (sp)+,r1
rts pc
/
chcarry: .=.+2
/
/
/
/
/ routine to multiply the two centennial numbers
/ pointed to by r2 and r3.
/ a pointer to the result is returned in r1
/ r2 and r3 are preserved
/
/ mov ptr1,r2
/ mov ptr2,r3
/ jsr pc,mul3
/ mov r1,...
/
/ save registers and make space for temps
/
mul3:
mov r5,-(sp)
mov r3,-(sp) /arg2
mov r2,-(sp) /arg1
mov r0,-(sp)
tst -(sp) /result
tst -(sp) /arg1
tst -(sp) /arg2
tst -(sp) /carry
/
/ compute sign of result and make args positive
/
clr outsign
mov r2,r1
jsr pc,fsfile
jsr pc,backspace
bmi 2f
mov r2,4(sp) /arg1
br 1f
2:
jsr pc,length
jsr pc,allocate
mov r1,4(sp)
mov r2,r0
jsr pc,move
jsr pc,chsign
com outsign
1:
mov r3,r1
jsr pc,fsfile
jsr pc,backspace
bmi 2f
mov r3,2(sp) /arg2
br 1f
2:
mov r3,r1
jsr pc,length
jsr pc,allocate
mov r1,2(sp)
mov r3,r0
jsr pc,move
jsr pc,chsign
com outsign
1:
/
/ compute the length of the result and
/ allocate space for it
/
mov w(r2),r0
sub a(r2),r0
add w(r3),r0
sub a(r3),r0
jsr pc,allocate
jsr pc,zero
mov r1,6(sp) /result
clr offset
mov 2(sp),r1 /arg2
jsr pc,rewind
/
/ work on next digit of arg2, starting over on arg1
/
1: mov 4(sp),r1 /arg1
jsr pc,rewind
mov 2(sp),r1 /arg2
jsr pc,getchar
bes 3f
mov r0,r2
mov 6(sp),r1 /result
jsr pc,rewind
add offset,r(r1)
clr 0(sp) /carry
/
/ work on next digit of arg3
/ form the product of the two digits,
/ add to what is already there and add in old carry
/ to generate new dit and new carry.
/
2: mov 4(sp),r1 /arg1
jsr pc,getchar
bes 2f
mov r0,r3
mpy r2,r3
add (sp),r3 /carry
mov 6(sp),r1 /result
jsr pc,lookchar
add r0,r3
mov r3,r1
clr r0
dvd $100.,r0
mov r0,(sp) /carry
mov r1,r0
mov 6(sp),r1 /result
jsr pc,alterchar
br 2b
/
2:
inc offset
tst (sp) /carry
beq 1b
mov 6(sp),r1 /result
jsr pc,lookchar
add (sp),r0 /carry
jsr pc,alterchar
br 1b
/
3:
/
/ change sign of result if necessary
/
tst outsign
bpl 1f
mov 6(sp),r1 /result
jsr pc,chsign
/
/ release dregs if necessary
/
1:
cmp 2(sp),14(sp)
beq 1f
mov 2(sp),r1
jsr pc,release
1:
cmp 4(sp),12(sp)
beq 1f
mov 4(sp),r1
jsr pc,release
1:
/
/ restore registers and return
/
tst (sp)+
tst (sp)+
tst (sp)+
mov (sp)+,r1
mov (sp)+,r0
mov (sp)+,r2
mov (sp)+,r3
mov (sp)+,r5
rts pc
/
outsign: .=.+2
offset: .=.+2
k: .=.+2
kptr: .=.+2

451
src/cmd/dc3.s Normal file
View File

@@ -0,0 +1,451 @@
/
/
/ routine to divide the two centennial numbers pointed
/ to by r2 (the divisor) and r3 (the dividend).
/ A pointer to the result is returned in r1. All other
/ registers are preserved. If the divisor is zero, zero
/ is returned and the carry bit is set.
/ Remainder is returned in r4 and has the sign
/ of the dividend.
/
/
/ mov divisor,r2
/ mov dividend,r3
/ jsr pc,div3
/ mov r1,result
/ mov r4,remainder
/
/
div3:
mov r5,-(sp)
mov r3,-(sp) /dividend
mov r2,-(sp) /divisor
mov r0,-(sp)
tst -(sp) /result
/
/ allocate space for result; allocate temps if necessary
/
clr r0
jsr pc,allocate
mov r1,0(sp) /result
/
/
/ check for divisor zero
/
mov 4(sp),r2 /divisor
mov w(r2),r0
sub a(r2),r0
bne 1f
jmp eh
1:
/
/ compute sign of result and make arguments positive
/
clr divsign
mov r2,r1
jsr pc,length
jsr pc,allocate
mov r1,divisor
mov r2,r0
jsr pc,move
jsr pc,fsfile
jsr pc,backspace
bpl 1f
2:
jsr pc,chsign
mov r1,divisor
com divsign
1:
clr remsign
mov r3,r1
jsr pc,length
jsr pc,allocate
mov r1,dividend
mov r3,r0
jsr pc,move
jsr pc,fsfile
jsr pc,backspace
bpl 1f
2:
jsr pc,chsign
mov r1,dividend
com divsign
com remsign
1:
/
/
/ find out how many digits in the quotient result
/
1:
mov dividend,r2
mov divisor,r3
mov w(r2),r0
sub a(r2),r0
add a(r3),r0
sub w(r3),r0
bhis 9f; jmp bugout; 9:
mov r0,divoffset
mov 0(sp),r1 /result
inc r0
jsr pc,seekchar
clr r0
mov dividend,r1
jsr pc,putchar
/
/ load r5 with binary divisor for finding
/ trial quotient digits. If leading digit of
/ divisor is <10, it is scaled
/
clr magic
mov divisor,r1
jsr pc,fsfile
jsr pc,backspace
mov r0,r5
cmp r5,$10.
bge 2f
inc magic
2:
mpy $100.,r5
jsr pc,backspace
add r0,r5
tst magic
beq 2f
mov r5,r4
mpy $100.,r4
jsr pc,backspace
add r0,r5
adc r4
asl r5
rol r4
dvd $25.,r4
mov r4,r5
2:
/
/ compute trial quotient digit
/
1:
mov dividend,r1
jsr pc,fsfile
jsr pc,backspace
bec 9f; 4; 9:
mov r0,r3
mpy $100.,r3
mov r3,r2
jsr pc,backspace
add r0,r2
mpy $100.,r2
jsr pc,backspace
add r0,r3
adc r2
/
mov r5,r0
tst magic
beq 3f
ashc $3,r2
3:
tst divoffset
beq 2f
inc r0
2:
dvd r0,r2
mov r2,trial
/
/
/ multiply divisor by trial digit
/
mov divisor,r1
jsr pc,rewind
jsr pc,length
inc r0
mov divxyz,r1
jsr pc,rewind
clr -(sp)
2:
mov divisor,r1
jsr pc,getchar
bes 2f
mov r0,r3
mpy trial,r3
add (sp),r3 /carry
clr r2
dvd $100.,r2
mov r2,(sp) /carry
mov r3,r0
mov divxyz,r1
jsr pc,alterchar
br 2b
2:
mov divxyz,r1
mov (sp)+,r0
jsr pc,alterchar
3:
/
/ and subtract from dividend
/
jsr pc,rewind
mov divoffset,r0
mov dividend,r1
jsr pc,seekchar
clr -(sp)
/
2: mov dividend,r1
jsr pc,lookchar
bes 2f
mov r0,r2
/
mov divxyz,r1
jsr pc,getchar
sub r0,r2
sub (sp),r2
clr (sp)
mov r2,r0
bpl 3f
add $100.,r0
mov $1.,(sp)
3: mov dividend,r1
jsr pc,alterchar
br 2b
/
/ put away the quotient digit
/
2:
mov (sp)+,divcarry
mov 0(sp),r1 /result
jsr pc,backspace
mov trial,r0
jsr pc,alterchar
jsr pc,backspace
/
/ and go for another digit
/
dec divoffset
bmi 1f
mov dividend,r1
dec w(r1)
cmp w(r1),a(r1)
bge 9f; 4; 9:
jmp 1b
/
/ fix up the result
/
1:
tst divcarry
beq 1f
mov trial,r0
dec r0
jsr pc,alterchar
mov dividend,r1
mov $-1,r0
jsr pc,alterchar
mov divisor,r2
mov dividend,r3
jsr pc,add3
mov r1,-(sp)
mov r3,r1
jsr pc,release
mov (sp)+,dividend
1:
mov 0(sp),r1 /result
jsr pc,rewind
clr divcarry
1:
jsr pc,lookchar
bes 1f
bic $!377,r0
add divcarry,r0
clr divcarry
cmp r0,$100.
blt 2f
sub $100.,r0
inc divcarry
2: jsr pc,alterchar
br 1b
/
1:
tst divcarry
beq 1f
mov $1.,r0
jsr pc,alterchar
1:
jsr pc,fsfile
1:
jsr pc,backspace
bes 1f
bne 1f
mov r(r1),w(r1)
br 1b
1:
/
/ change sign of result if necessary
/
tst divsign
bpl 1f
jsr pc,chsign
1:
mov dividend,r1
jsr pc,fsfile
1:
jsr pc,backspace
bes 1f
bne 1f
mov r(r1),w(r1)
br 1b
1:
bugout:
tst remsign
bpl 1f
mov dividend,r1
jsr pc,chsign
/
/ clean up junk, restore registers, and return
/
1:
mov divisor,r1
jsr pc,release
mov (sp)+,r1
mov (sp)+,r0
mov (sp)+,r2
mov (sp)+,r3
mov dividend,r4
mov (sp)+,r5
clc
rts pc
/
/
/
/
divisor: .=.+2
dividend: .=.+2
divxyz: .=.+2
divoffset:.=.+2
divcarry: .=.+2
divsign: .=.+2
trial: .=.+2
remsign: .=.+2
magic: .=.+2
/
/
/
/ routine to exponentiate the two centennial numbers
/ pointed to by r2 (the base) and r3 (the exponent).
/ A pointer to the result is returned in r1.
/
/ mov base,r2
/ mov exp,r3
/ jsr pc,exp3
/ mov r1,...
/
/
/ save registers
/
exp3:
mov r3,-(sp) /exponent
mov r2,-(sp) /base
mov r0,-(sp)
/
/
1:
mov $1,r0
jsr pc,allocate
mov r1,-(sp) /accumulated result
mov $1,r0
jsr pc,putchar
/
mov r2,r1
jsr pc,length
jsr pc,allocate
mov r1,-(sp) /powers of the base
mov r2,r0
jsr pc,move
/
mov r3,r1
jsr pc,length
jsr pc,allocate
mov r1,-(sp) /exponent
mov r3,r0
jsr pc,move
jsr pc,fsfile
clr exptemp
jsr pc,backspace
bpl 1f
inc exptemp
jsr pc,chsign
/
1:
mov 0(sp),r1
jsr pc,length
beq 1f
mov sqtemp,r2
mov 0(sp),r3
jsr pc,div3
mov r1,0(sp)
mov r3,r1
jsr pc,release
mov r4,r1
jsr pc,length
jsr pc,release
tst r0
beq 2f
/
/
/
mov 2(sp),r2
mov 4(sp),r3
jsr pc,mul3
mov r1,4(sp)
mov r3,r1
jsr pc,release
2:
mov 2(sp),r3
mov r3,r1
jsr pc,length
jsr pc,allocate
mov r1,r2
mov r3,r0
jsr pc,move
jsr pc,mul3
mov r1,2(sp)
mov r3,r1
jsr pc,release
mov r2,r1
jsr pc,release
br 1b
1:
tst exptemp
beq 1f
mov 10(sp),r1
jsr pc,length
bne 2f
jmp eh
2:
cmp r0,$1
blos 2f
mov 4(sp),r1
jsr pc,create
br 1f
2:
jsr pc,rewind
jsr pc,getchar
cmp r0,$1
bgt 2f
mov 4(sp),r1
jsr pc,create
jsr pc,putchar
br 1f
2:
mov 4(sp),r1
jsr pc,create
1:
mov (sp)+,r1
jsr pc,release
mov (sp)+,r1
jsr pc,release
mov (sp)+,r1
/
mov (sp)+,r0
mov (sp)+,r2
mov (sp)+,r3
rts pc
/
exptemp: .=.+2
/

407
src/cmd/dc4.s Normal file
View File

@@ -0,0 +1,407 @@
.globl getchar
.globl stats
.globl lookchar
.globl fsfile
.globl seekchar
.globl backspace
.globl putchar
.globl alterchar
.globl move
.globl rewind
.globl create
.globl zero
.globl allocate
.globl release
.globl collect
.globl getword, putword
.globl length, position
.globl w, r, a, l
.globl error
/
testing = 0
/
/
/ routine to return the length of a string
/
/ mov ...,r1
/ jsr pc,length
/ mov r0,...
/
length:
mov w(r1),r0
sub a(r1),r0
rts pc
/
/
/ routine to return the read pointer position
/
/ mov ...,r1
/ jsr pc,position
/ mov r0,...
/
position:
mov r(r1),r0
sub a(r1),r0
rts pc
/
/
/
/
/ routine to get a word from the string
/ mov ...,r1
/ jsr pc,getword
/ mov r0,...
/
getword:
jsr pc,getchar
bes noch
movb r0,nchar
jsr pc,getchar
bec 2f
dec r(r1)
br noch
2: movb r0,nchar+1
mov nchar,r0
tst r0 /tst clears c-bit
rts pc
/
/
/ routine to put a word onto the string
/ mov ...,r1
/ mov ...,r0
/ jsr pc,putword
/
putword:
jsr pc,putchar
swab r0
jsr pc,putchar
swab r0
rts pc
/
nchar: .=.+2
/
/
/
/ routine to read next character from string
/ pointed to by r1; character returned in r0
/ c-bit set if character not available (end of file)
/ r1 is preserved
/
/ mov ...,r1
/ jsr pc,getchar
/ movb r0,...
/
getchar:
jsr pc,lookchar
bec 2f
rts pc
2: inc r(r1)
tst r0 /tst clears c-bit
rts pc
/
noch: clr r0
sec
rts pc
/
/ routine to look at next character from string
/ pointed to by r1; character returned in r0
/ c-bit set if character not available (end of file)
/ r1 is preserved
/
/ mov ...,r1
/ jsr pc,lookchar
/ movb r0,...
/
lookchar:
.if testing
jsr pc,plausible
inc stats+6.
.endif
cmp w(r1),r(r1)
blos noch
movb *r(r1),r0
clc
rts pc
/
plausible:
cmp r1,$headers
bhis 9f; 4; 9:
cmp r1,$headend
blo 9f; 4; 9:
rts pc
/
/
/
/ routine to move the read pointer of a string to a
/ specified point. If the string is not long enough,
/ the string is extended
/
/ mov position,r0
/ mov ...,r1
/ jsr pc,seekchar
/
seekchar:
mov r1,-(sp)
mov r0,-(sp)
.if testing
jsr pc,plausible
inc stats+10.
.endif
1:
mov (sp),r0
add a(r1),r0
cmp r0,l(r1)
bhi 3f
mov r0,r(r1)
cmp r0,w(r1)
blo 1f
mov r0,w(r1)
br 1f
3:
mov (sp),r0
jsr pc,allocate
mov 2(sp),r0
jsr pc,move
jsr pc,swap
jsr pc,release
mov 2(sp),r1
br 1b
1:
mov (sp)+,r0
mov (sp)+,r1
rts pc
/
/
/ routine to move read pointer of string to end of string
/
/ mov ...,r1
/ jsr pc,fsfile
/
fsfile:
.if testing
jsr pc,plausible
inc stats+10.
.endif
mov w(r1),r(r1)
rts pc
/
/
/ routine to read a string backwards
/ the read pointer is decremented before reading
/
/ mov ...,r1
/ jsr pc,backspace
/ mov r0,...
/
backspace:
.if testing
jsr pc,plausible
inc stats+6.
.endif
cmp a(r1),r(r1)
bhis noch
dec r(r1)
movb *r(r1),r0
clc
rts pc
/
/
/
/
/ routine to put a character into the string
/ pointed to by r1; character in r0
/ r0 and r1 are preserved.
/
/ movb ch,r0
/ mov ...,r1
/ jsr pc,putchar
/
putchar:
mov r1,-(sp)
mov r0,-(sp)
.if testing
jsr pc,plausible
inc stats+8.
.endif
1: cmp w(r1),l(r1)
blt 3f
mov w(r1),r0
inc r0
sub a(r1),r0 /W-A+1
jsr pc,allocate
mov 2(sp),r0 /r1
jsr pc,move
jsr pc,swap
jsr pc,release
mov 2(sp),r1 /r1
cmp w(r1),l(r1)
blt 3f
4
/
3: movb (sp),*w(r1)
inc w(r1)
mov (sp)+,r0
tst (sp)+
rts pc
/
/
swap:
mov w(r1),-(sp)
mov w(r0),w(r1)
mov (sp),w(r0)
mov r(r1),(sp)
mov r(r0),r(r1)
mov (sp),r(r0)
mov a(r1),(sp)
mov a(r0),a(r1)
mov (sp),a(r0)
mov l(r1),(sp)
mov l(r0),l(r1)
mov (sp)+,l(r0)
rts pc
/
/
/ routine to alter a character in the string
/ pointed to by r1; character in r0
/ r0 and r1 are preserved.
/
/ movb ch,r0
/ mov ...,r1
/ jsr pc,alterchar
/
alterchar:
mov r1,-(sp)
mov r0,-(sp)
.if testing
jsr pc,preposterous
inc stats+8.
.endif
1: cmp r(r1),l(r1)
blt 3f
mov l(r1),r0
inc r0
sub a(r1),r0 /W-A+1
jsr pc,allocate
mov 2(sp),r0 /r1
jsr pc,move
jsr pc,swap
jsr pc,release
mov 2(sp),r1 /r1
cmp r(r1),l(r1)
blt 3f
4
/
3: movb (sp),*r(r1)
inc r(r1)
cmp r(r1),w(r1)
ble 1f
mov r(r1),w(r1)
1:
mov (sp)+,r0
tst (sp)+
rts pc
/
/
/ routine to move the contents of one string
/ to another.
/
/ mov source,r0
/ mov dest,r1
/ jsr pc,move
/
/ on return, r1 points to the new string and should
/ be saved. r0 is preserved.
/
move:
mov r3,-(sp)
mov r2,-(sp)
mov r1,-(sp)
mov r0,-(sp)
mov w(r0),r2
sub a(r0),r2 /W-A
mov l(r1),r3
sub a(r1),r3 /L-A
cmp r2,r3
ble 1f
mov r2,r0
jsr pc,allocate
mov 2(sp),r0 /r1
jsr pc,swap
jsr pc,release
mov r0,r1
mov 0(sp),r0 /r0
/
1: mov a(r0),(r0)
mov a(r1),(r1)
1: dec r2
blt 1f
movb *(r0),*(r1)
inc (r0)
inc (r1)
br 1b
/
/ fix up read ptr of new string
/
1: mov r(r0),r2
sub a(r0),r2
add a(r1),r2
mov r2,r(r1)
/
/ restore and return
/
mov (sp)+,r0
mov (sp)+,r1
mov (sp)+,r2
mov (sp)+,r3
rts pc
/
/
/ routine to rewind read pointer of string
/ pointed to by r1
/
/ mov ...,r1
/ jsr pc,rewind
/
rewind:
.if testing
jsr pc,plausible
inc stats+10.
.endif
mov a(r1),r(r1)
rts pc
/
/ routine to rewind write pointer of string
/ pointed to by r1
/
/ mov ...,r1
/ jsr pc,create
/
create:
.if testing
jsr pc,plausible
inc stats+10.
.endif
mov a(r1),w(r1)
mov a(r1),r(r1)
rts pc
/
/
/ routine to zero a string
/
/ mov ...,r1
/ jsr pc,zero
/
zero:
mov r0,-(sp)
.if testing
jsr pc,preposterous
.endif
mov a(r1),r0
1: cmp r0,l(r1)
bhis 1f
clrb (r0)+
br 1b
1: mov (sp)+,r0
rts pc
/
/

372
src/cmd/dc5.s Normal file
View File

@@ -0,0 +1,372 @@
/
/
/ here to allocate a new block
/
/ mov ...,r0
/ jsr pc,allocate
/ mov r1,...
/
/ requested size in bytes in r0
/ pointer to header of allocated block returned in r1
/ r0 is preserved
/
/ convert to words, adjust for header, round up
/ to a power of two
/
/ each block has a four-word header
/ W - write ptr (also used as link ptr in frlist)
/ R - read ptr
/ A - pointer to head of data
/ L - ptr to (end+1) of data
W=0
R=2
A=4
L=6
/
allocate:
clr garbage
mov r0,-(sp)
mov r2,-(sp)
tst stats
bne 1f
jsr pc,init
1:
inc stats
bne 9f; inc stats; 9:
cmp r0,$strend-strbuf
blo 9f; 4; 9:
1:
sub $1,r0
bmi 1f
jsr pc,log2
add $1,r0
1: asl r0 /bite to word
mov r0,-(sp)
add $2,r0
cmp r0,$frend-frlist+2
blo zzz
4
/
/ look on free list for block of required size
/
zzz:
mov (sp),r0
tst frlist(r0)
beq xxx
/
/ found it, allocate and return
/
mov frlist(r0),r1
mov (r1),frlist(r0)
mov a(r1),r0
mov r0,w(r1) /W
mov r0,r(r1) /R
tst (sp)+
mov (sp)+,r2
mov (sp)+,r0
rts pc
/
/ no block of required size
/ look for larger block
/
xxx:
tst frlist-2
beq www
tst (r0)+
cmp r0,$frend-frlist
bhis www
tst frlist(r0)
bne yyy
br xxx
/
/ there are no larger blocks; must garbage collect
/
www: jsr pc,collect
tst r0
bne zzz
/
/ out of space
/
mov $1,r0
sys write; 1f; 2f-1f
sys exit
1: <Out of space.\n>
2: .even
/
/ split larger block into two smaller pieces and
/ link together as smaller blocks in the free list.
/
yyy:
mov frlist(r0),r1
mov (r1),frlist(r0)
mov hdrptr,r2
beq www
mov (r2),hdrptr
clr (r2)
mov r2,(r1)
mov r1,frlist-2(r0)
mov l(r1),l(r2)
mov l(r1),r0
sub a(r1),r0
asr r0
add a(r1),r0
mov r0,l(r1)
mov r0,a(r2)
br zzz
/
/
/ here to release a block
/
/ mov ...,r1
/ jsr pc,release
/
/ pointer to block in r1
/
release:
/
/ discover that this is a plausible pointer
/
mov r0,-(sp)
jsr pc,preposterous
/
/ find free list index and link block to that entry
/
inc stats+2
mov frlist(r0),(r1)
clr r(r1)
mov r1,frlist(r0)
clr r1 /self-defense
mov (sp)+,r0
rts pc
/
/
/ jsr pc,collect
/
/ coalesce free storage by rejoining paired blocks
/ on the free list.
/ zero is returned in r0 if no paired blocks were found.
/
collect:
mov r1,-(sp)
mov r2,-(sp)
mov r3,-(sp)
mov r4,-(sp)
clr useful
inc stats+4.
clr r0 /start with smallest blocks
/r0 contains frlist index
loop1: mov $frlist,r1
add r0,r1
/
/ try next list member at this level
/
loop2: mov (r1),r3
beq advance /list is empty
tst *(r1) /W
beq advance /only one list element
/
/ calculate address of buddy
/
mov a(r3),r4
sub $strbuf,r4
bit exp2(r0),r4
beq 2f
bic exp2(r0),r4
br 1f
2: bis exp2(r0),r4
1: add $strbuf,r4
/
/ and search for him
/
loop3: tst 0(r3)
beq nocoal
mov (r3),r2
cmp a(r2),r4
beq coal
mov (r3),r3
br loop3
/
/ have found a pair; remove both blocks from list,
/ coalesce them, and put them on next higher list
/
coal: inc useful
mov (r3),r4
mov (r4),(r3) /remove him from list
mov (r1),r2
mov (r2),(r1) /remove the other one
cmp a(r2),a(r4)
bgt 1f
mov r2,-(sp)
mov r4,r2
mov (sp)+,r4
1: add exp2(r0),l(r4)
clr r(r4)
mov frlist+2(r0),(r4)
mov r4,frlist+2(r0)
mov frlist-2,(r2)
mov r2,frlist-2
clr r(r2)
mov $strbuf,a(r2)
mov $strbuf,l(r2)
br loop2
/
/ no buddy found, try next block on this list
/
nocoal:
mov (r1),r1
br loop2
/
/ advance to next free list
/
advance:
tst (r0)+
cmp r0,$frend-frlist
blo loop1
mov useful,r0
/
/ do we have enough headers to continue?
/
tst garbage
beq 1f
mov $1,r0
sys write; 4f; 5f-4f
sys exit
/
4: <Out of headers.\n>
5: .even
/
/
/ restore registers and return
/
1:
inc garbage
mov (sp)+,r4
mov (sp)+,r3
mov (sp)+,r2
mov (sp)+,r1
rts pc
/
garbage: .=.+2
/
/ routine to find integer part of log2(x)
/
/ jsr pc,log2
/
/ r0 = log2(r0)
/
log2:
mov r0,-(sp)
bge 9f; 4; 9:
mov $15.,r0
1:
rol (sp)
bmi 1f
sob r0,1b
1:
dec r0
tst (sp)+
rts pc
/
0 /Don't move me, I'm exp(-1)
exp2:
1;2;4;10;20;40;100;200;400;1000;2000;4000;
10000;20000;40000;100000
/
/ routine to discover whether r1 points to
/ a plausible header - to avoid ruination.
/
/ r1 is preserved and r0 gets a suitable index for frlist
/
/ jsr pc,preposterous
/
preposterous:
cmp r1,$headers
bhis 9f; 4; 9:
cmp r1,$headend
blo 9f; 4; 9:
cmp a(r1),$strbuf /A
bhis 9f; 4; 9:
cmp l(r1),$strend /L
blos 9f; 4; 9:
mov l(r1),r0 /L
sub a(r1),r0 /A
mov r0,-(sp)
jsr pc,log2
asl r0
cmp exp2(r0),(sp)
beq 9f; 4; 9:
add $2,r0
cmp r0,$frend-frlist+2
blo 9f; 4; 9:
sub $2,r0
mov r0,(sp)
mov frlist(r0),r0
1: beq 1f
cmp r0,r1
bne 9f; 4; 9:
mov (r0),r0
br 1b
1: mov (sp)+,r0
rts pc
/
/
/ routine to initialize storage area, headers and
/ free list upon first call to allocate a block.
/ The entire storage area is formed into a single block.
/
init:
mov r0,-(sp)
mov r1,-(sp)
/
/ form all the headers into a single list.
/
mov $headers,r0
mov r0,frlist-2
1: add $8,r0
mov r0,-8(r0)
cmp r0,$headend-8
blos 1b
clr -8(r0)
mov $frlist,r0
1: clr (r0)+
cmp r0,$frend
blo 1b
/
mov frlist-2,r1
mov (r1),frlist-2
clr w(r1)
mov $strbuf,r0
mov r0,a(r1)
mov $strend-strbuf,r0
jsr pc,log2
asl r0
cmp r0,$frend-frlist
blo 9f; 4; 9:
mov r1,frlist(r0)
mov exp2(r0),r0
add $strbuf,r0
mov r0,l(r1)
mov $frlist-2,r1
1: mov (r1),r1
tst r1
beq 1f
mov $strbuf,a(r1)
mov $strbuf,l(r1)
br 1b
1:
mov (sp)+,r1
mov (sp)+,r0
rts pc
/
/
.bss
stats: .=.+16.
useful: .=.+2
hdrptr: .=.+2 /do not move me
frlist: .=hdrptr+32.
frend:
headers:.=hdrptr+512.
headend:
strbuf: .=.+4000
strend:
end:

76
src/cmd/df.s Normal file
View File

@@ -0,0 +1,76 @@
/ df -- find free space
cmp (sp)+,$1
bgt 1f
mov $rf0,0f
jsr pc,df
mov $1,r0
sys write; plus; 1
mov $rk1,0f
jsr pc,df
mov $1,r0
sys write; plus; 1
mov $rk2,0f
jsr pc,df
mov $1,r0
sys write; plus; 1
mov $rk3,0f
jsr pc,df
mov $1,r0
2:
mov $1,r0
sys write; nl; 1
sys exit
1:
tst (sp)+
mov (sp)+,0f
jsr pc,df
br 2b
df:
clr r3
sys 36.
sys open; 0:..; 0
bes 9f
sys read; nfree; 1024.
mov $freeb,r1
mov nfree,r2
asr r2
1:
mov $16.,r4
mov (r1)+,r5
2:
rol r5
adc r3
dec r4
bne 2b
dec r2
bgt 1b
9:
clr r2
dvd $10.,r2
mov r3,-(sp)
mov r2,r3
beq 2f
jsr pc,9b
2:
movb (sp)+,ch
add $'0,ch
mov $1,r0
sys write; ch; 1
rts pc
rf0: </dev/rf0\0>
rk0: </dev/rk0\0>
rk1: </dev/rk1\0>
rk2: </dev/rk2\0>
rk3: </dev/rk3\0>
plus: <+>
nl: <\n>
.even
.bss
ch: .=.+2
nfree: .=.+2
freeb: .=.+1022.

92
src/cmd/dsw.s Normal file
View File

@@ -0,0 +1,92 @@
/ dsw - delete from tty
cmp (sp)+,$2
blt 1f
tst (sp)+
mov (sp)+,0f
1:
sys stat; 0:dot; stbuf
bes error
bit $40000,stbuf+2
beq error
mov 0b,0f
sys open; 0:..; 0
bes error
mov r0,r1
1:
clrb buf+10.
mov r1,r0
sys read; buf; 10.
bes done
tst r0
beq done
tst buf
beq 1b
mov 0b,r2
mov $obuf,r3
2:
movb (r2)+,(r3)+
bne 2b
mov $buf+2,r2
dec r3
cmpb -1(r3),$'/
beq 2f
movb $'/,(r3)+
2:
movb (r2)+,(r3)+
bne 2b
sys stat; obuf; stbuf
bes error
bit $40000,stbuf+2
bne 1b
mov $buf+2,r2
2:
tstb (r2)+
bne 2b
movb $' ,-(r2)
sub $buf+1,r2
mov r2,0f
2:
mov $1,r0
sys write; buf+2; 0:..
clr r0
sys read; ch; 1
cmpb ch,$'\n
beq 1b
clr r0
sys read; ch1; 1
cmpb ch1,$'\n
beq 3f
4:
clr r0
sys read; ch; 1
cmpb ch,$'\n
beq 2b
br 4b
3:
cmpb ch,$'x
beq done
cmpb ch,$'y
bne 2b
sys unlink; obuf
bes error
br 1b
done:
sys exit
error:
mov $1,r0
sys write; mes; 2
sys exit
dot: <.\0>
mes: <?\n>
.bss
obuf: .=.+100.
stbuf: .=.+40.
buf: .=.+11.
ch: .=.+1
ch1: .=.+1

198
src/cmd/dusg.s Normal file
View File

@@ -0,0 +1,198 @@
/ dusg -- summarize disk usage
mov (sp)+,r5
tst (sp)+
1:
dec r5
bgt 2f
tstb buf1
beq 3f
sys exit
3:
mov $dot,r0
br 3f
2:
mov (sp)+,r0
3:
cmpb (r0),$'-
bne 2f
cmpb 1(r0),$'a
bne 3f
inc aflg
br 1b
3:
cmpb 1(r0),$'s
bne 1b
dec aflg
br 1b
2:
mov $buf1,r1
2:
movb (r0)+,(r1)+
bne 2b
dec r1
clr buf3+10.
clr icnt
jsr pc,tree
tst aflg
bpl 1b
jsr r5,name
br 1b
tree:
sys stat; buf1; buf2
bes 1f
cmp buf2,$40.
bgt 2f
1:
clr r4
rts pc
2:
mov icnt,r0
mov $ibuf,r2
mov buf2,r3
1:
tst r0
beq 1f
cmp r3,(r2)+
bne 2f
clr r4
jsr r5,cname
rts pc
2:
dec r0
br 1b
1:
mov r3,(r2)+
inc icnt
bit $40000,buf2+2
bne 1f
jsr pc,gsize
jsr r5,cname
rts pc
1:
jsr pc,gsize
mov r4,r3
sys open; buf1; 0
bec 1f
rts pc
1:
mov r0,-(sp)
mov r1,-(sp)
1:
mov 2(sp),r0
sys read; buf3; 10.
bes 1f
tst r0
beq 1f
tst buf3
beq 1b
cmp buf3+2,$".\0
beq 1b
cmp buf3+2,$"..
bne 2f
tst buf3+4
beq 1b
2:
mov $buf3+2,r2
mov (sp),r1
movb $'/,(r1)+
cmpb -2(r1),$'/
bne 2f
dec r1
2:
movb (r2)+,(r1)+
bne 2b
dec r1
mov r3,-(sp)
jsr pc,tree
mov r4,r3
add (sp)+,r3
br 1b
1:
mov (sp)+,r1
clrb (r1)
mov (sp)+,r0
sys close
mov r3,r4
tst aflg
bmi 1f
jsr r5,name
1:
rts pc
cname:
tst aflg
bgt name
rts r5
name:
jsr pc,pnum
mov $011,r0
jsr pc,pchar
mov $buf1,r2
1:
movb (r2)+,r0
beq 1f
jsr pc,pchar
br 1b
1:
mov $'\n,r0
jsr pc,pchar
rts r5
gsize:
mov r5,-(sp)
mov buf2+6,r5 / size
add $511.,r5
clr r4
alsc $-9,r4
cmp r5,$8.
blo 1f
mov r5,-(sp)
add $255.,r5
alsc $-8,r4
add (sp)+,r5
1:
mov r5,r4
mov (sp)+,r5
rts pc
pnum:
mov r4,-(sp)
mov r5,-(sp)
mov r4,r5
jsr pc,1f
mov (sp)+,r5
mov (sp)+,r4
rts pc
1:
clr r4
dvd $10.,r4
mov r5,-(sp)
mov r4,r5
beq 1f
jsr pc,1b
1:
mov (sp)+,r0
add $'0,r0
jsr pc,pchar
rts pc
pchar:
mov r0,0f
mov $1,r0
sys write; 0f; 1
rts pc
0: 0
dot: <.\0>
.bss
icnt: .=.+2
buf1: .=.+100.
buf2: .=.+40.
buf3: .=.+12.
aflg: .=.+2
ibuf: .=.+1000.

127
src/cmd/fc.c Normal file
View File

@@ -0,0 +1,127 @@
/* fortran command */
char ts[500];
char *tsp ts;
char *av[50];
char *llist[50];
main(argc, argv)
char *argv[]; {
char *t;
int nl, cflag, i, j;
llist[0] = 0;
i = nl = cflag = 0;
while(++i < argc) {
if (getsuf(t=copy(argv[i])) == 'f') {
printf("%s:\n", t);
av[0] = "fc";
av[1] = t;
av[2] = 0;
if(callsys("/usr/fort/fc1", av) == 0) {
av[0] = "as";
av[1] = "-";
av[2] = "f.tmp1";
av[3] = 0;
callsys("/bin/as", av);
setsuf(t);
unlink(t);
if(link("a.out", t) | unlink("a.out")) {
printf("move failed: %s\n", t);
return;
}
} else {
cflag++;
goto loop;
}
} else if (*t == '-' & t[1] =='c') {
cflag++;
goto loop;
}
if (nodup(llist, t)) {
llist[nl++] = t;
llist[nl] = 0;
}
loop:;
}
unlink("f.tmp1");
if (cflag | nl==0) return;
i = 0;
av[0] = "ld";
av[1] = "/lib/fr0.o";
j = 2;
while(i<nl)
av[j++] = llist[i++];
av[j++] = "-lf";
av[j++] = "/lib/filib.a";
av[j++] = "-l";
av[j++] = 0;
callsys("/bin/ld", av);
}
getsuf(s)
char s[]; {
int c;
char t, *os;
c = 0;
os = s;
while(t = *s++)
if (t=='/')
c = 0;
else
c++;
s =- 3;
if (c<=8 & c>2 & *s++=='.' & *s=='f')
return('f');
return(0);
}
setsuf(s)
char s[]; {
while(*s++);
s[-2] = 'o';
}
callsys(f, v)
char f[], *v[]; {
int t, status;
if ((t=fork())==0) {
execv(f, v);
printf("Can't find %s\n", f);
exit(-1);
} else
if (t == -1) {
printf("Try again\n");
exit(-1);
}
while(t!=wait(&status));
if ((status&0377) != 0)
exit(-1);
return((status>>8) & 0377);
}
copy(s)
char s[]; {
char *otsp;
otsp = tsp;
while(*tsp++ = *s++);
return(otsp);
}
nodup(l, s)
char *l[], s[]; {
char *t, *os, c;
os = s;
while(t = *l++) {
s = os;
while(c = *s++)
if (c != *t++) goto ll;
if (*t++ == '\0') return (0);
ll:;
}
return(1);
}

533
src/cmd/fed2.s Normal file
View File

@@ -0,0 +1,533 @@
/
/
ed:
mov (sp)+,r3
ble error
econ:
sys stat; ftemp; buffer
bec 2f
sys creat; ftemp; 17
mov r0,tmpw
sys open; ftemp; 0
mov r0,tmpr
br 1f
2:
cmpb $'z,ftemp+9.
bne 2f
mov $1,r0
sys write; erm; 23.
jmp loop
2:
incb ftemp+9.
br econ
1:
mov (sp),r0
jsr pc,getspq
bes 3f
mov r0,r4
mov r2,r1
jsr pc,rewind
mov $buffer,r2
1:
jsr pc,getchar
bes 1f
movb r0,(r2)+
br 1b
1:
movb $'\n,(r2)+
jsr pc,output
mov r4,r1
jsr pc,rewind
2:
mov $buffer,r2
1:
jsr pc,getchar
bes 1f
movb r0,(r2)+
cmp r2,$bufend
blo 1b
mov tmpw,r0
sys write; buffer; 512.
br 2b
1:
sub $buffer,r2
beq 4f
mov r2,0f
mov tmpw,r0
sys write; buffer; 0:..
4:
tst iflag
beq 1f
mov tmpw,r0
sys close
mov tmpr,r0
sys close
sys unlink; ftemp
jmp loop
1:
mov tmpw,r0
sys close
sys fork
br 5f
mov r1,-(sp)
sys wait
sys intr; inter
mov (sp)+,r1
mov a(r1),w(r1)
2:
mov tmpr,r0
sys read; buffer; 512.
tst r0
beq 2f
add $buffer,r0
mov r0,bufend
mov $buffer,r2
1:
movb (r2)+,r0
jsr pc,putchar
cmp r2,bufend
blo 1b
br 2b
2:
mov tmpr,r0
sys close
sys unlink; ftemp
tst iflag
beq 1f
jmp loop
1:
tst qflag
bgt 1f
tst (sp)+
dec r3
bgt 1f
jmp loop
1: jmp econ
jmp loop
3:
mov (sp),r2
mov $2,r0
jsr pc,allocate
1:
tstb (r2)
beq 1f
movb (r2)+,r0
jsr pc,putchar
br 1b
1:
mov r1,r0
mov asmem,r1
jsr pc,putword
mov $2,r0
jsr pc,allocate
mov r1,r0
mov asmem,r1
jsr pc,putword
mov r0,r1
br 4b
5:
mov $2,r0
1:
sys close
inc r0
cmp r0,$10.
blo 1b
sys exec; edd; eda
sys exit
eda: edd; ftemp; 0
edd: </bin/ed\0>
.even
ftemp: </tmp/ftmpa\0>
erm: <Cannot open temp. file\n>
.even
tmpw: .=.+2
tmpr: .=.+2
/
/ remove a 'file' from memory
/
remove:
mov (sp)+,r3
bgt 5f
mov $1,vflag
mov asmem,r1
jsr pc,rewind
mov r(r1),-(sp)
4:
tst iflag
beq 1f
jmp loop
1:
jsr pc,getword
bes 4f
mov r0,r2
jsr pc,ask
bec 1f
mov r(r1),(sp)
br 4b
1:
jsr pc,getword
br 2f
5:
mov (sp),r0
jsr pc,getspq
bec 2f
tst qflag
blt 6f
mov (sp),r1
jsr pc,nothere
br 3f
2:
mov r0,r1
jsr pc,release
mov r2,r1
jsr pc,release
jsr pc,rm
3:
tst vflag
bne 3f
tst iflag
beq 1f
jmp loop
1:
tst qflag
bgt 5b
6:
tst (sp)+
dec r3
bgt 5b
jmp loop
3:
mov asmem,r1
mov (sp),r(r1)
br 4b
4:
tst (sp)+
jmp loop
/
/ rename a 'file'
/
rename:
mov (sp)+,r3
bne 1f
jmp error
1:
sub $2,r3
blt 1f
5:
mov (sp),r0
jsr pc,getsp
bes 4f
tst (sp)+
sub $4,r(r1)
mov (sp),r0
mov r2,-(sp)
mov r(r1),-(sp)
jsr pc,getsp
bes 3f
mov r2,-(sp)
mov r0,r1
jsr pc,release
jsr pc,rm
mov (sp)+,r0
mov (sp)+,r(r1)
jsr pc,alterword
mov (sp)+,r1
jsr pc,release
br 5f
3:
mov (sp)+,r(r1)
mov (sp)+,r1
jsr pc,release
mov $2,r0
jsr pc,allocate
mov (sp)+,r2
2:
movb (r2)+,r0
beq 2f
jsr pc,putchar
br 2b
2:
mov r1,r0
mov asmem,r1
jsr pc,alterword
5:
tst iflag
beq 2f
jmp loop
2:
tst r3
beq 2f
sub $2,r3
bge 5b
1:
tst (sp)+
jmp error
2:
jmp loop
4:
mov (sp)+,r1
jsr pc,nothere
tst (sp)+
br 5b
/
/ list contents of asmem
/
list:
mov $buffer,r2
movb $'\n,(r2)+
jsr pc,output
mov (sp)+,r3
beq 1f
mov $1,vflag
5:
tst iflag
beq 2f
jmp loop
2:
mov (sp),r0
jsr pc,getspq
bes 4f
mov r2,r1
br 3f
1:
mov asmem,r1
jsr pc,fsfile
sub $2,r(r1)
2:
tst iflag
bne 2f
jsr pc,backword
bes 2f
mov r0,r1
3:
jsr pc,getn
movb $'\n,(r2)+
jsr pc,output
tst vflag
bne 1f
mov asmem,r1
sub $2,r(r1)
br 2b
1:
tst qflag
bgt 5b
4:
tst (sp)+
dec r3
bgt 5b
2:
mov $buffer,r2
movb $'\n,(r2)+
jsr pc,output
jmp loop
/
/ list a 'file
/
listf:
mov (sp)+,r3
bgt 4f
jmp error
4:
mov (sp),r0
jsr pc,getspq
bes 3f
mov r0,r4
mov r2,r1
jsr pc,rewind
mov $buffer,r2
movb $'\n,(r2)+
1:
jsr pc,getchar
bes 1f
movb r0,(r2)+
cmp r2,$bufend
blo 1b
jsr pc,output
br 1b
1:
mov r4,r1
jsr pc,rewind
movb $':,(r2)+
cmp r2,$bufend
blo 2f
jsr pc,output
2:
movb $'\n,(r2)+
1:
tst iflag
beq 2f
jmp loop
2:
cmp r2,$bufend
blo 2f
jsr pc,output
2:
jsr pc,getchar
bes 1f
movb r0,(r2)+
br 1b
1:
jsr pc,output
3:
tst qflag
bgt 4b
tst (sp)+
dec r3
bgt 4b
mov $buffer,r2
movb $'\n,(r2)+
jsr pc,output
jmp loop
/
fin:
jsr pc,flush
jsr pc,whead
4
q:
jsr pc,flush
jsr pc,whead
sys exit
memck: mov (sp)+,r3
2:
ble 2f
mov (sp)+,r1
cmpb (r1),$'p
bne 1f
bis $1,vflag
br 3f
1:
cmpb (r1),$'f
bne 3f
bis $2,vflag
3:
dec r3
br 2b
2:
clr freeh
mov $freeb,r2
1:
clr (r2)+
cmp r2,$freen
blo 1b
mov $headers,r2
2:
cmp l(r2),$hsz
beq 6f
jsr pc,ck
bec 1f
cmp r2,asmem
beq 1f
mov asmem,r1
jsr pc,rewind
clr r3
4:
inc r3
jsr pc,getword
bes 5f
cmp r0,r2
bne 4b
6:
inc freeh
1:
cont:
add $8.,r2
cmp r2,$headend-4
blo 2b
mov asmem,r1
jsr pc,rewind
4:
jsr pc,getword
bes 4f
tst r(r0)
beq 2f
mov r0,r2
jsr pc,ck
bes 4b
2:
sub $hblk,r0
jsr r5,oct
mov $1,r0
sys write; re; 24.
cmp vflag,$1
beq 4b
bit $1,r3
beq 2f
jsr pc,getword
mov r0,r1
jsr pc,release
br 3f
2:
jsr pc,backword
add $4,r(r1)
mov r0,r1
jsr pc,release
3:
jsr pc,rm
clr r3
br 4b
4:
mov freeh,r0
jsr r5,decml
mov $1,r0
sys write; frh; 14.
mov $freeb,r2
mov $1,r3
6:
cmp r2,$freen
bhis 6f
mov (r2)+,r0
beq 3f
jsr r5,decml
mov $1,r0
sys write; frb; 18.
mov r3,r0
jsr r5,decml
mov $1,r0
sys write; lf; 1.
3:
asl r3
br 6b
6:
mov $1,r0
sys write; lf; 1.
jmp loop
5:
mov r2,r0
sub $hblk,r0
jsr r5,oct
mov $1,r0
sys write; un; 26.
tst vflag
beq 1b
mov r2,r1
cmp vflag,$2
beq 3f
jsr pc,rewind
mov $buffer,r2
2:
jsr pc,getchar
bes 2f
movb r0,(r2)+
cmp r2,$buffer+80.
blo 2b
jsr pc,output
br 2b
2:
movb $'\n,(r2)+
jsr pc,output
mov r1,r2
cmp vflag,$1
bne 3f
jmp cont
3:
jsr pc,release
jmp cont
/
interrupt: 4
/
un: < header not accounted for\n>
re: < part of asmem released\n>
lf: <\n>
frh: < free headers\n >
frb: < free blocks size >
endc: .even

358
src/cmd/fed3.s Normal file
View File

@@ -0,0 +1,358 @@
rti = 2
.globl rm
.globl ck
.globl loop
.globl oct
.globl argc
.globl arg
.globl tfiget
.globl asmem
.globl qflag
.globl vflag
.globl getspq
.globl q
.globl ask
.globl getword
.globl r
.globl w
.globl output
.globl buffer
.globl bufend
.globl fv
.globl getsp
.globl release
.globl nothere
.globl getn
.globl getchar
.globl rewind
.globl iflag
.globl inter
/ output buffer
/ r2 = last char in buffer + 1
/ r2 returned at beginning of buffer
/
output:
sub $buffer,r2
blos 1f
mov r2,0f
mov $1,r0
sys write; buffer; 0:..
mov $buffer,r2
1:
rts pc
/
/
/ routine to find the string pointed to by r0
/ in either memory or curly
/ r1 = where to look
/
/ returns error set if string not there
/ returns r1 = header of string if there
getsp:
mov r0,-(sp)
mov asmem,r1
jsr pc,rewind /memory
3:
jsr pc,getword
bes 1f
mov r0,r1
jsr pc,rewind
mov (sp),r2
2:
jsr pc,getchar
bes 2f
tstb (r2)
beq 4f
cmpb r0,(r2)+
beq 2b
4:
mov asmem,r1
add $2,r(r1)
br 3b
2:
tstb (r2)
bne 4b
mov r1,r2
mov asmem,r1
jsr pc,getword
tst (sp)+
rts pc
1:
mov (sp)+,r0
sec
rts pc
/
/ finds header of string with name same as that pointed to by r0
/ taking into account ? and *
getspq:
mov r0,-(sp)
mov asmem,r1
tst qflag
bgt 1f
jsr pc,rewind
1:
jsr pc,getword
bes 1f
mov r0,r1
jsr pc,rewind
mov (sp),r2
2:
cmpb (r2),$'*
bne 3f
clr strflg
mov $2,qflag
inc r2
tstb (r2)
beq 6f
mov r2,ch
3:
jsr pc,getchar
bes 2f
tstb (r2)
bne 3f
cmp $2,qflag
bne 4f
mov ch,r2
3:
cmpb (r2),$'?
bne 3f
inc r2
tst qflag
bne 2b
mov $1,qflag
br 2b
3:
cmpb r0,(r2)+
bne 5f
inc strflg
br 2b
5:
cmp $2,qflag
bne 4f
tst strflg
bne 4f
dec r2
br 2b
4:
mov asmem,r1
add $2,r(r1)
br 1b
2:
tstb (r2)
bne 4b
6:
mov r1,r2
mov asmem,r1
jsr pc,getword
tst (sp)+
rts pc
1:
mov $-1.,qflag
mov (sp)+,r0
sec
rts pc
/
/ tfiget
/ jsr r5,tfiget
/
tfiget:
clr r0
sys read; ch; 1
bes 1f
tst iflag
beq 9f; jmp loop; 9:
tst r0
beq 1f
movb ch,r0
rts pc
1: jmp q
/
/ routine to print file name and error message
/ r2 = next free byte in buffer
/
nothere:
mov $buffer,r2
1:
tstb (r1)
beq 1f
movb (r1)+,(r2)+
br 1b
1:
sub $buffer,r2
mov r2,0f
mov $1,r0
sys write; buffer; 0:..
mov $1,r0
sys write; err4; 16.
rts pc
/
/
/ routine to put characters from string in buffer
/ r1 = header of string
/ on return r2 = next free byte in buffer
/
getn:
mov $buffer,r2
jsr pc,rewind
1:
jsr pc,getchar
bes 1f
movb r0,(r2)+
cmp r2,$bufend
bhis 1f
br 1b
1: rts pc
/
ask:
mov r2,-(sp)
mov r0,r1
jsr pc,getn
movb $' ,(r2)+
jsr pc,output
jsr pc,tfiget
cmpb $'\n,r0
bne 1f
2:
mov asmem,r1
add $2,r(r1)
mov (sp)+,r2
sec
rts pc
1:
cmpb r0,$'y
beq 4f
cmpb r0,$'q
beq 3f
1:
tst iflag
bne 2b
jsr pc,tfiget
cmpb $'\n,r0
bne 1b
br 2b
4:
tst iflag
bne 2b
jsr pc,tfiget
cmpb $'\n,r0
bne 1b
mov asmem,r1
mov (sp)+,r2
clc
rts pc
3:
tst iflag
bne 2b
jsr pc,tfiget
cmpb $'\n,r0
bne 1b
mov (sp)+,r2
jmp loop
inter:
inc iflag
rti
/ to remove an entry from asmem - r points to name ptr
/
rm:
mov r3,-(sp)
mov asmem,r1
mov r(r1),r3
sub $4,r(r1)
mov r(r1),r2
mov r2,-(sp)
1:
mov r3,r(r1)
jsr pc,getword
bes 1f
mov r(r1),r3
mov r2,r(r1)
jsr pc,alterword
mov r(r1),r2
br 1b
1:
mov r2,w(r1)
mov (sp)+,r(r1)
mov (sp)+,r3
rts pc
/
/ check that header pointed to by r2 released
/
ck:
mov r2,-(sp)
mov l(r2),r0
sub a(r2),r0
sub $hblk,r2
jsr pc,log2
asl r0
mov r0,ch
mov frlist(r0),r0
1:
beq 1f
cmp r2,r0
beq 2f
add $hblk,r0
mov (r0),r0
br 1b
2:
mov ch,r0
inc freeb(r0)
mov (sp)+,r2
rts pc
1:
mov (sp)+,r2
sec
rts pc
oct:
mov r1,-(sp)
mov r0,r1
clr r0
div $8.,r0
mov r1,-(sp)
add $'0,(sp)
tst r0
beq 1f
jsr r5,oct
1:
movb (sp)+,ch
mov $1,r0
sys write; ch; 1
mov (sp)+,r1
rts r5
decml:
mov r1,-(sp)
mov r0,r1
clr r0
div $10.,r0
mov r1,-(sp)
add $'0,(sp)
tst r0
beq 1f
jsr r5,decml
1:
movb (sp)+,ch
mov $1,r0
sys write; ch; 1
mov (sp)+,r1
rts r5
/
/
iflag: 0
qflag: 0
vflag: 0
.data
err4: < not in memory.\n>
err1: <Cannot open file >
end1: .even
.bss
freeh: .=.+2
freeb: .=.+32.
freen:
ch: .=.+2
strflg: .=.+2
buffer: .=.+512.
bufend: .=.+2
argc = buffer + 20.
arg = buffer + 256.
fv: .=.+2
.text

165
src/cmd/form1.s Normal file
View File

@@ -0,0 +1,165 @@
testing = 0
/ form letter generator
/ command sequence
/ form proto arg1 arg2...
/ where proto is letter
rfo:
sys intr; int
mov $-1,buf
mov (sp)+,r2 /arg count
tst (sp)+ /skip first arg
sub $2,r2
bge 2f
mov $default,-(sp)
2:
mov (sp)+,letter
1: sys stat; otfil; buf
bec 2f
sys creat; otfil; 17
bec cont
2: cmpb $'z,otfil+4
beq err3
incb otfil+4
br 1b
err3:
mov $1,r0
sys write; mes3; 24.
sys exit
mes3: <cannot open output file\n>
otfil: <forma\0>
default: <letter\0>
.even
cont: mov r0,rfo
clr rfo+2
jsr pc,initl
/ set up argument list
/
mov $arg,r3
mov $10.,r0
jsr pc,allocate
mov r1,(r3)+
1:
dec r2
blt 1f
mov $10.,r0
jsr pc,allocate
mov r1,(r3)+
mov (sp)+,r4
2:
movb (r4)+,r0
beq 1b
jsr pc,putchar
br 2b
1:
sys time
ashc $-9.,r0
bic $!177,r0
div $10125.,r0
mov $daytab,r2
sub $365.,r0
1: sub (r2)+,r0
bge 1b
add -(r2),r0
mov r0,-(sp)
mov arg,r1
mov montab-daytab(r2),r2
1:
movb (r2)+,r0
beq 1f
jsr pc,putchar
br 1b
1:
movb $' ,r0
jsr pc,putchar
clr r0
mov (sp),r1
inc r1
div $10.,r0
mov r1,(sp)
mov arg,r1
tst r0
beq 1f
add $'0,r0
jsr pc,putchar
1:
mov (sp)+,r0
add $'0,r0
jsr pc,putchar
jmp loop
daytab: 31.; 29.; 31.; 30.; 31.; 30.; 31.; 31.; 30.; 31.; 30.; 999.
montab: m1; m2; m3; m4; m5; m6; m7; m8; m9; m10; m11; m12
m1: <January\0>
m2: <February\0>
m3: <March\0>
m4: <April\0>
m5: <May\0>
m6: <June\0>
m7: <July\0>
m8: <August\0>
m9: <September\0>
m10: <October\0>
m11: <November\0>
m12: <December\0>
buf: .=.+34.
.=rfo+516.
loop:
mov $10.,r0
jsr pc,allocate
mov r1,opointer
jsr pc,allocate
mov r1,ipointer
jsr pc,allocate
mov r1,curly
mov $10.,r0
jsr pc,allocate
mov r1,scr
mov letter,r3
movb $'\{,r0
jsr pc,putchar
1:
movb (r3)+,r0
beq 1f
jsr pc,putchar
br 1b
1:
movb $'\},r0
jsr pc,putchar
clr switch
tst iflag
beq 1f
mov $1,tflag
jmp interrupt
1:
jsr pc,scan
movb $'\n,r0
jsr r5,putc
jsr r5,flushb
mov scr,r1
jsr pc,release
jsr pc,relarg
mov opointer,r1
jsr pc,release
mov ipointer,r1
jsr pc,release
jsr pc,relcurl
jsr pc,flush
jsr pc,whead
.if testing
4
.endif
sys exit

92
src/cmd/form2.s Normal file
View File

@@ -0,0 +1,92 @@
/ scan
/ r1 = pointer to input header
/ r0 = pointer to output header
/ switch = 0 real output
/ not 0 output to r0
scan:
mov r0,-(sp)
mov r1,-(sp)
1:
mov (sp),r1
jsr pc,getchar
bes 5f
cmpb r0,$'\\
beq 3f
cmpb r0,$'\[
beq 4f
cmpb r0,$'\{
beq 4f
cmpb r0,$'\]
beq 1f
cmpb r0,$'\}
beq 7f
cmpb r0,$'\n
bne 6f
jsr pc,lookchar
bes 5f
movb $'\n,r0
6:
tst switch
beq 2f
mov 2(sp),r1
jsr pc,putchar
br 1b
2:
jsr r5,putc
br 1b
3:
jsr pc,getchar
br 6b
/ have [ or {
4:
mov r(r1),-(sp)
jsr pc,getchar
bes 1f
cmpb r0,$'0
blt 4f
cmpb r0,$'9
bgt 4f
jsr pc,getchar
cmpb r0,$'\]
beq 3f
cmpb r0,$'\}
beq 3f
4:
mov (sp)+,r(r1)
mov 2(sp),r0
jsr pc,esub
mov r1,(sp)
mov r0,2(sp)
br 1b
/ have arg
3:
tst switch
beq 2f
mov opointer,r1
mov 4(sp),r0
jsr pc,putword
mov 2(sp),r1
2:
mov (sp)+,r(r1)
jsr pc,getchar
inc r(r1) /skip ]
jsr pc,earg
br 1b
5:
tst argf
bne 1f
mov ipointer,r1
jsr pc,pop
bes 1f
mov r0,(sp)
br 1b
7:
inc curlyf
1:
mov (sp)+,r1
mov (sp)+,r0
rts pc

147
src/cmd/form3.s Normal file
View File

@@ -0,0 +1,147 @@
/ esub
/ r1 = pointer to input string
/
esub:
mov r1,-(sp)
tst switch
beq 1f
mov opointer,r1
jsr pc,putword
1:
tst iflag
beq 1f
mov $2,tflag
jmp interrupt
1:
inc switch
mov $10.,r0
jsr pc,allocate
mov r1,r0
mov opointer,r1
jsr pc,putword
mov (sp)+,r1
jsr pc,scan
tst iflag
beq 1f
mov $3,tflag
jmp interrupt
1:
mov r2,-(sp)
mov r1,r0
mov ipointer,r1
jsr pc,putword
mov opointer,r1
jsr pc,pop
bec 9f; 4; 9:
mov r0,-(sp) /last output
mov asmem,r1
jsr pc,getsp
bes 2f
5:
clr curlyf
mov (sp),r1
mov r0,r2
jsr pc,release
6:
mov opointer,r1
jsr pc,pop
bec 4f
clr switch
4: mov r2,r1
jsr pc,rewind
tst (sp)+
mov (sp)+,r2
rts pc
/ not in memory
2:
mov curly,r1
jsr pc,getsp
bes 2f
br 5b
2:
mov (sp),r1
jsr pc,rewind
mov $'\[,r0
1:
jsr r5,tfoput
jsr pc,getchar
bec 1b
mov $'\],r0
jsr r5,tfoput
mov $10.,r0
jsr pc,allocate
mov r1,r2
mov (sp),r0
tst curlyf
beq 1f
clr curlyf
mov curly,r1
jsr pc,addentry
br 2f
1:
mov asmem,r1
jsr pc,whead
jsr pc,addentry
2:
mov r2,r1
jsr pc,accept
br 6b
/
/
/ earg
/ r0 = number in ascii
/
earg:
tst iflag
beq 1f
mov $4,tflag
jmp interrupt
1:
mov r1,-(sp)
inc argf
sub $'0,r0
asl r0
mov arg(r0),r1
beq 5f
4:
mov (sp),r0
mov r1,(sp)
mov ipointer,r1
jsr pc,putword
mov opointer,r1
jsr pc,pop
bec 3f
clr switch
3:
mov (sp)+,r1
jsr pc,rewind
jsr pc,scan
mov r0,-(sp)
mov ipointer,r1
jsr pc,pop
bec 9f; 4; 9:
mov r0,r1
clr argf
clr curlyf
mov (sp)+,r0
rts pc
5:
mov r0,-(sp)
mov $'\[,r0
jsr r5,tfoput
mov (sp),r0
asr r0
add $'0,r0
jsr r5,tfoput
mov $'\],r0
jsr r5,tfoput
mov $10.,r0
jsr pc,allocate
mov (sp)+,r0
mov r1,arg(r0)
jsr pc,accept
br 4b

250
src/cmd/form4.s Normal file
View File

@@ -0,0 +1,250 @@
rti = 2
/ accept
/ r1 = header of where to put it
/
accept:
mov r0,-(sp)
movb $':,r0
jsr r5,tfoput
movb $' ,r0
jsr r5,tfoput
2:
jsr r5,tfiget
cmpb r0,$'\n
beq 1f
jsr pc,putchar
br 2b
1:
jsr pc,putchar
jsr r5,tfiget
cmpb r0,$'\n
beq 1f
jsr pc,putchar
br 2b
1:
mov (sp)+,r0
rts pc
/
/
/ routine to get the last word from the string
/ r1=header addr
/
pop:
jsr pc,fsfile
jsr pc,backword
bes 1f
sub $2,w(r1)
1:
rts pc
/
/
/ routine to add an entry to assoc mem or curly
/ r1 = header
/ r0 = header of string name
/ r2 = header of string
/
addentry:
jsr pc,putword
mov r2,r0
jsr pc,putword
rts pc
/
/
/ routine to find the string pointed to by r0
/ in either memory or curly
/ r1 = where to look
/
/ returns error set if string not there
/ returns r1 = header of string if there
/
getsp:
mov r0,-(sp)
mov r1,-(sp)
jsr pc,rewind /memory
3:
mov 2(sp),r1
jsr pc,rewind /output
mov (sp),r1
jsr pc,getword
bes 1f
mov r0,r1
mov r0,-(sp)
jsr pc,rewind /string
2:
mov (sp),r1
jsr pc,getchar
bes 2f
movb r0,r2
mov 4(sp),r1
jsr pc,getchar
bes 4f
cmpb r0,r2
beq 2b
4:
tst (sp)+
4:
mov (sp),r1
add $2,r(r1)
br 3b
2:
tst (sp)+
mov 2(sp),r1
cmp r(r1),w(r1)
bne 4b
mov (sp)+,r1
jsr pc,getword
tst (sp)+
rts pc
1:
mov (sp)+,r1
mov (sp)+,r0
sec
rts pc
/
/
/ tfoput
/
/ jsr r5,tfoput
/
tfoput:
mov r0,ch
mov $1,r0
sys write; ch; 1
rts r5
/
/
/ tfiget
/
/ jsr r5,tfiget
/
tfiget:
clr r0
sys read; ch; 1
bes 1f
tst r0
beq 1f
movb ch,r0
rts r5
1:
jsr r5,flushb
tst argf
beq 1f
mov opointer,r1
jsr pc,pop
1:
mov $5,tflag
jmp interrupt
/
/ putc
/ jsr r5,putc
/
putc:
mov r1,-(sp)
mov r2,-(sp)
mov $rfo+2,r1
mov r1,r2
add (r1),r2
movb r0,2(r2)
inc (r1)
cmp (r1),$512.
bge 1f
mov (sp)+,r2
mov (sp)+,r1
rts r5
1:
mov (sp)+,r2
mov (sp)+,r1
/
/
/ flush output buffer to output file.
/
flushb:
mov r1,-(sp)
mov r0,-(sp)
mov $rfo,r1
mov (r1)+,r0
mov (r1),0f+2
beq 1f
clr (r1)+
mov r1,0f
sys write; 0:..;..
1:
mov (sp)+,r0
mov (sp)+,r1
rts r5
relarg:
mov $arg,r2
1:
mov (r2)+,r1
beq 2f
jsr pc,release
br 1b
2:
cmp r2,$arge
blt 1b
rts pc
/
relcurl:
mov curly,r1
jsr pc,rewind
1:
jsr pc,getword
bes 1f
mov r0,r1
jsr pc,release
mov curly,r1
br 1b
1:
jsr pc,release
rts pc
/
int:
inc iflag
rti
/
interrupt:
jsr pc,relarg
tst opointer
beq 2f
1:
mov opointer,r1
jsr pc,rewind
1:
jsr pc,getword
bes 1f
mov r0,r1
jsr pc,release
mov opointer,r1
br 1b
1:
mov opointer,r1
jsr pc,release
tst ipointer
beq 2f
mov ipointer,r1
jsr pc,release
tst curly
beq 2f
jsr pc,relcurl
tst scr
beq 2f
mov scr,r1
jsr pc,release
2:
jsr pc,flush
jsr pc,whead
sys exit
letter: .=.+2
arg: .=.+20.
arge: 0
argf: .=.+2
switch: .=.+2
curly: .=.+2
curlyf: .=.+2
ch: .=.+2
opointer: .=.+2
ipointer: .=.+2
scr: .=.+2
iflag: 0
tflag: 0
end:

789
src/cmd/form5.s Normal file
View File

@@ -0,0 +1,789 @@
.globl b1
.globl hblk
.globl headers
.globl headsz
.globl strend
.globl initl
.globl asmem
.globl b1s
.globl b1e
.globl w1
.globl stats
.globl lookchar
.globl flush
.globl fsfile
.globl seekchar
.globl backspace
.globl alterchar
.globl zero
.globl getchar
.globl putchar
.globl copy
.globl rewind
.globl create
.globl allocate
.globl release
.globl collect
.globl w,r,a,l
.globl getword
.globl putword
.globl backword
.globl alterword
/
/
/ routine to read next character from string
/ pointer to by r1; character returned in r0
/ c-bit set if character not availiable (eof)
/
/ mov ...,r1
/ jsr pc,getchar
/ movb r0,...
/
getchar:
jsr pc,lookchar
bes 1f
inc r(r1)
tst r0 /clears c-bit
1: rts pc
/
/
/ routine to read a string backwards
/ the read pointer is decremented before reading
/
/ mov ...,r1
/ jsr pc,backspace
/ mov r0,...
/
backspace:
cmp a(r1),r(r1)
bhis nochc
dec r(r1)
jsr pc,lookchar
rts pc
nochc: clr r0
sec
rts pc
/
/
/ routine to put a word onto the string
/
/ mov ...,r1
/ mov ...,r0
/ jsr pc,putword
/
putword:
mov r0,-(sp)
sub $hblk,r0
jsr pc,putchar
swab r0
jsr pc,putchar
mov (sp)+,r0
rts pc
/
/
/ routine to get a word from the string
/
/ mov ...,r1
/ jsr pc,getword
/ mov r0,...
/
getword:
jsr pc,lookchar
bes 1f
movb r0,nchar
inc r(r1)
jsr pc,lookchar
bes 1f
movb r0,nchar+1
inc r(r1)
mov nchar,r0
add $hblk,r0
1: rts pc
/
/
/ routine to alter the word pointed to by r(r1)
/ by replacing the word there with r0
/
/ mov wd,r0
/ mov ...,r1
/ jsr pc,alterword
/
alterword:
mov r0,-(sp)
sub $hblk,r0
jsr pc,alterchar
swab r0
jsr pc,alterchar
mov (sp)+,r0
rts pc
/
/
/ routine to get words backwards from string
/
/ mov ...,r1
/ jsr pc,backword
/ mov r0,...
/
backword:
cmp a(r1),r(r1)
bhis nochw
dec r(r1)
jsr pc,lookchar
movb r0,nchar+1
cmp a(r1),r(r1)
bhis nochw
dec r(r1)
jsr pc,lookchar
movb r0,nchar
mov nchar,r0
add $hblk,r0
rts pc
/
nochw:
clr r0
sec
rts pc
/
/
/ routine to copy the contents of one string
/ to another.
/
/ mov source,r0
/ mov dest,r1
/ jsr pc,copy
/ mov r1,...
/
/ on return, r1 points to the new string and should
/ be saved. r0 is preserved.
/
copy:
inc stats+12.
mov r0,-(sp)
mov r1,-(sp)
mov r2,-(sp)
mov r3,-(sp)
mov w(r0),r2
sub a(r0),r2 /W-A (old)
mov l(r1),r3
sub a(r1),r3 /L-A (new)
cmp r2,r3
blos 1f
mov r2,r0
jsr pc,allocate
mov 4(sp),r0 /new
jsr pc,swap
jsr pc,release
mov r0,r1
mov 0(sp),r0 /old
1:
mov a(r1),w(r1) /rewind w pointer
cmp r2,$512.
blos copy1 /is a short string
/
jsr pc,flush
jsr pc,reset
/
mov a(r0),-(sp)
4:
mov (sp),0f
mov afi,r0
sys seek;0:.. ;0 /set input pointer
cmp r2,$512.
blos 2f
mov $512.,r3 /# output this time
mov r3,0f
mov r3,3f
add r3,(sp)
sub r3,r2 /# left to output
br 1f
2:
mov r2,0f
mov r2,3f
mov r2,r3
clr r2
1:
mov afi,r0
sys read;b1;0:..
bes bad
cmp r0,r3
bne bad
mov afout,r0
mov (r1),0f
add r3,(r1)
sys seek;0:.. ;0
sys write;b1;3:..
bes bad
tst r2
bgt 4b
tst (sp)+
/
/ fix up read ptr of new string
/
copy2:
mov 6(sp),r0 /restore r0
mov r(r0),r2
sub a(r0),r2
add a(r1),r2
mov r2,r(r1)
/
/ restore and return
/
mov (sp)+,r3
mov (sp)+,r2
mov (sp)+,r1
mov (sp)+,r0
rts pc
/
bad: mov $1,r0
sys write;1f;2f-1f
4
1: <error on copy\n>
2: .even
/
swap:
mov w(r1),-(sp)
mov w(r0),w(r1)
mov (sp),w(r0)
mov r(r1),(sp)
mov r(r0),r(r1)
mov (sp),r(r0)
mov a(r1),(sp)
mov a(r0),a(r1)
mov (sp),a(r0)
mov l(r1),(sp)
mov l(r0),l(r1)
mov (sp)+,l(r0)
rts pc
/
/ copy a short string
/
copy1:
mov r(r0),-(sp)
mov a(r0),r(r0)
mov nchar,-(sp)
mov r0,r2 /old
mov r1,r3 /new
1:
mov r2,r1
jsr pc,getchar
bes 1f
mov r3,r1
jsr pc,putchar
br 1b
1:
mov r2,r0
mov (sp)+,nchar
mov (sp)+,r(r0)
mov r3,r1
br copy2
/
/
/
/
/
/ routine to rewind read pointer of string
/ pointed to by r1
/
/ mov ...,r1
/ jsr pc,rewind
/
rewind:
mov a(r1),r(r1)
rts pc
/
/
/ routine to rewind write pointer of string
/ pointed to by r1
/
/ mov ...,r1
/ jsr pc,create
/
create:
mov a(r1),w(r1)
mov a(r1),r(r1)
rts pc
/
/
/ routine to zero a string
/
/ mov ...,r1
/ jsr pc,zero
/
zero:
mov r0,-(sp)
.if testing
jsr pc,preposterous
.endif
mov a(r1),w(r1)
clrb r0
1: cmp w(r1),l(r1)
bhis 1f
jsr pc,putchar
br 1b
1: mov a(r1),w(r1)
mov (sp)+,r0
rts pc
/
/
/
/ routine to move the read pointer of a string to the
/ relative position indicated by r0. the string is
/ extended if necessary - there is no error return.
/
/ mov position,r0
/ mov ...,r1
/ jsr pc,seekchar
/
seekchar:
mov r1,-(sp)
mov r0,-(sp)
.if testing
jsr pc,preposterous
.endif
inc stats+10.
1:
mov (sp),r0
add a(r1),r0
cmp r0,l(r1)
bhi 3f
mov r0,r(r1)
cmp r0,w(r1)
blo 1f
mov r0,w(r1)
br 1f
3:
mov (sp),r0
jsr pc,allocate
mov 2(sp),r0
jsr pc,copy
jsr pc,swap
jsr pc,release
mov 2(sp),r1
br 1b
1:
mov (sp)+,r0
mov (sp)+,r1
rts pc
/
/
/ routine to move read pointer of string to end of string
/
/ mov ...,r1
/ jsr pc,fsfile
/
fsfile:
mov r0,-(sp)
.if testing
jsr pc,preposterous
.endif
inc stats+10.
mov w(r1),r(r1)
mov (sp)+,r0
rts pc
/
/
/ routine to place the character in r0 at the current
/ position of the read pointer - the read pointer
/ is not moved.
/
/ movb ch,r0
/ mov ...,r1
/ jsr pc,alterchar
/ mov r1,...
/
alterchar:
mov r2,-(sp)
mov r1,-(sp)
mov r0,nchar
.if testing
jsr pc,preposterous
.endif
inc stats+8.
1: cmp r(r1),l(r1) /W,L
blo 3f
mov l(r1),r0
inc r0
sub a(r1),r0 /W-A+1
jsr pc,allocate
mov (sp),r0
jsr pc,copy
jsr pc,swap
jsr pc,release
mov (sp),r1
3:
mov r(r1),r0
jsr pc,bufchar
bec 2f
jsr pc,getbuf
2: movb nchar,(r0)
mov $1,w1(r2)
mov nchar,r0 /to preserve r0 for user
inc r(r1)
cmp r(r1),w(r1)
blos 3f
mov r(r1),w(r1)
3:
mov (sp)+,r1
mov (sp)+,r2
rts pc
/
/
/ routine to look at next character from string
/ pointed to by r1; character returned in r0
/ c-bit set if character not available (end of file)
/ r1 is preserved
/
/ mov ...,r1
/ jsr pc,lookchar
/ movb r0,...
/
lookchar:
mov r2,-(sp)
inc stats+6.
.if testing
jsr pc,preposterous
.endif
cmp w(r1),r(r1) /W,R
blos noch
mov r(r1),r0
jsr pc,bufchar
bec 2f
jsr pc,getbuf
/
2:
inc flag
bne 2f
jsr pc,fixct
br 1f
2:
mov flag,u1(r2)
1:
mov (sp)+,r2
movb (r0),r0
tst r0 /clears c-bit
rts pc
/
noch:
mov (sp)+,r2
clr r0
sec
rts pc
/
/
/ routine to put a character into the string
/ pointed to by r1; character in r0
/ r0 is preserved; r1 points to the string
/ after return and must be saved.
/
/ movb ch,r0
/ mov ...,r1
/ jsr pc,putchar
/ mov r1,...
/
putchar:
mov r2,-(sp)
mov r1,-(sp)
mov r0,nchar
.if testing
jsr pc,preposterous
.endif
inc stats+8.
1: cmp w(r1),l(r1) /W,L
blo 3f
mov w(r1),r0
inc r0
sub a(r1),r0 /W-A+1
jsr pc,allocate
mov (sp),r0
jsr pc,copy
jsr pc,swap
jsr pc,release
mov (sp),r1
3:
mov w(r1),r0
jsr pc,bufchar
bec 2f
jsr pc,getbuf
2: movb nchar,(r0)
mov $1,w1(r2)
mov nchar,r0 /to preserve r0 for user
inc w(r1)
inc flag
bne 2f
jsr pc,fixct
br 1f
2:
mov flag,u1(r2)
1:
mov (sp)+,r1
mov (sp)+,r2
rts pc
/
/
/ routine to flush contents of all buffers.
/
/ jsr pc,flush
/
flush:
mov r1,-(sp)
mov r2,-(sp)
mov r3,-(sp)
clr r3
1:
cmp r3,$numb
bhis 1f
mov r3,r2
asl r2
tst w1(r2)
ble 2f
mov r3,r1
ashc $9.,r1
bic $777,r1
add $b1,r1
jsr pc,clean
2:
inc r3
br 1b
1:
mov (sp)+,r3
mov (sp)+,r2
mov (sp)+,r1
rts pc
/
/
reset:
mov r3,-(sp)
mov r2,-(sp)
clr r3
1:
cmp r3,$numb
bge 1f
mov r3,r2
asl r2
mov $-1.,w1(r2)
clr b1s(r2)
clr b1e(r2)
clr u1(r2)
inc r3
br 1b
1:
clr flag
mov (sp)+,r2
mov (sp)+,r3
rts pc
/
/
/ routine to read from disc to a buffer
/ wcing the buffer if necessary
/
/ mov disc addr,r0
/ mov buffer addr,r2
/ jsr pc,getb
/
/ on return r0 = addr of byte in buffer
/
getb:
mov r3,-(sp)
mov r1,-(sp)
mov r0,-(sp)
mov r2,r3
asr r3
mov r3,r1
ashc $9.,r1
bic $777,r1
add $b1,r1
tst w1(r2) / w
ble 1f
jsr pc,clean
1: mov (sp),r0
bic $777,r0 /get lowest multiple of 512.
mov r0,0f
mov r0,b1s(r2) /set start
mov afi,r0
sys seek;0:..;0
mov r1,0f
sys read;0:..;512.
mov b1s(r2),b1e(r2)
add $512.,b1e(r2) / set end
clr w1(r2) /clear w
mov (sp)+,r0
sub b1s(r2),r0
add r1,r0 / set r0=byte addr in buffer
mov (sp)+,r1
mov (sp)+,r3
rts pc
/
/
/ routine to wc a buffer
/
/ mov buffer addr,r2
/ mov buffer addr+6,r1 beginning of buffer
/ jsr pc,clean
/
clean:
inc stats+24.
mov r0,-(sp)
mov b1s(r2),0f
mov afout,r0
sys seek;0:..;0
mov r1,0f
sys write;0:..;512.
clr w1(r2) /clear w
mov (sp)+,r0
rts pc
/
/
/ routine to get buffer addr of byte whose disc
/ addr is in r0 - also returns addr of write
/ flag for buffer in r2
/
/ mov disc addr,r0
/ jsr pc,bufchar
/ mov (r0),r0 for read
/ inc (r2) for write must inc w
/
/ c-bit set if char not in either buffer
/
bufchar:
mov r1,-(sp)
mov r3,-(sp)
clr r3
1:
mov r3,r2
asl r2
cmp r0,b1s(r2)
blo 2f
cmp r0,b1e(r2)
bhis 2f
sub b1s(r2),r0
mov r3,r1
ashc $9.,r1
bic $777,r1
add r1,r0
add $b1,r0
mov (sp)+,r3
mov (sp)+,r1
clc
rts pc
2:
inc r3
cmp r3,$numb
blt 1b
mov (sp)+,r3
mov (sp)+,r1
sec
rts pc
/
/
/ routine to get a buffer
/
/ mov disc addr,r0
/ jsr pc,getbuf
/ mov (r0),r0 (for read)
/ inc (r2) must inc w for w
/
getbuf:
mov r4,-(sp)
mov r3,-(sp)
mov $2,r3
clr r2
mov $1,r4
1:
cmp r4,$numb
bge 1f
cmp u1(r3),u1(r2)
bhis 2f
mov r3,r2
2:
inc r4
add $2.,r3
br 1b
1:
mov r2,r3
jsr pc,getb
add $stats+14.,r3
inc (r3)
mov (sp)+,r3
mov (sp)+,r4
rts pc
/
/
/ this routine renumbers the time used cell u1(r2)
/ of the buffers when the clock overflows
/
fixct:
mov r1,-(sp)
mov r3,-(sp)
mov $numb,r1
mov $numb,flag
2:
mov r1,u1(r2)
dec r1
bge 1f
mov (sp)+,r3
mov (sp)+,r1
rts pc
1:
clr r2
mov $2,r3
1:
cmp r3,$numb2
bge 2b
cmp u1(r3),u1(r2)
blo 2f
mov r3,r2
2:
add $2,r3
br 1b
b
bge 1f
cmp u1(r3),u1(r2)
bhis 2f
mov r3,r2
2:
inc r4
add $2.,r3
br 1b
1:
mov r2,r3
jsr pc,getb
add $stats+14.,r3
inc (r3)
mov (sp)+,r3
mov (sp)+,r4
rts pc
/
/
/ this routine renumbers the time used cell u1(r2)
/ of the buffers when the clock overflows
/
fixct:
mov r1,-(sp)
mov r3,-(sp)
mov $numb,r1
mov $numb,flag
2:
mov r1,u1(r2)
dec r1
bge 1f
mov (sp)+,r3
mov (sp)+,r1
rts pc
1:
clr r2
mov $2,r3
1:
cmp r3,$numb2
bge 2b
cmp u1(r3),u1(r2)
blo 2f
mov r3,r2
2:
add $2,r3
br 1b

456
src/cmd/form6.s Normal file
View File

@@ -0,0 +1,456 @@
.globl b1
.globl log2
.globl frlist
.globl stats
.globl b1s
.globl b1e
.globl w1
/ here to allocate a new block
/
/
/ mov ...,r0
/ jsr pc,allocate
/ mov r1,...
/
/ requested size in bytes in r0
/ pointer to header of allocated block returned in r1
/ r0 is preserved
/
/ convert to words, adjust for header, round up
/ to a power of two
/
/ each block has a four-word header
/ W - write ptr (also used as link ptr in frlist)
/ R - read ptr
/ A - pointer to head of data
/ L - ptr to (end+1) of data
hsz=6144.
datasz = 32768.
numb=4.
numb2=2*numb
W=0
R=2
A=4
L=6
/
allocate:
clr garbage
mov r0,-(sp)
mov r2,-(sp)
mov r3,-(sp)
inc stats
bne 9f; inc stats; 9:
cmp r0,$datasz
blo 9f; 4; 9:
dec r0
bmi 1f
jsr pc,log2
inc r0
1: asl r0
mov r0,-(sp)
add $2,r0
cmp r0,$frend-frlist+2
blo zzz
4
/
/ look on free list for block of required size
/
zzz:
mov (sp),r0
tst frlist(r0)
beq xxx
/
/ found it, allocate and return
/
mov frlist(r0),r1
add $hblk,r1
mov (r1),frlist(r0)
mov a(r1),r0
mov r0,w(r1) /W
mov r0,r(r1) /R
tst (sp)+
mov (sp)+,r3
mov (sp)+,r2
mov (sp)+,r0
/ jsr pc,whead
rts pc
/
/ no block of required size
/ look for larger block
/
xxx:
tst hblk
beq www
tst (r0)+
cmp r0,$frend-frlist
bhis www
tst frlist(r0)
bne yyy
br xxx
/
/ there are no larger blocks; must garbage collect
/
www: jsr pc,collect
tst r0
bne zzz
/
/ out of space
/
mov $1,r0
sys write; 1f; 2f-1f
jmp interrupt
1: <Out of space.\n>
2: .even
/
/ split larger block into two smaller pieces and
/ link together as smaller blocks in the free list.
/
yyy:
mov hblk,r3 /get free header block
beq www /should never get this
mov frlist(r0),r1
add $hblk,r1
mov w(r1),frlist(r0)
mov r3,w(r1)
add $hblk,r3
mov exp2-2(r0),r2
add a(r1),r2
mov w(r3),hblk
mov l(r1),l(r3)
mov r2,l(r1) /L
mov r2,a(r3)
clr w(r3) /W'
mov r1,r2
sub $hblk,r2
mov r2,frlist-2(r0)
br zzz
/
/
/ here to release a block
/
/ mov ...,r1
/ jsr pc,release
/
/ pointer to block in r1
/
release:
/
/ discover that this is a plausible pointer
/
mov r0,-(sp)
jsr pc,preposterous
/
/ find free list index and link block to that entry
/
inc stats+2
mov frlist(r0),w(r1)
clr r(r1)
sub $hblk,r1
mov r1,frlist(r0)
clr r1 /self-defense
mov (sp)+,r0
rts pc
/
/
/ jsr pc,collect
/
/ coalesce free storage by rejoining paired blocks
/ on the free list.
/ zero is returned in r0 if no paired blocks were found.
/
collect:
mov r1,-(sp)
mov r2,-(sp)
mov r3,-(sp)
mov r4,-(sp)
clr useful
inc stats+4.
clr r0 /start with smallest blocks
/r0 contains frlist index
loop1: mov $frlist,r1
add r0,r1
/
/ try next list member at this level
/
loop2: mov (r1),r3
beq advance /list is empty
add $hblk,r3
tst (r3) /W
beq advance /only one list element
/
/ calculate address of buddy
/
mov a(r3),r4
sub $hsz,r4
mov exp2(r0),r2
xor r2,r4
1: add $hsz,r4
/
/ and search for him
/
loop3:
cmp a(r3),r4
beq coal
mov r3,r2
mov w(r3),r3
tst r3
beq nocoal
add $hblk,r3
br loop3
/
/ have found a pair; remove both blocks from list,
/ coalesce them, and put them on next higher list
/
coal: mov $1,useful
mov w(r3),w(r2) /remove him from list
mov (r1),r2
add $hblk,r2
mov r3,r4
mov w(r2),w(r1) /remove other one
cmp a(r2),a(r4)
bhi 1f
mov r2,-(sp)
mov r4,r2
mov (sp)+,r4
1: mov hblk,(r2)
clr r(r2)
mov $hsz,a(r2)
mov $hsz,l(r2)
sub $hblk,r2
mov r2,hblk
add exp2(r0),l(r4) /L
clr r(r4)
mov frlist+2(r0),w(r4)
sub $hblk,r4
mov r4,frlist+2(r0)
br loop2
/
/ no buddy found, try next block on this list
/
nocoal:
mov (r1),r1
add $hblk,r1
br loop2
/
/ advance to next free list
/
advance:
tst (r0)+
cmp r0,$frend-frlist
blo loop1
mov useful,r0
/
/ do we have enough headers to continue?
/
tst garbage
beq 1f
mov $1,r0
sys write; 4f; 5f-4f
4
/
4: <Out of headers.\n>
5: .even
/
/
/ restore registers and return
/
1:
inc garbage
mov (sp)+,r4
mov (sp)+,r3
mov (sp)+,r2
mov (sp)+,r1
rts pc
/
garbage:.=.+2
/
/ routine to find integer part of log2(x)
/
/ jsr pc,log2
/
/ r0 = log2(r0)
/
log2:
mov $15.,-(sp)
tst r0
bne 1f
clr (sp)
br 2f
1: asl r0
bcs 2f
dec (sp)
br 1b
2: mov (sp)+,r0
rts pc
/
0
exp2:
1;2;4;10;20;40;100;200;400;1000;2000;4000;
10000;20000;40000;100000
/
/ routine to discover whether r1 points to
/ a plausible header - to avoid ruination.
/
/ r1 is preserved and r0 gets a suitable index for frlist
/
/ jsr pc,preposterous
/
preposterous:
cmp r1,$headers
bhis 9f; 4; 9:
cmp r1,$headend
blo 9f; 4; 9:
cmp a(r1),$hsz /A
bhis 9f; 4; 9:
cmp l(r1),$hsz+datasz /L
blos 9f; 4; 9:
mov l(r1),r0 /L
sub a(r1),r0 /A
mov r0,-(sp)
jsr pc,log2
asl r0
cmp exp2(r0),(sp)
beq 9f; 4; 9:
add $2,r0
cmp r0,$frend-frlist+2
blo 9f; 4; 9:
sub $2,r0
mov r0,(sp)
mov frlist(r0),r0
1: beq 1f
add $hblk,r0
cmp r0,r1
bne 9f; 4; 9:
mov (r0),r0
br 1b
1: mov (sp)+,r0
rts pc
/
/
/
whead:
inc stats+22.
mov r0,-(sp)
mov afout,r0
sys seek; 0; 0
sys write; hblk; hsz
mov (sp)+,r0
rts pc
/
/
initl:
clr hblk
mov r0,-(sp)
mov r2,-(sp)
sys open;almem; 1 /open for write
bec 2f
sys creat;almem; 17
bes err2
inc hblk
2:
mov r0,afout
sys open; almem; 0 /open for read
bes err2
mov r0,afi
br 1f
/
err2:
mov $1,r0
sys write; 4f; 5f-4f
4
.data
4: <cannot open output file\n>
5:
almem: <form.m\0>
.even
.text
/
1:
tst hblk
bgt 1f
sys read; hblk; hsz /r0 already afi
mov asmdisc,asmem
add $hblk,asmem
br 2f
1:
mov $headers,r2
mov r2,r0
sub $hblk,r0
mov r0,hblk
1:
add $8,r0
mov r0,(r2)
add $8,r2
cmp r2,$headend-8.
blo 1b
clr -8(r2)
mov $frlist,r0
1:
clr (r0)+
cmp r0,$frend
blo 1b
mov hblk,r2
add $hblk,r2
mov (r2),hblk
clr w(r2)
mov $hsz,a(r2)
mov $hsz+datasz,l(r2)
mov $datasz,r0
jsr pc,log2
asl r0
cmp r0,$frend-frlist
blo 9f; 4; 9:
sub $hblk,r2
mov r2,frlist(r0)
/
/ install plausible pointers to make octal dumps look nice
/
mov $hblk,r1
1:
mov (r1),r1
tst r1
beq 1f
add $hblk,r1
mov $hsz,a(r1)
mov $hsz,l(r1)
mov $hsz,r(r1)
br 1b
1:
mov afout,r0
sys write;hblk;hsz
jsr pc,reset
mov $4,r0
jsr pc,allocate
mov r1,asmem
mov r1,asmdisc
sub $hblk,asmdisc
2:
mov (sp)+,r2
mov (sp)+,r0
rts pc
/
/
.bss
/
b1s: .=.+numb2
b1e: .=.+numb2
w1: .=.+numb2
u1: .=.+numb2
b1: .=. + [512.*numb]
flag: .=.+2
stats: .=.+24. /alloc/release/collect/get/put/seek/copy
useful: .=.+2
afi: .=.+2
afout: .=.+2
asmem: .=.+2
nchar: .=.+2
/
/
hblk: .=.+2 /must remain here - pointer to free header
frlist: .=hblk+34.
frend:
asmdisc:.=.+2
headers: .=hblk+hsz
headend:
.text

200
src/cmd/fstrip.s Normal file
View File

@@ -0,0 +1,200 @@
/ fstrip -- remove fortran internal symbols
.globl fopen
.globl getw
.globl putw
.globl flush
mov (sp)+,argc
tst (sp)+
br loop
unloop:
sys unlink; s.tmp
loop:
dec argc
bgt 1f
sys exit
1:
mov (sp)+,r4
mov r4,r0
jsr r5,fopen; ibuf
bcc 1f
jsr r5,mesg; <open error: \0>; .even
br loop
1:
mov $'a,r1
1:
movb r1,s.tmp+8
sys stat; s.tmp; obuf
bec 2f
sys creat; s.tmp; 10
bec 1f
2:
inc r1
cmp r1,$'z
blos 1b
jsr r5,mesg; <can't create temp file for \0>; .even
sys exit
1:
mov r0,obuf
clr obuf+2
clr obuf+4
jsr r5,getw; ibuf
cmp r0,magic
beq 1f
jsr r5,mesg; <improper format: \0>; .even
br unloop
1:
jsr r5,putw; obuf
jsr r5,getw; ibuf
mov r0,r2
jsr r5,putw; obuf
jsr r5,getw; ibuf
add r0,r2
jsr r5,putw; obuf
jsr r5,getw; ibuf
jsr r5,putw; obuf
jsr r5,getw; ibuf
jsr r5,putw; obuf
jsr r5,getw; ibuf
jsr r5,putw; obuf
jsr r5,getw; ibuf
jsr r5,putw; obuf
jsr r5,getw; ibuf
cmp r0,$1
bne 9f
asr r2 / no relocation
9:
jsr r5,putw; obuf
1:
jsr r5,getw; ibuf
bcc 2f
jsr r5,mesg; <unexpected EOF: \0>; .even
sys exit
2:
jsr r5,putw; obuf
dec r2
bne 1b
clr r2
1:
jsr r5,getsym
bcs 1f
cmpb symbol+1,$'0
blo 3f / not digit
cmpb symbol+1,$'9
bhi 3f
cmpb symbol,$'t
beq 1b
cmpb symbol,$'d
beq 1b
cmpb symbol,$'c
beq 1b
3:
jsr r5,putsym
add $14,r2
br 1b
1:
jsr r5,flush; obuf
mov obuf,r0
sys close
mov ibuf,r0
sys close
mov r4,0f
sys creat; 0:..; 0 / same mode as before
bec 1f
jsr r5,mesg; <can't rewrite: \0>; .even
jmp unloop
1:
mov r0,ibuf
sys open; s.tmp; 0
bec 1f
jsr r5,mesg; <can't read temp file for: \0>; .even
sys exit
1:
mov r0,ibuf+2
sys read; obuf; 512.
mov r2,obuf+10 / new data
br 2f
1:
mov ibuf+2,r0
sys read; obuf; 512.
2:
mov r0,0f
beq 1f
mov ibuf,r0
sys write; obuf; 0:..
br 1b
1:
mov ibuf,r0
sys close
mov ibuf+2,r0
sys close
jmp unloop
mesg:
movb (r5)+,ch
beq 1f
mov $1,r0
sys write; ch; 1
br mesg
1:
inc r5
bic $1,r5
mov r4,r1
1:
movb (r1)+,ch
beq 1f
mov $1,r0
sys write; ch; 1
br 1b
1:
mov $1,r0
sys write; qnl; 1
rts r5
getsym:
mov r5,-(sp)
mov $symbol,r5
mov $6,-(sp)
1:
jsr r5,getw; ibuf
bcs 2f
mov r0,(r5)+
dec (sp)
bne 1b
tst (sp)+
mov (sp)+,r5
rts r5
2:
tst (sp)+
mov (sp)+,r5
sec
rts r5
putsym:
mov r5,-(sp)
mov $symbol,r5
mov $6,-(sp)
1:
mov (r5)+,r0
jsr r5,putw; obuf
dec (sp)
bne 1b
tst (sp)+
mov (sp)+,r5
rts r5
s.tmp:
</tmp/stma\0>
qnl:
<\n>
.even
magic:
br .+20
.bss
argc: .=.+2
symbol: .=.+14
ibuf: .=.+518.
obuf: .=.+518.
ch: .=.+2

179
src/cmd/getty.s Normal file
View File

@@ -0,0 +1,179 @@
/ getty -- get name and tty mode
/ for initialization
/ cycle through speeds and "login:" messages
/ summarized in itab
stty = 31.
sys quit; 0
sys intr; 0
0:
jsr r5,nextspeed
1:
mov $name,r5
2:
jsr r5,getc
cmp r0,$174
beq 5f
cmp r0,$176
beq 5f
cmp r0,$'\n
beq 1f
cmp r0,$'\r
beq 4f
cmp r0,$'@
beq 1b
cmp r0,$'#
bne 3f
cmp r5,$name
blos 2b
dec r5
br 2b
3:
movb r0,(r5)+
br 2b
4:
bis $20,flags /cr bit
mov $1,r0
sys write; nl; 1
br 2f
5:
mov $tab2741,itabp
inc nowr
br 0b
1:
mov $1,r0
sys write; cr; 1
2:
clrb (r5)+
/ determine whether terminal is upper-case only
cmp r5,$name+1
bhi 1f
bic $4,flags /no data-assume lc
1:
mov $name,r5
1:
movb (r5)+,r0
beq 1f
cmp r0,$'A
blo 2f
cmp r0,$'Z
bhi 2f
add $40,r0 / map to lc
movb r0,-1(r5)
br 1b
2:
cmp r0,$'a
blo 1b
cmp r0,$'z
bhi 1b
bic $4,flags
br 1b
1:
clr r0
mov fstate,r4
bis flags,4(r4)
sys stty; fstate: ..
go:
sys exec; login; loginp
sys exit
getc:
clr r0
sys read; ch; 1
tst r0
beq done
mov ch,r2
beq 1f
getc1:
cmp r2,$174
bhis 3f
tst nowr
bne 3f
mov $1,r0
sys write; ch; 1
3:
mov r2,r0
rts r5
1:
dec $0 / wait a while
bne 1b
mov $name,(sp)
jsr r5,nextspeed
2:
clr r0 / flush nulls
sys read; ch; 1
tst r0
beq done
movb ch,r2
beq 2b
br getc1
done:
sys exit
nextspeed:
mov itabp,r1
mov (r1)+,0f
bne 1f
mov $itab,itabp
br nextspeed
1:
clr r0
sys stty; 0:..
bes go
mov (r1)+,-(sp)
mov (r1)+,fstate
mov r1,itabp
mov (sp)+,r1
1:
movb (r1)+,ch
beq 1f
mov $1,r0
sys write; ch; 1
br 1b
1:
rts r5
itabp: itab
loginp: login
name
0
itab:
itty37; ttymes; tty37
itn300; tnmes; tn300
tab2741: i2741; m2741; f2741
0
itty37: 511; 511; 340 / any parity, raw, 150 baud
tty37: 511; 511; 210 / 37 parity, echo, 150 baud
itn300: 521; 521; 340 / any parity, raw, cr, 300 baud
tn300: 521; 521; 310 / any parity, echo, 300 baud
i2741: 1501; 501; 100540 /134 bits, 2741, raw, first time
f2741: 1501; 501; 500 /134 bps, 2741
0
m2741: <\nlogin: \0>
ttymes:
<\n\r\p:\alogin: \0>
tnmes:
<\n\r\p;login: \0>
login: </bin/login\0>
.even
nl: <\n>
cr: <\r>
flags: 004 / upper case map
.bss
ch: .=.+2
nowr: .=.+2
name: .=.+32.

193
src/cmd/glob.c Normal file
View File

@@ -0,0 +1,193 @@
/* global command --
glob params
"*" in params matches r.e ".*"
"?" in params matches r.e. "."
"[...]" in params matches character class
"[...a-z...]" in params matches a through z.
perform command with argument list
constructed as follows:
if param does not contain "*", "[", or "?", use it as is
if it does, find all files in current directory
which match the param, sort them, and use them
prepend the command name with "/bin" or "/usr/bin"
as required.
*/
char ab[2000]; /* generated characters */
char *ava[200]; /* generated arguments */
char **av ava;
char *string ab;
main(argc, argv)
char *argv[];
{
int i, j, c;
int inode, dirf, ap;
int fb[5], sb[17];
char *cp, *cpo;
if (argc < 3) {
write(1, "Arg count\n", 10);
return;
}
ap = 0;
av++;
fb[4] = 0;
loop:
cpo = cp = *++argv;
while(c = *cp++) if (c=='*' | c=='?' | c=='[') goto compl;
av[ap++] = copy(cpo);
if (--argc>=2) goto loop;
goto donow;
compl:
if(*--cp == '/') {
*cp = '\0';
if((dirf=open(cp==cpo? "/" : cpo, 0))<0)
goto oper;
*cp++ = '/';
goto compl1;
}
if(cp != cpo) goto compl;
if((dirf=open(".",0)) >= 0) goto compl1;
oper:
write(1, "No directory\n", 13);
return;
compl1:
j = ap;
l2:
while (read(dirf, &inode, 2)>0) {
read(dirf, fb, 8);
if (inode==0) goto l2;
if (match(fb, cp)) {
c = *cp;
*cp = '\0';
av[ap++] = cat(cpo, fb);
*cp = c;
}
}
close(dirf);
i = j;
while(i<ap-1) {
j = i;
while(++j<ap) {
if (compar(av[i],av[j])) {
c = av[i];
av[i] = av[j];
av[j] = c;
}
}
i++;
}
if (--argc>=2) goto loop;
donow:
if (ap<=1) {
write(1, "No match\n", 9);
return;
}
av[ap] = 0;
execv(av[0], av);
i = cat("/bin/", av[0]);
execv(i, av);
i = cat("/usr", i);
execv(i, av);
if (stat(i, sb) == 0) {
*av = i;
*--av = "/bin/sh";
execv(av[0], av);
}
write(1, "No command\n", 11);
}
match(s, p)
char *s, *p; {
if (*s=='.' & *p!='.') return(0);
return(amatch(s, p));
}
amatch(s, p)
char *s, *p;
{
int c, cc, ok, lc, scc;
scc = *s;
lc = 077777;
switch (c = *p) {
case '[':
ok = 0;
while (cc = *++p) {
switch (cc) {
case ']':
if (ok)
return(amatch(++s, ++p));
else
return(0);
case '-':
ok =| lc <= scc & scc <= (cc=p[1]);
}
if (scc==(lc=cc)) ok++;
}
return(0);
case '?':
caseq:
if(scc) return(amatch(++s, ++p));
return(0);
case '*':
return(umatch(s, ++p));
case 0:
return(!scc);
}
if (c==scc) goto caseq;
return(0);
}
umatch(s, p)
char *s, *p;
{
if(*p==0) return(1);
while(*s)
if (amatch(s++,p)) return(1);
return(0);
}
compar(s1,s2)
char *s1, *s2;
{
int c1,c2;
loop:
if ((c1 = *s1++)==0) return(0);
if ((c2 = *s2++)==0) return(1);
if (c1==c2) goto loop;
return(c1>c2);
}
copy(s1)
char *s1;
{
char *ts;
ts = string;
while(*string++ = *s1++);
return(ts);
}
cat(s1, s2)
char *s1, *s2;
{
char *ts;
ts = string;
while(*string++ = *s1++);
string--;
while(*string++ = *s2++);
return(ts);
}

64
src/cmd/goto.c Normal file
View File

@@ -0,0 +1,64 @@
int offset 0;
main(argc, argv)
char *argv[];
{
extern fin;
char line[64];
fin = dup(0);
if (!gtty(0, line) | argc<=1) {
write(1, "goto error\n", 11);
seek(0, 0, 2);
return;
}
seek(0, 0, 0);
loop:
if (getlin(line)) {
write(1, "label not found\n", 16);
return;
}
if (compar(line, argv[1])) goto loop;
seek(0, offset, 0);
}
getlin(s)
char s[];
{
int ch, i;
i = 0;
l:
if ((ch=getc())=='\0') return(1);
if (ch!=':') {
while(ch!='\n' & ch!='\0')
ch = getc();
goto l;
}
while ((ch=getc())==' ');
while (ch!=' ' & ch!='\n' & ch!='\0') {
s[i++] = ch;
ch = getc();
}
s[i] = '\0';
return(0);
}
compar(s1, s2)
char s1[], s2[];
{
int c, i;
i = 0;
l:
if(s1[i] != s2[i]) return(1);
if (s1[i++] == '\0') return(0);
goto l;
}
getc()
{
offset++;
return(getchar());
}

99
src/cmd/if.c Normal file
View File

@@ -0,0 +1,99 @@
/* if command */
int ap;
int ac;
char **av;
main(argc, argv)
char *argv[];
{
int np, i, c;
char *nargv[50], *ncom, *na, *nxtarg();
ac = argc;
av = argv;
if (ac<2) return;
ap = 1;
if (exp()) {
np = 0;
while (na=nxtarg())
nargv[np++] = na;
nargv[np] = 0;
if (np==0) return;
execv(nargv[0], nargv, np);
i = 0;
ncom = "/usr/bin/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
while(c=nargv[0][i]) {
ncom[9+i++] = c;
}
ncom[9+i] = '\0';
execv(ncom+4, nargv, np);
execv(ncom, nargv, np);
write(1, "no command\n", 11);
seek(0, 0, 2);
}
}
char *nxtarg() {
if (ap>ac) return(0*ap++);
return(av[ap++]);
}
exp(s) {
int p1;
p1 = e1();
if (eq(nxtarg(), "-o")) return(p1 | exp());
ap--;
return(p1);
}
e1() {
int p1;
p1 = e2();
if (eq(nxtarg(), "-a")) return (p1 & e1());
ap--;
return(p1);
}
e2() {
if (eq(nxtarg(), "!"))
return(!e3());
ap--;
return(e3());
}
e3() {
int p1;
char *a;
if ((a=nxtarg())==0) goto err;
if(eq(a, "(")) {
p1 = exp();
if(!eq(nxtarg(), ")")) goto err;
return(p1);
}
if(eq(a, "-r"))
return(tio(nxtarg(), 0));
if(eq(a, "-w"))
return(tio(nxtarg(), 1));
if(eq(a, "-c"))
return(tcreat(nxtarg()));
p1 = nxtarg();
if (p1==0) goto err;
if(eq(p1, "="))
return(eq(a, nxtarg()));
if(eq(p1, "!="))
return(!eq(a, nxtarg()));
err:
write(1, "if error\n", 9);
exit();
}

208
src/cmd/init.s Normal file
View File

@@ -0,0 +1,208 @@
/ init -- process control initialization
sys intr; 0
sys quit; 0
sys 38. / get console switches
cmp r0,$173030
bne 1f
help:
clr r0
sys close
mov $1,r0
sys close
sys open; ctty; 0
sys open; ctty; 1
sys exec; shell; shellp
br help
1:
sys mount; rk1; usr
sys mount; rk2; ssys
sys mount; rk3; crp
mov $'0,r1
1:
movb r1,tapx+8
sys chmod; tapx; 17
inc r1
cmp r1,$'8
blo 1b
sys creat; utmp; 16
sys close
sys unlink; dpdlock
sys fork
br daemon
sys fork
br dirass
sys fork
br dds
movb $'x,zero+8.
jsr pc,wtmprec
mov $itab,r1
br 1f
daemon:
sys exec; etcdpd; etcdpdp
sys exit
dirass:
sys chdir; usrmel
sys exec; melda; meldap
sys exit
dds:
sys exec; usrdd; usrddp
sys exit
/ create shell processes
1:
mov (r1)+,r0
beq pwait
movb r0,ttyx+8
jsr pc,dfork
mov r0,(r1)+
br 1b
/ wait for process to die
pwait:
sys wait
mov $itab,r1
/ search for process id
2:
tst (r1)+
beq pwait
cmp r0,(r1)+
bne 2b
/ take name out of utmp
sub $4,r1
mov r1,-(sp)
mov (r1),r1
sub $'0,r1
cmp r1,$'a-'0
blo 2f
sub $'a-'0-10.,r1 / map a-z into 10. on
2:
asl r1
asl r1
asl r1
asl r1
mov r1,0f
mov $zero,r1
2:
clr (r1)+
cmp r1,$zero+16.
blo 2b
sys open; utmp; 1
bes 2f
mov r0,r1
sys seek; 0:..; 0
mov r1,r0
sys write; zero; 16.
mov r1,r0
sys close
/ re-create user process
2:
mov (sp)+,r1
mov (r1)+,r0
movb r0,ttyx+8
movb r0,zero+8.
jsr pc,wtmprec
jsr pc,dfork
mov r0,(r1)+
br pwait
dfork:
sys fork
br 1f
bes dfork
rts pc
1:
sys quit; 0
sys intr; 0
sys chown; ttyx; 0
sys chmod; ttyx; 15
sys open; ttyx; 0
bes help1
sys open; ttyx; 1
bes help1
sys exec; getty; gettyp
sys exit / HELP!
help1:
jmp help
wtmprec:
mov r1,-(sp)
sys time
mov r0,zero+10.
mov r1,zero+12.
sys open; wtmp; 1
bes 2f
mov r0,r2
sys seek; 0; 2
mov r2,r0
sys write; zero; 16.
mov r2,r0
sys close
2:
mov (sp)+,r1
rts pc
etcdpdp:
etcdpd; 0
meldap:
melda; 0
usrddp:
usrdd; 0
usrdd: </usr/demo/dds\0>
melda: </usr/mel/da\0>
usrmel: </usr/mel\0>
rk1: </dev/rk1\0>
rk2: </dev/rk2\0>
rk3: </dev/rk3\0>
usr: </usr\0>
ssys: </sys\0>
crp: </crp\0>
ctty: </dev/tty\0>
shell: </bin/sh\0>
shellm: <-\0>
dpdlock:
</usr/dpd/lock\0>
etcdpd:
</etc/dpd\0>
tapx: </dev/tapx\0>
utmp: </tmp/utmp\0>
wtmp: </tmp/wtmp\0>
ttyx: </dev/ttyx\0>
getty: </etc/getty\0>
.even
shellp: shellm
0
gettyp: getty
0
itab:
'0; ..
'1; ..
'2; ..
'3; ..
'4; ..
'5; ..
'6; ..
'7; ..
'8; ..
'a; ..
'b; ..
0
.bss
offset: .=.+2
zero: .=.+8.; .=.+6; .=.+2.

475
src/cmd/ld1.s.part1 Normal file
View File

@@ -0,0 +1,475 @@
/ ld1 -- link editor
orig:
sys intr; sintr
mov (sp)+,r0
dec r0
bgt 1f
sys exit
1:
mov r0,argc
mov sp,argp
1:
jsr r5,nxtarg
br pass2
jsr r5,load1
br 1b
pass2:
sys creat; l.out; 017
bec 1f
clr filnam
jsr r5,mesg; outfile
sys exit
1:
mov r0,fout
mov txtsiz,r1
mov datsiz,r2
mov r1,r3
add r2,r3 / bss origin
clr r4
mov $symtab,r5
1:
cmp r5,esymp
bhis 1f
cmp 10(r5),$40 / undefined
bne 2f
mov 12(r5),r0 / common?
beq 2f / no
mov r4,12(r5) / common origin
add r3,12(r5)
inc r0
bic $1,r0 / even
add r0,r4 / new common origin
mov $47,10(r5) / temp. common type
2:
add $14,r5
br 1b
1:
add r4,bsssiz
mov $symtab,r5
1:
cmp r5,esymp
bhis 1f
cmp 10(r5),$43
blt 2f / undef, abs or text
beq 3f
cmp 10(r5),$47 / common
bne 4f
mov $44,10(r5) / set bss
br 2f
4:
add r2,12(r5) / bss
add r4,12(r5) / common total
3:
add r1,12(r5) / data
2:
add $14,r5
br 1b
1:
mov r1,fdatorg
mov r3,fbssorg
add r4,fbssorg
mov symsiz,locsymsiz
add esymp,symsiz
sub $symtab,symsiz
tst sqflg
beq 1f
clr symsiz
1:
jsr r5,oattach; otxtp; zero
add $20,oattpt
jsr r5,oattach; odatp; txtsiz
tst relflg / suppress relocation?
bne 1f
jsr r5,oattach; otrelp; datsiz
jsr r5,oattach; odrelp; txtsiz
1:
jsr r5,oattach; osymp; datsiz
tst entptr
beq 1f
tst exorig
beq 2f
jsr r5,mesg; mulent / too many entry points
2:
mov entptr,r0
mov 12(r0),exorig
inc exorig / 0 entry means none
1:
mov $7,-(sp)
mov $magic,r1 / write magic at start
tst sqflg
beq 1f
clr symsiz
1:
mov (r1)+,r0
jsr r5,putwrd; otxtp
1:
mov (r1)+,r0
jsr r5,putwrd; otxtp
dec (sp)
bne 1b
tst (sp)+
clr txtsiz
clr datsiz
clr bsssiz
clr *rlistp
mov $rlist,rlistp
1:
jsr r5,nxtarg2
br 1f
jsr r5,load2
br 1b
1:
jsr r5,flush; otxtp
jsr r5,flush; odatp
tst relflg
bne 1f
jsr r5,flush; otrelp
jsr r5,flush; odrelp
1:
mov $symtab,r1
1:
cmp r1,esymp
bhis 1f
cmp 10(r1),$40
bne 2f
mov r1,r0
clr filnam
jsr r5,smesg; undmes
2:
tst sqflg
beq 3f
add $14,r1
br 1b
3:
mov $6,r2
2:
mov (r1)+,r0
jsr r5,putwrd; osymp
dec r2
bne 2b
br 1b
1:
jsr r5,flush; osymp
done:
sys unlink; a.out
sys link; l.out; a.out
bec 1f
clr filnam
jsr r5,mesg; movemes
sys exit
1:
sys unlink; l.out
sys chmod; a.out; outmod: 37
sys exit
sintr:
sys unlink; l.out
sys exit
load1:
mov txtsiz,txtorg
mov datsiz,datorg
sub ctxtsiz,datorg
mov bsssiz,bssorg
sub ctxtsiz,bssorg
sub cdatsiz,bssorg
mov $14,locsymsiz
clr ndef
mov r5,-(sp)
mov esymp,-(sp)
mov $local,r5
jsr r5,attach; txtp; csymorg
1:
jsr r5,getsym
bvs 1f
cmp symbol+10,$40
bge 2f / external
tst xtflg
bne 1b
add $14,locsymsiz / count locals
br 1b
2:
jsr r5,lookup
mov (r4),r0
beq 2f / not yet in table
cmp 10(r0),$40
bgt 1b / multiply defined
inc ndef / remember def occurred
cmp symbol+10,$40
bgt 3f
dec ndef / forget def occurred
cmp 12(r0),symbol+12 / extend common region?
bge 1b
br 3f
2:
mov r4,(r5)+
jsr r5,enter
cmp symbol+10,$40
ble 1b / undefined symbol
3:
jsr r5,relsym
mov (r4),r0
mov symbol+10,10(r0)
mov symbol+12,12(r0)
br 1b
1:
tst libflg / load anyway if not library
beq 1f
tst ndef / load library if any definitions
bne 1f
mov (sp)+,esymp / rip out symbols
2:
cmp r5,$local / see if end of entered symbols
blos 2f
clr *-(r5) / rip out hash entry
br 2b
1:
tst (sp)+
tst entry
beq 1f
add txtorg,entry
tst exorig
beq 5f
jsr r5,mesg; mulent
5:
mov entry,exorig
1:
add locsymsiz,symsiz / total of local symbs
mov rlistp,r0
cmp r0,$rliste
blo 1f
jsr r5,mesg; toomany
jmp done
1:
mov reopened,r1
bne 1f
mov *argp,r1
cmp r1,$libfil
bne 1f
movb wlib,r1 / library, just remember letter name
1:
mov r1,(r0)+
mov libflg,(r0)+ / remember start of routine
beq 3f / not library
bis $1,reopened
3:
mov r0,rlistp
jsr r5,addin
2:
mov (sp)+,r5
rts r5
load2:
mov txtsiz,txtorg
mov fdatorg,r0
add datsiz,r0
sub ctxtsiz,r0
mov r0,datorg
mov fbssorg,r0
add bsssiz,r0
sub ctxtsiz,r0
sub cdatsiz,r0
mov r0,bssorg
mov r5,-(sp)
jsr r5,attach; txtp; csymorg
mov $local,r5
mov $-1,-(sp) / local symbol index
mov filnam,r1
2:
tstb (r1)+
bne 2b
2:
cmp r1,filnam
blos 2f
cmpb -(r1),$'/
bne 2b
tstb (r1)+
2:
mov $symbol,r0
2:
movb (r1)+,(r0)+
bne 3f
tstb -(r1)
3:
cmp r0,$symbol+8.
blo 2b
mov $37,symbol+10
mov txtorg,symbol+12
tst sqflg
bne 1f
jsr r5,wrlocsym
1:
jsr r5,getsym
bvs 1f
jsr r5,relsym
inc (sp)
cmp symbol+10,$40
blo 5f
jsr r5,lookup
tst (r4)
bne 6f
jsr r5,mesg; snotfound
br 1b
6:
cmp symbol+10,$40
bgt 2f
beq 4f
5:
tst xtflg
bne 1b / skip locals
jsr r5,wrlocsym / write local symbol
br 1b
2:
mov (r4),r0
cmp 10(r0),symbol+10
bne 2f
cmp 12(r0),symbol+12
beq 4f
2:
jsr r5,smesg; multi
4:
cmp r5,$elocal
blo 3f
jsr r5,mesg; locovflo
jmp done
3:
mov (sp),(r5)+ / save local index
mov (r4),(r5)+ / save symbol location
br 1b
1:
mov r5,locp
tst (sp)+
jsr r5,attach; txtp; ctxtorg
jsr r5,attach; relp; ctrelorg
mov txtsiz,relbas
1:
jsr r5,txtlod
br 1f
tst relflg
bne 2f
jsr r5,putwrd; otrelp
2:
mov r3,r0
jsr r5,putwrd; otxtp
br 1b
1:
jsr r5,attach; txtp; cdatorg
jsr r5,attach; relp; cdrelorg
mov datorg,r0
mov r0,relbas
mov r5,locp
mov (sp)+,r5
1:
jsr r5,txtlod
br 1f
tst relflg
bne 2f
jsr r5,putwrd; odrelp
2:
mov r3,r0
jsr r5,putwrd; odatp
br 1b
1:
jsr r5,addin
rts r5
txtlod:
jsr r5,getwrd; txtp
bvs 1f
tst (r5)+
mov r0,r3
jsr r5,getwrd; relp
bvc 2f
jsr r5,mesg; relerr
sys exit
2:
mov r0,r2
bic $1,r2
bic $!17,r0
cmp r0,$7
blos 3f
/ external symbol reference
clc
ror r2
asr r2
asr r2
asr r2 / get symbol number
jsr r5,lookloc / get symbol
cmp 10(r4),$40
bgt 2f
/ still undefined
sub $symtab,r4
add locsymsiz,r4
mov r5,-(sp)
mov r4,r5
clr r4
dvd $14,r4
als $4,r4
bis r4,r0
mov (sp)+,r5
br relrel
2:
/ symbol now defined
add 12(r4),r3 / symbol value
mov 10(r4),r2
sub $41,r2
bic $!1,r0
bne 4f
tst r2
beq 5f / not relative & relocatable
add dotdot,r3
br 5f
4:
tst r2
bne 5f / relative & absolute
sub dotdot,r3
5:
asl r2
bis r2,r0
br relrel
/ absolute, text, data, or bss symbol
3:
add *reltab(r2),r3
relrel:
bit $1,r0
beq 1f
sub relbas,r3 / relative relocation
1:
rts r5
wrlocsym:
mov $symbol,r1
mov $6,-(sp)
3:
mov (r1)+,r0
jsr r5,putwrd; osymp / write out local symbol
dec (sp)
bne 3b
tst (sp)+
rts r5
dd 12(r4),r3 / symbol value
mov 10(r4),r2
sub $41,r2
bic $!1,r0
bne 4f
tst r2
beq 5f / not relative & relocatable
add dotdot,r3
br 5f
4:
tst r2
bne 5f / relative & absolute
sub dotdot,r3
5:
asl r2
bis r2,r0
br relrel
/ absolute, text, data, or bss symbol
3:
add *reltab(r2),r3
relrel:
bit $1,r0
beq 1f
sub rel

560
src/cmd/ld2.s.part1 Normal file
View File

@@ -0,0 +1,560 @@
/ ld2 -- link editor
attach:
mov (r5)+,r1 / buffer
mov (r5)+,r2 / file origin, size
mov (r2),0f / seek ptr
mov fin,r0
sys seek; 0:..; 0
mov (r2),r0
bis $777,r0
inc r0 / start of next block
add $10,r1
mov r1,-(sp)
add $1000,(sp) / buf max
mov r0,-(r1) / next seek ptr
mov (sp),-(r1)
sub (r2)+,r0 / left in buffer
sub r0,(sp) / next buffer word
mov (sp),-(r1)
mov (sp)+,0f / buffer loc
cmp (r2),r0
bge 1f
mov (r2),r0
1:
mov r0,0f+2 / number to read
mov (r2),-(r1) / left in file
jsr r5,rdchk; 0:..; ..
rts r5
rdchk:
mov (r5)+,0f
mov (r5)+,0f+2
mov fin,r0
sys read; 0:..; ..
bes 1f
cmp r0,0b+2
bne 1f
rts r5
1:
jsr r5,mesg; premeof
jmp sintr
getwrd:
mov (r5)+,r1
sub $2,(r1)+ / left in file
bge 1f
sev / end of file
rts r5
1:
mov (r1)+,r2 / word ptr
cmp r2,(r1)+ / eob ptr
bhis 1f / end of buffer
mov (r2)+,r0
mov r2,-4(r1)
rts r5
1:
mov (r1),0f
mov fin,r0
sys seek; 0:..; 0
add $1000,(r1)+ / new seek ptr
mov r1,0f
mov -10(r1),r0 / left in file
add $2,r0
cmp r0,$1000
ble 1f
mov $1000,r0 / read 1000 at most
1:
mov r0,0f+2
jsr r5,rdchk; 0:..; ..
mov (r1)+,r0
mov r1,-10(r1) / new next word
rts r5
oattach:
mov (r5)+,r1
mov (r5)+,r2
mov oattpt,r0
add (r2),r0
mov r0,oattpt
mov r0,r2
bic $!777,r0
add r1,r0
add $6,r0
mov r0,(r1)+ / next slot
mov r1,r0
add $1004,r0
mov r0,(r1)+ / buf max
mov r2,(r1)+ / seek addr
rts r5
putwrd:
mov r1,-(sp)
mov r2,-(sp)
mov (r5)+,r2
mov (r2)+,r1 / slot
cmp r1,(r2) / buf max
bhis 1f
mov r0,(r1)+
mov r1,-(r2)
br 2f
1:
tst (r2)+
mov r0,-(sp)
jsr r5,flush1
mov (sp)+,*(r2)+
add $2,-(r2)
2:
mov (sp)+,r2
mov (sp)+,r1
rts r5
flush:
mov (r5)+,r2
cmp (r2)+,(r2)+
flush1:
mov (r2)+,r1
mov r1,0f / seek address
mov fout,r0
sys seek; 0:..; 0
bic $!777,r1
add r2,r1 / write address
mov r1,0f
mov r2,r0
bis $777,-(r2)
inc (r2) / new seek addr
cmp -(r2),-(r2)
sub (r2),r1
neg r1
mov r1,0f+2 / count
mov r0,(r2) / new next slot
mov fout,r0
sys write; 0:..; ..
rts r5
lookup:
mov $symbol,r1
mov (r1)+,r0
add (r1)+,r0
add (r1)+,r0
add (r1)+,r0
mov r0,r1
clr r0
dvd $hshsiz,r0
mov r1,r4
asl r4
add $hshtab,r4
1:
mov (r4)+,r0
beq 3f / not found
mov $symbol,r1
cmp (r1)+,(r0)+
bne 2f
cmp (r1)+,(r0)+
bne 2f
cmp (r1)+,(r0)+
bne 2f
cmp (r1)+,(r0)+
bne 2f
3:
tst -(r4)
rts r5
2:
cmp r4,$2*hshsiz+hshtab
blo 1b
mov $hshtab,r4
br 1b
enter:
mov esymp,r0
add $14,r0
cmp r0,0f
blo 1f
add $500.,r0
mov r0,0f
sys break; 0:symtab
1:
mov esymp,r0
mov r0,(r4)
mov $symbol,r1
mov $6,-(sp)
1:
mov (r1)+,(r0)+
dec (sp)
bne 1b
mov r0,esymp
tst (sp)+
rts r5
smesg:
mov r1,-(sp)
mov r0,-(sp)
jsr pc,1f
tst filnam
beq 2f
mov $1,r0
sys write; qsemi; 1
2:
mov (sp)+,r1
mov $8.,-(sp)
3:
movb (r1)+,ch
beq 4f
mov $1,r0
sys write; ch; 1
4:
dec (sp)
bne 3b
tst (sp)+
mov (sp)+,r1
br 2f
mesg:
jsr pc,1f
mov $1,r0
2:
sys write; qnl; 1
rts r5
1:
mov $17,outmod / make a.out nonexecutable
mov r1,-(sp)
mov (r5)+,r1
1:
movb (r1)+,ch
beq 1f
mov $1,r0
sys write; ch; 1
br 1b
1:
mov filnam,r1
beq 9f
1:
movb (r1)+,ch
beq 1f
mov $1,r0
sys write; ch; 1
br 1b
1:
9:
mov (sp)+,r1
rts pc
getsym:
mov $6,-(sp)
mov $symbol,r4
1:
jsr r5,getwrd; txtp
bvs 2f
mov r0,(r4)+
dec (sp)
bne 1b
tst (sp)+
rts r5
2:
tst (sp)+
sev
rts r5
nxtarg2:
mov rlistp,r1
add $4,rlistp
mov (r1)+,r0
beq 1f / end of args
cmp r0,$177 / see if system library
bhi 2f
cmp r0,$1 / see if archive
beq 3f
movb r0,wlib
mov $libfil,r0
2:
jsr r5,aopen
br nxtarg2
3:
mov (r1),libflg
beq 2f
sub $20,(r1)
mov (r1),0f
mov fin,r0
sys seek; 0:..; 0
2:
mov fin,r0
sys read; arcmag; 40
bes bform1
cmp r0,$20
blt bform1
mov $arcmag,r4
tst (r1)+
beq filstrt
cmp r0,$40
bne bform1
br libstrt
1:
rts r5
bform1:
jmp bform
nxtarg:
add libnxt,libflg / see if library
beq advarg / no
mov libflg,0f
mov fin,r0
sys seek; 0:..; 0
mov fin,r0
sys read; arcmag+2; 40 / get arc header, seg hdr
mov $arcmag+2,r4
add $20,libflg
cmp r0,$40
beq libstrt / not end of libr
advarg:
dec argc
bge 1f
rts r5
1:
mov argp,r1
tst (r1)+
mov r1,argp
cmpb *(r1),$'-
bne opnarg
jsr r5,specarg
br advarg
opnarg:
clr libflg
clr libnxt
mov *argp,r0
clr reopened
jsr r5,aopen
br advarg
mov fin,r0
sys read; arcmag; 42 / read arc header if any, file hdr
bes bform
mov r0,r3
mov $arcmag,r4
add r4,r3
cmp r3,$arcmag+20
blo bform
cmp (r4),arcmagic
bne filstrt
cmp r3,$arcmag+42
blo bform
tst (r4)+
mov $22,libflg
libstrt:
mov 16(r4),r0 / next library start
inc r0
bic $1,r0
mov r0,libnxt
clr 14(r4) / end of name
mov r4,filnam / archive entry name
add $20,r4 / point to file start
filstrt:
cmp (r4)+,magic / see if object file
bne bform
mov $ctxtorg,r1
mov libflg,r2 / text origin in file
add $20,r2 / skip header
mov (r4)+,r0
mov r2,(r1)+ / text origin
mov r0,(r1)+ / text size
add r0,r2
mov (r4)+,r0
mov r2,(r1)+ / data origin
mov r0,(r1)+ / data size
add r0,r2
mov (r4)+,(r1)+ / bss size
mov r2,(r1)+ / text reloc origin
mov ctxtsiz,(r1) / text reloc size
add (r1)+,r2
mov r2,(r1)+ / data reloc origin
mov cdatsiz,(r1) / data size
add (r1)+,r2
mov (r4)+,r0
mov r2,(r1)+ / symbol table origin
mov r0,(r1)+ / symbol table size
mov (r4)+,r0 / stack size
cmp r0,stksiz
blo 1f
mov r0,stksiz
1:
mov (r4)+,entry / entry
tst (r4)+ / relocation suppressed?
beq 1f
jsr r5,mesg; norel
rts r5
1:
tst (r5)+
rts r5
bform:
jsr r5,mesg; format
jmp sintr
specarg:
mov (r1),r0
movb 1(r0),r0
cmpb r0,$'u
beq use
cmpb r0,$'l
beq libarg
cmpb r0,$'x
beq xtsym
cmpb r0,$'e
beq entarg
cmpb r0,$'r
beq savrel
cmpb r0,$'s
beq squash
rts r5
squash:
inc sqflg
inc xtflg
rts r5
savrel:
clr relflg
rts r5
xtsym:
inc xtflg
rts r5
libarg:
movb $'a,wlib
mov (r1),r1
movb 2(r1),r0
beq 1f
movb r0,wlib
1:
mov $libfil,*argp
tst (r5)+
rts r5
entarg:
clr r4
jsr r5,use
mov (r4),entptr
rts r5
use:
dec argc
blt 2f
add $2,argp
mov *argp,r0
mov $symbol,r1
mov $8.,-(sp)
1:
movb (r0)+,(r1)+
beq 1f
dec (sp)
bgt 1b
1:
dec (sp)
ble 1f
clrb (r1)+
br 1b
1:
tst (sp)+
mov $40,(r1)+
clr (r1)+
jsr r5,lookup
tst (r4)
bne 2f
jsr r5,enter
2:
rts r5
relsym:
mov symbol+10,r0
bic $!37,r0
beq 1f
cmp r0,$5
bhis 1f
asl r0
add *reltab-2(r0),symbol+12
1:
rts r5
lookloc:
mov $local,r4
1:
cmp r4,locp
bhis 1f
cmp (r4)+,r2
beq 2f
tst (r4)+
br 1b
1:
jsr r5,mesg; snotfound
jmp sintr
2:
mov (r4),r4
rts r5
aopen:
clr reopened
mov r0,0f
mov r0,filnam
mov fin,r0
beq 1f
sys close
1:
sys open; 0:..; 0
bec 1f
jsr r5,mesg; fnotfound
rts r5
1:
mov r0,fin
tst (r5)+
rts r5
addin:
add ctxtsiz,txtsiz
add cdatsiz,datsiz
add cbsssiz,bsssiz
rts r5
mov symbol+10,r0
bic $!37,r0
beq 1f
cmp r0,$5
bhis 1f
asl r0
add *reltab-2(r0),symbol+12
1:
rts r5
lookloc:
mov $local,r4
1:
cmp r4,locp
bhis 1f
cmp (r4)+,r2
beq 2f
tst (r4)+
br 1b
1:
jsr r5,mesg; snotfound
jmp sintr
2:
mov (r4),r4
rts r5
aopen:
clr reopened
mov r0,0f
mov r0,filnam
mov fin,r0
beq 1f
sys close
1:
sys open; 0:..; 0
bec 1f
jsr r5,mesg; fnotfound
rts r5
1:
mov r0,fin
tst (r5)+

130
src/cmd/ldx.s Normal file
View File

@@ -0,0 +1,130 @@
/ ldx -- link editor
a.out:
<a.out\0>
l.out:
<l.out\0>
undmes:
<un: \0>
movemes:
<Can't move output file\0>
norel:
<No relocation bits: \0>
toomany:
<Too many routines loaded at: \0>
multi:
<Multiply defined: \0>
locovflo:
<Too many symbols in: \0>
relerr:
<Relocation error in: \0>
premeof:
<Premature EOF on: \0>
outfile:
<ld: can't create l.out\n\0>
fnotfound:
<File not found: \0>
format:
<Format error: \0>
snotfound:
<Symbol not found: \0>
mulent:
<Multiple entry point:\0>
libfil:
</lib/lib>
wlib:
<a>
<.a\0>
qnl:
<\n>
qsemi:
<;>
.even
dotdot: ..
zero: 0
rlistp: rlist
esymp: symtab
reltab:
zero
txtorg
datorg
bssorg
arcmagic:
-147.
magic:
br .+20
txtsiz: .=.+2
datsiz: .=.+2
bsssiz: .=.+2
symsiz: .=.+2
stksiz: .=.+2
exorig: .=.+2
relflg: 1
.bss
libflg: .=.+2
sqflg: .=.+2
entptr: .=.+2
entry: .=.+2
xtflg: .=.+2
txtorg: .=.+2
datorg: .=.+2
bssorg: .=.+2
fdatorg: .=.+2
fbssorg: .=.+2
ctxtorg:.=.+2
ctxtsiz:.=.+2
cdatorg:.=.+2
cdatsiz:.=.+2
cbsssiz: .=.+2
ctrelorg:.=.+2
ctrelsiz:.=.+2
cdrelorg:.=.+2
cdrelsiz:.=.+2
csymorg: .=.+2
csymsiz: .=.+2
arcmag: .=.+42
argc: .=.+2
argp: .=.+2
oattpt: .=.+2
locp: .=.+2
locsymsiz:.=.+2
fout: .=.+2
fin: .=.+2
reopened:.=.+2
ndef: .=.+2
ch: .=.+2
filnam: .=.+2
relbas: .=.+2
libnxt: .=.+2
symbol: .=.+14
txtp: .=.+10+512.
relp: .=.+10+512.
otxtp: .=.+6+512.
odatp: .=.+6+512.
osymp: .=.+6+512.
otrelp: .=.+6+512.
odrelp: .=.+6+512.
rlist: .=.+512.
rliste:
local: .=.+1024.
elocal:
hshsiz = 1000.
hshtab: .=2*hshsiz+.
symtab:
esymtab = orig+16384.-300.

49
src/cmd/ln.s Normal file
View File

@@ -0,0 +1,49 @@
/ link command
ln:
mov sp,r5
cmp (r5)+,$2
bhis 1f
sys exit
1:
beq 1f
tst (r5)+
mov (r5)+,0f
mov (r5),0f+2
br 2f
1:
tst (r5)+
mov (r5),0f
mov (r5),r4
1:
tstb (r4)+
bne 1b
1:
cmpb -(r4),$'/
beq 1f
cmp (r5),r4
bne 1b
br err
1:
inc r4
mov r4,0f+2
2:
mov 0f,2f
sys stat; 2:..; stbuf
bes err
bit $40000,stbuf+2
bne err
sys link; 0:..; ..
bes err
sys exit
err:
mov $1,r0
sys write; quest; 2
sys exit
quest:
<?\n>
.bss
stbuf: .=.+40.

280
src/cmd/login.s Normal file
View File

@@ -0,0 +1,280 @@
/ login -- enter new user
.globl ttyn
.globl crypt
.globl fopen
.globl getc
.globl mesg
sys quit; 0
sys intr; 0
jsr pc,ttyn
movb r0,ttyx+8.
sub $'0,r0
cmp r0,$'a-'0
blo 1f
sub $'a-'0-10.,r0 / map a-z into 10. on
1:
asl r0
asl r0
asl r0
asl r0
mov r0,offset
mov (sp)+,r5
tst (sp)+
dec r5
ble login
mov (sp)+,r4
mov $uname,r1
2:
movb (r4)+,(r1)+
bne 2b
dec r5
ble login
mov (sp)+,r4
mov $passwd,r1
2:
movb (r4)+,(r1)+
bne 2b
login:
clrb uname+8.
mov $passwdf,r0
jsr r5,fopen; pbuf
bec 1f
jsr r5,mesg; <Can't open password file\n\0>; .even
sys exit
1:
jsr pc,guname
1:
jsr r5,compar; uname
br .+4
br 2f
3:
jsr r5,getc; pbuf
bes sorry
cmp r0,$'\n
bne 3b
br 1b
sorry:
jsr r5,mesg; <Login incorrect\n\0>; .even
mov pbuf,r0
sys close
clr uname
clr passwd
br login
2:
jsr r5,getc; pbuf
cmp r0,$':
beq 2f
mov r0,-(sp)
jsr pc,gpasswd
cmpb (r0)+,(sp)+
bne sorry
mov r0,0f
jsr r5,compar; 0:..
br sorry
2:
clr r1
2:
jsr r5,getc; pbuf
cmp r0,$':
beq 2f
mpy $10.,r1
sub $'0,r0
add r0,r1
br 2b
2:
mov r1,0f
sys chown; ttyx; 0:..
mov r1,uid
1:
jsr r5,getc; pbuf
cmp r0,$':
bne 1b / skip ident field
mov $dirbuf,r1
1:
jsr r5,getc; pbuf
cmpb r0,$':
beq 1f
movb r0,(r1)+
br 1b
1:
clrb (r1)
sys chdir; dirbuf
bec 1f
jsr r5,mesg; <No directory\n\0>; .even
br sorry
1:
mov $uname+8.,r1
1:
tstb -(r1)
bne 1f
movb $' ,(r1)
br 1b
1:
cmpb ttyx+8.,$'x
beq 1f
sys open; utmp; 1
bes 1f
mov r0,r2
sys seek; offset:..; 0
movb ttyx+8.,uname+8.
sys time
mov r0,uname+10.
mov r1,uname+12.
mov r2,r0
sys write; uname; 16.
mov r2,r0
sys close
1:
cmpb ttyx+8.,$'x
beq 1f
sys open; wtmp; 1
bes 1f
mov r0,r1
sys seek; 0; 2
sys write; uname; 16.
mov r1,r0
sys close
1:
jsr r5,getc; pbuf
cmp r0,$'\n
beq 1f
mov $shell,r1
2:
movb r0,(r1)+
jsr r5,getc; pbuf
cmp r0,$'\n
bne 2b
clrb (r1)
1:
mov pbuf,r0
sys close
mov $motd,r0
jsr r5,fopen; pbuf
bes 1f
2:
jsr r5,getc; pbuf
bes 1f
mov r0,uname
mov $1,r0
sys write; uname; 1
br 2b
1:
mov pbuf,r0
sys close
sys stat; mailf; pbuf
bes 1f
tst pbuf+6
beq 1f
jsr r5,mesg; <You have mail\n\0>; .even
1:
mov uid,r0
sys setuid
sys exec; shell; shellp
jsr r5,mesg; <No Shell\n\0>; .even
sys exit
gpasswd:
mov $passwd,r1
tstb (r1)
bne 3f
clr r0
sys gtty; ttyb
bic $10,ttyb+4 / turn off echo
clr r0
sys stty; ttyb
jsr r5,mesg; <Password: \0>; .even
2:
jsr pc,tgetc
movb r0,(r1)+
beq 1f
cmp r1,$passwd+9.
blo 2b
dec r1
br 2b
1:
bis $10,ttyb+4 / turn on echo
clr r0
sys stty; ttyb
jsr r5,mesg; <\n\0>; .even
3:
mov $passwd,r0
jsr pc,crypt
clrb 8(r0)
rts pc
guname:
mov $uname,r1
tstb (r1)
bne 1f
clr (r1)+
clr (r1)+
clr (r1)+
clr (r1)+
mov $uname,r1
jsr r5,mesg; <Name: \0>; .even
2:
jsr pc,tgetc
movb r0,(r1)+
beq 1f
cmp r1,$uname+9.
blo 2b
dec r1
br 2b
1:
rts pc
compar:
mov (r5)+,r4
1:
jsr r5,getc; pbuf
bes 2f
cmpb r0,(r4)+
beq 1b
cmp r0,$':
bne 1f
tstb -(r4)
bne 1f
tst (r5)+
1:
rts r5
2:
tst (sp)+
jmp sorry
tgetc:
clr r0
sys read; ch; 1
tst r0
bne 1f
sys exit
1:
mov ch,r0
cmp r0,$'\n
bne 1f
clr r0
1:
rts pc
shellp:
mshell
0
utmp: </tmp/utmp\0>
wtmp: </tmp/wtmp\0>
shell: </bin/sh\0>; .=shell+32.
mshell: <-\0>
motd: </etc/motd\0>
mailf: <mailbox\0>
passwdf:</etc/passwd\0>
ttyx: </dev/ttyx\0>
.even
.bss
uname: .=.+16.
passwd: .=.+8.
dirbuf: .=.+32.
shbuf: .=.+32.
ttyb: .=.+6
uid: .=.+2
ch: .=.+2
pbuf: .=.+518.

23
src/cmd/mak Executable file
View File

@@ -0,0 +1,23 @@
echo acct.s; as acct.s; mv a.out acct
echo ar.s; as ar.s; mv a.out ar
echo cat.s; as cat.s; mv a.out cat
echo chmod.s; as chmod.s; mv a.out chmod
echo chown.s; as chown.s; mv a.out chown
echo cmp.s; as cmp.s; mv a.out cmp
echo colon.s; as colon.s; mv a.out :
echo date.s; as date.s; mv a.out date
echo df.s; as df.s; mv a.out df
echo dsw.s; as dsw.s; mv a.out dsw
echo dusg.s; as dusg.s; mv a.out dusg
echo fstrip.s; as fstrip.s; mv a.out fstrip
echo getty.s; as getty.s; mv a.out getty
echo init.s; as init.s; mv a.out init
echo ln.s; as ln.s; mv a.out ln
echo login.s; as login.s; mv a.out login
echo ls.s; as ls.s; mv a.out ls
echo as1: as as1?.s; mv a.out as1
#echo as2: as as2?.s; mv a.out as2
#echo bas; as bas?.s; mv a.out bas
echo db; as db?.s; mv a.out db
#echo dc; as dc?.s; mv a.out dc
#echo form; as form?.s; mv a.out form

80
src/cmd/unknown.c Normal file
View File

@@ -0,0 +1,80 @@
char b[242];
char c[60];
int nread 1;
char buf[512];
main(argc,argv) int argc; char *argv[]; {
int l,isw,k,ifile,i,j;
if(--argc <= 0)
{ifile = 0;
argc = 0;
goto newl;
}
l = 1;
while(argc--)
{printf("%s:\n \n",argv[l]);
ifile = open(argv[l++],0);
if(ifile < 0)
{printf("cannot open input file\n");
exit();
}
newl:
isw = j = 0;
i = -1;
cont:
while((b[++i] = get(ifile)) != 0)
{if((b[i] >= 'a' & b[i] <= 'z') |
(b[i] >= 'A' & b[i] <= 'Z'))
{c[j++] = b[i];
goto cont;
}
if(b[i] == '-')
{c[j++] = b[i];
if((b[++i] = get(ifile)) != '\n')
{c[j++] = b[i];
goto cont;
}
if(j == 1)goto newl;
isw = 1;
i = -1;
while(((b[++i] = get(ifile)) == ' ')
| (b[i] == '\t') | (b[i] == '\n'));
c[j++] = b[i];
goto cont;
}
if(b[i] == '\n'){if(isw != 1)goto newl;
i = -1; }
if(isw == 1)
{k = 0;
c[j++] = '\n';
while(k < j)putchar(c[k++]);
}
isw = j = 0;
}
}
}
get(ifile) int ifile;{
char *ibuf;
static ibuf;
if(--nread){
return(*ibuf++);}
if(nread = read(ifile,buf,512)){
if(nread < 0)goto err;
ibuf = buf;
return(*ibuf++);
}
nread = 1;
return(0);
err:
nread = 1;
printf("read error\n");
return(0);
}