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/>. */
20 #include "gdb_obstack.h"
21 #include "bfd.h" /* Binary File Description */
24 #include "expression.h"
33 #include "cli/cli-style.h"
34 #include "typeprint.h"
35 #include "target-float.h"
39 static int print_selected_record_field_types (struct type
*, struct type
*,
41 struct ui_file
*, int, int,
42 const struct type_print_options
*);
44 static int print_record_field_types (struct type
*, struct type
*,
45 struct ui_file
*, int, int,
46 const struct type_print_options
*);
50 static char *name_buffer
;
51 static int name_buffer_len
;
53 /* The (decoded) Ada name of TYPE. This value persists until the
57 decoded_type_name (struct type
*type
)
59 if (ada_type_name (type
) == NULL
)
63 const char *raw_name
= ada_type_name (type
);
66 if (name_buffer
== NULL
|| name_buffer_len
<= strlen (raw_name
))
68 name_buffer_len
= 16 + 2 * strlen (raw_name
);
69 name_buffer
= (char *) xrealloc (name_buffer
, name_buffer_len
);
71 strcpy (name_buffer
, raw_name
);
73 s
= (char *) strstr (name_buffer
, "___");
77 s
= name_buffer
+ strlen (name_buffer
) - 1;
78 while (s
> name_buffer
&& (s
[0] != '_' || s
[-1] != '_'))
87 for (s
= q
= name_buffer
; *s
!= '\0'; q
+= 1)
89 if (s
[0] == '_' && s
[1] == '_')
105 /* Return nonzero if TYPE is a subrange type, and its bounds
106 are identical to the bounds of its subtype. */
109 type_is_full_subrange_of_target_type (struct type
*type
)
111 struct type
*subtype
;
113 if (TYPE_CODE (type
) != TYPE_CODE_RANGE
)
116 subtype
= TYPE_TARGET_TYPE (type
);
120 if (is_dynamic_type (type
))
123 if (ada_discrete_type_low_bound (type
)
124 != ada_discrete_type_low_bound (subtype
))
127 if (ada_discrete_type_high_bound (type
)
128 != ada_discrete_type_high_bound (subtype
))
134 /* Print TYPE on STREAM, preferably as a range if BOUNDS_PREFERED_P
138 print_range (struct type
*type
, struct ui_file
*stream
,
139 int bounds_prefered_p
)
141 if (!bounds_prefered_p
)
143 /* Try stripping all TYPE_CODE_RANGE layers whose bounds
144 are identical to the bounds of their subtype. When
145 the bounds of both types match, it can allow us to
146 print a range using the name of its base type, which
147 is easier to read. For instance, we would print...
149 array (character) of ...
153 array ('["00"]' .. '["ff"]') of ... */
154 while (type_is_full_subrange_of_target_type (type
))
155 type
= TYPE_TARGET_TYPE (type
);
158 switch (TYPE_CODE (type
))
160 case TYPE_CODE_RANGE
:
163 LONGEST lo
= 0, hi
= 0; /* init for gcc -Wall */
168 lo
= ada_discrete_type_low_bound (type
);
169 hi
= ada_discrete_type_high_bound (type
);
171 catch (const gdb_exception_error
&e
)
173 /* This can happen when the range is dynamic. Sometimes,
174 resolving dynamic property values requires us to have
175 access to an actual object, which is not available
176 when the user is using the "ptype" command on a type.
177 Print the range as an unbounded range. */
178 fprintf_filtered (stream
, "<>");
184 ada_print_scalar (type
, lo
, stream
);
185 fprintf_filtered (stream
, " .. ");
186 ada_print_scalar (type
, hi
, stream
);
191 fprintf_filtered (stream
, "%.*s",
192 ada_name_prefix_len (TYPE_NAME (type
)),
198 /* Print the number or discriminant bound at BOUNDS+*N on STREAM, and
199 set *N past the bound and its delimiter, if any. */
202 print_range_bound (struct type
*type
, const char *bounds
, int *n
,
203 struct ui_file
*stream
)
207 if (ada_scan_number (bounds
, *n
, &B
, n
))
209 /* STABS decodes all range types which bounds are 0 .. -1 as
210 unsigned integers (ie. the type code is TYPE_CODE_INT, not
211 TYPE_CODE_RANGE). Unfortunately, ada_print_scalar() relies
212 on the unsigned flag to determine whether the bound should
213 be printed as a signed or an unsigned value. This causes
214 the upper bound of the 0 .. -1 range types to be printed as
215 a very large unsigned number instead of -1.
216 To workaround this stabs deficiency, we replace the TYPE by NULL
217 to indicate default output when we detect that the bound is negative,
218 and the type is a TYPE_CODE_INT. The bound is negative when
219 'm' is the last character of the number scanned in BOUNDS. */
220 if (bounds
[*n
- 1] == 'm' && TYPE_CODE (type
) == TYPE_CODE_INT
)
222 ada_print_scalar (type
, B
, stream
);
223 if (bounds
[*n
] == '_')
229 const char *bound
= bounds
+ *n
;
232 pend
= strstr (bound
, "__");
234 *n
+= bound_len
= strlen (bound
);
237 bound_len
= pend
- bound
;
240 fprintf_filtered (stream
, "%.*s", bound_len
, bound
);
244 /* Assuming NAME[0 .. NAME_LEN-1] is the name of a range type, print
245 the value (if found) of the bound indicated by SUFFIX ("___L" or
246 "___U") according to the ___XD conventions. */
249 print_dynamic_range_bound (struct type
*type
, const char *name
, int name_len
,
250 const char *suffix
, struct ui_file
*stream
)
253 std::string
name_buf (name
, name_len
);
256 if (get_int_var_value (name_buf
.c_str (), B
))
257 ada_print_scalar (type
, B
, stream
);
259 fprintf_filtered (stream
, "?");
262 /* Print RAW_TYPE as a range type, using any bound information
263 following the GNAT encoding (if available).
265 If BOUNDS_PREFERED_P is nonzero, force the printing of the range
266 using its bounds. Otherwise, try printing the range without
267 printing the value of the bounds, if possible (this is only
268 considered a hint, not a guaranty). */
271 print_range_type (struct type
*raw_type
, struct ui_file
*stream
,
272 int bounds_prefered_p
)
275 struct type
*base_type
;
276 const char *subtype_info
;
278 gdb_assert (raw_type
!= NULL
);
279 name
= TYPE_NAME (raw_type
);
280 gdb_assert (name
!= NULL
);
282 if (TYPE_CODE (raw_type
) == TYPE_CODE_RANGE
)
283 base_type
= TYPE_TARGET_TYPE (raw_type
);
285 base_type
= raw_type
;
287 subtype_info
= strstr (name
, "___XD");
288 if (subtype_info
== NULL
)
289 print_range (raw_type
, stream
, bounds_prefered_p
);
292 int prefix_len
= subtype_info
- name
;
293 const char *bounds_str
;
297 bounds_str
= strchr (subtype_info
, '_');
300 if (*subtype_info
== 'L')
302 print_range_bound (base_type
, bounds_str
, &n
, stream
);
306 print_dynamic_range_bound (base_type
, name
, prefix_len
, "___L",
309 fprintf_filtered (stream
, " .. ");
311 if (*subtype_info
== 'U')
312 print_range_bound (base_type
, bounds_str
, &n
, stream
);
314 print_dynamic_range_bound (base_type
, name
, prefix_len
, "___U",
319 /* Print enumerated type TYPE on STREAM. */
322 print_enum_type (struct type
*type
, struct ui_file
*stream
)
324 int len
= TYPE_NFIELDS (type
);
328 fprintf_filtered (stream
, "(");
332 for (i
= 0; i
< len
; i
++)
336 fprintf_filtered (stream
, ", ");
338 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type
, i
)), stream
);
339 if (lastval
!= TYPE_FIELD_ENUMVAL (type
, i
))
341 fprintf_filtered (stream
, " => %s",
342 plongest (TYPE_FIELD_ENUMVAL (type
, i
)));
343 lastval
= TYPE_FIELD_ENUMVAL (type
, i
);
347 fprintf_filtered (stream
, ")");
350 /* Print representation of Ada fixed-point type TYPE on STREAM. */
353 print_fixed_point_type (struct type
*type
, struct ui_file
*stream
)
355 struct value
*delta
= ada_delta (type
);
356 struct value
*small
= ada_scaling_factor (type
);
358 if (delta
== nullptr)
359 fprintf_filtered (stream
, "delta ??");
363 str
= target_float_to_string (value_contents (delta
),
364 value_type (delta
), "%g");
365 fprintf_filtered (stream
, "delta %s", str
.c_str());
366 if (!value_equal (delta
, small
))
368 str
= target_float_to_string (value_contents (small
),
369 value_type (small
), "%g");
370 fprintf_filtered (stream
, " <'small = %s>", str
.c_str());
375 /* Print simple (constrained) array type TYPE on STREAM. LEVEL is the
376 recursion (indentation) level, in case the element type itself has
377 nested structure, and SHOW is the number of levels of internal
378 structure to show (see ada_print_type). */
381 print_array_type (struct type
*type
, struct ui_file
*stream
, int show
,
382 int level
, const struct type_print_options
*flags
)
386 struct type
*elt_type
= NULL
;
388 if (ada_is_constrained_packed_array_type (type
))
389 type
= ada_coerce_to_simple_array_type (type
);
392 fprintf_filtered (stream
, "array (");
396 fprintf_styled (stream
, metadata_style
.style (),
397 _("<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')
784 fputs_filtered (" ", stream
);
785 fputs_styled (name
, function_name_style
.style (), stream
);
790 fprintf_filtered (stream
, " (");
791 for (i
= 0; i
< len
; i
+= 1)
795 fputs_filtered ("; ", stream
);
798 fprintf_filtered (stream
, "a%d: ", i
+ 1);
799 ada_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0,
802 fprintf_filtered (stream
, ")");
805 if (TYPE_TARGET_TYPE (type
) == NULL
)
806 fprintf_filtered (stream
, " return <unknown return type>");
807 else if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_VOID
)
809 fprintf_filtered (stream
, " return ");
810 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, 0, 0, flags
);
815 /* Print a description of a type TYPE0.
816 Output goes to STREAM (via stdio).
817 If VARSTRING is a non-empty string, print as an Ada variable/field
819 SHOW+1 is the maximum number of levels of internal type structure
820 to show (this applies to record types, enumerated types, and
822 SHOW is the number of levels of internal type structure to show
823 when there is a type name for the SHOWth deepest level (0th is
825 When SHOW<0, no inner structure is shown.
826 LEVEL indicates level of recursion (for nested definitions). */
829 ada_print_type (struct type
*type0
, const char *varstring
,
830 struct ui_file
*stream
, int show
, int level
,
831 const struct type_print_options
*flags
)
833 struct type
*type
= ada_check_typedef (ada_get_base_type (type0
));
834 char *type_name
= decoded_type_name (type0
);
835 int is_var_decl
= (varstring
!= NULL
&& varstring
[0] != '\0');
840 fprintf_filtered (stream
, "%.*s: ",
841 ada_name_prefix_len (varstring
), varstring
);
842 fprintf_styled (stream
, metadata_style
.style (), "<null type?>");
847 type
= ada_check_typedef (type
);
849 if (is_var_decl
&& TYPE_CODE (type
) != TYPE_CODE_FUNC
)
850 fprintf_filtered (stream
, "%.*s: ",
851 ada_name_prefix_len (varstring
), varstring
);
853 if (type_name
!= NULL
&& show
<= 0 && !ada_is_aligner_type (type
))
855 fprintf_filtered (stream
, "%.*s",
856 ada_name_prefix_len (type_name
), type_name
);
860 if (ada_is_aligner_type (type
))
861 ada_print_type (ada_aligned_type (type
), "", stream
, show
, level
, flags
);
862 else if (ada_is_constrained_packed_array_type (type
)
863 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
864 print_array_type (type
, stream
, show
, level
, flags
);
866 switch (TYPE_CODE (type
))
869 fprintf_filtered (stream
, "<");
870 c_print_type (type
, "", stream
, show
, level
, flags
);
871 fprintf_filtered (stream
, ">");
874 case TYPE_CODE_TYPEDEF
:
875 fprintf_filtered (stream
, "access ");
876 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, show
, level
,
880 fprintf_filtered (stream
, "<ref> ");
881 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, show
, level
,
884 case TYPE_CODE_ARRAY
:
885 print_array_type (type
, stream
, show
, level
, flags
);
888 fprintf_filtered (stream
, "(false, true)");
891 if (ada_is_fixed_point_type (type
))
892 print_fixed_point_type (type
, stream
);
895 const char *name
= ada_type_name (type
);
897 if (!ada_is_range_type_name (name
))
898 fprintf_styled (stream
, metadata_style
.style (),
899 _("<%s-byte integer>"),
900 pulongest (TYPE_LENGTH (type
)));
903 fprintf_filtered (stream
, "range ");
904 print_range_type (type
, stream
, 1 /* bounds_prefered_p */);
908 case TYPE_CODE_RANGE
:
909 if (ada_is_fixed_point_type (type
))
910 print_fixed_point_type (type
, stream
);
911 else if (ada_is_modular_type (type
))
912 fprintf_filtered (stream
, "mod %s",
913 int_string (ada_modulus (type
), 10, 0, 0, 1));
916 fprintf_filtered (stream
, "range ");
917 print_range (type
, stream
, 1 /* bounds_prefered_p */);
921 fprintf_styled (stream
, metadata_style
.style (),
922 _("<%s-byte float>"),
923 pulongest (TYPE_LENGTH (type
)));
927 fprintf_filtered (stream
, "(...)");
929 print_enum_type (type
, stream
);
931 case TYPE_CODE_STRUCT
:
932 if (ada_is_array_descriptor_type (type
))
933 print_array_type (type
, stream
, show
, level
, flags
);
934 else if (ada_is_bogus_array_descriptor (type
))
935 fprintf_filtered (stream
,
936 _("array (?) of ? (<mal-formed descriptor>)"));
938 print_record_type (type
, stream
, show
, level
, flags
);
940 case TYPE_CODE_UNION
:
941 print_unchecked_union_type (type
, stream
, show
, level
, flags
);
944 print_func_type (type
, stream
, varstring
, flags
);
949 /* Implement the la_print_typedef language method for Ada. */
952 ada_print_typedef (struct type
*type
, struct symbol
*new_symbol
,
953 struct ui_file
*stream
)
955 type
= ada_check_typedef (type
);
956 ada_print_type (type
, "", stream
, 0, 0, &type_print_raw_options
);
957 fprintf_filtered (stream
, "\n");
This page took 0.050452 seconds and 4 git commands to generate.