1 /* Support for printing Ada types for GDB, the GNU debugger.
2 Copyright (C) 1986, 1988, 1989, 1991, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "gdb_obstack.h"
22 #include "bfd.h" /* Binary File Description */
25 #include "expression.h"
34 #include "typeprint.h"
38 #include "gdb_string.h"
41 static int print_record_field_types (struct type
*, struct type
*,
42 struct ui_file
*, int, int);
44 static void print_array_type (struct type
*, struct ui_file
*, int, int);
46 static void print_choices (struct type
*, int, struct ui_file
*,
49 static void print_range (struct type
*, struct ui_file
*);
51 static void print_range_bound (struct type
*, char *, int *,
55 print_dynamic_range_bound (struct type
*, const char *, int,
56 const char *, struct ui_file
*);
58 static void print_range_type_named (char *, struct type
*, struct ui_file
*);
62 static char *name_buffer
;
63 static int name_buffer_len
;
65 /* The (decoded) Ada name of TYPE. This value persists until the
69 decoded_type_name (struct type
*type
)
71 if (ada_type_name (type
) == NULL
)
75 char *raw_name
= ada_type_name (type
);
78 if (name_buffer
== NULL
|| name_buffer_len
<= strlen (raw_name
))
80 name_buffer_len
= 16 + 2 * strlen (raw_name
);
81 name_buffer
= xrealloc (name_buffer
, name_buffer_len
);
83 strcpy (name_buffer
, raw_name
);
85 s
= (char *) strstr (name_buffer
, "___");
89 s
= name_buffer
+ strlen (name_buffer
) - 1;
90 while (s
> name_buffer
&& (s
[0] != '_' || s
[-1] != '_'))
99 for (s
= q
= name_buffer
; *s
!= '\0'; q
+= 1)
101 if (s
[0] == '_' && s
[1] == '_')
117 /* Print TYPE on STREAM, preferably as a range. */
120 print_range (struct type
*type
, struct ui_file
*stream
)
122 switch (TYPE_CODE (type
))
124 case TYPE_CODE_RANGE
:
127 struct type
*target_type
;
128 target_type
= TYPE_TARGET_TYPE (type
);
129 if (target_type
== NULL
)
131 ada_print_scalar (target_type
, ada_discrete_type_low_bound (type
),
133 fprintf_filtered (stream
, " .. ");
134 ada_print_scalar (target_type
, ada_discrete_type_high_bound (type
),
139 fprintf_filtered (stream
, "%.*s",
140 ada_name_prefix_len (TYPE_NAME (type
)),
146 /* Print the number or discriminant bound at BOUNDS+*N on STREAM, and
147 set *N past the bound and its delimiter, if any. */
150 print_range_bound (struct type
*type
, char *bounds
, int *n
,
151 struct ui_file
*stream
)
154 if (ada_scan_number (bounds
, *n
, &B
, n
))
156 /* STABS decodes all range types which bounds are 0 .. -1 as
157 unsigned integers (ie. the type code is TYPE_CODE_INT, not
158 TYPE_CODE_RANGE). Unfortunately, ada_print_scalar() relies
159 on the unsigned flag to determine whether the bound should
160 be printed as a signed or an unsigned value. This causes
161 the upper bound of the 0 .. -1 range types to be printed as
162 a very large unsigned number instead of -1.
163 To workaround this stabs deficiency, we replace the TYPE by NULL
164 to indicate default output when we detect that the bound is negative,
165 and the type is a TYPE_CODE_INT. The bound is negative when
166 'm' is the last character of the number scanned in BOUNDS. */
167 if (bounds
[*n
- 1] == 'm' && TYPE_CODE (type
) == TYPE_CODE_INT
)
169 ada_print_scalar (type
, B
, stream
);
170 if (bounds
[*n
] == '_')
176 char *bound
= bounds
+ *n
;
179 pend
= strstr (bound
, "__");
181 *n
+= bound_len
= strlen (bound
);
184 bound_len
= pend
- bound
;
187 fprintf_filtered (stream
, "%.*s", bound_len
, bound
);
191 /* Assuming NAME[0 .. NAME_LEN-1] is the name of a range type, print
192 the value (if found) of the bound indicated by SUFFIX ("___L" or
193 "___U") according to the ___XD conventions. */
196 print_dynamic_range_bound (struct type
*type
, const char *name
, int name_len
,
197 const char *suffix
, struct ui_file
*stream
)
199 static char *name_buf
= NULL
;
200 static size_t name_buf_len
= 0;
204 GROW_VECT (name_buf
, name_buf_len
, name_len
+ strlen (suffix
) + 1);
205 strncpy (name_buf
, name
, name_len
);
206 strcpy (name_buf
+ name_len
, suffix
);
208 B
= get_int_var_value (name_buf
, &OK
);
210 ada_print_scalar (type
, B
, stream
);
212 fprintf_filtered (stream
, "?");
215 /* Print the range type named NAME. If symbol lookup fails, fall back
216 to ORIG_TYPE as base type. */
219 print_range_type_named (char *name
, struct type
*orig_type
,
220 struct ui_file
*stream
)
222 struct type
*raw_type
= ada_find_any_type (name
);
223 struct type
*base_type
;
226 if (raw_type
== NULL
)
227 raw_type
= orig_type
;
229 if (TYPE_CODE (raw_type
) == TYPE_CODE_RANGE
)
230 base_type
= TYPE_TARGET_TYPE (raw_type
);
232 base_type
= raw_type
;
234 subtype_info
= strstr (name
, "___XD");
235 if (subtype_info
== NULL
)
236 print_range (raw_type
, stream
);
239 int prefix_len
= subtype_info
- name
;
244 bounds_str
= strchr (subtype_info
, '_');
247 if (*subtype_info
== 'L')
249 print_range_bound (base_type
, bounds_str
, &n
, stream
);
253 print_dynamic_range_bound (base_type
, name
, prefix_len
, "___L",
256 fprintf_filtered (stream
, " .. ");
258 if (*subtype_info
== 'U')
259 print_range_bound (base_type
, bounds_str
, &n
, stream
);
261 print_dynamic_range_bound (base_type
, name
, prefix_len
, "___U",
266 /* Print enumerated type TYPE on STREAM. */
269 print_enum_type (struct type
*type
, struct ui_file
*stream
)
271 int len
= TYPE_NFIELDS (type
);
274 fprintf_filtered (stream
, "(");
278 for (i
= 0; i
< len
; i
++)
282 fprintf_filtered (stream
, ", ");
284 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type
, i
)), stream
);
285 if (lastval
!= TYPE_FIELD_BITPOS (type
, i
))
287 fprintf_filtered (stream
, " => %d", TYPE_FIELD_BITPOS (type
, i
));
288 lastval
= TYPE_FIELD_BITPOS (type
, i
);
292 fprintf_filtered (stream
, ")");
295 /* Print representation of Ada fixed-point type TYPE on STREAM. */
298 print_fixed_point_type (struct type
*type
, struct ui_file
*stream
)
300 DOUBLEST delta
= ada_delta (type
);
301 DOUBLEST small
= ada_fixed_to_float (type
, 1.0);
304 fprintf_filtered (stream
, "delta ??");
307 fprintf_filtered (stream
, "delta %g", (double) delta
);
309 fprintf_filtered (stream
, " <'small = %g>", (double) small
);
313 /* Print simple (constrained) array type TYPE on STREAM. LEVEL is the
314 recursion (indentation) level, in case the element type itself has
315 nested structure, and SHOW is the number of levels of internal
316 structure to show (see ada_print_type). */
319 print_array_type (struct type
*type
, struct ui_file
*stream
, int show
,
325 if (ada_is_constrained_packed_array_type (type
))
326 type
= ada_coerce_to_simple_array_type (type
);
329 fprintf_filtered (stream
, "array (");
333 fprintf_filtered (stream
, _("<undecipherable array type>"));
339 fprintf_filtered (stream
, "...");
342 if (ada_is_simple_array_type (type
))
344 struct type
*range_desc_type
=
345 ada_find_parallel_type (type
, "___XA");
346 struct type
*arr_type
;
349 if (range_desc_type
== NULL
)
351 for (arr_type
= type
; TYPE_CODE (arr_type
) == TYPE_CODE_ARRAY
;
352 arr_type
= TYPE_TARGET_TYPE (arr_type
))
354 if (arr_type
!= type
)
355 fprintf_filtered (stream
, ", ");
356 print_range (TYPE_INDEX_TYPE (arr_type
), stream
);
357 if (TYPE_FIELD_BITSIZE (arr_type
, 0) > 0)
358 bitsize
= TYPE_FIELD_BITSIZE (arr_type
, 0);
364 n_indices
= TYPE_NFIELDS (range_desc_type
);
365 for (k
= 0, arr_type
= type
;
367 k
+= 1, arr_type
= TYPE_TARGET_TYPE (arr_type
))
370 fprintf_filtered (stream
, ", ");
371 print_range_type_named (TYPE_FIELD_NAME
372 (range_desc_type
, k
),
373 TYPE_INDEX_TYPE (arr_type
), stream
);
374 if (TYPE_FIELD_BITSIZE (arr_type
, 0) > 0)
375 bitsize
= TYPE_FIELD_BITSIZE (arr_type
, 0);
382 for (i
= i0
= ada_array_arity (type
); i
> 0; i
-= 1)
383 fprintf_filtered (stream
, "%s<>", i
== i0
? "" : ", ");
387 fprintf_filtered (stream
, ") of ");
389 ada_print_type (ada_array_element_type (type
, n_indices
), "", stream
,
390 show
== 0 ? 0 : show
- 1, level
+ 1);
392 fprintf_filtered (stream
, " <packed: %d-bit elements>", bitsize
);
395 /* Print the choices encoded by field FIELD_NUM of variant-part TYPE on
396 STREAM, assuming that VAL_TYPE (if non-NULL) is the type of the values. */
399 print_choices (struct type
*type
, int field_num
, struct ui_file
*stream
,
400 struct type
*val_type
)
404 const char *name
= TYPE_FIELD_NAME (type
, field_num
);
408 /* Skip over leading 'V': NOTE soon to be obsolete. */
411 if (!ada_scan_number (name
, 1, NULL
, &p
))
427 fprintf_filtered (stream
, " | ");
437 if (!ada_scan_number (name
, p
+ 1, &W
, &p
))
439 ada_print_scalar (val_type
, W
, stream
);
445 if (!ada_scan_number (name
, p
+ 1, &L
, &p
)
446 || name
[p
] != 'T' || !ada_scan_number (name
, p
+ 1, &U
, &p
))
448 ada_print_scalar (val_type
, L
, stream
);
449 fprintf_filtered (stream
, " .. ");
450 ada_print_scalar (val_type
, U
, stream
);
454 fprintf_filtered (stream
, "others");
461 fprintf_filtered (stream
, "??");
465 /* Assuming that field FIELD_NUM of TYPE is a VARIANTS field whose
466 discriminant is contained in OUTER_TYPE, print its variants on STREAM.
467 LEVEL is the recursion
468 (indentation) level, in case any of the fields themselves have
469 nested structure, and SHOW is the number of levels of internal structure
470 to show (see ada_print_type). For this purpose, fields nested in a
471 variant part are taken to be at the same level as the fields
472 immediately outside the variant part. */
475 print_variant_clauses (struct type
*type
, int field_num
,
476 struct type
*outer_type
, struct ui_file
*stream
,
480 struct type
*var_type
, *par_type
;
481 struct type
*discr_type
;
483 var_type
= TYPE_FIELD_TYPE (type
, field_num
);
484 discr_type
= ada_variant_discrim_type (var_type
, outer_type
);
486 if (TYPE_CODE (var_type
) == TYPE_CODE_PTR
)
488 var_type
= TYPE_TARGET_TYPE (var_type
);
489 if (var_type
== NULL
|| TYPE_CODE (var_type
) != TYPE_CODE_UNION
)
493 par_type
= ada_find_parallel_type (var_type
, "___XVU");
494 if (par_type
!= NULL
)
497 for (i
= 0; i
< TYPE_NFIELDS (var_type
); i
+= 1)
499 fprintf_filtered (stream
, "\n%*swhen ", level
+ 4, "");
500 print_choices (var_type
, i
, stream
, discr_type
);
501 fprintf_filtered (stream
, " =>");
502 if (print_record_field_types (TYPE_FIELD_TYPE (var_type
, i
),
503 outer_type
, stream
, show
, level
+ 4) <= 0)
504 fprintf_filtered (stream
, " null;");
508 /* Assuming that field FIELD_NUM of TYPE is a variant part whose
509 discriminants are contained in OUTER_TYPE, print a description of it
510 on STREAM. LEVEL is the recursion (indentation) level, in case any of
511 the fields themselves have nested structure, and SHOW is the number of
512 levels of internal structure to show (see ada_print_type). For this
513 purpose, fields nested in a variant part are taken to be at the same
514 level as the fields immediately outside the variant part. */
517 print_variant_part (struct type
*type
, int field_num
, struct type
*outer_type
,
518 struct ui_file
*stream
, int show
, int level
)
520 fprintf_filtered (stream
, "\n%*scase %s is", level
+ 4, "",
521 ada_variant_discrim_name
522 (TYPE_FIELD_TYPE (type
, field_num
)));
523 print_variant_clauses (type
, field_num
, outer_type
, stream
, show
,
525 fprintf_filtered (stream
, "\n%*send case;", level
+ 4, "");
528 /* Print a description on STREAM of the fields in record type TYPE, whose
529 discriminants are in OUTER_TYPE. LEVEL is the recursion (indentation)
530 level, in case any of the fields themselves have nested structure,
531 and SHOW is the number of levels of internal structure to show
532 (see ada_print_type). Does not print parent type information of TYPE.
533 Returns 0 if no fields printed, -1 for an incomplete type, else > 0.
534 Prints each field beginning on a new line, but does not put a new line at
538 print_record_field_types (struct type
*type
, struct type
*outer_type
,
539 struct ui_file
*stream
, int show
, int level
)
544 len
= TYPE_NFIELDS (type
);
546 if (len
== 0 && TYPE_STUB (type
))
549 for (i
= 0; i
< len
; i
+= 1)
553 if (ada_is_parent_field (type
, i
) || ada_is_ignored_field (type
, i
))
555 else if (ada_is_wrapper_field (type
, i
))
556 flds
+= print_record_field_types (TYPE_FIELD_TYPE (type
, i
), type
,
557 stream
, show
, level
);
558 else if (ada_is_variant_part (type
, i
))
560 print_variant_part (type
, i
, outer_type
, stream
, show
, level
);
566 fprintf_filtered (stream
, "\n%*s", level
+ 4, "");
567 ada_print_type (TYPE_FIELD_TYPE (type
, i
),
568 TYPE_FIELD_NAME (type
, i
),
569 stream
, show
- 1, level
+ 4);
570 fprintf_filtered (stream
, ";");
577 /* Print record type TYPE on STREAM. LEVEL is the recursion (indentation)
578 level, in case the element type itself has nested structure, and SHOW is
579 the number of levels of internal structure to show (see ada_print_type). */
582 print_record_type (struct type
*type0
, struct ui_file
*stream
, int show
,
585 struct type
*parent_type
;
588 type
= ada_find_parallel_type (type0
, "___XVE");
592 parent_type
= ada_parent_type (type
);
593 if (ada_type_name (parent_type
) != NULL
)
594 fprintf_filtered (stream
, "new %s with record",
595 decoded_type_name (parent_type
));
596 else if (parent_type
== NULL
&& ada_is_tagged_type (type
, 0))
597 fprintf_filtered (stream
, "tagged record");
599 fprintf_filtered (stream
, "record");
602 fprintf_filtered (stream
, " ... end record");
608 if (parent_type
!= NULL
&& ada_type_name (parent_type
) == NULL
)
609 flds
+= print_record_field_types (parent_type
, parent_type
,
610 stream
, show
, level
);
611 flds
+= print_record_field_types (type
, type
, stream
, show
, level
);
614 fprintf_filtered (stream
, "\n%*send record", level
, "");
616 fprintf_filtered (stream
, _(" <incomplete type> end record"));
618 fprintf_filtered (stream
, " null; end record");
622 /* Print the unchecked union type TYPE in something resembling Ada
623 format on STREAM. LEVEL is the recursion (indentation) level
624 in case the element type itself has nested structure, and SHOW is the
625 number of levels of internal structure to show (see ada_print_type). */
627 print_unchecked_union_type (struct type
*type
, struct ui_file
*stream
,
631 fprintf_filtered (stream
, "record (?) is ... end record");
632 else if (TYPE_NFIELDS (type
) == 0)
633 fprintf_filtered (stream
, "record (?) is null; end record");
638 fprintf_filtered (stream
, "record (?) is\n%*scase ? is", level
+ 4, "");
640 for (i
= 0; i
< TYPE_NFIELDS (type
); i
+= 1)
642 fprintf_filtered (stream
, "\n%*swhen ? =>\n%*s", level
+ 8, "",
644 ada_print_type (TYPE_FIELD_TYPE (type
, i
),
645 TYPE_FIELD_NAME (type
, i
),
646 stream
, show
- 1, level
+ 12);
647 fprintf_filtered (stream
, ";");
650 fprintf_filtered (stream
, "\n%*send case;\n%*send record",
651 level
+ 4, "", level
, "");
657 /* Print function or procedure type TYPE on STREAM. Make it a header
658 for function or procedure NAME if NAME is not null. */
661 print_func_type (struct type
*type
, struct ui_file
*stream
, char *name
)
663 int i
, len
= TYPE_NFIELDS (type
);
665 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_VOID
)
666 fprintf_filtered (stream
, "procedure");
668 fprintf_filtered (stream
, "function");
670 if (name
!= NULL
&& name
[0] != '\0')
671 fprintf_filtered (stream
, " %s", name
);
675 fprintf_filtered (stream
, " (");
676 for (i
= 0; i
< len
; i
+= 1)
680 fputs_filtered ("; ", stream
);
683 fprintf_filtered (stream
, "a%d: ", i
+ 1);
684 ada_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0);
686 fprintf_filtered (stream
, ")");
689 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_VOID
)
691 fprintf_filtered (stream
, " return ");
692 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, 0, 0);
697 /* Print a description of a type TYPE0.
698 Output goes to STREAM (via stdio).
699 If VARSTRING is a non-empty string, print as an Ada variable/field
701 SHOW+1 is the maximum number of levels of internal type structure
702 to show (this applies to record types, enumerated types, and
704 SHOW is the number of levels of internal type structure to show
705 when there is a type name for the SHOWth deepest level (0th is
707 When SHOW<0, no inner structure is shown.
708 LEVEL indicates level of recursion (for nested definitions). */
711 ada_print_type (struct type
*type0
, char *varstring
, struct ui_file
*stream
,
714 struct type
*type
= ada_check_typedef (ada_get_base_type (type0
));
715 char *type_name
= decoded_type_name (type0
);
716 int is_var_decl
= (varstring
!= NULL
&& varstring
[0] != '\0');
721 fprintf_filtered (stream
, "%.*s: ",
722 ada_name_prefix_len (varstring
), varstring
);
723 fprintf_filtered (stream
, "<null type?>");
728 type
= ada_check_typedef (type
);
730 if (is_var_decl
&& TYPE_CODE (type
) != TYPE_CODE_FUNC
)
731 fprintf_filtered (stream
, "%.*s: ",
732 ada_name_prefix_len (varstring
), varstring
);
734 if (type_name
!= NULL
&& show
<= 0)
736 fprintf_filtered (stream
, "%.*s",
737 ada_name_prefix_len (type_name
), type_name
);
741 if (ada_is_aligner_type (type
))
742 ada_print_type (ada_aligned_type (type
), "", stream
, show
, level
);
743 else if (ada_is_constrained_packed_array_type (type
))
745 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
747 fprintf_filtered (stream
, "access ");
748 print_array_type (TYPE_TARGET_TYPE (type
), stream
, show
, level
);
752 print_array_type (type
, stream
, show
, level
);
756 switch (TYPE_CODE (type
))
759 fprintf_filtered (stream
, "<");
760 c_print_type (type
, "", stream
, show
, level
);
761 fprintf_filtered (stream
, ">");
764 fprintf_filtered (stream
, "access ");
765 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, show
, level
);
768 fprintf_filtered (stream
, "<ref> ");
769 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, show
, level
);
771 case TYPE_CODE_ARRAY
:
772 print_array_type (type
, stream
, show
, level
);
775 fprintf_filtered (stream
, "(false, true)");
778 if (ada_is_fixed_point_type (type
))
779 print_fixed_point_type (type
, stream
);
782 char *name
= ada_type_name (type
);
783 if (!ada_is_range_type_name (name
))
784 fprintf_filtered (stream
, _("<%d-byte integer>"),
788 fprintf_filtered (stream
, "range ");
789 print_range_type_named (name
, type
, stream
);
793 case TYPE_CODE_RANGE
:
794 if (ada_is_fixed_point_type (type
))
795 print_fixed_point_type (type
, stream
);
796 else if (ada_is_modular_type (type
))
797 fprintf_filtered (stream
, "mod %s",
798 int_string (ada_modulus (type
), 10, 0, 0, 1));
801 fprintf_filtered (stream
, "range ");
802 print_range (type
, stream
);
806 fprintf_filtered (stream
, _("<%d-byte float>"), TYPE_LENGTH (type
));
810 fprintf_filtered (stream
, "(...)");
812 print_enum_type (type
, stream
);
814 case TYPE_CODE_STRUCT
:
815 if (ada_is_array_descriptor_type (type
))
816 print_array_type (type
, stream
, show
, level
);
817 else if (ada_is_bogus_array_descriptor (type
))
818 fprintf_filtered (stream
,
819 _("array (?) of ? (<mal-formed descriptor>)"));
821 print_record_type (type
, stream
, show
, level
);
823 case TYPE_CODE_UNION
:
824 print_unchecked_union_type (type
, stream
, show
, level
);
827 print_func_type (type
, stream
, varstring
);
This page took 0.046773 seconds and 4 git commands to generate.