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