1 /* Line completion stuff for GDB, the GNU debugger.
2 Copyright (C) 2000-2017 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "expression.h"
23 #include "filenames.h" /* For DOSish file names. */
25 #include "gdb_signals.h"
27 #include "reggroups.h"
28 #include "user-regs.h"
29 #include "arch-utils.h"
33 #include "cli/cli-decode.h"
35 /* FIXME: This is needed because of lookup_cmd_1 (). We should be
36 calling a hook instead so we eliminate the CLI dependency. */
39 /* Needed for rl_completer_word_break_characters() and for
40 rl_filename_completion_function. */
41 #include "readline/readline.h"
43 /* readline defines this. */
46 #include "completer.h"
48 /* Misc state that needs to be tracked across several different
49 readline completer entry point calls, all related to a single
50 completion invocation. */
52 struct gdb_completer_state
54 /* The current completion's completion tracker. This is a global
55 because a tracker can be shared between the handle_brkchars and
56 handle_completion phases, which involves different readline
58 completion_tracker
*tracker
= NULL
;
60 /* Whether the current completion was aborted. */
64 /* The current completion state. */
65 static gdb_completer_state current_completion
;
67 /* An enumeration of the various things a user might attempt to
68 complete for a location. If you change this, remember to update
69 the explicit_options array below too. */
71 enum explicit_location_match_type
73 /* The filename of a source file. */
76 /* The name of a function or method. */
79 /* The fully-qualified name of a function or method. */
85 /* The name of a label. */
89 /* Prototypes for local functions. */
91 /* readline uses the word breaks for two things:
92 (1) In figuring out where to point the TEXT parameter to the
93 rl_completion_entry_function. Since we don't use TEXT for much,
94 it doesn't matter a lot what the word breaks are for this purpose,
95 but it does affect how much stuff M-? lists.
96 (2) If one of the matches contains a word break character, readline
97 will quote it. That's why we switch between
98 current_language->la_word_break_characters() and
99 gdb_completer_command_word_break_characters. I'm not sure when
100 we need this behavior (perhaps for funky characters in C++
103 /* Variables which are necessary for fancy command line editing. */
105 /* When completing on command names, we remove '-' from the list of
106 word break characters, since we use it in command names. If the
107 readline library sees one in any of the current completion strings,
108 it thinks that the string needs to be quoted and automatically
109 supplies a leading quote. */
110 static const char gdb_completer_command_word_break_characters
[] =
111 " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,";
113 /* When completing on file names, we remove from the list of word
114 break characters any characters that are commonly used in file
115 names, such as '-', '+', '~', etc. Otherwise, readline displays
116 incorrect completion candidates. */
117 /* MS-DOS and MS-Windows use colon as part of the drive spec, and most
118 programs support @foo style response files. */
119 static const char gdb_completer_file_name_break_characters
[] =
120 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
126 /* Characters that can be used to quote completion strings. Note that
127 we can't include '"' because the gdb C parser treats such quoted
128 sequences as strings. */
129 static const char gdb_completer_quote_characters
[] = "'";
131 /* Accessor for some completer data that may interest other files. */
134 get_gdb_completer_quote_characters (void)
136 return gdb_completer_quote_characters
;
139 /* This can be used for functions which don't want to complete on
140 symbols but don't want to complete on anything else either. */
143 noop_completer (struct cmd_list_element
*ignore
,
144 completion_tracker
&tracker
,
145 const char *text
, const char *prefix
)
149 /* Complete on filenames. */
152 filename_completer (struct cmd_list_element
*ignore
,
153 completion_tracker
&tracker
,
154 const char *text
, const char *word
)
163 p
= rl_filename_completion_function (text
, subsequent_name
);
166 /* We need to set subsequent_name to a non-zero value before the
167 continue line below, because otherwise, if the first file
168 seen by GDB is a backup file whose name ends in a `~', we
169 will loop indefinitely. */
171 /* Like emacs, don't complete on old versions. Especially
172 useful in the "source" command. */
173 if (p
[strlen (p
) - 1] == '~')
180 /* Return exactly p. */
182 else if (word
> text
)
184 /* Return some portion of p. */
185 q
= (char *) xmalloc (strlen (p
) + 5);
186 strcpy (q
, p
+ (word
- text
));
191 /* Return some of TEXT plus p. */
192 q
= (char *) xmalloc (strlen (p
) + (text
- word
) + 5);
193 strncpy (q
, word
, text
- word
);
194 q
[text
- word
] = '\0';
198 tracker
.add_completion (gdb::unique_xmalloc_ptr
<char> (q
));
201 /* There is no way to do this just long enough to affect quote
202 inserting without also affecting the next completion. This
203 should be fixed in readline. FIXME. */
204 /* Ensure that readline does the right thing
205 with respect to inserting quotes. */
206 rl_completer_word_break_characters
= "";
210 /* The corresponding completer_handle_brkchars
214 filename_completer_handle_brkchars (struct cmd_list_element
*ignore
,
215 completion_tracker
&tracker
,
216 const char *text
, const char *word
)
218 set_rl_completer_word_break_characters
219 (gdb_completer_file_name_break_characters
);
222 /* Possible values for the found_quote flags word used by the completion
223 functions. It says what kind of (shell-like) quoting we found anywhere
225 #define RL_QF_SINGLE_QUOTE 0x01
226 #define RL_QF_DOUBLE_QUOTE 0x02
227 #define RL_QF_BACKSLASH 0x04
228 #define RL_QF_OTHER_QUOTE 0x08
230 /* Find the bounds of the current word for completion purposes, and
231 return a pointer to the end of the word. This mimics (and is a
232 modified version of) readline's _rl_find_completion_word internal
235 This function skips quoted substrings (characters between matched
236 pairs of characters in rl_completer_quote_characters). We try to
237 find an unclosed quoted substring on which to do matching. If one
238 is not found, we use the word break characters to find the
239 boundaries of the current word. QC, if non-null, is set to the
240 opening quote character if we found an unclosed quoted substring,
241 '\0' otherwise. DP, if non-null, is set to the value of the
242 delimiter character that caused a word break. */
244 struct gdb_rl_completion_word_info
246 const char *word_break_characters
;
247 const char *quote_characters
;
248 const char *basic_quote_characters
;
252 gdb_rl_find_completion_word (struct gdb_rl_completion_word_info
*info
,
254 const char *line_buffer
)
256 int scan
, end
, found_quote
, delimiter
, pass_next
, isbrk
;
258 const char *brkchars
;
259 int point
= strlen (line_buffer
);
261 /* The algorithm below does '--point'. Avoid buffer underflow with
273 found_quote
= delimiter
= 0;
276 brkchars
= info
->word_break_characters
;
278 if (info
->quote_characters
!= NULL
)
280 /* We have a list of characters which can be used in pairs to
281 quote substrings for the completer. Try to find the start of
282 an unclosed quoted substring. */
283 /* FOUND_QUOTE is set so we know what kind of quotes we
285 for (scan
= pass_next
= 0;
295 /* Shell-like semantics for single quotes -- don't allow
296 backslash to quote anything in single quotes, especially
297 not the closing quote. If you don't like this, take out
298 the check on the value of quote_char. */
299 if (quote_char
!= '\'' && line_buffer
[scan
] == '\\')
302 found_quote
|= RL_QF_BACKSLASH
;
306 if (quote_char
!= '\0')
308 /* Ignore everything until the matching close quote
310 if (line_buffer
[scan
] == quote_char
)
312 /* Found matching close. Abandon this
318 else if (strchr (info
->quote_characters
, line_buffer
[scan
]))
320 /* Found start of a quoted substring. */
321 quote_char
= line_buffer
[scan
];
323 /* Shell-like quoting conventions. */
324 if (quote_char
== '\'')
325 found_quote
|= RL_QF_SINGLE_QUOTE
;
326 else if (quote_char
== '"')
327 found_quote
|= RL_QF_DOUBLE_QUOTE
;
329 found_quote
|= RL_QF_OTHER_QUOTE
;
334 if (point
== end
&& quote_char
== '\0')
336 /* We didn't find an unclosed quoted substring upon which to do
337 completion, so use the word break characters to find the
338 substring on which to complete. */
341 scan
= line_buffer
[point
];
343 if (strchr (brkchars
, scan
) != 0)
348 /* If we are at an unquoted word break, then advance past it. */
349 scan
= line_buffer
[point
];
353 isbrk
= strchr (brkchars
, scan
) != 0;
357 /* If the character that caused the word break was a quoting
358 character, then remember it as the delimiter. */
359 if (info
->basic_quote_characters
360 && strchr (info
->basic_quote_characters
, scan
)
361 && (end
- point
) > 1)
373 return line_buffer
+ point
;
376 /* See completer.h. */
379 advance_to_expression_complete_word_point (completion_tracker
&tracker
,
382 gdb_rl_completion_word_info info
;
384 info
.word_break_characters
385 = current_language
->la_word_break_characters ();
386 info
.quote_characters
= gdb_completer_quote_characters
;
387 info
.basic_quote_characters
= rl_basic_quote_characters
;
390 = gdb_rl_find_completion_word (&info
, NULL
, NULL
, text
);
392 tracker
.advance_custom_word_point_by (start
- text
);
397 /* See completer.h. */
400 completion_tracker::completes_to_completion_word (const char *word
)
402 if (m_lowest_common_denominator_unique
)
404 const char *lcd
= m_lowest_common_denominator
;
406 if (strncmp_iw (word
, lcd
, strlen (lcd
)) == 0)
408 /* Maybe skip the function and complete on keywords. */
409 size_t wordlen
= strlen (word
);
410 if (word
[wordlen
- 1] == ' ')
418 /* Complete on linespecs, which might be of two possible forms:
424 This is intended to be used in commands that set breakpoints
428 complete_files_symbols (completion_tracker
&tracker
,
429 const char *text
, const char *word
)
431 completion_list fn_list
;
434 int quoted
= *text
== '\'' || *text
== '"';
435 int quote_char
= '\0';
436 const char *colon
= NULL
;
437 char *file_to_match
= NULL
;
438 const char *symbol_start
= text
;
439 const char *orig_text
= text
;
441 /* Do we have an unquoted colon, as in "break foo.c:bar"? */
442 for (p
= text
; *p
!= '\0'; ++p
)
444 if (*p
== '\\' && p
[1] == '\'')
446 else if (*p
== '\'' || *p
== '"')
450 while (*p
!= '\0' && *p
!= quote_found
)
452 if (*p
== '\\' && p
[1] == quote_found
)
457 if (*p
== quote_found
)
460 break; /* Hit the end of text. */
462 #if HAVE_DOS_BASED_FILE_SYSTEM
463 /* If we have a DOS-style absolute file name at the beginning of
464 TEXT, and the colon after the drive letter is the only colon
465 we found, pretend the colon is not there. */
466 else if (p
< text
+ 3 && *p
== ':' && p
== text
+ 1 + quoted
)
469 else if (*p
== ':' && !colon
)
472 symbol_start
= p
+ 1;
474 else if (strchr (current_language
->la_word_break_characters(), *p
))
475 symbol_start
= p
+ 1;
481 /* Where is the file name? */
486 file_to_match
= (char *) xmalloc (colon
- text
+ 1);
487 strncpy (file_to_match
, text
, colon
- text
);
488 file_to_match
[colon
- text
] = '\0';
489 /* Remove trailing colons and quotes from the file name. */
490 for (s
= file_to_match
+ (colon
- text
);
493 if (*s
== ':' || *s
== quote_char
)
496 /* If the text includes a colon, they want completion only on a
497 symbol name after the colon. Otherwise, we need to complete on
498 symbols as well as on files. */
501 collect_file_symbol_completion_matches (tracker
,
502 complete_symbol_mode::EXPRESSION
,
503 symbol_name_match_type::EXPRESSION
,
506 xfree (file_to_match
);
510 size_t text_len
= strlen (text
);
512 collect_symbol_completion_matches (tracker
,
513 complete_symbol_mode::EXPRESSION
,
514 symbol_name_match_type::EXPRESSION
,
516 /* If text includes characters which cannot appear in a file
517 name, they cannot be asking for completion on files. */
519 gdb_completer_file_name_break_characters
) == text_len
)
520 fn_list
= make_source_files_completion_list (text
, text
);
523 if (!fn_list
.empty () && !tracker
.have_completions ())
525 /* If we only have file names as possible completion, we should
526 bring them in sync with what rl_complete expects. The
527 problem is that if the user types "break /foo/b TAB", and the
528 possible completions are "/foo/bar" and "/foo/baz"
529 rl_complete expects us to return "bar" and "baz", without the
530 leading directories, as possible completions, because `word'
531 starts at the "b". But we ignore the value of `word' when we
532 call make_source_files_completion_list above (because that
533 would not DTRT when the completion results in both symbols
534 and file names), so make_source_files_completion_list returns
535 the full "/foo/bar" and "/foo/baz" strings. This produces
536 wrong results when, e.g., there's only one possible
537 completion, because rl_complete will prepend "/foo/" to each
538 candidate completion. The loop below removes that leading
540 for (const auto &fn_up
: fn_list
)
542 char *fn
= fn_up
.get ();
543 memmove (fn
, fn
+ (word
- text
), strlen (fn
) + 1 - (word
- text
));
547 tracker
.add_completions (std::move (fn_list
));
549 if (!tracker
.have_completions ())
551 /* No completions at all. As the final resort, try completing
552 on the entire text as a symbol. */
553 collect_symbol_completion_matches (tracker
,
554 complete_symbol_mode::EXPRESSION
,
555 symbol_name_match_type::EXPRESSION
,
560 /* See completer.h. */
563 complete_source_filenames (const char *text
)
565 size_t text_len
= strlen (text
);
567 /* If text includes characters which cannot appear in a file name,
568 the user cannot be asking for completion on files. */
570 gdb_completer_file_name_break_characters
)
572 return make_source_files_completion_list (text
, text
);
577 /* Complete address and linespec locations. */
580 complete_address_and_linespec_locations (completion_tracker
&tracker
,
582 symbol_name_match_type match_type
)
586 tracker
.advance_custom_word_point_by (1);
589 = advance_to_expression_complete_word_point (tracker
, text
);
590 complete_expression (tracker
, text
, word
);
594 linespec_complete (tracker
, text
, match_type
);
598 /* The explicit location options. Note that indexes into this array
599 must match the explicit_location_match_type enumerators. */
601 static const char *const explicit_options
[] =
611 /* The probe modifier options. These can appear before a location in
612 breakpoint commands. */
613 static const char *const probe_options
[] =
621 /* Returns STRING if not NULL, the empty string otherwise. */
624 string_or_empty (const char *string
)
626 return string
!= NULL
? string
: "";
629 /* A helper function to collect explicit location matches for the given
630 LOCATION, which is attempting to match on WORD. */
633 collect_explicit_location_matches (completion_tracker
&tracker
,
634 struct event_location
*location
,
635 enum explicit_location_match_type what
,
637 const struct language_defn
*language
)
639 const struct explicit_location
*explicit_loc
640 = get_explicit_location (location
);
642 /* True if the option expects an argument. */
643 bool needs_arg
= true;
645 /* Note, in the various MATCH_* below, we complete on
646 explicit_loc->foo instead of WORD, because only the former will
647 have already skipped past any quote char. */
652 const char *source
= string_or_empty (explicit_loc
->source_filename
);
653 completion_list matches
654 = make_source_files_completion_list (source
, source
);
655 tracker
.add_completions (std::move (matches
));
661 const char *function
= string_or_empty (explicit_loc
->function_name
);
662 linespec_complete_function (tracker
, function
,
663 explicit_loc
->func_name_match_type
,
664 explicit_loc
->source_filename
);
668 case MATCH_QUALIFIED
:
672 /* Nothing to offer. */
677 const char *label
= string_or_empty (explicit_loc
->label_name
);
678 linespec_complete_label (tracker
, language
,
679 explicit_loc
->source_filename
,
680 explicit_loc
->function_name
,
681 explicit_loc
->func_name_match_type
,
687 gdb_assert_not_reached ("unhandled explicit_location_match_type");
690 if (!needs_arg
|| tracker
.completes_to_completion_word (word
))
692 tracker
.discard_completions ();
693 tracker
.advance_custom_word_point_by (strlen (word
));
694 complete_on_enum (tracker
, explicit_options
, "", "");
695 complete_on_enum (tracker
, linespec_keywords
, "", "");
697 else if (!tracker
.have_completions ())
699 /* Maybe we have an unterminated linespec keyword at the tail of
700 the string. Try completing on that. */
701 size_t wordlen
= strlen (word
);
702 const char *keyword
= word
+ wordlen
;
704 if (wordlen
> 0 && keyword
[-1] != ' ')
706 while (keyword
> word
&& *keyword
!= ' ')
708 /* Don't complete on keywords if we'd be completing on the
709 whole explicit linespec option. E.g., "b -function
710 thr<tab>" should not complete to the "thread"
714 keyword
= skip_spaces (keyword
);
716 tracker
.advance_custom_word_point_by (keyword
- word
);
717 complete_on_enum (tracker
, linespec_keywords
, keyword
, keyword
);
720 else if (wordlen
> 0 && keyword
[-1] == ' ')
722 /* Assume that we're maybe past the explicit location
723 argument, and we didn't manage to find any match because
724 the user wants to create a pending breakpoint. Offer the
725 keyword and explicit location options as possible
727 tracker
.advance_custom_word_point_by (keyword
- word
);
728 complete_on_enum (tracker
, linespec_keywords
, keyword
, keyword
);
729 complete_on_enum (tracker
, explicit_options
, keyword
, keyword
);
734 /* If the next word in *TEXT_P is any of the keywords in KEYWORDS,
735 then advance both TEXT_P and the word point in the tracker past the
736 keyword and return the (0-based) index in the KEYWORDS array that
737 matched. Otherwise, return -1. */
740 skip_keyword (completion_tracker
&tracker
,
741 const char * const *keywords
, const char **text_p
)
743 const char *text
= *text_p
;
744 const char *after
= skip_to_space (text
);
745 size_t len
= after
- text
;
747 if (text
[len
] != ' ')
751 for (int i
= 0; keywords
[i
] != NULL
; i
++)
753 if (strncmp (keywords
[i
], text
, len
) == 0)
764 tracker
.advance_custom_word_point_by (len
+ 1);
773 /* A completer function for explicit locations. This function
774 completes both options ("-source", "-line", etc) and values. If
775 completing a quoted string, then QUOTED_ARG_START and
776 QUOTED_ARG_END point to the quote characters. LANGUAGE is the
780 complete_explicit_location (completion_tracker
&tracker
,
781 struct event_location
*location
,
783 const language_defn
*language
,
784 const char *quoted_arg_start
,
785 const char *quoted_arg_end
)
790 int keyword
= skip_keyword (tracker
, explicit_options
, &text
);
793 complete_on_enum (tracker
, explicit_options
, text
, text
);
796 /* Completing on value. */
797 enum explicit_location_match_type what
798 = (explicit_location_match_type
) keyword
;
800 if (quoted_arg_start
!= NULL
&& quoted_arg_end
!= NULL
)
802 if (quoted_arg_end
[1] == '\0')
804 /* If completing a quoted string with the cursor right
805 at the terminating quote char, complete the
806 completion word without interpretation, so that
807 readline advances the cursor one whitespace past the
808 quote, even if there's no match. This makes these
809 cases behave the same:
811 before: "b -function function()"
812 after: "b -function function() "
814 before: "b -function 'function()'"
815 after: "b -function 'function()' "
817 and trusts the user in this case:
819 before: "b -function 'not_loaded_function_yet()'"
820 after: "b -function 'not_loaded_function_yet()' "
822 gdb::unique_xmalloc_ptr
<char> text_copy
824 tracker
.add_completion (std::move (text_copy
));
826 else if (quoted_arg_end
[1] == ' ')
828 /* We're maybe past the explicit location argument.
829 Skip the argument without interpretion, assuming the
830 user may want to create pending breakpoint. Offer
831 the keyword and explicit location options as possible
833 tracker
.advance_custom_word_point_by (strlen (text
));
834 complete_on_enum (tracker
, linespec_keywords
, "", "");
835 complete_on_enum (tracker
, explicit_options
, "", "");
840 /* Now gather matches */
841 collect_explicit_location_matches (tracker
, location
, what
, text
,
846 /* A completer for locations. */
849 location_completer (struct cmd_list_element
*ignore
,
850 completion_tracker
&tracker
,
851 const char *text
, const char * /* word */)
853 int found_probe_option
= -1;
855 /* If we have a probe modifier, skip it. This can only appear as
856 first argument. Until we have a specific completer for probes,
857 falling back to the linespec completer for the remainder of the
858 line is better than nothing. */
859 if (text
[0] == '-' && text
[1] == 'p')
860 found_probe_option
= skip_keyword (tracker
, probe_options
, &text
);
862 const char *option_text
= text
;
863 int saved_word_point
= tracker
.custom_word_point ();
865 const char *copy
= text
;
867 explicit_completion_info completion_info
;
868 event_location_up location
869 = string_to_explicit_location (©
, current_language
,
871 if (completion_info
.quoted_arg_start
!= NULL
872 && completion_info
.quoted_arg_end
== NULL
)
874 /* Found an unbalanced quote. */
875 tracker
.set_quote_char (*completion_info
.quoted_arg_start
);
876 tracker
.advance_custom_word_point_by (1);
879 if (completion_info
.saw_explicit_location_option
)
883 tracker
.advance_custom_word_point_by (copy
- text
);
886 /* We found a terminator at the tail end of the string,
887 which means we're past the explicit location options. We
888 may have a keyword to complete on. If we have a whole
889 keyword, then complete whatever comes after as an
890 expression. This is mainly for the "if" keyword. If the
891 "thread" and "task" keywords gain their own completers,
892 they should be used here. */
893 int keyword
= skip_keyword (tracker
, linespec_keywords
, &text
);
897 complete_on_enum (tracker
, linespec_keywords
, text
, text
);
902 = advance_to_expression_complete_word_point (tracker
, text
);
903 complete_expression (tracker
, text
, word
);
908 tracker
.advance_custom_word_point_by (completion_info
.last_option
910 text
= completion_info
.last_option
;
912 complete_explicit_location (tracker
, location
.get (), text
,
914 completion_info
.quoted_arg_start
,
915 completion_info
.quoted_arg_end
);
919 /* This is an address or linespec location. */
920 else if (location
!= NULL
)
922 /* Handle non-explicit location options. */
924 int keyword
= skip_keyword (tracker
, explicit_options
, &text
);
926 complete_on_enum (tracker
, explicit_options
, text
, text
);
929 tracker
.advance_custom_word_point_by (copy
- text
);
932 symbol_name_match_type match_type
933 = get_explicit_location (location
.get ())->func_name_match_type
;
934 complete_address_and_linespec_locations (tracker
, text
, match_type
);
940 complete_address_and_linespec_locations (tracker
, text
,
941 symbol_name_match_type::WILD
);
944 /* Add matches for option names, if either:
946 - Some completer above found some matches, but the word point did
947 not advance (e.g., "b <tab>" finds all functions, or "b -<tab>"
948 matches all objc selectors), or;
950 - Some completer above advanced the word point, but found no
953 if ((text
[0] == '-' || text
[0] == '\0')
954 && (!tracker
.have_completions ()
955 || tracker
.custom_word_point () == saved_word_point
))
957 tracker
.set_custom_word_point (saved_word_point
);
960 if (found_probe_option
== -1)
961 complete_on_enum (tracker
, probe_options
, text
, text
);
962 complete_on_enum (tracker
, explicit_options
, text
, text
);
966 /* The corresponding completer_handle_brkchars
970 location_completer_handle_brkchars (struct cmd_list_element
*ignore
,
971 completion_tracker
&tracker
,
973 const char *word_ignored
)
975 tracker
.set_use_custom_word_point (true);
977 location_completer (ignore
, tracker
, text
, NULL
);
980 /* Helper for expression_completer which recursively adds field and
981 method names from TYPE, a struct or union type, to the OUTPUT
985 add_struct_fields (struct type
*type
, completion_list
&output
,
986 char *fieldname
, int namelen
)
989 int computed_type_name
= 0;
990 const char *type_name
= NULL
;
992 type
= check_typedef (type
);
993 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
995 if (i
< TYPE_N_BASECLASSES (type
))
996 add_struct_fields (TYPE_BASECLASS (type
, i
),
997 output
, fieldname
, namelen
);
998 else if (TYPE_FIELD_NAME (type
, i
))
1000 if (TYPE_FIELD_NAME (type
, i
)[0] != '\0')
1002 if (! strncmp (TYPE_FIELD_NAME (type
, i
),
1003 fieldname
, namelen
))
1004 output
.emplace_back (xstrdup (TYPE_FIELD_NAME (type
, i
)));
1006 else if (TYPE_CODE (TYPE_FIELD_TYPE (type
, i
)) == TYPE_CODE_UNION
)
1008 /* Recurse into anonymous unions. */
1009 add_struct_fields (TYPE_FIELD_TYPE (type
, i
),
1010 output
, fieldname
, namelen
);
1015 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
1017 const char *name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1019 if (name
&& ! strncmp (name
, fieldname
, namelen
))
1021 if (!computed_type_name
)
1023 type_name
= type_name_no_tag (type
);
1024 computed_type_name
= 1;
1026 /* Omit constructors from the completion list. */
1027 if (!type_name
|| strcmp (type_name
, name
))
1028 output
.emplace_back (xstrdup (name
));
1033 /* See completer.h. */
1036 complete_expression (completion_tracker
&tracker
,
1037 const char *text
, const char *word
)
1039 struct type
*type
= NULL
;
1041 enum type_code code
= TYPE_CODE_UNDEF
;
1043 /* Perform a tentative parse of the expression, to see whether a
1044 field completion is required. */
1048 type
= parse_expression_for_completion (text
, &fieldname
, &code
);
1050 CATCH (except
, RETURN_MASK_ERROR
)
1056 if (fieldname
&& type
)
1060 type
= check_typedef (type
);
1061 if (TYPE_CODE (type
) != TYPE_CODE_PTR
&& !TYPE_IS_REFERENCE (type
))
1063 type
= TYPE_TARGET_TYPE (type
);
1066 if (TYPE_CODE (type
) == TYPE_CODE_UNION
1067 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
1069 int flen
= strlen (fieldname
);
1070 completion_list result
;
1072 add_struct_fields (type
, result
, fieldname
, flen
);
1074 tracker
.add_completions (std::move (result
));
1078 else if (fieldname
&& code
!= TYPE_CODE_UNDEF
)
1080 struct cleanup
*cleanup
= make_cleanup (xfree
, fieldname
);
1082 collect_symbol_completion_matches_type (tracker
, fieldname
, fieldname
,
1084 do_cleanups (cleanup
);
1089 complete_files_symbols (tracker
, text
, word
);
1092 /* Complete on expressions. Often this means completing on symbol
1093 names, but some language parsers also have support for completing
1097 expression_completer (struct cmd_list_element
*ignore
,
1098 completion_tracker
&tracker
,
1099 const char *text
, const char *word
)
1101 complete_expression (tracker
, text
, word
);
1104 /* See definition in completer.h. */
1107 set_rl_completer_word_break_characters (const char *break_chars
)
1109 rl_completer_word_break_characters
= (char *) break_chars
;
1112 /* See definition in completer.h. */
1115 set_gdb_completion_word_break_characters (completer_ftype
*fn
)
1117 const char *break_chars
;
1119 /* So far we are only interested in differentiating filename
1120 completers from everything else. */
1121 if (fn
== filename_completer
)
1122 break_chars
= gdb_completer_file_name_break_characters
;
1124 break_chars
= gdb_completer_command_word_break_characters
;
1126 set_rl_completer_word_break_characters (break_chars
);
1129 /* Complete on symbols. */
1132 symbol_completer (struct cmd_list_element
*ignore
,
1133 completion_tracker
&tracker
,
1134 const char *text
, const char *word
)
1136 collect_symbol_completion_matches (tracker
, complete_symbol_mode::EXPRESSION
,
1137 symbol_name_match_type::EXPRESSION
,
1141 /* Here are some useful test cases for completion. FIXME: These
1142 should be put in the test suite. They should be tested with both
1145 "show output-" "radix"
1146 "show output" "-radix"
1147 "p" ambiguous (commands starting with p--path, print, printf, etc.)
1148 "p " ambiguous (all symbols)
1149 "info t foo" no completions
1150 "info t " no completions
1151 "info t" ambiguous ("info target", "info terminal", etc.)
1152 "info ajksdlfk" no completions
1153 "info ajksdlfk " no completions
1155 "info " ambiguous (all info commands)
1156 "p \"a" no completions (string constant)
1157 "p 'a" ambiguous (all symbols starting with a)
1158 "p b-a" ambiguous (all symbols starting with a)
1159 "p b-" ambiguous (all symbols)
1160 "file Make" "file" (word break hard to screw up here)
1161 "file ../gdb.stabs/we" "ird" (needs to not break word at slash)
1164 enum complete_line_internal_reason
1166 /* Preliminary phase, called by gdb_completion_word_break_characters
1167 function, is used to either:
1169 #1 - Determine the set of chars that are word delimiters
1170 depending on the current command in line_buffer.
1172 #2 - Manually advance RL_POINT to the "word break" point instead
1173 of letting readline do it (based on too-simple character
1176 Simpler completers that just pass a brkchars array to readline
1177 (#1 above) must defer generating the completions to the main
1178 phase (below). No completion list should be generated in this
1181 OTOH, completers that manually advance the word point(#2 above)
1182 must set "use_custom_word_point" in the tracker and generate
1183 their completion in this phase. Note that this is the convenient
1184 thing to do since they'll be parsing the input line anyway. */
1187 /* Main phase, called by complete_line function, is used to get the
1188 list of possible completions. */
1191 /* Special case when completing a 'help' command. In this case,
1192 once sub-command completions are exhausted, we simply return
1197 /* Helper for complete_line_internal to simplify it. */
1200 complete_line_internal_normal_command (completion_tracker
&tracker
,
1201 const char *command
, const char *word
,
1202 const char *cmd_args
,
1203 complete_line_internal_reason reason
,
1204 struct cmd_list_element
*c
)
1206 const char *p
= cmd_args
;
1208 if (c
->completer
== filename_completer
)
1210 /* Many commands which want to complete on file names accept
1211 several file names, as in "run foo bar >>baz". So we don't
1212 want to complete the entire text after the command, just the
1213 last word. To this end, we need to find the beginning of the
1214 file name by starting at `word' and going backwards. */
1217 && strchr (gdb_completer_file_name_break_characters
,
1223 if (reason
== handle_brkchars
)
1225 completer_handle_brkchars_ftype
*brkchars_fn
;
1227 if (c
->completer_handle_brkchars
!= NULL
)
1228 brkchars_fn
= c
->completer_handle_brkchars
;
1232 = (completer_handle_brkchars_func_for_completer
1236 brkchars_fn (c
, tracker
, p
, word
);
1239 if (reason
!= handle_brkchars
&& c
->completer
!= NULL
)
1240 (*c
->completer
) (c
, tracker
, p
, word
);
1243 /* Internal function used to handle completions.
1246 TEXT is the caller's idea of the "word" we are looking at.
1248 LINE_BUFFER is available to be looked at; it contains the entire
1249 text of the line. POINT is the offset in that line of the cursor.
1250 You should pretend that the line ends at POINT.
1252 See complete_line_internal_reason for description of REASON. */
1255 complete_line_internal_1 (completion_tracker
&tracker
,
1257 const char *line_buffer
, int point
,
1258 complete_line_internal_reason reason
)
1262 int ignore_help_classes
;
1263 /* Pointer within tmp_command which corresponds to text. */
1265 struct cmd_list_element
*c
, *result_list
;
1267 /* Choose the default set of word break characters to break
1268 completions. If we later find out that we are doing completions
1269 on command strings (as opposed to strings supplied by the
1270 individual command completer functions, which can be any string)
1271 then we will switch to the special word break set for command
1272 strings, which leaves out the '-' character used in some
1274 set_rl_completer_word_break_characters
1275 (current_language
->la_word_break_characters());
1277 /* Decide whether to complete on a list of gdb commands or on
1279 tmp_command
= (char *) alloca (point
+ 1);
1282 /* The help command should complete help aliases. */
1283 ignore_help_classes
= reason
!= handle_help
;
1285 strncpy (tmp_command
, line_buffer
, point
);
1286 tmp_command
[point
] = '\0';
1287 if (reason
== handle_brkchars
)
1289 gdb_assert (text
== NULL
);
1294 /* Since text always contains some number of characters leading up
1295 to point, we can find the equivalent position in tmp_command
1296 by subtracting that many characters from the end of tmp_command. */
1297 word
= tmp_command
+ point
- strlen (text
);
1300 /* Move P up to the start of the command. */
1301 p
= skip_spaces (p
);
1305 /* An empty line is ambiguous; that is, it could be any
1307 c
= CMD_LIST_AMBIGUOUS
;
1312 c
= lookup_cmd_1 (&p
, cmdlist
, &result_list
, ignore_help_classes
);
1315 /* Move p up to the next interesting thing. */
1316 while (*p
== ' ' || *p
== '\t')
1321 tracker
.advance_custom_word_point_by (p
- tmp_command
);
1325 /* It is an unrecognized command. So there are no
1326 possible completions. */
1328 else if (c
== CMD_LIST_AMBIGUOUS
)
1332 /* lookup_cmd_1 advances p up to the first ambiguous thing, but
1333 doesn't advance over that thing itself. Do so now. */
1335 while (*q
&& (isalnum (*q
) || *q
== '-' || *q
== '_'))
1337 if (q
!= tmp_command
+ point
)
1339 /* There is something beyond the ambiguous
1340 command, so there are no possible completions. For
1341 example, "info t " or "info t foo" does not complete
1342 to anything, because "info t" can be "info target" or
1347 /* We're trying to complete on the command which was ambiguous.
1348 This we can deal with. */
1351 if (reason
!= handle_brkchars
)
1352 complete_on_cmdlist (*result_list
->prefixlist
, tracker
, p
,
1353 word
, ignore_help_classes
);
1357 if (reason
!= handle_brkchars
)
1358 complete_on_cmdlist (cmdlist
, tracker
, p
, word
,
1359 ignore_help_classes
);
1361 /* Ensure that readline does the right thing with respect to
1362 inserting quotes. */
1363 set_rl_completer_word_break_characters
1364 (gdb_completer_command_word_break_characters
);
1369 /* We've recognized a full command. */
1371 if (p
== tmp_command
+ point
)
1373 /* There is no non-whitespace in the line beyond the
1376 if (p
[-1] == ' ' || p
[-1] == '\t')
1378 /* The command is followed by whitespace; we need to
1379 complete on whatever comes after command. */
1382 /* It is a prefix command; what comes after it is
1383 a subcommand (e.g. "info "). */
1384 if (reason
!= handle_brkchars
)
1385 complete_on_cmdlist (*c
->prefixlist
, tracker
, p
, word
,
1386 ignore_help_classes
);
1388 /* Ensure that readline does the right thing
1389 with respect to inserting quotes. */
1390 set_rl_completer_word_break_characters
1391 (gdb_completer_command_word_break_characters
);
1393 else if (reason
== handle_help
)
1397 if (reason
!= handle_brkchars
)
1398 complete_on_enum (tracker
, c
->enums
, p
, word
);
1399 set_rl_completer_word_break_characters
1400 (gdb_completer_command_word_break_characters
);
1404 /* It is a normal command; what comes after it is
1405 completed by the command's completer function. */
1406 complete_line_internal_normal_command (tracker
,
1407 tmp_command
, word
, p
,
1413 /* The command is not followed by whitespace; we need to
1414 complete on the command itself, e.g. "p" which is a
1415 command itself but also can complete to "print", "ptype"
1419 /* Find the command we are completing on. */
1421 while (q
> tmp_command
)
1423 if (isalnum (q
[-1]) || q
[-1] == '-' || q
[-1] == '_')
1429 if (reason
!= handle_brkchars
)
1430 complete_on_cmdlist (result_list
, tracker
, q
, word
,
1431 ignore_help_classes
);
1433 /* Ensure that readline does the right thing
1434 with respect to inserting quotes. */
1435 set_rl_completer_word_break_characters
1436 (gdb_completer_command_word_break_characters
);
1439 else if (reason
== handle_help
)
1443 /* There is non-whitespace beyond the command. */
1445 if (c
->prefixlist
&& !c
->allow_unknown
)
1447 /* It is an unrecognized subcommand of a prefix command,
1448 e.g. "info adsfkdj". */
1452 if (reason
!= handle_brkchars
)
1453 complete_on_enum (tracker
, c
->enums
, p
, word
);
1457 /* It is a normal command. */
1458 complete_line_internal_normal_command (tracker
,
1459 tmp_command
, word
, p
,
1466 /* Wrapper around complete_line_internal_1 to handle
1467 MAX_COMPLETIONS_REACHED_ERROR. */
1470 complete_line_internal (completion_tracker
&tracker
,
1472 const char *line_buffer
, int point
,
1473 complete_line_internal_reason reason
)
1477 complete_line_internal_1 (tracker
, text
, line_buffer
, point
, reason
);
1479 CATCH (except
, RETURN_MASK_ERROR
)
1481 if (except
.error
!= MAX_COMPLETIONS_REACHED_ERROR
)
1482 throw_exception (except
);
1487 /* See completer.h. */
1489 int max_completions
= 200;
1491 /* Initial size of the table. It automagically grows from here. */
1492 #define INITIAL_COMPLETION_HTAB_SIZE 200
1494 /* See completer.h. */
1496 completion_tracker::completion_tracker ()
1498 m_entries_hash
= htab_create_alloc (INITIAL_COMPLETION_HTAB_SIZE
,
1499 htab_hash_string
, (htab_eq
) streq
,
1500 NULL
, xcalloc
, xfree
);
1503 /* See completer.h. */
1506 completion_tracker::discard_completions ()
1508 xfree (m_lowest_common_denominator
);
1509 m_lowest_common_denominator
= NULL
;
1511 m_lowest_common_denominator_unique
= false;
1513 m_entries_vec
.clear ();
1515 htab_delete (m_entries_hash
);
1516 m_entries_hash
= htab_create_alloc (INITIAL_COMPLETION_HTAB_SIZE
,
1517 htab_hash_string
, (htab_eq
) streq
,
1518 NULL
, xcalloc
, xfree
);
1521 /* See completer.h. */
1523 completion_tracker::~completion_tracker ()
1525 xfree (m_lowest_common_denominator
);
1526 htab_delete (m_entries_hash
);
1529 /* See completer.h. */
1532 completion_tracker::maybe_add_completion
1533 (gdb::unique_xmalloc_ptr
<char> name
,
1534 completion_match_for_lcd
*match_for_lcd
)
1538 if (max_completions
== 0)
1541 if (htab_elements (m_entries_hash
) >= max_completions
)
1544 slot
= htab_find_slot (m_entries_hash
, name
.get (), INSERT
);
1545 if (*slot
== HTAB_EMPTY_ENTRY
)
1547 const char *match_for_lcd_str
= NULL
;
1549 if (match_for_lcd
!= NULL
)
1550 match_for_lcd_str
= match_for_lcd
->finish ();
1552 if (match_for_lcd_str
== NULL
)
1553 match_for_lcd_str
= name
.get ();
1555 recompute_lowest_common_denominator (match_for_lcd_str
);
1557 *slot
= name
.get ();
1558 m_entries_vec
.push_back (std::move (name
));
1564 /* See completer.h. */
1567 completion_tracker::add_completion (gdb::unique_xmalloc_ptr
<char> name
,
1568 completion_match_for_lcd
*match_for_lcd
)
1570 if (!maybe_add_completion (std::move (name
), match_for_lcd
))
1571 throw_error (MAX_COMPLETIONS_REACHED_ERROR
, _("Max completions reached."));
1574 /* See completer.h. */
1577 completion_tracker::add_completions (completion_list
&&list
)
1579 for (auto &candidate
: list
)
1580 add_completion (std::move (candidate
));
1583 /* Generate completions all at once. Does nothing if max_completions
1584 is 0. If max_completions is non-negative, this will collect at
1585 most max_completions strings.
1587 TEXT is the caller's idea of the "word" we are looking at.
1589 LINE_BUFFER is available to be looked at; it contains the entire
1592 POINT is the offset in that line of the cursor. You
1593 should pretend that the line ends at POINT. */
1596 complete_line (completion_tracker
&tracker
,
1597 const char *text
, const char *line_buffer
, int point
)
1599 if (max_completions
== 0)
1601 complete_line_internal (tracker
, text
, line_buffer
, point
,
1602 handle_completions
);
1605 /* Complete on command names. Used by "help". */
1608 command_completer (struct cmd_list_element
*ignore
,
1609 completion_tracker
&tracker
,
1610 const char *text
, const char *word
)
1612 complete_line_internal (tracker
, word
, text
,
1613 strlen (text
), handle_help
);
1616 /* The corresponding completer_handle_brkchars implementation. */
1619 command_completer_handle_brkchars (struct cmd_list_element
*ignore
,
1620 completion_tracker
&tracker
,
1621 const char *text
, const char *word
)
1623 set_rl_completer_word_break_characters
1624 (gdb_completer_command_word_break_characters
);
1627 /* Complete on signals. */
1630 signal_completer (struct cmd_list_element
*ignore
,
1631 completion_tracker
&tracker
,
1632 const char *text
, const char *word
)
1634 size_t len
= strlen (word
);
1636 const char *signame
;
1638 for (signum
= GDB_SIGNAL_FIRST
; signum
!= GDB_SIGNAL_LAST
; ++signum
)
1640 /* Can't handle this, so skip it. */
1641 if (signum
== GDB_SIGNAL_0
)
1644 signame
= gdb_signal_to_name ((enum gdb_signal
) signum
);
1646 /* Ignore the unknown signal case. */
1647 if (!signame
|| strcmp (signame
, "?") == 0)
1650 if (strncasecmp (signame
, word
, len
) == 0)
1652 gdb::unique_xmalloc_ptr
<char> copy (xstrdup (signame
));
1653 tracker
.add_completion (std::move (copy
));
1658 /* Bit-flags for selecting what the register and/or register-group
1659 completer should complete on. */
1661 enum reg_completer_target
1663 complete_register_names
= 0x1,
1664 complete_reggroup_names
= 0x2
1666 DEF_ENUM_FLAGS_TYPE (enum reg_completer_target
, reg_completer_targets
);
1668 /* Complete register names and/or reggroup names based on the value passed
1669 in TARGETS. At least one bit in TARGETS must be set. */
1672 reg_or_group_completer_1 (completion_tracker
&tracker
,
1673 const char *text
, const char *word
,
1674 reg_completer_targets targets
)
1676 size_t len
= strlen (word
);
1677 struct gdbarch
*gdbarch
;
1680 gdb_assert ((targets
& (complete_register_names
1681 | complete_reggroup_names
)) != 0);
1682 gdbarch
= get_current_arch ();
1684 if ((targets
& complete_register_names
) != 0)
1689 (name
= user_reg_map_regnum_to_name (gdbarch
, i
)) != NULL
;
1692 if (*name
!= '\0' && strncmp (word
, name
, len
) == 0)
1694 gdb::unique_xmalloc_ptr
<char> copy (xstrdup (name
));
1695 tracker
.add_completion (std::move (copy
));
1700 if ((targets
& complete_reggroup_names
) != 0)
1702 struct reggroup
*group
;
1704 for (group
= reggroup_next (gdbarch
, NULL
);
1706 group
= reggroup_next (gdbarch
, group
))
1708 name
= reggroup_name (group
);
1709 if (strncmp (word
, name
, len
) == 0)
1711 gdb::unique_xmalloc_ptr
<char> copy (xstrdup (name
));
1712 tracker
.add_completion (std::move (copy
));
1718 /* Perform completion on register and reggroup names. */
1721 reg_or_group_completer (struct cmd_list_element
*ignore
,
1722 completion_tracker
&tracker
,
1723 const char *text
, const char *word
)
1725 reg_or_group_completer_1 (tracker
, text
, word
,
1726 (complete_register_names
1727 | complete_reggroup_names
));
1730 /* Perform completion on reggroup names. */
1733 reggroup_completer (struct cmd_list_element
*ignore
,
1734 completion_tracker
&tracker
,
1735 const char *text
, const char *word
)
1737 reg_or_group_completer_1 (tracker
, text
, word
,
1738 complete_reggroup_names
);
1741 /* The default completer_handle_brkchars implementation. */
1744 default_completer_handle_brkchars (struct cmd_list_element
*ignore
,
1745 completion_tracker
&tracker
,
1746 const char *text
, const char *word
)
1748 set_rl_completer_word_break_characters
1749 (current_language
->la_word_break_characters ());
1752 /* See definition in completer.h. */
1754 completer_handle_brkchars_ftype
*
1755 completer_handle_brkchars_func_for_completer (completer_ftype
*fn
)
1757 if (fn
== filename_completer
)
1758 return filename_completer_handle_brkchars
;
1760 if (fn
== location_completer
)
1761 return location_completer_handle_brkchars
;
1763 if (fn
== command_completer
)
1764 return command_completer_handle_brkchars
;
1766 return default_completer_handle_brkchars
;
1769 /* Used as brkchars when we want to tell readline we have a custom
1770 word point. We do that by making our rl_completion_word_break_hook
1771 set RL_POINT to the desired word point, and return the character at
1772 the word break point as the break char. This is two bytes in order
1773 to fit one break character plus the terminating null. */
1774 static char gdb_custom_word_point_brkchars
[2];
1776 /* Since rl_basic_quote_characters is not completer-specific, we save
1777 its original value here, in order to be able to restore it in
1778 gdb_rl_attempted_completion_function. */
1779 static const char *gdb_org_rl_basic_quote_characters
= rl_basic_quote_characters
;
1781 /* Get the list of chars that are considered as word breaks
1782 for the current command. */
1785 gdb_completion_word_break_characters_throw ()
1787 /* New completion starting. Get rid of the previous tracker and
1789 delete current_completion
.tracker
;
1790 current_completion
.tracker
= new completion_tracker ();
1792 completion_tracker
&tracker
= *current_completion
.tracker
;
1794 complete_line_internal (tracker
, NULL
, rl_line_buffer
,
1795 rl_point
, handle_brkchars
);
1797 if (tracker
.use_custom_word_point ())
1799 gdb_assert (tracker
.custom_word_point () > 0);
1800 rl_point
= tracker
.custom_word_point () - 1;
1801 gdb_custom_word_point_brkchars
[0] = rl_line_buffer
[rl_point
];
1802 rl_completer_word_break_characters
= gdb_custom_word_point_brkchars
;
1803 rl_completer_quote_characters
= NULL
;
1805 /* Clear this too, so that if we're completing a quoted string,
1806 readline doesn't consider the quote character a delimiter.
1807 If we didn't do this, readline would auto-complete {b
1808 'fun<tab>} to {'b 'function()'}, i.e., add the terminating
1809 \', but, it wouldn't append the separator space either, which
1810 is not desirable. So instead we take care of appending the
1811 quote character to the LCD ourselves, in
1812 gdb_rl_attempted_completion_function. Since this global is
1813 not just completer-specific, we'll restore it back to the
1814 default in gdb_rl_attempted_completion_function. */
1815 rl_basic_quote_characters
= NULL
;
1818 return rl_completer_word_break_characters
;
1822 gdb_completion_word_break_characters ()
1824 /* New completion starting. */
1825 current_completion
.aborted
= false;
1829 return gdb_completion_word_break_characters_throw ();
1831 CATCH (ex
, RETURN_MASK_ALL
)
1833 /* Set this to that gdb_rl_attempted_completion_function knows
1835 current_completion
.aborted
= true;
1842 /* See completer.h. */
1845 completion_find_completion_word (completion_tracker
&tracker
, const char *text
,
1848 size_t point
= strlen (text
);
1850 complete_line_internal (tracker
, NULL
, text
, point
, handle_brkchars
);
1852 if (tracker
.use_custom_word_point ())
1854 gdb_assert (tracker
.custom_word_point () > 0);
1855 *quote_char
= tracker
.quote_char ();
1856 return text
+ tracker
.custom_word_point ();
1859 gdb_rl_completion_word_info info
;
1861 info
.word_break_characters
= rl_completer_word_break_characters
;
1862 info
.quote_characters
= gdb_completer_quote_characters
;
1863 info
.basic_quote_characters
= rl_basic_quote_characters
;
1865 return gdb_rl_find_completion_word (&info
, quote_char
, NULL
, text
);
1868 /* See completer.h. */
1871 completion_tracker::recompute_lowest_common_denominator (const char *new_match
)
1873 if (m_lowest_common_denominator
== NULL
)
1875 /* We don't have a lowest common denominator yet, so simply take
1876 the whole NEW_MATCH as being it. */
1877 m_lowest_common_denominator
= xstrdup (new_match
);
1878 m_lowest_common_denominator_unique
= true;
1882 /* Find the common denominator between the currently-known
1883 lowest common denominator and NEW_MATCH. That becomes the
1884 new lowest common denominator. */
1888 (new_match
[i
] != '\0'
1889 && new_match
[i
] == m_lowest_common_denominator
[i
]);
1892 if (m_lowest_common_denominator
[i
] != new_match
[i
])
1894 m_lowest_common_denominator
[i
] = '\0';
1895 m_lowest_common_denominator_unique
= false;
1900 /* See completer.h. */
1903 completion_tracker::advance_custom_word_point_by (size_t len
)
1905 m_custom_word_point
+= len
;
1908 /* Build a new C string that is a copy of LCD with the whitespace of
1909 ORIG/ORIG_LEN preserved.
1911 Say the user is completing a symbol name, with spaces, like:
1915 and the resulting completion match is:
1919 we want to end up with an input line like:
1922 ^^^^^^^ => text from LCD [1], whitespace from ORIG preserved.
1923 ^^ => new text from LCD
1925 [1] - We must take characters from the LCD instead of the original
1926 text, since some completions want to change upper/lowercase. E.g.:
1932 "handle SIG[QUIT|etc.]"
1936 expand_preserving_ws (const char *orig
, size_t orig_len
,
1939 const char *p_orig
= orig
;
1940 const char *orig_end
= orig
+ orig_len
;
1941 const char *p_lcd
= lcd
;
1944 while (p_orig
< orig_end
)
1948 while (p_orig
< orig_end
&& *p_orig
== ' ')
1950 p_lcd
= skip_spaces (p_lcd
);
1954 /* Take characters from the LCD instead of the original
1955 text, since some completions change upper/lowercase.
1959 "handle SIG[QUIT|etc.]"
1967 while (*p_lcd
!= '\0')
1970 return xstrdup (res
.c_str ());
1973 /* See completer.h. */
1976 completion_tracker::build_completion_result (const char *text
,
1979 completion_list
&list
= m_entries_vec
; /* The completions. */
1984 /* +1 for the LCD, and +1 for NULL termination. */
1985 char **match_list
= XNEWVEC (char *, 1 + list
.size () + 1);
1987 /* Build replacement word, based on the LCD. */
1990 = expand_preserving_ws (text
, end
- start
,
1991 m_lowest_common_denominator
);
1993 if (m_lowest_common_denominator_unique
)
1995 /* We don't rely on readline appending the quote char as
1996 delimiter as then readline wouldn't append the ' ' after the
1998 char buf
[2] = { quote_char () };
2000 match_list
[0] = reconcat (match_list
[0], match_list
[0],
2001 buf
, (char *) NULL
);
2002 match_list
[1] = NULL
;
2004 /* If the tracker wants to, or we already have a space at the
2005 end of the match, tell readline to skip appending
2007 bool completion_suppress_append
2008 = (suppress_append_ws ()
2009 || match_list
[0][strlen (match_list
[0]) - 1] == ' ');
2011 return completion_result (match_list
, 1, completion_suppress_append
);
2017 for (ix
= 0; ix
< list
.size (); ++ix
)
2018 match_list
[ix
+ 1] = list
[ix
].release ();
2019 match_list
[ix
+ 1] = NULL
;
2021 return completion_result (match_list
, list
.size (), false);
2025 /* See completer.h */
2027 completion_result::completion_result ()
2028 : match_list (NULL
), number_matches (0),
2029 completion_suppress_append (false)
2032 /* See completer.h */
2034 completion_result::completion_result (char **match_list_
,
2035 size_t number_matches_
,
2036 bool completion_suppress_append_
)
2037 : match_list (match_list_
),
2038 number_matches (number_matches_
),
2039 completion_suppress_append (completion_suppress_append_
)
2042 /* See completer.h */
2044 completion_result::~completion_result ()
2046 reset_match_list ();
2049 /* See completer.h */
2051 completion_result::completion_result (completion_result
&&rhs
)
2056 reset_match_list ();
2057 match_list
= rhs
.match_list
;
2058 rhs
.match_list
= NULL
;
2059 number_matches
= rhs
.number_matches
;
2060 rhs
.number_matches
= 0;
2063 /* See completer.h */
2066 completion_result::release_match_list ()
2068 char **ret
= match_list
;
2073 /* See completer.h */
2076 completion_result::sort_match_list ()
2078 if (number_matches
> 1)
2080 /* Element 0 is special (it's the common prefix), leave it
2082 std::sort (&match_list
[1],
2083 &match_list
[number_matches
+ 1],
2088 /* See completer.h */
2091 completion_result::reset_match_list ()
2093 if (match_list
!= NULL
)
2095 for (char **p
= match_list
; *p
!= NULL
; p
++)
2102 /* Helper for gdb_rl_attempted_completion_function, which does most of
2103 the work. This is called by readline to build the match list array
2104 and to determine the lowest common denominator. The real matches
2105 list starts at match[1], while match[0] is the slot holding
2106 readline's idea of the lowest common denominator of all matches,
2107 which is what readline replaces the completion "word" with.
2109 TEXT is the caller's idea of the "word" we are looking at, as
2110 computed in the handle_brkchars phase.
2112 START is the offset from RL_LINE_BUFFER where TEXT starts. END is
2113 the offset from RL_LINE_BUFFER where TEXT ends (i.e., where
2116 You should thus pretend that the line ends at END (relative to
2119 RL_LINE_BUFFER contains the entire text of the line. RL_POINT is
2120 the offset in that line of the cursor. You should pretend that the
2123 Returns NULL if there are no completions. */
2126 gdb_rl_attempted_completion_function_throw (const char *text
, int start
, int end
)
2128 /* Completers that provide a custom word point in the
2129 handle_brkchars phase also compute their completions then.
2130 Completers that leave the completion word handling to readline
2131 must be called twice. If rl_point (i.e., END) is at column 0,
2132 then readline skips the handle_brkchars phase, and so we create a
2133 tracker now in that case too. */
2134 if (end
== 0 || !current_completion
.tracker
->use_custom_word_point ())
2136 delete current_completion
.tracker
;
2137 current_completion
.tracker
= new completion_tracker ();
2139 complete_line (*current_completion
.tracker
, text
,
2140 rl_line_buffer
, rl_point
);
2143 completion_tracker
&tracker
= *current_completion
.tracker
;
2145 completion_result result
2146 = tracker
.build_completion_result (text
, start
, end
);
2148 rl_completion_suppress_append
= result
.completion_suppress_append
;
2149 return result
.release_match_list ();
2152 /* Function installed as "rl_attempted_completion_function" readline
2153 hook. Wrapper around gdb_rl_attempted_completion_function_throw
2154 that catches C++ exceptions, which can't cross readline. */
2157 gdb_rl_attempted_completion_function (const char *text
, int start
, int end
)
2159 /* Restore globals that might have been tweaked in
2160 gdb_completion_word_break_characters. */
2161 rl_basic_quote_characters
= gdb_org_rl_basic_quote_characters
;
2163 /* If we end up returning NULL, either on error, or simple because
2164 there are no matches, inhibit readline's default filename
2166 rl_attempted_completion_over
= 1;
2168 /* If the handle_brkchars phase was aborted, don't try
2170 if (current_completion
.aborted
)
2175 return gdb_rl_attempted_completion_function_throw (text
, start
, end
);
2177 CATCH (ex
, RETURN_MASK_ALL
)
2185 /* Skip over the possibly quoted word STR (as defined by the quote
2186 characters QUOTECHARS and the word break characters BREAKCHARS).
2187 Returns pointer to the location after the "word". If either
2188 QUOTECHARS or BREAKCHARS is NULL, use the same values used by the
2192 skip_quoted_chars (const char *str
, const char *quotechars
,
2193 const char *breakchars
)
2195 char quote_char
= '\0';
2198 if (quotechars
== NULL
)
2199 quotechars
= gdb_completer_quote_characters
;
2201 if (breakchars
== NULL
)
2202 breakchars
= current_language
->la_word_break_characters();
2204 for (scan
= str
; *scan
!= '\0'; scan
++)
2206 if (quote_char
!= '\0')
2208 /* Ignore everything until the matching close quote char. */
2209 if (*scan
== quote_char
)
2211 /* Found matching close quote. */
2216 else if (strchr (quotechars
, *scan
))
2218 /* Found start of a quoted string. */
2221 else if (strchr (breakchars
, *scan
))
2230 /* Skip over the possibly quoted word STR (as defined by the quote
2231 characters and word break characters used by the completer).
2232 Returns pointer to the location after the "word". */
2235 skip_quoted (const char *str
)
2237 return skip_quoted_chars (str
, NULL
, NULL
);
2240 /* Return a message indicating that the maximum number of completions
2241 has been reached and that there may be more. */
2244 get_max_completions_reached_message (void)
2246 return _("*** List may be truncated, max-completions reached. ***");
2249 /* GDB replacement for rl_display_match_list.
2250 Readline doesn't provide a clean interface for TUI(curses).
2251 A hack previously used was to send readline's rl_outstream through a pipe
2252 and read it from the event loop. Bleah. IWBN if readline abstracted
2253 away all the necessary bits, and this is what this code does. It
2254 replicates the parts of readline we need and then adds an abstraction
2255 layer, currently implemented as struct match_list_displayer, so that both
2256 CLI and TUI can use it. We copy all this readline code to minimize
2257 GDB-specific mods to readline. Once this code performs as desired then
2258 we can submit it to the readline maintainers.
2260 N.B. A lot of the code is the way it is in order to minimize differences
2261 from readline's copy. */
2263 /* Not supported here. */
2264 #undef VISIBLE_STATS
2266 #if defined (HANDLE_MULTIBYTE)
2267 #define MB_INVALIDCH(x) ((x) == (size_t)-1 || (x) == (size_t)-2)
2268 #define MB_NULLWCH(x) ((x) == 0)
2271 #define ELLIPSIS_LEN 3
2273 /* gdb version of readline/complete.c:get_y_or_n.
2274 'y' -> returns 1, and 'n' -> returns 0.
2275 Also supported: space == 'y', RUBOUT == 'n', ctrl-g == start over.
2276 If FOR_PAGER is non-zero, then also supported are:
2277 NEWLINE or RETURN -> returns 2, and 'q' -> returns 0. */
2280 gdb_get_y_or_n (int for_pager
, const struct match_list_displayer
*displayer
)
2286 RL_SETSTATE (RL_STATE_MOREINPUT
);
2287 c
= displayer
->read_key (displayer
);
2288 RL_UNSETSTATE (RL_STATE_MOREINPUT
);
2290 if (c
== 'y' || c
== 'Y' || c
== ' ')
2292 if (c
== 'n' || c
== 'N' || c
== RUBOUT
)
2294 if (c
== ABORT_CHAR
|| c
< 0)
2296 /* Readline doesn't erase_entire_line here, but without it the
2297 --More-- prompt isn't erased and neither is the text entered
2298 thus far redisplayed. */
2299 displayer
->erase_entire_line (displayer
);
2300 /* Note: The arguments to rl_abort are ignored. */
2303 if (for_pager
&& (c
== NEWLINE
|| c
== RETURN
))
2305 if (for_pager
&& (c
== 'q' || c
== 'Q'))
2307 displayer
->beep (displayer
);
2311 /* Pager function for tab-completion.
2312 This is based on readline/complete.c:_rl_internal_pager.
2313 LINES is the number of lines of output displayed thus far.
2315 -1 -> user pressed 'n' or equivalent,
2316 0 -> user pressed 'y' or equivalent,
2317 N -> user pressed NEWLINE or equivalent and N is LINES - 1. */
2320 gdb_display_match_list_pager (int lines
,
2321 const struct match_list_displayer
*displayer
)
2325 displayer
->puts (displayer
, "--More--");
2326 displayer
->flush (displayer
);
2327 i
= gdb_get_y_or_n (1, displayer
);
2328 displayer
->erase_entire_line (displayer
);
2337 /* Return non-zero if FILENAME is a directory.
2338 Based on readline/complete.c:path_isdir. */
2341 gdb_path_isdir (const char *filename
)
2345 return (stat (filename
, &finfo
) == 0 && S_ISDIR (finfo
.st_mode
));
2348 /* Return the portion of PATHNAME that should be output when listing
2349 possible completions. If we are hacking filename completion, we
2350 are only interested in the basename, the portion following the
2351 final slash. Otherwise, we return what we were passed. Since
2352 printing empty strings is not very informative, if we're doing
2353 filename completion, and the basename is the empty string, we look
2354 for the previous slash and return the portion following that. If
2355 there's no previous slash, we just return what we were passed.
2357 Based on readline/complete.c:printable_part. */
2360 gdb_printable_part (char *pathname
)
2364 if (rl_filename_completion_desired
== 0) /* don't need to do anything */
2367 temp
= strrchr (pathname
, '/');
2368 #if defined (__MSDOS__)
2369 if (temp
== 0 && ISALPHA ((unsigned char)pathname
[0]) && pathname
[1] == ':')
2370 temp
= pathname
+ 1;
2373 if (temp
== 0 || *temp
== '\0')
2375 /* If the basename is NULL, we might have a pathname like '/usr/src/'.
2376 Look for a previous slash and, if one is found, return the portion
2377 following that slash. If there's no previous slash, just return the
2378 pathname we were passed. */
2379 else if (temp
[1] == '\0')
2381 for (x
= temp
- 1; x
> pathname
; x
--)
2384 return ((*x
== '/') ? x
+ 1 : pathname
);
2390 /* Compute width of STRING when displayed on screen by print_filename.
2391 Based on readline/complete.c:fnwidth. */
2394 gdb_fnwidth (const char *string
)
2397 #if defined (HANDLE_MULTIBYTE)
2403 left
= strlen (string
) + 1;
2404 memset (&ps
, 0, sizeof (mbstate_t));
2410 if (CTRL_CHAR (string
[pos
]) || string
[pos
] == RUBOUT
)
2417 #if defined (HANDLE_MULTIBYTE)
2418 clen
= mbrtowc (&wc
, string
+ pos
, left
- pos
, &ps
);
2419 if (MB_INVALIDCH (clen
))
2423 memset (&ps
, 0, sizeof (mbstate_t));
2425 else if (MB_NULLWCH (clen
))
2431 width
+= (w
>= 0) ? w
: 1;
2443 /* Print TO_PRINT, one matching completion.
2444 PREFIX_BYTES is number of common prefix bytes.
2445 Based on readline/complete.c:fnprint. */
2448 gdb_fnprint (const char *to_print
, int prefix_bytes
,
2449 const struct match_list_displayer
*displayer
)
2453 #if defined (HANDLE_MULTIBYTE)
2460 end
= to_print
+ strlen (to_print
) + 1;
2461 memset (&ps
, 0, sizeof (mbstate_t));
2466 /* Don't print only the ellipsis if the common prefix is one of the
2467 possible completions */
2468 if (to_print
[prefix_bytes
] == '\0')
2475 ellipsis
= (to_print
[prefix_bytes
] == '.') ? '_' : '.';
2476 for (w
= 0; w
< ELLIPSIS_LEN
; w
++)
2477 displayer
->putch (displayer
, ellipsis
);
2478 printed_len
= ELLIPSIS_LEN
;
2481 s
= to_print
+ prefix_bytes
;
2486 displayer
->putch (displayer
, '^');
2487 displayer
->putch (displayer
, UNCTRL (*s
));
2490 #if defined (HANDLE_MULTIBYTE)
2491 memset (&ps
, 0, sizeof (mbstate_t));
2494 else if (*s
== RUBOUT
)
2496 displayer
->putch (displayer
, '^');
2497 displayer
->putch (displayer
, '?');
2500 #if defined (HANDLE_MULTIBYTE)
2501 memset (&ps
, 0, sizeof (mbstate_t));
2506 #if defined (HANDLE_MULTIBYTE)
2507 tlen
= mbrtowc (&wc
, s
, end
- s
, &ps
);
2508 if (MB_INVALIDCH (tlen
))
2512 memset (&ps
, 0, sizeof (mbstate_t));
2514 else if (MB_NULLWCH (tlen
))
2519 width
= (w
>= 0) ? w
: 1;
2521 for (w
= 0; w
< tlen
; ++w
)
2522 displayer
->putch (displayer
, s
[w
]);
2524 printed_len
+= width
;
2526 displayer
->putch (displayer
, *s
);
2536 /* Output TO_PRINT to rl_outstream. If VISIBLE_STATS is defined and we
2537 are using it, check for and output a single character for `special'
2538 filenames. Return the number of characters we output.
2539 Based on readline/complete.c:print_filename. */
2542 gdb_print_filename (char *to_print
, char *full_pathname
, int prefix_bytes
,
2543 const struct match_list_displayer
*displayer
)
2545 int printed_len
, extension_char
, slen
, tlen
;
2546 char *s
, c
, *new_full_pathname
;
2548 extern int _rl_complete_mark_directories
;
2551 printed_len
= gdb_fnprint (to_print
, prefix_bytes
, displayer
);
2553 #if defined (VISIBLE_STATS)
2554 if (rl_filename_completion_desired
&& (rl_visible_stats
|| _rl_complete_mark_directories
))
2556 if (rl_filename_completion_desired
&& _rl_complete_mark_directories
)
2559 /* If to_print != full_pathname, to_print is the basename of the
2560 path passed. In this case, we try to expand the directory
2561 name before checking for the stat character. */
2562 if (to_print
!= full_pathname
)
2564 /* Terminate the directory name. */
2566 to_print
[-1] = '\0';
2568 /* If setting the last slash in full_pathname to a NUL results in
2569 full_pathname being the empty string, we are trying to complete
2570 files in the root directory. If we pass a null string to the
2571 bash directory completion hook, for example, it will expand it
2572 to the current directory. We just want the `/'. */
2573 if (full_pathname
== 0 || *full_pathname
== 0)
2575 else if (full_pathname
[0] != '/')
2577 else if (full_pathname
[1] == 0)
2578 dn
= "//"; /* restore trailing slash to `//' */
2579 else if (full_pathname
[1] == '/' && full_pathname
[2] == 0)
2580 dn
= "/"; /* don't turn /// into // */
2583 s
= tilde_expand (dn
);
2584 if (rl_directory_completion_hook
)
2585 (*rl_directory_completion_hook
) (&s
);
2588 tlen
= strlen (to_print
);
2589 new_full_pathname
= (char *)xmalloc (slen
+ tlen
+ 2);
2590 strcpy (new_full_pathname
, s
);
2591 if (s
[slen
- 1] == '/')
2594 new_full_pathname
[slen
] = '/';
2595 new_full_pathname
[slen
] = '/';
2596 strcpy (new_full_pathname
+ slen
+ 1, to_print
);
2598 #if defined (VISIBLE_STATS)
2599 if (rl_visible_stats
)
2600 extension_char
= stat_char (new_full_pathname
);
2603 if (gdb_path_isdir (new_full_pathname
))
2604 extension_char
= '/';
2606 xfree (new_full_pathname
);
2611 s
= tilde_expand (full_pathname
);
2612 #if defined (VISIBLE_STATS)
2613 if (rl_visible_stats
)
2614 extension_char
= stat_char (s
);
2617 if (gdb_path_isdir (s
))
2618 extension_char
= '/';
2624 displayer
->putch (displayer
, extension_char
);
2632 /* GDB version of readline/complete.c:complete_get_screenwidth. */
2635 gdb_complete_get_screenwidth (const struct match_list_displayer
*displayer
)
2637 /* Readline has other stuff here which it's not clear we need. */
2638 return displayer
->width
;
2641 extern int _rl_completion_prefix_display_length
;
2642 extern int _rl_print_completions_horizontally
;
2644 EXTERN_C
int _rl_qsort_string_compare (const void *, const void *);
2645 typedef int QSFUNC (const void *, const void *);
2647 /* GDB version of readline/complete.c:rl_display_match_list.
2648 See gdb_display_match_list for a description of MATCHES, LEN, MAX.
2649 Returns non-zero if all matches are displayed. */
2652 gdb_display_match_list_1 (char **matches
, int len
, int max
,
2653 const struct match_list_displayer
*displayer
)
2655 int count
, limit
, printed_len
, lines
, cols
;
2656 int i
, j
, k
, l
, common_length
, sind
;
2658 int page_completions
= displayer
->height
!= INT_MAX
&& pagination_enabled
;
2660 /* Find the length of the prefix common to all items: length as displayed
2661 characters (common_length) and as a byte index into the matches (sind) */
2662 common_length
= sind
= 0;
2663 if (_rl_completion_prefix_display_length
> 0)
2665 t
= gdb_printable_part (matches
[0]);
2666 temp
= strrchr (t
, '/');
2667 common_length
= temp
? gdb_fnwidth (temp
) : gdb_fnwidth (t
);
2668 sind
= temp
? strlen (temp
) : strlen (t
);
2670 if (common_length
> _rl_completion_prefix_display_length
&& common_length
> ELLIPSIS_LEN
)
2671 max
-= common_length
- ELLIPSIS_LEN
;
2673 common_length
= sind
= 0;
2676 /* How many items of MAX length can we fit in the screen window? */
2677 cols
= gdb_complete_get_screenwidth (displayer
);
2680 if (limit
!= 1 && (limit
* max
== cols
))
2683 /* If cols == 0, limit will end up -1 */
2684 if (cols
< displayer
->width
&& limit
< 0)
2687 /* Avoid a possible floating exception. If max > cols,
2688 limit will be 0 and a divide-by-zero fault will result. */
2692 /* How many iterations of the printing loop? */
2693 count
= (len
+ (limit
- 1)) / limit
;
2695 /* Watch out for special case. If LEN is less than LIMIT, then
2696 just do the inner printing loop.
2697 0 < len <= limit implies count = 1. */
2699 /* Sort the items if they are not already sorted. */
2700 if (rl_ignore_completion_duplicates
== 0 && rl_sort_completion_matches
)
2701 qsort (matches
+ 1, len
, sizeof (char *), (QSFUNC
*)_rl_qsort_string_compare
);
2703 displayer
->crlf (displayer
);
2706 if (_rl_print_completions_horizontally
== 0)
2708 /* Print the sorted items, up-and-down alphabetically, like ls. */
2709 for (i
= 1; i
<= count
; i
++)
2711 for (j
= 0, l
= i
; j
< limit
; j
++)
2713 if (l
> len
|| matches
[l
] == 0)
2717 temp
= gdb_printable_part (matches
[l
]);
2718 printed_len
= gdb_print_filename (temp
, matches
[l
], sind
,
2722 for (k
= 0; k
< max
- printed_len
; k
++)
2723 displayer
->putch (displayer
, ' ');
2727 displayer
->crlf (displayer
);
2729 if (page_completions
&& lines
>= (displayer
->height
- 1) && i
< count
)
2731 lines
= gdb_display_match_list_pager (lines
, displayer
);
2739 /* Print the sorted items, across alphabetically, like ls -x. */
2740 for (i
= 1; matches
[i
]; i
++)
2742 temp
= gdb_printable_part (matches
[i
]);
2743 printed_len
= gdb_print_filename (temp
, matches
[i
], sind
, displayer
);
2744 /* Have we reached the end of this line? */
2747 if (i
&& (limit
> 1) && (i
% limit
) == 0)
2749 displayer
->crlf (displayer
);
2751 if (page_completions
&& lines
>= displayer
->height
- 1)
2753 lines
= gdb_display_match_list_pager (lines
, displayer
);
2759 for (k
= 0; k
< max
- printed_len
; k
++)
2760 displayer
->putch (displayer
, ' ');
2763 displayer
->crlf (displayer
);
2769 /* Utility for displaying completion list matches, used by both CLI and TUI.
2771 MATCHES is the list of strings, in argv format, LEN is the number of
2772 strings in MATCHES, and MAX is the length of the longest string in
2776 gdb_display_match_list (char **matches
, int len
, int max
,
2777 const struct match_list_displayer
*displayer
)
2779 /* Readline will never call this if complete_line returned NULL. */
2780 gdb_assert (max_completions
!= 0);
2782 /* complete_line will never return more than this. */
2783 if (max_completions
> 0)
2784 gdb_assert (len
<= max_completions
);
2786 if (rl_completion_query_items
> 0 && len
>= rl_completion_query_items
)
2790 /* We can't use *query here because they wait for <RET> which is
2791 wrong here. This follows the readline version as closely as possible
2792 for compatibility's sake. See readline/complete.c. */
2794 displayer
->crlf (displayer
);
2796 xsnprintf (msg
, sizeof (msg
),
2797 "Display all %d possibilities? (y or n)", len
);
2798 displayer
->puts (displayer
, msg
);
2799 displayer
->flush (displayer
);
2801 if (gdb_get_y_or_n (0, displayer
) == 0)
2803 displayer
->crlf (displayer
);
2808 if (gdb_display_match_list_1 (matches
, len
, max
, displayer
))
2810 /* Note: MAX_COMPLETIONS may be -1 or zero, but LEN is always > 0. */
2811 if (len
== max_completions
)
2813 /* The maximum number of completions has been reached. Warn the user
2814 that there may be more. */
2815 const char *message
= get_max_completions_reached_message ();
2817 displayer
->puts (displayer
, message
);
2818 displayer
->crlf (displayer
);
2824 _initialize_completer (void)
2826 add_setshow_zuinteger_unlimited_cmd ("max-completions", no_class
,
2827 &max_completions
, _("\
2828 Set maximum number of completion candidates."), _("\
2829 Show maximum number of completion candidates."), _("\
2830 Use this to limit the number of candidates considered\n\
2831 during completion. Specifying \"unlimited\" or -1\n\
2832 disables limiting. Note that setting either no limit or\n\
2833 a very large limit can make completion slow."),
2834 NULL
, NULL
, &setlist
, &showlist
);