![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to scan.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / lib / old_compiler / mip|
Return to scan.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / lib / old_compiler / mip |
1.1 ! root 1: #ifndef lint ! 2: static char *sccsid ="@(#)scan.c 2.4 (Berkeley) 4/22/87"; ! 3: #endif lint ! 4: ! 5: # include "pass1.h" ! 6: # include <a.out.h> ! 7: # include <stab.h> ! 8: # include <ctype.h> ! 9: # include <signal.h> ! 10: ! 11: /* temporarily */ ! 12: ! 13: int asm_esc = 0; /* asm escaped used in file */ ! 14: /* lexical actions */ ! 15: ! 16: # define A_ERR 0 /* illegal character */ ! 17: # define A_LET 1 /* saw a letter */ ! 18: # define A_DIG 2 /* saw a digit */ ! 19: # define A_1C 3 /* return a single character */ ! 20: # define A_STR 4 /* string */ ! 21: # define A_CC 5 /* character constant */ ! 22: # define A_BCD 6 /* GCOS BCD constant */ ! 23: # define A_SL 7 /* saw a / */ ! 24: # define A_DOT 8 /* saw a . */ ! 25: # define A_PL 9 /* + */ ! 26: # define A_MI 10 /* - */ ! 27: # define A_EQ 11 /* = */ ! 28: # define A_NOT 12 /* ! */ ! 29: # define A_LT 13 /* < */ ! 30: # define A_GT 14 /* > */ ! 31: # define A_AND 16 /* & */ ! 32: # define A_OR 17 /* | */ ! 33: # define A_WS 18 /* whitespace (not \n) */ ! 34: # define A_NL 19 /* \n */ ! 35: ! 36: /* character classes */ ! 37: ! 38: # define LEXLET 01 ! 39: # define LEXDIG 02 ! 40: # define LEXOCT 04 ! 41: # define LEXHEX 010 ! 42: # define LEXWS 020 ! 43: # define LEXDOT 040 ! 44: ! 45: /* reserved word actions */ ! 46: ! 47: # define AR_TY 0 /* type word */ ! 48: # define AR_RW 1 /* simple reserved word */ ! 49: # define AR_CL 2 /* storage class word */ ! 50: # define AR_S 3 /* struct */ ! 51: # define AR_U 4 /* union */ ! 52: # define AR_E 5 /* enum */ ! 53: # define AR_A 6 /* asm */ ! 54: ! 55: /* text buffer */ ! 56: #ifndef FLEXNAMES ! 57: # define LXTSZ 100 ! 58: #else ! 59: #define LXTSZ BUFSIZ ! 60: #endif ! 61: char yytext[LXTSZ]; ! 62: char * lxgcp; ! 63: ! 64: extern int proflg; ! 65: extern int gdebug; ! 66: extern int fpe(); ! 67: struct sigvec fpe_sigvec; ! 68: int oldway; /* allocate storage so lint will compile as well */ ! 69: #ifndef LINT ! 70: extern int lastloc; ! 71: #endif ! 72: ! 73: unsigned caloff(); ! 74: /* ARGSUSED */ ! 75: mainp1( argc, argv ) int argc; char *argv[]; { /* control multiple files */ ! 76: ! 77: register i; ! 78: register char *cp; ! 79: extern int idebug, bdebug, tdebug, edebug; ! 80: extern int ddebug, xdebug, gdebug, adebug; ! 81: extern unsigned int offsz; ! 82: int fdef = 0; ! 83: extern char *release; ! 84: ! 85: offsz = caloff(); ! 86: for( i=1; i<argc; ++i ){ ! 87: if( *(cp=argv[i]) == '-' && *++cp == 'X' ){ ! 88: while( *++cp ){ ! 89: switch( *cp ){ ! 90: ! 91: case 'r': ! 92: fprintf( stderr, "Release: %s\n", ! 93: release ); ! 94: break; ! 95: ! 96: case 'd': ! 97: ++ddebug; ! 98: break; ! 99: case 'i': ! 100: ++idebug; ! 101: break; ! 102: case 'b': ! 103: ++bdebug; ! 104: break; ! 105: case 't': ! 106: ++tdebug; ! 107: break; ! 108: case 'e': ! 109: ++edebug; ! 110: break; ! 111: case 'x': ! 112: ++xdebug; ! 113: break; ! 114: case 'P': /* profiling */ ! 115: ++proflg; ! 116: break; ! 117: case 'g': ! 118: ++gdebug; ! 119: break; ! 120: case 'a': ! 121: ++adebug; ! 122: break; ! 123: case 'G': ! 124: ++gdebug; ! 125: oldway = 1; ! 126: break; ! 127: } ! 128: } ! 129: } ! 130: else { ! 131: if( *(argv[i]) != '-' ) switch( fdef++ ) { ! 132: case 0: ! 133: case 1: ! 134: if( freopen(argv[i], fdef==1 ? "r" : "w", fdef==1 ? stdin : stdout) == NULL) { ! 135: fprintf(stderr, "ccom:can't open %s\n", argv[i]); ! 136: exit(1); ! 137: } ! 138: break; ! 139: ! 140: default: ! 141: ; ! 142: } ! 143: } ! 144: } ! 145: ! 146: # ifdef ONEPASS ! 147: p2init( argc, argv ); ! 148: # endif ! 149: ! 150: for( i=0; i<SYMTSZ; ++i ) stab[i].stype = TNULL; ! 151: ! 152: lineno = 1; ! 153: ! 154: lxinit(); ! 155: tinit(); ! 156: mkdope(); ! 157: ! 158: /* dimension table initialization */ ! 159: ! 160: dimtab[NULL] = 0; ! 161: dimtab[CHAR] = SZCHAR; ! 162: dimtab[INT] = SZINT; ! 163: dimtab[FLOAT] = SZFLOAT; ! 164: dimtab[DOUBLE] = SZDOUBLE; ! 165: dimtab[LONG] = SZLONG; ! 166: dimtab[SHORT] = SZSHORT; ! 167: dimtab[UCHAR] = SZCHAR; ! 168: dimtab[USHORT] = SZSHORT; ! 169: dimtab[UNSIGNED] = SZINT; ! 170: dimtab[ULONG] = SZLONG; ! 171: /* starts past any of the above */ ! 172: curdim = 16; ! 173: reached = 1; ! 174: ! 175: fpe_sigvec.sv_handler = fpe; ! 176: (void) sigvec(SIGFPE, &fpe_sigvec, (struct sigvec *) NULL); ! 177: ! 178: yyparse(); ! 179: yyaccpt(); ! 180: ! 181: ejobcode( nerrors ? 1 : 0 ); ! 182: return(nerrors?1:0); ! 183: ! 184: } ! 185: ! 186: # ifdef ibm ! 187: ! 188: # define CSMASK 0377 ! 189: # define CSSZ 256 ! 190: ! 191: # else ! 192: ! 193: # define CSMASK 0177 ! 194: # define CSSZ 128 ! 195: ! 196: # endif ! 197: ! 198: short lxmask[CSSZ+1]; ! 199: ! 200: lxenter( s, m ) register char *s; register short m; { ! 201: /* enter a mask into lxmask */ ! 202: register c; ! 203: ! 204: while( c= *s++ ) lxmask[c+1] |= m; ! 205: ! 206: } ! 207: ! 208: ! 209: # define lxget(c,m) (lxgcp=yytext,lxmore(c,m)) ! 210: ! 211: lxmore( c, m ) register c, m; { ! 212: register char *cp; ! 213: ! 214: *(cp = lxgcp) = c; ! 215: while( c=getchar(), lxmask[c+1]&m ){ ! 216: if( cp < &yytext[LXTSZ-1] ){ ! 217: *++cp = c; ! 218: } ! 219: } ! 220: ungetc(c,stdin); ! 221: *(lxgcp = cp+1) = '\0'; ! 222: } ! 223: ! 224: struct lxdope { ! 225: short lxch; /* the character */ ! 226: short lxact; /* the action to be performed */ ! 227: short lxtok; /* the token number to be returned */ ! 228: short lxval; /* the value to be returned */ ! 229: } lxdope[] = { ! 230: ! 231: '@', A_ERR, 0, 0, /* illegal characters go here... */ ! 232: '_', A_LET, 0, 0, /* letters point here */ ! 233: '0', A_DIG, 0, 0, /* digits point here */ ! 234: ' ', A_WS, 0, 0, /* whitespace goes here */ ! 235: '\n', A_NL, 0, 0, ! 236: '"', A_STR, 0, 0, /* character string */ ! 237: '\'', A_CC, 0, 0, /* character constant */ ! 238: '`', A_BCD, 0, 0, /* GCOS BCD constant */ ! 239: '(', A_1C, LP, 0, ! 240: ')', A_1C, RP, 0, ! 241: '{', A_1C, LC, 0, ! 242: '}', A_1C, RC, 0, ! 243: '[', A_1C, LB, 0, ! 244: ']', A_1C, RB, 0, ! 245: '*', A_1C, MUL, MUL, ! 246: '?', A_1C, QUEST, 0, ! 247: ':', A_1C, COLON, 0, ! 248: '+', A_PL, PLUS, PLUS, ! 249: '-', A_MI, MINUS, MINUS, ! 250: '/', A_SL, DIVOP, DIV, ! 251: '%', A_1C, DIVOP, MOD, ! 252: '&', A_AND, AND, AND, ! 253: '|', A_OR, OR, OR, ! 254: '^', A_1C, ER, ER, ! 255: '!', A_NOT, UNOP, NOT, ! 256: '~', A_1C, UNOP, COMPL, ! 257: ',', A_1C, CM, CM, ! 258: ';', A_1C, SM, 0, ! 259: '.', A_DOT, STROP, DOT, ! 260: '<', A_LT, RELOP, LT, ! 261: '>', A_GT, RELOP, GT, ! 262: '=', A_EQ, ASSIGN, ASSIGN, ! 263: -1, A_1C, 0, 0, ! 264: }; ! 265: ! 266: struct lxdope *lxcp[CSSZ+1]; ! 267: ! 268: lxinit(){ ! 269: register struct lxdope *p; ! 270: register i; ! 271: register char *cp; ! 272: /* set up character classes */ ! 273: ! 274: lxenter( "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$", LEXLET ); ! 275: lxenter( "0123456789", LEXDIG ); ! 276: lxenter( "0123456789abcdefABCDEF", LEXHEX ); ! 277: /* \013 should become \v someday; \013 is OK for ASCII and EBCDIC */ ! 278: lxenter( " \t\r\b\f\013", LEXWS ); ! 279: lxenter( "01234567", LEXOCT ); ! 280: lxmask['.'+1] |= LEXDOT; ! 281: ! 282: /* make lxcp point to appropriate lxdope entry for each character */ ! 283: ! 284: /* initialize error entries */ ! 285: ! 286: for( i= 0; i<=CSSZ; ++i ) lxcp[i] = lxdope; ! 287: ! 288: /* make unique entries */ ! 289: ! 290: for( p=lxdope; ; ++p ) { ! 291: lxcp[p->lxch+1] = p; ! 292: if( p->lxch < 0 ) break; ! 293: } ! 294: ! 295: /* handle letters, digits, and whitespace */ ! 296: /* by convention, first, second, and third places */ ! 297: ! 298: cp = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$"; ! 299: while( *cp ) lxcp[*cp++ + 1] = &lxdope[1]; ! 300: cp = "123456789"; ! 301: while( *cp ) lxcp[*cp++ + 1] = &lxdope[2]; ! 302: cp = "\t\b\r\f\013"; ! 303: while( *cp ) lxcp[*cp++ + 1] = &lxdope[3]; ! 304: ! 305: /* first line might have title */ ! 306: lxtitle(); ! 307: ! 308: } ! 309: ! 310: int lxmatch; /* character to be matched in char or string constant */ ! 311: ! 312: lxstr(ct){ ! 313: /* match a string or character constant, up to lxmatch */ ! 314: ! 315: register c; ! 316: register val; ! 317: register i; ! 318: ! 319: i=0; ! 320: while( (c=getchar()) != lxmatch ){ ! 321: switch( c ) { ! 322: ! 323: case EOF: ! 324: uerror( "unexpected EOF" ); ! 325: break; ! 326: ! 327: case '\n': ! 328: uerror( "newline in string or char constant" ); ! 329: ++lineno; ! 330: break; ! 331: ! 332: case '\\': ! 333: switch( c = getchar() ){ ! 334: ! 335: case '\n': ! 336: ++lineno; ! 337: continue; ! 338: ! 339: default: ! 340: if (hflag) ! 341: uerror("superfluous backslash in string/character constant"); ! 342: /*FALLTHROUGH*/ ! 343: case '\\': ! 344: case '\"': ! 345: case '\'': ! 346: val = c; ! 347: goto mkcc; ! 348: ! 349: case 'n': ! 350: val = '\n'; ! 351: goto mkcc; ! 352: ! 353: case 'r': ! 354: val = '\r'; ! 355: goto mkcc; ! 356: ! 357: case 'b': ! 358: val = '\b'; ! 359: goto mkcc; ! 360: ! 361: case 't': ! 362: val = '\t'; ! 363: goto mkcc; ! 364: ! 365: case 'f': ! 366: val = '\f'; ! 367: goto mkcc; ! 368: ! 369: case 'v': ! 370: val = '\013'; ! 371: goto mkcc; ! 372: ! 373: case '0': ! 374: case '1': ! 375: case '2': ! 376: case '3': ! 377: case '4': ! 378: case '5': ! 379: case '6': ! 380: case '7': ! 381: val = c-'0'; ! 382: c=getchar(); /* try for 2 */ ! 383: if( lxmask[c+1] & LEXOCT ){ ! 384: val = (val<<3) | (c-'0'); ! 385: c = getchar(); /* try for 3 */ ! 386: if( lxmask[c+1] & LEXOCT ){ ! 387: val = (val<<3) | (c-'0'); ! 388: } ! 389: else ungetc( c ,stdin); ! 390: } ! 391: else ungetc( c ,stdin); ! 392: ! 393: goto mkcc1; ! 394: ! 395: } ! 396: default: ! 397: val =c; ! 398: mkcc: ! 399: val = CCTRANS(val); ! 400: mkcc1: ! 401: if( lxmatch == '\'' ){ ! 402: val = CHARCAST(val); /* it is, after all, a "character" constant */ ! 403: makecc( val, i ); ! 404: } ! 405: else { /* stash the byte into the string */ ! 406: if( strflg ) { ! 407: if( ct==0 || i<ct ) putbyte( val ); ! 408: else if( i == ct ) werror( "non-null byte ignored in string initializer" ); ! 409: } ! 410: else bycode( val, i ); ! 411: } ! 412: ++i; ! 413: continue; ! 414: } ! 415: break; ! 416: } ! 417: /* end of string or char constant */ ! 418: ! 419: if( lxmatch == '"' ){ ! 420: if( strflg ){ /* end the string */ ! 421: if( ct==0 || i<ct ) putbyte( 0 ); /* the null at the end */ ! 422: } ! 423: else { /* the initializer gets a null byte */ ! 424: bycode( 0, i++ ); ! 425: bycode( -1, i ); ! 426: dimtab[curdim] = i; /* in case of later sizeof ... */ ! 427: } ! 428: } ! 429: else { /* end the character constant */ ! 430: if( i == 0 ) uerror( "empty character constant" ); ! 431: if( i>(SZINT/SZCHAR) || ( (pflag||hflag)&&i>1) ) ! 432: uerror( "too many characters in character constant" ); ! 433: } ! 434: } ! 435: ! 436: lxcom(){ ! 437: register c; ! 438: /* saw a /*: process a comment */ ! 439: ! 440: for(;;){ ! 441: ! 442: switch( c = getchar() ){ ! 443: ! 444: case EOF: ! 445: uerror( "unexpected EOF" ); ! 446: return; ! 447: ! 448: case '\n': ! 449: ++lineno; ! 450: ! 451: default: ! 452: continue; ! 453: ! 454: case '*': ! 455: if( (c = getchar()) == '/' ) return; ! 456: else ungetc( c ,stdin); ! 457: continue; ! 458: ! 459: # ifdef LINT ! 460: case 'V': ! 461: lxget( c, LEXLET|LEXDIG ); ! 462: { ! 463: extern int vaflag; ! 464: int i; ! 465: i = yytext[7]?yytext[7]-'0':0; ! 466: yytext[7] = '\0'; ! 467: if( strcmp( yytext, "VARARGS" ) ) continue; ! 468: vaflag = i; ! 469: continue; ! 470: } ! 471: case 'L': ! 472: lxget( c, LEXLET ); ! 473: if( strcmp( yytext, "LINTLIBRARY" ) ) continue; ! 474: { ! 475: extern int libflag; ! 476: libflag = 1; ! 477: } ! 478: continue; ! 479: ! 480: case 'A': ! 481: lxget( c, LEXLET ); ! 482: if( strcmp( yytext, "ARGSUSED" ) ) continue; ! 483: { ! 484: extern int argflag, vflag; ! 485: argflag = 1; ! 486: vflag = 0; ! 487: } ! 488: continue; ! 489: ! 490: case 'N': ! 491: lxget( c, LEXLET ); ! 492: if( strcmp( yytext, "NOTREACHED" ) ) continue; ! 493: reached = 0; ! 494: continue; ! 495: # endif ! 496: } ! 497: } ! 498: } ! 499: ! 500: yylex(){ ! 501: for(;;){ ! 502: ! 503: register lxchar; ! 504: register struct lxdope *p; ! 505: register struct symtab *sp; ! 506: int id; ! 507: ! 508: switch( (p=lxcp[(lxchar=getchar())+1])->lxact ){ ! 509: ! 510: onechar: ! 511: ungetc( lxchar ,stdin); ! 512: ! 513: case A_1C: ! 514: /* eat up a single character, and return an opcode */ ! 515: ! 516: yylval.intval = p->lxval; ! 517: return( p->lxtok ); ! 518: ! 519: case A_ERR: ! 520: uerror( "illegal character: %03o (octal)", lxchar ); ! 521: break; ! 522: ! 523: case A_LET: ! 524: /* collect an identifier, check for reserved word, and return */ ! 525: lxget( lxchar, LEXLET|LEXDIG ); ! 526: if( (lxchar=lxres()) > 0 ) return( lxchar ); /* reserved word */ ! 527: if( lxchar== 0 ) continue; ! 528: #ifdef FLEXNAMES ! 529: id = lookup( hash(yytext), ! 530: #else ! 531: id = lookup( yytext, ! 532: #endif ! 533: /* tag name for struct/union/enum */ ! 534: (stwart&TAGNAME)? STAG: ! 535: /* member name for struct/union */ ! 536: (stwart&(INSTRUCT|INUNION|FUNNYNAME))?SMOS:0 ); ! 537: sp = &stab[id]; ! 538: if( sp->sclass == TYPEDEF && !stwart ){ ! 539: stwart = instruct; ! 540: yylval.nodep = mkty( sp->stype, sp->dimoff, sp->sizoff ); ! 541: return( TYPE ); ! 542: } ! 543: stwart = (stwart&SEENAME) ? instruct : 0; ! 544: yylval.intval = id; ! 545: return( NAME ); ! 546: ! 547: case A_DIG: ! 548: /* collect a digit string, then look at last one... */ ! 549: lastcon = 0; ! 550: lxget( lxchar, LEXDIG ); ! 551: switch( lxchar=getchar() ){ ! 552: ! 553: case 'x': ! 554: case 'X': ! 555: if( yytext[0] != '0' && !yytext[1] ) uerror( "illegal hex constant" ); ! 556: lxmore( lxchar, LEXHEX ); ! 557: /* convert the value */ ! 558: { ! 559: register char *cp; ! 560: for( cp = yytext+2; *cp; ++cp ){ ! 561: /* this code won't work for all wild character sets, ! 562: but seems ok for ascii and ebcdic */ ! 563: lastcon <<= 4; ! 564: if( isdigit( *cp ) ) lastcon += *cp-'0'; ! 565: else if( isupper( *cp ) ) lastcon += *cp - 'A'+ 10; ! 566: else lastcon += *cp - 'a'+ 10; ! 567: } ! 568: } ! 569: ! 570: hexlong: ! 571: /* criterion for longness for hex and octal constants is that it ! 572: fit within 0177777 */ ! 573: if( lastcon & ~0177777L ) yylval.intval = 1; ! 574: else yylval.intval = 0; ! 575: ! 576: goto islong; ! 577: ! 578: case '.': ! 579: lxmore( lxchar, LEXDIG ); ! 580: ! 581: getfp: ! 582: if( (lxchar=getchar()) == 'e' || lxchar == 'E' ){ /* exponent */ ! 583: ! 584: case 'e': ! 585: case 'E': ! 586: if( (lxchar=getchar()) == '+' || lxchar == '-' ){ ! 587: *lxgcp++ = 'e'; ! 588: } ! 589: else { ! 590: ungetc(lxchar,stdin); ! 591: lxchar = 'e'; ! 592: } ! 593: lxmore( lxchar, LEXDIG ); ! 594: /* now have the whole thing... */ ! 595: } ! 596: else { /* no exponent */ ! 597: ungetc( lxchar ,stdin); ! 598: } ! 599: return( isitfloat( yytext ) ); ! 600: ! 601: default: ! 602: ungetc( lxchar ,stdin); ! 603: if( yytext[0] == '0' ){ ! 604: /* convert in octal */ ! 605: register char *cp; ! 606: for( cp = yytext+1; *cp; ++cp ){ ! 607: lastcon <<= 3; ! 608: lastcon += *cp - '0'; ! 609: } ! 610: goto hexlong; ! 611: } ! 612: else { ! 613: /* convert in decimal */ ! 614: register char *cp; ! 615: for( cp = yytext; *cp; ++cp ){ ! 616: lastcon = lastcon * 10 + *cp - '0'; ! 617: } ! 618: } ! 619: ! 620: /* decide if it is long or not (decimal case) */ ! 621: ! 622: /* if it is positive and fits in 15 bits, or negative and ! 623: and fits in 15 bits plus an extended sign, it is int; otherwise long */ ! 624: /* if there is an l or L following, all bets are off... */ ! 625: ! 626: { CONSZ v; ! 627: v = lastcon & ~077777L; ! 628: if( v == 0 || v == ~077777L ) yylval.intval = 0; ! 629: else yylval.intval = 1; ! 630: } ! 631: ! 632: islong: ! 633: /* finally, look for trailing L or l */ ! 634: if( (lxchar = getchar()) == 'L' || lxchar == 'l' ) yylval.intval = 1; ! 635: else ungetc( lxchar ,stdin); ! 636: return( ICON ); ! 637: } ! 638: ! 639: case A_DOT: ! 640: /* look for a dot: if followed by a digit, floating point */ ! 641: lxchar = getchar(); ! 642: if( lxmask[lxchar+1] & LEXDIG ){ ! 643: ungetc(lxchar,stdin); ! 644: lxget( '.', LEXDIG ); ! 645: goto getfp; ! 646: } ! 647: stwart = FUNNYNAME; ! 648: goto onechar; ! 649: ! 650: case A_STR: ! 651: /* string constant */ ! 652: lxmatch = '"'; ! 653: return( STRING ); ! 654: ! 655: case A_CC: ! 656: /* character constant */ ! 657: lxmatch = '\''; ! 658: lastcon = 0; ! 659: lxstr(0); ! 660: yylval.intval = 0; ! 661: return( ICON ); ! 662: ! 663: case A_BCD: ! 664: { ! 665: register i; ! 666: int j; ! 667: for( i=0; i<LXTSZ; ++i ){ ! 668: if( ( j = getchar() ) == '`' ) break; ! 669: if( j == '\n' ){ ! 670: uerror( "newline in BCD constant" ); ! 671: break; ! 672: } ! 673: yytext[i] = j; ! 674: } ! 675: yytext[i] = '\0'; ! 676: if( i>6 ) uerror( "BCD constant exceeds 6 characters" ); ! 677: # ifdef gcos ! 678: else strtob( yytext, &lastcon, i ); ! 679: lastcon >>= 6*(6-i); ! 680: # else ! 681: uerror( "gcos BCD constant illegal" ); ! 682: # endif ! 683: yylval.intval = 0; /* not long */ ! 684: return( ICON ); ! 685: } ! 686: ! 687: case A_SL: ! 688: /* / */ ! 689: if( (lxchar=getchar()) != '*' ) goto onechar; ! 690: lxcom(); ! 691: case A_WS: ! 692: continue; ! 693: ! 694: case A_NL: ! 695: ++lineno; ! 696: lxtitle(); ! 697: continue; ! 698: ! 699: case A_NOT: ! 700: /* ! */ ! 701: if( (lxchar=getchar()) != '=' ) goto onechar; ! 702: yylval.intval = NE; ! 703: return( EQUOP ); ! 704: ! 705: case A_MI: ! 706: /* - */ ! 707: if( (lxchar=getchar()) == '-' ){ ! 708: yylval.intval = DECR; ! 709: return( INCOP ); ! 710: } ! 711: if( lxchar != '>' ) goto onechar; ! 712: stwart = FUNNYNAME; ! 713: yylval.intval=STREF; ! 714: return( STROP ); ! 715: ! 716: case A_PL: ! 717: /* + */ ! 718: if( (lxchar=getchar()) != '+' ) goto onechar; ! 719: yylval.intval = INCR; ! 720: return( INCOP ); ! 721: ! 722: case A_AND: ! 723: /* & */ ! 724: if( (lxchar=getchar()) != '&' ) goto onechar; ! 725: return( yylval.intval = ANDAND ); ! 726: ! 727: case A_OR: ! 728: /* | */ ! 729: if( (lxchar=getchar()) != '|' ) goto onechar; ! 730: return( yylval.intval = OROR ); ! 731: ! 732: case A_LT: ! 733: /* < */ ! 734: if( (lxchar=getchar()) == '<' ){ ! 735: yylval.intval = LS; ! 736: return( SHIFTOP ); ! 737: } ! 738: if( lxchar != '=' ) goto onechar; ! 739: yylval.intval = LE; ! 740: return( RELOP ); ! 741: ! 742: case A_GT: ! 743: /* > */ ! 744: if( (lxchar=getchar()) == '>' ){ ! 745: yylval.intval = RS; ! 746: return(SHIFTOP ); ! 747: } ! 748: if( lxchar != '=' ) goto onechar; ! 749: yylval.intval = GE; ! 750: return( RELOP ); ! 751: ! 752: case A_EQ: ! 753: /* = */ ! 754: switch( lxchar = getchar() ){ ! 755: ! 756: case '=': ! 757: yylval.intval = EQ; ! 758: return( EQUOP ); ! 759: ! 760: case '+': ! 761: yylval.intval = ASG PLUS; ! 762: break; ! 763: ! 764: case '-': ! 765: yylval.intval = ASG MINUS; ! 766: ! 767: warn: ! 768: if( lxmask[ (lxchar=getchar())+1] & (LEXLET|LEXDIG|LEXDOT) ){ ! 769: werror( "ambiguous assignment: assignment op taken" ); ! 770: } ! 771: ungetc( lxchar ,stdin); ! 772: break; ! 773: ! 774: case '*': ! 775: yylval.intval = ASG MUL; ! 776: goto warn; ! 777: ! 778: case '/': ! 779: yylval.intval = ASG DIV; ! 780: break; ! 781: ! 782: case '%': ! 783: yylval.intval = ASG MOD; ! 784: break; ! 785: ! 786: case '&': ! 787: yylval.intval = ASG AND; ! 788: break; ! 789: ! 790: case '|': ! 791: yylval.intval = ASG OR; ! 792: break; ! 793: ! 794: case '^': ! 795: yylval.intval = ASG ER; ! 796: break; ! 797: ! 798: case '<': ! 799: if( (lxchar=getchar()) != '<' ){ ! 800: uerror( "=<%c illegal", lxchar ); ! 801: } ! 802: yylval.intval = ASG LS; ! 803: break; ! 804: ! 805: case '>': ! 806: if( (lxchar=getchar()) != '>' ){ ! 807: uerror( "=>%c illegal", lxchar ); ! 808: } ! 809: yylval.intval = ASG RS; ! 810: break; ! 811: ! 812: default: ! 813: goto onechar; ! 814: ! 815: } ! 816: ! 817: return( ASOP ); ! 818: ! 819: default: ! 820: cerror( "yylex error, character %03o (octal)", lxchar ); ! 821: ! 822: } ! 823: ! 824: /* ordinarily, repeat here... */ ! 825: cerror( "out of switch in yylex" ); ! 826: ! 827: } ! 828: ! 829: } ! 830: ! 831: struct lxrdope { ! 832: /* dope for reserved, in alphabetical order */ ! 833: ! 834: char *lxrch; /* name of reserved word */ ! 835: short lxract; /* reserved word action */ ! 836: short lxrval; /* value to be returned */ ! 837: } lxrdope[] = { ! 838: ! 839: "asm", AR_A, 0, ! 840: "auto", AR_CL, AUTO, ! 841: "break", AR_RW, BREAK, ! 842: "char", AR_TY, CHAR, ! 843: "case", AR_RW, CASE, ! 844: "continue", AR_RW, CONTINUE, ! 845: "double", AR_TY, DOUBLE, ! 846: "default", AR_RW, DEFAULT, ! 847: "do", AR_RW, DO, ! 848: "extern", AR_CL, EXTERN, ! 849: "else", AR_RW, ELSE, ! 850: "enum", AR_E, ENUM, ! 851: "for", AR_RW, FOR, ! 852: "float", AR_TY, FLOAT, ! 853: "fortran", AR_CL, FORTRAN, ! 854: "goto", AR_RW, GOTO, ! 855: "if", AR_RW, IF, ! 856: "int", AR_TY, INT, ! 857: "long", AR_TY, LONG, ! 858: "return", AR_RW, RETURN, ! 859: "register", AR_CL, REGISTER, ! 860: "switch", AR_RW, SWITCH, ! 861: "struct", AR_S, 0, ! 862: "sizeof", AR_RW, SIZEOF, ! 863: "short", AR_TY, SHORT, ! 864: "static", AR_CL, STATIC, ! 865: "typedef", AR_CL, TYPEDEF, ! 866: "unsigned", AR_TY, UNSIGNED, ! 867: "union", AR_U, 0, ! 868: "void", AR_TY, UNDEF, /* tymerge adds FTN */ ! 869: "while", AR_RW, WHILE, ! 870: "", 0, 0, /* to stop the search */ ! 871: }; ! 872: ! 873: lxres() { ! 874: /* check to see of yytext is reserved; if so, ! 875: /* do the appropriate action and return */ ! 876: /* otherwise, return -1 */ ! 877: ! 878: register c, ch; ! 879: register struct lxrdope *p; ! 880: ! 881: ch = yytext[0]; ! 882: ! 883: if( !islower(ch) ) return( -1 ); ! 884: ! 885: switch( ch ){ ! 886: ! 887: case 'a': ! 888: c=0; break; ! 889: case 'b': ! 890: c=2; break; ! 891: case 'c': ! 892: c=3; break; ! 893: case 'd': ! 894: c=6; break; ! 895: case 'e': ! 896: c=9; break; ! 897: case 'f': ! 898: c=12; break; ! 899: case 'g': ! 900: c=15; break; ! 901: case 'i': ! 902: c=16; break; ! 903: case 'l': ! 904: c=18; break; ! 905: case 'r': ! 906: c=19; break; ! 907: case 's': ! 908: c=21; break; ! 909: case 't': ! 910: c=26; break; ! 911: case 'u': ! 912: c=27; break; ! 913: case 'v': ! 914: c=29; break; ! 915: case 'w': ! 916: c=30; break; ! 917: ! 918: default: ! 919: return( -1 ); ! 920: } ! 921: ! 922: for( p= lxrdope+c; p->lxrch[0] == ch; ++p ){ ! 923: if( !strcmp( yytext, p->lxrch ) ){ /* match */ ! 924: switch( p->lxract ){ ! 925: ! 926: case AR_TY: ! 927: /* type word */ ! 928: stwart = instruct; ! 929: yylval.nodep = mkty( (TWORD)p->lxrval, 0, p->lxrval ); ! 930: return( TYPE ); ! 931: ! 932: case AR_RW: ! 933: { ! 934: extern int nsizeof; ! 935: ! 936: if (p->lxrval == SIZEOF) ! 937: ++nsizeof; ! 938: } ! 939: /* ordinary reserved word */ ! 940: return( yylval.intval = p->lxrval ); ! 941: ! 942: case AR_CL: ! 943: /* class word */ ! 944: yylval.intval = p->lxrval; ! 945: return( CLASS ); ! 946: ! 947: case AR_S: ! 948: /* struct */ ! 949: stwart = INSTRUCT|SEENAME|TAGNAME; ! 950: yylval.intval = INSTRUCT; ! 951: return( STRUCT ); ! 952: ! 953: case AR_U: ! 954: /* union */ ! 955: stwart = INUNION|SEENAME|TAGNAME; ! 956: yylval.intval = INUNION; ! 957: return( STRUCT ); ! 958: ! 959: case AR_E: ! 960: /* enums */ ! 961: stwart = SEENAME|TAGNAME; ! 962: return( yylval.intval = ENUM ); ! 963: ! 964: case AR_A: ! 965: /* asm */ ! 966: asm_esc = 1; /* warn the world! */ ! 967: lxget( ' ', LEXWS ); ! 968: if( getchar() != '(' ) goto badasm; ! 969: lxget( ' ', LEXWS ); ! 970: if( getchar() != '"' ) goto badasm; ! 971: # ifndef ONEPASS ! 972: # ifndef LINT ! 973: putchar(')'); ! 974: # endif ! 975: # endif ! 976: while( (c=getchar()) != '"' ){ ! 977: if( c=='\n' || c==EOF ) goto badasm; ! 978: # ifndef LINT ! 979: putchar(c); ! 980: # endif ! 981: } ! 982: lxget( ' ', LEXWS ); ! 983: if( getchar() != ')' ) goto badasm; ! 984: # ifndef LINT ! 985: putchar('\n'); ! 986: # endif ! 987: return( 0 ); ! 988: ! 989: badasm: ! 990: uerror( "bad asm construction" ); ! 991: return( 0 ); ! 992: ! 993: default: ! 994: cerror( "bad AR_?? action" ); ! 995: } ! 996: } ! 997: } ! 998: return( -1 ); ! 999: } ! 1000: ! 1001: extern int labelno; ! 1002: ! 1003: lxtitle(){ ! 1004: /* called after a newline; set linenumber and file name */ ! 1005: ! 1006: register c, val; ! 1007: register char *cp, *cq; ! 1008: ! 1009: for(;;){ /* might be several such lines in a row */ ! 1010: if( (c=getchar()) != '#' ){ ! 1011: if( c != EOF ) ungetc(c,stdin); ! 1012: #ifndef LINT ! 1013: if ( lastloc != PROG) return; ! 1014: cp = ftitle; ! 1015: cq = ititle; ! 1016: while ( *cp ) if (*cp++ != *cq++) return; ! 1017: if ( *cq ) return; ! 1018: psline(); ! 1019: #endif ! 1020: return; ! 1021: } ! 1022: ! 1023: lxget( ' ', LEXWS ); ! 1024: val = 0; ! 1025: for( c=getchar(); isdigit(c); c=getchar() ){ ! 1026: val = val*10+ c - '0'; ! 1027: } ! 1028: if( c == EOF ) ! 1029: continue; ! 1030: ungetc( c, stdin ); ! 1031: lineno = val; ! 1032: lxget( ' ', LEXWS ); ! 1033: if( (c=getchar()) != '\n' && c != EOF ){ ! 1034: for( cp=ftitle; c!=EOF && c!='\n'; c=getchar(),++cp ){ ! 1035: *cp = c; ! 1036: } ! 1037: *cp = '\0'; ! 1038: #ifndef LINT ! 1039: if (ititle[0] == '\0') { ! 1040: cp = ftitle; ! 1041: cq = ititle; ! 1042: while ( *cp ) ! 1043: *cq++ = *cp++; ! 1044: *cq = '\0'; ! 1045: *--cq = '\0'; ! 1046: #ifndef FLEXNAMES ! 1047: for ( cp = ititle+1; *(cp-1); cp += 8 ) { ! 1048: pstab(cp, N_SO); ! 1049: if (gdebug) printf("0,0,LL%d\n", labelno); ! 1050: } ! 1051: #else ! 1052: pstab(ititle+1, N_SO); ! 1053: if (gdebug) printf("0,0,LL%d\n", labelno); ! 1054: #endif ! 1055: ! 1056: *cq = '"'; ! 1057: printf("LL%d:\n", labelno++); ! 1058: } ! 1059: #endif ! 1060: } ! 1061: } ! 1062: } ! 1063: ! 1064: #ifdef FLEXNAMES ! 1065: #define NSAVETAB 4096 ! 1066: char *savetab; ! 1067: int saveleft; ! 1068: ! 1069: char * ! 1070: savestr(cp) ! 1071: register char *cp; ! 1072: { ! 1073: register int len; ! 1074: ! 1075: len = strlen(cp) + 1; ! 1076: if (len > saveleft) { ! 1077: saveleft = NSAVETAB; ! 1078: if (len > saveleft) ! 1079: saveleft = len; ! 1080: savetab = (char *)malloc(saveleft); ! 1081: if (savetab == 0) ! 1082: cerror("Ran out of memory (savestr)"); ! 1083: } ! 1084: strncpy(savetab, cp, len); ! 1085: cp = savetab; ! 1086: savetab += len; ! 1087: saveleft -= len; ! 1088: return (cp); ! 1089: } ! 1090: ! 1091: /* ! 1092: * The definition for the segmented hash tables. ! 1093: */ ! 1094: #define MAXHASH 20 ! 1095: #define HASHINC 1013 ! 1096: struct ht { ! 1097: char **ht_low; ! 1098: char **ht_high; ! 1099: int ht_used; ! 1100: } htab[MAXHASH]; ! 1101: ! 1102: char * ! 1103: hash(s) ! 1104: char *s; ! 1105: { ! 1106: register char **h; ! 1107: register i; ! 1108: register char *cp; ! 1109: struct ht *htp; ! 1110: int sh; ! 1111: ! 1112: /* ! 1113: * The hash function is a modular hash of ! 1114: * the sum of the characters with the sum ! 1115: * doubled before each successive character ! 1116: * is added. ! 1117: */ ! 1118: cp = s; ! 1119: i = 0; ! 1120: while (*cp) ! 1121: i = i*2 + *cp++; ! 1122: sh = (i&077777) % HASHINC; ! 1123: cp = s; ! 1124: /* ! 1125: * There are as many as MAXHASH active ! 1126: * hash tables at any given point in time. ! 1127: * The search starts with the first table ! 1128: * and continues through the active tables ! 1129: * as necessary. ! 1130: */ ! 1131: for (htp = htab; htp < &htab[MAXHASH]; htp++) { ! 1132: if (htp->ht_low == 0) { ! 1133: register char **hp = ! 1134: (char **) calloc(sizeof (char **), HASHINC); ! 1135: if (hp == 0) ! 1136: cerror("ran out of memory (hash)"); ! 1137: htp->ht_low = hp; ! 1138: htp->ht_high = htp->ht_low + HASHINC; ! 1139: } ! 1140: h = htp->ht_low + sh; ! 1141: /* ! 1142: * quadratic rehash increment ! 1143: * starts at 1 and incremented ! 1144: * by two each rehash. ! 1145: */ ! 1146: i = 1; ! 1147: do { ! 1148: if (*h == 0) { ! 1149: if (htp->ht_used > (HASHINC * 3)/4) ! 1150: break; ! 1151: htp->ht_used++; ! 1152: *h = savestr(cp); ! 1153: return (*h); ! 1154: } ! 1155: if (**h == *cp && strcmp(*h, cp) == 0) ! 1156: return (*h); ! 1157: h += i; ! 1158: i += 2; ! 1159: if (h >= htp->ht_high) ! 1160: h -= HASHINC; ! 1161: } while (i < HASHINC); ! 1162: } ! 1163: cerror("ran out of hash tables"); ! 1164: } ! 1165: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.