1 /* varobj support for Ada. 2 3 Copyright (C) 2012-2013 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 #include "defs.h" 21 #include "ada-varobj.h" 22 #include "ada-lang.h" 23 #include "language.h" 24 #include "valprint.h" 25 26 /* Implementation principle used in this unit: 27 28 For our purposes, the meat of the varobj object is made of two 29 elements: The varobj's (struct) value, and the varobj's (struct) 30 type. In most situations, the varobj has a non-NULL value, and 31 the type becomes redundant, as it can be directly derived from 32 the value. In the initial implementation of this unit, most 33 routines would only take a value, and return a value. 34 35 But there are many situations where it is possible for a varobj 36 to have a NULL value. For instance, if the varobj becomes out of 37 scope. Or better yet, when the varobj is the child of another 38 NULL pointer varobj. In that situation, we must rely on the type 39 instead of the value to create the child varobj. 40 41 That's why most functions below work with a (value, type) pair. 42 The value may or may not be NULL. But the type is always expected 43 to be set. When the value is NULL, then we work with the type 44 alone, and keep the value NULL. But when the value is not NULL, 45 then we work using the value, because it provides more information. 46 But we still always set the type as well, even if that type could 47 easily be derived from the value. The reason behind this is that 48 it allows the code to use the type without having to worry about 49 it being set or not. It makes the code clearer. */ 50 51 /* A convenience function that decodes the VALUE_PTR/TYPE_PTR couple: 52 If there is a value (*VALUE_PTR not NULL), then perform the decoding 53 using it, and compute the associated type from the resulting value. 54 Otherwise, compute a static approximation of *TYPE_PTR, leaving 55 *VALUE_PTR unchanged. 56 57 The results are written in place. */ 58 59 static void 60 ada_varobj_decode_var (struct value **value_ptr, struct type **type_ptr) 61 { 62 if (*value_ptr) 63 { 64 *value_ptr = ada_get_decoded_value (*value_ptr); 65 *type_ptr = ada_check_typedef (value_type (*value_ptr)); 66 } 67 else 68 *type_ptr = ada_get_decoded_type (*type_ptr); 69 } 70 71 /* Return a string containing an image of the given scalar value. 72 VAL is the numeric value, while TYPE is the value's type. 73 This is useful for plain integers, of course, but even more 74 so for enumerated types. 75 76 The result should be deallocated by xfree after use. */ 77 78 static char * 79 ada_varobj_scalar_image (struct type *type, LONGEST val) 80 { 81 struct ui_file *buf = mem_fileopen (); 82 struct cleanup *cleanups = make_cleanup_ui_file_delete (buf); 83 char *result; 84 85 ada_print_scalar (type, val, buf); 86 result = ui_file_xstrdup (buf, NULL); 87 do_cleanups (cleanups); 88 89 return result; 90 } 91 92 /* Assuming that the (PARENT_VALUE, PARENT_TYPE) pair designates 93 a struct or union, compute the (CHILD_VALUE, CHILD_TYPE) couple 94 corresponding to the field number FIELDNO. */ 95 96 static void 97 ada_varobj_struct_elt (struct value *parent_value, 98 struct type *parent_type, 99 int fieldno, 100 struct value **child_value, 101 struct type **child_type) 102 { 103 struct value *value = NULL; 104 struct type *type = NULL; 105 106 if (parent_value) 107 { 108 value = value_field (parent_value, fieldno); 109 type = value_type (value); 110 } 111 else 112 type = TYPE_FIELD_TYPE (parent_type, fieldno); 113 114 if (child_value) 115 *child_value = value; 116 if (child_type) 117 *child_type = type; 118 } 119 120 /* Assuming that the (PARENT_VALUE, PARENT_TYPE) pair is a pointer or 121 reference, return a (CHILD_VALUE, CHILD_TYPE) couple corresponding 122 to the dereferenced value. */ 123 124 static void 125 ada_varobj_ind (struct value *parent_value, 126 struct type *parent_type, 127 struct value **child_value, 128 struct type **child_type) 129 { 130 struct value *value = NULL; 131 struct type *type = NULL; 132 133 if (ada_is_array_descriptor_type (parent_type)) 134 { 135 /* This can only happen when PARENT_VALUE is NULL. Otherwise, 136 ada_get_decoded_value would have transformed our parent_type 137 into a simple array pointer type. */ 138 gdb_assert (parent_value == NULL); 139 gdb_assert (TYPE_CODE (parent_type) == TYPE_CODE_TYPEDEF); 140 141 /* Decode parent_type by the equivalent pointer to (decoded) 142 array. */ 143 while (TYPE_CODE (parent_type) == TYPE_CODE_TYPEDEF) 144 parent_type = TYPE_TARGET_TYPE (parent_type); 145 parent_type = ada_coerce_to_simple_array_type (parent_type); 146 parent_type = lookup_pointer_type (parent_type); 147 } 148 149 /* If parent_value is a null pointer, then only perform static 150 dereferencing. We cannot dereference null pointers. */ 151 if (parent_value && value_as_address (parent_value) == 0) 152 parent_value = NULL; 153 154 if (parent_value) 155 { 156 value = ada_value_ind (parent_value); 157 type = value_type (value); 158 } 159 else 160 type = TYPE_TARGET_TYPE (parent_type); 161 162 if (child_value) 163 *child_value = value; 164 if (child_type) 165 *child_type = type; 166 } 167 168 /* Assuming that the (PARENT_VALUE, PARENT_TYPE) pair is a simple 169 array (TYPE_CODE_ARRAY), return the (CHILD_VALUE, CHILD_TYPE) 170 pair corresponding to the element at ELT_INDEX. */ 171 172 static void 173 ada_varobj_simple_array_elt (struct value *parent_value, 174 struct type *parent_type, 175 int elt_index, 176 struct value **child_value, 177 struct type **child_type) 178 { 179 struct value *value = NULL; 180 struct type *type = NULL; 181 182 if (parent_value) 183 { 184 struct value *index_value = 185 value_from_longest (TYPE_INDEX_TYPE (parent_type), elt_index); 186 187 value = ada_value_subscript (parent_value, 1, &index_value); 188 type = value_type (value); 189 } 190 else 191 type = TYPE_TARGET_TYPE (parent_type); 192 193 if (child_value) 194 *child_value = value; 195 if (child_type) 196 *child_type = type; 197 } 198 199 /* Given the decoded value and decoded type of a variable object, 200 adjust the value and type to those necessary for getting children 201 of the variable object. 202 203 The replacement is performed in place. */ 204 205 static void 206 ada_varobj_adjust_for_child_access (struct value **value, 207 struct type **type) 208 { 209 /* Pointers to struct/union types are special: Instead of having 210 one child (the struct), their children are the components of 211 the struct/union type. We handle this situation by dereferencing 212 the (value, type) couple. */ 213 if (TYPE_CODE (*type) == TYPE_CODE_PTR 214 && (TYPE_CODE (TYPE_TARGET_TYPE (*type)) == TYPE_CODE_STRUCT 215 || TYPE_CODE (TYPE_TARGET_TYPE (*type)) == TYPE_CODE_UNION) 216 && !ada_is_array_descriptor_type (TYPE_TARGET_TYPE (*type)) 217 && !ada_is_constrained_packed_array_type (TYPE_TARGET_TYPE (*type))) 218 ada_varobj_ind (*value, *type, value, type); 219 } 220 221 /* Assuming that the (PARENT_VALUE, PARENT_TYPE) pair is an array 222 (any type of array, "simple" or not), return the number of children 223 that this array contains. */ 224 225 static int 226 ada_varobj_get_array_number_of_children (struct value *parent_value, 227 struct type *parent_type) 228 { 229 LONGEST lo, hi; 230 231 if (!get_array_bounds (parent_type, &lo, &hi)) 232 { 233 /* Could not get the array bounds. Pretend this is an empty array. */ 234 warning (_("unable to get bounds of array, assuming null array")); 235 return 0; 236 } 237 238 /* Ada allows the upper bound to be less than the lower bound, 239 in order to specify empty arrays... */ 240 if (hi < lo) 241 return 0; 242 243 return hi - lo + 1; 244 } 245 246 /* Assuming that the (PARENT_VALUE, PARENT_TYPE) pair is a struct or 247 union, return the number of children this struct contains. */ 248 249 static int 250 ada_varobj_get_struct_number_of_children (struct value *parent_value, 251 struct type *parent_type) 252 { 253 int n_children = 0; 254 int i; 255 256 gdb_assert (TYPE_CODE (parent_type) == TYPE_CODE_STRUCT 257 || TYPE_CODE (parent_type) == TYPE_CODE_UNION); 258 259 for (i = 0; i < TYPE_NFIELDS (parent_type); i++) 260 { 261 if (ada_is_ignored_field (parent_type, i)) 262 continue; 263 264 if (ada_is_wrapper_field (parent_type, i)) 265 { 266 struct value *elt_value; 267 struct type *elt_type; 268 269 ada_varobj_struct_elt (parent_value, parent_type, i, 270 &elt_value, &elt_type); 271 if (ada_is_tagged_type (elt_type, 0)) 272 { 273 /* We must not use ada_varobj_get_number_of_children 274 to determine is element's number of children, because 275 this function first calls ada_varobj_decode_var, 276 which "fixes" the element. For tagged types, this 277 includes reading the object's tag to determine its 278 real type, which happens to be the parent_type, and 279 leads to an infinite loop (because the element gets 280 fixed back into the parent). */ 281 n_children += ada_varobj_get_struct_number_of_children 282 (elt_value, elt_type); 283 } 284 else 285 n_children += ada_varobj_get_number_of_children (elt_value, elt_type); 286 } 287 else if (ada_is_variant_part (parent_type, i)) 288 { 289 /* In normal situations, the variant part of the record should 290 have been "fixed". Or, in other words, it should have been 291 replaced by the branch of the variant part that is relevant 292 for our value. But there are still situations where this 293 can happen, however (Eg. when our parent is a NULL pointer). 294 We do not support showing this part of the record for now, 295 so just pretend this field does not exist. */ 296 } 297 else 298 n_children++; 299 } 300 301 return n_children; 302 } 303 304 /* Assuming that the (PARENT_VALUE, PARENT_TYPE) pair designates 305 a pointer, return the number of children this pointer has. */ 306 307 static int 308 ada_varobj_get_ptr_number_of_children (struct value *parent_value, 309 struct type *parent_type) 310 { 311 struct type *child_type = TYPE_TARGET_TYPE (parent_type); 312 313 /* Pointer to functions and to void do not have a child, since 314 you cannot print what they point to. */ 315 if (TYPE_CODE (child_type) == TYPE_CODE_FUNC 316 || TYPE_CODE (child_type) == TYPE_CODE_VOID) 317 return 0; 318 319 /* All other types have 1 child. */ 320 return 1; 321 } 322 323 /* Return the number of children for the (PARENT_VALUE, PARENT_TYPE) 324 pair. */ 325 326 int 327 ada_varobj_get_number_of_children (struct value *parent_value, 328 struct type *parent_type) 329 { 330 ada_varobj_decode_var (&parent_value, &parent_type); 331 ada_varobj_adjust_for_child_access (&parent_value, &parent_type); 332 333 /* A typedef to an array descriptor in fact represents a pointer 334 to an unconstrained array. These types always have one child 335 (the unconstrained array). */ 336 if (ada_is_array_descriptor_type (parent_type) 337 && TYPE_CODE (parent_type) == TYPE_CODE_TYPEDEF) 338 return 1; 339 340 if (TYPE_CODE (parent_type) == TYPE_CODE_ARRAY) 341 return ada_varobj_get_array_number_of_children (parent_value, 342 parent_type); 343 344 if (TYPE_CODE (parent_type) == TYPE_CODE_STRUCT 345 || TYPE_CODE (parent_type) == TYPE_CODE_UNION) 346 return ada_varobj_get_struct_number_of_children (parent_value, 347 parent_type); 348 349 if (TYPE_CODE (parent_type) == TYPE_CODE_PTR) 350 return ada_varobj_get_ptr_number_of_children (parent_value, 351 parent_type); 352 353 /* All other types have no child. */ 354 return 0; 355 } 356 357 /* Describe the child of the (PARENT_VALUE, PARENT_TYPE) pair 358 whose index is CHILD_INDEX: 359 360 - If CHILD_NAME is not NULL, then a copy of the child's name 361 is saved in *CHILD_NAME. This copy must be deallocated 362 with xfree after use. 363 364 - If CHILD_VALUE is not NULL, then save the child's value 365 in *CHILD_VALUE. Same thing for the child's type with 366 CHILD_TYPE if not NULL. 367 368 - If CHILD_PATH_EXPR is not NULL, then compute the child's 369 path expression. The resulting string must be deallocated 370 after use with xfree. 371 372 Computing the child's path expression requires the PARENT_PATH_EXPR 373 to be non-NULL. Otherwise, PARENT_PATH_EXPR may be null if 374 CHILD_PATH_EXPR is NULL. 375 376 PARENT_NAME is the name of the parent, and should never be NULL. */ 377 378 static void ada_varobj_describe_child (struct value *parent_value, 379 struct type *parent_type, 380 const char *parent_name, 381 const char *parent_path_expr, 382 int child_index, 383 char **child_name, 384 struct value **child_value, 385 struct type **child_type, 386 char **child_path_expr); 387 388 /* Same as ada_varobj_describe_child, but limited to struct/union 389 objects. */ 390 391 static void 392 ada_varobj_describe_struct_child (struct value *parent_value, 393 struct type *parent_type, 394 const char *parent_name, 395 const char *parent_path_expr, 396 int child_index, 397 char **child_name, 398 struct value **child_value, 399 struct type **child_type, 400 char **child_path_expr) 401 { 402 int fieldno; 403 int childno = 0; 404 405 gdb_assert (TYPE_CODE (parent_type) == TYPE_CODE_STRUCT); 406 407 for (fieldno = 0; fieldno < TYPE_NFIELDS (parent_type); fieldno++) 408 { 409 if (ada_is_ignored_field (parent_type, fieldno)) 410 continue; 411 412 if (ada_is_wrapper_field (parent_type, fieldno)) 413 { 414 struct value *elt_value; 415 struct type *elt_type; 416 int elt_n_children; 417 418 ada_varobj_struct_elt (parent_value, parent_type, fieldno, 419 &elt_value, &elt_type); 420 if (ada_is_tagged_type (elt_type, 0)) 421 { 422 /* Same as in ada_varobj_get_struct_number_of_children: 423 For tagged types, we must be careful to not call 424 ada_varobj_get_number_of_children, to prevent our 425 element from being fixed back into the parent. */ 426 elt_n_children = ada_varobj_get_struct_number_of_children 427 (elt_value, elt_type); 428 } 429 else 430 elt_n_children = 431 ada_varobj_get_number_of_children (elt_value, elt_type); 432 433 /* Is the child we're looking for one of the children 434 of this wrapper field? */ 435 if (child_index - childno < elt_n_children) 436 { 437 if (ada_is_tagged_type (elt_type, 0)) 438 { 439 /* Same as in ada_varobj_get_struct_number_of_children: 440 For tagged types, we must be careful to not call 441 ada_varobj_describe_child, to prevent our element 442 from being fixed back into the parent. */ 443 ada_varobj_describe_struct_child 444 (elt_value, elt_type, parent_name, parent_path_expr, 445 child_index - childno, child_name, child_value, 446 child_type, child_path_expr); 447 } 448 else 449 ada_varobj_describe_child (elt_value, elt_type, 450 parent_name, parent_path_expr, 451 child_index - childno, 452 child_name, child_value, 453 child_type, child_path_expr); 454 return; 455 } 456 457 /* The child we're looking for is beyond this wrapper 458 field, so skip all its children. */ 459 childno += elt_n_children; 460 continue; 461 } 462 else if (ada_is_variant_part (parent_type, fieldno)) 463 { 464 /* In normal situations, the variant part of the record should 465 have been "fixed". Or, in other words, it should have been 466 replaced by the branch of the variant part that is relevant 467 for our value. But there are still situations where this 468 can happen, however (Eg. when our parent is a NULL pointer). 469 We do not support showing this part of the record for now, 470 so just pretend this field does not exist. */ 471 continue; 472 } 473 474 if (childno == child_index) 475 { 476 if (child_name) 477 { 478 /* The name of the child is none other than the field's 479 name, except that we need to strip suffixes from it. 480 For instance, fields with alignment constraints will 481 have an __XVA suffix added to them. */ 482 const char *field_name = TYPE_FIELD_NAME (parent_type, fieldno); 483 int child_name_len = ada_name_prefix_len (field_name); 484 485 *child_name = xstrprintf ("%.*s", child_name_len, field_name); 486 } 487 488 if (child_value && parent_value) 489 ada_varobj_struct_elt (parent_value, parent_type, fieldno, 490 child_value, NULL); 491 492 if (child_type) 493 ada_varobj_struct_elt (parent_value, parent_type, fieldno, 494 NULL, child_type); 495 496 if (child_path_expr) 497 { 498 /* The name of the child is none other than the field's 499 name, except that we need to strip suffixes from it. 500 For instance, fields with alignment constraints will 501 have an __XVA suffix added to them. */ 502 const char *field_name = TYPE_FIELD_NAME (parent_type, fieldno); 503 int child_name_len = ada_name_prefix_len (field_name); 504 505 *child_path_expr = 506 xstrprintf ("(%s).%.*s", parent_path_expr, 507 child_name_len, field_name); 508 } 509 510 return; 511 } 512 513 childno++; 514 } 515 516 /* Something went wrong. Either we miscounted the number of 517 children, or CHILD_INDEX was too high. But we should never 518 reach here. We don't have enough information to recover 519 nicely, so just raise an assertion failure. */ 520 gdb_assert_not_reached ("unexpected code path"); 521 } 522 523 /* Same as ada_varobj_describe_child, but limited to pointer objects. 524 525 Note that CHILD_INDEX is unused in this situation, but still provided 526 for consistency of interface with other routines describing an object's 527 child. */ 528 529 static void 530 ada_varobj_describe_ptr_child (struct value *parent_value, 531 struct type *parent_type, 532 const char *parent_name, 533 const char *parent_path_expr, 534 int child_index, 535 char **child_name, 536 struct value **child_value, 537 struct type **child_type, 538 char **child_path_expr) 539 { 540 if (child_name) 541 *child_name = xstrprintf ("%s.all", parent_name); 542 543 if (child_value && parent_value) 544 ada_varobj_ind (parent_value, parent_type, child_value, NULL); 545 546 if (child_type) 547 ada_varobj_ind (parent_value, parent_type, NULL, child_type); 548 549 if (child_path_expr) 550 *child_path_expr = xstrprintf ("(%s).all", parent_path_expr); 551 } 552 553 /* Same as ada_varobj_describe_child, limited to simple array objects 554 (TYPE_CODE_ARRAY only). 555 556 Assumes that the (PARENT_VALUE, PARENT_TYPE) pair is properly decoded. 557 This is done by ada_varobj_describe_child before calling us. */ 558 559 static void 560 ada_varobj_describe_simple_array_child (struct value *parent_value, 561 struct type *parent_type, 562 const char *parent_name, 563 const char *parent_path_expr, 564 int child_index, 565 char **child_name, 566 struct value **child_value, 567 struct type **child_type, 568 char **child_path_expr) 569 { 570 struct type *index_desc_type; 571 struct type *index_type; 572 int real_index; 573 574 gdb_assert (TYPE_CODE (parent_type) == TYPE_CODE_ARRAY); 575 576 index_desc_type = ada_find_parallel_type (parent_type, "___XA"); 577 ada_fixup_array_indexes_type (index_desc_type); 578 if (index_desc_type) 579 index_type = TYPE_FIELD_TYPE (index_desc_type, 0); 580 else 581 index_type = TYPE_INDEX_TYPE (parent_type); 582 real_index = child_index + ada_discrete_type_low_bound (index_type); 583 584 if (child_name) 585 *child_name = ada_varobj_scalar_image (index_type, real_index); 586 587 if (child_value && parent_value) 588 ada_varobj_simple_array_elt (parent_value, parent_type, real_index, 589 child_value, NULL); 590 591 if (child_type) 592 ada_varobj_simple_array_elt (parent_value, parent_type, real_index, 593 NULL, child_type); 594 595 if (child_path_expr) 596 { 597 char *index_img = ada_varobj_scalar_image (index_type, real_index); 598 struct cleanup *cleanups = make_cleanup (xfree, index_img); 599 600 /* Enumeration litterals by themselves are potentially ambiguous. 601 For instance, consider the following package spec: 602 603 package Pck is 604 type Color is (Red, Green, Blue, White); 605 type Blood_Cells is (White, Red); 606 end Pck; 607 608 In this case, the litteral "red" for instance, or even 609 the fully-qualified litteral "pck.red" cannot be resolved 610 by itself. Type qualification is needed to determine which 611 enumeration litterals should be used. 612 613 The following variable will be used to contain the name 614 of the array index type when such type qualification is 615 needed. */ 616 const char *index_type_name = NULL; 617 618 /* If the index type is a range type, find the base type. */ 619 while (TYPE_CODE (index_type) == TYPE_CODE_RANGE) 620 index_type = TYPE_TARGET_TYPE (index_type); 621 622 if (TYPE_CODE (index_type) == TYPE_CODE_ENUM 623 || TYPE_CODE (index_type) == TYPE_CODE_BOOL) 624 { 625 index_type_name = ada_type_name (index_type); 626 if (index_type_name) 627 index_type_name = ada_decode (index_type_name); 628 } 629 630 if (index_type_name != NULL) 631 *child_path_expr = 632 xstrprintf ("(%s)(%.*s'(%s))", parent_path_expr, 633 ada_name_prefix_len (index_type_name), 634 index_type_name, index_img); 635 else 636 *child_path_expr = 637 xstrprintf ("(%s)(%s)", parent_path_expr, index_img); 638 do_cleanups (cleanups); 639 } 640 } 641 642 /* See description at declaration above. */ 643 644 static void 645 ada_varobj_describe_child (struct value *parent_value, 646 struct type *parent_type, 647 const char *parent_name, 648 const char *parent_path_expr, 649 int child_index, 650 char **child_name, 651 struct value **child_value, 652 struct type **child_type, 653 char **child_path_expr) 654 { 655 /* We cannot compute the child's path expression without 656 the parent's path expression. This is a pre-condition 657 for calling this function. */ 658 if (child_path_expr) 659 gdb_assert (parent_path_expr != NULL); 660 661 ada_varobj_decode_var (&parent_value, &parent_type); 662 ada_varobj_adjust_for_child_access (&parent_value, &parent_type); 663 664 if (child_name) 665 *child_name = NULL; 666 if (child_value) 667 *child_value = NULL; 668 if (child_type) 669 *child_type = NULL; 670 if (child_path_expr) 671 *child_path_expr = NULL; 672 673 if (ada_is_array_descriptor_type (parent_type) 674 && TYPE_CODE (parent_type) == TYPE_CODE_TYPEDEF) 675 { 676 ada_varobj_describe_ptr_child (parent_value, parent_type, 677 parent_name, parent_path_expr, 678 child_index, child_name, 679 child_value, child_type, 680 child_path_expr); 681 return; 682 } 683 684 if (TYPE_CODE (parent_type) == TYPE_CODE_ARRAY) 685 { 686 ada_varobj_describe_simple_array_child 687 (parent_value, parent_type, parent_name, parent_path_expr, 688 child_index, child_name, child_value, child_type, 689 child_path_expr); 690 return; 691 } 692 693 if (TYPE_CODE (parent_type) == TYPE_CODE_STRUCT) 694 { 695 ada_varobj_describe_struct_child (parent_value, parent_type, 696 parent_name, parent_path_expr, 697 child_index, child_name, 698 child_value, child_type, 699 child_path_expr); 700 return; 701 } 702 703 if (TYPE_CODE (parent_type) == TYPE_CODE_PTR) 704 { 705 ada_varobj_describe_ptr_child (parent_value, parent_type, 706 parent_name, parent_path_expr, 707 child_index, child_name, 708 child_value, child_type, 709 child_path_expr); 710 return; 711 } 712 713 /* It should never happen. But rather than crash, report dummy names 714 and return a NULL child_value. */ 715 if (child_name) 716 *child_name = xstrdup ("???"); 717 } 718 719 /* Return the name of the child number CHILD_INDEX of the (PARENT_VALUE, 720 PARENT_TYPE) pair. PARENT_NAME is the name of the PARENT. 721 722 The result should be deallocated after use with xfree. */ 723 724 char * 725 ada_varobj_get_name_of_child (struct value *parent_value, 726 struct type *parent_type, 727 const char *parent_name, int child_index) 728 { 729 char *child_name; 730 731 ada_varobj_describe_child (parent_value, parent_type, parent_name, 732 NULL, child_index, &child_name, NULL, 733 NULL, NULL); 734 return child_name; 735 } 736 737 /* Return the path expression of the child number CHILD_INDEX of 738 the (PARENT_VALUE, PARENT_TYPE) pair. PARENT_NAME is the name 739 of the parent, and PARENT_PATH_EXPR is the parent's path expression. 740 Both must be non-NULL. 741 742 The result must be deallocated after use with xfree. */ 743 744 char * 745 ada_varobj_get_path_expr_of_child (struct value *parent_value, 746 struct type *parent_type, 747 const char *parent_name, 748 const char *parent_path_expr, 749 int child_index) 750 { 751 char *child_path_expr; 752 753 ada_varobj_describe_child (parent_value, parent_type, parent_name, 754 parent_path_expr, child_index, NULL, 755 NULL, NULL, &child_path_expr); 756 757 return child_path_expr; 758 } 759 760 /* Return the value of child number CHILD_INDEX of the (PARENT_VALUE, 761 PARENT_TYPE) pair. PARENT_NAME is the name of the parent. */ 762 763 struct value * 764 ada_varobj_get_value_of_child (struct value *parent_value, 765 struct type *parent_type, 766 const char *parent_name, int child_index) 767 { 768 struct value *child_value; 769 770 ada_varobj_describe_child (parent_value, parent_type, parent_name, 771 NULL, child_index, NULL, &child_value, 772 NULL, NULL); 773 774 return child_value; 775 } 776 777 /* Return the type of child number CHILD_INDEX of the (PARENT_VALUE, 778 PARENT_TYPE) pair. */ 779 780 struct type * 781 ada_varobj_get_type_of_child (struct value *parent_value, 782 struct type *parent_type, 783 int child_index) 784 { 785 struct type *child_type; 786 787 ada_varobj_describe_child (parent_value, parent_type, NULL, NULL, 788 child_index, NULL, NULL, &child_type, NULL); 789 790 return child_type; 791 } 792 793 /* Return a string that contains the image of the given VALUE, using 794 the print options OPTS as the options for formatting the result. 795 796 The resulting string must be deallocated after use with xfree. */ 797 798 static char * 799 ada_varobj_get_value_image (struct value *value, 800 struct value_print_options *opts) 801 { 802 char *result; 803 struct ui_file *buffer; 804 struct cleanup *old_chain; 805 806 buffer = mem_fileopen (); 807 old_chain = make_cleanup_ui_file_delete (buffer); 808 809 common_val_print (value, buffer, 0, opts, current_language); 810 result = ui_file_xstrdup (buffer, NULL); 811 812 do_cleanups (old_chain); 813 return result; 814 } 815 816 /* Assuming that the (VALUE, TYPE) pair designates an array varobj, 817 return a string that is suitable for use in the "value" field of 818 the varobj output. Most of the time, this is the number of elements 819 in the array inside square brackets, but there are situations where 820 it's useful to add more info. 821 822 OPTS are the print options used when formatting the result. 823 824 The result should be deallocated after use using xfree. */ 825 826 static char * 827 ada_varobj_get_value_of_array_variable (struct value *value, 828 struct type *type, 829 struct value_print_options *opts) 830 { 831 char *result; 832 const int numchild = ada_varobj_get_array_number_of_children (value, type); 833 834 /* If we have a string, provide its contents in the "value" field. 835 Otherwise, the only other way to inspect the contents of the string 836 is by looking at the value of each element, as in any other array, 837 which is not very convenient... */ 838 if (value 839 && ada_is_string_type (type) 840 && (opts->format == 0 || opts->format == 's')) 841 { 842 char *str; 843 struct cleanup *old_chain; 844 845 str = ada_varobj_get_value_image (value, opts); 846 old_chain = make_cleanup (xfree, str); 847 result = xstrprintf ("[%d] %s", numchild, str); 848 do_cleanups (old_chain); 849 } 850 else 851 result = xstrprintf ("[%d]", numchild); 852 853 return result; 854 } 855 856 /* Return a string representation of the (VALUE, TYPE) pair, using 857 the given print options OPTS as our formatting options. */ 858 859 char * 860 ada_varobj_get_value_of_variable (struct value *value, 861 struct type *type, 862 struct value_print_options *opts) 863 { 864 char *result = NULL; 865 866 ada_varobj_decode_var (&value, &type); 867 868 switch (TYPE_CODE (type)) 869 { 870 case TYPE_CODE_STRUCT: 871 case TYPE_CODE_UNION: 872 result = xstrdup ("{...}"); 873 break; 874 case TYPE_CODE_ARRAY: 875 result = ada_varobj_get_value_of_array_variable (value, type, opts); 876 break; 877 default: 878 if (!value) 879 result = xstrdup (""); 880 else 881 result = ada_varobj_get_value_image (value, opts); 882 break; 883 } 884 885 return result; 886 } 887 888 889