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