![[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] / 43BSD / lib / mip|
Return to scan.c CVS log | Up to [CSRG BSD Unix] / 43BSD / lib / mip |
1.1 ! root 1: #ifndef lint ! 2: static char *sccsid ="@(#)scan.c 2.1 (Berkeley) 4/23/86"; ! 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: char *release = "PCC/2.1 (Berkeley) 4/23/86"; ! 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: val = c; ! 341: goto mkcc; ! 342: ! 343: case 'n': ! 344: val = '\n'; ! 345: goto mkcc; ! 346: ! 347: case 'r': ! 348: val = '\r'; ! 349: goto mkcc; ! 350: ! 351: case 'b': ! 352: val = '\b'; ! 353: goto mkcc; ! 354: ! 355: case 't': ! 356: val = '\t'; ! 357: goto mkcc; ! 358: ! 359: case 'f': ! 360: val = '\f'; ! 361: goto mkcc; ! 362: ! 363: case 'v': ! 364: val = '\013'; ! 365: goto mkcc; ! 366: ! 367: case '0': ! 368: case '1': ! 369: case '2': ! 370: case '3': ! 371: case '4': ! 372: case '5': ! 373: case '6': ! 374: case '7': ! 375: val = c-'0'; ! 376: c=getchar(); /* try for 2 */ ! 377: if( lxmask[c+1] & LEXOCT ){ ! 378: val = (val<<3) | (c-'0'); ! 379: c = getchar(); /* try for 3 */ ! 380: if( lxmask[c+1] & LEXOCT ){ ! 381: val = (val<<3) | (c-'0'); ! 382: } ! 383: else ungetc( c ,stdin); ! 384: } ! 385: else ungetc( c ,stdin); ! 386: ! 387: goto mkcc1; ! 388: ! 389: } ! 390: default: ! 391: val =c; ! 392: mkcc: ! 393: val = CCTRANS(val); ! 394: mkcc1: ! 395: if( lxmatch == '\'' ){ ! 396: val = CHARCAST(val); /* it is, after all, a "character" constant */ ! 397: makecc( val, i ); ! 398: } ! 399: else { /* stash the byte into the string */ ! 400: if( strflg ) { ! 401: if( ct==0 || i<ct ) putbyte( val ); ! 402: else if( i == ct ) werror( "non-null byte ignored in string initializer" ); ! 403: } ! 404: else bycode( val, i ); ! 405: } ! 406: ++i; ! 407: continue; ! 408: } ! 409: break; ! 410: } ! 411: /* end of string or char constant */ ! 412: ! 413: if( lxmatch == '"' ){ ! 414: if( strflg ){ /* end the string */ ! 415: if( ct==0 || i<ct ) putbyte( 0 ); /* the null at the end */ ! 416: } ! 417: else { /* the initializer gets a null byte */ ! 418: bycode( 0, i++ ); ! 419: bycode( -1, i ); ! 420: dimtab[curdim] = i; /* in case of later sizeof ... */ ! 421: } ! 422: } ! 423: else { /* end the character constant */ ! 424: if( i == 0 ) uerror( "empty character constant" ); ! 425: if( i>(SZINT/SZCHAR) || ( (pflag||hflag)&&i>1) ) ! 426: uerror( "too many characters in character constant" ); ! 427: } ! 428: } ! 429: ! 430: lxcom(){ ! 431: register c; ! 432: /* saw a /*: process a comment */ ! 433: ! 434: for(;;){ ! 435: ! 436: switch( c = getchar() ){ ! 437: ! 438: case EOF: ! 439: uerror( "unexpected EOF" ); ! 440: return; ! 441: ! 442: case '\n': ! 443: ++lineno; ! 444: ! 445: default: ! 446: continue; ! 447: ! 448: case '*': ! 449: if( (c = getchar()) == '/' ) return; ! 450: else ungetc( c ,stdin); ! 451: continue; ! 452: ! 453: # ifdef LINT ! 454: case 'V': ! 455: lxget( c, LEXLET|LEXDIG ); ! 456: { ! 457: extern int vaflag; ! 458: int i; ! 459: i = yytext[7]?yytext[7]-'0':0; ! 460: yytext[7] = '\0'; ! 461: if( strcmp( yytext, "VARARGS" ) ) continue; ! 462: vaflag = i; ! 463: continue; ! 464: } ! 465: case 'L': ! 466: lxget( c, LEXLET ); ! 467: if( strcmp( yytext, "LINTLIBRARY" ) ) continue; ! 468: { ! 469: extern int libflag; ! 470: libflag = 1; ! 471: } ! 472: continue; ! 473: ! 474: case 'A': ! 475: lxget( c, LEXLET ); ! 476: if( strcmp( yytext, "ARGSUSED" ) ) continue; ! 477: { ! 478: extern int argflag, vflag; ! 479: argflag = 1; ! 480: vflag = 0; ! 481: } ! 482: continue; ! 483: ! 484: case 'N': ! 485: lxget( c, LEXLET ); ! 486: if( strcmp( yytext, "NOTREACHED" ) ) continue; ! 487: reached = 0; ! 488: continue; ! 489: # endif ! 490: } ! 491: } ! 492: } ! 493: ! 494: yylex(){ ! 495: for(;;){ ! 496: ! 497: register lxchar; ! 498: register struct lxdope *p; ! 499: register struct symtab *sp; ! 500: int id; ! 501: ! 502: switch( (p=lxcp[(lxchar=getchar())+1])->lxact ){ ! 503: ! 504: onechar: ! 505: ungetc( lxchar ,stdin); ! 506: ! 507: case A_1C: ! 508: /* eat up a single character, and return an opcode */ ! 509: ! 510: yylval.intval = p->lxval; ! 511: return( p->lxtok ); ! 512: ! 513: case A_ERR: ! 514: uerror( "illegal character: %03o (octal)", lxchar ); ! 515: break; ! 516: ! 517: case A_LET: ! 518: /* collect an identifier, check for reserved word, and return */ ! 519: lxget( lxchar, LEXLET|LEXDIG ); ! 520: if( (lxchar=lxres()) > 0 ) return( lxchar ); /* reserved word */ ! 521: if( lxchar== 0 ) continue; ! 522: #ifdef FLEXNAMES ! 523: id = lookup( hash(yytext), ! 524: #else ! 525: id = lookup( yytext, ! 526: #endif ! 527: /* tag name for struct/union/enum */ ! 528: (stwart&TAGNAME)? STAG: ! 529: /* member name for struct/union */ ! 530: (stwart&(INSTRUCT|INUNION|FUNNYNAME))?SMOS:0 ); ! 531: sp = &stab[id]; ! 532: if( sp->sclass == TYPEDEF && !stwart ){ ! 533: stwart = instruct; ! 534: yylval.nodep = mkty( sp->stype, sp->dimoff, sp->sizoff ); ! 535: return( TYPE ); ! 536: } ! 537: stwart = (stwart&SEENAME) ? instruct : 0; ! 538: yylval.intval = id; ! 539: return( NAME ); ! 540: ! 541: case A_DIG: ! 542: /* collect a digit string, then look at last one... */ ! 543: lastcon = 0; ! 544: lxget( lxchar, LEXDIG ); ! 545: switch( lxchar=getchar() ){ ! 546: ! 547: case 'x': ! 548: case 'X': ! 549: if( yytext[0] != '0' && !yytext[1] ) uerror( "illegal hex constant" ); ! 550: lxmore( lxchar, LEXHEX ); ! 551: /* convert the value */ ! 552: { ! 553: register char *cp; ! 554: for( cp = yytext+2; *cp; ++cp ){ ! 555: /* this code won't work for all wild character sets, ! 556: but seems ok for ascii and ebcdic */ ! 557: lastcon <<= 4; ! 558: if( isdigit( *cp ) ) lastcon += *cp-'0'; ! 559: else if( isupper( *cp ) ) lastcon += *cp - 'A'+ 10; ! 560: else lastcon += *cp - 'a'+ 10; ! 561: } ! 562: } ! 563: ! 564: hexlong: ! 565: /* criterion for longness for hex and octal constants is that it ! 566: fit within 0177777 */ ! 567: if( lastcon & ~0177777L ) yylval.intval = 1; ! 568: else yylval.intval = 0; ! 569: ! 570: goto islong; ! 571: ! 572: case '.': ! 573: lxmore( lxchar, LEXDIG ); ! 574: ! 575: getfp: ! 576: if( (lxchar=getchar()) == 'e' || lxchar == 'E' ){ /* exponent */ ! 577: ! 578: case 'e': ! 579: case 'E': ! 580: if( (lxchar=getchar()) == '+' || lxchar == '-' ){ ! 581: *lxgcp++ = 'e'; ! 582: } ! 583: else { ! 584: ungetc(lxchar,stdin); ! 585: lxchar = 'e'; ! 586: } ! 587: lxmore( lxchar, LEXDIG ); ! 588: /* now have the whole thing... */ ! 589: } ! 590: else { /* no exponent */ ! 591: ungetc( lxchar ,stdin); ! 592: } ! 593: return( isitfloat( yytext ) ); ! 594: ! 595: default: ! 596: ungetc( lxchar ,stdin); ! 597: if( yytext[0] == '0' ){ ! 598: /* convert in octal */ ! 599: register char *cp; ! 600: for( cp = yytext+1; *cp; ++cp ){ ! 601: lastcon <<= 3; ! 602: lastcon += *cp - '0'; ! 603: } ! 604: goto hexlong; ! 605: } ! 606: else { ! 607: /* convert in decimal */ ! 608: register char *cp; ! 609: for( cp = yytext; *cp; ++cp ){ ! 610: lastcon = lastcon * 10 + *cp - '0'; ! 611: } ! 612: } ! 613: ! 614: /* decide if it is long or not (decimal case) */ ! 615: ! 616: /* if it is positive and fits in 15 bits, or negative and ! 617: and fits in 15 bits plus an extended sign, it is int; otherwise long */ ! 618: /* if there is an l or L following, all bets are off... */ ! 619: ! 620: { CONSZ v; ! 621: v = lastcon & ~077777L; ! 622: if( v == 0 || v == ~077777L ) yylval.intval = 0; ! 623: else yylval.intval = 1; ! 624: } ! 625: ! 626: islong: ! 627: /* finally, look for trailing L or l */ ! 628: if( (lxchar = getchar()) == 'L' || lxchar == 'l' ) yylval.intval = 1; ! 629: else ungetc( lxchar ,stdin); ! 630: return( ICON ); ! 631: } ! 632: ! 633: case A_DOT: ! 634: /* look for a dot: if followed by a digit, floating point */ ! 635: lxchar = getchar(); ! 636: if( lxmask[lxchar+1] & LEXDIG ){ ! 637: ungetc(lxchar,stdin); ! 638: lxget( '.', LEXDIG ); ! 639: goto getfp; ! 640: } ! 641: stwart = FUNNYNAME; ! 642: goto onechar; ! 643: ! 644: case A_STR: ! 645: /* string constant */ ! 646: lxmatch = '"'; ! 647: return( STRING ); ! 648: ! 649: case A_CC: ! 650: /* character constant */ ! 651: lxmatch = '\''; ! 652: lastcon = 0; ! 653: lxstr(0); ! 654: yylval.intval = 0; ! 655: return( ICON ); ! 656: ! 657: case A_BCD: ! 658: { ! 659: register i; ! 660: int j; ! 661: for( i=0; i<LXTSZ; ++i ){ ! 662: if( ( j = getchar() ) == '`' ) break; ! 663: if( j == '\n' ){ ! 664: uerror( "newline in BCD constant" ); ! 665: break; ! 666: } ! 667: yytext[i] = j; ! 668: } ! 669: yytext[i] = '\0'; ! 670: if( i>6 ) uerror( "BCD constant exceeds 6 characters" ); ! 671: # ifdef gcos ! 672: else strtob( yytext, &lastcon, i ); ! 673: lastcon >>= 6*(6-i); ! 674: # else ! 675: uerror( "gcos BCD constant illegal" ); ! 676: # endif ! 677: yylval.intval = 0; /* not long */ ! 678: return( ICON ); ! 679: } ! 680: ! 681: case A_SL: ! 682: /* / */ ! 683: if( (lxchar=getchar()) != '*' ) goto onechar; ! 684: lxcom(); ! 685: case A_WS: ! 686: continue; ! 687: ! 688: case A_NL: ! 689: ++lineno; ! 690: lxtitle(); ! 691: continue; ! 692: ! 693: case A_NOT: ! 694: /* ! */ ! 695: if( (lxchar=getchar()) != '=' ) goto onechar; ! 696: yylval.intval = NE; ! 697: return( EQUOP ); ! 698: ! 699: case A_MI: ! 700: /* - */ ! 701: if( (lxchar=getchar()) == '-' ){ ! 702: yylval.intval = DECR; ! 703: return( INCOP ); ! 704: } ! 705: if( lxchar != '>' ) goto onechar; ! 706: stwart = FUNNYNAME; ! 707: yylval.intval=STREF; ! 708: return( STROP ); ! 709: ! 710: case A_PL: ! 711: /* + */ ! 712: if( (lxchar=getchar()) != '+' ) goto onechar; ! 713: yylval.intval = INCR; ! 714: return( INCOP ); ! 715: ! 716: case A_AND: ! 717: /* & */ ! 718: if( (lxchar=getchar()) != '&' ) goto onechar; ! 719: return( yylval.intval = ANDAND ); ! 720: ! 721: case A_OR: ! 722: /* | */ ! 723: if( (lxchar=getchar()) != '|' ) goto onechar; ! 724: return( yylval.intval = OROR ); ! 725: ! 726: case A_LT: ! 727: /* < */ ! 728: if( (lxchar=getchar()) == '<' ){ ! 729: yylval.intval = LS; ! 730: return( SHIFTOP ); ! 731: } ! 732: if( lxchar != '=' ) goto onechar; ! 733: yylval.intval = LE; ! 734: return( RELOP ); ! 735: ! 736: case A_GT: ! 737: /* > */ ! 738: if( (lxchar=getchar()) == '>' ){ ! 739: yylval.intval = RS; ! 740: return(SHIFTOP ); ! 741: } ! 742: if( lxchar != '=' ) goto onechar; ! 743: yylval.intval = GE; ! 744: return( RELOP ); ! 745: ! 746: case A_EQ: ! 747: /* = */ ! 748: switch( lxchar = getchar() ){ ! 749: ! 750: case '=': ! 751: yylval.intval = EQ; ! 752: return( EQUOP ); ! 753: ! 754: case '+': ! 755: yylval.intval = ASG PLUS; ! 756: break; ! 757: ! 758: case '-': ! 759: yylval.intval = ASG MINUS; ! 760: ! 761: warn: ! 762: if( lxmask[ (lxchar=getchar())+1] & (LEXLET|LEXDIG|LEXDOT) ){ ! 763: werror( "ambiguous assignment: assignment op taken" ); ! 764: } ! 765: ungetc( lxchar ,stdin); ! 766: break; ! 767: ! 768: case '*': ! 769: yylval.intval = ASG MUL; ! 770: goto warn; ! 771: ! 772: case '/': ! 773: yylval.intval = ASG DIV; ! 774: break; ! 775: ! 776: case '%': ! 777: yylval.intval = ASG MOD; ! 778: break; ! 779: ! 780: case '&': ! 781: yylval.intval = ASG AND; ! 782: break; ! 783: ! 784: case '|': ! 785: yylval.intval = ASG OR; ! 786: break; ! 787: ! 788: case '^': ! 789: yylval.intval = ASG ER; ! 790: break; ! 791: ! 792: case '<': ! 793: if( (lxchar=getchar()) != '<' ){ ! 794: uerror( "=<%c illegal", lxchar ); ! 795: } ! 796: yylval.intval = ASG LS; ! 797: break; ! 798: ! 799: case '>': ! 800: if( (lxchar=getchar()) != '>' ){ ! 801: uerror( "=>%c illegal", lxchar ); ! 802: } ! 803: yylval.intval = ASG RS; ! 804: break; ! 805: ! 806: default: ! 807: goto onechar; ! 808: ! 809: } ! 810: ! 811: return( ASOP ); ! 812: ! 813: default: ! 814: cerror( "yylex error, character %03o (octal)", lxchar ); ! 815: ! 816: } ! 817: ! 818: /* ordinarily, repeat here... */ ! 819: cerror( "out of switch in yylex" ); ! 820: ! 821: } ! 822: ! 823: } ! 824: ! 825: struct lxrdope { ! 826: /* dope for reserved, in alphabetical order */ ! 827: ! 828: char *lxrch; /* name of reserved word */ ! 829: short lxract; /* reserved word action */ ! 830: short lxrval; /* value to be returned */ ! 831: } lxrdope[] = { ! 832: ! 833: "asm", AR_A, 0, ! 834: "auto", AR_CL, AUTO, ! 835: "break", AR_RW, BREAK, ! 836: "char", AR_TY, CHAR, ! 837: "case", AR_RW, CASE, ! 838: "continue", AR_RW, CONTINUE, ! 839: "double", AR_TY, DOUBLE, ! 840: "default", AR_RW, DEFAULT, ! 841: "do", AR_RW, DO, ! 842: "extern", AR_CL, EXTERN, ! 843: "else", AR_RW, ELSE, ! 844: "enum", AR_E, ENUM, ! 845: "for", AR_RW, FOR, ! 846: "float", AR_TY, FLOAT, ! 847: "fortran", AR_CL, FORTRAN, ! 848: "goto", AR_RW, GOTO, ! 849: "if", AR_RW, IF, ! 850: "int", AR_TY, INT, ! 851: "long", AR_TY, LONG, ! 852: "return", AR_RW, RETURN, ! 853: "register", AR_CL, REGISTER, ! 854: "switch", AR_RW, SWITCH, ! 855: "struct", AR_S, 0, ! 856: "sizeof", AR_RW, SIZEOF, ! 857: "short", AR_TY, SHORT, ! 858: "static", AR_CL, STATIC, ! 859: "typedef", AR_CL, TYPEDEF, ! 860: "unsigned", AR_TY, UNSIGNED, ! 861: "union", AR_U, 0, ! 862: "void", AR_TY, UNDEF, /* tymerge adds FTN */ ! 863: "while", AR_RW, WHILE, ! 864: "", 0, 0, /* to stop the search */ ! 865: }; ! 866: ! 867: lxres() { ! 868: /* check to see of yytext is reserved; if so, ! 869: /* do the appropriate action and return */ ! 870: /* otherwise, return -1 */ ! 871: ! 872: register c, ch; ! 873: register struct lxrdope *p; ! 874: ! 875: ch = yytext[0]; ! 876: ! 877: if( !islower(ch) ) return( -1 ); ! 878: ! 879: switch( ch ){ ! 880: ! 881: case 'a': ! 882: c=0; break; ! 883: case 'b': ! 884: c=2; break; ! 885: case 'c': ! 886: c=3; break; ! 887: case 'd': ! 888: c=6; break; ! 889: case 'e': ! 890: c=9; break; ! 891: case 'f': ! 892: c=12; break; ! 893: case 'g': ! 894: c=15; break; ! 895: case 'i': ! 896: c=16; break; ! 897: case 'l': ! 898: c=18; break; ! 899: case 'r': ! 900: c=19; break; ! 901: case 's': ! 902: c=21; break; ! 903: case 't': ! 904: c=26; break; ! 905: case 'u': ! 906: c=27; break; ! 907: case 'v': ! 908: c=29; break; ! 909: case 'w': ! 910: c=30; break; ! 911: ! 912: default: ! 913: return( -1 ); ! 914: } ! 915: ! 916: for( p= lxrdope+c; p->lxrch[0] == ch; ++p ){ ! 917: if( !strcmp( yytext, p->lxrch ) ){ /* match */ ! 918: switch( p->lxract ){ ! 919: ! 920: case AR_TY: ! 921: /* type word */ ! 922: stwart = instruct; ! 923: yylval.nodep = mkty( (TWORD)p->lxrval, 0, p->lxrval ); ! 924: return( TYPE ); ! 925: ! 926: case AR_RW: ! 927: /* ordinary reserved word */ ! 928: return( yylval.intval = p->lxrval ); ! 929: ! 930: case AR_CL: ! 931: /* class word */ ! 932: yylval.intval = p->lxrval; ! 933: return( CLASS ); ! 934: ! 935: case AR_S: ! 936: /* struct */ ! 937: stwart = INSTRUCT|SEENAME|TAGNAME; ! 938: yylval.intval = INSTRUCT; ! 939: return( STRUCT ); ! 940: ! 941: case AR_U: ! 942: /* union */ ! 943: stwart = INUNION|SEENAME|TAGNAME; ! 944: yylval.intval = INUNION; ! 945: return( STRUCT ); ! 946: ! 947: case AR_E: ! 948: /* enums */ ! 949: stwart = SEENAME|TAGNAME; ! 950: return( yylval.intval = ENUM ); ! 951: ! 952: case AR_A: ! 953: /* asm */ ! 954: asm_esc = 1; /* warn the world! */ ! 955: lxget( ' ', LEXWS ); ! 956: if( getchar() != '(' ) goto badasm; ! 957: lxget( ' ', LEXWS ); ! 958: if( getchar() != '"' ) goto badasm; ! 959: # ifndef ONEPASS ! 960: # ifndef LINT ! 961: putchar(')'); ! 962: # endif ! 963: # endif ! 964: while( (c=getchar()) != '"' ){ ! 965: if( c=='\n' || c==EOF ) goto badasm; ! 966: # ifndef LINT ! 967: putchar(c); ! 968: # endif ! 969: } ! 970: lxget( ' ', LEXWS ); ! 971: if( getchar() != ')' ) goto badasm; ! 972: # ifndef LINT ! 973: putchar('\n'); ! 974: # endif ! 975: return( 0 ); ! 976: ! 977: badasm: ! 978: uerror( "bad asm construction" ); ! 979: return( 0 ); ! 980: ! 981: default: ! 982: cerror( "bad AR_?? action" ); ! 983: } ! 984: } ! 985: } ! 986: return( -1 ); ! 987: } ! 988: ! 989: extern int labelno; ! 990: ! 991: lxtitle(){ ! 992: /* called after a newline; set linenumber and file name */ ! 993: ! 994: register c, val; ! 995: register char *cp, *cq; ! 996: ! 997: for(;;){ /* might be several such lines in a row */ ! 998: if( (c=getchar()) != '#' ){ ! 999: if( c != EOF ) ungetc(c,stdin); ! 1000: #ifndef LINT ! 1001: if ( lastloc != PROG) return; ! 1002: cp = ftitle; ! 1003: cq = ititle; ! 1004: while ( *cp ) if (*cp++ != *cq++) return; ! 1005: if ( *cq ) return; ! 1006: psline(); ! 1007: #endif ! 1008: return; ! 1009: } ! 1010: ! 1011: lxget( ' ', LEXWS ); ! 1012: val = 0; ! 1013: for( c=getchar(); isdigit(c); c=getchar() ){ ! 1014: val = val*10+ c - '0'; ! 1015: } ! 1016: if( c == EOF ) ! 1017: continue; ! 1018: ungetc( c, stdin ); ! 1019: lineno = val; ! 1020: lxget( ' ', LEXWS ); ! 1021: if( (c=getchar()) != '\n' && c != EOF ){ ! 1022: for( cp=ftitle; c!=EOF && c!='\n'; c=getchar(),++cp ){ ! 1023: *cp = c; ! 1024: } ! 1025: *cp = '\0'; ! 1026: #ifndef LINT ! 1027: if (ititle[0] == '\0') { ! 1028: cp = ftitle; ! 1029: cq = ititle; ! 1030: while ( *cp ) ! 1031: *cq++ = *cp++; ! 1032: *cq = '\0'; ! 1033: *--cq = '\0'; ! 1034: #ifndef FLEXNAMES ! 1035: for ( cp = ititle+1; *(cp-1); cp += 8 ) { ! 1036: pstab(cp, N_SO); ! 1037: if (gdebug) printf("0,0,LL%d\n", labelno); ! 1038: } ! 1039: #else ! 1040: pstab(ititle+1, N_SO); ! 1041: if (gdebug) printf("0,0,LL%d\n", labelno); ! 1042: #endif ! 1043: ! 1044: *cq = '"'; ! 1045: printf("LL%d:\n", labelno++); ! 1046: } ! 1047: #endif ! 1048: } ! 1049: } ! 1050: } ! 1051: ! 1052: #ifdef FLEXNAMES ! 1053: #define NSAVETAB 4096 ! 1054: char *savetab; ! 1055: int saveleft; ! 1056: ! 1057: char * ! 1058: savestr(cp) ! 1059: register char *cp; ! 1060: { ! 1061: register int len; ! 1062: ! 1063: len = strlen(cp) + 1; ! 1064: if (len > saveleft) { ! 1065: saveleft = NSAVETAB; ! 1066: if (len > saveleft) ! 1067: saveleft = len; ! 1068: savetab = (char *)malloc(saveleft); ! 1069: if (savetab == 0) ! 1070: cerror("Ran out of memory (savestr)"); ! 1071: } ! 1072: strncpy(savetab, cp, len); ! 1073: cp = savetab; ! 1074: savetab += len; ! 1075: saveleft -= len; ! 1076: return (cp); ! 1077: } ! 1078: ! 1079: /* ! 1080: * The definition for the segmented hash tables. ! 1081: */ ! 1082: #define MAXHASH 20 ! 1083: #define HASHINC 1013 ! 1084: struct ht { ! 1085: char **ht_low; ! 1086: char **ht_high; ! 1087: int ht_used; ! 1088: } htab[MAXHASH]; ! 1089: ! 1090: char * ! 1091: hash(s) ! 1092: char *s; ! 1093: { ! 1094: register char **h; ! 1095: register i; ! 1096: register char *cp; ! 1097: struct ht *htp; ! 1098: int sh; ! 1099: ! 1100: /* ! 1101: * The hash function is a modular hash of ! 1102: * the sum of the characters with the sum ! 1103: * doubled before each successive character ! 1104: * is added. ! 1105: */ ! 1106: cp = s; ! 1107: i = 0; ! 1108: while (*cp) ! 1109: i = i*2 + *cp++; ! 1110: sh = (i&077777) % HASHINC; ! 1111: cp = s; ! 1112: /* ! 1113: * There are as many as MAXHASH active ! 1114: * hash tables at any given point in time. ! 1115: * The search starts with the first table ! 1116: * and continues through the active tables ! 1117: * as necessary. ! 1118: */ ! 1119: for (htp = htab; htp < &htab[MAXHASH]; htp++) { ! 1120: if (htp->ht_low == 0) { ! 1121: register char **hp = ! 1122: (char **) calloc(sizeof (char **), HASHINC); ! 1123: if (hp == 0) ! 1124: cerror("ran out of memory (hash)"); ! 1125: htp->ht_low = hp; ! 1126: htp->ht_high = htp->ht_low + HASHINC; ! 1127: } ! 1128: h = htp->ht_low + sh; ! 1129: /* ! 1130: * quadratic rehash increment ! 1131: * starts at 1 and incremented ! 1132: * by two each rehash. ! 1133: */ ! 1134: i = 1; ! 1135: do { ! 1136: if (*h == 0) { ! 1137: if (htp->ht_used > (HASHINC * 3)/4) ! 1138: break; ! 1139: htp->ht_used++; ! 1140: *h = savestr(cp); ! 1141: return (*h); ! 1142: } ! 1143: if (**h == *cp && strcmp(*h, cp) == 0) ! 1144: return (*h); ! 1145: h += i; ! 1146: i += 2; ! 1147: if (h >= htp->ht_high) ! 1148: h -= HASHINC; ! 1149: } while (i < HASHINC); ! 1150: } ! 1151: cerror("ran out of hash tables"); ! 1152: } ! 1153: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.