![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to print.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 print.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / ptcfront |
1.1 ! root 1: /*ident "@(#)ctrans:src/print.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: print.c: ! 11: ! 12: print statements and expressions ! 13: ! 14: ****************************************************************************/ ! 15: ! 16: #include "cfront.h" ! 17: ! 18: static int addrof_cm ; ! 19: extern void puttok(TOK); ! 20: ! 21: #define eprint(e) if (e) Eprint(e) ! 22: ! 23: void Eprint(Pexpr e) ! 24: { ! 25: switch (e->base) { ! 26: case REF: ! 27: if (Pref(e)->mem && Pref(e)->mem->tp && Pref(e)->mem->tp->base == FCT) { ! 28: // suppress ``this'' in ``this->f'' ! 29: Pref(e)->mem->print(); ! 30: break; ! 31: } ! 32: case NAME: ! 33: case MDOT: ! 34: case ID: ! 35: case ZERO: ! 36: case ICON: ! 37: case CCON: ! 38: case FCON: ! 39: case STRING: ! 40: case IVAL: ! 41: case TEXT: ! 42: case CM: ! 43: case G_CM: ! 44: case ELIST: ! 45: case COLON: ! 46: case ILIST: ! 47: case DOT: ! 48: case THIS: ! 49: case CALL: ! 50: case G_CALL: ! 51: case ICALL: ! 52: case ANAME: ! 53: e->print(); ! 54: case DUMMY: ! 55: break; ! 56: default: ! 57: putch('('); ! 58: e->print(); ! 59: putch(')'); ! 60: } ! 61: } ! 62: ! 63: void expr::print() ! 64: { ! 65: if (this == 0) error('i',"0->E::print()"); ! 66: if (this==e1 || this==e2) error('i',"(%p%k)->E::print(%p %p)",this,base,e1,e2); ! 67: // error('d',"(%d %k)->expr::print(%d %d)",this,base,e1,e2); ! 68: ! 69: switch (base) { ! 70: case MDOT: ! 71: { ! 72: // error('d',"mdot %s i1 %d %t",string2,i1,mem->tp); ! 73: int not_allocated = 0; ! 74: switch (i1) { ! 75: case 0: ! 76: putcat('O',string2); ! 77: puttok(DOT); // use sub-object directly ! 78: mem->print(); ! 79: break; ! 80: case 1: ! 81: putcat('P',string2); ! 82: puttok(REF); // use through pointer ! 83: mem->print(); ! 84: break; ! 85: case 2: ! 86: if (mem->tp->is_ptr_or_ref()==0) { ! 87: mem->print(); ! 88: puttok(DOT); ! 89: putcat('O',string2); ! 90: } ! 91: else ! 92: { ! 93: putch('('); // REF turns pointer into object: add & ! 94: putch('&'); // ``this'' is a pointer ! 95: putch('('); ! 96: eprint(mem); ! 97: puttok(REF); // call sub-object directly ! 98: putcat('O',string2); ! 99: putch(')'); ! 100: putch(')'); ! 101: } ! 102: break; ! 103: case 5: ! 104: not_allocated = 1; ! 105: // no break; ! 106: case 3: ! 107: if (mem->tp->is_ptr_or_ref()==0) { ! 108: putch('('); // Px is a pointer (T*) turn it back to a T ! 109: putch('*'); // *Px ! 110: putch('('); ! 111: eprint(mem);//mem->print(); ! 112: puttok(DOT); // call through pointer ! 113: putcat('P',string2); ! 114: putch(')'); ! 115: putch(')'); ! 116: } ! 117: else { ! 118: if (not_allocated) { ! 119: putch('('); ! 120: mem->print(); ! 121: if ( mem->base == NAME ) ! 122: puttok(REF); ! 123: else puttok(DOT); ! 124: putcat('O',string4); ! 125: putch(')'); ! 126: } ! 127: else eprint(mem); ! 128: if (mem->base == NAME && not_allocated) ! 129: puttok(DOT); ! 130: else puttok(REF); // call through pointer ! 131: putcat('P',string2); ! 132: } ! 133: break; ! 134: case 9: // vtbl entry: (p->_vtbl).f, (p->_vtbl).i, (p->_vtbl).d ! 135: // or memptr: mp.f, mp.i, mp.d ! 136: eprint(mem); ! 137: putch('.'); ! 138: putstring(string2); ! 139: } // end switch(i1) ! 140: break; ! 141: } // end MDOT ! 142: ! 143: case NAME: ! 144: { Pname n = Pname(this); ! 145: if (n->n_evaluated ! 146: && n->n_scope!=ARG) { ! 147: Ptype t = tp->skiptypedefs(); ! 148: if (t->base == EOBJ) t = Penum(Pbase(t)->b_name->tp)->e_type; ! 149: if (t->base!=INT || t->is_unsigned()) { ! 150: putstring("(("); ! 151: bit oc = Cast; ! 152: Cast = 1; ! 153: t->print(); ! 154: Cast = oc; ! 155: fprintf(out_file,")%d)",n->n_val); ! 156: } ! 157: else ! 158: fprintf(out_file,"%d",n->n_val); ! 159: } ! 160: else ! 161: n->print(); ! 162: break; ! 163: } ! 164: case ANAME: ! 165: if (curr_icall) { // in expansion: look it up ! 166: Pname n = Pname(this); ! 167: int argno = int(n->n_val); ! 168: ! 169: for (Pin il=curr_icall; il; il=il->i_next) ! 170: if (n->n_table == il->i_table) goto aok; ! 171: goto bok; ! 172: aok: ! 173: if (n = il->i_args[argno].local) { ! 174: n->print(); ! 175: } ! 176: else { ! 177: Pexpr ee = il->i_args[argno].arg; ! 178: Ptype t = il->i_args[argno].tp; ! 179: if (ee==0 || ee==this) error('i',"%p->E::print(A %p)",this,ee); ! 180: if (ee->tp==0 ! 181: || (t!=ee->tp && t->check(ee->tp,0) && t->is_cl_obj()==0) ! 182: ) { ! 183: putstring("(("); ! 184: bit oc = Cast; ! 185: Cast = 1; ! 186: t->print(); ! 187: Cast = oc; ! 188: putch(')'); ! 189: eprint(ee); ! 190: putch(')'); ! 191: } ! 192: else ! 193: eprint(ee); ! 194: } ! 195: } ! 196: else { ! 197: bok: /* in body: print it: */ ! 198: Pname(this)->print(); ! 199: } ! 200: break; ! 201: ! 202: case ICALL: ! 203: { il->i_next = curr_icall; ! 204: curr_icall = il; ! 205: //error('d',"icall %n",il->fct_name); ! 206: if (il == 0) error('i',"E::print: iline missing"); ! 207: Pexpr a0 = il->i_args[0].arg; ! 208: int val = QUEST; ! 209: if (il->fct_name->n_oper != CTOR) goto dumb; ! 210: ! 211: /* ! 212: find the value of "this" ! 213: if the argument is a "this" NOT assigned to ! 214: by the programmer, it was initialized ! 215: */ ! 216: switch (a0->base) { ! 217: case ZERO: ! 218: val = 0; ! 219: break; ! 220: case ADDROF: ! 221: case G_ADDROF: ! 222: val = 1; ! 223: break; ! 224: case CAST: ! 225: if (a0->e1->base == ANAME || a0->e1->base == NAME) { ! 226: Pname a = (Pname)a0->e1; ! 227: if (a->n_assigned_to == FUDGE111) val = FUDGE111; ! 228: } ! 229: } ! 230: if (val==QUEST) goto dumb; ! 231: /* ! 232: now find the test: "(this==0) ? _new(sizeof(X)) : 0" ! 233: ! 234: e1 is a comma expression, ! 235: the test is either the first sub-expression ! 236: or the first sub-expression after the assignments ! 237: initializing temporary variables ! 238: */ ! 239: dumb: ! 240: eprint(e1); ! 241: if (e2) Pstmt(e2)->print(); ! 242: curr_icall = il->i_next; ! 243: break; ! 244: } ! 245: case REF: ! 246: case DOT: ! 247: eprint(e1); ! 248: puttok(base); ! 249: if (mem == 0) { ! 250: fprintf(out_file,"MEM0"); ! 251: break; ! 252: } ! 253: if (mem->base == NAME) ! 254: Pname(mem)->print(); ! 255: else ! 256: mem->print(); ! 257: break; ! 258: ! 259: case MEMPTR: ! 260: error("P toMF not called"); ! 261: break; ! 262: ! 263: case VALUE: ! 264: tp2->print(); ! 265: puttok(LP); ! 266: if (e1) e1->print(); ! 267: puttok(RP); ! 268: break; ! 269: ! 270: case SIZEOF: ! 271: puttok(SIZEOF); ! 272: if (e1 && e1!=dummy) { ! 273: eprint(e1); ! 274: } ! 275: else if (tp2) { ! 276: putch('('); ! 277: if (tp2->base == CLASS) { ! 278: Pclass cl = Pclass(tp2); ! 279: putstring((cl->csu == UNION)?"union ":"struct "); ! 280: char *str = 0; ! 281: // nested local class does not encode name ! 282: if ( cl->lex_level && cl->nested_sig == 0 ) ! 283: str = make_local_name( cl ); ! 284: putstring(str?str:(cl->nested_sig?cl->nested_sig:cl->string)); ! 285: delete str; ! 286: } ! 287: else ! 288: tp2->print(); ! 289: putch(')'); ! 290: } ! 291: break; ! 292: ! 293: case CAST: ! 294: putch('('); ! 295: //error('d',"print cast %t",tp2); ! 296: if (tp2->base != VOID && tp2->memptr() == 0 ) { ! 297: // when VOID is represented as CHAR not everything ! 298: // can be cast to VOID ! 299: putch('('); ! 300: bit oc = Cast; ! 301: Cast = 1; ! 302: tp2->print(); ! 303: Cast = oc; ! 304: putch(')'); ! 305: } ! 306: eprint(e1); ! 307: putch(')'); ! 308: break; ! 309: ! 310: case ICON: ! 311: case FCON: ! 312: case CCON: ! 313: case ID: ! 314: if (string) putst(string); ! 315: break; ! 316: ! 317: case STRING: ! 318: // avoid printing very long lines ! 319: ntok += 4; ! 320: fprintf(out_file,"\"%s\"",string); ! 321: break; ! 322: ! 323: case THIS: ! 324: case ZERO: ! 325: putstring("0 "); ! 326: break; ! 327: ! 328: case IVAL: ! 329: fprintf(out_file,"%d",i1); ! 330: break; ! 331: ! 332: case TEXT: ! 333: { ! 334: int oo = vtbl_opt; // make `simulated static' name ! 335: vtbl_opt = -1; ! 336: char* s = vtbl_name(string,string2); ! 337: vtbl_opt = oo; ! 338: s[2] = 'p'; // pointer, not tbl itself ! 339: char* t = ptbl_lookup(s); ! 340: fprintf(out_file, " %s",t); ! 341: delete t; ! 342: ! 343: char *str = 0; ! 344: if ( string ) { ! 345: str = new char[ strlen(string) + strlen(string2) + 1 ]; ! 346: strcpy( str, string ); ! 347: strcat( str, string2 ); ! 348: } ! 349: ! 350: if ( ptbl->look( str?str:string2, 0 ) == 0 && ! 351: ptbl->look( str?str:string2, HIDDEN ) == 0 ) { ! 352: Pname nn = ptbl->insert(new name(str?str:string2),0); ! 353: nn->string2 = new char[strlen(s)+1]; ! 354: strcpy(nn->string2,s); ! 355: } ! 356: ! 357: delete str; ! 358: delete s; ! 359: } ! 360: // no break; ! 361: ! 362: case DUMMY: ! 363: break; ! 364: ! 365: case G_CALL: ! 366: case CALL: ! 367: { Pname fn = fct_name; ! 368: Pname at; ! 369: int m_ptr = 0; ! 370: ! 371: if (fn) { ! 372: Pfct f = Pfct(fn->tp); ! 373: ! 374: if (f->base==OVERLOAD) { // overloaded after call ! 375: fct_name = fn = Pgen(f)->fct_list->f; ! 376: f = Pfct(fn->tp); ! 377: } ! 378: ! 379: fn->print(); ! 380: at = f->f_args; ! 381: } ! 382: else { ! 383: Pfct f = Pfct(e1->tp); ! 384: ! 385: if (f) { // pointer to fct ! 386: Pexpr exex = e1; ! 387: if ( exex->base == DEREF ) { ! 388: exex = exex->e1; ! 389: while ( exex->base == CAST ) ! 390: exex = exex->e1; ! 391: if ( exex->base == MDOT ) ! 392: m_ptr = 1; ! 393: } ! 394: ! 395: if (f->base == OVERLOAD) { // overloaded after call ! 396: fct_name = fn = Pgen(f)->fct_list->f; ! 397: f = Pfct(fn->tp); ! 398: } ! 399: ! 400: f = Pfct(f->skiptypedefs()); ! 401: if (f->base == PTR) { ! 402: putstring("(*"); ! 403: e1->print(); ! 404: putch(')'); ! 405: f = Pfct(Pptr(f)->typ->skiptypedefs()); ! 406: } ! 407: else ! 408: eprint(e1); ! 409: ! 410: at = f->f_args; ! 411: } ! 412: else { // virtual: argtype encoded ! 413: // f_this already linked to f_result and/or argtype ! 414: at = (e1->base==QUEST) ? Pname(e1->e1->tp2) : Pname(e1->tp2); ! 415: eprint(e1); ! 416: } ! 417: } ! 418: ! 419: puttok(LP); ! 420: ! 421: if (e2) { ! 422: if (at) { ! 423: Pexpr e = e2; ! 424: while (at) { ! 425: Pexpr ex; ! 426: Ptype t = at->tp; ! 427: ! 428: if (t == 0) error('i',"T ofA missing for%n",fn); ! 429: if (e == 0) error('i',"%tA missing for%n",t,fn); ! 430: if (e->base == ELIST) { ! 431: ex = e->e1; ! 432: e = e->e2; ! 433: } ! 434: else ! 435: ex = e; ! 436: ! 437: if (ex == 0) error('i',"A ofT%t missing",t); ! 438: if (t!=ex->tp ! 439: && ex->tp ! 440: && t->check(ex->tp,0) ! 441: && t->is_cl_obj()==0 ! 442: && eobj==0 ! 443: && m_ptr == 0 ! 444: && (t->is_ptr()==0 || Mptr==0)) { ! 445: putch('('); ! 446: bit oc = Cast; ! 447: Cast = 1; ! 448: t->print(); ! 449: Cast = oc; ! 450: putch(')'); ! 451: #ifdef sun ! 452: if (ex->base == DIV) { // defend against perverse SUN cc bug ! 453: putstring("(0+"); ! 454: eprint(ex); ! 455: putch(')'); ! 456: } ! 457: else ! 458: #endif ! 459: eprint(ex); ! 460: } ! 461: else ! 462: ex->print(); ! 463: ! 464: // if m_ptr is set, then don't advance at ! 465: // at does not know about generated `this' ! 466: if ( m_ptr ) { ! 467: m_ptr = 0; ! 468: if (at) puttok(CM); ! 469: continue; ! 470: } ! 471: ! 472: at = at->n_list; ! 473: if (at) puttok(CM); ! 474: } ! 475: if (e) { ! 476: puttok(CM); ! 477: e->print(); ! 478: } ! 479: } ! 480: else ! 481: e2->print(); ! 482: } ! 483: puttok(RP); ! 484: break; ! 485: } ! 486: ! 487: case ASSIGN: ! 488: if (e1->base==ANAME && Pname(e1)->n_assigned_to==FUDGE111) { ! 489: // suppress assignment to "this" that has been optimized away ! 490: Pname n = Pname(e1); ! 491: int argno = int(n->n_val); ! 492: for (Pin il=curr_icall; il; il=il->i_next) ! 493: if (il->i_table == n->n_table) goto akk; ! 494: goto bkk; ! 495: akk: ! 496: if (il->i_args[argno].local == 0) { ! 497: e2->print(); ! 498: break; ! 499: } ! 500: } ! 501: //no break ! 502: case EQ: ! 503: case NE: ! 504: case GT: ! 505: case GE: ! 506: case LE: ! 507: case LT: ! 508: bkk: ! 509: { ! 510: Ptype t2 = e2->tp; ! 511: ! 512: eprint(e1); ! 513: puttok(base); ! 514: ! 515: if (e1->tp && e1->tp!=e2->tp && e2->base!=ZERO) { ! 516: // cast, but beware of int!=long etc. ! 517: Ptype t1 = e1->tp->skiptypedefs(); ! 518: switch (t1->base) { ! 519: default: ! 520: break; ! 521: case PTR: ! 522: case RPTR: ! 523: case VEC: ! 524: { Ptype t2 = e2->tp->skiptypedefs(); ! 525: ! 526: if (e2->tp==0 ! 527: || (Pptr(t1)->typ!=Pptr(t2)->typ && t1->check(t2,0))) { ! 528: putch('('); ! 529: bit oc = Cast; ! 530: Cast = 1; ! 531: e1->tp->print(); ! 532: Cast = oc; ! 533: putch(')'); ! 534: } ! 535: } ! 536: } ! 537: } ! 538: ! 539: eprint(e2); ! 540: break; ! 541: } ! 542: ! 543: case DEREF: ! 544: if (e2) { ! 545: ! 546: eprint(e1); ! 547: putch('['); ! 548: eprint(e2); ! 549: putch(']'); ! 550: } ! 551: else { ! 552: putch('('); ! 553: putch('*'); ! 554: eprint(e1); ! 555: putch(')'); ! 556: } ! 557: break; ! 558: ! 559: case ILIST: ! 560: puttok(LC); ! 561: if (e1) e1->print(); ! 562: if (e2) { // member pointer initiliazers ! 563: puttok(CM); ! 564: e2->print(); ! 565: } ! 566: puttok(RC); ! 567: break; ! 568: ! 569: case ELIST: ! 570: { Pexpr e = this; ! 571: for(;;) { ! 572: if (e->base == ELIST) { ! 573: e->e1->print(); ! 574: if (e = e->e2) { ! 575: puttok(CM); ! 576: } ! 577: else ! 578: return; ! 579: } ! 580: else { ! 581: e->print(); ! 582: return; ! 583: } ! 584: } ! 585: } ! 586: ! 587: case QUEST: ! 588: { // look for (&a == 0) etc. ! 589: Neval = 0; ! 590: binary_val = 1; ! 591: long i = cond->eval(); ! 592: binary_val = 0; ! 593: if (Neval == 0) ! 594: (i?e1:e2)->print(); ! 595: else { ! 596: eprint(cond); ! 597: putch('?'); ! 598: eprint(e1); ! 599: putch(':'); ! 600: eprint(e2); ! 601: } ! 602: break; ! 603: } ! 604: ! 605: case CM: // do &(a,b) => (a,&b) for previously checked inlines ! 606: case G_CM: ! 607: puttok(LP); ! 608: switch (e1->base) { ! 609: case ZERO: ! 610: case IVAL: ! 611: case ICON: ! 612: case NAME: ! 613: case MDOT: ! 614: case DOT: ! 615: case REF: ! 616: case FCON: ! 617: case STRING: ! 618: goto le2; // suppress constant a: &(a,b) => (&b) ! 619: default: ! 620: { int oo = addrof_cm; // &(a,b) does not affect a ! 621: addrof_cm = 0; ! 622: eprint(e1); ! 623: addrof_cm = oo; ! 624: } ! 625: puttok(CM); ! 626: le2: ! 627: if (addrof_cm) { ! 628: switch (e2->base) { ! 629: case CAST: ! 630: if (e2->e2) ! 631: switch (e2->e2->base) { ! 632: case CM: ! 633: case G_CM: ! 634: case ICALL: goto ec; ! 635: } ! 636: case NAME: ! 637: case MDOT: ! 638: case DOT: ! 639: case DEREF: ! 640: case REF: ! 641: case ANAME: ! 642: puttok(ADDROF); ! 643: addrof_cm--; ! 644: eprint(e2); ! 645: addrof_cm++; ! 646: break; ! 647: case ICALL: ! 648: case CM: ! 649: case G_CM: ! 650: ec: ! 651: eprint(e2); ! 652: break; ! 653: case G_CALL: ! 654: /* & ( e, ctor() ) with temporary optimized away */ ! 655: if (e2->fct_name ! 656: && e2->fct_name->n_oper==CTOR) { ! 657: addrof_cm--; ! 658: eprint(e2); ! 659: addrof_cm++; ! 660: break; ! 661: } ! 662: default: ! 663: error('i',"& inlineF call (%k)",e2->base); ! 664: } ! 665: } ! 666: else ! 667: eprint(e2); ! 668: puttok(RP); ! 669: } ! 670: break; ! 671: ! 672: case ADDROF: ! 673: case G_ADDROF: ! 674: switch (e2->base) { // & *e1 or &e1[e2] ! 675: case DEREF: ! 676: if (e2->e2 == 0) { // &*e == e ! 677: e2->e1->print(); ! 678: return; ! 679: } ! 680: break; ! 681: case ICALL: ! 682: addrof_cm++; // assumes inline expanded into ,-expression ! 683: eprint(e2); ! 684: addrof_cm--; ! 685: return; ! 686: case ASSIGN: // &(a=b) ??? works on many cc s ! 687: eprint(e2); // make sure it breaks! ! 688: return; ! 689: case NAME: { ! 690: Pname n = Pname(e2); ! 691: if(n->n_evaluated) { ! 692: n->n_evaluated=0; ! 693: puttok(ADDROF); ! 694: eprint(e2); ! 695: n->n_evaluated=1; ! 696: return; ! 697: } ! 698: break; ! 699: } ! 700: } ! 701: ! 702: // suppress cc warning on &fct ! 703: if (e2->tp==0 || e2->tp->base!=FCT) puttok(ADDROF); ! 704: ! 705: eprint(e2); ! 706: break; ! 707: ! 708: case PLUS: ! 709: case MINUS: ! 710: case MUL: ! 711: case DIV: ! 712: case MOD: ! 713: case LS: ! 714: case RS: ! 715: case AND: ! 716: case OR: ! 717: case ER: ! 718: case ANDAND: ! 719: case OROR: ! 720: case DECR: ! 721: case INCR: ! 722: case ASOR: ! 723: case ASER: ! 724: case ASAND: ! 725: case ASPLUS: ! 726: case ASMINUS: ! 727: case ASMUL: ! 728: case ASMOD: ! 729: case ASDIV: ! 730: case ASLS: ! 731: case ASRS: ! 732: eprint(e1); ! 733: // no break ! 734: case UPLUS: // only preserved for ansi_opt==1 ! 735: case UMINUS: ! 736: case NOT: ! 737: case COMPL: ! 738: puttok(base); ! 739: eprint(e2); ! 740: break; ! 741: ! 742: default: ! 743: error('i',"%p->E::print%k",this,base); ! 744: } ! 745: } ! 746: ! 747: Pexpr aval(Pname a) ! 748: { ! 749: int argno = int(a->n_val); ! 750: Pin il; ! 751: for (il=curr_icall; il; il=il->i_next) ! 752: if (il->i_table == a->n_table) goto aok; ! 753: return 0; ! 754: aok: ! 755: Pexpr aa = il->i_args[argno].arg; ! 756: ll: ! 757: switch (aa->base) { ! 758: case CAST: aa = aa->e1; goto ll; ! 759: case ANAME: return aval(Pname(aa)); ! 760: default: return aa; ! 761: } ! 762: } ! 763: ! 764: #define putcond() putch('('); e->print(); putch(')') ! 765: ! 766: static loc csloc = { 0, 0 }; // loc of last stmt with line!=0 ! 767: ! 768: void stmt::print() ! 769: { ! 770: //error('d',"S::print %d:%k s %d s_list %d",this,base,s,s_list); ! 771: if (where.line == 0) { ! 772: if (csloc.line) csloc.putline(); ! 773: } else { ! 774: csloc = where; ! 775: if (where.line!=last_line.line) ! 776: if (last_ll = where.line) ! 777: where.putline(); ! 778: else ! 779: last_line.putline(); ! 780: } ! 781: ! 782: if (memtbl && base!=BLOCK) { /* also print declarations of temporaries */ ! 783: puttok(LC); ! 784: Ptable tbl = memtbl; ! 785: memtbl = 0; ! 786: int i; ! 787: int bl = 1; ! 788: for (Pname n=tbl->get_mem(i=1); n; n=tbl->get_mem(++i)){ ! 789: if (n->tp == any_type) continue; ! 790: /* avoid double declarartion of temporaries from inlines */ ! 791: char* s = n->string; ! 792: if (s[0]!='_' || s[1]!='_' || s[2]!='X') { ! 793: n->dcl_print(0); ! 794: bl = 0; ! 795: } ! 796: Pname cn; ! 797: if (bl ! 798: && (cn=n->tp->is_cl_obj()) ! 799: && Pclass(cn->tp)->has_dtor()) bl = 0; ! 800: } ! 801: if ( last_ll==0 && (last_ll = where.line) ) ! 802: where.putline(); ! 803: if (bl) { ! 804: Pstmt sl = s_list; ! 805: s_list = 0; ! 806: print(); ! 807: memtbl = tbl; ! 808: puttok(RC); ! 809: if (sl) { ! 810: s_list = sl; ! 811: sl->print(); ! 812: } ! 813: } ! 814: else { ! 815: print(); ! 816: memtbl = tbl; ! 817: puttok(RC); ! 818: } ! 819: return; ! 820: } ! 821: ! 822: switch (base) { ! 823: default: ! 824: error('i',"S::print(base=%k)",base); ! 825: ! 826: case ASM: ! 827: fprintf(out_file,"asm(\"%s\");\n",(char*)e); ! 828: break; ! 829: ! 830: case DCL: ! 831: d->dcl_print(SM); ! 832: break; ! 833: ! 834: case BREAK: ! 835: case CONTINUE: ! 836: puttok(base); ! 837: puttok(SM); ! 838: break; ! 839: ! 840: case DEFAULT: ! 841: puttok(base); ! 842: putch(':'); ! 843: s->print(); ! 844: break; ! 845: ! 846: case SM: ! 847: if (e) { ! 848: e->print(); ! 849: if (e->base==ICALL && e->e2) break; /* a block: no SM */ ! 850: } ! 851: puttok(SM); ! 852: break; ! 853: ! 854: case WHILE: ! 855: puttok(WHILE); ! 856: putcond(); ! 857: if (s->s_list) { ! 858: puttok(LC); ! 859: s->print(); ! 860: puttok(RC); ! 861: } ! 862: else ! 863: s->print(); ! 864: break; ! 865: ! 866: case DO: ! 867: puttok(DO); ! 868: s->print(); ! 869: puttok(WHILE); ! 870: putcond(); ! 871: puttok(SM); ! 872: break; ! 873: ! 874: case SWITCH: ! 875: puttok(SWITCH); ! 876: putcond(); ! 877: s->print(); ! 878: break; ! 879: ! 880: case RETURN: ! 881: { ! 882: puttok(RETURN); ! 883: if (e) { ! 884: //error('d',"print return rt %t etp %t",ret_tp,e->tp); ! 885: if (ret_tp && ret_tp!=e->tp) { ! 886: Ptype tt = ret_tp->skiptypedefs(); ! 887: ! 888: switch (tt->base) { ! 889: case COBJ: ! 890: break; // cannot cast to struct ! 891: case RPTR: ! 892: case PTR: ! 893: if (Pptr(tt)->typ==Pptr(e->tp)->typ) break; ! 894: if (Pptr(tt)->memof) break; ! 895: default: ! 896: if (e->tp==0 || ret_tp->check(e->tp,0)) { ! 897: int oc = Cast; ! 898: putch('('); ! 899: Cast = 1; ! 900: ret_tp->print(); ! 901: Cast = oc; ! 902: putch(')'); ! 903: } ! 904: } ! 905: } ! 906: eprint(e); ! 907: } ! 908: puttok(SM); ! 909: } ! 910: while (s_list && s_list->base==SM) s_list = s_list->s_list; // FUDGE!! ! 911: break; ! 912: ! 913: case CASE: ! 914: puttok(CASE); ! 915: eprint(e); ! 916: putch(':'); ! 917: s->print(); ! 918: break; ! 919: ! 920: case GOTO: ! 921: puttok(GOTO); ! 922: d->print(); ! 923: puttok(SM); ! 924: break; ! 925: ! 926: case LABEL: ! 927: d->print(); ! 928: putch(':'); ! 929: s->print(); ! 930: break; ! 931: ! 932: case IF: ! 933: { int val = QUEST; ! 934: if (e->base == ANAME) { ! 935: Pname a = Pname(e); ! 936: Pexpr arg = aval(a); ! 937: //error('d',"arg %d%k %d (%d)",arg,arg?arg->base:0,arg?arg->base:0,arg?arg->e1:0); ! 938: if (arg) ! 939: switch (arg->base) { ! 940: case ZERO: val = 0; break; ! 941: case ADDROF: ! 942: case G_ADDROF: val = 1; break; ! 943: case IVAL: val = arg->i1!=0; ! 944: } ! 945: } ! 946: //error('d',"val %d",val); ! 947: switch (val) { ! 948: case 1: ! 949: s->print(); ! 950: break; ! 951: case 0: ! 952: if (else_stmt) ! 953: else_stmt->print(); ! 954: else ! 955: puttok(SM); /* null statement */ ! 956: break; ! 957: default: ! 958: puttok(IF); ! 959: putcond(); ! 960: if (s->s_list) { ! 961: puttok(LC); ! 962: s->print(); ! 963: puttok(RC); ! 964: } ! 965: else ! 966: s->print(); ! 967: if (else_stmt) { ! 968: if (else_stmt->where.line == 0) { ! 969: if (csloc.line) csloc.putline(); ! 970: } else { ! 971: csloc = else_stmt->where; ! 972: if (else_stmt->where.line!=last_line.line) ! 973: if (last_ll = else_stmt->where.line) ! 974: else_stmt->where.putline(); ! 975: else ! 976: last_line.putline(); ! 977: } ! 978: puttok(ELSE); ! 979: if (else_stmt->s_list) { ! 980: puttok(LC); ! 981: else_stmt->print(); ! 982: puttok(RC); ! 983: } ! 984: else ! 985: else_stmt->print(); ! 986: } ! 987: } ! 988: break; ! 989: } ! 990: ! 991: case FOR: ! 992: { ! 993: int fi = 0; // is the initializer statement an expression? ! 994: if (for_init) { ! 995: fi = 1; ! 996: if (for_init->memtbl==0 && for_init->s_list==0) ! 997: if (for_init->base==SM) ! 998: if (for_init->e->base!=ICALL || for_init->e->e1) ! 999: fi = 0; ! 1000: } ! 1001: //error('d',"for(; %d%k; %d%k)",e,e->base,e2,e2->base); ! 1002: if (fi) { ! 1003: puttok(LC); ! 1004: for_init->print(); ! 1005: } ! 1006: putstring("for("); ! 1007: if (fi==0 && for_init) for_init->e->print(); ! 1008: putch(';'); // to avoid newline: not puttok(SM) ! 1009: if (e) e->print(); ! 1010: putch(';'); ! 1011: if (e2) e2->print(); ! 1012: puttok(RP); ! 1013: s->print(); ! 1014: if (fi) puttok(RC); ! 1015: break; ! 1016: } ! 1017: ! 1018: case PAIR: ! 1019: if (s&&s2) { ! 1020: puttok(LC); ! 1021: s->print(); ! 1022: s2->print(); ! 1023: puttok(RC); ! 1024: } ! 1025: else { ! 1026: if (s) s->print(); ! 1027: if (s2) s2->print(); ! 1028: } ! 1029: break; ! 1030: ! 1031: case BLOCK: ! 1032: puttok(LC); ! 1033: //error('d',"block %d d %d memtbl %d own_tbl %d",this,d,memtbl,own_tbl); ! 1034: if (d) d->dcl_print(SM); ! 1035: if (memtbl && own_tbl) { ! 1036: Pname n; ! 1037: int i; ! 1038: for (n=memtbl->get_mem(i=1); n; n=memtbl->get_mem(++i)) { ! 1039: if (n->tp && n->n_union==0 && n->tp!=any_type) ! 1040: switch (n->n_scope) { ! 1041: case ARGT: ! 1042: case ARG: ! 1043: break; ! 1044: default: ! 1045: // error('d', "n: %s %k n_key: %k", n->string, n->base, n->n_key); ! 1046: if ( n->base == TNAME && n->n_key == NESTED ) ! 1047: continue; // printed from nested class ! 1048: n->dcl_print(0); ! 1049: } ! 1050: } ! 1051: if (last_ll==0 && s && (last_ll=s->where.line)) ! 1052: s->where.putline(); ! 1053: } ! 1054: if (s) s->print(); ! 1055: if (where2.line == 0) { ! 1056: if (csloc.line) csloc.putline(); ! 1057: } else { ! 1058: csloc = where2; ! 1059: if (where2.line!=last_line.line) ! 1060: if (last_ll = where2.line) ! 1061: where2.putline(); ! 1062: else ! 1063: last_line.putline(); ! 1064: } ! 1065: putstring("}\n"); ! 1066: if (last_ll && where.line) last_line.line++; ! 1067: } ! 1068: ! 1069: if (s_list) s_list->print(); ! 1070: } ! 1071: ! 1072: /* ! 1073: void table::dcl_print(TOK s, TOK pub) ! 1074: ! 1075: // print the declarations of the entries in the order they were inserted ! 1076: // ignore labels (tp==0) ! 1077: ! 1078: { ! 1079: register Pname* np; ! 1080: register int i; ! 1081: ! 1082: if (this == 0) return; ! 1083: ! 1084: np = entries; ! 1085: for (i=1; i<free_slot; i++) { ! 1086: register Pname n = np[i]; ! 1087: switch (s) { ! 1088: case 0: ! 1089: n->dcl_print(0); ! 1090: break; ! 1091: case EQ: ! 1092: if (n->tp && n->n_scope == pub) n->dcl_print(0); ! 1093: break; ! 1094: case NE: ! 1095: if (n->tp && n->n_scope != pub) n->dcl_print(0); ! 1096: break; ! 1097: } ! 1098: } ! 1099: } ! 1100: */ ! 1101: ! 1102: struct ptbl_rec { ! 1103: char* pname; ! 1104: char* vname; ! 1105: ptbl_rec* next; ! 1106: }; ! 1107: ! 1108: static char* ptbl_name; ! 1109: static ptbl_rec* ptbl_rec_lookup_head = 0; ! 1110: static ptbl_rec* ptbl_rec_pair_head = 0; ! 1111: ! 1112: void ptbl_init(int flag) ! 1113: { ! 1114: if (!flag) { ! 1115: char *p = st_name( "__ptbl_vec__" ); ! 1116: ptbl_name = new char[strlen(p)+1]; ! 1117: strcpy(ptbl_name, p); ! 1118: delete p; ! 1119: fprintf(out_file, "extern struct __mptr* %s[];\n", ptbl_name); ! 1120: if (last_ll) last_line.line++; ! 1121: } ! 1122: else { ! 1123: ptbl_rec *r, *p = ptbl_rec_lookup_head; ! 1124: if ( p == 0 ) return; // don't generate an empty object ! 1125: fprintf(out_file, "struct __mptr* %s[] = {\n", ptbl_name); ! 1126: if (last_ll) last_line.line++; ! 1127: int i = 0; ! 1128: while (p != 0) { ! 1129: r = ptbl_rec_pair_head; ! 1130: while (r && strcmp(r->pname, p->pname)) ! 1131: r = r->next; ! 1132: fprintf(out_file, "%s,\n", r->vname); ! 1133: if (last_ll) last_line.line++; ! 1134: p = p->next; ! 1135: } ! 1136: fprintf(out_file, "\n};\n"); ! 1137: if (last_ll) last_line.line += 2; ! 1138: } ! 1139: } ! 1140: ! 1141: char* ptbl_lookup(char *name) ! 1142: { ! 1143: ptbl_rec *r, *s, *p = ptbl_rec_lookup_head; ! 1144: int i = 0; ! 1145: ! 1146: while (p && strcmp(name, p->pname)) { ! 1147: r = p; ! 1148: p = p->next; ! 1149: i++; ! 1150: } ! 1151: ! 1152: if (p == 0) { ! 1153: s = new ptbl_rec; ! 1154: s->pname = new char[strlen(name) + 1]; ! 1155: s->vname = 0; ! 1156: s->next = 0; ! 1157: strcpy(s->pname, name); ! 1158: if (ptbl_rec_lookup_head == 0) ! 1159: ptbl_rec_lookup_head = s; ! 1160: else r->next = s; ! 1161: } ! 1162: ! 1163: char *pp = new char[ strlen(ptbl_name) + 10 ]; ! 1164: sprintf(pp, "%s[%d]", ptbl_name, i); ! 1165: return(pp); ! 1166: } ! 1167: ! 1168: void ptbl_add_pair(char* ptbl, char* vtbl) ! 1169: { ! 1170: // error('d', "ptbl_add_pair: ptbl: %s, vtbl: %s", ptbl, vtbl ); ! 1171: ptbl_rec *p = new ptbl_rec; ! 1172: ! 1173: p->pname = new char[strlen(ptbl) + 1]; ! 1174: strcpy(p->pname, ptbl); ! 1175: p->vname = new char[strlen(vtbl) + 1]; ! 1176: ! 1177: strcpy(p->vname, vtbl); ! 1178: p->next = ptbl_rec_pair_head; ! 1179: ! 1180: ptbl_rec_pair_head = p; ! 1181: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.