tree
convert (tree type, tree expr)
{
tree e = expr;
enum tree_code code = TREE_CODE (type);
const char *invalid_conv_diag;
tree ret;
location_t loc = EXPR_LOCATION (expr);
if (type == error_mark_node
|| expr == error_mark_node
|| TREE_TYPE (expr) == error_mark_node)
return error_mark_node;
if ((invalid_conv_diag
= targetm.invalid_conversion (TREE_TYPE (expr), type)))
{
error ("%s", invalid_conv_diag);
return error_mark_node;
}
if (type == TREE_TYPE (expr))
return expr;
ret = targetm.convert_to_type (type, expr);
if (ret)
return ret;
STRIP_TYPE_NOPS (e);
if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (expr)))
return fold_convert_loc (loc, type, expr);
if (TREE_CODE (TREE_TYPE (expr)) == ERROR_MARK)
return error_mark_node;
if (TREE_CODE (TREE_TYPE (expr)) == VOID_TYPE)
{
error ("void value not ignored as it ought to be");
return error_mark_node;
}
switch (code)
{
case VOID_TYPE:
return fold_convert_loc (loc, type, e);
case INTEGER_TYPE:
case ENUMERAL_TYPE:
ret = convert_to_integer (type, e);
goto maybe_fold;
case BOOLEAN_TYPE:
return fold_convert_loc
(loc, type, c_objc_common_truthvalue_conversion (input_location, expr));
case POINTER_TYPE:
case REFERENCE_TYPE:
ret = convert_to_pointer (type, e);
goto maybe_fold;
case REAL_TYPE:
ret = convert_to_real (type, e);
goto maybe_fold;
case FIXED_POINT_TYPE:
ret = convert_to_fixed (type, e);
goto maybe_fold;
case COMPLEX_TYPE:
/* If converting from COMPLEX_TYPE to a different COMPLEX_TYPE
and e is not COMPLEX_EXPR, convert_to_complex uses save_expr,
but for the C FE c_save_expr needs to be called instead. */
if (TREE_CODE (TREE_TYPE (e)) == COMPLEX_TYPE)
{
tree subtype = TREE_TYPE (type);
tree elt_type = TREE_TYPE (TREE_TYPE (e));
if (TYPE_MAIN_VARIANT (elt_type) != TYPE_MAIN_VARIANT (subtype)
&& TREE_CODE (e) != COMPLEX_EXPR)
{
if (in_late_binary_op)
e = save_expr (e);
else
e = c_save_expr (e);
ret
= fold_build2 (COMPLEX_EXPR, type,
convert (subtype,
fold_build1 (REALPART_EXPR,
elt_type, e)),
convert (subtype,
fold_build1 (IMAGPART_EXPR,
elt_type, e)));
goto maybe_fold;
}
}
ret = convert_to_complex (type, e);
goto maybe_fold;
case VECTOR_TYPE:
ret = convert_to_vector (type, e);
goto maybe_fold;
case RECORD_TYPE:
case UNION_TYPE:
if (lang_hooks.types_compatible_p (type, TREE_TYPE (expr)))
return e;
break;
default:
break;
maybe_fold:
if (TREE_CODE (ret) != C_MAYBE_CONST_EXPR)
ret = fold (ret);
return ret;
}
error ("conversion to non-scalar type requested");
return error_mark_node;
}
tree
convert (tree type, tree expr)
{
tree e = expr;
enum tree_code code = TREE_CODE (type);
const char *invalid_conv_diag;
tree ret;
location_t loc = EXPR_LOCATION (expr);
if (type == error_mark_node
|| expr == error_mark_node
|| TREE_TYPE (expr) == error_mark_node)
return error_mark_node;
if ((invalid_conv_diag
= targetm.invalid_conversion (TREE_TYPE (expr), type)))
{
error (invalid_conv_diag);
return error_mark_node;
}
if (type == TREE_TYPE (expr))
return expr;
ret = targetm.convert_to_type (type, expr);
if (ret)
return ret;
STRIP_TYPE_NOPS (e);
if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (expr)))
return fold_convert_loc (loc, type, expr);
if (TREE_CODE (TREE_TYPE (expr)) == ERROR_MARK)
return error_mark_node;
if (TREE_CODE (TREE_TYPE (expr)) == VOID_TYPE)
{
error ("void value not ignored as it ought to be");
return error_mark_node;
}
switch (code)
{
case VOID_TYPE:
return fold_convert_loc (loc, type, e);
case INTEGER_TYPE:
case ENUMERAL_TYPE:
ret = convert_to_integer (type, e);
goto maybe_fold;
case BOOLEAN_TYPE:
return fold_convert_loc
(loc, type, c_objc_common_truthvalue_conversion (input_location, expr));
case POINTER_TYPE:
case REFERENCE_TYPE:
ret = convert_to_pointer (type, e);
goto maybe_fold;
case REAL_TYPE:
ret = convert_to_real (type, e);
goto maybe_fold;
case FIXED_POINT_TYPE:
ret = convert_to_fixed (type, e);
goto maybe_fold;
case COMPLEX_TYPE:
ret = convert_to_complex (type, e);
goto maybe_fold;
case VECTOR_TYPE:
ret = convert_to_vector (type, e);
goto maybe_fold;
case RECORD_TYPE:
case UNION_TYPE:
if (lang_hooks.types_compatible_p (type, TREE_TYPE (expr)))
return e;
break;
default:
break;
maybe_fold:
if (TREE_CODE (ret) != C_MAYBE_CONST_EXPR)
ret = fold (ret);
return ret;
}
error ("conversion to non-scalar type requested");
return error_mark_node;
}
tree
ocp_convert (tree type, tree expr, int convtype, int flags)
{
tree e = expr;
enum tree_code code = TREE_CODE (type);
if (error_operand_p (e) || type == error_mark_node)
return error_mark_node;
complete_type (type);
complete_type (TREE_TYPE (expr));
e = decl_constant_value (e);
if (IS_AGGR_TYPE (type) && (convtype & CONV_FORCE_TEMP)
/* Some internal structures (vtable_entry_type, sigtbl_ptr_type)
don't go through finish_struct, so they don't have the synthesized
constructors. So don't force a temporary. */
&& TYPE_HAS_CONSTRUCTOR (type))
/* We need a new temporary; don't take this shortcut. */;
else if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (e)))
{
if (same_type_p (type, TREE_TYPE (e)))
/* The call to fold will not always remove the NOP_EXPR as
might be expected, since if one of the types is a typedef;
the comparison in fold is just equality of pointers, not a
call to comptypes. We don't call fold in this case because
that can result in infinite recursion; fold will call
convert, which will call ocp_convert, etc. */
return e;
/* For complex data types, we need to perform componentwise
conversion. */
else if (TREE_CODE (type) == COMPLEX_TYPE)
return fold (convert_to_complex (type, e));
else if (TREE_CODE (e) == TARGET_EXPR)
{
/* Don't build a NOP_EXPR of class type. Instead, change the
type of the temporary. Only allow this for cv-qual changes,
though. */
if (!same_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (e)),
TYPE_MAIN_VARIANT (type)))
abort ();
TREE_TYPE (e) = TREE_TYPE (TARGET_EXPR_SLOT (e)) = type;
return e;
}
else if (TREE_ADDRESSABLE (type))
/* We shouldn't be treating objects of ADDRESSABLE type as rvalues. */
abort ();
else
return fold (build1 (NOP_EXPR, type, e));
}
if (code == VOID_TYPE && (convtype & CONV_STATIC))
{
e = convert_to_void (e, /*implicit=*/NULL);
return e;
}
if (INTEGRAL_CODE_P (code))
{
tree intype = TREE_TYPE (e);
/* enum = enum, enum = int, enum = float, (enum)pointer are all
errors. */
if (TREE_CODE (type) == ENUMERAL_TYPE
&& ((ARITHMETIC_TYPE_P (intype) && ! (convtype & CONV_STATIC))
|| (TREE_CODE (intype) == POINTER_TYPE)))
{
pedwarn ("conversion from `%#T' to `%#T'", intype, type);
if (flag_pedantic_errors)
return error_mark_node;
}
if (IS_AGGR_TYPE (intype))
{
tree rval;
rval = build_type_conversion (type, e);
if (rval)
return rval;
if (flags & LOOKUP_COMPLAIN)
error ("`%#T' used where a `%T' was expected", intype, type);
if (flags & LOOKUP_SPECULATIVELY)
return NULL_TREE;
return error_mark_node;
}
if (code == BOOLEAN_TYPE)
return cp_truthvalue_conversion (e);
return fold (convert_to_integer (type, e));
}
if (POINTER_TYPE_P (type) || TYPE_PTR_TO_MEMBER_P (type))
return fold (cp_convert_to_pointer (type, e, false));
if (code == VECTOR_TYPE)
return fold (convert_to_vector (type, e));
if (code == REAL_TYPE || code == COMPLEX_TYPE)
{
if (IS_AGGR_TYPE (TREE_TYPE (e)))
{
tree rval;
rval = build_type_conversion (type, e);
if (rval)
return rval;
else
if (flags & LOOKUP_COMPLAIN)
error ("`%#T' used where a floating point value was expected",
TREE_TYPE (e));
}
if (code == REAL_TYPE)
return fold (convert_to_real (type, e));
else if (code == COMPLEX_TYPE)
return fold (convert_to_complex (type, e));
}
/* New C++ semantics: since assignment is now based on
memberwise copying, if the rhs type is derived from the
lhs type, then we may still do a conversion. */
if (IS_AGGR_TYPE_CODE (code))
{
tree dtype = TREE_TYPE (e);
tree ctor = NULL_TREE;
dtype = TYPE_MAIN_VARIANT (dtype);
/* Conversion between aggregate types. New C++ semantics allow
objects of derived type to be cast to objects of base type.
Old semantics only allowed this between pointers.
There may be some ambiguity between using a constructor
vs. using a type conversion operator when both apply. */
ctor = e;
if (abstract_virtuals_error (NULL_TREE, type))
return error_mark_node;
if ((flags & LOOKUP_ONLYCONVERTING)
&& ! (IS_AGGR_TYPE (dtype) && DERIVED_FROM_P (type, dtype)))
/* For copy-initialization, first we create a temp of the proper type
with a user-defined conversion sequence, then we direct-initialize
the target with the temp (see [dcl.init]). */
ctor = build_user_type_conversion (type, ctor, flags);
else
ctor = build_special_member_call (NULL_TREE,
complete_ctor_identifier,
build_tree_list (NULL_TREE, ctor),
TYPE_BINFO (type), flags);
if (ctor)
return build_cplus_new (type, ctor);
}
if (flags & LOOKUP_COMPLAIN)
error ("conversion from `%T' to non-scalar type `%T' requested",
TREE_TYPE (expr), type);
if (flags & LOOKUP_SPECULATIVELY)
return NULL_TREE;
return error_mark_node;
}
tree
convert (tree type, tree expr)
{
tree e = expr;
enum tree_code code = TREE_CODE (type);
const char *invalid_conv_diag;
tree ret;
location_t loc = EXPR_LOCATION (expr);
if (type == error_mark_node
|| error_operand_p (expr))
return error_mark_node;
if ((invalid_conv_diag
= targetm.invalid_conversion (TREE_TYPE (expr), type)))
{
error (invalid_conv_diag);
return error_mark_node;
}
if (type == TREE_TYPE (expr))
return expr;
ret = targetm.convert_to_type (type, expr);
if (ret)
return ret;
STRIP_TYPE_NOPS (e);
if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (expr))
&& (TREE_CODE (TREE_TYPE (expr)) != COMPLEX_TYPE
|| TREE_CODE (e) == COMPLEX_EXPR))
return fold_convert_loc (loc, type, expr);
if (TREE_CODE (TREE_TYPE (expr)) == ERROR_MARK)
return error_mark_node;
if (TREE_CODE (TREE_TYPE (expr)) == VOID_TYPE)
{
error ("void value not ignored as it ought to be");
return error_mark_node;
}
switch (code)
{
case VOID_TYPE:
return fold_convert_loc (loc, type, e);
case INTEGER_TYPE:
case ENUMERAL_TYPE:
if (flag_sanitize & SANITIZE_FLOAT_CAST
&& TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
&& COMPLETE_TYPE_P (type)
&& current_function_decl != NULL_TREE
&& !lookup_attribute ("no_sanitize_undefined",
DECL_ATTRIBUTES (current_function_decl)))
{
tree arg;
if (in_late_binary_op)
{
expr = save_expr (expr);
arg = expr;
}
else
{
expr = c_save_expr (expr);
arg = c_fully_fold (expr, false, NULL);
}
tree check = ubsan_instrument_float_cast (loc, type, expr, arg);
expr = fold_build1 (FIX_TRUNC_EXPR, type, expr);
if (check == NULL)
return expr;
return fold_build2 (COMPOUND_EXPR, TREE_TYPE (expr), check, expr);
}
ret = convert_to_integer (type, e);
goto maybe_fold;
case BOOLEAN_TYPE:
return fold_convert_loc
(loc, type, c_objc_common_truthvalue_conversion (input_location, expr));
case POINTER_TYPE:
case REFERENCE_TYPE:
ret = convert_to_pointer (type, e);
goto maybe_fold;
case REAL_TYPE:
ret = convert_to_real (type, e);
goto maybe_fold;
case FIXED_POINT_TYPE:
ret = convert_to_fixed (type, e);
goto maybe_fold;
case COMPLEX_TYPE:
/* If converting from COMPLEX_TYPE to a different COMPLEX_TYPE
and e is not COMPLEX_EXPR, convert_to_complex uses save_expr,
but for the C FE c_save_expr needs to be called instead. */
if (TREE_CODE (TREE_TYPE (e)) == COMPLEX_TYPE)
{
if (TREE_CODE (e) != COMPLEX_EXPR)
{
tree subtype = TREE_TYPE (type);
tree elt_type = TREE_TYPE (TREE_TYPE (e));
if (in_late_binary_op)
e = save_expr (e);
else
e = c_save_expr (e);
ret
= fold_build2_loc (loc, COMPLEX_EXPR, type,
convert (subtype,
fold_build1 (REALPART_EXPR,
elt_type, e)),
convert (subtype,
fold_build1 (IMAGPART_EXPR,
elt_type, e)));
goto maybe_fold;
}
}
ret = convert_to_complex (type, e);
goto maybe_fold;
case VECTOR_TYPE:
ret = convert_to_vector (type, e);
goto maybe_fold;
case RECORD_TYPE:
case UNION_TYPE:
if (lang_hooks.types_compatible_p (type, TREE_TYPE (expr)))
return e;
break;
default:
break;
maybe_fold:
if (TREE_CODE (ret) != C_MAYBE_CONST_EXPR)
ret = fold (ret);
return ret;
}
error ("conversion to non-scalar type requested");
return error_mark_node;
}
/** Convert to a \e complex_array data type
Converts a string to a \e complex_array data type property.
@return 1 on success, 0 on failure, -1 if conversion was incomplete
**/
int convert_to_complex_array(const char *buffer, void *data, PROPERTY *prop)
{
complex_array *a=(complex_array*)data;
unsigned row=0, col=0;
const char *p = buffer;
/* new array */
/* parse input */
for ( p=buffer ; *p!='\0' ; )
{
char value[256];
char objectname[64], propertyname[64];
complex c;
while ( *p!='\0' && isspace(*p) ) p++; /* skip spaces */
if ( *p!='\0' && sscanf(p,"%s",value)==1 )
{
if ( *p==';' ) /* end row */
{
row++;
col=0;
p++;
continue;
}
else if ( strnicmp(p,"NAN",3)==0 ) /* NULL value */
{
a->grow_to(row,col);
a->clr_at(row,col);
col++;
}
else if ( convert_to_complex(value,(void*)&c,prop) ) /* probably real value */
{
a->grow_to(row,col);
a->set_at(row,col,c);
col++;
}
else if ( sscanf(value,"%[^.].%[^; \t]",objectname,propertyname)==2 ) /* object property */
{
OBJECT *obj = object_find_name(objectname);
PROPERTY *prop;
if ( obj==NULL )
{
output_error("convert_to_double_array(const char *buffer='%10s...',...): entry at row %d, col %d - object '%s' not found", buffer,row,col,objectname);
return 0;
}
prop = object_get_property(obj,propertyname,NULL);
if ( prop==NULL )
{
output_error("convert_to_double_array(const char *buffer='%10s...',...): entry at row %d, col %d - property '%s' not found in object '%s'", buffer,row,col,propertyname,objectname);
return 0;
}
a->grow_to(row,col);
a->set_at(row,col,object_get_complex(obj,prop));
if ( a->is_nan(row,col) )
{
output_error("convert_to_double_array(const char *buffer='%10s...',...): entry at row %d, col %d property '%s' in object '%s' is not accessible", buffer,row,col,propertyname,objectname);
return 0;
}
col++;
}
else if ( sscanf(value,"%[^; \t]",propertyname)==1 ) /* object property */
{
GLOBALVAR *var = global_find(propertyname);
if ( var==NULL )
{
output_error("convert_to_double_array(const char *buffer='%10s...',...): entry at row %d, col %d global '%s' not found", buffer,row,col,propertyname);
return 0;
}
a->grow_to(row,col);
a->set_at(row,col,(complex*)var->prop->addr);
if ( a->is_nan(row,col) )
{
output_error("convert_to_double_array(const char *buffer='%10s...',...): entry at row %d, col %d property '%s' in object '%s' is not accessible", buffer,row,col,propertyname,objectname);
return 0;
}
col++;
}
else /* not a valid entry */
{
output_error("convert_to_double_array(const char *buffer='%10s...',...): entry at row %d, col %d is not valid (value='%10s')", buffer,row,col,p);
return 0;
}
while ( *p!='\0' && !isspace(*p) && *p!=';' ) p++; /* skip characters just parsed */
}
}
return 1;
}
tree
ocp_convert (tree type, tree expr, int convtype, int flags)
{
tree e = expr;
enum tree_code code = TREE_CODE (type);
const char *invalid_conv_diag;
tree e1;
if (error_operand_p (e) || type == error_mark_node)
return error_mark_node;
complete_type (type);
complete_type (TREE_TYPE (expr));
if ((invalid_conv_diag
= targetm.invalid_conversion (TREE_TYPE (expr), type)))
{
error (invalid_conv_diag);
return error_mark_node;
}
e = integral_constant_value (e);
if (error_operand_p (e))
return error_mark_node;
if (MAYBE_CLASS_TYPE_P (type) && (convtype & CONV_FORCE_TEMP))
/* We need a new temporary; don't take this shortcut. */;
else if (same_type_ignoring_top_level_qualifiers_p (type, TREE_TYPE (e)))
{
if (same_type_p (type, TREE_TYPE (e)))
/* The call to fold will not always remove the NOP_EXPR as
might be expected, since if one of the types is a typedef;
the comparison in fold is just equality of pointers, not a
call to comptypes. We don't call fold in this case because
that can result in infinite recursion; fold will call
convert, which will call ocp_convert, etc. */
return e;
/* For complex data types, we need to perform componentwise
conversion. */
else if (TREE_CODE (type) == COMPLEX_TYPE)
return fold_if_not_in_template (convert_to_complex (type, e));
else if (TREE_CODE (e) == TARGET_EXPR)
{
/* Don't build a NOP_EXPR of class type. Instead, change the
type of the temporary. */
TREE_TYPE (e) = TREE_TYPE (TARGET_EXPR_SLOT (e)) = type;
return e;
}
else
{
/* We shouldn't be treating objects of ADDRESSABLE type as
rvalues. */
gcc_assert (!TREE_ADDRESSABLE (type));
return fold_if_not_in_template (build_nop (type, e));
}
}
e1 = targetm.convert_to_type (type, e);
if (e1)
return e1;
if (code == VOID_TYPE && (convtype & CONV_STATIC))
{
e = convert_to_void (e, ICV_CAST, tf_warning_or_error);
return e;
}
if (INTEGRAL_CODE_P (code))
{
tree intype = TREE_TYPE (e);
if (TREE_CODE (type) == ENUMERAL_TYPE)
{
/* enum = enum, enum = int, enum = float, (enum)pointer are all
errors. */
if (((INTEGRAL_OR_ENUMERATION_TYPE_P (intype)
|| TREE_CODE (intype) == REAL_TYPE)
&& ! (convtype & CONV_STATIC))
|| TREE_CODE (intype) == POINTER_TYPE)
{
if (flags & LOOKUP_COMPLAIN)
permerror (input_location, "conversion from %q#T to %q#T", intype, type);
if (!flag_permissive)
return error_mark_node;
}
/* [expr.static.cast]
8. A value of integral or enumeration type can be explicitly
converted to an enumeration type. The value is unchanged if
the original value is within the range of the enumeration
values. Otherwise, the resulting enumeration value is
unspecified. */
if (TREE_CODE (expr) == INTEGER_CST
&& !int_fits_type_p (expr, ENUM_UNDERLYING_TYPE (type)))
warning (OPT_Wconversion,
"the result of the conversion is unspecified because "
"%qE is outside the range of type %qT",
expr, type);
}
if (MAYBE_CLASS_TYPE_P (intype))
{
tree rval;
rval = build_type_conversion (type, e);
if (rval)
return rval;
if (flags & LOOKUP_COMPLAIN)
error ("%q#T used where a %qT was expected", intype, type);
return error_mark_node;
}
if (code == BOOLEAN_TYPE)
return cp_truthvalue_conversion (e);
return fold_if_not_in_template (convert_to_integer (type, e));
}
if (NULLPTR_TYPE_P (type) && e && null_ptr_cst_p (e))
return nullptr_node;
if (POINTER_TYPE_P (type) || TYPE_PTR_TO_MEMBER_P (type))
return fold_if_not_in_template (cp_convert_to_pointer (type, e));
if (code == VECTOR_TYPE)
{
tree in_vtype = TREE_TYPE (e);
if (MAYBE_CLASS_TYPE_P (in_vtype))
{
tree ret_val;
ret_val = build_type_conversion (type, e);
if (ret_val)
return ret_val;
if (flags & LOOKUP_COMPLAIN)
error ("%q#T used where a %qT was expected", in_vtype, type);
return error_mark_node;
}
return fold_if_not_in_template (convert_to_vector (type, e));
}
if (code == REAL_TYPE || code == COMPLEX_TYPE)
{
if (MAYBE_CLASS_TYPE_P (TREE_TYPE (e)))
{
tree rval;
rval = build_type_conversion (type, e);
if (rval)
return rval;
else
if (flags & LOOKUP_COMPLAIN)
error ("%q#T used where a floating point value was expected",
TREE_TYPE (e));
}
if (code == REAL_TYPE)
return fold_if_not_in_template (convert_to_real (type, e));
else if (code == COMPLEX_TYPE)
return fold_if_not_in_template (convert_to_complex (type, e));
}
/* New C++ semantics: since assignment is now based on
memberwise copying, if the rhs type is derived from the
lhs type, then we may still do a conversion. */
if (RECORD_OR_UNION_CODE_P (code))
{
tree dtype = TREE_TYPE (e);
tree ctor = NULL_TREE;
dtype = TYPE_MAIN_VARIANT (dtype);
/* Conversion between aggregate types. New C++ semantics allow
objects of derived type to be cast to objects of base type.
Old semantics only allowed this between pointers.
There may be some ambiguity between using a constructor
vs. using a type conversion operator when both apply. */
ctor = e;
if (abstract_virtuals_error (NULL_TREE, type))
return error_mark_node;
if (BRACE_ENCLOSED_INITIALIZER_P (ctor))
ctor = perform_implicit_conversion (type, ctor, tf_warning_or_error);
else if ((flags & LOOKUP_ONLYCONVERTING)
&& ! (CLASS_TYPE_P (dtype) && DERIVED_FROM_P (type, dtype)))
/* For copy-initialization, first we create a temp of the proper type
with a user-defined conversion sequence, then we direct-initialize
the target with the temp (see [dcl.init]). */
ctor = build_user_type_conversion (type, ctor, flags);
else
{
VEC(tree,gc) *ctor_vec = make_tree_vector_single (ctor);
ctor = build_special_member_call (NULL_TREE,
complete_ctor_identifier,
&ctor_vec,
type, flags,
tf_warning_or_error);
release_tree_vector (ctor_vec);
}
if (ctor)
return build_cplus_new (type, ctor);
}
if (flags & LOOKUP_COMPLAIN)
{
/* If the conversion failed and expr was an invalid use of pointer to
member function, try to report a meaningful error. */
if (invalid_nonstatic_memfn_p (expr, tf_warning_or_error))
/* We displayed the error message. */;
else
error ("conversion from %qT to non-scalar type %qT requested",
TREE_TYPE (expr), type);
}
return error_mark_node;
}
tree
convert (tree type, tree expr)
{
tree e = expr;
enum tree_code code = TREE_CODE (type);
const char *invalid_conv_diag;
if (type == error_mark_node
|| expr == error_mark_node
|| TREE_TYPE (expr) == error_mark_node)
return error_mark_node;
if ((invalid_conv_diag
= targetm.invalid_conversion (TREE_TYPE (expr), type)))
{
error (invalid_conv_diag);
return error_mark_node;
}
if (type == TREE_TYPE (expr))
return expr;
if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (expr)))
return fold_build1 (NOP_EXPR, type, expr);
if (TREE_CODE (TREE_TYPE (expr)) == ERROR_MARK)
return error_mark_node;
if (TREE_CODE (TREE_TYPE (expr)) == VOID_TYPE)
{
error ("void value not ignored as it ought to be");
return error_mark_node;
}
if (code == VOID_TYPE)
return build1 (CONVERT_EXPR, type, e);
#if 0
/* This is incorrect. A truncation can't be stripped this way.
Extensions will be stripped by the use of get_unwidened. */
if (TREE_CODE (expr) == NOP_EXPR)
return convert (type, TREE_OPERAND (expr, 0));
#endif
if (code == INTEGER_TYPE || code == ENUMERAL_TYPE)
return fold (convert_to_integer (type, e));
if (code == BOOLEAN_TYPE)
{
tree t = c_objc_common_truthvalue_conversion (expr);
if (TREE_CODE (t) == ERROR_MARK)
return t;
/* If it returns a NOP_EXPR, we must fold it here to avoid
infinite recursion between fold () and convert (). */
if (TREE_CODE (t) == NOP_EXPR)
return fold_build1 (NOP_EXPR, type, TREE_OPERAND (t, 0));
else
return fold_build1 (NOP_EXPR, type, t);
}
if (code == POINTER_TYPE || code == REFERENCE_TYPE)
return fold (convert_to_pointer (type, e));
if (code == REAL_TYPE)
return fold (convert_to_real (type, e));
if (code == COMPLEX_TYPE)
return fold (convert_to_complex (type, e));
if (code == VECTOR_TYPE)
return fold (convert_to_vector (type, e));
if ((code == RECORD_TYPE || code == UNION_TYPE)
&& lang_hooks.types_compatible_p (type, TREE_TYPE (expr)))
return e;
error ("conversion to non-scalar type requested");
return error_mark_node;
}
