#include "linespec.h"
#include "source.h"
#include "filenames.h" /* for FILENAME_CMP */
+#include "objc-lang.h"
#include "hashtab.h"
char *operator_chars (char *p, char **end);
static struct partial_symbol *lookup_partial_symbol (struct partial_symtab *,
+ const char *,
const char *, int,
- namespace_enum);
+ domain_enum);
static struct symbol *lookup_symbol_aux (const char *name,
const char *mangled_name,
const struct block *block,
- const namespace_enum namespace,
+ const domain_enum domain,
int *is_a_field_of_this,
struct symtab **symtab);
struct symbol *lookup_symbol_aux_local (const char *name,
const char *mangled_name,
const struct block *block,
- const namespace_enum namespace,
+ const domain_enum domain,
struct symtab **symtab,
const struct block **static_block);
struct symbol *lookup_symbol_aux_block (const char *name,
const char *mangled_name,
const struct block *block,
- const namespace_enum namespace,
+ const domain_enum domain,
struct symtab **symtab);
static
struct symbol *lookup_symbol_aux_symtabs (int block_index,
const char *name,
const char *mangled_name,
- const namespace_enum namespace,
+ const domain_enum domain,
struct symtab **symtab);
static
struct symbol *lookup_symbol_aux_psymtabs (int block_index,
const char *name,
const char *mangled_name,
- const namespace_enum namespace,
+ const domain_enum domain,
struct symtab **symtab);
static
struct symbol *lookup_symbol_aux_minsyms (const char *name,
const char *mangled_name,
- const namespace_enum namespace,
+ const domain_enum domain,
int *is_a_field_of_this,
struct symtab **symtab);
static int file_matches (char *, char **, int);
-static void print_symbol_info (namespace_enum,
+static void print_symbol_info (domain_enum,
struct symtab *, struct symbol *, int, char *);
static void print_msymbol_info (struct minimal_symbol *);
-static void symtab_symbol_info (char *, namespace_enum, int);
+static void symtab_symbol_info (char *, domain_enum, int);
static void overload_list_add_symbol (struct symbol *sym, char *oload_name);
if (gsymbol->language == language_unknown)
gsymbol->language = language_auto;
+
+ if (gsymbol->language == language_objc
+ || gsymbol->language == language_auto)
+ {
+ demangled =
+ objc_demangle (mangled, 0);
+ if (demangled != NULL)
+ {
+ gsymbol->language = language_objc;
+ return demangled;
+ }
+ }
if (gsymbol->language == language_cplus
|| gsymbol->language == language_auto)
{
return NULL;
}
-/* Set both the mangled and demangled (if any) names for GSYMBOL based on
- NAME and LEN. The hash table corresponding to OBJFILE is used, and the
- memory comes from that objfile's symbol_obstack. NAME is copied, so the
- pointer can be discarded after calling this function. */
+/* Set both the mangled and demangled (if any) names for GSYMBOL based
+ on LINKAGE_NAME and LEN. The hash table corresponding to OBJFILE
+ is used, and the memory comes from that objfile's symbol_obstack.
+ LINKAGE_NAME is copied, so the pointer can be discarded after
+ calling this function. */
+
+/* We have to be careful when dealing with Java names: when we run
+ into a Java minimal symbol, we don't know it's a Java symbol, so it
+ gets demangled as a C++ name. This is unfortunate, but there's not
+ much we can do about it: but when demangling partial symbols and
+ regular symbols, we'd better not reuse the wrong demangled name.
+ (See PR gdb/1039.) We solve this by putting a distinctive prefix
+ on Java names when storing them in the hash table. */
+
+/* FIXME: carlton/2003-03-13: This is an unfortunate situation. I
+ don't mind the Java prefix so much: different languages have
+ different demangling requirements, so it's only natural that we
+ need to keep language data around in our demangling cache. But
+ it's not good that the minimal symbol has the wrong demangled name.
+ Unfortunately, I can't think of any easy solution to that
+ problem. */
+
+#define JAVA_PREFIX "##JAVA$$"
+#define JAVA_PREFIX_LEN 8
void
symbol_set_names (struct general_symbol_info *gsymbol,
- const char *name, int len, struct objfile *objfile)
+ const char *linkage_name, int len, struct objfile *objfile)
{
char **slot;
- const char *tmpname;
+ /* A 0-terminated copy of the linkage name. */
+ const char *linkage_name_copy;
+ /* A copy of the linkage name that might have a special Java prefix
+ added to it, for use when looking names up in the hash table. */
+ const char *lookup_name;
+ /* The length of lookup_name. */
+ int lookup_len;
if (objfile->demangled_names_hash == NULL)
create_demangled_names_hash (objfile);
- /* The stabs reader generally provides names that are not NULL-terminated;
- most of the other readers don't do this, so we can just use the given
- copy. */
- if (name[len] != 0)
+ /* The stabs reader generally provides names that are not
+ NUL-terminated; most of the other readers don't do this, so we
+ can just use the given copy, unless we're in the Java case. */
+ if (gsymbol->language == language_java)
{
- char *alloc_name = alloca (len + 1);
- memcpy (alloc_name, name, len);
- alloc_name[len] = 0;
- tmpname = alloc_name;
+ char *alloc_name;
+ lookup_len = len + JAVA_PREFIX_LEN;
+
+ alloc_name = alloca (lookup_len + 1);
+ memcpy (alloc_name, JAVA_PREFIX, JAVA_PREFIX_LEN);
+ memcpy (alloc_name + JAVA_PREFIX_LEN, linkage_name, len);
+ alloc_name[lookup_len] = '\0';
+
+ lookup_name = alloc_name;
+ linkage_name_copy = alloc_name + JAVA_PREFIX_LEN;
+ }
+ else if (linkage_name[len] != '\0')
+ {
+ char *alloc_name;
+ lookup_len = len;
+
+ alloc_name = alloca (lookup_len + 1);
+ memcpy (alloc_name, linkage_name, len);
+ alloc_name[lookup_len] = '\0';
+
+ lookup_name = alloc_name;
+ linkage_name_copy = alloc_name;
}
else
- tmpname = name;
+ {
+ lookup_len = len;
+ lookup_name = linkage_name;
+ linkage_name_copy = linkage_name;
+ }
- slot = (char **) htab_find_slot (objfile->demangled_names_hash, tmpname, INSERT);
+ slot = (char **) htab_find_slot (objfile->demangled_names_hash,
+ lookup_name, INSERT);
/* If this name is not in the hash table, add it. */
if (*slot == NULL)
{
- char *demangled_name = symbol_find_demangled_name (gsymbol, tmpname);
+ char *demangled_name = symbol_find_demangled_name (gsymbol,
+ linkage_name_copy);
int demangled_len = demangled_name ? strlen (demangled_name) : 0;
/* If there is a demangled name, place it right after the mangled name.
Otherwise, just place a second zero byte after the end of the mangled
name. */
*slot = obstack_alloc (&objfile->symbol_obstack,
- len + demangled_len + 2);
- memcpy (*slot, tmpname, len + 1);
- if (demangled_name)
+ lookup_len + demangled_len + 2);
+ memcpy (*slot, lookup_name, lookup_len + 1);
+ if (demangled_name != NULL)
{
- memcpy (*slot + len + 1, demangled_name, demangled_len + 1);
+ memcpy (*slot + lookup_len + 1, demangled_name, demangled_len + 1);
xfree (demangled_name);
}
else
- (*slot)[len + 1] = 0;
+ (*slot)[lookup_len + 1] = '\0';
}
- gsymbol->name = *slot;
- if ((*slot)[len + 1])
+ gsymbol->name = *slot + lookup_len - len;
+ if ((*slot)[lookup_len + 1] != '\0')
gsymbol->language_specific.cplus_specific.demangled_name
- = &(*slot)[len + 1];
+ = &(*slot)[lookup_len + 1];
else
gsymbol->language_specific.cplus_specific.demangled_name = NULL;
}
demangled = symbol_find_demangled_name (gsymbol, mangled);
if (gsymbol->language == language_cplus
- || gsymbol->language == language_java)
+ || gsymbol->language == language_java
+ || gsymbol->language == language_objc)
{
if (demangled)
{
pp++)
{
p = *pp;
- if (SYMBOL_NAMESPACE (p) == VAR_NAMESPACE
+ if (SYMBOL_DOMAIN (p) == VAR_DOMAIN
&& SYMBOL_CLASS (p) == LOC_BLOCK
&& pc >= SYMBOL_VALUE_ADDRESS (p)
&& (SYMBOL_VALUE_ADDRESS (p) > best_pc
pp++)
{
p = *pp;
- if (SYMBOL_NAMESPACE (p) == VAR_NAMESPACE
+ if (SYMBOL_DOMAIN (p) == VAR_DOMAIN
&& SYMBOL_CLASS (p) == LOC_BLOCK
&& pc >= SYMBOL_VALUE_ADDRESS (p)
&& (SYMBOL_VALUE_ADDRESS (p) > best_pc
}
/* Find the definition for a specified symbol name NAME
- in namespace NAMESPACE, visible from lexical block BLOCK.
+ in domain DOMAIN, visible from lexical block BLOCK.
Returns the struct symbol pointer, or zero if no symbol is found.
If SYMTAB is non-NULL, store the symbol table in which the
symbol was found there, or NULL if not found.
struct symbol *
lookup_symbol (const char *name, const struct block *block,
- const namespace_enum namespace, int *is_a_field_of_this,
+ const domain_enum domain, int *is_a_field_of_this,
struct symtab **symtab)
{
char *demangled_name = NULL;
}
returnval = lookup_symbol_aux (modified_name, mangled_name, block,
- namespace, is_a_field_of_this, symtab);
+ domain, is_a_field_of_this, symtab);
if (needtofreename)
xfree (demangled_name);
static struct symbol *
lookup_symbol_aux (const char *name, const char *mangled_name,
- const struct block *block, const namespace_enum namespace,
+ const struct block *block, const domain_enum domain,
int *is_a_field_of_this, struct symtab **symtab)
{
struct symbol *sym;
/* Search specified block and its superiors. Don't search
STATIC_BLOCK or GLOBAL_BLOCK. */
- sym = lookup_symbol_aux_local (name, mangled_name, block, namespace,
+ sym = lookup_symbol_aux_local (name, mangled_name, block, domain,
symtab, &static_block);
if (sym != NULL)
return sym;
/* FIXME: this code is never executed--block is always NULL at this
point. What is it trying to do, anyway? We already should have
checked the STATIC_BLOCK above (it is the superblock of top-level
- blocks). Why is VAR_NAMESPACE special-cased? */
+ blocks). Why is VAR_DOMAIN special-cased? */
/* Don't need to mess with the psymtabs; if we have a block,
that file is read in. If we don't, then we deal later with
all the psymtab stuff that needs checking. */
* code to find any 'sym''s that were not found above. I vote for
* deleting the following paragraph of code.
*/
- if (namespace == VAR_NAMESPACE && block != NULL)
+ if (domain == VAR_DOMAIN && block != NULL)
{
struct block *b;
/* Find the right symtab. */
if (BLOCK_START (b) <= BLOCK_START (block)
&& BLOCK_END (b) > BLOCK_START (block))
{
- sym = lookup_block_symbol (b, name, mangled_name, VAR_NAMESPACE);
+ sym = lookup_block_symbol (b, name, mangled_name, VAR_DOMAIN);
if (sym)
{
block_found = b;
}
#endif /* 0 */
- /* C++: If requested to do so by the caller,
+ /* C++/Java/Objective-C: If requested to do so by the caller,
check to see if NAME is a field of `this'. */
if (is_a_field_of_this)
{
if (static_block != NULL)
{
sym = lookup_symbol_aux_block (name, mangled_name, static_block,
- namespace, symtab);
+ domain, symtab);
if (sym != NULL)
return sym;
}
conversion on the fly and return the found symbol. */
sym = lookup_symbol_aux_symtabs (GLOBAL_BLOCK, name, mangled_name,
- namespace, symtab);
+ domain, symtab);
if (sym != NULL)
return sym;
Eventually, all global symbols might be resolved in this way. */
sym = lookup_symbol_aux_minsyms (name, mangled_name,
- namespace, is_a_field_of_this,
+ domain, is_a_field_of_this,
symtab);
if (sym != NULL)
#endif
sym = lookup_symbol_aux_psymtabs (GLOBAL_BLOCK, name, mangled_name,
- namespace, symtab);
+ domain, symtab);
if (sym != NULL)
return sym;
conversion on the fly and return the found symbol. */
sym = lookup_symbol_aux_symtabs (STATIC_BLOCK, name, mangled_name,
- namespace, symtab);
+ domain, symtab);
if (sym != NULL)
return sym;
sym = lookup_symbol_aux_psymtabs (STATIC_BLOCK, name, mangled_name,
- namespace, symtab);
+ domain, symtab);
if (sym != NULL)
return sym;
sym = lookup_symbol_aux_minsyms (name, mangled_name,
- namespace, is_a_field_of_this,
+ domain, is_a_field_of_this,
symtab);
if (sym != NULL)
static struct symbol *
lookup_symbol_aux_local (const char *name, const char *mangled_name,
const struct block *block,
- const namespace_enum namespace,
+ const domain_enum domain,
struct symtab **symtab,
const struct block **static_block)
{
while (BLOCK_SUPERBLOCK (BLOCK_SUPERBLOCK (block)) != NULL)
{
- sym = lookup_symbol_aux_block (name, mangled_name, block, namespace,
+ sym = lookup_symbol_aux_block (name, mangled_name, block, domain,
symtab);
if (sym != NULL)
return sym;
static struct symbol *
lookup_symbol_aux_block (const char *name, const char *mangled_name,
const struct block *block,
- const namespace_enum namespace,
+ const domain_enum domain,
struct symtab **symtab)
{
struct symbol *sym;
struct block *b;
struct symtab *s = NULL;
- sym = lookup_block_symbol (block, name, mangled_name, namespace);
+ sym = lookup_block_symbol (block, name, mangled_name, domain);
if (sym)
{
block_found = block;
static struct symbol *
lookup_symbol_aux_symtabs (int block_index,
const char *name, const char *mangled_name,
- const namespace_enum namespace,
+ const domain_enum domain,
struct symtab **symtab)
{
struct symbol *sym;
{
bv = BLOCKVECTOR (s);
block = BLOCKVECTOR_BLOCK (bv, block_index);
- sym = lookup_block_symbol (block, name, mangled_name, namespace);
+ sym = lookup_block_symbol (block, name, mangled_name, domain);
if (sym)
{
block_found = block;
static struct symbol *
lookup_symbol_aux_psymtabs (int block_index, const char *name,
const char *mangled_name,
- const namespace_enum namespace,
+ const domain_enum domain,
struct symtab **symtab)
{
struct symbol *sym;
ALL_PSYMTABS (objfile, ps)
{
if (!ps->readin
- && lookup_partial_symbol (ps, name, psymtab_index, namespace))
+ && lookup_partial_symbol (ps, name, mangled_name,
+ psymtab_index, domain))
{
s = PSYMTAB_TO_SYMTAB (ps);
bv = BLOCKVECTOR (s);
block = BLOCKVECTOR_BLOCK (bv, block_index);
- sym = lookup_block_symbol (block, name, mangled_name, namespace);
+ sym = lookup_block_symbol (block, name, mangled_name, domain);
if (!sym)
{
/* This shouldn't be necessary, but as a last resort try
block = BLOCKVECTOR_BLOCK (bv,
block_index == GLOBAL_BLOCK ?
STATIC_BLOCK : GLOBAL_BLOCK);
- sym = lookup_block_symbol (block, name, mangled_name, namespace);
+ sym = lookup_block_symbol (block, name, mangled_name, domain);
if (!sym)
error ("Internal: %s symbol `%s' found in %s psymtab but not in symtab.\n%s may be an inlined function, or may be a template function\n(if a template, try specifying an instantiation: %s<type>).",
block_index == GLOBAL_BLOCK ? "global" : "static",
static struct symbol *
lookup_symbol_aux_minsyms (const char *name,
const char *mangled_name,
- const namespace_enum namespace,
+ const domain_enum domain,
int *is_a_field_of_this,
struct symtab **symtab)
{
struct minimal_symbol *msymbol;
struct symtab *s;
- if (namespace == VAR_NAMESPACE)
+ if (domain == VAR_DOMAIN)
{
msymbol = lookup_minimal_symbol (name, NULL, NULL);
to be clearly the wrong thing to pass as the
unmangled name. */
sym =
- lookup_block_symbol (block, name, mangled_name, namespace);
+ lookup_block_symbol (block, name, mangled_name, domain);
/* We kept static functions in minimal symbol table as well as
in static scope. We want to find them in the symbol table. */
if (!sym)
{
block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
sym = lookup_block_symbol (block, name,
- mangled_name, namespace);
+ mangled_name, domain);
}
/* NOTE: carlton/2002-12-04: The following comment was
/* This is a mangled variable, look it up by its
mangled name. */
return lookup_symbol_aux (DEPRECATED_SYMBOL_NAME (msymbol), mangled_name,
- NULL, namespace, is_a_field_of_this,
+ NULL, domain, is_a_field_of_this,
symtab);
}
}
return NULL;
}
-/* Look, in partial_symtab PST, for symbol NAME. Check the global
- symbols if GLOBAL, the static symbols if not */
+/* Look, in partial_symtab PST, for symbol whose natural name is NAME.
+ If LINKAGE_NAME is non-NULL, check in addition that the symbol's
+ linkage name matches it. Check the global symbols if GLOBAL, the
+ static symbols if not */
static struct partial_symbol *
-lookup_partial_symbol (struct partial_symtab *pst, const char *name, int global,
- namespace_enum namespace)
+lookup_partial_symbol (struct partial_symtab *pst, const char *name,
+ const char *linkage_name, int global,
+ domain_enum domain)
{
struct partial_symbol *temp;
struct partial_symbol **start, **psym;
pointing at the earliest partial symbol whose name might be
correct. At that point *all* partial symbols with an
appropriate name will be checked against the correct
- namespace. */
+ domain. */
bottom = start;
top = start + length - 1;
if (!(top == bottom))
internal_error (__FILE__, __LINE__, "failed internal consistency check");
- /* djb - 2000-06-03 - Use SYMBOL_MATCHES_NAME, not a strcmp, so
- we don't have to force a linear search on C++. Probably holds true
- for JAVA as well, no way to check.*/
- while (top <= real_top && SYMBOL_MATCHES_NAME (*top,name))
+ while (top <= real_top
+ && (linkage_name != NULL
+ ? strcmp (SYMBOL_LINKAGE_NAME (*top), linkage_name) == 0
+ : SYMBOL_MATCHES_NATURAL_NAME (*top,name)))
{
- if (SYMBOL_NAMESPACE (*top) == namespace)
+ if (SYMBOL_DOMAIN (*top) == domain)
{
return (*top);
}
{
for (psym = start; psym < start + length; psym++)
{
- if (namespace == SYMBOL_NAMESPACE (*psym))
+ if (domain == SYMBOL_DOMAIN (*psym))
{
- if (SYMBOL_MATCHES_NAME (*psym, name))
+ if (linkage_name != NULL
+ ? strcmp (SYMBOL_LINKAGE_NAME (*psym), linkage_name) == 0
+ : SYMBOL_MATCHES_NATURAL_NAME (*psym, name))
{
return (*psym);
}
return (NULL);
}
-/* Look up a type named NAME in the struct_namespace. The type returned
+/* Look up a type named NAME in the struct_domain. The type returned
must not be opaque -- i.e., must have at least one field defined
This code was modelled on lookup_symbol -- the parts not relevant to looking
up types were just left out. In particular it's assumed here that types
- are available in struct_namespace and only at file-static or global blocks. */
+ are available in struct_domain and only at file-static or global blocks. */
struct type *
{
bv = BLOCKVECTOR (s);
block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
- sym = lookup_block_symbol (block, name, NULL, STRUCT_NAMESPACE);
+ sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN);
if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
{
return SYMBOL_TYPE (sym);
ALL_PSYMTABS (objfile, ps)
{
- if (!ps->readin && lookup_partial_symbol (ps, name, 1, STRUCT_NAMESPACE))
+ if (!ps->readin && lookup_partial_symbol (ps, name, NULL,
+ 1, STRUCT_DOMAIN))
{
s = PSYMTAB_TO_SYMTAB (ps);
bv = BLOCKVECTOR (s);
block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
- sym = lookup_block_symbol (block, name, NULL, STRUCT_NAMESPACE);
+ sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN);
if (!sym)
{
/* This shouldn't be necessary, but as a last resort
* the psymtab gets it wrong in some cases.
*/
block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
- sym = lookup_block_symbol (block, name, NULL, STRUCT_NAMESPACE);
+ sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN);
if (!sym)
error ("Internal: global symbol `%s' found in %s psymtab but not in symtab.\n\
%s may be an inlined function, or may be a template function\n\
{
bv = BLOCKVECTOR (s);
block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
- sym = lookup_block_symbol (block, name, NULL, STRUCT_NAMESPACE);
+ sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN);
if (sym && !TYPE_IS_OPAQUE (SYMBOL_TYPE (sym)))
{
return SYMBOL_TYPE (sym);
ALL_PSYMTABS (objfile, ps)
{
- if (!ps->readin && lookup_partial_symbol (ps, name, 0, STRUCT_NAMESPACE))
+ if (!ps->readin && lookup_partial_symbol (ps, name, NULL, 0, STRUCT_DOMAIN))
{
s = PSYMTAB_TO_SYMTAB (ps);
bv = BLOCKVECTOR (s);
block = BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK);
- sym = lookup_block_symbol (block, name, NULL, STRUCT_NAMESPACE);
+ sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN);
if (!sym)
{
/* This shouldn't be necessary, but as a last resort
* the psymtab gets it wrong in some cases.
*/
block = BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK);
- sym = lookup_block_symbol (block, name, NULL, STRUCT_NAMESPACE);
+ sym = lookup_block_symbol (block, name, NULL, STRUCT_DOMAIN);
if (!sym)
error ("Internal: static symbol `%s' found in %s psymtab but not in symtab.\n\
%s may be an inlined function, or may be a template function\n\
ALL_PSYMTABS (objfile, pst)
{
- if (lookup_partial_symbol (pst, main_name (), 1, VAR_NAMESPACE))
+ if (lookup_partial_symbol (pst, main_name (), NULL, 1, VAR_DOMAIN))
{
return (pst);
}
return (NULL);
}
-/* Search BLOCK for symbol NAME in NAMESPACE.
+/* Search BLOCK for symbol NAME in DOMAIN.
Note that if NAME is the demangled form of a C++ symbol, we will fail
to find a match during the binary search of the non-encoded names, but
for now we don't worry about the slight inefficiency of looking for
a match we'll never find, since it will go pretty quick. Once the
binary search terminates, we drop through and do a straight linear
- search on the symbols. Each symbol which is marked as being a C++
- symbol (language_cplus set) has both the encoded and non-encoded names
- tested for a match.
+ search on the symbols. Each symbol which is marked as being a ObjC/C++
+ symbol (language_cplus or language_objc set) has both the encoded and
+ non-encoded names tested for a match.
If MANGLED_NAME is non-NULL, verify that any symbol we find has this
particular mangled name.
struct symbol *
lookup_block_symbol (register const struct block *block, const char *name,
const char *mangled_name,
- const namespace_enum namespace)
+ const domain_enum domain)
{
register int bot, top, inc;
register struct symbol *sym;
hash_index = hash_index % BLOCK_BUCKETS (block);
for (sym = BLOCK_BUCKET (block, hash_index); sym; sym = sym->hash_next)
{
- if (SYMBOL_NAMESPACE (sym) == namespace
+ if (SYMBOL_DOMAIN (sym) == domain
&& (mangled_name
? strcmp (DEPRECATED_SYMBOL_NAME (sym), mangled_name) == 0
- : SYMBOL_MATCHES_NAME (sym, name)))
+ : SYMBOL_MATCHES_NATURAL_NAME (sym, name)))
return sym;
}
return NULL;
/* Now scan forward until we run out of symbols, find one whose
name is greater than NAME, or find one we want. If there is
- more than one symbol with the right name and namespace, we
+ more than one symbol with the right name and domain, we
return the first one; I believe it is now impossible for us
- to encounter two symbols with the same name and namespace
+ to encounter two symbols with the same name and domain
here, because blocks containing argument symbols are no
longer sorted. The exception is for C++, where multiple functions
(cloned constructors / destructors, in particular) can have
while (bot < top)
{
sym = BLOCK_SYM (block, bot);
- if (SYMBOL_NAMESPACE (sym) == namespace
+ if (SYMBOL_DOMAIN (sym) == domain
&& (mangled_name
? strcmp (DEPRECATED_SYMBOL_NAME (sym), mangled_name) == 0
- : SYMBOL_MATCHES_NAME (sym, name)))
+ : SYMBOL_MATCHES_NATURAL_NAME (sym, name)))
{
return sym;
}
while (bot < top)
{
sym = BLOCK_SYM (block, bot);
- if (SYMBOL_NAMESPACE (sym) == namespace
+ if (SYMBOL_DOMAIN (sym) == domain
&& (mangled_name
? strcmp (DEPRECATED_SYMBOL_NAME (sym), mangled_name) == 0
- : SYMBOL_MATCHES_NAME (sym, name)))
+ : SYMBOL_MATCHES_NATURAL_NAME (sym, name)))
{
/* If SYM has aliases, then use any alias that is active
at the current PC. If no alias is active at the current
returning the results in *MATCHES.
Only symbols of KIND are searched:
- FUNCTIONS_NAMESPACE - search all functions
- TYPES_NAMESPACE - search all type names
- METHODS_NAMESPACE - search all methods NOT IMPLEMENTED
- VARIABLES_NAMESPACE - search all symbols, excluding functions, type names,
+ FUNCTIONS_DOMAIN - search all functions
+ TYPES_DOMAIN - search all type names
+ METHODS_DOMAIN - search all methods NOT IMPLEMENTED
+ VARIABLES_DOMAIN - search all symbols, excluding functions, type names,
and constants (enums)
free_search_symbols should be called when *MATCHES is no longer needed.
separately alphabetized.
*/
void
-search_symbols (char *regexp, namespace_enum kind, int nfiles, char *files[],
+search_symbols (char *regexp, domain_enum kind, int nfiles, char *files[],
struct symbol_search **matches)
{
register struct symtab *s;
struct symbol_search *tail;
struct cleanup *old_chain = NULL;
- if (kind < VARIABLES_NAMESPACE)
- error ("must search on specific namespace");
+ if (kind < VARIABLES_DOMAIN)
+ error ("must search on specific domain");
- ourtype = types[(int) (kind - VARIABLES_NAMESPACE)];
- ourtype2 = types2[(int) (kind - VARIABLES_NAMESPACE)];
- ourtype3 = types3[(int) (kind - VARIABLES_NAMESPACE)];
- ourtype4 = types4[(int) (kind - VARIABLES_NAMESPACE)];
+ ourtype = types[(int) (kind - VARIABLES_DOMAIN)];
+ ourtype2 = types2[(int) (kind - VARIABLES_DOMAIN)];
+ ourtype3 = types3[(int) (kind - VARIABLES_DOMAIN)];
+ ourtype4 = types4[(int) (kind - VARIABLES_DOMAIN)];
sr = *matches = NULL;
tail = NULL;
if (file_matches (ps->filename, files, nfiles)
&& ((regexp == NULL
|| re_exec (SYMBOL_NATURAL_NAME (*psym)) != 0)
- && ((kind == VARIABLES_NAMESPACE && SYMBOL_CLASS (*psym) != LOC_TYPEDEF
+ && ((kind == VARIABLES_DOMAIN && SYMBOL_CLASS (*psym) != LOC_TYPEDEF
&& SYMBOL_CLASS (*psym) != LOC_BLOCK)
- || (kind == FUNCTIONS_NAMESPACE && SYMBOL_CLASS (*psym) == LOC_BLOCK)
- || (kind == TYPES_NAMESPACE && SYMBOL_CLASS (*psym) == LOC_TYPEDEF)
- || (kind == METHODS_NAMESPACE && SYMBOL_CLASS (*psym) == LOC_BLOCK))))
+ || (kind == FUNCTIONS_DOMAIN && SYMBOL_CLASS (*psym) == LOC_BLOCK)
+ || (kind == TYPES_DOMAIN && SYMBOL_CLASS (*psym) == LOC_TYPEDEF)
+ || (kind == METHODS_DOMAIN && SYMBOL_CLASS (*psym) == LOC_BLOCK))))
{
PSYMTAB_TO_SYMTAB (ps);
keep_going = 0;
any matching symbols without debug info.
*/
- if (nfiles == 0 && (kind == VARIABLES_NAMESPACE || kind == FUNCTIONS_NAMESPACE))
+ if (nfiles == 0 && (kind == VARIABLES_DOMAIN || kind == FUNCTIONS_DOMAIN))
{
ALL_MSYMBOLS (objfile, msymbol)
{
function lookup_symbol_minsym that found the
symbol associated to a given minimal symbol (if
any). */
- if (kind == FUNCTIONS_NAMESPACE
+ if (kind == FUNCTIONS_DOMAIN
|| lookup_symbol (DEPRECATED_SYMBOL_NAME (msymbol),
(struct block *) NULL,
- VAR_NAMESPACE,
+ VAR_DOMAIN,
0, (struct symtab **) NULL) == NULL)
found_misc = 1;
}
if (file_matches (s->filename, files, nfiles)
&& ((regexp == NULL
|| re_exec (SYMBOL_NATURAL_NAME (sym)) != 0)
- && ((kind == VARIABLES_NAMESPACE && SYMBOL_CLASS (sym) != LOC_TYPEDEF
+ && ((kind == VARIABLES_DOMAIN && SYMBOL_CLASS (sym) != LOC_TYPEDEF
&& SYMBOL_CLASS (sym) != LOC_BLOCK
&& SYMBOL_CLASS (sym) != LOC_CONST)
- || (kind == FUNCTIONS_NAMESPACE && SYMBOL_CLASS (sym) == LOC_BLOCK)
- || (kind == TYPES_NAMESPACE && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
- || (kind == METHODS_NAMESPACE && SYMBOL_CLASS (sym) == LOC_BLOCK))))
+ || (kind == FUNCTIONS_DOMAIN && SYMBOL_CLASS (sym) == LOC_BLOCK)
+ || (kind == TYPES_DOMAIN && SYMBOL_CLASS (sym) == LOC_TYPEDEF)
+ || (kind == METHODS_DOMAIN && SYMBOL_CLASS (sym) == LOC_BLOCK))))
{
/* match */
psr = (struct symbol_search *) xmalloc (sizeof (struct symbol_search));
/* If there are no eyes, avoid all contact. I mean, if there are
no debug symbols, then print directly from the msymbol_vector. */
- if (found_misc || kind != FUNCTIONS_NAMESPACE)
+ if (found_misc || kind != FUNCTIONS_DOMAIN)
{
ALL_MSYMBOLS (objfile, msymbol)
{
|| re_exec (SYMBOL_NATURAL_NAME (msymbol)) != 0)
{
/* Functions: Look up by address. */
- if (kind != FUNCTIONS_NAMESPACE ||
+ if (kind != FUNCTIONS_DOMAIN ||
(0 == find_pc_symtab (SYMBOL_VALUE_ADDRESS (msymbol))))
{
/* Variables/Absolutes: Look up by name */
if (lookup_symbol (DEPRECATED_SYMBOL_NAME (msymbol),
- (struct block *) NULL, VAR_NAMESPACE,
+ (struct block *) NULL, VAR_DOMAIN,
0, (struct symtab **) NULL) == NULL)
{
/* match */
regarding the match to gdb_stdout.
*/
static void
-print_symbol_info (namespace_enum kind, struct symtab *s, struct symbol *sym,
+print_symbol_info (domain_enum kind, struct symtab *s, struct symbol *sym,
int block, char *last)
{
if (last == NULL || strcmp (last, s->filename) != 0)
fputs_filtered (":\n", gdb_stdout);
}
- if (kind != TYPES_NAMESPACE && block == STATIC_BLOCK)
+ if (kind != TYPES_DOMAIN && block == STATIC_BLOCK)
printf_filtered ("static ");
/* Typedef that is not a C++ class */
- if (kind == TYPES_NAMESPACE
- && SYMBOL_NAMESPACE (sym) != STRUCT_NAMESPACE)
+ if (kind == TYPES_DOMAIN
+ && SYMBOL_DOMAIN (sym) != STRUCT_DOMAIN)
typedef_print (SYMBOL_TYPE (sym), sym, gdb_stdout);
/* variable, func, or typedef-that-is-c++-class */
- else if (kind < TYPES_NAMESPACE ||
- (kind == TYPES_NAMESPACE &&
- SYMBOL_NAMESPACE (sym) == STRUCT_NAMESPACE))
+ else if (kind < TYPES_DOMAIN ||
+ (kind == TYPES_DOMAIN &&
+ SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN))
{
type_print (SYMBOL_TYPE (sym),
(SYMBOL_CLASS (sym) == LOC_TYPEDEF
matches.
*/
static void
-symtab_symbol_info (char *regexp, namespace_enum kind, int from_tty)
+symtab_symbol_info (char *regexp, domain_enum kind, int from_tty)
{
static char *classnames[]
=
printf_filtered (regexp
? "All %ss matching regular expression \"%s\":\n"
: "All defined %ss:\n",
- classnames[(int) (kind - VARIABLES_NAMESPACE)], regexp);
+ classnames[(int) (kind - VARIABLES_DOMAIN)], regexp);
for (p = symbols; p != NULL; p = p->next)
{
static void
variables_info (char *regexp, int from_tty)
{
- symtab_symbol_info (regexp, VARIABLES_NAMESPACE, from_tty);
+ symtab_symbol_info (regexp, VARIABLES_DOMAIN, from_tty);
}
static void
functions_info (char *regexp, int from_tty)
{
- symtab_symbol_info (regexp, FUNCTIONS_NAMESPACE, from_tty);
+ symtab_symbol_info (regexp, FUNCTIONS_DOMAIN, from_tty);
}
static void
types_info (char *regexp, int from_tty)
{
- symtab_symbol_info (regexp, TYPES_NAMESPACE, from_tty);
+ symtab_symbol_info (regexp, TYPES_DOMAIN, from_tty);
}
/* Breakpoint all functions matching regular expression. */
struct symbol_search *p;
struct cleanup *old_chain;
- search_symbols (regexp, FUNCTIONS_NAMESPACE, 0, (char **) NULL, &ss);
+ search_symbols (regexp, FUNCTIONS_DOMAIN, 0, (char **) NULL, &ss);
old_chain = make_cleanup_free_search_symbols (ss);
for (p = ss; p != NULL; p = p->next)
strcat (string, DEPRECATED_SYMBOL_NAME (p->symbol));
strcat (string, "'");
break_command (string, from_tty);
- print_symbol_info (FUNCTIONS_NAMESPACE,
+ print_symbol_info (FUNCTIONS_DOMAIN,
p->symtab,
p->symbol,
p->block,
if (ps->readin)
continue;
- if ((lookup_partial_symbol (ps, oload_name, 1, VAR_NAMESPACE) != NULL)
- || (lookup_partial_symbol (ps, oload_name, 0, VAR_NAMESPACE) != NULL))
+ if ((lookup_partial_symbol (ps, oload_name, NULL, 1, VAR_DOMAIN)
+ != NULL)
+ || (lookup_partial_symbol (ps, oload_name, NULL, 0, VAR_DOMAIN)
+ != NULL))
PSYMTAB_TO_SYMTAB (ps);
}
projects / deliverable / binutils-gdb.git / blobdiff