/* Helper routines for C++ support in GDB.
- Copyright (C) 2003-2017 Free Software Foundation, Inc.
+ Copyright (C) 2003-2020 Free Software Foundation, Inc.
Contributed by David Carlton and by Kealia, Inc.
anonymous namespace; if so, add an appropriate using directive. */
void
-cp_scan_for_anonymous_namespaces (const struct symbol *const symbol,
+cp_scan_for_anonymous_namespaces (struct buildsym_compunit *compunit,
+ const struct symbol *const symbol,
struct objfile *const objfile)
{
- if (SYMBOL_DEMANGLED_NAME (symbol) != NULL)
+ if (symbol->demangled_name () != NULL)
{
- const char *name = SYMBOL_DEMANGLED_NAME (symbol);
+ const char *name = symbol->demangled_name ();
unsigned int previous_component;
unsigned int next_component;
anonymous namespace. So add symbols in it to the
namespace given by the previous component if there is
one, or to the global namespace if there isn't. */
- add_using_directive (&local_using_directives,
- dest, src, NULL, NULL, NULL, 1,
- &objfile->objfile_obstack);
+ std::vector<const char *> excludes;
+ add_using_directive (compunit->get_local_using_directives (),
+ dest, src, NULL, NULL, excludes,
+ 1, &objfile->objfile_obstack);
}
/* The "+ 2" is for the "::". */
previous_component = next_component + 2;
if (global_block != NULL)
{
- sym.symbol = lookup_symbol_in_block (name, global_block, domain);
+ sym.symbol = lookup_symbol_in_block (name,
+ symbol_name_match_type::FULL,
+ global_block, domain);
sym.block = global_block;
}
}
lang_this = lookup_language_this (langdef, block);
if (lang_this.symbol == NULL)
- return null_block_symbol;
+ return {};
type = check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (lang_this.symbol)));
/* If TYPE_NAME is NULL, abandon trying to find this symbol.
This can happen for lambda functions compiled with clang++,
which outputs no name for the container class. */
- if (TYPE_NAME (type) == NULL)
- return null_block_symbol;
+ if (type->name () == NULL)
+ return {};
/* Look for symbol NAME in this class. */
sym = cp_lookup_nested_symbol (type, name, block, domain);
{
/* Check for malformed input. */
if (prefix_len + 2 > strlen (name) || name[prefix_len + 1] != ':')
- return null_block_symbol;
+ return {};
/* The class, namespace or function name is everything up to and
including PREFIX_LEN. */
if (scope_sym.symbol == NULL)
scope_sym = lookup_global_symbol (scope.c_str (), block, VAR_DOMAIN);
if (scope_sym.symbol == NULL)
- return null_block_symbol;
+ return {};
struct type *scope_type = SYMBOL_TYPE (scope_sym.symbol);
/* If the scope is a function/method, then look up NESTED as a local
static variable. E.g., "print 'function()::static_var'". */
- if (TYPE_CODE (scope_type) == TYPE_CODE_FUNC
- || TYPE_CODE (scope_type) == TYPE_CODE_METHOD)
+ if ((scope_type->code () == TYPE_CODE_FUNC
+ || scope_type->code () == TYPE_CODE_METHOD)
+ && domain == VAR_DOMAIN)
return lookup_symbol (nested, SYMBOL_BLOCK_VALUE (scope_sym.symbol),
VAR_DOMAIN, NULL);
return sym;
}
-/* Used for cleanups to reset the "searched" flag in case of an error. */
-
-static void
-reset_directive_searched (void *data)
-{
- struct using_direct *direct = (struct using_direct *) data;
- direct->searched = 0;
-}
-
/* Search for NAME by applying all import statements belonging to
BLOCK which are applicable in SCOPE. If DECLARATION_ONLY the
search is restricted to using declarations.
const int search_parents)
{
struct using_direct *current;
- struct block_symbol sym;
+ struct block_symbol sym = {};
int len;
int directive_match;
- struct cleanup *searched_cleanup;
-
- sym.symbol = NULL;
- sym.block = NULL;
/* First, try to find the symbol in the given namespace if requested. */
if (search_scope_first)
{
/* Mark this import as searched so that the recursive call
does not search it again. */
- current->searched = 1;
- searched_cleanup = make_cleanup (reset_directive_searched,
- current);
+ scoped_restore reset_directive_searched
+ = make_scoped_restore (¤t->searched, 1);
/* If there is an import of a single declaration, compare the
imported declaration (after optional renaming by its alias)
search of this import is complete. */
if (declaration_only || sym.symbol != NULL || current->declaration)
{
- current->searched = 0;
- discard_cleanups (searched_cleanup);
-
if (sym.symbol != NULL)
return sym;
if (strcmp (name, *excludep) == 0)
break;
if (*excludep)
- {
- discard_cleanups (searched_cleanup);
- continue;
- }
+ continue;
if (current->alias != NULL
&& strcmp (name, current->alias) == 0)
name, block,
domain, 1, 0, 0);
}
- current->searched = 0;
- discard_cleanups (searched_cleanup);
if (sym.symbol != NULL)
return sym;
}
}
- return null_block_symbol;
+ return {};
}
/* Helper function that searches an array of symbols for one named NAME. */
/* Maybe we should store a dictionary in here instead. */
for (i = 0; i < num; ++i)
{
- if (strcmp (name, SYMBOL_NATURAL_NAME (syms[i])) == 0)
+ if (strcmp (name, syms[i]->natural_name ()) == 0)
return syms[i];
}
return NULL;
domain_name (domain));
}
- if (function != NULL && SYMBOL_LANGUAGE (function) == language_cplus)
+ if (function != NULL && function->language () == language_cplus)
{
/* Search the function's template parameters. */
if (SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION (function))
/* Search the template parameters of the function's defining
context. */
- if (SYMBOL_NATURAL_NAME (function))
+ if (function->natural_name ())
{
struct type *context;
- std::string name_copy (SYMBOL_NATURAL_NAME (function));
+ std::string name_copy (function->natural_name ());
const struct language_defn *lang = language_def (language_cplus);
- struct gdbarch *arch = symbol_arch (function);
const struct block *parent = BLOCK_SUPERBLOCK (block);
struct symbol *sym;
else
{
name_copy.erase (prefix_len);
- context = lookup_typename (lang, arch,
+ context = lookup_typename (lang,
name_copy.c_str (),
parent, 1);
}
block = BLOCK_SUPERBLOCK (block);
}
- return null_block_symbol;
+ return {};
}
/* Searches for NAME in the current namespace, and by applying
int is_in_anonymous)
{
int i;
- struct block_symbol sym;
-
- sym.symbol = NULL;
- sym.block = NULL;
+ struct block_symbol sym = {};
for (i = 0; i < TYPE_N_BASECLASSES (parent_type); ++i)
{
return sym;
}
- return null_block_symbol;
+ return {};
}
/* Look up a symbol named NESTED_NAME that is nested inside the C++
const struct block *block,
const domain_enum domain)
{
- /* type_name_no_tag_or_error provides better error reporting using the
+ /* type_name_or_error provides better error reporting using the
original type. */
struct type *saved_parent_type = parent_type;
if (symbol_lookup_debug)
{
- const char *type_name = type_name_no_tag (saved_parent_type);
+ const char *type_name = saved_parent_type->name ();
fprintf_unfiltered (gdb_stdlog,
"cp_lookup_nested_symbol (%s, %s, %s, %s)\n",
domain_name (domain));
}
- switch (TYPE_CODE (parent_type))
+ switch (parent_type->code ())
{
case TYPE_CODE_STRUCT:
case TYPE_CODE_NAMESPACE:
case TYPE_CODE_MODULE:
{
int size;
- const char *parent_name = type_name_no_tag_or_error (saved_parent_type);
+ const char *parent_name = type_name_or_error (saved_parent_type);
struct block_symbol sym;
char *concatenated_name;
int is_in_anonymous;
"cp_lookup_nested_symbol (...) = NULL"
" (func/method)\n");
}
- return null_block_symbol;
+ return {};
default:
internal_error (__FILE__, __LINE__,
full_name = (char *) alloca (scope_length + 2 + strlen (name) + 1);
strncpy (full_name, scope, scope_length);
- strncpy (full_name + scope_length, "::", 2);
+ memcpy (full_name + scope_length, "::", 2);
strcpy (full_name + scope_length + 2, name);
return basic_lookup_transparent_type (full_name);
obsolete. */
static void
-maintenance_cplus_namespace (char *args, int from_tty)
+maintenance_cplus_namespace (const char *args, int from_tty)
{
printf_unfiltered (_("The `maint namespace' command was removed.\n"));
}
+void _initialize_cp_namespace ();
void
-_initialize_cp_namespace (void)
+_initialize_cp_namespace ()
{
struct cmd_list_element *cmd;
projects / deliverable / binutils-gdb.git / blobdiff