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