![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cp-cvt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to cp-cvt.c CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* Language-level data type conversion for GNU C++. 1.1.1.5 root 2: Copyright (C) 1987, 1988, 1992, 1993 Free Software Foundation, Inc. 1.1 root 3: Hacked by Michael Tiemann ([email protected]) 4: 5: This file is part of GNU CC. 6: 7: GNU CC is free software; you can redistribute it and/or modify 8: it under the terms of the GNU General Public License as published by 9: the Free Software Foundation; either version 2, or (at your option) 10: any later version. 11: 12: GNU CC is distributed in the hope that it will be useful, 13: but WITHOUT ANY WARRANTY; without even the implied warranty of 14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15: GNU General Public License for more details. 16: 17: You should have received a copy of the GNU General Public License 18: along with GNU CC; see the file COPYING. If not, write to 19: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ 20: 21: 22: /* This file contains the functions for converting C expressions 23: to different data types. The only entry point is `convert'. 24: Every language front end must have a `convert' function 25: but what kind of conversions it does will depend on the language. */ 26: 27: #include "config.h" 28: #include "tree.h" 1.1.1.4 root 29: #include "flags.h" 1.1 root 30: #include "cp-tree.h" 1.1.1.6 ! root 31: #include "cp-class.h" 1.1.1.5 root 32: #include "convert.h" 1.1 root 33: 1.1.1.5 root 34: #undef NULL 35: #define NULL (char *)0 1.1 root 36: 37: /* Change of width--truncation and extension of integers or reals-- 38: is represented with NOP_EXPR. Proper functioning of many things 39: assumes that no other conversions can be NOP_EXPRs. 40: 41: Conversion between integer and pointer is represented with CONVERT_EXPR. 42: Converting integer to real uses FLOAT_EXPR 43: and real to integer uses FIX_TRUNC_EXPR. 44: 45: Here is a list of all the functions that assume that widening and 46: narrowing is always done with a NOP_EXPR: 1.1.1.6 ! root 47: In convert.c, convert_to_integer. 1.1 root 48: In c-typeck.c, build_binary_op_nodefault (boolean ops), 49: and truthvalue_conversion. 50: In expr.c: expand_expr, for operands of a MULT_EXPR. 51: In fold-const.c: fold. 52: In tree.c: get_narrower and get_unwidened. 53: 54: C++: in multiple-inheritance, converting between pointers may involve 55: adjusting them by a delta stored within the class definition. */ 56: 57: /* Subroutines of `convert'. */ 58: 1.1.1.6 ! root 59: /* Build a thunk. What it is, is an entry point that when called will ! 60: adjust the this pointer (the first argument) by offset, and then ! 61: goto the real address of the function given by REAL_ADDR that we ! 62: would like called. What we return is the address of the thunk. */ ! 63: static tree ! 64: build_thunk (offset, real_addr) ! 65: tree offset, real_addr; ! 66: { ! 67: if (TREE_CODE (real_addr) != ADDR_EXPR ! 68: || TREE_CODE (TREE_OPERAND (real_addr, 0)) != FUNCTION_DECL) ! 69: { ! 70: sorry ("MI pointer to member conversion too complex"); ! 71: return error_mark_node; ! 72: } ! 73: sorry ("MI pointer to member conversion too complex"); ! 74: return error_mark_node; ! 75: } ! 76: ! 77: /* Convert a `pointer to member' (POINTER_TYPE to METHOD_TYPE) into ! 78: another `pointer to method'. This may involved the creation of ! 79: a thunk to handle the this offset calculation. */ ! 80: static tree ! 81: convert_fn_ptr (type, expr) ! 82: tree type, expr; ! 83: { ! 84: tree binfo = get_binfo (TYPE_METHOD_BASETYPE (TREE_TYPE (TREE_TYPE (expr))), ! 85: TYPE_METHOD_BASETYPE (TREE_TYPE (type)), ! 86: 1); ! 87: if (binfo == error_mark_node) ! 88: { ! 89: error (" in pointer to member conversion"); ! 90: return error_mark_node; ! 91: } ! 92: if (binfo == NULL_TREE) ! 93: { ! 94: /* ARM 4.8 restriction. */ ! 95: error ("invalid pointer to member conversion"); ! 96: return error_mark_node; ! 97: } ! 98: if (BINFO_OFFSET_ZEROP (binfo)) ! 99: return build1 (NOP_EXPR, type, expr); ! 100: return build1 (NOP_EXPR, type, build_thunk (BINFO_OFFSET (binfo), expr)); ! 101: } ! 102: ! 103: /* if converting pointer to pointer ! 104: if dealing with classes, check for derived->base or vice versa ! 105: else if dealing with method pointers, delegate ! 106: else convert blindly ! 107: else if converting class, pass off to build_type_conversion ! 108: else try C-style pointer conversion */ 1.1 root 109: static tree 1.1.1.5 root 110: cp_convert_to_pointer (type, expr) 1.1 root 111: tree type, expr; 112: { 113: register tree intype = TREE_TYPE (expr); 114: register enum tree_code form = TREE_CODE (intype); 115: 116: if (form == POINTER_TYPE) 117: { 118: intype = TYPE_MAIN_VARIANT (intype); 119: 120: if (TYPE_MAIN_VARIANT (type) != intype 1.1.1.2 root 121: && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE 122: && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE) 1.1 root 123: { 124: enum tree_code code = PLUS_EXPR; 125: tree binfo = get_binfo (TREE_TYPE (type), TREE_TYPE (intype), 1); 126: if (binfo == error_mark_node) 127: return error_mark_node; 128: if (binfo == NULL_TREE) 129: { 130: binfo = get_binfo (TREE_TYPE (intype), TREE_TYPE (type), 1); 131: if (binfo == error_mark_node) 132: return error_mark_node; 133: code = MINUS_EXPR; 134: } 135: if (binfo) 136: { 137: if (TYPE_USES_VIRTUAL_BASECLASSES (TREE_TYPE (type)) 138: || TYPE_USES_VIRTUAL_BASECLASSES (TREE_TYPE (intype)) 139: || ! BINFO_OFFSET_ZEROP (binfo)) 140: { 141: /* Need to get the path we took. */ 142: tree path; 143: 144: if (code == PLUS_EXPR) 145: get_base_distance (TREE_TYPE (type), TREE_TYPE (intype), 0, &path); 146: else 147: get_base_distance (TREE_TYPE (intype), TREE_TYPE (type), 0, &path); 148: return build_vbase_path (code, type, expr, path, 0); 149: } 150: } 151: } 1.1.1.6 ! root 152: if (TYPE_MAIN_VARIANT (type) != intype ! 153: && TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE ! 154: && TREE_CODE (type) == POINTER_TYPE ! 155: && TREE_CODE (TREE_TYPE (intype)) == METHOD_TYPE) ! 156: return convert_fn_ptr (type, expr); ! 157: 1.1 root 158: return build1 (NOP_EXPR, type, expr); 159: } 160: 1.1.1.4 root 161: my_friendly_assert (form != OFFSET_TYPE, 186); 1.1 root 162: 163: if (IS_AGGR_TYPE (intype)) 164: { 165: /* If we cannot convert to the specific pointer type, 166: try to convert to the type `void *'. */ 167: tree rval; 168: rval = build_type_conversion (CONVERT_EXPR, type, expr, 1); 169: if (rval) 170: { 171: if (rval == error_mark_node) 172: error ("ambiguous pointer conversion"); 173: return rval; 174: } 175: } 176: 1.1.1.5 root 177: return convert_to_pointer (type, expr); 1.1 root 178: } 179: 180: /* Like convert, except permit conversions to take place which 181: are not normally allowed due to visibility restrictions 182: (such as conversion from sub-type to private super-type). */ 183: static tree 184: convert_to_pointer_force (type, expr) 185: tree type, expr; 186: { 187: register tree intype = TREE_TYPE (expr); 188: register enum tree_code form = TREE_CODE (intype); 189: 190: if (integer_zerop (expr)) 191: { 192: if (type == TREE_TYPE (null_pointer_node)) 193: return null_pointer_node; 194: expr = build_int_2 (0, 0); 195: TREE_TYPE (expr) = type; 196: return expr; 197: } 198: 199: if (form == POINTER_TYPE) 200: { 201: intype = TYPE_MAIN_VARIANT (intype); 202: 203: if (TYPE_MAIN_VARIANT (type) != intype 1.1.1.2 root 204: && TREE_CODE (TREE_TYPE (type)) == RECORD_TYPE 205: && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE) 1.1 root 206: { 207: enum tree_code code = PLUS_EXPR; 208: tree path; 209: int distance = get_base_distance (TREE_TYPE (type), 210: TREE_TYPE (intype), 0, &path); 211: if (distance == -2) 212: { 213: ambig: 1.1.1.6 ! root 214: cp_error ("type `%T' is ambiguous baseclass of `%s'", TREE_TYPE (type), 1.1 root 215: TYPE_NAME_STRING (TREE_TYPE (intype))); 216: return error_mark_node; 217: } 218: if (distance == -1) 219: { 220: distance = get_base_distance (TREE_TYPE (intype), 221: TREE_TYPE (type), 0, &path); 222: if (distance == -2) 223: goto ambig; 224: if (distance < 0) 225: /* Doesn't need any special help from us. */ 226: return build1 (NOP_EXPR, type, expr); 227: 228: code = MINUS_EXPR; 229: } 230: return build_vbase_path (code, type, expr, path, 0); 231: } 232: return build1 (NOP_EXPR, type, expr); 233: } 234: 1.1.1.5 root 235: return cp_convert_to_pointer (type, expr); 1.1 root 236: } 237: 238: /* We are passing something to a function which requires a reference. 239: The type we are interested in is in TYPE. The initial 240: value we have to begin with is in ARG. 241: 1.1.1.4 root 242: FLAGS controls how we manage visibility checking. 243: CHECKCONST controls if we report error messages on const subversion. */ 1.1 root 244: static tree 1.1.1.4 root 245: build_up_reference (type, arg, flags, checkconst) 1.1 root 246: tree type, arg; 1.1.1.4 root 247: int flags, checkconst; 1.1 root 248: { 249: tree rval, targ; 250: int literal_flag = 0; 251: tree argtype = TREE_TYPE (arg), basetype = argtype; 252: tree target_type = TREE_TYPE (type); 253: tree binfo = NULL_TREE; 254: 1.1.1.4 root 255: my_friendly_assert (TREE_CODE (type) == REFERENCE_TYPE, 187); 1.1 root 256: if (flags != 0 257: && TYPE_MAIN_VARIANT (argtype) != TYPE_MAIN_VARIANT (target_type) 258: && IS_AGGR_TYPE (argtype) 259: && IS_AGGR_TYPE (target_type)) 260: { 261: binfo = get_binfo (target_type, argtype, 262: (flags & LOOKUP_PROTECTED_OK) ? 3 : 2); 263: if ((flags & LOOKUP_PROTECT) && binfo == error_mark_node) 264: return error_mark_node; 1.1.1.6 ! root 265: if (binfo == NULL_TREE) ! 266: return error_not_base_type (target_type, argtype); 1.1 root 267: basetype = BINFO_TYPE (binfo); 268: } 269: 1.1.1.3 root 270: /* Pass along const and volatile down into the type. */ 271: if (TYPE_READONLY (type) || TYPE_VOLATILE (type)) 272: target_type = build_type_variant (target_type, TYPE_READONLY (type), 273: TYPE_VOLATILE (type)); 1.1 root 274: targ = arg; 275: if (TREE_CODE (targ) == SAVE_EXPR) 276: targ = TREE_OPERAND (targ, 0); 277: 278: switch (TREE_CODE (targ)) 279: { 280: case INDIRECT_REF: 281: /* This is a call to a constructor which did not know what it was 282: initializing until now: it needs to initialize a temporary. */ 283: if (TREE_HAS_CONSTRUCTOR (targ)) 284: { 285: tree temp = build_cplus_new (argtype, TREE_OPERAND (targ, 0), 1); 286: TREE_HAS_CONSTRUCTOR (targ) = 0; 1.1.1.4 root 287: return build_up_reference (type, temp, flags, 1); 1.1 root 288: } 289: /* Let &* cancel out to simplify resulting code. 290: Also, throw away intervening NOP_EXPRs. */ 291: arg = TREE_OPERAND (targ, 0); 292: if (TREE_CODE (arg) == NOP_EXPR || TREE_CODE (arg) == NON_LVALUE_EXPR 293: || (TREE_CODE (arg) == CONVERT_EXPR && TREE_REFERENCE_EXPR (arg))) 294: arg = TREE_OPERAND (arg, 0); 295: 1.1.1.3 root 296: /* in doing a &*, we have to get rid of the const'ness on the pointer 297: value. Haven't thought about volatile here. Pointers come to mind 298: here. */ 299: if (TREE_READONLY (arg)) 300: { 301: arg = copy_node (arg); 302: TREE_READONLY (arg) = 0; 303: } 304: 1.1 root 305: rval = build1 (CONVERT_EXPR, type, arg); 306: TREE_REFERENCE_EXPR (rval) = 1; 1.1.1.3 root 307: 308: /* propagate the const flag on something like: 309: 310: class Base { 311: public: 312: int foo; 313: }; 314: 315: class Derived : public Base { 316: public: 317: int bar; 318: }; 319: 320: void func(Base&); 321: 322: void func2(const Derived& d) { 323: func(d); 324: } 325: 326: on the d parameter. The below could have been avoided, if the flags 1.1.1.4 root 327: were down in the tree, not sure why they are not. (mrs) */ 1.1.1.3 root 328: /* The below code may have to be propagated to other parts of this 329: switch. */ 330: if (TREE_READONLY (targ) && !TREE_READONLY (arg) 331: && (TREE_CODE (arg) == PARM_DECL || TREE_CODE (arg) == VAR_DECL) 1.1.1.4 root 332: && TREE_CODE (TREE_TYPE (arg)) == REFERENCE_TYPE 333: && (TYPE_READONLY (target_type) && checkconst)) 1.1.1.3 root 334: { 1.1.1.4 root 335: arg = copy_node (arg); 1.1.1.3 root 336: TREE_READONLY (arg) = TREE_READONLY (targ); 337: } 1.1 root 338: literal_flag = TREE_CONSTANT (arg); 1.1.1.3 root 339: 340: goto done_but_maybe_warn; 1.1 root 341: 342: /* Get this out of a register if we happened to be in one by accident. 343: Also, build up references to non-lvalues it we must. */ 344: /* For &x[y], return (&) x+y */ 345: case ARRAY_REF: 346: if (mark_addressable (TREE_OPERAND (targ, 0)) == 0) 347: return error_mark_node; 348: rval = build_binary_op (PLUS_EXPR, TREE_OPERAND (targ, 0), 1.1.1.5 root 349: TREE_OPERAND (targ, 1), 1); 1.1 root 350: TREE_TYPE (rval) = type; 351: if (TREE_CONSTANT (TREE_OPERAND (targ, 1)) 352: && staticp (TREE_OPERAND (targ, 0))) 353: TREE_CONSTANT (rval) = 1; 354: goto done; 355: 356: case SCOPE_REF: 357: /* Could be a reference to a static member. */ 358: { 359: tree field = TREE_OPERAND (targ, 1); 360: if (TREE_STATIC (field)) 361: { 362: rval = build1 (ADDR_EXPR, type, field); 363: literal_flag = 1; 364: goto done; 365: } 366: } 1.1.1.5 root 367: 368: /* We should have farmed out member pointers above. */ 369: my_friendly_abort (188); 1.1 root 370: 371: case COMPONENT_REF: 372: rval = build_component_addr (targ, build_pointer_type (argtype), 373: "attempt to make a reference to bit-field structure member `%s'"); 374: TREE_TYPE (rval) = type; 375: literal_flag = staticp (TREE_OPERAND (targ, 0)); 1.1.1.3 root 376: 1.1 root 377: goto done_but_maybe_warn; 378: 379: /* Anything not already handled and not a true memory reference 380: needs to have a reference built up. Do so silently for 381: things like integers and return values from function, 382: but complain if we need a reference to something declared 383: as `register'. */ 384: 385: case RESULT_DECL: 386: if (staticp (targ)) 387: literal_flag = 1; 388: TREE_ADDRESSABLE (targ) = 1; 389: put_var_into_stack (targ); 390: break; 391: 392: case PARM_DECL: 393: if (targ == current_class_decl) 394: { 395: error ("address of `this' not available"); 1.1.1.4 root 396: #if 0 397: /* This code makes the following core dump the compiler on a sun4, 398: if the code below is used. 399: 400: class e_decl; 401: class a_decl; 402: typedef a_decl* a_ref; 403: 404: class a_s { 405: public: 406: a_s(); 407: void* append(a_ref& item); 408: }; 409: class a_decl { 410: public: 411: a_decl (e_decl *parent); 412: a_s generic_s; 413: a_s decls; 414: e_decl* parent; 415: }; 416: 417: class e_decl { 418: public: 419: e_decl(); 420: a_s implementations; 421: }; 422: 423: void foobar(void *); 424: 425: a_decl::a_decl(e_decl *parent) { 426: parent->implementations.append(this); 427: } 428: */ 429: 1.1 root 430: TREE_ADDRESSABLE (targ) = 1; /* so compiler doesn't die later */ 431: put_var_into_stack (targ); 1.1.1.5 root 432: break; 1.1.1.4 root 433: #else 434: return error_mark_node; 435: #endif 1.1 root 436: } 437: /* Fall through. */ 438: case VAR_DECL: 439: case CONST_DECL: 1.1.1.4 root 440: if (DECL_REGISTER (targ) && !TREE_ADDRESSABLE (targ)) 1.1 root 441: warning ("address needed to build reference for `%s', which is declared `register'", 442: IDENTIFIER_POINTER (DECL_NAME (targ))); 443: else if (staticp (targ)) 444: literal_flag = 1; 445: 446: TREE_ADDRESSABLE (targ) = 1; 447: put_var_into_stack (targ); 448: break; 449: 450: case COMPOUND_EXPR: 451: { 452: tree real_reference = build_up_reference (type, TREE_OPERAND (targ, 1), 1.1.1.4 root 453: LOOKUP_PROTECT, checkconst); 1.1 root 454: rval = build (COMPOUND_EXPR, type, TREE_OPERAND (targ, 0), real_reference); 455: TREE_CONSTANT (rval) = staticp (TREE_OPERAND (targ, 1)); 456: return rval; 457: } 458: 459: case MODIFY_EXPR: 460: case INIT_EXPR: 461: { 462: tree real_reference = build_up_reference (type, TREE_OPERAND (targ, 0), 1.1.1.4 root 463: LOOKUP_PROTECT, checkconst); 1.1 root 464: rval = build (COMPOUND_EXPR, type, arg, real_reference); 465: TREE_CONSTANT (rval) = staticp (TREE_OPERAND (targ, 0)); 466: return rval; 467: } 468: 469: case COND_EXPR: 470: return build (COND_EXPR, type, 471: TREE_OPERAND (targ, 0), 1.1.1.4 root 472: build_up_reference (type, TREE_OPERAND (targ, 1), 473: LOOKUP_PROTECT, checkconst), 474: build_up_reference (type, TREE_OPERAND (targ, 2), 475: LOOKUP_PROTECT, checkconst)); 1.1 root 476: 477: case WITH_CLEANUP_EXPR: 478: return build (WITH_CLEANUP_EXPR, type, 1.1.1.4 root 479: build_up_reference (type, TREE_OPERAND (targ, 0), 480: LOOKUP_PROTECT, checkconst), 1.1 root 481: 0, TREE_OPERAND (targ, 2)); 482: 483: case BIND_EXPR: 484: arg = TREE_OPERAND (targ, 1); 485: if (arg == NULL_TREE) 486: { 487: compiler_error ("({ ... }) expression not expanded when needed for reference"); 488: return error_mark_node; 489: } 490: rval = build1 (ADDR_EXPR, type, arg); 491: TREE_REFERENCE_EXPR (rval) = 1; 492: return rval; 493: 494: default: 495: break; 496: } 497: 498: if (TREE_ADDRESSABLE (targ) == 0) 499: { 500: tree temp; 501: 502: if (TREE_CODE (targ) == CALL_EXPR && IS_AGGR_TYPE (argtype)) 503: { 504: temp = build_cplus_new (argtype, targ, 1); 505: rval = build1 (ADDR_EXPR, type, temp); 506: goto done; 507: } 508: else 509: { 510: temp = get_temp_name (argtype, 0); 511: if (global_bindings_p ()) 512: { 513: /* Give this new temp some rtl and initialize it. */ 514: DECL_INITIAL (temp) = targ; 515: TREE_STATIC (temp) = 1; 516: finish_decl (temp, targ, NULL_TREE, 0); 517: /* Do this after declaring it static. */ 518: rval = build_unary_op (ADDR_EXPR, temp, 0); 519: literal_flag = TREE_CONSTANT (rval); 520: goto done; 521: } 522: else 523: { 524: rval = build_unary_op (ADDR_EXPR, temp, 0); 525: /* Put a value into the rtl. */ 526: if (IS_AGGR_TYPE (argtype)) 527: { 528: /* This may produce surprising results, 529: since we commit to initializing the temp 530: when the temp may not actually get used. */ 531: expand_aggr_init (temp, targ, 0); 532: TREE_TYPE (rval) = type; 533: literal_flag = TREE_CONSTANT (rval); 534: goto done; 535: } 536: else 537: { 538: if (binfo && !BINFO_OFFSET_ZEROP (binfo)) 539: rval = convert_pointer_to (target_type, rval); 540: else 541: TREE_TYPE (rval) = type; 1.1.1.6 ! root 542: ! 543: temp = build (MODIFY_EXPR, argtype, temp, arg); ! 544: TREE_SIDE_EFFECTS (temp) = 1; ! 545: return build (COMPOUND_EXPR, type, temp, rval); 1.1 root 546: } 547: } 548: } 549: } 550: else 551: { 552: if (TREE_CODE (arg) == SAVE_EXPR) 1.1.1.3 root 553: my_friendly_abort (5); 1.1 root 554: rval = build1 (ADDR_EXPR, type, arg); 555: } 556: 557: done_but_maybe_warn: 1.1.1.4 root 558: if (checkconst && TREE_READONLY (arg) && ! TYPE_READONLY (target_type)) 1.1.1.5 root 559: readonly_error (arg, "conversion to reference", 1); 1.1 root 560: 561: done: 562: if (TYPE_USES_COMPLEX_INHERITANCE (argtype)) 563: { 564: TREE_TYPE (rval) = TYPE_POINTER_TO (argtype); 565: rval = convert_pointer_to (target_type, rval); 566: TREE_TYPE (rval) = type; 567: } 568: TREE_CONSTANT (rval) = literal_flag; 569: return rval; 570: } 571: 572: /* For C++: Only need to do one-level references, but cannot 573: get tripped up on signed/unsigned differences. 574: 575: If DECL is NULL_TREE it means convert as though casting (by force). 576: If it is ERROR_MARK_NODE, it means the conversion is implicit, 577: and that temporaries may be created. 1.1.1.4 root 578: Make sure the use of user-defined conversion operators is un-ambiguous. 579: Otherwise, DECL is a _DECL node which can be used in error reporting. 580: 581: FNDECL, PARMNUM, and ERRTYPE are only used when checking for use of 582: volatile or const references where they aren't desired. */ 1.1.1.5 root 583: 1.1 root 584: tree 1.1.1.4 root 585: convert_to_reference (decl, reftype, expr, fndecl, parmnum, 586: errtype, strict, flags) 1.1.1.5 root 587: 1.1 root 588: tree decl; 589: tree reftype, expr; 1.1.1.4 root 590: tree fndecl; 591: int parmnum; 592: char *errtype; 1.1 root 593: int strict, flags; 594: { 595: register tree type = TYPE_MAIN_VARIANT (TREE_TYPE (reftype)); 596: register tree intype = TREE_TYPE (expr); 597: register enum tree_code form = TREE_CODE (intype); 1.1.1.4 root 598: tree rval = NULL_TREE; 1.1 root 599: 1.1.1.6 ! root 600: if (TREE_CODE(type) == ARRAY_TYPE) ! 601: type = build_pointer_type (TREE_TYPE(type)); 1.1 root 602: if (form == REFERENCE_TYPE) 603: intype = TREE_TYPE (intype); 604: intype = TYPE_MAIN_VARIANT (intype); 605: 606: /* @@ Probably need to have a check for X(X&) here. */ 607: 608: if (IS_AGGR_TYPE (intype)) 609: { 1.1.1.4 root 610: rval = build_type_conversion (CONVERT_EXPR, reftype, expr, 1); 1.1 root 611: if (rval) 612: { 613: if (rval == error_mark_node) 614: error ("ambiguous pointer conversion"); 615: return rval; 616: } 1.1.1.3 root 617: else if (type != intype 618: && (rval = build_type_conversion (CONVERT_EXPR, type, expr, 1))) 1.1 root 619: { 1.1.1.3 root 620: if (rval == error_mark_node) 621: return rval; 1.1 root 622: if (TYPE_NEEDS_DESTRUCTOR (type)) 623: { 1.1.1.5 root 624: rval = convert_to_reference (NULL_TREE, reftype, rval, NULL_TREE, 625: -1, (char *)NULL, strict, flags); 1.1 root 626: } 627: else 628: { 629: decl = get_temp_name (type, 0); 630: rval = build (INIT_EXPR, type, decl, rval); 631: rval = build (COMPOUND_EXPR, reftype, rval, 632: convert_to_reference (NULL_TREE, reftype, decl, 1.1.1.5 root 633: NULL_TREE, -1, (char*)NULL, 1.1 root 634: strict, flags)); 635: } 636: } 637: 638: if (form == REFERENCE_TYPE 639: && type != intype 640: && TYPE_USES_COMPLEX_INHERITANCE (intype)) 641: { 642: /* If it may move around, build a fresh reference. */ 643: expr = convert_from_reference (expr); 644: form = TREE_CODE (TREE_TYPE (expr)); 645: } 646: } 647: 648: /* @@ Perhaps this should try to go through a constructor first 649: @@ for proper initialization, but I am not sure when that 1.1.1.6 ! root 650: @@ is needed or desirable. */ 1.1 root 651: 652: if (((IS_AGGR_TYPE (type) || IS_AGGR_TYPE (intype)) 653: && comptypes (type, intype, strict)) 654: || (!IS_AGGR_TYPE (type) 1.1.1.6 ! root 655: #if 1 ! 656: && ((TREE_CODE (type) == TREE_CODE (intype) ! 657: && int_size_in_bytes (type) == int_size_in_bytes (intype)) ! 658: || TREE_READONLY (TREE_TYPE (reftype))))) ! 659: #else ! 660: && (comptypes (type, intype, 1) ! 661: || TREE_READONLY (TREE_TYPE (reftype))))) ! 662: #endif ! 663: 1.1 root 664: { 1.1.1.4 root 665: /* Section 13. */ 666: /* Since convert_for_initialization didn't call convert_for_assignment, 1.1.1.6 ! root 667: we have to do this checking here. FIXME: We should have a common 1.1.1.4 root 668: routine between here and convert_for_assignment. */ 669: if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE) 670: { 671: register tree ttl = TREE_TYPE (reftype); 672: register tree ttr = TREE_TYPE (TREE_TYPE (expr)); 673: 674: if (! TYPE_READONLY (ttl) && TYPE_READONLY (ttr)) 675: warn_for_assignment ("%s of non-`const &' reference from `const &'", 676: "reference to const given for argument %d of `%s'", 677: errtype, fndecl, parmnum, pedantic); 678: if (! TYPE_VOLATILE (ttl) && TYPE_VOLATILE (ttr)) 679: warn_for_assignment ("%s of non-`volatile &' reference from `volatile &'", 1.1.1.5 root 680: "reference to volatile given for argument %d of `%s'", 1.1.1.4 root 681: errtype, fndecl, parmnum, pedantic); 682: } 683: 1.1 root 684: /* If EXPR is of aggregate type, and is really a CALL_EXPR, 685: then we don't need to convert it to reference type if 686: it is only being used to initialize DECL which is also 687: of the same aggregate type. */ 688: if (form == REFERENCE_TYPE 689: || (decl != NULL_TREE && decl != error_mark_node 690: && IS_AGGR_TYPE (type) 691: && TREE_CODE (expr) == CALL_EXPR 692: && TYPE_MAIN_VARIANT (type) == intype)) 693: { 694: if (decl && decl != error_mark_node) 695: { 696: tree e1 = build (INIT_EXPR, void_type_node, decl, expr); 697: tree e2; 698: 699: TREE_SIDE_EFFECTS (e1) = 1; 700: if (form == REFERENCE_TYPE) 701: e2 = build1 (NOP_EXPR, reftype, decl); 702: else 703: { 704: e2 = build_unary_op (ADDR_EXPR, decl, 0); 705: TREE_TYPE (e2) = reftype; 706: TREE_REFERENCE_EXPR (e2) = 1; 707: } 708: return build_compound_expr (tree_cons (NULL_TREE, e1, 709: build_tree_list (NULL_TREE, e2))); 710: } 711: expr = copy_node (expr); 712: TREE_TYPE (expr) = reftype; 713: return expr; 714: } 715: if (decl == error_mark_node) 716: flags |= LOOKUP_PROTECTED_OK; 1.1.1.4 root 717: return build_up_reference (reftype, expr, flags, decl!=NULL_TREE); 1.1 root 718: } 719: 720: /* Definitely need to go through a constructor here. */ 721: if (TYPE_HAS_CONSTRUCTOR (type)) 722: { 1.1.1.6 ! root 723: tree init = build_method_call (NULL_TREE, constructor_name_full (type), 1.1.1.4 root 724: build_tree_list (NULL_TREE, expr), 725: TYPE_BINFO (type), LOOKUP_NO_CONVERSION); 726: 727: if (init != error_mark_node) 1.1.1.6 ! root 728: { ! 729: if (rval) ! 730: { ! 731: error ("both constructor and type conversion operator apply"); ! 732: return error_mark_node; ! 733: } ! 734: } ! 735: else ! 736: { ! 737: /* If a type conversion operator works, then pass that along ! 738: to the ctor. */ ! 739: if (rval != NULL_TREE) ! 740: expr = rval; ! 741: } 1.1.1.4 root 742: 1.1.1.6 ! root 743: init = build_method_call (NULL_TREE, constructor_name_full (type), 1.1.1.4 root 744: build_tree_list (NULL_TREE, expr), 1.1.1.5 root 745: TYPE_BINFO (type), LOOKUP_NORMAL|LOOKUP_NO_CONVERSION); 1.1 root 746: 747: if (init == error_mark_node) 748: return error_mark_node; 749: rval = build_cplus_new (type, init, 1); 750: if (decl == error_mark_node) 751: flags |= LOOKUP_PROTECTED_OK; 1.1.1.4 root 752: return build_up_reference (reftype, rval, flags, decl!=NULL_TREE); 1.1 root 753: } 754: 1.1.1.6 ! root 755: if (rval) ! 756: { ! 757: /* If we found a way to convert earlier, then use it. */ ! 758: return rval; ! 759: } ! 760: 1.1.1.4 root 761: my_friendly_assert (form != OFFSET_TYPE, 189); 762: 1.1.1.6 ! root 763: cp_error ("cannot convert type `%T' to type `%T'", intype, reftype); 1.1 root 764: 765: return error_mark_node; 766: } 767: 768: /* We are using a reference VAL for its value. Bash that reference all the 769: way down to its lowest form. */ 770: tree 771: convert_from_reference (val) 772: tree val; 773: { 774: tree type = TREE_TYPE (val); 775: 776: if (TREE_CODE (type) == OFFSET_TYPE) 777: type = TREE_TYPE (type); 778: if (TREE_CODE (type) == REFERENCE_TYPE) 779: { 780: tree target_type = TREE_TYPE (type); 1.1.1.5 root 781: tree nval; 1.1 root 782: 783: /* This can happen if we cast to a reference type. */ 784: if (TREE_CODE (val) == ADDR_EXPR) 785: { 1.1.1.5 root 786: nval = build1 (NOP_EXPR, build_pointer_type (target_type), val); 1.1.1.6 ! root 787: nval = build_indirect_ref (nval, NULL_PTR); 1.1.1.5 root 788: /* The below was missing, are other important flags missing too? */ 789: TREE_SIDE_EFFECTS (nval) = TREE_SIDE_EFFECTS (val); 790: return nval; 1.1 root 791: } 792: 1.1.1.5 root 793: nval = build1 (INDIRECT_REF, TYPE_MAIN_VARIANT (target_type), val); 794: 795: TREE_THIS_VOLATILE (nval) = TYPE_VOLATILE (target_type); 796: TREE_SIDE_EFFECTS (nval) = TYPE_VOLATILE (target_type); 797: TREE_READONLY (nval) = TYPE_READONLY (target_type); 798: /* The below was missing, are other important flags missing too? */ 1.1.1.6 ! root 799: TREE_SIDE_EFFECTS (nval) |= TREE_SIDE_EFFECTS (val); 1.1.1.5 root 800: return nval; 1.1 root 801: } 802: return val; 803: } 804: 805: /* See if there is a constructor of type TYPE which will convert 806: EXPR. The reference manual seems to suggest (8.5.6) that we need 807: not worry about finding constructors for base classes, then converting 808: to the derived class. 809: 810: MSGP is a pointer to a message that would be an appropriate error 811: string. If MSGP is NULL, then we are not interested in reporting 812: errors. */ 813: tree 814: convert_to_aggr (type, expr, msgp, protect) 815: tree type, expr; 816: char **msgp; 1.1.1.4 root 817: int protect; 1.1 root 818: { 819: tree basetype = type; 820: tree name = TYPE_IDENTIFIER (basetype); 821: tree function, fndecl, fntype, parmtypes, parmlist, result; 822: tree method_name; 823: enum visibility_type visibility; 824: int can_be_private, can_be_protected; 825: 826: if (! TYPE_HAS_CONSTRUCTOR (basetype)) 827: { 828: if (msgp) 829: *msgp = "type `%s' does not have a constructor"; 830: return error_mark_node; 831: } 832: 833: visibility = visibility_public; 834: can_be_private = 0; 835: can_be_protected = IDENTIFIER_CLASS_VALUE (name) || name == current_class_name; 836: 837: parmlist = build_tree_list (NULL_TREE, expr); 838: parmtypes = tree_cons (NULL_TREE, TREE_TYPE (expr), void_list_node); 839: 840: if (TYPE_USES_VIRTUAL_BASECLASSES (basetype)) 841: { 842: parmtypes = tree_cons (NULL_TREE, integer_type_node, parmtypes); 843: parmlist = tree_cons (NULL_TREE, integer_one_node, parmlist); 844: } 845: 846: /* The type of the first argument will be filled in inside the loop. */ 847: parmlist = tree_cons (NULL_TREE, integer_zero_node, parmlist); 848: parmtypes = tree_cons (NULL_TREE, TYPE_POINTER_TO (basetype), parmtypes); 849: 1.1.1.2 root 850: method_name = build_decl_overload (name, parmtypes, 1); 1.1 root 851: 852: /* constructors are up front. */ 853: fndecl = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype), 0); 854: if (TYPE_HAS_DESTRUCTOR (basetype)) 855: fndecl = DECL_CHAIN (fndecl); 856: 857: while (fndecl) 858: { 859: if (DECL_ASSEMBLER_NAME (fndecl) == method_name) 860: { 861: function = fndecl; 862: if (protect) 863: { 864: if (TREE_PRIVATE (fndecl)) 865: { 866: can_be_private = 867: (basetype == current_class_type 868: || is_friend (basetype, current_function_decl) 869: || purpose_member (basetype, DECL_VISIBILITY (fndecl))); 870: if (! can_be_private) 871: goto found; 872: } 873: else if (TREE_PROTECTED (fndecl)) 874: { 875: if (! can_be_protected) 876: goto found; 877: } 878: } 879: goto found_and_ok; 880: } 881: fndecl = DECL_CHAIN (fndecl); 882: } 883: 884: /* No exact conversion was found. See if an approximate 885: one will do. */ 886: fndecl = TREE_VEC_ELT (CLASSTYPE_METHOD_VEC (basetype), 0); 887: if (TYPE_HAS_DESTRUCTOR (basetype)) 888: fndecl = DECL_CHAIN (fndecl); 889: 890: { 891: int saw_private = 0; 892: int saw_protected = 0; 893: struct candidate *candidates = 894: (struct candidate *) alloca ((decl_list_length (fndecl)+1) * sizeof (struct candidate)); 895: struct candidate *cp = candidates; 896: 897: while (fndecl) 898: { 899: function = fndecl; 1.1.1.6 ! root 900: if (flag_ansi_overloading) ! 901: { ! 902: cp->v.ansi_harshness = (struct harshness_code *)alloca (3 * sizeof (struct harshness_code)); ! 903: cp->h_len = 2; ! 904: } ! 905: else ! 906: cp->v.old_harshness = (unsigned short *)alloca (3 * sizeof (short)); ! 907: 1.1 root 908: compute_conversion_costs (fndecl, parmlist, cp, 2); 1.1.1.6 ! root 909: if ((flag_ansi_overloading && (cp->h.code & EVIL_CODE) == 0) ! 910: || (!flag_ansi_overloading && cp->evil == 0)) 1.1 root 911: { 912: cp->u.field = fndecl; 913: if (protect) 914: { 915: if (TREE_PRIVATE (fndecl)) 916: visibility = visibility_private; 917: else if (TREE_PROTECTED (fndecl)) 918: visibility = visibility_protected; 919: else 920: visibility = visibility_public; 921: } 922: else 923: visibility = visibility_public; 924: 925: if (visibility == visibility_private 926: ? (basetype == current_class_type 927: || is_friend (basetype, cp->function) 928: || purpose_member (basetype, DECL_VISIBILITY (fndecl))) 929: : visibility == visibility_protected 930: ? (can_be_protected 931: || purpose_member (basetype, DECL_VISIBILITY (fndecl))) 932: : 1) 933: { 1.1.1.6 ! root 934: if ((flag_ansi_overloading && cp->h.code <= TRIVIAL_CODE) ! 935: || (!flag_ansi_overloading ! 936: && cp->user == 0 && cp->b_or_d == 0 ! 937: && cp->easy <= 1)) ! 938: goto found_and_ok; 1.1 root 939: cp++; 940: } 941: else 942: { 943: if (visibility == visibility_private) 944: saw_private = 1; 945: else 946: saw_protected = 1; 947: } 948: } 949: fndecl = DECL_CHAIN (fndecl); 950: } 951: if (cp - candidates) 952: { 953: /* Rank from worst to best. Then cp will point to best one. 954: Private fields have their bits flipped. For unsigned 955: numbers, this should make them look very large. 956: If the best alternate has a (signed) negative value, 957: then all we ever saw were private members. */ 958: if (cp - candidates > 1) 959: qsort (candidates, /* char *base */ 960: cp - candidates, /* int nel */ 961: sizeof (struct candidate), /* int width */ 962: rank_for_overload); /* int (*compar)() */ 963: 964: --cp; 1.1.1.6 ! root 965: if ((flag_ansi_overloading && (cp->h.code & EVIL_CODE)) ! 966: || (!flag_ansi_overloading && cp->evil > 1)) 1.1 root 967: { 968: if (msgp) 969: *msgp = "ambiguous type conversion possible for `%s'"; 970: return error_mark_node; 971: } 972: 973: function = cp->function; 974: fndecl = cp->u.field; 975: goto found_and_ok; 976: } 977: else if (msgp) 978: { 979: if (saw_private) 980: if (saw_protected) 981: *msgp = "only private and protected conversions apply"; 982: else 983: *msgp = "only private conversions apply"; 984: else if (saw_protected) 985: *msgp = "only protected conversions apply"; 986: } 987: return error_mark_node; 988: } 989: /* NOTREACHED */ 990: 991: not_found: 992: if (msgp) *msgp = "no appropriate conversion to type `%s'"; 993: return error_mark_node; 994: found: 995: if (visibility == visibility_private) 996: if (! can_be_private) 997: { 998: if (msgp) 999: *msgp = TREE_PRIVATE (fndecl) 1000: ? "conversion to type `%s' is private" 1001: : "conversion to type `%s' is from private base class"; 1002: return error_mark_node; 1003: } 1004: if (visibility == visibility_protected) 1005: if (! can_be_protected) 1006: { 1007: if (msgp) 1008: *msgp = TREE_PRIVATE (fndecl) 1009: ? "conversion to type `%s' is protected" 1010: : "conversion to type `%s' is from protected base class"; 1011: return error_mark_node; 1012: } 1013: function = fndecl; 1014: found_and_ok: 1015: 1016: /* It will convert, but we don't do anything about it yet. */ 1017: if (msgp == 0) 1018: return NULL_TREE; 1019: 1020: fntype = TREE_TYPE (function); 1.1.1.4 root 1021: if (DECL_INLINE (function) && TREE_CODE (function) == FUNCTION_DECL) 1.1 root 1022: function = build1 (ADDR_EXPR, build_pointer_type (fntype), function); 1023: else 1024: function = default_conversion (function); 1025: 1026: result = build_nt (CALL_EXPR, function, 1027: convert_arguments (NULL_TREE, TYPE_ARG_TYPES (fntype), 1028: parmlist, NULL_TREE, LOOKUP_NORMAL), 1029: NULL_TREE); 1030: TREE_TYPE (result) = TREE_TYPE (fntype); 1031: TREE_SIDE_EFFECTS (result) = 1; 1032: TREE_RAISES (result) = !! TYPE_RAISES_EXCEPTIONS (fntype); 1033: return result; 1034: } 1035: 1.1.1.6 ! root 1036: /* Call this when we know (for any reason) that expr is not, in fact, ! 1037: zero. This routine is like convert_pointer_to, but it pays ! 1038: attention to which specific instance of what type we want to ! 1039: convert to. This routine should eventually become ! 1040: convert_to_pointer after all references to convert_to_pointer ! 1041: are removed. */ 1.1 root 1042: tree 1.1.1.6 ! root 1043: convert_pointer_to_real (binfo, expr) 1.1 root 1044: tree binfo, expr; 1045: { 1046: register tree intype = TREE_TYPE (expr); 1047: tree ptr_type; 1048: tree type, rval; 1049: 1050: if (TREE_CODE (binfo) == TREE_VEC) 1051: type = BINFO_TYPE (binfo); 1052: else if (IS_AGGR_TYPE (binfo)) 1053: { 1054: type = binfo; 1055: } 1056: else 1057: { 1058: type = binfo; 1059: binfo = NULL_TREE; 1060: } 1061: 1062: ptr_type = build_pointer_type (type); 1063: if (ptr_type == TYPE_MAIN_VARIANT (intype)) 1064: return expr; 1065: 1066: if (intype == error_mark_node) 1067: return error_mark_node; 1068: 1.1.1.4 root 1069: my_friendly_assert (!integer_zerop (expr), 191); 1.1 root 1070: 1.1.1.5 root 1071: if (TREE_CODE (type) == RECORD_TYPE 1072: && TREE_CODE (TREE_TYPE (intype)) == RECORD_TYPE 1.1 root 1073: && type != TYPE_MAIN_VARIANT (TREE_TYPE (intype))) 1074: { 1075: tree path; 1.1.1.5 root 1076: int distance 1.1.1.6 ! root 1077: = get_base_distance (binfo, TYPE_MAIN_VARIANT (TREE_TYPE (intype)), 1.1.1.5 root 1078: 0, &path); 1.1 root 1079: 1.1.1.3 root 1080: /* This function shouldn't be called with unqualified arguments 1081: but if it is, give them an error message that they can read. 1082: */ 1083: if (distance < 0) 1084: { 1085: error ("cannot convert a pointer of type `%s'", 1086: TYPE_NAME_STRING (TREE_TYPE (intype))); 1.1.1.6 ! root 1087: cp_error ("to a pointer of type `%T'", type); 1.1.1.3 root 1088: 1.1.1.6 ! root 1089: if (distance == -2) ! 1090: cp_error ("because `%T' is an ambiguous base class", type); 1.1.1.3 root 1091: return error_mark_node; 1092: } 1.1 root 1093: 1094: return build_vbase_path (PLUS_EXPR, ptr_type, expr, path, 1); 1095: } 1096: rval = build1 (NOP_EXPR, ptr_type, 1097: TREE_CODE (expr) == NOP_EXPR ? TREE_OPERAND (expr, 0) : expr); 1098: TREE_CONSTANT (rval) = TREE_CONSTANT (expr); 1099: return rval; 1100: } 1101: 1.1.1.6 ! root 1102: /* Call this when we know (for any reason) that expr is ! 1103: not, in fact, zero. This routine gets a type out of the first ! 1104: argument and uses it to search for the type to convert to. If there ! 1105: is more than one instance of that type in the expr, the conversion is ! 1106: ambiguous. This routine should eventually go away, and all ! 1107: callers should use convert_to_pointer_real. */ ! 1108: tree ! 1109: convert_pointer_to (binfo, expr) ! 1110: tree binfo, expr; ! 1111: { ! 1112: tree type; ! 1113: ! 1114: if (TREE_CODE (binfo) == TREE_VEC) ! 1115: type = BINFO_TYPE (binfo); ! 1116: else if (IS_AGGR_TYPE (binfo)) ! 1117: type = binfo; ! 1118: else ! 1119: type = binfo; ! 1120: return convert_pointer_to_real (type, expr); ! 1121: } ! 1122: 1.1 root 1123: /* Same as above, but don't abort if we get an "ambiguous" baseclass. 1124: There's only one virtual baseclass we are looking for, and once 1125: we find one such virtual baseclass, we have found them all. */ 1126: 1127: tree 1128: convert_pointer_to_vbase (binfo, expr) 1129: tree binfo; 1130: tree expr; 1131: { 1132: tree intype = TREE_TYPE (TREE_TYPE (expr)); 1133: tree binfos = TYPE_BINFO_BASETYPES (intype); 1134: int i; 1135: 1136: for (i = TREE_VEC_LENGTH (binfos)-1; i >= 0; i--) 1137: { 1138: tree basetype = BINFO_TYPE (TREE_VEC_ELT (binfos, i)); 1139: if (BINFO_TYPE (binfo) == basetype) 1140: return convert_pointer_to (binfo, expr); 1141: if (binfo_member (BINFO_TYPE (binfo), CLASSTYPE_VBASECLASSES (basetype))) 1142: return convert_pointer_to_vbase (binfo, convert_pointer_to (basetype, expr)); 1143: } 1.1.1.3 root 1144: my_friendly_abort (6); 1.1 root 1145: /* NOTREACHED */ 1146: return NULL_TREE; 1147: } 1148: 1149: /* Create an expression whose value is that of EXPR, 1150: converted to type TYPE. The TREE_TYPE of the value 1151: is always TYPE. This function implements all reasonable 1152: conversions; callers should filter out those that are 1153: not permitted by the language being compiled. */ 1154: 1155: tree 1156: convert (type, expr) 1157: tree type, expr; 1158: { 1159: register tree e = expr; 1160: register enum tree_code code = TREE_CODE (type); 1161: 1.1.1.4 root 1162: if (type == TREE_TYPE (expr) 1163: || TREE_CODE (expr) == ERROR_MARK) 1.1 root 1164: return expr; 1.1.1.4 root 1165: if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (expr))) 1166: return fold (build1 (NOP_EXPR, type, expr)); 1.1 root 1167: if (TREE_CODE (TREE_TYPE (expr)) == ERROR_MARK) 1168: return error_mark_node; 1169: if (TREE_CODE (TREE_TYPE (expr)) == VOID_TYPE) 1170: { 1171: error ("void value not ignored as it ought to be"); 1172: return error_mark_node; 1173: } 1174: if (code == VOID_TYPE) 1175: { 1.1.1.6 ! root 1176: /* We're converting to a void type; see if they have an ! 1177: `operator void'. */ 1.1 root 1178: tree rval = build_type_conversion (NOP_EXPR, type, e, 0); 1179: /* If we can convert to void type via a type conversion, do so. */ 1180: if (rval) 1181: return rval; 1182: return build1 (CONVERT_EXPR, type, e); 1183: } 1184: #if 0 1185: /* This is incorrect. A truncation can't be stripped this way. 1186: Extensions will be stripped by the use of get_unwidened. */ 1187: if (TREE_CODE (expr) == NOP_EXPR) 1188: return convert (type, TREE_OPERAND (expr, 0)); 1189: #endif 1190: 1191: /* Just convert to the type of the member. */ 1192: if (code == OFFSET_TYPE) 1193: { 1194: type = TREE_TYPE (type); 1195: code = TREE_CODE (type); 1196: } 1197: 1198: /* C++ */ 1199: if (code == REFERENCE_TYPE) 1.1.1.4 root 1200: return fold (convert_to_reference (error_mark_node, 1201: type, e, 1202: NULL_TREE, -1, (char *)NULL, 1203: -1, LOOKUP_NORMAL)); 1.1 root 1204: else if (TREE_CODE (TREE_TYPE (e)) == REFERENCE_TYPE) 1205: e = convert_from_reference (e); 1206: 1207: if (code == INTEGER_TYPE || code == ENUMERAL_TYPE) 1.1.1.5 root 1208: { 1209: tree intype = TREE_TYPE (expr); 1210: enum tree_code form = TREE_CODE (intype); 1211: if (flag_int_enum_equivalence == 0 1212: && TREE_CODE (type) == ENUMERAL_TYPE 1213: && form == INTEGER_TYPE) 1214: { 1.1.1.6 ! root 1215: cp_pedwarn ("anachronistic conversion from `int' to `%#T'", type); ! 1216: 1.1.1.5 root 1217: if (flag_pedantic_errors) 1218: return error_mark_node; 1219: } 1220: if (form == OFFSET_TYPE) 1.1.1.6 ! root 1221: cp_error_at ("pointer-to-member expression object not composed with type `%D' object", ! 1222: TYPE_NAME (TYPE_OFFSET_BASETYPE (intype))); 1.1.1.5 root 1223: else if (IS_AGGR_TYPE (intype)) 1224: { 1225: tree rval; 1226: rval = build_type_conversion (CONVERT_EXPR, type, expr, 1); 1227: if (rval) return rval; 1.1.1.6 ! root 1228: cp_error ("`%#T' used where an `int' was expected", intype); 1.1.1.5 root 1229: return error_mark_node; 1230: } 1231: return fold (convert_to_integer (type, e)); 1232: } 1.1 root 1233: if (code == POINTER_TYPE) 1.1.1.5 root 1234: return fold (cp_convert_to_pointer (type, e)); 1.1 root 1235: if (code == REAL_TYPE) 1.1.1.5 root 1236: { 1237: if (IS_AGGR_TYPE (TREE_TYPE (e))) 1238: { 1239: tree rval; 1240: rval = build_type_conversion (CONVERT_EXPR, type, e, 1); 1241: if (rval) 1242: return rval; 1243: else 1.1.1.6 ! root 1244: cp_error ("`%#T' used where a floating point value was expected", ! 1245: TREE_TYPE (e)); 1.1.1.5 root 1246: } 1247: return fold (convert_to_real (type, e)); 1248: } 1.1 root 1249: 1250: /* New C++ semantics: since assignment is now based on 1251: memberwise copying, if the rhs type is derived from the 1252: lhs type, then we may still do a conversion. */ 1253: if (IS_AGGR_TYPE_CODE (code)) 1254: { 1255: tree dtype = TREE_TYPE (e); 1256: 1257: if (TREE_CODE (dtype) == REFERENCE_TYPE) 1258: { 1259: e = convert_from_reference (e); 1260: dtype = TREE_TYPE (e); 1261: } 1262: dtype = TYPE_MAIN_VARIANT (dtype); 1263: 1264: /* Conversion between aggregate types. New C++ semantics allow 1265: objects of derived type to be cast to objects of base type. 1.1.1.2 root 1266: Old semantics only allowed this between pointers. 1.1 root 1267: 1268: There may be some ambiguity between using a constructor 1269: vs. using a type conversion operator when both apply. */ 1270: 1271: if (IS_AGGR_TYPE (dtype)) 1272: { 1273: tree binfo; 1274: 1275: tree conversion = TYPE_HAS_CONVERSION (dtype) 1276: ? build_type_conversion (CONVERT_EXPR, type, e, 1) : NULL_TREE; 1277: 1278: if (TYPE_HAS_CONSTRUCTOR (type)) 1279: { 1.1.1.6 ! root 1280: tree rval = build_method_call (NULL_TREE, constructor_name_full (type), 1.1.1.4 root 1281: build_tree_list (NULL_TREE, e), 1282: TYPE_BINFO (type), 1.1 root 1283: conversion ? LOOKUP_NO_CONVERSION : 0); 1284: 1285: if (rval != error_mark_node) 1286: { 1287: if (conversion) 1288: { 1289: error ("both constructor and type conversion operator apply"); 1290: return error_mark_node; 1291: } 1292: /* call to constructor successful. */ 1293: rval = build_cplus_new (type, rval, 0); 1294: return rval; 1295: } 1296: } 1297: /* Type conversion successful/applies. */ 1298: if (conversion) 1299: { 1300: if (conversion == error_mark_node) 1301: error ("ambiguous pointer conversion"); 1302: return conversion; 1303: } 1304: 1305: /* now try normal C++ assignment semantics. */ 1306: binfo = TYPE_BINFO (dtype); 1307: if (BINFO_TYPE (binfo) == type 1308: || (binfo = get_binfo (type, dtype, 1))) 1309: { 1310: if (binfo == error_mark_node) 1311: return error_mark_node; 1312: } 1313: if (binfo != NULL_TREE) 1314: { 1315: if (lvalue_p (e)) 1316: { 1317: e = build_unary_op (ADDR_EXPR, e, 0); 1318: 1319: if (! BINFO_OFFSET_ZEROP (binfo)) 1320: e = build (PLUS_EXPR, TYPE_POINTER_TO (type), 1321: e, BINFO_OFFSET (binfo)); 1322: return build1 (INDIRECT_REF, type, e); 1323: } 1324: 1325: sorry ("addressable aggregates"); 1326: return error_mark_node; 1327: } 1328: error ("conversion between incompatible aggregate types requested"); 1329: return error_mark_node; 1330: } 1331: /* conversion from non-aggregate to aggregate type requires constructor. */ 1332: else if (TYPE_HAS_CONSTRUCTOR (type)) 1333: { 1334: tree rval; 1.1.1.6 ! root 1335: tree init = build_method_call (NULL_TREE, constructor_name_full (type), 1.1.1.4 root 1336: build_tree_list (NULL_TREE, e), 1337: TYPE_BINFO (type), LOOKUP_NORMAL); 1.1 root 1338: if (init == error_mark_node) 1339: { 1.1.1.6 ! root 1340: cp_error ("in conversion to type `%T'", type); 1.1 root 1341: return error_mark_node; 1342: } 1343: rval = build_cplus_new (type, init, 0); 1344: return rval; 1345: } 1346: } 1347: 1348: /* If TYPE or TREE_TYPE (EXPR) is not on the permanent_obstack, 1349: then the it won't be hashed and hence compare as not equal, 1350: even when it is. */ 1351: if (code == ARRAY_TYPE 1352: && TREE_TYPE (TREE_TYPE (expr)) == TREE_TYPE (type) 1353: && index_type_equal (TYPE_DOMAIN (TREE_TYPE (expr)), TYPE_DOMAIN (type))) 1354: return expr; 1355: 1356: error ("conversion to non-scalar type requested"); 1357: return error_mark_node; 1358: } 1359: 1360: /* Like convert, except permit conversions to take place which 1361: are not normally allowed due to visibility restrictions 1362: (such as conversion from sub-type to private super-type). */ 1363: tree 1364: convert_force (type, expr) 1365: tree type; 1366: tree expr; 1367: { 1368: register tree e = expr; 1369: register enum tree_code code = TREE_CODE (type); 1370: 1371: if (code == REFERENCE_TYPE) 1.1.1.4 root 1372: return fold (convert_to_reference (0, type, e, 1373: NULL_TREE, -1, (char *)NULL, 1374: -1, 0)); 1.1 root 1375: else if (TREE_CODE (TREE_TYPE (e)) == REFERENCE_TYPE) 1376: e = convert_from_reference (e); 1377: 1378: if (code == POINTER_TYPE) 1379: return fold (convert_to_pointer_force (type, e)); 1380: 1381: { 1382: int old_equiv = flag_int_enum_equivalence; 1383: flag_int_enum_equivalence = 1; 1384: e = convert (type, e); 1385: flag_int_enum_equivalence = old_equiv; 1386: } 1387: return e; 1388: } 1389: 1390: /* Subroutine of build_type_conversion. */ 1391: static tree 1392: build_type_conversion_1 (xtype, basetype, expr, typename, for_sure) 1393: tree xtype, basetype; 1394: tree expr; 1395: tree typename; 1396: int for_sure; 1397: { 1398: tree first_arg = expr; 1399: tree rval; 1400: int flags; 1401: 1402: if (for_sure == 0) 1403: { 1404: if (! lvalue_p (expr)) 1405: first_arg = build1 (NOP_EXPR, TYPE_POINTER_TO (basetype), integer_zero_node); 1406: flags = LOOKUP_PROTECT; 1407: } 1408: else 1409: flags = LOOKUP_NORMAL; 1410: 1.1.1.6 ! root 1411: rval = build_method_call (first_arg, constructor_name_full (typename), 1.1.1.4 root 1412: NULL_TREE, NULL_TREE, flags); 1.1 root 1413: if (rval == error_mark_node) 1414: { 1415: if (for_sure == 0) 1416: return NULL_TREE; 1417: return error_mark_node; 1418: } 1419: if (first_arg != expr) 1420: { 1421: expr = build_up_reference (build_reference_type (TREE_TYPE (expr)), expr, 1.1.1.4 root 1422: LOOKUP_COMPLAIN, 1); 1.1 root 1423: TREE_VALUE (TREE_OPERAND (rval, 1)) = build_unary_op (ADDR_EXPR, expr, 0); 1424: } 1425: if (TREE_CODE (TREE_TYPE (rval)) == REFERENCE_TYPE 1426: && TREE_CODE (xtype) != REFERENCE_TYPE) 1427: rval = default_conversion (rval); 1428: 1429: if (pedantic 1430: && TREE_TYPE (xtype) 1431: && (TREE_READONLY (TREE_TYPE (TREE_TYPE (rval))) 1432: > TREE_READONLY (TREE_TYPE (xtype)))) 1433: pedwarn ("user-defined conversion casting away `const'"); 1434: return convert (xtype, rval); 1435: } 1436: 1437: /* Convert an aggregate EXPR to type XTYPE. If a conversion 1438: exists, return the attempted conversion. This may 1439: return ERROR_MARK_NODE if the conversion is not 1440: allowed (references private members, etc). 1441: If no conversion exists, NULL_TREE is returned. 1442: 1443: If (FOR_SURE & 1) is non-zero, then we allow this type conversion 1444: to take place immediately. Otherwise, we build a SAVE_EXPR 1445: which can be evaluated if the results are ever needed. 1446: 1447: If FOR_SURE >= 2, then we only look for exact conversions. 1448: 1449: TYPE may be a reference type, in which case we first look 1450: for something that will convert to a reference type. If 1451: that fails, we will try to look for something of the 1452: reference's target type, and then return a reference to that. */ 1453: tree 1454: build_type_conversion (code, xtype, expr, for_sure) 1455: enum tree_code code; 1456: tree xtype, expr; 1457: int for_sure; 1458: { 1459: /* C++: check to see if we can convert this aggregate type 1460: into the required scalar type. */ 1461: tree type, type_default; 1462: tree typename = build_typename_overload (xtype), *typenames; 1463: int n_variants = 0; 1464: tree basetype, save_basetype; 1465: tree rval; 1466: int exact_conversion = for_sure >= 2; 1467: for_sure &= 1; 1468: 1469: if (expr == error_mark_node) 1470: return error_mark_node; 1471: 1472: basetype = TREE_TYPE (expr); 1473: if (TREE_CODE (basetype) == REFERENCE_TYPE) 1474: basetype = TREE_TYPE (basetype); 1475: 1476: basetype = TYPE_MAIN_VARIANT (basetype); 1477: if (! TYPE_LANG_SPECIFIC (basetype) || ! TYPE_HAS_CONVERSION (basetype)) 1.1.1.6 ! root 1478: return NULL_TREE; 1.1 root 1479: 1480: if (TREE_CODE (xtype) == POINTER_TYPE 1481: || TREE_CODE (xtype) == REFERENCE_TYPE) 1482: { 1483: /* Prepare to match a variant of this type. */ 1484: type = TYPE_MAIN_VARIANT (TREE_TYPE (xtype)); 1485: for (n_variants = 0; type; type = TYPE_NEXT_VARIANT (type)) 1486: n_variants++; 1487: typenames = (tree *)alloca (n_variants * sizeof (tree)); 1488: for (n_variants = 0, type = TYPE_MAIN_VARIANT (TREE_TYPE (xtype)); 1489: type; n_variants++, type = TYPE_NEXT_VARIANT (type)) 1490: { 1491: if (type == TREE_TYPE (xtype)) 1492: typenames[n_variants] = typename; 1493: else if (TREE_CODE (xtype) == POINTER_TYPE) 1494: typenames[n_variants] = build_typename_overload (build_pointer_type (type)); 1495: else 1496: typenames[n_variants] = build_typename_overload (build_reference_type (type)); 1497: } 1498: } 1499: 1500: save_basetype = basetype; 1501: type = xtype; 1502: 1503: while (TYPE_HAS_CONVERSION (basetype)) 1504: { 1505: int i; 1506: if (lookup_fnfields (TYPE_BINFO (basetype), typename, 0)) 1507: return build_type_conversion_1 (xtype, basetype, expr, typename, for_sure); 1508: for (i = 0; i < n_variants; i++) 1509: if (typenames[i] != typename 1510: && lookup_fnfields (TYPE_BINFO (basetype), typenames[i], 0)) 1511: return build_type_conversion_1 (xtype, basetype, expr, typenames[i], for_sure); 1512: 1513: if (TYPE_BINFO_BASETYPES (basetype)) 1514: basetype = TYPE_BINFO_BASETYPE (basetype, 0); 1.1.1.6 ! root 1515: else ! 1516: break; 1.1 root 1517: } 1518: 1519: if (TREE_CODE (type) == REFERENCE_TYPE) 1520: { 1521: tree first_arg = expr; 1522: type = TYPE_MAIN_VARIANT (TREE_TYPE (type)); 1523: basetype = save_basetype; 1524: 1525: /* May need to build a temporary for this. */ 1526: while (TYPE_HAS_CONVERSION (basetype)) 1527: { 1528: if (lookup_fnfields (TYPE_BINFO (basetype), typename, 0)) 1529: { 1530: int flags; 1531: 1532: if (for_sure == 0) 1533: { 1534: if (! lvalue_p (expr)) 1535: first_arg = build1 (NOP_EXPR, TYPE_POINTER_TO (basetype), integer_zero_node); 1536: flags = LOOKUP_PROTECT; 1537: } 1538: else 1539: flags = LOOKUP_NORMAL; 1.1.1.6 ! root 1540: rval = build_method_call (first_arg, constructor_name_full (typename), 1.1.1.4 root 1541: NULL_TREE, NULL_TREE, flags); 1.1 root 1542: if (rval == error_mark_node) 1543: { 1544: if (for_sure == 0) 1545: return NULL_TREE; 1546: return error_mark_node; 1547: } 1548: TREE_VALUE (TREE_OPERAND (rval, 1)) = expr; 1549: 1550: if (IS_AGGR_TYPE (type)) 1551: { 1.1.1.4 root 1552: tree init = build_method_call (NULL_TREE, 1.1.1.6 ! root 1553: constructor_name_full (type), 1.1.1.4 root 1554: build_tree_list (NULL_TREE, rval), NULL_TREE, LOOKUP_NORMAL); 1.1 root 1555: tree temp = build_cplus_new (type, init, 1); 1556: return build_up_reference (TYPE_REFERENCE_TO (type), temp, 1.1.1.4 root 1557: LOOKUP_COMPLAIN, 1); 1.1 root 1558: } 1559: return convert (xtype, rval); 1560: } 1561: if (TYPE_BINFO_BASETYPES (basetype)) 1562: basetype = TYPE_BINFO_BASETYPE (basetype, 0); 1.1.1.6 ! root 1563: else ! 1564: break; 1.1 root 1565: } 1566: /* No free conversions for reference types, right?. */ 1567: return NULL_TREE; 1568: } 1569: 1570: if (exact_conversion) 1571: return NULL_TREE; 1572: 1573: /* No perfect match found, try default. */ 1574: if (code == CONVERT_EXPR && TREE_CODE (type) == POINTER_TYPE) 1575: type_default = ptr_type_node; 1576: else if (type == void_type_node) 1577: return NULL_TREE; 1578: else 1579: { 1580: tree tmp = default_conversion (build1 (NOP_EXPR, type, integer_zero_node)); 1581: if (tmp == error_mark_node) 1582: return NULL_TREE; 1583: type_default = TREE_TYPE (tmp); 1584: } 1585: 1586: basetype = save_basetype; 1587: 1588: if (type_default != type) 1589: { 1590: type = type_default; 1591: typename = build_typename_overload (type); 1592: 1593: while (TYPE_HAS_CONVERSION (basetype)) 1594: { 1595: if (lookup_fnfields (TYPE_BINFO (basetype), typename, 0)) 1596: return build_type_conversion_1 (xtype, basetype, expr, typename, for_sure); 1597: if (TYPE_BINFO_BASETYPES (basetype)) 1598: basetype = TYPE_BINFO_BASETYPE (basetype, 0); 1.1.1.6 ! root 1599: else ! 1600: break; 1.1 root 1601: } 1602: } 1603: 1604: try_pointer: 1605: 1606: if (type == ptr_type_node) 1607: { 1608: /* Try converting to some other pointer type 1609: with which void* is compatible, or in situations 1610: in which void* is appropriate (such as &&,||, and !). */ 1611: 1612: while (TYPE_HAS_CONVERSION (basetype)) 1613: { 1614: if (CLASSTYPE_CONVERSION (basetype, ptr_conv) != 0) 1615: { 1616: if (CLASSTYPE_CONVERSION (basetype, ptr_conv) == error_mark_node) 1617: return error_mark_node; 1618: typename = DECL_NAME (CLASSTYPE_CONVERSION (basetype, ptr_conv)); 1619: return build_type_conversion_1 (xtype, basetype, expr, typename, for_sure); 1620: } 1621: if (TYPE_BINFO_BASETYPES (basetype)) 1622: basetype = TYPE_BINFO_BASETYPE (basetype, 0); 1.1.1.6 ! root 1623: else ! 1624: break; 1.1 root 1625: } 1626: } 1627: if (TREE_CODE (type) == POINTER_TYPE 1628: && TYPE_READONLY (TREE_TYPE (type)) 1629: && TYPE_MAIN_VARIANT (TREE_TYPE (type)) == void_type_node) 1630: { 1631: /* Try converting to some other pointer type 1632: with which const void* is compatible. */ 1633: 1634: while (TYPE_HAS_CONVERSION (basetype)) 1635: { 1636: if (CLASSTYPE_CONVERSION (basetype, constptr_conv) != 0) 1637: { 1638: if (CLASSTYPE_CONVERSION (basetype, constptr_conv) == error_mark_node) 1639: return error_mark_node; 1640: typename = DECL_NAME (CLASSTYPE_CONVERSION (basetype, constptr_conv)); 1641: return build_type_conversion_1 (xtype, basetype, expr, typename, for_sure); 1642: } 1643: if (TYPE_BINFO_BASETYPES (basetype)) 1644: basetype = TYPE_BINFO_BASETYPE (basetype, 0); 1.1.1.6 ! root 1645: else ! 1646: break; 1.1 root 1647: } 1648: } 1649: /* Use the longer or shorter conversion that is appropriate. Have 1650: to check against 0 because the conversion may come from a baseclass. */ 1651: if (TREE_CODE (type) == INTEGER_TYPE 1652: && TYPE_HAS_INT_CONVERSION (basetype) 1653: && CLASSTYPE_CONVERSION (basetype, int_conv) != 0 1654: && CLASSTYPE_CONVERSION (basetype, int_conv) != error_mark_node) 1655: { 1656: typename = DECL_NAME (CLASSTYPE_CONVERSION (basetype, int_conv)); 1657: return build_type_conversion_1 (xtype, basetype, expr, typename, for_sure); 1658: } 1.1.1.6 ! root 1659: 1.1 root 1660: if (TREE_CODE (type) == REAL_TYPE 1661: && TYPE_HAS_REAL_CONVERSION (basetype) 1662: && CLASSTYPE_CONVERSION (basetype, real_conv) != 0 1663: && CLASSTYPE_CONVERSION (basetype, real_conv) != error_mark_node) 1664: { 1.1.1.6 ! root 1665: /* Only accept using an operator double() if there isn't a conflicting ! 1666: operator int(). */ ! 1667: if (flag_ansi_overloading && TYPE_HAS_INT_CONVERSION (basetype)) ! 1668: { ! 1669: error ("two possible conversions for type `%s'", ! 1670: TYPE_NAME_STRING (type)); ! 1671: return error_mark_node; ! 1672: } ! 1673: 1.1 root 1674: typename = DECL_NAME (CLASSTYPE_CONVERSION (basetype, real_conv)); 1675: return build_type_conversion_1 (xtype, basetype, expr, typename, for_sure); 1676: } 1677: 1678: /* THIS IS A KLUDGE. */ 1679: if (TREE_CODE (type) != POINTER_TYPE 1680: && (code == TRUTH_ANDIF_EXPR 1681: || code == TRUTH_ORIF_EXPR 1682: || code == TRUTH_NOT_EXPR)) 1683: { 1684: /* Here's when we can convert to a pointer. */ 1685: type = ptr_type_node; 1686: goto try_pointer; 1687: } 1688: 1689: /* THESE ARE TOTAL KLUDGES. */ 1690: /* Default promotion yields no new alternatives, try 1691: conversions which are anti-default, such as 1692: 1693: double -> float or int -> unsigned or unsigned -> long 1694: 1695: */ 1.1.1.3 root 1696: if (type_default == type 1697: && (TREE_CODE (type) == INTEGER_TYPE || TREE_CODE (type) == REAL_TYPE)) 1.1 root 1698: { 1699: int not_again = 0; 1700: 1701: if (type == double_type_node) 1702: typename = build_typename_overload (float_type_node); 1703: else if (type == integer_type_node) 1704: typename = build_typename_overload (unsigned_type_node); 1705: else if (type == unsigned_type_node) 1706: typename = build_typename_overload (long_integer_type_node); 1707: 1708: again: 1709: basetype = save_basetype; 1710: while (TYPE_HAS_CONVERSION (basetype)) 1711: { 1712: if (lookup_fnfields (TYPE_BINFO (basetype), typename, 0)) 1713: return build_type_conversion_1 (xtype, basetype, expr, typename, for_sure); 1714: if (TYPE_BINFO_BASETYPES (basetype)) 1715: basetype = TYPE_BINFO_BASETYPE (basetype, 0); 1.1.1.6 ! root 1716: else ! 1717: break; 1.1 root 1718: } 1.1.1.2 root 1719: if (! not_again) 1.1 root 1720: { 1.1.1.2 root 1721: if (type == integer_type_node) 1722: { 1723: typename = build_typename_overload (long_integer_type_node); 1724: not_again = 1; 1725: goto again; 1726: } 1727: else 1728: { 1729: typename = build_typename_overload (integer_type_node); 1730: not_again = 1; 1731: goto again; 1732: } 1.1 root 1733: } 1734: } 1735: 1736: /* Now, try C promotions... 1737: 1738: float -> int 1739: int -> float, void * 1740: void * -> int 1741: 1742: Truthvalue conversions let us try to convert 1743: to pointer if we were going for int, and to int 1744: if we were looking for pointer. */ 1745: 1746: basetype = save_basetype; 1747: if (TREE_CODE (type) == REAL_TYPE 1748: || (TREE_CODE (type) == POINTER_TYPE 1749: && (code == TRUTH_ANDIF_EXPR 1750: || code == TRUTH_ORIF_EXPR 1751: || code == TRUTH_NOT_EXPR))) 1752: type = integer_type_node; 1753: else if (TREE_CODE (type) == INTEGER_TYPE) 1754: if (TYPE_HAS_REAL_CONVERSION (basetype)) 1755: type = double_type_node; 1756: else 1757: return NULL_TREE; 1758: else 1759: return NULL_TREE; 1760: 1761: typename = build_typename_overload (type); 1762: while (TYPE_HAS_CONVERSION (basetype)) 1763: { 1764: if (lookup_fnfields (TYPE_BINFO (basetype), typename, 0)) 1765: { 1766: rval = build_type_conversion_1 (xtype, basetype, expr, typename, for_sure); 1767: return rval; 1768: } 1769: if (TYPE_BINFO_BASETYPES (basetype)) 1770: basetype = TYPE_BINFO_BASETYPE (basetype, 0); 1771: else 1772: break; 1773: } 1774: 1775: return NULL_TREE; 1776: } 1777: 1778: /* Must convert two aggregate types to non-aggregate type. 1779: Attempts to find a non-ambiguous, "best" type conversion. 1780: 1781: Return 1 on success, 0 on failure. 1782: 1783: @@ What are the real semantics of this supposed to be??? */ 1784: int 1785: build_default_binary_type_conversion (code, arg1, arg2) 1786: enum tree_code code; 1787: tree *arg1, *arg2; 1788: { 1789: tree type1 = TREE_TYPE (*arg1); 1790: tree type2 = TREE_TYPE (*arg2); 1791: char *name1, *name2; 1792: 1.1.1.6 ! root 1793: if (TREE_CODE (type1) == REFERENCE_TYPE ! 1794: || TREE_CODE (type1) == POINTER_TYPE) 1.1 root 1795: type1 = TREE_TYPE (type1); 1.1.1.6 ! root 1796: if (TREE_CODE (type2) == REFERENCE_TYPE ! 1797: || TREE_CODE (type2) == POINTER_TYPE) 1.1 root 1798: type2 = TREE_TYPE (type2); 1799: 1800: if (TREE_CODE (TYPE_NAME (type1)) != TYPE_DECL) 1801: { 1802: tree decl = typedecl_for_tag (type1); 1803: if (decl) 1.1.1.2 root 1804: error ("type conversion nonexistent for type `%s'", 1.1 root 1805: IDENTIFIER_POINTER (DECL_NAME (decl))); 1806: else 1.1.1.2 root 1807: error ("type conversion nonexistent for non-C++ type"); 1.1 root 1808: return 0; 1809: } 1810: if (TREE_CODE (TYPE_NAME (type2)) != TYPE_DECL) 1811: { 1812: tree decl = typedecl_for_tag (type2); 1813: if (decl) 1.1.1.2 root 1814: error ("type conversion nonexistent for type `%s'", 1.1 root 1815: IDENTIFIER_POINTER (decl)); 1816: else 1.1.1.2 root 1817: error ("type conversion nonexistent for non-C++ type"); 1.1 root 1818: return 0; 1819: } 1820: 1821: name1 = TYPE_NAME_STRING (type1); 1822: name2 = TYPE_NAME_STRING (type2); 1823: 1824: if (!IS_AGGR_TYPE (type1) || !TYPE_HAS_CONVERSION (type1)) 1825: { 1826: if (!IS_AGGR_TYPE (type2) || !TYPE_HAS_CONVERSION (type2)) 1827: error ("type conversion required for binary operation on types `%s' and `%s'", 1828: name1, name2); 1829: else 1830: error ("type conversion required for type `%s'", name1); 1831: return 0; 1832: } 1833: else if (!IS_AGGR_TYPE (type2) || !TYPE_HAS_CONVERSION (type2)) 1834: { 1835: error ("type conversion required for type `%s'", name2); 1836: return 0; 1837: } 1838: 1839: if (TYPE_HAS_INT_CONVERSION (type1) && TYPE_HAS_REAL_CONVERSION (type1)) 1840: warning ("ambiguous type conversion for type `%s', defaulting to int", name1); 1841: if (TYPE_HAS_INT_CONVERSION (type1)) 1842: { 1843: *arg1 = build_type_conversion (code, integer_type_node, *arg1, 1); 1844: *arg2 = build_type_conversion (code, integer_type_node, *arg2, 1); 1845: } 1846: else if (TYPE_HAS_REAL_CONVERSION (type1)) 1847: { 1848: *arg1 = build_type_conversion (code, double_type_node, *arg1, 1); 1849: *arg2 = build_type_conversion (code, double_type_node, *arg2, 1); 1850: } 1851: else 1852: { 1853: *arg1 = build_type_conversion (code, ptr_type_node, *arg1, 1); 1854: if (*arg1 == error_mark_node) 1855: error ("ambiguous pointer conversion"); 1856: *arg2 = build_type_conversion (code, ptr_type_node, *arg2, 1); 1857: if (*arg1 != error_mark_node && *arg2 == error_mark_node) 1858: error ("ambiguous pointer conversion"); 1859: } 1860: if (*arg1 == 0) 1861: { 1862: if (*arg2 == 0 && type1 != type2) 1863: error ("default type conversion for types `%s' and `%s' failed", 1864: name1, name2); 1865: else 1866: error ("default type conversion for type `%s' failed", name1); 1867: return 0; 1868: } 1869: else if (*arg2 == 0) 1870: { 1871: error ("default type conversion for type `%s' failed", name2); 1872: return 0; 1873: } 1874: return 1; 1875: } 1876: 1877: /* Must convert two aggregate types to non-aggregate type. 1878: Attempts to find a non-ambiguous, "best" type conversion. 1879: 1880: Return 1 on success, 0 on failure. 1881: 1882: The type of the argument is expected to be of aggregate type here. 1883: 1884: @@ What are the real semantics of this supposed to be??? */ 1885: int 1886: build_default_unary_type_conversion (code, arg) 1887: enum tree_code code; 1888: tree *arg; 1889: { 1890: tree type = TREE_TYPE (*arg); 1891: tree id = TREE_CODE (TYPE_NAME (type)) == TYPE_DECL 1892: ? TYPE_IDENTIFIER (type) : TYPE_NAME (type); 1893: char *name = IDENTIFIER_POINTER (id); 1894: 1895: if (! TYPE_HAS_CONVERSION (type)) 1896: { 1897: error ("type conversion required for type `%s'", name); 1898: return 0; 1899: } 1900: 1901: if (TYPE_HAS_INT_CONVERSION (type) && TYPE_HAS_REAL_CONVERSION (type)) 1.1.1.6 ! root 1902: warning ("ambiguous type conversion for type `%s', defaulting to int", ! 1903: name); 1.1 root 1904: if (TYPE_HAS_INT_CONVERSION (type)) 1905: *arg = build_type_conversion (code, integer_type_node, *arg, 1); 1906: else if (TYPE_HAS_REAL_CONVERSION (type)) 1907: *arg = build_type_conversion (code, double_type_node, *arg, 1); 1908: else 1909: { 1910: *arg = build_type_conversion (code, ptr_type_node, *arg, 1); 1911: if (*arg == error_mark_node) 1912: error ("ambiguous pointer conversion"); 1913: } 1.1.1.6 ! root 1914: if (*arg == NULL_TREE) 1.1 root 1915: { 1916: error ("default type conversion for type `%s' failed", name); 1917: return 0; 1918: } 1919: return 1; 1920: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.