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