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