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