1/* Line completion stuff for GDB, the GNU debugger. 2 Copyright (C) 2000, 2001, 2007 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 26#include "cli/cli-decode.h" 27 28/* FIXME: This is needed because of lookup_cmd_1 (). We should be 29 calling a hook instead so we eliminate the CLI dependency. */ 30#include "gdbcmd.h" 31 32/* Needed for rl_completer_word_break_characters() and for 33 rl_filename_completion_function. */ 34#include "readline/readline.h" 35 36/* readline defines this. */ 37#undef savestring 38 39#include "completer.h" 40 41/* Prototypes for local functions. */ 42static 43char *line_completion_function (const char *text, int matches, 44 char *line_buffer, 45 int point); 46 47/* readline uses the word breaks for two things: 48 (1) In figuring out where to point the TEXT parameter to the 49 rl_completion_entry_function. Since we don't use TEXT for much, 50 it doesn't matter a lot what the word breaks are for this purpose, but 51 it does affect how much stuff M-? lists. 52 (2) If one of the matches contains a word break character, readline 53 will quote it. That's why we switch between 54 current_language->la_word_break_characters() and 55 gdb_completer_command_word_break_characters. I'm not sure when 56 we need this behavior (perhaps for funky characters in C++ symbols?). */ 57 58/* Variables which are necessary for fancy command line editing. */ 59 60/* When completing on command names, we remove '-' from the list of 61 word break characters, since we use it in command names. If the 62 readline library sees one in any of the current completion strings, 63 it thinks that the string needs to be quoted and automatically supplies 64 a leading quote. */ 65static char *gdb_completer_command_word_break_characters = 66" \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,"; 67 68/* When completing on file names, we remove from the list of word 69 break characters any characters that are commonly used in file 70 names, such as '-', '+', '~', etc. Otherwise, readline displays 71 incorrect completion candidates. */ 72#ifdef HAVE_DOS_BASED_FILE_SYSTEM 73/* MS-DOS and MS-Windows use colon as part of the drive spec, and most 74 programs support @foo style response files. */ 75static char *gdb_completer_file_name_break_characters = " \t\n*|\"';?><@"; 76#else 77static char *gdb_completer_file_name_break_characters = " \t\n*|\"';:?><"; 78#endif 79 80/* These are used when completing on locations, which can mix file 81 names and symbol names separated by a colon. */ 82static char *gdb_completer_loc_break_characters = " \t\n*|\"';:?><,"; 83 84/* Characters that can be used to quote completion strings. Note that we 85 can't include '"' because the gdb C parser treats such quoted sequences 86 as strings. */ 87static char *gdb_completer_quote_characters = "'"; 88 89/* Accessor for some completer data that may interest other files. */ 90 91char * 92get_gdb_completer_quote_characters (void) 93{ 94 return gdb_completer_quote_characters; 95} 96 97/* Line completion interface function for readline. */ 98 99char * 100readline_line_completion_function (const char *text, int matches) 101{ 102 return line_completion_function (text, matches, rl_line_buffer, rl_point); 103} 104 105/* This can be used for functions which don't want to complete on symbols 106 but don't want to complete on anything else either. */ 107char ** 108noop_completer (char *text, char *prefix) 109{ 110 return NULL; 111} 112 113/* Complete on filenames. */ 114char ** 115filename_completer (char *text, char *word) 116{ 117 int subsequent_name; 118 char **return_val; 119 int return_val_used; 120 int return_val_alloced; 121 122 return_val_used = 0; 123 /* Small for testing. */ 124 return_val_alloced = 1; 125 return_val = (char **) xmalloc (return_val_alloced * sizeof (char *)); 126 127 subsequent_name = 0; 128 while (1) 129 { 130 char *p, *q; 131 p = rl_filename_completion_function (text, subsequent_name); 132 if (return_val_used >= return_val_alloced) 133 { 134 return_val_alloced *= 2; 135 return_val = 136 (char **) xrealloc (return_val, 137 return_val_alloced * sizeof (char *)); 138 } 139 if (p == NULL) 140 { 141 return_val[return_val_used++] = p; 142 break; 143 } 144 /* We need to set subsequent_name to a non-zero value before the 145 continue line below, because otherwise, if the first file seen 146 by GDB is a backup file whose name ends in a `~', we will loop 147 indefinitely. */ 148 subsequent_name = 1; 149 /* Like emacs, don't complete on old versions. Especially useful 150 in the "source" command. */ 151 if (p[strlen (p) - 1] == '~') 152 { 153 xfree (p); 154 continue; 155 } 156 157 if (word == text) 158 /* Return exactly p. */ 159 return_val[return_val_used++] = p; 160 else if (word > text) 161 { 162 /* Return some portion of p. */ 163 q = xmalloc (strlen (p) + 5); 164 strcpy (q, p + (word - text)); 165 return_val[return_val_used++] = q; 166 xfree (p); 167 } 168 else 169 { 170 /* Return some of TEXT plus p. */ 171 q = xmalloc (strlen (p) + (text - word) + 5); 172 strncpy (q, word, text - word); 173 q[text - word] = '\0'; 174 strcat (q, p); 175 return_val[return_val_used++] = q; 176 xfree (p); 177 } 178 } 179#if 0 180 /* There is no way to do this just long enough to affect quote inserting 181 without also affecting the next completion. This should be fixed in 182 readline. FIXME. */ 183 /* Ensure that readline does the right thing 184 with respect to inserting quotes. */ 185 rl_completer_word_break_characters = ""; 186#endif 187 return return_val; 188} 189 190/* Complete on locations, which might be of two possible forms: 191 192 file:line 193 or 194 symbol+offset 195 196 This is intended to be used in commands that set breakpoints etc. */ 197char ** 198location_completer (char *text, char *word) 199{ 200 int n_syms = 0, n_files = 0; 201 char ** fn_list = NULL; 202 char ** list = NULL; 203 char *p; 204 int quote_found = 0; 205 int quoted = *text == '\'' || *text == '"'; 206 int quote_char = '\0'; 207 char *colon = NULL; 208 char *file_to_match = NULL; 209 char *symbol_start = text; 210 char *orig_text = text; 211 size_t text_len; 212 213 /* Do we have an unquoted colon, as in "break foo.c::bar"? */ 214 for (p = text; *p != '\0'; ++p) 215 { 216 if (*p == '\\' && p[1] == '\'') 217 p++; 218 else if (*p == '\'' || *p == '"') 219 { 220 quote_found = *p; 221 quote_char = *p++; 222 while (*p != '\0' && *p != quote_found) 223 { 224 if (*p == '\\' && p[1] == quote_found) 225 p++; 226 p++; 227 } 228 229 if (*p == quote_found) 230 quote_found = 0; 231 else 232 break; /* Hit the end of text. */ 233 } 234#if HAVE_DOS_BASED_FILE_SYSTEM 235 /* If we have a DOS-style absolute file name at the beginning of 236 TEXT, and the colon after the drive letter is the only colon 237 we found, pretend the colon is not there. */ 238 else if (p < text + 3 && *p == ':' && p == text + 1 + quoted) 239 ; 240#endif 241 else if (*p == ':' && !colon) 242 { 243 colon = p; 244 symbol_start = p + 1; 245 } 246 else if (strchr (current_language->la_word_break_characters(), *p)) 247 symbol_start = p + 1; 248 } 249 250 if (quoted) 251 text++; 252 text_len = strlen (text); 253 254 /* Where is the file name? */ 255 if (colon) 256 { 257 char *s; 258 259 file_to_match = (char *) xmalloc (colon - text + 1); 260 strncpy (file_to_match, text, colon - text + 1); 261 /* Remove trailing colons and quotes from the file name. */ 262 for (s = file_to_match + (colon - text); 263 s > file_to_match; 264 s--) 265 if (*s == ':' || *s == quote_char) 266 *s = '\0'; 267 } 268 /* If the text includes a colon, they want completion only on a 269 symbol name after the colon. Otherwise, we need to complete on 270 symbols as well as on files. */ 271 if (colon) 272 { 273 list = make_file_symbol_completion_list (symbol_start, word, 274 file_to_match); 275 xfree (file_to_match); 276 } 277 else 278 { 279 list = make_symbol_completion_list (symbol_start, word); 280 /* If text includes characters which cannot appear in a file 281 name, they cannot be asking for completion on files. */ 282 if (strcspn (text, 283 gdb_completer_file_name_break_characters) == text_len) 284 fn_list = make_source_files_completion_list (text, text); 285 } 286 287 /* How many completions do we have in both lists? */ 288 if (fn_list) 289 for ( ; fn_list[n_files]; n_files++) 290 ; 291 if (list) 292 for ( ; list[n_syms]; n_syms++) 293 ; 294 295 /* Make list[] large enough to hold both lists, then catenate 296 fn_list[] onto the end of list[]. */ 297 if (n_syms && n_files) 298 { 299 list = xrealloc (list, (n_syms + n_files + 1) * sizeof (char *)); 300 memcpy (list + n_syms, fn_list, (n_files + 1) * sizeof (char *)); 301 xfree (fn_list); 302 } 303 else if (n_files) 304 { 305 /* If we only have file names as possible completion, we should 306 bring them in sync with what rl_complete expects. The 307 problem is that if the user types "break /foo/b TAB", and the 308 possible completions are "/foo/bar" and "/foo/baz" 309 rl_complete expects us to return "bar" and "baz", without the 310 leading directories, as possible completions, because `word' 311 starts at the "b". But we ignore the value of `word' when we 312 call make_source_files_completion_list above (because that 313 would not DTRT when the completion results in both symbols 314 and file names), so make_source_files_completion_list returns 315 the full "/foo/bar" and "/foo/baz" strings. This produces 316 wrong results when, e.g., there's only one possible 317 completion, because rl_complete will prepend "/foo/" to each 318 candidate completion. The loop below removes that leading 319 part. */ 320 for (n_files = 0; fn_list[n_files]; n_files++) 321 { 322 memmove (fn_list[n_files], fn_list[n_files] + (word - text), 323 strlen (fn_list[n_files]) + 1 - (word - text)); 324 } 325 /* Return just the file-name list as the result. */ 326 list = fn_list; 327 } 328 else if (!n_syms) 329 { 330 /* No completions at all. As the final resort, try completing 331 on the entire text as a symbol. */ 332 list = make_symbol_completion_list (orig_text, word); 333 xfree (fn_list); 334 } 335 else 336 xfree (fn_list); 337 338 return list; 339} 340 341/* Complete on command names. Used by "help". */ 342char ** 343command_completer (char *text, char *word) 344{ 345 return complete_on_cmdlist (cmdlist, text, word); 346} 347 348 349/* Here are some useful test cases for completion. FIXME: These should 350 be put in the test suite. They should be tested with both M-? and TAB. 351 352 "show output-" "radix" 353 "show output" "-radix" 354 "p" ambiguous (commands starting with p--path, print, printf, etc.) 355 "p " ambiguous (all symbols) 356 "info t foo" no completions 357 "info t " no completions 358 "info t" ambiguous ("info target", "info terminal", etc.) 359 "info ajksdlfk" no completions 360 "info ajksdlfk " no completions 361 "info" " " 362 "info " ambiguous (all info commands) 363 "p \"a" no completions (string constant) 364 "p 'a" ambiguous (all symbols starting with a) 365 "p b-a" ambiguous (all symbols starting with a) 366 "p b-" ambiguous (all symbols) 367 "file Make" "file" (word break hard to screw up here) 368 "file ../gdb.stabs/we" "ird" (needs to not break word at slash) 369 */ 370 371/* Generate completions all at once. Returns a NULL-terminated array 372 of strings. Both the array and each element are allocated with 373 xmalloc. It can also return NULL if there are no completions. 374 375 TEXT is the caller's idea of the "word" we are looking at. 376 377 LINE_BUFFER is available to be looked at; it contains the entire text 378 of the line. POINT is the offset in that line of the cursor. You 379 should pretend that the line ends at POINT. */ 380 381char ** 382complete_line (const char *text, char *line_buffer, int point) 383{ 384 char **list = NULL; 385 char *tmp_command, *p; 386 /* Pointer within tmp_command which corresponds to text. */ 387 char *word; 388 struct cmd_list_element *c, *result_list; 389 390 /* Choose the default set of word break characters to break completions. 391 If we later find out that we are doing completions on command strings 392 (as opposed to strings supplied by the individual command completer 393 functions, which can be any string) then we will switch to the 394 special word break set for command strings, which leaves out the 395 '-' character used in some commands. */ 396 397 rl_completer_word_break_characters = 398 current_language->la_word_break_characters(); 399 400 /* Decide whether to complete on a list of gdb commands or on symbols. */ 401 tmp_command = (char *) alloca (point + 1); 402 p = tmp_command; 403 404 strncpy (tmp_command, line_buffer, point); 405 tmp_command[point] = '\0'; 406 /* Since text always contains some number of characters leading up 407 to point, we can find the equivalent position in tmp_command 408 by subtracting that many characters from the end of tmp_command. */ 409 word = tmp_command + point - strlen (text); 410 411 if (point == 0) 412 { 413 /* An empty line we want to consider ambiguous; that is, it 414 could be any command. */ 415 c = (struct cmd_list_element *) -1; 416 result_list = 0; 417 } 418 else 419 { 420 c = lookup_cmd_1 (&p, cmdlist, &result_list, 1); 421 } 422 423 /* Move p up to the next interesting thing. */ 424 while (*p == ' ' || *p == '\t') 425 { 426 p++; 427 } 428 429 if (!c) 430 { 431 /* It is an unrecognized command. So there are no 432 possible completions. */ 433 list = NULL; 434 } 435 else if (c == (struct cmd_list_element *) -1) 436 { 437 char *q; 438 439 /* lookup_cmd_1 advances p up to the first ambiguous thing, but 440 doesn't advance over that thing itself. Do so now. */ 441 q = p; 442 while (*q && (isalnum (*q) || *q == '-' || *q == '_')) 443 ++q; 444 if (q != tmp_command + point) 445 { 446 /* There is something beyond the ambiguous 447 command, so there are no possible completions. For 448 example, "info t " or "info t foo" does not complete 449 to anything, because "info t" can be "info target" or 450 "info terminal". */ 451 list = NULL; 452 } 453 else 454 { 455 /* We're trying to complete on the command which was ambiguous. 456 This we can deal with. */ 457 if (result_list) 458 { 459 list = complete_on_cmdlist (*result_list->prefixlist, p, 460 word); 461 } 462 else 463 { 464 list = complete_on_cmdlist (cmdlist, p, word); 465 } 466 /* Ensure that readline does the right thing with respect to 467 inserting quotes. */ 468 rl_completer_word_break_characters = 469 gdb_completer_command_word_break_characters; 470 } 471 } 472 else 473 { 474 /* We've recognized a full command. */ 475 476 if (p == tmp_command + point) 477 { 478 /* There is no non-whitespace in the line beyond the command. */ 479 480 if (p[-1] == ' ' || p[-1] == '\t') 481 { 482 /* The command is followed by whitespace; we need to complete 483 on whatever comes after command. */ 484 if (c->prefixlist) 485 { 486 /* It is a prefix command; what comes after it is 487 a subcommand (e.g. "info "). */ 488 list = complete_on_cmdlist (*c->prefixlist, p, word); 489 490 /* Ensure that readline does the right thing 491 with respect to inserting quotes. */ 492 rl_completer_word_break_characters = 493 gdb_completer_command_word_break_characters; 494 } 495 else if (c->enums) 496 { 497 list = complete_on_enum (c->enums, p, word); 498 rl_completer_word_break_characters = 499 gdb_completer_command_word_break_characters; 500 } 501 else 502 { 503 /* It is a normal command; what comes after it is 504 completed by the command's completer function. */ 505 if (c->completer == filename_completer) 506 { 507 /* Many commands which want to complete on 508 file names accept several file names, as 509 in "run foo bar >>baz". So we don't want 510 to complete the entire text after the 511 command, just the last word. To this 512 end, we need to find the beginning of the 513 file name by starting at `word' and going 514 backwards. */ 515 for (p = word; 516 p > tmp_command 517 && strchr (gdb_completer_file_name_break_characters, p[-1]) == NULL; 518 p--) 519 ; 520 rl_completer_word_break_characters = 521 gdb_completer_file_name_break_characters; 522 } 523 else if (c->completer == location_completer) 524 { 525 /* Commands which complete on locations want to 526 see the entire argument. */ 527 for (p = word; 528 p > tmp_command 529 && p[-1] != ' ' && p[-1] != '\t'; 530 p--) 531 ; 532 } 533 list = (*c->completer) (p, word); 534 } 535 } 536 else 537 { 538 /* The command is not followed by whitespace; we need to 539 complete on the command itself. e.g. "p" which is a 540 command itself but also can complete to "print", "ptype" 541 etc. */ 542 char *q; 543 544 /* Find the command we are completing on. */ 545 q = p; 546 while (q > tmp_command) 547 { 548 if (isalnum (q[-1]) || q[-1] == '-' || q[-1] == '_') 549 --q; 550 else 551 break; 552 } 553 554 list = complete_on_cmdlist (result_list, q, word); 555 556 /* Ensure that readline does the right thing 557 with respect to inserting quotes. */ 558 rl_completer_word_break_characters = 559 gdb_completer_command_word_break_characters; 560 } 561 } 562 else 563 { 564 /* There is non-whitespace beyond the command. */ 565 566 if (c->prefixlist && !c->allow_unknown) 567 { 568 /* It is an unrecognized subcommand of a prefix command, 569 e.g. "info adsfkdj". */ 570 list = NULL; 571 } 572 else if (c->enums) 573 { 574 list = complete_on_enum (c->enums, p, word); 575 } 576 else 577 { 578 /* It is a normal command. */ 579 if (c->completer == filename_completer) 580 { 581 /* See the commentary above about the specifics 582 of file-name completion. */ 583 for (p = word; 584 p > tmp_command 585 && strchr (gdb_completer_file_name_break_characters, p[-1]) == NULL; 586 p--) 587 ; 588 rl_completer_word_break_characters = 589 gdb_completer_file_name_break_characters; 590 } 591 else if (c->completer == location_completer) 592 { 593 for (p = word; 594 p > tmp_command 595 && p[-1] != ' ' && p[-1] != '\t'; 596 p--) 597 ; 598 } 599 list = (*c->completer) (p, word); 600 } 601 } 602 } 603 604 return list; 605} 606 607/* Generate completions one by one for the completer. Each time we are 608 called return another potential completion to the caller. 609 line_completion just completes on commands or passes the buck to the 610 command's completer function, the stuff specific to symbol completion 611 is in make_symbol_completion_list. 612 613 TEXT is the caller's idea of the "word" we are looking at. 614 615 MATCHES is the number of matches that have currently been collected from 616 calling this completion function. When zero, then we need to initialize, 617 otherwise the initialization has already taken place and we can just 618 return the next potential completion string. 619 620 LINE_BUFFER is available to be looked at; it contains the entire text 621 of the line. POINT is the offset in that line of the cursor. You 622 should pretend that the line ends at POINT. 623 624 Returns NULL if there are no more completions, else a pointer to a string 625 which is a possible completion, it is the caller's responsibility to 626 free the string. */ 627 628static char * 629line_completion_function (const char *text, int matches, 630 char *line_buffer, int point) 631{ 632 static char **list = (char **) NULL; /* Cache of completions. */ 633 static int index; /* Next cached completion. */ 634 char *output = NULL; 635 636 if (matches == 0) 637 { 638 /* The caller is beginning to accumulate a new set of completions, so 639 we need to find all of them now, and cache them for returning one at 640 a time on future calls. */ 641 642 if (list) 643 { 644 /* Free the storage used by LIST, but not by the strings inside. 645 This is because rl_complete_internal () frees the strings. */ 646 xfree (list); 647 } 648 index = 0; 649 list = complete_line (text, line_buffer, point); 650 } 651 652 /* If we found a list of potential completions during initialization then 653 dole them out one at a time. The vector of completions is NULL 654 terminated, so after returning the last one, return NULL (and continue 655 to do so) each time we are called after that, until a new list is 656 available. */ 657 658 if (list) 659 { 660 output = list[index]; 661 if (output) 662 { 663 index++; 664 } 665 } 666 667#if 0 668 /* Can't do this because readline hasn't yet checked the word breaks 669 for figuring out whether to insert a quote. */ 670 if (output == NULL) 671 /* Make sure the word break characters are set back to normal for the 672 next time that readline tries to complete something. */ 673 rl_completer_word_break_characters = 674 current_language->la_word_break_characters(); 675#endif 676 677 return (output); 678} 679 680/* Skip over the possibly quoted word STR (as defined by the quote 681 characters QUOTECHARS and the the word break characters 682 BREAKCHARS). Returns pointer to the location after the "word". If 683 either QUOTECHARS or BREAKCHARS is NULL, use the same values used 684 by the completer. */ 685 686char * 687skip_quoted_chars (char *str, char *quotechars, char *breakchars) 688{ 689 char quote_char = '\0'; 690 char *scan; 691 692 if (quotechars == NULL) 693 quotechars = gdb_completer_quote_characters; 694 695 if (breakchars == NULL) 696 breakchars = current_language->la_word_break_characters(); 697 698 for (scan = str; *scan != '\0'; scan++) 699 { 700 if (quote_char != '\0') 701 { 702 /* Ignore everything until the matching close quote char. */ 703 if (*scan == quote_char) 704 { 705 /* Found matching close quote. */ 706 scan++; 707 break; 708 } 709 } 710 else if (strchr (quotechars, *scan)) 711 { 712 /* Found start of a quoted string. */ 713 quote_char = *scan; 714 } 715 else if (strchr (breakchars, *scan)) 716 { 717 break; 718 } 719 } 720 721 return (scan); 722} 723 724/* Skip over the possibly quoted word STR (as defined by the quote 725 characters and word break characters used by the completer). 726 Returns pointer to the location after the "word". */ 727 728char * 729skip_quoted (char *str) 730{ 731 return skip_quoted_chars (str, NULL, NULL); 732} 733