1/* Support for printing Ada values for GDB, the GNU debugger. 2 Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1997, 2001 3 Free Software Foundation, Inc. 4 5This file is part of GDB. 6 7This program is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by 9the Free Software Foundation; either version 2 of the License, or 10(at your option) any later version. 11 12This program is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with this program; if not, write to the Free Software 19Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ 20 21#include <ctype.h> 22#include "defs.h" 23#include "symtab.h" 24#include "gdbtypes.h" 25#include "expression.h" 26#include "value.h" 27#include "demangle.h" 28#include "valprint.h" 29#include "language.h" 30#include "annotate.h" 31#include "ada-lang.h" 32#include "c-lang.h" 33#include "infcall.h" 34 35/* Encapsulates arguments to ada_val_print. */ 36struct ada_val_print_args 37{ 38 struct type *type; 39 char *valaddr0; 40 int embedded_offset; 41 CORE_ADDR address; 42 struct ui_file *stream; 43 int format; 44 int deref_ref; 45 int recurse; 46 enum val_prettyprint pretty; 47}; 48 49static void print_record (struct type *, char *, struct ui_file *, int, 50 int, enum val_prettyprint); 51 52static int print_field_values (struct type *, char *, struct ui_file *, 53 int, int, enum val_prettyprint, 54 int, struct type *, char *); 55 56static int print_variant_part (struct type *, int, char *, 57 struct ui_file *, int, int, 58 enum val_prettyprint, int, struct type *, 59 char *); 60 61static void val_print_packed_array_elements (struct type *, char *valaddr, 62 int, struct ui_file *, int, int, 63 enum val_prettyprint); 64 65static void adjust_type_signedness (struct type *); 66 67static int ada_val_print_stub (void *args0); 68 69static int ada_val_print_1 (struct type *, char *, int, CORE_ADDR, 70 struct ui_file *, int, int, int, 71 enum val_prettyprint); 72 73 74/* Make TYPE unsigned if its range of values includes no negatives. */ 75static void 76adjust_type_signedness (struct type *type) 77{ 78 if (type != NULL && TYPE_CODE (type) == TYPE_CODE_RANGE 79 && TYPE_LOW_BOUND (type) >= 0) 80 TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED; 81} 82 83/* Assuming TYPE is a simple array type, prints its lower bound on STREAM, 84 if non-standard (i.e., other than 1 for numbers, other than lower bound 85 of index type for enumerated type). Returns 1 if something printed, 86 otherwise 0. */ 87 88static int 89print_optional_low_bound (struct ui_file *stream, struct type *type) 90{ 91 struct type *index_type; 92 long low_bound; 93 94 index_type = TYPE_INDEX_TYPE (type); 95 low_bound = 0; 96 97 if (index_type == NULL) 98 return 0; 99 if (TYPE_CODE (index_type) == TYPE_CODE_RANGE) 100 { 101 low_bound = TYPE_LOW_BOUND (index_type); 102 index_type = TYPE_TARGET_TYPE (index_type); 103 } 104 else 105 return 0; 106 107 switch (TYPE_CODE (index_type)) 108 { 109 case TYPE_CODE_ENUM: 110 if (low_bound == TYPE_FIELD_BITPOS (index_type, 0)) 111 return 0; 112 break; 113 case TYPE_CODE_UNDEF: 114 index_type = builtin_type_long; 115 /* FALL THROUGH */ 116 default: 117 if (low_bound == 1) 118 return 0; 119 break; 120 } 121 122 ada_print_scalar (index_type, (LONGEST) low_bound, stream); 123 fprintf_filtered (stream, " => "); 124 return 1; 125} 126 127/* Version of val_print_array_elements for GNAT-style packed arrays. 128 Prints elements of packed array of type TYPE at bit offset 129 BITOFFSET from VALADDR on STREAM. Formats according to FORMAT and 130 separates with commas. RECURSE is the recursion (nesting) level. 131 If PRETTY, uses "prettier" format. TYPE must have been decoded (as 132 by ada_coerce_to_simple_array). */ 133 134static void 135val_print_packed_array_elements (struct type *type, char *valaddr, 136 int bitoffset, struct ui_file *stream, 137 int format, int recurse, 138 enum val_prettyprint pretty) 139{ 140 unsigned int i; 141 unsigned int things_printed = 0; 142 unsigned len; 143 struct type *elttype; 144 unsigned eltlen; 145 /* Position of the array element we are examining to see 146 whether it is repeated. */ 147 unsigned int rep1; 148 /* Number of repetitions we have detected so far. */ 149 unsigned int reps; 150 unsigned long bitsize = TYPE_FIELD_BITSIZE (type, 0); 151 struct value *mark = value_mark (); 152 153 elttype = TYPE_TARGET_TYPE (type); 154 eltlen = TYPE_LENGTH (check_typedef (elttype)); 155 156 { 157 LONGEST low, high; 158 if (get_discrete_bounds (TYPE_FIELD_TYPE (type, 0), &low, &high) < 0) 159 len = 1; 160 else 161 len = high - low + 1; 162 } 163 164 i = 0; 165 annotate_array_section_begin (i, elttype); 166 167 while (i < len && things_printed < print_max) 168 { 169 struct value *v0, *v1; 170 int i0; 171 172 if (i != 0) 173 { 174 if (prettyprint_arrays) 175 { 176 fprintf_filtered (stream, ",\n"); 177 print_spaces_filtered (2 + 2 * recurse, stream); 178 } 179 else 180 { 181 fprintf_filtered (stream, ", "); 182 } 183 } 184 wrap_here (n_spaces (2 + 2 * recurse)); 185 186 i0 = i; 187 v0 = ada_value_primitive_packed_val (NULL, valaddr, 188 (i0 * bitsize) / HOST_CHAR_BIT, 189 (i0 * bitsize) % HOST_CHAR_BIT, 190 bitsize, elttype); 191 while (1) 192 { 193 i += 1; 194 if (i >= len) 195 break; 196 v1 = ada_value_primitive_packed_val (NULL, valaddr, 197 (i * bitsize) / HOST_CHAR_BIT, 198 (i * bitsize) % HOST_CHAR_BIT, 199 bitsize, elttype); 200 if (memcmp (VALUE_CONTENTS (v0), VALUE_CONTENTS (v1), eltlen) != 0) 201 break; 202 } 203 204 if (i - i0 > repeat_count_threshold) 205 { 206 val_print (elttype, VALUE_CONTENTS (v0), 0, 0, stream, format, 207 0, recurse + 1, pretty); 208 annotate_elt_rep (i - i0); 209 fprintf_filtered (stream, " <repeats %u times>", i - i0); 210 annotate_elt_rep_end (); 211 212 } 213 else 214 { 215 int j; 216 for (j = i0; j < i; j += 1) 217 { 218 if (j > i0) 219 { 220 if (prettyprint_arrays) 221 { 222 fprintf_filtered (stream, ",\n"); 223 print_spaces_filtered (2 + 2 * recurse, stream); 224 } 225 else 226 { 227 fprintf_filtered (stream, ", "); 228 } 229 wrap_here (n_spaces (2 + 2 * recurse)); 230 } 231 val_print (elttype, VALUE_CONTENTS (v0), 0, 0, stream, format, 232 0, recurse + 1, pretty); 233 annotate_elt (); 234 } 235 } 236 things_printed += i - i0; 237 } 238 annotate_array_section_end (); 239 if (i < len) 240 { 241 fprintf_filtered (stream, "..."); 242 } 243 244 value_free_to_mark (mark); 245} 246 247static struct type * 248printable_val_type (struct type *type, char *valaddr) 249{ 250 return ada_to_fixed_type (ada_aligned_type (type), valaddr, 0, NULL); 251} 252 253/* Print the character C on STREAM as part of the contents of a literal 254 string whose delimiter is QUOTER. TYPE_LEN is the length in bytes 255 (1 or 2) of the character. */ 256 257void 258ada_emit_char (int c, struct ui_file *stream, int quoter, int type_len) 259{ 260 if (type_len != 2) 261 type_len = 1; 262 263 c &= (1 << (type_len * TARGET_CHAR_BIT)) - 1; 264 265 if (isascii (c) && isprint (c)) 266 { 267 if (c == quoter && c == '"') 268 fprintf_filtered (stream, "[\"%c\"]", quoter); 269 else 270 fprintf_filtered (stream, "%c", c); 271 } 272 else 273 fprintf_filtered (stream, "[\"%0*x\"]", type_len * 2, c); 274} 275 276/* Character #I of STRING, given that TYPE_LEN is the size in bytes (1 277 or 2) of a character. */ 278 279static int 280char_at (char *string, int i, int type_len) 281{ 282 if (type_len == 1) 283 return string[i]; 284 else 285 return (int) extract_unsigned_integer (string + 2 * i, 2); 286} 287 288void 289ada_printchar (int c, struct ui_file *stream) 290{ 291 fputs_filtered ("'", stream); 292 ada_emit_char (c, stream, '\'', 1); 293 fputs_filtered ("'", stream); 294} 295 296/* [From print_type_scalar in typeprint.c]. Print VAL on STREAM in a 297 form appropriate for TYPE. */ 298 299void 300ada_print_scalar (struct type *type, LONGEST val, struct ui_file *stream) 301{ 302 unsigned int i; 303 unsigned len; 304 305 CHECK_TYPEDEF (type); 306 307 switch (TYPE_CODE (type)) 308 { 309 310 case TYPE_CODE_ENUM: 311 len = TYPE_NFIELDS (type); 312 for (i = 0; i < len; i++) 313 { 314 if (TYPE_FIELD_BITPOS (type, i) == val) 315 { 316 break; 317 } 318 } 319 if (i < len) 320 { 321 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type, i)), stream); 322 } 323 else 324 { 325 print_longest (stream, 'd', 0, val); 326 } 327 break; 328 329 case TYPE_CODE_INT: 330 print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0, val); 331 break; 332 333 case TYPE_CODE_CHAR: 334 LA_PRINT_CHAR ((unsigned char) val, stream); 335 break; 336 337 case TYPE_CODE_BOOL: 338 fprintf_filtered (stream, val ? "true" : "false"); 339 break; 340 341 case TYPE_CODE_RANGE: 342 ada_print_scalar (TYPE_TARGET_TYPE (type), val, stream); 343 return; 344 345 case TYPE_CODE_UNDEF: 346 case TYPE_CODE_PTR: 347 case TYPE_CODE_ARRAY: 348 case TYPE_CODE_STRUCT: 349 case TYPE_CODE_UNION: 350 case TYPE_CODE_FUNC: 351 case TYPE_CODE_FLT: 352 case TYPE_CODE_VOID: 353 case TYPE_CODE_SET: 354 case TYPE_CODE_STRING: 355 case TYPE_CODE_ERROR: 356 case TYPE_CODE_MEMBER: 357 case TYPE_CODE_METHOD: 358 case TYPE_CODE_REF: 359 warning ("internal error: unhandled type in ada_print_scalar"); 360 break; 361 362 default: 363 error ("Invalid type code in symbol table."); 364 } 365 gdb_flush (stream); 366} 367 368/* Print the character string STRING, printing at most LENGTH characters. 369 Printing stops early if the number hits print_max; repeat counts 370 are printed as appropriate. Print ellipses at the end if we 371 had to stop before printing LENGTH characters, or if 372 FORCE_ELLIPSES. TYPE_LEN is the length (1 or 2) of the character type. 373 */ 374 375static void 376printstr (struct ui_file *stream, char *string, unsigned int length, 377 int force_ellipses, int type_len) 378{ 379 unsigned int i; 380 unsigned int things_printed = 0; 381 int in_quotes = 0; 382 int need_comma = 0; 383 384 if (length == 0) 385 { 386 fputs_filtered ("\"\"", stream); 387 return; 388 } 389 390 for (i = 0; i < length && things_printed < print_max; i += 1) 391 { 392 /* Position of the character we are examining 393 to see whether it is repeated. */ 394 unsigned int rep1; 395 /* Number of repetitions we have detected so far. */ 396 unsigned int reps; 397 398 QUIT; 399 400 if (need_comma) 401 { 402 fputs_filtered (", ", stream); 403 need_comma = 0; 404 } 405 406 rep1 = i + 1; 407 reps = 1; 408 while (rep1 < length && 409 char_at (string, rep1, type_len) == char_at (string, i, 410 type_len)) 411 { 412 rep1 += 1; 413 reps += 1; 414 } 415 416 if (reps > repeat_count_threshold) 417 { 418 if (in_quotes) 419 { 420 if (inspect_it) 421 fputs_filtered ("\\\", ", stream); 422 else 423 fputs_filtered ("\", ", stream); 424 in_quotes = 0; 425 } 426 fputs_filtered ("'", stream); 427 ada_emit_char (char_at (string, i, type_len), stream, '\'', 428 type_len); 429 fputs_filtered ("'", stream); 430 fprintf_filtered (stream, " <repeats %u times>", reps); 431 i = rep1 - 1; 432 things_printed += repeat_count_threshold; 433 need_comma = 1; 434 } 435 else 436 { 437 if (!in_quotes) 438 { 439 if (inspect_it) 440 fputs_filtered ("\\\"", stream); 441 else 442 fputs_filtered ("\"", stream); 443 in_quotes = 1; 444 } 445 ada_emit_char (char_at (string, i, type_len), stream, '"', 446 type_len); 447 things_printed += 1; 448 } 449 } 450 451 /* Terminate the quotes if necessary. */ 452 if (in_quotes) 453 { 454 if (inspect_it) 455 fputs_filtered ("\\\"", stream); 456 else 457 fputs_filtered ("\"", stream); 458 } 459 460 if (force_ellipses || i < length) 461 fputs_filtered ("...", stream); 462} 463 464void 465ada_printstr (struct ui_file *stream, char *string, unsigned int length, 466 int force_ellipses, int width) 467{ 468 printstr (stream, string, length, force_ellipses, width); 469} 470 471 472/* Print data of type TYPE located at VALADDR (within GDB), which came from 473 the inferior at address ADDRESS, onto stdio stream STREAM according to 474 FORMAT (a letter as for the printf % codes or 0 for natural format). 475 The data at VALADDR is in target byte order. 476 477 If the data is printed as a string, returns the number of string characters 478 printed. 479 480 If DEREF_REF is nonzero, then dereference references, otherwise just print 481 them like pointers. 482 483 RECURSE indicates the amount of indentation to supply before 484 continuation lines; this amount is roughly twice the value of RECURSE. 485 486 When PRETTY is non-zero, prints record fields on separate lines. 487 (For some reason, the current version of gdb instead uses a global 488 variable---prettyprint_arrays--- to causes a similar effect on 489 arrays.) */ 490 491int 492ada_val_print (struct type *type, char *valaddr0, int embedded_offset, 493 CORE_ADDR address, struct ui_file *stream, int format, 494 int deref_ref, int recurse, enum val_prettyprint pretty) 495{ 496 struct ada_val_print_args args; 497 args.type = type; 498 args.valaddr0 = valaddr0; 499 args.embedded_offset = embedded_offset; 500 args.address = address; 501 args.stream = stream; 502 args.format = format; 503 args.deref_ref = deref_ref; 504 args.recurse = recurse; 505 args.pretty = pretty; 506 507 return catch_errors (ada_val_print_stub, &args, NULL, RETURN_MASK_ALL); 508} 509 510/* Helper for ada_val_print; used as argument to catch_errors to 511 unmarshal the arguments to ada_val_print_1, which does the work. */ 512static int 513ada_val_print_stub (void * args0) 514{ 515 struct ada_val_print_args *argsp = (struct ada_val_print_args *) args0; 516 return ada_val_print_1 (argsp->type, argsp->valaddr0, 517 argsp->embedded_offset, argsp->address, 518 argsp->stream, argsp->format, argsp->deref_ref, 519 argsp->recurse, argsp->pretty); 520} 521 522/* See the comment on ada_val_print. This function differs in that it 523 * does not catch evaluation errors (leaving that to ada_val_print). */ 524 525static int 526ada_val_print_1 (struct type *type, char *valaddr0, int embedded_offset, 527 CORE_ADDR address, struct ui_file *stream, int format, 528 int deref_ref, int recurse, enum val_prettyprint pretty) 529{ 530 unsigned int len; 531 int i; 532 struct type *elttype; 533 unsigned int eltlen; 534 LONGEST val; 535 CORE_ADDR addr; 536 char *valaddr = valaddr0 + embedded_offset; 537 538 CHECK_TYPEDEF (type); 539 540 if (ada_is_array_descriptor (type) || ada_is_packed_array_type (type)) 541 { 542 int retn; 543 struct value *mark = value_mark (); 544 struct value *val; 545 val = value_from_contents_and_address (type, valaddr, address); 546 val = ada_coerce_to_simple_array_ptr (val); 547 if (val == NULL) 548 { 549 fprintf_filtered (stream, "(null)"); 550 retn = 0; 551 } 552 else 553 retn = ada_val_print_1 (VALUE_TYPE (val), VALUE_CONTENTS (val), 0, 554 VALUE_ADDRESS (val), stream, format, 555 deref_ref, recurse, pretty); 556 value_free_to_mark (mark); 557 return retn; 558 } 559 560 valaddr = ada_aligned_value_addr (type, valaddr); 561 embedded_offset -= valaddr - valaddr0 - embedded_offset; 562 type = printable_val_type (type, valaddr); 563 564 switch (TYPE_CODE (type)) 565 { 566 default: 567 return c_val_print (type, valaddr0, embedded_offset, address, stream, 568 format, deref_ref, recurse, pretty); 569 570 case TYPE_CODE_INT: 571 case TYPE_CODE_RANGE: 572 if (ada_is_fixed_point_type (type)) 573 { 574 LONGEST v = unpack_long (type, valaddr); 575 int len = TYPE_LENGTH (type); 576 577 fprintf_filtered (stream, len < 4 ? "%.11g" : "%.17g", 578 (double) ada_fixed_to_float (type, v)); 579 return 0; 580 } 581 else if (ada_is_vax_floating_type (type)) 582 { 583 struct value *val = 584 value_from_contents_and_address (type, valaddr, address); 585 struct value *func = ada_vax_float_print_function (type); 586 if (func != 0) 587 { 588 static struct type *parray_of_char = NULL; 589 struct value *printable_val; 590 591 if (parray_of_char == NULL) 592 parray_of_char = 593 make_pointer_type 594 (create_array_type 595 (NULL, builtin_type_char, 596 create_range_type (NULL, builtin_type_int, 0, 32)), NULL); 597 598 printable_val = 599 value_ind (value_cast (parray_of_char, 600 call_function_by_hand (func, 1, 601 &val))); 602 603 fprintf_filtered (stream, "%s", VALUE_CONTENTS (printable_val)); 604 return 0; 605 } 606 /* No special printing function. Do as best we can. */ 607 } 608 else if (TYPE_CODE (type) == TYPE_CODE_RANGE) 609 { 610 struct type *target_type = TYPE_TARGET_TYPE (type); 611 if (TYPE_LENGTH (type) != TYPE_LENGTH (target_type)) 612 { 613 /* Obscure case of range type that has different length from 614 its base type. Perform a conversion, or we will get a 615 nonsense value. Actually, we could use the same 616 code regardless of lengths; I'm just avoiding a cast. */ 617 struct value *v = value_cast (target_type, 618 value_from_contents_and_address 619 (type, valaddr, 0)); 620 return ada_val_print_1 (target_type, VALUE_CONTENTS (v), 0, 0, 621 stream, format, 0, recurse + 1, pretty); 622 } 623 else 624 return ada_val_print_1 (TYPE_TARGET_TYPE (type), 625 valaddr0, embedded_offset, 626 address, stream, format, deref_ref, 627 recurse, pretty); 628 } 629 else 630 { 631 format = format ? format : output_format; 632 if (format) 633 { 634 print_scalar_formatted (valaddr, type, format, 0, stream); 635 } 636 else 637 { 638 val_print_type_code_int (type, valaddr, stream); 639 if (ada_is_character_type (type)) 640 { 641 fputs_filtered (" ", stream); 642 ada_printchar ((unsigned char) unpack_long (type, valaddr), 643 stream); 644 } 645 } 646 return 0; 647 } 648 649 case TYPE_CODE_ENUM: 650 if (format) 651 { 652 print_scalar_formatted (valaddr, type, format, 0, stream); 653 break; 654 } 655 len = TYPE_NFIELDS (type); 656 val = unpack_long (type, valaddr); 657 for (i = 0; i < len; i++) 658 { 659 QUIT; 660 if (val == TYPE_FIELD_BITPOS (type, i)) 661 { 662 break; 663 } 664 } 665 if (i < len) 666 { 667 const char *name = ada_enum_name (TYPE_FIELD_NAME (type, i)); 668 if (name[0] == '\'') 669 fprintf_filtered (stream, "%ld %s", (long) val, name); 670 else 671 fputs_filtered (name, stream); 672 } 673 else 674 { 675 print_longest (stream, 'd', 0, val); 676 } 677 break; 678 679 case TYPE_CODE_UNION: 680 case TYPE_CODE_STRUCT: 681 if (ada_is_bogus_array_descriptor (type)) 682 { 683 fprintf_filtered (stream, "(...?)"); 684 return 0; 685 } 686 else 687 { 688 print_record (type, valaddr, stream, format, recurse, pretty); 689 return 0; 690 } 691 692 case TYPE_CODE_ARRAY: 693 if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0) 694 { 695 elttype = TYPE_TARGET_TYPE (type); 696 eltlen = TYPE_LENGTH (elttype); 697 len = TYPE_LENGTH (type) / eltlen; 698 699 /* For an array of chars, print with string syntax. */ 700 if (ada_is_string_type (type) && (format == 0 || format == 's')) 701 { 702 if (prettyprint_arrays) 703 { 704 print_spaces_filtered (2 + 2 * recurse, stream); 705 } 706 /* If requested, look for the first null char and only print 707 elements up to it. */ 708 if (stop_print_at_null) 709 { 710 int temp_len; 711 712 /* Look for a NULL char. */ 713 for (temp_len = 0; 714 temp_len < len && temp_len < print_max 715 && char_at (valaddr, temp_len, eltlen) != 0; 716 temp_len += 1); 717 len = temp_len; 718 } 719 720 printstr (stream, valaddr, len, 0, eltlen); 721 } 722 else 723 { 724 len = 0; 725 fprintf_filtered (stream, "("); 726 print_optional_low_bound (stream, type); 727 if (TYPE_FIELD_BITSIZE (type, 0) > 0) 728 val_print_packed_array_elements (type, valaddr, 0, stream, 729 format, recurse, pretty); 730 else 731 val_print_array_elements (type, valaddr, address, stream, 732 format, deref_ref, recurse, 733 pretty, 0); 734 fprintf_filtered (stream, ")"); 735 } 736 gdb_flush (stream); 737 return len; 738 } 739 740 case TYPE_CODE_REF: 741 elttype = check_typedef (TYPE_TARGET_TYPE (type)); 742 if (addressprint) 743 { 744 fprintf_filtered (stream, "@"); 745 /* Extract an address, assume that the address is unsigned. */ 746 print_address_numeric 747 (extract_unsigned_integer (valaddr, 748 TARGET_PTR_BIT / HOST_CHAR_BIT), 749 1, stream); 750 if (deref_ref) 751 fputs_filtered (": ", stream); 752 } 753 /* De-reference the reference */ 754 if (deref_ref) 755 { 756 if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF) 757 { 758 LONGEST deref_val_int = (LONGEST) 759 unpack_pointer (lookup_pointer_type (builtin_type_void), 760 valaddr); 761 if (deref_val_int != 0) 762 { 763 struct value *deref_val = 764 ada_value_ind (value_from_longest 765 (lookup_pointer_type (elttype), 766 deref_val_int)); 767 val_print (VALUE_TYPE (deref_val), 768 VALUE_CONTENTS (deref_val), 0, 769 VALUE_ADDRESS (deref_val), stream, format, 770 deref_ref, recurse + 1, pretty); 771 } 772 else 773 fputs_filtered ("(null)", stream); 774 } 775 else 776 fputs_filtered ("???", stream); 777 } 778 break; 779 } 780 return 0; 781} 782 783static int 784print_variant_part (struct type *type, int field_num, char *valaddr, 785 struct ui_file *stream, int format, int recurse, 786 enum val_prettyprint pretty, int comma_needed, 787 struct type *outer_type, char *outer_valaddr) 788{ 789 struct type *var_type = TYPE_FIELD_TYPE (type, field_num); 790 int which = ada_which_variant_applies (var_type, outer_type, outer_valaddr); 791 792 if (which < 0) 793 return 0; 794 else 795 return print_field_values 796 (TYPE_FIELD_TYPE (var_type, which), 797 valaddr + TYPE_FIELD_BITPOS (type, field_num) / HOST_CHAR_BIT 798 + TYPE_FIELD_BITPOS (var_type, which) / HOST_CHAR_BIT, 799 stream, format, recurse, pretty, 800 comma_needed, outer_type, outer_valaddr); 801} 802 803int 804ada_value_print (struct value *val0, struct ui_file *stream, int format, 805 enum val_prettyprint pretty) 806{ 807 char *valaddr = VALUE_CONTENTS (val0); 808 CORE_ADDR address = VALUE_ADDRESS (val0) + VALUE_OFFSET (val0); 809 struct type *type = 810 ada_to_fixed_type (VALUE_TYPE (val0), valaddr, address, NULL); 811 struct value *val = 812 value_from_contents_and_address (type, valaddr, address); 813 814 /* If it is a pointer, indicate what it points to. */ 815 if (TYPE_CODE (type) == TYPE_CODE_PTR || TYPE_CODE (type) == TYPE_CODE_REF) 816 { 817 /* Hack: remove (char *) for char strings. Their 818 type is indicated by the quoted string anyway. */ 819 if (TYPE_CODE (type) == TYPE_CODE_PTR && 820 TYPE_LENGTH (TYPE_TARGET_TYPE (type)) == sizeof (char) && 821 TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_INT && 822 !TYPE_UNSIGNED (TYPE_TARGET_TYPE (type))) 823 { 824 /* Print nothing */ 825 } 826 else 827 { 828 fprintf_filtered (stream, "("); 829 type_print (type, "", stream, -1); 830 fprintf_filtered (stream, ") "); 831 } 832 } 833 else if (ada_is_array_descriptor (type)) 834 { 835 fprintf_filtered (stream, "("); 836 type_print (type, "", stream, -1); 837 fprintf_filtered (stream, ") "); 838 } 839 else if (ada_is_bogus_array_descriptor (type)) 840 { 841 fprintf_filtered (stream, "("); 842 type_print (type, "", stream, -1); 843 fprintf_filtered (stream, ") (...?)"); 844 return 0; 845 } 846 return (val_print (type, VALUE_CONTENTS (val), 0, address, 847 stream, format, 1, 0, pretty)); 848} 849 850static void 851print_record (struct type *type, char *valaddr, struct ui_file *stream, 852 int format, int recurse, enum val_prettyprint pretty) 853{ 854 CHECK_TYPEDEF (type); 855 856 fprintf_filtered (stream, "("); 857 858 if (print_field_values (type, valaddr, stream, format, recurse, pretty, 859 0, type, valaddr) != 0 && pretty) 860 { 861 fprintf_filtered (stream, "\n"); 862 print_spaces_filtered (2 * recurse, stream); 863 } 864 865 fprintf_filtered (stream, ")"); 866} 867 868/* Print out fields of value at VALADDR having structure type TYPE. 869 870 TYPE, VALADDR, STREAM, FORMAT, RECURSE, and PRETTY have the 871 same meanings as in ada_print_value and ada_val_print. 872 873 OUTER_TYPE and OUTER_VALADDR give type and address of enclosing record 874 (used to get discriminant values when printing variant parts). 875 876 COMMA_NEEDED is 1 if fields have been printed at the current recursion 877 level, so that a comma is needed before any field printed by this 878 call. 879 880 Returns 1 if COMMA_NEEDED or any fields were printed. */ 881 882static int 883print_field_values (struct type *type, char *valaddr, struct ui_file *stream, 884 int format, int recurse, enum val_prettyprint pretty, 885 int comma_needed, struct type *outer_type, 886 char *outer_valaddr) 887{ 888 int i, len; 889 890 len = TYPE_NFIELDS (type); 891 892 for (i = 0; i < len; i += 1) 893 { 894 if (ada_is_ignored_field (type, i)) 895 continue; 896 897 if (ada_is_wrapper_field (type, i)) 898 { 899 comma_needed = 900 print_field_values (TYPE_FIELD_TYPE (type, i), 901 valaddr 902 + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT, 903 stream, format, recurse, pretty, 904 comma_needed, type, valaddr); 905 continue; 906 } 907 else if (ada_is_variant_part (type, i)) 908 { 909 comma_needed = 910 print_variant_part (type, i, valaddr, 911 stream, format, recurse, pretty, comma_needed, 912 outer_type, outer_valaddr); 913 continue; 914 } 915 916 if (comma_needed) 917 fprintf_filtered (stream, ", "); 918 comma_needed = 1; 919 920 if (pretty) 921 { 922 fprintf_filtered (stream, "\n"); 923 print_spaces_filtered (2 + 2 * recurse, stream); 924 } 925 else 926 { 927 wrap_here (n_spaces (2 + 2 * recurse)); 928 } 929 if (inspect_it) 930 { 931 if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR) 932 fputs_filtered ("\"( ptr \"", stream); 933 else 934 fputs_filtered ("\"( nodef \"", stream); 935 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i), 936 language_cplus, DMGL_NO_OPTS); 937 fputs_filtered ("\" \"", stream); 938 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i), 939 language_cplus, DMGL_NO_OPTS); 940 fputs_filtered ("\") \"", stream); 941 } 942 else 943 { 944 annotate_field_begin (TYPE_FIELD_TYPE (type, i)); 945 fprintf_filtered (stream, "%.*s", 946 ada_name_prefix_len (TYPE_FIELD_NAME (type, i)), 947 TYPE_FIELD_NAME (type, i)); 948 annotate_field_name_end (); 949 fputs_filtered (" => ", stream); 950 annotate_field_value (); 951 } 952 953 if (TYPE_FIELD_PACKED (type, i)) 954 { 955 struct value *v; 956 957 /* Bitfields require special handling, especially due to byte 958 order problems. */ 959 if (TYPE_CPLUS_SPECIFIC (type) != NULL 960 && TYPE_FIELD_IGNORE (type, i)) 961 { 962 fputs_filtered ("<optimized out or zero length>", stream); 963 } 964 else 965 { 966 int bit_pos = TYPE_FIELD_BITPOS (type, i); 967 int bit_size = TYPE_FIELD_BITSIZE (type, i); 968 969 adjust_type_signedness (TYPE_FIELD_TYPE (type, i)); 970 v = ada_value_primitive_packed_val (NULL, valaddr, 971 bit_pos / HOST_CHAR_BIT, 972 bit_pos % HOST_CHAR_BIT, 973 bit_size, 974 TYPE_FIELD_TYPE (type, i)); 975 val_print (TYPE_FIELD_TYPE (type, i), VALUE_CONTENTS (v), 0, 0, 976 stream, format, 0, recurse + 1, pretty); 977 } 978 } 979 else 980 ada_val_print (TYPE_FIELD_TYPE (type, i), 981 valaddr + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT, 982 0, 0, stream, format, 0, recurse + 1, pretty); 983 annotate_field_end (); 984 } 985 986 return comma_needed; 987} 988