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