/* varobj support for C and C++.
- Copyright (C) 1999-2015 Free Software Foundation, Inc.
+ Copyright (C) 1999-2017 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
thing to do is to compare the child's name with ANONYMOUS_*_NAME. */
int
-varobj_is_anonymous_child (struct varobj *child)
+varobj_is_anonymous_child (const struct varobj *child)
{
- return (strcmp (child->name, ANONYMOUS_STRUCT_NAME) == 0
- || strcmp (child->name, ANONYMOUS_UNION_NAME) == 0);
+ return (child->name == ANONYMOUS_STRUCT_NAME
+ || child->name == ANONYMOUS_UNION_NAME);
}
/* Given the value and the type of a variable object,
to us, is already supposed to be
reference-stripped. */
- gdb_assert (TYPE_CODE (*type) != TYPE_CODE_REF);
+ gdb_assert (!TYPE_IS_REFERENCE (*type));
/* Pointers to structures are treated just like
structures when accessing children. Don't
{
if (value && *value)
{
- volatile struct gdb_exception except;
- TRY_CATCH (except, RETURN_MASK_ERROR)
+ TRY
{
*value = value_ind (*value);
}
- if (except.reason < 0)
- *value = NULL;
+ CATCH (except, RETURN_MASK_ERROR)
+ {
+ *value = NULL;
+ }
+ END_CATCH
}
*type = target_type;
if (was_ptr)
a valid path expression? */
static int
-c_is_path_expr_parent (struct varobj *var)
+c_is_path_expr_parent (const struct varobj *var)
{
struct type *type;
&& TYPE_NAME (type) == NULL
&& TYPE_TAG_NAME (type) == NULL)
{
- struct varobj *parent = var->parent;
+ const struct varobj *parent = var->parent;
while (parent != NULL && CPLUS_FAKE_CHILD (parent))
parent = parent->parent;
/* C */
static int
-c_number_of_children (struct varobj *var)
+c_number_of_children (const struct varobj *var)
{
struct type *type = varobj_get_value_type (var);
int children = 0;
return children;
}
-static char *
-c_name_of_variable (struct varobj *parent)
+static std::string
+c_name_of_variable (const struct varobj *parent)
{
- return xstrdup (parent->name);
+ return parent->name;
}
/* Return the value of element TYPE_INDEX of a structure
value_struct_element_index (struct value *value, int type_index)
{
struct value *result = NULL;
- volatile struct gdb_exception e;
struct type *type = value_type (value);
type = check_typedef (type);
gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
|| TYPE_CODE (type) == TYPE_CODE_UNION);
- TRY_CATCH (e, RETURN_MASK_ERROR)
+ TRY
{
if (field_is_static (&TYPE_FIELD (type, type_index)))
result = value_static_field (type, type_index);
else
result = value_primitive_field (value, 0, type_index, type);
}
- if (e.reason < 0)
+ CATCH (e, RETURN_MASK_ERROR)
{
return NULL;
}
- else
- {
- return result;
- }
+ END_CATCH
+
+ return result;
}
/* Obtain the information about child INDEX of the variable
If any of CNAME, CVALUE, or CTYPE is not null, but the corresponding
information cannot be determined, set *CNAME, *CVALUE, or *CTYPE
- to NULL. */
+ to empty. */
static void
-c_describe_child (struct varobj *parent, int index,
- char **cname, struct value **cvalue, struct type **ctype,
- char **cfull_expression)
+c_describe_child (const struct varobj *parent, int index,
+ std::string *cname, struct value **cvalue,
+ struct type **ctype, std::string *cfull_expression)
{
struct value *value = parent->value;
struct type *type = varobj_get_value_type (parent);
- char *parent_expression = NULL;
+ std::string parent_expression;
int was_ptr;
- volatile struct gdb_exception except;
if (cname)
- *cname = NULL;
+ *cname = std::string ();
if (cvalue)
*cvalue = NULL;
if (ctype)
*ctype = NULL;
if (cfull_expression)
{
- *cfull_expression = NULL;
+ *cfull_expression = std::string ();
parent_expression
= varobj_get_path_expr (varobj_get_path_expr_parent (parent));
}
adjust_value_for_child_access (&value, &type, &was_ptr, 0);
-
+
switch (TYPE_CODE (type))
{
case TYPE_CODE_ARRAY:
if (cname)
- *cname
- = xstrdup (int_string (index
- + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)),
- 10, 1, 0, 0));
+ *cname = int_string (index
+ + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)),
+ 10, 1, 0, 0);
if (cvalue && value)
{
int real_index = index + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type));
- TRY_CATCH (except, RETURN_MASK_ERROR)
+ TRY
{
*cvalue = value_subscript (value, real_index);
}
+ CATCH (except, RETURN_MASK_ERROR)
+ {
+ }
+ END_CATCH
}
if (ctype)
if (cfull_expression)
*cfull_expression =
- xstrprintf ("(%s)[%s]", parent_expression,
- int_string (index
- + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)),
- 10, 1, 0, 0));
+ string_printf ("(%s)[%s]", parent_expression.c_str (),
+ int_string (index
+ + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)),
+ 10, 1, 0, 0));
break;
{
if (TYPE_CODE (TYPE_FIELD_TYPE (type, index))
== TYPE_CODE_STRUCT)
- *cname = xstrdup (ANONYMOUS_STRUCT_NAME);
+ *cname = ANONYMOUS_STRUCT_NAME;
else
- *cname = xstrdup (ANONYMOUS_UNION_NAME);
+ *cname = ANONYMOUS_UNION_NAME;
}
if (cfull_expression)
- *cfull_expression = xstrdup ("");
+ *cfull_expression = "";
}
else
{
if (cname)
- *cname = xstrdup (field_name);
+ *cname = field_name;
if (cfull_expression)
{
- char *join = was_ptr ? "->" : ".";
+ const char *join = was_ptr ? "->" : ".";
- *cfull_expression = xstrprintf ("(%s)%s%s", parent_expression,
- join, field_name);
+ *cfull_expression = string_printf ("(%s)%s%s",
+ parent_expression.c_str (),
+ join, field_name);
}
}
case TYPE_CODE_PTR:
if (cname)
- *cname = xstrprintf ("*%s", parent->name);
+ *cname = string_printf ("*%s", parent->name.c_str ());
if (cvalue && value)
{
- TRY_CATCH (except, RETURN_MASK_ERROR)
+ TRY
{
*cvalue = value_ind (value);
}
- if (except.reason < 0)
- *cvalue = NULL;
+ CATCH (except, RETURN_MASK_ERROR)
+ {
+ *cvalue = NULL;
+ }
+ END_CATCH
}
/* Don't use get_target_type because it calls
*ctype = TYPE_TARGET_TYPE (type);
if (cfull_expression)
- *cfull_expression = xstrprintf ("*(%s)", parent_expression);
-
+ *cfull_expression = string_printf ("*(%s)", parent_expression.c_str ());
break;
default:
/* This should not happen. */
if (cname)
- *cname = xstrdup ("???");
+ *cname = "???";
if (cfull_expression)
- *cfull_expression = xstrdup ("???");
+ *cfull_expression = "???";
/* Don't set value and type, we don't know then. */
}
}
-static char *
-c_name_of_child (struct varobj *parent, int index)
+static std::string
+c_name_of_child (const struct varobj *parent, int index)
{
- char *name;
+ std::string name;
c_describe_child (parent, index, &name, NULL, NULL, NULL);
return name;
}
-static char *
-c_path_expr_of_child (struct varobj *child)
+static std::string
+c_path_expr_of_child (const struct varobj *child)
{
+ std::string path_expr;
+
c_describe_child (child->parent, child->index, NULL, NULL, NULL,
- &child->path_expr);
- return child->path_expr;
+ &path_expr);
+ return path_expr;
}
static struct value *
-c_value_of_child (struct varobj *parent, int index)
+c_value_of_child (const struct varobj *parent, int index)
{
struct value *value = NULL;
}
static struct type *
-c_type_of_child (struct varobj *parent, int index)
+c_type_of_child (const struct varobj *parent, int index)
{
struct type *type = NULL;
to return the real type of the variable. */
static struct type *
-get_type (struct varobj *var)
+get_type (const struct varobj *var)
{
struct type *type;
return type;
}
-static char *
-c_value_of_variable (struct varobj *var, enum varobj_display_formats format)
+static std::string
+c_value_of_variable (const struct varobj *var,
+ enum varobj_display_formats format)
{
/* BOGUS: if val_print sees a struct/class, or a reference to one,
it will print out its children instead of "{...}". So we need to
struct type *type = get_type (var);
/* Strip top-level references. */
- while (TYPE_CODE (type) == TYPE_CODE_REF)
+ while (TYPE_IS_REFERENCE (type))
type = check_typedef (TYPE_TARGET_TYPE (type));
switch (TYPE_CODE (type))
{
case TYPE_CODE_STRUCT:
case TYPE_CODE_UNION:
- return xstrdup ("{...}");
+ return "{...}";
/* break; */
case TYPE_CODE_ARRAY:
- {
- char *number;
-
- number = xstrprintf ("[%d]", var->num_children);
- return (number);
- }
+ return string_printf ("[%d]", var->num_children);
/* break; */
default:
/* This can happen if we attempt to get the value of a struct
member when the parent is an invalid pointer. This is an
error condition, so we should tell the caller. */
- return NULL;
+ return std::string ();
}
else
{
/* Frozen variable and no value yet. We don't
implicitly fetch the value. MI response will
use empty string for the value, which is OK. */
- return NULL;
+ return std::string ();
gdb_assert (varobj_value_is_changeable_p (var));
gdb_assert (!value_lazy (var->value));
/* If the specified format is the current one,
we can reuse print_value. */
if (format == var->format)
- return xstrdup (var->print_value);
+ return var->print_value;
else
return varobj_value_get_print_value (var->value, format, var);
}
c_is_path_expr_parent /* is_path_expr_parent */
};
-/* A little convenience enum for dealing with C++/Java. */
+/* A little convenience enum for dealing with C++. */
enum vsections
{
v_public = 0, v_private, v_protected
/* C++ */
static int
-cplus_number_of_children (struct varobj *var)
+cplus_number_of_children (const struct varobj *var)
{
struct value *value = NULL;
struct type *type;
if (opts.objectprint)
{
value = var->value;
- lookup_actual_type = (TYPE_CODE (var->type) == TYPE_CODE_REF
+ lookup_actual_type = (TYPE_IS_REFERENCE (var->type)
|| TYPE_CODE (var->type) == TYPE_CODE_PTR);
}
adjust_value_for_child_access (&value, &type, NULL, lookup_actual_type);
/* It is necessary to access a real type (via RTTI). */
if (opts.objectprint)
{
- struct varobj *parent = var->parent;
+ const struct varobj *parent = var->parent;
value = parent->value;
- lookup_actual_type = (TYPE_CODE (parent->type) == TYPE_CODE_REF
+ lookup_actual_type = (TYPE_IS_REFERENCE (parent->type)
|| TYPE_CODE (parent->type) == TYPE_CODE_PTR);
}
adjust_value_for_child_access (&value, &type, NULL, lookup_actual_type);
cplus_class_num_children (type, kids);
- if (strcmp (var->name, "public") == 0)
+ if (var->name == "public")
children = kids[v_public];
- else if (strcmp (var->name, "private") == 0)
+ else if (var->name == "private")
children = kids[v_private];
else
children = kids[v_protected];
}
}
-static char *
-cplus_name_of_variable (struct varobj *parent)
+static std::string
+cplus_name_of_variable (const struct varobj *parent)
{
return c_name_of_variable (parent);
}
}
static void
-cplus_describe_child (struct varobj *parent, int index,
- char **cname, struct value **cvalue, struct type **ctype,
- char **cfull_expression)
+cplus_describe_child (const struct varobj *parent, int index,
+ std::string *cname, struct value **cvalue, struct type **ctype,
+ std::string *cfull_expression)
{
struct value *value;
struct type *type;
int was_ptr;
int lookup_actual_type = 0;
- char *parent_expression = NULL;
- struct varobj *var;
+ const char *parent_expression = NULL;
+ const struct varobj *var;
struct value_print_options opts;
if (cname)
- *cname = NULL;
+ *cname = std::string ();
if (cvalue)
*cvalue = NULL;
if (ctype)
*ctype = NULL;
if (cfull_expression)
- *cfull_expression = NULL;
+ *cfull_expression = std::string ();
get_user_print_options (&opts);
var = (CPLUS_FAKE_CHILD (parent)) ? parent->parent : parent;
if (opts.objectprint)
- lookup_actual_type = (TYPE_CODE (var->type) == TYPE_CODE_REF
+ lookup_actual_type = (TYPE_IS_REFERENCE (var->type)
|| TYPE_CODE (var->type) == TYPE_CODE_PTR);
value = var->value;
type = varobj_get_value_type (var);
if (TYPE_CODE (type) == TYPE_CODE_STRUCT
|| TYPE_CODE (type) == TYPE_CODE_UNION)
{
- char *join = was_ptr ? "->" : ".";
+ const char *join = was_ptr ? "->" : ".";
if (CPLUS_FAKE_CHILD (parent))
{
const char *field_name;
vptr_fieldno = get_vptr_fieldno (type, &basetype);
- if (strcmp (parent->name, "private") == 0)
+ if (parent->name == "private")
acc = private_field;
- else if (strcmp (parent->name, "protected") == 0)
+ else if (parent->name == "protected")
acc = protected_field;
while (index >= 0)
{
if (TYPE_CODE (TYPE_FIELD_TYPE (type, type_index))
== TYPE_CODE_STRUCT)
- *cname = xstrdup (ANONYMOUS_STRUCT_NAME);
+ *cname = ANONYMOUS_STRUCT_NAME;
else if (TYPE_CODE (TYPE_FIELD_TYPE (type, type_index))
== TYPE_CODE_UNION)
- *cname = xstrdup (ANONYMOUS_UNION_NAME);
+ *cname = ANONYMOUS_UNION_NAME;
}
if (cfull_expression)
- *cfull_expression = xstrdup ("");
+ *cfull_expression = std::string ();
}
else
{
if (cname)
- *cname = xstrdup (TYPE_FIELD_NAME (type, type_index));
+ *cname = TYPE_FIELD_NAME (type, type_index);
if (cfull_expression)
*cfull_expression
- = xstrprintf ("((%s)%s%s)", parent_expression, join,
- field_name);
+ = string_printf ("((%s)%s%s)", parent_expression, join,
+ field_name);
}
if (cvalue && value)
{
/* This is a baseclass. */
if (cname)
- *cname = xstrdup (TYPE_FIELD_NAME (type, index));
+ *cname = TYPE_FIELD_NAME (type, index);
if (cvalue && value)
*cvalue = value_cast (TYPE_FIELD_TYPE (type, index), value);
if (cfull_expression)
{
- char *ptr = was_ptr ? "*" : "";
+ const char *ptr = was_ptr ? "*" : "";
/* Cast the parent to the base' type. Note that in gdb,
expression like
as a constructor, if it exists. Therefore, we must
indicate that the name is a class name by using the
'class' keyword. See PR mi/11912 */
- *cfull_expression = xstrprintf ("(%s(class %s%s) %s)",
- ptr,
- TYPE_FIELD_NAME (type, index),
- ptr,
- parent_expression);
+ *cfull_expression = string_printf ("(%s(class %s%s) %s)",
+ ptr,
+ TYPE_FIELD_NAME (type, index),
+ ptr,
+ parent_expression);
}
}
else
gdb_assert (access);
if (cname)
- *cname = xstrdup (access);
+ *cname = access;
/* Value and type and full expression are null here. */
}
}
}
-static char *
-cplus_name_of_child (struct varobj *parent, int index)
+static std::string
+cplus_name_of_child (const struct varobj *parent, int index)
{
- char *name = NULL;
+ std::string name;
cplus_describe_child (parent, index, &name, NULL, NULL, NULL);
return name;
}
-static char *
-cplus_path_expr_of_child (struct varobj *child)
+static std::string
+cplus_path_expr_of_child (const struct varobj *child)
{
+ std::string path_expr;
+
cplus_describe_child (child->parent, child->index, NULL, NULL, NULL,
- &child->path_expr);
- return child->path_expr;
+ &path_expr);
+ return path_expr;
}
static struct value *
-cplus_value_of_child (struct varobj *parent, int index)
+cplus_value_of_child (const struct varobj *parent, int index)
{
struct value *value = NULL;
}
static struct type *
-cplus_type_of_child (struct varobj *parent, int index)
+cplus_type_of_child (const struct varobj *parent, int index)
{
struct type *type = NULL;
return type;
}
-static char *
-cplus_value_of_variable (struct varobj *var,
+static std::string
+cplus_value_of_variable (const struct varobj *var,
enum varobj_display_formats format)
{
/* If we have one of our special types, don't print out
any value. */
if (CPLUS_FAKE_CHILD (var))
- return xstrdup ("");
+ return std::string ();
return c_value_of_variable (var, format);
}