![[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 / mip|
Return to scan.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / lib / mip |
1.1 ! root 1: #ifndef lint ! 2: static char *sccsid ="@(#)scan.c 2.15 (Berkeley) 12/10/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: (void) 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: (void) 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: #ifdef gcos ! 239: '`', A_BCD, 0, 0, /* GCOS BCD constant */ ! 240: #endif ! 241: '(', A_1C, LP, 0, ! 242: ')', A_1C, RP, 0, ! 243: '{', A_1C, LC, 0, ! 244: '}', A_1C, RC, 0, ! 245: '[', A_1C, LB, 0, ! 246: ']', A_1C, RB, 0, ! 247: '*', A_1C, MUL, MUL, ! 248: '?', A_1C, QUEST, 0, ! 249: ':', A_1C, COLON, 0, ! 250: '+', A_PL, PLUS, PLUS, ! 251: '-', A_MI, MINUS, MINUS, ! 252: '/', A_SL, DIVOP, DIV, ! 253: '%', A_1C, DIVOP, MOD, ! 254: '&', A_AND, AND, AND, ! 255: '|', A_OR, OR, OR, ! 256: '^', A_1C, ER, ER, ! 257: '!', A_NOT, UNOP, NOT, ! 258: '~', A_1C, UNOP, COMPL, ! 259: ',', A_1C, CM, CM, ! 260: ';', A_1C, SM, 0, ! 261: '.', A_DOT, STROP, DOT, ! 262: '<', A_LT, RELOP, LT, ! 263: '>', A_GT, RELOP, GT, ! 264: '=', A_EQ, ASSIGN, ASSIGN, ! 265: -1, A_1C, 0, 0, ! 266: }; ! 267: ! 268: struct lxdope *lxcp[CSSZ+1]; ! 269: ! 270: lxinit(){ ! 271: register struct lxdope *p; ! 272: register i; ! 273: register char *cp; ! 274: /* set up character classes */ ! 275: ! 276: lxenter( "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_", LEXLET ); ! 277: #ifdef VMS ! 278: lxmask['$'+1] |= LEXLET; ! 279: #endif ! 280: lxenter( "0123456789", LEXDIG ); ! 281: lxenter( "0123456789abcdefABCDEF", LEXHEX ); ! 282: lxenter( " \t\r\b\f\v", LEXWS ); ! 283: lxenter( "01234567", LEXOCT ); ! 284: lxmask['.'+1] |= LEXDOT; ! 285: ! 286: /* make lxcp point to appropriate lxdope entry for each character */ ! 287: ! 288: /* initialize error entries */ ! 289: ! 290: for( i= 0; i<=CSSZ; ++i ) lxcp[i] = lxdope; ! 291: ! 292: /* make unique entries */ ! 293: ! 294: for( p=lxdope; ; ++p ) { ! 295: lxcp[p->lxch+1] = p; ! 296: if( p->lxch < 0 ) break; ! 297: } ! 298: ! 299: /* handle letters, digits, and whitespace */ ! 300: /* by convention, first, second, and third places */ ! 301: ! 302: cp = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; ! 303: while( *cp ) lxcp[*cp++ + 1] = &lxdope[1]; ! 304: #ifdef VMS ! 305: lxcp['$'+1] = &lxdope[1]; ! 306: #endif ! 307: cp = "123456789"; ! 308: while( *cp ) lxcp[*cp++ + 1] = &lxdope[2]; ! 309: cp = "\t\b\r\f\v"; ! 310: while( *cp ) lxcp[*cp++ + 1] = &lxdope[3]; ! 311: ! 312: /* first line might have title */ ! 313: lxtitle(); ! 314: ! 315: } ! 316: ! 317: int lxmatch = 0; /* character to be matched in char or string constant */ ! 318: ! 319: lxstr(ct){ ! 320: /* match a string or character constant, up to lxmatch */ ! 321: ! 322: register c; ! 323: register val; ! 324: register i; ! 325: ! 326: i=0; ! 327: while( (c=getchar()) != lxmatch ){ ! 328: switch( c ) { ! 329: ! 330: case EOF: ! 331: uerror( "unexpected EOF" ); ! 332: break; ! 333: ! 334: case '\n': ! 335: uerror( "newline in string or char constant" ); ! 336: ++lineno; ! 337: break; ! 338: ! 339: case '\\': ! 340: switch( c = getchar() ){ ! 341: ! 342: case '\n': ! 343: ++lineno; ! 344: continue; ! 345: ! 346: default: ! 347: #ifdef LINT ! 348: if( hflag ) ! 349: uerror( "superfluous backslash in %s constant", lxmatch == '\'' ? "char" : "string" ); ! 350: /*FALLTHROUGH*/ ! 351: #endif ! 352: case '\\': ! 353: case '\"': ! 354: case '\'': ! 355: val = c; ! 356: goto mkcc; ! 357: ! 358: case 'n': ! 359: val = '\n'; ! 360: goto mkcc; ! 361: ! 362: case 'r': ! 363: val = '\r'; ! 364: goto mkcc; ! 365: ! 366: case 'b': ! 367: val = '\b'; ! 368: goto mkcc; ! 369: ! 370: case 't': ! 371: val = '\t'; ! 372: goto mkcc; ! 373: ! 374: case 'f': ! 375: val = '\f'; ! 376: goto mkcc; ! 377: ! 378: case 'v': ! 379: val = '\v'; ! 380: goto mkcc; ! 381: ! 382: case '0': ! 383: case '1': ! 384: case '2': ! 385: case '3': ! 386: case '4': ! 387: case '5': ! 388: case '6': ! 389: case '7': ! 390: val = c-'0'; ! 391: c=getchar(); /* try for 2 */ ! 392: if( lxmask[c+1] & LEXOCT ){ ! 393: val = (val<<3) | (c-'0'); ! 394: c = getchar(); /* try for 3 */ ! 395: if( lxmask[c+1] & LEXOCT ){ ! 396: val = (val<<3) | (c-'0'); ! 397: } ! 398: else ungetc( c ,stdin); ! 399: } ! 400: else ungetc( c ,stdin); ! 401: ! 402: goto mkcc1; ! 403: ! 404: } ! 405: default: ! 406: val =c; ! 407: mkcc: ! 408: val = CCTRANS(val); ! 409: mkcc1: ! 410: if( lxmatch == '\'' ){ ! 411: val = CHARCAST(val); /* it is, after all, a "character" constant */ ! 412: makecc( val, i ); ! 413: } ! 414: else { /* stash the byte into the string */ ! 415: if( strflg ) { ! 416: if( ct==0 || i<ct ) putbyte( val ); ! 417: else if( i == ct ) werror( "non-null byte ignored in string initializer" ); ! 418: } ! 419: else bycode( val, i ); ! 420: } ! 421: ++i; ! 422: continue; ! 423: } ! 424: break; ! 425: } ! 426: /* end of string or char constant */ ! 427: ! 428: if( lxmatch == '"' ){ ! 429: if( strflg ){ /* end the string */ ! 430: if( ct==0 || i<ct ) putbyte( 0 ); /* the null at the end */ ! 431: } ! 432: else { /* the initializer gets a null byte */ ! 433: bycode( 0, i++ ); ! 434: bycode( -1, i ); ! 435: dimtab[curdim] = i; /* in case of later sizeof ... */ ! 436: } ! 437: } ! 438: else { /* end the character constant */ ! 439: if( i == 0 ) uerror( "empty character constant" ); ! 440: if( i>(SZINT/SZCHAR) || ( (pflag||hflag)&&i>1) ) ! 441: uerror( "too many characters in character constant" ); ! 442: } ! 443: lxmatch = 0; /* handshake with yylex() */ ! 444: } ! 445: ! 446: lxcom(){ ! 447: register c; ! 448: /* saw a /*: process a comment */ ! 449: ! 450: for(;;){ ! 451: ! 452: switch( c = getchar() ){ ! 453: ! 454: case EOF: ! 455: uerror( "unexpected EOF" ); ! 456: return; ! 457: ! 458: case '\n': ! 459: ++lineno; ! 460: ! 461: default: ! 462: continue; ! 463: ! 464: case '*': ! 465: if( (c = getchar()) == '/' ) return; ! 466: else ungetc( c ,stdin); ! 467: continue; ! 468: ! 469: # ifdef LINT ! 470: case 'V': ! 471: lxget( c, LEXLET|LEXDIG ); ! 472: { ! 473: extern int vaflag; ! 474: int i; ! 475: i = yytext[7]?yytext[7]-'0':0; ! 476: yytext[7] = '\0'; ! 477: if( strcmp( yytext, "VARARGS" ) ) continue; ! 478: vaflag = i; ! 479: continue; ! 480: } ! 481: case 'L': ! 482: lxget( c, LEXLET ); ! 483: if( strcmp( yytext, "LINTLIBRARY" ) ) continue; ! 484: { ! 485: extern int libflag; ! 486: libflag = 1; ! 487: } ! 488: continue; ! 489: ! 490: case 'A': ! 491: lxget( c, LEXLET ); ! 492: if( strcmp( yytext, "ARGSUSED" ) ) continue; ! 493: { ! 494: extern int argflag, vflag; ! 495: argflag = 1; ! 496: vflag = 0; ! 497: } ! 498: continue; ! 499: ! 500: case 'N': ! 501: lxget( c, LEXLET ); ! 502: if( strcmp( yytext, "NOTREACHED" ) ) continue; ! 503: reached = 0; ! 504: continue; ! 505: # endif ! 506: } ! 507: } ! 508: } ! 509: ! 510: yylex(){ ! 511: double atof(); ! 512: ! 513: if (lxmatch != 0) { ! 514: /* recover from a syntax error that consumes a STRING token */ ! 515: strflg = 1; ! 516: lxstr(0); ! 517: } ! 518: for(;;){ ! 519: ! 520: register lxchar; ! 521: register struct lxdope *p; ! 522: register struct symtab *sp; ! 523: int id; ! 524: char *s; ! 525: static char sc[5]; ! 526: ! 527: switch( (p=lxcp[(lxchar=getchar())+1])->lxact ){ ! 528: ! 529: onechar: ! 530: ungetc( lxchar ,stdin); ! 531: ! 532: case A_1C: ! 533: /* eat up a single character, and return an opcode */ ! 534: ! 535: yylval.intval = p->lxval; ! 536: return( p->lxtok ); ! 537: ! 538: case A_ERR: ! 539: switch( lxchar ){ ! 540: case '\\': s = "\\\\"; break; ! 541: case '\0': s = "\\0"; break; ! 542: default: ! 543: if( isgraph( lxchar ) ){ ! 544: sc[0] = lxchar; ! 545: sc[1] = '\0'; ! 546: } ! 547: else ! 548: sprintf( sc, "\\%03.3o", (unsigned char) lxchar ); ! 549: s = sc; ! 550: break; ! 551: } ! 552: uerror( "illegal character: '%s'", s ); ! 553: continue; /* ignore it and see if we find more */ ! 554: ! 555: case A_LET: ! 556: /* collect an identifier, check for reserved word, and return */ ! 557: lxget( lxchar, LEXLET|LEXDIG ); ! 558: if( (lxchar=lxres()) > 0 ) return( lxchar ); /* reserved word */ ! 559: if( lxchar== 0 ) continue; ! 560: #ifdef FLEXNAMES ! 561: id = lookup( hash(yytext), ! 562: #else ! 563: id = lookup( yytext, ! 564: #endif ! 565: /* tag name for struct/union/enum */ ! 566: (stwart&TAGNAME)? STAG: ! 567: /* member name for struct/union */ ! 568: (stwart&(INSTRUCT|INUNION|FUNNYNAME))?SMOS:0 ); ! 569: sp = &stab[id]; ! 570: if( sp->sclass == TYPEDEF && !stwart ){ ! 571: stwart = instruct; ! 572: yylval.nodep = mkty( sp->stype, sp->dimoff, sp->sizoff ); ! 573: return( TYPE ); ! 574: } ! 575: stwart = (stwart&SEENAME) ? instruct : 0; ! 576: yylval.intval = id; ! 577: return( NAME ); ! 578: ! 579: case A_DIG: ! 580: /* collect a digit string, then look at last one... */ ! 581: lastcon = 0; ! 582: lxget( lxchar, LEXDIG ); ! 583: switch( lxchar=getchar() ){ ! 584: ! 585: case 'x': ! 586: case 'X': ! 587: if( yytext[0] != '0' && !yytext[1] ) uerror( "illegal hex constant" ); ! 588: lxmore( lxchar, LEXHEX ); ! 589: /* convert the value */ ! 590: { ! 591: register char *cp; ! 592: for( cp = yytext+2; *cp; ++cp ){ ! 593: /* this code won't work for all wild character sets, ! 594: but seems ok for ascii and ebcdic */ ! 595: lastcon <<= 4; ! 596: if( isdigit( *cp ) ) lastcon += *cp-'0'; ! 597: else if( isupper( *cp ) ) lastcon += *cp - 'A'+ 10; ! 598: else lastcon += *cp - 'a'+ 10; ! 599: } ! 600: } ! 601: ! 602: hexlong: ! 603: /* criterion for longness for hex and octal constants is that it ! 604: fit within 0177777 */ ! 605: if( lastcon & ~0177777L ) yylval.intval = 1; ! 606: else yylval.intval = 0; ! 607: ! 608: goto islong; ! 609: ! 610: case '.': ! 611: lxmore( lxchar, LEXDIG ); ! 612: ! 613: getfp: ! 614: if( (lxchar=getchar()) == 'e' || lxchar == 'E' ){ /* exponent */ ! 615: ! 616: case 'e': ! 617: case 'E': ! 618: if( (lxchar=getchar()) == '+' || lxchar == '-' ){ ! 619: *lxgcp++ = 'e'; ! 620: } ! 621: else { ! 622: ungetc(lxchar,stdin); ! 623: lxchar = 'e'; ! 624: } ! 625: lxmore( lxchar, LEXDIG ); ! 626: /* now have the whole thing... */ ! 627: } ! 628: else { /* no exponent */ ! 629: ungetc( lxchar ,stdin); ! 630: } ! 631: dcon = atof( yytext ); ! 632: if( (lxchar = getchar()) == 'F' || lxchar == 'f' ){ ! 633: fcon = dcon; ! 634: return( FCON ); ! 635: } ! 636: else ungetc( lxchar ,stdin); ! 637: return( DCON ); ! 638: ! 639: default: ! 640: ungetc( lxchar ,stdin); ! 641: if( yytext[0] == '0' ){ ! 642: /* convert in octal */ ! 643: register char *cp; ! 644: for( cp = yytext+1; *cp; ++cp ){ ! 645: lastcon <<= 3; ! 646: lastcon += *cp - '0'; ! 647: } ! 648: goto hexlong; ! 649: } ! 650: else { ! 651: /* convert in decimal */ ! 652: register char *cp; ! 653: for( cp = yytext; *cp; ++cp ){ ! 654: lastcon = lastcon * 10 + *cp - '0'; ! 655: } ! 656: } ! 657: ! 658: /* decide if it is long or not (decimal case) */ ! 659: ! 660: /* if it is positive and fits in 15 bits, or negative and ! 661: and fits in 15 bits plus an extended sign, it is int; otherwise long */ ! 662: /* if there is an l or L following, all bets are off... */ ! 663: ! 664: { CONSZ v; ! 665: v = lastcon & ~077777L; ! 666: if( v == 0 || v == ~077777L ) yylval.intval = 0; ! 667: else yylval.intval = 1; ! 668: } ! 669: ! 670: islong: ! 671: /* finally, look for trailing L or l */ ! 672: if( (lxchar = getchar()) == 'L' || lxchar == 'l' ) yylval.intval = 1; ! 673: else ungetc( lxchar ,stdin); ! 674: return( ICON ); ! 675: } ! 676: ! 677: case A_DOT: ! 678: /* look for a dot: if followed by a digit, floating point */ ! 679: lxchar = getchar(); ! 680: if( lxmask[lxchar+1] & LEXDIG ){ ! 681: ungetc(lxchar,stdin); ! 682: lxget( '.', LEXDIG ); ! 683: goto getfp; ! 684: } ! 685: stwart = FUNNYNAME; ! 686: goto onechar; ! 687: ! 688: case A_STR: ! 689: /* string constant */ ! 690: lxmatch = '"'; ! 691: return( STRING ); ! 692: ! 693: case A_CC: ! 694: /* character constant */ ! 695: lxmatch = '\''; ! 696: lastcon = 0; ! 697: lxstr(0); ! 698: yylval.intval = 0; ! 699: return( ICON ); ! 700: ! 701: #ifdef gcos ! 702: case A_BCD: ! 703: { ! 704: register i; ! 705: int j; ! 706: for( i=0; i<LXTSZ; ++i ){ ! 707: if( ( j = getchar() ) == '`' ) break; ! 708: if( j == '\n' ){ ! 709: uerror( "newline in BCD constant" ); ! 710: break; ! 711: } ! 712: yytext[i] = j; ! 713: } ! 714: yytext[i] = '\0'; ! 715: if( i>6 ) uerror( "BCD constant exceeds 6 characters" ); ! 716: # ifndef unix ! 717: else strtob( yytext, &lastcon, i ); ! 718: lastcon >>= 6*(6-i); ! 719: # else ! 720: uerror( "gcos BCD constant illegal" ); ! 721: # endif ! 722: yylval.intval = 0; /* not long */ ! 723: return( ICON ); ! 724: } ! 725: #endif ! 726: ! 727: case A_SL: ! 728: /* / */ ! 729: if( (lxchar=getchar()) != '*' ) goto onechar; ! 730: lxcom(); ! 731: case A_WS: ! 732: continue; ! 733: ! 734: case A_NL: ! 735: ++lineno; ! 736: lxtitle(); ! 737: continue; ! 738: ! 739: case A_NOT: ! 740: /* ! */ ! 741: if( (lxchar=getchar()) != '=' ) goto onechar; ! 742: yylval.intval = NE; ! 743: return( EQUOP ); ! 744: ! 745: case A_MI: ! 746: /* - */ ! 747: if( (lxchar=getchar()) == '-' ){ ! 748: yylval.intval = DECR; ! 749: return( INCOP ); ! 750: } ! 751: if( lxchar != '>' ) goto onechar; ! 752: stwart = FUNNYNAME; ! 753: yylval.intval=STREF; ! 754: return( STROP ); ! 755: ! 756: case A_PL: ! 757: /* + */ ! 758: if( (lxchar=getchar()) != '+' ) goto onechar; ! 759: yylval.intval = INCR; ! 760: return( INCOP ); ! 761: ! 762: case A_AND: ! 763: /* & */ ! 764: if( (lxchar=getchar()) != '&' ) goto onechar; ! 765: return( yylval.intval = ANDAND ); ! 766: ! 767: case A_OR: ! 768: /* | */ ! 769: if( (lxchar=getchar()) != '|' ) goto onechar; ! 770: return( yylval.intval = OROR ); ! 771: ! 772: case A_LT: ! 773: /* < */ ! 774: if( (lxchar=getchar()) == '<' ){ ! 775: yylval.intval = LS; ! 776: return( SHIFTOP ); ! 777: } ! 778: if( lxchar != '=' ) goto onechar; ! 779: yylval.intval = LE; ! 780: return( RELOP ); ! 781: ! 782: case A_GT: ! 783: /* > */ ! 784: if( (lxchar=getchar()) == '>' ){ ! 785: yylval.intval = RS; ! 786: return(SHIFTOP ); ! 787: } ! 788: if( lxchar != '=' ) goto onechar; ! 789: yylval.intval = GE; ! 790: return( RELOP ); ! 791: ! 792: case A_EQ: ! 793: /* = */ ! 794: switch( lxchar = getchar() ){ ! 795: ! 796: case '=': ! 797: yylval.intval = EQ; ! 798: return( EQUOP ); ! 799: ! 800: #ifdef old_assignment_ops ! 801: case '+': ! 802: yylval.intval = ASG PLUS; ! 803: break; ! 804: ! 805: case '-': ! 806: yylval.intval = ASG MINUS; ! 807: ! 808: warn: ! 809: if( lxmask[ (lxchar=getchar())+1] & (LEXLET|LEXDIG|LEXDOT) ){ ! 810: werror( "ambiguous assignment: assignment op taken" ); ! 811: } ! 812: ungetc( lxchar ,stdin); ! 813: break; ! 814: ! 815: case '*': ! 816: yylval.intval = ASG MUL; ! 817: goto warn; ! 818: ! 819: case '/': ! 820: yylval.intval = ASG DIV; ! 821: break; ! 822: ! 823: case '%': ! 824: yylval.intval = ASG MOD; ! 825: break; ! 826: ! 827: case '&': ! 828: yylval.intval = ASG AND; ! 829: break; ! 830: ! 831: case '|': ! 832: yylval.intval = ASG OR; ! 833: break; ! 834: ! 835: case '^': ! 836: yylval.intval = ASG ER; ! 837: break; ! 838: ! 839: case '<': ! 840: if( (lxchar=getchar()) != '<' ){ ! 841: uerror( "=<%c illegal", lxchar ); ! 842: } ! 843: yylval.intval = ASG LS; ! 844: break; ! 845: ! 846: case '>': ! 847: if( (lxchar=getchar()) != '>' ){ ! 848: uerror( "=>%c illegal", lxchar ); ! 849: } ! 850: yylval.intval = ASG RS; ! 851: break; ! 852: #endif old_assignment_ops ! 853: ! 854: default: ! 855: goto onechar; ! 856: ! 857: } ! 858: ! 859: #ifdef old_assignment_ops /* defeat 'unreachable code' warning */ ! 860: return( ASOP ); ! 861: #endif old_assignment_ops ! 862: ! 863: default: ! 864: cerror( "yylex error, character %03o (octal)", lxchar ); ! 865: ! 866: } ! 867: ! 868: /* ordinarily, repeat here... */ ! 869: cerror( "out of switch in yylex" ); ! 870: ! 871: } ! 872: ! 873: } ! 874: ! 875: struct lxrdope { ! 876: /* dope for reserved, in alphabetical order */ ! 877: ! 878: char *lxrch; /* name of reserved word */ ! 879: short lxract; /* reserved word action */ ! 880: short lxrval; /* value to be returned */ ! 881: } lxrdope[] = { ! 882: ! 883: "asm", AR_A, 0, ! 884: "auto", AR_CL, AUTO, ! 885: "break", AR_RW, BREAK, ! 886: "char", AR_TY, CHAR, ! 887: "case", AR_RW, CASE, ! 888: "continue", AR_RW, CONTINUE, ! 889: "double", AR_TY, DOUBLE, ! 890: "default", AR_RW, DEFAULT, ! 891: "do", AR_RW, DO, ! 892: "extern", AR_CL, EXTERN, ! 893: "else", AR_RW, ELSE, ! 894: "enum", AR_E, ENUM, ! 895: "for", AR_RW, FOR, ! 896: "float", AR_TY, FLOAT, ! 897: "fortran", AR_CL, FORTRAN, ! 898: "goto", AR_RW, GOTO, ! 899: "if", AR_RW, IF, ! 900: "int", AR_TY, INT, ! 901: "long", AR_TY, LONG, ! 902: "return", AR_RW, RETURN, ! 903: "register", AR_CL, REGISTER, ! 904: "switch", AR_RW, SWITCH, ! 905: "struct", AR_S, 0, ! 906: "sizeof", AR_RW, SIZEOF, ! 907: "short", AR_TY, SHORT, ! 908: "static", AR_CL, STATIC, ! 909: "typedef", AR_CL, TYPEDEF, ! 910: "unsigned", AR_TY, UNSIGNED, ! 911: "union", AR_U, 0, ! 912: "void", AR_TY, UNDEF, /* tymerge adds FTN */ ! 913: "while", AR_RW, WHILE, ! 914: "", 0, 0, /* to stop the search */ ! 915: }; ! 916: ! 917: lxres() { ! 918: /* check to see of yytext is reserved; if so, ! 919: /* do the appropriate action and return */ ! 920: /* otherwise, return -1 */ ! 921: ! 922: register c, ch; ! 923: register struct lxrdope *p; ! 924: ! 925: ch = yytext[0]; ! 926: ! 927: if( !islower(ch) ) return( -1 ); ! 928: ! 929: switch( ch ){ ! 930: ! 931: case 'a': ! 932: c=0; break; ! 933: case 'b': ! 934: c=2; break; ! 935: case 'c': ! 936: c=3; break; ! 937: case 'd': ! 938: c=6; break; ! 939: case 'e': ! 940: c=9; break; ! 941: case 'f': ! 942: c=12; break; ! 943: case 'g': ! 944: c=15; break; ! 945: case 'i': ! 946: c=16; break; ! 947: case 'l': ! 948: c=18; break; ! 949: case 'r': ! 950: c=19; break; ! 951: case 's': ! 952: c=21; break; ! 953: case 't': ! 954: c=26; break; ! 955: case 'u': ! 956: c=27; break; ! 957: case 'v': ! 958: c=29; break; ! 959: case 'w': ! 960: c=30; break; ! 961: ! 962: default: ! 963: return( -1 ); ! 964: } ! 965: ! 966: for( p= lxrdope+c; p->lxrch[0] == ch; ++p ){ ! 967: if( !strcmp( yytext, p->lxrch ) ){ /* match */ ! 968: switch( p->lxract ){ ! 969: ! 970: case AR_TY: ! 971: /* type word */ ! 972: stwart = instruct; ! 973: yylval.nodep = mkty( (TWORD)p->lxrval, 0, p->lxrval ); ! 974: return( TYPE ); ! 975: ! 976: case AR_RW: ! 977: /* ordinary reserved word */ ! 978: return( yylval.intval = p->lxrval ); ! 979: ! 980: case AR_CL: ! 981: /* class word */ ! 982: yylval.intval = p->lxrval; ! 983: return( CLASS ); ! 984: ! 985: case AR_S: ! 986: /* struct */ ! 987: stwart = INSTRUCT|SEENAME|TAGNAME; ! 988: yylval.intval = INSTRUCT; ! 989: return( STRUCT ); ! 990: ! 991: case AR_U: ! 992: /* union */ ! 993: stwart = INUNION|SEENAME|TAGNAME; ! 994: yylval.intval = INUNION; ! 995: return( STRUCT ); ! 996: ! 997: case AR_E: ! 998: /* enums */ ! 999: stwart = SEENAME|TAGNAME; ! 1000: return( yylval.intval = ENUM ); ! 1001: ! 1002: case AR_A: ! 1003: /* asm */ ! 1004: asm_esc = 1; /* warn the world! */ ! 1005: lxget( ' ', LEXWS ); ! 1006: if( getchar() != '(' ) goto badasm; ! 1007: lxget( ' ', LEXWS ); ! 1008: if( getchar() != '"' ) goto badasm; ! 1009: # ifndef ONEPASS ! 1010: # ifndef LINT ! 1011: putchar(')'); ! 1012: # endif ! 1013: # endif ! 1014: while( (c=getchar()) != '"' ){ ! 1015: if( c=='\n' || c==EOF ) goto badasm; ! 1016: # ifndef LINT ! 1017: putchar(c); ! 1018: # endif ! 1019: } ! 1020: lxget( ' ', LEXWS ); ! 1021: if( getchar() != ')' ) goto badasm; ! 1022: # ifndef LINT ! 1023: putchar('\n'); ! 1024: # endif ! 1025: return( 0 ); ! 1026: ! 1027: badasm: ! 1028: uerror( "bad asm construction" ); ! 1029: return( 0 ); ! 1030: ! 1031: default: ! 1032: cerror( "bad AR_?? action" ); ! 1033: } ! 1034: } ! 1035: } ! 1036: return( -1 ); ! 1037: } ! 1038: ! 1039: extern int labelno; ! 1040: ! 1041: lxtitle(){ ! 1042: /* called after a newline; set linenumber and file name */ ! 1043: ! 1044: register c, val; ! 1045: register char *cp, *cq; ! 1046: ! 1047: for(;;){ /* might be several such lines in a row */ ! 1048: if( (c=getchar()) != '#' ){ ! 1049: if( c != EOF ) ungetc(c,stdin); ! 1050: #ifndef LINT ! 1051: if ( lastloc != PROG) return; ! 1052: cp = ftitle; ! 1053: cq = ititle; ! 1054: while ( *cp ) if (*cp++ != *cq++) return; ! 1055: if ( *cq ) return; ! 1056: if( nerrors == 0 ) psline(); ! 1057: #endif ! 1058: return; ! 1059: } ! 1060: ! 1061: lxget( ' ', LEXWS ); ! 1062: c = getchar(); ! 1063: if( c == 'i' ){ ! 1064: /* #ident -- currently a no-op */ ! 1065: lxget( c, LEXLET ); ! 1066: if( strcmp( yytext, "ident" ) ) ! 1067: werror( "%s: undefined control", yytext ); ! 1068: while( (c = getchar()) != '\n' && c != EOF ) ! 1069: ; ! 1070: continue; ! 1071: } ! 1072: if( c == 'p' ){ ! 1073: /* #pragma -- special instructions */ ! 1074: lxget( c, LEXLET ); ! 1075: if( strcmp( yytext, "pragma" ) ) { ! 1076: werror( "%s: undefined control", yytext ); ! 1077: while( (c = getchar()) != '\n' && c != EOF ) ! 1078: ; ! 1079: continue; ! 1080: } ! 1081: lxget( ' ' , LEXWS ); ! 1082: switch( c = getchar() ){ ! 1083: # ifdef LINT ! 1084: case 'V': ! 1085: lxget( c, LEXLET|LEXDIG ); ! 1086: { ! 1087: extern int vaflag; ! 1088: int i; ! 1089: i = yytext[7]?yytext[7]-'0':0; ! 1090: yytext[7] = '\0'; ! 1091: if( strcmp( yytext, "VARARGS" ) ) break; ! 1092: vaflag = i; ! 1093: break; ! 1094: } ! 1095: case 'L': ! 1096: lxget( c, LEXLET ); ! 1097: if( strcmp( yytext, "LINTLIBRARY" ) ) break; ! 1098: { ! 1099: extern int libflag; ! 1100: libflag = 1; ! 1101: } ! 1102: break; ! 1103: ! 1104: case 'A': ! 1105: lxget( c, LEXLET ); ! 1106: if( strcmp( yytext, "ARGSUSED" ) ) break; ! 1107: { ! 1108: extern int argflag, vflag; ! 1109: argflag = 1; ! 1110: vflag = 0; ! 1111: } ! 1112: break; ! 1113: ! 1114: case 'N': ! 1115: lxget( c, LEXLET ); ! 1116: if( strcmp( yytext, "NOTREACHED" ) ) break; ! 1117: reached = 0; ! 1118: break; ! 1119: #endif ! 1120: ! 1121: case '\n': ! 1122: case EOF: ! 1123: continue; ! 1124: } ! 1125: while( (c = getchar()) != '\n' && c != EOF ) ! 1126: ; ! 1127: continue; ! 1128: } ! 1129: if( c == 'l' ){ ! 1130: /* #line -- just like # */ ! 1131: lxget( c, LEXLET ); ! 1132: if( strcmp( yytext, "line" ) ){ ! 1133: werror( "%s: undefined control", yytext ); ! 1134: while( (c = getchar()) != '\n' && c != EOF ) ! 1135: ; ! 1136: continue; ! 1137: } ! 1138: lxget( ' ', LEXWS ); ! 1139: c = getchar(); ! 1140: } ! 1141: if( !isdigit(c) ){ ! 1142: if( isalpha(c) ){ ! 1143: lxget( c, LEXLET ); ! 1144: werror( "%s: undefined control", yytext ); ! 1145: } ! 1146: while( c != '\n' && c != EOF ) ! 1147: c = getchar(); ! 1148: continue; ! 1149: } ! 1150: ! 1151: val = 0; ! 1152: do { ! 1153: val = val*10+ c - '0'; ! 1154: } ! 1155: while( isdigit( c = getchar() ) ); ! 1156: ! 1157: if( c == EOF ) ! 1158: continue; ! 1159: ungetc( c, stdin ); ! 1160: lineno = val; ! 1161: lxget( ' ', LEXWS ); ! 1162: if( (c=getchar()) != '\n' && c != EOF ){ ! 1163: for( cp=ftitle; c!=EOF && c!='\n'; c=getchar(),++cp ){ ! 1164: *cp = c; ! 1165: } ! 1166: *cp = '\0'; ! 1167: #ifndef LINT ! 1168: if (ititle[0] == '\0') { ! 1169: cp = ftitle; ! 1170: cq = ititle; ! 1171: while ( *cp ) ! 1172: *cq++ = *cp++; ! 1173: *cq = '\0'; ! 1174: *--cq = '\0'; ! 1175: #ifndef FLEXNAMES ! 1176: for ( cp = ititle+1; *(cp-1); cp += 8 ) { ! 1177: pstab(cp, N_SO); ! 1178: if (gdebug) printf("0,0,LL%d\n", labelno); ! 1179: } ! 1180: #else ! 1181: pstab(ititle+1, N_SO); ! 1182: if (gdebug) printf("0,0,LL%d\n", labelno); ! 1183: #endif ! 1184: ! 1185: *cq = '"'; ! 1186: printf("LL%d:\n", labelno++); ! 1187: } ! 1188: #endif ! 1189: } ! 1190: } ! 1191: } ! 1192: ! 1193: #ifdef FLEXNAMES ! 1194: #define NSAVETAB 4096 ! 1195: char *savetab; ! 1196: unsigned saveleft; ! 1197: char *malloc(); ! 1198: char *calloc(); ! 1199: char *strncpy(); ! 1200: ! 1201: char * ! 1202: savestr(cp) ! 1203: register char *cp; ! 1204: { ! 1205: register int len; ! 1206: ! 1207: len = strlen(cp) + 1; ! 1208: if (len > saveleft) { ! 1209: saveleft = NSAVETAB; ! 1210: if (len > saveleft) ! 1211: saveleft = len; ! 1212: savetab = malloc(saveleft); ! 1213: if (savetab == 0) ! 1214: cerror("Ran out of memory (savestr)"); ! 1215: } ! 1216: (void) strncpy(savetab, cp, len); ! 1217: cp = savetab; ! 1218: savetab += len; ! 1219: saveleft -= len; ! 1220: return (cp); ! 1221: } ! 1222: ! 1223: /* ! 1224: * The definition for the segmented hash tables. ! 1225: */ ! 1226: #define MAXHASH 20 ! 1227: #define HASHINC 1013 ! 1228: struct ht { ! 1229: char **ht_low; ! 1230: char **ht_high; ! 1231: int ht_used; ! 1232: } htab[MAXHASH]; ! 1233: ! 1234: char * ! 1235: hash(s) ! 1236: char *s; ! 1237: { ! 1238: register char **h; ! 1239: register i; ! 1240: register char *cp; ! 1241: struct ht *htp; ! 1242: int sh; ! 1243: ! 1244: /* ! 1245: * The hash function is a modular hash of ! 1246: * the sum of the characters with the sum ! 1247: * doubled before each successive character ! 1248: * is added. ! 1249: */ ! 1250: cp = s; ! 1251: i = 0; ! 1252: while (*cp) ! 1253: i = i*2 + *cp++; ! 1254: sh = (i&077777) % HASHINC; ! 1255: cp = s; ! 1256: /* ! 1257: * There are as many as MAXHASH active ! 1258: * hash tables at any given point in time. ! 1259: * The search starts with the first table ! 1260: * and continues through the active tables ! 1261: * as necessary. ! 1262: */ ! 1263: for (htp = htab; htp < &htab[MAXHASH]; htp++) { ! 1264: if (htp->ht_low == 0) { ! 1265: register char **hp = ! 1266: (char **) calloc(sizeof (char **), HASHINC); ! 1267: if (hp == 0) ! 1268: cerror("ran out of memory (hash)"); ! 1269: htp->ht_low = hp; ! 1270: htp->ht_high = htp->ht_low + HASHINC; ! 1271: } ! 1272: h = htp->ht_low + sh; ! 1273: /* ! 1274: * quadratic rehash increment ! 1275: * starts at 1 and incremented ! 1276: * by two each rehash. ! 1277: */ ! 1278: i = 1; ! 1279: do { ! 1280: if (*h == 0) { ! 1281: if (htp->ht_used > (HASHINC * 3)/4) ! 1282: break; ! 1283: htp->ht_used++; ! 1284: *h = savestr(cp); ! 1285: return (*h); ! 1286: } ! 1287: if (**h == *cp && strcmp(*h, cp) == 0) ! 1288: return (*h); ! 1289: h += i; ! 1290: i += 2; ! 1291: if (h >= htp->ht_high) ! 1292: h -= HASHINC; ! 1293: } while (i < HASHINC); ! 1294: } ! 1295: cerror("ran out of hash tables"); ! 1296: /*NOTREACHED*/ ! 1297: } ! 1298: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.