/* The format of the output for this object */
enum varobj_display_formats format;
+
+ /* Was this variable updated via a varobj_set_value operation */
+ int updated;
};
/* Every variable keeps a linked list of its children, described
/* Creates a varobj (not its children) */
+/* Return the full FRAME which corresponds to the given CORE_ADDR
+ or NULL if no FRAME on the chain corresponds to CORE_ADDR. */
+
+static struct frame_info *
+find_frame_addr_in_frame_chain (CORE_ADDR frame_addr)
+{
+ struct frame_info *frame = NULL;
+
+ if (frame_addr == (CORE_ADDR) 0)
+ return NULL;
+
+ while (1)
+ {
+ frame = get_prev_frame (frame);
+ if (frame == NULL)
+ return NULL;
+ if (get_frame_base_address (frame) == frame_addr)
+ return frame;
+ }
+}
+
struct varobj *
varobj_create (char *objname,
char *expression, CORE_ADDR frame, enum varobj_type type)
/* Allow creator to specify context of variable */
if ((type == USE_CURRENT_FRAME) || (type == USE_SELECTED_FRAME))
- fi = selected_frame;
+ fi = deprecated_selected_frame;
else
+ /* FIXME: cagney/2002-11-23: This code should be doing a
+ lookup using the frame ID and not just the frame's
+ ``address''. This, of course, means an interface change.
+ However, with out that interface change ISAs, such as the
+ ia64 with its two stacks, won't work. Similar goes for the
+ case where there is a frameless function. */
fi = find_frame_addr_in_frame_chain (frame);
/* frame = -2 means always use selected frame */
Since select_frame is so benign, just call it for all cases. */
if (fi != NULL)
{
- get_frame_id (fi, &var->root->frame);
- old_fi = selected_frame;
+ var->root->frame = get_frame_id (fi);
+ old_fi = deprecated_selected_frame;
select_frame (fi);
}
else
var->value = evaluate_type (var->root->exp);
- var->type = VALUE_TYPE (var->value);
+ var->type = value_type (var->value);
/* Set language info */
lang = variable_language (var);
/* generate a name for this object */
id++;
- xasprintf (&obj_name, "var%d", id);
+ obj_name = xstrprintf ("var%d", id);
return obj_name;
}
/* 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);
+ type_print (value_type (val), "", stb, -1);
thetype = ui_file_xstrdup (stb, &length);
do_cleanups (old_chain);
varobj_set_value (struct varobj *var, char *expression)
{
struct value *val;
+ int error;
int offset = 0;
/* The argument "expression" contains the variable's new value.
return 0;
}
+ if (!my_value_equal (var->value, value, &error))
+ var->updated = 1;
if (!gdb_value_assign (var->value, value, &val))
return 0;
value_free (var->value);
/* Save the selected stack frame, since we will need to change it
in order to evaluate expressions. */
- get_frame_id (selected_frame, &old_fid);
+ old_fid = get_frame_id (deprecated_selected_frame);
/* Update the root variable. value_of_root can return NULL
if the variable is no longer around, i.e. we stepped out of
/* If values are not equal, note that it's changed.
There a couple of exceptions here, though.
We don't want some types to be reported as "changed". */
- else if (type_changeable (*varp)
- && !my_value_equal ((*varp)->value, new, &error2))
+ else if (type_changeable (*varp) &&
+ ((*varp)->updated || !my_value_equal ((*varp)->value, new, &error2)))
{
vpush (&result, *varp);
+ (*varp)->updated = 0;
changed++;
/* error2 replaces var->error since this new value
WILL replace the old one. */
/* Update this variable */
new = value_of_child (v->parent, v->index);
- if (type_changeable (v) && !my_value_equal (v->value, new, &error2))
+ if (type_changeable (v) &&
+ (v->updated || !my_value_equal (v->value, new, &error2)))
{
/* Note that it's changed */
vpush (&result, v);
+ v->updated = 0;
changed++;
}
/* error2 replaces v->error since this new value
for (vc = var->children; vc != NULL; vc = vc->next)
{
- if (STREQ (vc->child->name, name))
+ if (strcmp (vc->child->name, name) == 0)
return vc->child;
}
child->error = 1;
child->parent = parent;
child->root = parent->root;
- xasprintf (&childs_name, "%s.%s", parent->obj_name, name);
+ childs_name = xstrprintf ("%s.%s", parent->obj_name, name);
child->obj_name = childs_name;
install_variable (child);
var->children = NULL;
var->format = 0;
var->root = NULL;
+ var->updated = 0;
return var;
}
var->root->lang = NULL;
var->root->exp = NULL;
var->root->valid_block = NULL;
- var->root->frame.base = 0;
- var->root->frame.pc = 0;
+ var->root->frame = null_frame_id;
var->root->use_selected_frame = 0;
var->root->rootvar = NULL;
return make_cleanup (do_free_variable_cleanup, var);
}
-/* This returns the type of the variable. This skips past typedefs
- and returns the real type of the variable. It also dereferences
- pointers and references.
+/* This returns the type of the variable. It also skips past typedefs
+ to return the real type of the variable.
NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
except within get_target_type and get_type. */
struct type *type;
type = var->type;
- while (type != NULL && TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
- type = TYPE_TARGET_TYPE (type);
+ if (type != NULL)
+ type = check_typedef (type);
return type;
}
if (type != NULL)
{
type = TYPE_TARGET_TYPE (type);
- while (type != NULL && TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
- type = TYPE_TARGET_TYPE (type);
+ if (type != NULL)
+ type = check_typedef (type);
}
return type;
/* If the child had no evaluation errors, var->value
will be non-NULL and contain a valid type. */
if (var->value != NULL)
- return VALUE_TYPE (var->value);
+ return value_type (var->value);
/* Otherwise, we must compute the type. */
return (*var->root->lang->type_of_child) (var->parent, var->index);
switch (TYPE_CODE (type))
{
case TYPE_CODE_ARRAY:
- xasprintf (&name, "%d", index);
+ name = xstrprintf ("%d", index);
break;
case TYPE_CODE_STRUCT:
break;
default:
- xasprintf (&name, "*%s", parent->name);
+ name = xstrprintf ("*%s", parent->name);
break;
}
break;
case TYPE_CODE_ARRAY:
{
char *number;
- xasprintf (&number, "[%d]", var->num_children);
+ number = xstrprintf ("[%d]", var->num_children);
return (number);
}
/* break; */
if (VALUE_LAZY (var->value))
gdb_value_fetch_lazy (var->value);
- val_print (VALUE_TYPE (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);
type = get_type_deref (var->parent);
cplus_class_num_children (type, kids);
- if (STREQ (var->name, "public"))
+ if (strcmp (var->name, "public") == 0)
children = kids[v_public];
- else if (STREQ (var->name, "private"))
+ else if (strcmp (var->name, "private") == 0)
children = kids[v_private];
else
children = kids[v_protected];
{
char *name;
struct type *type;
- int children[3];
if (CPLUS_FAKE_CHILD (parent))
{
{
case TYPE_CODE_STRUCT:
case TYPE_CODE_UNION:
- cplus_class_num_children (type, children);
-
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 */
- 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];
-
- name = TYPE_FIELD_NAME (type, i);
+ /* The fields of the class type are ordered as they
+ appear in the class. We are given an index for a
+ particular access control type ("public","protected",
+ or "private"). We must skip over fields that don't
+ have the access control we are looking for to properly
+ find the indexed field. */
+ int type_index = TYPE_N_BASECLASSES (type);
+ if (strcmp (parent->name, "private") == 0)
+ {
+ while (index >= 0)
+ {
+ if (TYPE_VPTR_BASETYPE (type) == type
+ && type_index == TYPE_VPTR_FIELDNO (type))
+ ; /* ignore vptr */
+ else if (TYPE_FIELD_PRIVATE (type, type_index))
+ --index;
+ ++type_index;
+ }
+ --type_index;
+ }
+ else if (strcmp (parent->name, "protected") == 0)
+ {
+ while (index >= 0)
+ {
+ if (TYPE_VPTR_BASETYPE (type) == type
+ && type_index == TYPE_VPTR_FIELDNO (type))
+ ; /* ignore vptr */
+ else if (TYPE_FIELD_PROTECTED (type, type_index))
+ --index;
+ ++type_index;
+ }
+ --type_index;
+ }
+ else
+ {
+ while (index >= 0)
+ {
+ if (TYPE_VPTR_BASETYPE (type) == type
+ && type_index == TYPE_VPTR_FIELDNO (type))
+ ; /* ignore vptr */
+ else if (!TYPE_FIELD_PRIVATE (type, type_index) &&
+ !TYPE_FIELD_PROTECTED (type, type_index))
+ --index;
+ ++type_index;
+ }
+ --type_index;
+ }
+
+ name = TYPE_FIELD_NAME (type, type_index);
}
else if (index < TYPE_N_BASECLASSES (type))
+ /* We are looking up the name of a base class */
name = TYPE_FIELD_NAME (type, index);
else
{
+ int children[3];
+ cplus_class_num_children(type, children);
+
/* Everything beyond the baseclasses can
- only be "public", "private", or "protected" */
+ only be "public", "private", or "protected"
+
+ The special "fake" children are always output by varobj in
+ this order. So if INDEX == 2, it MUST be "protected". */
index -= TYPE_N_BASECLASSES (type);
switch (index)
{
case 0:
- if (children[v_public] != 0)
- {
- name = "public";
- break;
- }
+ if (children[v_public] > 0)
+ name = "public";
+ else if (children[v_private] > 0)
+ name = "private";
+ else
+ name = "protected";
+ break;
case 1:
- if (children[v_private] != 0)
+ if (children[v_public] > 0)
{
- name = "private";
- break;
+ if (children[v_private] > 0)
+ name = "private";
+ else
+ name = "protected";
}
+ else if (children[v_private] > 0)
+ name = "protected";
+ break;
case 2:
- if (children[v_protected] != 0)
- {
- name = "protected";
- break;
- }
+ /* Must be protected */
+ name = "protected";
+ break;
default:
/* error! */
break;
{
struct value *temp = NULL;
- if (TYPE_CODE (VALUE_TYPE (parent->value)) == TYPE_CODE_PTR
- || TYPE_CODE (VALUE_TYPE (parent->value)) == TYPE_CODE_REF)
+ if (TYPE_CODE (value_type (parent->value)) == TYPE_CODE_PTR
+ || TYPE_CODE (value_type (parent->value)) == TYPE_CODE_REF)
{
if (!gdb_value_ind (parent->value, &temp))
return NULL;
varobj_table = xmalloc (sizeof_table);
memset (varobj_table, 0, sizeof_table);
- add_show_from_set (add_set_cmd ("debugvarobj", class_maintenance, var_zinteger, (char *) &varobjdebug, "Set varobj debugging.\n\
+ deprecated_add_show_from_set (add_set_cmd ("debugvarobj", class_maintenance, var_zinteger, (char *) &varobjdebug, "Set varobj debugging.\n\
When non-zero, varobj debugging is enabled.", &setlist),
&showlist);
}