/* Support for printing Ada types for GDB, the GNU debugger.
- Copyright (C) 1986, 1988, 1989, 1991, 1997, 1998, 1999, 2000, 2001, 2002,
- 2003, 2004, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
+ Copyright (C) 1986-2020 Free Software Foundation, Inc.
This file is part of GDB.
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
-#include "gdb_obstack.h"
#include "bfd.h" /* Binary File Description */
-#include "symtab.h"
#include "gdbtypes.h"
-#include "expression.h"
#include "value.h"
-#include "gdbcore.h"
-#include "target.h"
-#include "command.h"
-#include "gdbcmd.h"
-#include "language.h"
-#include "demangle.h"
#include "c-lang.h"
+#include "cli/cli-style.h"
#include "typeprint.h"
+#include "target-float.h"
#include "ada-lang.h"
-
#include <ctype.h>
-#include "gdb_string.h"
-#include <errno.h>
static int print_selected_record_field_types (struct type *, struct type *,
int, int,
- struct ui_file *, int, int);
-
-static int print_record_field_types (struct type *, struct type *,
- struct ui_file *, int, int);
-
-static void print_array_type (struct type *, struct ui_file *, int, int);
-
-static int print_choices (struct type *, int, struct ui_file *,
- struct type *);
-
-static void print_range (struct type *, struct ui_file *);
+ struct ui_file *, int, int,
+ const struct type_print_options *);
-static void print_range_bound (struct type *, char *, int *,
- struct ui_file *);
-
-static void
-print_dynamic_range_bound (struct type *, const char *, int,
- const char *, struct ui_file *);
-
-static void print_range_type (struct type *, struct ui_file *);
+static int print_record_field_types (struct type *, struct type *,
+ struct ui_file *, int, int,
+ const struct type_print_options *);
\f
return NULL;
else
{
- char *raw_name = ada_type_name (type);
+ const char *raw_name = ada_type_name (type);
char *s, *q;
if (name_buffer == NULL || name_buffer_len <= strlen (raw_name))
{
name_buffer_len = 16 + 2 * strlen (raw_name);
- name_buffer = xrealloc (name_buffer, name_buffer_len);
+ name_buffer = (char *) xrealloc (name_buffer, name_buffer_len);
}
strcpy (name_buffer, raw_name);
}
}
-/* Print TYPE on STREAM, preferably as a range. */
+/* Return nonzero if TYPE is a subrange type, and its bounds
+ are identical to the bounds of its subtype. */
+
+static int
+type_is_full_subrange_of_target_type (struct type *type)
+{
+ struct type *subtype;
+
+ if (type->code () != TYPE_CODE_RANGE)
+ return 0;
+
+ subtype = TYPE_TARGET_TYPE (type);
+ if (subtype == NULL)
+ return 0;
+
+ if (is_dynamic_type (type))
+ return 0;
+
+ if (ada_discrete_type_low_bound (type)
+ != ada_discrete_type_low_bound (subtype))
+ return 0;
+
+ if (ada_discrete_type_high_bound (type)
+ != ada_discrete_type_high_bound (subtype))
+ return 0;
+
+ return 1;
+}
+
+/* Print TYPE on STREAM, preferably as a range if BOUNDS_PREFERED_P
+ is nonzero. */
static void
-print_range (struct type *type, struct ui_file *stream)
+print_range (struct type *type, struct ui_file *stream,
+ int bounds_prefered_p)
{
- switch (TYPE_CODE (type))
+ if (!bounds_prefered_p)
+ {
+ /* Try stripping all TYPE_CODE_RANGE layers whose bounds
+ are identical to the bounds of their subtype. When
+ the bounds of both types match, it can allow us to
+ print a range using the name of its base type, which
+ is easier to read. For instance, we would print...
+
+ array (character) of ...
+
+ ... instead of...
+
+ array ('["00"]' .. '["ff"]') of ... */
+ while (type_is_full_subrange_of_target_type (type))
+ type = TYPE_TARGET_TYPE (type);
+ }
+
+ switch (type->code ())
{
case TYPE_CODE_RANGE:
case TYPE_CODE_ENUM:
{
- struct type *target_type;
- target_type = TYPE_TARGET_TYPE (type);
- if (target_type == NULL)
- target_type = type;
- ada_print_scalar (target_type, ada_discrete_type_low_bound (type),
- stream);
- fprintf_filtered (stream, " .. ");
- ada_print_scalar (target_type, ada_discrete_type_high_bound (type),
- stream);
+ LONGEST lo = 0, hi = 0; /* init for gcc -Wall */
+ int got_error = 0;
+
+ try
+ {
+ lo = ada_discrete_type_low_bound (type);
+ hi = ada_discrete_type_high_bound (type);
+ }
+ catch (const gdb_exception_error &e)
+ {
+ /* This can happen when the range is dynamic. Sometimes,
+ resolving dynamic property values requires us to have
+ access to an actual object, which is not available
+ when the user is using the "ptype" command on a type.
+ Print the range as an unbounded range. */
+ fprintf_filtered (stream, "<>");
+ got_error = 1;
+ }
+
+ if (!got_error)
+ {
+ ada_print_scalar (type, lo, stream);
+ fprintf_filtered (stream, " .. ");
+ ada_print_scalar (type, hi, stream);
+ }
}
break;
default:
fprintf_filtered (stream, "%.*s",
- ada_name_prefix_len (TYPE_NAME (type)),
- TYPE_NAME (type));
+ ada_name_prefix_len (type->name ()),
+ type->name ());
break;
}
}
set *N past the bound and its delimiter, if any. */
static void
-print_range_bound (struct type *type, char *bounds, int *n,
+print_range_bound (struct type *type, const char *bounds, int *n,
struct ui_file *stream)
{
LONGEST B;
to indicate default output when we detect that the bound is negative,
and the type is a TYPE_CODE_INT. The bound is negative when
'm' is the last character of the number scanned in BOUNDS. */
- if (bounds[*n - 1] == 'm' && TYPE_CODE (type) == TYPE_CODE_INT)
+ if (bounds[*n - 1] == 'm' && type->code () == TYPE_CODE_INT)
type = NULL;
ada_print_scalar (type, B, stream);
if (bounds[*n] == '_')
else
{
int bound_len;
- char *bound = bounds + *n;
- char *pend;
+ const char *bound = bounds + *n;
+ const char *pend;
pend = strstr (bound, "__");
if (pend == NULL)
print_dynamic_range_bound (struct type *type, const char *name, int name_len,
const char *suffix, struct ui_file *stream)
{
- static char *name_buf = NULL;
- static size_t name_buf_len = 0;
LONGEST B;
- int OK;
+ std::string name_buf (name, name_len);
+ name_buf += suffix;
- GROW_VECT (name_buf, name_buf_len, name_len + strlen (suffix) + 1);
- strncpy (name_buf, name, name_len);
- strcpy (name_buf + name_len, suffix);
-
- B = get_int_var_value (name_buf, &OK);
- if (OK)
+ if (get_int_var_value (name_buf.c_str (), B))
ada_print_scalar (type, B, stream);
else
fprintf_filtered (stream, "?");
}
/* Print RAW_TYPE as a range type, using any bound information
- following the GNAT encoding (if available). */
+ following the GNAT encoding (if available).
+
+ If BOUNDS_PREFERED_P is nonzero, force the printing of the range
+ using its bounds. Otherwise, try printing the range without
+ printing the value of the bounds, if possible (this is only
+ considered a hint, not a guaranty). */
static void
-print_range_type (struct type *raw_type, struct ui_file *stream)
+print_range_type (struct type *raw_type, struct ui_file *stream,
+ int bounds_prefered_p)
{
- char *name;
+ const char *name;
struct type *base_type;
- char *subtype_info;
+ const char *subtype_info;
gdb_assert (raw_type != NULL);
- name = TYPE_NAME (raw_type);
+ name = raw_type->name ();
gdb_assert (name != NULL);
- if (TYPE_CODE (raw_type) == TYPE_CODE_RANGE)
+ if (raw_type->code () == TYPE_CODE_RANGE)
base_type = TYPE_TARGET_TYPE (raw_type);
else
base_type = raw_type;
subtype_info = strstr (name, "___XD");
if (subtype_info == NULL)
- print_range (raw_type, stream);
+ print_range (raw_type, stream, bounds_prefered_p);
else
{
int prefix_len = subtype_info - name;
- char *bounds_str;
+ const char *bounds_str;
int n;
subtype_info += 5;
static void
print_enum_type (struct type *type, struct ui_file *stream)
{
- int len = TYPE_NFIELDS (type);
- int i, lastval;
+ int len = type->num_fields ();
+ int i;
+ LONGEST lastval;
fprintf_filtered (stream, "(");
wrap_here (" ");
if (i)
fprintf_filtered (stream, ", ");
wrap_here (" ");
- fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type, i)), stream);
- if (lastval != TYPE_FIELD_BITPOS (type, i))
+ fputs_styled (ada_enum_name (TYPE_FIELD_NAME (type, i)),
+ variable_name_style.style (), stream);
+ if (lastval != TYPE_FIELD_ENUMVAL (type, i))
{
- fprintf_filtered (stream, " => %d", TYPE_FIELD_BITPOS (type, i));
- lastval = TYPE_FIELD_BITPOS (type, i);
+ fprintf_filtered (stream, " => %s",
+ plongest (TYPE_FIELD_ENUMVAL (type, i)));
+ lastval = TYPE_FIELD_ENUMVAL (type, i);
}
lastval += 1;
}
/* Print representation of Ada fixed-point type TYPE on STREAM. */
static void
-print_fixed_point_type (struct type *type, struct ui_file *stream)
+print_gnat_encoded_fixed_point_type (struct type *type, struct ui_file *stream)
{
- DOUBLEST delta = ada_delta (type);
- DOUBLEST small = ada_fixed_to_float (type, 1.0);
+ struct value *delta = gnat_encoded_fixed_point_delta (type);
+ struct value *small = ada_scaling_factor (type);
- if (delta < 0.0)
+ if (delta == nullptr)
fprintf_filtered (stream, "delta ??");
else
{
- fprintf_filtered (stream, "delta %g", (double) delta);
- if (delta != small)
- fprintf_filtered (stream, " <'small = %g>", (double) small);
+ std::string str;
+ str = target_float_to_string (value_contents (delta),
+ value_type (delta), "%g");
+ fprintf_filtered (stream, "delta %s", str.c_str());
+ if (!value_equal (delta, small))
+ {
+ str = target_float_to_string (value_contents (small),
+ value_type (small), "%g");
+ fprintf_filtered (stream, " <'small = %s>", str.c_str());
+ }
}
}
static void
print_array_type (struct type *type, struct ui_file *stream, int show,
- int level)
+ int level, const struct type_print_options *flags)
{
int bitsize;
int n_indices;
+ struct type *elt_type = NULL;
if (ada_is_constrained_packed_array_type (type))
type = ada_coerce_to_simple_array_type (type);
if (type == NULL)
{
- fprintf_filtered (stream, _("<undecipherable array type>"));
+ fprintf_styled (stream, metadata_style.style (),
+ _("<undecipherable array type>"));
return;
}
bitsize = 0;
if (range_desc_type == NULL)
{
- for (arr_type = type; TYPE_CODE (arr_type) == TYPE_CODE_ARRAY;
+ for (arr_type = type; arr_type->code () == TYPE_CODE_ARRAY;
arr_type = TYPE_TARGET_TYPE (arr_type))
{
if (arr_type != type)
fprintf_filtered (stream, ", ");
- print_range (TYPE_INDEX_TYPE (arr_type), stream);
+ print_range (TYPE_INDEX_TYPE (arr_type), stream,
+ 0 /* bounds_prefered_p */);
if (TYPE_FIELD_BITSIZE (arr_type, 0) > 0)
bitsize = TYPE_FIELD_BITSIZE (arr_type, 0);
}
{
int k;
- n_indices = TYPE_NFIELDS (range_desc_type);
+ n_indices = range_desc_type->num_fields ();
for (k = 0, arr_type = type;
k < n_indices;
k += 1, arr_type = TYPE_TARGET_TYPE (arr_type))
if (k > 0)
fprintf_filtered (stream, ", ");
print_range_type (TYPE_FIELD_TYPE (range_desc_type, k),
- stream);
+ stream, 0 /* bounds_prefered_p */);
if (TYPE_FIELD_BITSIZE (arr_type, 0) > 0)
bitsize = TYPE_FIELD_BITSIZE (arr_type, 0);
}
fprintf_filtered (stream, "%s<>", i == i0 ? "" : ", ");
}
+ elt_type = ada_array_element_type (type, n_indices);
fprintf_filtered (stream, ") of ");
wrap_here ("");
- ada_print_type (ada_array_element_type (type, n_indices), "", stream,
- show == 0 ? 0 : show - 1, level + 1);
- if (bitsize > 0)
+ ada_print_type (elt_type, "", stream, show == 0 ? 0 : show - 1, level + 1,
+ flags);
+ /* Arrays with variable-length elements are never bit-packed in practice but
+ compilers have to describe their stride so that we can properly fetch
+ individual elements. Do not say the array is packed in this case. */
+ if (bitsize > 0 && !is_dynamic_type (elt_type))
fprintf_filtered (stream, " <packed: %d-bit elements>", bitsize);
}
values. Return non-zero if the field is an encoding of
discriminant values, as in a standard variant record, and 0 if the
field is not so encoded (as happens with single-component variants
- in types annotated with pragma Unchecked_Variant). */
+ in types annotated with pragma Unchecked_Union). */
static int
print_choices (struct type *type, int field_num, struct ui_file *stream,
}
Huh:
- fprintf_filtered (stream, "?? =>");
+ fprintf_filtered (stream, "? =>");
return 0;
}
static void
print_variant_clauses (struct type *type, int field_num,
struct type *outer_type, struct ui_file *stream,
- int show, int level)
+ int show, int level,
+ const struct type_print_options *flags)
{
int i;
struct type *var_type, *par_type;
var_type = TYPE_FIELD_TYPE (type, field_num);
discr_type = ada_variant_discrim_type (var_type, outer_type);
- if (TYPE_CODE (var_type) == TYPE_CODE_PTR)
+ if (var_type->code () == TYPE_CODE_PTR)
{
var_type = TYPE_TARGET_TYPE (var_type);
- if (var_type == NULL || TYPE_CODE (var_type) != TYPE_CODE_UNION)
+ if (var_type == NULL || var_type->code () != TYPE_CODE_UNION)
return;
}
if (par_type != NULL)
var_type = par_type;
- for (i = 0; i < TYPE_NFIELDS (var_type); i += 1)
+ for (i = 0; i < var_type->num_fields (); i += 1)
{
fprintf_filtered (stream, "\n%*swhen ", level + 4, "");
if (print_choices (var_type, i, stream, discr_type))
{
if (print_record_field_types (TYPE_FIELD_TYPE (var_type, i),
- outer_type, stream, show, level + 4)
+ outer_type, stream, show, level + 4,
+ flags)
<= 0)
fprintf_filtered (stream, " null;");
}
else
print_selected_record_field_types (var_type, outer_type, i, i,
- stream, show, level + 4);
+ stream, show, level + 4, flags);
}
}
static void
print_variant_part (struct type *type, int field_num, struct type *outer_type,
- struct ui_file *stream, int show, int level)
+ struct ui_file *stream, int show, int level,
+ const struct type_print_options *flags)
{
- fprintf_filtered (stream, "\n%*scase %s is", level + 4, "",
- ada_variant_discrim_name
- (TYPE_FIELD_TYPE (type, field_num)));
+ const char *variant
+ = ada_variant_discrim_name (TYPE_FIELD_TYPE (type, field_num));
+ if (*variant == '\0')
+ variant = "?";
+
+ fprintf_filtered (stream, "\n%*scase %s is", level + 4, "", variant);
print_variant_clauses (type, field_num, outer_type, stream, show,
- level + 4);
+ level + 4, flags);
fprintf_filtered (stream, "\n%*send case;", level + 4, "");
}
static int
print_selected_record_field_types (struct type *type, struct type *outer_type,
int fld0, int fld1,
- struct ui_file *stream, int show, int level)
+ struct ui_file *stream, int show, int level,
+ const struct type_print_options *flags)
{
int i, flds;
;
else if (ada_is_wrapper_field (type, i))
flds += print_record_field_types (TYPE_FIELD_TYPE (type, i), type,
- stream, show, level);
+ stream, show, level, flags);
else if (ada_is_variant_part (type, i))
{
- print_variant_part (type, i, outer_type, stream, show, level);
+ print_variant_part (type, i, outer_type, stream, show, level, flags);
flds = 1;
}
else
fprintf_filtered (stream, "\n%*s", level + 4, "");
ada_print_type (TYPE_FIELD_TYPE (type, i),
TYPE_FIELD_NAME (type, i),
- stream, show - 1, level + 4);
+ stream, show - 1, level + 4, flags);
fprintf_filtered (stream, ";");
}
}
return flds;
}
+static void print_record_field_types_dynamic
+ (const gdb::array_view<variant_part> &parts,
+ int from, int to, struct type *type, struct ui_file *stream,
+ int show, int level, const struct type_print_options *flags);
+
+/* Print the choices encoded by VARIANT on STREAM. LEVEL is the
+ indentation level. The type of the discriminant for VARIANT is
+ given by DISR_TYPE. */
+
+static void
+print_choices (struct type *discr_type, const variant &variant,
+ struct ui_file *stream, int level)
+{
+ fprintf_filtered (stream, "\n%*swhen ", level, "");
+ if (variant.is_default ())
+ fprintf_filtered (stream, "others");
+ else
+ {
+ bool first = true;
+ for (const discriminant_range &range : variant.discriminants)
+ {
+ if (!first)
+ fprintf_filtered (stream, " | ");
+ first = false;
+
+ ada_print_scalar (discr_type, range.low, stream);
+ if (range.low != range.high)
+ ada_print_scalar (discr_type, range.high, stream);
+ }
+ }
+
+ fprintf_filtered (stream, " =>");
+}
+
+/* Print a single variant part, PART, on STREAM. TYPE is the
+ enclosing type. SHOW, LEVEL, and FLAGS are the usual type-printing
+ settings. This prints information about PART and the fields it
+ controls. It returns the index of the next field that should be
+ shown -- that is, one after the last field printed by this
+ call. */
+
+static int
+print_variant_part (const variant_part &part,
+ struct type *type, struct ui_file *stream,
+ int show, int level,
+ const struct type_print_options *flags)
+{
+ struct type *discr_type = nullptr;
+ const char *name;
+ if (part.discriminant_index == -1)
+ name = "?";
+ else
+ {
+ name = TYPE_FIELD_NAME (type, part.discriminant_index);
+ discr_type = TYPE_FIELD_TYPE (type, part.discriminant_index);
+ }
+
+ fprintf_filtered (stream, "\n%*scase %s is", level + 4, "", name);
+
+ int last_field = -1;
+ for (const variant &variant : part.variants)
+ {
+ print_choices (discr_type, variant, stream, level + 8);
+
+ if (variant.first_field == variant.last_field)
+ fprintf_filtered (stream, " null;");
+ else
+ {
+ print_record_field_types_dynamic (variant.parts,
+ variant.first_field,
+ variant.last_field, type, stream,
+ show, level + 8, flags);
+ last_field = variant.last_field;
+ }
+ }
+
+ fprintf_filtered (stream, "\n%*send case;", level + 4, "");
+
+ return last_field;
+}
+
+/* Print some fields of TYPE to STREAM. SHOW, LEVEL, and FLAGS are
+ the usual type-printing settings. PARTS is the array of variant
+ parts that correspond to the range of fields to be printed. FROM
+ and TO are the range of fields to print. */
+
+static void
+print_record_field_types_dynamic (const gdb::array_view<variant_part> &parts,
+ int from, int to,
+ struct type *type, struct ui_file *stream,
+ int show, int level,
+ const struct type_print_options *flags)
+{
+ int field = from;
+
+ for (const variant_part &part : parts)
+ {
+ if (part.variants.empty ())
+ continue;
+
+ /* Print any non-varying fields. */
+ int first_varying = part.variants[0].first_field;
+ print_selected_record_field_types (type, type, field,
+ first_varying - 1, stream,
+ show, level, flags);
+
+ field = print_variant_part (part, type, stream, show, level, flags);
+ }
+
+ /* Print any trailing fields that we were asked to print. */
+ print_selected_record_field_types (type, type, field, to - 1, stream, show,
+ level, flags);
+}
+
/* Print a description on STREAM of all fields of record or union type
TYPE, as for print_selected_record_field_types, above. */
static int
print_record_field_types (struct type *type, struct type *outer_type,
- struct ui_file *stream, int show, int level)
+ struct ui_file *stream, int show, int level,
+ const struct type_print_options *flags)
{
+ struct dynamic_prop *prop = type->dyn_prop (DYN_PROP_VARIANT_PARTS);
+ if (prop != nullptr)
+ {
+ if (prop->kind == PROP_TYPE)
+ {
+ type = prop->data.original_type;
+ prop = type->dyn_prop (DYN_PROP_VARIANT_PARTS);
+ }
+ gdb_assert (prop->kind == PROP_VARIANT_PARTS);
+ print_record_field_types_dynamic (*prop->data.variant_parts,
+ 0, type->num_fields (),
+ type, stream, show, level, flags);
+ return type->num_fields ();
+ }
+
return print_selected_record_field_types (type, outer_type,
- 0, TYPE_NFIELDS (type) - 1,
- stream, show, level);
+ 0, type->num_fields () - 1,
+ stream, show, level, flags);
}
static void
print_record_type (struct type *type0, struct ui_file *stream, int show,
- int level)
+ int level, const struct type_print_options *flags)
{
struct type *parent_type;
struct type *type;
flds = 0;
if (parent_type != NULL && ada_type_name (parent_type) == NULL)
flds += print_record_field_types (parent_type, parent_type,
- stream, show, level);
- flds += print_record_field_types (type, type, stream, show, level);
+ stream, show, level, flags);
+ flds += print_record_field_types (type, type, stream, show, level,
+ flags);
if (flds > 0)
fprintf_filtered (stream, "\n%*send record", level, "");
number of levels of internal structure to show (see ada_print_type). */
static void
print_unchecked_union_type (struct type *type, struct ui_file *stream,
- int show, int level)
+ int show, int level,
+ const struct type_print_options *flags)
{
if (show < 0)
fprintf_filtered (stream, "record (?) is ... end record");
- else if (TYPE_NFIELDS (type) == 0)
+ else if (type->num_fields () == 0)
fprintf_filtered (stream, "record (?) is null; end record");
else
{
fprintf_filtered (stream, "record (?) is\n%*scase ? is", level + 4, "");
- for (i = 0; i < TYPE_NFIELDS (type); i += 1)
+ for (i = 0; i < type->num_fields (); i += 1)
{
fprintf_filtered (stream, "\n%*swhen ? =>\n%*s", level + 8, "",
level + 12, "");
ada_print_type (TYPE_FIELD_TYPE (type, i),
TYPE_FIELD_NAME (type, i),
- stream, show - 1, level + 12);
+ stream, show - 1, level + 12, flags);
fprintf_filtered (stream, ";");
}
for function or procedure NAME if NAME is not null. */
static void
-print_func_type (struct type *type, struct ui_file *stream, const char *name)
+print_func_type (struct type *type, struct ui_file *stream, const char *name,
+ const struct type_print_options *flags)
{
- int i, len = TYPE_NFIELDS (type);
+ int i, len = type->num_fields ();
- if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_VOID)
+ if (TYPE_TARGET_TYPE (type) != NULL
+ && TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_VOID)
fprintf_filtered (stream, "procedure");
else
fprintf_filtered (stream, "function");
if (name != NULL && name[0] != '\0')
- fprintf_filtered (stream, " %s", name);
+ {
+ fputs_filtered (" ", stream);
+ fputs_styled (name, function_name_style.style (), stream);
+ }
if (len > 0)
{
wrap_here (" ");
}
fprintf_filtered (stream, "a%d: ", i + 1);
- ada_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0);
+ ada_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0,
+ flags);
}
fprintf_filtered (stream, ")");
}
- if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_VOID)
+ if (TYPE_TARGET_TYPE (type) == NULL)
+ fprintf_filtered (stream, " return <unknown return type>");
+ else if (TYPE_TARGET_TYPE (type)->code () != TYPE_CODE_VOID)
{
fprintf_filtered (stream, " return ");
- ada_print_type (TYPE_TARGET_TYPE (type), "", stream, 0, 0);
+ ada_print_type (TYPE_TARGET_TYPE (type), "", stream, 0, 0, flags);
}
}
void
ada_print_type (struct type *type0, const char *varstring,
- struct ui_file *stream, int show, int level)
+ struct ui_file *stream, int show, int level,
+ const struct type_print_options *flags)
{
struct type *type = ada_check_typedef (ada_get_base_type (type0));
char *type_name = decoded_type_name (type0);
if (is_var_decl)
fprintf_filtered (stream, "%.*s: ",
ada_name_prefix_len (varstring), varstring);
- fprintf_filtered (stream, "<null type?>");
+ fprintf_styled (stream, metadata_style.style (), "<null type?>");
return;
}
if (show > 0)
type = ada_check_typedef (type);
- if (is_var_decl && TYPE_CODE (type) != TYPE_CODE_FUNC)
+ if (is_var_decl && type->code () != TYPE_CODE_FUNC)
fprintf_filtered (stream, "%.*s: ",
ada_name_prefix_len (varstring), varstring);
}
if (ada_is_aligner_type (type))
- ada_print_type (ada_aligned_type (type), "", stream, show, level);
+ ada_print_type (ada_aligned_type (type), "", stream, show, level, flags);
else if (ada_is_constrained_packed_array_type (type)
- && TYPE_CODE (type) != TYPE_CODE_PTR)
- print_array_type (type, stream, show, level);
+ && type->code () != TYPE_CODE_PTR)
+ print_array_type (type, stream, show, level, flags);
else
- switch (TYPE_CODE (type))
+ switch (type->code ())
{
default:
fprintf_filtered (stream, "<");
- c_print_type (type, "", stream, show, level);
+ c_print_type (type, "", stream, show, level, flags);
fprintf_filtered (stream, ">");
break;
case TYPE_CODE_PTR:
case TYPE_CODE_TYPEDEF:
fprintf_filtered (stream, "access ");
- ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
+ ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level,
+ flags);
break;
case TYPE_CODE_REF:
fprintf_filtered (stream, "<ref> ");
- ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
+ ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level,
+ flags);
break;
case TYPE_CODE_ARRAY:
- print_array_type (type, stream, show, level);
+ print_array_type (type, stream, show, level, flags);
break;
case TYPE_CODE_BOOL:
fprintf_filtered (stream, "(false, true)");
break;
case TYPE_CODE_INT:
- if (ada_is_fixed_point_type (type))
- print_fixed_point_type (type, stream);
+ if (ada_is_gnat_encoded_fixed_point_type (type))
+ print_gnat_encoded_fixed_point_type (type, stream);
else
{
- char *name = ada_type_name (type);
+ const char *name = ada_type_name (type);
if (!ada_is_range_type_name (name))
- fprintf_filtered (stream, _("<%d-byte integer>"),
- TYPE_LENGTH (type));
+ fprintf_styled (stream, metadata_style.style (),
+ _("<%s-byte integer>"),
+ pulongest (TYPE_LENGTH (type)));
else
{
fprintf_filtered (stream, "range ");
- print_range_type (type, stream);
+ print_range_type (type, stream, 1 /* bounds_prefered_p */);
}
}
break;
case TYPE_CODE_RANGE:
- if (ada_is_fixed_point_type (type))
- print_fixed_point_type (type, stream);
+ if (ada_is_gnat_encoded_fixed_point_type (type))
+ print_gnat_encoded_fixed_point_type (type, stream);
else if (ada_is_modular_type (type))
fprintf_filtered (stream, "mod %s",
int_string (ada_modulus (type), 10, 0, 0, 1));
else
{
fprintf_filtered (stream, "range ");
- print_range (type, stream);
+ print_range (type, stream, 1 /* bounds_prefered_p */);
}
break;
case TYPE_CODE_FLT:
- fprintf_filtered (stream, _("<%d-byte float>"), TYPE_LENGTH (type));
+ fprintf_styled (stream, metadata_style.style (),
+ _("<%s-byte float>"),
+ pulongest (TYPE_LENGTH (type)));
break;
case TYPE_CODE_ENUM:
if (show < 0)
break;
case TYPE_CODE_STRUCT:
if (ada_is_array_descriptor_type (type))
- print_array_type (type, stream, show, level);
+ print_array_type (type, stream, show, level, flags);
else if (ada_is_bogus_array_descriptor (type))
fprintf_filtered (stream,
_("array (?) of ? (<mal-formed descriptor>)"));
else
- print_record_type (type, stream, show, level);
+ print_record_type (type, stream, show, level, flags);
break;
case TYPE_CODE_UNION:
- print_unchecked_union_type (type, stream, show, level);
+ print_unchecked_union_type (type, stream, show, level, flags);
break;
case TYPE_CODE_FUNC:
- print_func_type (type, stream, varstring);
+ print_func_type (type, stream, varstring, flags);
break;
}
}
struct ui_file *stream)
{
type = ada_check_typedef (type);
- ada_print_type (type, "", stream, 0, 0);
- fprintf_filtered (stream, "\n");
+ ada_print_type (type, "", stream, 0, 0, &type_print_raw_options);
}
projects / deliverable / binutils-gdb.git / blobdiff