![[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 / ooptcfront|
Return to simpl2.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / ooptcfront |
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:
204: if (own_tbl == 0) {
205: ss = (s) ? s->simpl() : 0;
206: return ss;
207: }
208:
209: scope = memtbl;
210: if (scope->init_stat == 0) scope->init_stat = 1; /* table is simplified. */
211:
212: for (n=scope->get_mem(i=1); n; n=scope->get_mem(++i)) {
213: Pstmt st = 0;
214: Pname cln;
215: Pexpr in = n->n_initializer;
216: //error('d',"local %k %n in %k %t",n->n_sto,n,in?in->base:0,in?in->tp:0);
217: if (in) {
218: scope->init_stat = 2; /* initializer in this scope */
219: if (n->n_sto == EXTERN) {
220: error(&n->where,"Id local extern%n",n);
221: continue;
222: }
223: }
224:
225: switch (n->n_scope) {
226: case ARG:
227: case 0:
228: case PUBLIC:
229: continue;
230: }
231:
232: if (n->n_stclass == STATIC) {
233: // local static class object
234: // error('d', "block::simpl: n %n in %t", n, in );
235: if (in && in->base==STAT_INIT) {
236: // dynamic initialization
237: // introduce first time switch
238: Pname cn;
239: Pname x;
240: Ptype ct;
241: if ( cn = n->tp->is_cl_obj() ) {
242: // error( 'd', "block::simpl: cl_obj_vec: %t", cl_obj_vec );
243: ct = new ptr(PTR,n->tp);
244: x = make_tmp('F', ct, gtbl );
245: x->n_initializer = zero;
246: }
247: else
248: x = make_tmp('F',int_type,scope);
249:
250: x->n_sto = n->n_stclass = STATIC;
251: if (in->e2)
252: in->base = ASSIGN;
253: else
254: in = in->e1;
255:
256: Pexpr set;
257: if ( cn ) {
258: x->dcl_print(0);
259: Pclass cl = Pclass(cn->tp);
260: Pname dtor = cl->has_dtor();
261: if ( dtor ) {
262: Pexpr eee = new expr(DEREF, x, 0 );
263: Pexpr c = call_dtor(eee,dtor,0,DOT,one);
264: c->tp = any_type;
265: Pexpr cc = new expr( QUEST, c, zero );
266: cc->cond = x;
267: Pstmt dls = new estmt( SM, n->where, cc, 0 );
268: if ( st_dlist ) dls->s_list = st_dlist;
269: st_dlist = dls;
270: }
271:
272: Pexpr xe = new expr( G_ADDROF, 0, n );
273: set = new expr(ASSIGN,x,xe);
274: set->tp = ct;
275: }
276: else {
277: set = new expr(ASSIGN,x,one);
278: set->tp = int_type;
279: }
280: in = new expr(G_CM,in,set);
281: in = new expr(STAT_INIT,zero,in);
282: in->cond = x;
283: }
284: else
285: continue;
286: }
287:
288: if ( in ) {
289: if ((in->base == ILIST && in->e2 == 0) ||
290: (in->base == STRING && n->tp->base == VEC))
291: if (ansi_opt==0) {
292: error('s',&n->where,"initialization of automatic aggregate");
293: continue;
294: }
295: }
296:
297: if (n->tp == 0) continue; /* label */
298: if (n->n_evaluated) continue;
299:
300: /* construction and destruction of temporaries is handled locally */
301: { char* s = n->string;
302: register char c3 = s[4];
303: if (s[0]=='_' && s[1]=='_' && s[2]=='D' && isdigit(c3)) continue;
304: }
305:
306: if ( cln=n->tp->is_cl_obj() ) {
307: Pclass cl = Pclass(cln->tp);
308: Pname d = cl->has_dtor();
309:
310: if (d) { // n->cl.dtor(0);
311: // local static class object
312: // suppress dtor for local static class object
313: if ( n->n_stclass == STATIC
314: && in
315: && in->base==STAT_INIT )
316: goto stat_init;
317:
318: Pexpr dl = call_dtor(n,d,0,DOT,one);
319: // Pstmt dls = new estmt(SM,n->where,dl,0);
320: Pstmt dls = new estmt(SM,no_where,dl,0);
321: if (dd) {
322: dls->s_list = dd;
323: dd = dls;
324: }
325: else
326: ddt = dd = dls;
327: }
328:
329: // error('d',"%n: in %d",n,in?in->base:0);
330: if (in) {
331: switch (in->base) {
332: case DEREF: // *constructor?
333: if (in->e1->base == G_CALL) {
334: Pname fn = in->e1->fct_name;
335: if (fn==0 || fn->n_oper!=CTOR) goto ddd;
336: st = new estmt(SM,n->where,in->e1,0);
337: n->n_initializer = 0;
338: break;
339: }
340: goto ddd;
341: case STAT_INIT:
342: // locate static class object
343: stat_init:
344: // error('d', "block::simpl: case #1 stat_init : n: %n", n );
345: in->base = QUEST;
346: st = new estmt(SM,n->where,in,0);
347: n->n_initializer = 0;
348: break;
349: case G_CM:
350: st = new estmt(SM,n->where,in->e1,0);
351: n->n_initializer = 0;
352: break;
353: case ASSIGN: // assignment to "n"?
354: if (in->e1 == n) {
355: st = new estmt(SM,n->where,in,0);
356: n->n_initializer = 0;
357: break;
358: }
359: default:
360: goto ddd;
361: }
362: }
363: }
364: else if (cl_obj_vec) {
365: Pclass cl = Pclass(cl_obj_vec->tp);
366: Pname d = cl->has_dtor();
367: Pname c = cl->has_ictor();
368: // error('d',"vec %n: in %k c %n",n,in?in->base:0,c);
369: n->n_initializer = 0;
370:
371: if (c) { // _vec_new(vec,noe,sz,ctor);
372: if (in==0 || in->base==ILIST) {
373: Pexpr a = cdvec(vec_new_fct,n,cl,c,-1,0);
374: st = new estmt(SM,n->where,a,0);
375: }
376: else
377: st = new estmt(SM,n->where,in,0);
378: }
379:
380: if (d) { // __vec_delete(vec,noe,sz,dtor,0);
381: Pfct f = Pfct(d->tp);
382: int i = 0;
383: for (Pname nn = f->f_args->n_list; nn && nn->n_list; nn=nn->n_list) i++;
384: //error('d',"d %n i %d",n,i);
385: Pexpr a = cdvec(vec_del_fct,n,cl,d,0,new ival(i));
386: // Pstmt dls = new estmt(SM,n->where,a,0);
387: Pstmt dls = new estmt(SM,no_where,a,0);
388: if (dd) {
389: dls->s_list = dd;
390: dd = dls;
391: }
392: else
393: ddt = dd = dls;
394: }
395: }
396: else if (in) {
397: switch (in->base) {
398: case ILIST:
399: switch (n->n_scope) {
400: case FCT:
401: if (in->e2) { // pointer to member
402: Pexpr ee = mptr_assign(n,in);
403: st = new estmt(SM,n->where,ee,0);
404: n->n_initializer = 0;
405: break;
406: }
407: case ARG:
408: if (ansi_opt == 0) error('s',"Ir list for localV%n",n);
409: }
410: break;
411: case STAT_INIT:
412: // error('d', "block::simpl: case #2 stat_init : n: %n", n );
413: in->base = QUEST;
414: st = new estmt(SM,n->where,in,0);
415: n->n_initializer = 0;
416: break;
417: case STRING:
418: if (n->tp->base==VEC) break; /* BUG char vec only */
419: default:
420: ddd:
421: { Pexpr ee = new expr(ASSIGN,n,in);
422: st = new estmt(SM,n->where,ee,0);
423: n->n_initializer = 0;
424: }
425: }
426: }
427:
428: if (st) {
429: if (ss)
430: sst->s_list = st;
431: else
432: ss = st;
433: sst = st;
434: }
435: }
436:
437: if (dd) {
438: Pstmt od = del_list;
439: Pstmt obd = break_del_list;
440: Pstmt ocd = continue_del_list;
441:
442: dd->simpl();
443: del_list = (od) ? Pstmt(new pair(curloc,dd,od)) : dd;
444: break_del_list = (break_del_list&&obd) ? Pstmt(new pair(curloc,dd,obd)) : dd;
445: continue_del_list = (continue_del_list&&ocd) ? Pstmt(new pair(curloc,dd,ocd)) : dd;
446:
447: stail = s ? s->simpl() : 0;
448:
449: Pfct f = Pfct(curr_fct->tp);
450: if (this!=f->body
451: || f->returns->base==VOID
452: || (f->returns->base!=VOID && no_of_returns==0 ) // you have been warned!
453: || strcmp(curr_fct->string,"main")==0 ) {
454: // not dropping through the bottom of a value returning function
455: if (stail) {
456: Pstmt tt = (stail->base==RETURN || stail->base==LABEL) ? stail : trim_tail(stail);
457: if (tt->base != RETURN) stail->s_list = dd;
458: }
459: else
460: s = dd;
461: stail = ddt;
462: }
463:
464: del_list = od;
465: continue_del_list = ocd;
466: break_del_list = obd;
467: }
468: else
469: stail = s ? s->simpl() : 0;
470:
471: if (ss) { /* place constructor calls */
472: ss->simpl();
473: sst->s_list = s;
474: s = ss;
475: if (stail == 0) stail = sst;
476: }
477:
478: scope = old_scope;
479:
480: return stail;
481: }
482:
483: int no_sizeof;
484:
485: void expr::simpl()
486: {
487: //error('d',"%d->expr::simpl %k e1=%d e2=%d",this,base,e1,e2);
488: if (this==0 || permanent==2) return; // already expanded
489:
490: switch (base) {
491: case MDOT:
492: mem->simpl();
493: // no break
494:
495: case ICALL: // already expanded
496: return;
497:
498: case G_ADDROF:
499: case ADDROF:
500: //error('d',"simpl & %k",e2->base);
501:
502: e2->simpl();
503: switch (e2->base) {
504: case DOT:
505: case REF:
506: { Pref r = Pref(e2);
507: Pname m = Pname(r->mem);
508: while (m->base == MDOT) m = Pname(m->mem);
509: if (m->n_stclass == STATIC) { // & static member
510: Pexpr x;
511: delp:
512: x = e2;
513: e2 = m;
514: r->mem = 0;
515: DEL(x);
516: }
517: else if (m->tp->base == FCT) { // & member fct
518: Pfct f = Pfct(m->tp);
519: if (f->f_virtual) { // &p->f ==> p->vtbl[fi]
520: int index = f->f_virtual;
521: Pexpr ie = index ? new ival(index):0;
522: if (ie) ie->tp = int_type;
523: Pname cn = m->n_table->t_name;
524: Pname vp = find_vptr(Pclass(cn->tp));
525: r->mem = vp;
526: base = DEREF;
527: e1 = e2;
528: e2 = ie;
529: }
530: else {
531: goto delp;
532: }
533: }
534: break;
535: }
536: }
537: break;
538:
539: case ANDAND:
540: case OROR:
541: Ntmp = 0;
542: // no break
543:
544: default:
545: if (e1) e1->simpl();
546: if (e2) e2->simpl();
547: break;
548:
549: case CM:
550: case G_CM:
551: { Pname n = 0;
552: e1->simpl();
553: e2->simpl();
554: if (e1->base==ICALL && e1->e1==0) n = e1->il->fct_name;
555: if (e2->base==ICALL && e2->e1==0) n = e2->il->fct_name;
556: if (n) error('s',"call of inline void%n in commaE",n);
557: // no break
558: }
559: case NAME:
560: case DUMMY:
561: case ICON:
562: case FCON:
563: case CCON:
564: case IVAL:
565: case FVAL:
566: case LVAL:
567: case STRING:
568: case ZERO:
569: case ILIST:
570: // case MDOT:
571: return;
572: /*
573: case SIZEOF:
574: base = IVAL;
575: i1 = tp2->tsizeof();
576: tp2 = 0; // can't DEL(tp2)
577: break;
578: */
579: case SIZEOF:
580: if (e1) e1->simpl();
581: return;
582:
583: case G_CALL:
584: case CALL:
585: Pcall(this)->simpl();
586: break;
587:
588: case NEW:
589: case GNEW:
590: simpl_new();
591: return;
592:
593: case DELETE:
594: case GDELETE:
595: simpl_delete();
596: break;
597:
598: case QUEST:
599: cond->simpl();
600: Ntmp = 0;
601: e2->simpl();
602: // no break
603:
604: case CAST:
605: case REF:
606: e1->simpl();
607: break;
608:
609: case DOT:
610: e1->simpl();
611: switch (e1->base) {
612: case CM:
613: case G_CM:
614: { // &( , name). => ( ... , &name)->
615: Pexpr ex = e1;
616: cfr:
617: switch (ex->e2->base) {
618: case NAME:
619: base = REF;
620: ex->e2 = ex->e2->address();
621: break;
622: case CM:
623: case G_CM:
624: ex = ex->e2;
625: goto cfr;
626: }
627: }
628: }
629: break;
630:
631: case ASSIGN:
632: {
633: Pfct f = 0;
634: Pexpr th = 0;
635: if ( curr_fct ) {
636: f = Pfct(curr_fct->tp);
637: th = f->f_this;
638: }
639:
640: imeasure++;
641: if (e1) e1->simpl();
642: if (e2) {
643: Pexpr c = e2;
644: c->simpl();
645: while (c->base == CAST) c = c->e1;
646: if (c->base == ILIST) e2 = c;
647:
648: if (e2->base == ILIST) { // pointer to member assignment
649: Pexpr ee = mptr_assign(e1,e2);
650: Pexpr eee = new expr(CM,ee->e2,e1);
651: e1 = ee->e1;
652: e2 = eee;
653: base = CM;
654: delete ee;
655: }
656: }
657:
658: if (th && th==e1 && curr_fct->n_oper==CTOR && init_list) {
659: // this=e2 => (this=e2,init_list)
660: Pclass cl = Pclass(Pbase(Pptr(th->tp)->typ)->b_name->tp);
661: if (cl->c_body == 1) cl->dcl_print(0);
662: imeasure++;
663: base = CM;
664: e1 = new expr(ASSIGN,e1,e2);
665: e2 = init_list;
666: if (warning_opt) // timid
667: error('w',"assignment to ``this'' inK: try defining%t::operator new() instead",f->memof);
668: }
669: break;
670: }
671: }
672:
673: switch (base) {
674: case QUEST:
675: case ANDAND:
676: case OROR:
677: if (Ntmp) error('s',"temporary ofC%n with destructor needed in%kE",Ntmp,base);
678: // no break;
679: default:
680: Ntmp = 0;
681: }
682:
683: if (tp==int_type || tp==defa_type) {
684: Neval = 0;
685: no_sizeof = 1; // do not convert sizeof's to ints
686: long i = eval();
687: no_sizeof = 0;
688: if (Neval == 0) {
689: base = IVAL;
690: i1 = i;
691: }
692: }
693:
694: }
695:
696: Pexpr vptr_entry(Pexpr pp, Pexpr ie, Pclass cl)
697: {
698: Pptr ttemp = pp->tp->is_ptr_or_ref();
699:
700: if (ttemp) {
701: Ptype pt = ttemp->typ; // check if cast pp = (base*)pp
702: Pclass pc = Pclass(pt->is_cl_obj()->tp); // is needed
703: if (pc!=cl) pp = new cast(cl,pp);
704: }
705: Pname vp = find_vptr(cl);
706: if (vp == 0) error('i',"can't find vptr");
707: Pexpr vptr = new ref(REF,pp,vp); // pp->vptr
708: return new expr(DEREF,vptr,ie); // pp->vptr[i]
709: }
710:
711: Pexpr new_this(Pexpr pp, Pexpr ee)
712: {
713: //error('d',"new this");
714: Pexpr dee = new mdot("d",ee); // pp->vptr[i].d
715: dee->i1 = 9;
716: Pexpr nthis = new cast(Pchar_type,pp);
717: nthis = new expr(PLUS,nthis,dee); // ((char*)pp)+delta
718: Ptype ct = pp->tp;
719: if (pp->base==NAME && Pname(pp)->n_xref) ct = pp->tp->addrof();
720: return new cast(ct,nthis);
721: }
722:
723: Pcall vcall(Pexpr pp, Pexpr ie, Pfct f, Pclass cl, Pexpr args)
724: /*
725: generate a call of the virtual function with the index ``ie''
726: and type "f" in class ``cl'' for the object pointed to by ``pp''
727:
728: multiple inheritance virtual call:
729:
730: p->f(x) is resolved like this
731: pp = p; // avoid side effects
732: pp = p.base_object; // often: pp = p;
733: // done when the name was resolved
734: i = index(f);
735: entry = pp->_vtbl[i-1];
736: pp = (T*)(((char*)pp)+entry.d)
737: (*(ftype)entry.f)(pp,x)
738: */
739: {
740: //error('d',"vcall %t",cl);
741: if (cl->c_body==1) cl->dcl_print(0); // look for first use of cl
742:
743: imeasure+=6;
744: Pexpr ee = vptr_entry(pp,ie,cl);
745:
746: Pexpr fee = new mdot("f",ee);
747: fee->i1 = 9;
748: Ptype pft = f->addrof();
749: fee = new cast(pft,fee); // (T)pp->vptr[i].f
750: Pexpr r = new expr(DEREF,fee,0); // *(T)pp->vptr[i].f
751: // e1->tp must be 0, means "argtype encoded"
752: r->tp2 = Ptype(f->f_this); // encode argtype
753:
754: Pexpr nthis = new_this(pp,ee);
755:
756: args = new expr(ELIST,nthis,args);
757: args->simpl();
758:
759: Pcall c = new call(r,args);
760: c->tp = f->returns;
761: return c;
762: }
763:
764: void call::simpl()
765: /*
766: fix member function calls:
767: p->f(x) becomes f(p,x)
768: o.f(x) becomes f(&o,x)
769: or if f is virtual:
770: p->f(x) is resolved like this
771: pp = p;
772: i = index(f);
773: entry = pp->_vtbl[i-1];
774: pp = (T*)(((char*)pp)+entry.i)
775: (*entry.f)(pp,x)
776: replace calls to inline functions by the expanded code
777: */
778: {
779: Pname fn = fct_name;
780: //error('d',"%d call::simpl() fn %n %d e1 %d",this,fn,fn,e1);
781: Pfct f = fn ? Pfct(fn->tp) : 0;
782:
783: if (fn == 0) e1->simpl();
784:
785: if (f) {
786: switch(f->base) {
787: case ANY:
788: return;
789: case OVERLOAD:
790: fct_name = fn = Pgen(f)->fct_list->f;
791: f = Pfct(fn->tp);
792: }
793: }
794:
795: switch (e1->base) {
796: case MEMPTR: // (p ->* q)(args)
797: {
798: Pexpr p = e1->e1;
799: Pexpr q = e1->e2;
800: Pclass cl = Pclass(e1->tp2);
801: Pfct f = Pfct(q->tp->deref());
802:
803: if (e2) e2->simpl();
804:
805: if (f->f_this == 0) { // might not know about ``this'' yet
806: if (f->memof == 0) error('i',"memof missing");
807: Pname tt = new name("this");
808: tt->n_scope = ARG;
809: tt->tp = f->memof->this_type;
810: PERM(tt);
811: // f->f_this = f->f_args = tt;
812: tt->n_list = f->argtype;
813: // f->f_this = tt;
814: tt->n_list = f->f_result ? f->f_result : f->argtype;
815: f->f_this = f->f_args = tt;
816: }
817: //error('d',"f_this %d",f->f_this);
818: extern has_virt(Pclass);
819:
820: // beware of sideeffects:
821: extern nin;
822: nin = 1;
823: if (q->not_simple()) error('s',"2nd operand of .* too complicated");
824: nin = 0;
825:
826: Pexpr qq = new mdot("f",q); // the function: (*(right type)q.f)
827: qq->i1 = 9;
828: qq = new cast(f->addrof(),qq);
829: Pexpr nc = new expr(DEREF,qq,0);
830: nc->tp2 = Ptype(f->f_this); // encode argtype
831:
832: Pexpr nthis = new_this(p,q); // arguments: (p+q.d,args)
833: Pexpr args = new expr(ELIST,nthis,e2);
834: imeasure+=3;
835:
836: if (has_virt(cl) == 0) { // no virtuals: simple
837: if (cl->defined == 0)
838: error("call throughP toMF before definition ofC %t",cl);
839: //error('d',"no virt");
840: // (p ->* q)(args) => (*q.f)(p+q.d,args)
841: e1 = nc;
842: e2 = args;
843: return;
844: }
845:
846: if (find_vptr(cl) == 0) { // must be a call to a second base
847: // that we cannot handle yet
848: // it is OK not to to generate
849: // a virtual call since a
850: // `sorry' will have been generated
851: // at the point of initialization
852: e1 = nc;
853: e2 = args;
854: return;
855:
856: }
857: // beware of sideeffects:
858: nin = 1;
859: if (p->not_simple()) error('s',"1st operand of .* too complicated");
860: nin = 0;
861:
862: Pexpr c = new mdot("i",q); // condition (q.i<0)
863: c->i1 = 9;
864: c = new expr(LT,c,zero);
865:
866: Pexpr ie = new mdot("i",q);
867: ie->i1 = 9;
868:
869: base = QUEST;
870: e1 = new call(nc,args);
871: e2 = vcall(p,ie,f,cl,e2);
872: cond = c;
873: return;
874: }
875: case DOT:
876: // if e1 is an object and not just a reference
877: // the vtbl need not be used
878: case REF:
879: { Pref r = Pref(e1);
880: Pexpr a1 = r->e1;
881: int obj = r->n_initializer!=0; // if B::f don't use vcall
882:
883: if (obj == 0) { // don't use vcall if we have an object
884: // (not a pointer or a reference)
885: if (e1->base==DOT && a1->base!=DEREF) obj = 1;
886: }
887:
888: //error('d',"fct_name %n f %d %d obj %d",fct_name,f,f->f_virtual,obj);
889: if (f && obj==0 && f->f_virtual) {
890: Pexpr a11 = 0;
891:
892: switch(a1->base) { // see if temporary might be needed
893: case NAME:
894: case MDOT:
895: a11 = a1;
896: break;
897: case REF:
898: case DOT:
899: if (a1->e1->base==NAME
900: || ((a1->e1->base==DOT || a1->e1->base==REF) && a1->e1->e1->base==NAME)) a11 = a1;
901: break;
902: case ADDROF:
903: case G_ADDROF:
904: if (a1->e2->base == NAME
905: || ((a1->e2->base==DOT || a1->e2->base==REF) && a1->e2->e1->base==NAME)) a11 = a1;
906: break;
907: case CAST:
908: switch (a1->e1->base) {
909: case NAME:
910: case MDOT:
911: a11 = a1;
912: }
913: }
914:
915: // if( a1->base==REF && fn->n_oper==DTOR ){
916: // a11 = a1;
917: // goto zsw;
918: // }
919: //
920: if (e1->base == DOT) {
921: // zsw:
922: if (a11) a11 = a11->address();
923: a1 = a1->address();
924: }
925:
926: if (a11 == 0) { // temporary (maybe) needed
927: // e->f() => (t=e,t->f(t))
928: if (a1->base==NAME)
929: a11 = a1; // &*name has become name
930: else {
931: Pname nx = new name(make_name('K'));
932: nx->tp = a1->tp;
933: Pname n = nx->dcl(scope,ARG); // no init!
934: delete nx;
935: Pname cln = a1->tp->is_cl_obj();
936: if (cln) {
937: Pclass cl = Pclass(cln->tp);
938: if (Ntmp==0 && cl->has_dtor()) Ntmp = cln;
939: if (cl->has_itor()) n->n_xref = 1;
940: }
941: n->n_scope = FCT;
942: n->assign();
943: a11 = n;
944: a1 = new expr(ASSIGN,n,a1);
945: a1->tp = n->tp;
946: a1->simpl();
947: Pcall cc = new call(0,0);
948: *cc = *this;
949: base = CM;
950: e1 = a1;
951: e2 = cc;
952: this = cc;
953: }
954: }
955:
956: int i = f->f_virtual;
957: Pexpr ie = i?new ival(i):0; // index
958: Pname cn = fn->n_table->t_name;
959: if (fn
960: && fn->n_initializer
961: && cc->nof
962: && cc->nof->n_oper==CTOR
963: && Pfct(cc->nof->tp)->memof->c_abstract)
964: error("call of pure virtualF%n inK%n",fn,cc->nof);
965: Pcall vc = vcall(a11,ie,f,Pclass(cn->tp),e2);
966: *this = *vc;
967: return;
968: }
969:
970: Ptype tt = r->mem->tp;
971: llp:
972: //error('d',"llp %t",tt);
973: switch (tt->base) {
974: // default: // pointer to function: (n->ptr_mem)(args); do nothing
975: case TYPE:
976: tt = Pbase(tt)->b_name->tp;
977: goto llp;
978: case OVERLOAD: // n->fctmem(args);
979: case FCT:
980: if (fct_name==0) {
981: // reconstitute fn destroyed to suppress "virtual"
982: fct_name = fn = Pname(e1->n_initializer);
983: f = Pfct(fn->tp);
984: }
985:
986: if (e1->base == DOT) a1 = a1->address();
987: e2 = new expr(ELIST,a1,e2);
988: e1 = r->mem;
989: }
990: }
991: }
992:
993: if (e2) e2->simpl();
994: //error('d',"fn %n inl %d imes %d",fn,f->f_inline,f->f_imeasure);
995: if (fn && f->f_inline && debug_opt==0) {
996: imeasure += f->f_imeasure;
997: Pclass cl = f->memof;
998: if (cl && cl->c_body) cl->dcl_print(0);
999: Ptable oscope = scope;
1000: Pexpr ee = f->expand(fn,scope,e2);
1001: scope = oscope;
1002: if (ee) *Pexpr(this) = *ee;
1003: }
1004: else if (fn && f->f_inline==0 && f->f_imeasure) {
1005: extern void uninline(Pname fn);
1006: uninline(fn);
1007: imeasure += 3;
1008: }
1009: else if (fn && debug_opt && f->f_inline==ITOR) {
1010: extern void expand_itor(Pclass);
1011: expand_itor(f->memof);
1012: }
1013: else
1014: imeasure += 3;
1015: }
1016:
1017: void uninline(Pname fn)
1018: // inline turned static
1019: {
1020: Pfct f = Pfct(fn->tp);
1021: //error('d',"uninline %n %d %d",fn,f->body,f->f_expr);
1022:
1023: if (warning_opt) error('w',"%n too complex for inlining",fn);
1024: f->f_imeasure = 0; // now it really is just static
1025:
1026: Pstmt s = f->body->s;
1027: // for (s = f->body->s; s; s=s->s_list)
1028: //error('d',"start %d %k",s->e,s->e->base);
1029: // s = f->body->s;
1030: while (s) {
1031: //error('d',"s %k %d %k",s->base,s->e,s->e->base);
1032: if (s->base == SM) {
1033: // turn comma expression into statement list
1034: Pexpr e = s->e;
1035: if (e)
1036: switch (e->base) {
1037: case CM:
1038: case G_CM:
1039: { Pstmt ss = new estmt(SM,no_where,e->e2,0);
1040: s->e = e->e1;
1041: ss->s_list = s->s_list;
1042: s->s_list = ss;
1043: delete e;
1044: continue;
1045: }
1046: }
1047: }
1048: s = s->s_list;
1049: }
1050: // for (s = f->body->s; s; s=s->s_list)
1051: //error('d',"echo %k %d %k",s->base,s->e,s->e->base);
1052:
1053: fn->dcl_print(0);
1054: }
1055:
1056: /*
1057: void ccheck(Pexpr e)
1058:
1059: Is there a conditional in this expression? (not perfect)
1060:
1061: {
1062: //error('d',"ccheck(e %k)",e,e?e->base,0);
1063: if (e)
1064: switch (e->base) {
1065: case QUEST:
1066: case ANDAND:
1067: case OROR:
1068: error('s',"E too complicated: uses%k and needs temporary ofCW destructor",e->base);
1069: break;
1070: case LT:
1071: case LE:
1072: case GT:
1073: case GE:
1074: case EQ:
1075: case NE:
1076: case ASSIGN:
1077: case ASPLUS:
1078: case ASMINUS:
1079: case G_CM:
1080: case CM:
1081: case PLUS:
1082: case MINUS:
1083: case MUL:
1084: case DIV:
1085: case OR:
1086: case ER:
1087: case AND:
1088: case G_CALL:
1089: case CALL:
1090: case ELIST:
1091: case DEREF:
1092: ccheck(e->e1);
1093: case NOT:
1094: case COMPL:
1095: case CAST:
1096: case ADDROF:
1097: case G_ADDROF:
1098: ccheck(e->e2);
1099: break;
1100: case ICALL: // check inlined arguments
1101: { Pin il = e->il;
1102: for (int i = 0; il->args[i].arg && i<il->i_slots; i++) ccheck(il->args[i].arg);
1103: }
1104: }
1105: }
1106: */
1107:
1108: void temp_in_cond(Pexpr ee, Pstmt ss, Ptable tbl)
1109: /*
1110: insert destructor calls 'ss' into condition 'ee'
1111: ee => (Qnn = ee, dtors, Qnn)
1112: */
1113: {
1114: //error('d',"temp_in_cond");
1115: // ccheck(ee);
1116: while (ee->base==CM || ee->base==G_CM) ee = ee->e2;
1117: Ptype ct = ee->tp;
1118: Pname n = new name(make_name('Q')); // int Qnn;
1119: n->tp = ct;
1120: Pname tmp = n->dcl(tbl,ARG);
1121: delete n;
1122: tmp->n_scope = FCT;
1123:
1124: Pexpr v = new expr(0,0,0);
1125: *v = *ee;
1126: PERM(ct);
1127: v = new cast(ct,v);
1128: Pexpr c = new expr(ASSIGN,tmp,v); // Qnn = ee
1129: c->tp = ct;
1130: ee->base = CM;
1131: ee->e1 = c;
1132:
1133: Pexpr ex = 0; // add dtors at end
1134:
1135: for (Pstmt sx = ss; sx; sx = sx->s_list) {
1136: if (ex) {
1137: ex = new expr(CM,ex,sx->e);
1138: ex->tp = sx->e->tp;
1139: }
1140: else
1141: ex = sx->e;
1142: }
1143: ee->e2 = new expr(CM,ex,tmp); // add Qnn at end
1144: ee->e2->tp = ct;
1145: }
1146:
1147: bit not_safe(Pexpr e)
1148: {
1149:
1150: switch (e->base) {
1151: default:
1152: return 1;
1153: /*
1154: case CALL:
1155: case G_CALL:
1156: case DOT:
1157: case REF:
1158: case ANAME:
1159: return 1;
1160: */
1161: case NAME:
1162: // if the name is automatic and has a destructor it is not safe
1163: // to destroy it before returning an expression depending on it
1164: { Pname n = Pname(e);
1165: if (n->n_table!=gtbl && n->n_table->t_name==0) {
1166: Pname cn = n->tp->is_cl_obj();
1167: if (cn && Pclass(cn->tp)->has_dtor()) return 1;
1168: }
1169: }
1170: case IVAL:
1171: case ICON:
1172: case CCON:
1173: case FCON:
1174: case STRING:
1175: return 0;
1176: case NOT:
1177: case COMPL:
1178: case ADDROF:
1179: case G_ADDROF:
1180: return not_safe(e->e2);
1181: case DEREF:
1182: // return not_safe(e->e1) || e->e2?not_safe(e->e2):0;
1183: { int i = not_safe(e->e1);
1184: if (i) return i;
1185: if (e->e2) return not_safe(e->e2);
1186: return 0;
1187: }
1188: case CM:
1189: case PLUS:
1190: case MINUS:
1191: case MUL:
1192: case DIV:
1193: case MOD:
1194: case ASSIGN:
1195: case ASPLUS:
1196: case ASMINUS:
1197: case ASMUL:
1198: case ASDIV:
1199: case OR:
1200: case AND:
1201: case OROR:
1202: case ANDAND:
1203: case LT:
1204: case LE:
1205: case GT:
1206: case GE:
1207: case EQ:
1208: case NE:
1209: return not_safe(e->e1) || not_safe(e->e2);
1210: case QUEST:
1211: return not_safe(e->cond) || not_safe(e->e1) || not_safe(e->e2);
1212: }
1213: }
1214:
1215:
1216: Pexpr curr_expr; /* to protect against an inline being expanded twice
1217: in a simple expression keep track of expressions
1218: being simplified
1219: */
1220: Pstmt stmt::simpl()
1221: /*
1222: return a pointer to the last statement in the list, or 0
1223: */
1224: {
1225: if (this == 0) error('i',"0->S::simpl()");
1226:
1227: Pstmt cstmt = Cstmt;
1228: Cstmt = this;
1229:
1230: curr_expr = e;
1231: //error('d',"stmt::simpl %k s_list %d",base,s_list);
1232:
1233: switch (base) {
1234: default:
1235: error('i',"S::simpl(%k)",base);
1236:
1237: case ASM:
1238: break;
1239:
1240: case BREAK:
1241: if (break_del_list) { // break => { _dtor()s; break; }
1242: Pstmt bs = new stmt(base,where,0);
1243: Pstmt dl = break_del_list->copy();
1244: base = BLOCK;
1245: s = new pair(where,dl,bs);
1246: }
1247: break;
1248:
1249: case CONTINUE:
1250: if (continue_del_list) { // continue => { _dtor()s; continue; }
1251: Pstmt bs = new stmt(base,where,0);
1252: Pstmt dl = continue_del_list->copy();
1253: base = BLOCK;
1254: s = new pair(where,dl,bs);
1255: }
1256: break;
1257:
1258: case DEFAULT:
1259: s->simpl();
1260: break;
1261:
1262: case SM:
1263: if (e) {
1264: if (e->base == DEREF) e = e->e1;
1265: e->simpl();
1266: if (e->base == DEREF) e = e->e1;
1267: }
1268: break;
1269:
1270: case RETURN:
1271: { /* return x;
1272: =>
1273: { dtor()s; return x; }
1274: OR (returning an X where X(X&) is defined) =>
1275: { ctor(_result,x); _dtor()s; return; }
1276: OR (where x needs temporaries)
1277: OR (where x might involve an object to be destroyed) =>
1278: { _result = x; _dtor()s; return _result; }
1279: return; =>
1280: { _dtor()s; return; }
1281: OR (in constructors) =>
1282: { _dtor()s; return _this; }
1283: */
1284: Pstmt sx = this;
1285: Pexpr ex = e;
1286:
1287: no_of_returns++;
1288:
1289: Pstmt dl = (del_list) ? del_list->copy() : 0;
1290: Pfct f = Pfct(curr_fct->tp);
1291:
1292: if (e == 0) e = dummy;
1293: if (e==dummy && curr_fct->n_oper==CTOR) e = f->f_this;
1294:
1295:
1296: // need to generate a temporary for mptr return
1297: Pexpr tt = e;
1298: while ( tt->base == CAST )
1299: tt = tt->e1;
1300: if ( tt->base == ILIST )
1301: e = tt;
1302:
1303: if (e->base == ILIST) {
1304: extern Pbase mptr_type;
1305: extern Ptype Pvptr_type;
1306: Pexpr mptr_assign(Pexpr, Pexpr);
1307: // memptr constant
1308: // return({1,2,f}) ==> memptr t; return((t={1,2,f},&t))
1309:
1310: Ptable ftbl = Pfct(curr_fct->tp)->body->memtbl;
1311: Pname temp = make_tmp('A',mptr_type,ftbl);
1312:
1313: // placed in mptr_assign()
1314: // temp->use(); // necessary for inlines to force declaration
1315:
1316: e = mptr_assign(temp,e);
1317: e = new expr(G_CM,e,temp);
1318: e->tp = mptr_type;
1319: }
1320:
1321: if (f->f_result) { // ctor(_result,x); dtors; return;
1322: if (e->base == G_CM) e = replace_temp(e,f->f_result);
1323: e->simpl();
1324: Pstmt cs = new estmt(SM,where,e,0);
1325: if (dl) cs = new pair(where,cs,dl);
1326: base = PAIR;
1327: s = cs;
1328: s2 = new estmt(RETURN,where,0,0);
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->ret_tp = ret_tp;
1645: base = PAIR;
1646: s = ss;
1647: s2 = rs;
1648: Cstmt = cstmt;
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: Cstmt = cstmt;
1674: return t1 ? t1 : rs;
1675: }
1676: }
1677:
1678: case FOR: // don't know which expression the temp comes from
1679: error('s',&where,"E in %kS needs temporary ofC%nW destructor",base,cln);
1680: break;
1681:
1682: case SM: // place dtors after all "converted" DCLs
1683: if (t1) {
1684: // ccheck(e);
1685: for (Pstmt ttt, tt=this;
1686: (ttt=tt->s_list) && ttt->base==SM;
1687: tt = ttt) ;
1688: t2->s_list = ttt;
1689: tt->s_list = ss;
1690: Cstmt = cstmt;
1691: return t1!=tt ? t1 : t2;
1692: }
1693: default:
1694: def:
1695: // if (e) ccheck(e);
1696: if (t1) { // t1 == tail of statment list
1697: t2->s_list = s_list;
1698: s_list = ss;
1699: Cstmt = cstmt;
1700: return t1;
1701: }
1702: s_list = ss;
1703: Cstmt = cstmt;
1704: return t2;
1705: }
1706: }
1707: Cstmt = cstmt;
1708: return (t1) ? t1 : this;
1709: }
1710:
1711: Cstmt = cstmt;
1712: return (s_list) ? s_list->simpl() : this;
1713: }
1714:
1715: Pstmt stmt::copy()
1716: // now handles dtors in the expression of an IF stmt
1717: // not general!
1718: {
1719: Pstmt ns = new stmt(0,curloc,0);
1720:
1721: *ns = *this;
1722: if (s) ns->s = s->copy();
1723: if (s_list) ns->s_list = s_list->copy();
1724:
1725: switch (base) {
1726: case PAIR:
1727: ns->s2 = s2->copy();
1728: break;
1729: }
1730:
1731: return ns;
1732: }
1733:
1734: void expr::simpl_new()
1735: /*
1736: change NEW or GNEW node to CALL node
1737: */
1738: {
1739: Pname cln;
1740: Pname ctor;
1741: int sz = 1;
1742: // int esz;
1743: Pexpr var_expr = 0;
1744: Pexpr const_expr = 0;
1745: Ptype tt = tp2;
1746: Pexpr arg;
1747: Pexpr szof;
1748: Pname nf;
1749: Pexpr init = e1;
1750:
1751: if (init && init->base) init = 0; // only non-ctor init
1752: //error('d',"use new %d used %d init %d",base,new_used,init);
1753:
1754: if (cln=tt->is_cl_obj()) {
1755: Pclass cl = Pclass(cln->tp);
1756: Pexpr p;
1757: ctor=cl->has_ctor();
1758: //error('d',"cl %t ctor %n",cl, ctor);
1759: if (e2 // placement
1760: || ctor==0 // no constructor
1761: || ctor->n_table!=cl->memtbl // inherited constructor???
1762: ) {
1763: // allocate using operator new(sizeof(cl),args1)
1764: Pexpr ce = new texpr(SIZEOF,tt,0);
1765: (void) tt->tsizeof();
1766: ce->tp = uint_type;
1767: e2 = new expr(ELIST,ce,e2);
1768: char* s = oper_name(NEW);
1769: Pname n = new name(s);
1770: if (base == GNEW) // ::new
1771: p = gtbl->look(s,0);
1772: else
1773: p = find_name(n,cl,scope,CALL,curr_fct);
1774: p = new call(p,e2);
1775: (void) p->call_fct(cl->memtbl);
1776: }
1777: else
1778: p = zero; // 0->ctor(args)
1779:
1780: if (ctor) {
1781: Pexpr c = e1; // ctor call generated in expr::typ
1782: Ptype ttt = tp;
1783: c->e1->e1 = p; // p->ctor
1784: c->simpl();
1785: *this = *c;
1786: tp = ttt;
1787: delete c;
1788: }
1789: else { // (tp)new(args)
1790: base = CAST;
1791: tp2 = tp;
1792: e1 = p;
1793: e2 = 0;
1794: simpl();
1795: }
1796: return;
1797: }
1798:
1799: if (cl_obj_vec) {
1800: Pclass cl = Pclass(cl_obj_vec->tp);
1801: ctor = cl->has_ictor();
1802: if (ctor == 0) {
1803: if (cl->has_ctor()) error("new %s[], no defaultK",cl->string);
1804: cl_obj_vec = 0;
1805: }
1806: }
1807:
1808: xxx:
1809: //error('d',"xxx %t",tt);
1810: switch (tt->base) {
1811: case TYPE:
1812: tt = Pbase(tt)->b_name->tp;
1813: goto xxx;
1814:
1815: default:
1816: (void) tt->tsizeof();
1817: szof = new texpr(SIZEOF,tt,0);
1818: szof->tp = uint_type;
1819: break;
1820:
1821: case VEC:
1822: { Pvec v = Pvec(tt);
1823: //error('d',"v %d %d",v->size,v->dim);
1824: if (v->size)
1825: sz *= v->size;
1826: else if (v->dim)
1827: var_expr = v->dim;
1828: else
1829: sz = 0;
1830: tt = v->typ;
1831: goto xxx;
1832: }
1833: }
1834:
1835: if (cl_obj_vec) { // _vec_new(0,no_of_elements,element_size,ctor)
1836: const_expr = new ival(sz);
1837: Pexpr noe = (var_expr) ? (sz!=1) ? new expr(MUL,const_expr,var_expr) : var_expr : const_expr;
1838: const_expr = szof;
1839: const_expr->tp = uint_type;
1840: base = CALL;
1841: arg = new expr(ELIST,ctor,0);
1842: /*ctor->take_addr();*/
1843: ctor->lval(ADDROF);
1844: arg = new expr(ELIST,const_expr,arg);
1845: arg = new expr(ELIST,noe,arg);
1846: arg = new expr(ELIST,e2?e2:zero,arg); // may be preallocated
1847: base = CAST;
1848: tp2 = tp;
1849: e1 = new expr(G_CALL,vec_new_fct,arg);
1850: e1->fct_name = vec_new_fct;
1851: e1->tp = Pfct(vec_new_fct->tp)->returns;
1852: simpl();
1853: return;
1854: }
1855:
1856: /* call _new(element_size*no_of_elements) */
1857: //error('d',"sz %d var %d",sz,var_expr);
1858: if (sz == 1)
1859: arg = (var_expr) ? new expr(MUL,szof,var_expr) : szof;
1860: else {
1861: const_expr = new ival(sz);
1862: const_expr->tp = uint_type;
1863: const_expr = new expr(MUL,const_expr,szof);
1864: const_expr->tp = uint_type;
1865: arg = (var_expr) ? new expr(MUL,const_expr,var_expr) : const_expr;
1866: }
1867:
1868: arg->tp = uint_type;
1869: base = CAST;
1870: tp2 = tp;
1871: arg = new expr(ELIST,arg,e2);
1872: nf = gtbl->look(oper_name(NEW),0); // always global,
1873: // all class object handled above
1874: e1 = new expr(G_CALL,nf,arg);
1875: (void) e1->call_fct(gtbl);
1876: simpl();
1877:
1878: if (init) { // alloc(sz) => (p=alloc(sz),*p=init,p);
1879: Pexpr p = init->e1;
1880: Pexpr ee = new expr(0,0,0);
1881: *ee = *this;
1882: ee = new expr(ASSIGN,p,ee); // ee: p = alloc(sz);
1883: init->base = ASSIGN;
1884: init->e1 = p->contents(); // init: *p = init_val
1885: ee = new expr(CM,ee,init);
1886: base = CM;
1887: e1 = ee;
1888: e2 = p;
1889: }
1890: }
1891:
1892: void expr::simpl_delete()
1893: /*
1894: delete p => _delete(p);
1895: or cl::~cl(p,1);
1896: delete[s]p => _delete(p);
1897: or vec_del_fct(p,vec_sz,elem_sz,~cl,1);
1898: */
1899: {
1900: for (Ptype tt = e1->tp; tt->base==TYPE; tt=Pbase(tt)->b_name->tp);
1901: tt = Pptr(tt)->typ;
1902: //error('d',"simpl_delete() %t",e1->tp);
1903: Pname cln = tt->is_cl_obj();
1904: Pname n;
1905: Pclass cl;
1906:
1907: if (cln) {
1908: cl = Pclass(cln->tp);
1909: if ((cl->defined&DEFINED) == 0) error('w',"delete%t (%t not defined)",cl,cl);
1910: }
1911: else
1912: cl = 0;
1913:
1914: if (cl && (n=cl->has_dtor())) { // ~cl() might be virtual
1915: Pexpr r = e1;
1916:
1917: // handle delete p, where p has a private destructor
1918: if (n->n_scope != PUBLIC) check_visibility(n,0,cl,cc->ftbl,cc->nof);
1919: //error('d',"e2 %d %k",e2,base);
1920: if (e2 == 0) { // e1->cl::~cl(1)
1921: Pexpr ee = call_dtor(r,n,base==GDELETE?0:one,REF,one);
1922: if (Pfct(n->tp)->f_virtual) {
1923: extern nin;
1924: nin = 1;
1925: if (r->not_simple()) error('s',"PE too complicated for delete");
1926: nin = 0;
1927: #ifndef sun
1928: if (ansi_opt) { // q?void:int would be an error
1929: #endif
1930: ee = new expr(G_CM,ee,zero);
1931: ee->tp = zero_type;
1932: #ifndef sun
1933: }
1934: #endif
1935: ee = new expr(QUEST,ee,zero);
1936: ee->tp = ee->e1->tp;
1937: ee->cond = r;
1938: }
1939: if (base == GDELETE) {
1940: char* s = oper_name(DELETE);
1941: Pexpr p = gtbl->look(s,0);
1942: e2 = new call(p,e1);
1943: base = CM;
1944: e1 = ee;
1945: }
1946: else {
1947: *this = *ee;
1948: delete ee;
1949: }
1950: simpl();
1951: return;
1952: }
1953: else { // del_cl_vec(e1,e2,elem_size,~cl,1);
1954: Pexpr sz = new texpr(SIZEOF,tt,0);
1955: (void)tt->tsizeof();
1956: Pfct f = Pfct(n->tp);
1957: int i = 0;
1958: for (Pname nn = f->f_args->n_list; nn && nn->n_list; nn=nn->n_list) i++;
1959: //error('d',"n %n i %d",n,i);
1960: Pexpr arg = new ival(i);
1961: sz->tp = uint_type;
1962: // Pexpr arg = one;
1963: arg = new expr(ELIST,one,arg);
1964: if (Pfct(n->tp)->f_virtual) {
1965: // beware of sideeffects in expression e1
1966:
1967: extern nin;
1968: nin = 1;
1969: if (r->not_simple()) error('s',"PE too complicated for delete[]");
1970: nin = 0;
1971: Pexpr a = new ref(REF,e1,n);
1972: a = a->address();
1973: a = new mdot( "f", a );
1974: a->i1 = 9;
1975: arg = new expr(ELIST,a,arg);
1976: }
1977: else {
1978: arg = new expr(ELIST,n,arg);
1979: n->lval(ADDROF); // n->take_addr();
1980: }
1981: arg = new expr(ELIST,sz,arg);
1982: arg = new expr(ELIST,e2,arg);
1983: arg = new expr(ELIST,e1,arg);
1984: Pexpr ee = new expr(G_CALL,vec_del_fct,arg);
1985: ee->fct_name = vec_del_fct;
1986: ee->tp = tp;
1987: // if (ansi_opt) { // q?void:int would be an error
1988: // ee = new expr(G_CM,ee,zero);
1989: // ee->tp = zero_type;
1990: // }
1991: // ee = new expr(QUEST,ee,zero);
1992: // ee->tp = tp;
1993: // ee->cond = r;
1994: *this = *ee;
1995: simpl();
1996: return;
1997: }
1998: }
1999: else if (cl_obj_vec) {
2000: error("delete array of arrays");
2001: }
2002: else { // _delete(e1)
2003: Pexpr ee = new expr(ELIST,e1,0);
2004: char* s = oper_name(DELETE);
2005: if (cl && base!=GDELETE) {
2006: Pname n = new name(s);
2007: e1 = find_name(n,cl,scope,CALL,curr_fct);
2008: if (e1->tp->base==OVERLOAD || Pfct(e1->tp)->nargs==2) {
2009: Pexpr ss = new texpr(SIZEOF,cl,0);
2010: ss->tp = uint_type;
2011: ee->e2 = new expr(ELIST,ss,0);
2012: }
2013: }
2014: else
2015: e1 = gtbl->look(s,0);
2016: base = G_CALL;
2017: e2 = ee;
2018: (void) call_fct(scope);
2019: }
2020:
2021: Pcall(this)->simpl();
2022: }
2023: /* ODI notes
2024:
2025: set Cstmt to get better error messages
2026:
2027: on sun, don't convert void to char *
2028:
2029: ditch support for RETBUG, it made a union hard to walk in the tree.
2030: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.