1 /* Support for printing Ada types for GDB, the GNU debugger.
2 Copyright (C) 1986-2017 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 #include "gdb_obstack.h"
21 #include "bfd.h" /* Binary File Description */
24 #include "expression.h"
33 #include "typeprint.h"
37 static int print_selected_record_field_types (struct type
*, struct type
*,
39 struct ui_file
*, int, int,
40 const struct type_print_options
*);
42 static int print_record_field_types (struct type
*, struct type
*,
43 struct ui_file
*, int, int,
44 const struct type_print_options
*);
48 static char *name_buffer
;
49 static int name_buffer_len
;
51 /* The (decoded) Ada name of TYPE. This value persists until the
55 decoded_type_name (struct type
*type
)
57 if (ada_type_name (type
) == NULL
)
61 const char *raw_name
= ada_type_name (type
);
64 if (name_buffer
== NULL
|| name_buffer_len
<= strlen (raw_name
))
66 name_buffer_len
= 16 + 2 * strlen (raw_name
);
67 name_buffer
= (char *) xrealloc (name_buffer
, name_buffer_len
);
69 strcpy (name_buffer
, raw_name
);
71 s
= (char *) strstr (name_buffer
, "___");
75 s
= name_buffer
+ strlen (name_buffer
) - 1;
76 while (s
> name_buffer
&& (s
[0] != '_' || s
[-1] != '_'))
85 for (s
= q
= name_buffer
; *s
!= '\0'; q
+= 1)
87 if (s
[0] == '_' && s
[1] == '_')
103 /* Return nonzero if TYPE is a subrange type, and its bounds
104 are identical to the bounds of its subtype. */
107 type_is_full_subrange_of_target_type (struct type
*type
)
109 struct type
*subtype
;
111 if (TYPE_CODE (type
) != TYPE_CODE_RANGE
)
114 subtype
= TYPE_TARGET_TYPE (type
);
118 if (is_dynamic_type (type
))
121 if (ada_discrete_type_low_bound (type
)
122 != ada_discrete_type_low_bound (subtype
))
125 if (ada_discrete_type_high_bound (type
)
126 != ada_discrete_type_high_bound (subtype
))
132 /* Print TYPE on STREAM, preferably as a range if BOUNDS_PREFERED_P
136 print_range (struct type
*type
, struct ui_file
*stream
,
137 int bounds_prefered_p
)
139 if (!bounds_prefered_p
)
141 /* Try stripping all TYPE_CODE_RANGE layers whose bounds
142 are identical to the bounds of their subtype. When
143 the bounds of both types match, it can allow us to
144 print a range using the name of its base type, which
145 is easier to read. For instance, we would print...
147 array (character) of ...
151 array ('["00"]' .. '["ff"]') of ... */
152 while (type_is_full_subrange_of_target_type (type
))
153 type
= TYPE_TARGET_TYPE (type
);
156 switch (TYPE_CODE (type
))
158 case TYPE_CODE_RANGE
:
161 struct type
*target_type
;
162 LONGEST lo
= 0, hi
= 0; /* init for gcc -Wall */
165 target_type
= TYPE_TARGET_TYPE (type
);
166 if (target_type
== NULL
)
171 lo
= ada_discrete_type_low_bound (type
);
172 hi
= ada_discrete_type_high_bound (type
);
174 CATCH (e
, RETURN_MASK_ERROR
)
176 /* This can happen when the range is dynamic. Sometimes,
177 resolving dynamic property values requires us to have
178 access to an actual object, which is not available
179 when the user is using the "ptype" command on a type.
180 Print the range as an unbounded range. */
181 fprintf_filtered (stream
, "<>");
188 ada_print_scalar (target_type
, lo
, stream
);
189 fprintf_filtered (stream
, " .. ");
190 ada_print_scalar (target_type
, hi
, stream
);
195 fprintf_filtered (stream
, "%.*s",
196 ada_name_prefix_len (TYPE_NAME (type
)),
202 /* Print the number or discriminant bound at BOUNDS+*N on STREAM, and
203 set *N past the bound and its delimiter, if any. */
206 print_range_bound (struct type
*type
, const char *bounds
, int *n
,
207 struct ui_file
*stream
)
211 if (ada_scan_number (bounds
, *n
, &B
, n
))
213 /* STABS decodes all range types which bounds are 0 .. -1 as
214 unsigned integers (ie. the type code is TYPE_CODE_INT, not
215 TYPE_CODE_RANGE). Unfortunately, ada_print_scalar() relies
216 on the unsigned flag to determine whether the bound should
217 be printed as a signed or an unsigned value. This causes
218 the upper bound of the 0 .. -1 range types to be printed as
219 a very large unsigned number instead of -1.
220 To workaround this stabs deficiency, we replace the TYPE by NULL
221 to indicate default output when we detect that the bound is negative,
222 and the type is a TYPE_CODE_INT. The bound is negative when
223 'm' is the last character of the number scanned in BOUNDS. */
224 if (bounds
[*n
- 1] == 'm' && TYPE_CODE (type
) == TYPE_CODE_INT
)
226 ada_print_scalar (type
, B
, stream
);
227 if (bounds
[*n
] == '_')
233 const char *bound
= bounds
+ *n
;
236 pend
= strstr (bound
, "__");
238 *n
+= bound_len
= strlen (bound
);
241 bound_len
= pend
- bound
;
244 fprintf_filtered (stream
, "%.*s", bound_len
, bound
);
248 /* Assuming NAME[0 .. NAME_LEN-1] is the name of a range type, print
249 the value (if found) of the bound indicated by SUFFIX ("___L" or
250 "___U") according to the ___XD conventions. */
253 print_dynamic_range_bound (struct type
*type
, const char *name
, int name_len
,
254 const char *suffix
, struct ui_file
*stream
)
256 static char *name_buf
= NULL
;
257 static size_t name_buf_len
= 0;
260 GROW_VECT (name_buf
, name_buf_len
, name_len
+ strlen (suffix
) + 1);
261 strncpy (name_buf
, name
, name_len
);
262 strcpy (name_buf
+ name_len
, suffix
);
264 if (get_int_var_value (name_buf
, B
))
265 ada_print_scalar (type
, B
, stream
);
267 fprintf_filtered (stream
, "?");
270 /* Print RAW_TYPE as a range type, using any bound information
271 following the GNAT encoding (if available).
273 If BOUNDS_PREFERED_P is nonzero, force the printing of the range
274 using its bounds. Otherwise, try printing the range without
275 printing the value of the bounds, if possible (this is only
276 considered a hint, not a guaranty). */
279 print_range_type (struct type
*raw_type
, struct ui_file
*stream
,
280 int bounds_prefered_p
)
283 struct type
*base_type
;
284 const char *subtype_info
;
286 gdb_assert (raw_type
!= NULL
);
287 name
= TYPE_NAME (raw_type
);
288 gdb_assert (name
!= NULL
);
290 if (TYPE_CODE (raw_type
) == TYPE_CODE_RANGE
)
291 base_type
= TYPE_TARGET_TYPE (raw_type
);
293 base_type
= raw_type
;
295 subtype_info
= strstr (name
, "___XD");
296 if (subtype_info
== NULL
)
297 print_range (raw_type
, stream
, bounds_prefered_p
);
300 int prefix_len
= subtype_info
- name
;
301 const char *bounds_str
;
305 bounds_str
= strchr (subtype_info
, '_');
308 if (*subtype_info
== 'L')
310 print_range_bound (base_type
, bounds_str
, &n
, stream
);
314 print_dynamic_range_bound (base_type
, name
, prefix_len
, "___L",
317 fprintf_filtered (stream
, " .. ");
319 if (*subtype_info
== 'U')
320 print_range_bound (base_type
, bounds_str
, &n
, stream
);
322 print_dynamic_range_bound (base_type
, name
, prefix_len
, "___U",
327 /* Print enumerated type TYPE on STREAM. */
330 print_enum_type (struct type
*type
, struct ui_file
*stream
)
332 int len
= TYPE_NFIELDS (type
);
336 fprintf_filtered (stream
, "(");
340 for (i
= 0; i
< len
; i
++)
344 fprintf_filtered (stream
, ", ");
346 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type
, i
)), stream
);
347 if (lastval
!= TYPE_FIELD_ENUMVAL (type
, i
))
349 fprintf_filtered (stream
, " => %s",
350 plongest (TYPE_FIELD_ENUMVAL (type
, i
)));
351 lastval
= TYPE_FIELD_ENUMVAL (type
, i
);
355 fprintf_filtered (stream
, ")");
358 /* Print representation of Ada fixed-point type TYPE on STREAM. */
361 print_fixed_point_type (struct type
*type
, struct ui_file
*stream
)
363 DOUBLEST delta
= ada_delta (type
);
364 DOUBLEST small
= ada_fixed_to_float (type
, 1);
367 fprintf_filtered (stream
, "delta ??");
370 fprintf_filtered (stream
, "delta %g", (double) delta
);
372 fprintf_filtered (stream
, " <'small = %g>", (double) small
);
376 /* Print simple (constrained) array type TYPE on STREAM. LEVEL is the
377 recursion (indentation) level, in case the element type itself has
378 nested structure, and SHOW is the number of levels of internal
379 structure to show (see ada_print_type). */
382 print_array_type (struct type
*type
, struct ui_file
*stream
, int show
,
383 int level
, const struct type_print_options
*flags
)
387 struct type
*elt_type
= NULL
;
389 if (ada_is_constrained_packed_array_type (type
))
390 type
= ada_coerce_to_simple_array_type (type
);
393 fprintf_filtered (stream
, "array (");
397 fprintf_filtered (stream
, _("<undecipherable array type>"));
402 if (ada_is_simple_array_type (type
))
404 struct type
*range_desc_type
;
405 struct type
*arr_type
;
407 range_desc_type
= ada_find_parallel_type (type
, "___XA");
408 ada_fixup_array_indexes_type (range_desc_type
);
411 if (range_desc_type
== NULL
)
413 for (arr_type
= type
; TYPE_CODE (arr_type
) == TYPE_CODE_ARRAY
;
414 arr_type
= TYPE_TARGET_TYPE (arr_type
))
416 if (arr_type
!= type
)
417 fprintf_filtered (stream
, ", ");
418 print_range (TYPE_INDEX_TYPE (arr_type
), stream
,
419 0 /* bounds_prefered_p */);
420 if (TYPE_FIELD_BITSIZE (arr_type
, 0) > 0)
421 bitsize
= TYPE_FIELD_BITSIZE (arr_type
, 0);
428 n_indices
= TYPE_NFIELDS (range_desc_type
);
429 for (k
= 0, arr_type
= type
;
431 k
+= 1, arr_type
= TYPE_TARGET_TYPE (arr_type
))
434 fprintf_filtered (stream
, ", ");
435 print_range_type (TYPE_FIELD_TYPE (range_desc_type
, k
),
436 stream
, 0 /* bounds_prefered_p */);
437 if (TYPE_FIELD_BITSIZE (arr_type
, 0) > 0)
438 bitsize
= TYPE_FIELD_BITSIZE (arr_type
, 0);
446 for (i
= i0
= ada_array_arity (type
); i
> 0; i
-= 1)
447 fprintf_filtered (stream
, "%s<>", i
== i0
? "" : ", ");
450 elt_type
= ada_array_element_type (type
, n_indices
);
451 fprintf_filtered (stream
, ") of ");
453 ada_print_type (elt_type
, "", stream
, show
== 0 ? 0 : show
- 1, level
+ 1,
455 /* Arrays with variable-length elements are never bit-packed in practice but
456 compilers have to describe their stride so that we can properly fetch
457 individual elements. Do not say the array is packed in this case. */
458 if (bitsize
> 0 && !is_dynamic_type (elt_type
))
459 fprintf_filtered (stream
, " <packed: %d-bit elements>", bitsize
);
462 /* Print the choices encoded by field FIELD_NUM of variant-part TYPE on
463 STREAM, assuming that VAL_TYPE (if non-NULL) is the type of the
464 values. Return non-zero if the field is an encoding of
465 discriminant values, as in a standard variant record, and 0 if the
466 field is not so encoded (as happens with single-component variants
467 in types annotated with pragma Unchecked_Variant). */
470 print_choices (struct type
*type
, int field_num
, struct ui_file
*stream
,
471 struct type
*val_type
)
475 const char *name
= TYPE_FIELD_NAME (type
, field_num
);
479 /* Skip over leading 'V': NOTE soon to be obsolete. */
482 if (!ada_scan_number (name
, 1, NULL
, &p
))
496 fprintf_filtered (stream
, " =>");
502 fprintf_filtered (stream
, " | ");
513 if (!ada_scan_number (name
, p
+ 1, &W
, &p
))
515 ada_print_scalar (val_type
, W
, stream
);
522 if (!ada_scan_number (name
, p
+ 1, &L
, &p
)
523 || name
[p
] != 'T' || !ada_scan_number (name
, p
+ 1, &U
, &p
))
525 ada_print_scalar (val_type
, L
, stream
);
526 fprintf_filtered (stream
, " .. ");
527 ada_print_scalar (val_type
, U
, stream
);
531 fprintf_filtered (stream
, "others");
538 fprintf_filtered (stream
, "?? =>");
542 /* Assuming that field FIELD_NUM of TYPE represents variants whose
543 discriminant is contained in OUTER_TYPE, print its components on STREAM.
544 LEVEL is the recursion (indentation) level, in case any of the fields
545 themselves have nested structure, and SHOW is the number of levels of
546 internal structure to show (see ada_print_type). For this purpose,
547 fields nested in a variant part are taken to be at the same level as
548 the fields immediately outside the variant part. */
551 print_variant_clauses (struct type
*type
, int field_num
,
552 struct type
*outer_type
, struct ui_file
*stream
,
554 const struct type_print_options
*flags
)
557 struct type
*var_type
, *par_type
;
558 struct type
*discr_type
;
560 var_type
= TYPE_FIELD_TYPE (type
, field_num
);
561 discr_type
= ada_variant_discrim_type (var_type
, outer_type
);
563 if (TYPE_CODE (var_type
) == TYPE_CODE_PTR
)
565 var_type
= TYPE_TARGET_TYPE (var_type
);
566 if (var_type
== NULL
|| TYPE_CODE (var_type
) != TYPE_CODE_UNION
)
570 par_type
= ada_find_parallel_type (var_type
, "___XVU");
571 if (par_type
!= NULL
)
574 for (i
= 0; i
< TYPE_NFIELDS (var_type
); i
+= 1)
576 fprintf_filtered (stream
, "\n%*swhen ", level
+ 4, "");
577 if (print_choices (var_type
, i
, stream
, discr_type
))
579 if (print_record_field_types (TYPE_FIELD_TYPE (var_type
, i
),
580 outer_type
, stream
, show
, level
+ 4,
583 fprintf_filtered (stream
, " null;");
586 print_selected_record_field_types (var_type
, outer_type
, i
, i
,
587 stream
, show
, level
+ 4, flags
);
591 /* Assuming that field FIELD_NUM of TYPE is a variant part whose
592 discriminants are contained in OUTER_TYPE, print a description of it
593 on STREAM. LEVEL is the recursion (indentation) level, in case any of
594 the fields themselves have nested structure, and SHOW is the number of
595 levels of internal structure to show (see ada_print_type). For this
596 purpose, fields nested in a variant part are taken to be at the same
597 level as the fields immediately outside the variant part. */
600 print_variant_part (struct type
*type
, int field_num
, struct type
*outer_type
,
601 struct ui_file
*stream
, int show
, int level
,
602 const struct type_print_options
*flags
)
604 fprintf_filtered (stream
, "\n%*scase %s is", level
+ 4, "",
605 ada_variant_discrim_name
606 (TYPE_FIELD_TYPE (type
, field_num
)));
607 print_variant_clauses (type
, field_num
, outer_type
, stream
, show
,
609 fprintf_filtered (stream
, "\n%*send case;", level
+ 4, "");
612 /* Print a description on STREAM of the fields FLD0 through FLD1 in
613 record or union type TYPE, whose discriminants are in OUTER_TYPE.
614 LEVEL is the recursion (indentation) level, in case any of the
615 fields themselves have nested structure, and SHOW is the number of
616 levels of internal structure to show (see ada_print_type). Does
617 not print parent type information of TYPE. Returns 0 if no fields
618 printed, -1 for an incomplete type, else > 0. Prints each field
619 beginning on a new line, but does not put a new line at end. */
622 print_selected_record_field_types (struct type
*type
, struct type
*outer_type
,
624 struct ui_file
*stream
, int show
, int level
,
625 const struct type_print_options
*flags
)
631 if (fld0
> fld1
&& TYPE_STUB (type
))
634 for (i
= fld0
; i
<= fld1
; i
+= 1)
638 if (ada_is_parent_field (type
, i
) || ada_is_ignored_field (type
, i
))
640 else if (ada_is_wrapper_field (type
, i
))
641 flds
+= print_record_field_types (TYPE_FIELD_TYPE (type
, i
), type
,
642 stream
, show
, level
, flags
);
643 else if (ada_is_variant_part (type
, i
))
645 print_variant_part (type
, i
, outer_type
, stream
, show
, level
, flags
);
651 fprintf_filtered (stream
, "\n%*s", level
+ 4, "");
652 ada_print_type (TYPE_FIELD_TYPE (type
, i
),
653 TYPE_FIELD_NAME (type
, i
),
654 stream
, show
- 1, level
+ 4, flags
);
655 fprintf_filtered (stream
, ";");
662 /* Print a description on STREAM of all fields of record or union type
663 TYPE, as for print_selected_record_field_types, above. */
666 print_record_field_types (struct type
*type
, struct type
*outer_type
,
667 struct ui_file
*stream
, int show
, int level
,
668 const struct type_print_options
*flags
)
670 return print_selected_record_field_types (type
, outer_type
,
671 0, TYPE_NFIELDS (type
) - 1,
672 stream
, show
, level
, flags
);
676 /* Print record type TYPE on STREAM. LEVEL is the recursion (indentation)
677 level, in case the element type itself has nested structure, and SHOW is
678 the number of levels of internal structure to show (see ada_print_type). */
681 print_record_type (struct type
*type0
, struct ui_file
*stream
, int show
,
682 int level
, const struct type_print_options
*flags
)
684 struct type
*parent_type
;
687 type
= ada_find_parallel_type (type0
, "___XVE");
691 parent_type
= ada_parent_type (type
);
692 if (ada_type_name (parent_type
) != NULL
)
694 const char *parent_name
= decoded_type_name (parent_type
);
696 /* If we fail to decode the parent type name, then use the parent
697 type name as is. Not pretty, but should never happen except
698 when the debugging info is incomplete or incorrect. This
699 prevents a crash trying to print a NULL pointer. */
700 if (parent_name
== NULL
)
701 parent_name
= ada_type_name (parent_type
);
702 fprintf_filtered (stream
, "new %s with record", parent_name
);
704 else if (parent_type
== NULL
&& ada_is_tagged_type (type
, 0))
705 fprintf_filtered (stream
, "tagged record");
707 fprintf_filtered (stream
, "record");
710 fprintf_filtered (stream
, " ... end record");
716 if (parent_type
!= NULL
&& ada_type_name (parent_type
) == NULL
)
717 flds
+= print_record_field_types (parent_type
, parent_type
,
718 stream
, show
, level
, flags
);
719 flds
+= print_record_field_types (type
, type
, stream
, show
, level
,
723 fprintf_filtered (stream
, "\n%*send record", level
, "");
725 fprintf_filtered (stream
, _(" <incomplete type> end record"));
727 fprintf_filtered (stream
, " null; end record");
731 /* Print the unchecked union type TYPE in something resembling Ada
732 format on STREAM. LEVEL is the recursion (indentation) level
733 in case the element type itself has nested structure, and SHOW is the
734 number of levels of internal structure to show (see ada_print_type). */
736 print_unchecked_union_type (struct type
*type
, struct ui_file
*stream
,
738 const struct type_print_options
*flags
)
741 fprintf_filtered (stream
, "record (?) is ... end record");
742 else if (TYPE_NFIELDS (type
) == 0)
743 fprintf_filtered (stream
, "record (?) is null; end record");
748 fprintf_filtered (stream
, "record (?) is\n%*scase ? is", level
+ 4, "");
750 for (i
= 0; i
< TYPE_NFIELDS (type
); i
+= 1)
752 fprintf_filtered (stream
, "\n%*swhen ? =>\n%*s", level
+ 8, "",
754 ada_print_type (TYPE_FIELD_TYPE (type
, i
),
755 TYPE_FIELD_NAME (type
, i
),
756 stream
, show
- 1, level
+ 12, flags
);
757 fprintf_filtered (stream
, ";");
760 fprintf_filtered (stream
, "\n%*send case;\n%*send record",
761 level
+ 4, "", level
, "");
767 /* Print function or procedure type TYPE on STREAM. Make it a header
768 for function or procedure NAME if NAME is not null. */
771 print_func_type (struct type
*type
, struct ui_file
*stream
, const char *name
,
772 const struct type_print_options
*flags
)
774 int i
, len
= TYPE_NFIELDS (type
);
776 if (TYPE_TARGET_TYPE (type
) != NULL
777 && TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_VOID
)
778 fprintf_filtered (stream
, "procedure");
780 fprintf_filtered (stream
, "function");
782 if (name
!= NULL
&& name
[0] != '\0')
783 fprintf_filtered (stream
, " %s", name
);
787 fprintf_filtered (stream
, " (");
788 for (i
= 0; i
< len
; i
+= 1)
792 fputs_filtered ("; ", stream
);
795 fprintf_filtered (stream
, "a%d: ", i
+ 1);
796 ada_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0,
799 fprintf_filtered (stream
, ")");
802 if (TYPE_TARGET_TYPE (type
) == NULL
)
803 fprintf_filtered (stream
, " return <unknown return type>");
804 else if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_VOID
)
806 fprintf_filtered (stream
, " return ");
807 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, 0, 0, flags
);
812 /* Print a description of a type TYPE0.
813 Output goes to STREAM (via stdio).
814 If VARSTRING is a non-empty string, print as an Ada variable/field
816 SHOW+1 is the maximum number of levels of internal type structure
817 to show (this applies to record types, enumerated types, and
819 SHOW is the number of levels of internal type structure to show
820 when there is a type name for the SHOWth deepest level (0th is
822 When SHOW<0, no inner structure is shown.
823 LEVEL indicates level of recursion (for nested definitions). */
826 ada_print_type (struct type
*type0
, const char *varstring
,
827 struct ui_file
*stream
, int show
, int level
,
828 const struct type_print_options
*flags
)
830 struct type
*type
= ada_check_typedef (ada_get_base_type (type0
));
831 char *type_name
= decoded_type_name (type0
);
832 int is_var_decl
= (varstring
!= NULL
&& varstring
[0] != '\0');
837 fprintf_filtered (stream
, "%.*s: ",
838 ada_name_prefix_len (varstring
), varstring
);
839 fprintf_filtered (stream
, "<null type?>");
844 type
= ada_check_typedef (type
);
846 if (is_var_decl
&& TYPE_CODE (type
) != TYPE_CODE_FUNC
)
847 fprintf_filtered (stream
, "%.*s: ",
848 ada_name_prefix_len (varstring
), varstring
);
850 if (type_name
!= NULL
&& show
<= 0 && !ada_is_aligner_type (type
))
852 fprintf_filtered (stream
, "%.*s",
853 ada_name_prefix_len (type_name
), type_name
);
857 if (ada_is_aligner_type (type
))
858 ada_print_type (ada_aligned_type (type
), "", stream
, show
, level
, flags
);
859 else if (ada_is_constrained_packed_array_type (type
)
860 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
861 print_array_type (type
, stream
, show
, level
, flags
);
863 switch (TYPE_CODE (type
))
866 fprintf_filtered (stream
, "<");
867 c_print_type (type
, "", stream
, show
, level
, flags
);
868 fprintf_filtered (stream
, ">");
871 case TYPE_CODE_TYPEDEF
:
872 fprintf_filtered (stream
, "access ");
873 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, show
, level
,
877 fprintf_filtered (stream
, "<ref> ");
878 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, show
, level
,
881 case TYPE_CODE_ARRAY
:
882 print_array_type (type
, stream
, show
, level
, flags
);
885 fprintf_filtered (stream
, "(false, true)");
888 if (ada_is_fixed_point_type (type
))
889 print_fixed_point_type (type
, stream
);
892 const char *name
= ada_type_name (type
);
894 if (!ada_is_range_type_name (name
))
895 fprintf_filtered (stream
, _("<%d-byte integer>"),
899 fprintf_filtered (stream
, "range ");
900 print_range_type (type
, stream
, 1 /* bounds_prefered_p */);
904 case TYPE_CODE_RANGE
:
905 if (ada_is_fixed_point_type (type
))
906 print_fixed_point_type (type
, stream
);
907 else if (ada_is_modular_type (type
))
908 fprintf_filtered (stream
, "mod %s",
909 int_string (ada_modulus (type
), 10, 0, 0, 1));
912 fprintf_filtered (stream
, "range ");
913 print_range (type
, stream
, 1 /* bounds_prefered_p */);
917 fprintf_filtered (stream
, _("<%d-byte float>"), TYPE_LENGTH (type
));
921 fprintf_filtered (stream
, "(...)");
923 print_enum_type (type
, stream
);
925 case TYPE_CODE_STRUCT
:
926 if (ada_is_array_descriptor_type (type
))
927 print_array_type (type
, stream
, show
, level
, flags
);
928 else if (ada_is_bogus_array_descriptor (type
))
929 fprintf_filtered (stream
,
930 _("array (?) of ? (<mal-formed descriptor>)"));
932 print_record_type (type
, stream
, show
, level
, flags
);
934 case TYPE_CODE_UNION
:
935 print_unchecked_union_type (type
, stream
, show
, level
, flags
);
938 print_func_type (type
, stream
, varstring
, flags
);
943 /* Implement the la_print_typedef language method for Ada. */
946 ada_print_typedef (struct type
*type
, struct symbol
*new_symbol
,
947 struct ui_file
*stream
)
949 type
= ada_check_typedef (type
);
950 ada_print_type (type
, "", stream
, 0, 0, &type_print_raw_options
);
951 fprintf_filtered (stream
, "\n");
This page took 0.128717 seconds and 4 git commands to generate.