/* Implementation of the GDB variable objects API.
- Copyright (C) 1999-2014 Free Software Foundation, Inc.
+ Copyright (C) 1999-2016 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
-#include "exceptions.h"
#include "value.h"
#include "expression.h"
#include "frame.h"
/* String representations of gdb's format codes. */
char *varobj_format_string[] =
- { "natural", "binary", "decimal", "hexadecimal", "octal" };
+ { "natural", "binary", "decimal", "hexadecimal", "octal", "zero-hexadecimal" };
/* True if we want to allow Python-based pretty-printing. */
static int pretty_printing = 0;
not NULL. */
struct frame_id frame;
- /* The thread ID that this varobj_root belong to. This field
+ /* The global thread ID that this varobj_root belongs to. This field
is only valid if valid_block is not NULL.
When not 0, indicates which thread 'frame' belongs to.
When 0, indicates that the thread list was empty when the varobj_root
varobj_item *saved_item;
};
-struct cpstack
-{
- char *name;
- struct cpstack *next;
-};
-
/* A list of varobjs */
struct vlist
/* Helper functions for the above subcommands. */
-static int delete_variable (struct cpstack **, struct varobj *, int);
+static int delete_variable (struct varobj *, int);
-static void delete_variable_1 (struct cpstack **, int *,
- struct varobj *, int, int);
+static void delete_variable_1 (int *, struct varobj *, int, int);
static int install_variable (struct varobj *);
static enum varobj_display_formats variable_default_display (struct varobj *);
-static void cppush (struct cpstack **pstack, char *name);
-
-static char *cppop (struct cpstack **pstack);
-
static int update_type_if_necessary (struct varobj *var,
struct value *new_value);
/* Language-specific routines. */
-static int number_of_children (struct varobj *);
+static int number_of_children (const struct varobj *);
-static char *name_of_variable (struct varobj *);
+static char *name_of_variable (const struct varobj *);
static char *name_of_child (struct varobj *, int);
static struct value *value_of_root (struct varobj **var_handle, int *);
-static struct value *value_of_child (struct varobj *parent, int index);
+static struct value *value_of_child (const struct varobj *parent, int index);
static char *my_value_of_variable (struct varobj *var,
enum varobj_display_formats format);
-static int is_root_p (struct varobj *var);
+static int is_root_p (const struct varobj *var);
static struct varobj *varobj_add_child (struct varobj *var,
struct varobj_item *item);
/* Private data */
/* Mappings of varobj_display_formats enums to gdb's format codes. */
-static int format_code[] = { 0, 't', 'd', 'x', 'o' };
+static int format_code[] = { 0, 't', 'd', 'x', 'o', 'z' };
/* Header of the list of root variable objects. */
static struct varobj_root *rootlist;
/* Prime number indicating the number of buckets in the hash table. */
-/* A prime large enough to avoid too many colisions. */
+/* A prime large enough to avoid too many collisions. */
#define VAROBJ_TABLE_SIZE 227
/* Pointer to the varobj hash table (built at run time). */
/* API Implementation */
static int
-is_root_p (struct varobj *var)
+is_root_p (const struct varobj *var)
{
return (var->root->rootvar == var);
}
/* Helper function to install a Python environment suitable for
use during operations on VAR. */
struct cleanup *
-varobj_ensure_python_env (struct varobj *var)
+varobj_ensure_python_env (const struct varobj *var)
{
return ensure_python_env (var->root->exp->gdbarch,
var->root->exp->language_defn);
}
#endif
-/* 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. */
return NULL;
}
+/* Creates a varobj (not its children). */
+
struct varobj *
varobj_create (char *objname,
char *expression, CORE_ADDR frame, enum varobj_type type)
const struct block *block;
const char *p;
struct value *value = NULL;
- volatile struct gdb_exception except;
CORE_ADDR pc;
/* Parse and evaluate the expression, filling in as much of the
innermost_block = NULL;
/* Wrap the call to parse expression, so we can
return a sensible error. */
- TRY_CATCH (except, RETURN_MASK_ERROR)
+ TRY
{
var->root->exp = parse_exp_1 (&p, pc, block, 0);
}
- if (except.reason < 0)
+ CATCH (except, RETURN_MASK_ERROR)
{
do_cleanups (old_chain);
return NULL;
}
+ END_CATCH
/* Don't allow variables to be created for types. */
if (var->root->exp->elts[0].opcode == OP_TYPE
error (_("Failed to find the specified frame"));
var->root->frame = get_frame_id (fi);
- var->root->thread_id = pid_to_thread_id (inferior_ptid);
+ var->root->thread_id = ptid_to_global_thread_id (inferior_ptid);
old_id = get_frame_id (get_selected_frame (NULL));
select_frame (fi);
}
/* We definitely need to catch errors here.
If evaluate_expression succeeds we got the value we wanted.
But if it fails, we still go on with a call to evaluate_type(). */
- TRY_CATCH (except, RETURN_MASK_ERROR)
+ TRY
{
value = evaluate_expression (var->root->exp);
}
-
- if (except.reason < 0)
+ CATCH (except, RETURN_MASK_ERROR)
{
/* Error getting the value. Try to at least get the
right type. */
var->type = value_type (type_only_value);
}
- else
- {
- int real_type_found = 0;
+ END_CATCH
- var->type = value_actual_type (value, 0, &real_type_found);
- if (real_type_found)
- value = value_cast (var->type, value);
- }
+ if (value != NULL)
+ {
+ int real_type_found = 0;
+
+ var->type = value_actual_type (value, 0, &real_type_found);
+ if (real_type_found)
+ value = value_cast (var->type, value);
+ }
/* Set language info */
var->root->lang_ops = var->root->exp->language_defn->la_varobj_ops;
/* Given the handle, return the name of the object. */
char *
-varobj_get_objname (struct varobj *var)
+varobj_get_objname (const struct varobj *var)
{
return var->obj_name;
}
-/* Given the handle, return the expression represented by the object. */
+/* Given the handle, return the expression represented by the object. The
+ result must be freed by the caller. */
char *
-varobj_get_expression (struct varobj *var)
+varobj_get_expression (const struct varobj *var)
{
return name_of_variable (var);
}
-/* Deletes a varobj and all its children if only_children == 0,
- otherwise deletes only the children; returns a malloc'ed list of
- all the (malloc'ed) names of the variables that have been deleted
- (NULL terminated). */
+/* See varobj.h. */
int
-varobj_delete (struct varobj *var, char ***dellist, int only_children)
+varobj_delete (struct varobj *var, int only_children)
{
- int delcount;
- int mycount;
- struct cpstack *result = NULL;
- char **cp;
-
- /* Initialize a stack for temporary results. */
- cppush (&result, NULL);
-
- if (only_children)
- /* Delete only the variable children. */
- delcount = delete_variable (&result, var, 1 /* only the children */ );
- else
- /* Delete the variable and all its children. */
- delcount = delete_variable (&result, var, 0 /* parent+children */ );
-
- /* We may have been asked to return a list of what has been deleted. */
- if (dellist != NULL)
- {
- *dellist = xmalloc ((delcount + 1) * sizeof (char *));
-
- cp = *dellist;
- mycount = delcount;
- *cp = cppop (&result);
- while ((*cp != NULL) && (mycount > 0))
- {
- mycount--;
- cp++;
- *cp = cppop (&result);
- }
-
- if (mycount || (*cp != NULL))
- warning (_("varobj_delete: assertion failed - mycount(=%d) <> 0"),
- mycount);
- }
-
- return delcount;
+ return delete_variable (var, only_children);
}
#if HAVE_PYTHON
case FORMAT_DECIMAL:
case FORMAT_HEXADECIMAL:
case FORMAT_OCTAL:
+ case FORMAT_ZHEXADECIMAL:
var->format = format;
break;
}
enum varobj_display_formats
-varobj_get_display_format (struct varobj *var)
+varobj_get_display_format (const struct varobj *var)
{
return var->format;
}
char *
-varobj_get_display_hint (struct varobj *var)
+varobj_get_display_hint (const struct varobj *var)
{
char *result = NULL;
/* Return true if the varobj has items after TO, false otherwise. */
int
-varobj_has_more (struct varobj *var, int to)
+varobj_has_more (const struct varobj *var, int to)
{
if (VEC_length (varobj_p, var->children) > to)
return 1;
inside that thread, returns GDB id of the thread -- which
is always positive. Otherwise, returns -1. */
int
-varobj_get_thread_id (struct varobj *var)
+varobj_get_thread_id (const struct varobj *var)
{
if (var->root->valid_block && var->root->thread_id > 0)
return var->root->thread_id;
}
int
-varobj_get_frozen (struct varobj *var)
+varobj_get_frozen (const struct varobj *var)
{
return var->frozen;
}
install_dynamic_child (struct varobj *var,
VEC (varobj_p) **changed,
VEC (varobj_p) **type_changed,
- VEC (varobj_p) **new,
+ VEC (varobj_p) **newobj,
VEC (varobj_p) **unchanged,
int *cchanged,
int index,
/* There's no child yet. */
struct varobj *child = varobj_add_child (var, item);
- if (new)
+ if (newobj)
{
- VEC_safe_push (varobj_p, *new, child);
+ VEC_safe_push (varobj_p, *newobj, child);
*cchanged = 1;
}
}
#if HAVE_PYTHON
static int
-dynamic_varobj_has_child_method (struct varobj *var)
+dynamic_varobj_has_child_method (const struct varobj *var)
{
struct cleanup *back_to;
PyObject *printer = var->dynamic->pretty_printer;
update_dynamic_varobj_children (struct varobj *var,
VEC (varobj_p) **changed,
VEC (varobj_p) **type_changed,
- VEC (varobj_p) **new,
+ VEC (varobj_p) **newobj,
VEC (varobj_p) **unchanged,
int *cchanged,
int update_children,
install_dynamic_child (var, can_mention ? changed : NULL,
can_mention ? type_changed : NULL,
- can_mention ? new : NULL,
+ can_mention ? newobj : NULL,
can_mention ? unchanged : NULL,
can_mention ? cchanged : NULL, i,
item);
*cchanged = 1;
for (j = i; j < VEC_length (varobj_p, var->children); ++j)
- varobj_delete (VEC_index (varobj_p, var->children, j), NULL, 0);
+ varobj_delete (VEC_index (varobj_p, var->children, j), 0);
VEC_truncate (varobj_p, var->children, i);
}
}
/* Obtain the type of an object Variable as a string similar to the one gdb
- prints on the console. */
+ prints on the console. The caller is responsible for freeing the string.
+ */
char *
varobj_get_type (struct varobj *var)
/* Obtain the type of an object variable. */
struct type *
-varobj_get_gdb_type (struct varobj *var)
+varobj_get_gdb_type (const struct varobj *var)
{
return var->type;
}
a valid path expression? */
static int
-is_path_expr_parent (struct varobj *var)
+is_path_expr_parent (const struct varobj *var)
{
gdb_assert (var->root->lang_ops->is_path_expr_parent != NULL);
return var->root->lang_ops->is_path_expr_parent (var);
parent. */
int
-varobj_default_is_path_expr_parent (struct varobj *var)
+varobj_default_is_path_expr_parent (const struct varobj *var)
{
return 1;
}
/* Return the path expression parent for VAR. */
-struct varobj *
-varobj_get_path_expr_parent (struct varobj *var)
+const struct varobj *
+varobj_get_path_expr_parent (const struct varobj *var)
{
- struct varobj *parent = var;
+ const struct varobj *parent = var;
while (!is_root_p (parent) && !is_path_expr_parent (parent))
parent = parent->parent;
/* Return a pointer to the full rooted expression of varobj VAR.
If it has not been computed yet, compute it. */
char *
-varobj_get_path_expr (struct varobj *var)
+varobj_get_path_expr (const struct varobj *var)
{
- if (var->path_expr != NULL)
- return var->path_expr;
- else
+ if (var->path_expr == NULL)
{
/* For root varobjs, we initialize path_expr
when creating varobj, so here it should be
child varobj. */
+ struct varobj *mutable_var = (struct varobj *) var;
gdb_assert (!is_root_p (var));
- return (*var->root->lang_ops->path_expr_of_child) (var);
+
+ mutable_var->path_expr = (*var->root->lang_ops->path_expr_of_child) (var);
}
+
+ return var->path_expr;
}
const struct language_defn *
-varobj_get_language (struct varobj *var)
+varobj_get_language (const struct varobj *var)
{
return var->root->exp->language_defn;
}
int
-varobj_get_attributes (struct varobj *var)
+varobj_get_attributes (const struct varobj *var)
{
int attributes = 0;
/* Return true if VAR is a dynamic varobj. */
int
-varobj_is_dynamic_p (struct varobj *var)
+varobj_is_dynamic_p (const struct varobj *var)
{
return var->dynamic->pretty_printer != NULL;
}
struct value *value = NULL; /* Initialize to keep gcc happy. */
int saved_input_radix = input_radix;
const char *s = expression;
- volatile struct gdb_exception except;
gdb_assert (varobj_editable_p (var));
input_radix = 10; /* ALWAYS reset to decimal temporarily. */
exp = parse_exp_1 (&s, 0, 0, 0);
- TRY_CATCH (except, RETURN_MASK_ERROR)
+ TRY
{
value = evaluate_expression (exp);
}
- if (except.reason < 0)
+ CATCH (except, RETURN_MASK_ERROR)
{
/* We cannot proceed without a valid expression. */
xfree (exp);
return 0;
}
+ END_CATCH
/* All types that are editable must also be changeable. */
gdb_assert (varobj_value_is_changeable_p (var));
/* The new value may be lazy. value_assign, or
rather value_contents, will take care of this. */
- TRY_CATCH (except, RETURN_MASK_ERROR)
+ TRY
{
val = value_assign (var->value, value);
}
- if (except.reason < 0)
- return 0;
+ CATCH (except, RETURN_MASK_ERROR)
+ {
+ return 0;
+ }
+ END_CATCH
/* If the value has changed, record it, so that next -var-update can
report this change. If a variable had a value of '1', we've set it
{
struct type *new_type;
char *curr_type_str, *new_type_str;
+ int type_name_changed;
new_type = value_actual_type (new_value, 0, 0);
new_type_str = type_to_string (new_type);
curr_type_str = varobj_get_type (var);
- if (strcmp (curr_type_str, new_type_str) != 0)
+ type_name_changed = strcmp (curr_type_str, new_type_str) != 0;
+ xfree (curr_type_str);
+ xfree (new_type_str);
+
+ if (type_name_changed)
{
var->type = new_type;
/* This information may be not valid for a new type. */
- varobj_delete (var, NULL, 1);
+ varobj_delete (var, 1);
VEC_free (varobj_p, var->children);
var->num_children = -1;
return 1;
will be lazy, which means we've lost that old value. */
if (need_to_fetch && value && value_lazy (value))
{
- struct varobj *parent = var->parent;
+ const struct varobj *parent = var->parent;
int frozen = var->frozen;
for (; !frozen && parent; parent = parent->parent)
}
else
{
- volatile struct gdb_exception except;
- TRY_CATCH (except, RETURN_MASK_ERROR)
+ TRY
{
value_fetch_lazy (value);
}
- if (except.reason < 0)
+ CATCH (except, RETURN_MASK_ERROR)
{
/* Set the value to NULL, so that for the next -var-update,
we don't try to compare the new value with this value,
that we couldn't even read. */
value = NULL;
}
+ END_CATCH
}
}
selected sub-range of VAR. If no range was selected using
-var-set-update-range, then both will be -1. */
void
-varobj_get_child_range (struct varobj *var, int *from, int *to)
+varobj_get_child_range (const struct varobj *var, int *from, int *to)
{
*from = var->from;
*to = var->to;
Py_XDECREF (constructor);
/* If there are any children now, wipe them. */
- varobj_delete (var, NULL, 1 /* children only */);
+ varobj_delete (var, 1 /* children only */);
var->num_children = -1;
do_cleanups (back_to);
NEW_VALUE may be NULL, if the varobj is now out of scope. */
static int
-varobj_value_has_mutated (struct varobj *var, struct value *new_value,
+varobj_value_has_mutated (const struct varobj *var, struct value *new_value,
struct type *new_type)
{
/* If we haven't previously computed the number of children in var,
to point to the new varobj. */
VEC(varobj_update_result) *
-varobj_update (struct varobj **varp, int explicit)
+varobj_update (struct varobj **varp, int is_explicit)
{
int type_changed = 0;
int i;
- struct value *new;
+ struct value *newobj;
VEC (varobj_update_result) *stack = NULL;
VEC (varobj_update_result) *result = NULL;
changing type. One use case for frozen varobjs is
retaining previously evaluated expressions, and we don't
want them to be reevaluated at all. */
- if (!explicit && (*varp)->frozen)
+ if (!is_explicit && (*varp)->frozen)
return result;
if (!(*varp)->root->is_valid)
the frame in which a local existed. We are letting the
value_of_root variable dispose of the varobj if the type
has changed. */
- new = value_of_root (varp, &type_changed);
- if (update_type_if_necessary(*varp, new))
+ newobj = value_of_root (varp, &type_changed);
+ if (update_type_if_necessary(*varp, newobj))
type_changed = 1;
r.varobj = *varp;
r.type_changed = type_changed;
- if (install_new_value ((*varp), new, type_changed))
+ if (install_new_value ((*varp), newobj, type_changed))
r.changed = 1;
- if (new == NULL)
+ if (newobj == NULL)
r.status = VAROBJ_NOT_IN_SCOPE;
r.value_installed = 1;
{
struct type *new_type;
- new = value_of_child (v->parent, v->index);
- if (update_type_if_necessary(v, new))
+ newobj = value_of_child (v->parent, v->index);
+ if (update_type_if_necessary(v, newobj))
r.type_changed = 1;
- if (new)
- new_type = value_type (new);
+ if (newobj)
+ new_type = value_type (newobj);
else
new_type = v->root->lang_ops->type_of_child (v->parent, v->index);
- if (varobj_value_has_mutated (v, new, new_type))
+ if (varobj_value_has_mutated (v, newobj, new_type))
{
/* The children are no longer valid; delete them now.
Report the fact that its type changed as well. */
- varobj_delete (v, NULL, 1 /* only_children */);
+ varobj_delete (v, 1 /* only_children */);
v->num_children = -1;
v->to = -1;
v->from = -1;
r.type_changed = 1;
}
- if (install_new_value (v, new, r.type_changed))
+ if (install_new_value (v, newobj, r.type_changed))
{
r.changed = 1;
v->updated = 0;
if (varobj_is_dynamic_p (v))
{
VEC (varobj_p) *changed = 0, *type_changed = 0, *unchanged = 0;
- VEC (varobj_p) *new = 0;
+ VEC (varobj_p) *newobj = 0;
int i, children_changed = 0;
if (v->frozen)
/* If update_dynamic_varobj_children returns 0, then we have
a non-conforming pretty-printer, so we skip it. */
- if (update_dynamic_varobj_children (v, &changed, &type_changed, &new,
+ if (update_dynamic_varobj_children (v, &changed, &type_changed, &newobj,
&unchanged, &children_changed, 1,
v->from, v->to))
{
- if (children_changed || new)
+ if (children_changed || newobj)
{
r.children_changed = 1;
- r.new = new;
+ r.newobj = newobj;
}
/* Push in reverse order so that the first child is
popped from the work stack first, and so will be
*/
static int
-delete_variable (struct cpstack **resultp, struct varobj *var,
- int only_children_p)
+delete_variable (struct varobj *var, int only_children_p)
{
int delcount = 0;
- delete_variable_1 (resultp, &delcount, var,
- only_children_p, 1 /* remove_from_parent_p */ );
+ delete_variable_1 (&delcount, var, only_children_p,
+ 1 /* remove_from_parent_p */ );
return delcount;
}
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 (struct cpstack **resultp, int *delcountp,
- struct varobj *var, int only_children_p,
+delete_variable_1 (int *delcountp, struct varobj *var, int only_children_p,
int remove_from_parent_p)
{
int i;
continue;
if (!remove_from_parent_p)
child->parent = NULL;
- delete_variable_1 (resultp, delcountp, child, 0, only_children_p);
+ delete_variable_1 (delcountp, child, 0, only_children_p);
}
VEC_free (varobj_p, var->children);
yet been installed, don't report it, it belongs to the caller... */
if (var->obj_name != NULL)
{
- cppush (resultp, xstrdup (var->obj_name));
*delcountp = *delcountp + 1;
}
error (_("Duplicate variable object name"));
/* Add varobj to hash table. */
- newvl = xmalloc (sizeof (struct vlist));
+ newvl = XNEW (struct vlist);
newvl->next = *(varobj_table + index);
newvl->var = var;
*(varobj_table + index) = newvl;
}
-/* Create and install a child of the parent of the given name. */
+/* Create and install a child of the parent of the given name.
+
+ The created VAROBJ takes ownership of the allocated NAME. */
+
static struct varobj *
create_child (struct varobj *parent, int index, char *name)
{
{
struct varobj *var;
- var = (struct varobj *) xmalloc (sizeof (struct varobj));
+ var = XNEW (struct varobj);
var->name = NULL;
var->path_expr = NULL;
var->obj_name = NULL;
var->num_children = -1;
var->parent = NULL;
var->children = NULL;
- var->format = 0;
+ var->format = FORMAT_NATURAL;
var->root = NULL;
var->updated = 0;
var->print_value = NULL;
var->frozen = 0;
var->not_fetched = 0;
- var->dynamic
- = (struct varobj_dynamic *) xmalloc (sizeof (struct varobj_dynamic));
+ var->dynamic = XNEW (struct varobj_dynamic);
var->dynamic->children_requested = 0;
var->from = -1;
var->to = -1;
{
struct varobj *var = new_variable ();
- var->root = (struct varobj_root *) xmalloc (sizeof (struct varobj_root));
+ var->root = XNEW (struct varobj_root);
var->root->lang_ops = NULL;
var->root->exp = NULL;
var->root->valid_block = NULL;
static void
do_free_variable_cleanup (void *var)
{
- free_variable (var);
+ free_variable ((struct varobj *) var);
}
static struct cleanup *
For example, top-level references are always stripped. */
struct type *
-varobj_get_value_type (struct varobj *var)
+varobj_get_value_type (const struct varobj *var)
{
struct type *type;
return FORMAT_NATURAL;
}
-/* FIXME: The following should be generic for any pointer. */
-static void
-cppush (struct cpstack **pstack, char *name)
-{
- struct cpstack *s;
-
- s = (struct cpstack *) xmalloc (sizeof (struct cpstack));
- s->name = name;
- s->next = *pstack;
- *pstack = s;
-}
-
-/* FIXME: The following should be generic for any pointer. */
-static char *
-cppop (struct cpstack **pstack)
-{
- struct cpstack *s;
- char *v;
-
- if ((*pstack)->name == NULL && (*pstack)->next == NULL)
- return NULL;
-
- s = *pstack;
- v = s->name;
- *pstack = (*pstack)->next;
- xfree (s);
-
- return v;
-}
-\f
/*
* Language-dependencies
*/
is the number of children that the user will see in the variable
display. */
static int
-number_of_children (struct varobj *var)
+number_of_children (const struct varobj *var)
{
return (*var->root->lang_ops->number_of_children) (var);
}
/* What is the expression for the root varobj VAR? Returns a malloc'd
string. */
static char *
-name_of_variable (struct varobj *var)
+name_of_variable (const struct varobj *var)
{
return (*var->root->lang_ops->name_of_variable) (var);
}
to it and return 1. Otherwise, return 0. */
static int
-check_scope (struct varobj *var)
+check_scope (const struct varobj *var)
{
struct frame_info *fi;
int scope;
}
else
{
- ptid_t ptid = thread_id_to_pid (var->root->thread_id);
- if (in_thread_list (ptid))
+ ptid_t ptid = global_thread_id_to_ptid (var->root->thread_id);
+
+ if (!ptid_equal (minus_one_ptid, ptid))
{
switch_to_thread (ptid);
within_scope = check_scope (var);
if (within_scope)
{
- volatile struct gdb_exception except;
/* We need to catch errors here, because if evaluate
expression fails we want to just return NULL. */
- TRY_CATCH (except, RETURN_MASK_ERROR)
+ TRY
{
new_val = evaluate_expression (var->root->exp);
}
+ CATCH (except, RETURN_MASK_ERROR)
+ {
+ }
+ END_CATCH
}
do_cleanups (back_to);
var->root->exp = tmp_var->root->exp;
tmp_var->root->exp = tmp_exp;
- varobj_delete (tmp_var, NULL, 0);
+ varobj_delete (tmp_var, 0);
*type_changed = 0;
}
else
tmp_var->obj_name = xstrdup (var->obj_name);
tmp_var->from = var->from;
tmp_var->to = var->to;
- varobj_delete (var, NULL, 0);
+ varobj_delete (var, 0);
install_variable (tmp_var);
*var_handle = tmp_var;
/* The type has mutated, so the children are no longer valid.
Just delete them, and tell our caller that the type has
changed. */
- varobj_delete (var, NULL, 1 /* only_children */);
+ varobj_delete (var, 1 /* only_children */);
var->num_children = -1;
var->to = -1;
var->from = -1;
/* What is the ``struct value *'' for the INDEX'th child of PARENT? */
static struct value *
-value_of_child (struct varobj *parent, int index)
+value_of_child (const struct varobj *parent, int index)
{
struct value *value;
char *
varobj_value_get_print_value (struct value *value,
enum varobj_display_formats format,
- struct varobj *var)
+ const struct varobj *var)
{
struct ui_file *stb;
struct cleanup *old_chain;
struct type *type = NULL;
long len = 0;
char *encoding = NULL;
- struct gdbarch *gdbarch = NULL;
/* Initialize it just to avoid a GCC false warning. */
CORE_ADDR str_addr = 0;
int string_print = 0;
stb = mem_fileopen ();
old_chain = make_cleanup_ui_file_delete (stb);
- gdbarch = get_type_arch (value_type (value));
#if HAVE_PYTHON
if (gdb_python_initialized)
{
if (s)
{
+ struct gdbarch *gdbarch;
char *hint;
hint = gdbpy_get_display_hint (value_formatter);
}
len = strlen (s);
- thevalue = xmemdup (s, len + 1, len + 1);
+ thevalue = (char *) xmemdup (s, len + 1, len + 1);
+ gdbarch = get_type_arch (value_type (value));
type = builtin_type (gdbarch)->builtin_char;
xfree (s);
}
int
-varobj_editable_p (struct varobj *var)
+varobj_editable_p (const struct varobj *var)
{
struct type *type;
/* Call VAR's value_is_changeable_p language-specific callback. */
int
-varobj_value_is_changeable_p (struct varobj *var)
+varobj_value_is_changeable_p (const struct varobj *var)
{
return var->root->lang_ops->value_is_changeable_p (var);
}
selected frame, and not bound to thread/frame. Such variable objects
are created using '@' as frame specifier to -var-create. */
int
-varobj_floating_p (struct varobj *var)
+varobj_floating_p (const struct varobj *var)
{
return var->root->floating;
}
languages. */
int
-varobj_default_value_is_changeable_p (struct varobj *var)
+varobj_default_value_is_changeable_p (const struct varobj *var)
{
int r;
struct type *type;
if (tmp_var != NULL)
{
tmp_var->obj_name = xstrdup (var->obj_name);
- varobj_delete (var, NULL, 0);
+ varobj_delete (var, 0);
install_variable (tmp_var);
}
else
void
_initialize_varobj (void)
{
- int sizeof_table = sizeof (struct vlist *) * VAROBJ_TABLE_SIZE;
-
- varobj_table = xmalloc (sizeof_table);
- memset (varobj_table, 0, sizeof_table);
+ varobj_table = XCNEWVEC (struct vlist *, VAROBJ_TABLE_SIZE);
add_setshow_zuinteger_cmd ("varobj", class_maintenance,
&varobjdebug,
projects / deliverable / binutils-gdb.git / blobdiff