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