{
struct value *v = allocate_value (type);
if (valaddr == NULL)
- VALUE_LAZY (v) = 1;
+ set_value_lazy (v, 1);
else
memcpy (value_contents_raw (v), valaddr, TYPE_LENGTH (type));
VALUE_ADDRESS (v) = address;
result = allocate_value (type);
VALUE_LVAL (result) = VALUE_LVAL (val);
- result->bitsize = value_bitsize (val);
- result->bitpos = value_bitpos (val);
+ set_value_bitsize (result, value_bitsize (val));
+ set_value_bitpos (result, value_bitpos (val));
VALUE_ADDRESS (result) = VALUE_ADDRESS (val) + value_offset (val);
- if (VALUE_LAZY (val)
+ if (value_lazy (val)
|| TYPE_LENGTH (type) > TYPE_LENGTH (value_type (val)))
- VALUE_LAZY (result) = 1;
+ set_value_lazy (result, 1);
else
- memcpy (value_contents_raw (result), VALUE_CONTENTS (val),
+ memcpy (value_contents_raw (result), value_contents (val),
TYPE_LENGTH (type));
return result;
}
struct value *mark = value_mark ();
struct value *dummy = value_from_longest (builtin_type_long, 0);
struct type *result;
- dummy->type = type;
+ deprecated_set_value_type (dummy, type);
result = ada_type_of_array (dummy, 0);
value_free_to_mark (mark);
return result;
v = allocate_value (type);
bytes = (unsigned char *) (valaddr + offset);
}
- else if (VALUE_LAZY (obj))
+ else if (value_lazy (obj))
{
v = value_at (type,
VALUE_ADDRESS (obj) + value_offset (obj) + offset);
else
{
v = allocate_value (type);
- bytes = (unsigned char *) VALUE_CONTENTS (obj) + offset;
+ bytes = (unsigned char *) value_contents (obj) + offset;
}
if (obj != NULL)
if (VALUE_LVAL (obj) == lval_internalvar)
VALUE_LVAL (v) = lval_internalvar_component;
VALUE_ADDRESS (v) = VALUE_ADDRESS (obj) + value_offset (obj) + offset;
- v->bitpos = bit_offset + value_bitpos (obj);
- v->bitsize = bit_size;
+ set_value_bitpos (v, bit_offset + value_bitpos (obj));
+ set_value_bitsize (v, bit_size);
if (value_bitpos (v) >= HOST_CHAR_BIT)
{
VALUE_ADDRESS (v) += 1;
- v->bitpos -= HOST_CHAR_BIT;
+ set_value_bitpos (v, value_bitpos (v) - HOST_CHAR_BIT);
}
}
else
- v->bitsize = bit_size;
- unpacked = (unsigned char *) VALUE_CONTENTS (v);
+ set_value_bitsize (v, bit_size);
+ unpacked = (unsigned char *) value_contents (v);
srcBitsLeft = bit_size;
nsrc = len;
TARGET, starting at bit offset TARG_OFFSET. SOURCE and TARGET must
not overlap. */
static void
-move_bits (char *target, int targ_offset, char *source, int src_offset, int n)
+move_bits (bfd_byte *target, int targ_offset, const bfd_byte *source,
+ int src_offset, int n)
{
unsigned int accum, mask;
int accum_bits, chunk_size;
struct type *type = value_type (toval);
int bits = value_bitsize (toval);
- if (!toval->modifiable)
+ if (!deprecated_value_modifiable (toval))
error (_("Left operand of assignment is not a modifiable lvalue."));
toval = coerce_ref (toval);
read_memory (VALUE_ADDRESS (toval) + value_offset (toval), buffer, len);
if (BITS_BIG_ENDIAN)
move_bits (buffer, value_bitpos (toval),
- VALUE_CONTENTS (fromval),
+ value_contents (fromval),
TYPE_LENGTH (value_type (fromval)) * TARGET_CHAR_BIT -
bits, bits);
else
- move_bits (buffer, value_bitpos (toval), VALUE_CONTENTS (fromval),
+ move_bits (buffer, value_bitpos (toval), value_contents (fromval),
0, bits);
write_memory (VALUE_ADDRESS (toval) + value_offset (toval), buffer,
len);
val = value_copy (toval);
- memcpy (value_contents_raw (val), VALUE_CONTENTS (fromval),
+ memcpy (value_contents_raw (val), value_contents (fromval),
TYPE_LENGTH (type));
- val->type = type;
+ deprecated_set_value_type (val, type);
return val;
}
else if (is_enumeral
&& TYPE_NAME (SYMBOL_TYPE (syms[i].sym)) != NULL)
{
- printf_unfiltered ("[%d] ", i + first_choice);
+ printf_unfiltered (("[%d] "), i + first_choice);
ada_print_type (SYMBOL_TYPE (syms[i].sym), NULL,
gdb_stdout, -1, 0);
printf_unfiltered (_("'(%s) (enumeral)\n"),
if (prompt == NULL)
prompt = ">";
- printf_unfiltered ("%s ", prompt);
+ printf_unfiltered (("%s "), prompt);
gdb_flush (gdb_stdout);
args = command_line_input ((char *) NULL, 0, annotation_suffix);
actual_type = ada_check_typedef (value_type (actual));
val = allocate_value (actual_type);
memcpy ((char *) value_contents_raw (val),
- (char *) VALUE_CONTENTS (actual),
+ (char *) value_contents (actual),
TYPE_LENGTH (actual_type));
actual = ensure_lval (val, sp);
}
for (i = ada_array_arity (ada_check_typedef (value_type (arr))); i > 0; i -= 1)
{
- modify_general_field (VALUE_CONTENTS (bounds),
+ modify_general_field (value_contents_writeable (bounds),
value_as_long (ada_array_bound (arr, i, 0)),
desc_bound_bitpos (bounds_type, i, 0),
desc_bound_bitsize (bounds_type, i, 0));
- modify_general_field (VALUE_CONTENTS (bounds),
+ modify_general_field (value_contents_writeable (bounds),
value_as_long (ada_array_bound (arr, i, 1)),
desc_bound_bitpos (bounds_type, i, 1),
desc_bound_bitsize (bounds_type, i, 1));
bounds = ensure_lval (bounds, sp);
- modify_general_field (VALUE_CONTENTS (descriptor),
+ modify_general_field (value_contents_writeable (descriptor),
VALUE_ADDRESS (ensure_lval (arr, sp)),
fat_pntr_data_bitpos (desc_type),
fat_pntr_data_bitsize (desc_type));
- modify_general_field (VALUE_CONTENTS (descriptor),
+ modify_general_field (value_contents_writeable (descriptor),
VALUE_ADDRESS (bounds),
fat_pntr_bounds_bitpos (desc_type),
fat_pntr_bounds_bitsize (desc_type));
int bit_pos = TYPE_FIELD_BITPOS (arg_type, fieldno);
int bit_size = TYPE_FIELD_BITSIZE (arg_type, fieldno);
- return ada_value_primitive_packed_val (arg1, VALUE_CONTENTS (arg1),
+ return ada_value_primitive_packed_val (arg1, value_contents (arg1),
offset + bit_pos / 8,
bit_pos % 8, bit_size, type);
}
if (TYPE_CODE (t) == TYPE_CODE_PTR)
address = value_as_address (arg);
else
- address = unpack_pointer (t, VALUE_CONTENTS (arg));
+ address = unpack_pointer (t, value_contents (arg));
t1 = ada_to_fixed_type (ada_get_base_type (t1), NULL, address, NULL);
if (find_struct_field (name, t1, 0,
which =
ada_which_variant_applies (var_type,
- value_type (dval), VALUE_CONTENTS (dval));
+ value_type (dval), value_contents (dval));
if (which < 0)
return empty_record (TYPE_OBJFILE (var_type));
|| TYPE_LENGTH (TYPE_TARGET_TYPE (type2))
!= TYPE_LENGTH (TYPE_TARGET_TYPE (type2)))
error (_("Incompatible types in assignment"));
- val->type = type;
+ deprecated_set_value_type (val, type);
}
return val;
}
and do not have user-defined equality. */
return
TYPE_LENGTH (value_type (arg1)) == TYPE_LENGTH (value_type (arg2))
- && memcmp (VALUE_CONTENTS (arg1), VALUE_CONTENTS (arg2),
+ && memcmp (value_contents (arg1), value_contents (arg2),
TYPE_LENGTH (value_type (arg1))) == 0;
}
return value_equal (arg1, arg2);
if (err_msg == NULL)
return 0;
else
- error ("%s", err_msg);
+ error (("%s"), err_msg);
}
return value_of_variable (syms[0].sym, syms[0].block);