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