1 /* Support for printing Ada values for GDB, the GNU debugger.
3 Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1997, 2001,
4 2002, 2003, 2004, 2005 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 2 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, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
24 #include "gdb_string.h"
27 #include "expression.h"
36 #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_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
78 /* Assuming TYPE is a simple, non-empty array type, prints its lower bound
79 on STREAM, if non-standard (i.e., other than 1 for numbers, other
80 than lower bound of index type for enumerated type). Returns 1
81 if something printed, otherwise 0. */
84 print_optional_low_bound (struct ui_file
*stream
, struct type
*type
)
86 struct type
*index_type
;
89 if (print_array_indexes_p ())
92 if (!get_array_low_bound (type
, &low_bound
))
95 index_type
= TYPE_INDEX_TYPE (type
);
97 switch (TYPE_CODE (index_type
))
100 if (low_bound
== TYPE_FIELD_BITPOS (index_type
, 0))
103 case TYPE_CODE_UNDEF
:
104 index_type
= builtin_type_long
;
112 ada_print_scalar (index_type
, (LONGEST
) low_bound
, stream
);
113 fprintf_filtered (stream
, " => ");
117 /* Version of val_print_array_elements for GNAT-style packed arrays.
118 Prints elements of packed array of type TYPE at bit offset
119 BITOFFSET from VALADDR on STREAM. Formats according to FORMAT and
120 separates with commas. RECURSE is the recursion (nesting) level.
121 If PRETTY, uses "prettier" format. TYPE must have been decoded (as
122 by ada_coerce_to_simple_array). */
125 val_print_packed_array_elements (struct type
*type
, const gdb_byte
*valaddr
,
126 int bitoffset
, struct ui_file
*stream
,
127 int format
, int recurse
,
128 enum val_prettyprint pretty
)
131 unsigned int things_printed
= 0;
133 struct type
*elttype
, *index_type
;
135 unsigned long bitsize
= TYPE_FIELD_BITSIZE (type
, 0);
136 struct value
*mark
= value_mark ();
139 elttype
= TYPE_TARGET_TYPE (type
);
140 eltlen
= TYPE_LENGTH (check_typedef (elttype
));
141 index_type
= TYPE_INDEX_TYPE (type
);
145 if (get_discrete_bounds (TYPE_FIELD_TYPE (type
, 0), &low
, &high
) < 0)
148 len
= high
- low
+ 1;
152 annotate_array_section_begin (i
, elttype
);
154 while (i
< len
&& things_printed
< print_max
)
156 struct value
*v0
, *v1
;
161 if (prettyprint_arrays
)
163 fprintf_filtered (stream
, ",\n");
164 print_spaces_filtered (2 + 2 * recurse
, stream
);
168 fprintf_filtered (stream
, ", ");
171 wrap_here (n_spaces (2 + 2 * recurse
));
172 maybe_print_array_index (index_type
, i
+ low
, stream
, format
, pretty
);
175 v0
= ada_value_primitive_packed_val (NULL
, valaddr
,
176 (i0
* bitsize
) / HOST_CHAR_BIT
,
177 (i0
* bitsize
) % HOST_CHAR_BIT
,
184 v1
= ada_value_primitive_packed_val (NULL
, valaddr
,
185 (i
* bitsize
) / HOST_CHAR_BIT
,
186 (i
* bitsize
) % HOST_CHAR_BIT
,
188 if (memcmp (value_contents (v0
), value_contents (v1
), eltlen
) != 0)
192 if (i
- i0
> repeat_count_threshold
)
194 val_print (elttype
, value_contents (v0
), 0, 0, stream
, format
,
195 0, recurse
+ 1, pretty
);
196 annotate_elt_rep (i
- i0
);
197 fprintf_filtered (stream
, _(" <repeats %u times>"), i
- i0
);
198 annotate_elt_rep_end ();
204 for (j
= i0
; j
< i
; j
+= 1)
208 if (prettyprint_arrays
)
210 fprintf_filtered (stream
, ",\n");
211 print_spaces_filtered (2 + 2 * recurse
, stream
);
215 fprintf_filtered (stream
, ", ");
217 wrap_here (n_spaces (2 + 2 * recurse
));
218 maybe_print_array_index (index_type
, j
+ low
,
219 stream
, format
, pretty
);
221 val_print (elttype
, value_contents (v0
), 0, 0, stream
, format
,
222 0, recurse
+ 1, pretty
);
226 things_printed
+= i
- i0
;
228 annotate_array_section_end ();
231 fprintf_filtered (stream
, "...");
234 value_free_to_mark (mark
);
238 printable_val_type (struct type
*type
, const gdb_byte
*valaddr
)
240 return ada_to_fixed_type (ada_aligned_type (type
), valaddr
, 0, NULL
);
243 /* Print the character C on STREAM as part of the contents of a literal
244 string whose delimiter is QUOTER. TYPE_LEN is the length in bytes
245 (1 or 2) of the character. */
248 ada_emit_char (int c
, struct ui_file
*stream
, int quoter
, int type_len
)
253 c
&= (1 << (type_len
* TARGET_CHAR_BIT
)) - 1;
255 if (isascii (c
) && isprint (c
))
257 if (c
== quoter
&& c
== '"')
258 fprintf_filtered (stream
, "[\"%c\"]", quoter
);
260 fprintf_filtered (stream
, "%c", c
);
263 fprintf_filtered (stream
, "[\"%0*x\"]", type_len
* 2, c
);
266 /* Character #I of STRING, given that TYPE_LEN is the size in bytes (1
267 or 2) of a character. */
270 char_at (const gdb_byte
*string
, int i
, int type_len
)
275 return (int) extract_unsigned_integer (string
+ 2 * i
, 2);
278 /* Wrapper around memcpy to make it legal argument to ui_file_put */
280 ui_memcpy (void *dest
, const char *buffer
, long len
)
282 memcpy (dest
, buffer
, (size_t) len
);
283 ((char *) dest
)[len
] = '\0';
286 /* Print a floating-point value of type TYPE, pointed to in GDB by
287 VALADDR, on STREAM. Use Ada formatting conventions: there must be
288 a decimal point, and at least one digit before and after the
289 point. We use GNAT format for NaNs and infinities. */
291 ada_print_floating (const gdb_byte
*valaddr
, struct type
*type
,
292 struct ui_file
*stream
)
297 struct ui_file
*tmp_stream
= mem_fileopen ();
298 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (tmp_stream
);
300 print_floating (valaddr
, type
, tmp_stream
);
301 ui_file_put (tmp_stream
, ui_memcpy
, buffer
);
302 do_cleanups (cleanups
);
305 len
= strlen (result
);
307 /* Modify for Ada rules. */
309 s
= strstr (result
, "inf");
311 s
= strstr (result
, "Inf");
313 s
= strstr (result
, "INF");
319 s
= strstr (result
, "nan");
321 s
= strstr (result
, "NaN");
323 s
= strstr (result
, "Nan");
327 if (result
[0] == '-')
332 if (s
== NULL
&& strchr (result
, '.') == NULL
)
334 s
= strchr (result
, 'e');
336 fprintf_filtered (stream
, "%s.0", result
);
338 fprintf_filtered (stream
, "%.*s.0%s", (int) (s
-result
), result
, s
);
341 fprintf_filtered (stream
, "%s", result
);
345 ada_printchar (int c
, struct ui_file
*stream
)
347 fputs_filtered ("'", stream
);
348 ada_emit_char (c
, stream
, '\'', 1);
349 fputs_filtered ("'", stream
);
352 /* [From print_type_scalar in typeprint.c]. Print VAL on STREAM in a
353 form appropriate for TYPE. */
356 ada_print_scalar (struct type
*type
, LONGEST val
, struct ui_file
*stream
)
361 type
= ada_check_typedef (type
);
363 switch (TYPE_CODE (type
))
367 len
= TYPE_NFIELDS (type
);
368 for (i
= 0; i
< len
; i
++)
370 if (TYPE_FIELD_BITPOS (type
, i
) == val
)
377 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type
, i
)), stream
);
381 print_longest (stream
, 'd', 0, val
);
386 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0, val
);
390 LA_PRINT_CHAR ((unsigned char) val
, stream
);
394 fprintf_filtered (stream
, val
? "true" : "false");
397 case TYPE_CODE_RANGE
:
398 ada_print_scalar (TYPE_TARGET_TYPE (type
), val
, stream
);
401 case TYPE_CODE_UNDEF
:
403 case TYPE_CODE_ARRAY
:
404 case TYPE_CODE_STRUCT
:
405 case TYPE_CODE_UNION
:
410 case TYPE_CODE_STRING
:
411 case TYPE_CODE_ERROR
:
412 case TYPE_CODE_MEMBER
:
413 case TYPE_CODE_METHOD
:
415 warning (_("internal error: unhandled type in ada_print_scalar"));
419 error (_("Invalid type code in symbol table."));
424 /* Print the character string STRING, printing at most LENGTH characters.
425 Printing stops early if the number hits print_max; repeat counts
426 are printed as appropriate. Print ellipses at the end if we
427 had to stop before printing LENGTH characters, or if
428 FORCE_ELLIPSES. TYPE_LEN is the length (1 or 2) of the character type.
432 printstr (struct ui_file
*stream
, const gdb_byte
*string
,
433 unsigned int length
, int force_ellipses
, int type_len
)
436 unsigned int things_printed
= 0;
442 fputs_filtered ("\"\"", stream
);
446 for (i
= 0; i
< length
&& things_printed
< print_max
; i
+= 1)
448 /* Position of the character we are examining
449 to see whether it is repeated. */
451 /* Number of repetitions we have detected so far. */
458 fputs_filtered (", ", stream
);
465 && char_at (string
, rep1
, type_len
) == char_at (string
, i
,
472 if (reps
> repeat_count_threshold
)
477 fputs_filtered ("\\\", ", stream
);
479 fputs_filtered ("\", ", stream
);
482 fputs_filtered ("'", stream
);
483 ada_emit_char (char_at (string
, i
, type_len
), stream
, '\'',
485 fputs_filtered ("'", stream
);
486 fprintf_filtered (stream
, _(" <repeats %u times>"), reps
);
488 things_printed
+= repeat_count_threshold
;
496 fputs_filtered ("\\\"", stream
);
498 fputs_filtered ("\"", stream
);
501 ada_emit_char (char_at (string
, i
, type_len
), stream
, '"',
507 /* Terminate the quotes if necessary. */
511 fputs_filtered ("\\\"", stream
);
513 fputs_filtered ("\"", stream
);
516 if (force_ellipses
|| i
< length
)
517 fputs_filtered ("...", stream
);
521 ada_printstr (struct ui_file
*stream
, const gdb_byte
*string
,
522 unsigned int length
, int width
, int force_ellipses
)
524 printstr (stream
, string
, length
, force_ellipses
, width
);
528 /* Print data of type TYPE located at VALADDR (within GDB), which came from
529 the inferior at address ADDRESS, onto stdio stream STREAM according to
530 FORMAT (a letter as for the printf % codes or 0 for natural format).
531 The data at VALADDR is in target byte order.
533 If the data is printed as a string, returns the number of string characters
536 If DEREF_REF is nonzero, then dereference references, otherwise just print
539 RECURSE indicates the amount of indentation to supply before
540 continuation lines; this amount is roughly twice the value of RECURSE.
542 When PRETTY is non-zero, prints record fields on separate lines.
543 (For some reason, the current version of gdb instead uses a global
544 variable---prettyprint_arrays--- to causes a similar effect on
548 ada_val_print (struct type
*type
, const gdb_byte
*valaddr0
,
549 int embedded_offset
, CORE_ADDR address
,
550 struct ui_file
*stream
, int format
, int deref_ref
,
551 int recurse
, enum val_prettyprint pretty
)
553 struct ada_val_print_args args
;
555 args
.valaddr0
= valaddr0
;
556 args
.embedded_offset
= embedded_offset
;
557 args
.address
= address
;
558 args
.stream
= stream
;
559 args
.format
= format
;
560 args
.deref_ref
= deref_ref
;
561 args
.recurse
= recurse
;
562 args
.pretty
= pretty
;
564 return catch_errors (ada_val_print_stub
, &args
, NULL
, RETURN_MASK_ALL
);
567 /* Helper for ada_val_print; used as argument to catch_errors to
568 unmarshal the arguments to ada_val_print_1, which does the work. */
570 ada_val_print_stub (void *args0
)
572 struct ada_val_print_args
*argsp
= (struct ada_val_print_args
*) args0
;
573 return ada_val_print_1 (argsp
->type
, argsp
->valaddr0
,
574 argsp
->embedded_offset
, argsp
->address
,
575 argsp
->stream
, argsp
->format
, argsp
->deref_ref
,
576 argsp
->recurse
, argsp
->pretty
);
579 /* See the comment on ada_val_print. This function differs in that it
580 * does not catch evaluation errors (leaving that to ada_val_print). */
583 ada_val_print_1 (struct type
*type
, const gdb_byte
*valaddr0
,
584 int embedded_offset
, CORE_ADDR address
,
585 struct ui_file
*stream
, int format
,
586 int deref_ref
, int recurse
, enum val_prettyprint pretty
)
590 struct type
*elttype
;
593 const gdb_byte
*valaddr
= valaddr0
+ embedded_offset
;
595 type
= ada_check_typedef (type
);
597 if (ada_is_array_descriptor_type (type
) || ada_is_packed_array_type (type
))
600 struct value
*mark
= value_mark ();
602 val
= value_from_contents_and_address (type
, valaddr
, address
);
603 val
= ada_coerce_to_simple_array_ptr (val
);
606 fprintf_filtered (stream
, "(null)");
610 retn
= ada_val_print_1 (value_type (val
), value_contents (val
), 0,
611 VALUE_ADDRESS (val
), stream
, format
,
612 deref_ref
, recurse
, pretty
);
613 value_free_to_mark (mark
);
617 valaddr
= ada_aligned_value_addr (type
, valaddr
);
618 embedded_offset
-= valaddr
- valaddr0
- embedded_offset
;
619 type
= printable_val_type (type
, valaddr
);
621 switch (TYPE_CODE (type
))
624 return c_val_print (type
, valaddr0
, embedded_offset
, address
, stream
,
625 format
, deref_ref
, recurse
, pretty
);
629 int ret
= c_val_print (type
, valaddr0
, embedded_offset
, address
,
630 stream
, format
, deref_ref
, recurse
, pretty
);
631 if (ada_is_tag_type (type
))
634 value_from_contents_and_address (type
, valaddr
, address
);
635 const char *name
= ada_tag_name (val
);
637 fprintf_filtered (stream
, " (%s)", name
);
644 case TYPE_CODE_RANGE
:
645 if (ada_is_fixed_point_type (type
))
647 LONGEST v
= unpack_long (type
, valaddr
);
648 int len
= TYPE_LENGTH (type
);
650 fprintf_filtered (stream
, len
< 4 ? "%.11g" : "%.17g",
651 (double) ada_fixed_to_float (type
, v
));
654 else if (ada_is_vax_floating_type (type
))
657 value_from_contents_and_address (type
, valaddr
, address
);
658 struct value
*func
= ada_vax_float_print_function (type
);
661 static struct type
*parray_of_char
= NULL
;
662 struct value
*printable_val
;
664 if (parray_of_char
== NULL
)
668 (NULL
, builtin_type_char
,
669 create_range_type (NULL
, builtin_type_int
, 0, 32)), NULL
);
672 value_ind (value_cast (parray_of_char
,
673 call_function_by_hand (func
, 1,
676 fprintf_filtered (stream
, "%s", value_contents (printable_val
));
679 /* No special printing function. Do as best we can. */
681 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
683 struct type
*target_type
= TYPE_TARGET_TYPE (type
);
684 if (TYPE_LENGTH (type
) != TYPE_LENGTH (target_type
))
686 /* Obscure case of range type that has different length from
687 its base type. Perform a conversion, or we will get a
688 nonsense value. Actually, we could use the same
689 code regardless of lengths; I'm just avoiding a cast. */
690 struct value
*v
= value_cast (target_type
,
691 value_from_contents_and_address
693 return ada_val_print_1 (target_type
, value_contents (v
), 0, 0,
694 stream
, format
, 0, recurse
+ 1, pretty
);
697 return ada_val_print_1 (TYPE_TARGET_TYPE (type
),
698 valaddr0
, embedded_offset
,
699 address
, stream
, format
, deref_ref
,
704 format
= format
? format
: output_format
;
707 print_scalar_formatted (valaddr
, type
, format
, 0, stream
);
709 else if (ada_is_system_address_type (type
))
711 /* FIXME: We want to print System.Address variables using
712 the same format as for any access type. But for some
713 reason GNAT encodes the System.Address type as an int,
714 so we have to work-around this deficiency by handling
715 System.Address values as a special case. */
716 fprintf_filtered (stream
, "(");
717 type_print (type
, "", stream
, -1);
718 fprintf_filtered (stream
, ") ");
719 deprecated_print_address_numeric
720 (extract_typed_address (valaddr
, builtin_type_void_data_ptr
),
725 val_print_type_code_int (type
, valaddr
, stream
);
726 if (ada_is_character_type (type
))
728 fputs_filtered (" ", stream
);
729 ada_printchar ((unsigned char) unpack_long (type
, valaddr
),
739 print_scalar_formatted (valaddr
, type
, format
, 0, stream
);
742 len
= TYPE_NFIELDS (type
);
743 val
= unpack_long (type
, valaddr
);
744 for (i
= 0; i
< len
; i
++)
747 if (val
== TYPE_FIELD_BITPOS (type
, i
))
754 const char *name
= ada_enum_name (TYPE_FIELD_NAME (type
, i
));
756 fprintf_filtered (stream
, "%ld %s", (long) val
, name
);
758 fputs_filtered (name
, stream
);
762 print_longest (stream
, 'd', 0, val
);
768 return c_val_print (type
, valaddr0
, embedded_offset
, address
, stream
,
769 format
, deref_ref
, recurse
, pretty
);
771 ada_print_floating (valaddr0
+ embedded_offset
, type
, stream
);
774 case TYPE_CODE_UNION
:
775 case TYPE_CODE_STRUCT
:
776 if (ada_is_bogus_array_descriptor (type
))
778 fprintf_filtered (stream
, "(...?)");
783 print_record (type
, valaddr
, stream
, format
, recurse
, pretty
);
787 case TYPE_CODE_ARRAY
:
788 elttype
= TYPE_TARGET_TYPE (type
);
792 eltlen
= TYPE_LENGTH (elttype
);
793 /* FIXME: This doesn't deal with non-empty arrays of
794 0-length items (not a typical case!) */
798 len
= TYPE_LENGTH (type
) / eltlen
;
800 /* For an array of chars, print with string syntax. */
801 if (ada_is_string_type (type
) && (format
== 0 || format
== 's'))
803 if (prettyprint_arrays
)
805 print_spaces_filtered (2 + 2 * recurse
, stream
);
807 /* If requested, look for the first null char and only print
808 elements up to it. */
809 if (stop_print_at_null
)
813 /* Look for a NULL char. */
815 temp_len
< len
&& temp_len
< print_max
816 && char_at (valaddr
, temp_len
, eltlen
) != 0;
821 printstr (stream
, valaddr
, len
, 0, eltlen
);
826 fprintf_filtered (stream
, "(");
827 print_optional_low_bound (stream
, type
);
828 if (TYPE_FIELD_BITSIZE (type
, 0) > 0)
829 val_print_packed_array_elements (type
, valaddr
, 0, stream
,
830 format
, recurse
, pretty
);
832 val_print_array_elements (type
, valaddr
, address
, stream
,
833 format
, deref_ref
, recurse
,
835 fprintf_filtered (stream
, ")");
841 elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
842 /* De-reference the reference */
845 if (TYPE_CODE (elttype
) != TYPE_CODE_UNDEF
)
847 LONGEST deref_val_int
= (LONGEST
)
848 unpack_pointer (lookup_pointer_type (builtin_type_void
),
850 if (deref_val_int
!= 0)
852 struct value
*deref_val
=
853 ada_value_ind (value_from_longest
854 (lookup_pointer_type (elttype
),
856 val_print (value_type (deref_val
),
857 value_contents (deref_val
), 0,
858 VALUE_ADDRESS (deref_val
), stream
, format
,
859 deref_ref
, recurse
+ 1, pretty
);
862 fputs_filtered ("(null)", stream
);
865 fputs_filtered ("???", stream
);
874 print_variant_part (struct type
*type
, int field_num
, const gdb_byte
*valaddr
,
875 struct ui_file
*stream
, int format
, int recurse
,
876 enum val_prettyprint pretty
, int comma_needed
,
877 struct type
*outer_type
, const gdb_byte
*outer_valaddr
)
879 struct type
*var_type
= TYPE_FIELD_TYPE (type
, field_num
);
880 int which
= ada_which_variant_applies (var_type
, outer_type
, outer_valaddr
);
885 return print_field_values
886 (TYPE_FIELD_TYPE (var_type
, which
),
887 valaddr
+ TYPE_FIELD_BITPOS (type
, field_num
) / HOST_CHAR_BIT
888 + TYPE_FIELD_BITPOS (var_type
, which
) / HOST_CHAR_BIT
,
889 stream
, format
, recurse
, pretty
,
890 comma_needed
, outer_type
, outer_valaddr
);
894 ada_value_print (struct value
*val0
, struct ui_file
*stream
, int format
,
895 enum val_prettyprint pretty
)
897 const gdb_byte
*valaddr
= value_contents (val0
);
898 CORE_ADDR address
= VALUE_ADDRESS (val0
) + value_offset (val0
);
900 ada_to_fixed_type (value_type (val0
), valaddr
, address
, NULL
);
902 value_from_contents_and_address (type
, valaddr
, address
);
904 /* If it is a pointer, indicate what it points to. */
905 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
907 /* Hack: don't print (char *) for char strings. Their
908 type is indicated by the quoted string anyway. */
909 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) != sizeof (char)
910 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_INT
911 || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type
)))
913 fprintf_filtered (stream
, "(");
914 type_print (type
, "", stream
, -1);
915 fprintf_filtered (stream
, ") ");
918 else if (ada_is_array_descriptor_type (type
))
920 fprintf_filtered (stream
, "(");
921 type_print (type
, "", stream
, -1);
922 fprintf_filtered (stream
, ") ");
924 else if (ada_is_bogus_array_descriptor (type
))
926 fprintf_filtered (stream
, "(");
927 type_print (type
, "", stream
, -1);
928 fprintf_filtered (stream
, ") (...?)");
932 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
933 && TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) == 0
934 && TYPE_CODE (TYPE_INDEX_TYPE (type
)) == TYPE_CODE_RANGE
)
936 /* This is an array of zero-length elements, that is an array
937 of null records. This array needs to be printed by hand,
938 as the standard routine to print arrays relies on the size of
939 the array elements to be nonzero. This is because it computes
940 the number of elements in the array by dividing the array size
941 by the array element size. */
942 fprintf_filtered (stream
, "(%d .. %d => ())",
943 TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
)),
944 TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type
)));
948 return (val_print (type
, value_contents (val
), 0, address
,
949 stream
, format
, 1, 0, pretty
));
953 print_record (struct type
*type
, const gdb_byte
*valaddr
,
954 struct ui_file
*stream
, int format
, int recurse
,
955 enum val_prettyprint pretty
)
957 type
= ada_check_typedef (type
);
959 fprintf_filtered (stream
, "(");
961 if (print_field_values (type
, valaddr
, stream
, format
, recurse
, pretty
,
962 0, type
, valaddr
) != 0 && pretty
)
964 fprintf_filtered (stream
, "\n");
965 print_spaces_filtered (2 * recurse
, stream
);
968 fprintf_filtered (stream
, ")");
971 /* Print out fields of value at VALADDR having structure type TYPE.
973 TYPE, VALADDR, STREAM, FORMAT, RECURSE, and PRETTY have the
974 same meanings as in ada_print_value and ada_val_print.
976 OUTER_TYPE and OUTER_VALADDR give type and address of enclosing record
977 (used to get discriminant values when printing variant parts).
979 COMMA_NEEDED is 1 if fields have been printed at the current recursion
980 level, so that a comma is needed before any field printed by this
983 Returns 1 if COMMA_NEEDED or any fields were printed. */
986 print_field_values (struct type
*type
, const gdb_byte
*valaddr
,
987 struct ui_file
*stream
, int format
, int recurse
,
988 enum val_prettyprint pretty
, int comma_needed
,
989 struct type
*outer_type
, const gdb_byte
*outer_valaddr
)
993 len
= TYPE_NFIELDS (type
);
995 for (i
= 0; i
< len
; i
+= 1)
997 if (ada_is_ignored_field (type
, i
))
1000 if (ada_is_wrapper_field (type
, i
))
1003 print_field_values (TYPE_FIELD_TYPE (type
, i
),
1005 + TYPE_FIELD_BITPOS (type
, i
) / HOST_CHAR_BIT
,
1006 stream
, format
, recurse
, pretty
,
1007 comma_needed
, type
, valaddr
);
1010 else if (ada_is_variant_part (type
, i
))
1013 print_variant_part (type
, i
, valaddr
,
1014 stream
, format
, recurse
, pretty
, comma_needed
,
1015 outer_type
, outer_valaddr
);
1020 fprintf_filtered (stream
, ", ");
1025 fprintf_filtered (stream
, "\n");
1026 print_spaces_filtered (2 + 2 * recurse
, stream
);
1030 wrap_here (n_spaces (2 + 2 * recurse
));
1034 if (TYPE_CODE (TYPE_FIELD_TYPE (type
, i
)) == TYPE_CODE_PTR
)
1035 fputs_filtered ("\"( ptr \"", stream
);
1037 fputs_filtered ("\"( nodef \"", stream
);
1038 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
1039 language_cplus
, DMGL_NO_OPTS
);
1040 fputs_filtered ("\" \"", stream
);
1041 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
1042 language_cplus
, DMGL_NO_OPTS
);
1043 fputs_filtered ("\") \"", stream
);
1047 annotate_field_begin (TYPE_FIELD_TYPE (type
, i
));
1048 fprintf_filtered (stream
, "%.*s",
1049 ada_name_prefix_len (TYPE_FIELD_NAME (type
, i
)),
1050 TYPE_FIELD_NAME (type
, i
));
1051 annotate_field_name_end ();
1052 fputs_filtered (" => ", stream
);
1053 annotate_field_value ();
1056 if (TYPE_FIELD_PACKED (type
, i
))
1060 /* Bitfields require special handling, especially due to byte
1062 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
1063 && TYPE_FIELD_IGNORE (type
, i
))
1065 fputs_filtered (_("<optimized out or zero length>"), stream
);
1069 int bit_pos
= TYPE_FIELD_BITPOS (type
, i
);
1070 int bit_size
= TYPE_FIELD_BITSIZE (type
, i
);
1072 adjust_type_signedness (TYPE_FIELD_TYPE (type
, i
));
1073 v
= ada_value_primitive_packed_val (NULL
, valaddr
,
1074 bit_pos
/ HOST_CHAR_BIT
,
1075 bit_pos
% HOST_CHAR_BIT
,
1077 TYPE_FIELD_TYPE (type
, i
));
1078 val_print (TYPE_FIELD_TYPE (type
, i
), value_contents (v
), 0, 0,
1079 stream
, format
, 0, recurse
+ 1, pretty
);
1083 ada_val_print (TYPE_FIELD_TYPE (type
, i
),
1084 valaddr
+ TYPE_FIELD_BITPOS (type
, i
) / HOST_CHAR_BIT
,
1085 0, 0, stream
, format
, 0, recurse
+ 1, pretty
);
1086 annotate_field_end ();
1089 return comma_needed
;