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