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