![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to expr3.hmm CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront / ooptcfront|
Return to expr3.hmm CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / ooptcfront |
1.1 ! root 1: *** /tmp/,RCSt1a12477 Tue Nov 7 09:42:18 1989 ! 2: --- /tmp/,RCSt2a12477 Tue Nov 7 09:42:22 1989 ! 3: *************** ! 4: *** 2,8 **** ! 5: /*ident "@(#)ctrans:src/expr3.c 1.3.5.29" */ ! 6: /* ! 7: $Source: /usr3/lang/benson/work/stripped_cfront/O/RCS/expr3.c,v $ $RCSfile: expr3.c,v $ ! 8: ! $Revision: 1.8 $ $Date: 89/10/16 08:15:27 $ ! 9: $Author: benson $ $Locker: $ ! 10: $State: Exp $ ! 11: */ ! 12: --- 2,8 ---- ! 13: /*ident "@(#)ctrans:src/expr3.c 1.3.5.29" */ ! 14: /* ! 15: $Source: /usr3/lang/benson/work/stripped_cfront/O/RCS/expr3.c,v $ $RCSfile: expr3.c,v $ ! 16: ! $Revision: 1.9 $ $Date: 89/10/20 14:30:34 $ ! 17: $Author: benson $ $Locker: $ ! 18: $State: Exp $ ! 19: */ ! 20: *************** ! 21: *** 24,29 **** ! 22: --- 24,30 ---- ! 23: ! 24: #include "cfront.h" ! 25: #include "size.h" ! 26: + #include "extended_error.h" ! 27: ! 28: int pr_dominate(Ptype t1, Ptype t2) ! 29: /* ! 30: *************** ! 31: *** 246,252 **** ! 32: ! 33: Pname Ntmp; ! 34: ! 35: ! static refd; // initialization routine called by ref_init, do not apply itor ! 36: extern loc no_where; ! 37: ! 38: Pname make_tmp(char c, Ptype t, Ptable tbl) ! 39: --- 247,253 ---- ! 40: ! 41: Pname Ntmp; ! 42: ! 43: ! int refd; // initialization routine called by ref_init, do not apply itor ! 44: extern loc no_where; ! 45: ! 46: Pname make_tmp(char c, Ptype t, Ptable tbl) ! 47: *************** ! 48: *** 889,900 **** ! 49: ! 50: } ! 51: ! 52: - extern int type_indexable (Ptype, int); ! 53: extern Pname indexable_member_reference (Pexpr, int); ! 54: ! 55: void const_err (Ptype t, Pexpr ob, Pname fn) ! 56: { ! 57: ! int tpindexable = type_indexable(t, 1); ! 58: int topindex = (indexable_member_reference(ob, 0) != 0); ! 59: if(!tpindexable) ! 60: error(strict_opt?0:'w',"non-constMF%n called for constO",fn); ! 61: --- 890,901 ---- ! 62: ! 63: } ! 64: ! 65: extern Pname indexable_member_reference (Pexpr, int); ! 66: ! 67: void const_err (Ptype t, Pexpr ob, Pname fn) ! 68: { ! 69: ! int tpindexable = t->tconst(const_idx) && !t->tconst(const_not_idx); ! 70: ! ! 71: int topindex = (indexable_member_reference(ob, 0) != 0); ! 72: if(!tpindexable) ! 73: error(strict_opt?0:'w',"non-constMF%n called for constO",fn); ! 74: *************** ! 75: *** 911,917 **** ! 76: --- 912,983 ---- ! 77: } ! 78: ! 79: ! 80: + class call_fct_eei { ! 81: + public: ! 82: + int valid; /* not on until we are processing some argument or another */ ! 83: + Pname fname; ! 84: + Pname cur_formal; ! 85: + Pexpr cur_actual; ! 86: + int argx; ! 87: + call_fct_eei () { ! 88: + valid = 0; ! 89: + argx = 0; ! 90: + fname = 0; ! 91: + cur_formal = 0; ! 92: + cur_actual = 0; ! 93: + }; ! 94: + }; ! 95: + ! 96: + int unprintable_expression_p (Pexpr e); ! 97: + char * print_expression (Pexpr e, int flags, int& err); ! 98: + ! 99: + void call_fct_extended_error (void * info, FILE * of) ! 100: + { ! 101: + call_fct_eei& cfe = *(call_fct_eei *) info; ! 102: + ! 103: + if(!cfe.valid) return; ! 104: + if(cfe.fname) fprintf(of, "Calling %s; ", err::name_string (cfe.fname)); ! 105: + if(cfe.cur_actual) { ! 106: + int perr = 0; ! 107: + char * msg; ! 108: + if(!unprintable_expression_p(cfe.cur_actual)) ! 109: + msg = print_expression (cfe.cur_actual, 0, perr); ! 110: + else perr = 1; ! 111: + if(perr) ! 112: + fprintf(of, "Passing an expression "); ! 113: + else fprintf(of, "Passing %s ", msg); ! 114: + if(msg) free (msg); ! 115: + } ! 116: + if(cfe.cur_formal) { ! 117: + if(cfe.cur_formal->string) ! 118: + fprintf(of, "to %s ", err::name_string(cfe.cur_formal)); ! 119: + else fprintf(of, "to type %s ", err::type_string(cfe.cur_formal->tp)); ! 120: + } ! 121: + fprintf(of, "\n"); ! 122: + } ! 123: + ! 124: + class call_fct_undo : public basic_undo { ! 125: + public: ! 126: + extended_error_state * ees; ! 127: + call_fct_eei cfei; ! 128: + call_fct_undo () { ! 129: + ees = extended_error_state::push (call_fct_extended_error, (void *) &cfei); ! 130: + }; ! 131: + virtual ~call_fct_undo () { ! 132: + extended_error_state::pop (); ! 133: + }; ! 134: + }; ! 135: + ! 136: + ! 137: Ptype expr::call_fct(Ptable tbl) ! 138: + { ! 139: + call_fct_undo Undo; ! 140: + ! 141: + return call_fct0(tbl, (void *)&Undo.cfei); ! 142: + } ! 143: + ! 144: + ! 145: + Ptype expr::call_fct0(Ptable tbl, void * eei) ! 146: /* ! 147: check "this" call: ! 148: e1(e2) ! 149: *************** ! 150: *** 935,940 **** ! 151: --- 1001,1008 ---- ! 152: // found without use of find_name() ! 153: int const_obj = 0; ! 154: ! 155: + call_fct_eei& cfei = *(call_fct_eei*)eei; ! 156: + ! 157: if (t1 == any_type) return any_type; ! 158: ! 159: switch (base) { ! 160: *************** ! 161: *** 1304,1316 **** ! 162: --- 1372,1393 ---- ! 163: e = arg; ! 164: if (k == 0) goto rlab; ! 165: ! 166: + if(fct_name && fct_name->base == NAME) ! 167: + cfei.fname = fct_name; ! 168: + ! 169: for (nn=f->argtype, argno=1; e||nn; nn=nn->n_list, e=etail->e2, argno++) { ! 170: Pexpr a; ! 171: ! 172: + cfei.valid = 1; ! 173: + cfei.argx = argno; ! 174: + cfei.cur_formal = nn; ! 175: + ! 176: if (e) { ! 177: a = e->e1; ! 178: etail = e; ! 179: ! 180: + cfei.cur_actual = a; ! 181: + ! 182: if (nn) { /* type check */ ! 183: Ptype t1 = nn->tp; ! 184: //error('d',"argtp %t etp %t a %k",t1,a->tp,a->base); ! 185: *************** ! 186: *** 1538,1546 **** ! 187: are handled correctly. ! 188: */ ! 189: { ! 190: ! register Ptype it = init->tp; ! 191: ! Pptr px = p; ! 192: ! while (px->base == TYPE) px = Pptr(Pbase(px)->b_name->tp); ! 193: Ptype p1 = px->typ; ! 194: Pname c1 = p1->is_cl_obj(); ! 195: //error('d',"ref_init: p %t, p1 %t, px %t, init->tp %t",p,p1,px,it); ! 196: --- 1615,1626 ---- ! 197: are handled correctly. ! 198: */ ! 199: { ! 200: ! /* p, the reference, has to to of a type reference-to-something. ! 201: ! consts of the form K & const are ignored for this purpose ! 202: ! while K const & aren't. this is ok, they don't mean anything. ! 203: ! Note that K & volatile and such are also ignored. --benson */ ! 204: ! ! 205: ! Pptr px = Pptr(Ptype(p)->underlying_type()); ! 206: Ptype p1 = px->typ; ! 207: Pname c1 = p1->is_cl_obj(); ! 208: //error('d',"ref_init: p %t, p1 %t, px %t, init->tp %t",p,p1,px,it); ! 209: *************** ! 210: *** 1552,1566 **** ! 211: && init->tp->base==FLOAT) ! 212: error('w',"initializing a float& with floatA is non-portable"); ! 213: ! 214: ! rloop: ! 215: ! switch (it->base) { ! 216: ! case TYPE: ! 217: ! it = Pbase(it)->b_name->tp; goto rloop; ! 218: ! default: ! 219: ! { Ptype tt = it->addrof(); ! 220: px->base = PTR; // allow &x for y& when y : public x ! 221: // but not &char for int& ! 222: int x = px->check(tt,COERCE); ! 223: ! 224: if (x == 0) { //CCC type is fine check for constness: ! 225: if (init->tp->tconst() ! 226: --- 1632,1642 ---- ! 227: && init->tp->base==FLOAT) ! 228: error('w',"initializing a float& with floatA is non-portable"); ! 229: ! 230: ! { Ptype tt = init->tp->underlying_type()->addrof(); ! 231: px->base = PTR; // allow &x for y& when y : public x ! 232: // but not &char for int& ! 233: int x = px->check(tt,COERCE); ! 234: + if(const_problem) x = 0; /* we deal with const ourself */ ! 235: ! 236: if (x == 0) { //CCC type is fine check for constness: ! 237: if (init->tp->tconst() ! 238: *************** ! 239: *** 1568,1574 **** ! 240: && fct_const==0) { ! 241: // not ``it'' ! 242: if (init->base == ELIST) init = init->e1; ! 243: ! if (px->typ->tconst() == 0) error("R to constO"); ! 244: px->base = RPTR; ! 245: // if we have a const lvalue we can still pass its address ! 246: extern ignore_const; ! 247: --- 1644,1656 ---- ! 248: && fct_const==0) { ! 249: // not ``it'' ! 250: if (init->base == ELIST) init = init->e1; ! 251: ! if (px->typ->tconst() == 0) { ! 252: ! if(init->tp->tconst (const_idx)) ! 253: ! err::signal(malformed_expr, ! 254: ! "Non-constant reference to indexable object."); ! 255: ! err::signal(malformed_expr, ! 256: ! "Non-constant reference to constant object."); ! 257: ! } ! 258: px->base = RPTR; ! 259: // if we have a const lvalue we can still pass its address ! 260: extern ignore_const; ! 261: *************** ! 262: *** 1580,1585 **** ! 263: --- 1662,1673 ---- ! 264: return ptr_init(px,init->address(),tbl);//return init->address(); ! 265: } ! 266: ignore_const--; ! 267: + /* going to xxx implies that we are going ! 268: + to try to concoct a temp. Not permissible in ! 269: + the indexable case. */ ! 270: + if(init->tp->tconst(const_idx)) ! 271: + err::signal(malformed_expr, ! 272: + "Non-constant reference to indexable object."); ! 273: goto xxx; ! 274: } ! 275: px->base = RPTR; ! 276: *************** ! 277: *** 1593,1599 **** ! 278: ! 279: px->base = RPTR; ! 280: } ! 281: - } ! 282: ! 283: //error('d',"c1 %n",c1); ! 284: if (c1) { // assigning to a const X & is fine ! 285: --- 1681,1686 ---- ! 286: *************** ! 287: *** 1604,1616 **** ! 288: init = x; ! 289: goto xxx; ! 290: } ! 291: ! while (p1->base==TYPE) p1 = Pbase(p1)->b_name->tp; ! 292: ! int bc = Pbase(p1)->b_const; ! 293: ! Pbase(p1)->b_const = 0; ! 294: ! refd = 1; /* disable itor */ ! 295: Pexpr a = class_init(0,p1,init,tbl); ! 296: ! Pbase(p1)->b_const = bc; ! 297: ! refd = 0; ! 298: if (a==init && init->tp!=any_type) goto xxx; ! 299: //error('d',"ri a %d %k",a->base,a->base); ! 300: switch (a->base) { ! 301: --- 1691,1716 ---- ! 302: init = x; ! 303: goto xxx; ! 304: } ! 305: ! /* This stretch of code is pretty surprising. ! 306: ! what about consts on typedefs on p1? ! 307: ! This is trying to turn const off for long enough to run class_init ! 308: ! and then turn it on again. If p1 is a class type, which seems ! 309: ! to be indicated by c1, then the typedefs can "only" carry const ! 310: ! and volatile. Since volatile isn't here yet, this is harmless. --benson */ ! 311: ! ! 312: ! if(Pclass(c1->tp)->c_abstract) ! 313: ! err::signal(malformed_expr, ! 314: ! "A temporary is needed for a parameter, but the argument type is abstract class %s.", ! 315: ! err::type_string(c1->tp)); ! 316: ! ! 317: ! ! 318: ! Ptype p1u = p1->underlying_type (); ! 319: ! int bc = Pbase(p1u)->b_const; ! 320: ! Pbase(p1u)->b_const = 0; ! 321: ! refd ++; /* disable itor */ ! 322: Pexpr a = class_init(0,p1,init,tbl); ! 323: ! Pbase(p1u)->b_const = bc; ! 324: ! refd --; ! 325: if (a==init && init->tp!=any_type) goto xxx; ! 326: //error('d',"ri a %d %k",a->base,a->base); ! 327: switch (a->base) { ! 328: *************** ! 329: *** 1628,1637 **** ! 330: // return ptr_init(px,a->address(),tbl);//a->address(); ! 331: } ! 332: ! 333: ! //error('d',"p1 %t it %t",p1,it); ! 334: ! if (p1->check(it,0)) { ! 335: ! 336: ! if (p1->check(it,ASSIGN) == 0) { ! 337: // if (p1->is_ptr()) // check for base* = derived* ! 338: // goto xxx; ! 339: ! 340: --- 1728,1743 ---- ! 341: // return ptr_init(px,a->address(),tbl);//a->address(); ! 342: } ! 343: ! 344: ! //error('d',"p1 %t it %t",p1,init->tp); ! 345: ! 346: ! /* NOTE: in this region, several uses of "it" were converted to uses ! 347: ! if init->tp rather than to init->tp->underlying_type(). Since ! 348: ! these are type checks, it seems nonsensical to ignore signed/unsigned ! 349: ! and related items. --benson */ ! 350: ! ! 351: ! if (p1->check(init->tp,0)) { ! 352: ! ! 353: ! if (p1->check(init->tp,ASSIGN) == 0) { ! 354: // if (p1->is_ptr()) // check for base* = derived* ! 355: // goto xxx; ! 356: ! 357: *************** ! 358: *** 1649,1655 **** ! 359: goto def; ! 360: } ! 361: ! 362: ! error("badIrT:%t (%tX)",it,p); ! 363: if (init->base != NAME) init->tp = any_type; ! 364: return init; ! 365: } ! 366: --- 1755,1761 ---- ! 367: goto def; ! 368: } ! 369: ! 370: ! error("badIrT:%t (%tX)",init->tp,p); ! 371: if (init->base != NAME) init->tp = any_type; ! 372: return init; ! 373: } ! 374: *************** ! 375: *** 1668,1674 **** ! 376: case DEREF: ! 377: case REF: ! 378: case DOT: // init => &init ! 379: ! if (it->tconst() && vec_const==0 && fct_const==0) goto def; ! 380: init->lval(ADDROF); ! 381: if (vec_const) return init; ! 382: if (fct_const && p1->is_ptr()) goto def; // fptr& = fct ! 383: --- 1774,1780 ---- ! 384: case DEREF: ! 385: case REF: ! 386: case DOT: // init => &init ! 387: ! if (init->tp->tconst() && vec_const==0 && fct_const==0) goto def; ! 388: init->lval(ADDROF); ! 389: if (vec_const) return init; ! 390: if (fct_const && p1->is_ptr()) goto def; // fptr& = fct ! 391: *************** ! 392: *** 1681,1686 **** ! 393: --- 1787,1799 ---- ! 394: { ! 395: //error('d',"def: init->tp %t p1 %t",init->tp,p1); ! 396: if (tbl == gtbl) error("Ir for staticR not an lvalue"); ! 397: + ! 398: + Pname tcl = p1->is_cl_obj (); ! 399: + if(tcl && Pclass(tcl->tp)->c_abstract) ! 400: + err::signal(malformed_expr, ! 401: + "A temporary is needed for a parameter, but the argument type is abstract class %s.", ! 402: + err::type_string(tcl->tp)); ! 403: + ! 404: Pname n = make_tmp('I',p1,tbl); ! 405: Pexpr a; ! 406: Pname ic = init->tp->is_cl_obj(); ! 407: *************** ! 408: *** 1687,1705 **** ! 409: ! 410: if (p1->tconst()==0 ! 411: && (init->tp->tconst() && vec_const==0 && fct_const==0) ! 412: ! && p1->check(it,ASSIGN)==0) ! 413: ! error('w',"constIr: temporary used toI reference"); ! 414: ! ! 415: switch (p1->base) { ! 416: case INT: ! 417: case CHAR: ! 418: case SHORT: ! 419: ! switch (it->base) { ! 420: case LONG: ! 421: case FLOAT: ! 422: case DOUBLE: ! 423: case LDOUBLE: ! 424: ! error('w',"%t assigned to %t inRIr",it,p1); ! 425: } ! 426: } ! 427: ! 428: --- 1800,1821 ---- ! 429: ! 430: if (p1->tconst()==0 ! 431: && (init->tp->tconst() && vec_const==0 && fct_const==0) ! 432: ! && p1->check(init->tp,ASSIGN)==0) { ! 433: ! if(init->tp->tconst(const_idx)) ! 434: ! err::signal(malformed_expr, ! 435: ! "Temporary copy of indexable item would be needed to initialize non-constant reference."); ! 436: ! error('w',"constIr: temporary used toI reference"); ! 437: ! } ! 438: switch (p1->base) { ! 439: case INT: ! 440: case CHAR: ! 441: case SHORT: ! 442: ! switch (init->tp->underlying_type()->base) { ! 443: case LONG: ! 444: case FLOAT: ! 445: case DOUBLE: ! 446: case LDOUBLE: ! 447: ! error('w',"%t assigned to %t inRIr",init->tp,p1); ! 448: } ! 449: } ! 450: ! 451: *************** ! 452: *** 2249,2258 **** ! 453: return c; ! 454: } ! 455: } ! 456: ! static char rcsinfo[] = "$Header: /usr3/lang/benson/work/stripped_cfront/O/RCS/expr3.c,v 1.8 89/10/16 08:15:27 benson Exp $"; ! 457: ! 458: ! 459: /* $Log: expr3.c,v $ ! 460: * Revision 1.8 89/10/16 08:15:27 benson ! 461: * distinguish indedxable from const in argument passing. ! 462: * ! 463: --- 2365,2379 ---- ! 464: return c; ! 465: } ! 466: } ! 467: ! static char rcsinfo[] = "$Header: /usr3/lang/benson/work/stripped_cfront/O/RCS/expr3.c,v 1.9 89/10/20 14:30:34 benson Exp $"; ! 468: ! 469: ! 470: /* $Log: expr3.c,v $ ! 471: + * Revision 1.9 89/10/20 14:30:34 benson ! 472: + * fixes to typ handling in function calls to eliminate some strange ! 473: + * temps. Also catch indexable explicitly here. Also make error context ! 474: + * for any arg-related error message. ! 475: + * ! 476: * Revision 1.8 89/10/16 08:15:27 benson ! 477: * distinguish indedxable from const in argument passing. ! 478: *
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.