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
)
300 return (int) extract_unsigned_integer (string
+ 2 * i
, 2);
303 /* Wrapper around memcpy to make it legal argument to ui_file_put */
305 ui_memcpy (void *dest
, const char *buffer
, long len
)
307 memcpy (dest
, buffer
, (size_t) len
);
308 ((char *) dest
)[len
] = '\0';
311 /* Print a floating-point value of type TYPE, pointed to in GDB by
312 VALADDR, on STREAM. Use Ada formatting conventions: there must be
313 a decimal point, and at least one digit before and after the
314 point. We use GNAT format for NaNs and infinities. */
316 ada_print_floating (const gdb_byte
*valaddr
, struct type
*type
,
317 struct ui_file
*stream
)
322 struct ui_file
*tmp_stream
= mem_fileopen ();
323 struct cleanup
*cleanups
= make_cleanup_ui_file_delete (tmp_stream
);
325 print_floating (valaddr
, type
, tmp_stream
);
326 ui_file_put (tmp_stream
, ui_memcpy
, buffer
);
327 do_cleanups (cleanups
);
330 len
= strlen (result
);
332 /* Modify for Ada rules. */
334 s
= strstr (result
, "inf");
336 s
= strstr (result
, "Inf");
338 s
= strstr (result
, "INF");
344 s
= strstr (result
, "nan");
346 s
= strstr (result
, "NaN");
348 s
= strstr (result
, "Nan");
352 if (result
[0] == '-')
357 if (s
== NULL
&& strchr (result
, '.') == NULL
)
359 s
= strchr (result
, 'e');
361 fprintf_filtered (stream
, "%s.0", result
);
363 fprintf_filtered (stream
, "%.*s.0%s", (int) (s
-result
), result
, s
);
366 fprintf_filtered (stream
, "%s", result
);
370 ada_printchar (int c
, struct type
*type
, struct ui_file
*stream
)
372 fputs_filtered ("'", stream
);
373 ada_emit_char (c
, type
, stream
, '\'', 1);
374 fputs_filtered ("'", stream
);
377 /* [From print_type_scalar in typeprint.c]. Print VAL on STREAM in a
378 form appropriate for TYPE, if non-NULL. If TYPE is NULL, print VAL
379 like a default signed integer. */
382 ada_print_scalar (struct type
*type
, LONGEST val
, struct ui_file
*stream
)
389 print_longest (stream
, 'd', 0, val
);
393 type
= ada_check_typedef (type
);
395 switch (TYPE_CODE (type
))
399 len
= TYPE_NFIELDS (type
);
400 for (i
= 0; i
< len
; i
++)
402 if (TYPE_FIELD_BITPOS (type
, i
) == val
)
409 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type
, i
)), stream
);
413 print_longest (stream
, 'd', 0, val
);
418 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0, val
);
422 LA_PRINT_CHAR ((unsigned char) val
, type
, stream
);
426 fprintf_filtered (stream
, val
? "true" : "false");
429 case TYPE_CODE_RANGE
:
430 ada_print_scalar (TYPE_TARGET_TYPE (type
), val
, stream
);
433 case TYPE_CODE_UNDEF
:
435 case TYPE_CODE_ARRAY
:
436 case TYPE_CODE_STRUCT
:
437 case TYPE_CODE_UNION
:
442 case TYPE_CODE_STRING
:
443 case TYPE_CODE_ERROR
:
444 case TYPE_CODE_MEMBERPTR
:
445 case TYPE_CODE_METHODPTR
:
446 case TYPE_CODE_METHOD
:
448 warning (_("internal error: unhandled type in ada_print_scalar"));
452 error (_("Invalid type code in symbol table."));
457 /* Print the character string STRING, printing at most LENGTH characters.
458 Printing stops early if the number hits print_max; repeat counts
459 are printed as appropriate. Print ellipses at the end if we
460 had to stop before printing LENGTH characters, or if
461 FORCE_ELLIPSES. TYPE_LEN is the length (1 or 2) of the character type.
465 printstr (struct ui_file
*stream
, struct type
*elttype
, const gdb_byte
*string
,
466 unsigned int length
, int force_ellipses
, int type_len
,
467 const struct value_print_options
*options
)
470 unsigned int things_printed
= 0;
476 fputs_filtered ("\"\"", stream
);
480 for (i
= 0; i
< length
&& things_printed
< options
->print_max
; i
+= 1)
482 /* Position of the character we are examining
483 to see whether it is repeated. */
485 /* Number of repetitions we have detected so far. */
492 fputs_filtered (", ", stream
);
499 && char_at (string
, rep1
, type_len
) == char_at (string
, i
,
506 if (reps
> options
->repeat_count_threshold
)
510 if (options
->inspect_it
)
511 fputs_filtered ("\\\", ", stream
);
513 fputs_filtered ("\", ", stream
);
516 fputs_filtered ("'", stream
);
517 ada_emit_char (char_at (string
, i
, type_len
), elttype
, stream
, '\'',
519 fputs_filtered ("'", stream
);
520 fprintf_filtered (stream
, _(" <repeats %u times>"), reps
);
522 things_printed
+= options
->repeat_count_threshold
;
529 if (options
->inspect_it
)
530 fputs_filtered ("\\\"", stream
);
532 fputs_filtered ("\"", stream
);
535 ada_emit_char (char_at (string
, i
, type_len
), elttype
, stream
, '"',
541 /* Terminate the quotes if necessary. */
544 if (options
->inspect_it
)
545 fputs_filtered ("\\\"", stream
);
547 fputs_filtered ("\"", stream
);
550 if (force_ellipses
|| i
< length
)
551 fputs_filtered ("...", stream
);
555 ada_printstr (struct ui_file
*stream
, struct type
*type
, const gdb_byte
*string
,
556 unsigned int length
, int force_ellipses
,
557 const struct value_print_options
*options
)
559 printstr (stream
, type
, string
, length
, force_ellipses
, TYPE_LENGTH (type
),
564 /* Print data of type TYPE located at VALADDR (within GDB), which came from
565 the inferior at address ADDRESS, onto stdio stream STREAM according to
566 OPTIONS. The data at VALADDR is in target byte order.
568 If the data is printed as a string, returns the number of string characters
571 RECURSE indicates the amount of indentation to supply before
572 continuation lines; this amount is roughly twice the value of RECURSE. */
575 ada_val_print (struct type
*type
, const gdb_byte
*valaddr0
,
576 int embedded_offset
, CORE_ADDR address
,
577 struct ui_file
*stream
, int recurse
,
578 const struct value_print_options
*options
)
580 struct ada_val_print_args args
;
582 args
.valaddr0
= valaddr0
;
583 args
.embedded_offset
= embedded_offset
;
584 args
.address
= address
;
585 args
.stream
= stream
;
586 args
.recurse
= recurse
;
587 args
.options
= options
;
589 return catch_errors (ada_val_print_stub
, &args
, NULL
, RETURN_MASK_ALL
);
592 /* Helper for ada_val_print; used as argument to catch_errors to
593 unmarshal the arguments to ada_val_print_1, which does the work. */
595 ada_val_print_stub (void *args0
)
597 struct ada_val_print_args
*argsp
= (struct ada_val_print_args
*) args0
;
598 return ada_val_print_1 (argsp
->type
, argsp
->valaddr0
,
599 argsp
->embedded_offset
, argsp
->address
,
600 argsp
->stream
, argsp
->recurse
, argsp
->options
);
603 /* Assuming TYPE is a simple array, print the value of this array located
604 at VALADDR. See ada_val_print for a description of the various
605 parameters of this function; they are identical. The semantics
606 of the return value is also identical to ada_val_print. */
609 ada_val_print_array (struct type
*type
, const gdb_byte
*valaddr
,
610 CORE_ADDR address
, struct ui_file
*stream
, int recurse
,
611 const struct value_print_options
*options
)
613 struct type
*elttype
= TYPE_TARGET_TYPE (type
);
621 eltlen
= TYPE_LENGTH (elttype
);
625 len
= TYPE_LENGTH (type
) / eltlen
;
627 /* For an array of chars, print with string syntax. */
628 if (ada_is_string_type (type
)
629 && (options
->format
== 0 || options
->format
== 's'))
631 if (options
->prettyprint_arrays
)
632 print_spaces_filtered (2 + 2 * recurse
, stream
);
634 /* If requested, look for the first null char and only print
635 elements up to it. */
636 if (options
->stop_print_at_null
)
640 /* Look for a NULL char. */
643 && temp_len
< options
->print_max
644 && char_at (valaddr
, temp_len
, eltlen
) != 0);
649 printstr (stream
, elttype
, valaddr
, len
, 0, eltlen
, options
);
654 fprintf_filtered (stream
, "(");
655 print_optional_low_bound (stream
, type
, options
);
656 if (TYPE_FIELD_BITSIZE (type
, 0) > 0)
657 val_print_packed_array_elements (type
, valaddr
, 0, stream
,
660 val_print_array_elements (type
, valaddr
, address
, stream
,
661 recurse
, options
, 0);
662 fprintf_filtered (stream
, ")");
668 /* See the comment on ada_val_print. This function differs in that it
669 does not catch evaluation errors (leaving that to ada_val_print). */
672 ada_val_print_1 (struct type
*type
, const gdb_byte
*valaddr0
,
673 int embedded_offset
, CORE_ADDR address
,
674 struct ui_file
*stream
, int recurse
,
675 const struct value_print_options
*options
)
679 struct type
*elttype
;
682 const gdb_byte
*valaddr
= valaddr0
+ embedded_offset
;
684 type
= ada_check_typedef (type
);
686 if (ada_is_array_descriptor_type (type
) || ada_is_packed_array_type (type
))
689 struct value
*mark
= value_mark ();
691 val
= value_from_contents_and_address (type
, valaddr
, address
);
692 val
= ada_coerce_to_simple_array_ptr (val
);
695 fprintf_filtered (stream
, "(null)");
699 retn
= ada_val_print_1 (value_type (val
), value_contents (val
), 0,
700 value_address (val
), stream
, recurse
, options
);
701 value_free_to_mark (mark
);
705 valaddr
= ada_aligned_value_addr (type
, valaddr
);
706 embedded_offset
-= valaddr
- valaddr0
- embedded_offset
;
707 type
= printable_val_type (type
, valaddr
);
709 switch (TYPE_CODE (type
))
712 return c_val_print (type
, valaddr0
, embedded_offset
, address
, stream
,
717 int ret
= c_val_print (type
, valaddr0
, embedded_offset
, address
,
718 stream
, recurse
, options
);
719 if (ada_is_tag_type (type
))
722 value_from_contents_and_address (type
, valaddr
, address
);
723 const char *name
= ada_tag_name (val
);
725 fprintf_filtered (stream
, " (%s)", name
);
732 case TYPE_CODE_RANGE
:
733 if (ada_is_fixed_point_type (type
))
735 LONGEST v
= unpack_long (type
, valaddr
);
736 int len
= TYPE_LENGTH (type
);
738 fprintf_filtered (stream
, len
< 4 ? "%.11g" : "%.17g",
739 (double) ada_fixed_to_float (type
, v
));
742 else if (ada_is_vax_floating_type (type
))
745 value_from_contents_and_address (type
, valaddr
, address
);
746 struct value
*func
= ada_vax_float_print_function (type
);
749 struct gdbarch
*gdbarch
= current_gdbarch
;
751 addr
= value_as_address (call_function_by_hand (func
, 1, &val
));
752 val_print_string (builtin_type (gdbarch
)->builtin_true_char
,
753 addr
, -1, stream
, options
);
756 /* No special printing function. Do as best we can. */
758 else if (TYPE_CODE (type
) == TYPE_CODE_RANGE
)
760 struct type
*target_type
= TYPE_TARGET_TYPE (type
);
761 if (TYPE_LENGTH (type
) != TYPE_LENGTH (target_type
))
763 /* Obscure case of range type that has different length from
764 its base type. Perform a conversion, or we will get a
765 nonsense value. Actually, we could use the same
766 code regardless of lengths; I'm just avoiding a cast. */
767 struct value
*v
= value_cast (target_type
,
768 value_from_contents_and_address
770 return ada_val_print_1 (target_type
, value_contents (v
), 0, 0,
771 stream
, recurse
+ 1, options
);
774 return ada_val_print_1 (TYPE_TARGET_TYPE (type
),
775 valaddr0
, embedded_offset
,
776 address
, stream
, recurse
, options
);
780 int format
= (options
->format
? options
->format
781 : options
->output_format
);
784 struct value_print_options opts
= *options
;
785 opts
.format
= format
;
786 print_scalar_formatted (valaddr
, type
, &opts
, 0, stream
);
788 else if (ada_is_system_address_type (type
)
789 && TYPE_OBJFILE (type
) != NULL
)
791 /* FIXME: We want to print System.Address variables using
792 the same format as for any access type. But for some
793 reason GNAT encodes the System.Address type as an int,
794 so we have to work-around this deficiency by handling
795 System.Address values as a special case.
797 We do this only for System.Address types defined in an
798 objfile. For the built-in version of System.Address we
799 have installed the proper type to begin with. */
801 struct gdbarch
*gdbarch
= get_objfile_arch (TYPE_OBJFILE (type
));
802 struct type
*ptr_type
= builtin_type (gdbarch
)->builtin_data_ptr
;
804 fprintf_filtered (stream
, "(");
805 type_print (type
, "", stream
, -1);
806 fprintf_filtered (stream
, ") ");
807 fputs_filtered (paddress (extract_typed_address
808 (valaddr
, ptr_type
)),
813 val_print_type_code_int (type
, valaddr
, stream
);
814 if (ada_is_character_type (type
))
816 fputs_filtered (" ", stream
);
817 ada_printchar ((unsigned char) unpack_long (type
, valaddr
),
827 print_scalar_formatted (valaddr
, type
, options
, 0, stream
);
830 len
= TYPE_NFIELDS (type
);
831 val
= unpack_long (type
, valaddr
);
832 for (i
= 0; i
< len
; i
++)
835 if (val
== TYPE_FIELD_BITPOS (type
, i
))
842 const char *name
= ada_enum_name (TYPE_FIELD_NAME (type
, i
));
844 fprintf_filtered (stream
, "%ld %s", (long) val
, name
);
846 fputs_filtered (name
, stream
);
850 print_longest (stream
, 'd', 0, val
);
854 case TYPE_CODE_FLAGS
:
856 print_scalar_formatted (valaddr
, type
, options
, 0, stream
);
858 val_print_type_code_flags (type
, valaddr
, stream
);
863 return c_val_print (type
, valaddr0
, embedded_offset
, address
, stream
,
866 ada_print_floating (valaddr0
+ embedded_offset
, type
, stream
);
869 case TYPE_CODE_UNION
:
870 case TYPE_CODE_STRUCT
:
871 if (ada_is_bogus_array_descriptor (type
))
873 fprintf_filtered (stream
, "(...?)");
878 print_record (type
, valaddr
, stream
, recurse
, options
);
882 case TYPE_CODE_ARRAY
:
883 return ada_val_print_array (type
, valaddr
, address
, stream
,
887 /* For references, the debugger is expected to print the value as
888 an address if DEREF_REF is null. But printing an address in place
889 of the object value would be confusing to an Ada programmer.
890 So, for Ada values, we print the actual dereferenced value
892 elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
894 if (TYPE_CODE (elttype
) != TYPE_CODE_UNDEF
)
896 LONGEST deref_val_int
= (LONGEST
) unpack_pointer (type
, valaddr
);
897 if (deref_val_int
!= 0)
899 struct value
*deref_val
=
900 ada_value_ind (value_from_longest
901 (lookup_pointer_type (elttype
),
903 val_print (value_type (deref_val
),
904 value_contents (deref_val
), 0,
905 value_address (deref_val
), stream
, recurse
+ 1,
906 options
, current_language
);
909 fputs_filtered ("(null)", stream
);
912 fputs_filtered ("???", stream
);
921 print_variant_part (struct type
*type
, int field_num
, const gdb_byte
*valaddr
,
922 struct ui_file
*stream
, int recurse
,
923 const struct value_print_options
*options
, int comma_needed
,
924 struct type
*outer_type
, const gdb_byte
*outer_valaddr
)
926 struct type
*var_type
= TYPE_FIELD_TYPE (type
, field_num
);
927 int which
= ada_which_variant_applies (var_type
, outer_type
, outer_valaddr
);
932 return print_field_values
933 (TYPE_FIELD_TYPE (var_type
, which
),
934 valaddr
+ TYPE_FIELD_BITPOS (type
, field_num
) / HOST_CHAR_BIT
935 + TYPE_FIELD_BITPOS (var_type
, which
) / HOST_CHAR_BIT
,
936 stream
, recurse
, options
,
937 comma_needed
, outer_type
, outer_valaddr
);
941 ada_value_print (struct value
*val0
, struct ui_file
*stream
,
942 const struct value_print_options
*options
)
944 const gdb_byte
*valaddr
= value_contents (val0
);
945 CORE_ADDR address
= value_address (val0
);
947 ada_to_fixed_type (value_type (val0
), valaddr
, address
, NULL
, 1);
949 value_from_contents_and_address (type
, valaddr
, address
);
950 struct value_print_options opts
;
952 /* If it is a pointer, indicate what it points to. */
953 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
955 /* Hack: don't print (char *) for char strings. Their
956 type is indicated by the quoted string anyway. */
957 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) != sizeof (char)
958 || TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_INT
959 || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type
)))
961 fprintf_filtered (stream
, "(");
962 type_print (type
, "", stream
, -1);
963 fprintf_filtered (stream
, ") ");
966 else if (ada_is_array_descriptor_type (type
))
968 fprintf_filtered (stream
, "(");
969 type_print (type
, "", stream
, -1);
970 fprintf_filtered (stream
, ") ");
972 else if (ada_is_bogus_array_descriptor (type
))
974 fprintf_filtered (stream
, "(");
975 type_print (type
, "", stream
, -1);
976 fprintf_filtered (stream
, ") (...?)");
982 return (val_print (type
, value_contents (val
), 0, address
,
983 stream
, 0, &opts
, current_language
));
987 print_record (struct type
*type
, const gdb_byte
*valaddr
,
988 struct ui_file
*stream
, int recurse
,
989 const struct value_print_options
*options
)
991 type
= ada_check_typedef (type
);
993 fprintf_filtered (stream
, "(");
995 if (print_field_values (type
, valaddr
, stream
, recurse
, options
,
996 0, type
, valaddr
) != 0 && options
->pretty
)
998 fprintf_filtered (stream
, "\n");
999 print_spaces_filtered (2 * recurse
, stream
);
1002 fprintf_filtered (stream
, ")");
1005 /* Print out fields of value at VALADDR having structure type TYPE.
1007 TYPE, VALADDR, STREAM, RECURSE, and OPTIONS have the
1008 same meanings as in ada_print_value and ada_val_print.
1010 OUTER_TYPE and OUTER_VALADDR give type and address of enclosing record
1011 (used to get discriminant values when printing variant parts).
1013 COMMA_NEEDED is 1 if fields have been printed at the current recursion
1014 level, so that a comma is needed before any field printed by this
1017 Returns 1 if COMMA_NEEDED or any fields were printed. */
1020 print_field_values (struct type
*type
, const gdb_byte
*valaddr
,
1021 struct ui_file
*stream
, int recurse
,
1022 const struct value_print_options
*options
,
1024 struct type
*outer_type
, const gdb_byte
*outer_valaddr
)
1028 len
= TYPE_NFIELDS (type
);
1030 for (i
= 0; i
< len
; i
+= 1)
1032 if (ada_is_ignored_field (type
, i
))
1035 if (ada_is_wrapper_field (type
, i
))
1038 print_field_values (TYPE_FIELD_TYPE (type
, i
),
1040 + TYPE_FIELD_BITPOS (type
, i
) / HOST_CHAR_BIT
,
1041 stream
, recurse
, options
,
1042 comma_needed
, type
, valaddr
);
1045 else if (ada_is_variant_part (type
, i
))
1048 print_variant_part (type
, i
, valaddr
,
1049 stream
, recurse
, options
, comma_needed
,
1050 outer_type
, outer_valaddr
);
1055 fprintf_filtered (stream
, ", ");
1058 if (options
->pretty
)
1060 fprintf_filtered (stream
, "\n");
1061 print_spaces_filtered (2 + 2 * recurse
, stream
);
1065 wrap_here (n_spaces (2 + 2 * recurse
));
1067 if (options
->inspect_it
)
1069 if (TYPE_CODE (TYPE_FIELD_TYPE (type
, i
)) == TYPE_CODE_PTR
)
1070 fputs_filtered ("\"( ptr \"", stream
);
1072 fputs_filtered ("\"( nodef \"", stream
);
1073 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
1074 language_cplus
, DMGL_NO_OPTS
);
1075 fputs_filtered ("\" \"", stream
);
1076 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
1077 language_cplus
, DMGL_NO_OPTS
);
1078 fputs_filtered ("\") \"", stream
);
1082 annotate_field_begin (TYPE_FIELD_TYPE (type
, i
));
1083 fprintf_filtered (stream
, "%.*s",
1084 ada_name_prefix_len (TYPE_FIELD_NAME (type
, i
)),
1085 TYPE_FIELD_NAME (type
, i
));
1086 annotate_field_name_end ();
1087 fputs_filtered (" => ", stream
);
1088 annotate_field_value ();
1091 if (TYPE_FIELD_PACKED (type
, i
))
1095 /* Bitfields require special handling, especially due to byte
1097 if (TYPE_CPLUS_SPECIFIC (type
) != NULL
1098 && TYPE_FIELD_IGNORE (type
, i
))
1100 fputs_filtered (_("<optimized out or zero length>"), stream
);
1104 int bit_pos
= TYPE_FIELD_BITPOS (type
, i
);
1105 int bit_size
= TYPE_FIELD_BITSIZE (type
, i
);
1106 struct value_print_options opts
;
1108 adjust_type_signedness (TYPE_FIELD_TYPE (type
, i
));
1109 v
= ada_value_primitive_packed_val (NULL
, valaddr
,
1110 bit_pos
/ HOST_CHAR_BIT
,
1111 bit_pos
% HOST_CHAR_BIT
,
1113 TYPE_FIELD_TYPE (type
, i
));
1116 val_print (TYPE_FIELD_TYPE (type
, i
), value_contents (v
), 0, 0,
1117 stream
, recurse
+ 1, &opts
, current_language
);
1122 struct value_print_options opts
= *options
;
1124 ada_val_print (TYPE_FIELD_TYPE (type
, i
),
1125 valaddr
+ TYPE_FIELD_BITPOS (type
, i
) / HOST_CHAR_BIT
,
1126 0, 0, stream
, recurse
+ 1, &opts
);
1128 annotate_field_end ();
1131 return comma_needed
;