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