Toolchain/binutils-gdb
1
0
Fork 0
forked from Imagelibrary/binutils-gdb
Code Pull Requests Activity
Files
c6756f62e04846d68c24ee922ddb0377d4bd17f2
binutils-gdb/gdb/completer.h
Pedro Alves c6756f62e0 Rewrite/enhance explicit locations completer, parse left->right 
One of the most annoying (to me) things about GDB's completion is when
you have overloads in your program, and you want to set a breakpoint
in one of them:

 void function(int);  // set breakpoint here.
 void function(long);

 (gdb) b -f func[TAB]
 (gdb) b -f function(       # ok, gdb completed as much as possible.
 (gdb) b -f function([TAB]  # show me the overloads, please.
 <_all_ symbols in the program are shown...>

E.g., when debugging GDB, that'd be:

 (gdb) b -f function([TAB]
 (anonymous namespace)::get_global()::global  pt_insn_get_offset@plt                       scm_new_port_table_entry
 asprintf                                     pt_pkt_alloc_decoder                         scm_new_port_table_entry@plt
 asprintf@plt                                 pt_pkt_alloc_decoder@plt                     scm_out_of_range
 bt_ctf_get_char_array                        pt_pkt_sync_forward                          scm_out_of_range@plt
 bt_ctf_get_char_array@plt                    pt_pkt_sync_forward@plt                      scm_putc
 bt_ctf_get_uint64                            pwrite                                       scm_putc@plt
 bt_ctf_get_uint64@plt                        pwrite@plt                                   scm_reverse_x
 bt_ctf_iter_read_event                       PyErr_Restore                                scm_reverse_x@plt
 bt_ctf_iter_read_event@plt                   PyErr_Restore@plt                            scm_set_port_filename_x
 <snip...>

Now that's a load of completely useless completions.

The reason GDB offers those is that the completer relies on readline
figuring out the completion word point in the input line based on the
language's word break characters, which include "(".  So readline
tells the completer to complete on "", the string that is after '('.
Likewise, if you type "function(i[TAB]" to try to complete to "int",
you're out of luck.  GDB shows you all the symbols in the program that
start with "i"...  This makes sense for the expression completer, as
what you'd want to type is e.g., a global variable, say:

(gdb) print function(i[TAB]

but, it makes no sense when specifying a function name for a
breakpoint location.

To get around that limitation, users need to quote the function name,
like:

 (gdb) b -f 'function([TAB]
 function(int)      function(long)
 (gdb) b 'function(i[TAB]
 (gdb) b 'function(int)' # now completes correctly!

Note that the quoting is only necessary for completion.  Creating the
breakpoint does not require the quoting:

 (gdb) b -f function(int) [RET]
 Breakpoint 1 at ....

This patch removes this limitation.

(
Actually, it's a necessary patch, though not sufficient.  That'll
start working correctly by the end of the series.  With this patch, if try it,
you'll see:

 (gdb) b -f function(i[TAB]
 (gdb) b -f function

i.e., gdb strips everything after the "(".  That's caused by some code
in symtab.c that'll be eliminated further down the series.  These
patches are all unfortunately interrelated, which is also the reason
new tests only appear much later in the series.
But let's ignore that reality for the remainder of the description.
)

So... this patch gets rid of the need for quoting.

It does that by adding a way for a completer to control the exact
completion word point that readline should start the completion
request for, instead of letting readline try to figure it out using
the current language's word break chars array, and often failing.

In the case above, we want the completer to figure out that it's
completing a function name that starts with "function(i".  It now
does.

It took me a while to figure out a way to ask readline to "use this
exact word point", and for a while I feared that it'd be impossible
with current readline (and having to rely on master readline for core
functionality is something I'd like to avoid very much).  Eventually,
after several different attempts, I came up with what is described in
the comment above gdb_custom_word_point_brkchars in the patch.

With this patch, the handle_brkchars phase of the explicit location
completer advances the expected word point as it parses the input line
left to right, until it figures out exactly what we're completing,
instead of expecting readline to break the string using the word break
characters, and then having the completer heuristically fix up a bad
decision by parsing the input string backwards.  This allows correctly
knowning that we're completing a symbol name after -function, complete
functions without quoting, etc.

Later, we'll make use of this same mechanims to implement a proper
linespec completer that avoids need for quoting too.

gdb/ChangeLog:
2017-07-17  Pedro Alves  <palves@redhat.com>

	* ada-lang.c (ada_collect_symbol_completion_matches): Add
	complete_symbol_mode parameter.
	* cli/cli-cmds.c (complete_command): Get the completion result out
	of the handle_brkchars tracker if used a custom word point.
	* completer.c: Include "linespec.h".
	(enum explicit_location_match_type) <MATCH_LINE>: New enumerator.
	(advance_to_expression_complete_word_point): New.
	(completion_tracker::completes_to_completion_word): New.
	(complete_files_symbols): Pass down
	complete_symbol_mode::EXPRESSION.
	(explicit_options, probe_options): New.
	(collect_explicit_location_matches): Complete on the
	explictit_loc->foo instead of word.  Use
	linespec_complete_function.  Handle MATCH_LINE.  Handle offering
	keyword and options completions.
	(backup_text_ptr): Delete.
	(skip_keyword): New.
	(complete_explicit_location): Remove 'word' parameter.  Add
	language, quoted_arg_start and quoted_arg_end parameters.
	Rewrite, parsing left to right.
	(location_completer): Rewrite.
	(location_completer_handle_brkchars): New function.
	(symbol_completer): Pass down complete_symbol_mode::EXPRESSION.
	(enum complete_line_internal_reason): Adjust comments.
	(completion_tracker::discard_completions): New.
	(completer_handle_brkchars_func_for_completer): Handle
	location_completer.
	(gdb_custom_word_point_brkchars)
	(gdb_org_rl_basic_quote_characters): New.
	(gdb_completion_word_break_characters_throw)
	(completion_find_completion_word): Handle trackers that use a
	custom word point.
	(completion_tracker::advance_custom_word_point_by): New.
	(completion_tracker::build_completion_result): Don't rely on
	readline appending the quote char.
	(gdb_rl_attempted_completion_function_throw): Handle trackers that
	use a custom word point.
	(gdb_rl_attempted_completion_function): Restore
	rl_basic_quote_characters.
	* completer.h (class completion_tracker): Extend intro comment.
	(completion_tracker::set_quote_char)
	(completion_tracker::quote_char)
	(completion_tracker::set_use_custom_word_point)
	(completion_tracker::use_custom_word_point)
	(completion_tracker::custom_word_point)
	(completion_tracker::set_custom_word_point)
	(completion_tracker::advance_custom_word_point_by)
	(completion_tracker::completes_to_completion_word)
	(completion_tracker::discard_completions): New methods.
	(completion_tracker::m_quote_char)
	(completion_tracker::m_use_custom_word_point)
	(completion_tracker::m_custom_word_point): New fields.
	(advance_to_expression_complete_word_point): Declare.
	* f-lang.c (f_collect_symbol_completion_matches): Add
	complete_symbol_mode parameter.
	* language.h (struct language_defn)
	<la_collect_symbol_completion_matches>: Add complete_symbol_mode
	parameter.
	* linespec.c (linespec_keywords): Add NULL terminator.  Make extern.
	(linespec_complete_function): New function.
	(linespec_lexer_lex_keyword): Adjust.
	* linespec.h (linespec_keywords, linespec_complete_function): New
	declarations.
	* location.c (find_end_quote): New function.
	(explicit_location_lex_one): Add explicit_completion_info
	parameter.  Save quoting info.  Don't throw if being called for
	completion.  Don't handle Ada operators here.
	(is_cp_operator, skip_op_false_positives, first_of)
	(explicit_location_lex_one_function): New function.
	(string_to_explicit_location): Replace 'dont_throw' parameter with
	an explicit_completion_info pointer parameter.  Handle it.  Don't
	use explicit_location_lex_one to lex function names.  Use
	explicit_location_lex_one_function instead.
	* location.h (struct explicit_completion_info): New.
	(string_to_explicit_location): Replace 'dont_throw' parameter with
	an explicit_completion_info pointer parameter.
	* symtab.c (default_collect_symbol_completion_matches_break_on):
	Add complete_symbol_mode parameter.  Handle LINESPEC mode.
	(default_collect_symbol_completion_matches)
	(collect_symbol_completion_matches): Add complete_symbol_mode
	parameter.
	(collect_symbol_completion_matches_type): Pass down
	complete_symbol_mode::EXPRESSION.
	(collect_file_symbol_completion_matches): Add complete_symbol_mode
	parameter.  Handle LINESPEC mode.
	* symtab.h (complete_symbol_mode): New.
	(default_collect_symbol_completion_matches_break_on)
	(default_collect_symbol_completion_matches)
	(collect_symbol_completion_matches)
	(collect_file_symbol_completion_matches): Add complete_symbol_mode
	parameter.

gdb/testsuite/ChangeLog:
2017-07-17  Pedro Alves  <palves@redhat.com>

	* gdb.linespec/ls-errs.exp (do_test): Adjust expected output.
2017-07-17 20:21:33 +01:00

368 lines
13 KiB
C++
Raw Blame History

/* Header for GDB line completion.
Copyright (C) 2000-2017 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#if !defined (COMPLETER_H)
#define COMPLETER_H 1
#include "gdb_vecs.h"
#include "command.h"
/* Types of functions in struct match_list_displayer. */
struct match_list_displayer;
typedef void mld_crlf_ftype (const struct match_list_displayer *);
typedef void mld_putch_ftype (const struct match_list_displayer *, int);
typedef void mld_puts_ftype (const struct match_list_displayer *,
const char *);
typedef void mld_flush_ftype (const struct match_list_displayer *);
typedef void mld_erase_entire_line_ftype (const struct match_list_displayer *);
typedef void mld_beep_ftype (const struct match_list_displayer *);
typedef int mld_read_key_ftype (const struct match_list_displayer *);
/* Interface between CLI/TUI and gdb_match_list_displayer. */
struct match_list_displayer
{
/* The screen dimensions to work with when displaying matches. */
int height, width;
/* Print cr,lf. */
mld_crlf_ftype *crlf;
/* Not "putc" to avoid issues where it is a stdio macro. Sigh. */
mld_putch_ftype *putch;
/* Print a string. */
mld_puts_ftype *puts;
/* Flush all accumulated output. */
mld_flush_ftype *flush;
/* Erase the currently line on the terminal (but don't discard any text the
user has entered, readline may shortly re-print it). */
mld_erase_entire_line_ftype *erase_entire_line;
/* Ring the bell. */
mld_beep_ftype *beep;
/* Read one key. */
mld_read_key_ftype *read_key;
};
/* A list of completion candidates. Each element is a malloc string,
because ownership of the strings is transferred to readline, which
calls free on each element. */
typedef std::vector<gdb::unique_xmalloc_ptr<char>> completion_list;
/* The final result of a completion that is handed over to either
readline or the "completion" command (which pretends to be
readline). Mainly a wrapper for a readline-style match list array,
though other bits of info are included too. */
struct completion_result
{
/* Create an empty result. */
completion_result ();
/* Create a result. */
completion_result (char **match_list, size_t number_matches,
bool completion_suppress_append);
/* Destroy a result. */
~completion_result ();
/* Disable copying, since we don't need it. */
completion_result (const completion_result &rhs) = delete;
void operator= (const completion_result &rhs) = delete;
/* Move a result. */
completion_result (completion_result &&rhs);
/* Release ownership of the match list array. */
char **release_match_list ();
/* Sort the match list. */
void sort_match_list ();
private:
/* Destroy the match list array and its contents. */
void reset_match_list ();
public:
/* (There's no point in making these fields private, since the whole
point of this wrapper is to build data in the layout expected by
readline. Making them private would require adding getters for
the "complete" command, which would expose the same
implementation details anyway.) */
/* The match list array, in the format that readline expects.
match_list[0] contains the common prefix. The real match list
starts at index 1. The list is NULL terminated. If there's only
one match, then match_list[1] is NULL. If there are no matches,
then this is NULL. */
char **match_list;
/* The number of matched completions in MATCH_LIST. Does not
include the NULL terminator or the common prefix. */
size_t number_matches;
/* Whether readline should suppress appending a whitespace, when
there's only one possible completion. */
bool completion_suppress_append;
};
/* Object used by completers to build a completion match list to hand
over to readline. It tracks:
- How many unique completions have been generated, 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.
- The custom word point to hand over to readline, for completers
that parse the input string in order to dynamically adjust
themselves depending on exactly what they're completing. E.g.,
the linespec completer needs to bypass readline's too-simple word
breaking algorithm.
*/
class completion_tracker
{
public:
completion_tracker ();
~completion_tracker ();
/* Disable copy. */
completion_tracker (const completion_tracker &rhs) = delete;
void operator= (const completion_tracker &rhs) = delete;
/* Add the completion NAME to the list of generated completions if
it is not there already. If too many completions were already
found, this throws an error. */
void add_completion (gdb::unique_xmalloc_ptr<char> name);
/* Add all completions matches in LIST. Elements are moved out of
LIST. */
void add_completions (completion_list &&list);
/* Set the quote char to be appended after a unique completion is
added to the input line. Set to '\0' to clear. See
m_quote_char's description. */
void set_quote_char (int quote_char)
{ m_quote_char = quote_char; }
/* The quote char to be appended after a unique completion is added
to the input line. Returns '\0' if no quote char has been set.
See m_quote_char's description. */
int quote_char () { return m_quote_char; }
/* Tell the tracker that the current completer wants to provide a
custom word point instead of a list of a break chars, in the
handle_brkchars phase. Such completers must also compute their
completions then. */
void set_use_custom_word_point (bool enable)
{ m_use_custom_word_point = enable; }
/* Whether the current completer computes a custom word point. */
bool use_custom_word_point () const
{ return m_use_custom_word_point; }
/* The custom word point. */
int custom_word_point () const
{ return m_custom_word_point; }
/* Set the custom word point to POINT. */
void set_custom_word_point (int point)
{ m_custom_word_point = point; }
/* Advance the custom word point by LEN. */
void advance_custom_word_point_by (size_t len);
/* Return true if we only have one completion, and it matches
exactly the completion word. I.e., completing results in what we
already have. */
bool completes_to_completion_word (const char *word);
/* True if we have any completion match recorded. */
bool have_completions () const
{ return !m_entries_vec.empty (); }
/* Discard the current completion match list and the current
LCD. */
void discard_completions ();
/* Build a completion_result containing the list of completion
matches to hand over to readline. The parameters are as in
rl_attempted_completion_function. */
completion_result build_completion_result (const char *text,
int start, int end);
private:
/* Add the completion NAME to the list of generated completions if
it is not there already. If false is returned, too many
completions were found. */
bool maybe_add_completion (gdb::unique_xmalloc_ptr<char> name);
/* Given a new match, recompute the lowest common denominator (LCD)
to hand over to readline. */
void recompute_lowest_common_denominator (const char *new_match);
/* The completion matches found so far, in a vector. */
completion_list m_entries_vec;
/* The completion matches found so far, in a hash table, for
duplicate elimination as entries are added. Otherwise the user
is left scratching his/her head: readline and complete_command
will remove duplicates, and if removal of duplicates there brings
the total under max_completions the user may think gdb quit
searching too early. */
htab_t m_entries_hash;
/* If non-zero, then this is the quote char that needs to be
appended after completion (iff we have a unique completion). We
don't rely on readline appending the quote char as delimiter as
then readline wouldn't append the ' ' after the completion.
I.e., we want this:
before tab: "b 'function("
after tab: "b 'function()' "
*/
int m_quote_char = '\0';
/* If true, the completer has its own idea of "word" point, and
doesn't want to rely on readline computing it based on brkchars.
Set in the handle_brkchars phase. */
bool m_use_custom_word_point = false;
/* The completer's idea of where the "word" we were looking at is
relative to RL_LINE_BUFFER. This is advanced in the
handle_brkchars phase as the completer discovers potential
completable words. */
int m_custom_word_point = 0;
/* Our idea of lowest common denominator to hand over to readline.
See intro. */
char *m_lowest_common_denominator = NULL;
/* If true, the LCD is unique. I.e., all completion candidates had
the same string. */
bool m_lowest_common_denominator_unique = false;
};
extern void gdb_display_match_list (char **matches, int len, int max,
const struct match_list_displayer *);
extern const char *get_max_completions_reached_message (void);
extern void complete_line (completion_tracker &tracker,
const char *text,
const char *line_buffer,
int point);
/* Find the bounds of the word in TEXT for completion purposes, and
return a pointer to the end of the word. Calls the completion
machinery for a handle_brkchars phase (using TRACKER) to figure out
the right work break characters for the command in TEXT.
QUOTE_CHAR, if non-null, is set to the opening quote character if
we found an unclosed quoted substring, '\0' otherwise. */
extern const char *completion_find_completion_word (completion_tracker &tracker,
const char *text,
int *quote_char);
/* Assuming TEXT is an expression in the current language, find the
completion word point for TEXT, emulating the algorithm readline
uses to find the word point, using the current language's word
break characters. */
const char *advance_to_expression_complete_word_point
(completion_tracker &tracker, const char *text);
extern char **gdb_rl_attempted_completion_function (const char *text,
int start, int end);
extern void noop_completer (struct cmd_list_element *,
completion_tracker &tracker,
const char *, const char *);
extern void filename_completer (struct cmd_list_element *,
completion_tracker &tracker,
const char *, const char *);
extern void expression_completer (struct cmd_list_element *,
completion_tracker &tracker,
const char *, const char *);
extern void location_completer (struct cmd_list_element *,
completion_tracker &tracker,
const char *, const char *);
extern void symbol_completer (struct cmd_list_element *,
completion_tracker &tracker,
const char *, const char *);
extern void command_completer (struct cmd_list_element *,
completion_tracker &tracker,
const char *, const char *);
extern void signal_completer (struct cmd_list_element *,
completion_tracker &tracker,
const char *, const char *);
extern void reg_or_group_completer (struct cmd_list_element *,
completion_tracker &tracker,
const char *, const char *);
extern void reggroup_completer (struct cmd_list_element *,
completion_tracker &tracker,
const char *, const char *);
extern const char *get_gdb_completer_quote_characters (void);
extern char *gdb_completion_word_break_characters (void);
/* Set the word break characters array to BREAK_CHARS. This function
is useful as const-correct alternative to direct assignment to
rl_completer_word_break_characters, which is "char *",
not "const char *". */
extern void set_rl_completer_word_break_characters (const char *break_chars);
/* Get the matching completer_handle_brkchars_ftype function for FN.
FN is one of the core completer functions above (filename,
location, symbol, etc.). This function is useful for cases when
the completer doesn't know the type of the completion until some
calculation is done (e.g., for Python functions). */
extern completer_handle_brkchars_ftype *
completer_handle_brkchars_func_for_completer (completer_ftype *fn);
/* Exported to linespec.c */
extern const char *skip_quoted_chars (const char *, const char *,
const char *);
extern const char *skip_quoted (const char *);
/* Maximum number of candidates to consider before the completer
bails by throwing MAX_COMPLETIONS_REACHED_ERROR. Negative values
disable limiting. */
extern int max_completions;
#endif /* defined (COMPLETER_H) */
View Git Blame Copy Permalink