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;
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;
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__");
{
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. */
-
- 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;
- }
- }
- }
+ /* 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 *