![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lex.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront / ocfront|
Return to lex.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / ocfront |
1.1 ! root 1: /*ident "@(#)ctrans:src/lex.c 1.3.4.24" */ ! 2: /*************************************************************************** ! 3: ! 4: C++ source for cfront, the C++ compiler front-end ! 5: written in the computer science research center of Bell Labs ! 6: ! 7: Copyright (c) 1984 AT&T, Inc. All Rights Reserved ! 8: THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC. ! 9: ! 10: lex.c: ! 11: lexical analyser based on pcc's and cpre's scanners ! 12: modified to handle classes: ! 13: new keywords: class ! 14: public ! 15: call ! 16: etc. ! 17: names are not entered in the symbol table by lex() ! 18: names can be of arbitrary length ! 19: error() is used to report errors ! 20: {} and () must match ! 21: numeric constants are not converted into internal representation ! 22: but stored as strings ! 23: ! 24: ****************************************************************************/ ! 25: ! 26: #include "cfront.h" ! 27: #include "yystype.h" ! 28: #include "size.h" ! 29: #include "tqueue.h" ! 30: ! 31: # define CCTRANS(x) x ! 32: ! 33: /* lexical actions */ ! 34: ! 35: #define A_ERR 0 /* illegal character */ ! 36: #define A_LET 1 /* saw a letter */ ! 37: #define A_DIG 2 /* saw a digit */ ! 38: #define A_1C 3 /* return a single character */ ! 39: #define A_STR 4 /* string */ ! 40: #define A_CC 5 /* character constant */ ! 41: #define A_BCD 6 /* GCOS BCD constant */ ! 42: #define A_SL 7 /* saw a / */ ! 43: #define A_DOT 8 /* saw a . */ ! 44: #define A_2C 9 /* possible two character symbol */ ! 45: #define A_WS 10 /* whitespace (not \n) */ ! 46: #define A_NL 11 /* \n */ ! 47: #define A_LC 12 /* { */ ! 48: #define A_RC 13 /* } */ ! 49: #define A_L 14 /* ( */ ! 50: #define A_R 15 /* ) */ ! 51: #define A_EOF 16 ! 52: #define A_ASS 17 ! 53: #define A_LT 18 ! 54: #define A_GT 19 /* > */ ! 55: #define A_ER 20 ! 56: #define A_OR 21 ! 57: #define A_AND 22 ! 58: #define A_MOD 23 ! 59: #define A_NOT 24 ! 60: #define A_MIN 25 ! 61: #define A_MUL 26 ! 62: #define A_PL 27 ! 63: #define A_COL 28 /* : */ ! 64: #define A_SHARP 29 /* # */ ! 65: ! 66: /* character classes */ ! 67: ! 68: # define LEXLET 01 ! 69: # define LEXDIG 02 ! 70: /* no LEXOCT because 8 and 9 used to be octal digits */ ! 71: # define LEXHEX 010 ! 72: # define LEXWS 020 ! 73: # define LEXDOT 040 ! 74: ! 75: const FIRSTCHUNK = 8*1024-8; ! 76: const BUFCHUNK = 4*1024-8; ! 77: ! 78: /* text buffer */ ! 79: static char inbuf[FIRSTCHUNK/*TBUFSZ*/]; ! 80: static char* txtmax = &inbuf[FIRSTCHUNK/*TBUFSZ*/-1]; ! 81: static char* txtstart = 0; ! 82: static char* txtfree = 0; ! 83: ! 84: static struct buf* bufhead; ! 85: static buf* freebuf; ! 86: //static bufs; ! 87: ! 88: struct buf { ! 89: buf* next; ! 90: char chars[BUFCHUNK]; ! 91: // buf() { next=bufhead; bufhead=this; } ! 92: }; ! 93: ! 94: new_buf(char c) ! 95: { ! 96: //fprintf(stderr,"new_buf %d\n",bufs++); ! 97: buf* pbuf; ! 98: if (freebuf) { ! 99: pbuf = freebuf; ! 100: freebuf = freebuf->next; ! 101: } ! 102: else ! 103: pbuf = new buf; // allocate and register new chunk ! 104: pbuf->next = bufhead; ! 105: bufhead = pbuf; ! 106: ! 107: if (BUFCHUNK < txtmax-txtstart) error('l',"lexical token too long"); ! 108: ! 109: // copy current token: ! 110: char* p = txtstart; ! 111: txtstart = txtfree = &pbuf->chars[0]; ! 112: while (p<txtmax) *txtfree++ = *p++; ! 113: *txtfree++=c; ! 114: txtmax = &pbuf->chars[BUFCHUNK-1]; ! 115: return 0; ! 116: } ! 117: ! 118: ! 119: #define pch(c) ((txtmax<=txtfree)?new_buf(c):(*txtfree++=c)) ! 120: #define start_txt() txtstart = txtfree ! 121: #define del_txt() txtfree = txtstart ! 122: ! 123: static int Nfile;// = 1; ! 124: static char* file_name[MAXFILE*4]; // source file names ! 125: // file_name[0] == src_file_name ! 126: // file_name[0] == 0 means stdin ! 127: static short file_stack[MAXFILE]; // stack of file name indices ! 128: static int tcurr_file; // current index in file_stack ! 129: // that is current #include nest level ! 130: ! 131: Linkage linkage = linkage_default; // linkage is default C++ ! 132: const LINKMAX = 10; ! 133: static Linkage lvec[LINKMAX] = { linkage_default }; ! 134: static int lcount = 0; ! 135: ! 136: void set_linkage(char* p) ! 137: { ! 138: if (p==0 || *p == 0) { // resume previous linkage ! 139: if (lcount>0) linkage = lvec[--lcount]; ! 140: } ! 141: else { ! 142: if (LINKMAX<=++lcount) { ! 143: error('l',"linkage directive nested too deep"); ! 144: --lcount; ! 145: } else if (strcmp(p,"C")==0) ! 146: lvec[lcount] = linkage = linkage_C; ! 147: else if (strcmp(p,"C++")==0) ! 148: lvec[lcount] = linkage = linkage_Cplusplus; ! 149: else { ! 150: error("%s linkage",p); ! 151: --lcount; ! 152: } ! 153: } ! 154: } ! 155: ! 156: static struct loc tloc; ! 157: FILE * out_file = stdout; ! 158: FILE * in_file = stdin; ! 159: Ptable ktbl; ! 160: static int p_level = 0; /* number of unmatched ``(''s */ ! 161: static int b_level = 0; /* number of unmatched ``{''s */ ! 162: ! 163: # ifdef ibm ! 164: ! 165: # define CSMASK 0377 ! 166: # define CSSZ 256 ! 167: ! 168: # else ! 169: ! 170: # define CSMASK 0177 ! 171: # define CSSZ 128 ! 172: ! 173: # endif ! 174: ! 175: static short lxmask[CSSZ+1]; ! 176: ! 177: int saved = 0; /* putback character, avoid ungetchar */ ! 178: static int lxtitle(); ! 179: ! 180: overload rt; ! 181: inline YYSTYPE rt(char* x) { YYSTYPE y; y.s = x; return y; } ! 182: inline YYSTYPE rt(int x) { YYSTYPE y; y.t = x; return y; } ! 183: inline YYSTYPE rt(loc x) { YYSTYPE y; y.l = x; return y; } ! 184: inline YYSTYPE rt(void* x) { YYSTYPE y; y.pn = Pname(x); return y; } ! 185: ! 186: #define get(c) (c=getc(in_file)) ! 187: #define unget(c) ungetc(c,in_file) ! 188: ! 189: #define reti(a,b) { addtok(a, rt(b), tloc); return a; } ! 190: #define retn(a,b) { addtok(a, rt((Pnode)b), tloc); return a; } ! 191: #define rets(a,b) { addtok(a, rt(b), tloc); return a; } ! 192: #define retl(a) { addtok(a, rt(tloc), tloc); return a; } ! 193: ! 194: void ktbl_init() ! 195: /* ! 196: enter keywords into keyword table for use by lex() ! 197: and into keyword representation table used for output ! 198: */ ! 199: { ! 200: ktbl = new table(KTBLSIZE,0,0); ! 201: ! 202: new_key("asm",ASM,0); ! 203: new_key("auto",AUTO,TYPE); ! 204: new_key("break",LOC,BREAK); ! 205: new_key("case",LOC,CASE); ! 206: new_key("continue",LOC,CONTINUE); ! 207: new_key("char",CHAR,TYPE); ! 208: new_key("do",LOC,DO); ! 209: new_key("double",DOUBLE,TYPE); ! 210: new_key("default",LOC,DEFAULT); ! 211: new_key("enum",ENUM,0); ! 212: new_key("else",LOC,ELSE); ! 213: new_key("extern",EXTERN,TYPE); ! 214: new_key("float",FLOAT,TYPE); ! 215: new_key("for",LOC,FOR); ! 216: // new_key("fortran",FORTRAN,0); ! 217: new_key("goto",LOC,GOTO); ! 218: new_key("catch",CATCH,CATCH); ! 219: new_key("try",TRY,TRY); ! 220: new_key("if",LOC,IF); ! 221: new_key("int",INT,TYPE); ! 222: new_key("long",LONG,TYPE); ! 223: new_key("return",LOC,RETURN); ! 224: new_key("register",REGISTER,TYPE); ! 225: new_key("static",STATIC,TYPE); ! 226: new_key("struct",STRUCT,AGGR); ! 227: new_key("sizeof",SIZEOF,0); ! 228: new_key("short",SHORT,TYPE); ! 229: new_key("switch",LOC,SWITCH); ! 230: new_key("template",TEMPLATE,TEMPLATE); ! 231: new_key("typedef",TYPEDEF,TYPE); ! 232: new_key("unsigned",UNSIGNED,TYPE); ! 233: new_key("union",UNION,AGGR); ! 234: new_key("void",VOID,TYPE); ! 235: new_key("while",LOC,WHILE); ! 236: ! 237: new_key("class",CLASS,AGGR); ! 238: new_key("const",CONST,TYPE); ! 239: new_key("delete",LOC,DELETE); ! 240: new_key("friend",FRIEND,TYPE); ! 241: new_key("inline",INLINE,TYPE); ! 242: new_key("new",NEW,0); ! 243: new_key("operator",OPERATOR,0); ! 244: new_key("overload",OVERLOAD,TYPE); ! 245: new_key("private",PRIVATE,PR); ! 246: new_key("protected",PROTECTED,PR); ! 247: new_key("public",PUBLIC,PR); ! 248: new_key("signed",SIGNED,TYPE); ! 249: new_key("this",THIS,0); ! 250: new_key("virtual",VIRTUAL,TYPE); ! 251: new_key("volatile",VOLATILE,TYPE); ! 252: } ! 253: ! 254: loc last_line; ! 255: loc noloc = { 0, 0 }; ! 256: ! 257: void loc::putline() ! 258: { ! 259: if (file==0 && line==0) return; ! 260: // fix, Nfile, not MAXFILE; Nfile == MAXFILE*4 ! 261: // if (0<=file && file<MAXFILE) { ! 262: if ( 0<=file && file <= Nfile ) { ! 263: char* f = file_name[file]; ! 264: if (f==0) f = src_file_name; ! 265: fprintf(out_file,line_format,line,f); ! 266: last_line = *this; ! 267: } ! 268: } ! 269: ! 270: void loc::put(FILE* p) ! 271: { ! 272: // fix, Nfile, not MAXFILE; Nfile == MAXFILE*4 ! 273: // if (0<=file && file<MAXFILE) { ! 274: if ( 0<=file && file <= Nfile ) { ! 275: char* f = file_name[file]; ! 276: if (f==0) f = src_file_name; ! 277: fprintf(p,"\"%s\", line %d: ",f,line); ! 278: } ! 279: } ! 280: ! 281: void lxenter(register char* s, short m) ! 282: /* enter a mask into lxmask */ ! 283: { ! 284: register c; ! 285: ! 286: while( c= *s++ ) lxmask[c+1] |= m; ! 287: ! 288: } ! 289: ! 290: ! 291: void lxget(register c, register m) ! 292: /* ! 293: put 'c' back then scan for members of character class 'm' ! 294: terminate the string read with \0 ! 295: txtfree points to the character position after that \0 ! 296: */ ! 297: { ! 298: pch(c); ! 299: while ( (get(c), lxmask[c+1]&m) ) pch(c); ! 300: unget(c); ! 301: pch('\0'); ! 302: } ! 303: ! 304: struct LXDOPE { ! 305: short lxch; /* the character */ ! 306: short lxact; /* the action to be performed */ ! 307: TOK lxtok; /* the token number to be returned */ ! 308: } lxdope[] = { ! 309: #ifdef apollo ! 310: '@', A_ERR, 0, /* illegal characters go here... */ ! 311: #else ! 312: '$', A_ERR, 0, /* illegal characters go here... */ ! 313: #endif ! 314: '_', A_LET, 0, /* letters point here */ ! 315: '0', A_DIG, 0, /* digits point here */ ! 316: ' ', A_WS, 0, /* whitespace goes here */ ! 317: '\n', A_NL, 0, ! 318: '"', A_STR, 0, /* character string */ ! 319: '\'', A_CC, 0, /* ASCII character constant */ ! 320: '`', A_BCD, 0, /* 'foreign' character constant, e.g. BCD */ ! 321: '(', A_L, LP, ! 322: ')', A_R, RP, ! 323: '{', A_LC, LC, ! 324: '}', A_RC, RC, ! 325: '[', A_1C, LB, ! 326: ']', A_1C, RB, ! 327: '*', A_MUL, MUL, ! 328: '?', A_1C, QUEST, ! 329: ':', A_COL, COLON, ! 330: '+', A_PL, PLUS, ! 331: '-', A_MIN, MINUS, ! 332: '/', A_SL, DIV, ! 333: '%', A_MOD, MOD, ! 334: '&', A_AND, AND, ! 335: '|', A_OR, OR, ! 336: '^', A_ER, ER, ! 337: '!', A_NOT, NOT, ! 338: '~', A_1C, COMPL, ! 339: ',', A_1C, CM, ! 340: ';', A_1C, SM, ! 341: '.', A_DOT, DOT, ! 342: '<', A_LT, LT, ! 343: '>', A_GT, GT, ! 344: '=', A_ASS, ASSIGN, ! 345: '#', A_SHARP, 0, ! 346: EOF, A_EOF, EOFTOK ! 347: }; ! 348: /* note: EOF is used as sentinel, so must be <=0 and last entry in table */ ! 349: ! 350: static struct LXDOPE *lxcp[CSSZ+1]; ! 351: ! 352: void lex_init() ! 353: { ! 354: register struct LXDOPE *p; ! 355: register i; ! 356: register char *cp; ! 357: /* set up character classes */ ! 358: ! 359: /* first clear lexmask */ ! 360: for(i=0; i<=CSSZ; i++) lxmask[i] = 0; ! 361: ! 362: #ifdef apollo ! 363: lxenter( "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$", LEXLET ); ! 364: #else ! 365: lxenter( "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_", LEXLET ); ! 366: #endif ! 367: lxenter( "0123456789", LEXDIG ); ! 368: lxenter( "0123456789abcdefABCDEF", LEXHEX ); ! 369: /* \013 should become \v someday; \013 is OK for ASCII and EBCDIC */ ! 370: lxenter( " \t\r\b\f\013", LEXWS ); ! 371: lxmask['.'+1] |= LEXDOT; ! 372: ! 373: /* make lxcp point to appropriate lxdope entry for each character */ ! 374: ! 375: /* initialize error entries */ ! 376: ! 377: for( i= 0; i<=CSSZ; ++i ) lxcp[i] = lxdope; ! 378: ! 379: /* make unique entries */ ! 380: ! 381: for( p=lxdope; ; ++p ) { ! 382: lxcp[p->lxch+1] = p; ! 383: if( p->lxch < 0 ) break; ! 384: } ! 385: ! 386: /* handle letters, digits, and whitespace */ ! 387: /* by convention, first, second, and third places */ ! 388: ! 389: cp = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; ! 390: while( *cp ) lxcp[*cp++ + 1] = &lxdope[1]; ! 391: cp = "123456789"; ! 392: while( *cp ) lxcp[*cp++ + 1] = &lxdope[2]; ! 393: cp = "\t\b\r\f\013"; ! 394: while( *cp ) lxcp[*cp++ + 1] = &lxdope[3]; ! 395: ! 396: file_name[0] = src_file_name; ! 397: // set both curloc and tloc so curloc is valid at program startup ! 398: // curloc.file = tloc.file = 0; ! 399: curloc.line = tloc.line = 1; ! 400: ! 401: ktbl_init(); ! 402: lex_clear(); ! 403: saved = lxtitle(); ! 404: } ! 405: ! 406: void lex_clear() ! 407: { ! 408: // delete extra buffers: ! 409: buf* p = bufhead; ! 410: bufhead = 0; ! 411: //if (p) { ! 412: //fprintf(stderr,"lex_clear\n"); ! 413: //bufs=0; ! 414: //} ! 415: while (p) { ! 416: buf* pp = p; ! 417: p = p->next; ! 418: pp->next = freebuf; ! 419: freebuf = pp; ! 420: } ! 421: ! 422: // re-set to static buffer: ! 423: txtstart = txtfree = inbuf; ! 424: txtmax = &inbuf[FIRSTCHUNK/*TBUFSZ*/-1]; ! 425: } ! 426: ! 427: int int_val(char hex) ! 428: { ! 429: switch (hex) { ! 430: case '0': case '1': case '2': case '3': case '4': ! 431: case '5': case '6': case '7': case '8': case '9': ! 432: return hex-'0'; ! 433: case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': ! 434: return hex-'a'+10; ! 435: case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': ! 436: return hex-'A'+10; ! 437: } ! 438: } ! 439: ! 440: void hex_to_oct() ! 441: /* ! 442: \x has been seen on input (in char const or string) and \ printed ! 443: read the following hexadecimal integer and replace it with an octal ! 444: */ ! 445: { ! 446: int i = 0; ! 447: int c; ! 448: get(c); ! 449: if (lxmask[c+1] & LEXHEX) { ! 450: i = int_val(c); ! 451: get(c); // try for two ! 452: if (lxmask[c+1] & LEXHEX) { ! 453: i = (i<<4) + int_val(c); ! 454: get(c); // try for three ! 455: if (lxmask[c+1] & LEXHEX) ! 456: i = (i<<4) + int_val(c); ! 457: else ! 458: unget(c); ! 459: } ! 460: else ! 461: unget(c); ! 462: } ! 463: else { ! 464: error("hexadecimal digitE after \\x"); ! 465: unget(c); ! 466: } ! 467: ! 468: // if (0377 < i) error('l',"hexadecimal constant too large"); ! 469: i &= 0377; ! 470: ! 471: pch(('0'+(i>>6))); ! 472: pch(('0'+((i&070)>>3))); ! 473: pch(('0'+(i&7))); ! 474: } ! 475: ! 476: ! 477: char * chconst() ! 478: /* ! 479: read a character constant into inbuf ! 480: */ ! 481: { ! 482: register c; ! 483: int nch = 0; ! 484: ! 485: pch('\''); ! 486: ! 487: for(;;) { ! 488: char* p; ! 489: char cc = 0; ! 490: ! 491: switch (get(c)) { ! 492: case '\'': ! 493: goto ex; ! 494: case EOF: ! 495: error("eof in char constant"); ! 496: goto ex; ! 497: case '\n': ! 498: error("newline in char constant"); ! 499: goto ex; ! 500: case '\\': ! 501: if (SZ_INT == nch++) error('l',"char constant too long"); ! 502: pch(c); ! 503: switch (get(c)){ ! 504: case '\n': ! 505: ++tloc.line; ! 506: default: ! 507: pch(c); ! 508: break; ! 509: case '4': case '5': case '6': case '7': // octal ! 510: p = txtfree; ! 511: cc = c-4; ! 512: case '0': case '1': case '2': case '3': ! 513: pch(c); ! 514: get(c); /* try for 2 */ ! 515: if( lxmask[c+1] & LEXDIG && c<'8'){ ! 516: pch(c); ! 517: get(c); /* try for 3 */ ! 518: if (lxmask[c+1] & LEXDIG && c<'8') { ! 519: if (cc) *p = cc; // zap high bit ! 520: pch(c); ! 521: } ! 522: else ! 523: unget(c); ! 524: } ! 525: else ! 526: unget(c); ! 527: break; ! 528: case 'x': // hexadecimal ! 529: hex_to_oct(); ! 530: break; ! 531: }; ! 532: break; ! 533: default: ! 534: if (SZ_INT == nch++) error('l',"char constant too long"); ! 535: pch(c); ! 536: } ! 537: } ! 538: ex: ! 539: if(nch==0) ! 540: error("empty char constant"); ! 541: pch('\''); ! 542: pch('\0'); ! 543: return txtstart; ! 544: } ! 545: ! 546: void lxcom() ! 547: /* process a "block comment" */ ! 548: { ! 549: register c; ! 550: ! 551: for(;;) ! 552: switch (get(c)) { ! 553: case EOF: ! 554: error('w',"eof in comment"); ! 555: return; ! 556: case '\n': ! 557: tloc.line++; ! 558: // Nline++; ! 559: break; ! 560: case '*': ! 561: if (get(c) == '/') return; ! 562: unget(c); ! 563: break; ! 564: case '/': ! 565: if (get(c) == '*') error('w',"``/*'' in comment"); ! 566: unget(c); ! 567: break; ! 568: } ! 569: } ! 570: ! 571: ! 572: void linecom() ! 573: // process a "line comment" ! 574: { ! 575: register c; ! 576: ! 577: get(c); ! 578: #ifdef DBG ! 579: if ( c=='@' && get(c)=='!' ) { ! 580: while ( get(c) != '\n' && c != EOF ) pch(c); ! 581: pch('\0'); ! 582: process_debug_flags(txtstart); ! 583: del_txt(); ! 584: } ! 585: #endif ! 586: for(;;get(c)) ! 587: switch (c) { ! 588: case EOF: ! 589: error('w',"eof in comment"); ! 590: return; ! 591: case '\n': ! 592: tloc.line++; ! 593: // Nline++; ! 594: saved = lxtitle(); ! 595: return; ! 596: } ! 597: } ! 598: ! 599: char eat_whitespace() ! 600: { ! 601: ! 602: for(;;) { ! 603: register c = get(c); ! 604: lx: ! 605: ! 606: switch (c) { ! 607: case EOF: ! 608: error('w',"unexpected comment"); ! 609: return EOF; ! 610: case '/': ! 611: switch (get(c)) { ! 612: case '*': ! 613: lxcom(); ! 614: break; ! 615: case '/': ! 616: linecom(); ! 617: break; ! 618: default: ! 619: unget(c); ! 620: return '/'; ! 621: } ! 622: break; ! 623: case '\n': ! 624: ++tloc.line; ! 625: c = lxtitle(); ! 626: goto lx; ! 627: case ' ': ! 628: case '\t': ! 629: break; ! 630: default: ! 631: return c; ! 632: } ! 633: } ! 634: } ! 635: ! 636: void get_string() ! 637: { ! 638: int lxchar; ! 639: ! 640: for(;;) ! 641: switch (get(lxchar)) { ! 642: case '\\': ! 643: pch('\\'); ! 644: switch (get(lxchar)){ ! 645: case '\n': ! 646: ++tloc.line; ! 647: default: ! 648: pch(lxchar); ! 649: break; ! 650: case 'x': // hexadecimal ! 651: hex_to_oct(); ! 652: break; ! 653: }; ! 654: break; ! 655: case '"': ! 656: { char* p = txtstart; // eat_whitespace() moves txtstart ! 657: if ((lxchar = eat_whitespace()) == '"') { ! 658: // string catenation, break with ! 659: // newline to avoid merging characters ! 660: // (e.g. "\xAB" "C") ! 661: pch('\\'); ! 662: pch('\n'); ! 663: ! 664: continue; // eat '\"' and carry on ! 665: }; ! 666: ! 667: txtstart = p; ! 668: unget(lxchar); ! 669: pch(0); ! 670: return; ! 671: } ! 672: case '\n': ! 673: error("newline in string"); ! 674: pch(0); ! 675: return; ! 676: case EOF: ! 677: error("eof in string"); ! 678: pch(0); ! 679: return; ! 680: default: ! 681: pch(lxchar); ! 682: } ! 683: } ! 684: ! 685: TOK tlex() ! 686: { ! 687: TOK ret; ! 688: Pname n; ! 689: ! 690: // Ntoken++; ! 691: ! 692: for(;;) { ! 693: register lxchar; ! 694: register struct LXDOPE *p; ! 695: ! 696: start_txt(); ! 697: ! 698: if (saved) { ! 699: lxchar = saved; ! 700: saved = 0; ! 701: } ! 702: else ! 703: get(lxchar); ! 704: ! 705: if (lxchar+1 >= CSSZ ) ! 706: error( "illegal input character encountered: %d", lxchar ); ! 707: ! 708: switch( (p=lxcp[lxchar+1])->lxact ){ ! 709: ! 710: case A_1C: // eat up a single character, and return an opcode ! 711: reti(p->lxtok,p->lxtok); ! 712: ! 713: case A_EOF: ! 714: if (p_level || b_level+lcount) ! 715: error("'%s' missing at end of input",(b_level+lcount) ? "}" : ")"); ! 716: ! 717: reti(EOFTOK,0); ! 718: ! 719: case A_SHARP: ! 720: // cope with header file not ended with '\n' ! 721: unget('#'); ! 722: saved = lxtitle(); ! 723: continue; ! 724: ! 725: case A_ERR: ! 726: { if (' '<=lxchar && lxchar<='~') // ASCII printable ! 727: error("illegal character '%c' (ignored)",lxchar); ! 728: else ! 729: error("illegal character '0%o' (ignored)",lxchar); ! 730: continue; ! 731: } ! 732: case A_LET: // collect an identifier and check for keyword ! 733: { ! 734: char ll; ! 735: switch (ll = lxchar) { ! 736: // case 'l': ! 737: case 'L': ! 738: switch (get(lxchar)) { ! 739: case '\'': ! 740: error('s',"wide character constant"); ! 741: unget(lxchar); ! 742: continue; ! 743: case '"': ! 744: error('s',"wide character string"); ! 745: unget(lxchar); ! 746: continue; ! 747: } ! 748: unget(lxchar); ! 749: lxchar = ll; ! 750: } ! 751: } ! 752: lxget( lxchar, LEXLET|LEXDIG ); ! 753: ! 754: //error( 'd', "lex: b_level: %d txtstart %s", b_level, txtstart); ! 755: // local class ! 756: if (n = ktbl->look(txtstart,0)) { ! 757: TOK x; ! 758: del_txt(); ! 759: switch (x=n->base) { ! 760: case TNAME: ! 761: rets(ID,n->string); ! 762: //error('d',"lex tname %n",n); ! 763: //if (b_level > 1) { ! 764: // Pname nn = ktbl->look(txtstart,LOCAL); ! 765: // if ( nn ) { ! 766: // n = nn; ! 767: //error( 'd', "lex: local class instance: %n", nn ); ! 768: // } ! 769: //} ! 770: // retn(TNAME,n); ! 771: case LOC: ! 772: retl(n->syn_class); ! 773: case EXTERN: ! 774: if ((lxchar = eat_whitespace()) == '\"') { ! 775: // linkage directive ! 776: get_string(); ! 777: rets(LINKAGE,txtstart); ! 778: } ! 779: unget(lxchar); ! 780: reti(TYPE,EXTERN); ! 781: case CATCH: ! 782: case TEMPLATE: ! 783: error('s',"%k",n->syn_class); ! 784: continue; ! 785: case TRY: ! 786: { ! 787: static int warn_try; ! 788: if (!warn_try) { ! 789: Pname n = ktbl->look("try",0); ! 790: n->n_key = DEFAULT; ! 791: error('w',&tloc,"%k is a future reserved keyword",n->syn_class); ! 792: warn_try++; ! 793: } ! 794: rets(ID,n->string); ! 795: } ! 796: default: ! 797: reti(n->syn_class,x); ! 798: } ! 799: } ! 800: rets(ID,txtstart); ! 801: //else ! 802: // local class ! 803: //if ( b_level && (n=ktbl->look(txtstart,LOCAL)) ) { ! 804: //error( 'd', "lex2: local class instance: %n", n ); ! 805: // retn(TNAME,n); ! 806: //} else ! 807: // rets(ID,txtstart); ! 808: ! 809: case A_DIG: ! 810: ! 811: ret = ICON; ! 812: ! 813: if (lxchar=='0') { ! 814: int pkchar; ! 815: get(pkchar); ! 816: if(pkchar=='x' || pkchar=='X') { // hex ! 817: pch(lxchar); ! 818: lxget(pkchar,LEXHEX); ! 819: txtfree--; ! 820: if (txtfree-txtstart<3) // minimum "0Xd\0" ! 821: error("hex digitX after \"0x\""); ! 822: get(lxchar); ! 823: goto getsuffix; ! 824: } ! 825: unget(pkchar); ! 826: } ! 827: ! 828: lxget(lxchar,LEXDIG); ! 829: txtfree--; ! 830: ! 831: if (get(lxchar) == '.') { ! 832: getfp: ! 833: lxget('.', LEXDIG ); ! 834: txtfree--; ! 835: ret = FCON; ! 836: get(lxchar); ! 837: }; ! 838: ! 839: if (lxchar=='e' || lxchar=='E') { ! 840: pch(lxchar); ! 841: get(lxchar); ! 842: if(lxchar=='-' || lxchar=='+') { ! 843: pch(lxchar); ! 844: get(lxchar); ! 845: } ! 846: if (lxmask[lxchar+1] & LEXDIG) { ! 847: lxget( lxchar, LEXDIG ); ! 848: txtfree--; ! 849: get(lxchar); ! 850: } ! 851: else ! 852: error("missing exponent digits?"); ! 853: ret = FCON; ! 854: }; ! 855: ! 856: if(*txtstart=='0' && ret==ICON) { ! 857: char *bch = txtstart; ! 858: while (++bch <= txtfree) { ! 859: if(*bch=='8' || *bch=='9') ! 860: error("%c used as octal digit",*bch); ! 861: } ! 862: } ! 863: ! 864: getsuffix: ! 865: switch (lxchar) { ! 866: case 'f': ! 867: case 'F': ! 868: if (ret==ICON) ! 869: error("%c suffix for integer constant",lxchar); ! 870: else ! 871: pch(lxchar); ! 872: break; ! 873: case 'u': ! 874: case 'U': ! 875: if (ret==FCON) { ! 876: error("%c suffix for floating constant",lxchar); ! 877: break; ! 878: } ! 879: pch(lxchar); ! 880: switch(get(lxchar)) { ! 881: case 'l': ! 882: case 'L': ! 883: pch(lxchar); ! 884: break; ! 885: default: ! 886: saved=lxchar; ! 887: break; ! 888: } ! 889: break; ! 890: case 'l': ! 891: case 'L': ! 892: pch(lxchar); ! 893: if (ret==FCON) { ! 894: break; ! 895: } ! 896: switch(get(lxchar)) { ! 897: case 'u': ! 898: case 'U': ! 899: pch(lxchar); ! 900: break; ! 901: default: ! 902: saved=lxchar; ! 903: break; ! 904: } ! 905: break; ! 906: default: ! 907: saved = lxchar; ! 908: break; ! 909: }; ! 910: ! 911: if(*txtstart=='0' && txtfree-txtstart==1) ! 912: reti(ZERO,0); // plain zero ! 913: ! 914: pch(0); ! 915: rets(ret,txtstart); ! 916: ! 917: ! 918: case A_DOT: ! 919: switch (get(lxchar)) { ! 920: case '.': // look for ellipsis ! 921: if (get(lxchar) != '.') { ! 922: error("token .. ?"); ! 923: saved = lxchar; ! 924: } ! 925: reti(ELLIPSIS,0); ! 926: case '*': ! 927: reti (REFMUL,DOT); ! 928: } ! 929: ! 930: if (lxmask[lxchar+1] & LEXDIG){// look for floating constant ! 931: unget(lxchar); ! 932: goto getfp; ! 933: } ! 934: saved = lxchar; ! 935: reti(DOT,0); ! 936: ! 937: case A_STR: ! 938: /* save string constant in buffer */ ! 939: get_string(); ! 940: rets(STRING,txtstart); ! 941: ! 942: case A_CC: ! 943: /* character constant */ ! 944: rets(CCON,chconst()); ! 945: ! 946: case A_BCD: ! 947: { ! 948: register i; ! 949: int j; ! 950: ! 951: pch('`'); ! 952: ! 953: for (i=0; i<7; ++i) { ! 954: pch(get(j)); ! 955: if (j == '`' ) break; ! 956: } ! 957: pch(0); ! 958: if (6<i) ! 959: error('l',"bcd constant exceeds 6 characters" ); ! 960: rets(CCON,txtstart); ! 961: } ! 962: ! 963: case A_SL: /* / */ ! 964: switch (get(lxchar)) { ! 965: case '*': ! 966: lxcom(); ! 967: break; ! 968: case '/': ! 969: linecom(); ! 970: break; ! 971: case '=': ! 972: reti(ASOP,ASDIV); ! 973: default: ! 974: saved = lxchar; ! 975: reti(DIVOP,DIV); ! 976: } ! 977: ! 978: case A_WS: ! 979: continue; ! 980: ! 981: case A_NL: ! 982: ++tloc.line; ! 983: // Nline++; ! 984: saved = lxtitle(); ! 985: continue; ! 986: ! 987: case A_LC: ! 988: if (BLMAX <= b_level++) { ! 989: error('l',"blocks too deeply nested"); ! 990: ext(3); ! 991: } ! 992: retl(LC); ! 993: ! 994: case A_RC: ! 995: if (lcount+b_level-- <= 0) { ! 996: error("unexpected '}'"); ! 997: b_level = 0; ! 998: } ! 999: retl(RC); ! 1000: ! 1001: case A_L: ! 1002: p_level++; ! 1003: reti(LP,0); ! 1004: ! 1005: case A_R: ! 1006: if (p_level-- <= 0) { ! 1007: error("unexpected ')'"); ! 1008: p_level = 0; ! 1009: } ! 1010: reti(RP,0); ! 1011: ! 1012: case A_ASS: ! 1013: switch (get(lxchar)) { ! 1014: case '=': ! 1015: reti(EQUOP,EQ); ! 1016: default: ! 1017: saved = lxchar; ! 1018: reti(ASSIGN,ASSIGN); ! 1019: } ! 1020: ! 1021: case A_COL: ! 1022: switch (get(lxchar)) { ! 1023: case ':': ! 1024: reti(MEM,0); ! 1025: case '=': ! 1026: error("':=' is not a c++ operator"); ! 1027: reti(ASSIGN,ASSIGN); ! 1028: default: ! 1029: saved = lxchar; ! 1030: reti(COLON,COLON); ! 1031: } ! 1032: case A_NOT: ! 1033: switch (get(lxchar)) { ! 1034: case '=': ! 1035: reti(EQUOP,NE); ! 1036: default: ! 1037: saved = lxchar; ! 1038: reti(NOT,NOT); ! 1039: } ! 1040: case A_GT: ! 1041: switch(get(lxchar)) { ! 1042: case '>': ! 1043: switch (get(lxchar)) { ! 1044: case '=': ! 1045: reti(ASOP,ASRS); ! 1046: break; ! 1047: default: ! 1048: saved = lxchar; ! 1049: reti(SHIFTOP,RS); ! 1050: } ! 1051: case '=': ! 1052: reti(RELOP,GE); ! 1053: default: ! 1054: saved = lxchar; ! 1055: reti(RELOP,GT); ! 1056: } ! 1057: case A_LT: ! 1058: switch (get(lxchar)) { ! 1059: case '<': ! 1060: switch (get(lxchar)) { ! 1061: case '=': ! 1062: reti(ASOP,ASLS); ! 1063: default: ! 1064: saved = lxchar; ! 1065: reti(SHIFTOP,LS); ! 1066: } ! 1067: case '=': ! 1068: reti(RELOP,LE); ! 1069: default: ! 1070: saved = lxchar; ! 1071: reti(RELOP,LT); ! 1072: } ! 1073: case A_AND: ! 1074: switch (get(lxchar)) { ! 1075: case '&': ! 1076: reti(ANDAND,ANDAND); ! 1077: case '=': ! 1078: reti(ASOP,ASAND); ! 1079: default: ! 1080: saved = lxchar; ! 1081: reti(AND,AND); ! 1082: } ! 1083: case A_OR: ! 1084: switch (get(lxchar)) { ! 1085: case '|': ! 1086: reti(OROR,OROR); ! 1087: case '=': ! 1088: reti(ASOP,ASOR); ! 1089: default: ! 1090: saved = lxchar; ! 1091: reti(OR,OR); ! 1092: } ! 1093: case A_ER: ! 1094: switch (get(lxchar)) { ! 1095: case '=': ! 1096: reti(ASOP,ASER); ! 1097: default: ! 1098: saved = lxchar; ! 1099: reti(ER,ER); ! 1100: } ! 1101: case A_PL: ! 1102: switch (get(lxchar)) { ! 1103: case '=': ! 1104: reti(ASOP,ASPLUS); ! 1105: case '+': ! 1106: reti(ICOP,INCR); ! 1107: default: ! 1108: saved = lxchar; ! 1109: reti(PLUS,PLUS); ! 1110: } ! 1111: case A_MIN: ! 1112: switch (get(lxchar)) { ! 1113: case '=': ! 1114: reti(ASOP,ASMINUS); ! 1115: case '-': ! 1116: reti(ICOP,DECR); ! 1117: case '>': ! 1118: if (get(lxchar) == '*') ! 1119: {reti(REFMUL,REF);} ! 1120: else ! 1121: saved = lxchar; ! 1122: reti(REF,REF); ! 1123: default: ! 1124: saved = lxchar; ! 1125: reti(MINUS,MINUS); ! 1126: } ! 1127: case A_MUL: ! 1128: switch (get(lxchar)) { ! 1129: case '=': ! 1130: reti(ASOP,ASMUL); ! 1131: case '/': ! 1132: error('w',"*/ not as end of comment"); ! 1133: default: ! 1134: saved = lxchar; ! 1135: reti(MUL,MUL); ! 1136: } ! 1137: case A_MOD: ! 1138: switch (get(lxchar)) { ! 1139: case '=': ! 1140: reti(ASOP,ASMOD); ! 1141: default: ! 1142: saved = lxchar; ! 1143: reti(DIVOP,MOD); ! 1144: } ! 1145: default: ! 1146: {error('i',"lex act==%d getc()->%d",p,lxchar);} ! 1147: ! 1148: } ! 1149: ! 1150: error('i',"lex, main switch"); ! 1151: } ! 1152: ! 1153: } ! 1154: ! 1155: int lxtitle() ! 1156: /* ! 1157: called after a newline; set linenumber and file name ! 1158: */ ! 1159: { ! 1160: register c; ! 1161: ! 1162: for(;;) ! 1163: switch ( get(c) ) { ! 1164: default: // e.g. not '\n', not '#' ! 1165: return c; ! 1166: case '\n': ! 1167: tloc.line++; ! 1168: // Nline++; ! 1169: ll: ! 1170: break; ! 1171: case '#': /* # lineno "filename" */ ! 1172: { int cl = tloc.line; ! 1173: tloc.line = 0; ! 1174: for(;;) ! 1175: switch (get(c)) { ! 1176: case '"': ! 1177: start_txt(); ! 1178: for(;;) ! 1179: switch (get(c)) { ! 1180: case '"': ! 1181: pch('\0'); ! 1182: ! 1183: while (get(c) != '\n') ; // skip to eol.. ignore anything more ! 1184: ! 1185: if (*txtstart) { // stack file name ! 1186: char* fn; ! 1187: if (tcurr_file == 0){ ! 1188: if (( fn = file_name[0]) ! 1189: && (strcmp(txtstart,fn)!=0)){ // 1st include ! 1190: if (MAXFILE*4<++Nfile) error('i',"fileN buffer overflow"); ! 1191: if (MAXFILE<++tcurr_file) error('i',"fileN stack overflow"); ! 1192: file_stack[tcurr_file] = Nfile; ! 1193: ! 1194: char* p1 = new char[txtfree-txtstart]; ! 1195: (void) strcpy(p1,txtstart); ! 1196: file_name[Nfile] = p1; ! 1197: // Nstr++; ! 1198: } ! 1199: else { //&& line is dummy #line "input.c" ! 1200: // ignore ! 1201: } ! 1202: //&& dead, dead, dead goto push; ! 1203: } ! 1204: else if ( (fn=file_name[file_stack[tcurr_file]]) ! 1205: && (strcmp(txtstart,fn)==0) ) { ! 1206: //new line, same file: ignore ! 1207: } ! 1208: else if ( (fn=file_name[file_stack[tcurr_file-1]]) ! 1209: && (strcmp(txtstart,fn)==0) ) { ! 1210: // previous file: pop ! 1211: tcurr_file--; ! 1212: } ! 1213: else { // new file name: push ! 1214: //&& push: ! 1215: if (MAXFILE*4<Nfile++) error('i',"fileN buffer overflow"); ! 1216: if (MAXFILE<tcurr_file++) error('i',"fileN stack overflow"); ! 1217: file_stack[tcurr_file] = Nfile; ! 1218: char* p = new char[txtfree-txtstart]; ! 1219: (void) strcpy(p,txtstart); ! 1220: file_name[Nfile] = p; ! 1221: // Nstr++; ! 1222: } ! 1223: } ! 1224: else { // no name .. back to the original .c file: "" ! 1225: tcurr_file = 0; ! 1226: } ! 1227: del_txt(); ! 1228: tloc.file = file_stack[tcurr_file]; ! 1229: goto ll; ! 1230: case '\n': ! 1231: error("unexpected end of line on '# line'"); ! 1232: default: ! 1233: pch(c); ! 1234: } ! 1235: case ' ': ! 1236: break; ! 1237: ! 1238: case '0': ! 1239: case '1': ! 1240: case '2': ! 1241: case '3': ! 1242: case '4': ! 1243: case '5': ! 1244: case '6': ! 1245: case '7': ! 1246: case '8': ! 1247: case '9': ! 1248: tloc.line = tloc.line*10+c-'0'; ! 1249: break; ! 1250: ! 1251: case 'l': // look for "#line ..." and then ignore "line" ! 1252: if (get(c)=='i' && get(c)=='n' && get(c)=='e') break; ! 1253: case '\n': ! 1254: tloc.putline(); ! 1255: goto ll; ! 1256: ! 1257: default: // pass #rubbish through ! 1258: tloc.line = cl; ! 1259: pch('#'); ! 1260: pch(c); ! 1261: while (get(c) != '\n') pch(c); ! 1262: pch('\0'); ! 1263: fprintf(out_file,"\n%s\n",txtstart); ! 1264: start_txt(); ! 1265: tloc.line++; ! 1266: // Nline++; ! 1267: goto ll; ! 1268: } ! 1269: } ! 1270: } ! 1271: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.