![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to simpl2.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 simpl2.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / ptcfront |
1.1 ! root 1: /*ident "@(#)ctrans:src/simpl2.c 1.13" */ ! 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: simpl2.c: ! 11: ! 12: simplify the typechecked function ! 13: remove: classes: ! 14: class fct-calls ! 15: operators ! 16: value constructors and destructors ! 17: new and delete operators (replace with function calls) ! 18: initializers (turn them into statements) ! 19: constant expressions (evaluate them) ! 20: inline functions (expand the calls) ! 21: enums (make const ints) ! 22: unreachable code (delete it) ! 23: make implicit coersions explicit ! 24: ! 25: in general you cannot simplify something twice ! 26: ! 27: *******************************************************************/ ! 28: ! 29: #include "cfront.h" ! 30: #include "size.h" ! 31: #include <ctype.h> ! 32: ! 33: extern Pname Ntmp; ! 34: extern Pnlist inllist; ! 35: Pname find_vptr(Pclass); ! 36: extern is_probably_temp(char*); ! 37: ! 38: extern int no_of_returns; ! 39: ! 40: extern Pname new_fct; ! 41: //extern Pname del_fct; ! 42: ! 43: extern Pstmt del_list; ! 44: extern Pstmt break_del_list; ! 45: extern Pstmt continue_del_list; ! 46: ! 47: extern Pname curr_fct; // current function ! 48: extern Pexpr init_list; ! 49: extern int imeasure; ! 50: ! 51: Pexpr cdvec(Pname f, Pexpr vec, Pclass cl, Pname cd, int tail, Pexpr i, Pexpr vec2) ! 52: /* ! 53: generate a call to construct or destroy the elements of a vector ! 54: */ ! 55: { ! 56: Pexpr sz = new texpr(SIZEOF,cl,0); // sizeof elem ! 57: sz->tp = uint_type; ! 58: (void) cl->tsizeof(); ! 59: ! 60: Pexpr esz = new texpr(SIZEOF,cl,0); // noe = sizeof(vec)/sizeof(elem) ! 61: esz->tp = int_type; ! 62: ! 63: Pexpr noe; ! 64: if (vec2) ! 65: noe = new texpr(SIZEOF,vec2->tp,0); ! 66: else noe = new texpr(SIZEOF,vec->tp,0); ! 67: ! 68: // Pexpr noe = new texpr(SIZEOF,vec->tp,0); ! 69: noe->tp = int_type; ! 70: noe = new expr(DIV,noe,esz); ! 71: noe->tp = uint_type; ! 72: // error('d',"cdvec tail %d i %d",tail,i); ! 73: // Pexpr arg = (0<=tail) ? new expr(ELIST,zero,0) : 0; // 0 or 1 for dtors ! 74: Pexpr arg = (i) ? new expr(ELIST,i,0) : 0; ! 75: arg = (0<=tail) ? new expr(ELIST,zero,arg) : arg; // 0 or 1 for dtors ! 76: arg = new expr(ELIST,cd,arg); // constructor or destructor ! 77: cd->lval(ADDROF); // cd->take_addr(); ! 78: ! 79: arg = new expr(ELIST,sz,arg); ! 80: arg = new expr(ELIST,noe,arg); ! 81: arg = new expr(ELIST,vec,arg); ! 82: ! 83: arg = new call(f,arg); ! 84: arg->base = G_CALL; ! 85: arg->fct_name = f; ! 86: ! 87: return arg; ! 88: } ! 89: ! 90: /* ! 91: int new_used; // pre-define new and delete only if the user didn't ! 92: ! 93: void new_init() ! 94: { ! 95: char* ns = oper_name(NEW); ! 96: char* ds = oper_name(DELETE); ! 97: ! 98: new_used = 1; ! 99: ! 100: new_fct = gtbl->look(ns,0); ! 101: del_fct = gtbl->look(ds,0); ! 102: ! 103: if (new_fct && !del_fct) ! 104: error('w',"%n defined but not operator delete()",new_fct); ! 105: if (del_fct && !new_fct) ! 106: error('w',"%n defined but not operator new()",del_fct); ! 107: ! 108: if (Pfct(new_fct->tp)->body==0) new_fct->dcl_print(0); ! 109: if (Pfct(del_fct->tp)->body==0) del_fct->dcl_print(0); ! 110: } ! 111: */ ! 112: Pstmt trim_tail(Pstmt tt) ! 113: /* ! 114: strip off statements after RETURN etc. ! 115: NOT general: used for stripping off spurious destructor calls ! 116: */ ! 117: { ! 118: if (tt == 0) return 0; ! 119: ! 120: while (tt->s_list) { ! 121: Pstmt tpx; ! 122: switch (tt->base) { ! 123: case PAIR: ! 124: tpx = trim_tail(tt->s2); ! 125: goto tpxl; ! 126: case BLOCK: ! 127: tpx = trim_tail(tt->s); ! 128: tpxl: ! 129: if (tpx == 0) return 0; ! 130: ! 131: switch (tpx->base) { ! 132: case SM: ! 133: break; ! 134: case CONTINUE: ! 135: case BREAK: ! 136: case GOTO: ! 137: case RETURN: ! 138: if (tt->s_list->base != LABEL) tt->s_list = 0; ! 139: default: ! 140: return tpx; ! 141: } ! 142: default: ! 143: if (tt = tt->s_list) break; ! 144: return 0; ! 145: case RETURN: ! 146: if (tt->s_list->base != LABEL) tt->s_list = 0; ! 147: return tt; ! 148: } ! 149: } ! 150: ! 151: switch (tt->base) { ! 152: case PAIR: return trim_tail(tt->s2); ! 153: // case LABEL: return trim_tail(tt->s); ! 154: case BLOCK: if (tt->s) return trim_tail(tt->s); ! 155: default: return tt; ! 156: } ! 157: } ! 158: ! 159: extern Ptype Pfct_type; ! 160: ! 161: Pexpr mptr_assign(Pexpr n, Pexpr in) ! 162: { ! 163: Pexpr i1; ! 164: Pexpr i2; ! 165: Pexpr i3; ! 166: ! 167: if ( n->base == NAME ) ! 168: Pname(n)->use(); ! 169: ! 170: if (in->base == NAME) { ! 171: i1 = new mdot("d",in); ! 172: i1->i1 = 9; ! 173: i2 = new mdot("i",in); ! 174: i2->i1 = 9; ! 175: i3 = new mdot("f",in); ! 176: i3->i1 = 9; ! 177: } ! 178: else { ! 179: i1 = in->e1->e1; ! 180: i2 = in->e1->e2; ! 181: i3 = in->e2; ! 182: } ! 183: Pexpr nd = new mdot("d",n); ! 184: nd->i1 = 9; ! 185: Pexpr e1 = new expr(ASSIGN,nd,i1); ! 186: ! 187: Pexpr ni = new mdot("i",n); ! 188: ni->i1 = 9; ! 189: Pexpr e2 = new expr(ASSIGN,ni,i2); ! 190: ! 191: Pexpr nf = new mdot("f",n); ! 192: nf->i1 = 9; ! 193: // Pexpr ii = in->e2; //new cast(Pfct_type,in->e2); ! 194: Pexpr e3 = new expr(ASSIGN,nf,i3); ! 195: ! 196: Pexpr ee = new expr(CM,e2,e3); ! 197: return new expr(CM,e1,ee); ! 198: } ! 199: ! 200: /* ! 201: * to move up dtors in && and || expressions ! 202: * need to keep track of temporaries handled ! 203: * not to destroy twice :: recognized in expr::typ ! 204: * actual rewriting is initiated in stmt::simpl ! 205: * need_lift_dtors(): predicate: yes, proceed ! 206: * make_dtor_expr(): create dtor expr ! 207: * find_temps_in_expr(): temporaries to make_dtor ! 208: * lift_dtor(): actually rewrite the &&/|| expression ! 209: */ ! 210: static Ptable tmp_tbl = new table(CTBLSIZE,0,0); ! 211: static Pname tmp_list; ! 212: static Ptable Ntmp_tbl; // if Cstmt set, use Cstmt->memtbl ! 213: static bit need_lift; ! 214: Pexpr Ntmp_dtor; ! 215: ! 216: static bit ! 217: need_lift_dtors(Pexpr e) ! 218: { // confirm that expression requires lifting ! 219: // error('d',"need_lift_dtors( %d %k )", e, e->base); ! 220: Pexpr ee, ex; ! 221: ! 222: for (ex = Ntmp_dtor; ex; ex = ex->e2) { ! 223: ee = ex->e1; ! 224: if ( ee == e ) break; ! 225: } ! 226: if ( !ex ) return 0; ! 227: return 1; ! 228: } ! 229: ! 230: static Pexpr ! 231: make_dtor_expr(Pname nl) ! 232: { ! 233: Pexpr dl=0; ! 234: Pname n; ! 235: ! 236: for (n = nl; n; n=n->n_list) { ! 237: // error('d',"make_dtor_expr: nl: %n", n ); ! 238: // if (tmp_tbl->look(n->string,0)) continue; ! 239: tmp_tbl->insert(n,DUMMY); ! 240: Pname cln = n->tp->is_cl_obj(); ! 241: Pname d = Pclass(cln->tp)->has_dtor(); ! 242: Pexpr e = call_dtor(n,d,0,DOT,one); ! 243: if (dl == 0 ) ! 244: dl = e; ! 245: else { ! 246: dl = new expr(CM,dl,e); ! 247: dl->tp = e->tp; ! 248: } ! 249: } ! 250: dl->simpl(); ! 251: return dl; ! 252: } ! 253: ! 254: static void ! 255: find_temps_in_expr(Pexpr e, char *s=0) ! 256: { ! 257: if ( e == 0 ) return; ! 258: ! 259: switch ( e->base ) { ! 260: case QUEST: ! 261: if (s && tmp_list) return; ! 262: find_temps_in_expr( e->cond,s ); // no break ! 263: default: ! 264: if (s && tmp_list) return; ! 265: find_temps_in_expr( e->e1,s ); ! 266: if (s && tmp_list) return; ! 267: find_temps_in_expr( e->e2,s ); ! 268: return; ! 269: case REF: case DOT: ! 270: if (s && tmp_list) return; ! 271: find_temps_in_expr( e->e1,s ); // no break ! 272: case MDOT: ! 273: // find_temps_in_expr( e->mem ); // no break ! 274: case SIZEOF: case ZERO: ! 275: case TNAME: case STRING: ! 276: case ICON: case ID: ! 277: case FCON: case CCON: ! 278: case IVAL: case BLOCK: ! 279: return; ! 280: case NAME: ! 281: Pname n = Pname(e); ! 282: Pname cln = n->tp->is_cl_obj(); ! 283: if (cln && ! 284: Pclass(cln->tp)->has_dtor() && ! 285: is_probably_temp(n->string) ) ! 286: { ! 287: // error('d',"find_temps_in_expr n %n s %s", n,s); ! 288: ! 289: if (s) { ! 290: if (strcmp(s,n->string)==0) ! 291: tmp_list = n; ! 292: return; ! 293: } ! 294: ! 295: if (tmp_list==0) ! 296: tmp_list = n; ! 297: else { ! 298: Pname nn = tmp_list; ! 299: if ( n == nn ) return; ! 300: while (nn->n_list) { ! 301: nn=nn->n_list; ! 302: if ( n == nn ) return; ! 303: } ! 304: nn->n_list = n; ! 305: } ! 306: } ! 307: return; ! 308: } ! 309: } ! 310: ! 311: static bit ! 312: find_in_Ntmp(char *s) ! 313: { // does `s' occur within Ntmp ! 314: // error('d',"find_in_ntmp( %s )", s); ! 315: Pexpr ee, ex; ! 316: ! 317: tmp_list = 0; ! 318: for (ex = Ntmp_dtor; ex; ex = ex->e2) { ! 319: ee = ex->e1; ! 320: find_temps_in_expr(ee,s); ! 321: if (tmp_list) { tmp_list = 0; return 1; } ! 322: } ! 323: return 0; ! 324: } ! 325: ! 326: static Pexpr ! 327: lift_dtors(Pexpr e, Ptable tbl) ! 328: { ! 329: // find class object temporaries in expression ! 330: tmp_list = 0; find_temps_in_expr( e->e1 ); ! 331: Pname n1 = tmp_list; tmp_list = 0; ! 332: ! 333: find_temps_in_expr( e->e2 ); ! 334: Pname n2 = tmp_list; tmp_list = 0; ! 335: ! 336: // generate dtor calls and rewrite expressions ! 337: Pexpr dl = make_dtor_expr(n1); ! 338: ! 339: // error('d',"lift_dtor: e: tp %k e1->tp %k scope %d",e->tp->base,e->e1->tp->base,scope); ! 340: if (tbl == 0) tbl = scope; ! 341: ! 342: Ptype t = 0; ! 343: Pname tmp = 0; ! 344: Pexpr ex; ! 345: ! 346: if (dl) { ! 347: t = e->e1->tp; ! 348: tmp = make_tmp('Q',t,tbl); ! 349: tmp->n_assigned_to++; ! 350: ex = new expr(ASSIGN,tmp,e->e1); ex->tp = t; ! 351: e->e1 = ex; e->e1->tp =t; ! 352: e->e1 = new expr(CM,e->e1,dl); e->e1->tp = dl->tp; ! 353: e->e1 = new expr(CM,e->e1,tmp); e->e1->tp =t; ! 354: } ! 355: ! 356: dl = make_dtor_expr(n2); ! 357: ! 358: if (dl) { ! 359: // reuse same temp if possible ! 360: if ( e->e2->tp != t ) { ! 361: t = e->e1->tp; ! 362: tmp = make_tmp('Q',t,tbl); ! 363: } ! 364: tmp->n_assigned_to++; ! 365: ex = new expr(ASSIGN,tmp,e->e2); ex->tp = t; ! 366: e->e2 = ex; e->e2->tp =t; ! 367: e->e2 = new expr(CM,e->e2,dl); e->e2->tp = dl->tp; ! 368: e->e2 = new expr(CM,e->e2,tmp); e->e2->tp =t; ! 369: } ! 370: ! 371: return e; ! 372: } ! 373: ! 374: Pstmt block::simpl() ! 375: { ! 376: int i; ! 377: Pname n; ! 378: Pstmt ss=0, sst=0; ! 379: Pstmt dd=0, ddt=0; ! 380: Pstmt stail; ! 381: Ptable old_scope = scope; ! 382: need_lift = 0; ! 383: tmp_tbl->reinit(); ! 384: ! 385: DB( if(Sdebug>=1) ! 386: error('d',"%d->block::simple() own_tbl %d memtbl %d curr_fct%n",this,own_tbl,memtbl,curr_fct); ! 387: ); ! 388: // error('d',"%d->block::simpl() own_tbl %d memtbl %d curr_fct%n",this,own_tbl,memtbl,curr_fct); ! 389: if (own_tbl == 0) { ! 390: ss = (s) ? s->simpl() : 0; ! 391: return ss; ! 392: } ! 393: ! 394: scope = memtbl; ! 395: if (scope->init_stat == 0) scope->init_stat = 1; /* table is simplified. */ ! 396: ! 397: for (n=scope->get_mem(i=1); n; n=scope->get_mem(++i)) { ! 398: Pstmt st = 0; ! 399: Pname cln; ! 400: Pexpr in = n->n_initializer; ! 401: // error('d',"local %k %n in %k %t",n->n_sto,n,in?in->base:0,in?in->tp:0); ! 402: if (in || n->n_evaluated) { ! 403: scope->init_stat = 2; /* initializer in this scope */ ! 404: if (n->n_sto == EXTERN) { ! 405: error(&n->where,"Id local extern%n",n); ! 406: continue; ! 407: } ! 408: } ! 409: ! 410: switch (n->n_scope) { ! 411: case ARG: ! 412: case 0: ! 413: case PUBLIC: ! 414: continue; ! 415: } ! 416: ! 417: if (n->n_stclass == STATIC) { // local static class object ! 418: /* initialization of local static objects; ! 419: * set up first pass switch ! 420: * temp_switch ? 0 ! 421: * : (stat_obj=init_expr, temp_switch=1); ! 422: * ! 423: * ARGS: temporary class object in init_expr with dtor ! 424: * must call dtor once in std function ! 425: */ ! 426: ! 427: if ((in==0 && n->n_scope==ARGS) || ! 428: (in && in->base==STAT_INIT)) ! 429: { ! 430: Pname cn; ! 431: Pname x; ! 432: Ptype ct; ! 433: int vec_seen = 0; ! 434: ! 435: cn = n->tp->is_cl_obj(); ! 436: if ( cn == 0 ) { ++vec_seen; cn = cl_obj_vec; } ! 437: ! 438: if ( cn ) { ! 439: ct = new ptr(PTR,vec_seen?Pvec(n->tp)->typ:n->tp); ! 440: x = make_tmp('F', ct, gtbl ); ! 441: x->n_initializer = zero; ! 442: } ! 443: else ! 444: x = make_tmp('F',int_type,scope); ! 445: ! 446: x->n_sto = n->n_stclass = STATIC; ! 447: ! 448: if (in) { ! 449: if (in->e2) ! 450: in->base = ASSIGN; ! 451: else in = in->e1; ! 452: } ! 453: ! 454: Pexpr set; ! 455: if ( cn ) { ! 456: x->dcl_print(0); ! 457: Pclass cl = Pclass(cn->tp); ! 458: Pname dtor = cl->has_dtor(); ! 459: ! 460: Pexpr cc; ! 461: if ( dtor ) { ! 462: if ( vec_seen == 0 ) { ! 463: Pexpr eee = new expr(DEREF, x, 0 ); ! 464: Pexpr c = call_dtor(eee,dtor,0,DOT,one); ! 465: c->tp = any_type; ! 466: cc = new expr( QUEST, c, zero ); ! 467: cc->cond = x; ! 468: } ! 469: else cc = cdvec(vec_del_fct,x,cl,dtor,0,zero,n); ! 470: cc->tp = any_type; // arghh! ! 471: ! 472: Pstmt dls = new estmt( SM, n->where, cc, 0 ); ! 473: if ( st_dlist ) dls->s_list = st_dlist; ! 474: st_dlist = dls; ! 475: } ! 476: ! 477: Pexpr xe; ! 478: if (cn) { ! 479: if ( vec_seen == 0 ) ! 480: xe = new expr( G_ADDROF, 0, n ); ! 481: else { ! 482: Pexpr ee = new expr( DEREF, n, zero ); ! 483: xe = new expr( G_ADDROF, 0, ee ); ! 484: } ! 485: } ! 486: ! 487: set = new expr(ASSIGN,x,xe); ! 488: set->tp = ct; ! 489: } ! 490: else { ! 491: set = new expr(ASSIGN,x,one); ! 492: set->tp = int_type; ! 493: } ! 494: ! 495: // set pointer to static object and continue. ! 496: // sorry for goto, but beats rewriting code. ! 497: if ( n->n_scope == ARGS && in == 0 ) { ! 498: set = new expr( QUEST, zero, set ); ! 499: set->cond = x; ! 500: st = new estmt(SM,n->where,set,0); ! 501: goto init_stat3; ! 502: } ! 503: ! 504: in = new expr(G_CM,in,set); ! 505: in = new expr(STAT_INIT,zero,in); ! 506: in->cond = x; ! 507: } ! 508: else ! 509: continue; ! 510: } ! 511: ! 512: if ( in ) { ! 513: if ((in->base == ILIST && in->e2 == 0) || ! 514: (in->base == STRING && n->tp->base == VEC)) ! 515: if (ansi_opt==0) { ! 516: error('s',&n->where,"initialization of%n (automatic aggregate)",n); ! 517: continue; ! 518: } ! 519: else { ! 520: n->n_initializer=in; ! 521: continue; ! 522: } ! 523: } ! 524: ! 525: if (ansi_opt && in && n->tp->tconst()) { ! 526: n->n_initializer=in; ! 527: continue; ! 528: } ! 529: ! 530: if (n->tp == 0) continue; /* label */ ! 531: if (n->n_evaluated) continue; ! 532: ! 533: // error('d',"***** block::simpl: %n->check",n); ! 534: // construction and destruction of temporaries is handled locally ! 535: // `D' :: int; X; ==> generates int __D<some_number> */ ! 536: // note: does not appear necessary since all go to int ! 537: { ! 538: char* s = n->string; ! 539: register char c3 = s[3]; ! 540: if (s[0]=='_' && s[1]=='_' && s[2]=='D' && isdigit(c3)) ! 541: continue; ! 542: } ! 543: ! 544: if ( cln=n->tp->is_cl_obj() ) { ! 545: Pclass cl = Pclass(cln->tp); ! 546: Pname d = cl->has_dtor(); ! 547: ! 548: if ( n->n_stclass == STATIC // local static class object ! 549: && in && in->base==STAT_INIT ) ! 550: goto stat_init; ! 551: ! 552: if (d) { // n->cl.dtor(0); ! 553: // error('d',"***** block::simpl: %n->%t.dtor(0)",n,cl); ! 554: // special case: int i = foo() && foo(); ! 555: // dtors hoisted within stmt::simpl, called below ... ! 556: if ( Ntmp_dtor && ! 557: is_probably_temp(n->string) && ! 558: find_in_Ntmp(n->string)) ! 559: continue; ! 560: ! 561: ! 562: Pexpr dl = call_dtor(n,d,0,DOT,one); ! 563: // Pstmt dls = new estmt(SM,n->where,dl,0); ! 564: Pstmt dls = new estmt(SM,no_where,dl,0); ! 565: if (dd) { ! 566: dls->s_list = dd; ! 567: dd = dls; ! 568: } ! 569: else ! 570: ddt = dd = dls; ! 571: } ! 572: ! 573: // error('d',"%n: in %d",n,in?in->base:0); ! 574: if (in) { ! 575: switch (in->base) { ! 576: case DEREF: // *constructor? ! 577: if (in->e1->base == G_CALL) { ! 578: Pname fn = in->e1->fct_name; ! 579: if (fn==0 || fn->n_oper!=CTOR) goto ddd; ! 580: st = new estmt(SM,n->where,in->e1,0); ! 581: n->n_initializer = 0; ! 582: break; ! 583: } ! 584: goto ddd; ! 585: case STAT_INIT: ! 586: stat_init: ! 587: // error('d', "block::simpl: case #1 stat_init : n: %n", n ); ! 588: in->base = QUEST; ! 589: st = new estmt(SM,n->where,in,0); ! 590: n->n_initializer = 0; ! 591: break; ! 592: case G_CM: ! 593: st = new estmt(SM,n->where,in->e1,0); ! 594: n->n_initializer = 0; ! 595: break; ! 596: case ASSIGN: // assignment to "n"? ! 597: if (in->e1 == n) { ! 598: st = new estmt(SM,n->where,in,0); ! 599: n->n_initializer = 0; ! 600: break; ! 601: } ! 602: default: ! 603: goto ddd; ! 604: } ! 605: } ! 606: } ! 607: else if (cl_obj_vec) { ! 608: Pclass cl = Pclass(cl_obj_vec->tp); ! 609: Pname d = cl->has_dtor(); ! 610: Pname c = cl->has_ictor(); ! 611: n->n_initializer = 0; ! 612: ! 613: if ( n->n_stclass == STATIC // local static class object ! 614: && in && in->base==STAT_INIT ) ! 615: goto stat_init2; ! 616: ! 617: if (c) { // _vec_new(vec,noe,sz,ctor); ! 618: if (in==0 || in->base==ILIST) { ! 619: Pexpr a = cdvec(vec_new_fct,n,cl,c,-1,0); ! 620: st = new estmt(SM,n->where,a,0); ! 621: } ! 622: else ! 623: st = new estmt(SM,n->where,in,0); ! 624: } ! 625: // no default ctor but provided all elements with argument ! 626: else if ( in ) st = new estmt(SM,n->where,in,0); ! 627: ! 628: ! 629: if (d) { // __vec_delete(vec,noe,sz,dtor,0); ! 630: Pfct f = Pfct(d->tp); ! 631: int i = 0; ! 632: for (Pname nn = f->f_args->n_list; ! 633: nn && nn->n_list; nn=nn->n_list) i++; ! 634: Pexpr a = cdvec(vec_del_fct,n,cl,d,0,new ival(i)); ! 635: // Pstmt dls = new estmt(SM,n->where,a,0); ! 636: Pstmt dls = new estmt(SM,no_where,a,0); ! 637: if (dd) { ! 638: dls->s_list = dd; ! 639: dd = dls; ! 640: } ! 641: else ! 642: ddt = dd = dls; ! 643: } ! 644: } ! 645: else if (in) { ! 646: switch (in->base) { ! 647: case ILIST: ! 648: switch (n->n_scope) { ! 649: case FCT: ! 650: if (in->e2) { // pointer to member ! 651: Pexpr ee = mptr_assign(n,in); ! 652: st = new estmt(SM,n->where,ee,0); ! 653: n->n_initializer = 0; ! 654: break; ! 655: } ! 656: case ARG: ! 657: if (ansi_opt == 0) error('s',"Ir list for localV%n",n); ! 658: } ! 659: break; ! 660: case STAT_INIT: ! 661: stat_init2: ! 662: // error('d', "block::simpl: case #2 stat_init : n: %n", n ); ! 663: in->base = QUEST; ! 664: st = new estmt(SM,n->where,in,0); ! 665: n->n_initializer = 0; ! 666: break; ! 667: case STRING: ! 668: if (n->tp->base==VEC) break; /* BUG char vec only */ ! 669: default: ! 670: ddd: ! 671: { Pexpr ee = new expr(ASSIGN,n,in); ! 672: st = new estmt(SM,n->where,ee,0); ! 673: n->n_initializer = 0; ! 674: } ! 675: } ! 676: } ! 677: ! 678: init_stat3: if (st) { ! 679: if (ss) ! 680: sst->s_list = st; ! 681: else ! 682: ss = st; ! 683: sst = st; ! 684: } ! 685: } ! 686: ! 687: if (dd) { ! 688: Pstmt od = del_list; ! 689: Pstmt obd = break_del_list; ! 690: Pstmt ocd = continue_del_list; ! 691: ! 692: dd->simpl(); ! 693: del_list = (od) ? Pstmt(new pair(curloc,dd,od)) : dd; ! 694: break_del_list = (break_del_list&&obd) ? Pstmt(new pair(curloc,dd,obd)) : dd; ! 695: continue_del_list = (continue_del_list&&ocd) ? Pstmt(new pair(curloc,dd,ocd)) : dd; ! 696: ! 697: stail = s ? s->simpl() : 0; ! 698: ! 699: Pfct f = Pfct(curr_fct->tp); ! 700: if (this!=f->body ! 701: || f->returns->base==VOID ! 702: || (f->returns->base!=VOID && no_of_returns==0 ) // you have been warned! ! 703: || strcmp(curr_fct->string,"main")==0 ) { ! 704: // not dropping through the bottom of a value returning function ! 705: if (stail) { ! 706: Pstmt tt = (stail->base==RETURN || stail->base==LABEL) ? stail : trim_tail(stail); ! 707: if (tt && tt->base != RETURN) stail->s_list = dd; ! 708: } ! 709: else ! 710: s = dd; ! 711: stail = ddt; ! 712: } ! 713: ! 714: del_list = od; ! 715: continue_del_list = ocd; ! 716: break_del_list = obd; ! 717: } ! 718: else ! 719: stail = s ? s->simpl() : 0; ! 720: ! 721: if (ss) { /* place constructor calls */ ! 722: ss->simpl(); ! 723: sst->s_list = s; ! 724: s = ss; ! 725: if (stail == 0) stail = sst; ! 726: } ! 727: ! 728: need_lift = 0; ! 729: scope = old_scope; ! 730: ! 731: return stail; ! 732: } ! 733: ! 734: int no_sizeof; ! 735: void expr::simpl() ! 736: { ! 737: DB(if(Sdebug>=2){ ! 738: error('d',"%d->expr::simpl() %k",this,this?base:0); ! 739: if(Sdebug>=3) display_expr(this); ! 740: }); ! 741: if (this==0 || permanent==2) return; // already expanded ! 742: static TOK obase = 0; ! 743: ! 744: switch (base) { ! 745: case MDOT: ! 746: obase = base; ! 747: mem->simpl(); ! 748: obase = 0; ! 749: // no break ! 750: ! 751: case ICALL: // already expanded ! 752: return; ! 753: ! 754: case G_ADDROF: ! 755: case ADDROF: ! 756: // error('d',"simpl & %k",e2->base); ! 757: ! 758: e2->simpl(); ! 759: switch (e2->base) { ! 760: case DOT: ! 761: case REF: ! 762: { Pref r = Pref(e2); ! 763: Pname m = Pname(r->mem); ! 764: while (m->base == MDOT) m = Pname(m->mem); ! 765: if (m->n_stclass == STATIC) { // & static member ! 766: Pexpr x; ! 767: delp: ! 768: x = e2; ! 769: e2 = m; ! 770: r->mem = 0; ! 771: DEL(x); ! 772: } ! 773: else if (m->tp->base == FCT) { // & member fct ! 774: Pfct f = Pfct(m->tp); ! 775: if (f->f_virtual) { // &p->f ==> p->vtbl[fi].f ! 776: int index = f->f_virtual; ! 777: Pexpr ie = index ? new ival(index):0; ! 778: if (ie) ie->tp = int_type; ! 779: Pname cn = m->n_table->t_name; ! 780: Pname vp = find_vptr(Pclass(cn->tp)); ! 781: r->mem = vp; ! 782: ! 783: if ( obase == MDOT ) { ! 784: base = DEREF; ! 785: e1 = e2; ! 786: e2 = ie; ! 787: } ! 788: else { // support old style &b.vf ! 789: base = MDOT; ! 790: mem = new expr(DEREF,e2,ie); ! 791: string2 = "f"; ! 792: i1 = 9; ! 793: } ! 794: } ! 795: else { ! 796: goto delp; ! 797: } ! 798: } ! 799: break; ! 800: } ! 801: } ! 802: break; ! 803: ! 804: case ANDAND: ! 805: case OROR: ! 806: // error('d',"simpl::expr %k", base ); ! 807: if ( Ntmp_dtor && need_lift_dtors(this)) { ! 808: need_lift = 1; ! 809: Pexpr e = lift_dtors(this, Ntmp_tbl); ! 810: *this = *e; ! 811: } ! 812: Ntmp = 0; ! 813: // no break ! 814: ! 815: default: ! 816: if (e1) e1->simpl(); ! 817: if (e2) e2->simpl(); ! 818: break; ! 819: ! 820: case CM: ! 821: case G_CM: ! 822: { ! 823: Pname n = 0; ! 824: e1->simpl(); ! 825: e2->simpl(); ! 826: if (e1->base==ICALL && e1->e1==0) n = e1->il->fct_name; ! 827: if (e2->base==ICALL && e2->e1==0) n = e2->il->fct_name; ! 828: if (n) error('s',"cannot expand inline void%n called in commaE",n); ! 829: // no break ! 830: } ! 831: case NAME: ! 832: case DUMMY: ! 833: case ICON: ! 834: case FCON: ! 835: case CCON: ! 836: case IVAL: ! 837: // case FVAL: ! 838: // case LVAL: ! 839: case STRING: ! 840: case ZERO: ! 841: case ILIST: ! 842: // case MDOT: ! 843: return; ! 844: /* ! 845: case SIZEOF: ! 846: base = IVAL; ! 847: i1 = tp2->tsizeof(); ! 848: tp2 = 0; // can't DEL(tp2) ! 849: break; ! 850: */ ! 851: case SIZEOF: ! 852: if (e1) e1->simpl(); ! 853: return; ! 854: ! 855: case G_CALL: ! 856: case CALL: ! 857: Pcall(this)->simpl(); ! 858: break; ! 859: ! 860: case NEW: ! 861: case GNEW: ! 862: simpl_new(); ! 863: return; ! 864: ! 865: case DELETE: ! 866: case GDELETE: ! 867: simpl_delete(); ! 868: break; ! 869: ! 870: case QUEST: ! 871: cond->simpl(); ! 872: Ntmp = 0; ! 873: e2->simpl(); ! 874: // no break ! 875: ! 876: case CAST: ! 877: case REF: ! 878: e1->simpl(); ! 879: break; ! 880: ! 881: case DOT: ! 882: e1->simpl(); ! 883: switch (e1->base) { ! 884: case CM: ! 885: case G_CM: ! 886: { // &( , name). => ( ... , &name)-> ! 887: Pexpr ex = e1; ! 888: cfr: ! 889: switch (ex->e2->base) { ! 890: case NAME: ! 891: base = REF; ! 892: ex->e2 = ex->e2->address(); ! 893: break; ! 894: case CM: ! 895: case G_CM: ! 896: ex = ex->e2; ! 897: goto cfr; ! 898: } ! 899: } ! 900: } ! 901: break; ! 902: ! 903: case ASSIGN: ! 904: { ! 905: Pfct f = 0; ! 906: Pexpr th = 0; ! 907: if ( curr_fct ) { ! 908: f = Pfct(curr_fct->tp); ! 909: th = f->f_this; ! 910: } ! 911: ! 912: imeasure++; ! 913: if (e1) e1->simpl(); ! 914: if (e2) { ! 915: Pexpr c = e2; ! 916: c->simpl(); ! 917: while (c->base == CAST) c = c->e1; ! 918: if (c->base == ILIST) e2 = c; ! 919: ! 920: if (e2->base == ILIST) { // pointer to member assignment ! 921: Pexpr ee = mptr_assign(e1,e2); ! 922: Pexpr eee = new expr(CM,ee->e2,e1); ! 923: e1 = ee->e1; ! 924: e2 = eee; ! 925: base = CM; ! 926: delete ee; ! 927: } ! 928: } ! 929: ! 930: if (th && th==e1 && curr_fct->n_oper==CTOR && init_list) { ! 931: // this=e2 => (this=e2,init_list) ! 932: Pclass cl = Pclass(Pbase(Pptr(th->tp)->typ)->b_name->tp); ! 933: if (cl->c_body == 1) cl->dcl_print(0); ! 934: imeasure++; ! 935: base = CM; ! 936: e1 = new expr(ASSIGN,e1,e2); ! 937: e2 = init_list; ! 938: if (warning_opt) // timid ! 939: error('w',"assignment to ``this'' inK: try defining%t::operator new() instead",f->memof); ! 940: } ! 941: break; ! 942: } ! 943: } ! 944: ! 945: switch (base) { ! 946: case QUEST: ! 947: case ANDAND: ! 948: case OROR: ! 949: if (Ntmp) error('s',"temporary ofC%n with destructor needed in%kE",Ntmp,base); ! 950: // no break; ! 951: default: ! 952: Ntmp = 0; ! 953: } ! 954: ! 955: if (tp==int_type || tp==defa_type) { ! 956: Neval = 0; ! 957: no_sizeof = 1; // do not convert sizeof's to ints ! 958: long i = eval(); ! 959: no_sizeof = 0; ! 960: if (Neval == 0) { ! 961: base = IVAL; ! 962: i1 = i; ! 963: } ! 964: } ! 965: ! 966: } ! 967: ! 968: Pexpr vptr_entry(Pexpr pp, Pexpr ie, Pclass cl) ! 969: { ! 970: Pptr ttemp = pp->tp->is_ptr_or_ref(); ! 971: ! 972: if (ttemp) { ! 973: Ptype pt = ttemp->typ; // check if cast pp = (base*)pp ! 974: Pclass pc = Pclass(pt->is_cl_obj()->tp); // is needed ! 975: if (pc!=cl) pp = new cast(cl,pp); ! 976: } ! 977: Pname vp = find_vptr(cl); ! 978: if (vp == 0) { ! 979: if (cc->cot && cc->cot->in_class==cl) ! 980: error('s',"cannot inline virtual function call before class %s has been completely declared - try uninlining %n",cl->string,curr_fct); ! 981: else error('i',"can't find vptr"); ! 982: } ! 983: Pexpr vptr = new ref(REF,pp,vp); // pp->vptr ! 984: return new expr(DEREF,vptr,ie); // pp->vptr[i] ! 985: } ! 986: ! 987: Pexpr new_this(Pexpr pp, Pexpr ee) ! 988: { ! 989: //error('d',"new this"); ! 990: Pexpr dee = new mdot("d",ee); // pp->vptr[i].d ! 991: dee->i1 = 9; ! 992: Pexpr nthis = new cast(Pchar_type,pp); ! 993: nthis = new expr(PLUS,nthis,dee); // ((char*)pp)+delta ! 994: Ptype ct = pp->tp; ! 995: if (pp->base==NAME && Pname(pp)->n_xref) ct = pp->tp->addrof(); ! 996: return new cast(ct,nthis); ! 997: } ! 998: ! 999: Pcall vcall(Pexpr pp, Pexpr ie, Pfct f, Pclass cl, Pexpr args) ! 1000: /* ! 1001: generate a call of the virtual function with the index ``ie'' ! 1002: and type "f" in class ``cl'' for the object pointed to by ``pp'' ! 1003: ! 1004: multiple inheritance virtual call: ! 1005: ! 1006: p->f(x) is resolved like this ! 1007: pp = p; // avoid side effects ! 1008: pp = p.base_object; // often: pp = p; ! 1009: // done when the name was resolved ! 1010: i = index(f); ! 1011: entry = pp->_vtbl[i-1]; ! 1012: pp = (T*)(((char*)pp)+entry.d) ! 1013: (*(ftype)entry.f)(pp,x) ! 1014: */ ! 1015: { ! 1016: //error('d',"vcall %t",cl); ! 1017: if (cl->c_body==1) cl->dcl_print(0); // look for first use of cl ! 1018: ! 1019: imeasure+=6; ! 1020: Pexpr ee = vptr_entry(pp,ie,cl); ! 1021: ! 1022: Pexpr fee = new mdot("f",ee); ! 1023: fee->i1 = 9; ! 1024: Ptype pft = f->addrof(); ! 1025: fee = new cast(pft,fee); // (T)pp->vptr[i].f ! 1026: Pexpr r = new expr(DEREF,fee,0); // *(T)pp->vptr[i].f ! 1027: // e1->tp must be 0, means "argtype encoded" ! 1028: r->tp2 = Ptype(f->f_this); // encode argtype ! 1029: ! 1030: Pexpr nthis = new_this(pp,ee); ! 1031: ! 1032: args = new expr(ELIST,nthis,args); ! 1033: args->simpl(); ! 1034: ! 1035: Pcall c = new call(r,args); ! 1036: c->tp = f->returns; ! 1037: return c; ! 1038: } ! 1039: ! 1040: void call::simpl() ! 1041: /* ! 1042: fix member function calls: ! 1043: p->f(x) becomes f(p,x) ! 1044: o.f(x) becomes f(&o,x) ! 1045: or if f is virtual: ! 1046: p->f(x) is resolved like this ! 1047: pp = p; ! 1048: i = index(f); ! 1049: entry = pp->_vtbl[i-1]; ! 1050: pp = (T*)(((char*)pp)+entry.i) ! 1051: (*entry.f)(pp,x) ! 1052: replace calls to inline functions by the expanded code ! 1053: */ ! 1054: { ! 1055: Pname fn = fct_name; ! 1056: //error('d',"%d call::simpl() fn %n %d e1 %d",this,fn,fn,e1); ! 1057: Pfct f = fn ? Pfct(fn->tp) : 0; ! 1058: ! 1059: if (fn == 0) e1->simpl(); ! 1060: ! 1061: if (f) { ! 1062: switch(f->base) { ! 1063: case ANY: ! 1064: return; ! 1065: case OVERLOAD: ! 1066: fct_name = fn = Pgen(f)->fct_list->f; ! 1067: f = Pfct(fn->tp); ! 1068: } ! 1069: } ! 1070: ! 1071: switch (e1->base) { ! 1072: case MEMPTR: // (p ->* q)(args) ! 1073: { ! 1074: Pexpr p = e1->e1; ! 1075: Pexpr q = e1->e2; ! 1076: Pclass cl = Pclass(e1->tp2); ! 1077: Pfct f = Pfct(q->tp->deref()); ! 1078: ! 1079: if (e2) e2->simpl(); ! 1080: ! 1081: if (f->f_this == 0) { // might not know about ``this'' yet ! 1082: if (f->memof == 0) error('i',"memof missing"); ! 1083: Pname tt = new name("this"); ! 1084: tt->n_scope = ARG; ! 1085: tt->tp = f->memof->this_type; ! 1086: PERM(tt); ! 1087: // f->f_this = f->f_args = tt; ! 1088: tt->n_list = f->argtype; ! 1089: // f->f_this = tt; ! 1090: tt->n_list = f->f_result ? f->f_result : f->argtype; ! 1091: f->f_this = f->f_args = tt; ! 1092: } ! 1093: //error('d',"f_this %d",f->f_this); ! 1094: extern has_virt(Pclass); ! 1095: ! 1096: // beware of sideeffects: ! 1097: nin = 1; ! 1098: if (q->not_simple()) error('s',"2nd operand of .* too complicated"); ! 1099: nin = 0; ! 1100: ! 1101: Pexpr qq = new mdot("f",q); // the function: (*(right type)q.f) ! 1102: qq->i1 = 9; ! 1103: qq = new cast(f->addrof(),qq); ! 1104: Pexpr nc = new expr(DEREF,qq,0); ! 1105: nc->tp2 = Ptype(f->f_this); // encode argtype ! 1106: ! 1107: Pexpr nthis = new_this(p,q); // arguments: (p+q.d,args) ! 1108: Pexpr args = new expr(ELIST,nthis,e2); ! 1109: imeasure+=3; ! 1110: ! 1111: if (has_virt(cl) == 0) { // no virtuals: simple ! 1112: if (cl->defined == 0) ! 1113: error("call throughP toMF before definition ofC %t",cl); ! 1114: //error('d',"no virt"); ! 1115: // (p ->* q)(args) => (*q.f)(p+q.d,args) ! 1116: e1 = nc; ! 1117: e2 = args; ! 1118: return; ! 1119: } ! 1120: ! 1121: if (find_vptr(cl) == 0) { // must be a call to a second base ! 1122: // that we cannot handle yet ! 1123: // it is OK not to to generate ! 1124: // a virtual call since a ! 1125: // `sorry' will have been generated ! 1126: // at the point of initialization ! 1127: e1 = nc; ! 1128: e2 = args; ! 1129: return; ! 1130: ! 1131: } ! 1132: // beware of sideeffects: ! 1133: nin = 1; ! 1134: if (p->not_simple()) error('s',"1st operand of .* too complicated"); ! 1135: nin = 0; ! 1136: ! 1137: Pexpr c = new mdot("i",q); // condition (q.i<0) ! 1138: c->i1 = 9; ! 1139: c = new expr(LT,c,zero); ! 1140: ! 1141: Pexpr ie = new mdot("i",q); ! 1142: ie->i1 = 9; ! 1143: ! 1144: base = QUEST; ! 1145: e1 = new call(nc,args); ! 1146: e2 = vcall(p,ie,f,cl,e2); ! 1147: cond = c; ! 1148: return; ! 1149: } ! 1150: case DOT: ! 1151: // if e1 is an object and not just a reference ! 1152: // the vtbl need not be used ! 1153: case REF: ! 1154: { Pref r = Pref(e1); ! 1155: Pexpr a1 = r->e1; ! 1156: int obj = r->n_initializer!=0; // if B::f don't use vcall ! 1157: ! 1158: if (obj == 0) { // don't use vcall if we have an object ! 1159: // (not a pointer or a reference) ! 1160: if (e1->base==DOT && a1->base!=DEREF) obj = 1; ! 1161: } ! 1162: ! 1163: //error('d',"fct_name %n f %d %d obj %d",fct_name,f,f->f_virtual,obj); ! 1164: if (f && obj==0 && f->f_virtual) { ! 1165: Pexpr a11 = 0; ! 1166: ! 1167: switch(a1->base) { // see if temporary might be needed ! 1168: case NAME: ! 1169: case MDOT: ! 1170: a11 = a1; ! 1171: break; ! 1172: case REF: ! 1173: case DOT: ! 1174: if (a1->e1->base==NAME ! 1175: || ((a1->e1->base==DOT || a1->e1->base==REF) && a1->e1->e1->base==NAME)) a11 = a1; ! 1176: break; ! 1177: case ADDROF: ! 1178: case G_ADDROF: ! 1179: if (a1->e2->base == NAME ! 1180: || ((a1->e2->base==DOT || a1->e2->base==REF) && a1->e2->e1->base==NAME)) a11 = a1; ! 1181: break; ! 1182: case CAST: ! 1183: switch (a1->e1->base) { ! 1184: case NAME: ! 1185: case MDOT: ! 1186: a11 = a1; ! 1187: } ! 1188: } ! 1189: ! 1190: // if( a1->base==REF && fn->n_oper==DTOR ){ ! 1191: // a11 = a1; ! 1192: // goto zsw; ! 1193: // } ! 1194: // ! 1195: if (e1->base == DOT) { ! 1196: // zsw: ! 1197: if (a11) a11 = a11->address(); ! 1198: a1 = a1->address(); ! 1199: } ! 1200: ! 1201: if (a11 == 0) { // temporary (maybe) needed ! 1202: // e->f() => (t=e,t->f(t)) ! 1203: if (a1->base==NAME) ! 1204: a11 = a1; // &*name has become name ! 1205: else { ! 1206: Pname nx = new name(make_name('K')); ! 1207: nx->tp = a1->tp; ! 1208: Pname n = nx->dcl(scope,ARG); // no init! ! 1209: delete nx; ! 1210: Pname cln = a1->tp->is_cl_obj(); ! 1211: if (cln) { ! 1212: Pclass cl = Pclass(cln->tp); ! 1213: if (Ntmp==0 && cl->has_dtor()) Ntmp = cln; ! 1214: if (cl->has_itor()) n->n_xref = 1; ! 1215: } ! 1216: n->n_scope = FCT; ! 1217: n->assign(); ! 1218: a11 = n; ! 1219: a1 = new expr(ASSIGN,n,a1); ! 1220: a1->tp = n->tp; ! 1221: a1->simpl(); ! 1222: Pcall cc = new call(0,0); ! 1223: *cc = *this; ! 1224: base = CM; ! 1225: e1 = a1; ! 1226: e2 = cc; ! 1227: this = cc; ! 1228: } ! 1229: } ! 1230: ! 1231: int i = f->f_virtual; ! 1232: Pexpr ie = i?new ival(i):0; // index ! 1233: Pname cn = fn->n_table->t_name; ! 1234: if (fn ! 1235: && fn->n_initializer ! 1236: && cc->nof ! 1237: && cc->nof->n_oper==CTOR ! 1238: && Pfct(cc->nof->tp)->memof->c_abstract ! 1239: && strcmp(Pfct(cc->nof->tp)->memof->string, cn->string) == 0 ) { ! 1240: // permit x::x( x& xx ) { xx.pvf(); } ! 1241: Pexpr ee = e1->e1; ! 1242: while ( ee && ee->base != NAME ) ee = ee->e1; ! 1243: if ( ee && strcmp( ee->string, "this" )==0) ! 1244: error("call of pure virtualF%n inK%n",fn,cc->nof); ! 1245: } ! 1246: Pcall vc = vcall(a11,ie,f,Pclass(cn->tp),e2); ! 1247: *this = *vc; ! 1248: return; ! 1249: } ! 1250: ! 1251: Ptype tt = r->mem->tp; ! 1252: llp: ! 1253: //error('d',"llp %t",tt); ! 1254: switch (tt->base) { ! 1255: // default: // pointer to function: (n->ptr_mem)(args); do nothing ! 1256: case TYPE: ! 1257: tt = Pbase(tt)->b_name->tp; ! 1258: goto llp; ! 1259: case OVERLOAD: // n->fctmem(args); ! 1260: case FCT: ! 1261: if (fct_name==0) { ! 1262: // reconstitute fn destroyed to suppress "virtual" ! 1263: fct_name = fn = Pname(e1->n_initializer); ! 1264: f = Pfct(fn->tp); ! 1265: } ! 1266: ! 1267: if (e1->base == DOT) a1 = a1->address(); ! 1268: e2 = new expr(ELIST,a1,e2); ! 1269: e1 = r->mem; ! 1270: } ! 1271: } ! 1272: } ! 1273: ! 1274: if (e2) e2->simpl(); ! 1275: //error('d',"fn %n inl %d imes %d",fn,f->f_inline,f->f_imeasure); ! 1276: if (fn && f->f_inline && debug_opt==0) { ! 1277: imeasure += f->f_imeasure; ! 1278: Pclass cl = f->memof; ! 1279: if (cl && cl->c_body) cl->dcl_print(0); ! 1280: Ptable oscope = scope; ! 1281: Pexpr ee = f->expand(fn,scope,e2); ! 1282: scope = oscope; ! 1283: if (ee) *Pexpr(this) = *ee; ! 1284: } ! 1285: else if (fn && f->f_inline==0 && f->f_imeasure) { ! 1286: extern void uninline(Pname fn); ! 1287: uninline(fn); ! 1288: imeasure += 3; ! 1289: } ! 1290: else if (fn && debug_opt && f->f_inline==ITOR) { ! 1291: extern void expand_itor(Pclass); ! 1292: expand_itor(f->memof); ! 1293: } ! 1294: else ! 1295: imeasure += 3; ! 1296: } ! 1297: ! 1298: void uninline(Pname fn) ! 1299: // inline turned static ! 1300: { ! 1301: Pfct f = Pfct(fn->tp); ! 1302: //error('d',"uninline %n %d %d",fn,f->body,f->f_expr); ! 1303: ! 1304: if (warning_opt) { ! 1305: error('w',"%n too complex for inlining",fn); ! 1306: error('w',"out-of-line copy of %n created",fn); ! 1307: } ! 1308: f->f_imeasure = 0; // now it really is just static ! 1309: ! 1310: Pstmt s = f->body->s; ! 1311: // for (s = f->body->s; s; s=s->s_list) ! 1312: //error('d',"start %d %k",s->e,s->e->base); ! 1313: // s = f->body->s; ! 1314: while (s) { ! 1315: //error('d',"s %k %d %k",s->base,s->e,s->e->base); ! 1316: if (s->base == SM) { ! 1317: // turn comma expression into statement list ! 1318: Pexpr e = s->e; ! 1319: if (e) ! 1320: switch (e->base) { ! 1321: case CM: ! 1322: case G_CM: ! 1323: { Pstmt ss = new estmt(SM,no_where,e->e2,0); ! 1324: s->e = e->e1; ! 1325: ss->s_list = s->s_list; ! 1326: s->s_list = ss; ! 1327: delete e; ! 1328: continue; ! 1329: } ! 1330: } ! 1331: } ! 1332: s = s->s_list; ! 1333: } ! 1334: // for (s = f->body->s; s; s=s->s_list) ! 1335: //error('d',"echo %k %d %k",s->base,s->e,s->e->base); ! 1336: ! 1337: fn->dcl_print(0); ! 1338: } ! 1339: ! 1340: /* ! 1341: void ccheck(Pexpr e) ! 1342: ! 1343: Is there a conditional in this expression? (not perfect) ! 1344: ! 1345: { ! 1346: //error('d',"ccheck(e %k)",e,e?e->base,0); ! 1347: if (e) ! 1348: switch (e->base) { ! 1349: case QUEST: ! 1350: case ANDAND: ! 1351: case OROR: ! 1352: error('s',"E too complicated: uses%k and needs temporary ofCW destructor",e->base); ! 1353: break; ! 1354: case LT: ! 1355: case LE: ! 1356: case GT: ! 1357: case GE: ! 1358: case EQ: ! 1359: case NE: ! 1360: case ASSIGN: ! 1361: case ASPLUS: ! 1362: case ASMINUS: ! 1363: case G_CM: ! 1364: case CM: ! 1365: case PLUS: ! 1366: case MINUS: ! 1367: case MUL: ! 1368: case DIV: ! 1369: case OR: ! 1370: case ER: ! 1371: case AND: ! 1372: case G_CALL: ! 1373: case CALL: ! 1374: case ELIST: ! 1375: case DEREF: ! 1376: ccheck(e->e1); ! 1377: case NOT: ! 1378: case COMPL: ! 1379: case CAST: ! 1380: case ADDROF: ! 1381: case G_ADDROF: ! 1382: ccheck(e->e2); ! 1383: break; ! 1384: case ICALL: // check inlined arguments ! 1385: { Pin il = e->il; ! 1386: for (int i = 0; il->args[i].arg && i<il->i_slots; i++) ccheck(il->args[i].arg); ! 1387: } ! 1388: } ! 1389: } ! 1390: */ ! 1391: ! 1392: void temp_in_cond(Pexpr ee, Pstmt ss, Ptable tbl) ! 1393: /* ! 1394: insert destructor calls 'ss' into condition 'ee' ! 1395: ee => (Qnn = ee, dtors, Qnn) ! 1396: */ ! 1397: { ! 1398: //error('d',"temp_in_cond"); ! 1399: // ccheck(ee); ! 1400: while (ee->base==CM || ee->base==G_CM) ee = ee->e2; ! 1401: Ptype ct = ee->tp; ! 1402: Pname n = new name(make_name('Q')); // int Qnn; ! 1403: n->tp = ct; ! 1404: Pname tmp = n->dcl(tbl,ARG); ! 1405: delete n; ! 1406: tmp->n_scope = FCT; ! 1407: ! 1408: Pexpr v = new expr(0,0,0); ! 1409: *v = *ee; ! 1410: PERM(ct); ! 1411: v = new cast(ct,v); ! 1412: ! 1413: tmp->n_assigned_to = 1; ! 1414: Pexpr c = new expr(ASSIGN,tmp,v); // Qnn = ee ! 1415: c->tp = ct; ! 1416: ee->base = CM; ! 1417: ee->e1 = c; ! 1418: ! 1419: Pexpr ex = 0; // add dtors at end ! 1420: ! 1421: for (Pstmt sx = ss; sx; sx = sx->s_list) { ! 1422: if (ex) { ! 1423: ex = new expr(CM,ex,sx->e); ! 1424: ex->tp = sx->e->tp; ! 1425: } ! 1426: else ! 1427: ex = sx->e; ! 1428: } ! 1429: ee->e2 = new expr(CM,ex,tmp); // add Qnn at end ! 1430: ee->e2->tp = ct; ! 1431: } ! 1432: ! 1433: bit not_safe(Pexpr e) ! 1434: { ! 1435: ! 1436: switch (e->base) { ! 1437: default: ! 1438: return 1; ! 1439: /* ! 1440: case CALL: ! 1441: case G_CALL: ! 1442: case DOT: ! 1443: case REF: ! 1444: case ANAME: ! 1445: return 1; ! 1446: */ ! 1447: case NAME: ! 1448: // if the name is automatic and has a destructor it is not safe ! 1449: // to destroy it before returning an expression depending on it ! 1450: { Pname n = Pname(e); ! 1451: if (n->n_table!=gtbl && n->n_table->t_name==0) { ! 1452: Pname cn = n->tp->is_cl_obj(); ! 1453: if (cn && Pclass(cn->tp)->has_dtor()) return 1; ! 1454: } ! 1455: } ! 1456: case IVAL: ! 1457: case ICON: ! 1458: case CCON: ! 1459: case FCON: ! 1460: case STRING: ! 1461: return 0; ! 1462: case NOT: ! 1463: case COMPL: ! 1464: case ADDROF: ! 1465: case G_ADDROF: ! 1466: return not_safe(e->e2); ! 1467: case DEREF: ! 1468: // return not_safe(e->e1) || e->e2?not_safe(e->e2):0; ! 1469: { int i = not_safe(e->e1); ! 1470: if (i) return i; ! 1471: if (e->e2) return not_safe(e->e2); ! 1472: return 0; ! 1473: } ! 1474: case CM: ! 1475: case PLUS: ! 1476: case MINUS: ! 1477: case MUL: ! 1478: case DIV: ! 1479: case MOD: ! 1480: case ASSIGN: ! 1481: case ASPLUS: ! 1482: case ASMINUS: ! 1483: case ASMUL: ! 1484: case ASDIV: ! 1485: case OR: ! 1486: case AND: ! 1487: case OROR: ! 1488: case ANDAND: ! 1489: case LT: ! 1490: case LE: ! 1491: case GT: ! 1492: case GE: ! 1493: case EQ: ! 1494: case NE: ! 1495: return not_safe(e->e1) || not_safe(e->e2); ! 1496: case QUEST: ! 1497: return not_safe(e->cond) || not_safe(e->e1) || not_safe(e->e2); ! 1498: } ! 1499: } ! 1500: ! 1501: ! 1502: Pexpr curr_expr; /* to protect against an inline being expanded twice ! 1503: in a simple expression keep track of expressions ! 1504: being simplified ! 1505: */ ! 1506: ! 1507: Pstmt stmt::simpl() ! 1508: /* ! 1509: return a pointer to the last statement in the list, or 0 ! 1510: */ ! 1511: { ! 1512: if (this == 0) error('i',"0->S::simpl()"); ! 1513: DB( if(Sdebug>=1){ ! 1514: error('d',"%d->stmt::simpl(): %k",this,base); ! 1515: if(Sdebug>=2) display_stmt(this); ! 1516: }); ! 1517: //Pstmt ostmt = Cstmt; ! 1518: //if ( where.line ) Cstmt = this; ! 1519: ! 1520: stmtno++; ! 1521: curr_expr = e; ! 1522: // need_lift = 0; ! 1523: Ntmp_tbl = base != BLOCK ? memtbl : 0; ! 1524: // error('d',"stmt::simpl %k s_list %d need_lift: %d",base,s_list,need_lift); ! 1525: ! 1526: switch (base) { ! 1527: default: ! 1528: error('i',"S::simpl(%k)",base); ! 1529: ! 1530: case ASM: ! 1531: break; ! 1532: ! 1533: case BREAK: ! 1534: if (break_del_list) { // break => { _dtor()s; break; } ! 1535: Pstmt bs = new stmt(base,where,0); ! 1536: Pstmt dl = break_del_list->copy(); ! 1537: base = BLOCK; ! 1538: s = new pair(where,dl,bs); ! 1539: } ! 1540: break; ! 1541: ! 1542: case CONTINUE: ! 1543: if (continue_del_list) { // continue => { _dtor()s; continue; } ! 1544: Pstmt bs = new stmt(base,where,0); ! 1545: Pstmt dl = continue_del_list->copy(); ! 1546: base = BLOCK; ! 1547: s = new pair(where,dl,bs); ! 1548: } ! 1549: break; ! 1550: ! 1551: case DEFAULT: ! 1552: s->simpl(); ! 1553: break; ! 1554: ! 1555: case SM: ! 1556: if (e) { ! 1557: if (e->base == DEREF) e = e->e1; ! 1558: e->simpl(); ! 1559: if (e->base == DEREF) e = e->e1; ! 1560: } ! 1561: break; ! 1562: ! 1563: case RETURN: ! 1564: { /* return x; ! 1565: => ! 1566: { dtor()s; return x; } ! 1567: OR (returning an X where X(X&) is defined) => ! 1568: { ctor(_result,x); _dtor()s; return; } ! 1569: OR (where x needs temporaries) ! 1570: OR (where x might involve an object to be destroyed) => ! 1571: { _result = x; _dtor()s; return _result; } ! 1572: return; => ! 1573: { _dtor()s; return; } ! 1574: OR (in constructors) => ! 1575: { _dtor()s; return _this; } ! 1576: */ ! 1577: Pstmt sx = this; ! 1578: Pexpr ex = e; ! 1579: ! 1580: no_of_returns++; ! 1581: ! 1582: Pstmt dl = (del_list) ? del_list->copy() : 0; ! 1583: Pfct f = Pfct(curr_fct->tp); ! 1584: ! 1585: if (e == 0) e = dummy; ! 1586: if (e==dummy && curr_fct->n_oper==CTOR) e = f->f_this; ! 1587: ! 1588: ! 1589: // need to generate a temporary for mptr return ! 1590: Pexpr tt = e; ! 1591: while ( tt->base == CAST ) ! 1592: tt = tt->e1; ! 1593: if ( tt->base == ILIST ) ! 1594: e = tt; ! 1595: ! 1596: if (e->base == ILIST) { ! 1597: extern Pbase mptr_type; ! 1598: extern Ptype Pvptr_type; ! 1599: Pexpr mptr_assign(Pexpr, Pexpr); ! 1600: // memptr constant ! 1601: // return({1,2,f}) ==> memptr t; return((t={1,2,f},&t)) ! 1602: ! 1603: Ptable ftbl = Pfct(curr_fct->tp)->body->memtbl; ! 1604: Pname temp = make_tmp('A',mptr_type,ftbl); ! 1605: ! 1606: // placed in mptr_assign() ! 1607: // temp->use(); // necessary for inlines to force declaration ! 1608: ! 1609: e = mptr_assign(temp,e); ! 1610: e = new expr(G_CM,e,temp); ! 1611: e->tp = mptr_type; ! 1612: } ! 1613: ! 1614: if (f->f_result) { // ctor(_result,x); dtors; return; ! 1615: if (e->base == G_CM) e = replace_temp(e,f->f_result); ! 1616: e->simpl(); ! 1617: Pstmt cs = new estmt(SM,where,e,0); ! 1618: if (dl) cs = new pair(where,cs,dl); ! 1619: base = PAIR; ! 1620: s = cs; ! 1621: s2 = new estmt(RETURN,where,0,0); ! 1622: //#ifdef RETBUG ! 1623: // s2->empty = 1; // fudge to bypass C bug (see print.c) ! 1624: // s2->ret_tp = ret_tp; ! 1625: //#endif ! 1626: } ! 1627: else { // dtors; return e; ! 1628: e->simpl(); ! 1629: if (dl) { ! 1630: if (e!=dummy && not_safe(e)) { ! 1631: // { _result = x; _dtor()s; return _result; } ! 1632: Ptable ftbl = Pfct(curr_fct->tp)->body->memtbl; ! 1633: ! 1634: Pname r = ftbl->look("_result",0); ! 1635: if (r == 0) { ! 1636: r = new name("_result"); ! 1637: r->tp = ret_tp; ! 1638: Pname rn = r->dcl(ftbl,ARG); ! 1639: rn->n_scope = FCT; ! 1640: rn->where = no_where; ! 1641: rn->assign(); ! 1642: delete r; ! 1643: r = rn; ! 1644: } ! 1645: Pexpr as = new expr(ASSIGN,r,e); ! 1646: as->tp = ret_tp; // wrong if = overloaded, but then X(X&) ought to have been used ! 1647: Pstmt cs = new estmt(SM,where,as,0); ! 1648: cs = new pair(where,cs,dl); ! 1649: base = PAIR; ! 1650: s = cs; ! 1651: s2 = new estmt(RETURN,where,r,0); ! 1652: // s2->ret_tp = ret_tp; ! 1653: } ! 1654: else { // { _dtor()s; return x; } ! 1655: base = PAIR; ! 1656: s = dl; ! 1657: s2 = new estmt(RETURN,where,e,0); ! 1658: } ! 1659: s2->ret_tp = ret_tp; ! 1660: } ! 1661: } ! 1662: ! 1663: // if (sx->memtbl) { ! 1664: // int i; ! 1665: // for (Pname n=sx->memtbl->get_mem(i=1); n; n=sx->memtbl->get_mem(++i)) { ! 1666: // Pname cn = n->tp->is_cl_obj(); ! 1667: // if (cn && Pclass(cn->tp)->has_dtor()) { ! 1668: // ccheck(ex); ! 1669: // break; ! 1670: // } ! 1671: // } ! 1672: // } ! 1673: break; ! 1674: } ! 1675: ! 1676: case WHILE: ! 1677: case DO: ! 1678: e->simpl(); ! 1679: { Pstmt obl = break_del_list; ! 1680: Pstmt ocl = continue_del_list; ! 1681: break_del_list = 0; ! 1682: continue_del_list = 0; ! 1683: s->simpl(); ! 1684: break_del_list = obl; ! 1685: continue_del_list = ocl; ! 1686: } ! 1687: break; ! 1688: ! 1689: case SWITCH: ! 1690: e->simpl(); ! 1691: { Pstmt obl = break_del_list; ! 1692: break_del_list = 0; ! 1693: s->simpl(); ! 1694: break_del_list = obl; ! 1695: } ! 1696: switch (s->base) { ! 1697: case SM: ! 1698: // permit switch (expr) ; ! 1699: if (s->e) goto df; ! 1700: case DEFAULT: ! 1701: case LABEL: ! 1702: case CASE: ! 1703: break; ! 1704: case BLOCK: ! 1705: if (s->s) ! 1706: switch (s->s->base) { ! 1707: case BREAK: // to cope with #define Case break; case ! 1708: case CASE: ! 1709: case LABEL: ! 1710: case DEFAULT: ! 1711: break; ! 1712: default: ! 1713: goto df; ! 1714: } ! 1715: break; ! 1716: default: ! 1717: df: ! 1718: error(&s->where,"S orIdE not reached: (case label missing?)"); ! 1719: } ! 1720: break; ! 1721: ! 1722: case CASE: ! 1723: e->simpl(); ! 1724: s->simpl(); ! 1725: break; ! 1726: ! 1727: case LABEL: ! 1728: if (del_list) error('s',"label in blockW destructors"); ! 1729: s->simpl(); ! 1730: break; ! 1731: ! 1732: case GOTO: ! 1733: /* If the goto is going to a different (effective) scope, ! 1734: then it is necessary to activate all relevant destructors ! 1735: on the way out of nested scopes, and issue errors if there ! 1736: are any constructors on the way into the target. ! 1737: ! 1738: Only bother if the goto and label have different effective ! 1739: scopes. (If mem table of goto == mem table of label, then ! 1740: they're in the same scope for all practical purposes. ! 1741: */ ! 1742: { ! 1743: Pname n = scope->look( d->string, LABEL ); ! 1744: if (n == 0) error('i',&where,"label%n missing",d); ! 1745: if(n->n_realscope!=scope && n->n_assigned_to) { ! 1746: ! 1747: /* Find the root of the smallest subtree containing ! 1748: the path of the goto. This algorithm is quadratic ! 1749: only if the goto is to an inner or unrelated scope. ! 1750: */ ! 1751: ! 1752: Ptable r = 0; ! 1753: ! 1754: for(Ptable q=n->n_realscope; q!=gtbl; q=q->next) { ! 1755: for( Ptable p = scope; p != gtbl; p = p->next ) { ! 1756: if( p==q ) { ! 1757: r = p; // found root of subtree! ! 1758: goto xyzzy; ! 1759: } ! 1760: } ! 1761: } ! 1762: ! 1763: xyzzy: if( r==0 ) error( 'i',&where,"finding root of subtree" ); ! 1764: ! 1765: /* At this point, r = root of subtree, n->n_realscope ! 1766: * = mem table of label, and scope = mem table of goto. */ ! 1767: ! 1768: /* Climb the tree from the label mem table to the table ! 1769: * preceding the root of the subtree, looking for ! 1770: * initializers and ctors. If the mem table "belongs" ! 1771: * to an unsimplified block(s), the n_initializer field ! 1772: * indicates presence of initializer, otherwise initializer ! 1773: * information is recorded in the init_stat field of ! 1774: * mem table. */ ! 1775: ! 1776: for( Ptable p=n->n_realscope; p!=r; p=p->next ) ! 1777: if( p->init_stat == 2 ) { ! 1778: error(&where,"goto%n pastDWIr",d); ! 1779: goto plugh; /* avoid multiple error msgs */ ! 1780: } ! 1781: else if( p->init_stat == 0 ) { ! 1782: int i; ! 1783: for(Pname nn=p->get_mem(i=1);nn;nn=p->get_mem(++i)) ! 1784: if(nn->n_initializer||nn->n_evaluated){ ! 1785: error(&nn->where,"goto%n pastId%n",d,nn); ! 1786: goto plugh; ! 1787: } ! 1788: } ! 1789: plugh: ! 1790: ! 1791: /* Proceed in a similar manner from the point of the goto, ! 1792: * generating the code to activate dtors before the goto. */ ! 1793: /* There is a bug in this code. If there are class objects ! 1794: * of the same name and type in (of course) different mem ! 1795: * tables on the path to the root of the subtree from the ! 1796: * goto, then the innermost object's dtor will be activated ! 1797: * more than once. */ ! 1798: ! 1799: { ! 1800: Pstmt dd = 0, ddt = 0; ! 1801: ! 1802: for( Ptable p=scope; p!=r; p=p->next ) { ! 1803: int i; ! 1804: for(Pname n=p->get_mem(i=1);n;n=p->get_mem(++i)) { ! 1805: Pname cln; ! 1806: if (n->tp == 0) continue; /* label */ ! 1807: int dtor=1; ! 1808: if (inllist) { ! 1809: for (Pname nl=inllist->head;nl;nl=nl->n_list) ! 1810: if (n==nl) dtor=0; ! 1811: } ! 1812: ! 1813: if ( cln=n->tp->is_cl_obj() ) { ! 1814: Pclass cl = (Pclass)cln->tp; ! 1815: Pname d = cl->has_dtor(); ! 1816: ! 1817: if (d && dtor) { /* n->cl::~cl(0); */ ! 1818: Pexpr dl = call_dtor(n,d,0,DOT,one); ! 1819: Pstmt dls = new estmt(SM,n->where,dl,0); ! 1820: if (dd) ! 1821: ddt->s_list = dls; ! 1822: else ! 1823: dd = dls; ! 1824: ddt = dls; ! 1825: } ! 1826: ! 1827: } ! 1828: else if (cl_obj_vec) { ! 1829: Pclass cl = (Pclass)cl_obj_vec->tp; ! 1830: // Pname c = cl->has_ictor(); ! 1831: Pname d = cl->has_dtor(); ! 1832: ! 1833: if (d && dtor) { // __vec_delete(vec,noe,sz,dtor,0); ! 1834: Pfct f = Pfct(d->tp); ! 1835: int i = 0; ! 1836: for (Pname nn = f->f_args->n_list; ! 1837: nn && nn->n_list; nn=nn->n_list) i++; ! 1838: Pexpr a = cdvec(vec_del_fct,n,cl,d,0,new ival(i)); ! 1839: Pstmt dls = new estmt(SM,n->where,a,0); ! 1840: if (dd) ! 1841: ddt->s_list = dls; ! 1842: else ! 1843: dd = dls; ! 1844: ddt = dls; ! 1845: } ! 1846: } ! 1847: } /* end mem table scan */ ! 1848: } /* end dtor loop */ ! 1849: ! 1850: /* "activate" the list of dtors obtained. */ ! 1851: ! 1852: if( dd ) { ! 1853: dd->simpl(); ! 1854: Pstmt bs = new stmt( base, where, 0 ); ! 1855: *bs = *this; ! 1856: base = PAIR; ! 1857: s = dd; ! 1858: s2 = bs; ! 1859: } ! 1860: } ! 1861: } /* end special case for non-local goto */ ! 1862: } ! 1863: break; ! 1864: ! 1865: case IF: ! 1866: e->simpl(); ! 1867: s->simpl(); ! 1868: if (else_stmt) else_stmt->simpl(); ! 1869: break; ! 1870: ! 1871: case FOR: // "for (s;e;e2) s2; => "s; for(;e,e2) s2" ! 1872: if (for_init) for_init->simpl(); ! 1873: if (e) { ! 1874: curr_expr = e; ! 1875: e->simpl(); ! 1876: } ! 1877: if (e2) { ! 1878: curr_expr = e2; ! 1879: e2->simpl(); ! 1880: if (e2->base==ICALL) ! 1881: if (e2->e1 == 0) error('s',"cannot expand inline void%n called in forE", e2->il->fct_name); ! 1882: } ! 1883: { Pstmt obl = break_del_list; ! 1884: Pstmt ocl = continue_del_list; ! 1885: break_del_list = 0; ! 1886: continue_del_list = 0; ! 1887: s->simpl(); ! 1888: break_del_list = obl; ! 1889: continue_del_list = ocl; ! 1890: } ! 1891: break; ! 1892: ! 1893: case BLOCK: ! 1894: Pblock(this)->simpl(); ! 1895: break; ! 1896: ! 1897: case PAIR: ! 1898: break; ! 1899: } ! 1900: ! 1901: /*if (s) s->simpl();*/ ! 1902: // error('d',"base %k memtbl %d e %d",base,memtbl); ! 1903: if (base!=BLOCK && memtbl) { ! 1904: Pstmt t1 = (s_list) ? s_list->simpl() : 0; ! 1905: Pstmt tpx = t1 ? t1 : this; ! 1906: ! 1907: Pstmt ss = 0; ! 1908: Pname cln; // used for warnings ! 1909: int i; ! 1910: Pname tn = memtbl->get_mem(i=1); ! 1911: for (; tn; tn=memtbl->get_mem(++i)) { ! 1912: // error('d',"tn: %n need_lift: %d",tn,need_lift); ! 1913: if (cln = tn->tp->is_cl_obj()) { ! 1914: Pname d = Pclass(cln->tp)->has_dtor(); ! 1915: if (d) { /* n->cl::~cl(0); */ ! 1916: if (need_lift && ! 1917: is_probably_temp(tn->string) && ! 1918: tmp_tbl->look(tn->string,0)) ! 1919: continue; ! 1920: ! 1921: Pexpr dl = call_dtor(tn,d,0,DOT,one); ! 1922: Pstmt dls = new estmt(SM,tn->where,dl,0); ! 1923: dls->s_list = ss; ! 1924: ss = dls; ! 1925: } ! 1926: } ! 1927: } ! 1928: ! 1929: if (ss) { ! 1930: Pstmt t2 = ss->simpl(); ! 1931: ! 1932: switch (base) { ! 1933: case IF: ! 1934: case WHILE: ! 1935: case DO: ! 1936: case SWITCH: ! 1937: temp_in_cond(e,ss,memtbl); ! 1938: break; ! 1939: ! 1940: case PAIR: // can hide a return ! 1941: { Pstmt ts = s2; ! 1942: while (ts->base==PAIR) ts = ts->s2; ! 1943: if (ts->base == RETURN) { // sordid ! 1944: this = ts; ! 1945: goto retu; ! 1946: } ! 1947: goto def; ! 1948: } ! 1949: case RETURN: ! 1950: retu: ! 1951: { ! 1952: if (e == 0) { ! 1953: // return; dtors; => dtors; return; ! 1954: Pstmt rs = new estmt(RETURN,where,0,0); ! 1955: //rs->empty = empty; // BSD fudge ! 1956: rs->ret_tp = ret_tp; ! 1957: base = PAIR; ! 1958: s = ss; ! 1959: s2 = rs; ! 1960: //Cstmt = ostmt; ! 1961: return t1 ? t1 : rs; ! 1962: } ! 1963: ! 1964: Pname cln = e->tp->is_cl_obj(); ! 1965: if (cln==0 ! 1966: || Pclass(cln->tp)->has_oper(ASSIGN)==0) { ! 1967: // ... return e; dtors; => ! 1968: // ... X r; ... r = e; dtors; return r; ! 1969: Pname rv = new name("_rresult"); // NOT "_result" ! 1970: rv->tp = ret_tp /* e->tp */; ! 1971: if (memtbl == 0) memtbl = new table(4,0,0); ! 1972: Pname n = rv->dcl(memtbl,ARG); ! 1973: n->where = no_where; ! 1974: n->n_scope = FCT; ! 1975: n->n_assigned_to = 1; ! 1976: delete rv; ! 1977: Pstmt rs = new estmt(RETURN,where,n,0); ! 1978: rs->ret_tp = ret_tp; ! 1979: base = SM; ! 1980: e = new expr(ASSIGN,n,e); ! 1981: e->tp = n->tp; ! 1982: Pstmt ps = new pair(where,ss,rs); ! 1983: ps->s_list = s_list; ! 1984: s_list = ps; ! 1985: //Cstmt = ostmt; ! 1986: return t1 ? t1 : rs; ! 1987: } ! 1988: } ! 1989: ! 1990: case FOR: // don't know which expression the temp comes from ! 1991: error('s',&where,"E in %kS needs temporary ofC%nW destructor",base,cln); ! 1992: break; ! 1993: ! 1994: case SM: // place dtors after all "converted" DCLs ! 1995: if (t1) { ! 1996: // ccheck(e); ! 1997: for (Pstmt ttt, tt=this; ! 1998: (ttt=tt->s_list) && ttt->base==SM; ! 1999: tt = ttt) ; ! 2000: t2->s_list = ttt; ! 2001: tt->s_list = ss; ! 2002: //Cstmt = ostmt; ! 2003: return t1!=tt ? t1 : t2; ! 2004: } ! 2005: default: ! 2006: def: ! 2007: // if (e) ccheck(e); ! 2008: if (t1) { // t1 == tail of statment list ! 2009: t2->s_list = s_list; ! 2010: s_list = ss; ! 2011: //Cstmt = ostmt; ! 2012: return t1; ! 2013: } ! 2014: s_list = ss; ! 2015: //Cstmt = ostmt; ! 2016: return t2; ! 2017: } ! 2018: } ! 2019: //Cstmt = ostmt; ! 2020: return (t1) ? t1 : this; ! 2021: } ! 2022: ! 2023: //Cstmt = ostmt; ! 2024: return (s_list) ? s_list->simpl() : this; ! 2025: } ! 2026: ! 2027: Pstmt stmt::copy() ! 2028: // now handles dtors in the expression of an IF stmt ! 2029: // not general! ! 2030: { ! 2031: Pstmt ns = new stmt(0,curloc,0); ! 2032: ! 2033: *ns = *this; ! 2034: if (s) ns->s = s->copy(); ! 2035: if (s_list) ns->s_list = s_list->copy(); ! 2036: ! 2037: switch (base) { ! 2038: case PAIR: ! 2039: ns->s2 = s2->copy(); ! 2040: break; ! 2041: } ! 2042: ! 2043: return ns; ! 2044: } ! 2045: ! 2046: Pname overFound = 0; ! 2047: ! 2048: static Pexpr ! 2049: mk_new_with_args( Pexpr pe, Ptype tt, Pclass cl, Pexpr vec = 0 ) ! 2050: { // allocate using operator new(sizeof(cl),args1) ! 2051: Pexpr p; ! 2052: Pexpr args = pe->e2; ! 2053: ! 2054: // Pexpr ce = new texpr(SIZEOF,tt,0); ! 2055: Pexpr ce; ! 2056: if (vec) ! 2057: ce = vec; ! 2058: else ce = new texpr(SIZEOF,tt,0); ! 2059: ! 2060: (void) tt->tsizeof(); ! 2061: ce->tp = size_t_type; ! 2062: args = new expr(ELIST,ce,args); ! 2063: char* s = oper_name(NEW); ! 2064: Pname n = new name(s); ! 2065: if (pe->base == GNEW) // ::new ! 2066: p = gtbl->look(s,0); ! 2067: else ! 2068: p = find_name(n,cl,scope,CALL,curr_fct); ! 2069: p = new call(p,args); ! 2070: overFound=0; // set in call_fct ! 2071: (void) p->call_fct(cl->memtbl); ! 2072: if (overFound && overFound->n_scope != EXTERN) ! 2073: check_visibility(overFound,0,cl,cc->ftbl,cc->nof); ! 2074: overFound=0; ! 2075: return p; ! 2076: } ! 2077: ! 2078: void expr::simpl_new() ! 2079: /* ! 2080: change NEW or GNEW node to CALL node ! 2081: */ ! 2082: { ! 2083: Pname cln; ! 2084: Pname ctor; ! 2085: int sz = 1; ! 2086: // int esz; ! 2087: Pexpr var_expr = 0; ! 2088: Pexpr const_expr = 0; ! 2089: Ptype tt = tp2; ! 2090: Pexpr arg; ! 2091: Pexpr szof; ! 2092: Pname nf; ! 2093: Pexpr init = e1; ! 2094: ! 2095: if (init && init->base) init = 0; // only non-ctor init ! 2096: // error('d',"simpl_new %k e1 %k e2 %k init %k",base, e1?e1->base:0,e2?e2->base:0,init?init->base:0); ! 2097: ! 2098: if ((cln=tt->is_cl_obj()) && init == 0) { ! 2099: Pclass cl = Pclass(cln->tp); ! 2100: Pexpr p; ! 2101: ctor=cl->has_ctor(); ! 2102: // error('d',"cl %t ctor %n",cl, ctor); ! 2103: if (e2 // placement ! 2104: || ctor==0 // no constructor ! 2105: || ctor->n_table!=cl->memtbl // inherited constructor??? ! 2106: || (base==GNEW && cl->has_oper(NEW)) ) ! 2107: p = mk_new_with_args( this, tt, cl ); // new(sizeof(cl),args1) ! 2108: else { ! 2109: p = zero; // 0->ctor(args) ! 2110: // check visibility anyway... ! 2111: (void)mk_new_with_args(this,tt,cl); ! 2112: } ! 2113: ! 2114: if (ctor) { ! 2115: Pexpr c = e1; // ctor call generated in expr::typ ! 2116: Ptype ttt = tp; ! 2117: c->e1->e1 = p; // p->ctor ! 2118: c->simpl(); ! 2119: *this = *c; ! 2120: tp = ttt; ! 2121: delete c; ! 2122: } ! 2123: else { // (tp)new(args) ! 2124: base = CAST; ! 2125: tp2 = tp; ! 2126: e1 = p; ! 2127: e2 = 0; ! 2128: simpl(); ! 2129: } ! 2130: return; ! 2131: } else if ( cln ) { ! 2132: Pclass cl = Pclass(cln->tp); ! 2133: // check visibility anyway... ! 2134: (void)mk_new_with_args(this,tt,cl); ! 2135: } ! 2136: ! 2137: Pclass covn = 0; ! 2138: if (cl_obj_vec) { ! 2139: covn = Pclass(cl_obj_vec->tp); ! 2140: ctor = covn->has_ictor(); ! 2141: if (ctor == 0) { ! 2142: if (covn->has_ctor()) error("new %s[], no defaultK",covn->string); ! 2143: cl_obj_vec = 0; ! 2144: } ! 2145: } ! 2146: ! 2147: xxx: ! 2148: //error('d',"xxx %t",tt); ! 2149: switch (tt->base) { ! 2150: case TYPE: ! 2151: tt = Pbase(tt)->b_name->tp; ! 2152: goto xxx; ! 2153: ! 2154: default: ! 2155: (void) tt->tsizeof(); ! 2156: szof = new texpr(SIZEOF,tt,0); ! 2157: szof->tp = uint_type; ! 2158: break; ! 2159: ! 2160: case VEC: ! 2161: { Pvec v = Pvec(tt); ! 2162: //error('d',"v %d %d",v->size,v->dim); ! 2163: if (v->size) ! 2164: sz *= v->size; ! 2165: else if (v->dim) ! 2166: var_expr = v->dim; ! 2167: else ! 2168: sz = 0; ! 2169: tt = v->typ; ! 2170: goto xxx; ! 2171: } ! 2172: } ! 2173: ! 2174: if (cl_obj_vec) { // _vec_new(0,no_of_elements,element_size,ctor) ! 2175: const_expr = new ival(sz); ! 2176: Pexpr noe = (var_expr) ? (sz!=1) ? new expr(MUL,const_expr,var_expr) : var_expr : const_expr; ! 2177: const_expr = szof; ! 2178: const_expr->tp = uint_type; ! 2179: base = CALL; ! 2180: arg = new expr(ELIST,ctor,0); ! 2181: /*ctor->take_addr();*/ ! 2182: ctor->lval(ADDROF); ! 2183: Pexpr sub=0; ! 2184: if (e2 && e2->e1 && ! 2185: e2->e1->tp) ! 2186: { // new(size_t, args) ! 2187: Pexpr vec_sz = new expr(MUL, noe, const_expr); ! 2188: sub = mk_new_with_args( this, tt, covn, vec_sz ); ! 2189: } ! 2190: arg = new expr(ELIST,const_expr,arg); ! 2191: arg = new expr(ELIST,noe,arg); ! 2192: // arg = new expr(ELIST,e2?e2:zero,arg); // may be preallocated ! 2193: arg = new expr(ELIST,e2?(sub?sub:e2):zero,arg); // may be preallocated ! 2194: base = CAST; ! 2195: tp2 = tp; ! 2196: e1 = new expr(G_CALL,vec_new_fct,arg); ! 2197: e1->fct_name = vec_new_fct; ! 2198: e1->tp = Pfct(vec_new_fct->tp)->returns; ! 2199: simpl(); ! 2200: return; ! 2201: } ! 2202: ! 2203: /* call _new(element_size*no_of_elements) */ ! 2204: //error('d',"sz %d var %d",sz,var_expr); ! 2205: if (sz == 1) ! 2206: arg = (var_expr) ? new expr(MUL,szof,var_expr) : szof; ! 2207: else { ! 2208: const_expr = new ival(sz); ! 2209: const_expr->tp = uint_type; ! 2210: const_expr = new expr(MUL,const_expr,szof); ! 2211: const_expr->tp = uint_type; ! 2212: arg = (var_expr) ? new expr(MUL,const_expr,var_expr) : const_expr; ! 2213: } ! 2214: ! 2215: arg->tp = uint_type; ! 2216: base = CAST; ! 2217: tp2 = tp; ! 2218: arg = new expr(ELIST,arg,e2); ! 2219: nf = gtbl->look(oper_name(NEW),0); // always global, ! 2220: // all class object handled above ! 2221: e1 = new expr(G_CALL,nf,arg); ! 2222: (void) e1->call_fct(gtbl); ! 2223: simpl(); ! 2224: ! 2225: if (init) { // alloc(sz) => (p=alloc(sz),*p=init,p); ! 2226: Pexpr p = init->e1; ! 2227: Pexpr ee = new expr(0,0,0); ! 2228: *ee = *this; ! 2229: ee = new expr(ASSIGN,p,ee); // ee: p = alloc(sz); ! 2230: init->base = ASSIGN; ! 2231: init->e1 = p->contents(); // init: *p = init_val ! 2232: ee = new expr(CM,ee,init); ! 2233: ee->simpl(); ! 2234: base = CM; ! 2235: e1 = ee; ! 2236: e2 = p; ! 2237: } ! 2238: } ! 2239: ! 2240: void expr::simpl_delete() ! 2241: /* ! 2242: delete p => _delete(p); ! 2243: or cl::~cl(p,1); ! 2244: delete[s]p => _delete(p); ! 2245: or vec_del_fct(p,vec_sz,elem_sz,~cl,1); ! 2246: */ ! 2247: { ! 2248: for (Ptype tt = e1->tp; tt->base==TYPE; tt=Pbase(tt)->b_name->tp); ! 2249: tt = Pptr(tt)->typ; ! 2250: //error('d',"simpl_delete() %t",e1->tp); ! 2251: Pname cln = tt->is_cl_obj(); ! 2252: Pname n; ! 2253: Pclass cl; ! 2254: ! 2255: if (cln) { ! 2256: cl = Pclass(cln->tp); ! 2257: if ((cl->defined&DEFINED) == 0) error('w',"delete%t (%t not defined)",cl,cl); ! 2258: } ! 2259: else ! 2260: cl = 0; ! 2261: ! 2262: if (cl && (n=cl->has_dtor())) { // ~cl() might be virtual ! 2263: //xxx check for private/protected op delete ! 2264: { ! 2265: Pexpr ee = new expr(ELIST,e1,0); ! 2266: char* s = oper_name(DELETE); ! 2267: Pname n; ! 2268: //error('d',"%s( %k )",s,e1->base); ! 2269: if (base!=GDELETE) { ! 2270: n = new name(s); ! 2271: n = (Pname)find_name(n,cl,scope,CALL,curr_fct); ! 2272: //error('d',"found%n %t",n,n->tp); ! 2273: if (n->tp->base==OVERLOAD ! 2274: || Pfct(n->tp)->nargs==2) { ! 2275: Pexpr ss = new texpr(SIZEOF,cl,0); ! 2276: ss->tp = size_t_type; ! 2277: ee->e2 = new expr(ELIST,ss,0); ! 2278: } ! 2279: } ! 2280: else ! 2281: n = gtbl->look(s,0); ! 2282: //error('d',"found%n %t",n,n->tp); ! 2283: ee = new call(n,ee); ! 2284: ee->base = G_CALL; ! 2285: //error('d',"delete..."); display_expr(ee); ! 2286: // following commented out to avoid typ::checking problems ! 2287: //overFound=0; // set in call_fct ! 2288: //(void) ee->call_fct(cl->memtbl); ! 2289: //if (overFound && overFound->n_scope != EXTERN) ! 2290: //check_visibility(overFound,0,cl,cc->ftbl,cc->nof); ! 2291: //overFound=0; ! 2292: } ! 2293: ! 2294: //if ( base!=GDELETE ) (void) cl->has_oper(DELETE); ! 2295: ! 2296: if(base==GDELETE && e2==0 || Pfct(n->tp)->f_virtual) { // may need temp ! 2297: nin=1; ! 2298: int needtemp = e1->not_simple(); ! 2299: nin=0; ! 2300: if(needtemp) { ! 2301: // convert: delete [e2] e1 ! 2302: // to: (T=e1), delete [e2] T ! 2303: // where T is a new temporary. ! 2304: Pname tnx = new name(make_name('K')); ! 2305: tnx->tp = e1->tp; ! 2306: Pname tn = tnx->dcl(scope,FCT); ! 2307: delete tnx; ! 2308: tn->assign(); ! 2309: e1 = new expr(ASSIGN,tn,e1); ! 2310: e2 = new expr(base,tn,e2); ! 2311: base=CM; ! 2312: ! 2313: simpl(); ! 2314: return; ! 2315: } ! 2316: } ! 2317: Pexpr r = e1; ! 2318: ! 2319: // handle delete p, where p has a private destructor ! 2320: if (n->n_scope != PUBLIC) check_visibility(n,0,cl,cc->ftbl,cc->nof); ! 2321: //error('d',"e2 %d %k",e2,base); ! 2322: if (e2 == 0) { // e1->cl::~cl(1) ! 2323: Pexpr ee = call_dtor(r,n,base==GDELETE?0:one,REF,one); ! 2324: if (Pfct(n->tp)->f_virtual) { ! 2325: if (ansi_opt) { // q?void:int would be an error ! 2326: ee = new expr(G_CM,ee,zero); ! 2327: ee->tp = zero_type; ! 2328: } ! 2329: ee = new expr(QUEST,ee,zero); ! 2330: ee->tp = ee->e1->tp; ! 2331: ee->cond = r; ! 2332: } ! 2333: if (base == GDELETE) { ! 2334: char* s = oper_name(DELETE); ! 2335: Pexpr p = gtbl->look(s,0); ! 2336: e2 = new call(p,new expr(ELIST,e1,0)); ! 2337: base = CM; ! 2338: e1 = ee; ! 2339: } ! 2340: else { ! 2341: *this = *ee; ! 2342: delete ee; ! 2343: } ! 2344: simpl(); ! 2345: return; ! 2346: } ! 2347: else { // del_cl_vec(e1,e2,elem_size,~cl,1); ! 2348: Pexpr sz = new texpr(SIZEOF,tt,0); ! 2349: (void)tt->tsizeof(); ! 2350: Pfct f = Pfct(n->tp); ! 2351: int i = 0; ! 2352: Pname nn = f->f_args->n_list; ! 2353: for (; nn && nn->n_list; nn=nn->n_list) i++; ! 2354: //error('d',"n %n i %d",n,i); ! 2355: Pexpr arg = new ival(i); ! 2356: sz->tp = uint_type; ! 2357: // Pexpr arg = one; ! 2358: arg = new expr(ELIST,one,arg); ! 2359: if (Pfct(n->tp)->f_virtual) { ! 2360: Pexpr a = new ref(REF,e1,n); ! 2361: a = a->address(); ! 2362: a = new mdot( "f", a ); ! 2363: a->i1 = 9; ! 2364: arg = new expr(ELIST,a,arg); ! 2365: } ! 2366: else { ! 2367: arg = new expr(ELIST,n,arg); ! 2368: n->lval(ADDROF); // n->take_addr(); ! 2369: } ! 2370: ! 2371: arg = new expr(ELIST,sz,arg); ! 2372: if (e2->base==DUMMY) { ! 2373: e2 = new ival(-1); // handle `delete[]p' ! 2374: } ! 2375: ! 2376: arg = new expr(ELIST,e2,arg); ! 2377: arg = new expr(ELIST,e1,arg); ! 2378: Pexpr ee = new expr(G_CALL,vec_del_fct,arg); ! 2379: ee->fct_name = vec_del_fct; ! 2380: ee->tp = tp; ! 2381: // if (ansi_opt) { // q?void:int would be an error ! 2382: // ee = new expr(G_CM,ee,zero); ! 2383: // ee->tp = zero_type; ! 2384: // } ! 2385: // ee = new expr(QUEST,ee,zero); ! 2386: // ee->tp = tp; ! 2387: // ee->cond = r; ! 2388: *this = *ee; ! 2389: simpl(); ! 2390: return; ! 2391: } ! 2392: } ! 2393: else if (cl_obj_vec) { ! 2394: error("delete array of arrays"); ! 2395: } ! 2396: else { // _delete(e1) ! 2397: Pexpr ee = new expr(ELIST,e1,0); ! 2398: char* s = oper_name(DELETE); ! 2399: if (cl && base!=GDELETE) { ! 2400: Pname n = new name(s); ! 2401: e1 = find_name(n,cl,scope,CALL,curr_fct); ! 2402: if (e1->tp->base==OVERLOAD || Pfct(e1->tp)->nargs==2) { ! 2403: Pexpr ss = new texpr(SIZEOF,cl,0); ! 2404: ss->tp = size_t_type; ! 2405: ee->e2 = new expr(ELIST,ss,0); ! 2406: } ! 2407: } ! 2408: else ! 2409: e1 = gtbl->look(s,0); ! 2410: base = G_CALL; ! 2411: e2 = ee; ! 2412: overFound=0; // set in call_fct ! 2413: (void) call_fct(scope); ! 2414: if (overFound && overFound->n_scope != EXTERN) ! 2415: check_visibility(overFound,0,cl,cc->ftbl,cc->nof); ! 2416: overFound=0; ! 2417: } ! 2418: ! 2419: Pcall(this)->simpl(); ! 2420: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.