gdb/c-varobj.c - gdb

Global variables defined

Data types defined

Functions defined

Macros defined

Source code

  1. /* varobj support for C and C++.

  3.    Copyright (C) 1999-2015 Free Software Foundation, Inc.

  5.    This program is free software; you can redistribute it and/or modify
  6.    it under the terms of the GNU General Public License as published by
  7.    the Free Software Foundation; either version 3 of the License, or
  8.    (at your option) any later version.

  10.    This program is distributed in the hope that it will be useful,
  11.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.    GNU General Public License for more details.

  15.    You should have received a copy of the GNU General Public License
  16.    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

  18. #include "defs.h"
  19. #include "value.h"
  20. #include "varobj.h"
  21. #include "gdbthread.h"
  22. #include "valprint.h"

  24. static void cplus_class_num_children (struct type *type, int children[3]);

  26. /* The names of varobjs representing anonymous structs or unions.  */
  27. ‌#define ANONYMOUS_STRUCT_NAME _("<anonymous struct>")
  28. ‌#define ANONYMOUS_UNION_NAME _("<anonymous union>")

  30. /* Does CHILD represent a child with no name?  This happens when
  31.    the child is an anonmous struct or union and it has no field name
  32.    in its parent variable.

  34.    This has already been determined by *_describe_child. The easiest
  35.    thing to do is to compare the child's name with ANONYMOUS_*_NAME.  */

  37. int
  38. ‌varobj_is_anonymous_child (struct varobj *child)
  39. {
  40.   return (strcmp (child->name, ANONYMOUS_STRUCT_NAME) == 0
  41.           || strcmp (child->name, ANONYMOUS_UNION_NAME) == 0);
  42. }

  44. /* Given the value and the type of a variable object,
  45.    adjust the value and type to those necessary
  46.    for getting children of the variable object.
  47.    This includes dereferencing top-level references
  48.    to all types and dereferencing pointers to
  49.    structures.

  51.    If LOOKUP_ACTUAL_TYPE is set the enclosing type of the
  52.    value will be fetched and if it differs from static type
  53.    the value will be casted to it.

  55.    Both TYPE and *TYPE should be non-null.  VALUE
  56.    can be null if we want to only translate type.
  57.    *VALUE can be null as well -- if the parent
  58.    value is not known.

  60.    If WAS_PTR is not NULL, set *WAS_PTR to 0 or 1
  61.    depending on whether pointer was dereferenced
  62.    in this function.  */

  64. static void
  65. ‌adjust_value_for_child_access (struct value **value,
  66.                                   struct type **type,
  67.                                   int *was_ptr,
  68.                                   int lookup_actual_type)
  69. {
  70.   gdb_assert (type && *type);

  72.   if (was_ptr)
  73.     *was_ptr = 0;

  75.   *type = check_typedef (*type);

  77.   /* The type of value stored in varobj, that is passed
  78.      to us, is already supposed to be
  79.      reference-stripped.  */

  81.   gdb_assert (TYPE_CODE (*type) != TYPE_CODE_REF);

  83.   /* Pointers to structures are treated just like
  84.      structures when accessing children.  Don't
  85.      dererences pointers to other types.  */
  86.   if (TYPE_CODE (*type) == TYPE_CODE_PTR)
  87.     {
  88.       struct type *target_type = get_target_type (*type);
  89.       if (TYPE_CODE (target_type) == TYPE_CODE_STRUCT
  90.           || TYPE_CODE (target_type) == TYPE_CODE_UNION)
  91.         {
  92.           if (value && *value)
  93.             {
  94.               volatile struct gdb_exception except;

  96.               TRY_CATCH (except, RETURN_MASK_ERROR)
  97.                 {
  98.                   *value = value_ind (*value);
  99.                 }

  101.               if (except.reason < 0)
  102.                 *value = NULL;
  103.             }
  104.           *type = target_type;
  105.           if (was_ptr)
  106.             *was_ptr = 1;
  107.         }
  108.     }

  110.   /* The 'get_target_type' function calls check_typedef on
  111.      result, so we can immediately check type code.  No
  112.      need to call check_typedef here.  */

  114.   /* Access a real type of the value (if necessary and possible).  */
  115.   if (value && *value && lookup_actual_type)
  116.     {
  117.       struct type *enclosing_type;
  118.       int real_type_found = 0;

  120.       enclosing_type = value_actual_type (*value, 1, &real_type_found);
  121.       if (real_type_found)
  122.         {
  123.           *type = enclosing_type;
  124.           *value = value_cast (enclosing_type, *value);
  125.         }
  126.     }
  127. }

  129. /* Is VAR a path expression parent, i.e., can it be used to construct
  130.    a valid path expression?  */

  132. static int
  133. ‌c_is_path_expr_parent (struct varobj *var)
  134. {
  135.   struct type *type;

  137.   /* "Fake" children are not path_expr parents.  */
  138.   if (CPLUS_FAKE_CHILD (var))
  139.     return 0;

  141.   type = varobj_get_gdb_type (var);

  143.   /* Anonymous unions and structs are also not path_expr parents.  */
  144.   if ((TYPE_CODE (type) == TYPE_CODE_STRUCT
  145.        || TYPE_CODE (type) == TYPE_CODE_UNION)
  146.       && TYPE_NAME (type) == NULL
  147.       && TYPE_TAG_NAME (type) == NULL)
  148.     {
  149.       struct varobj *parent = var->parent;

  151.       while (parent != NULL && CPLUS_FAKE_CHILD (parent))
  152.         parent = parent->parent;

  154.       if (parent != NULL)
  155.         {
  156.           struct type *parent_type;
  157.           int was_ptr;

  159.           parent_type = varobj_get_value_type (parent);
  160.           adjust_value_for_child_access (NULL, &parent_type, &was_ptr, 0);

  162.           if (TYPE_CODE (parent_type) == TYPE_CODE_STRUCT
  163.               || TYPE_CODE (parent_type) == TYPE_CODE_UNION)
  164.             {
  165.               const char *field_name;

  167.               gdb_assert (var->index < TYPE_NFIELDS (parent_type));
  168.               field_name = TYPE_FIELD_NAME (parent_type, var->index);
  169.               return !(field_name == NULL || *field_name == '\0');
  170.             }
  171.         }

  173.       return 0;
  174.     }

  176.   return 1;
  177. }

  179. /* C */

  181. static int
  182. ‌c_number_of_children (struct varobj *var)
  183. {
  184.   struct type *type = varobj_get_value_type (var);
  185.   int children = 0;
  186.   struct type *target;

  188.   adjust_value_for_child_access (NULL, &type, NULL, 0);
  189.   target = get_target_type (type);

  191.   switch (TYPE_CODE (type))
  192.     {
  193.     case TYPE_CODE_ARRAY:
  194.       if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (target) > 0
  195.           && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))
  196.         children = TYPE_LENGTH (type) / TYPE_LENGTH (target);
  197.       else
  198.         /* If we don't know how many elements there are, don't display
  199.            any.  */
  200.         children = 0;
  201.       break;

  203.     case TYPE_CODE_STRUCT:
  204.     case TYPE_CODE_UNION:
  205.       children = TYPE_NFIELDS (type);
  206.       break;

  208.     case TYPE_CODE_PTR:
  209.       /* The type here is a pointer to non-struct.  Typically, pointers
  210.          have one child, except for function ptrs, which have no children,
  211.          and except for void*, as we don't know what to show.

  213.          We can show char* so we allow it to be dereferenced.  If you decide
  214.          to test for it, please mind that a little magic is necessary to
  215.          properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and
  216.          TYPE_NAME == "char".  */
  217.       if (TYPE_CODE (target) == TYPE_CODE_FUNC
  218.           || TYPE_CODE (target) == TYPE_CODE_VOID)
  219.         children = 0;
  220.       else
  221.         children = 1;
  222.       break;

  224.     default:
  225.       /* Other types have no children.  */
  226.       break;
  227.     }

  229.   return children;
  230. }

  232. static char *
  233. ‌c_name_of_variable (struct varobj *parent)
  234. {
  235.   return xstrdup (parent->name);
  236. }

  238. /* Return the value of element TYPE_INDEX of a structure
  239.    value VALUE.  VALUE's type should be a structure,
  240.    or union, or a typedef to struct/union.

  242.    Returns NULL if getting the value fails.  Never throws.  */

  244. static struct value *
  245. ‌value_struct_element_index (struct value *value, int type_index)
  246. {
  247.   struct value *result = NULL;
  248.   volatile struct gdb_exception e;
  249.   struct type *type = value_type (value);

  251.   type = check_typedef (type);

  253.   gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
  254.               || TYPE_CODE (type) == TYPE_CODE_UNION);

  256.   TRY_CATCH (e, RETURN_MASK_ERROR)
  257.     {
  258.       if (field_is_static (&TYPE_FIELD (type, type_index)))
  259.         result = value_static_field (type, type_index);
  260.       else
  261.         result = value_primitive_field (value, 0, type_index, type);
  262.     }
  263.   if (e.reason < 0)
  264.     {
  265.       return NULL;
  266.     }
  267.   else
  268.     {
  269.       return result;
  270.     }
  271. }

  273. /* Obtain the information about child INDEX of the variable
  274.    object PARENT.
  275.    If CNAME is not null, sets *CNAME to the name of the child relative
  276.    to the parent.
  277.    If CVALUE is not null, sets *CVALUE to the value of the child.
  278.    If CTYPE is not null, sets *CTYPE to the type of the child.

  280.    If any of CNAME, CVALUE, or CTYPE is not null, but the corresponding
  281.    information cannot be determined, set *CNAME, *CVALUE, or *CTYPE
  282.    to NULL.  */

  284. static void
  285. ‌c_describe_child (struct varobj *parent, int index,
  286.                   char **cname, struct value **cvalue, struct type **ctype,
  287.                   char **cfull_expression)
  288. {
  289.   struct value *value = parent->value;
  290.   struct type *type = varobj_get_value_type (parent);
  291.   char *parent_expression = NULL;
  292.   int was_ptr;
  293.   volatile struct gdb_exception except;

  295.   if (cname)
  296.     *cname = NULL;
  297.   if (cvalue)
  298.     *cvalue = NULL;
  299.   if (ctype)
  300.     *ctype = NULL;
  301.   if (cfull_expression)
  302.     {
  303.       *cfull_expression = NULL;
  304.       parent_expression
  305.         = varobj_get_path_expr (varobj_get_path_expr_parent (parent));
  306.     }
  307.   adjust_value_for_child_access (&value, &type, &was_ptr, 0);

  309.   switch (TYPE_CODE (type))
  310.     {
  311.     case TYPE_CODE_ARRAY:
  312.       if (cname)
  313.         *cname
  314.           = xstrdup (int_string (index
  315.                                  + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)),
  316.                                  10, 1, 0, 0));

  318.       if (cvalue && value)
  319.         {
  320.           int real_index = index + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type));

  322.           TRY_CATCH (except, RETURN_MASK_ERROR)
  323.             {
  324.               *cvalue = value_subscript (value, real_index);
  325.             }
  326.         }

  328.       if (ctype)
  329.         *ctype = get_target_type (type);

  331.       if (cfull_expression)
  332.         *cfull_expression =
  333.           xstrprintf ("(%s)[%s]", parent_expression,
  334.                       int_string (index
  335.                                   + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)),
  336.                                   10, 1, 0, 0));


  339.       break;

  341.     case TYPE_CODE_STRUCT:
  342.     case TYPE_CODE_UNION:
  343.       {
  344.         const char *field_name;

  346.         /* If the type is anonymous and the field has no name,
  347.            set an appropriate name.  */
  348.         field_name = TYPE_FIELD_NAME (type, index);
  349.         if (field_name == NULL || *field_name == '\0')
  350.           {
  351.             if (cname)
  352.               {
  353.                 if (TYPE_CODE (TYPE_FIELD_TYPE (type, index))
  354.                     == TYPE_CODE_STRUCT)
  355.                   *cname = xstrdup (ANONYMOUS_STRUCT_NAME);
  356.                 else
  357.                   *cname = xstrdup (ANONYMOUS_UNION_NAME);
  358.               }

  360.             if (cfull_expression)
  361.               *cfull_expression = xstrdup ("");
  362.           }
  363.         else
  364.           {
  365.             if (cname)
  366.               *cname = xstrdup (field_name);

  368.             if (cfull_expression)
  369.               {
  370.                 char *join = was_ptr ? "->" : ".";

  372.                 *cfull_expression = xstrprintf ("(%s)%s%s", parent_expression,
  373.                                                 join, field_name);
  374.               }
  375.           }

  377.         if (cvalue && value)
  378.           {
  379.             /* For C, varobj index is the same as type index.  */
  380.             *cvalue = value_struct_element_index (value, index);
  381.           }

  383.         if (ctype)
  384.           *ctype = TYPE_FIELD_TYPE (type, index);
  385.       }
  386.       break;

  388.     case TYPE_CODE_PTR:
  389.       if (cname)
  390.         *cname = xstrprintf ("*%s", parent->name);

  392.       if (cvalue && value)
  393.         {
  394.           TRY_CATCH (except, RETURN_MASK_ERROR)
  395.             {
  396.               *cvalue = value_ind (value);
  397.             }

  399.           if (except.reason < 0)
  400.             *cvalue = NULL;
  401.         }

  403.       /* Don't use get_target_type because it calls
  404.          check_typedef and here, we want to show the true
  405.          declared type of the variable.  */
  406.       if (ctype)
  407.         *ctype = TYPE_TARGET_TYPE (type);

  409.       if (cfull_expression)
  410.         *cfull_expression = xstrprintf ("*(%s)", parent_expression);

  412.       break;

  414.     default:
  415.       /* This should not happen.  */
  416.       if (cname)
  417.         *cname = xstrdup ("???");
  418.       if (cfull_expression)
  419.         *cfull_expression = xstrdup ("???");
  420.       /* Don't set value and type, we don't know then.  */
  421.     }
  422. }

  424. static char *
  425. ‌c_name_of_child (struct varobj *parent, int index)
  426. {
  427.   char *name;

  429.   c_describe_child (parent, index, &name, NULL, NULL, NULL);
  430.   return name;
  431. }

  433. static char *
  434. ‌c_path_expr_of_child (struct varobj *child)
  435. {
  436.   c_describe_child (child->parent, child->index, NULL, NULL, NULL,
  437.                     &child->path_expr);
  438.   return child->path_expr;
  439. }

  441. static struct value *
  442. ‌c_value_of_child (struct varobj *parent, int index)
  443. {
  444.   struct value *value = NULL;

  446.   c_describe_child (parent, index, NULL, &value, NULL, NULL);
  447.   return value;
  448. }

  450. static struct type *
  451. ‌c_type_of_child (struct varobj *parent, int index)
  452. {
  453.   struct type *type = NULL;

  455.   c_describe_child (parent, index, NULL, NULL, &type, NULL);
  456.   return type;
  457. }

  459. /* This returns the type of the variable.  It also skips past typedefs
  460.    to return the real type of the variable.  */

  462. static struct type *
  463. ‌get_type (struct varobj *var)
  464. {
  465.   struct type *type;

  467.   type = var->type;
  468.   if (type != NULL)
  469.     type = check_typedef (type);

  471.   return type;
  472. }

  474. static char *
  475. ‌c_value_of_variable (struct varobj *var, enum varobj_display_formats format)
  476. {
  477.   /* BOGUS: if val_print sees a struct/class, or a reference to one,
  478.      it will print out its children instead of "{...}".  So we need to
  479.      catch that case explicitly.  */
  480.   struct type *type = get_type (var);

  482.   /* Strip top-level references.  */
  483.   while (TYPE_CODE (type) == TYPE_CODE_REF)
  484.     type = check_typedef (TYPE_TARGET_TYPE (type));

  486.   switch (TYPE_CODE (type))
  487.     {
  488.     case TYPE_CODE_STRUCT:
  489.     case TYPE_CODE_UNION:
  490.       return xstrdup ("{...}");
  491.       /* break; */

  493.     case TYPE_CODE_ARRAY:
  494.       {
  495.         char *number;

  497.         number = xstrprintf ("[%d]", var->num_children);
  498.         return (number);
  499.       }
  500.       /* break; */

  502.     default:
  503.       {
  504.         if (var->value == NULL)
  505.           {
  506.             /* This can happen if we attempt to get the value of a struct
  507.                member when the parent is an invalid pointer.  This is an
  508.                error condition, so we should tell the caller.  */
  509.             return NULL;
  510.           }
  511.         else
  512.           {
  513.             if (var->not_fetched && value_lazy (var->value))
  514.               /* Frozen variable and no value yet.  We don't
  515.                  implicitly fetch the value.  MI response will
  516.                  use empty string for the value, which is OK.  */
  517.               return NULL;

  519.             gdb_assert (varobj_value_is_changeable_p (var));
  520.             gdb_assert (!value_lazy (var->value));

  522.             /* If the specified format is the current one,
  523.                we can reuse print_value.  */
  524.             if (format == var->format)
  525.               return xstrdup (var->print_value);
  526.             else
  527.               return varobj_value_get_print_value (var->value, format, var);
  528.           }
  529.       }
  530.     }
  531. }


  534. /* varobj operations for c.  */

  536. ‌const struct lang_varobj_ops c_varobj_ops =
  537. {
  538.    c_number_of_children,
  539.    c_name_of_variable,
  540.    c_name_of_child,
  541.    c_path_expr_of_child,
  542.    c_value_of_child,
  543.    c_type_of_child,
  544.    c_value_of_variable,
  545.    varobj_default_value_is_changeable_p,
  546.    NULL, /* value_has_mutated */
  547.    c_is_path_expr_parent  /* is_path_expr_parent */
  548. };

  550. /* A little convenience enum for dealing with C++/Java.  */
  551. ‌enum vsections
  552. {
  553.   v_public = 0, v_private, v_protected
  554. };

  556. /* C++ */

  558. static int
  559. ‌cplus_number_of_children (struct varobj *var)
  560. {
  561.   struct value *value = NULL;
  562.   struct type *type;
  563.   int children, dont_know;
  564.   int lookup_actual_type = 0;
  565.   struct value_print_options opts;

  567.   dont_know = 1;
  568.   children = 0;

  570.   get_user_print_options (&opts);

  572.   if (!CPLUS_FAKE_CHILD (var))
  573.     {
  574.       type = varobj_get_value_type (var);

  576.       /* It is necessary to access a real type (via RTTI).  */
  577.       if (opts.objectprint)
  578.         {
  579.           value = var->value;
  580.           lookup_actual_type = (TYPE_CODE (var->type) == TYPE_CODE_REF
  581.                                 || TYPE_CODE (var->type) == TYPE_CODE_PTR);
  582.         }
  583.       adjust_value_for_child_access (&value, &type, NULL, lookup_actual_type);

  585.       if (((TYPE_CODE (type)) == TYPE_CODE_STRUCT)
  586.           || ((TYPE_CODE (type)) == TYPE_CODE_UNION))
  587.         {
  588.           int kids[3];

  590.           cplus_class_num_children (type, kids);
  591.           if (kids[v_public] != 0)
  592.             children++;
  593.           if (kids[v_private] != 0)
  594.             children++;
  595.           if (kids[v_protected] != 0)
  596.             children++;

  598.           /* Add any baseclasses.  */
  599.           children += TYPE_N_BASECLASSES (type);
  600.           dont_know = 0;

  602.           /* FIXME: save children in var.  */
  603.         }
  604.     }
  605.   else
  606.     {
  607.       int kids[3];

  609.       type = varobj_get_value_type (var->parent);

  611.       /* It is necessary to access a real type (via RTTI).  */
  612.       if (opts.objectprint)
  613.         {
  614.           struct varobj *parent = var->parent;

  616.           value = parent->value;
  617.           lookup_actual_type = (TYPE_CODE (parent->type) == TYPE_CODE_REF
  618.                                 || TYPE_CODE (parent->type) == TYPE_CODE_PTR);
  619.         }
  620.       adjust_value_for_child_access (&value, &type, NULL, lookup_actual_type);

  622.       cplus_class_num_children (type, kids);
  623.       if (strcmp (var->name, "public") == 0)
  624.         children = kids[v_public];
  625.       else if (strcmp (var->name, "private") == 0)
  626.         children = kids[v_private];
  627.       else
  628.         children = kids[v_protected];
  629.       dont_know = 0;
  630.     }

  632.   if (dont_know)
  633.     children = c_number_of_children (var);

  635.   return children;
  636. }

  638. /* Compute # of public, private, and protected variables in this class.
  639.    That means we need to descend into all baseclasses and find out
  640.    how many are there, too.  */

  642. static void
  643. ‌cplus_class_num_children (struct type *type, int children[3])
  644. {
  645.   int i, vptr_fieldno;
  646.   struct type *basetype = NULL;

  648.   children[v_public] = 0;
  649.   children[v_private] = 0;
  650.   children[v_protected] = 0;

  652.   vptr_fieldno = get_vptr_fieldno (type, &basetype);
  653.   for (i = TYPE_N_BASECLASSES (type); i < TYPE_NFIELDS (type); i++)
  654.     {
  655.       /* If we have a virtual table pointer, omit it.  Even if virtual
  656.          table pointers are not specifically marked in the debug info,
  657.          they should be artificial.  */
  658.       if ((type == basetype && i == vptr_fieldno)
  659.           || TYPE_FIELD_ARTIFICIAL (type, i))
  660.         continue;

  662.       if (TYPE_FIELD_PROTECTED (type, i))
  663.         children[v_protected]++;
  664.       else if (TYPE_FIELD_PRIVATE (type, i))
  665.         children[v_private]++;
  666.       else
  667.         children[v_public]++;
  668.     }
  669. }

  671. static char *
  672. ‌cplus_name_of_variable (struct varobj *parent)
  673. {
  674.   return c_name_of_variable (parent);
  675. }

  677. ‌enum accessibility { private_field, protected_field, public_field };

  679. /* Check if field INDEX of TYPE has the specified accessibility.
  680.    Return 0 if so and 1 otherwise.  */

  682. static int
  683. ‌match_accessibility (struct type *type, int index, enum accessibility acc)
  684. {
  685.   if (acc == private_field && TYPE_FIELD_PRIVATE (type, index))
  686.     return 1;
  687.   else if (acc == protected_field && TYPE_FIELD_PROTECTED (type, index))
  688.     return 1;
  689.   else if (acc == public_field && !TYPE_FIELD_PRIVATE (type, index)
  690.            && !TYPE_FIELD_PROTECTED (type, index))
  691.     return 1;
  692.   else
  693.     return 0;
  694. }

  696. static void
  697. ‌cplus_describe_child (struct varobj *parent, int index,
  698.                       char **cname, struct value **cvalue, struct type **ctype,
  699.                       char **cfull_expression)
  700. {
  701.   struct value *value;
  702.   struct type *type;
  703.   int was_ptr;
  704.   int lookup_actual_type = 0;
  705.   char *parent_expression = NULL;
  706.   struct varobj *var;
  707.   struct value_print_options opts;

  709.   if (cname)
  710.     *cname = NULL;
  711.   if (cvalue)
  712.     *cvalue = NULL;
  713.   if (ctype)
  714.     *ctype = NULL;
  715.   if (cfull_expression)
  716.     *cfull_expression = NULL;

  718.   get_user_print_options (&opts);

  720.   var = (CPLUS_FAKE_CHILD (parent)) ? parent->parent : parent;
  721.   if (opts.objectprint)
  722.     lookup_actual_type = (TYPE_CODE (var->type) == TYPE_CODE_REF
  723.                           || TYPE_CODE (var->type) == TYPE_CODE_PTR);
  724.   value = var->value;
  725.   type = varobj_get_value_type (var);
  726.   if (cfull_expression)
  727.     parent_expression
  728.       = varobj_get_path_expr (varobj_get_path_expr_parent (var));

  730.   adjust_value_for_child_access (&value, &type, &was_ptr, lookup_actual_type);

  732.   if (TYPE_CODE (type) == TYPE_CODE_STRUCT
  733.       || TYPE_CODE (type) == TYPE_CODE_UNION)
  734.     {
  735.       char *join = was_ptr ? "->" : ".";

  737.       if (CPLUS_FAKE_CHILD (parent))
  738.         {
  739.           /* The fields of the class type are ordered as they
  740.              appear in the class.  We are given an index for a
  741.              particular access control type ("public","protected",
  742.              or "private").  We must skip over fields that don't
  743.              have the access control we are looking for to properly
  744.              find the indexed field.  */
  745.           int type_index = TYPE_N_BASECLASSES (type);
  746.           enum accessibility acc = public_field;
  747.           int vptr_fieldno;
  748.           struct type *basetype = NULL;
  749.           const char *field_name;

  751.           vptr_fieldno = get_vptr_fieldno (type, &basetype);
  752.           if (strcmp (parent->name, "private") == 0)
  753.             acc = private_field;
  754.           else if (strcmp (parent->name, "protected") == 0)
  755.             acc = protected_field;

  757.           while (index >= 0)
  758.             {
  759.               if ((type == basetype && type_index == vptr_fieldno)
  760.                   || TYPE_FIELD_ARTIFICIAL (type, type_index))
  761.                 ; /* ignore vptr */
  762.               else if (match_accessibility (type, type_index, acc))
  763.                     --index;
  764.                   ++type_index;
  765.             }
  766.           --type_index;

  768.           /* If the type is anonymous and the field has no name,
  769.              set an appopriate name.  */
  770.           field_name = TYPE_FIELD_NAME (type, type_index);
  771.           if (field_name == NULL || *field_name == '\0')
  772.             {
  773.               if (cname)
  774.                 {
  775.                   if (TYPE_CODE (TYPE_FIELD_TYPE (type, type_index))
  776.                       == TYPE_CODE_STRUCT)
  777.                     *cname = xstrdup (ANONYMOUS_STRUCT_NAME);
  778.                   else if (TYPE_CODE (TYPE_FIELD_TYPE (type, type_index))
  779.                            == TYPE_CODE_UNION)
  780.                     *cname = xstrdup (ANONYMOUS_UNION_NAME);
  781.                 }

  783.               if (cfull_expression)
  784.                 *cfull_expression = xstrdup ("");
  785.             }
  786.           else
  787.             {
  788.               if (cname)
  789.                 *cname = xstrdup (TYPE_FIELD_NAME (type, type_index));

  791.               if (cfull_expression)
  792.                 *cfull_expression
  793.                   = xstrprintf ("((%s)%s%s)", parent_expression, join,
  794.                                 field_name);
  795.             }

  797.           if (cvalue && value)
  798.             *cvalue = value_struct_element_index (value, type_index);

  800.           if (ctype)
  801.             *ctype = TYPE_FIELD_TYPE (type, type_index);
  802.         }
  803.       else if (index < TYPE_N_BASECLASSES (type))
  804.         {
  805.           /* This is a baseclass.  */
  806.           if (cname)
  807.             *cname = xstrdup (TYPE_FIELD_NAME (type, index));

  809.           if (cvalue && value)
  810.             *cvalue = value_cast (TYPE_FIELD_TYPE (type, index), value);

  812.           if (ctype)
  813.             {
  814.               *ctype = TYPE_FIELD_TYPE (type, index);
  815.             }

  817.           if (cfull_expression)
  818.             {
  819.               char *ptr = was_ptr ? "*" : "";

  821.               /* Cast the parent to the base' type.  Note that in gdb,
  822.                  expression like
  823.                          (Base1)d
  824.                  will create an lvalue, for all appearences, so we don't
  825.                  need to use more fancy:
  826.                          *(Base1*)(&d)
  827.                  construct.

  829.                  When we are in the scope of the base class or of one
  830.                  of its children, the type field name will be interpreted
  831.                  as a constructor, if it exists.  Therefore, we must
  832.                  indicate that the name is a class name by using the
  833.                  'class' keyword.  See PR mi/11912  */
  834.               *cfull_expression = xstrprintf ("(%s(class %s%s) %s)",
  835.                                               ptr,
  836.                                               TYPE_FIELD_NAME (type, index),
  837.                                               ptr,
  838.                                               parent_expression);
  839.             }
  840.         }
  841.       else
  842.         {
  843.           char *access = NULL;
  844.           int children[3];

  846.           cplus_class_num_children (type, children);

  848.           /* Everything beyond the baseclasses can
  849.              only be "public", "private", or "protected"

  851.              The special "fake" children are always output by varobj in
  852.              this order.  So if INDEX == 2, it MUST be "protected".  */
  853.           index -= TYPE_N_BASECLASSES (type);
  854.           switch (index)
  855.             {
  856.             case 0:
  857.               if (children[v_public] > 0)
  858.                  access = "public";
  859.               else if (children[v_private] > 0)
  860.                  access = "private";
  861.               else
  862.                  access = "protected";
  863.               break;
  864.             case 1:
  865.               if (children[v_public] > 0)
  866.                 {
  867.                   if (children[v_private] > 0)
  868.                     access = "private";
  869.                   else
  870.                     access = "protected";
  871.                 }
  872.               else if (children[v_private] > 0)
  873.                  access = "protected";
  874.               break;
  875.             case 2:
  876.               /* Must be protected.  */
  877.               access = "protected";
  878.               break;
  879.             default:
  880.               /* error!  */
  881.               break;
  882.             }

  884.           gdb_assert (access);
  885.           if (cname)
  886.             *cname = xstrdup (access);

  888.           /* Value and type and full expression are null here.  */
  889.         }
  890.     }
  891.   else
  892.     {
  893.       c_describe_child (parent, index, cname, cvalue, ctype, cfull_expression);
  894.     }
  895. }

  897. static char *
  898. ‌cplus_name_of_child (struct varobj *parent, int index)
  899. {
  900.   char *name = NULL;

  902.   cplus_describe_child (parent, index, &name, NULL, NULL, NULL);
  903.   return name;
  904. }

  906. static char *
  907. ‌cplus_path_expr_of_child (struct varobj *child)
  908. {
  909.   cplus_describe_child (child->parent, child->index, NULL, NULL, NULL,
  910.                         &child->path_expr);
  911.   return child->path_expr;
  912. }

  914. static struct value *
  915. ‌cplus_value_of_child (struct varobj *parent, int index)
  916. {
  917.   struct value *value = NULL;

  919.   cplus_describe_child (parent, index, NULL, &value, NULL, NULL);
  920.   return value;
  921. }

  923. static struct type *
  924. ‌cplus_type_of_child (struct varobj *parent, int index)
  925. {
  926.   struct type *type = NULL;

  928.   cplus_describe_child (parent, index, NULL, NULL, &type, NULL);
  929.   return type;
  930. }

  932. static char *
  933. ‌cplus_value_of_variable (struct varobj *var,
  934.                          enum varobj_display_formats format)
  935. {

  937.   /* If we have one of our special types, don't print out
  938.      any value.  */
  939.   if (CPLUS_FAKE_CHILD (var))
  940.     return xstrdup ("");

  942.   return c_value_of_variable (var, format);
  943. }


  946. /* varobj operations for c++.  */

  948. ‌const struct lang_varobj_ops cplus_varobj_ops =
  949. {
  950.    cplus_number_of_children,
  951.    cplus_name_of_variable,
  952.    cplus_name_of_child,
  953.    cplus_path_expr_of_child,
  954.    cplus_value_of_child,
  955.    cplus_type_of_child,
  956.    cplus_value_of_variable,
  957.    varobj_default_value_is_changeable_p,
  958.    NULL, /* value_has_mutated */
  959.    c_is_path_expr_parent  /* is_path_expr_parent */
  960. };