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