/* Perform non-arithmetic operations on values, for GDB.
- Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
- 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
+
+ Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
+ 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
Free Software Foundation, Inc.
This file is part of GDB.
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., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA. */
#include "defs.h"
#include "symtab.h"
struct type *curtype,
char *name,
struct type *intype,
+ int want_address,
enum noside noside);
static struct value *value_namespace_elt (const struct type *curtype,
- char *name,
+ char *name, int want_address,
enum noside noside);
static struct value *value_maybe_namespace_elt (const struct type *curtype,
- char *name,
+ char *name, int want_address,
enum noside noside);
static CORE_ADDR allocate_space_in_inferior (int);
#endif
int overload_resolution = 0;
+static void
+show_overload_resolution (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("\
+Overload resolution in evaluating C++ functions is %s.\n"),
+ value);
+}
/* Find the address of function name NAME in the inferior. */
{
if (SYMBOL_CLASS (sym) != LOC_BLOCK)
{
- error ("\"%s\" exists in this program but is not a function.",
+ error (_("\"%s\" exists in this program but is not a function."),
name);
}
return value_of_variable (sym, NULL);
else
{
if (!target_has_execution)
- error ("evaluation of this expression requires the target program to be active");
+ error (_("evaluation of this expression requires the target program to be active"));
else
- error ("evaluation of this expression requires the program to have a function \"%s\".", name);
+ error (_("evaluation of this expression requires the program to have a function \"%s\"."), name);
}
}
}
if (value_logical_not (val))
{
if (!target_has_execution)
- error ("No memory available to program now: you need to start the target first");
+ error (_("No memory available to program now: you need to start the target first"));
else
- error ("No memory available to program: call to malloc failed");
+ error (_("No memory available to program: call to malloc failed"));
}
return val;
}
return value_as_long (value_allocate_space_in_inferior (len));
}
+/* Cast one pointer or reference type to another. Both TYPE and
+ the type of ARG2 should be pointer types, or else both should be
+ reference types. Returns the new pointer or reference. */
+
+struct value *
+value_cast_pointers (struct type *type, struct value *arg2)
+{
+ struct type *type2 = check_typedef (value_type (arg2));
+ struct type *t1 = check_typedef (TYPE_TARGET_TYPE (type));
+ struct type *t2 = check_typedef (TYPE_TARGET_TYPE (type2));
+
+ if (TYPE_CODE (t1) == TYPE_CODE_STRUCT
+ && TYPE_CODE (t2) == TYPE_CODE_STRUCT
+ && !value_logical_not (arg2))
+ {
+ struct value *v;
+
+ /* Look in the type of the source to see if it contains the
+ type of the target as a superclass. If so, we'll need to
+ offset the pointer rather than just change its type. */
+ if (TYPE_NAME (t1) != NULL)
+ {
+ struct value *v2;
+
+ if (TYPE_CODE (type2) == TYPE_CODE_REF)
+ v2 = coerce_ref (arg2);
+ else
+ v2 = value_ind (arg2);
+ v = search_struct_field (type_name_no_tag (t1),
+ v2, 0, t2, 1);
+ if (v)
+ {
+ v = value_addr (v);
+ deprecated_set_value_type (v, type);
+ return v;
+ }
+ }
+
+ /* Look in the type of the target to see if it contains the
+ type of the source as a superclass. If so, we'll need to
+ offset the pointer rather than just change its type.
+ FIXME: This fails silently with virtual inheritance. */
+ if (TYPE_NAME (t2) != NULL)
+ {
+ v = search_struct_field (type_name_no_tag (t2),
+ value_zero (t1, not_lval), 0, t1, 1);
+ if (v)
+ {
+ CORE_ADDR addr2 = value_as_address (arg2);
+ addr2 -= (VALUE_ADDRESS (v)
+ + value_offset (v)
+ + value_embedded_offset (v));
+ return value_from_pointer (type, addr2);
+ }
+ }
+ }
+
+ /* No superclass found, just change the pointer type. */
+ arg2 = value_copy (arg2);
+ deprecated_set_value_type (arg2, type);
+ arg2 = value_change_enclosing_type (arg2, type);
+ set_value_pointed_to_offset (arg2, 0); /* pai: chk_val */
+ return arg2;
+}
+
/* Cast value ARG2 to type TYPE and return as a value.
More general than a C cast: accepts any two types of the same length,
and if ARG2 is an lvalue it can be cast into anything at all. */
arg2 = coerce_ref (arg2);
type2 = check_typedef (value_type (arg2));
+ /* You can't cast to a reference type. See value_cast_pointers
+ instead. */
+ gdb_assert (code1 != TYPE_CODE_REF);
+
/* A cast to an undetermined-length array_type, such as (TYPE [])OBJECT,
is treated like a cast to (TYPE [N])OBJECT,
where N is sizeof(OBJECT)/sizeof(TYPE). */
low_bound = 0, high_bound = 0;
new_length = val_length / element_length;
if (val_length % element_length != 0)
- warning ("array element type size does not divide object size in cast");
+ warning (_("array element type size does not divide object size in cast"));
/* FIXME-type-allocation: need a way to free this type when we are
done with it. */
range_type = create_range_type ((struct type *) NULL,
TYPE_TARGET_TYPE (range_type),
low_bound,
new_length + low_bound - 1);
- arg2->type = create_array_type ((struct type *) NULL,
- element_type, range_type);
+ deprecated_set_value_type (arg2, create_array_type ((struct type *) NULL,
+ element_type, range_type));
return arg2;
}
}
arg2, 0, type2, 1);
if (v)
{
- v->type = type;
+ deprecated_set_value_type (v, type);
return v;
}
}
return value_from_double (type, value_as_double (arg2));
else if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_ENUM
|| code1 == TYPE_CODE_RANGE)
- && (scalar || code2 == TYPE_CODE_PTR))
+ && (scalar || code2 == TYPE_CODE_PTR
+ || code2 == TYPE_CODE_MEMBERPTR))
{
LONGEST longest;
- if (deprecated_hp_som_som_object_present /* if target compiled by HP aCC */
- && (code2 == TYPE_CODE_PTR))
+ /* If target compiled by HP aCC. */
+ if (deprecated_hp_som_som_object_present
+ && code2 == TYPE_CODE_MEMBERPTR)
{
unsigned int *ptr;
struct value *retvalp;
- switch (TYPE_CODE (TYPE_TARGET_TYPE (type2)))
- {
- /* With HP aCC, pointers to data members have a bias */
- case TYPE_CODE_MEMBER:
- retvalp = value_from_longest (type, value_as_long (arg2));
- /* force evaluation */
- ptr = (unsigned int *) VALUE_CONTENTS (retvalp);
- *ptr &= ~0x20000000; /* zap 29th bit to remove bias */
- return retvalp;
-
- /* While pointers to methods don't really point to a function */
- case TYPE_CODE_METHOD:
- error ("Pointers to methods not supported with HP aCC");
-
- default:
- break; /* fall out and go to normal handling */
- }
+ /* With HP aCC, pointers to data members have a bias. */
+ retvalp = value_from_longest (type, value_as_long (arg2));
+ /* force evaluation */
+ ptr = (unsigned int *) value_contents (retvalp);
+ *ptr &= ~0x20000000; /* zap 29th bit to remove bias */
+ return retvalp;
}
/* When we cast pointers to integers, we mustn't use
sees a cast as a simple reinterpretation of the pointer's
bits. */
if (code2 == TYPE_CODE_PTR)
- longest = extract_unsigned_integer (VALUE_CONTENTS (arg2),
+ longest = extract_unsigned_integer (value_contents (arg2),
TYPE_LENGTH (type2));
else
longest = value_as_long (arg2);
{
if (longest >= ((LONGEST) 1 << addr_bit)
|| longest <= -((LONGEST) 1 << addr_bit))
- warning ("value truncated");
+ warning (_("value truncated"));
}
return value_from_longest (type, longest);
}
+ else if (code1 == TYPE_CODE_METHODPTR && code2 == TYPE_CODE_INT
+ && value_as_long (arg2) == 0)
+ {
+ struct value *result = allocate_value (type);
+ cplus_make_method_ptr (value_contents_writeable (result), 0, 0);
+ return result;
+ }
+ else if (code1 == TYPE_CODE_MEMBERPTR && code2 == TYPE_CODE_INT
+ && value_as_long (arg2) == 0)
+ {
+ /* The Itanium C++ ABI represents NULL pointers to members as
+ minus one, instead of biasing the normal case. */
+ return value_from_longest (type, -1);
+ }
else if (TYPE_LENGTH (type) == TYPE_LENGTH (type2))
{
if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
- {
- struct type *t1 = check_typedef (TYPE_TARGET_TYPE (type));
- struct type *t2 = check_typedef (TYPE_TARGET_TYPE (type2));
- if (TYPE_CODE (t1) == TYPE_CODE_STRUCT
- && TYPE_CODE (t2) == TYPE_CODE_STRUCT
- && !value_logical_not (arg2))
- {
- struct value *v;
-
- /* Look in the type of the source to see if it contains the
- type of the target as a superclass. If so, we'll need to
- offset the pointer rather than just change its type. */
- if (TYPE_NAME (t1) != NULL)
- {
- v = search_struct_field (type_name_no_tag (t1),
- value_ind (arg2), 0, t2, 1);
- if (v)
- {
- v = value_addr (v);
- v->type = type;
- return v;
- }
- }
+ return value_cast_pointers (type, arg2);
- /* Look in the type of the target to see if it contains the
- type of the source as a superclass. If so, we'll need to
- offset the pointer rather than just change its type.
- FIXME: This fails silently with virtual inheritance. */
- if (TYPE_NAME (t2) != NULL)
- {
- v = search_struct_field (type_name_no_tag (t2),
- value_zero (t1, not_lval), 0, t1, 1);
- if (v)
- {
- CORE_ADDR addr2 = value_as_address (arg2);
- addr2 -= (VALUE_ADDRESS (v)
- + value_offset (v)
- + VALUE_EMBEDDED_OFFSET (v));
- return value_from_pointer (type, addr2);
- }
- }
- }
- /* No superclass found, just fall through to change ptr type. */
- }
- arg2->type = type;
+ arg2 = value_copy (arg2);
+ deprecated_set_value_type (arg2, type);
arg2 = value_change_enclosing_type (arg2, type);
- VALUE_POINTED_TO_OFFSET (arg2) = 0; /* pai: chk_val */
+ set_value_pointed_to_offset (arg2, 0); /* pai: chk_val */
return arg2;
}
else if (VALUE_LVAL (arg2) == lval_memory)
}
else
{
- error ("Invalid cast.");
+ error (_("Invalid cast."));
return 0;
}
}
value_zero (struct type *type, enum lval_type lv)
{
struct value *val = allocate_value (type);
-
- memset (VALUE_CONTENTS (val), 0, TYPE_LENGTH (check_typedef (type)));
VALUE_LVAL (val) = lv;
return val;
if we can be 'lazy' and defer the fetch, perhaps indefinately, call
value_at_lazy instead. value_at_lazy simply records the address of
the data and sets the lazy-evaluation-required flag. The lazy flag
- is tested in the VALUE_CONTENTS macro, which is used if and when
+ is tested in the value_contents macro, which is used if and when
the contents are actually required.
Note: value_at does *NOT* handle embedded offsets; perform such
struct value *val;
if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
- error ("Attempt to dereference a generic pointer.");
+ error (_("Attempt to dereference a generic pointer."));
val = allocate_value (type);
- read_memory (addr, VALUE_CONTENTS_ALL_RAW (val), TYPE_LENGTH (type));
+ read_memory (addr, value_contents_all_raw (val), TYPE_LENGTH (type));
VALUE_LVAL (val) = lval_memory;
VALUE_ADDRESS (val) = addr;
struct value *val;
if (TYPE_CODE (check_typedef (type)) == TYPE_CODE_VOID)
- error ("Attempt to dereference a generic pointer.");
+ error (_("Attempt to dereference a generic pointer."));
val = allocate_value (type);
VALUE_LVAL (val) = lval_memory;
VALUE_ADDRESS (val) = addr;
- VALUE_LAZY (val) = 1;
+ set_value_lazy (val, 1);
return val;
}
-/* Called only from the VALUE_CONTENTS and VALUE_CONTENTS_ALL macros,
- if the current data for a variable needs to be loaded into
- VALUE_CONTENTS(VAL). Fetches the data from the user's process, and
- clears the lazy flag to indicate that the data in the buffer is valid.
+/* Called only from the value_contents and value_contents_all()
+ macros, if the current data for a variable needs to be loaded into
+ value_contents(VAL). Fetches the data from the user's process, and
+ clears the lazy flag to indicate that the data in the buffer is
+ valid.
If the value is zero-length, we avoid calling read_memory, which would
abort. We mark the value as fetched anyway -- all 0 bytes of it.
- This function returns a value because it is used in the VALUE_CONTENTS
+ This function returns a value because it is used in the value_contents
macro as part of an expression, where a void would not work. The
value is ignored. */
value_fetch_lazy (struct value *val)
{
CORE_ADDR addr = VALUE_ADDRESS (val) + value_offset (val);
- int length = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val));
+ int length = TYPE_LENGTH (value_enclosing_type (val));
struct type *type = value_type (val);
if (length)
- read_memory (addr, VALUE_CONTENTS_ALL_RAW (val), length);
+ read_memory (addr, value_contents_all_raw (val), length);
- VALUE_LAZY (val) = 0;
+ set_value_lazy (val, 0);
return 0;
}
struct value *val;
struct frame_id old_frame;
- if (!toval->modifiable)
- error ("Left operand of assignment is not a modifiable lvalue.");
+ if (!deprecated_value_modifiable (toval))
+ error (_("Left operand of assignment is not a modifiable lvalue."));
toval = coerce_ref (toval);
case lval_internalvar:
set_internalvar (VALUE_INTERNALVAR (toval), fromval);
val = value_copy (VALUE_INTERNALVAR (toval)->value);
- val = value_change_enclosing_type (val, VALUE_ENCLOSING_TYPE (fromval));
- VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (fromval);
- VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (fromval);
+ val = value_change_enclosing_type (val, value_enclosing_type (fromval));
+ set_value_embedded_offset (val, value_embedded_offset (fromval));
+ set_value_pointed_to_offset (val, value_pointed_to_offset (fromval));
return val;
case lval_internalvar_component:
case lval_memory:
{
- char *dest_buffer;
+ const gdb_byte *dest_buffer;
CORE_ADDR changed_addr;
int changed_len;
- char buffer[sizeof (LONGEST)];
+ gdb_byte buffer[sizeof (LONGEST)];
if (value_bitsize (toval))
{
/ HOST_CHAR_BIT;
if (changed_len > (int) sizeof (LONGEST))
- error ("Can't handle bitfields which don't fit in a %d bit word.",
+ error (_("Can't handle bitfields which don't fit in a %d bit word."),
(int) sizeof (LONGEST) * HOST_CHAR_BIT);
read_memory (VALUE_ADDRESS (toval) + value_offset (toval),
{
changed_addr = VALUE_ADDRESS (toval) + value_offset (toval);
changed_len = TYPE_LENGTH (type);
- dest_buffer = VALUE_CONTENTS (fromval);
+ dest_buffer = value_contents (fromval);
}
write_memory (changed_addr, dest_buffer, changed_len);
value_reg = VALUE_REGNUM (toval);
if (!frame)
- error ("Value being assigned to is no longer active.");
+ error (_("Value being assigned to is no longer active."));
- if (VALUE_LVAL (toval) == lval_register
- && CONVERT_REGISTER_P (VALUE_REGNUM (toval), type))
+ if (CONVERT_REGISTER_P (VALUE_REGNUM (toval), type))
{
/* If TOVAL is a special machine register requiring
conversion of program values to a special raw format. */
VALUE_TO_REGISTER (frame, VALUE_REGNUM (toval),
- type, VALUE_CONTENTS (fromval));
+ type, value_contents (fromval));
}
else
{
- /* TOVAL is stored in a series of registers in the frame
- specified by the structure. Copy that value out,
- modify it, and copy it back in. */
- int amount_copied;
- int amount_to_copy;
- char *buffer;
- int reg_offset;
- int byte_offset;
- int regno;
-
- /* Locate the first register that falls in the value that
- needs to be transfered. Compute the offset of the
- value in that register. */
- {
- int offset;
- for (reg_offset = value_reg, offset = 0;
- offset + register_size (current_gdbarch, reg_offset) <= value_offset (toval);
- reg_offset++);
- byte_offset = value_offset (toval) - offset;
- }
-
- /* Compute the number of register aligned values that need
- to be copied. */
if (value_bitsize (toval))
- amount_to_copy = byte_offset + 1;
- else
- amount_to_copy = byte_offset + TYPE_LENGTH (type);
-
- /* And a bounce buffer. Be slightly over generous. */
- buffer = (char *) alloca (amount_to_copy + MAX_REGISTER_SIZE);
-
- /* Copy it in. */
- for (regno = reg_offset, amount_copied = 0;
- amount_copied < amount_to_copy;
- amount_copied += register_size (current_gdbarch, regno), regno++)
- frame_register_read (frame, regno, buffer + amount_copied);
-
- /* Modify what needs to be modified. */
- if (value_bitsize (toval))
- modify_field (buffer + byte_offset,
- value_as_long (fromval),
- value_bitpos (toval), value_bitsize (toval));
- else
- memcpy (buffer + byte_offset, VALUE_CONTENTS (fromval),
- TYPE_LENGTH (type));
+ {
+ int changed_len;
+ gdb_byte buffer[sizeof (LONGEST)];
- /* Copy it out. */
- for (regno = reg_offset, amount_copied = 0;
- amount_copied < amount_to_copy;
- amount_copied += register_size (current_gdbarch, regno), regno++)
- put_frame_register (frame, regno, buffer + amount_copied);
+ changed_len = (value_bitpos (toval)
+ + value_bitsize (toval)
+ + HOST_CHAR_BIT - 1)
+ / HOST_CHAR_BIT;
+ if (changed_len > (int) sizeof (LONGEST))
+ error (_("Can't handle bitfields which don't fit in a %d bit word."),
+ (int) sizeof (LONGEST) * HOST_CHAR_BIT);
+
+ get_frame_register_bytes (frame, value_reg,
+ value_offset (toval),
+ changed_len, buffer);
+
+ modify_field (buffer, value_as_long (fromval),
+ value_bitpos (toval), value_bitsize (toval));
+
+ put_frame_register_bytes (frame, value_reg,
+ value_offset (toval),
+ changed_len, buffer);
+ }
+ else
+ {
+ put_frame_register_bytes (frame, value_reg,
+ value_offset (toval),
+ TYPE_LENGTH (type),
+ value_contents (fromval));
+ }
}
+
if (deprecated_register_changed_hook)
deprecated_register_changed_hook (-1);
observer_notify_target_changed (¤t_target);
}
default:
- error ("Left operand of assignment is not an lvalue.");
+ error (_("Left operand of assignment is not an lvalue."));
}
/* Assigning to the stack pointer, frame pointer, and other
}
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;
- val = value_change_enclosing_type (val, VALUE_ENCLOSING_TYPE (fromval));
- VALUE_EMBEDDED_OFFSET (val) = VALUE_EMBEDDED_OFFSET (fromval);
- VALUE_POINTED_TO_OFFSET (val) = VALUE_POINTED_TO_OFFSET (fromval);
+ deprecated_set_value_type (val, type);
+ val = value_change_enclosing_type (val, value_enclosing_type (fromval));
+ set_value_embedded_offset (val, value_embedded_offset (fromval));
+ set_value_pointed_to_offset (val, value_pointed_to_offset (fromval));
return val;
}
struct value *val;
if (VALUE_LVAL (arg1) != lval_memory)
- error ("Only values in memory can be extended with '@'.");
+ error (_("Only values in memory can be extended with '@'."));
if (count < 1)
- error ("Invalid number %d of repetitions.", count);
+ error (_("Invalid number %d of repetitions."), count);
- val = allocate_repeat_value (VALUE_ENCLOSING_TYPE (arg1), count);
+ val = allocate_repeat_value (value_enclosing_type (arg1), count);
read_memory (VALUE_ADDRESS (arg1) + value_offset (arg1),
- VALUE_CONTENTS_ALL_RAW (val),
- TYPE_LENGTH (VALUE_ENCLOSING_TYPE (val)));
+ value_contents_all_raw (val),
+ TYPE_LENGTH (value_enclosing_type (val)));
VALUE_LVAL (val) = lval_memory;
VALUE_ADDRESS (val) = VALUE_ADDRESS (arg1) + value_offset (arg1);
{
if (BLOCK_FUNCTION (b)
&& SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)))
- error ("No frame is currently executing in block %s.",
+ error (_("No frame is currently executing in block %s."),
SYMBOL_PRINT_NAME (BLOCK_FUNCTION (b)));
else
- error ("No frame is currently executing in specified block");
+ error (_("No frame is currently executing in specified block"));
}
}
val = read_var_value (var, frame);
if (!val)
- error ("Address of symbol \"%s\" is unknown.", SYMBOL_PRINT_NAME (var));
+ error (_("Address of symbol \"%s\" is unknown."), SYMBOL_PRINT_NAME (var));
return val;
}
struct type *type = check_typedef (value_type (arg1));
if (VALUE_LVAL (arg1) != lval_memory)
- error ("Attempt to take address of value not located in memory.");
+ error (_("Attempt to take address of value not located in memory."));
return value_from_pointer (lookup_pointer_type (TYPE_TARGET_TYPE (type)),
(VALUE_ADDRESS (arg1) + value_offset (arg1)));
struct value *retval;
if (VALUE_LVAL (arg1) != lval_memory)
- error ("Attempt to take address of value not located in memory.");
+ error (_("Attempt to take address of value not located in memory."));
retval = value_from_pointer (lookup_pointer_type (value_type (arg1)),
(VALUE_ADDRESS (arg1) + value_offset (arg1)));
We keep the same location information, which is efficient,
and allows &(&X) to get the location containing the reference. */
arg2 = value_copy (arg1);
- arg2->type = lookup_pointer_type (TYPE_TARGET_TYPE (type));
+ deprecated_set_value_type (arg2, lookup_pointer_type (TYPE_TARGET_TYPE (type)));
return arg2;
}
if (TYPE_CODE (type) == TYPE_CODE_FUNC)
return value_coerce_function (arg1);
if (VALUE_LVAL (arg1) != lval_memory)
- error ("Attempt to take address of value not located in memory.");
+ error (_("Attempt to take address of value not located in memory."));
/* Get target memory address */
arg2 = value_from_pointer (lookup_pointer_type (value_type (arg1)),
(VALUE_ADDRESS (arg1)
+ value_offset (arg1)
- + VALUE_EMBEDDED_OFFSET (arg1)));
+ + value_embedded_offset (arg1)));
/* This may be a pointer to a base subobject; so remember the
full derived object's type ... */
- arg2 = value_change_enclosing_type (arg2, lookup_pointer_type (VALUE_ENCLOSING_TYPE (arg1)));
+ arg2 = value_change_enclosing_type (arg2, lookup_pointer_type (value_enclosing_type (arg1)));
/* ... and also the relative position of the subobject in the full object */
- VALUE_POINTED_TO_OFFSET (arg2) = VALUE_EMBEDDED_OFFSET (arg1);
+ set_value_pointed_to_offset (arg2, value_embedded_offset (arg1));
+ return arg2;
+}
+
+/* Return a reference value for the object for which ARG1 is the contents. */
+
+struct value *
+value_ref (struct value *arg1)
+{
+ struct value *arg2;
+
+ struct type *type = check_typedef (value_type (arg1));
+ if (TYPE_CODE (type) == TYPE_CODE_REF)
+ return arg1;
+
+ arg2 = value_addr (arg1);
+ deprecated_set_value_type (arg2, lookup_reference_type (type));
return arg2;
}
base_type = check_typedef (value_type (arg1));
- if (TYPE_CODE (base_type) == TYPE_CODE_MEMBER)
- error ("not implemented: member types in value_ind");
-
/* Allow * on an integer so we can cast it to whatever we want.
This returns an int, which seems like the most C-like thing
to do. "long long" variables are rare enough that
struct type *enc_type;
/* We may be pointing to something embedded in a larger object */
/* Get the real type of the enclosing object */
- enc_type = check_typedef (VALUE_ENCLOSING_TYPE (arg1));
+ enc_type = check_typedef (value_enclosing_type (arg1));
enc_type = TYPE_TARGET_TYPE (enc_type);
- /* Retrieve the enclosing object pointed to */
- arg2 = value_at_lazy (enc_type, (value_as_address (arg1)
- - VALUE_POINTED_TO_OFFSET (arg1)));
+
+ if (TYPE_CODE (check_typedef (enc_type)) == TYPE_CODE_FUNC
+ || TYPE_CODE (check_typedef (enc_type)) == TYPE_CODE_METHOD)
+ /* For functions, go through find_function_addr, which knows
+ how to handle function descriptors. */
+ arg2 = value_at_lazy (enc_type, find_function_addr (arg1, NULL));
+ else
+ /* Retrieve the enclosing object pointed to */
+ arg2 = value_at_lazy (enc_type, (value_as_address (arg1)
+ - value_pointed_to_offset (arg1)));
+
/* Re-adjust type */
- arg2->type = TYPE_TARGET_TYPE (base_type);
+ deprecated_set_value_type (arg2, TYPE_TARGET_TYPE (base_type));
/* Add embedding info */
arg2 = value_change_enclosing_type (arg2, enc_type);
- VALUE_EMBEDDED_OFFSET (arg2) = VALUE_POINTED_TO_OFFSET (arg1);
+ set_value_embedded_offset (arg2, value_pointed_to_offset (arg1));
/* We may be pointing to an object of some derived type */
arg2 = value_full_object (arg2, NULL, 0, 0, 0);
return arg2;
}
- error ("Attempt to take contents of a non-pointer value.");
+ error (_("Attempt to take contents of a non-pointer value."));
return 0; /* For lint -- never reached */
}
\f
-/* Pushing small parts of stack frames. */
-
-/* Push one word (the size of object that a register holds). */
-
-CORE_ADDR
-push_word (CORE_ADDR sp, ULONGEST word)
-{
- int len = DEPRECATED_REGISTER_SIZE;
- char buffer[MAX_REGISTER_SIZE];
-
- store_unsigned_integer (buffer, len, word);
- if (INNER_THAN (1, 2))
- {
- /* stack grows downward */
- sp -= len;
- write_memory (sp, buffer, len);
- }
- else
- {
- /* stack grows upward */
- write_memory (sp, buffer, len);
- sp += len;
- }
-
- return sp;
-}
-
-/* Push LEN bytes with data at BUFFER. */
-
-CORE_ADDR
-push_bytes (CORE_ADDR sp, char *buffer, int len)
-{
- if (INNER_THAN (1, 2))
- {
- /* stack grows downward */
- sp -= len;
- write_memory (sp, buffer, len);
- }
- else
- {
- /* stack grows upward */
- write_memory (sp, buffer, len);
- sp += len;
- }
-
- return sp;
-}
-
/* Create a value for an array by allocating space in the inferior, copying
the data into that space, and then setting up an array value.
nelem = highbound - lowbound + 1;
if (nelem <= 0)
{
- error ("bad array bounds (%d, %d)", lowbound, highbound);
+ error (_("bad array bounds (%d, %d)"), lowbound, highbound);
}
- typelength = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec[0]));
+ typelength = TYPE_LENGTH (value_enclosing_type (elemvec[0]));
for (idx = 1; idx < nelem; idx++)
{
- if (TYPE_LENGTH (VALUE_ENCLOSING_TYPE (elemvec[idx])) != typelength)
+ if (TYPE_LENGTH (value_enclosing_type (elemvec[idx])) != typelength)
{
- error ("array elements must all be the same size");
+ error (_("array elements must all be the same size"));
}
}
rangetype = create_range_type ((struct type *) NULL, builtin_type_int,
lowbound, highbound);
arraytype = create_array_type ((struct type *) NULL,
- VALUE_ENCLOSING_TYPE (elemvec[0]), rangetype);
+ value_enclosing_type (elemvec[0]), rangetype);
if (!current_language->c_style_arrays)
{
val = allocate_value (arraytype);
for (idx = 0; idx < nelem; idx++)
{
- memcpy (VALUE_CONTENTS_ALL_RAW (val) + (idx * typelength),
- VALUE_CONTENTS_ALL (elemvec[idx]),
+ memcpy (value_contents_all_raw (val) + (idx * typelength),
+ value_contents_all (elemvec[idx]),
typelength);
}
return val;
addr = allocate_space_in_inferior (nelem * typelength);
for (idx = 0; idx < nelem; idx++)
{
- write_memory (addr + (idx * typelength), VALUE_CONTENTS_ALL (elemvec[idx]),
+ write_memory (addr + (idx * typelength),
+ value_contents_all (elemvec[idx]),
typelength);
}
if (current_language->c_style_arrays == 0)
{
val = allocate_value (stringtype);
- memcpy (VALUE_CONTENTS_RAW (val), ptr, len);
+ memcpy (value_contents_raw (val), ptr, len);
return val;
}
copy LEN bytes from PTR in gdb to that address in the inferior. */
addr = allocate_space_in_inferior (len);
- write_memory (addr, ptr, len);
+ write_memory (addr, (gdb_byte *) ptr, len);
val = value_at_lazy (stringtype, addr);
return (val);
struct type *type = create_set_type ((struct type *) NULL, domain_type);
TYPE_CODE (type) = TYPE_CODE_BITSTRING;
val = allocate_value (type);
- memcpy (VALUE_CONTENTS_RAW (val), ptr, TYPE_LENGTH (type));
+ memcpy (value_contents_raw (val), ptr, TYPE_LENGTH (type));
return val;
}
\f
int i;
if (t2 == 0)
- internal_error (__FILE__, __LINE__, "typecmp: no argument list");
+ internal_error (__FILE__, __LINE__, _("typecmp: no argument list"));
/* Skip ``this'' argument if applicable. T2 will always include THIS. */
if (staticp)
if (TYPE_CODE (tt2) == TYPE_CODE_ARRAY)
t2[i] = value_coerce_array (t2[i]);
else
- t2[i] = value_addr (t2[i]);
+ t2[i] = value_ref (t2[i]);
continue;
}
{
v = value_static_field (type, i);
if (v == 0)
- error ("field %s is nonexistent or has been optimised out",
+ error (_("field %s is nonexistent or has been optimised out"),
name);
}
else
{
v = value_primitive_field (arg1, offset, i, type);
if (v == 0)
- error ("there is no field named %s", name);
+ error (_("there is no field named %s"), name);
}
return v;
}
struct value *v2 = allocate_value (basetype);
boffset = baseclass_offset (type, i,
- VALUE_CONTENTS (arg1) + offset,
+ value_contents (arg1) + offset,
VALUE_ADDRESS (arg1)
+ value_offset (arg1) + offset);
if (boffset == -1)
- error ("virtual baseclass botch");
+ error (_("virtual baseclass botch"));
/* The virtual base class pointer might have been clobbered by the
user program. Make sure that it still points to a valid memory
CORE_ADDR base_addr;
base_addr = VALUE_ADDRESS (arg1) + value_offset (arg1) + boffset;
- if (target_read_memory (base_addr, VALUE_CONTENTS_RAW (v2),
+ if (target_read_memory (base_addr, value_contents_raw (v2),
TYPE_LENGTH (basetype)) != 0)
- error ("virtual baseclass botch");
+ error (_("virtual baseclass botch"));
VALUE_LVAL (v2) = lval_memory;
VALUE_ADDRESS (v2) = base_addr;
}
{
VALUE_LVAL (v2) = VALUE_LVAL (arg1);
VALUE_ADDRESS (v2) = VALUE_ADDRESS (arg1);
- v2->offset = value_offset (arg1) + boffset;
- if (VALUE_LAZY (arg1))
- VALUE_LAZY (v2) = 1;
+ VALUE_FRAME_ID (v2) = VALUE_FRAME_ID (arg1);
+ set_value_offset (v2, value_offset (arg1) + boffset);
+ if (value_lazy (arg1))
+ set_value_lazy (v2, 1);
else
- memcpy (VALUE_CONTENTS_RAW (v2),
- VALUE_CONTENTS_RAW (arg1) + boffset,
+ memcpy (value_contents_raw (v2),
+ value_contents_raw (arg1) + boffset,
TYPE_LENGTH (basetype));
}
* conventions. */
void
-find_rt_vbase_offset (struct type *type, struct type *basetype, char *valaddr,
- int offset, int *boffset_p, int *skip_p)
+find_rt_vbase_offset (struct type *type, struct type *basetype,
+ const gdb_byte *valaddr, int offset, int *boffset_p,
+ int *skip_p)
{
int boffset; /* offset of virtual base */
int index; /* displacement to use in virtual table */
/* Before the constructor is invoked, things are usually zero'd out. */
if (vtbl == 0)
- error ("Couldn't find virtual table -- object may not be constructed yet.");
+ error (_("Couldn't find virtual table -- object may not be constructed yet."));
/* Find virtual base's offset -- jump over entries for primary base
check_stub_method_group (type, i);
if (j > 0 && args == 0)
- error ("cannot resolve overloaded method `%s': no arguments supplied", name);
+ error (_("cannot resolve overloaded method `%s': no arguments supplied"), name);
else if (j == 0 && args == 0)
{
v = value_fn_field (arg1p, f, j, type, offset);
according to HP/Taligent runtime spec. */
int skip;
find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
- VALUE_CONTENTS_ALL (*arg1p),
- offset + VALUE_EMBEDDED_OFFSET (*arg1p),
+ value_contents_all (*arg1p),
+ offset + value_embedded_offset (*arg1p),
&base_offset, &skip);
if (skip >= 0)
- error ("Virtual base class offset not found in vtable");
+ error (_("Virtual base class offset not found in vtable"));
}
else
{
struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
- char *base_valaddr;
+ const gdb_byte *base_valaddr;
/* The virtual base class pointer might have been clobbered by the
user program. Make sure that it still points to a valid memory
if (offset < 0 || offset >= TYPE_LENGTH (type))
{
- base_valaddr = (char *) alloca (TYPE_LENGTH (baseclass));
+ gdb_byte *tmp = alloca (TYPE_LENGTH (baseclass));
if (target_read_memory (VALUE_ADDRESS (*arg1p)
+ value_offset (*arg1p) + offset,
- base_valaddr,
- TYPE_LENGTH (baseclass)) != 0)
- error ("virtual baseclass botch");
+ tmp, TYPE_LENGTH (baseclass)) != 0)
+ error (_("virtual baseclass botch"));
+ base_valaddr = tmp;
}
else
- base_valaddr = VALUE_CONTENTS (*arg1p) + offset;
+ base_valaddr = value_contents (*arg1p) + offset;
base_offset =
baseclass_offset (type, i, base_valaddr,
VALUE_ADDRESS (*arg1p)
+ value_offset (*arg1p) + offset);
if (base_offset == -1)
- error ("virtual baseclass botch");
+ error (_("virtual baseclass botch"));
}
}
else
t = check_typedef (value_type (*argp));
}
- if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
- error ("not implemented: member type in value_struct_elt");
-
if (TYPE_CODE (t) != TYPE_CODE_STRUCT
&& TYPE_CODE (t) != TYPE_CODE_UNION)
- error ("Attempt to extract a component of a value that is not a %s.", err);
+ error (_("Attempt to extract a component of a value that is not a %s."), err);
/* Assume it's not, unless we see that it is. */
if (static_memfuncp)
return it as a pointer to a method. */
if (destructor_name_p (name, t))
- error ("Cannot get value of destructor");
+ error (_("Cannot get value of destructor"));
v = search_struct_method (name, argp, args, 0, static_memfuncp, t);
if (v == (struct value *) - 1)
- error ("Cannot take address of a method");
+ error (_("Cannot take address of method %s."), name);
else if (v == 0)
{
if (TYPE_NFN_FIELDS (t))
- error ("There is no member or method named %s.", name);
+ error (_("There is no member or method named %s."), name);
else
- error ("There is no member named %s.", name);
+ error (_("There is no member named %s."), name);
}
return v;
}
f_index, NULL, 0);
}
if (v == NULL)
- error ("could not find destructor function named %s.", name);
+ error (_("could not find destructor function named %s."), name);
else
return v;
}
else
{
- error ("destructor should not have any argument");
+ error (_("destructor should not have any argument"));
}
}
else
if (v == (struct value *) - 1)
{
- error ("One of the arguments you tried to pass to %s could not be converted to what the function wants.", name);
+ error (_("One of the arguments you tried to pass to %s could not be converted to what the function wants."), name);
}
else if (v == 0)
{
}
if (!v)
- error ("Structure has no component named %s.", name);
+ error (_("Structure has no component named %s."), name);
return v;
}
* according to HP/Taligent runtime spec. */
int skip;
find_rt_vbase_offset (type, TYPE_BASECLASS (type, i),
- VALUE_CONTENTS_ALL (*argp),
- offset + VALUE_EMBEDDED_OFFSET (*argp),
+ value_contents_all (*argp),
+ offset + value_embedded_offset (*argp),
&base_offset, &skip);
if (skip >= 0)
- error ("Virtual base class offset not found in vtable");
+ error (_("Virtual base class offset not found in vtable"));
}
else
{
base_offset = value_offset (*argp) + offset;
base_offset =
baseclass_offset (type, i,
- VALUE_CONTENTS (*argp) + base_offset,
+ value_contents (*argp) + base_offset,
VALUE_ADDRESS (*argp) + base_offset);
if (base_offset == -1)
- error ("virtual baseclass botch");
+ error (_("virtual baseclass botch"));
}
}
else
t = check_typedef (value_type (*argp));
}
- if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
- error ("Not implemented: member type in value_find_oload_lis");
-
if (TYPE_CODE (t) != TYPE_CODE_STRUCT
&& TYPE_CODE (t) != TYPE_CODE_UNION)
- error ("Attempt to extract a component of a value that is not a struct or union");
+ error (_("Attempt to extract a component of a value that is not a struct or union"));
return find_method_list (argp, method, 0, t, num_fns, basetype, boffset);
}
&num_fns,
&basetype, &boffset);
if (!fns_ptr || !num_fns)
- error ("Couldn't find method %s%s%s",
+ error (_("Couldn't find method %s%s%s"),
obj_type_name,
(obj_type_name && *obj_type_name) ? "::" : "",
name);
else
{
const char *qualified_name = SYMBOL_CPLUS_DEMANGLED_NAME (fsym);
- func_name = cp_func_name (qualified_name);
- /* If the name is NULL this must be a C-style function.
- Just return the same symbol. */
+ /* If we have a C++ name, try to extract just the function
+ part. */
+ if (qualified_name)
+ func_name = cp_func_name (qualified_name);
+
+ /* If there was no C++ name, this must be a C-style function.
+ Just return the same symbol. Do the same if cp_func_name
+ fails for some reason. */
if (func_name == NULL)
{
*symp = fsym;
if (match_quality == INCOMPATIBLE)
{
if (method)
- error ("Cannot resolve method %s%s%s to any overloaded instance",
+ error (_("Cannot resolve method %s%s%s to any overloaded instance"),
obj_type_name,
(obj_type_name && *obj_type_name) ? "::" : "",
name);
else
- error ("Cannot resolve function %s to any overloaded instance",
+ error (_("Cannot resolve function %s to any overloaded instance"),
func_name);
}
else if (match_quality == NON_STANDARD)
{
if (method)
- warning ("Using non-standard conversion to match method %s%s%s to supplied arguments",
+ warning (_("Using non-standard conversion to match method %s%s%s to supplied arguments"),
obj_type_name,
(obj_type_name && *obj_type_name) ? "::" : "",
name);
else
- warning ("Using non-standard conversion to match function %s to supplied arguments",
+ warning (_("Using non-standard conversion to match function %s to supplied arguments"),
func_name);
}
else
len = cp - dname;
if (strlen (name + 1) != len || strncmp (dname, name + 1, len) != 0)
- error ("name of destructor must equal name of class");
+ error (_("name of destructor must equal name of class"));
else
return 1;
}
t = TYPE_TARGET_TYPE (t);
}
- if (TYPE_CODE (t) == TYPE_CODE_MEMBER)
- error ("not implemented: member type in check_field");
-
if (TYPE_CODE (t) != TYPE_CODE_STRUCT
&& TYPE_CODE (t) != TYPE_CODE_UNION)
- error ("Internal error: `this' is not an aggregate");
+ error (_("Internal error: `this' is not an aggregate"));
return check_field_in (t, name);
}
/* C++: Given an aggregate type CURTYPE, and a member name NAME,
- return the appropriate member. This function is used to resolve
- user expressions of the form "DOMAIN::NAME". For more details on
- what happens, see the comment before
- value_struct_elt_for_reference. */
+ return the appropriate member (or the address of the member, if
+ WANT_ADDRESS). This function is used to resolve user expressions
+ of the form "DOMAIN::NAME". For more details on what happens, see
+ the comment before value_struct_elt_for_reference. */
struct value *
value_aggregate_elt (struct type *curtype,
- char *name,
+ char *name, int want_address,
enum noside noside)
{
switch (TYPE_CODE (curtype))
case TYPE_CODE_STRUCT:
case TYPE_CODE_UNION:
return value_struct_elt_for_reference (curtype, 0, curtype, name, NULL,
- noside);
+ want_address, noside);
case TYPE_CODE_NAMESPACE:
- return value_namespace_elt (curtype, name, noside);
+ return value_namespace_elt (curtype, name, want_address, noside);
default:
internal_error (__FILE__, __LINE__,
- "non-aggregate type in value_aggregate_elt");
+ _("non-aggregate type in value_aggregate_elt"));
}
}
static struct value *
value_struct_elt_for_reference (struct type *domain, int offset,
struct type *curtype, char *name,
- struct type *intype,
+ struct type *intype, int want_address,
enum noside noside)
{
struct type *t = curtype;
int i;
- struct value *v;
+ struct value *v, *result;
if (TYPE_CODE (t) != TYPE_CODE_STRUCT
&& TYPE_CODE (t) != TYPE_CODE_UNION)
- error ("Internal error: non-aggregate type to value_struct_elt_for_reference");
+ error (_("Internal error: non-aggregate type to value_struct_elt_for_reference"));
for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); i--)
{
{
v = value_static_field (t, i);
if (v == NULL)
- error ("static field %s has been optimized out",
+ error (_("static field %s has been optimized out"),
name);
+ if (want_address)
+ v = value_addr (v);
return v;
}
if (TYPE_FIELD_PACKED (t, i))
- error ("pointers to bitfield members not allowed");
-
- return value_from_longest
- (lookup_reference_type (lookup_member_type (TYPE_FIELD_TYPE (t, i),
- domain)),
- offset + (LONGEST) (TYPE_FIELD_BITPOS (t, i) >> 3));
+ error (_("pointers to bitfield members not allowed"));
+
+ if (want_address)
+ return value_from_longest
+ (lookup_memberptr_type (TYPE_FIELD_TYPE (t, i), domain),
+ offset + (LONGEST) (TYPE_FIELD_BITPOS (t, i) >> 3));
+ else if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ return allocate_value (TYPE_FIELD_TYPE (t, i));
+ else
+ error (_("Cannot reference non-static field \"%s\""), name);
}
}
/* Destructors are a special case. */
if (destructor_name_p (name, t))
{
- error ("member pointers to destructors not implemented yet");
+ error (_("member pointers to destructors not implemented yet"));
}
/* Perform all necessary dereferencing. */
check_stub_method_group (t, i);
if (intype == 0 && j > 1)
- error ("non-unique member `%s' requires type instantiation", name);
+ error (_("non-unique member `%s' requires type instantiation"), name);
if (intype)
{
while (j--)
if (TYPE_FN_FIELD_TYPE (f, j) == intype)
break;
if (j < 0)
- error ("no member function matches that type instantiation");
+ error (_("no member function matches that type instantiation"));
}
else
j = 0;
+ if (TYPE_FN_FIELD_STATIC_P (f, j))
+ {
+ struct symbol *s = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
+ 0, VAR_DOMAIN, 0, NULL);
+ if (s == NULL)
+ return NULL;
+
+ if (want_address)
+ return value_addr (read_var_value (s, 0));
+ else
+ return read_var_value (s, 0);
+ }
+
if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
{
- return value_from_longest
- (lookup_reference_type
- (lookup_member_type (TYPE_FN_FIELD_TYPE (f, j),
- domain)),
- (LONGEST) METHOD_PTR_FROM_VOFFSET (TYPE_FN_FIELD_VOFFSET (f, j)));
+ if (want_address)
+ {
+ result = allocate_value
+ (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f, j)));
+ cplus_make_method_ptr (value_contents_writeable (result),
+ TYPE_FN_FIELD_VOFFSET (f, j), 1);
+ }
+ else if (noside == EVAL_AVOID_SIDE_EFFECTS)
+ return allocate_value (TYPE_FN_FIELD_TYPE (f, j));
+ else
+ error (_("Cannot reference virtual member function \"%s\""),
+ name);
}
else
{
struct symbol *s = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, j),
0, VAR_DOMAIN, 0, NULL);
if (s == NULL)
- {
- v = 0;
- }
+ return NULL;
+
+ v = read_var_value (s, 0);
+ if (!want_address)
+ result = v;
else
{
- v = read_var_value (s, 0);
-#if 0
- VALUE_TYPE (v) = lookup_reference_type
- (lookup_member_type (TYPE_FN_FIELD_TYPE (f, j),
- domain));
-#endif
+ result = allocate_value (lookup_methodptr_type (TYPE_FN_FIELD_TYPE (f, j)));
+ cplus_make_method_ptr (value_contents_writeable (result),
+ VALUE_ADDRESS (v), 0);
}
- return v;
}
+ return result;
}
}
for (i = TYPE_N_BASECLASSES (t) - 1; i >= 0; i--)
offset + base_offset,
TYPE_BASECLASS (t, i),
name,
- intype,
+ intype, want_address,
noside);
if (v)
return v;
it up that way; this (frequently) works for types nested inside
classes. */
- return value_maybe_namespace_elt (curtype, name, noside);
+ return value_maybe_namespace_elt (curtype, name, want_address, noside);
}
/* C++: Return the member NAME of the namespace given by the type
static struct value *
value_namespace_elt (const struct type *curtype,
- char *name,
+ char *name, int want_address,
enum noside noside)
{
struct value *retval = value_maybe_namespace_elt (curtype, name,
- noside);
+ want_address, noside);
if (retval == NULL)
- error ("No symbol \"%s\" in namespace \"%s\".", name,
+ error (_("No symbol \"%s\" in namespace \"%s\"."), name,
TYPE_TAG_NAME (curtype));
return retval;
static struct value *
value_maybe_namespace_elt (const struct type *curtype,
- char *name,
+ char *name, int want_address,
enum noside noside)
{
const char *namespace_name = TYPE_TAG_NAME (curtype);
struct symbol *sym;
+ struct value *result;
sym = cp_lookup_symbol_namespace (namespace_name, name, NULL,
get_selected_block (0), VAR_DOMAIN,
return NULL;
else if ((noside == EVAL_AVOID_SIDE_EFFECTS)
&& (SYMBOL_CLASS (sym) == LOC_TYPEDEF))
- return allocate_value (SYMBOL_TYPE (sym));
+ result = allocate_value (SYMBOL_TYPE (sym));
else
- return value_of_variable (sym, get_selected_block (0));
+ result = value_of_variable (sym, get_selected_block (0));
+
+ if (result && want_address)
+ result = value_addr (result);
+
+ return result;
}
/* Given a pointer value V, find the real (RTTI) type
real_type = value_rtti_type (argp, &full, &top, &using_enc);
/* If no RTTI data, or if object is already complete, do nothing */
- if (!real_type || real_type == VALUE_ENCLOSING_TYPE (argp))
+ if (!real_type || real_type == value_enclosing_type (argp))
return argp;
/* If we have the full object, but for some reason the enclosing
/* Check if object is in memory */
if (VALUE_LVAL (argp) != lval_memory)
{
- warning ("Couldn't retrieve complete object of RTTI type %s; object may be in register(s).", TYPE_NAME (real_type));
+ warning (_("Couldn't retrieve complete object of RTTI type %s; object may be in register(s)."), TYPE_NAME (real_type));
return argp;
}
adjusting for the embedded offset of argp if that's what value_rtti_type
used for its computation. */
new_val = value_at_lazy (real_type, VALUE_ADDRESS (argp) - top +
- (using_enc ? 0 : VALUE_EMBEDDED_OFFSET (argp)));
- new_val->type = value_type (argp);
- VALUE_EMBEDDED_OFFSET (new_val) = using_enc ? top + VALUE_EMBEDDED_OFFSET (argp) : top;
+ (using_enc ? 0 : value_embedded_offset (argp)));
+ deprecated_set_value_type (new_val, value_type (argp));
+ set_value_embedded_offset (new_val, (using_enc
+ ? top + value_embedded_offset (argp)
+ : top));
return new_val;
}
if (deprecated_selected_frame == 0)
{
if (complain)
- error ("no frame selected");
+ error (_("no frame selected"));
else
return 0;
}
if (!func)
{
if (complain)
- error ("no `%s' in nameless context", name);
+ error (_("no `%s' in nameless context"), name);
else
return 0;
}
if (dict_empty (BLOCK_DICT (b)))
{
if (complain)
- error ("no args, no `%s'", name);
+ error (_("no args, no `%s'"), name);
else
return 0;
}
if (sym == NULL)
{
if (complain)
- error ("current stack frame does not contain a variable named `%s'", name);
+ error (_("current stack frame does not contain a variable named `%s'"), name);
else
return NULL;
}
ret = read_var_value (sym, deprecated_selected_frame);
if (ret == 0 && complain)
- error ("`%s' argument unreadable", name);
+ error (_("`%s' argument unreadable"), name);
return ret;
}
if (TYPE_CODE (array_type) != TYPE_CODE_ARRAY
&& TYPE_CODE (array_type) != TYPE_CODE_STRING
&& TYPE_CODE (array_type) != TYPE_CODE_BITSTRING)
- error ("cannot take slice of non-array");
+ error (_("cannot take slice of non-array"));
range_type = TYPE_INDEX_TYPE (array_type);
if (get_discrete_bounds (range_type, &lowerbound, &upperbound) < 0)
- error ("slice from bad array or bitstring");
+ error (_("slice from bad array or bitstring"));
if (lowbound < lowerbound || length < 0
|| lowbound + length - 1 > upperbound)
- error ("slice out of range");
+ error (_("slice out of range"));
/* FIXME-type-allocation: need a way to free this type when we are
done with it. */
slice_range_type = create_range_type ((struct type *) NULL,
for (i = 0; i < length; i++)
{
int element = value_bit_index (array_type,
- VALUE_CONTENTS (array),
+ value_contents (array),
lowbound + i);
if (element < 0)
- error ("internal error accessing bitstring");
+ error (_("internal error accessing bitstring"));
else if (element > 0)
{
int j = i % TARGET_CHAR_BIT;
if (BITS_BIG_ENDIAN)
j = TARGET_CHAR_BIT - 1 - j;
- VALUE_CONTENTS_RAW (slice)[i / TARGET_CHAR_BIT] |= (1 << j);
+ value_contents_raw (slice)[i / TARGET_CHAR_BIT] |= (1 << j);
}
}
/* We should set the address, bitssize, and bitspos, so the clice
slice_range_type);
TYPE_CODE (slice_type) = TYPE_CODE (array_type);
slice = allocate_value (slice_type);
- if (VALUE_LAZY (array))
- VALUE_LAZY (slice) = 1;
+ if (value_lazy (array))
+ set_value_lazy (slice, 1);
else
- memcpy (VALUE_CONTENTS (slice), VALUE_CONTENTS (array) + offset,
+ memcpy (value_contents_writeable (slice),
+ value_contents (array) + offset,
TYPE_LENGTH (slice_type));
if (VALUE_LVAL (array) == lval_internalvar)
VALUE_LVAL (slice) = lval_internalvar_component;
else
VALUE_LVAL (slice) = VALUE_LVAL (array);
VALUE_ADDRESS (slice) = VALUE_ADDRESS (array);
- slice->offset = value_offset (array) + offset;
+ VALUE_FRAME_ID (slice) = VALUE_FRAME_ID (array);
+ set_value_offset (slice, value_offset (array) + offset);
}
return slice;
}
arg1 = value_cast (real_type, arg1);
arg2 = value_cast (real_type, arg2);
- memcpy (VALUE_CONTENTS_RAW (val),
- VALUE_CONTENTS (arg1), TYPE_LENGTH (real_type));
- memcpy (VALUE_CONTENTS_RAW (val) + TYPE_LENGTH (real_type),
- VALUE_CONTENTS (arg2), TYPE_LENGTH (real_type));
+ memcpy (value_contents_raw (val),
+ value_contents (arg1), TYPE_LENGTH (real_type));
+ memcpy (value_contents_raw (val) + TYPE_LENGTH (real_type),
+ value_contents (arg2), TYPE_LENGTH (real_type));
return val;
}
struct value *re_val = allocate_value (val_real_type);
struct value *im_val = allocate_value (val_real_type);
- memcpy (VALUE_CONTENTS_RAW (re_val),
- VALUE_CONTENTS (val), TYPE_LENGTH (val_real_type));
- memcpy (VALUE_CONTENTS_RAW (im_val),
- VALUE_CONTENTS (val) + TYPE_LENGTH (val_real_type),
+ memcpy (value_contents_raw (re_val),
+ value_contents (val), TYPE_LENGTH (val_real_type));
+ memcpy (value_contents_raw (im_val),
+ value_contents (val) + TYPE_LENGTH (val_real_type),
TYPE_LENGTH (val_real_type));
return value_literal_complex (re_val, im_val, type);
|| TYPE_CODE (value_type (val)) == TYPE_CODE_INT)
return value_literal_complex (val, value_zero (real_type, not_lval), type);
else
- error ("cannot cast non-number to complex");
+ error (_("cannot cast non-number to complex"));
}
void
_initialize_valops (void)
{
-#if 0
- deprecated_add_show_from_set
- (add_set_cmd ("abandon", class_support, var_boolean, (char *) &auto_abandon,
- "Set automatic abandonment of expressions upon failure.",
- &setlist),
- &showlist);
-#endif
-
- deprecated_add_show_from_set
- (add_set_cmd ("overload-resolution", class_support, var_boolean, (char *) &overload_resolution,
- "Set overload resolution in evaluating C++ functions.",
- &setlist),
- &showlist);
+ add_setshow_boolean_cmd ("overload-resolution", class_support,
+ &overload_resolution, _("\
+Set overload resolution in evaluating C++ functions."), _("\
+Show overload resolution in evaluating C++ functions."), NULL,
+ NULL,
+ show_overload_resolution,
+ &setlist, &showlist);
overload_resolution = 1;
}
projects / deliverable / binutils-gdb.git / blobdiff