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