c-varobj.c revision 1.7
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 24static 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 37int 38varobj_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 64static void 65adjust_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 134static int 135c_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 0; 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 0; 176 } 177 178 return 1; 179} 180 181/* C */ 182 183static int 184c_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 234static std::string 235c_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 246static struct value * 247value_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 284static void 285c_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 429static std::string 430c_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 438static std::string 439c_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 448static struct value * 449c_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 457static struct type * 458c_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 469static struct type * 470get_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 481static std::string 482c_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 536 537/* varobj operations for c. */ 538 539const 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++. */ 554enum vsections 555{ 556 v_public = 0, v_private, v_protected 557}; 558 559/* C++ */ 560 561static int 562cplus_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 645static void 646cplus_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 674static std::string 675cplus_name_of_variable (const struct varobj *parent) 676{ 677 return c_name_of_variable (parent); 678} 679 680enum 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 685static int 686match_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 699static void 700cplus_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 900static std::string 901cplus_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 909static std::string 910cplus_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 919static struct value * 920cplus_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 928static struct type * 929cplus_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 937static std::string 938cplus_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 950 951/* varobj operations for c++. */ 952 953const 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 968