2003-09-11 David Carlton <carlton@kealia.com>

	* gdbtypes.h: Add TYPE_CODE_NAMESPACE.
	* gdbtypes.c (init_type): Handle TYPE_CODE_NAMESPACE.
	(recursive_dump_type): Ditto.
	* printcmd.c (print_formatted): Ditto.
	* typeprint.c (print_type_scalar): Ditto.
	* c-typeprint.c (c_type_print_varspec_prefix): Ditto.
	(c_type_print_varspec_suffix, c_type_print_base): Ditto.
	* cp-support.h: Declare cp_check_possible_namespace_symbols,
	maint_cplus_cmd_list.
	* cp-support.c: Make maint_cplus_cmd_list extern.
	* cp-namespace.c: Include objfiles.h, gdbtypes.h, dictionary.h,
	command.h.
	(lookup_symbol_file): Look in possible namespace blocks when
	appropriate.
	(initialize_namespace_symtab): New.
	(get_possible_namespace_block, free_namespace_block)
	(check_possible_namespace_symbols)
	(check_possible_namespace_symbols_loop)
	(check_one_possible_namespace_symbol)
	(lookup_possible_namespace_symbol, maintenance_cplus_namespace)
	(_initialize_cp_namespace): Ditto.
	* block.h: Declare allocate_block.
	* block.c (allocate_block): New.
	* jv-lang.c (get_java_class_symtab): Allocate blocks via
	allocate_block.
	* symfile.h: Update declaration of add_psymbol_to_list.
	* symfile.c (add_psymbol_to_list): Return the partial symbol in
	question.
	* dwarf2read.c (dwarf2_build_psymtabs_hard): Add argument to
	scan_partial_symbols_call.
	(scan_partial_symbols): Add NAMESPACE argument; update calls to
	helper functions.
	(add_partial_symbol): If necessary, scan mangled names for names
	of namespaces.
	(add_partial_namespace): Add NAMESPACE argument; generate partial
	symbols associated  to namespaces.
	(add_partial_enumeration): Add NAMESPACE argument.
	(new_symbol): Allow namespace syms.
	(read_namespace): Generate namespace syms.
	* objfiles.h: Add opaque declaration of struct symtab.
	(struct objfile): Add cp_namespace_symtab member.
	* objfiles.c (allocate_objfile): Set
	objfile->cp_namespace_symtab.
	* Makefile.in (cp-namespace.o): Depend on objfiles_h, gdbtypes_h,
	dictionary_h, command_h.

2003-09-11  David Carlton  <carlton@kealia.com>

	* gdb.c++/namespace.exp: Add tests for namespace types.
	* gdb.c++/maint.exp (test_help): Test 'help maint cp namespace'.
	(test_namespace): New.

1 files changed, 293 insertions, 5 deletions

diff --git a/gdb/cp-namespace.c b/gdb/cp-namespace.c
index db0839f..40959a5 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 "command.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
@@ -70,6 +74,26 @@ static struct symbol *lookup_symbol_file (const char *name,
 					  struct symtab **symtab,
 					  int anonymous_namespace);
 
+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,
+						 struct symtab **symtab);
+
+static void maintenance_cplus_namespace (char *args, int from_tty);
+
 /* Set up support for dealing with C++ namespace info in the current
    symtab.  */
 
@@ -453,13 +477,277 @@ lookup_symbol_file (const char *name,
       const struct block *global_block = block_global_block (block);
       
       if (global_block != NULL)
-	return lookup_symbol_aux_block (name, linkage_name, global_block,
-					domain, symtab);
-      else
-	return NULL;
+	sym = lookup_symbol_aux_block (name, linkage_name, global_block,
+				       domain, symtab);
     }
   else
     {
-      return lookup_symbol_global (name, linkage_name, domain, symtab);
+      sym = lookup_symbol_global (name, linkage_name, domain, symtab);
+    }
+
+  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, symtab);
+      if (sym != NULL)
+	return sym;
+    }
+
+  return NULL;
+}
+
+/* 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->symbol_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->symbol_obstack);
+  BLOCK_DICT (bl) = dict_create_linear (&objfile->symbol_obstack,
+					NULL);
+  BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK) = bl;
+  bl = allocate_block (&objfile->symbol_obstack);
+  BLOCK_DICT (bl) = dict_create_linear (&objfile->symbol_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->symbol_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 = obsavestring (name, len, &objfile->symbol_obstack);
+  struct symbol *sym = lookup_block_symbol (block, name_copy, NULL,
+					    VAR_DOMAIN);
+
+  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;
+      SYMBOL_SET_NAMES (sym, name_copy, len, 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
+    {
+      obstack_free (&objfile->symbol_obstack, name_copy);
+
+      return 1;
+    }
+}
+
+/* Look for a symbol named NAME in all the possible namespace blocks.
+   If one is found, return it; if SYMTAB is non-NULL, set *SYMTAB to
+   equal the symtab where it was found.  */
+
+static struct symbol *
+lookup_possible_namespace_symbol (const char *name, struct symtab **symtab)
+{
+  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)
+	{
+	  if (symtab != NULL)
+	    *symtab = objfile->cp_namespace_symtab;
+
+	  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));
+	}
+    }
+}
+
+void
+_initialize_cp_namespace (void)
+{
+  add_cmd ("namespace", class_maintenance, maintenance_cplus_namespace,
+	   "Print the list of possible C++ namespaces.",
+	   &maint_cplus_cmd_list);
 }