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