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"
32 #include "cli/cli-decode.h"
34 /* FIXME: This is needed because of lookup_cmd_1 (). We should be
35 calling a hook instead so we eliminate the CLI dependency. */
38 /* Needed for rl_completer_word_break_characters() and for
39 rl_filename_completion_function. */
40 #include "readline/readline.h"
42 /* readline defines this. */
45 #include "completer.h"
47 /* An enumeration of the various things a user might
48 attempt to complete for a location. */
50 enum explicit_location_match_type
52 /* The filename of a source file. */
55 /* The name of a function or method. */
58 /* The name of a label. */
62 /* Prototypes for local functions. */
64 char *line_completion_function (const char *text, int matches,
68 /* readline uses the word breaks for two things:
69 (1) In figuring out where to point the TEXT parameter to the
70 rl_completion_entry_function. Since we don't use TEXT for much,
71 it doesn't matter a lot what the word breaks are for this purpose,
72 but it does affect how much stuff M-? lists.
73 (2) If one of the matches contains a word break character, readline
74 will quote it. That's why we switch between
75 current_language->la_word_break_characters() and
76 gdb_completer_command_word_break_characters. I'm not sure when
77 we need this behavior (perhaps for funky characters in C++
80 /* Variables which are necessary for fancy command line editing. */
82 /* When completing on command names, we remove '-' from the list of
83 word break characters, since we use it in command names. If the
84 readline library sees one in any of the current completion strings,
85 it thinks that the string needs to be quoted and automatically
86 supplies a leading quote. */
87 static const char gdb_completer_command_word_break_characters[] =
88 " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,";
90 /* When completing on file names, we remove from the list of word
91 break characters any characters that are commonly used in file
92 names, such as '-', '+', '~', etc. Otherwise, readline displays
93 incorrect completion candidates. */
94 /* MS-DOS and MS-Windows use colon as part of the drive spec, and most
95 programs support @foo style response files. */
96 static const char gdb_completer_file_name_break_characters[] =
97 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
103 /* Characters that can be used to quote completion strings. Note that
104 we can't include '"' because the gdb C parser treats such quoted
105 sequences as strings. */
106 static const char gdb_completer_quote_characters[] = "'";
108 /* Accessor for some completer data that may interest other files. */
111 get_gdb_completer_quote_characters (void)
113 return gdb_completer_quote_characters;
116 /* Line completion interface function for readline. */
119 readline_line_completion_function (const char *text, int matches)
121 return line_completion_function (text, matches,
122 rl_line_buffer, rl_point);
125 /* This can be used for functions which don't want to complete on
126 symbols but don't want to complete on anything else either. */
128 noop_completer (struct cmd_list_element *ignore,
129 const char *text, const char *prefix)
134 /* Complete on filenames. */
136 filename_completer (struct cmd_list_element *ignore,
137 const char *text, const char *word)
140 VEC (char_ptr) *return_val = NULL;
147 p = rl_filename_completion_function (text, subsequent_name);
150 /* We need to set subsequent_name to a non-zero value before the
151 continue line below, because otherwise, if the first file
152 seen by GDB is a backup file whose name ends in a `~', we
153 will loop indefinitely. */
155 /* Like emacs, don't complete on old versions. Especially
156 useful in the "source" command. */
157 if (p[strlen (p) - 1] == '~')
164 /* Return exactly p. */
166 else if (word > text)
168 /* Return some portion of p. */
169 q = (char *) xmalloc (strlen (p) + 5);
170 strcpy (q, p + (word - text));
175 /* Return some of TEXT plus p. */
176 q = (char *) xmalloc (strlen (p) + (text - word) + 5);
177 strncpy (q, word, text - word);
178 q[text - word] = '\0';
182 VEC_safe_push (char_ptr, return_val, q);
185 /* There is no way to do this just long enough to affect quote
186 inserting without also affecting the next completion. This
187 should be fixed in readline. FIXME. */
188 /* Ensure that readline does the right thing
189 with respect to inserting quotes. */
190 rl_completer_word_break_characters = "";
195 /* Complete on linespecs, which might be of two possible forms:
201 This is intended to be used in commands that set breakpoints
204 static VEC (char_ptr) *
205 linespec_location_completer (struct cmd_list_element *ignore,
206 const char *text, const char *word)
208 int n_syms, n_files, ix;
209 VEC (char_ptr) *fn_list = NULL;
210 VEC (char_ptr) *list = NULL;
213 int quoted = *text == '\'' || *text == '"';
214 int quote_char = '\0';
215 const char *colon = NULL;
216 char *file_to_match = NULL;
217 const char *symbol_start = text;
218 const char *orig_text = text;
221 /* Do we have an unquoted colon, as in "break foo.c:bar"? */
222 for (p = text; *p != '\0'; ++p)
224 if (*p == '\\' && p[1] == '\'')
226 else if (*p == '\'' || *p == '"')
230 while (*p != '\0' && *p != quote_found)
232 if (*p == '\\' && p[1] == quote_found)
237 if (*p == quote_found)
240 break; /* Hit the end of text. */
242 #if HAVE_DOS_BASED_FILE_SYSTEM
243 /* If we have a DOS-style absolute file name at the beginning of
244 TEXT, and the colon after the drive letter is the only colon
245 we found, pretend the colon is not there. */
246 else if (p < text + 3 && *p == ':' && p == text + 1 + quoted)
249 else if (*p == ':' && !colon)
252 symbol_start = p + 1;
254 else if (strchr (current_language->la_word_break_characters(), *p))
255 symbol_start = p + 1;
260 text_len = strlen (text);
262 /* Where is the file name? */
267 file_to_match = (char *) xmalloc (colon - text + 1);
268 strncpy (file_to_match, text, colon - text);
269 file_to_match[colon - text] = '\0';
270 /* Remove trailing colons and quotes from the file name. */
271 for (s = file_to_match + (colon - text);
274 if (*s == ':' || *s == quote_char)
277 /* If the text includes a colon, they want completion only on a
278 symbol name after the colon. Otherwise, we need to complete on
279 symbols as well as on files. */
282 list = make_file_symbol_completion_list (symbol_start, word,
284 xfree (file_to_match);
288 list = make_symbol_completion_list (symbol_start, word);
289 /* If text includes characters which cannot appear in a file
290 name, they cannot be asking for completion on files. */
292 gdb_completer_file_name_break_characters) == text_len)
293 fn_list = make_source_files_completion_list (text, text);
296 n_syms = VEC_length (char_ptr, list);
297 n_files = VEC_length (char_ptr, fn_list);
299 /* Catenate fn_list[] onto the end of list[]. */
302 VEC_free (char_ptr, list); /* Paranoia. */
310 for (ix = 0; VEC_iterate (char_ptr, fn_list, ix, fn); ++ix)
311 VEC_safe_push (char_ptr, list, fn);
312 VEC_free (char_ptr, fn_list);
315 if (n_syms && n_files)
323 /* If we only have file names as possible completion, we should
324 bring them in sync with what rl_complete expects. The
325 problem is that if the user types "break /foo/b TAB", and the
326 possible completions are "/foo/bar" and "/foo/baz"
327 rl_complete expects us to return "bar" and "baz", without the
328 leading directories, as possible completions, because `word'
329 starts at the "b". But we ignore the value of `word' when we
330 call make_source_files_completion_list above (because that
331 would not DTRT when the completion results in both symbols
332 and file names), so make_source_files_completion_list returns
333 the full "/foo/bar" and "/foo/baz" strings. This produces
334 wrong results when, e.g., there's only one possible
335 completion, because rl_complete will prepend "/foo/" to each
336 candidate completion. The loop below removes that leading
338 for (ix = 0; VEC_iterate (char_ptr, list, ix, fn); ++ix)
340 memmove (fn, fn + (word - text),
341 strlen (fn) + 1 - (word - text));
346 /* No completions at all. As the final resort, try completing
347 on the entire text as a symbol. */
348 list = make_symbol_completion_list (orig_text, word);
354 /* A helper function to collect explicit location matches for the given
355 LOCATION, which is attempting to match on WORD. */
357 static VEC (char_ptr) *
358 collect_explicit_location_matches (struct event_location *location,
359 enum explicit_location_match_type what,
362 VEC (char_ptr) *matches = NULL;
363 const struct explicit_location *explicit_loc
364 = get_explicit_location (location);
370 const char *text = (explicit_loc->source_filename == NULL
371 ? "" : explicit_loc->source_filename);
373 matches = make_source_files_completion_list (text, word);
379 const char *text = (explicit_loc->function_name == NULL
380 ? "" : explicit_loc->function_name);
382 if (explicit_loc->source_filename != NULL)
384 const char *filename = explicit_loc->source_filename;
386 matches = make_file_symbol_completion_list (text, word, filename);
389 matches = make_symbol_completion_list (text, word);
398 gdb_assert_not_reached ("unhandled explicit_location_match_type");
404 /* A convenience macro to (safely) back up P to the previous word. */
407 backup_text_ptr (const char *p, const char *text)
409 while (p > text && isspace (*p))
411 for (; p > text && !isspace (p[-1]); --p)
417 /* A completer function for explicit locations. This function
418 completes both options ("-source", "-line", etc) and values. */
420 static VEC (char_ptr) *
421 explicit_location_completer (struct cmd_list_element *ignore,
422 struct event_location *location,
423 const char *text, const char *word)
426 VEC (char_ptr) *matches = NULL;
428 /* Find the beginning of the word. This is necessary because
429 we need to know if we are completing an option name or value. We
430 don't get the leading '-' from the completer. */
431 p = backup_text_ptr (word, text);
435 /* Completing on option name. */
436 static const char *const keywords[] =
445 /* Skip over the '-'. */
448 return complete_on_enum (keywords, p, p);
452 /* Completing on value (or unknown). Get the previous word to see what
453 the user is completing on. */
455 const char *new_word, *end;
456 enum explicit_location_match_type what;
457 struct explicit_location *explicit_loc
458 = get_explicit_location (location);
460 /* Backup P to the previous word, which should be the option
461 the user is attempting to complete. */
464 p = backup_text_ptr (p, text);
467 if (strncmp (p, "-source", len) == 0)
470 new_word = explicit_loc->source_filename + offset;
472 else if (strncmp (p, "-function", len) == 0)
474 what = MATCH_FUNCTION;
475 new_word = explicit_loc->function_name + offset;
477 else if (strncmp (p, "-label", len) == 0)
480 new_word = explicit_loc->label_name + offset;
484 /* The user isn't completing on any valid option name,
485 e.g., "break -source foo.c [tab]". */
489 /* If the user hasn't entered a search expression, e.g.,
490 "break -function <TAB><TAB>", new_word will be NULL, but
491 search routines require non-NULL search words. */
492 if (new_word == NULL)
495 /* Now gather matches */
496 matches = collect_explicit_location_matches (location, what, new_word);
502 /* A completer for locations. */
505 location_completer (struct cmd_list_element *ignore,
506 const char *text, const char *word)
508 VEC (char_ptr) *matches = NULL;
509 const char *copy = text;
511 event_location_up location = string_to_explicit_location (©,
514 if (location != NULL)
515 matches = explicit_location_completer (ignore, location.get (),
519 /* This is an address or linespec location.
520 Right now both of these are handled by the (old) linespec
522 matches = linespec_location_completer (ignore, text, word);
528 /* Helper for expression_completer which recursively adds field and
529 method names from TYPE, a struct or union type, to the array
532 add_struct_fields (struct type *type, VEC (char_ptr) **output,
533 char *fieldname, int namelen)
536 int computed_type_name = 0;
537 const char *type_name = NULL;
539 type = check_typedef (type);
540 for (i = 0; i < TYPE_NFIELDS (type); ++i)
542 if (i < TYPE_N_BASECLASSES (type))
543 add_struct_fields (TYPE_BASECLASS (type, i),
544 output, fieldname, namelen);
545 else if (TYPE_FIELD_NAME (type, i))
547 if (TYPE_FIELD_NAME (type, i)[0] != '\0')
549 if (! strncmp (TYPE_FIELD_NAME (type, i),
551 VEC_safe_push (char_ptr, *output,
552 xstrdup (TYPE_FIELD_NAME (type, i)));
554 else if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_UNION)
556 /* Recurse into anonymous unions. */
557 add_struct_fields (TYPE_FIELD_TYPE (type, i),
558 output, fieldname, namelen);
563 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)
565 const char *name = TYPE_FN_FIELDLIST_NAME (type, i);
567 if (name && ! strncmp (name, fieldname, namelen))
569 if (!computed_type_name)
571 type_name = type_name_no_tag (type);
572 computed_type_name = 1;
574 /* Omit constructors from the completion list. */
575 if (!type_name || strcmp (type_name, name))
576 VEC_safe_push (char_ptr, *output, xstrdup (name));
581 /* Complete on expressions. Often this means completing on symbol
582 names, but some language parsers also have support for completing
585 expression_completer (struct cmd_list_element *ignore,
586 const char *text, const char *word)
588 struct type *type = NULL;
590 enum type_code code = TYPE_CODE_UNDEF;
592 /* Perform a tentative parse of the expression, to see whether a
593 field completion is required. */
597 type = parse_expression_for_completion (text, &fieldname, &code);
599 CATCH (except, RETURN_MASK_ERROR)
605 if (fieldname && type)
609 type = check_typedef (type);
610 if (TYPE_CODE (type) != TYPE_CODE_PTR && !TYPE_IS_REFERENCE (type))
612 type = TYPE_TARGET_TYPE (type);
615 if (TYPE_CODE (type) == TYPE_CODE_UNION
616 || TYPE_CODE (type) == TYPE_CODE_STRUCT)
618 int flen = strlen (fieldname);
619 VEC (char_ptr) *result = NULL;
621 add_struct_fields (type, &result, fieldname, flen);
626 else if (fieldname && code != TYPE_CODE_UNDEF)
628 VEC (char_ptr) *result;
629 struct cleanup *cleanup = make_cleanup (xfree, fieldname);
631 result = make_symbol_completion_type (fieldname, fieldname, code);
632 do_cleanups (cleanup);
637 /* Not ideal but it is what we used to do before... */
638 return linespec_location_completer (ignore, text, word);
641 /* See definition in completer.h. */
644 set_rl_completer_word_break_characters (const char *break_chars)
646 rl_completer_word_break_characters = (char *) break_chars;
649 /* See definition in completer.h. */
652 set_gdb_completion_word_break_characters (completer_ftype *fn)
654 const char *break_chars;
656 /* So far we are only interested in differentiating filename
657 completers from everything else. */
658 if (fn == filename_completer)
659 break_chars = gdb_completer_file_name_break_characters;
661 break_chars = gdb_completer_command_word_break_characters;
663 set_rl_completer_word_break_characters (break_chars);
666 /* Complete on symbols. */
669 symbol_completer (struct cmd_list_element *ignore,
670 const char *text, const char *word)
672 return make_symbol_completion_list (text, word);
675 /* Here are some useful test cases for completion. FIXME: These
676 should be put in the test suite. They should be tested with both
679 "show output-" "radix"
680 "show output" "-radix"
681 "p" ambiguous (commands starting with p--path, print, printf, etc.)
682 "p " ambiguous (all symbols)
683 "info t foo" no completions
684 "info t " no completions
685 "info t" ambiguous ("info target", "info terminal", etc.)
686 "info ajksdlfk" no completions
687 "info ajksdlfk " no completions
689 "info " ambiguous (all info commands)
690 "p \"a" no completions (string constant)
691 "p 'a" ambiguous (all symbols starting with a)
692 "p b-a" ambiguous (all symbols starting with a)
693 "p b-" ambiguous (all symbols)
694 "file Make" "file" (word break hard to screw up here)
695 "file ../gdb.stabs/we" "ird" (needs to not break word at slash)
704 complete_line_internal_reason;
707 /* Internal function used to handle completions.
710 TEXT is the caller's idea of the "word" we are looking at.
712 LINE_BUFFER is available to be looked at; it contains the entire
713 text of the line. POINT is the offset in that line of the cursor.
714 You should pretend that the line ends at POINT.
716 REASON is of type complete_line_internal_reason.
718 If REASON is handle_brkchars:
719 Preliminary phase, called by gdb_completion_word_break_characters
720 function, is used to determine the correct set of chars that are
721 word delimiters depending on the current command in line_buffer.
722 No completion list should be generated; the return value should be
723 NULL. This is checked by an assertion in that function.
725 If REASON is handle_completions:
726 Main phase, called by complete_line function, is used to get the list
727 of posible completions.
729 If REASON is handle_help:
730 Special case when completing a 'help' command. In this case,
731 once sub-command completions are exhausted, we simply return NULL.
734 static VEC (char_ptr) *
735 complete_line_internal (const char *text,
736 const char *line_buffer, int point,
737 complete_line_internal_reason reason)
739 VEC (char_ptr) *list = NULL;
742 int ignore_help_classes;
743 /* Pointer within tmp_command which corresponds to text. */
745 struct cmd_list_element *c, *result_list;
747 /* Choose the default set of word break characters to break
748 completions. If we later find out that we are doing completions
749 on command strings (as opposed to strings supplied by the
750 individual command completer functions, which can be any string)
751 then we will switch to the special word break set for command
752 strings, which leaves out the '-' character used in some
754 set_rl_completer_word_break_characters
755 (current_language->la_word_break_characters());
757 /* Decide whether to complete on a list of gdb commands or on
759 tmp_command = (char *) alloca (point + 1);
762 /* The help command should complete help aliases. */
763 ignore_help_classes = reason != handle_help;
765 strncpy (tmp_command, line_buffer, point);
766 tmp_command[point] = '\0';
767 /* Since text always contains some number of characters leading up
768 to point, we can find the equivalent position in tmp_command
769 by subtracting that many characters from the end of tmp_command. */
770 word = tmp_command + point - strlen (text);
774 /* An empty line we want to consider ambiguous; that is, it
775 could be any command. */
776 c = CMD_LIST_AMBIGUOUS;
781 c = lookup_cmd_1 (&p, cmdlist, &result_list, ignore_help_classes);
784 /* Move p up to the next interesting thing. */
785 while (*p == ' ' || *p == '\t')
792 /* It is an unrecognized command. So there are no
793 possible completions. */
796 else if (c == CMD_LIST_AMBIGUOUS)
800 /* lookup_cmd_1 advances p up to the first ambiguous thing, but
801 doesn't advance over that thing itself. Do so now. */
803 while (*q && (isalnum (*q) || *q == '-' || *q == '_'))
805 if (q != tmp_command + point)
807 /* There is something beyond the ambiguous
808 command, so there are no possible completions. For
809 example, "info t " or "info t foo" does not complete
810 to anything, because "info t" can be "info target" or
816 /* We're trying to complete on the command which was ambiguous.
817 This we can deal with. */
820 if (reason != handle_brkchars)
821 list = complete_on_cmdlist (*result_list->prefixlist, p,
822 word, ignore_help_classes);
826 if (reason != handle_brkchars)
827 list = complete_on_cmdlist (cmdlist, p, word,
828 ignore_help_classes);
830 /* Ensure that readline does the right thing with respect to
832 set_rl_completer_word_break_characters
833 (gdb_completer_command_word_break_characters);
838 /* We've recognized a full command. */
840 if (p == tmp_command + point)
842 /* There is no non-whitespace in the line beyond the
845 if (p[-1] == ' ' || p[-1] == '\t')
847 /* The command is followed by whitespace; we need to
848 complete on whatever comes after command. */
851 /* It is a prefix command; what comes after it is
852 a subcommand (e.g. "info "). */
853 if (reason != handle_brkchars)
854 list = complete_on_cmdlist (*c->prefixlist, p, word,
855 ignore_help_classes);
857 /* Ensure that readline does the right thing
858 with respect to inserting quotes. */
859 set_rl_completer_word_break_characters
860 (gdb_completer_command_word_break_characters);
862 else if (reason == handle_help)
866 if (reason != handle_brkchars)
867 list = complete_on_enum (c->enums, p, word);
868 set_rl_completer_word_break_characters
869 (gdb_completer_command_word_break_characters);
873 /* It is a normal command; what comes after it is
874 completed by the command's completer function. */
875 if (c->completer == filename_completer)
877 /* Many commands which want to complete on
878 file names accept several file names, as
879 in "run foo bar >>baz". So we don't want
880 to complete the entire text after the
881 command, just the last word. To this
882 end, we need to find the beginning of the
883 file name by starting at `word' and going
887 && strchr (gdb_completer_file_name_break_characters, p[-1]) == NULL;
890 set_rl_completer_word_break_characters
891 (gdb_completer_file_name_break_characters);
893 if (reason == handle_brkchars
894 && c->completer_handle_brkchars != NULL)
895 (*c->completer_handle_brkchars) (c, p, word);
896 if (reason != handle_brkchars && c->completer != NULL)
897 list = (*c->completer) (c, p, word);
902 /* The command is not followed by whitespace; we need to
903 complete on the command itself, e.g. "p" which is a
904 command itself but also can complete to "print", "ptype"
908 /* Find the command we are completing on. */
910 while (q > tmp_command)
912 if (isalnum (q[-1]) || q[-1] == '-' || q[-1] == '_')
918 if (reason != handle_brkchars)
919 list = complete_on_cmdlist (result_list, q, word,
920 ignore_help_classes);
922 /* Ensure that readline does the right thing
923 with respect to inserting quotes. */
924 set_rl_completer_word_break_characters
925 (gdb_completer_command_word_break_characters);
928 else if (reason == handle_help)
932 /* There is non-whitespace beyond the command. */
934 if (c->prefixlist && !c->allow_unknown)
936 /* It is an unrecognized subcommand of a prefix command,
937 e.g. "info adsfkdj". */
942 if (reason != handle_brkchars)
943 list = complete_on_enum (c->enums, p, word);
947 /* It is a normal command. */
948 if (c->completer == filename_completer)
950 /* See the commentary above about the specifics
951 of file-name completion. */
954 && strchr (gdb_completer_file_name_break_characters,
958 set_rl_completer_word_break_characters
959 (gdb_completer_file_name_break_characters);
961 if (reason == handle_brkchars
962 && c->completer_handle_brkchars != NULL)
963 (*c->completer_handle_brkchars) (c, p, word);
964 if (reason != handle_brkchars && c->completer != NULL)
965 list = (*c->completer) (c, p, word);
973 /* See completer.h. */
975 int max_completions = 200;
977 /* See completer.h. */
980 new_completion_tracker (void)
982 if (max_completions <= 0)
985 return htab_create_alloc (max_completions,
986 htab_hash_string, (htab_eq) streq,
987 NULL, xcalloc, xfree);
990 /* Cleanup routine to free a completion tracker and reset the pointer
994 free_completion_tracker (void *p)
996 completion_tracker_t *tracker_ptr = (completion_tracker_t *) p;
998 htab_delete (*tracker_ptr);
1002 /* See completer.h. */
1005 make_cleanup_free_completion_tracker (completion_tracker_t *tracker_ptr)
1007 if (*tracker_ptr == NULL)
1008 return make_cleanup (null_cleanup, NULL);
1010 return make_cleanup (free_completion_tracker, tracker_ptr);
1013 /* See completer.h. */
1015 enum maybe_add_completion_enum
1016 maybe_add_completion (completion_tracker_t tracker, char *name)
1020 if (max_completions < 0)
1021 return MAYBE_ADD_COMPLETION_OK;
1022 if (max_completions == 0)
1023 return MAYBE_ADD_COMPLETION_MAX_REACHED;
1025 gdb_assert (tracker != NULL);
1027 if (htab_elements (tracker) >= max_completions)
1028 return MAYBE_ADD_COMPLETION_MAX_REACHED;
1030 slot = htab_find_slot (tracker, name, INSERT);
1032 if (*slot != HTAB_EMPTY_ENTRY)
1033 return MAYBE_ADD_COMPLETION_DUPLICATE;
1037 return (htab_elements (tracker) < max_completions
1038 ? MAYBE_ADD_COMPLETION_OK
1039 : MAYBE_ADD_COMPLETION_OK_MAX_REACHED);
1043 throw_max_completions_reached_error (void)
1045 throw_error (MAX_COMPLETIONS_REACHED_ERROR, _("Max completions reached."));
1048 /* Generate completions all at once. Returns a vector of unique strings
1049 allocated with xmalloc. Returns NULL if there are no completions
1050 or if max_completions is 0. If max_completions is non-negative, this will
1051 return at most max_completions strings.
1053 TEXT is the caller's idea of the "word" we are looking at.
1055 LINE_BUFFER is available to be looked at; it contains the entire
1058 POINT is the offset in that line of the cursor. You
1059 should pretend that the line ends at POINT. */
1062 complete_line (const char *text, const char *line_buffer, int point)
1064 VEC (char_ptr) *list;
1065 VEC (char_ptr) *result = NULL;
1066 struct cleanup *cleanups;
1067 completion_tracker_t tracker;
1069 int ix, max_reached;
1071 if (max_completions == 0)
1073 list = complete_line_internal (text, line_buffer, point,
1074 handle_completions);
1075 if (max_completions < 0)
1078 tracker = new_completion_tracker ();
1079 cleanups = make_cleanup_free_completion_tracker (&tracker);
1080 make_cleanup_free_char_ptr_vec (list);
1082 /* Do a final test for too many completions. Individual completers may
1083 do some of this, but are not required to. Duplicates are also removed
1084 here. Otherwise the user is left scratching his/her head: readline and
1085 complete_command will remove duplicates, and if removal of duplicates
1086 there brings the total under max_completions the user may think gdb quit
1087 searching too early. */
1089 for (ix = 0, max_reached = 0;
1090 !max_reached && VEC_iterate (char_ptr, list, ix, candidate);
1093 enum maybe_add_completion_enum add_status;
1095 add_status = maybe_add_completion (tracker, candidate);
1099 case MAYBE_ADD_COMPLETION_OK:
1100 VEC_safe_push (char_ptr, result, xstrdup (candidate));
1102 case MAYBE_ADD_COMPLETION_OK_MAX_REACHED:
1103 VEC_safe_push (char_ptr, result, xstrdup (candidate));
1106 case MAYBE_ADD_COMPLETION_MAX_REACHED:
1107 gdb_assert_not_reached ("more than max completions reached");
1108 case MAYBE_ADD_COMPLETION_DUPLICATE:
1113 do_cleanups (cleanups);
1118 /* Complete on command names. Used by "help". */
1120 command_completer (struct cmd_list_element *ignore,
1121 const char *text, const char *word)
1123 return complete_line_internal (word, text,
1124 strlen (text), handle_help);
1127 /* Complete on signals. */
1130 signal_completer (struct cmd_list_element *ignore,
1131 const char *text, const char *word)
1133 VEC (char_ptr) *return_val = NULL;
1134 size_t len = strlen (word);
1136 const char *signame;
1138 for (signum = GDB_SIGNAL_FIRST; signum != GDB_SIGNAL_LAST; ++signum)
1140 /* Can't handle this, so skip it. */
1141 if (signum == GDB_SIGNAL_0)
1144 signame = gdb_signal_to_name ((enum gdb_signal) signum);
1146 /* Ignore the unknown signal case. */
1147 if (!signame || strcmp (signame, "?") == 0)
1150 if (strncasecmp (signame, word, len) == 0)
1151 VEC_safe_push (char_ptr, return_val, xstrdup (signame));
1157 /* Bit-flags for selecting what the register and/or register-group
1158 completer should complete on. */
1160 enum reg_completer_target
1162 complete_register_names = 0x1,
1163 complete_reggroup_names = 0x2
1165 DEF_ENUM_FLAGS_TYPE (enum reg_completer_target, reg_completer_targets);
1167 /* Complete register names and/or reggroup names based on the value passed
1168 in TARGETS. At least one bit in TARGETS must be set. */
1170 static VEC (char_ptr) *
1171 reg_or_group_completer_1 (struct cmd_list_element *ignore,
1172 const char *text, const char *word,
1173 reg_completer_targets targets)
1175 VEC (char_ptr) *result = NULL;
1176 size_t len = strlen (word);
1177 struct gdbarch *gdbarch;
1180 gdb_assert ((targets & (complete_register_names
1181 | complete_reggroup_names)) != 0);
1182 gdbarch = get_current_arch ();
1184 if ((targets & complete_register_names) != 0)
1189 (name = user_reg_map_regnum_to_name (gdbarch, i)) != NULL;
1192 if (*name != '\0' && strncmp (word, name, len) == 0)
1193 VEC_safe_push (char_ptr, result, xstrdup (name));
1197 if ((targets & complete_reggroup_names) != 0)
1199 struct reggroup *group;
1201 for (group = reggroup_next (gdbarch, NULL);
1203 group = reggroup_next (gdbarch, group))
1205 name = reggroup_name (group);
1206 if (strncmp (word, name, len) == 0)
1207 VEC_safe_push (char_ptr, result, xstrdup (name));
1214 /* Perform completion on register and reggroup names. */
1217 reg_or_group_completer (struct cmd_list_element *ignore,
1218 const char *text, const char *word)
1220 return reg_or_group_completer_1 (ignore, text, word,
1221 (complete_register_names
1222 | complete_reggroup_names));
1225 /* Perform completion on reggroup names. */
1228 reggroup_completer (struct cmd_list_element *ignore,
1229 const char *text, const char *word)
1231 return reg_or_group_completer_1 (ignore, text, word,
1232 complete_reggroup_names);
1235 /* Get the list of chars that are considered as word breaks
1236 for the current command. */
1239 gdb_completion_word_break_characters (void)
1241 VEC (char_ptr) *list;
1243 list = complete_line_internal (rl_line_buffer, rl_line_buffer, rl_point,
1245 gdb_assert (list == NULL);
1246 return rl_completer_word_break_characters;
1249 /* Generate completions one by one for the completer. Each time we
1250 are called return another potential completion to the caller.
1251 line_completion just completes on commands or passes the buck to
1252 the command's completer function, the stuff specific to symbol
1253 completion is in make_symbol_completion_list.
1255 TEXT is the caller's idea of the "word" we are looking at.
1257 MATCHES is the number of matches that have currently been collected
1258 from calling this completion function. When zero, then we need to
1259 initialize, otherwise the initialization has already taken place
1260 and we can just return the next potential completion string.
1262 LINE_BUFFER is available to be looked at; it contains the entire
1263 text of the line. POINT is the offset in that line of the cursor.
1264 You should pretend that the line ends at POINT.
1266 Returns NULL if there are no more completions, else a pointer to a
1267 string which is a possible completion, it is the caller's
1268 responsibility to free the string. */
1271 line_completion_function (const char *text, int matches,
1272 char *line_buffer, int point)
1274 static VEC (char_ptr) *list = NULL; /* Cache of completions. */
1275 static int index; /* Next cached completion. */
1276 char *output = NULL;
1280 /* The caller is beginning to accumulate a new set of
1281 completions, so we need to find all of them now, and cache
1282 them for returning one at a time on future calls. */
1286 /* Free the storage used by LIST, but not by the strings
1287 inside. This is because rl_complete_internal () frees
1288 the strings. As complete_line may abort by calling
1289 `error' clear LIST now. */
1290 VEC_free (char_ptr, list);
1293 list = complete_line (text, line_buffer, point);
1296 /* If we found a list of potential completions during initialization
1297 then dole them out one at a time. After returning the last one,
1298 return NULL (and continue to do so) each time we are called after
1299 that, until a new list is available. */
1303 if (index < VEC_length (char_ptr, list))
1305 output = VEC_index (char_ptr, list, index);
1311 /* Can't do this because readline hasn't yet checked the word breaks
1312 for figuring out whether to insert a quote. */
1314 /* Make sure the word break characters are set back to normal for
1315 the next time that readline tries to complete something. */
1316 rl_completer_word_break_characters =
1317 current_language->la_word_break_characters();
1323 /* Skip over the possibly quoted word STR (as defined by the quote
1324 characters QUOTECHARS and the word break characters BREAKCHARS).
1325 Returns pointer to the location after the "word". If either
1326 QUOTECHARS or BREAKCHARS is NULL, use the same values used by the
1330 skip_quoted_chars (const char *str, const char *quotechars,
1331 const char *breakchars)
1333 char quote_char = '\0';
1336 if (quotechars == NULL)
1337 quotechars = gdb_completer_quote_characters;
1339 if (breakchars == NULL)
1340 breakchars = current_language->la_word_break_characters();
1342 for (scan = str; *scan != '\0'; scan++)
1344 if (quote_char != '\0')
1346 /* Ignore everything until the matching close quote char. */
1347 if (*scan == quote_char)
1349 /* Found matching close quote. */
1354 else if (strchr (quotechars, *scan))
1356 /* Found start of a quoted string. */
1359 else if (strchr (breakchars, *scan))
1368 /* Skip over the possibly quoted word STR (as defined by the quote
1369 characters and word break characters used by the completer).
1370 Returns pointer to the location after the "word". */
1373 skip_quoted (const char *str)
1375 return skip_quoted_chars (str, NULL, NULL);
1378 /* Return a message indicating that the maximum number of completions
1379 has been reached and that there may be more. */
1382 get_max_completions_reached_message (void)
1384 return _("*** List may be truncated, max-completions reached. ***");
1387 /* GDB replacement for rl_display_match_list.
1388 Readline doesn't provide a clean interface for TUI(curses).
1389 A hack previously used was to send readline's rl_outstream through a pipe
1390 and read it from the event loop. Bleah. IWBN if readline abstracted
1391 away all the necessary bits, and this is what this code does. It
1392 replicates the parts of readline we need and then adds an abstraction
1393 layer, currently implemented as struct match_list_displayer, so that both
1394 CLI and TUI can use it. We copy all this readline code to minimize
1395 GDB-specific mods to readline. Once this code performs as desired then
1396 we can submit it to the readline maintainers.
1398 N.B. A lot of the code is the way it is in order to minimize differences
1399 from readline's copy. */
1401 /* Not supported here. */
1402 #undef VISIBLE_STATS
1404 #if defined (HANDLE_MULTIBYTE)
1405 #define MB_INVALIDCH(x) ((x) == (size_t)-1 || (x) == (size_t)-2)
1406 #define MB_NULLWCH(x) ((x) == 0)
1409 #define ELLIPSIS_LEN 3
1411 /* gdb version of readline/complete.c:get_y_or_n.
1412 'y' -> returns 1, and 'n' -> returns 0.
1413 Also supported: space == 'y', RUBOUT == 'n', ctrl-g == start over.
1414 If FOR_PAGER is non-zero, then also supported are:
1415 NEWLINE or RETURN -> returns 2, and 'q' -> returns 0. */
1418 gdb_get_y_or_n (int for_pager, const struct match_list_displayer *displayer)
1424 RL_SETSTATE (RL_STATE_MOREINPUT);
1425 c = displayer->read_key (displayer);
1426 RL_UNSETSTATE (RL_STATE_MOREINPUT);
1428 if (c == 'y' || c == 'Y' || c == ' ')
1430 if (c == 'n' || c == 'N' || c == RUBOUT)
1432 if (c == ABORT_CHAR || c < 0)
1434 /* Readline doesn't erase_entire_line here, but without it the
1435 --More-- prompt isn't erased and neither is the text entered
1436 thus far redisplayed. */
1437 displayer->erase_entire_line (displayer);
1438 /* Note: The arguments to rl_abort are ignored. */
1441 if (for_pager && (c == NEWLINE || c == RETURN))
1443 if (for_pager && (c == 'q' || c == 'Q'))
1445 displayer->beep (displayer);
1449 /* Pager function for tab-completion.
1450 This is based on readline/complete.c:_rl_internal_pager.
1451 LINES is the number of lines of output displayed thus far.
1453 -1 -> user pressed 'n' or equivalent,
1454 0 -> user pressed 'y' or equivalent,
1455 N -> user pressed NEWLINE or equivalent and N is LINES - 1. */
1458 gdb_display_match_list_pager (int lines,
1459 const struct match_list_displayer *displayer)
1463 displayer->puts (displayer, "--More--");
1464 displayer->flush (displayer);
1465 i = gdb_get_y_or_n (1, displayer);
1466 displayer->erase_entire_line (displayer);
1475 /* Return non-zero if FILENAME is a directory.
1476 Based on readline/complete.c:path_isdir. */
1479 gdb_path_isdir (const char *filename)
1483 return (stat (filename, &finfo) == 0 && S_ISDIR (finfo.st_mode));
1486 /* Return the portion of PATHNAME that should be output when listing
1487 possible completions. If we are hacking filename completion, we
1488 are only interested in the basename, the portion following the
1489 final slash. Otherwise, we return what we were passed. Since
1490 printing empty strings is not very informative, if we're doing
1491 filename completion, and the basename is the empty string, we look
1492 for the previous slash and return the portion following that. If
1493 there's no previous slash, we just return what we were passed.
1495 Based on readline/complete.c:printable_part. */
1498 gdb_printable_part (char *pathname)
1502 if (rl_filename_completion_desired == 0) /* don't need to do anything */
1505 temp = strrchr (pathname, '/');
1506 #if defined (__MSDOS__)
1507 if (temp == 0 && ISALPHA ((unsigned char)pathname[0]) && pathname[1] == ':')
1508 temp = pathname + 1;
1511 if (temp == 0 || *temp == '\0')
1513 /* If the basename is NULL, we might have a pathname like '/usr/src/'.
1514 Look for a previous slash and, if one is found, return the portion
1515 following that slash. If there's no previous slash, just return the
1516 pathname we were passed. */
1517 else if (temp[1] == '\0')
1519 for (x = temp - 1; x > pathname; x--)
1522 return ((*x == '/') ? x + 1 : pathname);
1528 /* Compute width of STRING when displayed on screen by print_filename.
1529 Based on readline/complete.c:fnwidth. */
1532 gdb_fnwidth (const char *string)
1535 #if defined (HANDLE_MULTIBYTE)
1541 left = strlen (string) + 1;
1542 memset (&ps, 0, sizeof (mbstate_t));
1548 if (CTRL_CHAR (string[pos]) || string[pos] == RUBOUT)
1555 #if defined (HANDLE_MULTIBYTE)
1556 clen = mbrtowc (&wc, string + pos, left - pos, &ps);
1557 if (MB_INVALIDCH (clen))
1561 memset (&ps, 0, sizeof (mbstate_t));
1563 else if (MB_NULLWCH (clen))
1569 width += (w >= 0) ? w : 1;
1581 /* Print TO_PRINT, one matching completion.
1582 PREFIX_BYTES is number of common prefix bytes.
1583 Based on readline/complete.c:fnprint. */
1586 gdb_fnprint (const char *to_print, int prefix_bytes,
1587 const struct match_list_displayer *displayer)
1591 #if defined (HANDLE_MULTIBYTE)
1598 end = to_print + strlen (to_print) + 1;
1599 memset (&ps, 0, sizeof (mbstate_t));
1604 /* Don't print only the ellipsis if the common prefix is one of the
1605 possible completions */
1606 if (to_print[prefix_bytes] == '\0')
1613 ellipsis = (to_print[prefix_bytes] == '.') ? '_' : '.';
1614 for (w = 0; w < ELLIPSIS_LEN; w++)
1615 displayer->putch (displayer, ellipsis);
1616 printed_len = ELLIPSIS_LEN;
1619 s = to_print + prefix_bytes;
1624 displayer->putch (displayer, '^');
1625 displayer->putch (displayer, UNCTRL (*s));
1628 #if defined (HANDLE_MULTIBYTE)
1629 memset (&ps, 0, sizeof (mbstate_t));
1632 else if (*s == RUBOUT)
1634 displayer->putch (displayer, '^');
1635 displayer->putch (displayer, '?');
1638 #if defined (HANDLE_MULTIBYTE)
1639 memset (&ps, 0, sizeof (mbstate_t));
1644 #if defined (HANDLE_MULTIBYTE)
1645 tlen = mbrtowc (&wc, s, end - s, &ps);
1646 if (MB_INVALIDCH (tlen))
1650 memset (&ps, 0, sizeof (mbstate_t));
1652 else if (MB_NULLWCH (tlen))
1657 width = (w >= 0) ? w : 1;
1659 for (w = 0; w < tlen; ++w)
1660 displayer->putch (displayer, s[w]);
1662 printed_len += width;
1664 displayer->putch (displayer, *s);
1674 /* Output TO_PRINT to rl_outstream. If VISIBLE_STATS is defined and we
1675 are using it, check for and output a single character for `special'
1676 filenames. Return the number of characters we output.
1677 Based on readline/complete.c:print_filename. */
1680 gdb_print_filename (char *to_print, char *full_pathname, int prefix_bytes,
1681 const struct match_list_displayer *displayer)
1683 int printed_len, extension_char, slen, tlen;
1684 char *s, c, *new_full_pathname;
1686 extern int _rl_complete_mark_directories;
1689 printed_len = gdb_fnprint (to_print, prefix_bytes, displayer);
1691 #if defined (VISIBLE_STATS)
1692 if (rl_filename_completion_desired && (rl_visible_stats || _rl_complete_mark_directories))
1694 if (rl_filename_completion_desired && _rl_complete_mark_directories)
1697 /* If to_print != full_pathname, to_print is the basename of the
1698 path passed. In this case, we try to expand the directory
1699 name before checking for the stat character. */
1700 if (to_print != full_pathname)
1702 /* Terminate the directory name. */
1704 to_print[-1] = '\0';
1706 /* If setting the last slash in full_pathname to a NUL results in
1707 full_pathname being the empty string, we are trying to complete
1708 files in the root directory. If we pass a null string to the
1709 bash directory completion hook, for example, it will expand it
1710 to the current directory. We just want the `/'. */
1711 if (full_pathname == 0 || *full_pathname == 0)
1713 else if (full_pathname[0] != '/')
1715 else if (full_pathname[1] == 0)
1716 dn = "//"; /* restore trailing slash to `//' */
1717 else if (full_pathname[1] == '/' && full_pathname[2] == 0)
1718 dn = "/"; /* don't turn /// into // */
1721 s = tilde_expand (dn);
1722 if (rl_directory_completion_hook)
1723 (*rl_directory_completion_hook) (&s);
1726 tlen = strlen (to_print);
1727 new_full_pathname = (char *)xmalloc (slen + tlen + 2);
1728 strcpy (new_full_pathname, s);
1729 if (s[slen - 1] == '/')
1732 new_full_pathname[slen] = '/';
1733 new_full_pathname[slen] = '/';
1734 strcpy (new_full_pathname + slen + 1, to_print);
1736 #if defined (VISIBLE_STATS)
1737 if (rl_visible_stats)
1738 extension_char = stat_char (new_full_pathname);
1741 if (gdb_path_isdir (new_full_pathname))
1742 extension_char = '/';
1744 xfree (new_full_pathname);
1749 s = tilde_expand (full_pathname);
1750 #if defined (VISIBLE_STATS)
1751 if (rl_visible_stats)
1752 extension_char = stat_char (s);
1755 if (gdb_path_isdir (s))
1756 extension_char = '/';
1762 displayer->putch (displayer, extension_char);
1770 /* GDB version of readline/complete.c:complete_get_screenwidth. */
1773 gdb_complete_get_screenwidth (const struct match_list_displayer *displayer)
1775 /* Readline has other stuff here which it's not clear we need. */
1776 return displayer->width;
1779 extern int _rl_completion_prefix_display_length;
1780 extern int _rl_print_completions_horizontally;
1782 EXTERN_C int _rl_qsort_string_compare (const void *, const void *);
1783 typedef int QSFUNC (const void *, const void *);
1785 /* GDB version of readline/complete.c:rl_display_match_list.
1786 See gdb_display_match_list for a description of MATCHES, LEN, MAX.
1787 Returns non-zero if all matches are displayed. */
1790 gdb_display_match_list_1 (char **matches, int len, int max,
1791 const struct match_list_displayer *displayer)
1793 int count, limit, printed_len, lines, cols;
1794 int i, j, k, l, common_length, sind;
1796 int page_completions = displayer->height != INT_MAX && pagination_enabled;
1798 /* Find the length of the prefix common to all items: length as displayed
1799 characters (common_length) and as a byte index into the matches (sind) */
1800 common_length = sind = 0;
1801 if (_rl_completion_prefix_display_length > 0)
1803 t = gdb_printable_part (matches[0]);
1804 temp = strrchr (t, '/');
1805 common_length = temp ? gdb_fnwidth (temp) : gdb_fnwidth (t);
1806 sind = temp ? strlen (temp) : strlen (t);
1808 if (common_length > _rl_completion_prefix_display_length && common_length > ELLIPSIS_LEN)
1809 max -= common_length - ELLIPSIS_LEN;
1811 common_length = sind = 0;
1814 /* How many items of MAX length can we fit in the screen window? */
1815 cols = gdb_complete_get_screenwidth (displayer);
1818 if (limit != 1 && (limit * max == cols))
1821 /* If cols == 0, limit will end up -1 */
1822 if (cols < displayer->width && limit < 0)
1825 /* Avoid a possible floating exception. If max > cols,
1826 limit will be 0 and a divide-by-zero fault will result. */
1830 /* How many iterations of the printing loop? */
1831 count = (len + (limit - 1)) / limit;
1833 /* Watch out for special case. If LEN is less than LIMIT, then
1834 just do the inner printing loop.
1835 0 < len <= limit implies count = 1. */
1837 /* Sort the items if they are not already sorted. */
1838 if (rl_ignore_completion_duplicates == 0 && rl_sort_completion_matches)
1839 qsort (matches + 1, len, sizeof (char *), (QSFUNC *)_rl_qsort_string_compare);
1841 displayer->crlf (displayer);
1844 if (_rl_print_completions_horizontally == 0)
1846 /* Print the sorted items, up-and-down alphabetically, like ls. */
1847 for (i = 1; i <= count; i++)
1849 for (j = 0, l = i; j < limit; j++)
1851 if (l > len || matches[l] == 0)
1855 temp = gdb_printable_part (matches[l]);
1856 printed_len = gdb_print_filename (temp, matches[l], sind,
1860 for (k = 0; k < max - printed_len; k++)
1861 displayer->putch (displayer, ' ');
1865 displayer->crlf (displayer);
1867 if (page_completions && lines >= (displayer->height - 1) && i < count)
1869 lines = gdb_display_match_list_pager (lines, displayer);
1877 /* Print the sorted items, across alphabetically, like ls -x. */
1878 for (i = 1; matches[i]; i++)
1880 temp = gdb_printable_part (matches[i]);
1881 printed_len = gdb_print_filename (temp, matches[i], sind, displayer);
1882 /* Have we reached the end of this line? */
1885 if (i && (limit > 1) && (i % limit) == 0)
1887 displayer->crlf (displayer);
1889 if (page_completions && lines >= displayer->height - 1)
1891 lines = gdb_display_match_list_pager (lines, displayer);
1897 for (k = 0; k < max - printed_len; k++)
1898 displayer->putch (displayer, ' ');
1901 displayer->crlf (displayer);
1907 /* Utility for displaying completion list matches, used by both CLI and TUI.
1909 MATCHES is the list of strings, in argv format, LEN is the number of
1910 strings in MATCHES, and MAX is the length of the longest string in
1914 gdb_display_match_list (char **matches, int len, int max,
1915 const struct match_list_displayer *displayer)
1917 /* Readline will never call this if complete_line returned NULL. */
1918 gdb_assert (max_completions != 0);
1920 /* complete_line will never return more than this. */
1921 if (max_completions > 0)
1922 gdb_assert (len <= max_completions);
1924 if (rl_completion_query_items > 0 && len >= rl_completion_query_items)
1928 /* We can't use *query here because they wait for <RET> which is
1929 wrong here. This follows the readline version as closely as possible
1930 for compatibility's sake. See readline/complete.c. */
1932 displayer->crlf (displayer);
1934 xsnprintf (msg, sizeof (msg),
1935 "Display all %d possibilities? (y or n)", len);
1936 displayer->puts (displayer, msg);
1937 displayer->flush (displayer);
1939 if (gdb_get_y_or_n (0, displayer) == 0)
1941 displayer->crlf (displayer);
1946 if (gdb_display_match_list_1 (matches, len, max, displayer))
1948 /* Note: MAX_COMPLETIONS may be -1 or zero, but LEN is always > 0. */
1949 if (len == max_completions)
1951 /* The maximum number of completions has been reached. Warn the user
1952 that there may be more. */
1953 const char *message = get_max_completions_reached_message ();
1955 displayer->puts (displayer, message);
1956 displayer->crlf (displayer);
1961 extern initialize_file_ftype _initialize_completer; /* -Wmissing-prototypes */
1964 _initialize_completer (void)
1966 add_setshow_zuinteger_unlimited_cmd ("max-completions", no_class,
1967 &max_completions, _("\
1968 Set maximum number of completion candidates."), _("\
1969 Show maximum number of completion candidates."), _("\
1970 Use this to limit the number of candidates considered\n\
1971 during completion. Specifying \"unlimited\" or -1\n\
1972 disables limiting. Note that setting either no limit or\n\
1973 a very large limit can make completion slow."),
1974 NULL, NULL, &setlist, &showlist);