/* Support for printing Ada types for GDB, the GNU debugger.
- Copyright (C) 1986-2015 Free Software Foundation, Inc.
+ Copyright (C) 1986-2019 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>
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);
case TYPE_CODE_RANGE:
case TYPE_CODE_ENUM:
{
- struct type *target_type;
- volatile struct gdb_exception e;
LONGEST lo = 0, hi = 0; /* init for gcc -Wall */
+ int got_error = 0;
- target_type = TYPE_TARGET_TYPE (type);
- if (target_type == NULL)
- target_type = type;
-
- TRY_CATCH (e, RETURN_MASK_ERROR)
+ try
{
lo = ada_discrete_type_low_bound (type);
hi = ada_discrete_type_high_bound (type);
}
- if (e.reason < 0)
+ catch (const gdb_exception_error &e)
{
/* This can happen when the range is dynamic. Sometimes,
resolving dynamic property values requires us to have
when the user is using the "ptype" command on a type.
Print the range as an unbounded range. */
fprintf_filtered (stream, "<>");
+ got_error = 1;
}
- else
+
+ if (!got_error)
{
- ada_print_scalar (target_type, lo, stream);
+ ada_print_scalar (type, lo, stream);
fprintf_filtered (stream, " .. ");
- ada_print_scalar (target_type, hi, stream);
+ ada_print_scalar (type, hi, stream);
}
}
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;
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, "?");
else
{
int prefix_len = subtype_info - name;
- char *bounds_str;
+ const char *bounds_str;
int n;
subtype_info += 5;
static void
print_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 = ada_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());
+ }
}
}
{
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;
}
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, flags);
- 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);
}
}
Huh:
- fprintf_filtered (stream, "?? =>");
+ fprintf_filtered (stream, "? =>");
return 0;
}
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, flags);
fprintf_filtered (stream, "\n%*send case;", level + 4, "");
{
int i, len = TYPE_NFIELDS (type);
- if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_VOID)
+ if (TYPE_TARGET_TYPE (type) != NULL
+ && TYPE_CODE (TYPE_TARGET_TYPE (type)) == 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)
{
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_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_VOID)
{
fprintf_filtered (stream, " return ");
ada_print_type (TYPE_TARGET_TYPE (type), "", stream, 0, 0, flags);
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;
}
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 ");
}
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)
{
type = ada_check_typedef (type);
ada_print_type (type, "", stream, 0, 0, &type_print_raw_options);
- fprintf_filtered (stream, "\n");
}
projects / deliverable / binutils-gdb.git / blobdiff