1 /* Support for printing Ada values for GDB, the GNU debugger.
3 Copyright (C) 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1997, 2001, 2002,
4 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "gdb_string.h"
26 #include "expression.h"
35 #include "exceptions.h"
38 /* Encapsulates arguments to ada_val_print. */
39 struct ada_val_print_args
42 const gdb_byte *valaddr0;
45 struct ui_file *stream;
49 enum val_prettyprint pretty;
52 static void print_record (struct type *, const gdb_byte *, struct ui_file *,
53 int, int, enum val_prettyprint);
55 static int print_field_values (struct type *, const gdb_byte *,
56 struct ui_file *, int, int,
57 enum val_prettyprint, int, struct type *,
60 static void adjust_type_signedness (struct type *);
62 static int ada_val_print_stub (void *args0);
64 static int ada_val_print_1 (struct type *, const gdb_byte *, int, CORE_ADDR,
65 struct ui_file *, int, int, int,
66 enum val_prettyprint);
69 /* Make TYPE unsigned if its range of values includes no negatives. */
71 adjust_type_signedness (struct type *type)
73 if (type != NULL && TYPE_CODE (type) == TYPE_CODE_RANGE
74 && TYPE_LOW_BOUND (type) >= 0)
75 TYPE_UNSIGNED (type) = 1;
78 /* Assuming TYPE is a simple array type, prints its lower bound on STREAM,
79 if non-standard (i.e., other than 1 for numbers, other than lower bound
80 of index type for enumerated type). Returns 1 if something printed,
84 print_optional_low_bound (struct ui_file *stream, struct type *type)
86 struct type *index_type;
90 if (print_array_indexes_p ())
93 if (!get_array_bounds (type, &low_bound, &high_bound))
96 /* If this is an empty array, then don't print the lower bound.
97 That would be confusing, because we would print the lower bound,
98 followed by... nothing! */
99 if (low_bound > high_bound)
102 index_type = TYPE_INDEX_TYPE (type);
104 if (TYPE_CODE (index_type) == TYPE_CODE_RANGE)
106 /* We need to know what the base type is, in order to do the
107 appropriate check below. Otherwise, if this is a subrange
108 of an enumerated type, where the underlying value of the
109 first element is typically 0, we might test the low bound
110 against the wrong value. */
111 index_type = TYPE_TARGET_TYPE (index_type);
114 switch (TYPE_CODE (index_type))
121 if (low_bound == TYPE_FIELD_BITPOS (index_type, 0))
124 case TYPE_CODE_UNDEF:
125 index_type = builtin_type_int32;
133 ada_print_scalar (index_type, (LONGEST) low_bound, stream);
134 fprintf_filtered (stream, " => ");
138 /* Version of val_print_array_elements for GNAT-style packed arrays.
139 Prints elements of packed array of type TYPE at bit offset
140 BITOFFSET from VALADDR on STREAM. Formats according to FORMAT and
141 separates with commas. RECURSE is the recursion (nesting) level.
142 If PRETTY, uses "prettier" format. TYPE must have been decoded (as
143 by ada_coerce_to_simple_array). */
146 val_print_packed_array_elements (struct type *type, const gdb_byte *valaddr,
147 int bitoffset, struct ui_file *stream,
148 int format, int recurse,
149 enum val_prettyprint pretty)
152 unsigned int things_printed = 0;
154 struct type *elttype, *index_type;
156 unsigned long bitsize = TYPE_FIELD_BITSIZE (type, 0);
157 struct value *mark = value_mark ();
160 elttype = TYPE_TARGET_TYPE (type);
161 eltlen = TYPE_LENGTH (check_typedef (elttype));
162 index_type = TYPE_INDEX_TYPE (type);
166 if (get_discrete_bounds (TYPE_FIELD_TYPE (type, 0), &low, &high) < 0)
169 len = high - low + 1;
173 annotate_array_section_begin (i, elttype);
175 while (i < len && things_printed < print_max)
177 struct value *v0, *v1;
182 if (prettyprint_arrays)
184 fprintf_filtered (stream, ",\n");
185 print_spaces_filtered (2 + 2 * recurse, stream);
189 fprintf_filtered (stream, ", ");
192 wrap_here (n_spaces (2 + 2 * recurse));
193 maybe_print_array_index (index_type, i + low, stream, format, pretty);
196 v0 = ada_value_primitive_packed_val (NULL, valaddr,
197 (i0 * bitsize) / HOST_CHAR_BIT,
198 (i0 * bitsize) % HOST_CHAR_BIT,
205 v1 = ada_value_primitive_packed_val (NULL, valaddr,
206 (i * bitsize) / HOST_CHAR_BIT,
207 (i * bitsize) % HOST_CHAR_BIT,
209 if (memcmp (value_contents (v0), value_contents (v1), eltlen) != 0)
213 if (i - i0 > repeat_count_threshold)
215 val_print (elttype, value_contents (v0), 0, 0, stream, format,
216 0, recurse + 1, pretty, current_language);
217 annotate_elt_rep (i - i0);
218 fprintf_filtered (stream, _(" <repeats %u times>"), i - i0);
219 annotate_elt_rep_end ();
225 for (j = i0; j < i; j += 1)
229 if (prettyprint_arrays)
231 fprintf_filtered (stream, ",\n");
232 print_spaces_filtered (2 + 2 * recurse, stream);
236 fprintf_filtered (stream, ", ");
238 wrap_here (n_spaces (2 + 2 * recurse));
239 maybe_print_array_index (index_type, j + low,
240 stream, format, pretty);
242 val_print (elttype, value_contents (v0), 0, 0, stream, format,
243 0, recurse + 1, pretty, current_language);
247 things_printed += i - i0;
249 annotate_array_section_end ();
252 fprintf_filtered (stream, "...");
255 value_free_to_mark (mark);
259 printable_val_type (struct type *type, const gdb_byte *valaddr)
261 return ada_to_fixed_type (ada_aligned_type (type), valaddr, 0, NULL, 1);
264 /* Print the character C on STREAM as part of the contents of a literal
265 string whose delimiter is QUOTER. TYPE_LEN is the length in bytes
266 (1 or 2) of the character. */
269 ada_emit_char (int c, struct ui_file *stream, int quoter, int type_len)
274 c &= (1 << (type_len * TARGET_CHAR_BIT)) - 1;
276 if (isascii (c) && isprint (c))
278 if (c == quoter && c == '"')
279 fprintf_filtered (stream, "\"\"");
281 fprintf_filtered (stream, "%c", c);
284 fprintf_filtered (stream, "[\"%0*x\"]", type_len * 2, c);
287 /* Character #I of STRING, given that TYPE_LEN is the size in bytes (1
288 or 2) of a character. */
291 char_at (const gdb_byte *string, int i, int type_len)
296 return (int) extract_unsigned_integer (string + 2 * i, 2);
299 /* Wrapper around memcpy to make it legal argument to ui_file_put */
301 ui_memcpy (void *dest, const char *buffer, long len)
303 memcpy (dest, buffer, (size_t) len);
304 ((char *) dest)[len] = '\0';
307 /* Print a floating-point value of type TYPE, pointed to in GDB by
308 VALADDR, on STREAM. Use Ada formatting conventions: there must be
309 a decimal point, and at least one digit before and after the
310 point. We use GNAT format for NaNs and infinities. */
312 ada_print_floating (const gdb_byte *valaddr, struct type *type,
313 struct ui_file *stream)
318 struct ui_file *tmp_stream = mem_fileopen ();
319 struct cleanup *cleanups = make_cleanup_ui_file_delete (tmp_stream);
321 print_floating (valaddr, type, tmp_stream);
322 ui_file_put (tmp_stream, ui_memcpy, buffer);
323 do_cleanups (cleanups);
326 len = strlen (result);
328 /* Modify for Ada rules. */
330 s = strstr (result, "inf");
332 s = strstr (result, "Inf");
334 s = strstr (result, "INF");
340 s = strstr (result, "nan");
342 s = strstr (result, "NaN");
344 s = strstr (result, "Nan");
348 if (result[0] == '-')
353 if (s == NULL && strchr (result, '.') == NULL)
355 s = strchr (result, 'e');
357 fprintf_filtered (stream, "%s.0", result);
359 fprintf_filtered (stream, "%.*s.0%s", (int) (s-result), result, s);
362 fprintf_filtered (stream, "%s", result);
366 ada_printchar (int c, struct ui_file *stream)
368 fputs_filtered ("'", stream);
369 ada_emit_char (c, stream, '\'', 1);
370 fputs_filtered ("'", stream);
373 /* [From print_type_scalar in typeprint.c]. Print VAL on STREAM in a
374 form appropriate for TYPE. */
377 ada_print_scalar (struct type *type, LONGEST val, struct ui_file *stream)
382 type = ada_check_typedef (type);
384 switch (TYPE_CODE (type))
388 len = TYPE_NFIELDS (type);
389 for (i = 0; i < len; i++)
391 if (TYPE_FIELD_BITPOS (type, i) == val)
398 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type, i)), stream);
402 print_longest (stream, 'd', 0, val);
407 print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0, val);
411 LA_PRINT_CHAR ((unsigned char) val, stream);
415 fprintf_filtered (stream, val ? "true" : "false");
418 case TYPE_CODE_RANGE:
419 ada_print_scalar (TYPE_TARGET_TYPE (type), val, stream);
422 case TYPE_CODE_UNDEF:
424 case TYPE_CODE_ARRAY:
425 case TYPE_CODE_STRUCT:
426 case TYPE_CODE_UNION:
431 case TYPE_CODE_STRING:
432 case TYPE_CODE_ERROR:
433 case TYPE_CODE_MEMBERPTR:
434 case TYPE_CODE_METHODPTR:
435 case TYPE_CODE_METHOD:
437 warning (_("internal error: unhandled type in ada_print_scalar"));
441 error (_("Invalid type code in symbol table."));
446 /* Print the character string STRING, printing at most LENGTH characters.
447 Printing stops early if the number hits print_max; repeat counts
448 are printed as appropriate. Print ellipses at the end if we
449 had to stop before printing LENGTH characters, or if
450 FORCE_ELLIPSES. TYPE_LEN is the length (1 or 2) of the character type.
454 printstr (struct ui_file *stream, const gdb_byte *string,
455 unsigned int length, int force_ellipses, int type_len)
458 unsigned int things_printed = 0;
464 fputs_filtered ("\"\"", stream);
468 for (i = 0; i < length && things_printed < print_max; i += 1)
470 /* Position of the character we are examining
471 to see whether it is repeated. */
473 /* Number of repetitions we have detected so far. */
480 fputs_filtered (", ", stream);
487 && char_at (string, rep1, type_len) == char_at (string, i,
494 if (reps > repeat_count_threshold)
499 fputs_filtered ("\\\", ", stream);
501 fputs_filtered ("\", ", stream);
504 fputs_filtered ("'", stream);
505 ada_emit_char (char_at (string, i, type_len), stream, '\'',
507 fputs_filtered ("'", stream);
508 fprintf_filtered (stream, _(" <repeats %u times>"), reps);
510 things_printed += repeat_count_threshold;
518 fputs_filtered ("\\\"", stream);
520 fputs_filtered ("\"", stream);
523 ada_emit_char (char_at (string, i, type_len), stream, '"',
529 /* Terminate the quotes if necessary. */
533 fputs_filtered ("\\\"", stream);
535 fputs_filtered ("\"", stream);
538 if (force_ellipses || i < length)
539 fputs_filtered ("...", stream);
543 ada_printstr (struct ui_file *stream, const gdb_byte *string,
544 unsigned int length, int width, int force_ellipses)
546 printstr (stream, string, length, force_ellipses, width);
550 /* Print data of type TYPE located at VALADDR (within GDB), which came from
551 the inferior at address ADDRESS, onto stdio stream STREAM according to
552 FORMAT (a letter as for the printf % codes or 0 for natural format).
553 The data at VALADDR is in target byte order.
555 If the data is printed as a string, returns the number of string characters
558 If DEREF_REF is nonzero, then dereference references, otherwise just print
561 RECURSE indicates the amount of indentation to supply before
562 continuation lines; this amount is roughly twice the value of RECURSE.
564 When PRETTY is non-zero, prints record fields on separate lines.
565 (For some reason, the current version of gdb instead uses a global
566 variable---prettyprint_arrays--- to causes a similar effect on
570 ada_val_print (struct type *type, const gdb_byte *valaddr0,
571 int embedded_offset, CORE_ADDR address,
572 struct ui_file *stream, int format, int deref_ref,
573 int recurse, enum val_prettyprint pretty)
575 struct ada_val_print_args args;
577 args.valaddr0 = valaddr0;
578 args.embedded_offset = embedded_offset;
579 args.address = address;
580 args.stream = stream;
581 args.format = format;
582 args.deref_ref = deref_ref;
583 args.recurse = recurse;
584 args.pretty = pretty;
586 return catch_errors (ada_val_print_stub, &args, NULL, RETURN_MASK_ALL);
589 /* Helper for ada_val_print; used as argument to catch_errors to
590 unmarshal the arguments to ada_val_print_1, which does the work. */
592 ada_val_print_stub (void *args0)
594 struct ada_val_print_args *argsp = (struct ada_val_print_args *) args0;
595 return ada_val_print_1 (argsp->type, argsp->valaddr0,
596 argsp->embedded_offset, argsp->address,
597 argsp->stream, argsp->format, argsp->deref_ref,
598 argsp->recurse, argsp->pretty);
601 /* Assuming TYPE is a simple array, print the value of this array located
602 at VALADDR. See ada_val_print for a description of the various
603 parameters of this function; they are identical. The semantics
604 of the return value is also identical to ada_val_print. */
607 ada_val_print_array (struct type *type, const gdb_byte *valaddr,
608 CORE_ADDR address, struct ui_file *stream, int format,
609 int deref_ref, int recurse, enum val_prettyprint pretty)
611 struct type *elttype = TYPE_TARGET_TYPE (type);
619 eltlen = TYPE_LENGTH (elttype);
623 len = TYPE_LENGTH (type) / eltlen;
625 /* For an array of chars, print with string syntax. */
626 if (ada_is_string_type (type) && (format == 0 || format == 's'))
628 if (prettyprint_arrays)
629 print_spaces_filtered (2 + 2 * recurse, stream);
631 /* If requested, look for the first null char and only print
632 elements up to it. */
633 if (stop_print_at_null)
637 /* Look for a NULL char. */
640 && temp_len < print_max
641 && char_at (valaddr, temp_len, eltlen) != 0);
646 printstr (stream, valaddr, len, 0, eltlen);
651 fprintf_filtered (stream, "(");
652 print_optional_low_bound (stream, type);
653 if (TYPE_FIELD_BITSIZE (type, 0) > 0)
654 val_print_packed_array_elements (type, valaddr, 0, stream,
655 format, recurse, pretty);
657 val_print_array_elements (type, valaddr, address, stream,
658 format, deref_ref, recurse,
660 fprintf_filtered (stream, ")");
666 /* See the comment on ada_val_print. This function differs in that it
667 does not catch evaluation errors (leaving that to ada_val_print). */
670 ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
671 int embedded_offset, CORE_ADDR address,
672 struct ui_file *stream, int format,
673 int deref_ref, int recurse, enum val_prettyprint pretty)
677 struct type *elttype;
680 const gdb_byte *valaddr = valaddr0 + embedded_offset;
682 type = ada_check_typedef (type);
684 if (ada_is_array_descriptor_type (type) || ada_is_packed_array_type (type))
687 struct value *mark = value_mark ();
689 val = value_from_contents_and_address (type, valaddr, address);
690 val = ada_coerce_to_simple_array_ptr (val);
693 fprintf_filtered (stream, "(null)");
697 retn = ada_val_print_1 (value_type (val), value_contents (val), 0,
698 VALUE_ADDRESS (val), stream, format,
699 deref_ref, recurse, pretty);
700 value_free_to_mark (mark);
704 valaddr = ada_aligned_value_addr (type, valaddr);
705 embedded_offset -= valaddr - valaddr0 - embedded_offset;
706 type = printable_val_type (type, valaddr);
708 switch (TYPE_CODE (type))
711 return c_val_print (type, valaddr0, embedded_offset, address, stream,
712 format, deref_ref, recurse, pretty);
716 int ret = c_val_print (type, valaddr0, embedded_offset, address,
717 stream, format, deref_ref, recurse, pretty);
718 if (ada_is_tag_type (type))
721 value_from_contents_and_address (type, valaddr, address);
722 const char *name = ada_tag_name (val);
724 fprintf_filtered (stream, " (%s)", name);
731 case TYPE_CODE_RANGE:
732 if (ada_is_fixed_point_type (type))
734 LONGEST v = unpack_long (type, valaddr);
735 int len = TYPE_LENGTH (type);
737 fprintf_filtered (stream, len < 4 ? "%.11g" : "%.17g",
738 (double) ada_fixed_to_float (type, v));
741 else if (ada_is_vax_floating_type (type))
744 value_from_contents_and_address (type, valaddr, address);
745 struct value *func = ada_vax_float_print_function (type);
748 static struct type *parray_of_char = NULL;
749 struct value *printable_val;
751 if (parray_of_char == NULL)
755 (NULL, builtin_type_true_char,
756 create_range_type (NULL, builtin_type_int32, 0, 32)), NULL);
759 value_ind (value_cast (parray_of_char,
760 call_function_by_hand (func, 1,
763 fprintf_filtered (stream, "%s", value_contents (printable_val));
766 /* No special printing function. Do as best we can. */
768 else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
770 struct type *target_type = TYPE_TARGET_TYPE (type);
771 if (TYPE_LENGTH (type) != TYPE_LENGTH (target_type))
773 /* Obscure case of range type that has different length from
774 its base type. Perform a conversion, or we will get a
775 nonsense value. Actually, we could use the same
776 code regardless of lengths; I'm just avoiding a cast. */
777 struct value *v = value_cast (target_type,
778 value_from_contents_and_address
780 return ada_val_print_1 (target_type, value_contents (v), 0, 0,
781 stream, format, 0, recurse + 1, pretty);
784 return ada_val_print_1 (TYPE_TARGET_TYPE (type),
785 valaddr0, embedded_offset,
786 address, stream, format, deref_ref,
791 format = format ? format : output_format;
794 print_scalar_formatted (valaddr, type, format, 0, stream);
796 else if (ada_is_system_address_type (type)
797 && TYPE_OBJFILE (type) != NULL)
799 /* FIXME: We want to print System.Address variables using
800 the same format as for any access type. But for some
801 reason GNAT encodes the System.Address type as an int,
802 so we have to work-around this deficiency by handling
803 System.Address values as a special case.
805 We do this only for System.Address types defined in an
806 objfile. For the built-in version of System.Address we
807 have installed the proper type to begin with. */
809 struct gdbarch *gdbarch = get_objfile_arch (TYPE_OBJFILE (type));
810 struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
812 fprintf_filtered (stream, "(");
813 type_print (type, "", stream, -1);
814 fprintf_filtered (stream, ") ");
815 fputs_filtered (paddress (extract_typed_address
816 (valaddr, ptr_type)),
821 val_print_type_code_int (type, valaddr, stream);
822 if (ada_is_character_type (type))
824 fputs_filtered (" ", stream);
825 ada_printchar ((unsigned char) unpack_long (type, valaddr),
835 print_scalar_formatted (valaddr, type, format, 0, stream);
838 len = TYPE_NFIELDS (type);
839 val = unpack_long (type, valaddr);
840 for (i = 0; i < len; i++)
843 if (val == TYPE_FIELD_BITPOS (type, i))
850 const char *name = ada_enum_name (TYPE_FIELD_NAME (type, i));
852 fprintf_filtered (stream, "%ld %s", (long) val, name);
854 fputs_filtered (name, stream);
858 print_longest (stream, 'd', 0, val);
862 case TYPE_CODE_FLAGS:
864 print_scalar_formatted (valaddr, type, format, 0, stream);
866 val_print_type_code_flags (type, valaddr, stream);
871 return c_val_print (type, valaddr0, embedded_offset, address, stream,
872 format, deref_ref, recurse, pretty);
874 ada_print_floating (valaddr0 + embedded_offset, type, stream);
877 case TYPE_CODE_UNION:
878 case TYPE_CODE_STRUCT:
879 if (ada_is_bogus_array_descriptor (type))
881 fprintf_filtered (stream, "(...?)");
886 print_record (type, valaddr, stream, format, recurse, pretty);
890 case TYPE_CODE_ARRAY:
891 return ada_val_print_array (type, valaddr, address, stream, format,
892 deref_ref, recurse, pretty);
895 /* For references, the debugger is expected to print the value as
896 an address if DEREF_REF is null. But printing an address in place
897 of the object value would be confusing to an Ada programmer.
898 So, for Ada values, we print the actual dereferenced value
900 elttype = check_typedef (TYPE_TARGET_TYPE (type));
902 if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
904 LONGEST deref_val_int = (LONGEST) unpack_pointer (type, valaddr);
905 if (deref_val_int != 0)
907 struct value *deref_val =
908 ada_value_ind (value_from_longest
909 (lookup_pointer_type (elttype),
911 val_print (value_type (deref_val),
912 value_contents (deref_val), 0,
913 VALUE_ADDRESS (deref_val), stream, format,
914 deref_ref, recurse + 1, pretty, current_language);
917 fputs_filtered ("(null)", stream);
920 fputs_filtered ("???", stream);
929 print_variant_part (struct type *type, int field_num, const gdb_byte *valaddr,
930 struct ui_file *stream, int format, int recurse,
931 enum val_prettyprint pretty, int comma_needed,
932 struct type *outer_type, const gdb_byte *outer_valaddr)
934 struct type *var_type = TYPE_FIELD_TYPE (type, field_num);
935 int which = ada_which_variant_applies (var_type, outer_type, outer_valaddr);
940 return print_field_values
941 (TYPE_FIELD_TYPE (var_type, which),
942 valaddr + TYPE_FIELD_BITPOS (type, field_num) / HOST_CHAR_BIT
943 + TYPE_FIELD_BITPOS (var_type, which) / HOST_CHAR_BIT,
944 stream, format, recurse, pretty,
945 comma_needed, outer_type, outer_valaddr);
949 ada_value_print (struct value *val0, struct ui_file *stream, int format,
950 enum val_prettyprint pretty)
952 const gdb_byte *valaddr = value_contents (val0);
953 CORE_ADDR address = VALUE_ADDRESS (val0) + value_offset (val0);
955 ada_to_fixed_type (value_type (val0), valaddr, address, NULL, 1);
957 value_from_contents_and_address (type, valaddr, address);
959 /* If it is a pointer, indicate what it points to. */
960 if (TYPE_CODE (type) == TYPE_CODE_PTR)
962 /* Hack: don't print (char *) for char strings. Their
963 type is indicated by the quoted string anyway. */
964 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) != sizeof (char)
965 || TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_INT
966 || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type)))
968 fprintf_filtered (stream, "(");
969 type_print (type, "", stream, -1);
970 fprintf_filtered (stream, ") ");
973 else if (ada_is_array_descriptor_type (type))
975 fprintf_filtered (stream, "(");
976 type_print (type, "", stream, -1);
977 fprintf_filtered (stream, ") ");
979 else if (ada_is_bogus_array_descriptor (type))
981 fprintf_filtered (stream, "(");
982 type_print (type, "", stream, -1);
983 fprintf_filtered (stream, ") (...?)");
987 return (val_print (type, value_contents (val), 0, address,
988 stream, format, 1, 0, pretty, current_language));
992 print_record (struct type *type, const gdb_byte *valaddr,
993 struct ui_file *stream, int format, int recurse,
994 enum val_prettyprint pretty)
996 type = ada_check_typedef (type);
998 fprintf_filtered (stream, "(");
1000 if (print_field_values (type, valaddr, stream, format, recurse, pretty,
1001 0, type, valaddr) != 0 && pretty)
1003 fprintf_filtered (stream, "\n");
1004 print_spaces_filtered (2 * recurse, stream);
1007 fprintf_filtered (stream, ")");
1010 /* Print out fields of value at VALADDR having structure type TYPE.
1012 TYPE, VALADDR, STREAM, FORMAT, RECURSE, and PRETTY have the
1013 same meanings as in ada_print_value and ada_val_print.
1015 OUTER_TYPE and OUTER_VALADDR give type and address of enclosing record
1016 (used to get discriminant values when printing variant parts).
1018 COMMA_NEEDED is 1 if fields have been printed at the current recursion
1019 level, so that a comma is needed before any field printed by this
1022 Returns 1 if COMMA_NEEDED or any fields were printed. */
1025 print_field_values (struct type *type, const gdb_byte *valaddr,
1026 struct ui_file *stream, int format, int recurse,
1027 enum val_prettyprint pretty, int comma_needed,
1028 struct type *outer_type, const gdb_byte *outer_valaddr)
1032 len = TYPE_NFIELDS (type);
1034 for (i = 0; i < len; i += 1)
1036 if (ada_is_ignored_field (type, i))
1039 if (ada_is_wrapper_field (type, i))
1042 print_field_values (TYPE_FIELD_TYPE (type, i),
1044 + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
1045 stream, format, recurse, pretty,
1046 comma_needed, type, valaddr);
1049 else if (ada_is_variant_part (type, i))
1052 print_variant_part (type, i, valaddr,
1053 stream, format, recurse, pretty, comma_needed,
1054 outer_type, outer_valaddr);
1059 fprintf_filtered (stream, ", ");
1064 fprintf_filtered (stream, "\n");
1065 print_spaces_filtered (2 + 2 * recurse, stream);
1069 wrap_here (n_spaces (2 + 2 * recurse));
1073 if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
1074 fputs_filtered ("\"( ptr \"", stream);
1076 fputs_filtered ("\"( nodef \"", stream);
1077 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
1078 language_cplus, DMGL_NO_OPTS);
1079 fputs_filtered ("\" \"", stream);
1080 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
1081 language_cplus, DMGL_NO_OPTS);
1082 fputs_filtered ("\") \"", stream);
1086 annotate_field_begin (TYPE_FIELD_TYPE (type, i));
1087 fprintf_filtered (stream, "%.*s",
1088 ada_name_prefix_len (TYPE_FIELD_NAME (type, i)),
1089 TYPE_FIELD_NAME (type, i));
1090 annotate_field_name_end ();
1091 fputs_filtered (" => ", stream);
1092 annotate_field_value ();
1095 if (TYPE_FIELD_PACKED (type, i))
1099 /* Bitfields require special handling, especially due to byte
1101 if (TYPE_CPLUS_SPECIFIC (type) != NULL
1102 && TYPE_FIELD_IGNORE (type, i))
1104 fputs_filtered (_("<optimized out or zero length>"), stream);
1108 int bit_pos = TYPE_FIELD_BITPOS (type, i);
1109 int bit_size = TYPE_FIELD_BITSIZE (type, i);
1111 adjust_type_signedness (TYPE_FIELD_TYPE (type, i));
1112 v = ada_value_primitive_packed_val (NULL, valaddr,
1113 bit_pos / HOST_CHAR_BIT,
1114 bit_pos % HOST_CHAR_BIT,
1116 TYPE_FIELD_TYPE (type, i));
1117 val_print (TYPE_FIELD_TYPE (type, i), value_contents (v), 0, 0,
1118 stream, format, 0, recurse + 1, pretty,
1123 ada_val_print (TYPE_FIELD_TYPE (type, i),
1124 valaddr + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
1125 0, 0, stream, format, 0, recurse + 1, pretty);
1126 annotate_field_end ();
1129 return comma_needed;