aboutsummaryrefslogtreecommitdiff
path: root/gdb/ada-lang.c
diff options
context:
space:
mode:
authorPedro Alves <palves@redhat.com>2017-07-17 20:21:33 +0100
committerPedro Alves <palves@redhat.com>2017-07-17 20:21:33 +0100
commitc6756f62e04846d68c24ee922ddb0377d4bd17f2 (patch)
treee46b28cd0cb1ac766d8c086aef72d08aca2709e3 /gdb/ada-lang.c
parentc5bb8910e80c6cd80c63541f86471c18375c8198 (diff)
downloadgdb-c6756f62e04846d68c24ee922ddb0377d4bd17f2.zip
gdb-c6756f62e04846d68c24ee922ddb0377d4bd17f2.tar.gz
gdb-c6756f62e04846d68c24ee922ddb0377d4bd17f2.tar.bz2
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.
Diffstat (limited to 'gdb/ada-lang.c')
-rw-r--r--gdb/ada-lang.c1
1 files changed, 1 insertions, 0 deletions
diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index e629902..9b5dfab 100644
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -6500,6 +6500,7 @@ symbol_completion_add (completion_tracker &tracker,
static void
ada_collect_symbol_completion_matches (completion_tracker &tracker,
+ complete_symbol_mode mode,
const char *text0, const char *word,
enum type_code code)
{