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

   1:         .globl  _main, _write, _close, _execl, __exit, _brk
   2:         .globl  _read, _signal, _stat, _open, _mkstemp, _calloc, _realloc
   3: 
   4:         .globl  error, errore, errora, checkeos, pass1, aexit, argb
   5:         .globl  overlaid, defund, a.outp, errflg, passno, filerr, outmod
   6:         .globl  wrterr, argb, hshsiz, dot, dotdot, savdot, ch, outbuf
   7:         .globl  line, savop, inbuf, fbptr, fbtbl, symnum, hshtab, symblk
   8:         .globl  symleft, dotrel, symtab, fin, fout, curfb, nxtfb, ibufp
   9:         .globl  ibufc, a.tmp1, usymtab, SYMENTSZ, SYMBLKSZ, PSTENTSZ
  10:         .globl  obufp, Newsym, symbol,csv
  11: 
  12: / This assembler supports _both_ the old style object files (with
  13: / fixed 8 character symbols) and the new style (with a strings table).
  14: / The variable 'Newsym' defined below specifies which format will be
  15: / emitted, if the value is '0' the old style is output, if non-zero
  16: / then the new 'string table' format is output.
  17: /
  18: / The old style on disc symbol table entries looked like this:
  19: /   struct symbol
  20: /	{
  21: /	char name[8];
  22: /	short type;
  23: /	short value;
  24: /	};
  25: /
  26: / The new style of on disc symbol table entry looks like:
  27: /   struct symbol
  28: /	{
  29: /	off_t offset_in_string_table;
  30: /	short type;
  31: /	short value;
  32: /	};
  33: 
  34:         .data
  35: Newsym: 1
  36:         .text
  37: 
  38: PSTENTSZ = 6.
  39: SYMENTSZ = 8.
  40: 
  41: / User symbols and Permanent Symbol Table entries used to have the
  42: / same 12 byte format.  Merging the two phases of the assembler, moving
  43: / the symbol name characters to an externally allocated heap and
  44: / using a non-contiguous user symbol table meant that the symbol number
  45: / could no longer be calculated by subtracting the base of the symbol
  46: / table and dividing by the size of an entry.  What was done was to
  47: / expand the symbol table entry by another word and keep the symbol number
  48: / in that.  The new internal symbol structure is:
  49: /
  50: /	char	*name;
  51: /	u_short	flags;
  52: /	u_short value;
  53: /	u_short number;
  54: 
  55: SYMBLKSZ = 512.
  56: STRBLKSZ = 1024.
  57: hshsiz = 3001.
  58: 
  59: / PDP-11 assembler
  60: _main:
  61:         jsr     r5,csv
  62:         mov     $1,-(sp)                / signal(SIGINT, SIG_IGN)
  63:         mov     $2,-(sp)
  64:         jsr     pc,_signal
  65:         cmp     (sp)+,(sp)+
  66:         ror     r0
  67:         bcs     1f
  68: 
  69:         mov     $aexit,-(sp)            / signal(SIGINT, aexit)
  70:         mov     $2,-(sp)
  71:         jsr     pc,_signal
  72:         cmp     (sp)+,(sp)+
  73: 1:
  74:         mov     4(r5),r0                / argc
  75:         mov     6(r5),curarg            / argv
  76: 9:
  77:         dec     r0                      / argc--
  78:         add     $2,curarg               / argv++
  79: 1:
  80:         mov     *curarg,r1
  81:         cmpb    (r1)+,$'-
  82:         bne     1f
  83:         cmpb    (r1),$'-                / is this "--"?
  84:         bne     8f                      / no - br
  85:         tstb    1(r1)                   / check for null terminator
  86:         beq     1f                      / got it, the "--" means read 'stdin'
  87: 8:
  88:         add     $2,curarg               / argv++
  89:         dec     r0                      / argc--
  90:         cmpb    (r1),$'u
  91:         beq     3f
  92:         cmpb    (r1), $'V
  93:         bne     2f
  94:         inc     overlaid
  95:         br      1b
  96: 2:
  97:         tstb    (r1)
  98:         bne     2f
  99: 3:
 100:         mov     $40,defund
 101:         br      1b
 102: 2:
 103:         cmpb    (r1),$'o
 104:         bne     1f
 105:         mov     *curarg,a.outp
 106:         br      9b
 107: 1:
 108: 
 109: / The new object file format puts a ceiling of 32 characters on symbols.
 110: / If it is desired to raise this limit all that need be done is increase
 111: / the same ceiling in the C compiler and linker (ld).
 112: 
 113:         tst     Newsym
 114:         beq     1f
 115:         movb    $32.,Ncps
 116: 1:
 117:         mov     r0,nargs                / # of remaining args
 118:         bne     8f                      / br if any left
 119:         inc     nargs                   / fake at least one arg
 120:         mov     $dash, curarg           / of '-' so we read stdin
 121: 8:
 122:         mov     $a.tmp1,-(sp)
 123:         jsr     pc,_mkstemp             / fout = mkstemp(a.tmp1);
 124:         tst     (sp)+
 125:         mov     r0,fout
 126:         bmi     oops
 127: 
 128: / the symbol table is a single linked list of dynamically allocated
 129: / 'SYMBLKSZ' byte blocks.  Allocate the first one now.
 130:         mov     $SYMBLKSZ+2,-(sp)       / symblk = calloc(1, SYMBLKSZ+2)
 131:         mov     $1,-(sp)
 132:         jsr     pc,_calloc
 133:         cmp     (sp)+,(sp)+
 134:         mov     r0,symblk
 135:         mov     r0,usymtab              / pointer to first block
 136:         tst     (r0)+                   / skip link word
 137:         mov     r0,symend               / current end in block
 138:         mov     $SYMBLKSZ,symleft       / number of bytes left in block
 139: 
 140: / The string portion of symbol table entries is now allocated dynamically.
 141: / We allocate the strings in 1kb chunks to cut down the number of times
 142: / the string table needs to be extended (besides, long variable names are
 143: / coming real soon now).
 144: /
 145: / NOTE: the string blocks are linked together for debugging purposes only,
 146: / nothing depends on the link.
 147: 
 148:         mov     $STRBLKSZ+2,-(sp)
 149:         mov     $1,-(sp)
 150:         jsr     pc,_calloc              / strblk = calloc(1, STRBLKSZ+2)
 151:         / check for failure???
 152:         cmp     (sp)+,(sp)+
 153:         mov     r0,strblk               / save pointer to string block
 154:         tst     (r0)+                   / skip link word
 155:         mov     r0,strend               / set available string pointer
 156:         mov     $STRBLKSZ,strleft       / set amount left in block
 157: 
 158: / the hash table is now dynamically allocated so that it can be
 159: / reused in pass 2 and re-alloced if necessary.
 160:         mov     $2,-(sp)                / hshtab = calloc($hshsiz, sizeof(int))
 161:         mov     $hshsiz,-(sp)
 162:         jsr     pc,_calloc
 163:         cmp     (sp)+,(sp)+
 164:         mov     r0, hshtab
 165: 
 166:         mov     $symtab,r1
 167: 1:
 168:         clr     r3
 169:         mov     (r1),r2                 / pointer to PST symbol's string
 170: 2:
 171:         movb    (r2)+,r4
 172:         beq     2f
 173:         add     r4,r3
 174:         swab    r3
 175:         br      2b
 176: 2:
 177:         clr     r2
 178:         div     $hshsiz,r2
 179:         ashc    $1,r2
 180:         add     hshtab,r3
 181: 4:
 182:         sub     r2,r3
 183:         cmp     r3,hshtab
 184:         bhi     3f
 185:         add     $2*hshsiz,r3
 186: 3:
 187:         tst     -(r3)
 188:         bne     4b
 189:         mov     r1,(r3)
 190:         add     $PSTENTSZ,r1
 191:         cmp     r1,$ebsymtab
 192:         blo     1b
 193: 
 194: / perform pass 0 processing
 195:         jsr     pc,pass0
 196: 
 197: / flush the intermediate object file
 198:         mov     $1024.,-(sp)            / write(fout, outbuf, 1024)
 199:         mov     $outbuf,-(sp)
 200:         mov     fout,-(sp)
 201:         jsr     pc,_write
 202:         add     $6,sp
 203: 
 204:         tst     errflg                  / any errors?
 205:         beq     1f                      / yes - br
 206:         jsr     pc,aexit
 207: / not reached
 208: 1:
 209:         inc     passno                  / go from -1 to 0
 210:         clr     line                    / reset line number
 211:         jmp     pass1                   / pass1 does both passes 1, 2, exit
 212: 
 213: oops:
 214:         mov     $9f-8f,-(sp)            / write(fileno(stderr),8f,strlen())
 215:         mov     $8f,-(sp)
 216:         mov     $2,-(sp)
 217:         jsr     pc,_write
 218:         mov     $2,(sp)
 219:         jsr     pc,__exit
 220:         .data
 221: 8:
 222:         <as: can't create tmpfile\n>
 223: 9:
 224:         .even
 225:         .text
 226: 
 227: error:
 228:         tst     passno                  / on pass1,2 ?
 229:         bpl     errorp2
 230:         inc     errflg
 231:         mov     r0,-(sp)
 232:         mov     r1,-(sp)
 233:         mov     r5,r0
 234:         tst     *curarg
 235:         beq     1f
 236:         mov     r0,-(sp)
 237:         mov     *curarg,-(sp)
 238:         clr     *curarg
 239:         jsr     pc,filerr
 240:         tst     (sp)+
 241:         mov     (sp)+,r0
 242: 1:
 243:         mov     r2,-(sp)
 244:         mov     r3,-(sp)
 245:         jsr     pc,errcmn
 246:         mov     (sp)+,r3
 247:         mov     (sp)+,r2
 248:         mov     (sp)+,r1
 249:         mov     (sp)+,r0
 250:         rts     pc
 251: 
 252: errorp2:
 253:         mov     pc,errflg
 254:         mov     $666,outmod             / make nonexecutable
 255:         mov     r3,-(sp)
 256:         mov     r2,-(sp)
 257:         mov     r1,-(sp)
 258:         mov     r0,-(sp)
 259: 
 260:         tst     -(sp)                   / write(1, argb, strlen(argb))
 261:         mov     $argb,-(sp)
 262:         mov     $1,-(sp)
 263:         mov     $argb,r1
 264:         clr     r0
 265: 1:
 266:         tstb    (r1)+
 267:         beq     2f
 268:         inc     r0
 269:         br      1b
 270: 2:
 271:         mov     r0,4(sp)
 272:         jsr     pc,_write
 273:         add     $6,sp
 274: 
 275:         movb    12(sp),r0
 276:         jsr     pc,errcmn
 277:         mov     (sp)+,r0
 278:         mov     (sp)+,r1
 279:         mov     (sp)+,r2
 280:         mov     (sp)+,r3
 281:         mov     (sp)+,(sp)
 282:         rts     pc
 283: 
 284: errcmn:
 285:         mov     line,r3
 286:         movb    r0,9f
 287:         mov     $9f+6,r0
 288:         mov     $4,r1
 289: 2:
 290:         clr     r2
 291:         div     $10.,r2
 292:         add     $'0,r3
 293:         movb    r3,-(r0)
 294:         mov     r2,r3
 295:         sob     r1,2b
 296: 
 297:         mov     $7,-(sp)                / write(1, 9f, 7)
 298:         mov     $9f,-(sp)
 299:         mov     $1,-(sp)
 300:         jsr     pc,_write
 301:         add     $6,sp
 302:         rts     pc
 303: 
 304:         .data
 305: 9:      <f xxxx\n>
 306:         .even
 307:         .text
 308: 
 309: p0putw:
 310:         tst     ifflg
 311:         beq     1f
 312:         cmp     r4,$'\n
 313:         bne     2f
 314: 1:
 315:         mov     r4,*obufp
 316:         add     $2,obufp
 317:         cmp     obufp,$outbuf+1024.
 318:         blo     2f
 319:         mov     $outbuf,obufp
 320: 
 321:         mov     r1,-(sp)                / protect r1 from library
 322:         mov     $1024.,-(sp)            / write(fout, outbuf, 1024)
 323:         mov     $outbuf,-(sp)
 324:         mov     fout,-(sp)
 325:         jsr     pc,_write
 326:         add     $6,sp
 327:         mov     (sp)+,r1
 328:         tst     r0
 329:         bpl     2f
 330:         jmp     wrterr
 331: 2:
 332:         rts     pc
 333: 
 334: / Pass 0.
 335: 
 336: pass0:
 337:         jsr     pc,p0readop
 338:         jsr     pc,checkeos
 339:                 br 7f
 340:         tst     ifflg
 341:         beq     3f
 342:         cmp     r4,$200
 343:         blos    pass0
 344:         cmpb    (r4),$21                /if
 345:         bne     2f
 346:         inc     ifflg
 347: 2:
 348:         cmpb    (r4),$22                /endif
 349:         bne     pass0
 350:         dec     ifflg
 351:         br      pass0
 352: 3:
 353:         mov     r4,-(sp)
 354:         jsr     pc,p0readop
 355:         cmp     r4,$'=
 356:         beq     4f
 357:         cmp     r4,$':
 358:         beq     1f
 359:         mov     r4,savop
 360:         mov     (sp)+,r4
 361:         jsr     pc,opline
 362:         br      ealoop
 363: 1:
 364:         mov     (sp)+,r4
 365:         cmp     r4,$200
 366:         bhis    1f
 367:         cmp     r4,$1                   / digit
 368:         beq     3f
 369:         mov     $'x,r5
 370:         jsr     pc,error
 371:         br      pass0
 372: 1:
 373:         bitb    $37,(r4)
 374:         beq     1f
 375:         mov     $'m,r5
 376:         jsr     pc,error
 377: 1:
 378:         bisb    dot-2,(r4)
 379:         mov     dot,2(r4)
 380:         br      pass0
 381: 3:
 382:         mov     numval,r0
 383:         jsr     pc,fbcheck
 384:         movb    dotrel,curfbr(r0)
 385:         asl     r0
 386:         movb    dotrel,nxtfb
 387:         mov     dot,nxtfb+2
 388:         movb    r0,nxtfb+1
 389:         mov     dot,curfb(r0)
 390: 
 391:         cmp     fbfree,$4               / room for another fb entry?
 392:         bge     5f                      / yes - br
 393:         jsr     pc,growfb               / no - grow the table
 394: 5:
 395:         sub     $4,fbfree               / four bytes less available
 396:         mov     nxtfb,*fbptr            / store first word
 397:         add     $2,fbptr                / advance to next
 398:         mov     nxtfb+2,*fbptr          / store second word
 399:         add     $2,fbptr                / point to next entry
 400:         br      pass0
 401: 4:
 402:         jsr     pc,p0readop
 403:         jsr     pc,expres
 404:         mov     (sp)+,r1
 405:         cmp     r1,$200
 406:         bhis    1f
 407:         mov     $'x,r5
 408:         jsr     pc,error
 409: 7:
 410:         br      ealoop
 411: 1:
 412:         cmp     r1,$dotrel
 413:         bne     2f
 414:         bic     $40,r3
 415:         cmp     r3,dotrel
 416:         bne     1f
 417: 2:
 418:         bicb    $37,(r1)
 419:         bic     $!37,r3
 420:         bne     2f
 421:         clr     r2
 422: 2:
 423:         bisb    r3,(r1)
 424:         mov     r2,2(r1)
 425:         br      ealoop
 426: 1:
 427:         mov     $'.,r5
 428:         jsr     pc,error
 429:         movb    $2,dotrel
 430: ealoop:
 431:         cmp     r4,$';
 432:         beq     9f
 433:         cmp     r4,$'\n
 434:         bne     1f
 435:         inc     line
 436:         br      9f
 437: 1:
 438:         cmp     r4,$'\e
 439:         bne     2f
 440:         tst     ifflg
 441:         beq     1f
 442:         mov     $'x,r5
 443:         jsr     pc,error
 444: 1:
 445:         rts     pc
 446: 2:
 447:         mov     $'x,r5
 448:         jsr     pc,error
 449: 2:
 450:         jsr     pc,checkeos
 451:                 br 9f
 452:         jsr     pc,p0readop
 453:         br      2b
 454: 9:
 455:         jmp     pass0
 456: 
 457: fbcheck:
 458:         cmp     r0,$9.
 459:         bhi     1f
 460:         rts     pc
 461: 1:
 462:         mov     $'f,r5
 463:         jsr     pc,error
 464:         clr     r0
 465:         rts     pc
 466: 
 467: / the 'fb' table never grows to be large.  In fact all of the assemblies
 468: / of C compiler generated code which were processed by 'c2' never
 469: / produced a table larger than 0 bytes.  So we 'realloc' because
 470: / this is not done enough to matter.
 471: 
 472: growfb:
 473:         mov     r1,-(sp)                / save r1 from library
 474:         add     $256.,fbtblsz           / new size of fb table
 475:         mov     $256.,fbfree            / number available now
 476:         mov     fbtblsz,-(sp)           / fbtbl = realloc(fbtbl, fbtblsz);
 477:         mov     fbtbl,-(sp)
 478:         bne     1f                      / extending table - br
 479:         mov     $1,(sp)                 / r0 = calloc(1, fbtblsz);
 480:         jsr     pc,_calloc
 481:         br      2f
 482: 1:
 483:         jsr     pc,_realloc
 484: 2:
 485:         cmp     (sp)+,(sp)+
 486:         mov     r0,fbtbl
 487:         bne     1f
 488:         iot                             / Can never happen (I hope)
 489: 1:
 490:         add     fbtblsz,r0              / fbptr starts 256 bytes from
 491:         sub     $256.,r0                / end of new region
 492:         mov     r0,fbptr
 493:         mov     (sp)+,r1                / restore register
 494:         rts     pc
 495: 
 496: / Symbol table lookup and hashtable maintenance.
 497: 
 498: rname:
 499:         mov     r1,-(sp)
 500:         mov     r2,-(sp)
 501:         mov     r3,-(sp)
 502:         movb    Ncps,r5                 / Max num of chars to accept
 503:         mov     $symbol,r2
 504:         clr     (r2)
 505:         clr     -(sp)
 506:         clr     -(sp)
 507:         cmp     r0,$'~                  / symbol not for hash table?
 508:         bne     1f                      / no - br
 509:         inc     2(sp)
 510:         clr     ch
 511: 1:
 512:         jsr     pc,rch
 513:         movb    chartab(r0),r3
 514:         ble     1f
 515:         add     r3,(sp)
 516:         swab    (sp)
 517:         dec     r5
 518:         blt     1b
 519:         movb    r3,(r2)+
 520:         br      1b
 521: 1:
 522:         clrb    (r2)+                   / null terminate string
 523:         movb    r0,ch
 524:         mov     (sp)+,r1
 525:         clr     r0
 526:         tst     (sp)+
 527:         beq     1f
 528:         mov     symend,r4
 529:         br      4f                      / go insert into symtable (!hashtbl)
 530: 1:
 531:         div     $hshsiz,r0
 532:         ashc    $1,r0
 533:         add     hshtab,r1
 534:         clr     timesaround
 535: 1:
 536:         sub     r0,r1
 537:         cmp     r1,hshtab
 538:         bhi     2f
 539:         add     $2*hshsiz,r1
 540:         tst     timesaround
 541:         beq     3f
 542: 
 543:         mov     $8f-9f,-(sp)            / write(fileno(stdout),9f,8f-9f);
 544:         mov     $9f,-(sp)
 545:         mov     $1,-(sp)
 546:         jsr     pc,_write
 547:         add     $6,sp
 548:         jsr     pc,aexit
 549: / not reached
 550: 
 551:         .data
 552: timesaround: 0
 553: 9:
 554:         <as: symbol table overflow\n>
 555: 8:
 556:         .even
 557:         .text
 558: 3:
 559:         inc     timesaround
 560: 2:
 561:         mov     $symbol,r2
 562:         mov     -(r1),r4
 563:         beq     3f
 564:         mov     (r4)+,r3                / ptr to symbol's name
 565: 9:
 566:         cmpb    (r2),(r3)+
 567:         bne     1b                      / not the right symbol - br
 568:         tstb    (r2)+                   / at end of symbol?
 569:         bne     9b                      / nope - keep looking
 570:         br      1f                      / yep - br
 571: 3:
 572:         mov     symend,r4
 573:         jsr     pc,isroom               / make sure there's room in block
 574:         mov     r4,(r1)
 575: 4:
 576:         jsr     pc,isroom               / check for room in current block
 577: 
 578:         mov     $symbol,r2              / length of string (including null)
 579: 8 :
 580:         tstb    (r2)+
 581:         bne     8b
 582:         sub     $symbol,r2
 583:         jsr     pc,astring              / allocate string space
 584:         mov     r0,(r4)+                / save string pointer in symtab entry
 585:         mov     $symbol,r1
 586: 9:
 587:         movb    (r1)+,(r0)+             / copy symbol name to string block
 588:         bne     9b
 589:         sub     $SYMENTSZ,symleft
 590: 
 591: / each new symbol is assigned a unique one up number.  This is done because
 592: / the user symbol table is no longer contiguous - the symbol number can
 593: / not be calculated by subtracting a base address and dividing by the
 594: / size of a symbol.
 595: 
 596:         clr     (r4)+                   / flags word
 597:         clr     (r4)+                   / value word
 598:         mov     symnum,(r4)+
 599:         inc     symnum
 600:         mov     r4,symend
 601:         sub     $6,r4                   / point to flags word
 602: 1:
 603:         mov     r4,-(sp)
 604:         mov     r4,r3
 605:         tst     -(r3)                   / back to beginning of entry
 606:         cmp     r3,$ebsymtab            / Permanent Symbol Table(opcode, etc)?
 607:         blo     1f                      / yes - br
 608:         mov     6(r3),r4                / get symbol number
 609:         add     $4000,r4                / user symbol flag
 610:         br      2f
 611: 1:
 612: 
 613: / PST entries are PSTENTSZ bytes each because they do not have a 'symnum'
 614: / entry associated with them.
 615: 
 616:         sub     $symtab,r3
 617:         clr     r2
 618:         div     $PSTENTSZ,r2
 619:         mov     r2,r4
 620:         add     $1000,r4                / builtin symbol
 621: 2:
 622:         jsr     pc,p0putw
 623:         mov     (sp)+,r4
 624:         mov     (sp)+,r3
 625:         mov     (sp)+,r2
 626:         mov     (sp)+,r1
 627:         tst     (sp)+
 628:         rts     pc
 629: 
 630: isroom:
 631:         cmp     symleft,$SYMENTSZ       / room for another symbol?
 632:         bge     1f                      / yes - br
 633:         mov     r1,-(sp)                / save from library
 634:         mov     $SYMBLKSZ+2,-(sp)       / size of sym block plus link word
 635:         mov     $1,-(sp)                / number of blocks to allocate
 636:         jsr     pc,_calloc              / calloc(1, SYMBLKSZ+2);
 637:         cmp     (sp)+,(sp)+
 638:         / check for failure?
 639:         mov     r0,*symblk              / link new block to old
 640:         mov     r0,symblk               / this is now the current block
 641:         tst     (r0)+                   / skip link word
 642:         mov     $SYMBLKSZ,symleft       / number of bytes available
 643:         mov     r0,r4                   / put where it's expected
 644:         mov     (sp)+,r1                / restore saved register
 645: 1:
 646:         rts     pc                      / return
 647: 
 648: / allocate room for a string, the length is in R2 and includes room for
 649: / a terminating null byte.
 650: 
 651: astring:
 652:         cmp     r2,strleft              / room in current block?
 653:         ble     1f                      / yes - go carve out a chunk
 654:         mov     $STRBLKSZ+2,-(sp)
 655:         mov     $1,-(sp)
 656:         jsr     pc,_calloc              / symblk = calloc(1,STRBLKSZ+2)
 657:         / check for failure?
 658:         cmp     (sp)+,(sp)+
 659:         mov     r0,*strblk              / update forward link between blocks
 660:         mov     r0,strblk               / update current string block pointer
 661:         tst     (r0)+                   / skip link word
 662:         mov     r0,strend               / current data pointer
 663:         mov     $STRBLKSZ,strleft       / amount of space left
 664: 1:
 665:         mov     strend,r0               / string address
 666:         add     r2,strend               / update current end point
 667:         sub     r2,strleft              / update amount of space left
 668:         rts     pc
 669: 
 670: number:
 671:         mov     r2,-(sp)
 672:         mov     r3,-(sp)
 673:         mov     r5,-(sp)
 674:         clr     r1
 675:         clr     r5
 676: 1:
 677:         jsr     pc,rch
 678:         cmp     r0,$'0
 679:         blt     1f
 680:         cmp     r0,$'9
 681:         bgt     1f
 682:         sub     $'0,r0
 683:         mul     $10.,r5
 684:         add     r0,r5
 685:         ash     $3,r1
 686:         add     r0,r1
 687:         br      1b
 688: 1:
 689:         cmp     r0,$'b
 690:         beq     1f
 691:         cmp     r0,$'f
 692:         beq     1f
 693:         cmp     r0,$'.
 694:         bne     2f
 695:         mov     r5,r1
 696:         clr     r0
 697: 2:
 698:         movb    r0,ch
 699:         mov     r1,r0
 700:         mov     (sp)+,r5
 701:         mov     (sp)+,r3
 702:         mov     (sp)+,r2
 703:         rts     pc
 704: 1:
 705:         mov     r0,r3
 706:         mov     r5,r0
 707:         jsr     pc,fbcheck
 708:         add     $141,r0
 709:         cmp     r3,$'b
 710:         beq     1f
 711:         add     $10.,r0
 712: 1:
 713:         mov     r0,r4
 714:         mov     (sp)+,r5
 715:         mov     (sp)+,r3
 716:         mov     (sp)+,r2
 717:         add     $2,(sp)
 718:         rts     pc
 719: 
 720: rch:
 721:         movb    ch,r0
 722:         beq     1f
 723:         clrb    ch
 724:         rts     pc
 725: 1:
 726:         dec     ibufc
 727:         blt     2f
 728:         movb    *ibufp,r0
 729:         inc     ibufp
 730:         bic     $!177,r0
 731:         beq     1b
 732:         rts     pc
 733: 2:
 734:         mov     fin,r0
 735:         bmi     3f
 736:         mov     r1,-(sp)                / protect r1 from library
 737:         mov     $1024.,-(sp)            / read(fin, inbuf, 1024)
 738:         mov     $inbuf,-(sp)
 739:         mov     r0,-(sp)
 740:         jsr     pc,_read
 741:         add     $6,sp
 742:         mov     (sp)+,r1
 743:         tst     r0
 744:         ble     2f
 745:         mov     r0,ibufc
 746:         mov     $inbuf,ibufp
 747:         br      1b
 748: 2:
 749:         mov     r1,-(sp)                / protect r1 from library
 750:         mov     fin,-(sp)               / close(r0)
 751:         jsr     pc,_close
 752:         tst     (sp)+
 753:         mov     $-1,fin
 754:         mov     (sp)+,r1
 755: 3:
 756:         dec     nargs
 757:         bge     2f
 758:         mov     $'\e,r0
 759:         rts     pc
 760: 2:
 761:         tst     ifflg
 762:         beq     2f
 763:         mov     $'i,r5
 764:         jsr     pc,error
 765:         jsr     pc,aexit
 766: / not reached
 767: 
 768: 2:
 769: / check for the filename arguments of "-" or "--", these mean to read 'stdin'.
 770: / Additional filenames are permitted and will be processed when EOF
 771: / is detected on stdin.
 772:         mov     *curarg,r0
 773:         cmpb    (r0)+,$'-
 774:         bne     5f                      / not the special case - br
 775:         tstb    (r0)                    / must be '-' by itself
 776:         beq     4f
 777:         cmpb    (r0)+,$'-               / check for "--"
 778:         bne     5f                      / not a double -, must be a filename
 779:         tstb    (r0)                    / null terminated?
 780:         bne     5f                      / no - must be a filename
 781: 4:
 782:         clr     fin                     / file descriptor is 0 for stdin
 783:         br      2f
 784: 5:
 785:         mov     r1,-(sp)                / protect r1 from library
 786:         clr     -(sp)                   / open((r0), O_RDONLY, 0)
 787:         clr     -(sp)
 788:         mov     *curarg,-(sp)
 789:         jsr     pc,_open
 790:         add     $6,sp
 791:         mov     (sp)+,r1
 792:         mov     r0,fin
 793:         bpl     2f
 794:         mov     *curarg,-(sp)
 795:         jsr     pc,filerr
 796:         tst     (sp)+
 797:         jsr     pc,aexit
 798: /not reached
 799: 2:
 800:         mov     $1,line
 801:         mov     r4,-(sp)
 802:         mov     r1,-(sp)
 803:         mov     $5,r4
 804:         jsr     pc,p0putw
 805:         mov     *curarg,r1
 806: 2:
 807:         movb    (r1)+,r4
 808:         beq     2f
 809:         jsr     pc,p0putw
 810:         br      2b
 811: 2:
 812:         add     $2,curarg
 813:         mov     $-1,r4
 814:         jsr     pc,p0putw
 815:         mov     (sp)+,r1
 816:         mov     (sp)+,r4
 817:         br      1b
 818: 
 819: p0readop:
 820:         mov     savop,r4
 821:         beq     1f
 822:         clr     savop
 823:         rts     pc
 824: 1:
 825:         jsr     pc,8f
 826:         jsr     pc,p0putw
 827:         rts     pc
 828: 
 829: 8:
 830:         jsr     pc,rch
 831:         mov     r0,r4
 832:         movb    chartab(r0),r1
 833:         bgt     rdname
 834:         jmp     *1f-2(r1)
 835: 
 836:         .data
 837:         fixor
 838:         escp
 839:         8b
 840:         retread
 841:         dquote
 842:         garb
 843:         squote
 844:         rdname
 845:         skip
 846:         rdnum
 847:         retread
 848:         string
 849: 1:
 850:         .text
 851: escp:
 852:         jsr     pc,rch
 853:         mov     $esctab,r1
 854: 1:
 855:         cmpb    r0,(r1)+
 856:         beq     1f
 857:         tstb    (r1)+
 858:         bne     1b
 859:         rts     pc
 860: 1:
 861:         movb    (r1),r4
 862:         rts     pc
 863: 
 864:         .data
 865: esctab:
 866:         .byte '/, '/
 867:         .byte '\<, 035
 868:         .byte '>, 036
 869:         .byte '%, 037
 870:         .byte 0, 0
 871:         .text
 872: 
 873: fixor:
 874:         mov     $037,r4
 875: retread:
 876:         rts     pc
 877: 
 878: rdname:
 879:         movb    r0,ch
 880:         cmp     r1,$'0
 881:         blo     1f
 882:         cmp     r1,$'9
 883:         blos    rdnum
 884: 1:
 885:         jmp     rname
 886: 
 887: rdnum:
 888:         jsr     pc,number
 889:                 br 1f
 890:         rts     pc
 891: 
 892: squote:
 893:         jsr     pc,rsch
 894:         br      1f
 895: dquote:
 896:         jsr     pc,rsch
 897:         mov     r0,-(sp)
 898:         jsr     pc,rsch
 899:         swab    r0
 900:         bis     (sp)+,r0
 901: 1:
 902:         mov     r0,numval
 903:         mov     $1,r4
 904:         jsr     pc,p0putw
 905:         mov     numval,r4
 906:         jsr     pc,p0putw
 907:         mov     $1,r4
 908:         tst     (sp)+
 909:         rts     pc
 910: 
 911: skip:
 912:         jsr     pc,rch
 913:         mov     r0,r4
 914:         cmp     r0,$'\e
 915:         beq     1f
 916:         cmp     r0,$'\n
 917:         bne     skip
 918: 1:
 919:         rts     pc
 920: 
 921: garb:
 922:         mov     $'g,r5
 923:         jsr     pc,error
 924:         br      8b
 925: 
 926: string:
 927:         mov     $'<,r4
 928:         jsr     pc,p0putw
 929:         clr     numval
 930: 1:
 931:         jsr     pc,rsch
 932:         tst     r1
 933:         bne     1f
 934:         mov     r0,r4
 935:         bis     $400,r4
 936:         jsr     pc,p0putw
 937:         inc     numval
 938:         br      1b
 939: 1:
 940:         mov     $-1,r4
 941:         jsr     pc,p0putw
 942:         mov     $'<,r4
 943:         tst     (sp)+
 944:         rts     pc
 945: 
 946: rsch:
 947:         jsr     pc,rch
 948:         cmp     r0,$'\e
 949:         beq     4f
 950:         cmp     r0,$'\n
 951:         beq     4f
 952:         clr     r1
 953:         cmp     r0,$'\\
 954:         bne     3f
 955:         jsr     pc,rch
 956:         mov     $schar,r2
 957: 1:
 958:         cmpb    (r2)+,r0
 959:         beq     2f
 960:         tstb    (r2)+
 961:         bpl     1b
 962:         rts     pc
 963: 2:
 964:         movb    (r2)+,r0
 965:         clr     r1
 966:         rts     pc
 967: 3:
 968:         cmp     r0,$'>
 969:         bne     1f
 970:         inc     r1
 971: 1:
 972:         rts     pc
 973: 4:
 974:         mov     $'<,r5
 975:         jsr     pc,error
 976:         jsr     pc,aexit
 977: / not reached
 978: 
 979:         .data
 980: schar:
 981:         .byte 'n, 012
 982:         .byte 's, 040
 983:         .byte 't, 011
 984:         .byte 'e, 004
 985:         .byte '0, 000
 986:         .byte 'r, 015
 987:         .byte 'a, 006
 988:         .byte 'p, 033
 989:         .byte 0,  -1
 990:         .text
 991: 
 992: opline:
 993:         mov     r4,r0
 994:         bmi     1f
 995:         cmp     r0,$200
 996:         bgt     1f
 997:         cmp     r0,$'<
 998:         bne     xpr
 999:         jmp     opl17
1000: xpr:
1001:         jsr     pc,expres
1002:         add     $2,dot
1003:         rts     pc
1004: 1:
1005:         movb    (r4),r0
1006:         cmp     r0,$24
1007:         beq     xpr
1008:         cmp     r0,$5
1009:         blt     xpr
1010:         cmp     r0,$36
1011:         bgt     xpr
1012:         mov     r0,-(sp)
1013:         jsr     pc,p0readop
1014:         mov     (sp)+,r0
1015:         asl     r0
1016:         jmp     *1f-12(r0)
1017: 
1018:         .data
1019: 1:
1020:         opl13                   / map fop freg,fdst to double
1021:         opl6
1022:         opl7
1023:         opl10
1024:         opl11
1025:         opl13                   / map fld/fst to double
1026:         opl13
1027:         opl13                   / map fop fsrc,freg to double
1028:         opl15
1029:         opl16
1030:         opl17
1031:         opl20
1032:         opl21
1033:         opl22
1034:         opl23
1035:         xpr
1036:         opl25
1037:         opl26
1038:         opl27
1039:         opl13                   / map mul s,r to double
1040:         opl31
1041:         opl32
1042:         xpr
1043:         xpr
1044:         opl35
1045:         opl36
1046:         .text
1047: 
1048: opl35:                                  / jbr
1049:         mov     $4,-(sp)
1050:         br      1f
1051: 
1052: opl36:                                  / jeq, etc
1053:         mov     $6,-(sp)
1054: 1:
1055:         jsr     pc,expres
1056:         cmp     r3,dotrel
1057:         bne     1f
1058:         sub     dot,r2
1059:         bge     1f
1060:         cmp     r2,$-376
1061:         blt     1f
1062:         mov     $2,(sp)
1063: 1:
1064:         add     (sp)+,dot
1065:         rts     pc
1066: 
1067: opl13:
1068: opl7:                                   /double
1069:         jsr     pc,addres
1070: op2:
1071:         cmp     r4,$',
1072:         beq     1f
1073:         jsr     pc,errora
1074:         rts     pc
1075: 1:
1076:         jsr     pc,p0readop
1077: opl15:                                  / single operand
1078:         jsr     pc,addres
1079:         add     $2,dot
1080:         rts     pc
1081: 
1082: opl31:                                  / sob
1083:         jsr     pc,expres
1084:         cmp     r4,$',
1085:         beq     1f
1086:         jsr     pc,errora
1087: 1:
1088:         jsr     pc,p0readop
1089: 
1090: opl6:
1091: opl10:
1092: opl11:                                  /branch
1093:         jsr     pc,expres
1094:         add     $2,dot
1095:         rts     pc
1096: 
1097: opl16:                                  / .byte
1098:         jsr     pc,expres
1099:         inc     dot
1100:         cmp     r4,$',
1101:         bne     1f
1102:         jsr     pc,p0readop
1103:         br      opl16
1104: 1:
1105:         rts     pc
1106: 
1107: opl17:                                  / < (.ascii)
1108:         add     numval,dot
1109:         jsr     pc,p0readop
1110:         rts     pc
1111: 
1112: opl20:                                  /.even
1113:         inc     dot
1114:         bic     $1,dot
1115:         rts     pc
1116: 
1117: opl21:                                  /.if
1118:         jsr     pc,expres
1119:         tst     r3
1120:         bne     1f
1121:         mov     $'U,r5
1122:         jsr     pc,error
1123: 1:
1124:         tst     r2
1125:         bne     opl22
1126:         inc     ifflg
1127: opl22:                                  /endif
1128:         rts     pc
1129: 
1130: opl23:                                  /.globl
1131:         cmp     r4,$200
1132:         blo     1f
1133:         bisb    $40,(r4)
1134:         jsr     pc,p0readop
1135:         cmp     r4,$',
1136:         bne     1f
1137:         jsr     pc,p0readop
1138:         br      opl23
1139: 1:
1140:         rts     pc
1141: 
1142: opl25:
1143: opl26:
1144: opl27:
1145:         mov     dotrel,r1
1146:         asl     r1
1147:         mov     dot,savdot-4(r1)
1148:         mov     savdot-[2*25](r0),dot
1149:         asr     r0
1150:         sub     $25-2,r0
1151:         mov     r0,dotrel
1152:         rts     pc
1153: 
1154: opl32:                                  / .common
1155:         cmp     r4,$200
1156:         blo     1f
1157:         bis     $40,(r4)
1158:         jsr     pc,p0readop
1159:         cmp     r4,$',
1160:         bne     1f
1161:         jsr     pc,p0readop
1162:         jsr     pc,expres
1163:         rts     pc
1164: 1:
1165:         mov     $'x,r5
1166:         jsr     pc,error
1167:         rts     pc
1168: 
1169: addres:
1170:         cmp     r4,$'(
1171:         beq     alp
1172:         cmp     r4,$'-
1173:         beq     amin
1174:         cmp     r4,$'$
1175:         beq     adoll
1176:         cmp     r4,$'*
1177:         beq     astar
1178: getx:
1179:         jsr     pc,expres
1180:         cmp     r4,$'(
1181:         bne     2f
1182:         jsr     pc,p0readop
1183:         jsr     pc,expres
1184:         jsr     pc,checkreg
1185:         jsr     pc,checkrp
1186: 1:
1187:         add     $2,dot
1188:         clr     r0
1189:         rts     pc
1190: 2:
1191:         cmp     r3,$24                  / register type
1192:         bne     1b
1193:         jsr     pc,checkreg
1194:         clr     r0
1195:         rts     pc
1196: 
1197: alp:
1198:         jsr     pc,p0readop
1199:         jsr     pc,expres
1200:         jsr     pc,checkrp
1201:         jsr     pc,checkreg
1202:         cmp     r4,$'+
1203:         bne     1f
1204:         jsr     pc,p0readop
1205:         clr     r0
1206:         rts     pc
1207: 1:
1208:         mov     $2,r0
1209:         rts     pc
1210: 
1211: amin:
1212:         jsr     pc,p0readop
1213:         cmp     r4,$'(
1214:         beq     1f
1215:         mov     r4,savop
1216:         mov     $'-,r4
1217:         br      getx
1218: 1:
1219:         jsr     pc,p0readop
1220:         jsr     pc,expres
1221:         jsr     pc,checkrp
1222:         jsr     pc,checkreg
1223:         clr     r0
1224:         rts     pc
1225: 
1226: adoll:
1227:         jsr     pc,p0readop
1228:         jsr     pc,expres
1229:         add     $2,dot
1230:         clr     r0
1231:         rts     pc
1232: 
1233: astar:
1234:         jsr     pc,p0readop
1235:         cmp     r4,$'*
1236:         bne     1f
1237:         mov     $'*,r5
1238:         jsr     pc,error
1239: 1:
1240:         jsr     pc,addres
1241:         add     r0,dot
1242:         rts     pc
1243: 
1244: errora:
1245:         mov     $'a,r5
1246:         jsr     pc,error
1247:         rts     pc
1248: 
1249: checkreg:
1250:         cmp     r2,$7
1251:         bhi     1f
1252:         cmp     r3,$1
1253:         beq     2f
1254:         cmp     r3,$4
1255:         bhi     2f
1256: 1:
1257:         jsr     pc,errora
1258: 2:
1259:         rts     pc
1260: 
1261: errore:
1262:         mov     $'e,r5
1263:         jsr     pc,error
1264:         rts     pc
1265: 
1266: checkrp:
1267:         cmp     r4,$')
1268:         beq     1f
1269:         mov     $'),r5
1270:         jsr     pc,error
1271:         rts     pc
1272: 1:
1273:         jsr     pc,p0readop
1274:         rts     pc
1275: 
1276: expres:
1277:         mov     r5,-(sp)
1278:         mov     $'+,-(sp)
1279:         clr     opfound
1280:         clr     r2
1281:         mov     $1,r3
1282:         br      1f
1283: advanc:
1284:         jsr     pc,p0readop
1285: 1:
1286:         mov     r4,r0
1287:         tst     r0
1288:         blt     6f
1289:         cmp     r0,$177
1290:         ble     7f
1291: 6:
1292:         movb    (r4),r0
1293:         mov     2(r4),r1
1294:         br      oprand
1295: 7:
1296:         cmp     r4,$141
1297:         blo     1f
1298:         cmp     r4,$141+10.
1299:         bhis    2f
1300:         movb    curfbr-141(r4),r0
1301:         asl     r4
1302:         mov     curfb-[2*141](r4),r2
1303:         cmp     r2,$-1
1304:         bne     oprand
1305:         mov     $'f,r5
1306:         jsr     pc,error
1307:         br      oprand
1308: 2:
1309:         clr     r3
1310:         clr     r2
1311:         br      oprand
1312: 1:
1313:         mov     $esw1,r1
1314: 1:
1315:         cmp     (r1)+,r4
1316:         beq     1f
1317:         tst     (r1)+
1318:         bne     1b
1319:         tst     opfound
1320:         bne     2f
1321:         jsr     pc,errore
1322: 2:
1323:         tst     (sp)+
1324:         mov     (sp)+,r5
1325:         rts     pc
1326: 1:
1327:         jmp     *(r1)
1328: 
1329:         .data
1330: esw1:
1331:         '+;     binop
1332:         '-;     binop
1333:         '*;     binop
1334:         '/;     binop
1335:         '&;     binop
1336:         037;    binop
1337:         035;    binop
1338:         036;    binop
1339:         '%;     binop
1340:         '[;     brack
1341:         '^;     binop
1342:         1;      exnum
1343:         '!;     binop
1344:         0;      0
1345:         .text
1346: 
1347: binop:
1348:         cmpb    (sp),$'+
1349:         beq     1f
1350:         jsr     pc,errore
1351: 1:
1352:         movb    r4,(sp)
1353:         br      advanc
1354: 
1355: exnum:
1356:         mov     numval,r1
1357:         mov     $1,r0
1358:         br      oprand
1359: 
1360: brack:
1361:         mov     r2,-(sp)
1362:         mov     r3,-(sp)
1363:         jsr     pc,p0readop
1364:         jsr     pc,expres
1365:         cmp     r4,$']
1366:         beq     1f
1367:         mov     $'],r5
1368:         jsr     pc,error
1369: 1:
1370:         mov     r3,r0
1371:         mov     r2,r1
1372:         mov     (sp)+,r3
1373:         mov     (sp)+,r2
1374: 
1375: oprand:
1376:         inc     opfound
1377:         mov     $exsw2,r5
1378: 1:
1379:         cmp     (sp),(r5)+
1380:         beq     1f
1381:         tst     (r5)+
1382:         bne     1b
1383:         br      eoprnd
1384: 1:
1385:         jmp     *(r5)
1386: 
1387:         .data
1388: exsw2:
1389:         '+; exadd
1390:         '-; exsub
1391:         '*; exmul
1392:         '/; exdiv
1393:         037; exor
1394:         '&; exand
1395:         035;exlsh
1396:         036;exrsh
1397:         '%; exmod
1398:         '!; exnot
1399:         '^; excmbin
1400:         0;  0
1401:         .text
1402: 
1403: excmbin:
1404:         mov     r0,r3                   / give left flag of right
1405:         br      eoprnd
1406: 
1407: exrsh:
1408:         neg     r1
1409:         beq     exlsh
1410:         inc     r1
1411:         clc
1412:         ror     r2
1413: exlsh:
1414:         clr     r5
1415:         jsr     pc,combin
1416:         ash     r1,r2
1417:         br      eoprnd
1418: 
1419: exmod:
1420:         clr     r5
1421:         jsr     pc,combin
1422:         mov     r1,-(sp)
1423:         mov     r2,r1
1424:         clr     r0
1425:         div     (sp)+,r0
1426:         mov     r1,r2
1427:         br      eoprnd
1428: 
1429: exadd:
1430:         clr     r5
1431:         jsr     pc,combin
1432:         add     r1,r2
1433:         br      eoprnd
1434: 
1435: exsub:
1436:         mov     $1,r5
1437:         jsr     pc,combin
1438:         sub     r1,r2
1439:         br      eoprnd
1440: 
1441: exand:
1442:         clr     r5
1443:         jsr     pc,combin
1444:         com     r1
1445:         bic     r1,r2
1446:         br      eoprnd
1447: 
1448: exor:
1449:         clr     r5
1450:         jsr     pc,combin
1451:         bis     r1,r2
1452:         br      eoprnd
1453: 
1454: exmul:
1455:         clr     r5
1456:         jsr     pc,combin
1457:         mul     r2,r1
1458:         mov     r1,r2
1459:         br      eoprnd
1460: 
1461: exdiv:
1462:         clr     r5
1463:         jsr     pc,combin
1464:         mov     r1,-(sp)
1465:         mov     r2,r1
1466:         clr     r0
1467:         div     (sp)+,r0
1468:         mov     r0,r2
1469:         br      eoprnd
1470: 
1471: exnot:
1472:         clr     r5
1473:         jsr     pc,combin
1474:         com     r1
1475:         add     r1,r2
1476:         br      eoprnd
1477: 
1478: eoprnd:
1479:         mov     $'+,(sp)
1480:         jmp     advanc
1481: 
1482: combin:
1483:         mov     r0,-(sp)
1484:         bis     r3,(sp)
1485:         bic     $!40,(sp)
1486:         bic     $!37,r0
1487:         bic     $!37,r3
1488:         cmp     r0,r3
1489:         ble     1f
1490:         mov     r0,-(sp)
1491:         mov     r3,r0
1492:         mov     (sp)+,r3
1493: 1:
1494:         tst     r0
1495:         beq     1f
1496:         tst     r5
1497:         beq     2f
1498:         cmp     r0,r3
1499:         bne     2f
1500:         mov     $1,r3
1501:         br      2f
1502: 1:
1503:         clr     r3
1504: 2:
1505:         bis     (sp)+,r3
1506:         rts     pc
1507: 
1508:         .data
1509: chartab:
1510:         .byte -14,-14,-14,-14,-02,-14,-14,-14
1511:         .byte -14,-22, -2,-14,-14,-22,-14,-14
1512:         .byte -14,-14,-14,-14,-14,-14,-14,-14
1513:         .byte -14,-14,-14,-14,-14,-14,-14,-14
1514:         .byte -22,-20,-16,-14,-20,-20,-20,-12
1515:         .byte -20,-20,-20,-20,-20,-20,056,-06
1516:         .byte 060,061,062,063,064,065,066,067
1517:         .byte 070,071,-20,-02,-00,-20,-14,-14
1518:         .byte -14,101,102,103,104,105,106,107
1519:         .byte 110,111,112,113,114,115,116,117
1520:         .byte 120,121,122,123,124,125,126,127
1521:         .byte 130,131,132,-20,-24,-20,-20,137
1522:         .byte -14,141,142,143,144,145,146,147
1523:         .byte 150,151,152,153,154,155,156,157
1524:         .byte 160,161,162,163,164,165,166,167
1525:         .byte 170,171,172,-14,-26,-14,176,-14
1526: 
1527: a.tmp1: </tmp/atm1XX\0>
1528: Ncps:   .byte 8.
1529: 1:      <-\0>
1530:         .even
1531: dash:   1b
1532: fin:    -1
1533: fout:   -1
1534: / The next two _must_ be adjacent!  Not sure why, but then this whole
1535: / assembler is weird beyond belief.
1536: curfb:  -1;-1;-1;-1;-1;-1;-1;-1;-1;-1
1537: nxtfb:  .=.+20.                 / first 4 used by pass0, all 20. by pass1+2
1538:         .bss
1539: curfbr: .=.+10.
1540: savdot: .=.+6
1541: hshtab: .=.+2                   / dynamically allocated
1542: ch:     .=.+2
1543: symnum: .=.+2                   / symbol number
1544: symbol: .=.+32.                 / XXX
1545:         .=.+2                   / paranoia to make sure a null is present
1546: inbuf:  .=.+1024.
1547: line:   .=.+2
1548: ifflg:  .=.+2
1549: nargs:  .=.+2
1550: curarg: .=.+2
1551: opfound:.=.+2
1552: savop:  .=.+2
1553: numval: .=.+2
1554: fbtblsz:.=.+2
1555: fbfree: .=.+2
1556: fbptr:  .=.+2
1557: fbtbl:  .=.+2
1558: usymtab:.=.+2                   / ptr to first block of symbols
1559: symleft:.=.+2                   / bytes left in current symbol block
1560: symend: .=.+2                   / ptr to next symbol space in block
1561: symblk: .=.+2                   / ptr to beginning of current sym block
1562: strleft:.=.+2                   / amount left in string block
1563: strend: .=.+2                   / ptr to next available string byte
1564: strblk: .=.+2                   / ptr to current string block link word
1565: 
1566: / key to types
1567: 
1568: /	0	undefined
1569: /	1	absolute (nop, reset, bpt, ...)
1570: /	2	text
1571: /	3	data
1572: /	4	bss
1573: /	5	flop freg,dst (movfo, = stcfd)
1574: /	6	branch
1575: /	7	jsr
1576: /	10	rts
1577: /	11	sys, trap
1578: /	12	movf (=ldf,stf)
1579: /	13	double operand (mov)
1580: /	14	flop fsrc,freg (addf)
1581: /	15	single operand (clr)
1582: /	16	.byte
1583: /	17	string (.ascii, "<")
1584: /	20	.even
1585: /	21	.if
1586: /	22	.endif
1587: /	23	.globl
1588: /	24	register
1589: /	25	.text
1590: /	26	.data
1591: /	27	.bss
1592: /	30	mul,div, etc
1593: /	31	sob
1594: /	32	.comm
1595: /	33	estimated text
1596: /	34	estimated data
1597: /	35	jbr
1598: /	36	jeq, jne, etc
1599: 
1600:         .data
1601: / the format of PST entries was changed.  rather than fixed 8 byte strings
1602: / (often with many trailing nulls) a pointer to a null terminated string
1603: / is now used.  This saves quite a bit of space since most PST entries are
1604: / only 3 or 4 characters long.  we had to do this the hard way since there
1605: / is no macro capability in the assembler and i'd chuck out the SDI [Span
1606: / Dependent Instruction] stuff and use my own assembler before trying to
1607: / add macros to this one.  Symbols beginning with 'L' are used since the
1608: / linker can be told to discard those.
1609: 
1610: symtab:
1611: / special symbols
1612: 
1613: L1; dotrel: 02;    dot: 0000000
1614: L2;         01; dotdot: 0000000
1615: 
1616: / register
1617: 
1618: L3;     24;     000000
1619: L4;     24;     000001
1620: L5;     24;     000002
1621: L6;     24;     000003
1622: L7;     24;     000004
1623: L8;     24;     000005
1624: L9;     24;     000006
1625: L10;    24;     000007
1626: 
1627: / double operand
1628: 
1629: L11;    13;     0010000
1630: L12;    13;     0110000
1631: L13;    13;     0020000
1632: L14;    13;     0120000
1633: L15;    13;     0030000
1634: L16;    13;     0130000
1635: L17;    13;     0040000
1636: L18;    13;     0140000
1637: L19;    13;     0050000
1638: L20;    13;     0150000
1639: L21;    13;     0060000
1640: L22;    13;     0160000
1641: 
1642: / branch
1643: 
1644: L23;    06;     0000400
1645: L24;    06;     0001000
1646: L25;    06;     0001400
1647: L26;    06;     0002000
1648: L27;    06;     0002400
1649: L28;    06;     0003000
1650: L29;    06;     0003400
1651: L30;    06;     0100000
1652: L31;    06;     0100400
1653: L32;    06;     0101000
1654: L33;    06;     0101400
1655: L34;    06;     0102000
1656: L35;    06;     0102400
1657: L36;    06;     0103000
1658: L37;    06;     0103000
1659: L38;    06;     0103000
1660: L39;    06;     0103400
1661: L40;    06;     0103400
1662: L41;    06;     0103400
1663: 
1664: / jump/branch type
1665: 
1666: L42;    35;     0000400
1667: L43;    36;     0001000
1668: L44;    36;     0001400
1669: L45;    36;     0002000
1670: L46;    36;     0002400
1671: L47;    36;     0003000
1672: L48;    36;     0003400
1673: L49;    36;     0100000
1674: L50;    36;     0100400
1675: L51;    36;     0101000
1676: L52;    36;     0101400
1677: L53;    36;     0102000
1678: L54;    36;     0102400
1679: L55;    36;     0103000
1680: L56;    36;     0103000
1681: L57;    36;     0103000
1682: L58;    36;     0103400
1683: L59;    36;     0103400
1684: L60;    36;     0103400
1685: 
1686: / single operand
1687: 
1688: L61;    15;     0005000
1689: L62;    15;     0105000
1690: L63;    15;     0005100
1691: L64;    15;     0105100
1692: L65;    15;     0005200
1693: L66;    15;     0105200
1694: L67;    15;     0005300
1695: L68;    15;     0105300
1696: L69;    15;     0005400
1697: L70;    15;     0105400
1698: L71;    15;     0005500
1699: L72;    15;     0105500
1700: L73;    15;     0005600
1701: L74;    15;     0105600
1702: L75;    15;     0005700
1703: L76;    15;     0105700
1704: L77;    15;     0006000
1705: L78;    15;     0106000
1706: L79;    15;     0006100
1707: L80;    15;     0106100
1708: L81;    15;     0006200
1709: L82;    15;     0106200
1710: L83;    15;     0006300
1711: L84;    15;     0106300
1712: L85;    15;     0000100
1713: L86;    15;     0000300
1714: L87;    15;     0006500
1715: L88;    15;     0006600
1716: L89;    15;     0106500
1717: L90;    15;     0106600
1718: L91;    15;     0170300
1719: L92;    15;     0106700
1720: L93;    15;     0106400
1721: L94;    15;     0007000
1722: L95;    15;     0007200
1723: L96;    15;     0007300
1724: 
1725: / jsr
1726: 
1727: L97;    07;     0004000
1728: 
1729: / rts
1730: 
1731: L98;    010;    000200
1732: 
1733: / simple operand
1734: 
1735: L99;    011;    104400
1736: L102;   011;    000230
1737: 
1738: / flag-setting
1739: 
1740: L103;   01;     0000240
1741: L104;   01;     0000241
1742: L105;   01;     0000242
1743: L106;   01;     0000244
1744: L107;   01;     0000250
1745: L108;   01;     0000257
1746: L109;   01;     0000261
1747: L110;   01;     0000262
1748: L111;   01;     0000264
1749: L112;   01;     0000270
1750: L113;   01;     0000277
1751: L114;   01;     0000000
1752: L115;   01;     0000001
1753: L116;   01;     0000002
1754: L117;   01;     0000003
1755: L118;   01;     0000004
1756: L119;   01;     0000005
1757: L120;   01;     0000006
1758: L121;   01;     0000007
1759: 
1760: / floating point ops
1761: 
1762: L122;   01;     170000
1763: L123;   01;     170001
1764: L124;   01;     170011
1765: L125;   01;     170002
1766: L126;   01;     170012
1767: L127;   15;     170400
1768: L128;   15;     170700
1769: L129;   15;     170600
1770: L130;   15;     170500
1771: L131;   12;     172400
1772: L132;   14;     177000
1773: L133;   05;     175400
1774: L134;   14;     177400
1775: L135;   05;     176000
1776: L136;   14;     172000
1777: L137;   14;     173000
1778: L138;   14;     171000
1779: L139;   14;     174400
1780: L140;   14;     173400
1781: L141;   14;     171400
1782: L142;   14;     176400
1783: L143;   05;     175000
1784: L144;   15;     170100
1785: L145;   15;     170200
1786: L146;   24;     000000
1787: L147;   24;     000001
1788: L148;   24;     000002
1789: L149;   24;     000003
1790: L150;   24;     000004
1791: L151;   24;     000005
1792: 
1793: L152;   30;     070000
1794: L153;   30;     071000
1795: L154;   30;     072000
1796: L155;   30;     073000
1797: L156;   07;     074000
1798: L157;   15;     006700
1799: L158;   11;     006400
1800: L159;   31;     077000
1801: 
1802: / pseudo ops
1803: 
1804: L160;   16;     000000
1805: L161;   20;     000000
1806: L162;   21;     000000
1807: L163;   22;     000000
1808: L164;   23;     000000
1809: L165;   25;     000000
1810: L166;   26;     000000
1811: L167;   27;     000000
1812: L168;   32;     000000
1813: 
1814: ebsymtab:
1815: 
1816: L1:     <.\0>
1817: L2:     <..\0>
1818: L3:     <r0\0>
1819: L4:     <r1\0>
1820: L5:     <r2\0>
1821: L6:     <r3\0>
1822: L7:     <r4\0>
1823: L8:     <r5\0>
1824: L9:     <sp\0>
1825: L10:    <pc\0>
1826: L11:    <mov\0>
1827: L12:    <movb\0>
1828: L13:    <cmp\0>
1829: L14:    <cmpb\0>
1830: L15:    <bit\0>
1831: L16:    <bitb\0>
1832: L17:    <bic\0>
1833: L18:    <bicb\0>
1834: L19:    <bis\0>
1835: L20:    <bisb\0>
1836: L21:    <add\0>
1837: L22:    <sub\0>
1838: L23:    <br\0>
1839: L24:    <bne\0>
1840: L25:    <beq\0>
1841: L26:    <bge\0>
1842: L27:    <blt\0>
1843: L28:    <bgt\0>
1844: L29:    <ble\0>
1845: L30:    <bpl\0>
1846: L31:    <bmi\0>
1847: L32:    <bhi\0>
1848: L33:    <blos\0>
1849: L34:    <bvc\0>
1850: L35:    <bvs\0>
1851: L36:    <bhis\0>
1852: L37:    <bec\0>
1853: L38:    <bcc\0>
1854: L39:    <blo\0>
1855: L40:    <bcs\0>
1856: L41:    <bes\0>
1857: L42:    <jbr\0>
1858: L43:    <jne\0>
1859: L44:    <jeq\0>
1860: L45:    <jge\0>
1861: L46:    <jlt\0>
1862: L47:    <jgt\0>
1863: L48:    <jle\0>
1864: L49:    <jpl\0>
1865: L50:    <jmi\0>
1866: L51:    <jhi\0>
1867: L52:    <jlos\0>
1868: L53:    <jvc\0>
1869: L54:    <jvs\0>
1870: L55:    <jhis\0>
1871: L56:    <jec\0>
1872: L57:    <jcc\0>
1873: L58:    <jlo\0>
1874: L59:    <jcs\0>
1875: L60:    <jes\0>
1876: L61:    <clr\0>
1877: L62:    <clrb\0>
1878: L63:    <com\0>
1879: L64:    <comb\0>
1880: L65:    <inc\0>
1881: L66:    <incb\0>
1882: L67:    <dec\0>
1883: L68:    <decb\0>
1884: L69:    <neg\0>
1885: L70:    <negb\0>
1886: L71:    <adc\0>
1887: L72:    <adcb\0>
1888: L73:    <sbc\0>
1889: L74:    <sbcb\0>
1890: L75:    <tst\0>
1891: L76:    <tstb\0>
1892: L77:    <ror\0>
1893: L78:    <rorb\0>
1894: L79:    <rol\0>
1895: L80:    <rolb\0>
1896: L81:    <asr\0>
1897: L82:    <asrb\0>
1898: L83:    <asl\0>
1899: L84:    <aslb\0>
1900: L85:    <jmp\0>
1901: L86:    <swab\0>
1902: L87:    <mfpi\0>
1903: L88:    <mtpi\0>
1904: L89:    <mfpd\0>
1905: L90:    <mtpd\0>
1906: L91:    <stst\0>
1907: L92:    <mfps\0>
1908: L93:    <mtps\0>
1909: L94:    <csm\0>
1910: L95:    <tstset\0>
1911: L96:    <wrtlck\0>
1912: L97:    <jsr\0>
1913: L98:    <rts\0>
1914: L99:    <sys\0>
1915: L102:   <spl\0>
1916: L103:   <nop\0>
1917: L104:   <clc\0>
1918: L105:   <clv\0>
1919: L106:   <clz\0>
1920: L107:   <cln\0>
1921: L108:   <ccc\0>
1922: L109:   <sec\0>
1923: L110:   <sev\0>
1924: L111:   <sez\0>
1925: L112:   <sen\0>
1926: L113:   <scc\0>
1927: L114:   <halt\0>
1928: L115:   <wait\0>
1929: L116:   <rti\0>
1930: L117:   <bpt\0>
1931: L118:   <iot\0>
1932: L119:   <reset\0>
1933: L120:   <rtt\0>
1934: L121:   <mfpt\0>
1935: L122:   <cfcc\0>
1936: L123:   <setf\0>
1937: L124:   <setd\0>
1938: L125:   <seti\0>
1939: L126:   <setl\0>
1940: L127:   <clrf\0>
1941: L128:   <negf\0>
1942: L129:   <absf\0>
1943: L130:   <tstf\0>
1944: L131:   <movf\0>
1945: L132:   <movif\0>
1946: L133:   <movfi\0>
1947: L134:   <movof\0>
1948: L135:   <movfo\0>
1949: L136:   <addf\0>
1950: L137:   <subf\0>
1951: L138:   <mulf\0>
1952: L139:   <divf\0>
1953: L140:   <cmpf\0>
1954: L141:   <modf\0>
1955: L142:   <movie\0>
1956: L143:   <movei\0>
1957: L144:   <ldfps\0>
1958: L145:   <stfps\0>
1959: L146:   <fr0\0>
1960: L147:   <fr1\0>
1961: L148:   <fr2\0>
1962: L149:   <fr3\0>
1963: L150:   <fr4\0>
1964: L151:   <fr5\0>
1965: L152:   <mul\0>
1966: L153:   <div\0>
1967: L154:   <ash\0>
1968: L155:   <ashc\0>
1969: L156:   <xor\0>
1970: L157:   <sxt\0>
1971: L158:   <mark\0>
1972: L159:   <sob\0>
1973: L160:   <.byte\0>
1974: L161:   <.even\0>
1975: L162:   <.if\0>
1976: L163:   <.endif\0>
1977: L164:   <.globl\0>
1978: L165:   <.text\0>
1979: L166:   <.data\0>
1980: L167:   <.bss\0>
1981: L168:   <.comm\0>
1982:         .text

Defined functions

Defined variables