const char mi_simple_values[] = "--simple-values";
const char mi_all_values[] = "--all-values";
-extern int varobjdebug; /* defined in varobj.c */
+extern int varobjdebug; /* defined in varobj.c. */
-static int varobj_update_one (struct varobj *var,
+static void varobj_update_one (struct varobj *var,
enum print_values print_values);
static int mi_print_value_p (struct type *type, enum print_values print_values);
return MI_CMD_DONE;
}
-/* Helper for mi_cmd_var_update() Returns 0 if the update for
- the variable fails (usually because the variable is out of
- scope), and 1 if it succeeds. */
+/* Helper for mi_cmd_var_update(). */
-static int
+static void
varobj_update_one (struct varobj *var, enum print_values print_values)
{
struct varobj **changelist;
nc = varobj_update (&var, &changelist);
- /* nc == 0 means that nothing has changed.
- nc == -1 means that an error occured in updating the variable.
- nc == -2 means the variable has changed type. */
+ /* nc >= 0 represents the number of changes reported into changelist.
+ nc < 0 means that an error occured or the the variable has
+ changed type (TYPE_CHANGED). */
if (nc == 0)
- return 1;
- else if (nc == -1)
+ return;
+ else if (nc < 0)
{
if (mi_version (uiout) > 1)
cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
ui_out_field_string (uiout, "name", varobj_get_objname(var));
- ui_out_field_string (uiout, "in_scope", "false");
- if (mi_version (uiout) > 1)
- do_cleanups (cleanup);
- return -1;
- }
- else if (nc == -2)
- {
- if (mi_version (uiout) > 1)
- cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
- ui_out_field_string (uiout, "name", varobj_get_objname (var));
- ui_out_field_string (uiout, "in_scope", "true");
- ui_out_field_string (uiout, "new_type", varobj_get_type(var));
- ui_out_field_int (uiout, "new_num_children",
- varobj_get_num_children(var));
+
+ switch (nc)
+ {
+ case NOT_IN_SCOPE:
+ case WRONG_PARAM:
+ ui_out_field_string (uiout, "in_scope", "false");
+ break;
+ case INVALID:
+ ui_out_field_string (uiout, "in_scope", "invalid");
+ break;
+ case TYPE_CHANGED:
+ ui_out_field_string (uiout, "in_scope", "true");
+ ui_out_field_string (uiout, "new_type", varobj_get_type(var));
+ ui_out_field_int (uiout, "new_num_children",
+ varobj_get_num_children(var));
+ break;
+ }
if (mi_version (uiout) > 1)
do_cleanups (cleanup);
}
else
{
-
cc = changelist;
while (*cc != NULL)
{
cc++;
}
xfree (changelist);
- return 1;
}
- return 1;
}
using the currently selected frame. */
int use_selected_frame;
+ /* Flag that indicates validity: set to 0 when this varobj_root refers
+ to symbols that do not exist anymore. */
+ int is_valid;
+
/* Language info for this variable and its children */
struct language_specific *lang;
long length;
/* For the "fake" variables, do not return a type. (It's type is
- NULL, too.) */
- if (CPLUS_FAKE_CHILD (var))
+ NULL, too.)
+ Do not return a type for invalid variables as well. */
+ if (CPLUS_FAKE_CHILD (var) || !var->root->is_valid)
return NULL;
stb = mem_fileopen ();
{
int attributes = 0;
- if (variable_editable (var))
+ if (var->root->is_valid && variable_editable (var))
/* FIXME: define masks for attributes */
attributes |= 0x00000001; /* Editable */
expression to see if it's changed. Then go all the way
through its children, reconstructing them and noting if they've
changed.
- Return value:
- -1 if there was an error updating the varobj
- -2 if the type changed
- Otherwise it is the number of children + parent changed
+ Return value:
+ < 0 for error values, see varobj.h.
+ Otherwise it is the number of children + parent changed.
Only root variables can be updated...
NOTE: This function may delete the caller's varobj. If it
- returns -2, then it has done this and VARP will be modified
- to point to the new varobj. */
+ returns TYPE_CHANGED, then it has done this and VARP will be modified
+ to point to the new varobj. */
int
varobj_update (struct varobj **varp, struct varobj ***changelist)
struct frame_id old_fid;
struct frame_info *fi;
- /* sanity check: have we been passed a pointer? */
+ /* sanity check: have we been passed a pointer? */
if (changelist == NULL)
- return -1;
+ return WRONG_PARAM;
- /* Only root variables can be updated... */
+ /* Only root variables can be updated... */
if (!is_root_p (*varp))
- /* Not a root var */
- return -1;
+ /* Not a root var. */
+ return WRONG_PARAM;
+
+ if (!(*varp)->root->is_valid)
+ return INVALID;
/* Save the selected stack frame, since we will need to change it
- in order to evaluate expressions. */
+ in order to evaluate expressions. */
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
the frame in which a local existed. We are letting the
value_of_root variable dispose of the varobj if the type
- has changed. */
+ has changed. */
type_changed = 1;
new = value_of_root (varp, &type_changed);
- /* Restore selected frame */
+ /* Restore selected frame. */
fi = frame_find_by_id (old_fid);
if (fi)
select_frame (fi);
/* If this is a "use_selected_frame" varobj, and its type has changed,
- them note that it's changed. */
+ them note that it's changed. */
if (type_changed)
VEC_safe_push (varobj_p, result, *varp);
/* This means the varobj itself is out of scope.
Report it. */
VEC_free (varobj_p, result);
- return -1;
+ return NOT_IN_SCOPE;
}
VEC_safe_push (varobj_p, stack, *varp);
- /* Walk through the children, reconstructing them all. */
+ /* Walk through the children, reconstructing them all. */
while (!VEC_empty (varobj_p, stack))
{
v = VEC_pop (varobj_p, stack);
}
}
- /* Alloc (changed + 1) list entries */
+ /* Alloc (changed + 1) list entries. */
changed = VEC_length (varobj_p, result);
*changelist = xmalloc ((changed + 1) * sizeof (struct varobj *));
cv = *changelist;
*cv = 0;
if (type_changed)
- return -2;
+ return TYPE_CHANGED;
else
return changed;
}
var->root->frame = null_frame_id;
var->root->use_selected_frame = 0;
var->root->rootvar = NULL;
+ var->root->is_valid = 1;
return var;
}
static char *
my_value_of_variable (struct varobj *var)
{
- return (*var->root->lang->value_of_variable) (var);
+ if (var->root->is_valid)
+ return (*var->root->lang->value_of_variable) (var);
+ else
+ return NULL;
}
static char *
show_varobjdebug,
&setlist, &showlist);
}
+
+/* Invalidate the varobjs that are tied to locals and re-create the ones that
+ are defined on globals.
+ Invalidated varobjs will be always printed in_scope="invalid". */
+void
+varobj_invalidate (void)
+{
+ struct varobj **all_rootvarobj;
+ struct varobj **varp;
+
+ if (varobj_list (&all_rootvarobj) > 0)
+ {
+ varp = all_rootvarobj;
+ while (*varp != NULL)
+ {
+ /* global var must be re-evaluated. */
+ if ((*varp)->root->valid_block == NULL)
+ {
+ struct varobj *tmp_var;
+
+ /* Try to create a varobj with same expression. If we succeed replace
+ the old varobj, otherwise invalidate it. */
+ tmp_var = varobj_create (NULL, (*varp)->name, (CORE_ADDR) 0, USE_CURRENT_FRAME);
+ if (tmp_var != NULL)
+ {
+ tmp_var->obj_name = xstrdup ((*varp)->obj_name);
+ varobj_delete (*varp, NULL, 0);
+ install_variable (tmp_var);
+ }
+ else
+ (*varp)->root->is_valid = 0;
+ }
+ else /* locals must be invalidated. */
+ (*varp)->root->is_valid = 0;
+
+ varp++;
+ }
+ xfree (all_rootvarobj);
+ }
+ return;
+}
projects / binutils-gdb.git / commitdiff