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