Change int -> bool where applicable throughout varobj
This patch changes all the "int" I could find in varobj.{c,h} that are
really boolean values to use bool. I followed the ramifications
(parameters and return values of exported functions), so the changes
spilled a bit on other, related files (ada-varobj.c and c-varobj.c).
gdb/ChangeLog:
* ada-varobj.c (ada_value_is_changeable_p): Change int to bool where applicable.
(ada_value_has_mutated): Likewise.
* c-varobj.c (varobj_is_anonymous_child): Likewise.
(c_is_path_expr_parent): Likewise.
* mi/mi-cmd-var.c (varobj_update_one): Likewise.
(mi_cmd_var_set_frozen): Likewise.
(mi_cmd_var_update_iter): Likewise.
(mi_cmd_var_update): Likewise.
* varobj.c (pretty_printing): Likewise.
(varobj_enable_pretty_printing): Likewise.
(struct varobj_root) <floating, is_valid>: Likewise.
(struct varobj_dynamic) <children_requested>: Likewise.
(delete_variable): Likewise.
(delete_variable_1): Likewise.
(install_variable): Likewise.
(update_type_if_necessary): Likewise.
(install_new_value): Likewise.
(value_of_root): Likewise.
(is_root_p): Likewise.
(varobj_create): Likewise.
(varobj_delete): Likewise.
(varobj_has_more): Likewise.
(varobj_set_frozen): Likewise.
(varobj_get_frozen): Likewise.
(install_dynamic_child): Likewise.
(dynamic_varobj_has_child_method): Likewise.
(update_dynamic_varobj_children): Likewise.
(varobj_get_num_children): Likewise.
(varobj_list_children): Likewise.
(is_path_expr_parent): Likewise.
(varobj_default_is_path_expr_parent): Likewise.
(varobj_is_dynamic_p): Likewise.
(varobj_set_value): Likewise.
(varobj_value_has_mutated): Likewise.
(varobj_update): Likewise.
(check_scope): Likewise.
(value_of_root_1): Likewise.
(varobj_value_get_print_value): Likewise.
(varobj_editable_p): Likewise.
(varobj_value_is_changeable_p): Likewise.
(varobj_floating_p): Likewise.
(varobj_default_value_is_changeable_p): Likewise.
(varobj_invalidate_iter): Likewise.
* varobj.h (struct varobj_update_result) <type_changed,
children_changed, changed, value_installed>: Likewise.
(struct varobj) <updated, frozen, not_fetched>: Likewise.
(struct lang_varobj_ops) <value_is_changeable_p,
value_has_mutated, is_path_expr_parent>: Likewise.
(varobj_delete): Likewise.
(varobj_set_frozen): Likewise.
(varobj_get_frozen): Likewise.
(varobj_set_value): Likewise.
(varobj_update): Likewise.
(varobj_editable_p): Likewise.
(varobj_floating_p): Likewise.
(varobj_has_more): Likewise.
(varobj_is_dynamic_p): Likewise.
(varobj_default_value_is_changeable_p): Likewise.
(varobj_value_is_changeable_p): Likewise.
(varobj_is_anonymous_child): Likewise.
(varobj_default_is_path_expr_parent): Likewise.
This commit is contained in:
Simon Marchi
parent
eb02c04dc3
commit
4c37490d92
6 changed files with 257 additions and 195 deletions
288
gdb/varobj.c
288
gdb/varobj.c
|
|
@ -54,12 +54,12 @@ const char *varobj_format_string[] =
|
|||
{ "natural", "binary", "decimal", "hexadecimal", "octal", "zero-hexadecimal" };
|
||||
|
||||
/* True if we want to allow Python-based pretty-printing. */
|
||||
static int pretty_printing = 0;
|
||||
static bool pretty_printing = false;
|
||||
|
||||
void
|
||||
varobj_enable_pretty_printing (void)
|
||||
{
|
||||
pretty_printing = 1;
|
||||
pretty_printing = true;
|
||||
}
|
||||
|
||||
/* Data structures */
|
||||
|
|
@ -85,14 +85,14 @@ struct varobj_root
|
|||
was created. */
|
||||
int thread_id = 0;
|
||||
|
||||
/* If 1, the -var-update always recomputes the value in the
|
||||
/* If true, the -var-update always recomputes the value in the
|
||||
current thread and frame. Otherwise, variable object is
|
||||
always updated in the specific scope/thread/frame. */
|
||||
int floating = 0;
|
||||
bool floating = false;
|
||||
|
||||
/* Flag that indicates validity: set to 0 when this varobj_root refers
|
||||
/* Flag that indicates validity: set to false when this varobj_root refers
|
||||
to symbols that do not exist anymore. */
|
||||
int is_valid = 1;
|
||||
bool is_valid = true;
|
||||
|
||||
/* Language-related operations for this variable and its
|
||||
children. */
|
||||
|
|
@ -113,7 +113,7 @@ struct varobj_dynamic
|
|||
used to decide if dynamic varobj should recompute their children.
|
||||
In the event that the frontend never asked for the children, we
|
||||
can avoid that. */
|
||||
int children_requested = 0;
|
||||
bool children_requested_ = false;
|
||||
|
||||
/* The pretty-printer constructor. If NULL, then the default
|
||||
pretty-printer will be looked up. If None, then no
|
||||
|
|
@ -148,11 +148,11 @@ struct vlist
|
|||
|
||||
/* Helper functions for the above subcommands. */
|
||||
|
||||
static int delete_variable (struct varobj *, int);
|
||||
static int delete_variable (struct varobj *, bool);
|
||||
|
||||
static void delete_variable_1 (int *, struct varobj *, int, int);
|
||||
static void delete_variable_1 (int *, struct varobj *, bool, bool);
|
||||
|
||||
static int install_variable (struct varobj *);
|
||||
static bool install_variable (struct varobj *);
|
||||
|
||||
static void uninstall_variable (struct varobj *);
|
||||
|
||||
|
|
@ -166,11 +166,11 @@ create_child_with_value (struct varobj *parent, int index,
|
|||
|
||||
static enum varobj_display_formats variable_default_display (struct varobj *);
|
||||
|
||||
static int update_type_if_necessary (struct varobj *var,
|
||||
struct value *new_value);
|
||||
static bool update_type_if_necessary (struct varobj *var,
|
||||
struct value *new_value);
|
||||
|
||||
static int install_new_value (struct varobj *var, struct value *value,
|
||||
int initial);
|
||||
static bool install_new_value (struct varobj *var, struct value *value,
|
||||
bool initial);
|
||||
|
||||
/* Language-specific routines. */
|
||||
|
||||
|
|
@ -180,14 +180,14 @@ static std::string name_of_variable (const struct varobj *);
|
|||
|
||||
static std::string name_of_child (struct varobj *, int);
|
||||
|
||||
static struct value *value_of_root (struct varobj **var_handle, int *);
|
||||
static struct value *value_of_root (struct varobj **var_handle, bool *);
|
||||
|
||||
static struct value *value_of_child (const struct varobj *parent, int index);
|
||||
|
||||
static std::string my_value_of_variable (struct varobj *var,
|
||||
enum varobj_display_formats format);
|
||||
|
||||
static int is_root_p (const struct varobj *var);
|
||||
static bool is_root_p (const struct varobj *var);
|
||||
|
||||
static struct varobj *varobj_add_child (struct varobj *var,
|
||||
struct varobj_item *item);
|
||||
|
|
@ -210,7 +210,7 @@ static struct vlist **varobj_table;
|
|||
|
||||
|
||||
/* API Implementation */
|
||||
static int
|
||||
static bool
|
||||
is_root_p (const struct varobj *var)
|
||||
{
|
||||
return (var->root->rootvar == var);
|
||||
|
|
@ -299,7 +299,7 @@ varobj_create (const char *objname,
|
|||
|
||||
/* frame = -2 means always use selected frame. */
|
||||
if (type == USE_SELECTED_FRAME)
|
||||
var->root->floating = 1;
|
||||
var->root->floating = true;
|
||||
|
||||
pc = 0;
|
||||
block = NULL;
|
||||
|
|
@ -472,7 +472,7 @@ varobj_get_expression (const struct varobj *var)
|
|||
/* See varobj.h. */
|
||||
|
||||
int
|
||||
varobj_delete (struct varobj *var, int only_children)
|
||||
varobj_delete (struct varobj *var, bool only_children)
|
||||
{
|
||||
return delete_variable (var, only_children);
|
||||
}
|
||||
|
|
@ -555,11 +555,11 @@ varobj_get_display_hint (const struct varobj *var)
|
|||
|
||||
/* Return true if the varobj has items after TO, false otherwise. */
|
||||
|
||||
int
|
||||
bool
|
||||
varobj_has_more (const struct varobj *var, int to)
|
||||
{
|
||||
if (var->children.size () > to)
|
||||
return 1;
|
||||
return true;
|
||||
|
||||
return ((to == -1 || var->children.size () == to)
|
||||
&& (var->dynamic->saved_item != NULL));
|
||||
|
|
@ -579,7 +579,7 @@ varobj_get_thread_id (const struct varobj *var)
|
|||
}
|
||||
|
||||
void
|
||||
varobj_set_frozen (struct varobj *var, int frozen)
|
||||
varobj_set_frozen (struct varobj *var, bool frozen)
|
||||
{
|
||||
/* When a variable is unfrozen, we don't fetch its value.
|
||||
The 'not_fetched' flag remains set, so next -var-update
|
||||
|
|
@ -591,7 +591,7 @@ varobj_set_frozen (struct varobj *var, int frozen)
|
|||
var->frozen = frozen;
|
||||
}
|
||||
|
||||
int
|
||||
bool
|
||||
varobj_get_frozen (const struct varobj *var)
|
||||
{
|
||||
return var->frozen;
|
||||
|
|
@ -633,7 +633,7 @@ install_dynamic_child (struct varobj *var,
|
|||
std::vector<varobj *> *type_changed,
|
||||
std::vector<varobj *> *newobj,
|
||||
std::vector<varobj *> *unchanged,
|
||||
int *cchanged,
|
||||
bool *cchanged,
|
||||
int index,
|
||||
struct varobj_item *item)
|
||||
{
|
||||
|
|
@ -645,13 +645,13 @@ install_dynamic_child (struct varobj *var,
|
|||
if (newobj != NULL)
|
||||
{
|
||||
newobj->push_back (child);
|
||||
*cchanged = 1;
|
||||
*cchanged = true;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
varobj *existing = var->children[index];
|
||||
int type_updated = update_type_if_necessary (existing, item->value);
|
||||
bool type_updated = update_type_if_necessary (existing, item->value);
|
||||
|
||||
if (type_updated)
|
||||
{
|
||||
|
|
@ -670,13 +670,13 @@ install_dynamic_child (struct varobj *var,
|
|||
|
||||
#if HAVE_PYTHON
|
||||
|
||||
static int
|
||||
static bool
|
||||
dynamic_varobj_has_child_method (const struct varobj *var)
|
||||
{
|
||||
PyObject *printer = var->dynamic->pretty_printer;
|
||||
|
||||
if (!gdb_python_initialized)
|
||||
return 0;
|
||||
return false;
|
||||
|
||||
gdbpy_enter_varobj enter_py (var);
|
||||
return PyObject_HasAttr (printer, gdbpy_children_cst);
|
||||
|
|
@ -711,20 +711,20 @@ varobj_clear_saved_item (struct varobj_dynamic *var)
|
|||
}
|
||||
}
|
||||
|
||||
static int
|
||||
static bool
|
||||
update_dynamic_varobj_children (struct varobj *var,
|
||||
std::vector<varobj *> *changed,
|
||||
std::vector<varobj *> *type_changed,
|
||||
std::vector<varobj *> *newobj,
|
||||
std::vector<varobj *> *unchanged,
|
||||
int *cchanged,
|
||||
int update_children,
|
||||
bool *cchanged,
|
||||
bool update_children,
|
||||
int from,
|
||||
int to)
|
||||
{
|
||||
int i;
|
||||
|
||||
*cchanged = 0;
|
||||
*cchanged = false;
|
||||
|
||||
if (update_children || var->dynamic->child_iter == NULL)
|
||||
{
|
||||
|
|
@ -736,7 +736,7 @@ update_dynamic_varobj_children (struct varobj *var,
|
|||
i = 0;
|
||||
|
||||
if (var->dynamic->child_iter == NULL)
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
else
|
||||
i = var->children.size ();
|
||||
|
|
@ -772,7 +772,7 @@ update_dynamic_varobj_children (struct varobj *var,
|
|||
/* We don't want to push the extra child on any report list. */
|
||||
if (to < 0 || i < to)
|
||||
{
|
||||
int can_mention = from < 0 || i >= from;
|
||||
bool can_mention = from < 0 || i >= from;
|
||||
|
||||
install_dynamic_child (var, can_mention ? changed : NULL,
|
||||
can_mention ? type_changed : NULL,
|
||||
|
|
@ -795,7 +795,7 @@ update_dynamic_varobj_children (struct varobj *var,
|
|||
|
||||
if (i < var->children.size ())
|
||||
{
|
||||
*cchanged = 1;
|
||||
*cchanged = true;
|
||||
for (int j = i; j < var->children.size (); ++j)
|
||||
varobj_delete (var->children[j], 0);
|
||||
|
||||
|
|
@ -805,11 +805,11 @@ update_dynamic_varobj_children (struct varobj *var,
|
|||
/* If there are fewer children than requested, note that the list of
|
||||
children changed. */
|
||||
if (to >= 0 && var->children.size () < to)
|
||||
*cchanged = 1;
|
||||
*cchanged = true;
|
||||
|
||||
var->num_children = var->children.size ();
|
||||
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
|
||||
int
|
||||
|
|
@ -819,12 +819,12 @@ varobj_get_num_children (struct varobj *var)
|
|||
{
|
||||
if (varobj_is_dynamic_p (var))
|
||||
{
|
||||
int dummy;
|
||||
bool dummy;
|
||||
|
||||
/* If we have a dynamic varobj, don't report -1 children.
|
||||
So, try to fetch some children first. */
|
||||
update_dynamic_varobj_children (var, NULL, NULL, NULL, NULL, &dummy,
|
||||
0, 0, 0);
|
||||
false, 0, 0);
|
||||
}
|
||||
else
|
||||
var->num_children = number_of_children (var);
|
||||
|
|
@ -839,17 +839,17 @@ varobj_get_num_children (struct varobj *var)
|
|||
const std::vector<varobj *> &
|
||||
varobj_list_children (struct varobj *var, int *from, int *to)
|
||||
{
|
||||
int children_changed;
|
||||
|
||||
var->dynamic->children_requested = 1;
|
||||
var->dynamic->children_requested_ = true;
|
||||
|
||||
if (varobj_is_dynamic_p (var))
|
||||
{
|
||||
bool children_changed;
|
||||
|
||||
/* This, in theory, can result in the number of children changing without
|
||||
frontend noticing. But well, calling -var-list-children on the same
|
||||
varobj twice is not something a sane frontend would do. */
|
||||
update_dynamic_varobj_children (var, NULL, NULL, NULL, NULL,
|
||||
&children_changed, 0, 0, *to);
|
||||
&children_changed, false, 0, *to);
|
||||
varobj_restrict_range (var->children, from, to);
|
||||
return var->children;
|
||||
}
|
||||
|
|
@ -919,7 +919,7 @@ varobj_get_gdb_type (const struct varobj *var)
|
|||
/* Is VAR a path expression parent, i.e., can it be used to construct
|
||||
a valid path expression? */
|
||||
|
||||
static int
|
||||
static bool
|
||||
is_path_expr_parent (const struct varobj *var)
|
||||
{
|
||||
gdb_assert (var->root->lang_ops->is_path_expr_parent != NULL);
|
||||
|
|
@ -930,10 +930,10 @@ is_path_expr_parent (const struct varobj *var)
|
|||
a valid path expression? By default we assume any VAR can be a path
|
||||
parent. */
|
||||
|
||||
int
|
||||
bool
|
||||
varobj_default_is_path_expr_parent (const struct varobj *var)
|
||||
{
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
|
||||
/* Return the path expression parent for VAR. */
|
||||
|
|
@ -989,7 +989,7 @@ varobj_get_attributes (const struct varobj *var)
|
|||
|
||||
/* Return true if VAR is a dynamic varobj. */
|
||||
|
||||
int
|
||||
bool
|
||||
varobj_is_dynamic_p (const struct varobj *var)
|
||||
{
|
||||
return var->dynamic->pretty_printer != NULL;
|
||||
|
|
@ -1012,7 +1012,7 @@ varobj_get_value (struct varobj *var)
|
|||
value of the given expression. */
|
||||
/* Note: Invokes functions that can call error(). */
|
||||
|
||||
int
|
||||
bool
|
||||
varobj_set_value (struct varobj *var, const char *expression)
|
||||
{
|
||||
struct value *val = NULL; /* Initialize to keep gcc happy. */
|
||||
|
|
@ -1035,7 +1035,7 @@ varobj_set_value (struct varobj *var, const char *expression)
|
|||
CATCH (except, RETURN_MASK_ERROR)
|
||||
{
|
||||
/* We cannot proceed without a valid expression. */
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
END_CATCH
|
||||
|
||||
|
|
@ -1063,7 +1063,7 @@ varobj_set_value (struct varobj *var, const char *expression)
|
|||
|
||||
CATCH (except, RETURN_MASK_ERROR)
|
||||
{
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
END_CATCH
|
||||
|
||||
|
|
@ -1073,9 +1073,9 @@ varobj_set_value (struct varobj *var, const char *expression)
|
|||
variable as changed -- because the first assignment has set the
|
||||
'updated' flag. There's no need to optimize that, because return value
|
||||
of -var-update should be considered an approximation. */
|
||||
var->updated = install_new_value (var, val, 0 /* Compare values. */);
|
||||
var->updated = install_new_value (var, val, false /* Compare values. */);
|
||||
input_radix = saved_input_radix;
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
|
||||
#if HAVE_PYTHON
|
||||
|
|
@ -1199,7 +1199,7 @@ install_new_value_visualizer (struct varobj *var)
|
|||
VAR will change when a new value NEW_VALUE is assigned and if it is so
|
||||
updates the type of VAR. */
|
||||
|
||||
static int
|
||||
static bool
|
||||
update_type_if_necessary (struct varobj *var, struct value *new_value)
|
||||
{
|
||||
if (new_value)
|
||||
|
|
@ -1222,34 +1222,34 @@ update_type_if_necessary (struct varobj *var, struct value *new_value)
|
|||
varobj_delete (var, 1);
|
||||
var->children.clear ();
|
||||
var->num_children = -1;
|
||||
return 1;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
/* Assign a new value to a variable object. If INITIAL is non-zero,
|
||||
this is the first assignement after the variable object was just
|
||||
/* Assign a new value to a variable object. If INITIAL is true,
|
||||
this is the first assignment after the variable object was just
|
||||
created, or changed type. In that case, just assign the value
|
||||
and return 0.
|
||||
Otherwise, assign the new value, and return 1 if the value is
|
||||
different from the current one, 0 otherwise. The comparison is
|
||||
and return false.
|
||||
Otherwise, assign the new value, and return true if the value is
|
||||
different from the current one, false otherwise. The comparison is
|
||||
done on textual representation of value. Therefore, some types
|
||||
need not be compared. E.g. for structures the reported value is
|
||||
always "{...}", so no comparison is necessary here. If the old
|
||||
value was NULL and new one is not, or vice versa, we always return 1.
|
||||
value was NULL and new one is not, or vice versa, we always return true.
|
||||
|
||||
The VALUE parameter should not be released -- the function will
|
||||
take care of releasing it when needed. */
|
||||
static int
|
||||
install_new_value (struct varobj *var, struct value *value, int initial)
|
||||
static bool
|
||||
install_new_value (struct varobj *var, struct value *value, bool initial)
|
||||
{
|
||||
int changeable;
|
||||
int need_to_fetch;
|
||||
int changed = 0;
|
||||
int intentionally_not_fetched = 0;
|
||||
bool changeable;
|
||||
bool need_to_fetch;
|
||||
bool changed = false;
|
||||
bool intentionally_not_fetched = false;
|
||||
|
||||
/* We need to know the varobj's type to decide if the value should
|
||||
be fetched or not. C++ fake children (public/protected/private)
|
||||
|
|
@ -1261,7 +1261,7 @@ install_new_value (struct varobj *var, struct value *value, int initial)
|
|||
changeable. FIXME: need to make sure this behaviour will not
|
||||
mess up read-sensitive values. */
|
||||
if (var->dynamic->pretty_printer != NULL)
|
||||
changeable = 1;
|
||||
changeable = true;
|
||||
|
||||
need_to_fetch = changeable;
|
||||
|
||||
|
|
@ -1281,7 +1281,7 @@ install_new_value (struct varobj *var, struct value *value, int initial)
|
|||
the data from memory. For unions, that means we'll read the
|
||||
same memory more than once, which is not desirable. So
|
||||
fetch now. */
|
||||
need_to_fetch = 1;
|
||||
need_to_fetch = true;
|
||||
|
||||
/* The new value might be lazy. If the type is changeable,
|
||||
that is we'll be comparing values of this type, fetch the
|
||||
|
|
@ -1290,7 +1290,7 @@ install_new_value (struct varobj *var, struct value *value, int initial)
|
|||
if (need_to_fetch && value && value_lazy (value))
|
||||
{
|
||||
const struct varobj *parent = var->parent;
|
||||
int frozen = var->frozen;
|
||||
bool frozen = var->frozen;
|
||||
|
||||
for (; !frozen && parent; parent = parent->parent)
|
||||
frozen |= parent->frozen;
|
||||
|
|
@ -1301,7 +1301,7 @@ install_new_value (struct varobj *var, struct value *value, int initial)
|
|||
variables, we don't do fetch on initial assignment.
|
||||
For non-initial assignemnt we do the fetch, since it means we're
|
||||
explicitly asked to compare the new value with the old one. */
|
||||
intentionally_not_fetched = 1;
|
||||
intentionally_not_fetched = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -1347,9 +1347,7 @@ install_new_value (struct varobj *var, struct value *value, int initial)
|
|||
varobj had after the previous -var-update. So need to the
|
||||
varobj as changed. */
|
||||
if (var->updated)
|
||||
{
|
||||
changed = 1;
|
||||
}
|
||||
changed = true;
|
||||
else if (var->dynamic->pretty_printer == NULL)
|
||||
{
|
||||
/* Try to compare the values. That requires that both
|
||||
|
|
@ -1361,14 +1359,14 @@ install_new_value (struct varobj *var, struct value *value, int initial)
|
|||
Now that we've fetched the real value, we need to report
|
||||
this varobj as changed so that UI can show the real
|
||||
value. */
|
||||
changed = 1;
|
||||
changed = true;
|
||||
}
|
||||
else if (var->value == NULL && value == NULL)
|
||||
/* Equal. */
|
||||
;
|
||||
else if (var->value == NULL || value == NULL)
|
||||
{
|
||||
changed = 1;
|
||||
changed = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -1377,7 +1375,7 @@ install_new_value (struct varobj *var, struct value *value, int initial)
|
|||
|
||||
gdb_assert (!var->print_value.empty () && !print_value.empty ());
|
||||
if (var->print_value != print_value)
|
||||
changed = 1;
|
||||
changed = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -1396,10 +1394,10 @@ install_new_value (struct varobj *var, struct value *value, int initial)
|
|||
value_free (var->value);
|
||||
var->value = value;
|
||||
if (value && value_lazy (value) && intentionally_not_fetched)
|
||||
var->not_fetched = 1;
|
||||
var->not_fetched = true;
|
||||
else
|
||||
var->not_fetched = 0;
|
||||
var->updated = 0;
|
||||
var->not_fetched = false;
|
||||
var->updated = false;
|
||||
|
||||
install_new_value_visualizer (var);
|
||||
|
||||
|
|
@ -1413,7 +1411,7 @@ install_new_value (struct varobj *var, struct value *value, int initial)
|
|||
|| (!var->print_value.empty () && print_value.empty ())
|
||||
|| (!var->print_value.empty () && !print_value.empty ()
|
||||
&& var->print_value != print_value))
|
||||
changed = 1;
|
||||
changed = true;
|
||||
}
|
||||
var->print_value = print_value;
|
||||
|
||||
|
|
@ -1478,13 +1476,13 @@ varobj_set_visualizer (struct varobj *var, const char *visualizer)
|
|||
}
|
||||
|
||||
/* If NEW_VALUE is the new value of the given varobj (var), return
|
||||
non-zero if var has mutated. In other words, if the type of
|
||||
true if var has mutated. In other words, if the type of
|
||||
the new value is different from the type of the varobj's old
|
||||
value.
|
||||
|
||||
NEW_VALUE may be NULL, if the varobj is now out of scope. */
|
||||
|
||||
static int
|
||||
static bool
|
||||
varobj_value_has_mutated (const struct varobj *var, struct value *new_value,
|
||||
struct type *new_type)
|
||||
{
|
||||
|
|
@ -1493,9 +1491,9 @@ varobj_value_has_mutated (const struct varobj *var, struct value *new_value,
|
|||
the type has mutated or not. For all intents and purposes,
|
||||
it has not mutated. */
|
||||
if (var->num_children < 0)
|
||||
return 0;
|
||||
return false;
|
||||
|
||||
if (var->root->lang_ops->value_has_mutated)
|
||||
if (var->root->lang_ops->value_has_mutated != NULL)
|
||||
{
|
||||
/* The varobj module, when installing new values, explicitly strips
|
||||
references, saying that we're not interested in those addresses.
|
||||
|
|
@ -1507,7 +1505,7 @@ varobj_value_has_mutated (const struct varobj *var, struct value *new_value,
|
|||
return var->root->lang_ops->value_has_mutated (var, new_value, new_type);
|
||||
}
|
||||
else
|
||||
return 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
/* Update the values for a variable and its children. This is a
|
||||
|
|
@ -1516,7 +1514,7 @@ varobj_value_has_mutated (const struct varobj *var, struct value *new_value,
|
|||
through its children, reconstructing them and noting if they've
|
||||
changed.
|
||||
|
||||
The EXPLICIT parameter specifies if this call is result
|
||||
The IS_EXPLICIT parameter specifies if this call is result
|
||||
of MI request to update this specific variable, or
|
||||
result of implicit -var-update *. For implicit request, we don't
|
||||
update frozen variables.
|
||||
|
|
@ -1526,9 +1524,9 @@ varobj_value_has_mutated (const struct varobj *var, struct value *new_value,
|
|||
to point to the new varobj. */
|
||||
|
||||
std::vector<varobj_update_result>
|
||||
varobj_update (struct varobj **varp, int is_explicit)
|
||||
varobj_update (struct varobj **varp, bool is_explicit)
|
||||
{
|
||||
int type_changed = 0;
|
||||
bool type_changed = false;
|
||||
struct value *newobj;
|
||||
std::vector<varobj_update_result> stack;
|
||||
std::vector<varobj_update_result> result;
|
||||
|
|
@ -1557,16 +1555,16 @@ varobj_update (struct varobj **varp, int is_explicit)
|
|||
value_of_root variable dispose of the varobj if the type
|
||||
has changed. */
|
||||
newobj = value_of_root (varp, &type_changed);
|
||||
if (update_type_if_necessary(*varp, newobj))
|
||||
type_changed = 1;
|
||||
if (update_type_if_necessary (*varp, newobj))
|
||||
type_changed = true;
|
||||
r.varobj = *varp;
|
||||
r.type_changed = type_changed;
|
||||
if (install_new_value ((*varp), newobj, type_changed))
|
||||
r.changed = 1;
|
||||
r.changed = true;
|
||||
|
||||
if (newobj == NULL)
|
||||
r.status = VAROBJ_NOT_IN_SCOPE;
|
||||
r.value_installed = 1;
|
||||
r.value_installed = true;
|
||||
|
||||
if (r.status == VAROBJ_NOT_IN_SCOPE)
|
||||
{
|
||||
|
|
@ -1595,8 +1593,8 @@ varobj_update (struct varobj **varp, int is_explicit)
|
|||
struct type *new_type;
|
||||
|
||||
newobj = value_of_child (v->parent, v->index);
|
||||
if (update_type_if_necessary(v, newobj))
|
||||
r.type_changed = 1;
|
||||
if (update_type_if_necessary (v, newobj))
|
||||
r.type_changed = true;
|
||||
if (newobj)
|
||||
new_type = value_type (newobj);
|
||||
else
|
||||
|
|
@ -1611,13 +1609,13 @@ varobj_update (struct varobj **varp, int is_explicit)
|
|||
v->to = -1;
|
||||
v->from = -1;
|
||||
v->type = new_type;
|
||||
r.type_changed = 1;
|
||||
r.type_changed = true;
|
||||
}
|
||||
|
||||
if (install_new_value (v, newobj, r.type_changed))
|
||||
{
|
||||
r.changed = 1;
|
||||
v->updated = 0;
|
||||
r.changed = true;
|
||||
v->updated = false;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1626,14 +1624,14 @@ varobj_update (struct varobj **varp, int is_explicit)
|
|||
if (varobj_is_dynamic_p (v))
|
||||
{
|
||||
std::vector<varobj *> changed, type_changed, unchanged, newobj;
|
||||
int children_changed = 0;
|
||||
bool children_changed = false;
|
||||
|
||||
if (v->frozen)
|
||||
continue;
|
||||
|
||||
if (!v->dynamic->children_requested)
|
||||
if (!v->dynamic->children_requested_)
|
||||
{
|
||||
int dummy;
|
||||
bool dummy;
|
||||
|
||||
/* If we initially did not have potential children, but
|
||||
now we do, consider the varobj as changed.
|
||||
|
|
@ -1644,9 +1642,9 @@ varobj_update (struct varobj **varp, int is_explicit)
|
|||
if (!varobj_has_more (v, 0))
|
||||
{
|
||||
update_dynamic_varobj_children (v, NULL, NULL, NULL, NULL,
|
||||
&dummy, 0, 0, 0);
|
||||
&dummy, false, 0, 0);
|
||||
if (varobj_has_more (v, 0))
|
||||
r.changed = 1;
|
||||
r.changed = true;
|
||||
}
|
||||
|
||||
if (r.changed)
|
||||
|
|
@ -1655,15 +1653,15 @@ varobj_update (struct varobj **varp, int is_explicit)
|
|||
continue;
|
||||
}
|
||||
|
||||
/* If update_dynamic_varobj_children returns 0, then we have
|
||||
/* If update_dynamic_varobj_children returns false, then we have
|
||||
a non-conforming pretty-printer, so we skip it. */
|
||||
if (update_dynamic_varobj_children (v, &changed, &type_changed, &newobj,
|
||||
&unchanged, &children_changed, 1,
|
||||
&unchanged, &children_changed, true,
|
||||
v->from, v->to))
|
||||
{
|
||||
if (children_changed || !newobj.empty ())
|
||||
{
|
||||
r.children_changed = 1;
|
||||
r.children_changed = true;
|
||||
r.newobj = std::move (newobj);
|
||||
}
|
||||
/* Push in reverse order so that the first child is
|
||||
|
|
@ -1675,9 +1673,9 @@ varobj_update (struct varobj **varp, int is_explicit)
|
|||
varobj_update_result r (type_changed[i]);
|
||||
|
||||
/* Type may change only if value was changed. */
|
||||
r.changed = 1;
|
||||
r.type_changed = 1;
|
||||
r.value_installed = 1;
|
||||
r.changed = true;
|
||||
r.type_changed = true;
|
||||
r.value_installed = true;
|
||||
|
||||
stack.push_back (std::move (r));
|
||||
}
|
||||
|
|
@ -1685,8 +1683,8 @@ varobj_update (struct varobj **varp, int is_explicit)
|
|||
{
|
||||
varobj_update_result r (changed[i]);
|
||||
|
||||
r.changed = 1;
|
||||
r.value_installed = 1;
|
||||
r.changed = true;
|
||||
r.value_installed = true;
|
||||
|
||||
stack.push_back (std::move (r));
|
||||
}
|
||||
|
|
@ -1696,7 +1694,7 @@ varobj_update (struct varobj **varp, int is_explicit)
|
|||
{
|
||||
varobj_update_result r (unchanged[i]);
|
||||
|
||||
r.value_installed = 1;
|
||||
r.value_installed = true;
|
||||
|
||||
stack.push_back (std::move (r));
|
||||
}
|
||||
|
|
@ -1735,12 +1733,12 @@ varobj_update (struct varobj **varp, int is_explicit)
|
|||
*/
|
||||
|
||||
static int
|
||||
delete_variable (struct varobj *var, int only_children_p)
|
||||
delete_variable (struct varobj *var, bool only_children_p)
|
||||
{
|
||||
int delcount = 0;
|
||||
|
||||
delete_variable_1 (&delcount, var, only_children_p,
|
||||
1 /* remove_from_parent_p */ );
|
||||
true /* remove_from_parent_p */ );
|
||||
|
||||
return delcount;
|
||||
}
|
||||
|
|
@ -1750,8 +1748,8 @@ delete_variable (struct varobj *var, int only_children_p)
|
|||
and the parent is not removed we dump core. It must be always
|
||||
initially called with remove_from_parent_p set. */
|
||||
static void
|
||||
delete_variable_1 (int *delcountp, struct varobj *var, int only_children_p,
|
||||
int remove_from_parent_p)
|
||||
delete_variable_1 (int *delcountp, struct varobj *var, bool only_children_p,
|
||||
bool remove_from_parent_p)
|
||||
{
|
||||
/* Delete any children of this variable, too. */
|
||||
for (varobj *child : var->children)
|
||||
|
|
@ -1762,7 +1760,7 @@ delete_variable_1 (int *delcountp, struct varobj *var, int only_children_p,
|
|||
if (!remove_from_parent_p)
|
||||
child->parent = NULL;
|
||||
|
||||
delete_variable_1 (delcountp, child, 0, only_children_p);
|
||||
delete_variable_1 (delcountp, child, false, only_children_p);
|
||||
}
|
||||
var->children.clear ();
|
||||
|
||||
|
|
@ -1794,7 +1792,7 @@ delete_variable_1 (int *delcountp, struct varobj *var, int only_children_p,
|
|||
}
|
||||
|
||||
/* Install the given variable VAR with the object name VAR->OBJ_NAME. */
|
||||
static int
|
||||
static bool
|
||||
install_variable (struct varobj *var)
|
||||
{
|
||||
struct vlist *cv;
|
||||
|
|
@ -1832,7 +1830,7 @@ install_variable (struct varobj *var)
|
|||
rootlist = var->root;
|
||||
}
|
||||
|
||||
return 1; /* OK */
|
||||
return true; /* OK */
|
||||
}
|
||||
|
||||
/* Unistall the object VAR. */
|
||||
|
|
@ -2071,13 +2069,13 @@ name_of_child (struct varobj *var, int index)
|
|||
}
|
||||
|
||||
/* If frame associated with VAR can be found, switch
|
||||
to it and return 1. Otherwise, return 0. */
|
||||
to it and return true. Otherwise, return false. */
|
||||
|
||||
static int
|
||||
static bool
|
||||
check_scope (const struct varobj *var)
|
||||
{
|
||||
struct frame_info *fi;
|
||||
int scope;
|
||||
bool scope;
|
||||
|
||||
fi = frame_find_by_id (var->root->frame);
|
||||
scope = fi != NULL;
|
||||
|
|
@ -2088,7 +2086,7 @@ check_scope (const struct varobj *var)
|
|||
|
||||
if (pc < BLOCK_START (var->root->valid_block) ||
|
||||
pc >= BLOCK_END (var->root->valid_block))
|
||||
scope = 0;
|
||||
scope = false;
|
||||
else
|
||||
select_frame (fi);
|
||||
}
|
||||
|
|
@ -2102,7 +2100,7 @@ value_of_root_1 (struct varobj **var_handle)
|
|||
{
|
||||
struct value *new_val = NULL;
|
||||
struct varobj *var = *var_handle;
|
||||
int within_scope = 0;
|
||||
bool within_scope = false;
|
||||
|
||||
/* Only root variables can be updated... */
|
||||
if (!is_root_p (var))
|
||||
|
|
@ -2113,7 +2111,7 @@ value_of_root_1 (struct varobj **var_handle)
|
|||
|
||||
/* Determine whether the variable is still around. */
|
||||
if (var->root->valid_block == NULL || var->root->floating)
|
||||
within_scope = 1;
|
||||
within_scope = true;
|
||||
else if (var->root->thread_id == 0)
|
||||
{
|
||||
/* The program was single-threaded when the variable object was
|
||||
|
|
@ -2161,7 +2159,7 @@ value_of_root_1 (struct varobj **var_handle)
|
|||
- *var_handle will be set to the new varobj
|
||||
Otherwise, *type_changed will be set to 0. */
|
||||
static struct value *
|
||||
value_of_root (struct varobj **var_handle, int *type_changed)
|
||||
value_of_root (struct varobj **var_handle, bool *type_changed)
|
||||
{
|
||||
struct varobj *var;
|
||||
|
||||
|
|
@ -2211,7 +2209,7 @@ value_of_root (struct varobj **var_handle, int *type_changed)
|
|||
install_variable (tmp_var);
|
||||
*var_handle = tmp_var;
|
||||
var = *var_handle;
|
||||
*type_changed = 1;
|
||||
*type_changed = true;
|
||||
}
|
||||
}
|
||||
else
|
||||
|
|
@ -2237,7 +2235,7 @@ value_of_root (struct varobj **var_handle, int *type_changed)
|
|||
var->num_children = -1;
|
||||
var->to = -1;
|
||||
var->from = -1;
|
||||
*type_changed = 1;
|
||||
*type_changed = true;
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
|
@ -2288,7 +2286,7 @@ varobj_value_get_print_value (struct value *value,
|
|||
gdb::unique_xmalloc_ptr<char> encoding;
|
||||
/* Initialize it just to avoid a GCC false warning. */
|
||||
CORE_ADDR str_addr = 0;
|
||||
int string_print = 0;
|
||||
bool string_print = false;
|
||||
|
||||
if (value == NULL)
|
||||
return std::string ();
|
||||
|
|
@ -2328,7 +2326,7 @@ varobj_value_get_print_value (struct value *value,
|
|||
{
|
||||
gdbpy_extract_lazy_string (output.get (), &str_addr,
|
||||
&type, &len, &encoding);
|
||||
string_print = 1;
|
||||
string_print = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -2350,7 +2348,7 @@ varobj_value_get_print_value (struct value *value,
|
|||
if (hint)
|
||||
{
|
||||
if (!strcmp (hint.get (), "string"))
|
||||
string_print = 1;
|
||||
string_print = true;
|
||||
}
|
||||
|
||||
thevalue = std::string (s.get ());
|
||||
|
|
@ -2392,13 +2390,13 @@ varobj_value_get_print_value (struct value *value,
|
|||
return std::move (stb.string ());
|
||||
}
|
||||
|
||||
int
|
||||
bool
|
||||
varobj_editable_p (const struct varobj *var)
|
||||
{
|
||||
struct type *type;
|
||||
|
||||
if (!(var->root->is_valid && var->value && VALUE_LVAL (var->value)))
|
||||
return 0;
|
||||
return false;
|
||||
|
||||
type = varobj_get_value_type (var);
|
||||
|
||||
|
|
@ -2409,27 +2407,27 @@ varobj_editable_p (const struct varobj *var)
|
|||
case TYPE_CODE_ARRAY:
|
||||
case TYPE_CODE_FUNC:
|
||||
case TYPE_CODE_METHOD:
|
||||
return 0;
|
||||
return false;
|
||||
break;
|
||||
|
||||
default:
|
||||
return 1;
|
||||
return true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* Call VAR's value_is_changeable_p language-specific callback. */
|
||||
|
||||
int
|
||||
bool
|
||||
varobj_value_is_changeable_p (const struct varobj *var)
|
||||
{
|
||||
return var->root->lang_ops->value_is_changeable_p (var);
|
||||
}
|
||||
|
||||
/* Return 1 if that varobj is floating, that is is always evaluated in the
|
||||
/* Return true if that varobj is floating, that is is always evaluated in the
|
||||
selected frame, and not bound to thread/frame. Such variable objects
|
||||
are created using '@' as frame specifier to -var-create. */
|
||||
int
|
||||
bool
|
||||
varobj_floating_p (const struct varobj *var)
|
||||
{
|
||||
return var->root->floating;
|
||||
|
|
@ -2438,14 +2436,14 @@ varobj_floating_p (const struct varobj *var)
|
|||
/* Implement the "value_is_changeable_p" varobj callback for most
|
||||
languages. */
|
||||
|
||||
int
|
||||
bool
|
||||
varobj_default_value_is_changeable_p (const struct varobj *var)
|
||||
{
|
||||
int r;
|
||||
bool r;
|
||||
struct type *type;
|
||||
|
||||
if (CPLUS_FAKE_CHILD (var))
|
||||
return 0;
|
||||
return false;
|
||||
|
||||
type = varobj_get_value_type (var);
|
||||
|
||||
|
|
@ -2454,11 +2452,11 @@ varobj_default_value_is_changeable_p (const struct varobj *var)
|
|||
case TYPE_CODE_STRUCT:
|
||||
case TYPE_CODE_UNION:
|
||||
case TYPE_CODE_ARRAY:
|
||||
r = 0;
|
||||
r = false;
|
||||
break;
|
||||
|
||||
default:
|
||||
r = 1;
|
||||
r = true;
|
||||
}
|
||||
|
||||
return r;
|
||||
|
|
@ -2508,10 +2506,10 @@ varobj_invalidate_iter (struct varobj *var, void *unused)
|
|||
install_variable (tmp_var);
|
||||
}
|
||||
else
|
||||
var->root->is_valid = 0;
|
||||
var->root->is_valid = false;
|
||||
}
|
||||
else /* locals must be invalidated. */
|
||||
var->root->is_valid = 0;
|
||||
var->root->is_valid = false;
|
||||
}
|
||||
|
||||
/* Invalidate the varobjs that are tied to locals and re-create the ones that
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue