1 /* Support for printing Ada values for GDB, the GNU debugger.
3 Copyright (C) 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., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
25 #include "gdb_string.h"
28 #include "expression.h"
37 #include "exceptions.h"
39 /* Encapsulates arguments to ada_val_print. */
40 struct ada_val_print_args
43 const gdb_byte
*valaddr0
;
46 struct ui_file
*stream
;
50 enum val_prettyprint pretty
;
53 static void print_record (struct type
*, const gdb_byte
*, struct ui_file
*,
54 int, int, enum val_prettyprint
);
56 static int print_field_values (struct type
*, const gdb_byte
*,
57 struct ui_file
*, int, int,
58 enum val_prettyprint
, int, struct type
*,
61 static void adjust_type_signedness (struct type
*);
63 static int ada_val_print_stub (void *args0
);
65 static int ada_val_print_1 (struct type
*, const gdb_byte
*, int, CORE_ADDR
,
66 struct ui_file
*, int, int, int,
67 enum val_prettyprint
);
70 /* Make TYPE unsigned if its range of values includes no negatives. */
72 adjust_type_signedness (struct type
*type
)
74 if (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_RANGE
75 && TYPE_LOW_BOUND (type
) >= 0)
76 TYPE_FLAGS (type
) |= TYPE_FLAG_UNSIGNED
;
79 /* Assuming TYPE is a simple, non-empty array type, prints its lower bound
80 on STREAM, if non-standard (i.e., other than 1 for numbers, other
81 than lower bound of index type for enumerated type). Returns 1
82 if something printed, otherwise 0. */
85 print_optional_low_bound (struct ui_file
*stream
, struct type
*type
)
87 struct type
*index_type
;
90 if (print_array_indexes_p ())
93 if (!get_array_low_bound (type
, &low_bound
))
96 index_type
= TYPE_INDEX_TYPE (type
);
98 if (TYPE_CODE (index_type
) == TYPE_CODE_RANGE
)
100 /* We need to know what the base type is, in order to do the
101 appropriate check below. Otherwise, if this is a subrange
102 of an enumerated type, where the underlying value of the
103 first element is typically 0, we might test the low bound
104 against the wrong value. */
105 index_type
= TYPE_TARGET_TYPE (index_type
);
108 switch (TYPE_CODE (index_type
))
111 if (low_bound
== TYPE_FIELD_BITPOS (index_type
, 0))
114 case TYPE_CODE_UNDEF
:
115 index_type
= builtin_type_long
;
123 ada_print_scalar (index_type
, (LONGEST
) low_bound
, stream
);
124 fprintf_filtered (stream
, " => ");
128 /* Version of val_print_array_elements for GNAT-style packed arrays.
129 Prints elements of packed array of type TYPE at bit offset
130 BITOFFSET from VALADDR on STREAM. Formats according to FORMAT and
131 separates with commas. RECURSE is the recursion (nesting) level.
132 If PRETTY, uses "prettier" format. TYPE must have been decoded (as
133 by ada_coerce_to_simple_array). */
136 val_print_packed_array_elements (struct type
*type
, const gdb_byte
*valaddr
,
137 int bitoffset
, struct ui_file
*stream
,
138 int format
, int recurse
,
139 enum val_prettyprint pretty
)
142 unsigned int things_printed
= 0;
144 struct type
*elttype
, *index_type
;
146 unsigned long bitsize
= TYPE_FIELD_BITSIZE (type
, 0);
147 struct value
*mark
= value_mark ();
150 elttype
= TYPE_TARGET_TYPE (type
);
151 eltlen
= TYPE_LENGTH (check_typedef (elttype
));
152 index_type
= TYPE_INDEX_TYPE (type
);
156 if (get_discrete_bounds (TYPE_FIELD_TYPE (type
, 0), &low
, &high
) < 0)
159 len
= high
- low
+ 1;
163 annotate_array_section_begin (i
, elttype
);
165 while (i
< len
&& things_printed
< print_max
)
167 struct value
*v0
, *v1
;
172 if (prettyprint_arrays
)
174 fprintf_filtered (stream
, ",\n");
175 print_spaces_filtered (2 + 2 * recurse
, stream
);
179 fprintf_filtered (stream
, ", ");
182 wrap_here (n_spaces (2 + 2 * recurse
));
183 maybe_print_array_index (index_type
, i
+ low
, stream
, format
, pretty
);
186 v0
= ada_value_primitive_packed_val (NULL
, valaddr
,
187 (i0
* bitsize
) / HOST_CHAR_BIT
,
188 (i0
* bitsize
) % HOST_CHAR_BIT
,
195 v1
= ada_value_primitive_packed_val (NULL
, valaddr
,
196 (i
* bitsize
) / HOST_CHAR_BIT
,
197 (i
* bitsize
) % HOST_CHAR_BIT
,
199 if (memcmp (value_contents (v0
), value_contents (v1
), eltlen
) != 0)
203 if (i
- i0
> repeat_count_threshold
)
205 val_print (elttype
, value_contents (v0
), 0, 0, stream
, format
,
206 0, recurse
+ 1, pretty
);
207 annotate_elt_rep (i
- i0
);
208 fprintf_filtered (stream
, _(" <repeats %u times>"), i
- i0
);
209 annotate_elt_rep_end ();
215 for (j
= i0
; j
< i
; j
+= 1)
219 if (prettyprint_arrays
)
221 fprintf_filtered (stream
, ",\n");
222 print_spaces_filtered (2 + 2 * recurse
, stream
);
226 fprintf_filtered (stream
, ", ");
228 wrap_here (n_spaces (2 + 2 * recurse
));
229 maybe_print_array_index (index_type
, j
+ low
,
230 stream
, format
, pretty
);
232 val_print (elttype
, value_contents (v0
), 0, 0, stream
, format
,
233 0, recurse
+ 1, pretty
);
237 things_printed
+= i
- i0
;
239 annotate_array_section_end ();
242 fprintf_filtered (stream
, "...");
245 value_free_to_mark (mark
);
249 printable_val_type (struct type
*type
, const gdb_byte
*valaddr
)
251 return ada_to_fixed_type (ada_aligned_type (type
), valaddr
, 0, NULL
);
254 /* Print the character C on STREAM as part of the contents of a literal
255 string whose delimiter is QUOTER. TYPE_LEN is the length in bytes
256 (1 or 2) of the character. */
259 ada_emit_char (int c
, struct ui_file
*stream
, int quoter
, int type_len
)
264 c
&= (1 << (type_len
* TARGET_CHAR_BIT
)) - 1;
266 if (isascii (c
) && isprint (c
))
268 if (c
== quoter
&& c
== '"')
269 fprintf_filtered (stream
, "\"\"");
271 fprintf_filtered (stream
, "%c", c
);
274 fprintf_filtered (stream
, "[\"%0*x\"]", type_len
* 2, c
);
277 /* Character #I of STRING, given that TYPE_LEN is the size in bytes (1
278 or 2) of a character. */
281 char_at (const gdb_byte
*string
, int i
, int type_len
)
286 return (int) extract_unsigned_integer (string
+ 2 * i
, 2);
289 /* Wrapper around memcpy to make it legal argument to ui_file_put */
291 ui_memcpy (void *dest
, const char *buffer
, long len
)
293 memcpy (dest
, buffer
, (size_t) len
);
294 ((char *) dest
)[len
] = '\0';
297 /* Print a floating-point value of type TYPE, pointed to in GDB by
298 VALADDR, on STREAM. Use Ada formatting conventions: there must be
299 a decimal point, and at least one digit before and after the
300 point. We use GNAT format for NaNs and infinities. */
302 ada_print_floating (const gdb_byte
*valaddr
, struct type
*type
,
303 struct ui_file
*stream
)
308 struct ui_file
*tmp_stream
= mem_fileopen ();
309 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (tmp_stream
);
311 print_floating (valaddr
, type
, tmp_stream
);
312 ui_file_put (tmp_stream
, ui_memcpy
, buffer
);
313 do_cleanups (cleanups
);
316 len
= strlen (result
);
318 /* Modify for Ada rules. */
320 s
= strstr (result
, "inf");
322 s
= strstr (result
, "Inf");
324 s
= strstr (result
, "INF");
330 s
= strstr (result
, "nan");
332 s
= strstr (result
, "NaN");
334 s
= strstr (result
, "Nan");
338 if (result
[0] == '-')
343 if (s
== NULL
&& strchr (result
, '.') == NULL
)
345 s
= strchr (result
, 'e');
347 fprintf_filtered (stream
, "%s.0", result
);
349 fprintf_filtered (stream
, "%.*s.0%s", (int) (s
-result
), result
, s
);
352 fprintf_filtered (stream
, "%s", result
);
356 ada_printchar (int c
, struct ui_file
*stream
)
358 fputs_filtered ("'", stream
);
359 ada_emit_char (c
, stream
, '\'', 1);
360 fputs_filtered ("'", stream
);
363 /* [From print_type_scalar in typeprint.c]. Print VAL on STREAM in a
364 form appropriate for TYPE. */
367 ada_print_scalar (struct type
*type
, LONGEST val
, struct ui_file
*stream
)
372 type
= ada_check_typedef (type
);
374 switch (TYPE_CODE (type
))
378 len
= TYPE_NFIELDS (type
);
379 for (i
= 0; i
< len
; i
++)
381 if (TYPE_FIELD_BITPOS (type
, i
) == val
)
388 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type
, i
)), stream
);
392 print_longest (stream
, 'd', 0, val
);
397 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0, val
);
401 LA_PRINT_CHAR ((unsigned char) val
, stream
);
405 fprintf_filtered (stream
, val
? "true" : "false");
408 case TYPE_CODE_RANGE
:
409 ada_print_scalar (TYPE_TARGET_TYPE (type
), val
, stream
);
412 case TYPE_CODE_UNDEF
:
414 case TYPE_CODE_ARRAY
:
415 case TYPE_CODE_STRUCT
:
416 case TYPE_CODE_UNION
:
421 case TYPE_CODE_STRING
:
422 case TYPE_CODE_ERROR
:
423 case TYPE_CODE_MEMBER
:
424 case TYPE_CODE_METHOD
:
426 warning (_("internal error: unhandled type in ada_print_scalar"));
430 error (_("Invalid type code in symbol table."));
435 /* Print the character string STRING, printing at most LENGTH characters.
436 Printing stops early if the number hits print_max; repeat counts
437 are printed as appropriate. Print ellipses at the end if we
438 had to stop before printing LENGTH characters, or if
439 FORCE_ELLIPSES. TYPE_LEN is the length (1 or 2) of the character type.
443 printstr (struct ui_file
*stream
, const gdb_byte
*string
,
444 unsigned int length
, int force_ellipses
, int type_len
)
447 unsigned int things_printed
= 0;
453 fputs_filtered ("\"\"", stream
);
457 for (i
= 0; i
< length
&& things_printed
< print_max
; i
+= 1)
459 /* Position of the character we are examining
460 to see whether it is repeated. */
462 /* Number of repetitions we have detected so far. */
469 fputs_filtered (", ", stream
);
476 && char_at (string
, rep1
, type_len
) == char_at (string
, i
,
483 if (reps
> repeat_count_threshold
)
488 fputs_filtered ("\\\", ", stream
);
490 fputs_filtered ("\", ", stream
);
493 fputs_filtered ("'", stream
);
494 ada_emit_char (char_at (string
, i
, type_len
), stream
, '\'',
496 fputs_filtered ("'", stream
);
497 fprintf_filtered (stream
, _(" <repeats %u times>"), reps
);
499 things_printed
+= repeat_count_threshold
;
507 fputs_filtered ("\\\"", stream
);
509 fputs_filtered ("\"", stream
);
512 ada_emit_char (char_at (string
, i
, type_len
), stream
, '"',
518 /* Terminate the quotes if necessary. */
522 fputs_filtered ("\\\"", stream
);
524 fputs_filtered ("\"", stream
);
527 if (force_ellipses
|| i
< length
)
528 fputs_filtered ("...", stream
);
532 ada_printstr (struct ui_file
*stream
, const gdb_byte
*string
,
533 unsigned int length
, int width
, int force_ellipses
)
535 printstr (stream
, string
, length
, force_ellipses
, width
);
539 /* Print data of type TYPE located at VALADDR (within GDB), which came from
540 the inferior at address ADDRESS, onto stdio stream STREAM according to
541 FORMAT (a letter as for the printf % codes or 0 for natural format).
542 The data at VALADDR is in target byte order.
544 If the data is printed as a string, returns the number of string characters
547 If DEREF_REF is nonzero, then dereference references, otherwise just print
550 RECURSE indicates the amount of indentation to supply before
551 continuation lines; this amount is roughly twice the value of RECURSE.
553 When PRETTY is non-zero, prints record fields on separate lines.
554 (For some reason, the current version of gdb instead uses a global
555 variable---prettyprint_arrays--- to causes a similar effect on
559 ada_val_print (struct type
*type
, const gdb_byte
*valaddr0
,
560 int embedded_offset
, CORE_ADDR address
,
561 struct ui_file
*stream
, int format
, int deref_ref
,
562 int recurse
, enum val_prettyprint pretty
)
564 struct ada_val_print_args args
;
566 args
.valaddr0
= valaddr0
;
567 args
.embedded_offset
= embedded_offset
;
568 args
.address
= address
;
569 args
.stream
= stream
;
570 args
.format
= format
;
571 args
.deref_ref
= deref_ref
;
572 args
.recurse
= recurse
;
573 args
.pretty
= pretty
;
575 return catch_errors (ada_val_print_stub
, &args
, NULL
, RETURN_MASK_ALL
);
578 /* Helper for ada_val_print; used as argument to catch_errors to
579 unmarshal the arguments to ada_val_print_1, which does the work. */
581 ada_val_print_stub (void *args0
)
583 struct ada_val_print_args
*argsp
= (struct ada_val_print_args
*) args0
;
584 return ada_val_print_1 (argsp
->type
, argsp
->valaddr0
,
585 argsp
->embedded_offset
, argsp
->address
,
586 argsp
->stream
, argsp
->format
, argsp
->deref_ref
,
587 argsp
->recurse
, argsp
->pretty
);
590 /* See the comment on ada_val_print. This function differs in that it
591 * does not catch evaluation errors (leaving that to ada_val_print). */
594 ada_val_print_1 (struct type
*type
, const gdb_byte
*valaddr0
,
595 int embedded_offset
, CORE_ADDR address
,
596 struct ui_file
*stream
, int format
,
597 int deref_ref
, int recurse
, enum val_prettyprint pretty
)
601 struct type
*elttype
;
604 const gdb_byte
*valaddr
= valaddr0
+ embedded_offset
;
606 type
= ada_check_typedef (type
);
608 if (ada_is_array_descriptor_type (type
) || ada_is_packed_array_type (type
))
611 struct value
*mark
= value_mark ();
613 val
= value_from_contents_and_address (type
, valaddr
, address
);
614 val
= ada_coerce_to_simple_array_ptr (val
);
617 fprintf_filtered (stream
, "(null)");
621 retn
= ada_val_print_1 (value_type (val
), value_contents (val
), 0,
622 VALUE_ADDRESS (val
), stream
, format
,
623 deref_ref
, recurse
, pretty
);
624 value_free_to_mark (mark
);
628 valaddr
= ada_aligned_value_addr (type
, valaddr
);
629 embedded_offset
-= valaddr
- valaddr0
- embedded_offset
;
630 type
= printable_val_type (type
, valaddr
);
632 switch (TYPE_CODE (type
))
635 return c_val_print (type
, valaddr0
, embedded_offset
, address
, stream
,
636 format
, deref_ref
, recurse
, pretty
);
640 int ret
= c_val_print (type
, valaddr0
, embedded_offset
, address
,
641 stream
, format
, deref_ref
, recurse
, pretty
);
642 if (ada_is_tag_type (type
))
645 value_from_contents_and_address (type
, valaddr
, address
);
646 const char *name
= ada_tag_name (val
);
648 fprintf_filtered (stream
, " (%s)", name
);
655 case TYPE_CODE_RANGE
:
656 if (ada_is_fixed_point_type (type
))
658 LONGEST v
= unpack_long (type
, valaddr
);
659 int len
= TYPE_LENGTH (type
);
661 fprintf_filtered (stream
, len
< 4 ? "%.11g" : "%.17g",
662 (double) ada_fixed_to_float (type
, v
));
665 else if (ada_is_vax_floating_type (type
))
668 value_from_contents_and_address (type
, valaddr
, address
);
669 struct value
*func
= ada_vax_float_print_function (type
);
672 static struct type
*parray_of_char
= NULL
;
673 struct value
*printable_val
;
675 if (parray_of_char
== NULL
)
679 (NULL
, builtin_type_char
,
680 create_range_type (NULL
, builtin_type_int
, 0, 32)), NULL
);
683 value_ind (value_cast (parray_of_char
,
684 call_function_by_hand (func
, 1,
687 fprintf_filtered (stream
, "%s", value_contents (printable_val
));
690 /* No special printing function. Do as best we can. */
692 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
694 struct type
*target_type
= TYPE_TARGET_TYPE (type
);
695 if (TYPE_LENGTH (type
) != TYPE_LENGTH (target_type
))
697 /* Obscure case of range type that has different length from
698 its base type. Perform a conversion, or we will get a
699 nonsense value. Actually, we could use the same
700 code regardless of lengths; I'm just avoiding a cast. */
701 struct value
*v
= value_cast (target_type
,
702 value_from_contents_and_address
704 return ada_val_print_1 (target_type
, value_contents (v
), 0, 0,
705 stream
, format
, 0, recurse
+ 1, pretty
);
708 return ada_val_print_1 (TYPE_TARGET_TYPE (type
),
709 valaddr0
, embedded_offset
,
710 address
, stream
, format
, deref_ref
,
715 format
= format
? format
: output_format
;
718 print_scalar_formatted (valaddr
, type
, format
, 0, stream
);
720 else if (ada_is_system_address_type (type
))
722 /* FIXME: We want to print System.Address variables using
723 the same format as for any access type. But for some
724 reason GNAT encodes the System.Address type as an int,
725 so we have to work-around this deficiency by handling
726 System.Address values as a special case. */
727 fprintf_filtered (stream
, "(");
728 type_print (type
, "", stream
, -1);
729 fprintf_filtered (stream
, ") ");
730 deprecated_print_address_numeric
731 (extract_typed_address (valaddr
, builtin_type_void_data_ptr
),
736 val_print_type_code_int (type
, valaddr
, stream
);
737 if (ada_is_character_type (type
))
739 fputs_filtered (" ", stream
);
740 ada_printchar ((unsigned char) unpack_long (type
, valaddr
),
750 print_scalar_formatted (valaddr
, type
, format
, 0, stream
);
753 len
= TYPE_NFIELDS (type
);
754 val
= unpack_long (type
, valaddr
);
755 for (i
= 0; i
< len
; i
++)
758 if (val
== TYPE_FIELD_BITPOS (type
, i
))
765 const char *name
= ada_enum_name (TYPE_FIELD_NAME (type
, i
));
767 fprintf_filtered (stream
, "%ld %s", (long) val
, name
);
769 fputs_filtered (name
, stream
);
773 print_longest (stream
, 'd', 0, val
);
779 return c_val_print (type
, valaddr0
, embedded_offset
, address
, stream
,
780 format
, deref_ref
, recurse
, pretty
);
782 ada_print_floating (valaddr0
+ embedded_offset
, type
, stream
);
785 case TYPE_CODE_UNION
:
786 case TYPE_CODE_STRUCT
:
787 if (ada_is_bogus_array_descriptor (type
))
789 fprintf_filtered (stream
, "(...?)");
794 print_record (type
, valaddr
, stream
, format
, recurse
, pretty
);
798 case TYPE_CODE_ARRAY
:
799 elttype
= TYPE_TARGET_TYPE (type
);
803 eltlen
= TYPE_LENGTH (elttype
);
804 /* FIXME: This doesn't deal with non-empty arrays of
805 0-length items (not a typical case!) */
809 len
= TYPE_LENGTH (type
) / eltlen
;
811 /* For an array of chars, print with string syntax. */
812 if (ada_is_string_type (type
) && (format
== 0 || format
== 's'))
814 if (prettyprint_arrays
)
816 print_spaces_filtered (2 + 2 * recurse
, stream
);
818 /* If requested, look for the first null char and only print
819 elements up to it. */
820 if (stop_print_at_null
)
824 /* Look for a NULL char. */
826 temp_len
< len
&& temp_len
< print_max
827 && char_at (valaddr
, temp_len
, eltlen
) != 0;
832 printstr (stream
, valaddr
, len
, 0, eltlen
);
837 fprintf_filtered (stream
, "(");
838 print_optional_low_bound (stream
, type
);
839 if (TYPE_FIELD_BITSIZE (type
, 0) > 0)
840 val_print_packed_array_elements (type
, valaddr
, 0, stream
,
841 format
, recurse
, pretty
);
843 val_print_array_elements (type
, valaddr
, address
, stream
,
844 format
, deref_ref
, recurse
,
846 fprintf_filtered (stream
, ")");
852 elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
853 /* De-reference the reference */
856 if (TYPE_CODE (elttype
) != TYPE_CODE_UNDEF
)
858 LONGEST deref_val_int
= (LONGEST
)
859 unpack_pointer (lookup_pointer_type (builtin_type_void
),
861 if (deref_val_int
!= 0)
863 struct value
*deref_val
=
864 ada_value_ind (value_from_longest
865 (lookup_pointer_type (elttype
),
867 val_print (value_type (deref_val
),
868 value_contents (deref_val
), 0,
869 VALUE_ADDRESS (deref_val
), stream
, format
,
870 deref_ref
, recurse
+ 1, pretty
);
873 fputs_filtered ("(null)", stream
);
876 fputs_filtered ("???", stream
);
885 print_variant_part (struct type
*type
, int field_num
, const gdb_byte
*valaddr
,
886 struct ui_file
*stream
, int format
, int recurse
,
887 enum val_prettyprint pretty
, int comma_needed
,
888 struct type
*outer_type
, const gdb_byte
*outer_valaddr
)
890 struct type
*var_type
= TYPE_FIELD_TYPE (type
, field_num
);
891 int which
= ada_which_variant_applies (var_type
, outer_type
, outer_valaddr
);
896 return print_field_values
897 (TYPE_FIELD_TYPE (var_type
, which
),
898 valaddr
+ TYPE_FIELD_BITPOS (type
, field_num
) / HOST_CHAR_BIT
899 + TYPE_FIELD_BITPOS (var_type
, which
) / HOST_CHAR_BIT
,
900 stream
, format
, recurse
, pretty
,
901 comma_needed
, outer_type
, outer_valaddr
);
905 ada_value_print (struct value
*val0
, struct ui_file
*stream
, int format
,
906 enum val_prettyprint pretty
)
908 const gdb_byte
*valaddr
= value_contents (val0
);
909 CORE_ADDR address
= VALUE_ADDRESS (val0
) + value_offset (val0
);
911 ada_to_fixed_type (value_type (val0
), valaddr
, address
, NULL
);
913 value_from_contents_and_address (type
, valaddr
, address
);
915 /* If it is a pointer, indicate what it points to. */
916 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
918 /* Hack: don't print (char *) for char strings. Their
919 type is indicated by the quoted string anyway. */
920 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) != sizeof (char)
921 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_INT
922 || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type
)))
924 fprintf_filtered (stream
, "(");
925 type_print (type
, "", stream
, -1);
926 fprintf_filtered (stream
, ") ");
929 else if (ada_is_array_descriptor_type (type
))
931 fprintf_filtered (stream
, "(");
932 type_print (type
, "", stream
, -1);
933 fprintf_filtered (stream
, ") ");
935 else if (ada_is_bogus_array_descriptor (type
))
937 fprintf_filtered (stream
, "(");
938 type_print (type
, "", stream
, -1);
939 fprintf_filtered (stream
, ") (...?)");
943 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
944 && TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) == 0
945 && TYPE_CODE (TYPE_INDEX_TYPE (type
)) == TYPE_CODE_RANGE
)
947 /* This is an array of zero-length elements, that is an array
948 of null records. This array needs to be printed by hand,
949 as the standard routine to print arrays relies on the size of
950 the array elements to be nonzero. This is because it computes
951 the number of elements in the array by dividing the array size
952 by the array element size. */
953 fprintf_filtered (stream
, "(%d .. %d => ())",
954 TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type
)),
955 TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type
)));
959 return (val_print (type
, value_contents (val
), 0, address
,
960 stream
, format
, 1, 0, pretty
));
964 print_record (struct type
*type
, const gdb_byte
*valaddr
,
965 struct ui_file
*stream
, int format
, int recurse
,
966 enum val_prettyprint pretty
)
968 type
= ada_check_typedef (type
);
970 fprintf_filtered (stream
, "(");
972 if (print_field_values (type
, valaddr
, stream
, format
, recurse
, pretty
,
973 0, type
, valaddr
) != 0 && pretty
)
975 fprintf_filtered (stream
, "\n");
976 print_spaces_filtered (2 * recurse
, stream
);
979 fprintf_filtered (stream
, ")");
982 /* Print out fields of value at VALADDR having structure type TYPE.
984 TYPE, VALADDR, STREAM, FORMAT, RECURSE, and PRETTY have the
985 same meanings as in ada_print_value and ada_val_print.
987 OUTER_TYPE and OUTER_VALADDR give type and address of enclosing record
988 (used to get discriminant values when printing variant parts).
990 COMMA_NEEDED is 1 if fields have been printed at the current recursion
991 level, so that a comma is needed before any field printed by this
994 Returns 1 if COMMA_NEEDED or any fields were printed. */
997 print_field_values (struct type
*type
, const gdb_byte
*valaddr
,
998 struct ui_file
*stream
, int format
, int recurse
,
999 enum val_prettyprint pretty
, int comma_needed
,
1000 struct type
*outer_type
, const gdb_byte
*outer_valaddr
)
1004 len
= TYPE_NFIELDS (type
);
1006 for (i
= 0; i
< len
; i
+= 1)
1008 if (ada_is_ignored_field (type
, i
))
1011 if (ada_is_wrapper_field (type
, i
))
1014 print_field_values (TYPE_FIELD_TYPE (type
, i
),
1016 + TYPE_FIELD_BITPOS (type
, i
) / HOST_CHAR_BIT
,
1017 stream
, format
, recurse
, pretty
,
1018 comma_needed
, type
, valaddr
);
1021 else if (ada_is_variant_part (type
, i
))
1024 print_variant_part (type
, i
, valaddr
,
1025 stream
, format
, recurse
, pretty
, comma_needed
,
1026 outer_type
, outer_valaddr
);
1031 fprintf_filtered (stream
, ", ");
1036 fprintf_filtered (stream
, "\n");
1037 print_spaces_filtered (2 + 2 * recurse
, stream
);
1041 wrap_here (n_spaces (2 + 2 * recurse
));
1045 if (TYPE_CODE (TYPE_FIELD_TYPE (type
, i
)) == TYPE_CODE_PTR
)
1046 fputs_filtered ("\"( ptr \"", stream
);
1048 fputs_filtered ("\"( nodef \"", stream
);
1049 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
1050 language_cplus
, DMGL_NO_OPTS
);
1051 fputs_filtered ("\" \"", stream
);
1052 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
1053 language_cplus
, DMGL_NO_OPTS
);
1054 fputs_filtered ("\") \"", stream
);
1058 annotate_field_begin (TYPE_FIELD_TYPE (type
, i
));
1059 fprintf_filtered (stream
, "%.*s",
1060 ada_name_prefix_len (TYPE_FIELD_NAME (type
, i
)),
1061 TYPE_FIELD_NAME (type
, i
));
1062 annotate_field_name_end ();
1063 fputs_filtered (" => ", stream
);
1064 annotate_field_value ();
1067 if (TYPE_FIELD_PACKED (type
, i
))
1071 /* Bitfields require special handling, especially due to byte
1073 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
1074 && TYPE_FIELD_IGNORE (type
, i
))
1076 fputs_filtered (_("<optimized out or zero length>"), stream
);
1080 int bit_pos
= TYPE_FIELD_BITPOS (type
, i
);
1081 int bit_size
= TYPE_FIELD_BITSIZE (type
, i
);
1083 adjust_type_signedness (TYPE_FIELD_TYPE (type
, i
));
1084 v
= ada_value_primitive_packed_val (NULL
, valaddr
,
1085 bit_pos
/ HOST_CHAR_BIT
,
1086 bit_pos
% HOST_CHAR_BIT
,
1088 TYPE_FIELD_TYPE (type
, i
));
1089 val_print (TYPE_FIELD_TYPE (type
, i
), value_contents (v
), 0, 0,
1090 stream
, format
, 0, recurse
+ 1, pretty
);
1094 ada_val_print (TYPE_FIELD_TYPE (type
, i
),
1095 valaddr
+ TYPE_FIELD_BITPOS (type
, i
) / HOST_CHAR_BIT
,
1096 0, 0, stream
, format
, 0, recurse
+ 1, pretty
);
1097 annotate_field_end ();
1100 return comma_needed
;