/* Implementation of the GDB variable objects API.
- Copyright 1999, 2000 Free Software Foundation, Inc.
+ Copyright 1999, 2000, 2001 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
#include "value.h"
#include "expression.h"
#include "frame.h"
-#include "valprint.h"
#include "language.h"
#include "wrapper.h"
#include "gdbcmd.h"
/* Pointer to the varobj hash table (built at run time) */
static struct vlist **varobj_table;
-#if defined(FREEIF)
-#undef FREEIF
-#endif
-#define FREEIF(x) if (x != NULL) free((char *) (x))
-
/* Is the variable X one of our "fake" children? */
#define CPLUS_FAKE_CHILD(x) \
((x) != NULL && (x)->type == NULL && (x)->value == NULL)
enum varobj_type type)
{
struct varobj *var;
- struct frame_info *fi, *old_fi;
+ struct frame_info *fi;
+ struct frame_info *old_fi = NULL;
struct block *block;
struct cleanup *old_chain;
if (!gdb_evaluate_expression (exp, &value))
{
/* We cannot proceed without a valid expression. */
- FREEIF (exp);
+ xfree (exp);
return 0;
}
int error2;
struct varobj *v;
struct varobj **cv;
- struct varobj **templist;
+ struct varobj **templist = NULL;
value_ptr new;
struct vstack *stack = NULL;
struct vstack *result = NULL;
vc->child->parent = NULL;
delete_variable_1 (resultp, delcountp, vc->child, 0, only_children_p);
next = vc->next;
- free (vc);
+ xfree (vc);
}
/* if we were called to delete only the children we are done here */
yet been installed, don't report it, it belongs to the caller... */
if (var->obj_name != NULL)
{
- cppush (resultp, strdup (var->obj_name));
+ cppush (resultp, xstrdup (var->obj_name));
*delcountp = *delcountp + 1;
}
else
prev->next = cv->next;
- free (cv);
+ xfree (cv);
/* If root, remove varobj from root list */
if (var->root->rootvar == var)
if (var->root->rootvar == var)
{
free_current_contents ((char **) &var->root->exp);
- FREEIF (var->root);
+ xfree (var->root);
}
- FREEIF (var->name);
- FREEIF (var->obj_name);
- FREEIF (var);
+ xfree (var->name);
+ xfree (var->obj_name);
+ xfree (var);
}
static void
s = *pstack;
v = s->var;
*pstack = (*pstack)->next;
- free (s);
+ xfree (s);
return v;
}
s = *pstack;
v = s->name;
*pstack = (*pstack)->next;
- free (s);
+ xfree (s);
return v;
}
{
tmp_var->obj_name =
savestring (var->obj_name, strlen (var->obj_name));
- uninstall_variable (var);
+ varobj_delete (var, NULL, 0);
}
else
{
case TYPE_CODE_PTR:
/* This is where things get compilcated. All pointers have one child.
Except, of course, for struct and union ptr, which we automagically
- dereference for the user and function ptrs, which have no children. */
+ dereference for the user and function ptrs, which have no children.
+ We also don't dereference void* as we don't know what to show.
+ We can show char* so we allow it to be dereferenced. If you decide
+ to test for it, please mind that a little magic is necessary to
+ properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
+ TYPE_NAME == "char" */
+
switch (TYPE_CODE (target))
{
case TYPE_CODE_STRUCT:
break;
case TYPE_CODE_FUNC:
+ case TYPE_CODE_VOID:
children = 0;
break;
default:
- /* Don't dereference char* or void*. */
- if (TYPE_NAME (target) != NULL
- && (STREQ (TYPE_NAME (target), "char")
- || STREQ (TYPE_NAME (target), "void")))
- children = 0;
- else
- children = 1;
+ children = 1;
}
break;