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;
510 struct event_location *location;
512 location = string_to_explicit_location (©, current_language, 1);
513 if (location != NULL)
515 struct cleanup *cleanup;
517 cleanup = make_cleanup_delete_event_location (location);
518 matches = explicit_location_completer (ignore, location, text, word);
519 do_cleanups (cleanup);
523 /* This is an address or linespec location.
524 Right now both of these are handled by the (old) linespec
526 matches = linespec_location_completer (ignore, text, word);
532 /* Helper for expression_completer which recursively adds field and
533 method names from TYPE, a struct or union type, to the array
536 add_struct_fields (struct type *type, VEC (char_ptr) **output,
537 char *fieldname, int namelen)
540 int computed_type_name = 0;
541 const char *type_name = NULL;
543 type = check_typedef (type);
544 for (i = 0; i < TYPE_NFIELDS (type); ++i)
546 if (i < TYPE_N_BASECLASSES (type))
547 add_struct_fields (TYPE_BASECLASS (type, i),
548 output, fieldname, namelen);
549 else if (TYPE_FIELD_NAME (type, i))
551 if (TYPE_FIELD_NAME (type, i)[0] != '\0')
553 if (! strncmp (TYPE_FIELD_NAME (type, i),
555 VEC_safe_push (char_ptr, *output,
556 xstrdup (TYPE_FIELD_NAME (type, i)));
558 else if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_UNION)
560 /* Recurse into anonymous unions. */
561 add_struct_fields (TYPE_FIELD_TYPE (type, i),
562 output, fieldname, namelen);
567 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)
569 const char *name = TYPE_FN_FIELDLIST_NAME (type, i);
571 if (name && ! strncmp (name, fieldname, namelen))
573 if (!computed_type_name)
575 type_name = type_name_no_tag (type);
576 computed_type_name = 1;
578 /* Omit constructors from the completion list. */
579 if (!type_name || strcmp (type_name, name))
580 VEC_safe_push (char_ptr, *output, xstrdup (name));
585 /* Complete on expressions. Often this means completing on symbol
586 names, but some language parsers also have support for completing
589 expression_completer (struct cmd_list_element *ignore,
590 const char *text, const char *word)
592 struct type *type = NULL;
595 enum type_code code = TYPE_CODE_UNDEF;
597 /* Perform a tentative parse of the expression, to see whether a
598 field completion is required. */
602 type = parse_expression_for_completion (text, &fieldname, &code);
604 CATCH (except, RETURN_MASK_ERROR)
610 if (fieldname && type)
614 type = check_typedef (type);
615 if (TYPE_CODE (type) != TYPE_CODE_PTR && !TYPE_IS_REFERENCE (type))
617 type = TYPE_TARGET_TYPE (type);
620 if (TYPE_CODE (type) == TYPE_CODE_UNION
621 || TYPE_CODE (type) == TYPE_CODE_STRUCT)
623 int flen = strlen (fieldname);
624 VEC (char_ptr) *result = NULL;
626 add_struct_fields (type, &result, fieldname, flen);
631 else if (fieldname && code != TYPE_CODE_UNDEF)
633 VEC (char_ptr) *result;
634 struct cleanup *cleanup = make_cleanup (xfree, fieldname);
636 result = make_symbol_completion_type (fieldname, fieldname, code);
637 do_cleanups (cleanup);
642 /* Commands which complete on locations want to see the entire
645 p > text && p[-1] != ' ' && p[-1] != '\t';
649 /* Not ideal but it is what we used to do before... */
650 return location_completer (ignore, p, word);
653 /* See definition in completer.h. */
656 set_rl_completer_word_break_characters (const char *break_chars)
658 rl_completer_word_break_characters = (char *) break_chars;
661 /* See definition in completer.h. */
664 set_gdb_completion_word_break_characters (completer_ftype *fn)
666 const char *break_chars;
668 /* So far we are only interested in differentiating filename
669 completers from everything else. */
670 if (fn == filename_completer)
671 break_chars = gdb_completer_file_name_break_characters;
673 break_chars = gdb_completer_command_word_break_characters;
675 set_rl_completer_word_break_characters (break_chars);
678 /* Here are some useful test cases for completion. FIXME: These
679 should be put in the test suite. They should be tested with both
682 "show output-" "radix"
683 "show output" "-radix"
684 "p" ambiguous (commands starting with p--path, print, printf, etc.)
685 "p " ambiguous (all symbols)
686 "info t foo" no completions
687 "info t " no completions
688 "info t" ambiguous ("info target", "info terminal", etc.)
689 "info ajksdlfk" no completions
690 "info ajksdlfk " no completions
692 "info " ambiguous (all info commands)
693 "p \"a" no completions (string constant)
694 "p 'a" ambiguous (all symbols starting with a)
695 "p b-a" ambiguous (all symbols starting with a)
696 "p b-" ambiguous (all symbols)
697 "file Make" "file" (word break hard to screw up here)
698 "file ../gdb.stabs/we" "ird" (needs to not break word at slash)
707 complete_line_internal_reason;
710 /* Internal function used to handle completions.
713 TEXT is the caller's idea of the "word" we are looking at.
715 LINE_BUFFER is available to be looked at; it contains the entire
716 text of the line. POINT is the offset in that line of the cursor.
717 You should pretend that the line ends at POINT.
719 REASON is of type complete_line_internal_reason.
721 If REASON is handle_brkchars:
722 Preliminary phase, called by gdb_completion_word_break_characters
723 function, is used to determine the correct set of chars that are
724 word delimiters depending on the current command in line_buffer.
725 No completion list should be generated; the return value should be
726 NULL. This is checked by an assertion in that function.
728 If REASON is handle_completions:
729 Main phase, called by complete_line function, is used to get the list
730 of posible completions.
732 If REASON is handle_help:
733 Special case when completing a 'help' command. In this case,
734 once sub-command completions are exhausted, we simply return NULL.
737 static VEC (char_ptr) *
738 complete_line_internal (const char *text,
739 const char *line_buffer, int point,
740 complete_line_internal_reason reason)
742 VEC (char_ptr) *list = NULL;
745 int ignore_help_classes;
746 /* Pointer within tmp_command which corresponds to text. */
748 struct cmd_list_element *c, *result_list;
750 /* Choose the default set of word break characters to break
751 completions. If we later find out that we are doing completions
752 on command strings (as opposed to strings supplied by the
753 individual command completer functions, which can be any string)
754 then we will switch to the special word break set for command
755 strings, which leaves out the '-' character used in some
757 set_rl_completer_word_break_characters
758 (current_language->la_word_break_characters());
760 /* Decide whether to complete on a list of gdb commands or on
762 tmp_command = (char *) alloca (point + 1);
765 /* The help command should complete help aliases. */
766 ignore_help_classes = reason != handle_help;
768 strncpy (tmp_command, line_buffer, point);
769 tmp_command[point] = '\0';
770 /* Since text always contains some number of characters leading up
771 to point, we can find the equivalent position in tmp_command
772 by subtracting that many characters from the end of tmp_command. */
773 word = tmp_command + point - strlen (text);
777 /* An empty line we want to consider ambiguous; that is, it
778 could be any command. */
779 c = CMD_LIST_AMBIGUOUS;
784 c = lookup_cmd_1 (&p, cmdlist, &result_list, ignore_help_classes);
787 /* Move p up to the next interesting thing. */
788 while (*p == ' ' || *p == '\t')
795 /* It is an unrecognized command. So there are no
796 possible completions. */
799 else if (c == CMD_LIST_AMBIGUOUS)
803 /* lookup_cmd_1 advances p up to the first ambiguous thing, but
804 doesn't advance over that thing itself. Do so now. */
806 while (*q && (isalnum (*q) || *q == '-' || *q == '_'))
808 if (q != tmp_command + point)
810 /* There is something beyond the ambiguous
811 command, so there are no possible completions. For
812 example, "info t " or "info t foo" does not complete
813 to anything, because "info t" can be "info target" or
819 /* We're trying to complete on the command which was ambiguous.
820 This we can deal with. */
823 if (reason != handle_brkchars)
824 list = complete_on_cmdlist (*result_list->prefixlist, p,
825 word, ignore_help_classes);
829 if (reason != handle_brkchars)
830 list = complete_on_cmdlist (cmdlist, p, word,
831 ignore_help_classes);
833 /* Ensure that readline does the right thing with respect to
835 set_rl_completer_word_break_characters
836 (gdb_completer_command_word_break_characters);
841 /* We've recognized a full command. */
843 if (p == tmp_command + point)
845 /* There is no non-whitespace in the line beyond the
848 if (p[-1] == ' ' || p[-1] == '\t')
850 /* The command is followed by whitespace; we need to
851 complete on whatever comes after command. */
854 /* It is a prefix command; what comes after it is
855 a subcommand (e.g. "info "). */
856 if (reason != handle_brkchars)
857 list = complete_on_cmdlist (*c->prefixlist, p, word,
858 ignore_help_classes);
860 /* Ensure that readline does the right thing
861 with respect to inserting quotes. */
862 set_rl_completer_word_break_characters
863 (gdb_completer_command_word_break_characters);
865 else if (reason == handle_help)
869 if (reason != handle_brkchars)
870 list = complete_on_enum (c->enums, p, word);
871 set_rl_completer_word_break_characters
872 (gdb_completer_command_word_break_characters);
876 /* It is a normal command; what comes after it is
877 completed by the command's completer function. */
878 if (c->completer == filename_completer)
880 /* Many commands which want to complete on
881 file names accept several file names, as
882 in "run foo bar >>baz". So we don't want
883 to complete the entire text after the
884 command, just the last word. To this
885 end, we need to find the beginning of the
886 file name by starting at `word' and going
890 && strchr (gdb_completer_file_name_break_characters, p[-1]) == NULL;
893 set_rl_completer_word_break_characters
894 (gdb_completer_file_name_break_characters);
896 if (reason == handle_brkchars
897 && c->completer_handle_brkchars != NULL)
898 (*c->completer_handle_brkchars) (c, p, word);
899 if (reason != handle_brkchars && c->completer != NULL)
900 list = (*c->completer) (c, p, word);
905 /* The command is not followed by whitespace; we need to
906 complete on the command itself, e.g. "p" which is a
907 command itself but also can complete to "print", "ptype"
911 /* Find the command we are completing on. */
913 while (q > tmp_command)
915 if (isalnum (q[-1]) || q[-1] == '-' || q[-1] == '_')
921 if (reason != handle_brkchars)
922 list = complete_on_cmdlist (result_list, q, word,
923 ignore_help_classes);
925 /* Ensure that readline does the right thing
926 with respect to inserting quotes. */
927 set_rl_completer_word_break_characters
928 (gdb_completer_command_word_break_characters);
931 else if (reason == handle_help)
935 /* There is non-whitespace beyond the command. */
937 if (c->prefixlist && !c->allow_unknown)
939 /* It is an unrecognized subcommand of a prefix command,
940 e.g. "info adsfkdj". */
945 if (reason != handle_brkchars)
946 list = complete_on_enum (c->enums, p, word);
950 /* It is a normal command. */
951 if (c->completer == filename_completer)
953 /* See the commentary above about the specifics
954 of file-name completion. */
957 && strchr (gdb_completer_file_name_break_characters,
961 set_rl_completer_word_break_characters
962 (gdb_completer_file_name_break_characters);
964 if (reason == handle_brkchars
965 && c->completer_handle_brkchars != NULL)
966 (*c->completer_handle_brkchars) (c, p, word);
967 if (reason != handle_brkchars && c->completer != NULL)
968 list = (*c->completer) (c, p, word);
976 /* See completer.h. */
978 int max_completions = 200;
980 /* See completer.h. */
983 new_completion_tracker (void)
985 if (max_completions <= 0)
988 return htab_create_alloc (max_completions,
989 htab_hash_string, (htab_eq) streq,
990 NULL, xcalloc, xfree);
993 /* Cleanup routine to free a completion tracker and reset the pointer
997 free_completion_tracker (void *p)
999 completion_tracker_t *tracker_ptr = (completion_tracker_t *) p;
1001 htab_delete (*tracker_ptr);
1002 *tracker_ptr = NULL;
1005 /* See completer.h. */
1008 make_cleanup_free_completion_tracker (completion_tracker_t *tracker_ptr)
1010 if (*tracker_ptr == NULL)
1011 return make_cleanup (null_cleanup, NULL);
1013 return make_cleanup (free_completion_tracker, tracker_ptr);
1016 /* See completer.h. */
1018 enum maybe_add_completion_enum
1019 maybe_add_completion (completion_tracker_t tracker, char *name)
1023 if (max_completions < 0)
1024 return MAYBE_ADD_COMPLETION_OK;
1025 if (max_completions == 0)
1026 return MAYBE_ADD_COMPLETION_MAX_REACHED;
1028 gdb_assert (tracker != NULL);
1030 if (htab_elements (tracker) >= max_completions)
1031 return MAYBE_ADD_COMPLETION_MAX_REACHED;
1033 slot = htab_find_slot (tracker, name, INSERT);
1035 if (*slot != HTAB_EMPTY_ENTRY)
1036 return MAYBE_ADD_COMPLETION_DUPLICATE;
1040 return (htab_elements (tracker) < max_completions
1041 ? MAYBE_ADD_COMPLETION_OK
1042 : MAYBE_ADD_COMPLETION_OK_MAX_REACHED);
1046 throw_max_completions_reached_error (void)
1048 throw_error (MAX_COMPLETIONS_REACHED_ERROR, _("Max completions reached."));
1051 /* Generate completions all at once. Returns a vector of unique strings
1052 allocated with xmalloc. Returns NULL if there are no completions
1053 or if max_completions is 0. If max_completions is non-negative, this will
1054 return at most max_completions strings.
1056 TEXT is the caller's idea of the "word" we are looking at.
1058 LINE_BUFFER is available to be looked at; it contains the entire
1061 POINT is the offset in that line of the cursor. You
1062 should pretend that the line ends at POINT. */
1065 complete_line (const char *text, const char *line_buffer, int point)
1067 VEC (char_ptr) *list;
1068 VEC (char_ptr) *result = NULL;
1069 struct cleanup *cleanups;
1070 completion_tracker_t tracker;
1072 int ix, max_reached;
1074 if (max_completions == 0)
1076 list = complete_line_internal (text, line_buffer, point,
1077 handle_completions);
1078 if (max_completions < 0)
1081 tracker = new_completion_tracker ();
1082 cleanups = make_cleanup_free_completion_tracker (&tracker);
1083 make_cleanup_free_char_ptr_vec (list);
1085 /* Do a final test for too many completions. Individual completers may
1086 do some of this, but are not required to. Duplicates are also removed
1087 here. Otherwise the user is left scratching his/her head: readline and
1088 complete_command will remove duplicates, and if removal of duplicates
1089 there brings the total under max_completions the user may think gdb quit
1090 searching too early. */
1092 for (ix = 0, max_reached = 0;
1093 !max_reached && VEC_iterate (char_ptr, list, ix, candidate);
1096 enum maybe_add_completion_enum add_status;
1098 add_status = maybe_add_completion (tracker, candidate);
1102 case MAYBE_ADD_COMPLETION_OK:
1103 VEC_safe_push (char_ptr, result, xstrdup (candidate));
1105 case MAYBE_ADD_COMPLETION_OK_MAX_REACHED:
1106 VEC_safe_push (char_ptr, result, xstrdup (candidate));
1109 case MAYBE_ADD_COMPLETION_MAX_REACHED:
1110 gdb_assert_not_reached ("more than max completions reached");
1111 case MAYBE_ADD_COMPLETION_DUPLICATE:
1116 do_cleanups (cleanups);
1121 /* Complete on command names. Used by "help". */
1123 command_completer (struct cmd_list_element *ignore,
1124 const char *text, const char *word)
1126 return complete_line_internal (word, text,
1127 strlen (text), handle_help);
1130 /* Complete on signals. */
1133 signal_completer (struct cmd_list_element *ignore,
1134 const char *text, const char *word)
1136 VEC (char_ptr) *return_val = NULL;
1137 size_t len = strlen (word);
1139 const char *signame;
1141 for (signum = GDB_SIGNAL_FIRST; signum != GDB_SIGNAL_LAST; ++signum)
1143 /* Can't handle this, so skip it. */
1144 if (signum == GDB_SIGNAL_0)
1147 signame = gdb_signal_to_name ((enum gdb_signal) signum);
1149 /* Ignore the unknown signal case. */
1150 if (!signame || strcmp (signame, "?") == 0)
1153 if (strncasecmp (signame, word, len) == 0)
1154 VEC_safe_push (char_ptr, return_val, xstrdup (signame));
1160 /* Bit-flags for selecting what the register and/or register-group
1161 completer should complete on. */
1163 enum reg_completer_target
1165 complete_register_names = 0x1,
1166 complete_reggroup_names = 0x2
1168 DEF_ENUM_FLAGS_TYPE (enum reg_completer_target, reg_completer_targets);
1170 /* Complete register names and/or reggroup names based on the value passed
1171 in TARGETS. At least one bit in TARGETS must be set. */
1173 static VEC (char_ptr) *
1174 reg_or_group_completer_1 (struct cmd_list_element *ignore,
1175 const char *text, const char *word,
1176 reg_completer_targets targets)
1178 VEC (char_ptr) *result = NULL;
1179 size_t len = strlen (word);
1180 struct gdbarch *gdbarch;
1183 gdb_assert ((targets & (complete_register_names
1184 | complete_reggroup_names)) != 0);
1185 gdbarch = get_current_arch ();
1187 if ((targets & complete_register_names) != 0)
1192 (name = user_reg_map_regnum_to_name (gdbarch, i)) != NULL;
1195 if (*name != '\0' && strncmp (word, name, len) == 0)
1196 VEC_safe_push (char_ptr, result, xstrdup (name));
1200 if ((targets & complete_reggroup_names) != 0)
1202 struct reggroup *group;
1204 for (group = reggroup_next (gdbarch, NULL);
1206 group = reggroup_next (gdbarch, group))
1208 name = reggroup_name (group);
1209 if (strncmp (word, name, len) == 0)
1210 VEC_safe_push (char_ptr, result, xstrdup (name));
1217 /* Perform completion on register and reggroup names. */
1220 reg_or_group_completer (struct cmd_list_element *ignore,
1221 const char *text, const char *word)
1223 return reg_or_group_completer_1 (ignore, text, word,
1224 (complete_register_names
1225 | complete_reggroup_names));
1228 /* Perform completion on reggroup names. */
1231 reggroup_completer (struct cmd_list_element *ignore,
1232 const char *text, const char *word)
1234 return reg_or_group_completer_1 (ignore, text, word,
1235 complete_reggroup_names);
1238 /* Get the list of chars that are considered as word breaks
1239 for the current command. */
1242 gdb_completion_word_break_characters (void)
1244 VEC (char_ptr) *list;
1246 list = complete_line_internal (rl_line_buffer, rl_line_buffer, rl_point,
1248 gdb_assert (list == NULL);
1249 return rl_completer_word_break_characters;
1252 /* Generate completions one by one for the completer. Each time we
1253 are called return another potential completion to the caller.
1254 line_completion just completes on commands or passes the buck to
1255 the command's completer function, the stuff specific to symbol
1256 completion is in make_symbol_completion_list.
1258 TEXT is the caller's idea of the "word" we are looking at.
1260 MATCHES is the number of matches that have currently been collected
1261 from calling this completion function. When zero, then we need to
1262 initialize, otherwise the initialization has already taken place
1263 and we can just return the next potential completion string.
1265 LINE_BUFFER is available to be looked at; it contains the entire
1266 text of the line. POINT is the offset in that line of the cursor.
1267 You should pretend that the line ends at POINT.
1269 Returns NULL if there are no more completions, else a pointer to a
1270 string which is a possible completion, it is the caller's
1271 responsibility to free the string. */
1274 line_completion_function (const char *text, int matches,
1275 char *line_buffer, int point)
1277 static VEC (char_ptr) *list = NULL; /* Cache of completions. */
1278 static int index; /* Next cached completion. */
1279 char *output = NULL;
1283 /* The caller is beginning to accumulate a new set of
1284 completions, so we need to find all of them now, and cache
1285 them for returning one at a time on future calls. */
1289 /* Free the storage used by LIST, but not by the strings
1290 inside. This is because rl_complete_internal () frees
1291 the strings. As complete_line may abort by calling
1292 `error' clear LIST now. */
1293 VEC_free (char_ptr, list);
1296 list = complete_line (text, line_buffer, point);
1299 /* If we found a list of potential completions during initialization
1300 then dole them out one at a time. After returning the last one,
1301 return NULL (and continue to do so) each time we are called after
1302 that, until a new list is available. */
1306 if (index < VEC_length (char_ptr, list))
1308 output = VEC_index (char_ptr, list, index);
1314 /* Can't do this because readline hasn't yet checked the word breaks
1315 for figuring out whether to insert a quote. */
1317 /* Make sure the word break characters are set back to normal for
1318 the next time that readline tries to complete something. */
1319 rl_completer_word_break_characters =
1320 current_language->la_word_break_characters();
1326 /* Skip over the possibly quoted word STR (as defined by the quote
1327 characters QUOTECHARS and the word break characters BREAKCHARS).
1328 Returns pointer to the location after the "word". If either
1329 QUOTECHARS or BREAKCHARS is NULL, use the same values used by the
1333 skip_quoted_chars (const char *str, const char *quotechars,
1334 const char *breakchars)
1336 char quote_char = '\0';
1339 if (quotechars == NULL)
1340 quotechars = gdb_completer_quote_characters;
1342 if (breakchars == NULL)
1343 breakchars = current_language->la_word_break_characters();
1345 for (scan = str; *scan != '\0'; scan++)
1347 if (quote_char != '\0')
1349 /* Ignore everything until the matching close quote char. */
1350 if (*scan == quote_char)
1352 /* Found matching close quote. */
1357 else if (strchr (quotechars, *scan))
1359 /* Found start of a quoted string. */
1362 else if (strchr (breakchars, *scan))
1371 /* Skip over the possibly quoted word STR (as defined by the quote
1372 characters and word break characters used by the completer).
1373 Returns pointer to the location after the "word". */
1376 skip_quoted (const char *str)
1378 return skip_quoted_chars (str, NULL, NULL);
1381 /* Return a message indicating that the maximum number of completions
1382 has been reached and that there may be more. */
1385 get_max_completions_reached_message (void)
1387 return _("*** List may be truncated, max-completions reached. ***");
1390 /* GDB replacement for rl_display_match_list.
1391 Readline doesn't provide a clean interface for TUI(curses).
1392 A hack previously used was to send readline's rl_outstream through a pipe
1393 and read it from the event loop. Bleah. IWBN if readline abstracted
1394 away all the necessary bits, and this is what this code does. It
1395 replicates the parts of readline we need and then adds an abstraction
1396 layer, currently implemented as struct match_list_displayer, so that both
1397 CLI and TUI can use it. We copy all this readline code to minimize
1398 GDB-specific mods to readline. Once this code performs as desired then
1399 we can submit it to the readline maintainers.
1401 N.B. A lot of the code is the way it is in order to minimize differences
1402 from readline's copy. */
1404 /* Not supported here. */
1405 #undef VISIBLE_STATS
1407 #if defined (HANDLE_MULTIBYTE)
1408 #define MB_INVALIDCH(x) ((x) == (size_t)-1 || (x) == (size_t)-2)
1409 #define MB_NULLWCH(x) ((x) == 0)
1412 #define ELLIPSIS_LEN 3
1414 /* gdb version of readline/complete.c:get_y_or_n.
1415 'y' -> returns 1, and 'n' -> returns 0.
1416 Also supported: space == 'y', RUBOUT == 'n', ctrl-g == start over.
1417 If FOR_PAGER is non-zero, then also supported are:
1418 NEWLINE or RETURN -> returns 2, and 'q' -> returns 0. */
1421 gdb_get_y_or_n (int for_pager, const struct match_list_displayer *displayer)
1427 RL_SETSTATE (RL_STATE_MOREINPUT);
1428 c = displayer->read_key (displayer);
1429 RL_UNSETSTATE (RL_STATE_MOREINPUT);
1431 if (c == 'y' || c == 'Y' || c == ' ')
1433 if (c == 'n' || c == 'N' || c == RUBOUT)
1435 if (c == ABORT_CHAR || c < 0)
1437 /* Readline doesn't erase_entire_line here, but without it the
1438 --More-- prompt isn't erased and neither is the text entered
1439 thus far redisplayed. */
1440 displayer->erase_entire_line (displayer);
1441 /* Note: The arguments to rl_abort are ignored. */
1444 if (for_pager && (c == NEWLINE || c == RETURN))
1446 if (for_pager && (c == 'q' || c == 'Q'))
1448 displayer->beep (displayer);
1452 /* Pager function for tab-completion.
1453 This is based on readline/complete.c:_rl_internal_pager.
1454 LINES is the number of lines of output displayed thus far.
1456 -1 -> user pressed 'n' or equivalent,
1457 0 -> user pressed 'y' or equivalent,
1458 N -> user pressed NEWLINE or equivalent and N is LINES - 1. */
1461 gdb_display_match_list_pager (int lines,
1462 const struct match_list_displayer *displayer)
1466 displayer->puts (displayer, "--More--");
1467 displayer->flush (displayer);
1468 i = gdb_get_y_or_n (1, displayer);
1469 displayer->erase_entire_line (displayer);
1478 /* Return non-zero if FILENAME is a directory.
1479 Based on readline/complete.c:path_isdir. */
1482 gdb_path_isdir (const char *filename)
1486 return (stat (filename, &finfo) == 0 && S_ISDIR (finfo.st_mode));
1489 /* Return the portion of PATHNAME that should be output when listing
1490 possible completions. If we are hacking filename completion, we
1491 are only interested in the basename, the portion following the
1492 final slash. Otherwise, we return what we were passed. Since
1493 printing empty strings is not very informative, if we're doing
1494 filename completion, and the basename is the empty string, we look
1495 for the previous slash and return the portion following that. If
1496 there's no previous slash, we just return what we were passed.
1498 Based on readline/complete.c:printable_part. */
1501 gdb_printable_part (char *pathname)
1505 if (rl_filename_completion_desired == 0) /* don't need to do anything */
1508 temp = strrchr (pathname, '/');
1509 #if defined (__MSDOS__)
1510 if (temp == 0 && ISALPHA ((unsigned char)pathname[0]) && pathname[1] == ':')
1511 temp = pathname + 1;
1514 if (temp == 0 || *temp == '\0')
1516 /* If the basename is NULL, we might have a pathname like '/usr/src/'.
1517 Look for a previous slash and, if one is found, return the portion
1518 following that slash. If there's no previous slash, just return the
1519 pathname we were passed. */
1520 else if (temp[1] == '\0')
1522 for (x = temp - 1; x > pathname; x--)
1525 return ((*x == '/') ? x + 1 : pathname);
1531 /* Compute width of STRING when displayed on screen by print_filename.
1532 Based on readline/complete.c:fnwidth. */
1535 gdb_fnwidth (const char *string)
1538 #if defined (HANDLE_MULTIBYTE)
1544 left = strlen (string) + 1;
1545 memset (&ps, 0, sizeof (mbstate_t));
1551 if (CTRL_CHAR (string[pos]) || string[pos] == RUBOUT)
1558 #if defined (HANDLE_MULTIBYTE)
1559 clen = mbrtowc (&wc, string + pos, left - pos, &ps);
1560 if (MB_INVALIDCH (clen))
1564 memset (&ps, 0, sizeof (mbstate_t));
1566 else if (MB_NULLWCH (clen))
1572 width += (w >= 0) ? w : 1;
1584 /* Print TO_PRINT, one matching completion.
1585 PREFIX_BYTES is number of common prefix bytes.
1586 Based on readline/complete.c:fnprint. */
1589 gdb_fnprint (const char *to_print, int prefix_bytes,
1590 const struct match_list_displayer *displayer)
1594 #if defined (HANDLE_MULTIBYTE)
1601 end = to_print + strlen (to_print) + 1;
1602 memset (&ps, 0, sizeof (mbstate_t));
1607 /* Don't print only the ellipsis if the common prefix is one of the
1608 possible completions */
1609 if (to_print[prefix_bytes] == '\0')
1616 ellipsis = (to_print[prefix_bytes] == '.') ? '_' : '.';
1617 for (w = 0; w < ELLIPSIS_LEN; w++)
1618 displayer->putch (displayer, ellipsis);
1619 printed_len = ELLIPSIS_LEN;
1622 s = to_print + prefix_bytes;
1627 displayer->putch (displayer, '^');
1628 displayer->putch (displayer, UNCTRL (*s));
1631 #if defined (HANDLE_MULTIBYTE)
1632 memset (&ps, 0, sizeof (mbstate_t));
1635 else if (*s == RUBOUT)
1637 displayer->putch (displayer, '^');
1638 displayer->putch (displayer, '?');
1641 #if defined (HANDLE_MULTIBYTE)
1642 memset (&ps, 0, sizeof (mbstate_t));
1647 #if defined (HANDLE_MULTIBYTE)
1648 tlen = mbrtowc (&wc, s, end - s, &ps);
1649 if (MB_INVALIDCH (tlen))
1653 memset (&ps, 0, sizeof (mbstate_t));
1655 else if (MB_NULLWCH (tlen))
1660 width = (w >= 0) ? w : 1;
1662 for (w = 0; w < tlen; ++w)
1663 displayer->putch (displayer, s[w]);
1665 printed_len += width;
1667 displayer->putch (displayer, *s);
1677 /* Output TO_PRINT to rl_outstream. If VISIBLE_STATS is defined and we
1678 are using it, check for and output a single character for `special'
1679 filenames. Return the number of characters we output.
1680 Based on readline/complete.c:print_filename. */
1683 gdb_print_filename (char *to_print, char *full_pathname, int prefix_bytes,
1684 const struct match_list_displayer *displayer)
1686 int printed_len, extension_char, slen, tlen;
1687 char *s, c, *new_full_pathname, *dn;
1688 extern int _rl_complete_mark_directories;
1691 printed_len = gdb_fnprint (to_print, prefix_bytes, displayer);
1693 #if defined (VISIBLE_STATS)
1694 if (rl_filename_completion_desired && (rl_visible_stats || _rl_complete_mark_directories))
1696 if (rl_filename_completion_desired && _rl_complete_mark_directories)
1699 /* If to_print != full_pathname, to_print is the basename of the
1700 path passed. In this case, we try to expand the directory
1701 name before checking for the stat character. */
1702 if (to_print != full_pathname)
1704 /* Terminate the directory name. */
1706 to_print[-1] = '\0';
1708 /* If setting the last slash in full_pathname to a NUL results in
1709 full_pathname being the empty string, we are trying to complete
1710 files in the root directory. If we pass a null string to the
1711 bash directory completion hook, for example, it will expand it
1712 to the current directory. We just want the `/'. */
1713 if (full_pathname == 0 || *full_pathname == 0)
1715 else if (full_pathname[0] != '/')
1717 else if (full_pathname[1] == 0)
1718 dn = "//"; /* restore trailing slash to `//' */
1719 else if (full_pathname[1] == '/' && full_pathname[2] == 0)
1720 dn = "/"; /* don't turn /// into // */
1723 s = tilde_expand (dn);
1724 if (rl_directory_completion_hook)
1725 (*rl_directory_completion_hook) (&s);
1728 tlen = strlen (to_print);
1729 new_full_pathname = (char *)xmalloc (slen + tlen + 2);
1730 strcpy (new_full_pathname, s);
1731 if (s[slen - 1] == '/')
1734 new_full_pathname[slen] = '/';
1735 new_full_pathname[slen] = '/';
1736 strcpy (new_full_pathname + slen + 1, to_print);
1738 #if defined (VISIBLE_STATS)
1739 if (rl_visible_stats)
1740 extension_char = stat_char (new_full_pathname);
1743 if (gdb_path_isdir (new_full_pathname))
1744 extension_char = '/';
1746 xfree (new_full_pathname);
1751 s = tilde_expand (full_pathname);
1752 #if defined (VISIBLE_STATS)
1753 if (rl_visible_stats)
1754 extension_char = stat_char (s);
1757 if (gdb_path_isdir (s))
1758 extension_char = '/';
1764 displayer->putch (displayer, extension_char);
1772 /* GDB version of readline/complete.c:complete_get_screenwidth. */
1775 gdb_complete_get_screenwidth (const struct match_list_displayer *displayer)
1777 /* Readline has other stuff here which it's not clear we need. */
1778 return displayer->width;
1781 extern int _rl_completion_prefix_display_length;
1782 extern int _rl_print_completions_horizontally;
1784 EXTERN_C int _rl_qsort_string_compare (const void *, const void *);
1785 typedef int QSFUNC (const void *, const void *);
1787 /* GDB version of readline/complete.c:rl_display_match_list.
1788 See gdb_display_match_list for a description of MATCHES, LEN, MAX.
1789 Returns non-zero if all matches are displayed. */
1792 gdb_display_match_list_1 (char **matches, int len, int max,
1793 const struct match_list_displayer *displayer)
1795 int count, limit, printed_len, lines, cols;
1796 int i, j, k, l, common_length, sind;
1798 int page_completions = displayer->height != INT_MAX && pagination_enabled;
1800 /* Find the length of the prefix common to all items: length as displayed
1801 characters (common_length) and as a byte index into the matches (sind) */
1802 common_length = sind = 0;
1803 if (_rl_completion_prefix_display_length > 0)
1805 t = gdb_printable_part (matches[0]);
1806 temp = strrchr (t, '/');
1807 common_length = temp ? gdb_fnwidth (temp) : gdb_fnwidth (t);
1808 sind = temp ? strlen (temp) : strlen (t);
1810 if (common_length > _rl_completion_prefix_display_length && common_length > ELLIPSIS_LEN)
1811 max -= common_length - ELLIPSIS_LEN;
1813 common_length = sind = 0;
1816 /* How many items of MAX length can we fit in the screen window? */
1817 cols = gdb_complete_get_screenwidth (displayer);
1820 if (limit != 1 && (limit * max == cols))
1823 /* If cols == 0, limit will end up -1 */
1824 if (cols < displayer->width && limit < 0)
1827 /* Avoid a possible floating exception. If max > cols,
1828 limit will be 0 and a divide-by-zero fault will result. */
1832 /* How many iterations of the printing loop? */
1833 count = (len + (limit - 1)) / limit;
1835 /* Watch out for special case. If LEN is less than LIMIT, then
1836 just do the inner printing loop.
1837 0 < len <= limit implies count = 1. */
1839 /* Sort the items if they are not already sorted. */
1840 if (rl_ignore_completion_duplicates == 0 && rl_sort_completion_matches)
1841 qsort (matches + 1, len, sizeof (char *), (QSFUNC *)_rl_qsort_string_compare);
1843 displayer->crlf (displayer);
1846 if (_rl_print_completions_horizontally == 0)
1848 /* Print the sorted items, up-and-down alphabetically, like ls. */
1849 for (i = 1; i <= count; i++)
1851 for (j = 0, l = i; j < limit; j++)
1853 if (l > len || matches[l] == 0)
1857 temp = gdb_printable_part (matches[l]);
1858 printed_len = gdb_print_filename (temp, matches[l], sind,
1862 for (k = 0; k < max - printed_len; k++)
1863 displayer->putch (displayer, ' ');
1867 displayer->crlf (displayer);
1869 if (page_completions && lines >= (displayer->height - 1) && i < count)
1871 lines = gdb_display_match_list_pager (lines, displayer);
1879 /* Print the sorted items, across alphabetically, like ls -x. */
1880 for (i = 1; matches[i]; i++)
1882 temp = gdb_printable_part (matches[i]);
1883 printed_len = gdb_print_filename (temp, matches[i], sind, displayer);
1884 /* Have we reached the end of this line? */
1887 if (i && (limit > 1) && (i % limit) == 0)
1889 displayer->crlf (displayer);
1891 if (page_completions && lines >= displayer->height - 1)
1893 lines = gdb_display_match_list_pager (lines, displayer);
1899 for (k = 0; k < max - printed_len; k++)
1900 displayer->putch (displayer, ' ');
1903 displayer->crlf (displayer);
1909 /* Utility for displaying completion list matches, used by both CLI and TUI.
1911 MATCHES is the list of strings, in argv format, LEN is the number of
1912 strings in MATCHES, and MAX is the length of the longest string in
1916 gdb_display_match_list (char **matches, int len, int max,
1917 const struct match_list_displayer *displayer)
1919 /* Readline will never call this if complete_line returned NULL. */
1920 gdb_assert (max_completions != 0);
1922 /* complete_line will never return more than this. */
1923 if (max_completions > 0)
1924 gdb_assert (len <= max_completions);
1926 if (rl_completion_query_items > 0 && len >= rl_completion_query_items)
1930 /* We can't use *query here because they wait for <RET> which is
1931 wrong here. This follows the readline version as closely as possible
1932 for compatibility's sake. See readline/complete.c. */
1934 displayer->crlf (displayer);
1936 xsnprintf (msg, sizeof (msg),
1937 "Display all %d possibilities? (y or n)", len);
1938 displayer->puts (displayer, msg);
1939 displayer->flush (displayer);
1941 if (gdb_get_y_or_n (0, displayer) == 0)
1943 displayer->crlf (displayer);
1948 if (gdb_display_match_list_1 (matches, len, max, displayer))
1950 /* Note: MAX_COMPLETIONS may be -1 or zero, but LEN is always > 0. */
1951 if (len == max_completions)
1953 /* The maximum number of completions has been reached. Warn the user
1954 that there may be more. */
1955 const char *message = get_max_completions_reached_message ();
1957 displayer->puts (displayer, message);
1958 displayer->crlf (displayer);
1963 extern initialize_file_ftype _initialize_completer; /* -Wmissing-prototypes */
1966 _initialize_completer (void)
1968 add_setshow_zuinteger_unlimited_cmd ("max-completions", no_class,
1969 &max_completions, _("\
1970 Set maximum number of completion candidates."), _("\
1971 Show maximum number of completion candidates."), _("\
1972 Use this to limit the number of candidates considered\n\
1973 during completion. Specifying \"unlimited\" or -1\n\
1974 disables limiting. Note that setting either no limit or\n\
1975 a very large limit can make completion slow."),
1976 NULL, NULL, &setlist, &showlist);