1 /* Line completion stuff for GDB, the GNU debugger.
2 Copyright (C) 2000-2017 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "expression.h"
23 #include "filenames.h" /* For DOSish file names. */
25 #include "gdb_signals.h"
27 #include "reggroups.h"
28 #include "user-regs.h"
29 #include "arch-utils.h"
33 #include "cli/cli-decode.h"
35 /* FIXME: This is needed because of lookup_cmd_1 (). We should be
36 calling a hook instead so we eliminate the CLI dependency. */
39 /* Needed for rl_completer_word_break_characters() and for
40 rl_filename_completion_function. */
41 #include "readline/readline.h"
43 /* readline defines this. */
46 #include "completer.h"
48 /* Misc state that needs to be tracked across several different
49 readline completer entry point calls, all related to a single
50 completion invocation. */
52 struct gdb_completer_state
54 /* The current completion's completion tracker. This is a global
55 because a tracker can be shared between the handle_brkchars and
56 handle_completion phases, which involves different readline
58 completion_tracker
*tracker
= NULL
;
60 /* Whether the current completion was aborted. */
64 /* The current completion state. */
65 static gdb_completer_state current_completion
;
67 /* An enumeration of the various things a user might attempt to
68 complete for a location. If you change this, remember to update
69 the explicit_options array below too. */
71 enum explicit_location_match_type
73 /* The filename of a source file. */
76 /* The name of a function or method. */
82 /* The name of a label. */
86 /* Prototypes for local functions. */
88 /* readline uses the word breaks for two things:
89 (1) In figuring out where to point the TEXT parameter to the
90 rl_completion_entry_function. Since we don't use TEXT for much,
91 it doesn't matter a lot what the word breaks are for this purpose,
92 but it does affect how much stuff M-? lists.
93 (2) If one of the matches contains a word break character, readline
94 will quote it. That's why we switch between
95 current_language->la_word_break_characters() and
96 gdb_completer_command_word_break_characters. I'm not sure when
97 we need this behavior (perhaps for funky characters in C++
100 /* Variables which are necessary for fancy command line editing. */
102 /* When completing on command names, we remove '-' from the list of
103 word break characters, since we use it in command names. If the
104 readline library sees one in any of the current completion strings,
105 it thinks that the string needs to be quoted and automatically
106 supplies a leading quote. */
107 static const char gdb_completer_command_word_break_characters
[] =
108 " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,";
110 /* When completing on file names, we remove from the list of word
111 break characters any characters that are commonly used in file
112 names, such as '-', '+', '~', etc. Otherwise, readline displays
113 incorrect completion candidates. */
114 /* MS-DOS and MS-Windows use colon as part of the drive spec, and most
115 programs support @foo style response files. */
116 static const char gdb_completer_file_name_break_characters
[] =
117 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
123 /* Characters that can be used to quote completion strings. Note that
124 we can't include '"' because the gdb C parser treats such quoted
125 sequences as strings. */
126 static const char gdb_completer_quote_characters
[] = "'";
128 /* Accessor for some completer data that may interest other files. */
131 get_gdb_completer_quote_characters (void)
133 return gdb_completer_quote_characters
;
136 /* This can be used for functions which don't want to complete on
137 symbols but don't want to complete on anything else either. */
140 noop_completer (struct cmd_list_element
*ignore
,
141 completion_tracker
&tracker
,
142 const char *text
, const char *prefix
)
146 /* Complete on filenames. */
149 filename_completer (struct cmd_list_element
*ignore
,
150 completion_tracker
&tracker
,
151 const char *text
, const char *word
)
154 VEC (char_ptr
) *return_val
= NULL
;
161 p
= rl_filename_completion_function (text
, subsequent_name
);
164 /* We need to set subsequent_name to a non-zero value before the
165 continue line below, because otherwise, if the first file
166 seen by GDB is a backup file whose name ends in a `~', we
167 will loop indefinitely. */
169 /* Like emacs, don't complete on old versions. Especially
170 useful in the "source" command. */
171 if (p
[strlen (p
) - 1] == '~')
178 /* Return exactly p. */
180 else if (word
> text
)
182 /* Return some portion of p. */
183 q
= (char *) xmalloc (strlen (p
) + 5);
184 strcpy (q
, p
+ (word
- text
));
189 /* Return some of TEXT plus p. */
190 q
= (char *) xmalloc (strlen (p
) + (text
- word
) + 5);
191 strncpy (q
, word
, text
- word
);
192 q
[text
- word
] = '\0';
196 tracker
.add_completion (gdb::unique_xmalloc_ptr
<char> (q
));
199 /* There is no way to do this just long enough to affect quote
200 inserting without also affecting the next completion. This
201 should be fixed in readline. FIXME. */
202 /* Ensure that readline does the right thing
203 with respect to inserting quotes. */
204 rl_completer_word_break_characters
= "";
208 /* The corresponding completer_handle_brkchars
212 filename_completer_handle_brkchars (struct cmd_list_element
*ignore
,
213 completion_tracker
&tracker
,
214 const char *text
, const char *word
)
216 set_rl_completer_word_break_characters
217 (gdb_completer_file_name_break_characters
);
220 /* Possible values for the found_quote flags word used by the completion
221 functions. It says what kind of (shell-like) quoting we found anywhere
223 #define RL_QF_SINGLE_QUOTE 0x01
224 #define RL_QF_DOUBLE_QUOTE 0x02
225 #define RL_QF_BACKSLASH 0x04
226 #define RL_QF_OTHER_QUOTE 0x08
228 /* Find the bounds of the current word for completion purposes, and
229 return a pointer to the end of the word. This mimics (and is a
230 modified version of) readline's _rl_find_completion_word internal
233 This function skips quoted substrings (characters between matched
234 pairs of characters in rl_completer_quote_characters). We try to
235 find an unclosed quoted substring on which to do matching. If one
236 is not found, we use the word break characters to find the
237 boundaries of the current word. QC, if non-null, is set to the
238 opening quote character if we found an unclosed quoted substring,
239 '\0' otherwise. DP, if non-null, is set to the value of the
240 delimiter character that caused a word break. */
242 struct gdb_rl_completion_word_info
244 const char *word_break_characters
;
245 const char *quote_characters
;
246 const char *basic_quote_characters
;
250 gdb_rl_find_completion_word (struct gdb_rl_completion_word_info
*info
,
252 const char *line_buffer
)
254 int scan
, end
, found_quote
, delimiter
, pass_next
, isbrk
;
256 const char *brkchars
;
257 int point
= strlen (line_buffer
);
259 /* The algorithm below does '--point'. Avoid buffer underflow with
271 found_quote
= delimiter
= 0;
274 brkchars
= info
->word_break_characters
;
276 if (info
->quote_characters
!= NULL
)
278 /* We have a list of characters which can be used in pairs to
279 quote substrings for the completer. Try to find the start of
280 an unclosed quoted substring. */
281 /* FOUND_QUOTE is set so we know what kind of quotes we
283 for (scan
= pass_next
= 0;
293 /* Shell-like semantics for single quotes -- don't allow
294 backslash to quote anything in single quotes, especially
295 not the closing quote. If you don't like this, take out
296 the check on the value of quote_char. */
297 if (quote_char
!= '\'' && line_buffer
[scan
] == '\\')
300 found_quote
|= RL_QF_BACKSLASH
;
304 if (quote_char
!= '\0')
306 /* Ignore everything until the matching close quote
308 if (line_buffer
[scan
] == quote_char
)
310 /* Found matching close. Abandon this
316 else if (strchr (info
->quote_characters
, line_buffer
[scan
]))
318 /* Found start of a quoted substring. */
319 quote_char
= line_buffer
[scan
];
321 /* Shell-like quoting conventions. */
322 if (quote_char
== '\'')
323 found_quote
|= RL_QF_SINGLE_QUOTE
;
324 else if (quote_char
== '"')
325 found_quote
|= RL_QF_DOUBLE_QUOTE
;
327 found_quote
|= RL_QF_OTHER_QUOTE
;
332 if (point
== end
&& quote_char
== '\0')
334 /* We didn't find an unclosed quoted substring upon which to do
335 completion, so use the word break characters to find the
336 substring on which to complete. */
339 scan
= line_buffer
[point
];
341 if (strchr (brkchars
, scan
) != 0)
346 /* If we are at an unquoted word break, then advance past it. */
347 scan
= line_buffer
[point
];
351 isbrk
= strchr (brkchars
, scan
) != 0;
355 /* If the character that caused the word break was a quoting
356 character, then remember it as the delimiter. */
357 if (info
->basic_quote_characters
358 && strchr (info
->basic_quote_characters
, scan
)
359 && (end
- point
) > 1)
371 return line_buffer
+ point
;
374 /* See completer.h. */
377 advance_to_expression_complete_word_point (completion_tracker
&tracker
,
380 gdb_rl_completion_word_info info
;
382 info
.word_break_characters
383 = current_language
->la_word_break_characters ();
384 info
.quote_characters
= gdb_completer_quote_characters
;
385 info
.basic_quote_characters
= rl_basic_quote_characters
;
388 = gdb_rl_find_completion_word (&info
, NULL
, NULL
, text
);
390 tracker
.advance_custom_word_point_by (start
- text
);
395 /* See completer.h. */
398 completion_tracker::completes_to_completion_word (const char *word
)
400 if (m_lowest_common_denominator_unique
)
402 const char *lcd
= m_lowest_common_denominator
;
404 if (strncmp_iw (word
, lcd
, strlen (lcd
)) == 0)
406 /* Maybe skip the function and complete on keywords. */
407 size_t wordlen
= strlen (word
);
408 if (word
[wordlen
- 1] == ' ')
416 /* Complete on linespecs, which might be of two possible forms:
422 This is intended to be used in commands that set breakpoints
426 complete_files_symbols (completion_tracker
&tracker
,
427 const char *text
, const char *word
)
430 completion_list fn_list
;
433 int quoted
= *text
== '\'' || *text
== '"';
434 int quote_char
= '\0';
435 const char *colon
= NULL
;
436 char *file_to_match
= NULL
;
437 const char *symbol_start
= text
;
438 const char *orig_text
= text
;
440 /* Do we have an unquoted colon, as in "break foo.c:bar"? */
441 for (p
= text
; *p
!= '\0'; ++p
)
443 if (*p
== '\\' && p
[1] == '\'')
445 else if (*p
== '\'' || *p
== '"')
449 while (*p
!= '\0' && *p
!= quote_found
)
451 if (*p
== '\\' && p
[1] == quote_found
)
456 if (*p
== quote_found
)
459 break; /* Hit the end of text. */
461 #if HAVE_DOS_BASED_FILE_SYSTEM
462 /* If we have a DOS-style absolute file name at the beginning of
463 TEXT, and the colon after the drive letter is the only colon
464 we found, pretend the colon is not there. */
465 else if (p
< text
+ 3 && *p
== ':' && p
== text
+ 1 + quoted
)
468 else if (*p
== ':' && !colon
)
471 symbol_start
= p
+ 1;
473 else if (strchr (current_language
->la_word_break_characters(), *p
))
474 symbol_start
= p
+ 1;
480 /* Where is the file name? */
485 file_to_match
= (char *) xmalloc (colon
- text
+ 1);
486 strncpy (file_to_match
, text
, colon
- text
);
487 file_to_match
[colon
- text
] = '\0';
488 /* Remove trailing colons and quotes from the file name. */
489 for (s
= file_to_match
+ (colon
- text
);
492 if (*s
== ':' || *s
== quote_char
)
495 /* If the text includes a colon, they want completion only on a
496 symbol name after the colon. Otherwise, we need to complete on
497 symbols as well as on files. */
500 collect_file_symbol_completion_matches (tracker
,
501 complete_symbol_mode::EXPRESSION
,
502 symbol_name_match_type::EXPRESSION
,
505 xfree (file_to_match
);
509 size_t text_len
= strlen (text
);
511 collect_symbol_completion_matches (tracker
,
512 complete_symbol_mode::EXPRESSION
,
513 symbol_name_match_type::EXPRESSION
,
515 /* If text includes characters which cannot appear in a file
516 name, they cannot be asking for completion on files. */
518 gdb_completer_file_name_break_characters
) == text_len
)
519 fn_list
= make_source_files_completion_list (text
, text
);
522 if (!fn_list
.empty () && !tracker
.have_completions ())
526 /* If we only have file names as possible completion, we should
527 bring them in sync with what rl_complete expects. The
528 problem is that if the user types "break /foo/b TAB", and the
529 possible completions are "/foo/bar" and "/foo/baz"
530 rl_complete expects us to return "bar" and "baz", without the
531 leading directories, as possible completions, because `word'
532 starts at the "b". But we ignore the value of `word' when we
533 call make_source_files_completion_list above (because that
534 would not DTRT when the completion results in both symbols
535 and file names), so make_source_files_completion_list returns
536 the full "/foo/bar" and "/foo/baz" strings. This produces
537 wrong results when, e.g., there's only one possible
538 completion, because rl_complete will prepend "/foo/" to each
539 candidate completion. The loop below removes that leading
541 for (const auto &fn_up
: fn_list
)
543 char *fn
= fn_up
.get ();
544 memmove (fn
, fn
+ (word
- text
), strlen (fn
) + 1 - (word
- text
));
548 tracker
.add_completions (std::move (fn_list
));
550 if (!tracker
.have_completions ())
552 /* No completions at all. As the final resort, try completing
553 on the entire text as a symbol. */
554 collect_symbol_completion_matches (tracker
,
555 complete_symbol_mode::EXPRESSION
,
556 symbol_name_match_type::EXPRESSION
,
561 /* See completer.h. */
564 complete_source_filenames (const char *text
)
566 size_t text_len
= strlen (text
);
568 /* If text includes characters which cannot appear in a file name,
569 the user cannot be asking for completion on files. */
571 gdb_completer_file_name_break_characters
)
573 return make_source_files_completion_list (text
, text
);
578 /* Complete address and linespec locations. */
581 complete_address_and_linespec_locations (completion_tracker
&tracker
,
586 tracker
.advance_custom_word_point_by (1);
589 = advance_to_expression_complete_word_point (tracker
, text
);
590 complete_expression (tracker
, text
, word
);
594 linespec_complete (tracker
, text
);
598 /* The explicit location options. Note that indexes into this array
599 must match the explicit_location_match_type enumerators. */
601 static const char *const explicit_options
[] =
610 /* The probe modifier options. These can appear before a location in
611 breakpoint commands. */
612 static const char *const probe_options
[] =
620 /* Returns STRING if not NULL, the empty string otherwise. */
623 string_or_empty (const char *string
)
625 return string
!= NULL
? string
: "";
628 /* A helper function to collect explicit location matches for the given
629 LOCATION, which is attempting to match on WORD. */
632 collect_explicit_location_matches (completion_tracker
&tracker
,
633 struct event_location
*location
,
634 enum explicit_location_match_type what
,
636 const struct language_defn
*language
)
638 const struct explicit_location
*explicit_loc
639 = get_explicit_location (location
);
641 /* Note, in the various MATCH_* below, we complete on
642 explicit_loc->foo instead of WORD, because only the former will
643 have already skipped past any quote char. */
648 const char *source
= string_or_empty (explicit_loc
->source_filename
);
649 completion_list matches
650 = make_source_files_completion_list (source
, source
);
651 tracker
.add_completions (std::move (matches
));
657 const char *function
= string_or_empty (explicit_loc
->function_name
);
658 linespec_complete_function (tracker
, function
,
659 explicit_loc
->source_filename
);
664 /* Nothing to offer. */
669 const char *label
= string_or_empty (explicit_loc
->label_name
);
670 linespec_complete_label (tracker
, language
,
671 explicit_loc
->source_filename
,
672 explicit_loc
->function_name
,
678 gdb_assert_not_reached ("unhandled explicit_location_match_type");
681 if (tracker
.completes_to_completion_word (word
))
683 tracker
.discard_completions ();
684 tracker
.advance_custom_word_point_by (strlen (word
));
685 complete_on_enum (tracker
, explicit_options
, "", "");
686 complete_on_enum (tracker
, linespec_keywords
, "", "");
688 else if (!tracker
.have_completions ())
690 /* Maybe we have an unterminated linespec keyword at the tail of
691 the string. Try completing on that. */
692 size_t wordlen
= strlen (word
);
693 const char *keyword
= word
+ wordlen
;
695 if (wordlen
> 0 && keyword
[-1] != ' ')
697 while (keyword
> word
&& *keyword
!= ' ')
699 /* Don't complete on keywords if we'd be completing on the
700 whole explicit linespec option. E.g., "b -function
701 thr<tab>" should not complete to the "thread"
705 keyword
= skip_spaces (keyword
);
707 tracker
.advance_custom_word_point_by (keyword
- word
);
708 complete_on_enum (tracker
, linespec_keywords
, keyword
, keyword
);
711 else if (wordlen
> 0 && keyword
[-1] == ' ')
713 /* Assume that we're maybe past the explicit location
714 argument, and we didn't manage to find any match because
715 the user wants to create a pending breakpoint. Offer the
716 keyword and explicit location options as possible
718 tracker
.advance_custom_word_point_by (keyword
- word
);
719 complete_on_enum (tracker
, linespec_keywords
, keyword
, keyword
);
720 complete_on_enum (tracker
, explicit_options
, keyword
, keyword
);
725 /* If the next word in *TEXT_P is any of the keywords in KEYWORDS,
726 then advance both TEXT_P and the word point in the tracker past the
727 keyword and return the (0-based) index in the KEYWORDS array that
728 matched. Otherwise, return -1. */
731 skip_keyword (completion_tracker
&tracker
,
732 const char * const *keywords
, const char **text_p
)
734 const char *text
= *text_p
;
735 const char *after
= skip_to_space (text
);
736 size_t len
= after
- text
;
738 if (text
[len
] != ' ')
742 for (int i
= 0; keywords
[i
] != NULL
; i
++)
744 if (strncmp (keywords
[i
], text
, len
) == 0)
755 tracker
.advance_custom_word_point_by (len
+ 1);
764 /* A completer function for explicit locations. This function
765 completes both options ("-source", "-line", etc) and values. If
766 completing a quoted string, then QUOTED_ARG_START and
767 QUOTED_ARG_END point to the quote characters. LANGUAGE is the
771 complete_explicit_location (completion_tracker
&tracker
,
772 struct event_location
*location
,
774 const language_defn
*language
,
775 const char *quoted_arg_start
,
776 const char *quoted_arg_end
)
781 int keyword
= skip_keyword (tracker
, explicit_options
, &text
);
784 complete_on_enum (tracker
, explicit_options
, text
, text
);
787 /* Completing on value. */
788 enum explicit_location_match_type what
789 = (explicit_location_match_type
) keyword
;
791 if (quoted_arg_start
!= NULL
&& quoted_arg_end
!= NULL
)
793 if (quoted_arg_end
[1] == '\0')
795 /* If completing a quoted string with the cursor right
796 at the terminating quote char, complete the
797 completion word without interpretation, so that
798 readline advances the cursor one whitespace past the
799 quote, even if there's no match. This makes these
800 cases behave the same:
802 before: "b -function function()"
803 after: "b -function function() "
805 before: "b -function 'function()'"
806 after: "b -function 'function()' "
808 and trusts the user in this case:
810 before: "b -function 'not_loaded_function_yet()'"
811 after: "b -function 'not_loaded_function_yet()' "
813 gdb::unique_xmalloc_ptr
<char> text_copy
815 tracker
.add_completion (std::move (text_copy
));
817 else if (quoted_arg_end
[1] == ' ')
819 /* We're maybe past the explicit location argument.
820 Skip the argument without interpretion, assuming the
821 user may want to create pending breakpoint. Offer
822 the keyword and explicit location options as possible
824 tracker
.advance_custom_word_point_by (strlen (text
));
825 complete_on_enum (tracker
, linespec_keywords
, "", "");
826 complete_on_enum (tracker
, explicit_options
, "", "");
831 /* Now gather matches */
832 collect_explicit_location_matches (tracker
, location
, what
, text
,
837 /* A completer for locations. */
840 location_completer (struct cmd_list_element
*ignore
,
841 completion_tracker
&tracker
,
842 const char *text
, const char * /* word */)
844 int found_probe_option
= -1;
846 /* If we have a probe modifier, skip it. This can only appear as
847 first argument. Until we have a specific completer for probes,
848 falling back to the linespec completer for the remainder of the
849 line is better than nothing. */
850 if (text
[0] == '-' && text
[1] == 'p')
851 found_probe_option
= skip_keyword (tracker
, probe_options
, &text
);
853 const char *option_text
= text
;
854 int saved_word_point
= tracker
.custom_word_point ();
856 const char *copy
= text
;
858 explicit_completion_info completion_info
;
859 event_location_up location
860 = string_to_explicit_location (©
, current_language
,
862 if (completion_info
.quoted_arg_start
!= NULL
863 && completion_info
.quoted_arg_end
== NULL
)
865 /* Found an unbalanced quote. */
866 tracker
.set_quote_char (*completion_info
.quoted_arg_start
);
867 tracker
.advance_custom_word_point_by (1);
870 if (location
!= NULL
)
874 tracker
.advance_custom_word_point_by (copy
- text
);
877 /* We found a terminator at the tail end of the string,
878 which means we're past the explicit location options. We
879 may have a keyword to complete on. If we have a whole
880 keyword, then complete whatever comes after as an
881 expression. This is mainly for the "if" keyword. If the
882 "thread" and "task" keywords gain their own completers,
883 they should be used here. */
884 int keyword
= skip_keyword (tracker
, linespec_keywords
, &text
);
888 complete_on_enum (tracker
, linespec_keywords
, text
, text
);
893 = advance_to_expression_complete_word_point (tracker
, text
);
894 complete_expression (tracker
, text
, word
);
899 tracker
.advance_custom_word_point_by (completion_info
.last_option
901 text
= completion_info
.last_option
;
903 complete_explicit_location (tracker
, location
.get (), text
,
905 completion_info
.quoted_arg_start
,
906 completion_info
.quoted_arg_end
);
912 /* This is an address or linespec location. */
913 complete_address_and_linespec_locations (tracker
, text
);
916 /* Add matches for option names, if either:
918 - Some completer above found some matches, but the word point did
919 not advance (e.g., "b <tab>" finds all functions, or "b -<tab>"
920 matches all objc selectors), or;
922 - Some completer above advanced the word point, but found no
925 if ((text
[0] == '-' || text
[0] == '\0')
926 && (!tracker
.have_completions ()
927 || tracker
.custom_word_point () == saved_word_point
))
929 tracker
.set_custom_word_point (saved_word_point
);
932 if (found_probe_option
== -1)
933 complete_on_enum (tracker
, probe_options
, text
, text
);
934 complete_on_enum (tracker
, explicit_options
, text
, text
);
938 /* The corresponding completer_handle_brkchars
942 location_completer_handle_brkchars (struct cmd_list_element
*ignore
,
943 completion_tracker
&tracker
,
945 const char *word_ignored
)
947 tracker
.set_use_custom_word_point (true);
949 location_completer (ignore
, tracker
, text
, NULL
);
952 /* Helper for expression_completer which recursively adds field and
953 method names from TYPE, a struct or union type, to the OUTPUT
957 add_struct_fields (struct type
*type
, completion_list
&output
,
958 char *fieldname
, int namelen
)
961 int computed_type_name
= 0;
962 const char *type_name
= NULL
;
964 type
= check_typedef (type
);
965 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
967 if (i
< TYPE_N_BASECLASSES (type
))
968 add_struct_fields (TYPE_BASECLASS (type
, i
),
969 output
, fieldname
, namelen
);
970 else if (TYPE_FIELD_NAME (type
, i
))
972 if (TYPE_FIELD_NAME (type
, i
)[0] != '\0')
974 if (! strncmp (TYPE_FIELD_NAME (type
, i
),
976 output
.emplace_back (xstrdup (TYPE_FIELD_NAME (type
, i
)));
978 else if (TYPE_CODE (TYPE_FIELD_TYPE (type
, i
)) == TYPE_CODE_UNION
)
980 /* Recurse into anonymous unions. */
981 add_struct_fields (TYPE_FIELD_TYPE (type
, i
),
982 output
, fieldname
, namelen
);
987 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
989 const char *name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
991 if (name
&& ! strncmp (name
, fieldname
, namelen
))
993 if (!computed_type_name
)
995 type_name
= type_name_no_tag (type
);
996 computed_type_name
= 1;
998 /* Omit constructors from the completion list. */
999 if (!type_name
|| strcmp (type_name
, name
))
1000 output
.emplace_back (xstrdup (name
));
1005 /* See completer.h. */
1008 complete_expression (completion_tracker
&tracker
,
1009 const char *text
, const char *word
)
1011 struct type
*type
= NULL
;
1013 enum type_code code
= TYPE_CODE_UNDEF
;
1015 /* Perform a tentative parse of the expression, to see whether a
1016 field completion is required. */
1020 type
= parse_expression_for_completion (text
, &fieldname
, &code
);
1022 CATCH (except
, RETURN_MASK_ERROR
)
1028 if (fieldname
&& type
)
1032 type
= check_typedef (type
);
1033 if (TYPE_CODE (type
) != TYPE_CODE_PTR
&& !TYPE_IS_REFERENCE (type
))
1035 type
= TYPE_TARGET_TYPE (type
);
1038 if (TYPE_CODE (type
) == TYPE_CODE_UNION
1039 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
1041 int flen
= strlen (fieldname
);
1042 completion_list result
;
1044 add_struct_fields (type
, result
, fieldname
, flen
);
1046 tracker
.add_completions (std::move (result
));
1050 else if (fieldname
&& code
!= TYPE_CODE_UNDEF
)
1052 VEC (char_ptr
) *result
;
1053 struct cleanup
*cleanup
= make_cleanup (xfree
, fieldname
);
1055 collect_symbol_completion_matches_type (tracker
, fieldname
, fieldname
,
1057 do_cleanups (cleanup
);
1062 complete_files_symbols (tracker
, text
, word
);
1065 /* Complete on expressions. Often this means completing on symbol
1066 names, but some language parsers also have support for completing
1070 expression_completer (struct cmd_list_element
*ignore
,
1071 completion_tracker
&tracker
,
1072 const char *text
, const char *word
)
1074 complete_expression (tracker
, text
, word
);
1077 /* See definition in completer.h. */
1080 set_rl_completer_word_break_characters (const char *break_chars
)
1082 rl_completer_word_break_characters
= (char *) break_chars
;
1085 /* See definition in completer.h. */
1088 set_gdb_completion_word_break_characters (completer_ftype
*fn
)
1090 const char *break_chars
;
1092 /* So far we are only interested in differentiating filename
1093 completers from everything else. */
1094 if (fn
== filename_completer
)
1095 break_chars
= gdb_completer_file_name_break_characters
;
1097 break_chars
= gdb_completer_command_word_break_characters
;
1099 set_rl_completer_word_break_characters (break_chars
);
1102 /* Complete on symbols. */
1105 symbol_completer (struct cmd_list_element
*ignore
,
1106 completion_tracker
&tracker
,
1107 const char *text
, const char *word
)
1109 collect_symbol_completion_matches (tracker
, complete_symbol_mode::EXPRESSION
,
1110 symbol_name_match_type::EXPRESSION
,
1114 /* Here are some useful test cases for completion. FIXME: These
1115 should be put in the test suite. They should be tested with both
1118 "show output-" "radix"
1119 "show output" "-radix"
1120 "p" ambiguous (commands starting with p--path, print, printf, etc.)
1121 "p " ambiguous (all symbols)
1122 "info t foo" no completions
1123 "info t " no completions
1124 "info t" ambiguous ("info target", "info terminal", etc.)
1125 "info ajksdlfk" no completions
1126 "info ajksdlfk " no completions
1128 "info " ambiguous (all info commands)
1129 "p \"a" no completions (string constant)
1130 "p 'a" ambiguous (all symbols starting with a)
1131 "p b-a" ambiguous (all symbols starting with a)
1132 "p b-" ambiguous (all symbols)
1133 "file Make" "file" (word break hard to screw up here)
1134 "file ../gdb.stabs/we" "ird" (needs to not break word at slash)
1137 enum complete_line_internal_reason
1139 /* Preliminary phase, called by gdb_completion_word_break_characters
1140 function, is used to either:
1142 #1 - Determine the set of chars that are word delimiters
1143 depending on the current command in line_buffer.
1145 #2 - Manually advance RL_POINT to the "word break" point instead
1146 of letting readline do it (based on too-simple character
1149 Simpler completers that just pass a brkchars array to readline
1150 (#1 above) must defer generating the completions to the main
1151 phase (below). No completion list should be generated in this
1154 OTOH, completers that manually advance the word point(#2 above)
1155 must set "use_custom_word_point" in the tracker and generate
1156 their completion in this phase. Note that this is the convenient
1157 thing to do since they'll be parsing the input line anyway. */
1160 /* Main phase, called by complete_line function, is used to get the
1161 list of possible completions. */
1164 /* Special case when completing a 'help' command. In this case,
1165 once sub-command completions are exhausted, we simply return
1170 /* Helper for complete_line_internal to simplify it. */
1173 complete_line_internal_normal_command (completion_tracker
&tracker
,
1174 const char *command
, const char *word
,
1175 const char *cmd_args
,
1176 complete_line_internal_reason reason
,
1177 struct cmd_list_element
*c
)
1179 const char *p
= cmd_args
;
1181 if (c
->completer
== filename_completer
)
1183 /* Many commands which want to complete on file names accept
1184 several file names, as in "run foo bar >>baz". So we don't
1185 want to complete the entire text after the command, just the
1186 last word. To this end, we need to find the beginning of the
1187 file name by starting at `word' and going backwards. */
1190 && strchr (gdb_completer_file_name_break_characters
,
1196 if (reason
== handle_brkchars
)
1198 completer_handle_brkchars_ftype
*brkchars_fn
;
1200 if (c
->completer_handle_brkchars
!= NULL
)
1201 brkchars_fn
= c
->completer_handle_brkchars
;
1205 = (completer_handle_brkchars_func_for_completer
1209 brkchars_fn (c
, tracker
, p
, word
);
1212 if (reason
!= handle_brkchars
&& c
->completer
!= NULL
)
1213 (*c
->completer
) (c
, tracker
, p
, word
);
1216 /* Internal function used to handle completions.
1219 TEXT is the caller's idea of the "word" we are looking at.
1221 LINE_BUFFER is available to be looked at; it contains the entire
1222 text of the line. POINT is the offset in that line of the cursor.
1223 You should pretend that the line ends at POINT.
1225 See complete_line_internal_reason for description of REASON. */
1228 complete_line_internal_1 (completion_tracker
&tracker
,
1230 const char *line_buffer
, int point
,
1231 complete_line_internal_reason reason
)
1235 int ignore_help_classes
;
1236 /* Pointer within tmp_command which corresponds to text. */
1238 struct cmd_list_element
*c
, *result_list
;
1240 /* Choose the default set of word break characters to break
1241 completions. If we later find out that we are doing completions
1242 on command strings (as opposed to strings supplied by the
1243 individual command completer functions, which can be any string)
1244 then we will switch to the special word break set for command
1245 strings, which leaves out the '-' character used in some
1247 set_rl_completer_word_break_characters
1248 (current_language
->la_word_break_characters());
1250 /* Decide whether to complete on a list of gdb commands or on
1252 tmp_command
= (char *) alloca (point
+ 1);
1255 /* The help command should complete help aliases. */
1256 ignore_help_classes
= reason
!= handle_help
;
1258 strncpy (tmp_command
, line_buffer
, point
);
1259 tmp_command
[point
] = '\0';
1260 if (reason
== handle_brkchars
)
1262 gdb_assert (text
== NULL
);
1267 /* Since text always contains some number of characters leading up
1268 to point, we can find the equivalent position in tmp_command
1269 by subtracting that many characters from the end of tmp_command. */
1270 word
= tmp_command
+ point
- strlen (text
);
1273 /* Move P up to the start of the command. */
1274 p
= skip_spaces (p
);
1278 /* An empty line is ambiguous; that is, it could be any
1280 c
= CMD_LIST_AMBIGUOUS
;
1285 c
= lookup_cmd_1 (&p
, cmdlist
, &result_list
, ignore_help_classes
);
1288 /* Move p up to the next interesting thing. */
1289 while (*p
== ' ' || *p
== '\t')
1294 tracker
.advance_custom_word_point_by (p
- tmp_command
);
1298 /* It is an unrecognized command. So there are no
1299 possible completions. */
1301 else if (c
== CMD_LIST_AMBIGUOUS
)
1305 /* lookup_cmd_1 advances p up to the first ambiguous thing, but
1306 doesn't advance over that thing itself. Do so now. */
1308 while (*q
&& (isalnum (*q
) || *q
== '-' || *q
== '_'))
1310 if (q
!= tmp_command
+ point
)
1312 /* There is something beyond the ambiguous
1313 command, so there are no possible completions. For
1314 example, "info t " or "info t foo" does not complete
1315 to anything, because "info t" can be "info target" or
1320 /* We're trying to complete on the command which was ambiguous.
1321 This we can deal with. */
1324 if (reason
!= handle_brkchars
)
1325 complete_on_cmdlist (*result_list
->prefixlist
, tracker
, p
,
1326 word
, ignore_help_classes
);
1330 if (reason
!= handle_brkchars
)
1331 complete_on_cmdlist (cmdlist
, tracker
, p
, word
,
1332 ignore_help_classes
);
1334 /* Ensure that readline does the right thing with respect to
1335 inserting quotes. */
1336 set_rl_completer_word_break_characters
1337 (gdb_completer_command_word_break_characters
);
1342 /* We've recognized a full command. */
1344 if (p
== tmp_command
+ point
)
1346 /* There is no non-whitespace in the line beyond the
1349 if (p
[-1] == ' ' || p
[-1] == '\t')
1351 /* The command is followed by whitespace; we need to
1352 complete on whatever comes after command. */
1355 /* It is a prefix command; what comes after it is
1356 a subcommand (e.g. "info "). */
1357 if (reason
!= handle_brkchars
)
1358 complete_on_cmdlist (*c
->prefixlist
, tracker
, p
, word
,
1359 ignore_help_classes
);
1361 /* Ensure that readline does the right thing
1362 with respect to inserting quotes. */
1363 set_rl_completer_word_break_characters
1364 (gdb_completer_command_word_break_characters
);
1366 else if (reason
== handle_help
)
1370 if (reason
!= handle_brkchars
)
1371 complete_on_enum (tracker
, c
->enums
, p
, word
);
1372 set_rl_completer_word_break_characters
1373 (gdb_completer_command_word_break_characters
);
1377 /* It is a normal command; what comes after it is
1378 completed by the command's completer function. */
1379 complete_line_internal_normal_command (tracker
,
1380 tmp_command
, word
, p
,
1386 /* The command is not followed by whitespace; we need to
1387 complete on the command itself, e.g. "p" which is a
1388 command itself but also can complete to "print", "ptype"
1392 /* Find the command we are completing on. */
1394 while (q
> tmp_command
)
1396 if (isalnum (q
[-1]) || q
[-1] == '-' || q
[-1] == '_')
1402 if (reason
!= handle_brkchars
)
1403 complete_on_cmdlist (result_list
, tracker
, q
, word
,
1404 ignore_help_classes
);
1406 /* Ensure that readline does the right thing
1407 with respect to inserting quotes. */
1408 set_rl_completer_word_break_characters
1409 (gdb_completer_command_word_break_characters
);
1412 else if (reason
== handle_help
)
1416 /* There is non-whitespace beyond the command. */
1418 if (c
->prefixlist
&& !c
->allow_unknown
)
1420 /* It is an unrecognized subcommand of a prefix command,
1421 e.g. "info adsfkdj". */
1425 if (reason
!= handle_brkchars
)
1426 complete_on_enum (tracker
, c
->enums
, p
, word
);
1430 /* It is a normal command. */
1431 complete_line_internal_normal_command (tracker
,
1432 tmp_command
, word
, p
,
1439 /* Wrapper around complete_line_internal_1 to handle
1440 MAX_COMPLETIONS_REACHED_ERROR. */
1443 complete_line_internal (completion_tracker
&tracker
,
1445 const char *line_buffer
, int point
,
1446 complete_line_internal_reason reason
)
1450 complete_line_internal_1 (tracker
, text
, line_buffer
, point
, reason
);
1452 CATCH (except
, RETURN_MASK_ERROR
)
1454 if (except
.error
!= MAX_COMPLETIONS_REACHED_ERROR
)
1455 throw_exception (except
);
1460 /* See completer.h. */
1462 int max_completions
= 200;
1464 /* Initial size of the table. It automagically grows from here. */
1465 #define INITIAL_COMPLETION_HTAB_SIZE 200
1467 /* See completer.h. */
1469 completion_tracker::completion_tracker ()
1471 m_entries_hash
= htab_create_alloc (INITIAL_COMPLETION_HTAB_SIZE
,
1472 htab_hash_string
, (htab_eq
) streq
,
1473 NULL
, xcalloc
, xfree
);
1476 /* See completer.h. */
1479 completion_tracker::discard_completions ()
1481 xfree (m_lowest_common_denominator
);
1482 m_lowest_common_denominator
= NULL
;
1484 m_lowest_common_denominator_unique
= false;
1486 m_entries_vec
.clear ();
1488 htab_delete (m_entries_hash
);
1489 m_entries_hash
= htab_create_alloc (INITIAL_COMPLETION_HTAB_SIZE
,
1490 htab_hash_string
, (htab_eq
) streq
,
1491 NULL
, xcalloc
, xfree
);
1494 /* See completer.h. */
1496 completion_tracker::~completion_tracker ()
1498 xfree (m_lowest_common_denominator
);
1499 htab_delete (m_entries_hash
);
1502 /* See completer.h. */
1505 completion_tracker::maybe_add_completion
1506 (gdb::unique_xmalloc_ptr
<char> name
,
1507 completion_match_for_lcd
*match_for_lcd
)
1511 if (max_completions
== 0)
1514 if (htab_elements (m_entries_hash
) >= max_completions
)
1517 slot
= htab_find_slot (m_entries_hash
, name
.get (), INSERT
);
1518 if (*slot
== HTAB_EMPTY_ENTRY
)
1520 const char *match_for_lcd_str
= NULL
;
1522 if (match_for_lcd
!= NULL
)
1523 match_for_lcd_str
= match_for_lcd
->finish ();
1525 if (match_for_lcd_str
== NULL
)
1526 match_for_lcd_str
= name
.get ();
1528 recompute_lowest_common_denominator (match_for_lcd_str
);
1530 *slot
= name
.get ();
1531 m_entries_vec
.push_back (std::move (name
));
1537 /* See completer.h. */
1540 completion_tracker::add_completion (gdb::unique_xmalloc_ptr
<char> name
,
1541 completion_match_for_lcd
*match_for_lcd
)
1543 if (!maybe_add_completion (std::move (name
), match_for_lcd
))
1544 throw_error (MAX_COMPLETIONS_REACHED_ERROR
, _("Max completions reached."));
1547 /* See completer.h. */
1550 completion_tracker::add_completions (completion_list
&&list
)
1552 for (auto &candidate
: list
)
1553 add_completion (std::move (candidate
));
1556 /* Generate completions all at once. Does nothing if max_completions
1557 is 0. If max_completions is non-negative, this will collect at
1558 most max_completions strings.
1560 TEXT is the caller's idea of the "word" we are looking at.
1562 LINE_BUFFER is available to be looked at; it contains the entire
1565 POINT is the offset in that line of the cursor. You
1566 should pretend that the line ends at POINT. */
1569 complete_line (completion_tracker
&tracker
,
1570 const char *text
, const char *line_buffer
, int point
)
1572 if (max_completions
== 0)
1574 complete_line_internal (tracker
, text
, line_buffer
, point
,
1575 handle_completions
);
1578 /* Complete on command names. Used by "help". */
1581 command_completer (struct cmd_list_element
*ignore
,
1582 completion_tracker
&tracker
,
1583 const char *text
, const char *word
)
1585 complete_line_internal (tracker
, word
, text
,
1586 strlen (text
), handle_help
);
1589 /* The corresponding completer_handle_brkchars implementation. */
1592 command_completer_handle_brkchars (struct cmd_list_element
*ignore
,
1593 completion_tracker
&tracker
,
1594 const char *text
, const char *word
)
1596 set_rl_completer_word_break_characters
1597 (gdb_completer_command_word_break_characters
);
1600 /* Complete on signals. */
1603 signal_completer (struct cmd_list_element
*ignore
,
1604 completion_tracker
&tracker
,
1605 const char *text
, const char *word
)
1607 size_t len
= strlen (word
);
1609 const char *signame
;
1611 for (signum
= GDB_SIGNAL_FIRST
; signum
!= GDB_SIGNAL_LAST
; ++signum
)
1613 /* Can't handle this, so skip it. */
1614 if (signum
== GDB_SIGNAL_0
)
1617 signame
= gdb_signal_to_name ((enum gdb_signal
) signum
);
1619 /* Ignore the unknown signal case. */
1620 if (!signame
|| strcmp (signame
, "?") == 0)
1623 if (strncasecmp (signame
, word
, len
) == 0)
1625 gdb::unique_xmalloc_ptr
<char> copy (xstrdup (signame
));
1626 tracker
.add_completion (std::move (copy
));
1631 /* Bit-flags for selecting what the register and/or register-group
1632 completer should complete on. */
1634 enum reg_completer_target
1636 complete_register_names
= 0x1,
1637 complete_reggroup_names
= 0x2
1639 DEF_ENUM_FLAGS_TYPE (enum reg_completer_target
, reg_completer_targets
);
1641 /* Complete register names and/or reggroup names based on the value passed
1642 in TARGETS. At least one bit in TARGETS must be set. */
1645 reg_or_group_completer_1 (completion_tracker
&tracker
,
1646 const char *text
, const char *word
,
1647 reg_completer_targets targets
)
1649 size_t len
= strlen (word
);
1650 struct gdbarch
*gdbarch
;
1653 gdb_assert ((targets
& (complete_register_names
1654 | complete_reggroup_names
)) != 0);
1655 gdbarch
= get_current_arch ();
1657 if ((targets
& complete_register_names
) != 0)
1662 (name
= user_reg_map_regnum_to_name (gdbarch
, i
)) != NULL
;
1665 if (*name
!= '\0' && strncmp (word
, name
, len
) == 0)
1667 gdb::unique_xmalloc_ptr
<char> copy (xstrdup (name
));
1668 tracker
.add_completion (std::move (copy
));
1673 if ((targets
& complete_reggroup_names
) != 0)
1675 struct reggroup
*group
;
1677 for (group
= reggroup_next (gdbarch
, NULL
);
1679 group
= reggroup_next (gdbarch
, group
))
1681 name
= reggroup_name (group
);
1682 if (strncmp (word
, name
, len
) == 0)
1684 gdb::unique_xmalloc_ptr
<char> copy (xstrdup (name
));
1685 tracker
.add_completion (std::move (copy
));
1691 /* Perform completion on register and reggroup names. */
1694 reg_or_group_completer (struct cmd_list_element
*ignore
,
1695 completion_tracker
&tracker
,
1696 const char *text
, const char *word
)
1698 reg_or_group_completer_1 (tracker
, text
, word
,
1699 (complete_register_names
1700 | complete_reggroup_names
));
1703 /* Perform completion on reggroup names. */
1706 reggroup_completer (struct cmd_list_element
*ignore
,
1707 completion_tracker
&tracker
,
1708 const char *text
, const char *word
)
1710 reg_or_group_completer_1 (tracker
, text
, word
,
1711 complete_reggroup_names
);
1714 /* The default completer_handle_brkchars implementation. */
1717 default_completer_handle_brkchars (struct cmd_list_element
*ignore
,
1718 completion_tracker
&tracker
,
1719 const char *text
, const char *word
)
1721 set_rl_completer_word_break_characters
1722 (current_language
->la_word_break_characters ());
1725 /* See definition in completer.h. */
1727 completer_handle_brkchars_ftype
*
1728 completer_handle_brkchars_func_for_completer (completer_ftype
*fn
)
1730 if (fn
== filename_completer
)
1731 return filename_completer_handle_brkchars
;
1733 if (fn
== location_completer
)
1734 return location_completer_handle_brkchars
;
1736 if (fn
== command_completer
)
1737 return command_completer_handle_brkchars
;
1739 return default_completer_handle_brkchars
;
1742 /* Used as brkchars when we want to tell readline we have a custom
1743 word point. We do that by making our rl_completion_word_break_hook
1744 set RL_POINT to the desired word point, and return the character at
1745 the word break point as the break char. This is two bytes in order
1746 to fit one break character plus the terminating null. */
1747 static char gdb_custom_word_point_brkchars
[2];
1749 /* Since rl_basic_quote_characters is not completer-specific, we save
1750 its original value here, in order to be able to restore it in
1751 gdb_rl_attempted_completion_function. */
1752 static const char *gdb_org_rl_basic_quote_characters
= rl_basic_quote_characters
;
1754 /* Get the list of chars that are considered as word breaks
1755 for the current command. */
1758 gdb_completion_word_break_characters_throw ()
1760 /* New completion starting. Get rid of the previous tracker and
1762 delete current_completion
.tracker
;
1763 current_completion
.tracker
= new completion_tracker ();
1765 completion_tracker
&tracker
= *current_completion
.tracker
;
1767 complete_line_internal (tracker
, NULL
, rl_line_buffer
,
1768 rl_point
, handle_brkchars
);
1770 if (tracker
.use_custom_word_point ())
1772 gdb_assert (tracker
.custom_word_point () > 0);
1773 rl_point
= tracker
.custom_word_point () - 1;
1774 gdb_custom_word_point_brkchars
[0] = rl_line_buffer
[rl_point
];
1775 rl_completer_word_break_characters
= gdb_custom_word_point_brkchars
;
1776 rl_completer_quote_characters
= NULL
;
1778 /* Clear this too, so that if we're completing a quoted string,
1779 readline doesn't consider the quote character a delimiter.
1780 If we didn't do this, readline would auto-complete {b
1781 'fun<tab>} to {'b 'function()'}, i.e., add the terminating
1782 \', but, it wouldn't append the separator space either, which
1783 is not desirable. So instead we take care of appending the
1784 quote character to the LCD ourselves, in
1785 gdb_rl_attempted_completion_function. Since this global is
1786 not just completer-specific, we'll restore it back to the
1787 default in gdb_rl_attempted_completion_function. */
1788 rl_basic_quote_characters
= NULL
;
1791 return rl_completer_word_break_characters
;
1795 gdb_completion_word_break_characters ()
1797 /* New completion starting. */
1798 current_completion
.aborted
= false;
1802 return gdb_completion_word_break_characters_throw ();
1804 CATCH (ex
, RETURN_MASK_ALL
)
1806 /* Set this to that gdb_rl_attempted_completion_function knows
1808 current_completion
.aborted
= true;
1815 /* See completer.h. */
1818 completion_find_completion_word (completion_tracker
&tracker
, const char *text
,
1821 size_t point
= strlen (text
);
1823 complete_line_internal (tracker
, NULL
, text
, point
, handle_brkchars
);
1825 if (tracker
.use_custom_word_point ())
1827 gdb_assert (tracker
.custom_word_point () > 0);
1828 *quote_char
= tracker
.quote_char ();
1829 return text
+ tracker
.custom_word_point ();
1832 gdb_rl_completion_word_info info
;
1834 info
.word_break_characters
= rl_completer_word_break_characters
;
1835 info
.quote_characters
= gdb_completer_quote_characters
;
1836 info
.basic_quote_characters
= rl_basic_quote_characters
;
1838 return gdb_rl_find_completion_word (&info
, quote_char
, NULL
, text
);
1841 /* See completer.h. */
1844 completion_tracker::recompute_lowest_common_denominator (const char *new_match
)
1846 if (m_lowest_common_denominator
== NULL
)
1848 /* We don't have a lowest common denominator yet, so simply take
1849 the whole NEW_MATCH as being it. */
1850 m_lowest_common_denominator
= xstrdup (new_match
);
1851 m_lowest_common_denominator_unique
= true;
1855 /* Find the common denominator between the currently-known
1856 lowest common denominator and NEW_MATCH. That becomes the
1857 new lowest common denominator. */
1861 (new_match
[i
] != '\0'
1862 && new_match
[i
] == m_lowest_common_denominator
[i
]);
1865 if (m_lowest_common_denominator
[i
] != new_match
[i
])
1867 m_lowest_common_denominator
[i
] = '\0';
1868 m_lowest_common_denominator_unique
= false;
1873 /* See completer.h. */
1876 completion_tracker::advance_custom_word_point_by (size_t len
)
1878 m_custom_word_point
+= len
;
1881 /* Build a new C string that is a copy of LCD with the whitespace of
1882 ORIG/ORIG_LEN preserved.
1884 Say the user is completing a symbol name, with spaces, like:
1888 and the resulting completion match is:
1892 we want to end up with an input line like:
1895 ^^^^^^^ => text from LCD [1], whitespace from ORIG preserved.
1896 ^^ => new text from LCD
1898 [1] - We must take characters from the LCD instead of the original
1899 text, since some completions want to change upper/lowercase. E.g.:
1905 "handle SIG[QUIT|etc.]"
1909 expand_preserving_ws (const char *orig
, size_t orig_len
,
1912 const char *p_orig
= orig
;
1913 const char *orig_end
= orig
+ orig_len
;
1914 const char *p_lcd
= lcd
;
1917 while (p_orig
< orig_end
)
1921 while (p_orig
< orig_end
&& *p_orig
== ' ')
1923 p_lcd
= skip_spaces (p_lcd
);
1927 /* Take characters from the LCD instead of the original
1928 text, since some completions change upper/lowercase.
1932 "handle SIG[QUIT|etc.]"
1940 while (*p_lcd
!= '\0')
1943 return xstrdup (res
.c_str ());
1946 /* See completer.h. */
1949 completion_tracker::build_completion_result (const char *text
,
1952 completion_list
&list
= m_entries_vec
; /* The completions. */
1957 /* +1 for the LCD, and +1 for NULL termination. */
1958 char **match_list
= XNEWVEC (char *, 1 + list
.size () + 1);
1960 /* Build replacement word, based on the LCD. */
1963 = expand_preserving_ws (text
, end
- start
,
1964 m_lowest_common_denominator
);
1966 if (m_lowest_common_denominator_unique
)
1968 /* We don't rely on readline appending the quote char as
1969 delimiter as then readline wouldn't append the ' ' after the
1971 char buf
[2] = { quote_char () };
1973 match_list
[0] = reconcat (match_list
[0], match_list
[0],
1974 buf
, (char *) NULL
);
1975 match_list
[1] = NULL
;
1977 /* If the tracker wants to, or we already have a space at the
1978 end of the match, tell readline to skip appending
1980 bool completion_suppress_append
1981 = (suppress_append_ws ()
1982 || match_list
[0][strlen (match_list
[0]) - 1] == ' ');
1984 return completion_result (match_list
, 1, completion_suppress_append
);
1990 for (ix
= 0; ix
< list
.size (); ++ix
)
1991 match_list
[ix
+ 1] = list
[ix
].release ();
1992 match_list
[ix
+ 1] = NULL
;
1994 return completion_result (match_list
, list
.size (), false);
1998 /* See completer.h */
2000 completion_result::completion_result ()
2001 : match_list (NULL
), number_matches (0),
2002 completion_suppress_append (false)
2005 /* See completer.h */
2007 completion_result::completion_result (char **match_list_
,
2008 size_t number_matches_
,
2009 bool completion_suppress_append_
)
2010 : match_list (match_list_
),
2011 number_matches (number_matches_
),
2012 completion_suppress_append (completion_suppress_append_
)
2015 /* See completer.h */
2017 completion_result::~completion_result ()
2019 reset_match_list ();
2022 /* See completer.h */
2024 completion_result::completion_result (completion_result
&&rhs
)
2029 reset_match_list ();
2030 match_list
= rhs
.match_list
;
2031 rhs
.match_list
= NULL
;
2032 number_matches
= rhs
.number_matches
;
2033 rhs
.number_matches
= 0;
2036 /* See completer.h */
2039 completion_result::release_match_list ()
2041 char **ret
= match_list
;
2046 /* See completer.h */
2049 completion_result::sort_match_list ()
2051 if (number_matches
> 1)
2053 /* Element 0 is special (it's the common prefix), leave it
2055 std::sort (&match_list
[1],
2056 &match_list
[number_matches
+ 1],
2061 /* See completer.h */
2064 completion_result::reset_match_list ()
2066 if (match_list
!= NULL
)
2068 for (char **p
= match_list
; *p
!= NULL
; p
++)
2075 /* Helper for gdb_rl_attempted_completion_function, which does most of
2076 the work. This is called by readline to build the match list array
2077 and to determine the lowest common denominator. The real matches
2078 list starts at match[1], while match[0] is the slot holding
2079 readline's idea of the lowest common denominator of all matches,
2080 which is what readline replaces the completion "word" with.
2082 TEXT is the caller's idea of the "word" we are looking at, as
2083 computed in the handle_brkchars phase.
2085 START is the offset from RL_LINE_BUFFER where TEXT starts. END is
2086 the offset from RL_LINE_BUFFER where TEXT ends (i.e., where
2089 You should thus pretend that the line ends at END (relative to
2092 RL_LINE_BUFFER contains the entire text of the line. RL_POINT is
2093 the offset in that line of the cursor. You should pretend that the
2096 Returns NULL if there are no completions. */
2099 gdb_rl_attempted_completion_function_throw (const char *text
, int start
, int end
)
2101 /* Completers that provide a custom word point in the
2102 handle_brkchars phase also compute their completions then.
2103 Completers that leave the completion word handling to readline
2104 must be called twice. If rl_point (i.e., END) is at column 0,
2105 then readline skips the handle_brkchars phase, and so we create a
2106 tracker now in that case too. */
2107 if (end
== 0 || !current_completion
.tracker
->use_custom_word_point ())
2109 delete current_completion
.tracker
;
2110 current_completion
.tracker
= new completion_tracker ();
2112 complete_line (*current_completion
.tracker
, text
,
2113 rl_line_buffer
, rl_point
);
2116 completion_tracker
&tracker
= *current_completion
.tracker
;
2118 completion_result result
2119 = tracker
.build_completion_result (text
, start
, end
);
2121 rl_completion_suppress_append
= result
.completion_suppress_append
;
2122 return result
.release_match_list ();
2125 /* Function installed as "rl_attempted_completion_function" readline
2126 hook. Wrapper around gdb_rl_attempted_completion_function_throw
2127 that catches C++ exceptions, which can't cross readline. */
2130 gdb_rl_attempted_completion_function (const char *text
, int start
, int end
)
2132 /* Restore globals that might have been tweaked in
2133 gdb_completion_word_break_characters. */
2134 rl_basic_quote_characters
= gdb_org_rl_basic_quote_characters
;
2136 /* If we end up returning NULL, either on error, or simple because
2137 there are no matches, inhibit readline's default filename
2139 rl_attempted_completion_over
= 1;
2141 /* If the handle_brkchars phase was aborted, don't try
2143 if (current_completion
.aborted
)
2148 return gdb_rl_attempted_completion_function_throw (text
, start
, end
);
2150 CATCH (ex
, RETURN_MASK_ALL
)
2158 /* Skip over the possibly quoted word STR (as defined by the quote
2159 characters QUOTECHARS and the word break characters BREAKCHARS).
2160 Returns pointer to the location after the "word". If either
2161 QUOTECHARS or BREAKCHARS is NULL, use the same values used by the
2165 skip_quoted_chars (const char *str
, const char *quotechars
,
2166 const char *breakchars
)
2168 char quote_char
= '\0';
2171 if (quotechars
== NULL
)
2172 quotechars
= gdb_completer_quote_characters
;
2174 if (breakchars
== NULL
)
2175 breakchars
= current_language
->la_word_break_characters();
2177 for (scan
= str
; *scan
!= '\0'; scan
++)
2179 if (quote_char
!= '\0')
2181 /* Ignore everything until the matching close quote char. */
2182 if (*scan
== quote_char
)
2184 /* Found matching close quote. */
2189 else if (strchr (quotechars
, *scan
))
2191 /* Found start of a quoted string. */
2194 else if (strchr (breakchars
, *scan
))
2203 /* Skip over the possibly quoted word STR (as defined by the quote
2204 characters and word break characters used by the completer).
2205 Returns pointer to the location after the "word". */
2208 skip_quoted (const char *str
)
2210 return skip_quoted_chars (str
, NULL
, NULL
);
2213 /* Return a message indicating that the maximum number of completions
2214 has been reached and that there may be more. */
2217 get_max_completions_reached_message (void)
2219 return _("*** List may be truncated, max-completions reached. ***");
2222 /* GDB replacement for rl_display_match_list.
2223 Readline doesn't provide a clean interface for TUI(curses).
2224 A hack previously used was to send readline's rl_outstream through a pipe
2225 and read it from the event loop. Bleah. IWBN if readline abstracted
2226 away all the necessary bits, and this is what this code does. It
2227 replicates the parts of readline we need and then adds an abstraction
2228 layer, currently implemented as struct match_list_displayer, so that both
2229 CLI and TUI can use it. We copy all this readline code to minimize
2230 GDB-specific mods to readline. Once this code performs as desired then
2231 we can submit it to the readline maintainers.
2233 N.B. A lot of the code is the way it is in order to minimize differences
2234 from readline's copy. */
2236 /* Not supported here. */
2237 #undef VISIBLE_STATS
2239 #if defined (HANDLE_MULTIBYTE)
2240 #define MB_INVALIDCH(x) ((x) == (size_t)-1 || (x) == (size_t)-2)
2241 #define MB_NULLWCH(x) ((x) == 0)
2244 #define ELLIPSIS_LEN 3
2246 /* gdb version of readline/complete.c:get_y_or_n.
2247 'y' -> returns 1, and 'n' -> returns 0.
2248 Also supported: space == 'y', RUBOUT == 'n', ctrl-g == start over.
2249 If FOR_PAGER is non-zero, then also supported are:
2250 NEWLINE or RETURN -> returns 2, and 'q' -> returns 0. */
2253 gdb_get_y_or_n (int for_pager
, const struct match_list_displayer
*displayer
)
2259 RL_SETSTATE (RL_STATE_MOREINPUT
);
2260 c
= displayer
->read_key (displayer
);
2261 RL_UNSETSTATE (RL_STATE_MOREINPUT
);
2263 if (c
== 'y' || c
== 'Y' || c
== ' ')
2265 if (c
== 'n' || c
== 'N' || c
== RUBOUT
)
2267 if (c
== ABORT_CHAR
|| c
< 0)
2269 /* Readline doesn't erase_entire_line here, but without it the
2270 --More-- prompt isn't erased and neither is the text entered
2271 thus far redisplayed. */
2272 displayer
->erase_entire_line (displayer
);
2273 /* Note: The arguments to rl_abort are ignored. */
2276 if (for_pager
&& (c
== NEWLINE
|| c
== RETURN
))
2278 if (for_pager
&& (c
== 'q' || c
== 'Q'))
2280 displayer
->beep (displayer
);
2284 /* Pager function for tab-completion.
2285 This is based on readline/complete.c:_rl_internal_pager.
2286 LINES is the number of lines of output displayed thus far.
2288 -1 -> user pressed 'n' or equivalent,
2289 0 -> user pressed 'y' or equivalent,
2290 N -> user pressed NEWLINE or equivalent and N is LINES - 1. */
2293 gdb_display_match_list_pager (int lines
,
2294 const struct match_list_displayer
*displayer
)
2298 displayer
->puts (displayer
, "--More--");
2299 displayer
->flush (displayer
);
2300 i
= gdb_get_y_or_n (1, displayer
);
2301 displayer
->erase_entire_line (displayer
);
2310 /* Return non-zero if FILENAME is a directory.
2311 Based on readline/complete.c:path_isdir. */
2314 gdb_path_isdir (const char *filename
)
2318 return (stat (filename
, &finfo
) == 0 && S_ISDIR (finfo
.st_mode
));
2321 /* Return the portion of PATHNAME that should be output when listing
2322 possible completions. If we are hacking filename completion, we
2323 are only interested in the basename, the portion following the
2324 final slash. Otherwise, we return what we were passed. Since
2325 printing empty strings is not very informative, if we're doing
2326 filename completion, and the basename is the empty string, we look
2327 for the previous slash and return the portion following that. If
2328 there's no previous slash, we just return what we were passed.
2330 Based on readline/complete.c:printable_part. */
2333 gdb_printable_part (char *pathname
)
2337 if (rl_filename_completion_desired
== 0) /* don't need to do anything */
2340 temp
= strrchr (pathname
, '/');
2341 #if defined (__MSDOS__)
2342 if (temp
== 0 && ISALPHA ((unsigned char)pathname
[0]) && pathname
[1] == ':')
2343 temp
= pathname
+ 1;
2346 if (temp
== 0 || *temp
== '\0')
2348 /* If the basename is NULL, we might have a pathname like '/usr/src/'.
2349 Look for a previous slash and, if one is found, return the portion
2350 following that slash. If there's no previous slash, just return the
2351 pathname we were passed. */
2352 else if (temp
[1] == '\0')
2354 for (x
= temp
- 1; x
> pathname
; x
--)
2357 return ((*x
== '/') ? x
+ 1 : pathname
);
2363 /* Compute width of STRING when displayed on screen by print_filename.
2364 Based on readline/complete.c:fnwidth. */
2367 gdb_fnwidth (const char *string
)
2370 #if defined (HANDLE_MULTIBYTE)
2376 left
= strlen (string
) + 1;
2377 memset (&ps
, 0, sizeof (mbstate_t));
2383 if (CTRL_CHAR (string
[pos
]) || string
[pos
] == RUBOUT
)
2390 #if defined (HANDLE_MULTIBYTE)
2391 clen
= mbrtowc (&wc
, string
+ pos
, left
- pos
, &ps
);
2392 if (MB_INVALIDCH (clen
))
2396 memset (&ps
, 0, sizeof (mbstate_t));
2398 else if (MB_NULLWCH (clen
))
2404 width
+= (w
>= 0) ? w
: 1;
2416 /* Print TO_PRINT, one matching completion.
2417 PREFIX_BYTES is number of common prefix bytes.
2418 Based on readline/complete.c:fnprint. */
2421 gdb_fnprint (const char *to_print
, int prefix_bytes
,
2422 const struct match_list_displayer
*displayer
)
2426 #if defined (HANDLE_MULTIBYTE)
2433 end
= to_print
+ strlen (to_print
) + 1;
2434 memset (&ps
, 0, sizeof (mbstate_t));
2439 /* Don't print only the ellipsis if the common prefix is one of the
2440 possible completions */
2441 if (to_print
[prefix_bytes
] == '\0')
2448 ellipsis
= (to_print
[prefix_bytes
] == '.') ? '_' : '.';
2449 for (w
= 0; w
< ELLIPSIS_LEN
; w
++)
2450 displayer
->putch (displayer
, ellipsis
);
2451 printed_len
= ELLIPSIS_LEN
;
2454 s
= to_print
+ prefix_bytes
;
2459 displayer
->putch (displayer
, '^');
2460 displayer
->putch (displayer
, UNCTRL (*s
));
2463 #if defined (HANDLE_MULTIBYTE)
2464 memset (&ps
, 0, sizeof (mbstate_t));
2467 else if (*s
== RUBOUT
)
2469 displayer
->putch (displayer
, '^');
2470 displayer
->putch (displayer
, '?');
2473 #if defined (HANDLE_MULTIBYTE)
2474 memset (&ps
, 0, sizeof (mbstate_t));
2479 #if defined (HANDLE_MULTIBYTE)
2480 tlen
= mbrtowc (&wc
, s
, end
- s
, &ps
);
2481 if (MB_INVALIDCH (tlen
))
2485 memset (&ps
, 0, sizeof (mbstate_t));
2487 else if (MB_NULLWCH (tlen
))
2492 width
= (w
>= 0) ? w
: 1;
2494 for (w
= 0; w
< tlen
; ++w
)
2495 displayer
->putch (displayer
, s
[w
]);
2497 printed_len
+= width
;
2499 displayer
->putch (displayer
, *s
);
2509 /* Output TO_PRINT to rl_outstream. If VISIBLE_STATS is defined and we
2510 are using it, check for and output a single character for `special'
2511 filenames. Return the number of characters we output.
2512 Based on readline/complete.c:print_filename. */
2515 gdb_print_filename (char *to_print
, char *full_pathname
, int prefix_bytes
,
2516 const struct match_list_displayer
*displayer
)
2518 int printed_len
, extension_char
, slen
, tlen
;
2519 char *s
, c
, *new_full_pathname
;
2521 extern int _rl_complete_mark_directories
;
2524 printed_len
= gdb_fnprint (to_print
, prefix_bytes
, displayer
);
2526 #if defined (VISIBLE_STATS)
2527 if (rl_filename_completion_desired
&& (rl_visible_stats
|| _rl_complete_mark_directories
))
2529 if (rl_filename_completion_desired
&& _rl_complete_mark_directories
)
2532 /* If to_print != full_pathname, to_print is the basename of the
2533 path passed. In this case, we try to expand the directory
2534 name before checking for the stat character. */
2535 if (to_print
!= full_pathname
)
2537 /* Terminate the directory name. */
2539 to_print
[-1] = '\0';
2541 /* If setting the last slash in full_pathname to a NUL results in
2542 full_pathname being the empty string, we are trying to complete
2543 files in the root directory. If we pass a null string to the
2544 bash directory completion hook, for example, it will expand it
2545 to the current directory. We just want the `/'. */
2546 if (full_pathname
== 0 || *full_pathname
== 0)
2548 else if (full_pathname
[0] != '/')
2550 else if (full_pathname
[1] == 0)
2551 dn
= "//"; /* restore trailing slash to `//' */
2552 else if (full_pathname
[1] == '/' && full_pathname
[2] == 0)
2553 dn
= "/"; /* don't turn /// into // */
2556 s
= tilde_expand (dn
);
2557 if (rl_directory_completion_hook
)
2558 (*rl_directory_completion_hook
) (&s
);
2561 tlen
= strlen (to_print
);
2562 new_full_pathname
= (char *)xmalloc (slen
+ tlen
+ 2);
2563 strcpy (new_full_pathname
, s
);
2564 if (s
[slen
- 1] == '/')
2567 new_full_pathname
[slen
] = '/';
2568 new_full_pathname
[slen
] = '/';
2569 strcpy (new_full_pathname
+ slen
+ 1, to_print
);
2571 #if defined (VISIBLE_STATS)
2572 if (rl_visible_stats
)
2573 extension_char
= stat_char (new_full_pathname
);
2576 if (gdb_path_isdir (new_full_pathname
))
2577 extension_char
= '/';
2579 xfree (new_full_pathname
);
2584 s
= tilde_expand (full_pathname
);
2585 #if defined (VISIBLE_STATS)
2586 if (rl_visible_stats
)
2587 extension_char
= stat_char (s
);
2590 if (gdb_path_isdir (s
))
2591 extension_char
= '/';
2597 displayer
->putch (displayer
, extension_char
);
2605 /* GDB version of readline/complete.c:complete_get_screenwidth. */
2608 gdb_complete_get_screenwidth (const struct match_list_displayer
*displayer
)
2610 /* Readline has other stuff here which it's not clear we need. */
2611 return displayer
->width
;
2614 extern int _rl_completion_prefix_display_length
;
2615 extern int _rl_print_completions_horizontally
;
2617 EXTERN_C
int _rl_qsort_string_compare (const void *, const void *);
2618 typedef int QSFUNC (const void *, const void *);
2620 /* GDB version of readline/complete.c:rl_display_match_list.
2621 See gdb_display_match_list for a description of MATCHES, LEN, MAX.
2622 Returns non-zero if all matches are displayed. */
2625 gdb_display_match_list_1 (char **matches
, int len
, int max
,
2626 const struct match_list_displayer
*displayer
)
2628 int count
, limit
, printed_len
, lines
, cols
;
2629 int i
, j
, k
, l
, common_length
, sind
;
2631 int page_completions
= displayer
->height
!= INT_MAX
&& pagination_enabled
;
2633 /* Find the length of the prefix common to all items: length as displayed
2634 characters (common_length) and as a byte index into the matches (sind) */
2635 common_length
= sind
= 0;
2636 if (_rl_completion_prefix_display_length
> 0)
2638 t
= gdb_printable_part (matches
[0]);
2639 temp
= strrchr (t
, '/');
2640 common_length
= temp
? gdb_fnwidth (temp
) : gdb_fnwidth (t
);
2641 sind
= temp
? strlen (temp
) : strlen (t
);
2643 if (common_length
> _rl_completion_prefix_display_length
&& common_length
> ELLIPSIS_LEN
)
2644 max
-= common_length
- ELLIPSIS_LEN
;
2646 common_length
= sind
= 0;
2649 /* How many items of MAX length can we fit in the screen window? */
2650 cols
= gdb_complete_get_screenwidth (displayer
);
2653 if (limit
!= 1 && (limit
* max
== cols
))
2656 /* If cols == 0, limit will end up -1 */
2657 if (cols
< displayer
->width
&& limit
< 0)
2660 /* Avoid a possible floating exception. If max > cols,
2661 limit will be 0 and a divide-by-zero fault will result. */
2665 /* How many iterations of the printing loop? */
2666 count
= (len
+ (limit
- 1)) / limit
;
2668 /* Watch out for special case. If LEN is less than LIMIT, then
2669 just do the inner printing loop.
2670 0 < len <= limit implies count = 1. */
2672 /* Sort the items if they are not already sorted. */
2673 if (rl_ignore_completion_duplicates
== 0 && rl_sort_completion_matches
)
2674 qsort (matches
+ 1, len
, sizeof (char *), (QSFUNC
*)_rl_qsort_string_compare
);
2676 displayer
->crlf (displayer
);
2679 if (_rl_print_completions_horizontally
== 0)
2681 /* Print the sorted items, up-and-down alphabetically, like ls. */
2682 for (i
= 1; i
<= count
; i
++)
2684 for (j
= 0, l
= i
; j
< limit
; j
++)
2686 if (l
> len
|| matches
[l
] == 0)
2690 temp
= gdb_printable_part (matches
[l
]);
2691 printed_len
= gdb_print_filename (temp
, matches
[l
], sind
,
2695 for (k
= 0; k
< max
- printed_len
; k
++)
2696 displayer
->putch (displayer
, ' ');
2700 displayer
->crlf (displayer
);
2702 if (page_completions
&& lines
>= (displayer
->height
- 1) && i
< count
)
2704 lines
= gdb_display_match_list_pager (lines
, displayer
);
2712 /* Print the sorted items, across alphabetically, like ls -x. */
2713 for (i
= 1; matches
[i
]; i
++)
2715 temp
= gdb_printable_part (matches
[i
]);
2716 printed_len
= gdb_print_filename (temp
, matches
[i
], sind
, displayer
);
2717 /* Have we reached the end of this line? */
2720 if (i
&& (limit
> 1) && (i
% limit
) == 0)
2722 displayer
->crlf (displayer
);
2724 if (page_completions
&& lines
>= displayer
->height
- 1)
2726 lines
= gdb_display_match_list_pager (lines
, displayer
);
2732 for (k
= 0; k
< max
- printed_len
; k
++)
2733 displayer
->putch (displayer
, ' ');
2736 displayer
->crlf (displayer
);
2742 /* Utility for displaying completion list matches, used by both CLI and TUI.
2744 MATCHES is the list of strings, in argv format, LEN is the number of
2745 strings in MATCHES, and MAX is the length of the longest string in
2749 gdb_display_match_list (char **matches
, int len
, int max
,
2750 const struct match_list_displayer
*displayer
)
2752 /* Readline will never call this if complete_line returned NULL. */
2753 gdb_assert (max_completions
!= 0);
2755 /* complete_line will never return more than this. */
2756 if (max_completions
> 0)
2757 gdb_assert (len
<= max_completions
);
2759 if (rl_completion_query_items
> 0 && len
>= rl_completion_query_items
)
2763 /* We can't use *query here because they wait for <RET> which is
2764 wrong here. This follows the readline version as closely as possible
2765 for compatibility's sake. See readline/complete.c. */
2767 displayer
->crlf (displayer
);
2769 xsnprintf (msg
, sizeof (msg
),
2770 "Display all %d possibilities? (y or n)", len
);
2771 displayer
->puts (displayer
, msg
);
2772 displayer
->flush (displayer
);
2774 if (gdb_get_y_or_n (0, displayer
) == 0)
2776 displayer
->crlf (displayer
);
2781 if (gdb_display_match_list_1 (matches
, len
, max
, displayer
))
2783 /* Note: MAX_COMPLETIONS may be -1 or zero, but LEN is always > 0. */
2784 if (len
== max_completions
)
2786 /* The maximum number of completions has been reached. Warn the user
2787 that there may be more. */
2788 const char *message
= get_max_completions_reached_message ();
2790 displayer
->puts (displayer
, message
);
2791 displayer
->crlf (displayer
);
2797 _initialize_completer (void)
2799 add_setshow_zuinteger_unlimited_cmd ("max-completions", no_class
,
2800 &max_completions
, _("\
2801 Set maximum number of completion candidates."), _("\
2802 Show maximum number of completion candidates."), _("\
2803 Use this to limit the number of candidates considered\n\
2804 during completion. Specifying \"unlimited\" or -1\n\
2805 disables limiting. Note that setting either no limit or\n\
2806 a very large limit can make completion slow."),
2807 NULL
, NULL
, &setlist
, &showlist
);