1 /* Support for printing Ada types for GDB, the GNU debugger.
2 Copyright (C) 1986-2018 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"
34 #include "target-float.h"
38 static int print_selected_record_field_types (struct type
*, struct type
*,
40 struct ui_file
*, int, int,
41 const struct type_print_options
*);
43 static int print_record_field_types (struct type
*, struct type
*,
44 struct ui_file
*, int, int,
45 const struct type_print_options
*);
49 static char *name_buffer
;
50 static int name_buffer_len
;
52 /* The (decoded) Ada name of TYPE. This value persists until the
56 decoded_type_name (struct type
*type
)
58 if (ada_type_name (type
) == NULL
)
62 const char *raw_name
= ada_type_name (type
);
65 if (name_buffer
== NULL
|| name_buffer_len
<= strlen (raw_name
))
67 name_buffer_len
= 16 + 2 * strlen (raw_name
);
68 name_buffer
= (char *) xrealloc (name_buffer
, name_buffer_len
);
70 strcpy (name_buffer
, raw_name
);
72 s
= (char *) strstr (name_buffer
, "___");
76 s
= name_buffer
+ strlen (name_buffer
) - 1;
77 while (s
> name_buffer
&& (s
[0] != '_' || s
[-1] != '_'))
86 for (s
= q
= name_buffer
; *s
!= '\0'; q
+= 1)
88 if (s
[0] == '_' && s
[1] == '_')
104 /* Return nonzero if TYPE is a subrange type, and its bounds
105 are identical to the bounds of its subtype. */
108 type_is_full_subrange_of_target_type (struct type
*type
)
110 struct type
*subtype
;
112 if (TYPE_CODE (type
) != TYPE_CODE_RANGE
)
115 subtype
= TYPE_TARGET_TYPE (type
);
119 if (is_dynamic_type (type
))
122 if (ada_discrete_type_low_bound (type
)
123 != ada_discrete_type_low_bound (subtype
))
126 if (ada_discrete_type_high_bound (type
)
127 != ada_discrete_type_high_bound (subtype
))
133 /* Print TYPE on STREAM, preferably as a range if BOUNDS_PREFERED_P
137 print_range (struct type
*type
, struct ui_file
*stream
,
138 int bounds_prefered_p
)
140 if (!bounds_prefered_p
)
142 /* Try stripping all TYPE_CODE_RANGE layers whose bounds
143 are identical to the bounds of their subtype. When
144 the bounds of both types match, it can allow us to
145 print a range using the name of its base type, which
146 is easier to read. For instance, we would print...
148 array (character) of ...
152 array ('["00"]' .. '["ff"]') of ... */
153 while (type_is_full_subrange_of_target_type (type
))
154 type
= TYPE_TARGET_TYPE (type
);
157 switch (TYPE_CODE (type
))
159 case TYPE_CODE_RANGE
:
162 LONGEST lo
= 0, hi
= 0; /* init for gcc -Wall */
167 lo
= ada_discrete_type_low_bound (type
);
168 hi
= ada_discrete_type_high_bound (type
);
170 CATCH (e
, RETURN_MASK_ERROR
)
172 /* This can happen when the range is dynamic. Sometimes,
173 resolving dynamic property values requires us to have
174 access to an actual object, which is not available
175 when the user is using the "ptype" command on a type.
176 Print the range as an unbounded range. */
177 fprintf_filtered (stream
, "<>");
184 ada_print_scalar (type
, lo
, stream
);
185 fprintf_filtered (stream
, " .. ");
186 ada_print_scalar (type
, hi
, stream
);
191 fprintf_filtered (stream
, "%.*s",
192 ada_name_prefix_len (TYPE_NAME (type
)),
198 /* Print the number or discriminant bound at BOUNDS+*N on STREAM, and
199 set *N past the bound and its delimiter, if any. */
202 print_range_bound (struct type
*type
, const char *bounds
, int *n
,
203 struct ui_file
*stream
)
207 if (ada_scan_number (bounds
, *n
, &B
, n
))
209 /* STABS decodes all range types which bounds are 0 .. -1 as
210 unsigned integers (ie. the type code is TYPE_CODE_INT, not
211 TYPE_CODE_RANGE). Unfortunately, ada_print_scalar() relies
212 on the unsigned flag to determine whether the bound should
213 be printed as a signed or an unsigned value. This causes
214 the upper bound of the 0 .. -1 range types to be printed as
215 a very large unsigned number instead of -1.
216 To workaround this stabs deficiency, we replace the TYPE by NULL
217 to indicate default output when we detect that the bound is negative,
218 and the type is a TYPE_CODE_INT. The bound is negative when
219 'm' is the last character of the number scanned in BOUNDS. */
220 if (bounds
[*n
- 1] == 'm' && TYPE_CODE (type
) == TYPE_CODE_INT
)
222 ada_print_scalar (type
, B
, stream
);
223 if (bounds
[*n
] == '_')
229 const char *bound
= bounds
+ *n
;
232 pend
= strstr (bound
, "__");
234 *n
+= bound_len
= strlen (bound
);
237 bound_len
= pend
- bound
;
240 fprintf_filtered (stream
, "%.*s", bound_len
, bound
);
244 /* Assuming NAME[0 .. NAME_LEN-1] is the name of a range type, print
245 the value (if found) of the bound indicated by SUFFIX ("___L" or
246 "___U") according to the ___XD conventions. */
249 print_dynamic_range_bound (struct type
*type
, const char *name
, int name_len
,
250 const char *suffix
, struct ui_file
*stream
)
253 std::string
name_buf (name
, name_len
);
256 if (get_int_var_value (name_buf
.c_str (), B
))
257 ada_print_scalar (type
, B
, stream
);
259 fprintf_filtered (stream
, "?");
262 /* Print RAW_TYPE as a range type, using any bound information
263 following the GNAT encoding (if available).
265 If BOUNDS_PREFERED_P is nonzero, force the printing of the range
266 using its bounds. Otherwise, try printing the range without
267 printing the value of the bounds, if possible (this is only
268 considered a hint, not a guaranty). */
271 print_range_type (struct type
*raw_type
, struct ui_file
*stream
,
272 int bounds_prefered_p
)
275 struct type
*base_type
;
276 const char *subtype_info
;
278 gdb_assert (raw_type
!= NULL
);
279 name
= TYPE_NAME (raw_type
);
280 gdb_assert (name
!= NULL
);
282 if (TYPE_CODE (raw_type
) == TYPE_CODE_RANGE
)
283 base_type
= TYPE_TARGET_TYPE (raw_type
);
285 base_type
= raw_type
;
287 subtype_info
= strstr (name
, "___XD");
288 if (subtype_info
== NULL
)
289 print_range (raw_type
, stream
, bounds_prefered_p
);
292 int prefix_len
= subtype_info
- name
;
293 const char *bounds_str
;
297 bounds_str
= strchr (subtype_info
, '_');
300 if (*subtype_info
== 'L')
302 print_range_bound (base_type
, bounds_str
, &n
, stream
);
306 print_dynamic_range_bound (base_type
, name
, prefix_len
, "___L",
309 fprintf_filtered (stream
, " .. ");
311 if (*subtype_info
== 'U')
312 print_range_bound (base_type
, bounds_str
, &n
, stream
);
314 print_dynamic_range_bound (base_type
, name
, prefix_len
, "___U",
319 /* Print enumerated type TYPE on STREAM. */
322 print_enum_type (struct type
*type
, struct ui_file
*stream
)
324 int len
= TYPE_NFIELDS (type
);
328 fprintf_filtered (stream
, "(");
332 for (i
= 0; i
< len
; i
++)
336 fprintf_filtered (stream
, ", ");
338 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type
, i
)), stream
);
339 if (lastval
!= TYPE_FIELD_ENUMVAL (type
, i
))
341 fprintf_filtered (stream
, " => %s",
342 plongest (TYPE_FIELD_ENUMVAL (type
, i
)));
343 lastval
= TYPE_FIELD_ENUMVAL (type
, i
);
347 fprintf_filtered (stream
, ")");
350 /* Print representation of Ada fixed-point type TYPE on STREAM. */
353 print_fixed_point_type (struct type
*type
, struct ui_file
*stream
)
355 struct value
*delta
= ada_delta (type
);
356 struct value
*small
= ada_scaling_factor (type
);
358 if (delta
== nullptr)
359 fprintf_filtered (stream
, "delta ??");
363 str
= target_float_to_string (value_contents (delta
),
364 value_type (delta
), "%g");
365 fprintf_filtered (stream
, "delta %s", str
.c_str());
366 if (!value_equal (delta
, small
))
368 str
= target_float_to_string (value_contents (small
),
369 value_type (small
), "%g");
370 fprintf_filtered (stream
, " <'small = %s>", str
.c_str());
375 /* Print simple (constrained) array type TYPE on STREAM. LEVEL is the
376 recursion (indentation) level, in case the element type itself has
377 nested structure, and SHOW is the number of levels of internal
378 structure to show (see ada_print_type). */
381 print_array_type (struct type
*type
, struct ui_file
*stream
, int show
,
382 int level
, const struct type_print_options
*flags
)
386 struct type
*elt_type
= NULL
;
388 if (ada_is_constrained_packed_array_type (type
))
389 type
= ada_coerce_to_simple_array_type (type
);
392 fprintf_filtered (stream
, "array (");
396 fprintf_filtered (stream
, _("<undecipherable array type>"));
401 if (ada_is_simple_array_type (type
))
403 struct type
*range_desc_type
;
404 struct type
*arr_type
;
406 range_desc_type
= ada_find_parallel_type (type
, "___XA");
407 ada_fixup_array_indexes_type (range_desc_type
);
410 if (range_desc_type
== NULL
)
412 for (arr_type
= type
; TYPE_CODE (arr_type
) == TYPE_CODE_ARRAY
;
413 arr_type
= TYPE_TARGET_TYPE (arr_type
))
415 if (arr_type
!= type
)
416 fprintf_filtered (stream
, ", ");
417 print_range (TYPE_INDEX_TYPE (arr_type
), stream
,
418 0 /* bounds_prefered_p */);
419 if (TYPE_FIELD_BITSIZE (arr_type
, 0) > 0)
420 bitsize
= TYPE_FIELD_BITSIZE (arr_type
, 0);
427 n_indices
= TYPE_NFIELDS (range_desc_type
);
428 for (k
= 0, arr_type
= type
;
430 k
+= 1, arr_type
= TYPE_TARGET_TYPE (arr_type
))
433 fprintf_filtered (stream
, ", ");
434 print_range_type (TYPE_FIELD_TYPE (range_desc_type
, k
),
435 stream
, 0 /* bounds_prefered_p */);
436 if (TYPE_FIELD_BITSIZE (arr_type
, 0) > 0)
437 bitsize
= TYPE_FIELD_BITSIZE (arr_type
, 0);
445 for (i
= i0
= ada_array_arity (type
); i
> 0; i
-= 1)
446 fprintf_filtered (stream
, "%s<>", i
== i0
? "" : ", ");
449 elt_type
= ada_array_element_type (type
, n_indices
);
450 fprintf_filtered (stream
, ") of ");
452 ada_print_type (elt_type
, "", stream
, show
== 0 ? 0 : show
- 1, level
+ 1,
454 /* Arrays with variable-length elements are never bit-packed in practice but
455 compilers have to describe their stride so that we can properly fetch
456 individual elements. Do not say the array is packed in this case. */
457 if (bitsize
> 0 && !is_dynamic_type (elt_type
))
458 fprintf_filtered (stream
, " <packed: %d-bit elements>", bitsize
);
461 /* Print the choices encoded by field FIELD_NUM of variant-part TYPE on
462 STREAM, assuming that VAL_TYPE (if non-NULL) is the type of the
463 values. Return non-zero if the field is an encoding of
464 discriminant values, as in a standard variant record, and 0 if the
465 field is not so encoded (as happens with single-component variants
466 in types annotated with pragma Unchecked_Variant). */
469 print_choices (struct type
*type
, int field_num
, struct ui_file
*stream
,
470 struct type
*val_type
)
474 const char *name
= TYPE_FIELD_NAME (type
, field_num
);
478 /* Skip over leading 'V': NOTE soon to be obsolete. */
481 if (!ada_scan_number (name
, 1, NULL
, &p
))
495 fprintf_filtered (stream
, " =>");
501 fprintf_filtered (stream
, " | ");
512 if (!ada_scan_number (name
, p
+ 1, &W
, &p
))
514 ada_print_scalar (val_type
, W
, stream
);
521 if (!ada_scan_number (name
, p
+ 1, &L
, &p
)
522 || name
[p
] != 'T' || !ada_scan_number (name
, p
+ 1, &U
, &p
))
524 ada_print_scalar (val_type
, L
, stream
);
525 fprintf_filtered (stream
, " .. ");
526 ada_print_scalar (val_type
, U
, stream
);
530 fprintf_filtered (stream
, "others");
537 fprintf_filtered (stream
, "?? =>");
541 /* Assuming that field FIELD_NUM of TYPE represents variants whose
542 discriminant is contained in OUTER_TYPE, print its components on STREAM.
543 LEVEL is the recursion (indentation) level, in case any of the fields
544 themselves have nested structure, and SHOW is the number of levels of
545 internal structure to show (see ada_print_type). For this purpose,
546 fields nested in a variant part are taken to be at the same level as
547 the fields immediately outside the variant part. */
550 print_variant_clauses (struct type
*type
, int field_num
,
551 struct type
*outer_type
, struct ui_file
*stream
,
553 const struct type_print_options
*flags
)
556 struct type
*var_type
, *par_type
;
557 struct type
*discr_type
;
559 var_type
= TYPE_FIELD_TYPE (type
, field_num
);
560 discr_type
= ada_variant_discrim_type (var_type
, outer_type
);
562 if (TYPE_CODE (var_type
) == TYPE_CODE_PTR
)
564 var_type
= TYPE_TARGET_TYPE (var_type
);
565 if (var_type
== NULL
|| TYPE_CODE (var_type
) != TYPE_CODE_UNION
)
569 par_type
= ada_find_parallel_type (var_type
, "___XVU");
570 if (par_type
!= NULL
)
573 for (i
= 0; i
< TYPE_NFIELDS (var_type
); i
+= 1)
575 fprintf_filtered (stream
, "\n%*swhen ", level
+ 4, "");
576 if (print_choices (var_type
, i
, stream
, discr_type
))
578 if (print_record_field_types (TYPE_FIELD_TYPE (var_type
, i
),
579 outer_type
, stream
, show
, level
+ 4,
582 fprintf_filtered (stream
, " null;");
585 print_selected_record_field_types (var_type
, outer_type
, i
, i
,
586 stream
, show
, level
+ 4, flags
);
590 /* Assuming that field FIELD_NUM of TYPE is a variant part whose
591 discriminants are contained in OUTER_TYPE, print a description of it
592 on STREAM. LEVEL is the recursion (indentation) level, in case any of
593 the fields themselves have nested structure, and SHOW is the number of
594 levels of internal structure to show (see ada_print_type). For this
595 purpose, fields nested in a variant part are taken to be at the same
596 level as the fields immediately outside the variant part. */
599 print_variant_part (struct type
*type
, int field_num
, struct type
*outer_type
,
600 struct ui_file
*stream
, int show
, int level
,
601 const struct type_print_options
*flags
)
603 fprintf_filtered (stream
, "\n%*scase %s is", level
+ 4, "",
604 ada_variant_discrim_name
605 (TYPE_FIELD_TYPE (type
, field_num
)));
606 print_variant_clauses (type
, field_num
, outer_type
, stream
, show
,
608 fprintf_filtered (stream
, "\n%*send case;", level
+ 4, "");
611 /* Print a description on STREAM of the fields FLD0 through FLD1 in
612 record or union type TYPE, whose discriminants are in OUTER_TYPE.
613 LEVEL is the recursion (indentation) level, in case any of the
614 fields themselves have nested structure, and SHOW is the number of
615 levels of internal structure to show (see ada_print_type). Does
616 not print parent type information of TYPE. Returns 0 if no fields
617 printed, -1 for an incomplete type, else > 0. Prints each field
618 beginning on a new line, but does not put a new line at end. */
621 print_selected_record_field_types (struct type
*type
, struct type
*outer_type
,
623 struct ui_file
*stream
, int show
, int level
,
624 const struct type_print_options
*flags
)
630 if (fld0
> fld1
&& TYPE_STUB (type
))
633 for (i
= fld0
; i
<= fld1
; i
+= 1)
637 if (ada_is_parent_field (type
, i
) || ada_is_ignored_field (type
, i
))
639 else if (ada_is_wrapper_field (type
, i
))
640 flds
+= print_record_field_types (TYPE_FIELD_TYPE (type
, i
), type
,
641 stream
, show
, level
, flags
);
642 else if (ada_is_variant_part (type
, i
))
644 print_variant_part (type
, i
, outer_type
, stream
, show
, level
, flags
);
650 fprintf_filtered (stream
, "\n%*s", level
+ 4, "");
651 ada_print_type (TYPE_FIELD_TYPE (type
, i
),
652 TYPE_FIELD_NAME (type
, i
),
653 stream
, show
- 1, level
+ 4, flags
);
654 fprintf_filtered (stream
, ";");
661 /* Print a description on STREAM of all fields of record or union type
662 TYPE, as for print_selected_record_field_types, above. */
665 print_record_field_types (struct type
*type
, struct type
*outer_type
,
666 struct ui_file
*stream
, int show
, int level
,
667 const struct type_print_options
*flags
)
669 return print_selected_record_field_types (type
, outer_type
,
670 0, TYPE_NFIELDS (type
) - 1,
671 stream
, show
, level
, flags
);
675 /* Print record type TYPE on STREAM. LEVEL is the recursion (indentation)
676 level, in case the element type itself has nested structure, and SHOW is
677 the number of levels of internal structure to show (see ada_print_type). */
680 print_record_type (struct type
*type0
, struct ui_file
*stream
, int show
,
681 int level
, const struct type_print_options
*flags
)
683 struct type
*parent_type
;
686 type
= ada_find_parallel_type (type0
, "___XVE");
690 parent_type
= ada_parent_type (type
);
691 if (ada_type_name (parent_type
) != NULL
)
693 const char *parent_name
= decoded_type_name (parent_type
);
695 /* If we fail to decode the parent type name, then use the parent
696 type name as is. Not pretty, but should never happen except
697 when the debugging info is incomplete or incorrect. This
698 prevents a crash trying to print a NULL pointer. */
699 if (parent_name
== NULL
)
700 parent_name
= ada_type_name (parent_type
);
701 fprintf_filtered (stream
, "new %s with record", parent_name
);
703 else if (parent_type
== NULL
&& ada_is_tagged_type (type
, 0))
704 fprintf_filtered (stream
, "tagged record");
706 fprintf_filtered (stream
, "record");
709 fprintf_filtered (stream
, " ... end record");
715 if (parent_type
!= NULL
&& ada_type_name (parent_type
) == NULL
)
716 flds
+= print_record_field_types (parent_type
, parent_type
,
717 stream
, show
, level
, flags
);
718 flds
+= print_record_field_types (type
, type
, stream
, show
, level
,
722 fprintf_filtered (stream
, "\n%*send record", level
, "");
724 fprintf_filtered (stream
, _(" <incomplete type> end record"));
726 fprintf_filtered (stream
, " null; end record");
730 /* Print the unchecked union type TYPE in something resembling Ada
731 format on STREAM. LEVEL is the recursion (indentation) level
732 in case the element type itself has nested structure, and SHOW is the
733 number of levels of internal structure to show (see ada_print_type). */
735 print_unchecked_union_type (struct type
*type
, struct ui_file
*stream
,
737 const struct type_print_options
*flags
)
740 fprintf_filtered (stream
, "record (?) is ... end record");
741 else if (TYPE_NFIELDS (type
) == 0)
742 fprintf_filtered (stream
, "record (?) is null; end record");
747 fprintf_filtered (stream
, "record (?) is\n%*scase ? is", level
+ 4, "");
749 for (i
= 0; i
< TYPE_NFIELDS (type
); i
+= 1)
751 fprintf_filtered (stream
, "\n%*swhen ? =>\n%*s", level
+ 8, "",
753 ada_print_type (TYPE_FIELD_TYPE (type
, i
),
754 TYPE_FIELD_NAME (type
, i
),
755 stream
, show
- 1, level
+ 12, flags
);
756 fprintf_filtered (stream
, ";");
759 fprintf_filtered (stream
, "\n%*send case;\n%*send record",
760 level
+ 4, "", level
, "");
766 /* Print function or procedure type TYPE on STREAM. Make it a header
767 for function or procedure NAME if NAME is not null. */
770 print_func_type (struct type
*type
, struct ui_file
*stream
, const char *name
,
771 const struct type_print_options
*flags
)
773 int i
, len
= TYPE_NFIELDS (type
);
775 if (TYPE_TARGET_TYPE (type
) != NULL
776 && TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_VOID
)
777 fprintf_filtered (stream
, "procedure");
779 fprintf_filtered (stream
, "function");
781 if (name
!= NULL
&& name
[0] != '\0')
782 fprintf_filtered (stream
, " %s", name
);
786 fprintf_filtered (stream
, " (");
787 for (i
= 0; i
< len
; i
+= 1)
791 fputs_filtered ("; ", stream
);
794 fprintf_filtered (stream
, "a%d: ", i
+ 1);
795 ada_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0,
798 fprintf_filtered (stream
, ")");
801 if (TYPE_TARGET_TYPE (type
) == NULL
)
802 fprintf_filtered (stream
, " return <unknown return type>");
803 else if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_VOID
)
805 fprintf_filtered (stream
, " return ");
806 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, 0, 0, flags
);
811 /* Print a description of a type TYPE0.
812 Output goes to STREAM (via stdio).
813 If VARSTRING is a non-empty string, print as an Ada variable/field
815 SHOW+1 is the maximum number of levels of internal type structure
816 to show (this applies to record types, enumerated types, and
818 SHOW is the number of levels of internal type structure to show
819 when there is a type name for the SHOWth deepest level (0th is
821 When SHOW<0, no inner structure is shown.
822 LEVEL indicates level of recursion (for nested definitions). */
825 ada_print_type (struct type
*type0
, const char *varstring
,
826 struct ui_file
*stream
, int show
, int level
,
827 const struct type_print_options
*flags
)
829 struct type
*type
= ada_check_typedef (ada_get_base_type (type0
));
830 char *type_name
= decoded_type_name (type0
);
831 int is_var_decl
= (varstring
!= NULL
&& varstring
[0] != '\0');
836 fprintf_filtered (stream
, "%.*s: ",
837 ada_name_prefix_len (varstring
), varstring
);
838 fprintf_filtered (stream
, "<null type?>");
843 type
= ada_check_typedef (type
);
845 if (is_var_decl
&& TYPE_CODE (type
) != TYPE_CODE_FUNC
)
846 fprintf_filtered (stream
, "%.*s: ",
847 ada_name_prefix_len (varstring
), varstring
);
849 if (type_name
!= NULL
&& show
<= 0 && !ada_is_aligner_type (type
))
851 fprintf_filtered (stream
, "%.*s",
852 ada_name_prefix_len (type_name
), type_name
);
856 if (ada_is_aligner_type (type
))
857 ada_print_type (ada_aligned_type (type
), "", stream
, show
, level
, flags
);
858 else if (ada_is_constrained_packed_array_type (type
)
859 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
860 print_array_type (type
, stream
, show
, level
, flags
);
862 switch (TYPE_CODE (type
))
865 fprintf_filtered (stream
, "<");
866 c_print_type (type
, "", stream
, show
, level
, flags
);
867 fprintf_filtered (stream
, ">");
870 case TYPE_CODE_TYPEDEF
:
871 fprintf_filtered (stream
, "access ");
872 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, show
, level
,
876 fprintf_filtered (stream
, "<ref> ");
877 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, show
, level
,
880 case TYPE_CODE_ARRAY
:
881 print_array_type (type
, stream
, show
, level
, flags
);
884 fprintf_filtered (stream
, "(false, true)");
887 if (ada_is_fixed_point_type (type
))
888 print_fixed_point_type (type
, stream
);
891 const char *name
= ada_type_name (type
);
893 if (!ada_is_range_type_name (name
))
894 fprintf_filtered (stream
, _("<%d-byte integer>"),
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_filtered (stream
, _("<%d-byte float>"), TYPE_LENGTH (type
));
920 fprintf_filtered (stream
, "(...)");
922 print_enum_type (type
, stream
);
924 case TYPE_CODE_STRUCT
:
925 if (ada_is_array_descriptor_type (type
))
926 print_array_type (type
, stream
, show
, level
, flags
);
927 else if (ada_is_bogus_array_descriptor (type
))
928 fprintf_filtered (stream
,
929 _("array (?) of ? (<mal-formed descriptor>)"));
931 print_record_type (type
, stream
, show
, level
, flags
);
933 case TYPE_CODE_UNION
:
934 print_unchecked_union_type (type
, stream
, show
, level
, flags
);
937 print_func_type (type
, stream
, varstring
, flags
);
942 /* Implement the la_print_typedef language method for Ada. */
945 ada_print_typedef (struct type
*type
, struct symbol
*new_symbol
,
946 struct ui_file
*stream
)
948 type
= ada_check_typedef (type
);
949 ada_print_type (type
, "", stream
, 0, 0, &type_print_raw_options
);
950 fprintf_filtered (stream
, "\n");
This page took 0.05043 seconds and 4 git commands to generate.