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