1 /* Support for printing Ada types for GDB, the GNU debugger.
2 Copyright (C) 1986-2017 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 #include "gdb_obstack.h"
21 #include "bfd.h" /* Binary File Description */
24 #include "expression.h"
33 #include "typeprint.h"
37 static int print_selected_record_field_types (struct type
*, struct type
*,
39 struct ui_file
*, int, int,
40 const struct type_print_options
*);
42 static int print_record_field_types (struct type
*, struct type
*,
43 struct ui_file
*, int, int,
44 const struct type_print_options
*);
48 static char *name_buffer
;
49 static int name_buffer_len
;
51 /* The (decoded) Ada name of TYPE. This value persists until the
55 decoded_type_name (struct type
*type
)
57 if (ada_type_name (type
) == NULL
)
61 const char *raw_name
= ada_type_name (type
);
64 if (name_buffer
== NULL
|| name_buffer_len
<= strlen (raw_name
))
66 name_buffer_len
= 16 + 2 * strlen (raw_name
);
67 name_buffer
= (char *) xrealloc (name_buffer
, name_buffer_len
);
69 strcpy (name_buffer
, raw_name
);
71 s
= (char *) strstr (name_buffer
, "___");
75 s
= name_buffer
+ strlen (name_buffer
) - 1;
76 while (s
> name_buffer
&& (s
[0] != '_' || s
[-1] != '_'))
85 for (s
= q
= name_buffer
; *s
!= '\0'; q
+= 1)
87 if (s
[0] == '_' && s
[1] == '_')
103 /* Return nonzero if TYPE is a subrange type, and its bounds
104 are identical to the bounds of its subtype. */
107 type_is_full_subrange_of_target_type (struct type
*type
)
109 struct type
*subtype
;
111 if (TYPE_CODE (type
) != TYPE_CODE_RANGE
)
114 subtype
= TYPE_TARGET_TYPE (type
);
118 if (is_dynamic_type (type
))
121 if (ada_discrete_type_low_bound (type
)
122 != ada_discrete_type_low_bound (subtype
))
125 if (ada_discrete_type_high_bound (type
)
126 != ada_discrete_type_high_bound (subtype
))
132 /* Print TYPE on STREAM, preferably as a range if BOUNDS_PREFERED_P
136 print_range (struct type
*type
, struct ui_file
*stream
,
137 int bounds_prefered_p
)
139 if (!bounds_prefered_p
)
141 /* Try stripping all TYPE_CODE_RANGE layers whose bounds
142 are identical to the bounds of their subtype. When
143 the bounds of both types match, it can allow us to
144 print a range using the name of its base type, which
145 is easier to read. For instance, we would print...
147 array (character) of ...
151 array ('["00"]' .. '["ff"]') of ... */
152 while (type_is_full_subrange_of_target_type (type
))
153 type
= TYPE_TARGET_TYPE (type
);
156 switch (TYPE_CODE (type
))
158 case TYPE_CODE_RANGE
:
161 struct type
*target_type
;
162 LONGEST lo
= 0, hi
= 0; /* init for gcc -Wall */
165 target_type
= TYPE_TARGET_TYPE (type
);
166 if (target_type
== NULL
)
171 lo
= ada_discrete_type_low_bound (type
);
172 hi
= ada_discrete_type_high_bound (type
);
174 CATCH (e
, RETURN_MASK_ERROR
)
176 /* This can happen when the range is dynamic. Sometimes,
177 resolving dynamic property values requires us to have
178 access to an actual object, which is not available
179 when the user is using the "ptype" command on a type.
180 Print the range as an unbounded range. */
181 fprintf_filtered (stream
, "<>");
188 ada_print_scalar (target_type
, lo
, stream
);
189 fprintf_filtered (stream
, " .. ");
190 ada_print_scalar (target_type
, hi
, stream
);
195 fprintf_filtered (stream
, "%.*s",
196 ada_name_prefix_len (TYPE_NAME (type
)),
202 /* Print the number or discriminant bound at BOUNDS+*N on STREAM, and
203 set *N past the bound and its delimiter, if any. */
206 print_range_bound (struct type
*type
, const char *bounds
, int *n
,
207 struct ui_file
*stream
)
211 if (ada_scan_number (bounds
, *n
, &B
, n
))
213 /* STABS decodes all range types which bounds are 0 .. -1 as
214 unsigned integers (ie. the type code is TYPE_CODE_INT, not
215 TYPE_CODE_RANGE). Unfortunately, ada_print_scalar() relies
216 on the unsigned flag to determine whether the bound should
217 be printed as a signed or an unsigned value. This causes
218 the upper bound of the 0 .. -1 range types to be printed as
219 a very large unsigned number instead of -1.
220 To workaround this stabs deficiency, we replace the TYPE by NULL
221 to indicate default output when we detect that the bound is negative,
222 and the type is a TYPE_CODE_INT. The bound is negative when
223 'm' is the last character of the number scanned in BOUNDS. */
224 if (bounds
[*n
- 1] == 'm' && TYPE_CODE (type
) == TYPE_CODE_INT
)
226 ada_print_scalar (type
, B
, stream
);
227 if (bounds
[*n
] == '_')
233 const char *bound
= bounds
+ *n
;
236 pend
= strstr (bound
, "__");
238 *n
+= bound_len
= strlen (bound
);
241 bound_len
= pend
- bound
;
244 fprintf_filtered (stream
, "%.*s", bound_len
, bound
);
248 /* Assuming NAME[0 .. NAME_LEN-1] is the name of a range type, print
249 the value (if found) of the bound indicated by SUFFIX ("___L" or
250 "___U") according to the ___XD conventions. */
253 print_dynamic_range_bound (struct type
*type
, const char *name
, int name_len
,
254 const char *suffix
, struct ui_file
*stream
)
257 std::string
name_buf (name
, name_len
);
260 if (get_int_var_value (name_buf
.c_str (), B
))
261 ada_print_scalar (type
, B
, stream
);
263 fprintf_filtered (stream
, "?");
266 /* Print RAW_TYPE as a range type, using any bound information
267 following the GNAT encoding (if available).
269 If BOUNDS_PREFERED_P is nonzero, force the printing of the range
270 using its bounds. Otherwise, try printing the range without
271 printing the value of the bounds, if possible (this is only
272 considered a hint, not a guaranty). */
275 print_range_type (struct type
*raw_type
, struct ui_file
*stream
,
276 int bounds_prefered_p
)
279 struct type
*base_type
;
280 const char *subtype_info
;
282 gdb_assert (raw_type
!= NULL
);
283 name
= TYPE_NAME (raw_type
);
284 gdb_assert (name
!= NULL
);
286 if (TYPE_CODE (raw_type
) == TYPE_CODE_RANGE
)
287 base_type
= TYPE_TARGET_TYPE (raw_type
);
289 base_type
= raw_type
;
291 subtype_info
= strstr (name
, "___XD");
292 if (subtype_info
== NULL
)
293 print_range (raw_type
, stream
, bounds_prefered_p
);
296 int prefix_len
= subtype_info
- name
;
297 const char *bounds_str
;
301 bounds_str
= strchr (subtype_info
, '_');
304 if (*subtype_info
== 'L')
306 print_range_bound (base_type
, bounds_str
, &n
, stream
);
310 print_dynamic_range_bound (base_type
, name
, prefix_len
, "___L",
313 fprintf_filtered (stream
, " .. ");
315 if (*subtype_info
== 'U')
316 print_range_bound (base_type
, bounds_str
, &n
, stream
);
318 print_dynamic_range_bound (base_type
, name
, prefix_len
, "___U",
323 /* Print enumerated type TYPE on STREAM. */
326 print_enum_type (struct type
*type
, struct ui_file
*stream
)
328 int len
= TYPE_NFIELDS (type
);
332 fprintf_filtered (stream
, "(");
336 for (i
= 0; i
< len
; i
++)
340 fprintf_filtered (stream
, ", ");
342 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type
, i
)), stream
);
343 if (lastval
!= TYPE_FIELD_ENUMVAL (type
, i
))
345 fprintf_filtered (stream
, " => %s",
346 plongest (TYPE_FIELD_ENUMVAL (type
, i
)));
347 lastval
= TYPE_FIELD_ENUMVAL (type
, i
);
351 fprintf_filtered (stream
, ")");
354 /* Print representation of Ada fixed-point type TYPE on STREAM. */
357 print_fixed_point_type (struct type
*type
, struct ui_file
*stream
)
359 DOUBLEST delta
= ada_delta (type
);
360 DOUBLEST small
= ada_fixed_to_float (type
, 1);
363 fprintf_filtered (stream
, "delta ??");
366 fprintf_filtered (stream
, "delta %g", (double) delta
);
368 fprintf_filtered (stream
, " <'small = %g>", (double) small
);
372 /* Print simple (constrained) array type TYPE on STREAM. LEVEL is the
373 recursion (indentation) level, in case the element type itself has
374 nested structure, and SHOW is the number of levels of internal
375 structure to show (see ada_print_type). */
378 print_array_type (struct type
*type
, struct ui_file
*stream
, int show
,
379 int level
, const struct type_print_options
*flags
)
383 struct type
*elt_type
= NULL
;
385 if (ada_is_constrained_packed_array_type (type
))
386 type
= ada_coerce_to_simple_array_type (type
);
389 fprintf_filtered (stream
, "array (");
393 fprintf_filtered (stream
, _("<undecipherable array type>"));
398 if (ada_is_simple_array_type (type
))
400 struct type
*range_desc_type
;
401 struct type
*arr_type
;
403 range_desc_type
= ada_find_parallel_type (type
, "___XA");
404 ada_fixup_array_indexes_type (range_desc_type
);
407 if (range_desc_type
== NULL
)
409 for (arr_type
= type
; TYPE_CODE (arr_type
) == TYPE_CODE_ARRAY
;
410 arr_type
= TYPE_TARGET_TYPE (arr_type
))
412 if (arr_type
!= type
)
413 fprintf_filtered (stream
, ", ");
414 print_range (TYPE_INDEX_TYPE (arr_type
), stream
,
415 0 /* bounds_prefered_p */);
416 if (TYPE_FIELD_BITSIZE (arr_type
, 0) > 0)
417 bitsize
= TYPE_FIELD_BITSIZE (arr_type
, 0);
424 n_indices
= TYPE_NFIELDS (range_desc_type
);
425 for (k
= 0, arr_type
= type
;
427 k
+= 1, arr_type
= TYPE_TARGET_TYPE (arr_type
))
430 fprintf_filtered (stream
, ", ");
431 print_range_type (TYPE_FIELD_TYPE (range_desc_type
, k
),
432 stream
, 0 /* bounds_prefered_p */);
433 if (TYPE_FIELD_BITSIZE (arr_type
, 0) > 0)
434 bitsize
= TYPE_FIELD_BITSIZE (arr_type
, 0);
442 for (i
= i0
= ada_array_arity (type
); i
> 0; i
-= 1)
443 fprintf_filtered (stream
, "%s<>", i
== i0
? "" : ", ");
446 elt_type
= ada_array_element_type (type
, n_indices
);
447 fprintf_filtered (stream
, ") of ");
449 ada_print_type (elt_type
, "", stream
, show
== 0 ? 0 : show
- 1, level
+ 1,
451 /* Arrays with variable-length elements are never bit-packed in practice but
452 compilers have to describe their stride so that we can properly fetch
453 individual elements. Do not say the array is packed in this case. */
454 if (bitsize
> 0 && !is_dynamic_type (elt_type
))
455 fprintf_filtered (stream
, " <packed: %d-bit elements>", bitsize
);
458 /* Print the choices encoded by field FIELD_NUM of variant-part TYPE on
459 STREAM, assuming that VAL_TYPE (if non-NULL) is the type of the
460 values. Return non-zero if the field is an encoding of
461 discriminant values, as in a standard variant record, and 0 if the
462 field is not so encoded (as happens with single-component variants
463 in types annotated with pragma Unchecked_Variant). */
466 print_choices (struct type
*type
, int field_num
, struct ui_file
*stream
,
467 struct type
*val_type
)
471 const char *name
= TYPE_FIELD_NAME (type
, field_num
);
475 /* Skip over leading 'V': NOTE soon to be obsolete. */
478 if (!ada_scan_number (name
, 1, NULL
, &p
))
492 fprintf_filtered (stream
, " =>");
498 fprintf_filtered (stream
, " | ");
509 if (!ada_scan_number (name
, p
+ 1, &W
, &p
))
511 ada_print_scalar (val_type
, W
, stream
);
518 if (!ada_scan_number (name
, p
+ 1, &L
, &p
)
519 || name
[p
] != 'T' || !ada_scan_number (name
, p
+ 1, &U
, &p
))
521 ada_print_scalar (val_type
, L
, stream
);
522 fprintf_filtered (stream
, " .. ");
523 ada_print_scalar (val_type
, U
, stream
);
527 fprintf_filtered (stream
, "others");
534 fprintf_filtered (stream
, "?? =>");
538 /* Assuming that field FIELD_NUM of TYPE represents variants whose
539 discriminant is contained in OUTER_TYPE, print its components on STREAM.
540 LEVEL is the recursion (indentation) level, in case any of the fields
541 themselves have nested structure, and SHOW is the number of levels of
542 internal structure to show (see ada_print_type). For this purpose,
543 fields nested in a variant part are taken to be at the same level as
544 the fields immediately outside the variant part. */
547 print_variant_clauses (struct type
*type
, int field_num
,
548 struct type
*outer_type
, struct ui_file
*stream
,
550 const struct type_print_options
*flags
)
553 struct type
*var_type
, *par_type
;
554 struct type
*discr_type
;
556 var_type
= TYPE_FIELD_TYPE (type
, field_num
);
557 discr_type
= ada_variant_discrim_type (var_type
, outer_type
);
559 if (TYPE_CODE (var_type
) == TYPE_CODE_PTR
)
561 var_type
= TYPE_TARGET_TYPE (var_type
);
562 if (var_type
== NULL
|| TYPE_CODE (var_type
) != TYPE_CODE_UNION
)
566 par_type
= ada_find_parallel_type (var_type
, "___XVU");
567 if (par_type
!= NULL
)
570 for (i
= 0; i
< TYPE_NFIELDS (var_type
); i
+= 1)
572 fprintf_filtered (stream
, "\n%*swhen ", level
+ 4, "");
573 if (print_choices (var_type
, i
, stream
, discr_type
))
575 if (print_record_field_types (TYPE_FIELD_TYPE (var_type
, i
),
576 outer_type
, stream
, show
, level
+ 4,
579 fprintf_filtered (stream
, " null;");
582 print_selected_record_field_types (var_type
, outer_type
, i
, i
,
583 stream
, show
, level
+ 4, flags
);
587 /* Assuming that field FIELD_NUM of TYPE is a variant part whose
588 discriminants are contained in OUTER_TYPE, print a description of it
589 on STREAM. LEVEL is the recursion (indentation) level, in case any of
590 the fields themselves have nested structure, and SHOW is the number of
591 levels of internal structure to show (see ada_print_type). For this
592 purpose, fields nested in a variant part are taken to be at the same
593 level as the fields immediately outside the variant part. */
596 print_variant_part (struct type
*type
, int field_num
, struct type
*outer_type
,
597 struct ui_file
*stream
, int show
, int level
,
598 const struct type_print_options
*flags
)
600 fprintf_filtered (stream
, "\n%*scase %s is", level
+ 4, "",
601 ada_variant_discrim_name
602 (TYPE_FIELD_TYPE (type
, field_num
)));
603 print_variant_clauses (type
, field_num
, outer_type
, stream
, show
,
605 fprintf_filtered (stream
, "\n%*send case;", level
+ 4, "");
608 /* Print a description on STREAM of the fields FLD0 through FLD1 in
609 record or union type TYPE, whose discriminants are in OUTER_TYPE.
610 LEVEL is the recursion (indentation) level, in case any of the
611 fields themselves have nested structure, and SHOW is the number of
612 levels of internal structure to show (see ada_print_type). Does
613 not print parent type information of TYPE. Returns 0 if no fields
614 printed, -1 for an incomplete type, else > 0. Prints each field
615 beginning on a new line, but does not put a new line at end. */
618 print_selected_record_field_types (struct type
*type
, struct type
*outer_type
,
620 struct ui_file
*stream
, int show
, int level
,
621 const struct type_print_options
*flags
)
627 if (fld0
> fld1
&& TYPE_STUB (type
))
630 for (i
= fld0
; i
<= fld1
; i
+= 1)
634 if (ada_is_parent_field (type
, i
) || ada_is_ignored_field (type
, i
))
636 else if (ada_is_wrapper_field (type
, i
))
637 flds
+= print_record_field_types (TYPE_FIELD_TYPE (type
, i
), type
,
638 stream
, show
, level
, flags
);
639 else if (ada_is_variant_part (type
, i
))
641 print_variant_part (type
, i
, outer_type
, stream
, show
, level
, flags
);
647 fprintf_filtered (stream
, "\n%*s", level
+ 4, "");
648 ada_print_type (TYPE_FIELD_TYPE (type
, i
),
649 TYPE_FIELD_NAME (type
, i
),
650 stream
, show
- 1, level
+ 4, flags
);
651 fprintf_filtered (stream
, ";");
658 /* Print a description on STREAM of all fields of record or union type
659 TYPE, as for print_selected_record_field_types, above. */
662 print_record_field_types (struct type
*type
, struct type
*outer_type
,
663 struct ui_file
*stream
, int show
, int level
,
664 const struct type_print_options
*flags
)
666 return print_selected_record_field_types (type
, outer_type
,
667 0, TYPE_NFIELDS (type
) - 1,
668 stream
, show
, level
, flags
);
672 /* Print record type TYPE on STREAM. LEVEL is the recursion (indentation)
673 level, in case the element type itself has nested structure, and SHOW is
674 the number of levels of internal structure to show (see ada_print_type). */
677 print_record_type (struct type
*type0
, struct ui_file
*stream
, int show
,
678 int level
, const struct type_print_options
*flags
)
680 struct type
*parent_type
;
683 type
= ada_find_parallel_type (type0
, "___XVE");
687 parent_type
= ada_parent_type (type
);
688 if (ada_type_name (parent_type
) != NULL
)
690 const char *parent_name
= decoded_type_name (parent_type
);
692 /* If we fail to decode the parent type name, then use the parent
693 type name as is. Not pretty, but should never happen except
694 when the debugging info is incomplete or incorrect. This
695 prevents a crash trying to print a NULL pointer. */
696 if (parent_name
== NULL
)
697 parent_name
= ada_type_name (parent_type
);
698 fprintf_filtered (stream
, "new %s with record", parent_name
);
700 else if (parent_type
== NULL
&& ada_is_tagged_type (type
, 0))
701 fprintf_filtered (stream
, "tagged record");
703 fprintf_filtered (stream
, "record");
706 fprintf_filtered (stream
, " ... end record");
712 if (parent_type
!= NULL
&& ada_type_name (parent_type
) == NULL
)
713 flds
+= print_record_field_types (parent_type
, parent_type
,
714 stream
, show
, level
, flags
);
715 flds
+= print_record_field_types (type
, type
, stream
, show
, level
,
719 fprintf_filtered (stream
, "\n%*send record", level
, "");
721 fprintf_filtered (stream
, _(" <incomplete type> end record"));
723 fprintf_filtered (stream
, " null; end record");
727 /* Print the unchecked union type TYPE in something resembling Ada
728 format on STREAM. LEVEL is the recursion (indentation) level
729 in case the element type itself has nested structure, and SHOW is the
730 number of levels of internal structure to show (see ada_print_type). */
732 print_unchecked_union_type (struct type
*type
, struct ui_file
*stream
,
734 const struct type_print_options
*flags
)
737 fprintf_filtered (stream
, "record (?) is ... end record");
738 else if (TYPE_NFIELDS (type
) == 0)
739 fprintf_filtered (stream
, "record (?) is null; end record");
744 fprintf_filtered (stream
, "record (?) is\n%*scase ? is", level
+ 4, "");
746 for (i
= 0; i
< TYPE_NFIELDS (type
); i
+= 1)
748 fprintf_filtered (stream
, "\n%*swhen ? =>\n%*s", level
+ 8, "",
750 ada_print_type (TYPE_FIELD_TYPE (type
, i
),
751 TYPE_FIELD_NAME (type
, i
),
752 stream
, show
- 1, level
+ 12, flags
);
753 fprintf_filtered (stream
, ";");
756 fprintf_filtered (stream
, "\n%*send case;\n%*send record",
757 level
+ 4, "", level
, "");
763 /* Print function or procedure type TYPE on STREAM. Make it a header
764 for function or procedure NAME if NAME is not null. */
767 print_func_type (struct type
*type
, struct ui_file
*stream
, const char *name
,
768 const struct type_print_options
*flags
)
770 int i
, len
= TYPE_NFIELDS (type
);
772 if (TYPE_TARGET_TYPE (type
) != NULL
773 && TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_VOID
)
774 fprintf_filtered (stream
, "procedure");
776 fprintf_filtered (stream
, "function");
778 if (name
!= NULL
&& name
[0] != '\0')
779 fprintf_filtered (stream
, " %s", name
);
783 fprintf_filtered (stream
, " (");
784 for (i
= 0; i
< len
; i
+= 1)
788 fputs_filtered ("; ", stream
);
791 fprintf_filtered (stream
, "a%d: ", i
+ 1);
792 ada_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0,
795 fprintf_filtered (stream
, ")");
798 if (TYPE_TARGET_TYPE (type
) == NULL
)
799 fprintf_filtered (stream
, " return <unknown return type>");
800 else if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_VOID
)
802 fprintf_filtered (stream
, " return ");
803 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, 0, 0, flags
);
808 /* Print a description of a type TYPE0.
809 Output goes to STREAM (via stdio).
810 If VARSTRING is a non-empty string, print as an Ada variable/field
812 SHOW+1 is the maximum number of levels of internal type structure
813 to show (this applies to record types, enumerated types, and
815 SHOW is the number of levels of internal type structure to show
816 when there is a type name for the SHOWth deepest level (0th is
818 When SHOW<0, no inner structure is shown.
819 LEVEL indicates level of recursion (for nested definitions). */
822 ada_print_type (struct type
*type0
, const char *varstring
,
823 struct ui_file
*stream
, int show
, int level
,
824 const struct type_print_options
*flags
)
826 struct type
*type
= ada_check_typedef (ada_get_base_type (type0
));
827 char *type_name
= decoded_type_name (type0
);
828 int is_var_decl
= (varstring
!= NULL
&& varstring
[0] != '\0');
833 fprintf_filtered (stream
, "%.*s: ",
834 ada_name_prefix_len (varstring
), varstring
);
835 fprintf_filtered (stream
, "<null type?>");
840 type
= ada_check_typedef (type
);
842 if (is_var_decl
&& TYPE_CODE (type
) != TYPE_CODE_FUNC
)
843 fprintf_filtered (stream
, "%.*s: ",
844 ada_name_prefix_len (varstring
), varstring
);
846 if (type_name
!= NULL
&& show
<= 0 && !ada_is_aligner_type (type
))
848 fprintf_filtered (stream
, "%.*s",
849 ada_name_prefix_len (type_name
), type_name
);
853 if (ada_is_aligner_type (type
))
854 ada_print_type (ada_aligned_type (type
), "", stream
, show
, level
, flags
);
855 else if (ada_is_constrained_packed_array_type (type
)
856 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
857 print_array_type (type
, stream
, show
, level
, flags
);
859 switch (TYPE_CODE (type
))
862 fprintf_filtered (stream
, "<");
863 c_print_type (type
, "", stream
, show
, level
, flags
);
864 fprintf_filtered (stream
, ">");
867 case TYPE_CODE_TYPEDEF
:
868 fprintf_filtered (stream
, "access ");
869 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, show
, level
,
873 fprintf_filtered (stream
, "<ref> ");
874 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, show
, level
,
877 case TYPE_CODE_ARRAY
:
878 print_array_type (type
, stream
, show
, level
, flags
);
881 fprintf_filtered (stream
, "(false, true)");
884 if (ada_is_fixed_point_type (type
))
885 print_fixed_point_type (type
, stream
);
888 const char *name
= ada_type_name (type
);
890 if (!ada_is_range_type_name (name
))
891 fprintf_filtered (stream
, _("<%d-byte integer>"),
895 fprintf_filtered (stream
, "range ");
896 print_range_type (type
, stream
, 1 /* bounds_prefered_p */);
900 case TYPE_CODE_RANGE
:
901 if (ada_is_fixed_point_type (type
))
902 print_fixed_point_type (type
, stream
);
903 else if (ada_is_modular_type (type
))
904 fprintf_filtered (stream
, "mod %s",
905 int_string (ada_modulus (type
), 10, 0, 0, 1));
908 fprintf_filtered (stream
, "range ");
909 print_range (type
, stream
, 1 /* bounds_prefered_p */);
913 fprintf_filtered (stream
, _("<%d-byte float>"), TYPE_LENGTH (type
));
917 fprintf_filtered (stream
, "(...)");
919 print_enum_type (type
, stream
);
921 case TYPE_CODE_STRUCT
:
922 if (ada_is_array_descriptor_type (type
))
923 print_array_type (type
, stream
, show
, level
, flags
);
924 else if (ada_is_bogus_array_descriptor (type
))
925 fprintf_filtered (stream
,
926 _("array (?) of ? (<mal-formed descriptor>)"));
928 print_record_type (type
, stream
, show
, level
, flags
);
930 case TYPE_CODE_UNION
:
931 print_unchecked_union_type (type
, stream
, show
, level
, flags
);
934 print_func_type (type
, stream
, varstring
, flags
);
939 /* Implement the la_print_typedef language method for Ada. */
942 ada_print_typedef (struct type
*type
, struct symbol
*new_symbol
,
943 struct ui_file
*stream
)
945 type
= ada_check_typedef (type
);
946 ada_print_type (type
, "", stream
, 0, 0, &type_print_raw_options
);
947 fprintf_filtered (stream
, "\n");
This page took 0.049319 seconds and 4 git commands to generate.