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