![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lex.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / bin / as|
Return to lex.c CVS log | Up to [MW Coherent from dump] / coherent / b / bin / as |
1.1 ! root 1: /* ! 2: * This is the controlling loop in the assembler. ! 3: * ! 4: */ ! 5: #include <utype.h> ! 6: #include <asm.h> ! 7: #include <asflags.h> ! 8: #include <y_tab.h> ! 9: #include <symtab.h> ! 10: ! 11: /* states */ ! 12: #define INITIAL 0 ! 13: #define INSYM 1 ! 14: #define INCHAR 2 /* in char constant */ ! 15: #define LTS 3 ! 16: #define GTS 4 ! 17: #define BSLP 5 /* back slash while reading parms */ ! 18: #define WHITE 6 /* in white space */ ! 19: #define ENDLINE 7 ! 20: #define CSTATE 8 /* Pick up parms in macro expansion */ ! 21: #define INTOKEN 9 ! 22: ! 23: #define OPONLY1 10 /* search for operator only */ ! 24: #define OPONLY2 11 ! 25: #define OPONLY3 12 ! 26: #define OPONLY4 13 ! 27: ! 28: #define INSTR 14 /* string detected */ ! 29: #define BSL 15 /* back slash */ ! 30: #define BSLDIG 16 /* digit after back slash */ ! 31: ! 32: #define CMSTATE 17 /* pick up names in macro definition */ ! 33: #define INNAME 18 ! 34: ! 35: #define LZERO 19 /* lead zero */ ! 36: #define XNUM 20 /* hex number */ ! 37: #define DNUM 21 /* decimal number */ ! 38: #define ONUM 22 /* octal number */ ! 39: #define BNUM 23 /* binary number */ ! 40: ! 41: #define BANGS 24 /* ! seen */ ! 42: #define EQUS 25 /* = seen */ ! 43: ! 44: #define DSTATE 26 /* eat whole line for S_EQUS */ ! 45: ! 46: /* positions */ ! 47: #define LABEL 0 ! 48: #define OPCODE 1 ! 49: #define OPERAND 2 ! 50: #define COMMENT 3 ! 51: ! 52: /* comparisons */ ! 53: #define LT 1 ! 54: #define GT 2 ! 55: #define EQ 4 ! 56: ! 57: #define RET(toYacc) return(lastToken = (toYacc)) ! 58: #define RSTATE(toYacc, newstate) { state = newstate; RET(toYacc); } ! 59: #define NEWS(newstate) { state = newstate; continue; } ! 60: ! 61: static unsigned short state = INITIAL; ! 62: static unsigned short pstate; /* previous state when \ detected */ ! 63: static unsigned short pos = LABEL; ! 64: ! 65: static unsigned short ctype; /* current logic type */ ! 66: ! 67: static char buf[1024], *bp = buf; ! 68: static char *backOff; /* start of decimal number */ ! 69: static char fromMac = ' '; /* ' ' or '+' */ ! 70: static short opIx; /* index of current opcode */ ! 71: static psw = 0; ! 72: static long number = 0; ! 73: static char token[1024], *tp; ! 74: ! 75: static int lastChar; /* last Character in */ ! 76: static short vctr, scnt, dcnt; ! 77: static symt *stype; ! 78: static short ytype; ! 79: ! 80: /* ! 81: * Invalid character message. ! 82: */ ! 83: static void ! 84: invChar(c, s) ! 85: register short c; ! 86: char *s; ! 87: { ! 88: unsigned short p; ! 89: ! 90: p = bp - lastL; ! 91: if (isprint(c)) ! 92: yyerror("Invalid character '%c' %s at position %d", c, s, p); ! 93: /**/ ! 94: else ! 95: yyerror("Invalid character 0x%02x %s at position %d", ! 96: c & 255, s, p); /**/ ! 97: } ! 98: ! 99: /* ! 100: * Expand parms in macro line. ! 101: * # as first char of line foils replacment. ! 102: */ ! 103: static char * ! 104: expand(s, recurs) ! 105: register char *s; ! 106: { ! 107: register char c; ! 108: char *tp, *rep, *newl, *start; ! 109: macro *mac; ! 110: short sav, pb; ! 111: unsigned short point; ! 112: ! 113: start = s; ! 114: pb = 0; ! 115: for(state = WHITE; ; ) { ! 116: switch(state) { ! 117: case WHITE: ! 118: if (isalpha(c = *s++)) { ! 119: state = INSYM; ! 120: tp = token; ! 121: *tp++ = c; ! 122: break; ! 123: } ! 124: pb = 0; ! 125: break; ! 126: case INSYM: ! 127: if (isalnum(c = *s++)) { ! 128: *tp++ = c; ! 129: break; ! 130: } ! 131: mac = NULL; ! 132: *tp = '\0'; ! 133: if ((!recurs && (NULL != trueMac) && ! 134: (NULL != (rep = lookList(token)))) || ! 135: (NULL != (mac = macLookUp(token, MACSTR)))) { ! 136: tp = --s - (strlen(token) + pb); ! 137: sav = *tp; /* stomp parm name */ ! 138: *tp = '\0'; ! 139: if (NULL == mac) /* parm match */ ! 140: rep = expand(rep, 1); ! 141: else { /* equs match */ ! 142: rep = mac->names->str; ! 143: mac->type = MACSCAN; ! 144: rep = expand(rep, 1); ! 145: mac->type = MACSTR; ! 146: } ! 147: point = strlen(start) + strlen(rep); ! 148: newl = galloc(point + strlen(s) + 1); ! 149: sprintf(newl, "%s%s%s", start, rep, s); ! 150: *tp = sav; /* Un stomp parm name */ ! 151: start = newl; ! 152: s = start + point; /* don't rescan */ ! 153: } ! 154: pb = (c == '\\'); ! 155: state = WHITE; ! 156: } ! 157: if (!c) ! 158: break; ! 159: } ! 160: return(start); ! 161: } ! 162: ! 163: /* ! 164: * Get next line from macro or while. ! 165: */ ! 166: static char * ! 167: nextMac() ! 168: { ! 169: macctl *tmp; ! 170: macline *l; ! 171: extern char *strcpy(); ! 172: ! 173: for(;;) { ! 174: if (NULL == macExp) { /* not in a macro */ ! 175: fromMac = ' '; ! 176: return(NULL); ! 177: } ! 178: if (NULL != (l = macExp->curr)) { ! 179: fromMac = '+'; ! 180: macExp->curr = l->next; ! 181: return(strcpy(buf, l->line)); ! 182: } ! 183: ! 184: if ((tmp = macExp) == trueMac) { /* popping macro */ ! 185: freeList(macExp->parms); ! 186: ! 187: while(logic->expno == trueMac->expno) { ! 188: if ((logic->type == INWDEF) || ! 189: (logic->type == INPWDEF)) ! 190: yyerror("End of macro building .while"); ! 191: /* A \fB.macro\fR ended while reading in a ! 192: * \fB.while\fR loop. */ ! 193: freeLevel(); ! 194: } ! 195: ! 196: do { ! 197: trueMac = trueMac->prev; ! 198: } while((NULL != trueMac) && ! 199: (trueMac->type != MACTYPE)); ! 200: } ! 201: ! 202: macExp = macExp->prev; /* pop a level */ ! 203: free((char *)tmp); ! 204: } ! 205: } ! 206: ! 207: /* ! 208: * Save a line in a macro. ! 209: */ ! 210: saveLine() ! 211: { ! 212: macline *newl; ! 213: ! 214: newl = (macline *)alloc((unsigned)(sizeof(*newl) + strlen(lastL))); ! 215: strcpy(newl->line, lastL); ! 216: if (NULL == inMacDef->first) ! 217: lastDef = inMacDef->first = newl; ! 218: else { ! 219: lastDef->next = newl; ! 220: lastDef = newl; ! 221: } ! 222: } ! 223: ! 224: /* ! 225: * Get a line off a file. ! 226: */ ! 227: static char * ! 228: getLine() ! 229: { ! 230: register char *line; ! 231: ! 232: ++statement; /* increment statement number */ ! 233: if (NULL != (line = nextMac())) ! 234: return(line); ! 235: ! 236: while(NULL == (fgets(line = buf, sizeof(buf), inpc->fp))) { ! 237: if (NULL != inpc->prev) { ! 238: inpctl *tmp; ! 239: ! 240: fclose(inpc->fp); ! 241: inpc = (tmp = inpc)->prev; ! 242: free((char *)tmp); ! 243: } ! 244: else { /* end of pass */ ! 245: for(;NORMAL != logic->type; freeLevel()) { ! 246: switch(logic->type) { ! 247: case INMACDEF: ! 248: case PMACDEF: ! 249: yyerror("Missing .endm"); ! 250: /* Input ended leaving \fB.macro\fR open. */ ! 251: break; ! 252: case INIF0: ! 253: case INIF1: ! 254: case INIFX: ! 255: yyerror("Missing .endi"); ! 256: /* Input ended leaving \fB.if\fR open. */ ! 257: break; ! 258: case INWDEF: ! 259: case INPWDEF: ! 260: yyerror("Missing .endw"); ! 261: /* Input ended leaving \fB.while\fR open. */ ! 262: } ! 263: } ! 264: if (2 == pass) { ! 265: cleanUp(); ! 266: ! 267: switch (errCt) { ! 268: case 0: ! 269: exit(0); ! 270: case 1: ! 271: fprintf(errdev, "1 Error\n"); ! 272: break; ! 273: default: ! 274: fprintf(errdev, "%d Errors\n", errCt); ! 275: } ! 276: unlink(outName); ! 277: exit(1); ! 278: } ! 279: else { /* avoid close & open */ ! 280: rewind(inpc->fp); ! 281: inpc->lineNo = 0; ! 282: statement = 1; ! 283: ! 284: newPass(outName); ! 285: ! 286: /* reset compiler switches to initial state */ ! 287: alignon = alignonX; ! 288: lswitch = lswitchX; ! 289: nswitch = nswitchX; ! 290: wswitch = wswitchX; ! 291: fswitch = fswitchX; ! 292: bswitch = bswitchX; ! 293: ! 294: dodefs(); ! 295: outLine((char *)NULL, 0); ! 296: continue; ! 297: } ! 298: } ! 299: } ! 300: inpc->lineNo++; ! 301: return(line); ! 302: } ! 303: ! 304: /* ! 305: * In OPONLY3 we found an op process it. ! 306: * separated to keep from crashing Coherent compiler in cc2. ! 307: */ ! 308: static unsigned short ! 309: procOp() ! 310: { ! 311: register opc *op; ! 312: ! 313: *tp = '\0'; ! 314: bp--; ! 315: if (-1 == (opIx = opLookUp(token))) ! 316: return(OPONLY4); ! 317: ! 318: if (INIF1 <= ctype) ! 319: fatal("Logic error in macro def '%s' %d", token, ctype); /* TECH */ ! 320: ! 321: op = prefTab + opIx; ! 322: switch(op->kind) { /* switch on function type */ ! 323: case S_MACRO: ! 324: if (ctype < INIF0) ! 325: newLevel(PMACDEF); ! 326: break; ! 327: case S_ENDM: ! 328: switch(ctype) { ! 329: case INMACDEF: ! 330: inMacDef = (macro *)NULL; ! 331: lastDef = (macline *)NULL; ! 332: freeLevel(); ! 333: return(INITIAL); ! 334: case PMACDEF: ! 335: freeLevel(); ! 336: } ! 337: break; ! 338: case S_WHILE: ! 339: switch(ctype) { ! 340: case INWDEF: ! 341: case INPWDEF: ! 342: newLevel(INPWDEF); ! 343: } ! 344: break; ! 345: case S_ENDW: ! 346: switch(ctype) { ! 347: case INWDEF: { ! 348: macctl *tmp; ! 349: saveLine(); ! 350: logic = (tmp = logic)->prev; ! 351: tmp->type = WHILETYPE; ! 352: tmp->curr = tmp->first = inMacDef->first; ! 353: tmp->parms = tmp->names = NULL; ! 354: tmp->prev = macExp; ! 355: macExp = tmp; ! 356: free((char *)inMacDef); ! 357: lastDef = (macline *)NULL; ! 358: inMacDef = (macro *)NULL; ! 359: return(INITIAL); ! 360: } ! 361: case INPWDEF: ! 362: freeLevel(); ! 363: break; ! 364: } ! 365: break; ! 366: case S_IF: ! 367: switch(ctype) { ! 368: case INIF0: ! 369: case INIFX: ! 370: newLevel(INIFX); ! 371: } ! 372: break; ! 373: case S_ELSE: ! 374: switch(ctype) { ! 375: case INIF0: ! 376: logic->type = INIF1; ! 377: return(INITIAL); ! 378: } ! 379: break; ! 380: case S_ENDI: ! 381: switch(ctype) { ! 382: case INIF0: ! 383: case INIFX: ! 384: freeLevel(); ! 385: } ! 386: break; ! 387: } ! 388: return(OPONLY4); ! 389: } ! 390: ! 391: /* ! 392: * Read line and start processing. ! 393: * separated from yylex() to keep from crashing compiler in cc2. ! 394: */ ! 395: static unsigned short ! 396: startLine() ! 397: { ! 398: register short c; ! 399: ! 400: do { /* GNU outputs # line numbers */ ! 401: if (';' != lastChar) { ! 402: outLine(lastL, fromMac); ! 403: bp = lastL = getLine(); ! 404: } ! 405: if (COMMA != lastToken) ! 406: freel(); /* trash free space from last line */ ! 407: } while ('#' == *bp); ! 408: ! 409: ctype = logic->type; ! 410: ! 411: if (('#' != *bp) && ! 412: (';' != lastChar) && ! 413: (defCt || (NULL != trueMac)) && ! 414: ((ctype > INPWDEF) || (ctype < INWDEF))) { ! 415: bp = lastL = expand(bp, 0); ! 416: ! 417: if ((lastL != buf) && (fromMac != '+')) { ! 418: outLine(buf, fromMac); ! 419: fromMac = '@'; ! 420: } ! 421: } ! 422: ! 423: if ('#' == *bp) /* don't lex noexpand */ ! 424: bp++; ! 425: ! 426: if (COMMA == lastToken) /* continuation line ? */ ! 427: return(psw); ! 428: ! 429: lastChar = c = *bp; /* get a char */ ! 430: if (ctype < INIF1) { ! 431: if ((' ' == c) || ('\t' == c)) ! 432: return(OPONLY1); ! 433: else if (isalpha(c)) ! 434: return(OPONLY2); ! 435: else ! 436: return(OPONLY4); ! 437: } ! 438: if ((' ' == c) || ('\t' == c)) { ! 439: pos = OPCODE; ! 440: return(WHITE); ! 441: } ! 442: if (isalpha(c)) { ! 443: pos = LABEL; ! 444: tp = token; ! 445: *tp++ = c; ! 446: return(INSYM); ! 447: } ! 448: switch(c) { ! 449: case '/': case '\n': case 0: case ';': ! 450: break; ! 451: default: ! 452: invChar(c, ""); ! 453: } ! 454: return(INITIAL); ! 455: } ! 456: ! 457: /* ! 458: * Got an opcode, set it up. ! 459: */ ! 460: static ! 461: doOp(opIx) ! 462: { ! 463: register opc *op; ! 464: ! 465: lflags = 0; ! 466: stype = typTab + (kind = (op = prefTab + opIx)->kind); ! 467: yylval.o = op; ! 468: pos = OPERAND; ! 469: /* op code determines operand syntax */ ! 470: switch(ytype = stype->type) { ! 471: case NCMD: ! 472: RSTATE(ytype, ENDLINE) ! 473: case OP: ! 474: if (stype->bldr & REP_INSTR) ! 475: pos = OPCODE; ! 476: case ICMD: ! 477: case DATA: ! 478: RSTATE(ytype, WHITE) ! 479: case ECMD: ! 480: case ECMDX: ! 481: case CMD: ! 482: if (S_EQUS == kind) { ! 483: tp = token; ! 484: scnt = dcnt = 0; ! 485: RSTATE(ytype, DSTATE) ! 486: } ! 487: RSTATE(ytype, CSTATE) ! 488: case DCMD: ! 489: RSTATE(ytype, CMSTATE) ! 490: default: ! 491: fatal("Optype %d in lex", ytype); /* TECH */ ! 492: } ! 493: } ! 494: ! 495: /* ! 496: * get tokens ! 497: */ ! 498: yylex() ! 499: { ! 500: register short c; ! 501: ! 502: for(;;) { ! 503: /* ! 504: * Allow Japaneese comments and strings, catch other non ascii ! 505: * and abort the line. ! 506: */ ! 507: if ((state != INITIAL) && ! 508: !isascii(lastChar = c = *bp++) && ! 509: (state != INSTR) && ! 510: (state != INCHAR)) { ! 511: invChar(c, ""); ! 512: RSTATE(NL, INITIAL) ! 513: } ! 514: ! 515: switch(state) { ! 516: case INITIAL: /* start of line */ ! 517: bcnt = pcnt = 0; ! 518: psw = startLine(); ! 519: lastChar = c = *bp++; ! 520: if (!isascii(c)) { ! 521: invChar(c, ""); ! 522: RSTATE(NL, INITIAL) ! 523: } ! 524: NEWS(psw); ! 525: ! 526: case OPONLY1: /* find start of opcode */ ! 527: switch(c) { ! 528: case ' ': ! 529: case '\t': ! 530: continue; ! 531: default: ! 532: if (!islower(c)) ! 533: NEWS(OPONLY4) ! 534: tp = token; ! 535: *tp++ = c; ! 536: NEWS(OPONLY3) ! 537: } ! 538: ! 539: case OPONLY2: /* bypass label */ ! 540: if (isalnum(c)) ! 541: continue; ! 542: --bp; ! 543: if ((' ' == c) || ('\t' == c)) ! 544: NEWS(OPONLY1) ! 545: NEWS(OPONLY4) ! 546: ! 547: case OPONLY3: ! 548: if (isalnum(c)) { /* accumulate opcode */ ! 549: *tp++ = c; ! 550: continue; ! 551: } ! 552: NEWS(procOp()); ! 553: ! 554: case OPONLY4: /* default processing */ ! 555: if (logic->type < INIF0) ! 556: saveLine(); ! 557: NEWS(INITIAL) ! 558: ! 559: case INSYM: ! 560: if (isalnum(c)) { ! 561: *tp++ = c; ! 562: continue; ! 563: } ! 564: *tp = '\0'; ! 565: --bp; ! 566: if (pos == OPERAND) { ! 567: sym *sp; ! 568: ! 569: sp = symLookUp(token, S_UNDEF, 0L, 0); ! 570: switch(sp->type) { ! 571: case IDENTIFIER: ! 572: case REG: ! 573: case LEN: ! 574: yylval.s = sp; ! 575: break; ! 576: case NUMBER: ! 577: yylval.val = sp->loc; ! 578: } ! 579: RSTATE(sp->type, WHITE) ! 580: } ! 581: ! 582: /* pos != OPERAND may be opcode or label */ ! 583: if (':' != c) { ! 584: if (-1 != (opIx = opLookUp(token))) ! 585: return(doOp(opIx)); ! 586: ! 587: if (NULL != (macFound = macLookUp(token, MACTYPE))) { ! 588: static opc smac = { /* fake opcode */ ! 589: 0, S_MAC ! 590: }; ! 591: ! 592: yylval.o = &smac; /* macro expansion */ ! 593: RSTATE(CMD, CSTATE) ! 594: } ! 595: ! 596: if (!strcmp(token, ".")) { ! 597: yylval.t = token; ! 598: pos = OPCODE; ! 599: RSTATE(TOKEN, WHITE) ! 600: } ! 601: } ! 602: ! 603: if ((pos == LABEL) || (':' == c)) { ! 604: yylval.t = token; ! 605: pos = OPCODE; ! 606: RSTATE(TOKEN, WHITE) ! 607: } ! 608: ! 609: yyerror("Invalid opcode: '%s'", token); ! 610: /* The string in the opcode position is ! 611: * not one of our opcodes or one of ! 612: * your macros. */ ! 613: RSTATE(NL, INITIAL) ! 614: ! 615: case DSTATE: /* eat whole line for define */ ! 616: switch(c) { ! 617: case '"': ! 618: if (dcnt) ! 619: dcnt = 0; ! 620: else if (!scnt) ! 621: dcnt = 1; ! 622: break; ! 623: case '\'': ! 624: if (scnt) ! 625: scnt = 0; ! 626: else if (!dcnt) ! 627: scnt = 1; ! 628: break; ! 629: case '\\': ! 630: *tp++ = c; ! 631: psw = state; ! 632: NEWS(BSLP) ! 633: case '/': ! 634: if (scnt | dcnt) ! 635: break; ! 636: case 0: /* let # define take semicolon */ ! 637: case '\n': ! 638: *tp = '\0'; ! 639: yylval.t = trim(token); ! 640: RSTATE(TOKEN, ENDLINE) ! 641: } ! 642: *tp++ = c; ! 643: continue; ! 644: ! 645: case CSTATE: /* pick up parms on macro expansion */ ! 646: state = psw = INTOKEN; ! 647: *(tp = token) = '\0'; ! 648: scnt = dcnt = pcnt = bcnt = 0; ! 649: vctr = 1; ! 650: switch(c) { ! 651: case 0: ! 652: case ';': ! 653: case '\n': ! 654: case '/': ! 655: if (COMMA == lastToken) ! 656: NEWS(INITIAL) ! 657: RSTATE(NL, INITIAL) ! 658: case ',': ! 659: switch(lastToken) { ! 660: case CMD: ! 661: case COMMA: ! 662: bp--; ! 663: yylval.t = token; ! 664: RSTATE(TOKEN, CSTATE) ! 665: } ! 666: RSTATE(COMMA, CSTATE) ! 667: } ! 668: ! 669: case INTOKEN: /* pick up parms on macro expansion */ ! 670: switch(c) { ! 671: case '(': ! 672: pcnt += vctr; break; ! 673: case ')': ! 674: if (pcnt) ! 675: pcnt -= vctr; ! 676: break; ! 677: case '[': ! 678: bcnt += vctr; break; ! 679: case ']': ! 680: if (bcnt) ! 681: bcnt -= vctr; ! 682: break; ! 683: case '"': ! 684: if (dcnt) ! 685: dcnt = 0; ! 686: else if (!scnt) ! 687: dcnt = 1; ! 688: vctr = (dcnt | scnt) ^ 1; ! 689: break; ! 690: case '\'': ! 691: if (scnt) ! 692: scnt = 0; ! 693: else if (!dcnt) ! 694: scnt = 1; ! 695: vctr = (dcnt | scnt) ^ 1; ! 696: break; ! 697: case '\\': ! 698: *tp++ = c; ! 699: psw = state; ! 700: NEWS(BSLP) ! 701: ! 702: case ';': ! 703: case '/': ! 704: if (!vctr) ! 705: break; ! 706: case 0: ! 707: case '\n': ! 708: if (pcnt | bcnt | scnt | dcnt) { ! 709: yyerror("Unmatched bracket in parmeter"); ! 710: /* Line ended leaving an open bracket or parenthesis. */ ! 711: RSTATE(NL, INITIAL) ! 712: } ! 713: --bp; ! 714: *tp = '\0'; ! 715: if (*(yylval.t = trim(token))) ! 716: RSTATE(TOKEN, CSTATE) ! 717: NEWS(CSTATE) ! 718: case ',': ! 719: if (pcnt | bcnt | scnt | dcnt) ! 720: break; ! 721: --bp; ! 722: *tp = '\0'; ! 723: yylval.t = trim(token); ! 724: switch(ytype) { ! 725: case ECMD: ! 726: case ECMDX: ! 727: RSTATE(TOKEN, WHITE) ! 728: } ! 729: RSTATE(TOKEN, CSTATE) ! 730: } ! 731: *tp++ = c; ! 732: continue; ! 733: ! 734: case BSLP: /* back slash while reading parm */ ! 735: switch(c) { ! 736: case 0: ! 737: case '\n': ! 738: --bp; ! 739: yyerror("End of line after backslash reading parm"); ! 740: /* Macro parmeters may not be broken up with backslash. */ ! 741: break; ! 742: } ! 743: *tp++ = c; ! 744: NEWS(psw) ! 745: ! 746: case CMSTATE: /* pick up names on macro definition */ ! 747: psw = state = INNAME; ! 748: tp = token; ! 749: switch(c) { ! 750: case ',': ! 751: RET(COMMA); ! 752: case 0: ! 753: case ';': ! 754: case '\n': ! 755: case '/': ! 756: if (COMMA == lastToken) ! 757: NEWS(INITIAL) ! 758: RSTATE(NL, INITIAL) ! 759: } ! 760: case INNAME: /* pick up parms on macro definition */ ! 761: switch(c) { ! 762: case 0: ! 763: case ';': ! 764: case '\n': ! 765: case '/': ! 766: case ',': ! 767: --bp; ! 768: *tp = '\0'; ! 769: if (*(yylval.t = trim(token))) ! 770: RSTATE(TOKEN, CMSTATE) ! 771: NEWS(CMSTATE) ! 772: default: ! 773: if (ispunct(c)) { ! 774: invChar(c, "in macro name"); ! 775: RSTATE(NL, INITIAL) ! 776: } ! 777: } ! 778: *tp++ = c; ! 779: continue; ! 780: ! 781: ! 782: case WHITE: ! 783: /* ! 784: * This piece of code is heavily trafficked. ! 785: * Force the fastest form of switch statement ! 786: * by covering many cases. ! 787: */ ! 788: switch(c) { ! 789: case '1': case '2': case '3': case '4': ! 790: case '5': case '6': case '7': case '8': ! 791: case '9': case '0': ! 792: backOff = bp - 1; ! 793: if (number = c - '0') ! 794: NEWS(DNUM) ! 795: NEWS(LZERO); ! 796: ! 797: /* % allowed as first char only */ ! 798: case 'a': case 'b': case 'c': case 'd': ! 799: case 'e': case 'f': case 'g': case 'h': ! 800: case 'i': case 'j': case 'k': case 'l': ! 801: case 'm': case 'n': case 'o': case 'p': ! 802: case 'q': case 'r': case 's': case 't': ! 803: case 'u': case 'v': case 'w': case 'x': ! 804: case 'y': case 'z': ! 805: case 'A': case 'B': case 'C': case 'D': ! 806: case 'E': case 'F': case 'G': case 'H': ! 807: case 'I': case 'J': case 'K': case 'L': ! 808: case 'M': case 'N': case 'O': case 'P': ! 809: case 'Q': case 'R': case 'S': case 'T': ! 810: case 'U': case 'V': case 'W': case 'X': ! 811: case 'Y': case 'Z': case '?': case '_': ! 812: case '%': case '.': ! 813: tp = token; ! 814: *tp++ = c; ! 815: NEWS(INSYM) ! 816: ! 817: case ' ': ! 818: case '\t': ! 819: continue; ! 820: case 0: ! 821: case ';': ! 822: case '\n': ! 823: case '/': ! 824: if (COMMA == lastToken) ! 825: NEWS(INITIAL) ! 826: RSTATE(NL, INITIAL) ! 827: case '<': ! 828: NEWS(LTS) ! 829: case '>': ! 830: NEWS(GTS) ! 831: case '!': ! 832: NEWS(BANGS) ! 833: case '=': ! 834: NEWS(EQUS) ! 835: case '+': ! 836: RET(PLUS); ! 837: case '-': ! 838: RET(MINUS); ! 839: case '*': ! 840: RET(TIMES); ! 841: case ':': ! 842: if (OPERAND == pos) ! 843: RET(COLON); ! 844: pos = OPCODE; ! 845: RSTATE(NL, WHITE) ! 846: ! 847: case '&': ! 848: RET(AND); ! 849: case '|': ! 850: RET(OR); ! 851: case '^': ! 852: RET(XOR); ! 853: case '#': ! 854: RET(P_SIGN); ! 855: case '$': ! 856: RET(D_SIGN); ! 857: case '~': ! 858: RET(NOT); ! 859: case ',': ! 860: psw = WHITE; ! 861: RET(COMMA); ! 862: /* ! 863: * This assembler may reverse the normal usage of ! 864: * brackets and parentheses. That is expressions ! 865: * are put in []. 5(%eax) is 5 past %eax. ! 866: * bswitch flips this back. Keeps counts to improve ! 867: * the syntax error message. ! 868: */ ! 869: case '[': ! 870: bcnt++; ! 871: RET(bswitch ? LBRACK : LPAREN); ! 872: case ']': ! 873: bcnt--; ! 874: RET(bswitch ? RBRACK : RPAREN); ! 875: case '(': ! 876: pcnt++; ! 877: RET(bswitch ? LPAREN : LBRACK); ! 878: case ')': ! 879: pcnt--; ! 880: RET(bswitch ? RPAREN : RBRACK); ! 881: case '@': ! 882: RET(AT); ! 883: case '"': ! 884: psw = WHITE; ! 885: tp = token; ! 886: NEWS(INSTR) ! 887: case '\'': ! 888: psw = WHITE; ! 889: tp = token; ! 890: NEWS(INCHAR) ! 891: default: ! 892: invChar(c, "as token start"); ! 893: RSTATE(NL, INITIAL) ! 894: } ! 895: ! 896: case ONUM: ! 897: if (isdigit(c)) { ! 898: if (c > '7') ! 899: yyerror("Error in octal number"); /**/ ! 900: number *= 8; ! 901: number += c - '0'; ! 902: continue; ! 903: } ! 904: bp--; ! 905: yylval.val = number; ! 906: RSTATE(NUMBER, WHITE) ! 907: ! 908: case BNUM: ! 909: if (isdigit(c)) { ! 910: if (c > '1') ! 911: yyerror("Error in binary number"); /**/ ! 912: number *= 2; ! 913: number += c - '0'; ! 914: continue; ! 915: } ! 916: bp--; ! 917: yylval.val = number; ! 918: RSTATE(NUMBER, WHITE) ! 919: ! 920: case XNUM: ! 921: if (isxdigit(c)) { ! 922: number *= 16; ! 923: if (isdigit(c)) ! 924: number += c - '0'; ! 925: else if (islower(c)) ! 926: number += c - ('a' - 10); ! 927: else ! 928: number += c - ('A' - 10); ! 929: continue; ! 930: } ! 931: bp--; ! 932: yylval.val = number; ! 933: RSTATE(NUMBER, WHITE) ! 934: ! 935: case DNUM: ! 936: if (isdigit(c)) { ! 937: number *= 10; ! 938: number += c - '0'; ! 939: continue; ! 940: } ! 941: if (('.' == c) || ('e' == c) || ('E' == c)) { ! 942: yylval.dbl = strtod(backOff, &bp); ! 943: RSTATE(FNUM, WHITE) ! 944: } ! 945: bp--; ! 946: yylval.val = number; ! 947: RSTATE(NUMBER, WHITE) ! 948: ! 949: case LZERO: ! 950: switch(c) { ! 951: case '.': ! 952: yylval.dbl = strtod(backOff, &bp); ! 953: RSTATE(FNUM, WHITE) ! 954: case 'x': ! 955: case 'X': ! 956: NEWS(XNUM) ! 957: case 'b': ! 958: case 'B': ! 959: NEWS(BNUM) ! 960: default: ! 961: bp--; ! 962: if (isdigit(c)) ! 963: NEWS(ONUM) ! 964: yylval.val = number; ! 965: RSTATE(NUMBER, WHITE) ! 966: } ! 967: ! 968: case LTS: /* < seen */ ! 969: switch(c) { ! 970: case '<': ! 971: RSTATE(LSHIFT, WHITE) ! 972: case '=': ! 973: yylval.val = (LT|EQ); ! 974: break; ! 975: default: ! 976: --bp; ! 977: yylval.val = LT; ! 978: } ! 979: RSTATE(COMPARISON, WHITE) ! 980: ! 981: case GTS: /* > seen */ ! 982: switch(c) { ! 983: case '=': ! 984: yylval.val = (GT|EQ); ! 985: break; ! 986: case '>': ! 987: RSTATE(RSHIFT, WHITE) ! 988: default: ! 989: --bp; ! 990: yylval.val = GT; ! 991: } ! 992: RSTATE(COMPARISON, WHITE) ! 993: ! 994: case EQUS: /* = seen take = or == */ ! 995: if (OPCODE == pos) { ! 996: --bp; ! 997: opIx = opLookUp(".equ"); ! 998: return(doOp(opIx)); ! 999: } ! 1000: if ('=' != c) ! 1001: --bp; ! 1002: yylval.val = EQ; ! 1003: RSTATE(COMPARISON, WHITE) ! 1004: ! 1005: case BANGS: /* ! seen */ ! 1006: if ('=' == c) { ! 1007: yylval.val = (GT|LT); ! 1008: RSTATE(COMPARISON, WHITE) ! 1009: } ! 1010: --bp; ! 1011: RSTATE(BANG, WHITE) ! 1012: ! 1013: case INSTR: ! 1014: case INCHAR: ! 1015: switch(c) { ! 1016: case 0: ! 1017: case '\n': ! 1018: --bp; ! 1019: if (state == INSTR) { ! 1020: yyerror("End of line detected in string"); /**/ ! 1021: *tp = '\0'; ! 1022: yylval.t = token; ! 1023: RSTATE(TOKEN, psw) ! 1024: } ! 1025: yyerror("End of line detected in character constant"); ! 1026: /**/ ! 1027: case '\'': ! 1028: if (state != INCHAR) ! 1029: break; ! 1030: *tp = '\0'; ! 1031: if (strlen(token) != 1) ! 1032: yyerror("Character constant %d long", ! 1033: strlen(token)); ! 1034: /* Character constants must be one byte long. */ ! 1035: yylval.val = token[0]; ! 1036: RSTATE(NUMBER, psw) ! 1037: case '"': ! 1038: if (state != INSTR) ! 1039: break; ! 1040: *tp = '\0'; ! 1041: yylval.t = token; ! 1042: RSTATE(TOKEN, psw) ! 1043: case '\\': ! 1044: pstate = state; ! 1045: NEWS(BSL) ! 1046: } ! 1047: *tp++ = c; ! 1048: continue; ! 1049: ! 1050: case BSL: /* back slash */ ! 1051: switch(c) { ! 1052: case 0: ! 1053: case '\n': ! 1054: --bp; ! 1055: yyerror("End of line after backslash"); ! 1056: /**/ ! 1057: break; ! 1058: case 'n': ! 1059: *tp++ = '\n'; break; ! 1060: case 'r': ! 1061: *tp++ = '\r'; break; ! 1062: case 't': ! 1063: *tp++ = '\t'; break; ! 1064: case 'b': ! 1065: *tp++ = '\b'; break; ! 1066: case 'f': ! 1067: *tp++ = '\f'; break; ! 1068: default: ! 1069: if ((c >= '0') && (c <= '7')) { ! 1070: number = 0; ! 1071: bp--; ! 1072: NEWS(BSLDIG) ! 1073: } ! 1074: *tp++ = c; ! 1075: } ! 1076: NEWS(pstate) ! 1077: ! 1078: case BSLDIG: /* accumulate octal number */ ! 1079: if ((c >= '0') && (c <= '7')) { ! 1080: number *= 8; ! 1081: number += c - '0'; ! 1082: continue; ! 1083: } ! 1084: if (number > 255) { ! 1085: yyerror("Octal number %ld truncated to char", number); ! 1086: /* An octal number in a string was too big. */ ! 1087: number &= 255; ! 1088: } ! 1089: if (!number) { ! 1090: yyerror("Cannot insert \\0 in string"); ! 1091: /* NUL (\e0) terminates strings. ! 1092: * Instead of ! 1093: * .DM ! 1094: * .byte "hello\en\e0" ! 1095: * .DE ! 1096: * use: ! 1097: * .DM ! 1098: * .byte "hello\en", 0 ! 1099: * .DE */ ! 1100: } ! 1101: *tp++ = number; ! 1102: bp--; ! 1103: NEWS(pstate) ! 1104: ! 1105: case ENDLINE: ! 1106: RSTATE(NL, INITIAL) ! 1107: } ! 1108: } ! 1109: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.