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