![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to expr2.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 expr2.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / ptcfront |
1.1 root 1: /*ident "@(#)ctrans:src/expr2.c 1.9" */
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: expr2.c:
11:
12: type check expressions
13:
14: ************************************************************************/
15:
16: #include "cfront.h"
17: #include "size.h"
18: extern Pname conv_dominates(Pname,Pname);
19: extern int pr_dominate(Ptype, Ptype);
20: static Pname dominate(Pname,Pname,Pexpr,int);
21: static int const_obj1,const_obj2;
22:
23: Pname really_dominate(Pname on1, Pname on2, bit tc)
24: {
25: Pfct f1 = on1->get_fct();
26: Pfct f2 = on2->get_fct();
27:
28: Ptype t1=f1->returns;
29: Ptype t2=f2->returns;
30:
31: if (!t1 || !t2 || (t1->check(t2,OVERLOAD) && !const_problem))
32: return 0;
33:
34: // const check
35: int c1 = f1->f_const;
36: int c2 = f2->f_const;
37:
38: if(c1 == c2) ;
39: else if(c1 && !c2) return tc ? on1 : on2;
40: else if(c2 && !c1) return tc ? on2 : on1;
41:
42: // hierarchy check
43: Pname on = conv_dominates(on1,on2);
44: if(on) return on;
45: else return 0;
46: }
47:
48: void name::assign()
49: {
50: if (n_assigned_to++ == 0) {
51: switch (n_scope) {
52: case FCT:
53: if (n_used && n_addr_taken==0) {
54: Ptype t = tp->skiptypedefs();
55: switch (t->base) {
56: case VEC:
57: break;
58: default:
59: if (curr_loop)
60: error('w',&where,"%n may have been used before set",this);
61: else
62: error('w',&where,"%n used before set",this);
63: }
64: }
65: }
66: }
67: }
68:
69: void name::take_addr()
70: {
71: // error('d', "%n->take_addr tp: %t", this, tp?tp:0 );
72: // error('d', "%n->take_addr tp: %d %d", this, tp?tp:0, tp?tp->base:0 );
73: if ( (warning_opt) && (! n_addr_taken) && (tp) && (tp->base==FCT) && Pfct (tp)->f_inline)
74: error('w',"can't take address of inline function %n, %n not inlined", this, this);
75: n_addr_taken++;
76: if ( n_sto == EXTERN && tp ) {
77: Ptype t = tp->skiptypedefs();
78: switch ( t->base ) {
79: case COBJ:
80: t = Pbase(t)->b_name->tp; // no break
81: case CLASS: {
82: Pclass cl = Pclass(t);
83: if ( cl->c_body == 1 )
84: cl->dcl_print(0);
85: }
86: }
87: }
88: }
89:
90: int ignore_const; // for use by ref_init
91: static is_dataMemPtr(Pexpr);
92:
93: int expr::lval(TOK oper)
94: {
95: register Pexpr ee = this;
96: register Pname n;
97: int deref = 0;
98: char* es;
99:
100: //error('d',"%k expr::lval %k",base,oper);
101:
102: switch (oper) {
103: case ADDROF:
104: case G_ADDROF: es = "address of"; break;
105: case DEREF: es = "dereference of"; break;
106: case INCR: es = "increment of"; goto def;
107: case DECR: es = "decrement of"; goto def;
108: default: es = "assignment to";
109: def:
110: if (ignore_const==0 && tp->tconst()) {
111: if (oper) {
112: if (base == NAME) {
113: if (vec_const && Pname(this)->n_scope==ARG) break;
114: error("%s constant%n",es,this);
115: }
116: else
117: error("%s constant",es);
118: }
119: return 0;
120: }
121: }
122:
123: for(;;) {
124: //error('d',"loop %k",ee->base);
125: switch (ee->base) {
126: // case G_CALL:
127: // case CALL:
128: default:
129: defa:
130: if (deref == 0) {
131: if (oper) error("%s%k (not an lvalue)",es,ee->base);
132: return 0;
133: }
134: return 1;
135: case ZERO:
136: case CCON:
137: case ICON:
138: case FCON:
139: if (oper) error("%s numeric constant",es);
140: return 0;
141: case STRING:
142: if (oper) error('w',"%s string constant",es);
143: return 1;
144: case CAST:
145: switch( oper ) {
146: case 0:
147: case ADDROF:
148: case G_ADDROF:
149: case DEREF:
150: goto defa;
151: default:
152: if ( ee->tp->base == PTR
153: && is_dataMemPtr(ee) )
154: { // check for const class object
155: Pexpr te;
156: te = ee->e1->e1->e1;
157: if ( te->base == G_ADDROF )
158: te = te->e2;
159: if ( te->base == NAME ) {
160: Ptype pt = te->tp;
161: if ( pt->base == PTR )
162: pt = Pptr(pt)->typ;
163: if ( pt->tconst() )
164: error("%sCMP of const%n",es,te);
165: return 0;
166: }
167: }
168: goto defa;
169: }
170:
171: case DEREF:
172: {
173: Pexpr ee1 = ee->e1;
174: // error( 'd', "ee1: %k", ee1->base );
175: switch (ee1->base) { // *& vanishes
176: case ADDROF: // *&
177: return 1;
178: case G_CM:
179: case CM: // look for *(a,&b)
180: if (ee1->e2->base==G_ADDROF
181: || ee1->e2->base==ADDROF)
182: return 1;
183: goto defaa;
184: case QUEST: // look for *(q?&a:&b)
185: if ((ee1->e1->base==G_ADDROF
186: || ee1->e1->base==ADDROF)
187: && (ee1->e2->base==G_ADDROF
188: || ee1->e2->base==ADDROF))
189: return 1;
190: // no break
191: default:
192: defaa:
193: ee = ee1;
194: deref = 1;
195: }
196: break;
197: }
198:
199: case QUEST:
200: { int x1 = ee->e1->lval(deref?0:oper);
201: int x2 = ee->e2->lval(deref?0:oper);
202: if (ee->e1->tp->check(ee->e2->tp,0)) return 0;
203: if (deref) return 1;
204: return x1 && x2;
205: }
206:
207: case INCR:
208: case DECR:
209: if (e1) goto defa; // postfix does not preserve lval
210: case ASSIGN:
211: case ASPLUS:
212: case ASMINUS:
213: case ASMUL:
214: case ASDIV:
215: case ASMOD:
216: case ASAND:
217: case ASOR:
218: case ASER:
219: case ASLS:
220: case ASRS:
221: return 1;
222:
223: case CM:
224: case G_CM:
225: if (ee->e2->lval(deref?0:oper)==0) return deref;
226: return 1;
227:
228: case MEMPTR:
229: ee = ee->e2;
230: break;
231:
232: case MDOT:
233: ee = ee->mem;
234: break;
235:
236: case DOT:
237: {
238: // error('d',"dot %k oper %k",ee->e1->base,oper);
239: Pexpr e = 0;
240: int e_const = 0; // to catch x.y.val = 1, where x is const
241:
242: switch (ee->e1->base) { // update use counts, etc.
243: case NAME:
244: switch (oper) {
245: case ADDROF:
246: case G_ADDROF: Pname(ee->e1)->take_addr();
247: case 0: break;
248: case ASSIGN: Pname(ee->e1)->n_used--;
249: default: Pname(ee->e1)->assign(); // asop
250: }
251: break;
252: case DOT:
253: e = ee->e1;
254: do e=e->e1; while (e->base==DOT);
255: if (e->base == NAME) {
256: e_const = e->tp->tconst();
257: switch (oper) {
258: case ADDROF:
259: case G_ADDROF: Pname(e)->take_addr();
260: case 0: break;
261: case ASSIGN: Pname(e)->n_used--;
262: default: Pname(e)->assign(); // asop
263: }
264: }
265: }
266:
267: n = Pname(ee->mem);
268: while (n->base == MDOT) n = Pname(Pref(n)->mem);
269:
270: if (deref==0 &&
271: (ee->e1->tp->tconst() || e_const)) {
272:
273: switch (oper) {
274: case 0:
275: case ADDROF:
276: case G_ADDROF:
277: case DEREF:
278: break;
279: default:
280: error("%sM%n of%t",es,n,e_const?e->tp:ee->e1->tp);
281: }
282: return 0;
283: }
284: }
285: goto xx;
286:
287: case REF:
288: n = Pname(ee->mem);
289: while (n->base == MDOT) n = Pname(Pref(n)->mem);
290:
291: if (deref==0 && ee->e1) { //BR
292: Ptype p = ee->e1->tp->skiptypedefs();
293:
294: switch (p->base) {
295: case PTR:
296: case VEC: break;
297: default: error('i',"expr::lval %t->%n",p,n);
298: }
299: if (Pptr(p)->typ->tconst()) {
300: switch (oper) {
301: case 0:
302: case G_ADDROF:
303: case DEREF:
304: break;
305: case ADDROF:
306: if ( cm_const_save == 0 && const_ptr == 0 )
307: error(strict_opt?0:'w',"%sM%n of%t",es,n,Pptr(p)->typ);
308: break;
309: default:
310: error("%sM%n of%t",es,n,Pptr(p)->typ);
311: }
312: return 0;
313: }
314: }
315: goto xx;
316:
317: case NAME:
318: n = Pname(ee);
319: xx:
320: // error('d',"name xx: %n oper %d lex_level: %d",n,oper,n->lex_level);
321: if (deref) return 1;
322: if (oper==0) return n->n_stclass != ENUM ;
323:
324: if (n->tp->base==FIELD && Pbase(n->tp)->b_bits==0) {
325: error("%s 0-length field%n",es,n);
326: return 0;
327: }
328:
329: switch (oper) {
330: case ADDROF:
331: case G_ADDROF:
332: { Pfct f = (Pfct)n->tp;
333:
334: if (n->n_sto == REGISTER) {
335: if (warning_opt) error('w',"& register%n",n);
336: // return 0;
337: n->n_sto = 0;
338: n->n_stclass = AUTO;
339: }
340:
341: if (f == 0) {
342: error("& label%n",n);
343: return 0;
344: }
345:
346: if (n->n_stclass == ENUM) {
347: error("& enumerator%n",n);
348: return 0;
349: }
350:
351: if (n->tp->base == FIELD) {
352: error("& field%n",n);
353: return 0;
354: }
355:
356: n->n_used--;
357: if (n->n_qualifier) { // oops, not the real one
358: Pname tn = Pclass(n->n_table->t_name->tp)->memtbl->look(n->string,0);
359: n = tn ? tn : n;
360: }
361: n->take_addr();
362:
363: // suppress hoisting of local consts
364: int statmem = n->n_scope==0 || n->n_scope==PUBLIC || n->n_scope == FCT;
365: if (n->n_evaluated && n->n_scope!=ARG) { // &const
366: if (statmem == 0 && n->n_dcl_printed==0) {
367: n->n_initializer = new ival(n->n_val);
368: n->dcl_print(0);
369: }
370: }
371: else if (f->base==FCT && n->n_dcl_printed==0)
372: n->dcl_print(0);
373: break;
374: }
375:
376: case ASSIGN:
377: //error('d',"ass %n %d",n,n->n_used);
378: n->n_used--;
379: n->assign();
380: break;
381: // goto check_void;
382: default: /* incr ops, and asops */
383: if (cc->tot && n==cc->c_this) {
384: error("%n%k",n,oper);
385: return 0;
386: }
387: // check_void:
388: // { Ptype t = n->tp;
389: // while (t->base==TYPE) t = Pbase(t)->b_name->tp;
390: // if (t==Pvoid_type) {
391: // error("%s%t",es,n->tp);
392: // return 0;
393: // }
394: // }
395: n->assign();
396: }
397: return 1;
398: }
399: }
400: }
401:
402: int char_to_int(char* s)
403: /* assume s points to a string:
404: 'c'
405: or '\c'
406: or '\0'
407: or '\ddd'
408: or multi-character versions of the above
409: (hex constants have been converted to octal by the parser)
410: */
411: {
412: register int i = 0;
413: register char c, d, e;
414:
415: switch (*s) {
416: default:
417: error('i',"char constant store corrupted");
418: case '`':
419: error("bcd constant");
420: return 0;
421: case '\'':
422: break;
423: }
424:
425: for(;;) /* also handle multi-character constants */
426: switch (c = *++s) {
427: case '\'':
428: return i;
429: case '\\': /* special character */
430: switch (c = *++s) {
431: case '0': case '1': case '2': case '3': case '4':
432: case '5': case '6': case '7': /* octal representation */
433: c -= '0';
434: switch (d = *++s) { /* try for 2 */
435:
436: case '0': case '1': case '2': case '3': case '4':
437: case '5': case '6': case '7':
438: d -= '0';
439: switch (e = *++s) { /* try for 3 */
440:
441: case '0': case '1': case '2': case '3': case '4':
442: case '5': case '6': case '7':
443: c = c*64+d*8+e-'0';
444: break;
445: default:
446: c = c*8+d;
447: s--;
448: }
449: break;
450: default:
451: s--;
452: }
453: break;
454: case 'a':
455: c = '\a';
456: break;
457: case 'b':
458: c = '\b';
459: break;
460: case 'f':
461: c = '\f';
462: break;
463: case 'n':
464: c = '\n';
465: break;
466: case 'r':
467: c = '\r';
468: break;
469: case 't':
470: c = '\t';
471: break;
472: case 'v':
473: c = '\v';
474: break;
475: case '\\':
476: c = '\\';
477: break;
478: case '\'':
479: c = '\'';
480: break;
481: }
482: /* no break */
483: default:
484: if (i) i <<= BI_IN_BYTE;
485: i += c;
486: }
487: }
488:
489: const A10 = 'A'-10;
490: const a10 = 'a'-10;
491:
492: long str_to_long(register const char* p)
493: {
494: register c;
495: register unsigned long i= 0;
496: const char* pp = p;
497:
498: // error( 'd', "str_to_long: %s", p );
499:
500: if ((c=*p++) == '0') {
501: switch (c = *p++) {
502: case 0:
503: return 0;
504:
505: case 'l':
506: case 'L': /* long zero */
507: return 0;
508:
509: case 'x':
510: case 'X': /* hexadecimal */
511: while (c=*p++) {
512: switch (c) {
513: case 'l':
514: case 'L':
515: case 'U':
516: case 'u':
517: return i;
518: case 'A':
519: case 'B':
520: case 'C':
521: case 'D':
522: case 'E':
523: case 'F':
524: i = i*16 + c-A10;
525: break;
526: case 'a':
527: case 'b':
528: case 'c':
529: case 'd':
530: case 'e':
531: case 'f':
532: i = i*16 + c-a10;
533: break;
534: default:
535: i = i*16 + c-'0';
536: }
537: }
538: return i;
539:
540: default: /* octal */
541: do
542: switch (c) {
543: case 'l':
544: case 'L':
545: case 'U':
546: case 'u':
547: return i;
548: default:
549: i = i*8 + c-'0';
550: }
551: while (c=*p++);
552: return i;
553: }
554: }
555: /* decimal */
556: i = c-'0';
557: while (c=*p++)
558: switch (c) {
559: case 'l':
560: case 'L':
561: case 'U':
562: case 'u':
563: return i;
564: default:
565: { unsigned long ii = i;
566: i = i*10 + c-'0';
567: if (i<ii) goto bad;
568: }
569: }
570: return i;
571: bad:
572: error("integer constant %s larger than the largest long",pp);
573: return i;
574:
575:
576: }
577:
578: bit type::is_unsigned()
579: {
580: Ptype t = skiptypedefs();
581: if (t->base == PTR) return 0;
582: return Pbase(t)->b_unsigned;
583: }
584:
585: char* Neval;
586: bit binary_val;
587:
588: unsigned long expr::ueval(long x1, long x2)
589: {
590: unsigned long i1 = (unsigned long) x1;
591: unsigned long i2 = (unsigned long) x2;
592: //error('d',"ueval %k %ld %ld",base,x1,x2);
593: switch (base) {
594: case UMINUS: return -i2;
595: case UPLUS: return i2;
596: case NOT: return !i2;
597: case COMPL: return ~i2;
598: case CAST: return i1;
599: case PLUS: return i1+i2;
600: case MINUS: return i1-i2;
601: case MUL: return i1*i2;
602: case LS: return i1<<i2;
603: case RS: return i1>>i2;
604: case NE: return i1!=i2;
605: case EQ: return i1==i2;
606: case LT: return i1<i2;
607: case LE: return i1<=i2;
608: case GT: return i1>i2;
609: case GE: return i1>=i2;
610: case AND: return i1&i2;
611: case ANDAND: return i1&&i2;
612: case OR: return i1|i2;
613: case OROR: return i1||i2;
614: case ER: return i1^i2;
615: case MOD: if (i2 == 0) {
616: if (Neval == 0) {
617: Neval = "mod zero";
618: error("mod zero");
619: }
620: return 1;
621: }
622: return i1%i2;
623: case QUEST: return (cond->eval()) ? i1 : i2;
624: case DIV: if (i2 == 0) {
625: if (Neval == 0) {
626: Neval = "divide by zero";
627: error("divide by zero");
628: }
629: return 1;
630: }
631: return i1/i2;
632: case CM:
633: case G_CM:
634: return i2;
635: }
636:
637: Neval = "unsigned expression";
638: return 0;
639: }
640:
641: long expr::eval()
642: {
643: if (Neval) return 1;
644: // error('d',"eval %k",base);
645:
646: static int targno=0;
647: static int icallflag=0;
648:
649: switch (base) {
650: case ZERO: return 0;
651: case IVAL: return i1;
652: case ICON: return str_to_long(string);
653: case CCON: return char_to_int(string);
654: case FCON: Neval = "float in constant expression"; return 1;
655: case STRING: Neval = "string in constant expression"; return 1;
656: case EOBJ: return Pname(this)->n_val;
657: case SIZEOF:
658: extern no_sizeof;
659: if (no_sizeof) Neval = "sizeof";
660: return tp2->tsizeof();
661:
662: case NAME:
663: { Pname n = Pname(this);
664: // error('d',"eval %n eval %d %d",n,n->n_evaluated,n->n_val);
665: // error('d',"eval tp->tconst() %d, n->n_initializer: %k", n->tp->tconst(), n->n_initializer?n->n_initializer->base:0 );
666: if (n->n_evaluated && n->n_scope!=ARG) return n->n_val;
667: if (binary_val && strcmp(string,"_result")==0) return 8888;
668: Neval = "cannot evaluate constant";
669: return 1;
670: }
671: case ICALL:
672: if (e1) {
673: icallflag=1;
674: targno=0;
675: il->i_next = curr_icall;
676: curr_icall = il;
677: long i = e1->eval();
678: curr_icall = il->i_next;
679: icallflag=0;
680: return i;
681: }
682: Neval = "void inlineF";
683: return 1;
684: case ANAME:
685: { Pname n = (Pname)this;
686:
687: /*
688: int argno;
689: if (icallflag) {
690: argno=targno;
691: targno++;
692: }
693: */
694: int argno = (int) n->n_val;
695:
696: Pin il;
697: for (il=curr_icall; il; il=il->i_next)
698: if (il->i_table == n->n_table) goto aok;
699: goto bok;
700: aok:
701: if (il->i_args[argno].local) {
702: bok:
703: Neval = "inlineF call too complicated for constant expression";
704: return 1;
705: }
706: Pexpr aa = il->i_args[argno].arg;
707: return aa->eval();
708: }
709: case CAST:
710: { if (e1->base==FCON && tp2->base!=FLOAT && tp2->base!=DOUBLE) {
711: char* p = e1->string;
712: while (*p!='.') p++;
713: if (p==e1->string) *p++ = '0';
714: *p = 0;
715: e1->base = ICON;
716: }
717: long i = e1->eval();
718: Ptype tt = tp2->skiptypedefs();
719:
720: switch (tt->base) {
721: default:
722: Neval = "cast to non-integral type in constant expression";
723: break;
724: case EOBJ:
725: case LONG:
726: case INT:
727: case CHAR:
728: case SHORT:
729: i &= ~(((~(unsigned long)0)<<(BI_IN_BYTE*(tp2->tsizeof()-1)))<<BI_IN_BYTE);
730: break;
731: }
732: return i;
733: }
734: case UMINUS:
735: case UPLUS:
736: case NOT:
737: case COMPL:
738: case PLUS:
739: case MINUS:
740: case MUL:
741: case LS:
742: case RS:
743: case NE:
744: case LT:
745: case LE:
746: case GT:
747: case GE:
748: case AND:
749: case OR:
750: case ER:
751: case DIV:
752: case MOD:
753: case QUEST:
754: case EQ:
755: case ANDAND:
756: break;
757: case OROR:
758: if (binary_val) { // a||b, don't evaluate b if a!=0
759: long i1 = (e1) ? e1->eval() : 0;
760: if (Neval==0 && i1 && e1->tp->is_unsigned()==0) return i1;
761: }
762: break;
763: case CM:
764: case G_CM:
765: break;
766: case G_ADDROF:
767: case ADDROF:
768: if (binary_val) { // beware of &*(T*)0
769: switch (e2->base) {
770: case NAME:
771: case DOT:
772: case REF: return 9999;
773: }
774: }
775: default:
776: Neval = "bad operator in constant expression";
777: return 1;
778: }
779:
780: long i1 = (e1) ? e1->eval() : 0;
781: long i2 = (e2) ? e2->eval() : 0;
782:
783: if (binary_val && i1==9999 && i2==9999) {
784: Neval = "";
785: return 1;
786: }
787:
788: if (Neval==0
789: && ((e1&&e1->tp->is_unsigned()) || (e2&&e2->tp->is_unsigned())))
790: return (long) ueval(i1,i2);
791:
792: switch (base) {
793: case UMINUS: return -i2;
794: case UPLUS: return i2;
795: case NOT: return !i2;
796: case COMPL: return ~i2;
797: case CAST: return i1;
798: case PLUS: return i1+i2;
799: case MINUS: return i1-i2;
800: case MUL: return i1*i2;
801: case LS: return i1<<i2;
802: case RS: return i1>>i2;
803: case NE: return i1!=i2;
804: case EQ: return i1==i2;
805: case LT: return i1<i2;
806: case LE: return i1<=i2;
807: case GT: return i1>i2;
808: case GE: return i1>=i2;
809: case AND: return i1&i2;
810: case ANDAND: return i1&&i2;
811: case OR: return i1|i2;
812: case OROR: return i1||i2;
813: case ER: return i1^i2;
814: case MOD: if (i2 == 0) {
815: if (Neval == 0) {
816: Neval = "mod zero";
817: error("mod zero");
818: }
819: return 1;
820: }
821: return i1%i2;
822: case QUEST: return (cond->eval()) ? i1 : i2;
823: case DIV: if (i2 == 0) {
824: if (Neval == 0) {
825: Neval = "divide by zero";
826: error("divide by zero");
827: }
828: return 1;
829: }
830: return i1/i2;
831: case CM:
832: case G_CM:
833: return i2;
834: }
835: }
836: bit classdef::baseof(Pname f)
837: /*
838: is ``this'' class a public base class of "f"'s class
839: or its immediate base class
840: */
841: {
842: Ptable ctbl = f->n_table;
843: Pname b = ctbl->t_name;
844:
845: if (b == 0) return 0;
846: Pclass cl = Pclass(b->tp);
847: if (cl == 0) return 0;
848: if (cl == this) return 1;
849: ppbase = PUBLIC;
850: Pclass bcl = is_base(cl->string);
851: return (bcl && ppbase==PUBLIC);
852: }
853:
854: bit classdef::baseof(Pclass cl)
855: /*
856: is ``this'' class a public base class of "cl"
857: */
858: {
859: if (cl == 0) return 0;
860: if (cl == this) return 1;
861: ppbase = PUBLIC;
862: Pclass bcl = is_base(cl->string);
863: return (bcl && ppbase==PUBLIC);
864: }
865:
866: static int mem_match(Pfct f1, Pfct f2)
867: /*
868: check class membership.
869:
870: For some reason checking f_this==0 works and f_static doesn't
871: */
872: {
873: // if (f1->memof) return f2->f_this ?f2->memof==f1->memof : 0;
874: // if (f1 && f1->memof) return f2->f_this?f2->memof==f1->memof : 0;
875: // return f2->f_this==0;
876: if (f1==0 || f2==0) return 0;
877: if (f1->memof && f2->f_this && f2->memof!=f1->memof) return 0;
878: if (f2->f_this) return 0;
879: if (f1->memof && f2->f_static) return 0;
880: if (f1->check(f2,ASSIGN)) return 0;
881: return 1;
882: }
883:
884: int Pchecked;
885:
886: Pexpr ptof(Pfct ef, Pexpr e, Ptable tbl)
887: /*
888: a kludge: initialize/assign-to pointer to function
889: */
890: {
891: Pfct f;
892: Pname n = 0;
893: eee:
894: //error('d',"ptof %t %t %k",ef,e->tp,e->base);
895: switch (e->base) {
896: case QUEST:
897: e->e1 = ptof(ef,e->e1,tbl);
898: e->e2 = ptof(ef,e->e2,tbl);
899: return e;
900: case CM:
901: case G_CM:
902: e->e2 = ptof(ef,e->e2,tbl);
903: return e;
904: case NAME:
905: f = Pfct(e->tp);
906: Pname nn = Pname(e);
907:
908: switch (f->base) {
909: case OVERLOAD:
910: e = Pgen(f)->find(ef,0);
911: if (e == 0) {
912: error("cannot deduceT for &overloaded%n",nn);
913: return e;
914: }
915: // e = n;
916: // no break
917: case FCT:
918: Pchecked = mem_match(ef,Pfct(e->tp));
919: e = new expr(G_ADDROF,0,e);
920: return e->typ(tbl); // handle &B::f
921: //e->tp = f;
922: }
923: goto ad;
924:
925: case ZERO:
926: if (ef->memof) {
927: e = new expr(ELIST,zero,zero);
928: e = new expr(ILIST,e,zero);
929: e->tp = zero_type;
930: return e;
931: }
932: break;
933:
934: case MDOT:
935: // ?? error('s',"P toM of not firstB");
936: do e = e->mem; while (e->base == MDOT);
937: goto eee;
938:
939: case DOT:
940: case REF:
941: f = Pfct(e->mem->tp);
942:
943: switch (f->base) {
944: case OVERLOAD:
945: n = Pgen(f)->find(ef,0);
946: if (n == 0) error("cannot deduceT for &overloaded%n",e->mem);
947: else e = n;
948: // no break
949: case FCT:
950: Pchecked = mem_match(ef,Pfct(e->tp));
951: e = new expr(G_ADDROF,0,e);
952: return e->typ(tbl); // handle &B::f
953: // n = Pname(e->mem);
954: // e = n->address();
955: }
956: goto ad;
957:
958: case ADDROF:
959: case G_ADDROF:
960: f = Pfct(e->e2->tp);
961: ad:
962: if (f->base == OVERLOAD) {
963: n = Pgen(f)->find(ef,0);
964: if (n == 0) error("cannot deduceT for &overloaded %s()",Pgen(f)->fct_list->f->string);
965: Pchecked = mem_match(ef,Pfct(n->tp));
966: e->e2 = n;
967: e->tp = n->tp;
968: }
969: if (n) n->lval(ADDROF);
970: break;
971:
972: case CAST:
973: {
974: Pexpr te = e->e1;
975: if (e->e1->base == G_ADDROF) te = e->e1->e2;
976: (void) ptof(ef,te,tbl);
977: }
978: }
979: return e;
980: }
981:
982: Pexpr ptr_init(Pptr p, Pexpr init, Ptable tbl)
983: /*
984: check for silly initializers
985:
986: char* p = 0L; ?? fudge to allow redundant and incorrect `L'
987: char* p = 2 - 2; ?? worse
988: */
989: {
990: // error('d',"ptr_init: p=%t init->tp=%t init->base %k",p,init->tp,init->base);
991:
992: Pchecked = 0;
993:
994: Ptype it = init->tp->skiptypedefs();
995:
996: switch (it->base) {
997: case ZTYPE:
998: // if (init == zero) break;
999: break;
1000: case EOBJ:
1001: case INT:
1002: case CHAR:
1003: case SHORT:
1004: case LONG:
1005: { Neval = 0;
1006: long i = init->eval();
1007: if (Neval)
1008: error("badPIr: %s",Neval);
1009: else
1010: if (i)
1011: error("badPIr value %d",i);
1012: else {
1013: DEL(init);
1014: init = zero;
1015: }
1016: break;
1017: }
1018: }
1019:
1020: Pclass c1 = p->memof;
1021:
1022: if (c1) {
1023: if (init==zero)
1024: ;
1025: else {
1026: Pclass c2;
1027: // error('d',"it %t %d",it,it->base);
1028: switch (it->base) {
1029: case FCT:
1030: c2 = Pfct(it)->memof;
1031: break;
1032: case OVERLOAD:
1033: c2 = Pfct(Pgen(it)->fct_list->f->tp)->memof;
1034: break;
1035: case PTR:
1036: case RPTR:
1037: c2 = Pptr(it)->memof;
1038: break;
1039: default:
1040: c2 = 0;
1041: }
1042:
1043: if (c2 == 0) {
1044: // initialization by &A::f
1045: //error('d',"curious");
1046: }
1047: else if (c1 != c2) {
1048: Nptr = 0;
1049: Noffset = 0;
1050: vcllist->clear();
1051: vcllist=0;
1052: int u1 = is_unique_base(c1,c2->string,0);
1053: //error('d',"c1 %t c2 %t u1 %d off %d",c1,c2,u1,Noffset);
1054: if (u1 && (Nptr || Noffset)) {
1055: // requires offset manipulation
1056: int bad = 0;
1057: if (u1 == 1 && !Nptr) {
1058: if (init->base==ILIST) {
1059: // d = d+Noffset;
1060: switch (init->e1->e1->base) {
1061: case IVAL:
1062: init->e1->e1->i1 += Noffset;
1063: break;
1064: case ZERO:
1065: init->e1->e1 = new ival(Noffset);
1066: break;
1067: default:
1068: bad = 1;
1069: }
1070:
1071: // if (i<0) f = vptroffset
1072: switch (init->e1->e2->base) {
1073: case IVAL:
1074: if (0<init->e1->e2->i1) {
1075: // extern Ptype Pfct_type;
1076: // store vptr offset
1077: // init->e2=new cast(Pfct_type,zero);
1078: }
1079: else
1080: break;
1081: default:
1082: bad = 1;
1083: }
1084: } // end if (init->base==ILIST)
1085: else
1086: bad = 1;
1087: } // end if (u1 == 1 ...
1088: else
1089: bad = 1;
1090:
1091: if (bad) error('s',"%t assigned to %t (too complicated)",init->tp,p);
1092: } // end if (u1 && ...
1093:
1094: Nptr = 0;
1095: Noffset = 0;
1096: vcllist->clear();
1097: vcllist=0;
1098: int u2 = is_unique_base(c2,c1->string,0);
1099: //error('d',"c1 %t c2 %t u2 %d off %d",c1,c2,u2,Noffset);
1100: if (u2 && (Nptr || Noffset)) {
1101: // requires offset manipulation
1102: error('s',"%t assigned to %t",init->tp,p);
1103: }
1104: } // end if (c1 != c2
1105: } // end else
1106: } // end if (c1)
1107:
1108: Ptype pit = p->typ->skiptypedefs();
1109: // error('d',"p %t pit %t",p,pit);
1110: switch (pit->base) {
1111: case FCT:
1112: return ptof(Pfct(pit),init,tbl);
1113: case COBJ:
1114: { Pptr r;
1115: // error('d',"cobj: ptr %t, ref %t",it->is_ptr(),it->is_ref());
1116: if (r=it->is_ptr_or_ref()) {
1117: Pchecked = 1;
1118: TOK b = p->base; // could be REF
1119: TOK bb = r->base;
1120: if (b==RPTR) p->base = PTR;
1121: if (bb==RPTR) r->base = PTR;
1122: if (p->check(r,ASSIGN)) {
1123: if ( cc && cc->nof &&
1124: Pfct(cc->nof->tp)->f_const &&
1125: cc->c_this == init )
1126: error("%n const: assignment of%n (%t) to%t",cc->nof,init,init->tp,p);
1127: else
1128: error("no standard conversion of %t to %t",init->tp,p);
1129: }
1130: p->base = b;
1131: r->base = bb;
1132: Pexpr cp = cast_cptr(Pclass(Pbase(pit)->b_name->tp),init,tbl,0);
1133: if (cp != init) {
1134: PERM(p); // or else it will be deleted twice!
1135: return new cast(p,cp);
1136: }
1137: }
1138: // no break
1139: }
1140: default:
1141: return init;
1142: }
1143: }
1144:
1145: static Pname Lcoerce, Rcoerce;
1146: extern int suppress_error;
1147:
1148: int try_to_demote(TOK oper, Ptype t1, Ptype t2)
1149: /*
1150: look at t1 and t2 and see if there are ``demotions'' of t1 and/or t2
1151: so that ``t1 oper t2'' can be made legal
1152:
1153: return 0 is not
1154: 1 if there is exactly one way
1155: >1 if there is more than one way (if in doubt return 2)
1156: */
1157: {
1158: //error('d',"try_to_demote(%k : %t : %t)",oper,t1,t2);
1159:
1160: Pname n1 = t1 ? t1->is_cl_obj() : 0;
1161: Pclass c1 = n1 ? Pclass(n1->tp) : 0;
1162: Pname n2 = t2 ? t2->is_cl_obj() : 0;
1163: Pclass c2 = n2 ? Pclass(n2->tp) : 0;
1164:
1165: Ptype lt = t1;
1166: Ptype rt = t2;
1167:
1168: Lcoerce = Rcoerce = 0;
1169:
1170: // if (oper == DOT) return 0;
1171:
1172: if (c1)
1173: switch (oper) {
1174: case ASSIGN:
1175: case ASPLUS:
1176: case ASMINUS:
1177: case ASMUL:
1178: case ASDIV:
1179: case ASMOD:
1180: case ASAND:
1181: case ASOR:
1182: case ASER:
1183: case ASLS:
1184: case ASRS: // don't coerce left hand side of assignment
1185: // c1 = 0;
1186: if (c1->memtbl->look("__as",0)) return 0;
1187: }
1188: else
1189: switch (oper) {
1190: case ADDROF:
1191: case INCR:
1192: case DECR: // don't coerce unary requiring an lval
1193: return 0;
1194: }
1195:
1196: if (c1) {
1197: //error('d',"c1 %t",c1);
1198: for (Pname on1 = c1->conv; on1; on1=on1->n_list) {
1199: // error( 'd', "on1: %s tp: %k", on1->string, on1->tp->base );
1200: Pfct f = on1->get_fct();
1201: lt = f->returns;
1202: Pname cn = lt->is_cl_obj();
1203:
1204: if (cn && (Lcoerce==0 || Lcoerce->tp->check(f,0))) {
1205: Pclass cl = Pclass(cn->tp);
1206: Pname n = cl->has_oper(oper);
1207: if (n == 0) continue;
1208: // while (n->base==REF || n->base==MDOT) n=Pname(n->mem) ;
1209: Pfct nf = Pfct(n->tp);
1210: // error( 'd', "nf: %d %k", nf->base, nf->base );
1211: if (nf->base == FCT) {
1212: if (nf->nargs==1
1213: && t2
1214: && (nf->argtype->tp->check(t2,ARG)==0
1215: || can_coerce(nf->argtype->tp,t2)==1)
1216: ) {
1217: if (Lcoerce) return 2;
1218: Lcoerce = on1;
1219: }
1220: }
1221: else {
1222: for (Plist gl=Pgen(nf)->fct_list; gl; gl=gl->l) {
1223: Pfct nf = Pfct(gl->f->tp);
1224: if (nf->nargs==1
1225: && t2
1226: && (nf->argtype->tp->check(t2,ARG)==0
1227: || can_coerce(nf->argtype->tp,t2)==1)
1228: ) {
1229: if (Lcoerce) return 2;
1230: Lcoerce = on1;
1231: }
1232: }
1233: }
1234: continue;
1235: }
1236: //if (lt->is_cl_obj()) continue;
1237: if (c2) {
1238: //error('d',"c2 %t",c2);
1239: for (Pname on2 = c2->conv; on2; on2=on2->n_list) {
1240: Pfct f = on2->get_fct();
1241: rt = f->returns;
1242: if (rt->is_cl_obj()) continue;
1243:
1244: suppress_error = 1;
1245: int r1 = lt->kind(oper,0);
1246: int r2 = rt->kind(oper,0);
1247: if (np_promote(oper,r1,r2,lt,rt,1)!=any_type) {
1248: Pname sn = on1;
1249: if (Lcoerce) {
1250: Pname tn = really_dominate(
1251: Lcoerce,
1252: on1,
1253: const_obj1
1254: );
1255: if(!tn) {
1256: suppress_error = 0;
1257: return 2;
1258: }
1259: else sn = tn;
1260: }
1261: Lcoerce = sn;
1262: Rcoerce = on2;
1263:
1264: }
1265: suppress_error = 0;
1266: }
1267:
1268: }
1269: else if (rt) {
1270: suppress_error = 1;
1271: int r1 = lt->kind(oper,0);
1272: int r2 = rt->kind(oper,0);
1273: if (np_promote(oper,r1,r2,lt,rt,1)!=any_type) {
1274: Pname sn = on1;
1275: if (Lcoerce) {
1276: Pname tn = really_dominate(
1277: Lcoerce,
1278: on1,
1279: const_obj1
1280: );
1281: if(!tn) {
1282: suppress_error = 0;
1283: return 2;
1284: }
1285: else sn = tn;
1286: }
1287: Lcoerce = sn;
1288: }
1289: suppress_error = 0;
1290: }
1291: else {
1292: Pname sn = on1;
1293: if (Lcoerce) {
1294: Pname tn = really_dominate(
1295: Lcoerce,
1296: on1,
1297: const_obj1
1298: );
1299: if(!tn) return 2;
1300: else sn = tn;
1301: }
1302: Lcoerce = sn;
1303: }
1304: }
1305: }
1306: else if (c2) {
1307: //error('d',"c2 %n",c2);
1308: for (Pname on = c2->conv; on; on=on->n_list) {
1309: Pfct f = on->get_fct();
1310: rt = f->returns;
1311: Pname cn = rt->is_cl_obj();
1312: //error('d',"cn %n",cn);
1313: if (cn && (Rcoerce==0 || Rcoerce->tp->check(f,0))) {
1314: Pclass cl = Pclass(cn->tp);
1315: Pname n = cl->has_oper(oper);
1316: if (n == 0) continue;
1317:
1318: // while (n->base==REF || n->base==MDOT) n=Pname(n->mem);
1319: Pfct nf = Pfct(n->tp);
1320: if (nf->base == FCT) {
1321: if (nf->nargs == 0) {
1322: if (Lcoerce || Rcoerce) return 2;
1323: Rcoerce = on;
1324: }
1325: }
1326: else {
1327: for (Plist gl=Pgen(nf)->fct_list; gl; gl=gl->l)
1328: if (Pfct(gl->f->tp)->nargs == 0) {
1329: if (Lcoerce || Rcoerce) return 2;
1330: Rcoerce = on;
1331: }
1332: }
1333: continue;
1334: }
1335: //if (rt->is_cl_obj()) continue;
1336: if( lt ) {
1337: suppress_error = 1;
1338: int r1 = lt->kind(oper,0);
1339: int r2 = rt->kind(oper,0);
1340:
1341: if (np_promote(oper,r1,r2,lt,rt,1)!=any_type) {
1342: Pname sn = on;
1343: if (Lcoerce || Rcoerce) {
1344: Pname tn = really_dominate(
1345: Rcoerce,
1346: on,
1347: const_obj2
1348: );
1349: if(!tn) {
1350: suppress_error = 0;
1351: return 2;
1352: }
1353: else sn = tn;
1354: }
1355: Rcoerce = sn;
1356: }
1357: suppress_error = 0;
1358: }
1359: }
1360: }
1361:
1362: //error('d',"->%d || %d",Lcoerce,Rcoerce);
1363: return (Lcoerce || Rcoerce);
1364: }
1365:
1366: Pexpr expr::try_to_overload(Ptable tbl)
1367: {
1368:
1369: //error('d',"try_to_overload %k %d",base,base);
1370: const int STD = 3;
1371: Pname n1 = 0;
1372: Ptype t1 = 0;
1373: const_obj1 = 0;
1374: const_obj2 = 0;
1375:
1376: if (e1) {
1377: t1 = e1->tp;
1378: Ptype tpx = t1->skiptypedefs();
1379: n1 = tpx->is_cl_obj();
1380: const_obj1 = t1->tconst();
1381:
1382: Pexpr ee = e1;
1383: while (ee && (ee->base==DOT || ee->base==REF)) {
1384: Pexpr m = ee->mem;
1385: if ( ee->base==REF && m->tp && m->tp->is_ptr())
1386: break;
1387: ee = ee->e1;
1388: }
1389: if (ee) {
1390: int tc;
1391: Ptype ttt = ee->tp;
1392: switch (e1->base) {
1393: case REF:
1394: Pptr p = ttt?ttt->is_ptr():0;
1395: if (p && p->typ->tconst())
1396: const_obj1 = 1;
1397: break;
1398: case DOT:
1399: tc = ttt ? ttt->tconst() : 0;
1400: if (ttt && tc && (!strict_opt || tc!=2))
1401: const_obj1 = 1;
1402: }
1403: }
1404: }
1405:
1406: TOK bb = base;
1407: switch (bb) {
1408: case DEREF:
1409: if (e2 == 0) bb = MUL;
1410: // no break;
1411: case CALL:
1412: case G_CALL:
1413: if (n1 == 0) return 0; // ignore type of argument list
1414: }
1415:
1416: Pname n2 = 0;
1417: Ptype t2 = 0;
1418:
1419: if (e2 && e2->base!=ELIST) {
1420: t2 = e2->tp;
1421: Ptype tpx = t2->skiptypedefs();
1422: n2 = tpx->is_cl_obj();
1423: const_obj2 = t2->tconst();
1424: Pexpr ee = e2;
1425: while (ee && (ee->base==DOT || ee->base==REF)) {
1426: Pexpr m = ee->mem;
1427: if ( ee->base==REF && m->tp && m->tp->is_ptr())
1428: break;
1429: ee = ee->e1;
1430: }
1431: if (ee) {
1432: int tc;
1433: Ptype ttt = ee->tp;
1434: switch (e2->base) {
1435: case REF:
1436: Pptr p = ttt?ttt->is_ptr():0;
1437: if (p && p->typ->tconst())
1438: const_obj2 = 1;
1439: break;
1440: case DOT:
1441: tc = ttt ? ttt->tconst() : 0;
1442: if (ttt && tc && (!strict_opt || tc!=2))
1443: const_obj2 = 1;
1444: }
1445: }
1446: }
1447:
1448: if (n1==0 && n2==0) return 0;
1449: if (n1 && n1->tp == 0) return 0; // make_assign() fudge
1450: // error('d',"e1: %k e2: %k", e1?e1->base:0, e2?e2->base:0 );
1451: // error('d',"t1 %t t2 %t",t1,t2);
1452: // error('d',"n1 %n n2 %n",n1,n2);
1453: /* first try for non-member function: op(e1,e2) or op(e2) or op(e1) */
1454: Pexpr oe2 = e2;
1455: Pexpr ee2 = (e2 && e2->base!=ELIST) ? e2 = new expr(ELIST,e2,0) : 0;
1456: Pexpr ee1 = e1 ? new expr(ELIST,e1,e2) : ee2;
1457: char* obb = oper_name(bb);
1458: Pname gname = tbl->look(obb,0);
1459: // if necessary check for ambiguities
1460: int go = gname ? over_call(gname,ee1) : 0;
1461: //error('d',"go %d",go);
1462: if (go) gname = Nover;
1463:
1464: if (n1) {
1465: if (bb == ASSIGN) {
1466: Pclass c1 = Pclass(n1->tp);
1467: //error('d',"look %k %d",bb,c1->memtbl->look(obb,0));
1468: if (c1->memtbl->look(obb,0)==0) {
1469: Pclass bcl = c1->baselist?c1->baselist->bclass:0;
1470: if (n2==0
1471: || (Pclass(n2->tp)!=c1
1472: && Pclass(n2->tp)->has_base(c1)==0)) {
1473: // if legal, a=1 can be optimized to a.ctor(1)
1474: if (STD < go) goto glob;
1475: return 0;
1476: }
1477:
1478: if (bcl
1479: && c1->obj_size!=bcl->obj_size
1480: && bcl->memtbl->look(obb,0)) {
1481: // cannot inherit from smaller base class
1482: // make_assignment(n1);
1483: // return try_to_overload(tbl);
1484: goto mkas;
1485: }
1486:
1487: if (c1->c_xref&(C_VBASE|C_VPTR|C_ASS)) {
1488: // make operator=() if
1489: // no base (shouldn't happen
1490: // different (smaller) sized base
1491: // two bases
1492: mkas:
1493: if (STD < go) goto glob;
1494: // make_assignment(n1);
1495: // return try_to_overload(tbl);
1496: return make_assignment(n1) ? try_to_overload(tbl) : 0;
1497: }
1498: // error('d',"n2 %n",n2);
1499: // if (n2 && Pclass(n2->tp)==c1)
1500: return 0;
1501: }
1502: // now take care of other assignments,
1503: }
1504:
1505: int dbconv = 0;
1506: Pclass ccl = Pclass(n1->tp);
1507: // Pexpr mn = Pclass(n1->tp)->memtbl->look(obb,0);
1508: Pexpr mn = ccl->memtbl->look(obb,0);
1509: // error('d', "tcl %d %t cl %d %t", tcl, tcl, ccl, ccl);
1510: if(strcmp(obb,"__as")) {
1511: tcl = ccl; // ugh!!!
1512: if(!mn) dbconv = STD;
1513: }
1514: // tcl = ccl; // ugh!!!
1515: mn = ccl->find_name(obb,0);
1516:
1517: Pname mname = Pname(mn);
1518: // error('d',"mn %n %d %k %s",mname,mn,mn?mn->base:0,obb);
1519: if (mname == 0) goto glob;
1520:
1521: zaq:
1522: switch (mname->base) {
1523: case REF:
1524: case MDOT:
1525: mname = Pname(Pexpr(mname)->mem);
1526: goto zaq;
1527: }
1528:
1529: int mo = over_call(mname,e2);
1530: int smo = mo;
1531: if(mo && dbconv && mo >= dbconv) mo = dbconv;
1532: //error('d',"mo %d (go %d)",mo,go);
1533: if (mo==0 || mo<go)
1534: goto glob;
1535: else if (mo && mo==go) {
1536: //error('d',"t1 %t t2 %t",t1,t2);
1537: if (gname->tp->base == OVERLOAD) { // find right version
1538: for (Plist l = Pgen(gname->tp)->fct_list; l; l=l->l) {
1539: Pname n = l->f;
1540: int x = over_call(n,ee1);
1541: if (x == go) {
1542: gname = n;
1543: break;
1544: }
1545: }
1546: }
1547: //error('d',"gname %n: %t",gname,gname->tp);
1548: Pname aa = Pfct(gname->tp)->argtype;
1549: Pptr p;
1550: Ptype gt1 = aa->tp;
1551: if (p = gt1->is_ref()) gt1 = p->typ;
1552: Ptype gt2 = aa->n_list->tp;
1553: //error('d',"gt1 %t gt2 %t",gt1,gt2);
1554: if (mname->tp->base == OVERLOAD) { // find right version
1555: for (Plist l = Pgen(mname->tp)->fct_list; l; l=l->l) {
1556: Pname n = l->f;
1557: int x = over_call(n,e2);
1558: if (x == smo) {
1559: mname = n;
1560: break;
1561: }
1562: }
1563: }
1564: //error('d',"mname %n: %t",mname,mname->tp);
1565: Ptype mt1 = Pfct(mname->tp)->f_this->tp;
1566: mt1 = Pptr(mt1)->typ;
1567: Ptype mt2 = Pfct(mname->tp)->argtype->tp;
1568: //error('d',"mt1 %t mt2 %t",mt1,mt2);
1569: Pname mm = new name;
1570: Pname a1 = new name;
1571: a1->tp = mt1;
1572: Pname a2 = new name;
1573: a2->tp = mt2;
1574: a1->n_list = a2;
1575: mm->tp = new fct(void_type,a1,2);
1576: Pname gg = new name;
1577: Pname a3 = new name;
1578: a3->tp = gt1;
1579: Pname a4 = new name;
1580: a4->tp = gt2;
1581: a3->n_list = a4;
1582: gg->tp = new fct(void_type,a3,1);
1583: aa = dominate(gg,mm,ee1,0);
1584: delete a1;
1585: delete a2;
1586: delete a3;
1587: delete a4;
1588: DEL( gg->tp );
1589: DEL( mm->tp );
1590: //delete gg->tp;
1591: //delete mm->tp;
1592: if (aa == 0) {
1593: delete gg;
1594: delete mm;
1595: error("ambiguous operandTs%n and%t for%k",n1,t2,bb);
1596: tp = any_type;
1597: return this;
1598: }
1599: else if (aa == gg) {
1600: delete gg;
1601: delete mm;
1602: goto glob;
1603: }
1604: delete gg;
1605: delete mm;
1606: }
1607: else if (mo < STD) { // user-defined conversion user
1608:
1609: if (try_to_demote(bb,t1,t2))
1610: error("ambiguous use of overloaded%k",bb);
1611: }
1612:
1613: base = G_CALL; // e1.op(e2) or e1.op()
1614: Pname xx = new name(mname->string); // do another lookup
1615: // . suppresses virtual
1616: e1 = new ref(DOT,e1,xx);
1617: if (ee1) delete ee1;
1618: return typ(tbl);
1619: }
1620:
1621: if (n2 && e1==0) { /* look for unary operator */
1622: suppress_error++;
1623: Pexpr mn = Pclass(n2->tp)->find_name(obb,0);
1624: suppress_error--;
1625: Pname mname = Pname(mn);
1626: if (mname == 0) goto glob;
1627: zaqq:
1628: switch (mname->base) {
1629: case REF:
1630: case MDOT:
1631: mname = Pname(Pexpr(mname)->mem);
1632: goto zaqq;
1633: }
1634:
1635: switch (mname->n_scope) {
1636: default: goto glob;
1637: case 0:
1638: case PUBLIC: break; // try e2.op()
1639: }
1640:
1641: int mo = over_call(mname,0);
1642: //error('d',"e2 mo %d (go %d)",mo,go);
1643: if (mo==0 || mo<go)
1644: goto glob;
1645: else if (mo==go) {
1646: error("ambiguous operandT%n for%k",n2,bb);
1647: tp = any_type;
1648: return this;
1649: }
1650: else if (mo < STD) { // user-defined conversion user
1651: if (try_to_demote(bb,t1,t2))
1652: error("ambiguous use of overloaded%k",bb);
1653: }
1654: base = G_CALL; // e2.op()
1655: Pname xx = new name(Nover->string); // do another lookup
1656: // . suppresses virtual
1657: e1 = new ref(DOT,oe2,xx);
1658: e2 = 0;
1659: if (ee2) delete ee2;
1660: if (ee1 && ee1!=ee2) delete ee1;
1661: return typ(tbl);
1662: }
1663:
1664: glob:
1665: //error('d',"glob %d",go);
1666:
1667: if (go) {
1668: if (go < STD) { // user-defined conversion necessary => binary
1669: if (try_to_demote(bb,t1,t2))
1670: error("ambiguous use of overloaded%k: %t and %t",bb,t1,t2);
1671: }
1672:
1673: base = gname->n_table == gtbl ? G_CALL : CALL;
1674: //error('d',"gname %n %t",gname,gname->tp);
1675: e1 = new name(gname->string);
1676: // if global scope, look only for globals
1677: if(gname->n_table == gtbl) Pname(e1)->n_qualifier = sta_name;
1678: e2 = ee1;
1679: return typ(tbl);
1680: }
1681:
1682: if (ee2) delete ee2;
1683: if (ee1 && ee1!=ee2) delete ee1;
1684: e2 = oe2;
1685:
1686: //error('d',"bb %d %k",bb,bb);
1687: switch (bb) {
1688: case CM:
1689: case G_CM:
1690: case G_ADDROF:
1691: return 0;
1692: case ASSIGN:
1693: if (n1
1694: && n2
1695: && (n1->tp==n2->tp || Pclass(n2->tp)->has_base(Pclass(n1->tp)))) {
1696: if (make_assignment(n1))
1697: return try_to_overload(tbl);
1698: else
1699: return 0;
1700: }
1701: case DEREF:
1702: case CALL:
1703: if (n1 == 0) break;
1704:
1705: default: /* look for conversions to basic types */
1706: if (n1
1707: && Pclass(n1->tp)->conv
1708: && (bb==ANDAND || bb==OROR)) {
1709: e1 = check_cond(e1,bb,tbl);
1710: return 0;
1711: }
1712:
1713: if (n2
1714: && Pclass(n2->tp)->conv
1715: && (bb==ANDAND || bb==OROR || bb==NOT ||
1716: bb==UMINUS || bb==UPLUS || bb==COMPL)) {
1717: e2 = check_cond(e2,bb,tbl);
1718: return 0;
1719: }
1720:
1721: // error( 'd', "bb: %k t1: %k t2: %k", bb, t1?t1->base:0, t2?t2->base:0 );
1722: switch (try_to_demote(bb,t1,t2)) {
1723: default:
1724: if (Lcoerce) error("ambiguous conversion of%n",n1);
1725: if (Rcoerce) error("ambiguous conversion of%n",n2);
1726: case 0:
1727: break;
1728: case 1:
1729: if (Lcoerce) {
1730: Pname xx = new name(Lcoerce->string);
1731: Pref r = new ref(DOT,e1,xx);
1732: e1 = new expr(G_CALL,r,0);
1733: }
1734:
1735: if (Rcoerce) {
1736: Pname xx = new name(Rcoerce->string);
1737: Pref r = new ref(DOT,e2,xx);
1738: e2 = new expr(G_CALL,r,0);
1739: }
1740: return typ(tbl);
1741: }
1742:
1743: switch (bb) {
1744: case CM:
1745: case ADDROF: // has legal built-in meaning
1746: return 0;
1747: }
1748:
1749: if (t1 && t2)
1750: error("bad operandTs%t%t for%k",t1,t2,bb);
1751: else
1752: error("bad operandT%t for%k",t1?t1:t2,bb);
1753:
1754: tp = any_type;
1755: return this;
1756: }
1757:
1758: return 0;
1759: }
1760:
1761: Pexpr cast_cptr(Pclass ccl, Pexpr ee, Ptable tbl, int real_cast)
1762: /*
1763: "ee" is being cast to pointer object of class "ccl"
1764: if necessary modify "ee"
1765: */
1766: {
1767:
1768: // Ptype etp = ee->tp;
1769: // error('d',"cast_cptr %k ccl %t ee->tp %t",ee->tp->base,ccl,ee->tp);
1770: // if (etp->base!=PTR && etp->base!=RPTR) return ee;
1771: Ptype etp = ee->tp->is_ptr_or_ref();
1772: if (etp == 0) return ee;
1773:
1774: Pname on = Pptr(etp)->typ->is_cl_obj();
1775: if (on == 0) return ee;
1776:
1777: Pclass ocl = Pclass(on->tp);
1778: if (ocl==ccl || ccl==0 || ocl==0) return ee;
1779:
1780: // error('d',"cast_cptr %t(%t) real %d",ccl,ocl,real_cast);
1781: int oo = 0;
1782: Pexpr r = 0;
1783:
1784: if (ocl->baselist
1785: && (ocl->baselist->bclass!=ccl || ocl->baselist->base!=NAME)) {
1786: // casting derived to second or virtual base?
1787: Nptr = 0;
1788: Nvis = 0;
1789: Nalloc_base = 0;
1790: vcllist->clear();
1791: vcllist=0;
1792: int x = is_unique_base(ocl,ccl->string,0);
1793: if (Nvis) {
1794: if (real_cast==0)
1795: error("cast:%n* ->B%t*; privateBC",on,ccl);
1796: else if (warning_opt)
1797: error('w',"cast:%n* ->B%t*; privateBC",on,ccl);
1798: real_cast = 1; // suppress further error mesages
1799: Nvis = 0;
1800: }
1801:
1802: switch (x) {
1803: default:
1804: error("cast:%n* ->B%t*;%t isB more than once",on,ccl,ccl);
1805: case 0: // unrelated;
1806: break;
1807: case 1:
1808: oo = Noffset;
1809: break;
1810: }
1811:
1812: if (Nptr) { // => ee?Nptr:0
1813: if (ocl->c_body==1) ocl->dcl_print(0);
1814: Nptr->mem = ee; // ee->Pbase_class
1815: if ( Nalloc_base ) {
1816: // error('d', "cast_cptr: nalloc_base: %s", Nalloc_base);
1817: Nptr->i1 = 5;
1818: Nptr->string4 = new char[strlen(Nalloc_base)];
1819: strcpy(Nptr->string4,Nalloc_base);
1820: Nalloc_base = 0;
1821: }
1822: else Nptr->i1 = 3;
1823:
1824: if (ee->base==ADDROF || ee->base==G_ADDROF)
1825: ee = Nptr;
1826: else {
1827: Pexpr p = new expr(QUEST,Nptr,zero);
1828: nin = 1;
1829: if (ee->not_simple()) { // need temp
1830: Ptype t = ee->tp;
1831: Pname pp = make_tmp('N',t,tbl);
1832: Pname(pp)->n_assigned_to = 1;
1833: ee = new expr(ASSIGN,pp,ee);
1834: ee->tp = t;
1835: Nptr->mem = pp;
1836: }
1837: nin = 0;
1838: p->cond = ee;
1839: p->tp = ee->tp;
1840: ee = p;
1841: }
1842: }
1843: }
1844:
1845: if (ccl->baselist
1846: && (ccl->baselist->bclass!=ocl || ccl->baselist->base!=NAME)) {
1847: // casting second or virtual base to derived?
1848: Nptr = 0;
1849: vcllist->clear();
1850: vcllist=0;
1851: int x = is_unique_base(ccl,ocl->string,0);
1852: switch (x) {
1853: default:
1854: error("cast:%n* ->derived%t*;%n isB more than once",on,ccl,on);
1855: case 0: // unrelated;
1856: break;
1857: case 1:
1858: oo = -Noffset;
1859: if (Nptr)
1860: error("cast:%n* ->derived%t*;%n is virtualB",on,ccl,on);
1861: break;
1862: }
1863: Nvis = 0; // visibility no concern when converting from base to derived
1864: }
1865: // error('d',"oo %d ee %k",oo,ee->base);
1866: if (oo) { // => ee?ee+offset:0
1867: if (ee->base==ADDROF || ee->base==G_ADDROF)
1868: ee = rptr(ee->tp,ee,oo);
1869: else {
1870: Pexpr p;
1871: nin = 1;
1872: if (ee->not_simple()) { // need temp
1873: Ptype t = ee->base==MDOT?ee->mem->tp:ee->tp;
1874: Pname pp = make_tmp('M',t,tbl);
1875: Pname(pp)->n_assigned_to = 1;
1876: ee = new expr(ASSIGN,pp,ee);
1877: ee->tp = t;
1878: p = rptr(t,pp,oo);
1879: }
1880: else
1881: p = rptr(ee->base==MDOT?ee->mem->tp:ee->tp,ee,oo);
1882: nin = 0;
1883: Pexpr pp = new expr(QUEST,p,zero);
1884: pp->tp = ee->tp;
1885: pp->cond = ee;
1886: ee = pp;
1887: }
1888: }
1889:
1890: Nvis = 0; // Nvis set by has_base()
1891: if (ocl->has_base(ccl) && Nvis) {
1892: if (real_cast==0)
1893: error("cast:%n* ->B%t*; privateBC",on,ccl);
1894: else if (warning_opt)
1895: error('w',"cast:%n* ->B%t*; privateBC",on,ccl);
1896: Nvis = 0;
1897: }
1898:
1899: // error('d',"return %d %k %t",ee,ee->base,ee->tp);
1900: return ee;
1901: }
1902:
1903: Pexpr expr::donew(Ptable tbl)
1904: {
1905: Ptype tt = tp2;
1906: Ptype tpx = tt;
1907: bit v = 0;
1908: bit old = new_type;
1909: int init = 0; // non-constructor initialization
1910: new_type = 1;
1911:
1912: tt->dcl(tbl);
1913: new_type = old;
1914: // error('d',"donew %d %d (%k) tt %t",e1,e2,e2?e2->base:0,tt);
1915: if (e1) e1 = e1->typ(tbl);
1916: if (e2) e2 = e2->typ(tbl);
1917: ll:
1918: //error('d',"ll %d",tt->base);
1919: switch (tt->base) {
1920: default:
1921: if ( e1) {
1922: if (v) {
1923: error("Ir for array created using \"new\"");
1924: break;
1925: }
1926: init = 1;
1927: }
1928: // if (e1) {
1929: // error("Ir for nonCO created using \"new\"");
1930: // e1 = 0;
1931: // }
1932: break;
1933: case VEC:
1934: if (v && Pvec(tt)->dim) error("only 1st array dimension can be non-constant");
1935: if (Pvec(tt)->size==0 && Pvec(tt)->dim==0) error("array dimension missing in `new'");
1936: // if (Pvec(tt)->dim==zero) {
1937: // Pvec(tt)->size = 0;
1938: // Pvec(tt)->dim = 0;
1939: // }
1940: v++;
1941: tt = Pvec(tt)->typ;
1942: goto ll;
1943: case TYPE:
1944: tt = Pbase(tt)->b_name->tp;
1945: goto ll;
1946: case VOID:
1947: error("badT for `new': void");
1948: break;
1949: case COBJ:
1950: { Pname cn = Pbase(tt)->b_name;
1951: Pclass cl = Pclass(cn->tp);
1952: Pname icn = 0;
1953:
1954: if ( e1 ) { // arguments
1955: if ( e1->e2 == 0 && e1->base == ELIST ) {
1956: e1 = e1->e1;
1957: e1 = e1->typ(tbl);
1958: }
1959: icn = (e1->base!=ELIST)?e1->tp->is_cl_obj():0;
1960: }
1961: //Pname icn = (e1 && e1->base!=ELIST)?e1->tp->is_cl_obj() : 0;
1962:
1963: Pclass icl = icn ? Pclass(icn->tp) : 0;
1964:
1965: if (cl->c_abstract) {
1966: error("`new' of abstractC%t",cl);
1967: break;
1968: }
1969:
1970: if (v && e1) {
1971: error("Ir for array ofCO created using \"new\"");
1972: break;
1973: }
1974:
1975: if ((cl->defined&(DEFINED|SIMPLIFIED)) == 0) {
1976: error("new%n;%n isU",cn,cn);
1977: break;
1978: }
1979:
1980: Pname ctor = cl->has_ctor();
1981:
1982: if (ctor) {
1983: if (v) {
1984: Pname ic;
1985: if ((ic = cl->has_ictor())==0) {
1986: error("array ofC%n that does not have aK taking noAs",cn);
1987: break;
1988: }
1989:
1990: if (Pfct(ic->tp)->nargs) {
1991: error("defaultAs forK for array ofC%n",cn);
1992: break;
1993: }
1994: }
1995:
1996: if (icl
1997: && cl->has_itor()==0 // incomplete:
1998: // what if X(Y&) exists
1999: // for class Y : X ?
2000: && (icl==cl || icl->has_base(cl))) {
2001: init = 1;
2002: break;
2003: }
2004: e1 = call_ctor(tbl,0,ctor,e1);
2005: }
2006: else if (e1) {
2007: if (icl==cl || icl->has_base(cl))
2008: init = 1;
2009: else
2010: error("new%n(As ); %n does not have aK",cn,cn);
2011: }
2012: }
2013: }
2014:
2015: if (init) {
2016: Pname tmp = make_tmp('N',tt->addrof(),tbl);
2017: e1 = e1->typ(tbl);
2018: if (tt->check(e1->tp,ASSIGN))
2019: error("badIrT %t for new operator (%t X)",e1->tp,tt);
2020: e1 = new expr(0,tmp,e1);
2021: tmp->assign();
2022: }
2023:
2024: // tp = (v) ? tpx : tpx->addrof();
2025: switch (v) {
2026: case 0:
2027: tp = tpx->addrof();
2028: break;
2029: case 1:
2030: tp = tpx;
2031: break;
2032: default:
2033: tp = tpx;
2034: }
2035: //error('d',"donew(%d) -> %t",v,tp);
2036: return this;
2037: }
2038:
2039: static is_dataMemPtr( Pexpr ee )
2040: /* this is utterly implementation dependent
2041: * called by expr::lval to determine
2042: * const objects bounds to pointers to data members
2043: */
2044: {
2045: Pexpr te = ee->e1;
2046: if ( te == 0 ) return 0;
2047: if ( te->base != PLUS ) return 0;
2048: if ( (te = te->e2) == 0 ) return 0;
2049: if ( te->base != MINUS ) return 0;
2050: if ( (te = te->e1) == 0 ) return 0;
2051: if ( te->base != CAST ) return 0;
2052: if ( (te = te->e1) == 0 ) return 0;
2053: if ( te->tp->base != PTR ) return 0;
2054: if ( Pptr(te->tp)->memof == 0 ) return 0;
2055: return 1;
2056: }
2057:
2058: Pname dominate(Pname n1, Pname n2, Pexpr arg, int const_obj)
2059: /*
2060: the two functions n1 and n2 are equal after the intersect
2061: rule is applied. Does the one dominate the other in terms
2062: of const?
2063:
2064: If so return it, otherwise return 0;
2065: */
2066: {
2067: Pname res = 0;
2068:
2069: Pfct f1 = Pfct(n1->tp);
2070: Pfct f2 = Pfct(n2->tp);
2071:
2072: Pname a1 = f1->argtype;
2073: Pname a2 = f2->argtype;
2074: Pexpr e = arg;
2075: //error('d',"dominate: %n %t %t e %d",n1,f1,f2,e);
2076:
2077: if (e == 0) {
2078: if (const_obj) {
2079: if (f1->f_const && f2->f_const==0) return n1;
2080: if (f2->f_const && f1->f_const==0) return n2;
2081: }
2082: else {
2083: if (f1->f_const==0 && f2->f_const) return n1;
2084: if (f2->f_const==0 && f1->f_const) return n2;
2085: }
2086: return 0;
2087: }
2088:
2089: for(; a1 && a2 && e; a1 = a1->n_list, a2 = a2->n_list, e = e->e2) {
2090: Ptype t1 = a1->tp;
2091: Ptype t2 = a2->tp;
2092: Ptype at = e->e1->tp;
2093: //error('d',"t1 %t t2 %t at %t",t1,t2,at);
2094: if (t1==t2 || t1->check(t2,0)==0 )
2095: continue;
2096: Pptr r1 = t1->is_ref();
2097: Pptr r2 = t2->is_ref();
2098: //error('d',"const_problem %t %t %t %d",t1,t2,at,const_problem);
2099: if (const_problem) { // t1 and t1 differs only in const
2100: Pname rr;
2101: if (at->check(t1,0)==0 && const_problem==0) {
2102: if (t1->is_ptr())
2103: rr = n1;
2104: else
2105: goto nc;
2106: }
2107: else if (at->check(t2,0)==0 && const_problem==0) {
2108: if (t2->is_ptr())
2109: rr = n2;
2110: else
2111: goto nc;
2112: }
2113: else if (r1 && r1->typ->check(at,0)==0 && const_problem==0)
2114: rr = n1;
2115: else if (r2 && r2->typ->check(at,0)==0 && const_problem==0)
2116: rr = n2;
2117: else
2118: goto nc;
2119:
2120: if (res && res!=rr) return 0; // mutual dominace
2121: res = rr;
2122: continue; // identical
2123: }
2124: nc:
2125: if (r2 && (t1==r2 || t1->check(r2->typ,0)==0)) continue;
2126: if (r1 && (t2==r1 || t2->check(r1->typ,0)==0)) continue;
2127:
2128: Pname rr = 0;
2129: if (t1==at || exact1(a1,at)) {
2130: rr = n1;
2131: if(t2==at || exact1(a2,at))
2132: continue;
2133: }
2134: else if (t2==at || exact1(a2,at))
2135: rr = n2;
2136: else { // try integral promotion
2137: if (exact2(a1,at))
2138: rr = n1;
2139: if (exact2(a2,at)) {
2140: if (rr) rr = 0;
2141: else rr = n2;
2142: }
2143: }
2144: if (!rr) { // try standard conversions
2145: if (exact3(a1,at))
2146: rr = n1;
2147: if (exact3(a2,at)) {
2148: if (rr) rr = 0;
2149: else rr = n2;
2150: }
2151: }
2152: if (rr) {
2153: if (res && res!=rr) return 0; // mutual dominance
2154: res = rr;
2155: continue;
2156: }
2157:
2158: int r = pr_dominate(t1,t2);
2159: //error('d',"pr1 %d",r);
2160: if (r) {
2161: Pname rr = r==1?n1:n2;
2162: if (res && res!=rr) return 0; // mutual dominace
2163: res = rr;
2164: continue;
2165: }
2166:
2167: r = pr_dominate(t1,at);
2168: //error('d',"pr2 %d",r);
2169: if (r==2) {
2170: r = pr_dominate(t2,at);
2171: if (r!=2) res = n1;
2172: continue;
2173: }
2174:
2175: r = pr_dominate(t2,at);
2176: //error('d',"pr3 %d",r);
2177: if (r==2) {
2178: if (res && res!=n2) return 0; // mutual dominace
2179: res = n2;
2180: continue;
2181: }
2182:
2183: }
2184:
2185: if (e) {
2186: //error('d',"more args %t a1 %t a2 %t",e->e1->tp,a1?a1->tp:0,a2?a2->tp:0);
2187: int k1 = f1->nargs_known!=ELLIPSIS;
2188: int k2 = f2->nargs_known!=ELLIPSIS;
2189: if (a1 && a1->tp->check(e->e1->tp,ASSIGN)==0) return n1;
2190: if (a2 && a2->tp->check(e->e1->tp,ASSIGN)==0) return n2;
2191: if (k1 && k2) return 0;
2192: }
2193:
2194: if (a1==0 && a2 && a2->n_initializer==0) return 0;
2195: if (a2==0 && a1 && a1->n_initializer==0) return 0;
2196: if (res==0)
2197: if (const_obj) {
2198: if (f1->f_const && f2->f_const==0) return n1;
2199: if (f2->f_const && f1->f_const==0) return n2;
2200: }
2201: else {
2202: if (f1->f_const==0 && f2->f_const) return n1;
2203: if (f2->f_const==0 && f1->f_const) return n2;
2204: }
2205: //error('d'," -> %n %t",res,res?res->tp:0);
2206: return res;
2207: }
2208:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.