struct type *type;
/* The value of this expression or subexpression. This may be NULL. */
- value_ptr value;
+ struct value *value;
/* Did an error occur evaluating the expression or getting its value? */
int error;
static enum varobj_display_formats variable_default_display (struct varobj *);
-static int my_value_equal (value_ptr, value_ptr, int *);
+static int my_value_equal (struct value *, struct value *, int *);
static void vpush (struct vstack **pstack, struct varobj *var);
static char *name_of_child (struct varobj *, int);
-static value_ptr value_of_root (struct varobj **var_handle, int *);
+static struct value *value_of_root (struct varobj **var_handle, int *);
-static value_ptr value_of_child (struct varobj *parent, int index);
+static struct value *value_of_child (struct varobj *parent, int index);
static struct type *type_of_child (struct varobj *var);
static char *c_name_of_child (struct varobj *parent, int index);
-static value_ptr c_value_of_root (struct varobj **var_handle);
+static struct value *c_value_of_root (struct varobj **var_handle);
-static value_ptr c_value_of_child (struct varobj *parent, int index);
+static struct value *c_value_of_child (struct varobj *parent, int index);
static struct type *c_type_of_child (struct varobj *parent, int index);
static char *cplus_name_of_child (struct varobj *parent, int index);
-static value_ptr cplus_value_of_root (struct varobj **var_handle);
+static struct value *cplus_value_of_root (struct varobj **var_handle);
-static value_ptr cplus_value_of_child (struct varobj *parent, int index);
+static struct value *cplus_value_of_child (struct varobj *parent, int index);
static struct type *cplus_type_of_child (struct varobj *parent, int index);
static char *java_name_of_child (struct varobj *parent, int index);
-static value_ptr java_value_of_root (struct varobj **var_handle);
+static struct value *java_value_of_root (struct varobj **var_handle);
-static value_ptr java_value_of_child (struct varobj *parent, int index);
+static struct value *java_value_of_child (struct varobj *parent, int index);
static struct type *java_type_of_child (struct varobj *parent, int index);
/* The name of the INDEX'th child of PARENT. */
char *(*name_of_child) (struct varobj * parent, int index);
- /* The value_ptr of the root variable ROOT. */
- value_ptr (*value_of_root) (struct varobj ** root_handle);
+ /* The ``struct value *'' of the root variable ROOT. */
+ struct value *(*value_of_root) (struct varobj ** root_handle);
- /* The value_ptr of the INDEX'th child of PARENT. */
- value_ptr (*value_of_child) (struct varobj * parent, int index);
+ /* The ``struct value *'' of the INDEX'th child of PARENT. */
+ struct value *(*value_of_child) (struct varobj * parent, int index);
/* The type of the INDEX'th child of PARENT. */
struct type *(*type_of_child) (struct varobj * parent, int index);
block = NULL;
if (fi != NULL)
- block = get_frame_block (fi);
+ block = get_frame_block (fi, 0);
p = expression;
innermost_block = NULL;
char *
varobj_get_type (struct varobj *var)
{
- value_ptr val;
+ struct value *val;
struct cleanup *old_chain;
struct ui_file *stb;
char *thetype;
stb = mem_fileopen ();
old_chain = make_cleanup_ui_file_delete (stb);
- /* To print the type, we simply create a zero value_ptr and
+ /* To print the type, we simply create a zero ``struct value *'' and
cast it to our type. We then typeprint this variable. */
val = value_zero (var->type, not_lval);
type_print (VALUE_TYPE (val), "", stb, -1);
int
varobj_set_value (struct varobj *var, char *expression)
{
- value_ptr val;
+ struct value *val;
int offset = 0;
/* The argument "expression" contains the variable's new value.
We need to first construct a legal expression for this -- ugh! */
/* Does this cover all the bases? */
struct expression *exp;
- value_ptr value;
+ struct value *value;
int saved_input_radix = input_radix;
- if (variable_editable (var) && !var->error)
+ if (var->value != NULL && variable_editable (var) && !var->error)
{
char *s = expression;
int i;
- value_ptr temp;
input_radix = 10; /* ALWAYS reset to decimal temporarily */
if (!gdb_parse_exp_1 (&s, 0, 0, &exp))
return 0;
}
- /* If our parent is "public", "private", or "protected", we could
- be asking to modify the value of a baseclass. If so, we need to
- adjust our address by the offset of our baseclass in the subclass,
- since VALUE_ADDRESS (var->value) points at the start of the subclass.
- For some reason, value_cast doesn't take care of this properly. */
- temp = var->value;
- if (var->parent != NULL && CPLUS_FAKE_CHILD (var->parent))
- {
- struct varobj *super, *sub;
- struct type *type;
- super = var->parent->parent;
- sub = super->parent;
- if (sub != NULL)
- {
- /* Yes, it is a baseclass */
- type = get_type_deref (sub);
-
- if (super->index < TYPE_N_BASECLASSES (type))
- {
- temp = value_copy (var->value);
- for (i = 0; i < super->index; i++)
- offset += TYPE_LENGTH (TYPE_FIELD_TYPE (type, i));
- }
- }
- }
-
- VALUE_ADDRESS (temp) += offset;
- if (!gdb_value_assign (temp, value, &val))
+ if (!gdb_value_assign (var->value, value, &val))
return 0;
- VALUE_ADDRESS (val) -= offset;
value_free (var->value);
release_value (val);
var->value = val;
struct varobj *v;
struct varobj **cv;
struct varobj **templist = NULL;
- value_ptr new;
+ struct value *new;
struct vstack *stack = NULL;
struct vstack *result = NULL;
struct frame_info *old_fi;
child->name = name;
child->index = index;
child->value = value_of_child (parent, index);
- if (child->value == NULL || parent->error)
+ if ((!CPLUS_FAKE_CHILD(child) && child->value == NULL) || parent->error)
child->error = 1;
child->parent = parent;
child->root = parent->root;
one is "safe" -- it NEVER longjmps. It determines if the VAR's
value is the same as VAL2. */
static int
-my_value_equal (value_ptr val1, value_ptr val2, int *error2)
+my_value_equal (struct value *val1, struct value *val2, int *error2)
{
int r, err1, err2;
return (*var->root->lang->name_of_child) (var, index);
}
-/* What is the value_ptr of the root variable VAR?
+/* What is the ``struct value *'' of the root variable VAR?
TYPE_CHANGED controls what to do if the type of a
use_selected_frame = 1 variable changes. On input,
TYPE_CHANGED = 1 means discard the old varobj, and replace
old varobj pointer away somewhere before calling this.
On return, TYPE_CHANGED will be 1 if the type has changed, and
0 otherwise. */
-static value_ptr
+static struct value *
value_of_root (struct varobj **var_handle, int *type_changed)
{
struct varobj *var;
return (*var->root->lang->value_of_root) (var_handle);
}
-/* What is the value_ptr for the INDEX'th child of PARENT? */
-static value_ptr
+/* What is the ``struct value *'' for the INDEX'th child of PARENT? */
+static struct value *
value_of_child (struct varobj *parent, int index)
{
- value_ptr value;
+ struct value *value;
value = (*parent->root->lang->value_of_child) (parent, index);
/* If we're being lazy, fetch the real value of the variable. */
if (value != NULL && VALUE_LAZY (value))
- gdb_value_fetch_lazy (value);
+ {
+ /* If we fail to fetch the value of the child, return
+ NULL so that callers notice that we're leaving an
+ error message. */
+ if (!gdb_value_fetch_lazy (value))
+ value = NULL;
+ }
return value;
}
return name;
}
-static value_ptr
+static struct value *
c_value_of_root (struct varobj **var_handle)
{
- value_ptr new_val;
+ struct value *new_val;
struct varobj *var = *var_handle;
struct frame_info *fi;
int within_scope;
return NULL;
}
-static value_ptr
+static struct value *
c_value_of_child (struct varobj *parent, int index)
{
- value_ptr value, temp, indval;
+ struct value *value;
+ struct value *temp;
+ struct value *indval;
struct type *type, *target;
char *name;
case TYPE_CODE_STRUCT:
case TYPE_CODE_UNION:
- value = value_struct_elt (&temp, NULL, name, NULL, "vstructure");
+ gdb_value_struct_elt (NULL, &value, &temp, NULL, name, NULL, "vstructure");
break;
case TYPE_CODE_PTR:
{
case TYPE_CODE_STRUCT:
case TYPE_CODE_UNION:
- value =
- value_struct_elt (&temp, NULL, name, NULL, "vstructure");
+ gdb_value_struct_elt (NULL, &value, &temp, NULL, name, NULL, "vstructure");
break;
default:
if (value != NULL)
release_value (value);
+ xfree (name);
return value;
}
break;
}
+ xfree (name);
return type;
}
c_value_of_variable (struct varobj *var)
{
struct type *type;
- value_ptr val;
-
- if (var->value != NULL)
- val = var->value;
- else
- {
- /* This can happen if we attempt to get the value of a struct
- member when the parent is an invalid pointer. */
- return xstrdup ("???");
- }
/* BOGUS: if val_print sees a struct/class, it will print out its
children instead of "{...}" */
struct cleanup *old_chain = make_cleanup_ui_file_delete (stb);
char *thevalue;
- if (VALUE_LAZY (val))
- gdb_value_fetch_lazy (val);
- val_print (VALUE_TYPE (val), VALUE_CONTENTS_RAW (val), 0,
- VALUE_ADDRESS (val),
- stb, format_code[(int) var->format], 1, 0, 0);
- thevalue = ui_file_xstrdup (stb, &dummy);
- do_cleanups (old_chain);
+ if (var->value == NULL)
+ {
+ /* This can happen if we attempt to get the value of a struct
+ member when the parent is an invalid pointer. This is an
+ error condition, so we should tell the caller. */
+ return NULL;
+ }
+ else
+ {
+ if (VALUE_LAZY (var->value))
+ gdb_value_fetch_lazy (var->value);
+ val_print (VALUE_TYPE (var->value), VALUE_CONTENTS_RAW (var->value), 0,
+ VALUE_ADDRESS (var->value),
+ stb, format_code[(int) var->format], 1, 0, 0);
+ thevalue = ui_file_xstrdup (stb, &dummy);
+ do_cleanups (old_chain);
+ }
+
return thevalue;
}
/* break; */
if (CPLUS_FAKE_CHILD (parent))
{
+ int i;
+
+ /* Skip over vptr, if it exists. */
+ if (TYPE_VPTR_BASETYPE (type) == type
+ && index >= TYPE_VPTR_FIELDNO (type))
+ index++;
+
/* FIXME: This assumes that type orders
inherited, public, private, protected */
- int i = index + TYPE_N_BASECLASSES (type);
- if (STREQ (parent->name, "private")
- || STREQ (parent->name, "protected"))
+ i = index + TYPE_N_BASECLASSES (type);
+ if (STREQ (parent->name, "private") || STREQ (parent->name, "protected"))
i += children[v_public];
if (STREQ (parent->name, "protected"))
i += children[v_private];
return name;
}
-static value_ptr
+static struct value *
cplus_value_of_root (struct varobj **var_handle)
{
return c_value_of_root (var_handle);
}
-static value_ptr
+static struct value *
cplus_value_of_child (struct varobj *parent, int index)
{
struct type *type;
- value_ptr value;
- char *name;
+ struct value *value;
if (CPLUS_FAKE_CHILD (parent))
type = get_type_deref (parent->parent);
type = get_type_deref (parent);
value = NULL;
- name = name_of_child (parent, index);
if (((TYPE_CODE (type)) == TYPE_CODE_STRUCT) ||
((TYPE_CODE (type)) == TYPE_CODE_UNION))
{
if (CPLUS_FAKE_CHILD (parent))
{
- value_ptr temp = parent->parent->value;
- value = value_struct_elt (&temp, NULL, name,
- NULL, "cplus_structure");
- release_value (value);
+ char *name;
+ struct value *temp = parent->parent->value;
+
+ if (temp == NULL)
+ return NULL;
+
+ name = name_of_child (parent, index);
+ gdb_value_struct_elt (NULL, &value, &temp, NULL, name, NULL,
+ "cplus_structure");
+ if (value != NULL)
+ release_value (value);
+
+ xfree (name);
}
else if (index >= TYPE_N_BASECLASSES (type))
{
/* Baseclass */
if (parent->value != NULL)
{
- value_ptr temp;
+ struct value *temp = NULL;
if (TYPE_CODE (VALUE_TYPE (parent->value)) == TYPE_CODE_PTR
|| TYPE_CODE (VALUE_TYPE (parent->value)) == TYPE_CODE_REF)
else
temp = parent->value;
- value = value_cast (TYPE_FIELD_TYPE (type, index), temp);
- release_value (value);
+ if (temp != NULL)
+ {
+ value = value_cast (TYPE_FIELD_TYPE (type, index), temp);
+ release_value (value);
+ }
+ else
+ {
+ /* We failed to evaluate the parent's value, so don't even
+ bother trying to evaluate this child. */
+ return NULL;
+ }
}
}
}
{
struct type *type, *t;
- t = get_type_deref (parent);
+ if (CPLUS_FAKE_CHILD (parent))
+ {
+ /* Looking for the type of a child of public, private, or protected. */
+ t = get_type_deref (parent->parent);
+ }
+ else
+ t = get_type_deref (parent);
+
type = NULL;
switch (TYPE_CODE (t))
{
case TYPE_CODE_STRUCT:
case TYPE_CODE_UNION:
- if (index >= TYPE_N_BASECLASSES (t))
+ if (CPLUS_FAKE_CHILD (parent))
{
- /* special */
- return NULL;
+ char *name = cplus_name_of_child (parent, index);
+ type = lookup_struct_elt_type (t, name, 0);
+ xfree (name);
}
+ else if (index < TYPE_N_BASECLASSES (t))
+ type = TYPE_FIELD_TYPE (t, index);
else
{
- /* Baseclass */
- type = TYPE_FIELD_TYPE (t, index);
+ /* special */
+ return NULL;
}
break;
return name;
}
-static value_ptr
+static struct value *
java_value_of_root (struct varobj **var_handle)
{
return cplus_value_of_root (var_handle);
}
-static value_ptr
+static struct value *
java_value_of_child (struct varobj *parent, int index)
{
return cplus_value_of_child (parent, index);
projects / deliverable / binutils-gdb.git / blobdiff