gdb/c-varobj.c

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