![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lalex.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront / ocfront|
Return to lalex.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / ocfront |
1.1 ! root 1: /*ident "@(#)ctrans:src/lalex.c 1.6.3.37" */ ! 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: lalex.c: ! 11: ! 12: lookahead ! 13: ! 14: *****************************************************************************/ ! 15: #include <stdio.h> ! 16: ! 17: #ifdef c_plusplus ! 18: overload is_empty; ! 19: #endif ! 20: ! 21: #include "cfront.h" ! 22: #include "yystype.h" ! 23: #include "tqueue.h" ! 24: ! 25: #ifdef DBG ! 26: #define LDB(val,a) { if(Ldebug>=val) {a;} } ! 27: #else ! 28: #define LDB(val,a) /**/ ! 29: #endif ! 30: ! 31: #ifdef DBG ! 32: static char* ! 33: image( int t ) ! 34: { ! 35: if(keys[t]) return keys[t]; ! 36: else { static char b[20]; ! 37: sprintf(b,"token(%d)",t); ! 38: return b; ! 39: } ! 40: } ! 41: static void ! 42: showQ( char* where ) ! 43: /* ! 44: display token Q ! 45: */ ! 46: { ! 47: fprintf(stderr,"TOKEN Q (%s):\n",where); ! 48: for (register toknode* t = front; t; t = t->next) { ! 49: fprintf(stderr,"\t%s",image(t->tok)); ! 50: switch(t->tok) { ! 51: case ID: case ICON: case CCON: case FCON: case STRING: ! 52: fprintf(stderr," '%s'",t->retval.s); ! 53: break; ! 54: case TNAME: ! 55: fprintf(stderr," '%s'",t->retval.pn->string); ! 56: break; ! 57: } ! 58: putc(' ',stderr); ! 59: t->place.put(stderr); ! 60: putc('\n',stderr); ! 61: } ! 62: putc('\n',stderr); ! 63: } ! 64: #endif ! 65: ! 66: int bl_level; ! 67: ! 68: static int laexpr( TOK ); ! 69: static int latype( TOK ); ! 70: static int la_decl(); ! 71: static TOK lookahead(); ! 72: ! 73: /* make this a toknode! */ ! 74: static int lasttk = 0; // one token history ! 75: static YYSTYPE lastval; // yylval lasttk value ! 76: ! 77: int must_be_expr = 0; // handle redundant parentheses ! 78: int must_be_id = 0; // !0, TNAME => ID, i.e., int X ! 79: ! 80: loc curloc; ! 81: int curr_file; ! 82: ! 83: toknode* latok; // current lookahead token ! 84: toknode* front = 0; ! 85: toknode* rear = 0; ! 86: ! 87: static toknode* free_toks = 0; ! 88: const TQCHUNK = 16; ! 89: ! 90: toknode::toknode(TOK t, YYSTYPE r, loc tloc) ! 91: { ! 92: if (free_toks == 0) { ! 93: register toknode* q; ! 94: free_toks = q = (toknode*)malloc( TQCHUNK * sizeof(toknode) ); ! 95: for (; q != &free_toks[TQCHUNK-1]; q->next = q+1, ++q); ! 96: q->next = 0; ! 97: } ! 98: this = free_toks; free_toks = free_toks->next; ! 99: tok = t; ! 100: used = 0; ! 101: retval = r; ! 102: place = tloc; ! 103: next = last = 0; ! 104: } ! 105: ! 106: toknode::~toknode() ! 107: { ! 108: next = free_toks; ! 109: free_toks = this; ! 110: this = 0; ! 111: } ! 112: ! 113: #define USE_TOKEN(T,W) \ ! 114: LDB(2,error('d',&(T)->place,"use_token('%k','%s')",(T)->tok,W);); \ ! 115: if ( !(T)->used ) use_token(T); ! 116: ! 117: Ptype ! 118: return_nstd_local_type( Pname n, TOK &sw ) ! 119: { ! 120: Ptype tt; ! 121: switch ( n->tp->base ) { ! 122: case EOBJ: ! 123: case COBJ: ! 124: tt = Pbase(n->tp)->b_name->tp; ! 125: sw = n->tp->base; ! 126: break; ! 127: default: ! 128: tt = n->tpdef; ! 129: sw = NESTED; // in repr.c, prints ``typedef'' ! 130: break; ! 131: } ! 132: return tt; ! 133: } ! 134: ! 135: static Pname ! 136: local_nested_kludge( Pname n, Pname tn ) ! 137: /* ! 138: * for backward compatibility with 2.0 ! 139: * in transitional model of nested class types ! 140: * ! 141: * struct T { ... }; ! 142: * foobar() { ! 143: * class X { ! 144: * typedef int T; ! 145: * // ... ! 146: * }; ! 147: * T t; ! 148: * } ! 149: * ! 150: * pure nested classes, choose global struct T{}; ! 151: * no nested classes, choose typedef int T ! 152: * transitional model: choose typedef, and generate warning ! 153: * BUG: local typedefs and enums do not have lex_level set ! 154: */ ! 155: { ! 156: // error( 'd', "local_nested_kludge: n: %n", n ); ! 157: for ( Pname nn = n; nn; nn = nn->n_tbl_list ) ! 158: { ! 159: Pname local_class; ! 160: TOK ntd; ! 161: if ( nn->n_key != NESTED ) continue; ! 162: Ptype tt = return_nstd_local_type(nn,ntd); ! 163: Pclass cl = tt->in_class; ! 164: while ( cl->in_class ) cl = cl->in_class; ! 165: if (cl->lex_level && ! 166: (local_class = ktbl->look(cl->string,LOCAL))) ! 167: { ! 168: // same typedef at nested and non-nested scope ! 169: if (ntd == NESTED && tn && tn->tp == nn->tp ) ! 170: ; ! 171: else ! 172: error('w',"%s occurs at outer and nested localC scope; using %k %t::%s", n->string,ntd,cl,n->string); ! 173: ! 174: /* ! 175: if ( ntd == NESTED && nn->n_dcl_printed != 2 ) { ! 176: nn->dcl_print(0); ! 177: nn->n_dcl_printed = 2; ! 178: } ! 179: */ ! 180: return nn; ! 181: } ! 182: } ! 183: return 0; ! 184: } ! 185: ! 186: enum { one_back, two_back }; ! 187: ! 188: static void ! 189: use_token( toknode* T ) ! 190: /* ! 191: lookup TNAMEs here instead of in tlex() ! 192: maintain block level ! 193: */ ! 194: { ! 195: static TOK last_tokens[2]; // TSCOPE not reduced at this point ! 196: static Pname last_tname; // tname :: id, where id is nested class ! 197: static Pname tdef_name; // typedef tname tdef_name ! 198: ! 199: T->used = 1; ! 200: ! 201: // error('d', &T->place, "use_token: %k, lasttk: %k",T->tok,lasttk ); ! 202: // error('d', &T->place, "last_tokens: %k %k",last_tokens[two_back],last_tokens[one_back]); ! 203: // error('d', &T->place, "use_token: last_tname: %n", last_tname); ! 204: ! 205: switch ( T->tok ) { ! 206: case ID: ! 207: Pname n; ! 208: // error('d', &T->place, "use_token: %s", T->retval.s ); ! 209: if ( last_tokens[one_back] == MEM && ! 210: last_tokens[two_back] == TNAME && ! 211: (n=ktbl->look(T->retval.s,NESTED))) ! 212: { // TYPEDEF :: ID, nested class ctor ! 213: if (tdef_name && tdef_name->n_key==NESTED && ! 214: strcmp(tdef_name->string,n->string)==0) ! 215: { ! 216: T->tok = TNAME; ! 217: T->retval.pn = n; ! 218: break; ! 219: } ! 220: else { // TNAME :: ID, where ID may be nested class ! 221: for ( Pname nn = n; nn; nn = nn->n_tbl_list ) ! 222: { ! 223: TOK sw; ! 224: if ( nn->n_key != NESTED ) continue; ! 225: Ptype tt = return_nstd_local_type(nn,sw); ! 226: Pclass cl = tt->in_class; ! 227: if (strcmp(last_tname->string,cl->string)==0) ! 228: { ! 229: T->tok = TNAME; ! 230: T->retval.pn = nn; ! 231: break; ! 232: } ! 233: } ! 234: } ! 235: } ! 236: else ! 237: if ( bl_level && ! 238: // TNAME:: and :: cannot refer to ``local'' TNAME ! 239: last_tokens[one_back] != MEM && ! 240: (n=ktbl->look(T->retval.s,LOCAL)) ) ! 241: { ! 242: DB( if(Ldebug>=1)error( 'd', &T->place, "use_token: local class instance: %n", n ) ); ! 243: T->tok = TNAME; ! 244: T->retval.pn = n; ! 245: } ! 246: else if ( n=ktbl->look(T->retval.s,0) ) { ! 247: DB( if(Ldebug>=1)error( 'd', &T->place, "use_token: global class instance: %n", n ) ); ! 248: // error( 'd', &T->place, "use_token: global class instance: %n %t", n, n->tp ); ! 249: ! 250: // X:: ?, then n cannot be a global TNAME ! 251: // except in the case of a constructor ! 252: if (last_tokens[one_back] == MEM && ! 253: last_tokens[two_back] == TNAME && ! 254: strcmp(T->retval.s,last_tname->string)) ! 255: ; // do nothing; i.e., return ID ! 256: else ! 257: if ( bl_level && n->tp->base != COBJ && ! 258: last_tokens[one_back] == MEM && ! 259: last_tokens[two_back] != TNAME && ! 260: gtbl->look(T->retval.s,0)) ! 261: ; // do nothing: local typedefs & enums not implemented ! 262: else { ! 263: Pname nn = 0; ! 264: TOK ntd; ! 265: if (bl_level && (nn=ktbl->look(T->retval.s,NESTED))) ! 266: { ! 267: (void) return_nstd_local_type(n,ntd); ! 268: nn = local_nested_kludge(nn,ntd==NESTED?n:0); ! 269: } ! 270: T->tok = TNAME; ! 271: T->retval.pn = nn?nn:n; ! 272: } ! 273: } ! 274: #ifdef DBG ! 275: else if(Ldebug>=1) ! 276: error('d',&T->place,"use_token: id %s",T->retval.s); ! 277: #endif ! 278: break; ! 279: case LC: ++bl_level; break; ! 280: case RC: --bl_level; break; ! 281: } ! 282: ! 283: if (T->tok != COMPL || last_tokens[one_back] != MEM) { ! 284: last_tokens[two_back] = last_tokens[one_back]; ! 285: last_tokens[one_back] = T->tok; ! 286: if (T->tok == TNAME) last_tname = T->retval.pn; ! 287: if ( last_tname && ! 288: last_tname->tp->base == TYPE ) ! 289: { ! 290: tdef_name = last_tname; ! 291: do ! 292: tdef_name = Pbase(tdef_name->tp)->b_name; ! 293: while ( tdef_name->tp->base == TYPE ); ! 294: } ! 295: } ! 296: } ! 297: ! 298: void ! 299: addtok(TOK t, YYSTYPE r, loc tloc) ! 300: { ! 301: toknode* T = new toknode(t,r,tloc); ! 302: if (front == 0) ! 303: front = rear = T; ! 304: else { ! 305: rear->next = T; ! 306: T->last = rear; ! 307: rear = T; ! 308: } ! 309: //error('d',&tloc,"addtok: %k '%s'",t,t==ID?r.s:""); ! 310: //showQ("addtok"); ! 311: } ! 312: ! 313: extern TOK ! 314: deltok( int noset = 0 ) ! 315: { ! 316: register toknode* T = front; ! 317: USE_TOKEN(T,"deltok"); ! 318: register TOK tk = T->tok; ! 319: if ( !noset ) { yylval = T->retval; curloc = T->place; } ! 320: curr_file = curloc.file; ! 321: if (front = front->next) ! 322: front->last = 0; ! 323: else ! 324: latok = rear = 0; ! 325: delete T; ! 326: return tk; ! 327: } ! 328: ! 329: static void ! 330: add_tokens() ! 331: /* ! 332: extend lookahead token queue when depleted ! 333: */ ! 334: { ! 335: TOK tk = tlex(); ! 336: if ( tk != ID ) ! 337: return; ! 338: ! 339: while (tk == ID || tk == MEM || tk == DOT ) ! 340: tk = tlex(); ! 341: } ! 342: ! 343: extern TOK ! 344: la_look() ! 345: /* ! 346: peek at head of token queue ! 347: */ ! 348: { ! 349: LDB(1,fprintf(stderr,"\n*** la_look()")); ! 350: if ( front == 0 ) ! 351: add_tokens(); ! 352: ! 353: latok = front; ! 354: USE_TOKEN(latok,"la_look"); ! 355: LDB(1,fprintf(stderr," -- %s\n",image(latok->tok))); ! 356: return latok->tok; ! 357: } ! 358: ! 359: #define NEXTTOK() ( (yychar==-1) ? (yychar=lalex(),yychar) : yychar ) ! 360: void ! 361: check_decl() ! 362: /* ! 363: Lookahead to direct parsing of local/arg type declarations ! 364: la_decl() returns 1 if lookahead sees a declaration. ! 365: */ ! 366: { ! 367: TOK tk2; ! 368: switch( NEXTTOK() ) { ! 369: default: ! 370: break; ! 371: case TSCOPE: //XXX ! 372: tk2 = la_look(); ! 373: while ( tk2 == TSCOPE ) tk2 = lookahead(); ! 374: if ( tk2 == TNAME ) { ! 375: toknode* t = latok; ! 376: if(t->tok!=TNAME) ! 377: error('i',"check_decl() token scan"); ! 378: tk2 = lookahead(); ! 379: if ( tk2 == LP && la_decl() ) { ! 380: t->tok = DECL_MARKER; //TNAME ! 381: } ! 382: } ! 383: break; ! 384: case TYPE: case TNAME: ! 385: if ( la_look() == LP && la_decl() ) { ! 386: must_be_id = 0; ! 387: DECL_TYPE=yychar; ! 388: yychar = DECL_MARKER; ! 389: } ! 390: } ! 391: } ! 392: ! 393: void ! 394: check_cast() ! 395: /* ! 396: Lookahead to direct parsing of cast ! 397: la_cast() returns 1 if lookahead sees an ambiguous old-style C cast. ! 398: */ ! 399: { ! 400: TOK tk2; ! 401: switch( NEXTTOK() ) { ! 402: case TSCOPE: //XXX ! 403: tk2 = la_look(); ! 404: while ( tk2 == TSCOPE ) tk2 = lookahead(); ! 405: if ( tk2 == TNAME ) { ! 406: toknode* t = latok; ! 407: if(t->tok!=TNAME) ! 408: error('i',"check_cast() token scan"); ! 409: tk2 = lookahead(); ! 410: if ( tk2 == LP && la_decl() ) { ! 411: t->tok = DECL_MARKER;//TNAME ! 412: } ! 413: } ! 414: break; ! 415: case TYPE: case TNAME: ! 416: if ( la_look() == LP && la_cast() ) { ! 417: must_be_id = 0; ! 418: DECL_TYPE = yychar; ! 419: yychar = DECL_MARKER; ! 420: } ! 421: } ! 422: } ! 423: ! 424: ! 425: static int ! 426: latype( TOK t ) ! 427: { ! 428: switch ( t ) { ! 429: default: // includes friend, typedef, storage classes, etc. ! 430: return 0; ! 431: case CHAR: case SHORT: case INT: case LONG: ! 432: case FLOAT: case DOUBLE: ! 433: case UNSIGNED: ! 434: return 1; ! 435: } ! 436: } ! 437: ! 438: static int ! 439: laexpr( TOK t ) ! 440: { ! 441: switch ( t ) { ! 442: default: ! 443: return 0; ! 444: case RETURN: case NEW: case AND: case ANDAND: case OR: case OROR: ! 445: case SIZEOF: case NOT: case COMPL: case MUL: case PLUS: case MINUS: ! 446: case ER: case ASSIGN: case ASOP: case RELOP: case EQUOP: case DIVOP: ! 447: case SHIFTOP: case ICOP: ! 448: return 1; ! 449: } ! 450: } ! 451: ! 452: ! 453: static TOK ! 454: lookahead() ! 455: /* ! 456: advance lookahead pointer, lexing at end of Q ! 457: handle occurrences of TNAME and TSCOPE ! 458: (should be kept up to date with lalex()) ! 459: */ ! 460: { ! 461: TOK tk; ! 462: TOK tk2; ! 463: TOK prev_tk = 0; ! 464: YYSTYPE lastval; ! 465: ! 466: if ( latok == rear ) { ! 467: add_tokens(); ! 468: if ( latok ) ! 469: latok = latok->next; ! 470: else ! 471: latok = front; ! 472: } ! 473: else ! 474: latok = latok->next; ! 475: ! 476: if ( latok->last ) { ! 477: prev_tk = latok->last->tok; ! 478: lastval = latok->last->retval; ! 479: } ! 480: ! 481: nexttok: ! 482: USE_TOKEN(latok,"lookahead1"); ! 483: tk = latok->tok; ! 484: if ( tk == ID || tk == TNAME ) ! 485: { ! 486: if (latok->next == 0) add_tokens(); ! 487: USE_TOKEN(latok->next,"lookahead2"); ! 488: /* TOK */ tk2 = latok->next->tok; ! 489: if ( tk == TNAME ) { ! 490: if ( tk2 == MEM || tk2 == DOT ) { ! 491: tscope: tk = TSCOPE; ! 492: // error('d',"lookahead: tk: %k tk2: %k", tk, tk2 ); ! 493: //XXX -- should be modified to loop and do lookup ! 494: latok = latok->next; ! 495: if (latok->next == 0) add_tokens(); ! 496: USE_TOKEN(latok->next,"lookahead3"); ! 497: tk2 = latok->next->tok; ! 498: if ( tk2 == MUL ) { ! 499: tk = MEMPTR; ! 500: latok = latok->next; ! 501: } ! 502: } ! 503: else if (( prev_tk == MUL && tk2 != RP ) ! 504: || prev_tk == AND ) ! 505: { ! 506: tk = ID; ! 507: latok->retval.pn->hide(); ! 508: latok->tok = ID; ! 509: latok->retval.s = latok->retval.pn->string; ! 510: } ! 511: } ! 512: else if ( tk2 == MEM ) { ! 513: // ID :: ! 514: //XXX latok = latok->next->next; ! 515: //XXX goto nexttok; ! 516: goto tscope; // treat as tscope ! 517: } ! 518: ! 519: if ( tk == ID && ! 520: ( tk2 == ID || ! 521: ( prev_tk == ID && ( tk2 == COLON || tk2 == LC )))) { ! 522: // ID ID ! 523: latok = latok->next; ! 524: goto nexttok; ! 525: } ! 526: } ! 527: ! 528: if ( tk == ID ) { ! 529: Pname nstd = ktbl->look(latok->retval.s,NESTED); ! 530: if (nstd && (must_be_id == 0 || ! 531: must_be_id && prev_tk == LP)) { ! 532: extern Pname check_for_nested(Pname,TOK,YYSTYPE,TOK); // use this in lalex, too ! 533: Pname n = check_for_nested(nstd,prev_tk,lastval,tk2); ! 534: if ( n ) { ! 535: tk = latok->tok = TNAME; ! 536: latok->retval.pn = n; ! 537: } ! 538: } ! 539: } ! 540: ! 541: return tk; ! 542: } ! 543: ! 544: static Pname mem_sel = 0; ! 545: char *class_typedef = 0; ! 546: ! 547: static Pname ! 548: do_local_class( Pname n, int lex_level ) ! 549: { /* ! 550: * modify to ``do_local_type: ! 551: * do local types: enums and typedefs ! 552: */ ! 553: Pname nn = n; ! 554: if ( n->tp ) { // already a TNAME ! 555: Pclass cl = n->tp->base==COBJ ? Pclass(Pbase(n->tp)->b_name->tp) : 0; ! 556: if ( n->lex_level != lex_level || (cl && cl->lcl) ) { ! 557: local_hide( n ); ! 558: nn = new name( n->string ); ! 559: nn->lex_level = lex_level>=0?lex_level:0; ! 560: } ! 561: else ! 562: if ( lex_level == n->lex_level && cl->defined ) { ! 563: error( "localC %n redefined", n ); ! 564: return n; ! 565: } ! 566: } ! 567: ! 568: nn = nn->tname( lastval.t ); ! 569: modified_tn = modified_tn->l; ! 570: nn->n_key = LOCAL; ! 571: local_class = new name_list( nn, local_class ); ! 572: local_blk = new name_list( nn, local_blk ); ! 573: ! 574: // error('d', "do_local_class: nn %n tp %t", nn, Pclass(Pbase(nn->tp)->b_name->tp)); ! 575: return nn; ! 576: } ! 577: ! 578: static char* ! 579: make_nested_name( char *s, Pclass cl ) ! 580: { // Q<cnt>_<class_names><space><null> ! 581: const nested_depth = 9; ! 582: char *str_arr[nested_depth]; ! 583: int size_arr[nested_depth]; ! 584: int cnt = 2; ! 585: int size = 4; // Q,<cnt>,<_>,<null> ! 586: ! 587: str_arr[0] = s; str_arr[1] = cl->string; ! 588: ! 589: size += size_arr[0] = strlen(s); ! 590: size += size_arr[1] = cl->strlen?cl->strlen:strlen(cl->string); ! 591: ! 592: for (Pclass nc = cl->in_class; nc; nc = nc->in_class ) { ! 593: if (cnt > nested_depth-1) error('s',"nested depth class beyond %d unsupported",nested_depth); ! 594: size += size_arr[cnt] = nc->strlen?nc->strlen:strlen(nc->string); ! 595: str_arr[cnt++] = nc->string; ! 596: } ! 597: ! 598: for ( int i=0; i<cnt; i++ ) // <nnn><string> ! 599: size += size_arr[i]>99?3:size_arr[i]<10?1:2; ! 600: ! 601: //error('d', "make_nested_name( %s, %t ) cnt: %d size: %d", s, cl, cnt, size ); ! 602: char *result = new char[size]; ! 603: sprintf(result, "Q%d_", cnt ); ! 604: size = 3; ! 605: for ( i=cnt; i; i-- ) { ! 606: sprintf(result+size,"%d%s", size_arr[i-1], str_arr[i-1]); ! 607: size += size_arr[i-1] + (size_arr[i-1]>99?3:size_arr[i-1]<10?1:2); ! 608: } ! 609: ! 610: //error('d', "size: %d ", size ); ! 611: result[size] = '\0'; ! 612: //error('d', "make_nested_name result: %s", result ); ! 613: return result; ! 614: } ! 615: ! 616: int is_empty( Pclass cl, bit const_chk ) ! 617: { /* for nested class check, empty means *no* members ! 618: * for const object check, means no *data* members ! 619: */ ! 620: ! 621: // error('d',"%t->is_empty: max: %d real_size: %d", cl, cl->memtbl->max(),cl->real_size ); ! 622: ! 623: int mbr_cnt = cl->memtbl->max(); ! 624: if ( mbr_cnt == 0 ) return 1; ! 625: ! 626: if ( cl->baselist == 0 && cl->real_size!=1 ) ! 627: return 0; ! 628: ! 629: // empty class to turn on transitional nested class scope ! 630: if ( const_chk == 0 && ! 631: ( cl->baselist != 0 || mbr_cnt > 1 )) return 0; ! 632: ! 633: int i = 1; ! 634: for (Pname nn=cl->memtbl->get_mem(i); nn; nn=cl->memtbl->get_mem(++i)) { ! 635: if (nn->base==NAME && ! 636: nn->n_union==0 && ! 637: nn->tp->base!=FCT && ! 638: nn->tp->base!=OVERLOAD && ! 639: nn->tp->base!=CLASS && ! 640: nn->tp->base!=ENUM && ! 641: nn->tp->base!=EOBJ && ! 642: nn->n_stclass != STATIC) ! 643: { ! 644: if ( nn->string[0]=='_' && ! 645: nn->string[1]=='_' && ! 646: nn->string[2]=='W' ) ! 647: return 1; ! 648: else return 0; ! 649: } ! 650: } ! 651: ! 652: return 1; // if here, no data members encountered ! 653: } ! 654: ! 655: static int ! 656: is_empty( Penum en ) ! 657: { // is this an empty enum ?? ! 658: ! 659: // error('d', "%t no_of_enumerators: %d", en, en->no_of_enumerators); ! 660: if ( en->no_of_enumerators != 0 ) ! 661: return 0; ! 662: ! 663: return 1; ! 664: } ! 665: ! 666: static Pname ! 667: check_nested_type( Pname nm ) ! 668: { ! 669: // error('d', "check nested type: %n ccl: %t", nm, ccl ); ! 670: ! 671: Pname nx, n = ktbl->look(nm->string, NESTED); ! 672: if ( n == 0 || n == nm ) return nm; ! 673: ! 674: int cnt = 1; ! 675: for (nx = n; n; n=n->n_tbl_list ) ! 676: if (n->n_key == NESTED) ++cnt; ! 677: ! 678: if ( cnt > 1 ) { ! 679: error( "ambiguous nested type %s (%d instances), use x::y syntax", nm->string, cnt ); ! 680: error( 'i', "cannot recover from previous errors" ); ! 681: } ! 682: else { ! 683: TOK ntk; ! 684: Ptype tt = return_nstd_local_type(nx,ntk); ! 685: error('w', "use %t:: to access nested %k %s (anachronism)", tt->in_class, ntk, nx->string); ! 686: } ! 687: return nx; ! 688: } ! 689: ! 690: static int ! 691: in_local_class( Pclass cl ) ! 692: { ! 693: if ( cl->lex_level ) ! 694: return 1; ! 695: if ( cl->in_class ) ! 696: return in_local_class( cl->in_class ); ! 697: return 0; ! 698: } ! 699: ! 700: static Pname ! 701: do_nested_type( Pname n ) ! 702: { ! 703: Pname nn = n; ! 704: char *str = 0; ! 705: ! 706: // error('d', "do_nested_type: %s in_typedef: %d ccl: %t", n->string, in_typedef, ccl ); ! 707: // error('d', "lasttk: %k class_typedef: %s", lasttk, class_typedef); ! 708: if ( in_typedef && ccl->string[0]=='_' ! 709: && ccl->string[1]=='_' ! 710: && ccl->string[2]=='C') return n; ! 711: ! 712: if ( n->tp ) ! 713: { // already a TNAME : ! 714: // hide existing instance, encode new instance ! 715: /* ! 716: * need handle the anomaly: ! 717: * class x; ! 718: * x *p; ! 719: * class y { ! 720: * class x{ ... }; // oops ! 721: * }; ! 722: */ ! 723: if (n->tp->base==COBJ) { ! 724: Pclass cl = Pclass(Pbase(n->tp)->b_name->tp); ! 725: if (cl->defined == 0 && lasttk == AGGR) { ! 726: error('w',"forward declaration ofC%n resolved to nested%t::%s",n,ccl,n->string); ! 727: cl->lcl = new char[9]; ! 728: strcpy(cl->lcl,"FUDGE007"); // license to hack ! 729: n->lex_level=Pbase(n->tp)->b_name->lex_level=0; ! 730: return n; ! 731: } ! 732: } ! 733: else if (n->tp->base==EOBJ) { // watch out for enum x; ! 734: Penum en = Penum(Pbase(n->tp)->b_name->tp); ! 735: if (en->defined == 0 && lasttk == ENUM) return n; ! 736: } ! 737: ! 738: nested_hide( n ); ! 739: nn = new name( n->string ); ! 740: str = make_nested_name( n->string, ccl ); ! 741: } ! 742: else ! 743: // make sure we haven't already seen a nested instance ! 744: // if so, for transition, this needs to be an error ! 745: if (ktbl->look( n->string, NESTED )) ! 746: error("multiple type %s nestings (to do this define an empty class/enum %s {};)",n->string,n->string); ! 747: if ( in_typedef && ! 748: ( class_typedef == 0 || ! 749: strcmp(nn->string,class_typedef)==0 )) ! 750: { ! 751: if (strcmp(ccl->string, nn->string)==0) { // class x { typedef T x; ! 752: error( "nested Tdef %s redefines immediately enclosing class", nn->string ); ! 753: error( 'i', "cannot recover from previous errors" ); ! 754: } ! 755: ! 756: // make sure there isn't an identifier at global scope being defined ! 757: // by a nested typedef -- previously an error; keep it so for transition ! 758: Pname tn; ! 759: if ( n->tp == 0 && in_local_class(ccl)==0 && ! 760: (tn=gtbl->look(n->string,0))) { ! 761: error( "nested Tdef %s redefines global %n", n->string, tn ); ! 762: error( 'i', "cannot recover from previous errors" ); ! 763: } ! 764: ! 765: nn->tpdef = new type; ! 766: nn->tpdef->nested_sig = str; ! 767: nn->tpdef->in_class = ccl; ! 768: nn->tpdef->lex_level = NESTED; ! 769: PERM(nn->tpdef); ! 770: } ! 771: else { ! 772: nn = nn->tname( lastval.t ); ! 773: Pname tn = Pbase(nn->tp)->b_name; ! 774: Ptype tt = tn->tp; ! 775: if ( tt->defined && tt->in_class == ccl) { ! 776: error( "nested %t redefines immediately enclosing class", nn->string ); ! 777: error( 'i', "cannot recover from previous errors" ); ! 778: } ! 779: tt->nested_sig = str; ! 780: modified_tn = modified_tn->l; ! 781: nn->lex_level = tn->lex_level = 0; ! 782: nested_type = new name_list( nn, nested_type ); ! 783: } ! 784: nn->n_key = NESTED; ! 785: return nn; ! 786: } ! 787: ! 788: static Pname dtor_seen; ! 789: static int in_expr; ! 790: extern int in_sizeof; ! 791: ! 792: extern TOK ! 793: lalex() ! 794: /* return next token to grammar */ ! 795: { ! 796: register TOK tk; ! 797: if ( front == 0 ) ! 798: add_tokens(); // extend lookahead queue ! 799: LDB(1,fprintf(stderr,"\n*** lalex()\n");showQ("before")); ! 800: ! 801: gettok: ! 802: tk = deltok(); ! 803: // error('d',&curloc,"lalex: just got %k '%s' in_typedef: %d",tk,tk==ID?yylval.s:tk==TNAME?yylval.pn->string:"", in_typedef); ! 804: ! 805: if ( tk == ID || tk == TNAME ) ! 806: { ! 807: TOK tk2 = la_look(); ! 808: int lex_level = bl_level - in_class_decl - (tk2 == LC ); ! 809: ! 810: if ( tk == TNAME ) ! 811: { ! 812: //error('d', "lalex tname %n; lasttk: %k tk2: %k", yylval.pn, lasttk, tk2); ! 813: //error('d', " must_be_id: %d must_be_expr %d decl_type %d",must_be_id,must_be_expr,DECL_TYPE); ! 814: //error('d', " bl_level: %d parsing_members %d",bl_level,parsing_class_members); ! 815: if ( tk2 == LP ! 816: && (bl_level == 0 || parsing_class_members) ! 817: && ( laexpr(lasttk) == 0 ) ! 818: && must_be_expr == 0 ! 819: && DECL_TYPE == 0 ) { ! 820: if (la_decl()) { ! 821: must_be_id = 0; ! 822: DECL_TYPE = tk; ! 823: tk = DECL_MARKER; ! 824: goto ret; ! 825: } ! 826: } ! 827: ! 828: // note: *** can handle local typedefs here, too! ! 829: if ( in_typedef && ! 830: in_typedef->base != 0 && ! 831: ccl && in_mem_fct == 0 && ! 832: (tk2 == SM || tk2 == RP || tk2 == LB)) ! 833: yylval.pn = do_nested_type(yylval.pn); ! 834: ! 835: if ( lasttk == AGGR || lasttk == ENUM ) { ! 836: if ( tk2 == LC || tk2 == COLON ) { // class definition ! 837: if ( in_typedef && ! 838: in_typedef->base == 0 && ! 839: class_typedef == 0 ) ! 840: class_typedef = yylval.pn->string; ! 841: if ( lex_level ! 842: && (in_class_decl==0 || in_mem_fct) ! 843: && lasttk != ENUM ) // temporary ! 844: yylval.pn = do_local_class( yylval.pn, lex_level ); ! 845: else ! 846: if ( in_class_decl && ccl ) ! 847: yylval.pn = do_nested_type( yylval.pn ); ! 848: } ! 849: } ! 850: ! 851: if ( tk2 == MEM || (tk2 == DOT && mem_sel == 0 )) { ! 852: if (tk2==DOT) ! 853: error(strict_opt?0:'w',"``.'' used for qualification; please use ``::'' (anachronism)"); ! 854: crunch: ! 855: tk = TSCOPE; ! 856: {//XXX -- should be modified to do lookup and del at each :: ! 857: while ( (tk2 = lookahead()) == TSCOPE ) ; ! 858: if ( tk2 == TNAME ) { ! 859: tk2 = lookahead(); ! 860: if ( tk2 == LP ! 861: && (bl_level == 0 || parsing_class_members) ! 862: && ( laexpr(lasttk) == 0 ) ! 863: && must_be_expr == 0 ! 864: && DECL_TYPE == 0 ) { ! 865: if (la_decl()) { ! 866: must_be_id = 0; ! 867: //DECL_TYPE = tk;//??? ! 868: DECL_TYPE = TNAME; ! 869: //front should be :: ! 870: front->tok = TSCOPE; ! 871: front->retval.pn = yylval.pn; ! 872: yylval.pn = 0; ! 873: tk = DECL_MARKER; ! 874: goto ret; ! 875: } ! 876: } ! 877: } ! 878: } ! 879: tk2 = deltok(1); ! 880: tk2 = la_look(); ! 881: if ( tk2 == MUL ) { ! 882: tk = MEMPTR; ! 883: tk2 = deltok(1); ! 884: } ! 885: } ! 886: // Have a TNAME. Check to be sure. ! 887: else if ( must_be_id ){ ! 888: //error('d',"lalex: must_be_id: <tname %n> <%k>",yylval.pn,tk2); ! 889: if ( in_class_decl ! 890: && lasttk == TYPE ! 891: && tk2 == LP ! 892: && strcmp(yylval.pn->string,ccl->string) == 0 ) ! 893: error("%nK with returnT", yylval.pn); ! 894: ! 895: else if ( lasttk == TYPE && lastval.t == OVERLOAD ! 896: && ( tk2 == SM || tk2 == LP ) ) ! 897: { ! 898: tk = ID; ! 899: yylval.pn->hide(); ! 900: yylval.pn = new name( yylval.pn->string ); ! 901: yylval.pn->n_oper = TNAME; ! 902: } ! 903: else if ( lasttk == OPERATOR || ! 904: in_typedef && yylval.pn->n_key == NESTED) ! 905: must_be_id = 0; ! 906: else if ( lasttk != TSCOPE // watch out for X::X ! 907: || lastval.pn != yylval.pn ! 908: || (in_typedef && ! 909: in_typedef->check( yylval.pn->tp,0) == 0 )) ! 910: { ! 911: tk = ID; ! 912: if ( in_typedef && (lasttk == MUL || lasttk == REF)) { ! 913: defer_check = 1; ! 914: in_tag = yylval.pn; ! 915: } ! 916: ! 917: if ( lasttk == MEM && yylval.pn->lex_level ) { ! 918: Pname nn = gtbl->look( yylval.pn->string, 0 ); ! 919: if (nn == 0 ) ! 920: error( "%k%s undeclared", lasttk, yylval.pn->string); ! 921: else ! 922: yylval.pn = nn; ! 923: } ! 924: else { ! 925: // error('d',"lalex: else: lasttk: %k", lasttk ); ! 926: if (lasttk!=DOT && lasttk!=REF ! 927: && lasttk!=TSCOPE && lasttk != GOTO ! 928: // handle typedefs in basetype::check ! 929: // when type is available ! 930: && !in_typedef) { ! 931: // error('d',"\"%s\" line %d: hiding%n",__FILE__,__LINE__,yylval.pn); ! 932: yylval.pn->hide(); ! 933: } ! 934: ! 935: yylval.pn = new name (yylval.pn->string); ! 936: if (lasttk!=DOT && lasttk!=REF && ! 937: lasttk!=TSCOPE && lasttk !=GOTO) ! 938: yylval.pn->n_oper = TNAME; ! 939: } ! 940: if ( defer_check ) defer_check = 0; ! 941: } ! 942: } // must_be_id ! 943: ! 944: if ( in_class_decl && ! 945: ccl->lex_level && ! 946: yylval.pn->lex_level != 0 && ! 947: yylval.pn->tp && ! 948: (yylval.pn->tp->base != COBJ && yylval.pn->tp->base != EOBJ)) ! 949: { ! 950: Pname n = gtbl->look( yylval.pn->string,0); ! 951: if ( in_mem_fct ) { ! 952: if (n && n->base == TNAME ) { ! 953: error('w', "local typedef %n(%t) is not in scope of local class %s members; using global (%t)", yylval.pn, yylval.pn->tp, ccl->string, n->tp ); ! 954: yylval.pn = n; ! 955: } else ! 956: error( "local typedef %sis not in scope of inline member function of local class %s", yylval.pn->string, ccl->string); ! 957: } ! 958: } ! 959: ! 960: // if we still have a TNAME, make sure have the right TNAME ! 961: // possibility of ananchronistic reference to nested type ! 962: Ptype nbt = yylval.pn->tp; ! 963: if (tk == TNAME && curr_scope == 0 && nbt && // Y y; not X::Y y; ! 964: (nbt->base == EOBJ || nbt->base == COBJ)) ! 965: { ! 966: Ptype t = Pbase(nbt)->b_name->tp; ! 967: if ( ccl && t->in_class && ! 968: strcmp(t->in_class->string, ccl->string)) ! 969: { ! 970: switch( nbt->base ) { ! 971: case COBJ: ! 972: if (is_empty(Pclass(t))) ! 973: yylval.pn = check_nested_type( yylval.pn ); ! 974: break; ! 975: case EOBJ: ! 976: if (is_empty(Penum(t))) ! 977: yylval.pn = check_nested_type( yylval.pn ); ! 978: break; ! 979: }; ! 980: } ! 981: } ! 982: } ! 983: else ! 984: { // tk == ID ! 985: char *s = yylval.s; ! 986: Pname n = ktbl->look( s, HIDDEN ); ! 987: Pname nstd = ktbl->look( s, NESTED ); ! 988: ! 989: // inside a class definition, ccl, that is nested ! 990: // s is a nested class name, and is the name of ccl ! 991: if (ccl && ccl->in_class && nstd && ! 992: strcmp(s, ccl->string)==0) ! 993: { ! 994: for (Pname nn=nstd; nn; nn=nn->n_tbl_list) { ! 995: Ptype tt = (nn->tp->base==COBJ || nn->tp->base==EOBJ) ! 996: ? Pbase(nn->tp)->b_name->tp : nn->tpdef; ! 997: Pclass cl = tt->in_class; ! 998: if ( nn->n_key != NESTED ) continue; ! 999: if (strcmp(ccl->in_class->string,cl->string) == 0) { ! 1000: tk = TNAME; ! 1001: yylval.pn = nn; ! 1002: n = nstd = nn; ! 1003: } ! 1004: } ! 1005: } ! 1006: ! 1007: if (tk2 == MEM) { ! 1008: // ID :: ! 1009: if (n) { ! 1010: yylval.pn = n; ! 1011: /*XXX*/ goto crunch; ! 1012: } ! 1013: else ! 1014: if (nstd && ! 1015: nstd->n_tbl_list==0) ! 1016: { ! 1017: yylval.pn = nstd; ! 1018: tk = TSCOPE; ! 1019: tk2 = deltok(1); ! 1020: tk2 = la_look(); ! 1021: if (tk2 == MUL ) { ! 1022: tk = MEMPTR; ! 1023: tk2 = deltok(1); ! 1024: } ! 1025: } ! 1026: else { ! 1027: error( "%s:: %sis not aTN", s, s ); ! 1028: tk2 = deltok(1); ! 1029: goto gettok; ! 1030: } ! 1031: } ! 1032: else // transitional kludge ! 1033: if ( n && nstd && n == nstd ) ! 1034: ; // null statement ! 1035: ! 1036: // Have an ID. Check last token to be sure. ! 1037: else if (lasttk==ENUM || lasttk==AGGR) { ! 1038: int fd = tk2!=LC && tk2!=COLON; ! 1039: if ( in_typedef && fd == 0 && ! 1040: in_typedef->base == 0 && ! 1041: class_typedef == 0 ) ! 1042: class_typedef = yylval.s; ! 1043: tk = TNAME; ! 1044: if ( nstd ) { ! 1045: // in transitional model, need flag this as error ! 1046: if ( fd == 0 ) { // real definition ! 1047: if ( ccl == 0 ) ! 1048: error("nested and global%k %s(to do this place global%k %s {}; first)",lasttk==ENUM?lasttk:CLASS, s, lasttk==ENUM?lasttk:CLASS, s); ! 1049: else ! 1050: error("multiple nested%k %s(to do this place global%k %s {}; first)",lasttk==ENUM?lasttk:CLASS, s, lasttk==ENUM?lasttk:CLASS,s); ! 1051: error( 'i', "cannot recover from previous errors" ); ! 1052: } ! 1053: } ! 1054: else ! 1055: if (n==0) { // new tag, define it ! 1056: // error('d', "ccl: %t fd: %d, in_mem_fct: %d, in_class_decl: %d", ccl, fd, in_mem_fct, in_class_decl); ! 1057: n = new name( s ); ! 1058: if ( fd ) // struct X*, etc. ! 1059: n->lex_level=0; ! 1060: else ! 1061: n->lex_level=lex_level>=0?lex_level:0; ! 1062: ! 1063: if ( ccl && fd == 0 && ! 1064: in_class_decl && ! 1065: in_mem_fct == 0 ) ! 1066: n = do_nested_type( n ); ! 1067: else ! 1068: // note: ***** modify to handle local typedef ! 1069: // note: ***** add local enums ! 1070: if ( n->lex_level && ! 1071: lasttk != ENUM ) // temporary ! 1072: n = do_local_class( n, n->lex_level ); ! 1073: else { ! 1074: n = n->tname( lastval.t ); ! 1075: modified_tn = modified_tn->l; ! 1076: if (fd && gtbl->look(n->string,0)) statStat = n; ! 1077: } ! 1078: } ! 1079: else { ! 1080: if (n->tp->base!=COBJ && n->tp->base!=EOBJ) { ! 1081: error( 'i', "hidden%n:%t",n,n->tp ); ! 1082: goto gettok; ! 1083: } ! 1084: ! 1085: if ( tk2 == LC || tk2 == COLON ) { ! 1086: // class declared and hidden but not yet defined ! 1087: // may have ctor defined which invalidates hiding ! 1088: statStat = n; ! 1089: n->n_key = 0; // inside class definition it cannot be hidden ! 1090: } ! 1091: } ! 1092: yylval.pn = nstd?nstd:n; ! 1093: } ! 1094: else { ! 1095: tk = ID; ! 1096: yylval.pn = new name( s ); ! 1097: } ! 1098: ! 1099: if ( tk == ID ) ! 1100: { ! 1101: switch ( tk2 ) { ! 1102: case ID: case TNAME: case AGGR: case ENUM: ! 1103: { ! 1104: Pname n = 0; ! 1105: ! 1106: if ((curr_scope||ccl) && nstd) { ! 1107: // within class scope in which nested class is visible ! 1108: // curr_scope == set by TSCOPE, X::foo() { ... } ! 1109: // ccl == parsing class definition ``ccl'' ! 1110: ! 1111: char *str = curr_scope?curr_scope->string:ccl->string; ! 1112: for (Pname nn=nstd; nn; nn=nn->n_tbl_list) { ! 1113: Ptype tt = (nn->tp->base==COBJ || nn->tp->base==EOBJ) ! 1114: ? Pbase(nn->tp)->b_name->tp : nn->tpdef; ! 1115: Pclass cl = tt->in_class; ! 1116: if ( nn->n_key != NESTED ) continue; ! 1117: if ( strcmp(str,cl->string) == 0){ ! 1118: tk = TNAME; ! 1119: yylval.pn = nn; ! 1120: if (lasttk == TYPE && ! 1121: lastval.t == TYPEDEF ) ! 1122: in_typedef = yylval.pn->tp; ! 1123: break; ! 1124: } ! 1125: } ! 1126: } ! 1127: if (tk == TNAME) break; // found nested class ! 1128: ! 1129: n = ktbl->look( s, HIDDEN ); ! 1130: if ( n ) { ! 1131: Pname nn = n; ! 1132: switch ( n->tp->base ) { ! 1133: default: ! 1134: error("typedef %sis not visible in this scope", s ); ! 1135: break; ! 1136: case COBJ: ! 1137: if (is_empty(Pclass(Pbase(n->tp)->b_name->tp))) ! 1138: n = check_nested_type( nn ); ! 1139: if (nn == n) ! 1140: error("%sis hidden: use struct %s%s", s,s,front->retval.s); ! 1141: break; ! 1142: case EOBJ: ! 1143: if (is_empty(Penum(Pbase(n->tp)->b_name->tp))) ! 1144: n = check_nested_type( nn ); ! 1145: if (nn == n) ! 1146: error("%sis hidden: use enum %s%s", s,s,front->retval.s); ! 1147: break; ! 1148: }; ! 1149: tk = TNAME; ! 1150: yylval.pn = n; ! 1151: } ! 1152: else ! 1153: if (n=ktbl->look(s,NESTED)) ! 1154: { ! 1155: TOK ntk; ! 1156: bit ok = 0; ! 1157: Ptype tt = return_nstd_local_type(n,ntk); ! 1158: Pclass cl = tt->in_class; ! 1159: if (ccl) { ! 1160: // x::y unncessary with in_class, ! 1161: // a derived class of in_class ! 1162: // or classes enclosing in_class ! 1163: if (ccl==cl || ccl->has_base(cl)) ! 1164: ok++; ! 1165: else { ! 1166: for (Pclass eccl=ccl->in_class;eccl; eccl=eccl->in_class) ! 1167: if ( eccl == cl ) { ok++; break; } ! 1168: } ! 1169: } ! 1170: if (!ok) ! 1171: error('w', "use %t:: to access nested %k %s (anachronism)", cl, ntk, n->string ); ! 1172: tk = TNAME; ! 1173: yylval.pn = n; ! 1174: } ! 1175: else { // probably a typo ! 1176: if ( tk2 == ID ) ! 1177: error("%s%s: %sis not aTN", s,front->retval.s,s); ! 1178: else if ( tk2 == TNAME ) ! 1179: error("%s%s: %sis not aTN", s,front->retval.pn->string,s); ! 1180: else ! 1181: error("%s%k: %sis not aTN", s,front->retval.t,s); ! 1182: goto gettok; ! 1183: } ! 1184: break; ! 1185: } ! 1186: case DOT: case REF: ! 1187: mem_sel = yylval.pn; ! 1188: break; ! 1189: default: ! 1190: if ( lasttk == TNAME && tk2 == LC ) ! 1191: { ! 1192: error("T%s %k: %s is unexpected", s, tk2, s ); ! 1193: goto gettok; ! 1194: } ! 1195: ! 1196: // have an ID. lets just make sure it should not be a TNAME ! 1197: if (curr_scope||ccl||nstd) { ! 1198: if (ccl && in_typedef && ! 1199: in_typedef->base != 0 && ! 1200: in_mem_fct == 0 && ! 1201: (tk2 == SM || tk2 == RP || tk2 == LB)) ! 1202: { ! 1203: yylval.pn = do_nested_type( yylval.pn ); ! 1204: tk = TNAME; ! 1205: } ! 1206: else ! 1207: if (nstd && must_be_id == 0 && in_expr == 0) { ! 1208: // error('d',"nstd: %n must_be_id 0 have id tk2: %k lasttk: %k",nstd,tk2,lasttk); ! 1209: // error('d',"nstd: in_expr %d lex_level %d",in_expr,lex_level); ! 1210: Pclass xcl = curr_scope?Pclass(Pbase(curr_scope->tp)->b_name->tp):(ccl?ccl:0); ! 1211: for (Pname nn=nstd; nn; nn=nn->n_tbl_list) { ! 1212: TOK ntk; ! 1213: bit ok = 0; ! 1214: Ptype tt = return_nstd_local_type(nn,ntk); ! 1215: Pclass cl = tt->in_class; ! 1216: // error('d',"xcl: %t ccl: %t", xcl, ccl ); ! 1217: if ( xcl ) { ! 1218: if (xcl==cl || xcl->has_base(cl) || ccl == cl) ! 1219: ok++; ! 1220: else { ! 1221: for (Pclass eccl=xcl->in_class;eccl;eccl=eccl->in_class) ! 1222: if ( eccl == cl ) { ok++; break; } ! 1223: } ! 1224: } ! 1225: ! 1226: if (nn == nstd) ! 1227: { ! 1228: if ( ! 1229: // special case: foo(X, ! 1230: // in_arg_list not set until **after** X is handled ! 1231: ((in_arg_list || lasttk==LP) && // foo(nestedX ! 1232: (tk2==CM || tk2==ASSIGN || ! 1233: (tk2==RP && lasttk!=MUL && lasttk!=REF))) ! 1234: || // class x : public nestedX ! 1235: (tk2==LC && (lasttk==PR || lasttk==VIRTUAL)) ! 1236: || // nestedX [*&] ! 1237: (tk2 == MUL || tk2==AND) ! 1238: || (lasttk==LP && tk2==RP) ! 1239: || (lasttk==TSCOPE && lastval.pn == nn) ! 1240: || (lasttk==COMPL && dtor_seen == nn) ! 1241: || (lasttk==TYPE && lastval.t == TYPEDEF) ! 1242: || lasttk == OPERATOR ! 1243: || lasttk == NEW || in_sizeof ) ! 1244: { // must be type name, and it must be nested: ! 1245: if ( nstd->n_tbl_list == 0 ) { // only one: ok ! 1246: if (lasttk != TSCOPE && !ok ) ! 1247: error('w', "use %t:: to access nested %k %s (anachronism)", cl, ntk, nn->string); ! 1248: break; ! 1249: } ! 1250: else { ! 1251: if (lasttk != TSCOPE && !ok){ ! 1252: error("ambiguous nested type %s, use X::%s",nn->string,nn->string); ! 1253: error( 'i', "cannot recover from previous errors" ); ! 1254: } ! 1255: } ! 1256: } ! 1257: ! 1258: } ! 1259: if ( nn->n_key != NESTED ) continue; ! 1260: if (xcl && ! 1261: strcmp(xcl->string,cl->string) == 0) break; ! 1262: } // end: for nn = nstd ! 1263: ! 1264: if (nn) { ! 1265: tk = TNAME; ! 1266: yylval.pn = nn; ! 1267: if (lasttk == TYPE && ! 1268: lastval.t == TYPEDEF ) ! 1269: in_typedef = yylval.pn->tp; ! 1270: } ! 1271: } // end: if (nstd) ! 1272: } // end: if (curr_scope||ccl) ! 1273: break; ! 1274: } // end: switch tk2 ! 1275: } // end: if (tk == ID) ! 1276: } ! 1277: ! 1278: // error('d',"testing for in_expr: in_expr: %d tk: %k", in_expr, tk ); ! 1279: // error('d',"testing for in_expr: tk2: %k lasttk: %k", tk2, lasttk ); ! 1280: if (lex_level && tk==ID && tk2==LP && ! 1281: (lasttk==LC || lasttk==RC || lasttk==RP || ! 1282: lasttk == ASSIGN || lasttk == SM)) ! 1283: in_expr = 1; ! 1284: else in_expr = 0; ! 1285: ! 1286: } ! 1287: if ( tk == TNAME || ( tk == TYPE && latype(yylval.t) ) ! 1288: // XXX || tk == TSCOPE || tk == MEM ! 1289: || tk == REF || tk == DOT || tk == GOTO ! 1290: || tk == MEMPTR ) ! 1291: // TNAME cannot immediately follow a type name, ! 1292: // scope operator, right curly, selection, or goto ! 1293: must_be_id = 1; ! 1294: else ! 1295: must_be_id = 0; ! 1296: ! 1297: switch ( tk ) { ! 1298: case SM: ! 1299: mem_sel = 0; // no break ! 1300: in_expr = 0; ! 1301: case RP: case RC: must_be_expr = 0; break; ! 1302: case COLON: ! 1303: if (lasttk == RP || ! 1304: (lasttk == TYPE && lastval.t == CONST)) ! 1305: must_be_expr = 1; ! 1306: break; ! 1307: case SIZEOF: ! 1308: in_sizeof = 1; ! 1309: break; ! 1310: }; ! 1311: ret: ! 1312: if ( tk == COMPL && lasttk == TSCOPE ) ! 1313: dtor_seen = lastval.pn; ! 1314: else dtor_seen = 0; ! 1315: lasttk = tk; ! 1316: lastval = yylval; ! 1317: LDB(1,showQ("after"); ! 1318: fprintf(stderr,"returning '%s'",image(tk)); ! 1319: if ( tk==ID || tk==TNAME ) fprintf(stderr," -- '%s'",yylval.pn->string); ! 1320: fprintf(stderr,"\n"); ! 1321: ); ! 1322: // error('d',"returning tk: %k dtor_seen: %n", tk,dtor_seen ); ! 1323: return tk; ! 1324: } ! 1325: ! 1326: extern void ! 1327: la_backup( TOK t, YYSTYPE r ) ! 1328: /* ! 1329: called by parser to push token back on front of queue ! 1330: */ ! 1331: { ! 1332: LDB(1,fprintf(stderr,"\n*** la_backup( '%s', ...)\n",image(t))); ! 1333: if ( t == ID ) { Pname n = r.pn; r.s = n->string; DEL(n); } ! 1334: register toknode* T = new toknode(t,r,curloc); ! 1335: if (front) { ! 1336: front->last = T; ! 1337: T->next = front; ! 1338: T->last = 0; ! 1339: front = T; ! 1340: } else ! 1341: front = rear = T; ! 1342: lasttk = 0; ! 1343: } ! 1344: ! 1345: extern int ! 1346: la_sctype( TOK t ) ! 1347: { ! 1348: //error('d',&latok->place,"la_sctype(%k ) -- latok ==%k",t,latok->tok); ! 1349: if ( t != latok->tok && t != TSCOPE && t != MEMPTR ) ! 1350: error( 'i', &latok->place, "la_sctype, lalex.c" ); ! 1351: ! 1352: switch( latok->retval.t ) { ! 1353: case TYPEDEF: ! 1354: case EXTERN: ! 1355: case STATIC: ! 1356: case AUTO: ! 1357: case REGISTER: ! 1358: case OVERLOAD: ! 1359: case INLINE: ! 1360: case FRIEND: ! 1361: case CONST: ! 1362: case VOLATILE: ! 1363: return 1; ! 1364: default: ! 1365: return 0; ! 1366: } ! 1367: } ! 1368: ! 1369: extern int ! 1370: la_cast() ! 1371: /* ! 1372: called in reduction of term_lp to check for ambiguous prefix-style cast ! 1373: if result is 1, caller inserts DECL_MARKER to force reduction of cast ! 1374: */ ! 1375: { ! 1376: // yychar already designates TYPE or TNAME ! 1377: // LP must start the lookahead queue! ! 1378: LDB(1,fprintf(stderr,"\n*** la_cast()\n");); ! 1379: int tk, tk2 = latok->tok; ! 1380: ! 1381: for ( ; ; ) { ! 1382: tk = tk2; ! 1383: tk2 = lookahead(); ! 1384: ! 1385: switch( tk ) { ! 1386: case LP: ! 1387: if ( tk2 == MUL || tk2 == AND || ! 1388: tk2 == TSCOPE || tk2 == MEMPTR ) ! 1389: // T ( * ... ! 1390: // T ( C ::* ... ! 1391: continue; ! 1392: else ! 1393: // T ( exp ) ! 1394: return 0; ! 1395: case MUL: case AND: ! 1396: //if ( tk2 == SCTYPE ) ! 1397: if ( la_sctype( tk2 ) ) ! 1398: // T ( * const ... ! 1399: // T ( * volatile ... ! 1400: tk2 = lookahead(); ! 1401: continue; ! 1402: case TSCOPE: ! 1403: if ( tk2 == MUL ) ! 1404: // T ( C :: * ... ! 1405: continue; ! 1406: else ! 1407: // T ( exp ) ! 1408: return 0; ! 1409: case RP: case LB: ! 1410: // T (*)() ! 1411: // T (*[])() ! 1412: return 1; ! 1413: case MEMPTR: ! 1414: if ( tk2 == RP ) ! 1415: continue; ! 1416: } ! 1417: ! 1418: return 0; ! 1419: } ! 1420: } ! 1421: ! 1422: static int ! 1423: la_decl() ! 1424: /* ! 1425: handles ambiguities ! 1426: type (*x) () ! 1427: type (*x) [] ! 1428: at start of arg list / statement ! 1429: return val == 1 if lookahead finds a declaration ! 1430: (used for error messages only) ! 1431: if declaration is "ambiguous" (i.e., can't be recognized with ! 1432: 1-symbol lookahead), insert DECL_MARKER to force reduction ! 1433: of "type" ! 1434: */ ! 1435: { ! 1436: ! 1437: // LP must start the lookahead queue! ! 1438: LDB(1,fprintf(stderr,"\n*** la_decl()\n");); ! 1439: int tk, tk2 = latok->tok; ! 1440: int paren = 0; ! 1441: int ptr = 0; ! 1442: ! 1443: for ( ; ; ) { ! 1444: ! 1445: tk = tk2; ! 1446: tk2 = lookahead(); ! 1447: ! 1448: // fprintf(stderr,"\nla_decl:tk:%d %s tk2: %d %s", tk, keys[tk], tk2, keys[tk2]); ! 1449: switch( tk ) { ! 1450: case LP: ! 1451: if ( tk2 == MUL || tk2 == AND || tk2 == TSCOPE ) { ! 1452: // T ( * ... ! 1453: ++paren; ! 1454: ptr = 1; ! 1455: continue; ! 1456: } else ! 1457: if ( tk2 == MEMPTR ) { ! 1458: // T ( C ::* ... ! 1459: return 1; ! 1460: } else ! 1461: // possible redundant parens ! 1462: if ( tk2 == ID && lookahead() == RP ) { ! 1463: TOK tp = lookahead(); ! 1464: // error( 'd', "tp %k tk: %k tk2: %k", tp, tk, tk2 ); ! 1465: // error( 'd', "bl_level: %d, in_class_decl: %d", bl_level,in_class_decl ); ! 1466: if ( tp == SM || tp == CM || tp == ASSIGN ) ! 1467: { ! 1468: // member initialization list ! 1469: if ( tp != SM && in_arg_list == 0 ) return 1; ! 1470: } ! 1471: else ! 1472: if ( tp == RP && (bl_level-in_class_decl==0)) ! 1473: return 1; ! 1474: if ( tp != LP ) ! 1475: return 0; ! 1476: latok=latok->last; // restore lookahead ! 1477: ++paren; ! 1478: continue; ! 1479: } ! 1480: else ! 1481: // T ( exp ) ! 1482: return 0; ! 1483: case MUL: case AND: ! 1484: //if ( tk2 == SCTYPE ) ! 1485: if ( la_sctype( tk2 )) ! 1486: // T ( * const ... ! 1487: // T ( * volatile ... ! 1488: return 1; ! 1489: else { ! 1490: ptr = 0; ! 1491: continue; ! 1492: } ! 1493: case MEMPTR: ! 1494: // T ( C :: * ... ! 1495: return 1; ! 1496: case TSCOPE: ! 1497: if ( tk2 == MUL ) //??tk SHOULD HAVE TRANSLATED TO MEMPTR!! ! 1498: // T ( C :: * ... ! 1499: return 1; ! 1500: else if ( ptr ) ! 1501: // T ( exp ) ! 1502: return 0; ! 1503: else if ( tk2 == ID || tk2 == OPERATOR ) ! 1504: // T ( * C :: id ... ! 1505: continue; ! 1506: else ! 1507: // error ! 1508: return 0; ! 1509: } ! 1510: ! 1511: break; ! 1512: } ! 1513: ! 1514: if ( tk == RP || tk == LB ) ! 1515: // T (*)() ! 1516: // T (*[])() ! 1517: return 1; ! 1518: ! 1519: if ( tk != ID && tk != OPERATOR ) ! 1520: // T ( exp ) ! 1521: return 0; ! 1522: ! 1523: if ( tk == OPERATOR ) ! 1524: switch ( tk2 ) { ! 1525: case PLUS: case MINUS: case MUL: case REFMUL: ! 1526: case AND: case OR: case ER: case SHIFTOP: case EQUOP: ! 1527: case DIVOP: case RELOP: case ANDAND: case OROR: ! 1528: case NOT: case COMPL: case ICOP: case ASSIGN: ! 1529: case ASOP: case NEW: case GNEW: case DELETE: ! 1530: // OPERATOR oper ! 1531: tk2 = lookahead(); ! 1532: break; ! 1533: case LP: ! 1534: // OPERATOR () ! 1535: tk2 = lookahead(); ! 1536: if ( tk2 == RP ) { ! 1537: tk2 = lookahead(); ! 1538: break; ! 1539: } else ! 1540: return 0; ! 1541: case LB: ! 1542: // OPERATOR [] ! 1543: tk2 = lookahead(); ! 1544: if ( tk2 == LB ) { ! 1545: tk2 = lookahead(); ! 1546: break; ! 1547: } else ! 1548: return 0; ! 1549: default: // illegal operator ! 1550: return 0; ! 1551: } ! 1552: ! 1553: int allow_lp = 1; ! 1554: int allow_rp = 1; ! 1555: for ( ; ; ) { ! 1556: tk = tk2; ! 1557: tk2 = lookahead(); ! 1558: ! 1559: // fprintf(stderr,"\nla_decl2:tk:%d %s tk2: %d %s", tk, keys[tk], tk2, keys[tk2]); ! 1560: switch( tk ) { ! 1561: case LP: ! 1562: if ( !allow_lp ) ! 1563: // T ( * id [ exp ] ( ... ! 1564: return 0; ! 1565: ! 1566: // Current lookahead will be a decl if ! 1567: // the next lookahead is an arg decl ! 1568: if ( tk2 == RP || tk2 == ENUM || tk2==AGGR ! 1569: || tk2==ELLIPSIS || la_sctype( tk2 )) ! 1570: // T ( * id () ! 1571: // T ( * id ) () ! 1572: return 1; ! 1573: ! 1574: if ( tk2 == TYPE || tk2 == TNAME ) { ! 1575: // T ( * id ) ( T2 ... ! 1576: if ( lookahead() == LP && !la_decl() ) ! 1577: return 0; ! 1578: return 1; ! 1579: } ! 1580: ! 1581: return 0; ! 1582: case LB: ! 1583: if ( tk2 == RB || lookahead() == RB ) ! 1584: // T ( * id [] ... ! 1585: return 1; ! 1586: else { ! 1587: // T ( * id [ exp ] ... ! 1588: allow_lp = 0; ! 1589: allow_rp = 1; ! 1590: while ( lookahead() != RB ); ! 1591: tk2 = lookahead(); ! 1592: continue; ! 1593: } ! 1594: case RP: ! 1595: // error ('d', "rp: allow_rp: %d paren: %d", allow_rp, paren ); ! 1596: if ( !allow_rp || !paren ) ! 1597: // T ( * id ) ) ! 1598: return 0; ! 1599: // permit redundant parentheses ! 1600: else ! 1601: if ( tk2 == SM || tk2 == CM || tk2 == ASSIGN ) ! 1602: return 1; ! 1603: else ! 1604: if ( tk2 == RP && (bl_level-in_class_decl == 0)) ! 1605: return 1; ! 1606: else ! 1607: { ! 1608: // T ( * id ) ... ! 1609: allow_lp = 1; ! 1610: allow_rp = 0; ! 1611: --paren; ! 1612: continue; ! 1613: } ! 1614: default: ! 1615: return 0; ! 1616: } ! 1617: } ! 1618: } ! 1619: ! 1620: ! 1621: ! 1622: /* ! 1623: ** PROCESSING OF INLINE MEMBER FUNCTIONS ! 1624: */ ! 1625: static int la_snarf(); ! 1626: ! 1627: extern toknode* ! 1628: save_text() ! 1629: /* ! 1630: save text of inline def on q of class ! 1631: */ ! 1632: { ! 1633: // Q should contain at least the tokens < FDEF, X ... > ! 1634: // where X is either LC or COLON (start of ftn) ! 1635: LDB(2,fprintf(stderr,"save_text()")); ! 1636: LDB(3,fprintf(stderr,"front: %s",image(front->tok))); ! 1637: LDB(3,fprintf(stderr,"front->next: %s",image(front->next->tok))); ! 1638: latok = front->next; ! 1639: if ( la_snarf() ) { ! 1640: // append this set of tokens to ! 1641: // inline tokenq for class ! 1642: toknode* t = front; // FDEF ! 1643: if ( ccl->c_funqf == 0 ) ! 1644: ccl->c_funqf = front; ! 1645: else { ! 1646: ccl->c_funqr->next = front; ! 1647: front->last = ccl->c_funqr; ! 1648: } ! 1649: ccl->c_funqr = latok; ! 1650: front = latok->next; ! 1651: latok->next = 0; ! 1652: if (front) front->last = 0; ! 1653: return t; ! 1654: } ! 1655: return 0; ! 1656: } ! 1657: ! 1658: ! 1659: extern void ! 1660: restore_text() ! 1661: /* ! 1662: restore tokens for member inlines onto token q ! 1663: */ ! 1664: { ! 1665: LDB(2,fprintf(stderr,"restore_text()")); ! 1666: if (ccl->c_funqf == 0) // no inlines on Q ! 1667: return; ! 1668: LDB(3,fprintf(stderr," Q present: %d,%d",ccl->c_funqf,ccl->c_funqr)); ! 1669: LDB(3,fprintf(stderr," front==%s",image(ccl->c_funqf->tok))); ! 1670: LDB(3,fprintf(stderr," rear ==%s",image(ccl->c_funqr->tok))); ! 1671: ccl->c_funqr->next = front; ! 1672: if (front) front->last = ccl->c_funqr; ! 1673: front = ccl->c_funqf; ! 1674: ccl->c_funqf = ccl->c_funqr = 0; ! 1675: } ! 1676: ! 1677: ! 1678: static void ! 1679: del_tokens( toknode* marker ) ! 1680: /* ! 1681: delete tokens from marker to latok, not inclusive ! 1682: */ ! 1683: { ! 1684: if ( marker == 0 || marker == latok || marker->next == 0 ) ! 1685: error('i', "bad token queue"); ! 1686: ! 1687: LDB(2,fprintf(stderr,"del_tokens: %s..%s\n",image(marker->tok),image(latok->tok))); ! 1688: ! 1689: register toknode* tt = marker->next; ! 1690: if ( tt == latok ) return; ! 1691: marker->next = latok; ! 1692: latok->last->next = 0; ! 1693: latok->last = marker; ! 1694: register toknode* tx = tt; ! 1695: do { ! 1696: LDB(3,fprintf(stderr," deleting %s\n",image(tt->tok))); ! 1697: tx = tx->next; ! 1698: delete tt; ! 1699: tt = tx; ! 1700: } while ( tx ); ! 1701: } ! 1702: ! 1703: ! 1704: static int ! 1705: la_snarf() ! 1706: /* ! 1707: scan function def without processing declarations ! 1708: */ ! 1709: { ! 1710: LDB(2,fprintf(stderr,"la_snarf()")); ! 1711: loc *L = &latok->place; ! 1712: //DBPLACE(1,L.l,L.f); ! 1713: int parens = 0; ! 1714: int paren_error = 0; ! 1715: toknode* marker = latok; ! 1716: switch ( latok->tok ) { ! 1717: default: ! 1718: error('i', L, "bad token Q snarfing function: %d", latok->tok); ! 1719: case COLON: ! 1720: break; ! 1721: case LC: ! 1722: --bl_level; ! 1723: goto eatf; ! 1724: } ! 1725: LDB(2,fprintf(stderr,"\"eat\" member initializers")); ! 1726: for (;;) { ! 1727: if (latok->next == 0) add_tokens(); ! 1728: switch ( (latok=latok->next)->tok ) { ! 1729: case LP: ! 1730: ++parens; ! 1731: default: ! 1732: LDB(3,fprintf(stderr,"...%s",image(latok->tok))); ! 1733: continue; ! 1734: case RP: ! 1735: if ( (--parens < 0) && (paren_error++ == 0) ) ! 1736: error(0,&latok->place,"unbalanced ()"); ! 1737: continue; ! 1738: case LC: ! 1739: case RC: ! 1740: if ( parens <= 0 ) ! 1741: goto eatf; ! 1742: continue; ! 1743: case SM: ! 1744: if ( parens <= 0 ) { ! 1745: error(0, L, "illegal bit field"); ! 1746: del_tokens( front ); ! 1747: delete front; ! 1748: front = latok; ! 1749: front->last = 0; ! 1750: return 0; ! 1751: } ! 1752: continue; ! 1753: case EOFTOK: ! 1754: error('i',&latok->place,"unexpected end of file"); ! 1755: } // switch ! 1756: } // for ! 1757: ! 1758: eatf: ! 1759: int level = 1; ! 1760: for (;;) { ! 1761: if (latok->next == 0) add_tokens(); ! 1762: switch ( (latok=latok->next)->tok ) { ! 1763: case LC: ! 1764: ++level; ! 1765: default: ! 1766: LDB(3,fprintf(stderr,"...%s",image(latok->tok))); ! 1767: continue; ! 1768: case RC: ! 1769: LDB(3,fprintf(stderr,"...RC")); ! 1770: if (--level <= 0) { ! 1771: if (level < 0) { ! 1772: error(0,&latok->place,"unexpected '}'"); ! 1773: goto bad; ! 1774: } ! 1775: return 1; ! 1776: } ! 1777: break; ! 1778: case EOFTOK: ! 1779: error('e', &latok->place, "unbalanced {}"); ! 1780: goto bad; ! 1781: } // switch ! 1782: } // for ! 1783: bad: ! 1784: del_tokens( marker ); ! 1785: marker->tok = SM; ! 1786: return 0; ! 1787: } ! 1788: ! 1789: Pname check_for_nested( Pname nstd, TOK lasttk, YYSTYPE lastval, TOK tk2) ! 1790: { ! 1791: // error('d',"nstd: %n must_be_id 0 tk2: %k lasttk: %d",nstd,tk2,lasttk); ! 1792: TOK tk = ID; ! 1793: Pclass xcl = curr_scope?Pclass(Pbase(curr_scope->tp)->b_name->tp):(ccl?ccl:0); ! 1794: ! 1795: for (Pname nn=nstd; nn; nn=nn->n_tbl_list) { ! 1796: TOK ntk; ! 1797: bit ok = 0; ! 1798: Ptype tt = return_nstd_local_type(nn,ntk); ! 1799: Pclass cl = tt->in_class; ! 1800: if ( xcl ) { ! 1801: if (xcl==cl || xcl->has_base(cl)) ! 1802: ok++; ! 1803: else { ! 1804: for (Pclass eccl=xcl->in_class;eccl;eccl=eccl->in_class) ! 1805: if ( eccl == cl ) { ok++; break; } ! 1806: } ! 1807: } ! 1808: ! 1809: if (nn == nstd) ! 1810: { ! 1811: if ( ((in_arg_list || lasttk==LP) && // foo(nestedX ! 1812: (tk2==CM || tk2==ASSIGN || tk2==RP)) ! 1813: || (tk2==LC && (lasttk==PR || lasttk==VIRTUAL)) ! 1814: || (tk2 == MUL || tk2==AND) ! 1815: || (lasttk==LP && tk2==RP) ! 1816: || (lasttk==TSCOPE && lastval.pn == nn) ! 1817: || (lasttk==COMPL && dtor_seen == nn) ! 1818: || (lasttk==TYPE && lastval.t == TYPEDEF) ! 1819: || lasttk == NEW || in_sizeof ) ! 1820: { ! 1821: if ( nstd->n_tbl_list == 0 ) { // only one: ok ! 1822: break; ! 1823: } else { ! 1824: if (lasttk != TSCOPE && !ok){ ! 1825: error("ambiguous nested type %s, use X::%s",nn->string,nn->string); ! 1826: error( 'i', "cannot recover from previous errors" ); ! 1827: } ! 1828: } ! 1829: } ! 1830: } ! 1831: if ( nn->n_key != NESTED ) continue; ! 1832: if (xcl && strcmp(xcl->string,cl->string) == 0) break; ! 1833: } // end: for nn = nstd ! 1834: return nn; ! 1835: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.