* 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.
+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'.
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) \
#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
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. */
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);
+}
/* 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.
#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. */
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:
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)
{
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
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);
}
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 */
+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
# 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
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
projects / thirdparty / binutils-gdb.git / commitdiff
