/* Helper routines for C++ support in GDB.
- Copyright (C) 2003, 2004, 2007, 2008, 2009 Free Software Foundation, Inc.
+ Copyright (C) 2003-2017 Free Software Foundation, Inc.
Contributed by David Carlton and by Kealia, Inc.
#include "gdb_obstack.h"
#include "symtab.h"
#include "symfile.h"
-#include "gdb_assert.h"
#include "block.h"
#include "objfiles.h"
#include "gdbtypes.h"
#include "command.h"
#include "frame.h"
#include "buildsym.h"
-
-static struct using_direct *cp_copy_usings (struct using_direct *using,
- struct obstack *obstack);
-
-static struct symbol *lookup_namespace_scope (const char *name,
- const char *linkage_name,
- const struct block *block,
- const domain_enum domain,
- const char *scope,
- int scope_len);
-
-static struct symbol *lookup_symbol_file (const char *name,
- const char *linkage_name,
- const struct block *block,
- const domain_enum domain,
- int anonymous_namespace);
+#include "language.h"
+#include "namespace.h"
+#include <string>
+
+static struct block_symbol
+ cp_lookup_nested_symbol_1 (struct type *container_type,
+ const char *nested_name,
+ const char *concatenated_name,
+ const struct block *block,
+ const domain_enum domain,
+ int basic_lookup, int is_in_anonymous);
static struct type *cp_lookup_transparent_type_loop (const char *name,
const char *scope,
int scope_len);
-static void initialize_namespace_symtab (struct objfile *objfile);
-
-static struct block *get_possible_namespace_block (struct objfile *objfile);
-
-static void free_namespace_block (struct symtab *symtab);
-
-static int check_possible_namespace_symbols_loop (const char *name,
- int len,
- struct objfile *objfile);
-
-static int check_one_possible_namespace_symbol (const char *name,
- int len,
- struct objfile *objfile);
-
-static struct symbol *lookup_possible_namespace_symbol (const char *name);
-
-static void maintenance_cplus_namespace (char *args, int from_tty);
-
/* Check to see if SYMBOL refers to an object contained within an
anonymous namespace; if so, add an appropriate using directive. */
-/* Optimize away strlen ("(anonymous namespace)"). */
-
-#define ANONYMOUS_NAMESPACE_LEN 21
-
void
-cp_scan_for_anonymous_namespaces (const struct symbol *symbol)
+cp_scan_for_anonymous_namespaces (const struct symbol *const symbol,
+ struct objfile *const objfile)
{
if (SYMBOL_DEMANGLED_NAME (symbol) != NULL)
{
const char *name = SYMBOL_DEMANGLED_NAME (symbol);
unsigned int previous_component;
unsigned int next_component;
- const char *len;
/* Start with a quick-and-dirty check for mention of "(anonymous
namespace)". */
- if (!cp_is_anonymous (name))
+ if (!cp_is_in_anonymous (name))
return;
previous_component = 0;
while (name[next_component] == ':')
{
- if ((next_component - previous_component) == ANONYMOUS_NAMESPACE_LEN
+ if (((next_component - previous_component)
+ == CP_ANONYMOUS_NAMESPACE_LEN)
&& strncmp (name + previous_component,
- "(anonymous namespace)",
- ANONYMOUS_NAMESPACE_LEN) == 0)
+ CP_ANONYMOUS_NAMESPACE_STR,
+ CP_ANONYMOUS_NAMESPACE_LEN) == 0)
{
- int dest_len = (previous_component == 0 ? 0 : previous_component - 2);
+ int dest_len = (previous_component == 0
+ ? 0 : previous_component - 2);
int src_len = next_component;
- char *dest = alloca (dest_len + 1);
- char *src = alloca (src_len + 1);
+ char *dest = (char *) alloca (dest_len + 1);
+ char *src = (char *) alloca (src_len + 1);
memcpy (dest, name, dest_len);
memcpy (src, name, src_len);
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. */
- cp_add_using_directive (dest, src);
+ std::vector<const char *> excludes;
+ add_using_directive (&local_using_directives,
+ dest, src, NULL, NULL, excludes, 1,
+ &objfile->objfile_obstack);
}
/* The "+ 2" is for the "::". */
previous_component = next_component + 2;
}
}
-/* Add a using directive to using_list. If the using directive in question
- has already been added, don't add it twice. */
+/* Test whether or not NAMESPACE looks like it mentions an anonymous
+ namespace; return nonzero if so. */
-void
-cp_add_using_directive (const char *dest, const char *src)
+int
+cp_is_in_anonymous (const char *symbol_name)
{
- struct using_direct *current;
- struct using_direct *new;
+ return (strstr (symbol_name, CP_ANONYMOUS_NAMESPACE_STR)
+ != NULL);
+}
+
+/* Look up NAME in DOMAIN in BLOCK's static block and in global blocks.
+ If IS_IN_ANONYMOUS is nonzero, the symbol in question is located
+ within an anonymous namespace. */
- /* Has it already been added? */
+static struct block_symbol
+cp_basic_lookup_symbol (const char *name, const struct block *block,
+ const domain_enum domain, int is_in_anonymous)
+{
+ struct block_symbol sym;
+
+ sym = lookup_symbol_in_static_block (name, block, domain);
+ if (sym.symbol != NULL)
+ return sym;
- for (current = using_directives; current != NULL; current = current->next)
+ if (is_in_anonymous)
{
- if (strcmp (current->import_src, src) == 0
- && strcmp (current->import_dest, dest) == 0)
- return;
+ /* Symbols defined in anonymous namespaces have external linkage
+ but should be treated as local to a single file nonetheless.
+ So we only search the current file's global block. */
+
+ const struct block *global_block = block_global_block (block);
+
+ if (global_block != NULL)
+ {
+ sym.symbol = lookup_symbol_in_block (name, global_block, domain);
+ sym.block = global_block;
+ }
}
+ else
+ sym = lookup_global_symbol (name, block, domain);
- using_directives = cp_add_using (dest, src, using_directives);
+ return sym;
+}
+/* Search bare symbol NAME in DOMAIN in BLOCK.
+ NAME is guaranteed to not have any scope (no "::") in its name, though
+ if for example NAME is a template spec then "::" may appear in the
+ argument list.
+ If LANGDEF is non-NULL then try to lookup NAME as a primitive type in
+ that language. Normally we wouldn't need LANGDEF but fortran also uses
+ this code.
+ If SEARCH is non-zero then see if we can determine "this" from BLOCK, and
+ if so then also search for NAME in that class. */
+
+static struct block_symbol
+cp_lookup_bare_symbol (const struct language_defn *langdef,
+ const char *name, const struct block *block,
+ const domain_enum domain, int search)
+{
+ struct block_symbol sym;
+
+ /* Note: We can't do a simple assert for ':' not being in NAME because
+ ':' may be in the args of a template spec. This isn't intended to be
+ a complete test, just cheap and documentary. */
+ if (strchr (name, '<') == NULL && strchr (name, '(') == NULL)
+ gdb_assert (strstr (name, "::") == NULL);
+
+ sym = lookup_symbol_in_static_block (name, block, domain);
+ if (sym.symbol != NULL)
+ return sym;
+
+ /* If we didn't find a definition for a builtin type in the static block,
+ search for it now. This is actually the right thing to do and can be
+ a massive performance win. E.g., when debugging a program with lots of
+ shared libraries we could search all of them only to find out the
+ builtin type isn't defined in any of them. This is common for types
+ like "void". */
+ if (langdef != NULL && domain == VAR_DOMAIN)
+ {
+ struct gdbarch *gdbarch;
+
+ if (block == NULL)
+ gdbarch = target_gdbarch ();
+ else
+ gdbarch = block_gdbarch (block);
+ sym.symbol
+ = language_lookup_primitive_type_as_symbol (langdef, gdbarch, name);
+ sym.block = NULL;
+ if (sym.symbol != NULL)
+ return sym;
+ }
+
+ sym = lookup_global_symbol (name, block, domain);
+ if (sym.symbol != NULL)
+ return sym;
+
+ if (search)
+ {
+ struct block_symbol lang_this;
+ struct type *type;
+
+ lang_this.symbol = NULL;
+
+ if (langdef != NULL)
+ lang_this = lookup_language_this (langdef, block);
+
+ if (lang_this.symbol == NULL)
+ return null_block_symbol;
+
+
+ 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;
+
+ /* Look for symbol NAME in this class. */
+ sym = cp_lookup_nested_symbol (type, name, block, domain);
+ }
+
+ return sym;
}
-/* Record the namespace that the function defined by SYMBOL was
- defined in, if necessary. BLOCK is the associated block; use
- OBSTACK for allocation. */
+/* Search NAME in DOMAIN in all static blocks, and then in all baseclasses.
+ BLOCK specifies the context in which to perform the search.
+ NAME is guaranteed to have scope (contain "::") and PREFIX_LEN specifies
+ the length of the entire scope of NAME (up to, but not including, the last
+ "::".
+
+ Note: At least in the case of Fortran, which also uses this code, there
+ may be no text after the last "::". */
+
+static struct block_symbol
+cp_search_static_and_baseclasses (const char *name,
+ const struct block *block,
+ const domain_enum domain,
+ unsigned int prefix_len,
+ int is_in_anonymous)
+{
+ /* Check for malformed input. */
+ if (prefix_len + 2 > strlen (name) || name[prefix_len + 1] != ':')
+ return null_block_symbol;
+
+ /* 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. */
+ 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 null_block_symbol;
+
+ 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. */
+ return cp_lookup_nested_symbol_1 (scope_type, nested, name,
+ block, domain, 0, is_in_anonymous);
+}
-void
-cp_set_block_scope (const struct symbol *symbol,
- struct block *block,
- struct obstack *obstack,
- const char *processing_current_prefix,
- int processing_has_namespace_info)
+/* Look up NAME in the C++ namespace NAMESPACE. Other arguments are
+ as in cp_lookup_symbol_nonlocal. If SEARCH is non-zero, search
+ through base classes for a matching symbol.
+
+ Note: Part of the complexity is because NAME may itself specify scope.
+ Part of the complexity is also because this handles the case where
+ there is no scoping in which case we also try looking in the class of
+ "this" if we can compute it. */
+
+static struct block_symbol
+cp_lookup_symbol_in_namespace (const char *the_namespace, const char *name,
+ const struct block *block,
+ const domain_enum domain, int search)
{
- if (processing_has_namespace_info)
+ char *concatenated_name = NULL;
+ int is_in_anonymous;
+ unsigned int prefix_len;
+ struct block_symbol sym;
+
+ if (the_namespace[0] != '\0')
{
- block_set_scope
- (block, obsavestring (processing_current_prefix,
- strlen (processing_current_prefix),
- obstack),
- obstack);
+ concatenated_name
+ = (char *) alloca (strlen (the_namespace) + 2 + strlen (name) + 1);
+ strcpy (concatenated_name, the_namespace);
+ strcat (concatenated_name, "::");
+ strcat (concatenated_name, name);
+ name = concatenated_name;
}
- else if (SYMBOL_DEMANGLED_NAME (symbol) != NULL)
+
+ prefix_len = cp_entire_prefix_len (name);
+ if (prefix_len == 0)
+ return cp_lookup_bare_symbol (NULL, name, block, domain, search);
+
+ /* This would be simpler if we just called cp_lookup_nested_symbol
+ at this point. But that would require first looking up the containing
+ class/namespace. Since we're only searching static and global blocks
+ there's often no need to first do that lookup. */
+
+ is_in_anonymous
+ = the_namespace[0] != '\0' && cp_is_in_anonymous (the_namespace);
+ sym = cp_basic_lookup_symbol (name, block, domain, is_in_anonymous);
+ if (sym.symbol != NULL)
+ return sym;
+
+ if (search)
+ sym = cp_search_static_and_baseclasses (name, block, domain, prefix_len,
+ is_in_anonymous);
+
+ return sym;
+}
+
+/* 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.
+ Example:
+
+ namespace A {
+ int x;
+ }
+ using A::x;
+
+ If SEARCH_PARENTS the search will include imports which are
+ applicable in parents of SCOPE.
+ Example:
+
+ namespace A {
+ using namespace X;
+ namespace B {
+ using namespace Y;
+ }
+ }
+
+ If SCOPE is "A::B" and SEARCH_PARENTS is true the imports of
+ namespaces X and Y will be considered. If SEARCH_PARENTS is false
+ only the import of Y is considered.
+
+ SEARCH_SCOPE_FIRST is an internal implementation detail: Callers must
+ pass 0 for it. Internally we pass 1 when recursing. */
+
+static struct block_symbol
+cp_lookup_symbol_via_imports (const char *scope,
+ const char *name,
+ const struct block *block,
+ const domain_enum domain,
+ const int search_scope_first,
+ const int declaration_only,
+ const int search_parents)
+{
+ struct using_direct *current;
+ struct block_symbol sym;
+ int len;
+ int directive_match;
+
+ sym.symbol = NULL;
+ sym.block = NULL;
+
+ /* First, try to find the symbol in the given namespace if requested. */
+ if (search_scope_first)
+ sym = cp_lookup_symbol_in_namespace (scope, name,
+ block, domain, 1);
+
+ if (sym.symbol != NULL)
+ return sym;
+
+ /* Go through the using directives. If any of them add new names to
+ the namespace we're searching in, see if we can find a match by
+ applying them. */
+
+ for (current = block_using (block);
+ current != NULL;
+ current = current->next)
{
- /* Try to figure out the appropriate namespace from the
- demangled name. */
+ const char **excludep;
+
+ len = strlen (current->import_dest);
+ directive_match = (search_parents
+ ? (startswith (scope, current->import_dest)
+ && (len == 0
+ || scope[len] == ':'
+ || scope[len] == '\0'))
+ : strcmp (scope, current->import_dest) == 0);
+
+ /* If the import destination is the current scope or one of its
+ ancestors then it is applicable. */
+ if (directive_match && !current->searched)
+ {
+ /* Mark this import as searched so that the recursive call
+ does not search it again. */
+ 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)
+ with the sought out name. If there is a match pass
+ current->import_src as NAMESPACE to direct the search
+ towards the imported namespace. */
+ if (current->declaration
+ && strcmp (name, current->alias
+ ? current->alias : current->declaration) == 0)
+ sym = cp_lookup_symbol_in_namespace (current->import_src,
+ current->declaration,
+ block, domain, 1);
+
+ /* If this is a DECLARATION_ONLY search or a symbol was found
+ or this import statement was an import declaration, the
+ search of this import is complete. */
+ if (declaration_only || sym.symbol != NULL || current->declaration)
+ {
+ if (sym.symbol != NULL)
+ return sym;
- /* FIXME: carlton/2003-04-15: If the function in question is
- a method of a class, the name will actually include the
- name of the class as well. This should be harmless, but
- is a little unfortunate. */
+ continue;
+ }
- const char *name = SYMBOL_DEMANGLED_NAME (symbol);
- unsigned int prefix_len = cp_entire_prefix_len (name);
+ /* Do not follow CURRENT if NAME matches its EXCLUDES. */
+ for (excludep = current->excludes; *excludep; excludep++)
+ if (strcmp (name, *excludep) == 0)
+ break;
+ if (*excludep)
+ continue;
+
+ if (current->alias != NULL
+ && strcmp (name, current->alias) == 0)
+ /* If the import is creating an alias and the alias matches
+ the sought name. Pass current->import_src as the NAME to
+ direct the search towards the aliased namespace. */
+ {
+ sym = cp_lookup_symbol_in_namespace (scope,
+ current->import_src,
+ block, domain, 1);
+ }
+ else if (current->alias == NULL)
+ {
+ /* If this import statement creates no alias, pass
+ current->inner as NAMESPACE to direct the search
+ towards the imported namespace. */
+ sym = cp_lookup_symbol_via_imports (current->import_src,
+ name, block,
+ domain, 1, 0, 0);
+ }
- block_set_scope (block,
- obsavestring (name, prefix_len, obstack),
- obstack);
+ if (sym.symbol != NULL)
+ return sym;
+ }
}
+
+ return null_block_symbol;
}
-/* Test whether or not NAMESPACE looks like it mentions an anonymous
- namespace; return nonzero if so. */
+/* Helper function that searches an array of symbols for one named NAME. */
-int
-cp_is_anonymous (const char *namespace)
+static struct symbol *
+search_symbol_list (const char *name, int num,
+ struct symbol **syms)
{
- return (strstr (namespace, "(anonymous namespace)")
- != NULL);
+ int i;
+
+ /* Maybe we should store a dictionary in here instead. */
+ for (i = 0; i < num; ++i)
+ {
+ if (strcmp (name, SYMBOL_NATURAL_NAME (syms[i])) == 0)
+ return syms[i];
+ }
+ return NULL;
}
-/* Create a new struct using direct which imports the namespace SRC
- into the scope DEST.
- Set its next member in the linked list to NEXT; allocate all memory
- using xmalloc. It copies the strings, so NAME can be a temporary
- string. */
+/* Like cp_lookup_symbol_via_imports, but if BLOCK is a function, it
+ searches through the template parameters of the function and the
+ function's type. */
-struct using_direct *
-cp_add_using (const char *dest,
- const char *src,
- struct using_direct *next)
+struct block_symbol
+cp_lookup_symbol_imports_or_template (const char *scope,
+ const char *name,
+ const struct block *block,
+ const domain_enum domain)
{
- struct using_direct *retval;
+ struct symbol *function = BLOCK_FUNCTION (block);
+ struct block_symbol result;
- retval = xmalloc (sizeof (struct using_direct));
- retval->import_src = savestring (src, strlen(src));
- retval->import_dest = savestring (dest, strlen(dest));
- retval->next = next;
+ if (symbol_lookup_debug)
+ {
+ fprintf_unfiltered (gdb_stdlog,
+ "cp_lookup_symbol_imports_or_template"
+ " (%s, %s, %s, %s)\n",
+ scope, name, host_address_to_string (block),
+ domain_name (domain));
+ }
- return retval;
-}
+ if (function != NULL && SYMBOL_LANGUAGE (function) == language_cplus)
+ {
+ /* Search the function's template parameters. */
+ if (SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION (function))
+ {
+ struct template_symbol *templ
+ = (struct template_symbol *) function;
+ struct symbol *sym = search_symbol_list (name,
+ templ->n_template_arguments,
+ templ->template_arguments);
-/* Make a copy of the using directives in the list pointed to by
- USING, using OBSTACK to allocate memory. Free all memory pointed
- to by USING via xfree. */
+ if (sym != NULL)
+ {
+ if (symbol_lookup_debug)
+ {
+ fprintf_unfiltered (gdb_stdlog,
+ "cp_lookup_symbol_imports_or_template"
+ " (...) = %s\n",
+ host_address_to_string (sym));
+ }
+ return (struct block_symbol) {sym, block};
+ }
+ }
-static struct using_direct *
-cp_copy_usings (struct using_direct *using,
- struct obstack *obstack)
-{
- if (using == NULL)
+ /* Search the template parameters of the function's defining
+ context. */
+ if (SYMBOL_NATURAL_NAME (function))
+ {
+ struct type *context;
+ std::string name_copy (SYMBOL_NATURAL_NAME (function));
+ 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;
+
+ while (1)
+ {
+ unsigned int prefix_len
+ = cp_entire_prefix_len (name_copy.c_str ());
+
+ if (prefix_len == 0)
+ context = NULL;
+ else
+ {
+ name_copy.erase (prefix_len);
+ context = lookup_typename (lang, arch,
+ name_copy.c_str (),
+ parent, 1);
+ }
+
+ if (context == NULL)
+ break;
+
+ sym
+ = search_symbol_list (name,
+ TYPE_N_TEMPLATE_ARGUMENTS (context),
+ TYPE_TEMPLATE_ARGUMENTS (context));
+ if (sym != NULL)
+ {
+ if (symbol_lookup_debug)
+ {
+ fprintf_unfiltered
+ (gdb_stdlog,
+ "cp_lookup_symbol_imports_or_template (...) = %s\n",
+ host_address_to_string (sym));
+ }
+ return (struct block_symbol) {sym, parent};
+ }
+ }
+ }
+ }
+
+ result = cp_lookup_symbol_via_imports (scope, name, block, domain, 0, 1, 1);
+ if (symbol_lookup_debug)
{
- return NULL;
+ fprintf_unfiltered (gdb_stdlog,
+ "cp_lookup_symbol_imports_or_template (...) = %s\n",
+ result.symbol != NULL
+ ? host_address_to_string (result.symbol) : "NULL");
}
- else
+ return result;
+}
+
+/* Search for NAME by applying relevant import statements belonging to BLOCK
+ and its parents. SCOPE is the namespace scope of the context in which the
+ search is being evaluated. */
+
+static struct block_symbol
+cp_lookup_symbol_via_all_imports (const char *scope, const char *name,
+ const struct block *block,
+ const domain_enum domain)
+{
+ struct block_symbol sym;
+
+ while (block != NULL)
{
- struct using_direct *retval
- = obstack_alloc (obstack, sizeof (struct using_direct));
- retval->import_src = obsavestring (using->import_src, strlen (using->import_src),
- obstack);
- retval->import_dest = obsavestring (using->import_dest, strlen (using->import_dest),
- obstack);
- retval->next = cp_copy_usings (using->next, obstack);
-
- xfree (using->import_src);
- xfree (using->import_dest);
- xfree (using);
-
- return retval;
+ sym = cp_lookup_symbol_via_imports (scope, name, block, domain, 0, 0, 1);
+ if (sym.symbol)
+ return sym;
+
+ block = BLOCK_SUPERBLOCK (block);
}
+
+ return null_block_symbol;
}
-/* The C++-specific version of name lookup for static and global
- names. This makes sure that names get looked for in all namespaces
- that are in scope. NAME is the natural name of the symbol that
- we're looking for, LINKAGE_NAME (which is optional) is its linkage
- name, BLOCK is the block that we're searching within, DOMAIN says
- what kind of symbols we're looking for, and if SYMTAB is non-NULL,
- we should store the symtab where we found the symbol in it. */
-
-struct symbol *
-cp_lookup_symbol_nonlocal (const char *name,
- const char *linkage_name,
- const struct block *block,
- const domain_enum domain)
+/* Searches for NAME in the current namespace, and by applying
+ relevant import statements belonging to BLOCK and its parents.
+ SCOPE is the namespace scope of the context in which the search is
+ being evaluated. */
+
+struct block_symbol
+cp_lookup_symbol_namespace (const char *scope,
+ const char *name,
+ const struct block *block,
+ const domain_enum domain)
{
- return lookup_namespace_scope (name, linkage_name, block, domain,
- block_scope (block), 0);
+ struct block_symbol sym;
+
+ if (symbol_lookup_debug)
+ {
+ fprintf_unfiltered (gdb_stdlog,
+ "cp_lookup_symbol_namespace (%s, %s, %s, %s)\n",
+ scope, name, host_address_to_string (block),
+ domain_name (domain));
+ }
+
+ /* First, try to find the symbol in the given namespace. */
+ sym = cp_lookup_symbol_in_namespace (scope, name, block, domain, 1);
+
+ /* Search for name in namespaces imported to this and parent blocks. */
+ if (sym.symbol == NULL)
+ sym = cp_lookup_symbol_via_all_imports (scope, name, block, domain);
+
+ if (symbol_lookup_debug)
+ {
+ fprintf_unfiltered (gdb_stdlog,
+ "cp_lookup_symbol_namespace (...) = %s\n",
+ sym.symbol != NULL
+ ? host_address_to_string (sym.symbol) : "NULL");
+ }
+ return sym;
}
/* Lookup NAME at namespace scope (or, in C terms, in static and
"A::x", and if that call fails, then the first call looks for
"x". */
-static struct symbol *
-lookup_namespace_scope (const char *name,
- const char *linkage_name,
+static struct block_symbol
+lookup_namespace_scope (const struct language_defn *langdef,
+ const char *name,
const struct block *block,
const domain_enum domain,
const char *scope,
int scope_len)
{
- char *namespace;
+ char *the_namespace;
if (scope[scope_len] != '\0')
{
/* Recursively search for names in child namespaces first. */
- struct symbol *sym;
+ struct block_symbol sym;
int new_scope_len = scope_len;
/* If the current scope is followed by "::", skip past that. */
new_scope_len += 2;
}
new_scope_len += cp_find_first_component (scope + new_scope_len);
- sym = lookup_namespace_scope (name, linkage_name, block,
- domain, scope, new_scope_len);
- if (sym != NULL)
+ sym = lookup_namespace_scope (langdef, name, block, domain,
+ scope, new_scope_len);
+ if (sym.symbol != NULL)
return sym;
}
/* Okay, we didn't find a match in our children, so look for the
- name in the current namespace. */
-
- namespace = alloca (scope_len + 1);
- strncpy (namespace, scope, scope_len);
- namespace[scope_len] = '\0';
- return cp_lookup_symbol_namespace (namespace, name, linkage_name,
- block, domain);
+ name in the current namespace.
+
+ If we there is no scope and we know we have a bare symbol, then short
+ circuit everything and call cp_lookup_bare_symbol directly.
+ This isn't an optimization, rather it allows us to pass LANGDEF which
+ is needed for primitive type lookup. The test doesn't have to be
+ perfect: if NAME is a bare symbol that our test doesn't catch (e.g., a
+ template symbol with "::" in the argument list) then
+ cp_lookup_symbol_in_namespace will catch it. */
+
+ if (scope_len == 0 && strchr (name, ':') == NULL)
+ return cp_lookup_bare_symbol (langdef, name, block, domain, 1);
+
+ the_namespace = (char *) alloca (scope_len + 1);
+ strncpy (the_namespace, scope, scope_len);
+ the_namespace[scope_len] = '\0';
+ return cp_lookup_symbol_in_namespace (the_namespace, name,
+ block, domain, 1);
}
-/* Look up NAME in the C++ namespace NAMESPACE, applying the using
- directives that are active in BLOCK. Other arguments are as in
- cp_lookup_symbol_nonlocal. */
+/* The C++-specific version of name lookup for static and global
+ names. This makes sure that names get looked for in all namespaces
+ that are in scope. NAME is the natural name of the symbol that
+ we're looking for, BLOCK is the block that we're searching within,
+ DOMAIN says what kind of symbols we're looking for. */
-struct symbol *
-cp_lookup_symbol_namespace (const char *namespace,
- const char *name,
- const char *linkage_name,
- const struct block *block,
- const domain_enum domain)
+struct block_symbol
+cp_lookup_symbol_nonlocal (const struct language_defn *langdef,
+ const char *name,
+ const struct block *block,
+ const domain_enum domain)
{
- const struct using_direct *current;
- struct symbol *sym;
-
- /* First, go through the using directives. If any of them add new
- names to the namespace we're searching in, see if we can find a
- match by applying them. */
+ struct block_symbol sym;
+ const char *scope = block_scope (block);
- for (current = block_using (block);
- current != NULL;
- current = current->next)
+ if (symbol_lookup_debug)
{
- if (strcmp (namespace, current->import_dest) == 0)
- {
- sym = cp_lookup_symbol_namespace (current->import_src,
- name,
- linkage_name,
- block,
- domain);
- if (sym != NULL)
- return sym;
- }
+ fprintf_unfiltered (gdb_stdlog,
+ "cp_lookup_symbol_non_local"
+ " (%s, %s (scope %s), %s)\n",
+ name, host_address_to_string (block), scope,
+ domain_name (domain));
}
- /* We didn't find anything by applying any of the using directives
- that are still applicable; so let's see if we've got a match
- using the current namespace. */
-
- if (namespace[0] == '\0')
+ /* First, try to find the symbol in the given namespace, and all
+ containing namespaces. */
+ sym = lookup_namespace_scope (langdef, name, block, domain, scope, 0);
+
+ /* Search for name in namespaces imported to this and parent blocks. */
+ if (sym.symbol == NULL)
+ sym = cp_lookup_symbol_via_all_imports (scope, name, block, domain);
+
+ if (symbol_lookup_debug)
{
- return lookup_symbol_file (name, linkage_name, block,
- domain, 0);
+ fprintf_unfiltered (gdb_stdlog,
+ "cp_lookup_symbol_nonlocal (...) = %s\n",
+ (sym.symbol != NULL
+ ? host_address_to_string (sym.symbol)
+ : "NULL"));
}
- else
+ return sym;
+}
+
+/* Search through the base classes of PARENT_TYPE for a base class
+ named NAME and return its type. If not found, return NULL. */
+
+struct type *
+cp_find_type_baseclass_by_name (struct type *parent_type, const char *name)
+{
+ int i;
+
+ parent_type = check_typedef (parent_type);
+ for (i = 0; i < TYPE_N_BASECLASSES (parent_type); ++i)
{
- char *concatenated_name
- = alloca (strlen (namespace) + 2 + strlen (name) + 1);
- strcpy (concatenated_name, namespace);
- strcat (concatenated_name, "::");
- strcat (concatenated_name, name);
- sym = lookup_symbol_file (concatenated_name, linkage_name,
- block, domain,
- cp_is_anonymous (namespace));
- return sym;
+ struct type *type = check_typedef (TYPE_BASECLASS (parent_type, i));
+ const char *base_name = TYPE_BASECLASS_NAME (parent_type, i);
+
+ if (base_name == NULL)
+ continue;
+
+ if (streq (base_name, name))
+ return type;
+
+ type = cp_find_type_baseclass_by_name (type, name);
+ if (type != NULL)
+ return type;
}
+
+ return NULL;
}
-/* Look up NAME in BLOCK's static block and in global blocks. If
- ANONYMOUS_NAMESPACE is nonzero, the symbol in question is located
- within an anonymous namespace. Other arguments are as in
- cp_lookup_symbol_nonlocal. */
+/* Search through the base classes of PARENT_TYPE for a symbol named
+ NAME in block BLOCK. */
-static struct symbol *
-lookup_symbol_file (const char *name,
- const char *linkage_name,
- const struct block *block,
- const domain_enum domain,
- int anonymous_namespace)
+static struct block_symbol
+find_symbol_in_baseclass (struct type *parent_type, const char *name,
+ const struct block *block, const domain_enum domain,
+ int is_in_anonymous)
{
- struct symbol *sym = NULL;
+ int i;
+ struct block_symbol sym;
- sym = lookup_symbol_static (name, linkage_name, block, domain);
- if (sym != NULL)
- return sym;
+ sym.symbol = NULL;
+ sym.block = NULL;
- if (anonymous_namespace)
+ for (i = 0; i < TYPE_N_BASECLASSES (parent_type); ++i)
{
- /* Symbols defined in anonymous namespaces have external linkage
- but should be treated as local to a single file nonetheless.
- So we only search the current file's global block. */
+ struct type *base_type = TYPE_BASECLASS (parent_type, i);
+ const char *base_name = TYPE_BASECLASS_NAME (parent_type, i);
- const struct block *global_block = block_global_block (block);
-
- if (global_block != NULL)
- sym = lookup_symbol_aux_block (name, linkage_name, global_block,
- domain);
+ if (base_name == NULL)
+ continue;
+
+ std::string concatenated_name = std::string (base_name) + "::" + name;
+
+ sym = cp_lookup_nested_symbol_1 (base_type, name,
+ concatenated_name.c_str (),
+ block, domain, 1, is_in_anonymous);
+ if (sym.symbol != NULL)
+ break;
}
- else
+
+ return sym;
+}
+
+/* Helper function to look up NESTED_NAME in CONTAINER_TYPE and in DOMAIN
+ and within the context of BLOCK.
+ NESTED_NAME may have scope ("::").
+ CONTAINER_TYPE needn't have been "check_typedef'd" yet.
+ CONCATENATED_NAME is the fully scoped spelling of NESTED_NAME, it is
+ passed as an argument so that callers can control how space for it is
+ allocated.
+ If BASIC_LOOKUP is non-zero then perform a basic lookup of
+ CONCATENATED_NAME. See cp_basic_lookup_symbol for details.
+ If IS_IN_ANONYMOUS is non-zero then CONCATENATED_NAME is in an anonymous
+ namespace. */
+
+static struct block_symbol
+cp_lookup_nested_symbol_1 (struct type *container_type,
+ const char *nested_name,
+ const char *concatenated_name,
+ const struct block *block,
+ const domain_enum domain,
+ int basic_lookup, int is_in_anonymous)
+{
+ struct block_symbol sym;
+
+ /* NOTE: carlton/2003-11-10: We don't treat C++ class members
+ of classes like, say, data or function members. Instead,
+ they're just represented by symbols whose names are
+ qualified by the name of the surrounding class. This is
+ just like members of namespaces; in particular,
+ cp_basic_lookup_symbol works when looking them up. */
+
+ if (basic_lookup)
{
- sym = lookup_symbol_global (name, linkage_name, block, domain);
+ sym = cp_basic_lookup_symbol (concatenated_name, block, domain,
+ is_in_anonymous);
+ if (sym.symbol != NULL)
+ return sym;
}
- if (sym != NULL)
- return sym;
+ /* Now search all static file-level symbols. We have to do this for things
+ like typedefs in the class. We do not try to guess any imported
+ namespace as even the fully specified namespace search is already not
+ C++ compliant and more assumptions could make it too magic. */
- /* Now call "lookup_possible_namespace_symbol". Symbols in here
- claim to be associated to namespaces, but this claim might be
- incorrect: the names in question might actually correspond to
- classes instead of namespaces. But if they correspond to
- classes, then we should have found a match for them above. So if
- we find them now, they should be genuine. */
+ /* First search in this symtab, what we want is possibly there. */
+ sym = lookup_symbol_in_static_block (concatenated_name, block, domain);
+ if (sym.symbol != NULL)
+ return sym;
- /* FIXME: carlton/2003-06-12: This is a hack and should eventually
- be deleted: see comments below. */
+ /* Nope. We now have to search all static blocks in all objfiles,
+ even if block != NULL, because there's no guarantees as to which
+ symtab the symbol we want is in. Except for symbols defined in
+ anonymous namespaces should be treated as local to a single file,
+ which we just searched. */
+ if (!is_in_anonymous)
+ {
+ sym = lookup_static_symbol (concatenated_name, domain);
+ if (sym.symbol != NULL)
+ return sym;
+ }
- if (domain == VAR_DOMAIN)
+ /* If this is a class with baseclasses, search them next. */
+ container_type = check_typedef (container_type);
+ if (TYPE_N_BASECLASSES (container_type) > 0)
{
- sym = lookup_possible_namespace_symbol (name);
- if (sym != NULL)
+ sym = find_symbol_in_baseclass (container_type, nested_name, block,
+ domain, is_in_anonymous);
+ if (sym.symbol != NULL)
return sym;
}
- return NULL;
+ return null_block_symbol;
}
-/* Look up a type named NESTED_NAME that is nested inside the C++
+/* Look up a symbol named NESTED_NAME that is nested inside the C++
class or namespace given by PARENT_TYPE, from within the context
- given by BLOCK. Return NULL if there is no such nested type. */
-
-struct type *
-cp_lookup_nested_type (struct type *parent_type,
- const char *nested_name,
- const struct block *block)
+ given by BLOCK, and in DOMAIN.
+ Return NULL if there is no such nested symbol. */
+
+struct block_symbol
+cp_lookup_nested_symbol (struct type *parent_type,
+ const char *nested_name,
+ const struct block *block,
+ const domain_enum domain)
{
+ /* type_name_no_tag_or_error provides better error reporting using the
+ original type. */
+ struct type *saved_parent_type = parent_type;
+
+ parent_type = check_typedef (parent_type);
+
+ if (symbol_lookup_debug)
+ {
+ const char *type_name = type_name_no_tag (saved_parent_type);
+
+ fprintf_unfiltered (gdb_stdlog,
+ "cp_lookup_nested_symbol (%s, %s, %s, %s)\n",
+ type_name != NULL ? type_name : "unnamed",
+ nested_name, host_address_to_string (block),
+ domain_name (domain));
+ }
+
switch (TYPE_CODE (parent_type))
{
case TYPE_CODE_STRUCT:
case TYPE_CODE_NAMESPACE:
+ case TYPE_CODE_UNION:
+ case TYPE_CODE_ENUM:
+ /* NOTE: Handle modules here as well, because Fortran is re-using the C++
+ specific code to lookup nested symbols in modules, by calling the
+ function pointer la_lookup_symbol_nonlocal, which ends up here. */
+ case TYPE_CODE_MODULE:
{
- /* NOTE: carlton/2003-11-10: We don't treat C++ class members
- of classes like, say, data or function members. Instead,
- they're just represented by symbols whose names are
- qualified by the name of the surrounding class. This is
- just like members of namespaces; in particular,
- lookup_symbol_namespace works when looking them up. */
-
- const char *parent_name = TYPE_TAG_NAME (parent_type);
- struct symbol *sym = cp_lookup_symbol_namespace (parent_name,
- nested_name,
- NULL,
- block,
- VAR_DOMAIN);
- if (sym == NULL || SYMBOL_CLASS (sym) != LOC_TYPEDEF)
- return NULL;
- else
- return SYMBOL_TYPE (sym);
+ int size;
+ const char *parent_name = type_name_no_tag_or_error (saved_parent_type);
+ struct block_symbol sym;
+ char *concatenated_name;
+ int is_in_anonymous;
+
+ size = strlen (parent_name) + 2 + strlen (nested_name) + 1;
+ concatenated_name = (char *) alloca (size);
+ xsnprintf (concatenated_name, size, "%s::%s",
+ parent_name, nested_name);
+ is_in_anonymous = cp_is_in_anonymous (concatenated_name);
+
+ sym = cp_lookup_nested_symbol_1 (parent_type, nested_name,
+ concatenated_name, block, domain,
+ 1, is_in_anonymous);
+
+ if (symbol_lookup_debug)
+ {
+ fprintf_unfiltered (gdb_stdlog,
+ "cp_lookup_nested_symbol (...) = %s\n",
+ (sym.symbol != NULL
+ ? host_address_to_string (sym.symbol)
+ : "NULL"));
+ }
+ return sym;
}
+
+ case TYPE_CODE_FUNC:
+ case TYPE_CODE_METHOD:
+ if (symbol_lookup_debug)
+ {
+ fprintf_unfiltered (gdb_stdlog,
+ "cp_lookup_nested_symbol (...) = NULL"
+ " (func/method)\n");
+ }
+ return null_block_symbol;
+
default:
internal_error (__FILE__, __LINE__,
- _("cp_lookup_nested_type called on a non-aggregate type."));
+ _("cp_lookup_nested_symbol called "
+ "on a non-aggregate type."));
}
}
/* FIXME: carlton/2004-01-16: The problem that this is trying to
address is that, unfortunately, sometimes NAME is wrong: it may not
include the name of namespaces enclosing the type in question.
- lookup_transparent_type gets called when the the type in question
+ lookup_transparent_type gets called when the type in question
is a declaration, and we're trying to find its definition; but, for
declarations, our type name deduction mechanism doesn't work.
There's nothing we can do to fix this in general, I think, in the
return cp_lookup_transparent_type_loop (name, scope, 0);
}
-/* Lookup the the type definition associated to NAME in
- namespaces/classes containing SCOPE whose name is strictly longer
- than LENGTH. LENGTH must be the index of the start of a
- component of SCOPE. */
+/* Lookup the type definition associated to NAME in namespaces/classes
+ containing SCOPE whose name is strictly longer than LENGTH. LENGTH
+ must be the index of the start of a component of SCOPE. */
static struct type *
-cp_lookup_transparent_type_loop (const char *name, const char *scope,
+cp_lookup_transparent_type_loop (const char *name,
+ const char *scope,
int length)
{
int scope_length = length + cp_find_first_component (scope + length);
if (scope[scope_length] == ':')
{
struct type *retval
- = cp_lookup_transparent_type_loop (name, scope, scope_length + 2);
+ = cp_lookup_transparent_type_loop (name, scope,
+ scope_length + 2);
+
if (retval != NULL)
return retval;
}
- full_name = alloca (scope_length + 2 + strlen (name) + 1);
+ 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);
}
-/* Now come functions for dealing with symbols associated to
- namespaces. (They're used to store the namespaces themselves, not
- objects that live in the namespaces.) These symbols come in two
- varieties: if we run into a DW_TAG_namespace DIE, then we know that
- we have a namespace, so dwarf2read.c creates a symbol for it just
- like normal. But, unfortunately, versions of GCC through at least
- 3.3 don't generate those DIE's. Our solution is to try to guess
- their existence by looking at demangled names. This might cause us
- to misidentify classes as namespaces, however. So we put those
- symbols in a special block (one per objfile), and we only search
- that block as a last resort. */
-
-/* FIXME: carlton/2003-06-12: Once versions of GCC that generate
- DW_TAG_namespace have been out for a year or two, we should get rid
- of all of this "possible namespace" nonsense. */
-
-/* Allocate everything necessary for the possible namespace block
- associated to OBJFILE. */
-
-static void
-initialize_namespace_symtab (struct objfile *objfile)
-{
- struct symtab *namespace_symtab;
- struct blockvector *bv;
- struct block *bl;
-
- namespace_symtab = allocate_symtab ("<<C++-namespaces>>", objfile);
- namespace_symtab->language = language_cplus;
- namespace_symtab->free_code = free_nothing;
- namespace_symtab->dirname = NULL;
-
- bv = obstack_alloc (&objfile->objfile_obstack,
- sizeof (struct blockvector)
- + FIRST_LOCAL_BLOCK * sizeof (struct block *));
- BLOCKVECTOR_NBLOCKS (bv) = FIRST_LOCAL_BLOCK + 1;
- BLOCKVECTOR (namespace_symtab) = bv;
-
- /* Allocate empty GLOBAL_BLOCK and STATIC_BLOCK. */
-
- bl = allocate_block (&objfile->objfile_obstack);
- BLOCK_DICT (bl) = dict_create_linear (&objfile->objfile_obstack,
- NULL);
- BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK) = bl;
- bl = allocate_block (&objfile->objfile_obstack);
- BLOCK_DICT (bl) = dict_create_linear (&objfile->objfile_obstack,
- NULL);
- BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK) = bl;
-
- /* Allocate the possible namespace block; we put it where the first
- local block will live, though I don't think there's any need to
- pretend that it's actually a local block (e.g. by setting
- BLOCK_SUPERBLOCK appropriately). We don't use the global or
- static block because we don't want it searched during the normal
- search of all global/static blocks in lookup_symbol: we only want
- it used as a last resort. */
-
- /* NOTE: carlton/2003-09-11: I considered not associating the fake
- symbols to a block/symtab at all. But that would cause problems
- with lookup_symbol's SYMTAB argument and with block_found, so
- having a symtab/block for this purpose seems like the best
- solution for now. */
-
- bl = allocate_block (&objfile->objfile_obstack);
- BLOCK_DICT (bl) = dict_create_hashed_expandable ();
- BLOCKVECTOR_BLOCK (bv, FIRST_LOCAL_BLOCK) = bl;
-
- namespace_symtab->free_func = free_namespace_block;
-
- objfile->cp_namespace_symtab = namespace_symtab;
-}
-
-/* Locate the possible namespace block associated to OBJFILE,
- allocating it if necessary. */
-
-static struct block *
-get_possible_namespace_block (struct objfile *objfile)
-{
- if (objfile->cp_namespace_symtab == NULL)
- initialize_namespace_symtab (objfile);
-
- return BLOCKVECTOR_BLOCK (BLOCKVECTOR (objfile->cp_namespace_symtab),
- FIRST_LOCAL_BLOCK);
-}
-
-/* Free the dictionary associated to the possible namespace block. */
+/* This used to do something but was removed when it became
+ obsolete. */
static void
-free_namespace_block (struct symtab *symtab)
+maintenance_cplus_namespace (const char *args, int from_tty)
{
- struct block *possible_namespace_block;
-
- possible_namespace_block = BLOCKVECTOR_BLOCK (BLOCKVECTOR (symtab),
- FIRST_LOCAL_BLOCK);
- gdb_assert (possible_namespace_block != NULL);
- dict_free (BLOCK_DICT (possible_namespace_block));
+ printf_unfiltered (_("The `maint namespace' command was removed.\n"));
}
-/* Ensure that there are symbols in the possible namespace block
- associated to OBJFILE for all initial substrings of NAME that look
- like namespaces or classes. NAME should end in a member variable:
- it shouldn't consist solely of namespaces. */
-
-void
-cp_check_possible_namespace_symbols (const char *name, struct objfile *objfile)
-{
- check_possible_namespace_symbols_loop (name,
- cp_find_first_component (name),
- objfile);
-}
-
-/* This is a helper loop for cp_check_possible_namespace_symbols; it
- ensures that there are symbols in the possible namespace block
- associated to OBJFILE for all namespaces that are initial
- substrings of NAME of length at least LEN. It returns 1 if a
- previous loop had already created the shortest such symbol and 0
- otherwise.
-
- This function assumes that if there is already a symbol associated
- to a substring of NAME of a given length, then there are already
- symbols associated to all substrings of NAME whose length is less
- than that length. So if cp_check_possible_namespace_symbols has
- been called once with argument "A::B::C::member", then that will
- create symbols "A", "A::B", and "A::B::C". If it is then later
- called with argument "A::B::D::member", then the new call will
- generate a new symbol for "A::B::D", but once it sees that "A::B"
- has already been created, it doesn't bother checking to see if "A"
- has also been created. */
-
-static int
-check_possible_namespace_symbols_loop (const char *name, int len,
- struct objfile *objfile)
-{
- if (name[len] == ':')
- {
- int done;
- int next_len = len + 2;
-
- next_len += cp_find_first_component (name + next_len);
- done = check_possible_namespace_symbols_loop (name, next_len,
- objfile);
-
- if (!done)
- done = check_one_possible_namespace_symbol (name, len, objfile);
-
- return done;
- }
- else
- return 0;
-}
-
-/* Check to see if there's already a possible namespace symbol in
- OBJFILE whose name is the initial substring of NAME of length LEN.
- If not, create one and return 0; otherwise, return 1. */
-
-static int
-check_one_possible_namespace_symbol (const char *name, int len,
- struct objfile *objfile)
-{
- struct block *block = get_possible_namespace_block (objfile);
- char *name_copy = alloca (len + 1);
- struct symbol *sym;
-
- memcpy (name_copy, name, len);
- name_copy[len] = '\0';
- sym = lookup_block_symbol (block, name_copy, NULL, VAR_DOMAIN);
-
- if (sym == NULL)
- {
- struct type *type;
-
- type = init_type (TYPE_CODE_NAMESPACE, 0, 0, name_copy, objfile);
-
- TYPE_TAG_NAME (type) = TYPE_NAME (type);
-
- sym = obstack_alloc (&objfile->objfile_obstack, sizeof (struct symbol));
- memset (sym, 0, sizeof (struct symbol));
- SYMBOL_LANGUAGE (sym) = language_cplus;
- /* Note that init_type copied the name to the objfile's
- obstack. */
- SYMBOL_SET_NAMES (sym, TYPE_NAME (type), len, 0, objfile);
- SYMBOL_CLASS (sym) = LOC_TYPEDEF;
- SYMBOL_TYPE (sym) = type;
- SYMBOL_DOMAIN (sym) = VAR_DOMAIN;
-
- dict_add_symbol (BLOCK_DICT (block), sym);
-
- return 0;
- }
- else
- return 1;
-}
-
-/* Look for a symbol named NAME in all the possible namespace blocks.
- If one is found, return it. */
-
-static struct symbol *
-lookup_possible_namespace_symbol (const char *name)
-{
- struct objfile *objfile;
-
- ALL_OBJFILES (objfile)
- {
- struct symbol *sym;
-
- sym = lookup_block_symbol (get_possible_namespace_block (objfile),
- name, NULL, VAR_DOMAIN);
-
- if (sym != NULL)
- return sym;
- }
-
- return NULL;
-}
-
-/* Print out all the possible namespace symbols. */
-
-static void
-maintenance_cplus_namespace (char *args, int from_tty)
-{
- struct objfile *objfile;
- printf_unfiltered (_("Possible namespaces:\n"));
- ALL_OBJFILES (objfile)
- {
- struct dict_iterator iter;
- struct symbol *sym;
-
- ALL_BLOCK_SYMBOLS (get_possible_namespace_block (objfile), iter, sym)
- {
- printf_unfiltered ("%s\n", SYMBOL_PRINT_NAME (sym));
- }
- }
-}
-
-/* Provide a prototype to silence -Wmissing-prototypes. */
-extern initialize_file_ftype _initialize_cp_namespace;
-
void
_initialize_cp_namespace (void)
{
- add_cmd ("namespace", class_maintenance, maintenance_cplus_namespace,
- _("Print the list of possible C++ namespaces."),
- &maint_cplus_cmd_list);
+ struct cmd_list_element *cmd;
+
+ cmd = add_cmd ("namespace", class_maintenance,
+ maintenance_cplus_namespace,
+ _("Deprecated placeholder for removed functionality."),
+ &maint_cplus_cmd_list);
+ deprecate_cmd (cmd, NULL);
}