2003-04-30 David Carlton <carlton@bactrian.org>

	* Makefile.in (cp-namespace.o): Update dependencies.
	(cp-support.o): Ditto.
	* cp-support.h: Declare maint_cplus_cmd_list.
	* cp-namespace.c: Move variables namespace_block,
	possible_namespace_block, namespace_objfile here from
	cp-support.c.
	Move functions initialize_namespace_blocks, get_namespace_block,
	get_possible_namespace_block, free_namespace_blocks,
	check_one_possible_namespace_symbol,
	check_possible_namespace_symbols_loop, maintenance_print_namespace
	here from cp-support.c.
	Include objfiles.h, gdbtypes.h, dictionary.h, gdbcmd.h.
	* cp-namespace.c (_initialize_cp_namespace): New.
	(maintenance_cplus_namespace): Rename from
	maintenance_print_namespace.
	* cp-support.c (cp_find_first_component): Fix typo in comment.
	(_initialize_cp_support): Don't add 'maint print
	namespace'.
	Make maint_cplus_cmd_list extern.
	Prune includes.

2003-04-30  David Carlton  <carlton@bactrian.org>

	* gdb.c++/maint.exp (test_help): Refactor, and add test for maint
	cp namespace.
	(test_namespace): New.

7 files changed, 361 insertions, 311 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index ec0af51491a..56020809e0f 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,26 @@
+2003-04-30  David Carlton  <carlton@bactrian.org>
+
+	* Makefile.in (cp-namespace.o): Update dependencies.
+	(cp-support.o): Ditto.
+	* cp-support.h: Declare maint_cplus_cmd_list.
+	* cp-namespace.c: Move variables namespace_block,
+	possible_namespace_block, namespace_objfile here from
+	cp-support.c.
+	Move functions initialize_namespace_blocks, get_namespace_block,
+	get_possible_namespace_block, free_namespace_blocks,
+	check_one_possible_namespace_symbol,
+	check_possible_namespace_symbols_loop, maintenance_print_namespace
+	here from cp-support.c.
+	Include objfiles.h, gdbtypes.h, dictionary.h, gdbcmd.h.
+	* cp-namespace.c (_initialize_cp_namespace): New.
+	(maintenance_cplus_namespace): Rename from
+	maintenance_print_namespace.
+	* cp-support.c (cp_find_first_component): Fix typo in comment.
+	(_initialize_cp_support): Don't add 'maint print
+	namespace'.
+	Make maint_cplus_cmd_list extern.
+	Prune includes.
+
 2003-04-18  David Carlton  <carlton@bactrian.org>
 
 	* mdebugread.c (parse_symbol): Move up declaration of 'iter'.
diff --git a/gdb/Makefile.in b/gdb/Makefile.in
index dffb8aa26fd..d7d32cf33ba 100644
--- a/gdb/Makefile.in
+++ b/gdb/Makefile.in
@@ -1619,11 +1619,10 @@ corelow.o: corelow.c $(defs_h) $(gdb_string_h) $(frame_h) $(inferior_h) \
 cp-abi.o: cp-abi.c $(defs_h) $(value_h) $(cp_abi_h) $(command_h) \
 	$(gdbcmd_h) $(ui_out_h) $(gdb_string_h)
 cp-namespace.o: cp-namespace.c $(defs_h) $(cp_support_h) $(gdb_obstack_h) \
-	$(symtab_h) $(symfile_h) $(gdb_assert_h) $(block_h)
+	$(symtab_h) $(symfile_h) $(gdb_assert_h) $(block_h) $(objfiles_h) \
+	$(gdbtypes_h) $(dictionary_h) $(gdbcmd_h)
 cp-support.o: cp-support.c $(defs_h) $(cp_support_h) $(gdb_string_h) \
-	$(demangle_h) $(gdb_assert_h) $(gdb_obstack_h) $(symtab_h) \
-	$(symfile_h) $(block_h) $(objfiles_h) $(gdbtypes_h) $(dictionary_h) \
-	$(gdbcmd_h)
+	$(demangle_h) $(gdb_assert_h) $(symtab_h) $(gdbcmd_h)
 cp-valprint.o: cp-valprint.c $(defs_h) $(gdb_obstack_h) $(symtab_h) \
 	$(gdbtypes_h) $(expression_h) $(value_h) $(command_h) $(gdbcmd_h) \
 	$(demangle_h) $(annotate_h) $(gdb_string_h) $(c_lang_h) $(target_h) \
diff --git a/gdb/cp-namespace.c b/gdb/cp-namespace.c
index 24741c33c53..339cea788d2 100644
--- a/gdb/cp-namespace.c
+++ b/gdb/cp-namespace.c
@@ -27,6 +27,10 @@
 #include "symfile.h"
 #include "gdb_assert.h"
 #include "block.h"
+#include "objfiles.h"
+#include "gdbtypes.h"
+#include "dictionary.h"
+#include "gdbcmd.h"
 
 /* When set, the file that we're processing seems to have debugging
    info for C++ namespaces, so cp-namespace.c shouldn't try to guess
@@ -52,6 +56,35 @@ static struct using_direct *cp_add_using (const char *name,
 static struct using_direct *cp_copy_usings (struct using_direct *using,
 					    struct obstack *obstack);
 
+/* This block exists only to store symbols associated to namespaces.
+   Normally, try to avoid accessing it directly: instead, use
+   get_namespace_block if you can.  Similarly with
+   possible_namespace_block and namespace_objfile.  */
+
+static struct block *namespace_block = NULL;
+
+static struct block *possible_namespace_block = NULL;
+
+static struct objfile *namespace_objfile = NULL;
+
+static void initialize_namespace_blocks (void);
+
+static struct block *get_namespace_block (void);
+
+static struct block *get_possible_namespace_block (void);
+
+static struct objfile *get_namespace_objfile (void);
+
+static void free_namespace_blocks (struct symtab *symtab);
+
+static int check_one_possible_namespace_symbol (const char *name,
+						int len);
+
+static int check_possible_namespace_symbols_loop (const char *name,
+						  int len);
+
+static void maintenance_print_namespace (char *args, int from_tty);
+
 /* Set up support for dealing with C++ namespace info in the current
    symtab.  */
 
@@ -264,3 +297,273 @@ cp_copy_usings (struct using_direct *using,
       return retval;
     }
 }
+
+/* Allocate everything necessary for namespace_block and
+   possible_namespace_block.  */
+
+static void
+initialize_namespace_blocks (void)
+{
+  struct objfile *objfile = get_namespace_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;
+
+  /* 2 = 3 blocks (global = namespace_block, static = NULL,
+     possible_namespace_block) - 1 block that's always part of struct
+     blockvector.  */
+  bv = obstack_alloc (&objfile->symbol_obstack,
+		      sizeof (struct blockvector)
+		      + 2 * sizeof (struct block *));
+  BLOCKVECTOR_NBLOCKS (bv) = 3;
+  BLOCKVECTOR (namespace_symtab) = bv;
+  
+  /* Allocate dummy STATIC_BLOCK. */
+  bl = allocate_block (&objfile->symbol_obstack);
+  BLOCK_DICT (bl) = dict_create_linear (&objfile->symbol_obstack,
+					NULL);
+  BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK) = bl;
+
+  /* Allocate GLOBAL_BLOCK, which is namespace_block.  */
+  bl = allocate_block (&objfile->symbol_obstack);
+  BLOCK_DICT (bl) = dict_create_hashed_expandable ();
+  BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK) = bl;
+  namespace_block = bl;
+
+  /* Allocate 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).  */
+  bl = allocate_block (&objfile->symbol_obstack);
+  BLOCK_DICT (bl) = dict_create_hashed_expandable ();
+  BLOCKVECTOR_BLOCK (bv, 2) = bl;
+  possible_namespace_block = bl;
+
+  namespace_symtab->free_func = free_namespace_blocks;
+}
+
+/* Locate namespace_block, allocating it if necessary.  */
+
+static struct block *
+get_namespace_block (void)
+{
+  if (namespace_block == NULL)
+    initialize_namespace_blocks ();
+
+  return namespace_block;
+}
+
+/* Locate possible_namespace_block, allocating it if necessary.  */
+
+static struct block *
+get_possible_namespace_block (void)
+{
+  if (namespace_block == NULL)
+    initialize_namespace_blocks ();
+
+  return possible_namespace_block;
+}
+
+/* Free the dictionary associated to the namespace block.  */
+
+static void
+free_namespace_blocks (struct symtab *symtab)
+{
+  gdb_assert (namespace_block != NULL);
+  dict_free (BLOCK_DICT (namespace_block));
+  namespace_block = NULL;
+  dict_free (BLOCK_DICT (possible_namespace_block));
+  possible_namespace_block = NULL;
+  namespace_objfile = NULL;
+}
+
+/* Locate the namespace objfile, allocating it if necessary.  */
+
+static struct objfile *
+get_namespace_objfile (void)
+{
+  if (namespace_objfile == NULL)
+    {
+      namespace_objfile = allocate_objfile (NULL, 0);
+      namespace_objfile->name = "<C++-namespaces>";
+    }
+
+  return namespace_objfile;
+}
+
+/* Check to see if there's already a namespace symbol corresponding to
+   the initial substring of NAME whose length is LEN; if there isn't
+   one, allocate one and add it to the namespace symtab.  Return the
+   symbol in question.  */
+
+struct symbol *
+cp_check_namespace_symbol (const char *name, int len)
+{
+  struct objfile *objfile = get_namespace_objfile ();
+  char *name_copy = obsavestring (name, len, &objfile->symbol_obstack);
+  struct symbol *sym = cp_lookup_namespace_symbol (name_copy);
+
+  if (sym == NULL)
+    {
+      struct type *type = init_type (TYPE_CODE_NAMESPACE, 0, 0,
+				     name_copy, objfile);
+      TYPE_TAG_NAME (type) = TYPE_NAME (type);
+
+      sym = obstack_alloc (&objfile->symbol_obstack, sizeof (struct symbol));
+      memset (sym, 0, sizeof (struct symbol));
+      SYMBOL_LANGUAGE (sym) = language_cplus;
+      DEPRECATED_SYMBOL_NAME (sym) = name_copy;
+      SYMBOL_CLASS (sym) = LOC_TYPEDEF;
+      SYMBOL_TYPE (sym) = type;
+      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+
+      dict_add_symbol (BLOCK_DICT (get_namespace_block ()), sym);
+    }
+  else
+    {
+      obstack_free (&objfile->symbol_obstack, name_copy);
+    }
+
+  return sym;
+}
+
+/* Look for a symbol in namespace_block named NAME.  */
+
+struct symbol *
+cp_lookup_namespace_symbol (const char *name)
+{
+  return lookup_block_symbol (get_namespace_block (), name, NULL,
+			      VAR_NAMESPACE);
+}
+
+/* The next few functions deal with "possible namespace symbols".
+   These are symbols that claim to be associated to namespaces,
+   whereas in fact we don't know if the object of that name is a
+   namespace or a class.  So don't trust them until you've searched
+   through all the global symbols to see if there's a class of that
+   name or not.  */
+
+/* FIXME: carlton/2002-12-18: This concept is a hack.  But it seems to
+   be the easiest way to deal with our desire for namespace symbols,
+   given the commonness of compilers that don't generate debugging
+   info for them.  Once such compilers are more common, we should
+   delete all the possible namespace stuff.  */
+
+/* Check to see if there's already a possible namespace symbol 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 = get_namespace_objfile ();
+  char *name_copy = obsavestring (name, len, &objfile->symbol_obstack);
+  const struct block *block = get_possible_namespace_block ();
+  struct symbol *sym = lookup_block_symbol (block, name_copy,
+					    NULL, VAR_NAMESPACE);
+
+  if (sym == NULL)
+    {
+      struct type *type = init_type (TYPE_CODE_NAMESPACE, 0, 0,
+				     name_copy, objfile);
+      TYPE_TAG_NAME (type) = TYPE_NAME (type);
+
+      sym = obstack_alloc (&objfile->symbol_obstack, sizeof (struct symbol));
+      memset (sym, 0, sizeof (struct symbol));
+      SYMBOL_LANGUAGE (sym) = language_cplus;
+      DEPRECATED_SYMBOL_NAME (sym) = name_copy;
+      SYMBOL_CLASS (sym) = LOC_TYPEDEF;
+      SYMBOL_TYPE (sym) = type;
+      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
+
+      dict_add_symbol (BLOCK_DICT (block), sym);
+      return 0;
+    }
+  else
+    {
+      obstack_free (&objfile->symbol_obstack, name_copy);
+      return 1;
+    }
+}
+
+/* This is a helper loop for cp_check_possible_namespace_symbols; it
+   ensures that there are namespace symbols for all namespaces that
+   are initial substrings of NAME of length LEN.  It returns 1 if a
+   previous loop had already created the shortest such symbol and 0
+   otherwise.  */
+
+static int
+check_possible_namespace_symbols_loop (const char *name, int len)
+{
+  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);
+
+      if (!done)
+	{
+	  done = check_one_possible_namespace_symbol (name, len);
+	}
+
+      return done;
+    }
+  else
+    return 0;
+}
+
+/* Ensure that there are symbols in possible_namespace_block for all
+   initial substrings of NAME that look like namespaces or
+   classes.  */
+
+void
+cp_check_possible_namespace_symbols (const char *name)
+{
+  check_possible_namespace_symbols_loop (name,
+					 cp_find_first_component (name));
+}
+
+/* Look for a symbol in possible_namespace_block named NAME.  */
+
+struct symbol *
+cp_lookup_possible_namespace_symbol (const char *name)
+{
+  return lookup_block_symbol (get_possible_namespace_block (),
+			      name, NULL, VAR_NAMESPACE);
+}
+
+static void
+maintenance_cplus_namespace (char *args, int from_tty)
+{
+  const struct block *namespace_block = get_namespace_block ();
+  const struct block *possible_namespace_block
+    = get_possible_namespace_block ();
+  struct dict_iterator iter;
+  struct symbol *sym;
+
+  printf_unfiltered ("Definite namespaces:\n");
+  ALL_BLOCK_SYMBOLS (namespace_block, iter, sym)
+    {
+      printf_unfiltered ("%s\n", SYMBOL_PRINT_NAME (sym));
+    }
+  printf_unfiltered ("Possible namespaces:\n");
+  ALL_BLOCK_SYMBOLS (possible_namespace_block, iter, sym)
+    {
+      printf_unfiltered ("%s\n", SYMBOL_PRINT_NAME (sym));
+    }
+}
+
+void
+_initialize_cp_namespace (void)
+{
+  add_cmd ("namespace", class_maintenance, maintenance_cplus_namespace,
+	   "Print the list of current known C++ namespaces.",
+	   &maint_cplus_cmd_list);
+}
diff --git a/gdb/cp-support.c b/gdb/cp-support.c
index b2f746c708a..c4c45f5780e 100644
--- a/gdb/cp-support.c
+++ b/gdb/cp-support.c
@@ -1,7 +1,7 @@
 /* Helper routines for C++ support in GDB.
    Copyright 2002, 2003 Free Software Foundation, Inc.
 
-   Contributed by MontaVista Software and Stanford University.
+   Contributed by MontaVista Software.
 
    This file is part of GDB.
 
@@ -26,18 +26,12 @@
 #include "gdb_string.h"
 #include "demangle.h"
 #include "gdb_assert.h"
-#include "gdb_obstack.h"
 #include "symtab.h"
-#include "symfile.h"
-#include "block.h"
-#include "objfiles.h"
-#include "gdbtypes.h"
-#include "dictionary.h"
 #include "gdbcmd.h"
 
 /* The list of "maint cplus" commands.  */
 
-static struct cmd_list_element *maint_cplus_cmd_list = NULL;
+struct cmd_list_element *maint_cplus_cmd_list = NULL;
 
 /* The actual commands.  */
 
@@ -46,35 +40,6 @@ static void first_component_command (char *arg, int from_tty);
 
 static const char *find_last_component (const char *name);
 
-/* This block exists only to store symbols associated to namespaces.
-   Normally, try to avoid accessing it directly: instead, use
-   get_namespace_block if you can.  Similarly with
-   possible_namespace_block and namespace_objfile.  */
-
-static struct block *namespace_block = NULL;
-
-static struct block *possible_namespace_block = NULL;
-
-static struct objfile *namespace_objfile = NULL;
-
-static void initialize_namespace_blocks (void);
-
-static struct block *get_namespace_block (void);
-
-static struct block *get_possible_namespace_block (void);
-
-static struct objfile *get_namespace_objfile (void);
-
-static void free_namespace_blocks (struct symtab *symtab);
-
-static int check_one_possible_namespace_symbol (const char *name,
-						int len);
-
-static int check_possible_namespace_symbols_loop (const char *name,
-						  int len);
-
-static void maintenance_print_namespace (char *args, int from_tty);
-
 /* Here are some random pieces of trivia to keep in mind while trying
    to take apart demangled names:
 
@@ -284,7 +249,7 @@ cp_find_first_component (const char *name)
 	case ':':
 	  return index;
 	case 'o':
-	  /* Operator names can screw up the recurson.  */
+	  /* Operator names can screw up the recursion.  */
 	  if (operator_possible
 	      && strncmp (name + index, "operator", LENGTH_OF_OPERATOR) == 0)
 	    {
@@ -362,268 +327,6 @@ cp_entire_prefix_len (const char *name)
   return previous_len;
 }
 
-/* Allocate everything necessary for namespace_block and
-   possible_namespace_block.  */
-
-static void
-initialize_namespace_blocks (void)
-{
-  struct objfile *objfile = get_namespace_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;
-
-  /* 2 = 3 blocks (global = namespace_block, static = NULL,
-     possible_namespace_block) - 1 block that's always part of struct
-     blockvector.  */
-  bv = obstack_alloc (&objfile->symbol_obstack,
-		      sizeof (struct blockvector)
-		      + 2 * sizeof (struct block *));
-  BLOCKVECTOR_NBLOCKS (bv) = 3;
-  BLOCKVECTOR (namespace_symtab) = bv;
-  
-  /* Allocate dummy STATIC_BLOCK. */
-  bl = allocate_block (&objfile->symbol_obstack);
-  BLOCK_DICT (bl) = dict_create_linear (&objfile->symbol_obstack,
-					NULL);
-  BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK) = bl;
-
-  /* Allocate GLOBAL_BLOCK, which is namespace_block.  */
-  bl = allocate_block (&objfile->symbol_obstack);
-  BLOCK_DICT (bl) = dict_create_hashed_expandable ();
-  BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK) = bl;
-  namespace_block = bl;
-
-  /* Allocate 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).  */
-  bl = allocate_block (&objfile->symbol_obstack);
-  BLOCK_DICT (bl) = dict_create_hashed_expandable ();
-  BLOCKVECTOR_BLOCK (bv, 2) = bl;
-  possible_namespace_block = bl;
-
-  namespace_symtab->free_func = free_namespace_blocks;
-}
-
-/* Locate namespace_block, allocating it if necessary.  */
-
-static struct block *
-get_namespace_block (void)
-{
-  if (namespace_block == NULL)
-    initialize_namespace_blocks ();
-
-  return namespace_block;
-}
-
-/* Locate possible_namespace_block, allocating it if necessary.  */
-
-static struct block *
-get_possible_namespace_block (void)
-{
-  if (namespace_block == NULL)
-    initialize_namespace_blocks ();
-
-  return possible_namespace_block;
-}
-
-/* Free the dictionary associated to the namespace block.  */
-
-static void
-free_namespace_blocks (struct symtab *symtab)
-{
-  gdb_assert (namespace_block != NULL);
-  dict_free (BLOCK_DICT (namespace_block));
-  namespace_block = NULL;
-  dict_free (BLOCK_DICT (possible_namespace_block));
-  possible_namespace_block = NULL;
-  namespace_objfile = NULL;
-}
-
-/* Locate the namespace objfile, allocating it if necessary.  */
-
-static struct objfile *
-get_namespace_objfile (void)
-{
-  if (namespace_objfile == NULL)
-    {
-      namespace_objfile = allocate_objfile (NULL, 0);
-      namespace_objfile->name = "<C++-namespaces>";
-    }
-
-  return namespace_objfile;
-}
-
-/* Check to see if there's already a namespace symbol corresponding to
-   the initial substring of NAME whose length is LEN; if there isn't
-   one, allocate one and add it to the namespace symtab.  Return the
-   symbol in question.  */
-
-struct symbol *
-cp_check_namespace_symbol (const char *name, int len)
-{
-  struct objfile *objfile = get_namespace_objfile ();
-  char *name_copy = obsavestring (name, len, &objfile->symbol_obstack);
-  struct symbol *sym = cp_lookup_namespace_symbol (name_copy);
-
-  if (sym == NULL)
-    {
-      struct type *type = init_type (TYPE_CODE_NAMESPACE, 0, 0,
-				     name_copy, objfile);
-      TYPE_TAG_NAME (type) = TYPE_NAME (type);
-
-      sym = obstack_alloc (&objfile->symbol_obstack, sizeof (struct symbol));
-      memset (sym, 0, sizeof (struct symbol));
-      SYMBOL_LANGUAGE (sym) = language_cplus;
-      DEPRECATED_SYMBOL_NAME (sym) = name_copy;
-      SYMBOL_CLASS (sym) = LOC_TYPEDEF;
-      SYMBOL_TYPE (sym) = type;
-      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
-
-      dict_add_symbol (BLOCK_DICT (get_namespace_block ()), sym);
-    }
-  else
-    {
-      obstack_free (&objfile->symbol_obstack, name_copy);
-    }
-
-  return sym;
-}
-
-/* Look for a symbol in namespace_block named NAME.  */
-
-struct symbol *
-cp_lookup_namespace_symbol (const char *name)
-{
-  return lookup_block_symbol (get_namespace_block (), name, NULL,
-			      VAR_NAMESPACE);
-}
-
-/* The next few functions deal with "possible namespace symbols".
-   These are symbols that claim to be associated to namespaces,
-   whereas in fact we don't know if the object of that name is a
-   namespace or a class.  So don't trust them until you've searched
-   through all the global symbols to see if there's a class of that
-   name or not.  */
-
-/* FIXME: carlton/2002-12-18: This concept is a hack.  But it seems to
-   be the easiest way to deal with our desire for namespace symbols,
-   given the commonness of compilers that don't generate debugging
-   info for them.  Once such compilers are more common, we should
-   delete all the possible namespace stuff.  */
-
-/* Check to see if there's already a possible namespace symbol 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 = get_namespace_objfile ();
-  char *name_copy = obsavestring (name, len, &objfile->symbol_obstack);
-  const struct block *block = get_possible_namespace_block ();
-  struct symbol *sym = lookup_block_symbol (block, name_copy,
-					    NULL, VAR_NAMESPACE);
-
-  if (sym == NULL)
-    {
-      struct type *type = init_type (TYPE_CODE_NAMESPACE, 0, 0,
-				     name_copy, objfile);
-      TYPE_TAG_NAME (type) = TYPE_NAME (type);
-
-      sym = obstack_alloc (&objfile->symbol_obstack, sizeof (struct symbol));
-      memset (sym, 0, sizeof (struct symbol));
-      SYMBOL_LANGUAGE (sym) = language_cplus;
-      DEPRECATED_SYMBOL_NAME (sym) = name_copy;
-      SYMBOL_CLASS (sym) = LOC_TYPEDEF;
-      SYMBOL_TYPE (sym) = type;
-      SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
-
-      dict_add_symbol (BLOCK_DICT (block), sym);
-      return 0;
-    }
-  else
-    {
-      obstack_free (&objfile->symbol_obstack, name_copy);
-      return 1;
-    }
-}
-
-/* This is a helper loop for cp_check_possible_namespace_symbols; it
-   ensures that there are namespace symbols for all namespaces that
-   are initial substrings of NAME of length LEN.  It returns 1 if a
-   previous loop had already created the shortest such symbol and 0
-   otherwise.  */
-
-static int
-check_possible_namespace_symbols_loop (const char *name, int len)
-{
-  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);
-
-      if (!done)
-	{
-	  done = check_one_possible_namespace_symbol (name, len);
-	}
-
-      return done;
-    }
-  else
-    return 0;
-}
-
-/* Ensure that there are symbols in possible_namespace_block for all
-   initial substrings of NAME that look like namespaces or
-   classes.  */
-
-void
-cp_check_possible_namespace_symbols (const char *name)
-{
-  check_possible_namespace_symbols_loop (name,
-					 cp_find_first_component (name));
-}
-
-/* Look for a symbol in possible_namespace_block named NAME.  */
-
-struct symbol *
-cp_lookup_possible_namespace_symbol (const char *name)
-{
-  return lookup_block_symbol (get_possible_namespace_block (),
-			      name, NULL, VAR_NAMESPACE);
-}
-
-static void
-maintenance_print_namespace (char *args, int from_tty)
-{
-  const struct block *namespace_block = get_namespace_block ();
-  const struct block *possible_namespace_block
-    = get_possible_namespace_block ();
-  struct dict_iterator iter;
-  struct symbol *sym;
-
-  printf_unfiltered ("Definite namespaces:\n");
-  ALL_BLOCK_SYMBOLS (namespace_block, iter, sym)
-    {
-      printf_unfiltered ("%s\n", SYMBOL_PRINT_NAME (sym));
-    }
-  printf_unfiltered ("Possible namespaces:\n");
-  ALL_BLOCK_SYMBOLS (possible_namespace_block, iter, sym)
-    {
-      printf_unfiltered ("%s\n", SYMBOL_PRINT_NAME (sym));
-    }
-}
-
 /* If FULL_NAME is the demangled name of a C++ function (including an
    arg list, possibly including namespace/class qualifications),
    return a new string containing only the function name (without the
@@ -688,7 +391,4 @@ _initialize_cp_support (void)
   add_cmd ("first_component", class_maintenance, first_component_command,
 	   "Print the first class/namespace component of NAME.",
 	   &maint_cplus_cmd_list);
-  add_cmd ("namespace", class_maintenance, maintenance_print_namespace,
-	   "Print the list of current known C++ namespaces.",
-	   &maintenanceprintlist);
 }
diff --git a/gdb/cp-support.h b/gdb/cp-support.h
index 1bf1c727ed8..cb53e8a35fe 100644
--- a/gdb/cp-support.h
+++ b/gdb/cp-support.h
@@ -88,4 +88,8 @@ extern void cp_set_block_scope (const struct symbol *symbol,
 
 extern void cp_scan_for_anonymous_namespaces (const struct symbol *symbol);
 
+/* The list of "maint cplus" commands.  */
+
+extern struct cmd_list_element *maint_cplus_cmd_list;
+
 #endif /* CP_SUPPORT_H */
diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog
index 8776e7f57b8..9b31a200f2a 100644
--- a/gdb/testsuite/ChangeLog
+++ b/gdb/testsuite/ChangeLog
@@ -1,3 +1,9 @@
+2003-04-30  David Carlton  <carlton@bactrian.org>
+
+	* gdb.c++/maint.exp (test_help): Refactor, and add test for maint
+	cp namespace.
+	(test_namespace): New.
+
 2003-04-18  David Carlton  <carlton@bactrian.org>
 
 	* gdb.c++/maint.exp (test_first_component): Add tests for
diff --git a/gdb/testsuite/gdb.c++/maint.exp b/gdb/testsuite/gdb.c++/maint.exp
index 3da1a5a6581..c61a790cdc4 100644
--- a/gdb/testsuite/gdb.c++/maint.exp
+++ b/gdb/testsuite/gdb.c++/maint.exp
@@ -29,13 +29,19 @@ if $tracelevel then {
 # Test the help messages.
 
 proc test_help {} {
-    gdb_test "help maintenance cplus" "C\\+\\+ maintenance commands.\r\n\r\nList of maintenance cplus subcommands:\r\n\r\nmaintenance cplus first_component -- Print the first class/namespace component of NAME\r\n\r\nType \"help maintenance cplus\" followed by maintenance cplus subcommand name for full documentation.\r\nCommand name abbreviations are allowed if unambiguous."
+    set first_component_help "Print the first class/namespace component of NAME"
+    set namespace_help "Print the list of current known C\\+\\+ namespaces"
 
-    gdb_test "help maint cp" "C\\+\\+ maintenance commands.\r\n\r\nList of maintenance cplus subcommands:\r\n\r\nmaintenance cplus first_component -- Print the first class/namespace component of NAME\r\n\r\nType \"help maintenance cplus\" followed by maintenance cplus subcommand name for full documentation.\r\nCommand name abbreviations are allowed if unambiguous."
+    set multiple_help_body "List of maintenance cplus subcommands:\r\n\r\nmaintenance cplus first_component -- ${first_component_help}\r\nmaintenance cplus namespace -- ${namespace_help}\r\n\r\nType \"help maintenance cplus\" followed by maintenance cplus subcommand name for full documentation.\r\nCommand name abbreviations are allowed if unambiguous."
 
-    gdb_test "maint cp" "\"maintenance cplus\" must be followed by the name of a command.\r\nList of maintenance cplus subcommands:\r\n\r\nmaintenance cplus first_component -- Print the first class/namespace component of NAME\r\n\r\nType \"help maintenance cplus\" followed by maintenance cplus subcommand name for full documentation.\r\nCommand name abbreviations are allowed if unambiguous."
+    set help_maint_cp "C\\+\\+ maintenance commands.\r\n\r\n${multiple_help_body}"
 
-    gdb_test "help maint cp first_component" "Print the first class/namespace component of NAME."
+    gdb_test "help maintenance cplus" "${help_maint_cp}"
+    gdb_test "help maint cp" "${help_maint_cp}"
+    gdb_test "maint cp" "\"maintenance cplus\" must be followed by the name of a command.\r\n${multiple_help_body}"
+
+    gdb_test "help maint cp first_component" "${first_component_help}."
+    gdb_test "help maint cp namespace" "${namespace_help}."
 }
 
 # This is used when NAME should contain only a single component.  Be
@@ -74,11 +80,20 @@ proc test_first_component {} {
     gdb_test "maint cp first_component C<std::basic_streambuf<wchar_t,std::char_traits<wchar_t> > >::bar" "C<std::basic_streambuf<wchar_t,std::char_traits<wchar_t> > >"
 }
 
+proc test_namespace {} {
+    # FIXME: carlton/2003-04-28: I should think of more tests to add
+    # here.  Unfortunately, it's hard to predict exactly what will be
+    # picked up from the library, or what order it will be in.
+
+    gdb_test "maint cp namespace" "Definite namespaces:\r\nPossible namespaces:"
+}
+
 gdb_exit
 gdb_start
 
 test_help
 test_first_component
+test_namespace
 
 gdb_exit
 return 0