/* Helper routines for C++ support in GDB.
- Copyright (C) 2003-2017 Free Software Foundation, Inc.
+ Copyright (C) 2003-2019 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)
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)));
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;
+ return {};
/* Look for symbol NAME in this class. */
sym = cp_lookup_nested_symbol (type, name, block, domain);
unsigned int prefix_len,
int is_in_anonymous)
{
- struct block_symbol sym;
- struct block_symbol klass_sym;
- struct type *klass_type;
-
/* Check for malformed input. */
if (prefix_len + 2 > strlen (name) || name[prefix_len + 1] != ':')
- return null_block_symbol;
-
- /* Find the name of the class and the name of the method, variable, etc. */
+ return {};
- /* The class name is everything up to and including PREFIX_LEN. */
- std::string klass (name, prefix_len);
+ /* The class, namespace or function name is everything up to and
+ including PREFIX_LEN. */
+ std::string scope (name, prefix_len);
/* The rest of the name is everything else past the initial scope
operator. */
- std::string nested (name + prefix_len + 2);
-
- /* Lookup a class named KLASS. If none is found, there is nothing
- more that can be done. KLASS could be a namespace, so always look
- in VAR_DOMAIN. This works for classes too because of
- symbol_matches_domain (which should be replaced with something else,
- but it's what we have today). */
- klass_sym = lookup_global_symbol (klass.c_str (), block, VAR_DOMAIN);
- if (klass_sym.symbol == NULL)
- return null_block_symbol;
- klass_type = SYMBOL_TYPE (klass_sym.symbol);
-
- /* Look for a symbol named NESTED in this class.
+ const char *nested = name + prefix_len + 2;
+
+ /* Lookup the scope symbol. If none is found, there is nothing more
+ that can be done. SCOPE could be a namespace, so always look in
+ VAR_DOMAIN. This works for classes too because of
+ symbol_matches_domain (which should be replaced with something
+ else, but it's what we have today). */
+ block_symbol scope_sym = lookup_symbol_in_static_block (scope.c_str (),
+ block, VAR_DOMAIN);
+ if (scope_sym.symbol == NULL)
+ scope_sym = lookup_global_symbol (scope.c_str (), block, VAR_DOMAIN);
+ if (scope_sym.symbol == NULL)
+ 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)
+ return lookup_symbol (nested, SYMBOL_BLOCK_VALUE (scope_sym.symbol),
+ VAR_DOMAIN, NULL);
+
+ /* Look for a symbol named NESTED in this class/namespace.
The caller is assumed to have already have done a basic lookup of NAME.
So we pass zero for BASIC_LOOKUP to cp_lookup_nested_symbol_1 here. */
- sym = cp_lookup_nested_symbol_1 (klass_type, nested.c_str (), name,
- block, domain, 0, is_in_anonymous);
-
- return sym;
+ return cp_lookup_nested_symbol_1 (scope_type, nested, name,
+ block, domain, 0, is_in_anonymous);
}
/* Look up NAME in the C++ namespace NAMESPACE. Other arguments are
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. */
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 = TYPE_NAME (saved_parent_type);
fprintf_unfiltered (gdb_stdlog,
"cp_lookup_nested_symbol (%s, %s, %s, %s)\n",
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"));
}
-/* Provide a prototype to silence -Wmissing-prototypes. */
-extern initialize_file_ftype _initialize_cp_namespace;
-
void
_initialize_cp_namespace (void)
{