/* Implementation of the GDB variable objects API.
- Copyright (C) 1999-2012 Free Software Foundation, Inc.
+ Copyright (C) 1999-2013 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
/* Non-zero if we want to see trace of varobj level stuff. */
-int varobjdebug = 0;
+unsigned int varobjdebug = 0;
static void
show_varobjdebug (struct ui_file *file, int from_tty,
struct cmd_list_element *c, const char *value)
struct expression *exp;
/* Block for which this expression is valid. */
- struct block *valid_block;
+ const struct block *valid_block;
/* The frame for this expression. This field is set iff valid_block is
not NULL. */
struct frame_info *fi;
struct frame_id old_id = null_frame_id;
struct block *block;
- char *p;
+ const char *p;
enum varobj_languages lang;
struct value *value = NULL;
volatile struct gdb_exception except;
}
/* Don't allow variables to be created for types. */
- if (var->root->exp->elts[0].opcode == OP_TYPE)
+ if (var->root->exp->elts[0].opcode == OP_TYPE
+ || var->root->exp->elts[0].opcode == OP_TYPEOF
+ || var->root->exp->elts[0].opcode == OP_DECLTYPE)
{
do_cleanups (old_chain);
fprintf_unfiltered (gdb_stderr, "Attempt to use a type name"
char *result = NULL;
#if HAVE_PYTHON
- struct cleanup *back_to = varobj_ensure_python_env (var);
+ struct cleanup *back_to;
+
+ if (!gdb_python_initialized)
+ return NULL;
+
+ back_to = varobj_ensure_python_env (var);
if (var->pretty_printer)
result = gdbpy_get_display_hint (var->pretty_printer);
PyObject *printer = var->pretty_printer;
int result;
+ if (!gdb_python_initialized)
+ return 0;
+
back_to = varobj_ensure_python_env (var);
result = PyObject_HasAttr (printer, gdbpy_children_cst);
do_cleanups (back_to);
int i;
PyObject *printer = var->pretty_printer;
+ if (!gdb_python_initialized)
+ return 0;
+
back_to = varobj_ensure_python_env (var);
*cchanged = 0;
make_cleanup_py_decref (children);
- if (!PyIter_Check (children))
- error (_("Returned value is not iterable"));
-
Py_XDECREF (var->child_iter);
var->child_iter = PyObject_GetIter (children);
if (!var->child_iter)
return 1;
#else
- gdb_assert (0 && "should never be called if Python is not enabled");
+ gdb_assert_not_reached ("should never be called if Python is not enabled");
#endif
}
struct expression *exp;
struct value *value = NULL; /* Initialize to keep gcc happy. */
int saved_input_radix = input_radix;
- char *s = expression;
+ const char *s = expression;
volatile struct gdb_exception except;
gdb_assert (varobj_editable_p (var));
#if HAVE_PYTHON
/* If the constructor is None, then we want the raw value. If VAR
does not have a value, just skip this. */
+ if (!gdb_python_initialized)
+ return;
+
if (var->constructor != Py_None && var->value)
{
struct cleanup *cleanup;
PyObject *mainmod, *globals, *constructor;
struct cleanup *back_to;
+ if (!gdb_python_initialized)
+ return;
+
back_to = varobj_ensure_python_env (var);
mainmod = PyImport_AddModule ("__main__");
VEC(varobj_update_result) *
varobj_update (struct varobj **varp, int explicit)
{
- int changed = 0;
int type_changed = 0;
int i;
struct value *new;
{
struct ui_file *stb;
struct cleanup *old_chain;
- gdb_byte *thevalue = NULL;
+ char *thevalue = NULL;
struct value_print_options opts;
struct type *type = NULL;
long len = 0;
gdbarch = get_type_arch (value_type (value));
#if HAVE_PYTHON
- {
- PyObject *value_formatter = var->pretty_printer;
+ if (gdb_python_initialized)
+ {
+ PyObject *value_formatter = var->pretty_printer;
- varobj_ensure_python_env (var);
+ varobj_ensure_python_env (var);
- if (value_formatter)
- {
- /* First check to see if we have any children at all. If so,
- we simply return {...}. */
- if (dynamic_varobj_has_child_method (var))
- {
- do_cleanups (old_chain);
- return xstrdup ("{...}");
- }
+ if (value_formatter)
+ {
+ /* First check to see if we have any children at all. If so,
+ we simply return {...}. */
+ if (dynamic_varobj_has_child_method (var))
+ {
+ do_cleanups (old_chain);
+ return xstrdup ("{...}");
+ }
- if (PyObject_HasAttr (value_formatter, gdbpy_to_string_cst))
- {
- struct value *replacement;
- PyObject *output = NULL;
+ if (PyObject_HasAttr (value_formatter, gdbpy_to_string_cst))
+ {
+ struct value *replacement;
+ PyObject *output = NULL;
- output = apply_varobj_pretty_printer (value_formatter,
- &replacement,
- stb);
+ output = apply_varobj_pretty_printer (value_formatter,
+ &replacement,
+ stb);
- /* If we have string like output ... */
- if (output)
- {
- make_cleanup_py_decref (output);
-
- /* If this is a lazy string, extract it. For lazy
- strings we always print as a string, so set
- string_print. */
- if (gdbpy_is_lazy_string (output))
- {
- gdbpy_extract_lazy_string (output, &str_addr, &type,
- &len, &encoding);
- make_cleanup (free_current_contents, &encoding);
- string_print = 1;
- }
- else
- {
- /* If it is a regular (non-lazy) string, extract
- it and copy the contents into THEVALUE. If the
- hint says to print it as a string, set
- string_print. Otherwise just return the extracted
- string as a value. */
-
- PyObject *py_str
- = python_string_to_target_python_string (output);
-
- if (py_str)
- {
- char *s = PyString_AsString (py_str);
- char *hint;
-
- hint = gdbpy_get_display_hint (value_formatter);
- if (hint)
- {
- if (!strcmp (hint, "string"))
- string_print = 1;
- xfree (hint);
- }
-
- len = PyString_Size (py_str);
- thevalue = xmemdup (s, len + 1, len + 1);
- type = builtin_type (gdbarch)->builtin_char;
- Py_DECREF (py_str);
-
- if (!string_print)
- {
- do_cleanups (old_chain);
- return thevalue;
- }
-
- make_cleanup (xfree, thevalue);
- }
- else
- gdbpy_print_stack ();
- }
- }
- /* If the printer returned a replacement value, set VALUE
- to REPLACEMENT. If there is not a replacement value,
- just use the value passed to this function. */
- if (replacement)
- value = replacement;
- }
- }
- }
+ /* If we have string like output ... */
+ if (output)
+ {
+ make_cleanup_py_decref (output);
+
+ /* If this is a lazy string, extract it. For lazy
+ strings we always print as a string, so set
+ string_print. */
+ if (gdbpy_is_lazy_string (output))
+ {
+ gdbpy_extract_lazy_string (output, &str_addr, &type,
+ &len, &encoding);
+ make_cleanup (free_current_contents, &encoding);
+ string_print = 1;
+ }
+ else
+ {
+ /* If it is a regular (non-lazy) string, extract
+ it and copy the contents into THEVALUE. If the
+ hint says to print it as a string, set
+ string_print. Otherwise just return the extracted
+ string as a value. */
+
+ char *s = python_string_to_target_string (output);
+
+ if (s)
+ {
+ char *hint;
+
+ hint = gdbpy_get_display_hint (value_formatter);
+ if (hint)
+ {
+ if (!strcmp (hint, "string"))
+ string_print = 1;
+ xfree (hint);
+ }
+
+ len = strlen (s);
+ thevalue = xmemdup (s, len + 1, len + 1);
+ type = builtin_type (gdbarch)->builtin_char;
+ xfree (s);
+
+ if (!string_print)
+ {
+ do_cleanups (old_chain);
+ return thevalue;
+ }
+
+ make_cleanup (xfree, thevalue);
+ }
+ else
+ gdbpy_print_stack ();
+ }
+ }
+ /* If the printer returned a replacement value, set VALUE
+ to REPLACEMENT. If there is not a replacement value,
+ just use the value passed to this function. */
+ if (replacement)
+ value = replacement;
+ }
+ }
+ }
#endif
get_formatted_print_options (&opts, format_code[(int) format]);
/* If the THEVALUE has contents, it is a regular string. */
if (thevalue)
- LA_PRINT_STRING (stb, type, thevalue, len, encoding, 0, &opts);
+ LA_PRINT_STRING (stb, type, (gdb_byte *) thevalue, len, encoding, 0, &opts);
else if (string_print)
/* Otherwise, if string_print is set, and it is not a regular
string, it is a lazy string. */
{
new_val = evaluate_expression (var->root->exp);
}
-
- return new_val;
}
do_cleanups (back_to);
- return NULL;
+ return new_val;
}
static struct value *
varobj_table = xmalloc (sizeof_table);
memset (varobj_table, 0, sizeof_table);
- add_setshow_zinteger_cmd ("debugvarobj", class_maintenance,
- &varobjdebug,
- _("Set varobj debugging."),
- _("Show varobj debugging."),
- _("When non-zero, varobj debugging is enabled."),
- NULL, show_varobjdebug,
- &setlist, &showlist);
+ add_setshow_zuinteger_cmd ("debugvarobj", class_maintenance,
+ &varobjdebug,
+ _("Set varobj debugging."),
+ _("Show varobj debugging."),
+ _("When non-zero, varobj debugging is enabled."),
+ NULL, show_varobjdebug,
+ &setlist, &showlist);
}
/* Invalidate varobj VAR if it is tied to locals and re-create it if it is
- defined on globals. It is a helper for varobj_invalidate. */
+ defined on globals. It is a helper for varobj_invalidate.
+
+ This function is called after changing the symbol file, in this case the
+ pointers to "struct type" stored by the varobj are no longer valid. All
+ varobj must be either re-evaluated, or marked as invalid here. */
static void
varobj_invalidate_iter (struct varobj *var, void *unused)
{
- /* Floating varobjs are reparsed on each stop, so we don't care if the
- presently parsed expression refers to something that's gone. */
- if (var->root->floating)
- return;
-
- /* global var must be re-evaluated. */
- if (var->root->valid_block == NULL)
+ /* global and floating var must be re-evaluated. */
+ if (var->root->floating || var->root->valid_block == NULL)
{
struct varobj *tmp_var;