![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to expr2.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 expr2.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / cfront2.00 |
1.1 ! root 1: /*ident "@(#)ctrans:src/expr2.c 1.1.5.29" */ ! 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: expr2.c: ! 11: ! 12: type check expressions ! 13: ! 14: ************************************************************************/ ! 15: ! 16: #include "cfront.h" ! 17: #include "size.h" ! 18: ! 19: void name::assign() ! 20: { ! 21: if (n_assigned_to++ == 0) { ! 22: switch (n_scope) { ! 23: case FCT: ! 24: if (n_used && n_addr_taken==0) { ! 25: Ptype t = tp; ! 26: ll: ! 27: switch (t->base) { ! 28: case TYPE: ! 29: t=Pbase(t)->b_name->tp; goto ll; ! 30: case VEC: ! 31: break; ! 32: default: ! 33: if (curr_loop) ! 34: error('w',&where,"%n may have been used before set",this); ! 35: else ! 36: error('w',&where,"%n used before set",this); ! 37: } ! 38: } ! 39: } ! 40: } ! 41: } ! 42: ! 43: int ignore_const; // for use by ref_init ! 44: static is_dataMemPtr(Pexpr); ! 45: ! 46: int expr::lval(TOK oper) ! 47: { ! 48: register Pexpr ee = this; ! 49: register Pname n; ! 50: int deref = 0; ! 51: char* es; ! 52: ! 53: //error('d',"%k expr::lval %k",base,oper); ! 54: ! 55: switch (oper) { ! 56: case ADDROF: ! 57: case G_ADDROF: es = "address of"; break; ! 58: case DEREF: es = "dereference of"; break; ! 59: case INCR: es = "increment of"; goto def; ! 60: case DECR: es = "decrement of"; goto def; ! 61: default: es = "assignment to"; ! 62: def: ! 63: if (ignore_const==0 && tp->tconst()) { ! 64: if (oper) { ! 65: if (base == NAME) { ! 66: if (vec_const && Pname(this)->n_scope==ARG) break; ! 67: error("%s constant%n",es,this); ! 68: } ! 69: else ! 70: error("%s constant",es); ! 71: } ! 72: return 0; ! 73: } ! 74: } ! 75: ! 76: for(;;) { ! 77: //error('d',"loop %k",ee->base); ! 78: switch (ee->base) { ! 79: // case G_CALL: ! 80: // case CALL: ! 81: default: ! 82: defa: ! 83: if (deref == 0) { ! 84: if (oper) error("%s%k (not an lvalue)",es,ee->base); ! 85: return 0; ! 86: } ! 87: return 1; ! 88: case ZERO: ! 89: case CCON: ! 90: case ICON: ! 91: case FCON: ! 92: if (oper) error("%s numeric constant",es); ! 93: return 0; ! 94: case STRING: ! 95: if (oper) error('w',"%s string constant",es); ! 96: return 1; ! 97: case CAST: ! 98: switch( oper ) { ! 99: case 0: ! 100: case ADDROF: ! 101: case G_ADDROF: ! 102: case DEREF: ! 103: goto defa; ! 104: default: ! 105: if ( ee->tp->base == PTR ! 106: && is_dataMemPtr(ee) ) ! 107: { // check for const class object ! 108: Pexpr te; ! 109: te = ee->e1->e1->e1; ! 110: if ( te->base == G_ADDROF ) ! 111: te = te->e2; ! 112: if ( te->base == NAME ) { ! 113: Ptype pt = te->tp; ! 114: if ( pt->base == PTR ) ! 115: pt = Pptr(pt)->typ; ! 116: if ( pt->tconst() ) ! 117: error("%sCMP of const%n",es,te); ! 118: return 0; ! 119: } ! 120: } ! 121: goto defa; ! 122: } ! 123: ! 124: case DEREF: ! 125: { ! 126: Pexpr ee1 = ee->e1; ! 127: // error( 'd', "ee1: %k", ee1->base ); ! 128: switch (ee1->base) { // *& vanishes ! 129: case ADDROF: // *& ! 130: return 1; ! 131: case G_CM: ! 132: case CM: // look for *(a,&b) ! 133: if (ee1->e2->base==G_ADDROF ! 134: || ee1->e2->base==ADDROF) ! 135: return 1; ! 136: goto defaa; ! 137: case QUEST: // look for *(q?&a:&b) ! 138: if ((ee1->e1->base==G_ADDROF ! 139: || ee1->e1->base==ADDROF) ! 140: && (ee1->e2->base==G_ADDROF ! 141: || ee1->e2->base==ADDROF)) ! 142: return 1; ! 143: // no break ! 144: default: ! 145: defaa: ! 146: ee = ee1; ! 147: deref = 1; ! 148: } ! 149: break; ! 150: } ! 151: ! 152: case QUEST: ! 153: { int x1 = ee->e1->lval(deref?0:oper); ! 154: int x2 = ee->e2->lval(deref?0:oper); ! 155: if (ee->e1->tp->check(ee->e2->tp,0)) return 0; ! 156: if (deref) return 1; ! 157: return x1 && x2; ! 158: } ! 159: ! 160: case INCR: ! 161: case DECR: ! 162: if (e1) goto defa; // postfix does not preserve lval ! 163: case ASSIGN: ! 164: case ASPLUS: ! 165: case ASMINUS: ! 166: case ASMUL: ! 167: case ASDIV: ! 168: case ASMOD: ! 169: case ASAND: ! 170: case ASOR: ! 171: case ASER: ! 172: case ASLS: ! 173: case ASRS: ! 174: return 1; ! 175: ! 176: case CM: ! 177: case G_CM: ! 178: if (ee->e2->lval(deref?0:oper)==0) return deref; ! 179: return 1; ! 180: ! 181: case MEMPTR: ! 182: ee = ee->e2; ! 183: break; ! 184: ! 185: case MDOT: ! 186: ee = ee->mem; ! 187: break; ! 188: ! 189: case DOT: ! 190: //error('d',"dot %k oper %k",ee->e1->base,oper); ! 191: switch (ee->e1->base) { // update use counts, etc. ! 192: case NAME: ! 193: switch (oper) { ! 194: case ADDROF: ! 195: case G_ADDROF: Pname(ee->e1)->take_addr(); ! 196: case 0: break; ! 197: case ASSIGN: Pname(ee->e1)->n_used--; ! 198: default: Pname(ee->e1)->assign(); // asop ! 199: } ! 200: break; ! 201: case DOT: ! 202: Pexpr e = ee->e1; ! 203: do e=e->e1; while (e->base==DOT); ! 204: if (e->base == NAME) { ! 205: switch (oper) { ! 206: case ADDROF: ! 207: case G_ADDROF: Pname(e)->take_addr(); ! 208: case 0: break; ! 209: case ASSIGN: Pname(e)->n_used--; ! 210: default: Pname(e)->assign(); // asop ! 211: } ! 212: } ! 213: } ! 214: ! 215: n = Pname(ee->mem); ! 216: while (n->base == MDOT) n = Pname(Pref(n)->mem); ! 217: ! 218: if (deref==0 && ee->e1->tp->tconst()) { ! 219: switch (oper) { ! 220: case 0: ! 221: case ADDROF: ! 222: case G_ADDROF: ! 223: case DEREF: ! 224: break; ! 225: default: ! 226: error("%sM%n of%t",es,n,ee->e1->tp); ! 227: } ! 228: return 0; ! 229: } ! 230: goto xx; ! 231: ! 232: case REF: ! 233: n = Pname(ee->mem); ! 234: while (n->base == MDOT) n = Pname(Pref(n)->mem); ! 235: ! 236: if (deref==0 && ee->e1) { //BR ! 237: Ptype p = ee->e1->tp; ! 238: zxc: ! 239: switch (p->base) { ! 240: case TYPE: p = Pbase(p)->b_name->tp; goto zxc; ! 241: case PTR: ! 242: case VEC: break; ! 243: default: error('i',"expr::lval %t->%n",p,n); ! 244: } ! 245: if (Pptr(p)->typ->tconst()) { ! 246: switch (oper) { ! 247: case 0: ! 248: case ADDROF: ! 249: case G_ADDROF: ! 250: case DEREF: ! 251: break; ! 252: default: ! 253: error("%sM%n of%t",es,n,Pptr(p)->typ); ! 254: } ! 255: return 0; ! 256: } ! 257: } ! 258: goto xx; ! 259: ! 260: case NAME: ! 261: n = Pname(ee); ! 262: xx: ! 263: // error('d',"name xx: %n oper %d lex_level: %d",n,oper,n->lex_level); ! 264: if (deref || oper==0) return 1; ! 265: ! 266: if (n->tp->base==FIELD && Pbase(n->tp)->b_bits==0) { ! 267: error("%s 0-length field%n",es,n); ! 268: return 0; ! 269: } ! 270: ! 271: switch (oper) { ! 272: case ADDROF: ! 273: case G_ADDROF: ! 274: { Pfct f = (Pfct)n->tp; ! 275: ! 276: if (n->n_sto == REGISTER) { ! 277: if (warning_opt) error('w',"& register%n",n); ! 278: // return 0; ! 279: n->n_sto = 0; ! 280: n->n_stclass = AUTO; ! 281: } ! 282: ! 283: if (f == 0) { ! 284: error("& label%n",n); ! 285: return 0; ! 286: } ! 287: ! 288: if (n->n_stclass == ENUM) { ! 289: error("& enumerator%n",n); ! 290: return 0; ! 291: } ! 292: ! 293: if (n->tp->base == FIELD) { ! 294: error("& field%n",n); ! 295: return 0; ! 296: } ! 297: ! 298: n->n_used--; ! 299: if (n->n_qualifier) // oops, not the real one ! 300: n = Pclass(n->n_table->t_name->tp)->memtbl->look(n->string,0); ! 301: n->take_addr(); ! 302: ! 303: // suppress hoisting of local consts ! 304: int statmem = n->n_scope==0 || n->n_scope==PUBLIC || n->n_scope == FCT; ! 305: if (n->n_evaluated && n->n_scope!=ARG) { // &const ! 306: n->n_evaluated = 0; // use allocated version ! 307: n->n_initializer = new ival(n->n_val); ! 308: if (statmem == 0) n->dcl_print(0); ! 309: } ! 310: else if (f->base==FCT && n->n_dcl_printed==0) ! 311: n->dcl_print(0); ! 312: break; ! 313: } ! 314: ! 315: case ASSIGN: ! 316: //error('d',"ass %n %d",n,n->n_used); ! 317: n->n_used--; ! 318: n->assign(); ! 319: break; ! 320: // goto check_void; ! 321: default: /* incr ops, and asops */ ! 322: if (cc->tot && n==cc->c_this) { ! 323: error("%n%k",n,oper); ! 324: return 0; ! 325: } ! 326: // check_void: ! 327: // { Ptype t = n->tp; ! 328: // while (t->base==TYPE) t = Pbase(t)->b_name->tp; ! 329: // if (t==Pvoid_type) { ! 330: // error("%s%t",es,n->tp); ! 331: // return 0; ! 332: // } ! 333: // } ! 334: n->assign(); ! 335: } ! 336: return 1; ! 337: } ! 338: } ! 339: } ! 340: ! 341: int char_to_int(char* s) ! 342: /* assume s points to a string: ! 343: 'c' ! 344: or '\c' ! 345: or '\0' ! 346: or '\ddd' ! 347: or multi-character versions of the above ! 348: (hex constants have been converted to octal by the parser) ! 349: */ ! 350: { ! 351: register int i = 0; ! 352: register char c, d, e; ! 353: ! 354: switch (*s) { ! 355: default: ! 356: error('i',"char constant store corrupted"); ! 357: case '`': ! 358: error("bcd constant"); ! 359: return 0; ! 360: case '\'': ! 361: break; ! 362: } ! 363: ! 364: for(;;) /* also handle multi-character constants */ ! 365: switch (c = *++s) { ! 366: case '\'': ! 367: return i; ! 368: case '\\': /* special character */ ! 369: switch (c = *++s) { ! 370: case '0': case '1': case '2': case '3': case '4': ! 371: case '5': case '6': case '7': /* octal representation */ ! 372: c -= '0'; ! 373: switch (d = *++s) { /* try for 2 */ ! 374: ! 375: case '0': case '1': case '2': case '3': case '4': ! 376: case '5': case '6': case '7': ! 377: d -= '0'; ! 378: switch (e = *++s) { /* try for 3 */ ! 379: ! 380: case '0': case '1': case '2': case '3': case '4': ! 381: case '5': case '6': case '7': ! 382: c = c*64+d*8+e-'0'; ! 383: break; ! 384: default: ! 385: c = c*8+d; ! 386: s--; ! 387: } ! 388: break; ! 389: default: ! 390: s--; ! 391: } ! 392: break; ! 393: case 'b': ! 394: c = '\b'; ! 395: break; ! 396: case 'f': ! 397: c = '\f'; ! 398: break; ! 399: case 'n': ! 400: c = '\n'; ! 401: break; ! 402: case 'r': ! 403: c = '\r'; ! 404: break; ! 405: case 't': ! 406: c = '\t'; ! 407: break; ! 408: case '\\': ! 409: c = '\\'; ! 410: break; ! 411: case '\'': ! 412: c = '\''; ! 413: break; ! 414: } ! 415: /* no break */ ! 416: default: ! 417: if (i) i <<= BI_IN_BYTE; ! 418: i += c; ! 419: } ! 420: } ! 421: ! 422: const A10 = 'A'-10; ! 423: const a10 = 'a'-10; ! 424: ! 425: long str_to_long(register const char* p) ! 426: { ! 427: register c; ! 428: register unsigned long i= 0; ! 429: const char* pp = p; ! 430: ! 431: // error( 'd', "str_to_long: %s", p ); ! 432: ! 433: if ((c=*p++) == '0') { ! 434: switch (c = *p++) { ! 435: case 0: ! 436: return 0; ! 437: ! 438: case 'l': ! 439: case 'L': /* long zero */ ! 440: return 0; ! 441: ! 442: case 'x': ! 443: case 'X': /* hexadecimal */ ! 444: while (c=*p++) { ! 445: switch (c) { ! 446: case 'l': ! 447: case 'L': ! 448: case 'U': ! 449: case 'u': ! 450: return i; ! 451: case 'A': ! 452: case 'B': ! 453: case 'C': ! 454: case 'D': ! 455: case 'E': ! 456: case 'F': ! 457: i = i*16 + c-A10; ! 458: break; ! 459: case 'a': ! 460: case 'b': ! 461: case 'c': ! 462: case 'd': ! 463: case 'e': ! 464: case 'f': ! 465: i = i*16 + c-a10; ! 466: break; ! 467: default: ! 468: i = i*16 + c-'0'; ! 469: } ! 470: } ! 471: return i; ! 472: ! 473: default: /* octal */ ! 474: do ! 475: switch (c) { ! 476: case 'l': ! 477: case 'L': ! 478: case 'U': ! 479: case 'u': ! 480: return i; ! 481: default: ! 482: i = i*8 + c-'0'; ! 483: } ! 484: while (c=*p++); ! 485: return i; ! 486: } ! 487: } ! 488: /* decimal */ ! 489: i = c-'0'; ! 490: while (c=*p++) ! 491: switch (c) { ! 492: case 'l': ! 493: case 'L': ! 494: case 'U': ! 495: case 'u': ! 496: return i; ! 497: default: ! 498: { unsigned long ii = i; ! 499: i = i*10 + c-'0'; ! 500: if (i<ii) goto bad; ! 501: } ! 502: } ! 503: return i; ! 504: bad: ! 505: error("integer constant %s larger that the largest long",pp); ! 506: return i; ! 507: ! 508: ! 509: } ! 510: ! 511: bit type::is_unsigned() ! 512: { ! 513: Ptype t = this; ! 514: while (t->base==TYPE) t = Pbase(t)->b_name->tp; ! 515: if (t->base == PTR) return 0; ! 516: return Pbase(t)->b_unsigned; ! 517: } ! 518: ! 519: char* Neval; ! 520: bit binary_val; ! 521: ! 522: unsigned long expr::ueval(long x1, long x2) ! 523: { ! 524: unsigned long i1 = (unsigned long) x1; ! 525: unsigned long i2 = (unsigned long) x2; ! 526: //error('d',"ueval %k %ld %ld",base,x1,x2); ! 527: switch (base) { ! 528: case UMINUS: return -i2; ! 529: case UPLUS: return i2; ! 530: case NOT: return !i2; ! 531: case COMPL: return ~i2; ! 532: case CAST: return i1; ! 533: case PLUS: return i1+i2; ! 534: case MINUS: return i1-i2; ! 535: case MUL: return i1*i2; ! 536: case LS: return i1<<i2; ! 537: case RS: return i1>>i2; ! 538: case NE: return i1!=i2; ! 539: case EQ: return i1==i2; ! 540: case LT: return i1<i2; ! 541: case LE: return i1<=i2; ! 542: case GT: return i1>i2; ! 543: case GE: return i1>=i2; ! 544: case AND: return i1&i2; ! 545: case ANDAND: return i1&&i2; ! 546: case OR: return i1|i2; ! 547: case OROR: return i1||i2; ! 548: case ER: return i1^i2; ! 549: case MOD: return (i2==0) ? 1 : i1%i2; ! 550: case QUEST: return (cond->eval()) ? i1 : i2; ! 551: case DIV: if (i2 == 0) { ! 552: if (Neval == 0) { ! 553: Neval = "divide by zero"; ! 554: error('w',"divide by zero"); ! 555: } ! 556: return 1; ! 557: } ! 558: return i1/i2; ! 559: case CM: ! 560: case G_CM: ! 561: return i2; ! 562: } ! 563: ! 564: Neval = "unsigned expression"; ! 565: return 0; ! 566: } ! 567: ! 568: long expr::eval() ! 569: { ! 570: static long cast_mask[] = { 0377, 0177777, 077777777, ~0 }; ! 571: ! 572: if (Neval) return 1; ! 573: // error('d',"eval %k",base); ! 574: ! 575: switch (base) { ! 576: case ZERO: return 0; ! 577: case IVAL: return i1; ! 578: case ICON: return str_to_long(string); ! 579: case CCON: return char_to_int(string); ! 580: case FCON: Neval = "float in constant expression"; return 1; ! 581: case STRING: Neval = "string in constant expression"; return 1; ! 582: case EOBJ: return Pname(this)->n_val; ! 583: case SIZEOF: ! 584: extern no_sizeof; ! 585: if (no_sizeof) Neval = "sizeof"; ! 586: return tp2->tsizeof(); ! 587: ! 588: case NAME: ! 589: { Pname n = Pname(this); ! 590: // error('d',"eval %n eval %d %d",n,n->n_evaluated,n->n_val); ! 591: // error('d',"eval tp->tconst() %d, n->n_initializer: %k", n->tp->tconst(), n->n_initializer?n->n_initializer->base:0 ); ! 592: if (n->n_evaluated && n->n_scope!=ARG) return n->n_val; ! 593: if (n->n_initializer ! 594: && n->n_scope!=ARG ! 595: && n->n_initializer->base==IVAL // encoding for outlined ! 596: && n->n_initializer->i1==n->n_val // const see ::lval above ! 597: && n->tp->tconst()) return n->n_val; ! 598: if (binary_val && strcmp(string,"_result")==0) return 8888; ! 599: Neval = "cannot evaluate constant"; ! 600: return 1; ! 601: } ! 602: case ICALL: ! 603: if (e1) { ! 604: il->i_next = curr_icall; ! 605: curr_icall = il; ! 606: long i = e1->eval(); ! 607: curr_icall = il->i_next; ! 608: return i; ! 609: } ! 610: Neval = "void inlineF"; ! 611: return 1; ! 612: case ANAME: ! 613: { Pname n = (Pname)this; ! 614: int argno = (int)n->n_val; ! 615: Pin il; ! 616: for (il=curr_icall; il; il=il->i_next) ! 617: if (il->i_table == n->n_table) goto aok; ! 618: goto bok; ! 619: aok: ! 620: if (il->i_args[argno].local) { ! 621: bok: ! 622: Neval = "inlineF call too complicated for constant expression"; ! 623: return 1; ! 624: } ! 625: Pexpr aa = il->i_args[argno].arg; ! 626: return aa->eval(); ! 627: } ! 628: case CAST: ! 629: { if (e1->base == FCON) { ! 630: char* p = e1->string; ! 631: while (*p!='.') p++; ! 632: if (p==e1->string) *p++ = '0'; ! 633: *p = 0; ! 634: e1->base = ICON; ! 635: } ! 636: long i = e1->eval(); ! 637: Ptype tt = tp2; ! 638: strip: ! 639: switch (tt->base) { ! 640: default: ! 641: Neval = "cast to non-integral type in constant expression"; ! 642: break; ! 643: case TYPE: ! 644: tt = Pbase(tt)->b_name->tp; ! 645: goto strip; ! 646: case EOBJ: ! 647: case LONG: ! 648: case INT: ! 649: case CHAR: ! 650: case SHORT: ! 651: { ! 652: if (BI_IN_BYTE!=8) error('i',"expr::eval() assumes 8 bit bytes, please re-write it"); ! 653: if (4<SZ_LONG) error('i',"expr::eval() assumes sizeof(long)<=4, please re-write it"); ! 654: i &= cast_mask[tp2->tsizeof()-1]; ! 655: } ! 656: } ! 657: return i; ! 658: } ! 659: case UMINUS: ! 660: case UPLUS: ! 661: case NOT: ! 662: case COMPL: ! 663: case PLUS: ! 664: case MINUS: ! 665: case MUL: ! 666: case LS: ! 667: case RS: ! 668: case NE: ! 669: case LT: ! 670: case LE: ! 671: case GT: ! 672: case GE: ! 673: case AND: ! 674: case OR: ! 675: case ER: ! 676: case DIV: ! 677: case MOD: ! 678: case QUEST: ! 679: case EQ: ! 680: case ANDAND: ! 681: break; ! 682: case OROR: ! 683: if (binary_val) { // a||b, don't evaluate b if a!=0 ! 684: long i1 = (e1) ? e1->eval() : 0; ! 685: if (Neval==0 && i1 && e1->tp->is_unsigned()==0) return i1; ! 686: } ! 687: break; ! 688: case CM: ! 689: case G_CM: ! 690: break; ! 691: case G_ADDROF: ! 692: case ADDROF: ! 693: if (binary_val) { // beware of &*(T*)0 ! 694: switch (e2->base) { ! 695: case NAME: ! 696: case DOT: ! 697: case REF: return 9999; ! 698: } ! 699: } ! 700: default: ! 701: Neval = "bad operator in constant expression"; ! 702: return 1; ! 703: } ! 704: ! 705: long i1 = (e1) ? e1->eval() : 0; ! 706: long i2 = (e2) ? e2->eval() : 0; ! 707: ! 708: if (binary_val && i1==9999 && i2==9999) { ! 709: Neval = ""; ! 710: return 1; ! 711: } ! 712: ! 713: if (Neval==0 ! 714: && ((e1&&e1->tp->is_unsigned()) || (e2&&e2->tp->is_unsigned()))) ! 715: return (long) ueval(i1,i2); ! 716: ! 717: switch (base) { ! 718: case UMINUS: return -i2; ! 719: case UPLUS: return i2; ! 720: case NOT: return !i2; ! 721: case COMPL: return ~i2; ! 722: case CAST: return i1; ! 723: case PLUS: return i1+i2; ! 724: case MINUS: return i1-i2; ! 725: case MUL: return i1*i2; ! 726: case LS: return i1<<i2; ! 727: case RS: return i1>>i2; ! 728: case NE: return i1!=i2; ! 729: case EQ: return i1==i2; ! 730: case LT: return i1<i2; ! 731: case LE: return i1<=i2; ! 732: case GT: return i1>i2; ! 733: case GE: return i1>=i2; ! 734: case AND: return i1&i2; ! 735: case ANDAND: return i1&&i2; ! 736: case OR: return i1|i2; ! 737: case OROR: return i1||i2; ! 738: case ER: return i1^i2; ! 739: case MOD: return (i2==0) ? 1 : i1%i2; ! 740: case QUEST: return (cond->eval()) ? i1 : i2; ! 741: case DIV: if (i2 == 0) { ! 742: if (Neval == 0) { ! 743: Neval = "divide by zero"; ! 744: error('w',"divide by zero"); ! 745: } ! 746: return 1; ! 747: } ! 748: return i1/i2; ! 749: case CM: ! 750: case G_CM: ! 751: return i2; ! 752: } ! 753: } ! 754: extern TOK ppbase; ! 755: bit classdef::baseof(Pname f) ! 756: /* ! 757: is ``this'' class a public base class of "f"'s class ! 758: or its immediate base class ! 759: */ ! 760: { ! 761: Ptable ctbl = f->n_table; ! 762: Pname b = ctbl->t_name; ! 763: ! 764: if (b == 0) return 0; ! 765: Pclass cl = Pclass(b->tp); ! 766: if (cl == 0) return 0; ! 767: if (cl == this) return 1; ! 768: ppbase = PUBLIC; ! 769: Pclass bcl = is_base(cl->string); ! 770: return (bcl && ppbase==PUBLIC); ! 771: } ! 772: ! 773: bit classdef::baseof(Pclass cl) ! 774: /* ! 775: is ``this'' class a public base class of "cl" ! 776: */ ! 777: { ! 778: if (cl == 0) return 0; ! 779: if (cl == this) return 1; ! 780: ppbase = PUBLIC; ! 781: Pclass bcl = is_base(cl->string); ! 782: return (bcl && ppbase==PUBLIC); ! 783: } ! 784: ! 785: static int mem_match(Pfct f1, Pfct f2) ! 786: /* ! 787: check class membership. ! 788: ! 789: For some reason checking f_this==0 works and f_static doesn't ! 790: */ ! 791: { ! 792: // if (f1->memof) return f2->f_this ?f2->memof==f1->memof : 0; ! 793: // if (f1 && f1->memof) return f2->f_this?f2->memof==f1->memof : 0; ! 794: // return f2->f_this==0; ! 795: if (f1==0 || f2==0) return 0; ! 796: if (f1->memof && f2->f_this && f2->memof!=f1->memof) return 0; ! 797: if (f2->f_this) return 0; ! 798: if (f1->check(f2,ASSIGN)) return 0; ! 799: return 1; ! 800: } ! 801: ! 802: int Pchecked; ! 803: ! 804: Pexpr ptof(Pfct ef, Pexpr e, Ptable tbl) ! 805: /* ! 806: a kludge: initialize/assign-to pointer to function ! 807: */ ! 808: { ! 809: Pfct f; ! 810: Pname n = 0; ! 811: eee: ! 812: //error('d',"ptof %t %t %k",ef,e->tp,e->base); ! 813: switch (e->base) { ! 814: case QUEST: ! 815: e->e1 = ptof(ef,e->e1,tbl); ! 816: e->e2 = ptof(ef,e->e2,tbl); ! 817: return e; ! 818: case CM: ! 819: case G_CM: ! 820: e->e2 = ptof(ef,e->e2,tbl); ! 821: return e; ! 822: case NAME: ! 823: f = Pfct(e->tp); ! 824: // n = Pname(e); ! 825: ! 826: switch (f->base) { ! 827: case OVERLOAD: ! 828: e = Pgen(f)->find(ef,0); ! 829: if (e == 0) error("cannot deduceT for &overloaded%n",e); ! 830: // e = n; ! 831: // no break ! 832: case FCT: ! 833: Pchecked = mem_match(ef,Pfct(e->tp)); ! 834: e = new expr(G_ADDROF,0,e); ! 835: return e->typ(tbl); // handle &B::f ! 836: //e->tp = f; ! 837: } ! 838: goto ad; ! 839: ! 840: case ZERO: ! 841: if (ef->memof) { ! 842: e = new expr(ELIST,zero,zero); ! 843: e = new expr(ILIST,e,zero); ! 844: e->tp = zero_type; ! 845: return e; ! 846: } ! 847: break; ! 848: ! 849: case MDOT: ! 850: error('s',"P toM of not firstB"); ! 851: do e = e->mem; while (e->base == MDOT); ! 852: goto eee; ! 853: ! 854: case DOT: ! 855: case REF: ! 856: f = Pfct(e->mem->tp); ! 857: ! 858: switch (f->base) { ! 859: case OVERLOAD: ! 860: e = Pgen(f)->find(ef,0); ! 861: if (n == 0) error("cannot deduceT for &overloaded%n",e->mem); ! 862: // e->mem = n; ! 863: // no break ! 864: case FCT: ! 865: Pchecked = mem_match(ef,Pfct(e->tp)); ! 866: e = new expr(G_ADDROF,0,e); ! 867: return e->typ(tbl); // handle &B::f ! 868: // n = Pname(e->mem); ! 869: // e = n->address(); ! 870: } ! 871: goto ad; ! 872: ! 873: case ADDROF: ! 874: case G_ADDROF: ! 875: f = Pfct(e->e2->tp); ! 876: ad: ! 877: if (f->base == OVERLOAD) { ! 878: n = Pgen(f)->find(ef,0); ! 879: if (n == 0) error("cannot deduceT for &overloaded %s()",Pgen(f)->fct_list->f->string); ! 880: Pchecked = mem_match(ef,Pfct(n->tp)); ! 881: e->e2 = n; ! 882: e->tp = n->tp; ! 883: } ! 884: if (n) n->lval(ADDROF); ! 885: break; ! 886: ! 887: case CAST: ! 888: { ! 889: Pexpr te = e->e1; ! 890: if (e->e1->base == G_ADDROF) te = e->e1->e2; ! 891: (void) ptof(ef,te,tbl); ! 892: } ! 893: } ! 894: return e; ! 895: } ! 896: ! 897: Pexpr ptr_init(Pptr p, Pexpr init, Ptable tbl) ! 898: /* ! 899: check for silly initializers ! 900: ! 901: char* p = 0L; ?? fudge to allow redundant and incorrect `L' ! 902: char* p = 2 - 2; ?? worse ! 903: */ ! 904: { ! 905: //error('d',"ptr_init: p=%t init->tp=%t init->base %k",p,init->tp,init->base); ! 906: ! 907: Pchecked = 0; ! 908: ! 909: Ptype it = init->tp; ! 910: itl: ! 911: switch (it->base) { ! 912: case TYPE: ! 913: it = Pbase(it)->b_name->tp; goto itl; ! 914: case ZTYPE: ! 915: // if (init == zero) break; ! 916: break; ! 917: case EOBJ: ! 918: case INT: ! 919: case CHAR: ! 920: case SHORT: ! 921: { Neval = 0; ! 922: long i = init->eval(); ! 923: if (Neval) ! 924: error("badPIr: %s",Neval); ! 925: else ! 926: if (i) ! 927: error("badPIr value %d",i); ! 928: else { ! 929: DEL(init); ! 930: init = zero; ! 931: } ! 932: break; ! 933: } ! 934: case LONG: ! 935: if (init->base==ICON ! 936: && init->string[0]=='0' ! 937: && (init->string[1]=='L' || init->string[1]=='l')) { ! 938: DEL(init); ! 939: init = zero; ! 940: } ! 941: break; ! 942: } ! 943: ! 944: Pclass c1 = p->memof; ! 945: ! 946: if (c1) { ! 947: //error('d',"c1 %t",c1); ! 948: if (init==zero) ! 949: ; ! 950: else { ! 951: Pclass c2; ! 952: //error('d',"it %t %d",it,it->base); ! 953: switch (it->base) { ! 954: case FCT: ! 955: c2 = Pfct(it)->memof; ! 956: break; ! 957: case OVERLOAD: ! 958: c2 = Pfct(Pgen(it)->fct_list->f->tp)->memof; ! 959: break; ! 960: case PTR: ! 961: case RPTR: ! 962: c2 = Pptr(it)->memof; ! 963: break; ! 964: default: ! 965: c2 = 0; ! 966: } ! 967: ! 968: if (c2 == 0) { ! 969: // initialization by &A::f ! 970: //error('d',"curious"); ! 971: } ! 972: else if (c1 != c2) { ! 973: Nptr = 0; ! 974: Noffset = 0; ! 975: vcllist->clear(); ! 976: vcllist=0; ! 977: int u1 = is_unique_base(c1,c2->string,0); ! 978: //error('d',"c1 %t c2 %t u1 %d off %d",c1,c2,u1,Noffset); ! 979: if (u1 && (Nptr || Noffset)) { ! 980: // requires offset manipulation ! 981: int bad = 0; ! 982: if (u1 == 1 && !Nptr) { ! 983: //error('d',"try c1 %t c2 %t u1 %d off %d",c1,c2,u1,Noffset); ! 984: //error('d',"init %k %t",init->base,init->tp); ! 985: if (init->base==ILIST) { ! 986: // d = d+Noffset; ! 987: //error('d'," d %k %d",init->e1->e1->base,init->e1->e1->i1); ! 988: switch (init->e1->e1->base) { ! 989: case IVAL: ! 990: init->e1->e1->i1 += Noffset; ! 991: break; ! 992: case ZERO: ! 993: init->e1->e1 = new ival(Noffset); ! 994: break; ! 995: default: ! 996: bad = 1; ! 997: } ! 998: ! 999: //error('d'," i %k %d",init->e1->e2->base,init->e1->e2->i1); ! 1000: // if (i<0) f = vptroffset ! 1001: switch (init->e1->e2->base) { ! 1002: case IVAL: ! 1003: if (0<init->e1->e2->i1) { ! 1004: //error('d',"vptr"); ! 1005: extern Ptype Pfct_type; ! 1006: // store vptr offset ! 1007: // init->e2 = new cast(Pfct_type,zero); ! 1008: } ! 1009: else ! 1010: break; ! 1011: default: ! 1012: bad = 1; ! 1013: } ! 1014: } ! 1015: else ! 1016: bad = 1; ! 1017: ! 1018: } ! 1019: else ! 1020: bad = 1; ! 1021: ! 1022: if (bad) error('s',"%t assigned to %t (too complicated)",init->tp,p); ! 1023: } ! 1024: ! 1025: Nptr = 0; ! 1026: Noffset = 0; ! 1027: vcllist->clear(); ! 1028: vcllist=0; ! 1029: int u2 = is_unique_base(c2,c1->string,0); ! 1030: //error('d',"c1 %t c2 %t u2 %d off %d",c1,c2,u2,Noffset); ! 1031: if (u2 && (Nptr || Noffset)) { ! 1032: // requires offset manipulation ! 1033: error('s',"%t assigned to %t",init->tp,p); ! 1034: } ! 1035: } ! 1036: } ! 1037: } ! 1038: ! 1039: Ptype pit = p->typ; ! 1040: lll: ! 1041: //error('d',"p %t pit %t",p,pit); ! 1042: switch (pit->base) { ! 1043: case TYPE: ! 1044: pit = Pbase(pit)->b_name->tp; ! 1045: goto lll; ! 1046: case FCT: ! 1047: return ptof(Pfct(pit),init,tbl); ! 1048: case COBJ: ! 1049: { Pptr r; ! 1050: //error('d',"cobj: ptr %t, ref %t",it->is_ptr(),it->is_ref()); ! 1051: if (r=it->is_ptr_or_ref()) { ! 1052: Pchecked = 1; ! 1053: TOK b = p->base; // could be REF ! 1054: TOK bb = r->base; ! 1055: if (b==RPTR) p->base = PTR; ! 1056: if (bb==RPTR) r->base = PTR; ! 1057: if (p->check(r,ASSIGN)) ! 1058: error("no standard conversion of %t to %t",init->tp,p); ! 1059: p->base = b; ! 1060: r->base = bb; ! 1061: Pexpr cp = cast_cptr(Pclass(Pbase(pit)->b_name->tp),init,tbl,0); ! 1062: if (cp != init) { ! 1063: PERM(p); // or else it will be deleted twice! ! 1064: return new cast(p,cp); ! 1065: } ! 1066: } ! 1067: // no break ! 1068: } ! 1069: default: ! 1070: return init; ! 1071: } ! 1072: } ! 1073: ! 1074: static Pname Lcoerce, Rcoerce; ! 1075: extern int suppress_error; ! 1076: ! 1077: int try_to_demote(TOK oper, Ptype t1, Ptype t2) ! 1078: /* ! 1079: look at t1 and t2 and see if there are ``demotions'' of t1 and/or t2 ! 1080: so that ``t1 oper t2'' can be made legal ! 1081: ! 1082: return 0 is not ! 1083: 1 if there is exactly one way ! 1084: >1 if there is more than one way (if in doubt return 2) ! 1085: */ ! 1086: { ! 1087: //error('d',"try_to_demote(%k : %t : %t)",oper,t1,t2); ! 1088: ! 1089: Pname n1 = t1 ? t1->is_cl_obj() : 0; ! 1090: Pclass c1 = n1 ? Pclass(n1->tp) : 0; ! 1091: Pname n2 = t2 ? t2->is_cl_obj() : 0; ! 1092: Pclass c2 = n2 ? Pclass(n2->tp) : 0; ! 1093: ! 1094: Ptype lt = t1; ! 1095: Ptype rt = t2; ! 1096: ! 1097: Lcoerce = Rcoerce = 0; ! 1098: ! 1099: // if (oper == DOT) return 0; ! 1100: ! 1101: if (c1) ! 1102: switch (oper) { ! 1103: case ASSIGN: ! 1104: case ASPLUS: ! 1105: case ASMINUS: ! 1106: case ASMUL: ! 1107: case ASDIV: ! 1108: case ASMOD: ! 1109: case ASAND: ! 1110: case ASOR: ! 1111: case ASER: ! 1112: case ASLS: ! 1113: case ASRS: // don't coerce left hand side of assignment ! 1114: // c1 = 0; ! 1115: if (c1->memtbl->look("__as",0)) return 0; ! 1116: } ! 1117: else ! 1118: switch (oper) { ! 1119: case ADDROF: ! 1120: case INCR: ! 1121: case DECR: // don't coerce unary requiring an lval ! 1122: return 0; ! 1123: } ! 1124: ! 1125: if (c1) { ! 1126: //error('d',"c1 %t",c1); ! 1127: for (Pname on1 = c1->conv; on1; on1=on1->n_list) { ! 1128: Pfct f = Pfct(on1->tp); ! 1129: lt = f->returns; ! 1130: Pname cn = lt->is_cl_obj(); ! 1131: ! 1132: if (cn && (Lcoerce==0 || Lcoerce->tp->check(f,0))) { ! 1133: Pclass cl = Pclass(cn->tp); ! 1134: Pname n = cl->has_oper(oper); ! 1135: if (n == 0) continue; ! 1136: // while (n->base==REF || n->base==MDOT) n=Pname(n->mem); ! 1137: Pfct nf = Pfct(n->tp); ! 1138: if (nf->base == FCT) { ! 1139: if (nf->nargs==1 ! 1140: && (nf->argtype->tp->check(t2,ARG)==0 ! 1141: || can_coerce(nf->argtype->tp,t2)==1) ! 1142: ) { ! 1143: if (Lcoerce) return 2; ! 1144: Lcoerce = on1; ! 1145: } ! 1146: } ! 1147: else { ! 1148: for (Plist gl=Pgen(nf)->fct_list; gl; gl=gl->l) { ! 1149: Pfct nf = Pfct(gl->f->tp); ! 1150: if (nf->nargs==1 ! 1151: && (nf->argtype->tp->check(t2,ARG)==0 ! 1152: || can_coerce(nf->argtype->tp,t2)==1) ! 1153: ) { ! 1154: if (Lcoerce) return 2; ! 1155: Lcoerce = on1; ! 1156: } ! 1157: } ! 1158: } ! 1159: continue; ! 1160: } ! 1161: //if (lt->is_cl_obj()) continue; ! 1162: if (c2) { ! 1163: //error('d',"c2 %t",c2); ! 1164: for (Pname on2 = c2->conv; on2; on2=on2->n_list) { ! 1165: Pfct f = Pfct(on2->tp); ! 1166: rt = f->returns; ! 1167: if (rt->is_cl_obj()) continue; ! 1168: ! 1169: suppress_error = 1; ! 1170: int r1 = lt->kind(oper,0); ! 1171: int r2 = rt->kind(oper,0); ! 1172: if (np_promote(oper,r1,r2,lt,rt,1)!=any_type) { ! 1173: if (Lcoerce) { ! 1174: suppress_error = 0; ! 1175: return 2; ! 1176: } ! 1177: Lcoerce = on1; ! 1178: Rcoerce = on2; ! 1179: ! 1180: }; ! 1181: suppress_error = 0; ! 1182: } ! 1183: ! 1184: } ! 1185: else if (rt) { ! 1186: suppress_error = 1; ! 1187: int r1 = lt->kind(oper,0); ! 1188: int r2 = rt->kind(oper,0); ! 1189: if (np_promote(oper,r1,r2,lt,rt,1)!=any_type) { ! 1190: if (Lcoerce) { ! 1191: suppress_error = 0; ! 1192: return 2; ! 1193: } ! 1194: Lcoerce = on1; ! 1195: }; ! 1196: suppress_error = 0; ! 1197: } ! 1198: else { ! 1199: if (Lcoerce) return 2; ! 1200: Lcoerce = on1; ! 1201: } ! 1202: } ! 1203: } ! 1204: else if (c2) { ! 1205: //error('d',"c2 %n",c2); ! 1206: for (Pname on = c2->conv; on; on=on->n_list) { ! 1207: Pfct f = Pfct(on->tp); ! 1208: rt = f->returns; ! 1209: Pname cn = rt->is_cl_obj(); ! 1210: //error('d',"cn %n",cn); ! 1211: if (cn && (Rcoerce==0 || Rcoerce->tp->check(f,0))) { ! 1212: Pclass cl = Pclass(cn->tp); ! 1213: Pname n = cl->has_oper(oper); ! 1214: if (n == 0) continue; ! 1215: ! 1216: // while (n->base==REF || n->base==MDOT) n=Pname(n->mem); ! 1217: Pfct nf = Pfct(n->tp); ! 1218: if (nf->base == FCT) { ! 1219: if (nf->nargs == 0) { ! 1220: if (Lcoerce || Rcoerce) return 2; ! 1221: Rcoerce = on; ! 1222: } ! 1223: } ! 1224: else { ! 1225: for (Plist gl=Pgen(nf)->fct_list; gl; gl=gl->l) ! 1226: if (Pfct(gl->f->tp)->nargs == 0) { ! 1227: if (Lcoerce || Rcoerce) return 2; ! 1228: Rcoerce = on; ! 1229: } ! 1230: } ! 1231: continue; ! 1232: } ! 1233: //if (rt->is_cl_obj()) continue; ! 1234: suppress_error = 1; ! 1235: int r1 = lt->kind(oper,0); ! 1236: int r2 = rt->kind(oper,0); ! 1237: ! 1238: if (np_promote(oper,r1,r2,lt,rt,1)!=any_type) { ! 1239: if (Lcoerce || Rcoerce) { ! 1240: suppress_error = 0; ! 1241: return 2; ! 1242: } ! 1243: Rcoerce = on; ! 1244: } ! 1245: suppress_error = 0; ! 1246: } ! 1247: } ! 1248: ! 1249: //error('d',"->%d || %d",Lcoerce,Rcoerce); ! 1250: return (Lcoerce || Rcoerce); ! 1251: } ! 1252: ! 1253: Pexpr expr::try_to_overload(Ptable tbl) ! 1254: { ! 1255: // TOK bb = (base==DEREF && e2==0) ? MUL : base; ! 1256: //error('d',"try_to_overload %k %k",base,base); ! 1257: ! 1258: Pname n1 = 0; ! 1259: Ptype t1 = 0; ! 1260: ! 1261: if (e1) { ! 1262: t1 = e1->tp; ! 1263: Ptype tpx = t1; ! 1264: while (tpx->base == TYPE) tpx = Pbase(tpx)->b_name->tp; ! 1265: n1 = tpx->is_cl_obj(); ! 1266: } ! 1267: ! 1268: TOK bb = base; ! 1269: switch (bb) { ! 1270: case DEREF: ! 1271: if (e2 == 0) bb = MUL; ! 1272: // no break; ! 1273: case CALL: ! 1274: case G_CALL: ! 1275: if (n1 == 0) return 0; // ignore type of argument list ! 1276: } ! 1277: ! 1278: Pname n2 = 0; ! 1279: Ptype t2 = 0; ! 1280: ! 1281: if (e2 && e2->base!=ELIST) { ! 1282: t2 = e2->tp; ! 1283: Ptype tpx = t2; ! 1284: while (tpx->base == TYPE) tpx = Pbase(tpx)->b_name->tp; ! 1285: n2 = tpx->is_cl_obj(); ! 1286: } ! 1287: ! 1288: if (n1==0 && n2==0) return 0; ! 1289: if (n1 && n1->tp == 0) return 0; // make_assign() fudge ! 1290: //error('d',"t1 %t t2 %t",t1,t2); ! 1291: //error('d',"n1 %n n2 %n",n1,n2); ! 1292: /* first try for non-member function: op(e1,e2) or op(e2) or op(e1) */ ! 1293: Pexpr oe2 = e2; ! 1294: Pexpr ee2 = (e2 && e2->base!=ELIST) ? e2 = new expr(ELIST,e2,0) : 0; ! 1295: Pexpr ee1 = e1 ? new expr(ELIST,e1,e2) : ee2; ! 1296: char* obb = oper_name(bb); ! 1297: Pname gname = gtbl->look(obb,0);// first look at member functions ! 1298: // then if necessary check for ambiguities ! 1299: int go = gname ? over_call(gname,ee1) : 0; ! 1300: //error('d',"go %d",go); ! 1301: if (go) gname = Nover; ! 1302: ! 1303: if (n1) { ! 1304: if (bb == ASSIGN) { ! 1305: Pclass c1 = Pclass(n1->tp); ! 1306: //error('d',"look %k %d",bb,c1->memtbl->look(obb,0)); ! 1307: if (c1->memtbl->look(obb,0)==0) { ! 1308: Pclass bcl = c1->baselist?c1->baselist->bclass:0; ! 1309: if (n2==0 ! 1310: || (Pclass(n2->tp)!=c1 ! 1311: && Pclass(n2->tp)->has_base(c1)==0)) { ! 1312: // if legal, a=1 can be optimized to a.ctor(1) ! 1313: if (2 < go) goto glob; ! 1314: return 0; ! 1315: } ! 1316: ! 1317: if (bcl ! 1318: && c1->obj_size!=bcl->obj_size ! 1319: && bcl->memtbl->look(obb,0)) { ! 1320: // cannot inherit from smaller base class ! 1321: // make_assignment(n1); ! 1322: // return try_to_overload(tbl); ! 1323: goto mkas; ! 1324: } ! 1325: ! 1326: if (c1->c_xref&(C_VBASE|C_VPTR|C_ASS)) { ! 1327: // make operator=() if ! 1328: // no base (shouldn't happen ! 1329: // different (smaller) sized base ! 1330: // two bases ! 1331: mkas: ! 1332: if (2 < go) goto glob; ! 1333: // make_assignment(n1); ! 1334: // return try_to_overload(tbl); ! 1335: return make_assignment(n1) ? try_to_overload(tbl) : 0; ! 1336: } ! 1337: //error('d',"n2 %n",n2); ! 1338: // if (n2 && Pclass(n2->tp)==c1) ! 1339: return 0; ! 1340: } ! 1341: // now take care of other assignments, ! 1342: } ! 1343: ! 1344: Pexpr mn = Pclass(n1->tp)->find_name(obb,0); ! 1345: Pname mname = Pname(mn); ! 1346: //error('d',"mn %n %d %k %s",mname,mn,mn?mn->base:0,obb); ! 1347: if (mname == 0) goto glob; ! 1348: ! 1349: zaq: ! 1350: switch (mname->base) { ! 1351: case REF: ! 1352: case MDOT: ! 1353: mname = Pname(Pexpr(mname)->mem); ! 1354: goto zaq; ! 1355: } ! 1356: ! 1357: int mo = over_call(mname,e2); ! 1358: //error('d',"mo %d (go %d)",mo,go); ! 1359: if (mo==0 || mo<go) ! 1360: goto glob; ! 1361: else if (mo && mo==go) { ! 1362: //error('d',"t1 %t t2 %t",t1,t2); ! 1363: if (gname->tp->base == OVERLOAD) { // find right version ! 1364: for (Plist l = Pgen(gname->tp)->fct_list; l; l=l->l) { ! 1365: Pname n = l->f; ! 1366: int x = over_call(n,ee1); ! 1367: if (x == go) { ! 1368: gname = n; ! 1369: break; ! 1370: } ! 1371: } ! 1372: } ! 1373: //error('d',"gname %n: %t",gname,gname->tp); ! 1374: Pname aa = Pfct(gname->tp)->argtype; ! 1375: Pptr p; ! 1376: Ptype gt1 = aa->tp; ! 1377: if (p = gt1->is_ref()) gt1 = p->typ; ! 1378: Ptype gt2 = aa->n_list->tp; ! 1379: //error('d',"gt1 %t gt2 %t",gt1,gt2); ! 1380: if (mname->tp->base == OVERLOAD) { // find right version ! 1381: for (Plist l = Pgen(mname->tp)->fct_list; l; l=l->l) { ! 1382: Pname n = l->f; ! 1383: int x = over_call(n,e2); ! 1384: if (x == mo) { ! 1385: mname = n; ! 1386: break; ! 1387: } ! 1388: } ! 1389: } ! 1390: //error('d',"mname %n: %t",mname,mname->tp); ! 1391: Ptype mt1 = Pfct(mname->tp)->f_this->tp; ! 1392: mt1 = Pptr(mt1)->typ; ! 1393: Ptype mt2 = Pfct(mname->tp)->argtype->tp; ! 1394: //error('d',"mt1 %t mt2 %t",mt1,mt2); ! 1395: Pname mm = new name; ! 1396: Pname a1 = new name; ! 1397: a1->tp = mt1; ! 1398: Pname a2 = new name; ! 1399: a2->tp = mt2; ! 1400: a1->n_list = a2; ! 1401: mm->tp = new fct(void_type,a1,2); ! 1402: Pname gg = new name; ! 1403: Pname a3 = new name; ! 1404: a3->tp = gt1; ! 1405: Pname a4 = new name; ! 1406: a4->tp = gt2; ! 1407: a3->n_list = a4; ! 1408: gg->tp = new fct(void_type,a3,1); ! 1409: extern Pname dominate(Pname,Pname,Pexpr,int,int); ! 1410: aa = dominate(gg,mm,ee1,0,1); ! 1411: delete a1; ! 1412: delete a2; ! 1413: delete a3; ! 1414: delete a4; ! 1415: delete gg->tp; ! 1416: delete mm->tp; ! 1417: if (aa == 0) { ! 1418: delete gg; ! 1419: delete mm; ! 1420: error("ambiguous operandTs%n and%t for%k",n1,t2,bb); ! 1421: tp = any_type; ! 1422: return this; ! 1423: } ! 1424: else if (aa == gg) { ! 1425: delete gg; ! 1426: delete mm; ! 1427: goto glob; ! 1428: } ! 1429: delete gg; ! 1430: delete mm; ! 1431: } ! 1432: else if (mo < 2) { // user-defined conversion user ! 1433: if (try_to_demote(bb,t1,t2)) ! 1434: error("ambiguous use of overloaded%k",bb); ! 1435: } ! 1436: ! 1437: base = G_CALL; // e1.op(e2) or e1.op() ! 1438: Pname xx = new name(mname->string); // do another lookup ! 1439: // . suppresses virtual ! 1440: e1 = new ref(DOT,e1,xx); ! 1441: if (ee1) delete ee1; ! 1442: return typ(tbl); ! 1443: } ! 1444: ! 1445: if (n2 && e1==0) { /* look for unary operator */ ! 1446: Pexpr mn = Pclass(n2->tp)->find_name(obb,0); ! 1447: Pname mname = Pname(mn); ! 1448: if (mname == 0) goto glob; ! 1449: zaqq: ! 1450: switch (mname->base) { ! 1451: case REF: ! 1452: case MDOT: ! 1453: mname = Pname(Pexpr(mname)->mem); ! 1454: goto zaqq; ! 1455: } ! 1456: ! 1457: switch (mname->n_scope) { ! 1458: default: goto glob; ! 1459: case 0: ! 1460: case PUBLIC: break; // try e2.op() ! 1461: } ! 1462: ! 1463: int mo = over_call(mname,0); ! 1464: //error('d',"e2 mo %d (go %d)",mo,go); ! 1465: if (mo==0 || mo<go) ! 1466: goto glob; ! 1467: else if (mo==go) { ! 1468: error("ambiguous operandT%n for%k",n2,bb); ! 1469: tp = any_type; ! 1470: return this; ! 1471: } ! 1472: else if (mo < 2) { // user-defined conversion user ! 1473: if (try_to_demote(bb,t1,t2)) ! 1474: error("ambiguous use of overloaded%k",bb); ! 1475: } ! 1476: base = G_CALL; // e2.op() ! 1477: Pname xx = new name(Nover->string); // do another lookup ! 1478: // . suppresses virtual ! 1479: e1 = new ref(DOT,oe2,xx); ! 1480: e2 = 0; ! 1481: if (ee2) delete ee2; ! 1482: if (ee1 && ee1!=ee2) delete ee1; ! 1483: return typ(tbl); ! 1484: } ! 1485: ! 1486: glob: ! 1487: //error('d',"glob %d",go); ! 1488: ! 1489: if (go) { ! 1490: if (go < 2) { // user-defined conversion necessary => binary ! 1491: if (try_to_demote(bb,t1,t2)) ! 1492: error("ambiguous use of overloaded%k: %t and %t",bb,t1,t2); ! 1493: } ! 1494: ! 1495: base = G_CALL; // ::op(e1,e2) or ::op(e1) or ::op(e2) ! 1496: //error('d',"gname %n %t",gname,gname->tp); ! 1497: e1 = new name(gname->string); ! 1498: Pname(e1)->n_qualifier = sta_name; // look only for globals ! 1499: e2 = ee1; ! 1500: return typ(tbl); ! 1501: } ! 1502: ! 1503: if (ee2) delete ee2; ! 1504: if (ee1 && ee1!=ee2) delete ee1; ! 1505: e2 = oe2; ! 1506: ! 1507: //error('d',"bb %d %k",bb,bb); ! 1508: switch (bb) { ! 1509: case CM: ! 1510: case G_CM: ! 1511: case G_ADDROF: ! 1512: return 0; ! 1513: case ASSIGN: ! 1514: if (n1 ! 1515: && n2 ! 1516: && (n1->tp==n2->tp || Pclass(n2->tp)->has_base(Pclass(n1->tp)))) { ! 1517: if (make_assignment(n1)) ! 1518: return try_to_overload(tbl); ! 1519: else ! 1520: return 0; ! 1521: } ! 1522: case DEREF: ! 1523: case CALL: ! 1524: if (n1 == 0) break; ! 1525: ! 1526: default: /* look for conversions to basic types */ ! 1527: if (n1 ! 1528: && Pclass(n1->tp)->conv ! 1529: && (bb==ANDAND || bb==OROR)) { ! 1530: e1 = check_cond(e1,bb,tbl); ! 1531: return 0; ! 1532: } ! 1533: ! 1534: if (n2 ! 1535: && Pclass(n2->tp)->conv ! 1536: && (bb==ANDAND || bb==OROR || bb==NOT)) { ! 1537: e2 = check_cond(e2,bb,tbl); ! 1538: return 0; ! 1539: } ! 1540: ! 1541: switch (try_to_demote(bb,t1,t2)) { ! 1542: default: ! 1543: if (Lcoerce) error("ambiguous conversion of%n",n1); ! 1544: if (Rcoerce) error("ambiguous conversion of%n",n2); ! 1545: case 0: ! 1546: break; ! 1547: case 1: ! 1548: if (Lcoerce) { ! 1549: Pname xx = new name(Lcoerce->string); ! 1550: Pref r = new ref(DOT,e1,xx); ! 1551: e1 = new expr(G_CALL,r,0); ! 1552: } ! 1553: ! 1554: if (Rcoerce) { ! 1555: Pname xx = new name(Rcoerce->string); ! 1556: Pref r = new ref(DOT,e2,xx); ! 1557: e2 = new expr(G_CALL,r,0); ! 1558: } ! 1559: return typ(tbl); ! 1560: } ! 1561: ! 1562: switch (bb) { ! 1563: case CM: ! 1564: case ADDROF: // has legal built-in meaning ! 1565: return 0; ! 1566: } ! 1567: ! 1568: if (t1 && t2) ! 1569: error("bad operandTs%t%t for%k",t1,t2,bb); ! 1570: else ! 1571: error("bad operandT%t for%k",t1?t1:t2,bb); ! 1572: ! 1573: tp = any_type; ! 1574: return this; ! 1575: } ! 1576: ! 1577: return 0; ! 1578: } ! 1579: ! 1580: Pexpr cast_cptr(Pclass ccl, Pexpr ee, Ptable tbl, int real_cast) ! 1581: /* ! 1582: "ee" is being cast to pointer object of class "ccl" ! 1583: if necessary modify "ee" ! 1584: */ ! 1585: { ! 1586: ! 1587: // Ptype etp = ee->tp; ! 1588: //error('d',"cast_cptr %k ccl %t ee->tp %t",ee->tp->base,ccl,ee->tp); ! 1589: ! 1590: // if (etp->base!=PTR && etp->base!=RPTR) return ee; ! 1591: Ptype etp = ee->tp->is_ptr_or_ref(); ! 1592: if (etp == 0) return ee; ! 1593: ! 1594: Pname on = Pptr(etp)->typ->is_cl_obj(); ! 1595: if (on == 0) return ee; ! 1596: ! 1597: Pclass ocl = Pclass(on->tp); ! 1598: if (ocl==ccl || ccl==0 || ocl==0) return ee; ! 1599: ! 1600: //error('d',"cast_cptr %t(%t) real %d",ccl,ocl,real_cast); ! 1601: int oo = 0; ! 1602: Pexpr r = 0; ! 1603: ! 1604: if (ocl->baselist ! 1605: && (ocl->baselist->bclass!=ccl || ocl->baselist->base!=NAME)) { ! 1606: // casting derived to second or virtual base? ! 1607: Nptr = 0; ! 1608: vcllist->clear(); ! 1609: vcllist=0; ! 1610: int x = is_unique_base(ocl,ccl->string,0); ! 1611: //error('d',"x1 %d",x); ! 1612: if (Nvis) { ! 1613: if (real_cast==0) ! 1614: error("cast:%n* ->B%t*; privateBC",on,ccl); ! 1615: else if (warning_opt) ! 1616: error('w',"cast:%n* ->B%t*; privateBC",on,ccl); ! 1617: real_cast = 1; // suppress further error mesages ! 1618: Nvis = 0; ! 1619: } ! 1620: ! 1621: switch (x) { ! 1622: default: ! 1623: error("cast:%n* ->B%t*;%t isB more than once",on,ccl,ccl); ! 1624: case 0: // unrelated; ! 1625: break; ! 1626: case 1: ! 1627: oo = Noffset; ! 1628: break; ! 1629: } ! 1630: ! 1631: if (Nptr) { // => ee?Nptr:0 ! 1632: //error('d',"nptr"); ! 1633: if (ocl->c_body==1) ocl->dcl_print(0); ! 1634: Nptr->mem = ee; // ee->Pbase_class ! 1635: Nptr->i1 = 3; ! 1636: if (ee->base==ADDROF || ee->base==G_ADDROF) ! 1637: ee = Nptr; ! 1638: else { ! 1639: Pexpr p = new expr(QUEST,Nptr,zero); ! 1640: extern nin; ! 1641: nin = 1; ! 1642: if (ee->not_simple()) { // need temp ! 1643: Ptype t = ee->tp; ! 1644: Pname pp = make_tmp('N',t,tbl); ! 1645: Pname(pp)->n_assigned_to = 1; ! 1646: ee = new expr(ASSIGN,pp,ee); ! 1647: ee->tp = t; ! 1648: Nptr->mem = pp; ! 1649: } ! 1650: nin = 0; ! 1651: p->cond = ee; ! 1652: //error('d',"p->tp %t",ee->tp); ! 1653: p->tp = ee->tp; ! 1654: ee = p; ! 1655: } ! 1656: } ! 1657: } ! 1658: ! 1659: if (ccl->baselist ! 1660: && (ccl->baselist->bclass!=ocl || ccl->baselist->base!=NAME)) { ! 1661: // casting second or virtual base to derived? ! 1662: Nptr = 0; ! 1663: vcllist->clear(); ! 1664: vcllist=0; ! 1665: int x = is_unique_base(ccl,ocl->string,0); ! 1666: //error('d',"x2 %d",x); ! 1667: switch (x) { ! 1668: default: ! 1669: error("cast:%n* ->derived%t*;%n isB more than once",on,ccl,on); ! 1670: case 0: // unrelated; ! 1671: break; ! 1672: case 1: ! 1673: oo = -Noffset; ! 1674: if (Nptr) ! 1675: error("cast:%n* ->derived%t*;%n is virtualB",on,ccl,on); ! 1676: break; ! 1677: } ! 1678: Nvis = 0; // visibility no concern when converting ! 1679: // from base to derived ! 1680: ! 1681: ! 1682: } ! 1683: //error('d',"oo %d ee %k",oo,ee->base); ! 1684: if (oo) { // => ee?ee+offset:0 ! 1685: if (ee->base==ADDROF || ee->base==G_ADDROF) ! 1686: ee = rptr(ee->tp,ee,oo); ! 1687: else { ! 1688: Pexpr p; ! 1689: extern nin; ! 1690: nin = 1; ! 1691: if (ee->not_simple()) { // need temp ! 1692: Ptype t = ee->tp; ! 1693: Pname pp = make_tmp('M',t,tbl); ! 1694: Pname(pp)->n_assigned_to = 1; ! 1695: ee = new expr(ASSIGN,pp,ee); ! 1696: ee->tp = t; ! 1697: p = rptr(t,pp,oo); ! 1698: } ! 1699: else ! 1700: p = rptr(ee->tp,ee,oo); ! 1701: nin = 0; ! 1702: Pexpr pp = new expr(QUEST,p,zero); ! 1703: pp->tp = ee->tp; ! 1704: pp->cond = ee; ! 1705: ee = pp; ! 1706: } ! 1707: } ! 1708: ! 1709: if (ocl->has_base(ccl) && Nvis) { ! 1710: if (real_cast==0) ! 1711: error("cast:%n* ->B%t*; privateBC",on,ccl); ! 1712: else if (warning_opt) ! 1713: error('w',"cast:%n* ->B%t*; privateBC",on,ccl); ! 1714: Nvis = 0; ! 1715: } ! 1716: ! 1717: //error('d',"return %d %k %t",ee,ee->base,ee->tp); ! 1718: return ee; ! 1719: } ! 1720: ! 1721: Pexpr expr::donew(Ptable tbl) ! 1722: { ! 1723: Ptype tt = tp2; ! 1724: Ptype tpx = tt; ! 1725: bit v = 0; ! 1726: bit old = new_type; ! 1727: int init = 0; // non-constructor initialization ! 1728: new_type = 1; ! 1729: ! 1730: tt->dcl(tbl); ! 1731: new_type = old; ! 1732: //error('d',"donew %d %d (%k) tt %t",e1,e2,e2?e2->base:0,tt); ! 1733: if (e1) e1 = e1->typ(tbl); ! 1734: if (e2) e2 = e2->typ(tbl); ! 1735: ll: ! 1736: //error('d',"ll %d",tt->base); ! 1737: switch (tt->base) { ! 1738: default: ! 1739: if ( e1) { ! 1740: if (v) { ! 1741: error("Ir for array created using \"new\""); ! 1742: break; ! 1743: } ! 1744: init = 1; ! 1745: } ! 1746: // if (e1) { ! 1747: // error("Ir for nonCO created using \"new\""); ! 1748: // e1 = 0; ! 1749: // } ! 1750: break; ! 1751: case VEC: ! 1752: if (v && Pvec(tt)->dim) error("only 1st array dimension can be non-constant"); ! 1753: if (Pvec(tt)->size==0 && Pvec(tt)->dim==0) error("array dimension missingin `new'"); ! 1754: // if (Pvec(tt)->dim==zero) { ! 1755: // Pvec(tt)->size = 0; ! 1756: // Pvec(tt)->dim = 0; ! 1757: // } ! 1758: v++; ! 1759: tt = Pvec(tt)->typ; ! 1760: goto ll; ! 1761: case TYPE: ! 1762: tt = Pbase(tt)->b_name->tp; ! 1763: goto ll; ! 1764: case VOID: ! 1765: error("badT for `new': void"); ! 1766: break; ! 1767: case COBJ: ! 1768: { Pname cn = Pbase(tt)->b_name; ! 1769: Pclass cl = Pclass(cn->tp); ! 1770: Pname icn = (e1 && e1->base!=ELIST) ? e1->tp->is_cl_obj() : 0; ! 1771: Pclass icl = icn ? Pclass(icn->tp) : 0; ! 1772: ! 1773: if (cl->c_abstract) { ! 1774: error("`new' of abstractC%t",cl); ! 1775: break; ! 1776: } ! 1777: ! 1778: if (v && e1) { ! 1779: error("Ir for array ofCO created using \"new\""); ! 1780: break; ! 1781: } ! 1782: ! 1783: if ((cl->defined&(DEFINED|SIMPLIFIED)) == 0) { ! 1784: error("new%n;%n isU",cn,cn); ! 1785: break; ! 1786: } ! 1787: ! 1788: Pname ctor = cl->has_ctor(); ! 1789: ! 1790: if (ctor) { ! 1791: if (v) { ! 1792: Pname ic; ! 1793: if ((ic = cl->has_ictor())==0) { ! 1794: error("array ofC%n that does not have aK taking noAs",cn); ! 1795: break; ! 1796: } ! 1797: ! 1798: if (Pfct(ic->tp)->nargs) { ! 1799: error("defaultAs forK for array ofC%n",cn); ! 1800: break; ! 1801: } ! 1802: } ! 1803: ! 1804: if (icl ! 1805: && cl->has_itor()==0 // incomplete: ! 1806: // what if X(Y&) exists ! 1807: // for class Y : X ? ! 1808: && (icl==cl || icl->has_base(cl))) { ! 1809: init = 1; ! 1810: break; ! 1811: } ! 1812: e1 = call_ctor(tbl,0,ctor,e1); ! 1813: } ! 1814: else if (e1) { ! 1815: if (icl==cl || icl->has_base(cl)) ! 1816: init = 1; ! 1817: else ! 1818: error("new%n(As ); %n does not have aK",cn,cn); ! 1819: } ! 1820: } ! 1821: } ! 1822: ! 1823: if (init) { ! 1824: Pname tmp = make_tmp('N',tt->addrof(),tbl); ! 1825: e1 = e1->typ(tbl); ! 1826: if (tt->check(e1->tp,ASSIGN)) ! 1827: error("badIrT %t for new operator (%t X)",e1->tp,tt); ! 1828: e1 = new expr(0,tmp,e1); ! 1829: tmp->assign(); ! 1830: } ! 1831: ! 1832: // tp = (v) ? tpx : tpx->addrof(); ! 1833: switch (v) { ! 1834: case 0: ! 1835: tp = tpx->addrof(); ! 1836: break; ! 1837: case 1: ! 1838: tp = tpx; ! 1839: break; ! 1840: default: ! 1841: tp = tpx; ! 1842: } ! 1843: //error('d',"donew(%d) -> %t",v,tp); ! 1844: return this; ! 1845: } ! 1846: ! 1847: static is_dataMemPtr( Pexpr ee ) ! 1848: /* this is utterly implementation dependent ! 1849: * called by expr::lval to determine ! 1850: * const objects bounds to pointers to data members ! 1851: */ ! 1852: { ! 1853: Pexpr te = ee->e1; ! 1854: if ( te == 0 ) return 0; ! 1855: if ( te->base != PLUS ) return 0; ! 1856: if ( (te = te->e2) == 0 ) return 0; ! 1857: if ( te->base != MINUS ) return 0; ! 1858: if ( (te = te->e1) == 0 ) return 0; ! 1859: if ( te->base != CAST ) return 0; ! 1860: if ( (te = te->e1) == 0 ) return 0; ! 1861: if ( te->tp->base != PTR ) return 0; ! 1862: if ( Pptr(te)->memof == 0 ) return 0; ! 1863: return 1; ! 1864: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.