1 /* Line completion stuff for GDB, the GNU debugger.
2 Copyright (C) 2000-2019 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 "common/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
)
161 gdb::unique_xmalloc_ptr
<char> p_rl
162 (rl_filename_completion_function (text
, subsequent_name
));
165 /* We need to set subsequent_name to a non-zero value before the
166 continue line below, because otherwise, if the first file
167 seen by GDB is a backup file whose name ends in a `~', we
168 will loop indefinitely. */
170 /* Like emacs, don't complete on old versions. Especially
171 useful in the "source" command. */
172 const char *p
= p_rl
.get ();
173 if (p
[strlen (p
) - 1] == '~')
176 tracker
.add_completion
177 (make_completion_match_str (std::move (p_rl
), text
, word
));
180 /* There is no way to do this just long enough to affect quote
181 inserting without also affecting the next completion. This
182 should be fixed in readline. FIXME. */
183 /* Ensure that readline does the right thing
184 with respect to inserting quotes. */
185 rl_completer_word_break_characters
= "";
189 /* The corresponding completer_handle_brkchars
193 filename_completer_handle_brkchars (struct cmd_list_element
*ignore
,
194 completion_tracker
&tracker
,
195 const char *text
, const char *word
)
197 set_rl_completer_word_break_characters
198 (gdb_completer_file_name_break_characters
);
201 /* Possible values for the found_quote flags word used by the completion
202 functions. It says what kind of (shell-like) quoting we found anywhere
204 #define RL_QF_SINGLE_QUOTE 0x01
205 #define RL_QF_DOUBLE_QUOTE 0x02
206 #define RL_QF_BACKSLASH 0x04
207 #define RL_QF_OTHER_QUOTE 0x08
209 /* Find the bounds of the current word for completion purposes, and
210 return a pointer to the end of the word. This mimics (and is a
211 modified version of) readline's _rl_find_completion_word internal
214 This function skips quoted substrings (characters between matched
215 pairs of characters in rl_completer_quote_characters). We try to
216 find an unclosed quoted substring on which to do matching. If one
217 is not found, we use the word break characters to find the
218 boundaries of the current word. QC, if non-null, is set to the
219 opening quote character if we found an unclosed quoted substring,
220 '\0' otherwise. DP, if non-null, is set to the value of the
221 delimiter character that caused a word break. */
223 struct gdb_rl_completion_word_info
225 const char *word_break_characters
;
226 const char *quote_characters
;
227 const char *basic_quote_characters
;
231 gdb_rl_find_completion_word (struct gdb_rl_completion_word_info
*info
,
233 const char *line_buffer
)
235 int scan
, end
, found_quote
, delimiter
, pass_next
, isbrk
;
237 const char *brkchars
;
238 int point
= strlen (line_buffer
);
240 /* The algorithm below does '--point'. Avoid buffer underflow with
252 found_quote
= delimiter
= 0;
255 brkchars
= info
->word_break_characters
;
257 if (info
->quote_characters
!= NULL
)
259 /* We have a list of characters which can be used in pairs to
260 quote substrings for the completer. Try to find the start of
261 an unclosed quoted substring. */
262 /* FOUND_QUOTE is set so we know what kind of quotes we
264 for (scan
= pass_next
= 0;
274 /* Shell-like semantics for single quotes -- don't allow
275 backslash to quote anything in single quotes, especially
276 not the closing quote. If you don't like this, take out
277 the check on the value of quote_char. */
278 if (quote_char
!= '\'' && line_buffer
[scan
] == '\\')
281 found_quote
|= RL_QF_BACKSLASH
;
285 if (quote_char
!= '\0')
287 /* Ignore everything until the matching close quote
289 if (line_buffer
[scan
] == quote_char
)
291 /* Found matching close. Abandon this
297 else if (strchr (info
->quote_characters
, line_buffer
[scan
]))
299 /* Found start of a quoted substring. */
300 quote_char
= line_buffer
[scan
];
302 /* Shell-like quoting conventions. */
303 if (quote_char
== '\'')
304 found_quote
|= RL_QF_SINGLE_QUOTE
;
305 else if (quote_char
== '"')
306 found_quote
|= RL_QF_DOUBLE_QUOTE
;
308 found_quote
|= RL_QF_OTHER_QUOTE
;
313 if (point
== end
&& quote_char
== '\0')
315 /* We didn't find an unclosed quoted substring upon which to do
316 completion, so use the word break characters to find the
317 substring on which to complete. */
320 scan
= line_buffer
[point
];
322 if (strchr (brkchars
, scan
) != 0)
327 /* If we are at an unquoted word break, then advance past it. */
328 scan
= line_buffer
[point
];
332 isbrk
= strchr (brkchars
, scan
) != 0;
336 /* If the character that caused the word break was a quoting
337 character, then remember it as the delimiter. */
338 if (info
->basic_quote_characters
339 && strchr (info
->basic_quote_characters
, scan
)
340 && (end
- point
) > 1)
352 return line_buffer
+ point
;
355 /* Find the completion word point for TEXT, emulating the algorithm
356 readline uses to find the word point, using WORD_BREAK_CHARACTERS
357 as word break characters. */
360 advance_to_completion_word (completion_tracker
&tracker
,
361 const char *word_break_characters
,
364 gdb_rl_completion_word_info info
;
366 info
.word_break_characters
= word_break_characters
;
367 info
.quote_characters
= gdb_completer_quote_characters
;
368 info
.basic_quote_characters
= rl_basic_quote_characters
;
372 = gdb_rl_find_completion_word (&info
, NULL
, &delimiter
, text
);
374 tracker
.advance_custom_word_point_by (start
- text
);
378 tracker
.set_quote_char (delimiter
);
379 tracker
.set_suppress_append_ws (true);
385 /* See completer.h. */
388 advance_to_expression_complete_word_point (completion_tracker
&tracker
,
391 const char *brk_chars
= current_language
->la_word_break_characters ();
392 return advance_to_completion_word (tracker
, brk_chars
, text
);
395 /* See completer.h. */
398 advance_to_filename_complete_word_point (completion_tracker
&tracker
,
401 const char *brk_chars
= gdb_completer_file_name_break_characters
;
402 return advance_to_completion_word (tracker
, brk_chars
, text
);
405 /* See completer.h. */
408 completion_tracker::completes_to_completion_word (const char *word
)
410 if (m_lowest_common_denominator_unique
)
412 const char *lcd
= m_lowest_common_denominator
;
414 if (strncmp_iw (word
, lcd
, strlen (lcd
)) == 0)
416 /* Maybe skip the function and complete on keywords. */
417 size_t wordlen
= strlen (word
);
418 if (word
[wordlen
- 1] == ' ')
426 /* Complete on linespecs, which might be of two possible forms:
432 This is intended to be used in commands that set breakpoints
436 complete_files_symbols (completion_tracker
&tracker
,
437 const char *text
, const char *word
)
439 completion_list fn_list
;
442 int quoted
= *text
== '\'' || *text
== '"';
443 int quote_char
= '\0';
444 const char *colon
= NULL
;
445 char *file_to_match
= NULL
;
446 const char *symbol_start
= text
;
447 const char *orig_text
= text
;
449 /* Do we have an unquoted colon, as in "break foo.c:bar"? */
450 for (p
= text
; *p
!= '\0'; ++p
)
452 if (*p
== '\\' && p
[1] == '\'')
454 else if (*p
== '\'' || *p
== '"')
458 while (*p
!= '\0' && *p
!= quote_found
)
460 if (*p
== '\\' && p
[1] == quote_found
)
465 if (*p
== quote_found
)
468 break; /* Hit the end of text. */
470 #if HAVE_DOS_BASED_FILE_SYSTEM
471 /* If we have a DOS-style absolute file name at the beginning of
472 TEXT, and the colon after the drive letter is the only colon
473 we found, pretend the colon is not there. */
474 else if (p
< text
+ 3 && *p
== ':' && p
== text
+ 1 + quoted
)
477 else if (*p
== ':' && !colon
)
480 symbol_start
= p
+ 1;
482 else if (strchr (current_language
->la_word_break_characters(), *p
))
483 symbol_start
= p
+ 1;
489 /* Where is the file name? */
494 file_to_match
= (char *) xmalloc (colon
- text
+ 1);
495 strncpy (file_to_match
, text
, colon
- text
);
496 file_to_match
[colon
- text
] = '\0';
497 /* Remove trailing colons and quotes from the file name. */
498 for (s
= file_to_match
+ (colon
- text
);
501 if (*s
== ':' || *s
== quote_char
)
504 /* If the text includes a colon, they want completion only on a
505 symbol name after the colon. Otherwise, we need to complete on
506 symbols as well as on files. */
509 collect_file_symbol_completion_matches (tracker
,
510 complete_symbol_mode::EXPRESSION
,
511 symbol_name_match_type::EXPRESSION
,
514 xfree (file_to_match
);
518 size_t text_len
= strlen (text
);
520 collect_symbol_completion_matches (tracker
,
521 complete_symbol_mode::EXPRESSION
,
522 symbol_name_match_type::EXPRESSION
,
524 /* If text includes characters which cannot appear in a file
525 name, they cannot be asking for completion on files. */
527 gdb_completer_file_name_break_characters
) == text_len
)
528 fn_list
= make_source_files_completion_list (text
, text
);
531 if (!fn_list
.empty () && !tracker
.have_completions ())
533 /* If we only have file names as possible completion, we should
534 bring them in sync with what rl_complete expects. The
535 problem is that if the user types "break /foo/b TAB", and the
536 possible completions are "/foo/bar" and "/foo/baz"
537 rl_complete expects us to return "bar" and "baz", without the
538 leading directories, as possible completions, because `word'
539 starts at the "b". But we ignore the value of `word' when we
540 call make_source_files_completion_list above (because that
541 would not DTRT when the completion results in both symbols
542 and file names), so make_source_files_completion_list returns
543 the full "/foo/bar" and "/foo/baz" strings. This produces
544 wrong results when, e.g., there's only one possible
545 completion, because rl_complete will prepend "/foo/" to each
546 candidate completion. The loop below removes that leading
548 for (const auto &fn_up
: fn_list
)
550 char *fn
= fn_up
.get ();
551 memmove (fn
, fn
+ (word
- text
), strlen (fn
) + 1 - (word
- text
));
555 tracker
.add_completions (std::move (fn_list
));
557 if (!tracker
.have_completions ())
559 /* No completions at all. As the final resort, try completing
560 on the entire text as a symbol. */
561 collect_symbol_completion_matches (tracker
,
562 complete_symbol_mode::EXPRESSION
,
563 symbol_name_match_type::EXPRESSION
,
568 /* See completer.h. */
571 complete_source_filenames (const char *text
)
573 size_t text_len
= strlen (text
);
575 /* If text includes characters which cannot appear in a file name,
576 the user cannot be asking for completion on files. */
578 gdb_completer_file_name_break_characters
)
580 return make_source_files_completion_list (text
, text
);
585 /* Complete address and linespec locations. */
588 complete_address_and_linespec_locations (completion_tracker
&tracker
,
590 symbol_name_match_type match_type
)
594 tracker
.advance_custom_word_point_by (1);
597 = advance_to_expression_complete_word_point (tracker
, text
);
598 complete_expression (tracker
, text
, word
);
602 linespec_complete (tracker
, text
, match_type
);
606 /* The explicit location options. Note that indexes into this array
607 must match the explicit_location_match_type enumerators. */
609 static const char *const explicit_options
[] =
619 /* The probe modifier options. These can appear before a location in
620 breakpoint commands. */
621 static const char *const probe_options
[] =
629 /* Returns STRING if not NULL, the empty string otherwise. */
632 string_or_empty (const char *string
)
634 return string
!= NULL
? string
: "";
637 /* A helper function to collect explicit location matches for the given
638 LOCATION, which is attempting to match on WORD. */
641 collect_explicit_location_matches (completion_tracker
&tracker
,
642 struct event_location
*location
,
643 enum explicit_location_match_type what
,
645 const struct language_defn
*language
)
647 const struct explicit_location
*explicit_loc
648 = get_explicit_location (location
);
650 /* True if the option expects an argument. */
651 bool needs_arg
= true;
653 /* Note, in the various MATCH_* below, we complete on
654 explicit_loc->foo instead of WORD, because only the former will
655 have already skipped past any quote char. */
660 const char *source
= string_or_empty (explicit_loc
->source_filename
);
661 completion_list matches
662 = make_source_files_completion_list (source
, source
);
663 tracker
.add_completions (std::move (matches
));
669 const char *function
= string_or_empty (explicit_loc
->function_name
);
670 linespec_complete_function (tracker
, function
,
671 explicit_loc
->func_name_match_type
,
672 explicit_loc
->source_filename
);
676 case MATCH_QUALIFIED
:
680 /* Nothing to offer. */
685 const char *label
= string_or_empty (explicit_loc
->label_name
);
686 linespec_complete_label (tracker
, language
,
687 explicit_loc
->source_filename
,
688 explicit_loc
->function_name
,
689 explicit_loc
->func_name_match_type
,
695 gdb_assert_not_reached ("unhandled explicit_location_match_type");
698 if (!needs_arg
|| tracker
.completes_to_completion_word (word
))
700 tracker
.discard_completions ();
701 tracker
.advance_custom_word_point_by (strlen (word
));
702 complete_on_enum (tracker
, explicit_options
, "", "");
703 complete_on_enum (tracker
, linespec_keywords
, "", "");
705 else if (!tracker
.have_completions ())
707 /* Maybe we have an unterminated linespec keyword at the tail of
708 the string. Try completing on that. */
709 size_t wordlen
= strlen (word
);
710 const char *keyword
= word
+ wordlen
;
712 if (wordlen
> 0 && keyword
[-1] != ' ')
714 while (keyword
> word
&& *keyword
!= ' ')
716 /* Don't complete on keywords if we'd be completing on the
717 whole explicit linespec option. E.g., "b -function
718 thr<tab>" should not complete to the "thread"
722 keyword
= skip_spaces (keyword
);
724 tracker
.advance_custom_word_point_by (keyword
- word
);
725 complete_on_enum (tracker
, linespec_keywords
, keyword
, keyword
);
728 else if (wordlen
> 0 && keyword
[-1] == ' ')
730 /* Assume that we're maybe past the explicit location
731 argument, and we didn't manage to find any match because
732 the user wants to create a pending breakpoint. Offer the
733 keyword and explicit location options as possible
735 tracker
.advance_custom_word_point_by (keyword
- word
);
736 complete_on_enum (tracker
, linespec_keywords
, keyword
, keyword
);
737 complete_on_enum (tracker
, explicit_options
, keyword
, keyword
);
742 /* If the next word in *TEXT_P is any of the keywords in KEYWORDS,
743 then advance both TEXT_P and the word point in the tracker past the
744 keyword and return the (0-based) index in the KEYWORDS array that
745 matched. Otherwise, return -1. */
748 skip_keyword (completion_tracker
&tracker
,
749 const char * const *keywords
, const char **text_p
)
751 const char *text
= *text_p
;
752 const char *after
= skip_to_space (text
);
753 size_t len
= after
- text
;
755 if (text
[len
] != ' ')
759 for (int i
= 0; keywords
[i
] != NULL
; i
++)
761 if (strncmp (keywords
[i
], text
, len
) == 0)
772 tracker
.advance_custom_word_point_by (len
+ 1);
781 /* A completer function for explicit locations. This function
782 completes both options ("-source", "-line", etc) and values. If
783 completing a quoted string, then QUOTED_ARG_START and
784 QUOTED_ARG_END point to the quote characters. LANGUAGE is the
788 complete_explicit_location (completion_tracker
&tracker
,
789 struct event_location
*location
,
791 const language_defn
*language
,
792 const char *quoted_arg_start
,
793 const char *quoted_arg_end
)
798 int keyword
= skip_keyword (tracker
, explicit_options
, &text
);
801 complete_on_enum (tracker
, explicit_options
, text
, text
);
804 /* Completing on value. */
805 enum explicit_location_match_type what
806 = (explicit_location_match_type
) keyword
;
808 if (quoted_arg_start
!= NULL
&& quoted_arg_end
!= NULL
)
810 if (quoted_arg_end
[1] == '\0')
812 /* If completing a quoted string with the cursor right
813 at the terminating quote char, complete the
814 completion word without interpretation, so that
815 readline advances the cursor one whitespace past the
816 quote, even if there's no match. This makes these
817 cases behave the same:
819 before: "b -function function()"
820 after: "b -function function() "
822 before: "b -function 'function()'"
823 after: "b -function 'function()' "
825 and trusts the user in this case:
827 before: "b -function 'not_loaded_function_yet()'"
828 after: "b -function 'not_loaded_function_yet()' "
830 tracker
.add_completion (make_unique_xstrdup (text
));
832 else if (quoted_arg_end
[1] == ' ')
834 /* We're maybe past the explicit location argument.
835 Skip the argument without interpretion, assuming the
836 user may want to create pending breakpoint. Offer
837 the keyword and explicit location options as possible
839 tracker
.advance_custom_word_point_by (strlen (text
));
840 complete_on_enum (tracker
, linespec_keywords
, "", "");
841 complete_on_enum (tracker
, explicit_options
, "", "");
846 /* Now gather matches */
847 collect_explicit_location_matches (tracker
, location
, what
, text
,
852 /* A completer for locations. */
855 location_completer (struct cmd_list_element
*ignore
,
856 completion_tracker
&tracker
,
857 const char *text
, const char * /* word */)
859 int found_probe_option
= -1;
861 /* If we have a probe modifier, skip it. This can only appear as
862 first argument. Until we have a specific completer for probes,
863 falling back to the linespec completer for the remainder of the
864 line is better than nothing. */
865 if (text
[0] == '-' && text
[1] == 'p')
866 found_probe_option
= skip_keyword (tracker
, probe_options
, &text
);
868 const char *option_text
= text
;
869 int saved_word_point
= tracker
.custom_word_point ();
871 const char *copy
= text
;
873 explicit_completion_info completion_info
;
874 event_location_up location
875 = string_to_explicit_location (©
, current_language
,
877 if (completion_info
.quoted_arg_start
!= NULL
878 && completion_info
.quoted_arg_end
== NULL
)
880 /* Found an unbalanced quote. */
881 tracker
.set_quote_char (*completion_info
.quoted_arg_start
);
882 tracker
.advance_custom_word_point_by (1);
885 if (completion_info
.saw_explicit_location_option
)
889 tracker
.advance_custom_word_point_by (copy
- text
);
892 /* We found a terminator at the tail end of the string,
893 which means we're past the explicit location options. We
894 may have a keyword to complete on. If we have a whole
895 keyword, then complete whatever comes after as an
896 expression. This is mainly for the "if" keyword. If the
897 "thread" and "task" keywords gain their own completers,
898 they should be used here. */
899 int keyword
= skip_keyword (tracker
, linespec_keywords
, &text
);
903 complete_on_enum (tracker
, linespec_keywords
, text
, text
);
908 = advance_to_expression_complete_word_point (tracker
, text
);
909 complete_expression (tracker
, text
, word
);
914 tracker
.advance_custom_word_point_by (completion_info
.last_option
916 text
= completion_info
.last_option
;
918 complete_explicit_location (tracker
, location
.get (), text
,
920 completion_info
.quoted_arg_start
,
921 completion_info
.quoted_arg_end
);
925 /* This is an address or linespec location. */
926 else if (location
!= NULL
)
928 /* Handle non-explicit location options. */
930 int keyword
= skip_keyword (tracker
, explicit_options
, &text
);
932 complete_on_enum (tracker
, explicit_options
, text
, text
);
935 tracker
.advance_custom_word_point_by (copy
- text
);
938 symbol_name_match_type match_type
939 = get_explicit_location (location
.get ())->func_name_match_type
;
940 complete_address_and_linespec_locations (tracker
, text
, match_type
);
946 complete_address_and_linespec_locations (tracker
, text
,
947 symbol_name_match_type::WILD
);
950 /* Add matches for option names, if either:
952 - Some completer above found some matches, but the word point did
953 not advance (e.g., "b <tab>" finds all functions, or "b -<tab>"
954 matches all objc selectors), or;
956 - Some completer above advanced the word point, but found no
959 if ((text
[0] == '-' || text
[0] == '\0')
960 && (!tracker
.have_completions ()
961 || tracker
.custom_word_point () == saved_word_point
))
963 tracker
.set_custom_word_point (saved_word_point
);
966 if (found_probe_option
== -1)
967 complete_on_enum (tracker
, probe_options
, text
, text
);
968 complete_on_enum (tracker
, explicit_options
, text
, text
);
972 /* The corresponding completer_handle_brkchars
976 location_completer_handle_brkchars (struct cmd_list_element
*ignore
,
977 completion_tracker
&tracker
,
979 const char *word_ignored
)
981 tracker
.set_use_custom_word_point (true);
983 location_completer (ignore
, tracker
, text
, NULL
);
986 /* Helper for expression_completer which recursively adds field and
987 method names from TYPE, a struct or union type, to the OUTPUT
991 add_struct_fields (struct type
*type
, completion_list
&output
,
992 const char *fieldname
, int namelen
)
995 int computed_type_name
= 0;
996 const char *type_name
= NULL
;
998 type
= check_typedef (type
);
999 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
1001 if (i
< TYPE_N_BASECLASSES (type
))
1002 add_struct_fields (TYPE_BASECLASS (type
, i
),
1003 output
, fieldname
, namelen
);
1004 else if (TYPE_FIELD_NAME (type
, i
))
1006 if (TYPE_FIELD_NAME (type
, i
)[0] != '\0')
1008 if (! strncmp (TYPE_FIELD_NAME (type
, i
),
1009 fieldname
, namelen
))
1010 output
.emplace_back (xstrdup (TYPE_FIELD_NAME (type
, i
)));
1012 else if (TYPE_CODE (TYPE_FIELD_TYPE (type
, i
)) == TYPE_CODE_UNION
)
1014 /* Recurse into anonymous unions. */
1015 add_struct_fields (TYPE_FIELD_TYPE (type
, i
),
1016 output
, fieldname
, namelen
);
1021 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
1023 const char *name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1025 if (name
&& ! strncmp (name
, fieldname
, namelen
))
1027 if (!computed_type_name
)
1029 type_name
= TYPE_NAME (type
);
1030 computed_type_name
= 1;
1032 /* Omit constructors from the completion list. */
1033 if (!type_name
|| strcmp (type_name
, name
))
1034 output
.emplace_back (xstrdup (name
));
1039 /* See completer.h. */
1042 complete_expression (completion_tracker
&tracker
,
1043 const char *text
, const char *word
)
1045 struct type
*type
= NULL
;
1046 gdb::unique_xmalloc_ptr
<char> fieldname
;
1047 enum type_code code
= TYPE_CODE_UNDEF
;
1049 /* Perform a tentative parse of the expression, to see whether a
1050 field completion is required. */
1053 type
= parse_expression_for_completion (text
, &fieldname
, &code
);
1055 catch (const gdb_exception_error
&except
)
1060 if (fieldname
!= nullptr && type
)
1064 type
= check_typedef (type
);
1065 if (TYPE_CODE (type
) != TYPE_CODE_PTR
&& !TYPE_IS_REFERENCE (type
))
1067 type
= TYPE_TARGET_TYPE (type
);
1070 if (TYPE_CODE (type
) == TYPE_CODE_UNION
1071 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
1073 completion_list result
;
1075 add_struct_fields (type
, result
, fieldname
.get (),
1076 strlen (fieldname
.get ()));
1077 tracker
.add_completions (std::move (result
));
1081 else if (fieldname
!= nullptr && code
!= TYPE_CODE_UNDEF
)
1083 collect_symbol_completion_matches_type (tracker
, fieldname
.get (),
1084 fieldname
.get (), code
);
1088 complete_files_symbols (tracker
, text
, word
);
1091 /* Complete on expressions. Often this means completing on symbol
1092 names, but some language parsers also have support for completing
1096 expression_completer (struct cmd_list_element
*ignore
,
1097 completion_tracker
&tracker
,
1098 const char *text
, const char *word
)
1100 complete_expression (tracker
, text
, word
);
1103 /* See definition in completer.h. */
1106 set_rl_completer_word_break_characters (const char *break_chars
)
1108 rl_completer_word_break_characters
= (char *) break_chars
;
1111 /* See definition in completer.h. */
1114 set_gdb_completion_word_break_characters (completer_ftype
*fn
)
1116 const char *break_chars
;
1118 /* So far we are only interested in differentiating filename
1119 completers from everything else. */
1120 if (fn
== filename_completer
)
1121 break_chars
= gdb_completer_file_name_break_characters
;
1123 break_chars
= gdb_completer_command_word_break_characters
;
1125 set_rl_completer_word_break_characters (break_chars
);
1128 /* Complete on symbols. */
1131 symbol_completer (struct cmd_list_element
*ignore
,
1132 completion_tracker
&tracker
,
1133 const char *text
, const char *word
)
1135 collect_symbol_completion_matches (tracker
, complete_symbol_mode::EXPRESSION
,
1136 symbol_name_match_type::EXPRESSION
,
1140 /* Here are some useful test cases for completion. FIXME: These
1141 should be put in the test suite. They should be tested with both
1144 "show output-" "radix"
1145 "show output" "-radix"
1146 "p" ambiguous (commands starting with p--path, print, printf, etc.)
1147 "p " ambiguous (all symbols)
1148 "info t foo" no completions
1149 "info t " no completions
1150 "info t" ambiguous ("info target", "info terminal", etc.)
1151 "info ajksdlfk" no completions
1152 "info ajksdlfk " no completions
1154 "info " ambiguous (all info commands)
1155 "p \"a" no completions (string constant)
1156 "p 'a" ambiguous (all symbols starting with a)
1157 "p b-a" ambiguous (all symbols starting with a)
1158 "p b-" ambiguous (all symbols)
1159 "file Make" "file" (word break hard to screw up here)
1160 "file ../gdb.stabs/we" "ird" (needs to not break word at slash)
1163 enum complete_line_internal_reason
1165 /* Preliminary phase, called by gdb_completion_word_break_characters
1166 function, is used to either:
1168 #1 - Determine the set of chars that are word delimiters
1169 depending on the current command in line_buffer.
1171 #2 - Manually advance RL_POINT to the "word break" point instead
1172 of letting readline do it (based on too-simple character
1175 Simpler completers that just pass a brkchars array to readline
1176 (#1 above) must defer generating the completions to the main
1177 phase (below). No completion list should be generated in this
1180 OTOH, completers that manually advance the word point(#2 above)
1181 must set "use_custom_word_point" in the tracker and generate
1182 their completion in this phase. Note that this is the convenient
1183 thing to do since they'll be parsing the input line anyway. */
1186 /* Main phase, called by complete_line function, is used to get the
1187 list of possible completions. */
1190 /* Special case when completing a 'help' command. In this case,
1191 once sub-command completions are exhausted, we simply return
1196 /* Helper for complete_line_internal to simplify it. */
1199 complete_line_internal_normal_command (completion_tracker
&tracker
,
1200 const char *command
, const char *word
,
1201 const char *cmd_args
,
1202 complete_line_internal_reason reason
,
1203 struct cmd_list_element
*c
)
1205 const char *p
= cmd_args
;
1207 if (c
->completer
== filename_completer
)
1209 /* Many commands which want to complete on file names accept
1210 several file names, as in "run foo bar >>baz". So we don't
1211 want to complete the entire text after the command, just the
1212 last word. To this end, we need to find the beginning of the
1213 file name by starting at `word' and going backwards. */
1216 && strchr (gdb_completer_file_name_break_characters
,
1222 if (reason
== handle_brkchars
)
1224 completer_handle_brkchars_ftype
*brkchars_fn
;
1226 if (c
->completer_handle_brkchars
!= NULL
)
1227 brkchars_fn
= c
->completer_handle_brkchars
;
1231 = (completer_handle_brkchars_func_for_completer
1235 brkchars_fn (c
, tracker
, p
, word
);
1238 if (reason
!= handle_brkchars
&& c
->completer
!= NULL
)
1239 (*c
->completer
) (c
, tracker
, p
, word
);
1242 /* Internal function used to handle completions.
1245 TEXT is the caller's idea of the "word" we are looking at.
1247 LINE_BUFFER is available to be looked at; it contains the entire
1248 text of the line. POINT is the offset in that line of the cursor.
1249 You should pretend that the line ends at POINT.
1251 See complete_line_internal_reason for description of REASON. */
1254 complete_line_internal_1 (completion_tracker
&tracker
,
1256 const char *line_buffer
, int point
,
1257 complete_line_internal_reason reason
)
1261 int ignore_help_classes
;
1262 /* Pointer within tmp_command which corresponds to text. */
1264 struct cmd_list_element
*c
, *result_list
;
1266 /* Choose the default set of word break characters to break
1267 completions. If we later find out that we are doing completions
1268 on command strings (as opposed to strings supplied by the
1269 individual command completer functions, which can be any string)
1270 then we will switch to the special word break set for command
1271 strings, which leaves out the '-' character used in some
1273 set_rl_completer_word_break_characters
1274 (current_language
->la_word_break_characters());
1276 /* Decide whether to complete on a list of gdb commands or on
1278 tmp_command
= (char *) alloca (point
+ 1);
1281 /* The help command should complete help aliases. */
1282 ignore_help_classes
= reason
!= handle_help
;
1284 strncpy (tmp_command
, line_buffer
, point
);
1285 tmp_command
[point
] = '\0';
1286 if (reason
== handle_brkchars
)
1288 gdb_assert (text
== NULL
);
1293 /* Since text always contains some number of characters leading up
1294 to point, we can find the equivalent position in tmp_command
1295 by subtracting that many characters from the end of tmp_command. */
1296 word
= tmp_command
+ point
- strlen (text
);
1299 /* Move P up to the start of the command. */
1300 p
= skip_spaces (p
);
1304 /* An empty line is ambiguous; that is, it could be any
1306 c
= CMD_LIST_AMBIGUOUS
;
1311 c
= lookup_cmd_1 (&p
, cmdlist
, &result_list
, ignore_help_classes
);
1314 /* Move p up to the next interesting thing. */
1315 while (*p
== ' ' || *p
== '\t')
1320 tracker
.advance_custom_word_point_by (p
- tmp_command
);
1324 /* It is an unrecognized command. So there are no
1325 possible completions. */
1327 else if (c
== CMD_LIST_AMBIGUOUS
)
1331 /* lookup_cmd_1 advances p up to the first ambiguous thing, but
1332 doesn't advance over that thing itself. Do so now. */
1334 while (*q
&& (isalnum (*q
) || *q
== '-' || *q
== '_'))
1336 if (q
!= tmp_command
+ point
)
1338 /* There is something beyond the ambiguous
1339 command, so there are no possible completions. For
1340 example, "info t " or "info t foo" does not complete
1341 to anything, because "info t" can be "info target" or
1346 /* We're trying to complete on the command which was ambiguous.
1347 This we can deal with. */
1350 if (reason
!= handle_brkchars
)
1351 complete_on_cmdlist (*result_list
->prefixlist
, tracker
, p
,
1352 word
, ignore_help_classes
);
1356 if (reason
!= handle_brkchars
)
1357 complete_on_cmdlist (cmdlist
, tracker
, p
, word
,
1358 ignore_help_classes
);
1360 /* Ensure that readline does the right thing with respect to
1361 inserting quotes. */
1362 set_rl_completer_word_break_characters
1363 (gdb_completer_command_word_break_characters
);
1368 /* We've recognized a full command. */
1370 if (p
== tmp_command
+ point
)
1372 /* There is no non-whitespace in the line beyond the
1375 if (p
[-1] == ' ' || p
[-1] == '\t')
1377 /* The command is followed by whitespace; we need to
1378 complete on whatever comes after command. */
1381 /* It is a prefix command; what comes after it is
1382 a subcommand (e.g. "info "). */
1383 if (reason
!= handle_brkchars
)
1384 complete_on_cmdlist (*c
->prefixlist
, tracker
, p
, word
,
1385 ignore_help_classes
);
1387 /* Ensure that readline does the right thing
1388 with respect to inserting quotes. */
1389 set_rl_completer_word_break_characters
1390 (gdb_completer_command_word_break_characters
);
1392 else if (reason
== handle_help
)
1396 if (reason
!= handle_brkchars
)
1397 complete_on_enum (tracker
, c
->enums
, p
, word
);
1398 set_rl_completer_word_break_characters
1399 (gdb_completer_command_word_break_characters
);
1403 /* It is a normal command; what comes after it is
1404 completed by the command's completer function. */
1405 complete_line_internal_normal_command (tracker
,
1406 tmp_command
, word
, p
,
1412 /* The command is not followed by whitespace; we need to
1413 complete on the command itself, e.g. "p" which is a
1414 command itself but also can complete to "print", "ptype"
1418 /* Find the command we are completing on. */
1420 while (q
> tmp_command
)
1422 if (isalnum (q
[-1]) || q
[-1] == '-' || q
[-1] == '_')
1428 /* Move the custom word point back too. */
1429 tracker
.advance_custom_word_point_by (q
- p
);
1431 if (reason
!= handle_brkchars
)
1432 complete_on_cmdlist (result_list
, tracker
, q
, word
,
1433 ignore_help_classes
);
1435 /* Ensure that readline does the right thing
1436 with respect to inserting quotes. */
1437 set_rl_completer_word_break_characters
1438 (gdb_completer_command_word_break_characters
);
1441 else if (reason
== handle_help
)
1445 /* There is non-whitespace beyond the command. */
1447 if (c
->prefixlist
&& !c
->allow_unknown
)
1449 /* It is an unrecognized subcommand of a prefix command,
1450 e.g. "info adsfkdj". */
1454 if (reason
!= handle_brkchars
)
1455 complete_on_enum (tracker
, c
->enums
, p
, word
);
1459 /* It is a normal command. */
1460 complete_line_internal_normal_command (tracker
,
1461 tmp_command
, word
, p
,
1468 /* Wrapper around complete_line_internal_1 to handle
1469 MAX_COMPLETIONS_REACHED_ERROR. */
1472 complete_line_internal (completion_tracker
&tracker
,
1474 const char *line_buffer
, int point
,
1475 complete_line_internal_reason reason
)
1479 complete_line_internal_1 (tracker
, text
, line_buffer
, point
, reason
);
1481 catch (const gdb_exception_error
&except
)
1483 if (except
.error
!= MAX_COMPLETIONS_REACHED_ERROR
)
1488 /* See completer.h. */
1490 int max_completions
= 200;
1492 /* Initial size of the table. It automagically grows from here. */
1493 #define INITIAL_COMPLETION_HTAB_SIZE 200
1495 /* See completer.h. */
1497 completion_tracker::completion_tracker ()
1499 m_entries_hash
= htab_create_alloc (INITIAL_COMPLETION_HTAB_SIZE
,
1500 htab_hash_string
, streq_hash
,
1501 NULL
, xcalloc
, xfree
);
1504 /* See completer.h. */
1507 completion_tracker::discard_completions ()
1509 xfree (m_lowest_common_denominator
);
1510 m_lowest_common_denominator
= NULL
;
1512 m_lowest_common_denominator_unique
= false;
1514 m_entries_vec
.clear ();
1516 htab_delete (m_entries_hash
);
1517 m_entries_hash
= htab_create_alloc (INITIAL_COMPLETION_HTAB_SIZE
,
1518 htab_hash_string
, streq_hash
,
1519 NULL
, xcalloc
, xfree
);
1522 /* See completer.h. */
1524 completion_tracker::~completion_tracker ()
1526 xfree (m_lowest_common_denominator
);
1527 htab_delete (m_entries_hash
);
1530 /* See completer.h. */
1533 completion_tracker::maybe_add_completion
1534 (gdb::unique_xmalloc_ptr
<char> name
,
1535 completion_match_for_lcd
*match_for_lcd
,
1536 const char *text
, const char *word
)
1540 if (max_completions
== 0)
1543 if (htab_elements (m_entries_hash
) >= max_completions
)
1546 slot
= htab_find_slot (m_entries_hash
, name
.get (), INSERT
);
1547 if (*slot
== HTAB_EMPTY_ENTRY
)
1549 const char *match_for_lcd_str
= NULL
;
1551 if (match_for_lcd
!= NULL
)
1552 match_for_lcd_str
= match_for_lcd
->finish ();
1554 if (match_for_lcd_str
== NULL
)
1555 match_for_lcd_str
= name
.get ();
1557 gdb::unique_xmalloc_ptr
<char> lcd
1558 = make_completion_match_str (match_for_lcd_str
, text
, word
);
1560 recompute_lowest_common_denominator (std::move (lcd
));
1562 *slot
= name
.get ();
1563 m_entries_vec
.push_back (std::move (name
));
1569 /* See completer.h. */
1572 completion_tracker::add_completion (gdb::unique_xmalloc_ptr
<char> name
,
1573 completion_match_for_lcd
*match_for_lcd
,
1574 const char *text
, const char *word
)
1576 if (!maybe_add_completion (std::move (name
), match_for_lcd
, text
, word
))
1577 throw_error (MAX_COMPLETIONS_REACHED_ERROR
, _("Max completions reached."));
1580 /* See completer.h. */
1583 completion_tracker::add_completions (completion_list
&&list
)
1585 for (auto &candidate
: list
)
1586 add_completion (std::move (candidate
));
1589 /* Helper for the make_completion_match_str overloads. Returns NULL
1590 as an indication that we want MATCH_NAME exactly. It is up to the
1591 caller to xstrdup that string if desired. */
1594 make_completion_match_str_1 (const char *match_name
,
1595 const char *text
, const char *word
)
1601 /* Return NULL as an indication that we want MATCH_NAME
1605 else if (word
> text
)
1607 /* Return some portion of MATCH_NAME. */
1608 newobj
= xstrdup (match_name
+ (word
- text
));
1612 /* Return some of WORD plus MATCH_NAME. */
1613 size_t len
= strlen (match_name
);
1614 newobj
= (char *) xmalloc (text
- word
+ len
+ 1);
1615 memcpy (newobj
, word
, text
- word
);
1616 memcpy (newobj
+ (text
- word
), match_name
, len
+ 1);
1622 /* See completer.h. */
1624 gdb::unique_xmalloc_ptr
<char>
1625 make_completion_match_str (const char *match_name
,
1626 const char *text
, const char *word
)
1628 char *newobj
= make_completion_match_str_1 (match_name
, text
, word
);
1630 newobj
= xstrdup (match_name
);
1631 return gdb::unique_xmalloc_ptr
<char> (newobj
);
1634 /* See completer.h. */
1636 gdb::unique_xmalloc_ptr
<char>
1637 make_completion_match_str (gdb::unique_xmalloc_ptr
<char> &&match_name
,
1638 const char *text
, const char *word
)
1640 char *newobj
= make_completion_match_str_1 (match_name
.get (), text
, word
);
1642 return std::move (match_name
);
1643 return gdb::unique_xmalloc_ptr
<char> (newobj
);
1646 /* See complete.h. */
1649 complete (const char *line
, char const **word
, int *quote_char
)
1651 completion_tracker tracker_handle_brkchars
;
1652 completion_tracker tracker_handle_completions
;
1653 completion_tracker
*tracker
;
1655 /* The WORD should be set to the end of word to complete. We initialize
1656 to the completion point which is assumed to be at the end of LINE.
1657 This leaves WORD to be initialized to a sensible value in cases
1658 completion_find_completion_word() fails i.e., throws an exception.
1660 *word
= line
+ strlen (line
);
1664 *word
= completion_find_completion_word (tracker_handle_brkchars
,
1667 /* Completers that provide a custom word point in the
1668 handle_brkchars phase also compute their completions then.
1669 Completers that leave the completion word handling to readline
1670 must be called twice. */
1671 if (tracker_handle_brkchars
.use_custom_word_point ())
1672 tracker
= &tracker_handle_brkchars
;
1675 complete_line (tracker_handle_completions
, *word
, line
, strlen (line
));
1676 tracker
= &tracker_handle_completions
;
1679 catch (const gdb_exception
&ex
)
1684 return tracker
->build_completion_result (*word
, *word
- line
, strlen (line
));
1688 /* Generate completions all at once. Does nothing if max_completions
1689 is 0. If max_completions is non-negative, this will collect at
1690 most max_completions strings.
1692 TEXT is the caller's idea of the "word" we are looking at.
1694 LINE_BUFFER is available to be looked at; it contains the entire
1697 POINT is the offset in that line of the cursor. You
1698 should pretend that the line ends at POINT. */
1701 complete_line (completion_tracker
&tracker
,
1702 const char *text
, const char *line_buffer
, int point
)
1704 if (max_completions
== 0)
1706 complete_line_internal (tracker
, text
, line_buffer
, point
,
1707 handle_completions
);
1710 /* Complete on command names. Used by "help". */
1713 command_completer (struct cmd_list_element
*ignore
,
1714 completion_tracker
&tracker
,
1715 const char *text
, const char *word
)
1717 complete_line_internal (tracker
, word
, text
,
1718 strlen (text
), handle_help
);
1721 /* The corresponding completer_handle_brkchars implementation. */
1724 command_completer_handle_brkchars (struct cmd_list_element
*ignore
,
1725 completion_tracker
&tracker
,
1726 const char *text
, const char *word
)
1728 set_rl_completer_word_break_characters
1729 (gdb_completer_command_word_break_characters
);
1732 /* Complete on signals. */
1735 signal_completer (struct cmd_list_element
*ignore
,
1736 completion_tracker
&tracker
,
1737 const char *text
, const char *word
)
1739 size_t len
= strlen (word
);
1741 const char *signame
;
1743 for (signum
= GDB_SIGNAL_FIRST
; signum
!= GDB_SIGNAL_LAST
; ++signum
)
1745 /* Can't handle this, so skip it. */
1746 if (signum
== GDB_SIGNAL_0
)
1749 signame
= gdb_signal_to_name ((enum gdb_signal
) signum
);
1751 /* Ignore the unknown signal case. */
1752 if (!signame
|| strcmp (signame
, "?") == 0)
1755 if (strncasecmp (signame
, word
, len
) == 0)
1756 tracker
.add_completion (make_unique_xstrdup (signame
));
1760 /* Bit-flags for selecting what the register and/or register-group
1761 completer should complete on. */
1763 enum reg_completer_target
1765 complete_register_names
= 0x1,
1766 complete_reggroup_names
= 0x2
1768 DEF_ENUM_FLAGS_TYPE (enum reg_completer_target
, reg_completer_targets
);
1770 /* Complete register names and/or reggroup names based on the value passed
1771 in TARGETS. At least one bit in TARGETS must be set. */
1774 reg_or_group_completer_1 (completion_tracker
&tracker
,
1775 const char *text
, const char *word
,
1776 reg_completer_targets targets
)
1778 size_t len
= strlen (word
);
1779 struct gdbarch
*gdbarch
;
1782 gdb_assert ((targets
& (complete_register_names
1783 | complete_reggroup_names
)) != 0);
1784 gdbarch
= get_current_arch ();
1786 if ((targets
& complete_register_names
) != 0)
1791 (name
= user_reg_map_regnum_to_name (gdbarch
, i
)) != NULL
;
1794 if (*name
!= '\0' && strncmp (word
, name
, len
) == 0)
1795 tracker
.add_completion (make_unique_xstrdup (name
));
1799 if ((targets
& complete_reggroup_names
) != 0)
1801 struct reggroup
*group
;
1803 for (group
= reggroup_next (gdbarch
, NULL
);
1805 group
= reggroup_next (gdbarch
, group
))
1807 name
= reggroup_name (group
);
1808 if (strncmp (word
, name
, len
) == 0)
1809 tracker
.add_completion (make_unique_xstrdup (name
));
1814 /* Perform completion on register and reggroup names. */
1817 reg_or_group_completer (struct cmd_list_element
*ignore
,
1818 completion_tracker
&tracker
,
1819 const char *text
, const char *word
)
1821 reg_or_group_completer_1 (tracker
, text
, word
,
1822 (complete_register_names
1823 | complete_reggroup_names
));
1826 /* Perform completion on reggroup names. */
1829 reggroup_completer (struct cmd_list_element
*ignore
,
1830 completion_tracker
&tracker
,
1831 const char *text
, const char *word
)
1833 reg_or_group_completer_1 (tracker
, text
, word
,
1834 complete_reggroup_names
);
1837 /* The default completer_handle_brkchars implementation. */
1840 default_completer_handle_brkchars (struct cmd_list_element
*ignore
,
1841 completion_tracker
&tracker
,
1842 const char *text
, const char *word
)
1844 set_rl_completer_word_break_characters
1845 (current_language
->la_word_break_characters ());
1848 /* See definition in completer.h. */
1850 completer_handle_brkchars_ftype
*
1851 completer_handle_brkchars_func_for_completer (completer_ftype
*fn
)
1853 if (fn
== filename_completer
)
1854 return filename_completer_handle_brkchars
;
1856 if (fn
== location_completer
)
1857 return location_completer_handle_brkchars
;
1859 if (fn
== command_completer
)
1860 return command_completer_handle_brkchars
;
1862 return default_completer_handle_brkchars
;
1865 /* Used as brkchars when we want to tell readline we have a custom
1866 word point. We do that by making our rl_completion_word_break_hook
1867 set RL_POINT to the desired word point, and return the character at
1868 the word break point as the break char. This is two bytes in order
1869 to fit one break character plus the terminating null. */
1870 static char gdb_custom_word_point_brkchars
[2];
1872 /* Since rl_basic_quote_characters is not completer-specific, we save
1873 its original value here, in order to be able to restore it in
1874 gdb_rl_attempted_completion_function. */
1875 static const char *gdb_org_rl_basic_quote_characters
= rl_basic_quote_characters
;
1877 /* Get the list of chars that are considered as word breaks
1878 for the current command. */
1881 gdb_completion_word_break_characters_throw ()
1883 /* New completion starting. Get rid of the previous tracker and
1885 delete current_completion
.tracker
;
1886 current_completion
.tracker
= new completion_tracker ();
1888 completion_tracker
&tracker
= *current_completion
.tracker
;
1890 complete_line_internal (tracker
, NULL
, rl_line_buffer
,
1891 rl_point
, handle_brkchars
);
1893 if (tracker
.use_custom_word_point ())
1895 gdb_assert (tracker
.custom_word_point () > 0);
1896 rl_point
= tracker
.custom_word_point () - 1;
1897 gdb_custom_word_point_brkchars
[0] = rl_line_buffer
[rl_point
];
1898 rl_completer_word_break_characters
= gdb_custom_word_point_brkchars
;
1899 rl_completer_quote_characters
= NULL
;
1901 /* Clear this too, so that if we're completing a quoted string,
1902 readline doesn't consider the quote character a delimiter.
1903 If we didn't do this, readline would auto-complete {b
1904 'fun<tab>} to {'b 'function()'}, i.e., add the terminating
1905 \', but, it wouldn't append the separator space either, which
1906 is not desirable. So instead we take care of appending the
1907 quote character to the LCD ourselves, in
1908 gdb_rl_attempted_completion_function. Since this global is
1909 not just completer-specific, we'll restore it back to the
1910 default in gdb_rl_attempted_completion_function. */
1911 rl_basic_quote_characters
= NULL
;
1914 return rl_completer_word_break_characters
;
1918 gdb_completion_word_break_characters ()
1920 /* New completion starting. */
1921 current_completion
.aborted
= false;
1925 return gdb_completion_word_break_characters_throw ();
1927 catch (const gdb_exception
&ex
)
1929 /* Set this to that gdb_rl_attempted_completion_function knows
1931 current_completion
.aborted
= true;
1937 /* See completer.h. */
1940 completion_find_completion_word (completion_tracker
&tracker
, const char *text
,
1943 size_t point
= strlen (text
);
1945 complete_line_internal (tracker
, NULL
, text
, point
, handle_brkchars
);
1947 if (tracker
.use_custom_word_point ())
1949 gdb_assert (tracker
.custom_word_point () > 0);
1950 *quote_char
= tracker
.quote_char ();
1951 return text
+ tracker
.custom_word_point ();
1954 gdb_rl_completion_word_info info
;
1956 info
.word_break_characters
= rl_completer_word_break_characters
;
1957 info
.quote_characters
= gdb_completer_quote_characters
;
1958 info
.basic_quote_characters
= rl_basic_quote_characters
;
1960 return gdb_rl_find_completion_word (&info
, quote_char
, NULL
, text
);
1963 /* See completer.h. */
1966 completion_tracker::recompute_lowest_common_denominator
1967 (gdb::unique_xmalloc_ptr
<char> &&new_match_up
)
1969 if (m_lowest_common_denominator
== NULL
)
1971 /* We don't have a lowest common denominator yet, so simply take
1972 the whole NEW_MATCH_UP as being it. */
1973 m_lowest_common_denominator
= new_match_up
.release ();
1974 m_lowest_common_denominator_unique
= true;
1978 /* Find the common denominator between the currently-known
1979 lowest common denominator and NEW_MATCH_UP. That becomes the
1980 new lowest common denominator. */
1982 const char *new_match
= new_match_up
.get ();
1985 (new_match
[i
] != '\0'
1986 && new_match
[i
] == m_lowest_common_denominator
[i
]);
1989 if (m_lowest_common_denominator
[i
] != new_match
[i
])
1991 m_lowest_common_denominator
[i
] = '\0';
1992 m_lowest_common_denominator_unique
= false;
1997 /* See completer.h. */
2000 completion_tracker::advance_custom_word_point_by (int len
)
2002 m_custom_word_point
+= len
;
2005 /* Build a new C string that is a copy of LCD with the whitespace of
2006 ORIG/ORIG_LEN preserved.
2008 Say the user is completing a symbol name, with spaces, like:
2012 and the resulting completion match is:
2016 we want to end up with an input line like:
2019 ^^^^^^^ => text from LCD [1], whitespace from ORIG preserved.
2020 ^^ => new text from LCD
2022 [1] - We must take characters from the LCD instead of the original
2023 text, since some completions want to change upper/lowercase. E.g.:
2029 "handle SIG[QUIT|etc.]"
2033 expand_preserving_ws (const char *orig
, size_t orig_len
,
2036 const char *p_orig
= orig
;
2037 const char *orig_end
= orig
+ orig_len
;
2038 const char *p_lcd
= lcd
;
2041 while (p_orig
< orig_end
)
2045 while (p_orig
< orig_end
&& *p_orig
== ' ')
2047 p_lcd
= skip_spaces (p_lcd
);
2051 /* Take characters from the LCD instead of the original
2052 text, since some completions change upper/lowercase.
2056 "handle SIG[QUIT|etc.]"
2064 while (*p_lcd
!= '\0')
2067 return xstrdup (res
.c_str ());
2070 /* See completer.h. */
2073 completion_tracker::build_completion_result (const char *text
,
2076 completion_list
&list
= m_entries_vec
; /* The completions. */
2081 /* +1 for the LCD, and +1 for NULL termination. */
2082 char **match_list
= XNEWVEC (char *, 1 + list
.size () + 1);
2084 /* Build replacement word, based on the LCD. */
2087 = expand_preserving_ws (text
, end
- start
,
2088 m_lowest_common_denominator
);
2090 if (m_lowest_common_denominator_unique
)
2092 /* We don't rely on readline appending the quote char as
2093 delimiter as then readline wouldn't append the ' ' after the
2095 char buf
[2] = { (char) quote_char () };
2097 match_list
[0] = reconcat (match_list
[0], match_list
[0],
2098 buf
, (char *) NULL
);
2099 match_list
[1] = NULL
;
2101 /* If the tracker wants to, or we already have a space at the
2102 end of the match, tell readline to skip appending
2104 bool completion_suppress_append
2105 = (suppress_append_ws ()
2106 || match_list
[0][strlen (match_list
[0]) - 1] == ' ');
2108 return completion_result (match_list
, 1, completion_suppress_append
);
2114 for (ix
= 0; ix
< list
.size (); ++ix
)
2115 match_list
[ix
+ 1] = list
[ix
].release ();
2116 match_list
[ix
+ 1] = NULL
;
2118 return completion_result (match_list
, list
.size (), false);
2122 /* See completer.h */
2124 completion_result::completion_result ()
2125 : match_list (NULL
), number_matches (0),
2126 completion_suppress_append (false)
2129 /* See completer.h */
2131 completion_result::completion_result (char **match_list_
,
2132 size_t number_matches_
,
2133 bool completion_suppress_append_
)
2134 : match_list (match_list_
),
2135 number_matches (number_matches_
),
2136 completion_suppress_append (completion_suppress_append_
)
2139 /* See completer.h */
2141 completion_result::~completion_result ()
2143 reset_match_list ();
2146 /* See completer.h */
2148 completion_result::completion_result (completion_result
&&rhs
)
2153 reset_match_list ();
2154 match_list
= rhs
.match_list
;
2155 rhs
.match_list
= NULL
;
2156 number_matches
= rhs
.number_matches
;
2157 rhs
.number_matches
= 0;
2160 /* See completer.h */
2163 completion_result::release_match_list ()
2165 char **ret
= match_list
;
2170 /* See completer.h */
2173 completion_result::sort_match_list ()
2175 if (number_matches
> 1)
2177 /* Element 0 is special (it's the common prefix), leave it
2179 std::sort (&match_list
[1],
2180 &match_list
[number_matches
+ 1],
2185 /* See completer.h */
2188 completion_result::reset_match_list ()
2190 if (match_list
!= NULL
)
2192 for (char **p
= match_list
; *p
!= NULL
; p
++)
2199 /* Helper for gdb_rl_attempted_completion_function, which does most of
2200 the work. This is called by readline to build the match list array
2201 and to determine the lowest common denominator. The real matches
2202 list starts at match[1], while match[0] is the slot holding
2203 readline's idea of the lowest common denominator of all matches,
2204 which is what readline replaces the completion "word" with.
2206 TEXT is the caller's idea of the "word" we are looking at, as
2207 computed in the handle_brkchars phase.
2209 START is the offset from RL_LINE_BUFFER where TEXT starts. END is
2210 the offset from RL_LINE_BUFFER where TEXT ends (i.e., where
2213 You should thus pretend that the line ends at END (relative to
2216 RL_LINE_BUFFER contains the entire text of the line. RL_POINT is
2217 the offset in that line of the cursor. You should pretend that the
2220 Returns NULL if there are no completions. */
2223 gdb_rl_attempted_completion_function_throw (const char *text
, int start
, int end
)
2225 /* Completers that provide a custom word point in the
2226 handle_brkchars phase also compute their completions then.
2227 Completers that leave the completion word handling to readline
2228 must be called twice. If rl_point (i.e., END) is at column 0,
2229 then readline skips the handle_brkchars phase, and so we create a
2230 tracker now in that case too. */
2231 if (end
== 0 || !current_completion
.tracker
->use_custom_word_point ())
2233 delete current_completion
.tracker
;
2234 current_completion
.tracker
= new completion_tracker ();
2236 complete_line (*current_completion
.tracker
, text
,
2237 rl_line_buffer
, rl_point
);
2240 completion_tracker
&tracker
= *current_completion
.tracker
;
2242 completion_result result
2243 = tracker
.build_completion_result (text
, start
, end
);
2245 rl_completion_suppress_append
= result
.completion_suppress_append
;
2246 return result
.release_match_list ();
2249 /* Function installed as "rl_attempted_completion_function" readline
2250 hook. Wrapper around gdb_rl_attempted_completion_function_throw
2251 that catches C++ exceptions, which can't cross readline. */
2254 gdb_rl_attempted_completion_function (const char *text
, int start
, int end
)
2256 /* Restore globals that might have been tweaked in
2257 gdb_completion_word_break_characters. */
2258 rl_basic_quote_characters
= gdb_org_rl_basic_quote_characters
;
2260 /* If we end up returning NULL, either on error, or simple because
2261 there are no matches, inhibit readline's default filename
2263 rl_attempted_completion_over
= 1;
2265 /* If the handle_brkchars phase was aborted, don't try
2267 if (current_completion
.aborted
)
2272 return gdb_rl_attempted_completion_function_throw (text
, start
, end
);
2274 catch (const gdb_exception
&ex
)
2281 /* Skip over the possibly quoted word STR (as defined by the quote
2282 characters QUOTECHARS and the word break characters BREAKCHARS).
2283 Returns pointer to the location after the "word". If either
2284 QUOTECHARS or BREAKCHARS is NULL, use the same values used by the
2288 skip_quoted_chars (const char *str
, const char *quotechars
,
2289 const char *breakchars
)
2291 char quote_char
= '\0';
2294 if (quotechars
== NULL
)
2295 quotechars
= gdb_completer_quote_characters
;
2297 if (breakchars
== NULL
)
2298 breakchars
= current_language
->la_word_break_characters();
2300 for (scan
= str
; *scan
!= '\0'; scan
++)
2302 if (quote_char
!= '\0')
2304 /* Ignore everything until the matching close quote char. */
2305 if (*scan
== quote_char
)
2307 /* Found matching close quote. */
2312 else if (strchr (quotechars
, *scan
))
2314 /* Found start of a quoted string. */
2317 else if (strchr (breakchars
, *scan
))
2326 /* Skip over the possibly quoted word STR (as defined by the quote
2327 characters and word break characters used by the completer).
2328 Returns pointer to the location after the "word". */
2331 skip_quoted (const char *str
)
2333 return skip_quoted_chars (str
, NULL
, NULL
);
2336 /* Return a message indicating that the maximum number of completions
2337 has been reached and that there may be more. */
2340 get_max_completions_reached_message (void)
2342 return _("*** List may be truncated, max-completions reached. ***");
2345 /* GDB replacement for rl_display_match_list.
2346 Readline doesn't provide a clean interface for TUI(curses).
2347 A hack previously used was to send readline's rl_outstream through a pipe
2348 and read it from the event loop. Bleah. IWBN if readline abstracted
2349 away all the necessary bits, and this is what this code does. It
2350 replicates the parts of readline we need and then adds an abstraction
2351 layer, currently implemented as struct match_list_displayer, so that both
2352 CLI and TUI can use it. We copy all this readline code to minimize
2353 GDB-specific mods to readline. Once this code performs as desired then
2354 we can submit it to the readline maintainers.
2356 N.B. A lot of the code is the way it is in order to minimize differences
2357 from readline's copy. */
2359 /* Not supported here. */
2360 #undef VISIBLE_STATS
2362 #if defined (HANDLE_MULTIBYTE)
2363 #define MB_INVALIDCH(x) ((x) == (size_t)-1 || (x) == (size_t)-2)
2364 #define MB_NULLWCH(x) ((x) == 0)
2367 #define ELLIPSIS_LEN 3
2369 /* gdb version of readline/complete.c:get_y_or_n.
2370 'y' -> returns 1, and 'n' -> returns 0.
2371 Also supported: space == 'y', RUBOUT == 'n', ctrl-g == start over.
2372 If FOR_PAGER is non-zero, then also supported are:
2373 NEWLINE or RETURN -> returns 2, and 'q' -> returns 0. */
2376 gdb_get_y_or_n (int for_pager
, const struct match_list_displayer
*displayer
)
2382 RL_SETSTATE (RL_STATE_MOREINPUT
);
2383 c
= displayer
->read_key (displayer
);
2384 RL_UNSETSTATE (RL_STATE_MOREINPUT
);
2386 if (c
== 'y' || c
== 'Y' || c
== ' ')
2388 if (c
== 'n' || c
== 'N' || c
== RUBOUT
)
2390 if (c
== ABORT_CHAR
|| c
< 0)
2392 /* Readline doesn't erase_entire_line here, but without it the
2393 --More-- prompt isn't erased and neither is the text entered
2394 thus far redisplayed. */
2395 displayer
->erase_entire_line (displayer
);
2396 /* Note: The arguments to rl_abort are ignored. */
2399 if (for_pager
&& (c
== NEWLINE
|| c
== RETURN
))
2401 if (for_pager
&& (c
== 'q' || c
== 'Q'))
2403 displayer
->beep (displayer
);
2407 /* Pager function for tab-completion.
2408 This is based on readline/complete.c:_rl_internal_pager.
2409 LINES is the number of lines of output displayed thus far.
2411 -1 -> user pressed 'n' or equivalent,
2412 0 -> user pressed 'y' or equivalent,
2413 N -> user pressed NEWLINE or equivalent and N is LINES - 1. */
2416 gdb_display_match_list_pager (int lines
,
2417 const struct match_list_displayer
*displayer
)
2421 displayer
->puts (displayer
, "--More--");
2422 displayer
->flush (displayer
);
2423 i
= gdb_get_y_or_n (1, displayer
);
2424 displayer
->erase_entire_line (displayer
);
2433 /* Return non-zero if FILENAME is a directory.
2434 Based on readline/complete.c:path_isdir. */
2437 gdb_path_isdir (const char *filename
)
2441 return (stat (filename
, &finfo
) == 0 && S_ISDIR (finfo
.st_mode
));
2444 /* Return the portion of PATHNAME that should be output when listing
2445 possible completions. If we are hacking filename completion, we
2446 are only interested in the basename, the portion following the
2447 final slash. Otherwise, we return what we were passed. Since
2448 printing empty strings is not very informative, if we're doing
2449 filename completion, and the basename is the empty string, we look
2450 for the previous slash and return the portion following that. If
2451 there's no previous slash, we just return what we were passed.
2453 Based on readline/complete.c:printable_part. */
2456 gdb_printable_part (char *pathname
)
2460 if (rl_filename_completion_desired
== 0) /* don't need to do anything */
2463 temp
= strrchr (pathname
, '/');
2464 #if defined (__MSDOS__)
2465 if (temp
== 0 && ISALPHA ((unsigned char)pathname
[0]) && pathname
[1] == ':')
2466 temp
= pathname
+ 1;
2469 if (temp
== 0 || *temp
== '\0')
2471 /* If the basename is NULL, we might have a pathname like '/usr/src/'.
2472 Look for a previous slash and, if one is found, return the portion
2473 following that slash. If there's no previous slash, just return the
2474 pathname we were passed. */
2475 else if (temp
[1] == '\0')
2477 for (x
= temp
- 1; x
> pathname
; x
--)
2480 return ((*x
== '/') ? x
+ 1 : pathname
);
2486 /* Compute width of STRING when displayed on screen by print_filename.
2487 Based on readline/complete.c:fnwidth. */
2490 gdb_fnwidth (const char *string
)
2493 #if defined (HANDLE_MULTIBYTE)
2499 left
= strlen (string
) + 1;
2500 memset (&ps
, 0, sizeof (mbstate_t));
2506 if (CTRL_CHAR (string
[pos
]) || string
[pos
] == RUBOUT
)
2513 #if defined (HANDLE_MULTIBYTE)
2514 clen
= mbrtowc (&wc
, string
+ pos
, left
- pos
, &ps
);
2515 if (MB_INVALIDCH (clen
))
2519 memset (&ps
, 0, sizeof (mbstate_t));
2521 else if (MB_NULLWCH (clen
))
2527 width
+= (w
>= 0) ? w
: 1;
2539 /* Print TO_PRINT, one matching completion.
2540 PREFIX_BYTES is number of common prefix bytes.
2541 Based on readline/complete.c:fnprint. */
2544 gdb_fnprint (const char *to_print
, int prefix_bytes
,
2545 const struct match_list_displayer
*displayer
)
2549 #if defined (HANDLE_MULTIBYTE)
2556 end
= to_print
+ strlen (to_print
) + 1;
2557 memset (&ps
, 0, sizeof (mbstate_t));
2562 /* Don't print only the ellipsis if the common prefix is one of the
2563 possible completions */
2564 if (to_print
[prefix_bytes
] == '\0')
2571 ellipsis
= (to_print
[prefix_bytes
] == '.') ? '_' : '.';
2572 for (w
= 0; w
< ELLIPSIS_LEN
; w
++)
2573 displayer
->putch (displayer
, ellipsis
);
2574 printed_len
= ELLIPSIS_LEN
;
2577 s
= to_print
+ prefix_bytes
;
2582 displayer
->putch (displayer
, '^');
2583 displayer
->putch (displayer
, UNCTRL (*s
));
2586 #if defined (HANDLE_MULTIBYTE)
2587 memset (&ps
, 0, sizeof (mbstate_t));
2590 else if (*s
== RUBOUT
)
2592 displayer
->putch (displayer
, '^');
2593 displayer
->putch (displayer
, '?');
2596 #if defined (HANDLE_MULTIBYTE)
2597 memset (&ps
, 0, sizeof (mbstate_t));
2602 #if defined (HANDLE_MULTIBYTE)
2603 tlen
= mbrtowc (&wc
, s
, end
- s
, &ps
);
2604 if (MB_INVALIDCH (tlen
))
2608 memset (&ps
, 0, sizeof (mbstate_t));
2610 else if (MB_NULLWCH (tlen
))
2615 width
= (w
>= 0) ? w
: 1;
2617 for (w
= 0; w
< tlen
; ++w
)
2618 displayer
->putch (displayer
, s
[w
]);
2620 printed_len
+= width
;
2622 displayer
->putch (displayer
, *s
);
2632 /* Output TO_PRINT to rl_outstream. If VISIBLE_STATS is defined and we
2633 are using it, check for and output a single character for `special'
2634 filenames. Return the number of characters we output.
2635 Based on readline/complete.c:print_filename. */
2638 gdb_print_filename (char *to_print
, char *full_pathname
, int prefix_bytes
,
2639 const struct match_list_displayer
*displayer
)
2641 int printed_len
, extension_char
, slen
, tlen
;
2642 char *s
, c
, *new_full_pathname
;
2644 extern int _rl_complete_mark_directories
;
2647 printed_len
= gdb_fnprint (to_print
, prefix_bytes
, displayer
);
2649 #if defined (VISIBLE_STATS)
2650 if (rl_filename_completion_desired
&& (rl_visible_stats
|| _rl_complete_mark_directories
))
2652 if (rl_filename_completion_desired
&& _rl_complete_mark_directories
)
2655 /* If to_print != full_pathname, to_print is the basename of the
2656 path passed. In this case, we try to expand the directory
2657 name before checking for the stat character. */
2658 if (to_print
!= full_pathname
)
2660 /* Terminate the directory name. */
2662 to_print
[-1] = '\0';
2664 /* If setting the last slash in full_pathname to a NUL results in
2665 full_pathname being the empty string, we are trying to complete
2666 files in the root directory. If we pass a null string to the
2667 bash directory completion hook, for example, it will expand it
2668 to the current directory. We just want the `/'. */
2669 if (full_pathname
== 0 || *full_pathname
== 0)
2671 else if (full_pathname
[0] != '/')
2673 else if (full_pathname
[1] == 0)
2674 dn
= "//"; /* restore trailing slash to `//' */
2675 else if (full_pathname
[1] == '/' && full_pathname
[2] == 0)
2676 dn
= "/"; /* don't turn /// into // */
2679 s
= tilde_expand (dn
);
2680 if (rl_directory_completion_hook
)
2681 (*rl_directory_completion_hook
) (&s
);
2684 tlen
= strlen (to_print
);
2685 new_full_pathname
= (char *)xmalloc (slen
+ tlen
+ 2);
2686 strcpy (new_full_pathname
, s
);
2687 if (s
[slen
- 1] == '/')
2690 new_full_pathname
[slen
] = '/';
2691 new_full_pathname
[slen
] = '/';
2692 strcpy (new_full_pathname
+ slen
+ 1, to_print
);
2694 #if defined (VISIBLE_STATS)
2695 if (rl_visible_stats
)
2696 extension_char
= stat_char (new_full_pathname
);
2699 if (gdb_path_isdir (new_full_pathname
))
2700 extension_char
= '/';
2702 xfree (new_full_pathname
);
2707 s
= tilde_expand (full_pathname
);
2708 #if defined (VISIBLE_STATS)
2709 if (rl_visible_stats
)
2710 extension_char
= stat_char (s
);
2713 if (gdb_path_isdir (s
))
2714 extension_char
= '/';
2720 displayer
->putch (displayer
, extension_char
);
2728 /* GDB version of readline/complete.c:complete_get_screenwidth. */
2731 gdb_complete_get_screenwidth (const struct match_list_displayer
*displayer
)
2733 /* Readline has other stuff here which it's not clear we need. */
2734 return displayer
->width
;
2737 extern int _rl_completion_prefix_display_length
;
2738 extern int _rl_print_completions_horizontally
;
2740 EXTERN_C
int _rl_qsort_string_compare (const void *, const void *);
2741 typedef int QSFUNC (const void *, const void *);
2743 /* GDB version of readline/complete.c:rl_display_match_list.
2744 See gdb_display_match_list for a description of MATCHES, LEN, MAX.
2745 Returns non-zero if all matches are displayed. */
2748 gdb_display_match_list_1 (char **matches
, int len
, int max
,
2749 const struct match_list_displayer
*displayer
)
2751 int count
, limit
, printed_len
, lines
, cols
;
2752 int i
, j
, k
, l
, common_length
, sind
;
2754 int page_completions
= displayer
->height
!= INT_MAX
&& pagination_enabled
;
2756 /* Find the length of the prefix common to all items: length as displayed
2757 characters (common_length) and as a byte index into the matches (sind) */
2758 common_length
= sind
= 0;
2759 if (_rl_completion_prefix_display_length
> 0)
2761 t
= gdb_printable_part (matches
[0]);
2762 temp
= strrchr (t
, '/');
2763 common_length
= temp
? gdb_fnwidth (temp
) : gdb_fnwidth (t
);
2764 sind
= temp
? strlen (temp
) : strlen (t
);
2766 if (common_length
> _rl_completion_prefix_display_length
&& common_length
> ELLIPSIS_LEN
)
2767 max
-= common_length
- ELLIPSIS_LEN
;
2769 common_length
= sind
= 0;
2772 /* How many items of MAX length can we fit in the screen window? */
2773 cols
= gdb_complete_get_screenwidth (displayer
);
2776 if (limit
!= 1 && (limit
* max
== cols
))
2779 /* If cols == 0, limit will end up -1 */
2780 if (cols
< displayer
->width
&& limit
< 0)
2783 /* Avoid a possible floating exception. If max > cols,
2784 limit will be 0 and a divide-by-zero fault will result. */
2788 /* How many iterations of the printing loop? */
2789 count
= (len
+ (limit
- 1)) / limit
;
2791 /* Watch out for special case. If LEN is less than LIMIT, then
2792 just do the inner printing loop.
2793 0 < len <= limit implies count = 1. */
2795 /* Sort the items if they are not already sorted. */
2796 if (rl_ignore_completion_duplicates
== 0 && rl_sort_completion_matches
)
2797 qsort (matches
+ 1, len
, sizeof (char *), (QSFUNC
*)_rl_qsort_string_compare
);
2799 displayer
->crlf (displayer
);
2802 if (_rl_print_completions_horizontally
== 0)
2804 /* Print the sorted items, up-and-down alphabetically, like ls. */
2805 for (i
= 1; i
<= count
; i
++)
2807 for (j
= 0, l
= i
; j
< limit
; j
++)
2809 if (l
> len
|| matches
[l
] == 0)
2813 temp
= gdb_printable_part (matches
[l
]);
2814 printed_len
= gdb_print_filename (temp
, matches
[l
], sind
,
2818 for (k
= 0; k
< max
- printed_len
; k
++)
2819 displayer
->putch (displayer
, ' ');
2823 displayer
->crlf (displayer
);
2825 if (page_completions
&& lines
>= (displayer
->height
- 1) && i
< count
)
2827 lines
= gdb_display_match_list_pager (lines
, displayer
);
2835 /* Print the sorted items, across alphabetically, like ls -x. */
2836 for (i
= 1; matches
[i
]; i
++)
2838 temp
= gdb_printable_part (matches
[i
]);
2839 printed_len
= gdb_print_filename (temp
, matches
[i
], sind
, displayer
);
2840 /* Have we reached the end of this line? */
2843 if (i
&& (limit
> 1) && (i
% limit
) == 0)
2845 displayer
->crlf (displayer
);
2847 if (page_completions
&& lines
>= displayer
->height
- 1)
2849 lines
= gdb_display_match_list_pager (lines
, displayer
);
2855 for (k
= 0; k
< max
- printed_len
; k
++)
2856 displayer
->putch (displayer
, ' ');
2859 displayer
->crlf (displayer
);
2865 /* Utility for displaying completion list matches, used by both CLI and TUI.
2867 MATCHES is the list of strings, in argv format, LEN is the number of
2868 strings in MATCHES, and MAX is the length of the longest string in
2872 gdb_display_match_list (char **matches
, int len
, int max
,
2873 const struct match_list_displayer
*displayer
)
2875 /* Readline will never call this if complete_line returned NULL. */
2876 gdb_assert (max_completions
!= 0);
2878 /* complete_line will never return more than this. */
2879 if (max_completions
> 0)
2880 gdb_assert (len
<= max_completions
);
2882 if (rl_completion_query_items
> 0 && len
>= rl_completion_query_items
)
2886 /* We can't use *query here because they wait for <RET> which is
2887 wrong here. This follows the readline version as closely as possible
2888 for compatibility's sake. See readline/complete.c. */
2890 displayer
->crlf (displayer
);
2892 xsnprintf (msg
, sizeof (msg
),
2893 "Display all %d possibilities? (y or n)", len
);
2894 displayer
->puts (displayer
, msg
);
2895 displayer
->flush (displayer
);
2897 if (gdb_get_y_or_n (0, displayer
) == 0)
2899 displayer
->crlf (displayer
);
2904 if (gdb_display_match_list_1 (matches
, len
, max
, displayer
))
2906 /* Note: MAX_COMPLETIONS may be -1 or zero, but LEN is always > 0. */
2907 if (len
== max_completions
)
2909 /* The maximum number of completions has been reached. Warn the user
2910 that there may be more. */
2911 const char *message
= get_max_completions_reached_message ();
2913 displayer
->puts (displayer
, message
);
2914 displayer
->crlf (displayer
);
2920 _initialize_completer (void)
2922 add_setshow_zuinteger_unlimited_cmd ("max-completions", no_class
,
2923 &max_completions
, _("\
2924 Set maximum number of completion candidates."), _("\
2925 Show maximum number of completion candidates."), _("\
2926 Use this to limit the number of candidates considered\n\
2927 during completion. Specifying \"unlimited\" or -1\n\
2928 disables limiting. Note that setting either no limit or\n\
2929 a very large limit can make completion slow."),
2930 NULL
, NULL
, &setlist
, &showlist
);