/* Line completion stuff for GDB, the GNU debugger.
- Copyright (C) 2000-2020 Free Software Foundation, Inc.
+ Copyright (C) 2000-2022 Free Software Foundation, Inc.
This file is part of GDB.
#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?). */
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;
}
}
}
advance_to_expression_complete_word_point (completion_tracker &tracker,
const char *text)
{
- const char *brk_chars = current_language->la_word_break_characters ();
+ const char *brk_chars = current_language->word_break_characters ();
return advance_to_completion_word (tracker, brk_chars, text);
}
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;
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. */
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),
output, fieldname, namelen);
- else if (TYPE_FIELD_NAME (type, i))
+ else if (type->field (i).name ())
{
- if (TYPE_FIELD_NAME (type, i)[0] != '\0')
+ if (type->field (i).name ()[0] != '\0')
{
- if (! strncmp (TYPE_FIELD_NAME (type, i),
+ if (! strncmp (type->field (i).name (),
fieldname, namelen))
- output.emplace_back (xstrdup (TYPE_FIELD_NAME (type, i)));
+ output.emplace_back (xstrdup (type->field (i).name ()));
}
- 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->is_pointer_or_reference ())
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;
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')
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
{
/* 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_vec.clear ();
+ m_entries_hash.reset (nullptr);
- htab_delete (m_entries_hash);
- m_entries_hash = htab_create_alloc (INITIAL_COMPLETION_HTAB_SIZE,
- htab_hash_string, streq_hash,
- NULL, xcalloc, xfree);
+ /* 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 ();
+ };
+
+ 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. */
/* 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. */ }
+
+ /* The list we are filling. */
+ char **match_list;
+
+ /* The next index in the list to write to. */
+ int index;
+ };
+ list_builder builder (match_list);
- for (ix = 0; ix < list.size (); ++ix)
- match_list[ix + 1] = list[ix].release ();
- match_list[ix + 1] = NULL;
+ /* 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;
- return completion_result (match_list, list.size (), false);
+ 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 / binutils-gdb.git / blobdiff