1 /* Support for printing Ada types for GDB, the GNU debugger.
2 Copyright (C) 1986-2016 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
)
256 static char *name_buf
= NULL
;
257 static size_t name_buf_len
= 0;
261 GROW_VECT (name_buf
, name_buf_len
, name_len
+ strlen (suffix
) + 1);
262 strncpy (name_buf
, name
, name_len
);
263 strcpy (name_buf
+ name_len
, suffix
);
265 B
= get_int_var_value (name_buf
, &OK
);
267 ada_print_scalar (type
, B
, stream
);
269 fprintf_filtered (stream
, "?");
272 /* Print RAW_TYPE as a range type, using any bound information
273 following the GNAT encoding (if available).
275 If BOUNDS_PREFERED_P is nonzero, force the printing of the range
276 using its bounds. Otherwise, try printing the range without
277 printing the value of the bounds, if possible (this is only
278 considered a hint, not a guaranty). */
281 print_range_type (struct type
*raw_type
, struct ui_file
*stream
,
282 int bounds_prefered_p
)
285 struct type
*base_type
;
286 const char *subtype_info
;
288 gdb_assert (raw_type
!= NULL
);
289 name
= TYPE_NAME (raw_type
);
290 gdb_assert (name
!= NULL
);
292 if (TYPE_CODE (raw_type
) == TYPE_CODE_RANGE
)
293 base_type
= TYPE_TARGET_TYPE (raw_type
);
295 base_type
= raw_type
;
297 subtype_info
= strstr (name
, "___XD");
298 if (subtype_info
== NULL
)
299 print_range (raw_type
, stream
, bounds_prefered_p
);
302 int prefix_len
= subtype_info
- name
;
303 const char *bounds_str
;
307 bounds_str
= strchr (subtype_info
, '_');
310 if (*subtype_info
== 'L')
312 print_range_bound (base_type
, bounds_str
, &n
, stream
);
316 print_dynamic_range_bound (base_type
, name
, prefix_len
, "___L",
319 fprintf_filtered (stream
, " .. ");
321 if (*subtype_info
== 'U')
322 print_range_bound (base_type
, bounds_str
, &n
, stream
);
324 print_dynamic_range_bound (base_type
, name
, prefix_len
, "___U",
329 /* Print enumerated type TYPE on STREAM. */
332 print_enum_type (struct type
*type
, struct ui_file
*stream
)
334 int len
= TYPE_NFIELDS (type
);
338 fprintf_filtered (stream
, "(");
342 for (i
= 0; i
< len
; i
++)
346 fprintf_filtered (stream
, ", ");
348 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type
, i
)), stream
);
349 if (lastval
!= TYPE_FIELD_ENUMVAL (type
, i
))
351 fprintf_filtered (stream
, " => %s",
352 plongest (TYPE_FIELD_ENUMVAL (type
, i
)));
353 lastval
= TYPE_FIELD_ENUMVAL (type
, i
);
357 fprintf_filtered (stream
, ")");
360 /* Print representation of Ada fixed-point type TYPE on STREAM. */
363 print_fixed_point_type (struct type
*type
, struct ui_file
*stream
)
365 DOUBLEST delta
= ada_delta (type
);
366 DOUBLEST small
= ada_fixed_to_float (type
, 1.0);
369 fprintf_filtered (stream
, "delta ??");
372 fprintf_filtered (stream
, "delta %g", (double) delta
);
374 fprintf_filtered (stream
, " <'small = %g>", (double) small
);
378 /* Print simple (constrained) array type TYPE on STREAM. LEVEL is the
379 recursion (indentation) level, in case the element type itself has
380 nested structure, and SHOW is the number of levels of internal
381 structure to show (see ada_print_type). */
384 print_array_type (struct type
*type
, struct ui_file
*stream
, int show
,
385 int level
, const struct type_print_options
*flags
)
389 struct type
*elt_type
= NULL
;
391 if (ada_is_constrained_packed_array_type (type
))
392 type
= ada_coerce_to_simple_array_type (type
);
395 fprintf_filtered (stream
, "array (");
399 fprintf_filtered (stream
, _("<undecipherable array type>"));
404 if (ada_is_simple_array_type (type
))
406 struct type
*range_desc_type
;
407 struct type
*arr_type
;
409 range_desc_type
= ada_find_parallel_type (type
, "___XA");
410 ada_fixup_array_indexes_type (range_desc_type
);
413 if (range_desc_type
== NULL
)
415 for (arr_type
= type
; TYPE_CODE (arr_type
) == TYPE_CODE_ARRAY
;
416 arr_type
= TYPE_TARGET_TYPE (arr_type
))
418 if (arr_type
!= type
)
419 fprintf_filtered (stream
, ", ");
420 print_range (TYPE_INDEX_TYPE (arr_type
), stream
,
421 0 /* bounds_prefered_p */);
422 if (TYPE_FIELD_BITSIZE (arr_type
, 0) > 0)
423 bitsize
= TYPE_FIELD_BITSIZE (arr_type
, 0);
430 n_indices
= TYPE_NFIELDS (range_desc_type
);
431 for (k
= 0, arr_type
= type
;
433 k
+= 1, arr_type
= TYPE_TARGET_TYPE (arr_type
))
436 fprintf_filtered (stream
, ", ");
437 print_range_type (TYPE_FIELD_TYPE (range_desc_type
, k
),
438 stream
, 0 /* bounds_prefered_p */);
439 if (TYPE_FIELD_BITSIZE (arr_type
, 0) > 0)
440 bitsize
= TYPE_FIELD_BITSIZE (arr_type
, 0);
448 for (i
= i0
= ada_array_arity (type
); i
> 0; i
-= 1)
449 fprintf_filtered (stream
, "%s<>", i
== i0
? "" : ", ");
452 elt_type
= ada_array_element_type (type
, n_indices
);
453 fprintf_filtered (stream
, ") of ");
455 ada_print_type (elt_type
, "", stream
, show
== 0 ? 0 : show
- 1, level
+ 1,
457 /* Arrays with variable-length elements are never bit-packed in practice but
458 compilers have to describe their stride so that we can properly fetch
459 individual elements. Do not say the array is packed in this case. */
460 if (bitsize
> 0 && !is_dynamic_type (elt_type
))
461 fprintf_filtered (stream
, " <packed: %d-bit elements>", bitsize
);
464 /* Print the choices encoded by field FIELD_NUM of variant-part TYPE on
465 STREAM, assuming that VAL_TYPE (if non-NULL) is the type of the
466 values. Return non-zero if the field is an encoding of
467 discriminant values, as in a standard variant record, and 0 if the
468 field is not so encoded (as happens with single-component variants
469 in types annotated with pragma Unchecked_Variant). */
472 print_choices (struct type
*type
, int field_num
, struct ui_file
*stream
,
473 struct type
*val_type
)
477 const char *name
= TYPE_FIELD_NAME (type
, field_num
);
481 /* Skip over leading 'V': NOTE soon to be obsolete. */
484 if (!ada_scan_number (name
, 1, NULL
, &p
))
498 fprintf_filtered (stream
, " =>");
504 fprintf_filtered (stream
, " | ");
515 if (!ada_scan_number (name
, p
+ 1, &W
, &p
))
517 ada_print_scalar (val_type
, W
, stream
);
524 if (!ada_scan_number (name
, p
+ 1, &L
, &p
)
525 || name
[p
] != 'T' || !ada_scan_number (name
, p
+ 1, &U
, &p
))
527 ada_print_scalar (val_type
, L
, stream
);
528 fprintf_filtered (stream
, " .. ");
529 ada_print_scalar (val_type
, U
, stream
);
533 fprintf_filtered (stream
, "others");
540 fprintf_filtered (stream
, "?? =>");
544 /* Assuming that field FIELD_NUM of TYPE represents variants whose
545 discriminant is contained in OUTER_TYPE, print its components on STREAM.
546 LEVEL is the recursion (indentation) level, in case any of the fields
547 themselves have nested structure, and SHOW is the number of levels of
548 internal structure to show (see ada_print_type). For this purpose,
549 fields nested in a variant part are taken to be at the same level as
550 the fields immediately outside the variant part. */
553 print_variant_clauses (struct type
*type
, int field_num
,
554 struct type
*outer_type
, struct ui_file
*stream
,
556 const struct type_print_options
*flags
)
559 struct type
*var_type
, *par_type
;
560 struct type
*discr_type
;
562 var_type
= TYPE_FIELD_TYPE (type
, field_num
);
563 discr_type
= ada_variant_discrim_type (var_type
, outer_type
);
565 if (TYPE_CODE (var_type
) == TYPE_CODE_PTR
)
567 var_type
= TYPE_TARGET_TYPE (var_type
);
568 if (var_type
== NULL
|| TYPE_CODE (var_type
) != TYPE_CODE_UNION
)
572 par_type
= ada_find_parallel_type (var_type
, "___XVU");
573 if (par_type
!= NULL
)
576 for (i
= 0; i
< TYPE_NFIELDS (var_type
); i
+= 1)
578 fprintf_filtered (stream
, "\n%*swhen ", level
+ 4, "");
579 if (print_choices (var_type
, i
, stream
, discr_type
))
581 if (print_record_field_types (TYPE_FIELD_TYPE (var_type
, i
),
582 outer_type
, stream
, show
, level
+ 4,
585 fprintf_filtered (stream
, " null;");
588 print_selected_record_field_types (var_type
, outer_type
, i
, i
,
589 stream
, show
, level
+ 4, flags
);
593 /* Assuming that field FIELD_NUM of TYPE is a variant part whose
594 discriminants are contained in OUTER_TYPE, print a description of it
595 on STREAM. LEVEL is the recursion (indentation) level, in case any of
596 the fields themselves have nested structure, and SHOW is the number of
597 levels of internal structure to show (see ada_print_type). For this
598 purpose, fields nested in a variant part are taken to be at the same
599 level as the fields immediately outside the variant part. */
602 print_variant_part (struct type
*type
, int field_num
, struct type
*outer_type
,
603 struct ui_file
*stream
, int show
, int level
,
604 const struct type_print_options
*flags
)
606 fprintf_filtered (stream
, "\n%*scase %s is", level
+ 4, "",
607 ada_variant_discrim_name
608 (TYPE_FIELD_TYPE (type
, field_num
)));
609 print_variant_clauses (type
, field_num
, outer_type
, stream
, show
,
611 fprintf_filtered (stream
, "\n%*send case;", level
+ 4, "");
614 /* Print a description on STREAM of the fields FLD0 through FLD1 in
615 record or union type TYPE, whose discriminants are in OUTER_TYPE.
616 LEVEL is the recursion (indentation) level, in case any of the
617 fields themselves have nested structure, and SHOW is the number of
618 levels of internal structure to show (see ada_print_type). Does
619 not print parent type information of TYPE. Returns 0 if no fields
620 printed, -1 for an incomplete type, else > 0. Prints each field
621 beginning on a new line, but does not put a new line at end. */
624 print_selected_record_field_types (struct type
*type
, struct type
*outer_type
,
626 struct ui_file
*stream
, int show
, int level
,
627 const struct type_print_options
*flags
)
633 if (fld0
> fld1
&& TYPE_STUB (type
))
636 for (i
= fld0
; i
<= fld1
; i
+= 1)
640 if (ada_is_parent_field (type
, i
) || ada_is_ignored_field (type
, i
))
642 else if (ada_is_wrapper_field (type
, i
))
643 flds
+= print_record_field_types (TYPE_FIELD_TYPE (type
, i
), type
,
644 stream
, show
, level
, flags
);
645 else if (ada_is_variant_part (type
, i
))
647 print_variant_part (type
, i
, outer_type
, stream
, show
, level
, flags
);
653 fprintf_filtered (stream
, "\n%*s", level
+ 4, "");
654 ada_print_type (TYPE_FIELD_TYPE (type
, i
),
655 TYPE_FIELD_NAME (type
, i
),
656 stream
, show
- 1, level
+ 4, flags
);
657 fprintf_filtered (stream
, ";");
664 /* Print a description on STREAM of all fields of record or union type
665 TYPE, as for print_selected_record_field_types, above. */
668 print_record_field_types (struct type
*type
, struct type
*outer_type
,
669 struct ui_file
*stream
, int show
, int level
,
670 const struct type_print_options
*flags
)
672 return print_selected_record_field_types (type
, outer_type
,
673 0, TYPE_NFIELDS (type
) - 1,
674 stream
, show
, level
, flags
);
678 /* Print record type TYPE on STREAM. LEVEL is the recursion (indentation)
679 level, in case the element type itself has nested structure, and SHOW is
680 the number of levels of internal structure to show (see ada_print_type). */
683 print_record_type (struct type
*type0
, struct ui_file
*stream
, int show
,
684 int level
, const struct type_print_options
*flags
)
686 struct type
*parent_type
;
689 type
= ada_find_parallel_type (type0
, "___XVE");
693 parent_type
= ada_parent_type (type
);
694 if (ada_type_name (parent_type
) != NULL
)
696 const char *parent_name
= decoded_type_name (parent_type
);
698 /* If we fail to decode the parent type name, then use the parent
699 type name as is. Not pretty, but should never happen except
700 when the debugging info is incomplete or incorrect. This
701 prevents a crash trying to print a NULL pointer. */
702 if (parent_name
== NULL
)
703 parent_name
= ada_type_name (parent_type
);
704 fprintf_filtered (stream
, "new %s with record", parent_name
);
706 else if (parent_type
== NULL
&& ada_is_tagged_type (type
, 0))
707 fprintf_filtered (stream
, "tagged record");
709 fprintf_filtered (stream
, "record");
712 fprintf_filtered (stream
, " ... end record");
718 if (parent_type
!= NULL
&& ada_type_name (parent_type
) == NULL
)
719 flds
+= print_record_field_types (parent_type
, parent_type
,
720 stream
, show
, level
, flags
);
721 flds
+= print_record_field_types (type
, type
, stream
, show
, level
,
725 fprintf_filtered (stream
, "\n%*send record", level
, "");
727 fprintf_filtered (stream
, _(" <incomplete type> end record"));
729 fprintf_filtered (stream
, " null; end record");
733 /* Print the unchecked union type TYPE in something resembling Ada
734 format on STREAM. LEVEL is the recursion (indentation) level
735 in case the element type itself has nested structure, and SHOW is the
736 number of levels of internal structure to show (see ada_print_type). */
738 print_unchecked_union_type (struct type
*type
, struct ui_file
*stream
,
740 const struct type_print_options
*flags
)
743 fprintf_filtered (stream
, "record (?) is ... end record");
744 else if (TYPE_NFIELDS (type
) == 0)
745 fprintf_filtered (stream
, "record (?) is null; end record");
750 fprintf_filtered (stream
, "record (?) is\n%*scase ? is", level
+ 4, "");
752 for (i
= 0; i
< TYPE_NFIELDS (type
); i
+= 1)
754 fprintf_filtered (stream
, "\n%*swhen ? =>\n%*s", level
+ 8, "",
756 ada_print_type (TYPE_FIELD_TYPE (type
, i
),
757 TYPE_FIELD_NAME (type
, i
),
758 stream
, show
- 1, level
+ 12, flags
);
759 fprintf_filtered (stream
, ";");
762 fprintf_filtered (stream
, "\n%*send case;\n%*send record",
763 level
+ 4, "", level
, "");
769 /* Print function or procedure type TYPE on STREAM. Make it a header
770 for function or procedure NAME if NAME is not null. */
773 print_func_type (struct type
*type
, struct ui_file
*stream
, const char *name
,
774 const struct type_print_options
*flags
)
776 int i
, len
= TYPE_NFIELDS (type
);
778 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_VOID
)
779 fprintf_filtered (stream
, "procedure");
781 fprintf_filtered (stream
, "function");
783 if (name
!= NULL
&& name
[0] != '\0')
784 fprintf_filtered (stream
, " %s", name
);
788 fprintf_filtered (stream
, " (");
789 for (i
= 0; i
< len
; i
+= 1)
793 fputs_filtered ("; ", stream
);
796 fprintf_filtered (stream
, "a%d: ", i
+ 1);
797 ada_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0,
800 fprintf_filtered (stream
, ")");
803 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.050225 seconds and 4 git commands to generate.