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