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