![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to print2.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 print2.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / optcfront |
1.1 ! root 1: /*ident "@(#)ctrans:src/print2.c 1.6" */ ! 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: print2.c: ! 11: ! 12: print names and declarations ! 13: ! 14: ****************************************************************************/ ! 15: ! 16: #include "cfront.h" ! 17: #include "template.h" ! 18: ! 19: bit Cast; ! 20: int last_ll = 1; ! 21: Pin curr_icall; ! 22: char emode; ! 23: int ntok; ! 24: ! 25: static int MAIN; // fudge to get _main() called by main() ! 26: ! 27: #define eprint(e) if (e) Eprint(e) ! 28: ! 29: #ifdef DENSE ! 30: void chop(char*); ! 31: #endif ! 32: ! 33: void puttok(TOK t) ! 34: /* ! 35: print the output representation of "t" ! 36: */ ! 37: { ! 38: // if (t<=0 || MAXTOK<t) error("illegal token %d",t); ! 39: // char* s = keys[t]; ! 40: // if (s == 0) error("V representation token %d",t); ! 41: ! 42: putstring(keys[t]); ! 43: ! 44: if (12<ntok++) { ! 45: ntok = 0; ! 46: last_line.putline(); ! 47: } ! 48: else if (t == SM) { ! 49: ntok = 0; ! 50: putch('\n'); ! 51: if (last_ll) last_line.line++; ! 52: } ! 53: else ! 54: putch(' '); ! 55: } ! 56: ! 57: #define MX 20 ! 58: #define NTBUF 10 ! 59: class dcl_buf { ! 60: /* ! 61: buffer for assembling declaration (or cast) ! 62: left contains CONST_PTR => *CONST ! 63: CONST_RPTR => &CONST ! 64: PTR => * ! 65: RPTR => & ! 66: LP => ( ! 67: right contains RP => ) ! 68: VEC => [ rnode ] ! 69: FCT => ( rnode ) ! 70: FIELD => : rnode ! 71: */ ! 72: Pbase b; ! 73: Pname n; ! 74: TOK left[MX], right[MX]; ! 75: Pnode rnode[MX]; ! 76: Pclass lnode[MX]; ! 77: int li, ri; ! 78: public: ! 79: void init(Pname nn) { b=0; n=nn; li=ri=0; } ! 80: void base(Pbase bb) { b = bb; } ! 81: void front(TOK t) { left[++li] = t; } ! 82: void front(Pclass c) { left[++li] = MEMPTR; lnode[li] = c; } ! 83: void back(TOK t, Pnode nod) { right[++ri] = t; rnode[ri] = nod; } ! 84: void paran() { front(LP); back(RP,0); } ! 85: void put(); ! 86: } *tbufvec[NTBUF] = {0}, *tbuf = 0; ! 87: ! 88: int freetbuf = 0; ! 89: ! 90: void dcl_buf::put() ! 91: { ! 92: int i; ! 93: Pfct ff = 0; ! 94: ! 95: if (MX<=li || MX<=ri) error('i',"T buffer overflow"); ! 96: if (b == 0) error('i',"noBT%s",Cast?" in cast":""); ! 97: ! 98: if (n && n->n_sto && n->n_sto!=REGISTER) puttok(n->n_sto); ! 99: ! 100: b->dcl_print(); ! 101: ! 102: for( ; li; li--) { ! 103: switch (left[li]) { ! 104: case LP: ! 105: putch('('); ! 106: break; ! 107: case PTR: ! 108: putch('*'); ! 109: break; ! 110: case RPTR: ! 111: if (emode) ! 112: putch('&'); ! 113: else ! 114: putch('*'); ! 115: break; ! 116: case CONST_PTR: ! 117: if (emode) ! 118: putstring("*const "); ! 119: else ! 120: putch('*'); ! 121: break; ! 122: case CONST_RPTR: ! 123: if (emode) ! 124: putstring("&const "); ! 125: else ! 126: putch('*'); ! 127: break; ! 128: case MEMPTR: ! 129: if (lnode[li]) fprintf(out_file,"%s::",lnode[li]->string); ! 130: } ! 131: } ! 132: ! 133: if (n) n->print(); ! 134: ! 135: for(i=1; i<=ri; i++) { ! 136: switch (right[i]) { ! 137: case RP: ! 138: putch(')'); ! 139: break; ! 140: case VEC: ! 141: putch('['); ! 142: { Pvec v = (Pvec) rnode[i]; ! 143: Pexpr d = v->dim; ! 144: int s = v->size; ! 145: if (d) d->print(); ! 146: if (s) fprintf(out_file,"%d",s); ! 147: } ! 148: putch(']'); ! 149: break; ! 150: case FCT: // beware of function returning pointer to ! 151: // function expressed witout typedef ! 152: { Pfct f = Pfct(rnode[i]); ! 153: if (f->body) ff = f; ! 154: f->dcl_print(); ! 155: break; ! 156: } ! 157: case FIELD: ! 158: { Pbase f = (Pbase) rnode[i]; ! 159: Pexpr d = (Pexpr)f->b_name; ! 160: int s = f->b_bits; ! 161: putch(':'); ! 162: if (d) ! 163: d->print(); ! 164: else if (s) ! 165: fprintf(out_file,"%d",s); ! 166: else ! 167: puttok(ZERO); ! 168: break; ! 169: } ! 170: } ! 171: } ! 172: void print_body(Pfct); ! 173: if (ff && emode==0) print_body(ff); ! 174: } ! 175: ! 176: static Pexpr mk_zero_init( Ptype tt, Pname obname, Pname currname ) ! 177: /* ! 178: creates 0 initializer for defined objects ! 179: side effect: generates right nesting level for {} ! 180: */ ! 181: { ! 182: zaq: ! 183: switch (tt->base) { ! 184: case TYPE: ! 185: tt = Pbase(tt)->b_name->tp; goto zaq; ! 186: case VEC: // type a[size]; => type a[size] = {0}; ! 187: { ! 188: if ( obname == currname ) { ! 189: //xxx initializing vectors blows up the size of some programs ! 190: return 0; ! 191: } else { ! 192: Pexpr i = mk_zero_init(Pvec(tt)->typ,obname,currname); ! 193: if ( i == 0 ) return 0; ! 194: return new expr( ILIST, i, 0 ); ! 195: } ! 196: } ! 197: case COBJ: // "X a;" == "X a = {0};" ! 198: { ! 199: Pclass cl = Pclass(Pbase(tt)->b_name->tp); ! 200: if ( !ansi_opt && (cl->csu == ANON || cl->csu == UNION) ) { ! 201: if ( warning_opt ) { ! 202: // ridiculous handstands to avoid printing ! 203: // compiler generated names in warning ! 204: Ptype tn = obname->tp; ! 205: for(;;) if(tn->base==VEC) tn=Pvec(tn)->typ; else break; ! 206: if ( obname == currname && tt == tn ) { ! 207: if ( cl->string[0]=='_' && cl->string[1]=='_' ) ! 208: error('w',&obname->where,"cannot generate zeroIr for%n ofT union; toI, compile with +a1 or insert non-union object as first member",obname); ! 209: else ! 210: error('w',&obname->where,"cannot generate zeroIr for%n ofT%t; toI, compile with +a1 or insert non-union object as first member",obname,obname->tp); ! 211: } else { Pclass cx; ! 212: if ( tn->base == COBJ ! 213: && (cx=(Pclass)Pbase(tn)->b_name->tp, ! 214: cx->string[0]=='_' && cx->string[1]=='_') ) ! 215: error('w',&obname->where,"cannot generate zeroIr for%n (union or aggregate with union as first element); toI, compile with +a1 or insert non-union object as first member",obname); ! 216: else ! 217: error('w',&obname->where,"cannot generate zeroIr for%n ofT%t (union or aggregate with union as first element); toI, compile with +a1 or insert non-union object as first member",obname,obname->tp); ! 218: } ! 219: } // if warning_opt ! 220: return 0; ! 221: } ! 222: Pbcl l = cl->baselist; ! 223: while ( l ) { ! 224: if ( l->base == NAME ) cl = l->bclass; ! 225: else return new expr(ILIST,zero,0); ! 226: l = cl->baselist; ! 227: } ! 228: int i = 1; ! 229: Pname nn = cl->memtbl->get_mem(i); ! 230: for ( ; nn; nn = cl->memtbl->get_mem(++i) ) { ! 231: Ptype tx = nn->tp; ! 232: while ( tx->base == TYPE ) tx = Pbase(tx)->b_name->tp; ! 233: if (nn->base==NAME ! 234: && nn->n_union==0 ! 235: && tx->base!=FCT ! 236: && tx->base!=OVERLOAD ! 237: && tx->base!=CLASS ! 238: && tx->base!=ENUM ! 239: && nn->n_stclass != STATIC) { ! 240: Pexpr i = mk_zero_init(tx,obname,nn); ! 241: if ( i == 0 ) return 0; ! 242: return new expr(ILIST,i,0); ! 243: } ! 244: } ! 245: return 0; ! 246: } ! 247: case PTR: ! 248: if (tt->memptr()) { ! 249: Pexpr i = new expr(ELIST,zero,zero); ! 250: return new expr(ILIST,i,zero); ! 251: } ! 252: // no break ! 253: case RPTR: ! 254: case CHAR: ! 255: case SHORT: ! 256: case INT: ! 257: case EOBJ: ! 258: case LONG: ! 259: case FLOAT: ! 260: case DOUBLE: ! 261: case LDOUBLE: // "int a;" == "int a = 0;" ! 262: case FIELD: ! 263: case ANY: ! 264: return zero; ! 265: } ! 266: return 0; ! 267: } ! 268: ! 269: void name::dcl_print(TOK list) ! 270: /* ! 271: Print the declaration for a name (list==0) or a name list (list!=0): ! 272: For each name ! 273: (1) print storage class ! 274: (2) print base type ! 275: (3) print the name with its declarators ! 276: Avoid (illegal) repetition of basetypes which are class or enum declarations ! 277: (A name list may contain names with different base types) ! 278: list == SM : terminator SM ! 279: list == 0: single declaration with terminator SM ! 280: list == CM : separator CM ! 281: */ ! 282: { ! 283: if (error_count) return; ! 284: ! 285: for (Pname n=this; n; n=n->n_list) { ! 286: Ptype t = n->tp; ! 287: int sm = 0; ! 288: ! 289: // error('d',"%s->dcl_print() tp %t sto %k",n->string,t,n->n_sto); ! 290: if (t == 0) error('i',"N::dcl_print(%n)T missing",n); ! 291: ! 292: if (n->n_stclass==ENUM) if (list) continue; else return; ! 293: ! 294: if (n->where.line!=last_line.line || n->where.file!=last_line.file) ! 295: //fprintf(stderr,"%s ",n->string?n->string:"<0>"); n->where.put(stderr); fprintf(stderr," last "); last_line.put(stderr); putc('\n',stderr); ! 296: if (last_ll = n->where.line) ! 297: n->where.putline(); ! 298: else ! 299: last_line.putline(); ! 300: ! 301: int tc = Pbase(t)->b_const; ! 302: for (Ptype tt = t; tt->base==TYPE; tt = Pbase(tt)->b_name->tp) ! 303: tc |= Pbase(tt)->b_const; ! 304: ! 305: switch (t->base) { ! 306: case CLASS: ! 307: //fprintf(stderr,"class %s->dcl_print()\n",n->string); ! 308: if (n->base != TNAME) { ! 309: Pclass(t)->dcl_print(n); ! 310: sm = 1; ! 311: } ! 312: break; ! 313: ! 314: case ENUM: ! 315: Penum(t)->dcl_print(0); ! 316: sm = 1; ! 317: break; ! 318: ! 319: case FCT: ! 320: { Pfct f = Pfct(t); ! 321: ! 322: if (n->base == TNAME) puttok(TYPEDEF); ! 323: ! 324: // error('d',"fct %n->dcl_print() printed %d body %d defined %d",n,n->n_dcl_printed,f->body,f->defined); ! 325: // error('d',"n %d tbl %d tp %t inline %d",n,n->n_table,n->tp,f->f_inline); ! 326: if (n->n_dcl_printed==2 // definition already printed ! 327: || (n->n_dcl_printed==1 && f->body==0) ! 328: // declaration already printed ! 329: ) { ! 330: // don't print again ! 331: sm = 1; // no SM ! 332: break; ! 333: } ! 334: ! 335: if (f->f_result == 0) make_res(f); ! 336: ! 337: if (f->body && n->n_sto==EXTERN) n->n_sto = 0; ! 338: ! 339: if (f->f_inline && ((n->n_table!=gtbl) || strcmp(n->string,"main"))) { ! 340: if (debug_opt) { ! 341: //error('d',"f %t defined %d inline %d",f,f->defined,f->f_inline); ! 342: if (f->defined&DEFINED ! 343: && f->defined&SIMPLIFIED ! 344: && f->f_inline!=ITOR) ! 345: goto prnt_def; ! 346: else if (n->n_dcl_printed==0) ! 347: goto prnt_dcl; ! 348: else { ! 349: sm = 1; ! 350: break; ! 351: } ! 352: } ! 353: if (f->f_virtual || n->n_addr_taken) { ! 354: prnt_dcl: ! 355: //error('d',"prnt_dcl %d %n %k",n,n,n->n_sto); ! 356: TOK st = n->n_sto; ! 357: Pblock b = f->body; ! 358: f->body = 0; ! 359: t->dcl_print(n); ! 360: n->n_dcl_printed = 1; ! 361: n->n_sto = st; ! 362: f->body = b; ! 363: break; ! 364: } ! 365: else ! 366: sm = 1; // no SM ! 367: } ! 368: else if ((f->defined&DEFINED)==0 ! 369: || (f->defined&SIMPLIFIED)==0) ! 370: goto prnt_dcl; ! 371: else if (n->n_table==gtbl && strcmp(n->string,"main")==0) { ! 372: if (f->f_inline) { ! 373: if (warning_opt) { ! 374: error('w',"main() cannot be inlined"); ! 375: error('w',"out-of-line copy of main() created"); ! 376: } ! 377: n->n_sto=0; ! 378: } ! 379: MAIN = 1; ! 380: gtbl->look("main",0)->use(); ! 381: f->f_signature = 0; ! 382: t->dcl_print(n); ! 383: n->n_dcl_printed = f->body?2:1; ! 384: MAIN = 0; ! 385: } ! 386: else { ! 387: prnt_def: ! 388: // error('d',"prnt_def %n %k %d %k",n,n->n_oper,n,n->n_sto); ! 389: if (n->n_oper==CTOR || n->n_oper==DTOR) { ! 390: Pclass cl = Pclass(n->n_table->t_name->tp); ! 391: if (cl->c_body == 3) cl->print_all_vtbls(cl); ! 392: } ! 393: ! 394: if ( n->n_sto == STATIC && ! 395: pdef_name == 0 && def_name == 0 ) { ! 396: // error('d', "printing ptbl_vec without first definition" ); ! 397: pdef_name = n; ! 398: ptbl_init(0); ! 399: } ! 400: t->dcl_print(n); ! 401: n->n_dcl_printed = f->body?2:1; ! 402: } ! 403: if (f->body) sm = 1; ! 404: break; ! 405: } ! 406: ! 407: case OVERLOAD: ! 408: { ! 409: for (Plist gl=Pgen(t)->fct_list; gl; gl=gl->l) { ! 410: Pname nn = gl->f; ! 411: Pfct f=(Pfct) nn->tp; ! 412: if (f->defined) nn->dcl_print(0); ! 413: sm = 1; ! 414: } ! 415: break; ! 416: } ! 417: ! 418: case ASM: ! 419: fprintf(out_file,"asm(\"%s\")\n",(char*)Pbase(t)->b_name); ! 420: break; ! 421: ! 422: case INT: ! 423: case EOBJ: ! 424: case CHAR: ! 425: case LONG: ! 426: case SHORT: ! 427: tcx: ! 428: // do not allocate space for constants unless necessary ! 429: if (tc ! 430: && n->n_sto!=EXTERN // extern const one; ! 431: // const one = 1; ! 432: // allocates storage ! 433: && (n->n_scope==EXTERN // FUDGE const one = 1; ! 434: // is treated as static ! 435: // need loader support ! 436: || n->n_scope==STATIC ! 437: || n->n_scope==FCT) ! 438: ) { ! 439: if (n->n_evaluated && n->n_addr_taken==0) { ! 440: sm = 1; /* no ; */ ! 441: break; ! 442: } ! 443: } ! 444: tc = 0; ! 445: // no break; ! 446: ! 447: default: ! 448: { ! 449: /* ! 450: // don't print local instance of const ! 451: if ( n->n_dcl_printed == 3 ) { ! 452: sm = 1; ! 453: break; ! 454: } ! 455: */ ! 456: Pexpr i = n->n_initializer; ! 457: if (n->base == TNAME && n->n_key == NESTED) i = 0; ! 458: if (tc) { ! 459: switch (tt->base) { ! 460: case CHAR: ! 461: case SHORT: ! 462: case INT: ! 463: case LONG: ! 464: case EOBJ: ! 465: goto tcx; ! 466: } ! 467: } ! 468: ! 469: if (n->base == TNAME) { ! 470: /* Always print template formals, even when they have the same ! 471: * formal name, since the instantiation name is different. This ! 472: * fix should not be required when the copy mechanism is in place. */ ! 473: if (! n_template_arg) ! 474: for (Pname tn=ktbl->look(n->string,HIDDEN); tn; tn=tn->n_tbl_list) ! 475: if (tn && tn->lex_level && t==tn->tp) return; ! 476: puttok(TYPEDEF); ! 477: } ! 478: ! 479: if (n->n_stclass == REGISTER) { ! 480: // (imperfect) check against member functions ! 481: // register s a; a.f() illegal ! 482: Pname cln = n->tp->is_cl_obj(); ! 483: if (cln) { ! 484: Pclass cl = Pclass(cln->tp); ! 485: if (cl->csu!=CLASS ! 486: && cl->baselist==0 ! 487: && cl->has_itor()==0 ! 488: && cl->virt_count==0) puttok(REGISTER); ! 489: } ! 490: else ! 491: puttok(REGISTER); ! 492: } ! 493: ! 494: if (i) { ! 495: if (n->n_sto==EXTERN && n->n_stclass==STATIC) { ! 496: n->n_initializer = 0; ! 497: t->dcl_print(n); ! 498: puttok(SM); ! 499: n->n_initializer = i; ! 500: n->n_sto = 0; ! 501: t->dcl_print(n); ! 502: n->n_sto = EXTERN; ! 503: } ! 504: else ! 505: t->dcl_print(n); ! 506: if(n->n_table) { ! 507: Pname nn = n->n_table->look(n->string,0); ! 508: if(nn) ! 509: nn->n_dcl_printed = 1; ! 510: else ! 511: n->n_dcl_printed = 1; ! 512: } ! 513: else ! 514: n->n_dcl_printed = 1; ! 515: } ! 516: else if (n->n_evaluated && Pbase(t)->b_const) { ! 517: if (n->n_sto==EXTERN && n->n_stclass==STATIC) { ! 518: int v = n->n_evaluated; ! 519: n->n_evaluated = 0; ! 520: t->dcl_print(n); ! 521: puttok(SM); ! 522: if (n->where.line!=last_line.line || n->where.file!=last_line.file) ! 523: if (last_ll = n->where.line) ! 524: n->where.putline(); ! 525: else ! 526: last_line.putline(); ! 527: n->n_evaluated = v; ! 528: n->n_sto = 0; ! 529: t->dcl_print(n); ! 530: n->n_sto = EXTERN; ! 531: } ! 532: else ! 533: t->dcl_print(n); ! 534: if(n->n_table) { ! 535: Pname nn = n->n_table->look(n->string,0); ! 536: if(nn) ! 537: nn->n_dcl_printed = 1; ! 538: else ! 539: n->n_dcl_printed = 1; ! 540: } ! 541: else ! 542: n->n_dcl_printed = 1; ! 543: } ! 544: else { ! 545: //error('d',"%n sto %k val %d stc %k",n,n->n_sto,n->n_val,n_stclass); ! 546: if ((n->n_sto==0 || (n->n_val && n->n_evaluated==0)) ! 547: && n_stclass==STATIC ! 548: && n->n_sto!=STATIC ! 549: && n->n_table==gtbl) { ! 550: if (n->n_val && n->n_evaluated==0) { ! 551: // extern x = f(); ! 552: // generate int x = 0; ! 553: // plus dynamic initialization ! 554: n->n_sto = 0; ! 555: } ! 556: ! 557: n->n_initializer = i = mk_zero_init(t,n,n); ! 558: } ! 559: t->dcl_print(n); ! 560: if(n->n_table) { ! 561: Pname nn = n->n_table->look(n->string,0); ! 562: if(nn) ! 563: nn->n_dcl_printed = 1; ! 564: else ! 565: n->n_dcl_printed = 1; ! 566: } ! 567: else ! 568: n->n_dcl_printed = 1; ! 569: } ! 570: ! 571: if (n->n_scope!=ARG) { ! 572: if (i) { ! 573: puttok(ASSIGN); ! 574: ! 575: Pexpr i2 = i; ! 576: while (i2->base == CAST) i2 = i2->e1; ! 577: if (i2->base == ILIST) i = i2; ! 578: if (t!=i->tp ! 579: && i->base!=ZERO ! 580: && i->base!=ILIST /*&& i->tp!=Pchar_type*/) { ! 581: Ptype t1 = n->tp; ! 582: cmp: ! 583: switch (t1->base) { ! 584: case TYPE: ! 585: t1 = Pbase(t1)->b_name->tp; ! 586: goto cmp; ! 587: default: ! 588: i->print(); ! 589: break; ! 590: // case EOBJ: ! 591: // goto cst; ! 592: case VEC: ! 593: if (Pvec(t1)->typ->base==CHAR) { ! 594: i->print(); ! 595: break; ! 596: } ! 597: // no break ! 598: case PTR: ! 599: case RPTR: ! 600: if (i->tp==0 || n->tp->check(i->tp,0)) { ! 601: // cst: ! 602: putch('('); ! 603: bit oc = Cast; ! 604: Cast = 1; ! 605: t->print(); ! 606: Cast = oc; ! 607: putch(')'); ! 608: } ! 609: eprint(i); ! 610: } ! 611: } ! 612: else { ! 613: if (i==zero) { ! 614: while (t->base == TYPE) t = Pbase(t)->b_name->tp; ! 615: // if (t->base == EOBJ) { ! 616: // putch('('); ! 617: // bit oc = Cast; ! 618: // Cast = 1; ! 619: // t->print(); ! 620: // Cast = oc; ! 621: // putch(')'); ! 622: // } ! 623: } ! 624: eprint(i); ! 625: ! 626: // i->print(); ! 627: } ! 628: } ! 629: else if (n->n_evaluated) { ! 630: puttok(ASSIGN); ! 631: if (n->tp->base!=INT || n->tp->is_unsigned()) { ! 632: putstring("(("); ! 633: bit oc = Cast; ! 634: Cast = 1; ! 635: n->tp->print(); ! 636: Cast = oc; ! 637: fprintf(out_file,")%d)",n->n_val); ! 638: } ! 639: else ! 640: fprintf(out_file,"%d",n->n_val); ! 641: } ! 642: } ! 643: } ! 644: } ! 645: ! 646: switch (list) { ! 647: case SM: ! 648: if (sm==0) puttok(SM); ! 649: break; ! 650: case 0: ! 651: if (sm==0) puttok(SM); ! 652: return; ! 653: case CM: ! 654: if (n->n_list) puttok(CM); ! 655: break; ! 656: } ! 657: } ! 658: } ! 659: ! 660: char *local_sign( Ptype pt ) ! 661: { // get function signature for local class ! 662: char buf[1024]; ! 663: char* bb = pt->signature(buf); ! 664: int ll = bb-buf; ! 665: if (1023 < ll) error('i',"local class N buffer overflow"); ! 666: char *p = new char[ll+1]; ! 667: strcpy(p,buf); ! 668: return p; ! 669: } ! 670: ! 671: void enumdef::dcl_print(Pname cln) ! 672: /* ! 673: */ ! 674: { ! 675: // note: ***** modify to handle local enums ! 676: // error('d', "%t::dcl_print(%n) in_class: %t nested_sig: %s", this, cln, in_class, nested_sig ); ! 677: char* s = nested_sig?nested_sig:(cln ? cln->string:0); ! 678: if ( nested_sig ) ! 679: fprintf(out_file,"enum __%s { ",nested_sig); ! 680: else fprintf(out_file,"enum %s { ",string); ! 681: ! 682: for (Pname px, p=mem; p; p=px) { ! 683: px = p->n_list; ! 684: if (s) { ! 685: if (p->n_evaluated) ! 686: fprintf(out_file,"%s__%s = %d",p->string,s,p->n_val); ! 687: else ! 688: fprintf(out_file,"%s__%s",p->string,s); ! 689: } ! 690: else { ! 691: if (p->n_evaluated) ! 692: fprintf(out_file,"%s = %d",p->string,p->n_val); ! 693: else ! 694: fprintf(out_file,"%s",p->string); ! 695: } ! 696: if (px) puttok(CM); ! 697: p->n_initializer = 0; ! 698: delete p; ! 699: } ! 700: mem = 0; ! 701: puttok(RC); ! 702: puttok(SM); ! 703: } ! 704: ! 705: void name::print() ! 706: { // print just the name itself ! 707: if (this == 0) error('i',"0->N::print()"); ! 708: if (string == 0) { ! 709: if (emode) putch('?'); ! 710: return; ! 711: } ! 712: ! 713: // error( 'd', "%s->name::print(), base: %k", string, base ); ! 714: switch (base) { ! 715: case TNAME: ! 716: if (n_key == NESTED && tpdef && ! 717: tpdef->nested_sig) { ! 718: if ( emode == 0 ) { ! 719: putstring( " __" ); ! 720: putst(tpdef->nested_sig); ! 721: } ! 722: else { ! 723: putst(tpdef->in_class->string); ! 724: putstring( "::" ); ! 725: putst(string); ! 726: } ! 727: return; ! 728: } ! 729: ! 730: if (emode && tp) { ! 731: if (n_template_arg_string) { ! 732: tp->dcl_print(0); return; ! 733: } else ! 734: if(tp->base == COBJ) { ! 735: Pclass cl = Pclass(Pbase(tp)->b_name->tp); ! 736: if(cl && cl->base == CLASS && ! 737: (cl->class_base == instantiated_template_class)) { ! 738: Ptclass(cl)->inst->print_pretty_name(); return; ! 739: } ! 740: } ! 741: } ! 742: ! 743: putst(n_template_arg_string ? n_template_arg_string : string); ! 744: return; ! 745: ! 746: case MDOT: ! 747: Pexpr(this)->print(); ! 748: return; ! 749: } ! 750: ! 751: if (emode) { ! 752: Ptable tbl; ! 753: char* cs = 0; ! 754: bit f = 0; ! 755: if (tp) { ! 756: switch (tp->base) { ! 757: case OVERLOAD: ! 758: case FCT: ! 759: f = 1; ! 760: default: ! 761: if (tbl=n_table) { ! 762: if (tbl == gtbl) { ! 763: if (f == 0) putstring("::"); ! 764: } ! 765: else { ! 766: if (tbl->t_name) { ! 767: Ptclass pc = Ptclass(tbl->t_name->tp); ! 768: cs = tbl->t_name->string; ! 769: if ((pc->base == CLASS) && ! 770: (pc->class_base == instantiated_template_class)) ! 771: pc->inst->print_pretty_name(); ! 772: else fprintf(out_file,"%s",cs); ! 773: fprintf (out_file, "::") ; ! 774: } ! 775: } ! 776: } ! 777: ! 778: if (n_scope==ARG && strcmp(string,"this")==0) { ! 779: // tell which "this" it is ! 780: Ptype tt = Pptr(tp)->typ; ! 781: Pname cn = Pbase(tt)->b_name; ! 782: fprintf(out_file,"%s::",cn->string); ! 783: } ! 784: ! 785: case CLASS: ! 786: case ENUM: ! 787: // case TYPE: ! 788: break; ! 789: } ! 790: nop: ! 791: switch (n_oper) { ! 792: case TYPE: ! 793: putstring("operator "); ! 794: if (tp) Pfct(tp)->returns->dcl_print(0); ! 795: break; ! 796: case 0: ! 797: putstring(string); ! 798: break; ! 799: case DTOR: ! 800: putch('~'); ! 801: case CTOR: ! 802: if (cs) { ! 803: if(tbl->t_name) { ! 804: Ptclass pc = Ptclass(tbl->t_name->tp); ! 805: if ((pc->base == CLASS) && ! 806: (pc->class_base == instantiated_template_class)) ! 807: pc->inst->print_pretty_name(); ! 808: else putstring(cs); ! 809: } ! 810: } ! 811: else { ! 812: if (string) ! 813: fprintf(out_file,"%s()", n_template_arg_string ! 814: ? n_template_arg_string : string); ! 815: else putstring("constructor"); ! 816: f = 0; ! 817: } ! 818: break; ! 819: case TNAME: ! 820: putstring(string); ! 821: break; ! 822: default: ! 823: putstring("operator "); ! 824: putstring(keys[n_oper]); ! 825: break; ! 826: } ! 827: if (f) putstring("()"); ! 828: } ! 829: else { ! 830: if (n_oper) goto nop; ! 831: if (string) ! 832: putstring(n_template_arg_string ! 833: ? n_template_arg_string : string); ! 834: } ! 835: return; ! 836: } ! 837: ! 838: char* sig = 0; ! 839: Pclass cl = 0; ! 840: Penum en = 0; ! 841: int i = n_union; ! 842: ! 843: if (tp) { ! 844: Ptable tbl; ! 845: ! 846: switch (tp->base) { ! 847: default: ! 848: if (tbl=n_table) { // global or member ! 849: Pname tn; ! 850: if (tbl == gtbl) { ! 851: // if (i) fprintf(out_file,"__O%d.",i); ! 852: if ( i ) { ! 853: if (n_anon) ! 854: fprintf(out_file,"__O%d.%s.", i, n_anon ); ! 855: else fprintf(out_file,"__O%d.",i); ! 856: } ! 857: break; ! 858: } ! 859: ! 860: if (tn=tbl->t_name) { ! 861: cl = Pclass(tn->tp); ! 862: if (i) { ! 863: if (cl->string[0]=='_' ! 864: && cl->string[1]=='_' ! 865: && cl->string[2]=='C' ) { ! 866: if (n_anon) ! 867: fprintf(out_file,"__O%d.%s.", i, n_anon ); ! 868: else fprintf(out_file,"__O%d.",i); ! 869: } ! 870: else ! 871: if ( cl->nested_sig ) ! 872: fprintf(out_file,"__O%d__%s.",i,cl->nested_sig); ! 873: else ! 874: if ( cl->lex_level ) { ! 875: char *str = make_local_name(cl,1); ! 876: fprintf(out_file,"__O%d%s.",i,str); ! 877: delete str; ! 878: } ! 879: else fprintf(out_file,"__O%d__%d%s.",i,cl->strlen,cl->string); ! 880: cl = 0; ! 881: } ! 882: else ! 883: if (cl->string[0]=='_' ! 884: && cl->string[1]=='_' ! 885: && cl->string[2]=='C' ! 886: && n_stclass != STATIC ) ! 887: cl = 0; ! 888: break; ! 889: } ! 890: } ! 891: ! 892: switch (n_stclass) { // local variable ! 893: case STATIC: ! 894: case EXTERN: ! 895: if (i) ! 896: fprintf(out_file,"__O%d.",i); ! 897: else if (n_sto==STATIC && tp->base!=FCT) { ! 898: if (lex_level == 0) ! 899: putstring("__S"); ! 900: else ! 901: fprintf(out_file,"__%d",lex_level); ! 902: } ! 903: break; ! 904: default: ! 905: // encode with lexical level UNLESS ``special'' ! 906: // e.g. __builtin ! 907: if (string[0]!='_' || string[1]!='_' || string[2] != 'C' ) { ! 908: if (i) ! 909: { ! 910: if (n_anon) ! 911: fprintf(out_file,"__%d__O%d.%s.",lex_level-1,i,n_anon); ! 912: else fprintf(out_file,"__%d__O%d.",lex_level-1,i); ! 913: } ! 914: else ! 915: fprintf(out_file,"__%d",lex_level); ! 916: } ! 917: } ! 918: break; ! 919: case CLASS: ! 920: case ENUM: ! 921: if (tp->in_class && tp->nested_sig) en = Penum(tp); ! 922: break; ! 923: } ! 924: ! 925: if (tp->base==FCT) { ! 926: sig = Pfct(tp)->f_signature; ! 927: if (sig && sig[0]==0) sig = 0; ! 928: } ! 929: } ! 930: ! 931: if (string) { ! 932: #ifdef DENSE ! 933: int i = strlen(string); ! 934: if (cl) i += cl->strlen+4; // __dd<class name> ! 935: if (sig) { ! 936: if (cl == 0) i += 2; ! 937: i += strlen(sig); ! 938: } ! 939: ! 940: if (31<i) { ! 941: char buf[256]; ! 942: if (cl && sig) ! 943: sprintf(buf,"%s__%d%s%s",string,cl->strlen,cl->string,sig); ! 944: else if (cl) ! 945: sprintf(buf,"%s__%d%s",string,cl->strlen,cl->string); ! 946: else if (sig) ! 947: sprintf(buf,"%s__%s",string,sig); ! 948: else ! 949: sprintf(buf,"%s",string); ! 950: chop(buf); ! 951: fprintf(out_file,"%s ",buf); ! 952: return; ! 953: } ! 954: #endif ! 955: ! 956: if ( en ) ! 957: fprintf(out_file,"__%s", en->nested_sig); ! 958: else ! 959: putstring(n_template_arg_string ! 960: ? n_template_arg_string : string); ! 961: ! 962: if ( cl ) { ! 963: if ( cl->nested_sig ) ! 964: fprintf(out_file,"__%s",cl->nested_sig); ! 965: else ! 966: if ( cl->lex_level ) { ! 967: char *str = make_local_name( cl, 1 ); ! 968: putstring( str ); ! 969: delete str; ! 970: } ! 971: else fprintf(out_file,"__%d%s",cl->strlen,cl->string); ! 972: } ! 973: ! 974: if (sig) { ! 975: if (cl == 0) putstring("__"); ! 976: putstring(sig); ! 977: } ! 978: putch(' '); ! 979: } ! 980: } ! 981: ! 982: #ifdef DENSE ! 983: void chop(char* buf) ! 984: { ! 985: static char alpha[] = "_0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; ! 986: static const asz = sizeof(alpha)-1; ! 987: int hash = 0; ! 988: char* p = &buf[29]; ! 989: ! 990: while (*p) { ! 991: hash <<= 1; ! 992: if (hash & (1<<12)) { ! 993: hash &= ~(1<<12); ! 994: hash++; ! 995: } ! 996: hash ^= *p++; ! 997: } ! 998: ! 999: buf[29] = alpha[(int)(hash%asz)]; ! 1000: buf[30] = alpha[(int)((hash/asz)%asz)]; ! 1001: buf[31] = 0; ! 1002: } ! 1003: #endif ! 1004: ! 1005: void type::print() ! 1006: { ! 1007: switch (base) { ! 1008: case PTR: ! 1009: case RPTR: ! 1010: case VEC: ! 1011: Pptr(this)->dcl_print(0); ! 1012: break; ! 1013: case FCT: ! 1014: Pfct(this)->dcl_print(); ! 1015: break; ! 1016: // case VEC: ! 1017: // Pvec(this)->dcl_print(0); ! 1018: // break; ! 1019: case CLASS: ! 1020: case ENUM: ! 1021: if (emode) ! 1022: fprintf(out_file,"%k",base); ! 1023: else ! 1024: // error('i',"%p->T::print(%k %s)",this,base,Pclass(this)->string); ! 1025: fprintf(out_file,"struct %s *",Pclass(this)->string); ! 1026: break; ! 1027: case TYPE: ! 1028: if (Cast||Pbase(this)->b_name->lex_level) { ! 1029: Pbase(this)->b_name->tp->print(); ! 1030: break; ! 1031: } ! 1032: // no break ! 1033: default: ! 1034: Pbase(this)->dcl_print(); ! 1035: } ! 1036: } ! 1037: ! 1038: char* type::signature(register char* p) ! 1039: /* ! 1040: take a signature suitable for argument types for overloaded ! 1041: function names ! 1042: */ ! 1043: { ! 1044: Ptype t = this; ! 1045: int pp = 0; // pointer to ! 1046: ! 1047: xx: ! 1048: //error('d',"xx(%d) %d %k",this,t,t->base); ! 1049: ! 1050: // first unroll typedefs and handle derived types: ! 1051: ! 1052: switch (t->base) { ! 1053: case TYPE: ! 1054: if (Pbase(t)->b_const) *p++ = 'C'; ! 1055: t = Pbase(t)->b_name->tp; ! 1056: goto xx; ! 1057: ! 1058: case VEC: ! 1059: if (pp && Pvec(t)->size) { // A<size>_ ! 1060: *p++ = 'A'; ! 1061: sprintf(p,"%d\0",Pvec(t)->size); // don't trust ! 1062: // sprintf return value ! 1063: while (*++p); ! 1064: *p++ = '_'; ! 1065: } ! 1066: else ! 1067: *p++ = 'P'; ! 1068: t = Pvec(t)->typ; ! 1069: pp = 1; ! 1070: goto xx; ! 1071: ! 1072: case PTR: ! 1073: if (Pptr(t)->rdo) *p++ = 'C'; // *const ! 1074: if (Pptr(t)->memof) { // M<size><classname> ! 1075: Pclass cl = Pptr(t)->memof; ! 1076: register char* s = cl->string; ! 1077: int d = cl->strlen; ! 1078: if (d==0) cl->strlen = d = strlen(s); ! 1079: *p++ = 'M'; ! 1080: if (d/10) *p++ = '0'+d/10; ! 1081: *p++ = '0'+ d%10; // assume <100 char ! 1082: while (*p++ = *s++); ! 1083: --p; // not the '\0' ! 1084: } ! 1085: else ! 1086: *p++ = 'P'; ! 1087: t = Pptr(t)->typ; ! 1088: pp = 1; ! 1089: goto xx; ! 1090: ! 1091: case RPTR: ! 1092: *p++ = 'R'; ! 1093: t = Pptr(t)->typ; ! 1094: pp = 1; ! 1095: goto xx; ! 1096: ! 1097: case FCT: ! 1098: { Pfct f = Pfct(t); ! 1099: Pname n = f->argtype; ! 1100: ! 1101: if (f->f_const) *p++ = 'C'; // constant member function ! 1102: if (f->f_static) *p++ = 'S'; // static member function ! 1103: // if (f->memof && f->f_this==0) *p++ = 'S'; //SSS static member function ! 1104: *p++ = 'F'; ! 1105: if (n == 0) ! 1106: *p++ = 'v'; // VOID, that is f() == f(void) ! 1107: else ! 1108: for ( ; n; n=n->n_list) { // print argument encoding ! 1109: // check if argtype is the same ! 1110: // as previously seen argtype ! 1111: int i = 0; ! 1112: for (Pname nn=f->argtype; n!=nn; nn=nn->n_list) { ! 1113: i++; ! 1114: if (nn->tp==n->tp || nn->tp->check(n->tp,0)==0) { ! 1115: // typeof (n) == typeof(arg i) ! 1116: int x = 1; // try for a run after n ! 1117: Pname nnn = n; ! 1118: while ((nnn=nnn->n_list) && x<9) { ! 1119: if (nnn->tp==n->tp ! 1120: || nnn->tp->check(n->tp,0)==0) { ! 1121: x++; ! 1122: n = nnn; ! 1123: } ! 1124: else ! 1125: break; ! 1126: } ! 1127: ! 1128: if (x == 1) // Ti ! 1129: *p++ = 'T'; ! 1130: else { // Nxi ! 1131: *p++ = 'N'; ! 1132: *p++ = '0'+x; ! 1133: } ! 1134: ! 1135: // assume <100 arguments ! 1136: if (9<i) *p++ = '0'+i/10; ! 1137: *p++ = '0'+i%10; ! 1138: goto zk; ! 1139: } ! 1140: } ! 1141: ! 1142: // ``normal'' case print argument type signature ! 1143: // if (n->n_xref) *p++ = 'R'; ! 1144: p = n->tp->signature(p); ! 1145: zk:; ! 1146: } ! 1147: ! 1148: if (f->nargs_known == ELLIPSIS) *p++ = 'e'; ! 1149: ! 1150: if (pp) { // '_' result type ! 1151: *p++ = '_'; ! 1152: p = f->returns->signature(p); ! 1153: } ! 1154: ! 1155: *p = 0; ! 1156: return p; ! 1157: } ! 1158: } ! 1159: ! 1160: // base type modifiers: ! 1161: ! 1162: if ( Pbase(t)->b_const ) *p++ = 'C'; ! 1163: // if ( Pbase(t)->b_signed ) *p++ = 'S'; ! 1164: if ( Pbase(t)->b_unsigned ) *p++ = 'U'; ! 1165: // if ( Pbase(t)->b_volatile ) *p++ = 'V'; ! 1166: ! 1167: ! 1168: // now base types: ! 1169: ! 1170: register char *s, *ns = 0;; ! 1171: int d; ! 1172: Pclass cl; ! 1173: //lll: ! 1174: switch (t->base) { ! 1175: // case TNAME: t = Pbase(t)->b_name->tp; goto lll; ! 1176: case ANY: break; ! 1177: case ZTYPE: break; ! 1178: case VOID: *p++ = 'v'; break; ! 1179: case CHAR: *p++ = 'c'; break; ! 1180: case SHORT: *p++ = 's'; break; ! 1181: // case EOBJ: ! 1182: case INT: *p++ = 'i'; break; ! 1183: case LONG: *p++ = 'l'; break; ! 1184: case FLOAT: *p++ = 'f'; break; ! 1185: case DOUBLE: *p++ = 'd'; break; ! 1186: case LDOUBLE: *p++ = 'r'; break; ! 1187: case EOBJ: ! 1188: // *p++ = 'i'; ! 1189: // break; ! 1190: { Penum en = Penum(Pbase(t)->b_name->tp); ! 1191: // t = en->e_type; ! 1192: // goto lll; ! 1193: ns = en->nested_sig; ! 1194: s = en->string; ! 1195: d = en->strlen; ! 1196: if (d==0) en->strlen = d = strlen(s); ! 1197: goto pppp; ! 1198: } ! 1199: ! 1200: case COBJ: ! 1201: { cl = Pclass(Pbase(t)->b_name->tp); ! 1202: ns = cl->nested_sig; ! 1203: s = cl->string; ! 1204: d = cl->strlen; ! 1205: if (d==0) cl->strlen = d = strlen(s); ! 1206: pppp: ! 1207: if ( ns == 0 ) { ! 1208: if (d/10) *p++ = '0'+d/10; ! 1209: *p++ = '0'+ d%10; // assume less that 99 characters ! 1210: } ! 1211: else s = ns; ! 1212: ! 1213: while (*p++ = *s++); ! 1214: --p; ! 1215: break; ! 1216: } ! 1217: case FIELD: ! 1218: default: ! 1219: error('i',"signature of %k",t->base); ! 1220: } ! 1221: ! 1222: *p = 0; ! 1223: return p; ! 1224: } ! 1225: ! 1226: void basetype::dcl_print() ! 1227: { ! 1228: Pname nn; ! 1229: Pclass cl; ! 1230: ! 1231: if (emode) { ! 1232: if (b_virtual) puttok(VIRTUAL); ! 1233: if (b_inline) puttok(INLINE); ! 1234: } ! 1235: if(ansi_opt || emode) ! 1236: if (b_const) puttok(CONST); ! 1237: if (b_unsigned) puttok(UNSIGNED); ! 1238: ! 1239: switch (base) { ! 1240: case ANY: ! 1241: if (emode) ! 1242: putstring("any "); ! 1243: else ! 1244: putstring("int "); ! 1245: break; ! 1246: ! 1247: case ZTYPE: ! 1248: if (emode) ! 1249: putstring("zero "); ! 1250: else ! 1251: putstring("int "); ! 1252: break; ! 1253: ! 1254: case VOID: ! 1255: if (emode==0 && ansi_opt==0) { ! 1256: // silly trick to bypass BSD C compiler bug ! 1257: // void* (*)() dosn't work there ! 1258: // note simpl.c knows that VOID -> CHAR grep for VCVC ! 1259: puttok(CHAR); ! 1260: break; ! 1261: } ! 1262: case CHAR: ! 1263: case SHORT: ! 1264: case INT: ! 1265: case LONG: ! 1266: case FLOAT: ! 1267: case DOUBLE: ! 1268: case LDOUBLE: ! 1269: puttok(base); ! 1270: break; ! 1271: ! 1272: case EOBJ: ! 1273: nn = b_name; ! 1274: eob: ! 1275: if (emode == 0) ! 1276: // puttok(INT); ! 1277: Penum(nn->tp)->e_type->dcl_print(); ! 1278: else { ! 1279: puttok(ENUM); ! 1280: nn->print(); ! 1281: } ! 1282: break; ! 1283: ! 1284: case COBJ: ! 1285: nn = b_name; ! 1286: cob: ! 1287: cl = Pclass(nn->tp); ! 1288: if (emode && (cl->base == CLASS) && ! 1289: (cl->class_base == instantiated_template_class)) { ! 1290: Ptclass(cl)->inst->print_pretty_name(); ! 1291: break; ! 1292: } else ! 1293: if (cl && (cl->csu==UNION || cl->csu==ANON)) ! 1294: puttok(UNION); ! 1295: else puttok(STRUCT); ! 1296: { ! 1297: char* s = 0; ! 1298: if ( cl && cl->nested_sig ) ! 1299: fprintf(out_file," __%s ",cl->nested_sig); ! 1300: else { ! 1301: if ( cl && cl->lex_level ) ! 1302: s = make_local_name( cl ); ! 1303: putst(s?s:nn->string); ! 1304: delete s; ! 1305: } ! 1306: } ! 1307: break; ! 1308: ! 1309: case TYPE: ! 1310: if (emode == 0) { ! 1311: switch (b_name->tp->base) { ! 1312: case COBJ: ! 1313: nn = Pbase(b_name->tp)->b_name; ! 1314: goto cob; ! 1315: case EOBJ: ! 1316: nn = Pbase(b_name->tp)->b_name; ! 1317: goto eob; ! 1318: } ! 1319: } ! 1320: b_name->print(); ! 1321: break; ! 1322: ! 1323: default: ! 1324: if (emode) { ! 1325: if (0<base && base<=MAXTOK && keys[base]) ! 1326: fprintf(out_file," %s",keys[base]); ! 1327: else ! 1328: putch('?'); ! 1329: } ! 1330: else ! 1331: error('i',"%p->BT::dcl_print(%d)",this,base); ! 1332: } ! 1333: } ! 1334: Pbase memptr_type; ! 1335: ! 1336: void type::dcl_print(Pname n) ! 1337: /* ! 1338: "this" type is the type of "n". Print the declaration ! 1339: */ ! 1340: { ! 1341: //error('d',"%p::dcl_print(%n)",this,n); ! 1342: Ptype t = this; ! 1343: Pptr p; ! 1344: TOK pre = 0; ! 1345: ! 1346: if (t == 0) error('i',"0->dcl_print()"); ! 1347: if (n && n->tp!=t) error('i',"not %n'sT (%p)",n,t); ! 1348: ! 1349: if (base == OVERLOAD) { ! 1350: for (Plist gl=Pgen(this)->fct_list; gl; gl=gl->l) { ! 1351: Pname nn = gl->f; ! 1352: nn->tp->dcl_print(nn); ! 1353: if (gl->l) puttok(SM); ! 1354: } ! 1355: return; ! 1356: } ! 1357: ! 1358: tbuf = tbufvec[freetbuf]; ! 1359: if (tbuf == 0) { ! 1360: if (freetbuf == NTBUF-1) error('i',"AT nesting overflow"); ! 1361: tbufvec[freetbuf] = tbuf = new class dcl_buf; ! 1362: } ! 1363: freetbuf++; ! 1364: if ( base==FIELD && Pbase(this)->b_bits == 0 ) ! 1365: tbuf->init(0);// some compilers can't handle mangled names here ! 1366: else ! 1367: tbuf->init(n); ! 1368: if (n && n->n_xref) tbuf->front(PTR); ! 1369: ! 1370: while (t) { ! 1371: TOK k; ! 1372: ! 1373: switch (t->base) { ! 1374: case PTR: ! 1375: p = Pptr(t); ! 1376: k = (p->rdo) ? CONST_PTR : PTR; ! 1377: goto ppp; ! 1378: case RPTR: ! 1379: p = Pptr(t); ! 1380: k = (p->rdo) ? CONST_RPTR : RPTR; ! 1381: ppp: ! 1382: if (p->memof) { ! 1383: if (emode) { ! 1384: tbuf->front(k); ! 1385: tbuf->front(p->memof); ! 1386: } ! 1387: else { ! 1388: t = p->typ; ! 1389: while (t->base==TYPE) t = Pbase(t)->b_name->tp; ! 1390: if (t->base == FCT) { ! 1391: tbuf->base(mptr_type); ! 1392: goto zaq; ! 1393: } ! 1394: else ! 1395: tbuf->front(k); ! 1396: } ! 1397: } ! 1398: else ! 1399: tbuf->front(k); ! 1400: pre = PTR; ! 1401: t = p->typ; ! 1402: break; ! 1403: case VEC: ! 1404: { Pvec v = Pvec(t); ! 1405: if (Cast && pre != PTR && pre != VEC) { // for Macintosh: ptr to array uses [] notation ! 1406: tbuf->front(PTR); ! 1407: pre = PTR; ! 1408: } ! 1409: else { ! 1410: if (pre == PTR) tbuf->paran(); ! 1411: tbuf->back(VEC,v); ! 1412: pre = VEC; ! 1413: } ! 1414: t = v->typ; ! 1415: break; ! 1416: } ! 1417: ! 1418: case FCT: ! 1419: { Pfct f = Pfct(t); ! 1420: if (pre == PTR) ! 1421: tbuf->paran(); ! 1422: else if (emode && f->memof && n==0) ! 1423: tbuf->front(f->memof); ! 1424: tbuf->back(FCT,f); ! 1425: pre = FCT; ! 1426: t = (f->s_returns) ? f->s_returns : f->returns; ! 1427: break; ! 1428: } ! 1429: case FIELD: ! 1430: tbuf->back(FIELD,t); ! 1431: tbuf->base( Pbase(Pbase(t)->b_fieldtype) ); ! 1432: t = 0; ! 1433: break; ! 1434: case 0: ! 1435: if(!emode)error('i',"noBT(B=0)"); ! 1436: goto dobase; ! 1437: case TYPE: ! 1438: if (Cast||Pbase(t)->b_name->lex_level) { // unravel type in case it contains vectors ! 1439: t = Pbase(t)->b_name->tp; ! 1440: break; ! 1441: } ! 1442: default: // the base has been reached ! 1443: dobase: ! 1444: if (emode) { ! 1445: char* s; ! 1446: for (Ptype tt = t; tt->base==TYPE; tt=Pbase(tt)->b_name->tp); ! 1447: switch (tt->base) { ! 1448: case CLASS: ! 1449: s = Pclass(tt)->string; ! 1450: if (Ptclass(this)->class_base == instantiated_template_class || ! 1451: Ptclass(this)->class_base == uninstantiated_template_class) { ! 1452: Ptclass(this)->inst->print_pretty_name(); ! 1453: --freetbuf; ! 1454: return; ! 1455: } ! 1456: if (s[0]=='_' &&s[1]=='_' && s[2]=='C') s="class"; ! 1457: goto fret; ! 1458: case ENUM: ! 1459: s = "enum"; ! 1460: goto fret; ! 1461: case OVERLOAD: ! 1462: s = "overloaded"; ! 1463: fret: ! 1464: putstring(s); ! 1465: freetbuf--; ! 1466: return; ! 1467: } ! 1468: } ! 1469: ! 1470: tbuf->base( Pbase(t) ); ! 1471: goto zaq; ! 1472: } // switch ! 1473: } // while ! 1474: zaq: ! 1475: tbuf->put(); ! 1476: freetbuf--; ! 1477: } ! 1478: ! 1479: void fct::dcl_print() ! 1480: { ! 1481: Pname nn; ! 1482: //error('d',"fct::dcl_print()"); ! 1483: if (emode) { ! 1484: putch('('); ! 1485: for (nn=argtype; nn;) { ! 1486: nn->tp->dcl_print(0); ! 1487: if (nn=nn->n_list) puttok(CM); else break; ! 1488: } ! 1489: switch (nargs_known) { ! 1490: case 0: // putst("?"); break; ! 1491: case ELLIPSIS: puttok(ELLIPSIS); break; ! 1492: } ! 1493: putch(')'); ! 1494: if (f_const) puttok(CONST); ! 1495: if (f_static) puttok(STATIC); // wrong place for ``static'' ! 1496: return; ! 1497: } ! 1498: ! 1499: Pname at = f_args; ! 1500: putch('('); ! 1501: ! 1502: if (ansi_opt) { ! 1503: // print typed arguments: ! 1504: at = (f_this) ? f_this : (f_result) ? f_result : argtype; ! 1505: // WNG -- note: at = f_args had 0 value with ansi_opt set ! 1506: // mystery fix added here ! 1507: if (at == 0) { ! 1508: if (nargs_known == ELLIPSIS) { ! 1509: putch(')'); ! 1510: return; ! 1511: } ! 1512: puttok(VOID); ! 1513: } ! 1514: else if (body && Cast==0) ! 1515: at->dcl_print(CM); // print argument type and name ! 1516: else { ! 1517: for (nn=at; nn;) { ! 1518: // nn->tp->dcl_print(0); // print argument type ! 1519: nn->tp->dcl_print(nn); // print argument type ! 1520: // (there may not be a name) ! 1521: if (nn=nn->n_list) puttok(CM); else break; ! 1522: } ! 1523: } ! 1524: if (nargs_known == ELLIPSIS) putstring(",..."); ! 1525: putch(')'); ! 1526: } ! 1527: else { ! 1528: // print argument names followed by argument type declarations: ! 1529: if (body && Cast==0) { ! 1530: for (nn=at; nn;) { ! 1531: nn->print(); ! 1532: if (nn=nn->n_list) puttok(CM); else break; ! 1533: } ! 1534: #ifdef mips ! 1535: if (nargs_known == ELLIPSIS) ! 1536: putstring(", va_alist"); ! 1537: #endif ! 1538: #ifdef sparc ! 1539: if (nargs_known == ELLIPSIS) ! 1540: putstring(", __builtin_va_alist"); ! 1541: #endif ! 1542: putch(')'); ! 1543: } ! 1544: else ! 1545: putch(')'); ! 1546: } ! 1547: } ! 1548: ! 1549: void print_body(Pfct f) ! 1550: { ! 1551: if (Cast==0) { ! 1552: ! 1553: if (ansi_opt==0 && f->f_args) { ! 1554: f->f_args->dcl_print(SM); ! 1555: if ( last_ll==0 && (last_ll = f->body->where.line) ) ! 1556: f->body->where.putline(); ! 1557: } ! 1558: ! 1559: if (MAIN) { ! 1560: putstring("{ _main(); "); // call constructors ! 1561: f->body->print(); ! 1562: puttok(RC); ! 1563: } ! 1564: else ! 1565: f->body->print(); ! 1566: } ! 1567: } ! 1568: ! 1569: Pbcl shared_seen; ! 1570: ! 1571: void classdef::print_members() ! 1572: { ! 1573: int i; ! 1574: ! 1575: Pbcl l = baselist; ! 1576: // error('d',"%t->print_members()",this); ! 1577: if (l) { ! 1578: if (l->base == NAME) { ! 1579: l->bclass->print_members(); // first base only ! 1580: // pad to ensure alignment: ! 1581: int boff = l->bclass->real_size; ! 1582: int ba = l->bclass->align(); ! 1583: int xtra = boff%ba; ! 1584: int waste = (xtra) ? ba-xtra : 0; // padding ! 1585: //error('d',"%s: size % align %d waste %d",string,boff,ba,waste); ! 1586: if (waste) { ! 1587: // waste it to protect against structure ! 1588: // assignments to the base class ! 1589: char* s = make_name('W'); ! 1590: fprintf(out_file,"char %s[%d];\n",s,waste); ! 1591: delete s; ! 1592: } ! 1593: l = l->next; ! 1594: } ! 1595: ! 1596: for (; l; l=l->next) ! 1597: /* for second base etc. one must allocate as an object ! 1598: (rather than a list of members) to ensure proper alignment ! 1599: for shared base allocate a pointer ! 1600: size, alignment, & offset handled in cassdef::dcl() ! 1601: */ ! 1602: if (l->base == NAME) { ! 1603: Pclass bcl = l->bclass; ! 1604: char *str = 0; ! 1605: char *cs = bcl->nested_sig?bcl->nested_sig:bcl->string; ! 1606: if (bcl->lex_level && ! 1607: bcl->nested_sig==0) ! 1608: str=make_local_name(bcl); ! 1609: puttok(STRUCT); ! 1610: putst(str?str:cs); ! 1611: putcat('O',bcl->string); // leave as unencoded ! 1612: puttok(SM); ! 1613: delete str; ! 1614: } ! 1615: } ! 1616: ! 1617: // Sam: A class or an enum type declared within a class can hide a ! 1618: // member with the same name, so make sure that it gets printed by ! 1619: // traversing the n_tbl_list to get at these names. ! 1620: for (Pname nn=memtbl->get_mem(i=1); nn; nn=memtbl->get_mem(++i)) { ! 1621: do { if (nn->base==NAME ! 1622: && nn->n_union==0 ! 1623: && nn->tp->base!=FCT ! 1624: && nn->tp->base!=OVERLOAD ! 1625: && nn->tp->base!=CLASS ! 1626: && nn->tp->base!=ENUM ! 1627: && nn->n_stclass != STATIC) { ! 1628: // if (nn->tp->base==FIELD && Pbase(nn->tp)->b_bits==0) continue; ! 1629: Pexpr i = nn->n_initializer; ! 1630: nn->n_initializer = 0; ! 1631: nn->dcl_print(0); ! 1632: nn->n_initializer = i; ! 1633: } ! 1634: } while ((nn->base == NAME) && ! 1635: ((nn->tp->base!=CLASS) || (nn->tp->base!=ENUM)) && ! 1636: (nn = nn->n_tbl_list)) ; ! 1637: } ! 1638: ! 1639: for (l=baselist; l; l=l->next) ! 1640: if (l->base==VIRTUAL && l->ptr_offset) { ! 1641: Pclass bcl = l->bclass; ! 1642: char* str = 0; ! 1643: char *cs = bcl->nested_sig?bcl->nested_sig:bcl->string; ! 1644: if (bcl->lex_level && ! 1645: bcl->nested_sig==0) ! 1646: str=make_local_name(bcl); ! 1647: puttok(STRUCT); ! 1648: putst(str?str:cs); ! 1649: putch('*'); ! 1650: putcat('P',bcl->string); // leave unencoded ! 1651: puttok(SM); ! 1652: delete str; ! 1653: } ! 1654: } ! 1655: ! 1656: // void classdef::print_vtbl(Pvirt vtab) ! 1657: // { ! 1658: // error('d',"%s->print_vtbl(%s) vtbl_opt %d",string,vtab->string,vtbl_opt); ! 1659: // error('d',"print_vtbl: lex_level: %d", lex_level ); ! 1660: // ! 1661: // switch (vtbl_opt) { ! 1662: // case -1: ! 1663: // case 1: ! 1664: // vlist = new vl(this,vtab,vlist); ! 1665: // } ! 1666: // ! 1667: // int oo = vtbl_opt; // make `simulated static' name ! 1668: // vtbl_opt = -1; ! 1669: // char* str = lex_level ? make_local_name(this) : 0; ! 1670: // char* s = vtbl_name(vtab->string,str?str:string); ! 1671: // vtbl_opt = oo; ! 1672: // fprintf(out_file,"extern struct __mptr %s[];\n",s); ! 1673: // s[2] = 'p'; // pointer, not tbl itself ! 1674: // fprintf(out_file,"extern struct __mptr* %s;\n",s); ! 1675: // ! 1676: // delete s; ! 1677: // delete str; ! 1678: // } ! 1679: ! 1680: vl* vlist; ! 1681: ! 1682: void really_really_print(Pclass cl, Pvirt vtab, char* s, char* ss); ! 1683: ! 1684: int p2(Pname nn, Ptype t, Pclass cl, Pvirt vtab, char* s) ! 1685: { ! 1686: int init; ! 1687: ! 1688: if (t->base == FCT) { ! 1689: Pfct f = Pfct(t); ! 1690: ! 1691: //error('d',"p2 %n init %d inline %d virtual %d",nn,nn->n_initializer,f->f_inline,f->f_virtual); ! 1692: //error('d',"p2 %s expr %d imeasure %d body %d",s,f->f_expr,f->f_imeasure,f->body); ! 1693: //error('d',"sto %k",nn->n_sto); ! 1694: if (nn->n_initializer ! 1695: || nn->n_sto==STATIC ! 1696: || f->f_inline ! 1697: || f->f_imeasure ! 1698: || f->f_virtual==0) return 0; ! 1699: init = f->body!=0; ! 1700: } ! 1701: else ! 1702: init = nn->n_initializer!=0; ! 1703: ! 1704: int oo = vtbl_opt; ! 1705: vtbl_opt = 1; // make sure the name is universal ! 1706: char *cs = cl->nested_sig?cl->nested_sig:cl->string; ! 1707: char* sstr = (cl->lex_level&&cl->nested_sig==0)? make_local_name(cl) : 0; ! 1708: char* ss = vtbl_name(vtab->string,sstr?sstr:cs); ! 1709: ! 1710: if (init) { // unique definition here ! 1711: really_really_print(cl,vtab,ss,s); ! 1712: } ! 1713: else { // unique definition elsewhere ! 1714: char *vstr = 0; ! 1715: if ( vtab && vtab->string ) { ! 1716: vstr = new char[strlen(vtab->string)+cl->strlen+1]; ! 1717: strcpy( vstr, vtab->string ); ! 1718: strcat( vstr, cl->string ); ! 1719: } ! 1720: Pname nn; ! 1721: if (nn=ptbl->look(vstr?vstr:cl->string,0)) { // use of ptbl in file ! 1722: fprintf(out_file,"extern struct __mptr %s[];\n",ss); ! 1723: s[2] = 'p'; ! 1724: // fprintf(out_file,"struct __mptr* %s = ",s); ! 1725: // fprintf(out_file,"%s;\n",ss); ! 1726: ptbl_add_pair(s, ss); ! 1727: nn->n_key=HIDDEN; ! 1728: } ! 1729: delete vstr; ! 1730: } ! 1731: vtbl_opt = oo; ! 1732: ! 1733: delete ss; ! 1734: delete sstr; ! 1735: ! 1736: return 1; ! 1737: } ! 1738: ! 1739: void classdef::really_print(Pvirt vtab) ! 1740: { ! 1741: // error('d',"really_print %t %d",this,vtbl_opt); ! 1742: int oo = vtbl_opt; // make `simulated static' name ! 1743: vtbl_opt = -1; ! 1744: char *cs = nested_sig?nested_sig:string; ! 1745: char* str = (lex_level&&nested_sig==0) ? make_local_name(this) : 0; ! 1746: char* s = vtbl_name(vtab->string,str?str:cs); ! 1747: // error('d', "really_print: %s, vtab: %s, s: %s", string, vtab->string, s ); ! 1748: vtbl_opt = oo; ! 1749: ! 1750: // see if needed ! 1751: int i; ! 1752: for (Pname nn=memtbl->get_mem(i=1); nn; nn=memtbl->get_mem(++i) ) { ! 1753: Ptype t = nn->tp; ! 1754: zse: ! 1755: if (t) ! 1756: switch (t->base) { ! 1757: case TYPE: ! 1758: t = Pbase(t)->b_name->tp; ! 1759: goto zse; ! 1760: /* ! 1761: case COBJ: ! 1762: if (nn->n_sto == EXTERN) ! 1763: { Pclass cl = Pclass(Pbase(t)->b_name->tp); ! 1764: if (cl->has_ctor()) { ! 1765: p2(nn,t,this,vtab,s); ! 1766: return; ! 1767: } ! 1768: } ! 1769: break; ! 1770: */ ! 1771: case FCT: ! 1772: if (p2(nn,t,this,vtab,s)) ! 1773: goto xyzzy; ! 1774: break; ! 1775: ! 1776: case OVERLOAD: ! 1777: { for (Plist gl=Pgen(t)->fct_list; gl; gl=gl->l) ! 1778: if (p2(gl->f,gl->f->tp,this,vtab,s)) ! 1779: goto xyzzy; ! 1780: } ! 1781: } ! 1782: } ! 1783: ! 1784: { // must be initialized var in block to permit goto ! 1785: char* ss = vtbl_name(vtab->string,str?str:cs); ! 1786: // error('d', "really_print: %s, vtab: %s, ss: %s", cs, vtab->string, s ); ! 1787: ! 1788: if (vtbl_opt) ! 1789: really_really_print(this,vtab,ss,s); ! 1790: else { ! 1791: char *vstr = 0; ! 1792: if ( vtab && vtab->string ) { ! 1793: vstr = new char[::strlen(vtab->string)+strlen+1]; ! 1794: strcpy( vstr, vtab->string ); ! 1795: strcat( vstr, string ); ! 1796: } ! 1797: Pname nn; ! 1798: if (nn=ptbl->look(vstr?vstr:string,0)) { // use of ptbl in file ! 1799: fprintf(out_file,"extern struct __mptr %s[];\n",ss); ! 1800: s[2] = 'p'; ! 1801: // fprintf(out_file,"struct __mptr* %s = ",s); ! 1802: // fprintf(out_file,"%s;\n",ss); ! 1803: ptbl_add_pair(s, ss); ! 1804: nn->n_key=HIDDEN; ! 1805: } ! 1806: delete vstr; ! 1807: } ! 1808: delete ss; ! 1809: } ! 1810: xyzzy: ! 1811: delete s; ! 1812: delete str; ! 1813: } ! 1814: ! 1815: void really_really_print(Pclass cl, Pvirt vtab, char* s, char* ss) ! 1816: { ! 1817: // error('d',"really %s %s",s, ss); ! 1818: // make sure function is declared before using ! 1819: // it in vtbl initializer ! 1820: Pname nn; ! 1821: int i; ! 1822: for (i=0; nn = vtab->virt_init[i].n; i++) { ! 1823: Pfct f = Pfct(nn->tp); ! 1824: if (nn->n_initializer) { // pure virtual ! 1825: static pv; ! 1826: if (pv == 0) { // VCVC void->char assumed ! 1827: fprintf(out_file,"char __pure_virtual_called();\n"); ! 1828: pv = 1; ! 1829: } ! 1830: continue; ! 1831: } ! 1832: if (f->base != FCT) error('i',"vtbl %n",nn); ! 1833: //extern void expand_dtor(Pclass cl); ! 1834: // if (f->f_inline == IDTOR) expand_dtor(f->memof); ! 1835: ! 1836: if (nn->n_dcl_printed==0 /*|| f->f_inline*/) { ! 1837: if (f->f_inline && vtbl_opt) puttok(STATIC); ! 1838: if (f->f_result == 0) make_res(f); ! 1839: Ptype r = f->s_returns ? f->s_returns : f->returns; ! 1840: r->print(); ! 1841: nn->print(); ! 1842: putstring("()"); ! 1843: puttok(SM); ! 1844: nn->n_dcl_printed = 1; ! 1845: } ! 1846: } ! 1847: ! 1848: // if (vtbl_opt == -1) puttok(STATIC); ! 1849: ! 1850: ! 1851: fprintf(out_file,"struct __mptr %s[] = {0,0,0,\n",s); ! 1852: ! 1853: Pname n; ! 1854: for (i=0; n=vtab->virt_init[i].n; i++) { ! 1855: if (n->n_initializer) ! 1856: putstring("0,0,(__vptp)__pure_virtual_called,\n"); ! 1857: else { ! 1858: fprintf(out_file,"%d,0,(__vptp)",-vtab->virt_init[i].offset); ! 1859: n->print(); ! 1860: n->n_addr_taken = 1; ! 1861: putstring(",\n"); ! 1862: } ! 1863: } ! 1864: putstring("0,0,0};\n"); ! 1865: ! 1866: ss[2] = 'p'; ! 1867: // fprintf(out_file,"struct __mptr* %s = ",ss); ! 1868: s[2] = 'v'; ! 1869: // fprintf(out_file,"%s;\n",s); ! 1870: ptbl_add_pair(ss,s); ! 1871: ! 1872: Pname nm; ! 1873: char *cstr = 0; ! 1874: char *vstr = 0; ! 1875: char *cs = cl->nested_sig?cl->nested_sig:cl->string; ! 1876: if (cl->lex_level && cl->nested_sig==0) cstr = make_local_name( cl ); ! 1877: if ( vtab && vtab->string ) { ! 1878: vstr = new char[strlen(vtab->string)+(cstr?strlen(cstr):strlen(cs))+1]; ! 1879: strcpy( vstr, vtab->string ); ! 1880: strcat( vstr, cstr?cstr:cs ); ! 1881: } ! 1882: ! 1883: if ( vstr == 0 ) vstr = cstr; ! 1884: if ( nm = ptbl->look(vstr?vstr:cl->string,0) ) ! 1885: nm->n_key = HIDDEN; ! 1886: else ! 1887: if ( ptbl->look(vstr?vstr:cl->string,HIDDEN) == 0 ) ! 1888: ptbl->insert(new name(vstr?vstr:cl->string),HIDDEN); ! 1889: if (cstr == vstr) delete cstr; ! 1890: else { ! 1891: delete cstr; ! 1892: delete vstr; ! 1893: } ! 1894: ! 1895: //error('d',"really-> %s",s); ! 1896: } ! 1897: ! 1898: #include <ctype.h> ! 1899: char* vtbl_name(char* s1, char* s2) ! 1900: { ! 1901: char* s3 = (vtbl_opt == -1 && *src_file_name) ? src_file_name : 0; ! 1902: // if vtbl_opt == -1 fake a static (there are no portable ! 1903: // way of doing a forward declaration of a static in C) ! 1904: int ll = s1 ? strlen(s1) : 0; ! 1905: int ll2 = strlen(s2); ! 1906: int ll3 = s3 ? strlen(s3) : 0; ! 1907: int sz = (ll+ll2+ll3+20)/32+1; // avoid fragmentation ! 1908: ! 1909: sz *= 32; ! 1910: // error('d',"vtbl_name(%s,%s,%s) %d",s1?s1:"",s2,s3?s3:"",sz); ! 1911: char* buf = new char[sz]; ! 1912: if (s3) { ! 1913: if (s1) ! 1914: sprintf(buf,"__vtbl__%d%s__%d%s__%s",ll,s1,ll2,s2,s3); ! 1915: else ! 1916: sprintf(buf,"__vtbl__%d%s__%s",ll2,s2,s3); ! 1917: } ! 1918: else if (s1) ! 1919: sprintf(buf,"__vtbl__%d%s__%d%s",ll,s1,ll2,s2); ! 1920: else ! 1921: sprintf(buf,"__vtbl__%d%s",ll2,s2); ! 1922: ! 1923: if (vtbl_opt == -1) { ! 1924: for (char* p = buf+ll2+11; *p; p++) ! 1925: if (!isalpha(*p) && !isdigit(*p)) *p = '_'; ! 1926: } ! 1927: #ifdef DENSE ! 1928: chop(buf); ! 1929: #endif ! 1930: return buf; ! 1931: } ! 1932: ! 1933: void classdef::print_all_vtbls(Pclass bcl) ! 1934: { ! 1935: //error('d',"%t->print_all_vtbls(%t) vlt %d bl %d",this,bcl,virt_list,baselist); ! 1936: ! 1937: for (Pvirt blist = bcl->virt_list; blist; blist = blist->next) { ! 1938: if (this != blist->vclass) continue; ! 1939: if (blist->printed) continue; ! 1940: // if (blist->string==0 && find_vptr(this)==0) { //BSopt ! 1941: // continue; ! 1942: // } ! 1943: // print_vtbl(blist); ! 1944: vlist = new vl(this,blist,vlist); ! 1945: blist->printed = 1; ! 1946: } ! 1947: ! 1948: for (Pbcl b = bcl->baselist; b; b = b->next) ! 1949: print_all_vtbls(b->bclass); ! 1950: ! 1951: if (this==bcl) c_body = 0; ! 1952: } ! 1953: ! 1954: extern Pclass current_instantiation; ! 1955: void classdef::dcl_print(Pname) ! 1956: { ! 1957: //error('d',"%t->classdef::dcl_print() -- c_body==%d defined==0%o",this,c_body,defined); ! 1958: defined |= REF_SEEN; ! 1959: // ensure template instantiations are printed exactly once. ! 1960: if (class_base != vanilla_class && current_instantiation != this) return; ! 1961: ! 1962: if (c_body==0 || c_body==3 || (defined&DEFINED)==0) return; ! 1963: c_body = 3; ! 1964: ! 1965: int i; ! 1966: for (Pname nn=memtbl->get_mem(i=1); nn; nn=memtbl->get_mem(++i) ) { ! 1967: if (nn->base==NAME ! 1968: && nn->n_union==0 ! 1969: && nn->tp->base==CLASS ! 1970: && Pclass(nn->tp)->c_body==1) ! 1971: Pclass(nn->tp)->dcl_print(nn); ! 1972: else if (nn->base == TNAME && Pbase(nn->tp)->base != COBJ) ! 1973: nn->dcl_print(0); ! 1974: else if (nn->tp && nn->tp->base == ENUM) { ! 1975: if(nn->n_union==0) Penum(nn->tp)->dcl_print(nn); ! 1976: } ! 1977: } ! 1978: ! 1979: TOK lvl = in_class ? NESTED : lex_level ? LOCAL : 0; ! 1980: Pname n = ktbl->look(string,lvl); ! 1981: if (n==0) n = ktbl->look(string,HIDDEN); ! 1982: ! 1983: if (n) { ! 1984: if (n->where.line!=last_line.line ! 1985: || n->where.file!=last_line.file) ! 1986: if (last_ll = n->where.line) ! 1987: n->where.putline(); ! 1988: else ! 1989: last_line.putline(); ! 1990: } ! 1991: ! 1992: TOK c = csu==CLASS ? STRUCT : csu; ! 1993: puttok(c); ! 1994: // if (string[0]!='_' || string[1]!='_' || string[2]!='C') ! 1995: ! 1996: char *str = 0; ! 1997: if ( lex_level && nested_sig == 0) str = make_local_name( this ); ! 1998: if ( nested_sig ) putstring( " __" ); ! 1999: putst(str?str:(nested_sig?nested_sig:string)); ! 2000: ! 2001: int sm = 0; ! 2002: int sz = tsizeof(); ! 2003: int dvirt = 0; ! 2004: ! 2005: if ( nested_sig ) ! 2006: fprintf(out_file,"{\t/* sizeof __%s == %d */\n",nested_sig,obj_size); ! 2007: else ! 2008: fprintf(out_file,"{\t/* sizeof %s == %d */\n",str?str:string,obj_size); ! 2009: if ( last_ll ) last_line.line++; ! 2010: delete str; ! 2011: ! 2012: print_members(); ! 2013: for (Pbcl b = baselist; b; b = b->next) { // declare virtual classes ! 2014: if (b->base != VIRTUAL) continue; ! 2015: Pclass bcl = b->bclass; ! 2016: dvirt += bcl->virt_count; ! 2017: //error('d',"%t in %t %d",b->bclass,this,b->allocated); ! 2018: if (b->allocated==0) continue; ! 2019: char* str = 0; ! 2020: if (bcl->lex_level) str = make_local_name(bcl); ! 2021: puttok(STRUCT); // struct bcl Obcl; ! 2022: putst(str?str:bcl->string); ! 2023: putcat('O',bcl->string); // leave unencoded ! 2024: puttok(SM); ! 2025: delete str; ! 2026: } ! 2027: putstring("};\n"); ! 2028: if ( last_ll ) last_line.line++; ! 2029: ! 2030: for (nn=memtbl->get_mem(i=1); nn; nn=memtbl->get_mem(++i) ) { ! 2031: if (nn->base==NAME && nn->n_union==0) { ! 2032: Ptype t = nn->tp; ! 2033: switch (t->base) { ! 2034: case FCT: ! 2035: case OVERLOAD: ! 2036: break; ! 2037: default: ! 2038: if (nn->n_stclass == STATIC) { ! 2039: TOK b = nn->n_sto; ! 2040: //error('d',"print nn %n tp %t b %k eval %d",nn,nn->tp,b,nn->n_evaluated); ! 2041: /* ! 2042: Pname cn; ! 2043: TOK bb = ((cn=nn->tp->is_cl_obj()) ! 2044: && Pclass(cn->tp)->has_ctor())==0 ! 2045: ?0:b; // force explicit initialization ! 2046: nn->n_sto = (nn->n_evaluated) ? STATIC : bb; ! 2047: */ ! 2048: nn->n_sto = (nn->n_evaluated) ? STATIC : b; ! 2049: nn->dcl_print(0); ! 2050: nn->n_sto = b; ! 2051: } ! 2052: } ! 2053: } ! 2054: } ! 2055: if (vtbl_opt != -1) print_all_vtbls(this); // force declaration ! 2056: //error('d',"dcl_print -> "); ! 2057: } ! 2058: ! 2059: ! 2060: char * ! 2061: make_local_name( Pclass cl, int ln ) ! 2062: { ! 2063: char *buf; ! 2064: if ( cl->in_fct == 0 ) error( 'i', "localC %s missingFN", cl->string ); ! 2065: char *fsig = Pfct(cl->in_fct->tp)->f_signature; ! 2066: if ( fsig == 0 ) fsig = local_sign( cl->in_fct->tp ); ! 2067: char *fs = cl->in_fct->string; ! 2068: int class_len=cl->strlen+strlen(fsig)+strlen(fs)+strlen(cl->lcl)+4; ! 2069: int sz = (class_len+20)/32+1; // from vtbl_name() ! 2070: ! 2071: if ( Pfct(cl->in_fct->tp)->memof == 0 ) { ! 2072: sz *= 32; ! 2073: buf = new char[ sz ]; ! 2074: // error('d', "make_local_name: sz: %d", sz ); ! 2075: ! 2076: if (ln) ! 2077: sprintf(buf, "__%d%s__%s__%s%s", class_len, cl->string, fs, fsig, cl->lcl); ! 2078: else ! 2079: sprintf(buf, "%s__%s__%s%s", cl->string, fs, fsig, cl->lcl); ! 2080: } ! 2081: else ! 2082: { ! 2083: char *cs = Pclass(Pfct(cl->in_fct->tp)->memof)->string; ! 2084: int len = Pclass(Pfct(cl->in_fct->tp)->memof)->strlen; ! 2085: if ( len < 10 ) ! 2086: ++class_len; ! 2087: else ! 2088: if ( len > 99 ) ! 2089: class_len += 3; ! 2090: else class_len += 2; ! 2091: class_len += len; ! 2092: sz = (class_len+20)/32+1; ! 2093: sz *= 32; ! 2094: buf = new char[ sz ]; ! 2095: // error('d', "make_local_name: sz: %d", sz ); ! 2096: ! 2097: if ( ln ) ! 2098: sprintf(buf, "__%d%s__%s__%d%s%s%s",class_len,cl->string,fs,len,cs,fsig,cl->lcl); ! 2099: else sprintf(buf, "%s__%s__%d%s%s%s",cl->string,fs,len,cs,fsig,cl->lcl); ! 2100: } ! 2101: ! 2102: #ifdef DENSE ! 2103: chop( buf ); ! 2104: #endif ! 2105: ! 2106: return buf; ! 2107: } ! 2108:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.