1 /* Line completion stuff for GDB, the GNU debugger.
2 Copyright (C) 2000-2020 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 "gdbsupport/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 /* See completer.h. */
50 class completion_tracker::completion_hash_entry
54 completion_hash_entry (gdb::unique_xmalloc_ptr
<char> name
,
55 gdb::unique_xmalloc_ptr
<char> lcd
)
56 : m_name (std::move (name
)),
57 m_lcd (std::move (lcd
))
62 /* Returns a pointer to the lowest common denominator string. This
63 string will only be valid while this hash entry is still valid as the
64 string continues to be owned by this hash entry and will be released
65 when this entry is deleted. */
66 char *get_lcd () const
71 /* Get, and release the name field from this hash entry. This can only
72 be called once, after which the name field is no longer valid. This
73 should be used to pass ownership of the name to someone else. */
76 return m_name
.release ();
79 /* Return true of the name in this hash entry is STR. */
80 bool is_name_eq (const char *str
) const
82 return strcmp (m_name
.get (), str
) == 0;
85 /* Return the hash value based on the name of the entry. */
86 hashval_t
hash_name () const
88 return htab_hash_string (m_name
.get ());
91 /* A static function that can be passed to the htab hash system to be
92 used as a callback that deletes an item from the hash. */
93 static void deleter (void *arg
)
95 completion_hash_entry
*entry
= (completion_hash_entry
*) arg
;
101 /* The symbol name stored in this hash entry. */
102 gdb::unique_xmalloc_ptr
<char> m_name
;
104 /* The lowest common denominator string computed for this hash entry. */
105 gdb::unique_xmalloc_ptr
<char> m_lcd
;
108 /* Misc state that needs to be tracked across several different
109 readline completer entry point calls, all related to a single
110 completion invocation. */
112 struct gdb_completer_state
114 /* The current completion's completion tracker. This is a global
115 because a tracker can be shared between the handle_brkchars and
116 handle_completion phases, which involves different readline
118 completion_tracker
*tracker
= NULL
;
120 /* Whether the current completion was aborted. */
121 bool aborted
= false;
124 /* The current completion state. */
125 static gdb_completer_state current_completion
;
127 /* An enumeration of the various things a user might attempt to
128 complete for a location. If you change this, remember to update
129 the explicit_options array below too. */
131 enum explicit_location_match_type
133 /* The filename of a source file. */
136 /* The name of a function or method. */
139 /* The fully-qualified name of a function or method. */
145 /* The name of a label. */
149 /* Prototypes for local functions. */
151 /* readline uses the word breaks for two things:
152 (1) In figuring out where to point the TEXT parameter to the
153 rl_completion_entry_function. Since we don't use TEXT for much,
154 it doesn't matter a lot what the word breaks are for this purpose,
155 but it does affect how much stuff M-? lists.
156 (2) If one of the matches contains a word break character, readline
157 will quote it. That's why we switch between
158 current_language->word_break_characters () and
159 gdb_completer_command_word_break_characters. I'm not sure when
160 we need this behavior (perhaps for funky characters in C++
163 /* Variables which are necessary for fancy command line editing. */
165 /* When completing on command names, we remove '-' and '.' from the list of
166 word break characters, since we use it in command names. If the
167 readline library sees one in any of the current completion strings,
168 it thinks that the string needs to be quoted and automatically
169 supplies a leading quote. */
170 static const char gdb_completer_command_word_break_characters
[] =
171 " \t\n!@#$%^&*()+=|~`}{[]\"';:?/><,";
173 /* When completing on file names, we remove from the list of word
174 break characters any characters that are commonly used in file
175 names, such as '-', '+', '~', etc. Otherwise, readline displays
176 incorrect completion candidates. */
177 /* MS-DOS and MS-Windows use colon as part of the drive spec, and most
178 programs support @foo style response files. */
179 static const char gdb_completer_file_name_break_characters
[] =
180 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
186 /* Characters that can be used to quote completion strings. Note that
187 we can't include '"' because the gdb C parser treats such quoted
188 sequences as strings. */
189 static const char gdb_completer_quote_characters
[] = "'";
191 /* Accessor for some completer data that may interest other files. */
194 get_gdb_completer_quote_characters (void)
196 return gdb_completer_quote_characters
;
199 /* This can be used for functions which don't want to complete on
200 symbols but don't want to complete on anything else either. */
203 noop_completer (struct cmd_list_element
*ignore
,
204 completion_tracker
&tracker
,
205 const char *text
, const char *prefix
)
209 /* Complete on filenames. */
212 filename_completer (struct cmd_list_element
*ignore
,
213 completion_tracker
&tracker
,
214 const char *text
, const char *word
)
221 gdb::unique_xmalloc_ptr
<char> p_rl
222 (rl_filename_completion_function (text
, subsequent_name
));
225 /* We need to set subsequent_name to a non-zero value before the
226 continue line below, because otherwise, if the first file
227 seen by GDB is a backup file whose name ends in a `~', we
228 will loop indefinitely. */
230 /* Like emacs, don't complete on old versions. Especially
231 useful in the "source" command. */
232 const char *p
= p_rl
.get ();
233 if (p
[strlen (p
) - 1] == '~')
236 tracker
.add_completion
237 (make_completion_match_str (std::move (p_rl
), text
, word
));
240 /* There is no way to do this just long enough to affect quote
241 inserting without also affecting the next completion. This
242 should be fixed in readline. FIXME. */
243 /* Ensure that readline does the right thing
244 with respect to inserting quotes. */
245 rl_completer_word_break_characters
= "";
249 /* The corresponding completer_handle_brkchars
253 filename_completer_handle_brkchars (struct cmd_list_element
*ignore
,
254 completion_tracker
&tracker
,
255 const char *text
, const char *word
)
257 set_rl_completer_word_break_characters
258 (gdb_completer_file_name_break_characters
);
261 /* Possible values for the found_quote flags word used by the completion
262 functions. It says what kind of (shell-like) quoting we found anywhere
264 #define RL_QF_SINGLE_QUOTE 0x01
265 #define RL_QF_DOUBLE_QUOTE 0x02
266 #define RL_QF_BACKSLASH 0x04
267 #define RL_QF_OTHER_QUOTE 0x08
269 /* Find the bounds of the current word for completion purposes, and
270 return a pointer to the end of the word. This mimics (and is a
271 modified version of) readline's _rl_find_completion_word internal
274 This function skips quoted substrings (characters between matched
275 pairs of characters in rl_completer_quote_characters). We try to
276 find an unclosed quoted substring on which to do matching. If one
277 is not found, we use the word break characters to find the
278 boundaries of the current word. QC, if non-null, is set to the
279 opening quote character if we found an unclosed quoted substring,
280 '\0' otherwise. DP, if non-null, is set to the value of the
281 delimiter character that caused a word break. */
283 struct gdb_rl_completion_word_info
285 const char *word_break_characters
;
286 const char *quote_characters
;
287 const char *basic_quote_characters
;
291 gdb_rl_find_completion_word (struct gdb_rl_completion_word_info
*info
,
293 const char *line_buffer
)
295 int scan
, end
, found_quote
, delimiter
, pass_next
, isbrk
;
297 const char *brkchars
;
298 int point
= strlen (line_buffer
);
300 /* The algorithm below does '--point'. Avoid buffer underflow with
312 found_quote
= delimiter
= 0;
315 brkchars
= info
->word_break_characters
;
317 if (info
->quote_characters
!= NULL
)
319 /* We have a list of characters which can be used in pairs to
320 quote substrings for the completer. Try to find the start of
321 an unclosed quoted substring. */
322 /* FOUND_QUOTE is set so we know what kind of quotes we
324 for (scan
= pass_next
= 0;
334 /* Shell-like semantics for single quotes -- don't allow
335 backslash to quote anything in single quotes, especially
336 not the closing quote. If you don't like this, take out
337 the check on the value of quote_char. */
338 if (quote_char
!= '\'' && line_buffer
[scan
] == '\\')
341 found_quote
|= RL_QF_BACKSLASH
;
345 if (quote_char
!= '\0')
347 /* Ignore everything until the matching close quote
349 if (line_buffer
[scan
] == quote_char
)
351 /* Found matching close. Abandon this
357 else if (strchr (info
->quote_characters
, line_buffer
[scan
]))
359 /* Found start of a quoted substring. */
360 quote_char
= line_buffer
[scan
];
362 /* Shell-like quoting conventions. */
363 if (quote_char
== '\'')
364 found_quote
|= RL_QF_SINGLE_QUOTE
;
365 else if (quote_char
== '"')
366 found_quote
|= RL_QF_DOUBLE_QUOTE
;
368 found_quote
|= RL_QF_OTHER_QUOTE
;
373 if (point
== end
&& quote_char
== '\0')
375 /* We didn't find an unclosed quoted substring upon which to do
376 completion, so use the word break characters to find the
377 substring on which to complete. */
380 scan
= line_buffer
[point
];
382 if (strchr (brkchars
, scan
) != 0)
387 /* If we are at an unquoted word break, then advance past it. */
388 scan
= line_buffer
[point
];
392 isbrk
= strchr (brkchars
, scan
) != 0;
396 /* If the character that caused the word break was a quoting
397 character, then remember it as the delimiter. */
398 if (info
->basic_quote_characters
399 && strchr (info
->basic_quote_characters
, scan
)
400 && (end
- point
) > 1)
412 return line_buffer
+ point
;
415 /* Find the completion word point for TEXT, emulating the algorithm
416 readline uses to find the word point, using WORD_BREAK_CHARACTERS
417 as word break characters. */
420 advance_to_completion_word (completion_tracker
&tracker
,
421 const char *word_break_characters
,
424 gdb_rl_completion_word_info info
;
426 info
.word_break_characters
= word_break_characters
;
427 info
.quote_characters
= gdb_completer_quote_characters
;
428 info
.basic_quote_characters
= rl_basic_quote_characters
;
432 = gdb_rl_find_completion_word (&info
, NULL
, &delimiter
, text
);
434 tracker
.advance_custom_word_point_by (start
- text
);
438 tracker
.set_quote_char (delimiter
);
439 tracker
.set_suppress_append_ws (true);
445 /* See completer.h. */
448 advance_to_expression_complete_word_point (completion_tracker
&tracker
,
451 const char *brk_chars
= current_language
->word_break_characters ();
452 return advance_to_completion_word (tracker
, brk_chars
, text
);
455 /* See completer.h. */
458 advance_to_filename_complete_word_point (completion_tracker
&tracker
,
461 const char *brk_chars
= gdb_completer_file_name_break_characters
;
462 return advance_to_completion_word (tracker
, brk_chars
, text
);
465 /* See completer.h. */
468 completion_tracker::completes_to_completion_word (const char *word
)
470 recompute_lowest_common_denominator ();
471 if (m_lowest_common_denominator_unique
)
473 const char *lcd
= m_lowest_common_denominator
;
475 if (strncmp_iw (word
, lcd
, strlen (lcd
)) == 0)
477 /* Maybe skip the function and complete on keywords. */
478 size_t wordlen
= strlen (word
);
479 if (word
[wordlen
- 1] == ' ')
487 /* See completer.h. */
490 complete_nested_command_line (completion_tracker
&tracker
, const char *text
)
492 /* Must be called from a custom-word-point completer. */
493 gdb_assert (tracker
.use_custom_word_point ());
495 /* Disable the custom word point temporarily, because we want to
496 probe whether the command we're completing itself uses a custom
498 tracker
.set_use_custom_word_point (false);
499 size_t save_custom_word_point
= tracker
.custom_word_point ();
501 int quote_char
= '\0';
502 const char *word
= completion_find_completion_word (tracker
, text
,
505 if (tracker
.use_custom_word_point ())
507 /* The command we're completing uses a custom word point, so the
508 tracker already contains the matches. We're done. */
512 /* Restore the custom word point settings. */
513 tracker
.set_custom_word_point (save_custom_word_point
);
514 tracker
.set_use_custom_word_point (true);
516 /* Run the handle_completions completer phase. */
517 complete_line (tracker
, word
, text
, strlen (text
));
520 /* Complete on linespecs, which might be of two possible forms:
526 This is intended to be used in commands that set breakpoints
530 complete_files_symbols (completion_tracker
&tracker
,
531 const char *text
, const char *word
)
533 completion_list fn_list
;
536 int quoted
= *text
== '\'' || *text
== '"';
537 int quote_char
= '\0';
538 const char *colon
= NULL
;
539 char *file_to_match
= NULL
;
540 const char *symbol_start
= text
;
541 const char *orig_text
= text
;
543 /* Do we have an unquoted colon, as in "break foo.c:bar"? */
544 for (p
= text
; *p
!= '\0'; ++p
)
546 if (*p
== '\\' && p
[1] == '\'')
548 else if (*p
== '\'' || *p
== '"')
552 while (*p
!= '\0' && *p
!= quote_found
)
554 if (*p
== '\\' && p
[1] == quote_found
)
559 if (*p
== quote_found
)
562 break; /* Hit the end of text. */
564 #if HAVE_DOS_BASED_FILE_SYSTEM
565 /* If we have a DOS-style absolute file name at the beginning of
566 TEXT, and the colon after the drive letter is the only colon
567 we found, pretend the colon is not there. */
568 else if (p
< text
+ 3 && *p
== ':' && p
== text
+ 1 + quoted
)
571 else if (*p
== ':' && !colon
)
574 symbol_start
= p
+ 1;
576 else if (strchr (current_language
->word_break_characters (), *p
))
577 symbol_start
= p
+ 1;
583 /* Where is the file name? */
588 file_to_match
= (char *) xmalloc (colon
- text
+ 1);
589 strncpy (file_to_match
, text
, colon
- text
);
590 file_to_match
[colon
- text
] = '\0';
591 /* Remove trailing colons and quotes from the file name. */
592 for (s
= file_to_match
+ (colon
- text
);
595 if (*s
== ':' || *s
== quote_char
)
598 /* If the text includes a colon, they want completion only on a
599 symbol name after the colon. Otherwise, we need to complete on
600 symbols as well as on files. */
603 collect_file_symbol_completion_matches (tracker
,
604 complete_symbol_mode::EXPRESSION
,
605 symbol_name_match_type::EXPRESSION
,
608 xfree (file_to_match
);
612 size_t text_len
= strlen (text
);
614 collect_symbol_completion_matches (tracker
,
615 complete_symbol_mode::EXPRESSION
,
616 symbol_name_match_type::EXPRESSION
,
618 /* If text includes characters which cannot appear in a file
619 name, they cannot be asking for completion on files. */
621 gdb_completer_file_name_break_characters
) == text_len
)
622 fn_list
= make_source_files_completion_list (text
, text
);
625 if (!fn_list
.empty () && !tracker
.have_completions ())
627 /* If we only have file names as possible completion, we should
628 bring them in sync with what rl_complete expects. The
629 problem is that if the user types "break /foo/b TAB", and the
630 possible completions are "/foo/bar" and "/foo/baz"
631 rl_complete expects us to return "bar" and "baz", without the
632 leading directories, as possible completions, because `word'
633 starts at the "b". But we ignore the value of `word' when we
634 call make_source_files_completion_list above (because that
635 would not DTRT when the completion results in both symbols
636 and file names), so make_source_files_completion_list returns
637 the full "/foo/bar" and "/foo/baz" strings. This produces
638 wrong results when, e.g., there's only one possible
639 completion, because rl_complete will prepend "/foo/" to each
640 candidate completion. The loop below removes that leading
642 for (const auto &fn_up
: fn_list
)
644 char *fn
= fn_up
.get ();
645 memmove (fn
, fn
+ (word
- text
), strlen (fn
) + 1 - (word
- text
));
649 tracker
.add_completions (std::move (fn_list
));
651 if (!tracker
.have_completions ())
653 /* No completions at all. As the final resort, try completing
654 on the entire text as a symbol. */
655 collect_symbol_completion_matches (tracker
,
656 complete_symbol_mode::EXPRESSION
,
657 symbol_name_match_type::EXPRESSION
,
662 /* See completer.h. */
665 complete_source_filenames (const char *text
)
667 size_t text_len
= strlen (text
);
669 /* If text includes characters which cannot appear in a file name,
670 the user cannot be asking for completion on files. */
672 gdb_completer_file_name_break_characters
)
674 return make_source_files_completion_list (text
, text
);
679 /* Complete address and linespec locations. */
682 complete_address_and_linespec_locations (completion_tracker
&tracker
,
684 symbol_name_match_type match_type
)
688 tracker
.advance_custom_word_point_by (1);
691 = advance_to_expression_complete_word_point (tracker
, text
);
692 complete_expression (tracker
, text
, word
);
696 linespec_complete (tracker
, text
, match_type
);
700 /* The explicit location options. Note that indexes into this array
701 must match the explicit_location_match_type enumerators. */
703 static const char *const explicit_options
[] =
713 /* The probe modifier options. These can appear before a location in
714 breakpoint commands. */
715 static const char *const probe_options
[] =
723 /* Returns STRING if not NULL, the empty string otherwise. */
726 string_or_empty (const char *string
)
728 return string
!= NULL
? string
: "";
731 /* A helper function to collect explicit location matches for the given
732 LOCATION, which is attempting to match on WORD. */
735 collect_explicit_location_matches (completion_tracker
&tracker
,
736 struct event_location
*location
,
737 enum explicit_location_match_type what
,
739 const struct language_defn
*language
)
741 const struct explicit_location
*explicit_loc
742 = get_explicit_location (location
);
744 /* True if the option expects an argument. */
745 bool needs_arg
= true;
747 /* Note, in the various MATCH_* below, we complete on
748 explicit_loc->foo instead of WORD, because only the former will
749 have already skipped past any quote char. */
754 const char *source
= string_or_empty (explicit_loc
->source_filename
);
755 completion_list matches
756 = make_source_files_completion_list (source
, source
);
757 tracker
.add_completions (std::move (matches
));
763 const char *function
= string_or_empty (explicit_loc
->function_name
);
764 linespec_complete_function (tracker
, function
,
765 explicit_loc
->func_name_match_type
,
766 explicit_loc
->source_filename
);
770 case MATCH_QUALIFIED
:
774 /* Nothing to offer. */
779 const char *label
= string_or_empty (explicit_loc
->label_name
);
780 linespec_complete_label (tracker
, language
,
781 explicit_loc
->source_filename
,
782 explicit_loc
->function_name
,
783 explicit_loc
->func_name_match_type
,
789 gdb_assert_not_reached ("unhandled explicit_location_match_type");
792 if (!needs_arg
|| tracker
.completes_to_completion_word (word
))
794 tracker
.discard_completions ();
795 tracker
.advance_custom_word_point_by (strlen (word
));
796 complete_on_enum (tracker
, explicit_options
, "", "");
797 complete_on_enum (tracker
, linespec_keywords
, "", "");
799 else if (!tracker
.have_completions ())
801 /* Maybe we have an unterminated linespec keyword at the tail of
802 the string. Try completing on that. */
803 size_t wordlen
= strlen (word
);
804 const char *keyword
= word
+ wordlen
;
806 if (wordlen
> 0 && keyword
[-1] != ' ')
808 while (keyword
> word
&& *keyword
!= ' ')
810 /* Don't complete on keywords if we'd be completing on the
811 whole explicit linespec option. E.g., "b -function
812 thr<tab>" should not complete to the "thread"
816 keyword
= skip_spaces (keyword
);
818 tracker
.advance_custom_word_point_by (keyword
- word
);
819 complete_on_enum (tracker
, linespec_keywords
, keyword
, keyword
);
822 else if (wordlen
> 0 && keyword
[-1] == ' ')
824 /* Assume that we're maybe past the explicit location
825 argument, and we didn't manage to find any match because
826 the user wants to create a pending breakpoint. Offer the
827 keyword and explicit location options as possible
829 tracker
.advance_custom_word_point_by (keyword
- word
);
830 complete_on_enum (tracker
, linespec_keywords
, keyword
, keyword
);
831 complete_on_enum (tracker
, explicit_options
, keyword
, keyword
);
836 /* If the next word in *TEXT_P is any of the keywords in KEYWORDS,
837 then advance both TEXT_P and the word point in the tracker past the
838 keyword and return the (0-based) index in the KEYWORDS array that
839 matched. Otherwise, return -1. */
842 skip_keyword (completion_tracker
&tracker
,
843 const char * const *keywords
, const char **text_p
)
845 const char *text
= *text_p
;
846 const char *after
= skip_to_space (text
);
847 size_t len
= after
- text
;
849 if (text
[len
] != ' ')
853 for (int i
= 0; keywords
[i
] != NULL
; i
++)
855 if (strncmp (keywords
[i
], text
, len
) == 0)
866 tracker
.advance_custom_word_point_by (len
+ 1);
875 /* A completer function for explicit locations. This function
876 completes both options ("-source", "-line", etc) and values. If
877 completing a quoted string, then QUOTED_ARG_START and
878 QUOTED_ARG_END point to the quote characters. LANGUAGE is the
882 complete_explicit_location (completion_tracker
&tracker
,
883 struct event_location
*location
,
885 const language_defn
*language
,
886 const char *quoted_arg_start
,
887 const char *quoted_arg_end
)
892 int keyword
= skip_keyword (tracker
, explicit_options
, &text
);
896 complete_on_enum (tracker
, explicit_options
, text
, text
);
897 /* There are keywords that start with "-". Include them, too. */
898 complete_on_enum (tracker
, linespec_keywords
, text
, text
);
902 /* Completing on value. */
903 enum explicit_location_match_type what
904 = (explicit_location_match_type
) keyword
;
906 if (quoted_arg_start
!= NULL
&& quoted_arg_end
!= NULL
)
908 if (quoted_arg_end
[1] == '\0')
910 /* If completing a quoted string with the cursor right
911 at the terminating quote char, complete the
912 completion word without interpretation, so that
913 readline advances the cursor one whitespace past the
914 quote, even if there's no match. This makes these
915 cases behave the same:
917 before: "b -function function()"
918 after: "b -function function() "
920 before: "b -function 'function()'"
921 after: "b -function 'function()' "
923 and trusts the user in this case:
925 before: "b -function 'not_loaded_function_yet()'"
926 after: "b -function 'not_loaded_function_yet()' "
928 tracker
.add_completion (make_unique_xstrdup (text
));
930 else if (quoted_arg_end
[1] == ' ')
932 /* We're maybe past the explicit location argument.
933 Skip the argument without interpretation, assuming the
934 user may want to create pending breakpoint. Offer
935 the keyword and explicit location options as possible
937 tracker
.advance_custom_word_point_by (strlen (text
));
938 complete_on_enum (tracker
, linespec_keywords
, "", "");
939 complete_on_enum (tracker
, explicit_options
, "", "");
944 /* Now gather matches */
945 collect_explicit_location_matches (tracker
, location
, what
, text
,
950 /* A completer for locations. */
953 location_completer (struct cmd_list_element
*ignore
,
954 completion_tracker
&tracker
,
955 const char *text
, const char * /* word */)
957 int found_probe_option
= -1;
959 /* If we have a probe modifier, skip it. This can only appear as
960 first argument. Until we have a specific completer for probes,
961 falling back to the linespec completer for the remainder of the
962 line is better than nothing. */
963 if (text
[0] == '-' && text
[1] == 'p')
964 found_probe_option
= skip_keyword (tracker
, probe_options
, &text
);
966 const char *option_text
= text
;
967 int saved_word_point
= tracker
.custom_word_point ();
969 const char *copy
= text
;
971 explicit_completion_info completion_info
;
972 event_location_up location
973 = string_to_explicit_location (©
, current_language
,
975 if (completion_info
.quoted_arg_start
!= NULL
976 && completion_info
.quoted_arg_end
== NULL
)
978 /* Found an unbalanced quote. */
979 tracker
.set_quote_char (*completion_info
.quoted_arg_start
);
980 tracker
.advance_custom_word_point_by (1);
983 if (completion_info
.saw_explicit_location_option
)
987 tracker
.advance_custom_word_point_by (copy
- text
);
990 /* We found a terminator at the tail end of the string,
991 which means we're past the explicit location options. We
992 may have a keyword to complete on. If we have a whole
993 keyword, then complete whatever comes after as an
994 expression. This is mainly for the "if" keyword. If the
995 "thread" and "task" keywords gain their own completers,
996 they should be used here. */
997 int keyword
= skip_keyword (tracker
, linespec_keywords
, &text
);
1001 complete_on_enum (tracker
, linespec_keywords
, text
, text
);
1006 = advance_to_expression_complete_word_point (tracker
, text
);
1007 complete_expression (tracker
, text
, word
);
1012 tracker
.advance_custom_word_point_by (completion_info
.last_option
1014 text
= completion_info
.last_option
;
1016 complete_explicit_location (tracker
, location
.get (), text
,
1018 completion_info
.quoted_arg_start
,
1019 completion_info
.quoted_arg_end
);
1023 /* This is an address or linespec location. */
1024 else if (location
!= NULL
)
1026 /* Handle non-explicit location options. */
1028 int keyword
= skip_keyword (tracker
, explicit_options
, &text
);
1030 complete_on_enum (tracker
, explicit_options
, text
, text
);
1033 tracker
.advance_custom_word_point_by (copy
- text
);
1036 symbol_name_match_type match_type
1037 = get_explicit_location (location
.get ())->func_name_match_type
;
1038 complete_address_and_linespec_locations (tracker
, text
, match_type
);
1044 complete_address_and_linespec_locations (tracker
, text
,
1045 symbol_name_match_type::WILD
);
1048 /* Add matches for option names, if either:
1050 - Some completer above found some matches, but the word point did
1051 not advance (e.g., "b <tab>" finds all functions, or "b -<tab>"
1052 matches all objc selectors), or;
1054 - Some completer above advanced the word point, but found no
1057 if ((text
[0] == '-' || text
[0] == '\0')
1058 && (!tracker
.have_completions ()
1059 || tracker
.custom_word_point () == saved_word_point
))
1061 tracker
.set_custom_word_point (saved_word_point
);
1064 if (found_probe_option
== -1)
1065 complete_on_enum (tracker
, probe_options
, text
, text
);
1066 complete_on_enum (tracker
, explicit_options
, text
, text
);
1070 /* The corresponding completer_handle_brkchars
1074 location_completer_handle_brkchars (struct cmd_list_element
*ignore
,
1075 completion_tracker
&tracker
,
1077 const char *word_ignored
)
1079 tracker
.set_use_custom_word_point (true);
1081 location_completer (ignore
, tracker
, text
, NULL
);
1084 /* Helper for expression_completer which recursively adds field and
1085 method names from TYPE, a struct or union type, to the OUTPUT
1089 add_struct_fields (struct type
*type
, completion_list
&output
,
1090 const char *fieldname
, int namelen
)
1093 int computed_type_name
= 0;
1094 const char *type_name
= NULL
;
1096 type
= check_typedef (type
);
1097 for (i
= 0; i
< type
->num_fields (); ++i
)
1099 if (i
< TYPE_N_BASECLASSES (type
))
1100 add_struct_fields (TYPE_BASECLASS (type
, i
),
1101 output
, fieldname
, namelen
);
1102 else if (TYPE_FIELD_NAME (type
, i
))
1104 if (TYPE_FIELD_NAME (type
, i
)[0] != '\0')
1106 if (! strncmp (TYPE_FIELD_NAME (type
, i
),
1107 fieldname
, namelen
))
1108 output
.emplace_back (xstrdup (TYPE_FIELD_NAME (type
, i
)));
1110 else if (type
->field (i
).type ()->code () == TYPE_CODE_UNION
)
1112 /* Recurse into anonymous unions. */
1113 add_struct_fields (type
->field (i
).type (),
1114 output
, fieldname
, namelen
);
1119 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
1121 const char *name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1123 if (name
&& ! strncmp (name
, fieldname
, namelen
))
1125 if (!computed_type_name
)
1127 type_name
= type
->name ();
1128 computed_type_name
= 1;
1130 /* Omit constructors from the completion list. */
1131 if (!type_name
|| strcmp (type_name
, name
))
1132 output
.emplace_back (xstrdup (name
));
1137 /* See completer.h. */
1140 complete_expression (completion_tracker
&tracker
,
1141 const char *text
, const char *word
)
1143 struct type
*type
= NULL
;
1144 gdb::unique_xmalloc_ptr
<char> fieldname
;
1145 enum type_code code
= TYPE_CODE_UNDEF
;
1147 /* Perform a tentative parse of the expression, to see whether a
1148 field completion is required. */
1151 type
= parse_expression_for_completion (text
, &fieldname
, &code
);
1153 catch (const gdb_exception_error
&except
)
1158 if (fieldname
!= nullptr && type
)
1162 type
= check_typedef (type
);
1163 if (type
->code () != TYPE_CODE_PTR
&& !TYPE_IS_REFERENCE (type
))
1165 type
= TYPE_TARGET_TYPE (type
);
1168 if (type
->code () == TYPE_CODE_UNION
1169 || type
->code () == TYPE_CODE_STRUCT
)
1171 completion_list result
;
1173 add_struct_fields (type
, result
, fieldname
.get (),
1174 strlen (fieldname
.get ()));
1175 tracker
.add_completions (std::move (result
));
1179 else if (fieldname
!= nullptr && code
!= TYPE_CODE_UNDEF
)
1181 collect_symbol_completion_matches_type (tracker
, fieldname
.get (),
1182 fieldname
.get (), code
);
1186 complete_files_symbols (tracker
, text
, word
);
1189 /* Complete on expressions. Often this means completing on symbol
1190 names, but some language parsers also have support for completing
1194 expression_completer (struct cmd_list_element
*ignore
,
1195 completion_tracker
&tracker
,
1196 const char *text
, const char *word
)
1198 complete_expression (tracker
, text
, word
);
1201 /* See definition in completer.h. */
1204 set_rl_completer_word_break_characters (const char *break_chars
)
1206 rl_completer_word_break_characters
= (char *) break_chars
;
1209 /* Complete on symbols. */
1212 symbol_completer (struct cmd_list_element
*ignore
,
1213 completion_tracker
&tracker
,
1214 const char *text
, const char *word
)
1216 collect_symbol_completion_matches (tracker
, complete_symbol_mode::EXPRESSION
,
1217 symbol_name_match_type::EXPRESSION
,
1221 /* Here are some useful test cases for completion. FIXME: These
1222 should be put in the test suite. They should be tested with both
1225 "show output-" "radix"
1226 "show output" "-radix"
1227 "p" ambiguous (commands starting with p--path, print, printf, etc.)
1228 "p " ambiguous (all symbols)
1229 "info t foo" no completions
1230 "info t " no completions
1231 "info t" ambiguous ("info target", "info terminal", etc.)
1232 "info ajksdlfk" no completions
1233 "info ajksdlfk " no completions
1235 "info " ambiguous (all info commands)
1236 "p \"a" no completions (string constant)
1237 "p 'a" ambiguous (all symbols starting with a)
1238 "p b-a" ambiguous (all symbols starting with a)
1239 "p b-" ambiguous (all symbols)
1240 "file Make" "file" (word break hard to screw up here)
1241 "file ../gdb.stabs/we" "ird" (needs to not break word at slash)
1244 enum complete_line_internal_reason
1246 /* Preliminary phase, called by gdb_completion_word_break_characters
1247 function, is used to either:
1249 #1 - Determine the set of chars that are word delimiters
1250 depending on the current command in line_buffer.
1252 #2 - Manually advance RL_POINT to the "word break" point instead
1253 of letting readline do it (based on too-simple character
1256 Simpler completers that just pass a brkchars array to readline
1257 (#1 above) must defer generating the completions to the main
1258 phase (below). No completion list should be generated in this
1261 OTOH, completers that manually advance the word point(#2 above)
1262 must set "use_custom_word_point" in the tracker and generate
1263 their completion in this phase. Note that this is the convenient
1264 thing to do since they'll be parsing the input line anyway. */
1267 /* Main phase, called by complete_line function, is used to get the
1268 list of possible completions. */
1271 /* Special case when completing a 'help' command. In this case,
1272 once sub-command completions are exhausted, we simply return
1277 /* Helper for complete_line_internal to simplify it. */
1280 complete_line_internal_normal_command (completion_tracker
&tracker
,
1281 const char *command
, const char *word
,
1282 const char *cmd_args
,
1283 complete_line_internal_reason reason
,
1284 struct cmd_list_element
*c
)
1286 const char *p
= cmd_args
;
1288 if (c
->completer
== filename_completer
)
1290 /* Many commands which want to complete on file names accept
1291 several file names, as in "run foo bar >>baz". So we don't
1292 want to complete the entire text after the command, just the
1293 last word. To this end, we need to find the beginning of the
1294 file name by starting at `word' and going backwards. */
1297 && strchr (gdb_completer_file_name_break_characters
,
1303 if (reason
== handle_brkchars
)
1305 completer_handle_brkchars_ftype
*brkchars_fn
;
1307 if (c
->completer_handle_brkchars
!= NULL
)
1308 brkchars_fn
= c
->completer_handle_brkchars
;
1312 = (completer_handle_brkchars_func_for_completer
1316 brkchars_fn (c
, tracker
, p
, word
);
1319 if (reason
!= handle_brkchars
&& c
->completer
!= NULL
)
1320 (*c
->completer
) (c
, tracker
, p
, word
);
1323 /* Internal function used to handle completions.
1326 TEXT is the caller's idea of the "word" we are looking at.
1328 LINE_BUFFER is available to be looked at; it contains the entire
1329 text of the line. POINT is the offset in that line of the cursor.
1330 You should pretend that the line ends at POINT.
1332 See complete_line_internal_reason for description of REASON. */
1335 complete_line_internal_1 (completion_tracker
&tracker
,
1337 const char *line_buffer
, int point
,
1338 complete_line_internal_reason reason
)
1342 int ignore_help_classes
;
1343 /* Pointer within tmp_command which corresponds to text. */
1345 struct cmd_list_element
*c
, *result_list
;
1347 /* Choose the default set of word break characters to break
1348 completions. If we later find out that we are doing completions
1349 on command strings (as opposed to strings supplied by the
1350 individual command completer functions, which can be any string)
1351 then we will switch to the special word break set for command
1352 strings, which leaves out the '-' and '.' character used in some
1354 set_rl_completer_word_break_characters
1355 (current_language
->word_break_characters ());
1357 /* Decide whether to complete on a list of gdb commands or on
1359 tmp_command
= (char *) alloca (point
+ 1);
1362 /* The help command should complete help aliases. */
1363 ignore_help_classes
= reason
!= handle_help
;
1365 strncpy (tmp_command
, line_buffer
, point
);
1366 tmp_command
[point
] = '\0';
1367 if (reason
== handle_brkchars
)
1369 gdb_assert (text
== NULL
);
1374 /* Since text always contains some number of characters leading up
1375 to point, we can find the equivalent position in tmp_command
1376 by subtracting that many characters from the end of tmp_command. */
1377 word
= tmp_command
+ point
- strlen (text
);
1380 /* Move P up to the start of the command. */
1381 p
= skip_spaces (p
);
1385 /* An empty line is ambiguous; that is, it could be any
1387 c
= CMD_LIST_AMBIGUOUS
;
1392 c
= lookup_cmd_1 (&p
, cmdlist
, &result_list
, NULL
, ignore_help_classes
);
1395 /* Move p up to the next interesting thing. */
1396 while (*p
== ' ' || *p
== '\t')
1401 tracker
.advance_custom_word_point_by (p
- tmp_command
);
1405 /* It is an unrecognized command. So there are no
1406 possible completions. */
1408 else if (c
== CMD_LIST_AMBIGUOUS
)
1412 /* lookup_cmd_1 advances p up to the first ambiguous thing, but
1413 doesn't advance over that thing itself. Do so now. */
1415 while (valid_cmd_char_p (*q
))
1417 if (q
!= tmp_command
+ point
)
1419 /* There is something beyond the ambiguous
1420 command, so there are no possible completions. For
1421 example, "info t " or "info t foo" does not complete
1422 to anything, because "info t" can be "info target" or
1427 /* We're trying to complete on the command which was ambiguous.
1428 This we can deal with. */
1431 if (reason
!= handle_brkchars
)
1432 complete_on_cmdlist (*result_list
->prefixlist
, tracker
, p
,
1433 word
, ignore_help_classes
);
1437 if (reason
!= handle_brkchars
)
1438 complete_on_cmdlist (cmdlist
, tracker
, p
, word
,
1439 ignore_help_classes
);
1441 /* Ensure that readline does the right thing with respect to
1442 inserting quotes. */
1443 set_rl_completer_word_break_characters
1444 (gdb_completer_command_word_break_characters
);
1449 /* We've recognized a full command. */
1451 if (p
== tmp_command
+ point
)
1453 /* There is no non-whitespace in the line beyond the
1456 if (p
[-1] == ' ' || p
[-1] == '\t')
1458 /* The command is followed by whitespace; we need to
1459 complete on whatever comes after command. */
1462 /* It is a prefix command; what comes after it is
1463 a subcommand (e.g. "info "). */
1464 if (reason
!= handle_brkchars
)
1465 complete_on_cmdlist (*c
->prefixlist
, tracker
, p
, word
,
1466 ignore_help_classes
);
1468 /* Ensure that readline does the right thing
1469 with respect to inserting quotes. */
1470 set_rl_completer_word_break_characters
1471 (gdb_completer_command_word_break_characters
);
1473 else if (reason
== handle_help
)
1477 if (reason
!= handle_brkchars
)
1478 complete_on_enum (tracker
, c
->enums
, p
, word
);
1479 set_rl_completer_word_break_characters
1480 (gdb_completer_command_word_break_characters
);
1484 /* It is a normal command; what comes after it is
1485 completed by the command's completer function. */
1486 complete_line_internal_normal_command (tracker
,
1487 tmp_command
, word
, p
,
1493 /* The command is not followed by whitespace; we need to
1494 complete on the command itself, e.g. "p" which is a
1495 command itself but also can complete to "print", "ptype"
1499 /* Find the command we are completing on. */
1501 while (q
> tmp_command
)
1503 if (valid_cmd_char_p (q
[-1]))
1509 /* Move the custom word point back too. */
1510 tracker
.advance_custom_word_point_by (q
- p
);
1512 if (reason
!= handle_brkchars
)
1513 complete_on_cmdlist (result_list
, tracker
, q
, word
,
1514 ignore_help_classes
);
1516 /* Ensure that readline does the right thing
1517 with respect to inserting quotes. */
1518 set_rl_completer_word_break_characters
1519 (gdb_completer_command_word_break_characters
);
1522 else if (reason
== handle_help
)
1526 /* There is non-whitespace beyond the command. */
1528 if (c
->prefixlist
&& !c
->allow_unknown
)
1530 /* It is an unrecognized subcommand of a prefix command,
1531 e.g. "info adsfkdj". */
1535 if (reason
!= handle_brkchars
)
1536 complete_on_enum (tracker
, c
->enums
, p
, word
);
1540 /* It is a normal command. */
1541 complete_line_internal_normal_command (tracker
,
1542 tmp_command
, word
, p
,
1549 /* Wrapper around complete_line_internal_1 to handle
1550 MAX_COMPLETIONS_REACHED_ERROR. */
1553 complete_line_internal (completion_tracker
&tracker
,
1555 const char *line_buffer
, int point
,
1556 complete_line_internal_reason reason
)
1560 complete_line_internal_1 (tracker
, text
, line_buffer
, point
, reason
);
1562 catch (const gdb_exception_error
&except
)
1564 if (except
.error
!= MAX_COMPLETIONS_REACHED_ERROR
)
1569 /* See completer.h. */
1571 int max_completions
= 200;
1573 /* Initial size of the table. It automagically grows from here. */
1574 #define INITIAL_COMPLETION_HTAB_SIZE 200
1576 /* See completer.h. */
1578 completion_tracker::completion_tracker ()
1580 discard_completions ();
1583 /* See completer.h. */
1586 completion_tracker::discard_completions ()
1588 xfree (m_lowest_common_denominator
);
1589 m_lowest_common_denominator
= NULL
;
1591 m_lowest_common_denominator_unique
= false;
1592 m_lowest_common_denominator_valid
= false;
1594 m_entries_hash
.reset (nullptr);
1596 /* A callback used by the hash table to compare new entries with existing
1597 entries. We can't use the standard streq_hash function here as the
1598 key to our hash is just a single string, while the values we store in
1599 the hash are a struct containing multiple strings. */
1600 static auto entry_eq_func
1601 = [] (const void *first
, const void *second
) -> int
1603 /* The FIRST argument is the entry already in the hash table, and
1604 the SECOND argument is the new item being inserted. */
1605 const completion_hash_entry
*entry
1606 = (const completion_hash_entry
*) first
;
1607 const char *name_str
= (const char *) second
;
1609 return entry
->is_name_eq (name_str
);
1612 /* Callback used by the hash table to compute the hash value for an
1613 existing entry. This is needed when expanding the hash table. */
1614 static auto entry_hash_func
1615 = [] (const void *arg
) -> hashval_t
1617 const completion_hash_entry
*entry
1618 = (const completion_hash_entry
*) arg
;
1619 return entry
->hash_name ();
1622 m_entries_hash
.reset (htab_create_alloc (INITIAL_COMPLETION_HTAB_SIZE
,
1623 entry_hash_func
, entry_eq_func
,
1624 completion_hash_entry::deleter
,
1628 /* See completer.h. */
1630 completion_tracker::~completion_tracker ()
1632 xfree (m_lowest_common_denominator
);
1635 /* See completer.h. */
1638 completion_tracker::maybe_add_completion
1639 (gdb::unique_xmalloc_ptr
<char> name
,
1640 completion_match_for_lcd
*match_for_lcd
,
1641 const char *text
, const char *word
)
1645 if (max_completions
== 0)
1648 if (htab_elements (m_entries_hash
.get ()) >= max_completions
)
1651 hashval_t hash
= htab_hash_string (name
.get ());
1652 slot
= htab_find_slot_with_hash (m_entries_hash
.get (), name
.get (),
1654 if (*slot
== HTAB_EMPTY_ENTRY
)
1656 const char *match_for_lcd_str
= NULL
;
1658 if (match_for_lcd
!= NULL
)
1659 match_for_lcd_str
= match_for_lcd
->finish ();
1661 if (match_for_lcd_str
== NULL
)
1662 match_for_lcd_str
= name
.get ();
1664 gdb::unique_xmalloc_ptr
<char> lcd
1665 = make_completion_match_str (match_for_lcd_str
, text
, word
);
1667 size_t lcd_len
= strlen (lcd
.get ());
1668 *slot
= new completion_hash_entry (std::move (name
), std::move (lcd
));
1670 m_lowest_common_denominator_valid
= false;
1671 m_lowest_common_denominator_max_length
1672 = std::max (m_lowest_common_denominator_max_length
, lcd_len
);
1678 /* See completer.h. */
1681 completion_tracker::add_completion (gdb::unique_xmalloc_ptr
<char> name
,
1682 completion_match_for_lcd
*match_for_lcd
,
1683 const char *text
, const char *word
)
1685 if (!maybe_add_completion (std::move (name
), match_for_lcd
, text
, word
))
1686 throw_error (MAX_COMPLETIONS_REACHED_ERROR
, _("Max completions reached."));
1689 /* See completer.h. */
1692 completion_tracker::add_completions (completion_list
&&list
)
1694 for (auto &candidate
: list
)
1695 add_completion (std::move (candidate
));
1698 /* See completer.h. */
1701 completion_tracker::remove_completion (const char *name
)
1703 hashval_t hash
= htab_hash_string (name
);
1704 if (htab_find_slot_with_hash (m_entries_hash
.get (), name
, hash
, NO_INSERT
)
1707 htab_remove_elt_with_hash (m_entries_hash
.get (), name
, hash
);
1708 m_lowest_common_denominator_valid
= false;
1712 /* Helper for the make_completion_match_str overloads. Returns NULL
1713 as an indication that we want MATCH_NAME exactly. It is up to the
1714 caller to xstrdup that string if desired. */
1717 make_completion_match_str_1 (const char *match_name
,
1718 const char *text
, const char *word
)
1724 /* Return NULL as an indication that we want MATCH_NAME
1728 else if (word
> text
)
1730 /* Return some portion of MATCH_NAME. */
1731 newobj
= xstrdup (match_name
+ (word
- text
));
1735 /* Return some of WORD plus MATCH_NAME. */
1736 size_t len
= strlen (match_name
);
1737 newobj
= (char *) xmalloc (text
- word
+ len
+ 1);
1738 memcpy (newobj
, word
, text
- word
);
1739 memcpy (newobj
+ (text
- word
), match_name
, len
+ 1);
1745 /* See completer.h. */
1747 gdb::unique_xmalloc_ptr
<char>
1748 make_completion_match_str (const char *match_name
,
1749 const char *text
, const char *word
)
1751 char *newobj
= make_completion_match_str_1 (match_name
, text
, word
);
1753 newobj
= xstrdup (match_name
);
1754 return gdb::unique_xmalloc_ptr
<char> (newobj
);
1757 /* See completer.h. */
1759 gdb::unique_xmalloc_ptr
<char>
1760 make_completion_match_str (gdb::unique_xmalloc_ptr
<char> &&match_name
,
1761 const char *text
, const char *word
)
1763 char *newobj
= make_completion_match_str_1 (match_name
.get (), text
, word
);
1765 return std::move (match_name
);
1766 return gdb::unique_xmalloc_ptr
<char> (newobj
);
1769 /* See complete.h. */
1772 complete (const char *line
, char const **word
, int *quote_char
)
1774 completion_tracker tracker_handle_brkchars
;
1775 completion_tracker tracker_handle_completions
;
1776 completion_tracker
*tracker
;
1778 /* The WORD should be set to the end of word to complete. We initialize
1779 to the completion point which is assumed to be at the end of LINE.
1780 This leaves WORD to be initialized to a sensible value in cases
1781 completion_find_completion_word() fails i.e., throws an exception.
1783 *word
= line
+ strlen (line
);
1787 *word
= completion_find_completion_word (tracker_handle_brkchars
,
1790 /* Completers that provide a custom word point in the
1791 handle_brkchars phase also compute their completions then.
1792 Completers that leave the completion word handling to readline
1793 must be called twice. */
1794 if (tracker_handle_brkchars
.use_custom_word_point ())
1795 tracker
= &tracker_handle_brkchars
;
1798 complete_line (tracker_handle_completions
, *word
, line
, strlen (line
));
1799 tracker
= &tracker_handle_completions
;
1802 catch (const gdb_exception
&ex
)
1807 return tracker
->build_completion_result (*word
, *word
- line
, strlen (line
));
1811 /* Generate completions all at once. Does nothing if max_completions
1812 is 0. If max_completions is non-negative, this will collect at
1813 most max_completions strings.
1815 TEXT is the caller's idea of the "word" we are looking at.
1817 LINE_BUFFER is available to be looked at; it contains the entire
1820 POINT is the offset in that line of the cursor. You
1821 should pretend that the line ends at POINT. */
1824 complete_line (completion_tracker
&tracker
,
1825 const char *text
, const char *line_buffer
, int point
)
1827 if (max_completions
== 0)
1829 complete_line_internal (tracker
, text
, line_buffer
, point
,
1830 handle_completions
);
1833 /* Complete on command names. Used by "help". */
1836 command_completer (struct cmd_list_element
*ignore
,
1837 completion_tracker
&tracker
,
1838 const char *text
, const char *word
)
1840 complete_line_internal (tracker
, word
, text
,
1841 strlen (text
), handle_help
);
1844 /* The corresponding completer_handle_brkchars implementation. */
1847 command_completer_handle_brkchars (struct cmd_list_element
*ignore
,
1848 completion_tracker
&tracker
,
1849 const char *text
, const char *word
)
1851 set_rl_completer_word_break_characters
1852 (gdb_completer_command_word_break_characters
);
1855 /* Complete on signals. */
1858 signal_completer (struct cmd_list_element
*ignore
,
1859 completion_tracker
&tracker
,
1860 const char *text
, const char *word
)
1862 size_t len
= strlen (word
);
1864 const char *signame
;
1866 for (signum
= GDB_SIGNAL_FIRST
; signum
!= GDB_SIGNAL_LAST
; ++signum
)
1868 /* Can't handle this, so skip it. */
1869 if (signum
== GDB_SIGNAL_0
)
1872 signame
= gdb_signal_to_name ((enum gdb_signal
) signum
);
1874 /* Ignore the unknown signal case. */
1875 if (!signame
|| strcmp (signame
, "?") == 0)
1878 if (strncasecmp (signame
, word
, len
) == 0)
1879 tracker
.add_completion (make_unique_xstrdup (signame
));
1883 /* Bit-flags for selecting what the register and/or register-group
1884 completer should complete on. */
1886 enum reg_completer_target
1888 complete_register_names
= 0x1,
1889 complete_reggroup_names
= 0x2
1891 DEF_ENUM_FLAGS_TYPE (enum reg_completer_target
, reg_completer_targets
);
1893 /* Complete register names and/or reggroup names based on the value passed
1894 in TARGETS. At least one bit in TARGETS must be set. */
1897 reg_or_group_completer_1 (completion_tracker
&tracker
,
1898 const char *text
, const char *word
,
1899 reg_completer_targets targets
)
1901 size_t len
= strlen (word
);
1902 struct gdbarch
*gdbarch
;
1905 gdb_assert ((targets
& (complete_register_names
1906 | complete_reggroup_names
)) != 0);
1907 gdbarch
= get_current_arch ();
1909 if ((targets
& complete_register_names
) != 0)
1914 (name
= user_reg_map_regnum_to_name (gdbarch
, i
)) != NULL
;
1917 if (*name
!= '\0' && strncmp (word
, name
, len
) == 0)
1918 tracker
.add_completion (make_unique_xstrdup (name
));
1922 if ((targets
& complete_reggroup_names
) != 0)
1924 struct reggroup
*group
;
1926 for (group
= reggroup_next (gdbarch
, NULL
);
1928 group
= reggroup_next (gdbarch
, group
))
1930 name
= reggroup_name (group
);
1931 if (strncmp (word
, name
, len
) == 0)
1932 tracker
.add_completion (make_unique_xstrdup (name
));
1937 /* Perform completion on register and reggroup names. */
1940 reg_or_group_completer (struct cmd_list_element
*ignore
,
1941 completion_tracker
&tracker
,
1942 const char *text
, const char *word
)
1944 reg_or_group_completer_1 (tracker
, text
, word
,
1945 (complete_register_names
1946 | complete_reggroup_names
));
1949 /* Perform completion on reggroup names. */
1952 reggroup_completer (struct cmd_list_element
*ignore
,
1953 completion_tracker
&tracker
,
1954 const char *text
, const char *word
)
1956 reg_or_group_completer_1 (tracker
, text
, word
,
1957 complete_reggroup_names
);
1960 /* The default completer_handle_brkchars implementation. */
1963 default_completer_handle_brkchars (struct cmd_list_element
*ignore
,
1964 completion_tracker
&tracker
,
1965 const char *text
, const char *word
)
1967 set_rl_completer_word_break_characters
1968 (current_language
->word_break_characters ());
1971 /* See definition in completer.h. */
1973 completer_handle_brkchars_ftype
*
1974 completer_handle_brkchars_func_for_completer (completer_ftype
*fn
)
1976 if (fn
== filename_completer
)
1977 return filename_completer_handle_brkchars
;
1979 if (fn
== location_completer
)
1980 return location_completer_handle_brkchars
;
1982 if (fn
== command_completer
)
1983 return command_completer_handle_brkchars
;
1985 return default_completer_handle_brkchars
;
1988 /* Used as brkchars when we want to tell readline we have a custom
1989 word point. We do that by making our rl_completion_word_break_hook
1990 set RL_POINT to the desired word point, and return the character at
1991 the word break point as the break char. This is two bytes in order
1992 to fit one break character plus the terminating null. */
1993 static char gdb_custom_word_point_brkchars
[2];
1995 /* Since rl_basic_quote_characters is not completer-specific, we save
1996 its original value here, in order to be able to restore it in
1997 gdb_rl_attempted_completion_function. */
1998 static const char *gdb_org_rl_basic_quote_characters
= rl_basic_quote_characters
;
2000 /* Get the list of chars that are considered as word breaks
2001 for the current command. */
2004 gdb_completion_word_break_characters_throw ()
2006 /* New completion starting. Get rid of the previous tracker and
2008 delete current_completion
.tracker
;
2009 current_completion
.tracker
= new completion_tracker ();
2011 completion_tracker
&tracker
= *current_completion
.tracker
;
2013 complete_line_internal (tracker
, NULL
, rl_line_buffer
,
2014 rl_point
, handle_brkchars
);
2016 if (tracker
.use_custom_word_point ())
2018 gdb_assert (tracker
.custom_word_point () > 0);
2019 rl_point
= tracker
.custom_word_point () - 1;
2021 gdb_assert (rl_point
>= 0 && rl_point
< strlen (rl_line_buffer
));
2023 gdb_custom_word_point_brkchars
[0] = rl_line_buffer
[rl_point
];
2024 rl_completer_word_break_characters
= gdb_custom_word_point_brkchars
;
2025 rl_completer_quote_characters
= NULL
;
2027 /* Clear this too, so that if we're completing a quoted string,
2028 readline doesn't consider the quote character a delimiter.
2029 If we didn't do this, readline would auto-complete {b
2030 'fun<tab>} to {'b 'function()'}, i.e., add the terminating
2031 \', but, it wouldn't append the separator space either, which
2032 is not desirable. So instead we take care of appending the
2033 quote character to the LCD ourselves, in
2034 gdb_rl_attempted_completion_function. Since this global is
2035 not just completer-specific, we'll restore it back to the
2036 default in gdb_rl_attempted_completion_function. */
2037 rl_basic_quote_characters
= NULL
;
2040 return rl_completer_word_break_characters
;
2044 gdb_completion_word_break_characters ()
2046 /* New completion starting. */
2047 current_completion
.aborted
= false;
2051 return gdb_completion_word_break_characters_throw ();
2053 catch (const gdb_exception
&ex
)
2055 /* Set this to that gdb_rl_attempted_completion_function knows
2057 current_completion
.aborted
= true;
2063 /* See completer.h. */
2066 completion_find_completion_word (completion_tracker
&tracker
, const char *text
,
2069 size_t point
= strlen (text
);
2071 complete_line_internal (tracker
, NULL
, text
, point
, handle_brkchars
);
2073 if (tracker
.use_custom_word_point ())
2075 gdb_assert (tracker
.custom_word_point () > 0);
2076 *quote_char
= tracker
.quote_char ();
2077 return text
+ tracker
.custom_word_point ();
2080 gdb_rl_completion_word_info info
;
2082 info
.word_break_characters
= rl_completer_word_break_characters
;
2083 info
.quote_characters
= gdb_completer_quote_characters
;
2084 info
.basic_quote_characters
= rl_basic_quote_characters
;
2086 return gdb_rl_find_completion_word (&info
, quote_char
, NULL
, text
);
2089 /* See completer.h. */
2092 completion_tracker::recompute_lcd_visitor (completion_hash_entry
*entry
)
2094 if (!m_lowest_common_denominator_valid
)
2096 /* This is the first lowest common denominator that we are
2097 considering, just copy it in. */
2098 strcpy (m_lowest_common_denominator
, entry
->get_lcd ());
2099 m_lowest_common_denominator_unique
= true;
2100 m_lowest_common_denominator_valid
= true;
2104 /* Find the common denominator between the currently-known lowest
2105 common denominator and NEW_MATCH_UP. That becomes the new lowest
2106 common denominator. */
2108 const char *new_match
= entry
->get_lcd ();
2111 (new_match
[i
] != '\0'
2112 && new_match
[i
] == m_lowest_common_denominator
[i
]);
2115 if (m_lowest_common_denominator
[i
] != new_match
[i
])
2117 m_lowest_common_denominator
[i
] = '\0';
2118 m_lowest_common_denominator_unique
= false;
2123 /* See completer.h. */
2126 completion_tracker::recompute_lowest_common_denominator ()
2128 /* We've already done this. */
2129 if (m_lowest_common_denominator_valid
)
2132 /* Resize the storage to ensure we have enough space, the plus one gives
2133 us space for the trailing null terminator we will include. */
2134 m_lowest_common_denominator
2135 = (char *) xrealloc (m_lowest_common_denominator
,
2136 m_lowest_common_denominator_max_length
+ 1);
2138 /* Callback used to visit each entry in the m_entries_hash. */
2140 = [] (void **slot
, void *info
) -> int
2142 completion_tracker
*obj
= (completion_tracker
*) info
;
2143 completion_hash_entry
*entry
= (completion_hash_entry
*) *slot
;
2144 obj
->recompute_lcd_visitor (entry
);
2148 htab_traverse (m_entries_hash
.get (), visitor_func
, this);
2149 m_lowest_common_denominator_valid
= true;
2152 /* See completer.h. */
2155 completion_tracker::advance_custom_word_point_by (int len
)
2157 m_custom_word_point
+= len
;
2160 /* Build a new C string that is a copy of LCD with the whitespace of
2161 ORIG/ORIG_LEN preserved.
2163 Say the user is completing a symbol name, with spaces, like:
2167 and the resulting completion match is:
2171 we want to end up with an input line like:
2174 ^^^^^^^ => text from LCD [1], whitespace from ORIG preserved.
2175 ^^ => new text from LCD
2177 [1] - We must take characters from the LCD instead of the original
2178 text, since some completions want to change upper/lowercase. E.g.:
2184 "handle SIG[QUIT|etc.]"
2188 expand_preserving_ws (const char *orig
, size_t orig_len
,
2191 const char *p_orig
= orig
;
2192 const char *orig_end
= orig
+ orig_len
;
2193 const char *p_lcd
= lcd
;
2196 while (p_orig
< orig_end
)
2200 while (p_orig
< orig_end
&& *p_orig
== ' ')
2202 p_lcd
= skip_spaces (p_lcd
);
2206 /* Take characters from the LCD instead of the original
2207 text, since some completions change upper/lowercase.
2211 "handle SIG[QUIT|etc.]"
2219 while (*p_lcd
!= '\0')
2222 return xstrdup (res
.c_str ());
2225 /* See completer.h. */
2228 completion_tracker::build_completion_result (const char *text
,
2231 size_t element_count
= htab_elements (m_entries_hash
.get ());
2233 if (element_count
== 0)
2236 /* +1 for the LCD, and +1 for NULL termination. */
2237 char **match_list
= XNEWVEC (char *, 1 + element_count
+ 1);
2239 /* Build replacement word, based on the LCD. */
2241 recompute_lowest_common_denominator ();
2243 = expand_preserving_ws (text
, end
- start
,
2244 m_lowest_common_denominator
);
2246 if (m_lowest_common_denominator_unique
)
2248 /* We don't rely on readline appending the quote char as
2249 delimiter as then readline wouldn't append the ' ' after the
2251 char buf
[2] = { (char) quote_char () };
2253 match_list
[0] = reconcat (match_list
[0], match_list
[0],
2254 buf
, (char *) NULL
);
2255 match_list
[1] = NULL
;
2257 /* If the tracker wants to, or we already have a space at the
2258 end of the match, tell readline to skip appending
2260 char *match
= match_list
[0];
2261 bool completion_suppress_append
2262 = (suppress_append_ws ()
2263 || (match
[0] != '\0'
2264 && match
[strlen (match
) - 1] == ' '));
2266 return completion_result (match_list
, 1, completion_suppress_append
);
2270 /* State object used while building the completion list. */
2273 list_builder (char **ml
)
2278 /* The list we are filling. */
2281 /* The next index in the list to write to. */
2284 list_builder
builder (match_list
);
2286 /* Visit each entry in m_entries_hash and add it to the completion
2287 list, updating the builder state object. */
2289 = [] (void **slot
, void *info
) -> int
2291 completion_hash_entry
*entry
= (completion_hash_entry
*) *slot
;
2292 list_builder
*state
= (list_builder
*) info
;
2294 state
->match_list
[state
->index
] = entry
->release_name ();
2299 /* Build the completion list and add a null at the end. */
2300 htab_traverse_noresize (m_entries_hash
.get (), func
, &builder
);
2301 match_list
[builder
.index
] = NULL
;
2303 return completion_result (match_list
, builder
.index
- 1, false);
2307 /* See completer.h */
2309 completion_result::completion_result ()
2310 : match_list (NULL
), number_matches (0),
2311 completion_suppress_append (false)
2314 /* See completer.h */
2316 completion_result::completion_result (char **match_list_
,
2317 size_t number_matches_
,
2318 bool completion_suppress_append_
)
2319 : match_list (match_list_
),
2320 number_matches (number_matches_
),
2321 completion_suppress_append (completion_suppress_append_
)
2324 /* See completer.h */
2326 completion_result::~completion_result ()
2328 reset_match_list ();
2331 /* See completer.h */
2333 completion_result::completion_result (completion_result
&&rhs
) noexcept
2334 : match_list (rhs
.match_list
),
2335 number_matches (rhs
.number_matches
)
2337 rhs
.match_list
= NULL
;
2338 rhs
.number_matches
= 0;
2341 /* See completer.h */
2344 completion_result::release_match_list ()
2346 char **ret
= match_list
;
2351 /* See completer.h */
2354 completion_result::sort_match_list ()
2356 if (number_matches
> 1)
2358 /* Element 0 is special (it's the common prefix), leave it
2360 std::sort (&match_list
[1],
2361 &match_list
[number_matches
+ 1],
2366 /* See completer.h */
2369 completion_result::reset_match_list ()
2371 if (match_list
!= NULL
)
2373 for (char **p
= match_list
; *p
!= NULL
; p
++)
2380 /* Helper for gdb_rl_attempted_completion_function, which does most of
2381 the work. This is called by readline to build the match list array
2382 and to determine the lowest common denominator. The real matches
2383 list starts at match[1], while match[0] is the slot holding
2384 readline's idea of the lowest common denominator of all matches,
2385 which is what readline replaces the completion "word" with.
2387 TEXT is the caller's idea of the "word" we are looking at, as
2388 computed in the handle_brkchars phase.
2390 START is the offset from RL_LINE_BUFFER where TEXT starts. END is
2391 the offset from RL_LINE_BUFFER where TEXT ends (i.e., where
2394 You should thus pretend that the line ends at END (relative to
2397 RL_LINE_BUFFER contains the entire text of the line. RL_POINT is
2398 the offset in that line of the cursor. You should pretend that the
2401 Returns NULL if there are no completions. */
2404 gdb_rl_attempted_completion_function_throw (const char *text
, int start
, int end
)
2406 /* Completers that provide a custom word point in the
2407 handle_brkchars phase also compute their completions then.
2408 Completers that leave the completion word handling to readline
2409 must be called twice. If rl_point (i.e., END) is at column 0,
2410 then readline skips the handle_brkchars phase, and so we create a
2411 tracker now in that case too. */
2412 if (end
== 0 || !current_completion
.tracker
->use_custom_word_point ())
2414 delete current_completion
.tracker
;
2415 current_completion
.tracker
= new completion_tracker ();
2417 complete_line (*current_completion
.tracker
, text
,
2418 rl_line_buffer
, rl_point
);
2421 completion_tracker
&tracker
= *current_completion
.tracker
;
2423 completion_result result
2424 = tracker
.build_completion_result (text
, start
, end
);
2426 rl_completion_suppress_append
= result
.completion_suppress_append
;
2427 return result
.release_match_list ();
2430 /* Function installed as "rl_attempted_completion_function" readline
2431 hook. Wrapper around gdb_rl_attempted_completion_function_throw
2432 that catches C++ exceptions, which can't cross readline. */
2435 gdb_rl_attempted_completion_function (const char *text
, int start
, int end
)
2437 /* Restore globals that might have been tweaked in
2438 gdb_completion_word_break_characters. */
2439 rl_basic_quote_characters
= gdb_org_rl_basic_quote_characters
;
2441 /* If we end up returning NULL, either on error, or simple because
2442 there are no matches, inhibit readline's default filename
2444 rl_attempted_completion_over
= 1;
2446 /* If the handle_brkchars phase was aborted, don't try
2448 if (current_completion
.aborted
)
2453 return gdb_rl_attempted_completion_function_throw (text
, start
, end
);
2455 catch (const gdb_exception
&ex
)
2462 /* Skip over the possibly quoted word STR (as defined by the quote
2463 characters QUOTECHARS and the word break characters BREAKCHARS).
2464 Returns pointer to the location after the "word". If either
2465 QUOTECHARS or BREAKCHARS is NULL, use the same values used by the
2469 skip_quoted_chars (const char *str
, const char *quotechars
,
2470 const char *breakchars
)
2472 char quote_char
= '\0';
2475 if (quotechars
== NULL
)
2476 quotechars
= gdb_completer_quote_characters
;
2478 if (breakchars
== NULL
)
2479 breakchars
= current_language
->word_break_characters ();
2481 for (scan
= str
; *scan
!= '\0'; scan
++)
2483 if (quote_char
!= '\0')
2485 /* Ignore everything until the matching close quote char. */
2486 if (*scan
== quote_char
)
2488 /* Found matching close quote. */
2493 else if (strchr (quotechars
, *scan
))
2495 /* Found start of a quoted string. */
2498 else if (strchr (breakchars
, *scan
))
2507 /* Skip over the possibly quoted word STR (as defined by the quote
2508 characters and word break characters used by the completer).
2509 Returns pointer to the location after the "word". */
2512 skip_quoted (const char *str
)
2514 return skip_quoted_chars (str
, NULL
, NULL
);
2517 /* Return a message indicating that the maximum number of completions
2518 has been reached and that there may be more. */
2521 get_max_completions_reached_message (void)
2523 return _("*** List may be truncated, max-completions reached. ***");
2526 /* GDB replacement for rl_display_match_list.
2527 Readline doesn't provide a clean interface for TUI(curses).
2528 A hack previously used was to send readline's rl_outstream through a pipe
2529 and read it from the event loop. Bleah. IWBN if readline abstracted
2530 away all the necessary bits, and this is what this code does. It
2531 replicates the parts of readline we need and then adds an abstraction
2532 layer, currently implemented as struct match_list_displayer, so that both
2533 CLI and TUI can use it. We copy all this readline code to minimize
2534 GDB-specific mods to readline. Once this code performs as desired then
2535 we can submit it to the readline maintainers.
2537 N.B. A lot of the code is the way it is in order to minimize differences
2538 from readline's copy. */
2540 /* Not supported here. */
2541 #undef VISIBLE_STATS
2543 #if defined (HANDLE_MULTIBYTE)
2544 #define MB_INVALIDCH(x) ((x) == (size_t)-1 || (x) == (size_t)-2)
2545 #define MB_NULLWCH(x) ((x) == 0)
2548 #define ELLIPSIS_LEN 3
2550 /* gdb version of readline/complete.c:get_y_or_n.
2551 'y' -> returns 1, and 'n' -> returns 0.
2552 Also supported: space == 'y', RUBOUT == 'n', ctrl-g == start over.
2553 If FOR_PAGER is non-zero, then also supported are:
2554 NEWLINE or RETURN -> returns 2, and 'q' -> returns 0. */
2557 gdb_get_y_or_n (int for_pager
, const struct match_list_displayer
*displayer
)
2563 RL_SETSTATE (RL_STATE_MOREINPUT
);
2564 c
= displayer
->read_key (displayer
);
2565 RL_UNSETSTATE (RL_STATE_MOREINPUT
);
2567 if (c
== 'y' || c
== 'Y' || c
== ' ')
2569 if (c
== 'n' || c
== 'N' || c
== RUBOUT
)
2571 if (c
== ABORT_CHAR
|| c
< 0)
2573 /* Readline doesn't erase_entire_line here, but without it the
2574 --More-- prompt isn't erased and neither is the text entered
2575 thus far redisplayed. */
2576 displayer
->erase_entire_line (displayer
);
2577 /* Note: The arguments to rl_abort are ignored. */
2580 if (for_pager
&& (c
== NEWLINE
|| c
== RETURN
))
2582 if (for_pager
&& (c
== 'q' || c
== 'Q'))
2584 displayer
->beep (displayer
);
2588 /* Pager function for tab-completion.
2589 This is based on readline/complete.c:_rl_internal_pager.
2590 LINES is the number of lines of output displayed thus far.
2592 -1 -> user pressed 'n' or equivalent,
2593 0 -> user pressed 'y' or equivalent,
2594 N -> user pressed NEWLINE or equivalent and N is LINES - 1. */
2597 gdb_display_match_list_pager (int lines
,
2598 const struct match_list_displayer
*displayer
)
2602 displayer
->puts (displayer
, "--More--");
2603 displayer
->flush (displayer
);
2604 i
= gdb_get_y_or_n (1, displayer
);
2605 displayer
->erase_entire_line (displayer
);
2614 /* Return non-zero if FILENAME is a directory.
2615 Based on readline/complete.c:path_isdir. */
2618 gdb_path_isdir (const char *filename
)
2622 return (stat (filename
, &finfo
) == 0 && S_ISDIR (finfo
.st_mode
));
2625 /* Return the portion of PATHNAME that should be output when listing
2626 possible completions. If we are hacking filename completion, we
2627 are only interested in the basename, the portion following the
2628 final slash. Otherwise, we return what we were passed. Since
2629 printing empty strings is not very informative, if we're doing
2630 filename completion, and the basename is the empty string, we look
2631 for the previous slash and return the portion following that. If
2632 there's no previous slash, we just return what we were passed.
2634 Based on readline/complete.c:printable_part. */
2637 gdb_printable_part (char *pathname
)
2641 if (rl_filename_completion_desired
== 0) /* don't need to do anything */
2644 temp
= strrchr (pathname
, '/');
2645 #if defined (__MSDOS__)
2646 if (temp
== 0 && ISALPHA ((unsigned char)pathname
[0]) && pathname
[1] == ':')
2647 temp
= pathname
+ 1;
2650 if (temp
== 0 || *temp
== '\0')
2652 /* If the basename is NULL, we might have a pathname like '/usr/src/'.
2653 Look for a previous slash and, if one is found, return the portion
2654 following that slash. If there's no previous slash, just return the
2655 pathname we were passed. */
2656 else if (temp
[1] == '\0')
2658 for (x
= temp
- 1; x
> pathname
; x
--)
2661 return ((*x
== '/') ? x
+ 1 : pathname
);
2667 /* Compute width of STRING when displayed on screen by print_filename.
2668 Based on readline/complete.c:fnwidth. */
2671 gdb_fnwidth (const char *string
)
2674 #if defined (HANDLE_MULTIBYTE)
2680 left
= strlen (string
) + 1;
2681 memset (&ps
, 0, sizeof (mbstate_t));
2687 if (CTRL_CHAR (string
[pos
]) || string
[pos
] == RUBOUT
)
2694 #if defined (HANDLE_MULTIBYTE)
2695 clen
= mbrtowc (&wc
, string
+ pos
, left
- pos
, &ps
);
2696 if (MB_INVALIDCH (clen
))
2700 memset (&ps
, 0, sizeof (mbstate_t));
2702 else if (MB_NULLWCH (clen
))
2708 width
+= (w
>= 0) ? w
: 1;
2720 /* Print TO_PRINT, one matching completion.
2721 PREFIX_BYTES is number of common prefix bytes.
2722 Based on readline/complete.c:fnprint. */
2725 gdb_fnprint (const char *to_print
, int prefix_bytes
,
2726 const struct match_list_displayer
*displayer
)
2730 #if defined (HANDLE_MULTIBYTE)
2737 end
= to_print
+ strlen (to_print
) + 1;
2738 memset (&ps
, 0, sizeof (mbstate_t));
2743 /* Don't print only the ellipsis if the common prefix is one of the
2744 possible completions */
2745 if (to_print
[prefix_bytes
] == '\0')
2752 ellipsis
= (to_print
[prefix_bytes
] == '.') ? '_' : '.';
2753 for (w
= 0; w
< ELLIPSIS_LEN
; w
++)
2754 displayer
->putch (displayer
, ellipsis
);
2755 printed_len
= ELLIPSIS_LEN
;
2758 s
= to_print
+ prefix_bytes
;
2763 displayer
->putch (displayer
, '^');
2764 displayer
->putch (displayer
, UNCTRL (*s
));
2767 #if defined (HANDLE_MULTIBYTE)
2768 memset (&ps
, 0, sizeof (mbstate_t));
2771 else if (*s
== RUBOUT
)
2773 displayer
->putch (displayer
, '^');
2774 displayer
->putch (displayer
, '?');
2777 #if defined (HANDLE_MULTIBYTE)
2778 memset (&ps
, 0, sizeof (mbstate_t));
2783 #if defined (HANDLE_MULTIBYTE)
2784 tlen
= mbrtowc (&wc
, s
, end
- s
, &ps
);
2785 if (MB_INVALIDCH (tlen
))
2789 memset (&ps
, 0, sizeof (mbstate_t));
2791 else if (MB_NULLWCH (tlen
))
2796 width
= (w
>= 0) ? w
: 1;
2798 for (w
= 0; w
< tlen
; ++w
)
2799 displayer
->putch (displayer
, s
[w
]);
2801 printed_len
+= width
;
2803 displayer
->putch (displayer
, *s
);
2813 /* Output TO_PRINT to rl_outstream. If VISIBLE_STATS is defined and we
2814 are using it, check for and output a single character for `special'
2815 filenames. Return the number of characters we output.
2816 Based on readline/complete.c:print_filename. */
2819 gdb_print_filename (char *to_print
, char *full_pathname
, int prefix_bytes
,
2820 const struct match_list_displayer
*displayer
)
2822 int printed_len
, extension_char
, slen
, tlen
;
2823 char *s
, c
, *new_full_pathname
;
2825 extern int _rl_complete_mark_directories
;
2828 printed_len
= gdb_fnprint (to_print
, prefix_bytes
, displayer
);
2830 #if defined (VISIBLE_STATS)
2831 if (rl_filename_completion_desired
&& (rl_visible_stats
|| _rl_complete_mark_directories
))
2833 if (rl_filename_completion_desired
&& _rl_complete_mark_directories
)
2836 /* If to_print != full_pathname, to_print is the basename of the
2837 path passed. In this case, we try to expand the directory
2838 name before checking for the stat character. */
2839 if (to_print
!= full_pathname
)
2841 /* Terminate the directory name. */
2843 to_print
[-1] = '\0';
2845 /* If setting the last slash in full_pathname to a NUL results in
2846 full_pathname being the empty string, we are trying to complete
2847 files in the root directory. If we pass a null string to the
2848 bash directory completion hook, for example, it will expand it
2849 to the current directory. We just want the `/'. */
2850 if (full_pathname
== 0 || *full_pathname
== 0)
2852 else if (full_pathname
[0] != '/')
2854 else if (full_pathname
[1] == 0)
2855 dn
= "//"; /* restore trailing slash to `//' */
2856 else if (full_pathname
[1] == '/' && full_pathname
[2] == 0)
2857 dn
= "/"; /* don't turn /// into // */
2860 s
= tilde_expand (dn
);
2861 if (rl_directory_completion_hook
)
2862 (*rl_directory_completion_hook
) (&s
);
2865 tlen
= strlen (to_print
);
2866 new_full_pathname
= (char *)xmalloc (slen
+ tlen
+ 2);
2867 strcpy (new_full_pathname
, s
);
2868 if (s
[slen
- 1] == '/')
2871 new_full_pathname
[slen
] = '/';
2872 new_full_pathname
[slen
] = '/';
2873 strcpy (new_full_pathname
+ slen
+ 1, to_print
);
2875 #if defined (VISIBLE_STATS)
2876 if (rl_visible_stats
)
2877 extension_char
= stat_char (new_full_pathname
);
2880 if (gdb_path_isdir (new_full_pathname
))
2881 extension_char
= '/';
2883 xfree (new_full_pathname
);
2888 s
= tilde_expand (full_pathname
);
2889 #if defined (VISIBLE_STATS)
2890 if (rl_visible_stats
)
2891 extension_char
= stat_char (s
);
2894 if (gdb_path_isdir (s
))
2895 extension_char
= '/';
2901 displayer
->putch (displayer
, extension_char
);
2909 /* GDB version of readline/complete.c:complete_get_screenwidth. */
2912 gdb_complete_get_screenwidth (const struct match_list_displayer
*displayer
)
2914 /* Readline has other stuff here which it's not clear we need. */
2915 return displayer
->width
;
2918 extern int _rl_completion_prefix_display_length
;
2919 extern int _rl_print_completions_horizontally
;
2921 EXTERN_C
int _rl_qsort_string_compare (const void *, const void *);
2922 typedef int QSFUNC (const void *, const void *);
2924 /* GDB version of readline/complete.c:rl_display_match_list.
2925 See gdb_display_match_list for a description of MATCHES, LEN, MAX.
2926 Returns non-zero if all matches are displayed. */
2929 gdb_display_match_list_1 (char **matches
, int len
, int max
,
2930 const struct match_list_displayer
*displayer
)
2932 int count
, limit
, printed_len
, lines
, cols
;
2933 int i
, j
, k
, l
, common_length
, sind
;
2935 int page_completions
= displayer
->height
!= INT_MAX
&& pagination_enabled
;
2937 /* Find the length of the prefix common to all items: length as displayed
2938 characters (common_length) and as a byte index into the matches (sind) */
2939 common_length
= sind
= 0;
2940 if (_rl_completion_prefix_display_length
> 0)
2942 t
= gdb_printable_part (matches
[0]);
2943 temp
= strrchr (t
, '/');
2944 common_length
= temp
? gdb_fnwidth (temp
) : gdb_fnwidth (t
);
2945 sind
= temp
? strlen (temp
) : strlen (t
);
2947 if (common_length
> _rl_completion_prefix_display_length
&& common_length
> ELLIPSIS_LEN
)
2948 max
-= common_length
- ELLIPSIS_LEN
;
2950 common_length
= sind
= 0;
2953 /* How many items of MAX length can we fit in the screen window? */
2954 cols
= gdb_complete_get_screenwidth (displayer
);
2957 if (limit
!= 1 && (limit
* max
== cols
))
2960 /* If cols == 0, limit will end up -1 */
2961 if (cols
< displayer
->width
&& limit
< 0)
2964 /* Avoid a possible floating exception. If max > cols,
2965 limit will be 0 and a divide-by-zero fault will result. */
2969 /* How many iterations of the printing loop? */
2970 count
= (len
+ (limit
- 1)) / limit
;
2972 /* Watch out for special case. If LEN is less than LIMIT, then
2973 just do the inner printing loop.
2974 0 < len <= limit implies count = 1. */
2976 /* Sort the items if they are not already sorted. */
2977 if (rl_ignore_completion_duplicates
== 0 && rl_sort_completion_matches
)
2978 qsort (matches
+ 1, len
, sizeof (char *), (QSFUNC
*)_rl_qsort_string_compare
);
2980 displayer
->crlf (displayer
);
2983 if (_rl_print_completions_horizontally
== 0)
2985 /* Print the sorted items, up-and-down alphabetically, like ls. */
2986 for (i
= 1; i
<= count
; i
++)
2988 for (j
= 0, l
= i
; j
< limit
; j
++)
2990 if (l
> len
|| matches
[l
] == 0)
2994 temp
= gdb_printable_part (matches
[l
]);
2995 printed_len
= gdb_print_filename (temp
, matches
[l
], sind
,
2999 for (k
= 0; k
< max
- printed_len
; k
++)
3000 displayer
->putch (displayer
, ' ');
3004 displayer
->crlf (displayer
);
3006 if (page_completions
&& lines
>= (displayer
->height
- 1) && i
< count
)
3008 lines
= gdb_display_match_list_pager (lines
, displayer
);
3016 /* Print the sorted items, across alphabetically, like ls -x. */
3017 for (i
= 1; matches
[i
]; i
++)
3019 temp
= gdb_printable_part (matches
[i
]);
3020 printed_len
= gdb_print_filename (temp
, matches
[i
], sind
, displayer
);
3021 /* Have we reached the end of this line? */
3024 if (i
&& (limit
> 1) && (i
% limit
) == 0)
3026 displayer
->crlf (displayer
);
3028 if (page_completions
&& lines
>= displayer
->height
- 1)
3030 lines
= gdb_display_match_list_pager (lines
, displayer
);
3036 for (k
= 0; k
< max
- printed_len
; k
++)
3037 displayer
->putch (displayer
, ' ');
3040 displayer
->crlf (displayer
);
3046 /* Utility for displaying completion list matches, used by both CLI and TUI.
3048 MATCHES is the list of strings, in argv format, LEN is the number of
3049 strings in MATCHES, and MAX is the length of the longest string in
3053 gdb_display_match_list (char **matches
, int len
, int max
,
3054 const struct match_list_displayer
*displayer
)
3056 /* Readline will never call this if complete_line returned NULL. */
3057 gdb_assert (max_completions
!= 0);
3059 /* complete_line will never return more than this. */
3060 if (max_completions
> 0)
3061 gdb_assert (len
<= max_completions
);
3063 if (rl_completion_query_items
> 0 && len
>= rl_completion_query_items
)
3067 /* We can't use *query here because they wait for <RET> which is
3068 wrong here. This follows the readline version as closely as possible
3069 for compatibility's sake. See readline/complete.c. */
3071 displayer
->crlf (displayer
);
3073 xsnprintf (msg
, sizeof (msg
),
3074 "Display all %d possibilities? (y or n)", len
);
3075 displayer
->puts (displayer
, msg
);
3076 displayer
->flush (displayer
);
3078 if (gdb_get_y_or_n (0, displayer
) == 0)
3080 displayer
->crlf (displayer
);
3085 if (gdb_display_match_list_1 (matches
, len
, max
, displayer
))
3087 /* Note: MAX_COMPLETIONS may be -1 or zero, but LEN is always > 0. */
3088 if (len
== max_completions
)
3090 /* The maximum number of completions has been reached. Warn the user
3091 that there may be more. */
3092 const char *message
= get_max_completions_reached_message ();
3094 displayer
->puts (displayer
, message
);
3095 displayer
->crlf (displayer
);
3100 void _initialize_completer ();
3102 _initialize_completer ()
3104 add_setshow_zuinteger_unlimited_cmd ("max-completions", no_class
,
3105 &max_completions
, _("\
3106 Set maximum number of completion candidates."), _("\
3107 Show maximum number of completion candidates."), _("\
3108 Use this to limit the number of candidates considered\n\
3109 during completion. Specifying \"unlimited\" or -1\n\
3110 disables limiting. Note that setting either no limit or\n\
3111 a very large limit can make completion slow."),
3112 NULL
, NULL
, &setlist
, &showlist
);