![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to expr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront / ptcfront|
Return to expr.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / ptcfront |
1.1 ! root 1: /*ident "@(#)ctrans:src/expr.c 1.16" */ ! 2: /*************************************************************************** ! 3: ! 4: C++ source for cfront, the C++ compiler front-end ! 5: written in the computer science research center of Bell Labs ! 6: ! 7: Copyright (c) 1984 AT&T, Inc. All rights Reserved ! 8: THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC. ! 9: ! 10: expr.c: ! 11: ! 12: type check expressions ! 13: ! 14: ************************************************************************/ ! 15: ! 16: #include "cfront.h" ! 17: #include "size.h" ! 18: ! 19: int const_save; ! 20: int const_ptr; ! 21: extern Ptype Pfct_type; ! 22: ! 23: Pexpr expr::address() ! 24: { ! 25: // error('d',"address %k %d %s",base,base,base==NAME||base==ANAME?string:"?"); ! 26: // error('d',"address e1 %d %k e2 %d %k", e1, e1?e1->base:0, e2, e2?e2->base:0); ! 27: switch (base) { ! 28: case DEREF: ! 29: if (e2 == 0) return e1; // &*e => e ! 30: break; ! 31: case QUEST: // &(a?b:c) => a?&b:&c ! 32: e1 = e1->address(); ! 33: // no break; ! 34: case G_CM: ! 35: if ( e1 && e1->base == G_CALL && ! 36: e2 && e2->base == G_ADDROF) ! 37: return this; ! 38: case CM: ! 39: e2 = e2->address(); // &(e1,e2) => (e1,&e2) ! 40: tp = e2->tp; //LLL ! 41: return this; ! 42: case INCR: ! 43: case DECR: // &(++a) => (++a,&a) ! 44: if (e1) break; ! 45: nin++; ! 46: if (e2->not_simple()) error('s',"& of%k",base); ! 47: nin--; ! 48: e1 = new expr(base,0,e2); ! 49: e2 = e2->address(); ! 50: base = G_CM; ! 51: tp = e2->tp; ! 52: return this; ! 53: case ASSIGN: // &(a=b) => ((a=b),&a) ! 54: case ASPLUS: ! 55: case ASMINUS: ! 56: case ASMUL: ! 57: case ASDIV: ! 58: case ASMOD: ! 59: case ASAND: ! 60: case ASOR: ! 61: case ASER: ! 62: case ASLS: ! 63: case ASRS: ! 64: nin++; ! 65: if (e1->not_simple()) error('s',"& of%k",base); ! 66: nin--; ! 67: Pexpr a = new expr(base,e1,e2); ! 68: a->tp = a->e1->tp; ! 69: base = G_CM; ! 70: e1 = a; ! 71: e2 = a->e1->address(); ! 72: tp = e2->tp; ! 73: return this; ! 74: ! 75: case NAME: ! 76: if (Pname(this)->n_stclass == REGISTER) error("& register%n",Pname(this)); ! 77: Pname(this)->take_addr(); ! 78: break; ! 79: case CALL: ! 80: case CAST: ! 81: case NEW: ! 82: case GNEW: ! 83: if (tp && tp->is_ptr_or_ref()) { // hack? ! 84: return this; ! 85: } ! 86: break; ! 87: } ! 88: ! 89: register Pexpr ee = new expr(G_ADDROF,0,this); ! 90: if (tp) { // tp==0 ??? ! 91: ee->tp = tp->addrof(); ! 92: ! 93: switch (tp->base) { ! 94: case PTR: ! 95: Pptr(ee->tp)->memof = Pptr(tp)->memof; ! 96: break; ! 97: case FCT: ! 98: if (Pfct(tp)->f_static==0) ! 99: Pptr(ee->tp)->memof = Pfct(tp)->memof; ! 100: break; ! 101: case OVERLOAD: ! 102: if (Pfct(Pgen(tp)->fct_list->f->tp)->f_static==0) ! 103: Pptr(ee->tp)->memof = Pfct(Pgen(tp)->fct_list->f->tp)->memof; ! 104: } ! 105: } ! 106: ! 107: return ee; ! 108: } ! 109: ! 110: Pexpr expr::contents() ! 111: { ! 112: //error('d',"deref %k %d %t",base,base,tp); ! 113: // if (base==ADDROF || base==G_ADDROF) return e2; // *& ! 114: switch (base) { ! 115: case ADDROF: ! 116: case G_ADDROF: ! 117: return e2; // *& ! 118: case ELIST: ! 119: //error('d',"contents of elist"); ! 120: e1 = e1->contents(); ! 121: tp = e1->tp; ! 122: return this; ! 123: }; ! 124: ! 125: register Pexpr ee = new expr(DEREF,this,0); ! 126: if (tp) { // tp==0 ??? ! 127: Ptype tt = tp->skiptypedefs(); ! 128: ee->tp = Pptr(tt)->typ; ! 129: Pname cn = ee->tp->is_cl_obj(); ! 130: if (cn) { ! 131: // look for first use of class ! 132: Pclass cl = Pclass(cn->tp); ! 133: if (cl->c_body==1) cl->dcl_print(0); ! 134: } ! 135: } ! 136: return ee; ! 137: } ! 138: ! 139: static Pexpr ! 140: make_postfix( Pexpr op, Pname fn=0 ) { ! 141: /* apply the postfix form of increment/decrement operator ! 142: * if (fn) special call from check_postscipt to handle ! 143: * the two operator instances declared at different scopes ! 144: * i.e., member and non-member, therefore stored as FCTs. ! 145: */ ! 146: Pfct f; ! 147: Plist fl; ! 148: Pname n = fn?fn:0; ! 149: Pexpr e = op->e1->base==NAME?op->e1:op->e1->mem; ! 150: if (n) goto mk_postfix; // sorry(!!!) ! 151: ! 152: for (fl=Pgen(e->tp)->fct_list;fl; fl=fl->l) { ! 153: n = fl->f; ! 154: f = Pfct(n->tp); ! 155: if ((f->nargs==1 && f->f_this) || ! 156: (f->nargs==2 && f->f_this==0)) { ! 157: ! 158: mk_postfix: // rewrite the call expression ! 159: if (op->e1->base == NAME) { ! 160: op->e1 = n; ! 161: op->e2->e2 = new expr(ELIST,zero,0); ! 162: } else { ! 163: op->e1->mem = n; ! 164: op->e2 = new expr(ELIST,zero,0); ! 165: } ! 166: ! 167: op->fct_name = n; ! 168: n->dcl_print(0); ! 169: return op; ! 170: } ! 171: } ! 172: error('w',"no postfix instance of%n, although overloaded",Pname(e)); ! 173: return op; // as it were ! 174: } ! 175: ! 176: static Pexpr ! 177: check_postfix( Pexpr op ) { ! 178: /* special case: member and non-member operator++/-- instances ! 179: * each stored as FCT, and so try_to_overload returns prefix instance ! 180: * need to make an explicit check if postfix instance exists ! 181: */ ! 182: int is_glob = op->e1->base==NAME ? 1: 0; ! 183: Pname fn = is_glob ? Pname(op->e1) : Pname(op->e1->mem); ! 184: ! 185: // error('d',"check_postfix: fn: %n is_glob: %d",fn,is_glob); ! 186: ! 187: if (is_glob == 0) { // found operator++/--() as member ! 188: Pname n = gtbl->look(fn->string,0); ! 189: Ptype arg_tp = op->e1->e1->tp; ! 190: ! 191: if (n==0) return op; ! 192: if (n->tp->base == FCT) { // one global instance ! 193: Pfct ff = Pfct(n->tp); ! 194: ! 195: // error('d',"check_postfix: global n:%n arg: %t act: %t",n,ff->argtype->tp,arg_tp); ! 196: extern int exact1(Pname,Ptype); // place in cfront.h ! 197: ! 198: if (ff->nargs != 2) return op; ! 199: if (exact1(ff->argtype, arg_tp)==0) return op; ! 200: return make_postfix(op,n); ! 201: } ! 202: if (n->tp->base == OVERLOAD) { // multiple global instances ! 203: for (Plist fl=Pgen(n->tp)->fct_list; fl; fl=fl->l) { ! 204: Pname nn = fl->f; ! 205: Pfct ff = Pfct(nn->tp); ! 206: if (ff->nargs != 2) continue; ! 207: if (exact1(ff->argtype, arg_tp)==0) continue; ! 208: return make_postfix(op,nn); ! 209: } ! 210: return op; ! 211: } ! 212: } ! 213: else { // examine class table for postfix member ! 214: Pfct f = Pfct(fn->tp); ! 215: Pptr p = f->argtype->tp->is_ptr_or_ref(); ! 216: Ptype t = p?p->typ:f->argtype->tp; ! 217: Pname cn = t->is_cl_obj(); ! 218: if (cn == 0) error('i',"check_postfix: %n(%n %t),CTX",fn,f->argtype,t); ! 219: ! 220: Pname nn = Pclass(cn->tp)->memtbl->look(fn->string,0); ! 221: // error('d',"check_postfix: found: %n %t", nn, nn->tp); ! 222: if (nn) return make_postfix(op,nn); ! 223: return op; ! 224: } ! 225: } ! 226: ! 227: int bound; ! 228: int chars_in_largest; // no of characters in largest int ! 229: static Pclass mpglob; ! 230: ! 231: Pexpr expr::typ(Ptable tbl) ! 232: /* ! 233: find the type of "this" and place it in tp; ! 234: return the typechecked version of the expression: ! 235: "tbl" provides the scope for the names in "this" ! 236: */ ! 237: { ! 238: //if (this == 0) error('i',"0->expr::typ"); ! 239: Pname n; ! 240: Ptype t = 0; ! 241: Ptype t1, t2; ! 242: TOK b = base; ! 243: TOK r1, r2; ! 244: #define nppromote(b) t=np_promote(b,r1,r2,t1,t2,1) ! 245: #define npcheck(b) (void)np_promote(b,r1,r2,t1,t2,0) ! 246: if (tbl->base != TABLE) error('i',"expr::typ(%d)",tbl->base); ! 247: ! 248: DB( if(Tdebug>=1) { ! 249: error('d',"%d->expr::typ(%d) %k %t",this,tbl,b,tp); ! 250: display_expr(this); ! 251: }); ! 252: // error('d',"%k->typ %n tp: %t", b,b==NAME?this:0,tp); ! 253: // error('d'," e1 %d %k e1 %d %k",e1,e1?e1->base:0,e2,e2?e2->base:0); ! 254: ! 255: if (tp) { ! 256: switch (b) { ! 257: case NAME: ! 258: //?? Pname(this)->use(); ! 259: break; ! 260: case MDOT: ! 261: mem = mem->typ(tbl); ! 262: } ; ! 263: // if (b == NAME) Pname(this)->use(); ! 264: return this; ! 265: } ! 266: ! 267: extern Pname Ntmp; ! 268: ! 269: switch (b) { // is it a basic type ! 270: case MDOT: ! 271: error('i',"mdot %s",string2); ! 272: case DUMMY: ! 273: error("emptyE"); ! 274: tp = any_type; ! 275: return this; ! 276: ! 277: case ZERO: ! 278: tp = zero_type; ! 279: return this; ! 280: ! 281: case IVAL: ! 282: tp = int_type; ! 283: return this; ! 284: ! 285: //case FVAL: ! 286: // tp = float_type; ! 287: // return this; ! 288: ! 289: case ICON: ! 290: /* is it long? ! 291: explicit long? ! 292: decimal larger than largest signed int ! 293: octal or hexadecimal larger than largest unsigned int ! 294: */ ! 295: { int ll = strlen(string); ! 296: switch (string[ll-1]) { ! 297: case 'l': ! 298: case 'L': ! 299: switch (string[ll-2]) { ! 300: case 'u': ! 301: case 'U': ! 302: string[ll-2] = 0; ! 303: tp = ulong_type; ! 304: goto cast_n_save; ! 305: } ! 306: lng: ! 307: tp = long_type; ! 308: goto save; ! 309: case 'u': ! 310: case 'U': // 1u => unsigned(1) ! 311: switch (string[ll-2]) { ! 312: case 'l': ! 313: case 'L': ! 314: string[ll-2] = 0; ! 315: ulng: ! 316: tp = ulong_type; ! 317: goto cast_n_save; ! 318: default: ! 319: string[ll-1] = 0; ! 320: uint: ! 321: tp = uint_type; ! 322: goto cast_n_save; ! 323: } ! 324: } ! 325: ! 326: // no suffix - see if we can figure it out ! 327: if (string[0] == '0') { // assume 8 bits in byte ! 328: register index = 1; ! 329: switch (string[1]) { ! 330: case 'x': ! 331: case 'X': ! 332: while(string[++index]=='0') ; ! 333: ll -= index; ! 334: int HSZ = SZ_INT+SZ_INT; ! 335: if(ll < HSZ) goto nrm; ! 336: if(ll == HSZ) ! 337: if(string[2]>='8') goto uint; ! 338: else goto nrm; ! 339: if(SZ_INT==SZ_LONG) break; ! 340: HSZ = SZ_LONG+SZ_LONG; ! 341: if(ll < HSZ) goto lng; ! 342: if(ll == HSZ) ! 343: if(string[2]>='8') goto ulng; ! 344: else goto lng; ! 345: break; ! 346: default: // OCTAL ! 347: register IBITS = BI_IN_BYTE*SZ_INT; ! 348: while(string[index]=='0') index++; ! 349: register char x = string[index]; ! 350: int lbt = x=='1' ? 1 : ! 351: ( x=='2' || x=='3' ? 2 : 3 ); ! 352: int nbits = (ll-index-1)*3 + lbt; ! 353: if(nbits < IBITS) goto nrm; ! 354: if(nbits == IBITS) goto uint; ! 355: if(nbits < BI_IN_BYTE*SZ_LONG) goto lng; ! 356: } ! 357: goto ulng; ! 358: } ! 359: else { // DECIMAL ! 360: if (ll<chars_in_largest) { ! 361: nrm: ! 362: tp = int_type; ! 363: goto save; ! 364: } ! 365: if (ll>chars_in_largest) { ! 366: if(SZ_INT==SZ_LONG || ll>2*chars_in_largest) ! 367: goto ulng; ! 368: goto lng; ! 369: } ! 370: // ll == chars_in_largest ! 371: char* p = string; ! 372: char* q = LARGEST_INT; ! 373: do if (*p>*q) { ! 374: if(SZ_INT==SZ_LONG) goto ulng; ! 375: goto lng; ! 376: } while (*p++==*q++ && *p); ! 377: } ! 378: ! 379: goto nrm; ! 380: } ! 381: case CCON: ! 382: tp = c_strlen(string)<5 ? char_type : int_type; // stored as 'a' ! 383: goto save; ! 384: ! 385: case FCON: ! 386: { int ll = strlen(string); ! 387: int last = string[ll-1]; ! 388: tp = double_type; ! 389: if (last=='F' || last=='f') { ! 390: tp = float_type; ! 391: if (!ansi_opt) { ! 392: string[ll-1] = 0; ! 393: goto cast_n_save; ! 394: } ! 395: } ! 396: else if (last=='L' || last=='l') { ! 397: if (ansi_opt == 0) string[ll-1] = 0; ! 398: tp = ldouble_type; ! 399: } ! 400: goto save; ! 401: } ! 402: case STRING: // type of "as\tdf" is char[6] ! 403: // c_strlen counts the terminating '\0' ! 404: { Pvec v = new vec(char_type,0); ! 405: v->size = c_strlen(string); ! 406: tp = v; ! 407: } ! 408: save: ! 409: if (const_save) { // "as\tdf" needs 7 chars for storage ! 410: char* p = new char[strlen(string)+1]; ! 411: strcpy(p,string); ! 412: string = p; ! 413: } ! 414: ! 415: return this; ! 416: ! 417: cast_n_save: ! 418: if (const_save) { // "as\tdf" needs 7 chars for storage ! 419: char* p = new char[strlen(string)+1]; ! 420: strcpy(p,string); ! 421: string = p; ! 422: } ! 423: ! 424: return new cast(tp,this); ! 425: ! 426: case THIS: ! 427: delete this; ! 428: if (cc->c_this) { ! 429: cc->c_this->use(); ! 430: return cc->c_this; ! 431: } ! 432: error("``this'' used in nonC context"); ! 433: n = new name("this"); ! 434: n->tp = any_type; ! 435: return tbl->insert(n,0); ! 436: ! 437: case NAME: ! 438: { ! 439: Pname q = Pname(this)->n_qualifier; // suppress virtual iff x:: ! 440: Pexpr ee = find_name(Pname(this),cc->cot,tbl,0,cc->nof); ! 441: if (q && (ee->base==REF || ee->base==DOT)) ! 442: ee->n_initializer = Pexpr(q); ! 443: //error('d',"ee %k %t %n",ee->base,ee->tp,ee->base==NAME?ee:ee->base==REF?ee->mem:0); ! 444: // if (ee->tp->base == RPTR) return ee->contents(); ! 445: if (ee->tp->is_ref()) return ee->contents(); ! 446: ! 447: if (ee->base==NAME && Pname(ee)->n_xref) { ! 448: // fudge to handle X(X&) args ! 449: ee = new expr(DEREF,ee,0); ! 450: ee->tp = ee->e1->tp; // !! ! 451: } ! 452: ! 453: return ee; ! 454: } ! 455: ! 456: case ADDROF: ! 457: case G_ADDROF: // handle lookup for &s::i ! 458: mpglob = 0; ! 459: if (e2->base == NAME) e2 = find_name(Pname(e2),cc->cot,tbl,ADDROF,cc->nof); ! 460: if (e2->base==NAME && Pname(e2)->n_xref) { ! 461: // fudge to handle X(X&) args ! 462: e2 = new expr(DEREF,e2,0); ! 463: e2->tp = e2->e1->tp; // !! ! 464: } ! 465: if (e2->base==DOT) { // &f().x = > &(tmp=f(),&tmp)->x ! 466: switch (e2->e1->base) { ! 467: case CALL: ! 468: case G_CALL: ! 469: case VALUE: ! 470: error("& non-lvalue"); ! 471: } ! 472: } ! 473: break; ! 474: ! 475: case SIZEOF: ! 476: if (tp2) { ! 477: tp2->dcl(tbl); ! 478: switch (tp2->base) { ! 479: case VOID: ! 480: error("sizeof(void)"); ! 481: break; ! 482: case CLASS: ! 483: { ! 484: Pclass cl = Pclass(tp2); ! 485: if (cl->c_body==1 ! 486: && (cl->defined&(DEFINED|SIMPLIFIED)) == 0) ! 487: error('s',"class defined within sizeof"); ! 488: } ! 489: } ! 490: ! 491: if (e1 && e1!=dummy) { ! 492: e1 = e1->typ(tbl); ! 493: DEL(e1); ! 494: e1 = dummy; ! 495: } ! 496: Pptr r = tp2->is_ref(); ! 497: if (r) tp2 = r->typ; // sizeof(T&)==sizeof(T) ! 498: } ! 499: else if (e1 == dummy) { ! 500: error("sizeof emptyE"); ! 501: tp = any_type; ! 502: return this; ! 503: } ! 504: else { ! 505: e1 = e1->typ(tbl); ! 506: tp2 = e1->tp; ! 507: if(tp2->base == VEC) tp2->permanent = 1; ! 508: if (e1->base==ILIST) // PtoM ! 509: e1 = dummy; ! 510: else if (tp2 == char_type) // sizeof ('a') ! 511: e1 = dummy; ! 512: } ! 513: (void) tp2->tsizeof(); ! 514: tp = size_t_type; ! 515: return this; ! 516: ! 517: case CAST: ! 518: // return docast(tbl); ! 519: ! 520: { Pexpr ee = docast(tbl); ! 521: return ee->tp->is_ref() ? ee->contents() : ee; ! 522: } ! 523: ! 524: ! 525: case VALUE: ! 526: if ( tp2->base == COBJ || tp2->base == EOBJ) { ! 527: Pname tp2_name = tp2->bname(); ! 528: char *s = tp2_name->string; ! 529: //Pname tn = gtbl->look( s, 0 ); ! 530: //??? non type name apparently takes precedence ! 531: // Don't use global ftn if it hides local ! 532: // class ctor. (Note: More info is needed ! 533: // to detect all cases.) ! 534: Pname tn = tbl->look( s, 0 ); ! 535: //error( 'd', "tn: %n %t lex_levels: %d %d", tn, tn?tn->tp:0, tn?tn->lex_level:0, Pbase(tp2)->b_name->lex_level ); ! 536: if ( tn && tn->n_qualifier == 0 ! 537: && tn->lex_level == tp2_name->lex_level ! 538: && (tn->tp->base==FCT || tn->tp->base==OVERLOAD)) ! 539: { ! 540: Pexpr et = new expr( CALL, tn, e1 ); ! 541: *this = *et; ! 542: b = CALL; ! 543: break; ! 544: } ! 545: } ! 546: return dovalue(tbl); ! 547: ! 548: case NEW: ! 549: case GNEW: ! 550: return donew(tbl); ! 551: ! 552: case DELETE: // delete e1 OR delete[e2] e1 ! 553: case GDELETE: ! 554: { int i; ! 555: if (e1->base == ADDROF) error('w',"delete &E"); ! 556: e1 = e1->typ(tbl); ! 557: i = e1->tp->num_ptr(DELETE); ! 558: if (i != 'P') error("nonP deleted"); ! 559: if (e2) { ! 560: e2 = e2->typ(tbl); ! 561: e2->tp->integral(DELETE); ! 562: } ! 563: tp = void_type; ! 564: return this; ! 565: } ! 566: ! 567: case ILIST: /* an ILIST is pointer to an ELIST */ ! 568: e1 = e1->typ(tbl); ! 569: tp = any_type; ! 570: return this; ! 571: ! 572: case ELIST: ! 573: { Pexpr e; ! 574: Pexpr ex; ! 575: ! 576: if (e1 == dummy && e2==0) { ! 577: error("emptyIrL"); ! 578: tp = any_type; ! 579: return this; ! 580: } ! 581: ! 582: for (e=this; e; e=ex) { ! 583: Pexpr ee = e->e1; ! 584: //error('d',"e %d %d ee %d %d",e,e?e->base:0,ee,ee?ee->base:0); ! 585: if (e->base != ELIST) error('i',"elist%k",e->base); ! 586: if (ex = e->e2) { /* look ahead for end of list */ ! 587: if (ee == dummy) error("EX in EL"); ! 588: if (ex->e1 == dummy && ex->e2 == 0) { ! 589: /* { ... , } */ ! 590: DEL(ex); ! 591: e->e2 = ex = 0; ! 592: } ! 593: } ! 594: e->e1 = ee->typ(tbl); ! 595: t = e->e1->tp; ! 596: if (t->base == FCT) { // yuk! ! 597: ee = new expr(G_ADDROF,0,e->e1); ! 598: e->e1 = ee->typ(tbl); ! 599: t = e->e1->tp; ! 600: } ! 601: } ! 602: tp = t; ! 603: return this; ! 604: } ! 605: ! 606: case DOT: ! 607: case REF: ! 608: { if (e2) { // *. or ->* ! 609: if (b == REF) b = base = REFMUL; ! 610: break; ! 611: } ! 612: ! 613: Pbase b; ! 614: ! 615: e1 = e1->typ(tbl); ! 616: t = e1->tp->skiptypedefs(); ! 617: ! 618: // check that . (->) is applied to class object (pointer) ! 619: if (base == REF) { ! 620: switch (t->base) { ! 621: case COBJ: ! 622: { ! 623: Pname n = t->classtype()->has_oper(REF); ! 624: if (n) { ! 625: n->n_used += 2; ! 626: e1 = new call(new ref(DOT,e1,n),0); ! 627: return typ(tbl); ! 628: } ! 629: // no break; ! 630: } ! 631: default: ! 632: error("nonP ->%n",mem); ! 633: t = any_type; ! 634: // no break; ! 635: case ANY: ! 636: goto qqq; ! 637: case PTR: ! 638: case VEC: ! 639: b = Pbase(Pptr(t)->typ->skiptypedefs()); ! 640: } ! 641: } ! 642: else { // base == DOT ! 643: qqq: ! 644: switch (t->base) { ! 645: default: error("nonO .%n",mem); t = any_type; ! 646: case ANY: ! 647: case COBJ: break; ! 648: } ! 649: //error('d',"dot %k",e1->base); ! 650: switch (e1->base) { ! 651: case QUEST: ! 652: case ASSIGN: ! 653: case INCR: ! 654: case DECR: ! 655: case ASPLUS: ! 656: case ASMINUS: ! 657: case ASMUL: ! 658: case ASDIV: ! 659: case ASMOD: ! 660: case ASAND: ! 661: case ASOR: ! 662: case ASER: ! 663: case ASLS: ! 664: case ASRS: ! 665: case CM: ! 666: case G_CM: ! 667: base = REF; ! 668: e1 = e1->address(); ! 669: break; ! 670: case CALL: ! 671: case G_CALL: ! 672: //error('d'," f(). %n mem->tp %t",e1->fct_name,mem->tp); ! 673: #ifdef FDOTRIGHT ! 674: // this rewrite is only necessary on machines with broken C compilers ! 675: // there seems to be a lot of those ! 676: // and for inlines (a,b).c ! 677: if (e1->fct_name && Pfct(e1->fct_name->tp)->f_inline) ! 678: #endif ! 679: { // f(). => (tmp=f(),&tmp)-> ! 680: Pname tmp = make_tmp('Q',e1->tp,tbl); ! 681: //error('d',"fdot2 %k",e1->base); ! 682: e1 = init_tmp(tmp,e1,tbl); ! 683: Pexpr aa = tmp->address(); ! 684: e1 = new expr(G_CM,e1,aa); ! 685: e1->tp = aa->tp; ! 686: base = REF; ! 687: break; ! 688: } ! 689: } ! 690: b = Pbase(t->skiptypedefs()); ! 691: } ! 692: ! 693: switch (b->base) { ! 694: default: ! 695: error("(%t) before %k%n (%n not aM)",e1->tp,base,mem,mem); ! 696: case ANY: ! 697: tp = any_type; ! 698: return this; ! 699: case COBJ: ! 700: { ! 701: Pclass cl = b->classtype(); ! 702: if (cl->c_body == 1) cl->dcl_print(0); ! 703: break; ! 704: } ! 705: } ! 706: ! 707: /* ! 708: x.m is not a const even if x is a const object, this case is handled ! 709: by lval() rejecting it ! 710: */ ! 711: ! 712: if (mem->tp) { ! 713: tp = mem->tp; ! 714: for (Pexpr ee = mem; ee->base==REF; ee = ee->e1) { ! 715: if (ee->e1 == cc->c_this) { // this-> => p-> ! 716: ee->e1 = e1; ! 717: ee->base = base; ! 718: return mem->tp->is_ref() ? mem->contents() : mem; ! 719: } ! 720: } ! 721: ! 722: // return tp->base==RPTR ? contents() : this; ! 723: return tp->is_ref() ? contents() : this; ! 724: } ! 725: ! 726: ! 727: Pname q = Pname(mem)->n_qualifier; ! 728: Pexpr e = find_name(Pname(mem),b->classtype(),0,base,cc->nof); ! 729: if (q && (e->base==REF || e->base==DOT)) ! 730: Pname(e)->n_initializer = Pexpr(q); ! 731: //error('d',"e %k %t %n",e->base,e->tp,e->base==NAME?e:e->base==REF?e->mem:0); ! 732: ! 733: for (Pexpr ee = e; ee->base==REF; ee = ee->e1) { ! 734: if (ee->e1 == cc->c_this) { // this-> => p-> ! 735: ee->e1 = e1; ! 736: ee->base = base; ! 737: break; ! 738: } ! 739: } ! 740: ! 741: if (e->base == NAME) { ! 742: switch (e->tp->base) { ! 743: case FCT: ! 744: case OVERLOAD: ! 745: mem = e; ! 746: tp = e->tp; ! 747: e = this; ! 748: } ! 749: } ! 750: ! 751: // function or static member ! 752: return e->tp->is_ref() ? e->contents() : e; ! 753: } ! 754: ! 755: //?? case G_CALL: ! 756: case CALL: /* handle undefined function names */ ! 757: //error('d',"call %k %t %k",e1->base,e1->tp,e2?e2->base:0); ! 758: if (e1->base==NAME && e1->tp==0) { ! 759: Pname q = Pname(e1)->n_qualifier; ! 760: e1 = find_name(Pname(e1),cc->cot,tbl,CALL,cc->nof); ! 761: //error('d',"e1 %k %t %n",e1->base,e1->tp,e1->base==NAME?e1:e1->base==REF?e1->mem:0); ! 762: if (q && (e1->base==REF ||e1->base==DOT)) // suppress virtual call ! 763: e1->n_initializer = Pexpr(q); ! 764: } ! 765: ! 766: if (e1->base==NAME && Pname(e1)->n_xref) { ! 767: // fudge to handle X(X&) args ! 768: e1 = new expr(DEREF,e1,0); ! 769: e1->tp = e1->e1->tp; // !! ! 770: } ! 771: ! 772: switch (e1->base) { ! 773: case DOT: ! 774: /* ! 775: #ifdef FDOTRIGHT ! 776: { ! 777: //error('d',"fdot1 %k",e1->e1->base); ! 778: switch (e1->e1->base) { ! 779: case CALL: ! 780: case G_CALL: // f().g() => (tmp=f(),tmp.g()) ! 781: { Pexpr ee = e1->e1; ! 782: Pexpr ex = ee->typ(tbl); ! 783: Pname tmp = make_tmp('Q',ex->tp,tbl); ! 784: ex = init_tmp(tmp,ex,tbl); ! 785: ! 786: Pexpr ee2 = new expr(base,e1,e2); ! 787: e1->base = DOT; ! 788: e1->e1 = tmp; ! 789: ! 790: base = G_CM; ! 791: e1 = ex; ! 792: e2 = ee2; ! 793: ! 794: return typ(tbl); ! 795: } ! 796: } ! 797: break; ! 798: } ! 799: #endif ! 800: */ ! 801: case REF: // becomes ob.x::~x(0) or ! 802: if (e2==0 // becomes p->x::~x(0) ! 803: && Pref(e1)->mem ! 804: && Pref(e1)->mem->base==NAME ! 805: && Pname(Pref(e1)->mem)->n_oper==DTOR) { ! 806: e1 = e1->typ(tbl); ! 807: Pexpr ee = call_dtor(e1->e1,Pref(e1)->mem,0,e1->base,one); ! 808: ee->tp = void_type; ! 809: return ee; ! 810: } ! 811: } ! 812: break; ! 813: ! 814: case QUEST: ! 815: cond = cond->typ(tbl); ! 816: case ANDAND: ! 817: case OROR: ! 818: Ntmp = 0; ! 819: } ! 820: ! 821: if (e1) { ! 822: e1 = e1->typ(tbl); ! 823: if (e1->tp->is_ref()) e1 = e1->contents(); ! 824: t1 = e1->tp; ! 825: // if (t1->is_cl_obj()) t1->tsizeof(); ! 826: } ! 827: else ! 828: t1 = 0; ! 829: ! 830: if (e2) { ! 831: e2 = e2->typ(tbl); ! 832: if (e2->tp->is_ref()) e2 = e2->contents(); ! 833: t2 = e2->tp; ! 834: // if (t2->is_cl_obj()) t2->tsizeof(); ! 835: } ! 836: else ! 837: t2 = 0; ! 838: ! 839: // error('d',"b %k t1 %t t2 %t",b,t1,t2); ! 840: switch (b) { // filter out non-overloadable operators ! 841: default: ! 842: { ! 843: Pexpr x = try_to_overload(tbl); ! 844: if (x) { ! 845: if (b==INCR || b==DECR) { ! 846: Pexpr fe = x->e1->base==NAME?x->e1:x->e1->mem; ! 847: if (t2==0 && t1) { // postfix ! 848: if (fe->tp->base==OVERLOAD) ! 849: x = make_postfix(x); ! 850: else x = check_postfix(x); ! 851: } ! 852: } ! 853: return x; ! 854: } ! 855: // if (x) return x; ! 856: // error('d',"e2: %t t2: %t", e2->tp, t2); ! 857: if (t2 && t1==0 && t2!=e2->tp) t2 = e2->tp; ! 858: } ! 859: case DOT: ! 860: case G_CM: ! 861: case G_ADDROF: ! 862: case G_CALL: ! 863: case QUEST: ! 864: break; ! 865: } ! 866: ! 867: switch (b) { ! 868: case QUEST: ! 869: if (Ntmp) error('s',"temporary ofC%n with destructor needed in%kE",Ntmp,b); ! 870: break; ! 871: case ANDAND: ! 872: case OROR: ! 873: extern Pexpr Ntmp_dtor; ! 874: if (Ntmp) { ! 875: Ntmp_dtor = new expr(ELIST,this,Ntmp_dtor); ! 876: // error('d',"(e %d) temp ofC%n with dtor needed in%kE",this,Ntmp,b); ! 877: } ! 878: } ! 879: ! 880: t = (t1==0) ? t2 : (t2==0) ? t1 : 0; ! 881: // error('d', "expr::typ t %t", t ); ! 882: // error('d',"b2 %d %k",b,b); ! 883: switch (b) { /* are the operands of legal types */ ! 884: case REFMUL: ! 885: base = REF; ! 886: // no break; ! 887: case DOT: ! 888: { // a .* p => &a MEMPTR p => appropriate indirection ! 889: // to be considered: what happens if a .* expression ! 890: // is used except in a call/=? ! 891: Pexpr a = e1->typ(tbl); ! 892: Ptype at = a->tp->skiptypedefs(); ! 893: if (base == DOT) { ! 894: a = a->address(); ! 895: at = at->addrof(); // beware of n_xref ! 896: } ! 897: ! 898: Pname cn = Pptr(at)->typ->is_cl_obj(); ! 899: Pclass mm = cn ? Pclass(cn->tp) : 0; ! 900: ! 901: Pexpr p = e2->typ(tbl); ! 902: Ptype pt = p->tp->skiptypedefs(); ! 903: Pname pcn = pt->is_cl_obj(); ! 904: ! 905: //error('d',"mm %t pt %t",mm,pt); ! 906: if (pcn) { ! 907: Pclass cl = Pclass(pcn->tp); ! 908: Pname found = 0; ! 909: for (Pname on=cl->conv; on; on=on->n_list) { ! 910: Pfct f = Pfct(on->tp); ! 911: Pptr frt = Pptr(f->returns->skiptypedefs()); ! 912: if (frt->base!=PTR || Pptr(frt)->memof==0) break; ! 913: if (Pptr(frt)->memof==mm || mm->has_base(Pptr(frt)->memof)) { ! 914: if (found) ! 915: error("two possible conversions forP toM: %n and %n",found,on); ! 916: else ! 917: found = on; ! 918: } ! 919: } ! 920: //error('d',"found %n",found); ! 921: if (found) { ! 922: p = new ref(DOT,p,found); ! 923: p = new call(p,0); ! 924: p = p->typ(tbl); ! 925: pt = p->tp->skiptypedefs(); ! 926: } ! 927: ! 928: } ! 929: if (pt->base!=PTR || Pptr(pt)->memof==0) { ! 930: error("P toMX in .*E: %t",pt); ! 931: tp = any_type; ! 932: base = DUMMY; ! 933: return this; ! 934: } ! 935: Pclass pm = Pptr(pt)->memof; ! 936: ! 937: // while (at->base == TYPE) at = Pbase(at)->b_name->tp; ! 938: // Pname cn = Pptr(at)->typ->is_cl_obj(); ! 939: // Pclass mm = cn ? Pclass(cn->tp) : 0; ! 940: //error('d',"mm %t %t %d %d",mm,pm,pm->baseof(mm),mm->has_base(pm)); ! 941: ! 942: // if (mm!=pm && pm->baseof(mm)==0 && mm->has_base(pm)==0) { ! 943: if (mm != pm) { ! 944: if (mm->has_base(pm) == 0) { ! 945: error("badOT in .*E: %t (%s*X)",a->tp,pm->string); ! 946: tp = any_type; ! 947: //return this; ! 948: } ! 949: a = new texpr(CAST,pm->this_type,a); ! 950: e1 = a = a->typ(tbl); ! 951: } ! 952: ! 953: Ptype tpx = Pptr(pt)->typ->skiptypedefs(); ! 954: ! 955: if (tpx->base == FCT) { // a.*p => (&a MEMPTR p) ! 956: base = MEMPTR; ! 957: tp2 = mm; // keep the class for simpl.c ! 958: e1 = a; ! 959: e2 = p; ! 960: } ! 961: else { // a .* p => *(typeof(p))((char*)&a + (int)p-1) ! 962: a = new cast(Pchar_type,a); ! 963: p = new cast(int_type,p); ! 964: p = new expr(MINUS,p,one); ! 965: p->tp = int_type; ! 966: Pexpr pl = new expr(PLUS,a,p); ! 967: pl->tp = Pchar_type; ! 968: base = DEREF; ! 969: pt = new ptr(PTR,tpx); // need a T* not a T C::* ! 970: Pptr(pt)->b_const = Pptr(tpx)->b_const; ! 971: mpglob = pm; ! 972: // PERM(pt); ! 973: e1 = new cast(pt,pl); ! 974: e2 = 0; ! 975: } ! 976: tp = tpx; ! 977: return tp->is_ref() ? contents() : this; ! 978: } ! 979: ! 980: case G_CALL: ! 981: case CALL: ! 982: tp = call_fct(tbl); /* two calls of use() for e1's names */ ! 983: if (tp->is_ref()) return contents(); ! 984: return this; ! 985: ! 986: case DEREF: ! 987: if (e1 == dummy) error("O missing before []\n"); ! 988: if (e2 == dummy) error("subscriptE missing"); ! 989: ! 990: if (t) { /* *t */ ! 991: t = t->skiptypedefs(); ! 992: // t->vec_type(); ! 993: if (t->base==PTR && Pptr(t)->memof) error("P toM dereferenced"); ! 994: tp = t->deref(); ! 995: } ! 996: else { // e1[e2] that is *(e1+e2) ! 997: //error('d',"deref %t[%t]",t1,t2); ! 998: if (t1->vec_type()) { // e1[e2] ! 999: switch (t2->base) { ! 1000: case CHAR: ! 1001: case SHORT: ! 1002: case INT: ! 1003: case LONG: ! 1004: case EOBJ: ! 1005: break; ! 1006: default: ! 1007: { Pname cn = t2->is_cl_obj(); ! 1008: if (cn) // conversion to integral? ! 1009: e2 = check_cond(e2,DEREF,tbl); ! 1010: else ! 1011: t2->integral(DEREF); ! 1012: } ! 1013: } ! 1014: t1 = t1->skiptypedefs(); ! 1015: if (t1->base==PTR && Pptr(t1)->memof) error("P toM dereferenced"); ! 1016: tp = t1->deref(); ! 1017: (void) tp->tsizeof(); ! 1018: } ! 1019: else if (t2->vec_type()) { // really e2[e1] ! 1020: t1->integral(DEREF); ! 1021: t2 = t2->skiptypedefs(); ! 1022: if (t2->base==PTR && Pptr(t2)->memof) error("P toM dereferenced"); ! 1023: tp = t2->deref(); ! 1024: (void) tp->tsizeof(); ! 1025: } ! 1026: else { ! 1027: error("[] applied to nonPT:%t[%t]",t1,t2); ! 1028: tp = any_type; ! 1029: } ! 1030: } ! 1031: ! 1032: if (tp->is_ref()) return contents(); ! 1033: ! 1034: return this; ! 1035: ! 1036: case G_ADDROF: ! 1037: case ADDROF: ! 1038: //error('d',"addrof(%d) %k %d",base,e2->base,e2->base); ! 1039: switch (e2->base) { // potential lvalues ! 1040: case G_CM: ! 1041: if (base==ADDROF && e2->e2->base==NAME) { ! 1042: // check for cfront generated result variable ! 1043: char* s = e2->e2->string; ! 1044: if (s[0]=='_' && s[1] && s[1]=='_') { ! 1045: if (s[2] && (s[2]=='R' || s[2]=='V')) { ! 1046: error("address of non-lvalue"); ! 1047: break; ! 1048: } ! 1049: } ! 1050: } ! 1051: case CM: // &(a,b) => (a,&b) ! 1052: { ! 1053: Pexpr ee = e2; ! 1054: ee->tp = 0; ! 1055: ee->e2 = new expr(base,0,ee->e2); ! 1056: delete this; ! 1057: return ee->typ(tbl); ! 1058: } ! 1059: case QUEST: // & (a?b:c) => (a?&b:&c) ! 1060: { ! 1061: Pexpr ee = e2; ! 1062: ee->tp = 0; ! 1063: ee->e1 = new expr(base,0,ee->e1); ! 1064: ee->e2 = new expr(base,0,ee->e2); ! 1065: delete this; ! 1066: return ee->typ(tbl); ! 1067: } ! 1068: case INCR: ! 1069: case DECR: ! 1070: if (e2->e1) break; ! 1071: case ASSIGN: ! 1072: case ASPLUS: ! 1073: case ASMINUS: ! 1074: case ASMUL: ! 1075: case ASDIV: ! 1076: case ASMOD: ! 1077: case ASAND: ! 1078: case ASOR: ! 1079: case ASER: ! 1080: case ASLS: ! 1081: case ASRS: ! 1082: return e2->address(); ! 1083: } ! 1084: ! 1085: if (e2->lval(ADDROF) == 0) { ! 1086: if (error_count) { // error_count == 0 possible ! 1087: // in case of & const ! 1088: tp = any_type; ! 1089: return this; ! 1090: } ! 1091: } ! 1092: ! 1093: tp = t->addrof(); ! 1094: ! 1095: if( base==ADDROF && mpglob) ! 1096: Pptr(tp)->memof = mpglob; ! 1097: ! 1098: if (e2->tp->base == VEC) { ! 1099: if(e2->base != NAME) { ! 1100: base = CAST; ! 1101: tp2 = tp; ! 1102: e1 = e2; ! 1103: e2 = 0; ! 1104: return this; ! 1105: } ! 1106: } ! 1107: ! 1108: // tp = t->addrof(); ! 1109: ! 1110: if (t->base==FCT) ! 1111: Pptr(tp)->memof = Pfct(t)->memof; ! 1112: ! 1113: // if (t->tconst() && vec_const==0 && fct_const==0) Pptr(tp)->b_const = 1; ! 1114: // ??? & (const T) is NOT T*const but const T* ! 1115: ! 1116: switch (e2->base) { ! 1117: case NAME: ! 1118: mname: // check for &s::i ! 1119: { Pname n2 = Pname(e2); ! 1120: Pname cn = (n2->n_table && n2->n_table!=gtbl) ? n2->n_table->t_name : 0; ! 1121: // error('d',"n2 %k cn %n t %t",n2->base,cn,t); ! 1122: if (cn == 0) break; ! 1123: // Pptr(tp)->memof = Pclass(cn->tp); ! 1124: ! 1125: if (t->base==FCT && Pfct(t)->f_this==0) { ! 1126: Pptr(tp)->memof = 0; ! 1127: break; ! 1128: } ! 1129: ! 1130: switch (t->base) { ! 1131: case OVERLOAD: ! 1132: return e2; ! 1133: case FCT: ! 1134: // error('d', "cn->tp: %d, %k", cn->tp, cn->tp->base); ! 1135: Pptr(tp)->memof = Pclass(cn->tp); //SSS ! 1136: ! 1137: if (Pfct(t)->f_virtual) { ! 1138: // { 0,vtbl index,0 } ! 1139: e1 = new ival(Pfct(t)->f_virtual); ! 1140: e1 = new expr(ELIST,zero,e1); ! 1141: e2 = zero; ! 1142: base = ILIST; ! 1143: // tp = int_type; ! 1144: return this; ! 1145: } // use the pointer ! 1146: ! 1147: // { 0,-1,(int(*)())ptr } ! 1148: e1 = new ival(-1); ! 1149: e1 = new expr(ELIST,zero,e1); ! 1150: // e2 is the name ! 1151: e2 = new cast(Pfct_type,e2); ! 1152: base = ILIST; ! 1153: // tp = int_type; ! 1154: return this; ! 1155: ! 1156: // return e2; ! 1157: ! 1158: default: ! 1159: if (n2->n_stclass != STATIC) { // offset + 1 ! 1160: //error('d',"n2 %n %d",n2,n2->n_offset); ! 1161: //error('d',"q %n cn %n",n2->n_qualifier,cn); ! 1162: e1 = new ival(n2->n_offset+1); ! 1163: Pptr(tp)->memof = Pclass(cn->tp); ! 1164: //error('d',"cl %d %s i %d",Pclass(cn->tp),Pclass(cn->tp)?Pclass(cn->tp)->string:"0",n2->n_offset); ! 1165: } ! 1166: else ! 1167: return this; ! 1168: } ! 1169: //error('d',"int_type"); ! 1170: e1->tp = int_type; ! 1171: e2 = 0; ! 1172: tp2 = tp; ! 1173: base = CAST; ! 1174: return this; ! 1175: } ! 1176: case DOT: ! 1177: case REF: ! 1178: { ! 1179: Pname m = Pname(e2->mem); ! 1180: // error( 'd', "e2->mem->base: %k", e2->mem->base ); ! 1181: // Pname m = (e2->mem->base == MDOT) ? Pname(e2->mem->mem) : Pname(e2->mem); ! 1182: while ( m->base == MDOT ) m = Pname(Pexpr(m)->mem); ! 1183: ! 1184: Pfct f = Pfct(m->tp); ! 1185: ! 1186: if (f->base == FCT || f->base == OVERLOAD) { // &p->f ! 1187: Pexpr q = Pname(e2)->n_initializer; // &p->x::f ! 1188: ! 1189: if (q && bound==0 && e2->e1==cc->c_this) { ! 1190: // FUDGE: &this->x::f => &x::f ! 1191: DEL(e2); ! 1192: e2 = m; ! 1193: goto mname; ! 1194: } ! 1195: ! 1196: bound = 1; ! 1197: if(!f->f_static) { ! 1198: error(strict_opt?0:'w', ! 1199: "address of boundF (try using ``%s::*'' forPT and ``&%s::%s'' for address) (anachronism)", ! 1200: m->n_table->t_name->string, ! 1201: m->n_table->t_name->string, ! 1202: m->string ! 1203: ); ! 1204: } ! 1205: ! 1206: if (q || f->f_virtual==0) { ! 1207: // & x.f => & f ! 1208: DEL(e2); ! 1209: e2 = m; ! 1210: } ! 1211: } ! 1212: break; ! 1213: ! 1214: } ! 1215: case MEMPTR: ! 1216: // &(p->*q) ! 1217: error("& .* E"); ! 1218: } ! 1219: ! 1220: return this; ! 1221: ! 1222: case UMINUS: ! 1223: t->numeric(UMINUS); ! 1224: tp = t; ! 1225: return this; ! 1226: ! 1227: case UPLUS: ! 1228: t->num_ptr(UPLUS); ! 1229: tp = t; ! 1230: if (ansi_opt==0) { ! 1231: base = PLUS; ! 1232: e1 = zero; ! 1233: } ! 1234: return this; ! 1235: ! 1236: case NOT: ! 1237: e2 = check_cond(e2,NOT,tbl); ! 1238: tp = int_type; ! 1239: return this; ! 1240: ! 1241: case COMPL: ! 1242: t->integral(COMPL); ! 1243: tp = t; ! 1244: return this; ! 1245: ! 1246: case INCR: ! 1247: case DECR: ! 1248: { ! 1249: // error('d',"incr-decr: e1: %k e2: %k", e1?e1->base:0, e2?e2->base:0); ! 1250: Pexpr e = e1?e1:e2; // e1!=0 ==> e++ or e-- ! 1251: // e1==0 ==> ++e or --e ! 1252: ! 1253: e->lval(b); ! 1254: ! 1255: switch(e->base) { ! 1256: case QUEST: ! 1257: e->tp=0; ! 1258: e->e1 = e1 ? new expr(base,e->e1,0) : new expr(base,0,e->e1); ! 1259: e->e2 = e1 ? new expr(base,e->e2,0) : new expr(base,0,e->e2); ! 1260: delete this; ! 1261: return e->typ(tbl); ! 1262: case CM: ! 1263: case G_CM: ! 1264: e->tp=0; ! 1265: e->e2 = e1 ? new expr(base,e->e2,0) : new expr(base,0,e->e2); ! 1266: delete this; ! 1267: return e->typ(tbl); ! 1268: case INCR: ! 1269: case DECR: ! 1270: if(e->e1) ! 1271: break; ! 1272: nin++; ! 1273: if(e->e2->not_simple()) ! 1274: error('s',"overly complex %k of %k",b,e->base); ! 1275: nin--; ! 1276: e = new expr(G_CM,e,e->e2->typ(tbl)); ! 1277: if (e1) e1=e; else e2=e; ! 1278: // e1?e1:e2 = e; ! 1279: return typ(tbl); ! 1280: case ASSIGN: ! 1281: case ASPLUS: ! 1282: case ASMINUS: ! 1283: case ASMUL: ! 1284: case ASDIV: ! 1285: case ASMOD: ! 1286: case ASAND: ! 1287: case ASOR: ! 1288: case ASER: ! 1289: case ASLS: ! 1290: case ASRS: ! 1291: nin++; ! 1292: if(e->e1->not_simple()) ! 1293: error('s',"overly complex %k of %k",b,e->base); ! 1294: nin--; ! 1295: e = new expr(G_CM,e,e->e1->typ(tbl)); ! 1296: if (e1) e1=e; else e2=e; ! 1297: // e1?e1:e2 = e; ! 1298: return typ(tbl); ! 1299: } ! 1300: } ! 1301: ! 1302: r1 = t->num_ptr(b); ! 1303: if (r1='P' && t->check(Pvoid_type,0)==0) error("%k of void*",b); ! 1304: tp = t; ! 1305: return this; ! 1306: ! 1307: } ! 1308: ! 1309: if (e1==dummy || e2==dummy || e1==0 || e2==0) error("operand missing for%k",b); ! 1310: switch (b) { ! 1311: case MUL: ! 1312: case DIV: ! 1313: r1 = t1->numeric(b); ! 1314: r2 = t2->numeric(b); ! 1315: nppromote(b); ! 1316: break; ! 1317: ! 1318: case PLUS: ! 1319: r2 = t2->num_ptr(PLUS); ! 1320: r1 = t1->num_ptr(PLUS); ! 1321: nppromote(PLUS); ! 1322: goto void_check; ! 1323: ! 1324: case MINUS: ! 1325: r2 = t2->num_ptr(MINUS); ! 1326: r1 = t1->num_ptr(MINUS); ! 1327: if (r2=='P' && r1!='P' && r1!='A') error("nonP - P"); ! 1328: nppromote(MINUS); ! 1329: void_check: ! 1330: if ((r1='P' && t1->check(Pvoid_type,0)==0) ! 1331: || (r2='P' && t2->check(Pvoid_type,0)==0)) ! 1332: error("%k of void*",b); ! 1333: tp = t; ! 1334: break; ! 1335: ! 1336: case LS: ! 1337: case RS: ! 1338: case AND: ! 1339: case OR: ! 1340: case ER: ! 1341: switch (e1->base) { ! 1342: case LT: ! 1343: case LE: ! 1344: case GT: ! 1345: case GE: ! 1346: case EQ: ! 1347: case NE: ! 1348: error('w',"%kE as operand for%k",e1->base,b); ! 1349: } ! 1350: switch (e2->base) { ! 1351: case LT: ! 1352: case LE: ! 1353: case GT: ! 1354: case GE: ! 1355: case EQ: ! 1356: case NE: ! 1357: error('w',"%kE as operand for%k",e2->base,b); ! 1358: } ! 1359: case MOD: ! 1360: r1 = t1->integral(b); ! 1361: r2 = t2->integral(b); ! 1362: nppromote(b); ! 1363: break; ! 1364: ! 1365: case LT: ! 1366: case LE: ! 1367: case GT: ! 1368: case GE: ! 1369: case EQ: ! 1370: case NE: ! 1371: r1 = t1->num_ptr(b); ! 1372: r2 = t2->num_ptr(b); ! 1373: if (r1=='P' && r2=='I') { // allow things like: ! 1374: // if (p==2-2) ! 1375: // YUCK! ! 1376: Neval = 0; ! 1377: long i = e2->eval(); ! 1378: if (Neval==0 && i==0) { ! 1379: DEL(e2); ! 1380: e2 = zero; ! 1381: r2 = 'Z'; ! 1382: } ! 1383: } ! 1384: else if (r2=='P' && r1=='I') { ! 1385: Neval = 0; ! 1386: long i = e1->eval(); ! 1387: if (Neval==0 && i==0) { ! 1388: DEL(e1); ! 1389: e1 = zero; ! 1390: r1 = 'Z'; ! 1391: } ! 1392: } ! 1393: ! 1394: if (b!=EQ && b!=NE) { ! 1395: if (r1=='P' && r2=='Z') error("P%k 0",b); ! 1396: if (r2=='P' && r1=='Z') error("P%k 0",b); ! 1397: } ! 1398: ! 1399: // make sure functions are properly converted to pointers to ! 1400: // functions and make sure overloaded functions are rejected ! 1401: Pexpr ptof(Pfct ef, Pexpr e, Ptable tbl); ! 1402: if (r1 == FCT) e1 = ptof(0,e1,tbl); ! 1403: if (r2 == FCT) e2 = ptof(0,e2,tbl); ! 1404: ! 1405: npcheck(b); ! 1406: ! 1407: if (r1=='P') { // need cast for pointers to virtual and second bases ! 1408: Pptr p1 = t1->is_ptr(); ! 1409: Pptr p2 = t2->is_ptr(); ! 1410: Pname cn = p1?p1->typ->is_cl_obj():0; ! 1411: Pname cn2 = p2?p2->typ->is_cl_obj():0; ! 1412: ! 1413: if (cn && cn2) { ! 1414: Pclass cl = Pclass(cn->tp); ! 1415: Pclass cl2 = Pclass(cn2->tp); ! 1416: ! 1417: if (cl->has_base(cl2)) { ! 1418: e1 = cast_cptr(cl2,e1,tbl,0); ! 1419: e1 = new cast(p2,e1); ! 1420: } ! 1421: else if (cl2->has_base(cl)) { ! 1422: e2 = cast_cptr(cl,e2,tbl,0); ! 1423: e2 = new cast(p1,e2); ! 1424: } ! 1425: } ! 1426: } ! 1427: ! 1428: if (r1=='P' && t1->memptr()) { ! 1429: mpmp: ! 1430: if (r2=='Z') { ! 1431: e2 = zero; ! 1432: e1 = new mdot("i",e1); ! 1433: e1->i1 = 9; ! 1434: } ! 1435: else if (r2=='P' && t2->memptr()) { ! 1436: // ERROR: no check for sideeffects ! 1437: Pexpr i1 = new mdot("i",e1); ! 1438: Pexpr i2; ! 1439: i1->i1 = 9; ! 1440: ! 1441: i2 = e2; ! 1442: while ( i2->base == CAST ) ! 1443: i2 = i2->e1; ! 1444: if ( i2->base == ILIST ) ! 1445: e2 = i2; ! 1446: ! 1447: if (e2->base==ILIST) ! 1448: i2 = e2->e1->e2; ! 1449: else { ! 1450: i2 = new mdot("i",e2); ! 1451: i2->i1 = 9; ! 1452: } ! 1453: ! 1454: Pexpr f1 = new mdot("f",e1); ! 1455: Pexpr f2; ! 1456: f1->i1 = 9; ! 1457: if (e2->base == ILIST) ! 1458: // f2 = new cast(Pfct_type,e2->e2); ! 1459: f2 = e2->e2; ! 1460: else { ! 1461: f2 = new mdot("f",e2); ! 1462: f2->i1 = 9; ! 1463: } ! 1464: ! 1465: Pexpr ei = new expr(base,i1,i2); ! 1466: Pexpr fi = new expr(base,f1,f2); ! 1467: ! 1468: base = b==NE ? OROR : ANDAND; ! 1469: e1 = ei; ! 1470: e2 = fi; ! 1471: } else if (r2=='P') { ! 1472: error('s',"%t %k %t",t1,base,t2); ! 1473: } ! 1474: } ! 1475: else if (r2=='P' && t2->memptr()) { ! 1476: Pexpr ee = e1; // swap ! 1477: e1 = e2; ! 1478: e2 = ee; ! 1479: int rr = r1; ! 1480: r1 = r2; ! 1481: r2 = rr; ! 1482: Ptype tt = t1; ! 1483: t1 = t2; ! 1484: t2 = tt; ! 1485: goto mpmp; ! 1486: } ! 1487: t = int_type; ! 1488: break; ! 1489: ! 1490: case ANDAND: ! 1491: case OROR: ! 1492: e1 = check_cond(e1,b,tbl); ! 1493: e2 = check_cond(e2,b,tbl); ! 1494: t = int_type; ! 1495: break; ! 1496: ! 1497: case QUEST: ! 1498: { ! 1499: Pname c1, c2; ! 1500: cond = check_cond(cond,b,tbl); ! 1501: //error('d',"cond %k %t",cond->base,cond->tp); ! 1502: //error('d',"t1 %t t2 %t",t1,t2); ! 1503: ! 1504: // still doesn't do complete checking for possible conversions... ! 1505: ! 1506: bit MPTR = 0; // local hack ! 1507: ! 1508: extern int suppress_error; // global hack ! 1509: suppress_error++; ! 1510: r1 = t1->num_ptr(b); ! 1511: r2 = t2->num_ptr(b); ! 1512: suppress_error--; ! 1513: if (r1=='P' && r2=='P' && t1->memptr() && t2->memptr()) { ! 1514: ! 1515: ++MPTR; // prevent later sorry ! 1516: ! 1517: // watch for casts ! 1518: Pexpr tt = e1; ! 1519: while ( tt->base == CAST ) tt = tt->e1; ! 1520: if ( tt->base == ILIST ) e1 = tt; ! 1521: ! 1522: tt = e2; ! 1523: while ( tt->base == CAST ) tt = tt->e1; ! 1524: if ( tt->base == ILIST ) e2 = tt; ! 1525: ! 1526: // cannot have sides return (expr?{}:{}) ! 1527: // reuse same temp for both sides ?: ! 1528: Pname temp = make_tmp( 'A', mptr_type, tbl ); ! 1529: ! 1530: e1 = mptr_assign( temp, e1 ); ! 1531: e1 = new expr( G_CM, e1, temp ); ! 1532: e1->tp = temp->tp; ! 1533: ! 1534: e2 = mptr_assign( temp, e2 ); ! 1535: e2 = new expr( G_CM, e2, temp ); ! 1536: e2->tp = temp->tp; ! 1537: } ! 1538: ! 1539: if (t1==t2 ! 1540: || ( (c1=t1->is_cl_obj()) ! 1541: && (c2=t2->is_cl_obj()) ! 1542: && (c1->tp==c2->tp) ! 1543: )) ! 1544: t = t1; ! 1545: else { ! 1546: r1 = t1->num_ptr(b); ! 1547: r2 = t2->num_ptr(b); ! 1548: ! 1549: if (r1=='P' && r2=='P') { ! 1550: Pptr p1 = t1->is_ptr(); ! 1551: Pptr p2 = t2->is_ptr(); ! 1552: //error('d',"p1 %t p2 %t",p1,p2); ! 1553: if ((c1 = p1->typ->is_cl_obj()) ! 1554: && (c2 = p2->typ->is_cl_obj())) { ! 1555: Pclass cl1 = Pclass(c1->tp); ! 1556: Pclass cl2 = Pclass(c2->tp); ! 1557: if (cl1==cl2 || cl2->has_base(cl1)) { ! 1558: t = t1; ! 1559: goto caca; ! 1560: } ! 1561: else if (cl1->has_base(cl2)) { ! 1562: t = t2; ! 1563: goto caca; ! 1564: } ! 1565: } ! 1566: } ! 1567: ! 1568: if (r1==FCT && r2==FCT) { // fudge ! 1569: if (t1->check(t2,ASSIGN)) ! 1570: error("badTs in ?:E: %t and %t",t1,t2); ! 1571: else if (Pfct(t1)->memof) error('s',"conditionalE with%t",t1); ! 1572: t = t1; ! 1573: } ! 1574: else ! 1575: nppromote(b); ! 1576: caca: ! 1577: //error('d',"?: t %t t1 %t t2 %t",t,t1,t2); ! 1578: if (t!=t1 && t->check(t1,0)) { ! 1579: PERM(t); ! 1580: e1 = new cast(t,e1); ! 1581: } ! 1582: ! 1583: if (t!=t2 && t->check(t2,0)) { ! 1584: PERM(t); ! 1585: e2 = new cast(t,e2); ! 1586: } ! 1587: ! 1588: Pptr pt = t->is_ptr(); ! 1589: //if (pt && pt->base==PTR && pt->memof) error('s',"conditionalE with%t",t); ! 1590: if (pt && pt->base==PTR && pt->memof && MPTR == 0) error('s',"conditionalE with%t",t); ! 1591: } ! 1592: } ! 1593: break; ! 1594: ! 1595: case ASPLUS: ! 1596: r1 = t1->num_ptr(ASPLUS); ! 1597: r2 = t2->num_ptr(ASPLUS); ! 1598: nppromote(ASPLUS); ! 1599: goto ass; ! 1600: ! 1601: case ASMINUS: ! 1602: r1 = t1->num_ptr(ASMINUS); ! 1603: r2 = t2->num_ptr(ASMINUS); ! 1604: if (r2=='P' && r1!='P' && r1!='A') error("P -= nonP"); ! 1605: nppromote(ASMINUS); ! 1606: goto ass; ! 1607: ! 1608: case ASMUL: ! 1609: case ASDIV: ! 1610: r1 = t1->numeric(b); ! 1611: r2 = t1->numeric(b); ! 1612: nppromote(b); ! 1613: goto ass; ! 1614: ! 1615: case ASMOD: ! 1616: r1 = t1->integral(ASMOD); ! 1617: r2 = t2->integral(ASMOD); ! 1618: nppromote(ASMOD); ! 1619: goto ass; ! 1620: ! 1621: case ASAND: ! 1622: case ASOR: ! 1623: case ASER: ! 1624: case ASLS: ! 1625: case ASRS: ! 1626: r1 = t1->integral(b); ! 1627: r2 = t2->integral(b); ! 1628: npcheck(b); ! 1629: t = int_type; ! 1630: goto ass; ! 1631: ass: ! 1632: if (r1='P' && t1->check(Pvoid_type,0)==0) error("%k of void*",b); ! 1633: tp = t; ! 1634: as_type = t; /* the type of the rhs */ ! 1635: t2 = t; ! 1636: ! 1637: case ASSIGN: ! 1638: //error('d',"assign %k: %t %t %s",b,t1,t2,ignore_const?"ignore const":""); ! 1639: //error('d'," e1 %d %k e1 %d %k",e1,e1->base,e2,e2->base); ! 1640: if (ignore_const) { // handle static initializers ! 1641: // represented as assignments ! 1642: // ignore consts. ! 1643: tp = e1->tp; ! 1644: return this; ! 1645: } ! 1646: ! 1647: switch (e1->base) { ! 1648: case G_CM: ! 1649: case CM: // (a,b)=c => *(a,&b)=c ! 1650: { ! 1651: e1->e2 = new expr(G_ADDROF,0,e1->e2); ! 1652: e1->tp = 0; ! 1653: e1 = new expr(DEREF,e1,0); ! 1654: return typ(tbl); ! 1655: } ! 1656: case QUEST: // (a?b:c)=d => *(a?&b:&c)=c ! 1657: { ! 1658: e1->e1 = new expr(G_ADDROF,0,e1->e1); ! 1659: e1->e2 = new expr(G_ADDROF,0,e1->e2); ! 1660: e1->tp = 0; ! 1661: e1 = new expr(DEREF,e1,0); ! 1662: return typ(tbl); ! 1663: } ! 1664: case ASSIGN: // (a*=b)=c => a*=b,a=c ! 1665: case ASPLUS: ! 1666: case ASMINUS: ! 1667: case ASMUL: ! 1668: case ASDIV: ! 1669: case ASMOD: ! 1670: case ASAND: ! 1671: case ASOR: ! 1672: case ASER: ! 1673: case ASLS: ! 1674: case ASRS: ! 1675: { ! 1676: base = G_CM; ! 1677: nin++; ! 1678: if (e1->e1->not_simple()) error('s',"lvalue %k too complicated",b); ! 1679: nin--; ! 1680: Pexpr aa = new expr(e1->base,e1->e1,e1->e2); ! 1681: Pexpr bb = new expr(b,e1->e1,e2); ! 1682: e1 = aa; ! 1683: e2 = bb; ! 1684: return typ(tbl); ! 1685: } ! 1686: case INCR: ! 1687: case DECR: // ++a=b => ++a,a=b ! 1688: { ! 1689: if(!e1->e2) break ; ! 1690: base = G_CM; ! 1691: nin++; ! 1692: if (e1->e2->not_simple()) error('s',"lvalue %k too complicated",b); ! 1693: nin--; ! 1694: Pexpr aa = new expr(e1->base,0,e1->e2); ! 1695: Pexpr bb = new expr(b,e1->e2,e2); ! 1696: e1 = aa; ! 1697: e2 = bb; ! 1698: return typ(tbl); ! 1699: } ! 1700: case REF: ! 1701: { ! 1702: Pexpr r = e1; ! 1703: // hack to prevent ! 1704: // f().i = j ! 1705: // transformed into ! 1706: // ((t=f()),&t)->i = j ! 1707: if (r->e1->base==G_CM ! 1708: && r->e1->e2->base==G_ADDROF ! 1709: && r->e1->e2->e2->base==NAME) { ! 1710: char* s = r->e1->e2->e2->string; ! 1711: if (s[0]=='_' && s[1]=='_') ! 1712: error("left hand side not lvalue"); ! 1713: } ! 1714: } ! 1715: } ! 1716: ! 1717: if (e1->lval(b) == 0) { ! 1718: tp = any_type; ! 1719: return this; ! 1720: } ! 1721: ! 1722: t1 = t1->skiptypedefs(); ! 1723: switch (t1->base) { ! 1724: case INT: ! 1725: case CHAR: ! 1726: case SHORT: ! 1727: // if (e2->base==ICON && e2->tp==long_type) ! 1728: // error('w',"long constant assigned to%k",t1->base); ! 1729: { Ptype t = e2->tp->skiptypedefs(); ! 1730: switch (t->base) { ! 1731: case LONG: ! 1732: case FLOAT: ! 1733: case DOUBLE: ! 1734: case LDOUBLE: ! 1735: error('w',"%t assigned to %t",e2->tp,t1); ! 1736: } ! 1737: } ! 1738: // no break ! 1739: case LONG: ! 1740: if (b==ASSIGN ! 1741: && Pbase(t1)->b_unsigned ! 1742: && e2->base==UMINUS ! 1743: && e2->e2->base==ICON) ! 1744: error('w',"negative assigned to unsigned"); ! 1745: break; ! 1746: case PTR: ! 1747: if (b == ASSIGN) { ! 1748: //error('d',"ptr t1 %t %d %t",t1,t1->memptr(),t2); ! 1749: //?? if (t1->memptr() && t2->base!=OVERLOAD) break; ! 1750: e2 = ptr_init(Pptr(t1),e2,tbl); ! 1751: t2 = e2->tp; ! 1752: //error('d',"pchecked %d",Pchecked); ! 1753: if (Pchecked) { ! 1754: tp = e1->tp; ! 1755: return this; ! 1756: } ! 1757: } ! 1758: break; ! 1759: case COBJ: ! 1760: { Pname c1 = t1->is_cl_obj(); ! 1761: // test of c1->tp necessary for ``fake classes'' ! 1762: // _Sdd generated for vector assignemnts ! 1763: if (c1 ! 1764: && c1->tp ! 1765: /* && Pclass(c1->tp)->memtbl->look("__as",0)==0*/) { ! 1766: //&& Pclass(c1->tp)->has_oper(ASSIGN)==0) { ! 1767: Pname c2 = t2->is_cl_obj(); ! 1768: // error('d', "expr::typ: c1: %n c2: %n", c1, c2 ); ! 1769: if (c1 != c2) { ! 1770: /* ! 1771: consider: ! 1772: ! 1773: struct A { A(B&); }; ! 1774: struct B : A {}; ! 1775: ! 1776: A aa; ! 1777: B bb; ! 1778: ! 1779: aa = bb; // aa.operator=(A(bb)); ! 1780: // optimize to aa.A(bb) when possible ! 1781: // avoid temporary where aa = *(A*)&bb is legal ! 1782: */ ! 1783: // error('d',"expr::typ c1 %n %d c2 %n %d",c1,c1?c1->tp:0,c2,c2?c2->tp:0); ! 1784: if (c2 ! 1785: && c2->tp ! 1786: && can_coerce(t1,t2)==0 ! 1787: //&& Pclass(c2->tp)->has_base(Pclass(c1->tp)) ! 1788: //&& (1<is_unique_base(Pclass(c2->tp),c1->string,0)) ! 1789: && (vcllist->clear(),vcllist=0,1<is_unique_base(Pclass(c2->tp),c1->string,0)) ! 1790: && Pclass(c1->tp)->c_xref&(C_VBASE|C_VPTR|C_ASS)) { ! 1791: // error('d',"aaa"); ! 1792: if (make_assignment(c1)) return try_to_overload(tbl); ! 1793: } ! 1794: // optimize ! 1795: else { ! 1796: e2 = new expr(ELIST,e2,0); ! 1797: e2 = new texpr(VALUE,t1,e2); ! 1798: if (Pclass(c1->tp)->has_dtor()==0 && ! 1799: Pclass(c1->tp)->has_oper(ASSIGN)==0) { ! 1800: // optimize ! 1801: // error('d',"bbb"); ! 1802: e2->e2 = e1; ! 1803: e2 = e2->typ(tbl); ! 1804: if (e2->base==DEREF && e2->e1->base==G_CALL || ! 1805: e2->base==ASSIGN && e2->e1==e1) { ! 1806: // error('d',"ccc"); ! 1807: *this = *e2; ! 1808: } ! 1809: tp = t1; ! 1810: return this; ! 1811: } ! 1812: return typ(tbl); ! 1813: } ! 1814: } ! 1815: // test of c1->tp necessary for ``fake classes'' ! 1816: // _Sdd generated for vector assignemnts ! 1817: else if (c1->tp && Pclass(c1->tp)->c_xref&(C_VBASE|C_VPTR|C_ASS)) { ! 1818: if (make_assignment(c1)) return try_to_overload(tbl); ! 1819: } ! 1820: } ! 1821: (void) t1->tsizeof(); ! 1822: break; ! 1823: } ! 1824: } ! 1825: ! 1826: //error('d',"check(%t,%t) -> %d",e1->tp,t2,try_to_coerce(t1,e2,"assignment",tbl)); ! 1827: { Pexpr x = try_to_coerce(t1,e2,"assignment",tbl); ! 1828: if (x) ! 1829: e2 = x; ! 1830: else if (e1->tp->check(t2,ASSIGN)) ! 1831: error("bad assignmentT:%t =%t",e1->tp,t2); ! 1832: else if ((t1 = t1->is_ptr()) && t1->memptr()) { ! 1833: if (t2 == zero_type) { ! 1834: Pexpr ee = new expr(ELIST,zero,zero); ! 1835: e2 = new expr(ILIST,ee,zero); ! 1836: } ! 1837: else if (t2->base==PTR && t2->memptr()) { ! 1838: // do nothing: structure assignment ! 1839: } ! 1840: else { ! 1841: Pexpr x = ptr_init(Pptr(t1),e2,tbl); ! 1842: if (x != e2) e2 = x; ! 1843: } ! 1844: } ! 1845: } ! 1846: t = e1->tp; // the type of the lhs ! 1847: break; ! 1848: case CM: ! 1849: case G_CM: ! 1850: t = t2; ! 1851: break; ! 1852: default: ! 1853: error('i',"unknown operator%k",b); ! 1854: } ! 1855: ! 1856: tp = t; ! 1857: return this; ! 1858: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.