if (full_path != NULL)
{
const char *fp = symtab_to_fullname (s);
+
if (fp != NULL && FILENAME_CMP (full_path, fp) == 0)
{
return s;
if (real_path != NULL)
{
char *fullname = symtab_to_fullname (s);
+
if (fullname != NULL)
{
char *rp = gdb_realpath (fullname);
+
make_cleanup (xfree, rp);
if (FILENAME_CMP (real_path, rp) == 0)
{
mangled_name_len = ((is_constructor ? 0 : strlen (field_name))
+ strlen (buf) + len + strlen (physname) + 1);
- {
- mangled_name = (char *) xmalloc (mangled_name_len);
- if (is_constructor)
- mangled_name[0] = '\0';
- else
- strcpy (mangled_name, field_name);
- }
+ mangled_name = (char *) xmalloc (mangled_name_len);
+ if (is_constructor)
+ mangled_name[0] = '\0';
+ else
+ strcpy (mangled_name, field_name);
+
strcat (mangled_name, buf);
/* If the class doesn't have a name, i.e. newname NULL, then we just
mangle it using 0 for the length of the class. Thus it gets mangled
hash_demangled_name_entry (const void *data)
{
const struct demangled_name_entry *e = data;
+
return htab_hash_string (e->mangled);
}
{
const struct demangled_name_entry *da = a;
const struct demangled_name_entry *db = b;
+
return strcmp (da->mangled, db->mangled) == 0;
}
if (gsymbol->language == language_java)
{
char *alloc_name;
- lookup_len = len + JAVA_PREFIX_LEN;
+ 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);
else if (linkage_name[len] != '\0')
{
char *alloc_name;
- lookup_len = len;
+ lookup_len = len;
alloc_name = alloca (lookup_len + 1);
memcpy (alloc_name, linkage_name, len);
alloc_name[lookup_len] = '\0';
ALL_OBJFILES (objfile)
{
struct symtab *result = NULL;
+
if (objfile->sf)
result = objfile->sf->qf->find_pc_sect_symtab (objfile, msymbol,
pc, section, 0);
a search of the section table. */
struct obj_section *s;
+
ALL_OBJFILE_OSECTIONS (objfile, s)
{
int idx = s->the_bfd_section->index;
modified_name = name;
- /* If we are using C++, D, or Java, demangle the name before doing a lookup, so
- we can always binary search. */
+ /* If we are using C++, D, or Java, demangle the name before doing a
+ lookup, so we can always binary search. */
if (lang == language_cplus)
{
demangled_name = cplus_demangle (name, DMGL_ANSI | DMGL_PARAMS);
{
struct symbol *sym = NULL;
const struct block *function_block = block;
+
/* 'this' is only defined in the function's block, so find the
enclosing function block. */
for (; function_block && !BLOCK_FUNCTION (function_block);
struct symtab *symtab;
struct blockvector *bv;
const struct block *block;
- struct partial_symtab *ps;
struct symbol *sym;
if (!objfile->sf)
struct blockvector *bv;
struct symtab *s = NULL;
struct symtab *best_s = NULL;
- struct partial_symtab *ps;
struct objfile *objfile;
struct program_space *pspace;
CORE_ADDR distance = 0;
if ((objfile->flags & OBJF_REORDERED) && objfile->sf)
{
struct symtab *result;
+
result
= objfile->sf->qf->find_pc_sect_symtab (objfile,
msymbol,
ALL_OBJFILES (objfile)
{
struct symtab *result;
+
if (!objfile->sf)
continue;
result = objfile->sf->qf->find_pc_sect_symtab (objfile,
If not found, return NULL. */
struct symtab *
-find_line_symtab (struct symtab *symtab, int line, int *index, int *exact_match)
+find_line_symtab (struct symtab *symtab, int line,
+ int *index, int *exact_match)
{
int exact = 0; /* Initialized here to avoid a compiler warning. */
find_pc_line_pc_range (CORE_ADDR pc, CORE_ADDR *startptr, CORE_ADDR *endptr)
{
struct symtab_and_line sal;
+
sal = find_pc_line (pc, 0);
*startptr = sal.pc;
*endptr = sal.end;
{
CORE_ADDR func_start, func_end;
struct linetable *l;
- int ind, i, len;
- int best_lineno = 0;
- CORE_ADDR best_pc = func_addr;
+ int i;
/* Give up if this symbol has no lineinfo table. */
l = LINETABLE (symtab);
{
struct minimal_symbol *msymbol
= lookup_minimal_symbol_by_pc_section (sal->pc, sal->section);
+
if (msymbol == NULL)
{
do_cleanups (old_chain);
if (isalpha (*p) || *p == '_' || *p == '$')
{
char *q = p + 1;
+
while (isalnum (*q) || *q == '_' || *q == '$')
q++;
*end = q;
sources_info (char *ignore, int from_tty)
{
struct symtab *s;
- struct partial_symtab *ps;
struct objfile *objfile;
int first;
ALL_SYMTABS (objfile, s)
{
const char *fullname = symtab_to_fullname (s);
+
output_source_filename (fullname ? fullname : s->filename, &first);
}
printf_filtered ("\n\n");
search_symbols_file_matches (const char *filename, void *user_data)
{
struct search_symbols_data *data = user_data;
+
return file_matches (filename, data->files, data->nfiles);
}
search_symbols_name_matches (const char *symname, void *user_data)
{
struct search_symbols_data *data = user_data;
+
return data->regexp == NULL || re_exec (symname);
}
char *val;
int found_misc = 0;
static enum minimal_symbol_type types[]
- =
- {mst_data, mst_text, mst_abs, mst_unknown};
+ = {mst_data, mst_text, mst_abs, mst_unknown};
static enum minimal_symbol_type types2[]
- =
- {mst_bss, mst_file_text, mst_abs, mst_unknown};
+ = {mst_bss, mst_file_text, mst_abs, mst_unknown};
static enum minimal_symbol_type types3[]
- =
- {mst_file_data, mst_solib_trampoline, mst_abs, mst_unknown};
+ = {mst_file_data, mst_solib_trampoline, mst_abs, mst_unknown};
static enum minimal_symbol_type types4[]
- =
- {mst_file_bss, mst_text, mst_abs, mst_unknown};
+ = {mst_file_bss, mst_text, mst_abs, mst_unknown};
enum minimal_symbol_type ourtype;
enum minimal_symbol_type ourtype2;
enum minimal_symbol_type ourtype3;
and <TYPENAME> or <OPERATOR>. */
char *opend;
char *opname = operator_chars (regexp, &opend);
+
if (*opname)
{
int fix = -1; /* -1 means ok; otherwise number of spaces needed. */
+
if (isalpha (*opname) || *opname == '_' || *opname == '$')
{
/* There should 1 space between 'operator' and 'TYPENAME'. */
if (fix >= 0)
{
char *tmp = (char *) alloca (8 + fix + strlen (opname) + 1);
+
sprintf (tmp, "operator%.*s%s", fix, " ", opname);
regexp = tmp;
}
{
struct symbol_search *prevtail = tail;
int nfound = 0;
+
b = BLOCKVECTOR_BLOCK (bv, i);
ALL_BLOCK_SYMBOLS (b, iter, sym)
{
struct symtab *real_symtab = SYMBOL_SYMTAB (sym);
+
QUIT;
if (file_matches (real_symtab->filename, files, nfiles)
static void
symtab_symbol_info (char *regexp, domain_enum kind, int from_tty)
{
- static char *classnames[]
- =
- {"variable", "function", "type", "method"};
+ static char *classnames[] = {"variable", "function", "type", "method"};
struct symbol_search *symbols;
struct symbol_search *p;
struct cleanup *old_chain;
if (regexp)
{
char *colon = strchr (regexp, ':');
+
if (colon && *(colon + 1) != ':')
{
int colon_index;
int newlen = (strlen (p->symtab->filename)
+ strlen (SYMBOL_LINKAGE_NAME (p->symbol))
+ 4);
+
if (newlen > len)
{
string = xrealloc (string, newlen);
}
else
{
- int newlen = (strlen (SYMBOL_LINKAGE_NAME (p->msymbol))
- + 3);
+ int newlen = (strlen (SYMBOL_LINKAGE_NAME (p->msymbol)) + 3);
+
if (newlen > len)
{
string = xrealloc (string, newlen);
char *text, char *word)
{
int newsize;
- int i;
/* clip symbols that cannot match */
{
char *new;
+
if (word == sym_text)
{
new = xmalloc (strlen (symname) + 5);
void *user_data)
{
struct add_name_data *datum = (struct add_name_data *) user_data;
+
completion_list_add_name ((char *) name,
datum->sym_text, datum->sym_text_len,
datum->text, datum->word);
add_partial_symbol_name (const char *name, void *user_data)
{
struct add_name_data *datum = (struct add_name_data *) user_data;
+
completion_list_add_name ((char *) name,
datum->sym_text, datum->sym_text_len,
datum->text, datum->word);
else
{
const char *base_name = lbasename (filename);
+
if (base_name != filename
&& !filename_seen (base_name, 1, data->first)
#if HAVE_DOS_BASED_FILE_SYSTEM
if (prologue_sal.symtab->language != language_asm)
{
struct linetable *linetable = LINETABLE (prologue_sal.symtab);
- int exact;
int idx = 0;
/* Skip any earlier lines, and any end-of-sequence marker
{
struct linetable *l;
int len;
+
if (fullname != NULL
&& symtab_to_fullname (symtab) != NULL
&& FILENAME_CMP (fullname, symtab->fullname) != 0)
struct symtabs_and_lines
expand_line_sal (struct symtab_and_line sal)
{
- struct symtabs_and_lines ret, this_line;
+ struct symtabs_and_lines ret;
int i, j;
struct objfile *objfile;
- struct partial_symtab *psymtab;
- struct symtab *symtab;
int lineno;
int deleted = 0;
struct block **blocks = NULL;
blocks = alloca (ret.nelts * sizeof (struct block *));
for (i = 0; i < ret.nelts; ++i)
{
- struct blockvector *bl;
- struct block *b;
-
set_current_program_space (ret.sals[i].pspace);
filter[i] = 1;