GDB (xrefs)

/tmp/gdb-8.1/gdb/completer.c
Go to the documentation of this file.
1 /* Line completion stuff for GDB, the GNU debugger.
2 Copyright (C) 2000-2018 Free Software Foundation, Inc.
3
4 This file is part of GDB.
5
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.
10
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.
15
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/>. */
18
19 #include "defs.h"
20 #include "symtab.h"
21 #include "gdbtypes.h"
22 #include "expression.h"
23 #include "filenames.h" /* For DOSish file names. */
24 #include "language.h"
25 #include "gdb_signals.h"
26 #include "target.h"
27 #include "reggroups.h"
28 #include "user-regs.h"
29 #include "arch-utils.h"
30 #include "location.h"
31 #include <algorithm>
32 #include "linespec.h"
33 #include "cli/cli-decode.h"
34
35 /* FIXME: This is needed because of lookup_cmd_1 (). We should be
36 calling a hook instead so we eliminate the CLI dependency. */
37 #include "gdbcmd.h"
38
39 /* Needed for rl_completer_word_break_characters() and for
40 rl_filename_completion_function. */
41 #include "readline/readline.h"
42
43 /* readline defines this. */
44 #undef savestring
45
46 #include "completer.h"
47
48 /* Misc state that needs to be tracked across several different
49 readline completer entry point calls, all related to a single
50 completion invocation. */
51
52 struct gdb_completer_state
53 {
54 /* The current completion's completion tracker. This is a global
55 because a tracker can be shared between the handle_brkchars and
56 handle_completion phases, which involves different readline
57 callbacks. */
58 completion_tracker *tracker = NULL;
59
60 /* Whether the current completion was aborted. */
61 bool aborted = false;
62 };
63
64 /* The current completion state. */
65 static gdb_completer_state current_completion;
66
67 /* An enumeration of the various things a user might attempt to
68 complete for a location. If you change this, remember to update
69 the explicit_options array below too. */
70
71 enum explicit_location_match_type
72 {
73 /* The filename of a source file. */
74 MATCH_SOURCE,
75
76 /* The name of a function or method. */
77 MATCH_FUNCTION,
78
79 /* The fully-qualified name of a function or method. */
80 MATCH_QUALIFIED,
81
82 /* A line number. */
83 MATCH_LINE,
84
85 /* The name of a label. */
86 MATCH_LABEL
87 };
88
89 /* Prototypes for local functions. */
90
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++
101 symbols?). */
102
103 /* Variables which are necessary for fancy command line editing. */
104
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!@#$%^&*()+=|~`}{[]\"';:?/>.<,";
112
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
121 " \t\n*|\"';?><@";
122 #else
123 " \t\n*|\"';:?><";
124 #endif
125
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[] = "'";
130
131 /* Accessor for some completer data that may interest other files. */
132
133 const char *
134 get_gdb_completer_quote_characters (void)
135 {
136 return gdb_completer_quote_characters;
137 }
138
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. */
141
142 void
143 noop_completer (struct cmd_list_element *ignore,
144 completion_tracker &tracker,
145 const char *text, const char *prefix)
146 {
147 }
148
149 /* Complete on filenames. */
150
151 void
152 filename_completer (struct cmd_list_element *ignore,
153 completion_tracker &tracker,
154 const char *text, const char *word)
155 {
156 int subsequent_name;
157
158 subsequent_name = 0;
159 while (1)
160 {
161 gdb::unique_xmalloc_ptr<char> p_rl
162 (rl_filename_completion_function (text, subsequent_name));
163 if (p_rl == NULL)
164 break;
165 /* We need to set subsequent_name to a non-zero value before the
166 continue line below, because otherwise, if the first file
167 seen by GDB is a backup file whose name ends in a `~', we
168 will loop indefinitely. */
169 subsequent_name = 1;
170 /* Like emacs, don't complete on old versions. Especially
171 useful in the "source" command. */
172 const char *p = p_rl.get ();
173 if (p[strlen (p) - 1] == '~')
174 continue;
175
176 tracker.add_completion
177 (make_completion_match_str (std::move (p_rl), text, word));
178 }
179 #if 0
180 /* There is no way to do this just long enough to affect quote
181 inserting without also affecting the next completion. This
182 should be fixed in readline. FIXME. */
183 /* Ensure that readline does the right thing
184 with respect to inserting quotes. */
185 rl_completer_word_break_characters = "";
186 #endif
187 }
188
189 /* The corresponding completer_handle_brkchars
190 implementation. */
191
192 static void
193 filename_completer_handle_brkchars (struct cmd_list_element *ignore,
194 completion_tracker &tracker,
195 const char *text, const char *word)
196 {
197 set_rl_completer_word_break_characters
198 (gdb_completer_file_name_break_characters);
199 }
200
201 /* Possible values for the found_quote flags word used by the completion
202 functions. It says what kind of (shell-like) quoting we found anywhere
203 in the line. */
204 #define RL_QF_SINGLE_QUOTE 0x01
205 #define RL_QF_DOUBLE_QUOTE 0x02
206 #define RL_QF_BACKSLASH 0x04
207 #define RL_QF_OTHER_QUOTE 0x08
208
209 /* Find the bounds of the current word for completion purposes, and
210 return a pointer to the end of the word. This mimics (and is a
211 modified version of) readline's _rl_find_completion_word internal
212 function.
213
214 This function skips quoted substrings (characters between matched
215 pairs of characters in rl_completer_quote_characters). We try to
216 find an unclosed quoted substring on which to do matching. If one
217 is not found, we use the word break characters to find the
218 boundaries of the current word. QC, if non-null, is set to the
219 opening quote character if we found an unclosed quoted substring,
220 '\0' otherwise. DP, if non-null, is set to the value of the
221 delimiter character that caused a word break. */
222
223 struct gdb_rl_completion_word_info
224 {
225 const char *word_break_characters;
226 const char *quote_characters;
227 const char *basic_quote_characters;
228 };
229
230 static const char *
231 gdb_rl_find_completion_word (struct gdb_rl_completion_word_info *info,
232 int *qc, int *dp,
233 const char *line_buffer)
234 {
235 int scan, end, found_quote, delimiter, pass_next, isbrk;
236 char quote_char;
237 const char *brkchars;
238 int point = strlen (line_buffer);
239
240 /* The algorithm below does '--point'. Avoid buffer underflow with
241 the empty string. */
242 if (point == 0)
243 {
244 if (qc != NULL)
245 *qc = '\0';
246 if (dp != NULL)
247 *dp = '\0';
248 return line_buffer;
249 }
250
251 end = point;
252 found_quote = delimiter = 0;
253 quote_char = '\0';
254
255 brkchars = info->word_break_characters;
256
257 if (info->quote_characters != NULL)
258 {
259 /* We have a list of characters which can be used in pairs to
260 quote substrings for the completer. Try to find the start of
261 an unclosed quoted substring. */
262 /* FOUND_QUOTE is set so we know what kind of quotes we
263 found. */
264 for (scan = pass_next = 0;
265 scan < end;
266 scan++)
267 {
268 if (pass_next)
269 {
270 pass_next = 0;
271 continue;
272 }
273
274 /* Shell-like semantics for single quotes -- don't allow
275 backslash to quote anything in single quotes, especially
276 not the closing quote. If you don't like this, take out
277 the check on the value of quote_char. */
278 if (quote_char != '\'' && line_buffer[scan] == '\\')
279 {
280 pass_next = 1;
281 found_quote |= RL_QF_BACKSLASH;
282 continue;
283 }
284
285 if (quote_char != '\0')
286 {
287 /* Ignore everything until the matching close quote
288 char. */
289 if (line_buffer[scan] == quote_char)
290 {
291 /* Found matching close. Abandon this
292 substring. */
293 quote_char = '\0';
294 point = end;
295 }
296 }
297 else if (strchr (info->quote_characters, line_buffer[scan]))
298 {
299 /* Found start of a quoted substring. */
300 quote_char = line_buffer[scan];
301 point = scan + 1;
302 /* Shell-like quoting conventions. */
303 if (quote_char == '\'')
304 found_quote |= RL_QF_SINGLE_QUOTE;
305 else if (quote_char == '"')
306 found_quote |= RL_QF_DOUBLE_QUOTE;
307 else
308 found_quote |= RL_QF_OTHER_QUOTE;
309 }
310 }
311 }
312
313 if (point == end && quote_char == '\0')
314 {
315 /* We didn't find an unclosed quoted substring upon which to do
316 completion, so use the word break characters to find the
317 substring on which to complete. */
318 while (--point)
319 {
320 scan = line_buffer[point];
321
322 if (strchr (brkchars, scan) != 0)
323 break;
324 }
325 }
326
327 /* If we are at an unquoted word break, then advance past it. */
328 scan = line_buffer[point];
329
330 if (scan)
331 {
332 isbrk = strchr (brkchars, scan) != 0;
333
334 if (isbrk)
335 {
336 /* If the character that caused the word break was a quoting
337 character, then remember it as the delimiter. */
338 if (info->basic_quote_characters
339 && strchr (info->basic_quote_characters, scan)
340 && (end - point) > 1)
341 delimiter = scan;
342
343 point++;
344 }
345 }
346
347 if (qc != NULL)
348 *qc = quote_char;
349 if (dp != NULL)
350 *dp = delimiter;
351
352 return line_buffer + point;
353 }
354
355 /* See completer.h. */
356
357 const char *
358 advance_to_expression_complete_word_point (completion_tracker &tracker,
359 const char *text)
360 {
361 gdb_rl_completion_word_info info;
362
363 info.word_break_characters
364 = current_language->la_word_break_characters ();
365 info.quote_characters = gdb_completer_quote_characters;
366 info.basic_quote_characters = rl_basic_quote_characters;
367
368 const char *start
369 = gdb_rl_find_completion_word (&info, NULL, NULL, text);
370
371 tracker.advance_custom_word_point_by (start - text);
372
373 return start;
374 }
375
376 /* See completer.h. */
377
378 bool
379 completion_tracker::completes_to_completion_word (const char *word)
380 {
381 if (m_lowest_common_denominator_unique)
382 {
383 const char *lcd = m_lowest_common_denominator;
384
385 if (strncmp_iw (word, lcd, strlen (lcd)) == 0)
386 {
387 /* Maybe skip the function and complete on keywords. */
388 size_t wordlen = strlen (word);
389 if (word[wordlen - 1] == ' ')
390 return true;
391 }
392 }
393
394 return false;
395 }
396
397 /* Complete on linespecs, which might be of two possible forms:
398
399 file:line
400 or
401 symbol+offset
402
403 This is intended to be used in commands that set breakpoints
404 etc. */
405
406 static void
407 complete_files_symbols (completion_tracker &tracker,
408 const char *text, const char *word)
409 {
410 completion_list fn_list;
411 const char *p;
412 int quote_found = 0;
413 int quoted = *text == '\'' || *text == '"';
414 int quote_char = '\0';
415 const char *colon = NULL;
416 char *file_to_match = NULL;
417 const char *symbol_start = text;
418 const char *orig_text = text;
419
420 /* Do we have an unquoted colon, as in "break foo.c:bar"? */
421 for (p = text; *p != '\0'; ++p)
422 {
423 if (*p == '\\' && p[1] == '\'')
424 p++;
425 else if (*p == '\'' || *p == '"')
426 {
427 quote_found = *p;
428 quote_char = *p++;
429 while (*p != '\0' && *p != quote_found)
430 {
431 if (*p == '\\' && p[1] == quote_found)
432 p++;
433 p++;
434 }
435
436 if (*p == quote_found)
437 quote_found = 0;
438 else
439 break; /* Hit the end of text. */
440 }
441 #if HAVE_DOS_BASED_FILE_SYSTEM
442 /* If we have a DOS-style absolute file name at the beginning of
443 TEXT, and the colon after the drive letter is the only colon
444 we found, pretend the colon is not there. */
445 else if (p < text + 3 && *p == ':' && p == text + 1 + quoted)
446 ;
447 #endif
448 else if (*p == ':' && !colon)
449 {
450 colon = p;
451 symbol_start = p + 1;
452 }
453 else if (strchr (current_language->la_word_break_characters(), *p))
454 symbol_start = p + 1;
455 }
456
457 if (quoted)
458 text++;
459
460 /* Where is the file name? */
461 if (colon)
462 {
463 char *s;
464
465 file_to_match = (char *) xmalloc (colon - text + 1);
466 strncpy (file_to_match, text, colon - text);
467 file_to_match[colon - text] = '\0';
468 /* Remove trailing colons and quotes from the file name. */
469 for (s = file_to_match + (colon - text);
470 s > file_to_match;
471 s--)
472 if (*s == ':' || *s == quote_char)
473 *s = '\0';
474 }
475 /* If the text includes a colon, they want completion only on a
476 symbol name after the colon. Otherwise, we need to complete on
477 symbols as well as on files. */
478 if (colon)
479 {
480 collect_file_symbol_completion_matches (tracker,
481 complete_symbol_mode::EXPRESSION,
482 symbol_name_match_type::EXPRESSION,
483 symbol_start, word,
484 file_to_match);
485 xfree (file_to_match);
486 }
487 else
488 {
489 size_t text_len = strlen (text);
490
491 collect_symbol_completion_matches (tracker,
492 complete_symbol_mode::EXPRESSION,
493 symbol_name_match_type::EXPRESSION,
494 symbol_start, word);
495 /* If text includes characters which cannot appear in a file
496 name, they cannot be asking for completion on files. */
497 if (strcspn (text,
498 gdb_completer_file_name_break_characters) == text_len)
499 fn_list = make_source_files_completion_list (text, text);
500 }
501
502 if (!fn_list.empty () && !tracker.have_completions ())
503 {
504 /* If we only have file names as possible completion, we should
505 bring them in sync with what rl_complete expects. The
506 problem is that if the user types "break /foo/b TAB", and the
507 possible completions are "/foo/bar" and "/foo/baz"
508 rl_complete expects us to return "bar" and "baz", without the
509 leading directories, as possible completions, because `word'
510 starts at the "b". But we ignore the value of `word' when we
511 call make_source_files_completion_list above (because that
512 would not DTRT when the completion results in both symbols
513 and file names), so make_source_files_completion_list returns
514 the full "/foo/bar" and "/foo/baz" strings. This produces
515 wrong results when, e.g., there's only one possible
516 completion, because rl_complete will prepend "/foo/" to each
517 candidate completion. The loop below removes that leading
518 part. */
519 for (const auto &fn_up: fn_list)
520 {
521 char *fn = fn_up.get ();
522 memmove (fn, fn + (word - text), strlen (fn) + 1 - (word - text));
523 }
524 }
525
526 tracker.add_completions (std::move (fn_list));
527
528 if (!tracker.have_completions ())
529 {
530 /* No completions at all. As the final resort, try completing
531 on the entire text as a symbol. */
532 collect_symbol_completion_matches (tracker,
533 complete_symbol_mode::EXPRESSION,
534 symbol_name_match_type::EXPRESSION,
535 orig_text, word);
536 }
537 }
538
539 /* See completer.h. */
540
541 completion_list
542 complete_source_filenames (const char *text)
543 {
544 size_t text_len = strlen (text);
545
546 /* If text includes characters which cannot appear in a file name,
547 the user cannot be asking for completion on files. */
548 if (strcspn (text,
549 gdb_completer_file_name_break_characters)
550 == text_len)
551 return make_source_files_completion_list (text, text);
552
553 return {};
554 }
555
556 /* Complete address and linespec locations. */
557
558 static void
559 complete_address_and_linespec_locations (completion_tracker &tracker,
560 const char *text,
561 symbol_name_match_type match_type)
562 {
563 if (*text == '*')
564 {
565 tracker.advance_custom_word_point_by (1);
566 text++;
567 const char *word
568 = advance_to_expression_complete_word_point (tracker, text);
569 complete_expression (tracker, text, word);
570 }
571 else
572 {
573 linespec_complete (tracker, text, match_type);
574 }
575 }
576
577 /* The explicit location options. Note that indexes into this array
578 must match the explicit_location_match_type enumerators. */
579
580 static const char *const explicit_options[] =
581 {
582 "-source",
583 "-function",
584 "-qualified",
585 "-line",
586 "-label",
587 NULL
588 };
589
590 /* The probe modifier options. These can appear before a location in
591 breakpoint commands. */
592 static const char *const probe_options[] =
593 {
594 "-probe",
595 "-probe-stap",
596 "-probe-dtrace",
597 NULL
598 };
599
600 /* Returns STRING if not NULL, the empty string otherwise. */
601
602 static const char *
603 string_or_empty (const char *string)
604 {
605 return string != NULL ? string : "";
606 }
607
608 /* A helper function to collect explicit location matches for the given
609 LOCATION, which is attempting to match on WORD. */
610
611 static void
612 collect_explicit_location_matches (completion_tracker &tracker,
613 struct event_location *location,
614 enum explicit_location_match_type what,
615 const char *word,
616 const struct language_defn *language)
617 {
618 const struct explicit_location *explicit_loc
619 = get_explicit_location (location);
620
621 /* True if the option expects an argument. */
622 bool needs_arg = true;
623
624 /* Note, in the various MATCH_* below, we complete on
625 explicit_loc->foo instead of WORD, because only the former will
626 have already skipped past any quote char. */
627 switch (what)
628 {
629 case MATCH_SOURCE:
630 {
631 const char *source = string_or_empty (explicit_loc->source_filename);
632 completion_list matches
633 = make_source_files_completion_list (source, source);
634 tracker.add_completions (std::move (matches));
635 }
636 break;
637
638 case MATCH_FUNCTION:
639 {
640 const char *function = string_or_empty (explicit_loc->function_name);
641 linespec_complete_function (tracker, function,
642 explicit_loc->func_name_match_type,
643 explicit_loc->source_filename);
644 }
645 break;
646
647 case MATCH_QUALIFIED:
648 needs_arg = false;
649 break;
650 case MATCH_LINE:
651 /* Nothing to offer. */
652 break;
653
654 case MATCH_LABEL:
655 {
656 const char *label = string_or_empty (explicit_loc->label_name);
657 linespec_complete_label (tracker, language,
658 explicit_loc->source_filename,
659 explicit_loc->function_name,
660 explicit_loc->func_name_match_type,
661 label);
662 }
663 break;
664
665 default:
666 gdb_assert_not_reached ("unhandled explicit_location_match_type");
667 }
668
669 if (!needs_arg || tracker.completes_to_completion_word (word))
670 {
671 tracker.discard_completions ();
672 tracker.advance_custom_word_point_by (strlen (word));
673 complete_on_enum (tracker, explicit_options, "", "");
674 complete_on_enum (tracker, linespec_keywords, "", "");
675 }
676 else if (!tracker.have_completions ())
677 {
678 /* Maybe we have an unterminated linespec keyword at the tail of
679 the string. Try completing on that. */
680 size_t wordlen = strlen (word);
681 const char *keyword = word + wordlen;
682
683 if (wordlen > 0 && keyword[-1] != ' ')
684 {
685 while (keyword > word && *keyword != ' ')
686 keyword--;
687 /* Don't complete on keywords if we'd be completing on the
688 whole explicit linespec option. E.g., "b -function
689 thr<tab>" should not complete to the "thread"
690 keyword. */
691 if (keyword != word)
692 {
693 keyword = skip_spaces (keyword);
694
695 tracker.advance_custom_word_point_by (keyword - word);
696 complete_on_enum (tracker, linespec_keywords, keyword, keyword);
697 }
698 }
699 else if (wordlen > 0 && keyword[-1] == ' ')
700 {
701 /* Assume that we're maybe past the explicit location
702 argument, and we didn't manage to find any match because
703 the user wants to create a pending breakpoint. Offer the
704 keyword and explicit location options as possible
705 completions. */
706 tracker.advance_custom_word_point_by (keyword - word);
707 complete_on_enum (tracker, linespec_keywords, keyword, keyword);
708 complete_on_enum (tracker, explicit_options, keyword, keyword);
709 }
710 }
711 }
712
713 /* If the next word in *TEXT_P is any of the keywords in KEYWORDS,
714 then advance both TEXT_P and the word point in the tracker past the
715 keyword and return the (0-based) index in the KEYWORDS array that
716 matched. Otherwise, return -1. */
717
718 static int
719 skip_keyword (completion_tracker &tracker,
720 const char * const *keywords, const char **text_p)
721 {
722 const char *text = *text_p;
723 const char *after = skip_to_space (text);
724 size_t len = after - text;
725
726 if (text[len] != ' ')
727 return -1;
728
729 int found = -1;
730 for (int i = 0; keywords[i] != NULL; i++)
731 {
732 if (strncmp (keywords[i], text, len) == 0)
733 {
734 if (found == -1)
735 found = i;
736 else
737 return -1;
738 }
739 }
740
741 if (found != -1)
742 {
743 tracker.advance_custom_word_point_by (len + 1);
744 text += len + 1;
745 *text_p = text;
746 return found;
747 }
748
749 return -1;
750 }
751
752 /* A completer function for explicit locations. This function
753 completes both options ("-source", "-line", etc) and values. If
754 completing a quoted string, then QUOTED_ARG_START and
755 QUOTED_ARG_END point to the quote characters. LANGUAGE is the
756 current language. */
757
758 static void
759 complete_explicit_location (completion_tracker &tracker,
760 struct event_location *location,
761 const char *text,
762 const language_defn *language,
763 const char *quoted_arg_start,
764 const char *quoted_arg_end)
765 {
766 if (*text != '-')
767 return;
768
769 int keyword = skip_keyword (tracker, explicit_options, &text);
770
771 if (keyword == -1)
772 complete_on_enum (tracker, explicit_options, text, text);
773 else
774 {
775 /* Completing on value. */
776 enum explicit_location_match_type what
777 = (explicit_location_match_type) keyword;
778
779 if (quoted_arg_start != NULL && quoted_arg_end != NULL)
780 {
781 if (quoted_arg_end[1] == '\0')
782 {
783 /* If completing a quoted string with the cursor right
784 at the terminating quote char, complete the
785 completion word without interpretation, so that
786 readline advances the cursor one whitespace past the
787 quote, even if there's no match. This makes these
788 cases behave the same:
789
790 before: "b -function function()"
791 after: "b -function function() "
792
793 before: "b -function 'function()'"
794 after: "b -function 'function()' "
795
796 and trusts the user in this case:
797
798 before: "b -function 'not_loaded_function_yet()'"
799 after: "b -function 'not_loaded_function_yet()' "
800 */
801 gdb::unique_xmalloc_ptr<char> text_copy
802 (xstrdup (text));
803 tracker.add_completion (std::move (text_copy));
804 }
805 else if (quoted_arg_end[1] == ' ')
806 {
807 /* We're maybe past the explicit location argument.
808 Skip the argument without interpretion, assuming the
809 user may want to create pending breakpoint. Offer
810 the keyword and explicit location options as possible
811 completions. */
812 tracker.advance_custom_word_point_by (strlen (text));
813 complete_on_enum (tracker, linespec_keywords, "", "");
814 complete_on_enum (tracker, explicit_options, "", "");
815 }
816 return;
817 }
818
819 /* Now gather matches */
820 collect_explicit_location_matches (tracker, location, what, text,
821 language);
822 }
823 }
824
825 /* A completer for locations. */
826
827 void
828 location_completer (struct cmd_list_element *ignore,
829 completion_tracker &tracker,
830 const char *text, const char * /* word */)
831 {
832 int found_probe_option = -1;
833
834 /* If we have a probe modifier, skip it. This can only appear as
835 first argument. Until we have a specific completer for probes,
836 falling back to the linespec completer for the remainder of the
837 line is better than nothing. */
838 if (text[0] == '-' && text[1] == 'p')
839 found_probe_option = skip_keyword (tracker, probe_options, &text);
840
841 const char *option_text = text;
842 int saved_word_point = tracker.custom_word_point ();
843
844 const char *copy = text;
845
846 explicit_completion_info completion_info;
847 event_location_up location
848 = string_to_explicit_location (&copy, current_language,
849 &completion_info);
850 if (completion_info.quoted_arg_start != NULL
851 && completion_info.quoted_arg_end == NULL)
852 {
853 /* Found an unbalanced quote. */
854 tracker.set_quote_char (*completion_info.quoted_arg_start);
855 tracker.advance_custom_word_point_by (1);
856 }
857
858 if (completion_info.saw_explicit_location_option)
859 {
860 if (*copy != '\0')
861 {
862 tracker.advance_custom_word_point_by (copy - text);
863 text = copy;
864
865 /* We found a terminator at the tail end of the string,
866 which means we're past the explicit location options. We
867 may have a keyword to complete on. If we have a whole
868 keyword, then complete whatever comes after as an
869 expression. This is mainly for the "if" keyword. If the
870 "thread" and "task" keywords gain their own completers,
871 they should be used here. */
872 int keyword = skip_keyword (tracker, linespec_keywords, &text);
873
874 if (keyword == -1)
875 {
876 complete_on_enum (tracker, linespec_keywords, text, text);
877 }
878 else
879 {
880 const char *word
881 = advance_to_expression_complete_word_point (tracker, text);
882 complete_expression (tracker, text, word);
883 }
884 }
885 else
886 {
887 tracker.advance_custom_word_point_by (completion_info.last_option
888 - text);
889 text = completion_info.last_option;
890
891 complete_explicit_location (tracker, location.get (), text,
892 current_language,
893 completion_info.quoted_arg_start,
894 completion_info.quoted_arg_end);
895
896 }
897 }
898 /* This is an address or linespec location. */
899 else if (location != NULL)
900 {
901 /* Handle non-explicit location options. */
902
903 int keyword = skip_keyword (tracker, explicit_options, &text);
904 if (keyword == -1)
905 complete_on_enum (tracker, explicit_options, text, text);
906 else
907 {
908 tracker.advance_custom_word_point_by (copy - text);
909 text = copy;
910
911 symbol_name_match_type match_type
912 = get_explicit_location (location.get ())->func_name_match_type;
913 complete_address_and_linespec_locations (tracker, text, match_type);
914 }
915 }
916 else
917 {
918 /* No options. */
919 complete_address_and_linespec_locations (tracker, text,
920 symbol_name_match_type::WILD);
921 }
922
923 /* Add matches for option names, if either:
924
925 - Some completer above found some matches, but the word point did
926 not advance (e.g., "b <tab>" finds all functions, or "b -<tab>"
927 matches all objc selectors), or;
928
929 - Some completer above advanced the word point, but found no
930 matches.
931 */
932 if ((text[0] == '-' || text[0] == '\0')
933 && (!tracker.have_completions ()
934 || tracker.custom_word_point () == saved_word_point))
935 {
936 tracker.set_custom_word_point (saved_word_point);
937 text = option_text;
938
939 if (found_probe_option == -1)
940 complete_on_enum (tracker, probe_options, text, text);
941 complete_on_enum (tracker, explicit_options, text, text);
942 }
943 }
944
945 /* The corresponding completer_handle_brkchars
946 implementation. */
947
948 static void
949 location_completer_handle_brkchars (struct cmd_list_element *ignore,
950 completion_tracker &tracker,
951 const char *text,
952 const char *word_ignored)
953 {
954 tracker.set_use_custom_word_point (true);
955
956 location_completer (ignore, tracker, text, NULL);
957 }
958
959 /* Helper for expression_completer which recursively adds field and
960 method names from TYPE, a struct or union type, to the OUTPUT
961 list. */
962
963 static void
964 add_struct_fields (struct type *type, completion_list &output,
965 char *fieldname, int namelen)
966 {
967 int i;
968 int computed_type_name = 0;
969 const char *type_name = NULL;
970
971 type = check_typedef (type);
972 for (i = 0; i < TYPE_NFIELDS (type); ++i)
973 {
974 if (i < TYPE_N_BASECLASSES (type))
975 add_struct_fields (TYPE_BASECLASS (type, i),
976 output, fieldname, namelen);
977 else if (TYPE_FIELD_NAME (type, i))
978 {
979 if (TYPE_FIELD_NAME (type, i)[0] != '\0')
980 {
981 if (! strncmp (TYPE_FIELD_NAME (type, i),
982 fieldname, namelen))
983 output.emplace_back (xstrdup (TYPE_FIELD_NAME (type, i)));
984 }
985 else if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_UNION)
986 {
987 /* Recurse into anonymous unions. */
988 add_struct_fields (TYPE_FIELD_TYPE (type, i),
989 output, fieldname, namelen);
990 }
991 }
992 }
993
994 for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)
995 {
996 const char *name = TYPE_FN_FIELDLIST_NAME (type, i);
997
998 if (name && ! strncmp (name, fieldname, namelen))
999 {
1000 if (!computed_type_name)
1001 {
1002 type_name = type_name_no_tag (type);
1003 computed_type_name = 1;
1004 }
1005 /* Omit constructors from the completion list. */
1006 if (!type_name || strcmp (type_name, name))
1007 output.emplace_back (xstrdup (name));
1008 }
1009 }
1010 }
1011
1012 /* See completer.h. */
1013
1014 void
1015 complete_expression (completion_tracker &tracker,
1016 const char *text, const char *word)
1017 {
1018 struct type *type = NULL;
1019 char *fieldname;
1020 enum type_code code = TYPE_CODE_UNDEF;
1021
1022 /* Perform a tentative parse of the expression, to see whether a
1023 field completion is required. */
1024 fieldname = NULL;
1025 TRY
1026 {
1027 type = parse_expression_for_completion (text, &fieldname, &code);
1028 }
1029 CATCH (except, RETURN_MASK_ERROR)
1030 {
1031 return;
1032 }
1033 END_CATCH
1034
1035 if (fieldname && type)
1036 {
1037 for (;;)
1038 {
1039 type = check_typedef (type);
1040 if (TYPE_CODE (type) != TYPE_CODE_PTR && !TYPE_IS_REFERENCE (type))
1041 break;
1042 type = TYPE_TARGET_TYPE (type);
1043 }
1044
1045 if (TYPE_CODE (type) == TYPE_CODE_UNION
1046 || TYPE_CODE (type) == TYPE_CODE_STRUCT)
1047 {
1048 int flen = strlen (fieldname);
1049 completion_list result;
1050
1051 add_struct_fields (type, result, fieldname, flen);
1052 xfree (fieldname);
1053 tracker.add_completions (std::move (result));
1054 return;
1055 }
1056 }
1057 else if (fieldname && code != TYPE_CODE_UNDEF)
1058 {
1059 struct cleanup *cleanup = make_cleanup (xfree, fieldname);
1060
1061 collect_symbol_completion_matches_type (tracker, fieldname, fieldname,
1062 code);
1063 do_cleanups (cleanup);
1064 return;
1065 }
1066 xfree (fieldname);
1067
1068 complete_files_symbols (tracker, text, word);
1069 }
1070
1071 /* Complete on expressions. Often this means completing on symbol
1072 names, but some language parsers also have support for completing
1073 field names. */
1074
1075 void
1076 expression_completer (struct cmd_list_element *ignore,
1077 completion_tracker &tracker,
1078 const char *text, const char *word)
1079 {
1080 complete_expression (tracker, text, word);
1081 }
1082
1083 /* See definition in completer.h. */
1084
1085 void
1086 set_rl_completer_word_break_characters (const char *break_chars)
1087 {
1088 rl_completer_word_break_characters = (char *) break_chars;
1089 }
1090
1091 /* See definition in completer.h. */
1092
1093 void
1094 set_gdb_completion_word_break_characters (completer_ftype *fn)
1095 {
1096 const char *break_chars;
1097
1098 /* So far we are only interested in differentiating filename
1099 completers from everything else. */
1100 if (fn == filename_completer)
1101 break_chars = gdb_completer_file_name_break_characters;
1102 else
1103 break_chars = gdb_completer_command_word_break_characters;
1104
1105 set_rl_completer_word_break_characters (break_chars);
1106 }
1107
1108 /* Complete on symbols. */
1109
1110 void
1111 symbol_completer (struct cmd_list_element *ignore,
1112 completion_tracker &tracker,
1113 const char *text, const char *word)
1114 {
1115 collect_symbol_completion_matches (tracker, complete_symbol_mode::EXPRESSION,
1116 symbol_name_match_type::EXPRESSION,
1117 text, word);
1118 }
1119
1120 /* Here are some useful test cases for completion. FIXME: These
1121 should be put in the test suite. They should be tested with both
1122 M-? and TAB.
1123
1124 "show output-" "radix"
1125 "show output" "-radix"
1126 "p" ambiguous (commands starting with p--path, print, printf, etc.)
1127 "p " ambiguous (all symbols)
1128 "info t foo" no completions
1129 "info t " no completions
1130 "info t" ambiguous ("info target", "info terminal", etc.)
1131 "info ajksdlfk" no completions
1132 "info ajksdlfk " no completions
1133 "info" " "
1134 "info " ambiguous (all info commands)
1135 "p \"a" no completions (string constant)
1136 "p 'a" ambiguous (all symbols starting with a)
1137 "p b-a" ambiguous (all symbols starting with a)
1138 "p b-" ambiguous (all symbols)
1139 "file Make" "file" (word break hard to screw up here)
1140 "file ../gdb.stabs/we" "ird" (needs to not break word at slash)
1141 */
1142
1143 enum complete_line_internal_reason
1144 {
1145 /* Preliminary phase, called by gdb_completion_word_break_characters
1146 function, is used to either:
1147
1148 #1 - Determine the set of chars that are word delimiters
1149 depending on the current command in line_buffer.
1150
1151 #2 - Manually advance RL_POINT to the "word break" point instead
1152 of letting readline do it (based on too-simple character
1153 matching).
1154
1155 Simpler completers that just pass a brkchars array to readline
1156 (#1 above) must defer generating the completions to the main
1157 phase (below). No completion list should be generated in this
1158 phase.
1159
1160 OTOH, completers that manually advance the word point(#2 above)
1161 must set "use_custom_word_point" in the tracker and generate
1162 their completion in this phase. Note that this is the convenient
1163 thing to do since they'll be parsing the input line anyway. */
1164 handle_brkchars,
1165
1166 /* Main phase, called by complete_line function, is used to get the
1167 list of possible completions. */
1168 handle_completions,
1169
1170 /* Special case when completing a 'help' command. In this case,
1171 once sub-command completions are exhausted, we simply return
1172 NULL. */
1173 handle_help,
1174 };
1175
1176 /* Helper for complete_line_internal to simplify it. */
1177
1178 static void
1179 complete_line_internal_normal_command (completion_tracker &tracker,
1180 const char *command, const char *word,
1181 const char *cmd_args,
1182 complete_line_internal_reason reason,
1183 struct cmd_list_element *c)
1184 {
1185 const char *p = cmd_args;
1186
1187 if (c->completer == filename_completer)
1188 {
1189 /* Many commands which want to complete on file names accept
1190 several file names, as in "run foo bar >>baz". So we don't
1191 want to complete the entire text after the command, just the
1192 last word. To this end, we need to find the beginning of the
1193 file name by starting at `word' and going backwards. */
1194 for (p = word;
1195 p > command
1196 && strchr (gdb_completer_file_name_break_characters,
1197 p[-1]) == NULL;
1198 p--)
1199 ;
1200 }
1201
1202 if (reason == handle_brkchars)
1203 {
1204 completer_handle_brkchars_ftype *brkchars_fn;
1205
1206 if (c->completer_handle_brkchars != NULL)
1207 brkchars_fn = c->completer_handle_brkchars;
1208 else
1209 {
1210 brkchars_fn
1211 = (completer_handle_brkchars_func_for_completer
1212 (c->completer));
1213 }
1214
1215 brkchars_fn (c, tracker, p, word);
1216 }
1217
1218 if (reason != handle_brkchars && c->completer != NULL)
1219 (*c->completer) (c, tracker, p, word);
1220 }
1221
1222 /* Internal function used to handle completions.
1223
1224
1225 TEXT is the caller's idea of the "word" we are looking at.
1226
1227 LINE_BUFFER is available to be looked at; it contains the entire
1228 text of the line. POINT is the offset in that line of the cursor.
1229 You should pretend that the line ends at POINT.
1230
1231 See complete_line_internal_reason for description of REASON. */
1232
1233 static void
1234 complete_line_internal_1 (completion_tracker &tracker,
1235 const char *text,
1236 const char *line_buffer, int point,
1237 complete_line_internal_reason reason)
1238 {
1239 char *tmp_command;
1240 const char *p;
1241 int ignore_help_classes;
1242 /* Pointer within tmp_command which corresponds to text. */
1243 const char *word;
1244 struct cmd_list_element *c, *result_list;
1245
1246 /* Choose the default set of word break characters to break
1247 completions. If we later find out that we are doing completions
1248 on command strings (as opposed to strings supplied by the
1249 individual command completer functions, which can be any string)
1250 then we will switch to the special word break set for command
1251 strings, which leaves out the '-' character used in some
1252 commands. */
1253 set_rl_completer_word_break_characters
1254 (current_language->la_word_break_characters());
1255
1256 /* Decide whether to complete on a list of gdb commands or on
1257 symbols. */
1258 tmp_command = (char *) alloca (point + 1);
1259 p = tmp_command;
1260
1261 /* The help command should complete help aliases. */
1262 ignore_help_classes = reason != handle_help;
1263
1264 strncpy (tmp_command, line_buffer, point);
1265 tmp_command[point] = '\0';
1266 if (reason == handle_brkchars)
1267 {
1268 gdb_assert (text == NULL);
1269 word = NULL;
1270 }
1271 else
1272 {
1273 /* Since text always contains some number of characters leading up
1274 to point, we can find the equivalent position in tmp_command
1275 by subtracting that many characters from the end of tmp_command. */
1276 word = tmp_command + point - strlen (text);
1277 }
1278
1279 /* Move P up to the start of the command. */
1280 p = skip_spaces (p);
1281
1282 if (*p == '\0')
1283 {
1284 /* An empty line is ambiguous; that is, it could be any
1285 command. */
1286 c = CMD_LIST_AMBIGUOUS;
1287 result_list = 0;
1288 }
1289 else
1290 {
1291 c = lookup_cmd_1 (&p, cmdlist, &result_list, ignore_help_classes);
1292 }
1293
1294 /* Move p up to the next interesting thing. */
1295 while (*p == ' ' || *p == '\t')
1296 {
1297 p++;
1298 }
1299
1300 tracker.advance_custom_word_point_by (p - tmp_command);
1301
1302 if (!c)
1303 {
1304 /* It is an unrecognized command. So there are no
1305 possible completions. */
1306 }
1307 else if (c == CMD_LIST_AMBIGUOUS)
1308 {
1309 const char *q;
1310
1311 /* lookup_cmd_1 advances p up to the first ambiguous thing, but
1312 doesn't advance over that thing itself. Do so now. */
1313 q = p;
1314 while (*q && (isalnum (*q) || *q == '-' || *q == '_'))
1315 ++q;
1316 if (q != tmp_command + point)
1317 {
1318 /* There is something beyond the ambiguous
1319 command, so there are no possible completions. For
1320 example, "info t " or "info t foo" does not complete
1321 to anything, because "info t" can be "info target" or
1322 "info terminal". */
1323 }
1324 else
1325 {
1326 /* We're trying to complete on the command which was ambiguous.
1327 This we can deal with. */
1328 if (result_list)
1329 {
1330 if (reason != handle_brkchars)
1331 complete_on_cmdlist (*result_list->prefixlist, tracker, p,
1332 word, ignore_help_classes);
1333 }
1334 else
1335 {
1336 if (reason != handle_brkchars)
1337 complete_on_cmdlist (cmdlist, tracker, p, word,
1338 ignore_help_classes);
1339 }
1340 /* Ensure that readline does the right thing with respect to
1341 inserting quotes. */
1342 set_rl_completer_word_break_characters
1343 (gdb_completer_command_word_break_characters);
1344 }
1345 }
1346 else
1347 {
1348 /* We've recognized a full command. */
1349
1350 if (p == tmp_command + point)
1351 {
1352 /* There is no non-whitespace in the line beyond the
1353 command. */
1354
1355 if (p[-1] == ' ' || p[-1] == '\t')
1356 {
1357 /* The command is followed by whitespace; we need to
1358 complete on whatever comes after command. */
1359 if (c->prefixlist)
1360 {
1361 /* It is a prefix command; what comes after it is
1362 a subcommand (e.g. "info "). */
1363 if (reason != handle_brkchars)
1364 complete_on_cmdlist (*c->prefixlist, tracker, p, word,
1365 ignore_help_classes);
1366
1367 /* Ensure that readline does the right thing
1368 with respect to inserting quotes. */
1369 set_rl_completer_word_break_characters
1370 (gdb_completer_command_word_break_characters);
1371 }
1372 else if (reason == handle_help)
1373 ;
1374 else if (c->enums)
1375 {
1376 if (reason != handle_brkchars)
1377 complete_on_enum (tracker, c->enums, p, word);
1378 set_rl_completer_word_break_characters
1379 (gdb_completer_command_word_break_characters);
1380 }
1381 else
1382 {
1383 /* It is a normal command; what comes after it is
1384 completed by the command's completer function. */
1385 complete_line_internal_normal_command (tracker,
1386 tmp_command, word, p,
1387 reason, c);
1388 }
1389 }
1390 else
1391 {
1392 /* The command is not followed by whitespace; we need to
1393 complete on the command itself, e.g. "p" which is a
1394 command itself but also can complete to "print", "ptype"
1395 etc. */
1396 const char *q;
1397
1398 /* Find the command we are completing on. */
1399 q = p;
1400 while (q > tmp_command)
1401 {
1402 if (isalnum (q[-1]) || q[-1] == '-' || q[-1] == '_')
1403 --q;
1404 else
1405 break;
1406 }
1407
1408 if (reason != handle_brkchars)
1409 complete_on_cmdlist (result_list, tracker, q, word,
1410 ignore_help_classes);
1411
1412 /* Ensure that readline does the right thing
1413 with respect to inserting quotes. */
1414 set_rl_completer_word_break_characters
1415 (gdb_completer_command_word_break_characters);
1416 }
1417 }
1418 else if (reason == handle_help)
1419 ;
1420 else
1421 {
1422 /* There is non-whitespace beyond the command. */
1423
1424 if (c->prefixlist && !c->allow_unknown)
1425 {
1426 /* It is an unrecognized subcommand of a prefix command,
1427 e.g. "info adsfkdj". */
1428 }
1429 else if (c->enums)
1430 {
1431 if (reason != handle_brkchars)
1432 complete_on_enum (tracker, c->enums, p, word);
1433 }
1434 else
1435 {
1436 /* It is a normal command. */
1437 complete_line_internal_normal_command (tracker,
1438 tmp_command, word, p,
1439 reason, c);
1440 }
1441 }
1442 }
1443 }
1444
1445 /* Wrapper around complete_line_internal_1 to handle
1446 MAX_COMPLETIONS_REACHED_ERROR. */
1447
1448 static void
1449 complete_line_internal (completion_tracker &tracker,
1450 const char *text,
1451 const char *line_buffer, int point,
1452 complete_line_internal_reason reason)
1453 {
1454 TRY
1455 {
1456 complete_line_internal_1 (tracker, text, line_buffer, point, reason);
1457 }
1458 CATCH (except, RETURN_MASK_ERROR)
1459 {
1460 if (except.error != MAX_COMPLETIONS_REACHED_ERROR)
1461 throw_exception (except);
1462 }
1463 END_CATCH
1464 }
1465
1466 /* See completer.h. */
1467
1468 int max_completions = 200;
1469
1470 /* Initial size of the table. It automagically grows from here. */
1471 #define INITIAL_COMPLETION_HTAB_SIZE 200
1472
1473 /* See completer.h. */
1474
1475 completion_tracker::completion_tracker ()
1476 {
1477 m_entries_hash = htab_create_alloc (INITIAL_COMPLETION_HTAB_SIZE,
1478 htab_hash_string, (htab_eq) streq,
1479 NULL, xcalloc, xfree);
1480 }
1481
1482 /* See completer.h. */
1483
1484 void
1485 completion_tracker::discard_completions ()
1486 {
1487 xfree (m_lowest_common_denominator);
1488 m_lowest_common_denominator = NULL;
1489
1490 m_lowest_common_denominator_unique = false;
1491
1492 m_entries_vec.clear ();
1493
1494 htab_delete (m_entries_hash);
1495 m_entries_hash = htab_create_alloc (INITIAL_COMPLETION_HTAB_SIZE,
1496 htab_hash_string, (htab_eq) streq,
1497 NULL, xcalloc, xfree);
1498 }
1499
1500 /* See completer.h. */
1501
1502 completion_tracker::~completion_tracker ()
1503 {
1504 xfree (m_lowest_common_denominator);
1505 htab_delete (m_entries_hash);
1506 }
1507
1508 /* See completer.h. */
1509
1510 bool
1511 completion_tracker::maybe_add_completion
1512 (gdb::unique_xmalloc_ptr<char> name,
1513 completion_match_for_lcd *match_for_lcd,
1514 const char *text, const char *word)
1515 {
1516 void **slot;
1517
1518 if (max_completions == 0)
1519 return false;
1520
1521 if (htab_elements (m_entries_hash) >= max_completions)
1522 return false;
1523
1524 slot = htab_find_slot (m_entries_hash, name.get (), INSERT);
1525 if (*slot == HTAB_EMPTY_ENTRY)
1526 {
1527 const char *match_for_lcd_str = NULL;
1528
1529 if (match_for_lcd != NULL)
1530 match_for_lcd_str = match_for_lcd->finish ();
1531
1532 if (match_for_lcd_str == NULL)
1533 match_for_lcd_str = name.get ();
1534
1535 gdb::unique_xmalloc_ptr<char> lcd
1536 = make_completion_match_str (match_for_lcd_str, text, word);
1537
1538 recompute_lowest_common_denominator (std::move (lcd));
1539
1540 *slot = name.get ();
1541 m_entries_vec.push_back (std::move (name));
1542 }
1543
1544 return true;
1545 }
1546
1547 /* See completer.h. */
1548
1549 void
1550 completion_tracker::add_completion (gdb::unique_xmalloc_ptr<char> name,
1551 completion_match_for_lcd *match_for_lcd,
1552 const char *text, const char *word)
1553 {
1554 if (!maybe_add_completion (std::move (name), match_for_lcd, text, word))
1555 throw_error (MAX_COMPLETIONS_REACHED_ERROR, _("Max completions reached."));
1556 }
1557
1558 /* See completer.h. */
1559
1560 void
1561 completion_tracker::add_completions (completion_list &&list)
1562 {
1563 for (auto &candidate : list)
1564 add_completion (std::move (candidate));
1565 }
1566
1567 /* Helper for the make_completion_match_str overloads. Returns NULL
1568 as an indication that we want MATCH_NAME exactly. It is up to the
1569 caller to xstrdup that string if desired. */
1570
1571 static char *
1572 make_completion_match_str_1 (const char *match_name,
1573 const char *text, const char *word)
1574 {
1575 char *newobj;
1576
1577 if (word == text)
1578 {
1579 /* Return NULL as an indication that we want MATCH_NAME
1580 exactly. */
1581 return NULL;
1582 }
1583 else if (word > text)
1584 {
1585 /* Return some portion of MATCH_NAME. */
1586 newobj = xstrdup (match_name + (word - text));
1587 }
1588 else
1589 {
1590 /* Return some of WORD plus MATCH_NAME. */
1591 size_t len = strlen (match_name);
1592 newobj = (char *) xmalloc (text - word + len + 1);
1593 memcpy (newobj, word, text - word);
1594 memcpy (newobj + (text - word), match_name, len + 1);
1595 }
1596
1597 return newobj;
1598 }
1599
1600 /* See completer.h. */
1601
1602 gdb::unique_xmalloc_ptr<char>
1603 make_completion_match_str (const char *match_name,
1604 const char *text, const char *word)
1605 {
1606 char *newobj = make_completion_match_str_1 (match_name, text, word);
1607 if (newobj == NULL)
1608 newobj = xstrdup (match_name);
1609 return gdb::unique_xmalloc_ptr<char> (newobj);
1610 }
1611
1612 /* See completer.h. */
1613
1614 gdb::unique_xmalloc_ptr<char>
1615 make_completion_match_str (gdb::unique_xmalloc_ptr<char> &&match_name,
1616 const char *text, const char *word)
1617 {
1618 char *newobj = make_completion_match_str_1 (match_name.get (), text, word);
1619 if (newobj == NULL)
1620 return std::move (match_name);
1621 return gdb::unique_xmalloc_ptr<char> (newobj);
1622 }
1623
1624 /* Generate completions all at once. Does nothing if max_completions
1625 is 0. If max_completions is non-negative, this will collect at
1626 most max_completions strings.
1627
1628 TEXT is the caller's idea of the "word" we are looking at.
1629
1630 LINE_BUFFER is available to be looked at; it contains the entire
1631 text of the line.
1632
1633 POINT is the offset in that line of the cursor. You
1634 should pretend that the line ends at POINT. */
1635
1636 void
1637 complete_line (completion_tracker &tracker,
1638 const char *text, const char *line_buffer, int point)
1639 {
1640 if (max_completions == 0)
1641 return;
1642 complete_line_internal (tracker, text, line_buffer, point,
1643 handle_completions);
1644 }
1645
1646 /* Complete on command names. Used by "help". */
1647
1648 void
1649 command_completer (struct cmd_list_element *ignore,
1650 completion_tracker &tracker,
1651 const char *text, const char *word)
1652 {
1653 complete_line_internal (tracker, word, text,
1654 strlen (text), handle_help);
1655 }
1656
1657 /* The corresponding completer_handle_brkchars implementation. */
1658
1659 static void
1660 command_completer_handle_brkchars (struct cmd_list_element *ignore,
1661 completion_tracker &tracker,
1662 const char *text, const char *word)
1663 {
1664 set_rl_completer_word_break_characters
1665 (gdb_completer_command_word_break_characters);
1666 }
1667
1668 /* Complete on signals. */
1669
1670 void
1671 signal_completer (struct cmd_list_element *ignore,
1672 completion_tracker &tracker,
1673 const char *text, const char *word)
1674 {
1675 size_t len = strlen (word);
1676 int signum;
1677 const char *signame;
1678
1679 for (signum = GDB_SIGNAL_FIRST; signum != GDB_SIGNAL_LAST; ++signum)
1680 {
1681 /* Can't handle this, so skip it. */
1682 if (signum == GDB_SIGNAL_0)
1683 continue;
1684
1685 signame = gdb_signal_to_name ((enum gdb_signal) signum);
1686
1687 /* Ignore the unknown signal case. */
1688 if (!signame || strcmp (signame, "?") == 0)
1689 continue;
1690
1691 if (strncasecmp (signame, word, len) == 0)
1692 {
1693 gdb::unique_xmalloc_ptr<char> copy (xstrdup (signame));
1694 tracker.add_completion (std::move (copy));
1695 }
1696 }
1697 }
1698
1699 /* Bit-flags for selecting what the register and/or register-group
1700 completer should complete on. */
1701
1702 enum reg_completer_target
1703 {
1704 complete_register_names = 0x1,
1705 complete_reggroup_names = 0x2
1706 };
1707 DEF_ENUM_FLAGS_TYPE (enum reg_completer_target, reg_completer_targets);
1708
1709 /* Complete register names and/or reggroup names based on the value passed
1710 in TARGETS. At least one bit in TARGETS must be set. */
1711
1712 static void
1713 reg_or_group_completer_1 (completion_tracker &tracker,
1714 const char *text, const char *word,
1715 reg_completer_targets targets)
1716 {
1717 size_t len = strlen (word);
1718 struct gdbarch *gdbarch;
1719 const char *name;
1720
1721 gdb_assert ((targets & (complete_register_names
1722 | complete_reggroup_names)) != 0);
1723 gdbarch = get_current_arch ();
1724
1725 if ((targets & complete_register_names) != 0)
1726 {
1727 int i;
1728
1729 for (i = 0;
1730 (name = user_reg_map_regnum_to_name (gdbarch, i)) != NULL;
1731 i++)
1732 {
1733 if (*name != '\0' && strncmp (word, name, len) == 0)
1734 {
1735 gdb::unique_xmalloc_ptr<char> copy (xstrdup (name));
1736 tracker.add_completion (std::move (copy));
1737 }
1738 }
1739 }
1740
1741 if ((targets & complete_reggroup_names) != 0)
1742 {
1743 struct reggroup *group;
1744
1745 for (group = reggroup_next (gdbarch, NULL);
1746 group != NULL;
1747 group = reggroup_next (gdbarch, group))
1748 {
1749 name = reggroup_name (group);
1750 if (strncmp (word, name, len) == 0)
1751 {
1752 gdb::unique_xmalloc_ptr<char> copy (xstrdup (name));
1753 tracker.add_completion (std::move (copy));
1754 }
1755 }
1756 }
1757 }
1758
1759 /* Perform completion on register and reggroup names. */
1760
1761 void
1762 reg_or_group_completer (struct cmd_list_element *ignore,
1763 completion_tracker &tracker,
1764 const char *text, const char *word)
1765 {
1766 reg_or_group_completer_1 (tracker, text, word,
1767 (complete_register_names
1768 | complete_reggroup_names));
1769 }
1770
1771 /* Perform completion on reggroup names. */
1772
1773 void
1774 reggroup_completer (struct cmd_list_element *ignore,
1775 completion_tracker &tracker,
1776 const char *text, const char *word)
1777 {
1778 reg_or_group_completer_1 (tracker, text, word,
1779 complete_reggroup_names);
1780 }
1781
1782 /* The default completer_handle_brkchars implementation. */
1783
1784 static void
1785 default_completer_handle_brkchars (struct cmd_list_element *ignore,
1786 completion_tracker &tracker,
1787 const char *text, const char *word)
1788 {
1789 set_rl_completer_word_break_characters
1790 (current_language->la_word_break_characters ());
1791 }
1792
1793 /* See definition in completer.h. */
1794
1795 completer_handle_brkchars_ftype *
1796 completer_handle_brkchars_func_for_completer (completer_ftype *fn)
1797 {
1798 if (fn == filename_completer)
1799 return filename_completer_handle_brkchars;
1800
1801 if (fn == location_completer)
1802 return location_completer_handle_brkchars;
1803
1804 if (fn == command_completer)
1805 return command_completer_handle_brkchars;
1806
1807 return default_completer_handle_brkchars;
1808 }
1809
1810 /* Used as brkchars when we want to tell readline we have a custom
1811 word point. We do that by making our rl_completion_word_break_hook
1812 set RL_POINT to the desired word point, and return the character at
1813 the word break point as the break char. This is two bytes in order
1814 to fit one break character plus the terminating null. */
1815 static char gdb_custom_word_point_brkchars[2];
1816
1817 /* Since rl_basic_quote_characters is not completer-specific, we save
1818 its original value here, in order to be able to restore it in
1819 gdb_rl_attempted_completion_function. */
1820 static const char *gdb_org_rl_basic_quote_characters = rl_basic_quote_characters;
1821
1822 /* Get the list of chars that are considered as word breaks
1823 for the current command. */
1824
1825 static char *
1826 gdb_completion_word_break_characters_throw ()
1827 {
1828 /* New completion starting. Get rid of the previous tracker and
1829 start afresh. */
1830 delete current_completion.tracker;
1831 current_completion.tracker = new completion_tracker ();
1832
1833 completion_tracker &tracker = *current_completion.tracker;
1834
1835 complete_line_internal (tracker, NULL, rl_line_buffer,
1836 rl_point, handle_brkchars);
1837
1838 if (tracker.use_custom_word_point ())
1839 {
1840 gdb_assert (tracker.custom_word_point () > 0);
1841 rl_point = tracker.custom_word_point () - 1;
1842 gdb_custom_word_point_brkchars[0] = rl_line_buffer[rl_point];
1843 rl_completer_word_break_characters = gdb_custom_word_point_brkchars;
1844 rl_completer_quote_characters = NULL;
1845
1846 /* Clear this too, so that if we're completing a quoted string,
1847 readline doesn't consider the quote character a delimiter.
1848 If we didn't do this, readline would auto-complete {b
1849 'fun<tab>} to {'b 'function()'}, i.e., add the terminating
1850 \', but, it wouldn't append the separator space either, which
1851 is not desirable. So instead we take care of appending the
1852 quote character to the LCD ourselves, in
1853 gdb_rl_attempted_completion_function. Since this global is
1854 not just completer-specific, we'll restore it back to the
1855 default in gdb_rl_attempted_completion_function. */
1856 rl_basic_quote_characters = NULL;
1857 }
1858
1859 return rl_completer_word_break_characters;
1860 }
1861
1862 char *
1863 gdb_completion_word_break_characters ()
1864 {
1865 /* New completion starting. */
1866 current_completion.aborted = false;
1867
1868 TRY
1869 {
1870 return gdb_completion_word_break_characters_throw ();
1871 }
1872 CATCH (ex, RETURN_MASK_ALL)
1873 {
1874 /* Set this to that gdb_rl_attempted_completion_function knows
1875 to abort early. */
1876 current_completion.aborted = true;
1877 }
1878 END_CATCH
1879
1880 return NULL;
1881 }
1882
1883 /* See completer.h. */
1884
1885 const char *
1886 completion_find_completion_word (completion_tracker &tracker, const char *text,
1887 int *quote_char)
1888 {
1889 size_t point = strlen (text);
1890
1891 complete_line_internal (tracker, NULL, text, point, handle_brkchars);
1892
1893 if (tracker.use_custom_word_point ())
1894 {
1895 gdb_assert (tracker.custom_word_point () > 0);
1896 *quote_char = tracker.quote_char ();
1897 return text + tracker.custom_word_point ();
1898 }
1899
1900 gdb_rl_completion_word_info info;
1901
1902 info.word_break_characters = rl_completer_word_break_characters;
1903 info.quote_characters = gdb_completer_quote_characters;
1904 info.basic_quote_characters = rl_basic_quote_characters;
1905
1906 return gdb_rl_find_completion_word (&info, quote_char, NULL, text);
1907 }
1908
1909 /* See completer.h. */
1910
1911 void
1912 completion_tracker::recompute_lowest_common_denominator
1913 (gdb::unique_xmalloc_ptr<char> &&new_match_up)
1914 {
1915 if (m_lowest_common_denominator == NULL)
1916 {
1917 /* We don't have a lowest common denominator yet, so simply take
1918 the whole NEW_MATCH_UP as being it. */
1919 m_lowest_common_denominator = new_match_up.release ();
1920 m_lowest_common_denominator_unique = true;
1921 }
1922 else
1923 {
1924 /* Find the common denominator between the currently-known
1925 lowest common denominator and NEW_MATCH_UP. That becomes the
1926 new lowest common denominator. */
1927 size_t i;
1928 const char *new_match = new_match_up.get ();
1929
1930 for (i = 0;
1931 (new_match[i] != '\0'
1932 && new_match[i] == m_lowest_common_denominator[i]);
1933 i++)
1934 ;
1935 if (m_lowest_common_denominator[i] != new_match[i])
1936 {
1937 m_lowest_common_denominator[i] = '\0';
1938 m_lowest_common_denominator_unique = false;
1939 }
1940 }
1941 }
1942
1943 /* See completer.h. */
1944
1945 void
1946 completion_tracker::advance_custom_word_point_by (size_t len)
1947 {
1948 m_custom_word_point += len;
1949 }
1950
1951 /* Build a new C string that is a copy of LCD with the whitespace of
1952 ORIG/ORIG_LEN preserved.
1953
1954 Say the user is completing a symbol name, with spaces, like:
1955
1956 "foo ( i"
1957
1958 and the resulting completion match is:
1959
1960 "foo(int)"
1961
1962 we want to end up with an input line like:
1963
1964 "foo ( int)"
1965 ^^^^^^^ => text from LCD [1], whitespace from ORIG preserved.
1966 ^^ => new text from LCD
1967
1968 [1] - We must take characters from the LCD instead of the original
1969 text, since some completions want to change upper/lowercase. E.g.:
1970
1971 "handle sig<>"
1972
1973 completes to:
1974
1975 "handle SIG[QUIT|etc.]"
1976 */
1977
1978 static char *
1979 expand_preserving_ws (const char *orig, size_t orig_len,
1980 const char *lcd)
1981 {
1982 const char *p_orig = orig;
1983 const char *orig_end = orig + orig_len;
1984 const char *p_lcd = lcd;
1985 std::string res;
1986
1987 while (p_orig < orig_end)
1988 {
1989 if (*p_orig == ' ')
1990 {
1991 while (p_orig < orig_end && *p_orig == ' ')
1992 res += *p_orig++;
1993 p_lcd = skip_spaces (p_lcd);
1994 }
1995 else
1996 {
1997 /* Take characters from the LCD instead of the original
1998 text, since some completions change upper/lowercase.
1999 E.g.:
2000 "handle sig<>"
2001 completes to:
2002 "handle SIG[QUIT|etc.]"
2003 */
2004 res += *p_lcd;
2005 p_orig++;
2006 p_lcd++;
2007 }
2008 }
2009
2010 while (*p_lcd != '\0')
2011 res += *p_lcd++;
2012
2013 return xstrdup (res.c_str ());
2014 }
2015
2016 /* See completer.h. */
2017
2018 completion_result
2019 completion_tracker::build_completion_result (const char *text,
2020 int start, int end)
2021 {
2022 completion_list &list = m_entries_vec; /* The completions. */
2023
2024 if (list.empty ())
2025 return {};
2026
2027 /* +1 for the LCD, and +1 for NULL termination. */
2028 char **match_list = XNEWVEC (char *, 1 + list.size () + 1);
2029
2030 /* Build replacement word, based on the LCD. */
2031
2032 match_list[0]
2033 = expand_preserving_ws (text, end - start,
2034 m_lowest_common_denominator);
2035
2036 if (m_lowest_common_denominator_unique)
2037 {
2038 /* We don't rely on readline appending the quote char as
2039 delimiter as then readline wouldn't append the ' ' after the
2040 completion. */
2041 char buf[2] = { quote_char () };
2042
2043 match_list[0] = reconcat (match_list[0], match_list[0],
2044 buf, (char *) NULL);
2045 match_list[1] = NULL;
2046
2047 /* If the tracker wants to, or we already have a space at the
2048 end of the match, tell readline to skip appending
2049 another. */
2050 bool completion_suppress_append
2051 = (suppress_append_ws ()
2052 || match_list[0][strlen (match_list[0]) - 1] == ' ');
2053
2054 return completion_result (match_list, 1, completion_suppress_append);
2055 }
2056 else
2057 {
2058 int ix;
2059
2060 for (ix = 0; ix < list.size (); ++ix)
2061 match_list[ix + 1] = list[ix].release ();
2062 match_list[ix + 1] = NULL;
2063
2064 return completion_result (match_list, list.size (), false);
2065 }
2066 }
2067
2068 /* See completer.h */
2069
2070 completion_result::completion_result ()
2071 : match_list (NULL), number_matches (0),
2072 completion_suppress_append (false)
2073 {}
2074
2075 /* See completer.h */
2076
2077 completion_result::completion_result (char **match_list_,
2078 size_t number_matches_,
2079 bool completion_suppress_append_)
2080 : match_list (match_list_),
2081 number_matches (number_matches_),
2082 completion_suppress_append (completion_suppress_append_)
2083 {}
2084
2085 /* See completer.h */
2086
2087 completion_result::~completion_result ()
2088 {
2089 reset_match_list ();
2090 }
2091
2092 /* See completer.h */
2093
2094 completion_result::completion_result (completion_result &&rhs)
2095 {
2096 if (this == &rhs)
2097 return;
2098
2099 reset_match_list ();
2100 match_list = rhs.match_list;
2101 rhs.match_list = NULL;
2102 number_matches = rhs.number_matches;
2103 rhs.number_matches = 0;
2104 }
2105
2106 /* See completer.h */
2107
2108 char **
2109 completion_result::release_match_list ()
2110 {
2111 char **ret = match_list;
2112 match_list = NULL;
2113 return ret;
2114 }
2115
2116 /* See completer.h */
2117
2118 void
2119 completion_result::sort_match_list ()
2120 {
2121 if (number_matches > 1)
2122 {
2123 /* Element 0 is special (it's the common prefix), leave it
2124 be. */
2125 std::sort (&match_list[1],
2126 &match_list[number_matches + 1],
2127 compare_cstrings);
2128 }
2129 }
2130
2131 /* See completer.h */
2132
2133 void
2134 completion_result::reset_match_list ()
2135 {
2136 if (match_list != NULL)
2137 {
2138 for (char **p = match_list; *p != NULL; p++)
2139 xfree (*p);
2140 xfree (match_list);
2141 match_list = NULL;
2142 }
2143 }
2144
2145 /* Helper for gdb_rl_attempted_completion_function, which does most of
2146 the work. This is called by readline to build the match list array
2147 and to determine the lowest common denominator. The real matches
2148 list starts at match[1], while match[0] is the slot holding
2149 readline's idea of the lowest common denominator of all matches,
2150 which is what readline replaces the completion "word" with.
2151
2152 TEXT is the caller's idea of the "word" we are looking at, as
2153 computed in the handle_brkchars phase.
2154
2155 START is the offset from RL_LINE_BUFFER where TEXT starts. END is
2156 the offset from RL_LINE_BUFFER where TEXT ends (i.e., where
2157 rl_point is).
2158
2159 You should thus pretend that the line ends at END (relative to
2160 RL_LINE_BUFFER).
2161
2162 RL_LINE_BUFFER contains the entire text of the line. RL_POINT is
2163 the offset in that line of the cursor. You should pretend that the
2164 line ends at POINT.
2165
2166 Returns NULL if there are no completions. */
2167
2168 static char **
2169 gdb_rl_attempted_completion_function_throw (const char *text, int start, int end)
2170 {
2171 /* Completers that provide a custom word point in the
2172 handle_brkchars phase also compute their completions then.
2173 Completers that leave the completion word handling to readline
2174 must be called twice. If rl_point (i.e., END) is at column 0,
2175 then readline skips the handle_brkchars phase, and so we create a
2176 tracker now in that case too. */
2177 if (end == 0 || !current_completion.tracker->use_custom_word_point ())
2178 {
2179 delete current_completion.tracker;
2180 current_completion.tracker = new completion_tracker ();
2181
2182 complete_line (*current_completion.tracker, text,
2183 rl_line_buffer, rl_point);
2184 }
2185
2186 completion_tracker &tracker = *current_completion.tracker;
2187
2188 completion_result result
2189 = tracker.build_completion_result (text, start, end);
2190
2191 rl_completion_suppress_append = result.completion_suppress_append;
2192 return result.release_match_list ();
2193 }
2194
2195 /* Function installed as "rl_attempted_completion_function" readline
2196 hook. Wrapper around gdb_rl_attempted_completion_function_throw
2197 that catches C++ exceptions, which can't cross readline. */
2198
2199 char **
2200 gdb_rl_attempted_completion_function (const char *text, int start, int end)
2201 {
2202 /* Restore globals that might have been tweaked in
2203 gdb_completion_word_break_characters. */
2204 rl_basic_quote_characters = gdb_org_rl_basic_quote_characters;
2205
2206 /* If we end up returning NULL, either on error, or simple because
2207 there are no matches, inhibit readline's default filename
2208 completer. */
2209 rl_attempted_completion_over = 1;
2210
2211 /* If the handle_brkchars phase was aborted, don't try
2212 completing. */
2213 if (current_completion.aborted)
2214 return NULL;
2215
2216 TRY
2217 {
2218 return gdb_rl_attempted_completion_function_throw (text, start, end);
2219 }
2220 CATCH (ex, RETURN_MASK_ALL)
2221 {
2222 }
2223 END_CATCH
2224
2225 return NULL;
2226 }
2227
2228 /* Skip over the possibly quoted word STR (as defined by the quote
2229 characters QUOTECHARS and the word break characters BREAKCHARS).
2230 Returns pointer to the location after the "word". If either
2231 QUOTECHARS or BREAKCHARS is NULL, use the same values used by the
2232 completer. */
2233
2234 const char *
2235 skip_quoted_chars (const char *str, const char *quotechars,
2236 const char *breakchars)
2237 {
2238 char quote_char = '\0';
2239 const char *scan;
2240
2241 if (quotechars == NULL)
2242 quotechars = gdb_completer_quote_characters;
2243
2244 if (breakchars == NULL)
2245 breakchars = current_language->la_word_break_characters();
2246
2247 for (scan = str; *scan != '\0'; scan++)
2248 {
2249 if (quote_char != '\0')
2250 {
2251 /* Ignore everything until the matching close quote char. */
2252 if (*scan == quote_char)
2253 {
2254 /* Found matching close quote. */
2255 scan++;
2256 break;
2257 }
2258 }
2259 else if (strchr (quotechars, *scan))
2260 {
2261 /* Found start of a quoted string. */
2262 quote_char = *scan;
2263 }
2264 else if (strchr (breakchars, *scan))
2265 {
2266 break;
2267 }
2268 }
2269
2270 return (scan);
2271 }
2272
2273 /* Skip over the possibly quoted word STR (as defined by the quote
2274 characters and word break characters used by the completer).
2275 Returns pointer to the location after the "word". */
2276
2277 const char *
2278 skip_quoted (const char *str)
2279 {
2280 return skip_quoted_chars (str, NULL, NULL);
2281 }
2282
2283 /* Return a message indicating that the maximum number of completions
2284 has been reached and that there may be more. */
2285
2286 const char *
2287 get_max_completions_reached_message (void)
2288 {
2289 return _("*** List may be truncated, max-completions reached. ***");
2290 }
2291
2292 /* GDB replacement for rl_display_match_list.
2293 Readline doesn't provide a clean interface for TUI(curses).
2294 A hack previously used was to send readline's rl_outstream through a pipe
2295 and read it from the event loop. Bleah. IWBN if readline abstracted
2296 away all the necessary bits, and this is what this code does. It
2297 replicates the parts of readline we need and then adds an abstraction
2298 layer, currently implemented as struct match_list_displayer, so that both
2299 CLI and TUI can use it. We copy all this readline code to minimize
2300 GDB-specific mods to readline. Once this code performs as desired then
2301 we can submit it to the readline maintainers.
2302
2303 N.B. A lot of the code is the way it is in order to minimize differences
2304 from readline's copy. */
2305
2306 /* Not supported here. */
2307 #undef VISIBLE_STATS
2308
2309 #if defined (HANDLE_MULTIBYTE)
2310 #define MB_INVALIDCH(x) ((x) == (size_t)-1 || (x) == (size_t)-2)
2311 #define MB_NULLWCH(x) ((x) == 0)
2312 #endif
2313
2314 #define ELLIPSIS_LEN 3
2315
2316 /* gdb version of readline/complete.c:get_y_or_n.
2317 'y' -> returns 1, and 'n' -> returns 0.
2318 Also supported: space == 'y', RUBOUT == 'n', ctrl-g == start over.
2319 If FOR_PAGER is non-zero, then also supported are:
2320 NEWLINE or RETURN -> returns 2, and 'q' -> returns 0. */
2321
2322 static int
2323 gdb_get_y_or_n (int for_pager, const struct match_list_displayer *displayer)
2324 {
2325 int c;
2326
2327 for (;;)
2328 {
2329 RL_SETSTATE (RL_STATE_MOREINPUT);
2330 c = displayer->read_key (displayer);
2331 RL_UNSETSTATE (RL_STATE_MOREINPUT);
2332
2333 if (c == 'y' || c == 'Y' || c == ' ')
2334 return 1;
2335 if (c == 'n' || c == 'N' || c == RUBOUT)
2336 return 0;
2337 if (c == ABORT_CHAR || c < 0)
2338 {
2339 /* Readline doesn't erase_entire_line here, but without it the
2340 --More-- prompt isn't erased and neither is the text entered
2341 thus far redisplayed. */
2342 displayer->erase_entire_line (displayer);
2343 /* Note: The arguments to rl_abort are ignored. */
2344 rl_abort (0, 0);
2345 }
2346 if (for_pager && (c == NEWLINE || c == RETURN))
2347 return 2;
2348 if (for_pager && (c == 'q' || c == 'Q'))
2349 return 0;
2350 displayer->beep (displayer);
2351 }
2352 }
2353
2354 /* Pager function for tab-completion.
2355 This is based on readline/complete.c:_rl_internal_pager.
2356 LINES is the number of lines of output displayed thus far.
2357 Returns:
2358 -1 -> user pressed 'n' or equivalent,
2359 0 -> user pressed 'y' or equivalent,
2360 N -> user pressed NEWLINE or equivalent and N is LINES - 1. */
2361
2362 static int
2363 gdb_display_match_list_pager (int lines,
2364 const struct match_list_displayer *displayer)
2365 {
2366 int i;
2367
2368 displayer->puts (displayer, "--More--");
2369 displayer->flush (displayer);
2370 i = gdb_get_y_or_n (1, displayer);
2371 displayer->erase_entire_line (displayer);
2372 if (i == 0)
2373 return -1;
2374 else if (i == 2)
2375 return (lines - 1);
2376 else
2377 return 0;
2378 }
2379
2380 /* Return non-zero if FILENAME is a directory.
2381 Based on readline/complete.c:path_isdir. */
2382
2383 static int
2384 gdb_path_isdir (const char *filename)
2385 {
2386 struct stat finfo;
2387
2388 return (stat (filename, &finfo) == 0 && S_ISDIR (finfo.st_mode));
2389 }
2390
2391 /* Return the portion of PATHNAME that should be output when listing
2392 possible completions. If we are hacking filename completion, we
2393 are only interested in the basename, the portion following the
2394 final slash. Otherwise, we return what we were passed. Since
2395 printing empty strings is not very informative, if we're doing
2396 filename completion, and the basename is the empty string, we look
2397 for the previous slash and return the portion following that. If
2398 there's no previous slash, we just return what we were passed.
2399
2400 Based on readline/complete.c:printable_part. */
2401
2402 static char *
2403 gdb_printable_part (char *pathname)
2404 {
2405 char *temp, *x;
2406
2407 if (rl_filename_completion_desired == 0) /* don't need to do anything */
2408 return (pathname);
2409
2410 temp = strrchr (pathname, '/');
2411 #if defined (__MSDOS__)
2412 if (temp == 0 && ISALPHA ((unsigned char)pathname[0]) && pathname[1] == ':')
2413 temp = pathname + 1;
2414 #endif
2415
2416 if (temp == 0 || *temp == '\0')
2417 return (pathname);
2418 /* If the basename is NULL, we might have a pathname like '/usr/src/'.
2419 Look for a previous slash and, if one is found, return the portion
2420 following that slash. If there's no previous slash, just return the
2421 pathname we were passed. */
2422 else if (temp[1] == '\0')
2423 {
2424 for (x = temp - 1; x > pathname; x--)
2425 if (*x == '/')
2426 break;
2427 return ((*x == '/') ? x + 1 : pathname);
2428 }
2429 else
2430 return ++temp;
2431 }
2432
2433 /* Compute width of STRING when displayed on screen by print_filename.
2434 Based on readline/complete.c:fnwidth. */
2435
2436 static int
2437 gdb_fnwidth (const char *string)
2438 {
2439 int width, pos;
2440 #if defined (HANDLE_MULTIBYTE)
2441 mbstate_t ps;
2442 int left, w;
2443 size_t clen;
2444 wchar_t wc;
2445
2446 left = strlen (string) + 1;
2447 memset (&ps, 0, sizeof (mbstate_t));
2448 #endif
2449
2450 width = pos = 0;
2451 while (string[pos])
2452 {
2453 if (CTRL_CHAR (string[pos]) || string[pos] == RUBOUT)
2454 {
2455 width += 2;
2456 pos++;
2457 }
2458 else
2459 {
2460 #if defined (HANDLE_MULTIBYTE)
2461 clen = mbrtowc (&wc, string + pos, left - pos, &ps);
2462 if (MB_INVALIDCH (clen))
2463 {
2464 width++;
2465 pos++;
2466 memset (&ps, 0, sizeof (mbstate_t));
2467 }
2468 else if (MB_NULLWCH (clen))
2469 break;
2470 else
2471 {
2472 pos += clen;
2473 w = wcwidth (wc);
2474 width += (w >= 0) ? w : 1;
2475 }
2476 #else
2477 width++;
2478 pos++;
2479 #endif
2480 }
2481 }
2482
2483 return width;
2484 }
2485
2486 /* Print TO_PRINT, one matching completion.
2487 PREFIX_BYTES is number of common prefix bytes.
2488 Based on readline/complete.c:fnprint. */
2489
2490 static int
2491 gdb_fnprint (const char *to_print, int prefix_bytes,
2492 const struct match_list_displayer *displayer)
2493 {
2494 int printed_len, w;
2495 const char *s;
2496 #if defined (HANDLE_MULTIBYTE)
2497 mbstate_t ps;
2498 const char *end;
2499 size_t tlen;
2500 int width;
2501 wchar_t wc;
2502
2503 end = to_print + strlen (to_print) + 1;
2504 memset (&ps, 0, sizeof (mbstate_t));
2505 #endif
2506
2507 printed_len = 0;
2508
2509 /* Don't print only the ellipsis if the common prefix is one of the
2510 possible completions */
2511 if (to_print[prefix_bytes] == '\0')
2512 prefix_bytes = 0;
2513
2514 if (prefix_bytes)
2515 {
2516 char ellipsis;
2517
2518 ellipsis = (to_print[prefix_bytes] == '.') ? '_' : '.';
2519 for (w = 0; w < ELLIPSIS_LEN; w++)
2520 displayer->putch (displayer, ellipsis);
2521 printed_len = ELLIPSIS_LEN;
2522 }
2523
2524 s = to_print + prefix_bytes;
2525 while (*s)
2526 {
2527 if (CTRL_CHAR (*s))
2528 {
2529 displayer->putch (displayer, '^');
2530 displayer->putch (displayer, UNCTRL (*s));
2531 printed_len += 2;
2532 s++;
2533 #if defined (HANDLE_MULTIBYTE)
2534 memset (&ps, 0, sizeof (mbstate_t));
2535 #endif
2536 }
2537 else if (*s == RUBOUT)
2538 {
2539 displayer->putch (displayer, '^');
2540 displayer->putch (displayer, '?');
2541 printed_len += 2;
2542 s++;
2543 #if defined (HANDLE_MULTIBYTE)
2544 memset (&ps, 0, sizeof (mbstate_t));
2545 #endif
2546 }
2547 else
2548 {
2549 #if defined (HANDLE_MULTIBYTE)
2550 tlen = mbrtowc (&wc, s, end - s, &ps);
2551 if (MB_INVALIDCH (tlen))
2552 {
2553 tlen = 1;
2554 width = 1;
2555 memset (&ps, 0, sizeof (mbstate_t));
2556 }
2557 else if (MB_NULLWCH (tlen))
2558 break;
2559 else
2560 {
2561 w = wcwidth (wc);
2562 width = (w >= 0) ? w : 1;
2563 }
2564 for (w = 0; w < tlen; ++w)
2565 displayer->putch (displayer, s[w]);
2566 s += tlen;
2567 printed_len += width;
2568 #else
2569 displayer->putch (displayer, *s);
2570 s++;
2571 printed_len++;
2572 #endif
2573 }
2574 }
2575
2576 return printed_len;
2577 }
2578
2579 /* Output TO_PRINT to rl_outstream. If VISIBLE_STATS is defined and we
2580 are using it, check for and output a single character for `special'
2581 filenames. Return the number of characters we output.
2582 Based on readline/complete.c:print_filename. */
2583
2584 static int
2585 gdb_print_filename (char *to_print, char *full_pathname, int prefix_bytes,
2586 const struct match_list_displayer *displayer)
2587 {
2588 int printed_len, extension_char, slen, tlen;
2589 char *s, c, *new_full_pathname;
2590 const char *dn;
2591 extern int _rl_complete_mark_directories;
2592
2593 extension_char = 0;
2594 printed_len = gdb_fnprint (to_print, prefix_bytes, displayer);
2595
2596 #if defined (VISIBLE_STATS)
2597 if (rl_filename_completion_desired && (rl_visible_stats || _rl_complete_mark_directories))
2598 #else
2599 if (rl_filename_completion_desired && _rl_complete_mark_directories)
2600 #endif
2601 {
2602 /* If to_print != full_pathname, to_print is the basename of the
2603 path passed. In this case, we try to expand the directory
2604 name before checking for the stat character. */
2605 if (to_print != full_pathname)
2606 {
2607 /* Terminate the directory name. */
2608 c = to_print[-1];
2609 to_print[-1] = '\0';
2610
2611 /* If setting the last slash in full_pathname to a NUL results in
2612 full_pathname being the empty string, we are trying to complete
2613 files in the root directory. If we pass a null string to the
2614 bash directory completion hook, for example, it will expand it
2615 to the current directory. We just want the `/'. */
2616 if (full_pathname == 0 || *full_pathname == 0)
2617 dn = "/";
2618 else if (full_pathname[0] != '/')
2619 dn = full_pathname;
2620 else if (full_pathname[1] == 0)
2621 dn = "//"; /* restore trailing slash to `//' */
2622 else if (full_pathname[1] == '/' && full_pathname[2] == 0)
2623 dn = "/"; /* don't turn /// into // */
2624 else
2625 dn = full_pathname;
2626 s = tilde_expand (dn);
2627 if (rl_directory_completion_hook)
2628 (*rl_directory_completion_hook) (&s);
2629
2630 slen = strlen (s);
2631 tlen = strlen (to_print);
2632 new_full_pathname = (char *)xmalloc (slen + tlen + 2);
2633 strcpy (new_full_pathname, s);
2634 if (s[slen - 1] == '/')
2635 slen--;
2636 else
2637 new_full_pathname[slen] = '/';
2638 new_full_pathname[slen] = '/';
2639 strcpy (new_full_pathname + slen + 1, to_print);
2640
2641 #if defined (VISIBLE_STATS)
2642 if (rl_visible_stats)
2643 extension_char = stat_char (new_full_pathname);
2644 else
2645 #endif
2646 if (gdb_path_isdir (new_full_pathname))
2647 extension_char = '/';
2648
2649 xfree (new_full_pathname);
2650 to_print[-1] = c;
2651 }
2652 else
2653 {
2654 s = tilde_expand (full_pathname);
2655 #if defined (VISIBLE_STATS)
2656 if (rl_visible_stats)
2657 extension_char = stat_char (s);
2658 else
2659 #endif
2660 if (gdb_path_isdir (s))
2661 extension_char = '/';
2662 }
2663
2664 xfree (s);
2665 if (extension_char)
2666 {
2667 displayer->putch (displayer, extension_char);
2668 printed_len++;
2669 }
2670 }
2671
2672 return printed_len;
2673 }
2674
2675 /* GDB version of readline/complete.c:complete_get_screenwidth. */
2676
2677 static int
2678 gdb_complete_get_screenwidth (const struct match_list_displayer *displayer)
2679 {
2680 /* Readline has other stuff here which it's not clear we need. */
2681 return displayer->width;
2682 }
2683
2684 extern int _rl_completion_prefix_display_length;
2685 extern int _rl_print_completions_horizontally;
2686
2687 EXTERN_C int _rl_qsort_string_compare (const void *, const void *);
2688 typedef int QSFUNC (const void *, const void *);
2689
2690 /* GDB version of readline/complete.c:rl_display_match_list.
2691 See gdb_display_match_list for a description of MATCHES, LEN, MAX.
2692 Returns non-zero if all matches are displayed. */
2693
2694 static int
2695 gdb_display_match_list_1 (char **matches, int len, int max,
2696 const struct match_list_displayer *displayer)
2697 {
2698 int count, limit, printed_len, lines, cols;
2699 int i, j, k, l, common_length, sind;
2700 char *temp, *t;
2701 int page_completions = displayer->height != INT_MAX && pagination_enabled;
2702
2703 /* Find the length of the prefix common to all items: length as displayed
2704 characters (common_length) and as a byte index into the matches (sind) */
2705 common_length = sind = 0;
2706 if (_rl_completion_prefix_display_length > 0)
2707 {
2708 t = gdb_printable_part (matches[0]);
2709 temp = strrchr (t, '/');
2710 common_length = temp ? gdb_fnwidth (temp) : gdb_fnwidth (t);
2711 sind = temp ? strlen (temp) : strlen (t);
2712
2713 if (common_length > _rl_completion_prefix_display_length && common_length > ELLIPSIS_LEN)
2714 max -= common_length - ELLIPSIS_LEN;
2715 else
2716 common_length = sind = 0;
2717 }
2718
2719 /* How many items of MAX length can we fit in the screen window? */
2720 cols = gdb_complete_get_screenwidth (displayer);
2721 max += 2;
2722 limit = cols / max;
2723 if (limit != 1 && (limit * max == cols))
2724 limit--;
2725
2726 /* If cols == 0, limit will end up -1 */
2727 if (cols < displayer->width && limit < 0)
2728 limit = 1;
2729
2730 /* Avoid a possible floating exception. If max > cols,
2731 limit will be 0 and a divide-by-zero fault will result. */
2732 if (limit == 0)
2733 limit = 1;
2734
2735 /* How many iterations of the printing loop? */
2736 count = (len + (limit - 1)) / limit;
2737
2738 /* Watch out for special case. If LEN is less than LIMIT, then
2739 just do the inner printing loop.
2740 0 < len <= limit implies count = 1. */
2741
2742 /* Sort the items if they are not already sorted. */
2743 if (rl_ignore_completion_duplicates == 0 && rl_sort_completion_matches)
2744 qsort (matches + 1, len, sizeof (char *), (QSFUNC *)_rl_qsort_string_compare);
2745
2746 displayer->crlf (displayer);
2747
2748 lines = 0;
2749 if (_rl_print_completions_horizontally == 0)
2750 {
2751 /* Print the sorted items, up-and-down alphabetically, like ls. */
2752 for (i = 1; i <= count; i++)
2753 {
2754 for (j = 0, l = i; j < limit; j++)
2755 {
2756 if (l > len || matches[l] == 0)
2757 break;
2758 else
2759 {
2760 temp = gdb_printable_part (matches[l]);
2761 printed_len = gdb_print_filename (temp, matches[l], sind,
2762 displayer);
2763
2764 if (j + 1 < limit)
2765 for (k = 0; k < max - printed_len; k++)
2766 displayer->putch (displayer, ' ');
2767 }
2768 l += count;
2769 }
2770 displayer->crlf (displayer);
2771 lines++;
2772 if (page_completions && lines >= (displayer->height - 1) && i < count)
2773 {
2774 lines = gdb_display_match_list_pager (lines, displayer);
2775 if (lines < 0)
2776 return 0;
2777 }
2778 }
2779 }
2780 else
2781 {
2782 /* Print the sorted items, across alphabetically, like ls -x. */
2783 for (i = 1; matches[i]; i++)
2784 {
2785 temp = gdb_printable_part (matches[i]);
2786 printed_len = gdb_print_filename (temp, matches[i], sind, displayer);
2787 /* Have we reached the end of this line? */
2788 if (matches[i+1])
2789 {
2790 if (i && (limit > 1) && (i % limit) == 0)
2791 {
2792 displayer->crlf (displayer);
2793 lines++;
2794 if (page_completions && lines >= displayer->height - 1)
2795 {
2796 lines = gdb_display_match_list_pager (lines, displayer);
2797 if (lines < 0)
2798 return 0;
2799 }
2800 }
2801 else
2802 for (k = 0; k < max - printed_len; k++)
2803 displayer->putch (displayer, ' ');
2804 }
2805 }
2806 displayer->crlf (displayer);
2807 }
2808
2809 return 1;
2810 }
2811
2812 /* Utility for displaying completion list matches, used by both CLI and TUI.
2813
2814 MATCHES is the list of strings, in argv format, LEN is the number of
2815 strings in MATCHES, and MAX is the length of the longest string in
2816 MATCHES. */
2817
2818 void
2819 gdb_display_match_list (char **matches, int len, int max,
2820 const struct match_list_displayer *displayer)
2821 {
2822 /* Readline will never call this if complete_line returned NULL. */
2823 gdb_assert (max_completions != 0);
2824
2825 /* complete_line will never return more than this. */
2826 if (max_completions > 0)
2827 gdb_assert (len <= max_completions);
2828
2829 if (rl_completion_query_items > 0 && len >= rl_completion_query_items)
2830 {
2831 char msg[100];
2832
2833 /* We can't use *query here because they wait for <RET> which is
2834 wrong here. This follows the readline version as closely as possible
2835 for compatibility's sake. See readline/complete.c. */
2836
2837 displayer->crlf (displayer);
2838
2839 xsnprintf (msg, sizeof (msg),
2840 "Display all %d possibilities? (y or n)", len);
2841 displayer->puts (displayer, msg);
2842 displayer->flush (displayer);
2843
2844 if (gdb_get_y_or_n (0, displayer) == 0)
2845 {
2846 displayer->crlf (displayer);
2847 return;
2848 }
2849 }
2850
2851 if (gdb_display_match_list_1 (matches, len, max, displayer))
2852 {
2853 /* Note: MAX_COMPLETIONS may be -1 or zero, but LEN is always > 0. */
2854 if (len == max_completions)
2855 {
2856 /* The maximum number of completions has been reached. Warn the user
2857 that there may be more. */
2858 const char *message = get_max_completions_reached_message ();
2859
2860 displayer->puts (displayer, message);
2861 displayer->crlf (displayer);
2862 }
2863 }
2864 }
2865
2866 void
2867 _initialize_completer (void)
2868 {
2869 add_setshow_zuinteger_unlimited_cmd ("max-completions", no_class,
2870 &max_completions, _("\
2871 Set maximum number of completion candidates."), _("\
2872 Show maximum number of completion candidates."), _("\
2873 Use this to limit the number of candidates considered\n\
2874 during completion. Specifying \"unlimited\" or -1\n\
2875 disables limiting. Note that setting either no limit or\n\
2876 a very large limit can make completion slow."),
2877 NULL, NULL, &setlist, &showlist);
2878 }
gdbarch
Definition: gdbarch.c:127
handle_help
Definition: completer.c:1173
completion_tracker::suppress_append_ws
bool suppress_append_ws() const
Definition: completer.h:364
string
const char * string
Definition: signals.c:50
gdb_completer_file_name_break_characters
static const char gdb_completer_file_name_break_characters[]
Definition: completer.c:119
gdb_org_rl_basic_quote_characters
static const char * gdb_org_rl_basic_quote_characters
Definition: completer.c:1820
user_reg_map_regnum_to_name
const char * user_reg_map_regnum_to_name(struct gdbarch *gdbarch, int regnum)
Definition: user-regs.c:193
gdb_printable_part
static char * gdb_printable_part(char *pathname)
Definition: completer.c:2403
gdb_rl_completion_word_info::quote_characters
const char * quote_characters
Definition: completer.c:226
reg_completer_target
reg_completer_target
Definition: completer.c:1702
default_completer_handle_brkchars
static void default_completer_handle_brkchars(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition: completer.c:1785
MAX_COMPLETIONS_REACHED_ERROR
Definition: common-exceptions.h:105
type_code
type_code
Definition: gdbtypes.h:80
completer.h
match_list_displayer::putch
mld_putch_ftype * putch
Definition: completer.h:47
gdb_fnwidth
static int gdb_fnwidth(const char *string)
Definition: completer.c:2437
make_source_files_completion_list
completion_list make_source_files_completion_list(const char *text, const char *word)
Definition: symtab.c:5381
ELLIPSIS_LEN
#define ELLIPSIS_LEN
Definition: completer.c:2314
MATCH_LABEL
Definition: completer.c:86
gdb_completion_word_break_characters_throw
static char * gdb_completion_word_break_characters_throw()
Definition: completer.c:1826
GDB_SIGNAL_FIRST
#define GDB_SIGNAL_FIRST
TYPE_FIELD_NAME
#define TYPE_FIELD_NAME(thistype, n)
Definition: gdbtypes.h:1372
RETURN_MASK_ALL
Definition: common-exceptions.h:44
TYPE_N_BASECLASSES
#define TYPE_N_BASECLASSES(thistype)
Definition: gdbtypes.h:1331
cmd_list_element::completer_handle_brkchars
completer_handle_brkchars_ftype * completer_handle_brkchars
Definition: cli-decode.h:172
xfree
void xfree(void *)
make_completion_match_str_1
static char * make_completion_match_str_1(const char *match_name, const char *text, const char *word)
Definition: completer.c:1572
no_class
Definition: command.h:41
TYPE_NFN_FIELDS
#define TYPE_NFN_FIELDS(thistype)
Definition: gdbtypes.h:1311
match_list_displayer::crlf
mld_crlf_ftype * crlf
Definition: completer.h:44
completer_handle_brkchars_func_for_completer
completer_handle_brkchars_ftype * completer_handle_brkchars_func_for_completer(completer_ftype *fn)
Definition: completer.c:1796
cmd_list_element
Definition: cli-decode.h:46
completion_tracker::have_completions
bool have_completions() const
Definition: completer.h:391
INT_MAX
#define INT_MAX
Definition: defs.h:477
RL_QF_OTHER_QUOTE
#define RL_QF_OTHER_QUOTE
Definition: completer.c:207
scan
static void scan(struct macro_buffer *dest, struct macro_buffer *src, struct macro_name_list *no_loop, macro_lookup_ftype *lookup_func, void *lookup_baton)
Definition: macroexp.c:1446
completion_tracker::add_completions
void add_completions(completion_list &&list)
Definition: completer.c:1561
linespec_keywords
const char *const linespec_keywords[]
Definition: linespec.c:251
current_completion
static gdb_completer_state current_completion
Definition: completer.c:65
complete_expression
void complete_expression(completion_tracker &tracker, const char *text, const char *word)
Definition: completer.c:1015
complete_on_cmdlist
void complete_on_cmdlist(struct cmd_list_element *list, completion_tracker &tracker, const char *text, const char *word, int ignore_help_classes)
Definition: cli-decode.c:1795
compare_cstrings
static bool compare_cstrings(const char *str1, const char *str2)
Definition: utils.h:102
cmd_list_element::enums
const char *const * enums
Definition: cli-decode.h:185
MATCH_SOURCE
Definition: completer.c:74
reggroups.h
completion_result
Definition: completer.h:230
completion_tracker::set_quote_char
void set_quote_char(int quote_char)
Definition: completer.h:332
gdb_path_isdir
static int gdb_path_isdir(const char *filename)
Definition: completer.c:2384
cmd_list_element::allow_unknown
unsigned int allow_unknown
Definition: cli-decode.h:90
RETURN_MASK_ERROR
Definition: common-exceptions.h:43
collect_file_symbol_completion_matches
void collect_file_symbol_completion_matches(completion_tracker &tracker, complete_symbol_mode mode, symbol_name_match_type name_match_type, const char *text, const char *word, const char *srcfile)
Definition: symtab.c:5240
reg_or_group_completer_1
static void reg_or_group_completer_1(completion_tracker &tracker, const char *text, const char *word, reg_completer_targets targets)
Definition: completer.c:1713
complete_on_enum
void complete_on_enum(completion_tracker &tracker, const char *const *enumlist, const char *text, const char *word)
Definition: cli-decode.c:1853
memset
void * memset(T *s, int c, size_t n)=delete
match_list_displayer
Definition: completer.h:38
linespec_complete_label
void linespec_complete_label(completion_tracker &tracker, const struct language_defn *language, const char *source_filename, const char *function_name, symbol_name_match_type func_name_match_type, const char *label_name)
Definition: linespec.c:2960
collect_symbol_completion_matches_type
void collect_symbol_completion_matches_type(completion_tracker &tracker, const char *text, const char *word, enum type_code code)
Definition: symtab.c:5221
advance_to_expression_complete_word_point
const char * advance_to_expression_complete_word_point(completion_tracker &tracker, const char *text)
Definition: completer.c:358
RL_QF_SINGLE_QUOTE
#define RL_QF_SINGLE_QUOTE
Definition: completer.c:204
delimiter
char delimiter
Definition: gdb_vecs.h:38
completion_tracker::discard_completions
void discard_completions()
Definition: completer.c:1485
completion_tracker::completes_to_completion_word
bool completes_to_completion_word(const char *word)
Definition: completer.c:379
lookup_cmd_1
struct cmd_list_element * lookup_cmd_1(const char **text, struct cmd_list_element *clist, struct cmd_list_element **result_list, int ignore_help_classes)
Definition: cli-decode.c:1385
filename_completer
void filename_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition: completer.c:152
collect_symbol_completion_matches
void collect_symbol_completion_matches(completion_tracker &tracker, complete_symbol_mode mode, symbol_name_match_type name_match_type, const char *text, const char *word)
Definition: symtab.c:5206
TYPE_CODE_UNDEF
Definition: gdbtypes.h:83
gdb_print_filename
static int gdb_print_filename(char *to_print, char *full_pathname, int prefix_bytes, const struct match_list_displayer *displayer)
Definition: completer.c:2585
cmdlist
struct cmd_list_element * cmdlist
Definition: cli-cmds.c:79
skip_spaces
char * skip_spaces(char *chp)
Definition: common-utils.c:337
set_rl_completer_word_break_characters
void set_rl_completer_word_break_characters(const char *break_chars)
Definition: completer.c:1086
cleanup
Definition: cleanups.c:38
gdb_completion_word_break_characters
char * gdb_completion_word_break_characters()
Definition: completer.c:1863
_
#define _(String)
Definition: gdb_locale.h:35
gdb_display_match_list_pager
static int gdb_display_match_list_pager(int lines, const struct match_list_displayer *displayer)
Definition: completer.c:2363
defs.h
complete_line_internal_reason
complete_line_internal_reason
Definition: completer.c:1143
END_CATCH
#define END_CATCH
Definition: common-exceptions.h:259
TYPE_FIELD_TYPE
#define TYPE_FIELD_TYPE(thistype, n)
Definition: gdbtypes.h:1371
reggroup
Definition: reggroups.c:33
cleanup_check.ps
ps
Definition: cleanup_check.py:333
complete_line
void complete_line(completion_tracker &tracker, const char *text, const char *line_buffer, int point)
Definition: completer.c:1637
match_list_displayer::read_key
mld_read_key_ftype * read_key
Definition: completer.h:63
RL_QF_DOUBLE_QUOTE
#define RL_QF_DOUBLE_QUOTE
Definition: completer.c:205
pagination_enabled
int pagination_enabled
Definition: utils.c:128
cli-decode.h
arch-utils.h
skip_quoted_chars
const char * skip_quoted_chars(const char *str, const char *quotechars, const char *breakchars)
Definition: completer.c:2235
completion_tracker::custom_word_point
int custom_word_point() const
Definition: completer.h:352
TYPE_IS_REFERENCE
#define TYPE_IS_REFERENCE(t)
Definition: gdbtypes.h:332
completion_result::reset_match_list
void reset_match_list()
Definition: completer.c:2134
completion_tracker::m_custom_word_point
int m_custom_word_point
Definition: completer.h:464
gdb_rl_find_completion_word
static const char * gdb_rl_find_completion_word(struct gdb_rl_completion_word_info *info, int *qc, int *dp, const char *line_buffer)
Definition: completer.c:231
language_defn
Definition: language.h:132
add_struct_fields
static void add_struct_fields(struct type *type, completion_list &output, char *fieldname, int namelen)
Definition: completer.c:964
gdb_signals.h
complete_explicit_location
static void complete_explicit_location(completion_tracker &tracker, struct event_location *location, const char *text, const language_defn *language, const char *quoted_arg_start, const char *quoted_arg_end)
Definition: completer.c:759
INITIAL_COMPLETION_HTAB_SIZE
#define INITIAL_COMPLETION_HTAB_SIZE
Definition: completer.c:1471
get_max_completions_reached_message
const char * get_max_completions_reached_message(void)
Definition: completer.c:2287
match_list_displayer::height
int height
Definition: completer.h:41
signal_completer
void signal_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition: completer.c:1671
strncmp_iw
int strncmp_iw(const char *string1, const char *string2, size_t string2_len)
Definition: utils.c:2508
complete_source_filenames
completion_list complete_source_filenames(const char *text)
Definition: completer.c:542
TRY
#define TRY
Definition: common-exceptions.h:246
symtab.h
completion_tracker::completion_tracker
completion_tracker()
Definition: completer.c:1475
setlist
struct cmd_list_element * setlist
Definition: cli-cmds.c:111
name
const char *const name
Definition: aarch64-tdep.c:76
completion_result::release_match_list
char ** release_match_list()
Definition: completer.c:2109
completion_tracker::m_entries_hash
htab_t m_entries_hash
Definition: completer.h:442
complete_reggroup_names
Definition: completer.c:1705
gdb_custom_word_point_brkchars
static char gdb_custom_word_point_brkchars[2]
Definition: completer.c:1815
check_typedef
struct type * check_typedef(struct type *type)
Definition: gdbtypes.c:2421
CATCH
#define CATCH(EXCEPTION, MASK)
Definition: common-exceptions.h:254
match_list_displayer::beep
mld_beep_ftype * beep
Definition: completer.h:60
noop_completer
void noop_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *prefix)
Definition: completer.c:143
gdb::unique_xmalloc_ptr
std::unique_ptr< T, xfree_deleter< T > > unique_xmalloc_ptr
Definition: gdb_unique_ptr.h:48
max_completions
int max_completions
Definition: completer.c:1468
match_list_displayer::puts
mld_puts_ftype * puts
Definition: completer.h:50
gdb_rl_attempted_completion_function
char ** gdb_rl_attempted_completion_function(const char *text, int start, int end)
Definition: completer.c:2200
linespec_complete_function
void linespec_complete_function(completion_tracker &tracker, const char *function, symbol_name_match_type func_match_type, const char *source_filename)
Definition: linespec.c:2848
gdb_completer_command_word_break_characters
static const char gdb_completer_command_word_break_characters[]
Definition: completer.c:110
skip_quoted
const char * skip_quoted(const char *str)
Definition: completer.c:2278
completion_tracker::use_custom_word_point
bool use_custom_word_point() const
Definition: completer.h:348
completion_list
std::vector< gdb::unique_xmalloc_ptr< char > > completion_list
Definition: completer.h:69
location_completer_handle_brkchars
static void location_completer_handle_brkchars(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word_ignored)
Definition: completer.c:949
showlist
struct cmd_list_element * showlist
Definition: cli-cmds.c:119
collect_explicit_location_matches
static void collect_explicit_location_matches(completion_tracker &tracker, struct event_location *location, enum explicit_location_match_type what, const char *word, const struct language_defn *language)
Definition: completer.c:612
symbol_name_match_type::EXPRESSION
streq
int streq(const char *lhs, const char *rhs)
Definition: utils.c:2641
expression.h
gdb_assert_not_reached
#define gdb_assert_not_reached(message)
Definition: gdb_assert.h:55
explicit_completion_info::quoted_arg_start
const char * quoted_arg_start
Definition: location.h:254
command_completer
void command_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition: completer.c:1649
make_cleanup
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:116
TYPE_CODE_UNION
Definition: gdbtypes.h:107
expand_preserving_ws
static char * expand_preserving_ws(const char *orig, size_t orig_len, const char *lcd)
Definition: completer.c:1979
reggroup_completer
void reggroup_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition: completer.c:1774
type
Definition: gdbtypes.h:749
explicit_completion_info::last_option
const char * last_option
Definition: location.h:247
completion_result::match_list
char ** match_list
Definition: completer.h:269
language.h
gdb_get_y_or_n
static int gdb_get_y_or_n(int for_pager, const struct match_list_displayer *displayer)
Definition: completer.c:2323
complete_symbol_mode::EXPRESSION
gdb_complete_get_screenwidth
static int gdb_complete_get_screenwidth(const struct match_list_displayer *displayer)
Definition: completer.c:2678
symbol_completer
void symbol_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition: completer.c:1111
completion_tracker::quote_char
int quote_char()
Definition: completer.h:338
get_current_arch
struct gdbarch * get_current_arch(void)
Definition: arch-utils.c:798
completion_match_for_lcd::finish
const char * finish()
Definition: completer.h:154
event_location
Definition: location.c:36
EXTERN_C
#define EXTERN_C
Definition: common-defs.h:87
_rl_qsort_string_compare
EXTERN_C int _rl_qsort_string_compare(const void *, const void *)
gdb_rl_attempted_completion_function_throw
static char ** gdb_rl_attempted_completion_function_throw(const char *text, int start, int end)
Definition: completer.c:2169
gdb_completer_quote_characters
static const char gdb_completer_quote_characters[]
Definition: completer.c:129
linespec.h
CMD_LIST_AMBIGUOUS
#define CMD_LIST_AMBIGUOUS
Definition: command.h:228
_initialize_completer
void _initialize_completer(void)
Definition: completer.c:2867
explicit_location
Definition: location.h:85
skip_to_space
const char * skip_to_space(const char *chp)
Definition: common-utils.c:361
event_location_up
std::unique_ptr< event_location, event_location_deleter > event_location_up
Definition: location.h:140
gdb_signal_to_name
const char * gdb_signal_to_name(enum gdb_signal)
Definition: signals.c:78
gdb_completer_state::aborted
bool aborted
Definition: completer.c:61
completion_tracker::advance_custom_word_point_by
void advance_custom_word_point_by(size_t len)
Definition: completer.c:1946
TYPE_BASECLASS
#define TYPE_BASECLASS(thistype, index)
Definition: gdbtypes.h:1330
gdb_rl_completion_word_info
Definition: completer.c:223
gdb_completer_state
Definition: completer.c:52
completer_ftype
void completer_ftype(struct cmd_list_element *, completion_tracker &tracker, const char *text, const char *word)
Definition: command.h:191
completion_result::completion_suppress_append
bool completion_suppress_append
Definition: completer.h:276
QSFUNC
int QSFUNC(const void *, const void *)
Definition: completer.c:2688
completion_result::number_matches
size_t number_matches
Definition: completer.h:272
xmalloc
void * xmalloc(YYSIZE_T)
TYPE_CODE_STRUCT
Definition: gdbtypes.h:106
get_gdb_completer_quote_characters
const char * get_gdb_completer_quote_characters(void)
Definition: completer.c:134
handle_completions
Definition: completer.c:1168
completion_result::~completion_result
~completion_result()
Definition: completer.c:2087
completion_tracker::maybe_add_completion
bool maybe_add_completion(gdb::unique_xmalloc_ptr< char > name, completion_match_for_lcd *match_for_lcd, const char *text, const char *word)
Definition: completer.c:1512
completion_tracker::m_lowest_common_denominator_unique
bool m_lowest_common_denominator_unique
Definition: completer.h:485
completion_result::sort_match_list
void sort_match_list()
Definition: completer.c:2119
keyword
Definition: m2-exp.c:2540
completion_find_completion_word
const char * completion_find_completion_word(completion_tracker &tracker, const char *text, int *quote_char)
Definition: completer.c:1886
user-regs.h
gdb_assert
#define gdb_assert(expr)
Definition: gdb_assert.h:32
set_gdb_completion_word_break_characters
void set_gdb_completion_word_break_characters(completer_ftype *fn)
Definition: completer.c:1094
completion_tracker::~completion_tracker
~completion_tracker()
Definition: completer.c:1502
completion_tracker::build_completion_result
completion_result build_completion_result(const char *text, int start, int end)
Definition: completer.c:2019
location_completer
void location_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *)
Definition: completer.c:828
completion_tracker::m_entries_vec
completion_list m_entries_vec
Definition: completer.h:434
completion_result::completion_result
completion_result()
Definition: completer.c:2070
explicit_location::function_name
char * function_name
Definition: location.h:91
TYPE_CODE_PTR
Definition: gdbtypes.h:84
filename_completer_handle_brkchars
static void filename_completer_handle_brkchars(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition: completer.c:193
throw_exception
void throw_exception(struct gdb_exception exception)
Definition: common-exceptions.c:312
DEF_ENUM_FLAGS_TYPE
DEF_ENUM_FLAGS_TYPE(enum reg_completer_target, reg_completer_targets)
explicit_location::func_name_match_type
symbol_name_match_type func_name_match_type
Definition: location.h:94
XNEWVEC
#define XNEWVEC(T, N)
Definition: poison.h:145
complete_line_internal_normal_command
static void complete_line_internal_normal_command(completion_tracker &tracker, const char *command, const char *word, const char *cmd_args, complete_line_internal_reason reason, struct cmd_list_element *c)
Definition: completer.c:1179
current_language
const struct language_defn * current_language
Definition: language.c:81
TYPE_TARGET_TYPE
#define TYPE_TARGET_TYPE(thistype)
Definition: gdbtypes.h:1226
MATCH_LINE
Definition: completer.c:83
xsnprintf
int xsnprintf(char *str, size_t size, const char *format,...)
Definition: common-utils.c:134
make_completion_match_str
gdb::unique_xmalloc_ptr< char > make_completion_match_str(const char *match_name, const char *text, const char *word)
Definition: completer.c:1603
TYPE_CODE
#define TYPE_CODE(thistype)
Definition: gdbtypes.h:1238
complete_line_internal
static void complete_line_internal(completion_tracker &tracker, const char *text, const char *line_buffer, int point, complete_line_internal_reason reason)
Definition: completer.c:1449
completion_tracker::set_custom_word_point
void set_custom_word_point(int point)
Definition: completer.h:356
handle_brkchars
Definition: completer.c:1164
explicit_completion_info::quoted_arg_end
const char * quoted_arg_end
Definition: location.h:255
gdb_completer_state::tracker
completion_tracker * tracker
Definition: completer.c:58
expression_completer
void expression_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition: completer.c:1076
_rl_completion_prefix_display_length
int _rl_completion_prefix_display_length
code
int code
Definition: ser-unix.c:239
TYPE_NFIELDS
#define TYPE_NFIELDS(thistype)
Definition: gdbtypes.h:1239
qsort
#define qsort
Definition: ada-exp.c:2694
string_or_empty
static const char * string_or_empty(const char *string)
Definition: completer.c:603
completion_tracker::add_completion
void add_completion(gdb::unique_xmalloc_ptr< char > name, completion_match_for_lcd *match_for_lcd=NULL, const char *text=NULL, const char *word=NULL)
Definition: completer.c:1550
target.h
RL_QF_BACKSLASH
#define RL_QF_BACKSLASH
Definition: completer.c:206
location.h
completion_match_for_lcd
Definition: completer.h:134
match_list_displayer::erase_entire_line
mld_erase_entire_line_ftype * erase_entire_line
Definition: completer.h:57
gdbtypes.h
skip_keyword
static int skip_keyword(completion_tracker &tracker, const char *const *keywords, const char **text_p)
Definition: completer.c:719
_rl_print_completions_horizontally
int _rl_print_completions_horizontally
ignore
static int ignore(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: corelow.c:879
gdb_rl_completion_word_info::basic_quote_characters
const char * basic_quote_characters
Definition: completer.c:227
language
language
Definition: defs.h:203
match_list_displayer::flush
mld_flush_ftype * flush
Definition: completer.h:53
completer_handle_brkchars_ftype
void completer_handle_brkchars_ftype(struct cmd_list_element *, completion_tracker &tracker, const char *text, const char *word)
Definition: command.h:196
explicit_location::source_filename
char * source_filename
Definition: location.h:88
completion_tracker
Definition: completer.h:310
language_defn::la_word_break_characters
const char *(* la_word_break_characters)(void)
Definition: language.h:315
complete_address_and_linespec_locations
static void complete_address_and_linespec_locations(completion_tracker &tracker, const char *text, symbol_name_match_type match_type)
Definition: completer.c:559
cmd_list_element::prefixlist
struct cmd_list_element ** prefixlist
Definition: cli-decode.h:151
match_list_displayer::width
int width
Definition: completer.h:41
reg_or_group_completer
void reg_or_group_completer(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition: completer.c:1762
complete_line_internal_1
static void complete_line_internal_1(completion_tracker &tracker, const char *text, const char *line_buffer, int point, complete_line_internal_reason reason)
Definition: completer.c:1234
explicit_options
static const char *const explicit_options[]
Definition: completer.c:580
string_to_explicit_location
event_location_up string_to_explicit_location(const char **argp, const struct language_defn *language, explicit_completion_info *completion_info)
Definition: location.c:719
explicit_location::label_name
char * label_name
Definition: location.h:97
completion_tracker::m_lowest_common_denominator
char * m_lowest_common_denominator
Definition: completer.h:476
MATCH_QUALIFIED
Definition: completer.c:80
reggroup_next
struct reggroup * reggroup_next(struct gdbarch *gdbarch, struct reggroup *last)
Definition: reggroups.c:133
parse_expression_for_completion
struct type * parse_expression_for_completion(const char *, char **, enum type_code *)
Definition: parse.c:1270
TYPE_FN_FIELDLIST_NAME
#define TYPE_FN_FIELDLIST_NAME(thistype, n)
Definition: gdbtypes.h:1415
type_name_no_tag
const char * type_name_no_tag(const struct type *type)
Definition: gdbtypes.c:1466
complete_files_symbols
static void complete_files_symbols(completion_tracker &tracker, const char *text, const char *word)
Definition: completer.c:407
MATCH_FUNCTION
Definition: completer.c:77
linespec_complete
void linespec_complete(completion_tracker &tracker, const char *text, symbol_name_match_type match_type)
Definition: linespec.c:2999
explicit_location_match_type
explicit_location_match_type
Definition: completer.c:71
probe_options
static const char *const probe_options[]
Definition: completer.c:592
command_completer_handle_brkchars
static void command_completer_handle_brkchars(struct cmd_list_element *ignore, completion_tracker &tracker, const char *text, const char *word)
Definition: completer.c:1660
cmd_list_element::completer
completer_ftype * completer
Definition: cli-decode.h:164
gdb_display_match_list
void gdb_display_match_list(char **matches, int len, int max, const struct match_list_displayer *displayer)
Definition: completer.c:2819
gdb_display_match_list_1
static int gdb_display_match_list_1(char **matches, int len, int max, const struct match_list_displayer *displayer)
Definition: completer.c:2695
xcalloc
PTR xcalloc(size_t number, size_t size)
Definition: common-utils.c:72
gdb_rl_completion_word_info::word_break_characters
const char * word_break_characters
Definition: completer.c:225
gdbcmd.h
gdb_fnprint
static int gdb_fnprint(const char *to_print, int prefix_bytes, const struct match_list_displayer *displayer)
Definition: completer.c:2491
add_setshow_zuinteger_unlimited_cmd
void add_setshow_zuinteger_unlimited_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_const_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:765
completion_tracker::set_use_custom_word_point
void set_use_custom_word_point(bool enable)
Definition: completer.h:344
symbol_name_match_type::WILD
throw_error
void throw_error(enum errors error, const char *fmt,...)
Definition: common-exceptions.c:389
explicit_completion_info
Definition: location.h:243
explicit_completion_info::saw_explicit_location_option
bool saw_explicit_location_option
Definition: location.h:260
reggroup_name
const char * reggroup_name(struct reggroup *group)
Definition: reggroups.c:66
do_cleanups
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:174
get_explicit_location
struct explicit_location * get_explicit_location(struct event_location *location)
Definition: location.c:213
complete_register_names
Definition: completer.c:1704
symbol_name_match_type
symbol_name_match_type
Definition: symtab.h:52
CTRL_CHAR
#define CTRL_CHAR(c)
Definition: tui-io.c:69
completion_tracker::recompute_lowest_common_denominator
void recompute_lowest_common_denominator(gdb::unique_xmalloc_ptr< char > &&new_match)
Definition: completer.c:1913