# 2.11BSD#431 - /usr/src/bin/as/as2.s

##### Functions

    aexit             X
    checkeos          X
    filerr            X
    pass1             X
    wrterr            X

##### Variables

    a.outp            X
    argb              X
    defund            X
    errflg            X
    ibufc             X
    ibufp             X
    obufp             X
    outbuf            X
    outmod            X
    overlaid          X
    passno            X

       1: / Sept 10, 1997 - fix coredump caused by using wrong error reporting
       2: /	calling convention in three places.
       3:
       4:         .globl  _signal, _close, _lseek, _unlink, _umask, _chmod, __exit
       5:         .globl  _write, _read, _brk, _end, _open, _realloc, _fchmod
       6:         .globl  pass1, hshsiz, outmod, dot, dotdot, error
       7:         .globl  checkeos, curfb, savdot, ch, line, savop, inbuf, errflg
       8:         .globl  fbptr, fbtbl, symnum, hshtab, symblk, symleft, dotrel
       9:         .globl  symtab, aexit, overlaid, defund, a.outp, passno, filerr
      10:         .globl  wrterr, argb, curfb, nxtfb, usymtab
      11:         .globl  fin, fout, a.tmp1, ibufc, ibufp, obufp, outbuf, symbol
      12:         .globl  PSTENTSZ, SYMENTSZ, SYMBLKSZ, Newsym
      13:
      14: pass1:
      15:         mov     fout,fin                / tmp file is now input file
      16:         mov     $666,-(sp)              / mode
      17:         mov     $3001 ,-(sp)            / O_WRONLY|O_CREAT|O_TRUNC
      18:         mov     a.outp,-(sp)            / filename
      19:         jsr     pc,_open
      20:         add     $6,sp
      21:         mov     r0,fout                 / file descriptor any good?
      22:         bpl     1f                      / yes - br
      23:         mov     a.outp,-(sp)
      24:         jsr     pc,filerr
      25: 1:
      26:
      27: / 'symnum' has number of symbols.  The hashtable from pass 0 is no
      28: / longer needed - we can reuse it directly for 'usymtab' if there are less
      29: / than 'hshsiz' symbols.  If there are more than 'hshsiz' (currently
      30: / 1500) symbols we have to realloc.
      31: /
      32: / The 'fb' table (usually 0 long) is appended to the 'usymtab' (4 byte
      33: / entries per symbol).
      34:
      35:         mov     fbptr,r0
      36:         sub     fbtbl,r0                / # bytes in 'fb' table
      37:         asr     r0                      / convert to number of words
      38:         add     symnum,r0               / add in number of symbols twice
      39:         add     symnum,r0               / because we need 2 words per symbol
      40:         inc     r0                      / one more for terminator word
      41:         cmp     r0,$hshsiz              / is hashtable big enough already?
      42:         blo     1f                      / yes -br
      43:         asl     r0                      / convert to bytes
      44:         mov     r0,-(sp)
      45:         mov     hshtab,-(sp)
      46:         jsr     pc,_realloc             / hshtab = realloc(hshtab, r0)
      47:         mov     r0,hshtab
      48:         bne     1f
      49:         iot                             / should never happen
      50: 1:
      51:         mov     hshtab,r1
      52:         mov     usymtab,r2
      53: 9:
      54:         mov     r2,symblk               / save ptr to start of block
      55:         tst     (r2)+                   / skip link word
      56:         mov     $SYMBLKSZ,symleft       / init amount left in block
      57: 1:
      58:         tst     (r2)                    / end of symbol table block
      59:         beq     4f                      / yes - br
      60:         add     $8.,symsiz              / size of symbol table
      61:         tst     Newsym                  / are we doing new style?
      62:         bne     8f                      / yes - br
      63:         add     $4,symsiz               / no, symbol table entries are bigger
      64: 8:
      65:         mov     2(r2),r0                / flags word
      66:         bic     $!37,r0
      67:         cmp     r0,$2                   /text
      68:         blo     2f
      69:         cmp     r0,$3                   /data
      70:         bhi     2f
      71:         add     $31,r0                  /mark "estimated"
      72:         mov     r0,(r1)+                / store flags word
      73:         mov     4(r2),(r1)+             / copy value word
      74:         br      3f
      75: 2:
      76:         clr     (r1)+
      77:         clr     (r1)+
      78: 3:
      79:         add     $SYMENTSZ,r2            / skip to next symbol entry
      80:         sub     $SYMENTSZ,symleft       / one symbol less in block
      81:         cmp     symleft,$SYMENTSZ       / room for another symbol?
      82:         bge     1b                      / yes - br
      83: 4:
      84:         mov     *symblk,r2              / follow link to next block
      85:         bne     9b                      / if not at end
      86: 1:
      87:
      88: / The 'fb' table needs to be appended to the 'usymtab' table now
      89:
      90:         mov     fbtbl,r0
      91:         mov     r1,fbbufp               / save start of 'fb' table
      92: 1:
      93:         cmp     r0,fbptr                / at end of table?
      94:         bhis    2f                      / yes - br
      95:         mov     (r0)+,r4
      96:         add     $31,r4                  / "estimated"
      97:         mov     r4,(r1)+
      98:         mov     (r0)+,(r1)+
      99:         br      1b
     100: 2:
     101:         mov     r1,endtable
     102:         mov     $100000,(r1)+
     103:
     104:         mov     $savdot,r0              / reset the 'psect' (text,data,bss)
     105:         clr     (r0)+                   / counters for the next pass
     106:         clr     (r0)+
     107:         clr     (r0)+
     108:         jsr     pc,setup                / init fb stuff
     109:
     110:         jsr     pc,pass1_2              / do pass 1
     111:
     112: / prepare for pass 2
     113:         inc     passno
     114:         cmp     outmod,$777
     115:         beq     1f
     116:         jsr     pc,aexit
     117: / not reached
     118: 1:
     119:         jsr     pc,setup
     120:         inc     bsssiz
     121:         bic     $1,bsssiz
     122:         mov     txtsiz,r1
     123:         inc     r1
     124:         bic     $1,r1
     125:         mov     r1,txtsiz
     126:         mov     datsiz,r2
     127:         inc     r2
     128:         bic     $1,r2
     129:         mov     r2,datsiz
     130:         mov     r1,r3
     131:         mov     r3,datbase              / txtsiz
     132:         mov     r3,savdot+2
     133:         add     r2,r3
     134:         mov     r3,bssbase              / txtsiz+datsiz
     135:         mov     r3,savdot+4
     136:         clr     r0
     137:         asl     r3
     138:         adc     r0
     139:         add     $20,r3
     140:         adc     r0
     141:         mov     r3,symseek+2            / 2*txtsiz+2*datsiz+20
     142:         mov     r0,symseek
     143:         sub     r2,r3
     144:         sbc     r0
     145:         mov     r3,drelseek+2           / 2*txtsiz+datsiz
     146:         mov     r0,drelseek
     147:         sub     r1,r3
     148:         sbc     r0
     149:         mov     r3,trelseek+2           / txtsiz+datsiz+20
     150:         mov     r0,trelseek
     151:         sub     r2,r3
     152:         sbc     r0
     153:         mov     r0,datseek
     154:         mov     r3,datseek+2            / txtsiz+20
     155:         mov     hshtab,r1
     156: 1:
     157:         jsr     pc,doreloc
     158:         add     $4,r1
     159:         cmp     r1,endtable
     160:         blo     1b
     161:         clr     r0
     162:         clr     r1
     163:         mov     $txtp,-(sp)
     164:         jsr     pc,oset
     165:         mov     trelseek,r0
     166:         mov     trelseek+2,r1
     167:         mov     $relp,-(sp)
     168:         jsr     pc,oset
     169:         mov     $8.,r2
     170:         mov     $txtmagic,r1
     171: 1:
     172:         mov     (r1)+,r0
     173:         mov     $txtp,-(sp)
     174:         jsr     pc,putw
     175:         sob     r2,1b
     176:
     177:         jsr     pc,pass1_2                      / do pass 2
     178:
     179: /polish off text and relocation
     180:
     181:         mov     $txtp,-(sp)
     182:         jsr     pc,flush
     183:         mov     $relp,-(sp)
     184:         jsr     pc,flush
     185:
     186: / append full symbol table
     187:         mov     symseek,r0
     188:         mov     symseek+2,r1
     189:         mov     $txtp,-(sp)
     190:         jsr     pc,oset
     191:
     192:         mov     usymtab,r2              / pointer to first symbol block
     193:         mov     hshtab,r1               / 'type' and 'value' array
     194:
     195:         tst     Newsym
     196:         beq     8f
     197:         jsr     pc,nsymout
     198:         br      9f
     199: 8:
     200:         jsr     pc,osymout
     201: 9:
     202:         mov     $txtp,-(sp)
     203:         jsr     pc,flush
     204:         jsr     pc,aexit
     205: / not reached
     206:
     207: saexit:
     208:         mov     pc,errflg
     209:
     210: aexit:
     211:         mov     $a.tmp1,-(sp)           / unlink(a.tmp1)
     212:         jsr     pc,_unlink
     213:         tst     errflg
     214:         bne     2f
     215:
     216:         clr     (sp)
     217:         jsr     pc,_umask
     218:
     219:         bic     r0,outmod               / fchmod(fout, outmod&umask(0))
     220:         mov     outmod,(sp)
     221:         mov     fout,-(sp)
     222:         jsr     pc,_fchmod
     223:         tst     (sp)+
     224:         clr     (sp)
     225:         br      1f
     226: 2:
     227:         mov     $2,(sp)
     228: 1:
     229:         jsr     pc,__exit               / _exit(errflg ? 2 : 0)
     230:
     231: filerr:
     232:         mov     2(sp),r0                / filename string.  no need to clean
     233:         tst     -(sp)                   / stack, this routine goes to saexit.
     234:         mov     r0,-(sp)
     235:         mov     $1,-(sp)
     236: 1:
     237:         tstb    (r0)+
     238:         bne     1b
     239:         sub     2(sp),r0
     240:         dec     r0
     241:         mov     r0,4(sp)
     242:         jsr     pc,_write
     243:         add     $6,sp
     244:
     245:         mov     $2,-(sp)                / write(1, "?\n", 2)
     246:         mov     $qnl,-(sp)
     247:         mov     $1,-(sp)
     248:         jsr     pc,_write
     249:         add     $6,sp
     250:         tst     passno
     251:         bpl     saexit
     252:         rts     pc
     253:
     254: osymout:
     255: 9:
     256:         mov     r2,symblk               / save ptr to current sym block
     257:         tst     (r2)+                   / skip link word
     258:         mov     $SYMBLKSZ,symleft       / space left in symbol block
     259: 1:
     260:         mov     (r2),r4                 / pointer to symbol name
     261:         beq     4f                      / end of block - br
     262:
     263:         mov     $8.,r5                  / max number to copy
     264:         mov     $symbol,r0              / destination buffer
     265: 2:
     266:         movb    (r4),(r0)+              / copy a byte
     267:         beq     6f
     268:         inc     r4                      / non null - bump source ptr
     269: 6:
     270:         sob     r5,2b
     271:
     272: / Now put four words of symbol name to the object file
     273:         mov     $4,r5                   / number of words to do
     274:         mov     $symbol,r4
     275: 6:
     276:         mov     (r4)+,r0                / word (2 chars) of symbol name
     277:         mov     $txtp,-(sp)
     278:         jsr     pc,putw
     279:         sob     r5,6b
     280:
     281: / values from 'hshtab' (parallel array to symbol table) are retrieved now,
     282: / they take the place of the flags and value entries of the symbol table.
     283:         mov     (r1)+,r0
     284:         mov     $txtp,-(sp)
     285:         jsr     pc,putw
     286:         mov     (r1)+,r0
     287:         mov     $txtp,-(sp)
     288:         jsr     pc,putw
     289:         add     $SYMENTSZ,r2            / skip to next symbol
     290:         sub     $SYMENTSZ,symleft       / one less symbol in block
     291:         cmp     symleft,$SYMENTSZ       / room for another?
     292:         bge     1b                      / yes - br
     293: 4:
     294:         mov     *symblk,r2              / no, follow link to next block
     295:         bne     9b                      / unless it's end of list
     296:         rts     pc
     297:
     298: nsymout:
     299:         clr     totalsz
     300:         mov     $4,totalsz+2            / string table min size is 4
     301: 9:
     302:         mov     r2,symblk               / save ptr to current symbol block
     303:         tst     (r2)+                   / skip link word
     304:         mov     $SYMBLKSZ,symleft       / amount of space left in block
     305: 1:
     306:         mov     (r2),r4                 / pointer to symbol's string
     307:         beq     4f                      / end of block - br
     308:         mov     totalsz,r0              / now output the...
     309:         mov     $txtp,-(sp)             / high order of the string index...
     310:         jsr     pc,putw                 / to the object file
     311:         mov     totalsz+2,r0
     312:         mov     $txtp,-(sp)
     313:         jsr     pc,putw                 / and the low order word
     314: 2:
     315:         tstb    (r4)+                   / find the end of the string
     316:         bne     2b
     317:         sub     (r2),r4                 / compute length including the null
     318:         add     r4,totalsz+2            / offset of next string
     319:         adc     totalsz
     320:         mov     (r1)+,r0                / 'type' word of symbol
     321:         mov     $txtp,-(sp)
     322:         jsr     pc,putw
     323:         mov     (r1)+,r0                / 'value' word of symbol
     324:         mov     $txtp,-(sp)
     325:         jsr     pc,putw
     326:         add     $SYMENTSZ,r2            / advance to next symbol
     327:         sub     $SYMENTSZ,symleft       / adjust amount left in symbol block
     328:         cmp     symleft,$SYMENTSZ       / is there enough for another symbol?
     329:         bge     1b                      / yes - br
     330: 4:
     331:         mov     *symblk,r2              / follow link to next symbol block
     332:         bne     9b                      / more - br
     333:         mov     totalsz,r0              / now output the string table length
     334:         mov     $txtp,-(sp)             / high order word first
     335:         jsr     pc,putw
     336:         mov     totalsz+2,r0            / followed by the low order
     337:         mov     $txtp,-(sp)
     338:         jsr     pc,putw
     339:
     340: / Now write the strings out
     341:
     342:         mov     usymtab,r2              / start at beginning of symbols
     343: 9:
     344:         mov     r2,symblk               / save pointer to current block
     345:         tst     (r2)+                   / skip link word
     346:         mov     $SYMBLKSZ,symleft       / amount left in block
     347: 1:
     348:         mov     (r2),r4                 / pointer to symbol's string
     349:         beq     4f                      / at end of block - br
     350:         jsr     pc,putstring            / write out the string
     351:         add     $SYMENTSZ,r2            / advance to next symbol
     352:         sub     $SYMENTSZ,symleft       / adjust amount left in block
     353:         cmp     symleft,$SYMENTSZ       / enough for another symbol?
     354:         bge     1b                      / yes - br
     355: 4:
     356:         mov     *symblk,r2              / move to next block of symbols
     357:         bne     9b                      / any left - br
     358:
     359: / probably not necessary but let us leave the file size on an even
     360: / byte boundary.
     361:
     362:         bit     $1,totalsz+2            / odd number of bytes in string table?
     363:         beq     5f                      / no - br
     364:         mov     symblk,r4               / we know 'symblk' points to a null
     365:         jsr     pc,putstring            / output a single null
     366: 5:
     367:         rts     pc
     368:
     369: / R4 has the address of a null terminated string to write to the output
     370: / file.  The terminating null is included in the output.  This routine
     371: / "inlines" the 'txtp seek structure' manipulation because the 'putw'
     372: / routine was 1) not suitable to byte output and 2) symbol strings are
     373: / only written using the 'txtp' (as opposed to 'relp' - relocation info)
     374: / structure.
     375:
     376: putstring:
     377:         cmp     txtp,txtp+2             / room for another byte?
     378:         bhis    1f                      / no - br
     379: 3:
     380:         movb    (r4),*txtp              / put byte in buffer
     381:         inc     txtp                    / advance output position
     382:         tstb    (r4)+                   / did we just do the null?
     383:         bne     putstring               / no - go again
     384:         rts     pc                      / yes - we're done, return
     385: 1:
     386:         mov     r2,-(sp)                / save r2 from being destroyed
     387:         mov     $txtp,-(sp)             / flush buffered output and...
     388:         jsr     pc,flush                / reset the pointers
     389:         mov     (sp)+,r2                / restore symbol pointer
     390:         br      3b                      / go output a byte
     391:
     392: doreloc:
     393:         movb    (r1),r0
     394:         bne     1f
     395:         bisb    defund,(r1)
     396: 1:
     397:         bic     $!37,r0
     398:         cmp     r0,$5
     399:         bhis    1f
     400:         cmp     r0,$3
     401:         blo     1f
     402:         beq     2f
     403:         add     bssbase,2(r1)
     404:         rts     pc
     405: 2:
     406:         add     datbase,2(r1)
     407: 1:
     408:         rts     pc
     409:
     410: setup:
     411:         clr     dot
     412:         mov     $2,dotrel
     413:         mov     $..,dotdot
     414:         clr     brtabp
     415:
     416:         mov     $curfb,r4
     417: 1:
     418:         clr     (r4)+
     419:         cmp     r4,$curfb+40.
     420:         blo     1b
     421:         clr     r4
     422: 1:
     423:         jsr     pc,fbadv
     424:         inc     r4
     425:         cmp     r4,$10.
     426:         blt     1b
     427: / just rewind /tmp/atm1xx rather than close and re-open
     428:         clr     -(sp)
     429:         clr     -(sp)
     430:         clr     -(sp)
     431:         mov     fin,-(sp)
     432:         jsr     pc,_lseek               / lseek(fin, 0L, 0)
     433:         add     $8.,sp
     434:         clr     ibufc
     435:         rts     pc
     436:
     437: outw:
     438:         cmp     dot-2,$4
     439:         beq     9f
     440:         bit     $1,dot
     441:         bne     1f
     442:         add     $2,dot
     443:         tst     passno
     444:         beq     8f
     445:         clr     -(sp)
     446:         rol     r3
     447:         adc     (sp)
     448:         asr     r3                      / get relative pc bit
     449:         cmp     r3,$40
     450:         bne     2f
     451: / external references
     452:         mov     $666,outmod             / make nonexecutable
     453:         mov     xsymbol,r3
     454:         sub     hshtab,r3
     455:         asl     r3
     456:         bis     $4,r3                   / external relocation
     457:         br      3f
     458: 2:
     459:         bic     $40,r3                  / clear any ext bits
     460:         cmp     r3,$5
     461:         blo     4f
     462:         cmp     r3,$33                  / est. text, data
     463:         beq     6f
     464:         cmp     r3,$34
     465:         bne     7f
     466: 6:
     467:         mov     $'r,-(sp)
     468:         jsr     pc,error
     469: 7:
     470:         mov     $1,r3                   / make absolute
     471: 4:
     472:         cmp     r3,$2
     473:         blo     5f
     474:         cmp     r3,$4
     475:         bhi     5f
     476:         tst     (sp)
     477:         bne     4f
     478:         add     dotdot,r2
     479:         br      4f
     480: 5:
     481:         tst     (sp)
     482:         beq     4f
     483:         sub     dotdot,r2
     484: 4:
     485:         dec     r3
     486:         bpl     3f
     487:         clr     r3
     488: 3:
     489:         asl     r3
     490:         bis     (sp)+,r3
     491:         mov     r2,r0
     492:         mov     $txtp,-(sp)
     493:         jsr     pc,putw
     494:         mov     tseekp,r0
     495:         add     $2,2(r0)
     496:         adc     (r0)
     497:         mov     r3,r0
     498:         mov     $relp,-(sp)
     499:         jsr     pc,putw
     500:         mov     rseekp,r0
     501:         add     $2,2(r0)
     502:         adc     (r0)
     503: 8:
     504:         rts     pc
     505: 1:
     506:         mov     $'o,-(sp)
     507:         jsr     pc,error
     508:         clr     r3
     509:         jsr     pc,outb
     510:         rts     pc
     511: 9:
     512:         mov     $'x,-(sp)
     513:         jsr     pc,error
     514:         rts     pc
     515:
     516: outb:
     517:         cmp     dot-2,$4                / test bss mode
     518:         beq     9b
     519:         cmp     r3,$1
     520:         blos    1f
     521:         mov     $'r,-(sp)
     522:         jsr     pc,error
     523: 1:
     524:         tst     passno
     525:         beq     2f
     526:         mov     r2,r0
     527:         bit     $1,dot
     528:         bne     1f
     529:         mov     $txtp,-(sp)
     530:         jsr     pc,putw
     531:         clr     r0
     532:         mov     $relp,-(sp)
     533:         jsr     pc,putw
     534:         mov     tseekp,r0
     535:         add     $2,2(r0)
     536:         adc     (r0)
     537:         mov     rseekp,r0
     538:         add     $2,2(r0)
     539:         adc     (r0)
     540:         br      2f
     541: 1:
     542:         mov     txtp,r0
     543:         movb    r2,-1(r0)
     544: 2:
     545:         inc     dot
     546:         rts     pc
     547:
     548: / pass 1 and 2 common code
     549:
     550: pass1_2:
     551:         jsr     pc,readop
     552:         cmp     r4,$5
     553:         beq     2f
     554:         cmp     r4,$'<
     555:         beq     2f
     556:         jsr     pc,checkeos
     557:                 br eal1
     558:         mov     r4,-(sp)
     559:         cmp     (sp),$1
     560:         bne     1f
     561:         mov     $2,(sp)
     562:         jsr     pc,getw
     563:         mov     r4,numval
     564: 1:
     565:         jsr     pc,readop
     566:         cmp     r4,$'=
     567:         beq     4f
     568:         cmp     r4,$':
     569:         beq     1f
     570:         mov     r4,savop
     571:         mov     (sp)+,r4
     572: 2:
     573:         jsr     pc,opline
     574: dotmax:
     575:         tst     passno
     576:         bne     eal1
     577:         movb    dotrel,r0
     578:         asl     r0
     579:         cmp     dot,txtsiz-4(r0)
     580:         bhi     8f
     581:         jmp     ealoop
     582: 8:
     583:         mov     dot,txtsiz-4(r0)
     584: eal1:
     585:         jmp     ealoop
     586: 1:
     587:         mov     (sp)+,r4
     588:         cmp     r4,$200
     589:         bhis    1f
     590:         cmp     r4,$2
     591:         beq     3f
     592:         mov     $'x,-(sp)
     593:         jsr     pc,error
     594:         br      pass1_2
     595: 1:
     596:         tst     passno
     597:         bne     2f
     598:         movb    (r4),r0
     599:         bic     $!37,r0
     600:         beq     5f
     601:         cmp     r0,$33
     602:         blt     6f
     603:         cmp     r0,$34
     604:         ble     5f
     605: 6:
     606:         mov     $'m,-(sp)
     607:         jsr     pc,error
     608: 5:
     609:         bic     $37,(r4)
     610:         bis     dotrel,(r4)
     611:         mov     2(r4),brdelt
     612:         sub     dot,brdelt
     613:         mov     dot,2(r4)
     614:         br      pass1_2
     615: 2:
     616:         cmp     dot,2(r4)
     617:         beq     pass1_2
     618:         mov     $'p,-(sp)
     619:         jsr     pc,error
     620:         br      pass1_2
     621: 3:
     622:         mov     numval,r4
     623:         jsr     pc,fbadv
     624:         asl     r4
     625:         mov     curfb(r4),r0
     626:         movb    dotrel,(r0)
     627:         mov     2(r0),brdelt
     628:         sub     dot,brdelt
     629:         mov     dot,2(r0)
     630:         br      pass1_2
     631: 4:
     632:         jsr     pc,readop
     633:         jsr     pc,expres
     634:         mov     (sp)+,r1
     635:         cmp     r1,$dotrel              /test for dot
     636:         bne     1f
     637:         bic     $40,r3
     638:         cmp     r3,dotrel               / can't change relocation
     639:         bne     2f
     640:         cmp     r3,$4                   / bss
     641:         bne     3f
     642:         mov     r2,dot
     643:         br      dotmax
     644: 3:
     645:         sub     dot,r2
     646:         bmi     2f
     647:         mov     r2,-(sp)
     648: 3:
     649:         dec     (sp)
     650:         bmi     3f
     651:         clr     r2
     652:         mov     $1,r3
     653:         jsr     pc,outb
     654:         br      3b
     655: 3:
     656:         tst     (sp)+
     657:         br      dotmax
     658: 2:
     659:         mov     $'.,-(sp)
     660:         jsr     pc,error
     661:         br      ealoop
     662: 1:
     663:         cmp     r3,$40
     664:         bne     1f
     665:         mov     $'r,-(sp)
     666:         jsr     pc,error
     667: 1:
     668:         bic     $37,(r1)
     669:         bic     $!37,r3
     670:         bne     1f
     671:         clr     r2
     672: 1:
     673:         bisb    r3,(r1)
     674:         mov     r2,2(r1)
     675:
     676: ealoop:
     677:         cmp     r4,$'\n
     678:         beq     1f
     679:         cmp     r4,$'\e
     680:         bne     9f
     681:         rts     pc
     682: 1:
     683:         inc     line
     684: 9:
     685:         jmp     pass1_2
     686:
     687: checkeos:
     688:         cmp     r4,$'\n
     689:         beq     1f
     690:         cmp     r4,$';
     691:         beq     1f
     692:         cmp     r4,$'\e
     693:         beq     1f
     694:         add     $2,(sp)
     695: 1:
     696:         rts     pc
     697:
     698: fbadv:
     699:         asl     r4
     700:         mov     nxtfb(r4),r1
     701:         mov     r1,curfb(r4)
     702:         bne     1f
     703:         mov     fbbufp,r1
     704:         br      2f
     705: 1:
     706:         add     $4,r1
     707: 2:
     708:         cmpb    1(r1),r4
     709:         beq     1f
     710:         tst     (r1)
     711:         bpl     1b
     712: 1:
     713:         mov     r1,nxtfb(r4)
     714:         asr     r4
     715:         rts     pc
     716:
     717: oset:
     718:         mov     r2,-(sp)
     719:         mov     r3,-(sp)
     720:         mov     6(sp),r3
     721:         mov     r1,r2
     722:         bic     $!1777,r1
     723:         add     r3,r1
     724:         add     $8,r1
     725:         mov     r1,(r3)+                / next slot
     726:         mov     r3,r1
     727:         add     $2006,r1
     728:         mov     r1,(r3)+                / buf max
     729:         mov     r0,(r3)+
     730:         mov     r2,(r3)+                / seek addr
     731:         mov     (sp)+,r3
     732:         mov     (sp)+,r2
     733:         mov     (sp)+,(sp)
     734:         rts     pc
     735:
     736: putw:
     737:         mov     r1,-(sp)
     738:         mov     r2,-(sp)
     739:         mov     6(sp),r2
     740:         mov     (r2)+,r1                / slot
     741:         cmp     r1,(r2)                 / buf max
     742:         bhis    1f
     743:         mov     r0,(r1)+
     744:         mov     r1,-(r2)
     745:         br      2f
     746: 1:
     747:         tst     (r2)+
     748:         mov     r0,-(sp)
     749:         jsr     pc,flush1
     750:         mov     (sp)+,r0
     751:         mov     r0,*(r2)+
     752:         add     $2,-(r2)
     753: 2:
     754:         mov     (sp)+,r2
     755:         mov     (sp)+,r1
     756:         mov     (sp)+,(sp)
     757: ret:
     758:         rts     pc
     759:
     760: flush:
     761:         mov     2(sp),r2
     762:         mov     (sp)+,(sp)
     763:         cmp     (r2)+,(r2)+
     764: flush1:
     765:
     766:         clr     -(sp)                   / lseek(fout, (r2)L+, L_SET)
     767:         mov     2(r2),-(sp)
     768:         mov     (r2)+,-(sp)
     769:         tst     (r2)+
     770:         mov     fout,-(sp)
     771:         jsr     pc,_lseek
     772:         add     $8.,sp
     773:
     774:         cmp     -(sp),-(sp)             / write(fout, <buf>, <len>)
     775:         bic     $!1777,r1
     776:         add     r2,r1                   / write address
     777:         mov     r1,-(sp)                / { <buf> }
     778:         mov     r2,r0
     779:         bis     $1777,-(r2)
     780:         add     $1,(r2)                 / new seek addr
     781:         adc     -(r2)
     782:         cmp     -(r2),-(r2)
     783:         sub     (r2),r1
     784:         neg     r1
     785:         mov     r1,2(sp)                / count
     786:         mov     r0,(r2)                 / new next slot
     787:
     788:         mov     fout,-(sp)
     789:         mov     r1,6(sp)                / protect r1 from library
     790:         jsr     pc,_write
     791:         add     $6,sp
     792:         mov     (sp)+,r1
     793:         tst     r0
     794:         bpl     ret
     795: / fall thru to wrterr
     796:
     797: wrterr:
     798:         mov     $8f-9f,-(sp)            / write(1, 9f, 8f-9f)
     799:         mov     $9f,-(sp)
     800:         mov     $1,-(sp)
     801:         jsr     pc,_write
     802:         add     $6,sp
     803:         jsr     pc,saexit
     804: / not reached
     805:
     806:         .data
     807: 9:
     808:         <as: write error\n>
     809: 8:
     810:         .even
     811:         .text
     812:
     813: readop:
     814:         mov     savop,r4
     815:         beq     1f
     816:         clr     savop
     817:         rts     pc
     818: 1:
     819:         jsr     pc,getw1
     820:         cmp     r4,$200
     821:         blo     1f
     822:         cmp     r4,$4000
     823:         blo     2f
     824:         sub     $4000,r4
     825:         asl     r4
     826:         asl     r4
     827:         add     hshtab,r4
     828:         rts     pc
     829: 2:
     830: / remove PST flag (1000) then multiply by PSTENTSZ.  In pass 0 the PST
     831: / symbol number was divided by PSTENTSZ(to make it fit) - we now reverse
     832: / that process.
     833:         mov     r5,-(sp)
     834:         mov     r4,r5
     835:         sub     $1000,r5
     836:         mul     $PSTENTSZ,r5
     837:         mov     r5,r4
     838:         mov     (sp)+,r5
     839:         add     $dotrel,r4              / point at dot's flag field
     840: 1:
     841:         rts     pc
     842:
     843: getw:
     844:         mov     savop,r4
     845:         beq     getw1
     846:         clr     savop
     847:         rts     pc
     848: getw1:
     849:         dec     ibufc
     850:         bgt     1f
     851:
     852:         mov     r1,-(sp)                / protect r1 from library
     853:         mov     $1024.,-(sp)            / read(fin, inbuf, 1024)
     854:         mov     $inbuf,-(sp)
     855:         mov     fin,-(sp)
     856:         jsr     pc,_read
     857:         add     $6,sp
     858:         mov     (sp)+,r1
     859:         asr     r0
     860:         mov     r0,ibufc
     861:         bgt     2f
     862:         mov     $4,r4
     863:         sev
     864:         rts     pc
     865: 2:
     866:         mov     $inbuf,ibufp
     867: 1:
     868:         mov     *ibufp,r4
     869:         add     $2,ibufp
     870:         rts     pc
     871:
     872: opline:
     873:         mov     r4,r0
     874:         bmi     2f
     875:         cmp     r0,$177
     876:         bgt     2f
     877:         cmp     r4,$5
     878:         beq     opeof
     879:         cmp     r4,$'<
     880:         bne     xpr
     881:         jmp     opl17
     882: xxpr:
     883:         tst     (sp)+
     884: xpr:
     885:         jsr     pc,expres
     886:         jsr     pc,outw
     887:         rts     pc
     888: 2:
     889:         movb    (r4),r0
     890:         cmp     r0,$24                  /reg
     891:         beq     xpr
     892:         cmp     r0,$33                  /est text
     893:         beq     xpr
     894:         cmp     r0,$34                  / est data
     895:         beq     xpr
     896:         cmp     r0,$5
     897:         blt     xpr
     898:         cmp     r0,$36
     899:         bgt     xpr
     900:         mov     2(r4),-(sp)
     901:         mov     r0,-(sp)
     902:         jsr     pc,readop
     903:         mov     (sp)+,r0
     904:         asl     r0
     905:         mov     $adrbuf,r5
     906:         clr     swapf
     907:         mov     $-1,rlimit
     908:         jmp     *1f-10.(r0)
     909:         .data
     910: 1:
     911:         opl5
     912:         opl6
     913:         opl7
     914:         opl10
     915:         opl11
     916:         opl12
     917:         opl13
     918:         opl14
     919:         opl15
     920:         opl16
     921:         opl17
     922:         opl20
     923:         opl21
     924:         opl22
     925:         opl23
     926:         xxpr
     927:         opl25
     928:         opl26
     929:         opl27
     930:         opl30
     931:         opl31
     932:         opl32
     933:         xxpr
     934:         xxpr
     935:         opl35
     936:         opl36
     937:         .text
     938:
     939: opeof:
     940:         mov     $1,line
     941:         mov     $20,-(sp)
     942:         mov     $argb,r1
     943: 1:
     944:         jsr     pc,getw
     945:         tst     r4
     946:         bmi     1f
     947:         movb    r4,(r1)+
     948:         dec     (sp)
     949:         bgt     1b
     950:         tstb    -(r1)
     951:         br      1b
     952: 1:
     953:         movb    $'\n,(r1)+
     954:         clrb    (r1)+
     955:         tst     (sp)+
     956:         rts     pc
     957:
     958: opl30:                                  / mul, div etc
     959:         inc     swapf
     960:         mov     $1000,rlimit
     961:         br      opl13
     962:
     963: opl14:                                  / flop freg,fsrc
     964:         inc     swapf
     965:
     966: opl5:                                   / flop src,freg
     967:         mov     $400,rlimit
     968:
     969: opl13:                                  /double
     970:         jsr     pc,addres
     971: op2a:
     972:         mov     r2,-(sp)
     973:         jsr     pc,readop
     974: op2b:
     975:         jsr     pc,addres
     976:         tst     swapf
     977:         beq     1f
     978:         mov     (sp),r0
     979:         mov     r2,(sp)
     980:         mov     r0,r2
     981: 1:
     982:         swab    (sp)
     983:         asr     (sp)
     984:         asr     (sp)
     985:         cmp     (sp),rlimit
     986:         blo     1f
     987:         mov     $'x,-(sp)
     988:         jsr     pc,error
     989: 1:
     990:         bis     (sp)+,r2
     991:         bis     (sp)+,r2
     992:         clr     r3
     993:         jsr     pc,outw
     994:         mov     $adrbuf,r1
     995: 1:
     996:         cmp     r1,r5
     997:         bhis    1f
     998:         mov     (r1)+,r2
     999:         mov     (r1)+,r3
    1000:         mov     (r1)+,xsymbol
    1001:         jsr     pc,outw
    1002:         br      1b
    1003: 1:
    1004:         rts     pc
    1005:
    1006: opl15:                                  / single operand
    1007:         clr     -(sp)
    1008:         br      op2b
    1009:
    1010: opl12:                                  / movf
    1011:         mov     $400,rlimit
    1012:         jsr     pc,addres
    1013:         cmp     r2,$4                   / see if source is fregister
    1014:         blo     1f
    1015:         inc     swapf
    1016:         br      op2a
    1017: 1:
    1018:         mov     $174000,(sp)
    1019:         br      op2a
    1020:
    1021: opl35:                                  / jbr
    1022: opl36:                                  / jeq, jne, etc
    1023:         jsr     pc,expres
    1024:         tst     passno
    1025:         bne     1f
    1026:         mov     r2,r0
    1027:         jsr     pc,setbr
    1028:         tst     r2
    1029:         beq     2f
    1030:         cmp     (sp),$br
    1031:         beq     2f
    1032:         add     $2,r2
    1033: 2:
    1034:         add     r2,dot                  / if doesn't fit
    1035:         add     $2,dot
    1036:         tst     (sp)+
    1037:         rts     pc
    1038: 1:
    1039:         jsr     pc,getbr
    1040:         bcc     dobranch
    1041:         mov     (sp)+,r0
    1042:         mov     r2,-(sp)
    1043:         mov     r3,-(sp)
    1044:         cmp     r0,$br
    1045:         beq     2f
    1046:         mov     $402,r2
    1047:         xor     r0,r2                   / flip cond, add ".+6"
    1048:         mov     $1,r3
    1049:         jsr     pc,outw
    1050: 2:
    1051:         mov     $1,r3
    1052:         mov     $jmp+37,r2
    1053:         jsr     pc,outw
    1054:         mov     (sp)+,r3
    1055:         mov     (sp)+,r2
    1056:         jsr     pc,outw
    1057:         rts     pc
    1058:
    1059: opl31:                                  / sob
    1060:         jsr     pc,expres
    1061:         jsr     pc,checkreg
    1062:         swab    r2
    1063:         asr     r2
    1064:         asr     r2
    1065:         bis     r2,(sp)
    1066:         jsr     pc,readop
    1067:         jsr     pc,expres
    1068:         tst     passno
    1069:         beq     3f
    1070:         sub     dot,r2
    1071:         neg     r2
    1072:         mov     r2,r0
    1073:         cmp     r0,$-2
    1074:         blt     2f
    1075:         cmp     r0,$175
    1076:         bgt     2f
    1077:         add     $4,r2
    1078:         br      1f
    1079:
    1080: opl6:                                   /branch
    1081:         jsr     pc,expres
    1082:         tst     passno
    1083:         beq     3f
    1084: dobranch:
    1085:         sub     dot,r2
    1086:         mov     r2,r0
    1087:         cmp     r0,$-254.
    1088:         blt     2f
    1089:         cmp     r0,$256.
    1090:         bgt     2f
    1091: 1:
    1092:         bit     $1,r2
    1093:         bne     2f
    1094:         cmp     r3,dot-2                / same relocation as .
    1095:         bne     2f
    1096:         asr     r2
    1097:         dec     r2
    1098:         bic     $177400,r2
    1099: 3:
    1100:         bis     (sp)+,r2
    1101:         clr     r3
    1102:         jsr     pc,outw
    1103:         rts     pc
    1104: 2:
    1105:         mov     $'b,-(sp)
    1106:         jsr     pc,error
    1107:         clr     r2
    1108:         br      3b
    1109:
    1110: opl7:                                   /jsr
    1111:         jsr     pc,expres
    1112:         jsr     pc,checkreg
    1113:         jmp     op2a
    1114:
    1115: opl10:                                  / rts
    1116:         jsr     pc,expres
    1117:         jsr     pc,checkreg
    1118:         br      1f
    1119:
    1120: opl11:                                  / sys
    1121:         jsr     pc,expres
    1122:         cmp     r2,$256.
    1123:         bhis    0f
    1124:         cmp     r3,$1
    1125:         ble     1f
    1126: 0:
    1127:         mov     $'a,-(sp)
    1128:         jsr     pc,error
    1129: 1:
    1130:         bis     (sp)+,r2
    1131:         jsr     pc,outw
    1132:         rts     pc
    1133:
    1134: opl16:                                  / .byte
    1135:         jsr     pc,expres
    1136:         jsr     pc,outb
    1137:         cmp     r4,$',
    1138:         bne     1f
    1139:         jsr     pc,readop
    1140:         br      opl16
    1141: 1:
    1142:         tst     (sp)+
    1143:         rts     pc
    1144:
    1145: opl17:                                  / < (.ascii)
    1146:         jsr     pc,getw
    1147:         mov     $1,r3
    1148:         mov     r4,r2
    1149:         bmi     2f
    1150:         bic     $!377,r2
    1151:         jsr     pc,outb
    1152:         br      opl17
    1153: 2:
    1154:         jsr     pc,getw
    1155:         rts     pc
    1156:
    1157: opl20:                                  /.even
    1158:         bit     $1,dot
    1159:         beq     1f
    1160:         cmp     dot-2,$4
    1161:         beq     2f                      / bss mode
    1162:         clr     r2
    1163:         clr     r3
    1164:         jsr     pc,outb
    1165:         br      1f
    1166: 2:
    1167:         inc     dot
    1168: 1:
    1169:         tst     (sp)+
    1170:         rts     pc
    1171:
    1172: opl21:                                  /if
    1173:         jsr     pc,expres
    1174: opl22:
    1175: oplret:
    1176:         tst     (sp)+
    1177:         rts     pc
    1178:
    1179: opl23:                                  /.globl
    1180:         cmp     r4,$200
    1181:         blo     1f
    1182:         bisb    $40,(r4)
    1183:         jsr     pc,readop
    1184:         cmp     r4,$',
    1185:         bne     1f
    1186:         jsr     pc,readop
    1187:         br      opl23
    1188: 1:
    1189:         tst     (sp)+
    1190:         rts     pc
    1191:
    1192: opl25:                                  / .text, .data, .bss
    1193: opl26:
    1194: opl27:
    1195:         inc     dot
    1196:         bic     $1,dot
    1197:         mov     r0,-(sp)
    1198:         mov     dot-2,r1
    1199:         asl     r1
    1200:         mov     dot,savdot-4(r1)
    1201:         tst     passno
    1202:         beq     1f
    1203:         mov     $txtp,-(sp)
    1204:         jsr     pc,flush
    1205:         mov     $relp,-(sp)
    1206:         jsr     pc,flush
    1207:         mov     (sp),r2
    1208:         asl     r2
    1209:         add     $txtseek-[4*25],r2
    1210:         mov     r2,tseekp
    1211:         mov     (r2),r0
    1212:         mov     2(r2),r1
    1213:         mov     $txtp,-(sp)
    1214:         jsr     pc,oset
    1215:         add     $trelseek-txtseek,r2
    1216:         mov     (r2),r0
    1217:         mov     2(r2),r1
    1218:         mov     r2,rseekp
    1219:         mov     $relp,-(sp)
    1220:         jsr     pc,oset
    1221: 1:
    1222:         mov     (sp)+,r0
    1223:         mov     savdot-[2*25](r0),dot
    1224:         asr     r0
    1225:         sub     $25-2,r0
    1226:         mov     r0,dot-2                / new . relocation
    1227:         tst     (sp)+
    1228:         rts     pc
    1229:
    1230: opl32:
    1231:         cmp     r4,$200
    1232:         blo     1f
    1233:         mov     r4,-(sp)
    1234:         jsr     pc,readop
    1235:         jsr     pc,readop
    1236:         jsr     pc,expres
    1237:         mov     (sp)+,r0
    1238:         bit     $37,(r0)
    1239:         bne     1f
    1240:         bis     $40,(r0)
    1241:         mov     r2,2(r0)
    1242: 1:
    1243:         tst     (sp)+
    1244:         rts     pc
    1245:
    1246: addres:
    1247:         clr     -(sp)
    1248: 4:
    1249:         cmp     r4,$'(
    1250:         beq     alp
    1251:         cmp     r4,$'-
    1252:         beq     amin
    1253:         cmp     r4,$'$
    1254:         beq     adoll
    1255:         cmp     r4,$'*
    1256:         bne     getx
    1257:         jmp     astar
    1258: getx:
    1259:         jsr     pc,expres
    1260:         cmp     r4,$'(
    1261:         bne     2f
    1262:         jsr     pc,readop
    1263:         mov     r2,(r5)+
    1264:         mov     r3,(r5)+
    1265:         mov     xsymbol,(r5)+
    1266:         jsr     pc,expres
    1267:         jsr     pc,checkreg
    1268:         jsr     pc,checkrp
    1269:         bis     $60,r2
    1270:         bis     (sp)+,r2
    1271:         rts     pc
    1272:
    1273: 2:
    1274:         cmp     r3,$24
    1275:         bne     1f
    1276:         jsr     pc,checkreg
    1277:         bis     (sp)+,r2
    1278:         rts     pc
    1279: 1:
    1280:         mov     r3,-(sp)
    1281:         bic     $40,r3
    1282:         mov     (sp)+,r3
    1283:         bis     $100000,r3
    1284:         sub     dot,r2
    1285:         sub     $4,r2
    1286:         cmp     r5,$adrbuf
    1287:         beq     1f
    1288:         sub     $2,r2
    1289: 1:
    1290:         mov     r2,(r5)+                / index
    1291:         mov     r3,(r5)+                / index reloc.
    1292:         mov     xsymbol,(r5)+           / index global
    1293:         mov     $67,r2                  / address mode
    1294:         bis     (sp)+,r2
    1295:         rts     pc
    1296:
    1297: alp:
    1298:         jsr     pc,readop
    1299:         jsr     pc,expres
    1300:         jsr     pc,checkrp
    1301:         jsr     pc,checkreg
    1302:         cmp     r4,$'+
    1303:         beq     1f
    1304:         tst     (sp)+
    1305:         beq     2f
    1306:         bis     $70,r2
    1307:         clr     (r5)+
    1308:         clr     (r5)+
    1309:         mov     xsymbol,(r5)+
    1310:         rts     pc
    1311: 2:
    1312:         bis     $10,r2
    1313:         rts     pc
    1314: 1:
    1315:         jsr     pc,readop
    1316:         bis     $20,r2
    1317:         bis     (sp)+,r2
    1318:         rts     pc
    1319:
    1320: amin:
    1321:         jsr     pc,readop
    1322:         cmp     r4,$'(
    1323:         beq     1f
    1324:         mov     r4,savop
    1325:         mov     $'-,r4
    1326:         br      getx
    1327: 1:
    1328:         jsr     pc,readop
    1329:         jsr     pc,expres
    1330:         jsr     pc,checkrp
    1331:         jsr     pc,checkreg
    1332:         bis     (sp)+,r2
    1333:         bis     $40,r2
    1334:         rts     pc
    1335:
    1336: adoll:
    1337:         jsr     pc,readop
    1338:         jsr     pc,expres
    1339:         mov     r2,(r5)+
    1340:         mov     r3,(r5)+
    1341:         mov     xsymbol,(r5)+
    1342:         mov     (sp)+,r2
    1343:         bis     $27,r2
    1344:         rts     pc
    1345:
    1346: astar:
    1347:         tst     (sp)
    1348:         beq     1f
    1349:         mov     $'*,-(sp)
    1350:         jsr     pc,error
    1351: 1:
    1352:         mov     $10,(sp)
    1353:         jsr     pc,readop
    1354:         jmp     4b
    1355:
    1356: checkreg:
    1357:         cmp     r2,$7
    1358:         bhi     1f
    1359:         cmp     r1,$1
    1360:         blos    2f
    1361:         cmp     r3,$5
    1362:         blo     1f
    1363: 2:
    1364:         rts     pc
    1365: 1:
    1366:         mov     $'a,-(sp)
    1367:         jsr     pc,error
    1368:         clr     r2
    1369:         clr     r3
    1370:         rts     pc
    1371:
    1372: checkrp:
    1373:         cmp     r4,$')
    1374:         beq     1f
    1375:         mov     $'),-(sp)
    1376:         jsr     pc,error
    1377:         rts     pc
    1378: 1:
    1379:         jsr     pc,readop
    1380:         rts     pc
    1381:
    1382: setbr:
    1383:         mov     brtabp,r1
    1384:         cmp     r1,$brlen
    1385:         blt     1f
    1386:         mov     $2,r2
    1387:         rts     pc
    1388: 1:
    1389:         inc     brtabp
    1390:         clr     -(sp)
    1391:         sub     dot,r0
    1392:         ble     1f
    1393:         sub     brdelt,r0
    1394: 1:
    1395:         cmp     r0,$-254.
    1396:         blt     1f
    1397:         cmp     r0,$256.
    1398:         ble     2f
    1399: 1:
    1400:         mov     r1,-(sp)
    1401:         bic     $!7,(sp)
    1402:         mov     $1,r0
    1403:         ash     (sp)+,r0
    1404:         ash     $-3,r1
    1405:         bisb    r0,brtab(r1)
    1406:         mov     $2,(sp)
    1407: 2:
    1408:         mov     (sp)+,r2
    1409:         rts     pc
    1410:
    1411: getbr:
    1412:         mov     brtabp,r1
    1413:         cmp     r1,$brlen
    1414:         blt     1f
    1415:         sec
    1416:         rts     pc
    1417: 1:
    1418:         mov     r1,-(sp)
    1419:         bic     $!7,(sp)
    1420:         neg     (sp)
    1421:         inc     brtabp
    1422:         ash     $-3,r1
    1423:         movb    brtab(r1),r1
    1424:         ash     (sp)+,r1
    1425:         ror     r1                      / 0-bit into c-bit
    1426:         rts     pc
    1427:
    1428: expres:
    1429:         clr     xsymbol
    1430: expres1:
    1431:         mov     r5,-(sp)
    1432:         mov     $'+,-(sp)
    1433:         clr     r2
    1434:         mov     $1,r3
    1435:         br      1f
    1436: advanc:
    1437:         jsr     pc,readop
    1438: 1:
    1439:         mov     r4,r0
    1440:         blt     6f
    1441:         cmp     r0,$177
    1442:         ble     7f
    1443: 6:
    1444:         movb    (r4),r0
    1445:         bne     1f
    1446:         tst     passno
    1447:         beq     1f
    1448:         mov     $'u,-(sp)
    1449:         jsr     pc,error
    1450: 1:
    1451:         tst     overlaid
    1452:         beq     0f
    1453: /
    1454: / Bill Shannon's hack to the assembler to force globl text
    1455: / references to remain undefined so that the link editor may
    1456: / resolve them. This is necessary if a function is used as an
    1457: / arg in an overlay located piece of code, and the function is
    1458: / actually in another overlay. Elsewise, the assembler fix's up
    1459: / the reference before the link editor changes the globl refrence
    1460: / to the thunk. -wfj 5/80
    1461:         cmp     r0,$42                  / is it globl text ?
    1462:         bne     0f                      / nope
    1463:         mov     $40,r0                  / yes, treat it as undefined external
    1464: 0:
    1465:         cmp     r0,$40
    1466:         bne     1f
    1467:         mov     r4,xsymbol
    1468:         clr     r1
    1469:         br      oprand
    1470: 1:
    1471:         mov     2(r4),r1
    1472:         br      oprand
    1473: 7:
    1474:         cmp     r4,$141
    1475:         blo     1f
    1476:         asl     r4
    1477:         mov     curfb-[2*141](r4),r0
    1478:         mov     2(r0),r1
    1479:         movb    (r0),r0
    1480:         br      oprand
    1481: 1:
    1482:         mov     $esw1,r1
    1483: 1:
    1484:         cmp     (r1)+,r4
    1485:         beq     1f
    1486:         tst     (r1)+
    1487:         bne     1b
    1488:         tst     (sp)+
    1489:         mov     (sp)+,r5
    1490:         rts     pc
    1491: 1:
    1492:         jmp     *(r1)
    1493:         .data
    1494: esw1:
    1495:         '+;     binop
    1496:         '-;     binop
    1497:         '*;     binop
    1498:         '/;     binop
    1499:         '&;     binop
    1500:         037;    binop
    1501:         035;    binop
    1502:         036;    binop
    1503:         '%;     binop
    1504:         '[;     brack
    1505:         '^;     binop
    1506:         1;      exnum
    1507:         2;      exnum1
    1508:         '!;     binop
    1509:         200;    0
    1510:         .text
    1511: binop:
    1512:         cmpb    (sp),$'+
    1513:         beq     1f
    1514:         mov     $'e,-(sp)
    1515:         jsr     pc,error
    1516: 1:
    1517:         movb    r4,(sp)
    1518:         br      advanc
    1519:
    1520: exnum1:
    1521:         mov     numval,r1
    1522:         br      1f
    1523:
    1524: exnum:
    1525:         jsr     pc,getw
    1526:         mov     r4,r1
    1527: 1:
    1528:         mov     $1,r0
    1529:         br      oprand
    1530:
    1531: brack:
    1532:         mov     r2,-(sp)
    1533:         mov     r3,-(sp)
    1534:         jsr     pc,readop
    1535:         jsr     pc,expres1
    1536:         cmp     r4,$']
    1537:         beq     1f
    1538:         mov     $'],-(sp)
    1539:         jsr     pc,error
    1540: 1:
    1541:         mov     r3,r0
    1542:         mov     r2,r1
    1543:         mov     (sp)+,r3
    1544:         mov     (sp)+,r2
    1545:
    1546: oprand:
    1547:         mov     $exsw2,r5
    1548: 1:
    1549:         cmp     (sp),(r5)+
    1550:         beq     1f
    1551:         tst     (r5)+
    1552:         bne     1b
    1553:         br      eoprnd
    1554: 1:
    1555:         jmp     *(r5)
    1556:         .data
    1557: exsw2:
    1558:         '+; exadd
    1559:         '-; exsub
    1560:         '*; exmul
    1561:         '/; exdiv
    1562:         037; exor
    1563:         '&; exand
    1564:         035;exlsh
    1565:         036;exrsh
    1566:         '%; exmod
    1567:         '^; excmbin
    1568:         '!; exnot
    1569:         200;  0
    1570:         .text
    1571: excmbin:
    1572:         mov     r0,r3
    1573:         br      eoprnd
    1574:
    1575: exrsh:
    1576:         neg     r1
    1577:         beq     exlsh
    1578:         inc     r1
    1579:         clc
    1580:         ror     r2
    1581: exlsh:
    1582:         mov     $relte2,r5
    1583:         jsr     pc,combin
    1584:         ash     r1,r2
    1585:         br      eoprnd
    1586:
    1587: exmod:
    1588:         mov     $relte2,r5
    1589:         jsr     pc,combin
    1590:         mov     r3,r0
    1591:         mov     r2,r3
    1592:         clr     r2
    1593:         div     r1,r2
    1594:         mov     r3,r2
    1595:         mov     r0,r3
    1596:         br      eoprnd
    1597:
    1598: exadd:
    1599:         mov     $reltp2,r5
    1600:         jsr     pc,combin
    1601:         add     r1,r2
    1602:         br      eoprnd
    1603:
    1604: exsub:
    1605:         mov     $reltm2,r5
    1606:         jsr     pc,combin
    1607:         sub     r1,r2
    1608:         br      eoprnd
    1609:
    1610: exand:
    1611:         mov     $relte2,r5
    1612:         jsr     pc,combin
    1613:         com     r1
    1614:         bic     r1,r2
    1615:         br      eoprnd
    1616:
    1617: exor:
    1618:         mov     $relte2,r5
    1619:         jsr     pc,combin
    1620:         bis     r1,r2
    1621:         br      eoprnd
    1622:
    1623: exmul:
    1624:         mov     $relte2,r5
    1625:         jsr     pc,combin
    1626:         mul     r2,r1
    1627:         mov     r1,r2
    1628:         br      eoprnd
    1629:
    1630: exdiv:
    1631:         mov     $relte2,r5
    1632:         jsr     pc,combin
    1633:         mov     r3,r0
    1634:         mov     r2,r3
    1635:         clr     r2
    1636:         div     r1,r2
    1637:         mov     r0,r3
    1638:         br      eoprnd
    1639:
    1640: exnot:
    1641:         mov     $relte2,r5
    1642:         jsr     pc,combin
    1643:         com     r1
    1644:         add     r1,r2
    1645:         br      eoprnd
    1646:
    1647: eoprnd:
    1648:         mov     $'+,(sp)
    1649:         jmp     advanc
    1650:
    1651: combin:
    1652:         tst     passno
    1653:         bne     combin1
    1654:         mov     r0,-(sp)
    1655:         bis     r3,(sp)
    1656:         bic     $!40,(sp)
    1657:         bic     $!37,r0
    1658:         bic     $!37,r3
    1659:         cmp     r0,r3
    1660:         ble     1f
    1661:         mov     r0,-(sp)
    1662:         mov     r3,r0
    1663:         mov     (sp)+,r3
    1664: 1:
    1665:         tst     r0
    1666:         beq     1f
    1667:         cmp     r5,$reltm2
    1668:         bne     2f
    1669:         cmp     r0,r3
    1670:         bne     2f
    1671:         mov     $1,r3
    1672:         br      2f
    1673: 1:
    1674:         clr     r3
    1675: 2:
    1676:         bis     (sp)+,r3
    1677:         rts     pc
    1678: combin1:
    1679:         mov     r1,-(sp)
    1680:         clr     maxtyp
    1681:         jsr     pc,maprel
    1682:         mov     r0,r1
    1683:         mul     $6,r1
    1684:         mov     r3,r0
    1685:         jsr     pc,maprel
    1686:         add     r5,r0
    1687:         add     r1,r0
    1688:         movb    (r0),r3
    1689:         bpl     1f
    1690:         cmp     r3,$-1
    1691:         beq     2f
    1692:         mov     $'r,-(sp)
    1693:         jsr     pc,error
    1694: 2:
    1695:         mov     maxtyp,r3
    1696: 1:
    1697:         mov     (sp)+,r1
    1698:         rts     pc
    1699:
    1700: maprel:
    1701:         cmp     r0,$40
    1702:         bne     1f
    1703:         mov     $5,r0
    1704:         rts     pc
    1705: 1:
    1706:         bic     $!37,r0
    1707:         cmp     r0,maxtyp
    1708:         blos    1f
    1709:         mov     r0,maxtyp
    1710: 1:
    1711:         cmp     r0,$5
    1712:         blo     1f
    1713:         mov     $1,r0
    1714: 1:
    1715:         rts     pc
    1716:         .data
    1717: X = -2
    1718: M = -1
    1719: reltp2:
    1720:         .byte 0, 0, 0, 0, 0, 0
    1721:         .byte 0, M, 2, 3, 4,40
    1722:         .byte 0, 2, X, X, X, X
    1723:         .byte 0, 3, X, X, X, X
    1724:         .byte 0, 4, X, X, X, X
    1725:         .byte 0,40, X, X, X, X
    1726:
    1727: reltm2:
    1728:         .byte 0, 0, 0, 0, 0, 0
    1729:         .byte 0, M, 2, 3, 4,40
    1730:         .byte 0, X, 1, X, X, X
    1731:         .byte 0, X, X, 1, X, X
    1732:         .byte 0, X, X, X, 1, X
    1733:         .byte 0, X, X, X, X, X
    1734:
    1735: relte2:
    1736:         .byte 0, 0, 0, 0, 0, 0
    1737:         .byte 0, M, X, X, X, X
    1738:         .byte 0, X, X, X, X, X
    1739:         .byte 0, X, X, X, X, X
    1740:         .byte 0, X, X, X, X, X
    1741:         .byte 0, X, X, X, X, X
    1742:
    1743: qnl:    <?\n>
    1744: a.out:  <a.out\0>
    1745:         .even
    1746: a.outp: a.out
    1747:
    1748: obufp:  outbuf
    1749: passno: -1
    1750: outmod: 0777
    1751:
    1752: tseekp: txtseek
    1753: rseekp: trelseek
    1754:
    1755: txtmagic:
    1756:         br      .+20
    1757: txtsiz: .=.+2
    1758: datsiz: .=.+2
    1759: bsssiz: .=.+2
    1760: symsiz: .=.+2
    1761:         .=.+6
    1762:
    1763: txtseek:0; 20
    1764: datseek:.=.+4
    1765:         .=.+4
    1766: trelseek:.=.+4
    1767: drelseek:.=.+4
    1768:         .=.+4
    1769: symseek:.=.+4
    1770:
    1771:         .bss
    1772: brlen   = 1024.
    1773: brtab:  .=.+[brlen\/8.]
    1774: brtabp: .=.+2
    1775: brdelt: .=.+2
    1776: fbbufp: .=.+2
    1777: defund: .=.+2
    1778: datbase:.=.+2
    1779: bssbase:.=.+2
    1780: ibufc:  .=.+2
    1781: overlaid: .=.+2
    1782: adrbuf: .=.+12.
    1783: xsymbol:.=.+2
    1784: errflg: .=.+2
    1785: argb:   .=.+22.
    1786: numval: .=.+2
    1787: maxtyp: .=.+2
    1788: ibufp:  .=.+2
    1789: txtp:   .=.+8.
    1790:         .=.+1024.
    1791: relp:   .=.+8.
    1792: outbuf:
    1793:         .=.+1024.
    1794: swapf:  .=.+2
    1795: rlimit: .=.+2
    1796: endtable:.=.+2
    1797: totalsz:                        / string table length
    1798:         .=.+4
    1799:         .text

#### Defined functions

addres defined in line 1246; used 3 times

- in line 970-975(2), 1012

adoll defined in line 1336; used 1 times

- in line 1254

advanc defined in line 1436; used 2 times

- in line 1518, 1649

aexit declared in line 9; defined in line 210; used 10 times

- in line 9, 116, 204
- in /usr/src/bin/as/as0.s line 4, 69, 206, 548, 765, 797, 976

alp defined in line 1297; used 1 times

- in line 1250

amin defined in line 1320; used 1 times

- in line 1252

astar defined in line 1346; used 1 times

- in line 1257

binop defined in line 1511; used 11 times

- in line 1495-1508(11)

brack defined in line 1531; used 1 times

- in line 1504

checkeos declared in line 7; defined in line 687; used 5 times

- in line 7, 556
- in /usr/src/bin/as/as0.s line 4, 338, 450

checkreg defined in line 1356; used 7 times

- in line 1061, 1112-1117(2), 1267, 1276, 1301, 1331

checkrp defined in line 1372; used 3 times

- in line 1268, 1300, 1330

combin defined in line 1651; used 9 times

- in line 1583, 1589, 1600, 1606, 1612, 1619, 1625, 1632, 1642

combin1 defined in line 1678; used 1 times

- in line 1653

dobranch defined in line 1084; used 1 times

- in line 1040

doreloc defined in line 392; used 1 times

- in line 157

dotmax defined in line 574; used 2 times

- in line 643, 657

eal1 defined in line 584; used 2 times

- in line 557, 576

ealoop defined in line 676; used 3 times

- in line 581-585(2), 661

eoprnd defined in line 1647; used 11 times

- in line 1553, 1573, 1585, 1596, 1602, 1608, 1615, 1621, 1628, 1638, 1645

exadd defined in line 1598; used 1 times

- in line 1558

exand defined in line 1610; used 1 times

- in line 1563

excmbin defined in line 1571; used 1 times

- in line 1567

exdiv defined in line 1630; used 1 times

- in line 1561

exlsh defined in line 1581; used 2 times

- in line 1564, 1577

exmod defined in line 1587; used 1 times

- in line 1566

exmul defined in line 1623; used 1 times

- in line 1560

exnot defined in line 1640; used 1 times

- in line 1568

exnum defined in line 1524; used 1 times

- in line 1506

exnum1 defined in line 1520; used 1 times

- in line 1507

exor defined in line 1617; used 1 times

- in line 1562

expres defined in line 1428; used 17 times

- in line 633, 885, 1023, 1060, 1067, 1081, 1111-1121(3), 1135, 1173, 1236, 1259, 1266, 1299, 1329, 1338

expres1 defined in line 1430; used 1 times

- in line 1535

exrsh defined in line 1575; used 1 times

- in line 1565

exsub defined in line 1604; used 1 times

- in line 1559

fbadv defined in line 698; used 2 times

- in line 423, 623

filerr declared in line 9; defined in line 231; used 5 times

- in line 9, 24
- in /usr/src/bin/as/as0.s line 5, 239, 795

flush defined in line 760; used 6 times

- in line 182-184(2), 203, 388, 1204-1206(2)

flush1 defined in line 764; used 1 times

- in line 749

getbr defined in line 1411; used 1 times

- in line 1039

getw defined in line 843; used 5 times

- in line 562, 944, 1146, 1154, 1525

getw1 defined in line 848; used 2 times

- in line 819, 845

getx defined in line 1258; used 2 times

- in line 1256, 1326

maprel defined in line 1700; used 2 times

- in line 1681-1685(2)

nsymout defined in line 298; used 1 times

- in line 197

op2a defined in line 971; used 3 times

- in line 1016-1019(2), 1113

op2b defined in line 974; used 1 times

- in line 1008

opeof defined in line 939; used 1 times

- in line 878

opl10 defined in line 1115; used 1 times

- in line 914

opl11 defined in line 1120; used 1 times

- in line 915

opl12 defined in line 1010; used 1 times

- in line 916

opl13 defined in line 969; used 2 times

- in line 917, 961

opl14 defined in line 963; used 1 times

- in line 918

opl15 defined in line 1006; used 1 times

- in line 919

opl16 defined in line 1134; used 2 times

- in line 920, 1140

opl17 defined in line 1145; used 3 times

- in line 881, 921, 1152

opl20 defined in line 1157; used 1 times

- in line 922

opl21 defined in line 1172; used 1 times

- in line 923

opl22 defined in line 1174; used 1 times

- in line 924

opl23 defined in line 1179; used 2 times

- in line 925, 1187

opl25 defined in line 1192; used 1 times

- in line 927

opl26 defined in line 1193; used 1 times

- in line 928

opl27 defined in line 1194; used 1 times

- in line 929

opl30 defined in line 958; used 1 times

- in line 930

opl31 defined in line 1059; used 1 times

- in line 931

opl32 defined in line 1230; used 1 times

- in line 932

opl35 defined in line 1021; used 1 times

- in line 935

opl36 defined in line 1022; used 1 times

- in line 936

opl5 defined in line 966; used 1 times

- in line 911

opl6 defined in line 1080; used 1 times

- in line 912

opl7 defined in line 1110; used 1 times

- in line 913

opline defined in line 872; used 1 times

- in line 573

oplret defined in line 1175; never used
oprand defined in line 1546; used 4 times

- in line 1469-1472(2), 1480, 1529

oset defined in line 717; used 5 times

- in line 164-168(2), 190, 1214, 1220

osymout defined in line 254; used 1 times

- in line 200

outb defined in line 516; used 5 times

- in line 509, 653, 1136, 1151, 1164

outw defined in line 437; used 8 times

- in line 886, 993, 1001, 1049-1056(3), 1102, 1131

pass1 declared in line 6; defined in line 14; used 3 times

- in line 6
- in /usr/src/bin/as/as0.s line 4, 211

pass1_2 defined in line 550; used 8 times

- in line 110, 177, 594, 614-620(3), 630, 685

putstring defined in line 376; used 3 times

- in line 350, 365, 383

putw defined in line 736; used 14 times

- in line 174, 278, 285-288(2), 310-313(2), 322-325(2), 335-338(2), 493, 499, 530-533(2)

readop defined in line 813; used 21 times

- in line 551, 565, 632, 902, 973, 1066, 1139, 1183-1186(2), 1234-1235(2), 1262, 1298, 1315, 1321, 1328, 1337, 1353, 1379, 1437, 1534

ret defined in line 757; used 1 times

- in line 794

saexit defined in line 207; used 2 times

- in line 251, 803

setbr defined in line 1382; used 1 times

- in line 1027

setup defined in line 410; used 2 times

- in line 108, 119

wrterr declared in line 10; defined in line 797; used 3 times

- in line 10
- in /usr/src/bin/as/as0.s line 6, 330

xpr defined in line 884; used 6 times

- in line 880, 891-899(5)

xxpr defined in line 882; used 3 times

- in line 926, 933-934(2)

#### Defined variables

M defined in line 1718; used 3 times

- in line 1721, 1729, 1737

X defined in line 1717; used 57 times

- in line 1722-1741(57)

a.out defined in line 1744; used 1 times

- in line 1746

a.outp declared in line 9; defined in line 1746; used 5 times

- in line 9, 18-23(2)
- in /usr/src/bin/as/as0.s line 5, 105

adrbuf defined in line 1782; used 3 times

- in line 905, 994, 1286

argb declared in line 10; defined in line 1785; used 6 times

- in line 10, 942
- in /usr/src/bin/as/as0.s line 4-6(2), 261-263(2)

brdelt defined in line 1775; used 5 times

- in line 611-612(2), 627-628(2), 1393

brlen defined in line 1772; used 3 times

- in line 1384, 1413, 1773

brtab defined in line 1773; used 2 times

- in line 1405, 1423

brtabp defined in line 1774; used 5 times

- in line 414, 1383, 1389, 1412, 1421

bssbase defined in line 1779; used 2 times

- in line 134, 403

bsssiz defined in line 1759; used 2 times

- in line 120-121(2)

datbase defined in line 1778; used 2 times

- in line 131, 406

datseek defined in line 1764; used 2 times

- in line 153-154(2)

datsiz defined in line 1758; used 2 times

- in line 126-129(2)

defund declared in line 9; defined in line 1777; used 4 times

- in line 9, 395
- in /usr/src/bin/as/as0.s line 5, 100

drelseek defined in line 1767; used 2 times

- in line 145-146(2)

endtable defined in line 1796; used 2 times

- in line 101, 159

errflg declared in line 7; defined in line 1784; used 7 times

- in line 7, 208-213(2)
- in /usr/src/bin/as/as0.s line 5, 204, 230, 253

esw1 defined in line 1494; used 1 times

- in line 1482

exsw2 defined in line 1557; used 1 times

- in line 1547

fbbufp defined in line 1776; used 2 times

- in line 91, 703

ibufc declared in line 11; defined in line 1780; used 7 times

- in line 11, 434, 849, 860
- in /usr/src/bin/as/as0.s line 9, 726, 745

ibufp declared in line 11; defined in line 1788; used 8 times

- in line 11, 866-869(3)
- in /usr/src/bin/as/as0.s line 8, 728-729(2), 746

maxtyp defined in line 1787; used 4 times

- in line 1680, 1695, 1707-1709(2)

numval defined in line 1786; used 3 times

- in line 563, 622, 1521

obufp declared in line 11; defined in line 1748; used 6 times

- in line 11
- in /usr/src/bin/as/as0.s line 10, 315-319(4)

outbuf declared in line 11; defined in line 1792; used 7 times

- in line 11, 1748
- in /usr/src/bin/as/as0.s line 6, 199, 317-323(3)

outmod declared in line 6; defined in line 1750; used 7 times

- in line 6, 114, 219-220(2), 452
- in /usr/src/bin/as/as0.s line 5, 254

overlaid declared in line 9; defined in line 1781; used 4 times

- in line 9, 1451
- in /usr/src/bin/as/as0.s line 5, 94

passno declared in line 9; defined in line 1749; used 16 times

- in line 9, 113, 250, 443, 524, 575, 596, 1024, 1068, 1082, 1201, 1446, 1652
- in /usr/src/bin/as/as0.s line 5, 209, 228

qnl defined in line 1743; used 1 times

- in line 246

relp defined in line 1791; used 6 times

- in line 167, 183, 498, 532, 1205, 1219

relte2 defined in line 1735; used 7 times

- in line 1582, 1588, 1611, 1618, 1624, 1631, 1641

reltm2 defined in line 1727; used 2 times

- in line 1605, 1667

reltp2 defined in line 1719; used 1 times

- in line 1599

rlimit defined in line 1795; used 5 times

- in line 907, 960, 967, 985, 1011

rseekp defined in line 1753; used 3 times

- in line 500, 537, 1218

swapf defined in line 1794; used 5 times

- in line 906, 959-964(2), 976, 1015

symseek defined in line 1769; used 4 times

- in line 141-142(2), 187-188(2)

symsiz defined in line 1760; used 2 times

- in line 60-63(2)

totalsz defined in line 1797; used 9 times

- in line 299-300(2), 308-311(2), 318-319(2), 333-336(2), 362

trelseek defined in line 1766; used 6 times

- in line 149-150(2), 165-166(2), 1215, 1753

tseekp defined in line 1752; used 3 times

- in line 494, 534, 1210

txtmagic defined in line 1755; used 1 times

- in line 170

txtp defined in line 1789; used 24 times

- in line 163, 173, 181, 189, 202, 277, 284-287(2), 309-312(2), 321-324(2), 334-337(2), 377-381(4), 387, 492, 529, 542, 1203, 1213

txtseek defined in line 1763; used 3 times

- in line 1209, 1215, 1752

txtsiz defined in line 1757; used 4 times

- in line 122-125(2), 579-583(2)

xsymbol defined in line 1783; used 8 times

- in line 453, 1000, 1265, 1292, 1309, 1341, 1429, 1467

Last modified: 2000-02-21 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 4632 |