gdb/c-varobj.c

   1 /* varobj support for C and C++.
   2
   3    Copyright (C) 1999-2015 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 int
  38 varobj_is_anonymous_child (const struct varobj *child)
  39 {
  40   return (strcmp (child->name, ANONYMOUS_STRUCT_NAME) == 0
  41           || strcmp (child->name, ANONYMOUS_UNION_NAME) == 0);
  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_CODE (*type) != TYPE_CODE_REF);
  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               volatile struct gdb_exception except;
  95
  96               TRY_CATCH (except, RETURN_MASK_ERROR)
  97                 {
  98                   *value = value_ind (*value);
  99                 }
 100
 101               if (except.reason < 0)
 102                 *value = NULL;
 103             }
 104           *type = target_type;
 105           if (was_ptr)
 106             *was_ptr = 1;
 107         }
 108     }
 109
 110   /* The 'get_target_type' function calls check_typedef on
 111      result, so we can immediately check type code.  No
 112      need to call check_typedef here.  */
 113
 114   /* Access a real type of the value (if necessary and possible).  */
 115   if (value && *value && lookup_actual_type)
 116     {
 117       struct type *enclosing_type;
 118       int real_type_found = 0;
 119
 120       enclosing_type = value_actual_type (*value, 1, &real_type_found);
 121       if (real_type_found)
 122         {
 123           *type = enclosing_type;
 124           *value = value_cast (enclosing_type, *value);
 125         }
 126     }
 127 }
 128
 129 /* Is VAR a path expression parent, i.e., can it be used to construct
 130    a valid path expression?  */
 131
 132 static int
 133 c_is_path_expr_parent (const struct varobj *var)
 134 {
 135   struct type *type;
 136
 137   /* "Fake" children are not path_expr parents.  */
 138   if (CPLUS_FAKE_CHILD (var))
 139     return 0;
 140
 141   type = varobj_get_gdb_type (var);
 142
 143   /* Anonymous unions and structs are also not path_expr parents.  */
 144   if ((TYPE_CODE (type) == TYPE_CODE_STRUCT
 145        || TYPE_CODE (type) == TYPE_CODE_UNION)
 146       && TYPE_NAME (type) == NULL
 147       && TYPE_TAG_NAME (type) == NULL)
 148     {
 149       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 (TYPE_CODE (parent_type) == TYPE_CODE_STRUCT
 163               || TYPE_CODE (parent_type) == TYPE_CODE_UNION)
 164             {
 165               const char *field_name;
 166
 167               gdb_assert (var->index < TYPE_NFIELDS (parent_type));
 168               field_name = TYPE_FIELD_NAME (parent_type, var->index);
 169               return !(field_name == NULL || *field_name == '\0');
 170             }
 171         }
 172
 173       return 0;
 174     }
 175
 176   return 1;
 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 (type))
 192     {
 193     case TYPE_CODE_ARRAY:
 194       if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (target) > 0
 195           && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))
 196         children = TYPE_LENGTH (type) / TYPE_LENGTH (target);
 197       else
 198         /* If we don't know how many elements there are, don't display
 199            any.  */
 200         children = 0;
 201       break;
 202
 203     case TYPE_CODE_STRUCT:
 204     case TYPE_CODE_UNION:
 205       children = TYPE_NFIELDS (type);
 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 (TYPE_CODE (target) == TYPE_CODE_FUNC
 218           || TYPE_CODE (target) == 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 char *
 233 c_name_of_variable (const struct varobj *parent)
 234 {
 235   return xstrdup (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   volatile struct gdb_exception e;
 249   struct type *type = value_type (value);
 250
 251   type = check_typedef (type);
 252
 253   gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT
 254               || TYPE_CODE (type) == TYPE_CODE_UNION);
 255
 256   TRY_CATCH (e, RETURN_MASK_ERROR)
 257     {
 258       if (field_is_static (&TYPE_FIELD (type, type_index)))
 259         result = value_static_field (type, type_index);
 260       else
 261         result = value_primitive_field (value, 0, type_index, type);
 262     }
 263   if (e.reason < 0)
 264     {
 265       return NULL;
 266     }
 267   else
 268     {
 269       return result;
 270     }
 271 }
 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 NULL.  */
 283
 284 static void
 285 c_describe_child (const struct varobj *parent, int index,
 286                   char **cname, struct value **cvalue, struct type **ctype,
 287                   char **cfull_expression)
 288 {
 289   struct value *value = parent->value;
 290   struct type *type = varobj_get_value_type (parent);
 291   char *parent_expression = NULL;
 292   int was_ptr;
 293   volatile struct gdb_exception except;
 294
 295   if (cname)
 296     *cname = NULL;
 297   if (cvalue)
 298     *cvalue = NULL;
 299   if (ctype)
 300     *ctype = NULL;
 301   if (cfull_expression)
 302     {
 303       *cfull_expression = NULL;
 304       parent_expression
 305         = varobj_get_path_expr (varobj_get_path_expr_parent (parent));
 306     }
 307   adjust_value_for_child_access (&value, &type, &was_ptr, 0);
 308
 309   switch (TYPE_CODE (type))
 310     {
 311     case TYPE_CODE_ARRAY:
 312       if (cname)
 313         *cname
 314           = xstrdup (int_string (index
 315                                  + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)),
 316                                  10, 1, 0, 0));
 317
 318       if (cvalue && value)
 319         {
 320           int real_index = index + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type));
 321
 322           TRY_CATCH (except, RETURN_MASK_ERROR)
 323             {
 324               *cvalue = value_subscript (value, real_index);
 325             }
 326         }
 327
 328       if (ctype)
 329         *ctype = get_target_type (type);
 330
 331       if (cfull_expression)
 332         *cfull_expression =
 333           xstrprintf ("(%s)[%s]", parent_expression,
 334                       int_string (index
 335                                   + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)),
 336                                   10, 1, 0, 0));
 337
 338
 339       break;
 340
 341     case TYPE_CODE_STRUCT:
 342     case TYPE_CODE_UNION:
 343       {
 344         const char *field_name;
 345
 346         /* If the type is anonymous and the field has no name,
 347            set an appropriate name.  */
 348         field_name = TYPE_FIELD_NAME (type, index);
 349         if (field_name == NULL || *field_name == '\0')
 350           {
 351             if (cname)
 352               {
 353                 if (TYPE_CODE (TYPE_FIELD_TYPE (type, index))
 354                     == TYPE_CODE_STRUCT)
 355                   *cname = xstrdup (ANONYMOUS_STRUCT_NAME);
 356                 else
 357                   *cname = xstrdup (ANONYMOUS_UNION_NAME);
 358               }
 359
 360             if (cfull_expression)
 361               *cfull_expression = xstrdup ("");
 362           }
 363         else
 364           {
 365             if (cname)
 366               *cname = xstrdup (field_name);
 367
 368             if (cfull_expression)
 369               {
 370                 char *join = was_ptr ? "->" : ".";
 371
 372                 *cfull_expression = xstrprintf ("(%s)%s%s", parent_expression,
 373                                                 join, field_name);
 374               }
 375           }
 376
 377         if (cvalue && value)
 378           {
 379             /* For C, varobj index is the same as type index.  */
 380             *cvalue = value_struct_element_index (value, index);
 381           }
 382
 383         if (ctype)
 384           *ctype = TYPE_FIELD_TYPE (type, index);
 385       }
 386       break;
 387
 388     case TYPE_CODE_PTR:
 389       if (cname)
 390         *cname = xstrprintf ("*%s", parent->name);
 391
 392       if (cvalue && value)
 393         {
 394           TRY_CATCH (except, RETURN_MASK_ERROR)
 395             {
 396               *cvalue = value_ind (value);
 397             }
 398
 399           if (except.reason < 0)
 400             *cvalue = NULL;
 401         }
 402
 403       /* Don't use get_target_type because it calls
 404          check_typedef and here, we want to show the true
 405          declared type of the variable.  */
 406       if (ctype)
 407         *ctype = TYPE_TARGET_TYPE (type);
 408
 409       if (cfull_expression)
 410         *cfull_expression = xstrprintf ("*(%s)", parent_expression);
 411
 412       break;
 413
 414     default:
 415       /* This should not happen.  */
 416       if (cname)
 417         *cname = xstrdup ("???");
 418       if (cfull_expression)
 419         *cfull_expression = xstrdup ("???");
 420       /* Don't set value and type, we don't know then.  */
 421     }
 422 }
 423
 424 static char *
 425 c_name_of_child (const struct varobj *parent, int index)
 426 {
 427   char *name;
 428
 429   c_describe_child (parent, index, &name, NULL, NULL, NULL);
 430   return name;
 431 }
 432
 433 static char *
 434 c_path_expr_of_child (const struct varobj *child)
 435 {
 436   char *path_expr;
 437
 438   c_describe_child (child->parent, child->index, NULL, NULL, NULL,
 439                     &path_expr);
 440   return path_expr;
 441 }
 442
 443 static struct value *
 444 c_value_of_child (const struct varobj *parent, int index)
 445 {
 446   struct value *value = NULL;
 447
 448   c_describe_child (parent, index, NULL, &value, NULL, NULL);
 449   return value;
 450 }
 451
 452 static struct type *
 453 c_type_of_child (const struct varobj *parent, int index)
 454 {
 455   struct type *type = NULL;
 456
 457   c_describe_child (parent, index, NULL, NULL, &type, NULL);
 458   return type;
 459 }
 460
 461 /* This returns the type of the variable.  It also skips past typedefs
 462    to return the real type of the variable.  */
 463
 464 static struct type *
 465 get_type (const struct varobj *var)
 466 {
 467   struct type *type;
 468
 469   type = var->type;
 470   if (type != NULL)
 471     type = check_typedef (type);
 472
 473   return type;
 474 }
 475
 476 static char *
 477 c_value_of_variable (const struct varobj *var,
 478                      enum varobj_display_formats format)
 479 {
 480   /* BOGUS: if val_print sees a struct/class, or a reference to one,
 481      it will print out its children instead of "{...}".  So we need to
 482      catch that case explicitly.  */
 483   struct type *type = get_type (var);
 484
 485   /* Strip top-level references.  */
 486   while (TYPE_CODE (type) == TYPE_CODE_REF)
 487     type = check_typedef (TYPE_TARGET_TYPE (type));
 488
 489   switch (TYPE_CODE (type))
 490     {
 491     case TYPE_CODE_STRUCT:
 492     case TYPE_CODE_UNION:
 493       return xstrdup ("{...}");
 494       /* break; */
 495
 496     case TYPE_CODE_ARRAY:
 497       {
 498         char *number;
 499
 500         number = xstrprintf ("[%d]", var->num_children);
 501         return (number);
 502       }
 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 NULL;
 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 NULL;
 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 xstrdup (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++/Java.  */
 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_CODE (var->type) == TYPE_CODE_REF
 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_CODE (parent->type) == TYPE_CODE_REF
 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 (strcmp (var->name, "public") == 0)
 627         children = kids[v_public];
 628       else if (strcmp (var->name, "private") == 0)
 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 char *
 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                       char **cname, struct value **cvalue, struct type **ctype,
 702                       char **cfull_expression)
 703 {
 704   struct value *value;
 705   struct type *type;
 706   int was_ptr;
 707   int lookup_actual_type = 0;
 708   char *parent_expression = NULL;
 709   const struct varobj *var;
 710   struct value_print_options opts;
 711
 712   if (cname)
 713     *cname = NULL;
 714   if (cvalue)
 715     *cvalue = NULL;
 716   if (ctype)
 717     *ctype = NULL;
 718   if (cfull_expression)
 719     *cfull_expression = NULL;
 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_CODE (var->type) == TYPE_CODE_REF
 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       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 (strcmp (parent->name, "private") == 0)
 756             acc = private_field;
 757           else if (strcmp (parent->name, "protected") == 0)
 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 = xstrdup (ANONYMOUS_STRUCT_NAME);
 781                   else if (TYPE_CODE (TYPE_FIELD_TYPE (type, type_index))
 782                            == TYPE_CODE_UNION)
 783                     *cname = xstrdup (ANONYMOUS_UNION_NAME);
 784                 }
 785
 786               if (cfull_expression)
 787                 *cfull_expression = xstrdup ("");
 788             }
 789           else
 790             {
 791               if (cname)
 792                 *cname = xstrdup (TYPE_FIELD_NAME (type, type_index));
 793
 794               if (cfull_expression)
 795                 *cfull_expression
 796                   = xstrprintf ("((%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 = xstrdup (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               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 = xstrprintf ("(%s(class %s%s) %s)",
 838                                               ptr,
 839                                               TYPE_FIELD_NAME (type, index),
 840                                               ptr,
 841                                               parent_expression);
 842             }
 843         }
 844       else
 845         {
 846           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 = xstrdup (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 char *
 901 cplus_name_of_child (const struct varobj *parent, int index)
 902 {
 903   char *name = NULL;
 904
 905   cplus_describe_child (parent, index, &name, NULL, NULL, NULL);
 906   return name;
 907 }
 908
 909 static char *
 910 cplus_path_expr_of_child (const struct varobj *child)
 911 {
 912   char *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 char *
 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 xstrdup ("");
 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