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