1 /* Line completion stuff for GDB, the GNU debugger.
2 Copyright (C) 2000-2016 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 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 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
95 /* MS-DOS and MS-Windows use colon as part of the drive spec, and most
96 programs support @foo style response files. */
97 static char *gdb_completer_file_name_break_characters
= " \t\n*|\"';?><@";
99 static char *gdb_completer_file_name_break_characters
= " \t\n*|\"';:?><";
102 /* Characters that can be used to quote completion strings. Note that
103 we can't include '"' because the gdb C parser treats such quoted
104 sequences as strings. */
105 static char *gdb_completer_quote_characters
= "'";
107 /* Accessor for some completer data that may interest other files. */
110 get_gdb_completer_quote_characters (void)
112 return gdb_completer_quote_characters
;
115 /* Line completion interface function for readline. */
118 readline_line_completion_function (const char *text
, int matches
)
120 return line_completion_function (text
, matches
,
121 rl_line_buffer
, rl_point
);
124 /* This can be used for functions which don't want to complete on
125 symbols but don't want to complete on anything else either. */
127 noop_completer (struct cmd_list_element
*ignore
,
128 const char *text
, const char *prefix
)
133 /* Complete on filenames. */
135 filename_completer (struct cmd_list_element
*ignore
,
136 const char *text
, const char *word
)
139 VEC (char_ptr
) *return_val
= NULL
;
146 p
= rl_filename_completion_function (text
, subsequent_name
);
149 /* We need to set subsequent_name to a non-zero value before the
150 continue line below, because otherwise, if the first file
151 seen by GDB is a backup file whose name ends in a `~', we
152 will loop indefinitely. */
154 /* Like emacs, don't complete on old versions. Especially
155 useful in the "source" command. */
156 if (p
[strlen (p
) - 1] == '~')
163 /* Return exactly p. */
165 else if (word
> text
)
167 /* Return some portion of p. */
168 q
= (char *) xmalloc (strlen (p
) + 5);
169 strcpy (q
, p
+ (word
- text
));
174 /* Return some of TEXT plus p. */
175 q
= (char *) xmalloc (strlen (p
) + (text
- word
) + 5);
176 strncpy (q
, word
, text
- word
);
177 q
[text
- word
] = '\0';
181 VEC_safe_push (char_ptr
, return_val
, q
);
184 /* There is no way to do this just long enough to affect quote
185 inserting without also affecting the next completion. This
186 should be fixed in readline. FIXME. */
187 /* Ensure that readline does the right thing
188 with respect to inserting quotes. */
189 rl_completer_word_break_characters
= "";
194 /* Complete on linespecs, which might be of two possible forms:
200 This is intended to be used in commands that set breakpoints
203 static VEC (char_ptr
) *
204 linespec_location_completer (struct cmd_list_element
*ignore
,
205 const char *text
, const char *word
)
207 int n_syms
, n_files
, ix
;
208 VEC (char_ptr
) *fn_list
= NULL
;
209 VEC (char_ptr
) *list
= NULL
;
212 int quoted
= *text
== '\'' || *text
== '"';
213 int quote_char
= '\0';
214 const char *colon
= NULL
;
215 char *file_to_match
= NULL
;
216 const char *symbol_start
= text
;
217 const char *orig_text
= text
;
220 /* Do we have an unquoted colon, as in "break foo.c:bar"? */
221 for (p
= text
; *p
!= '\0'; ++p
)
223 if (*p
== '\\' && p
[1] == '\'')
225 else if (*p
== '\'' || *p
== '"')
229 while (*p
!= '\0' && *p
!= quote_found
)
231 if (*p
== '\\' && p
[1] == quote_found
)
236 if (*p
== quote_found
)
239 break; /* Hit the end of text. */
241 #if HAVE_DOS_BASED_FILE_SYSTEM
242 /* If we have a DOS-style absolute file name at the beginning of
243 TEXT, and the colon after the drive letter is the only colon
244 we found, pretend the colon is not there. */
245 else if (p
< text
+ 3 && *p
== ':' && p
== text
+ 1 + quoted
)
248 else if (*p
== ':' && !colon
)
251 symbol_start
= p
+ 1;
253 else if (strchr (current_language
->la_word_break_characters(), *p
))
254 symbol_start
= p
+ 1;
259 text_len
= strlen (text
);
261 /* Where is the file name? */
266 file_to_match
= (char *) xmalloc (colon
- text
+ 1);
267 strncpy (file_to_match
, text
, colon
- text
);
268 file_to_match
[colon
- text
] = '\0';
269 /* Remove trailing colons and quotes from the file name. */
270 for (s
= file_to_match
+ (colon
- text
);
273 if (*s
== ':' || *s
== quote_char
)
276 /* If the text includes a colon, they want completion only on a
277 symbol name after the colon. Otherwise, we need to complete on
278 symbols as well as on files. */
281 list
= make_file_symbol_completion_list (symbol_start
, word
,
283 xfree (file_to_match
);
287 list
= make_symbol_completion_list (symbol_start
, word
);
288 /* If text includes characters which cannot appear in a file
289 name, they cannot be asking for completion on files. */
291 gdb_completer_file_name_break_characters
) == text_len
)
292 fn_list
= make_source_files_completion_list (text
, text
);
295 n_syms
= VEC_length (char_ptr
, list
);
296 n_files
= VEC_length (char_ptr
, fn_list
);
298 /* Catenate fn_list[] onto the end of list[]. */
301 VEC_free (char_ptr
, list
); /* Paranoia. */
309 for (ix
= 0; VEC_iterate (char_ptr
, fn_list
, ix
, fn
); ++ix
)
310 VEC_safe_push (char_ptr
, list
, fn
);
311 VEC_free (char_ptr
, fn_list
);
314 if (n_syms
&& n_files
)
322 /* If we only have file names as possible completion, we should
323 bring them in sync with what rl_complete expects. The
324 problem is that if the user types "break /foo/b TAB", and the
325 possible completions are "/foo/bar" and "/foo/baz"
326 rl_complete expects us to return "bar" and "baz", without the
327 leading directories, as possible completions, because `word'
328 starts at the "b". But we ignore the value of `word' when we
329 call make_source_files_completion_list above (because that
330 would not DTRT when the completion results in both symbols
331 and file names), so make_source_files_completion_list returns
332 the full "/foo/bar" and "/foo/baz" strings. This produces
333 wrong results when, e.g., there's only one possible
334 completion, because rl_complete will prepend "/foo/" to each
335 candidate completion. The loop below removes that leading
337 for (ix
= 0; VEC_iterate (char_ptr
, list
, ix
, fn
); ++ix
)
339 memmove (fn
, fn
+ (word
- text
),
340 strlen (fn
) + 1 - (word
- text
));
345 /* No completions at all. As the final resort, try completing
346 on the entire text as a symbol. */
347 list
= make_symbol_completion_list (orig_text
, word
);
353 /* A helper function to collect explicit location matches for the given
354 LOCATION, which is attempting to match on WORD. */
356 static VEC (char_ptr
) *
357 collect_explicit_location_matches (struct event_location
*location
,
358 enum explicit_location_match_type what
,
361 VEC (char_ptr
) *matches
= NULL
;
362 const struct explicit_location
*explicit_loc
363 = get_explicit_location (location
);
369 const char *text
= (explicit_loc
->source_filename
== NULL
370 ? "" : explicit_loc
->source_filename
);
372 matches
= make_source_files_completion_list (text
, word
);
378 const char *text
= (explicit_loc
->function_name
== NULL
379 ? "" : explicit_loc
->function_name
);
381 if (explicit_loc
->source_filename
!= NULL
)
383 const char *filename
= explicit_loc
->source_filename
;
385 matches
= make_file_symbol_completion_list (text
, word
, filename
);
388 matches
= make_symbol_completion_list (text
, word
);
397 gdb_assert_not_reached ("unhandled explicit_location_match_type");
403 /* A convenience macro to (safely) back up P to the previous word. */
406 backup_text_ptr (const char *p
, const char *text
)
408 while (p
> text
&& isspace (*p
))
410 for (; p
> text
&& !isspace (p
[-1]); --p
)
416 /* A completer function for explicit locations. This function
417 completes both options ("-source", "-line", etc) and values. */
419 static VEC (char_ptr
) *
420 explicit_location_completer (struct cmd_list_element
*ignore
,
421 struct event_location
*location
,
422 const char *text
, const char *word
)
425 VEC (char_ptr
) *matches
= NULL
;
427 /* Find the beginning of the word. This is necessary because
428 we need to know if we are completing an option name or value. We
429 don't get the leading '-' from the completer. */
430 p
= backup_text_ptr (word
, text
);
434 /* Completing on option name. */
435 static const char *const keywords
[] =
444 /* Skip over the '-'. */
447 return complete_on_enum (keywords
, p
, p
);
451 /* Completing on value (or unknown). Get the previous word to see what
452 the user is completing on. */
454 const char *new_word
, *end
;
455 enum explicit_location_match_type what
;
456 struct explicit_location
*explicit_loc
457 = get_explicit_location (location
);
459 /* Backup P to the previous word, which should be the option
460 the user is attempting to complete. */
463 p
= backup_text_ptr (p
, text
);
466 if (strncmp (p
, "-source", len
) == 0)
469 new_word
= explicit_loc
->source_filename
+ offset
;
471 else if (strncmp (p
, "-function", len
) == 0)
473 what
= MATCH_FUNCTION
;
474 new_word
= explicit_loc
->function_name
+ offset
;
476 else if (strncmp (p
, "-label", len
) == 0)
479 new_word
= explicit_loc
->label_name
+ offset
;
483 /* The user isn't completing on any valid option name,
484 e.g., "break -source foo.c [tab]". */
488 /* If the user hasn't entered a search expression, e.g.,
489 "break -function <TAB><TAB>", new_word will be NULL, but
490 search routines require non-NULL search words. */
491 if (new_word
== NULL
)
494 /* Now gather matches */
495 matches
= collect_explicit_location_matches (location
, what
, new_word
);
501 /* A completer for locations. */
504 location_completer (struct cmd_list_element
*ignore
,
505 const char *text
, const char *word
)
507 VEC (char_ptr
) *matches
= NULL
;
508 const char *copy
= text
;
509 struct event_location
*location
;
511 location
= string_to_explicit_location (©
, current_language
, 1);
512 if (location
!= NULL
)
514 struct cleanup
*cleanup
;
516 cleanup
= make_cleanup_delete_event_location (location
);
517 matches
= explicit_location_completer (ignore
, location
, text
, word
);
518 do_cleanups (cleanup
);
522 /* This is an address or linespec location.
523 Right now both of these are handled by the (old) linespec
525 matches
= linespec_location_completer (ignore
, text
, word
);
531 /* Helper for expression_completer which recursively adds field and
532 method names from TYPE, a struct or union type, to the array
535 add_struct_fields (struct type
*type
, VEC (char_ptr
) **output
,
536 char *fieldname
, int namelen
)
539 int computed_type_name
= 0;
540 const char *type_name
= NULL
;
542 type
= check_typedef (type
);
543 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
545 if (i
< TYPE_N_BASECLASSES (type
))
546 add_struct_fields (TYPE_BASECLASS (type
, i
),
547 output
, fieldname
, namelen
);
548 else if (TYPE_FIELD_NAME (type
, i
))
550 if (TYPE_FIELD_NAME (type
, i
)[0] != '\0')
552 if (! strncmp (TYPE_FIELD_NAME (type
, i
),
554 VEC_safe_push (char_ptr
, *output
,
555 xstrdup (TYPE_FIELD_NAME (type
, i
)));
557 else if (TYPE_CODE (TYPE_FIELD_TYPE (type
, i
)) == TYPE_CODE_UNION
)
559 /* Recurse into anonymous unions. */
560 add_struct_fields (TYPE_FIELD_TYPE (type
, i
),
561 output
, fieldname
, namelen
);
566 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
568 const char *name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
570 if (name
&& ! strncmp (name
, fieldname
, namelen
))
572 if (!computed_type_name
)
574 type_name
= type_name_no_tag (type
);
575 computed_type_name
= 1;
577 /* Omit constructors from the completion list. */
578 if (!type_name
|| strcmp (type_name
, name
))
579 VEC_safe_push (char_ptr
, *output
, xstrdup (name
));
584 /* Complete on expressions. Often this means completing on symbol
585 names, but some language parsers also have support for completing
588 expression_completer (struct cmd_list_element
*ignore
,
589 const char *text
, const char *word
)
591 struct type
*type
= NULL
;
594 enum type_code code
= TYPE_CODE_UNDEF
;
596 /* Perform a tentative parse of the expression, to see whether a
597 field completion is required. */
601 type
= parse_expression_for_completion (text
, &fieldname
, &code
);
603 CATCH (except
, RETURN_MASK_ERROR
)
609 if (fieldname
&& type
)
613 type
= check_typedef (type
);
614 if (TYPE_CODE (type
) != TYPE_CODE_PTR
615 && TYPE_CODE (type
) != TYPE_CODE_REF
)
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_gdb_completion_word_break_characters (completer_ftype
*fn
)
658 /* So far we are only interested in differentiating filename
659 completers from everything else. */
660 if (fn
== filename_completer
)
661 rl_completer_word_break_characters
662 = gdb_completer_file_name_break_characters
;
664 rl_completer_word_break_characters
665 = gdb_completer_command_word_break_characters
;
668 /* Here are some useful test cases for completion. FIXME: These
669 should be put in the test suite. They should be tested with both
672 "show output-" "radix"
673 "show output" "-radix"
674 "p" ambiguous (commands starting with p--path, print, printf, etc.)
675 "p " ambiguous (all symbols)
676 "info t foo" no completions
677 "info t " no completions
678 "info t" ambiguous ("info target", "info terminal", etc.)
679 "info ajksdlfk" no completions
680 "info ajksdlfk " no completions
682 "info " ambiguous (all info commands)
683 "p \"a" no completions (string constant)
684 "p 'a" ambiguous (all symbols starting with a)
685 "p b-a" ambiguous (all symbols starting with a)
686 "p b-" ambiguous (all symbols)
687 "file Make" "file" (word break hard to screw up here)
688 "file ../gdb.stabs/we" "ird" (needs to not break word at slash)
697 complete_line_internal_reason
;
700 /* Internal function used to handle completions.
703 TEXT is the caller's idea of the "word" we are looking at.
705 LINE_BUFFER is available to be looked at; it contains the entire
706 text of the line. POINT is the offset in that line of the cursor.
707 You should pretend that the line ends at POINT.
709 REASON is of type complete_line_internal_reason.
711 If REASON is handle_brkchars:
712 Preliminary phase, called by gdb_completion_word_break_characters
713 function, is used to determine the correct set of chars that are
714 word delimiters depending on the current command in line_buffer.
715 No completion list should be generated; the return value should be
716 NULL. This is checked by an assertion in that function.
718 If REASON is handle_completions:
719 Main phase, called by complete_line function, is used to get the list
720 of posible completions.
722 If REASON is handle_help:
723 Special case when completing a 'help' command. In this case,
724 once sub-command completions are exhausted, we simply return NULL.
727 static VEC (char_ptr
) *
728 complete_line_internal (const char *text
,
729 const char *line_buffer
, int point
,
730 complete_line_internal_reason reason
)
732 VEC (char_ptr
) *list
= NULL
;
735 int ignore_help_classes
;
736 /* Pointer within tmp_command which corresponds to text. */
738 struct cmd_list_element
*c
, *result_list
;
740 /* Choose the default set of word break characters to break
741 completions. If we later find out that we are doing completions
742 on command strings (as opposed to strings supplied by the
743 individual command completer functions, which can be any string)
744 then we will switch to the special word break set for command
745 strings, which leaves out the '-' character used in some
747 rl_completer_word_break_characters
=
748 current_language
->la_word_break_characters();
750 /* Decide whether to complete on a list of gdb commands or on
752 tmp_command
= (char *) alloca (point
+ 1);
755 /* The help command should complete help aliases. */
756 ignore_help_classes
= reason
!= handle_help
;
758 strncpy (tmp_command
, line_buffer
, point
);
759 tmp_command
[point
] = '\0';
760 /* Since text always contains some number of characters leading up
761 to point, we can find the equivalent position in tmp_command
762 by subtracting that many characters from the end of tmp_command. */
763 word
= tmp_command
+ point
- strlen (text
);
767 /* An empty line we want to consider ambiguous; that is, it
768 could be any command. */
769 c
= CMD_LIST_AMBIGUOUS
;
774 c
= lookup_cmd_1 (&p
, cmdlist
, &result_list
, ignore_help_classes
);
777 /* Move p up to the next interesting thing. */
778 while (*p
== ' ' || *p
== '\t')
785 /* It is an unrecognized command. So there are no
786 possible completions. */
789 else if (c
== CMD_LIST_AMBIGUOUS
)
793 /* lookup_cmd_1 advances p up to the first ambiguous thing, but
794 doesn't advance over that thing itself. Do so now. */
796 while (*q
&& (isalnum (*q
) || *q
== '-' || *q
== '_'))
798 if (q
!= tmp_command
+ point
)
800 /* There is something beyond the ambiguous
801 command, so there are no possible completions. For
802 example, "info t " or "info t foo" does not complete
803 to anything, because "info t" can be "info target" or
809 /* We're trying to complete on the command which was ambiguous.
810 This we can deal with. */
813 if (reason
!= handle_brkchars
)
814 list
= complete_on_cmdlist (*result_list
->prefixlist
, p
,
815 word
, ignore_help_classes
);
819 if (reason
!= handle_brkchars
)
820 list
= complete_on_cmdlist (cmdlist
, p
, word
,
821 ignore_help_classes
);
823 /* Ensure that readline does the right thing with respect to
825 rl_completer_word_break_characters
=
826 gdb_completer_command_word_break_characters
;
831 /* We've recognized a full command. */
833 if (p
== tmp_command
+ point
)
835 /* There is no non-whitespace in the line beyond the
838 if (p
[-1] == ' ' || p
[-1] == '\t')
840 /* The command is followed by whitespace; we need to
841 complete on whatever comes after command. */
844 /* It is a prefix command; what comes after it is
845 a subcommand (e.g. "info "). */
846 if (reason
!= handle_brkchars
)
847 list
= complete_on_cmdlist (*c
->prefixlist
, p
, word
,
848 ignore_help_classes
);
850 /* Ensure that readline does the right thing
851 with respect to inserting quotes. */
852 rl_completer_word_break_characters
=
853 gdb_completer_command_word_break_characters
;
855 else if (reason
== handle_help
)
859 if (reason
!= handle_brkchars
)
860 list
= complete_on_enum (c
->enums
, p
, word
);
861 rl_completer_word_break_characters
=
862 gdb_completer_command_word_break_characters
;
866 /* It is a normal command; what comes after it is
867 completed by the command's completer function. */
868 if (c
->completer
== filename_completer
)
870 /* Many commands which want to complete on
871 file names accept several file names, as
872 in "run foo bar >>baz". So we don't want
873 to complete the entire text after the
874 command, just the last word. To this
875 end, we need to find the beginning of the
876 file name by starting at `word' and going
880 && strchr (gdb_completer_file_name_break_characters
, p
[-1]) == NULL
;
883 rl_completer_word_break_characters
=
884 gdb_completer_file_name_break_characters
;
886 if (reason
== handle_brkchars
887 && c
->completer_handle_brkchars
!= NULL
)
888 (*c
->completer_handle_brkchars
) (c
, p
, word
);
889 if (reason
!= handle_brkchars
&& c
->completer
!= NULL
)
890 list
= (*c
->completer
) (c
, p
, word
);
895 /* The command is not followed by whitespace; we need to
896 complete on the command itself, e.g. "p" which is a
897 command itself but also can complete to "print", "ptype"
901 /* Find the command we are completing on. */
903 while (q
> tmp_command
)
905 if (isalnum (q
[-1]) || q
[-1] == '-' || q
[-1] == '_')
911 if (reason
!= handle_brkchars
)
912 list
= complete_on_cmdlist (result_list
, q
, word
,
913 ignore_help_classes
);
915 /* Ensure that readline does the right thing
916 with respect to inserting quotes. */
917 rl_completer_word_break_characters
=
918 gdb_completer_command_word_break_characters
;
921 else if (reason
== handle_help
)
925 /* There is non-whitespace beyond the command. */
927 if (c
->prefixlist
&& !c
->allow_unknown
)
929 /* It is an unrecognized subcommand of a prefix command,
930 e.g. "info adsfkdj". */
935 if (reason
!= handle_brkchars
)
936 list
= complete_on_enum (c
->enums
, p
, word
);
940 /* It is a normal command. */
941 if (c
->completer
== filename_completer
)
943 /* See the commentary above about the specifics
944 of file-name completion. */
947 && strchr (gdb_completer_file_name_break_characters
,
951 rl_completer_word_break_characters
=
952 gdb_completer_file_name_break_characters
;
954 if (reason
== handle_brkchars
955 && c
->completer_handle_brkchars
!= NULL
)
956 (*c
->completer_handle_brkchars
) (c
, p
, word
);
957 if (reason
!= handle_brkchars
&& c
->completer
!= NULL
)
958 list
= (*c
->completer
) (c
, p
, word
);
966 /* See completer.h. */
968 int max_completions
= 200;
970 /* See completer.h. */
973 new_completion_tracker (void)
975 if (max_completions
<= 0)
978 return htab_create_alloc (max_completions
,
979 htab_hash_string
, (htab_eq
) streq
,
980 NULL
, xcalloc
, xfree
);
983 /* Cleanup routine to free a completion tracker and reset the pointer
987 free_completion_tracker (void *p
)
989 completion_tracker_t
*tracker_ptr
= (completion_tracker_t
*) p
;
991 htab_delete (*tracker_ptr
);
995 /* See completer.h. */
998 make_cleanup_free_completion_tracker (completion_tracker_t
*tracker_ptr
)
1000 if (*tracker_ptr
== NULL
)
1001 return make_cleanup (null_cleanup
, NULL
);
1003 return make_cleanup (free_completion_tracker
, tracker_ptr
);
1006 /* See completer.h. */
1008 enum maybe_add_completion_enum
1009 maybe_add_completion (completion_tracker_t tracker
, char *name
)
1013 if (max_completions
< 0)
1014 return MAYBE_ADD_COMPLETION_OK
;
1015 if (max_completions
== 0)
1016 return MAYBE_ADD_COMPLETION_MAX_REACHED
;
1018 gdb_assert (tracker
!= NULL
);
1020 if (htab_elements (tracker
) >= max_completions
)
1021 return MAYBE_ADD_COMPLETION_MAX_REACHED
;
1023 slot
= htab_find_slot (tracker
, name
, INSERT
);
1025 if (*slot
!= HTAB_EMPTY_ENTRY
)
1026 return MAYBE_ADD_COMPLETION_DUPLICATE
;
1030 return (htab_elements (tracker
) < max_completions
1031 ? MAYBE_ADD_COMPLETION_OK
1032 : MAYBE_ADD_COMPLETION_OK_MAX_REACHED
);
1036 throw_max_completions_reached_error (void)
1038 throw_error (MAX_COMPLETIONS_REACHED_ERROR
, _("Max completions reached."));
1041 /* Generate completions all at once. Returns a vector of unique strings
1042 allocated with xmalloc. Returns NULL if there are no completions
1043 or if max_completions is 0. If max_completions is non-negative, this will
1044 return at most max_completions strings.
1046 TEXT is the caller's idea of the "word" we are looking at.
1048 LINE_BUFFER is available to be looked at; it contains the entire
1051 POINT is the offset in that line of the cursor. You
1052 should pretend that the line ends at POINT. */
1055 complete_line (const char *text
, const char *line_buffer
, int point
)
1057 VEC (char_ptr
) *list
;
1058 VEC (char_ptr
) *result
= NULL
;
1059 struct cleanup
*cleanups
;
1060 completion_tracker_t tracker
;
1062 int ix
, max_reached
;
1064 if (max_completions
== 0)
1066 list
= complete_line_internal (text
, line_buffer
, point
,
1067 handle_completions
);
1068 if (max_completions
< 0)
1071 tracker
= new_completion_tracker ();
1072 cleanups
= make_cleanup_free_completion_tracker (&tracker
);
1073 make_cleanup_free_char_ptr_vec (list
);
1075 /* Do a final test for too many completions. Individual completers may
1076 do some of this, but are not required to. Duplicates are also removed
1077 here. Otherwise the user is left scratching his/her head: readline and
1078 complete_command will remove duplicates, and if removal of duplicates
1079 there brings the total under max_completions the user may think gdb quit
1080 searching too early. */
1082 for (ix
= 0, max_reached
= 0;
1083 !max_reached
&& VEC_iterate (char_ptr
, list
, ix
, candidate
);
1086 enum maybe_add_completion_enum add_status
;
1088 add_status
= maybe_add_completion (tracker
, candidate
);
1092 case MAYBE_ADD_COMPLETION_OK
:
1093 VEC_safe_push (char_ptr
, result
, xstrdup (candidate
));
1095 case MAYBE_ADD_COMPLETION_OK_MAX_REACHED
:
1096 VEC_safe_push (char_ptr
, result
, xstrdup (candidate
));
1099 case MAYBE_ADD_COMPLETION_MAX_REACHED
:
1100 gdb_assert_not_reached ("more than max completions reached");
1101 case MAYBE_ADD_COMPLETION_DUPLICATE
:
1106 do_cleanups (cleanups
);
1111 /* Complete on command names. Used by "help". */
1113 command_completer (struct cmd_list_element
*ignore
,
1114 const char *text
, const char *word
)
1116 return complete_line_internal (word
, text
,
1117 strlen (text
), handle_help
);
1120 /* Complete on signals. */
1123 signal_completer (struct cmd_list_element
*ignore
,
1124 const char *text
, const char *word
)
1126 VEC (char_ptr
) *return_val
= NULL
;
1127 size_t len
= strlen (word
);
1129 const char *signame
;
1131 for (signum
= GDB_SIGNAL_FIRST
; signum
!= GDB_SIGNAL_LAST
; ++signum
)
1133 /* Can't handle this, so skip it. */
1134 if (signum
== GDB_SIGNAL_0
)
1137 signame
= gdb_signal_to_name ((enum gdb_signal
) signum
);
1139 /* Ignore the unknown signal case. */
1140 if (!signame
|| strcmp (signame
, "?") == 0)
1143 if (strncasecmp (signame
, word
, len
) == 0)
1144 VEC_safe_push (char_ptr
, return_val
, xstrdup (signame
));
1150 /* Bit-flags for selecting what the register and/or register-group
1151 completer should complete on. */
1153 enum reg_completer_target
1155 complete_register_names
= 0x1,
1156 complete_reggroup_names
= 0x2
1158 DEF_ENUM_FLAGS_TYPE (enum reg_completer_target
, reg_completer_targets
);
1160 /* Complete register names and/or reggroup names based on the value passed
1161 in TARGETS. At least one bit in TARGETS must be set. */
1163 static VEC (char_ptr
) *
1164 reg_or_group_completer_1 (struct cmd_list_element
*ignore
,
1165 const char *text
, const char *word
,
1166 reg_completer_targets targets
)
1168 VEC (char_ptr
) *result
= NULL
;
1169 size_t len
= strlen (word
);
1170 struct gdbarch
*gdbarch
;
1173 gdb_assert ((targets
& (complete_register_names
1174 | complete_reggroup_names
)) != 0);
1175 gdbarch
= get_current_arch ();
1177 if ((targets
& complete_register_names
) != 0)
1182 (name
= user_reg_map_regnum_to_name (gdbarch
, i
)) != NULL
;
1185 if (*name
!= '\0' && strncmp (word
, name
, len
) == 0)
1186 VEC_safe_push (char_ptr
, result
, xstrdup (name
));
1190 if ((targets
& complete_reggroup_names
) != 0)
1192 struct reggroup
*group
;
1194 for (group
= reggroup_next (gdbarch
, NULL
);
1196 group
= reggroup_next (gdbarch
, group
))
1198 name
= reggroup_name (group
);
1199 if (strncmp (word
, name
, len
) == 0)
1200 VEC_safe_push (char_ptr
, result
, xstrdup (name
));
1207 /* Perform completion on register and reggroup names. */
1210 reg_or_group_completer (struct cmd_list_element
*ignore
,
1211 const char *text
, const char *word
)
1213 return reg_or_group_completer_1 (ignore
, text
, word
,
1214 (complete_register_names
1215 | complete_reggroup_names
));
1218 /* Perform completion on reggroup names. */
1221 reggroup_completer (struct cmd_list_element
*ignore
,
1222 const char *text
, const char *word
)
1224 return reg_or_group_completer_1 (ignore
, text
, word
,
1225 complete_reggroup_names
);
1228 /* Get the list of chars that are considered as word breaks
1229 for the current command. */
1232 gdb_completion_word_break_characters (void)
1234 VEC (char_ptr
) *list
;
1236 list
= complete_line_internal (rl_line_buffer
, rl_line_buffer
, rl_point
,
1238 gdb_assert (list
== NULL
);
1239 return rl_completer_word_break_characters
;
1242 /* Generate completions one by one for the completer. Each time we
1243 are called return another potential completion to the caller.
1244 line_completion just completes on commands or passes the buck to
1245 the command's completer function, the stuff specific to symbol
1246 completion is in make_symbol_completion_list.
1248 TEXT is the caller's idea of the "word" we are looking at.
1250 MATCHES is the number of matches that have currently been collected
1251 from calling this completion function. When zero, then we need to
1252 initialize, otherwise the initialization has already taken place
1253 and we can just return the next potential completion string.
1255 LINE_BUFFER is available to be looked at; it contains the entire
1256 text of the line. POINT is the offset in that line of the cursor.
1257 You should pretend that the line ends at POINT.
1259 Returns NULL if there are no more completions, else a pointer to a
1260 string which is a possible completion, it is the caller's
1261 responsibility to free the string. */
1264 line_completion_function (const char *text
, int matches
,
1265 char *line_buffer
, int point
)
1267 static VEC (char_ptr
) *list
= NULL
; /* Cache of completions. */
1268 static int index
; /* Next cached completion. */
1269 char *output
= NULL
;
1273 /* The caller is beginning to accumulate a new set of
1274 completions, so we need to find all of them now, and cache
1275 them for returning one at a time on future calls. */
1279 /* Free the storage used by LIST, but not by the strings
1280 inside. This is because rl_complete_internal () frees
1281 the strings. As complete_line may abort by calling
1282 `error' clear LIST now. */
1283 VEC_free (char_ptr
, list
);
1286 list
= complete_line (text
, line_buffer
, point
);
1289 /* If we found a list of potential completions during initialization
1290 then dole them out one at a time. After returning the last one,
1291 return NULL (and continue to do so) each time we are called after
1292 that, until a new list is available. */
1296 if (index
< VEC_length (char_ptr
, list
))
1298 output
= VEC_index (char_ptr
, list
, index
);
1304 /* Can't do this because readline hasn't yet checked the word breaks
1305 for figuring out whether to insert a quote. */
1307 /* Make sure the word break characters are set back to normal for
1308 the next time that readline tries to complete something. */
1309 rl_completer_word_break_characters
=
1310 current_language
->la_word_break_characters();
1316 /* Skip over the possibly quoted word STR (as defined by the quote
1317 characters QUOTECHARS and the word break characters BREAKCHARS).
1318 Returns pointer to the location after the "word". If either
1319 QUOTECHARS or BREAKCHARS is NULL, use the same values used by the
1323 skip_quoted_chars (const char *str
, const char *quotechars
,
1324 const char *breakchars
)
1326 char quote_char
= '\0';
1329 if (quotechars
== NULL
)
1330 quotechars
= gdb_completer_quote_characters
;
1332 if (breakchars
== NULL
)
1333 breakchars
= current_language
->la_word_break_characters();
1335 for (scan
= str
; *scan
!= '\0'; scan
++)
1337 if (quote_char
!= '\0')
1339 /* Ignore everything until the matching close quote char. */
1340 if (*scan
== quote_char
)
1342 /* Found matching close quote. */
1347 else if (strchr (quotechars
, *scan
))
1349 /* Found start of a quoted string. */
1352 else if (strchr (breakchars
, *scan
))
1361 /* Skip over the possibly quoted word STR (as defined by the quote
1362 characters and word break characters used by the completer).
1363 Returns pointer to the location after the "word". */
1366 skip_quoted (const char *str
)
1368 return skip_quoted_chars (str
, NULL
, NULL
);
1371 /* Return a message indicating that the maximum number of completions
1372 has been reached and that there may be more. */
1375 get_max_completions_reached_message (void)
1377 return _("*** List may be truncated, max-completions reached. ***");
1380 /* GDB replacement for rl_display_match_list.
1381 Readline doesn't provide a clean interface for TUI(curses).
1382 A hack previously used was to send readline's rl_outstream through a pipe
1383 and read it from the event loop. Bleah. IWBN if readline abstracted
1384 away all the necessary bits, and this is what this code does. It
1385 replicates the parts of readline we need and then adds an abstraction
1386 layer, currently implemented as struct match_list_displayer, so that both
1387 CLI and TUI can use it. We copy all this readline code to minimize
1388 GDB-specific mods to readline. Once this code performs as desired then
1389 we can submit it to the readline maintainers.
1391 N.B. A lot of the code is the way it is in order to minimize differences
1392 from readline's copy. */
1394 /* Not supported here. */
1395 #undef VISIBLE_STATS
1397 #if defined (HANDLE_MULTIBYTE)
1398 #define MB_INVALIDCH(x) ((x) == (size_t)-1 || (x) == (size_t)-2)
1399 #define MB_NULLWCH(x) ((x) == 0)
1402 #define ELLIPSIS_LEN 3
1404 /* gdb version of readline/complete.c:get_y_or_n.
1405 'y' -> returns 1, and 'n' -> returns 0.
1406 Also supported: space == 'y', RUBOUT == 'n', ctrl-g == start over.
1407 If FOR_PAGER is non-zero, then also supported are:
1408 NEWLINE or RETURN -> returns 2, and 'q' -> returns 0. */
1411 gdb_get_y_or_n (int for_pager
, const struct match_list_displayer
*displayer
)
1417 RL_SETSTATE (RL_STATE_MOREINPUT
);
1418 c
= displayer
->read_key (displayer
);
1419 RL_UNSETSTATE (RL_STATE_MOREINPUT
);
1421 if (c
== 'y' || c
== 'Y' || c
== ' ')
1423 if (c
== 'n' || c
== 'N' || c
== RUBOUT
)
1425 if (c
== ABORT_CHAR
|| c
< 0)
1427 /* Readline doesn't erase_entire_line here, but without it the
1428 --More-- prompt isn't erased and neither is the text entered
1429 thus far redisplayed. */
1430 displayer
->erase_entire_line (displayer
);
1431 /* Note: The arguments to rl_abort are ignored. */
1434 if (for_pager
&& (c
== NEWLINE
|| c
== RETURN
))
1436 if (for_pager
&& (c
== 'q' || c
== 'Q'))
1438 displayer
->beep (displayer
);
1442 /* Pager function for tab-completion.
1443 This is based on readline/complete.c:_rl_internal_pager.
1444 LINES is the number of lines of output displayed thus far.
1446 -1 -> user pressed 'n' or equivalent,
1447 0 -> user pressed 'y' or equivalent,
1448 N -> user pressed NEWLINE or equivalent and N is LINES - 1. */
1451 gdb_display_match_list_pager (int lines
,
1452 const struct match_list_displayer
*displayer
)
1456 displayer
->puts (displayer
, "--More--");
1457 displayer
->flush (displayer
);
1458 i
= gdb_get_y_or_n (1, displayer
);
1459 displayer
->erase_entire_line (displayer
);
1468 /* Return non-zero if FILENAME is a directory.
1469 Based on readline/complete.c:path_isdir. */
1472 gdb_path_isdir (const char *filename
)
1476 return (stat (filename
, &finfo
) == 0 && S_ISDIR (finfo
.st_mode
));
1479 /* Return the portion of PATHNAME that should be output when listing
1480 possible completions. If we are hacking filename completion, we
1481 are only interested in the basename, the portion following the
1482 final slash. Otherwise, we return what we were passed. Since
1483 printing empty strings is not very informative, if we're doing
1484 filename completion, and the basename is the empty string, we look
1485 for the previous slash and return the portion following that. If
1486 there's no previous slash, we just return what we were passed.
1488 Based on readline/complete.c:printable_part. */
1491 gdb_printable_part (char *pathname
)
1495 if (rl_filename_completion_desired
== 0) /* don't need to do anything */
1498 temp
= strrchr (pathname
, '/');
1499 #if defined (__MSDOS__)
1500 if (temp
== 0 && ISALPHA ((unsigned char)pathname
[0]) && pathname
[1] == ':')
1501 temp
= pathname
+ 1;
1504 if (temp
== 0 || *temp
== '\0')
1506 /* If the basename is NULL, we might have a pathname like '/usr/src/'.
1507 Look for a previous slash and, if one is found, return the portion
1508 following that slash. If there's no previous slash, just return the
1509 pathname we were passed. */
1510 else if (temp
[1] == '\0')
1512 for (x
= temp
- 1; x
> pathname
; x
--)
1515 return ((*x
== '/') ? x
+ 1 : pathname
);
1521 /* Compute width of STRING when displayed on screen by print_filename.
1522 Based on readline/complete.c:fnwidth. */
1525 gdb_fnwidth (const char *string
)
1528 #if defined (HANDLE_MULTIBYTE)
1534 left
= strlen (string
) + 1;
1535 memset (&ps
, 0, sizeof (mbstate_t));
1541 if (CTRL_CHAR (string
[pos
]) || string
[pos
] == RUBOUT
)
1548 #if defined (HANDLE_MULTIBYTE)
1549 clen
= mbrtowc (&wc
, string
+ pos
, left
- pos
, &ps
);
1550 if (MB_INVALIDCH (clen
))
1554 memset (&ps
, 0, sizeof (mbstate_t));
1556 else if (MB_NULLWCH (clen
))
1562 width
+= (w
>= 0) ? w
: 1;
1574 /* Print TO_PRINT, one matching completion.
1575 PREFIX_BYTES is number of common prefix bytes.
1576 Based on readline/complete.c:fnprint. */
1579 gdb_fnprint (const char *to_print
, int prefix_bytes
,
1580 const struct match_list_displayer
*displayer
)
1584 #if defined (HANDLE_MULTIBYTE)
1591 end
= to_print
+ strlen (to_print
) + 1;
1592 memset (&ps
, 0, sizeof (mbstate_t));
1597 /* Don't print only the ellipsis if the common prefix is one of the
1598 possible completions */
1599 if (to_print
[prefix_bytes
] == '\0')
1606 ellipsis
= (to_print
[prefix_bytes
] == '.') ? '_' : '.';
1607 for (w
= 0; w
< ELLIPSIS_LEN
; w
++)
1608 displayer
->putch (displayer
, ellipsis
);
1609 printed_len
= ELLIPSIS_LEN
;
1612 s
= to_print
+ prefix_bytes
;
1617 displayer
->putch (displayer
, '^');
1618 displayer
->putch (displayer
, UNCTRL (*s
));
1621 #if defined (HANDLE_MULTIBYTE)
1622 memset (&ps
, 0, sizeof (mbstate_t));
1625 else if (*s
== RUBOUT
)
1627 displayer
->putch (displayer
, '^');
1628 displayer
->putch (displayer
, '?');
1631 #if defined (HANDLE_MULTIBYTE)
1632 memset (&ps
, 0, sizeof (mbstate_t));
1637 #if defined (HANDLE_MULTIBYTE)
1638 tlen
= mbrtowc (&wc
, s
, end
- s
, &ps
);
1639 if (MB_INVALIDCH (tlen
))
1643 memset (&ps
, 0, sizeof (mbstate_t));
1645 else if (MB_NULLWCH (tlen
))
1650 width
= (w
>= 0) ? w
: 1;
1652 for (w
= 0; w
< tlen
; ++w
)
1653 displayer
->putch (displayer
, s
[w
]);
1655 printed_len
+= width
;
1657 displayer
->putch (displayer
, *s
);
1667 /* Output TO_PRINT to rl_outstream. If VISIBLE_STATS is defined and we
1668 are using it, check for and output a single character for `special'
1669 filenames. Return the number of characters we output.
1670 Based on readline/complete.c:print_filename. */
1673 gdb_print_filename (char *to_print
, char *full_pathname
, int prefix_bytes
,
1674 const struct match_list_displayer
*displayer
)
1676 int printed_len
, extension_char
, slen
, tlen
;
1677 char *s
, c
, *new_full_pathname
, *dn
;
1678 extern int _rl_complete_mark_directories
;
1681 printed_len
= gdb_fnprint (to_print
, prefix_bytes
, displayer
);
1683 #if defined (VISIBLE_STATS)
1684 if (rl_filename_completion_desired
&& (rl_visible_stats
|| _rl_complete_mark_directories
))
1686 if (rl_filename_completion_desired
&& _rl_complete_mark_directories
)
1689 /* If to_print != full_pathname, to_print is the basename of the
1690 path passed. In this case, we try to expand the directory
1691 name before checking for the stat character. */
1692 if (to_print
!= full_pathname
)
1694 /* Terminate the directory name. */
1696 to_print
[-1] = '\0';
1698 /* If setting the last slash in full_pathname to a NUL results in
1699 full_pathname being the empty string, we are trying to complete
1700 files in the root directory. If we pass a null string to the
1701 bash directory completion hook, for example, it will expand it
1702 to the current directory. We just want the `/'. */
1703 if (full_pathname
== 0 || *full_pathname
== 0)
1705 else if (full_pathname
[0] != '/')
1707 else if (full_pathname
[1] == 0)
1708 dn
= "//"; /* restore trailing slash to `//' */
1709 else if (full_pathname
[1] == '/' && full_pathname
[2] == 0)
1710 dn
= "/"; /* don't turn /// into // */
1713 s
= tilde_expand (dn
);
1714 if (rl_directory_completion_hook
)
1715 (*rl_directory_completion_hook
) (&s
);
1718 tlen
= strlen (to_print
);
1719 new_full_pathname
= (char *)xmalloc (slen
+ tlen
+ 2);
1720 strcpy (new_full_pathname
, s
);
1721 if (s
[slen
- 1] == '/')
1724 new_full_pathname
[slen
] = '/';
1725 new_full_pathname
[slen
] = '/';
1726 strcpy (new_full_pathname
+ slen
+ 1, to_print
);
1728 #if defined (VISIBLE_STATS)
1729 if (rl_visible_stats
)
1730 extension_char
= stat_char (new_full_pathname
);
1733 if (gdb_path_isdir (new_full_pathname
))
1734 extension_char
= '/';
1736 xfree (new_full_pathname
);
1741 s
= tilde_expand (full_pathname
);
1742 #if defined (VISIBLE_STATS)
1743 if (rl_visible_stats
)
1744 extension_char
= stat_char (s
);
1747 if (gdb_path_isdir (s
))
1748 extension_char
= '/';
1754 displayer
->putch (displayer
, extension_char
);
1762 /* GDB version of readline/complete.c:complete_get_screenwidth. */
1765 gdb_complete_get_screenwidth (const struct match_list_displayer
*displayer
)
1767 /* Readline has other stuff here which it's not clear we need. */
1768 return displayer
->width
;
1771 extern int _rl_completion_prefix_display_length
;
1772 extern int _rl_print_completions_horizontally
;
1774 EXTERN_C
int _rl_qsort_string_compare (const void *, const void *);
1775 typedef int QSFUNC (const void *, const void *);
1777 /* GDB version of readline/complete.c:rl_display_match_list.
1778 See gdb_display_match_list for a description of MATCHES, LEN, MAX.
1779 Returns non-zero if all matches are displayed. */
1782 gdb_display_match_list_1 (char **matches
, int len
, int max
,
1783 const struct match_list_displayer
*displayer
)
1785 int count
, limit
, printed_len
, lines
, cols
;
1786 int i
, j
, k
, l
, common_length
, sind
;
1788 int page_completions
= displayer
->height
!= INT_MAX
&& pagination_enabled
;
1790 /* Find the length of the prefix common to all items: length as displayed
1791 characters (common_length) and as a byte index into the matches (sind) */
1792 common_length
= sind
= 0;
1793 if (_rl_completion_prefix_display_length
> 0)
1795 t
= gdb_printable_part (matches
[0]);
1796 temp
= strrchr (t
, '/');
1797 common_length
= temp
? gdb_fnwidth (temp
) : gdb_fnwidth (t
);
1798 sind
= temp
? strlen (temp
) : strlen (t
);
1800 if (common_length
> _rl_completion_prefix_display_length
&& common_length
> ELLIPSIS_LEN
)
1801 max
-= common_length
- ELLIPSIS_LEN
;
1803 common_length
= sind
= 0;
1806 /* How many items of MAX length can we fit in the screen window? */
1807 cols
= gdb_complete_get_screenwidth (displayer
);
1810 if (limit
!= 1 && (limit
* max
== cols
))
1813 /* If cols == 0, limit will end up -1 */
1814 if (cols
< displayer
->width
&& limit
< 0)
1817 /* Avoid a possible floating exception. If max > cols,
1818 limit will be 0 and a divide-by-zero fault will result. */
1822 /* How many iterations of the printing loop? */
1823 count
= (len
+ (limit
- 1)) / limit
;
1825 /* Watch out for special case. If LEN is less than LIMIT, then
1826 just do the inner printing loop.
1827 0 < len <= limit implies count = 1. */
1829 /* Sort the items if they are not already sorted. */
1830 if (rl_ignore_completion_duplicates
== 0 && rl_sort_completion_matches
)
1831 qsort (matches
+ 1, len
, sizeof (char *), (QSFUNC
*)_rl_qsort_string_compare
);
1833 displayer
->crlf (displayer
);
1836 if (_rl_print_completions_horizontally
== 0)
1838 /* Print the sorted items, up-and-down alphabetically, like ls. */
1839 for (i
= 1; i
<= count
; i
++)
1841 for (j
= 0, l
= i
; j
< limit
; j
++)
1843 if (l
> len
|| matches
[l
] == 0)
1847 temp
= gdb_printable_part (matches
[l
]);
1848 printed_len
= gdb_print_filename (temp
, matches
[l
], sind
,
1852 for (k
= 0; k
< max
- printed_len
; k
++)
1853 displayer
->putch (displayer
, ' ');
1857 displayer
->crlf (displayer
);
1859 if (page_completions
&& lines
>= (displayer
->height
- 1) && i
< count
)
1861 lines
= gdb_display_match_list_pager (lines
, displayer
);
1869 /* Print the sorted items, across alphabetically, like ls -x. */
1870 for (i
= 1; matches
[i
]; i
++)
1872 temp
= gdb_printable_part (matches
[i
]);
1873 printed_len
= gdb_print_filename (temp
, matches
[i
], sind
, displayer
);
1874 /* Have we reached the end of this line? */
1877 if (i
&& (limit
> 1) && (i
% limit
) == 0)
1879 displayer
->crlf (displayer
);
1881 if (page_completions
&& lines
>= displayer
->height
- 1)
1883 lines
= gdb_display_match_list_pager (lines
, displayer
);
1889 for (k
= 0; k
< max
- printed_len
; k
++)
1890 displayer
->putch (displayer
, ' ');
1893 displayer
->crlf (displayer
);
1899 /* Utility for displaying completion list matches, used by both CLI and TUI.
1901 MATCHES is the list of strings, in argv format, LEN is the number of
1902 strings in MATCHES, and MAX is the length of the longest string in
1906 gdb_display_match_list (char **matches
, int len
, int max
,
1907 const struct match_list_displayer
*displayer
)
1909 /* Readline will never call this if complete_line returned NULL. */
1910 gdb_assert (max_completions
!= 0);
1912 /* complete_line will never return more than this. */
1913 if (max_completions
> 0)
1914 gdb_assert (len
<= max_completions
);
1916 if (rl_completion_query_items
> 0 && len
>= rl_completion_query_items
)
1920 /* We can't use *query here because they wait for <RET> which is
1921 wrong here. This follows the readline version as closely as possible
1922 for compatibility's sake. See readline/complete.c. */
1924 displayer
->crlf (displayer
);
1926 xsnprintf (msg
, sizeof (msg
),
1927 "Display all %d possibilities? (y or n)", len
);
1928 displayer
->puts (displayer
, msg
);
1929 displayer
->flush (displayer
);
1931 if (gdb_get_y_or_n (0, displayer
) == 0)
1933 displayer
->crlf (displayer
);
1938 if (gdb_display_match_list_1 (matches
, len
, max
, displayer
))
1940 /* Note: MAX_COMPLETIONS may be -1 or zero, but LEN is always > 0. */
1941 if (len
== max_completions
)
1943 /* The maximum number of completions has been reached. Warn the user
1944 that there may be more. */
1945 const char *message
= get_max_completions_reached_message ();
1947 displayer
->puts (displayer
, message
);
1948 displayer
->crlf (displayer
);
1953 extern initialize_file_ftype _initialize_completer
; /* -Wmissing-prototypes */
1956 _initialize_completer (void)
1958 add_setshow_zuinteger_unlimited_cmd ("max-completions", no_class
,
1959 &max_completions
, _("\
1960 Set maximum number of completion candidates."), _("\
1961 Show maximum number of completion candidates."), _("\
1962 Use this to limit the number of candidates considered\n\
1963 during completion. Specifying \"unlimited\" or -1\n\
1964 disables limiting. Note that setting either no limit or\n\
1965 a very large limit can make completion slow."),
1966 NULL
, NULL
, &setlist
, &showlist
);