struct linespec
{
/* An explicit location describing the SaLs. */
- struct explicit_location explicit_loc;
+ struct explicit_location explicit_loc {};
- /* The list of symtabs to search to which to limit the search. May not
- be NULL. If explicit.SOURCE_FILENAME is NULL (no user-specified
- filename), FILE_SYMTABS should contain one single NULL member. This
- will cause the code to use the default symtab. */
- std::vector<symtab *> *file_symtabs;
+ /* The list of symtabs to search to which to limit the search.
+
+ If explicit.SOURCE_FILENAME is NULL (no user-specified filename),
+ FILE_SYMTABS should contain one single NULL member. This will cause the
+ code to use the default symtab. */
+ std::vector<symtab *> file_symtabs;
/* A list of matching function symbols and minimal symbols. Both lists
- may be NULL (or empty) if no matching symbols were found. */
- std::vector<block_symbol> *function_symbols;
- std::vector<bound_minimal_symbol> *minimal_symbols;
+ may be empty if no matching symbols were found. */
+ std::vector<block_symbol> function_symbols;
+ std::vector<bound_minimal_symbol> minimal_symbols;
/* A structure of matching label symbols and the corresponding
- function symbol in which the label was found. Both may be NULL
- or both must be non-NULL. */
+ function symbol in which the label was found. Both may be empty
+ or both must be non-empty. */
struct
{
- std::vector<block_symbol> *label_symbols;
- std::vector<block_symbol> *function_symbols;
+ std::vector<block_symbol> label_symbols;
+ std::vector<block_symbol> function_symbols;
} labels;
};
struct linespec_state *state;
/* A list of symtabs to which to restrict matches. */
- std::vector<symtab *> *file_symtabs;
+ const std::vector<symtab *> *file_symtabs;
/* The result being accumulated. */
struct
#define PARSER_STATE(PPTR) (&(PPTR)->state)
/* The result of the parse. */
- struct linespec result {};
+ linespec result;
#define PARSER_RESULT(PPTR) (&(PPTR)->result)
/* What the parser believes the current word point should complete
static std::vector<symtab *> symtabs_from_filename
(const char *, struct program_space *pspace);
-static std::vector<block_symbol> *find_label_symbols
- (struct linespec_state *self, std::vector<block_symbol> *function_symbols,
- std::vector<block_symbol> *label_funcs_ret, const char *name,
- bool completion_mode = false);
+static std::vector<block_symbol> find_label_symbols
+ (struct linespec_state *self,
+ const std::vector<block_symbol> &function_symbols,
+ std::vector<block_symbol> *label_funcs_ret,
+ const char *name, bool completion_mode = false);
static void find_linespec_symbols (struct linespec_state *self,
- std::vector<symtab *> *file_symtabs,
+ const std::vector<symtab *> &file_symtabs,
const char *name,
symbol_name_match_type name_match_type,
std::vector<block_symbol> *symbols,
{
gdb::unique_xmalloc_ptr<char> name;
linespec_token token;
- std::vector<block_symbol> symbols;
- std::vector<block_symbol> *labels;
- std::vector<bound_minimal_symbol> minimal_symbols;
/* Get the next token. */
token = linespec_lexer_lex_one (parser);
}
else
{
+ std::vector<block_symbol> symbols;
+ std::vector<bound_minimal_symbol> minimal_symbols;
+
/* Try looking it up as a function/method. */
find_linespec_symbols (PARSER_STATE (parser),
PARSER_RESULT (parser)->file_symtabs, name.get (),
if (!symbols.empty () || !minimal_symbols.empty ())
{
- PARSER_RESULT (parser)->function_symbols
- = new std::vector<block_symbol> (std::move (symbols));
- PARSER_RESULT (parser)->minimal_symbols
- = new std::vector<bound_minimal_symbol>
- (std::move (minimal_symbols));
+ PARSER_RESULT (parser)->function_symbols = std::move (symbols);
+ PARSER_RESULT (parser)->minimal_symbols = std::move (minimal_symbols);
PARSER_EXPLICIT (parser)->function_name = name.release ();
}
else
{
/* NAME was not a function or a method. So it must be a label
name or user specified variable like "break foo.c:$zippo". */
- labels = find_label_symbols (PARSER_STATE (parser), NULL,
- &symbols, name.get ());
- if (labels != NULL)
+ std::vector<block_symbol> labels
+ = find_label_symbols (PARSER_STATE (parser), {}, &symbols,
+ name.get ());
+
+ if (!labels.empty ())
{
- PARSER_RESULT (parser)->labels.label_symbols = labels;
+ PARSER_RESULT (parser)->labels.label_symbols = std::move (labels);
PARSER_RESULT (parser)->labels.function_symbols
- = new std::vector<block_symbol> (std::move (symbols));
+ = std::move (symbols);
PARSER_EXPLICIT (parser)->label_name = name.release ();
}
else if (token.type == LSTOKEN_STRING
}
else
{
+ std::vector<block_symbol> symbols;
+
/* Grab a copy of the label's name and look it up. */
name = copy_token_string (token);
- labels
+ std::vector<block_symbol> labels
= find_label_symbols (PARSER_STATE (parser),
PARSER_RESULT (parser)->function_symbols,
&symbols, name.get ());
- if (labels != NULL)
+ if (!labels.empty ())
{
- PARSER_RESULT (parser)->labels.label_symbols = labels;
+ PARSER_RESULT (parser)->labels.label_symbols
+ = std::move (labels);
PARSER_RESULT (parser)->labels.function_symbols
- = new std::vector<block_symbol> (std::move (symbols));
+ = std::move (symbols);
PARSER_EXPLICIT (parser)->label_name = name.release ();
}
else
if (explicit_loc->function_name == NULL)
{
/* No function was specified, so add the symbol name. */
- gdb_assert (ls->labels.function_symbols->size () == 1);
- block_symbol s = ls->labels.function_symbols->front ();
+ gdb_assert (ls->labels.function_symbols.size () == 1);
+ block_symbol s = ls->labels.function_symbols.front ();
explicit_loc->function_name = xstrdup (s.symbol->natural_name ());
}
}
set_default_source_symtab_and_line uses
select_source_symtab that calls us with such an argument. */
- if (ls->file_symtabs->size () == 1
- && ls->file_symtabs->front () == nullptr)
+ if (ls->file_symtabs.size () == 1
+ && ls->file_symtabs.front () == nullptr)
{
set_current_program_space (self->program_space);
/* Make sure we have at least a default source line. */
set_default_source_symtab_and_line ();
initialize_defaults (&self->default_symtab, &self->default_line);
- *ls->file_symtabs
+ ls->file_symtabs
= collect_symtabs_from_filename (self->default_symtab->filename,
self->search_pspace);
use_default = 1;
{
std::vector<symtab_and_line> sals;
- if (ls->labels.label_symbols != NULL)
+ if (!ls->labels.label_symbols.empty ())
{
/* We have just a bunch of functions/methods or labels. */
struct symtab_and_line sal;
- for (const auto &sym : *ls->labels.label_symbols)
+ for (const auto &sym : ls->labels.label_symbols)
{
struct program_space *pspace
= SYMTAB_PSPACE (symbol_symtab (sym.symbol));
sym.symbol->natural_name (), 0);
}
}
- else if (ls->function_symbols != NULL || ls->minimal_symbols != NULL)
+ else if (!ls->function_symbols.empty () || !ls->minimal_symbols.empty ())
{
/* We have just a bunch of functions and/or methods. */
- if (ls->function_symbols != NULL)
+ if (!ls->function_symbols.empty ())
{
/* Sort symbols so that symbols with the same program space are next
to each other. */
- std::sort (ls->function_symbols->begin (),
- ls->function_symbols->end (),
+ std::sort (ls->function_symbols.begin (),
+ ls->function_symbols.end (),
compare_symbols);
- for (const auto &sym : *ls->function_symbols)
+ for (const auto &sym : ls->function_symbols)
{
program_space *pspace
= SYMTAB_PSPACE (symbol_symtab (sym.symbol));
bool found_ifunc = false;
if (state->funfirstline
- && ls->minimal_symbols != NULL
+ && !ls->minimal_symbols.empty ()
&& SYMBOL_CLASS (sym.symbol) == LOC_BLOCK)
{
const CORE_ADDR addr
= BLOCK_ENTRY_PC (SYMBOL_BLOCK_VALUE (sym.symbol));
- for (const auto &elem : *ls->minimal_symbols)
+ for (const auto &elem : ls->minimal_symbols)
{
if (MSYMBOL_TYPE (elem.minsym) == mst_text_gnu_ifunc
|| MSYMBOL_TYPE (elem.minsym) == mst_data_gnu_ifunc)
}
}
- if (ls->minimal_symbols != NULL)
+ if (!ls->minimal_symbols.empty ())
{
/* Sort minimal symbols by program space, too */
- std::sort (ls->minimal_symbols->begin (),
- ls->minimal_symbols->end (),
+ std::sort (ls->minimal_symbols.begin (),
+ ls->minimal_symbols.end (),
compare_msymbols);
- for (const auto &elem : *ls->minimal_symbols)
+ for (const auto &elem : ls->minimal_symbols)
{
program_space *pspace = elem.objfile->pspace;
set_current_program_space (pspace);
const char *label_name,
struct line_offset line_offset)
{
- std::vector<block_symbol> symbols;
- std::vector<block_symbol> *labels;
std::vector<bound_minimal_symbol> minimal_symbols;
result->explicit_loc.func_name_match_type = fname_match_type;
{
try
{
- *result->file_symtabs
+ result->file_symtabs
= symtabs_from_filename (source_filename, self->search_pspace);
}
catch (const gdb_exception_error &except)
else
{
/* A NULL entry means to use the default symtab. */
- result->file_symtabs->push_back (nullptr);
+ result->file_symtabs.push_back (nullptr);
}
if (function_name != NULL)
{
+ std::vector<block_symbol> symbols;
+
find_linespec_symbols (self, result->file_symtabs,
function_name, fname_match_type,
&symbols, &minimal_symbols);
result->explicit_loc.source_filename);
result->explicit_loc.function_name = xstrdup (function_name);
- result->function_symbols
- = new std::vector<block_symbol> (std::move (symbols));
- result->minimal_symbols
- = new std::vector<bound_minimal_symbol> (std::move (minimal_symbols));
+ result->function_symbols = std::move (symbols);
+ result->minimal_symbols = std::move (minimal_symbols);
}
if (label_name != NULL)
{
- labels = find_label_symbols (self, result->function_symbols,
- &symbols, label_name);
+ std::vector<block_symbol> symbols;
+ std::vector<block_symbol> labels
+ = find_label_symbols (self, result->function_symbols,
+ &symbols, label_name);
- if (labels == NULL)
+ if (labels.empty ())
undefined_label_error (result->explicit_loc.function_name,
label_name);
result->explicit_loc.label_name = xstrdup (label_name);
result->labels.label_symbols = labels;
- result->labels.function_symbols
- = new std::vector<block_symbol> (std::move (symbols));
+ result->labels.function_symbols = std::move (symbols);
}
if (line_offset.sign != LINE_OFFSET_UNKNOWN)
{
/* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
if (parser->completion_tracker == NULL)
- PARSER_RESULT (parser)->file_symtabs->push_back (nullptr);
+ PARSER_RESULT (parser)->file_symtabs.push_back (nullptr);
/* User specified a convenience variable or history value. */
gdb::unique_xmalloc_ptr<char> var = copy_token_string (token);
/* Check if the input is a filename. */
try
{
- *PARSER_RESULT (parser)->file_symtabs
+ PARSER_RESULT (parser)->file_symtabs
= symtabs_from_filename (user_filename.get (),
PARSER_STATE (parser)->search_pspace);
}
else
{
/* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
- PARSER_RESULT (parser)->file_symtabs->push_back (nullptr);
+ PARSER_RESULT (parser)->file_symtabs.push_back (nullptr);
}
}
/* If the next token is not EOI, KEYWORD, or COMMA, issue an error. */
else
{
/* A NULL entry means to use GLOBAL_DEFAULT_SYMTAB. */
- PARSER_RESULT (parser)->file_symtabs->push_back (nullptr);
+ PARSER_RESULT (parser)->file_symtabs.push_back (nullptr);
}
/* Parse the rest of the linespec. */
linespec_parse_basic (parser);
if (parser->completion_tracker == NULL
- && PARSER_RESULT (parser)->function_symbols == NULL
- && PARSER_RESULT (parser)->labels.label_symbols == NULL
+ && PARSER_RESULT (parser)->function_symbols.empty ()
+ && PARSER_RESULT (parser)->labels.label_symbols.empty ()
&& PARSER_EXPLICIT (parser)->line_offset.sign == LINE_OFFSET_UNKNOWN
- && PARSER_RESULT (parser)->minimal_symbols == NULL)
+ && PARSER_RESULT (parser)->minimal_symbols.empty ())
{
/* The linespec didn't parse. Re-throw the file exception if
there was one. */
struct linespec_result *canonical)
{
lexer.current.type = LSTOKEN_CONSUMED;
- PARSER_RESULT (this)->file_symtabs = new std::vector<symtab *> ();
PARSER_EXPLICIT (this)->func_name_match_type
= symbol_name_match_type::WILD;
PARSER_EXPLICIT (this)->line_offset.sign = LINE_OFFSET_UNKNOWN;
xfree (PARSER_EXPLICIT (this)->label_name);
xfree (PARSER_EXPLICIT (this)->function_name);
- delete PARSER_RESULT (this)->file_symtabs;
- delete PARSER_RESULT (this)->function_symbols;
- delete PARSER_RESULT (this)->minimal_symbols;
- delete PARSER_RESULT (this)->labels.label_symbols;
- delete PARSER_RESULT (this)->labels.function_symbols;
-
linespec_state_destructor (PARSER_STATE (this));
}
const char *label_name)
{
std::vector<block_symbol> label_function_symbols;
- std::vector<block_symbol> *labels
+ std::vector<block_symbol> labels
= find_label_symbols (PARSER_STATE (parser),
PARSER_RESULT (parser)->function_symbols,
&label_function_symbols,
label_name, true);
- if (labels != nullptr)
+ for (const auto &label : labels)
{
- for (const auto &label : *labels)
- {
- char *match = xstrdup (label.symbol->search_name ());
- tracker.add_completion (gdb::unique_xmalloc_ptr<char> (match));
- }
- delete labels;
+ char *match = xstrdup (label.symbol->search_name ());
+ tracker.add_completion (gdb::unique_xmalloc_ptr<char> (match));
}
}
func_name, match_type,
&function_symbols, &minimal_symbols);
- PARSER_RESULT (&parser)->function_symbols
- = new std::vector<block_symbol> (std::move (function_symbols));
- PARSER_RESULT (&parser)->minimal_symbols
- = new std::vector<bound_minimal_symbol> (std::move (minimal_symbols));
+ PARSER_RESULT (&parser)->function_symbols = std::move (function_symbols);
+ PARSER_RESULT (&parser)->minimal_symbols = std::move (minimal_symbols);
complete_label (tracker, &parser, parser.completion_word);
}
saved_arg[new_argptr - arg] = '\0';
ls->explicit_loc.function_name = xstrdup (saved_arg);
- ls->function_symbols
- = new std::vector<block_symbol> (std::move (symbols));
- ls->minimal_symbols
- = new std::vector<bound_minimal_symbol> (std::move (minimal_symbols));
+ ls->function_symbols = std::move (symbols);
+ ls->minimal_symbols = std::move (minimal_symbols);
values = convert_linespec_to_sals (self, ls);
if (self->canonical)
static std::vector<block_symbol>
lookup_prefix_sym (struct linespec_state *state,
- std::vector<symtab *> *file_symtabs,
+ const std::vector<symtab *> &file_symtabs,
const char *class_name)
{
decode_compound_collector collector;
lookup_name_info lookup_name (class_name, symbol_name_match_type::FULL);
- for (const auto &elt : *file_symtabs)
+ for (const auto &elt : file_symtabs)
{
if (elt == nullptr)
{
in SYMBOLS (for debug symbols) and MINSYMS (for minimal symbols). */
static void
-find_method (struct linespec_state *self, std::vector<symtab *> *file_symtabs,
+find_method (struct linespec_state *self,
+ const std::vector<symtab *> &file_symtabs,
const char *class_name, const char *method_name,
std::vector<block_symbol> *sym_classes,
std::vector<block_symbol> *symbols,
compare_symbols);
info.state = self;
- info.file_symtabs = file_symtabs;
+ info.file_symtabs = &file_symtabs;
info.result.symbols = symbols;
info.result.minimal_symbols = minsyms;
static void
find_function_symbols (struct linespec_state *state,
- std::vector<symtab *> *file_symtabs, const char *name,
+ const std::vector<symtab *> &file_symtabs, const char *name,
symbol_name_match_type name_match_type,
std::vector<block_symbol> *symbols,
std::vector<bound_minimal_symbol> *minsyms)
info.state = state;
info.result.symbols = symbols;
info.result.minimal_symbols = minsyms;
- info.file_symtabs = file_symtabs;
+ info.file_symtabs = &file_symtabs;
/* Try NAME as an Objective-C selector. */
find_imps (name, &symbol_names);
static void
find_linespec_symbols (struct linespec_state *state,
- std::vector<symtab *> *file_symtabs,
+ const std::vector<symtab *> &file_symtabs,
const char *lookup_name,
symbol_name_match_type name_match_type,
std::vector <block_symbol> *symbols,
}
}
-/* Return all labels that match name NAME in FUNCTION_SYMBOLS or NULL
- if no matches were found.
+/* Return all labels that match name NAME in FUNCTION_SYMBOLS.
Return the actual function symbol in which the label was found in
LABEL_FUNC_RET. If COMPLETION_MODE is true, then NAME is
exactly NAME match. */
-static std::vector<block_symbol> *
+static std::vector<block_symbol>
find_label_symbols (struct linespec_state *self,
- std::vector<block_symbol> *function_symbols,
+ const std::vector<block_symbol> &function_symbols,
std::vector<block_symbol> *label_funcs_ret,
const char *name,
bool completion_mode)
struct symbol *fn_sym;
std::vector<block_symbol> result;
- if (function_symbols == NULL)
+ if (function_symbols.empty ())
{
set_current_program_space (self->program_space);
block = get_current_search_block ();
block && !BLOCK_FUNCTION (block);
block = BLOCK_SUPERBLOCK (block))
;
+
if (!block)
- return NULL;
+ return {};
+
fn_sym = BLOCK_FUNCTION (block);
find_label_symbols_in_block (block, name, fn_sym, completion_mode,
}
else
{
- for (const auto &elt : *function_symbols)
+ for (const auto &elt : function_symbols)
{
fn_sym = elt.symbol;
set_current_program_space (SYMTAB_PSPACE (symbol_symtab (fn_sym)));
}
}
- if (!result.empty ())
- return new std::vector<block_symbol> (std::move (result));
- return nullptr;
+ return result;
}
\f
std::vector<symtab_and_line> values;
- for (const auto &elt : *ls->file_symtabs)
+ for (const auto &elt : ls->file_symtabs)
{
/* The logic above should ensure this. */
gdb_assert (elt != NULL);
struct linetable_entry **best_entry)
{
std::vector<symtab_and_line> sals;
- for (const auto &elt : *ls->file_symtabs)
+ for (const auto &elt : ls->file_symtabs)
{
std::vector<CORE_ADDR> pcs;
projects / binutils-gdb.git / commitdiff