1 /* Support for printing Ada types for GDB, the GNU debugger.
2 Copyright (C) 1986-2019 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/>. */
21 /* Standard C includes. */
24 /* Local non-gdb includes. */
28 #include "cli/cli-style.h"
31 #include "expression.h"
32 #include "gdb_obstack.h"
38 #include "target-float.h"
40 #include "typeprint.h"
43 static int print_selected_record_field_types (struct type
*, struct type
*,
45 struct ui_file
*, int, int,
46 const struct type_print_options
*);
48 static int print_record_field_types (struct type
*, struct type
*,
49 struct ui_file
*, int, int,
50 const struct type_print_options
*);
54 static char *name_buffer
;
55 static int name_buffer_len
;
57 /* The (decoded) Ada name of TYPE. This value persists until the
61 decoded_type_name (struct type
*type
)
63 if (ada_type_name (type
) == NULL
)
67 const char *raw_name
= ada_type_name (type
);
70 if (name_buffer
== NULL
|| name_buffer_len
<= strlen (raw_name
))
72 name_buffer_len
= 16 + 2 * strlen (raw_name
);
73 name_buffer
= (char *) xrealloc (name_buffer
, name_buffer_len
);
75 strcpy (name_buffer
, raw_name
);
77 s
= (char *) strstr (name_buffer
, "___");
81 s
= name_buffer
+ strlen (name_buffer
) - 1;
82 while (s
> name_buffer
&& (s
[0] != '_' || s
[-1] != '_'))
91 for (s
= q
= name_buffer
; *s
!= '\0'; q
+= 1)
93 if (s
[0] == '_' && s
[1] == '_')
109 /* Return nonzero if TYPE is a subrange type, and its bounds
110 are identical to the bounds of its subtype. */
113 type_is_full_subrange_of_target_type (struct type
*type
)
115 struct type
*subtype
;
117 if (TYPE_CODE (type
) != TYPE_CODE_RANGE
)
120 subtype
= TYPE_TARGET_TYPE (type
);
124 if (is_dynamic_type (type
))
127 if (ada_discrete_type_low_bound (type
)
128 != ada_discrete_type_low_bound (subtype
))
131 if (ada_discrete_type_high_bound (type
)
132 != ada_discrete_type_high_bound (subtype
))
138 /* Print TYPE on STREAM, preferably as a range if BOUNDS_PREFERED_P
142 print_range (struct type
*type
, struct ui_file
*stream
,
143 int bounds_prefered_p
)
145 if (!bounds_prefered_p
)
147 /* Try stripping all TYPE_CODE_RANGE layers whose bounds
148 are identical to the bounds of their subtype. When
149 the bounds of both types match, it can allow us to
150 print a range using the name of its base type, which
151 is easier to read. For instance, we would print...
153 array (character) of ...
157 array ('["00"]' .. '["ff"]') of ... */
158 while (type_is_full_subrange_of_target_type (type
))
159 type
= TYPE_TARGET_TYPE (type
);
162 switch (TYPE_CODE (type
))
164 case TYPE_CODE_RANGE
:
167 LONGEST lo
= 0, hi
= 0; /* init for gcc -Wall */
172 lo
= ada_discrete_type_low_bound (type
);
173 hi
= ada_discrete_type_high_bound (type
);
175 CATCH (e
, RETURN_MASK_ERROR
)
177 /* This can happen when the range is dynamic. Sometimes,
178 resolving dynamic property values requires us to have
179 access to an actual object, which is not available
180 when the user is using the "ptype" command on a type.
181 Print the range as an unbounded range. */
182 fprintf_filtered (stream
, "<>");
189 ada_print_scalar (type
, lo
, stream
);
190 fprintf_filtered (stream
, " .. ");
191 ada_print_scalar (type
, hi
, stream
);
196 fprintf_filtered (stream
, "%.*s",
197 ada_name_prefix_len (TYPE_NAME (type
)),
203 /* Print the number or discriminant bound at BOUNDS+*N on STREAM, and
204 set *N past the bound and its delimiter, if any. */
207 print_range_bound (struct type
*type
, const char *bounds
, int *n
,
208 struct ui_file
*stream
)
212 if (ada_scan_number (bounds
, *n
, &B
, n
))
214 /* STABS decodes all range types which bounds are 0 .. -1 as
215 unsigned integers (ie. the type code is TYPE_CODE_INT, not
216 TYPE_CODE_RANGE). Unfortunately, ada_print_scalar() relies
217 on the unsigned flag to determine whether the bound should
218 be printed as a signed or an unsigned value. This causes
219 the upper bound of the 0 .. -1 range types to be printed as
220 a very large unsigned number instead of -1.
221 To workaround this stabs deficiency, we replace the TYPE by NULL
222 to indicate default output when we detect that the bound is negative,
223 and the type is a TYPE_CODE_INT. The bound is negative when
224 'm' is the last character of the number scanned in BOUNDS. */
225 if (bounds
[*n
- 1] == 'm' && TYPE_CODE (type
) == TYPE_CODE_INT
)
227 ada_print_scalar (type
, B
, stream
);
228 if (bounds
[*n
] == '_')
234 const char *bound
= bounds
+ *n
;
237 pend
= strstr (bound
, "__");
239 *n
+= bound_len
= strlen (bound
);
242 bound_len
= pend
- bound
;
245 fprintf_filtered (stream
, "%.*s", bound_len
, bound
);
249 /* Assuming NAME[0 .. NAME_LEN-1] is the name of a range type, print
250 the value (if found) of the bound indicated by SUFFIX ("___L" or
251 "___U") according to the ___XD conventions. */
254 print_dynamic_range_bound (struct type
*type
, const char *name
, int name_len
,
255 const char *suffix
, struct ui_file
*stream
)
258 std::string
name_buf (name
, name_len
);
261 if (get_int_var_value (name_buf
.c_str (), B
))
262 ada_print_scalar (type
, B
, stream
);
264 fprintf_filtered (stream
, "?");
267 /* Print RAW_TYPE as a range type, using any bound information
268 following the GNAT encoding (if available).
270 If BOUNDS_PREFERED_P is nonzero, force the printing of the range
271 using its bounds. Otherwise, try printing the range without
272 printing the value of the bounds, if possible (this is only
273 considered a hint, not a guaranty). */
276 print_range_type (struct type
*raw_type
, struct ui_file
*stream
,
277 int bounds_prefered_p
)
280 struct type
*base_type
;
281 const char *subtype_info
;
283 gdb_assert (raw_type
!= NULL
);
284 name
= TYPE_NAME (raw_type
);
285 gdb_assert (name
!= NULL
);
287 if (TYPE_CODE (raw_type
) == TYPE_CODE_RANGE
)
288 base_type
= TYPE_TARGET_TYPE (raw_type
);
290 base_type
= raw_type
;
292 subtype_info
= strstr (name
, "___XD");
293 if (subtype_info
== NULL
)
294 print_range (raw_type
, stream
, bounds_prefered_p
);
297 int prefix_len
= subtype_info
- name
;
298 const char *bounds_str
;
302 bounds_str
= strchr (subtype_info
, '_');
305 if (*subtype_info
== 'L')
307 print_range_bound (base_type
, bounds_str
, &n
, stream
);
311 print_dynamic_range_bound (base_type
, name
, prefix_len
, "___L",
314 fprintf_filtered (stream
, " .. ");
316 if (*subtype_info
== 'U')
317 print_range_bound (base_type
, bounds_str
, &n
, stream
);
319 print_dynamic_range_bound (base_type
, name
, prefix_len
, "___U",
324 /* Print enumerated type TYPE on STREAM. */
327 print_enum_type (struct type
*type
, struct ui_file
*stream
)
329 int len
= TYPE_NFIELDS (type
);
333 fprintf_filtered (stream
, "(");
337 for (i
= 0; i
< len
; i
++)
341 fprintf_filtered (stream
, ", ");
343 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type
, i
)), stream
);
344 if (lastval
!= TYPE_FIELD_ENUMVAL (type
, i
))
346 fprintf_filtered (stream
, " => %s",
347 plongest (TYPE_FIELD_ENUMVAL (type
, i
)));
348 lastval
= TYPE_FIELD_ENUMVAL (type
, i
);
352 fprintf_filtered (stream
, ")");
355 /* Print representation of Ada fixed-point type TYPE on STREAM. */
358 print_fixed_point_type (struct type
*type
, struct ui_file
*stream
)
360 struct value
*delta
= ada_delta (type
);
361 struct value
*small
= ada_scaling_factor (type
);
363 if (delta
== nullptr)
364 fprintf_filtered (stream
, "delta ??");
368 str
= target_float_to_string (value_contents (delta
),
369 value_type (delta
), "%g");
370 fprintf_filtered (stream
, "delta %s", str
.c_str());
371 if (!value_equal (delta
, small
))
373 str
= target_float_to_string (value_contents (small
),
374 value_type (small
), "%g");
375 fprintf_filtered (stream
, " <'small = %s>", str
.c_str());
380 /* Print simple (constrained) array type TYPE on STREAM. LEVEL is the
381 recursion (indentation) level, in case the element type itself has
382 nested structure, and SHOW is the number of levels of internal
383 structure to show (see ada_print_type). */
386 print_array_type (struct type
*type
, struct ui_file
*stream
, int show
,
387 int level
, const struct type_print_options
*flags
)
391 struct type
*elt_type
= NULL
;
393 if (ada_is_constrained_packed_array_type (type
))
394 type
= ada_coerce_to_simple_array_type (type
);
397 fprintf_filtered (stream
, "array (");
401 fprintf_filtered (stream
, _("<undecipherable array type>"));
406 if (ada_is_simple_array_type (type
))
408 struct type
*range_desc_type
;
409 struct type
*arr_type
;
411 range_desc_type
= ada_find_parallel_type (type
, "___XA");
412 ada_fixup_array_indexes_type (range_desc_type
);
415 if (range_desc_type
== NULL
)
417 for (arr_type
= type
; TYPE_CODE (arr_type
) == TYPE_CODE_ARRAY
;
418 arr_type
= TYPE_TARGET_TYPE (arr_type
))
420 if (arr_type
!= type
)
421 fprintf_filtered (stream
, ", ");
422 print_range (TYPE_INDEX_TYPE (arr_type
), stream
,
423 0 /* bounds_prefered_p */);
424 if (TYPE_FIELD_BITSIZE (arr_type
, 0) > 0)
425 bitsize
= TYPE_FIELD_BITSIZE (arr_type
, 0);
432 n_indices
= TYPE_NFIELDS (range_desc_type
);
433 for (k
= 0, arr_type
= type
;
435 k
+= 1, arr_type
= TYPE_TARGET_TYPE (arr_type
))
438 fprintf_filtered (stream
, ", ");
439 print_range_type (TYPE_FIELD_TYPE (range_desc_type
, k
),
440 stream
, 0 /* bounds_prefered_p */);
441 if (TYPE_FIELD_BITSIZE (arr_type
, 0) > 0)
442 bitsize
= TYPE_FIELD_BITSIZE (arr_type
, 0);
450 for (i
= i0
= ada_array_arity (type
); i
> 0; i
-= 1)
451 fprintf_filtered (stream
, "%s<>", i
== i0
? "" : ", ");
454 elt_type
= ada_array_element_type (type
, n_indices
);
455 fprintf_filtered (stream
, ") of ");
457 ada_print_type (elt_type
, "", stream
, show
== 0 ? 0 : show
- 1, level
+ 1,
459 /* Arrays with variable-length elements are never bit-packed in practice but
460 compilers have to describe their stride so that we can properly fetch
461 individual elements. Do not say the array is packed in this case. */
462 if (bitsize
> 0 && !is_dynamic_type (elt_type
))
463 fprintf_filtered (stream
, " <packed: %d-bit elements>", bitsize
);
466 /* Print the choices encoded by field FIELD_NUM of variant-part TYPE on
467 STREAM, assuming that VAL_TYPE (if non-NULL) is the type of the
468 values. Return non-zero if the field is an encoding of
469 discriminant values, as in a standard variant record, and 0 if the
470 field is not so encoded (as happens with single-component variants
471 in types annotated with pragma Unchecked_Variant). */
474 print_choices (struct type
*type
, int field_num
, struct ui_file
*stream
,
475 struct type
*val_type
)
479 const char *name
= TYPE_FIELD_NAME (type
, field_num
);
483 /* Skip over leading 'V': NOTE soon to be obsolete. */
486 if (!ada_scan_number (name
, 1, NULL
, &p
))
500 fprintf_filtered (stream
, " =>");
506 fprintf_filtered (stream
, " | ");
517 if (!ada_scan_number (name
, p
+ 1, &W
, &p
))
519 ada_print_scalar (val_type
, W
, stream
);
526 if (!ada_scan_number (name
, p
+ 1, &L
, &p
)
527 || name
[p
] != 'T' || !ada_scan_number (name
, p
+ 1, &U
, &p
))
529 ada_print_scalar (val_type
, L
, stream
);
530 fprintf_filtered (stream
, " .. ");
531 ada_print_scalar (val_type
, U
, stream
);
535 fprintf_filtered (stream
, "others");
542 fprintf_filtered (stream
, "?? =>");
546 /* Assuming that field FIELD_NUM of TYPE represents variants whose
547 discriminant is contained in OUTER_TYPE, print its components on STREAM.
548 LEVEL is the recursion (indentation) level, in case any of the fields
549 themselves have nested structure, and SHOW is the number of levels of
550 internal structure to show (see ada_print_type). For this purpose,
551 fields nested in a variant part are taken to be at the same level as
552 the fields immediately outside the variant part. */
555 print_variant_clauses (struct type
*type
, int field_num
,
556 struct type
*outer_type
, struct ui_file
*stream
,
558 const struct type_print_options
*flags
)
561 struct type
*var_type
, *par_type
;
562 struct type
*discr_type
;
564 var_type
= TYPE_FIELD_TYPE (type
, field_num
);
565 discr_type
= ada_variant_discrim_type (var_type
, outer_type
);
567 if (TYPE_CODE (var_type
) == TYPE_CODE_PTR
)
569 var_type
= TYPE_TARGET_TYPE (var_type
);
570 if (var_type
== NULL
|| TYPE_CODE (var_type
) != TYPE_CODE_UNION
)
574 par_type
= ada_find_parallel_type (var_type
, "___XVU");
575 if (par_type
!= NULL
)
578 for (i
= 0; i
< TYPE_NFIELDS (var_type
); i
+= 1)
580 fprintf_filtered (stream
, "\n%*swhen ", level
+ 4, "");
581 if (print_choices (var_type
, i
, stream
, discr_type
))
583 if (print_record_field_types (TYPE_FIELD_TYPE (var_type
, i
),
584 outer_type
, stream
, show
, level
+ 4,
587 fprintf_filtered (stream
, " null;");
590 print_selected_record_field_types (var_type
, outer_type
, i
, i
,
591 stream
, show
, level
+ 4, flags
);
595 /* Assuming that field FIELD_NUM of TYPE is a variant part whose
596 discriminants are contained in OUTER_TYPE, print a description of it
597 on STREAM. LEVEL is the recursion (indentation) level, in case any of
598 the fields themselves have nested structure, and SHOW is the number of
599 levels of internal structure to show (see ada_print_type). For this
600 purpose, fields nested in a variant part are taken to be at the same
601 level as the fields immediately outside the variant part. */
604 print_variant_part (struct type
*type
, int field_num
, struct type
*outer_type
,
605 struct ui_file
*stream
, int show
, int level
,
606 const struct type_print_options
*flags
)
608 fprintf_filtered (stream
, "\n%*scase %s is", level
+ 4, "",
609 ada_variant_discrim_name
610 (TYPE_FIELD_TYPE (type
, field_num
)));
611 print_variant_clauses (type
, field_num
, outer_type
, stream
, show
,
613 fprintf_filtered (stream
, "\n%*send case;", level
+ 4, "");
616 /* Print a description on STREAM of the fields FLD0 through FLD1 in
617 record or union type TYPE, whose discriminants are in OUTER_TYPE.
618 LEVEL is the recursion (indentation) level, in case any of the
619 fields themselves have nested structure, and SHOW is the number of
620 levels of internal structure to show (see ada_print_type). Does
621 not print parent type information of TYPE. Returns 0 if no fields
622 printed, -1 for an incomplete type, else > 0. Prints each field
623 beginning on a new line, but does not put a new line at end. */
626 print_selected_record_field_types (struct type
*type
, struct type
*outer_type
,
628 struct ui_file
*stream
, int show
, int level
,
629 const struct type_print_options
*flags
)
635 if (fld0
> fld1
&& TYPE_STUB (type
))
638 for (i
= fld0
; i
<= fld1
; i
+= 1)
642 if (ada_is_parent_field (type
, i
) || ada_is_ignored_field (type
, i
))
644 else if (ada_is_wrapper_field (type
, i
))
645 flds
+= print_record_field_types (TYPE_FIELD_TYPE (type
, i
), type
,
646 stream
, show
, level
, flags
);
647 else if (ada_is_variant_part (type
, i
))
649 print_variant_part (type
, i
, outer_type
, stream
, show
, level
, flags
);
655 fprintf_filtered (stream
, "\n%*s", level
+ 4, "");
656 ada_print_type (TYPE_FIELD_TYPE (type
, i
),
657 TYPE_FIELD_NAME (type
, i
),
658 stream
, show
- 1, level
+ 4, flags
);
659 fprintf_filtered (stream
, ";");
666 /* Print a description on STREAM of all fields of record or union type
667 TYPE, as for print_selected_record_field_types, above. */
670 print_record_field_types (struct type
*type
, struct type
*outer_type
,
671 struct ui_file
*stream
, int show
, int level
,
672 const struct type_print_options
*flags
)
674 return print_selected_record_field_types (type
, outer_type
,
675 0, TYPE_NFIELDS (type
) - 1,
676 stream
, show
, level
, flags
);
680 /* Print record type TYPE on STREAM. LEVEL is the recursion (indentation)
681 level, in case the element type itself has nested structure, and SHOW is
682 the number of levels of internal structure to show (see ada_print_type). */
685 print_record_type (struct type
*type0
, struct ui_file
*stream
, int show
,
686 int level
, const struct type_print_options
*flags
)
688 struct type
*parent_type
;
691 type
= ada_find_parallel_type (type0
, "___XVE");
695 parent_type
= ada_parent_type (type
);
696 if (ada_type_name (parent_type
) != NULL
)
698 const char *parent_name
= decoded_type_name (parent_type
);
700 /* If we fail to decode the parent type name, then use the parent
701 type name as is. Not pretty, but should never happen except
702 when the debugging info is incomplete or incorrect. This
703 prevents a crash trying to print a NULL pointer. */
704 if (parent_name
== NULL
)
705 parent_name
= ada_type_name (parent_type
);
706 fprintf_filtered (stream
, "new %s with record", parent_name
);
708 else if (parent_type
== NULL
&& ada_is_tagged_type (type
, 0))
709 fprintf_filtered (stream
, "tagged record");
711 fprintf_filtered (stream
, "record");
714 fprintf_filtered (stream
, " ... end record");
720 if (parent_type
!= NULL
&& ada_type_name (parent_type
) == NULL
)
721 flds
+= print_record_field_types (parent_type
, parent_type
,
722 stream
, show
, level
, flags
);
723 flds
+= print_record_field_types (type
, type
, stream
, show
, level
,
727 fprintf_filtered (stream
, "\n%*send record", level
, "");
729 fprintf_filtered (stream
, _(" <incomplete type> end record"));
731 fprintf_filtered (stream
, " null; end record");
735 /* Print the unchecked union type TYPE in something resembling Ada
736 format on STREAM. LEVEL is the recursion (indentation) level
737 in case the element type itself has nested structure, and SHOW is the
738 number of levels of internal structure to show (see ada_print_type). */
740 print_unchecked_union_type (struct type
*type
, struct ui_file
*stream
,
742 const struct type_print_options
*flags
)
745 fprintf_filtered (stream
, "record (?) is ... end record");
746 else if (TYPE_NFIELDS (type
) == 0)
747 fprintf_filtered (stream
, "record (?) is null; end record");
752 fprintf_filtered (stream
, "record (?) is\n%*scase ? is", level
+ 4, "");
754 for (i
= 0; i
< TYPE_NFIELDS (type
); i
+= 1)
756 fprintf_filtered (stream
, "\n%*swhen ? =>\n%*s", level
+ 8, "",
758 ada_print_type (TYPE_FIELD_TYPE (type
, i
),
759 TYPE_FIELD_NAME (type
, i
),
760 stream
, show
- 1, level
+ 12, flags
);
761 fprintf_filtered (stream
, ";");
764 fprintf_filtered (stream
, "\n%*send case;\n%*send record",
765 level
+ 4, "", level
, "");
771 /* Print function or procedure type TYPE on STREAM. Make it a header
772 for function or procedure NAME if NAME is not null. */
775 print_func_type (struct type
*type
, struct ui_file
*stream
, const char *name
,
776 const struct type_print_options
*flags
)
778 int i
, len
= TYPE_NFIELDS (type
);
780 if (TYPE_TARGET_TYPE (type
) != NULL
781 && TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_VOID
)
782 fprintf_filtered (stream
, "procedure");
784 fprintf_filtered (stream
, "function");
786 if (name
!= NULL
&& name
[0] != '\0')
788 fputs_filtered (" ", stream
);
789 fputs_styled (name
, function_name_style
.style (), stream
);
794 fprintf_filtered (stream
, " (");
795 for (i
= 0; i
< len
; i
+= 1)
799 fputs_filtered ("; ", stream
);
802 fprintf_filtered (stream
, "a%d: ", i
+ 1);
803 ada_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0,
806 fprintf_filtered (stream
, ")");
809 if (TYPE_TARGET_TYPE (type
) == NULL
)
810 fprintf_filtered (stream
, " return <unknown return type>");
811 else if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_VOID
)
813 fprintf_filtered (stream
, " return ");
814 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, 0, 0, flags
);
819 /* Print a description of a type TYPE0.
820 Output goes to STREAM (via stdio).
821 If VARSTRING is a non-empty string, print as an Ada variable/field
823 SHOW+1 is the maximum number of levels of internal type structure
824 to show (this applies to record types, enumerated types, and
826 SHOW is the number of levels of internal type structure to show
827 when there is a type name for the SHOWth deepest level (0th is
829 When SHOW<0, no inner structure is shown.
830 LEVEL indicates level of recursion (for nested definitions). */
833 ada_print_type (struct type
*type0
, const char *varstring
,
834 struct ui_file
*stream
, int show
, int level
,
835 const struct type_print_options
*flags
)
837 struct type
*type
= ada_check_typedef (ada_get_base_type (type0
));
838 char *type_name
= decoded_type_name (type0
);
839 int is_var_decl
= (varstring
!= NULL
&& varstring
[0] != '\0');
844 fprintf_filtered (stream
, "%.*s: ",
845 ada_name_prefix_len (varstring
), varstring
);
846 fprintf_filtered (stream
, "<null type?>");
851 type
= ada_check_typedef (type
);
853 if (is_var_decl
&& TYPE_CODE (type
) != TYPE_CODE_FUNC
)
854 fprintf_filtered (stream
, "%.*s: ",
855 ada_name_prefix_len (varstring
), varstring
);
857 if (type_name
!= NULL
&& show
<= 0 && !ada_is_aligner_type (type
))
859 fprintf_filtered (stream
, "%.*s",
860 ada_name_prefix_len (type_name
), type_name
);
864 if (ada_is_aligner_type (type
))
865 ada_print_type (ada_aligned_type (type
), "", stream
, show
, level
, flags
);
866 else if (ada_is_constrained_packed_array_type (type
)
867 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
868 print_array_type (type
, stream
, show
, level
, flags
);
870 switch (TYPE_CODE (type
))
873 fprintf_filtered (stream
, "<");
874 c_print_type (type
, "", stream
, show
, level
, flags
);
875 fprintf_filtered (stream
, ">");
878 case TYPE_CODE_TYPEDEF
:
879 fprintf_filtered (stream
, "access ");
880 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, show
, level
,
884 fprintf_filtered (stream
, "<ref> ");
885 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, show
, level
,
888 case TYPE_CODE_ARRAY
:
889 print_array_type (type
, stream
, show
, level
, flags
);
892 fprintf_filtered (stream
, "(false, true)");
895 if (ada_is_fixed_point_type (type
))
896 print_fixed_point_type (type
, stream
);
899 const char *name
= ada_type_name (type
);
901 if (!ada_is_range_type_name (name
))
902 fprintf_filtered (stream
, _("<%s-byte integer>"),
903 pulongest (TYPE_LENGTH (type
)));
906 fprintf_filtered (stream
, "range ");
907 print_range_type (type
, stream
, 1 /* bounds_prefered_p */);
911 case TYPE_CODE_RANGE
:
912 if (ada_is_fixed_point_type (type
))
913 print_fixed_point_type (type
, stream
);
914 else if (ada_is_modular_type (type
))
915 fprintf_filtered (stream
, "mod %s",
916 int_string (ada_modulus (type
), 10, 0, 0, 1));
919 fprintf_filtered (stream
, "range ");
920 print_range (type
, stream
, 1 /* bounds_prefered_p */);
924 fprintf_filtered (stream
, _("<%s-byte float>"),
925 pulongest (TYPE_LENGTH (type
)));
929 fprintf_filtered (stream
, "(...)");
931 print_enum_type (type
, stream
);
933 case TYPE_CODE_STRUCT
:
934 if (ada_is_array_descriptor_type (type
))
935 print_array_type (type
, stream
, show
, level
, flags
);
936 else if (ada_is_bogus_array_descriptor (type
))
937 fprintf_filtered (stream
,
938 _("array (?) of ? (<mal-formed descriptor>)"));
940 print_record_type (type
, stream
, show
, level
, flags
);
942 case TYPE_CODE_UNION
:
943 print_unchecked_union_type (type
, stream
, show
, level
, flags
);
946 print_func_type (type
, stream
, varstring
, flags
);
951 /* Implement the la_print_typedef language method for Ada. */
954 ada_print_typedef (struct type
*type
, struct symbol
*new_symbol
,
955 struct ui_file
*stream
)
957 type
= ada_check_typedef (type
);
958 ada_print_type (type
, "", stream
, 0, 0, &type_print_raw_options
);
959 fprintf_filtered (stream
, "\n");
This page took 0.06496 seconds and 4 git commands to generate.