1 /* Line completion stuff for GDB, the GNU debugger.
2 Copyright (C) 2000-2017 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "expression.h"
23 #include "filenames.h" /* For DOSish file names. */
25 #include "gdb_signals.h"
27 #include "reggroups.h"
28 #include "user-regs.h"
29 #include "arch-utils.h"
33 #include "cli/cli-decode.h"
35 /* FIXME: This is needed because of lookup_cmd_1 (). We should be
36 calling a hook instead so we eliminate the CLI dependency. */
39 /* Needed for rl_completer_word_break_characters() and for
40 rl_filename_completion_function. */
41 #include "readline/readline.h"
43 /* readline defines this. */
46 #include "completer.h"
48 static void complete_expression (completion_tracker
&tracker
,
49 const char *text
, const char *word
);
51 /* Misc state that needs to be tracked across several different
52 readline completer entry point calls, all related to a single
53 completion invocation. */
55 struct gdb_completer_state
57 /* The current completion's completion tracker. This is a global
58 because a tracker can be shared between the handle_brkchars and
59 handle_completion phases, which involves different readline
61 completion_tracker
*tracker
= NULL
;
63 /* Whether the current completion was aborted. */
67 /* The current completion state. */
68 static gdb_completer_state current_completion
;
70 /* An enumeration of the various things a user might attempt to
71 complete for a location. If you change this, remember to update
72 the explicit_options array below too. */
74 enum explicit_location_match_type
76 /* The filename of a source file. */
79 /* The 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
)
157 VEC (char_ptr
) *return_val
= NULL
;
164 p
= rl_filename_completion_function (text
, subsequent_name
);
167 /* We need to set subsequent_name to a non-zero value before the
168 continue line below, because otherwise, if the first file
169 seen by GDB is a backup file whose name ends in a `~', we
170 will loop indefinitely. */
172 /* Like emacs, don't complete on old versions. Especially
173 useful in the "source" command. */
174 if (p
[strlen (p
) - 1] == '~')
181 /* Return exactly p. */
183 else if (word
> text
)
185 /* Return some portion of p. */
186 q
= (char *) xmalloc (strlen (p
) + 5);
187 strcpy (q
, p
+ (word
- text
));
192 /* Return some of TEXT plus p. */
193 q
= (char *) xmalloc (strlen (p
) + (text
- word
) + 5);
194 strncpy (q
, word
, text
- word
);
195 q
[text
- word
] = '\0';
199 tracker
.add_completion (gdb::unique_xmalloc_ptr
<char> (q
));
202 /* There is no way to do this just long enough to affect quote
203 inserting without also affecting the next completion. This
204 should be fixed in readline. FIXME. */
205 /* Ensure that readline does the right thing
206 with respect to inserting quotes. */
207 rl_completer_word_break_characters
= "";
211 /* The corresponding completer_handle_brkchars
215 filename_completer_handle_brkchars (struct cmd_list_element
*ignore
,
216 completion_tracker
&tracker
,
217 const char *text
, const char *word
)
219 set_rl_completer_word_break_characters
220 (gdb_completer_file_name_break_characters
);
223 /* Possible values for the found_quote flags word used by the completion
224 functions. It says what kind of (shell-like) quoting we found anywhere
226 #define RL_QF_SINGLE_QUOTE 0x01
227 #define RL_QF_DOUBLE_QUOTE 0x02
228 #define RL_QF_BACKSLASH 0x04
229 #define RL_QF_OTHER_QUOTE 0x08
231 /* Find the bounds of the current word for completion purposes, and
232 return a pointer to the end of the word. This mimics (and is a
233 modified version of) readline's _rl_find_completion_word internal
236 This function skips quoted substrings (characters between matched
237 pairs of characters in rl_completer_quote_characters). We try to
238 find an unclosed quoted substring on which to do matching. If one
239 is not found, we use the word break characters to find the
240 boundaries of the current word. QC, if non-null, is set to the
241 opening quote character if we found an unclosed quoted substring,
242 '\0' otherwise. DP, if non-null, is set to the value of the
243 delimiter character that caused a word break. */
245 struct gdb_rl_completion_word_info
247 const char *word_break_characters
;
248 const char *quote_characters
;
249 const char *basic_quote_characters
;
253 gdb_rl_find_completion_word (struct gdb_rl_completion_word_info
*info
,
255 const char *line_buffer
)
257 int scan
, end
, found_quote
, delimiter
, pass_next
, isbrk
;
259 const char *brkchars
;
260 int point
= strlen (line_buffer
);
262 /* The algorithm below does '--point'. Avoid buffer underflow with
274 found_quote
= delimiter
= 0;
277 brkchars
= info
->word_break_characters
;
279 if (info
->quote_characters
!= NULL
)
281 /* We have a list of characters which can be used in pairs to
282 quote substrings for the completer. Try to find the start of
283 an unclosed quoted substring. */
284 /* FOUND_QUOTE is set so we know what kind of quotes we
286 for (scan
= pass_next
= 0;
296 /* Shell-like semantics for single quotes -- don't allow
297 backslash to quote anything in single quotes, especially
298 not the closing quote. If you don't like this, take out
299 the check on the value of quote_char. */
300 if (quote_char
!= '\'' && line_buffer
[scan
] == '\\')
303 found_quote
|= RL_QF_BACKSLASH
;
307 if (quote_char
!= '\0')
309 /* Ignore everything until the matching close quote
311 if (line_buffer
[scan
] == quote_char
)
313 /* Found matching close. Abandon this
319 else if (strchr (info
->quote_characters
, line_buffer
[scan
]))
321 /* Found start of a quoted substring. */
322 quote_char
= line_buffer
[scan
];
324 /* Shell-like quoting conventions. */
325 if (quote_char
== '\'')
326 found_quote
|= RL_QF_SINGLE_QUOTE
;
327 else if (quote_char
== '"')
328 found_quote
|= RL_QF_DOUBLE_QUOTE
;
330 found_quote
|= RL_QF_OTHER_QUOTE
;
335 if (point
== end
&& quote_char
== '\0')
337 /* We didn't find an unclosed quoted substring upon which to do
338 completion, so use the word break characters to find the
339 substring on which to complete. */
342 scan
= line_buffer
[point
];
344 if (strchr (brkchars
, scan
) != 0)
349 /* If we are at an unquoted word break, then advance past it. */
350 scan
= line_buffer
[point
];
354 isbrk
= strchr (brkchars
, scan
) != 0;
358 /* If the character that caused the word break was a quoting
359 character, then remember it as the delimiter. */
360 if (info
->basic_quote_characters
361 && strchr (info
->basic_quote_characters
, scan
)
362 && (end
- point
) > 1)
374 return line_buffer
+ point
;
377 /* See completer.h. */
380 advance_to_expression_complete_word_point (completion_tracker
&tracker
,
383 gdb_rl_completion_word_info info
;
385 info
.word_break_characters
386 = current_language
->la_word_break_characters ();
387 info
.quote_characters
= gdb_completer_quote_characters
;
388 info
.basic_quote_characters
= rl_basic_quote_characters
;
391 = gdb_rl_find_completion_word (&info
, NULL
, NULL
, text
);
393 tracker
.advance_custom_word_point_by (start
- text
);
398 /* See completer.h. */
401 completion_tracker::completes_to_completion_word (const char *word
)
403 if (m_lowest_common_denominator_unique
)
405 const char *lcd
= m_lowest_common_denominator
;
407 if (strncmp_iw (word
, lcd
, strlen (lcd
)) == 0)
409 /* Maybe skip the function and complete on keywords. */
410 size_t wordlen
= strlen (word
);
411 if (word
[wordlen
- 1] == ' ')
419 /* Complete on linespecs, which might be of two possible forms:
425 This is intended to be used in commands that set breakpoints
429 complete_files_symbols (completion_tracker
&tracker
,
430 const char *text
, const char *word
)
433 completion_list fn_list
;
436 int quoted
= *text
== '\'' || *text
== '"';
437 int quote_char
= '\0';
438 const char *colon
= NULL
;
439 char *file_to_match
= NULL
;
440 const char *symbol_start
= text
;
441 const char *orig_text
= text
;
443 /* Do we have an unquoted colon, as in "break foo.c:bar"? */
444 for (p
= text
; *p
!= '\0'; ++p
)
446 if (*p
== '\\' && p
[1] == '\'')
448 else if (*p
== '\'' || *p
== '"')
452 while (*p
!= '\0' && *p
!= quote_found
)
454 if (*p
== '\\' && p
[1] == quote_found
)
459 if (*p
== quote_found
)
462 break; /* Hit the end of text. */
464 #if HAVE_DOS_BASED_FILE_SYSTEM
465 /* If we have a DOS-style absolute file name at the beginning of
466 TEXT, and the colon after the drive letter is the only colon
467 we found, pretend the colon is not there. */
468 else if (p
< text
+ 3 && *p
== ':' && p
== text
+ 1 + quoted
)
471 else if (*p
== ':' && !colon
)
474 symbol_start
= p
+ 1;
476 else if (strchr (current_language
->la_word_break_characters(), *p
))
477 symbol_start
= p
+ 1;
483 /* Where is the file name? */
488 file_to_match
= (char *) xmalloc (colon
- text
+ 1);
489 strncpy (file_to_match
, text
, colon
- text
);
490 file_to_match
[colon
- text
] = '\0';
491 /* Remove trailing colons and quotes from the file name. */
492 for (s
= file_to_match
+ (colon
- text
);
495 if (*s
== ':' || *s
== quote_char
)
498 /* If the text includes a colon, they want completion only on a
499 symbol name after the colon. Otherwise, we need to complete on
500 symbols as well as on files. */
503 collect_file_symbol_completion_matches (tracker
,
504 complete_symbol_mode::EXPRESSION
,
507 xfree (file_to_match
);
511 size_t text_len
= strlen (text
);
513 collect_symbol_completion_matches (tracker
,
514 complete_symbol_mode::EXPRESSION
,
516 /* If text includes characters which cannot appear in a file
517 name, they cannot be asking for completion on files. */
519 gdb_completer_file_name_break_characters
) == text_len
)
520 fn_list
= make_source_files_completion_list (text
, text
);
523 if (!fn_list
.empty () && !tracker
.have_completions ())
527 /* If we only have file names as possible completion, we should
528 bring them in sync with what rl_complete expects. The
529 problem is that if the user types "break /foo/b TAB", and the
530 possible completions are "/foo/bar" and "/foo/baz"
531 rl_complete expects us to return "bar" and "baz", without the
532 leading directories, as possible completions, because `word'
533 starts at the "b". But we ignore the value of `word' when we
534 call make_source_files_completion_list above (because that
535 would not DTRT when the completion results in both symbols
536 and file names), so make_source_files_completion_list returns
537 the full "/foo/bar" and "/foo/baz" strings. This produces
538 wrong results when, e.g., there's only one possible
539 completion, because rl_complete will prepend "/foo/" to each
540 candidate completion. The loop below removes that leading
542 for (const auto &fn_up
: fn_list
)
544 char *fn
= fn_up
.get ();
545 memmove (fn
, fn
+ (word
- text
), strlen (fn
) + 1 - (word
- text
));
549 tracker
.add_completions (std::move (fn_list
));
551 if (!tracker
.have_completions ())
553 /* No completions at all. As the final resort, try completing
554 on the entire text as a symbol. */
555 collect_symbol_completion_matches (tracker
,
556 complete_symbol_mode::EXPRESSION
,
561 /* The explicit location options. Note that indexes into this array
562 must match the explicit_location_match_type enumerators. */
563 static const char *const explicit_options
[] =
572 /* The probe modifier options. These can appear before a location in
573 breakpoint commands. */
574 static const char *const probe_options
[] =
582 /* Returns STRING if not NULL, the empty string otherwise. */
585 string_or_empty (const char *string
)
587 return string
!= NULL
? string
: "";
590 /* A helper function to collect explicit location matches for the given
591 LOCATION, which is attempting to match on WORD. */
594 collect_explicit_location_matches (completion_tracker
&tracker
,
595 struct event_location
*location
,
596 enum explicit_location_match_type what
,
598 const struct language_defn
*language
)
600 const struct explicit_location
*explicit_loc
601 = get_explicit_location (location
);
603 /* Note, in the various MATCH_* below, we complete on
604 explicit_loc->foo instead of WORD, because only the former will
605 have already skipped past any quote char. */
610 const char *source
= string_or_empty (explicit_loc
->source_filename
);
611 completion_list matches
612 = make_source_files_completion_list (source
, source
);
613 tracker
.add_completions (std::move (matches
));
619 const char *function
= string_or_empty (explicit_loc
->function_name
);
620 linespec_complete_function (tracker
, function
,
621 explicit_loc
->source_filename
);
626 /* Nothing to offer. */
634 gdb_assert_not_reached ("unhandled explicit_location_match_type");
637 if (tracker
.completes_to_completion_word (word
))
639 tracker
.discard_completions ();
640 tracker
.advance_custom_word_point_by (strlen (word
));
641 complete_on_enum (tracker
, explicit_options
, "", "");
642 complete_on_enum (tracker
, linespec_keywords
, "", "");
644 else if (!tracker
.have_completions ())
646 /* Maybe we have an unterminated linespec keyword at the tail of
647 the string. Try completing on that. */
648 size_t wordlen
= strlen (word
);
649 const char *keyword
= word
+ wordlen
;
651 if (wordlen
> 0 && keyword
[-1] != ' ')
653 while (keyword
> word
&& *keyword
!= ' ')
655 /* Don't complete on keywords if we'd be completing on the
656 whole explicit linespec option. E.g., "b -function
657 thr<tab>" should not complete to the "thread"
661 keyword
= skip_spaces_const (keyword
);
663 tracker
.advance_custom_word_point_by (keyword
- word
);
664 complete_on_enum (tracker
, linespec_keywords
, keyword
, keyword
);
667 else if (wordlen
> 0 && keyword
[-1] == ' ')
669 /* Assume that we're maybe past the explicit location
670 argument, and we didn't manage to find any match because
671 the user wants to create a pending breakpoint. Offer the
672 keyword and explicit location options as possible
674 tracker
.advance_custom_word_point_by (keyword
- word
);
675 complete_on_enum (tracker
, linespec_keywords
, keyword
, keyword
);
676 complete_on_enum (tracker
, explicit_options
, keyword
, keyword
);
681 /* If the next word in *TEXT_P is any of the keywords in KEYWORDS,
682 then advance both TEXT_P and the word point in the tracker past the
683 keyword and return the (0-based) index in the KEYWORDS array that
684 matched. Otherwise, return -1. */
687 skip_keyword (completion_tracker
&tracker
,
688 const char * const *keywords
, const char **text_p
)
690 const char *text
= *text_p
;
691 const char *after
= skip_to_space_const (text
);
692 size_t len
= after
- text
;
694 if (text
[len
] != ' ')
698 for (int i
= 0; keywords
[i
] != NULL
; i
++)
700 if (strncmp (keywords
[i
], text
, len
) == 0)
711 tracker
.advance_custom_word_point_by (len
+ 1);
720 /* A completer function for explicit locations. This function
721 completes both options ("-source", "-line", etc) and values. If
722 completing a quoted string, then QUOTED_ARG_START and
723 QUOTED_ARG_END point to the quote characters. LANGUAGE is the
727 complete_explicit_location (completion_tracker
&tracker
,
728 struct event_location
*location
,
730 const language_defn
*language
,
731 const char *quoted_arg_start
,
732 const char *quoted_arg_end
)
737 int keyword
= skip_keyword (tracker
, explicit_options
, &text
);
740 complete_on_enum (tracker
, explicit_options
, text
, text
);
743 /* Completing on value. */
744 enum explicit_location_match_type what
745 = (explicit_location_match_type
) keyword
;
747 if (quoted_arg_start
!= NULL
&& quoted_arg_end
!= NULL
)
749 if (quoted_arg_end
[1] == '\0')
751 /* If completing a quoted string with the cursor right
752 at the terminating quote char, complete the
753 completion word without interpretation, so that
754 readline advances the cursor one whitespace past the
755 quote, even if there's no match. This makes these
756 cases behave the same:
758 before: "b -function function()"
759 after: "b -function function() "
761 before: "b -function 'function()'"
762 after: "b -function 'function()' "
764 and trusts the user in this case:
766 before: "b -function 'not_loaded_function_yet()'"
767 after: "b -function 'not_loaded_function_yet()' "
769 gdb::unique_xmalloc_ptr
<char> text_copy
771 tracker
.add_completion (std::move (text_copy
));
773 else if (quoted_arg_end
[1] == ' ')
775 /* We're maybe past the explicit location argument.
776 Skip the argument without interpretion, assuming the
777 user may want to create pending breakpoint. Offer
778 the keyword and explicit location options as possible
780 tracker
.advance_custom_word_point_by (strlen (text
));
781 complete_on_enum (tracker
, linespec_keywords
, "", "");
782 complete_on_enum (tracker
, explicit_options
, "", "");
787 /* Now gather matches */
788 collect_explicit_location_matches (tracker
, location
, what
, text
,
793 /* A completer for locations. */
796 location_completer (struct cmd_list_element
*ignore
,
797 completion_tracker
&tracker
,
798 const char *text
, const char *word_entry
)
800 int found_probe_option
= -1;
802 /* If we have a probe modifier, skip it. This can only appear as
803 first argument. Until we have a specific completer for probes,
804 falling back to the linespec completer for the remainder of the
805 line is better than nothing. */
806 if (text
[0] == '-' && text
[1] == 'p')
807 found_probe_option
= skip_keyword (tracker
, probe_options
, &text
);
809 const char *option_text
= text
;
810 int saved_word_point
= tracker
.custom_word_point ();
812 const char *copy
= text
;
814 explicit_completion_info completion_info
;
815 event_location_up location
816 = string_to_explicit_location (©
, current_language
,
818 if (completion_info
.quoted_arg_start
!= NULL
819 && completion_info
.quoted_arg_end
== NULL
)
821 /* Found an unbalanced quote. */
822 tracker
.set_quote_char (*completion_info
.quoted_arg_start
);
823 tracker
.advance_custom_word_point_by (1);
826 if (location
!= NULL
)
830 tracker
.advance_custom_word_point_by (copy
- text
);
833 /* We found a terminator at the tail end of the string,
834 which means we're past the explicit location options. We
835 may have a keyword to complete on. If we have a whole
836 keyword, then complete whatever comes after as an
837 expression. This is mainly for the "if" keyword. If the
838 "thread" and "task" keywords gain their own completers,
839 they should be used here. */
840 int keyword
= skip_keyword (tracker
, linespec_keywords
, &text
);
844 complete_on_enum (tracker
, linespec_keywords
, text
, text
);
849 = advance_to_expression_complete_word_point (tracker
, text
);
850 complete_expression (tracker
, text
, word
);
855 tracker
.advance_custom_word_point_by (completion_info
.last_option
857 text
= completion_info
.last_option
;
859 complete_explicit_location (tracker
, location
.get (), text
,
861 completion_info
.quoted_arg_start
,
862 completion_info
.quoted_arg_end
);
868 /* This is an address or linespec location. */
871 tracker
.advance_custom_word_point_by (1);
874 = advance_to_expression_complete_word_point (tracker
, text
);
875 complete_expression (tracker
, text
, word
);
879 /* Fall back to the old linespec completer, for now. */
881 if (word_entry
== NULL
)
883 /* We're in the handle_brkchars phase. */
884 tracker
.set_use_custom_word_point (false);
888 complete_files_symbols (tracker
, text
, word_entry
);
892 /* Add matches for option names, if either:
894 - Some completer above found some matches, but the word point did
895 not advance (e.g., "b <tab>" finds all functions, or "b -<tab>"
896 matches all objc selectors), or;
898 - Some completer above advanced the word point, but found no
901 if ((text
[0] == '-' || text
[0] == '\0')
902 && (!tracker
.have_completions ()
903 || tracker
.custom_word_point () == saved_word_point
))
905 tracker
.set_custom_word_point (saved_word_point
);
908 if (found_probe_option
== -1)
909 complete_on_enum (tracker
, probe_options
, text
, text
);
910 complete_on_enum (tracker
, explicit_options
, text
, text
);
914 /* The corresponding completer_handle_brkchars
918 location_completer_handle_brkchars (struct cmd_list_element
*ignore
,
919 completion_tracker
&tracker
,
921 const char *word_ignored
)
923 tracker
.set_use_custom_word_point (true);
925 location_completer (ignore
, tracker
, text
, NULL
);
928 /* Helper for expression_completer which recursively adds field and
929 method names from TYPE, a struct or union type, to the OUTPUT
933 add_struct_fields (struct type
*type
, completion_list
&output
,
934 char *fieldname
, int namelen
)
937 int computed_type_name
= 0;
938 const char *type_name
= NULL
;
940 type
= check_typedef (type
);
941 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
943 if (i
< TYPE_N_BASECLASSES (type
))
944 add_struct_fields (TYPE_BASECLASS (type
, i
),
945 output
, fieldname
, namelen
);
946 else if (TYPE_FIELD_NAME (type
, i
))
948 if (TYPE_FIELD_NAME (type
, i
)[0] != '\0')
950 if (! strncmp (TYPE_FIELD_NAME (type
, i
),
952 output
.emplace_back (xstrdup (TYPE_FIELD_NAME (type
, i
)));
954 else if (TYPE_CODE (TYPE_FIELD_TYPE (type
, i
)) == TYPE_CODE_UNION
)
956 /* Recurse into anonymous unions. */
957 add_struct_fields (TYPE_FIELD_TYPE (type
, i
),
958 output
, fieldname
, namelen
);
963 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
965 const char *name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
967 if (name
&& ! strncmp (name
, fieldname
, namelen
))
969 if (!computed_type_name
)
971 type_name
= type_name_no_tag (type
);
972 computed_type_name
= 1;
974 /* Omit constructors from the completion list. */
975 if (!type_name
|| strcmp (type_name
, name
))
976 output
.emplace_back (xstrdup (name
));
981 /* Complete on expressions. Often this means completing on symbol
982 names, but some language parsers also have support for completing
986 complete_expression (completion_tracker
&tracker
,
987 const char *text
, const char *word
)
989 struct type
*type
= NULL
;
991 enum type_code code
= TYPE_CODE_UNDEF
;
993 /* Perform a tentative parse of the expression, to see whether a
994 field completion is required. */
998 type
= parse_expression_for_completion (text
, &fieldname
, &code
);
1000 CATCH (except
, RETURN_MASK_ERROR
)
1006 if (fieldname
&& type
)
1010 type
= check_typedef (type
);
1011 if (TYPE_CODE (type
) != TYPE_CODE_PTR
&& !TYPE_IS_REFERENCE (type
))
1013 type
= TYPE_TARGET_TYPE (type
);
1016 if (TYPE_CODE (type
) == TYPE_CODE_UNION
1017 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
1019 int flen
= strlen (fieldname
);
1020 completion_list result
;
1022 add_struct_fields (type
, result
, fieldname
, flen
);
1024 tracker
.add_completions (std::move (result
));
1028 else if (fieldname
&& code
!= TYPE_CODE_UNDEF
)
1030 VEC (char_ptr
) *result
;
1031 struct cleanup
*cleanup
= make_cleanup (xfree
, fieldname
);
1033 collect_symbol_completion_matches_type (tracker
, fieldname
, fieldname
,
1035 do_cleanups (cleanup
);
1040 complete_files_symbols (tracker
, text
, word
);
1043 /* Complete on expressions. Often this means completing on symbol
1044 names, but some language parsers also have support for completing
1048 expression_completer (struct cmd_list_element
*ignore
,
1049 completion_tracker
&tracker
,
1050 const char *text
, const char *word
)
1052 complete_expression (tracker
, text
, word
);
1055 /* See definition in completer.h. */
1058 set_rl_completer_word_break_characters (const char *break_chars
)
1060 rl_completer_word_break_characters
= (char *) break_chars
;
1063 /* See definition in completer.h. */
1066 set_gdb_completion_word_break_characters (completer_ftype
*fn
)
1068 const char *break_chars
;
1070 /* So far we are only interested in differentiating filename
1071 completers from everything else. */
1072 if (fn
== filename_completer
)
1073 break_chars
= gdb_completer_file_name_break_characters
;
1075 break_chars
= gdb_completer_command_word_break_characters
;
1077 set_rl_completer_word_break_characters (break_chars
);
1080 /* Complete on symbols. */
1083 symbol_completer (struct cmd_list_element
*ignore
,
1084 completion_tracker
&tracker
,
1085 const char *text
, const char *word
)
1087 collect_symbol_completion_matches (tracker
, complete_symbol_mode::EXPRESSION
,
1091 /* Here are some useful test cases for completion. FIXME: These
1092 should be put in the test suite. They should be tested with both
1095 "show output-" "radix"
1096 "show output" "-radix"
1097 "p" ambiguous (commands starting with p--path, print, printf, etc.)
1098 "p " ambiguous (all symbols)
1099 "info t foo" no completions
1100 "info t " no completions
1101 "info t" ambiguous ("info target", "info terminal", etc.)
1102 "info ajksdlfk" no completions
1103 "info ajksdlfk " no completions
1105 "info " ambiguous (all info commands)
1106 "p \"a" no completions (string constant)
1107 "p 'a" ambiguous (all symbols starting with a)
1108 "p b-a" ambiguous (all symbols starting with a)
1109 "p b-" ambiguous (all symbols)
1110 "file Make" "file" (word break hard to screw up here)
1111 "file ../gdb.stabs/we" "ird" (needs to not break word at slash)
1114 enum complete_line_internal_reason
1116 /* Preliminary phase, called by gdb_completion_word_break_characters
1117 function, is used to either:
1119 #1 - Determine the set of chars that are word delimiters
1120 depending on the current command in line_buffer.
1122 #2 - Manually advance RL_POINT to the "word break" point instead
1123 of letting readline do it (based on too-simple character
1126 Simpler completers that just pass a brkchars array to readline
1127 (#1 above) must defer generating the completions to the main
1128 phase (below). No completion list should be generated in this
1131 OTOH, completers that manually advance the word point(#2 above)
1132 must set "use_custom_word_point" in the tracker and generate
1133 their completion in this phase. Note that this is the convenient
1134 thing to do since they'll be parsing the input line anyway. */
1137 /* Main phase, called by complete_line function, is used to get the
1138 list of possible completions. */
1141 /* Special case when completing a 'help' command. In this case,
1142 once sub-command completions are exhausted, we simply return
1147 /* Helper for complete_line_internal to simplify it. */
1150 complete_line_internal_normal_command (completion_tracker
&tracker
,
1151 const char *command
, const char *word
,
1152 const char *cmd_args
,
1153 complete_line_internal_reason reason
,
1154 struct cmd_list_element
*c
)
1156 const char *p
= cmd_args
;
1158 if (c
->completer
== filename_completer
)
1160 /* Many commands which want to complete on file names accept
1161 several file names, as in "run foo bar >>baz". So we don't
1162 want to complete the entire text after the command, just the
1163 last word. To this end, we need to find the beginning of the
1164 file name by starting at `word' and going backwards. */
1167 && strchr (gdb_completer_file_name_break_characters
,
1173 if (reason
== handle_brkchars
)
1175 completer_handle_brkchars_ftype
*brkchars_fn
;
1177 if (c
->completer_handle_brkchars
!= NULL
)
1178 brkchars_fn
= c
->completer_handle_brkchars
;
1182 = (completer_handle_brkchars_func_for_completer
1186 brkchars_fn (c
, tracker
, p
, word
);
1189 if (reason
!= handle_brkchars
&& c
->completer
!= NULL
)
1190 (*c
->completer
) (c
, tracker
, p
, word
);
1193 /* Internal function used to handle completions.
1196 TEXT is the caller's idea of the "word" we are looking at.
1198 LINE_BUFFER is available to be looked at; it contains the entire
1199 text of the line. POINT is the offset in that line of the cursor.
1200 You should pretend that the line ends at POINT.
1202 See complete_line_internal_reason for description of REASON. */
1205 complete_line_internal_1 (completion_tracker
&tracker
,
1207 const char *line_buffer
, int point
,
1208 complete_line_internal_reason reason
)
1212 int ignore_help_classes
;
1213 /* Pointer within tmp_command which corresponds to text. */
1215 struct cmd_list_element
*c
, *result_list
;
1217 /* Choose the default set of word break characters to break
1218 completions. If we later find out that we are doing completions
1219 on command strings (as opposed to strings supplied by the
1220 individual command completer functions, which can be any string)
1221 then we will switch to the special word break set for command
1222 strings, which leaves out the '-' character used in some
1224 set_rl_completer_word_break_characters
1225 (current_language
->la_word_break_characters());
1227 /* Decide whether to complete on a list of gdb commands or on
1229 tmp_command
= (char *) alloca (point
+ 1);
1232 /* The help command should complete help aliases. */
1233 ignore_help_classes
= reason
!= handle_help
;
1235 strncpy (tmp_command
, line_buffer
, point
);
1236 tmp_command
[point
] = '\0';
1237 if (reason
== handle_brkchars
)
1239 gdb_assert (text
== NULL
);
1244 /* Since text always contains some number of characters leading up
1245 to point, we can find the equivalent position in tmp_command
1246 by subtracting that many characters from the end of tmp_command. */
1247 word
= tmp_command
+ point
- strlen (text
);
1252 /* An empty line we want to consider ambiguous; that is, it
1253 could be any command. */
1254 c
= CMD_LIST_AMBIGUOUS
;
1259 c
= lookup_cmd_1 (&p
, cmdlist
, &result_list
, ignore_help_classes
);
1262 /* Move p up to the next interesting thing. */
1263 while (*p
== ' ' || *p
== '\t')
1268 tracker
.advance_custom_word_point_by (p
- tmp_command
);
1272 /* It is an unrecognized command. So there are no
1273 possible completions. */
1275 else if (c
== CMD_LIST_AMBIGUOUS
)
1279 /* lookup_cmd_1 advances p up to the first ambiguous thing, but
1280 doesn't advance over that thing itself. Do so now. */
1282 while (*q
&& (isalnum (*q
) || *q
== '-' || *q
== '_'))
1284 if (q
!= tmp_command
+ point
)
1286 /* There is something beyond the ambiguous
1287 command, so there are no possible completions. For
1288 example, "info t " or "info t foo" does not complete
1289 to anything, because "info t" can be "info target" or
1294 /* We're trying to complete on the command which was ambiguous.
1295 This we can deal with. */
1298 if (reason
!= handle_brkchars
)
1299 complete_on_cmdlist (*result_list
->prefixlist
, tracker
, p
,
1300 word
, ignore_help_classes
);
1304 if (reason
!= handle_brkchars
)
1305 complete_on_cmdlist (cmdlist
, tracker
, p
, word
,
1306 ignore_help_classes
);
1308 /* Ensure that readline does the right thing with respect to
1309 inserting quotes. */
1310 set_rl_completer_word_break_characters
1311 (gdb_completer_command_word_break_characters
);
1316 /* We've recognized a full command. */
1318 if (p
== tmp_command
+ point
)
1320 /* There is no non-whitespace in the line beyond the
1323 if (p
[-1] == ' ' || p
[-1] == '\t')
1325 /* The command is followed by whitespace; we need to
1326 complete on whatever comes after command. */
1329 /* It is a prefix command; what comes after it is
1330 a subcommand (e.g. "info "). */
1331 if (reason
!= handle_brkchars
)
1332 complete_on_cmdlist (*c
->prefixlist
, tracker
, p
, word
,
1333 ignore_help_classes
);
1335 /* Ensure that readline does the right thing
1336 with respect to inserting quotes. */
1337 set_rl_completer_word_break_characters
1338 (gdb_completer_command_word_break_characters
);
1340 else if (reason
== handle_help
)
1344 if (reason
!= handle_brkchars
)
1345 complete_on_enum (tracker
, c
->enums
, p
, word
);
1346 set_rl_completer_word_break_characters
1347 (gdb_completer_command_word_break_characters
);
1351 /* It is a normal command; what comes after it is
1352 completed by the command's completer function. */
1353 complete_line_internal_normal_command (tracker
,
1354 tmp_command
, word
, p
,
1360 /* The command is not followed by whitespace; we need to
1361 complete on the command itself, e.g. "p" which is a
1362 command itself but also can complete to "print", "ptype"
1366 /* Find the command we are completing on. */
1368 while (q
> tmp_command
)
1370 if (isalnum (q
[-1]) || q
[-1] == '-' || q
[-1] == '_')
1376 if (reason
!= handle_brkchars
)
1377 complete_on_cmdlist (result_list
, tracker
, q
, word
,
1378 ignore_help_classes
);
1380 /* Ensure that readline does the right thing
1381 with respect to inserting quotes. */
1382 set_rl_completer_word_break_characters
1383 (gdb_completer_command_word_break_characters
);
1386 else if (reason
== handle_help
)
1390 /* There is non-whitespace beyond the command. */
1392 if (c
->prefixlist
&& !c
->allow_unknown
)
1394 /* It is an unrecognized subcommand of a prefix command,
1395 e.g. "info adsfkdj". */
1399 if (reason
!= handle_brkchars
)
1400 complete_on_enum (tracker
, c
->enums
, p
, word
);
1404 /* It is a normal command. */
1405 complete_line_internal_normal_command (tracker
,
1406 tmp_command
, word
, p
,
1413 /* Wrapper around complete_line_internal_1 to handle
1414 MAX_COMPLETIONS_REACHED_ERROR. */
1417 complete_line_internal (completion_tracker
&tracker
,
1419 const char *line_buffer
, int point
,
1420 complete_line_internal_reason reason
)
1424 complete_line_internal_1 (tracker
, text
, line_buffer
, point
, reason
);
1426 CATCH (except
, RETURN_MASK_ERROR
)
1428 if (except
.error
!= MAX_COMPLETIONS_REACHED_ERROR
)
1429 throw_exception (except
);
1433 /* See completer.h. */
1435 int max_completions
= 200;
1437 /* Initial size of the table. It automagically grows from here. */
1438 #define INITIAL_COMPLETION_HTAB_SIZE 200
1440 /* See completer.h. */
1442 completion_tracker::completion_tracker ()
1444 m_entries_hash
= htab_create_alloc (INITIAL_COMPLETION_HTAB_SIZE
,
1445 htab_hash_string
, (htab_eq
) streq
,
1446 NULL
, xcalloc
, xfree
);
1449 /* See completer.h. */
1452 completion_tracker::discard_completions ()
1454 xfree (m_lowest_common_denominator
);
1455 m_lowest_common_denominator
= NULL
;
1457 m_lowest_common_denominator_unique
= false;
1459 m_entries_vec
.clear ();
1461 htab_delete (m_entries_hash
);
1462 m_entries_hash
= htab_create_alloc (INITIAL_COMPLETION_HTAB_SIZE
,
1463 htab_hash_string
, (htab_eq
) streq
,
1464 NULL
, xcalloc
, xfree
);
1467 /* See completer.h. */
1469 completion_tracker::~completion_tracker ()
1471 xfree (m_lowest_common_denominator
);
1472 htab_delete (m_entries_hash
);
1475 /* See completer.h. */
1478 completion_tracker::maybe_add_completion (gdb::unique_xmalloc_ptr
<char> name
)
1482 if (max_completions
== 0)
1485 if (htab_elements (m_entries_hash
) >= max_completions
)
1488 slot
= htab_find_slot (m_entries_hash
, name
.get (), INSERT
);
1489 if (*slot
== HTAB_EMPTY_ENTRY
)
1491 const char *match_for_lcd_str
= name
.get ();
1493 recompute_lowest_common_denominator (match_for_lcd_str
);
1495 *slot
= name
.get ();
1496 m_entries_vec
.push_back (std::move (name
));
1502 /* See completer.h. */
1505 completion_tracker::add_completion (gdb::unique_xmalloc_ptr
<char> name
)
1507 if (!maybe_add_completion (std::move (name
)))
1508 throw_error (MAX_COMPLETIONS_REACHED_ERROR
, _("Max completions reached."));
1511 /* See completer.h. */
1514 completion_tracker::add_completions (completion_list
&&list
)
1516 for (auto &candidate
: list
)
1517 add_completion (std::move (candidate
));
1520 /* Generate completions all at once. Does nothing if max_completions
1521 is 0. If max_completions is non-negative, this will collect at
1522 most max_completions strings.
1524 TEXT is the caller's idea of the "word" we are looking at.
1526 LINE_BUFFER is available to be looked at; it contains the entire
1529 POINT is the offset in that line of the cursor. You
1530 should pretend that the line ends at POINT. */
1533 complete_line (completion_tracker
&tracker
,
1534 const char *text
, const char *line_buffer
, int point
)
1536 if (max_completions
== 0)
1538 complete_line_internal (tracker
, text
, line_buffer
, point
,
1539 handle_completions
);
1542 /* Complete on command names. Used by "help". */
1545 command_completer (struct cmd_list_element
*ignore
,
1546 completion_tracker
&tracker
,
1547 const char *text
, const char *word
)
1549 complete_line_internal (tracker
, word
, text
,
1550 strlen (text
), handle_help
);
1553 /* The corresponding completer_handle_brkchars implementation. */
1556 command_completer_handle_brkchars (struct cmd_list_element
*ignore
,
1557 completion_tracker
&tracker
,
1558 const char *text
, const char *word
)
1560 set_rl_completer_word_break_characters
1561 (gdb_completer_command_word_break_characters
);
1564 /* Complete on signals. */
1567 signal_completer (struct cmd_list_element
*ignore
,
1568 completion_tracker
&tracker
,
1569 const char *text
, const char *word
)
1571 size_t len
= strlen (word
);
1573 const char *signame
;
1575 for (signum
= GDB_SIGNAL_FIRST
; signum
!= GDB_SIGNAL_LAST
; ++signum
)
1577 /* Can't handle this, so skip it. */
1578 if (signum
== GDB_SIGNAL_0
)
1581 signame
= gdb_signal_to_name ((enum gdb_signal
) signum
);
1583 /* Ignore the unknown signal case. */
1584 if (!signame
|| strcmp (signame
, "?") == 0)
1587 if (strncasecmp (signame
, word
, len
) == 0)
1589 gdb::unique_xmalloc_ptr
<char> copy (xstrdup (signame
));
1590 tracker
.add_completion (std::move (copy
));
1595 /* Bit-flags for selecting what the register and/or register-group
1596 completer should complete on. */
1598 enum reg_completer_target
1600 complete_register_names
= 0x1,
1601 complete_reggroup_names
= 0x2
1603 DEF_ENUM_FLAGS_TYPE (enum reg_completer_target
, reg_completer_targets
);
1605 /* Complete register names and/or reggroup names based on the value passed
1606 in TARGETS. At least one bit in TARGETS must be set. */
1609 reg_or_group_completer_1 (completion_tracker
&tracker
,
1610 const char *text
, const char *word
,
1611 reg_completer_targets targets
)
1613 size_t len
= strlen (word
);
1614 struct gdbarch
*gdbarch
;
1617 gdb_assert ((targets
& (complete_register_names
1618 | complete_reggroup_names
)) != 0);
1619 gdbarch
= get_current_arch ();
1621 if ((targets
& complete_register_names
) != 0)
1626 (name
= user_reg_map_regnum_to_name (gdbarch
, i
)) != NULL
;
1629 if (*name
!= '\0' && strncmp (word
, name
, len
) == 0)
1631 gdb::unique_xmalloc_ptr
<char> copy (xstrdup (name
));
1632 tracker
.add_completion (std::move (copy
));
1637 if ((targets
& complete_reggroup_names
) != 0)
1639 struct reggroup
*group
;
1641 for (group
= reggroup_next (gdbarch
, NULL
);
1643 group
= reggroup_next (gdbarch
, group
))
1645 name
= reggroup_name (group
);
1646 if (strncmp (word
, name
, len
) == 0)
1648 gdb::unique_xmalloc_ptr
<char> copy (xstrdup (name
));
1649 tracker
.add_completion (std::move (copy
));
1655 /* Perform completion on register and reggroup names. */
1658 reg_or_group_completer (struct cmd_list_element
*ignore
,
1659 completion_tracker
&tracker
,
1660 const char *text
, const char *word
)
1662 reg_or_group_completer_1 (tracker
, text
, word
,
1663 (complete_register_names
1664 | complete_reggroup_names
));
1667 /* Perform completion on reggroup names. */
1670 reggroup_completer (struct cmd_list_element
*ignore
,
1671 completion_tracker
&tracker
,
1672 const char *text
, const char *word
)
1674 reg_or_group_completer_1 (tracker
, text
, word
,
1675 complete_reggroup_names
);
1678 /* The default completer_handle_brkchars implementation. */
1681 default_completer_handle_brkchars (struct cmd_list_element
*ignore
,
1682 completion_tracker
&tracker
,
1683 const char *text
, const char *word
)
1685 set_rl_completer_word_break_characters
1686 (current_language
->la_word_break_characters ());
1689 /* See definition in completer.h. */
1691 completer_handle_brkchars_ftype
*
1692 completer_handle_brkchars_func_for_completer (completer_ftype
*fn
)
1694 if (fn
== filename_completer
)
1695 return filename_completer_handle_brkchars
;
1697 if (fn
== location_completer
)
1698 return location_completer_handle_brkchars
;
1700 if (fn
== command_completer
)
1701 return command_completer_handle_brkchars
;
1703 return default_completer_handle_brkchars
;
1706 /* Used as brkchars when we want to tell readline we have a custom
1707 word point. We do that by making our rl_completion_word_break_hook
1708 set RL_POINT to the desired word point, and return the character at
1709 the word break point as the break char. This is two bytes in order
1710 to fit one break character plus the terminating null. */
1711 static char gdb_custom_word_point_brkchars
[2];
1713 /* Since rl_basic_quote_characters is not completer-specific, we save
1714 its original value here, in order to be able to restore it in
1715 gdb_rl_attempted_completion_function. */
1716 static const char *gdb_org_rl_basic_quote_characters
= rl_basic_quote_characters
;
1718 /* Get the list of chars that are considered as word breaks
1719 for the current command. */
1722 gdb_completion_word_break_characters_throw ()
1724 /* New completion starting. Get rid of the previous tracker and
1726 delete current_completion
.tracker
;
1727 current_completion
.tracker
= new completion_tracker ();
1729 completion_tracker
&tracker
= *current_completion
.tracker
;
1731 complete_line_internal (tracker
, NULL
, rl_line_buffer
,
1732 rl_point
, handle_brkchars
);
1734 if (tracker
.use_custom_word_point ())
1736 gdb_assert (tracker
.custom_word_point () > 0);
1737 rl_point
= tracker
.custom_word_point () - 1;
1738 gdb_custom_word_point_brkchars
[0] = rl_line_buffer
[rl_point
];
1739 rl_completer_word_break_characters
= gdb_custom_word_point_brkchars
;
1740 rl_completer_quote_characters
= NULL
;
1742 /* Clear this too, so that if we're completing a quoted string,
1743 readline doesn't consider the quote character a delimiter.
1744 If we didn't do this, readline would auto-complete {b
1745 'fun<tab>} to {'b 'function()'}, i.e., add the terminating
1746 \', but, it wouldn't append the separator space either, which
1747 is not desirable. So instead we take care of appending the
1748 quote character to the LCD ourselves, in
1749 gdb_rl_attempted_completion_function. Since this global is
1750 not just completer-specific, we'll restore it back to the
1751 default in gdb_rl_attempted_completion_function. */
1752 rl_basic_quote_characters
= NULL
;
1755 return rl_completer_word_break_characters
;
1759 gdb_completion_word_break_characters ()
1761 /* New completion starting. */
1762 current_completion
.aborted
= false;
1766 return gdb_completion_word_break_characters_throw ();
1768 CATCH (ex
, RETURN_MASK_ALL
)
1770 /* Set this to that gdb_rl_attempted_completion_function knows
1772 current_completion
.aborted
= true;
1779 /* See completer.h. */
1782 completion_find_completion_word (completion_tracker
&tracker
, const char *text
,
1785 size_t point
= strlen (text
);
1787 complete_line_internal (tracker
, NULL
, text
, point
, handle_brkchars
);
1789 if (tracker
.use_custom_word_point ())
1791 gdb_assert (tracker
.custom_word_point () > 0);
1792 *quote_char
= tracker
.quote_char ();
1793 return text
+ tracker
.custom_word_point ();
1796 gdb_rl_completion_word_info info
;
1798 info
.word_break_characters
= rl_completer_word_break_characters
;
1799 info
.quote_characters
= gdb_completer_quote_characters
;
1800 info
.basic_quote_characters
= rl_basic_quote_characters
;
1802 return gdb_rl_find_completion_word (&info
, quote_char
, NULL
, text
);
1805 /* See completer.h. */
1808 completion_tracker::recompute_lowest_common_denominator (const char *new_match
)
1810 if (m_lowest_common_denominator
== NULL
)
1812 /* We don't have a lowest common denominator yet, so simply take
1813 the whole NEW_MATCH as being it. */
1814 m_lowest_common_denominator
= xstrdup (new_match
);
1815 m_lowest_common_denominator_unique
= true;
1819 /* Find the common denominator between the currently-known
1820 lowest common denominator and NEW_MATCH. That becomes the
1821 new lowest common denominator. */
1825 (new_match
[i
] != '\0'
1826 && new_match
[i
] == m_lowest_common_denominator
[i
]);
1829 if (m_lowest_common_denominator
[i
] != new_match
[i
])
1831 m_lowest_common_denominator
[i
] = '\0';
1832 m_lowest_common_denominator_unique
= false;
1837 /* See completer.h. */
1840 completion_tracker::advance_custom_word_point_by (size_t len
)
1842 m_custom_word_point
+= len
;
1845 /* Build a new C string that is a copy of LCD with the whitespace of
1846 ORIG/ORIG_LEN preserved.
1848 Say the user is completing a symbol name, with spaces, like:
1852 and the resulting completion match is:
1856 we want to end up with an input line like:
1859 ^^^^^^^ => text from LCD [1], whitespace from ORIG preserved.
1860 ^^ => new text from LCD
1862 [1] - We must take characters from the LCD instead of the original
1863 text, since some completions want to change upper/lowercase. E.g.:
1869 "handle SIG[QUIT|etc.]"
1873 expand_preserving_ws (const char *orig
, size_t orig_len
,
1876 const char *p_orig
= orig
;
1877 const char *orig_end
= orig
+ orig_len
;
1878 const char *p_lcd
= lcd
;
1881 while (p_orig
< orig_end
)
1885 while (p_orig
< orig_end
&& *p_orig
== ' ')
1887 p_lcd
= skip_spaces_const (p_lcd
);
1891 /* Take characters from the LCD instead of the original
1892 text, since some completions change upper/lowercase.
1896 "handle SIG[QUIT|etc.]"
1904 while (*p_lcd
!= '\0')
1907 return xstrdup (res
.c_str ());
1910 /* See completer.h. */
1913 completion_tracker::build_completion_result (const char *text
,
1916 completion_list
&list
= m_entries_vec
; /* The completions. */
1921 /* +1 for the LCD, and +1 for NULL termination. */
1922 char **match_list
= XNEWVEC (char *, 1 + list
.size () + 1);
1924 /* Build replacement word, based on the LCD. */
1927 = expand_preserving_ws (text
, end
- start
,
1928 m_lowest_common_denominator
);
1930 if (m_lowest_common_denominator_unique
)
1932 /* We don't rely on readline appending the quote char as
1933 delimiter as then readline wouldn't append the ' ' after the
1935 char buf
[2] = { quote_char () };
1937 match_list
[0] = reconcat (match_list
[0], match_list
[0],
1938 buf
, (char *) NULL
);
1939 match_list
[1] = NULL
;
1941 /* If we already have a space at the end of the match, tell
1942 readline to skip appending another. */
1943 bool completion_suppress_append
1944 = (match_list
[0][strlen (match_list
[0]) - 1] == ' ');
1946 return completion_result (match_list
, 1, completion_suppress_append
);
1952 for (ix
= 0; ix
< list
.size (); ++ix
)
1953 match_list
[ix
+ 1] = list
[ix
].release ();
1954 match_list
[ix
+ 1] = NULL
;
1956 return completion_result (match_list
, list
.size (), false);
1960 /* See completer.h */
1962 completion_result::completion_result ()
1963 : match_list (NULL
), number_matches (0),
1964 completion_suppress_append (false)
1967 /* See completer.h */
1969 completion_result::completion_result (char **match_list_
,
1970 size_t number_matches_
,
1971 bool completion_suppress_append_
)
1972 : match_list (match_list_
),
1973 number_matches (number_matches_
),
1974 completion_suppress_append (completion_suppress_append_
)
1977 /* See completer.h */
1979 completion_result::~completion_result ()
1981 reset_match_list ();
1984 /* See completer.h */
1986 completion_result::completion_result (completion_result
&&rhs
)
1991 reset_match_list ();
1992 match_list
= rhs
.match_list
;
1993 rhs
.match_list
= NULL
;
1994 number_matches
= rhs
.number_matches
;
1995 rhs
.number_matches
= 0;
1998 /* See completer.h */
2001 completion_result::release_match_list ()
2003 char **ret
= match_list
;
2008 /* Compare C strings for std::sort. */
2011 compare_cstrings (const char *str1
, const char *str2
)
2013 return strcmp (str1
, str2
) < 0;
2016 /* See completer.h */
2019 completion_result::sort_match_list ()
2021 if (number_matches
> 1)
2023 /* Element 0 is special (it's the common prefix), leave it
2025 std::sort (&match_list
[1],
2026 &match_list
[number_matches
+ 1],
2031 /* See completer.h */
2034 completion_result::reset_match_list ()
2036 if (match_list
!= NULL
)
2038 for (char **p
= match_list
; *p
!= NULL
; p
++)
2045 /* Helper for gdb_rl_attempted_completion_function, which does most of
2046 the work. This is called by readline to build the match list array
2047 and to determine the lowest common denominator. The real matches
2048 list starts at match[1], while match[0] is the slot holding
2049 readline's idea of the lowest common denominator of all matches,
2050 which is what readline replaces the completion "word" with.
2052 TEXT is the caller's idea of the "word" we are looking at, as
2053 computed in the handle_brkchars phase.
2055 START is the offset from RL_LINE_BUFFER where TEXT starts. END is
2056 the offset from RL_LINE_BUFFER where TEXT ends (i.e., where
2059 You should thus pretend that the line ends at END (relative to
2062 RL_LINE_BUFFER contains the entire text of the line. RL_POINT is
2063 the offset in that line of the cursor. You should pretend that the
2066 Returns NULL if there are no completions. */
2069 gdb_rl_attempted_completion_function_throw (const char *text
, int start
, int end
)
2071 /* Completers that provide a custom word point in the
2072 handle_brkchars phase also compute their completions then.
2073 Completers that leave the completion word handling to readline
2074 must be called twice. If rl_point (i.e., END) is at column 0,
2075 then readline skips the handle_brkchars phase, and so we create a
2076 tracker now in that case too. */
2077 if (end
== 0 || !current_completion
.tracker
->use_custom_word_point ())
2079 delete current_completion
.tracker
;
2080 current_completion
.tracker
= new completion_tracker ();
2082 complete_line (*current_completion
.tracker
, text
,
2083 rl_line_buffer
, rl_point
);
2086 completion_tracker
&tracker
= *current_completion
.tracker
;
2088 completion_result result
2089 = tracker
.build_completion_result (text
, start
, end
);
2091 rl_completion_suppress_append
= result
.completion_suppress_append
;
2092 return result
.release_match_list ();
2095 /* Function installed as "rl_attempted_completion_function" readline
2096 hook. Wrapper around gdb_rl_attempted_completion_function_throw
2097 that catches C++ exceptions, which can't cross readline. */
2100 gdb_rl_attempted_completion_function (const char *text
, int start
, int end
)
2102 /* Restore globals that might have been tweaked in
2103 gdb_completion_word_break_characters. */
2104 rl_basic_quote_characters
= gdb_org_rl_basic_quote_characters
;
2106 /* If we end up returning NULL, either on error, or simple because
2107 there are no matches, inhibit readline's default filename
2109 rl_attempted_completion_over
= 1;
2111 /* If the handle_brkchars phase was aborted, don't try
2113 if (current_completion
.aborted
)
2118 return gdb_rl_attempted_completion_function_throw (text
, start
, end
);
2120 CATCH (ex
, RETURN_MASK_ALL
)
2128 /* Skip over the possibly quoted word STR (as defined by the quote
2129 characters QUOTECHARS and the word break characters BREAKCHARS).
2130 Returns pointer to the location after the "word". If either
2131 QUOTECHARS or BREAKCHARS is NULL, use the same values used by the
2135 skip_quoted_chars (const char *str
, const char *quotechars
,
2136 const char *breakchars
)
2138 char quote_char
= '\0';
2141 if (quotechars
== NULL
)
2142 quotechars
= gdb_completer_quote_characters
;
2144 if (breakchars
== NULL
)
2145 breakchars
= current_language
->la_word_break_characters();
2147 for (scan
= str
; *scan
!= '\0'; scan
++)
2149 if (quote_char
!= '\0')
2151 /* Ignore everything until the matching close quote char. */
2152 if (*scan
== quote_char
)
2154 /* Found matching close quote. */
2159 else if (strchr (quotechars
, *scan
))
2161 /* Found start of a quoted string. */
2164 else if (strchr (breakchars
, *scan
))
2173 /* Skip over the possibly quoted word STR (as defined by the quote
2174 characters and word break characters used by the completer).
2175 Returns pointer to the location after the "word". */
2178 skip_quoted (const char *str
)
2180 return skip_quoted_chars (str
, NULL
, NULL
);
2183 /* Return a message indicating that the maximum number of completions
2184 has been reached and that there may be more. */
2187 get_max_completions_reached_message (void)
2189 return _("*** List may be truncated, max-completions reached. ***");
2192 /* GDB replacement for rl_display_match_list.
2193 Readline doesn't provide a clean interface for TUI(curses).
2194 A hack previously used was to send readline's rl_outstream through a pipe
2195 and read it from the event loop. Bleah. IWBN if readline abstracted
2196 away all the necessary bits, and this is what this code does. It
2197 replicates the parts of readline we need and then adds an abstraction
2198 layer, currently implemented as struct match_list_displayer, so that both
2199 CLI and TUI can use it. We copy all this readline code to minimize
2200 GDB-specific mods to readline. Once this code performs as desired then
2201 we can submit it to the readline maintainers.
2203 N.B. A lot of the code is the way it is in order to minimize differences
2204 from readline's copy. */
2206 /* Not supported here. */
2207 #undef VISIBLE_STATS
2209 #if defined (HANDLE_MULTIBYTE)
2210 #define MB_INVALIDCH(x) ((x) == (size_t)-1 || (x) == (size_t)-2)
2211 #define MB_NULLWCH(x) ((x) == 0)
2214 #define ELLIPSIS_LEN 3
2216 /* gdb version of readline/complete.c:get_y_or_n.
2217 'y' -> returns 1, and 'n' -> returns 0.
2218 Also supported: space == 'y', RUBOUT == 'n', ctrl-g == start over.
2219 If FOR_PAGER is non-zero, then also supported are:
2220 NEWLINE or RETURN -> returns 2, and 'q' -> returns 0. */
2223 gdb_get_y_or_n (int for_pager
, const struct match_list_displayer
*displayer
)
2229 RL_SETSTATE (RL_STATE_MOREINPUT
);
2230 c
= displayer
->read_key (displayer
);
2231 RL_UNSETSTATE (RL_STATE_MOREINPUT
);
2233 if (c
== 'y' || c
== 'Y' || c
== ' ')
2235 if (c
== 'n' || c
== 'N' || c
== RUBOUT
)
2237 if (c
== ABORT_CHAR
|| c
< 0)
2239 /* Readline doesn't erase_entire_line here, but without it the
2240 --More-- prompt isn't erased and neither is the text entered
2241 thus far redisplayed. */
2242 displayer
->erase_entire_line (displayer
);
2243 /* Note: The arguments to rl_abort are ignored. */
2246 if (for_pager
&& (c
== NEWLINE
|| c
== RETURN
))
2248 if (for_pager
&& (c
== 'q' || c
== 'Q'))
2250 displayer
->beep (displayer
);
2254 /* Pager function for tab-completion.
2255 This is based on readline/complete.c:_rl_internal_pager.
2256 LINES is the number of lines of output displayed thus far.
2258 -1 -> user pressed 'n' or equivalent,
2259 0 -> user pressed 'y' or equivalent,
2260 N -> user pressed NEWLINE or equivalent and N is LINES - 1. */
2263 gdb_display_match_list_pager (int lines
,
2264 const struct match_list_displayer
*displayer
)
2268 displayer
->puts (displayer
, "--More--");
2269 displayer
->flush (displayer
);
2270 i
= gdb_get_y_or_n (1, displayer
);
2271 displayer
->erase_entire_line (displayer
);
2280 /* Return non-zero if FILENAME is a directory.
2281 Based on readline/complete.c:path_isdir. */
2284 gdb_path_isdir (const char *filename
)
2288 return (stat (filename
, &finfo
) == 0 && S_ISDIR (finfo
.st_mode
));
2291 /* Return the portion of PATHNAME that should be output when listing
2292 possible completions. If we are hacking filename completion, we
2293 are only interested in the basename, the portion following the
2294 final slash. Otherwise, we return what we were passed. Since
2295 printing empty strings is not very informative, if we're doing
2296 filename completion, and the basename is the empty string, we look
2297 for the previous slash and return the portion following that. If
2298 there's no previous slash, we just return what we were passed.
2300 Based on readline/complete.c:printable_part. */
2303 gdb_printable_part (char *pathname
)
2307 if (rl_filename_completion_desired
== 0) /* don't need to do anything */
2310 temp
= strrchr (pathname
, '/');
2311 #if defined (__MSDOS__)
2312 if (temp
== 0 && ISALPHA ((unsigned char)pathname
[0]) && pathname
[1] == ':')
2313 temp
= pathname
+ 1;
2316 if (temp
== 0 || *temp
== '\0')
2318 /* If the basename is NULL, we might have a pathname like '/usr/src/'.
2319 Look for a previous slash and, if one is found, return the portion
2320 following that slash. If there's no previous slash, just return the
2321 pathname we were passed. */
2322 else if (temp
[1] == '\0')
2324 for (x
= temp
- 1; x
> pathname
; x
--)
2327 return ((*x
== '/') ? x
+ 1 : pathname
);
2333 /* Compute width of STRING when displayed on screen by print_filename.
2334 Based on readline/complete.c:fnwidth. */
2337 gdb_fnwidth (const char *string
)
2340 #if defined (HANDLE_MULTIBYTE)
2346 left
= strlen (string
) + 1;
2347 memset (&ps
, 0, sizeof (mbstate_t));
2353 if (CTRL_CHAR (string
[pos
]) || string
[pos
] == RUBOUT
)
2360 #if defined (HANDLE_MULTIBYTE)
2361 clen
= mbrtowc (&wc
, string
+ pos
, left
- pos
, &ps
);
2362 if (MB_INVALIDCH (clen
))
2366 memset (&ps
, 0, sizeof (mbstate_t));
2368 else if (MB_NULLWCH (clen
))
2374 width
+= (w
>= 0) ? w
: 1;
2386 /* Print TO_PRINT, one matching completion.
2387 PREFIX_BYTES is number of common prefix bytes.
2388 Based on readline/complete.c:fnprint. */
2391 gdb_fnprint (const char *to_print
, int prefix_bytes
,
2392 const struct match_list_displayer
*displayer
)
2396 #if defined (HANDLE_MULTIBYTE)
2403 end
= to_print
+ strlen (to_print
) + 1;
2404 memset (&ps
, 0, sizeof (mbstate_t));
2409 /* Don't print only the ellipsis if the common prefix is one of the
2410 possible completions */
2411 if (to_print
[prefix_bytes
] == '\0')
2418 ellipsis
= (to_print
[prefix_bytes
] == '.') ? '_' : '.';
2419 for (w
= 0; w
< ELLIPSIS_LEN
; w
++)
2420 displayer
->putch (displayer
, ellipsis
);
2421 printed_len
= ELLIPSIS_LEN
;
2424 s
= to_print
+ prefix_bytes
;
2429 displayer
->putch (displayer
, '^');
2430 displayer
->putch (displayer
, UNCTRL (*s
));
2433 #if defined (HANDLE_MULTIBYTE)
2434 memset (&ps
, 0, sizeof (mbstate_t));
2437 else if (*s
== RUBOUT
)
2439 displayer
->putch (displayer
, '^');
2440 displayer
->putch (displayer
, '?');
2443 #if defined (HANDLE_MULTIBYTE)
2444 memset (&ps
, 0, sizeof (mbstate_t));
2449 #if defined (HANDLE_MULTIBYTE)
2450 tlen
= mbrtowc (&wc
, s
, end
- s
, &ps
);
2451 if (MB_INVALIDCH (tlen
))
2455 memset (&ps
, 0, sizeof (mbstate_t));
2457 else if (MB_NULLWCH (tlen
))
2462 width
= (w
>= 0) ? w
: 1;
2464 for (w
= 0; w
< tlen
; ++w
)
2465 displayer
->putch (displayer
, s
[w
]);
2467 printed_len
+= width
;
2469 displayer
->putch (displayer
, *s
);
2479 /* Output TO_PRINT to rl_outstream. If VISIBLE_STATS is defined and we
2480 are using it, check for and output a single character for `special'
2481 filenames. Return the number of characters we output.
2482 Based on readline/complete.c:print_filename. */
2485 gdb_print_filename (char *to_print
, char *full_pathname
, int prefix_bytes
,
2486 const struct match_list_displayer
*displayer
)
2488 int printed_len
, extension_char
, slen
, tlen
;
2489 char *s
, c
, *new_full_pathname
;
2491 extern int _rl_complete_mark_directories
;
2494 printed_len
= gdb_fnprint (to_print
, prefix_bytes
, displayer
);
2496 #if defined (VISIBLE_STATS)
2497 if (rl_filename_completion_desired
&& (rl_visible_stats
|| _rl_complete_mark_directories
))
2499 if (rl_filename_completion_desired
&& _rl_complete_mark_directories
)
2502 /* If to_print != full_pathname, to_print is the basename of the
2503 path passed. In this case, we try to expand the directory
2504 name before checking for the stat character. */
2505 if (to_print
!= full_pathname
)
2507 /* Terminate the directory name. */
2509 to_print
[-1] = '\0';
2511 /* If setting the last slash in full_pathname to a NUL results in
2512 full_pathname being the empty string, we are trying to complete
2513 files in the root directory. If we pass a null string to the
2514 bash directory completion hook, for example, it will expand it
2515 to the current directory. We just want the `/'. */
2516 if (full_pathname
== 0 || *full_pathname
== 0)
2518 else if (full_pathname
[0] != '/')
2520 else if (full_pathname
[1] == 0)
2521 dn
= "//"; /* restore trailing slash to `//' */
2522 else if (full_pathname
[1] == '/' && full_pathname
[2] == 0)
2523 dn
= "/"; /* don't turn /// into // */
2526 s
= tilde_expand (dn
);
2527 if (rl_directory_completion_hook
)
2528 (*rl_directory_completion_hook
) (&s
);
2531 tlen
= strlen (to_print
);
2532 new_full_pathname
= (char *)xmalloc (slen
+ tlen
+ 2);
2533 strcpy (new_full_pathname
, s
);
2534 if (s
[slen
- 1] == '/')
2537 new_full_pathname
[slen
] = '/';
2538 new_full_pathname
[slen
] = '/';
2539 strcpy (new_full_pathname
+ slen
+ 1, to_print
);
2541 #if defined (VISIBLE_STATS)
2542 if (rl_visible_stats
)
2543 extension_char
= stat_char (new_full_pathname
);
2546 if (gdb_path_isdir (new_full_pathname
))
2547 extension_char
= '/';
2549 xfree (new_full_pathname
);
2554 s
= tilde_expand (full_pathname
);
2555 #if defined (VISIBLE_STATS)
2556 if (rl_visible_stats
)
2557 extension_char
= stat_char (s
);
2560 if (gdb_path_isdir (s
))
2561 extension_char
= '/';
2567 displayer
->putch (displayer
, extension_char
);
2575 /* GDB version of readline/complete.c:complete_get_screenwidth. */
2578 gdb_complete_get_screenwidth (const struct match_list_displayer
*displayer
)
2580 /* Readline has other stuff here which it's not clear we need. */
2581 return displayer
->width
;
2584 extern int _rl_completion_prefix_display_length
;
2585 extern int _rl_print_completions_horizontally
;
2587 EXTERN_C
int _rl_qsort_string_compare (const void *, const void *);
2588 typedef int QSFUNC (const void *, const void *);
2590 /* GDB version of readline/complete.c:rl_display_match_list.
2591 See gdb_display_match_list for a description of MATCHES, LEN, MAX.
2592 Returns non-zero if all matches are displayed. */
2595 gdb_display_match_list_1 (char **matches
, int len
, int max
,
2596 const struct match_list_displayer
*displayer
)
2598 int count
, limit
, printed_len
, lines
, cols
;
2599 int i
, j
, k
, l
, common_length
, sind
;
2601 int page_completions
= displayer
->height
!= INT_MAX
&& pagination_enabled
;
2603 /* Find the length of the prefix common to all items: length as displayed
2604 characters (common_length) and as a byte index into the matches (sind) */
2605 common_length
= sind
= 0;
2606 if (_rl_completion_prefix_display_length
> 0)
2608 t
= gdb_printable_part (matches
[0]);
2609 temp
= strrchr (t
, '/');
2610 common_length
= temp
? gdb_fnwidth (temp
) : gdb_fnwidth (t
);
2611 sind
= temp
? strlen (temp
) : strlen (t
);
2613 if (common_length
> _rl_completion_prefix_display_length
&& common_length
> ELLIPSIS_LEN
)
2614 max
-= common_length
- ELLIPSIS_LEN
;
2616 common_length
= sind
= 0;
2619 /* How many items of MAX length can we fit in the screen window? */
2620 cols
= gdb_complete_get_screenwidth (displayer
);
2623 if (limit
!= 1 && (limit
* max
== cols
))
2626 /* If cols == 0, limit will end up -1 */
2627 if (cols
< displayer
->width
&& limit
< 0)
2630 /* Avoid a possible floating exception. If max > cols,
2631 limit will be 0 and a divide-by-zero fault will result. */
2635 /* How many iterations of the printing loop? */
2636 count
= (len
+ (limit
- 1)) / limit
;
2638 /* Watch out for special case. If LEN is less than LIMIT, then
2639 just do the inner printing loop.
2640 0 < len <= limit implies count = 1. */
2642 /* Sort the items if they are not already sorted. */
2643 if (rl_ignore_completion_duplicates
== 0 && rl_sort_completion_matches
)
2644 qsort (matches
+ 1, len
, sizeof (char *), (QSFUNC
*)_rl_qsort_string_compare
);
2646 displayer
->crlf (displayer
);
2649 if (_rl_print_completions_horizontally
== 0)
2651 /* Print the sorted items, up-and-down alphabetically, like ls. */
2652 for (i
= 1; i
<= count
; i
++)
2654 for (j
= 0, l
= i
; j
< limit
; j
++)
2656 if (l
> len
|| matches
[l
] == 0)
2660 temp
= gdb_printable_part (matches
[l
]);
2661 printed_len
= gdb_print_filename (temp
, matches
[l
], sind
,
2665 for (k
= 0; k
< max
- printed_len
; k
++)
2666 displayer
->putch (displayer
, ' ');
2670 displayer
->crlf (displayer
);
2672 if (page_completions
&& lines
>= (displayer
->height
- 1) && i
< count
)
2674 lines
= gdb_display_match_list_pager (lines
, displayer
);
2682 /* Print the sorted items, across alphabetically, like ls -x. */
2683 for (i
= 1; matches
[i
]; i
++)
2685 temp
= gdb_printable_part (matches
[i
]);
2686 printed_len
= gdb_print_filename (temp
, matches
[i
], sind
, displayer
);
2687 /* Have we reached the end of this line? */
2690 if (i
&& (limit
> 1) && (i
% limit
) == 0)
2692 displayer
->crlf (displayer
);
2694 if (page_completions
&& lines
>= displayer
->height
- 1)
2696 lines
= gdb_display_match_list_pager (lines
, displayer
);
2702 for (k
= 0; k
< max
- printed_len
; k
++)
2703 displayer
->putch (displayer
, ' ');
2706 displayer
->crlf (displayer
);
2712 /* Utility for displaying completion list matches, used by both CLI and TUI.
2714 MATCHES is the list of strings, in argv format, LEN is the number of
2715 strings in MATCHES, and MAX is the length of the longest string in
2719 gdb_display_match_list (char **matches
, int len
, int max
,
2720 const struct match_list_displayer
*displayer
)
2722 /* Readline will never call this if complete_line returned NULL. */
2723 gdb_assert (max_completions
!= 0);
2725 /* complete_line will never return more than this. */
2726 if (max_completions
> 0)
2727 gdb_assert (len
<= max_completions
);
2729 if (rl_completion_query_items
> 0 && len
>= rl_completion_query_items
)
2733 /* We can't use *query here because they wait for <RET> which is
2734 wrong here. This follows the readline version as closely as possible
2735 for compatibility's sake. See readline/complete.c. */
2737 displayer
->crlf (displayer
);
2739 xsnprintf (msg
, sizeof (msg
),
2740 "Display all %d possibilities? (y or n)", len
);
2741 displayer
->puts (displayer
, msg
);
2742 displayer
->flush (displayer
);
2744 if (gdb_get_y_or_n (0, displayer
) == 0)
2746 displayer
->crlf (displayer
);
2751 if (gdb_display_match_list_1 (matches
, len
, max
, displayer
))
2753 /* Note: MAX_COMPLETIONS may be -1 or zero, but LEN is always > 0. */
2754 if (len
== max_completions
)
2756 /* The maximum number of completions has been reached. Warn the user
2757 that there may be more. */
2758 const char *message
= get_max_completions_reached_message ();
2760 displayer
->puts (displayer
, message
);
2761 displayer
->crlf (displayer
);
2766 extern initialize_file_ftype _initialize_completer
; /* -Wmissing-prototypes */
2769 _initialize_completer (void)
2771 add_setshow_zuinteger_unlimited_cmd ("max-completions", no_class
,
2772 &max_completions
, _("\
2773 Set maximum number of completion candidates."), _("\
2774 Show maximum number of completion candidates."), _("\
2775 Use this to limit the number of candidates considered\n\
2776 during completion. Specifying \"unlimited\" or -1\n\
2777 disables limiting. Note that setting either no limit or\n\
2778 a very large limit can make completion slow."),
2779 NULL
, NULL
, &setlist
, &showlist
);