struct complaint bad_sclass_complaint =
{"Bad n_sclass for symbol %s", 0, 0};
+struct complaint misordered_blocks_complaint =
+ {"Blocks out of order at address %x", 0, 0};
+
+struct complaint tagndx_bad_complaint =
+ {"Symbol table entry for %s has bad tagndx value", 0, 0};
+
/* Simplified internal version of coff symbol table information */
struct coff_symbol {
process_coff_symbol PARAMS ((struct coff_symbol *, union internal_auxent *,
struct objfile *));
-static PTR
-patch_opaque_types PARAMS ((struct objfile *, struct symtab *, PTR, PTR, PTR));
+static void
+patch_opaque_types PARAMS ((struct symtab *));
static void
patch_type PARAMS ((struct type *, struct type *));
union internal_auxent *));
static void
-read_coff_symtab PARAMS ((int, int, struct objfile *));
+read_coff_symtab PARAMS ((long, int, struct objfile *));
static void
find_linenos PARAMS ((bfd *, sec_ptr, PTR));
coff_symfile_finish PARAMS ((struct objfile *));
static void
-record_minimal_symbol PARAMS ((char *, CORE_ADDR));
+record_minimal_symbol PARAMS ((char *, CORE_ADDR, enum minimal_symbol_type));
static void
coff_end_symtab PARAMS ((struct objfile *));
for (next = *listhead; next; next = next1)
{
next1 = next->next;
- free (next);
+ free ((PTR)next);
}
*listhead = 0;
for (next = pending_blocks; next; next = next1)
{
next1 = next->next;
- free (next);
+ free ((PTR)next);
}
pending_blocks = 0;
/* Initialize the source file line number information for this file. */
if (line_vector) /* Unlikely, but maybe possible? */
- free (line_vector);
+ free ((PTR)line_vector);
line_vector_index = 0;
line_vector_length = 1000;
prev_line_number = -2; /* Force first line number to be explicit */
/* Make a block for the local symbols within. */
coff_finish_block (cstk->name, &coff_local_symbols, cstk->old_blocks,
cstk->start_addr, cur_src_end_addr, objfile);
- free (cstk);
+ free ((PTR)cstk);
}
/* Ignore a file that has no functions with real debugging info. */
if (pending_blocks == 0 && coff_file_symbols == 0 && coff_global_symbols == 0)
{
- free (line_vector);
+ free ((PTR)line_vector);
line_vector = 0;
line_vector_length = -1;
last_source_file = 0;
return;
}
+ /* It is unfortunate that in amdcoff, pending blocks might not be ordered
+ in this stage. Especially, blocks for static functions will show up at
+ the end. We need to sort them, so tools like `find_pc_function' and
+ `find_pc_block' can work reliably. */
+ if (pending_blocks) {
+ /* FIXME! Remove this horrid bubble sort and use qsort!!! */
+ int swapped;
+ do {
+ struct pending_block *pb, *pbnext;
+
+ pb = pending_blocks, pbnext = pb->next;
+ swapped = 0;
+
+ while ( pbnext ) {
+
+ /* swap blocks if unordered! */
+
+ if (BLOCK_START(pb->block) < BLOCK_START(pbnext->block)) {
+ struct block *tmp = pb->block;
+ complain (&misordered_blocks_complaint, BLOCK_START (pb->block));
+ pb->block = pbnext->block;
+ pbnext->block = tmp;
+ swapped = 1;
+ }
+ pb = pbnext;
+ pbnext = pbnext->next;
+ }
+ } while (swapped);
+ }
+
/* Create the two top-level blocks for this file (STATIC_BLOCK and
GLOBAL_BLOCK). */
coff_finish_block (0, &coff_file_symbols, 0, cur_src_start_addr, cur_src_end_addr, objfile);
}
\f
static void
-record_minimal_symbol (name, address)
+record_minimal_symbol (name, address, type)
char *name;
CORE_ADDR address;
+ enum minimal_symbol_type type;
{
/* We don't want TDESC entry points in the minimal symbol table */
if (name[0] == '@') return;
is, so this guess is more useful than mst_unknown. */
prim_record_minimal_symbol (savestring (name, strlen (name)),
address,
- (int)mst_text);
+ type);
}
\f
/* coff_symfile_init ()
init_entry_point_info (objfile);
/* Save the section number for the text section */
- if (section = bfd_get_section_by_name(abfd,".text"))
+ section = bfd_get_section_by_name(abfd,".text");
+ if (section)
text_bfd_scnum = section->index;
else
text_bfd_scnum = -1;
int num_symbols;
int symtab_offset;
int stringtab_offset;
+ struct symtab *s;
info = (struct coff_symfile_info *) objfile -> sym_private;
symfile_bfd = abfd; /* Kludge for swap routines */
/* Read the line number table, all at once. */
info->min_lineno_offset = 0;
info->max_lineno_offset = 0;
- bfd_map_over_sections (abfd, find_linenos, info);
+ bfd_map_over_sections (abfd, find_linenos, (PTR)info);
val = init_lineno (desc, info->min_lineno_offset,
info->max_lineno_offset - info->min_lineno_offset);
error ("\"%s\": can't get string table", name);
make_cleanup (free_stringtab, 0);
- /* Position to read the symbol table. Do not read it all at once. */
- val = lseek (desc, (long)symtab_offset, 0);
- if (val < 0)
- perror_with_name (name);
-
init_minimal_symbol_collection ();
make_cleanup (discard_minimal_symbols, 0);
/* Now that the executable file is positioned at symbol table,
process it and define symbols accordingly. */
- read_coff_symtab (desc, num_symbols, objfile);
-
- iterate_over_symtabs (patch_opaque_types, (PTR) NULL, (PTR) NULL,
- (PTR) NULL);
+ read_coff_symtab ((long)symtab_offset, num_symbols, objfile);
/* Sort symbols alphabetically within each block. */
}
static void
-coff_new_init (objfile)
- struct objfile *objfile;
+coff_new_init (ignore)
+ struct objfile *ignore;
{
/* Nothin' to do */
}
We read them one at a time using read_one_sym (). */
static void
-read_coff_symtab (desc, nsyms, objfile)
- int desc;
+read_coff_symtab (symtab_offset, nsyms, objfile)
+ long symtab_offset;
int nsyms;
struct objfile *objfile;
{
- int newfd; /* Avoid multiple closes on same desc */
FILE *stream;
register struct coff_context_stack *new;
struct coff_symbol coff_symbol;
struct coff_symbol fcn_cs_saved;
static struct internal_syment fcn_sym_saved;
static union internal_auxent fcn_aux_saved;
-
+ struct symtab *s;
+
/* A .file is open. */
int in_source_file = 0;
int num_object_files = 0;
/* Name of the current file. */
char *filestring = "";
- int depth;
- int fcn_first_line;
- int fcn_last_line;
- int fcn_start_addr;
- long fcn_line_ptr;
+ int depth = 0;
+ int fcn_first_line = 0;
+ int fcn_last_line = 0;
+ int fcn_start_addr = 0;
+ long fcn_line_ptr = 0;
struct cleanup *old_chain;
+ int val;
+ stream = fopen (objfile->name, FOPEN_RB);
+ if (!stream)
+ perror_with_name(objfile->name);
- newfd = dup (desc);
- if (newfd == -1)
- fatal ("Too many open files");
- stream = fdopen (newfd, "r");
+ /* Position to read the symbol table. */
+ val = fseek (stream, (long)symtab_offset, 0);
+ if (val < 0)
+ perror_with_name (objfile->name);
/* These cleanups will be discarded below if we succeed. */
old_chain = make_cleanup (free_objfile, objfile);
bzero (opaque_type_chain, sizeof opaque_type_chain);
if (type_vector) /* Get rid of previous one */
- free (type_vector);
+ free ((PTR)type_vector);
type_vector_length = 160;
type_vector = (struct type **)
xmalloc (type_vector_length * sizeof (struct type *));
/* record as a minimal symbol. if we get '.bf' next,
* then we undo this step
*/
- record_minimal_symbol (cs->c_name, cs->c_value);
+ record_minimal_symbol (cs->c_name, cs->c_value, mst_text);
fcn_line_ptr = main_aux.x_sym.x_fcnary.x_fcn.x_lnnoptr;
fcn_start_addr = cs->c_value;
record this symbol as a function in the minimal symbol table.
But why are absolute syms recorded as functions, anyway? */
if (cs->c_secnum <= text_bfd_scnum+1) {/* text or abs */
- record_minimal_symbol (cs->c_name, cs->c_value);
+ record_minimal_symbol (cs->c_name, cs->c_value,
+ mst_text);
break;
} else {
- cs->c_type = T_INT;
+ record_minimal_symbol (cs->c_name, cs->c_value,
+ mst_data);
+ break;
}
}
(void) process_coff_symbol (cs, &main_aux, objfile);
);
coff_context_stack = 0;
within_function = 0;
- free (new);
+ free ((PTR)new);
}
break;
depth--;
coff_local_symbols = new->locals;
coff_context_stack = new->next;
- free (new);
+ free ((PTR)new);
}
break;
if (last_source_file)
coff_end_symtab (objfile);
fclose (stream);
+
+ /* Patch up any opaque types (references to types that are not defined
+ in the file where they are referenced, e.g. "struct foo *bar"). */
+ ALL_OBJFILE_SYMTABS (objfile, s)
+ patch_opaque_types (s);
+
discard_cleanups (old_chain);
current_objfile = NULL;
}
}
/* Patch up all appropriate typedef symbols in the opaque_type_chains
- so that they can be used to print out opaque data structures properly.
-
- This is called via iterate_over_symtabs, and thus simply returns NULL
- for each time it is called, to indicate that the iteration should
- continue. */
+ so that they can be used to print out opaque data structures properly. */
-/* ARGSUSED */
-static PTR
-patch_opaque_types (objfile, s, arg1, arg2, arg3)
- struct objfile *objfile;
+static void
+patch_opaque_types (s)
struct symtab *s;
- PTR arg1;
- PTR arg2;
- PTR arg3;
{
register struct block *b;
register int i;
}
}
}
- return (NULL);
}
\f
static struct symbol *
TYPE_NAME (SYMBOL_TYPE (sym)) = concat (SYMBOL_NAME (sym), NULL);
/* Keep track of any type which points to empty structured type,
- so it can be filled from a definition from another file */
+ so it can be filled from a definition from another file. A
+ simple forward reference (TYPE_CODE_UNDEF) is not an
+ empty structured type, though; the forward references
+ work themselves out via the magic of coff_lookup_type. */
if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_PTR &&
- TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) == 0)
+ TYPE_LENGTH (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) == 0 &&
+ TYPE_CODE (TYPE_TARGET_TYPE (SYMBOL_TYPE (sym))) !=
+ TYPE_CODE_UNDEF)
{
register int i = hashname (SYMBOL_NAME (sym));
return type;
}
- /* Reference to existing type */
+ /* Reference to existing type. This only occurs with the
+ struct, union, and enum types. EPI a29k coff
+ fakes us out by producing aux entries with a nonzero
+ x_tagndx for definitions of structs, unions, and enums, so we
+ have to check the c_sclass field. */
if (cs->c_naux > 0 && aux->x_sym.x_tagndx.l != 0)
{
- type = coff_alloc_type (aux->x_sym.x_tagndx.l);
- return type;
+ if (cs->c_sclass != C_STRTAG
+ && cs->c_sclass != C_UNTAG
+ && cs->c_sclass != C_ENTAG)
+ {
+ type = coff_alloc_type (aux->x_sym.x_tagndx.l);
+ return type;
+ } else {
+ complain (&tagndx_bad_complaint, cs->c_name);
+ /* And fall through to decode_base_type... */
+ }
}
return decode_base_type (cs, BTYPE (c_type), aux);
#include "regex.h"
#include "expression.h"
#include "language.h"
+#include "demangle.h"
#include <obstack.h>
#include <assert.h>
/* Prototypes for local functions */
+static char *
+expensive_mangler PARAMS ((const char *));
+
extern int
find_methods PARAMS ((struct type *, char *, char **, struct symbol **));
static void
-completion_list_add_symbol PARAMS ((char *));
+completion_list_add_symbol PARAMS ((char *, char *, int));
static struct symtabs_and_lines
decode_line_2 PARAMS ((struct symbol *[], int, int));
char no_symtab_msg[] = "No symbol table is loaded. Use the \"file\" command.";
+/* While the C++ support is still in flux, issue a possibly helpful hint on
+ using the new command completion feature on single quoted demangled C++
+ symbols. Remove when loose ends are cleaned up. FIXME -fnf */
+
+void
+cplusplus_hint (name)
+ char *name;
+{
+ printf ("Hint: try '%s<TAB> or '%s<ESC-?>\n", name, name);
+ printf ("(Note leading single quote.)\n");
+}
+
/* Check for a symtab of a specific name; first in symtabs, then in
psymtabs. *If* there is no '/' in the name, a match after a '/'
in the symtab filename will also work. */
register struct objfile *objfile;
register struct block *b;
register struct minimal_symbol *msymbol;
+ char *temp;
+ extern char *gdb_completer_word_break_characters;
+
+ /* If NAME contains any characters from gdb_completer_word_break_characters
+ then it is probably from a quoted name string. So check to see if it
+ has a C++ mangled equivalent, and if so, use the mangled equivalent. */
+
+ if (strpbrk (name, gdb_completer_word_break_characters) != NULL)
+ {
+ if ((temp = expensive_mangler (name)) != NULL)
+ {
+ name = temp;
+ }
+ }
/* Search specified block and its superiors. */
/* Test each minimal symbol to see if the minimal symbol's name
is a C++ mangled name that matches a user visible name. */
- int matchcount = strlen (name);
char *demangled;
ALL_MSYMBOLS (objfile, msymbol)
{
- if (strncmp (msymbol -> name, name, matchcount) == 0)
+ demangled = demangle_and_match (msymbol -> name, name, 0);
+ if (demangled != NULL)
{
- demangled = cplus_demangle (msymbol -> name, -1);
- if (demangled != NULL)
- {
- if (strcmp (demangled, name) == 0)
- {
- free (demangled);
- goto found_msym;
- }
- free (demangled);
- }
+ free (demangled);
+ goto found_msym;
}
}
+ msymbol = NULL; /* Not found */
}
found_msym:
- if (msymbol != NULL && msymbol -> name != NULL)
+ if (msymbol != NULL)
{
s = find_pc_symtab (msymbol -> address);
/* If S is NULL, there are no debug symbols for this file.
register const struct block *block;
const char *name;
{
- register int bot, top, inc;
+ register int bot, top;
register struct symbol *sym;
+ char *demangled;
bot = 0;
top = BLOCK_NSYMS (block);
- inc = name[0];
while (bot < top)
{
sym = BLOCK_SYM (block, bot);
- if (SYMBOL_NAME (sym)[0] == inc
- && SYMBOL_NAMESPACE (sym) == VAR_NAMESPACE)
+ if (SYMBOL_NAMESPACE (sym) == VAR_NAMESPACE)
{
- char *demangled = cplus_demangle(SYMBOL_NAME (sym), -1);
+ demangled = demangle_and_match (SYMBOL_NAME (sym), name, 0);
if (demangled != NULL)
{
- int cond = strcmp (demangled, name);
free (demangled);
- if (!cond)
- return sym;
+ return (sym);
}
}
bot++;
}
- return 0;
+ return (NULL);
}
/* Look, in partial_symtab PST, for static mangled symbol NAME. */
{
struct partial_symbol *start, *psym;
int length = pst->n_static_syms;
- register int inc = name[0];
+ char *demangled;
if (!length)
return (struct partial_symbol *) 0;
start = pst->objfile->static_psymbols.list + pst->statics_offset;
for (psym = start; psym < start + length; psym++)
{
- if (SYMBOL_NAME (psym)[0] == inc
- && SYMBOL_NAMESPACE (psym) == VAR_NAMESPACE)
+ if (SYMBOL_NAMESPACE (psym) == VAR_NAMESPACE)
{
- char *demangled = cplus_demangle(SYMBOL_NAME (psym), -1);
+ demangled = demangle_and_match (SYMBOL_NAME (psym), name, 0);
if (demangled != NULL)
{
- int cond = strcmp (demangled, name);
free (demangled);
- if (!cond)
- return psym;
+ return (psym);
}
}
}
- return (struct partial_symbol *) 0;
+ return (NULL);
}
/* Look, in partial_symtab PST, for symbol NAME. Check the global
else
{
fputs_filtered("(Cannot find method ", stdout);
- fputs_demangled(phys_name, stdout, 0);
+ fputs_demangled(phys_name, stdout, DMGL_PARAMS);
fputs_filtered(" - possibly inlined.)\n", stdout);
}
}
struct symbol **sym_arr;
struct type *t;
char **physnames;
+ char *saved_arg = *argptr;
+ extern char *gdb_completer_quote_characters;
/* Defaults have defaults. */
default_line = current_source_line;
}
- /* See if arg is *PC */
- if (**argptr == '*')
+ /* Check to see if *ARGPTR points to a string that has been quoted with
+ gdb_completer_quote_characters. If so, P will be left pointing at
+ someplace other than *ARGPTR */
+
+ if (((p = skip_quoted (*argptr)) != *argptr) &&
+ ((*(p - 1) != **argptr) ||
+ (strchr (gdb_completer_quote_characters, **argptr) == NULL)))
{
- (*argptr)++;
+ /* Not quoted symbol string specification, reset P */
+ p = *argptr;
+ }
+
+ /* See if arg is *PC or '<some symbol specifier string>' */
+
+ if ((**argptr == '*') || (p != *argptr))
+ {
+ if (**argptr == '*')
+ {
+ (*argptr)++;
+ }
pc = parse_and_eval_address_1 (argptr);
values.sals = (struct symtab_and_line *)
xmalloc (sizeof (struct symtab_and_line));
tmp[q1 - q] = '\0';
opname = cplus_mangle_opname (tmp, 1);
if (opname == NULL)
- error ("No mangling for \"%s\"", tmp);
+ {
+ warning ("no mangling for \"%s\"", tmp);
+ cplusplus_hint (saved_arg);
+ return_to_top_level ();
+ }
copy = (char*) alloca (3 + strlen(opname));
sprintf (copy, "__%s", opname);
p = q1;
else
tmp = copy;
if (tmp[0] == '~')
- error ("The class `%s' does not have destructor defined",
- sym_class->name);
+ warning ("the class `%s' does not have destructor defined",
+ sym_class->name);
else
- error ("The class %s does not have any method named %s",
- sym_class->name, tmp);
+ warning ("the class %s does not have any method named %s",
+ sym_class->name, tmp);
+ cplusplus_hint (saved_arg);
+ return_to_top_level ();
}
}
else
- /* The quotes are important if copy is empty. */
- error("No class, struct, or union named \"%s\"", copy );
+ {
+ /* The quotes are important if copy is empty. */
+ warning ("can't find class, struct, or union named \"%s\"",
+ copy);
+ cplusplus_hint (saved_arg);
+ return_to_top_level ();
+ }
}
/* end of C++ */
/* Arg token is not digits => try it as a variable name
Find the next token (everything up to end or next whitespace). */
- p = *argptr;
- while (*p && *p != ' ' && *p != '\t' && *p != ',') p++;
+ p = skip_quoted (*argptr);
copy = (char *) alloca (p - *argptr + 1);
bcopy (*argptr, copy, p - *argptr);
- copy[p - *argptr] = 0;
+ copy[p - *argptr] = '\0';
+ if ((copy[0] == copy [p - *argptr - 1])
+ && strchr (gdb_completer_quote_characters, copy[0]) != NULL)
+ {
+ char *temp;
+ copy [p - *argptr - 1] = '\0';
+ copy++;
+ if ((temp = expensive_mangler (copy)) != NULL)
+ {
+ copy = temp;
+ }
+ }
while (*p == ' ' || *p == '\t') p++;
*argptr = p;
!have_partial_symbols () && !have_minimal_symbols ())
error (no_symtab_msg);
- error ("Function %s not defined.", copy);
+ error ("Function \"%s\" not defined.", copy);
return values; /* for lint */
}
char *name;
int *first;
{
- static unsigned int column;
/* Table of files printed so far. Since a single source file can
result in several partial symbol tables, we need to avoid printing
it more than once. Note: if some of the psymtabs are read in and
if (*first)
{
- column = 0;
*first = 0;
}
else
{
- printf_filtered (",");
- column++;
+ printf_filtered (", ");
}
- if (column != 0 && column + strlen (name) >= 70)
- {
- printf_filtered ("\n");
- column = 0;
- }
- else if (column != 0)
- {
- printf_filtered (" ");
- column++;
- }
+ wrap_here ("");
fputs_filtered (name, stdout);
- column += strlen (name);
}
static void
}
static int
-name_match(name)
+name_match (name)
char *name;
{
- char *demangled = cplus_demangle(name, -1);
+ char *demangled = cplus_demangle (name, 0);
if (demangled != NULL)
{
int cond = re_exec (demangled);
free (demangled);
- return cond;
+ return (cond);
}
- return re_exec(name);
+ return (re_exec (name));
}
#define NAME_MATCH(NAME) name_match(NAME)
if (regexp == 0 || NAME_MATCH (msymbol -> name))
{
/* Functions: Look up by address. */
- if (class != 1 &&
- (find_pc_symtab (msymbol -> address) != NULL))
+ if (class != 1 ||
+ (0 == find_pc_symtab (msymbol -> address)))
{
/* Variables/Absolutes: Look up by name */
if (lookup_symbol (msymbol -> name,
\f
/* Helper routine for make_symbol_completion_list. */
-int return_val_size, return_val_index;
-char **return_val;
+static int return_val_size;
+static int return_val_index;
+static char **return_val;
+
+/* Test to see if the symbol specified by SYMNAME (or it's demangled
+ equivalent) matches TEXT in the first TEXT_LEN characters. If so,
+ add it to the current completion list. */
static void
-completion_list_add_symbol (symname)
+completion_list_add_symbol (symname, text, text_len)
char *symname;
+ char *text;
+ int text_len;
{
- if (return_val_index + 3 > return_val_size)
- return_val = (char **) xrealloc ((char *) return_val,
- (return_val_size *= 2) * sizeof (char *));
-
- return_val[return_val_index] =
- (char *)xmalloc (1 + strlen (symname));
-
- strcpy (return_val[return_val_index], symname);
-
- return_val[++return_val_index] = (char *)NULL;
+ char *demangled;
+ int newsize;
+
+ /* First see if SYMNAME is a C++ mangled name, and if so, use the
+ demangled name instead, including any parameters. */
+
+ if ((demangled = cplus_demangle (symname, DMGL_PARAMS | DMGL_ANSI)) != NULL)
+ {
+ symname = demangled;
+ }
+
+ /* If we have a match for a completion, then add SYMNAME to the current
+ list of matches. Note that we always make a copy of the string, even
+ if it is one that was returned from cplus_demangle and is already
+ in malloc'd memory. */
+
+ if (strncmp (symname, text, text_len) == 0)
+ {
+ if (return_val_index + 3 > return_val_size)
+ {
+ newsize = (return_val_size *= 2) * sizeof (char *);
+ return_val = (char **) xrealloc ((char *) return_val, newsize);
+ }
+ return_val[return_val_index++] = savestring (symname, strlen (symname));
+ return_val[return_val_index] = NULL;
+ }
+
+ if (demangled != NULL)
+ {
+ free (demangled);
+ }
}
/* Return a NULL terminated array of all symbols (regardless of class) which
begin by matching TEXT. If the answer is no symbols, then the return value
is an array which contains only a NULL pointer.
- Problem: All of the symbols have to be copied because readline
- frees them. I'm not going to worry about this; hopefully there
- won't be that many. */
+ Problem: All of the symbols have to be copied because readline frees them.
+ I'm not going to worry about this; hopefully there won't be that many. */
char **
make_symbol_completion_list (text)
char *text;
{
+ register struct symbol *sym;
register struct symtab *s;
register struct partial_symtab *ps;
register struct minimal_symbol *msymbol;
register struct objfile *objfile;
register struct block *b, *surrounding_static_block = 0;
register int i, j;
+ int text_len;
struct partial_symbol *psym;
- int text_len = strlen (text);
+ text_len = strlen (text);
return_val_size = 100;
return_val_index = 0;
- return_val =
- (char **)xmalloc ((1 + return_val_size) *sizeof (char *));
- return_val[0] = (char *)NULL;
+ return_val = (char **) xmalloc ((return_val_size + 1) * sizeof (char *));
+ return_val[0] = NULL;
/* Look through the partial symtabs for all symbols which begin
by matching TEXT. Add each one that you find to the list. */
+ ps->n_global_syms);
psym++)
{
- QUIT; /* If interrupted, then quit. */
- if ((strncmp (SYMBOL_NAME (psym), text, text_len) == 0))
- completion_list_add_symbol (SYMBOL_NAME (psym));
+ /* If interrupted, then quit. */
+ QUIT;
+ completion_list_add_symbol (SYMBOL_NAME (psym), text, text_len);
}
for (psym = objfile->static_psymbols.list + ps->statics_offset;
psym++)
{
QUIT;
- if ((strncmp (SYMBOL_NAME (psym), text, text_len) == 0))
- completion_list_add_symbol (SYMBOL_NAME (psym));
+ completion_list_add_symbol (SYMBOL_NAME (psym), text, text_len);
}
}
ALL_MSYMBOLS (objfile, msymbol)
{
- if (strncmp (text, msymbol -> name, text_len) == 0)
- {
- completion_list_add_symbol (msymbol -> name);
- }
+ QUIT;
+ completion_list_add_symbol (msymbol -> name, text, text_len);
}
/* Search upwards from currently selected frame (so that we can
complete on local vars. */
+
+ for (b = get_selected_block (); b != NULL; b = BLOCK_SUPERBLOCK (b))
+ {
+ if (!BLOCK_SUPERBLOCK (b))
+ {
+ surrounding_static_block = b; /* For elmin of dups */
+ }
+
+ /* Also catch fields of types defined in this places which match our
+ text string. Only complete on types visible from current context. */
+
+ for (i = 0; i < BLOCK_NSYMS (b); i++)
+ {
+ sym = BLOCK_SYM (b, i);
+ completion_list_add_symbol (SYMBOL_NAME (sym), text, text_len);
+ if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
+ {
+ struct type *t = SYMBOL_TYPE (sym);
+ enum type_code c = TYPE_CODE (t);
+
+ if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT)
+ {
+ for (j = TYPE_N_BASECLASSES (t); j < TYPE_NFIELDS (t); j++)
+ {
+ if (TYPE_FIELD_NAME (t, j))
+ {
+ completion_list_add_symbol (TYPE_FIELD_NAME (t, j),
+ text, text_len);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ /* Go through the symtabs and check the externs and statics for
+ symbols which match. */
+
+ ALL_SYMTABS (objfile, s)
+ {
+ QUIT;
+ b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
+ for (i = 0; i < BLOCK_NSYMS (b); i++)
+ {
+ sym = BLOCK_SYM (b, i);
+ completion_list_add_symbol (SYMBOL_NAME (sym), text, text_len);
+ }
+ }
+
+ ALL_SYMTABS (objfile, s)
+ {
+ QUIT;
+ b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
+ /* Don't do this block twice. */
+ if (b == surrounding_static_block) continue;
+ for (i = 0; i < BLOCK_NSYMS (b); i++)
+ {
+ sym = BLOCK_SYM (b, i);
+ completion_list_add_symbol (SYMBOL_NAME (sym), text, text_len);
+ }
+ }
+
+ return (return_val);
+}
+
+\f
+/* Find a mangled symbol that corresponds to LOOKFOR using brute force.
+ Basically we go munging through available symbols, demangling each one,
+ looking for a match on the demangled result. */
+
+static char *
+expensive_mangler (lookfor)
+ const char *lookfor;
+{
+ register struct symbol *sym;
+ register struct symtab *s;
+ register struct partial_symtab *ps;
+ register struct minimal_symbol *msymbol;
+ register struct objfile *objfile;
+ register struct block *b, *surrounding_static_block = 0;
+ register int i, j;
+ struct partial_symbol *psym;
+ char *demangled;
+
+ /* Look through the partial symtabs for a symbol that matches */
+
+ ALL_PSYMTABS (objfile, ps)
+ {
+ /* If the psymtab's been read in we'll get it when we search
+ through the blockvector. */
+ if (ps->readin) continue;
+
+ for (psym = objfile->global_psymbols.list + ps->globals_offset;
+ psym < (objfile->global_psymbols.list + ps->globals_offset
+ + ps->n_global_syms);
+ psym++)
+ {
+ QUIT; /* If interrupted, then quit. */
+ demangled = demangle_and_match (SYMBOL_NAME (psym), lookfor,
+ DMGL_PARAMS | DMGL_ANSI);
+ if (demangled != NULL)
+ {
+ free (demangled);
+ return (SYMBOL_NAME (psym));
+ }
+ }
+
+ for (psym = objfile->static_psymbols.list + ps->statics_offset;
+ psym < (objfile->static_psymbols.list + ps->statics_offset
+ + ps->n_static_syms);
+ psym++)
+ {
+ QUIT;
+ demangled = demangle_and_match (SYMBOL_NAME (psym), lookfor,
+ DMGL_PARAMS | DMGL_ANSI);
+ if (demangled != NULL)
+ {
+ free (demangled);
+ return (SYMBOL_NAME (psym));
+ }
+ }
+ }
+
+ /* Scan through the misc symbol vectors looking for a match. */
+
+ ALL_MSYMBOLS (objfile, msymbol)
+ {
+ QUIT;
+ demangled = demangle_and_match (msymbol -> name, lookfor,
+ DMGL_PARAMS | DMGL_ANSI);
+ if (demangled != NULL)
+ {
+ free (demangled);
+ return (msymbol -> name);
+ }
+ }
+
+ /* Search upwards from currently selected frame looking for a match */
+
for (b = get_selected_block (); b; b = BLOCK_SUPERBLOCK (b))
{
if (!BLOCK_SUPERBLOCK (b))
from current context. */
for (i = 0; i < BLOCK_NSYMS (b); i++)
{
- register struct symbol *sym = BLOCK_SYM (b, i);
-
- if (!strncmp (SYMBOL_NAME (sym), text, text_len))
- completion_list_add_symbol (SYMBOL_NAME (sym));
-
+ sym = BLOCK_SYM (b, i);
+ demangled = demangle_and_match (SYMBOL_NAME (sym), lookfor,
+ DMGL_PARAMS | DMGL_ANSI);
+ if (demangled != NULL)
+ {
+ free (demangled);
+ return (SYMBOL_NAME (sym));
+ }
if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
{
struct type *t = SYMBOL_TYPE (sym);
enum type_code c = TYPE_CODE (t);
if (c == TYPE_CODE_UNION || c == TYPE_CODE_STRUCT)
- for (j = TYPE_N_BASECLASSES (t); j < TYPE_NFIELDS (t); j++)
- if (TYPE_FIELD_NAME (t, j) &&
- !strncmp (TYPE_FIELD_NAME (t, j), text, text_len))
- completion_list_add_symbol (TYPE_FIELD_NAME (t, j));
+ {
+ for (j = TYPE_N_BASECLASSES (t); j < TYPE_NFIELDS (t); j++)
+ {
+ if (TYPE_FIELD_NAME (t, j))
+ {
+ demangled =
+ demangle_and_match (TYPE_FIELD_NAME (t, j),
+ lookfor,
+ DMGL_PARAMS | DMGL_ANSI);
+ if (demangled != NULL)
+ {
+ free (demangled);
+ return (TYPE_FIELD_NAME (t, j));
+ }
+ }
+ }
+ }
}
}
}
ALL_SYMTABS (objfile, s)
{
+ QUIT;
b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
-
for (i = 0; i < BLOCK_NSYMS (b); i++)
- if (!strncmp (SYMBOL_NAME (BLOCK_SYM (b, i)), text, text_len))
- completion_list_add_symbol (SYMBOL_NAME (BLOCK_SYM (b, i)));
+ {
+ sym = BLOCK_SYM (b, i);
+ demangled = demangle_and_match (SYMBOL_NAME (sym), lookfor,
+ DMGL_PARAMS | DMGL_ANSI);
+ if (demangled != NULL)
+ {
+ free (demangled);
+ return (SYMBOL_NAME (sym));
+ }
+ }
}
ALL_SYMTABS (objfile, s)
{
+ QUIT;
b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
-
/* Don't do this block twice. */
if (b == surrounding_static_block) continue;
-
for (i = 0; i < BLOCK_NSYMS (b); i++)
- if (!strncmp (SYMBOL_NAME (BLOCK_SYM (b, i)), text, text_len))
- completion_list_add_symbol (SYMBOL_NAME (BLOCK_SYM (b, i)));
+ {
+ sym = BLOCK_SYM (b, i);
+ demangled = demangle_and_match (SYMBOL_NAME (sym), lookfor,
+ DMGL_PARAMS | DMGL_ANSI);
+ if (demangled != NULL)
+ {
+ free (demangled);
+ return (SYMBOL_NAME (sym));
+ }
+ }
}
- return (return_val);
+ return (NULL);
}
+
\f
#if 0
/* Add the type of the symbol sym to the type of the current
projects / binutils-gdb.git / commitdiff