gdb/c-varobj.c

   1 /* varobj support for C and C++.
   2
   3    Copyright (C) 1999-2023 Free Software Foundation, Inc.
   4
   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.
   9
  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.
  14
  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/>.  */
  17
  18 #include "defs.h"
  19 #include "value.h"
  20 #include "varobj.h"
  21 #include "gdbthread.h"
  22 #include "valprint.h"
  23
  24 static void cplus_class_num_children (struct type *type, int children[3]);
  25
  26 /* The names of varobjs representing anonymous structs or unions.  */
  27 #define ANONYMOUS_STRUCT_NAME _("<anonymous struct>")
  28 #define ANONYMOUS_UNION_NAME _("<anonymous union>")
  29
  30 /* Does CHILD represent a child with no name?  This happens when
  31    the child is an anonymous struct or union and it has no field name
  32    in its parent variable.
  33
  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.  */
  36
  37 bool
  38 varobj_is_anonymous_child (const struct varobj *child)
  39 {
  40   return (child->name == ANONYMOUS_STRUCT_NAME
  41           || child->name == ANONYMOUS_UNION_NAME);
  42 }
  43
  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.
  50
  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.
  54
  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.
  59
  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.  */
  63
  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);
  71
  72   if (was_ptr)
  73     *was_ptr = 0;
  74
  75   *type = check_typedef (*type);
  76
  77   /* The type of value stored in varobj, that is passed
  78      to us, is already supposed to be
  79      reference-stripped.  */
  80
  81   gdb_assert (!TYPE_IS_REFERENCE (*type));
  82
  83   /* Pointers to structures are treated just like
  84      structures when accessing children.  Don't
  85      dereference pointers to other types.  */
  86   if ((*type)->code () == TYPE_CODE_PTR)
  87     {
  88       struct type *target_type = get_target_type (*type);
  89       if (target_type->code () == TYPE_CODE_STRUCT
  90           || target_type->code () == TYPE_CODE_UNION)
  91         {
  92           if (value && *value)
  93             {
  94
  95               try
  96                 {
  97                   *value = value_ind (*value);
  98                 }
  99
 100               catch (const gdb_exception_error &except)
 101                 {
 102                   *value = NULL;
 103                 }
 104             }
 105           *type = target_type;
 106           if (was_ptr)
 107             *was_ptr = 1;
 108         }
 109     }
 110
 111   /* The 'get_target_type' function calls check_typedef on
 112      result, so we can immediately check type code.  No
 113      need to call check_typedef here.  */
 114
 115   /* Access a real type of the value (if necessary and possible).  */
 116   if (value && *value && lookup_actual_type)
 117     {
 118       struct type *enclosing_type;
 119       int real_type_found = 0;
 120
 121       enclosing_type = value_actual_type (*value, 1, &real_type_found);
 122       if (real_type_found)
 123         {
 124           *type = enclosing_type;
 125           *value = value_cast (enclosing_type, *value);
 126         }
 127     }
 128 }
 129
 130 /* Is VAR a path expression parent, i.e., can it be used to construct
 131    a valid path expression?  */
 132
 133 static bool
 134 c_is_path_expr_parent (const struct varobj *var)
 135 {
 136   struct type *type;
 137
 138   /* "Fake" children are not path_expr parents.  */
 139   if (CPLUS_FAKE_CHILD (var))
 140     return false;
 141
 142   type = varobj_get_gdb_type (var);
 143
 144   /* Anonymous unions and structs are also not path_expr parents.  */
 145   if ((type->code () == TYPE_CODE_STRUCT
 146        || type->code () == TYPE_CODE_UNION)
 147       && type->name () == NULL)
 148     {
 149       const struct varobj *parent = var->parent;
 150
 151       while (parent != NULL && CPLUS_FAKE_CHILD (parent))
 152         parent = parent->parent;
 153
 154       if (parent != NULL)
 155         {
 156           struct type *parent_type;
 157           int was_ptr;
 158
 159           parent_type = varobj_get_value_type (parent);
 160           adjust_value_for_child_access (NULL, &parent_type, &was_ptr, 0);
 161
 162           if (parent_type->code () == TYPE_CODE_STRUCT
 163               || parent_type->code () == TYPE_CODE_UNION)
 164             {
 165               const char *field_name;
 166
 167               gdb_assert (var->index < parent_type->num_fields ());
 168               field_name = parent_type->field (var->index).name ();
 169               return !(field_name == NULL || *field_name == '\0');
 170             }
 171         }
 172
 173       return false;
 174     }
 175
 176   return true;
 177 }
 178
 179 /* C */
 180
 181 static int
 182 c_number_of_children (const struct varobj *var)
 183 {
 184   struct type *type = varobj_get_value_type (var);
 185   int children = 0;
 186   struct type *target;
 187
 188   adjust_value_for_child_access (NULL, &type, NULL, 0);
 189   target = get_target_type (type);
 190
 191   switch (type->code ())
 192     {
 193     case TYPE_CODE_ARRAY:
 194       if (type->length () > 0 && target->length () > 0
 195           && (type->bounds ()->high.kind () != PROP_UNDEFINED))
 196         children = type->length () / target->length ();
 197       else
 198         /* If we don't know how many elements there are, don't display
 199            any.  */
 200         children = 0;
 201       break;
 202
 203     case TYPE_CODE_STRUCT:
 204     case TYPE_CODE_UNION:
 205       children = type->num_fields ();
 206       break;
 207
 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.
 212
 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 (target->code () == TYPE_CODE_FUNC
 218           || target->code () == TYPE_CODE_VOID)
 219         children = 0;
 220       else
 221         children = 1;
 222       break;
 223
 224     default:
 225       /* Other types have no children.  */
 226       break;
 227     }
 228
 229   return children;
 230 }
 231
 232 static std::string
 233 c_name_of_variable (const struct varobj *parent)
 234 {
 235   return parent->name;
 236 }
 237
 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.
 241
 242    Returns NULL if getting the value fails.  Never throws.  */
 243
 244 static struct value *
 245 value_struct_element_index (struct value *value, int type_index)
 246 {
 247   struct value *result = NULL;
 248   struct type *type = value->type ();
 249
 250   type = check_typedef (type);
 251
 252   gdb_assert (type->code () == TYPE_CODE_STRUCT
 253               || type->code () == TYPE_CODE_UNION);
 254
 255   try
 256     {
 257       if (type->field (type_index).is_static ())
 258         result = value_static_field (type, type_index);
 259       else
 260         result = value->primitive_field (0, type_index, type);
 261     }
 262   catch (const gdb_exception_error &e)
 263     {
 264       return NULL;
 265     }
 266
 267   return result;
 268 }
 269
 270 /* Obtain the information about child INDEX of the variable
 271    object PARENT.
 272    If CNAME is not null, sets *CNAME to the name of the child relative
 273    to the parent.
 274    If CVALUE is not null, sets *CVALUE to the value of the child.
 275    If CTYPE is not null, sets *CTYPE to the type of the child.
 276
 277    If any of CNAME, CVALUE, or CTYPE is not null, but the corresponding
 278    information cannot be determined, set *CNAME, *CVALUE, or *CTYPE
 279    to empty.  */
 280
 281 static void
 282 c_describe_child (const struct varobj *parent, int index,
 283                   std::string *cname, struct value **cvalue,
 284                   struct type **ctype, std::string *cfull_expression)
 285 {
 286   struct value *value = parent->value.get ();
 287   struct type *type = varobj_get_value_type (parent);
 288   std::string parent_expression;
 289   int was_ptr;
 290
 291   if (cname)
 292     *cname = std::string ();
 293   if (cvalue)
 294     *cvalue = NULL;
 295   if (ctype)
 296     *ctype = NULL;
 297   if (cfull_expression)
 298     {
 299       *cfull_expression = std::string ();
 300       parent_expression
 301         = varobj_get_path_expr (varobj_get_path_expr_parent (parent));
 302     }
 303   adjust_value_for_child_access (&value, &type, &was_ptr, 0);
 304
 305   switch (type->code ())
 306     {
 307     case TYPE_CODE_ARRAY:
 308       if (cname)
 309         *cname = int_string (index + type->bounds ()->low.const_val (),
 310                              10, 1, 0, 0);
 311
 312       if (cvalue && value)
 313         {
 314           int real_index
 315             = index + type->bounds ()->low.const_val ();
 316
 317           try
 318             {
 319               *cvalue = value_subscript (value, real_index);
 320             }
 321           catch (const gdb_exception_error &except)
 322             {
 323             }
 324         }
 325
 326       if (ctype)
 327         *ctype = get_target_type (type);
 328
 329       if (cfull_expression)
 330         *cfull_expression = string_printf
 331           ("(%s)[%s]", parent_expression.c_str (),
 332            int_string (index + type->bounds ()->low.const_val (),
 333                        10, 1, 0, 0));
 334
 335       break;
 336
 337     case TYPE_CODE_STRUCT:
 338     case TYPE_CODE_UNION:
 339       {
 340         const char *field_name;
 341
 342         /* If the type is anonymous and the field has no name,
 343            set an appropriate name.  */
 344         field_name = type->field (index).name ();
 345         if (field_name == NULL || *field_name == '\0')
 346           {
 347             if (cname)
 348               {
 349                 if (type->field (index).type ()->code ()
 350                     == TYPE_CODE_STRUCT)
 351                   *cname = ANONYMOUS_STRUCT_NAME;
 352                 else
 353                   *cname = ANONYMOUS_UNION_NAME;
 354               }
 355
 356             if (cfull_expression)
 357               *cfull_expression = "";
 358           }
 359         else
 360           {
 361             if (cname)
 362               *cname = field_name;
 363
 364             if (cfull_expression)
 365               {
 366                 const char *join = was_ptr ? "->" : ".";
 367
 368                 *cfull_expression = string_printf ("(%s)%s%s",
 369                                                    parent_expression.c_str (),
 370                                                    join, field_name);
 371               }
 372           }
 373
 374         if (cvalue && value)
 375           {
 376             /* For C, varobj index is the same as type index.  */
 377             *cvalue = value_struct_element_index (value, index);
 378           }
 379
 380         if (ctype)
 381           *ctype = type->field (index).type ();
 382       }
 383       break;
 384
 385     case TYPE_CODE_PTR:
 386       if (cname)
 387         *cname = string_printf ("*%s", parent->name.c_str ());
 388
 389       if (cvalue && value)
 390         {
 391           try
 392             {
 393               *cvalue = value_ind (value);
 394             }
 395
 396           catch (const gdb_exception_error &except)
 397             {
 398               *cvalue = NULL;
 399             }
 400         }
 401
 402       /* Don't use get_target_type because it calls
 403          check_typedef and here, we want to show the true
 404          declared type of the variable.  */
 405       if (ctype)
 406         *ctype = type->target_type ();
 407
 408       if (cfull_expression)
 409         *cfull_expression = string_printf ("*(%s)", parent_expression.c_str ());
 410       break;
 411
 412     default:
 413       /* This should not happen.  */
 414       if (cname)
 415         *cname = "???";
 416       if (cfull_expression)
 417         *cfull_expression = "???";
 418       /* Don't set value and type, we don't know then.  */
 419     }
 420 }
 421
 422 static std::string
 423 c_name_of_child (const struct varobj *parent, int index)
 424 {
 425   std::string name;
 426
 427   c_describe_child (parent, index, &name, NULL, NULL, NULL);
 428   return name;
 429 }
 430
 431 static std::string
 432 c_path_expr_of_child (const struct varobj *child)
 433 {
 434   std::string path_expr;
 435
 436   c_describe_child (child->parent, child->index, NULL, NULL, NULL,
 437                     &path_expr);
 438   return path_expr;
 439 }
 440
 441 static struct value *
 442 c_value_of_child (const struct varobj *parent, int index)
 443 {
 444   struct value *value = NULL;
 445
 446   c_describe_child (parent, index, NULL, &value, NULL, NULL);
 447   return value;
 448 }
 449
 450 static struct type *
 451 c_type_of_child (const struct varobj *parent, int index)
 452 {
 453   struct type *type = NULL;
 454
 455   c_describe_child (parent, index, NULL, NULL, &type, NULL);
 456   return type;
 457 }
 458
 459 /* This returns the type of the variable.  It also skips past typedefs
 460    to return the real type of the variable.  */
 461
 462 static struct type *
 463 get_type (const struct varobj *var)
 464 {
 465   struct type *type;
 466
 467   type = var->type;
 468   if (type != NULL)
 469     type = check_typedef (type);
 470
 471   return type;
 472 }
 473
 474 static std::string
 475 c_value_of_variable (const struct varobj *var,
 476                      enum varobj_display_formats format)
 477 {
 478   /* BOGUS: if val_print sees a struct/class, or a reference to one,
 479      it will print out its children instead of "{...}".  So we need to
 480      catch that case explicitly.  */
 481   struct type *type = get_type (var);
 482
 483   /* Strip top-level references.  */
 484   while (TYPE_IS_REFERENCE (type))
 485     type = check_typedef (type->target_type ());
 486
 487   switch (type->code ())
 488     {
 489     case TYPE_CODE_STRUCT:
 490     case TYPE_CODE_UNION:
 491       return "{...}";
 492       /* break; */
 493
 494     case TYPE_CODE_ARRAY:
 495       return string_printf ("[%d]", var->num_children);
 496       /* break; */
 497
 498     default:
 499       {
 500         if (var->value == NULL)
 501           {
 502             /* This can happen if we attempt to get the value of a struct
 503                member when the parent is an invalid pointer.  This is an
 504                error condition, so we should tell the caller.  */
 505             return std::string ();
 506           }
 507         else
 508           {
 509             if (var->not_fetched && var->value->lazy ())
 510               /* Frozen variable and no value yet.  We don't
 511                  implicitly fetch the value.  MI response will
 512                  use empty string for the value, which is OK.  */
 513               return std::string ();
 514
 515             gdb_assert (varobj_value_is_changeable_p (var));
 516             gdb_assert (!var->value->lazy ());
 517
 518             /* If the specified format is the current one,
 519                we can reuse print_value.  */
 520             if (format == var->format)
 521               return var->print_value;
 522             else
 523               return varobj_value_get_print_value (var->value.get (), format,
 524                                                    var);
 525           }
 526       }
 527     }
 528 }
 529 \f
 530
 531 /* varobj operations for c.  */
 532
 533 const struct lang_varobj_ops c_varobj_ops =
 534 {
 535    c_number_of_children,
 536    c_name_of_variable,
 537    c_name_of_child,
 538    c_path_expr_of_child,
 539    c_value_of_child,
 540    c_type_of_child,
 541    c_value_of_variable,
 542    varobj_default_value_is_changeable_p,
 543    NULL, /* value_has_mutated */
 544    c_is_path_expr_parent  /* is_path_expr_parent */
 545 };
 546
 547 /* A little convenience enum for dealing with C++.  */
 548 enum vsections
 549 {
 550   v_public = 0, v_private, v_protected
 551 };
 552
 553 /* C++ */
 554
 555 static int
 556 cplus_number_of_children (const struct varobj *var)
 557 {
 558   struct value *value = NULL;
 559   struct type *type;
 560   int children, dont_know;
 561   int lookup_actual_type = 0;
 562   struct value_print_options opts;
 563
 564   dont_know = 1;
 565   children = 0;
 566
 567   get_user_print_options (&opts);
 568
 569   if (!CPLUS_FAKE_CHILD (var))
 570     {
 571       type = varobj_get_value_type (var);
 572
 573       /* It is necessary to access a real type (via RTTI).  */
 574       if (opts.objectprint)
 575         {
 576           value = var->value.get ();
 577           lookup_actual_type = var->type->is_pointer_or_reference ();
 578         }
 579       adjust_value_for_child_access (&value, &type, NULL, lookup_actual_type);
 580
 581       if (((type->code ()) == TYPE_CODE_STRUCT)
 582           || ((type->code ()) == TYPE_CODE_UNION))
 583         {
 584           int kids[3];
 585
 586           cplus_class_num_children (type, kids);
 587           if (kids[v_public] != 0)
 588             children++;
 589           if (kids[v_private] != 0)
 590             children++;
 591           if (kids[v_protected] != 0)
 592             children++;
 593
 594           /* Add any baseclasses.  */
 595           children += TYPE_N_BASECLASSES (type);
 596           dont_know = 0;
 597
 598           /* FIXME: save children in var.  */
 599         }
 600     }
 601   else
 602     {
 603       int kids[3];
 604
 605       type = varobj_get_value_type (var->parent);
 606
 607       /* It is necessary to access a real type (via RTTI).  */
 608       if (opts.objectprint)
 609         {
 610           const struct varobj *parent = var->parent;
 611
 612           value = parent->value.get ();
 613           lookup_actual_type = parent->type->is_pointer_or_reference ();
 614         }
 615       adjust_value_for_child_access (&value, &type, NULL, lookup_actual_type);
 616
 617       cplus_class_num_children (type, kids);
 618       if (var->name == "public")
 619         children = kids[v_public];
 620       else if (var->name == "private")
 621         children = kids[v_private];
 622       else
 623         children = kids[v_protected];
 624       dont_know = 0;
 625     }
 626
 627   if (dont_know)
 628     children = c_number_of_children (var);
 629
 630   return children;
 631 }
 632
 633 /* Compute # of public, private, and protected variables in this class.
 634    That means we need to descend into all baseclasses and find out
 635    how many are there, too.  */
 636
 637 static void
 638 cplus_class_num_children (struct type *type, int children[3])
 639 {
 640   int i, vptr_fieldno;
 641   struct type *basetype = NULL;
 642
 643   children[v_public] = 0;
 644   children[v_private] = 0;
 645   children[v_protected] = 0;
 646
 647   vptr_fieldno = get_vptr_fieldno (type, &basetype);
 648   for (i = TYPE_N_BASECLASSES (type); i < type->num_fields (); i++)
 649     {
 650       field &fld = type->field (i);
 651
 652       /* If we have a virtual table pointer, omit it.  Even if virtual
 653          table pointers are not specifically marked in the debug info,
 654          they should be artificial.  */
 655       if ((type == basetype && i == vptr_fieldno)
 656           || fld.is_artificial ())
 657         continue;
 658
 659       if (fld.is_protected ())
 660         children[v_protected]++;
 661       else if (fld.is_private ())
 662         children[v_private]++;
 663       else
 664         children[v_public]++;
 665     }
 666 }
 667
 668 static std::string
 669 cplus_name_of_variable (const struct varobj *parent)
 670 {
 671   return c_name_of_variable (parent);
 672 }
 673
 674 static void
 675 cplus_describe_child (const struct varobj *parent, int index,
 676                       std::string *cname, struct value **cvalue, struct type **ctype,
 677                       std::string *cfull_expression)
 678 {
 679   struct value *value;
 680   struct type *type;
 681   int was_ptr;
 682   int lookup_actual_type = 0;
 683   const char *parent_expression = NULL;
 684   const struct varobj *var;
 685   struct value_print_options opts;
 686
 687   if (cname)
 688     *cname = std::string ();
 689   if (cvalue)
 690     *cvalue = NULL;
 691   if (ctype)
 692     *ctype = NULL;
 693   if (cfull_expression)
 694     *cfull_expression = std::string ();
 695
 696   get_user_print_options (&opts);
 697
 698   var = (CPLUS_FAKE_CHILD (parent)) ? parent->parent : parent;
 699   if (opts.objectprint)
 700     lookup_actual_type = var->type->is_pointer_or_reference ();
 701   value = var->value.get ();
 702   type = varobj_get_value_type (var);
 703   if (cfull_expression)
 704     parent_expression
 705       = varobj_get_path_expr (varobj_get_path_expr_parent (var));
 706
 707   adjust_value_for_child_access (&value, &type, &was_ptr, lookup_actual_type);
 708
 709   if (type->code () == TYPE_CODE_STRUCT
 710       || type->code () == TYPE_CODE_UNION)
 711     {
 712       const char *join = was_ptr ? "->" : ".";
 713
 714       if (CPLUS_FAKE_CHILD (parent))
 715         {
 716           /* The fields of the class type are ordered as they
 717              appear in the class.  We are given an index for a
 718              particular access control type ("public","protected",
 719              or "private").  We must skip over fields that don't
 720              have the access control we are looking for to properly
 721              find the indexed field.  */
 722           int type_index = TYPE_N_BASECLASSES (type);
 723           enum accessibility acc = accessibility::PUBLIC;
 724           int vptr_fieldno;
 725           struct type *basetype = NULL;
 726           const char *field_name;
 727
 728           vptr_fieldno = get_vptr_fieldno (type, &basetype);
 729           if (parent->name == "private")
 730             acc = accessibility::PRIVATE;
 731           else if (parent->name == "protected")
 732             acc = accessibility::PROTECTED;
 733
 734           while (index >= 0)
 735             {
 736               if ((type == basetype && type_index == vptr_fieldno)
 737                   || type->field (type_index).is_artificial ())
 738                 ; /* ignore vptr */
 739               else if (type->field (type_index).accessibility () == acc)
 740                 --index;
 741               ++type_index;
 742             }
 743           --type_index;
 744
 745           /* If the type is anonymous and the field has no name,
 746              set an appropriate name.  */
 747           field_name = type->field (type_index).name ();
 748           if (field_name == NULL || *field_name == '\0')
 749             {
 750               if (cname)
 751                 {
 752                   if (type->field (type_index).type ()->code ()
 753                       == TYPE_CODE_STRUCT)
 754                     *cname = ANONYMOUS_STRUCT_NAME;
 755                   else if (type->field (type_index).type ()->code ()
 756                            == TYPE_CODE_UNION)
 757                     *cname = ANONYMOUS_UNION_NAME;
 758                 }
 759
 760               if (cfull_expression)
 761                 *cfull_expression = std::string ();
 762             }
 763           else
 764             {
 765               if (cname)
 766                 *cname = type->field (type_index).name ();
 767
 768               if (cfull_expression)
 769                 *cfull_expression
 770                   = string_printf ("((%s)%s%s)", parent_expression, join,
 771                                    field_name);
 772             }
 773
 774           if (cvalue && value)
 775             *cvalue = value_struct_element_index (value, type_index);
 776
 777           if (ctype)
 778             *ctype = type->field (type_index).type ();
 779         }
 780       else if (index < TYPE_N_BASECLASSES (type))
 781         {
 782           /* This is a baseclass.  */
 783           if (cname)
 784             *cname = type->field (index).name ();
 785
 786           if (cvalue && value)
 787             *cvalue = value_cast (type->field (index).type (), value);
 788
 789           if (ctype)
 790             {
 791               *ctype = type->field (index).type ();
 792             }
 793
 794           if (cfull_expression)
 795             {
 796               const char *ptr = was_ptr ? "*" : "";
 797
 798               /* Cast the parent to the base' type.  Note that in gdb,
 799                  expression like
 800                          (Base1)d
 801                  will create an lvalue, for all appearances, so we don't
 802                  need to use more fancy:
 803                          *(Base1*)(&d)
 804                  construct.
 805
 806                  When we are in the scope of the base class or of one
 807                  of its children, the type field name will be interpreted
 808                  as a constructor, if it exists.  Therefore, we must
 809                  indicate that the name is a class name by using the
 810                  'class' keyword.  See PR mi/11912  */
 811               *cfull_expression = string_printf ("(%s(class %s%s) %s)",
 812                                                  ptr,
 813                                                  type->field (index).name (),
 814                                                  ptr,
 815                                                  parent_expression);
 816             }
 817         }
 818       else
 819         {
 820           const char *access = NULL;
 821           int children[3];
 822
 823           cplus_class_num_children (type, children);
 824
 825           /* Everything beyond the baseclasses can
 826              only be "public", "private", or "protected"
 827
 828              The special "fake" children are always output by varobj in
 829              this order.  So if INDEX == 2, it MUST be "protected".  */
 830           index -= TYPE_N_BASECLASSES (type);
 831           switch (index)
 832             {
 833             case 0:
 834               if (children[v_public] > 0)
 835                 access = "public";
 836               else if (children[v_private] > 0)
 837                 access = "private";
 838               else
 839                 access = "protected";
 840               break;
 841             case 1:
 842               if (children[v_public] > 0)
 843                 {
 844                   if (children[v_private] > 0)
 845                     access = "private";
 846                   else
 847                     access = "protected";
 848                 }
 849               else if (children[v_private] > 0)
 850                 access = "protected";
 851               break;
 852             case 2:
 853               /* Must be protected.  */
 854               access = "protected";
 855               break;
 856             default:
 857               /* error!  */
 858               break;
 859             }
 860
 861           gdb_assert (access);
 862           if (cname)
 863             *cname = access;
 864
 865           /* Value and type and full expression are null here.  */
 866         }
 867     }
 868   else
 869     {
 870       c_describe_child (parent, index, cname, cvalue, ctype, cfull_expression);
 871     }
 872 }
 873
 874 static std::string
 875 cplus_name_of_child (const struct varobj *parent, int index)
 876 {
 877   std::string name;
 878
 879   cplus_describe_child (parent, index, &name, NULL, NULL, NULL);
 880   return name;
 881 }
 882
 883 static std::string
 884 cplus_path_expr_of_child (const struct varobj *child)
 885 {
 886   std::string path_expr;
 887
 888   cplus_describe_child (child->parent, child->index, NULL, NULL, NULL,
 889                         &path_expr);
 890   return path_expr;
 891 }
 892
 893 static struct value *
 894 cplus_value_of_child (const struct varobj *parent, int index)
 895 {
 896   struct value *value = NULL;
 897
 898   cplus_describe_child (parent, index, NULL, &value, NULL, NULL);
 899   return value;
 900 }
 901
 902 static struct type *
 903 cplus_type_of_child (const struct varobj *parent, int index)
 904 {
 905   struct type *type = NULL;
 906
 907   cplus_describe_child (parent, index, NULL, NULL, &type, NULL);
 908   return type;
 909 }
 910
 911 static std::string
 912 cplus_value_of_variable (const struct varobj *var,
 913                          enum varobj_display_formats format)
 914 {
 915
 916   /* If we have one of our special types, don't print out
 917      any value.  */
 918   if (CPLUS_FAKE_CHILD (var))
 919     return std::string ();
 920
 921   return c_value_of_variable (var, format);
 922 }
 923 \f
 924
 925 /* varobj operations for c++.  */
 926
 927 const struct lang_varobj_ops cplus_varobj_ops =
 928 {
 929    cplus_number_of_children,
 930    cplus_name_of_variable,
 931    cplus_name_of_child,
 932    cplus_path_expr_of_child,
 933    cplus_value_of_child,
 934    cplus_type_of_child,
 935    cplus_value_of_variable,
 936    varobj_default_value_is_changeable_p,
 937    NULL, /* value_has_mutated */
 938    c_is_path_expr_parent  /* is_path_expr_parent */
 939 };
 940
 941 \f