![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to expr3.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 expr3.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / ooptcfront |
1.1 root 1: /*ident "@(#)ctrans:src/expr3.c 1.3.5.31" */
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: expr3.c:
11:
12: type check function calls, casts, and explicit coercions
13:
14: ************************************************************************/
15:
16: #include "cfront.h"
17: #include "size.h"
18:
19: int pr_dominate(Ptype t1, Ptype t2)
20: /*
21: */
22: {
23: Pname cn1 = t1->is_cl_obj();
24: Pname cn2 = t2->is_cl_obj();
25: //error('d',"pr_dominate(%t,%t)",t1,t2);
26:
27: if (cn1==0 || cn2==0) {
28: Ptype p1 = t1->is_ptr();
29: Ptype p2 = t2->is_ptr();
30: if (p1 && p2) { // pointers
31: cn1 = Pptr(p1)->typ->is_cl_obj();
32: cn2 = Pptr(p2)->typ->is_cl_obj();
33: if (cn1==0 || cn2==0) return 0;
34: }
35: else {
36: p1 = t1->is_ref();
37: p2 = t2->is_ref();
38: if (p1 && p2) { // references
39: cn1 = Pptr(p1)->typ->is_cl_obj();
40: cn2 = Pptr(p2)->typ->is_cl_obj();
41: if (cn1==0 || cn2==0) return 0;
42: }
43: // else if (p1 && cn2) {
44: // cn1 = Pptr(p1)->typ->is_cl_obj();
45: // }
46: else
47: return 0; // not the same and not classes
48: }
49: }
50: Pclass c1 = Pclass(cn1->tp);
51: Pclass c2 = Pclass(cn2->tp);
52: //error('d'," c1 : c2 %d; c2 : c1 %d",c1->has_base(c2),c2->has_base(c1));
53: if (c1->has_base(c2)) return 1;
54: if (c2->has_base(c1)) return 2;
55: }
56:
57: static exact1(Pname,Ptype);
58: static exact2(Pname,Ptype);
59: static exact3(Pname,Ptype);
60:
61: static Pname user_dominate(Pname n1, Pname n2)
62: {
63: Pfct f1 = Pfct(n1->tp);
64: Pfct f2 = Pfct(n2->tp);
65:
66: Pname a1 = f1->argtype;
67: Pname a2 = f2->argtype;
68: //error('d',"user_dominate: %n %t %t",n1,f1,f2);
69:
70: int k1 = f1->nargs_known!=ELLIPSIS;
71: int k2 = f2->nargs_known!=ELLIPSIS;
72:
73: if (k1 && k2==0) return n1;
74: if (k2 && k1==0) return n2;
75:
76: for(; a1 && a2; a1 = a1->n_list, a2 = a2->n_list) {
77: Ptype t1 = a1->tp;
78: Ptype t2 = a2->tp;
79: }
80:
81: if (a1) return n1;
82: if (a2) return n2;
83:
84: return 0;
85: }
86:
87: Pname dominate(Pname n1, Pname n2, Pexpr arg, int const_obj, int level)
88: /*
89: the two functions n1 and n2 can each respond to a call using
90: standard conversions. Does the one dominate the other in the
91: sense that all its arguments are identical to the other or
92: classes defived from the class of the corresponding argument
93: of the other.
94:
95: If so return it, otherwise return 0;
96: */
97: {
98: Pname res = 0;
99:
100: Pfct f1 = Pfct(n1->tp);
101: Pfct f2 = Pfct(n2->tp);
102:
103: Pname a1 = f1->argtype;
104: Pname a2 = f2->argtype;
105: Pexpr e = arg;
106: //error('d',"dominate: %n %t %t e %d",n1,f1,f2,e);
107:
108: if (e == 0) {
109: if (const_obj) {
110: if (f1->f_const && f2->f_const==0) return n1;
111: if (f2->f_const && f1->f_const==0) return n2;
112: }
113: else {
114: if (f1->f_const==0 && f2->f_const) return n1;
115: if (f2->f_const==0 && f1->f_const) return n2;
116: }
117: return 0;
118: }
119:
120: for(; a1 && a2 && e; a1 = a1->n_list, a2 = a2->n_list, e = e->e2) {
121: Ptype t1 = a1->tp;
122: Ptype t2 = a2->tp;
123: Ptype at = e->e1->tp;
124: //error('d',"t1 %t t2 %t at %t",t1,t2,at);
125: if (t1==t2 || t1->check(t2,0)==0) continue;
126: Pptr r1 = t1->is_ref();
127: Pptr r2 = t2->is_ref();
128: //error('d',"const_problem %t %t %t %d",t1,t2,at,const_problem);
129: if (const_problem) { // t1 and t1 differs only in const
130: Pname rr;
131: if (at->check(t1,0)==0 && const_problem==0) {
132: if (t1->is_ptr())
133: rr = n1;
134: else
135: goto nc;
136: }
137: else if (at->check(t2,0)==0 && const_problem==0) {
138: if (t2->is_ptr())
139: rr = n2;
140: else
141: goto nc;
142: }
143: else if (r1 && r1->typ->check(at,0)==0 && const_problem==0)
144: rr = n1;
145: else if (r2 && r2->typ->check(at,0)==0 && const_problem==0)
146: rr = n2;
147: else
148: return 0;
149:
150: if (res && res!=rr) return 0; // mutual dominace
151: res = rr;
152: continue; // identical
153: }
154: nc:
155: if (r2 && (t1==r2 || t1->check(r2->typ,0)==0)) continue;
156: if (r1 && (t2==r1 || t2->check(r1->typ,0)==0)) continue;
157: int r = pr_dominate(t1,t2);
158: //error('d',"pr1 %d",r);
159: if (r) {
160: Pname rr = r==1?n1:n2;
161: if (res && res!=rr) return 0; // mutual dominace
162: res = rr;
163: continue;
164: }
165:
166: r = pr_dominate(t1,at);
167: //error('d',"pr2 %d",r);
168: if (r==2) {
169: if (res && res!=n1) return 0; // mutual dominace
170: res = n1;
171: r = pr_dominate(t2,at);
172: if (r==2) return 0; // mutual dominace
173: continue;
174: }
175:
176: r = pr_dominate(t2,at);
177: //error('d',"pr3 %d",r);
178: if (r==2) {
179: if (res && res!=n2) return 0; // mutual dominace
180: res = n2;
181: continue;
182: }
183:
184: Pname rr = 0;
185: if (t1==at || exact1(a1,at))
186: rr = n1;
187: else if (t2==at || exact1(a2,at))
188: rr = n2;
189: else if (1<level) { // try integral promotion
190: if (exact2(a1,at))
191: rr = n1;
192: if (exact2(a2,at)) {
193: if (rr) return 0;
194: rr = n2;
195: }
196: }
197: else if (1<level) { // try standard conversions
198: if (exact3(a1,at))
199: rr = n1;
200: if (exact3(a2,at)) {
201: if (rr) return 0;
202: rr = n2;
203: }
204: }
205: if (rr) {
206: if (res && res!=rr) return 0; // mutual dominance
207: res = rr;
208: continue;
209: }
210: }
211: //if (a1==0 && a2 && a2->n_initializer==0) return 0; // wrong number of arguments
212: //if (a2==0 && a1 && a1->n_initializer==0) return 0; // wrong number of arguments
213:
214: if (e) {
215: //error('d',"more args %t a1 %t a2 %t",e->e1->tp,a1?a1->tp:0,a2?a2->tp:0);
216: int k1 = f1->nargs_known!=ELLIPSIS;
217: int k2 = f2->nargs_known!=ELLIPSIS;
218: if (a1 && a1->tp->check(e->e1->tp,ASSIGN)==0) return n1;
219: if (a2 && a2->tp->check(e->e1->tp,ASSIGN)==0) return n2;
220: if (k1 && k2) return 0;
221: }
222:
223: if (a1==0 && a2 && a2->n_initializer==0) return 0;
224: if (a2==0 && a1 && a1->n_initializer==0) return 0;
225: if (res==0)
226: if (const_obj) {
227: if (f1->f_const && f2->f_const==0) return n1;
228: if (f2->f_const && f1->f_const==0) return n2;
229: }
230: else {
231: if (f1->f_const==0 && f2->f_const) return n1;
232: if (f2->f_const==0 && f1->f_const) return n2;
233: }
234: //error('d'," -> %n %t",res,res?res->tp:0);
235: return res;
236: }
237:
238: Pname Ntmp;
239:
240: static refd; // initialization routine called by ref_init, do not apply itor
241: extern loc no_where;
242:
243: Pname make_tmp(char c, Ptype t, Ptable tbl)
244: {
245: Pname tn = tbl->t_name;
246:
247: if (tn && tn->tp) error('s',"defaultA too complicated");
248:
249: if (Ntmp == 0) {
250: Pname cn = t->is_cl_obj();
251: if (cn && Pclass(cn->tp)->has_dtor()) Ntmp = cn;
252: }
253:
254: //error('d',"tbl %d cstmt %d %d sti %d",tbl,Cstmt,Cstmt?Cstmt->memtbl:0,sti_tbl);
255: if (Cstmt) { // make Cstmt into a block
256: if (Cstmt->memtbl == 0) Cstmt->memtbl = new table(4,tbl,0);
257: tbl = Cstmt->memtbl;
258: }
259: else if (tbl == gtbl) {
260: if (sti_tbl == 0) sti_tbl = new table(8,gtbl,0);
261: tbl = sti_tbl;
262: }
263:
264: Pname tmpx = new name(make_name(c));
265: tmpx->where = no_where;
266: tmpx->tp = t;
267: (void) t->tsizeof();
268: if ( t->base == COBJ ) {
269: Pclass cl = Pclass(Pbase(t)->b_name->tp);
270: // error( 'd', "cl: %s %d", cl->string, cl->lex_level );
271: if ( cl->lex_level ) tmpx->lex_level = cl->lex_level;
272: }
273: Pname tmp = tmpx->dcl(tbl,ARG); // ARG => no init
274: //error('d',"make_tmp %n %t",tmp,t);
275: delete tmpx;
276: tmp->n_scope = FCT;
277: return tmp;
278: }
279:
280: Pexpr init_tmp(Pname tmp, Pexpr init, Ptable tbl)
281: {
282: Pname cn = tmp->tp->is_cl_obj();
283: Pname ct = cn ? Pclass(cn->tp)->has_itor() : 0;
284:
285: tmp->n_assigned_to = 1;
286: //error('d',"init_tmp %n ct %n refd %d",tmp,ct,refd);
287: if (ct) { // must initialize
288: if (refd) {
289: //error('d',"'orrible %k",init->e1->base);
290: switch (init->e1->base) { // 'orrible 'ack
291: case NAME:
292: case REF:
293: case DEREF:
294: if (init->e1->tp->is_ptr())
295: init = init->e1;
296: else
297: init = new expr(G_CM,init,init->e1->address());
298:
299: }
300: if (ct->tp->base == OVERLOAD) ct = Pgen(ct->tp)->fct_list->f; // first fct
301: tbl = 0;
302: }
303: return call_ctor(tbl,tmp,ct,init,DOT);
304: }
305: Pexpr ass = new expr(ASSIGN,tmp,init); // no ctor: can assign
306: ass->tp = tmp->tp;
307: return ass;
308: }
309: /*
310: int exact0(Pname nn, Ptype at)
311: // return 1 if
312: // exact match
313:
314: {
315: if (nn == 0) return 0; //known==ELLIPSIS;
316: Ptype nt = nn->tp;
317: if (at == nt) return 1;
318: //error('d',"exact0 %d",nt->check(at,0));
319: return nt->check(at,0)==0;
320: }
321: */
322:
323: int exact3(Pname nn, Ptype at)
324: /*
325: return 1 if
326: match with standard conversions
327: */
328: {
329: if (nn == 0) return 0; //known==ELLIPSIS;
330: Ptype nt = nn->tp;
331: if (at == nt) return 1;
332:
333: //error('d',"exact3 %d",nt->check(at,ASSIGN));
334: return nt->check(at,ASSIGN)==0;
335: }
336:
337: int exact1(Pname nn, Ptype at)
338: /*
339: return 1 if
340: exact match with
341: T <-> const T
342: X -> X&
343: T* -> const T*
344: T* -> T*const
345: taken into account
346: */
347: {
348: if (nn == 0) return 0;//known==ELLIPSIS;
349: Ptype nt = nn->tp;
350: if (at == nt) return 1;
351:
352: //error('d',"exact1 nt %t at %t",nt,at);
353: if (nt->check(at,0)) {
354: //error('d',"nt %t at %t cp %d",nt,at,const_problem);
355: if (const_problem) return 1; // handle T <-> const T
356:
357: Pptr rt = nt->is_ref(); //handle X -> X&
358: if (rt && (at->check(Pptr(rt)->typ,0)==0 || const_problem)) return 1;
359:
360: Pptr art = at->is_ptr();
361: if (rt && art) return 0; // ptrs do not match refs
362:
363: // handle T* -> const T* and
364: // T* -> T*const
365: if (rt || (rt = nt->is_ptr())) {
366: if (art == 0) art = at->is_ref();
367: if (art) {
368: //error('d',"art %t %t",art->typ,rt->typ);
369: if (art->typ->check(rt->typ,0)) {
370: if (const_problem) return 1;
371: }
372: else // T* -> T*const
373: return 1;
374: }
375: }
376: return 0;
377: }
378: return 1;
379: }
380:
381: Pexpr Ninit; // default argument used;
382: int Nstd; // standard coercion used (derived* =>base* or int=>long or ...)
383:
384: bit exact_match(Pname n, Pexpr arg)
385: /*
386: look for an exact match between "n" and the argument list "arg"
387: This function goes through three stages:
388: (1) exact match (no coercions at all)
389: (2) do integral promotions and float->double and re-try exact match
390: (3) try for unique standard conversions
391:
392: */
393: {
394: Pfct f = Pfct(n->tp);
395: register Pexpr e;
396: register Pname nn;
397:
398: //error('d',"exact_match(%n) %t",n,n->tp);
399:
400: for (e=arg, nn=f->argtype; e; e=e->e2, nn=nn->n_list) {
401: Pexpr a = e->e1;
402: Ptype at = a->tp;
403: if (at->base == ANY) return 0;
404: if (at->base == ZTYPE) at = int_type;
405: if (exact1(nn,at)==0) return 0;
406: }
407:
408: //error('d',"exact %d -> %d",nn,nn?nn->n_initializer!=0:1);
409: if (nn) {
410: Ninit = nn->n_initializer;
411: return Ninit!=0;
412: }
413:
414: //error('d',"return 1");
415: return 1; // exact match without any promotions
416: }
417:
418: int exact2(Pname nn, Ptype at)
419: /*
420: return 1 if
421: do integral promotion and float->double on at, then match
422: */
423: {
424: //error('d',"exact2 nt %t at %t",nn?nn->tp:0,at);
425: atat:
426: switch (at->base) {
427: case TYPE:
428: at = Pbase(at)->b_name->tp;
429: goto atat;
430: case EOBJ:
431: at = Penum(Pbase(at)->b_name->tp)->e_type;
432: break;
433: case ZTYPE:
434: at = int_type;
435: break;
436: case CHAR:
437: case SHORT:
438: at = (Pbase(at)->b_unsigned && at->tsizeof()==SZ_INT) ? uint_type : int_type;
439: break;
440: case FLOAT:
441: at = double_type;
442: }
443:
444: if (nn == 0) return 0;//known==ELLIPSIS;
445: Ptype nt = nn->tp;
446: //error('d'," exact2 nt %t at %t",nt,at);
447: if (at == nt) return 1;
448: if (nt->check(at,0)) {
449: if (const_problem) return 1;
450:
451: Pptr rt = nt->is_ref(); // handle X -> X&
452: if (rt && (at->check(Pptr(rt)->typ,0)==0 || const_problem)) return 1;
453:
454: Pptr art = at->is_ptr();
455: if (rt && art) return 0; // ptrs do not match refs
456:
457: // handle T* -> const T* and
458: // T* -> T*const
459: if (rt || (rt = nt->is_ptr())) {
460: if (art == 0) art = at->is_ref();
461: if (art) {
462: if (art->typ->check(rt->typ,0)) {
463: if (const_problem) return 1;
464: }
465: else // T* -> T*const
466: return 1;
467: }
468: }
469: return 0;
470: }
471: return 1;
472: }
473:
474: bit prom_match(Pname n, Pexpr arg)
475: /*
476: look for an exact match between "n" and the argument list "arg"
477: using integral promotions and float->double
478:
479: */
480: {
481: Pfct f = Pfct(n->tp);
482: register Pexpr e;
483: register Pname nn;
484:
485: //error('d',"prom_match(%n) %t",n,n->tp);
486:
487: for (e=arg, nn=f->argtype; e; e=e->e2, nn=nn->n_list) {
488: Pexpr a = e->e1;
489: Ptype at = a->tp;
490: if (at->base == ANY) return 0;
491:
492: if (exact2(nn,at)==0) return 0;
493: }
494:
495: if (nn) {
496: Ninit = nn->n_initializer;
497: return Ninit!=0;
498: }
499:
500: return 1; // exact match with promotions
501: }
502:
503: bit std_match(Pname n, Pexpr arg)
504: /*
505: look for an exact match between "n" and the argument list "arg"
506: using standard conversions
507:
508: */
509: {
510: Pfct f = Pfct(n->tp);
511: register Pexpr e;
512: register Pname nn;
513:
514: //error('d',"std_match(%n) %t",n,n->tp);
515:
516: for (e=arg, nn=f->argtype; e; e=e->e2, nn=nn->n_list) {
517: Pexpr a = e->e1;
518: Ptype at = a->tp;
519:
520: if (at->base == ANY) return 0;
521: if (nn == 0) return 0;//f->nargs_known==ELLIPSIS;
522:
523: Ptype nt = nn->tp;
524: tptp:
525: switch (nt->base) {
526: case TYPE:
527: nt = Pbase(nt)->b_name->tp;
528: goto tptp;
529: case RPTR:
530: if (at==zero_type && Pptr(nt)->typ->is_ptr()==0) return 0; //break;
531: if (nt->check(at,COERCE)) {
532: Pptr pt = at->addrof();
533: nt->base = PTR; // handle derived classes
534: if (nt->check(pt,COERCE)) {
535: nt->base = RPTR;
536: delete pt;
537: return 0;
538: }
539: nt->base = RPTR;
540: delete pt;
541: }
542: break;
543: default:
544: // if (nt->check(at,COERCE)) return 0;
545: switch (at->base) {
546: default:
547: if (nt->check(at,COERCE)) return 0;
548: break;
549: case OVERLOAD:
550: {
551: // the actual argument is an overloaded function
552: // we'll try each instance until one matches
553: register Plist gl;
554: int no_match = 1;
555:
556: for (gl = Pgen(at)->fct_list; gl; gl=gl->l) {
557: if (nt->check(gl->f->tp,COERCE)==0) {
558: no_match = 0;
559: break;
560: }
561: }
562:
563: if ( no_match ) return 0;
564: }
565: } // end at->base switch
566:
567: }
568: }
569:
570: if (nn) {
571: Ninit = nn->n_initializer;
572: return Ninit!=0;
573: }
574:
575: return 1;
576: }
577:
578: Pname Ncoerce;
579: int ref_cast;
580:
581: bit can_coerce(Ptype t1, Ptype t2)
582: /* return number of possible coercions of t2 into t1,
583: Ncoerce holds a coercion function (not constructor), if found
584: */
585: {
586: int zz = 0;
587: Ncoerce = 0;
588: if (t2->base == ANY) return 0;
589: //error('d',"can_coerce t1 %t t2 %t",t1,t2);
590:
591: tptp:
592: switch (t1->base) {
593: case TYPE:
594: t1 = Pbase(t1)->b_name->tp;
595: goto tptp;
596: case RPTR:
597: rloop:
598: switch (t2->base) {
599: case TYPE:
600: t2 = Pbase(t2)->b_name->tp;
601: goto rloop;
602: // case VEC:
603: // case PTR:
604: // case RPTR:
605: // if (t1->check(t2,COERCE) == 0) return 1;
606: default:
607: { Ptype tt2 = t2->addrof();
608: if (t1->check(tt2,COERCE) == 0) return 1;
609: if (ref_cast) break;//return 0; // (T&): no coercions
610: // except operator T&()
611: Ptype tt1 = Pptr(t1)->typ;
612: while (tt1->base==TYPE) tt1 = Pbase(tt1)->b_name->tp;
613: int bc = Pbase(tt1)->b_const;
614: Pbase(tt1)->b_const = 0;
615: int i = can_coerce(tt1,t2);
616: Pbase(tt1)->b_const = bc;
617: if (i) return i;
618: zz = 1;
619: }
620: }
621: }
622:
623: Pname c1 = t1->is_cl_obj();
624: Pname c2 = t2->is_cl_obj();
625: int val = 0;
626: if (ref_cast || zz) goto oper_coerce;
627: if (c1) {
628: Pclass cl = Pclass(c1->tp);
629: if (c2 && c2->tp==cl) return 1;
630: // A more comprehensive test for template classes
631: if (c2 && (Pclass(c1->tp)->same_class(Pclass(c2->tp)))) return 1 ;
632:
633: /* look for constructor
634: with one argument
635: or with default for second argument
636: of acceptable type
637: */
638: Pname ctor = cl->has_ctor();
639: if (ctor == 0) goto oper_coerce;
640: register Pfct f = Pfct(ctor->tp);
641: //error('d',"ctor %n f %t",ctor,f);
642: switch (f->base) {
643: case FCT:
644: switch (f->nargs) {
645: case 1:
646: one:
647: { Ptype tt = f->argtype->tp;
648: //error('d',"tt %t t2 %t -> %d cp %d",tt,t2,tt->check(t2,COERCE),const_problem);
649: if (tt->check(t2,COERCE)==0)
650: val = 1;
651: else if (const_problem) {
652: Pptr p1 = tt->is_ptr_or_ref();
653: if (p1==0 || p1->typ->tconst()) val = 1;
654: }
655: if (tt = tt->is_ref()) {
656: Pptr pt = t2->addrof(); // handle derived classed
657: tt->base = PTR;
658: if (tt->check(pt,COERCE) == 0) val = 1;
659: tt->base = RPTR;
660: delete pt;
661: }
662: goto oper_coerce;
663: }
664: default:
665: if (f->argtype->n_list->n_initializer) goto one;
666: case 0:
667: goto oper_coerce;
668: }
669: case OVERLOAD:
670: { register Plist gl;
671:
672: for (gl=Pgen(f)->fct_list; gl; gl=gl->l) { // look for match
673: Pname nn = gl->f;
674: Pfct ff = Pfct(nn->tp);
675:
676: switch (ff->nargs) {
677: case 0:
678: break;
679: case 1:
680: over_one:
681: { Ptype tt = ff->argtype->tp;
682: //error('d',"over one %t %t -> %d %d",tt,t2,tt->check(t2,COERCE),const_problem);
683: if (tt->check(t2,COERCE)==0)
684: val = 1;
685: else if (const_problem) {
686: Pptr p1 = tt->is_ptr_or_ref();
687: if (p1==0 || p1->typ->tconst()) val = 1;
688: }
689: if (tt=tt->is_ref()) {
690: Pptr pt = t2->addrof(); // handle derived classed
691: tt->base = PTR;
692: if (tt->check(pt,COERCE) == 0) {
693: tt->base = RPTR;
694: delete pt;
695: val = 1;
696: goto oper_coerce;
697: }
698: tt->base = RPTR;
699: delete pt;
700: }
701: break;
702: }
703: default:
704: if (ff->argtype->n_list->n_initializer) goto over_one;
705: }
706: }
707: goto oper_coerce;
708: }
709: default:
710: error('i',"cannot_coerce(%k)\n",f->base);
711: }
712: }
713:
714: oper_coerce:
715: //error('d',"oper_coerce %d",val);
716: if (c2) {
717: Pclass cl = Pclass(c2->tp);
718: int std = 0;
719: int oval = val;
720: extern Pname conv_dominates(Pname,Pname);
721: for (Pname ox, on=cl->conv; on; on=ox) {
722: Pfct f = Pfct(on->tp);
723: ox = on->n_list;
724: Nstd = 0;
725: //error('d',"on %n -> %d",on,t1->check(f->returns,COERCE));
726: if (t1->check(f->returns,COERCE) == 0) {
727: if (Nstd==0) { // forget solutions involving standard conversions
728: Pname old = Ncoerce;
729: if (std) { // forget
730: val = oval+1;
731: std = 0;
732: Ncoerce = on;
733: }
734: else if (Ncoerce == 0) {
735: // val = 1;
736: val++;
737: Ncoerce = on;
738: }
739: else if ((Ncoerce = conv_dominates(Ncoerce,on))==0) {
740: if (val == 1) {
741: //error('d',"val==1 on %n old %n",on,old);
742: Ptype ton = Pfct(on->tp)->returns;
743: Ptype tco = Pfct(old->tp)->returns;
744: if (t1->check(ton,0)==0)
745: ;
746: else if (t1->check(tco,0)==0)
747: on = old;
748: else
749: val++;
750: }
751: else
752: val++;
753: Ncoerce = on;
754: }
755: }
756: else { // take note only if no exact match seen
757: if (Ncoerce==0 || on->tp->check(Ncoerce->tp,0)) {
758: if (val==0 || std) {
759:
760: if (Ncoerce) Ncoerce = conv_dominates(Ncoerce,on);
761: if (Ncoerce == 0) {
762: Ncoerce = on;
763: val++;
764: std = 1;
765: }
766: }
767: }
768: }
769: }
770:
771: }
772: }
773: //error('d',"val %d",val);
774: if (val) return val;
775: if (c1 && Pclass(c1->tp)->has_itor()) return 0;
776: //error('d',"%t->check(%t) -> %d",t1,t2,t1->check(t2,COERCE));
777: if (t1->check(t2,COERCE)) return 0;
778: return 1;
779: }
780:
781: int gen_coerce(Pname n, Pexpr arg)
782: /*
783: look to see if the argument list "arg" can be coerced into a call of "n"
784: 1: it can
785: 0: it cannot or it can be done in more than one way
786: */
787: {
788: Pfct f = (Pfct) n->tp;
789: register Pexpr e;
790: register Pname nn;
791:
792: //error('d',"gen_coerce(%n,%d) %t",n,arg,n->tp);
793: for (e=arg, nn=f->argtype; e; e=e->e2, nn=nn->n_list) {
794: if (nn == 0) return f->nargs_known==ELLIPSIS;
795: Pexpr a = e->e1;
796: Ptype at = a->tp;
797: int i = can_coerce(nn->tp,at);
798: //error('d',"i %d",i);
799: if (i != 1) return 0;
800: }
801: if (nn && nn->n_initializer==0) return 0;
802: return 1;
803: }
804:
805:
806: Pname Nover;
807: // int Nover_coerce;
808:
809: int over_call(Pname n, Pexpr arg)
810: /*
811: return 4 if n(arg) can be performed without coercion of arg
812: return 3 if n(arg) can be performed only with promotion coercion of arg
813: return 2 if n(arg) can be performed only with standard coercion of arg
814: return 1 if n(arg) can be performed only with user defined coercion of arg
815: return 0 if n(arg) is an error
816: Nover is the function found, if any
817: Nstd is the number of standard coercions used
818: */
819: {
820: register Plist gl;
821: Pgen g = Pgen(n->tp);
822: if (arg && arg->base!= ELIST) error('i',"ALX");
823:
824: //error('d',"over_call(%n) %k",n,n->tp->base);
825: extern suppress_error;
826: suppress_error = 1;
827: // Nover_coerce = 0;
828: Nstd = 0;
829: switch (g->base) {
830: default: error('i',"over_call(%t)\n",g);
831: case OVERLOAD: break;
832: case FCT:
833: Nover = n;
834: Ninit = 0;
835: if (exact_match(n,arg)) {suppress_error = 0; return 4;}
836: if (prom_match(n,arg)) {suppress_error = 0; return 3;}
837: if (std_match(n,arg) && Ninit==0) {suppress_error = 0; return 2;}
838: Nstd = 0;
839: suppress_error = 0;
840: return gen_coerce(n,arg);
841: }
842:
843: Pname exact = 0;
844: int no_exact = 0;
845: int ret = 0;
846: Pname nret;
847: for (gl=g->fct_list; gl; gl=gl->l) { /* look for match */
848: Nover = gl->f;
849: Ninit = 0;
850: Nstd = 0;
851: if (exact_match(Nover,arg)) {suppress_error = 0; return 4;} // no coercion
852: // if (prom_match(Nover,arg)) return 3; // only promotion
853: // if (std_match(Nover,arg) && Ninit==0) return 2; // only built-in conversion
854: if (ret<3 && prom_match(Nover,arg)) {
855: nret = Nover;
856: ret = 3;
857: }
858: if (ret<2 && std_match(Nover,arg) && Ninit==0) {
859: nret = Nover;
860: ret = 2;
861: }
862: }
863:
864: suppress_error = 0;
865: if (ret) {
866: Nover = nret;
867: return ret;
868: }
869:
870: Nover = 0;
871: for (gl=g->fct_list; gl; gl=gl->l) { /* look for coercion */
872: Pname nn = gl->f;
873: if (gen_coerce(nn,arg)) {
874: Nover = nn;
875: return 1;
876: }
877: }
878: return 0;
879:
880: }
881:
882: Ptype expr::call_fct(Ptable tbl)
883: /*
884: check "this" call:
885: e1(e2)
886: e1->typ() and e2->typ() has been done
887: */
888: {
889: Pfct f;
890: Pname fn;
891: int x;
892: int k;
893: Pname nn;
894: Pexpr e;
895: Ptype t;
896: Pexpr arg = e2;
897: Ptype t1 = e1?e1->tp:0;
898: int argno;
899: Pexpr etail = 0;
900: Pname no_virt = 0; // set if explicit qualifier was used: c::f()
901: Pname chk = 0; // set if visibility check is needed
902: // that is if function name might have been
903: // found without use of find_name()
904: int const_obj = 0;
905:
906: if (t1 == any_type) return any_type;
907:
908: switch (base) {
909: case CALL:
910: case G_CALL: break;
911: default: error('i',"call_fct(%k)",base);
912: }
913:
914: //error('d',"call %d %k %n arg %d",this,e1->base,e1->base==NAME?e1:0,arg);
915: if (t1 == 0) error('i',"call_fct(e1=%d,e1->tp=%t)",e1,t1);
916: if (arg && arg->base!=ELIST) error('i',"badAL%d%k",arg,arg->base);
917:
918: switch (e1->base) {
919: case NAME:
920: fn = Pname(e1);
921: //error('d',"name %n %k",fn,fn->n_oper);
922: switch (fn->n_oper) {
923: case 0:
924: case CTOR:
925: case DTOR:
926: case TYPE:
927: case NEW:
928: case DELETE:
929: break;
930: default: // real operator: check for operator+(1,2);
931: if (arg == 0) break;
932: Pexpr a = arg->e1; // first operand
933:
934: if (Pfct(fn->tp)->memof // obj.operator(1) is OK
935: || a->tp->is_cl_obj()
936: || a->tp->is_ref()) break;
937: a = arg->e2;
938: if (a == 0) // unary
939: error("%k of basicT",fn->n_oper);
940: else { // binary
941: a = a->e1; // second operand
942: if (a->tp->is_cl_obj() || a->tp->is_ref()) break;
943: error("%k of basicTs",fn->n_oper);
944: }
945: break;
946: }
947: break;
948: case REF:
949: case DOT:
950: no_virt = Pname(e1->n_initializer);
951: e1->n_initializer = 0;
952: // const_obj = (e1&&e1->e1)?e1->e1->tp->tconst():0;
953: if (e1 && e1->e1) {
954: Ptype t = e1->e1->tp;
955: Pptr tt = t->is_ptr_or_ref();
956: //error('d',"t %t tt %t",t,tt);
957: const_obj = (tt ? tt->typ : t)->tconst();
958: }
959: case MDOT:
960: { Pexpr n = e1->mem;
961: lxlx:
962: switch (n->base) {
963: case MDOT:
964: // reverse mdot (see expr::print())
965: // p->a.b() => (&p->a)->b() => b(&p->a)
966: // or p->a->b() => (p->a)->b() => b(p->a)
967: // or oo.a.b() => (&oo.a)->b() => b(&oo.a)
968: // or oo.a->b() => (oo.a)->b() => b(oo.a)
969: {
970: Pexpr r = e1;
971: Pexpr p = r->e1;
972: for (Pexpr m = r->mem; m->base==MDOT; m = r->mem) {
973: p = new mdot(m->string2,p);
974: p->i1 = m->i1+2;
975: p->tp = p->mem->tp;
976: r->mem = m->mem;
977: r->e1 = p;
978: }
979: }
980: case REF:
981: case DOT:
982: n = n->mem;
983: goto lxlx;
984: case NAME:
985: break;
986: default:
987: error('i',"ref %k",n->base);
988: }
989: fn = Pname(n);
990: //error('d',"mem %n",fn);
991: break;
992: }
993: case MEMPTR:
994: default:
995: fn = 0;
996: };
997:
998: lll:
999: //error('d',"lll: %t %k",t1,t1->base);
1000: switch (t1->base) {
1001: case TYPE:
1002: t1 = Pbase(t1)->b_name->tp;
1003: goto lll;
1004:
1005: case PTR: // pf() allowed as shorthand for (*pf)()
1006: switch (Pptr(t1)->typ->base) {
1007: case FCT:
1008: case OVERLOAD:
1009: if (Pptr(t1)->memof) error("O missing in call throughP toMF");
1010: t1 = Pptr(t1)->typ;
1011: fn = 0;
1012: goto lll;
1013: }
1014:
1015: default:
1016: if (fn)
1017: error("call of%n;%n is a%t",fn,fn,e1->tp);
1018: else
1019: error("call of%kE ofT%t",e1->base,e1->tp);
1020:
1021: case ANY:
1022: return any_type;
1023:
1024: case OVERLOAD:
1025: { register Plist gl;
1026: Pgen g = Pgen(t1);
1027: Pname found = 0;
1028: Pname exact = 0;
1029: int no_exact = 0;
1030:
1031: for (gl=g->fct_list; gl; gl=gl->l) { // look for exact match
1032: register Pname nn = gl->f;
1033: if (exact_match(nn,arg)) {
1034: //error('d',"found exact %n %t",nn,nn->tp);
1035: if (found) {
1036: // check if one fct dominates the other
1037: Pname d = dominate(found,nn,arg,const_obj,0);
1038: if (d)
1039: nn = d;
1040: else
1041: error("two exact matches for%n:%t and%t",nn,nn->tp,found->tp);
1042: }
1043: found = nn;
1044: }
1045: }
1046: //error('d',"found exact2 %n",found);
1047: if (found) goto fnd;
1048:
1049: for (gl=g->fct_list; gl; gl=gl->l) { // look for exact match
1050: register Pname nn = gl->f;
1051:
1052: if (prom_match(nn,arg)) {
1053: if (found) {
1054: // check if one fct dominates the other
1055: Pname d = dominate(found,nn,arg,const_obj,1);
1056: if (d)
1057: nn = d;
1058: else
1059: error("two exact matches (after integral promotions) for%n:%t and%t",nn,nn->tp,found->tp);
1060: }
1061: found = nn;
1062: }
1063: }
1064: //error('d',"found exact2 %n",found);
1065: if (found) goto fnd;
1066:
1067: // for (gl=g->fct_list; gl; gl=gl->l) { // look for exact match
1068: // register Pname nn = gl->f;
1069: //
1070: // if (exact_match(nn,arg) || prom_match(nn,arg)) {
1071: // found = nn;
1072: // goto fnd;
1073: // }
1074: // }
1075:
1076: Pname mvec[10];
1077: for (gl=g->fct_list; gl; gl=gl->l) { // look for match
1078: // with standard conversion
1079: register Pname nn = gl->f;
1080: Ninit = 0;
1081: Nstd = 0;
1082: if (std_match(nn,arg)) {
1083: // if (Nstd == 0) {
1084: // found = nn;
1085: // goto fnd;
1086: // }
1087: if (exact) {
1088: // check if one fct dominates the other
1089: Pname d = dominate(exact,nn,arg,const_obj,2);
1090: if (d == 0) {
1091: mvec[no_exact++] = nn;
1092: // no_exact++;
1093: // error("two standard conversions possible for%n: %t and %t",fn,exact->tp,nn->tp);
1094: }
1095: else
1096: exact = d;
1097: }
1098: else
1099: exact = nn;
1100: }
1101:
1102: }
1103:
1104: //error('d',"excact %n",exact);
1105: if (exact) {
1106: if (no_exact) {
1107: while (no_exact) {
1108: Pname d = dominate(exact,mvec[--no_exact],arg,const_obj,2);
1109: if (d)
1110: exact = d;
1111: else
1112: error("two standard conversions possible for%n: %t and %t",fn,exact->tp,mvec[no_exact]->tp);
1113: }
1114:
1115: }
1116: //error('d',"found exact3 %n",found);
1117: found = exact;
1118: goto fnd;
1119: }
1120:
1121: for (gl=g->fct_list; gl; gl=gl->l) { /* look for coercion */
1122: register Pname nn = gl->f;
1123: if (gen_coerce(nn,arg)) {
1124: //error('d',"user2 %n %t",nn,nn->tp);
1125: if (found) {
1126: // check if one fct dominates the other
1127: Pname d = dominate(found,nn,arg,const_obj,3);
1128: if (d == 0) d = user_dominate(found,nn);
1129: if (d == 0) {
1130: error("ambiguousA for%n: %t and %t",fn,found->tp,nn->tp);
1131: goto fnd;
1132: }
1133: else
1134: found = d;
1135: }
1136: else
1137: found = nn;
1138: }
1139: }
1140:
1141: fnd:
1142: //error('d',"fnd %t",found?found->tp:0);
1143: if (found) {
1144: chk = fn = found;
1145: f = Pfct(fn->tp);
1146: }
1147: else {
1148: error("badAL for%n (no match against any %n)",fn,fn);
1149: return any_type;
1150: }
1151: break;
1152: }
1153: case FCT:
1154: f = Pfct(t1);
1155: if (fn) {
1156: switch (fn->n_oper) {
1157: case CTOR:
1158: case TYPE:
1159: chk = fn;
1160: }
1161: }
1162: }
1163:
1164: //error('d',"chk %n",chk);
1165: if (chk) {
1166: Ptype t = 0;
1167: Pexpr ee = e1->e1;
1168:
1169: switch (e1->base) {
1170: case REF: // ptr->chk()
1171: if (ee == 0) { // 0->x() fudge handling new x()
1172: check_visibility(chk,no_virt,Pclass(chk->n_table->t_name->tp),tbl,cc->nof);
1173: break;
1174: };
1175: t = ee->tp;
1176: while(t->base==TYPE) t = Pbase(t)->b_name->tp;
1177: t = Pptr(t)->typ;
1178: break;
1179: case DOT: // obj.chk()
1180: t = ee->tp;
1181: }
1182:
1183: Pname cn = t?t->is_cl_obj():0;
1184: Pclass cl = cn?Pclass(cn->tp):0; // class of ``this'' for chk
1185:
1186: if (cl) {
1187: if (chk->n_oper==CTOR
1188: && chk->n_protect
1189: && cc->nof
1190: && cc->nof->n_oper==CTOR)
1191: // BUG: cannot handle protected base
1192: // class constructor
1193: ;
1194: else {
1195: check_visibility(chk,no_virt,cl,tbl,cc->nof);
1196: }
1197: }
1198: }
1199:
1200: if (fn && f->f_result==0) {
1201: // protect against class cn; cn f(); ... class cn { cn(cn&); ... };
1202: make_res(f);
1203: //error('d',"returns %t",f->returns);
1204: f->returns->tsizeof(); // make sure it is declared
1205: }
1206:
1207: //error('d',"fn %n %t printed %d",fn,fn?fn->tp:0,fn?fn->n_dcl_printed:0);
1208: if (fn && fn->n_dcl_printed==0) {
1209: if (f->f_inline==0 && f->f_imeasure) {
1210: extern void uninline(Pname fn);
1211: uninline(fn);
1212: }
1213:
1214: // ensure printout of class declaration:
1215: for (Pname nn=f->argtype; nn; nn=nn->n_list)
1216: if (nn->tp->is_cl_obj()) (void) nn->tp->tsizeof();
1217:
1218: fn->dcl_print(0);
1219: }
1220:
1221: if (no_virt && f->f_static==0) {
1222: if (e1->base==REF || e1->base==DOT) e1->n_initializer = fn;
1223: }
1224: else
1225: fct_name = fn;
1226: //error('d',"fn %n %t %d %d",fn,f,f->f_this,f->f_static);
1227: if (f->f_this) { //SSS call of non-static memberfunction
1228: switch (e1->base) {
1229: case MEMPTR:
1230: case REF:
1231: case DOT:
1232: break;
1233: default:
1234: error("O orP missing for%n ofT %t",fct_name,f);
1235: }
1236: }
1237: else if (fn) { //SSS call of static function
1238: sss:
1239: switch (e1->base) {
1240: case REF:
1241: case DOT:
1242: e1 = e1->mem;
1243: goto sss;
1244: }
1245: }
1246:
1247: if (fn) fn->use(); // a patch: ctors are sometimes not use()d
1248:
1249: if (f->f_const==0
1250: && (fn==0 || (fn->n_oper!=CTOR && fn->n_oper!=DTOR))) { //CCC
1251: Pexpr ee = e1->e1;
1252: if (ee) {
1253: Ptype tt = ee->tp;
1254: switch (e1->base) {
1255: case REF:
1256: { Pptr p = tt?tt->is_ptr():0;
1257: if (p && p->typ->tconst())
1258: error(strict_opt?0:'w',"non-constMF%n called for constO",fn);
1259: // is really an error, but only warn to help transition
1260: break;
1261: }
1262: case DOT:
1263: if (tt && tt->tconst())
1264: error(strict_opt?0:'w',"non-constMF%n called for constO",fn);
1265: // is really an error, but only warn to help transition
1266: }
1267: }
1268: }
1269:
1270: t = f->returns;
1271: x = f->nargs;
1272: k = f->nargs_known;
1273:
1274: e = arg;
1275: if (k == 0) goto rlab;
1276:
1277: for (nn=f->argtype, argno=1; e||nn; nn=nn->n_list, e=etail->e2, argno++) {
1278: Pexpr a;
1279:
1280: if (e) {
1281: a = e->e1;
1282: etail = e;
1283:
1284: if (nn) { /* type check */
1285: Ptype t1 = nn->tp;
1286: //error('d',"argtp %t etp %t a %k",t1,a->tp,a->base);
1287:
1288: lx:
1289: switch (t1->base) {
1290: case TYPE:
1291: t1 = Pbase(t1)->b_name->tp;
1292: goto lx;
1293: case RPTR:
1294: { Ptype pt = Pptr(t1)->typ;
1295: if (pt->base != FCT ||
1296: ( pt->base == FCT &&
1297: pt->check(a->tp,0)))
1298: a = ref_init(Pptr(nn->tp),a,tbl);
1299: goto cbcb;
1300: }
1301: case COBJ:
1302: if (a->base!=G_CM
1303: || nn->tp->check(a->tp,ASSIGN))
1304: a = class_init(0,t1,a,tbl);
1305: if (nn->n_xref) {
1306: // (temp.ctor(arg),&arg)
1307: a = a->address();
1308: }
1309: else {
1310: // defend against:
1311: // int f(X); ... X(X&);
1312: Pname cln = Pbase(t1)->b_name;
1313: if (cln && Pclass(cln->tp)->has_itor()) {
1314: // mark X(X&) arguments
1315: nn->n_xref = 1;
1316: a = a->address();
1317: }
1318: }
1319: cbcb:
1320: //error('d',"cbcb: a %d %k %t",a->base,a->base,a->tp);
1321: if (a->base==G_CM) {
1322: if (a->e1->base==DEREF) a->e1 = a->e1->e2; // (*e1,e2) => (e1,e2)
1323: //error('d'," a %d %k",a->e1->base,a->e1->base);
1324: if (a->e1->base==G_CALL
1325: && Pname(a->e1->fct_name)
1326: && Pname(a->e1->fct_name)->n_oper==CTOR
1327: && (a->e2->base==G_ADDROF || a->e2->base==ADDROF)) {
1328: a = a->e1; // (ctor(&tmp),&tmp) => ctor(&tmp)
1329: //error('d',"tmp %k %n",a->e2->base,a->e2->e2);
1330: goto cccc;
1331: }
1332: else if (a->e2->base==G_ADDROF
1333: && a->e2->e2->base==NAME) {
1334: cccc:
1335: //error('d',"cccc: a %d %k %t",a->base,a->base,a->tp);
1336: if (t1->base==RPTR
1337: && Pptr(t1)->typ->tconst()==0) { // temporary used
1338: if (warning_opt)
1339: error('w',"temporary used for non-const%tA",nn->tp);
1340: else {
1341: Ptype atp = a->tp;
1342: if (atp==void_type
1343: && a->base==G_CALL
1344: && a->e1->tp->base==FCT)
1345: atp = Pfct(a->e1->tp)->s_returns;
1346:
1347: Ptype tt = t1->is_ref();
1348: //error('d',"tt %t atp %t",tt,atp);
1349: if (tt) {
1350: if (Pptr(tt)->typ->tsizeof()!=atp->tsizeof()) { // sliced
1351: Ptype aat = atp->is_ptr_or_ref();
1352: if (aat==0
1353: || Pptr(tt)->typ->tsizeof()!=Pptr(aat)->typ->tsizeof())
1354: error('w',"temporary used for non-const%tA",nn->tp);
1355: }
1356: }
1357: else if (t1->tsizeof()!=atp->tsizeof()) // sliced
1358: error('w',"temporary used for non-const%tA",nn->tp);
1359: }
1360:
1361: // if (warning_opt // blabber
1362: // || t1->tsizeof()!=a->tp->tsizeof())) // sliced
1363: // error('w',"temporary used for non-const%tA",nn->tp);
1364:
1365: }
1366: }
1367: }
1368: e->e1 = a;
1369: break;
1370: case ANY:
1371: goto rlab;
1372: case PTR:
1373: {// Pexpr x = a;
1374: e->e1/* = a */= ptr_init(Pptr(t1),a,tbl);
1375: // if (x==a || x==a->e2) goto def; // needs checking
1376: if (Pchecked == 0) goto def;
1377: break;
1378: }
1379: // e->e1 = a = ptr_init(Pptr(t1),a,tbl);
1380: // goto def;
1381: case CHAR:
1382: case SHORT:
1383: case INT:
1384: // if (a->base==ICON && a->tp==long_type)
1385: // error('w',"long constantA for%n,%kX",fn,t1->base);
1386: { Ptype t = a->tp;
1387: csi:
1388: switch (t->base) {
1389: case TYPE:
1390: t = Pbase(t)->b_name->tp; goto csi;
1391: case LONG:
1392: case FLOAT:
1393: case DOUBLE:
1394: case LDOUBLE:
1395: error('w',"%t passed as %t",a->tp,t1);
1396: }
1397: }
1398: // no break
1399: case LONG:
1400: if (Pbase(t1)->b_unsigned
1401: && a->base==UMINUS
1402: && a->e2->base==ICON)
1403: error('w',"negativeA for%n, unsignedX",fn);
1404: default:
1405: def:
1406: { Pexpr x = try_to_coerce(t1,a,"argument",tbl);
1407: //error('d',"x %d t1 %t nn %t a1 %t",x,t1,nn->tp,a->tp);
1408: if (x)
1409: e->e1 = x;
1410: else if (nn->tp->check(a->tp,ARG)) {
1411: error("badA %dT for%n:%t (%tX)",argno,fn,a->tp,nn->tp);
1412: return any_type;
1413: }
1414: }
1415: }
1416:
1417: Pexpr tt = e->e1;
1418: while ( tt->base == CAST )
1419: tt = tt->e1;
1420: if ( tt->base == ILIST )
1421: e->e1 = tt;
1422:
1423: if (e->e1->base == ILIST) {
1424: extern Pbase mptr_type;
1425: Pexpr mptr_assign(Pexpr, Pexpr);
1426: // memptr constant
1427: // f({1,2,f}) ==> memptr t; f((t={1,2,f},t))
1428: Pname temp = make_tmp('A',mptr_type,tbl);
1429: e->e1 = mptr_assign(temp,e->e1);
1430: e->e1 = a = new expr(G_CM,e->e1,temp);
1431: a->tp = temp->tp;
1432: }
1433:
1434: }
1435: else {
1436: if (k != ELLIPSIS) {
1437: error("unexpected %dA for%n",argno,fn);
1438: return any_type;
1439: }
1440: goto rlab;
1441: }
1442: }
1443: else { /* default argument? */
1444: a = nn->n_initializer;
1445: if (a == 0) {
1446: error("A %d ofT%tX for%n",argno,nn->tp,fn);
1447: return any_type;
1448: }
1449: if (a->base == ILIST) {
1450: extern Pbase mptr_type;
1451: Pexpr mptr_assign(Pexpr, Pexpr);
1452: // memptr constant
1453: // f({1,2,f}) ==> memptr t; f((t={1,2,f},t))
1454: Pname temp = make_tmp('A',mptr_type,tbl);
1455: a = mptr_assign(temp,a);
1456: a = new expr(G_CM,a,temp);
1457: a->tp = temp->tp;
1458: }
1459: a->permanent = 2; // ought not be necessary, but it is
1460: e = new expr(ELIST,a,0);
1461: if (etail)
1462: etail->e2 = e;
1463: else
1464: e2 = e;
1465: etail = e;
1466: }
1467: }
1468:
1469: rlab:
1470: //error('d',"rlab fct_name %n %t",fct_name,fct_name?fct_name->tp:0);
1471: for (; e; e = e->e2) { // unchecked arguments
1472: Pexpr a = e->e1;
1473: Pname cn;
1474:
1475: if (a->base==NAME && a->tp->base==FCT) {
1476: // function name that escaped the type system:
1477: // update use count
1478: a->lval(ADDROF);
1479: }
1480: else if (cn = a->tp->is_cl_obj()) {
1481: Pclass cl = Pclass(cn->tp);
1482: if (cl->has_ctor() || cl->memtbl->look("__as",0)/*cl->has_oper(ASSIGN)*/)
1483: error("O ofC%t withK or = copied",cl);
1484: }
1485: else if (a->tp->is_ref())
1486: e->e1 = a->contents();
1487: }
1488:
1489: if (f->f_result) { // f(args) => (f(&temp,args),temp)
1490: Pname tn = make_tmp('R',f->returns,tbl);
1491: e2 = new expr(ELIST,tn->address(),e2);
1492: //error('d',"result %n",fn);
1493: Pexpr ee = new expr(0,0,0);
1494: *ee = *this;
1495: base = G_CM; // (f(&temp,args),temp)
1496: e1 = ee;
1497: e2 = tn;
1498: tp = tn->tp;
1499: }
1500:
1501: return t;
1502: }
1503:
1504: Pexpr ref_init(Pptr p, Pexpr init, Ptable tbl)
1505: /*
1506: initialize the "p" with the "init"
1507: remember to call ptr_init to ensure that pointers to second bases
1508: are handled correctly.
1509: */
1510: {
1511: register Ptype it = init->tp;
1512: Pptr px = p;
1513: while (px->base == TYPE) px = Pptr(Pbase(px)->b_name->tp);
1514: Ptype p1 = px->typ;
1515: Pname c1 = p1->is_cl_obj();
1516: //error('d',"ref_init: p %t, p1 %t, px %t, init->tp %t",p,p1,px,it);
1517:
1518: if (init->base == ILIST) error("IrL as RIr");
1519:
1520: if (init->base==NAME
1521: && Pname(init)->n_scope==ARG
1522: && init->tp->base==FLOAT)
1523: error('w',"initializing a float& with floatA is non-portable");
1524:
1525: Ptype itb = it;
1526: while(itb->base == TYPE) itb = Pbase(itb)->b_name->tp;
1527: { Ptype tt = itb->addrof();
1528: px->base = PTR; // allow &x for y& when y : public x
1529: // but not &char for int&
1530: int x = px->check(tt,COERCE);
1531: if(const_problem) x = 0; /* handled here */
1532: if (x == 0) { //CCC type is fine check for constness:
1533: if (init->tp->tconst()
1534: && vec_const==0
1535: && fct_const==0) {
1536: // not ``it''
1537: if (init->base == ELIST) init = init->e1;
1538: if (px->typ->tconst() == 0) error("R to constO");
1539: px->base = RPTR;
1540: // if we have a const lvalue we can still pass its address
1541: extern ignore_const;
1542: ignore_const++;
1543: if (init->lval(0)) {
1544: init->lval(ADDROF); // force output
1545: ignore_const--;
1546: //error('d',"in1 %t",init->tp);
1547: return ptr_init(px,init->address(),tbl);//return init->address();
1548: }
1549: ignore_const--;
1550: goto xxx;
1551: }
1552: px->base = RPTR;
1553: if (init->lval(0)) { // can pass the address // no temporary needed
1554: init->lval(ADDROF); // force output
1555: //error('d',"px %t init %t init %t",px,init->tp,init->tp);
1556: return ptr_init(px,init->address(),tbl);
1557: }
1558: goto xxx;
1559: }
1560:
1561: px->base = RPTR;
1562: }
1563:
1564: //error('d',"c1 %n",c1);
1565: if (c1) { // assigning to a const X & is fine
1566: ref_cast++;
1567: Pexpr x = try_to_coerce(p,init,"reference initialization",tbl);
1568: ref_cast--;
1569: if (x) {
1570: init = x;
1571: goto xxx;
1572: }
1573: Ptype p1b = p1;
1574: while (p1b->base==TYPE) p1b = Pbase(p1b)->b_name->tp;
1575: int bc = Pbase(p1b)->b_const;
1576: Pbase(p1b)->b_const = 0;
1577: refd = 1; /* disable itor */
1578: Pexpr a = class_init(0,p1,init,tbl);
1579: Pbase(p1b)->b_const = bc;
1580: refd = 0;
1581: if (a==init && init->tp!=any_type) goto xxx;
1582: //error('d',"ri a %d %k",a->base,a->base);
1583: switch (a->base) {
1584: case G_CALL:
1585: // case CM:
1586: // case G_CM:
1587: init = a;
1588: goto xxx;
1589: }
1590: a = a->address();
1591: //error('d',"ri2 a %d %k",a->base,a->base);
1592: a = ptr_init(px,a,tbl);
1593: //error('d',"ri3 a %d %k",a->base,a->base);
1594: return a;
1595: // return ptr_init(px,a->address(),tbl);//a->address();
1596: }
1597:
1598: //error('d',"p1 %t it %t",p1,it);
1599: /* NOTE: in this region, several uses of "it" were left even though
1600: the resolution of it to its basetype was removed above.
1601: Since these are type checks, it seems a a bad idea to ignore signed/unsigned
1602: and related items. --benson */
1603: if (p1->check(it,0)) {
1604:
1605: if (p1->check(it,ASSIGN) == 0) {
1606: // if (p1->is_ptr()) // check for base* = derived*
1607: // goto xxx;
1608:
1609: // things like ``double& rr = 1;'' temporary needed
1610: // warn in case of ``slightly wrong lvalue'', e.g.
1611: // int i; double& r = i;
1612: if (init->lval(0) && p1->tconst()==0) error('w',"conversion of lvalue needed: temporary used toI reference");
1613: goto def;
1614: }
1615:
1616: Pexpr x = try_to_coerce(p1,init,"reference",tbl); // x==init
1617: if (x==0) x = try_to_coerce(px,init,"reference",tbl); // x&=init
1618: if (x) {
1619: init = x;
1620: goto def;
1621: }
1622:
1623: error("badIrT:%t (%tX)",it,p);
1624: if (init->base != NAME) init->tp = any_type;
1625: return init;
1626: }
1627:
1628: xxx: /*
1629: here comes the test of a ``fundamental theorem'':
1630: a structure valued expression is
1631: (1) an lvalue of type T (possibly const)
1632: or (2) the result of a function (a _result if X(X&) is defined)
1633: or (3) a * or [] or ? or , expression
1634: */
1635: //error('d',"xxx %k %d %t",init->base,init->base,init->tp);
1636:
1637: switch (init->base) {
1638: case NAME:
1639: case DEREF:
1640: case REF:
1641: case DOT: // init => &init
1642: if (it->tconst() && vec_const==0 && fct_const==0) goto def;
1643: init->lval(ADDROF);
1644: if (vec_const) return init;
1645: if (fct_const && p1->is_ptr()) goto def; // fptr& = fct
1646: // no break
1647: case CM:
1648: case G_CM: // & (f(&temp), temp)
1649: return ptr_init(px,init->address(),tbl);//init->address();
1650: default:
1651: def:
1652: {
1653: //error('d',"def: init->tp %t p1 %t",init->tp,p1);
1654: if (tbl == gtbl) error("Ir for staticR not an lvalue");
1655:
1656: Pname tcl = p1->is_cl_obj ();
1657: if(tcl && Pclass(tcl->tp)->c_abstract)
1658: error("a temporary is needed for a parameter, but the argument type is abstract class %t.", tcl->tp);
1659:
1660: Pname n = make_tmp('I',p1,tbl);
1661: Pexpr a;
1662: Pname ic = init->tp->is_cl_obj();
1663:
1664: if (p1->tconst()==0
1665: && (init->tp->tconst() && vec_const==0 && fct_const==0)
1666: && p1->check(it,ASSIGN)==0)
1667: error('w',"constIr: temporary used toI reference");
1668:
1669: switch (p1->base) {
1670: case INT:
1671: case CHAR:
1672: case SHORT:
1673: switch (it->base) {
1674: case LONG:
1675: case FLOAT:
1676: case DOUBLE:
1677: case LDOUBLE:
1678: error('w',"%t assigned to %t inRIr",it,p1);
1679: }
1680: }
1681:
1682: if (ic!=c1 && Pclass(ic->tp) != Pclass(c1->tp)) {
1683: // derived class1 => must cast: ``it Ix; (Ix=init,(p)&Ix);''
1684: n->tp = init->tp;
1685: a = ptr_init(px,n->address(),tbl);//n->address();
1686: PERM(p);
1687: a = new texpr(CAST,p,a);
1688: a->tp = p;
1689: }
1690: else
1691: a = n->address();
1692:
1693: refd = 1;
1694: Pexpr as = init_tmp(n,init,tbl);
1695: refd = 0;
1696: a = new expr(G_CM,as,a);
1697: a->tp = a->e2->tp;
1698: return a;
1699: }
1700: }
1701: }
1702:
1703: Pexpr class_init(Pexpr nn, Ptype tt, Pexpr init, Ptable tbl)
1704: /*
1705: initialize "nn" of type "tt" with "init"
1706: if nn==0 make a temporary,
1707: nn may not be a name
1708: */
1709: {
1710: if (init == dummy) return 0;
1711: //error('d',"class_init %t with %t init %k refd %d",tt,init->tp,init->base,refd);
1712: Pname c1 = tt->is_cl_obj();
1713:
1714: if (init == 0) {
1715: error("emptyIr");
1716: return dummy;
1717: }
1718:
1719: if (c1) {
1720: Pclass cl = Pclass(c1->tp);
1721: Pname c2 = init->tp->is_cl_obj();
1722:
1723: if (c1!=c2 || (refd==0 && cl->has_itor())) {
1724: /* really ought to make a temp if refd,
1725: but ref_init can do that
1726: */
1727: int i = can_coerce(tt,init->tp);
1728: //error('d',"i %d nn %n",i,nn);
1729: switch (i) {
1730: default:
1731: error("%d ways of making a%n from a%t",i,c1,init->tp);
1732: init->tp = any_type;
1733: return init;
1734: case 0:
1735: if (c2 && Pclass(c2->tp)->has_base(cl)) {
1736: init = init->address();
1737: Pexpr x = cast_cptr(cl,init,tbl,0);
1738:
1739: if (x == init) {
1740: Ptype pt = tt->addrof();
1741: PERM(pt);
1742: x = new cast(pt,init);
1743: }
1744:
1745: return x->contents();
1746: }
1747: error("cannot make a%n from a%t",c1,init->tp);
1748: init->tp = any_type;
1749: return init;
1750: case 1:
1751: //error('d',"ncoerce %n %k %d",Ncoerce,init->base,init->base);
1752: if (Ncoerce == 0) {
1753: Pexpr a = new expr(ELIST,init,0);
1754: a = new texpr(VALUE,tt,a);
1755: a->e2 = nn;
1756: // return a->typ(tbl);
1757: a = a->typ(tbl);
1758: //error('d',"ci a %k %d %t",a->base,a->base,a->tp);
1759: return a;
1760: }
1761:
1762: switch (init->base) {
1763: case CM:
1764: case G_CM: //ddd
1765: case NAME: /* init.coerce() */
1766: /* *ref */ case DEREF:
1767: { Pref r = new ref(DOT,init,Ncoerce);
1768: Pexpr rr = r->typ(tbl);
1769: init = new expr(G_CALL,rr,0);
1770: init->fct_name = Ncoerce;
1771: break;
1772: }
1773: default: // (temp=init,temp.coerce())
1774: { Pname tmp = make_tmp('U',init->tp,tbl);
1775: int x = refd;
1776: refd = 0; // ??
1777: Pexpr ass = init_tmp(tmp,init,tbl);
1778: refd = x;
1779: Pref r = new ref(DOT,tmp,Ncoerce);
1780: Pexpr rr = r->typ(tbl);
1781: Pexpr c = new expr(G_CALL,rr,0);
1782: c->fct_name = Ncoerce;
1783: c = c->typ(tbl);
1784: init = new expr(CM,ass,c);
1785: init->tp = c->tp;
1786: if (refd) { // &f() => (t=f(), &t)
1787: Pname tmp2 = make_tmp('L',c->tp,tbl);
1788: ass = init_tmp(tmp2,init,tbl);
1789: init = new expr(G_CM,ass,tmp2);
1790: }
1791: }
1792: }
1793: //error('d',"nn %n",nn);
1794: if (nn) {
1795: Pexpr a = new expr(ELIST,init,0);
1796: a = new texpr(VALUE,tt,a);
1797: a->e2 = nn;
1798: return a->typ(tbl);
1799: }
1800: }
1801: //error('d',"c1 %n c2 %n",c1,c2);
1802: return init->typ(tbl);
1803: }
1804: return init;
1805: }
1806: //error('d',"ci check tt %t init->tp %t",tt,init->tp);
1807: if (tt->check(init->tp,ASSIGN) && refd==0) {
1808: error("badIrT:%t (%tX)",init->tp,tt);
1809: init->tp = any_type;
1810: }
1811:
1812: return init;
1813: }
1814:
1815: extern int bound; // fudge for bound pointers to functions
1816:
1817: Pexpr expr::docast(Ptable tbl)
1818: {
1819: // check cast against value, INCOMPLETE
1820:
1821: //error('d',"docast %d %t %k",this,tp2,e1->base);
1822: if (e1 == dummy) {
1823: error("E missing for cast");
1824: tp = any_type;
1825: return this;
1826: }
1827:
1828: int pmf = 0;
1829: int ptom_cast = 0;
1830: Pexpr ee = e1;
1831:
1832: //error('d',"ee %k %d",ee->base,ee->base);
1833: switch (ee->base) {
1834: case ADDROF:
1835: ee = ee->e2;
1836: switch (ee->base) {
1837: case NAME: goto nm;
1838: case REF: goto rf;
1839: }
1840: break;
1841:
1842: case NAME:
1843: nm:
1844: if (Pname(ee)->n_qualifier) pmf = 1;
1845: break;
1846:
1847: case REF:
1848: rf:
1849: if (ee->e1->base == THIS) bound = 1;
1850: break;
1851: }
1852:
1853: e1 = e1->typ(tbl);
1854:
1855: int b = bound; // distinguish between explicit and implicit THIS
1856: bound = 0;
1857: pmf = pmf && e1->base==CAST;
1858:
1859: Ptype etp = e1->tp;
1860: Ptype tt = tp2;
1861: Ptype t = tt;
1862: tt->dcl(tbl);
1863:
1864: while (etp->base == TYPE) etp = Pbase(etp)->b_name->tp;
1865: while (tt->base == TYPE) tt = Pbase(tt)->b_name->tp;
1866:
1867: //error('d',"e1 %k etp %t tt %t",e1->base,etp,tt);
1868:
1869: switch (etp->base) {
1870: case PTR:
1871: case RPTR:
1872: if (Pptr(etp)->typ->base == OVERLOAD) goto over;
1873:
1874: if (warning_opt && i2==0 && Pptr(etp)->typ->tconst()) {
1875: switch (tt->base) {
1876: case FCT:
1877: break;
1878: case PTR:
1879: case RPTR:
1880: if (Pptr(tt)->typ->tconst()) break;
1881: default:
1882: // casting away const
1883: // should be an error
1884: // but ANSI says OK so I chicken out
1885: // to be able to compile strtok(), etc.
1886: error('w',"const cast away:%t->%t",e1->tp,tp2);
1887: }
1888: }
1889: else
1890: i2 = 0; // to allow cfront to escape its own checking
1891: break;
1892: case COBJ:
1893: { ref_cast = 1;
1894: Pexpr x = try_to_coerce(tt,e1,"cast",tbl);
1895: ref_cast = 0;
1896: //error('d',"x %k %t tt %d %t",x?x->base:0,x?x->tp:0,tt,tt);
1897: if (x) {
1898: if (x!=e1 && x->base==DEREF && tt->is_ref()) x = x->e1;
1899: if (tt==x->tp || tt->check(x->tp,0)==0 || const_problem)
1900: return x;
1901: else
1902: return new cast(tt,x);
1903: }
1904: // else if (e1->base==DEREF && tt->is_ref()) return e1;
1905: break;
1906: }
1907: case VOID:
1908: if (tt->base == VOID) {
1909: tp = t;
1910: return this;
1911: }
1912: error("cast of void value");
1913: // no break;
1914: case ANY:
1915: any:
1916: tp = any_type;
1917: return this;
1918: case FCT:
1919: if (tt->base == PTR && Pptr(tt)->typ->base != FCT)
1920: error('w',"P toF cast toP to nonF");
1921: break;
1922: case OVERLOAD:
1923: over:
1924: error("cast of overloaded");
1925: goto any;
1926: }
1927:
1928: //error('d',"tt %t",tt);
1929: switch (tt->base) {
1930: case PTR:
1931: if (Pptr(tt)->typ->base==FCT && Pptr(tt)->memof) {
1932: if (etp->base!=PTR
1933: || Pptr(etp)->typ->base!=FCT
1934: || Pptr(etp)->memof==0)
1935: error("cast toP toM %t",tt);
1936: else { // adjust delta in MI case
1937: // for the moment just suppress the cast
1938: // all pmfs are the same to cc
1939: /*
1940: Pclass c1 = Pptr(tt)->memof;
1941: Pclass c2 = Pptr(etp)->memof;
1942: */
1943: ptom_cast = 1;
1944: tp2 = void_type;
1945: }
1946: }
1947:
1948: switch (etp->base) {
1949: case COBJ:
1950: error("cannot castCO toP");
1951: break;
1952: case FCT:
1953: e1 = new expr(G_ADDROF,0,e1);
1954: bound = b;
1955: e1 = e1->typ(tbl);
1956: bound = 0;
1957: if (e1->base == CAST)
1958: pmf = 1;
1959: else
1960: break;
1961: // no break;
1962:
1963: case PTR:
1964: { Pname cn = Pptr(tt)->typ->is_cl_obj();
1965: if (cn) {
1966: Pexpr x = cast_cptr(Pclass(cn->tp),e1,tbl,1);
1967:
1968: if (x == e1) {
1969: PERM(tt);
1970: e1 = new cast(tt,e1);
1971: e1->i2 = i2;
1972: }
1973: else
1974: e1 = x;
1975: }
1976: if (pmf) {
1977: zaqq:
1978: switch (tt->base) {
1979: case TYPE:
1980: tt = Pbase(tt)->b_name->tp; goto zaqq;
1981: case PTR:
1982: if (Pptr(tt)->memof) break;
1983: default:
1984: error("%t cast to%t (%t is not aP toM)",e1->tp,tp2,tp2);
1985: }
1986: }
1987: }
1988: }
1989: break;
1990:
1991: case RPTR: // (x&)e: pretend e is an x
1992: { Ptype er = etp;
1993: Ptype cr = tt;
1994: do {
1995: if (er = er->is_ptr_or_ref()) er = Pptr(er)->typ;
1996: if (cr = cr->is_ptr_or_ref()) cr = Pptr(cr)->typ;
1997: } while (er && cr);
1998: int pp = er!=0; // if `e' is a suitable pointer cast it:
1999: // (x&)e => (x*)e, otherwise
2000: // (x&)e => *(x*)&e
2001: //error('d',"rptr tt %t e1->base %k e1->tp %t",tt,e1->base,e1->tp);
2002: // if (Pptr(tt)->typ->tsizeof()>etp->tsizeof()) goto zse;
2003: // we need to be able to ``raise the type'' from base to derived
2004: // if (etp->is_cl_obj() && Pptr(tt)->typ->is_cl_obj()==0) goto zse;
2005:
2006: if (e1->base==G_CM
2007: || e1->base==CALL
2008: || e1->base==G_CALL
2009: || e1->lval(0))
2010: ;
2011: else if (e1->tp->tconst()) {
2012: // casting away const
2013: // should be an error
2014: // but ANSI says OK so I chicken out
2015: // to be able to compile strtok(), etc.
2016: if (warning_opt && Pptr(tt)->typ->tconst()==0)
2017: error('w',"const cast away:%t->%t",e1->tp,tp2);
2018:
2019: }
2020: else
2021: error("cannot cast%t to%t",etp,t);
2022: //error('d',"e1 %k %t %d",e1->base,e1->tp,pp);
2023: if (pp == 0) e1 = e1->address(); // *(x*)&e
2024: tp = t;
2025:
2026: // do proper pointer manipulation for multiple inheritance
2027: Pname cn = Pptr(tt)->typ->is_cl_obj();
2028: if (cn) {
2029: Pexpr x = cast_cptr(Pclass(cn->tp),e1,tbl,1);
2030:
2031: if (x == e1) {
2032: PERM(tt);
2033: e1 = new cast(tt,e1);
2034: e1->i2 = i2;
2035: }
2036: else
2037: e1 = x;
2038: }
2039:
2040: return pp ? this : contents();
2041: // zse:
2042: // error("cannot cast%t to%t",etp,t);
2043: // tp2 = tt = any_type;
2044: // break;
2045: }
2046: case COBJ:
2047: base = VALUE; // (x)e => x(e): construct an x from e
2048: e1 = new expr(ELIST,e1,0);
2049: return typ(tbl);
2050:
2051: case CHAR:
2052: case INT:
2053: case SHORT:
2054: case LONG:
2055: case FLOAT:
2056: case DOUBLE:
2057: case LDOUBLE:
2058: switch (etp->base) {
2059: case FCT:
2060: e1 = new expr(ADDROF,0,e1);
2061: e1 = e1->typ(tbl);
2062: break;
2063: case COBJ:
2064: error("cannot castCO to%k",tt->base);
2065: break;
2066: }
2067: break;
2068: }
2069:
2070: tp = t;
2071:
2072: if (e1->base==ILIST && ptom_cast==0) { // pointer to member constant
2073: Pexpr ee = e1->e1; // ELIST
2074: int i;
2075: switch (ee->e2->base) {
2076: case IVAL:
2077: i = int(ee->e2->i1);
2078: break;
2079: case ZERO:
2080: i = 0;
2081: }
2082:
2083: if (i<0)
2084: e1 = e1->e2; // just the function
2085: else
2086: e1 = ee->e2; // just the index
2087: return this;
2088: }
2089:
2090: if (etp->base==PTR && Pptr(etp)->memof && Pptr(etp)->typ->base==FCT) {
2091: Pclass cl = Pptr(etp)->memof;
2092:
2093: if (Pptr(tt)->memof==0 && b == 0 ) {
2094: Pexpr y = new mdot("f",e1);
2095: y->i1 = 9;
2096: y = new cast(tt,y);
2097: if (cl->virt_count && b==0) {
2098: // ERROR: no check for side effects
2099: Pexpr z = new mdot("i",e1);
2100: Pexpr x = new mdot("i",e1);
2101: x->i1 = 9;
2102: x = new cast(tt,x);
2103: z->i1 = 9;
2104: Pexpr q = new expr (QUEST,x,y);
2105: q->cond = new expr(LE,zero,z);
2106: q->tp = tt;
2107: delete this;
2108: return q;
2109: }
2110: delete this;
2111: return y;
2112: }
2113: }
2114:
2115: return this;
2116: }
2117:
2118: Pexpr expr::dovalue(Ptable tbl)
2119: {
2120: Ptype tt = tp2;
2121: Pclass cl;
2122: Pname cn ;
2123:
2124: //error('d',"value %d %t e1 %d e2 %d",tt,tt,e1,e2);
2125:
2126: tt->dcl(tbl);
2127: vv:
2128: switch (tt->base) {
2129: case TYPE:
2130: tt = Pbase(tt)->b_name->tp;
2131: goto vv;
2132:
2133: case EOBJ:
2134: default:
2135: if (e1 == 0) {
2136: error("value missing in conversion to%t",tt);
2137: return dummy;
2138: }
2139: base = CAST;
2140: e1 = e1->e1; // strip ELIST
2141: return typ(tbl);
2142:
2143: case CLASS:
2144: cl = Pclass(tt);
2145: tp2 = Pptr(cl->this_type)->typ;
2146: break;
2147:
2148: case COBJ:
2149: cn = Pbase(tt)->b_name;
2150: cl = Pclass(cn->tp);
2151: }
2152:
2153: //error('d',"e1 %k e1->e2 %k",e1->base,e1?e1->e2->base:0);
2154: if (e1 && e1->e2==0) { // single argument
2155: if (e1->e1->base==ELIST) e1->e1 = e1->e1->e1; // spurious elist
2156: e1->e1 = e1->e1->typ(tbl);
2157: if (tt->base==COBJ) {
2158: Pexpr x = try_to_coerce(tt,e1->e1,"type conversion",tbl);
2159: if (x) return x;
2160: }
2161:
2162: Pname acn = e1->e1->tp->is_cl_obj();
2163: //error('d',"acn %n %d",acn,cl->has_itor());
2164: if (acn && cl->has_itor()==0) {
2165: Pclass acl = Pclass(acn->tp);
2166: int hb = acl->has_base(cl);
2167:
2168: if (acl==cl || hb) {
2169: vcllist->clear();
2170: vcllist=0;
2171: if (1<is_unique_base(acl,cl->string,0)) error("ambiguous assignment to base %t",cl);
2172: Pexpr ee = e1->e1;
2173: if (ee->base == ELIST) ee = ee->e1; // ???
2174: if (hb) { // ee => *(tp2*)&ee
2175: // remember = may be overloaded
2176: //error('d',"hb %k %t %d",ee->base,ee->tp,ee->lval(0));
2177: if (ee->lval(0)==0) {
2178: Pname tmp = make_tmp('T',ee->tp,tbl);
2179: ee = init_tmp(tmp,ee,tbl);
2180: ee = new expr(G_CM,ee,tmp->address());
2181: }
2182: else
2183: ee = ee->address();
2184: ee = new texpr(CAST,new ptr(PTR,tp2),ee); //new cast(new ptr(PTR,tp2),ee);
2185: ee = ee->contents();
2186: ee->typ(tbl);
2187: }
2188:
2189: if (e2) { // x(x_obj) => e2=x_obj
2190: base = ASSIGN;
2191: e1 = e2;
2192: e2 = ee;
2193: tp = tp2;
2194: return this;
2195: }
2196: return ee; // strip ELIST: x(x_obj) => x_obj
2197: }
2198: }
2199: }
2200:
2201:
2202: /* x(a) => obj.ctor(a); where e1==obj */
2203: Pname ctor = cl->has_ctor();
2204: if (ctor == 0) {
2205: error("cannot make a%t",cl);
2206: return dummy;
2207: }
2208:
2209: //error('d',"e2 %k",e2?e2->base:0);
2210: if (e2 == 0) { // x(a) => x temp; (temp.x(a),temp)
2211: Pname n = make_tmp('V',tp2,tbl);
2212: n->assign();
2213: if (tbl == gtbl) n->dcl_print(0); // a hack
2214: Pexpr c = call_ctor(tbl,n,ctor,e1,DOT);
2215: c = new expr(G_CM,c,n);
2216: c->tp = n->tp;
2217: //error('d',"tp1 %t",c->tp);
2218: return c;
2219: }
2220: else {
2221: Pexpr c = call_ctor(tbl,e2,ctor,e1,DOT);
2222: c = new expr(DEREF,c,0); // deref value returned by constructor
2223: c->tp = c->e1->tp;
2224: //error('d',"tp2 %t",c->tp);
2225: return c;
2226: }
2227: }
2228:
2229: /* ODI notes
2230:
2231: fixes for template classes and to get const right
2232: by not discarding const information from typedefs
2233:
2234: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.