![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to asscan.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 3BSD / cmd / as|
Return to asscan.c CVS log | Up to [CSRG BSD Unix] / 3BSD / cmd / as |
1.1 ! root 1: /* Copyright (c) 1979 Regents of the University of California */ ! 2: #include <stdio.h> ! 3: #include "as.h" ! 4: #include "asscan.h" ! 5: ! 6: extern int d124; ! 7: extern struct exp *xp; ! 8: ! 9: struct tokbufdesc *bufstart; /*where the buffer list begins*/ ! 10: struct tokbufdesc *buftail; /*last one on the list*/ ! 11: struct tokbufdesc *emptybuf; /*the one being filled*/ ! 12: ! 13: #define TOKDALLOP 8 ! 14: ! 15: int useVM; /*keep `tmp' file in virtual memory*/ ! 16: int bufno; /*which buffer number: 0,1 for tmp file*/ ! 17: struct tokbufdesc tokbuf[2]; /*our initial increment of buffers*/ ! 18: ! 19: inittmpfile() ! 20: { ! 21: if (passno == 1){ ! 22: if (useVM){ ! 23: bufstart = &tokbuf[0]; ! 24: buftail = &tokbuf[1]; ! 25: bufstart->tok_next = buftail; ! 26: buftail->tok_next = 0; ! 27: } ! 28: tokbuf[0].tok_count = -1; ! 29: tokbuf[1].tok_count = -1; ! 30: } ! 31: bufno = 0; ! 32: emptybuf = &tokbuf[bufno]; ! 33: tokptr = 0; ! 34: tokub = 0; ! 35: } ! 36: ! 37: closetmpfile() ! 38: { ! 39: if (passno == 1){ ! 40: if (useVM){ ! 41: emptybuf->toks[emptybuf->tok_count++] = PARSEEOF; ! 42: } else { ! 43: /* ! 44: * Clean up the buffers that haven't been ! 45: * written out yet ! 46: */ ! 47: if (tokbuf[bufno ^ 1].tok_count >= 0){ ! 48: if (fwrite(&tokbuf[bufno ^ 1], sizeof *emptybuf, 1, tmpfil) != 1){ ! 49: badwrite: ! 50: yyerror("Unexpected end of file writing the interpass tmp file"); ! 51: exit(2); ! 52: } ! 53: } ! 54: /* ! 55: * Ensure that we will read an End of file, ! 56: * if there are more than one file names ! 57: * in the argument list ! 58: */ ! 59: tokbuf[bufno].toks[tokbuf[bufno].tok_count++] = PARSEEOF; ! 60: if (fwrite(&tokbuf[bufno], sizeof *emptybuf, 1, tmpfil) ! 61: != 1) goto badwrite; ! 62: } ! 63: } /*end of being pass 1*/ ! 64: } ! 65: ! 66: #define bstrlg(from, length) \ ! 67: *(lgtype *)from = length; \ ! 68: (char *)from += sizeof(lgtype) + length ! 69: ! 70: #define bstrfromto(from,to) \ ! 71: *(lgtype *)from = (char *)to - (char *)from - sizeof(lgtype); \ ! 72: (char *)from += sizeof(lgtype) + (char *)to - (char *)from ! 73: ! 74: #define eatstrlg(from) \ ! 75: (char *)from += sizeof(lgtype) + *(lgtype *)from ! 76: ! 77: #define bskiplg(from, length) \ ! 78: *(lgtype *)from = length; \ ! 79: (char *)from += sizeof(lgtype) + length ! 80: ! 81: #define bskipfromto(from, to) \ ! 82: *(lgtype *)from = (toktype *)to - (toktype *)from - sizeof(lgtype); \ ! 83: (char *)from += sizeof (lgtype) + (toktype *)to - (toktype *)from ! 84: ! 85: #define eatskiplg(from) \ ! 86: (toktype *)from += sizeof(lgtype) + *(lgtype *)from ! 87: ! 88: #ifdef DEBUG ! 89: ptrall firsttoken; ! 90: #endif ! 91: ! 92: extern int yylval; /*global communication with parser*/ ! 93: ! 94: toktype yylex() ! 95: { ! 96: register ptrall bufptr; ! 97: register toktype val; ! 98: register struct exp *locxp; ! 99: ! 100: bufptr = tokptr; /*copy in the global value*/ ! 101: top: ! 102: if (bufptr < tokub){ ! 103: gtoken(val, bufptr); ! 104: switch(yylval = val){ ! 105: case PARSEEOF : ! 106: yylval = val = PARSEEOF; ! 107: break; ! 108: case INT: ! 109: locxp = xp++; ! 110: glong(locxp->xvalue, bufptr); ! 111: makevalue: ! 112: locxp->xtype = XABS; ! 113: locxp->xloc = 0; ! 114: locxp->xname = NULL; ! 115: yylval = (int)locxp; ! 116: break; ! 117: case FLTNUM: /*case patched on 3-Jan-80*/ ! 118: locxp = xp++; ! 119: gdouble(locxp->doubval.dvalue, bufptr); ! 120: /* ! 121: * We make sure that locxp->xvalue ! 122: * is not in the range suitable for ! 123: * a short literal. The field ! 124: * xvalue is only used for ! 125: * integers, not doubles, but when ! 126: * we test for short literals ! 127: * in ascode.c, we look ! 128: * at the field xvalue when ! 129: * it encounters an in line ! 130: * floating number. Ergo, ! 131: * give it a bad value. ! 132: */ ! 133: locxp->xvalue = -1; ! 134: goto makevalue; ! 135: case NAME: ! 136: gptr(yylval, bufptr); ! 137: lastnam = (struct symtab *)yylval; ! 138: break; ! 139: case SIZESPEC: ! 140: case REG: ! 141: case INSTn: ! 142: case INST0: ! 143: gchar(yylval, bufptr); ! 144: break; ! 145: case IJXXX: ! 146: gchar(yylval, bufptr); ! 147: gptr(lastjxxx, bufptr); ! 148: break; ! 149: case ILINESKIP: ! 150: gint(yylval, bufptr); ! 151: lineno += yylval; ! 152: goto top; ! 153: case SKIP: ! 154: eatskiplg(bufptr); ! 155: goto top; ! 156: case VOID: ! 157: goto top; ! 158: case STRING: ! 159: strptr = &strbuf[strno ^= 1]; ! 160: strptr->str_lg = *((lgtype *)bufptr); ! 161: movestr(&strptr->str[0], ! 162: (char *)bufptr + sizeof(lgtype), ! 163: strptr->str_lg); ! 164: eatstrlg(bufptr); ! 165: yylval = (int)strptr; ! 166: break; ! 167: case ISTAB: ! 168: case ISTABSTR: ! 169: case ISTABNONE: ! 170: case ISTABDOT: ! 171: case IALIGN: ! 172: gptr(yylval, bufptr); ! 173: break; ! 174: } /*end of the switch*/ ! 175: ! 176: #ifdef DEBUG ! 177: ! 178: if (toktrace) ! 179: switch(val){ ! 180: case INT: printf("Class integer val %d\n", ! 181: ((struct exp *)yylval)->xvalue); ! 182: break; ! 183: case FLTNUM: printf("Class floating point num value %4.3f\n", ! 184: ((struct exp *)yylval) -> doubval.dvalue); ! 185: break; ! 186: case NAME: printf("Class name, \"%.8s\"\n", ! 187: ((struct symtab *)yylval)->name); ! 188: break; ! 189: case REG: printf("Class register, number %d\n", ! 190: yylval); ! 191: break; ! 192: case INSTn: printf("Class INSTn, %.8s\n", ! 193: itab[0xFF &yylval]->name); ! 194: break; ! 195: case IJXXX: printf("Class IJXXX, %.8s\n", ! 196: itab[0xFF &yylval]->name); ! 197: break; ! 198: case INST0: printf("Class INST0, %.8s\n", ! 199: itab[0xFF &yylval]->name); ! 200: break; ! 201: case STRING: printf("Class string, length %d\n", ! 202: ((struct strdesc *)yylval)->str_lg); ! 203: break; ! 204: default: printf("Pass: %d Tok: %d Other class: %d, 0%o, '%c'\n", ! 205: passno, ! 206: bufptr - firsttoken, ! 207: val,val, val); ! 208: break; ! 209: } /*end of the debug switch*/ ! 210: #endif ! 211: ! 212: } /*end of this buffer*/ ! 213: else { ! 214: if (useVM){ ! 215: bufno += 1; ! 216: emptybuf = emptybuf->tok_next; ! 217: if (emptybuf == 0){ ! 218: struct tokbufdesc *newdallop; ! 219: int i; ! 220: if (passno == 2) ! 221: goto badread; ! 222: emptybuf = newdallop = ! 223: (struct tokbufdesc *)sbrk( ! 224: TOKDALLOP*sizeof (struct tokbufdesc)); ! 225: if (emptybuf == (struct tokbufdesc *)-1) ! 226: goto badwrite; ! 227: for (i=0; i < TOKDALLOP; i++){ ! 228: buftail->tok_next = newdallop; ! 229: buftail = newdallop; ! 230: newdallop += 1; ! 231: } ! 232: buftail->tok_next = 0; ! 233: } /*end of need to get more buffers*/ ! 234: (toktype *)bufptr = &(emptybuf->toks[0]); ! 235: if (passno == 1) ! 236: scan_dot_s(emptybuf); ! 237: } else { /*don't use VM*/ ! 238: bufno ^= 1; ! 239: emptybuf = &tokbuf[bufno]; ! 240: ((toktype *)bufptr) = &(emptybuf->toks[0]); ! 241: if (passno == 1){ ! 242: /* ! 243: * First check if there are things to write ! 244: * out at all ! 245: */ ! 246: if (emptybuf->tok_count >= 0){ ! 247: if (fwrite(emptybuf, sizeof *emptybuf, 1, tmpfil) != 1){ ! 248: badwrite: ! 249: yyerror("Unexpected end of file writing the interpass tmp file"); ! 250: exit(2); ! 251: } ! 252: } ! 253: scan_dot_s(emptybuf); ! 254: } else { /*pass 2*/ ! 255: if (fread(emptybuf, sizeof *emptybuf, 1, tmpfil) != 1){ ! 256: badread: ! 257: yyerror("Unexpected end of file while reading the interpass tmp file"); ! 258: exit(1); ! 259: } ! 260: } /*end of pass2*/ ! 261: } /*end of using a real live file*/ ! 262: (char *)tokub = (char *)bufptr + emptybuf->tok_count; ! 263: #ifdef DEBUG ! 264: firsttoken = bufptr; ! 265: if (debug) ! 266: printf("created buffernumber %d with %d tokens\n", ! 267: bufno, emptybuf->tok_count); ! 268: #endif ! 269: goto top; ! 270: } /*end of reading/creating a new buffer*/ ! 271: tokptr = bufptr; /*copy back the global value*/ ! 272: return(val); ! 273: } /*end of yylex*/ ! 274: ! 275: ! 276: buildskip(from, to) ! 277: register ptrall from, to; ! 278: { ! 279: int diff; ! 280: register int frombufno; ! 281: register struct tokbufdesc *middlebuf; ! 282: /* ! 283: * check if from and to are in the same buffer ! 284: * from and to DIFFER BY AT MOST 1 buffer and to is ! 285: * always ahead of from, with to being in the buffer emptybuf ! 286: * points to. ! 287: * The hard part here is accounting for the case where the ! 288: * skip is to cross a buffer boundary; we must construct ! 289: * two skips. ! 290: * ! 291: * Figure out where the buffer boundary between from and to is ! 292: * It's easy in VM, as buffers increase to high memory, but ! 293: * w/o VM, we alternate between two buffers, and want ! 294: * to look at the exact middle of the contiguous buffer region. ! 295: */ ! 296: middlebuf = useVM ? emptybuf : &tokbuf[1]; ! 297: if ( ( (toktype *)from > (toktype *)middlebuf) ! 298: ^ ( (toktype *)to > (toktype *)middlebuf) ! 299: ){ /*split across a buffer boundary*/ ! 300: ptoken(from, SKIP); ! 301: /* ! 302: * Set the skip so it lands someplace beyond ! 303: * the end of this buffer. ! 304: * When we pull this skip out in the second pass, ! 305: * we will temporarily move the current pointer ! 306: * out beyond the end of the buffer, but immediately ! 307: * do a compare and fail the compare, and then reset ! 308: * all the pointers correctly to point into the next buffer. ! 309: */ ! 310: bskiplg(from, TOKBUFLG + 1); ! 311: /* ! 312: * Now, force from to be in the same buffer as to ! 313: */ ! 314: (toktype *)from = (toktype *)&(emptybuf->toks[0]); ! 315: } ! 316: /* ! 317: * Now, to and from are in the same buffer ! 318: */ ! 319: if (from > to) ! 320: yyerror("Internal error: bad skip construction"); ! 321: else { ! 322: if ( (diff = (toktype *)to - (toktype *)from) >= ! 323: (sizeof(toktype) + sizeof(lgtype) + 1)) { ! 324: ptoken(from, SKIP); ! 325: bskipfromto(from, to); ! 326: } else { ! 327: for ( ; diff > 0; --diff) ! 328: ptoken(from, VOID); ! 329: } ! 330: } ! 331: } ! 332: ! 333: movestr(to, from, lg) ! 334: register char *to, *from; ! 335: register int lg; ! 336: { ! 337: if (lg <= 0) return; ! 338: do ! 339: *to++ = *from++; ! 340: while (--lg); ! 341: } ! 342: static int newfflag = 0; ! 343: static char *newfname; ! 344: int scanlineno; /*the scanner's linenumber*/ ! 345: ! 346: new_dot_s(namep) ! 347: char *namep; ! 348: { ! 349: newfflag = 1; ! 350: newfname = namep; ! 351: dotsname = namep; ! 352: lineno = 1; ! 353: scanlineno = 1; ! 354: } ! 355: ! 356: /* ! 357: * Maps characters to their use in assembly language ! 358: */ ! 359: #define EOFCHAR (-1) ! 360: #define NEEDCHAR (-2) ! 361: ! 362: readonly short type[] = { ! 363: NEEDSBUF, /*fill up the input buffer*/ ! 364: SCANEOF, /*hit the hard end of file*/ ! 365: SP, BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR, /*\0..^G*/ ! 366: BADCHAR,SP, NL, BADCHAR,BADCHAR,SP, BADCHAR,BADCHAR, /*BS..SI*/ ! 367: BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR, /*DLE..ETB*/ ! 368: BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR,BADCHAR, /*CAN..US*/ ! 369: SP, ORNOT, DQ, SH, LITOP, REGOP, AND, SQ, /*sp .. '*/ ! 370: LP, RP, MUL, PLUS, CM, MINUS, ALPH, DIV, /*( .. /*/ ! 371: DIG, DIG, DIG, DIG, DIG, DIG, DIG, DIG, /*0 .. 7*/ ! 372: DIG, DIG, COLON, SEMI, LSH, BADCHAR,RSH, BADCHAR, /*8 .. ?*/ ! 373: BADCHAR,ALPH, ALPH, ALPH, ALPH, ALPH, ALPH, ALPH,/*@ .. G*/ ! 374: ALPH, ALPH, ALPH, ALPH, ALPH, ALPH, ALPH, ALPH,/*H .. BADCHAR*/ ! 375: ALPH, ALPH, ALPH, ALPH, ALPH, ALPH, ALPH, ALPH,/*P .. V*/ ! 376: ALPH, ALPH, ALPH, LB, BADCHAR,RB, XOR, ALPH,/*W .. _*/ ! 377: SIZEQUOTE,ALPH, ALPH, ALPH, ALPH, ALPH, ALPH, ALPH,/*` .. g*/ ! 378: ALPH, ALPH, ALPH, ALPH, ALPH, ALPH, ALPH, ALPH,/*h .. o*/ ! 379: ALPH, ALPH, ALPH, ALPH, ALPH, ALPH, ALPH, ALPH,/*p .. v*/ ! 380: ALPH, ALPH, ALPH, BADCHAR,IOR, BADCHAR,TILDE, BADCHAR,/*x .. del*/ ! 381: }; ! 382: ! 383: /* ! 384: * The table of possible uses for each character to test set inclusion. ! 385: * Different than the above table, which knows about tokens yylex ! 386: * is to return. ! 387: */ ! 388: #define HEXFLAG 01 /* 'x' or 'X' */ ! 389: #define HEXLDIGIT 02 /* 'a' .. 'f' */ ! 390: #define HEXUDIGIT 04 /* 'A' .. 'F' */ ! 391: #define ALPHA 010 /* 'A' .. 'Z', 'a' .. 'z', '_'*/ ! 392: #define DIGIT 020 /* '0' .. '9' */ ! 393: #define FLOATEXP 040 /* 'd' 'e' 'D' 'E' */ ! 394: /*exponent field*/ ! 395: #define SIGN 0100 /* '+' .. '-'*/ ! 396: #define REGDIGIT 0200 /* '0' .. '5' */ ! 397: #define SZSPECBEGIN 0400 /* 'b', 'B', 'l', 'L', 'w', 'W' */ ! 398: #define POINT 01000 /* '.' */ ! 399: #define SPACE 02000 /* '\t' or ' ' */ ! 400: #define BSESCAPE 04000 /* bnrtf */ ! 401: #define STRESCAPE 010000 /* '"', '\\', '\n' */ ! 402: #define OCTDIGIT 020000 /* '0' .. '7' */ ! 403: #define FLOATFLAG 040000 /* 'd', 'D', 'f', 'F' */ ! 404: /*after leading 0*/ ! 405: ! 406: readonly short charsets[] = { ! 407: 0, 0, 0, 0, 0, 0, 0, 0, /*\0..^G*/ ! 408: 0, SPACE, STRESCAPE,0, 0, 0, 0, 0, /*BS..SI*/ ! 409: 0, 0, 0, 0, 0, 0, 0, 0, /*DLE..ETB*/ ! 410: 0, 0, 0, 0, 0, 0, 0, 0, /*CAN..US*/ ! 411: SPACE, 0, STRESCAPE,0, 0, 0, 0, 0, /*sp.. '*/ ! 412: 0, 0, 0, SIGN, 0, SIGN, POINT+ALPHA,0, /*( .. /*/ ! 413: DIGIT+REGDIGIT+OCTDIGIT, DIGIT+REGDIGIT+OCTDIGIT, /*0..1*/ ! 414: DIGIT+REGDIGIT+OCTDIGIT, DIGIT+REGDIGIT+OCTDIGIT, /*2..3*/ ! 415: DIGIT+REGDIGIT+OCTDIGIT, DIGIT+REGDIGIT+OCTDIGIT, /*4..5*/ ! 416: DIGIT+OCTDIGIT, DIGIT+OCTDIGIT, /*6..7*/ ! 417: DIGIT, DIGIT, 0, 0, 0, 0, 0, 0, /*8..?*/ ! 418: 0, /*@*/ ! 419: ALPHA+HEXUDIGIT,ALPHA+HEXUDIGIT+SZSPECBEGIN, /*A..B*/ ! 420: ALPHA+HEXUDIGIT,ALPHA+HEXUDIGIT+FLOATEXP+FLOATFLAG, /*C..D*/ ! 421: ALPHA+HEXUDIGIT+FLOATEXP,ALPHA+HEXUDIGIT+FLOATFLAG, /*E..F*/ ! 422: ALPHA, /*G*/ ! 423: ALPHA, ALPHA, ALPHA, ALPHA, /*H..K*/ ! 424: ALPHA+SZSPECBEGIN, ALPHA, ALPHA, ALPHA, /*L..O*/ ! 425: ALPHA, ALPHA, ALPHA, ALPHA, /*P..S*/ ! 426: ALPHA, ALPHA, ALPHA, ALPHA+SZSPECBEGIN, /*T..W*/ ! 427: ALPHA+HEXFLAG, ALPHA, ALPHA, 0,STRESCAPE,0, 0, ALPHA,/*X.._*/ ! 428: ! 429: 0, ! 430: ALPHA+HEXLDIGIT,ALPHA+HEXLDIGIT+BSESCAPE+SZSPECBEGIN, /*a..b*/ ! 431: ALPHA+HEXLDIGIT,ALPHA+HEXLDIGIT+FLOATEXP+FLOATFLAG, /*c..d*/ ! 432: ALPHA+HEXLDIGIT+FLOATEXP,ALPHA+HEXLDIGIT+BSESCAPE+FLOATFLAG, /*e..f*/ ! 433: ALPHA, /*g*/ ! 434: ALPHA, ALPHA, ALPHA, ALPHA, /*h..k*/ ! 435: ALPHA+SZSPECBEGIN, ALPHA, ALPHA+BSESCAPE, ALPHA, /*l..o*/ ! 436: ALPHA, ALPHA, ALPHA+BSESCAPE, ALPHA, /*p..s*/ ! 437: ALPHA+BSESCAPE, ALPHA, ALPHA, ALPHA+SZSPECBEGIN,/*t..w*/ ! 438: ALPHA+HEXFLAG, ALPHA, ALPHA, 0,0, 0, 0, 0, /*x..del*/ ! 439: 0}; ! 440: ! 441: #define INCHARSET(val, kind) (charsets[val] & (kind) ) ! 442: static toktype oval = NL; ! 443: ! 444: #define INBUFLG 2 + 2*BUFSIZ + 128 ! 445: static char inbuffer[INBUFLG]; ! 446: static char *InBufPtr = 0; ! 447: ! 448: #ifdef getchar ! 449: #undef getchar ! 450: #endif ! 451: #define getchar() *inbufptr++ ! 452: ! 453: #ifdef ungetc ! 454: #undef ungetc ! 455: #endif ! 456: #define ungetc(char, fileptr) *--inbufptr = char ! 457: ! 458: char *fillinbuffer() ! 459: { ! 460: register char *cp, *inbufptr; ! 461: int nread; ! 462: ! 463: inbufptr = &inbuffer[2]; /*allow enough room for two ungetcs*/ ! 464: nread = fread(inbufptr, 1, 2*BUFSIZ, stdin); ! 465: if (nread == 2*BUFSIZ){ ! 466: cp = fgets(inbufptr+2*BUFSIZ, 128, stdin); /*get next whole line*/ ! 467: if (cp != 0){ ! 468: while(*cp++); /*find the trailing null*/ ! 469: *--cp = NEEDCHAR; /*clobber with a NEED character*/ ! 470: return(inbufptr); ! 471: } else { ! 472: *(inbufptr + 2*BUFSIZ) = EOFCHAR; ! 473: return(inbufptr); ! 474: } ! 475: } else { ! 476: if (nread == 0) /*hard end of file*/ ! 477: return(0); ! 478: inbuffer[2+nread] = EOFCHAR; ! 479: return(inbufptr); ! 480: } ! 481: } ! 482: ! 483: scan_dot_s(bufferbox) ! 484: struct tokbufdesc *bufferbox; ! 485: { ! 486: register int yylval;/*lexical value*/ ! 487: register toktype val; /*the value returned; the character read*/ ! 488: register int base; /*the base of the number also counter*/ ! 489: register char *cp; ! 490: register char *inbufptr; ! 491: register struct symtab *op; ! 492: register unsigned char tag; ! 493: ! 494: register ptrall bufptr; /*where to stuff tokens*/ ! 495: ptrall lgbackpatch; /*where to stuff a string length*/ ! 496: ptrall bufub; /*where not to stuff tokens*/ ! 497: register int maxstrlg; /*how long a string can be*/ ! 498: long intval; /*value of int*/ ! 499: char fltchr[64]; /*buffer for floating values*/ ! 500: double fltval; /*floating value returned*/ ! 501: int linescrossed; /*when doing strings and comments*/ ! 502: ! 503: inbufptr = InBufPtr; ! 504: if (inbufptr == 0){ ! 505: inbufptr = fillinbuffer(); ! 506: if (inbufptr == 0){ /*end of file*/ ! 507: endoffile: ! 508: inbufptr = 0; ! 509: ptoken(bufptr, PARSEEOF); ! 510: goto done; ! 511: } ! 512: } ! 513: ! 514: (toktype *)bufptr = (toktype *) & (bufferbox->toks[0]); ! 515: (toktype *)bufub = &(bufferbox->toks[AVAILTOKS]); ! 516: ! 517: if (newfflag){ ! 518: #ifdef DEBUG ! 519: if (debug) ! 520: printf(">>>>>>>>>>>>>(scanner) Starting to insert tokens into a new file: %s\n", ! 521: newfname); ! 522: #endif ! 523: ptoken(bufptr, IFILE); ! 524: ptoken(bufptr, STRING); ! 525: val = strlen(newfname) + 1; ! 526: movestr( (char *)&( ( (lgtype *)bufptr)[1]), newfname, val); ! 527: bstrlg(bufptr, val); ! 528: ! 529: ptoken(bufptr, ILINENO); ! 530: ptoken(bufptr, INT); ! 531: pint(bufptr, 1); ! 532: newfflag = 0; ! 533: } ! 534: ! 535: while (bufptr < bufub){ ! 536: loop: ! 537: switch(yylval = (type+2)[val = getchar()]) { ! 538: case SCANEOF: ! 539: inbufptr = 0; ! 540: goto endoffile; ! 541: ! 542: case NEEDSBUF: ! 543: inbufptr = fillinbuffer(); ! 544: if (inbufptr == 0) ! 545: goto endoffile; ! 546: goto loop; ! 547: ! 548: case DIV: /*process C style comments*/ ! 549: if ( (val = getchar()) == '*') { /*comment prelude*/ ! 550: int incomment; ! 551: linescrossed = 0; ! 552: incomment = 1; ! 553: val = getchar(); /*skip over the * */ ! 554: do{ ! 555: while ( (val != '*') && ! 556: (val != '\n') && ! 557: (val != EOFCHAR) && ! 558: (val != NEEDCHAR)) ! 559: val = getchar(); ! 560: if (val == '\n'){ ! 561: scanlineno++; ! 562: linescrossed++; ! 563: } else ! 564: if (val == EOFCHAR) ! 565: goto endoffile; ! 566: if (val == NEEDCHAR){ ! 567: inbufptr = fillinbuffer(); ! 568: if (inbufptr == 0) ! 569: goto endoffile; ! 570: lineno++; ! 571: incomment = 1; ! 572: val = getchar(); /*pull in the new char*/ ! 573: } else { /*its a star */ ! 574: val = getchar(); ! 575: incomment = val != '/'; ! 576: } ! 577: } while (incomment); ! 578: val = ILINESKIP; ! 579: yylval = linescrossed; ! 580: goto ret; ! 581: } else { /*just an ordinary DIV*/ ! 582: ungetc(val, stdin); ! 583: val = yylval = DIV; ! 584: goto ret; ! 585: } ! 586: case SH: ! 587: if (oval == NL){ ! 588: /* ! 589: * Attempt to recognize a C preprocessor ! 590: * style comment '^#[ \t]*[0-9]*[ \t]*".*" ! 591: */ ! 592: val = getchar(); /*bump the #*/ ! 593: while (INCHARSET(val, SPACE)) ! 594: val = getchar();/*bump white */ ! 595: if (INCHARSET(val, DIGIT)){ ! 596: intval = 0; ! 597: while(INCHARSET(val, DIGIT)){ ! 598: intval = intval *10 + val - '0'; ! 599: val = getchar(); ! 600: } ! 601: while (INCHARSET(val, SPACE)) ! 602: val = getchar(); ! 603: if (val == '"'){ ! 604: ptoken(bufptr, ILINENO); ! 605: ptoken(bufptr, INT); ! 606: pint(bufptr, intval - 1); ! 607: ptoken(bufptr, IFILE); ! 608: /* ! 609: * The '"' has already been ! 610: * munched ! 611: * ! 612: * eatstr will not eat ! 613: * the trailing \n, so ! 614: * it is given to the parser ! 615: * and counted. ! 616: */ ! 617: goto eatstr; ! 618: } ! 619: } ! 620: } ! 621: /* ! 622: * Well, its just an ordinary decadent comment ! 623: */ ! 624: while ((val != '\n') && (val != EOFCHAR)) ! 625: val = getchar(); ! 626: if (val == EOFCHAR) ! 627: goto endoffile; ! 628: val = yylval = oval = NL; ! 629: scanlineno++; ! 630: goto ret; ! 631: ! 632: case NL: ! 633: scanlineno++; ! 634: val = yylval; ! 635: goto ret; ! 636: ! 637: case SP: ! 638: oval = SP; /*invalidate ^# meta comments*/ ! 639: goto loop; ! 640: ! 641: case REGOP: /* % , could be used as modulo, or register*/ ! 642: val = getchar(); ! 643: if (INCHARSET(val, DIGIT)){ ! 644: yylval = val-'0'; ! 645: if (val=='1') { ! 646: if (INCHARSET( (val = getchar()), REGDIGIT)) ! 647: yylval = 10+val-'0'; ! 648: else ! 649: ungetc(val, stdin); ! 650: } ! 651: /* ! 652: * God only knows what the original author ! 653: * wanted this undocumented feature to ! 654: * do. ! 655: * %5++ is really r7 ! 656: */ ! 657: while(INCHARSET( (val = getchar()), SIGN)) { ! 658: if (val=='+') ! 659: yylval++; ! 660: else ! 661: yylval--; ! 662: } ! 663: ungetc(val, stdin); ! 664: val = REG; ! 665: } else { ! 666: ungetc(val, stdin); ! 667: val = REGOP; ! 668: } ! 669: goto ret; ! 670: ! 671: case ALPH: ! 672: yylval = val; ! 673: if (INCHARSET(val, SZSPECBEGIN)){ ! 674: if( (val = getchar()) == '`' || val == '^'){ ! 675: yylval |= 0100; /*convert to lower*/ ! 676: if (yylval == 'b') yylval = 1; ! 677: else if (yylval == 'w') yylval = 2; ! 678: else if (yylval == 'l') yylval = 4; ! 679: else yylval = d124; ! 680: val = SIZESPEC; ! 681: goto ret; ! 682: } else { ! 683: ungetc(val, stdin); ! 684: val = yylval; /*restore first character*/ ! 685: } ! 686: } ! 687: cp = yytext; ! 688: do { ! 689: if (cp < &yytext[NCPS]) ! 690: *cp++ = val; ! 691: } while (INCHARSET ( (val = getchar()), ALPHA | DIGIT)); ! 692: *cp = '\0'; ! 693: while (INCHARSET(val, SPACE)) ! 694: val = getchar(); ! 695: ungetc(val, stdin); ! 696: tag = (op = *lookup(1))->tag; ! 697: if (tag && tag != LABELID){ ! 698: yylval = ( (struct instab *)op)->opcode; ! 699: val = op->tag ; ! 700: goto ret; ! 701: } else { ! 702: /* ! 703: * Its a name... (Labels are subsets ofname) ! 704: */ ! 705: yylval = (int)op; ! 706: val = NAME; ! 707: goto ret; ! 708: } ! 709: ! 710: case DIG: ! 711: intval = val-'0'; ! 712: if (val=='0') { ! 713: val = getchar(); ! 714: if (INCHARSET(val, HEXFLAG)){ ! 715: base = 16; ! 716: } else ! 717: if (INCHARSET(val, FLOATFLAG)){ ! 718: char *p = fltchr; ! 719: double atof(); ! 720: ! 721: while ( (p < &fltchr[63]) && ! 722: INCHARSET( ! 723: (val=getchar()), ! 724: (DIGIT|SIGN|FLOATEXP|POINT) ! 725: ) ! 726: ) *p++ = val; ! 727: ungetc(val, stdin); ! 728: *p++ = '\0'; ! 729: fltval = atof(fltchr); ! 730: val = FLTNUM; ! 731: goto ret; ! 732: } else { ! 733: ungetc(val, stdin); ! 734: base = 8; ! 735: } ! 736: } else ! 737: base = 10; ! 738: while ( INCHARSET( (val = getchar()), DIGIT) || ! 739: (base==16 && (INCHARSET(val, HEXLDIGIT|HEXUDIGIT) ) ! 740: ) ! 741: ){ ! 742: if (base==8) ! 743: intval <<= 3; ! 744: else if (base==10) ! 745: intval *= 10; ! 746: else { ! 747: intval <<= 4; ! 748: if (INCHARSET(val, HEXLDIGIT)) ! 749: val -= 'a' - 10 - '0'; ! 750: else if (INCHARSET(val, HEXUDIGIT)) ! 751: val -= 'A' - 10 - '0'; ! 752: } ! 753: intval += val-'0'; ! 754: } ! 755: ungetc(val, stdin); ! 756: val = INT; ! 757: goto ret; ! 758: ! 759: case LSH: ! 760: case RSH: ! 761: /* ! 762: * We allow the C style operators ! 763: * << and >>, as well as < and > ! 764: */ ! 765: if ( (base = getchar()) != val) ! 766: ungetc(base, stdin); ! 767: val = yylval; ! 768: goto ret; ! 769: ! 770: case MINUS: ! 771: if ( (val = getchar()) =='(') ! 772: yylval=val=MP; ! 773: else { ! 774: ungetc(val,stdin); ! 775: val=MINUS; ! 776: } ! 777: goto ret; ! 778: ! 779: case SQ: ! 780: if ((yylval = getchar()) == '\n') ! 781: scanlineno++; /*not entirely correct*/ ! 782: intval = yylval; ! 783: val = INT; ! 784: goto ret; ! 785: ! 786: case DQ: ! 787: eatstr: ! 788: linescrossed = 0; ! 789: maxstrlg = (char *)bufub - (char *)bufptr; ! 790: ! 791: if (maxstrlg < MAXSTRLG) { ! 792: ungetc('"', stdin); ! 793: *(toktype *)bufptr = VOID ; ! 794: bufub = bufptr; ! 795: goto done; ! 796: } ! 797: if (maxstrlg > MAXSTRLG) ! 798: maxstrlg = MAXSTRLG; ! 799: ! 800: ptoken(bufptr, STRING); ! 801: lgbackpatch = bufptr; /*this is where the size goes*/ ! 802: bufptr += sizeof(lgtype); ! 803: /* ! 804: * bufptr is now set to ! 805: * be stuffed with characters from ! 806: * the input ! 807: */ ! 808: ! 809: while ( (maxstrlg > 0) ! 810: && !(INCHARSET( (val = getchar()), STRESCAPE)) ! 811: ){ ! 812: stuff: ! 813: maxstrlg-= 1; ! 814: pchar(bufptr, val); ! 815: } ! 816: if (maxstrlg <= 0){ /*enough characters to fill a string buffer*/ ! 817: ungetc('"', stdin); /*will read it next*/ ! 818: } ! 819: else if (val == '"'); /*done*/ ! 820: else if (val == '\n'){ ! 821: scanlineno++; ! 822: linescrossed++; ! 823: goto stuff; ! 824: } else { ! 825: val = getchar(); /*skip the '\\'*/ ! 826: if ( INCHARSET(val, BSESCAPE)){ ! 827: switch (val){ ! 828: case 'b': val = '\b'; goto stuff; ! 829: case 'f': val = '\f'; goto stuff; ! 830: case 'n': val = '\n'; goto stuff; ! 831: case 'r': val = '\r'; goto stuff; ! 832: case 't': val = '\t'; goto stuff; ! 833: } ! 834: } ! 835: if ( !(INCHARSET(val,OCTDIGIT)) ) goto stuff; ! 836: base = 0; ! 837: intval = 0; ! 838: while ( (base < 3) && (INCHARSET(val, OCTDIGIT))){ ! 839: base++;intval <<= 3;intval += val - '0'; ! 840: val = getchar(); ! 841: } ! 842: ungetc(val, stdin); ! 843: val = (char)intval; ! 844: goto stuff; ! 845: } ! 846: /* ! 847: * bufptr now points at the next free slot ! 848: */ ! 849: bstrfromto(lgbackpatch, bufptr); ! 850: if (linescrossed){ ! 851: val = ILINESKIP; ! 852: yylval = linescrossed; ! 853: goto ret; ! 854: } else ! 855: goto builtval; ! 856: ! 857: case BADCHAR: ! 858: linescrossed = lineno; ! 859: lineno = scanlineno; ! 860: yyerror("Illegal character mapped: %d, char read:(octal) %o", ! 861: yylval, val); ! 862: lineno = linescrossed; ! 863: val = BADCHAR; ! 864: goto ret; ! 865: ! 866: default: ! 867: val = yylval; ! 868: goto ret; ! 869: } /*end of the switch*/ ! 870: /* ! 871: * here with one token, so stuff it ! 872: */ ! 873: ret: ! 874: oval = val; ! 875: ptoken(bufptr, val); ! 876: switch(val){ ! 877: case ILINESKIP: ! 878: pint(bufptr, yylval); ! 879: break; ! 880: case SIZESPEC: ! 881: pchar(bufptr, yylval); ! 882: break; ! 883: case INT: plong(bufptr, intval); ! 884: break; ! 885: case FLTNUM: pdouble(bufptr, fltval); ! 886: break; ! 887: case NAME: pptr(bufptr, (int)(struct symtab *)yylval); ! 888: break; ! 889: case REG: pchar(bufptr, yylval); ! 890: break; ! 891: case INST0: ! 892: case INSTn: ! 893: pchar(bufptr, yylval); ! 894: break; ! 895: case IJXXX: ! 896: pchar(bufptr, yylval); ! 897: pptr(bufptr, (int)(struct symtab *)symalloc()); ! 898: break; ! 899: case ISTAB: ! 900: case ISTABSTR: ! 901: case ISTABNONE: ! 902: case ISTABDOT: ! 903: case IALIGN: ! 904: pptr(bufptr, (int)(struct symtab *)symalloc()); ! 905: break; ! 906: /* ! 907: * default: ! 908: */ ! 909: } ! 910: builtval: ; ! 911: } /*end of the while to stuff the buffer*/ ! 912: done: ! 913: bufferbox->tok_count = (toktype *)bufptr - &(bufferbox->toks[0]); ! 914: ! 915: /* ! 916: * This is a real kludge: ! 917: * ! 918: * We put the last token in the buffer to be a MINUS ! 919: * symbol. This last token will never be picked up ! 920: * in the normal way, but can be looked at during ! 921: * a peekahead look that the short circuit expression ! 922: * evaluator uses to see if an expression is complicated. ! 923: * ! 924: * Consider the following situation: ! 925: * ! 926: * .word 45 + 47 ! 927: * buffer 1 | buffer 0 ! 928: * the peekahead would want to look across the buffer, ! 929: * but will look in the buffer end zone, see the minus, and ! 930: * fail. ! 931: */ ! 932: ptoken(bufptr, MINUS); ! 933: InBufPtr = inbufptr; /*copy this back*/ ! 934: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.