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, 2009, 2010, 2011
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
24 #include "gdb_string.h"
27 #include "expression.h"
36 #include "exceptions.h"
39 static void print_record (struct type
*, const gdb_byte
*, struct ui_file
*,
42 const struct value_print_options
*);
44 static int print_field_values (struct type
*, const gdb_byte
*,
45 struct ui_file
*, int,
47 const struct value_print_options
*,
51 static void adjust_type_signedness (struct type
*);
53 static int ada_val_print_1 (struct type
*, const gdb_byte
*, int, CORE_ADDR
,
54 struct ui_file
*, int,
56 const struct value_print_options
*);
59 /* Make TYPE unsigned if its range of values includes no negatives. */
61 adjust_type_signedness (struct type
*type
)
63 if (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_RANGE
64 && TYPE_LOW_BOUND (type
) >= 0)
65 TYPE_UNSIGNED (type
) = 1;
68 /* Assuming TYPE is a simple array type, prints its lower bound on STREAM,
69 if non-standard (i.e., other than 1 for numbers, other than lower bound
70 of index type for enumerated type). Returns 1 if something printed,
74 print_optional_low_bound (struct ui_file
*stream
, struct type
*type
,
75 const struct value_print_options
*options
)
77 struct type
*index_type
;
81 if (options
->print_array_indexes
)
84 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
87 /* If this is an empty array, then don't print the lower bound.
88 That would be confusing, because we would print the lower bound,
89 followed by... nothing! */
90 if (low_bound
> high_bound
)
93 index_type
= TYPE_INDEX_TYPE (type
);
95 if (TYPE_CODE (index_type
) == TYPE_CODE_RANGE
)
97 /* We need to know what the base type is, in order to do the
98 appropriate check below. Otherwise, if this is a subrange
99 of an enumerated type, where the underlying value of the
100 first element is typically 0, we might test the low bound
101 against the wrong value. */
102 index_type
= TYPE_TARGET_TYPE (index_type
);
105 switch (TYPE_CODE (index_type
))
112 if (low_bound
== TYPE_FIELD_BITPOS (index_type
, 0))
115 case TYPE_CODE_UNDEF
:
124 ada_print_scalar (index_type
, low_bound
, stream
);
125 fprintf_filtered (stream
, " => ");
129 /* Version of val_print_array_elements for GNAT-style packed arrays.
130 Prints elements of packed array of type TYPE at bit offset
131 BITOFFSET from VALADDR on STREAM. Formats according to OPTIONS and
132 separates with commas. RECURSE is the recursion (nesting) level.
133 TYPE must have been decoded (as 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
,
139 const struct value
*val
,
140 const struct value_print_options
*options
)
143 unsigned int things_printed
= 0;
145 struct type
*elttype
, *index_type
;
147 unsigned long bitsize
= TYPE_FIELD_BITSIZE (type
, 0);
148 struct value
*mark
= value_mark ();
151 elttype
= TYPE_TARGET_TYPE (type
);
152 eltlen
= TYPE_LENGTH (check_typedef (elttype
));
153 index_type
= TYPE_INDEX_TYPE (type
);
158 if (get_discrete_bounds (index_type
, &low
, &high
) < 0)
161 len
= high
- low
+ 1;
165 annotate_array_section_begin (i
, elttype
);
167 while (i
< len
&& things_printed
< options
->print_max
)
169 struct value
*v0
, *v1
;
174 if (options
->prettyprint_arrays
)
176 fprintf_filtered (stream
, ",\n");
177 print_spaces_filtered (2 + 2 * recurse
, stream
);
181 fprintf_filtered (stream
, ", ");
184 wrap_here (n_spaces (2 + 2 * recurse
));
185 maybe_print_array_index (index_type
, i
+ low
, stream
, options
);
188 v0
= ada_value_primitive_packed_val (NULL
, valaddr
,
189 (i0
* bitsize
) / HOST_CHAR_BIT
,
190 (i0
* bitsize
) % HOST_CHAR_BIT
,
197 v1
= ada_value_primitive_packed_val (NULL
, valaddr
,
198 (i
* bitsize
) / HOST_CHAR_BIT
,
199 (i
* bitsize
) % HOST_CHAR_BIT
,
201 if (memcmp (value_contents (v0
), value_contents (v1
), eltlen
) != 0)
205 if (i
- i0
> options
->repeat_count_threshold
)
207 struct value_print_options opts
= *options
;
210 val_print (elttype
, value_contents (v0
), 0, 0, stream
,
211 recurse
+ 1, val
, &opts
, current_language
);
212 annotate_elt_rep (i
- i0
);
213 fprintf_filtered (stream
, _(" <repeats %u times>"), i
- i0
);
214 annotate_elt_rep_end ();
220 struct value_print_options opts
= *options
;
223 for (j
= i0
; j
< i
; j
+= 1)
227 if (options
->prettyprint_arrays
)
229 fprintf_filtered (stream
, ",\n");
230 print_spaces_filtered (2 + 2 * recurse
, stream
);
234 fprintf_filtered (stream
, ", ");
236 wrap_here (n_spaces (2 + 2 * recurse
));
237 maybe_print_array_index (index_type
, j
+ low
,
240 val_print (elttype
, value_contents (v0
), 0, 0, stream
,
241 recurse
+ 1, val
, &opts
, current_language
);
245 things_printed
+= i
- i0
;
247 annotate_array_section_end ();
250 fprintf_filtered (stream
, "...");
253 value_free_to_mark (mark
);
257 printable_val_type (struct type
*type
, const gdb_byte
*valaddr
)
259 return ada_to_fixed_type (ada_aligned_type (type
), valaddr
, 0, NULL
, 1);
262 /* Print the character C on STREAM as part of the contents of a literal
263 string whose delimiter is QUOTER. TYPE_LEN is the length in bytes
267 ada_emit_char (int c
, struct type
*type
, struct ui_file
*stream
,
268 int quoter
, int type_len
)
270 /* If this character fits in the normal ASCII range, and is
271 a printable character, then print the character as if it was
272 an ASCII character, even if this is a wide character.
273 The UCHAR_MAX check is necessary because the isascii function
274 requires that its argument have a value of an unsigned char,
275 or EOF (EOF is obviously not printable). */
276 if (c
<= UCHAR_MAX
&& 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
291 char_at (const gdb_byte
*string
, int i
, int type_len
,
292 enum bfd_endian byte_order
)
297 return (int) extract_unsigned_integer (string
+ type_len
* i
,
298 type_len
, byte_order
);
301 /* Wrapper around memcpy to make it legal argument to ui_file_put. */
303 ui_memcpy (void *dest
, const char *buffer
, long len
)
305 memcpy (dest
, buffer
, (size_t) len
);
306 ((char *) dest
)[len
] = '\0';
309 /* Print a floating-point value of type TYPE, pointed to in GDB by
310 VALADDR, on STREAM. Use Ada formatting conventions: there must be
311 a decimal point, and at least one digit before and after the
312 point. We use GNAT format for NaNs and infinities. */
314 ada_print_floating (const gdb_byte
*valaddr
, struct type
*type
,
315 struct ui_file
*stream
)
320 struct ui_file
*tmp_stream
= mem_fileopen ();
321 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (tmp_stream
);
323 print_floating (valaddr
, type
, tmp_stream
);
324 ui_file_put (tmp_stream
, ui_memcpy
, buffer
);
325 do_cleanups (cleanups
);
328 len
= strlen (result
);
330 /* Modify for Ada rules. */
332 s
= strstr (result
, "inf");
334 s
= strstr (result
, "Inf");
336 s
= strstr (result
, "INF");
342 s
= strstr (result
, "nan");
344 s
= strstr (result
, "NaN");
346 s
= strstr (result
, "Nan");
350 if (result
[0] == '-')
355 if (s
== NULL
&& strchr (result
, '.') == NULL
)
357 s
= strchr (result
, 'e');
359 fprintf_filtered (stream
, "%s.0", result
);
361 fprintf_filtered (stream
, "%.*s.0%s", (int) (s
-result
), result
, s
);
364 fprintf_filtered (stream
, "%s", result
);
368 ada_printchar (int c
, struct type
*type
, struct ui_file
*stream
)
370 fputs_filtered ("'", stream
);
371 ada_emit_char (c
, type
, stream
, '\'', TYPE_LENGTH (type
));
372 fputs_filtered ("'", stream
);
375 /* [From print_type_scalar in typeprint.c]. Print VAL on STREAM in a
376 form appropriate for TYPE, if non-NULL. If TYPE is NULL, print VAL
377 like a default signed integer. */
380 ada_print_scalar (struct type
*type
, LONGEST val
, struct ui_file
*stream
)
387 print_longest (stream
, 'd', 0, val
);
391 type
= ada_check_typedef (type
);
393 switch (TYPE_CODE (type
))
397 len
= TYPE_NFIELDS (type
);
398 for (i
= 0; i
< len
; i
++)
400 if (TYPE_FIELD_BITPOS (type
, i
) == val
)
407 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type
, i
)), stream
);
411 print_longest (stream
, 'd', 0, val
);
416 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0, val
);
420 LA_PRINT_CHAR (val
, type
, stream
);
424 fprintf_filtered (stream
, val
? "true" : "false");
427 case TYPE_CODE_RANGE
:
428 ada_print_scalar (TYPE_TARGET_TYPE (type
), val
, stream
);
431 case TYPE_CODE_UNDEF
:
433 case TYPE_CODE_ARRAY
:
434 case TYPE_CODE_STRUCT
:
435 case TYPE_CODE_UNION
:
440 case TYPE_CODE_STRING
:
441 case TYPE_CODE_ERROR
:
442 case TYPE_CODE_MEMBERPTR
:
443 case TYPE_CODE_METHODPTR
:
444 case TYPE_CODE_METHOD
:
446 warning (_("internal error: unhandled type in ada_print_scalar"));
450 error (_("Invalid type code in symbol table."));
455 /* Print the character string STRING, printing at most LENGTH characters.
456 Printing stops early if the number hits print_max; repeat counts
457 are printed as appropriate. Print ellipses at the end if we
458 had to stop before printing LENGTH characters, or if FORCE_ELLIPSES.
459 TYPE_LEN is the length (1 or 2) of the character type. */
462 printstr (struct ui_file
*stream
, struct type
*elttype
, const gdb_byte
*string
,
463 unsigned int length
, int force_ellipses
, int type_len
,
464 const struct value_print_options
*options
)
466 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (elttype
));
468 unsigned int things_printed
= 0;
474 fputs_filtered ("\"\"", stream
);
478 for (i
= 0; i
< length
&& things_printed
< options
->print_max
; i
+= 1)
480 /* Position of the character we are examining
481 to see whether it is repeated. */
483 /* Number of repetitions we have detected so far. */
490 fputs_filtered (", ", stream
);
497 && char_at (string
, rep1
, type_len
, byte_order
)
498 == char_at (string
, i
, type_len
, byte_order
))
504 if (reps
> options
->repeat_count_threshold
)
508 if (options
->inspect_it
)
509 fputs_filtered ("\\\", ", stream
);
511 fputs_filtered ("\", ", stream
);
514 fputs_filtered ("'", stream
);
515 ada_emit_char (char_at (string
, i
, type_len
, byte_order
),
516 elttype
, stream
, '\'', type_len
);
517 fputs_filtered ("'", stream
);
518 fprintf_filtered (stream
, _(" <repeats %u times>"), reps
);
520 things_printed
+= options
->repeat_count_threshold
;
527 if (options
->inspect_it
)
528 fputs_filtered ("\\\"", stream
);
530 fputs_filtered ("\"", stream
);
533 ada_emit_char (char_at (string
, i
, type_len
, byte_order
),
534 elttype
, stream
, '"', type_len
);
539 /* Terminate the quotes if necessary. */
542 if (options
->inspect_it
)
543 fputs_filtered ("\\\"", stream
);
545 fputs_filtered ("\"", stream
);
548 if (force_ellipses
|| i
< length
)
549 fputs_filtered ("...", stream
);
553 ada_printstr (struct ui_file
*stream
, struct type
*type
,
554 const gdb_byte
*string
, unsigned int length
,
555 const char *encoding
, int force_ellipses
,
556 const struct value_print_options
*options
)
558 printstr (stream
, type
, string
, length
, force_ellipses
, TYPE_LENGTH (type
),
563 /* Print data of type TYPE located at VALADDR (within GDB), which came from
564 the inferior at address ADDRESS, onto stdio stream STREAM according to
565 OPTIONS. The data at VALADDR is in target byte order.
567 If the data is printed as a string, returns the number of string characters
570 RECURSE indicates the amount of indentation to supply before
571 continuation lines; this amount is roughly twice the value of RECURSE. */
574 ada_val_print (struct type
*type
, const gdb_byte
*valaddr0
,
575 int embedded_offset
, CORE_ADDR address
,
576 struct ui_file
*stream
, int recurse
,
577 const struct value
*val
,
578 const struct value_print_options
*options
)
580 volatile struct gdb_exception except
;
583 TRY_CATCH (except
, RETURN_MASK_ALL
)
585 result
= ada_val_print_1 (type
, valaddr0
, embedded_offset
, address
,
586 stream
, recurse
, val
, options
);
589 if (except
.reason
< 0)
595 /* Assuming TYPE is a simple array, print the value of this array located
596 at VALADDR. See ada_val_print for a description of the various
597 parameters of this function; they are identical. The semantics
598 of the return value is also identical to ada_val_print. */
601 ada_val_print_array (struct type
*type
, const gdb_byte
*valaddr
,
602 CORE_ADDR address
, struct ui_file
*stream
, int recurse
,
603 const struct value
*val
,
604 const struct value_print_options
*options
)
606 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
607 struct type
*elttype
= TYPE_TARGET_TYPE (type
);
610 /* For an array of chars, print with string syntax. */
611 if (ada_is_string_type (type
)
612 && (options
->format
== 0 || options
->format
== 's'))
620 eltlen
= TYPE_LENGTH (elttype
);
624 len
= TYPE_LENGTH (type
) / eltlen
;
626 if (options
->prettyprint_arrays
)
627 print_spaces_filtered (2 + 2 * recurse
, stream
);
629 /* If requested, look for the first null char and only print
630 elements up to it. */
631 if (options
->stop_print_at_null
)
635 /* Look for a NULL char. */
638 && temp_len
< options
->print_max
639 && char_at (valaddr
, temp_len
, eltlen
, byte_order
) != 0);
644 printstr (stream
, elttype
, valaddr
, len
, 0, eltlen
, options
);
649 fprintf_filtered (stream
, "(");
650 print_optional_low_bound (stream
, type
, options
);
651 if (TYPE_FIELD_BITSIZE (type
, 0) > 0)
652 val_print_packed_array_elements (type
, valaddr
, 0, stream
,
653 recurse
, val
, options
);
655 val_print_array_elements (type
, valaddr
, address
, stream
,
656 recurse
, val
, options
, 0);
657 fprintf_filtered (stream
, ")");
663 /* See the comment on ada_val_print. This function differs in that it
664 does not catch evaluation errors (leaving that to ada_val_print). */
667 ada_val_print_1 (struct type
*type
, const gdb_byte
*valaddr0
,
668 int embedded_offset
, CORE_ADDR address
,
669 struct ui_file
*stream
, int recurse
,
670 const struct value
*original_value
,
671 const struct value_print_options
*options
)
675 struct type
*elttype
;
677 const gdb_byte
*valaddr
= valaddr0
+ embedded_offset
;
679 type
= ada_check_typedef (type
);
681 if (ada_is_array_descriptor_type (type
)
682 || ada_is_constrained_packed_array_type (type
))
685 struct value
*mark
= value_mark ();
688 val
= value_from_contents_and_address (type
, valaddr
, address
);
689 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
) /* array access type. */
690 val
= ada_coerce_to_simple_array_ptr (val
);
692 val
= ada_coerce_to_simple_array (val
);
695 gdb_assert (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
);
696 fprintf_filtered (stream
, "0x0");
700 retn
= ada_val_print_1 (value_type (val
), value_contents (val
), 0,
701 value_address (val
), stream
, recurse
,
703 value_free_to_mark (mark
);
707 valaddr
= ada_aligned_value_addr (type
, valaddr
);
708 embedded_offset
-= valaddr
- valaddr0
- embedded_offset
;
709 type
= printable_val_type (type
, valaddr
);
711 switch (TYPE_CODE (type
))
714 return c_val_print (type
, valaddr0
, embedded_offset
, address
, stream
,
715 recurse
, original_value
, options
);
719 int ret
= c_val_print (type
, valaddr0
, embedded_offset
, address
,
720 stream
, recurse
, original_value
, options
);
722 if (ada_is_tag_type (type
))
725 value_from_contents_and_address (type
, valaddr
, address
);
726 const char *name
= ada_tag_name (val
);
729 fprintf_filtered (stream
, " (%s)", name
);
736 case TYPE_CODE_RANGE
:
737 if (ada_is_fixed_point_type (type
))
739 LONGEST v
= unpack_long (type
, valaddr
);
740 int len
= TYPE_LENGTH (type
);
742 fprintf_filtered (stream
, len
< 4 ? "%.11g" : "%.17g",
743 (double) ada_fixed_to_float (type
, v
));
746 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
748 struct type
*target_type
= TYPE_TARGET_TYPE (type
);
750 if (TYPE_LENGTH (type
) != TYPE_LENGTH (target_type
))
752 /* Obscure case of range type that has different length from
753 its base type. Perform a conversion, or we will get a
754 nonsense value. Actually, we could use the same
755 code regardless of lengths; I'm just avoiding a cast. */
756 struct value
*v
= value_cast (target_type
,
757 value_from_contents_and_address
760 return ada_val_print_1 (target_type
, value_contents (v
), 0, 0,
761 stream
, recurse
+ 1, NULL
, options
);
764 return ada_val_print_1 (TYPE_TARGET_TYPE (type
),
765 valaddr0
, embedded_offset
,
766 address
, stream
, recurse
,
767 original_value
, options
);
771 int format
= (options
->format
? options
->format
772 : options
->output_format
);
776 struct value_print_options opts
= *options
;
778 opts
.format
= format
;
779 print_scalar_formatted (valaddr
, type
, &opts
, 0, stream
);
781 else if (ada_is_system_address_type (type
))
783 /* FIXME: We want to print System.Address variables using
784 the same format as for any access type. But for some
785 reason GNAT encodes the System.Address type as an int,
786 so we have to work-around this deficiency by handling
787 System.Address values as a special case. */
789 struct gdbarch
*gdbarch
= get_type_arch (type
);
790 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
791 CORE_ADDR addr
= extract_typed_address (valaddr
, ptr_type
);
793 fprintf_filtered (stream
, "(");
794 type_print (type
, "", stream
, -1);
795 fprintf_filtered (stream
, ") ");
796 fputs_filtered (paddress (gdbarch
, addr
), stream
);
800 val_print_type_code_int (type
, valaddr
, stream
);
801 if (ada_is_character_type (type
))
803 fputs_filtered (" ", stream
);
804 ada_printchar (unpack_long (type
, valaddr
), type
, stream
);
813 print_scalar_formatted (valaddr
, type
, options
, 0, stream
);
816 len
= TYPE_NFIELDS (type
);
817 val
= unpack_long (type
, valaddr
);
818 for (i
= 0; i
< len
; i
++)
821 if (val
== TYPE_FIELD_BITPOS (type
, i
))
828 const char *name
= ada_enum_name (TYPE_FIELD_NAME (type
, i
));
831 fprintf_filtered (stream
, "%ld %s", (long) val
, name
);
833 fputs_filtered (name
, stream
);
837 print_longest (stream
, 'd', 0, val
);
841 case TYPE_CODE_FLAGS
:
843 print_scalar_formatted (valaddr
, type
, options
, 0, stream
);
845 val_print_type_code_flags (type
, valaddr
, stream
);
850 return c_val_print (type
, valaddr0
, embedded_offset
, address
, stream
,
851 recurse
, original_value
, options
);
853 ada_print_floating (valaddr0
+ embedded_offset
, type
, stream
);
856 case TYPE_CODE_UNION
:
857 case TYPE_CODE_STRUCT
:
858 if (ada_is_bogus_array_descriptor (type
))
860 fprintf_filtered (stream
, "(...?)");
865 print_record (type
, valaddr
, stream
, recurse
, original_value
,
870 case TYPE_CODE_ARRAY
:
871 return ada_val_print_array (type
, valaddr
, address
, stream
,
872 recurse
, original_value
, options
);
875 /* For references, the debugger is expected to print the value as
876 an address if DEREF_REF is null. But printing an address in place
877 of the object value would be confusing to an Ada programmer.
878 So, for Ada values, we print the actual dereferenced value
880 elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
882 if (TYPE_CODE (elttype
) != TYPE_CODE_UNDEF
)
884 LONGEST deref_val_int
= (LONGEST
) unpack_pointer (type
, valaddr
);
886 if (deref_val_int
!= 0)
888 struct value
*deref_val
=
889 ada_value_ind (value_from_longest
890 (lookup_pointer_type (elttype
),
893 val_print (value_type (deref_val
),
894 value_contents (deref_val
), 0,
895 value_address (deref_val
), stream
, recurse
+ 1,
896 original_value
, options
, current_language
);
899 fputs_filtered ("(null)", stream
);
902 fputs_filtered ("???", stream
);
911 print_variant_part (struct type
*type
, int field_num
, const gdb_byte
*valaddr
,
912 struct ui_file
*stream
, int recurse
,
913 const struct value
*val
,
914 const struct value_print_options
*options
,
916 struct type
*outer_type
, const gdb_byte
*outer_valaddr
)
918 struct type
*var_type
= TYPE_FIELD_TYPE (type
, field_num
);
919 int which
= ada_which_variant_applies (var_type
, outer_type
, outer_valaddr
);
924 return print_field_values
925 (TYPE_FIELD_TYPE (var_type
, which
),
926 valaddr
+ TYPE_FIELD_BITPOS (type
, field_num
) / HOST_CHAR_BIT
927 + TYPE_FIELD_BITPOS (var_type
, which
) / HOST_CHAR_BIT
,
928 stream
, recurse
, val
, options
,
929 comma_needed
, outer_type
, outer_valaddr
);
933 ada_value_print (struct value
*val0
, struct ui_file
*stream
,
934 const struct value_print_options
*options
)
936 struct value
*val
= ada_to_fixed_value (val0
);
937 CORE_ADDR address
= value_address (val
);
938 struct type
*type
= value_type (val
);
939 struct value_print_options opts
;
941 /* If it is a pointer, indicate what it points to. */
942 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
944 /* Hack: don't print (char *) for char strings. Their
945 type is indicated by the quoted string anyway. */
946 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) != sizeof (char)
947 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_INT
948 || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type
)))
950 fprintf_filtered (stream
, "(");
951 type_print (type
, "", stream
, -1);
952 fprintf_filtered (stream
, ") ");
955 else if (ada_is_array_descriptor_type (type
))
957 /* We do not print the type description unless TYPE is an array
958 access type (this is encoded by the compiler as a typedef to
959 a fat pointer - hence the check against TYPE_CODE_TYPEDEF). */
960 if (TYPE_CODE (type
) == TYPE_CODE_TYPEDEF
)
962 fprintf_filtered (stream
, "(");
963 type_print (type
, "", stream
, -1);
964 fprintf_filtered (stream
, ") ");
967 else if (ada_is_bogus_array_descriptor (type
))
969 fprintf_filtered (stream
, "(");
970 type_print (type
, "", stream
, -1);
971 fprintf_filtered (stream
, ") (...?)");
977 return (val_print (type
, value_contents (val
), 0, address
,
978 stream
, 0, val
, &opts
, current_language
));
982 print_record (struct type
*type
, const gdb_byte
*valaddr
,
983 struct ui_file
*stream
, int recurse
,
984 const struct value
*val
,
985 const struct value_print_options
*options
)
987 type
= ada_check_typedef (type
);
989 fprintf_filtered (stream
, "(");
991 if (print_field_values (type
, valaddr
, stream
, recurse
, val
, options
,
992 0, type
, valaddr
) != 0 && options
->pretty
)
994 fprintf_filtered (stream
, "\n");
995 print_spaces_filtered (2 * recurse
, stream
);
998 fprintf_filtered (stream
, ")");
1001 /* Print out fields of value at VALADDR having structure type TYPE.
1003 TYPE, VALADDR, STREAM, RECURSE, and OPTIONS have the
1004 same meanings as in ada_print_value and ada_val_print.
1006 OUTER_TYPE and OUTER_VALADDR give type and address of enclosing record
1007 (used to get discriminant values when printing variant parts).
1009 COMMA_NEEDED is 1 if fields have been printed at the current recursion
1010 level, so that a comma is needed before any field printed by this
1013 Returns 1 if COMMA_NEEDED or any fields were printed. */
1016 print_field_values (struct type
*type
, const gdb_byte
*valaddr
,
1017 struct ui_file
*stream
, int recurse
,
1018 const struct value
*val
,
1019 const struct value_print_options
*options
,
1021 struct type
*outer_type
, const gdb_byte
*outer_valaddr
)
1025 len
= TYPE_NFIELDS (type
);
1027 for (i
= 0; i
< len
; i
+= 1)
1029 if (ada_is_ignored_field (type
, i
))
1032 if (ada_is_wrapper_field (type
, i
))
1035 print_field_values (TYPE_FIELD_TYPE (type
, i
),
1037 + TYPE_FIELD_BITPOS (type
, i
) / HOST_CHAR_BIT
,
1038 stream
, recurse
, val
, options
,
1039 comma_needed
, type
, valaddr
);
1042 else if (ada_is_variant_part (type
, i
))
1045 print_variant_part (type
, i
, valaddr
,
1046 stream
, recurse
, val
, options
, comma_needed
,
1047 outer_type
, outer_valaddr
);
1052 fprintf_filtered (stream
, ", ");
1055 if (options
->pretty
)
1057 fprintf_filtered (stream
, "\n");
1058 print_spaces_filtered (2 + 2 * recurse
, stream
);
1062 wrap_here (n_spaces (2 + 2 * recurse
));
1064 if (options
->inspect_it
)
1066 if (TYPE_CODE (TYPE_FIELD_TYPE (type
, i
)) == TYPE_CODE_PTR
)
1067 fputs_filtered ("\"( ptr \"", stream
);
1069 fputs_filtered ("\"( nodef \"", stream
);
1070 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
1071 language_cplus
, DMGL_NO_OPTS
);
1072 fputs_filtered ("\" \"", stream
);
1073 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
1074 language_cplus
, DMGL_NO_OPTS
);
1075 fputs_filtered ("\") \"", stream
);
1079 annotate_field_begin (TYPE_FIELD_TYPE (type
, i
));
1080 fprintf_filtered (stream
, "%.*s",
1081 ada_name_prefix_len (TYPE_FIELD_NAME (type
, i
)),
1082 TYPE_FIELD_NAME (type
, i
));
1083 annotate_field_name_end ();
1084 fputs_filtered (" => ", stream
);
1085 annotate_field_value ();
1088 if (TYPE_FIELD_PACKED (type
, i
))
1092 /* Bitfields require special handling, especially due to byte
1094 if (HAVE_CPLUS_STRUCT (type
) && TYPE_FIELD_IGNORE (type
, i
))
1096 fputs_filtered (_("<optimized out or zero length>"), stream
);
1100 int bit_pos
= TYPE_FIELD_BITPOS (type
, i
);
1101 int bit_size
= TYPE_FIELD_BITSIZE (type
, i
);
1102 struct value_print_options opts
;
1104 adjust_type_signedness (TYPE_FIELD_TYPE (type
, i
));
1105 v
= ada_value_primitive_packed_val (NULL
, valaddr
,
1106 bit_pos
/ HOST_CHAR_BIT
,
1107 bit_pos
% HOST_CHAR_BIT
,
1109 TYPE_FIELD_TYPE (type
, i
));
1112 val_print (TYPE_FIELD_TYPE (type
, i
), value_contents (v
), 0, 0,
1113 stream
, recurse
+ 1, v
,
1114 &opts
, current_language
);
1119 struct value_print_options opts
= *options
;
1122 ada_val_print (TYPE_FIELD_TYPE (type
, i
),
1123 valaddr
+ TYPE_FIELD_BITPOS (type
, i
) / HOST_CHAR_BIT
,
1124 0, 0, stream
, recurse
+ 1, val
, &opts
);
1126 annotate_field_end ();
1129 return comma_needed
;