/* Line completion stuff for GDB, the GNU debugger.
- Copyright (C) 2000-2019 Free Software Foundation, Inc.
+ Copyright (C) 2000-2022 Free Software Foundation, Inc.
This file is part of GDB.
#include "expression.h"
#include "filenames.h" /* For DOSish file names. */
#include "language.h"
-#include "common/gdb_signals.h"
+#include "gdbsupport/gdb_signals.h"
#include "target.h"
#include "reggroups.h"
#include "user-regs.h"
#include "completer.h"
+/* See completer.h. */
+
+class completion_tracker::completion_hash_entry
+{
+public:
+ /* Constructor. */
+ completion_hash_entry (gdb::unique_xmalloc_ptr<char> name,
+ gdb::unique_xmalloc_ptr<char> lcd)
+ : m_name (std::move (name)),
+ m_lcd (std::move (lcd))
+ {
+ /* Nothing. */
+ }
+
+ /* Returns a pointer to the lowest common denominator string. This
+ string will only be valid while this hash entry is still valid as the
+ string continues to be owned by this hash entry and will be released
+ when this entry is deleted. */
+ char *get_lcd () const
+ {
+ return m_lcd.get ();
+ }
+
+ /* Get, and release the name field from this hash entry. This can only
+ be called once, after which the name field is no longer valid. This
+ should be used to pass ownership of the name to someone else. */
+ char *release_name ()
+ {
+ return m_name.release ();
+ }
+
+ /* Return true of the name in this hash entry is STR. */
+ bool is_name_eq (const char *str) const
+ {
+ return strcmp (m_name.get (), str) == 0;
+ }
+
+ /* Return the hash value based on the name of the entry. */
+ hashval_t hash_name () const
+ {
+ return htab_hash_string (m_name.get ());
+ }
+
+private:
+
+ /* The symbol name stored in this hash entry. */
+ gdb::unique_xmalloc_ptr<char> m_name;
+
+ /* The lowest common denominator string computed for this hash entry. */
+ gdb::unique_xmalloc_ptr<char> m_lcd;
+};
+
/* Misc state that needs to be tracked across several different
readline completer entry point calls, all related to a single
completion invocation. */
but it does affect how much stuff M-? lists.
(2) If one of the matches contains a word break character, readline
will quote it. That's why we switch between
- current_language->la_word_break_characters() and
+ current_language->word_break_characters () and
gdb_completer_command_word_break_characters. I'm not sure when
we need this behavior (perhaps for funky characters in C++
symbols?). */
/* Variables which are necessary for fancy command line editing. */
-/* When completing on command names, we remove '-' from the list of
+/* When completing on command names, we remove '-' and '.' from the list of
word break characters, since we use it in command names. If the
readline library sees one in any of the current completion strings,
it thinks that the string needs to be quoted and automatically
supplies a leading quote. */
static const char gdb_completer_command_word_break_characters[] =
-" \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,";
+" \t\n!@#$%^&*()+=|~`}{[]\"';:?/><,";
/* When completing on file names, we remove from the list of word
break characters any characters that are commonly used in file
will loop indefinitely. */
subsequent_name = 1;
/* Like emacs, don't complete on old versions. Especially
- useful in the "source" command. */
+ useful in the "source" command. */
const char *p = p_rl.get ();
if (p[strlen (p) - 1] == '~')
continue;
(gdb_completer_file_name_break_characters);
}
-/* Possible values for the found_quote flags word used by the completion
- functions. It says what kind of (shell-like) quoting we found anywhere
- in the line. */
-#define RL_QF_SINGLE_QUOTE 0x01
-#define RL_QF_DOUBLE_QUOTE 0x02
-#define RL_QF_BACKSLASH 0x04
-#define RL_QF_OTHER_QUOTE 0x08
-
/* Find the bounds of the current word for completion purposes, and
return a pointer to the end of the word. This mimics (and is a
modified version of) readline's _rl_find_completion_word internal
int *qc, int *dp,
const char *line_buffer)
{
- int scan, end, found_quote, delimiter, pass_next, isbrk;
+ int scan, end, delimiter, pass_next, isbrk;
char quote_char;
const char *brkchars;
int point = strlen (line_buffer);
}
end = point;
- found_quote = delimiter = 0;
+ delimiter = 0;
quote_char = '\0';
brkchars = info->word_break_characters;
/* We have a list of characters which can be used in pairs to
quote substrings for the completer. Try to find the start of
an unclosed quoted substring. */
- /* FOUND_QUOTE is set so we know what kind of quotes we
- found. */
for (scan = pass_next = 0;
scan < end;
scan++)
if (quote_char != '\'' && line_buffer[scan] == '\\')
{
pass_next = 1;
- found_quote |= RL_QF_BACKSLASH;
continue;
}
/* Found start of a quoted substring. */
quote_char = line_buffer[scan];
point = scan + 1;
- /* Shell-like quoting conventions. */
- if (quote_char == '\'')
- found_quote |= RL_QF_SINGLE_QUOTE;
- else if (quote_char == '"')
- found_quote |= RL_QF_DOUBLE_QUOTE;
- else
- found_quote |= RL_QF_OTHER_QUOTE;
}
}
}
return line_buffer + point;
}
-/* See completer.h. */
+/* Find the completion word point for TEXT, emulating the algorithm
+ readline uses to find the word point, using WORD_BREAK_CHARACTERS
+ as word break characters. */
-const char *
-advance_to_expression_complete_word_point (completion_tracker &tracker,
- const char *text)
+static const char *
+advance_to_completion_word (completion_tracker &tracker,
+ const char *word_break_characters,
+ const char *text)
{
gdb_rl_completion_word_info info;
- info.word_break_characters
- = current_language->la_word_break_characters ();
+ info.word_break_characters = word_break_characters;
info.quote_characters = gdb_completer_quote_characters;
info.basic_quote_characters = rl_basic_quote_characters;
/* See completer.h. */
+const char *
+advance_to_expression_complete_word_point (completion_tracker &tracker,
+ const char *text)
+{
+ const char *brk_chars = current_language->word_break_characters ();
+ return advance_to_completion_word (tracker, brk_chars, text);
+}
+
+/* See completer.h. */
+
+const char *
+advance_to_filename_complete_word_point (completion_tracker &tracker,
+ const char *text)
+{
+ const char *brk_chars = gdb_completer_file_name_break_characters;
+ return advance_to_completion_word (tracker, brk_chars, text);
+}
+
+/* See completer.h. */
+
bool
completion_tracker::completes_to_completion_word (const char *word)
{
+ recompute_lowest_common_denominator ();
if (m_lowest_common_denominator_unique)
{
const char *lcd = m_lowest_common_denominator;
return false;
}
+/* See completer.h. */
+
+void
+complete_nested_command_line (completion_tracker &tracker, const char *text)
+{
+ /* Must be called from a custom-word-point completer. */
+ gdb_assert (tracker.use_custom_word_point ());
+
+ /* Disable the custom word point temporarily, because we want to
+ probe whether the command we're completing itself uses a custom
+ word point. */
+ tracker.set_use_custom_word_point (false);
+ size_t save_custom_word_point = tracker.custom_word_point ();
+
+ int quote_char = '\0';
+ const char *word = completion_find_completion_word (tracker, text,
+ "e_char);
+
+ if (tracker.use_custom_word_point ())
+ {
+ /* The command we're completing uses a custom word point, so the
+ tracker already contains the matches. We're done. */
+ return;
+ }
+
+ /* Restore the custom word point settings. */
+ tracker.set_custom_word_point (save_custom_word_point);
+ tracker.set_use_custom_word_point (true);
+
+ /* Run the handle_completions completer phase. */
+ complete_line (tracker, word, text, strlen (text));
+}
+
/* Complete on linespecs, which might be of two possible forms:
file:line
colon = p;
symbol_start = p + 1;
}
- else if (strchr (current_language->la_word_break_characters(), *p))
+ else if (strchr (current_language->word_break_characters (), *p))
symbol_start = p + 1;
}
int keyword = skip_keyword (tracker, explicit_options, &text);
if (keyword == -1)
- complete_on_enum (tracker, explicit_options, text, text);
+ {
+ complete_on_enum (tracker, explicit_options, text, text);
+ /* There are keywords that start with "-". Include them, too. */
+ complete_on_enum (tracker, linespec_keywords, text, text);
+ }
else
{
/* Completing on value. */
else if (quoted_arg_end[1] == ' ')
{
/* We're maybe past the explicit location argument.
- Skip the argument without interpretion, assuming the
+ Skip the argument without interpretation, assuming the
user may want to create pending breakpoint. Offer
the keyword and explicit location options as possible
completions. */
const char *type_name = NULL;
type = check_typedef (type);
- for (i = 0; i < TYPE_NFIELDS (type); ++i)
+ for (i = 0; i < type->num_fields (); ++i)
{
if (i < TYPE_N_BASECLASSES (type))
add_struct_fields (TYPE_BASECLASS (type, i),
fieldname, namelen))
output.emplace_back (xstrdup (TYPE_FIELD_NAME (type, i)));
}
- else if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_UNION)
+ else if (type->field (i).type ()->code () == TYPE_CODE_UNION)
{
/* Recurse into anonymous unions. */
- add_struct_fields (TYPE_FIELD_TYPE (type, i),
+ add_struct_fields (type->field (i).type (),
output, fieldname, namelen);
}
}
{
if (!computed_type_name)
{
- type_name = TYPE_NAME (type);
+ type_name = type->name ();
computed_type_name = 1;
}
/* Omit constructors from the completion list. */
for (;;)
{
type = check_typedef (type);
- if (TYPE_CODE (type) != TYPE_CODE_PTR && !TYPE_IS_REFERENCE (type))
+ if (type->code () != TYPE_CODE_PTR && !TYPE_IS_REFERENCE (type))
break;
type = TYPE_TARGET_TYPE (type);
}
- if (TYPE_CODE (type) == TYPE_CODE_UNION
- || TYPE_CODE (type) == TYPE_CODE_STRUCT)
+ if (type->code () == TYPE_CODE_UNION
+ || type->code () == TYPE_CODE_STRUCT)
{
completion_list result;
rl_completer_word_break_characters = (char *) break_chars;
}
-/* See definition in completer.h. */
-
-void
-set_gdb_completion_word_break_characters (completer_ftype *fn)
-{
- const char *break_chars;
-
- /* So far we are only interested in differentiating filename
- completers from everything else. */
- if (fn == filename_completer)
- break_chars = gdb_completer_file_name_break_characters;
- else
- break_chars = gdb_completer_command_word_break_characters;
-
- set_rl_completer_word_break_characters (break_chars);
-}
-
/* Complete on symbols. */
void
on command strings (as opposed to strings supplied by the
individual command completer functions, which can be any string)
then we will switch to the special word break set for command
- strings, which leaves out the '-' character used in some
+ strings, which leaves out the '-' and '.' character used in some
commands. */
set_rl_completer_word_break_characters
- (current_language->la_word_break_characters());
+ (current_language->word_break_characters ());
/* Decide whether to complete on a list of gdb commands or on
symbols. */
result_list = 0;
}
else
- {
- c = lookup_cmd_1 (&p, cmdlist, &result_list, ignore_help_classes);
- }
+ c = lookup_cmd_1 (&p, cmdlist, &result_list, NULL, ignore_help_classes,
+ true);
/* Move p up to the next interesting thing. */
while (*p == ' ' || *p == '\t')
/* lookup_cmd_1 advances p up to the first ambiguous thing, but
doesn't advance over that thing itself. Do so now. */
q = p;
- while (*q && (isalnum (*q) || *q == '-' || *q == '_'))
+ while (valid_cmd_char_p (*q))
++q;
if (q != tmp_command + point)
{
if (result_list)
{
if (reason != handle_brkchars)
- complete_on_cmdlist (*result_list->prefixlist, tracker, p,
+ complete_on_cmdlist (*result_list->subcommands, tracker, p,
word, ignore_help_classes);
}
else
{
/* The command is followed by whitespace; we need to
complete on whatever comes after command. */
- if (c->prefixlist)
+ if (c->is_prefix ())
{
/* It is a prefix command; what comes after it is
a subcommand (e.g. "info "). */
if (reason != handle_brkchars)
- complete_on_cmdlist (*c->prefixlist, tracker, p, word,
+ complete_on_cmdlist (*c->subcommands, tracker, p, word,
ignore_help_classes);
/* Ensure that readline does the right thing
q = p;
while (q > tmp_command)
{
- if (isalnum (q[-1]) || q[-1] == '-' || q[-1] == '_')
+ if (valid_cmd_char_p (q[-1]))
--q;
else
break;
{
/* There is non-whitespace beyond the command. */
- if (c->prefixlist && !c->allow_unknown)
+ if (c->is_prefix () && !c->allow_unknown)
{
/* It is an unrecognized subcommand of a prefix command,
e.g. "info adsfkdj". */
completion_tracker::completion_tracker ()
{
- m_entries_hash = htab_create_alloc (INITIAL_COMPLETION_HTAB_SIZE,
- htab_hash_string, streq_hash,
- NULL, xcalloc, xfree);
+ discard_completions ();
}
/* See completer.h. */
m_lowest_common_denominator = NULL;
m_lowest_common_denominator_unique = false;
+ m_lowest_common_denominator_valid = false;
+
+ m_entries_hash.reset (nullptr);
- m_entries_vec.clear ();
+ /* A callback used by the hash table to compare new entries with existing
+ entries. We can't use the standard htab_eq_string function here as the
+ key to our hash is just a single string, while the values we store in
+ the hash are a struct containing multiple strings. */
+ static auto entry_eq_func
+ = [] (const void *first, const void *second) -> int
+ {
+ /* The FIRST argument is the entry already in the hash table, and
+ the SECOND argument is the new item being inserted. */
+ const completion_hash_entry *entry
+ = (const completion_hash_entry *) first;
+ const char *name_str = (const char *) second;
+
+ return entry->is_name_eq (name_str);
+ };
+
+ /* Callback used by the hash table to compute the hash value for an
+ existing entry. This is needed when expanding the hash table. */
+ static auto entry_hash_func
+ = [] (const void *arg) -> hashval_t
+ {
+ const completion_hash_entry *entry
+ = (const completion_hash_entry *) arg;
+ return entry->hash_name ();
+ };
- htab_delete (m_entries_hash);
- m_entries_hash = htab_create_alloc (INITIAL_COMPLETION_HTAB_SIZE,
- htab_hash_string, streq_hash,
- NULL, xcalloc, xfree);
+ m_entries_hash.reset
+ (htab_create_alloc (INITIAL_COMPLETION_HTAB_SIZE,
+ entry_hash_func, entry_eq_func,
+ htab_delete_entry<completion_hash_entry>,
+ xcalloc, xfree));
}
/* See completer.h. */
completion_tracker::~completion_tracker ()
{
xfree (m_lowest_common_denominator);
- htab_delete (m_entries_hash);
}
/* See completer.h. */
if (max_completions == 0)
return false;
- if (htab_elements (m_entries_hash) >= max_completions)
+ if (htab_elements (m_entries_hash.get ()) >= max_completions)
return false;
- slot = htab_find_slot (m_entries_hash, name.get (), INSERT);
+ hashval_t hash = htab_hash_string (name.get ());
+ slot = htab_find_slot_with_hash (m_entries_hash.get (), name.get (),
+ hash, INSERT);
if (*slot == HTAB_EMPTY_ENTRY)
{
const char *match_for_lcd_str = NULL;
gdb::unique_xmalloc_ptr<char> lcd
= make_completion_match_str (match_for_lcd_str, text, word);
- recompute_lowest_common_denominator (std::move (lcd));
+ size_t lcd_len = strlen (lcd.get ());
+ *slot = new completion_hash_entry (std::move (name), std::move (lcd));
- *slot = name.get ();
- m_entries_vec.push_back (std::move (name));
+ m_lowest_common_denominator_valid = false;
+ m_lowest_common_denominator_max_length
+ = std::max (m_lowest_common_denominator_max_length, lcd_len);
}
return true;
add_completion (std::move (candidate));
}
+/* See completer.h. */
+
+void
+completion_tracker::remove_completion (const char *name)
+{
+ hashval_t hash = htab_hash_string (name);
+ if (htab_find_slot_with_hash (m_entries_hash.get (), name, hash, NO_INSERT)
+ != NULL)
+ {
+ htab_remove_elt_with_hash (m_entries_hash.get (), name, hash);
+ m_lowest_common_denominator_valid = false;
+ }
+}
+
/* Helper for the make_completion_match_str overloads. Returns NULL
as an indication that we want MATCH_NAME exactly. It is up to the
caller to xstrdup that string if desired. */
const char *text, const char *word)
{
set_rl_completer_word_break_characters
- (current_language->la_word_break_characters ());
+ (current_language->word_break_characters ());
}
/* See definition in completer.h. */
{
gdb_assert (tracker.custom_word_point () > 0);
rl_point = tracker.custom_word_point () - 1;
+
+ gdb_assert (rl_point >= 0 && rl_point < strlen (rl_line_buffer));
+
gdb_custom_word_point_brkchars[0] = rl_line_buffer[rl_point];
rl_completer_word_break_characters = gdb_custom_word_point_brkchars;
rl_completer_quote_characters = NULL;
/* See completer.h. */
void
-completion_tracker::recompute_lowest_common_denominator
- (gdb::unique_xmalloc_ptr<char> &&new_match_up)
+completion_tracker::recompute_lcd_visitor (completion_hash_entry *entry)
{
- if (m_lowest_common_denominator == NULL)
+ if (!m_lowest_common_denominator_valid)
{
- /* We don't have a lowest common denominator yet, so simply take
- the whole NEW_MATCH_UP as being it. */
- m_lowest_common_denominator = new_match_up.release ();
+ /* This is the first lowest common denominator that we are
+ considering, just copy it in. */
+ strcpy (m_lowest_common_denominator, entry->get_lcd ());
m_lowest_common_denominator_unique = true;
+ m_lowest_common_denominator_valid = true;
}
else
{
- /* Find the common denominator between the currently-known
- lowest common denominator and NEW_MATCH_UP. That becomes the
- new lowest common denominator. */
+ /* Find the common denominator between the currently-known lowest
+ common denominator and NEW_MATCH_UP. That becomes the new lowest
+ common denominator. */
size_t i;
- const char *new_match = new_match_up.get ();
+ const char *new_match = entry->get_lcd ();
for (i = 0;
(new_match[i] != '\0'
/* See completer.h. */
+void
+completion_tracker::recompute_lowest_common_denominator ()
+{
+ /* We've already done this. */
+ if (m_lowest_common_denominator_valid)
+ return;
+
+ /* Resize the storage to ensure we have enough space, the plus one gives
+ us space for the trailing null terminator we will include. */
+ m_lowest_common_denominator
+ = (char *) xrealloc (m_lowest_common_denominator,
+ m_lowest_common_denominator_max_length + 1);
+
+ /* Callback used to visit each entry in the m_entries_hash. */
+ auto visitor_func
+ = [] (void **slot, void *info) -> int
+ {
+ completion_tracker *obj = (completion_tracker *) info;
+ completion_hash_entry *entry = (completion_hash_entry *) *slot;
+ obj->recompute_lcd_visitor (entry);
+ return 1;
+ };
+
+ htab_traverse (m_entries_hash.get (), visitor_func, this);
+ m_lowest_common_denominator_valid = true;
+}
+
+/* See completer.h. */
+
void
completion_tracker::advance_custom_word_point_by (int len)
{
completion_tracker::build_completion_result (const char *text,
int start, int end)
{
- completion_list &list = m_entries_vec; /* The completions. */
+ size_t element_count = htab_elements (m_entries_hash.get ());
- if (list.empty ())
+ if (element_count == 0)
return {};
/* +1 for the LCD, and +1 for NULL termination. */
- char **match_list = XNEWVEC (char *, 1 + list.size () + 1);
+ char **match_list = XNEWVEC (char *, 1 + element_count + 1);
/* Build replacement word, based on the LCD. */
+ recompute_lowest_common_denominator ();
match_list[0]
= expand_preserving_ws (text, end - start,
m_lowest_common_denominator);
/* If the tracker wants to, or we already have a space at the
end of the match, tell readline to skip appending
another. */
+ char *match = match_list[0];
bool completion_suppress_append
= (suppress_append_ws ()
- || match_list[0][strlen (match_list[0]) - 1] == ' ');
+ || (match[0] != '\0'
+ && match[strlen (match) - 1] == ' '));
return completion_result (match_list, 1, completion_suppress_append);
}
else
{
- int ix;
+ /* State object used while building the completion list. */
+ struct list_builder
+ {
+ list_builder (char **ml)
+ : match_list (ml),
+ index (1)
+ { /* Nothing. */ }
- for (ix = 0; ix < list.size (); ++ix)
- match_list[ix + 1] = list[ix].release ();
- match_list[ix + 1] = NULL;
+ /* The list we are filling. */
+ char **match_list;
- return completion_result (match_list, list.size (), false);
+ /* The next index in the list to write to. */
+ int index;
+ };
+ list_builder builder (match_list);
+
+ /* Visit each entry in m_entries_hash and add it to the completion
+ list, updating the builder state object. */
+ auto func
+ = [] (void **slot, void *info) -> int
+ {
+ completion_hash_entry *entry = (completion_hash_entry *) *slot;
+ list_builder *state = (list_builder *) info;
+
+ state->match_list[state->index] = entry->release_name ();
+ state->index++;
+ return 1;
+ };
+
+ /* Build the completion list and add a null at the end. */
+ htab_traverse_noresize (m_entries_hash.get (), func, &builder);
+ match_list[builder.index] = NULL;
+
+ return completion_result (match_list, builder.index - 1, false);
}
}
/* See completer.h */
-completion_result::completion_result (completion_result &&rhs)
+completion_result::completion_result (completion_result &&rhs) noexcept
+ : match_list (rhs.match_list),
+ number_matches (rhs.number_matches)
{
- if (this == &rhs)
- return;
-
- reset_match_list ();
- match_list = rhs.match_list;
rhs.match_list = NULL;
- number_matches = rhs.number_matches;
rhs.number_matches = 0;
}
quotechars = gdb_completer_quote_characters;
if (breakchars == NULL)
- breakchars = current_language->la_word_break_characters();
+ breakchars = current_language->word_break_characters ();
for (scan = str; *scan != '\0'; scan++)
{
else if (temp[1] == '\0')
{
for (x = temp - 1; x > pathname; x--)
- if (*x == '/')
- break;
+ if (*x == '/')
+ break;
return ((*x == '/') ? x + 1 : pathname);
}
else
while (*s)
{
if (CTRL_CHAR (*s))
- {
- displayer->putch (displayer, '^');
- displayer->putch (displayer, UNCTRL (*s));
- printed_len += 2;
- s++;
+ {
+ displayer->putch (displayer, '^');
+ displayer->putch (displayer, UNCTRL (*s));
+ printed_len += 2;
+ s++;
#if defined (HANDLE_MULTIBYTE)
memset (&ps, 0, sizeof (mbstate_t));
#endif
- }
+ }
else if (*s == RUBOUT)
{
displayer->putch (displayer, '^');
}
}
+void _initialize_completer ();
void
-_initialize_completer (void)
+_initialize_completer ()
{
add_setshow_zuinteger_unlimited_cmd ("max-completions", no_class,
&max_completions, _("\
projects / deliverable / binutils-gdb.git / blobdiff