#include "parser-defs.h"
#include "completer.h"
#include "progspace-and-thread.h"
+#include "common/gdb_optional.h"
+#include "filename-seen-cache.h"
+#include "arch-utils.h"
+#include <algorithm>
/* Forward declarations for local functions. */
/* See symtab.h. */
const struct block_symbol null_block_symbol = { NULL, NULL };
-extern initialize_file_ftype _initialize_symtab;
-
/* Program space key for finding name and language of "main". */
static const struct program_space_data *main_progspace_key;
absolutizing a relative path. */
if (IS_ABSOLUTE_PATH (name))
{
- real_path.reset (gdb_realpath (name));
+ real_path = gdb_realpath (name);
gdb_assert (IS_ABSOLUTE_PATH (real_path.get ()));
}
else
return symbol_natural_name (gsymbol);
}
-
-/* Initialize the structure fields to zero values. */
-
-void
-init_sal (struct symtab_and_line *sal)
-{
- memset (sal, 0, sizeof (*sal));
-}
\f
/* Return 1 if the two sections are the same, or if they could
/* The "mt print symbol-cache" command. */
static void
-maintenance_print_symbol_cache (char *args, int from_tty)
+maintenance_print_symbol_cache (const char *args, int from_tty)
{
struct program_space *pspace;
/* The "mt flush-symbol-cache" command. */
static void
-maintenance_flush_symbol_cache (char *args, int from_tty)
+maintenance_flush_symbol_cache (const char *args, int from_tty)
{
struct program_space *pspace;
/* The "mt print symbol-cache-statistics" command. */
static void
-maintenance_print_symbol_cache_statistics (char *args, int from_tty)
+maintenance_print_symbol_cache_statistics (const char *args, int from_tty)
{
struct program_space *pspace;
Similarly, any Ada type declaration implicitly defines a typedef. */
if (symbol_language == language_cplus
|| symbol_language == language_d
- || symbol_language == language_ada)
+ || symbol_language == language_ada
+ || symbol_language == language_rust)
{
if ((domain == VAR_DOMAIN || domain == STRUCT_DOMAIN)
&& symbol_domain == STRUCT_DOMAIN)
int len;
int i;
struct linetable_entry *item;
- struct symtab_and_line val;
const struct blockvector *bv;
struct bound_minimal_symbol msymbol;
But what we want is the statement containing the instruction.
Fudge the pc to make sure we get that. */
- init_sal (&val); /* initialize to zeroes */
-
- val.pspace = current_program_space;
-
/* It's tempting to assume that, if we can't find debugging info for
any function enclosing PC, that we shouldn't search for line
number info, either. However, GAS can emit line number info for
return find_pc_line (BMSYMBOL_VALUE_ADDRESS (mfunsym), 0);
}
+ symtab_and_line val;
+ val.pspace = current_program_space;
cust = find_pc_sect_compunit_symtab (pc, section);
if (cust == NULL)
struct symtab_and_line
find_function_start_sal (struct symbol *sym, int funfirstline)
{
- struct symtab_and_line sal;
- struct obj_section *section;
-
fixup_symbol_section (sym, NULL);
- section = SYMBOL_OBJ_SECTION (symbol_objfile (sym), sym);
- sal = find_pc_sect_line (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)), section, 0);
+
+ obj_section *section = SYMBOL_OBJ_SECTION (symbol_objfile (sym), sym);
+ symtab_and_line sal
+ = find_pc_sect_line (BLOCK_START (SYMBOL_BLOCK_VALUE (sym)), section, 0);
+ sal.symbol = sym;
if (funfirstline && sal.symtab != NULL
&& (COMPUNIT_LOCATIONS_VALID (SYMTAB_COMPUNIT (sal.symtab))
can find a line number for after the prologue. */
if (sal.pc < BLOCK_START (SYMBOL_BLOCK_VALUE (sym)))
{
- init_sal (&sal);
+ sal = {};
sal.pspace = current_program_space;
sal.pc = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
sal.section = section;
+ sal.symbol = sym;
}
if (funfirstline)
if (gdbarch_skip_entrypoint_p (gdbarch))
pc = gdbarch_skip_entrypoint (gdbarch, pc);
if (skip)
- pc = gdbarch_skip_prologue (gdbarch, pc);
+ pc = gdbarch_skip_prologue_noexcept (gdbarch, pc);
/* For overlays, map pc back into its mapped VMA range. */
pc = overlay_mapped_address (pc, section);
/* Don't return END_PC, which is past the end of the function. */
return prologue_sal.pc;
}
+
+/* See symtab.h. */
+
+symbol *
+find_function_alias_target (bound_minimal_symbol msymbol)
+{
+ if (!msymbol_is_text (msymbol.minsym))
+ return NULL;
+
+ CORE_ADDR addr = BMSYMBOL_VALUE_ADDRESS (msymbol);
+ symbol *sym = find_pc_function (addr);
+ if (sym != NULL
+ && SYMBOL_CLASS (sym) == LOC_BLOCK
+ && BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) == addr)
+ return sym;
+
+ return NULL;
+}
+
\f
/* If P is of the form "operator[ \t]+..." where `...' is
some legitimate operator text, return a pointer to the
operator_chars (const char *p, const char **end)
{
*end = "";
- if (!startswith (p, "operator"))
+ if (!startswith (p, CP_OPERATOR_STR))
return *end;
- p += 8;
+ p += CP_OPERATOR_LEN;
/* Don't get faked out by `operator' being part of a longer
identifier. */
}
\f
-/* Cache to watch for file names already seen by filename_seen. */
-
-struct filename_seen_cache
-{
- /* Table of files seen so far. */
- htab_t tab;
- /* Initial size of the table. It automagically grows from here. */
-#define INITIAL_FILENAME_SEEN_CACHE_SIZE 100
-};
-
-/* filename_seen_cache constructor. */
-
-static struct filename_seen_cache *
-create_filename_seen_cache (void)
-{
- struct filename_seen_cache *cache = XNEW (struct filename_seen_cache);
-
- cache->tab = htab_create_alloc (INITIAL_FILENAME_SEEN_CACHE_SIZE,
- filename_hash, filename_eq,
- NULL, xcalloc, xfree);
-
- return cache;
-}
-
-/* Empty the cache, but do not delete it. */
-
-static void
-clear_filename_seen_cache (struct filename_seen_cache *cache)
-{
- htab_empty (cache->tab);
-}
-
-/* filename_seen_cache destructor.
- This takes a void * argument as it is generally used as a cleanup. */
-
-static void
-delete_filename_seen_cache (void *ptr)
-{
- struct filename_seen_cache *cache = (struct filename_seen_cache *) ptr;
-
- htab_delete (cache->tab);
- xfree (cache);
-}
-
-/* If FILE is not already in the table of files in CACHE, return zero;
- otherwise return non-zero. Optionally add FILE to the table if ADD
- is non-zero.
-
- NOTE: We don't manage space for FILE, we assume FILE lives as long
- as the caller needs. */
-
-static int
-filename_seen (struct filename_seen_cache *cache, const char *file, int add)
-{
- void **slot;
-
- /* Is FILE in tab? */
- slot = htab_find_slot (cache->tab, file, add ? INSERT : NO_INSERT);
- if (*slot != NULL)
- return 1;
-
- /* No; maybe add it to tab. */
- if (add)
- *slot = (char *) file;
-
- return 0;
-}
-
/* Data structure to maintain printing state for output_source_filename. */
struct output_source_filename_data
symtabs; it doesn't hurt to check. */
/* Was NAME already seen? */
- if (filename_seen (data->filename_seen_cache, name, 1))
+ if (data->filename_seen_cache->seen (name))
{
/* Yes; don't print it again. */
return;
}
static void
-sources_info (char *ignore, int from_tty)
+info_sources_command (char *ignore, int from_tty)
{
struct compunit_symtab *cu;
struct symtab *s;
struct objfile *objfile;
struct output_source_filename_data data;
- struct cleanup *cleanups;
if (!have_full_symbols () && !have_partial_symbols ())
{
error (_("No symbol table is loaded. Use the \"file\" command."));
}
- data.filename_seen_cache = create_filename_seen_cache ();
- cleanups = make_cleanup (delete_filename_seen_cache,
- data.filename_seen_cache);
+ filename_seen_cache filenames_seen;
+
+ data.filename_seen_cache = &filenames_seen;
printf_filtered ("Source files for which symbols have been read in:\n\n");
printf_filtered ("Source files for which symbols "
"will be read in on demand:\n\n");
- clear_filename_seen_cache (data.filename_seen_cache);
+ filenames_seen.clear ();
data.first = 1;
map_symbol_filenames (output_partial_symbol_filename, &data,
1 /*need_fullname*/);
printf_filtered ("\n");
-
- do_cleanups (cleanups);
}
/* Compare FILE against all the NFILES entries of FILES. If BASENAMES is
return 0;
}
-/* Free any memory associated with a search. */
-
-void
-free_search_symbols (struct symbol_search *symbols)
-{
- struct symbol_search *p;
- struct symbol_search *next;
-
- for (p = symbols; p != NULL; p = next)
- {
- next = p->next;
- xfree (p);
- }
-}
-
-static void
-do_free_search_symbols_cleanup (void *symbolsp)
-{
- struct symbol_search *symbols = *(struct symbol_search **) symbolsp;
-
- free_search_symbols (symbols);
-}
-
-struct cleanup *
-make_cleanup_free_search_symbols (struct symbol_search **symbolsp)
-{
- return make_cleanup (do_free_search_symbols_cleanup, symbolsp);
-}
-
/* Helper function for sort_search_symbols_remove_dups and qsort. Can only
sort symbols, not minimal symbols. */
-static int
-compare_search_syms (const void *sa, const void *sb)
+int
+symbol_search::compare_search_syms (const symbol_search &sym_a,
+ const symbol_search &sym_b)
{
- struct symbol_search *sym_a = *(struct symbol_search **) sa;
- struct symbol_search *sym_b = *(struct symbol_search **) sb;
int c;
- c = FILENAME_CMP (symbol_symtab (sym_a->symbol)->filename,
- symbol_symtab (sym_b->symbol)->filename);
+ c = FILENAME_CMP (symbol_symtab (sym_a.symbol)->filename,
+ symbol_symtab (sym_b.symbol)->filename);
if (c != 0)
return c;
- if (sym_a->block != sym_b->block)
- return sym_a->block - sym_b->block;
+ if (sym_a.block != sym_b.block)
+ return sym_a.block - sym_b.block;
- return strcmp (SYMBOL_PRINT_NAME (sym_a->symbol),
- SYMBOL_PRINT_NAME (sym_b->symbol));
+ return strcmp (SYMBOL_PRINT_NAME (sym_a.symbol),
+ SYMBOL_PRINT_NAME (sym_b.symbol));
}
-/* Sort the NFOUND symbols in list FOUND and remove duplicates.
- The duplicates are freed, and the new list is returned in
- *NEW_HEAD, *NEW_TAIL. */
+/* Sort the symbols in RESULT and remove duplicates. */
static void
-sort_search_symbols_remove_dups (struct symbol_search *found, int nfound,
- struct symbol_search **new_head,
- struct symbol_search **new_tail)
+sort_search_symbols_remove_dups (std::vector<symbol_search> *result)
{
- struct symbol_search **symbols, *symp;
- int i, j, nunique;
-
- gdb_assert (found != NULL && nfound > 0);
-
- /* Build an array out of the list so we can easily sort them. */
- symbols = XNEWVEC (struct symbol_search *, nfound);
-
- symp = found;
- for (i = 0; i < nfound; i++)
- {
- gdb_assert (symp != NULL);
- gdb_assert (symp->block >= 0 && symp->block <= 1);
- symbols[i] = symp;
- symp = symp->next;
- }
- gdb_assert (symp == NULL);
-
- qsort (symbols, nfound, sizeof (struct symbol_search *),
- compare_search_syms);
-
- /* Collapse out the dups. */
- for (i = 1, j = 1; i < nfound; ++i)
- {
- if (compare_search_syms (&symbols[j - 1], &symbols[i]) != 0)
- symbols[j++] = symbols[i];
- else
- xfree (symbols[i]);
- }
- nunique = j;
- symbols[j - 1]->next = NULL;
-
- /* Rebuild the linked list. */
- for (i = 0; i < nunique - 1; i++)
- symbols[i]->next = symbols[i + 1];
- symbols[nunique - 1]->next = NULL;
-
- *new_head = symbols[0];
- *new_tail = symbols[nunique - 1];
- xfree (symbols);
+ std::sort (result->begin (), result->end ());
+ result->erase (std::unique (result->begin (), result->end ()),
+ result->end ());
}
/* Search the symbol table for matches to the regular expression REGEXP,
- returning the results in *MATCHES.
+ returning the results.
Only symbols of KIND are searched:
VARIABLES_DOMAIN - search all symbols, excluding functions, type names,
TYPES_DOMAIN - search all type names
ALL_DOMAIN - an internal error for this function
- free_search_symbols should be called when *MATCHES is no longer needed.
-
Within each file the results are sorted locally; each symtab's global and
static blocks are separately alphabetized.
Duplicate entries are removed. */
-void
+std::vector<symbol_search>
search_symbols (const char *regexp, enum search_domain kind,
- int nfiles, const char *files[],
- struct symbol_search **matches)
+ int nfiles, const char *files[])
{
struct compunit_symtab *cust;
const struct blockvector *bv;
enum minimal_symbol_type ourtype2;
enum minimal_symbol_type ourtype3;
enum minimal_symbol_type ourtype4;
- struct symbol_search *found;
- struct symbol_search *tail;
- int nfound;
- /* This is true if PREG contains valid data, false otherwise. */
- bool preg_p;
- regex_t preg;
-
- /* OLD_CHAIN .. RETVAL_CHAIN is always freed, RETVAL_CHAIN .. current
- CLEANUP_CHAIN is freed only in the case of an error. */
- struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
- struct cleanup *retval_chain;
+ std::vector<symbol_search> result;
+ gdb::optional<compiled_regex> preg;
gdb_assert (kind <= TYPES_DOMAIN);
ourtype3 = types3[kind];
ourtype4 = types4[kind];
- *matches = NULL;
- preg_p = false;
-
if (regexp != NULL)
{
/* Make sure spacing is right for C++ operators.
}
}
- errcode = regcomp (&preg, regexp,
- REG_NOSUB | (case_sensitivity == case_sensitive_off
- ? REG_ICASE : 0));
- if (errcode != 0)
- {
- char *err = get_regcomp_error (errcode, &preg);
-
- make_cleanup (xfree, err);
- error (_("Invalid regexp (%s): %s"), err, regexp);
- }
- preg_p = true;
- make_regfree_cleanup (&preg);
+ int cflags = REG_NOSUB | (case_sensitivity == case_sensitive_off
+ ? REG_ICASE : 0);
+ preg.emplace (regexp, cflags, _("Invalid regexp"));
}
/* Search through the partial symtabs *first* for all symbols
},
[&] (const char *symname)
{
- return (!preg_p || regexec (&preg, symname,
- 0, NULL, 0) == 0);
+ return (!preg || preg->exec (symname,
+ 0, NULL, 0) == 0);
},
NULL,
kind);
|| MSYMBOL_TYPE (msymbol) == ourtype3
|| MSYMBOL_TYPE (msymbol) == ourtype4)
{
- if (!preg_p
- || regexec (&preg, MSYMBOL_NATURAL_NAME (msymbol), 0,
- NULL, 0) == 0)
+ if (!preg
+ || preg->exec (MSYMBOL_NATURAL_NAME (msymbol), 0,
+ NULL, 0) == 0)
{
/* Note: An important side-effect of these lookup functions
is to expand the symbol table if msymbol is found, for the
}
}
- found = NULL;
- tail = NULL;
- nfound = 0;
- retval_chain = make_cleanup_free_search_symbols (&found);
-
ALL_COMPUNITS (objfile, cust)
{
bv = COMPUNIT_BLOCKVECTOR (cust);
files, nfiles, 1))
&& file_matches (symtab_to_fullname (real_symtab),
files, nfiles, 0)))
- && ((!preg_p
- || regexec (&preg, SYMBOL_NATURAL_NAME (sym), 0,
- NULL, 0) == 0)
+ && ((!preg
+ || preg->exec (SYMBOL_NATURAL_NAME (sym), 0,
+ NULL, 0) == 0)
&& ((kind == VARIABLES_DOMAIN
&& SYMBOL_CLASS (sym) != LOC_TYPEDEF
&& SYMBOL_CLASS (sym) != LOC_UNRESOLVED
&& SYMBOL_CLASS (sym) == LOC_TYPEDEF))))
{
/* match */
- struct symbol_search *psr = XCNEW (struct symbol_search);
-
- psr->block = i;
- psr->symbol = sym;
- psr->next = NULL;
- if (tail == NULL)
- found = psr;
- else
- tail->next = psr;
- tail = psr;
- nfound ++;
+ result.emplace_back (i, sym);
}
}
}
}
- if (found != NULL)
- {
- sort_search_symbols_remove_dups (found, nfound, &found, &tail);
- /* Note: nfound is no longer useful beyond this point. */
- }
+ if (!result.empty ())
+ sort_search_symbols_remove_dups (&result);
/* If there are no eyes, avoid all contact. I mean, if there are
no debug symbols, then add matching minsyms. */
|| MSYMBOL_TYPE (msymbol) == ourtype3
|| MSYMBOL_TYPE (msymbol) == ourtype4)
{
- if (!preg_p
- || regexec (&preg, MSYMBOL_NATURAL_NAME (msymbol), 0,
- NULL, 0) == 0)
+ if (!preg || preg->exec (MSYMBOL_NATURAL_NAME (msymbol), 0,
+ NULL, 0) == 0)
{
/* For functions we can do a quick check of whether the
symbol might be found via find_pc_symtab. */
.symbol == NULL)
{
/* match */
- struct symbol_search *psr = XNEW (struct symbol_search);
- psr->block = i;
- psr->msymbol.minsym = msymbol;
- psr->msymbol.objfile = objfile;
- psr->symbol = NULL;
- psr->next = NULL;
- if (tail == NULL)
- found = psr;
- else
- tail->next = psr;
- tail = psr;
+ result.emplace_back (i, msymbol, objfile);
}
}
}
}
}
- discard_cleanups (retval_chain);
- do_cleanups (old_chain);
- *matches = found;
+ return result;
}
/* Helper function for symtab_symbol_info, this function uses
{
static const char * const classnames[] =
{"variable", "function", "type"};
- struct symbol_search *symbols;
- struct symbol_search *p;
- struct cleanup *old_chain;
const char *last_filename = NULL;
int first = 1;
gdb_assert (kind <= TYPES_DOMAIN);
/* Must make sure that if we're interrupted, symbols gets freed. */
- search_symbols (regexp, kind, 0, NULL, &symbols);
- old_chain = make_cleanup_free_search_symbols (&symbols);
+ std::vector<symbol_search> symbols = search_symbols (regexp, kind, 0, NULL);
if (regexp != NULL)
printf_filtered (_("All %ss matching regular expression \"%s\":\n"),
else
printf_filtered (_("All defined %ss:\n"), classnames[kind]);
- for (p = symbols; p != NULL; p = p->next)
+ for (const symbol_search &p : symbols)
{
QUIT;
- if (p->msymbol.minsym != NULL)
+ if (p.msymbol.minsym != NULL)
{
if (first)
{
printf_filtered (_("\nNon-debugging symbols:\n"));
first = 0;
}
- print_msymbol_info (p->msymbol);
+ print_msymbol_info (p.msymbol);
}
else
{
print_symbol_info (kind,
- p->symbol,
- p->block,
+ p.symbol,
+ p.block,
last_filename);
last_filename
- = symtab_to_filename_for_display (symbol_symtab (p->symbol));
+ = symtab_to_filename_for_display (symbol_symtab (p.symbol));
}
}
-
- do_cleanups (old_chain);
}
static void
-variables_info (char *regexp, int from_tty)
+info_variables_command (char *regexp, int from_tty)
{
symtab_symbol_info (regexp, VARIABLES_DOMAIN, from_tty);
}
static void
-functions_info (char *regexp, int from_tty)
+info_functions_command (char *regexp, int from_tty)
{
symtab_symbol_info (regexp, FUNCTIONS_DOMAIN, from_tty);
}
static void
-types_info (char *regexp, int from_tty)
+info_types_command (char *regexp, int from_tty)
{
symtab_symbol_info (regexp, TYPES_DOMAIN, from_tty);
}
static void
rbreak_command (char *regexp, int from_tty)
{
- struct symbol_search *ss;
- struct symbol_search *p;
struct cleanup *old_chain;
char *string = NULL;
int len = 0;
}
}
- search_symbols (regexp, FUNCTIONS_DOMAIN, nfiles, files, &ss);
- old_chain = make_cleanup_free_search_symbols (&ss);
- make_cleanup (free_current_contents, &string);
+ std::vector<symbol_search> symbols = search_symbols (regexp,
+ FUNCTIONS_DOMAIN,
+ nfiles, files);
start_rbreak_breakpoints ();
- make_cleanup (do_end_rbreak_breakpoints, NULL);
- for (p = ss; p != NULL; p = p->next)
+ old_chain = make_cleanup (do_end_rbreak_breakpoints, NULL);
+ for (const symbol_search &p : symbols)
{
- if (p->msymbol.minsym == NULL)
+ if (p.msymbol.minsym == NULL)
{
- struct symtab *symtab = symbol_symtab (p->symbol);
+ struct symtab *symtab = symbol_symtab (p.symbol);
const char *fullname = symtab_to_fullname (symtab);
int newlen = (strlen (fullname)
- + strlen (SYMBOL_LINKAGE_NAME (p->symbol))
+ + strlen (SYMBOL_LINKAGE_NAME (p.symbol))
+ 4);
if (newlen > len)
}
strcpy (string, fullname);
strcat (string, ":'");
- strcat (string, SYMBOL_LINKAGE_NAME (p->symbol));
+ strcat (string, SYMBOL_LINKAGE_NAME (p.symbol));
strcat (string, "'");
break_command (string, from_tty);
print_symbol_info (FUNCTIONS_DOMAIN,
- p->symbol,
- p->block,
+ p.symbol,
+ p.block,
symtab_to_filename_for_display (symtab));
}
else
{
- int newlen = (strlen (MSYMBOL_LINKAGE_NAME (p->msymbol.minsym)) + 3);
+ int newlen = (strlen (MSYMBOL_LINKAGE_NAME (p.msymbol.minsym)) + 3);
if (newlen > len)
{
len = newlen;
}
strcpy (string, "'");
- strcat (string, MSYMBOL_LINKAGE_NAME (p->msymbol.minsym));
+ strcat (string, MSYMBOL_LINKAGE_NAME (p.msymbol.minsym));
strcat (string, "'");
break_command (string, from_tty);
printf_filtered ("<function, no debug info> %s;\n",
- MSYMBOL_PRINT_NAME (p->msymbol.minsym));
+ MSYMBOL_PRINT_NAME (p.msymbol.minsym));
}
}
return 1;
}
-/* Free any memory associated with a completion list. */
-
-static void
-free_completion_list (VEC (char_ptr) **list_ptr)
-{
- int i;
- char *p;
-
- for (i = 0; VEC_iterate (char_ptr, *list_ptr, i, p); ++i)
- xfree (p);
- VEC_free (char_ptr, *list_ptr);
-}
-
-/* Callback for make_cleanup. */
-
-static void
-do_free_completion_list (void *list)
-{
- free_completion_list ((VEC (char_ptr) **) list);
-}
-
-/* Helper routine for make_symbol_completion_list. */
-
-static VEC (char_ptr) *return_val;
-
-#define COMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
- completion_list_add_name \
- (SYMBOL_NATURAL_NAME (symbol), (sym_text), (len), (text), (word))
-
-#define MCOMPLETION_LIST_ADD_SYMBOL(symbol, sym_text, len, text, word) \
- completion_list_add_name \
- (MSYMBOL_NATURAL_NAME (symbol), (sym_text), (len), (text), (word))
-
-/* Tracker for how many unique completions have been generated. Used
- to terminate completion list generation early if the list has grown
- to a size so large as to be useless. This helps avoid GDB seeming
- to lock up in the event the user requests to complete on something
- vague that necessitates the time consuming expansion of many symbol
- tables. */
-
-static completion_tracker_t completion_tracker;
-
/* Test to see if the symbol specified by SYMNAME (which is already
demangled for C++ symbols) matches SYM_TEXT in the first SYM_TEXT_LEN
characters. If so, add it to the current completion list. */
static void
-completion_list_add_name (const char *symname,
+completion_list_add_name (completion_tracker &tracker,
+ const char *symname,
const char *sym_text, int sym_text_len,
const char *text, const char *word)
{
{
char *newobj;
- enum maybe_add_completion_enum add_status;
if (word == sym_text)
{
strcat (newobj, symname);
}
- add_status = maybe_add_completion (completion_tracker, newobj);
+ gdb::unique_xmalloc_ptr<char> completion (newobj);
- switch (add_status)
- {
- case MAYBE_ADD_COMPLETION_OK:
- VEC_safe_push (char_ptr, return_val, newobj);
- break;
- case MAYBE_ADD_COMPLETION_OK_MAX_REACHED:
- VEC_safe_push (char_ptr, return_val, newobj);
- throw_max_completions_reached_error ();
- case MAYBE_ADD_COMPLETION_MAX_REACHED:
- xfree (newobj);
- throw_max_completions_reached_error ();
- case MAYBE_ADD_COMPLETION_DUPLICATE:
- xfree (newobj);
- break;
- }
+ tracker.add_completion (std::move (completion));
}
}
+/* completion_list_add_name wrapper for struct symbol. */
+
+static void
+completion_list_add_symbol (completion_tracker &tracker,
+ symbol *sym,
+ const char *sym_text, int sym_text_len,
+ const char *text, const char *word)
+{
+ completion_list_add_name (tracker, SYMBOL_NATURAL_NAME (sym),
+ sym_text, sym_text_len, text, word);
+}
+
+/* completion_list_add_name wrapper for struct minimal_symbol. */
+
+static void
+completion_list_add_msymbol (completion_tracker &tracker,
+ minimal_symbol *sym,
+ const char *sym_text, int sym_text_len,
+ const char *text, const char *word)
+{
+ completion_list_add_name (tracker, MSYMBOL_NATURAL_NAME (sym),
+ sym_text, sym_text_len, text, word);
+}
+
/* ObjC: In case we are completing on a selector, look as the msymbol
again and feed all the selectors into the mill. */
static void
-completion_list_objc_symbol (struct minimal_symbol *msymbol,
+completion_list_objc_symbol (completion_tracker &tracker,
+ struct minimal_symbol *msymbol,
const char *sym_text, int sym_text_len,
const char *text, const char *word)
{
if (sym_text[0] == '[')
/* Complete on shortened method method. */
- completion_list_add_name (method + 1, sym_text, sym_text_len, text, word);
+ completion_list_add_name (tracker, method + 1,
+ sym_text, sym_text_len, text, word);
while ((strlen (method) + 1) >= tmplen)
{
memcpy (tmp, method, (category - method));
tmp[category - method] = ' ';
memcpy (tmp + (category - method) + 1, selector, strlen (selector) + 1);
- completion_list_add_name (tmp, sym_text, sym_text_len, text, word);
+ completion_list_add_name (tracker, tmp,
+ sym_text, sym_text_len, text, word);
if (sym_text[0] == '[')
- completion_list_add_name (tmp + 1, sym_text, sym_text_len, text, word);
+ completion_list_add_name (tracker, tmp + 1,
+ sym_text, sym_text_len, text, word);
}
if (selector != NULL)
if (tmp2 != NULL)
*tmp2 = '\0';
- completion_list_add_name (tmp, sym_text, sym_text_len, text, word);
+ completion_list_add_name (tracker, tmp,
+ sym_text, sym_text_len, text, word);
}
}
}
static void
-completion_list_add_fields (struct symbol *sym, const char *sym_text,
- int sym_text_len, const char *text,
- const char *word)
+completion_list_add_fields (completion_tracker &tracker,
+ struct symbol *sym,
+ const char *sym_text, int sym_text_len,
+ const char *text, const char *word)
{
if (SYMBOL_CLASS (sym) == LOC_TYPEDEF)
{
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_name (TYPE_FIELD_NAME (t, j),
+ completion_list_add_name (tracker, TYPE_FIELD_NAME (t, j),
sym_text, sym_text_len, text, word);
}
}
static void
add_symtab_completions (struct compunit_symtab *cust,
+ completion_tracker &tracker,
const char *sym_text, int sym_text_len,
const char *text, const char *word,
enum type_code code)
if (code == TYPE_CODE_UNDEF
|| (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
&& TYPE_CODE (SYMBOL_TYPE (sym)) == code))
- COMPLETION_LIST_ADD_SYMBOL (sym,
+ completion_list_add_symbol (tracker, sym,
sym_text, sym_text_len,
text, word);
}
}
}
-static void
-default_make_symbol_completion_list_break_on_1 (const char *text,
- const char *word,
- const char *break_on,
- enum type_code code)
+void
+default_collect_symbol_completion_matches_break_on
+ (completion_tracker &tracker,
+ complete_symbol_mode mode,
+ const char *text, const char *word,
+ const char *break_on, enum type_code code)
{
/* Problem: All of the symbols have to be copied because readline
frees them. I'm not going to worry about this; hopefully there
const char *sym_text;
/* Length of sym_text. */
int sym_text_len;
- struct cleanup *cleanups;
/* Now look for the symbol we are supposed to complete on. */
+ if (mode == complete_symbol_mode::LINESPEC)
+ sym_text = text;
+ else
{
const char *p;
char quote_found;
}
gdb_assert (sym_text[sym_text_len] == '\0' || sym_text[sym_text_len] == '(');
- completion_tracker = new_completion_tracker ();
- cleanups = make_cleanup_free_completion_tracker (&completion_tracker);
-
/* At this point scan through the misc symbol vectors and add each
symbol you find to the list. Eventually we want to ignore
anything that isn't a text symbol (everything else will be
ALL_MSYMBOLS (objfile, msymbol)
{
QUIT;
- MCOMPLETION_LIST_ADD_SYMBOL (msymbol, sym_text, sym_text_len, text,
- word);
- completion_list_objc_symbol (msymbol, sym_text, sym_text_len, text,
- word);
+ completion_list_add_msymbol (tracker,
+ msymbol, sym_text, sym_text_len,
+ text, word);
+
+ completion_list_objc_symbol (tracker,
+ msymbol, sym_text, sym_text_len,
+ text, word);
}
}
/* Add completions for all currently loaded symbol tables. */
ALL_COMPUNITS (objfile, cust)
- add_symtab_completions (cust, sym_text, sym_text_len, text, word,
- code);
+ add_symtab_completions (cust, tracker,
+ sym_text, sym_text_len, text, word, code);
/* Look through the partial symtabs for all symbols which begin by
matching SYM_TEXT. Expand all CUs that you find to the list. */
[&] (compunit_symtab *symtab) /* expansion notify */
{
add_symtab_completions (symtab,
+ tracker,
sym_text, sym_text_len,
text, word, code);
},
{
if (code == TYPE_CODE_UNDEF)
{
- COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text,
+ completion_list_add_symbol (tracker, sym,
+ sym_text, sym_text_len, text,
word);
- completion_list_add_fields (sym, sym_text, sym_text_len, text,
+ completion_list_add_fields (tracker, sym,
+ sym_text, sym_text_len, text,
word);
}
else if (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN
&& TYPE_CODE (SYMBOL_TYPE (sym)) == code)
- COMPLETION_LIST_ADD_SYMBOL (sym, sym_text, sym_text_len, text,
+ completion_list_add_symbol (tracker, sym,
+ sym_text, sym_text_len, text,
word);
}
{
if (surrounding_static_block != NULL)
ALL_BLOCK_SYMBOLS (surrounding_static_block, iter, sym)
- completion_list_add_fields (sym, sym_text, sym_text_len, text, word);
+ completion_list_add_fields (tracker, sym,
+ sym_text, sym_text_len, text, word);
if (surrounding_global_block != NULL)
ALL_BLOCK_SYMBOLS (surrounding_global_block, iter, sym)
- completion_list_add_fields (sym, sym_text, sym_text_len, text, word);
+ completion_list_add_fields (tracker, sym,
+ sym_text, sym_text_len, text, word);
}
/* Skip macros if we are completing a struct tag -- arguable but
macro_source_file *,
int)
{
- completion_list_add_name (macro_name,
+ completion_list_add_name (tracker, macro_name,
sym_text, sym_text_len,
text, word);
};
/* User-defined macros are always visible. */
macro_for_each (macro_user_macros, add_macro_name);
}
-
- do_cleanups (cleanups);
-}
-
-VEC (char_ptr) *
-default_make_symbol_completion_list_break_on (const char *text,
- const char *word,
- const char *break_on,
- enum type_code code)
-{
- struct cleanup *back_to;
-
- return_val = NULL;
- back_to = make_cleanup (do_free_completion_list, &return_val);
-
- TRY
- {
- default_make_symbol_completion_list_break_on_1 (text, word,
- break_on, code);
- }
- CATCH (except, RETURN_MASK_ERROR)
- {
- if (except.error != MAX_COMPLETIONS_REACHED_ERROR)
- throw_exception (except);
- }
- END_CATCH
-
- discard_cleanups (back_to);
- return return_val;
}
-VEC (char_ptr) *
-default_make_symbol_completion_list (const char *text, const char *word,
- enum type_code code)
+void
+default_collect_symbol_completion_matches (completion_tracker &tracker,
+ complete_symbol_mode mode,
+ const char *text, const char *word,
+ enum type_code code)
{
- return default_make_symbol_completion_list_break_on (text, word, "", code);
+ return default_collect_symbol_completion_matches_break_on (tracker, mode,
+ text, word, "",
+ code);
}
-/* Return a vector of all symbols (regardless of class) which begin by
- matching TEXT. If the answer is no symbols, then the return value
- is NULL. */
+/* Collect all symbols (regardless of class) which begin by matching
+ TEXT. */
-VEC (char_ptr) *
-make_symbol_completion_list (const char *text, const char *word)
+void
+collect_symbol_completion_matches (completion_tracker &tracker,
+ complete_symbol_mode mode,
+ const char *text, const char *word)
{
- return current_language->la_make_symbol_completion_list (text, word,
- TYPE_CODE_UNDEF);
+ current_language->la_collect_symbol_completion_matches (tracker, mode,
+ text, word,
+ TYPE_CODE_UNDEF);
}
-/* Like make_symbol_completion_list, but only return STRUCT_DOMAIN
- symbols whose type code is CODE. */
+/* Like collect_symbol_completion_matches, but only collect
+ STRUCT_DOMAIN symbols whose type code is CODE. */
-VEC (char_ptr) *
-make_symbol_completion_type (const char *text, const char *word,
- enum type_code code)
+void
+collect_symbol_completion_matches_type (completion_tracker &tracker,
+ const char *text, const char *word,
+ enum type_code code)
{
+ complete_symbol_mode mode = complete_symbol_mode::EXPRESSION;
+
gdb_assert (code == TYPE_CODE_UNION
|| code == TYPE_CODE_STRUCT
|| code == TYPE_CODE_ENUM);
- return current_language->la_make_symbol_completion_list (text, word, code);
+ current_language->la_collect_symbol_completion_matches (tracker, mode,
+ text, word, code);
}
-/* Like make_symbol_completion_list, but suitable for use as a
- completion function. */
+/* Like collect_symbol_completion_matches, but collects a list of
+ symbols defined in all source files named SRCFILE. */
-VEC (char_ptr) *
-make_symbol_completion_list_fn (struct cmd_list_element *ignore,
- const char *text, const char *word)
-{
- return make_symbol_completion_list (text, word);
-}
-
-/* Like make_symbol_completion_list, but returns a list of symbols
- defined in a source file FILE. */
-
-static VEC (char_ptr) *
-make_file_symbol_completion_list_1 (const char *text, const char *word,
- const char *srcfile)
+void
+collect_file_symbol_completion_matches (completion_tracker &tracker,
+ complete_symbol_mode mode,
+ const char *text, const char *word,
+ const char *srcfile)
{
- struct symtab *s;
/* The symbol we are completing on. Points in same buffer as text. */
const char *sym_text;
/* Length of sym_text. */
/* Now look for the symbol we are supposed to complete on.
FIXME: This should be language-specific. */
+ if (mode == complete_symbol_mode::LINESPEC)
+ sym_text = text;
+ else
{
const char *p;
char quote_found;
/* A double-quoted string is never a symbol, nor does it make sense
to complete it any other way. */
{
- return NULL;
+ return;
}
else
{
sym_text_len = strlen (sym_text);
- /* Find the symtab for SRCFILE (this loads it if it was not yet read
- in). */
- s = lookup_symtab (srcfile);
- if (s == NULL)
+ /* Go through symtabs for SRCFILE and check the externs and statics
+ for symbols which match. */
+ iterate_over_symtabs (srcfile, [&] (symtab *s)
{
- /* Maybe they typed the file with leading directories, while the
- symbol tables record only its basename. */
- const char *tail = lbasename (srcfile);
-
- if (tail > srcfile)
- s = lookup_symtab (tail);
- }
-
- /* If we have no symtab for that file, return an empty list. */
- if (s == NULL)
- return (return_val);
-
- /* Go through this symtab and check the externs and statics for
- symbols which match. */
- add_symtab_completions (SYMTAB_COMPUNIT (s),
- sym_text, sym_text_len,
- text, word, TYPE_CODE_UNDEF);
-
- return (return_val);
-}
-
-/* Wrapper around make_file_symbol_completion_list_1
- to handle MAX_COMPLETIONS_REACHED_ERROR. */
-
-VEC (char_ptr) *
-make_file_symbol_completion_list (const char *text, const char *word,
- const char *srcfile)
-{
- struct cleanup *back_to, *cleanups;
-
- completion_tracker = new_completion_tracker ();
- cleanups = make_cleanup_free_completion_tracker (&completion_tracker);
- return_val = NULL;
- back_to = make_cleanup (do_free_completion_list, &return_val);
-
- TRY
- {
- make_file_symbol_completion_list_1 (text, word, srcfile);
- }
- CATCH (except, RETURN_MASK_ERROR)
- {
- if (except.error != MAX_COMPLETIONS_REACHED_ERROR)
- throw_exception (except);
- }
- END_CATCH
-
- discard_cleanups (back_to);
- do_cleanups (cleanups);
- return return_val;
+ add_symtab_completions (SYMTAB_COMPUNIT (s),
+ tracker,
+ sym_text, sym_text_len,
+ text, word, TYPE_CODE_UNDEF);
+ return false;
+ });
}
/* A helper function for make_source_files_completion_list. It adds
static void
add_filename_to_list (const char *fname, const char *text, const char *word,
- VEC (char_ptr) **list)
+ completion_list *list)
{
char *newobj;
size_t fnlen = strlen (fname);
newobj[text - word] = '\0';
strcat (newobj, fname);
}
- VEC_safe_push (char_ptr, *list, newobj);
+ list->emplace_back (newobj);
}
static int
const char *text;
const char *word;
int text_len;
- VEC (char_ptr) **list;
+ completion_list *list;
};
/* A callback for map_partial_symbol_filenames. */
if (not_interesting_fname (filename))
return;
- if (!filename_seen (data->filename_seen_cache, filename, 1)
+ if (!data->filename_seen_cache->seen (filename)
&& filename_ncmp (filename, data->text, data->text_len) == 0)
{
/* This file matches for a completion; add it to the
const char *base_name = lbasename (filename);
if (base_name != filename
- && !filename_seen (data->filename_seen_cache, base_name, 1)
+ && !data->filename_seen_cache->seen (base_name)
&& filename_ncmp (base_name, data->text, data->text_len) == 0)
add_filename_to_list (base_name, data->text, data->word, data->list);
}
}
-/* Return a vector of all source files whose names begin with matching
+/* Return a list of all source files whose names begin with matching
TEXT. The file names are looked up in the symbol tables of this
- program. If the answer is no matchess, then the return value is
- NULL. */
+ program. */
-VEC (char_ptr) *
+completion_list
make_source_files_completion_list (const char *text, const char *word)
{
struct compunit_symtab *cu;
struct symtab *s;
struct objfile *objfile;
size_t text_len = strlen (text);
- VEC (char_ptr) *list = NULL;
+ completion_list list;
const char *base_name;
struct add_partial_filename_data datum;
- struct filename_seen_cache *filename_seen_cache;
- struct cleanup *back_to, *cache_cleanup;
if (!have_full_symbols () && !have_partial_symbols ())
return list;
- back_to = make_cleanup (do_free_completion_list, &list);
-
- filename_seen_cache = create_filename_seen_cache ();
- cache_cleanup = make_cleanup (delete_filename_seen_cache,
- filename_seen_cache);
+ filename_seen_cache filenames_seen;
ALL_FILETABS (objfile, cu, s)
{
if (not_interesting_fname (s->filename))
continue;
- if (!filename_seen (filename_seen_cache, s->filename, 1)
+ if (!filenames_seen.seen (s->filename)
&& filename_ncmp (s->filename, text, text_len) == 0)
{
/* This file matches for a completion; add it to the current
command do when they parse file names. */
base_name = lbasename (s->filename);
if (base_name != s->filename
- && !filename_seen (filename_seen_cache, base_name, 1)
+ && !filenames_seen.seen (base_name)
&& filename_ncmp (base_name, text, text_len) == 0)
add_filename_to_list (base_name, text, word, &list);
}
}
- datum.filename_seen_cache = filename_seen_cache;
+ datum.filename_seen_cache = &filenames_seen;
datum.text = text;
datum.word = word;
datum.text_len = text_len;
map_symbol_filenames (maybe_add_partial_symtab_filename, &datum,
0 /*need_fullname*/);
- do_cleanups (cache_cleanup);
- discard_cleanups (back_to);
-
return list;
}
\f
symbol_cache_key
= register_program_space_data_with_cleanup (NULL, symbol_cache_cleanup);
- add_info ("variables", variables_info, _("\
+ add_info ("variables", info_variables_command, _("\
All global and static variable names, or those matching REGEXP."));
if (dbx_commands)
- add_com ("whereis", class_info, variables_info, _("\
+ add_com ("whereis", class_info, info_variables_command, _("\
All global and static variable names, or those matching REGEXP."));
- add_info ("functions", functions_info,
+ add_info ("functions", info_functions_command,
_("All function names, or those matching REGEXP."));
/* FIXME: This command has at least the following problems:
print "struct foo *".
I also think "ptype" or "whatis" is more likely to be useful (but if
there is much disagreement "info types" can be fixed). */
- add_info ("types", types_info,
+ add_info ("types", info_types_command,
_("All type names, or those matching REGEXP."));
- add_info ("sources", sources_info,
+ add_info ("sources", info_sources_command,
_("Source files in the program."));
add_com ("rbreak", class_breakpoint, rbreak_command,
projects / deliverable / binutils-gdb.git / blobdiff