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