struct value *
value_subscript (struct value *array, LONGEST index)
{
- struct value *bound;
int c_style = current_language->c_style_arrays;
struct type *tarray;
{
struct type *range_type = TYPE_INDEX_TYPE (tarray);
LONGEST lowerbound, upperbound;
- get_discrete_bounds (range_type, &lowerbound, &upperbound);
+ get_discrete_bounds (range_type, &lowerbound, &upperbound);
if (VALUE_LVAL (array) != lval_memory)
return value_subscripted_rvalue (array, index, lowerbound);
unsigned int elt_offs = elt_size * longest_to_int (index - lowerbound);
struct value *v;
- if (index < lowerbound || elt_offs >= TYPE_LENGTH (array_type))
+ if (index < lowerbound || (!TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (array_type)
+ && elt_offs >= TYPE_LENGTH (array_type)))
error (_("no such vector element"));
v = allocate_value (elt_type);
For now, we do not overload the `=' operator. */
int
-binop_user_defined_p (enum exp_opcode op, struct value *arg1, struct value *arg2)
+binop_types_user_defined_p (enum exp_opcode op,
+ struct type *type1, struct type *type2)
{
- struct type *type1, *type2;
if (op == BINOP_ASSIGN || op == BINOP_CONCAT)
return 0;
- type1 = check_typedef (value_type (arg1));
+ type1 = check_typedef (type1);
if (TYPE_CODE (type1) == TYPE_CODE_REF)
type1 = check_typedef (TYPE_TARGET_TYPE (type1));
- type2 = check_typedef (value_type (arg2));
+ type2 = check_typedef (type1);
if (TYPE_CODE (type2) == TYPE_CODE_REF)
type2 = check_typedef (TYPE_TARGET_TYPE (type2));
|| TYPE_CODE (type2) == TYPE_CODE_STRUCT);
}
+/* Check to see if either argument is a structure, or a reference to
+ one. This is called so we know whether to go ahead with the normal
+ binop or look for a user defined function instead.
+
+ For now, we do not overload the `=' operator. */
+
+int
+binop_user_defined_p (enum exp_opcode op,
+ struct value *arg1, struct value *arg2)
+{
+ return binop_types_user_defined_p (op, value_type (arg1), value_type (arg2));
+}
+
/* Check to see if argument is a structure. This is called so
we know whether to go ahead with the normal unop or look for a
user defined function instead.
unop_user_defined_p (enum exp_opcode op, struct value *arg1)
{
struct type *type1;
+
if (op == UNOP_ADDR)
return 0;
type1 = check_typedef (value_type (arg1));
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
struct type *return_type;
+
return_type
= TYPE_TARGET_TYPE (check_typedef (value_type (argvec[0])));
return value_zero (return_type, VALUE_LVAL (arg1));
if (noside == EVAL_AVOID_SIDE_EFFECTS)
{
struct type *return_type;
+
return_type
= TYPE_TARGET_TYPE (check_typedef (value_type (argvec[0])));
return value_zero (return_type, VALUE_LVAL (arg1));
if (TYPE_CODE (type2) == TYPE_CODE_INT)
{
struct type *tmp = type1;
+
type1 = tmp;
tmp = type2;
inval1 = arg2;
if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
{
char_type = type2;
+
inchar = (char) unpack_long (type2,
value_contents (inval2));
for (idx = 0; idx < count; idx++)
else
{
char_type = TYPE_TARGET_TYPE (type2);
+
for (idx = 0; idx < count; idx++)
{
memcpy (ptr + (idx * inval2len), value_contents (inval2),
if (TYPE_CODE (type1) == TYPE_CODE_CHAR)
{
char_type = type1;
+
*ptr = (char) unpack_long (type1, value_contents (inval1));
}
else
{
char_type = TYPE_TARGET_TYPE (type1);
+
memcpy (ptr, value_contents (inval1), inval1len);
}
if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
if (TYPE_CODE (type1) == TYPE_CODE_DECFLOAT
|| TYPE_CODE (type2) == TYPE_CODE_DECFLOAT)
{
- struct type *v_type;
int len_v1, len_v2, len_v;
enum bfd_endian byte_order_v1, byte_order_v2, byte_order_v;
gdb_byte v1[16], v2[16];
in target format. real.c in GCC probably has the necessary
code. */
DOUBLEST v1, v2, v = 0;
+
v1 = value_as_double (arg1);
v2 = value_as_double (arg2);
|| TYPE_CODE (type2) == TYPE_CODE_BOOL)
{
LONGEST v1, v2, v = 0;
+
v1 = value_as_long (arg1);
v2 = value_as_long (arg2);
{
LONGEST v2_signed = value_as_long (arg2);
ULONGEST v1, v2, v = 0;
+
v1 = (ULONGEST) value_as_long (arg1);
v2 = (ULONGEST) v2_signed;
else
{
LONGEST v1, v2, v = 0;
+
v1 = value_as_long (arg1);
v2 = value_as_long (arg2);
/* NOTE: kettenis/20050816: Avoid compiler bug on systems where
`long double' values are returned in static storage (m68k). */
DOUBLEST d = value_as_double (arg1);
+
return d == value_as_double (arg2);
}
else if ((code1 == TYPE_CODE_DECFLOAT || is_int1)
/* NOTE: kettenis/20050816: Avoid compiler bug on systems where
`long double' values are returned in static storage (m68k). */
DOUBLEST d = value_as_double (arg1);
+
return d < value_as_double (arg2);
}
else if ((code1 == TYPE_CODE_DECFLOAT || is_int1)
LONGEST word;
unsigned rel_index;
struct type *range = TYPE_INDEX_TYPE (type);
+
if (get_discrete_bounds (range, &low_bound, &high_bound) < 0)
return -2;
if (index < low_bound || index > high_bound)
int member;
struct type *settype = check_typedef (value_type (set));
struct type *eltype = check_typedef (value_type (element));
+
if (TYPE_CODE (eltype) == TYPE_CODE_RANGE)
eltype = TYPE_TARGET_TYPE (eltype);
if (TYPE_CODE (settype) != TYPE_CODE_SET)