Research V5 development
authorKen Thompson <ken@research.uucp>
Tue, 26 Nov 1974 23:13:21 +0000 (18:13 -0500)
committerKen Thompson <ken@research.uucp>
Tue, 26 Nov 1974 23:13:21 +0000 (18:13 -0500)
Work on file usr/source/s4/dup.s
Work on file usr/source/s4/putchr.s
Work on file usr/source/s2/od.c
Work on file usr/source/s1/fed3.s
Work on file usr/source/s3/compar.s
Work on file usr/source/s1/ld2.s
Work on file usr/source/s4/getuid.s
Work on file usr/source/s3/fp3.s
Work on file usr/source/s2/typo.c

Co-Authored-By: Dennis Ritchie <dmr@research.uucp>
Synthesized-from: v5

usr/source/s1/fed3.s [new file with mode: 0644]
usr/source/s1/ld2.s [new file with mode: 0644]
usr/source/s2/od.c [new file with mode: 0644]
usr/source/s2/typo.c [new file with mode: 0644]
usr/source/s3/compar.s [new file with mode: 0644]
usr/source/s3/fp3.s [new file with mode: 0644]
usr/source/s4/dup.s [new file with mode: 0644]
usr/source/s4/getuid.s [new file with mode: 0644]
usr/source/s4/putchr.s [new file with mode: 0644]

diff --git a/usr/source/s1/fed3.s b/usr/source/s1/fed3.s
new file mode 100644 (file)
index 0000000..7d76a07
--- /dev/null
@@ -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
diff --git a/usr/source/s1/ld2.s b/usr/source/s1/ld2.s
new file mode 100644 (file)
index 0000000..fa2c45c
--- /dev/null
@@ -0,0 +1,548 @@
+/ 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     $2,errcnt
+       mov     $666,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
+       cmpb    r0,$'n
+       beq     new
+       cmpb    r0,$'d
+       beq     sdcom
+       rts     r5
+
+squash:
+       inc     sqflg
+       inc     xtflg
+       rts     r5
+
+savrel:
+       clr     relflg
+       inc     clrelflg
+       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
+
+new:
+       inc     nflg
+       rts     r5
+
+sdcom:
+       inc     dcom
+       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
+       mov     $4,r0
+       sys     exit
+1:
+       mov     r0,fin
+       tst     (r5)+
+       rts     r5
+
+addin:
+       add     ctxtsiz,txtsiz
+       add     cdatsiz,datsiz
+       add     cbsssiz,bsssiz
+       rts     r5
+
+issymbol:
+       mov     r1,-(sp)
+       mov     (r0)+,r1
+       cmp     (r1)+,(r5)
+       bne     1f
+       cmp     (r1)+,2(r5)
+       bne     1f
+       cmp     (r1)+,4(r5)
+       bne     1f
+       cmp     (r1)+,6(r5)
+       beq     2f
+1:
+       tst     (r0)+
+2:
+       mov     (sp)+,r1
+       rts     r0
diff --git a/usr/source/s2/od.c b/usr/source/s2/od.c
new file mode 100644 (file)
index 0000000..b0e943a
--- /dev/null
@@ -0,0 +1,614 @@
+int    word[16];
+char   gbuf[512];
+int    fi;
+int    conv;
+int    base    010;
+int    basem   01000;
+int    max;
+int    gidx;
+int    gcnt;
+int    eof;
+int    addr[2];
+int    from[2];
+int    key;
+int    flag;
+int    nword   8;
+
+main(argc, argv)
+char **argv;
+{
+       extern fout;
+       int f, k, w, i, a[2];
+       char *p;
+
+       fout = dup(1);
+       argv++;
+       if(argc > 1) {
+               p = *argv;
+               if(*p == '-') {
+                       while((i = *p++) != '\0') {
+                               switch(i) {
+                               case 'o':
+                                       conv =| 001;
+                                       f = 6;
+                                       break;
+                               case 'd':
+                                       conv =| 002;
+                                       f = 5;
+                                       break;
+                               case 'a':
+                                       conv =| 004;
+                                       f = 4;
+                                       break;
+                               case 'h':
+                                       conv =| 010;
+                                       f = 4;
+                                       break;
+                               case 'c':
+                                       conv =| 020;
+                                       f = 5;
+                                       break;
+                               case 'b':
+                                       conv =| 040;
+                                       f = 7;
+                                       break;
+                               }
+                               if(f > max)
+                                       max = f;
+                       }
+                       argc--;
+                       argv++;
+               }
+       }
+       if(!conv) {
+               max = 6;
+               conv = 1;
+       }
+       if(argc > 1)
+       if(**argv != '+') {
+               fi = open(*argv, 0);
+               if(fi < 0) {
+                       printf("cannot open %s\n", *argv);
+                       goto done;
+               }
+               argv++;
+               argc--;
+       }
+       if(argc > 1)
+               offset(*argv);
+
+loop:
+       f = 1;
+       a[0] = addr[0];
+       a[1] = addr[1];
+       for(i=0; i<nword; i++) {
+               w = getw();
+               if(eof)
+                       break;
+               word[i] = w;
+               if(i)
+                       f =& w==k; else
+                       k = w;
+       }
+       if(i)
+       if(f && !eof) {
+               if(!(flag && k==key)) {
+                       dupl();
+                       key = k;
+                       from[0] = a[0];
+                       from[1] = a[1];
+               }
+               flag =+ i;
+       } else {
+               dupl();
+               line(a, word, i);
+       }
+       if(!eof)
+               goto loop;
+       puta(addr);
+       putchar('\n');
+
+done:
+       flush();
+}
+
+dupl()
+{
+
+       if(flag) {
+               flag = 0;
+               line(from, &key, 1);
+       }
+}
+
+puta(a)
+int a[2];
+{
+
+       putn(a[0], base, 4);
+       putn(a[1], base, 3);
+       putchar(' ');
+}
+
+line(a, w, n)
+int w[];
+{
+       int i, f, c;
+
+       f = 1;
+       for(c=1; c; c=+c) {
+               if((c&conv) == 0)
+                       continue;
+               if(f) {
+                       puta(a);
+                       f = 0;
+               } else
+                       for(i=0; i<8; i++)
+                               putchar(' ');
+               for(i=0; i<n; i++) {
+                       putx(w[i], c);
+                       putchar(i==n-1? '\n': ' ');
+               }
+       }
+}
+
+putx(n, c)
+{
+
+       switch(c) {
+       case 001:
+               pre(6);
+               putn(n, 8, 6);
+               break;
+       case 002:
+               pre(5);
+               putn(n, 10, 5);
+               break;
+       case 004:
+               pre(4);
+               putop(n);
+               break;
+       case 010:
+               pre(4);
+               putn(n, 16, 4);
+               break;
+       case 020:
+               pre(5);
+               putc(n);
+               putchar(' ');
+               putc(n>>8);
+               break;
+       case 040:
+               pre(7);
+               putn(n&0377, 8, 3);
+               putchar(' ');
+               putn((n>>8)&0377, 8, 3);
+               break;
+       }
+}
+
+getw()
+{
+       int b1, b2;
+
+       b1 = getc();
+       if(b1 == -1) {
+               eof = 1;
+               return(0);
+       }
+       b2 = getc();
+       if(b2 == -1)
+               b2 = 0;
+       return(b1|(b2<<8));
+}
+
+getc()
+{
+
+       if(gidx >= gcnt) {
+               gcnt = read(fi, gbuf, 512);
+               if(gcnt <= 0)
+                       return(-1);
+               gidx = 0;
+       }
+       if(++addr[1] >= basem) {
+               addr[0]++;
+               addr[1] = 0;
+       }
+       return(gbuf[gidx++]&0377);
+}
+
+putc(c)
+{
+       c =& 0377;
+       if(c>037 && c<0177 && c!='\\') {
+               putchar(' ');
+               putchar(c);
+               return;
+       }
+       putchar('\\');
+       switch(c) {
+       case '\0':
+               putchar('0');
+               break;
+       case '\n':
+               putchar('n');
+               break;
+       case '\\':
+               putchar('\\');
+               break;
+       case '\t':
+               putchar('t');
+               break;
+       default:
+               putchar('?');
+       }
+}
+
+putn(n, b, c)
+{
+
+       if(!c)
+               return;
+       putn(ldiv(0,n,b),b,c-1);
+       if((n=lrem(0,n,b)) > 9)
+               putchar(n-10+'a'); else
+               putchar(n+'0');
+}
+
+pre(n)
+{
+       int i;
+
+       for(i=n; i<max; i++)
+               putchar(' ');
+}
+
+offset(s)
+char s[];
+{
+       char *p;
+       int a[2], d, i, j, b;
+
+       p = s;
+       while(*p++);
+       i = p-s-1;
+       b = 0;
+       if(i > 0)
+               if(p[-2] == 'b') {
+                       i--;
+                       b++;
+                       p--;
+               }
+       if(i > 0)
+               if(p[-2] == '.') {
+                       i--;
+                       base = 10;
+                       basem = 1000;
+               }
+       a[0] = 0;
+       for(j=0; i-j>3; j++) {
+               d = s[j];
+               if(d>='0' && d<='9')
+                       a[0] = a[0]*base + d-'0';
+       }
+       a[1] = 0;
+       for(; i-j>0; j++) {
+               d = s[j];
+               if(d>='0' && d<='9')
+                       a[1] = a[1]*base + d-'0';
+       }
+       if(b) {
+               i = a[0]*basem+a[1];
+               a[0] = 0;
+               a[1] = 0;
+               while(i--) {
+                       a[1] =+ 512;
+                       while(a[1] >= basem) {
+                               a[1] =- basem;
+                               a[0]++;
+                       }
+               }
+       }
+       i = 0;
+       while(a[0] > addr[0]+1) {
+               addr[1] =+ 512;
+               while(addr[1] >= basem) {
+                       addr[1] =- basem;
+                       addr[0]++;
+               }
+               i++;
+       }
+       seek(fi, i, 3);
+       while(a[0]!=addr[0] || a[1]!=addr[1])
+               if(getc() == -1)
+                       break;
+}
+
+putop(n)
+{
+       char *p;
+       int i, c;
+
+       p = getop(n);
+       for(i=0; (c = *p++) != '\0'; i++)
+               putchar(c);
+       for(; i<4; i++)
+               putchar(' ');
+}
+
+getop(n)
+{
+
+       switch(n&0170000)
+       {
+       case 0000000:
+               switch(n&0177000)
+               {
+               case 0004000:
+                       return("jsr");
+
+               case 0077000:
+                       return("sob");
+               }
+               switch(n&0177400)
+               {
+               case 0000400:
+                       return("br");
+
+               case 0001000:
+                       return("bne");
+
+               case 0001400:
+                       return("beq");
+
+               case 0002000:
+                       return("bge");
+
+               case 0002400:
+                       return("blt");
+
+               case 0003000:
+                       return("bgt");
+
+               case 0003400:
+                       return("ble");
+               }
+               switch(n&0177700)
+               {
+               case 0000100:
+                       return("jmp");
+
+               case 0000300:
+                       return("swab");
+
+               case 0005000:
+                       return("clr");
+
+               case 0005100:
+                       return("com");
+
+               case 0005200:
+                       return("inc");
+
+               case 0005300:
+                       return("dec");
+
+               case 0005400:
+                       return("neg");
+
+               case 0005500:
+                       return("adc");
+
+               case 0005600:
+                       return("sbc");
+
+               case 0005700:
+                       return("tst");
+
+               case 0006000:
+                       return("ror");
+
+               case 0006100:
+                       return("rol");
+
+               case 0006200:
+                       return("asr");
+
+               case 0006300:
+                       return("asl");
+
+               case 0006400:
+                       return("mark");
+
+               case 0006500:
+                       return("mfpi");
+
+               case 0006600:
+                       return("mtpi");
+
+               case 0006700:
+                       return("sxt");
+               }
+               switch(n&0177740)
+               {
+               case 0000240:
+                       return("flag");
+               }
+               switch(n&0177770)
+               {
+               case 0000200:
+                       return("rts");
+
+               case 0000230:
+                       return("spl");
+               }
+               switch(n&0177777)
+               {
+               case 0000000:
+                       return("halt");
+
+               case 0000001:
+                       return("wait");
+
+               case 0000002:
+                       return("rti");
+
+               case 0000003:
+                       return("bpt");
+
+               case 0000004:
+                       return("iot");
+
+               case 0000005:
+                       return("rset");
+
+               case 0000006:
+                       return("rtt");
+               }
+               break;
+
+       case 0010000:
+               return("mov ");
+
+       case 0020000:
+               return("cmp");
+
+       case 0030000:
+               return("bit");
+
+       case 0040000:
+               return("bic");
+
+       case 0050000:
+               return("bis");
+
+       case 0060000:
+               return("add");
+
+       case 0070000:
+               switch(n&0177000)
+               {
+               case 0070000:
+                       return("mul");
+
+               case 0071000:
+                       return("div");
+
+               case 0072000:
+                       return("ash");
+
+               case 0073000:
+                       return("ashc");
+
+               case 0074000:
+                       return("xor");
+               }
+               break;
+
+       case 0100000:
+               switch(n&0177400)
+               {
+               case 0100000:
+                       return("bpl");
+
+               case 0100400:
+                       return("bmi");
+
+               case 0101000:
+                       return("bhi");
+
+               case 0101400:
+                       return("blos");
+
+               case 0102000:
+                       return("bvc");
+
+               case 0102400:
+                       return("bvs");
+
+               case 0103000:
+                       return("bhis");
+
+               case 0103400:
+                       return("blo");
+
+               case 0104000:
+                       return("emt");
+
+               case 0104400:
+                       return("sys");
+               }
+               switch(n&0177700)
+               {
+               case 0105000:
+                       return("clrb");
+
+               case 0105100:
+                       return("comb");
+
+               case 0105200:
+                       return("incb");
+
+               case 0105300:
+                       return("decb");
+
+               case 0105400:
+                       return("negb");
+
+               case 0105500:
+                       return("adcb");
+
+               case 0105600:
+                       return("sbcb");
+
+               case 0105700:
+                       return("tstb");
+
+               case 0106000:
+                       return("rorb");
+
+               case 0106100:
+                       return("rolb");
+
+               case 0106200:
+                       return("asrb");
+
+               case 0106300:
+                       return("aslb");
+
+               case 0106500:
+                       return("mfpd");
+
+               case 0106600:
+                       return("mfpd");
+               }
+               break;
+
+       case 0110000:
+               return("movb");
+
+       case 0120000:
+               return("cmpb");
+
+       case 0130000:
+               return("bitb");
+
+       case 0140000:
+               return("bicb");
+
+       case 0150000:
+               return("bisb");
+
+       case 0160000:
+               return("sub");
+
+       case 0170000:
+               switch(n&01777000)
+               {
+               case 0:0;
+               }
+               break;
+       }
+       return("???");
+}
diff --git a/usr/source/s2/typo.c b/usr/source/s2/typo.c
new file mode 100644 (file)
index 0000000..e69ea26
--- /dev/null
@@ -0,0 +1,437 @@
+#include "pinhead.h"
+int    sqflg   0;
+int    sn      -1;
+char   hole[26];
+char number[3];
+int eflg;
+char w2006[100];
+flg 0;
+char realwd[100];
+char *wd {&realwd[1]};
+char *fptr;
+char *ffptr &ffbuf;
+char ffbuf[36];
+int    neng;
+int    npr;
+int table[2];  /*keep these four cards in order*/
+int tab1[26];
+int tab2[730];
+char tab3[19684];
+int logtab[256];
+float inctab[256];
+char nwd[100];
+int tot;
+int wtot;
+char *buf[3];
+file[3];
+ptr[3];
+char *name[3];
+bsp[768];
+
+main(argc,argv) int argc; char *argv[]; {
+       char let,lt;
+       auto arg,t,sw,i,j,salt,er,c;
+       register k,l,m;
+       float junk;
+       int unl();
+       int ii;
+       float log(), exp(), pow();
+
+       nice(-20);
+       inctab[0] = 1;
+       logtab[0] = -10;
+       for(ii=1; ii<256; ii++){
+               inctab[ii] = exp(-ii/30.497);
+               logtab[ii] = log(30.*pow(1.0333,ii+0.) - 30.) + .5;
+               }
+       logtab[1] = -10;
+
+       number[2] = ' ';
+       buf[0] = bsp;
+       buf[1] = bsp + 0400;
+       buf[2] = bsp + 01000;
+       ptr[0] = 0; ptr[1] = 0;
+       ptr[2] = 1;
+       arg = 1;
+       while(argc>1 && argv[arg][0] == '-') {
+               switch(argv[arg][1]) {
+               default:
+                       printf("Unrecognizable argument: %c\n",argv[arg][1]);
+                               exit();
+               case 0:
+               case 'n':
+                               neng++;
+                               break;
+               case '1':
+                               npr++;
+               }
+               arg++;
+               --argc;
+       }
+       if(!neng) {
+               salt = open("/usr/lib/salt",0);
+               er = read(salt,table,21200);
+                       if(er != 21200)err("read salt");
+               close(salt);
+               }
+       if((signal(2,1) & 1) != 1)
+       signal(2,unl);
+       name[0] = "/usr/tmp/ttmpa1";
+       name[1] = "/usr/tmp/ttmpa2";
+       name[2] = "/usr/tmp/ttmpa3";
+       while((file[0] = open(name[0],1)) > 0){
+               close(file[0]);
+               for(j=0; j < 3; j++)name[j][13]++;
+               if(name[0][13] == 'z')err("creat tmp file");
+       }
+       file[0] = creat(name[0],0666);
+       fptr = argv[arg];
+       if(argc == 1) {argc = 2; arg = 0;}
+       while(--argc){
+               if(arg == 0){
+                       file[2] = 0;
+               }else{
+                       file[2] = open(argv[arg++],0);
+                       if(file[2] < 0)err("open input file");
+               }
+               eflg = 1;
+               while((j = wdval(2)) != 0){
+                       put(0,nwd,j);
+                       k = -1;
+                       l = 0;
+                       m = 1;
+                       if(inctab[table[0]] > (junk=rand()/32768.)) table[0]++;
+                       while(m <= j){
+                               c = 27*wd[k++] + wd[l++];
+                               if(inctab[tab2[c]] > junk) tab2[c]++;
+                               c = 27*c + wd[m++];
+                               if(inctab[tab3[c]] > junk) tab3[c]++;
+                       }
+                       c = 27*wd[k] + wd[l];
+                       if(inctab[tab2[c]] > junk) tab2[c]++;
+               }
+               if(file[2]) close(file[2]);
+       }
+       flsh(0,0);
+       close(file[0]);
+       sw = fork();
+               if(sw == 0){execl("/usr/bin/usort","usort","-o",name[2],name[0],0);
+                       err("sort"); }
+               if(sw < 0)err("fork");
+       er = wait();
+               if(er != sw)err("probs");
+       file[0] = creat(name[0],0666);
+               if(file[0] < 0)err("creat tmp");
+       file[1] = open("/usr/lib/sq2006",0);
+               if(file[1] < 0)err("open w2006");
+       ptr[1] = 1;
+       j = getsq(1);
+       file[2] = open(name[2],0);
+               if(file[2] < 0)err("open tmp");
+       ptr[2] = 1;
+
+       while(ptr[2]){
+               l=0;
+               for(k=0;((c = wd[k] = get(2)) != '\n');k++)
+                       if(c == -1)goto done;
+               for(i=0; i<=k;i++){
+                       if(wd[i] < w2006[l]){
+                               put(0,wd,k);
+                               break;
+                       }
+                       if(wd[i] > w2006[l]){
+                               l = getsq(1);
+                                       if(l == -1){
+                                               put(0,wd,k);
+                                               for(k=0;((c = wd[k] =get(2))!= -1);k++){
+                                                       put(0,wd,k);
+                                                       k = -1;
+                                               }
+                                               goto done;
+                               }
+                               i = -1;
+                               l=0;
+                               continue;
+                       }
+                       l++;
+               }
+       }
+done:
+       close(file[2]); 
+       unlink(name[2]);
+       flsh(0,0);
+       close(file[1]);
+       close(file[0]);
+       ptr[1] = 1;
+       file[1] = open(name[0],0);
+               if(file[1] < 0)err("open tmp ");
+       file[0] = creat(name[1],0666);
+               if(file[0] < 0)err("create tmp");
+       while((j = nwdval(1)) != 0){
+               wtot = 0;
+               flg = 0;
+               k = -1; l = 0; m = 1;
+               while(m <= j){
+                       tot = 0;
+                       c = wd[k++]*27 + wd[l++];
+                       tot =+ (logtab[tab2[c]]+logtab[tab2[wd[k]*27+wd[l]]]);
+                       tot =>> 1;
+                       c = c*27 + wd[m++];
+                       tot =- logtab[tab3[c] & 0377];
+                       if(tot > wtot) wtot = tot;
+                       }
+               if(wtot < 0) wtot = 0;
+               t = conf(wtot,2,number);
+               put(0,number,2);
+               put(0,nwd,j);
+               }
+       flsh(0,0);
+       close(file[1]);
+       close(file[0]);
+
+       sw = fork();
+               if(sw == 0){execl("/bin/sort","sort","+0nr", "+1","-o",name[1],name[1]
+                       ,0);
+                       err("sort"); }
+               if(sw < 0)err("fork");
+       er = wait();
+               if(er != sw)err("prob");
+
+       sw = fork();
+               if(sw == 0){
+                       if(npr) {
+                               execl("/bin/cat","cat",name[1],0);
+                       } else {
+                               i = 0 ;
+                               while((c = "Possible typo's in "[i++])!=0)
+                                       *ffptr++ = c;
+                               i = 0;
+                               while((c = fptr[i++]) != 0)
+                                       *ffptr++ = c;
+                               *ffptr = 0;
+                               execl("/bin/pr","pr","-3", "-h",
+                               ffbuf,name[1],0);
+                               err("pr");
+               }
+       }
+               if(sw < 0)err("fork");
+       er = wait();
+               if(er != sw)err("prob");
+       unl();
+}
+
+unl() {
+       register j;
+       j = 2;
+       while(j--)unlink(name[j]);
+       exit();
+}
+
+
+err(c) char c[];{
+       register j;
+       printf("cannot %s\n",c);
+       unl();
+}
+
+get(ifile) int ifile;{
+       static char *ibuf[10];
+       if(--ptr[ifile]){
+               return(*ibuf[ifile]++ & 0377);}
+       if(ptr[ifile] = read(file[ifile],buf[ifile],512)){
+               if(ptr[ifile] < 0)goto prob;
+               ibuf[ifile] = buf[ifile];
+               return(*ibuf[ifile]++ & 0377);
+       }
+       ptr[ifile] = 1;
+       return(-1);
+
+prob:
+       ptr[ifile] = 1;
+       printf("read error\n");
+       return(-1);
+}
+
+put(ofile,s,optr) char s[]; {
+       register i;
+
+       while(optr-- >= 0)
+                buf[ofile][(ptr[ofile] < 512)?ptr[ofile]++:flsh(ofile,1)] = *s++;
+       return;
+}
+
+flsh(ofile,i){
+       register error;
+       error = write(file[ofile],buf[ofile],ptr[ofile]);
+       if(error < 0)goto prob;
+
+       ptr[ofile] = i;
+       return(0);
+prob:
+       printf("write error on t.%d\n",file[ofile]);
+       unl();
+}
+
+wdval(wfile) int wfile; {
+       static let,wflg;
+       register j;
+beg:
+       j = -1;
+       if(wflg == 1){wflg = 0;
+               goto st; }
+       while((let = get(wfile)) != '\n'){
+st:
+               switch(let){
+               case -1:        return(0);
+               case '%':       if(j != -1)break;
+                                       goto ret;
+               case '-':
+                               if((let = get(wfile)) == '\n'){
+                                       while((let = get(wfile)) == '\n')if(let == -1)return(0);
+                                       goto st; }
+                               else {wflg = 1;
+                                       goto ret; }
+               case '\'':
+                               if(eflg != 1){
+                                       if(j < 1)goto beg;
+                                               else break;
+                                       }
+               case '.':
+                               if(eflg == 1){
+                                       while((let = get(wfile)) != '\n')if(let == -1)return(0);
+                                       goto st; }
+                               else goto ret;
+               default:
+                               eflg = 0;
+                               if(let < 'A')goto ret;
+                               if(let <= 'Z'){ wd[++j] = let - 0100;
+                                       nwd[j] = let + ' ';
+                                       break; }
+                               if(let < 'a' || let > 'z')goto ret;
+                               wd[++j] = let - 0140;
+                               nwd[j] = let;
+                       }
+                eflg = 0;      }
+
+       eflg = 1;
+       wflg = 1;
+ret:
+       if(j < 1)goto beg;
+       nwd[++j] = '\n';
+       wd[j] = 0;
+       return(j);
+}
+
+nwdval(wfile) int wfile;{
+       register j;
+       register char c;
+       j = -1;
+       do{
+               if(( c = nwd[++j] = get(wfile)) == -1)return(0);
+               wd[j] = c - 0140;
+       }
+       while(c != '\n');
+       wd[j] = '\0';
+       return(j);
+}
+conf(n,width,cbuf) char cbuf[]; {
+       register i,a;
+
+       i = width;
+       while(i--)cbuf[i] = ' ';
+
+       cbuf[(a = n/10)?conf(a,--width,cbuf):--width] = n%10 + '0';
+
+       return(++width);
+}
+rand(){
+       static gorp;
+       gorp = (gorp + 625) & 077777;
+       return(gorp);
+}
+
+getsq(ifile) int ifile;
+{
+       register char *p, *cp;
+       register c;
+       int n, f;
+
+       if(sqflg == 0){
+               for(c=7; c<16; c++)
+                       hole[nib[c]-'a'] = c+64-1+26;
+               for(n=0; cp=suftab[n]; n++) {
+                       p = w2006;
+                       while(*p++ = *cp++)
+                               ;
+                       p--;
+                       cp = suftab[n];
+                       while(p > w2006)
+                               *cp++ = *--p;
+               }
+               sqflg = 1;
+       }
+
+count:
+       f = 0;
+       if((c = getn(ifile)) < 0)return(-1);
+       if(c < 10) {
+               if(c == 9) {
+                       if((c = getn(ifile)) < 0)return(-1);
+                       if(c > 2)
+                               c =+ 9;
+               } else
+                       c =+ 3;
+       } else {
+               f++;
+               if(c == 15) {
+                       if((c = getn(ifile)) < 0)return(-1);
+                       if(c > 2)
+                               c =+ 5;
+               } else
+                       c =- 7;
+       }
+       p = w2006+c;
+
+chr:
+       if((c = getn(ifile)) < 0)return(-1);
+       n = nib[c];
+       if(n) {
+               if(n == '\n')
+                       goto out;
+               *p++ = n;
+               goto chr;
+       }
+       c = c*16 + getn(ifile);
+       if(c < 26) {
+               if(hole[c] == 0) {
+                       *p++ = c+'a';
+                       goto chr;
+               }
+               c = hole[c];
+       }
+       cp = suftab[c-26];
+       while(*cp)
+               *p++ = *cp++;
+
+out:
+       w2006[0] =| 040;
+       if(f)
+               w2006[0] =& ~040;
+       *p++ = '\n';
+       return(1);
+}
+
+getn(ifile) int ifile;
+{
+       register c;
+
+       c = sn;
+       if(c < 0) {
+               c = get(ifile);
+               if(c == -1) return(-1);
+               sn = c >> 4;
+               return(c&017);
+       }
+       sn = -1;
+       return(c);
+}
diff --git a/usr/source/s3/compar.s b/usr/source/s3/compar.s
new file mode 100644 (file)
index 0000000..ddf4a4e
--- /dev/null
@@ -0,0 +1,30 @@
+/ default comparison routine for qsort
+/ set codes for 
+/
+/      cmp     (r0),(r4)
+/
+
+.globl compare
+
+compare:
+       mov     r3,-(sp)
+       mov     r4,-(sp)
+1:
+       cmpb    (r0)+,(r4)+
+       bne     1f
+       dec     r3
+       bne     1b
+       clr     r0
+       br      2f
+1:
+       blo     1f
+       mov     $1,r0
+       br      2f
+1:
+       mov     $-1,r0
+2:
+       mov     (sp)+,r4
+       mov     (sp)+,r3
+       tst     r0
+       rts     pc
+
diff --git a/usr/source/s3/fp3.s b/usr/source/s3/fp3.s
new file mode 100644 (file)
index 0000000..66ffecf
--- /dev/null
@@ -0,0 +1,335 @@
+/ fp3 -- floating simulation
+
+i.addx:
+       jsr     pc,setab
+       br      1f
+
+i.subx:
+       jsr     pc,setab
+       neg     bsign
+1:
+       tst     bsign
+       beq     reta
+       tst     asign
+       beq     retb
+       mov     areg+8,r1
+       sub     breg+8,r1
+       blt     1f
+       beq     2f
+       cmp     r1,$56.
+       bge     reta
+       mov     $breg,r0
+       br      4f
+1:
+       neg     r1
+       cmp     r1,$56.
+       bge     retb
+       mov     $areg,r0
+4:
+       mov     r1,-(sp)
+       mov     (r0)+,r1
+       mov     (r0)+,r2
+       mov     (r0)+,r3
+       mov     (r0)+,r4
+       add     (sp),(r0)
+1:
+       clc
+       ror     r1
+       ror     r2
+       ror     r3
+       ror     r4
+       dec     (sp)
+       bgt     1b
+       mov     r4,-(r0)
+       mov     r3,-(r0)
+       mov     r2,-(r0)
+       mov     r1,-(r0)
+       tst     (sp)+
+2:
+       mov     $areg+8,r1
+       mov     $breg+8,r2
+       mov     $4,r0
+       cmp     asign,bsign
+       bne     4f
+       clc
+1:
+       adc     -(r1)
+       bcs     3f
+       add     -(r2),(r1)
+2:
+       dec     r0
+       bne     1b
+       br      5f
+3:
+       add     -(r2),(r1)
+       sec
+       br      2b
+       br      5f
+4:
+       clc
+1:
+       sbc     -(r1)
+       bcs     3f
+       sub     -(r2),(r1)
+2:
+       dec     r0
+       bne     1b
+       br      5f
+3:
+       sub     -(r2),(r1)
+       sec
+       br      2b
+
+saret:
+       mov     $areg,r1
+5:
+       tst     (r1)
+       bge     3f
+       mov     $areg+8,r1
+       mov     $4,r0
+       clc
+1:
+       adc     -(r1)
+       bcs     2f
+       neg     (r1)
+2:
+       dec     r0
+       bne     1b
+       neg     -(r1)
+3:
+       jsr     pc,norm
+       br      reta
+
+retb:
+       mov     $bsign,r1
+       mov     $asign,r2
+       mov     $6,r0
+1:
+       mov     (r1)+,(r2)+
+       dec     r0
+       bne     1b
+
+reta:
+       mov     r5,r2
+       mov     $asign,r0
+       tst     (r0)
+       beq     unflo
+       mov     aexp,r1
+       cmp     r1,$177
+       bgt     ovflo
+       cmp     r1,$-177
+       blt     unflo
+       add     $200,r1
+       swab    r1
+       clc
+       ror     r1
+       tst     (r0)+
+       bge     1f
+       bis     $100000,r1
+1:
+       bic     $!177,(r0)
+       bis     (r0)+,r1
+       mov     r1,(r2)+
+       mov     (r0)+,(r2)+
+       bit     $m.ext,fpsr
+       beq     1f
+       mov     (r0)+,(r2)+
+       mov     (r0)+,(r2)+
+1:
+       rts     pc
+
+unflo:
+       clr     (r2)+
+       clr     (r2)+
+       bit     $m.ext,fpsr
+       beq     1f
+       clr     (r2)+
+       clr     (r2)+
+1:
+       rts     pc
+
+ovflo:
+       bis     $2,fpsr                 / set v-bit (overflow)
+       jmp     ret
+
+i.mulx:
+       jsr     pc,i.mul
+       br      saret
+
+i.modx:
+       jsr     pc,i.mul
+       jsr     pc,norm
+       mov     $asign,r0
+       mov     $bsign,r1
+       mov     $6,r2
+1:
+       mov     (r0)+,(r1)+
+       dec     r2
+       bne     1b
+       clr     r0              / count
+       mov     $200,r1         / bit
+       clr     r2              / reg offset
+1:
+       cmp     r0,aexp
+       bge     2f              / in fraction
+       bic     r1,areg(r2)
+       br      3f
+2:
+       bic     r1,breg(r2)
+3:
+       inc     r0
+       clc
+       ror     r1
+       bne     1b
+       mov     $100000,r1
+       add     $2,r2
+       cmp     r2,$8
+       blt     1b
+       jsr     pc,norm
+       jsr     pc,reta
+       cmp     r5,$ac1
+       beq     1f
+       cmp     r5,$ac3
+       beq     1f
+       bit     $200,breg
+       bne     2f
+       clr     bsign
+2:
+       add     $8,r5
+       jsr     pc,retb
+       sub     $8,r5
+1:
+       rts     pc
+
+i.divx:
+       jsr     pc,setab
+       tst     bsign
+       beq     ovflo
+       sub     bexp,aexp
+       jsr     pc,xorsign
+       mov     r5,-(sp)
+       mov     $areg,r0
+       mov     (r0),r1
+       clr     (r0)+
+       mov     (r0),r2
+       clr     (r0)+
+       mov     (r0),r3
+       clr     (r0)+
+       mov     (r0),r4
+       clr     (r0)+
+       mov     $areg,r5
+       mov     $400,-(sp)
+1:
+       mov     $breg,r0
+       cmp     (r0)+,r1
+       blt     2f
+       bgt     3f
+       cmp     (r0)+,r2
+       blo     2f
+       bhi     3f
+       cmp     (r0)+,r3
+       blo     2f
+       bhi     3f
+       cmp     (r0)+,r4
+       bhi     3f
+2:
+       mov     $breg,r0
+       sub     (r0)+,r1
+       clr     -(sp)
+       sub     (r0)+,r2
+       adc     (sp)
+       clr     -(sp)
+       sub     (r0)+,r3
+       adc     (sp)
+       sub     (r0)+,r4
+       sbc     r3
+       adc     (sp)
+       sub     (sp)+,r2
+       adc     (sp)
+       sub     (sp)+,r1
+       bis     (sp),(r5)
+3:
+       asl     r4
+       rol     r3
+       rol     r2
+       rol     r1
+       clc
+       ror     (sp)
+       bne     1b
+       mov     $100000,(sp)
+       add     $2,r5
+       cmp     r5,$areg+8
+       blo     1b
+       tst     (sp)+
+       mov     (sp)+,r5
+       jmp     saret
+
+
+i.mul:
+       jsr     pc,setab
+       add     bexp,aexp
+       dec     aexp
+       jsr     pc,xorsign
+       mov     r5,-(sp)
+       mov     $breg+4,r5
+       bit     $m.ext,fpsr
+       beq     1f
+       add     $4,r5
+1:
+       clr     r0
+       clr     r1
+       clr     r2
+       clr     r3
+       clr     r4
+1:
+       asl     r0
+       bne     2f
+       inc     r0
+       tst     -(r5)
+2:
+       cmp     r0,$400
+       bne     2f
+       cmp     r5,$breg
+       bhi     2f
+       mov     $areg,r0
+       mov     r1,(r0)+
+       mov     r2,(r0)+
+       mov     r3,(r0)+
+       mov     r4,(r0)+
+       mov     (sp)+,r5
+       rts     pc
+2:
+       clc
+       ror     r1
+       ror     r2
+       ror     r3
+       ror     r4
+       bit     r0,(r5)
+       beq     1b
+       mov     r0,-(sp)
+       mov     $areg,r0
+       add     (r0)+,r1
+       clr     -(sp)
+       add     (r0)+,r2
+       adc     (sp)
+       clr     -(sp)
+       add     (r0)+,r3
+       adc     (sp)
+       add     (r0)+,r4
+       adc     r3
+       adc     (sp)
+       add     (sp)+,r2
+       adc     (sp)
+       add     (sp)+,r1
+       mov     (sp)+,r0
+       br      1b
+
+xorsign:
+       cmp     asign,bsign
+       beq     1f
+       mov     $-1,asign
+       rts     pc
+1:
+       mov     $1,asign
+       rts     pc
+
diff --git a/usr/source/s4/dup.s b/usr/source/s4/dup.s
new file mode 100644 (file)
index 0000000..e5758fb
--- /dev/null
@@ -0,0 +1,18 @@
+/ C library -- dup
+
+/      f = dup(of)
+/      f == -1 for error
+
+dup = 41.
+
+.globl _dup, retrn, cerror
+
+_dup:
+       mov     r5,-(sp)
+       mov     sp,r5
+       mov     4(r5),r0
+       sys     dup
+       bec     1f
+       jmp     cerror
+1:
+       jmp     retrn
diff --git a/usr/source/s4/getuid.s b/usr/source/s4/getuid.s
new file mode 100644 (file)
index 0000000..b6edd8a
--- /dev/null
@@ -0,0 +1,13 @@
+/ C library -- getuid
+
+/ uid = getuid();
+/
+
+.globl _getuid, retrn
+
+_getuid:
+       mov     r5,-(sp)
+       mov     sp,r5
+       sys     getuid
+       bic     $!377,r0
+       jmp     retrn
diff --git a/usr/source/s4/putchr.s b/usr/source/s4/putchr.s
new file mode 100644 (file)
index 0000000..94a8d56
--- /dev/null
@@ -0,0 +1,55 @@
+/ C library -- putchar
+
+       .globl  _putchar,_flush
+       .globl  _fout
+
+_putchar:
+       mov     r5,-(sp)
+       mov     sp,r5
+       mov     _fout+4,r0
+       bne     1f
+       jsr     pc,fl
+       mov     _fout+4,r0
+1:
+       movb    4(r5),(r0)+
+       beq     1f
+       inc     _fout+4
+       dec     _fout+2
+       bgt     1f
+       jsr     pc,fl
+1:
+       mov     4(r5),r0
+       mov     (sp)+,r5
+       rts     pc
+
+_flush:
+       mov     r5,-(sp)
+       mov     sp,r5
+       jsr     pc,fl
+       mov     (sp)+,r5
+       rts     pc
+
+fl:
+       mov     _fout+4,r0
+       beq     1f
+       sub     $_fout+6,r0
+       mov     r0,0f
+       mov     _fout,r0
+       bne     2f
+       inc     r0
+2:
+       sys     0; 9f
+.data
+9:     sys     write; _fout+6; 0:..
+.text
+1:
+       mov     $_fout+6,_fout+4
+       mov     $512.,_fout+2
+       cmp     _fout,$2
+       bhi     1f
+       mov     $1,_fout+2
+1:
+       rts     pc
+
+.bss
+_fout: .=.+518.