![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to typ.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 typ.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / ooptcfront |
1.1 root 1: /*ident "@(#)ctrans:src/typ.c 1.2.4.19" */
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: typ.c:
11:
12:
13: ***************************************************************************/
14:
15: #include "cfront.h"
16: #include "size.h"
17:
18: Pbase short_type;
19: Pbase int_type;
20: Pbase char_type;
21: Pbase long_type;
22:
23: Pbase uchar_type;
24: Pbase ushort_type;
25: Pbase uint_type;
26: Pbase ulong_type;
27:
28: Pbase zero_type;
29: Pbase float_type;
30: Pbase double_type;
31: Pbase ldouble_type;
32: Pbase void_type;
33: Pbase any_type;
34:
35: Ptype Pint_type;
36: Ptype Pchar_type;
37: Ptype Pvoid_type;
38: Ptype Pfctvec_type;
39:
40: Ptable gtbl;
41: Ptable any_tbl;
42:
43: Pname Cdcl;
44: Pstmt Cstmt;
45:
46: bit new_type;
47: extern int suppress_error;
48:
49: void echeck(Ptype t1, Ptype t2)
50: /*
51: t1 is an enum, t2 is assigned to it
52: */
53: {
54: if (t1 == t2) return;
55:
56: //error('d',"echeck(%t,%t) %d %d",t1,t2,t1->base,t2->base);
57: //error('d',"se %d",suppress_error);
58: if (t1->base==EOBJ
59: && t2->base==EOBJ
60: && Pbase(t1)->b_name->tp == Pbase(t2)->b_name->tp) return;
61:
62: error(strict_opt?0:'w',"%t assigned to %t",t2,t1);
63: }
64:
65:
66: Ptype np_promote(TOK oper, TOK r1, TOK r2, Ptype t1, Ptype t2, TOK p)
67: /*
68: an arithmetic operator "oper" is applied to "t1" and "t2",
69: types t1 and t2 has been checked and belongs to catagories
70: "r1" and "r2", respectively:
71: A ANY
72: Z ZERO
73: I CHAR, SHORT, INT, LONG, FIELD, or EOBJ
74: F FLOAT DOUBLE LDOUBLE
75: P PTR (to something) or VEC (of something)
76: test for compatability of the operands,
77: if (p) return the promoted result type
78: */
79: {
80: if (r2 == 'A') return t1;
81:
82: //error('d',"promote(%t,%t,%k)",t1,t2,oper);
83: // if (r1!='P' && r2=='P' && t2->check(Pvoid_type,0)==0) {
84: // error("%k of %t",oper,Pvoid_type);
85: // return any_type;
86: // }
87:
88: switch (r1) {
89: case 'A': return t2;
90: case 'Z':
91: switch (r2) {
92: case 'Z': return int_type;
93: case 'I':
94: case 'F': return (p) ? Pbase(t2)->arit_conv(0) : 0;
95: case 'P': return t2;
96: default: error('i',"zero(%d)",r2);
97: }
98: case 'I':
99: switch (r2) {
100: case 'Z': t2 = 0;
101: case 'I':
102: case 'F': return (p) ? Pbase(t1)->arit_conv(Pbase(t2)) : 0;
103: case 'P': switch (oper) {
104: case PLUS:
105: case ASPLUS: break;
106: default: error("int%kP",oper); return any_type;
107: }
108: return t2;
109: case FCT: error("int%kF",oper); return any_type;
110: default: error('i',"int(%d)",r2); return any_type;
111: }
112: case 'F':
113: switch (r2) {
114: case 'Z': t2 = 0;
115: case 'I':
116: case 'F': return (p) ? Pbase(t1)->arit_conv(Pbase(t2)) : 0;
117: case 'P': error("float%kP",oper); return any_type;
118: case FCT: error("float%kF",oper); return any_type;
119: default: error('i',"float(%d)",r2); return any_type;
120: }
121: case 'P':
122: // if (t1->check(Pvoid_type,0)==0) {
123: // error("%k of %t",oper,Pvoid_type);
124: // return any_type;
125: // }
126:
127: switch (r2) {
128: case 'Z': return t1;
129: case 'I':
130: switch (oper) {
131: case PLUS:
132: case MINUS:
133: case ASPLUS:
134: case ASMINUS: break;
135: default: error("P%k int",oper); return any_type;
136: }
137: return t1;
138: case 'F': error("P%k float",oper); return any_type;
139: case 'P':
140: if (t1->check(t2,ASSIGN)) {
141: switch (oper) {
142: case EQ:
143: case NE:
144: case LE:
145: case GE:
146: case GT:
147: case LT:
148: case QUEST:
149: if (t2->check(t1,ASSIGN) == 0) goto zz;
150: }
151: error("T mismatch:%t %k%t",t1,oper,t2);
152: return any_type;
153: }
154: zz:
155: switch (oper) {
156: case MINUS:
157: case ASMINUS: return int_type;
158: case PLUS:
159: case ASPLUS: error("P +P"); return any_type;
160: default: return t1;
161: }
162: case FCT: return t1;
163: default: error('i',"P(%d)",r2);
164: }
165: case FCT:
166: error("F%k%t",oper,t2);
167: return any_type;
168: default:
169: error('i',"np_promote(%d,%d)",r1,r2);
170: }
171: }
172:
173: TOK type::kind(TOK oper, TOK v)
174: /* v == 'I' integral
175: 'N' numeric
176: 'P' numeric or pointer
177: */
178: {
179: Ptype t = this;
180: if (this == 0) error('i',"type::kind(): this==0");
181: xx:
182: switch (t->base) {
183: case ANY: return 'A';
184: case ZTYPE: return 'Z';
185: case FIELD:
186: case CHAR:
187: case SHORT:
188: case INT:
189: case LONG:
190: case EOBJ: return 'I';
191: case FLOAT:
192: case LDOUBLE:
193: case DOUBLE: if (v == 'I') error("float operand for %k",oper); return 'F';
194: case VEC:// if (v != 'P') error("V operand for %k",oper); return 'P';
195: case PTR: if (v != 'P') error("P operand for %k",oper);
196: switch (oper) {
197: case INCR:
198: case DECR:
199: case MINUS:
200: case PLUS:
201: case ASMINUS:
202: case ASPLUS:
203: if (t->base==PTR
204: && (Pptr(t)->memof || Pptr(t)->typ->base==FCT))
205: error("%t operand of%k",this,oper);
206: else
207: Pptr(t)->typ->tsizeof(); // get increment
208: break;
209: default:
210: if (t->base==PTR
211: && (Pptr(t)->memof || Pptr(t)->typ->base==FCT))
212: error("%t operand of%k",this,oper);
213: case ANDAND:
214: case OROR:
215: case ASSIGN:
216: case NE:
217: case EQ:
218: case IF:
219: case WHILE:
220: case DO:
221: case FOR:
222: case QUEST:
223: case NOT:
224: break;
225:
226: }
227: return 'P';
228: case RPTR: error("R operand for %k",oper); return 'A';
229: case TYPE: t = Pbase(t)->b_name->tp; goto xx;
230: case FCT: if (v != 'P') error("F operand for %k",oper); return FCT;
231: case OVERLOAD: error("overloaded operand for %k",oper); return 'A';
232: case CLASS:
233: case ENUM: error("%k operand for %k",base,oper); return 'A';
234: default: error("%t operand for %k",this,oper); return 'A';
235: }
236: }
237:
238: extern int catch_delete_bugs;
239:
240: void type::dcl(Ptable tbl)
241: /*
242: go through the type (list) and
243: (1) evaluate vector dimensions
244: (2) evaluate field sizes
245: (3) lookup struct tags, etc.
246: (4) handle implicit tag declarations
247: */
248: {
249: static arg_fudge;
250:
251: if(permanent == 3 && catch_delete_bugs) error ('i', "typ::dcl of a deleted expr.");
252:
253: Ptype t = this;
254:
255: if (this == 0) error('i',"T::dcl(this==0)");
256: if (tbl->base != TABLE) error('i',"T::dcl(%d)",tbl->base);
257:
258: xx:
259: //error('d',"type::dcl %k",t->base);
260: switch (t->base) {
261: case TYPE:
262: t = Pbase(t)->b_name->tp;
263: goto xx;
264: case PTR:
265: case RPTR:
266: { Pptr p = Pptr(t);
267: t = p->typ;
268: if (t->base == TYPE) {
269: Ptype tt = Pbase(t)->b_name->tp;
270: if (tt->base == FCT) p->typ = tt;
271: return;
272: }
273: goto xx;
274: }
275:
276: case VEC:
277: { Pvec v = Pvec(t);
278: Pexpr e = v->dim;
279: if (e) {
280: Ptype et;
281: v->dim = e = e->typ(tbl);
282: et = e->tp;
283: if (et->integral(0) == 'A') {
284: error("UN in array dimension");
285: }
286: else {
287: long i;
288: Neval = 0;
289: i = e->eval();
290: if (Neval == 0) {
291: if (largest_int<i)
292: error("array dimension too large");
293: v->size = int(i);
294: extern Ptable lcl_tbl;
295: // error( 'd', "lcl_tbl: %d", lcl_tbl );
296: if ( lcl_tbl == 0 )
297:
298: DEL(v->dim);
299: v->dim = 0;
300: }
301:
302: if (new_type) {
303: if (Neval)
304: ;
305: else if (i == 0)
306: v->dim = zero;
307: else if (i < 0) {
308: error("negative array dimension");
309: i = 1;
310: }
311: }
312: else {
313: if (Neval)
314: error("%s",Neval);
315: else if (i == 0)
316: error('w',"array dimension == 0");
317: else if (i < 0) {
318: error("negative array dimension");
319: i = 1;
320: }
321: }
322: }
323: }
324: t = v->typ;
325: llx:
326: switch (t->base) {
327: case TYPE:
328: t = Pbase(t)->b_name->tp;
329: goto llx;
330: case FCT:
331: v->typ = t;
332: break;
333: case VEC:
334: if (Pvec(t)->dim==0 && Pvec(t)->size==0) error("null dimension (something like [][] seen)");
335: if (arg_fudge) {
336: v->base = PTR; // X[12][10] ==> X(*)[10]
337: Pptr(v)->rdo = 0;
338: Pptr(v)->memof = 0;
339: }
340: }
341: goto xx;
342: }
343:
344: case FCT:
345: { Pfct f = Pfct(t);
346: void dargs(Pname, Pfct, Ptable);
347: if (f->argtype) dargs(0,f,tbl);
348: for (Pname n=f->argtype; n; n = n->n_list) {
349: arg_fudge++;
350: n->tp->dcl(tbl);
351: arg_fudge--;
352: }
353: Pname cn = f->returns->is_cl_obj();
354: if (cn && Pclass(cn->tp)->has_itor())
355: make_res(f);
356: else if (f->f_this == 0)
357: f->f_args = f->argtype;
358: t = f->returns;
359: goto xx;
360: }
361:
362: case FIELD:
363: { Pbase f = Pbase(t);
364: Pexpr e = Pexpr(f->b_name);
365: long i;
366: Ptype et;
367: e = e->typ(tbl);
368: f->b_name = Pname(e);
369: et = e->tp;
370: if (et->integral(0) == 'A') {
371: error("UN in field size");
372: i = 1;
373: }
374: else {
375: Neval = 0;
376: i = e->eval();
377: if (Neval)
378: error("%s",Neval);
379: else if (i < 0) {
380: error("negative field size");
381: i = 1;
382: }
383: else if (f->b_fieldtype->tsizeof()*BI_IN_BYTE < i)
384: error("field size > sizeof(%t)",f->b_fieldtype);
385: DEL(e);
386: }
387: f->b_bits = int(i);
388: f->b_name = 0;
389: break;
390: }
391: }
392: }
393:
394: bit vrp_equiv; // vector == pointer equivalence used in check()
395: bit const_problem; // types differs only in const
396: int vhack;
397: int Vcheckerror;
398:
399: inline int p_rdo(Pptr p)
400: {
401: return p->rdo;
402: }
403:
404: inline int b_ro(Pbase b)
405: {
406: return b->b_const;
407: }
408:
409: bit type::check(Ptype t, TOK oper)
410: /*
411: check if "this" can be combined with "t" by the operator "oper"
412:
413: used for check of
414: assignment types (oper==ASSIGN)
415: declaration compatability (oper==0)
416: 255 is for parameterized type formals.
417: as for (oper = 0) but (oper ==255)
418: special checking for ANY types
419: argument types (oper==ARG)
420: return types (oper==RETURN)
421: overloaded function name match (oper==OVERLOAD)
422: overloaded function coercion (oper==COERCE)
423: virtual function match (oper==VIRTUAL)
424:
425: NOT for arithmetic operators
426:
427: return 1 if the check failed
428:
429: checking of const const* and *const is a mess
430: */
431: {
432: const unsigned int strict_any_check = (oper == 255) ;
433:
434: Ptype t1 = this;
435: Ptype t2 = t;
436: Ptype tt1 = this;
437: Ptype tt2 = t;
438: int cnst1 = 0;
439: int cnst2 = 0;
440: TOK b1, b2;
441: bit first = 1;
442: TOK r;
443: int vv;
444: int ptr_count = 0;
445: int fct_seen = 0;
446: int over;
447: Pptr p1 = 0;
448: Pptr p2 = 0;
449: int p_count = 0;
450:
451: if (strict_any_check) oper = 0 ;
452:
453: //error('d',"check %k %t %t",oper,t1,t2);
454: if (t1==0 || t2==0) error('i',"check(%p,%p,%d)",t1,t2,oper);
455:
456: if (oper==VIRTUAL) {
457: vv = 1;
458: Vcheckerror = 0;
459: oper = 0;
460: }
461: else
462: vv = 0;
463:
464: if (oper == OVERLOAD) {
465: over = 1;
466: oper = 0;
467: }
468: else
469: over = 0;
470:
471: const_problem = 0;
472:
473: while (t1 && t2) {
474: top:
475: //error('d',"top: %t (%d) %t (%d)",t1,t1->base,t2,t2->base);
476: if (t1 == t2) {
477: /* if the types are the same type,
478: and it is a const type, it dosen't
479: matter whether one had a const added
480: on top by a typedef and the other did not. */
481: if (cnst1==cnst2 || t1->tconst()) return 0;
482: if (oper) {
483: //error('d',"oper %d cnst1 %d cnst2 %d ptr %d",oper,cnst1,cnst2,tt1->is_ptr());
484: if (tt1 = tt1->is_ptr()) {
485:
486: // const* = int*
487: if (cnst2<cnst1) return 0;
488:
489: // int* = int *const
490: if (cnst2==1 && tt2->tconst()) {
491: // check for int* = const *const
492: tt2 = tt2->is_ptr();
493: if (tt2->tconst()) return 1;
494: return 0;
495: }
496: }
497: else { // int = const allowed
498: if (oper==ARG || cnst1<cnst2) return 0;
499: }
500: }
501: else {
502: if (p_count && p_rdo(p1)+cnst1==p_rdo(p2)+cnst2)
503: return 0;
504: // const_problem = 1;
505: }
506:
507: const_problem = 1;
508: return 1;
509: }
510:
511: if ((t1->base == ANY || t2->base == ANY)) {
512: if (! strict_any_check) return 0;
513: // Perform the check for strict_any, ie. the
514: return ((t1 == t2) ? 0 : 1) ;
515: }
516:
517: b1 = t1->base;
518: switch (b1) {
519: case TYPE:
520: if (b_ro(Pbase(t1))) cnst1 |= 1; /* support
521: multiple consts
522: */
523: t1 = Pbase(t1)->b_name->tp;
524: goto top;
525: }
526:
527: b2 = t2->base;
528: switch (b2) {
529: case TYPE:
530: if (b_ro(Pbase(t2))) cnst2 |= 1;
531: t2 = Pbase(t2)->b_name->tp;
532: goto top;
533: }
534:
535: //error('d',"oper %k b1 %k b2 %k",oper,b1,b2);
536: if (b1 != b2) {
537: switch (b1) {
538: case PTR:
539: switch (b2) {
540: case VEC:
541: if (ptr_count) return 1;
542: // ptr/vec equivalence does not
543: // apply to declaration matching
544: t1 = Pptr(t1)->typ;
545: t2 = Pvec(t2)->typ;
546: if (oper == 0 && over==0) return 1;
547: ptr_count++;
548: first = 0;
549: goto top;
550: case FCT:
551: t1 = Pptr(t1)->typ;
552: if (t1->base!=VOID)
553: if (first==0 || t1->base!=b2) return 1;
554: first = 0;
555: goto top;
556: }
557: first = 0;
558: break;
559:
560: case FCT:
561: switch( b2 ) {
562: case PTR:
563: t2 = Pptr(t2)->typ;
564: if (t1->base!=VOID
565: && (first==0||t2->base!=b1)) return 1;
566: first = 0;
567: goto top;
568: }
569: first = 0;
570: break;
571:
572: case VEC:
573: switch (b2) {
574: case PTR:
575: if (ptr_count) return 1;
576: t1 = Pvec(t1)->typ;
577: t2 = Pptr(t2)->typ;
578: switch (oper) {
579: case ARG:
580: case ASSIGN:
581: case COERCE:
582: break;
583: case 0:
584: if (over) break;
585: default:
586: return 1;
587: }
588: ptr_count++;
589: first = 0;
590: goto top;
591: }
592: first = 0;
593: break;
594: }
595: goto base_check;
596: }
597:
598: switch (b1) {
599: case VEC:
600: //error('d',"vec %k %d %d",oper,Pvec(t1)->size,Pvec(t2)->size);
601: if (first==0 && Pvec(t1)->size!=Pvec(t2)->size) return 1;
602: first = 0;
603: t1 = Pvec(t1)->typ;
604: t2 = Pvec(t2)->typ;
605: ptr_count++;
606: break;
607:
608: case PTR:
609: case RPTR:
610: first = 0;
611: p1 = Pptr(t1);
612: p2 = Pptr(t2);
613: p_count++;
614:
615: if (p1->memof != p2->memof) {
616: t1 = p1->typ;
617: t2 = p2->typ;
618: while (t1->base == TYPE) t1 = Pbase(t1)->b_name->tp;
619: while (t2->base == TYPE) t2 = Pbase(t2)->b_name->tp;
620: if (t1 != t2) {
621: if (p1->memof==0
622: || p2->memof==0
623: || p1->memof->baseof(p2->memof)==0)
624: return 1;
625: Nstd++;
626: }
627: }
628:
629: t1 = p1->typ;
630: t2 = p2->typ;
631: ptr_count++;
632:
633: if (oper==0) {
634: if (p_rdo(p1)+cnst1!=p_rdo(p2)+cnst2
635: && cnst1+b_ro(Pbase(t1))!=cnst2+b_ro(Pbase(t2))) {
636: // const_problem only if nothing
637: // more serious is wrong
638: if (t1->check(t2,0) == 0) const_problem = 1;
639: return 1;
640: }
641:
642: if (b1==RPTR && t1->tconst()!=t2->tconst())
643: const_problem = 1;
644: }
645: break;
646:
647: case FCT:
648: first = 0;
649: { Pfct f1 = Pfct(t1);
650: Pfct f2 = Pfct(t2);
651: Pname a1 = f1->argtype;
652: Pname a2 = f2->argtype;
653: TOK k1 = f1->nargs_known;
654: TOK k2 = f2->nargs_known;
655: int n1 = f1->nargs;
656: int n2 = f2->nargs;
657: //error('d',"f1%t f2%t",f1,f2);
658: if (f1->memof != f2->memof) {
659: if (f1->memof==0 && f2->f_this==0) //SSS
660: goto sss;
661: if (vv == 0) // match even if private base class
662: if (f1->memof==0
663: || f2->memof==0
664: || f1->memof->baseof(f2->memof)==0) return 1;
665: Nstd++;
666: sss:; //SSS
667: }
668:
669: if (k1 != k2) return 1;
670:
671: if (n1!=n2 && k1 && k2) {
672: goto aaa;
673: }
674: else if (a1 && a2) {
675: int i = 0;
676: while (a1 && a2) {
677: i++;
678: if (a1->tp->check(a2->tp,over?OVERLOAD:0)) return 1;
679: a1 = a1->n_list;
680: a2 = a2->n_list;
681: }
682: if (a1 || a2) goto aaa;
683: }
684: else if (a1 || a2) {
685: aaa:
686: //error('d',"aaa k1 %d k2 %d",k1,k2);
687: if (k1 == ELLIPSIS) {
688: switch (oper) {
689: case 0:
690: if (a2 && k2==0) break;
691: return 1;
692: case ASSIGN:
693: if (a2 && k2==0) break;
694: return 1;
695: case ARG:
696: if (a1) return 1;
697: break;
698: // case OVERLOAD:
699: case COERCE:
700: return 1;
701: }
702: }
703: else if (k2 == ELLIPSIS) {
704: return 1;
705: }
706: else if (k1 || k2) {
707: return 1;
708: }
709: }
710:
711: t1 = f1->returns;
712: t2 = f2->returns;
713: fct_seen = 1;
714:
715: switch (oper) { //CCC
716: case 0:
717: if (f1->f_const!=f2->f_const) {
718: if (t1->check(t2,0)==0) const_problem = 1;
719: return 1;
720: // if (vv == 0) return 1;
721: // Vcheckerror = 1;
722: }
723: break;
724: default: // really pointer to function
725: if (f1->f_const && f2->f_const==0) return 1;
726: }
727:
728:
729: if (vv && t1->check(t2,0)) { Vcheckerror = 1; return 1; }
730: }
731: break;
732:
733: case FIELD:
734: goto field_check;
735: case CHAR:
736: case SHORT:
737: case INT:
738: case LONG:
739: goto int_check;
740: case FLOAT:
741: case DOUBLE:
742: case LDOUBLE:
743: goto float_check;
744: case EOBJ:
745: goto enum_check;
746: case COBJ:
747: goto cla_check;
748: case ZTYPE:
749: case VOID:
750: return 0;
751: default:
752: error('i',"T::check(o=%d %d %d)",oper,b1,b2);
753: }
754: }
755:
756: if (t1 || t2) {
757: const_problem = 0; // not a problem: the type itself is bad
758: return 1;
759: }
760: return 0;
761:
762: field_check:
763: switch (oper) {
764: case 0:
765: case ARG:
766: error('i',"check field?");
767: }
768: return 0;
769:
770: enum_check:
771: //error('d',"enum check %t %t",t1,t2);
772: if (Pbase(t1)->b_name->tp != Pbase(t2)->b_name->tp) goto base_check;
773: goto const_check;
774:
775: float_check:
776: if (first==0 && b1!=b2 && b2!=ZTYPE) return 1;
777: // no break
778:
779: int_check:
780: //error('d',"int_check");
781: if (Pbase(t1)->b_unsigned != Pbase(t2)->b_unsigned) {
782: if (first == 0) return 1;
783: if (oper /*&& oper!=OVERLOAD*/)
784: Nstd++;
785: else
786: return 1;
787: }
788: // no break
789:
790: const_check:
791: //error('d',"const_check %t (%d) %t (%d)",t1,t1->tconst(),t2,t2->tconst());
792: if (oper==0) {
793: //error('d',"oper==0: t1 %t t2 %t cnst1 %d cnst2 %d",t1,t2,cnst1,cnst2);
794: if (t1->tconst()+cnst1!=t2->tconst()+cnst2) {
795: const_problem = 1;
796: return 1;
797: }
798: }
799: else if (first==0) {
800: if (t1->tconst()+cnst1==0 && t2->tconst()+cnst2) {
801: //error('d',"t1 %t t2 %t cnst1 %d cnst2 %d",t1,t2,cnst1,cnst2);
802: //error('d',"tt1 %t %d cnst1 %d cnst2 %d",tt1,tt1->is_ptr(),cnst1,cnst2);
803: //error('d',"tt2 %t",tt2);
804: if (tt1->is_ptr()) {
805: if (fct_const || vec_const) cnst2--;
806:
807: // const* = int*
808: if (cnst2-tt2->tconst()<cnst1-tt1->tconst()) return 0;
809:
810: // int* = *const
811: if (cnst2==1 && tt2->tconst()) return 0;
812:
813: // const T* = const T*
814: if (t2->tconst()+cnst2==t1->tconst()+cnst1) return 0;
815: }
816: else { // int = const allowed
817: if (cnst1<cnst2) return 0;
818: }
819: const_problem = 1;
820: return 1;
821: }
822: else { // const* vs int *const
823: /*
824: //error('d',"t1 %t cnst1 %d t2 %t cnst2 %d",t1,cnst1,t2,cnst2);
825: if (tt1->is_ptr()) {
826: int tt1c = tt1->tconst();
827: int tt2c = tt2->tconst() - fct_const - vec_const;
828: //error('d',"tt1c %d tt2c %d",tt1c,tt2c);
829: if (tt1c<tt2c) return 1;
830: int t1c = t1->tconst();
831: int t2c = t2->tconst() - fct_const - vec_const;
832: //error('d',"t1c %d t2c %d",t1c,t2c);
833: if (cnst1+t1c<cnst2+t2c) return 1;
834: if (tt2c<tt1c // *const = *
835: && cnst1+t1c>cnst2+t2c) // T = constT
836: return 1;
837: }
838: */
839:
840: }
841: }
842: else {
843: //error('d',"first t1 %t t2 %t cnst1 %d cnst2 %d",t1,t2,cnst1,cnst2);
844: }
845: //error('d',"return 0");
846: return 0;
847:
848: cla_check:
849: { Pname n1 = Pbase(t1)->b_name;
850: Pname n2 = Pbase(t2)->b_name;
851: //error('d',"cla_check %n %n ptr_count %d",n1,n2,ptr_count);
852:
853: if (n1 == n2) goto const_check;
854: // once again, a more comprehensive check for classes,
855: // since they may be parametrized.
856: if ((t1->base == COBJ) && (t2->base == COBJ) &&
857: ((Pclass(n1->tp)->same_class(Pclass(n2->tp)))))
858: goto const_check ;
859:
860: if (/*first || */1<ptr_count || fct_seen) return 1;
861:
862: switch (oper) {
863: case ARG:
864: case ASSIGN:
865: case RETURN:
866: case COERCE:
867: { extern TOK ppbase;
868: ppbase = PUBLIC;
869: if (Pclass(n2->tp)->is_base(n1->string)) {
870: if (ppbase!=PUBLIC) {
871: const_problem = 0;
872: // vrp_equiv = 0;
873: return 1; // private or protected base
874: }
875: Nstd++;
876: goto const_check;
877: }
878: }
879: // no break
880: case 0:
881: case OVERLOAD:
882: const_problem = 0;
883: // vrp_equiv = 0;
884: return 1;
885: }
886:
887: goto const_check;
888: }
889:
890: base_check:
891: //error('d',"base_check t1=%t t2=%t oper=%d %s",t1,t2,oper,first?"first":"");
892: //error('d',"ptr_count %d",ptr_count);
893: if (oper)
894: if (first || 1!=ptr_count) {
895: if (b1==VOID || b2==VOID) return 1;
896: }
897: else {
898: if (b1 == VOID) { // check for void* = T*
899: register Ptype tpx = this;
900: tpxloop:
901: switch (tpx->base) { // t1 == void*
902: default:
903: const_problem = 0;
904: return 1;
905: case VOID: break;
906: case PTR:
907: case VEC: tpx = Pvec(tpx)->typ;
908: goto tpxloop;
909: case TYPE: tpx = Pbase(tpx)->b_name->tp;
910: goto tpxloop;
911: }
912:
913: tpx = t;
914: bloop:
915: switch (tpx->base) { // t2 == T*
916: default:
917: const_problem = 0;
918: return 1;
919: case VEC:
920: case PTR:
921: case FCT: Nstd++;
922: // return 0;
923: goto const_check; // prevent void* = const*
924: case TYPE: tpx = Pbase(tpx)->b_name->tp;
925: goto bloop;
926: }
927: }
928:
929: if (b2 != ZTYPE) {
930: const_problem = 0;
931: return 1;
932: }
933: }
934: //error('d',"oper %d b1 %d b2 %d cp %d",oper,b1,b2,const_problem);
935: switch (oper) {
936: case 0:
937: if (b1 != b2) {
938: const_problem = 0; // we have a bigger problem
939: // vrp_equiv = 0;
940: }
941: return 1;
942: case COERCE: // could probably be merged with the cases below
943: switch (b1) {
944: case EOBJ:
945: // echeck(t1,t2);
946: case ZTYPE:
947: case CHAR:
948: case SHORT:
949: case INT:
950: switch (b2) {
951: case LONG:
952: case FLOAT:
953: case DOUBLE:
954: case LDOUBLE:
955: // Nstd++;
956: case EOBJ:
957: case ZTYPE:
958: case CHAR:
959: case SHORT:
960: case INT:
961: case FIELD:
962: Nstd++;
963: if (b1 == EOBJ) echeck(t1,t2);
964: goto const_check;
965: }
966: return 1;
967: case LONG: // char, short, and int promotes to long
968: switch (b2) {
969: case FLOAT:
970: case DOUBLE:
971: case LDOUBLE:
972: case ZTYPE:
973: case EOBJ:
974: case CHAR:
975: case SHORT:
976: case INT:
977: case FIELD:
978: Nstd++;
979: goto const_check;
980: }
981: return 1;
982: case FLOAT:
983: // switch (b2) {
984: // case ZTYPE:
985: // Nstd++;
986: // case FLOAT:
987: // case DOUBLE:
988: // goto const_check;
989: // }
990: // return 1;
991: case DOUBLE: // char, short, int, and float promotes to double
992: case LDOUBLE:
993: switch (b2) {
994: case LONG:
995: case ZTYPE:
996: case EOBJ:
997: case CHAR:
998: case SHORT:
999: case INT:
1000: // Nstd++;
1001: case FLOAT:
1002: case DOUBLE:
1003: case LDOUBLE:
1004: Nstd++;
1005: goto const_check;
1006: }
1007: return 1;
1008: case PTR:
1009: switch (b2) {
1010: case ZTYPE:
1011: Nstd++;
1012: goto const_check;
1013: }
1014: case RPTR:
1015: case VEC:
1016: case COBJ:
1017: case FCT:
1018: return 1;
1019: }
1020: case ARG:
1021: case ASSIGN:
1022: case RETURN:
1023: switch (b1) {
1024: case COBJ:
1025: return 1;
1026: case EOBJ:
1027: // echeck(t1,t2);
1028: case ZTYPE:
1029: case CHAR:
1030: case SHORT:
1031: case INT:
1032: case LONG:
1033: suppress_error++;
1034: r = t2->num_ptr(ASSIGN);
1035: suppress_error--;
1036: switch (r) {
1037: case 'F':
1038: // if (oper!=ARG) error('w',"%t assigned to%t",t2,t1);
1039: break;
1040: case 'A':
1041: case 'P':
1042: case FCT: return 1;
1043: }
1044: if (b1 == EOBJ) echeck(t1,t2);
1045: break;
1046: case FLOAT:
1047: case DOUBLE:
1048: case LDOUBLE:
1049: suppress_error++;
1050: r = t2->numeric(ASSIGN);
1051: suppress_error--;
1052: switch (r) {
1053: case 'A':
1054: case 'P':
1055: case FCT: return 1;
1056: }
1057: break;
1058: case VEC:
1059: return 1;
1060: case PTR:
1061: suppress_error++;
1062: r = t2->num_ptr(ASSIGN);
1063: suppress_error--;
1064: switch (r) {
1065: case 'A':
1066: case 'I':
1067: case 'F': return 1;
1068: case FCT: if (Pptr(t1)->typ->base != FCT) return 1;
1069: }
1070: break;
1071: case RPTR:
1072: return 1;
1073: case FCT:
1074: switch (oper) {
1075: case ARG:
1076: case ASSIGN:
1077: return 1;
1078: }
1079: }
1080: break;
1081: }
1082: goto const_check;
1083: }
1084:
1085: /* ODI notes
1086:
1087: parameterized types
1088:
1089: constant checking fixes, especially to make
1090:
1091: typedef const int a;
1092:
1093: typedef const a b;
1094:
1095: work.
1096:
1097: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.