/* Ada language support routines for GDB, the GNU debugger.
- Copyright (C) 1992-2019 Free Software Foundation, Inc.
+ Copyright (C) 1992-2020 Free Software Foundation, Inc.
This file is part of GDB.
static struct cmd_list_element *maint_set_ada_cmdlist;
static struct cmd_list_element *maint_show_ada_cmdlist;
-/* Implement the "maintenance set ada" (prefix) command. */
-
-static void
-maint_set_ada_cmd (const char *args, int from_tty)
-{
- help_list (maint_set_ada_cmdlist, "maintenance set ada ", all_commands,
- gdb_stdout);
-}
-
-/* Implement the "maintenance show ada" (prefix) command. */
-
-static void
-maint_show_ada_cmd (const char *args, int from_tty)
-{
- cmd_show_list (maint_show_ada_cmdlist, from_tty, "");
-}
-
/* The "maintenance ada set/show ignore-descriptive-type" value. */
static bool ada_ignore_descriptive_types_p = false;
LONGEST
ada_discrete_type_high_bound (struct type *type)
{
- type = resolve_dynamic_type (type, NULL, 0);
+ type = resolve_dynamic_type (type, {}, 0);
switch (TYPE_CODE (type))
{
case TYPE_CODE_RANGE:
LONGEST
ada_discrete_type_low_bound (struct type *type)
{
- type = resolve_dynamic_type (type, NULL, 0);
+ type = resolve_dynamic_type (type, {}, 0);
switch (TYPE_CODE (type))
{
case TYPE_CODE_RANGE:
to next call. */
static char *
-ada_fold_name (const char *name)
+ada_fold_name (gdb::string_view name)
{
static char *fold_buffer = NULL;
static size_t fold_buffer_size = 0;
- int len = strlen (name);
+ int len = name.size ();
GROW_VECT (fold_buffer, fold_buffer_size, len + 1);
if (name[0] == '\'')
{
- strncpy (fold_buffer, name + 1, len - 2);
+ strncpy (fold_buffer, name.data () + 1, len - 2);
fold_buffer[len - 2] = '\000';
}
else
if (!gsymbol->ada_mangled)
{
- std::string decoded = ada_decode (gsymbol->name);
+ std::string decoded = ada_decode (gsymbol->linkage_name ());
struct obstack *obstack = gsymbol->language_specific.obstack;
gsymbol->ada_mangled = 1;
return NULL;
}
- if (gdbarch_bits_big_endian (get_type_arch (value_type (arr)))
+ if (type_byte_order (value_type (arr)) == BFD_ENDIAN_BIG
&& ada_is_modular_type (value_type (arr)))
{
/* This is a (right-justified) modular type representing a packed
const gdb_byte *src; /* First byte containing data to unpack */
gdb_byte *unpacked;
const int is_scalar = is_scalar_type (type);
- const int is_big_endian = gdbarch_bits_big_endian (get_type_arch (type));
+ const int is_big_endian = type_byte_order (type) == BFD_ENDIAN_BIG;
gdb::byte_vector staging;
type = ada_check_typedef (type);
staging.data (), staging.size (),
is_big_endian, has_negatives (type),
is_scalar);
- type = resolve_dynamic_type (type, staging.data (), 0);
+ type = resolve_dynamic_type (type, staging, 0);
if (TYPE_LENGTH (type) < (bit_size + HOST_CHAR_BIT - 1) / HOST_CHAR_BIT)
{
/* This happens when the length of the object is dynamic,
if (from_size == 0)
from_size = TYPE_LENGTH (value_type (fromval)) * TARGET_CHAR_BIT;
- const int is_big_endian = gdbarch_bits_big_endian (get_type_arch (type));
+ const int is_big_endian = type_byte_order (type) == BFD_ENDIAN_BIG;
ULONGEST from_offset = 0;
if (is_big_endian && is_scalar_type (value_type (fromval)))
from_offset = from_size - bits;
else
bits = value_bitsize (component);
- if (gdbarch_bits_big_endian (get_type_arch (value_type (container))))
+ if (type_byte_order (value_type (container)) == BFD_ENDIAN_BIG)
{
int src_offset;
struct ada_symbol_cache *sym_cache
= ada_get_symbol_cache (current_program_space);
int h;
- char *copy;
struct cache_entry *e;
/* Symbols for builtin types don't have a block.
e = XOBNEW (&sym_cache->cache_space, cache_entry);
e->next = sym_cache->root[h];
sym_cache->root[h] = e;
- e->name = copy
- = (char *) obstack_alloc (&sym_cache->cache_space, strlen (name) + 1);
- strcpy (copy, name);
+ e->name = obstack_strdup (&sym_cache->cache_space, name);
e->sym = sym;
e->domain = domain;
e->block = block;
if (num_defns_collected (obstackp) == 0 && global && !is_wild_match)
{
const char *name = ada_lookup_name (lookup_name);
- lookup_name_info name1 (std::string ("<_ada_") + name + '>',
- symbol_name_match_type::FULL);
+ std::string bracket_name = std::string ("<_ada_") + name + '>';
+ lookup_name_info name1 (bracket_name, symbol_name_match_type::FULL);
for (objfile *objfile : current_program_space->objfiles ())
{
sym != NULL;
sym = block_iter_match_next (lookup_name, &iter))
{
- if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
- SYMBOL_DOMAIN (sym), domain))
+ if (symbol_matches_domain (sym->language (), SYMBOL_DOMAIN (sym), domain))
{
if (SYMBOL_CLASS (sym) != LOC_UNRESOLVED)
{
ALL_BLOCK_SYMBOLS (block, iter, sym)
{
- if (symbol_matches_domain (SYMBOL_LANGUAGE (sym),
+ if (symbol_matches_domain (sym->language (),
SYMBOL_DOMAIN (sym), domain))
{
int cmp;
if (completion_skip_symbol (mode, msymbol))
continue;
- language symbol_language = MSYMBOL_LANGUAGE (msymbol);
+ language symbol_language = msymbol->language ();
/* Ada minimal symbols won't have their language set to Ada. If
we let completion_list_add_name compare using the
continue;
completion_list_add_name (tracker,
- SYMBOL_LANGUAGE (sym),
+ sym->language (),
sym->linkage_name (),
lookup_name, text, word);
}
continue;
completion_list_add_name (tracker,
- SYMBOL_LANGUAGE (sym),
+ sym->language (),
sym->linkage_name (),
lookup_name, text, word);
}
continue;
completion_list_add_name (tracker,
- SYMBOL_LANGUAGE (sym),
+ sym->language (),
sym->linkage_name (),
lookup_name, text, word);
}
/* Assuming that VAR_TYPE is the type of a variant part of a record (a union),
- within a value of type OUTER_TYPE that is stored in GDB at
- OUTER_VALADDR, determine which variant clause (field number in VAR_TYPE,
+ within OUTER, determine which variant clause (field number in VAR_TYPE,
numbering from 0) is applicable. Returns -1 if none are. */
int
-ada_which_variant_applies (struct type *var_type, struct type *outer_type,
- const gdb_byte *outer_valaddr)
+ada_which_variant_applies (struct type *var_type, struct value *outer)
{
int others_clause;
int i;
const char *discrim_name = ada_variant_discrim_name (var_type);
- struct value *outer;
struct value *discrim;
LONGEST discrim_val;
/* Using plain value_from_contents_and_address here causes problems
because we will end up trying to resolve a type that is currently
being constructed. */
- outer = value_from_contents_and_address_unresolved (outer_type,
- outer_valaddr, 0);
discrim = ada_value_struct_elt (outer, discrim_name, 1);
if (discrim == NULL)
return -1;
if (is_unchecked_variant (var_type, value_type (dval)))
return var_type0;
- which =
- ada_which_variant_applies (var_type,
- value_type (dval), value_contents (dval));
+ which = ada_which_variant_applies (var_type, dval);
if (which < 0)
return empty_record (var_type);
ada_lookup_name_info::ada_lookup_name_info (const lookup_name_info &lookup_name)
{
- const std::string &user_name = lookup_name.name ();
+ gdb::string_view user_name = lookup_name.name ();
if (user_name[0] == '<')
{
if (user_name.back () == '>')
- m_encoded_name = user_name.substr (1, user_name.size () - 2);
+ m_encoded_name
+ = user_name.substr (1, user_name.size () - 2).to_string ();
else
- m_encoded_name = user_name.substr (1, user_name.size () - 1);
+ m_encoded_name
+ = user_name.substr (1, user_name.size () - 1).to_string ();
m_encoded_p = true;
m_verbatim_p = true;
m_wild_match_p = false;
{
m_verbatim_p = false;
- m_encoded_p = user_name.find ("__") != std::string::npos;
+ m_encoded_p = user_name.find ("__") != gdb::string_view::npos;
if (!m_encoded_p)
{
- const char *folded = ada_fold_name (user_name.c_str ());
+ const char *folded = ada_fold_name (user_name);
const char *encoded = ada_encode_1 (folded, false);
if (encoded != NULL)
m_encoded_name = encoded;
else
- m_encoded_name = user_name;
+ m_encoded_name = user_name.to_string ();
}
else
- m_encoded_name = user_name;
+ m_encoded_name = user_name.to_string ();
/* Handle the 'package Standard' special case. See description
of m_standard_p. */
const lookup_name_info &lookup_name,
completion_match_result *comp_match_res)
{
- const std::string &name = lookup_name.name ();
+ gdb::string_view name_view = lookup_name.name ();
- int cmp = (lookup_name.completion_mode ()
- ? strncmp (symbol_search_name, name.c_str (), name.size ())
- : strcmp (symbol_search_name, name.c_str ()));
- if (cmp == 0)
+ if (lookup_name.completion_mode ()
+ ? (strncmp (symbol_search_name, name_view.data (),
+ name_view.size ()) == 0)
+ : symbol_search_name == name_view)
{
if (comp_match_res != NULL)
comp_match_res->set_match (symbol_search_name);
emit_char, /* Function to print single char (not used) */
ada_print_type, /* Print a type using appropriate syntax */
ada_print_typedef, /* Print a typedef using appropriate syntax */
- ada_val_print, /* Print a value using appropriate syntax */
+ ada_value_print_inner, /* la_value_print_inner */
ada_value_print, /* Print a top-level value */
ada_read_var_value, /* la_read_var_value */
NULL, /* Language specific skip_trampoline */
static struct cmd_list_element *set_ada_list;
static struct cmd_list_element *show_ada_list;
-/* Implement the "set ada" prefix command. */
-
-static void
-set_ada_command (const char *arg, int from_tty)
-{
- printf_unfiltered (_(\
-"\"set ada\" must be followed by the name of a setting.\n"));
- help_list (set_ada_list, "set ada ", all_commands, gdb_stdout);
-}
-
-/* Implement the "show ada" prefix command. */
-
-static void
-show_ada_command (const char *args, int from_tty)
-{
- cmd_show_list (show_ada_list, from_tty, "");
-}
-
static void
initialize_ada_catchpoint_ops (void)
{
ada_clear_symbol_cache ();
}
+void _initialize_ada_language ();
void
-_initialize_ada_language (void)
+_initialize_ada_language ()
{
initialize_ada_catchpoint_ops ();
- add_prefix_cmd ("ada", no_class, set_ada_command,
- _("Prefix command for changing Ada-specific settings."),
- &set_ada_list, "set ada ", 0, &setlist);
+ add_basic_prefix_cmd ("ada", no_class,
+ _("Prefix command for changing Ada-specific settings."),
+ &set_ada_list, "set ada ", 0, &setlist);
- add_prefix_cmd ("ada", no_class, show_ada_command,
- _("Generic command for showing Ada-specific settings."),
- &show_ada_list, "show ada ", 0, &showlist);
+ add_show_prefix_cmd ("ada", no_class,
+ _("Generic command for showing Ada-specific settings."),
+ &show_ada_list, "show ada ", 0, &showlist);
add_setshow_boolean_cmd ("trust-PAD-over-XVS", class_obscure,
&trust_pad_over_xvs, _("\
If a regular expression is passed as an argument, only those matching\n\
the regular expression are listed."));
- add_prefix_cmd ("ada", class_maintenance, maint_set_ada_cmd,
- _("Set Ada maintenance-related variables."),
- &maint_set_ada_cmdlist, "maintenance set ada ",
- 0/*allow-unknown*/, &maintenance_set_cmdlist);
+ add_basic_prefix_cmd ("ada", class_maintenance,
+ _("Set Ada maintenance-related variables."),
+ &maint_set_ada_cmdlist, "maintenance set ada ",
+ 0/*allow-unknown*/, &maintenance_set_cmdlist);
- add_prefix_cmd ("ada", class_maintenance, maint_show_ada_cmd,
- _("Show Ada maintenance-related variables."),
- &maint_show_ada_cmdlist, "maintenance show ada ",
- 0/*allow-unknown*/, &maintenance_show_cmdlist);
+ add_show_prefix_cmd ("ada", class_maintenance,
+ _("Show Ada maintenance-related variables."),
+ &maint_show_ada_cmdlist, "maintenance show ada ",
+ 0/*allow-unknown*/, &maintenance_show_cmdlist);
add_setshow_boolean_cmd
("ignore-descriptive-types", class_maintenance,