gdb

	* symfile.c (reread_symbols): Update.
	* objfiles.h (struct objfile) <cp_namespace_symtab>: Remove
	field.
	* objfiles.c (allocate_objfile): Update.
	* cp-support.h (cp_check_possible_namespace_symbols): Don't
	declare.
	* cp-namespace.c (lookup_symbol_file): Don't call
	lookup_possible_namespace_symbol.
	(initialize_namespace_symtab, get_possible_namespace_block)
	(free_namespace_block, cp_check_possible_namespace_symbols)
	(check_possible_namespace_symbols_loop)
	(check_one_possible_namespace_symbol)
	(lookup_possible_namespace_symbol): Remove.
	(maintenance_cplus_namespace): Replace with notice.
	(_initialize_cp_namespace): Deprecate `maint cplus namespace'.
gdb/testsuite
	* gdb.cp/maint.exp (test_help): Update.
	(test_namespace): Likewise.

1 files changed, 11 insertions, 276 deletions

diff --git a/gdb/cp-namespace.c b/gdb/cp-namespace.c
index bdbc215..030cfb9 100644
--- a/gdb/cp-namespace.c
+++ b/gdb/cp-namespace.c
@@ -49,24 +49,6 @@ 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.  */
 
@@ -636,27 +618,7 @@ lookup_symbol_file (const char *name,
       sym = lookup_symbol_global (name, block, domain);
     }
 
-  if (sym != NULL)
-    return sym;
-
-  /* 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.  */
-
-  /* FIXME: carlton/2003-06-12: This is a hack and should eventually
-     be deleted: see comments below.  */
-
-  if (domain == VAR_DOMAIN)
-    {
-      sym = lookup_possible_namespace_symbol (name);
-      if (sym != NULL)
-	return sym;
-    }
-
-  return NULL;
+  return sym;
 }
 
 /* Look up a type named NESTED_NAME that is nested inside the C++
@@ -784,243 +746,13 @@ cp_lookup_transparent_type_loop (const char *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.  */
-
-static void
-free_namespace_block (struct symtab *symtab)
-{
-  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));
-}
-
-/* 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, 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_SET_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, VAR_DOMAIN);
-
-      if (sym != NULL)
-	return sym;
-    }
-
-  return NULL;
-}
-
-/* Print out all the possible namespace symbols.  */
+/* This used to do something but was removed when it became
+   obsolete.  */
 
 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));
-	}
-    }
+  printf_unfiltered (_("The `maint namespace' command was removed.\n"));
 }
 
 /* Provide a prototype to silence -Wmissing-prototypes.  */
@@ -1029,8 +761,11 @@ 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);
 }