1 /* Support for printing Ada types for GDB, the GNU debugger.
2 Copyright (C) 1986-2013 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"
40 static int print_selected_record_field_types (struct type
*, struct type
*,
42 struct ui_file
*, int, int,
43 const struct type_print_options
*);
45 static int print_record_field_types (struct type
*, struct type
*,
46 struct ui_file
*, int, int,
47 const struct type_print_options
*);
49 static void print_array_type (struct type
*, struct ui_file
*, int, int,
50 const struct type_print_options
*);
52 static int print_choices (struct type
*, int, struct ui_file
*,
55 static void print_range (struct type
*, struct ui_file
*);
57 static void print_range_bound (struct type
*, char *, int *,
61 print_dynamic_range_bound (struct type
*, const char *, int,
62 const char *, struct ui_file
*);
64 static void print_range_type (struct type
*, struct ui_file
*);
68 static char *name_buffer
;
69 static int name_buffer_len
;
71 /* The (decoded) Ada name of TYPE. This value persists until the
75 decoded_type_name (struct type
*type
)
77 if (ada_type_name (type
) == NULL
)
81 const char *raw_name
= ada_type_name (type
);
84 if (name_buffer
== NULL
|| name_buffer_len
<= strlen (raw_name
))
86 name_buffer_len
= 16 + 2 * strlen (raw_name
);
87 name_buffer
= xrealloc (name_buffer
, name_buffer_len
);
89 strcpy (name_buffer
, raw_name
);
91 s
= (char *) strstr (name_buffer
, "___");
95 s
= name_buffer
+ strlen (name_buffer
) - 1;
96 while (s
> name_buffer
&& (s
[0] != '_' || s
[-1] != '_'))
105 for (s
= q
= name_buffer
; *s
!= '\0'; q
+= 1)
107 if (s
[0] == '_' && s
[1] == '_')
123 /* Print TYPE on STREAM, preferably as a range. */
126 print_range (struct type
*type
, struct ui_file
*stream
)
128 switch (TYPE_CODE (type
))
130 case TYPE_CODE_RANGE
:
133 struct type
*target_type
;
134 target_type
= TYPE_TARGET_TYPE (type
);
135 if (target_type
== NULL
)
137 ada_print_scalar (target_type
, ada_discrete_type_low_bound (type
),
139 fprintf_filtered (stream
, " .. ");
140 ada_print_scalar (target_type
, ada_discrete_type_high_bound (type
),
145 fprintf_filtered (stream
, "%.*s",
146 ada_name_prefix_len (TYPE_NAME (type
)),
152 /* Print the number or discriminant bound at BOUNDS+*N on STREAM, and
153 set *N past the bound and its delimiter, if any. */
156 print_range_bound (struct type
*type
, char *bounds
, int *n
,
157 struct ui_file
*stream
)
161 if (ada_scan_number (bounds
, *n
, &B
, n
))
163 /* STABS decodes all range types which bounds are 0 .. -1 as
164 unsigned integers (ie. the type code is TYPE_CODE_INT, not
165 TYPE_CODE_RANGE). Unfortunately, ada_print_scalar() relies
166 on the unsigned flag to determine whether the bound should
167 be printed as a signed or an unsigned value. This causes
168 the upper bound of the 0 .. -1 range types to be printed as
169 a very large unsigned number instead of -1.
170 To workaround this stabs deficiency, we replace the TYPE by NULL
171 to indicate default output when we detect that the bound is negative,
172 and the type is a TYPE_CODE_INT. The bound is negative when
173 'm' is the last character of the number scanned in BOUNDS. */
174 if (bounds
[*n
- 1] == 'm' && TYPE_CODE (type
) == TYPE_CODE_INT
)
176 ada_print_scalar (type
, B
, stream
);
177 if (bounds
[*n
] == '_')
183 char *bound
= bounds
+ *n
;
186 pend
= strstr (bound
, "__");
188 *n
+= bound_len
= strlen (bound
);
191 bound_len
= pend
- bound
;
194 fprintf_filtered (stream
, "%.*s", bound_len
, bound
);
198 /* Assuming NAME[0 .. NAME_LEN-1] is the name of a range type, print
199 the value (if found) of the bound indicated by SUFFIX ("___L" or
200 "___U") according to the ___XD conventions. */
203 print_dynamic_range_bound (struct type
*type
, const char *name
, int name_len
,
204 const char *suffix
, struct ui_file
*stream
)
206 static char *name_buf
= NULL
;
207 static size_t name_buf_len
= 0;
211 GROW_VECT (name_buf
, name_buf_len
, name_len
+ strlen (suffix
) + 1);
212 strncpy (name_buf
, name
, name_len
);
213 strcpy (name_buf
+ name_len
, suffix
);
215 B
= get_int_var_value (name_buf
, &OK
);
217 ada_print_scalar (type
, B
, stream
);
219 fprintf_filtered (stream
, "?");
222 /* Print RAW_TYPE as a range type, using any bound information
223 following the GNAT encoding (if available). */
226 print_range_type (struct type
*raw_type
, struct ui_file
*stream
)
229 struct type
*base_type
;
230 const char *subtype_info
;
232 gdb_assert (raw_type
!= NULL
);
233 name
= TYPE_NAME (raw_type
);
234 gdb_assert (name
!= NULL
);
236 if (TYPE_CODE (raw_type
) == TYPE_CODE_RANGE
)
237 base_type
= TYPE_TARGET_TYPE (raw_type
);
239 base_type
= raw_type
;
241 subtype_info
= strstr (name
, "___XD");
242 if (subtype_info
== NULL
)
243 print_range (raw_type
, stream
);
246 int prefix_len
= subtype_info
- name
;
251 bounds_str
= strchr (subtype_info
, '_');
254 if (*subtype_info
== 'L')
256 print_range_bound (base_type
, bounds_str
, &n
, stream
);
260 print_dynamic_range_bound (base_type
, name
, prefix_len
, "___L",
263 fprintf_filtered (stream
, " .. ");
265 if (*subtype_info
== 'U')
266 print_range_bound (base_type
, bounds_str
, &n
, stream
);
268 print_dynamic_range_bound (base_type
, name
, prefix_len
, "___U",
273 /* Print enumerated type TYPE on STREAM. */
276 print_enum_type (struct type
*type
, struct ui_file
*stream
)
278 int len
= TYPE_NFIELDS (type
);
282 fprintf_filtered (stream
, "(");
286 for (i
= 0; i
< len
; i
++)
290 fprintf_filtered (stream
, ", ");
292 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type
, i
)), stream
);
293 if (lastval
!= TYPE_FIELD_ENUMVAL (type
, i
))
295 fprintf_filtered (stream
, " => %s",
296 plongest (TYPE_FIELD_ENUMVAL (type
, i
)));
297 lastval
= TYPE_FIELD_ENUMVAL (type
, i
);
301 fprintf_filtered (stream
, ")");
304 /* Print representation of Ada fixed-point type TYPE on STREAM. */
307 print_fixed_point_type (struct type
*type
, struct ui_file
*stream
)
309 DOUBLEST delta
= ada_delta (type
);
310 DOUBLEST small
= ada_fixed_to_float (type
, 1.0);
313 fprintf_filtered (stream
, "delta ??");
316 fprintf_filtered (stream
, "delta %g", (double) delta
);
318 fprintf_filtered (stream
, " <'small = %g>", (double) small
);
322 /* Print simple (constrained) array type TYPE on STREAM. LEVEL is the
323 recursion (indentation) level, in case the element type itself has
324 nested structure, and SHOW is the number of levels of internal
325 structure to show (see ada_print_type). */
328 print_array_type (struct type
*type
, struct ui_file
*stream
, int show
,
329 int level
, const struct type_print_options
*flags
)
334 if (ada_is_constrained_packed_array_type (type
))
335 type
= ada_coerce_to_simple_array_type (type
);
338 fprintf_filtered (stream
, "array (");
342 fprintf_filtered (stream
, _("<undecipherable array type>"));
347 if (ada_is_simple_array_type (type
))
349 struct type
*range_desc_type
;
350 struct type
*arr_type
;
352 range_desc_type
= ada_find_parallel_type (type
, "___XA");
353 ada_fixup_array_indexes_type (range_desc_type
);
356 if (range_desc_type
== NULL
)
358 for (arr_type
= type
; TYPE_CODE (arr_type
) == TYPE_CODE_ARRAY
;
359 arr_type
= TYPE_TARGET_TYPE (arr_type
))
361 if (arr_type
!= type
)
362 fprintf_filtered (stream
, ", ");
363 print_range (TYPE_INDEX_TYPE (arr_type
), stream
);
364 if (TYPE_FIELD_BITSIZE (arr_type
, 0) > 0)
365 bitsize
= TYPE_FIELD_BITSIZE (arr_type
, 0);
372 n_indices
= TYPE_NFIELDS (range_desc_type
);
373 for (k
= 0, arr_type
= type
;
375 k
+= 1, arr_type
= TYPE_TARGET_TYPE (arr_type
))
378 fprintf_filtered (stream
, ", ");
379 print_range_type (TYPE_FIELD_TYPE (range_desc_type
, k
),
381 if (TYPE_FIELD_BITSIZE (arr_type
, 0) > 0)
382 bitsize
= TYPE_FIELD_BITSIZE (arr_type
, 0);
390 for (i
= i0
= ada_array_arity (type
); i
> 0; i
-= 1)
391 fprintf_filtered (stream
, "%s<>", i
== i0
? "" : ", ");
394 fprintf_filtered (stream
, ") of ");
396 ada_print_type (ada_array_element_type (type
, n_indices
), "", stream
,
397 show
== 0 ? 0 : show
- 1, level
+ 1, flags
);
399 fprintf_filtered (stream
, " <packed: %d-bit elements>", bitsize
);
402 /* Print the choices encoded by field FIELD_NUM of variant-part TYPE on
403 STREAM, assuming that VAL_TYPE (if non-NULL) is the type of the
404 values. Return non-zero if the field is an encoding of
405 discriminant values, as in a standard variant record, and 0 if the
406 field is not so encoded (as happens with single-component variants
407 in types annotated with pragma Unchecked_Variant). */
410 print_choices (struct type
*type
, int field_num
, struct ui_file
*stream
,
411 struct type
*val_type
)
415 const char *name
= TYPE_FIELD_NAME (type
, field_num
);
419 /* Skip over leading 'V': NOTE soon to be obsolete. */
422 if (!ada_scan_number (name
, 1, NULL
, &p
))
436 fprintf_filtered (stream
, " =>");
442 fprintf_filtered (stream
, " | ");
453 if (!ada_scan_number (name
, p
+ 1, &W
, &p
))
455 ada_print_scalar (val_type
, W
, stream
);
462 if (!ada_scan_number (name
, p
+ 1, &L
, &p
)
463 || name
[p
] != 'T' || !ada_scan_number (name
, p
+ 1, &U
, &p
))
465 ada_print_scalar (val_type
, L
, stream
);
466 fprintf_filtered (stream
, " .. ");
467 ada_print_scalar (val_type
, U
, stream
);
471 fprintf_filtered (stream
, "others");
478 fprintf_filtered (stream
, "?? =>");
482 /* Assuming that field FIELD_NUM of TYPE represents variants whose
483 discriminant is contained in OUTER_TYPE, print its components on STREAM.
484 LEVEL is the recursion (indentation) level, in case any of the fields
485 themselves have nested structure, and SHOW is the number of levels of
486 internal structure to show (see ada_print_type). For this purpose,
487 fields nested in a variant part are taken to be at the same level as
488 the fields immediately outside the variant part. */
491 print_variant_clauses (struct type
*type
, int field_num
,
492 struct type
*outer_type
, struct ui_file
*stream
,
494 const struct type_print_options
*flags
)
497 struct type
*var_type
, *par_type
;
498 struct type
*discr_type
;
500 var_type
= TYPE_FIELD_TYPE (type
, field_num
);
501 discr_type
= ada_variant_discrim_type (var_type
, outer_type
);
503 if (TYPE_CODE (var_type
) == TYPE_CODE_PTR
)
505 var_type
= TYPE_TARGET_TYPE (var_type
);
506 if (var_type
== NULL
|| TYPE_CODE (var_type
) != TYPE_CODE_UNION
)
510 par_type
= ada_find_parallel_type (var_type
, "___XVU");
511 if (par_type
!= NULL
)
514 for (i
= 0; i
< TYPE_NFIELDS (var_type
); i
+= 1)
516 fprintf_filtered (stream
, "\n%*swhen ", level
+ 4, "");
517 if (print_choices (var_type
, i
, stream
, discr_type
))
519 if (print_record_field_types (TYPE_FIELD_TYPE (var_type
, i
),
520 outer_type
, stream
, show
, level
+ 4,
523 fprintf_filtered (stream
, " null;");
526 print_selected_record_field_types (var_type
, outer_type
, i
, i
,
527 stream
, show
, level
+ 4, flags
);
531 /* Assuming that field FIELD_NUM of TYPE is a variant part whose
532 discriminants are contained in OUTER_TYPE, print a description of it
533 on STREAM. LEVEL is the recursion (indentation) level, in case any of
534 the fields themselves have nested structure, and SHOW is the number of
535 levels of internal structure to show (see ada_print_type). For this
536 purpose, fields nested in a variant part are taken to be at the same
537 level as the fields immediately outside the variant part. */
540 print_variant_part (struct type
*type
, int field_num
, struct type
*outer_type
,
541 struct ui_file
*stream
, int show
, int level
,
542 const struct type_print_options
*flags
)
544 fprintf_filtered (stream
, "\n%*scase %s is", level
+ 4, "",
545 ada_variant_discrim_name
546 (TYPE_FIELD_TYPE (type
, field_num
)));
547 print_variant_clauses (type
, field_num
, outer_type
, stream
, show
,
549 fprintf_filtered (stream
, "\n%*send case;", level
+ 4, "");
552 /* Print a description on STREAM of the fields FLD0 through FLD1 in
553 record or union type TYPE, whose discriminants are in OUTER_TYPE.
554 LEVEL is the recursion (indentation) level, in case any of the
555 fields themselves have nested structure, and SHOW is the number of
556 levels of internal structure to show (see ada_print_type). Does
557 not print parent type information of TYPE. Returns 0 if no fields
558 printed, -1 for an incomplete type, else > 0. Prints each field
559 beginning on a new line, but does not put a new line at end. */
562 print_selected_record_field_types (struct type
*type
, struct type
*outer_type
,
564 struct ui_file
*stream
, int show
, int level
,
565 const struct type_print_options
*flags
)
571 if (fld0
> fld1
&& TYPE_STUB (type
))
574 for (i
= fld0
; i
<= fld1
; i
+= 1)
578 if (ada_is_parent_field (type
, i
) || ada_is_ignored_field (type
, i
))
580 else if (ada_is_wrapper_field (type
, i
))
581 flds
+= print_record_field_types (TYPE_FIELD_TYPE (type
, i
), type
,
582 stream
, show
, level
, flags
);
583 else if (ada_is_variant_part (type
, i
))
585 print_variant_part (type
, i
, outer_type
, stream
, show
, level
, flags
);
591 fprintf_filtered (stream
, "\n%*s", level
+ 4, "");
592 ada_print_type (TYPE_FIELD_TYPE (type
, i
),
593 TYPE_FIELD_NAME (type
, i
),
594 stream
, show
- 1, level
+ 4, flags
);
595 fprintf_filtered (stream
, ";");
602 /* Print a description on STREAM of all fields of record or union type
603 TYPE, as for print_selected_record_field_types, above. */
606 print_record_field_types (struct type
*type
, struct type
*outer_type
,
607 struct ui_file
*stream
, int show
, int level
,
608 const struct type_print_options
*flags
)
610 return print_selected_record_field_types (type
, outer_type
,
611 0, TYPE_NFIELDS (type
) - 1,
612 stream
, show
, level
, flags
);
616 /* Print record type TYPE on STREAM. LEVEL is the recursion (indentation)
617 level, in case the element type itself has nested structure, and SHOW is
618 the number of levels of internal structure to show (see ada_print_type). */
621 print_record_type (struct type
*type0
, struct ui_file
*stream
, int show
,
622 int level
, const struct type_print_options
*flags
)
624 struct type
*parent_type
;
627 type
= ada_find_parallel_type (type0
, "___XVE");
631 parent_type
= ada_parent_type (type
);
632 if (ada_type_name (parent_type
) != NULL
)
634 const char *parent_name
= decoded_type_name (parent_type
);
636 /* If we fail to decode the parent type name, then use the parent
637 type name as is. Not pretty, but should never happen except
638 when the debugging info is incomplete or incorrect. This
639 prevents a crash trying to print a NULL pointer. */
640 if (parent_name
== NULL
)
641 parent_name
= ada_type_name (parent_type
);
642 fprintf_filtered (stream
, "new %s with record", parent_name
);
644 else if (parent_type
== NULL
&& ada_is_tagged_type (type
, 0))
645 fprintf_filtered (stream
, "tagged record");
647 fprintf_filtered (stream
, "record");
650 fprintf_filtered (stream
, " ... end record");
656 if (parent_type
!= NULL
&& ada_type_name (parent_type
) == NULL
)
657 flds
+= print_record_field_types (parent_type
, parent_type
,
658 stream
, show
, level
, flags
);
659 flds
+= print_record_field_types (type
, type
, stream
, show
, level
,
663 fprintf_filtered (stream
, "\n%*send record", level
, "");
665 fprintf_filtered (stream
, _(" <incomplete type> end record"));
667 fprintf_filtered (stream
, " null; end record");
671 /* Print the unchecked union type TYPE in something resembling Ada
672 format on STREAM. LEVEL is the recursion (indentation) level
673 in case the element type itself has nested structure, and SHOW is the
674 number of levels of internal structure to show (see ada_print_type). */
676 print_unchecked_union_type (struct type
*type
, struct ui_file
*stream
,
678 const struct type_print_options
*flags
)
681 fprintf_filtered (stream
, "record (?) is ... end record");
682 else if (TYPE_NFIELDS (type
) == 0)
683 fprintf_filtered (stream
, "record (?) is null; end record");
688 fprintf_filtered (stream
, "record (?) is\n%*scase ? is", level
+ 4, "");
690 for (i
= 0; i
< TYPE_NFIELDS (type
); i
+= 1)
692 fprintf_filtered (stream
, "\n%*swhen ? =>\n%*s", level
+ 8, "",
694 ada_print_type (TYPE_FIELD_TYPE (type
, i
),
695 TYPE_FIELD_NAME (type
, i
),
696 stream
, show
- 1, level
+ 12, flags
);
697 fprintf_filtered (stream
, ";");
700 fprintf_filtered (stream
, "\n%*send case;\n%*send record",
701 level
+ 4, "", level
, "");
707 /* Print function or procedure type TYPE on STREAM. Make it a header
708 for function or procedure NAME if NAME is not null. */
711 print_func_type (struct type
*type
, struct ui_file
*stream
, const char *name
,
712 const struct type_print_options
*flags
)
714 int i
, len
= TYPE_NFIELDS (type
);
716 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_VOID
)
717 fprintf_filtered (stream
, "procedure");
719 fprintf_filtered (stream
, "function");
721 if (name
!= NULL
&& name
[0] != '\0')
722 fprintf_filtered (stream
, " %s", name
);
726 fprintf_filtered (stream
, " (");
727 for (i
= 0; i
< len
; i
+= 1)
731 fputs_filtered ("; ", stream
);
734 fprintf_filtered (stream
, "a%d: ", i
+ 1);
735 ada_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0,
738 fprintf_filtered (stream
, ")");
741 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_VOID
)
743 fprintf_filtered (stream
, " return ");
744 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, 0, 0, flags
);
749 /* Print a description of a type TYPE0.
750 Output goes to STREAM (via stdio).
751 If VARSTRING is a non-empty string, print as an Ada variable/field
753 SHOW+1 is the maximum number of levels of internal type structure
754 to show (this applies to record types, enumerated types, and
756 SHOW is the number of levels of internal type structure to show
757 when there is a type name for the SHOWth deepest level (0th is
759 When SHOW<0, no inner structure is shown.
760 LEVEL indicates level of recursion (for nested definitions). */
763 ada_print_type (struct type
*type0
, const char *varstring
,
764 struct ui_file
*stream
, int show
, int level
,
765 const struct type_print_options
*flags
)
767 struct type
*type
= ada_check_typedef (ada_get_base_type (type0
));
768 char *type_name
= decoded_type_name (type0
);
769 int is_var_decl
= (varstring
!= NULL
&& varstring
[0] != '\0');
774 fprintf_filtered (stream
, "%.*s: ",
775 ada_name_prefix_len (varstring
), varstring
);
776 fprintf_filtered (stream
, "<null type?>");
781 type
= ada_check_typedef (type
);
783 if (is_var_decl
&& TYPE_CODE (type
) != TYPE_CODE_FUNC
)
784 fprintf_filtered (stream
, "%.*s: ",
785 ada_name_prefix_len (varstring
), varstring
);
787 if (type_name
!= NULL
&& show
<= 0 && !ada_is_aligner_type (type
))
789 fprintf_filtered (stream
, "%.*s",
790 ada_name_prefix_len (type_name
), type_name
);
794 if (ada_is_aligner_type (type
))
795 ada_print_type (ada_aligned_type (type
), "", stream
, show
, level
, flags
);
796 else if (ada_is_constrained_packed_array_type (type
)
797 && TYPE_CODE (type
) != TYPE_CODE_PTR
)
798 print_array_type (type
, stream
, show
, level
, flags
);
800 switch (TYPE_CODE (type
))
803 fprintf_filtered (stream
, "<");
804 c_print_type (type
, "", stream
, show
, level
, flags
);
805 fprintf_filtered (stream
, ">");
808 case TYPE_CODE_TYPEDEF
:
809 fprintf_filtered (stream
, "access ");
810 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, show
, level
,
814 fprintf_filtered (stream
, "<ref> ");
815 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, show
, level
,
818 case TYPE_CODE_ARRAY
:
819 print_array_type (type
, stream
, show
, level
, flags
);
822 fprintf_filtered (stream
, "(false, true)");
825 if (ada_is_fixed_point_type (type
))
826 print_fixed_point_type (type
, stream
);
829 const char *name
= ada_type_name (type
);
831 if (!ada_is_range_type_name (name
))
832 fprintf_filtered (stream
, _("<%d-byte integer>"),
836 fprintf_filtered (stream
, "range ");
837 print_range_type (type
, stream
);
841 case TYPE_CODE_RANGE
:
842 if (ada_is_fixed_point_type (type
))
843 print_fixed_point_type (type
, stream
);
844 else if (ada_is_modular_type (type
))
845 fprintf_filtered (stream
, "mod %s",
846 int_string (ada_modulus (type
), 10, 0, 0, 1));
849 fprintf_filtered (stream
, "range ");
850 print_range (type
, stream
);
854 fprintf_filtered (stream
, _("<%d-byte float>"), TYPE_LENGTH (type
));
858 fprintf_filtered (stream
, "(...)");
860 print_enum_type (type
, stream
);
862 case TYPE_CODE_STRUCT
:
863 if (ada_is_array_descriptor_type (type
))
864 print_array_type (type
, stream
, show
, level
, flags
);
865 else if (ada_is_bogus_array_descriptor (type
))
866 fprintf_filtered (stream
,
867 _("array (?) of ? (<mal-formed descriptor>)"));
869 print_record_type (type
, stream
, show
, level
, flags
);
871 case TYPE_CODE_UNION
:
872 print_unchecked_union_type (type
, stream
, show
, level
, flags
);
875 print_func_type (type
, stream
, varstring
, flags
);
880 /* Implement the la_print_typedef language method for Ada. */
883 ada_print_typedef (struct type
*type
, struct symbol
*new_symbol
,
884 struct ui_file
*stream
)
886 type
= ada_check_typedef (type
);
887 ada_print_type (type
, "", stream
, 0, 0, &type_print_raw_options
);
888 fprintf_filtered (stream
, "\n");
This page took 0.074393 seconds and 4 git commands to generate.