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 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
;
47 const struct value_print_options
*options
;
50 static void print_record (struct type
*, const gdb_byte
*, struct ui_file
*,
51 int, const struct value_print_options
*);
53 static int print_field_values (struct type
*, const gdb_byte
*,
54 struct ui_file
*, int,
55 const struct value_print_options
*,
59 static void adjust_type_signedness (struct type
*);
61 static int ada_val_print_stub (void *args0
);
63 static int ada_val_print_1 (struct type
*, const gdb_byte
*, int, CORE_ADDR
,
64 struct ui_file
*, int,
65 const struct value_print_options
*);
68 /* Make TYPE unsigned if its range of values includes no negatives. */
70 adjust_type_signedness (struct type
*type
)
72 if (type
!= NULL
&& TYPE_CODE (type
) == TYPE_CODE_RANGE
73 && TYPE_LOW_BOUND (type
) >= 0)
74 TYPE_UNSIGNED (type
) = 1;
77 /* Assuming TYPE is a simple array type, prints its lower bound on STREAM,
78 if non-standard (i.e., other than 1 for numbers, other than lower bound
79 of index type for enumerated type). Returns 1 if something printed,
83 print_optional_low_bound (struct ui_file
*stream
, struct type
*type
,
84 const struct value_print_options
*options
)
86 struct type
*index_type
;
90 if (options
->print_array_indexes
)
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
:
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 OPTIONS and
141 separates with commas. RECURSE is the recursion (nesting) level.
142 TYPE must have been decoded (as by ada_coerce_to_simple_array). */
145 val_print_packed_array_elements (struct type
*type
, const gdb_byte
*valaddr
,
146 int bitoffset
, struct ui_file
*stream
,
148 const struct value_print_options
*options
)
151 unsigned int things_printed
= 0;
153 struct type
*elttype
, *index_type
;
155 unsigned long bitsize
= TYPE_FIELD_BITSIZE (type
, 0);
156 struct value
*mark
= value_mark ();
159 elttype
= TYPE_TARGET_TYPE (type
);
160 eltlen
= TYPE_LENGTH (check_typedef (elttype
));
161 index_type
= TYPE_INDEX_TYPE (type
);
165 if (get_discrete_bounds (index_type
, &low
, &high
) < 0)
168 len
= high
- low
+ 1;
172 annotate_array_section_begin (i
, elttype
);
174 while (i
< len
&& things_printed
< options
->print_max
)
176 struct value
*v0
, *v1
;
181 if (options
->prettyprint_arrays
)
183 fprintf_filtered (stream
, ",\n");
184 print_spaces_filtered (2 + 2 * recurse
, stream
);
188 fprintf_filtered (stream
, ", ");
191 wrap_here (n_spaces (2 + 2 * recurse
));
192 maybe_print_array_index (index_type
, i
+ low
, stream
, options
);
195 v0
= ada_value_primitive_packed_val (NULL
, valaddr
,
196 (i0
* bitsize
) / HOST_CHAR_BIT
,
197 (i0
* bitsize
) % HOST_CHAR_BIT
,
204 v1
= ada_value_primitive_packed_val (NULL
, valaddr
,
205 (i
* bitsize
) / HOST_CHAR_BIT
,
206 (i
* bitsize
) % HOST_CHAR_BIT
,
208 if (memcmp (value_contents (v0
), value_contents (v1
), eltlen
) != 0)
212 if (i
- i0
> options
->repeat_count_threshold
)
214 struct value_print_options opts
= *options
;
216 val_print (elttype
, value_contents (v0
), 0, 0, stream
,
217 recurse
+ 1, &opts
, current_language
);
218 annotate_elt_rep (i
- i0
);
219 fprintf_filtered (stream
, _(" <repeats %u times>"), i
- i0
);
220 annotate_elt_rep_end ();
226 struct value_print_options opts
= *options
;
228 for (j
= i0
; j
< i
; j
+= 1)
232 if (options
->prettyprint_arrays
)
234 fprintf_filtered (stream
, ",\n");
235 print_spaces_filtered (2 + 2 * recurse
, stream
);
239 fprintf_filtered (stream
, ", ");
241 wrap_here (n_spaces (2 + 2 * recurse
));
242 maybe_print_array_index (index_type
, j
+ low
,
245 val_print (elttype
, value_contents (v0
), 0, 0, stream
,
246 recurse
+ 1, &opts
, current_language
);
250 things_printed
+= i
- i0
;
252 annotate_array_section_end ();
255 fprintf_filtered (stream
, "...");
258 value_free_to_mark (mark
);
262 printable_val_type (struct type
*type
, const gdb_byte
*valaddr
)
264 return ada_to_fixed_type (ada_aligned_type (type
), valaddr
, 0, NULL
, 1);
267 /* Print the character C on STREAM as part of the contents of a literal
268 string whose delimiter is QUOTER. TYPE_LEN is the length in bytes
269 (1 or 2) of the character. */
272 ada_emit_char (int c
, struct type
*type
, struct ui_file
*stream
,
273 int quoter
, int type_len
)
278 c
&= (1 << (type_len
* TARGET_CHAR_BIT
)) - 1;
280 if (isascii (c
) && isprint (c
))
282 if (c
== quoter
&& c
== '"')
283 fprintf_filtered (stream
, "\"\"");
285 fprintf_filtered (stream
, "%c", c
);
288 fprintf_filtered (stream
, "[\"%0*x\"]", type_len
* 2, c
);
291 /* Character #I of STRING, given that TYPE_LEN is the size in bytes (1
292 or 2) of a character. */
295 char_at (const gdb_byte
*string
, int i
, int type_len
,
296 enum bfd_endian byte_order
)
301 return (int) extract_unsigned_integer (string
+ 2 * i
, 2, byte_order
);
304 /* Wrapper around memcpy to make it legal argument to ui_file_put */
306 ui_memcpy (void *dest
, const char *buffer
, long len
)
308 memcpy (dest
, buffer
, (size_t) len
);
309 ((char *) dest
)[len
] = '\0';
312 /* Print a floating-point value of type TYPE, pointed to in GDB by
313 VALADDR, on STREAM. Use Ada formatting conventions: there must be
314 a decimal point, and at least one digit before and after the
315 point. We use GNAT format for NaNs and infinities. */
317 ada_print_floating (const gdb_byte
*valaddr
, struct type
*type
,
318 struct ui_file
*stream
)
323 struct ui_file
*tmp_stream
= mem_fileopen ();
324 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (tmp_stream
);
326 print_floating (valaddr
, type
, tmp_stream
);
327 ui_file_put (tmp_stream
, ui_memcpy
, buffer
);
328 do_cleanups (cleanups
);
331 len
= strlen (result
);
333 /* Modify for Ada rules. */
335 s
= strstr (result
, "inf");
337 s
= strstr (result
, "Inf");
339 s
= strstr (result
, "INF");
345 s
= strstr (result
, "nan");
347 s
= strstr (result
, "NaN");
349 s
= strstr (result
, "Nan");
353 if (result
[0] == '-')
358 if (s
== NULL
&& strchr (result
, '.') == NULL
)
360 s
= strchr (result
, 'e');
362 fprintf_filtered (stream
, "%s.0", result
);
364 fprintf_filtered (stream
, "%.*s.0%s", (int) (s
-result
), result
, s
);
367 fprintf_filtered (stream
, "%s", result
);
371 ada_printchar (int c
, struct type
*type
, struct ui_file
*stream
)
373 fputs_filtered ("'", stream
);
374 ada_emit_char (c
, type
, stream
, '\'', 1);
375 fputs_filtered ("'", stream
);
378 /* [From print_type_scalar in typeprint.c]. Print VAL on STREAM in a
379 form appropriate for TYPE, if non-NULL. If TYPE is NULL, print VAL
380 like a default signed integer. */
383 ada_print_scalar (struct type
*type
, LONGEST val
, struct ui_file
*stream
)
390 print_longest (stream
, 'd', 0, val
);
394 type
= ada_check_typedef (type
);
396 switch (TYPE_CODE (type
))
400 len
= TYPE_NFIELDS (type
);
401 for (i
= 0; i
< len
; i
++)
403 if (TYPE_FIELD_BITPOS (type
, i
) == val
)
410 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type
, i
)), stream
);
414 print_longest (stream
, 'd', 0, val
);
419 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0, val
);
423 LA_PRINT_CHAR ((unsigned char) val
, type
, stream
);
427 fprintf_filtered (stream
, val
? "true" : "false");
430 case TYPE_CODE_RANGE
:
431 ada_print_scalar (TYPE_TARGET_TYPE (type
), val
, stream
);
434 case TYPE_CODE_UNDEF
:
436 case TYPE_CODE_ARRAY
:
437 case TYPE_CODE_STRUCT
:
438 case TYPE_CODE_UNION
:
443 case TYPE_CODE_STRING
:
444 case TYPE_CODE_ERROR
:
445 case TYPE_CODE_MEMBERPTR
:
446 case TYPE_CODE_METHODPTR
:
447 case TYPE_CODE_METHOD
:
449 warning (_("internal error: unhandled type in ada_print_scalar"));
453 error (_("Invalid type code in symbol table."));
458 /* Print the character string STRING, printing at most LENGTH characters.
459 Printing stops early if the number hits print_max; repeat counts
460 are printed as appropriate. Print ellipses at the end if we
461 had to stop before printing LENGTH characters, or if
462 FORCE_ELLIPSES. TYPE_LEN is the length (1 or 2) of the character type.
466 printstr (struct ui_file
*stream
, struct type
*elttype
, const gdb_byte
*string
,
467 unsigned int length
, int force_ellipses
, int type_len
,
468 const struct value_print_options
*options
)
470 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (elttype
));
472 unsigned int things_printed
= 0;
478 fputs_filtered ("\"\"", stream
);
482 for (i
= 0; i
< length
&& things_printed
< options
->print_max
; i
+= 1)
484 /* Position of the character we are examining
485 to see whether it is repeated. */
487 /* Number of repetitions we have detected so far. */
494 fputs_filtered (", ", stream
);
501 && char_at (string
, rep1
, type_len
, byte_order
)
502 == char_at (string
, i
, type_len
, byte_order
))
508 if (reps
> options
->repeat_count_threshold
)
512 if (options
->inspect_it
)
513 fputs_filtered ("\\\", ", stream
);
515 fputs_filtered ("\", ", stream
);
518 fputs_filtered ("'", stream
);
519 ada_emit_char (char_at (string
, i
, type_len
, byte_order
),
520 elttype
, stream
, '\'', type_len
);
521 fputs_filtered ("'", stream
);
522 fprintf_filtered (stream
, _(" <repeats %u times>"), reps
);
524 things_printed
+= options
->repeat_count_threshold
;
531 if (options
->inspect_it
)
532 fputs_filtered ("\\\"", stream
);
534 fputs_filtered ("\"", stream
);
537 ada_emit_char (char_at (string
, i
, type_len
, byte_order
),
538 elttype
, stream
, '"', type_len
);
543 /* Terminate the quotes if necessary. */
546 if (options
->inspect_it
)
547 fputs_filtered ("\\\"", stream
);
549 fputs_filtered ("\"", stream
);
552 if (force_ellipses
|| i
< length
)
553 fputs_filtered ("...", stream
);
557 ada_printstr (struct ui_file
*stream
, struct type
*type
, const gdb_byte
*string
,
558 unsigned int length
, int force_ellipses
,
559 const struct value_print_options
*options
)
561 printstr (stream
, type
, string
, length
, force_ellipses
, TYPE_LENGTH (type
),
566 /* Print data of type TYPE located at VALADDR (within GDB), which came from
567 the inferior at address ADDRESS, onto stdio stream STREAM according to
568 OPTIONS. The data at VALADDR is in target byte order.
570 If the data is printed as a string, returns the number of string characters
573 RECURSE indicates the amount of indentation to supply before
574 continuation lines; this amount is roughly twice the value of RECURSE. */
577 ada_val_print (struct type
*type
, const gdb_byte
*valaddr0
,
578 int embedded_offset
, CORE_ADDR address
,
579 struct ui_file
*stream
, int recurse
,
580 const struct value_print_options
*options
)
582 struct ada_val_print_args args
;
584 args
.valaddr0
= valaddr0
;
585 args
.embedded_offset
= embedded_offset
;
586 args
.address
= address
;
587 args
.stream
= stream
;
588 args
.recurse
= recurse
;
589 args
.options
= options
;
591 return catch_errors (ada_val_print_stub
, &args
, NULL
, RETURN_MASK_ALL
);
594 /* Helper for ada_val_print; used as argument to catch_errors to
595 unmarshal the arguments to ada_val_print_1, which does the work. */
597 ada_val_print_stub (void *args0
)
599 struct ada_val_print_args
*argsp
= (struct ada_val_print_args
*) args0
;
600 return ada_val_print_1 (argsp
->type
, argsp
->valaddr0
,
601 argsp
->embedded_offset
, argsp
->address
,
602 argsp
->stream
, argsp
->recurse
, argsp
->options
);
605 /* Assuming TYPE is a simple array, print the value of this array located
606 at VALADDR. See ada_val_print for a description of the various
607 parameters of this function; they are identical. The semantics
608 of the return value is also identical to ada_val_print. */
611 ada_val_print_array (struct type
*type
, const gdb_byte
*valaddr
,
612 CORE_ADDR address
, struct ui_file
*stream
, int recurse
,
613 const struct value_print_options
*options
)
615 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
616 struct type
*elttype
= TYPE_TARGET_TYPE (type
);
624 eltlen
= TYPE_LENGTH (elttype
);
628 len
= TYPE_LENGTH (type
) / eltlen
;
630 /* For an array of chars, print with string syntax. */
631 if (ada_is_string_type (type
)
632 && (options
->format
== 0 || options
->format
== 's'))
634 if (options
->prettyprint_arrays
)
635 print_spaces_filtered (2 + 2 * recurse
, stream
);
637 /* If requested, look for the first null char and only print
638 elements up to it. */
639 if (options
->stop_print_at_null
)
643 /* Look for a NULL char. */
646 && temp_len
< options
->print_max
647 && char_at (valaddr
, temp_len
, eltlen
, byte_order
) != 0);
652 printstr (stream
, elttype
, valaddr
, len
, 0, eltlen
, options
);
657 fprintf_filtered (stream
, "(");
658 print_optional_low_bound (stream
, type
, options
);
659 if (TYPE_FIELD_BITSIZE (type
, 0) > 0)
660 val_print_packed_array_elements (type
, valaddr
, 0, stream
,
663 val_print_array_elements (type
, valaddr
, address
, stream
,
664 recurse
, options
, 0);
665 fprintf_filtered (stream
, ")");
671 /* See the comment on ada_val_print. This function differs in that it
672 does not catch evaluation errors (leaving that to ada_val_print). */
675 ada_val_print_1 (struct type
*type
, const gdb_byte
*valaddr0
,
676 int embedded_offset
, CORE_ADDR address
,
677 struct ui_file
*stream
, int recurse
,
678 const struct value_print_options
*options
)
682 struct type
*elttype
;
685 const gdb_byte
*valaddr
= valaddr0
+ embedded_offset
;
687 type
= ada_check_typedef (type
);
689 if (ada_is_array_descriptor_type (type
)
690 || ada_is_constrained_packed_array_type (type
))
693 struct value
*mark
= value_mark ();
695 val
= value_from_contents_and_address (type
, valaddr
, address
);
696 val
= ada_coerce_to_simple_array_ptr (val
);
699 fprintf_filtered (stream
, "(null)");
703 retn
= ada_val_print_1 (value_type (val
), value_contents (val
), 0,
704 value_address (val
), stream
, recurse
, options
);
705 value_free_to_mark (mark
);
709 valaddr
= ada_aligned_value_addr (type
, valaddr
);
710 embedded_offset
-= valaddr
- valaddr0
- embedded_offset
;
711 type
= printable_val_type (type
, valaddr
);
713 switch (TYPE_CODE (type
))
716 return c_val_print (type
, valaddr0
, embedded_offset
, address
, stream
,
721 int ret
= c_val_print (type
, valaddr0
, embedded_offset
, address
,
722 stream
, recurse
, options
);
723 if (ada_is_tag_type (type
))
726 value_from_contents_and_address (type
, valaddr
, address
);
727 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 (ada_is_vax_floating_type (type
))
749 value_from_contents_and_address (type
, valaddr
, address
);
750 struct value
*func
= ada_vax_float_print_function (type
);
753 struct gdbarch
*gdbarch
= get_type_arch (type
);
755 addr
= value_as_address (call_function_by_hand (func
, 1, &val
));
756 val_print_string (builtin_type (gdbarch
)->builtin_true_char
,
757 addr
, -1, stream
, options
);
760 /* No special printing function. Do as best we can. */
762 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
764 struct type
*target_type
= TYPE_TARGET_TYPE (type
);
765 if (TYPE_LENGTH (type
) != TYPE_LENGTH (target_type
))
767 /* Obscure case of range type that has different length from
768 its base type. Perform a conversion, or we will get a
769 nonsense value. Actually, we could use the same
770 code regardless of lengths; I'm just avoiding a cast. */
771 struct value
*v
= value_cast (target_type
,
772 value_from_contents_and_address
774 return ada_val_print_1 (target_type
, value_contents (v
), 0, 0,
775 stream
, recurse
+ 1, options
);
778 return ada_val_print_1 (TYPE_TARGET_TYPE (type
),
779 valaddr0
, embedded_offset
,
780 address
, stream
, recurse
, options
);
784 int format
= (options
->format
? options
->format
785 : options
->output_format
);
788 struct value_print_options opts
= *options
;
789 opts
.format
= format
;
790 print_scalar_formatted (valaddr
, type
, &opts
, 0, stream
);
792 else if (ada_is_system_address_type (type
))
794 /* FIXME: We want to print System.Address variables using
795 the same format as for any access type. But for some
796 reason GNAT encodes the System.Address type as an int,
797 so we have to work-around this deficiency by handling
798 System.Address values as a special case. */
800 struct gdbarch
*gdbarch
= get_type_arch (type
);
801 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
802 CORE_ADDR addr
= extract_typed_address (valaddr
, ptr_type
);
804 fprintf_filtered (stream
, "(");
805 type_print (type
, "", stream
, -1);
806 fprintf_filtered (stream
, ") ");
807 fputs_filtered (paddress (gdbarch
, addr
), stream
);
811 val_print_type_code_int (type
, valaddr
, stream
);
812 if (ada_is_character_type (type
))
814 fputs_filtered (" ", stream
);
815 ada_printchar ((unsigned char) unpack_long (type
, valaddr
),
825 print_scalar_formatted (valaddr
, type
, options
, 0, stream
);
828 len
= TYPE_NFIELDS (type
);
829 val
= unpack_long (type
, valaddr
);
830 for (i
= 0; i
< len
; i
++)
833 if (val
== TYPE_FIELD_BITPOS (type
, i
))
840 const char *name
= ada_enum_name (TYPE_FIELD_NAME (type
, i
));
842 fprintf_filtered (stream
, "%ld %s", (long) val
, name
);
844 fputs_filtered (name
, stream
);
848 print_longest (stream
, 'd', 0, val
);
852 case TYPE_CODE_FLAGS
:
854 print_scalar_formatted (valaddr
, type
, options
, 0, stream
);
856 val_print_type_code_flags (type
, valaddr
, stream
);
861 return c_val_print (type
, valaddr0
, embedded_offset
, address
, stream
,
864 ada_print_floating (valaddr0
+ embedded_offset
, type
, stream
);
867 case TYPE_CODE_UNION
:
868 case TYPE_CODE_STRUCT
:
869 if (ada_is_bogus_array_descriptor (type
))
871 fprintf_filtered (stream
, "(...?)");
876 print_record (type
, valaddr
, stream
, recurse
, options
);
880 case TYPE_CODE_ARRAY
:
881 return ada_val_print_array (type
, valaddr
, address
, stream
,
885 /* For references, the debugger is expected to print the value as
886 an address if DEREF_REF is null. But printing an address in place
887 of the object value would be confusing to an Ada programmer.
888 So, for Ada values, we print the actual dereferenced value
890 elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
892 if (TYPE_CODE (elttype
) != TYPE_CODE_UNDEF
)
894 LONGEST deref_val_int
= (LONGEST
) unpack_pointer (type
, valaddr
);
895 if (deref_val_int
!= 0)
897 struct value
*deref_val
=
898 ada_value_ind (value_from_longest
899 (lookup_pointer_type (elttype
),
901 val_print (value_type (deref_val
),
902 value_contents (deref_val
), 0,
903 value_address (deref_val
), stream
, recurse
+ 1,
904 options
, current_language
);
907 fputs_filtered ("(null)", stream
);
910 fputs_filtered ("???", stream
);
919 print_variant_part (struct type
*type
, int field_num
, const gdb_byte
*valaddr
,
920 struct ui_file
*stream
, int recurse
,
921 const struct value_print_options
*options
, int comma_needed
,
922 struct type
*outer_type
, const gdb_byte
*outer_valaddr
)
924 struct type
*var_type
= TYPE_FIELD_TYPE (type
, field_num
);
925 int which
= ada_which_variant_applies (var_type
, outer_type
, outer_valaddr
);
930 return print_field_values
931 (TYPE_FIELD_TYPE (var_type
, which
),
932 valaddr
+ TYPE_FIELD_BITPOS (type
, field_num
) / HOST_CHAR_BIT
933 + TYPE_FIELD_BITPOS (var_type
, which
) / HOST_CHAR_BIT
,
934 stream
, recurse
, options
,
935 comma_needed
, outer_type
, outer_valaddr
);
939 ada_value_print (struct value
*val0
, struct ui_file
*stream
,
940 const struct value_print_options
*options
)
942 const gdb_byte
*valaddr
= value_contents (val0
);
943 CORE_ADDR address
= value_address (val0
);
945 ada_to_fixed_type (value_type (val0
), valaddr
, address
, NULL
, 1);
947 value_from_contents_and_address (type
, valaddr
, address
);
948 struct value_print_options opts
;
950 /* If it is a pointer, indicate what it points to. */
951 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
953 /* Hack: don't print (char *) for char strings. Their
954 type is indicated by the quoted string anyway. */
955 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) != sizeof (char)
956 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_INT
957 || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type
)))
959 fprintf_filtered (stream
, "(");
960 type_print (type
, "", stream
, -1);
961 fprintf_filtered (stream
, ") ");
964 else if (ada_is_array_descriptor_type (type
))
966 fprintf_filtered (stream
, "(");
967 type_print (type
, "", stream
, -1);
968 fprintf_filtered (stream
, ") ");
970 else if (ada_is_bogus_array_descriptor (type
))
972 fprintf_filtered (stream
, "(");
973 type_print (type
, "", stream
, -1);
974 fprintf_filtered (stream
, ") (...?)");
980 return (val_print (type
, value_contents (val
), 0, address
,
981 stream
, 0, &opts
, current_language
));
985 print_record (struct type
*type
, const gdb_byte
*valaddr
,
986 struct ui_file
*stream
, int recurse
,
987 const struct value_print_options
*options
)
989 type
= ada_check_typedef (type
);
991 fprintf_filtered (stream
, "(");
993 if (print_field_values (type
, valaddr
, stream
, recurse
, options
,
994 0, type
, valaddr
) != 0 && options
->pretty
)
996 fprintf_filtered (stream
, "\n");
997 print_spaces_filtered (2 * recurse
, stream
);
1000 fprintf_filtered (stream
, ")");
1003 /* Print out fields of value at VALADDR having structure type TYPE.
1005 TYPE, VALADDR, STREAM, RECURSE, and OPTIONS have the
1006 same meanings as in ada_print_value and ada_val_print.
1008 OUTER_TYPE and OUTER_VALADDR give type and address of enclosing record
1009 (used to get discriminant values when printing variant parts).
1011 COMMA_NEEDED is 1 if fields have been printed at the current recursion
1012 level, so that a comma is needed before any field printed by this
1015 Returns 1 if COMMA_NEEDED or any fields were printed. */
1018 print_field_values (struct type
*type
, const gdb_byte
*valaddr
,
1019 struct ui_file
*stream
, int recurse
,
1020 const struct value_print_options
*options
,
1022 struct type
*outer_type
, const gdb_byte
*outer_valaddr
)
1026 len
= TYPE_NFIELDS (type
);
1028 for (i
= 0; i
< len
; i
+= 1)
1030 if (ada_is_ignored_field (type
, i
))
1033 if (ada_is_wrapper_field (type
, i
))
1036 print_field_values (TYPE_FIELD_TYPE (type
, i
),
1038 + TYPE_FIELD_BITPOS (type
, i
) / HOST_CHAR_BIT
,
1039 stream
, recurse
, options
,
1040 comma_needed
, type
, valaddr
);
1043 else if (ada_is_variant_part (type
, i
))
1046 print_variant_part (type
, i
, valaddr
,
1047 stream
, recurse
, options
, comma_needed
,
1048 outer_type
, outer_valaddr
);
1053 fprintf_filtered (stream
, ", ");
1056 if (options
->pretty
)
1058 fprintf_filtered (stream
, "\n");
1059 print_spaces_filtered (2 + 2 * recurse
, stream
);
1063 wrap_here (n_spaces (2 + 2 * recurse
));
1065 if (options
->inspect_it
)
1067 if (TYPE_CODE (TYPE_FIELD_TYPE (type
, i
)) == TYPE_CODE_PTR
)
1068 fputs_filtered ("\"( ptr \"", stream
);
1070 fputs_filtered ("\"( nodef \"", stream
);
1071 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
1072 language_cplus
, DMGL_NO_OPTS
);
1073 fputs_filtered ("\" \"", stream
);
1074 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
1075 language_cplus
, DMGL_NO_OPTS
);
1076 fputs_filtered ("\") \"", stream
);
1080 annotate_field_begin (TYPE_FIELD_TYPE (type
, i
));
1081 fprintf_filtered (stream
, "%.*s",
1082 ada_name_prefix_len (TYPE_FIELD_NAME (type
, i
)),
1083 TYPE_FIELD_NAME (type
, i
));
1084 annotate_field_name_end ();
1085 fputs_filtered (" => ", stream
);
1086 annotate_field_value ();
1089 if (TYPE_FIELD_PACKED (type
, i
))
1093 /* Bitfields require special handling, especially due to byte
1095 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
1096 && TYPE_FIELD_IGNORE (type
, i
))
1098 fputs_filtered (_("<optimized out or zero length>"), stream
);
1102 int bit_pos
= TYPE_FIELD_BITPOS (type
, i
);
1103 int bit_size
= TYPE_FIELD_BITSIZE (type
, i
);
1104 struct value_print_options opts
;
1106 adjust_type_signedness (TYPE_FIELD_TYPE (type
, i
));
1107 v
= ada_value_primitive_packed_val (NULL
, valaddr
,
1108 bit_pos
/ HOST_CHAR_BIT
,
1109 bit_pos
% HOST_CHAR_BIT
,
1111 TYPE_FIELD_TYPE (type
, i
));
1114 val_print (TYPE_FIELD_TYPE (type
, i
), value_contents (v
), 0, 0,
1115 stream
, recurse
+ 1, &opts
, current_language
);
1120 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, &opts
);
1126 annotate_field_end ();
1129 return comma_needed
;