![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to expr3.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront / cfront2.00|
Return to expr3.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / cfront2.00 |
1.1 ! root 1: /*ident "@(#)ctrans:src/expr3.c 1.3.5.29" */ ! 2: /*************************************************************************** ! 3: ! 4: C++ source for cfront, the C++ compiler front-end ! 5: written in the computer science research center of Bell Labs ! 6: ! 7: Copyright (c) 1984 AT&T, Inc. All rigths Reserved ! 8: THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC. ! 9: ! 10: expr3.c: ! 11: ! 12: type check function calls, casts, and explicit coercions ! 13: ! 14: ************************************************************************/ ! 15: ! 16: #include "cfront.h" ! 17: #include "size.h" ! 18: ! 19: int pr_dominate(Ptype t1, Ptype t2) ! 20: /* ! 21: */ ! 22: { ! 23: Pname cn1 = t1->is_cl_obj(); ! 24: Pname cn2 = t2->is_cl_obj(); ! 25: //error('d',"pr_dominate(%t,%t)",t1,t2); ! 26: ! 27: if (cn1==0 || cn2==0) { ! 28: Ptype p1 = t1->is_ptr(); ! 29: Ptype p2 = t2->is_ptr(); ! 30: if (p1 && p2) { // pointers ! 31: cn1 = Pptr(p1)->typ->is_cl_obj(); ! 32: cn2 = Pptr(p2)->typ->is_cl_obj(); ! 33: if (cn1==0 || cn2==0) return 0; ! 34: } ! 35: else { ! 36: p1 = t1->is_ref(); ! 37: p2 = t2->is_ref(); ! 38: if (p1 && p2) { // references ! 39: cn1 = Pptr(p1)->typ->is_cl_obj(); ! 40: cn2 = Pptr(p2)->typ->is_cl_obj(); ! 41: if (cn1==0 || cn2==0) return 0; ! 42: } ! 43: // else if (p1 && cn2) { ! 44: // cn1 = Pptr(p1)->typ->is_cl_obj(); ! 45: // } ! 46: else ! 47: return 0; // not the same and not classes ! 48: } ! 49: } ! 50: Pclass c1 = Pclass(cn1->tp); ! 51: Pclass c2 = Pclass(cn2->tp); ! 52: //error('d'," c1 : c2 %d; c2 : c1 %d",c1->has_base(c2),c2->has_base(c1)); ! 53: if (c1->has_base(c2)) return 1; ! 54: if (c2->has_base(c1)) return 2; ! 55: } ! 56: ! 57: static exact1(Pname,Ptype); ! 58: static exact2(Pname,Ptype); ! 59: static exact3(Pname,Ptype); ! 60: ! 61: static Pname user_dominate(Pname n1, Pname n2) ! 62: { ! 63: Pfct f1 = Pfct(n1->tp); ! 64: Pfct f2 = Pfct(n2->tp); ! 65: ! 66: Pname a1 = f1->argtype; ! 67: Pname a2 = f2->argtype; ! 68: //error('d',"user_dominate: %n %t %t",n1,f1,f2); ! 69: ! 70: int k1 = f1->nargs_known!=ELLIPSIS; ! 71: int k2 = f2->nargs_known!=ELLIPSIS; ! 72: ! 73: if (k1 && k2==0) return n1; ! 74: if (k2 && k1==0) return n2; ! 75: ! 76: for(; a1 && a2; a1 = a1->n_list, a2 = a2->n_list) { ! 77: Ptype t1 = a1->tp; ! 78: Ptype t2 = a2->tp; ! 79: } ! 80: ! 81: if (a1) return n1; ! 82: if (a2) return n2; ! 83: ! 84: return 0; ! 85: } ! 86: ! 87: Pname dominate(Pname n1, Pname n2, Pexpr arg, int const_obj, int level) ! 88: /* ! 89: the two functions n1 and n2 can each respond to a call using ! 90: standard conversions. Does the one dominate the other in the ! 91: sense that all its arguments are identical to the other or ! 92: classes defived from the class of the corresponding argument ! 93: of the other. ! 94: ! 95: If so return it, otherwise return 0; ! 96: */ ! 97: { ! 98: Pname res = 0; ! 99: ! 100: Pfct f1 = Pfct(n1->tp); ! 101: Pfct f2 = Pfct(n2->tp); ! 102: ! 103: Pname a1 = f1->argtype; ! 104: Pname a2 = f2->argtype; ! 105: Pexpr e = arg; ! 106: //error('d',"dominate: %n %t %t e %d",n1,f1,f2,e); ! 107: ! 108: if (e == 0) { ! 109: if (const_obj) { ! 110: if (f1->f_const && f2->f_const==0) return n1; ! 111: if (f2->f_const && f1->f_const==0) return n2; ! 112: } ! 113: else { ! 114: if (f1->f_const==0 && f2->f_const) return n1; ! 115: if (f2->f_const==0 && f1->f_const) return n2; ! 116: } ! 117: return 0; ! 118: } ! 119: ! 120: for(; a1 && a2 && e; a1 = a1->n_list, a2 = a2->n_list, e = e->e2) { ! 121: Ptype t1 = a1->tp; ! 122: Ptype t2 = a2->tp; ! 123: Ptype at = e->e1->tp; ! 124: //error('d',"t1 %t t2 %t at %t",t1,t2,at); ! 125: if (t1==t2 || t1->check(t2,0)==0) continue; ! 126: Pptr r1 = t1->is_ref(); ! 127: Pptr r2 = t2->is_ref(); ! 128: //error('d',"const_problem %t %t %t %d",t1,t2,at,const_problem); ! 129: if (const_problem) { // t1 and t1 differs only in const ! 130: Pname rr; ! 131: if (at->check(t1,0)==0 && const_problem==0) { ! 132: if (t1->is_ptr()) ! 133: rr = n1; ! 134: else ! 135: goto nc; ! 136: } ! 137: else if (at->check(t2,0)==0 && const_problem==0) { ! 138: if (t2->is_ptr()) ! 139: rr = n2; ! 140: else ! 141: goto nc; ! 142: } ! 143: else if (r1 && r1->typ->check(at,0)==0 && const_problem==0) ! 144: rr = n1; ! 145: else if (r2 && r2->typ->check(at,0)==0 && const_problem==0) ! 146: rr = n2; ! 147: else ! 148: return 0; ! 149: ! 150: if (res && res!=rr) return 0; // mutual dominace ! 151: res = rr; ! 152: continue; // identical ! 153: } ! 154: nc: ! 155: if (r2 && (t1==r2 || t1->check(r2->typ,0)==0)) continue; ! 156: if (r1 && (t2==r1 || t2->check(r1->typ,0)==0)) continue; ! 157: int r = pr_dominate(t1,t2); ! 158: //error('d',"pr1 %d",r); ! 159: if (r) { ! 160: Pname rr = r==1?n1:n2; ! 161: if (res && res!=rr) return 0; // mutual dominace ! 162: res = rr; ! 163: continue; ! 164: } ! 165: ! 166: r = pr_dominate(t1,at); ! 167: //error('d',"pr2 %d",r); ! 168: if (r==2) { ! 169: if (res && res!=n1) return 0; // mutual dominace ! 170: res = n1; ! 171: r = pr_dominate(t2,at); ! 172: if (r==2) return 0; // mutual dominace ! 173: continue; ! 174: } ! 175: ! 176: r = pr_dominate(t2,at); ! 177: //error('d',"pr3 %d",r); ! 178: if (r==2) { ! 179: if (res && res!=n2) return 0; // mutual dominace ! 180: res = n2; ! 181: continue; ! 182: } ! 183: ! 184: Pname rr = 0; ! 185: if (t1==at || exact1(a1,at)) ! 186: rr = n1; ! 187: else if (t2==at || exact1(a2,at)) ! 188: rr = n2; ! 189: else if (1<level) { // try integral promotion ! 190: if (exact2(a1,at)) ! 191: rr = n1; ! 192: if (exact2(a2,at)) { ! 193: if (rr) return 0; ! 194: rr = n2; ! 195: } ! 196: } ! 197: else if (1<level) { // try standard conversions ! 198: if (exact3(a1,at)) ! 199: rr = n1; ! 200: if (exact3(a2,at)) { ! 201: if (rr) return 0; ! 202: rr = n2; ! 203: } ! 204: } ! 205: if (rr) { ! 206: if (res && res!=rr) return 0; // mutual dominance ! 207: res = rr; ! 208: continue; ! 209: } ! 210: } ! 211: //if (a1==0 && a2 && a2->n_initializer==0) return 0; // wrong number of arguments ! 212: //if (a2==0 && a1 && a1->n_initializer==0) return 0; // wrong number of arguments ! 213: ! 214: if (e) { ! 215: //error('d',"more args %t a1 %t a2 %t",e->e1->tp,a1?a1->tp:0,a2?a2->tp:0); ! 216: int k1 = f1->nargs_known!=ELLIPSIS; ! 217: int k2 = f2->nargs_known!=ELLIPSIS; ! 218: if (a1 && a1->tp->check(e->e1->tp,ASSIGN)==0) return n1; ! 219: if (a2 && a2->tp->check(e->e1->tp,ASSIGN)==0) return n2; ! 220: if (k1 && k2) return 0; ! 221: } ! 222: ! 223: if (a1==0 && a2 && a2->n_initializer==0) return 0; ! 224: if (a2==0 && a1 && a1->n_initializer==0) return 0; ! 225: if (res==0) ! 226: if (const_obj) { ! 227: if (f1->f_const && f2->f_const==0) return n1; ! 228: if (f2->f_const && f1->f_const==0) return n2; ! 229: } ! 230: else { ! 231: if (f1->f_const==0 && f2->f_const) return n1; ! 232: if (f2->f_const==0 && f1->f_const) return n2; ! 233: } ! 234: //error('d'," -> %n %t",res,res?res->tp:0); ! 235: return res; ! 236: } ! 237: ! 238: Pname Ntmp; ! 239: ! 240: static refd; // initialization routine called by ref_init, do not apply itor ! 241: extern loc no_where; ! 242: ! 243: Pname make_tmp(char c, Ptype t, Ptable tbl) ! 244: { ! 245: Pname tn = tbl->t_name; ! 246: ! 247: if (tn && tn->tp) error('s',"defaultA too complicated"); ! 248: ! 249: if (Ntmp == 0) { ! 250: Pname cn = t->is_cl_obj(); ! 251: if (cn && Pclass(cn->tp)->has_dtor()) Ntmp = cn; ! 252: } ! 253: ! 254: //error('d',"tbl %d cstmt %d %d sti %d",tbl,Cstmt,Cstmt?Cstmt->memtbl:0,sti_tbl); ! 255: if (Cstmt) { // make Cstmt into a block ! 256: if (Cstmt->memtbl == 0) Cstmt->memtbl = new table(4,tbl,0); ! 257: tbl = Cstmt->memtbl; ! 258: } ! 259: else if (tbl == gtbl) { ! 260: if (sti_tbl == 0) sti_tbl = new table(8,gtbl,0); ! 261: tbl = sti_tbl; ! 262: } ! 263: ! 264: Pname tmpx = new name(make_name(c)); ! 265: tmpx->where = no_where; ! 266: tmpx->tp = t; ! 267: (void) t->tsizeof(); ! 268: if ( t->base == COBJ ) { ! 269: Pclass cl = Pclass(Pbase(t)->b_name->tp); ! 270: // error( 'd', "cl: %s %d", cl->string, cl->lex_level ); ! 271: if ( cl->lex_level ) tmpx->lex_level = cl->lex_level; ! 272: } ! 273: Pname tmp = tmpx->dcl(tbl,ARG); // ARG => no init ! 274: //error('d',"make_tmp %n %t",tmp,t); ! 275: delete tmpx; ! 276: tmp->n_scope = FCT; ! 277: return tmp; ! 278: } ! 279: ! 280: Pexpr init_tmp(Pname tmp, Pexpr init, Ptable tbl) ! 281: { ! 282: Pname cn = tmp->tp->is_cl_obj(); ! 283: Pname ct = cn ? Pclass(cn->tp)->has_itor() : 0; ! 284: ! 285: tmp->n_assigned_to = 1; ! 286: //error('d',"init_tmp %n ct %n refd %d",tmp,ct,refd); ! 287: if (ct) { // must initialize ! 288: if (refd) { ! 289: //error('d',"'orrible %k",init->e1->base); ! 290: switch (init->e1->base) { // 'orrible 'ack ! 291: case NAME: ! 292: case REF: ! 293: case DEREF: ! 294: if (init->e1->tp->is_ptr()) ! 295: init = init->e1; ! 296: else ! 297: init = new expr(G_CM,init,init->e1->address()); ! 298: ! 299: } ! 300: if (ct->tp->base == OVERLOAD) ct = Pgen(ct->tp)->fct_list->f; // first fct ! 301: tbl = 0; ! 302: } ! 303: return call_ctor(tbl,tmp,ct,init,DOT); ! 304: } ! 305: Pexpr ass = new expr(ASSIGN,tmp,init); // no ctor: can assign ! 306: ass->tp = tmp->tp; ! 307: return ass; ! 308: } ! 309: /* ! 310: int exact0(Pname nn, Ptype at) ! 311: // return 1 if ! 312: // exact match ! 313: ! 314: { ! 315: if (nn == 0) return 0; //known==ELLIPSIS; ! 316: Ptype nt = nn->tp; ! 317: if (at == nt) return 1; ! 318: //error('d',"exact0 %d",nt->check(at,0)); ! 319: return nt->check(at,0)==0; ! 320: } ! 321: */ ! 322: ! 323: int exact3(Pname nn, Ptype at) ! 324: /* ! 325: return 1 if ! 326: match with standard conversions ! 327: */ ! 328: { ! 329: if (nn == 0) return 0; //known==ELLIPSIS; ! 330: Ptype nt = nn->tp; ! 331: if (at == nt) return 1; ! 332: ! 333: //error('d',"exact3 %d",nt->check(at,ASSIGN)); ! 334: return nt->check(at,ASSIGN)==0; ! 335: } ! 336: ! 337: int exact1(Pname nn, Ptype at) ! 338: /* ! 339: return 1 if ! 340: exact match with ! 341: T <-> const T ! 342: X -> X& ! 343: T* -> const T* ! 344: T* -> T*const ! 345: taken into account ! 346: */ ! 347: { ! 348: if (nn == 0) return 0;//known==ELLIPSIS; ! 349: Ptype nt = nn->tp; ! 350: if (at == nt) return 1; ! 351: ! 352: //error('d',"exact1 nt %t at %t",nt,at); ! 353: if (nt->check(at,0)) { ! 354: //error('d',"nt %t at %t cp %d",nt,at,const_problem); ! 355: if (const_problem) return 1; // handle T <-> const T ! 356: ! 357: Pptr rt = nt->is_ref(); //handle X -> X& ! 358: if (rt && (at->check(Pptr(rt)->typ,0)==0 || const_problem)) return 1; ! 359: ! 360: Pptr art = at->is_ptr(); ! 361: if (rt && art) return 0; // ptrs do not match refs ! 362: ! 363: // handle T* -> const T* and ! 364: // T* -> T*const ! 365: if (rt || (rt = nt->is_ptr())) { ! 366: if (art == 0) art = at->is_ref(); ! 367: if (art) { ! 368: //error('d',"art %t %t",art->typ,rt->typ); ! 369: if (art->typ->check(rt->typ,0)) { ! 370: if (const_problem) return 1; ! 371: } ! 372: else // T* -> T*const ! 373: return 1; ! 374: } ! 375: } ! 376: return 0; ! 377: } ! 378: return 1; ! 379: } ! 380: ! 381: Pexpr Ninit; // default argument used; ! 382: int Nstd; // standard coercion used (derived* =>base* or int=>long or ...) ! 383: ! 384: bit exact_match(Pname n, Pexpr arg) ! 385: /* ! 386: look for an exact match between "n" and the argument list "arg" ! 387: This function goes through three stages: ! 388: (1) exact match (no coercions at all) ! 389: (2) do integral promotions and float->double and re-try exact match ! 390: (3) try for unique standard conversions ! 391: ! 392: */ ! 393: { ! 394: Pfct f = Pfct(n->tp); ! 395: register Pexpr e; ! 396: register Pname nn; ! 397: ! 398: //error('d',"exact_match(%n) %t",n,n->tp); ! 399: ! 400: for (e=arg, nn=f->argtype; e; e=e->e2, nn=nn->n_list) { ! 401: Pexpr a = e->e1; ! 402: Ptype at = a->tp; ! 403: if (at->base == ANY) return 0; ! 404: if (at->base == ZTYPE) at = int_type; ! 405: if (exact1(nn,at)==0) return 0; ! 406: } ! 407: ! 408: //error('d',"exact %d -> %d",nn,nn?nn->n_initializer!=0:1); ! 409: if (nn) { ! 410: Ninit = nn->n_initializer; ! 411: return Ninit!=0; ! 412: } ! 413: ! 414: //error('d',"return 1"); ! 415: return 1; // exact match without any promotions ! 416: } ! 417: ! 418: int exact2(Pname nn, Ptype at) ! 419: /* ! 420: return 1 if ! 421: do integral promotion and float->double on at, then match ! 422: */ ! 423: { ! 424: //error('d',"exact2 nt %t at %t",nn?nn->tp:0,at); ! 425: atat: ! 426: switch (at->base) { ! 427: case TYPE: ! 428: at = Pbase(at)->b_name->tp; ! 429: goto atat; ! 430: case EOBJ: ! 431: at = Penum(Pbase(at)->b_name->tp)->e_type; ! 432: break; ! 433: case ZTYPE: ! 434: at = int_type; ! 435: break; ! 436: case CHAR: ! 437: case SHORT: ! 438: at = (Pbase(at)->b_unsigned && at->tsizeof()==SZ_INT) ? uint_type : int_type; ! 439: break; ! 440: case FLOAT: ! 441: at = double_type; ! 442: } ! 443: ! 444: if (nn == 0) return 0;//known==ELLIPSIS; ! 445: Ptype nt = nn->tp; ! 446: //error('d'," exact2 nt %t at %t",nt,at); ! 447: if (at == nt) return 1; ! 448: if (nt->check(at,0)) { ! 449: if (const_problem) return 1; ! 450: ! 451: Pptr rt = nt->is_ref(); // handle X -> X& ! 452: if (rt && (at->check(Pptr(rt)->typ,0)==0 || const_problem)) return 1; ! 453: ! 454: Pptr art = at->is_ptr(); ! 455: if (rt && art) return 0; // ptrs do not match refs ! 456: ! 457: // handle T* -> const T* and ! 458: // T* -> T*const ! 459: if (rt || (rt = nt->is_ptr())) { ! 460: if (art == 0) art = at->is_ref(); ! 461: if (art) { ! 462: if (art->typ->check(rt->typ,0)) { ! 463: if (const_problem) return 1; ! 464: } ! 465: else // T* -> T*const ! 466: return 1; ! 467: } ! 468: } ! 469: return 0; ! 470: } ! 471: return 1; ! 472: } ! 473: ! 474: bit prom_match(Pname n, Pexpr arg) ! 475: /* ! 476: look for an exact match between "n" and the argument list "arg" ! 477: using integral promotions and float->double ! 478: ! 479: */ ! 480: { ! 481: Pfct f = Pfct(n->tp); ! 482: register Pexpr e; ! 483: register Pname nn; ! 484: ! 485: //error('d',"prom_match(%n) %t",n,n->tp); ! 486: ! 487: for (e=arg, nn=f->argtype; e; e=e->e2, nn=nn->n_list) { ! 488: Pexpr a = e->e1; ! 489: Ptype at = a->tp; ! 490: if (at->base == ANY) return 0; ! 491: ! 492: if (exact2(nn,at)==0) return 0; ! 493: } ! 494: ! 495: if (nn) { ! 496: Ninit = nn->n_initializer; ! 497: return Ninit!=0; ! 498: } ! 499: ! 500: return 1; // exact match with promotions ! 501: } ! 502: ! 503: bit std_match(Pname n, Pexpr arg) ! 504: /* ! 505: look for an exact match between "n" and the argument list "arg" ! 506: using standard conversions ! 507: ! 508: */ ! 509: { ! 510: Pfct f = Pfct(n->tp); ! 511: register Pexpr e; ! 512: register Pname nn; ! 513: ! 514: //error('d',"std_match(%n) %t",n,n->tp); ! 515: ! 516: for (e=arg, nn=f->argtype; e; e=e->e2, nn=nn->n_list) { ! 517: Pexpr a = e->e1; ! 518: Ptype at = a->tp; ! 519: ! 520: if (at->base == ANY) return 0; ! 521: if (nn == 0) return 0;//f->nargs_known==ELLIPSIS; ! 522: ! 523: Ptype nt = nn->tp; ! 524: tptp: ! 525: switch (nt->base) { ! 526: case TYPE: ! 527: nt = Pbase(nt)->b_name->tp; ! 528: goto tptp; ! 529: case RPTR: ! 530: if (at==zero_type && Pptr(nt)->typ->is_ptr()==0) return 0; //break; ! 531: if (nt->check(at,COERCE)) { ! 532: Pptr pt = at->addrof(); ! 533: nt->base = PTR; // handle derived classes ! 534: if (nt->check(pt,COERCE)) { ! 535: nt->base = RPTR; ! 536: delete pt; ! 537: return 0; ! 538: } ! 539: nt->base = RPTR; ! 540: delete pt; ! 541: } ! 542: break; ! 543: default: ! 544: // if (nt->check(at,COERCE)) return 0; ! 545: switch (at->base) { ! 546: default: ! 547: if (nt->check(at,COERCE)) return 0; ! 548: break; ! 549: case OVERLOAD: ! 550: { ! 551: // the actual argument is an overloaded function ! 552: // we'll try each instance until one matches ! 553: register Plist gl; ! 554: int no_match = 1; ! 555: ! 556: for (gl = Pgen(at)->fct_list; gl; gl=gl->l) { ! 557: if (nt->check(gl->f->tp,COERCE)==0) { ! 558: no_match = 0; ! 559: break; ! 560: } ! 561: } ! 562: ! 563: if ( no_match ) return 0; ! 564: } ! 565: } // end at->base switch ! 566: ! 567: } ! 568: } ! 569: ! 570: if (nn) { ! 571: Ninit = nn->n_initializer; ! 572: return Ninit!=0; ! 573: } ! 574: ! 575: return 1; ! 576: } ! 577: ! 578: Pname Ncoerce; ! 579: int ref_cast; ! 580: ! 581: bit can_coerce(Ptype t1, Ptype t2) ! 582: /* return number of possible coercions of t2 into t1, ! 583: Ncoerce holds a coercion function (not constructor), if found ! 584: */ ! 585: { ! 586: int zz = 0; ! 587: Ncoerce = 0; ! 588: if (t2->base == ANY) return 0; ! 589: //error('d',"can_coerce t1 %t t2 %t",t1,t2); ! 590: ! 591: tptp: ! 592: switch (t1->base) { ! 593: case TYPE: ! 594: t1 = Pbase(t1)->b_name->tp; ! 595: goto tptp; ! 596: case RPTR: ! 597: rloop: ! 598: switch (t2->base) { ! 599: case TYPE: ! 600: t2 = Pbase(t2)->b_name->tp; ! 601: goto rloop; ! 602: // case VEC: ! 603: // case PTR: ! 604: // case RPTR: ! 605: // if (t1->check(t2,COERCE) == 0) return 1; ! 606: default: ! 607: { Ptype tt2 = t2->addrof(); ! 608: if (t1->check(tt2,COERCE) == 0) return 1; ! 609: if (ref_cast) break;//return 0; // (T&): no coercions ! 610: // except operator T&() ! 611: Ptype tt1 = Pptr(t1)->typ; ! 612: while (tt1->base==TYPE) tt1 = Pbase(tt1)->b_name->tp; ! 613: int bc = Pbase(tt1)->b_const; ! 614: Pbase(tt1)->b_const = 0; ! 615: int i = can_coerce(tt1,t2); ! 616: Pbase(tt1)->b_const = bc; ! 617: if (i) return i; ! 618: zz = 1; ! 619: } ! 620: } ! 621: } ! 622: ! 623: Pname c1 = t1->is_cl_obj(); ! 624: Pname c2 = t2->is_cl_obj(); ! 625: int val = 0; ! 626: if (ref_cast || zz) goto oper_coerce; ! 627: if (c1) { ! 628: Pclass cl = Pclass(c1->tp); ! 629: if (c2 && c2->tp==cl) return 1; ! 630: ! 631: /* look for constructor ! 632: with one argument ! 633: or with default for second argument ! 634: of acceptable type ! 635: */ ! 636: Pname ctor = cl->has_ctor(); ! 637: if (ctor == 0) goto oper_coerce; ! 638: register Pfct f = Pfct(ctor->tp); ! 639: //error('d',"ctor %n f %t",ctor,f); ! 640: switch (f->base) { ! 641: case FCT: ! 642: switch (f->nargs) { ! 643: case 1: ! 644: one: ! 645: { Ptype tt = f->argtype->tp; ! 646: //error('d',"tt %t t2 %t -> %d cp %d",tt,t2,tt->check(t2,COERCE),const_problem); ! 647: if (tt->check(t2,COERCE)==0) ! 648: val = 1; ! 649: else if (const_problem) { ! 650: Pptr p1 = tt->is_ptr_or_ref(); ! 651: if (p1==0 || p1->typ->tconst()) val = 1; ! 652: } ! 653: if (tt = tt->is_ref()) { ! 654: Pptr pt = t2->addrof(); // handle derived classed ! 655: tt->base = PTR; ! 656: if (tt->check(pt,COERCE) == 0) val = 1; ! 657: tt->base = RPTR; ! 658: delete pt; ! 659: } ! 660: goto oper_coerce; ! 661: } ! 662: default: ! 663: if (f->argtype->n_list->n_initializer) goto one; ! 664: case 0: ! 665: goto oper_coerce; ! 666: } ! 667: case OVERLOAD: ! 668: { register Plist gl; ! 669: ! 670: for (gl=Pgen(f)->fct_list; gl; gl=gl->l) { // look for match ! 671: Pname nn = gl->f; ! 672: Pfct ff = Pfct(nn->tp); ! 673: ! 674: switch (ff->nargs) { ! 675: case 0: ! 676: break; ! 677: case 1: ! 678: over_one: ! 679: { Ptype tt = ff->argtype->tp; ! 680: //error('d',"over one %t %t -> %d %d",tt,t2,tt->check(t2,COERCE),const_problem); ! 681: if (tt->check(t2,COERCE)==0) ! 682: val = 1; ! 683: else if (const_problem) { ! 684: Pptr p1 = tt->is_ptr_or_ref(); ! 685: if (p1==0 || p1->typ->tconst()) val = 1; ! 686: } ! 687: if (tt=tt->is_ref()) { ! 688: Pptr pt = t2->addrof(); // handle derived classed ! 689: tt->base = PTR; ! 690: if (tt->check(pt,COERCE) == 0) { ! 691: tt->base = RPTR; ! 692: delete pt; ! 693: val = 1; ! 694: goto oper_coerce; ! 695: } ! 696: tt->base = RPTR; ! 697: delete pt; ! 698: } ! 699: break; ! 700: } ! 701: default: ! 702: if (ff->argtype->n_list->n_initializer) goto over_one; ! 703: } ! 704: } ! 705: goto oper_coerce; ! 706: } ! 707: default: ! 708: error('i',"cannot_coerce(%k)\n",f->base); ! 709: } ! 710: } ! 711: ! 712: oper_coerce: ! 713: //error('d',"oper_coerce %d",val); ! 714: if (c2) { ! 715: Pclass cl = Pclass(c2->tp); ! 716: int std = 0; ! 717: int oval = val; ! 718: extern Pname conv_dominates(Pname,Pname); ! 719: for (Pname ox, on=cl->conv; on; on=ox) { ! 720: Pfct f = Pfct(on->tp); ! 721: ox = on->n_list; ! 722: Nstd = 0; ! 723: //error('d',"on %n -> %d",on,t1->check(f->returns,COERCE)); ! 724: if (t1->check(f->returns,COERCE) == 0) { ! 725: if (Nstd==0) { // forget solutions involving standard conversions ! 726: Pname old = Ncoerce; ! 727: if (std) { // forget ! 728: val = oval+1; ! 729: std = 0; ! 730: Ncoerce = on; ! 731: } ! 732: else if (Ncoerce == 0) { ! 733: // val = 1; ! 734: val++; ! 735: Ncoerce = on; ! 736: } ! 737: else if ((Ncoerce = conv_dominates(Ncoerce,on))==0) { ! 738: if (val == 1) { ! 739: //error('d',"val==1 on %n old %n",on,old); ! 740: Ptype ton = Pfct(on->tp)->returns; ! 741: Ptype tco = Pfct(old->tp)->returns; ! 742: if (t1->check(ton,0)==0) ! 743: ; ! 744: else if (t1->check(tco,0)==0) ! 745: on = old; ! 746: else ! 747: val++; ! 748: } ! 749: else ! 750: val++; ! 751: Ncoerce = on; ! 752: } ! 753: } ! 754: else { // take note only if no exact match seen ! 755: if (Ncoerce==0 || on->tp->check(Ncoerce->tp,0)) { ! 756: if (val==0 || std) { ! 757: ! 758: if (Ncoerce) Ncoerce = conv_dominates(Ncoerce,on); ! 759: if (Ncoerce == 0) { ! 760: Ncoerce = on; ! 761: val++; ! 762: std = 1; ! 763: } ! 764: } ! 765: } ! 766: } ! 767: } ! 768: ! 769: } ! 770: } ! 771: //error('d',"val %d",val); ! 772: if (val) return val; ! 773: if (c1 && Pclass(c1->tp)->has_itor()) return 0; ! 774: //error('d',"%t->check(%t) -> %d",t1,t2,t1->check(t2,COERCE)); ! 775: if (t1->check(t2,COERCE)) return 0; ! 776: return 1; ! 777: } ! 778: ! 779: int gen_coerce(Pname n, Pexpr arg) ! 780: /* ! 781: look to see if the argument list "arg" can be coerced into a call of "n" ! 782: 1: it can ! 783: 0: it cannot or it can be done in more than one way ! 784: */ ! 785: { ! 786: Pfct f = (Pfct) n->tp; ! 787: register Pexpr e; ! 788: register Pname nn; ! 789: ! 790: //error('d',"gen_coerce(%n,%d) %t",n,arg,n->tp); ! 791: for (e=arg, nn=f->argtype; e; e=e->e2, nn=nn->n_list) { ! 792: if (nn == 0) return f->nargs_known==ELLIPSIS; ! 793: Pexpr a = e->e1; ! 794: Ptype at = a->tp; ! 795: int i = can_coerce(nn->tp,at); ! 796: //error('d',"i %d",i); ! 797: if (i != 1) return 0; ! 798: } ! 799: if (nn && nn->n_initializer==0) return 0; ! 800: return 1; ! 801: } ! 802: ! 803: ! 804: Pname Nover; ! 805: // int Nover_coerce; ! 806: ! 807: int over_call(Pname n, Pexpr arg) ! 808: /* ! 809: return 4 if n(arg) can be performed without coercion of arg ! 810: return 3 if n(arg) can be performed only with promotion coercion of arg ! 811: return 2 if n(arg) can be performed only with standard coercion of arg ! 812: return 1 if n(arg) can be performed only with user defined coercion of arg ! 813: return 0 if n(arg) is an error ! 814: Nover is the function found, if any ! 815: Nstd is the number of standard coercions used ! 816: */ ! 817: { ! 818: register Plist gl; ! 819: Pgen g = Pgen(n->tp); ! 820: if (arg && arg->base!= ELIST) error('i',"ALX"); ! 821: ! 822: //error('d',"over_call(%n) %k",n,n->tp->base); ! 823: extern suppress_error; ! 824: suppress_error = 1; ! 825: // Nover_coerce = 0; ! 826: Nstd = 0; ! 827: switch (g->base) { ! 828: default: error('i',"over_call(%t)\n",g); ! 829: case OVERLOAD: break; ! 830: case FCT: ! 831: Nover = n; ! 832: Ninit = 0; ! 833: if (exact_match(n,arg)) {suppress_error = 0; return 4;} ! 834: if (prom_match(n,arg)) {suppress_error = 0; return 3;} ! 835: if (std_match(n,arg) && Ninit==0) {suppress_error = 0; return 2;} ! 836: Nstd = 0; ! 837: suppress_error = 0; ! 838: return gen_coerce(n,arg); ! 839: } ! 840: ! 841: Pname exact = 0; ! 842: int no_exact = 0; ! 843: int ret = 0; ! 844: Pname nret; ! 845: for (gl=g->fct_list; gl; gl=gl->l) { /* look for match */ ! 846: Nover = gl->f; ! 847: Ninit = 0; ! 848: Nstd = 0; ! 849: if (exact_match(Nover,arg)) {suppress_error = 0; return 4;} // no coercion ! 850: // if (prom_match(Nover,arg)) return 3; // only promotion ! 851: // if (std_match(Nover,arg) && Ninit==0) return 2; // only built-in conversion ! 852: if (ret<3 && prom_match(Nover,arg)) { ! 853: nret = Nover; ! 854: ret = 3; ! 855: } ! 856: if (ret<2 && std_match(Nover,arg) && Ninit==0) { ! 857: nret = Nover; ! 858: ret = 2; ! 859: } ! 860: } ! 861: ! 862: suppress_error = 0; ! 863: if (ret) { ! 864: Nover = nret; ! 865: return ret; ! 866: } ! 867: ! 868: Nover = 0; ! 869: for (gl=g->fct_list; gl; gl=gl->l) { /* look for coercion */ ! 870: Pname nn = gl->f; ! 871: if (gen_coerce(nn,arg)) { ! 872: Nover = nn; ! 873: return 1; ! 874: } ! 875: } ! 876: return 0; ! 877: ! 878: } ! 879: ! 880: Ptype expr::call_fct(Ptable tbl) ! 881: /* ! 882: check "this" call: ! 883: e1(e2) ! 884: e1->typ() and e2->typ() has been done ! 885: */ ! 886: { ! 887: Pfct f; ! 888: Pname fn; ! 889: int x; ! 890: int k; ! 891: Pname nn; ! 892: Pexpr e; ! 893: Ptype t; ! 894: Pexpr arg = e2; ! 895: Ptype t1 = e1?e1->tp:0; ! 896: int argno; ! 897: Pexpr etail = 0; ! 898: Pname no_virt = 0; // set if explicit qualifier was used: c::f() ! 899: Pname chk = 0; // set if visibility check is needed ! 900: // that is if function name might have been ! 901: // found without use of find_name() ! 902: int const_obj = 0; ! 903: ! 904: if (t1 == any_type) return any_type; ! 905: ! 906: switch (base) { ! 907: case CALL: ! 908: case G_CALL: break; ! 909: default: error('i',"call_fct(%k)",base); ! 910: } ! 911: ! 912: //error('d',"call %d %k %n arg %d",this,e1->base,e1->base==NAME?e1:0,arg); ! 913: if (t1 == 0) error('i',"call_fct(e1=%d,e1->tp=%t)",e1,t1); ! 914: if (arg && arg->base!=ELIST) error('i',"badAL%d%k",arg,arg->base); ! 915: ! 916: switch (e1->base) { ! 917: case NAME: ! 918: fn = Pname(e1); ! 919: //error('d',"name %n %k",fn,fn->n_oper); ! 920: switch (fn->n_oper) { ! 921: case 0: ! 922: case CTOR: ! 923: case DTOR: ! 924: case TYPE: ! 925: case NEW: ! 926: case DELETE: ! 927: break; ! 928: default: // real operator: check for operator+(1,2); ! 929: if (arg == 0) break; ! 930: Pexpr a = arg->e1; // first operand ! 931: ! 932: if (Pfct(fn->tp)->memof // obj.operator(1) is OK ! 933: || a->tp->is_cl_obj() ! 934: || a->tp->is_ref()) break; ! 935: a = arg->e2; ! 936: if (a == 0) // unary ! 937: error("%k of basicT",fn->n_oper); ! 938: else { // binary ! 939: a = a->e1; // second operand ! 940: if (a->tp->is_cl_obj() || a->tp->is_ref()) break; ! 941: error("%k of basicTs",fn->n_oper); ! 942: } ! 943: break; ! 944: } ! 945: break; ! 946: case REF: ! 947: case DOT: ! 948: no_virt = Pname(e1->n_initializer); ! 949: e1->n_initializer = 0; ! 950: // const_obj = (e1&&e1->e1)?e1->e1->tp->tconst():0; ! 951: if (e1 && e1->e1) { ! 952: Ptype t = e1->e1->tp; ! 953: Pptr tt = t->is_ptr_or_ref(); ! 954: //error('d',"t %t tt %t",t,tt); ! 955: const_obj = (tt ? tt->typ : t)->tconst(); ! 956: } ! 957: case MDOT: ! 958: { Pexpr n = e1->mem; ! 959: lxlx: ! 960: switch (n->base) { ! 961: case MDOT: ! 962: // reverse mdot (see expr::print()) ! 963: // p->a.b() => (&p->a)->b() => b(&p->a) ! 964: // or p->a->b() => (p->a)->b() => b(p->a) ! 965: // or oo.a.b() => (&oo.a)->b() => b(&oo.a) ! 966: // or oo.a->b() => (oo.a)->b() => b(oo.a) ! 967: { ! 968: Pexpr r = e1; ! 969: Pexpr p = r->e1; ! 970: for (Pexpr m = r->mem; m->base==MDOT; m = r->mem) { ! 971: p = new mdot(m->string2,p); ! 972: p->i1 = m->i1+2; ! 973: p->tp = p->mem->tp; ! 974: r->mem = m->mem; ! 975: r->e1 = p; ! 976: } ! 977: } ! 978: case REF: ! 979: case DOT: ! 980: n = n->mem; ! 981: goto lxlx; ! 982: case NAME: ! 983: break; ! 984: default: ! 985: error('i',"ref %k",n->base); ! 986: } ! 987: fn = Pname(n); ! 988: //error('d',"mem %n",fn); ! 989: break; ! 990: } ! 991: case MEMPTR: ! 992: default: ! 993: fn = 0; ! 994: }; ! 995: ! 996: lll: ! 997: //error('d',"lll: %t %k",t1,t1->base); ! 998: switch (t1->base) { ! 999: case TYPE: ! 1000: t1 = Pbase(t1)->b_name->tp; ! 1001: goto lll; ! 1002: ! 1003: case PTR: // pf() allowed as shorthand for (*pf)() ! 1004: switch (Pptr(t1)->typ->base) { ! 1005: case FCT: ! 1006: case OVERLOAD: ! 1007: if (Pptr(t1)->memof) error("O missing in call throughP toMF"); ! 1008: t1 = Pptr(t1)->typ; ! 1009: fn = 0; ! 1010: goto lll; ! 1011: } ! 1012: ! 1013: default: ! 1014: if (fn) ! 1015: error("call of%n;%n is a%t",fn,fn,e1->tp); ! 1016: else ! 1017: error("call of%kE ofT%t",e1->base,e1->tp); ! 1018: ! 1019: case ANY: ! 1020: return any_type; ! 1021: ! 1022: case OVERLOAD: ! 1023: { register Plist gl; ! 1024: Pgen g = Pgen(t1); ! 1025: Pname found = 0; ! 1026: Pname exact = 0; ! 1027: int no_exact = 0; ! 1028: ! 1029: for (gl=g->fct_list; gl; gl=gl->l) { // look for exact match ! 1030: register Pname nn = gl->f; ! 1031: if (exact_match(nn,arg)) { ! 1032: //error('d',"found exact %n %t",nn,nn->tp); ! 1033: if (found) { ! 1034: // check if one fct dominates the other ! 1035: Pname d = dominate(found,nn,arg,const_obj,0); ! 1036: if (d) ! 1037: nn = d; ! 1038: else ! 1039: error("two exact matches for%n:%t and%t",nn,nn->tp,found->tp); ! 1040: } ! 1041: found = nn; ! 1042: } ! 1043: } ! 1044: //error('d',"found exact2 %n",found); ! 1045: if (found) goto fnd; ! 1046: ! 1047: for (gl=g->fct_list; gl; gl=gl->l) { // look for exact match ! 1048: register Pname nn = gl->f; ! 1049: ! 1050: if (prom_match(nn,arg)) { ! 1051: if (found) { ! 1052: // check if one fct dominates the other ! 1053: Pname d = dominate(found,nn,arg,const_obj,1); ! 1054: if (d) ! 1055: nn = d; ! 1056: else ! 1057: error("two exact matches (after integral promotions) for%n:%t and%t",nn,nn->tp,found->tp); ! 1058: } ! 1059: found = nn; ! 1060: } ! 1061: } ! 1062: //error('d',"found exact2 %n",found); ! 1063: if (found) goto fnd; ! 1064: ! 1065: // for (gl=g->fct_list; gl; gl=gl->l) { // look for exact match ! 1066: // register Pname nn = gl->f; ! 1067: // ! 1068: // if (exact_match(nn,arg) || prom_match(nn,arg)) { ! 1069: // found = nn; ! 1070: // goto fnd; ! 1071: // } ! 1072: // } ! 1073: ! 1074: Pname mvec[10]; ! 1075: for (gl=g->fct_list; gl; gl=gl->l) { // look for match ! 1076: // with standard conversion ! 1077: register Pname nn = gl->f; ! 1078: Ninit = 0; ! 1079: Nstd = 0; ! 1080: if (std_match(nn,arg)) { ! 1081: // if (Nstd == 0) { ! 1082: // found = nn; ! 1083: // goto fnd; ! 1084: // } ! 1085: if (exact) { ! 1086: // check if one fct dominates the other ! 1087: Pname d = dominate(exact,nn,arg,const_obj,2); ! 1088: if (d == 0) { ! 1089: mvec[no_exact++] = nn; ! 1090: // no_exact++; ! 1091: // error("two standard conversions possible for%n: %t and %t",fn,exact->tp,nn->tp); ! 1092: } ! 1093: else ! 1094: exact = d; ! 1095: } ! 1096: else ! 1097: exact = nn; ! 1098: } ! 1099: ! 1100: } ! 1101: ! 1102: //error('d',"excact %n",exact); ! 1103: if (exact) { ! 1104: if (no_exact) { ! 1105: while (no_exact) { ! 1106: Pname d = dominate(exact,mvec[--no_exact],arg,const_obj,2); ! 1107: if (d) ! 1108: exact = d; ! 1109: else ! 1110: error("two standard conversions possible for%n: %t and %t",fn,exact->tp,mvec[no_exact]->tp); ! 1111: } ! 1112: ! 1113: } ! 1114: //error('d',"found exact3 %n",found); ! 1115: found = exact; ! 1116: goto fnd; ! 1117: } ! 1118: ! 1119: for (gl=g->fct_list; gl; gl=gl->l) { /* look for coercion */ ! 1120: register Pname nn = gl->f; ! 1121: if (gen_coerce(nn,arg)) { ! 1122: //error('d',"user2 %n %t",nn,nn->tp); ! 1123: if (found) { ! 1124: // check if one fct dominates the other ! 1125: Pname d = dominate(found,nn,arg,const_obj,3); ! 1126: if (d == 0) d = user_dominate(found,nn); ! 1127: if (d == 0) { ! 1128: error("ambiguousA for%n: %t and %t",fn,found->tp,nn->tp); ! 1129: goto fnd; ! 1130: } ! 1131: else ! 1132: found = d; ! 1133: } ! 1134: else ! 1135: found = nn; ! 1136: } ! 1137: } ! 1138: ! 1139: fnd: ! 1140: //error('d',"fnd %t",found?found->tp:0); ! 1141: if (found) { ! 1142: chk = fn = found; ! 1143: f = Pfct(fn->tp); ! 1144: } ! 1145: else { ! 1146: error("badAL for%n (no match against any %n)",fn,fn); ! 1147: return any_type; ! 1148: } ! 1149: break; ! 1150: } ! 1151: case FCT: ! 1152: f = Pfct(t1); ! 1153: if (fn) { ! 1154: switch (fn->n_oper) { ! 1155: case CTOR: ! 1156: case TYPE: ! 1157: chk = fn; ! 1158: } ! 1159: } ! 1160: } ! 1161: ! 1162: //error('d',"chk %n",chk); ! 1163: if (chk) { ! 1164: Ptype t = 0; ! 1165: Pexpr ee = e1->e1; ! 1166: ! 1167: switch (e1->base) { ! 1168: case REF: // ptr->chk() ! 1169: if (ee == 0) { // 0->x() fudge handling new x() ! 1170: check_visibility(chk,no_virt,Pclass(chk->n_table->t_name->tp),tbl,cc->nof); ! 1171: break; ! 1172: }; ! 1173: t = ee->tp; ! 1174: while(t->base==TYPE) t = Pbase(t)->b_name->tp; ! 1175: t = Pptr(t)->typ; ! 1176: break; ! 1177: case DOT: // obj.chk() ! 1178: t = ee->tp; ! 1179: } ! 1180: ! 1181: Pname cn = t?t->is_cl_obj():0; ! 1182: Pclass cl = cn?Pclass(cn->tp):0; // class of ``this'' for chk ! 1183: ! 1184: if (cl) { ! 1185: if (chk->n_oper==CTOR ! 1186: && chk->n_protect ! 1187: && cc->nof ! 1188: && cc->nof->n_oper==CTOR) ! 1189: // BUG: cannot handle protected base ! 1190: // class constructor ! 1191: ; ! 1192: else { ! 1193: check_visibility(chk,no_virt,cl,tbl,cc->nof); ! 1194: } ! 1195: } ! 1196: } ! 1197: ! 1198: if (fn && f->f_result==0) { ! 1199: // protect against class cn; cn f(); ... class cn { cn(cn&); ... }; ! 1200: make_res(f); ! 1201: //error('d',"returns %t",f->returns); ! 1202: f->returns->tsizeof(); // make sure it is declared ! 1203: } ! 1204: ! 1205: //error('d',"fn %n %t printed %d",fn,fn?fn->tp:0,fn?fn->n_dcl_printed:0); ! 1206: if (fn && fn->n_dcl_printed==0) { ! 1207: if (f->f_inline==0 && f->f_imeasure) { ! 1208: extern void uninline(Pname fn); ! 1209: uninline(fn); ! 1210: } ! 1211: ! 1212: // ensure printout of class declaration: ! 1213: for (Pname nn=f->argtype; nn; nn=nn->n_list) ! 1214: if (nn->tp->is_cl_obj()) (void) nn->tp->tsizeof(); ! 1215: ! 1216: fn->dcl_print(0); ! 1217: } ! 1218: ! 1219: if (no_virt && f->f_static==0) { ! 1220: if (e1->base==REF || e1->base==DOT) e1->n_initializer = fn; ! 1221: } ! 1222: else ! 1223: fct_name = fn; ! 1224: //error('d',"fn %n %t %d %d",fn,f,f->f_this,f->f_static); ! 1225: if (f->f_this) { //SSS call of non-static memberfunction ! 1226: switch (e1->base) { ! 1227: case MEMPTR: ! 1228: case REF: ! 1229: case DOT: ! 1230: break; ! 1231: default: ! 1232: error("O orP missing for%n ofT %t",fct_name,f); ! 1233: } ! 1234: } ! 1235: else if (fn) { //SSS call of static function ! 1236: sss: ! 1237: switch (e1->base) { ! 1238: case REF: ! 1239: case DOT: ! 1240: e1 = e1->mem; ! 1241: goto sss; ! 1242: } ! 1243: } ! 1244: ! 1245: if (fn) fn->use(); // a patch: ctors are sometimes not use()d ! 1246: ! 1247: if (f->f_const==0 ! 1248: && (fn==0 || (fn->n_oper!=CTOR && fn->n_oper!=DTOR))) { //CCC ! 1249: Pexpr ee = e1->e1; ! 1250: if (ee) { ! 1251: Ptype tt = ee->tp; ! 1252: switch (e1->base) { ! 1253: case REF: ! 1254: { Pptr p = tt?tt->is_ptr():0; ! 1255: if (p && p->typ->tconst()) ! 1256: error(strict_opt?0:'w',"non-constMF%n called for constO",fn); ! 1257: // is really an error, but only warn to help transition ! 1258: break; ! 1259: } ! 1260: case DOT: ! 1261: if (tt && tt->tconst()) ! 1262: error(strict_opt?0:'w',"non-constMF%n called for constO",fn); ! 1263: // is really an error, but only warn to help transition ! 1264: } ! 1265: } ! 1266: } ! 1267: ! 1268: t = f->returns; ! 1269: x = f->nargs; ! 1270: k = f->nargs_known; ! 1271: ! 1272: e = arg; ! 1273: if (k == 0) goto rlab; ! 1274: ! 1275: for (nn=f->argtype, argno=1; e||nn; nn=nn->n_list, e=etail->e2, argno++) { ! 1276: Pexpr a; ! 1277: ! 1278: if (e) { ! 1279: a = e->e1; ! 1280: etail = e; ! 1281: ! 1282: if (nn) { /* type check */ ! 1283: Ptype t1 = nn->tp; ! 1284: //error('d',"argtp %t etp %t a %k",t1,a->tp,a->base); ! 1285: ! 1286: lx: ! 1287: switch (t1->base) { ! 1288: case TYPE: ! 1289: t1 = Pbase(t1)->b_name->tp; ! 1290: goto lx; ! 1291: case RPTR: ! 1292: { Ptype pt = Pptr(t1)->typ; ! 1293: if (pt->base != FCT || ! 1294: ( pt->base == FCT && ! 1295: pt->check(a->tp,0))) ! 1296: a = ref_init(Pptr(nn->tp),a,tbl); ! 1297: goto cbcb; ! 1298: } ! 1299: case COBJ: ! 1300: if (a->base!=G_CM ! 1301: || nn->tp->check(a->tp,ASSIGN)) ! 1302: a = class_init(0,t1,a,tbl); ! 1303: if (nn->n_xref) { ! 1304: // (temp.ctor(arg),&arg) ! 1305: a = a->address(); ! 1306: } ! 1307: else { ! 1308: // defend against: ! 1309: // int f(X); ... X(X&); ! 1310: Pname cln = Pbase(t1)->b_name; ! 1311: if (cln && Pclass(cln->tp)->has_itor()) { ! 1312: // mark X(X&) arguments ! 1313: nn->n_xref = 1; ! 1314: a = a->address(); ! 1315: } ! 1316: } ! 1317: cbcb: ! 1318: //error('d',"cbcb: a %d %k %t",a->base,a->base,a->tp); ! 1319: if (a->base==G_CM) { ! 1320: if (a->e1->base==DEREF) a->e1 = a->e1->e2; // (*e1,e2) => (e1,e2) ! 1321: //error('d'," a %d %k",a->e1->base,a->e1->base); ! 1322: if (a->e1->base==G_CALL ! 1323: && Pname(a->e1->fct_name) ! 1324: && Pname(a->e1->fct_name)->n_oper==CTOR ! 1325: && (a->e2->base==G_ADDROF || a->e2->base==ADDROF)) { ! 1326: a = a->e1; // (ctor(&tmp),&tmp) => ctor(&tmp) ! 1327: //error('d',"tmp %k %n",a->e2->base,a->e2->e2); ! 1328: goto cccc; ! 1329: } ! 1330: else if (a->e2->base==G_ADDROF ! 1331: && a->e2->e2->base==NAME) { ! 1332: cccc: ! 1333: //error('d',"cccc: a %d %k %t",a->base,a->base,a->tp); ! 1334: if (t1->base==RPTR ! 1335: && Pptr(t1)->typ->tconst()==0) { // temporary used ! 1336: if (warning_opt) ! 1337: error('w',"temporary used for non-const%tA",nn->tp); ! 1338: else { ! 1339: Ptype atp = a->tp; ! 1340: if (atp==void_type ! 1341: && a->base==G_CALL ! 1342: && a->e1->tp->base==FCT) ! 1343: atp = Pfct(a->e1->tp)->s_returns; ! 1344: ! 1345: Ptype tt = t1->is_ref(); ! 1346: //error('d',"tt %t atp %t",tt,atp); ! 1347: if (tt) { ! 1348: if (Pptr(tt)->typ->tsizeof()!=atp->tsizeof()) { // sliced ! 1349: Ptype aat = atp->is_ptr_or_ref(); ! 1350: if (aat==0 ! 1351: || Pptr(tt)->typ->tsizeof()!=Pptr(aat)->typ->tsizeof()) ! 1352: error('w',"temporary used for non-const%tA",nn->tp); ! 1353: } ! 1354: } ! 1355: else if (t1->tsizeof()!=atp->tsizeof()) // sliced ! 1356: error('w',"temporary used for non-const%tA",nn->tp); ! 1357: } ! 1358: ! 1359: // if (warning_opt // blabber ! 1360: // || t1->tsizeof()!=a->tp->tsizeof())) // sliced ! 1361: // error('w',"temporary used for non-const%tA",nn->tp); ! 1362: ! 1363: } ! 1364: } ! 1365: } ! 1366: e->e1 = a; ! 1367: break; ! 1368: case ANY: ! 1369: goto rlab; ! 1370: case PTR: ! 1371: {// Pexpr x = a; ! 1372: e->e1/* = a */= ptr_init(Pptr(t1),a,tbl); ! 1373: // if (x==a || x==a->e2) goto def; // needs checking ! 1374: if (Pchecked == 0) goto def; ! 1375: break; ! 1376: } ! 1377: // e->e1 = a = ptr_init(Pptr(t1),a,tbl); ! 1378: // goto def; ! 1379: case CHAR: ! 1380: case SHORT: ! 1381: case INT: ! 1382: // if (a->base==ICON && a->tp==long_type) ! 1383: // error('w',"long constantA for%n,%kX",fn,t1->base); ! 1384: { Ptype t = a->tp; ! 1385: csi: ! 1386: switch (t->base) { ! 1387: case TYPE: ! 1388: t = Pbase(t)->b_name->tp; goto csi; ! 1389: case LONG: ! 1390: case FLOAT: ! 1391: case DOUBLE: ! 1392: case LDOUBLE: ! 1393: error('w',"%t passed as %t",a->tp,t1); ! 1394: } ! 1395: } ! 1396: // no break ! 1397: case LONG: ! 1398: if (Pbase(t1)->b_unsigned ! 1399: && a->base==UMINUS ! 1400: && a->e2->base==ICON) ! 1401: error('w',"negativeA for%n, unsignedX",fn); ! 1402: default: ! 1403: def: ! 1404: { Pexpr x = try_to_coerce(t1,a,"argument",tbl); ! 1405: //error('d',"x %d t1 %t nn %t a1 %t",x,t1,nn->tp,a->tp); ! 1406: if (x) ! 1407: e->e1 = x; ! 1408: else if (nn->tp->check(a->tp,ARG)) { ! 1409: error("badA %dT for%n:%t (%tX)",argno,fn,a->tp,nn->tp); ! 1410: return any_type; ! 1411: } ! 1412: } ! 1413: } ! 1414: ! 1415: Pexpr tt = e->e1; ! 1416: while ( tt->base == CAST ) ! 1417: tt = tt->e1; ! 1418: if ( tt->base == ILIST ) ! 1419: e->e1 = tt; ! 1420: ! 1421: if (e->e1->base == ILIST) { ! 1422: extern Pbase mptr_type; ! 1423: Pexpr mptr_assign(Pexpr, Pexpr); ! 1424: // memptr constant ! 1425: // f({1,2,f}) ==> memptr t; f((t={1,2,f},t)) ! 1426: Pname temp = make_tmp('A',mptr_type,tbl); ! 1427: e->e1 = mptr_assign(temp,e->e1); ! 1428: e->e1 = a = new expr(G_CM,e->e1,temp); ! 1429: a->tp = temp->tp; ! 1430: } ! 1431: ! 1432: } ! 1433: else { ! 1434: if (k != ELLIPSIS) { ! 1435: error("unexpected %dA for%n",argno,fn); ! 1436: return any_type; ! 1437: } ! 1438: goto rlab; ! 1439: } ! 1440: } ! 1441: else { /* default argument? */ ! 1442: a = nn->n_initializer; ! 1443: if (a == 0) { ! 1444: error("A %d ofT%tX for%n",argno,nn->tp,fn); ! 1445: return any_type; ! 1446: } ! 1447: if (a->base == ILIST) { ! 1448: extern Pbase mptr_type; ! 1449: Pexpr mptr_assign(Pexpr, Pexpr); ! 1450: // memptr constant ! 1451: // f({1,2,f}) ==> memptr t; f((t={1,2,f},t)) ! 1452: Pname temp = make_tmp('A',mptr_type,tbl); ! 1453: a = mptr_assign(temp,a); ! 1454: a = new expr(G_CM,a,temp); ! 1455: a->tp = temp->tp; ! 1456: } ! 1457: a->permanent = 2; // ought not be necessary, but it is ! 1458: e = new expr(ELIST,a,0); ! 1459: if (etail) ! 1460: etail->e2 = e; ! 1461: else ! 1462: e2 = e; ! 1463: etail = e; ! 1464: } ! 1465: } ! 1466: ! 1467: rlab: ! 1468: //error('d',"rlab fct_name %n %t",fct_name,fct_name?fct_name->tp:0); ! 1469: for (; e; e = e->e2) { // unchecked arguments ! 1470: Pexpr a = e->e1; ! 1471: Pname cn; ! 1472: ! 1473: if (a->base==NAME && a->tp->base==FCT) { ! 1474: // function name that escaped the type system: ! 1475: // update use count ! 1476: a->lval(ADDROF); ! 1477: } ! 1478: else if (cn = a->tp->is_cl_obj()) { ! 1479: Pclass cl = Pclass(cn->tp); ! 1480: if (cl->has_ctor() || cl->memtbl->look("__as",0)/*cl->has_oper(ASSIGN)*/) ! 1481: error("O ofC%t withK or = copied",cl); ! 1482: } ! 1483: else if (a->tp->is_ref()) ! 1484: e->e1 = a->contents(); ! 1485: } ! 1486: ! 1487: if (f->f_result) { // f(args) => (f(&temp,args),temp) ! 1488: Pname tn = make_tmp('R',f->returns,tbl); ! 1489: e2 = new expr(ELIST,tn->address(),e2); ! 1490: //error('d',"result %n",fn); ! 1491: Pexpr ee = new expr(0,0,0); ! 1492: *ee = *this; ! 1493: base = G_CM; // (f(&temp,args),temp) ! 1494: e1 = ee; ! 1495: e2 = tn; ! 1496: tp = tn->tp; ! 1497: } ! 1498: ! 1499: return t; ! 1500: } ! 1501: ! 1502: Pexpr ref_init(Pptr p, Pexpr init, Ptable tbl) ! 1503: /* ! 1504: initialize the "p" with the "init" ! 1505: remember to call ptr_init to ensure that pointers to second bases ! 1506: are handled correctly. ! 1507: */ ! 1508: { ! 1509: register Ptype it = init->tp; ! 1510: Pptr px = p; ! 1511: while (px->base == TYPE) px = Pptr(Pbase(px)->b_name->tp); ! 1512: Ptype p1 = px->typ; ! 1513: Pname c1 = p1->is_cl_obj(); ! 1514: //error('d',"ref_init: p %t, p1 %t, px %t, init->tp %t",p,p1,px,it); ! 1515: ! 1516: if (init->base == ILIST) error("IrL as RIr"); ! 1517: ! 1518: if (init->base==NAME ! 1519: && Pname(init)->n_scope==ARG ! 1520: && init->tp->base==FLOAT) ! 1521: error('w',"initializing a float& with floatA is non-portable"); ! 1522: ! 1523: rloop: ! 1524: switch (it->base) { ! 1525: case TYPE: ! 1526: it = Pbase(it)->b_name->tp; goto rloop; ! 1527: default: ! 1528: { Ptype tt = it->addrof(); ! 1529: px->base = PTR; // allow &x for y& when y : public x ! 1530: // but not &char for int& ! 1531: int x = px->check(tt,COERCE); ! 1532: ! 1533: if (x == 0) { //CCC type is fine check for constness: ! 1534: if (init->tp->tconst() ! 1535: && vec_const==0 ! 1536: && fct_const==0) { ! 1537: // not ``it'' ! 1538: if (init->base == ELIST) init = init->e1; ! 1539: if (px->typ->tconst() == 0) error("R to constO"); ! 1540: px->base = RPTR; ! 1541: // if we have a const lvalue we can still pass its address ! 1542: extern ignore_const; ! 1543: ignore_const++; ! 1544: if (init->lval(0)) { ! 1545: init->lval(ADDROF); // force output ! 1546: ignore_const--; ! 1547: //error('d',"in1 %t",init->tp); ! 1548: return ptr_init(px,init->address(),tbl);//return init->address(); ! 1549: } ! 1550: ignore_const--; ! 1551: goto xxx; ! 1552: } ! 1553: px->base = RPTR; ! 1554: if (init->lval(0)) { // can pass the address // no temporary needed ! 1555: init->lval(ADDROF); // force output ! 1556: //error('d',"px %t init %t init %t",px,init->tp,init->tp); ! 1557: return ptr_init(px,init->address(),tbl); ! 1558: } ! 1559: goto xxx; ! 1560: } ! 1561: ! 1562: px->base = RPTR; ! 1563: } ! 1564: } ! 1565: ! 1566: //error('d',"c1 %n",c1); ! 1567: if (c1) { // assigning to a const X & is fine ! 1568: ref_cast++; ! 1569: Pexpr x = try_to_coerce(p,init,"reference initialization",tbl); ! 1570: ref_cast--; ! 1571: if (x) { ! 1572: init = x; ! 1573: goto xxx; ! 1574: } ! 1575: while (p1->base==TYPE) p1 = Pbase(p1)->b_name->tp; ! 1576: int bc = Pbase(p1)->b_const; ! 1577: Pbase(p1)->b_const = 0; ! 1578: refd = 1; /* disable itor */ ! 1579: Pexpr a = class_init(0,p1,init,tbl); ! 1580: Pbase(p1)->b_const = bc; ! 1581: refd = 0; ! 1582: if (a==init && init->tp!=any_type) goto xxx; ! 1583: //error('d',"ri a %d %k",a->base,a->base); ! 1584: switch (a->base) { ! 1585: case G_CALL: ! 1586: // case CM: ! 1587: // case G_CM: ! 1588: init = a; ! 1589: goto xxx; ! 1590: } ! 1591: a = a->address(); ! 1592: //error('d',"ri2 a %d %k",a->base,a->base); ! 1593: a = ptr_init(px,a,tbl); ! 1594: //error('d',"ri3 a %d %k",a->base,a->base); ! 1595: return a; ! 1596: // return ptr_init(px,a->address(),tbl);//a->address(); ! 1597: } ! 1598: ! 1599: //error('d',"p1 %t it %t",p1,it); ! 1600: if (p1->check(it,0)) { ! 1601: ! 1602: if (p1->check(it,ASSIGN) == 0) { ! 1603: // if (p1->is_ptr()) // check for base* = derived* ! 1604: // goto xxx; ! 1605: ! 1606: // things like ``double& rr = 1;'' temporary needed ! 1607: // warn in case of ``slightly wrong lvalue'', e.g. ! 1608: // int i; double& r = i; ! 1609: if (init->lval(0) && p1->tconst()==0) error('w',"conversion of lvalue needed: temporary used toI reference"); ! 1610: goto def; ! 1611: } ! 1612: ! 1613: Pexpr x = try_to_coerce(p1,init,"reference",tbl); // x==init ! 1614: if (x==0) x = try_to_coerce(px,init,"reference",tbl); // x&=init ! 1615: if (x) { ! 1616: init = x; ! 1617: goto def; ! 1618: } ! 1619: ! 1620: error("badIrT:%t (%tX)",it,p); ! 1621: if (init->base != NAME) init->tp = any_type; ! 1622: return init; ! 1623: } ! 1624: ! 1625: xxx: /* ! 1626: here comes the test of a ``fundamental theorem'': ! 1627: a structure valued expression is ! 1628: (1) an lvalue of type T (possibly const) ! 1629: or (2) the result of a function (a _result if X(X&) is defined) ! 1630: or (3) a * or [] or ? or , expression ! 1631: */ ! 1632: //error('d',"xxx %k %d %t",init->base,init->base,init->tp); ! 1633: ! 1634: switch (init->base) { ! 1635: case NAME: ! 1636: case DEREF: ! 1637: case REF: ! 1638: case DOT: // init => &init ! 1639: if (it->tconst() && vec_const==0 && fct_const==0) goto def; ! 1640: init->lval(ADDROF); ! 1641: if (vec_const) return init; ! 1642: if (fct_const && p1->is_ptr()) goto def; // fptr& = fct ! 1643: // no break ! 1644: case CM: ! 1645: case G_CM: // & (f(&temp), temp) ! 1646: return ptr_init(px,init->address(),tbl);//init->address(); ! 1647: default: ! 1648: def: ! 1649: { ! 1650: //error('d',"def: init->tp %t p1 %t",init->tp,p1); ! 1651: if (tbl == gtbl) error("Ir for staticR not an lvalue"); ! 1652: Pname n = make_tmp('I',p1,tbl); ! 1653: Pexpr a; ! 1654: Pname ic = init->tp->is_cl_obj(); ! 1655: ! 1656: if (p1->tconst()==0 ! 1657: && (init->tp->tconst() && vec_const==0 && fct_const==0) ! 1658: && p1->check(it,ASSIGN)==0) ! 1659: error('w',"constIr: temporary used toI reference"); ! 1660: ! 1661: switch (p1->base) { ! 1662: case INT: ! 1663: case CHAR: ! 1664: case SHORT: ! 1665: switch (it->base) { ! 1666: case LONG: ! 1667: case FLOAT: ! 1668: case DOUBLE: ! 1669: case LDOUBLE: ! 1670: error('w',"%t assigned to %t inRIr",it,p1); ! 1671: } ! 1672: } ! 1673: ! 1674: if (ic!=c1 && Pclass(ic->tp) != Pclass(c1->tp)) { ! 1675: // derived class1 => must cast: ``it Ix; (Ix=init,(p)&Ix);'' ! 1676: n->tp = init->tp; ! 1677: a = ptr_init(px,n->address(),tbl);//n->address(); ! 1678: PERM(p); ! 1679: a = new texpr(CAST,p,a); ! 1680: a->tp = p; ! 1681: } ! 1682: else ! 1683: a = n->address(); ! 1684: ! 1685: refd = 1; ! 1686: Pexpr as = init_tmp(n,init,tbl); ! 1687: refd = 0; ! 1688: a = new expr(G_CM,as,a); ! 1689: a->tp = a->e2->tp; ! 1690: return a; ! 1691: } ! 1692: } ! 1693: } ! 1694: ! 1695: Pexpr class_init(Pexpr nn, Ptype tt, Pexpr init, Ptable tbl) ! 1696: /* ! 1697: initialize "nn" of type "tt" with "init" ! 1698: if nn==0 make a temporary, ! 1699: nn may not be a name ! 1700: */ ! 1701: { ! 1702: if (init == dummy) return 0; ! 1703: //error('d',"class_init %t with %t init %k refd %d",tt,init->tp,init->base,refd); ! 1704: Pname c1 = tt->is_cl_obj(); ! 1705: ! 1706: if (init == 0) { ! 1707: error("emptyIr"); ! 1708: return dummy; ! 1709: } ! 1710: ! 1711: if (c1) { ! 1712: Pclass cl = Pclass(c1->tp); ! 1713: Pname c2 = init->tp->is_cl_obj(); ! 1714: ! 1715: if (c1!=c2 || (refd==0 && cl->has_itor())) { ! 1716: /* really ought to make a temp if refd, ! 1717: but ref_init can do that ! 1718: */ ! 1719: int i = can_coerce(tt,init->tp); ! 1720: //error('d',"i %d nn %n",i,nn); ! 1721: switch (i) { ! 1722: default: ! 1723: error("%d ways of making a%n from a%t",i,c1,init->tp); ! 1724: init->tp = any_type; ! 1725: return init; ! 1726: case 0: ! 1727: if (c2 && Pclass(c2->tp)->has_base(cl)) { ! 1728: init = init->address(); ! 1729: Pexpr x = cast_cptr(cl,init,tbl,0); ! 1730: ! 1731: if (x == init) { ! 1732: Ptype pt = tt->addrof(); ! 1733: PERM(pt); ! 1734: x = new cast(pt,init); ! 1735: } ! 1736: ! 1737: return x->contents(); ! 1738: } ! 1739: error("cannot make a%n from a%t",c1,init->tp); ! 1740: init->tp = any_type; ! 1741: return init; ! 1742: case 1: ! 1743: //error('d',"ncoerce %n %k %d",Ncoerce,init->base,init->base); ! 1744: if (Ncoerce == 0) { ! 1745: Pexpr a = new expr(ELIST,init,0); ! 1746: a = new texpr(VALUE,tt,a); ! 1747: a->e2 = nn; ! 1748: // return a->typ(tbl); ! 1749: a = a->typ(tbl); ! 1750: //error('d',"ci a %k %d %t",a->base,a->base,a->tp); ! 1751: return a; ! 1752: } ! 1753: ! 1754: switch (init->base) { ! 1755: case CM: ! 1756: case G_CM: //ddd ! 1757: case NAME: /* init.coerce() */ ! 1758: /* *ref */ case DEREF: ! 1759: { Pref r = new ref(DOT,init,Ncoerce); ! 1760: Pexpr rr = r->typ(tbl); ! 1761: init = new expr(G_CALL,rr,0); ! 1762: init->fct_name = Ncoerce; ! 1763: break; ! 1764: } ! 1765: default: // (temp=init,temp.coerce()) ! 1766: { Pname tmp = make_tmp('U',init->tp,tbl); ! 1767: int x = refd; ! 1768: refd = 0; // ?? ! 1769: Pexpr ass = init_tmp(tmp,init,tbl); ! 1770: refd = x; ! 1771: Pref r = new ref(DOT,tmp,Ncoerce); ! 1772: Pexpr rr = r->typ(tbl); ! 1773: Pexpr c = new expr(G_CALL,rr,0); ! 1774: c->fct_name = Ncoerce; ! 1775: c = c->typ(tbl); ! 1776: init = new expr(CM,ass,c); ! 1777: init->tp = c->tp; ! 1778: if (refd) { // &f() => (t=f(), &t) ! 1779: Pname tmp2 = make_tmp('L',c->tp,tbl); ! 1780: ass = init_tmp(tmp2,init,tbl); ! 1781: init = new expr(G_CM,ass,tmp2); ! 1782: } ! 1783: } ! 1784: } ! 1785: //error('d',"nn %n",nn); ! 1786: if (nn) { ! 1787: Pexpr a = new expr(ELIST,init,0); ! 1788: a = new texpr(VALUE,tt,a); ! 1789: a->e2 = nn; ! 1790: return a->typ(tbl); ! 1791: } ! 1792: } ! 1793: //error('d',"c1 %n c2 %n",c1,c2); ! 1794: return init->typ(tbl); ! 1795: } ! 1796: return init; ! 1797: } ! 1798: //error('d',"ci check tt %t init->tp %t",tt,init->tp); ! 1799: if (tt->check(init->tp,ASSIGN) && refd==0) { ! 1800: error("badIrT:%t (%tX)",init->tp,tt); ! 1801: init->tp = any_type; ! 1802: } ! 1803: ! 1804: return init; ! 1805: } ! 1806: ! 1807: extern int bound; // fudge for bound pointers to functions ! 1808: ! 1809: Pexpr expr::docast(Ptable tbl) ! 1810: { ! 1811: // check cast against value, INCOMPLETE ! 1812: ! 1813: //error('d',"docast %d %t %k",this,tp2,e1->base); ! 1814: if (e1 == dummy) { ! 1815: error("E missing for cast"); ! 1816: tp = any_type; ! 1817: return this; ! 1818: } ! 1819: ! 1820: int pmf = 0; ! 1821: int ptom_cast = 0; ! 1822: Pexpr ee = e1; ! 1823: ! 1824: //error('d',"ee %k %d",ee->base,ee->base); ! 1825: switch (ee->base) { ! 1826: case ADDROF: ! 1827: ee = ee->e2; ! 1828: switch (ee->base) { ! 1829: case NAME: goto nm; ! 1830: case REF: goto rf; ! 1831: } ! 1832: break; ! 1833: ! 1834: case NAME: ! 1835: nm: ! 1836: if (Pname(ee)->n_qualifier) pmf = 1; ! 1837: break; ! 1838: ! 1839: case REF: ! 1840: rf: ! 1841: if (ee->e1->base == THIS) bound = 1; ! 1842: break; ! 1843: } ! 1844: ! 1845: e1 = e1->typ(tbl); ! 1846: ! 1847: int b = bound; // distinguish between explicit and implicit THIS ! 1848: bound = 0; ! 1849: pmf = pmf && e1->base==CAST; ! 1850: ! 1851: Ptype etp = e1->tp; ! 1852: Ptype tt = tp2; ! 1853: Ptype t = tt; ! 1854: tt->dcl(tbl); ! 1855: ! 1856: while (etp->base == TYPE) etp = Pbase(etp)->b_name->tp; ! 1857: while (tt->base == TYPE) tt = Pbase(tt)->b_name->tp; ! 1858: ! 1859: //error('d',"e1 %k etp %t tt %t",e1->base,etp,tt); ! 1860: ! 1861: switch (etp->base) { ! 1862: case PTR: ! 1863: case RPTR: ! 1864: if (Pptr(etp)->typ->base == OVERLOAD) goto over; ! 1865: ! 1866: if (warning_opt && i2==0 && Pptr(etp)->typ->tconst()) { ! 1867: switch (tt->base) { ! 1868: case FCT: ! 1869: break; ! 1870: case PTR: ! 1871: case RPTR: ! 1872: if (Pptr(tt)->typ->tconst()) break; ! 1873: default: ! 1874: // casting away const ! 1875: // should be an error ! 1876: // but ANSI says OK so I chicken out ! 1877: // to be able to compile strtok(), etc. ! 1878: error('w',"const cast away:%t->%t",e1->tp,tp2); ! 1879: } ! 1880: } ! 1881: else ! 1882: i2 = 0; // to allow cfront to escape its own checking ! 1883: break; ! 1884: case COBJ: ! 1885: { ref_cast = 1; ! 1886: Pexpr x = try_to_coerce(tt,e1,"cast",tbl); ! 1887: ref_cast = 0; ! 1888: //error('d',"x %k %t tt %d %t",x?x->base:0,x?x->tp:0,tt,tt); ! 1889: if (x) { ! 1890: if (x!=e1 && x->base==DEREF && tt->is_ref()) x = x->e1; ! 1891: if (tt==x->tp || tt->check(x->tp,0)==0 || const_problem) ! 1892: return x; ! 1893: else ! 1894: return new cast(tt,x); ! 1895: } ! 1896: // else if (e1->base==DEREF && tt->is_ref()) return e1; ! 1897: break; ! 1898: } ! 1899: case VOID: ! 1900: if (tt->base == VOID) { ! 1901: tp = t; ! 1902: return this; ! 1903: } ! 1904: error("cast of void value"); ! 1905: // no break; ! 1906: case ANY: ! 1907: any: ! 1908: tp = any_type; ! 1909: return this; ! 1910: case FCT: ! 1911: if (tt->base == PTR && Pptr(tt)->typ->base != FCT) ! 1912: error('w',"P toF cast toP to nonF"); ! 1913: break; ! 1914: case OVERLOAD: ! 1915: over: ! 1916: error("cast of overloaded"); ! 1917: goto any; ! 1918: } ! 1919: ! 1920: //error('d',"tt %t",tt); ! 1921: switch (tt->base) { ! 1922: case PTR: ! 1923: if (Pptr(tt)->typ->base==FCT && Pptr(tt)->memof) { ! 1924: if (etp->base!=PTR ! 1925: || Pptr(etp)->typ->base!=FCT ! 1926: || Pptr(etp)->memof==0) ! 1927: error("cast toP toM %t",tt); ! 1928: else { // adjust delta in MI case ! 1929: // for the moment just suppress the cast ! 1930: // all pmfs are the same to cc ! 1931: /* ! 1932: Pclass c1 = Pptr(tt)->memof; ! 1933: Pclass c2 = Pptr(etp)->memof; ! 1934: */ ! 1935: ptom_cast = 1; ! 1936: tp2 = void_type; ! 1937: } ! 1938: } ! 1939: ! 1940: switch (etp->base) { ! 1941: case COBJ: ! 1942: error("cannot castCO toP"); ! 1943: break; ! 1944: case FCT: ! 1945: e1 = new expr(G_ADDROF,0,e1); ! 1946: bound = b; ! 1947: e1 = e1->typ(tbl); ! 1948: bound = 0; ! 1949: if (e1->base == CAST) ! 1950: pmf = 1; ! 1951: else ! 1952: break; ! 1953: // no break; ! 1954: ! 1955: case PTR: ! 1956: { Pname cn = Pptr(tt)->typ->is_cl_obj(); ! 1957: if (cn) { ! 1958: Pexpr x = cast_cptr(Pclass(cn->tp),e1,tbl,1); ! 1959: ! 1960: if (x == e1) { ! 1961: PERM(tt); ! 1962: e1 = new cast(tt,e1); ! 1963: e1->i2 = i2; ! 1964: } ! 1965: else ! 1966: e1 = x; ! 1967: } ! 1968: if (pmf) { ! 1969: zaqq: ! 1970: switch (tt->base) { ! 1971: case TYPE: ! 1972: tt = Pbase(tt)->b_name->tp; goto zaqq; ! 1973: case PTR: ! 1974: if (Pptr(tt)->memof) break; ! 1975: default: ! 1976: error("%t cast to%t (%t is not aP toM)",e1->tp,tp2,tp2); ! 1977: } ! 1978: } ! 1979: } ! 1980: } ! 1981: break; ! 1982: ! 1983: case RPTR: // (x&)e: pretend e is an x ! 1984: { Ptype er = etp; ! 1985: Ptype cr = tt; ! 1986: do { ! 1987: if (er = er->is_ptr_or_ref()) er = Pptr(er)->typ; ! 1988: if (cr = cr->is_ptr_or_ref()) cr = Pptr(cr)->typ; ! 1989: } while (er && cr); ! 1990: int pp = er!=0; // if `e' is a suitable pointer cast it: ! 1991: // (x&)e => (x*)e, otherwise ! 1992: // (x&)e => *(x*)&e ! 1993: //error('d',"rptr tt %t e1->base %k e1->tp %t",tt,e1->base,e1->tp); ! 1994: // if (Pptr(tt)->typ->tsizeof()>etp->tsizeof()) goto zse; ! 1995: // we need to be able to ``raise the type'' from base to derived ! 1996: // if (etp->is_cl_obj() && Pptr(tt)->typ->is_cl_obj()==0) goto zse; ! 1997: ! 1998: if (e1->base==G_CM ! 1999: || e1->base==CALL ! 2000: || e1->base==G_CALL ! 2001: || e1->lval(0)) ! 2002: ; ! 2003: else if (e1->tp->tconst()) { ! 2004: // casting away const ! 2005: // should be an error ! 2006: // but ANSI says OK so I chicken out ! 2007: // to be able to compile strtok(), etc. ! 2008: if (warning_opt && Pptr(tt)->typ->tconst()==0) ! 2009: error('w',"const cast away:%t->%t",e1->tp,tp2); ! 2010: ! 2011: } ! 2012: else ! 2013: error("cannot cast%t to%t",etp,t); ! 2014: //error('d',"e1 %k %t %d",e1->base,e1->tp,pp); ! 2015: if (pp == 0) e1 = e1->address(); // *(x*)&e ! 2016: tp = t; ! 2017: ! 2018: // do proper pointer manipulation for multiple inheritance ! 2019: Pname cn = Pptr(tt)->typ->is_cl_obj(); ! 2020: if (cn) { ! 2021: Pexpr x = cast_cptr(Pclass(cn->tp),e1,tbl,1); ! 2022: ! 2023: if (x == e1) { ! 2024: PERM(tt); ! 2025: e1 = new cast(tt,e1); ! 2026: e1->i2 = i2; ! 2027: } ! 2028: else ! 2029: e1 = x; ! 2030: } ! 2031: ! 2032: return pp ? this : contents(); ! 2033: // zse: ! 2034: // error("cannot cast%t to%t",etp,t); ! 2035: // tp2 = tt = any_type; ! 2036: // break; ! 2037: } ! 2038: case COBJ: ! 2039: base = VALUE; // (x)e => x(e): construct an x from e ! 2040: e1 = new expr(ELIST,e1,0); ! 2041: return typ(tbl); ! 2042: ! 2043: case CHAR: ! 2044: case INT: ! 2045: case SHORT: ! 2046: case LONG: ! 2047: case FLOAT: ! 2048: case DOUBLE: ! 2049: case LDOUBLE: ! 2050: switch (etp->base) { ! 2051: case FCT: ! 2052: e1 = new expr(ADDROF,0,e1); ! 2053: e1 = e1->typ(tbl); ! 2054: break; ! 2055: case COBJ: ! 2056: error("cannot castCO to%k",tt->base); ! 2057: break; ! 2058: } ! 2059: break; ! 2060: } ! 2061: ! 2062: tp = t; ! 2063: ! 2064: if (e1->base==ILIST && ptom_cast==0) { // pointer to member constant ! 2065: Pexpr ee = e1->e1; // ELIST ! 2066: int i; ! 2067: switch (ee->e2->base) { ! 2068: case IVAL: ! 2069: i = int(ee->e2->i1); ! 2070: break; ! 2071: case ZERO: ! 2072: i = 0; ! 2073: } ! 2074: ! 2075: if (i<0) ! 2076: e1 = e1->e2; // just the function ! 2077: else ! 2078: e1 = ee->e2; // just the index ! 2079: return this; ! 2080: } ! 2081: ! 2082: if (etp->base==PTR && Pptr(etp)->memof && Pptr(etp)->typ->base==FCT) { ! 2083: Pclass cl = Pptr(etp)->memof; ! 2084: ! 2085: if (Pptr(tt)->memof==0 && b == 0 ) { ! 2086: Pexpr y = new mdot("f",e1); ! 2087: y->i1 = 9; ! 2088: y = new cast(tt,y); ! 2089: if (cl->virt_count && b==0) { ! 2090: // ERROR: no check for side effects ! 2091: Pexpr z = new mdot("i",e1); ! 2092: Pexpr x = new mdot("i",e1); ! 2093: x->i1 = 9; ! 2094: x = new cast(tt,x); ! 2095: z->i1 = 9; ! 2096: Pexpr q = new expr (QUEST,x,y); ! 2097: q->cond = new expr(LE,zero,z); ! 2098: q->tp = tt; ! 2099: delete this; ! 2100: return q; ! 2101: } ! 2102: delete this; ! 2103: return y; ! 2104: } ! 2105: } ! 2106: ! 2107: return this; ! 2108: } ! 2109: ! 2110: Pexpr expr::dovalue(Ptable tbl) ! 2111: { ! 2112: Ptype tt = tp2; ! 2113: Pclass cl; ! 2114: Pname cn; ! 2115: ! 2116: //error('d',"value %d %t e1 %d e2 %d",tt,tt,e1,e2); ! 2117: ! 2118: tt->dcl(tbl); ! 2119: vv: ! 2120: switch (tt->base) { ! 2121: case TYPE: ! 2122: tt = Pbase(tt)->b_name->tp; ! 2123: goto vv; ! 2124: ! 2125: case EOBJ: ! 2126: default: ! 2127: if (e1 == 0) { ! 2128: error("value missing in conversion to%t",tt); ! 2129: return dummy; ! 2130: } ! 2131: base = CAST; ! 2132: e1 = e1->e1; // strip ELIST ! 2133: return typ(tbl); ! 2134: ! 2135: case CLASS: ! 2136: cl = Pclass(tt); ! 2137: tp2 = Pptr(cl->this_type)->typ; ! 2138: break; ! 2139: ! 2140: case COBJ: ! 2141: cn = Pbase(tt)->b_name; ! 2142: cl = Pclass(cn->tp); ! 2143: } ! 2144: ! 2145: //error('d',"e1 %k e1->e2 %k",e1->base,e1?e1->e2->base:0); ! 2146: if (e1 && e1->e2==0) { // single argument ! 2147: if (e1->e1->base==ELIST) e1->e1 = e1->e1->e1; // spurious elist ! 2148: e1->e1 = e1->e1->typ(tbl); ! 2149: if (tt->base==COBJ) { ! 2150: Pexpr x = try_to_coerce(tt,e1->e1,"type conversion",tbl); ! 2151: if (x) return x; ! 2152: } ! 2153: ! 2154: Pname acn = e1->e1->tp->is_cl_obj(); ! 2155: //error('d',"acn %n %d",acn,cl->has_itor()); ! 2156: if (acn && cl->has_itor()==0) { ! 2157: Pclass acl = Pclass(acn->tp); ! 2158: int hb = acl->has_base(cl); ! 2159: ! 2160: if (acl==cl || hb) { ! 2161: vcllist->clear(); ! 2162: vcllist=0; ! 2163: if (1<is_unique_base(acl,cl->string,0)) error("ambiguous assignment to base %t",cl); ! 2164: Pexpr ee = e1->e1; ! 2165: if (ee->base == ELIST) ee = ee->e1; // ??? ! 2166: if (hb) { // ee => *(tp2*)&ee ! 2167: // remember = may be overloaded ! 2168: //error('d',"hb %k %t %d",ee->base,ee->tp,ee->lval(0)); ! 2169: if (ee->lval(0)==0) { ! 2170: Pname tmp = make_tmp('T',ee->tp,tbl); ! 2171: ee = init_tmp(tmp,ee,tbl); ! 2172: ee = new expr(G_CM,ee,tmp->address()); ! 2173: } ! 2174: else ! 2175: ee = ee->address(); ! 2176: ee = new texpr(CAST,new ptr(PTR,tp2),ee); //new cast(new ptr(PTR,tp2),ee); ! 2177: ee = ee->contents(); ! 2178: ee->typ(tbl); ! 2179: } ! 2180: ! 2181: if (e2) { // x(x_obj) => e2=x_obj ! 2182: base = ASSIGN; ! 2183: e1 = e2; ! 2184: e2 = ee; ! 2185: tp = tp2; ! 2186: return this; ! 2187: } ! 2188: return ee; // strip ELIST: x(x_obj) => x_obj ! 2189: } ! 2190: } ! 2191: } ! 2192: ! 2193: ! 2194: /* x(a) => obj.ctor(a); where e1==obj */ ! 2195: Pname ctor = cl->has_ctor(); ! 2196: if (ctor == 0) { ! 2197: error("cannot make a%t",cl); ! 2198: return dummy; ! 2199: } ! 2200: ! 2201: //error('d',"e2 %k",e2?e2->base:0); ! 2202: if (e2 == 0) { // x(a) => x temp; (temp.x(a),temp) ! 2203: Pname n = make_tmp('V',tp2,tbl); ! 2204: n->assign(); ! 2205: if (tbl == gtbl) n->dcl_print(0); // a hack ! 2206: Pexpr c = call_ctor(tbl,n,ctor,e1,DOT); ! 2207: c = new expr(G_CM,c,n); ! 2208: c->tp = n->tp; ! 2209: //error('d',"tp1 %t",c->tp); ! 2210: return c; ! 2211: } ! 2212: else { ! 2213: Pexpr c = call_ctor(tbl,e2,ctor,e1,DOT); ! 2214: c = new expr(DEREF,c,0); // deref value returned by constructor ! 2215: c->tp = c->e1->tp; ! 2216: //error('d',"tp2 %t",c->tp); ! 2217: return c; ! 2218: } ! 2219: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.