1 /* Support for printing Ada types for GDB, the GNU debugger.
2 Copyright (C) 1986-2015 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
= 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
, 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 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
;
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
)
390 if (ada_is_constrained_packed_array_type (type
))
391 type
= ada_coerce_to_simple_array_type (type
);
394 fprintf_filtered (stream
, "array (");
398 fprintf_filtered (stream
, _("<undecipherable array type>"));
403 if (ada_is_simple_array_type (type
))
405 struct type
*range_desc_type
;
406 struct type
*arr_type
;
408 range_desc_type
= ada_find_parallel_type (type
, "___XA");
409 ada_fixup_array_indexes_type (range_desc_type
);
412 if (range_desc_type
== NULL
)
414 for (arr_type
= type
; TYPE_CODE (arr_type
) == TYPE_CODE_ARRAY
;
415 arr_type
= TYPE_TARGET_TYPE (arr_type
))
417 if (arr_type
!= type
)
418 fprintf_filtered (stream
, ", ");
419 print_range (TYPE_INDEX_TYPE (arr_type
), stream
,
420 0 /* bounds_prefered_p */);
421 if (TYPE_FIELD_BITSIZE (arr_type
, 0) > 0)
422 bitsize
= TYPE_FIELD_BITSIZE (arr_type
, 0);
429 n_indices
= TYPE_NFIELDS (range_desc_type
);
430 for (k
= 0, arr_type
= type
;
432 k
+= 1, arr_type
= TYPE_TARGET_TYPE (arr_type
))
435 fprintf_filtered (stream
, ", ");
436 print_range_type (TYPE_FIELD_TYPE (range_desc_type
, k
),
437 stream
, 0 /* bounds_prefered_p */);
438 if (TYPE_FIELD_BITSIZE (arr_type
, 0) > 0)
439 bitsize
= TYPE_FIELD_BITSIZE (arr_type
, 0);
447 for (i
= i0
= ada_array_arity (type
); i
> 0; i
-= 1)
448 fprintf_filtered (stream
, "%s<>", i
== i0
? "" : ", ");
451 fprintf_filtered (stream
, ") of ");
453 ada_print_type (ada_array_element_type (type
, n_indices
), "", stream
,
454 show
== 0 ? 0 : show
- 1, level
+ 1, flags
);
456 fprintf_filtered (stream
, " <packed: %d-bit elements>", bitsize
);
459 /* Print the choices encoded by field FIELD_NUM of variant-part TYPE on
460 STREAM, assuming that VAL_TYPE (if non-NULL) is the type of the
461 values. Return non-zero if the field is an encoding of
462 discriminant values, as in a standard variant record, and 0 if the
463 field is not so encoded (as happens with single-component variants
464 in types annotated with pragma Unchecked_Variant). */
467 print_choices (struct type
*type
, int field_num
, struct ui_file
*stream
,
468 struct type
*val_type
)
472 const char *name
= TYPE_FIELD_NAME (type
, field_num
);
476 /* Skip over leading 'V': NOTE soon to be obsolete. */
479 if (!ada_scan_number (name
, 1, NULL
, &p
))
493 fprintf_filtered (stream
, " =>");
499 fprintf_filtered (stream
, " | ");
510 if (!ada_scan_number (name
, p
+ 1, &W
, &p
))
512 ada_print_scalar (val_type
, W
, stream
);
519 if (!ada_scan_number (name
, p
+ 1, &L
, &p
)
520 || name
[p
] != 'T' || !ada_scan_number (name
, p
+ 1, &U
, &p
))
522 ada_print_scalar (val_type
, L
, stream
);
523 fprintf_filtered (stream
, " .. ");
524 ada_print_scalar (val_type
, U
, stream
);
528 fprintf_filtered (stream
, "others");
535 fprintf_filtered (stream
, "?? =>");
539 /* Assuming that field FIELD_NUM of TYPE represents variants whose
540 discriminant is contained in OUTER_TYPE, print its components on STREAM.
541 LEVEL is the recursion (indentation) level, in case any of the fields
542 themselves have nested structure, and SHOW is the number of levels of
543 internal structure to show (see ada_print_type). For this purpose,
544 fields nested in a variant part are taken to be at the same level as
545 the fields immediately outside the variant part. */
548 print_variant_clauses (struct type
*type
, int field_num
,
549 struct type
*outer_type
, struct ui_file
*stream
,
551 const struct type_print_options
*flags
)
554 struct type
*var_type
, *par_type
;
555 struct type
*discr_type
;
557 var_type
= TYPE_FIELD_TYPE (type
, field_num
);
558 discr_type
= ada_variant_discrim_type (var_type
, outer_type
);
560 if (TYPE_CODE (var_type
) == TYPE_CODE_PTR
)
562 var_type
= TYPE_TARGET_TYPE (var_type
);
563 if (var_type
== NULL
|| TYPE_CODE (var_type
) != TYPE_CODE_UNION
)
567 par_type
= ada_find_parallel_type (var_type
, "___XVU");
568 if (par_type
!= NULL
)
571 for (i
= 0; i
< TYPE_NFIELDS (var_type
); i
+= 1)
573 fprintf_filtered (stream
, "\n%*swhen ", level
+ 4, "");
574 if (print_choices (var_type
, i
, stream
, discr_type
))
576 if (print_record_field_types (TYPE_FIELD_TYPE (var_type
, i
),
577 outer_type
, stream
, show
, level
+ 4,
580 fprintf_filtered (stream
, " null;");
583 print_selected_record_field_types (var_type
, outer_type
, i
, i
,
584 stream
, show
, level
+ 4, flags
);
588 /* Assuming that field FIELD_NUM of TYPE is a variant part whose
589 discriminants are contained in OUTER_TYPE, print a description of it
590 on STREAM. LEVEL is the recursion (indentation) level, in case any of
591 the fields themselves have nested structure, and SHOW is the number of
592 levels of internal structure to show (see ada_print_type). For this
593 purpose, fields nested in a variant part are taken to be at the same
594 level as the fields immediately outside the variant part. */
597 print_variant_part (struct type
*type
, int field_num
, struct type
*outer_type
,
598 struct ui_file
*stream
, int show
, int level
,
599 const struct type_print_options
*flags
)
601 fprintf_filtered (stream
, "\n%*scase %s is", level
+ 4, "",
602 ada_variant_discrim_name
603 (TYPE_FIELD_TYPE (type
, field_num
)));
604 print_variant_clauses (type
, field_num
, outer_type
, stream
, show
,
606 fprintf_filtered (stream
, "\n%*send case;", level
+ 4, "");
609 /* Print a description on STREAM of the fields FLD0 through FLD1 in
610 record or union type TYPE, whose discriminants are in OUTER_TYPE.
611 LEVEL is the recursion (indentation) level, in case any of the
612 fields themselves have nested structure, and SHOW is the number of
613 levels of internal structure to show (see ada_print_type). Does
614 not print parent type information of TYPE. Returns 0 if no fields
615 printed, -1 for an incomplete type, else > 0. Prints each field
616 beginning on a new line, but does not put a new line at end. */
619 print_selected_record_field_types (struct type
*type
, struct type
*outer_type
,
621 struct ui_file
*stream
, int show
, int level
,
622 const struct type_print_options
*flags
)
628 if (fld0
> fld1
&& TYPE_STUB (type
))
631 for (i
= fld0
; i
<= fld1
; i
+= 1)
635 if (ada_is_parent_field (type
, i
) || ada_is_ignored_field (type
, i
))
637 else if (ada_is_wrapper_field (type
, i
))
638 flds
+= print_record_field_types (TYPE_FIELD_TYPE (type
, i
), type
,
639 stream
, show
, level
, flags
);
640 else if (ada_is_variant_part (type
, i
))
642 print_variant_part (type
, i
, outer_type
, stream
, show
, level
, flags
);
648 fprintf_filtered (stream
, "\n%*s", level
+ 4, "");
649 ada_print_type (TYPE_FIELD_TYPE (type
, i
),
650 TYPE_FIELD_NAME (type
, i
),
651 stream
, show
- 1, level
+ 4, flags
);
652 fprintf_filtered (stream
, ";");
659 /* Print a description on STREAM of all fields of record or union type
660 TYPE, as for print_selected_record_field_types, above. */
663 print_record_field_types (struct type
*type
, struct type
*outer_type
,
664 struct ui_file
*stream
, int show
, int level
,
665 const struct type_print_options
*flags
)
667 return print_selected_record_field_types (type
, outer_type
,
668 0, TYPE_NFIELDS (type
) - 1,
669 stream
, show
, level
, flags
);
673 /* Print record type TYPE on STREAM. LEVEL is the recursion (indentation)
674 level, in case the element type itself has nested structure, and SHOW is
675 the number of levels of internal structure to show (see ada_print_type). */
678 print_record_type (struct type
*type0
, struct ui_file
*stream
, int show
,
679 int level
, const struct type_print_options
*flags
)
681 struct type
*parent_type
;
684 type
= ada_find_parallel_type (type0
, "___XVE");
688 parent_type
= ada_parent_type (type
);
689 if (ada_type_name (parent_type
) != NULL
)
691 const char *parent_name
= decoded_type_name (parent_type
);
693 /* If we fail to decode the parent type name, then use the parent
694 type name as is. Not pretty, but should never happen except
695 when the debugging info is incomplete or incorrect. This
696 prevents a crash trying to print a NULL pointer. */
697 if (parent_name
== NULL
)
698 parent_name
= ada_type_name (parent_type
);
699 fprintf_filtered (stream
, "new %s with record", parent_name
);
701 else if (parent_type
== NULL
&& ada_is_tagged_type (type
, 0))
702 fprintf_filtered (stream
, "tagged record");
704 fprintf_filtered (stream
, "record");
707 fprintf_filtered (stream
, " ... end record");
713 if (parent_type
!= NULL
&& ada_type_name (parent_type
) == NULL
)
714 flds
+= print_record_field_types (parent_type
, parent_type
,
715 stream
, show
, level
, flags
);
716 flds
+= print_record_field_types (type
, type
, stream
, show
, level
,
720 fprintf_filtered (stream
, "\n%*send record", level
, "");
722 fprintf_filtered (stream
, _(" <incomplete type> end record"));
724 fprintf_filtered (stream
, " null; end record");
728 /* Print the unchecked union type TYPE in something resembling Ada
729 format on STREAM. LEVEL is the recursion (indentation) level
730 in case the element type itself has nested structure, and SHOW is the
731 number of levels of internal structure to show (see ada_print_type). */
733 print_unchecked_union_type (struct type
*type
, struct ui_file
*stream
,
735 const struct type_print_options
*flags
)
738 fprintf_filtered (stream
, "record (?) is ... end record");
739 else if (TYPE_NFIELDS (type
) == 0)
740 fprintf_filtered (stream
, "record (?) is null; end record");
745 fprintf_filtered (stream
, "record (?) is\n%*scase ? is", level
+ 4, "");
747 for (i
= 0; i
< TYPE_NFIELDS (type
); i
+= 1)
749 fprintf_filtered (stream
, "\n%*swhen ? =>\n%*s", level
+ 8, "",
751 ada_print_type (TYPE_FIELD_TYPE (type
, i
),
752 TYPE_FIELD_NAME (type
, i
),
753 stream
, show
- 1, level
+ 12, flags
);
754 fprintf_filtered (stream
, ";");
757 fprintf_filtered (stream
, "\n%*send case;\n%*send record",
758 level
+ 4, "", level
, "");
764 /* Print function or procedure type TYPE on STREAM. Make it a header
765 for function or procedure NAME if NAME is not null. */
768 print_func_type (struct type
*type
, struct ui_file
*stream
, const char *name
,
769 const struct type_print_options
*flags
)
771 int i
, len
= TYPE_NFIELDS (type
);
773 if (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_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_VOID
)
800 fprintf_filtered (stream
, " return ");
801 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, 0, 0, flags
);
806 /* Print a description of a type TYPE0.
807 Output goes to STREAM (via stdio).
808 If VARSTRING is a non-empty string, print as an Ada variable/field
810 SHOW+1 is the maximum number of levels of internal type structure
811 to show (this applies to record types, enumerated types, and
813 SHOW is the number of levels of internal type structure to show
814 when there is a type name for the SHOWth deepest level (0th is
816 When SHOW<0, no inner structure is shown.
817 LEVEL indicates level of recursion (for nested definitions). */
820 ada_print_type (struct type
*type0
, const char *varstring
,
821 struct ui_file
*stream
, int show
, int level
,
822 const struct type_print_options
*flags
)
824 struct type
*type
= ada_check_typedef (ada_get_base_type (type0
));
825 char *type_name
= decoded_type_name (type0
);
826 int is_var_decl
= (varstring
!= NULL
&& varstring
[0] != '\0');
831 fprintf_filtered (stream
, "%.*s: ",
832 ada_name_prefix_len (varstring
), varstring
);
833 fprintf_filtered (stream
, "<null type?>");
838 type
= ada_check_typedef (type
);
840 if (is_var_decl
&& TYPE_CODE (type
) != TYPE_CODE_FUNC
)
841 fprintf_filtered (stream
, "%.*s: ",
842 ada_name_prefix_len (varstring
), varstring
);
844 if (type_name
!= NULL
&& show
<= 0 && !ada_is_aligner_type (type
))
846 fprintf_filtered (stream
, "%.*s",
847 ada_name_prefix_len (type_name
), type_name
);
851 if (ada_is_aligner_type (type
))
852 ada_print_type (ada_aligned_type (type
), "", stream
, show
, level
, flags
);
853 else if (ada_is_constrained_packed_array_type (type
)
854 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
855 print_array_type (type
, stream
, show
, level
, flags
);
857 switch (TYPE_CODE (type
))
860 fprintf_filtered (stream
, "<");
861 c_print_type (type
, "", stream
, show
, level
, flags
);
862 fprintf_filtered (stream
, ">");
865 case TYPE_CODE_TYPEDEF
:
866 fprintf_filtered (stream
, "access ");
867 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, show
, level
,
871 fprintf_filtered (stream
, "<ref> ");
872 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, show
, level
,
875 case TYPE_CODE_ARRAY
:
876 print_array_type (type
, stream
, show
, level
, flags
);
879 fprintf_filtered (stream
, "(false, true)");
882 if (ada_is_fixed_point_type (type
))
883 print_fixed_point_type (type
, stream
);
886 const char *name
= ada_type_name (type
);
888 if (!ada_is_range_type_name (name
))
889 fprintf_filtered (stream
, _("<%d-byte integer>"),
893 fprintf_filtered (stream
, "range ");
894 print_range_type (type
, stream
, 1 /* bounds_prefered_p */);
898 case TYPE_CODE_RANGE
:
899 if (ada_is_fixed_point_type (type
))
900 print_fixed_point_type (type
, stream
);
901 else if (ada_is_modular_type (type
))
902 fprintf_filtered (stream
, "mod %s",
903 int_string (ada_modulus (type
), 10, 0, 0, 1));
906 fprintf_filtered (stream
, "range ");
907 print_range (type
, stream
, 1 /* bounds_prefered_p */);
911 fprintf_filtered (stream
, _("<%d-byte float>"), TYPE_LENGTH (type
));
915 fprintf_filtered (stream
, "(...)");
917 print_enum_type (type
, stream
);
919 case TYPE_CODE_STRUCT
:
920 if (ada_is_array_descriptor_type (type
))
921 print_array_type (type
, stream
, show
, level
, flags
);
922 else if (ada_is_bogus_array_descriptor (type
))
923 fprintf_filtered (stream
,
924 _("array (?) of ? (<mal-formed descriptor>)"));
926 print_record_type (type
, stream
, show
, level
, flags
);
928 case TYPE_CODE_UNION
:
929 print_unchecked_union_type (type
, stream
, show
, level
, flags
);
932 print_func_type (type
, stream
, varstring
, flags
);
937 /* Implement the la_print_typedef language method for Ada. */
940 ada_print_typedef (struct type
*type
, struct symbol
*new_symbol
,
941 struct ui_file
*stream
)
943 type
= ada_check_typedef (type
);
944 ada_print_type (type
, "", stream
, 0, 0, &type_print_raw_options
);
945 fprintf_filtered (stream
, "\n");
This page took 0.054001 seconds and 4 git commands to generate.