1 /* Support for printing Ada types for GDB, the GNU debugger.
2 Copyright (C) 1986-2020 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 "bfd.h" /* Binary File Description */
24 #include "cli/cli-style.h"
25 #include "typeprint.h"
26 #include "target-float.h"
30 static int print_selected_record_field_types (struct type
*, struct type
*,
32 struct ui_file
*, int, int,
33 const struct type_print_options
*);
35 static int print_record_field_types (struct type
*, struct type
*,
36 struct ui_file
*, int, int,
37 const struct type_print_options
*);
41 static char *name_buffer
;
42 static int name_buffer_len
;
44 /* The (decoded) Ada name of TYPE. This value persists until the
48 decoded_type_name (struct type
*type
)
50 if (ada_type_name (type
) == NULL
)
54 const char *raw_name
= ada_type_name (type
);
57 if (name_buffer
== NULL
|| name_buffer_len
<= strlen (raw_name
))
59 name_buffer_len
= 16 + 2 * strlen (raw_name
);
60 name_buffer
= (char *) xrealloc (name_buffer
, name_buffer_len
);
62 strcpy (name_buffer
, raw_name
);
64 s
= (char *) strstr (name_buffer
, "___");
68 s
= name_buffer
+ strlen (name_buffer
) - 1;
69 while (s
> name_buffer
&& (s
[0] != '_' || s
[-1] != '_'))
78 for (s
= q
= name_buffer
; *s
!= '\0'; q
+= 1)
80 if (s
[0] == '_' && s
[1] == '_')
96 /* Return nonzero if TYPE is a subrange type, and its bounds
97 are identical to the bounds of its subtype. */
100 type_is_full_subrange_of_target_type (struct type
*type
)
102 struct type
*subtype
;
104 if (TYPE_CODE (type
) != TYPE_CODE_RANGE
)
107 subtype
= TYPE_TARGET_TYPE (type
);
111 if (is_dynamic_type (type
))
114 if (ada_discrete_type_low_bound (type
)
115 != ada_discrete_type_low_bound (subtype
))
118 if (ada_discrete_type_high_bound (type
)
119 != ada_discrete_type_high_bound (subtype
))
125 /* Print TYPE on STREAM, preferably as a range if BOUNDS_PREFERED_P
129 print_range (struct type
*type
, struct ui_file
*stream
,
130 int bounds_prefered_p
)
132 if (!bounds_prefered_p
)
134 /* Try stripping all TYPE_CODE_RANGE layers whose bounds
135 are identical to the bounds of their subtype. When
136 the bounds of both types match, it can allow us to
137 print a range using the name of its base type, which
138 is easier to read. For instance, we would print...
140 array (character) of ...
144 array ('["00"]' .. '["ff"]') of ... */
145 while (type_is_full_subrange_of_target_type (type
))
146 type
= TYPE_TARGET_TYPE (type
);
149 switch (TYPE_CODE (type
))
151 case TYPE_CODE_RANGE
:
154 LONGEST lo
= 0, hi
= 0; /* init for gcc -Wall */
159 lo
= ada_discrete_type_low_bound (type
);
160 hi
= ada_discrete_type_high_bound (type
);
162 catch (const gdb_exception_error
&e
)
164 /* This can happen when the range is dynamic. Sometimes,
165 resolving dynamic property values requires us to have
166 access to an actual object, which is not available
167 when the user is using the "ptype" command on a type.
168 Print the range as an unbounded range. */
169 fprintf_filtered (stream
, "<>");
175 ada_print_scalar (type
, lo
, stream
);
176 fprintf_filtered (stream
, " .. ");
177 ada_print_scalar (type
, hi
, stream
);
182 fprintf_filtered (stream
, "%.*s",
183 ada_name_prefix_len (TYPE_NAME (type
)),
189 /* Print the number or discriminant bound at BOUNDS+*N on STREAM, and
190 set *N past the bound and its delimiter, if any. */
193 print_range_bound (struct type
*type
, const char *bounds
, int *n
,
194 struct ui_file
*stream
)
198 if (ada_scan_number (bounds
, *n
, &B
, n
))
200 /* STABS decodes all range types which bounds are 0 .. -1 as
201 unsigned integers (ie. the type code is TYPE_CODE_INT, not
202 TYPE_CODE_RANGE). Unfortunately, ada_print_scalar() relies
203 on the unsigned flag to determine whether the bound should
204 be printed as a signed or an unsigned value. This causes
205 the upper bound of the 0 .. -1 range types to be printed as
206 a very large unsigned number instead of -1.
207 To workaround this stabs deficiency, we replace the TYPE by NULL
208 to indicate default output when we detect that the bound is negative,
209 and the type is a TYPE_CODE_INT. The bound is negative when
210 'm' is the last character of the number scanned in BOUNDS. */
211 if (bounds
[*n
- 1] == 'm' && TYPE_CODE (type
) == TYPE_CODE_INT
)
213 ada_print_scalar (type
, B
, stream
);
214 if (bounds
[*n
] == '_')
220 const char *bound
= bounds
+ *n
;
223 pend
= strstr (bound
, "__");
225 *n
+= bound_len
= strlen (bound
);
228 bound_len
= pend
- bound
;
231 fprintf_filtered (stream
, "%.*s", bound_len
, bound
);
235 /* Assuming NAME[0 .. NAME_LEN-1] is the name of a range type, print
236 the value (if found) of the bound indicated by SUFFIX ("___L" or
237 "___U") according to the ___XD conventions. */
240 print_dynamic_range_bound (struct type
*type
, const char *name
, int name_len
,
241 const char *suffix
, struct ui_file
*stream
)
244 std::string
name_buf (name
, name_len
);
247 if (get_int_var_value (name_buf
.c_str (), B
))
248 ada_print_scalar (type
, B
, stream
);
250 fprintf_filtered (stream
, "?");
253 /* Print RAW_TYPE as a range type, using any bound information
254 following the GNAT encoding (if available).
256 If BOUNDS_PREFERED_P is nonzero, force the printing of the range
257 using its bounds. Otherwise, try printing the range without
258 printing the value of the bounds, if possible (this is only
259 considered a hint, not a guaranty). */
262 print_range_type (struct type
*raw_type
, struct ui_file
*stream
,
263 int bounds_prefered_p
)
266 struct type
*base_type
;
267 const char *subtype_info
;
269 gdb_assert (raw_type
!= NULL
);
270 name
= TYPE_NAME (raw_type
);
271 gdb_assert (name
!= NULL
);
273 if (TYPE_CODE (raw_type
) == TYPE_CODE_RANGE
)
274 base_type
= TYPE_TARGET_TYPE (raw_type
);
276 base_type
= raw_type
;
278 subtype_info
= strstr (name
, "___XD");
279 if (subtype_info
== NULL
)
280 print_range (raw_type
, stream
, bounds_prefered_p
);
283 int prefix_len
= subtype_info
- name
;
284 const char *bounds_str
;
288 bounds_str
= strchr (subtype_info
, '_');
291 if (*subtype_info
== 'L')
293 print_range_bound (base_type
, bounds_str
, &n
, stream
);
297 print_dynamic_range_bound (base_type
, name
, prefix_len
, "___L",
300 fprintf_filtered (stream
, " .. ");
302 if (*subtype_info
== 'U')
303 print_range_bound (base_type
, bounds_str
, &n
, stream
);
305 print_dynamic_range_bound (base_type
, name
, prefix_len
, "___U",
310 /* Print enumerated type TYPE on STREAM. */
313 print_enum_type (struct type
*type
, struct ui_file
*stream
)
315 int len
= TYPE_NFIELDS (type
);
319 fprintf_filtered (stream
, "(");
323 for (i
= 0; i
< len
; i
++)
327 fprintf_filtered (stream
, ", ");
329 fputs_styled (ada_enum_name (TYPE_FIELD_NAME (type
, i
)),
330 variable_name_style
.style (), stream
);
331 if (lastval
!= TYPE_FIELD_ENUMVAL (type
, i
))
333 fprintf_filtered (stream
, " => %s",
334 plongest (TYPE_FIELD_ENUMVAL (type
, i
)));
335 lastval
= TYPE_FIELD_ENUMVAL (type
, i
);
339 fprintf_filtered (stream
, ")");
342 /* Print representation of Ada fixed-point type TYPE on STREAM. */
345 print_fixed_point_type (struct type
*type
, struct ui_file
*stream
)
347 struct value
*delta
= ada_delta (type
);
348 struct value
*small
= ada_scaling_factor (type
);
350 if (delta
== nullptr)
351 fprintf_filtered (stream
, "delta ??");
355 str
= target_float_to_string (value_contents (delta
),
356 value_type (delta
), "%g");
357 fprintf_filtered (stream
, "delta %s", str
.c_str());
358 if (!value_equal (delta
, small
))
360 str
= target_float_to_string (value_contents (small
),
361 value_type (small
), "%g");
362 fprintf_filtered (stream
, " <'small = %s>", str
.c_str());
367 /* Print simple (constrained) array type TYPE on STREAM. LEVEL is the
368 recursion (indentation) level, in case the element type itself has
369 nested structure, and SHOW is the number of levels of internal
370 structure to show (see ada_print_type). */
373 print_array_type (struct type
*type
, struct ui_file
*stream
, int show
,
374 int level
, const struct type_print_options
*flags
)
378 struct type
*elt_type
= NULL
;
380 if (ada_is_constrained_packed_array_type (type
))
381 type
= ada_coerce_to_simple_array_type (type
);
384 fprintf_filtered (stream
, "array (");
388 fprintf_styled (stream
, metadata_style
.style (),
389 _("<undecipherable array type>"));
394 if (ada_is_simple_array_type (type
))
396 struct type
*range_desc_type
;
397 struct type
*arr_type
;
399 range_desc_type
= ada_find_parallel_type (type
, "___XA");
400 ada_fixup_array_indexes_type (range_desc_type
);
403 if (range_desc_type
== NULL
)
405 for (arr_type
= type
; TYPE_CODE (arr_type
) == TYPE_CODE_ARRAY
;
406 arr_type
= TYPE_TARGET_TYPE (arr_type
))
408 if (arr_type
!= type
)
409 fprintf_filtered (stream
, ", ");
410 print_range (TYPE_INDEX_TYPE (arr_type
), stream
,
411 0 /* bounds_prefered_p */);
412 if (TYPE_FIELD_BITSIZE (arr_type
, 0) > 0)
413 bitsize
= TYPE_FIELD_BITSIZE (arr_type
, 0);
420 n_indices
= TYPE_NFIELDS (range_desc_type
);
421 for (k
= 0, arr_type
= type
;
423 k
+= 1, arr_type
= TYPE_TARGET_TYPE (arr_type
))
426 fprintf_filtered (stream
, ", ");
427 print_range_type (TYPE_FIELD_TYPE (range_desc_type
, k
),
428 stream
, 0 /* bounds_prefered_p */);
429 if (TYPE_FIELD_BITSIZE (arr_type
, 0) > 0)
430 bitsize
= TYPE_FIELD_BITSIZE (arr_type
, 0);
438 for (i
= i0
= ada_array_arity (type
); i
> 0; i
-= 1)
439 fprintf_filtered (stream
, "%s<>", i
== i0
? "" : ", ");
442 elt_type
= ada_array_element_type (type
, n_indices
);
443 fprintf_filtered (stream
, ") of ");
445 ada_print_type (elt_type
, "", stream
, show
== 0 ? 0 : show
- 1, level
+ 1,
447 /* Arrays with variable-length elements are never bit-packed in practice but
448 compilers have to describe their stride so that we can properly fetch
449 individual elements. Do not say the array is packed in this case. */
450 if (bitsize
> 0 && !is_dynamic_type (elt_type
))
451 fprintf_filtered (stream
, " <packed: %d-bit elements>", bitsize
);
454 /* Print the choices encoded by field FIELD_NUM of variant-part TYPE on
455 STREAM, assuming that VAL_TYPE (if non-NULL) is the type of the
456 values. Return non-zero if the field is an encoding of
457 discriminant values, as in a standard variant record, and 0 if the
458 field is not so encoded (as happens with single-component variants
459 in types annotated with pragma Unchecked_Union). */
462 print_choices (struct type
*type
, int field_num
, struct ui_file
*stream
,
463 struct type
*val_type
)
467 const char *name
= TYPE_FIELD_NAME (type
, field_num
);
471 /* Skip over leading 'V': NOTE soon to be obsolete. */
474 if (!ada_scan_number (name
, 1, NULL
, &p
))
488 fprintf_filtered (stream
, " =>");
494 fprintf_filtered (stream
, " | ");
505 if (!ada_scan_number (name
, p
+ 1, &W
, &p
))
507 ada_print_scalar (val_type
, W
, stream
);
514 if (!ada_scan_number (name
, p
+ 1, &L
, &p
)
515 || name
[p
] != 'T' || !ada_scan_number (name
, p
+ 1, &U
, &p
))
517 ada_print_scalar (val_type
, L
, stream
);
518 fprintf_filtered (stream
, " .. ");
519 ada_print_scalar (val_type
, U
, stream
);
523 fprintf_filtered (stream
, "others");
530 fprintf_filtered (stream
, "? =>");
534 /* Assuming that field FIELD_NUM of TYPE represents variants whose
535 discriminant is contained in OUTER_TYPE, print its components on STREAM.
536 LEVEL is the recursion (indentation) level, in case any of the fields
537 themselves have nested structure, and SHOW is the number of levels of
538 internal structure to show (see ada_print_type). For this purpose,
539 fields nested in a variant part are taken to be at the same level as
540 the fields immediately outside the variant part. */
543 print_variant_clauses (struct type
*type
, int field_num
,
544 struct type
*outer_type
, struct ui_file
*stream
,
546 const struct type_print_options
*flags
)
549 struct type
*var_type
, *par_type
;
550 struct type
*discr_type
;
552 var_type
= TYPE_FIELD_TYPE (type
, field_num
);
553 discr_type
= ada_variant_discrim_type (var_type
, outer_type
);
555 if (TYPE_CODE (var_type
) == TYPE_CODE_PTR
)
557 var_type
= TYPE_TARGET_TYPE (var_type
);
558 if (var_type
== NULL
|| TYPE_CODE (var_type
) != TYPE_CODE_UNION
)
562 par_type
= ada_find_parallel_type (var_type
, "___XVU");
563 if (par_type
!= NULL
)
566 for (i
= 0; i
< TYPE_NFIELDS (var_type
); i
+= 1)
568 fprintf_filtered (stream
, "\n%*swhen ", level
+ 4, "");
569 if (print_choices (var_type
, i
, stream
, discr_type
))
571 if (print_record_field_types (TYPE_FIELD_TYPE (var_type
, i
),
572 outer_type
, stream
, show
, level
+ 4,
575 fprintf_filtered (stream
, " null;");
578 print_selected_record_field_types (var_type
, outer_type
, i
, i
,
579 stream
, show
, level
+ 4, flags
);
583 /* Assuming that field FIELD_NUM of TYPE is a variant part whose
584 discriminants are contained in OUTER_TYPE, print a description of it
585 on STREAM. LEVEL is the recursion (indentation) level, in case any of
586 the fields themselves have nested structure, and SHOW is the number of
587 levels of internal structure to show (see ada_print_type). For this
588 purpose, fields nested in a variant part are taken to be at the same
589 level as the fields immediately outside the variant part. */
592 print_variant_part (struct type
*type
, int field_num
, struct type
*outer_type
,
593 struct ui_file
*stream
, int show
, int level
,
594 const struct type_print_options
*flags
)
597 = ada_variant_discrim_name (TYPE_FIELD_TYPE (type
, field_num
));
598 if (*variant
== '\0')
601 fprintf_filtered (stream
, "\n%*scase %s is", level
+ 4, "", variant
);
602 print_variant_clauses (type
, field_num
, outer_type
, stream
, show
,
604 fprintf_filtered (stream
, "\n%*send case;", level
+ 4, "");
607 /* Print a description on STREAM of the fields FLD0 through FLD1 in
608 record or union type TYPE, whose discriminants are in OUTER_TYPE.
609 LEVEL is the recursion (indentation) level, in case any of the
610 fields themselves have nested structure, and SHOW is the number of
611 levels of internal structure to show (see ada_print_type). Does
612 not print parent type information of TYPE. Returns 0 if no fields
613 printed, -1 for an incomplete type, else > 0. Prints each field
614 beginning on a new line, but does not put a new line at end. */
617 print_selected_record_field_types (struct type
*type
, struct type
*outer_type
,
619 struct ui_file
*stream
, int show
, int level
,
620 const struct type_print_options
*flags
)
626 if (fld0
> fld1
&& TYPE_STUB (type
))
629 for (i
= fld0
; i
<= fld1
; i
+= 1)
633 if (ada_is_parent_field (type
, i
) || ada_is_ignored_field (type
, i
))
635 else if (ada_is_wrapper_field (type
, i
))
636 flds
+= print_record_field_types (TYPE_FIELD_TYPE (type
, i
), type
,
637 stream
, show
, level
, flags
);
638 else if (ada_is_variant_part (type
, i
))
640 print_variant_part (type
, i
, outer_type
, stream
, show
, level
, flags
);
646 fprintf_filtered (stream
, "\n%*s", level
+ 4, "");
647 ada_print_type (TYPE_FIELD_TYPE (type
, i
),
648 TYPE_FIELD_NAME (type
, i
),
649 stream
, show
- 1, level
+ 4, flags
);
650 fprintf_filtered (stream
, ";");
657 /* Print a description on STREAM of all fields of record or union type
658 TYPE, as for print_selected_record_field_types, above. */
661 print_record_field_types (struct type
*type
, struct type
*outer_type
,
662 struct ui_file
*stream
, int show
, int level
,
663 const struct type_print_options
*flags
)
665 return print_selected_record_field_types (type
, outer_type
,
666 0, TYPE_NFIELDS (type
) - 1,
667 stream
, show
, level
, flags
);
671 /* Print record type TYPE on STREAM. LEVEL is the recursion (indentation)
672 level, in case the element type itself has nested structure, and SHOW is
673 the number of levels of internal structure to show (see ada_print_type). */
676 print_record_type (struct type
*type0
, struct ui_file
*stream
, int show
,
677 int level
, const struct type_print_options
*flags
)
679 struct type
*parent_type
;
682 type
= ada_find_parallel_type (type0
, "___XVE");
686 parent_type
= ada_parent_type (type
);
687 if (ada_type_name (parent_type
) != NULL
)
689 const char *parent_name
= decoded_type_name (parent_type
);
691 /* If we fail to decode the parent type name, then use the parent
692 type name as is. Not pretty, but should never happen except
693 when the debugging info is incomplete or incorrect. This
694 prevents a crash trying to print a NULL pointer. */
695 if (parent_name
== NULL
)
696 parent_name
= ada_type_name (parent_type
);
697 fprintf_filtered (stream
, "new %s with record", parent_name
);
699 else if (parent_type
== NULL
&& ada_is_tagged_type (type
, 0))
700 fprintf_filtered (stream
, "tagged record");
702 fprintf_filtered (stream
, "record");
705 fprintf_filtered (stream
, " ... end record");
711 if (parent_type
!= NULL
&& ada_type_name (parent_type
) == NULL
)
712 flds
+= print_record_field_types (parent_type
, parent_type
,
713 stream
, show
, level
, flags
);
714 flds
+= print_record_field_types (type
, type
, stream
, show
, level
,
718 fprintf_filtered (stream
, "\n%*send record", level
, "");
720 fprintf_filtered (stream
, _(" <incomplete type> end record"));
722 fprintf_filtered (stream
, " null; end record");
726 /* Print the unchecked union type TYPE in something resembling Ada
727 format on STREAM. LEVEL is the recursion (indentation) level
728 in case the element type itself has nested structure, and SHOW is the
729 number of levels of internal structure to show (see ada_print_type). */
731 print_unchecked_union_type (struct type
*type
, struct ui_file
*stream
,
733 const struct type_print_options
*flags
)
736 fprintf_filtered (stream
, "record (?) is ... end record");
737 else if (TYPE_NFIELDS (type
) == 0)
738 fprintf_filtered (stream
, "record (?) is null; end record");
743 fprintf_filtered (stream
, "record (?) is\n%*scase ? is", level
+ 4, "");
745 for (i
= 0; i
< TYPE_NFIELDS (type
); i
+= 1)
747 fprintf_filtered (stream
, "\n%*swhen ? =>\n%*s", level
+ 8, "",
749 ada_print_type (TYPE_FIELD_TYPE (type
, i
),
750 TYPE_FIELD_NAME (type
, i
),
751 stream
, show
- 1, level
+ 12, flags
);
752 fprintf_filtered (stream
, ";");
755 fprintf_filtered (stream
, "\n%*send case;\n%*send record",
756 level
+ 4, "", level
, "");
762 /* Print function or procedure type TYPE on STREAM. Make it a header
763 for function or procedure NAME if NAME is not null. */
766 print_func_type (struct type
*type
, struct ui_file
*stream
, const char *name
,
767 const struct type_print_options
*flags
)
769 int i
, len
= TYPE_NFIELDS (type
);
771 if (TYPE_TARGET_TYPE (type
) != NULL
772 && TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_VOID
)
773 fprintf_filtered (stream
, "procedure");
775 fprintf_filtered (stream
, "function");
777 if (name
!= NULL
&& name
[0] != '\0')
779 fputs_filtered (" ", stream
);
780 fputs_styled (name
, function_name_style
.style (), stream
);
785 fprintf_filtered (stream
, " (");
786 for (i
= 0; i
< len
; i
+= 1)
790 fputs_filtered ("; ", stream
);
793 fprintf_filtered (stream
, "a%d: ", i
+ 1);
794 ada_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0,
797 fprintf_filtered (stream
, ")");
800 if (TYPE_TARGET_TYPE (type
) == NULL
)
801 fprintf_filtered (stream
, " return <unknown return type>");
802 else if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_VOID
)
804 fprintf_filtered (stream
, " return ");
805 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, 0, 0, flags
);
810 /* Print a description of a type TYPE0.
811 Output goes to STREAM (via stdio).
812 If VARSTRING is a non-empty string, print as an Ada variable/field
814 SHOW+1 is the maximum number of levels of internal type structure
815 to show (this applies to record types, enumerated types, and
817 SHOW is the number of levels of internal type structure to show
818 when there is a type name for the SHOWth deepest level (0th is
820 When SHOW<0, no inner structure is shown.
821 LEVEL indicates level of recursion (for nested definitions). */
824 ada_print_type (struct type
*type0
, const char *varstring
,
825 struct ui_file
*stream
, int show
, int level
,
826 const struct type_print_options
*flags
)
828 struct type
*type
= ada_check_typedef (ada_get_base_type (type0
));
829 char *type_name
= decoded_type_name (type0
);
830 int is_var_decl
= (varstring
!= NULL
&& varstring
[0] != '\0');
835 fprintf_filtered (stream
, "%.*s: ",
836 ada_name_prefix_len (varstring
), varstring
);
837 fprintf_styled (stream
, metadata_style
.style (), "<null type?>");
842 type
= ada_check_typedef (type
);
844 if (is_var_decl
&& TYPE_CODE (type
) != TYPE_CODE_FUNC
)
845 fprintf_filtered (stream
, "%.*s: ",
846 ada_name_prefix_len (varstring
), varstring
);
848 if (type_name
!= NULL
&& show
<= 0 && !ada_is_aligner_type (type
))
850 fprintf_filtered (stream
, "%.*s",
851 ada_name_prefix_len (type_name
), type_name
);
855 if (ada_is_aligner_type (type
))
856 ada_print_type (ada_aligned_type (type
), "", stream
, show
, level
, flags
);
857 else if (ada_is_constrained_packed_array_type (type
)
858 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
859 print_array_type (type
, stream
, show
, level
, flags
);
861 switch (TYPE_CODE (type
))
864 fprintf_filtered (stream
, "<");
865 c_print_type (type
, "", stream
, show
, level
, flags
);
866 fprintf_filtered (stream
, ">");
869 case TYPE_CODE_TYPEDEF
:
870 fprintf_filtered (stream
, "access ");
871 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, show
, level
,
875 fprintf_filtered (stream
, "<ref> ");
876 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, show
, level
,
879 case TYPE_CODE_ARRAY
:
880 print_array_type (type
, stream
, show
, level
, flags
);
883 fprintf_filtered (stream
, "(false, true)");
886 if (ada_is_fixed_point_type (type
))
887 print_fixed_point_type (type
, stream
);
890 const char *name
= ada_type_name (type
);
892 if (!ada_is_range_type_name (name
))
893 fprintf_styled (stream
, metadata_style
.style (),
894 _("<%s-byte integer>"),
895 pulongest (TYPE_LENGTH (type
)));
898 fprintf_filtered (stream
, "range ");
899 print_range_type (type
, stream
, 1 /* bounds_prefered_p */);
903 case TYPE_CODE_RANGE
:
904 if (ada_is_fixed_point_type (type
))
905 print_fixed_point_type (type
, stream
);
906 else if (ada_is_modular_type (type
))
907 fprintf_filtered (stream
, "mod %s",
908 int_string (ada_modulus (type
), 10, 0, 0, 1));
911 fprintf_filtered (stream
, "range ");
912 print_range (type
, stream
, 1 /* bounds_prefered_p */);
916 fprintf_styled (stream
, metadata_style
.style (),
917 _("<%s-byte float>"),
918 pulongest (TYPE_LENGTH (type
)));
922 fprintf_filtered (stream
, "(...)");
924 print_enum_type (type
, stream
);
926 case TYPE_CODE_STRUCT
:
927 if (ada_is_array_descriptor_type (type
))
928 print_array_type (type
, stream
, show
, level
, flags
);
929 else if (ada_is_bogus_array_descriptor (type
))
930 fprintf_filtered (stream
,
931 _("array (?) of ? (<mal-formed descriptor>)"));
933 print_record_type (type
, stream
, show
, level
, flags
);
935 case TYPE_CODE_UNION
:
936 print_unchecked_union_type (type
, stream
, show
, level
, flags
);
939 print_func_type (type
, stream
, varstring
, flags
);
944 /* Implement the la_print_typedef language method for Ada. */
947 ada_print_typedef (struct type
*type
, struct symbol
*new_symbol
,
948 struct ui_file
*stream
)
950 type
= ada_check_typedef (type
);
951 ada_print_type (type
, "", stream
, 0, 0, &type_print_raw_options
);
This page took 0.050851 seconds and 4 git commands to generate.