1 /* Line completion stuff for GDB, the GNU debugger.
2 Copyright (C) 2000-2022 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 ());
93 /* The symbol name stored in this hash entry. */
94 gdb::unique_xmalloc_ptr
<char> m_name
;
96 /* The lowest common denominator string computed for this hash entry. */
97 gdb::unique_xmalloc_ptr
<char> m_lcd
;
100 /* Misc state that needs to be tracked across several different
101 readline completer entry point calls, all related to a single
102 completion invocation. */
104 struct gdb_completer_state
106 /* The current completion's completion tracker. This is a global
107 because a tracker can be shared between the handle_brkchars and
108 handle_completion phases, which involves different readline
110 completion_tracker
*tracker
= NULL
;
112 /* Whether the current completion was aborted. */
113 bool aborted
= false;
116 /* The current completion state. */
117 static gdb_completer_state current_completion
;
119 /* An enumeration of the various things a user might attempt to
120 complete for a location. If you change this, remember to update
121 the explicit_options array below too. */
123 enum explicit_location_match_type
125 /* The filename of a source file. */
128 /* The name of a function or method. */
131 /* The fully-qualified name of a function or method. */
137 /* The name of a label. */
141 /* Prototypes for local functions. */
143 /* readline uses the word breaks for two things:
144 (1) In figuring out where to point the TEXT parameter to the
145 rl_completion_entry_function. Since we don't use TEXT for much,
146 it doesn't matter a lot what the word breaks are for this purpose,
147 but it does affect how much stuff M-? lists.
148 (2) If one of the matches contains a word break character, readline
149 will quote it. That's why we switch between
150 current_language->word_break_characters () and
151 gdb_completer_command_word_break_characters. I'm not sure when
152 we need this behavior (perhaps for funky characters in C++
155 /* Variables which are necessary for fancy command line editing. */
157 /* When completing on command names, we remove '-' and '.' from the list of
158 word break characters, since we use it in command names. If the
159 readline library sees one in any of the current completion strings,
160 it thinks that the string needs to be quoted and automatically
161 supplies a leading quote. */
162 static const char gdb_completer_command_word_break_characters
[] =
163 " \t\n!@#$%^&*()+=|~`}{[]\"';:?/><,";
165 /* When completing on file names, we remove from the list of word
166 break characters any characters that are commonly used in file
167 names, such as '-', '+', '~', etc. Otherwise, readline displays
168 incorrect completion candidates. */
169 /* MS-DOS and MS-Windows use colon as part of the drive spec, and most
170 programs support @foo style response files. */
171 static const char gdb_completer_file_name_break_characters
[] =
172 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
178 /* Characters that can be used to quote completion strings. Note that
179 we can't include '"' because the gdb C parser treats such quoted
180 sequences as strings. */
181 static const char gdb_completer_quote_characters
[] = "'";
183 /* Accessor for some completer data that may interest other files. */
186 get_gdb_completer_quote_characters (void)
188 return gdb_completer_quote_characters
;
191 /* This can be used for functions which don't want to complete on
192 symbols but don't want to complete on anything else either. */
195 noop_completer (struct cmd_list_element
*ignore
,
196 completion_tracker
&tracker
,
197 const char *text
, const char *prefix
)
201 /* Complete on filenames. */
204 filename_completer (struct cmd_list_element
*ignore
,
205 completion_tracker
&tracker
,
206 const char *text
, const char *word
)
213 gdb::unique_xmalloc_ptr
<char> p_rl
214 (rl_filename_completion_function (text
, subsequent_name
));
217 /* We need to set subsequent_name to a non-zero value before the
218 continue line below, because otherwise, if the first file
219 seen by GDB is a backup file whose name ends in a `~', we
220 will loop indefinitely. */
222 /* Like emacs, don't complete on old versions. Especially
223 useful in the "source" command. */
224 const char *p
= p_rl
.get ();
225 if (p
[strlen (p
) - 1] == '~')
228 tracker
.add_completion
229 (make_completion_match_str (std::move (p_rl
), text
, word
));
232 /* There is no way to do this just long enough to affect quote
233 inserting without also affecting the next completion. This
234 should be fixed in readline. FIXME. */
235 /* Ensure that readline does the right thing
236 with respect to inserting quotes. */
237 rl_completer_word_break_characters
= "";
241 /* The corresponding completer_handle_brkchars
245 filename_completer_handle_brkchars (struct cmd_list_element
*ignore
,
246 completion_tracker
&tracker
,
247 const char *text
, const char *word
)
249 set_rl_completer_word_break_characters
250 (gdb_completer_file_name_break_characters
);
253 /* Find the bounds of the current word for completion purposes, and
254 return a pointer to the end of the word. This mimics (and is a
255 modified version of) readline's _rl_find_completion_word internal
258 This function skips quoted substrings (characters between matched
259 pairs of characters in rl_completer_quote_characters). We try to
260 find an unclosed quoted substring on which to do matching. If one
261 is not found, we use the word break characters to find the
262 boundaries of the current word. QC, if non-null, is set to the
263 opening quote character if we found an unclosed quoted substring,
264 '\0' otherwise. DP, if non-null, is set to the value of the
265 delimiter character that caused a word break. */
267 struct gdb_rl_completion_word_info
269 const char *word_break_characters
;
270 const char *quote_characters
;
271 const char *basic_quote_characters
;
275 gdb_rl_find_completion_word (struct gdb_rl_completion_word_info
*info
,
277 const char *line_buffer
)
279 int scan
, end
, delimiter
, pass_next
, isbrk
;
281 const char *brkchars
;
282 int point
= strlen (line_buffer
);
284 /* The algorithm below does '--point'. Avoid buffer underflow with
299 brkchars
= info
->word_break_characters
;
301 if (info
->quote_characters
!= NULL
)
303 /* We have a list of characters which can be used in pairs to
304 quote substrings for the completer. Try to find the start of
305 an unclosed quoted substring. */
306 for (scan
= pass_next
= 0;
316 /* Shell-like semantics for single quotes -- don't allow
317 backslash to quote anything in single quotes, especially
318 not the closing quote. If you don't like this, take out
319 the check on the value of quote_char. */
320 if (quote_char
!= '\'' && line_buffer
[scan
] == '\\')
326 if (quote_char
!= '\0')
328 /* Ignore everything until the matching close quote
330 if (line_buffer
[scan
] == quote_char
)
332 /* Found matching close. Abandon this
338 else if (strchr (info
->quote_characters
, line_buffer
[scan
]))
340 /* Found start of a quoted substring. */
341 quote_char
= line_buffer
[scan
];
347 if (point
== end
&& quote_char
== '\0')
349 /* We didn't find an unclosed quoted substring upon which to do
350 completion, so use the word break characters to find the
351 substring on which to complete. */
354 scan
= line_buffer
[point
];
356 if (strchr (brkchars
, scan
) != 0)
361 /* If we are at an unquoted word break, then advance past it. */
362 scan
= line_buffer
[point
];
366 isbrk
= strchr (brkchars
, scan
) != 0;
370 /* If the character that caused the word break was a quoting
371 character, then remember it as the delimiter. */
372 if (info
->basic_quote_characters
373 && strchr (info
->basic_quote_characters
, scan
)
374 && (end
- point
) > 1)
386 return line_buffer
+ point
;
389 /* Find the completion word point for TEXT, emulating the algorithm
390 readline uses to find the word point, using WORD_BREAK_CHARACTERS
391 as word break characters. */
394 advance_to_completion_word (completion_tracker
&tracker
,
395 const char *word_break_characters
,
398 gdb_rl_completion_word_info info
;
400 info
.word_break_characters
= word_break_characters
;
401 info
.quote_characters
= gdb_completer_quote_characters
;
402 info
.basic_quote_characters
= rl_basic_quote_characters
;
406 = gdb_rl_find_completion_word (&info
, NULL
, &delimiter
, text
);
408 tracker
.advance_custom_word_point_by (start
- text
);
412 tracker
.set_quote_char (delimiter
);
413 tracker
.set_suppress_append_ws (true);
419 /* See completer.h. */
422 advance_to_expression_complete_word_point (completion_tracker
&tracker
,
425 const char *brk_chars
= current_language
->word_break_characters ();
426 return advance_to_completion_word (tracker
, brk_chars
, text
);
429 /* See completer.h. */
432 advance_to_filename_complete_word_point (completion_tracker
&tracker
,
435 const char *brk_chars
= gdb_completer_file_name_break_characters
;
436 return advance_to_completion_word (tracker
, brk_chars
, text
);
439 /* See completer.h. */
442 completion_tracker::completes_to_completion_word (const char *word
)
444 recompute_lowest_common_denominator ();
445 if (m_lowest_common_denominator_unique
)
447 const char *lcd
= m_lowest_common_denominator
;
449 if (strncmp_iw (word
, lcd
, strlen (lcd
)) == 0)
451 /* Maybe skip the function and complete on keywords. */
452 size_t wordlen
= strlen (word
);
453 if (word
[wordlen
- 1] == ' ')
461 /* See completer.h. */
464 complete_nested_command_line (completion_tracker
&tracker
, const char *text
)
466 /* Must be called from a custom-word-point completer. */
467 gdb_assert (tracker
.use_custom_word_point ());
469 /* Disable the custom word point temporarily, because we want to
470 probe whether the command we're completing itself uses a custom
472 tracker
.set_use_custom_word_point (false);
473 size_t save_custom_word_point
= tracker
.custom_word_point ();
475 int quote_char
= '\0';
476 const char *word
= completion_find_completion_word (tracker
, text
,
479 if (tracker
.use_custom_word_point ())
481 /* The command we're completing uses a custom word point, so the
482 tracker already contains the matches. We're done. */
486 /* Restore the custom word point settings. */
487 tracker
.set_custom_word_point (save_custom_word_point
);
488 tracker
.set_use_custom_word_point (true);
490 /* Run the handle_completions completer phase. */
491 complete_line (tracker
, word
, text
, strlen (text
));
494 /* Complete on linespecs, which might be of two possible forms:
500 This is intended to be used in commands that set breakpoints
504 complete_files_symbols (completion_tracker
&tracker
,
505 const char *text
, const char *word
)
507 completion_list fn_list
;
510 int quoted
= *text
== '\'' || *text
== '"';
511 int quote_char
= '\0';
512 const char *colon
= NULL
;
513 char *file_to_match
= NULL
;
514 const char *symbol_start
= text
;
515 const char *orig_text
= text
;
517 /* Do we have an unquoted colon, as in "break foo.c:bar"? */
518 for (p
= text
; *p
!= '\0'; ++p
)
520 if (*p
== '\\' && p
[1] == '\'')
522 else if (*p
== '\'' || *p
== '"')
526 while (*p
!= '\0' && *p
!= quote_found
)
528 if (*p
== '\\' && p
[1] == quote_found
)
533 if (*p
== quote_found
)
536 break; /* Hit the end of text. */
538 #if HAVE_DOS_BASED_FILE_SYSTEM
539 /* If we have a DOS-style absolute file name at the beginning of
540 TEXT, and the colon after the drive letter is the only colon
541 we found, pretend the colon is not there. */
542 else if (p
< text
+ 3 && *p
== ':' && p
== text
+ 1 + quoted
)
545 else if (*p
== ':' && !colon
)
548 symbol_start
= p
+ 1;
550 else if (strchr (current_language
->word_break_characters (), *p
))
551 symbol_start
= p
+ 1;
557 /* Where is the file name? */
562 file_to_match
= (char *) xmalloc (colon
- text
+ 1);
563 strncpy (file_to_match
, text
, colon
- text
);
564 file_to_match
[colon
- text
] = '\0';
565 /* Remove trailing colons and quotes from the file name. */
566 for (s
= file_to_match
+ (colon
- text
);
569 if (*s
== ':' || *s
== quote_char
)
572 /* If the text includes a colon, they want completion only on a
573 symbol name after the colon. Otherwise, we need to complete on
574 symbols as well as on files. */
577 collect_file_symbol_completion_matches (tracker
,
578 complete_symbol_mode::EXPRESSION
,
579 symbol_name_match_type::EXPRESSION
,
582 xfree (file_to_match
);
586 size_t text_len
= strlen (text
);
588 collect_symbol_completion_matches (tracker
,
589 complete_symbol_mode::EXPRESSION
,
590 symbol_name_match_type::EXPRESSION
,
592 /* If text includes characters which cannot appear in a file
593 name, they cannot be asking for completion on files. */
595 gdb_completer_file_name_break_characters
) == text_len
)
596 fn_list
= make_source_files_completion_list (text
, text
);
599 if (!fn_list
.empty () && !tracker
.have_completions ())
601 /* If we only have file names as possible completion, we should
602 bring them in sync with what rl_complete expects. The
603 problem is that if the user types "break /foo/b TAB", and the
604 possible completions are "/foo/bar" and "/foo/baz"
605 rl_complete expects us to return "bar" and "baz", without the
606 leading directories, as possible completions, because `word'
607 starts at the "b". But we ignore the value of `word' when we
608 call make_source_files_completion_list above (because that
609 would not DTRT when the completion results in both symbols
610 and file names), so make_source_files_completion_list returns
611 the full "/foo/bar" and "/foo/baz" strings. This produces
612 wrong results when, e.g., there's only one possible
613 completion, because rl_complete will prepend "/foo/" to each
614 candidate completion. The loop below removes that leading
616 for (const auto &fn_up
: fn_list
)
618 char *fn
= fn_up
.get ();
619 memmove (fn
, fn
+ (word
- text
), strlen (fn
) + 1 - (word
- text
));
623 tracker
.add_completions (std::move (fn_list
));
625 if (!tracker
.have_completions ())
627 /* No completions at all. As the final resort, try completing
628 on the entire text as a symbol. */
629 collect_symbol_completion_matches (tracker
,
630 complete_symbol_mode::EXPRESSION
,
631 symbol_name_match_type::EXPRESSION
,
636 /* See completer.h. */
639 complete_source_filenames (const char *text
)
641 size_t text_len
= strlen (text
);
643 /* If text includes characters which cannot appear in a file name,
644 the user cannot be asking for completion on files. */
646 gdb_completer_file_name_break_characters
)
648 return make_source_files_completion_list (text
, text
);
653 /* Complete address and linespec locations. */
656 complete_address_and_linespec_locations (completion_tracker
&tracker
,
658 symbol_name_match_type match_type
)
662 tracker
.advance_custom_word_point_by (1);
665 = advance_to_expression_complete_word_point (tracker
, text
);
666 complete_expression (tracker
, text
, word
);
670 linespec_complete (tracker
, text
, match_type
);
674 /* The explicit location options. Note that indexes into this array
675 must match the explicit_location_match_type enumerators. */
677 static const char *const explicit_options
[] =
687 /* The probe modifier options. These can appear before a location in
688 breakpoint commands. */
689 static const char *const probe_options
[] =
697 /* Returns STRING if not NULL, the empty string otherwise. */
700 string_or_empty (const char *string
)
702 return string
!= NULL
? string
: "";
705 /* A helper function to collect explicit location matches for the given
706 LOCATION, which is attempting to match on WORD. */
709 collect_explicit_location_matches (completion_tracker
&tracker
,
710 struct event_location
*location
,
711 enum explicit_location_match_type what
,
713 const struct language_defn
*language
)
715 const struct explicit_location
*explicit_loc
716 = get_explicit_location (location
);
718 /* True if the option expects an argument. */
719 bool needs_arg
= true;
721 /* Note, in the various MATCH_* below, we complete on
722 explicit_loc->foo instead of WORD, because only the former will
723 have already skipped past any quote char. */
728 const char *source
= string_or_empty (explicit_loc
->source_filename
);
729 completion_list matches
730 = make_source_files_completion_list (source
, source
);
731 tracker
.add_completions (std::move (matches
));
737 const char *function
= string_or_empty (explicit_loc
->function_name
);
738 linespec_complete_function (tracker
, function
,
739 explicit_loc
->func_name_match_type
,
740 explicit_loc
->source_filename
);
744 case MATCH_QUALIFIED
:
748 /* Nothing to offer. */
753 const char *label
= string_or_empty (explicit_loc
->label_name
);
754 linespec_complete_label (tracker
, language
,
755 explicit_loc
->source_filename
,
756 explicit_loc
->function_name
,
757 explicit_loc
->func_name_match_type
,
763 gdb_assert_not_reached ("unhandled explicit_location_match_type");
766 if (!needs_arg
|| tracker
.completes_to_completion_word (word
))
768 tracker
.discard_completions ();
769 tracker
.advance_custom_word_point_by (strlen (word
));
770 complete_on_enum (tracker
, explicit_options
, "", "");
771 complete_on_enum (tracker
, linespec_keywords
, "", "");
773 else if (!tracker
.have_completions ())
775 /* Maybe we have an unterminated linespec keyword at the tail of
776 the string. Try completing on that. */
777 size_t wordlen
= strlen (word
);
778 const char *keyword
= word
+ wordlen
;
780 if (wordlen
> 0 && keyword
[-1] != ' ')
782 while (keyword
> word
&& *keyword
!= ' ')
784 /* Don't complete on keywords if we'd be completing on the
785 whole explicit linespec option. E.g., "b -function
786 thr<tab>" should not complete to the "thread"
790 keyword
= skip_spaces (keyword
);
792 tracker
.advance_custom_word_point_by (keyword
- word
);
793 complete_on_enum (tracker
, linespec_keywords
, keyword
, keyword
);
796 else if (wordlen
> 0 && keyword
[-1] == ' ')
798 /* Assume that we're maybe past the explicit location
799 argument, and we didn't manage to find any match because
800 the user wants to create a pending breakpoint. Offer the
801 keyword and explicit location options as possible
803 tracker
.advance_custom_word_point_by (keyword
- word
);
804 complete_on_enum (tracker
, linespec_keywords
, keyword
, keyword
);
805 complete_on_enum (tracker
, explicit_options
, keyword
, keyword
);
810 /* If the next word in *TEXT_P is any of the keywords in KEYWORDS,
811 then advance both TEXT_P and the word point in the tracker past the
812 keyword and return the (0-based) index in the KEYWORDS array that
813 matched. Otherwise, return -1. */
816 skip_keyword (completion_tracker
&tracker
,
817 const char * const *keywords
, const char **text_p
)
819 const char *text
= *text_p
;
820 const char *after
= skip_to_space (text
);
821 size_t len
= after
- text
;
823 if (text
[len
] != ' ')
827 for (int i
= 0; keywords
[i
] != NULL
; i
++)
829 if (strncmp (keywords
[i
], text
, len
) == 0)
840 tracker
.advance_custom_word_point_by (len
+ 1);
849 /* A completer function for explicit locations. This function
850 completes both options ("-source", "-line", etc) and values. If
851 completing a quoted string, then QUOTED_ARG_START and
852 QUOTED_ARG_END point to the quote characters. LANGUAGE is the
856 complete_explicit_location (completion_tracker
&tracker
,
857 struct event_location
*location
,
859 const language_defn
*language
,
860 const char *quoted_arg_start
,
861 const char *quoted_arg_end
)
866 int keyword
= skip_keyword (tracker
, explicit_options
, &text
);
870 complete_on_enum (tracker
, explicit_options
, text
, text
);
871 /* There are keywords that start with "-". Include them, too. */
872 complete_on_enum (tracker
, linespec_keywords
, text
, text
);
876 /* Completing on value. */
877 enum explicit_location_match_type what
878 = (explicit_location_match_type
) keyword
;
880 if (quoted_arg_start
!= NULL
&& quoted_arg_end
!= NULL
)
882 if (quoted_arg_end
[1] == '\0')
884 /* If completing a quoted string with the cursor right
885 at the terminating quote char, complete the
886 completion word without interpretation, so that
887 readline advances the cursor one whitespace past the
888 quote, even if there's no match. This makes these
889 cases behave the same:
891 before: "b -function function()"
892 after: "b -function function() "
894 before: "b -function 'function()'"
895 after: "b -function 'function()' "
897 and trusts the user in this case:
899 before: "b -function 'not_loaded_function_yet()'"
900 after: "b -function 'not_loaded_function_yet()' "
902 tracker
.add_completion (make_unique_xstrdup (text
));
904 else if (quoted_arg_end
[1] == ' ')
906 /* We're maybe past the explicit location argument.
907 Skip the argument without interpretation, assuming the
908 user may want to create pending breakpoint. Offer
909 the keyword and explicit location options as possible
911 tracker
.advance_custom_word_point_by (strlen (text
));
912 complete_on_enum (tracker
, linespec_keywords
, "", "");
913 complete_on_enum (tracker
, explicit_options
, "", "");
918 /* Now gather matches */
919 collect_explicit_location_matches (tracker
, location
, what
, text
,
924 /* A completer for locations. */
927 location_completer (struct cmd_list_element
*ignore
,
928 completion_tracker
&tracker
,
929 const char *text
, const char * /* word */)
931 int found_probe_option
= -1;
933 /* If we have a probe modifier, skip it. This can only appear as
934 first argument. Until we have a specific completer for probes,
935 falling back to the linespec completer for the remainder of the
936 line is better than nothing. */
937 if (text
[0] == '-' && text
[1] == 'p')
938 found_probe_option
= skip_keyword (tracker
, probe_options
, &text
);
940 const char *option_text
= text
;
941 int saved_word_point
= tracker
.custom_word_point ();
943 const char *copy
= text
;
945 explicit_completion_info completion_info
;
946 event_location_up location
947 = string_to_explicit_location (©
, current_language
,
949 if (completion_info
.quoted_arg_start
!= NULL
950 && completion_info
.quoted_arg_end
== NULL
)
952 /* Found an unbalanced quote. */
953 tracker
.set_quote_char (*completion_info
.quoted_arg_start
);
954 tracker
.advance_custom_word_point_by (1);
957 if (completion_info
.saw_explicit_location_option
)
961 tracker
.advance_custom_word_point_by (copy
- text
);
964 /* We found a terminator at the tail end of the string,
965 which means we're past the explicit location options. We
966 may have a keyword to complete on. If we have a whole
967 keyword, then complete whatever comes after as an
968 expression. This is mainly for the "if" keyword. If the
969 "thread" and "task" keywords gain their own completers,
970 they should be used here. */
971 int keyword
= skip_keyword (tracker
, linespec_keywords
, &text
);
975 complete_on_enum (tracker
, linespec_keywords
, text
, text
);
980 = advance_to_expression_complete_word_point (tracker
, text
);
981 complete_expression (tracker
, text
, word
);
986 tracker
.advance_custom_word_point_by (completion_info
.last_option
988 text
= completion_info
.last_option
;
990 complete_explicit_location (tracker
, location
.get (), text
,
992 completion_info
.quoted_arg_start
,
993 completion_info
.quoted_arg_end
);
997 /* This is an address or linespec location. */
998 else if (location
!= NULL
)
1000 /* Handle non-explicit location options. */
1002 int keyword
= skip_keyword (tracker
, explicit_options
, &text
);
1004 complete_on_enum (tracker
, explicit_options
, text
, text
);
1007 tracker
.advance_custom_word_point_by (copy
- text
);
1010 symbol_name_match_type match_type
1011 = get_explicit_location (location
.get ())->func_name_match_type
;
1012 complete_address_and_linespec_locations (tracker
, text
, match_type
);
1018 complete_address_and_linespec_locations (tracker
, text
,
1019 symbol_name_match_type::WILD
);
1022 /* Add matches for option names, if either:
1024 - Some completer above found some matches, but the word point did
1025 not advance (e.g., "b <tab>" finds all functions, or "b -<tab>"
1026 matches all objc selectors), or;
1028 - Some completer above advanced the word point, but found no
1031 if ((text
[0] == '-' || text
[0] == '\0')
1032 && (!tracker
.have_completions ()
1033 || tracker
.custom_word_point () == saved_word_point
))
1035 tracker
.set_custom_word_point (saved_word_point
);
1038 if (found_probe_option
== -1)
1039 complete_on_enum (tracker
, probe_options
, text
, text
);
1040 complete_on_enum (tracker
, explicit_options
, text
, text
);
1044 /* The corresponding completer_handle_brkchars
1048 location_completer_handle_brkchars (struct cmd_list_element
*ignore
,
1049 completion_tracker
&tracker
,
1051 const char *word_ignored
)
1053 tracker
.set_use_custom_word_point (true);
1055 location_completer (ignore
, tracker
, text
, NULL
);
1058 /* See completer.h. */
1061 complete_expression (completion_tracker
&tracker
,
1062 const char *text
, const char *word
)
1065 std::unique_ptr
<expr_completion_base
> expr_completer
;
1067 /* Perform a tentative parse of the expression, to see whether a
1068 field completion is required. */
1071 exp
= parse_expression_for_completion (text
, &expr_completer
);
1073 catch (const gdb_exception_error
&except
)
1078 /* Part of the parse_expression_for_completion contract. */
1079 gdb_assert ((exp
== nullptr) == (expr_completer
== nullptr));
1080 if (expr_completer
!= nullptr
1081 && expr_completer
->complete (exp
.get (), tracker
))
1084 complete_files_symbols (tracker
, text
, word
);
1087 /* Complete on expressions. Often this means completing on symbol
1088 names, but some language parsers also have support for completing
1092 expression_completer (struct cmd_list_element
*ignore
,
1093 completion_tracker
&tracker
,
1094 const char *text
, const char *word
)
1096 complete_expression (tracker
, text
, word
);
1099 /* See definition in completer.h. */
1102 set_rl_completer_word_break_characters (const char *break_chars
)
1104 rl_completer_word_break_characters
= (char *) break_chars
;
1107 /* Complete on symbols. */
1110 symbol_completer (struct cmd_list_element
*ignore
,
1111 completion_tracker
&tracker
,
1112 const char *text
, const char *word
)
1114 collect_symbol_completion_matches (tracker
, complete_symbol_mode::EXPRESSION
,
1115 symbol_name_match_type::EXPRESSION
,
1119 /* Here are some useful test cases for completion. FIXME: These
1120 should be put in the test suite. They should be tested with both
1123 "show output-" "radix"
1124 "show output" "-radix"
1125 "p" ambiguous (commands starting with p--path, print, printf, etc.)
1126 "p " ambiguous (all symbols)
1127 "info t foo" no completions
1128 "info t " no completions
1129 "info t" ambiguous ("info target", "info terminal", etc.)
1130 "info ajksdlfk" no completions
1131 "info ajksdlfk " no completions
1133 "info " ambiguous (all info commands)
1134 "p \"a" no completions (string constant)
1135 "p 'a" ambiguous (all symbols starting with a)
1136 "p b-a" ambiguous (all symbols starting with a)
1137 "p b-" ambiguous (all symbols)
1138 "file Make" "file" (word break hard to screw up here)
1139 "file ../gdb.stabs/we" "ird" (needs to not break word at slash)
1142 enum complete_line_internal_reason
1144 /* Preliminary phase, called by gdb_completion_word_break_characters
1145 function, is used to either:
1147 #1 - Determine the set of chars that are word delimiters
1148 depending on the current command in line_buffer.
1150 #2 - Manually advance RL_POINT to the "word break" point instead
1151 of letting readline do it (based on too-simple character
1154 Simpler completers that just pass a brkchars array to readline
1155 (#1 above) must defer generating the completions to the main
1156 phase (below). No completion list should be generated in this
1159 OTOH, completers that manually advance the word point(#2 above)
1160 must set "use_custom_word_point" in the tracker and generate
1161 their completion in this phase. Note that this is the convenient
1162 thing to do since they'll be parsing the input line anyway. */
1165 /* Main phase, called by complete_line function, is used to get the
1166 list of possible completions. */
1169 /* Special case when completing a 'help' command. In this case,
1170 once sub-command completions are exhausted, we simply return
1175 /* Helper for complete_line_internal to simplify it. */
1178 complete_line_internal_normal_command (completion_tracker
&tracker
,
1179 const char *command
, const char *word
,
1180 const char *cmd_args
,
1181 complete_line_internal_reason reason
,
1182 struct cmd_list_element
*c
)
1184 const char *p
= cmd_args
;
1186 if (c
->completer
== filename_completer
)
1188 /* Many commands which want to complete on file names accept
1189 several file names, as in "run foo bar >>baz". So we don't
1190 want to complete the entire text after the command, just the
1191 last word. To this end, we need to find the beginning of the
1192 file name by starting at `word' and going backwards. */
1195 && strchr (gdb_completer_file_name_break_characters
,
1201 if (reason
== handle_brkchars
)
1203 completer_handle_brkchars_ftype
*brkchars_fn
;
1205 if (c
->completer_handle_brkchars
!= NULL
)
1206 brkchars_fn
= c
->completer_handle_brkchars
;
1210 = (completer_handle_brkchars_func_for_completer
1214 brkchars_fn (c
, tracker
, p
, word
);
1217 if (reason
!= handle_brkchars
&& c
->completer
!= NULL
)
1218 (*c
->completer
) (c
, tracker
, p
, word
);
1221 /* Internal function used to handle completions.
1224 TEXT is the caller's idea of the "word" we are looking at.
1226 LINE_BUFFER is available to be looked at; it contains the entire
1227 text of the line. POINT is the offset in that line of the cursor.
1228 You should pretend that the line ends at POINT.
1230 See complete_line_internal_reason for description of REASON. */
1233 complete_line_internal_1 (completion_tracker
&tracker
,
1235 const char *line_buffer
, int point
,
1236 complete_line_internal_reason reason
)
1240 int ignore_help_classes
;
1241 /* Pointer within tmp_command which corresponds to text. */
1243 struct cmd_list_element
*c
, *result_list
;
1245 /* Choose the default set of word break characters to break
1246 completions. If we later find out that we are doing completions
1247 on command strings (as opposed to strings supplied by the
1248 individual command completer functions, which can be any string)
1249 then we will switch to the special word break set for command
1250 strings, which leaves out the '-' and '.' character used in some
1252 set_rl_completer_word_break_characters
1253 (current_language
->word_break_characters ());
1255 /* Decide whether to complete on a list of gdb commands or on
1257 tmp_command
= (char *) alloca (point
+ 1);
1260 /* The help command should complete help aliases. */
1261 ignore_help_classes
= reason
!= handle_help
;
1263 strncpy (tmp_command
, line_buffer
, point
);
1264 tmp_command
[point
] = '\0';
1265 if (reason
== handle_brkchars
)
1267 gdb_assert (text
== NULL
);
1272 /* Since text always contains some number of characters leading up
1273 to point, we can find the equivalent position in tmp_command
1274 by subtracting that many characters from the end of tmp_command. */
1275 word
= tmp_command
+ point
- strlen (text
);
1278 /* Move P up to the start of the command. */
1279 p
= skip_spaces (p
);
1283 /* An empty line is ambiguous; that is, it could be any
1285 c
= CMD_LIST_AMBIGUOUS
;
1289 c
= lookup_cmd_1 (&p
, cmdlist
, &result_list
, NULL
, ignore_help_classes
,
1292 /* Move p up to the next interesting thing. */
1293 while (*p
== ' ' || *p
== '\t')
1298 tracker
.advance_custom_word_point_by (p
- tmp_command
);
1302 /* It is an unrecognized command. So there are no
1303 possible completions. */
1305 else if (c
== CMD_LIST_AMBIGUOUS
)
1309 /* lookup_cmd_1 advances p up to the first ambiguous thing, but
1310 doesn't advance over that thing itself. Do so now. */
1312 while (valid_cmd_char_p (*q
))
1314 if (q
!= tmp_command
+ point
)
1316 /* There is something beyond the ambiguous
1317 command, so there are no possible completions. For
1318 example, "info t " or "info t foo" does not complete
1319 to anything, because "info t" can be "info target" or
1324 /* We're trying to complete on the command which was ambiguous.
1325 This we can deal with. */
1328 if (reason
!= handle_brkchars
)
1329 complete_on_cmdlist (*result_list
->subcommands
, tracker
, p
,
1330 word
, ignore_help_classes
);
1334 if (reason
!= handle_brkchars
)
1335 complete_on_cmdlist (cmdlist
, tracker
, p
, word
,
1336 ignore_help_classes
);
1338 /* Ensure that readline does the right thing with respect to
1339 inserting quotes. */
1340 set_rl_completer_word_break_characters
1341 (gdb_completer_command_word_break_characters
);
1346 /* We've recognized a full command. */
1348 if (p
== tmp_command
+ point
)
1350 /* There is no non-whitespace in the line beyond the
1353 if (p
[-1] == ' ' || p
[-1] == '\t')
1355 /* The command is followed by whitespace; we need to
1356 complete on whatever comes after command. */
1357 if (c
->is_prefix ())
1359 /* It is a prefix command; what comes after it is
1360 a subcommand (e.g. "info "). */
1361 if (reason
!= handle_brkchars
)
1362 complete_on_cmdlist (*c
->subcommands
, tracker
, p
, word
,
1363 ignore_help_classes
);
1365 /* Ensure that readline does the right thing
1366 with respect to inserting quotes. */
1367 set_rl_completer_word_break_characters
1368 (gdb_completer_command_word_break_characters
);
1370 else if (reason
== handle_help
)
1374 if (reason
!= handle_brkchars
)
1375 complete_on_enum (tracker
, c
->enums
, p
, word
);
1376 set_rl_completer_word_break_characters
1377 (gdb_completer_command_word_break_characters
);
1381 /* It is a normal command; what comes after it is
1382 completed by the command's completer function. */
1383 complete_line_internal_normal_command (tracker
,
1384 tmp_command
, word
, p
,
1390 /* The command is not followed by whitespace; we need to
1391 complete on the command itself, e.g. "p" which is a
1392 command itself but also can complete to "print", "ptype"
1396 /* Find the command we are completing on. */
1398 while (q
> tmp_command
)
1400 if (valid_cmd_char_p (q
[-1]))
1406 /* Move the custom word point back too. */
1407 tracker
.advance_custom_word_point_by (q
- p
);
1409 if (reason
!= handle_brkchars
)
1410 complete_on_cmdlist (result_list
, tracker
, q
, word
,
1411 ignore_help_classes
);
1413 /* Ensure that readline does the right thing
1414 with respect to inserting quotes. */
1415 set_rl_completer_word_break_characters
1416 (gdb_completer_command_word_break_characters
);
1419 else if (reason
== handle_help
)
1423 /* There is non-whitespace beyond the command. */
1425 if (c
->is_prefix () && !c
->allow_unknown
)
1427 /* It is an unrecognized subcommand of a prefix command,
1428 e.g. "info adsfkdj". */
1432 if (reason
!= handle_brkchars
)
1433 complete_on_enum (tracker
, c
->enums
, p
, word
);
1437 /* It is a normal command. */
1438 complete_line_internal_normal_command (tracker
,
1439 tmp_command
, word
, p
,
1446 /* Wrapper around complete_line_internal_1 to handle
1447 MAX_COMPLETIONS_REACHED_ERROR. */
1450 complete_line_internal (completion_tracker
&tracker
,
1452 const char *line_buffer
, int point
,
1453 complete_line_internal_reason reason
)
1457 complete_line_internal_1 (tracker
, text
, line_buffer
, point
, reason
);
1459 catch (const gdb_exception_error
&except
)
1461 if (except
.error
!= MAX_COMPLETIONS_REACHED_ERROR
)
1466 /* See completer.h. */
1468 int max_completions
= 200;
1470 /* Initial size of the table. It automagically grows from here. */
1471 #define INITIAL_COMPLETION_HTAB_SIZE 200
1473 /* See completer.h. */
1475 completion_tracker::completion_tracker ()
1477 discard_completions ();
1480 /* See completer.h. */
1483 completion_tracker::discard_completions ()
1485 xfree (m_lowest_common_denominator
);
1486 m_lowest_common_denominator
= NULL
;
1488 m_lowest_common_denominator_unique
= false;
1489 m_lowest_common_denominator_valid
= false;
1491 m_entries_hash
.reset (nullptr);
1493 /* A callback used by the hash table to compare new entries with existing
1494 entries. We can't use the standard htab_eq_string function here as the
1495 key to our hash is just a single string, while the values we store in
1496 the hash are a struct containing multiple strings. */
1497 static auto entry_eq_func
1498 = [] (const void *first
, const void *second
) -> int
1500 /* The FIRST argument is the entry already in the hash table, and
1501 the SECOND argument is the new item being inserted. */
1502 const completion_hash_entry
*entry
1503 = (const completion_hash_entry
*) first
;
1504 const char *name_str
= (const char *) second
;
1506 return entry
->is_name_eq (name_str
);
1509 /* Callback used by the hash table to compute the hash value for an
1510 existing entry. This is needed when expanding the hash table. */
1511 static auto entry_hash_func
1512 = [] (const void *arg
) -> hashval_t
1514 const completion_hash_entry
*entry
1515 = (const completion_hash_entry
*) arg
;
1516 return entry
->hash_name ();
1519 m_entries_hash
.reset
1520 (htab_create_alloc (INITIAL_COMPLETION_HTAB_SIZE
,
1521 entry_hash_func
, entry_eq_func
,
1522 htab_delete_entry
<completion_hash_entry
>,
1526 /* See completer.h. */
1528 completion_tracker::~completion_tracker ()
1530 xfree (m_lowest_common_denominator
);
1533 /* See completer.h. */
1536 completion_tracker::maybe_add_completion
1537 (gdb::unique_xmalloc_ptr
<char> name
,
1538 completion_match_for_lcd
*match_for_lcd
,
1539 const char *text
, const char *word
)
1543 if (max_completions
== 0)
1546 if (htab_elements (m_entries_hash
.get ()) >= max_completions
)
1549 hashval_t hash
= htab_hash_string (name
.get ());
1550 slot
= htab_find_slot_with_hash (m_entries_hash
.get (), name
.get (),
1552 if (*slot
== HTAB_EMPTY_ENTRY
)
1554 const char *match_for_lcd_str
= NULL
;
1556 if (match_for_lcd
!= NULL
)
1557 match_for_lcd_str
= match_for_lcd
->finish ();
1559 if (match_for_lcd_str
== NULL
)
1560 match_for_lcd_str
= name
.get ();
1562 gdb::unique_xmalloc_ptr
<char> lcd
1563 = make_completion_match_str (match_for_lcd_str
, text
, word
);
1565 size_t lcd_len
= strlen (lcd
.get ());
1566 *slot
= new completion_hash_entry (std::move (name
), std::move (lcd
));
1568 m_lowest_common_denominator_valid
= false;
1569 m_lowest_common_denominator_max_length
1570 = std::max (m_lowest_common_denominator_max_length
, lcd_len
);
1576 /* See completer.h. */
1579 completion_tracker::add_completion (gdb::unique_xmalloc_ptr
<char> name
,
1580 completion_match_for_lcd
*match_for_lcd
,
1581 const char *text
, const char *word
)
1583 if (!maybe_add_completion (std::move (name
), match_for_lcd
, text
, word
))
1584 throw_error (MAX_COMPLETIONS_REACHED_ERROR
, _("Max completions reached."));
1587 /* See completer.h. */
1590 completion_tracker::add_completions (completion_list
&&list
)
1592 for (auto &candidate
: list
)
1593 add_completion (std::move (candidate
));
1596 /* See completer.h. */
1599 completion_tracker::remove_completion (const char *name
)
1601 hashval_t hash
= htab_hash_string (name
);
1602 if (htab_find_slot_with_hash (m_entries_hash
.get (), name
, hash
, NO_INSERT
)
1605 htab_remove_elt_with_hash (m_entries_hash
.get (), name
, hash
);
1606 m_lowest_common_denominator_valid
= false;
1610 /* Helper for the make_completion_match_str overloads. Returns NULL
1611 as an indication that we want MATCH_NAME exactly. It is up to the
1612 caller to xstrdup that string if desired. */
1615 make_completion_match_str_1 (const char *match_name
,
1616 const char *text
, const char *word
)
1622 /* Return NULL as an indication that we want MATCH_NAME
1626 else if (word
> text
)
1628 /* Return some portion of MATCH_NAME. */
1629 newobj
= xstrdup (match_name
+ (word
- text
));
1633 /* Return some of WORD plus MATCH_NAME. */
1634 size_t len
= strlen (match_name
);
1635 newobj
= (char *) xmalloc (text
- word
+ len
+ 1);
1636 memcpy (newobj
, word
, text
- word
);
1637 memcpy (newobj
+ (text
- word
), match_name
, len
+ 1);
1643 /* See completer.h. */
1645 gdb::unique_xmalloc_ptr
<char>
1646 make_completion_match_str (const char *match_name
,
1647 const char *text
, const char *word
)
1649 char *newobj
= make_completion_match_str_1 (match_name
, text
, word
);
1651 newobj
= xstrdup (match_name
);
1652 return gdb::unique_xmalloc_ptr
<char> (newobj
);
1655 /* See completer.h. */
1657 gdb::unique_xmalloc_ptr
<char>
1658 make_completion_match_str (gdb::unique_xmalloc_ptr
<char> &&match_name
,
1659 const char *text
, const char *word
)
1661 char *newobj
= make_completion_match_str_1 (match_name
.get (), text
, word
);
1663 return std::move (match_name
);
1664 return gdb::unique_xmalloc_ptr
<char> (newobj
);
1667 /* See complete.h. */
1670 complete (const char *line
, char const **word
, int *quote_char
)
1672 completion_tracker tracker_handle_brkchars
;
1673 completion_tracker tracker_handle_completions
;
1674 completion_tracker
*tracker
;
1676 /* The WORD should be set to the end of word to complete. We initialize
1677 to the completion point which is assumed to be at the end of LINE.
1678 This leaves WORD to be initialized to a sensible value in cases
1679 completion_find_completion_word() fails i.e., throws an exception.
1681 *word
= line
+ strlen (line
);
1685 *word
= completion_find_completion_word (tracker_handle_brkchars
,
1688 /* Completers that provide a custom word point in the
1689 handle_brkchars phase also compute their completions then.
1690 Completers that leave the completion word handling to readline
1691 must be called twice. */
1692 if (tracker_handle_brkchars
.use_custom_word_point ())
1693 tracker
= &tracker_handle_brkchars
;
1696 complete_line (tracker_handle_completions
, *word
, line
, strlen (line
));
1697 tracker
= &tracker_handle_completions
;
1700 catch (const gdb_exception
&ex
)
1705 return tracker
->build_completion_result (*word
, *word
- line
, strlen (line
));
1709 /* Generate completions all at once. Does nothing if max_completions
1710 is 0. If max_completions is non-negative, this will collect at
1711 most max_completions strings.
1713 TEXT is the caller's idea of the "word" we are looking at.
1715 LINE_BUFFER is available to be looked at; it contains the entire
1718 POINT is the offset in that line of the cursor. You
1719 should pretend that the line ends at POINT. */
1722 complete_line (completion_tracker
&tracker
,
1723 const char *text
, const char *line_buffer
, int point
)
1725 if (max_completions
== 0)
1727 complete_line_internal (tracker
, text
, line_buffer
, point
,
1728 handle_completions
);
1731 /* Complete on command names. Used by "help". */
1734 command_completer (struct cmd_list_element
*ignore
,
1735 completion_tracker
&tracker
,
1736 const char *text
, const char *word
)
1738 complete_line_internal (tracker
, word
, text
,
1739 strlen (text
), handle_help
);
1742 /* The corresponding completer_handle_brkchars implementation. */
1745 command_completer_handle_brkchars (struct cmd_list_element
*ignore
,
1746 completion_tracker
&tracker
,
1747 const char *text
, const char *word
)
1749 set_rl_completer_word_break_characters
1750 (gdb_completer_command_word_break_characters
);
1753 /* Complete on signals. */
1756 signal_completer (struct cmd_list_element
*ignore
,
1757 completion_tracker
&tracker
,
1758 const char *text
, const char *word
)
1760 size_t len
= strlen (word
);
1762 const char *signame
;
1764 for (signum
= GDB_SIGNAL_FIRST
; signum
!= GDB_SIGNAL_LAST
; ++signum
)
1766 /* Can't handle this, so skip it. */
1767 if (signum
== GDB_SIGNAL_0
)
1770 signame
= gdb_signal_to_name ((enum gdb_signal
) signum
);
1772 /* Ignore the unknown signal case. */
1773 if (!signame
|| strcmp (signame
, "?") == 0)
1776 if (strncasecmp (signame
, word
, len
) == 0)
1777 tracker
.add_completion (make_unique_xstrdup (signame
));
1781 /* Bit-flags for selecting what the register and/or register-group
1782 completer should complete on. */
1784 enum reg_completer_target
1786 complete_register_names
= 0x1,
1787 complete_reggroup_names
= 0x2
1789 DEF_ENUM_FLAGS_TYPE (enum reg_completer_target
, reg_completer_targets
);
1791 /* Complete register names and/or reggroup names based on the value passed
1792 in TARGETS. At least one bit in TARGETS must be set. */
1795 reg_or_group_completer_1 (completion_tracker
&tracker
,
1796 const char *text
, const char *word
,
1797 reg_completer_targets targets
)
1799 size_t len
= strlen (word
);
1800 struct gdbarch
*gdbarch
;
1803 gdb_assert ((targets
& (complete_register_names
1804 | complete_reggroup_names
)) != 0);
1805 gdbarch
= get_current_arch ();
1807 if ((targets
& complete_register_names
) != 0)
1812 (name
= user_reg_map_regnum_to_name (gdbarch
, i
)) != NULL
;
1815 if (*name
!= '\0' && strncmp (word
, name
, len
) == 0)
1816 tracker
.add_completion (make_unique_xstrdup (name
));
1820 if ((targets
& complete_reggroup_names
) != 0)
1822 struct reggroup
*group
;
1824 for (group
= reggroup_next (gdbarch
, NULL
);
1826 group
= reggroup_next (gdbarch
, group
))
1828 name
= reggroup_name (group
);
1829 if (strncmp (word
, name
, len
) == 0)
1830 tracker
.add_completion (make_unique_xstrdup (name
));
1835 /* Perform completion on register and reggroup names. */
1838 reg_or_group_completer (struct cmd_list_element
*ignore
,
1839 completion_tracker
&tracker
,
1840 const char *text
, const char *word
)
1842 reg_or_group_completer_1 (tracker
, text
, word
,
1843 (complete_register_names
1844 | complete_reggroup_names
));
1847 /* Perform completion on reggroup names. */
1850 reggroup_completer (struct cmd_list_element
*ignore
,
1851 completion_tracker
&tracker
,
1852 const char *text
, const char *word
)
1854 reg_or_group_completer_1 (tracker
, text
, word
,
1855 complete_reggroup_names
);
1858 /* The default completer_handle_brkchars implementation. */
1861 default_completer_handle_brkchars (struct cmd_list_element
*ignore
,
1862 completion_tracker
&tracker
,
1863 const char *text
, const char *word
)
1865 set_rl_completer_word_break_characters
1866 (current_language
->word_break_characters ());
1869 /* See definition in completer.h. */
1871 completer_handle_brkchars_ftype
*
1872 completer_handle_brkchars_func_for_completer (completer_ftype
*fn
)
1874 if (fn
== filename_completer
)
1875 return filename_completer_handle_brkchars
;
1877 if (fn
== location_completer
)
1878 return location_completer_handle_brkchars
;
1880 if (fn
== command_completer
)
1881 return command_completer_handle_brkchars
;
1883 return default_completer_handle_brkchars
;
1886 /* Used as brkchars when we want to tell readline we have a custom
1887 word point. We do that by making our rl_completion_word_break_hook
1888 set RL_POINT to the desired word point, and return the character at
1889 the word break point as the break char. This is two bytes in order
1890 to fit one break character plus the terminating null. */
1891 static char gdb_custom_word_point_brkchars
[2];
1893 /* Since rl_basic_quote_characters is not completer-specific, we save
1894 its original value here, in order to be able to restore it in
1895 gdb_rl_attempted_completion_function. */
1896 static const char *gdb_org_rl_basic_quote_characters
= rl_basic_quote_characters
;
1898 /* Get the list of chars that are considered as word breaks
1899 for the current command. */
1902 gdb_completion_word_break_characters_throw ()
1904 /* New completion starting. Get rid of the previous tracker and
1906 delete current_completion
.tracker
;
1907 current_completion
.tracker
= new completion_tracker ();
1909 completion_tracker
&tracker
= *current_completion
.tracker
;
1911 complete_line_internal (tracker
, NULL
, rl_line_buffer
,
1912 rl_point
, handle_brkchars
);
1914 if (tracker
.use_custom_word_point ())
1916 gdb_assert (tracker
.custom_word_point () > 0);
1917 rl_point
= tracker
.custom_word_point () - 1;
1919 gdb_assert (rl_point
>= 0 && rl_point
< strlen (rl_line_buffer
));
1921 gdb_custom_word_point_brkchars
[0] = rl_line_buffer
[rl_point
];
1922 rl_completer_word_break_characters
= gdb_custom_word_point_brkchars
;
1923 rl_completer_quote_characters
= NULL
;
1925 /* Clear this too, so that if we're completing a quoted string,
1926 readline doesn't consider the quote character a delimiter.
1927 If we didn't do this, readline would auto-complete {b
1928 'fun<tab>} to {'b 'function()'}, i.e., add the terminating
1929 \', but, it wouldn't append the separator space either, which
1930 is not desirable. So instead we take care of appending the
1931 quote character to the LCD ourselves, in
1932 gdb_rl_attempted_completion_function. Since this global is
1933 not just completer-specific, we'll restore it back to the
1934 default in gdb_rl_attempted_completion_function. */
1935 rl_basic_quote_characters
= NULL
;
1938 return (char *) rl_completer_word_break_characters
;
1942 gdb_completion_word_break_characters ()
1944 /* New completion starting. */
1945 current_completion
.aborted
= false;
1949 return gdb_completion_word_break_characters_throw ();
1951 catch (const gdb_exception
&ex
)
1953 /* Set this to that gdb_rl_attempted_completion_function knows
1955 current_completion
.aborted
= true;
1961 /* See completer.h. */
1964 completion_find_completion_word (completion_tracker
&tracker
, const char *text
,
1967 size_t point
= strlen (text
);
1969 complete_line_internal (tracker
, NULL
, text
, point
, handle_brkchars
);
1971 if (tracker
.use_custom_word_point ())
1973 gdb_assert (tracker
.custom_word_point () > 0);
1974 *quote_char
= tracker
.quote_char ();
1975 return text
+ tracker
.custom_word_point ();
1978 gdb_rl_completion_word_info info
;
1980 info
.word_break_characters
= rl_completer_word_break_characters
;
1981 info
.quote_characters
= gdb_completer_quote_characters
;
1982 info
.basic_quote_characters
= rl_basic_quote_characters
;
1984 return gdb_rl_find_completion_word (&info
, quote_char
, NULL
, text
);
1987 /* See completer.h. */
1990 completion_tracker::recompute_lcd_visitor (completion_hash_entry
*entry
)
1992 if (!m_lowest_common_denominator_valid
)
1994 /* This is the first lowest common denominator that we are
1995 considering, just copy it in. */
1996 strcpy (m_lowest_common_denominator
, entry
->get_lcd ());
1997 m_lowest_common_denominator_unique
= true;
1998 m_lowest_common_denominator_valid
= true;
2002 /* Find the common denominator between the currently-known lowest
2003 common denominator and NEW_MATCH_UP. That becomes the new lowest
2004 common denominator. */
2006 const char *new_match
= entry
->get_lcd ();
2009 (new_match
[i
] != '\0'
2010 && new_match
[i
] == m_lowest_common_denominator
[i
]);
2013 if (m_lowest_common_denominator
[i
] != new_match
[i
])
2015 m_lowest_common_denominator
[i
] = '\0';
2016 m_lowest_common_denominator_unique
= false;
2021 /* See completer.h. */
2024 completion_tracker::recompute_lowest_common_denominator ()
2026 /* We've already done this. */
2027 if (m_lowest_common_denominator_valid
)
2030 /* Resize the storage to ensure we have enough space, the plus one gives
2031 us space for the trailing null terminator we will include. */
2032 m_lowest_common_denominator
2033 = (char *) xrealloc (m_lowest_common_denominator
,
2034 m_lowest_common_denominator_max_length
+ 1);
2036 /* Callback used to visit each entry in the m_entries_hash. */
2038 = [] (void **slot
, void *info
) -> int
2040 completion_tracker
*obj
= (completion_tracker
*) info
;
2041 completion_hash_entry
*entry
= (completion_hash_entry
*) *slot
;
2042 obj
->recompute_lcd_visitor (entry
);
2046 htab_traverse (m_entries_hash
.get (), visitor_func
, this);
2047 m_lowest_common_denominator_valid
= true;
2050 /* See completer.h. */
2053 completion_tracker::advance_custom_word_point_by (int len
)
2055 m_custom_word_point
+= len
;
2058 /* Build a new C string that is a copy of LCD with the whitespace of
2059 ORIG/ORIG_LEN preserved.
2061 Say the user is completing a symbol name, with spaces, like:
2065 and the resulting completion match is:
2069 we want to end up with an input line like:
2072 ^^^^^^^ => text from LCD [1], whitespace from ORIG preserved.
2073 ^^ => new text from LCD
2075 [1] - We must take characters from the LCD instead of the original
2076 text, since some completions want to change upper/lowercase. E.g.:
2082 "handle SIG[QUIT|etc.]"
2086 expand_preserving_ws (const char *orig
, size_t orig_len
,
2089 const char *p_orig
= orig
;
2090 const char *orig_end
= orig
+ orig_len
;
2091 const char *p_lcd
= lcd
;
2094 while (p_orig
< orig_end
)
2098 while (p_orig
< orig_end
&& *p_orig
== ' ')
2100 p_lcd
= skip_spaces (p_lcd
);
2104 /* Take characters from the LCD instead of the original
2105 text, since some completions change upper/lowercase.
2109 "handle SIG[QUIT|etc.]"
2117 while (*p_lcd
!= '\0')
2120 return xstrdup (res
.c_str ());
2123 /* See completer.h. */
2126 completion_tracker::build_completion_result (const char *text
,
2129 size_t element_count
= htab_elements (m_entries_hash
.get ());
2131 if (element_count
== 0)
2134 /* +1 for the LCD, and +1 for NULL termination. */
2135 char **match_list
= XNEWVEC (char *, 1 + element_count
+ 1);
2137 /* Build replacement word, based on the LCD. */
2139 recompute_lowest_common_denominator ();
2141 = expand_preserving_ws (text
, end
- start
,
2142 m_lowest_common_denominator
);
2144 if (m_lowest_common_denominator_unique
)
2146 /* We don't rely on readline appending the quote char as
2147 delimiter as then readline wouldn't append the ' ' after the
2149 char buf
[2] = { (char) quote_char () };
2151 match_list
[0] = reconcat (match_list
[0], match_list
[0],
2152 buf
, (char *) NULL
);
2153 match_list
[1] = NULL
;
2155 /* If the tracker wants to, or we already have a space at the
2156 end of the match, tell readline to skip appending
2158 char *match
= match_list
[0];
2159 bool completion_suppress_append
2160 = (suppress_append_ws ()
2161 || (match
[0] != '\0'
2162 && match
[strlen (match
) - 1] == ' '));
2164 return completion_result (match_list
, 1, completion_suppress_append
);
2168 /* State object used while building the completion list. */
2171 list_builder (char **ml
)
2176 /* The list we are filling. */
2179 /* The next index in the list to write to. */
2182 list_builder
builder (match_list
);
2184 /* Visit each entry in m_entries_hash and add it to the completion
2185 list, updating the builder state object. */
2187 = [] (void **slot
, void *info
) -> int
2189 completion_hash_entry
*entry
= (completion_hash_entry
*) *slot
;
2190 list_builder
*state
= (list_builder
*) info
;
2192 state
->match_list
[state
->index
] = entry
->release_name ();
2197 /* Build the completion list and add a null at the end. */
2198 htab_traverse_noresize (m_entries_hash
.get (), func
, &builder
);
2199 match_list
[builder
.index
] = NULL
;
2201 return completion_result (match_list
, builder
.index
- 1, false);
2205 /* See completer.h */
2207 completion_result::completion_result ()
2208 : match_list (NULL
), number_matches (0),
2209 completion_suppress_append (false)
2212 /* See completer.h */
2214 completion_result::completion_result (char **match_list_
,
2215 size_t number_matches_
,
2216 bool completion_suppress_append_
)
2217 : match_list (match_list_
),
2218 number_matches (number_matches_
),
2219 completion_suppress_append (completion_suppress_append_
)
2222 /* See completer.h */
2224 completion_result::~completion_result ()
2226 reset_match_list ();
2229 /* See completer.h */
2231 completion_result::completion_result (completion_result
&&rhs
) noexcept
2232 : match_list (rhs
.match_list
),
2233 number_matches (rhs
.number_matches
)
2235 rhs
.match_list
= NULL
;
2236 rhs
.number_matches
= 0;
2239 /* See completer.h */
2242 completion_result::release_match_list ()
2244 char **ret
= match_list
;
2249 /* See completer.h */
2252 completion_result::sort_match_list ()
2254 if (number_matches
> 1)
2256 /* Element 0 is special (it's the common prefix), leave it
2258 std::sort (&match_list
[1],
2259 &match_list
[number_matches
+ 1],
2264 /* See completer.h */
2267 completion_result::reset_match_list ()
2269 if (match_list
!= NULL
)
2271 for (char **p
= match_list
; *p
!= NULL
; p
++)
2278 /* Helper for gdb_rl_attempted_completion_function, which does most of
2279 the work. This is called by readline to build the match list array
2280 and to determine the lowest common denominator. The real matches
2281 list starts at match[1], while match[0] is the slot holding
2282 readline's idea of the lowest common denominator of all matches,
2283 which is what readline replaces the completion "word" with.
2285 TEXT is the caller's idea of the "word" we are looking at, as
2286 computed in the handle_brkchars phase.
2288 START is the offset from RL_LINE_BUFFER where TEXT starts. END is
2289 the offset from RL_LINE_BUFFER where TEXT ends (i.e., where
2292 You should thus pretend that the line ends at END (relative to
2295 RL_LINE_BUFFER contains the entire text of the line. RL_POINT is
2296 the offset in that line of the cursor. You should pretend that the
2299 Returns NULL if there are no completions. */
2302 gdb_rl_attempted_completion_function_throw (const char *text
, int start
, int end
)
2304 /* Completers that provide a custom word point in the
2305 handle_brkchars phase also compute their completions then.
2306 Completers that leave the completion word handling to readline
2307 must be called twice. If rl_point (i.e., END) is at column 0,
2308 then readline skips the handle_brkchars phase, and so we create a
2309 tracker now in that case too. */
2310 if (end
== 0 || !current_completion
.tracker
->use_custom_word_point ())
2312 delete current_completion
.tracker
;
2313 current_completion
.tracker
= new completion_tracker ();
2315 complete_line (*current_completion
.tracker
, text
,
2316 rl_line_buffer
, rl_point
);
2319 completion_tracker
&tracker
= *current_completion
.tracker
;
2321 completion_result result
2322 = tracker
.build_completion_result (text
, start
, end
);
2324 rl_completion_suppress_append
= result
.completion_suppress_append
;
2325 return result
.release_match_list ();
2328 /* Function installed as "rl_attempted_completion_function" readline
2329 hook. Wrapper around gdb_rl_attempted_completion_function_throw
2330 that catches C++ exceptions, which can't cross readline. */
2333 gdb_rl_attempted_completion_function (const char *text
, int start
, int end
)
2335 /* Restore globals that might have been tweaked in
2336 gdb_completion_word_break_characters. */
2337 rl_basic_quote_characters
= gdb_org_rl_basic_quote_characters
;
2339 /* If we end up returning NULL, either on error, or simple because
2340 there are no matches, inhibit readline's default filename
2342 rl_attempted_completion_over
= 1;
2344 /* If the handle_brkchars phase was aborted, don't try
2346 if (current_completion
.aborted
)
2351 return gdb_rl_attempted_completion_function_throw (text
, start
, end
);
2353 catch (const gdb_exception
&ex
)
2360 /* Skip over the possibly quoted word STR (as defined by the quote
2361 characters QUOTECHARS and the word break characters BREAKCHARS).
2362 Returns pointer to the location after the "word". If either
2363 QUOTECHARS or BREAKCHARS is NULL, use the same values used by the
2367 skip_quoted_chars (const char *str
, const char *quotechars
,
2368 const char *breakchars
)
2370 char quote_char
= '\0';
2373 if (quotechars
== NULL
)
2374 quotechars
= gdb_completer_quote_characters
;
2376 if (breakchars
== NULL
)
2377 breakchars
= current_language
->word_break_characters ();
2379 for (scan
= str
; *scan
!= '\0'; scan
++)
2381 if (quote_char
!= '\0')
2383 /* Ignore everything until the matching close quote char. */
2384 if (*scan
== quote_char
)
2386 /* Found matching close quote. */
2391 else if (strchr (quotechars
, *scan
))
2393 /* Found start of a quoted string. */
2396 else if (strchr (breakchars
, *scan
))
2405 /* Skip over the possibly quoted word STR (as defined by the quote
2406 characters and word break characters used by the completer).
2407 Returns pointer to the location after the "word". */
2410 skip_quoted (const char *str
)
2412 return skip_quoted_chars (str
, NULL
, NULL
);
2415 /* Return a message indicating that the maximum number of completions
2416 has been reached and that there may be more. */
2419 get_max_completions_reached_message (void)
2421 return _("*** List may be truncated, max-completions reached. ***");
2424 /* GDB replacement for rl_display_match_list.
2425 Readline doesn't provide a clean interface for TUI(curses).
2426 A hack previously used was to send readline's rl_outstream through a pipe
2427 and read it from the event loop. Bleah. IWBN if readline abstracted
2428 away all the necessary bits, and this is what this code does. It
2429 replicates the parts of readline we need and then adds an abstraction
2430 layer, currently implemented as struct match_list_displayer, so that both
2431 CLI and TUI can use it. We copy all this readline code to minimize
2432 GDB-specific mods to readline. Once this code performs as desired then
2433 we can submit it to the readline maintainers.
2435 N.B. A lot of the code is the way it is in order to minimize differences
2436 from readline's copy. */
2438 /* Not supported here. */
2439 #undef VISIBLE_STATS
2441 #if defined (HANDLE_MULTIBYTE)
2442 #define MB_INVALIDCH(x) ((x) == (size_t)-1 || (x) == (size_t)-2)
2443 #define MB_NULLWCH(x) ((x) == 0)
2446 #define ELLIPSIS_LEN 3
2448 /* gdb version of readline/complete.c:get_y_or_n.
2449 'y' -> returns 1, and 'n' -> returns 0.
2450 Also supported: space == 'y', RUBOUT == 'n', ctrl-g == start over.
2451 If FOR_PAGER is non-zero, then also supported are:
2452 NEWLINE or RETURN -> returns 2, and 'q' -> returns 0. */
2455 gdb_get_y_or_n (int for_pager
, const struct match_list_displayer
*displayer
)
2461 RL_SETSTATE (RL_STATE_MOREINPUT
);
2462 c
= displayer
->read_key (displayer
);
2463 RL_UNSETSTATE (RL_STATE_MOREINPUT
);
2465 if (c
== 'y' || c
== 'Y' || c
== ' ')
2467 if (c
== 'n' || c
== 'N' || c
== RUBOUT
)
2469 if (c
== ABORT_CHAR
|| c
< 0)
2471 /* Readline doesn't erase_entire_line here, but without it the
2472 --More-- prompt isn't erased and neither is the text entered
2473 thus far redisplayed. */
2474 displayer
->erase_entire_line (displayer
);
2475 /* Note: The arguments to rl_abort are ignored. */
2478 if (for_pager
&& (c
== NEWLINE
|| c
== RETURN
))
2480 if (for_pager
&& (c
== 'q' || c
== 'Q'))
2482 displayer
->beep (displayer
);
2486 /* Pager function for tab-completion.
2487 This is based on readline/complete.c:_rl_internal_pager.
2488 LINES is the number of lines of output displayed thus far.
2490 -1 -> user pressed 'n' or equivalent,
2491 0 -> user pressed 'y' or equivalent,
2492 N -> user pressed NEWLINE or equivalent and N is LINES - 1. */
2495 gdb_display_match_list_pager (int lines
,
2496 const struct match_list_displayer
*displayer
)
2500 displayer
->puts (displayer
, "--More--");
2501 displayer
->flush (displayer
);
2502 i
= gdb_get_y_or_n (1, displayer
);
2503 displayer
->erase_entire_line (displayer
);
2512 /* Return non-zero if FILENAME is a directory.
2513 Based on readline/complete.c:path_isdir. */
2516 gdb_path_isdir (const char *filename
)
2520 return (stat (filename
, &finfo
) == 0 && S_ISDIR (finfo
.st_mode
));
2523 /* Return the portion of PATHNAME that should be output when listing
2524 possible completions. If we are hacking filename completion, we
2525 are only interested in the basename, the portion following the
2526 final slash. Otherwise, we return what we were passed. Since
2527 printing empty strings is not very informative, if we're doing
2528 filename completion, and the basename is the empty string, we look
2529 for the previous slash and return the portion following that. If
2530 there's no previous slash, we just return what we were passed.
2532 Based on readline/complete.c:printable_part. */
2535 gdb_printable_part (char *pathname
)
2539 if (rl_filename_completion_desired
== 0) /* don't need to do anything */
2542 temp
= strrchr (pathname
, '/');
2543 #if defined (__MSDOS__)
2544 if (temp
== 0 && ISALPHA ((unsigned char)pathname
[0]) && pathname
[1] == ':')
2545 temp
= pathname
+ 1;
2548 if (temp
== 0 || *temp
== '\0')
2550 /* If the basename is NULL, we might have a pathname like '/usr/src/'.
2551 Look for a previous slash and, if one is found, return the portion
2552 following that slash. If there's no previous slash, just return the
2553 pathname we were passed. */
2554 else if (temp
[1] == '\0')
2556 for (x
= temp
- 1; x
> pathname
; x
--)
2559 return ((*x
== '/') ? x
+ 1 : pathname
);
2565 /* Compute width of STRING when displayed on screen by print_filename.
2566 Based on readline/complete.c:fnwidth. */
2569 gdb_fnwidth (const char *string
)
2572 #if defined (HANDLE_MULTIBYTE)
2578 left
= strlen (string
) + 1;
2579 memset (&ps
, 0, sizeof (mbstate_t));
2585 if (CTRL_CHAR (string
[pos
]) || string
[pos
] == RUBOUT
)
2592 #if defined (HANDLE_MULTIBYTE)
2593 clen
= mbrtowc (&wc
, string
+ pos
, left
- pos
, &ps
);
2594 if (MB_INVALIDCH (clen
))
2598 memset (&ps
, 0, sizeof (mbstate_t));
2600 else if (MB_NULLWCH (clen
))
2606 width
+= (w
>= 0) ? w
: 1;
2618 /* Print TO_PRINT, one matching completion.
2619 PREFIX_BYTES is number of common prefix bytes.
2620 Based on readline/complete.c:fnprint. */
2623 gdb_fnprint (const char *to_print
, int prefix_bytes
,
2624 const struct match_list_displayer
*displayer
)
2628 #if defined (HANDLE_MULTIBYTE)
2635 end
= to_print
+ strlen (to_print
) + 1;
2636 memset (&ps
, 0, sizeof (mbstate_t));
2641 /* Don't print only the ellipsis if the common prefix is one of the
2642 possible completions */
2643 if (to_print
[prefix_bytes
] == '\0')
2650 ellipsis
= (to_print
[prefix_bytes
] == '.') ? '_' : '.';
2651 for (w
= 0; w
< ELLIPSIS_LEN
; w
++)
2652 displayer
->putch (displayer
, ellipsis
);
2653 printed_len
= ELLIPSIS_LEN
;
2656 s
= to_print
+ prefix_bytes
;
2661 displayer
->putch (displayer
, '^');
2662 displayer
->putch (displayer
, UNCTRL (*s
));
2665 #if defined (HANDLE_MULTIBYTE)
2666 memset (&ps
, 0, sizeof (mbstate_t));
2669 else if (*s
== RUBOUT
)
2671 displayer
->putch (displayer
, '^');
2672 displayer
->putch (displayer
, '?');
2675 #if defined (HANDLE_MULTIBYTE)
2676 memset (&ps
, 0, sizeof (mbstate_t));
2681 #if defined (HANDLE_MULTIBYTE)
2682 tlen
= mbrtowc (&wc
, s
, end
- s
, &ps
);
2683 if (MB_INVALIDCH (tlen
))
2687 memset (&ps
, 0, sizeof (mbstate_t));
2689 else if (MB_NULLWCH (tlen
))
2694 width
= (w
>= 0) ? w
: 1;
2696 for (w
= 0; w
< tlen
; ++w
)
2697 displayer
->putch (displayer
, s
[w
]);
2699 printed_len
+= width
;
2701 displayer
->putch (displayer
, *s
);
2711 /* Output TO_PRINT to rl_outstream. If VISIBLE_STATS is defined and we
2712 are using it, check for and output a single character for `special'
2713 filenames. Return the number of characters we output.
2714 Based on readline/complete.c:print_filename. */
2717 gdb_print_filename (char *to_print
, char *full_pathname
, int prefix_bytes
,
2718 const struct match_list_displayer
*displayer
)
2720 int printed_len
, extension_char
, slen
, tlen
;
2721 char *s
, c
, *new_full_pathname
;
2723 extern int _rl_complete_mark_directories
;
2726 printed_len
= gdb_fnprint (to_print
, prefix_bytes
, displayer
);
2728 #if defined (VISIBLE_STATS)
2729 if (rl_filename_completion_desired
&& (rl_visible_stats
|| _rl_complete_mark_directories
))
2731 if (rl_filename_completion_desired
&& _rl_complete_mark_directories
)
2734 /* If to_print != full_pathname, to_print is the basename of the
2735 path passed. In this case, we try to expand the directory
2736 name before checking for the stat character. */
2737 if (to_print
!= full_pathname
)
2739 /* Terminate the directory name. */
2741 to_print
[-1] = '\0';
2743 /* If setting the last slash in full_pathname to a NUL results in
2744 full_pathname being the empty string, we are trying to complete
2745 files in the root directory. If we pass a null string to the
2746 bash directory completion hook, for example, it will expand it
2747 to the current directory. We just want the `/'. */
2748 if (full_pathname
== 0 || *full_pathname
== 0)
2750 else if (full_pathname
[0] != '/')
2752 else if (full_pathname
[1] == 0)
2753 dn
= "//"; /* restore trailing slash to `//' */
2754 else if (full_pathname
[1] == '/' && full_pathname
[2] == 0)
2755 dn
= "/"; /* don't turn /// into // */
2758 s
= tilde_expand (dn
);
2759 if (rl_directory_completion_hook
)
2760 (*rl_directory_completion_hook
) (&s
);
2763 tlen
= strlen (to_print
);
2764 new_full_pathname
= (char *)xmalloc (slen
+ tlen
+ 2);
2765 strcpy (new_full_pathname
, s
);
2766 if (s
[slen
- 1] == '/')
2769 new_full_pathname
[slen
] = '/';
2770 new_full_pathname
[slen
] = '/';
2771 strcpy (new_full_pathname
+ slen
+ 1, to_print
);
2773 #if defined (VISIBLE_STATS)
2774 if (rl_visible_stats
)
2775 extension_char
= stat_char (new_full_pathname
);
2778 if (gdb_path_isdir (new_full_pathname
))
2779 extension_char
= '/';
2781 xfree (new_full_pathname
);
2786 s
= tilde_expand (full_pathname
);
2787 #if defined (VISIBLE_STATS)
2788 if (rl_visible_stats
)
2789 extension_char
= stat_char (s
);
2792 if (gdb_path_isdir (s
))
2793 extension_char
= '/';
2799 displayer
->putch (displayer
, extension_char
);
2807 /* GDB version of readline/complete.c:complete_get_screenwidth. */
2810 gdb_complete_get_screenwidth (const struct match_list_displayer
*displayer
)
2812 /* Readline has other stuff here which it's not clear we need. */
2813 return displayer
->width
;
2816 extern int _rl_completion_prefix_display_length
;
2817 extern int _rl_print_completions_horizontally
;
2819 EXTERN_C
int _rl_qsort_string_compare (const void *, const void *);
2820 typedef int QSFUNC (const void *, const void *);
2822 /* GDB version of readline/complete.c:rl_display_match_list.
2823 See gdb_display_match_list for a description of MATCHES, LEN, MAX.
2824 Returns non-zero if all matches are displayed. */
2827 gdb_display_match_list_1 (char **matches
, int len
, int max
,
2828 const struct match_list_displayer
*displayer
)
2830 int count
, limit
, printed_len
, lines
, cols
;
2831 int i
, j
, k
, l
, common_length
, sind
;
2833 int page_completions
= displayer
->height
!= INT_MAX
&& pagination_enabled
;
2835 /* Find the length of the prefix common to all items: length as displayed
2836 characters (common_length) and as a byte index into the matches (sind) */
2837 common_length
= sind
= 0;
2838 if (_rl_completion_prefix_display_length
> 0)
2840 t
= gdb_printable_part (matches
[0]);
2841 temp
= strrchr (t
, '/');
2842 common_length
= temp
? gdb_fnwidth (temp
) : gdb_fnwidth (t
);
2843 sind
= temp
? strlen (temp
) : strlen (t
);
2845 if (common_length
> _rl_completion_prefix_display_length
&& common_length
> ELLIPSIS_LEN
)
2846 max
-= common_length
- ELLIPSIS_LEN
;
2848 common_length
= sind
= 0;
2851 /* How many items of MAX length can we fit in the screen window? */
2852 cols
= gdb_complete_get_screenwidth (displayer
);
2855 if (limit
!= 1 && (limit
* max
== cols
))
2858 /* If cols == 0, limit will end up -1 */
2859 if (cols
< displayer
->width
&& limit
< 0)
2862 /* Avoid a possible floating exception. If max > cols,
2863 limit will be 0 and a divide-by-zero fault will result. */
2867 /* How many iterations of the printing loop? */
2868 count
= (len
+ (limit
- 1)) / limit
;
2870 /* Watch out for special case. If LEN is less than LIMIT, then
2871 just do the inner printing loop.
2872 0 < len <= limit implies count = 1. */
2874 /* Sort the items if they are not already sorted. */
2875 if (rl_ignore_completion_duplicates
== 0 && rl_sort_completion_matches
)
2876 qsort (matches
+ 1, len
, sizeof (char *), (QSFUNC
*)_rl_qsort_string_compare
);
2878 displayer
->crlf (displayer
);
2881 if (_rl_print_completions_horizontally
== 0)
2883 /* Print the sorted items, up-and-down alphabetically, like ls. */
2884 for (i
= 1; i
<= count
; i
++)
2886 for (j
= 0, l
= i
; j
< limit
; j
++)
2888 if (l
> len
|| matches
[l
] == 0)
2892 temp
= gdb_printable_part (matches
[l
]);
2893 printed_len
= gdb_print_filename (temp
, matches
[l
], sind
,
2897 for (k
= 0; k
< max
- printed_len
; k
++)
2898 displayer
->putch (displayer
, ' ');
2902 displayer
->crlf (displayer
);
2904 if (page_completions
&& lines
>= (displayer
->height
- 1) && i
< count
)
2906 lines
= gdb_display_match_list_pager (lines
, displayer
);
2914 /* Print the sorted items, across alphabetically, like ls -x. */
2915 for (i
= 1; matches
[i
]; i
++)
2917 temp
= gdb_printable_part (matches
[i
]);
2918 printed_len
= gdb_print_filename (temp
, matches
[i
], sind
, displayer
);
2919 /* Have we reached the end of this line? */
2922 if (i
&& (limit
> 1) && (i
% limit
) == 0)
2924 displayer
->crlf (displayer
);
2926 if (page_completions
&& lines
>= displayer
->height
- 1)
2928 lines
= gdb_display_match_list_pager (lines
, displayer
);
2934 for (k
= 0; k
< max
- printed_len
; k
++)
2935 displayer
->putch (displayer
, ' ');
2938 displayer
->crlf (displayer
);
2944 /* Utility for displaying completion list matches, used by both CLI and TUI.
2946 MATCHES is the list of strings, in argv format, LEN is the number of
2947 strings in MATCHES, and MAX is the length of the longest string in
2951 gdb_display_match_list (char **matches
, int len
, int max
,
2952 const struct match_list_displayer
*displayer
)
2954 /* Readline will never call this if complete_line returned NULL. */
2955 gdb_assert (max_completions
!= 0);
2957 /* complete_line will never return more than this. */
2958 if (max_completions
> 0)
2959 gdb_assert (len
<= max_completions
);
2961 if (rl_completion_query_items
> 0 && len
>= rl_completion_query_items
)
2965 /* We can't use *query here because they wait for <RET> which is
2966 wrong here. This follows the readline version as closely as possible
2967 for compatibility's sake. See readline/complete.c. */
2969 displayer
->crlf (displayer
);
2971 xsnprintf (msg
, sizeof (msg
),
2972 "Display all %d possibilities? (y or n)", len
);
2973 displayer
->puts (displayer
, msg
);
2974 displayer
->flush (displayer
);
2976 if (gdb_get_y_or_n (0, displayer
) == 0)
2978 displayer
->crlf (displayer
);
2983 if (gdb_display_match_list_1 (matches
, len
, max
, displayer
))
2985 /* Note: MAX_COMPLETIONS may be -1 or zero, but LEN is always > 0. */
2986 if (len
== max_completions
)
2988 /* The maximum number of completions has been reached. Warn the user
2989 that there may be more. */
2990 const char *message
= get_max_completions_reached_message ();
2992 displayer
->puts (displayer
, message
);
2993 displayer
->crlf (displayer
);
2998 void _initialize_completer ();
3000 _initialize_completer ()
3002 add_setshow_zuinteger_unlimited_cmd ("max-completions", no_class
,
3003 &max_completions
, _("\
3004 Set maximum number of completion candidates."), _("\
3005 Show maximum number of completion candidates."), _("\
3006 Use this to limit the number of candidates considered\n\
3007 during completion. Specifying \"unlimited\" or -1\n\
3008 disables limiting. Note that setting either no limit or\n\
3009 a very large limit can make completion slow."),
3010 NULL
, NULL
, &setlist
, &showlist
);