* f-typeprint.c, valarith.c, valprint.c, typeprint.c, eval.c:
Add check_typedef/CHECK_TYPEDEF as needed. * f-typeprint.c: Various cleaning up. * valarith.c (value_subscript): Also subscript bitstrings (for Chill). * typeprint.c (print_type_scalar): Also support TYPE_CODE_RANGE. * eval.c (evaluate_subexp_standard case OP_ARRAY): Implement support for labelled array tuples and ranges in powerset tuples. (init_array_element): New function.
This commit is contained in:
parent
940d596798
commit
bcbf388e99
|
@ -27,6 +27,15 @@ Wed Nov 29 13:35:18 1995 Per Bothner <bothner@kalessin.cygnus.com>
|
|||
findvar.c, hppa-tdep.c, infcmd.c, language.c, printcmd.c,
|
||||
rs6000-tdep.c, symmisc.c, symtab.c:
|
||||
Add check_typedef/CHECK_TYPEDEF as needed.
|
||||
|
||||
* f-typeprint.c, valarith.c, valprint.c, typeprint.c, eval.c:
|
||||
Add check_typedef/CHECK_TYPEDEF as needed.
|
||||
* f-typeprint.c: Various cleaning up.
|
||||
* valarith.c (value_subscript): Also subscript bitstrings (for Chill).
|
||||
* typeprint.c (print_type_scalar): Also support TYPE_CODE_RANGE.
|
||||
* eval.c (evaluate_subexp_standard case OP_ARRAY): Implement
|
||||
support for labelled array tuples and ranges in powerset tuples.
|
||||
(init_array_element): New function.
|
||||
|
||||
* top.c (command_line_input): Only strip out an initial #-comment.
|
||||
Looking for internal comments is language-specific (breaks Scheme).
|
||||
|
|
235
gdb/eval.c
235
gdb/eval.c
|
@ -177,13 +177,13 @@ evaluate_struct_tuple (struct_val, exp, pos, noside, nargs)
|
|||
enum noside noside;
|
||||
int nargs;
|
||||
{
|
||||
struct type *struct_type = VALUE_TYPE (struct_val);
|
||||
struct type *struct_type = check_typedef (VALUE_TYPE (struct_val));
|
||||
struct type *substruct_type = struct_type;
|
||||
struct type *field_type;
|
||||
int fieldno = -1;
|
||||
int variantno = -1;
|
||||
int subfieldno = -1;
|
||||
while (--nargs >= 0)
|
||||
while (--nargs >= 0)
|
||||
{
|
||||
int pc = *pos;
|
||||
value_ptr val = NULL;
|
||||
|
@ -307,6 +307,58 @@ evaluate_struct_tuple (struct_val, exp, pos, noside, nargs)
|
|||
return struct_val;
|
||||
}
|
||||
|
||||
/* Recursive helper function for setting elements of array tuples for Chill.
|
||||
The target is ARRAY (which has bounds LOW_BOUND to HIGH_BOUND);
|
||||
the element value is ELEMENT;
|
||||
EXP, POS and NOSIDE are as usual.
|
||||
Evaluates index expresions and sets the specified element(s) of
|
||||
ARRAY to ELEMENT.
|
||||
Returns last index value. */
|
||||
|
||||
static LONGEST
|
||||
init_array_element (array, element, exp, pos, noside, low_bound, high_bound)
|
||||
value_ptr array, element;
|
||||
register struct expression *exp;
|
||||
register int *pos;
|
||||
enum noside noside;
|
||||
{
|
||||
LONGEST index;
|
||||
int element_size = TYPE_LENGTH (VALUE_TYPE (element));
|
||||
if (exp->elts[*pos].opcode == BINOP_COMMA)
|
||||
{
|
||||
(*pos)++;
|
||||
init_array_element (array, element, exp, pos, noside,
|
||||
low_bound, high_bound);
|
||||
return init_array_element (array, element,
|
||||
exp, pos, noside, low_bound, high_bound);
|
||||
}
|
||||
else if (exp->elts[*pos].opcode == BINOP_RANGE)
|
||||
{
|
||||
LONGEST low, high;
|
||||
value_ptr val;
|
||||
(*pos)++;
|
||||
low = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
|
||||
high = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
|
||||
if (low < low_bound || high > high_bound)
|
||||
error ("tuple range index out of range");
|
||||
for (index = low ; index <= high; index++)
|
||||
{
|
||||
memcpy (VALUE_CONTENTS_RAW (array)
|
||||
+ (index - low_bound) * element_size,
|
||||
VALUE_CONTENTS (element), element_size);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
index = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
|
||||
if (index < low_bound || index > high_bound)
|
||||
error ("tuple index out of range");
|
||||
memcpy (VALUE_CONTENTS_RAW (array) + (index - low_bound) * element_size,
|
||||
VALUE_CONTENTS (element), element_size);
|
||||
}
|
||||
return index;
|
||||
}
|
||||
|
||||
value_ptr
|
||||
evaluate_subexp_standard (expect_type, exp, pos, noside)
|
||||
struct type *expect_type;
|
||||
|
@ -440,62 +492,107 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
|
|||
tem2 = longest_to_int (exp->elts[pc + 1].longconst);
|
||||
tem3 = longest_to_int (exp->elts[pc + 2].longconst);
|
||||
nargs = tem3 - tem2 + 1;
|
||||
type = expect_type ? check_typedef (expect_type) : NULL_TYPE;
|
||||
|
||||
if (expect_type != NULL_TYPE && noside != EVAL_SKIP
|
||||
&& TYPE_CODE (expect_type) == TYPE_CODE_STRUCT)
|
||||
&& TYPE_CODE (type) == TYPE_CODE_STRUCT)
|
||||
{
|
||||
value_ptr rec = allocate_value (expect_type);
|
||||
memset (VALUE_CONTENTS_RAW (rec), '\0', TYPE_LENGTH (expect_type));
|
||||
memset (VALUE_CONTENTS_RAW (rec), '\0', TYPE_LENGTH (type));
|
||||
return evaluate_struct_tuple (rec, exp, pos, noside, nargs);
|
||||
}
|
||||
|
||||
if (expect_type != NULL_TYPE && noside != EVAL_SKIP
|
||||
&& TYPE_CODE (expect_type) == TYPE_CODE_ARRAY)
|
||||
&& TYPE_CODE (type) == TYPE_CODE_ARRAY)
|
||||
{
|
||||
struct type *range_type = TYPE_FIELD_TYPE (expect_type, 0);
|
||||
struct type *element_type = TYPE_TARGET_TYPE (expect_type);
|
||||
LONGEST low_bound = TYPE_FIELD_BITPOS (range_type, 0);
|
||||
LONGEST high_bound = TYPE_FIELD_BITPOS (range_type, 1);
|
||||
int element_size = TYPE_LENGTH (element_type);
|
||||
struct type *range_type = TYPE_FIELD_TYPE (type, 0);
|
||||
struct type *element_type = TYPE_TARGET_TYPE (type);
|
||||
value_ptr array = allocate_value (expect_type);
|
||||
if (nargs != (high_bound - low_bound + 1))
|
||||
error ("wrong number of initialiers for array type");
|
||||
for (tem = low_bound; tem <= high_bound; tem++)
|
||||
int element_size = TYPE_LENGTH (check_typedef (element_type));
|
||||
LONGEST low_bound, high_bound, index;
|
||||
if (get_discrete_bounds (range_type, &low_bound, &high_bound) < 0)
|
||||
{
|
||||
value_ptr element = evaluate_subexp (element_type,
|
||||
exp, pos, noside);
|
||||
low_bound = 0;
|
||||
high_bound = (TYPE_LENGTH (type) / element_size) - 1;
|
||||
}
|
||||
index = low_bound;
|
||||
memset (VALUE_CONTENTS_RAW (array), 0, TYPE_LENGTH (expect_type));
|
||||
for (tem = nargs; --nargs >= 0; )
|
||||
{
|
||||
value_ptr element;
|
||||
int index_pc = 0;
|
||||
if (exp->elts[*pos].opcode == BINOP_RANGE)
|
||||
{
|
||||
index_pc = ++(*pos);
|
||||
evaluate_subexp (NULL_TYPE, exp, pos, EVAL_SKIP);
|
||||
}
|
||||
element = evaluate_subexp (element_type, exp, pos, noside);
|
||||
if (VALUE_TYPE (element) != element_type)
|
||||
element = value_cast (element_type, element);
|
||||
memcpy (VALUE_CONTENTS_RAW (array)
|
||||
+ (tem - low_bound) * element_size,
|
||||
VALUE_CONTENTS (element),
|
||||
element_size);
|
||||
if (index_pc)
|
||||
{
|
||||
int continue_pc = *pos;
|
||||
*pos = index_pc;
|
||||
index = init_array_element (array, element, exp, pos, noside,
|
||||
low_bound, high_bound);
|
||||
*pos = continue_pc;
|
||||
}
|
||||
else
|
||||
{
|
||||
memcpy (VALUE_CONTENTS_RAW (array)
|
||||
+ (index - low_bound) * element_size,
|
||||
VALUE_CONTENTS (element),
|
||||
element_size);
|
||||
}
|
||||
index++;
|
||||
}
|
||||
return array;
|
||||
}
|
||||
|
||||
if (expect_type != NULL_TYPE && noside != EVAL_SKIP
|
||||
&& TYPE_CODE (expect_type) == TYPE_CODE_SET)
|
||||
&& TYPE_CODE (type) == TYPE_CODE_SET)
|
||||
{
|
||||
value_ptr set = allocate_value (expect_type);
|
||||
struct type *element_type = TYPE_INDEX_TYPE (expect_type);
|
||||
int low_bound = TYPE_LOW_BOUND (element_type);
|
||||
int high_bound = TYPE_HIGH_BOUND (element_type);
|
||||
char *valaddr = VALUE_CONTENTS_RAW (set);
|
||||
memset (valaddr, '\0', TYPE_LENGTH (expect_type));
|
||||
struct type *element_type = TYPE_INDEX_TYPE (type);
|
||||
LONGEST low_bound, high_bound;
|
||||
if (get_discrete_bounds (element_type, &low_bound, &high_bound) < 0)
|
||||
error ("(power)set type with unknown size");
|
||||
memset (valaddr, '\0', TYPE_LENGTH (type));
|
||||
for (tem = 0; tem < nargs; tem++)
|
||||
{
|
||||
value_ptr element_val = evaluate_subexp (element_type,
|
||||
exp, pos, noside);
|
||||
LONGEST element = value_as_long (element_val);
|
||||
int bit_index;
|
||||
if (element < low_bound || element > high_bound)
|
||||
LONGEST range_low, range_high;
|
||||
value_ptr elem_val;
|
||||
if (exp->elts[*pos].opcode == BINOP_RANGE)
|
||||
{
|
||||
(*pos)++;
|
||||
elem_val = evaluate_subexp (element_type, exp, pos, noside);
|
||||
range_low = value_as_long (elem_val);
|
||||
elem_val = evaluate_subexp (element_type, exp, pos, noside);
|
||||
range_high = value_as_long (elem_val);
|
||||
}
|
||||
else
|
||||
{
|
||||
elem_val = evaluate_subexp (element_type, exp, pos, noside);
|
||||
range_low = range_high = value_as_long (elem_val);
|
||||
}
|
||||
if (range_low > range_high)
|
||||
{
|
||||
warning ("empty POWERSET tuple range");
|
||||
continue;
|
||||
}
|
||||
if (range_low < low_bound || range_high > high_bound)
|
||||
error ("POWERSET tuple element out of range");
|
||||
element -= low_bound;
|
||||
bit_index = (unsigned) element % TARGET_CHAR_BIT;
|
||||
if (BITS_BIG_ENDIAN)
|
||||
bit_index = TARGET_CHAR_BIT - 1 - bit_index;
|
||||
valaddr [(unsigned) element / TARGET_CHAR_BIT] |= 1 << bit_index;
|
||||
range_low -= low_bound;
|
||||
range_high -= low_bound;
|
||||
for ( ; range_low <= range_high; range_low++)
|
||||
{
|
||||
int bit_index = (unsigned) range_low % TARGET_CHAR_BIT;
|
||||
if (BITS_BIG_ENDIAN)
|
||||
bit_index = TARGET_CHAR_BIT - 1 - bit_index;
|
||||
valaddr [(unsigned) range_low / TARGET_CHAR_BIT]
|
||||
|= 1 << bit_index;
|
||||
}
|
||||
}
|
||||
return set;
|
||||
}
|
||||
|
@ -517,6 +614,8 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
|
|||
= value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
|
||||
int upper
|
||||
= value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));
|
||||
if (noside == EVAL_SKIP)
|
||||
goto nosideret;
|
||||
return value_slice (array, lowbound, upper - lowbound + 1);
|
||||
}
|
||||
|
||||
|
@ -740,7 +839,8 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
|
|||
|
||||
/* First determine the type code we are dealing with. */
|
||||
arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
|
||||
code = TYPE_CODE (VALUE_TYPE (arg1));
|
||||
type = check_typedef (VALUE_TYPE (arg1));
|
||||
code = TYPE_CODE (type);
|
||||
|
||||
switch (code)
|
||||
{
|
||||
|
@ -775,29 +875,17 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
|
|||
|
||||
arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
|
||||
|
||||
if (TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_INT)
|
||||
error ("Substring arguments must be of type integer");
|
||||
|
||||
if (nargs < 2)
|
||||
return value_subscript (arg1, arg2);
|
||||
|
||||
arg3 = evaluate_subexp_with_coercion (exp, pos, noside);
|
||||
|
||||
if (TYPE_CODE (VALUE_TYPE (arg3)) != TYPE_CODE_INT)
|
||||
error ("Substring arguments must be of type integer");
|
||||
|
||||
tem2 = *((int *) VALUE_CONTENTS_RAW (arg2));
|
||||
tem3 = *((int *) VALUE_CONTENTS_RAW (arg3));
|
||||
|
||||
if ((tem2 < 1) || (tem2 > tem3))
|
||||
error ("Bad 'from' value %d on substring operation", tem2);
|
||||
|
||||
if ((tem3 < tem2) || (tem3 > (TYPE_LENGTH (VALUE_TYPE (arg1)))))
|
||||
error ("Bad 'to' value %d on substring operation", tem3);
|
||||
|
||||
if (noside == EVAL_SKIP)
|
||||
goto nosideret;
|
||||
|
||||
tem2 = value_as_long (arg2);
|
||||
tem2 = value_as_long (arg3);
|
||||
|
||||
return value_slice (arg1, tem2, tem3 - tem2 + 1);
|
||||
|
||||
case OP_COMPLEX:
|
||||
|
@ -883,9 +971,10 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
|
|||
arg2 = evaluate_subexp (NULL_TYPE, exp, pos, noside);
|
||||
if (noside == EVAL_SKIP)
|
||||
goto nosideret;
|
||||
if (TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_PTR)
|
||||
type = check_typedef (VALUE_TYPE (arg2));
|
||||
if (TYPE_CODE (type) != TYPE_CODE_PTR)
|
||||
goto bad_pointer_to_member;
|
||||
type = TYPE_TARGET_TYPE (VALUE_TYPE (arg2));
|
||||
type = check_typedef (TYPE_TARGET_TYPE (type));
|
||||
if (TYPE_CODE (type) == TYPE_CODE_METHOD)
|
||||
error ("not implemented: pointer-to-method in pointer-to-member construct");
|
||||
if (TYPE_CODE (type) != TYPE_CODE_MEMBER)
|
||||
|
@ -996,7 +1085,7 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
|
|||
type (like a plain int variable for example), then report this
|
||||
as an error. */
|
||||
|
||||
type = TYPE_TARGET_TYPE (VALUE_TYPE (arg1));
|
||||
type = TYPE_TARGET_TYPE (check_typedef (VALUE_TYPE (arg1)));
|
||||
if (type)
|
||||
return value_zero (type, VALUE_LVAL (arg1));
|
||||
else
|
||||
|
@ -1042,7 +1131,7 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
|
|||
type (like a plain int variable for example), then report this
|
||||
as an error. */
|
||||
|
||||
type = TYPE_TARGET_TYPE (VALUE_TYPE (arg1));
|
||||
type = TYPE_TARGET_TYPE (check_typedef (VALUE_TYPE (arg1)));
|
||||
if (type != NULL)
|
||||
{
|
||||
arg1 = value_zero (type, VALUE_LVAL (arg1));
|
||||
|
@ -1078,8 +1167,9 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
|
|||
|
||||
if (nargs > MAX_FORTRAN_DIMS)
|
||||
error ("Too many subscripts for F77 (%d Max)", MAX_FORTRAN_DIMS);
|
||||
|
||||
ndimensions = calc_f77_array_dims (VALUE_TYPE (arg1));
|
||||
|
||||
tmp_type = check_typedef (VALUE_TYPE (arg1));
|
||||
ndimensions = calc_f77_array_dims (type);
|
||||
|
||||
if (nargs != ndimensions)
|
||||
error ("Wrong number of subscripts");
|
||||
|
@ -1087,7 +1177,6 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
|
|||
/* Now that we know we have a legal array subscript expression
|
||||
let us actually find out where this element exists in the array. */
|
||||
|
||||
tmp_type = VALUE_TYPE (arg1);
|
||||
offset_item = 0;
|
||||
for (i = 1; i <= nargs; i++)
|
||||
{
|
||||
|
@ -1121,7 +1210,7 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
|
|||
offset to. */
|
||||
|
||||
if (i < nargs)
|
||||
tmp_type = TYPE_TARGET_TYPE (tmp_type);
|
||||
tmp_type = check_typedef (TYPE_TARGET_TYPE (tmp_type));
|
||||
}
|
||||
|
||||
/* Now let us calculate the offset for this item */
|
||||
|
@ -1341,20 +1430,21 @@ evaluate_subexp_standard (expect_type, exp, pos, noside)
|
|||
|
||||
case UNOP_IND:
|
||||
if (expect_type && TYPE_CODE (expect_type) == TYPE_CODE_PTR)
|
||||
expect_type = TYPE_TARGET_TYPE (expect_type);
|
||||
expect_type = TYPE_TARGET_TYPE (check_typedef (expect_type));
|
||||
arg1 = evaluate_subexp (expect_type, exp, pos, noside);
|
||||
if (noside == EVAL_SKIP)
|
||||
goto nosideret;
|
||||
if (noside == EVAL_AVOID_SIDE_EFFECTS)
|
||||
{
|
||||
if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR
|
||||
|| TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_REF
|
||||
type = check_typedef (VALUE_TYPE (arg1));
|
||||
if (TYPE_CODE (type) == TYPE_CODE_PTR
|
||||
|| TYPE_CODE (type) == TYPE_CODE_REF
|
||||
/* In C you can dereference an array to get the 1st elt. */
|
||||
|| TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_ARRAY
|
||||
|| TYPE_CODE (type) == TYPE_CODE_ARRAY
|
||||
)
|
||||
return value_zero (TYPE_TARGET_TYPE (VALUE_TYPE (arg1)),
|
||||
return value_zero (TYPE_TARGET_TYPE (type),
|
||||
lval_memory);
|
||||
else if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_INT)
|
||||
else if (TYPE_CODE (type) == TYPE_CODE_INT)
|
||||
/* GDB allows dereferencing an int. */
|
||||
return value_zero (builtin_type_int, lval_memory);
|
||||
else
|
||||
|
@ -1605,7 +1695,7 @@ evaluate_subexp_with_coercion (exp, pos, noside)
|
|||
{
|
||||
case OP_VAR_VALUE:
|
||||
var = exp->elts[pc + 2].symbol;
|
||||
if (TYPE_CODE (SYMBOL_TYPE (var)) == TYPE_CODE_ARRAY
|
||||
if (TYPE_CODE (check_typedef (SYMBOL_TYPE (var))) == TYPE_CODE_ARRAY
|
||||
&& CAST_IS_CONVERSION)
|
||||
{
|
||||
(*pos) += 4;
|
||||
|
@ -1633,6 +1723,7 @@ evaluate_subexp_for_sizeof (exp, pos)
|
|||
{
|
||||
enum exp_opcode op;
|
||||
register int pc;
|
||||
struct type *type;
|
||||
value_ptr val;
|
||||
|
||||
pc = (*pos);
|
||||
|
@ -1647,20 +1738,22 @@ evaluate_subexp_for_sizeof (exp, pos)
|
|||
case UNOP_IND:
|
||||
(*pos)++;
|
||||
val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
|
||||
type = check_typedef (VALUE_TYPE (val));
|
||||
type = check_typedef (TYPE_TARGET_TYPE (type));
|
||||
return value_from_longest (builtin_type_int, (LONGEST)
|
||||
TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (val))));
|
||||
TYPE_LENGTH (type));
|
||||
|
||||
case UNOP_MEMVAL:
|
||||
(*pos) += 3;
|
||||
return value_from_longest (builtin_type_int,
|
||||
(LONGEST) TYPE_LENGTH (exp->elts[pc + 1].type));
|
||||
type = check_typedef (exp->elts[pc + 1].type);
|
||||
return value_from_longest (builtin_type_int,
|
||||
(LONGEST) TYPE_LENGTH (type));
|
||||
|
||||
case OP_VAR_VALUE:
|
||||
(*pos) += 4;
|
||||
type = check_typedef (SYMBOL_TYPE (exp->elts[pc + 2].symbol));
|
||||
return
|
||||
value_from_longest
|
||||
(builtin_type_int,
|
||||
(LONGEST) TYPE_LENGTH (SYMBOL_TYPE (exp->elts[pc + 2].symbol)));
|
||||
value_from_longest (builtin_type_int, (LONGEST) TYPE_LENGTH (type));
|
||||
|
||||
default:
|
||||
val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_AVOID_SIDE_EFFECTS);
|
||||
|
|
|
@ -314,16 +314,7 @@ print_equivalent_f77_float_type (type, stream)
|
|||
appropriate real. XLC stupidly outputs -12 as a type
|
||||
for real when it really should be outputting -18 */
|
||||
|
||||
switch (TYPE_LENGTH (type))
|
||||
{
|
||||
case 4:
|
||||
fprintf_filtered (stream, "real*4");
|
||||
break;
|
||||
|
||||
case 8:
|
||||
fprintf_filtered(stream,"real*8");
|
||||
break;
|
||||
}
|
||||
fprintf_filtered (stream, "real*%d", TYPE_LENGTH (type));
|
||||
}
|
||||
|
||||
/* Print the name of the type (or the ultimate pointer target,
|
||||
|
@ -370,19 +361,23 @@ f_type_print_base (type, stream, show, level)
|
|||
return;
|
||||
}
|
||||
|
||||
if (TYPE_CODE (type) != TYPE_CODE_TYPEDEF)
|
||||
CHECK_TYPEDEF (type);
|
||||
|
||||
switch (TYPE_CODE (type))
|
||||
{
|
||||
case TYPE_CODE_ARRAY:
|
||||
f_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
|
||||
case TYPE_CODE_TYPEDEF:
|
||||
f_type_print_base (TYPE_TARGET_TYPE (type), stream, 0, level);
|
||||
break;
|
||||
|
||||
case TYPE_CODE_ARRAY:
|
||||
case TYPE_CODE_FUNC:
|
||||
f_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
|
||||
break;
|
||||
|
||||
case TYPE_CODE_PTR:
|
||||
fprintf_filtered (stream, "PTR TO -> ( ");
|
||||
f_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
|
||||
f_type_print_base (TYPE_TARGET_TYPE (type), stream, 0, level);
|
||||
break;
|
||||
|
||||
case TYPE_CODE_VOID:
|
||||
|
@ -419,8 +414,7 @@ f_type_print_base (type, stream, show, level)
|
|||
break;
|
||||
|
||||
case TYPE_CODE_COMPLEX:
|
||||
fprintf_filtered (stream, "complex*");
|
||||
fprintf_filtered (stream, "%d", TYPE_LENGTH (type));
|
||||
fprintf_filtered (stream, "complex*%d", TYPE_LENGTH (type));
|
||||
break;
|
||||
|
||||
case TYPE_CODE_FLT:
|
||||
|
|
|
@ -180,6 +180,8 @@ print_type_scalar (type, val, stream)
|
|||
unsigned int i;
|
||||
unsigned len;
|
||||
|
||||
CHECK_TYPEDEF (type);
|
||||
|
||||
switch (TYPE_CODE (type))
|
||||
{
|
||||
|
||||
|
@ -214,6 +216,10 @@ print_type_scalar (type, val, stream)
|
|||
fprintf_filtered (stream, val ? "TRUE" : "FALSE");
|
||||
break;
|
||||
|
||||
case TYPE_CODE_RANGE:
|
||||
print_type_scalar (TYPE_TARGET_TYPE (type), val, stream);
|
||||
return;
|
||||
|
||||
case TYPE_CODE_UNDEF:
|
||||
case TYPE_CODE_PTR:
|
||||
case TYPE_CODE_ARRAY:
|
||||
|
@ -223,7 +229,6 @@ print_type_scalar (type, val, stream)
|
|||
case TYPE_CODE_FLT:
|
||||
case TYPE_CODE_VOID:
|
||||
case TYPE_CODE_SET:
|
||||
case TYPE_CODE_RANGE:
|
||||
case TYPE_CODE_STRING:
|
||||
case TYPE_CODE_ERROR:
|
||||
case TYPE_CODE_MEMBER:
|
||||
|
|
263
gdb/valarith.c
263
gdb/valarith.c
|
@ -16,7 +16,7 @@ GNU General Public License for more details.
|
|||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
||||
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
|
||||
|
||||
#include "defs.h"
|
||||
#include "value.h"
|
||||
|
@ -44,30 +44,35 @@ value_add (arg1, arg2)
|
|||
{
|
||||
register value_ptr valint, valptr;
|
||||
register int len;
|
||||
struct type *type1, *type2, *valptrtype;
|
||||
|
||||
COERCE_ARRAY (arg1);
|
||||
COERCE_ARRAY (arg2);
|
||||
type1 = check_typedef (VALUE_TYPE (arg1));
|
||||
type2 = check_typedef (VALUE_TYPE (arg2));
|
||||
|
||||
if ((TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR
|
||||
|| TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_PTR)
|
||||
if ((TYPE_CODE (type1) == TYPE_CODE_PTR
|
||||
|| TYPE_CODE (type2) == TYPE_CODE_PTR)
|
||||
&&
|
||||
(TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_INT
|
||||
|| TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_INT))
|
||||
(TYPE_CODE (type1) == TYPE_CODE_INT
|
||||
|| TYPE_CODE (type2) == TYPE_CODE_INT))
|
||||
/* Exactly one argument is a pointer, and one is an integer. */
|
||||
{
|
||||
if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR)
|
||||
if (TYPE_CODE (type1) == TYPE_CODE_PTR)
|
||||
{
|
||||
valptr = arg1;
|
||||
valint = arg2;
|
||||
valptrtype = type1;
|
||||
}
|
||||
else
|
||||
{
|
||||
valptr = arg2;
|
||||
valint = arg1;
|
||||
valptrtype = type2;
|
||||
}
|
||||
len = TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (valptr)));
|
||||
len = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (valptrtype)));
|
||||
if (len == 0) len = 1; /* For (void *) */
|
||||
return value_from_longest (VALUE_TYPE (valptr),
|
||||
return value_from_longest (valptrtype,
|
||||
value_as_long (valptr)
|
||||
+ (len * value_as_long (valint)));
|
||||
}
|
||||
|
@ -79,30 +84,31 @@ value_ptr
|
|||
value_sub (arg1, arg2)
|
||||
value_ptr arg1, arg2;
|
||||
{
|
||||
|
||||
struct type *type1, *type2;
|
||||
COERCE_ARRAY (arg1);
|
||||
COERCE_ARRAY (arg2);
|
||||
type1 = check_typedef (VALUE_TYPE (arg1));
|
||||
type2 = check_typedef (VALUE_TYPE (arg2));
|
||||
|
||||
if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_PTR)
|
||||
if (TYPE_CODE (type1) == TYPE_CODE_PTR)
|
||||
{
|
||||
if (TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_INT)
|
||||
if (TYPE_CODE (type2) == TYPE_CODE_INT)
|
||||
{
|
||||
/* pointer - integer. */
|
||||
LONGEST sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)));
|
||||
return value_from_longest
|
||||
(VALUE_TYPE (arg1),
|
||||
value_as_long (arg1)
|
||||
- (TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (arg1)))
|
||||
* value_as_long (arg2)));
|
||||
value_as_long (arg1) - (sz * value_as_long (arg2)));
|
||||
}
|
||||
else if (TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_PTR
|
||||
&& TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (arg1)))
|
||||
== TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (arg2))))
|
||||
else if (TYPE_CODE (type2) == TYPE_CODE_PTR
|
||||
&& TYPE_LENGTH (TYPE_TARGET_TYPE (type1))
|
||||
== TYPE_LENGTH (TYPE_TARGET_TYPE (type2)))
|
||||
{
|
||||
/* pointer to <type x> - pointer to <type x>. */
|
||||
LONGEST sz = TYPE_LENGTH (check_typedef (TYPE_TARGET_TYPE (type1)));
|
||||
return value_from_longest
|
||||
(builtin_type_long, /* FIXME -- should be ptrdiff_t */
|
||||
(value_as_long (arg1) - value_as_long (arg2))
|
||||
/ (LONGEST) (TYPE_LENGTH (TYPE_TARGET_TYPE (VALUE_TYPE (arg1)))));
|
||||
(value_as_long (arg1) - value_as_long (arg2)) / sz);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -127,16 +133,18 @@ value_subscript (array, idx)
|
|||
{
|
||||
value_ptr bound;
|
||||
int c_style = current_language->c_style_arrays;
|
||||
struct type *tarray, *tint;
|
||||
|
||||
COERCE_REF (array);
|
||||
COERCE_VARYING_ARRAY (array);
|
||||
tarray = check_typedef (VALUE_TYPE (array));
|
||||
COERCE_VARYING_ARRAY (array, tarray);
|
||||
|
||||
if (TYPE_CODE (VALUE_TYPE (array)) == TYPE_CODE_ARRAY
|
||||
|| TYPE_CODE (VALUE_TYPE (array)) == TYPE_CODE_STRING)
|
||||
if (TYPE_CODE (tarray) == TYPE_CODE_ARRAY
|
||||
|| TYPE_CODE (tarray) == TYPE_CODE_STRING)
|
||||
{
|
||||
struct type *range_type = TYPE_FIELD_TYPE (VALUE_TYPE (array), 0);
|
||||
int lowerbound = TYPE_LOW_BOUND (range_type);
|
||||
int upperbound = TYPE_HIGH_BOUND (range_type);
|
||||
struct type *range_type = TYPE_INDEX_TYPE (tarray);
|
||||
LONGEST lowerbound, upperbound;
|
||||
get_discrete_bounds (range_type, &lowerbound, &upperbound);
|
||||
|
||||
if (VALUE_LVAL (array) != lval_memory)
|
||||
return value_subscripted_rvalue (array, idx, lowerbound);
|
||||
|
@ -159,6 +167,33 @@ value_subscript (array, idx)
|
|||
|
||||
array = value_coerce_array (array);
|
||||
}
|
||||
|
||||
if (TYPE_CODE (tarray) == TYPE_CODE_BITSTRING)
|
||||
{
|
||||
struct type *range_type = TYPE_INDEX_TYPE (tarray);
|
||||
LONGEST index = value_as_long (idx);
|
||||
value_ptr v;
|
||||
int offset, byte, bit_index;
|
||||
LONGEST lowerbound, upperbound, word;
|
||||
get_discrete_bounds (range_type, &lowerbound, &upperbound);
|
||||
if (index < lowerbound || index > upperbound)
|
||||
error ("bitstring index out of range");
|
||||
index -= lowerbound;
|
||||
offset = index / TARGET_CHAR_BIT;
|
||||
byte = *((char*)VALUE_CONTENTS (array) + offset);
|
||||
bit_index = index % TARGET_CHAR_BIT;
|
||||
byte >>= (BITS_BIG_ENDIAN ? TARGET_CHAR_BIT - 1 - bit_index : bit_index);
|
||||
v = value_from_longest (builtin_type_int, byte & 1);
|
||||
VALUE_BITPOS (v) = bit_index;
|
||||
VALUE_BITSIZE (v) = 1;
|
||||
VALUE_LVAL (v) = VALUE_LVAL (array);
|
||||
if (VALUE_LVAL (array) == lval_internalvar)
|
||||
VALUE_LVAL (v) = lval_internalvar_component;
|
||||
VALUE_ADDRESS (v) = VALUE_ADDRESS (array);
|
||||
VALUE_OFFSET (v) = offset + VALUE_OFFSET (array);
|
||||
return v;
|
||||
}
|
||||
|
||||
if (c_style)
|
||||
return value_ind (value_add (array, idx));
|
||||
else
|
||||
|
@ -174,13 +209,14 @@ value_subscripted_rvalue (array, idx, lowerbound)
|
|||
value_ptr array, idx;
|
||||
int lowerbound;
|
||||
{
|
||||
struct type *elt_type = TYPE_TARGET_TYPE (VALUE_TYPE (array));
|
||||
struct type *array_type = check_typedef (VALUE_TYPE (array));
|
||||
struct type *elt_type = check_typedef (TYPE_TARGET_TYPE (array_type));
|
||||
int elt_size = TYPE_LENGTH (elt_type);
|
||||
LONGEST index = value_as_long (idx);
|
||||
int elt_offs = elt_size * longest_to_int (index - lowerbound);
|
||||
value_ptr v;
|
||||
|
||||
if (index < lowerbound || elt_offs >= TYPE_LENGTH (VALUE_TYPE (array)))
|
||||
if (index < lowerbound || elt_offs >= TYPE_LENGTH (array_type))
|
||||
error ("no such vector element");
|
||||
|
||||
v = allocate_value (elt_type);
|
||||
|
@ -195,7 +231,6 @@ value_subscripted_rvalue (array, idx, lowerbound)
|
|||
VALUE_LVAL (v) = VALUE_LVAL (array);
|
||||
VALUE_ADDRESS (v) = VALUE_ADDRESS (array);
|
||||
VALUE_OFFSET (v) = VALUE_OFFSET (array) + elt_offs;
|
||||
VALUE_BITSIZE (v) = elt_size * 8;
|
||||
return v;
|
||||
}
|
||||
|
||||
|
@ -210,14 +245,17 @@ binop_user_defined_p (op, arg1, arg2)
|
|||
enum exp_opcode op;
|
||||
value_ptr arg1, arg2;
|
||||
{
|
||||
struct type *type1, *type2;
|
||||
if (op == BINOP_ASSIGN)
|
||||
return 0;
|
||||
return (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_STRUCT
|
||||
|| TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_STRUCT
|
||||
|| (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_REF
|
||||
&& TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))) == TYPE_CODE_STRUCT)
|
||||
|| (TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_REF
|
||||
&& TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg2))) == TYPE_CODE_STRUCT));
|
||||
type1 = check_typedef (VALUE_TYPE (arg1));
|
||||
type2 = check_typedef (VALUE_TYPE (arg2));
|
||||
return (TYPE_CODE (type1) == TYPE_CODE_STRUCT
|
||||
|| TYPE_CODE (type2) == TYPE_CODE_STRUCT
|
||||
|| (TYPE_CODE (type1) == TYPE_CODE_REF
|
||||
&& TYPE_CODE (TYPE_TARGET_TYPE (type1)) == TYPE_CODE_STRUCT)
|
||||
|| (TYPE_CODE (type2) == TYPE_CODE_REF
|
||||
&& TYPE_CODE (TYPE_TARGET_TYPE (type2)) == TYPE_CODE_STRUCT));
|
||||
}
|
||||
|
||||
/* Check to see if argument is a structure. This is called so
|
||||
|
@ -230,11 +268,19 @@ int unop_user_defined_p (op, arg1)
|
|||
enum exp_opcode op;
|
||||
value_ptr arg1;
|
||||
{
|
||||
struct type *type1;
|
||||
if (op == UNOP_ADDR)
|
||||
return 0;
|
||||
return (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_STRUCT
|
||||
|| (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_REF
|
||||
&& TYPE_CODE (TYPE_TARGET_TYPE (VALUE_TYPE (arg1))) == TYPE_CODE_STRUCT));
|
||||
type1 = check_typedef (VALUE_TYPE (arg1));
|
||||
for (;;)
|
||||
{
|
||||
if (TYPE_CODE (type1) == TYPE_CODE_STRUCT)
|
||||
return 1;
|
||||
else if (TYPE_CODE (type1) == TYPE_CODE_REF)
|
||||
type1 = TYPE_TARGET_TYPE (type1);
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
/* We know either arg1 or arg2 is a structure, so try to find the right
|
||||
|
@ -264,7 +310,7 @@ value_x_binop (arg1, arg2, op, otherop)
|
|||
/* now we know that what we have to do is construct our
|
||||
arg vector and find the right function to call it with. */
|
||||
|
||||
if (TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_STRUCT)
|
||||
if (TYPE_CODE (check_typedef (VALUE_TYPE (arg1))) != TYPE_CODE_STRUCT)
|
||||
error ("Can't do that binary op on that type"); /* FIXME be explicit */
|
||||
|
||||
argvec = (value_ptr *) alloca (sizeof (value_ptr) * 4);
|
||||
|
@ -358,7 +404,7 @@ value_x_unop (arg1, op)
|
|||
/* now we know that what we have to do is construct our
|
||||
arg vector and find the right function to call it with. */
|
||||
|
||||
if (TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_STRUCT)
|
||||
if (TYPE_CODE (check_typedef (VALUE_TYPE (arg1))) != TYPE_CODE_STRUCT)
|
||||
error ("Can't do that unary op on that type"); /* FIXME be explicit */
|
||||
|
||||
argvec = (value_ptr *) alloca (sizeof (value_ptr) * 3);
|
||||
|
@ -429,6 +475,8 @@ value_concat (arg1, arg2)
|
|||
int count, idx;
|
||||
char *ptr;
|
||||
char inchar;
|
||||
struct type *type1 = check_typedef (VALUE_TYPE (arg1));
|
||||
struct type *type2 = check_typedef (VALUE_TYPE (arg2));
|
||||
|
||||
/* First figure out if we are dealing with two values to be concatenated
|
||||
or a repeat count and a value to be repeated. INVAL1 is set to the
|
||||
|
@ -436,8 +484,11 @@ value_concat (arg1, arg2)
|
|||
to the second of the two concatenated values or the value to be
|
||||
repeated. */
|
||||
|
||||
if (TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_INT)
|
||||
if (TYPE_CODE (type2) == TYPE_CODE_INT)
|
||||
{
|
||||
struct type *tmp = type1;
|
||||
type1 = tmp;
|
||||
tmp = type2;
|
||||
inval1 = arg2;
|
||||
inval2 = arg1;
|
||||
}
|
||||
|
@ -449,19 +500,19 @@ value_concat (arg1, arg2)
|
|||
|
||||
/* Now process the input values. */
|
||||
|
||||
if (TYPE_CODE (VALUE_TYPE (inval1)) == TYPE_CODE_INT)
|
||||
if (TYPE_CODE (type1) == TYPE_CODE_INT)
|
||||
{
|
||||
/* We have a repeat count. Validate the second value and then
|
||||
construct a value repeated that many times. */
|
||||
if (TYPE_CODE (VALUE_TYPE (inval2)) == TYPE_CODE_STRING
|
||||
|| TYPE_CODE (VALUE_TYPE (inval2)) == TYPE_CODE_CHAR)
|
||||
if (TYPE_CODE (type2) == TYPE_CODE_STRING
|
||||
|| TYPE_CODE (type2) == TYPE_CODE_CHAR)
|
||||
{
|
||||
count = longest_to_int (value_as_long (inval1));
|
||||
inval2len = TYPE_LENGTH (VALUE_TYPE (inval2));
|
||||
inval2len = TYPE_LENGTH (type2);
|
||||
ptr = (char *) alloca (count * inval2len);
|
||||
if (TYPE_CODE (VALUE_TYPE (inval2)) == TYPE_CODE_CHAR)
|
||||
if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
|
||||
{
|
||||
inchar = (char) unpack_long (VALUE_TYPE (inval2),
|
||||
inchar = (char) unpack_long (type2,
|
||||
VALUE_CONTENTS (inval2));
|
||||
for (idx = 0; idx < count; idx++)
|
||||
{
|
||||
|
@ -478,8 +529,8 @@ value_concat (arg1, arg2)
|
|||
}
|
||||
outval = value_string (ptr, count * inval2len);
|
||||
}
|
||||
else if (TYPE_CODE (VALUE_TYPE (inval2)) == TYPE_CODE_BITSTRING
|
||||
|| TYPE_CODE (VALUE_TYPE (inval2)) == TYPE_CODE_BOOL)
|
||||
else if (TYPE_CODE (type2) == TYPE_CODE_BITSTRING
|
||||
|| TYPE_CODE (type2) == TYPE_CODE_BOOL)
|
||||
{
|
||||
error ("unimplemented support for bitstring/boolean repeats");
|
||||
}
|
||||
|
@ -488,30 +539,30 @@ value_concat (arg1, arg2)
|
|||
error ("can't repeat values of that type");
|
||||
}
|
||||
}
|
||||
else if (TYPE_CODE (VALUE_TYPE (inval1)) == TYPE_CODE_STRING
|
||||
|| TYPE_CODE (VALUE_TYPE (inval1)) == TYPE_CODE_CHAR)
|
||||
else if (TYPE_CODE (type1) == TYPE_CODE_STRING
|
||||
|| TYPE_CODE (type1) == TYPE_CODE_CHAR)
|
||||
{
|
||||
/* We have two character strings to concatenate. */
|
||||
if (TYPE_CODE (VALUE_TYPE (inval2)) != TYPE_CODE_STRING
|
||||
&& TYPE_CODE (VALUE_TYPE (inval2)) != TYPE_CODE_CHAR)
|
||||
if (TYPE_CODE (type2) != TYPE_CODE_STRING
|
||||
&& TYPE_CODE (type2) != TYPE_CODE_CHAR)
|
||||
{
|
||||
error ("Strings can only be concatenated with other strings.");
|
||||
}
|
||||
inval1len = TYPE_LENGTH (VALUE_TYPE (inval1));
|
||||
inval2len = TYPE_LENGTH (VALUE_TYPE (inval2));
|
||||
inval1len = TYPE_LENGTH (type1);
|
||||
inval2len = TYPE_LENGTH (type2);
|
||||
ptr = (char *) alloca (inval1len + inval2len);
|
||||
if (TYPE_CODE (VALUE_TYPE (inval1)) == TYPE_CODE_CHAR)
|
||||
if (TYPE_CODE (type1) == TYPE_CODE_CHAR)
|
||||
{
|
||||
*ptr = (char) unpack_long (VALUE_TYPE (inval1), VALUE_CONTENTS (inval1));
|
||||
*ptr = (char) unpack_long (type1, VALUE_CONTENTS (inval1));
|
||||
}
|
||||
else
|
||||
{
|
||||
memcpy (ptr, VALUE_CONTENTS (inval1), inval1len);
|
||||
}
|
||||
if (TYPE_CODE (VALUE_TYPE (inval2)) == TYPE_CODE_CHAR)
|
||||
if (TYPE_CODE (type2) == TYPE_CODE_CHAR)
|
||||
{
|
||||
*(ptr + inval1len) =
|
||||
(char) unpack_long (VALUE_TYPE (inval2), VALUE_CONTENTS (inval2));
|
||||
(char) unpack_long (type2, VALUE_CONTENTS (inval2));
|
||||
}
|
||||
else
|
||||
{
|
||||
|
@ -519,12 +570,12 @@ value_concat (arg1, arg2)
|
|||
}
|
||||
outval = value_string (ptr, inval1len + inval2len);
|
||||
}
|
||||
else if (TYPE_CODE (VALUE_TYPE (inval1)) == TYPE_CODE_BITSTRING
|
||||
|| TYPE_CODE (VALUE_TYPE (inval1)) == TYPE_CODE_BOOL)
|
||||
else if (TYPE_CODE (type1) == TYPE_CODE_BITSTRING
|
||||
|| TYPE_CODE (type1) == TYPE_CODE_BOOL)
|
||||
{
|
||||
/* We have two bitstrings to concatenate. */
|
||||
if (TYPE_CODE (VALUE_TYPE (inval2)) != TYPE_CODE_BITSTRING
|
||||
&& TYPE_CODE (VALUE_TYPE (inval2)) != TYPE_CODE_BOOL)
|
||||
if (TYPE_CODE (type2) != TYPE_CODE_BITSTRING
|
||||
&& TYPE_CODE (type2) != TYPE_CODE_BOOL)
|
||||
{
|
||||
error ("Bitstrings or booleans can only be concatenated with other bitstrings or booleans.");
|
||||
}
|
||||
|
@ -552,26 +603,29 @@ value_binop (arg1, arg2, op)
|
|||
enum exp_opcode op;
|
||||
{
|
||||
register value_ptr val;
|
||||
struct type *type1, *type2;
|
||||
|
||||
COERCE_ENUM (arg1);
|
||||
COERCE_ENUM (arg2);
|
||||
type1 = check_typedef (VALUE_TYPE (arg1));
|
||||
type2 = check_typedef (VALUE_TYPE (arg2));
|
||||
|
||||
if ((TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_FLT
|
||||
&& TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_CHAR
|
||||
&& TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_INT
|
||||
&& TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_BOOL
|
||||
&& TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_RANGE)
|
||||
if ((TYPE_CODE (type1) != TYPE_CODE_FLT
|
||||
&& TYPE_CODE (type1) != TYPE_CODE_CHAR
|
||||
&& TYPE_CODE (type1) != TYPE_CODE_INT
|
||||
&& TYPE_CODE (type1) != TYPE_CODE_BOOL
|
||||
&& TYPE_CODE (type1) != TYPE_CODE_RANGE)
|
||||
||
|
||||
(TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_FLT
|
||||
&& TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_CHAR
|
||||
&& TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_INT
|
||||
&& TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_BOOL
|
||||
&& TYPE_CODE (VALUE_TYPE (arg2)) != TYPE_CODE_RANGE))
|
||||
(TYPE_CODE (type2) != TYPE_CODE_FLT
|
||||
&& TYPE_CODE (type2) != TYPE_CODE_CHAR
|
||||
&& TYPE_CODE (type2) != TYPE_CODE_INT
|
||||
&& TYPE_CODE (type2) != TYPE_CODE_BOOL
|
||||
&& TYPE_CODE (type2) != TYPE_CODE_RANGE))
|
||||
error ("Argument to arithmetic operation not a number or boolean.");
|
||||
|
||||
if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_FLT
|
||||
if (TYPE_CODE (type1) == TYPE_CODE_FLT
|
||||
||
|
||||
TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_FLT)
|
||||
TYPE_CODE (type2) == TYPE_CODE_FLT)
|
||||
{
|
||||
/* FIXME-if-picky-about-floating-accuracy: Should be doing this
|
||||
in target format. real.c in GCC probably has the necessary
|
||||
|
@ -605,9 +659,9 @@ value_binop (arg1, arg2, op)
|
|||
store_floating (VALUE_CONTENTS_RAW (val), TYPE_LENGTH (VALUE_TYPE (val)),
|
||||
v);
|
||||
}
|
||||
else if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_BOOL
|
||||
else if (TYPE_CODE (type1) == TYPE_CODE_BOOL
|
||||
&&
|
||||
TYPE_CODE (VALUE_TYPE (arg2)) == TYPE_CODE_BOOL)
|
||||
TYPE_CODE (type2) == TYPE_CODE_BOOL)
|
||||
{
|
||||
LONGEST v1, v2, v;
|
||||
v1 = value_as_long (arg1);
|
||||
|
@ -631,9 +685,9 @@ value_binop (arg1, arg2, op)
|
|||
error ("Invalid operation on booleans.");
|
||||
}
|
||||
|
||||
val = allocate_value (builtin_type_chill_bool);
|
||||
val = allocate_value (type1);
|
||||
store_signed_integer (VALUE_CONTENTS_RAW (val),
|
||||
TYPE_LENGTH (VALUE_TYPE (val)),
|
||||
TYPE_LENGTH (type1),
|
||||
v);
|
||||
}
|
||||
else
|
||||
|
@ -642,8 +696,6 @@ value_binop (arg1, arg2, op)
|
|||
/* FIXME: This implements ANSI C rules (also correct for C++).
|
||||
What about FORTRAN and chill? */
|
||||
{
|
||||
struct type *type1 = VALUE_TYPE (arg1);
|
||||
struct type *type2 = VALUE_TYPE (arg2);
|
||||
int promoted_len1 = TYPE_LENGTH (type1);
|
||||
int promoted_len2 = TYPE_LENGTH (type2);
|
||||
int is_unsigned1 = TYPE_UNSIGNED (type1);
|
||||
|
@ -937,13 +989,15 @@ value_logical_not (arg1)
|
|||
{
|
||||
register int len;
|
||||
register char *p;
|
||||
struct type *type1;
|
||||
|
||||
COERCE_ARRAY (arg1);
|
||||
type1 = check_typedef (VALUE_TYPE (arg1));
|
||||
|
||||
if (TYPE_CODE (VALUE_TYPE (arg1)) == TYPE_CODE_FLT)
|
||||
if (TYPE_CODE (type1) == TYPE_CODE_FLT)
|
||||
return 0 == value_as_double (arg1);
|
||||
|
||||
len = TYPE_LENGTH (VALUE_TYPE (arg1));
|
||||
len = TYPE_LENGTH (type1);
|
||||
p = VALUE_CONTENTS (arg1);
|
||||
|
||||
while (--len >= 0)
|
||||
|
@ -965,14 +1019,17 @@ value_equal (arg1, arg2)
|
|||
{
|
||||
register int len;
|
||||
register char *p1, *p2;
|
||||
struct type *type1, *type2;
|
||||
enum type_code code1;
|
||||
enum type_code code2;
|
||||
|
||||
COERCE_ARRAY (arg1);
|
||||
COERCE_ARRAY (arg2);
|
||||
|
||||
code1 = TYPE_CODE (VALUE_TYPE (arg1));
|
||||
code2 = TYPE_CODE (VALUE_TYPE (arg2));
|
||||
type1 = check_typedef (VALUE_TYPE (arg1));
|
||||
type2 = check_typedef (VALUE_TYPE (arg2));
|
||||
code1 = TYPE_CODE (type1);
|
||||
code2 = TYPE_CODE (type2);
|
||||
|
||||
if (code1 == TYPE_CODE_INT && code2 == TYPE_CODE_INT)
|
||||
return longest_to_int (value_as_long (value_binop (arg1, arg2,
|
||||
|
@ -989,8 +1046,8 @@ value_equal (arg1, arg2)
|
|||
return (CORE_ADDR) value_as_long (arg1) == value_as_pointer (arg2);
|
||||
|
||||
else if (code1 == code2
|
||||
&& ((len = TYPE_LENGTH (VALUE_TYPE (arg1)))
|
||||
== TYPE_LENGTH (VALUE_TYPE (arg2))))
|
||||
&& ((len = TYPE_LENGTH (type1))
|
||||
== TYPE_LENGTH (type2)))
|
||||
{
|
||||
p1 = VALUE_CONTENTS (arg1);
|
||||
p2 = VALUE_CONTENTS (arg2);
|
||||
|
@ -1017,12 +1074,15 @@ value_less (arg1, arg2)
|
|||
{
|
||||
register enum type_code code1;
|
||||
register enum type_code code2;
|
||||
struct type *type1, *type2;
|
||||
|
||||
COERCE_ARRAY (arg1);
|
||||
COERCE_ARRAY (arg2);
|
||||
|
||||
code1 = TYPE_CODE (VALUE_TYPE (arg1));
|
||||
code2 = TYPE_CODE (VALUE_TYPE (arg2));
|
||||
type1 = check_typedef (VALUE_TYPE (arg1));
|
||||
type2 = check_typedef (VALUE_TYPE (arg2));
|
||||
code1 = TYPE_CODE (type1);
|
||||
code2 = TYPE_CODE (type2);
|
||||
|
||||
if (code1 == TYPE_CODE_INT && code2 == TYPE_CODE_INT)
|
||||
return longest_to_int (value_as_long (value_binop (arg1, arg2,
|
||||
|
@ -1057,7 +1117,7 @@ value_neg (arg1)
|
|||
|
||||
COERCE_ENUM (arg1);
|
||||
|
||||
type = VALUE_TYPE (arg1);
|
||||
type = check_typedef (VALUE_TYPE (arg1));
|
||||
|
||||
if (TYPE_CODE (type) == TYPE_CODE_FLT)
|
||||
return value_from_double (type, - value_as_double (arg1));
|
||||
|
@ -1075,7 +1135,7 @@ value_complement (arg1)
|
|||
{
|
||||
COERCE_ENUM (arg1);
|
||||
|
||||
if (TYPE_CODE (VALUE_TYPE (arg1)) != TYPE_CODE_INT)
|
||||
if (TYPE_CODE (check_typedef (VALUE_TYPE (arg1))) != TYPE_CODE_INT)
|
||||
error ("Argument to complement operation not an integer.");
|
||||
|
||||
return value_from_longest (VALUE_TYPE (arg1), ~ value_as_long (arg1));
|
||||
|
@ -1091,15 +1151,12 @@ value_bit_index (type, valaddr, index)
|
|||
char *valaddr;
|
||||
int index;
|
||||
{
|
||||
struct type *range;
|
||||
int low_bound, high_bound;
|
||||
LONGEST low_bound, high_bound;
|
||||
LONGEST word;
|
||||
unsigned rel_index;
|
||||
range = TYPE_FIELD_TYPE (type, 0);
|
||||
if (TYPE_CODE (range) != TYPE_CODE_RANGE)
|
||||
struct type *range = TYPE_FIELD_TYPE (type, 0);
|
||||
if (get_discrete_bounds (range, &low_bound, &high_bound) < 0)
|
||||
return -2;
|
||||
low_bound = TYPE_LOW_BOUND (range);
|
||||
high_bound = TYPE_HIGH_BOUND (range);
|
||||
if (index < low_bound || index > high_bound)
|
||||
return -1;
|
||||
rel_index = index - low_bound;
|
||||
|
@ -1116,14 +1173,16 @@ value_in (element, set)
|
|||
value_ptr element, set;
|
||||
{
|
||||
int member;
|
||||
if (TYPE_CODE (VALUE_TYPE (set)) != TYPE_CODE_SET)
|
||||
struct type *settype = check_typedef (VALUE_TYPE (set));
|
||||
struct type *eltype = check_typedef (VALUE_TYPE (element));
|
||||
if (TYPE_CODE (settype) != TYPE_CODE_SET)
|
||||
error ("Second argument of 'IN' has wrong type");
|
||||
if (TYPE_CODE (VALUE_TYPE (element)) != TYPE_CODE_INT
|
||||
&& TYPE_CODE (VALUE_TYPE (element)) != TYPE_CODE_CHAR
|
||||
&& TYPE_CODE (VALUE_TYPE (element)) != TYPE_CODE_ENUM
|
||||
&& TYPE_CODE (VALUE_TYPE (element)) != TYPE_CODE_BOOL)
|
||||
if (TYPE_CODE (eltype) != TYPE_CODE_INT
|
||||
&& TYPE_CODE (eltype) != TYPE_CODE_CHAR
|
||||
&& TYPE_CODE (eltype) != TYPE_CODE_ENUM
|
||||
&& TYPE_CODE (eltype) != TYPE_CODE_BOOL)
|
||||
error ("First argument of 'IN' has wrong type");
|
||||
member = value_bit_index (VALUE_TYPE (set), VALUE_CONTENTS (set),
|
||||
member = value_bit_index (settype, VALUE_CONTENTS (set),
|
||||
value_as_long (element));
|
||||
if (member < 0)
|
||||
error ("First argument of 'IN' not in range");
|
||||
|
|
|
@ -16,7 +16,7 @@ GNU General Public License for more details.
|
|||
|
||||
You should have received a copy of the GNU General Public License
|
||||
along with this program; if not, write to the Free Software
|
||||
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
||||
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
|
||||
|
||||
#include "defs.h"
|
||||
#include "gdb_string.h"
|
||||
|
@ -135,6 +135,7 @@ val_print (type, valaddr, address, stream, format, deref_ref, recurse, pretty)
|
|||
int recurse;
|
||||
enum val_prettyprint pretty;
|
||||
{
|
||||
struct type *real_type = check_typedef (type);
|
||||
if (pretty == Val_pretty_default)
|
||||
{
|
||||
pretty = prettyprint_structs ? Val_prettyprint : Val_no_prettyprint;
|
||||
|
@ -146,8 +147,8 @@ val_print (type, valaddr, address, stream, format, deref_ref, recurse, pretty)
|
|||
only a stub and we can't find and substitute its complete type, then
|
||||
print appropriate string and return. */
|
||||
|
||||
check_stub_type (type);
|
||||
if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
|
||||
if (TYPE_FLAGS (real_type) & TYPE_FLAG_STUB
|
||||
|| TYPE_LENGTH (real_type) == 0)
|
||||
{
|
||||
fprintf_filtered (stream, "<incomplete type>");
|
||||
gdb_flush (stream);
|
||||
|
@ -576,7 +577,7 @@ val_print_array_elements (type, valaddr, address, stream, format, deref_ref,
|
|||
unsigned int reps;
|
||||
|
||||
elttype = TYPE_TARGET_TYPE (type);
|
||||
eltlen = TYPE_LENGTH (elttype);
|
||||
eltlen = TYPE_LENGTH (check_typedef (elttype));
|
||||
len = TYPE_LENGTH (type) / eltlen;
|
||||
|
||||
annotate_array_section_begin (i, elttype);
|
||||
|
@ -632,63 +633,6 @@ val_print_array_elements (type, valaddr, address, stream, format, deref_ref,
|
|||
}
|
||||
}
|
||||
|
||||
void
|
||||
value_print_array_elements (val, stream, format, pretty)
|
||||
value_ptr val;
|
||||
GDB_FILE *stream;
|
||||
int format;
|
||||
enum val_prettyprint pretty;
|
||||
{
|
||||
unsigned int things_printed = 0;
|
||||
register unsigned int i, n, typelen;
|
||||
/* Position of the array elem we are examining to see if it is repeated. */
|
||||
unsigned int rep1;
|
||||
/* Number of repetitions we have detected so far. */
|
||||
unsigned int reps;
|
||||
|
||||
n = VALUE_REPETITIONS (val);
|
||||
typelen = TYPE_LENGTH (VALUE_TYPE (val));
|
||||
for (i = 0; i < n && things_printed < print_max; i++)
|
||||
{
|
||||
if (i != 0)
|
||||
{
|
||||
fprintf_filtered (stream, ", ");
|
||||
}
|
||||
wrap_here ("");
|
||||
|
||||
rep1 = i + 1;
|
||||
reps = 1;
|
||||
while (rep1 < n && !memcmp (VALUE_CONTENTS (val) + typelen * i,
|
||||
VALUE_CONTENTS (val) + typelen * rep1,
|
||||
typelen))
|
||||
{
|
||||
++reps;
|
||||
++rep1;
|
||||
}
|
||||
|
||||
if (reps > repeat_count_threshold)
|
||||
{
|
||||
val_print (VALUE_TYPE (val), VALUE_CONTENTS (val) + typelen * i,
|
||||
VALUE_ADDRESS (val) + typelen * i, stream, format, 1,
|
||||
0, pretty);
|
||||
fprintf_filtered (stream, " <repeats %u times>", reps);
|
||||
i = rep1 - 1;
|
||||
things_printed += repeat_count_threshold;
|
||||
}
|
||||
else
|
||||
{
|
||||
val_print (VALUE_TYPE (val), VALUE_CONTENTS (val) + typelen * i,
|
||||
VALUE_ADDRESS (val) + typelen * i, stream, format, 1,
|
||||
0, pretty);
|
||||
things_printed++;
|
||||
}
|
||||
}
|
||||
if (i < n)
|
||||
{
|
||||
fprintf_filtered (stream, "...");
|
||||
}
|
||||
}
|
||||
|
||||
/* Print a string from the inferior, starting at ADDR and printing up to LEN
|
||||
characters, to STREAM. If LEN is zero, printing stops at the first null
|
||||
byte, otherwise printing proceeds (including null bytes) until either
|
||||
|
|
Loading…
Reference in New Issue