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