![[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.