![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to expand.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 expand.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / ooptcfront |
1.1 root 1: /*ident "@(#)ctrans:src/expand.c 1.3.4.20" */
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: expand.c:
11:
12: expand inline functions
13:
14: ******************************************************************/
15:
16: #include "cfront.h"
17: Ptable Scope;
18: // extern void display_expr(Pexpr);
19:
20: static int inline_name_count = 1;
21: char* temp(char* vn, Pname fn)
22: //
23: // type.inline_temp_index is used to construct the name
24: // in place of the address of fn. That way, cfront
25: // output dosen't change as nodes move around.
26: // AT&T uses the address. --benson@odi
27: // - anything unique will do
28: // add two bytes to make the name sensitive to the scope
29: // to avoid re-using temps when an inline is expanded in
30: // more than one other inline that is then called in the
31: // same expression
32: //
33: {
34: char temp[50]; /* Big enough for any purpose */
35:
36: if (vn[0]!='_' || vn[1]!='_' || vn[2]!='X') {
37: if(fn->tp->inline_temp_index == 0)
38: fn->tp->inline_temp_index = inline_name_count ++;
39: // this used to be the low 3 bytes of fn->tp.
40: // this may be slower, but it works.
41: // tune later.
42: long a = fn->tp->inline_temp_index;
43: sprintf(temp, "%lx", a);
44: int al = strlen(temp);
45: // allocate memory for the result
46: int ll = strlen(vn);
47: char* s = new char[ll+al+8];
48: register char* p = s;
49:
50: // append _ _ X vn
51: *p++ = '_';
52: *p++ = '_';
53: *p++ = 'X';
54: strcpy(p,vn);
55: p += ll;
56: strcat(p,temp);
57: p += al;
58: // append scope representation and trailing null
59: *p++ = 'a' + ((int(Scope)>>4)&15);
60: *p++ = 'a' + ((int(Scope)>>8)&15);
61: *p = '\0';
62: return s;
63: }
64: else
65: return vn;
66:
67: }
68:
69: Pname dcl_local(Ptable scope, Pname an, Pname fn)
70: {
71: if (scope == 0) {
72: if (sti_tbl == 0) sti_tbl = new table(8,gtbl,0);
73: scope = sti_tbl;
74: // error('s',"cannot expand inlineF needing temporaryV in nonF context");
75: // return an;
76: }
77:
78: if (an->n_stclass == STATIC) {
79: if (an->tp->base!=FCT) error('s',"cannot expand inlineF with static%n",an);
80: return an;
81: }
82:
83: Pname cn = fn->n_table->t_name;
84: char* s = temp(an->string,fn);
85: Pname nx = new name(s);
86: Ptype atp = an->tp;
87: //error('d',"dcl_local(%d,%n,%n) -> %s",scope,an,fn,s);
88: while (atp->base == TYPE) atp = Pbase(atp)->b_name->tp;
89: if (atp->base == VEC) {
90: if (an->n_scope == ARG) {
91: Pptr t = new ptr(PTR,Pvec(atp)->typ);
92: nx->tp = t;
93: }
94: else {
95: error('s',"cannot expand inlineF needing temporaryV of vectorT");
96: return an;
97: }
98: }
99: else
100: nx->tp = atp;
101: PERM(nx->tp);
102:
103: nx->n_used = an->n_used;
104: nx->n_assigned_to = an->n_assigned_to;
105: nx->n_addr_taken = an->n_addr_taken;
106: nx->n_xref = an->n_xref;
107: //error('d',"nx %n %t,",nx,nx->tp);
108: Pname r = scope->look(nx->string,0);
109: if (r) {
110: //error('d',"ll %n %t",ll,ll->tp);
111: if (r->tp->check(nx->tp,0))
112: error('s',"cannot expand inlineF %n with two local variables with the sameN (%s)",fn,an->string);
113: else
114: r = 0;
115: }
116: if (r==0) {
117: r = scope->insert(nx,0);
118: //error('d',"%d %d %d %d",r->n_stclass,an->n_stclass,r->lex_level,an->lex_level);
119: r->n_stclass = an->n_stclass;
120: r->lex_level = an->lex_level;
121: delete nx;
122: r->where.line = 0;
123: }
124: return r;
125: }
126:
127: int ck_cast(Ptype t1, Ptype t2)
128: /*
129: return a value of type t2 from a function returning a t1
130: return 1 if cast is needed
131: */
132: {
133: st:
134: while (t1->base == TYPE) t1 = Pbase(t1)->b_name->tp;
135: while (t2->base == TYPE) t2 = Pbase(t2)->b_name->tp;
136:
137: if (t1 == t2) return 0;
138:
139: if (t1->base != t2->base) return 1;
140:
141: switch (t1->base) {
142: case RPTR:
143: case PTR:
144: { t1 = Pptr(t1)->typ;
145: if (t1->base == VOID) return 1;
146: t2 = Pptr(t2)->typ;
147: goto st;
148: }
149: case CHAR:
150: case SHORT:
151: case INT:
152: case LONG:
153: if (Pbase(t1)->b_unsigned != Pbase(t2)->b_unsigned) return 1;
154: break;
155: case COBJ:
156: {
157: Pname nn = Pbase(t1)->b_name;
158:
159: if (Pclass(nn->tp)->csu==UNION ) return 0;
160:
161: if (t2->base==COBJ && nn->tp==Pbase(t2)->b_name->tp) return 0;
162:
163: return 1;
164: }
165: }
166:
167: return 0;
168: }
169:
170: int makeCM( Ptype t )
171: /* return 1 if the type is not a primitive type
172: * this will cause the generation of (t,0)
173: * note: ``t'' is guaranteed not to be 0
174: */
175: {
176: while ( t->base == TYPE )
177: t = Pbase(t)->b_name->tp;
178:
179: switch (t->base) {
180: case FLOAT:
181: case DOUBLE:
182: case LDOUBLE:
183: case CHAR:
184: case SHORT:
185: case INT:
186: case LONG:
187: case EOBJ:
188: return 0;
189: default:
190: return 1;
191: }
192: }
193:
194: static ret_seen = 0;
195:
196: Pstmt stmt::expand()
197: /*
198: copy the statements with the formal arguments replaced by ANAMES
199:
200: called once only per inline function
201: expand_tbl!=0 if the function should be transformed into an expression
202: and expand_tbl is the table for local variables
203: */
204: {
205: if (this == 0) error('i',"0->S::expand() for%n",expand_fn);
206:
207: if (memtbl) { /* check for static variables */
208: register Ptable t = memtbl;
209: register int i;
210: for (register Pname n = t->get_mem(i=1); n; n=t->get_mem(++i)) {
211: if (n->n_stclass == STATIC) {
212: if (n->tp->base == FCT) continue;
213: error('s',"cannot expand inlineF with static%n",n);
214: n->n_stclass = AUTO;
215: }
216: n->where.line = 0;
217: }
218: }
219:
220: if (expand_tbl) { /* make expression */
221: Pexpr ee;
222:
223: if (memtbl) { // temporaries
224: int i;
225: for (Pname n=memtbl->get_mem(i=1); n; n=memtbl->get_mem(++i)) {
226: //error('d',"block %n %k %d %d",n,base,memtbl->real_block == this,n->lex_level);
227: if (n->base!=NAME || n->tp==any_type) continue;
228:
229: if (base==BLOCK
230: && memtbl->real_block == this
231: && n->lex_level < 2
232: && (n->string[0]!='_' // promoted from called
233: // inlines
234: || n->string[1]!='_'
235: || n->string[2]!='X')
236: )
237: continue;
238:
239: if (memtbl != scope)
240: {
241: Pname nn = dcl_local(scope,n,expand_fn);
242: nn->base = NAME;
243: n->string = nn->string;
244: }
245: else if (n->tp->base!=FCT && n->tp->base!=OVERLOAD){
246: n->string = temp(n->string, expand_fn);
247: n->where.line = 0;
248: }
249: }
250: }
251:
252: switch (base) {
253: default:
254: error('s',"cannot expand inlineF%n with %kS in inline",expand_fn,base);
255: return Pstmt(dummy);
256:
257: case BLOCK:
258: if (s_list) {
259: ee = Pexpr(s_list->expand());
260: if (s) {
261: ee = new expr(CM, Pexpr(s->expand()), ee);
262: ee->tp = ee->e2->tp;
263: PERM(ee);
264: }
265: return Pstmt(ee);
266: }
267:
268: if (s) return s->expand();
269:
270: return Pstmt(zero);
271:
272: case PAIR:
273: ee = s2 ? Pexpr(s2->expand()) : 0;
274: ee = new expr(CM, s?Pexpr(s->expand()):0, ee);
275: ee->tp = ee->e2->tp;
276: if (s_list) {
277: ee = new expr(CM, ee, Pexpr(s_list->expand()));
278: ee->tp = ee->e2->tp;
279: }
280: PERM(ee);
281: return Pstmt(ee);
282:
283: case RETURN:
284: ret_seen = 1;
285: s_list = 0;
286: // return Pstmt(e ? e->expand() : zero);
287:
288: if (e == 0)
289: ee = zero;
290: else {
291: ee = e->expand();
292: Ptype tt = Pfct(expand_fn->tp)->returns;
293: if (tt == 0) tt = Pfct(expand_fn->tp)->returns;
294: if (tt!=ee->tp && ck_cast(tt,ee->tp)) ee = new cast(tt,ee);
295: }
296:
297: return Pstmt(ee);
298:
299: case SM:
300: if (e== 0 || e==dummy)
301: ee = zero;
302: else {
303: if (e->base == DEREF) e = e->e1;
304: ee = e->expand();
305: }
306: // no break;
307:
308: case ASM:
309: if (s_list) {
310: ee = new expr(CM, ee, (Pexpr)s_list->expand());
311: ee->tp = ee->e2->tp;
312: PERM(ee);
313: }
314: return (Pstmt)ee;
315:
316: case IF:
317: {
318: int ors = ret_seen;
319: ret_seen = 0;
320: Pexpr qq = new expr(QUEST,Pexpr(s->expand()),0);
321: int ret1 = ret_seen;
322: ret_seen = 0;
323:
324: qq->cond = e->expand();
325: qq->e2 = else_stmt ? Pexpr(else_stmt->expand()) : zero;
326: int ret2 = ret_seen;
327: if (ret1+ret2 && s_list) {
328: error('s',"cannot expand inlineF%n with S after \"return\"",expand_fn);
329: ret_seen = 0;
330: }
331: ret_seen += ors;
332:
333: // handle ``if (x) class_object_valued_expression;''
334:
335: Ptype t1 = qq->e1->tp;
336: Ptype t2 = qq->e2->tp;
337:
338: if (t1 && t1->base==FCT)
339: t1 = Pfct(t1)->s_returns ? Pfct(t1)->s_returns : Pfct(t1)->returns;
340:
341: if (t2 && t2->base==FCT)
342: t2 = Pfct(t2)->s_returns ? Pfct(t2)->s_returns : Pfct(t2)->returns;
343:
344: Pname c1 = t1?t1->is_cl_obj():0;
345: Pname c2 = t2?t2->is_cl_obj():0;
346:
347: int z1 = c1 && c1!=c2;
348: int z2 = c2 && c1!=c2;
349:
350: //error('d',"t1 %t t2 %t",t1,t2);
351: if (c1==0
352: && c2==0
353: && t1
354: && t2
355: && t2->check(t1,ASSIGN)
356: && t1->check(t2,ASSIGN)) {
357: z1 = makeCM( t1 );
358: z2 = makeCM( t2 );
359: if ((z1 && ret1) || (z2 && ret2))
360: error('s',"cannot expand inlineF with return in ifS");
361: }
362:
363: if (t1 && z1==0) {
364: // since zero is acceptable to all pointer types
365: // we need only ``fix'' z1 and z2 will take care
366: // of itself
367: z1 = t1->is_ptr_or_ref()
368: && t2
369: && t2->is_ptr_or_ref()
370: && t1->check(t2,0);
371: }
372:
373: if (z1) {
374: Pexpr v = (z2==0 && (t2->is_ptr_or_ref())) ? new cast(t2,zero) : zero;
375: qq->e1 = new expr(CM,qq->e1,v);
376: qq->e1->tp = qq->e1->e1->tp;
377: }
378:
379: if (z2) {
380: Pexpr v = (z1==0 && (t1->is_ptr_or_ref())) ? new cast(t1,zero) : zero;
381: qq->e2 = new expr(CM,qq->e2,v);
382: qq->e2->tp = qq->e2->e1->tp;
383: }
384:
385: if (s_list) {
386: qq = new expr(CM,qq,Pexpr(s_list->expand()));
387: qq->tp = qq->e2->tp;
388: }
389: else
390: qq->tp = qq->e1->tp;
391: PERM(qq);
392: return Pstmt(qq);
393: }
394: }
395: }
396:
397: where.line = 0;
398:
399: switch (base) {
400: default:
401: if (e) e = e->expand();
402: break;
403: case PAIR:
404: if (s2) s2 = s2->expand();
405: break;
406: case BLOCK:
407: break;
408: case FOR:
409: if (for_init) for_init = for_init->expand();
410: if (e2) e2 = e2->expand();
411: case ASM:
412: break;
413: // case LABEL:
414: // case GOTO:
415: case RETURN:
416: // case BREAK:
417: // case CONTINUE:
418: error('s',"cannot expand inlineF%n with %kS",expand_fn,base);
419: }
420:
421: if (s) s = s->expand();
422: if (s_list) s_list = s_list->expand();
423: PERM(this);
424: return this;
425: }
426:
427: Pexpr expr::expand()
428: {
429: if (this == 0) error('i',"E::expand(0)");
430:
431: switch (base) {
432: case NAME:
433: if (expand_tbl && Pname(this)->n_scope==FCT) {
434: Pname n = Pname(this);
435: char* s = n->string;
436: if (s[0]=='_' && s[1]=='_' && s[2]=='X') break;
437: Pname cn = expand_fn->n_table->t_name;
438: // n->string = temp(s,expand_fn->string,(cn)?cn->string:0);
439: n->string = temp(s,expand_fn);
440: }
441: case DUMMY:
442: case ICON:
443: case FCON:
444: case CCON:
445: case IVAL:
446: case FVAL:
447: case LVAL:
448: case STRING:
449: case ZERO:
450: case TEXT:
451: case ANAME:
452: case MDOT:
453: break;
454: case ICALL:
455: if (expand_tbl && e1==0) {
456: int ors = ret_seen;
457: ret_seen = 0;
458: Pname fn = il->fct_name;
459: Pfct f = Pfct(fn->tp);
460: if (f->f_expr==0
461: // f->returns==void_type
462: // && f->s_returns!=int_type
463: // && fn->n_oper!=CTOR
464: )
465: error('s',"cannot expand value-returning inline%n with call of non-value-returning inline%n",expand_fn,fn);
466: // else
467: // error("inline%n called before defined",fn);
468: ret_seen = ors;
469: }
470: break;
471: case SIZEOF:
472: case CAST:
473: if (tp2) PERM(tp2);
474: goto rrr;
475: case QUEST:
476: cond = cond->expand();
477: default:
478: if (e2) e2 = e2->expand();
479: case REF:
480: case DOT:
481: rrr:
482: if (e1) e1 = e1->expand();
483: break;
484: }
485:
486: switch (base) {
487: case CM:
488: case G_CM:
489: if (tp==0) tp=e2->tp;
490: }
491:
492: PERM(this);
493: return this;
494: }
495:
496: int nin;
497:
498: bit expr::not_simple()
499: /*
500: is a temporary variable needed to hold the value of this expression
501: as an argument for an inline expansion?
502: return 1; if side effect
503: return 2; if modifies expression
504: */
505: {
506: int s;
507: //error('d',"not_simple%k",base);
508: switch (base) {
509: default:
510: return 2;
511: case NAME:
512: if (nin==0 && Pname(this)->n_table==gtbl) return 2; // unsafe: aliasing
513: case ZERO:
514: case IVAL:
515: case FVAL:
516: case ICON:
517: case CCON:
518: case FCON:
519: case STRING:
520: return 0;
521: case MDOT:
522: return mem->not_simple();
523: case SIZEOF:
524: return (e1==0 || e1==dummy) ? 0 : e1->not_simple();
525: case G_ADDROF:
526: case ADDROF:
527: return e2->not_simple();
528: case CAST:
529: case DOT:
530: case REF:
531: return e1->not_simple();
532: case UMINUS:
533: case NOT:
534: case COMPL:
535: return e2->not_simple();
536: case DEREF:
537: s = e1->not_simple();
538: if (1<s) return 2;
539: if (e2==0) return s;
540: return s |= e2->not_simple();
541: case MUL:
542: case DIV:
543: case MOD:
544: case PLUS:
545: case MINUS:
546: case LS:
547: case RS:
548: case AND:
549: case OR:
550: case ER:
551: case LT:
552: case LE:
553: case GT:
554: case GE:
555: case EQ:
556: case NE:
557: case ANDAND:
558: case OROR:
559: case CM:
560: s = e1->not_simple();
561: if (1<s) return 2;
562: return s |= e2->not_simple();
563: case QUEST:
564: s = cond->not_simple();
565: if (1<s) return 2;
566: s |= e1->not_simple();
567: if (1<s) return 2;
568: return s |= e2->not_simple();
569: case ANAME:
570: if (curr_icall) {
571: Pname n = (Pname)this;
572: int argno = int(n->n_val);
573: for (Pin il=curr_icall; il; il=il->i_next)
574: if (n->n_table == il->i_table) goto aok;
575: goto bok;
576: aok:
577: return (il->i_args[argno].local) ? 0 : il->i_args[argno].arg->not_simple();
578: }
579: bok: error('i',"expand aname%n",this);
580: case G_CM:
581: case VALUE:
582: case NEW:
583: case GNEW:
584: case CALL:
585: case G_CALL:
586: case ICALL:
587: case ASSIGN:
588: case INCR:
589: case DECR:
590: case ASPLUS:
591: case ASMINUS:
592: case ASMUL:
593: case ASDIV:
594: case ASMOD:
595: case ASAND:
596: case ASOR:
597: case ASER:
598: case ASLS:
599: case ASRS:
600: return 2;
601: }
602: }
603:
604: extern void uninline(Pname fn);
605: //extern Pname new_fct;
606: //extern Pname del_fct;
607: extern Pstmt del_list;
608: extern Pstmt break_del_list;
609: extern Pstmt continue_del_list;
610: extern Pname curr_fct;
611: extern Pexpr init_list;
612:
613: extern Pname make_default_ctor(Pclass cl);
614: void expand_itor(Pclass cl)
615: {
616: //error('d',"expand_itor(%t)",cl);
617: Pexpr s2 = curr_expr;
618: Pstmt s5 = del_list;
619: Pstmt s6 = break_del_list;
620: Pstmt s7 = continue_del_list;
621: Pname s8 = curr_fct;
622: Pexpr s9 = init_list;
623: (void) cl->make_itor(1);
624: curr_expr = s2;
625: del_list = s5;
626: break_del_list = s6;
627: continue_del_list = s7;
628: curr_fct = s8;
629: init_list = s9;
630: }
631: /*
632: extern Pname make_default_dtor(Pclass cl);
633: void expand_dtor(Pclass cl)
634: {
635: //error('d',"expand_itor(%t)",cl);
636: Pexpr s2 = curr_expr;
637: Pstmt s5 = del_list;
638: Pstmt s6 = break_del_list;
639: Pstmt s7 = continue_del_list;
640: Pname s8 = curr_fct;
641: Pexpr s9 = init_list;
642: (void) make_default_dtor(cl);
643: curr_expr = s2;
644: del_list = s5;
645: break_del_list = s6;
646: continue_del_list = s7;
647: curr_fct = s8;
648: init_list = s9;
649: }
650:
651:
652: void expand_ictor(Pclass cl)
653: {
654: //error('d',"expand_itor(%t)",cl);
655: Pexpr s2 = curr_expr;
656: Pstmt s5 = del_list;
657: Pstmt s6 = break_del_list;
658: Pstmt s7 = continue_del_list;
659: Pname s8 = curr_fct;
660: Pexpr s9 = init_list;
661: (void) make_default_ctor(cl);
662: curr_expr = s2;
663: del_list = s5;
664: break_del_list = s6;
665: continue_del_list = s7;
666: curr_fct = s8;
667: init_list = s9;
668: }
669: */
670: Pexpr fct::expand(Pname fn, Ptable scope, Pexpr ll)
671: /*
672: expand call to (previously defined) inline function in "scope"
673: with the argument list "ll"
674: (1) declare variables in "scope"
675: (2) initialize argument variables
676: (3) link to body
677: */
678: {
679: Scope = scope;
680: //error('d',"expand%s() body %d f_expr %d inline %d",fn->string,body,f_expr,f_inline);
681: if (f_inline == ITOR) {
682: Pexpr s1 = last_expanded;
683: expand_itor(memof);
684: last_expanded = s1;
685: this = Pfct(fn->tp);
686: if (f_inline==0 && f_imeasure) {
687: uninline(fn);
688: return 0;
689: }
690: }
691: /*
692: if (f_inline == ICTOR) {
693: Pexpr s1 = last_expanded;
694: expand_ictor(memof);
695: last_expanded = s1;
696: this = Pfct(fn->tp);
697: if (f_inline==0 && f_imeasure) {
698: uninline(fn);
699: return 0;
700: }
701: }
702: if (f_inline == IDTOR) {
703: Pexpr s1 = last_expanded;
704: expand_dtor(memof);
705: last_expanded = s1;
706: this = Pfct(fn->tp);
707: if (f_inline==0 && f_imeasure) {
708: uninline(fn);
709: return 0;
710: }
711: }
712: */
713: //error('d',"expand %n body %d f_expr %d defined %d",fn,body,f_expr,defined);
714: //error('d',"inline %d scope %d %d",f_inline,Pfct(fn->tp)->body->memtbl,scope);
715: if ((body==0 && f_expr==0) // before defined
716: || ((defined&SIMPLIFIED)==0) // before simplified
717: || (Pfct(fn->tp)->body->memtbl==scope) // while defining
718: || (f_inline>1) // recursive call
719: // || (last_expanded && last_expanded==curr_expr) // twice in an expression
720: ) { // so don't expand
721: if (warning_opt) error('w',"cannot inline%n in thisE",fn);
722: if (fn->n_addr_taken++==0) fn->dcl_print(0);
723: return 0;
724: }
725:
726: if (fn->n_oper==CTOR) {
727: Pclass cl = Pclass(fn->n_table->t_name->tp);
728: if (cl->c_body == 3) cl->print_all_vtbls(cl);
729: }
730:
731: Pin il = new iline;
732: Pexpr ic = new texpr(ICALL,0,0);
733: int ns = 0;
734: for (Pname an = f_args; an; an=an->n_list) ns++;
735: il->fct_name = fn;
736: il->i_args = new ia[il->i_slots = ns];
737: ic->il = il;
738: ic->tp = s_returns ? s_returns : returns;
739: // Pname at = (f_this) ? f_this : (f_result) ? f_result : argtype;
740: Pname at = f_args;
741:
742: f_inline++;
743:
744: if (at) il->i_table = at->n_table;
745: int i = 0;
746: int not_simple = 0; /* is a temporary argument needed? */
747:
748: for (Pname n=at; n; n=n->n_list, i++) {
749: /* check formal/actual argument pairs
750: and generate temporaries as necessary
751: */
752: if (ll == 0) error('i',"F::expand(%n):AX",fn);
753: Pexpr ee;
754:
755: if (ll->base == ELIST) {
756: ee = ll->e1;
757: ll = ll->e2;
758: }
759: else {
760: ee = ll;
761: ll = 0;
762: }
763:
764: /* could be avoided when expanding into a block */
765: il->i_args[i].local = 0;
766: int s ;
767:
768: // try to protect agains aliasing through pointers and references
769: for (Pname m=at; m; m=m->n_list) {
770: Pptr p;
771: if (n!=m) {
772: // if ((p=m->tp->is_ptr()) || (p=m->tp->is_ref()))
773: if (p=m->tp->is_ptr_or_ref())
774: if (p->check(n->tp,0)==0 || p->typ->check(n->tp,0)==0) goto zxc;
775:
776: }
777: }
778:
779: if (n->n_assigned_to==FUDGE111
780: && ee!=zero
781: && ee->not_simple()==0)
782: ;
783: else if (n->n_addr_taken || n->n_assigned_to)
784: goto zxc;
785: else if (s=ee->not_simple()) {
786: if (/*n->n_used==0 // n_used not set for ``this''
787: || */1<s
788: || 1<n->n_used ) { // not safe
789: zxc:
790: if (last_expanded && last_expanded==curr_expr) {
791: f_inline--;
792: delete il->i_args;
793: delete il;
794: if (fn->n_addr_taken++==0) fn->dcl_print(0);
795: return 0;
796: }
797: //error('d',"zxc %n %t ee %d %t",n,n->tp,ee->base,ee->tp);
798: Pname nn = dcl_local(scope,n,fn);
799: nn->base = NAME;
800: il->i_args[i].local = nn;
801: ++not_simple;
802: // if (nn->tp->is_ref()
803: // && ee->tp
804: // && ee->tp->is_ptr_or_ref()==0) ee = ee->address();
805: }
806: }
807:
808: il->i_args[i].arg = ee;
809: il->i_args[i].tp = n->tp;
810: }
811:
812: Ptable tbl = body->memtbl;
813: if (f_expr) { // generate comma expression
814:
815: char loc_var = 0;
816:
817: /* look for local variables needing declaration: */
818: for (n=tbl->get_mem(i=1); n; n=tbl->get_mem(++i) ) {
819: //error('d',"n %n %d",n,n->base);
820: //error('d',"loc %n %d %d %d",n,n->n_used,n->n_assigned_to,n->n_addr_taken);
821: if (n->base==NAME // don't re-declare the args
822: && (n->tp->base!=FCT && n->tp->base!=OVERLOAD)
823: && (n->n_used || n->n_assigned_to || n->n_addr_taken)) {
824: if (last_expanded && last_expanded==curr_expr) {
825: f_inline--;
826: delete il->i_args;
827: delete il;
828: if (fn->n_addr_taken++==0) fn->dcl_print(0);
829: return 0;
830: }
831: Pname nn = dcl_local(scope,n,fn);
832: nn->base = NAME;
833: n->string = nn->string;
834:
835: loc_var++;
836: }
837: }
838:
839: if (i /*not_simple*/ || loc_var) last_expanded = curr_expr;
840:
841: Pexpr ex;
842: if (not_simple) {
843: Pexpr etail = ex = new expr(CM,0,0);
844: for (i=0; i<il->i_slots; i++) {
845: Pname n = il->i_args[i].local;
846: if (n == 0) continue;
847: Pexpr e = il->i_args[i].arg;
848: // if used assign
849: // otherwise (e.g. unused argument)
850: // simply evaluate for sideeffects
851: if (n->n_used
852: || n->n_assigned_to
853: || n->n_addr_taken) {
854: Pexpr mptr_assign(Pexpr n, Pexpr in);
855: Pptr p1 = n->tp->is_ptr();
856: Pptr p2 = e->tp ? e->tp->is_ptr() : 0;
857: if (p1 && p1->memof && p1!=p2) {
858: switch (e->base) {
859: case CM:
860: case G_CM:
861: e->e2 = mptr_assign(n,e->e2);
862: break;
863: default:
864: e = mptr_assign(n,e);
865: }
866: etail->e1 = e;
867: }
868: else
869: etail->e1 = new expr(ASSIGN,n,e);
870: }
871: else
872: etail->e1 = e;
873: if (--not_simple)
874: etail = etail->e2 = new expr(CM,0,0);
875: else
876: break;
877: }
878: etail->e2 = f_expr;
879: }
880: else
881: ex = f_expr;
882: ic->e1 = ex;
883: }
884: else { // generate block:
885: for (n=tbl->get_mem(i=1); n; n=tbl->get_mem(++i) ) {
886: // mangle local names
887: if (n->base==NAME
888: && (n->n_used || n->n_assigned_to || n->n_addr_taken)) {
889: // Pname cn = fn->n_table->t_name;
890: // n->string = temp(n->string,fn->string,(cn)?cn->string:0);
891: n->string = temp(n->string,fn);
892: }
893: }
894: Pstmt ss;
895: if (not_simple) {
896: last_expanded = curr_expr;
897: Pstmt st = new estmt(SM,curloc,0,0);
898: st->where.line = 0;
899: Pstmt stail = st;
900: for (i=0; i<il->i_slots; i++) {
901: Pname n = il->i_args[i].local;
902: if (n == 0) continue;
903: Pexpr e = il->i_args[i].arg;
904: Pptr p1 = n->tp->is_ptr();
905: Pptr p2 = e->tp->is_ptr();
906: Pexpr mptr_assign(Pexpr n, Pexpr in);
907: if (p1 && p1->memof && p1!=p2) {
908: switch (e->base) {
909: case CM:
910: case G_CM:
911: e->e2 = mptr_assign(n,e->e2);
912: break;
913: default:
914: e = mptr_assign(n,e);
915: }
916: stail->e = e;
917: }
918: else
919: stail->e = new expr(ASSIGN,n,e);
920: if (--not_simple) {
921: stail = stail->s_list = new estmt(SM,curloc,0,0);
922: stail->where.line = 0;
923: }
924: else
925: break;
926: }
927: stail->s_list = body;
928: ss = new block(curloc,0,st);
929: ss->where.line = 0;
930: }
931: else
932: ss = body;
933: ic->e2 = Pexpr(ss);
934: }
935:
936: f_inline--;
937: return ic;
938: }
939:
940: /* ODI Notes
941:
942: change address sensitive name to be address-insensitive
943: that way cfront output can be diffed to regress the compiler.
944: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.