/* Implementation of the GDB variable objects API.
- Copyright 1999, 2000, 2001 Free Software Foundation, Inc.
+
+ Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005
+ 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
Boston, MA 02111-1307, USA. */
#include "defs.h"
+#include "exceptions.h"
#include "value.h"
#include "expression.h"
#include "frame.h"
#include "language.h"
#include "wrapper.h"
#include "gdbcmd.h"
+
+#include "gdb_assert.h"
#include "gdb_string.h"
-#include <math.h>
#include "varobj.h"
/* Non-zero if we want to see trace of varobj level stuff. */
int varobjdebug = 0;
+static void
+show_varobjdebug (struct ui_file *file, int from_tty,
+ struct cmd_list_element *c, const char *value)
+{
+ fprintf_filtered (file, _("Varobj debugging is %s.\n"), value);
+}
/* String representations of gdb's format codes */
char *varobj_format_string[] =
frame = get_prev_frame (frame);
if (frame == NULL)
return NULL;
- if (get_frame_base (frame) == frame_addr)
+ if (get_frame_base_address (frame) == frame_addr)
return frame;
}
}
/* Allow creator to specify context of variable */
if ((type == USE_CURRENT_FRAME) || (type == USE_SELECTED_FRAME))
- fi = selected_frame;
+ fi = deprecated_selected_frame;
else
/* FIXME: cagney/2002-11-23: This code should be doing a
lookup using the frame ID and not just the frame's
if (var->root->exp->elts[0].opcode == OP_TYPE)
{
do_cleanups (old_chain);
- fprintf_unfiltered (gdb_stderr,
- "Attempt to use a type name as an expression.");
+ fprintf_unfiltered (gdb_stderr, "Attempt to use a type name"
+ " as an expression.\n");
return NULL;
}
Since select_frame is so benign, just call it for all cases. */
if (fi != NULL)
{
- get_frame_id (fi, &var->root->frame);
- old_fi = selected_frame;
+ var->root->frame = get_frame_id (fi);
+ old_fi = deprecated_selected_frame;
select_frame (fi);
}
{
/* no error */
release_value (var->value);
- if (VALUE_LAZY (var->value))
+ if (value_lazy (var->value))
gdb_value_fetch_lazy (var->value);
}
else
var->value = evaluate_type (var->root->exp);
- var->type = VALUE_TYPE (var->value);
+ var->type = value_type (var->value);
/* Set language info */
lang = variable_language (var);
/* generate a name for this object */
id++;
- xasprintf (&obj_name, "var%d", id);
+ obj_name = xstrprintf ("var%d", id);
return obj_name;
}
cv = cv->next;
if (cv == NULL)
- error ("Variable object not found");
+ error (_("Variable object not found"));
return cv->var;
}
}
if (mycount || (*cp != NULL))
- warning ("varobj_delete: assertion failed - mycount(=%d) <> 0",
+ warning (_("varobj_delete: assertion failed - mycount(=%d) <> 0"),
mycount);
}
/* To print the type, we simply create a zero ``struct value *'' and
cast it to our type. We then typeprint this variable. */
val = value_zero (var->type, not_lval);
- type_print (VALUE_TYPE (val), "", stb, -1);
+ type_print (value_type (val), "", stb, -1);
thetype = ui_file_xstrdup (stb, &length);
do_cleanups (old_chain);
return thetype;
}
+/* Obtain the type of an object variable. */
+
+struct type *
+varobj_get_gdb_type (struct varobj *var)
+{
+ return var->type;
+}
+
enum varobj_languages
varobj_get_language (struct varobj *var)
{
varobj_set_value (struct varobj *var, char *expression)
{
struct value *val;
- int error;
int offset = 0;
+ int error = 0;
/* The argument "expression" contains the variable's new value.
We need to first construct a legal expression for this -- ugh! */
varobj_update (struct varobj **varp, struct varobj ***changelist)
{
int changed = 0;
+ int error = 0;
int type_changed;
int i;
int vleft;
- int error2;
struct varobj *v;
struct varobj **cv;
struct varobj **templist = NULL;
/* Save the selected stack frame, since we will need to change it
in order to evaluate expressions. */
- get_frame_id (selected_frame, &old_fid);
+ 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
There a couple of exceptions here, though.
We don't want some types to be reported as "changed". */
else if (type_changeable (*varp) &&
- ((*varp)->updated || !my_value_equal ((*varp)->value, new, &error2)))
+ ((*varp)->updated || !my_value_equal ((*varp)->value, new, &error)))
{
vpush (&result, *varp);
(*varp)->updated = 0;
changed++;
- /* error2 replaces var->error since this new value
- WILL replace the old one. */
- (*varp)->error = error2;
+ /* Its value is going to be updated to NEW. */
+ (*varp)->error = error;
}
/* We must always keep around the new value for this root
/* Update this variable */
new = value_of_child (v->parent, v->index);
if (type_changeable (v) &&
- (v->updated || !my_value_equal (v->value, new, &error2)))
+ (v->updated || !my_value_equal (v->value, new, &error)))
{
/* Note that it's changed */
vpush (&result, v);
v->updated = 0;
changed++;
}
- /* error2 replaces v->error since this new value
- WILL replace the old one. */
- v->error = error2;
+ /* Its value is going to be updated to NEW. */
+ v->error = error;
/* We must always keep new values, since children depend on it. */
if (v->value != NULL)
*cv = vpop (&result);
}
if (vleft)
- warning ("varobj_update: assertion failed - vleft <> 0");
+ warning (_("varobj_update: assertion failed - vleft <> 0"));
if (changed > 1)
{
cv = cv->next;
if (cv != NULL)
- error ("Duplicate variable object name");
+ error (_("Duplicate variable object name"));
/* Add varobj to hash table */
newvl = xmalloc (sizeof (struct vlist));
child->error = 1;
child->parent = parent;
child->root = parent->root;
- xasprintf (&childs_name, "%s.%s", parent->obj_name, name);
+ childs_name = xstrprintf ("%s.%s", parent->obj_name, name);
child->obj_name = childs_name;
install_variable (child);
var->root->lang = NULL;
var->root->exp = NULL;
var->root->valid_block = NULL;
- var->root->frame.base = 0;
- var->root->frame.pc = 0;
+ var->root->frame = null_frame_id;
var->root->use_selected_frame = 0;
var->root->rootvar = NULL;
return make_cleanup (do_free_variable_cleanup, var);
}
-/* This returns the type of the variable. This skips past typedefs
- and returns the real type of the variable. It also dereferences
- pointers and references.
+/* This returns the type of the variable. It also skips past typedefs
+ to return the real type of the variable.
NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file
except within get_target_type and get_type. */
struct type *type;
type = var->type;
- while (type != NULL && TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
- type = TYPE_TARGET_TYPE (type);
+ if (type != NULL)
+ type = check_typedef (type);
return type;
}
if (type != NULL)
{
type = TYPE_TARGET_TYPE (type);
- while (type != NULL && TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
- type = TYPE_TARGET_TYPE (type);
+ if (type != NULL)
+ type = check_typedef (type);
}
return type;
return FORMAT_NATURAL;
}
-/* This function is similar to gdb's value_equal, except that this
- one is "safe" -- it NEVER longjmps. It determines if the VAR's
- value is the same as VAL2. */
+/* This function is similar to GDB's value_contents_equal, except that
+ this one is "safe"; it never longjmps. It determines if the VAL1's
+ value is the same as VAL2. If for some reason the value of VAR2
+ can't be established, *ERROR2 is set to non-zero. */
+
static int
-my_value_equal (struct value *val1, struct value *val2, int *error2)
+my_value_equal (struct value *val1, struct value *volatile val2, int *error2)
{
- int r, err1, err2;
+ volatile struct gdb_exception except;
- *error2 = 0;
- /* Special case: NULL values. If both are null, say
- they're equal. */
+ /* As a special case, if both are null, we say they're equal. */
if (val1 == NULL && val2 == NULL)
return 1;
else if (val1 == NULL || val2 == NULL)
return 0;
- /* This is bogus, but unfortunately necessary. We must know
- exactly what caused an error -- reading val1 or val2 -- so
- that we can really determine if we think that something has changed. */
- err1 = 0;
- err2 = 0;
- /* We do need to catch errors here because the whole purpose
- is to test if value_equal() has errored */
- if (!gdb_value_equal (val1, val1, &r))
- err1 = 1;
-
- if (!gdb_value_equal (val2, val2, &r))
- *error2 = err2 = 1;
+ /* The contents of VAL1 are supposed to be known. */
+ gdb_assert (!value_lazy (val1));
- if (err1 != err2)
- return 0;
-
- if (!gdb_value_equal (val1, val2, &r))
+ /* Make sure we also know the contents of VAL2. */
+ val2 = coerce_array (val2);
+ TRY_CATCH (except, RETURN_MASK_ERROR)
{
- /* An error occurred, this could have happened if
- either val1 or val2 errored. ERR1 and ERR2 tell
- us which of these it is. If both errored, then
- we assume nothing has changed. If one of them is
- valid, though, then something has changed. */
- if (err1 == err2)
- {
- /* both the old and new values caused errors, so
- we say the value did not change */
- /* This is indeterminate, though. Perhaps we should
- be safe and say, yes, it changed anyway?? */
- return 1;
- }
- else
- {
- return 0;
- }
+ if (value_lazy (val2))
+ value_fetch_lazy (val2);
+ }
+ if (except.reason < 0)
+ {
+ *error2 = 1;
+ return 0;
}
+ gdb_assert (!value_lazy (val2));
- return r;
+ return value_contents_equal (val1, val2);
}
/* FIXME: The following should be generic for any pointer */
value = (*parent->root->lang->value_of_child) (parent, index);
/* If we're being lazy, fetch the real value of the variable. */
- if (value != NULL && VALUE_LAZY (value))
+ if (value != NULL && value_lazy (value))
{
/* If we fail to fetch the value of the child, return
NULL so that callers notice that we're leaving an
/* If the child had no evaluation errors, var->value
will be non-NULL and contain a valid type. */
if (var->value != NULL)
- return VALUE_TYPE (var->value);
+ return value_type (var->value);
/* Otherwise, we must compute the type. */
return (*var->root->lang->type_of_child) (var->parent, var->index);
switch (TYPE_CODE (type))
{
case TYPE_CODE_ARRAY:
- xasprintf (&name, "%d", index);
+ name = xstrprintf ("%d", index);
break;
case TYPE_CODE_STRUCT:
break;
default:
- xasprintf (&name, "*%s", parent->name);
+ name = xstrprintf ("*%s", parent->name);
break;
}
break;
go on */
if (gdb_evaluate_expression (var->root->exp, &new_val))
{
- if (VALUE_LAZY (new_val))
+ if (value_lazy (new_val))
{
/* We need to catch errors because if
value_fetch_lazy fails we still want to continue
(after making val->error = 1) */
- /* FIXME: Shouldn't be using VALUE_CONTENTS? The
- comment on value_fetch_lazy() says it is only
- called from the macro... */
+ /* FIXME: Shouldn't be using value_contents()? The
+ comment on value_fetch_lazy() says it is only called
+ from the macro... */
if (!gdb_value_fetch_lazy (new_val))
var->error = 1;
else
default:
/* This should not happen as only the above types have children */
- warning ("Child of parent whose type does not allow children");
+ warning (_("Child of parent whose type does not allow children"));
/* FIXME: Can we still go on? */
type = NULL;
break;
case TYPE_CODE_ARRAY:
{
char *number;
- xasprintf (&number, "[%d]", var->num_children);
+ number = xstrprintf ("[%d]", var->num_children);
return (number);
}
/* break; */
struct cleanup *old_chain = make_cleanup_ui_file_delete (stb);
char *thevalue;
- if (VALUE_LAZY (var->value))
+ if (value_lazy (var->value))
gdb_value_fetch_lazy (var->value);
- val_print (VALUE_TYPE (var->value),
- VALUE_CONTENTS_RAW (var->value), 0,
- VALUE_ADDRESS (var->value), stb,
- format_code[(int) var->format], 1, 0, 0);
+ common_val_print (var->value, stb,
+ format_code[(int) var->format], 1, 0, 0);
thevalue = ui_file_xstrdup (stb, &dummy);
do_cleanups (old_chain);
return thevalue;
{
struct value *temp = NULL;
- if (TYPE_CODE (VALUE_TYPE (parent->value)) == TYPE_CODE_PTR
- || TYPE_CODE (VALUE_TYPE (parent->value)) == TYPE_CODE_REF)
+ if (TYPE_CODE (value_type (parent->value)) == TYPE_CODE_PTR
+ || TYPE_CODE (value_type (parent->value)) == TYPE_CODE_REF)
{
if (!gdb_value_ind (parent->value, &temp))
return NULL;
varobj_table = xmalloc (sizeof_table);
memset (varobj_table, 0, sizeof_table);
- add_show_from_set (add_set_cmd ("debugvarobj", class_maintenance, var_zinteger, (char *) &varobjdebug, "Set varobj debugging.\n\
-When non-zero, varobj debugging is enabled.", &setlist),
- &showlist);
+ 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);
}