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 (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 (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       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 (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 (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 (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 (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 (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 (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 (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 (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 (struct varobj *var, enum varobj_display_formats format)
 478 {
 479   /* BOGUS: if val_print sees a struct/class, or a reference to one,
 480      it will print out its children instead of "{...}".  So we need to
 481      catch that case explicitly.  */
 482   struct type *type = get_type (var);
 483
 484   /* Strip top-level references.  */
 485   while (TYPE_CODE (type) == TYPE_CODE_REF)
 486     type = check_typedef (TYPE_TARGET_TYPE (type));
 487
 488   switch (TYPE_CODE (type))
 489     {
 490     case TYPE_CODE_STRUCT:
 491     case TYPE_CODE_UNION:
 492       return xstrdup ("{...}");
 493       /* break; */
 494
 495     case TYPE_CODE_ARRAY:
 496       {
 497         char *number;
 498
 499         number = xstrprintf ("[%d]", var->num_children);
 500         return (number);
 501       }
 502       /* break; */
 503
 504     default:
 505       {
 506         if (var->value == NULL)
 507           {
 508             /* This can happen if we attempt to get the value of a struct
 509                member when the parent is an invalid pointer.  This is an
 510                error condition, so we should tell the caller.  */
 511             return NULL;
 512           }
 513         else
 514           {
 515             if (var->not_fetched && value_lazy (var->value))
 516               /* Frozen variable and no value yet.  We don't
 517                  implicitly fetch the value.  MI response will
 518                  use empty string for the value, which is OK.  */
 519               return NULL;
 520
 521             gdb_assert (varobj_value_is_changeable_p (var));
 522             gdb_assert (!value_lazy (var->value));
 523
 524             /* If the specified format is the current one,
 525                we can reuse print_value.  */
 526             if (format == var->format)
 527               return xstrdup (var->print_value);
 528             else
 529               return varobj_value_get_print_value (var->value, format, var);
 530           }
 531       }
 532     }
 533 }
 534 \f
 535
 536 /* varobj operations for c.  */
 537
 538 const struct lang_varobj_ops c_varobj_ops =
 539 {
 540    c_number_of_children,
 541    c_name_of_variable,
 542    c_name_of_child,
 543    c_path_expr_of_child,
 544    c_value_of_child,
 545    c_type_of_child,
 546    c_value_of_variable,
 547    varobj_default_value_is_changeable_p,
 548    NULL, /* value_has_mutated */
 549    c_is_path_expr_parent  /* is_path_expr_parent */
 550 };
 551
 552 /* A little convenience enum for dealing with C++/Java.  */
 553 enum vsections
 554 {
 555   v_public = 0, v_private, v_protected
 556 };
 557
 558 /* C++ */
 559
 560 static int
 561 cplus_number_of_children (struct varobj *var)
 562 {
 563   struct value *value = NULL;
 564   struct type *type;
 565   int children, dont_know;
 566   int lookup_actual_type = 0;
 567   struct value_print_options opts;
 568
 569   dont_know = 1;
 570   children = 0;
 571
 572   get_user_print_options (&opts);
 573
 574   if (!CPLUS_FAKE_CHILD (var))
 575     {
 576       type = varobj_get_value_type (var);
 577
 578       /* It is necessary to access a real type (via RTTI).  */
 579       if (opts.objectprint)
 580         {
 581           value = var->value;
 582           lookup_actual_type = (TYPE_CODE (var->type) == TYPE_CODE_REF
 583                                 || TYPE_CODE (var->type) == TYPE_CODE_PTR);
 584         }
 585       adjust_value_for_child_access (&value, &type, NULL, lookup_actual_type);
 586
 587       if (((TYPE_CODE (type)) == TYPE_CODE_STRUCT)
 588           || ((TYPE_CODE (type)) == TYPE_CODE_UNION))
 589         {
 590           int kids[3];
 591
 592           cplus_class_num_children (type, kids);
 593           if (kids[v_public] != 0)
 594             children++;
 595           if (kids[v_private] != 0)
 596             children++;
 597           if (kids[v_protected] != 0)
 598             children++;
 599
 600           /* Add any baseclasses.  */
 601           children += TYPE_N_BASECLASSES (type);
 602           dont_know = 0;
 603
 604           /* FIXME: save children in var.  */
 605         }
 606     }
 607   else
 608     {
 609       int kids[3];
 610
 611       type = varobj_get_value_type (var->parent);
 612
 613       /* It is necessary to access a real type (via RTTI).  */
 614       if (opts.objectprint)
 615         {
 616           struct varobj *parent = var->parent;
 617
 618           value = parent->value;
 619           lookup_actual_type = (TYPE_CODE (parent->type) == TYPE_CODE_REF
 620                                 || TYPE_CODE (parent->type) == TYPE_CODE_PTR);
 621         }
 622       adjust_value_for_child_access (&value, &type, NULL, lookup_actual_type);
 623
 624       cplus_class_num_children (type, kids);
 625       if (strcmp (var->name, "public") == 0)
 626         children = kids[v_public];
 627       else if (strcmp (var->name, "private") == 0)
 628         children = kids[v_private];
 629       else
 630         children = kids[v_protected];
 631       dont_know = 0;
 632     }
 633
 634   if (dont_know)
 635     children = c_number_of_children (var);
 636
 637   return children;
 638 }
 639
 640 /* Compute # of public, private, and protected variables in this class.
 641    That means we need to descend into all baseclasses and find out
 642    how many are there, too.  */
 643
 644 static void
 645 cplus_class_num_children (struct type *type, int children[3])
 646 {
 647   int i, vptr_fieldno;
 648   struct type *basetype = NULL;
 649
 650   children[v_public] = 0;
 651   children[v_private] = 0;
 652   children[v_protected] = 0;
 653
 654   vptr_fieldno = get_vptr_fieldno (type, &basetype);
 655   for (i = TYPE_N_BASECLASSES (type); i < TYPE_NFIELDS (type); i++)
 656     {
 657       /* If we have a virtual table pointer, omit it.  Even if virtual
 658          table pointers are not specifically marked in the debug info,
 659          they should be artificial.  */
 660       if ((type == basetype && i == vptr_fieldno)
 661           || TYPE_FIELD_ARTIFICIAL (type, i))
 662         continue;
 663
 664       if (TYPE_FIELD_PROTECTED (type, i))
 665         children[v_protected]++;
 666       else if (TYPE_FIELD_PRIVATE (type, i))
 667         children[v_private]++;
 668       else
 669         children[v_public]++;
 670     }
 671 }
 672
 673 static char *
 674 cplus_name_of_variable (struct varobj *parent)
 675 {
 676   return c_name_of_variable (parent);
 677 }
 678
 679 enum accessibility { private_field, protected_field, public_field };
 680
 681 /* Check if field INDEX of TYPE has the specified accessibility.
 682    Return 0 if so and 1 otherwise.  */
 683
 684 static int
 685 match_accessibility (struct type *type, int index, enum accessibility acc)
 686 {
 687   if (acc == private_field && TYPE_FIELD_PRIVATE (type, index))
 688     return 1;
 689   else if (acc == protected_field && TYPE_FIELD_PROTECTED (type, index))
 690     return 1;
 691   else if (acc == public_field && !TYPE_FIELD_PRIVATE (type, index)
 692            && !TYPE_FIELD_PROTECTED (type, index))
 693     return 1;
 694   else
 695     return 0;
 696 }
 697
 698 static void
 699 cplus_describe_child (struct varobj *parent, int index,
 700                       char **cname, struct value **cvalue, struct type **ctype,
 701                       char **cfull_expression)
 702 {
 703   struct value *value;
 704   struct type *type;
 705   int was_ptr;
 706   int lookup_actual_type = 0;
 707   char *parent_expression = NULL;
 708   struct varobj *var;
 709   struct value_print_options opts;
 710
 711   if (cname)
 712     *cname = NULL;
 713   if (cvalue)
 714     *cvalue = NULL;
 715   if (ctype)
 716     *ctype = NULL;
 717   if (cfull_expression)
 718     *cfull_expression = NULL;
 719
 720   get_user_print_options (&opts);
 721
 722   var = (CPLUS_FAKE_CHILD (parent)) ? parent->parent : parent;
 723   if (opts.objectprint)
 724     lookup_actual_type = (TYPE_CODE (var->type) == TYPE_CODE_REF
 725                           || TYPE_CODE (var->type) == TYPE_CODE_PTR);
 726   value = var->value;
 727   type = varobj_get_value_type (var);
 728   if (cfull_expression)
 729     parent_expression
 730       = varobj_get_path_expr (varobj_get_path_expr_parent (var));
 731
 732   adjust_value_for_child_access (&value, &type, &was_ptr, lookup_actual_type);
 733
 734   if (TYPE_CODE (type) == TYPE_CODE_STRUCT
 735       || TYPE_CODE (type) == TYPE_CODE_UNION)
 736     {
 737       char *join = was_ptr ? "->" : ".";
 738
 739       if (CPLUS_FAKE_CHILD (parent))
 740         {
 741           /* The fields of the class type are ordered as they
 742              appear in the class.  We are given an index for a
 743              particular access control type ("public","protected",
 744              or "private").  We must skip over fields that don't
 745              have the access control we are looking for to properly
 746              find the indexed field.  */
 747           int type_index = TYPE_N_BASECLASSES (type);
 748           enum accessibility acc = public_field;
 749           int vptr_fieldno;
 750           struct type *basetype = NULL;
 751           const char *field_name;
 752
 753           vptr_fieldno = get_vptr_fieldno (type, &basetype);
 754           if (strcmp (parent->name, "private") == 0)
 755             acc = private_field;
 756           else if (strcmp (parent->name, "protected") == 0)
 757             acc = protected_field;
 758
 759           while (index >= 0)
 760             {
 761               if ((type == basetype && type_index == vptr_fieldno)
 762                   || TYPE_FIELD_ARTIFICIAL (type, type_index))
 763                 ; /* ignore vptr */
 764               else if (match_accessibility (type, type_index, acc))
 765                     --index;
 766                   ++type_index;
 767             }
 768           --type_index;
 769
 770           /* If the type is anonymous and the field has no name,
 771              set an appopriate name.  */
 772           field_name = TYPE_FIELD_NAME (type, type_index);
 773           if (field_name == NULL || *field_name == '\0')
 774             {
 775               if (cname)
 776                 {
 777                   if (TYPE_CODE (TYPE_FIELD_TYPE (type, type_index))
 778                       == TYPE_CODE_STRUCT)
 779                     *cname = xstrdup (ANONYMOUS_STRUCT_NAME);
 780                   else if (TYPE_CODE (TYPE_FIELD_TYPE (type, type_index))
 781                            == TYPE_CODE_UNION)
 782                     *cname = xstrdup (ANONYMOUS_UNION_NAME);
 783                 }
 784
 785               if (cfull_expression)
 786                 *cfull_expression = xstrdup ("");
 787             }
 788           else
 789             {
 790               if (cname)
 791                 *cname = xstrdup (TYPE_FIELD_NAME (type, type_index));
 792
 793               if (cfull_expression)
 794                 *cfull_expression
 795                   = xstrprintf ("((%s)%s%s)", parent_expression, join,
 796                                 field_name);
 797             }
 798
 799           if (cvalue && value)
 800             *cvalue = value_struct_element_index (value, type_index);
 801
 802           if (ctype)
 803             *ctype = TYPE_FIELD_TYPE (type, type_index);
 804         }
 805       else if (index < TYPE_N_BASECLASSES (type))
 806         {
 807           /* This is a baseclass.  */
 808           if (cname)
 809             *cname = xstrdup (TYPE_FIELD_NAME (type, index));
 810
 811           if (cvalue && value)
 812             *cvalue = value_cast (TYPE_FIELD_TYPE (type, index), value);
 813
 814           if (ctype)
 815             {
 816               *ctype = TYPE_FIELD_TYPE (type, index);
 817             }
 818
 819           if (cfull_expression)
 820             {
 821               char *ptr = was_ptr ? "*" : "";
 822
 823               /* Cast the parent to the base' type.  Note that in gdb,
 824                  expression like
 825                          (Base1)d
 826                  will create an lvalue, for all appearences, so we don't
 827                  need to use more fancy:
 828                          *(Base1*)(&d)
 829                  construct.
 830
 831                  When we are in the scope of the base class or of one
 832                  of its children, the type field name will be interpreted
 833                  as a constructor, if it exists.  Therefore, we must
 834                  indicate that the name is a class name by using the
 835                  'class' keyword.  See PR mi/11912  */
 836               *cfull_expression = xstrprintf ("(%s(class %s%s) %s)",
 837                                               ptr,
 838                                               TYPE_FIELD_NAME (type, index),
 839                                               ptr,
 840                                               parent_expression);
 841             }
 842         }
 843       else
 844         {
 845           char *access = NULL;
 846           int children[3];
 847
 848           cplus_class_num_children (type, children);
 849
 850           /* Everything beyond the baseclasses can
 851              only be "public", "private", or "protected"
 852
 853              The special "fake" children are always output by varobj in
 854              this order.  So if INDEX == 2, it MUST be "protected".  */
 855           index -= TYPE_N_BASECLASSES (type);
 856           switch (index)
 857             {
 858             case 0:
 859               if (children[v_public] > 0)
 860                 access = "public";
 861               else if (children[v_private] > 0)
 862                 access = "private";
 863               else
 864                 access = "protected";
 865               break;
 866             case 1:
 867               if (children[v_public] > 0)
 868                 {
 869                   if (children[v_private] > 0)
 870                     access = "private";
 871                   else
 872                     access = "protected";
 873                 }
 874               else if (children[v_private] > 0)
 875                 access = "protected";
 876               break;
 877             case 2:
 878               /* Must be protected.  */
 879               access = "protected";
 880               break;
 881             default:
 882               /* error!  */
 883               break;
 884             }
 885
 886           gdb_assert (access);
 887           if (cname)
 888             *cname = xstrdup (access);
 889
 890           /* Value and type and full expression are null here.  */
 891         }
 892     }
 893   else
 894     {
 895       c_describe_child (parent, index, cname, cvalue, ctype, cfull_expression);
 896     }
 897 }
 898
 899 static char *
 900 cplus_name_of_child (struct varobj *parent, int index)
 901 {
 902   char *name = NULL;
 903
 904   cplus_describe_child (parent, index, &name, NULL, NULL, NULL);
 905   return name;
 906 }
 907
 908 static char *
 909 cplus_path_expr_of_child (struct varobj *child)
 910 {
 911   char *path_expr;
 912
 913   cplus_describe_child (child->parent, child->index, NULL, NULL, NULL,
 914                         &path_expr);
 915   return path_expr;
 916 }
 917
 918 static struct value *
 919 cplus_value_of_child (struct varobj *parent, int index)
 920 {
 921   struct value *value = NULL;
 922
 923   cplus_describe_child (parent, index, NULL, &value, NULL, NULL);
 924   return value;
 925 }
 926
 927 static struct type *
 928 cplus_type_of_child (struct varobj *parent, int index)
 929 {
 930   struct type *type = NULL;
 931
 932   cplus_describe_child (parent, index, NULL, NULL, &type, NULL);
 933   return type;
 934 }
 935
 936 static char *
 937 cplus_value_of_variable (struct varobj *var,
 938                          enum varobj_display_formats format)
 939 {
 940
 941   /* If we have one of our special types, don't print out
 942      any value.  */
 943   if (CPLUS_FAKE_CHILD (var))
 944     return xstrdup ("");
 945
 946   return c_value_of_variable (var, format);
 947 }
 948 \f
 949
 950 /* varobj operations for c++.  */
 951
 952 const struct lang_varobj_ops cplus_varobj_ops =
 953 {
 954    cplus_number_of_children,
 955    cplus_name_of_variable,
 956    cplus_name_of_child,
 957    cplus_path_expr_of_child,
 958    cplus_value_of_child,
 959    cplus_type_of_child,
 960    cplus_value_of_variable,
 961    varobj_default_value_is_changeable_p,
 962    NULL, /* value_has_mutated */
 963    c_is_path_expr_parent  /* is_path_expr_parent */
 964 };
 965
 966 \f