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       /* If we have a virtual table pointer, omit it.  Even if virtual
 651          table pointers are not specifically marked in the debug info,
 652          they should be artificial.  */
 653       if ((type == basetype && i == vptr_fieldno)
 654           || TYPE_FIELD_ARTIFICIAL (type, i))
 655         continue;
 656
 657       if (TYPE_FIELD_PROTECTED (type, i))
 658         children[v_protected]++;
 659       else if (TYPE_FIELD_PRIVATE (type, i))
 660         children[v_private]++;
 661       else
 662         children[v_public]++;
 663     }
 664 }
 665
 666 static std::string
 667 cplus_name_of_variable (const struct varobj *parent)
 668 {
 669   return c_name_of_variable (parent);
 670 }
 671
 672 enum accessibility { private_field, protected_field, public_field };
 673
 674 /* Check if field INDEX of TYPE has the specified accessibility.
 675    Return 0 if so and 1 otherwise.  */
 676
 677 static int
 678 match_accessibility (struct type *type, int index, enum accessibility acc)
 679 {
 680   if (acc == private_field && TYPE_FIELD_PRIVATE (type, index))
 681     return 1;
 682   else if (acc == protected_field && TYPE_FIELD_PROTECTED (type, index))
 683     return 1;
 684   else if (acc == public_field && !TYPE_FIELD_PRIVATE (type, index)
 685            && !TYPE_FIELD_PROTECTED (type, index))
 686     return 1;
 687   else
 688     return 0;
 689 }
 690
 691 static void
 692 cplus_describe_child (const struct varobj *parent, int index,
 693                       std::string *cname, struct value **cvalue, struct type **ctype,
 694                       std::string *cfull_expression)
 695 {
 696   struct value *value;
 697   struct type *type;
 698   int was_ptr;
 699   int lookup_actual_type = 0;
 700   const char *parent_expression = NULL;
 701   const struct varobj *var;
 702   struct value_print_options opts;
 703
 704   if (cname)
 705     *cname = std::string ();
 706   if (cvalue)
 707     *cvalue = NULL;
 708   if (ctype)
 709     *ctype = NULL;
 710   if (cfull_expression)
 711     *cfull_expression = std::string ();
 712
 713   get_user_print_options (&opts);
 714
 715   var = (CPLUS_FAKE_CHILD (parent)) ? parent->parent : parent;
 716   if (opts.objectprint)
 717     lookup_actual_type = var->type->is_pointer_or_reference ();
 718   value = var->value.get ();
 719   type = varobj_get_value_type (var);
 720   if (cfull_expression)
 721     parent_expression
 722       = varobj_get_path_expr (varobj_get_path_expr_parent (var));
 723
 724   adjust_value_for_child_access (&value, &type, &was_ptr, lookup_actual_type);
 725
 726   if (type->code () == TYPE_CODE_STRUCT
 727       || type->code () == TYPE_CODE_UNION)
 728     {
 729       const char *join = was_ptr ? "->" : ".";
 730
 731       if (CPLUS_FAKE_CHILD (parent))
 732         {
 733           /* The fields of the class type are ordered as they
 734              appear in the class.  We are given an index for a
 735              particular access control type ("public","protected",
 736              or "private").  We must skip over fields that don't
 737              have the access control we are looking for to properly
 738              find the indexed field.  */
 739           int type_index = TYPE_N_BASECLASSES (type);
 740           enum accessibility acc = public_field;
 741           int vptr_fieldno;
 742           struct type *basetype = NULL;
 743           const char *field_name;
 744
 745           vptr_fieldno = get_vptr_fieldno (type, &basetype);
 746           if (parent->name == "private")
 747             acc = private_field;
 748           else if (parent->name == "protected")
 749             acc = protected_field;
 750
 751           while (index >= 0)
 752             {
 753               if ((type == basetype && type_index == vptr_fieldno)
 754                   || TYPE_FIELD_ARTIFICIAL (type, type_index))
 755                 ; /* ignore vptr */
 756               else if (match_accessibility (type, type_index, acc))
 757                     --index;
 758                   ++type_index;
 759             }
 760           --type_index;
 761
 762           /* If the type is anonymous and the field has no name,
 763              set an appropriate name.  */
 764           field_name = type->field (type_index).name ();
 765           if (field_name == NULL || *field_name == '\0')
 766             {
 767               if (cname)
 768                 {
 769                   if (type->field (type_index).type ()->code ()
 770                       == TYPE_CODE_STRUCT)
 771                     *cname = ANONYMOUS_STRUCT_NAME;
 772                   else if (type->field (type_index).type ()->code ()
 773                            == TYPE_CODE_UNION)
 774                     *cname = ANONYMOUS_UNION_NAME;
 775                 }
 776
 777               if (cfull_expression)
 778                 *cfull_expression = std::string ();
 779             }
 780           else
 781             {
 782               if (cname)
 783                 *cname = type->field (type_index).name ();
 784
 785               if (cfull_expression)
 786                 *cfull_expression
 787                   = string_printf ("((%s)%s%s)", parent_expression, join,
 788                                    field_name);
 789             }
 790
 791           if (cvalue && value)
 792             *cvalue = value_struct_element_index (value, type_index);
 793
 794           if (ctype)
 795             *ctype = type->field (type_index).type ();
 796         }
 797       else if (index < TYPE_N_BASECLASSES (type))
 798         {
 799           /* This is a baseclass.  */
 800           if (cname)
 801             *cname = type->field (index).name ();
 802
 803           if (cvalue && value)
 804             *cvalue = value_cast (type->field (index).type (), value);
 805
 806           if (ctype)
 807             {
 808               *ctype = type->field (index).type ();
 809             }
 810
 811           if (cfull_expression)
 812             {
 813               const char *ptr = was_ptr ? "*" : "";
 814
 815               /* Cast the parent to the base' type.  Note that in gdb,
 816                  expression like
 817                          (Base1)d
 818                  will create an lvalue, for all appearances, so we don't
 819                  need to use more fancy:
 820                          *(Base1*)(&d)
 821                  construct.
 822
 823                  When we are in the scope of the base class or of one
 824                  of its children, the type field name will be interpreted
 825                  as a constructor, if it exists.  Therefore, we must
 826                  indicate that the name is a class name by using the
 827                  'class' keyword.  See PR mi/11912  */
 828               *cfull_expression = string_printf ("(%s(class %s%s) %s)",
 829                                                  ptr,
 830                                                  type->field (index).name (),
 831                                                  ptr,
 832                                                  parent_expression);
 833             }
 834         }
 835       else
 836         {
 837           const char *access = NULL;
 838           int children[3];
 839
 840           cplus_class_num_children (type, children);
 841
 842           /* Everything beyond the baseclasses can
 843              only be "public", "private", or "protected"
 844
 845              The special "fake" children are always output by varobj in
 846              this order.  So if INDEX == 2, it MUST be "protected".  */
 847           index -= TYPE_N_BASECLASSES (type);
 848           switch (index)
 849             {
 850             case 0:
 851               if (children[v_public] > 0)
 852                 access = "public";
 853               else if (children[v_private] > 0)
 854                 access = "private";
 855               else
 856                 access = "protected";
 857               break;
 858             case 1:
 859               if (children[v_public] > 0)
 860                 {
 861                   if (children[v_private] > 0)
 862                     access = "private";
 863                   else
 864                     access = "protected";
 865                 }
 866               else if (children[v_private] > 0)
 867                 access = "protected";
 868               break;
 869             case 2:
 870               /* Must be protected.  */
 871               access = "protected";
 872               break;
 873             default:
 874               /* error!  */
 875               break;
 876             }
 877
 878           gdb_assert (access);
 879           if (cname)
 880             *cname = access;
 881
 882           /* Value and type and full expression are null here.  */
 883         }
 884     }
 885   else
 886     {
 887       c_describe_child (parent, index, cname, cvalue, ctype, cfull_expression);
 888     }
 889 }
 890
 891 static std::string
 892 cplus_name_of_child (const struct varobj *parent, int index)
 893 {
 894   std::string name;
 895
 896   cplus_describe_child (parent, index, &name, NULL, NULL, NULL);
 897   return name;
 898 }
 899
 900 static std::string
 901 cplus_path_expr_of_child (const struct varobj *child)
 902 {
 903   std::string path_expr;
 904
 905   cplus_describe_child (child->parent, child->index, NULL, NULL, NULL,
 906                         &path_expr);
 907   return path_expr;
 908 }
 909
 910 static struct value *
 911 cplus_value_of_child (const struct varobj *parent, int index)
 912 {
 913   struct value *value = NULL;
 914
 915   cplus_describe_child (parent, index, NULL, &value, NULL, NULL);
 916   return value;
 917 }
 918
 919 static struct type *
 920 cplus_type_of_child (const struct varobj *parent, int index)
 921 {
 922   struct type *type = NULL;
 923
 924   cplus_describe_child (parent, index, NULL, NULL, &type, NULL);
 925   return type;
 926 }
 927
 928 static std::string
 929 cplus_value_of_variable (const struct varobj *var,
 930                          enum varobj_display_formats format)
 931 {
 932
 933   /* If we have one of our special types, don't print out
 934      any value.  */
 935   if (CPLUS_FAKE_CHILD (var))
 936     return std::string ();
 937
 938   return c_value_of_variable (var, format);
 939 }
 940 \f
 941
 942 /* varobj operations for c++.  */
 943
 944 const struct lang_varobj_ops cplus_varobj_ops =
 945 {
 946    cplus_number_of_children,
 947    cplus_name_of_variable,
 948    cplus_name_of_child,
 949    cplus_path_expr_of_child,
 950    cplus_value_of_child,
 951    cplus_type_of_child,
 952    cplus_value_of_variable,
 953    varobj_default_value_is_changeable_p,
 954    NULL, /* value_has_mutated */
 955    c_is_path_expr_parent  /* is_path_expr_parent */
 956 };
 957
 958 \f