diff options
Diffstat (limited to 'gdb/cp-namespace.c')
| -rw-r--r-- | gdb/cp-namespace.c | 73 |
1 files changed, 73 insertions, 0 deletions
diff --git a/gdb/cp-namespace.c b/gdb/cp-namespace.c index fed440e..b9cc794 100644 --- a/gdb/cp-namespace.c +++ b/gdb/cp-namespace.c @@ -31,6 +31,7 @@ #include "gdbtypes.h" #include "dictionary.h" #include "command.h" +#include "frame.h" /* When set, the file that we're processing is known to have debugging info for C++ namespaces. */ @@ -85,6 +86,10 @@ static struct symbol *lookup_symbol_file (const char *name, struct symtab **symtab, int anonymous_namespace); +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); @@ -551,6 +556,74 @@ cp_lookup_nested_type (struct type *parent_type, } } +/* The C++-version of lookup_transparent_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 + 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 + absence of debug information about namespaces (I've filed PR + gdb/1511 about this); until such debug information becomes more + prevalent, one heuristic which sometimes looks is to search for the + definition in namespaces containing the current namespace. + + We should delete this functions once the appropriate debug + information becomes more widespread. (GCC 3.4 will be the first + released version of GCC with such information.) */ + +struct type * +cp_lookup_transparent_type (const char *name) +{ + /* First, try the honest way of looking up the definition. */ + struct type *t = basic_lookup_transparent_type (name); + const char *scope; + + if (t != NULL) + return t; + + /* If that doesn't work and we're within a namespace, look there + instead. */ + scope = block_scope (get_selected_block (0)); + + if (scope[0] == '\0') + return NULL; + + 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. */ + +static struct type * +cp_lookup_transparent_type_loop (const char *name, const char *scope, + int length) +{ + int scope_length = cp_find_first_component (scope + length); + char *full_name; + + /* If the current scope is followed by "::", look in the next + component. */ + if (scope[scope_length] == ':') + { + struct type *retval + = cp_lookup_transparent_type_loop (name, scope, scope_length + 2); + if (retval != NULL) + return retval; + } + + full_name = alloca (scope_length + 2 + strlen (name) + 1); + strncpy (full_name, scope, scope_length); + strncpy (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 |