gdb/completer.c

   1 /* Line completion stuff for GDB, the GNU debugger.
   2    Copyright (C) 2000-2015 Free Software Foundation, Inc.
   3
   4    This file is part of GDB.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 #include "defs.h"
  20 #include "symtab.h"
  21 #include "gdbtypes.h"
  22 #include "expression.h"
  23 #include "filenames.h"          /* For DOSish file names.  */
  24 #include "language.h"
  25 #include "gdb_signals.h"
  26 #include "target.h"
  27 #include "reggroups.h"
  28 #include "user-regs.h"
  29
  30 #include "cli/cli-decode.h"
  31
  32 /* FIXME: This is needed because of lookup_cmd_1 ().  We should be
  33    calling a hook instead so we eliminate the CLI dependency.  */
  34 #include "gdbcmd.h"
  35
  36 /* Needed for rl_completer_word_break_characters() and for
  37    rl_filename_completion_function.  */
  38 #include "readline/readline.h"
  39
  40 /* readline defines this.  */
  41 #undef savestring
  42
  43 #include "completer.h"
  44
  45 /* Prototypes for local functions.  */
  46 static
  47 char *line_completion_function (const char *text, int matches,
  48                                 char *line_buffer,
  49                                 int point);
  50
  51 /* readline uses the word breaks for two things:
  52    (1) In figuring out where to point the TEXT parameter to the
  53    rl_completion_entry_function.  Since we don't use TEXT for much,
  54    it doesn't matter a lot what the word breaks are for this purpose,
  55    but it does affect how much stuff M-? lists.
  56    (2) If one of the matches contains a word break character, readline
  57    will quote it.  That's why we switch between
  58    current_language->la_word_break_characters() and
  59    gdb_completer_command_word_break_characters.  I'm not sure when
  60    we need this behavior (perhaps for funky characters in C++
  61    symbols?).  */
  62
  63 /* Variables which are necessary for fancy command line editing.  */
  64
  65 /* When completing on command names, we remove '-' from the list of
  66    word break characters, since we use it in command names.  If the
  67    readline library sees one in any of the current completion strings,
  68    it thinks that the string needs to be quoted and automatically
  69    supplies a leading quote.  */
  70 static char *gdb_completer_command_word_break_characters =
  71 " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,";
  72
  73 /* When completing on file names, we remove from the list of word
  74    break characters any characters that are commonly used in file
  75    names, such as '-', '+', '~', etc.  Otherwise, readline displays
  76    incorrect completion candidates.  */
  77 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
  78 /* MS-DOS and MS-Windows use colon as part of the drive spec, and most
  79    programs support @foo style response files.  */
  80 static char *gdb_completer_file_name_break_characters = " \t\n*|\"';?><@";
  81 #else
  82 static char *gdb_completer_file_name_break_characters = " \t\n*|\"';:?><";
  83 #endif
  84
  85 /* Characters that can be used to quote completion strings.  Note that
  86    we can't include '"' because the gdb C parser treats such quoted
  87    sequences as strings.  */
  88 static char *gdb_completer_quote_characters = "'";
  89 \f
  90 /* Accessor for some completer data that may interest other files.  */
  91
  92 char *
  93 get_gdb_completer_quote_characters (void)
  94 {
  95   return gdb_completer_quote_characters;
  96 }
  97
  98 /* Line completion interface function for readline.  */
  99
 100 char *
 101 readline_line_completion_function (const char *text, int matches)
 102 {
 103   return line_completion_function (text, matches,
 104                                    rl_line_buffer, rl_point);
 105 }
 106
 107 /* This can be used for functions which don't want to complete on
 108    symbols but don't want to complete on anything else either.  */
 109 VEC (char_ptr) *
 110 noop_completer (struct cmd_list_element *ignore,
 111                 const char *text, const char *prefix)
 112 {
 113   return NULL;
 114 }
 115
 116 /* Complete on filenames.  */
 117 VEC (char_ptr) *
 118 filename_completer (struct cmd_list_element *ignore,
 119                     const char *text, const char *word)
 120 {
 121   int subsequent_name;
 122   VEC (char_ptr) *return_val = NULL;
 123
 124   subsequent_name = 0;
 125   while (1)
 126     {
 127       char *p, *q;
 128
 129       p = rl_filename_completion_function (text, subsequent_name);
 130       if (p == NULL)
 131         break;
 132       /* We need to set subsequent_name to a non-zero value before the
 133          continue line below, because otherwise, if the first file
 134          seen by GDB is a backup file whose name ends in a `~', we
 135          will loop indefinitely.  */
 136       subsequent_name = 1;
 137       /* Like emacs, don't complete on old versions.  Especially
 138          useful in the "source" command.  */
 139       if (p[strlen (p) - 1] == '~')
 140         {
 141           xfree (p);
 142           continue;
 143         }
 144
 145       if (word == text)
 146         /* Return exactly p.  */
 147         q = p;
 148       else if (word > text)
 149         {
 150           /* Return some portion of p.  */
 151           q = xmalloc (strlen (p) + 5);
 152           strcpy (q, p + (word - text));
 153           xfree (p);
 154         }
 155       else
 156         {
 157           /* Return some of TEXT plus p.  */
 158           q = xmalloc (strlen (p) + (text - word) + 5);
 159           strncpy (q, word, text - word);
 160           q[text - word] = '\0';
 161           strcat (q, p);
 162           xfree (p);
 163         }
 164       VEC_safe_push (char_ptr, return_val, q);
 165     }
 166 #if 0
 167   /* There is no way to do this just long enough to affect quote
 168      inserting without also affecting the next completion.  This
 169      should be fixed in readline.  FIXME.  */
 170   /* Ensure that readline does the right thing
 171      with respect to inserting quotes.  */
 172   rl_completer_word_break_characters = "";
 173 #endif
 174   return return_val;
 175 }
 176
 177 /* Complete on locations, which might be of two possible forms:
 178
 179        file:line
 180    or
 181        symbol+offset
 182
 183    This is intended to be used in commands that set breakpoints
 184    etc.  */
 185
 186 VEC (char_ptr) *
 187 location_completer (struct cmd_list_element *ignore,
 188                     const char *text, const char *word)
 189 {
 190   int n_syms, n_files, ix;
 191   VEC (char_ptr) *fn_list = NULL;
 192   VEC (char_ptr) *list = NULL;
 193   const char *p;
 194   int quote_found = 0;
 195   int quoted = *text == '\'' || *text == '"';
 196   int quote_char = '\0';
 197   const char *colon = NULL;
 198   char *file_to_match = NULL;
 199   const char *symbol_start = text;
 200   const char *orig_text = text;
 201   size_t text_len;
 202
 203   /* Do we have an unquoted colon, as in "break foo.c:bar"?  */
 204   for (p = text; *p != '\0'; ++p)
 205     {
 206       if (*p == '\\' && p[1] == '\'')
 207         p++;
 208       else if (*p == '\'' || *p == '"')
 209         {
 210           quote_found = *p;
 211           quote_char = *p++;
 212           while (*p != '\0' && *p != quote_found)
 213             {
 214               if (*p == '\\' && p[1] == quote_found)
 215                 p++;
 216               p++;
 217             }
 218
 219           if (*p == quote_found)
 220             quote_found = 0;
 221           else
 222             break;              /* Hit the end of text.  */
 223         }
 224 #if HAVE_DOS_BASED_FILE_SYSTEM
 225       /* If we have a DOS-style absolute file name at the beginning of
 226          TEXT, and the colon after the drive letter is the only colon
 227          we found, pretend the colon is not there.  */
 228       else if (p < text + 3 && *p == ':' && p == text + 1 + quoted)
 229         ;
 230 #endif
 231       else if (*p == ':' && !colon)
 232         {
 233           colon = p;
 234           symbol_start = p + 1;
 235         }
 236       else if (strchr (current_language->la_word_break_characters(), *p))
 237         symbol_start = p + 1;
 238     }
 239
 240   if (quoted)
 241     text++;
 242   text_len = strlen (text);
 243
 244   /* Where is the file name?  */
 245   if (colon)
 246     {
 247       char *s;
 248
 249       file_to_match = (char *) xmalloc (colon - text + 1);
 250       strncpy (file_to_match, text, colon - text + 1);
 251       /* Remove trailing colons and quotes from the file name.  */
 252       for (s = file_to_match + (colon - text);
 253            s > file_to_match;
 254            s--)
 255         if (*s == ':' || *s == quote_char)
 256           *s = '\0';
 257     }
 258   /* If the text includes a colon, they want completion only on a
 259      symbol name after the colon.  Otherwise, we need to complete on
 260      symbols as well as on files.  */
 261   if (colon)
 262     {
 263       list = make_file_symbol_completion_list (symbol_start, word,
 264                                                file_to_match);
 265       xfree (file_to_match);
 266     }
 267   else
 268     {
 269       list = make_symbol_completion_list (symbol_start, word);
 270       /* If text includes characters which cannot appear in a file
 271          name, they cannot be asking for completion on files.  */
 272       if (strcspn (text,
 273                    gdb_completer_file_name_break_characters) == text_len)
 274         fn_list = make_source_files_completion_list (text, text);
 275     }
 276
 277   n_syms = VEC_length (char_ptr, list);
 278   n_files = VEC_length (char_ptr, fn_list);
 279
 280   /* Catenate fn_list[] onto the end of list[].  */
 281   if (!n_syms)
 282     {
 283       VEC_free (char_ptr, list); /* Paranoia.  */
 284       list = fn_list;
 285       fn_list = NULL;
 286     }
 287   else
 288     {
 289       char *fn;
 290
 291       for (ix = 0; VEC_iterate (char_ptr, fn_list, ix, fn); ++ix)
 292         VEC_safe_push (char_ptr, list, fn);
 293       VEC_free (char_ptr, fn_list);
 294     }
 295
 296   if (n_syms && n_files)
 297     {
 298       /* Nothing.  */
 299     }
 300   else if (n_files)
 301     {
 302       char *fn;
 303
 304       /* If we only have file names as possible completion, we should
 305          bring them in sync with what rl_complete expects.  The
 306          problem is that if the user types "break /foo/b TAB", and the
 307          possible completions are "/foo/bar" and "/foo/baz"
 308          rl_complete expects us to return "bar" and "baz", without the
 309          leading directories, as possible completions, because `word'
 310          starts at the "b".  But we ignore the value of `word' when we
 311          call make_source_files_completion_list above (because that
 312          would not DTRT when the completion results in both symbols
 313          and file names), so make_source_files_completion_list returns
 314          the full "/foo/bar" and "/foo/baz" strings.  This produces
 315          wrong results when, e.g., there's only one possible
 316          completion, because rl_complete will prepend "/foo/" to each
 317          candidate completion.  The loop below removes that leading
 318          part.  */
 319       for (ix = 0; VEC_iterate (char_ptr, list, ix, fn); ++ix)
 320         {
 321           memmove (fn, fn + (word - text),
 322                    strlen (fn) + 1 - (word - text));
 323         }
 324     }
 325   else if (!n_syms)
 326     {
 327       /* No completions at all.  As the final resort, try completing
 328          on the entire text as a symbol.  */
 329       list = make_symbol_completion_list (orig_text, word);
 330     }
 331
 332   return list;
 333 }
 334
 335 /* Helper for expression_completer which recursively adds field and
 336    method names from TYPE, a struct or union type, to the array
 337    OUTPUT.  */
 338 static void
 339 add_struct_fields (struct type *type, VEC (char_ptr) **output,
 340                    char *fieldname, int namelen)
 341 {
 342   int i;
 343   int computed_type_name = 0;
 344   const char *type_name = NULL;
 345
 346   CHECK_TYPEDEF (type);
 347   for (i = 0; i < TYPE_NFIELDS (type); ++i)
 348     {
 349       if (i < TYPE_N_BASECLASSES (type))
 350         add_struct_fields (TYPE_BASECLASS (type, i),
 351                            output, fieldname, namelen);
 352       else if (TYPE_FIELD_NAME (type, i))
 353         {
 354           if (TYPE_FIELD_NAME (type, i)[0] != '\0')
 355             {
 356               if (! strncmp (TYPE_FIELD_NAME (type, i),
 357                              fieldname, namelen))
 358                 VEC_safe_push (char_ptr, *output,
 359                                xstrdup (TYPE_FIELD_NAME (type, i)));
 360             }
 361           else if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_UNION)
 362             {
 363               /* Recurse into anonymous unions.  */
 364               add_struct_fields (TYPE_FIELD_TYPE (type, i),
 365                                  output, fieldname, namelen);
 366             }
 367         }
 368     }
 369
 370   for (i = TYPE_NFN_FIELDS (type) - 1; i >= 0; --i)
 371     {
 372       const char *name = TYPE_FN_FIELDLIST_NAME (type, i);
 373
 374       if (name && ! strncmp (name, fieldname, namelen))
 375         {
 376           if (!computed_type_name)
 377             {
 378               type_name = type_name_no_tag (type);
 379               computed_type_name = 1;
 380             }
 381           /* Omit constructors from the completion list.  */
 382           if (!type_name || strcmp (type_name, name))
 383             VEC_safe_push (char_ptr, *output, xstrdup (name));
 384         }
 385     }
 386 }
 387
 388 /* Complete on expressions.  Often this means completing on symbol
 389    names, but some language parsers also have support for completing
 390    field names.  */
 391 VEC (char_ptr) *
 392 expression_completer (struct cmd_list_element *ignore,
 393                       const char *text, const char *word)
 394 {
 395   struct type *type = NULL;
 396   char *fieldname;
 397   const char *p;
 398   volatile struct gdb_exception except;
 399   enum type_code code = TYPE_CODE_UNDEF;
 400
 401   /* Perform a tentative parse of the expression, to see whether a
 402      field completion is required.  */
 403   fieldname = NULL;
 404   TRY_CATCH (except, RETURN_MASK_ERROR)
 405     {
 406       type = parse_expression_for_completion (text, &fieldname, &code);
 407     }
 408   if (except.reason < 0)
 409     return NULL;
 410   if (fieldname && type)
 411     {
 412       for (;;)
 413         {
 414           CHECK_TYPEDEF (type);
 415           if (TYPE_CODE (type) != TYPE_CODE_PTR
 416               && TYPE_CODE (type) != TYPE_CODE_REF)
 417             break;
 418           type = TYPE_TARGET_TYPE (type);
 419         }
 420
 421       if (TYPE_CODE (type) == TYPE_CODE_UNION
 422           || TYPE_CODE (type) == TYPE_CODE_STRUCT)
 423         {
 424           int flen = strlen (fieldname);
 425           VEC (char_ptr) *result = NULL;
 426
 427           add_struct_fields (type, &result, fieldname, flen);
 428           xfree (fieldname);
 429           return result;
 430         }
 431     }
 432   else if (fieldname && code != TYPE_CODE_UNDEF)
 433     {
 434       VEC (char_ptr) *result;
 435       struct cleanup *cleanup = make_cleanup (xfree, fieldname);
 436
 437       result = make_symbol_completion_type (fieldname, fieldname, code);
 438       do_cleanups (cleanup);
 439       return result;
 440     }
 441   xfree (fieldname);
 442
 443   /* Commands which complete on locations want to see the entire
 444      argument.  */
 445   for (p = word;
 446        p > text && p[-1] != ' ' && p[-1] != '\t';
 447        p--)
 448     ;
 449
 450   /* Not ideal but it is what we used to do before...  */
 451   return location_completer (ignore, p, word);
 452 }
 453
 454 /* See definition in completer.h.  */
 455
 456 void
 457 set_gdb_completion_word_break_characters (completer_ftype *fn)
 458 {
 459   /* So far we are only interested in differentiating filename
 460      completers from everything else.  */
 461   if (fn == filename_completer)
 462     rl_completer_word_break_characters
 463       = gdb_completer_file_name_break_characters;
 464   else
 465     rl_completer_word_break_characters
 466       = gdb_completer_command_word_break_characters;
 467 }
 468
 469 /* Here are some useful test cases for completion.  FIXME: These
 470    should be put in the test suite.  They should be tested with both
 471    M-? and TAB.
 472
 473    "show output-" "radix"
 474    "show output" "-radix"
 475    "p" ambiguous (commands starting with p--path, print, printf, etc.)
 476    "p "  ambiguous (all symbols)
 477    "info t foo" no completions
 478    "info t " no completions
 479    "info t" ambiguous ("info target", "info terminal", etc.)
 480    "info ajksdlfk" no completions
 481    "info ajksdlfk " no completions
 482    "info" " "
 483    "info " ambiguous (all info commands)
 484    "p \"a" no completions (string constant)
 485    "p 'a" ambiguous (all symbols starting with a)
 486    "p b-a" ambiguous (all symbols starting with a)
 487    "p b-" ambiguous (all symbols)
 488    "file Make" "file" (word break hard to screw up here)
 489    "file ../gdb.stabs/we" "ird" (needs to not break word at slash)
 490  */
 491
 492 typedef enum
 493 {
 494   handle_brkchars,
 495   handle_completions,
 496   handle_help
 497 }
 498 complete_line_internal_reason;
 499
 500
 501 /* Internal function used to handle completions.
 502
 503
 504    TEXT is the caller's idea of the "word" we are looking at.
 505
 506    LINE_BUFFER is available to be looked at; it contains the entire
 507    text of the line.  POINT is the offset in that line of the cursor.
 508    You should pretend that the line ends at POINT.
 509
 510    REASON is of type complete_line_internal_reason.
 511
 512    If REASON is handle_brkchars:
 513    Preliminary phase, called by gdb_completion_word_break_characters
 514    function, is used to determine the correct set of chars that are
 515    word delimiters depending on the current command in line_buffer.
 516    No completion list should be generated; the return value should be
 517    NULL.  This is checked by an assertion in that function.
 518
 519    If REASON is handle_completions:
 520    Main phase, called by complete_line function, is used to get the list
 521    of posible completions.
 522
 523    If REASON is handle_help:
 524    Special case when completing a 'help' command.  In this case,
 525    once sub-command completions are exhausted, we simply return NULL.
 526  */
 527
 528 static VEC (char_ptr) *
 529 complete_line_internal (const char *text,
 530                         const char *line_buffer, int point,
 531                         complete_line_internal_reason reason)
 532 {
 533   VEC (char_ptr) *list = NULL;
 534   char *tmp_command;
 535   const char *p;
 536   int ignore_help_classes;
 537   /* Pointer within tmp_command which corresponds to text.  */
 538   char *word;
 539   struct cmd_list_element *c, *result_list;
 540
 541   /* Choose the default set of word break characters to break
 542      completions.  If we later find out that we are doing completions
 543      on command strings (as opposed to strings supplied by the
 544      individual command completer functions, which can be any string)
 545      then we will switch to the special word break set for command
 546      strings, which leaves out the '-' character used in some
 547      commands.  */
 548   rl_completer_word_break_characters =
 549     current_language->la_word_break_characters();
 550
 551   /* Decide whether to complete on a list of gdb commands or on
 552      symbols.  */
 553   tmp_command = (char *) alloca (point + 1);
 554   p = tmp_command;
 555
 556   /* The help command should complete help aliases.  */
 557   ignore_help_classes = reason != handle_help;
 558
 559   strncpy (tmp_command, line_buffer, point);
 560   tmp_command[point] = '\0';
 561   /* Since text always contains some number of characters leading up
 562      to point, we can find the equivalent position in tmp_command
 563      by subtracting that many characters from the end of tmp_command.  */
 564   word = tmp_command + point - strlen (text);
 565
 566   if (point == 0)
 567     {
 568       /* An empty line we want to consider ambiguous; that is, it
 569          could be any command.  */
 570       c = CMD_LIST_AMBIGUOUS;
 571       result_list = 0;
 572     }
 573   else
 574     {
 575       c = lookup_cmd_1 (&p, cmdlist, &result_list, ignore_help_classes);
 576     }
 577
 578   /* Move p up to the next interesting thing.  */
 579   while (*p == ' ' || *p == '\t')
 580     {
 581       p++;
 582     }
 583
 584   if (!c)
 585     {
 586       /* It is an unrecognized command.  So there are no
 587          possible completions.  */
 588       list = NULL;
 589     }
 590   else if (c == CMD_LIST_AMBIGUOUS)
 591     {
 592       const char *q;
 593
 594       /* lookup_cmd_1 advances p up to the first ambiguous thing, but
 595          doesn't advance over that thing itself.  Do so now.  */
 596       q = p;
 597       while (*q && (isalnum (*q) || *q == '-' || *q == '_'))
 598         ++q;
 599       if (q != tmp_command + point)
 600         {
 601           /* There is something beyond the ambiguous
 602              command, so there are no possible completions.  For
 603              example, "info t " or "info t foo" does not complete
 604              to anything, because "info t" can be "info target" or
 605              "info terminal".  */
 606           list = NULL;
 607         }
 608       else
 609         {
 610           /* We're trying to complete on the command which was ambiguous.
 611              This we can deal with.  */
 612           if (result_list)
 613             {
 614               if (reason != handle_brkchars)
 615                 list = complete_on_cmdlist (*result_list->prefixlist, p,
 616                                             word, ignore_help_classes);
 617             }
 618           else
 619             {
 620               if (reason != handle_brkchars)
 621                 list = complete_on_cmdlist (cmdlist, p, word,
 622                                             ignore_help_classes);
 623             }
 624           /* Ensure that readline does the right thing with respect to
 625              inserting quotes.  */
 626           rl_completer_word_break_characters =
 627             gdb_completer_command_word_break_characters;
 628         }
 629     }
 630   else
 631     {
 632       /* We've recognized a full command.  */
 633
 634       if (p == tmp_command + point)
 635         {
 636           /* There is no non-whitespace in the line beyond the
 637              command.  */
 638
 639           if (p[-1] == ' ' || p[-1] == '\t')
 640             {
 641               /* The command is followed by whitespace; we need to
 642                  complete on whatever comes after command.  */
 643               if (c->prefixlist)
 644                 {
 645                   /* It is a prefix command; what comes after it is
 646                      a subcommand (e.g. "info ").  */
 647                   if (reason != handle_brkchars)
 648                     list = complete_on_cmdlist (*c->prefixlist, p, word,
 649                                                 ignore_help_classes);
 650
 651                   /* Ensure that readline does the right thing
 652                      with respect to inserting quotes.  */
 653                   rl_completer_word_break_characters =
 654                     gdb_completer_command_word_break_characters;
 655                 }
 656               else if (reason == handle_help)
 657                 list = NULL;
 658               else if (c->enums)
 659                 {
 660                   if (reason != handle_brkchars)
 661                     list = complete_on_enum (c->enums, p, word);
 662                   rl_completer_word_break_characters =
 663                     gdb_completer_command_word_break_characters;
 664                 }
 665               else
 666                 {
 667                   /* It is a normal command; what comes after it is
 668                      completed by the command's completer function.  */
 669                   if (c->completer == filename_completer)
 670                     {
 671                       /* Many commands which want to complete on
 672                          file names accept several file names, as
 673                          in "run foo bar >>baz".  So we don't want
 674                          to complete the entire text after the
 675                          command, just the last word.  To this
 676                          end, we need to find the beginning of the
 677                          file name by starting at `word' and going
 678                          backwards.  */
 679                       for (p = word;
 680                            p > tmp_command
 681                              && strchr (gdb_completer_file_name_break_characters, p[-1]) == NULL;
 682                            p--)
 683                         ;
 684                       rl_completer_word_break_characters =
 685                         gdb_completer_file_name_break_characters;
 686                     }
 687                   else if (c->completer == location_completer)
 688                     {
 689                       /* Commands which complete on locations want to
 690                          see the entire argument.  */
 691                       for (p = word;
 692                            p > tmp_command
 693                              && p[-1] != ' ' && p[-1] != '\t';
 694                            p--)
 695                         ;
 696                     }
 697                   if (reason == handle_brkchars
 698                       && c->completer_handle_brkchars != NULL)
 699                     (*c->completer_handle_brkchars) (c, p, word);
 700                   if (reason != handle_brkchars && c->completer != NULL)
 701                     list = (*c->completer) (c, p, word);
 702                 }
 703             }
 704           else
 705             {
 706               /* The command is not followed by whitespace; we need to
 707                  complete on the command itself, e.g. "p" which is a
 708                  command itself but also can complete to "print", "ptype"
 709                  etc.  */
 710               const char *q;
 711
 712               /* Find the command we are completing on.  */
 713               q = p;
 714               while (q > tmp_command)
 715                 {
 716                   if (isalnum (q[-1]) || q[-1] == '-' || q[-1] == '_')
 717                     --q;
 718                   else
 719                     break;
 720                 }
 721
 722               if (reason != handle_brkchars)
 723                 list = complete_on_cmdlist (result_list, q, word,
 724                                             ignore_help_classes);
 725
 726               /* Ensure that readline does the right thing
 727                  with respect to inserting quotes.  */
 728               rl_completer_word_break_characters =
 729                 gdb_completer_command_word_break_characters;
 730             }
 731         }
 732       else if (reason == handle_help)
 733         list = NULL;
 734       else
 735         {
 736           /* There is non-whitespace beyond the command.  */
 737
 738           if (c->prefixlist && !c->allow_unknown)
 739             {
 740               /* It is an unrecognized subcommand of a prefix command,
 741                  e.g. "info adsfkdj".  */
 742               list = NULL;
 743             }
 744           else if (c->enums)
 745             {
 746               if (reason != handle_brkchars)
 747                 list = complete_on_enum (c->enums, p, word);
 748             }
 749           else
 750             {
 751               /* It is a normal command.  */
 752               if (c->completer == filename_completer)
 753                 {
 754                   /* See the commentary above about the specifics
 755                      of file-name completion.  */
 756                   for (p = word;
 757                        p > tmp_command
 758                          && strchr (gdb_completer_file_name_break_characters,
 759                                     p[-1]) == NULL;
 760                        p--)
 761                     ;
 762                   rl_completer_word_break_characters =
 763                     gdb_completer_file_name_break_characters;
 764                 }
 765               else if (c->completer == location_completer)
 766                 {
 767                   for (p = word;
 768                        p > tmp_command
 769                          && p[-1] != ' ' && p[-1] != '\t';
 770                        p--)
 771                     ;
 772                 }
 773               if (reason == handle_brkchars
 774                   && c->completer_handle_brkchars != NULL)
 775                 (*c->completer_handle_brkchars) (c, p, word);
 776               if (reason != handle_brkchars && c->completer != NULL)
 777                 list = (*c->completer) (c, p, word);
 778             }
 779         }
 780     }
 781
 782   return list;
 783 }
 784 /* Generate completions all at once.  Returns a vector of strings.
 785    Each element is allocated with xmalloc.  It can also return NULL if
 786    there are no completions.
 787
 788    TEXT is the caller's idea of the "word" we are looking at.
 789
 790    LINE_BUFFER is available to be looked at; it contains the entire
 791    text of the line.
 792
 793    POINT is the offset in that line of the cursor.  You
 794    should pretend that the line ends at POINT.  */
 795
 796 VEC (char_ptr) *
 797 complete_line (const char *text, const char *line_buffer, int point)
 798 {
 799   return complete_line_internal (text, line_buffer,
 800                                  point, handle_completions);
 801 }
 802
 803 /* Complete on command names.  Used by "help".  */
 804 VEC (char_ptr) *
 805 command_completer (struct cmd_list_element *ignore,
 806                    const char *text, const char *word)
 807 {
 808   return complete_line_internal (word, text,
 809                                  strlen (text), handle_help);
 810 }
 811
 812 /* Complete on signals.  */
 813
 814 VEC (char_ptr) *
 815 signal_completer (struct cmd_list_element *ignore,
 816                   const char *text, const char *word)
 817 {
 818   VEC (char_ptr) *return_val = NULL;
 819   size_t len = strlen (word);
 820   enum gdb_signal signum;
 821   const char *signame;
 822
 823   for (signum = GDB_SIGNAL_FIRST; signum != GDB_SIGNAL_LAST; ++signum)
 824     {
 825       /* Can't handle this, so skip it.  */
 826       if (signum == GDB_SIGNAL_0)
 827         continue;
 828
 829       signame = gdb_signal_to_name (signum);
 830
 831       /* Ignore the unknown signal case.  */
 832       if (!signame || strcmp (signame, "?") == 0)
 833         continue;
 834
 835       if (strncasecmp (signame, word, len) == 0)
 836         VEC_safe_push (char_ptr, return_val, xstrdup (signame));
 837     }
 838
 839   return return_val;
 840 }
 841
 842 /* Complete on a register or reggroup.  */
 843
 844 VEC (char_ptr) *
 845 reg_or_group_completer (struct cmd_list_element *ignore,
 846                         const char *text, const char *word)
 847 {
 848   VEC (char_ptr) *result = NULL;
 849   size_t len = strlen (word);
 850   struct gdbarch *gdbarch;
 851   struct reggroup *group;
 852   const char *name;
 853   int i;
 854
 855   if (!target_has_registers)
 856     return result;
 857
 858   gdbarch = get_frame_arch (get_selected_frame (NULL));
 859
 860   for (i = 0;
 861        (name = user_reg_map_regnum_to_name (gdbarch, i)) != NULL;
 862        i++)
 863     {
 864       if (*name != '\0' && strncmp (word, name, len) == 0)
 865         VEC_safe_push (char_ptr, result, xstrdup (name));
 866     }
 867
 868   for (group = reggroup_next (gdbarch, NULL);
 869        group != NULL;
 870        group = reggroup_next (gdbarch, group))
 871     {
 872       name = reggroup_name (group);
 873       if (strncmp (word, name, len) == 0)
 874         VEC_safe_push (char_ptr, result, xstrdup (name));
 875     }
 876
 877   return result;
 878 }
 879
 880
 881 /* Get the list of chars that are considered as word breaks
 882    for the current command.  */
 883
 884 char *
 885 gdb_completion_word_break_characters (void)
 886 {
 887   VEC (char_ptr) *list;
 888
 889   list = complete_line_internal (rl_line_buffer, rl_line_buffer, rl_point,
 890                                  handle_brkchars);
 891   gdb_assert (list == NULL);
 892   return rl_completer_word_break_characters;
 893 }
 894
 895 /* Generate completions one by one for the completer.  Each time we
 896    are called return another potential completion to the caller.
 897    line_completion just completes on commands or passes the buck to
 898    the command's completer function, the stuff specific to symbol
 899    completion is in make_symbol_completion_list.
 900
 901    TEXT is the caller's idea of the "word" we are looking at.
 902
 903    MATCHES is the number of matches that have currently been collected
 904    from calling this completion function.  When zero, then we need to
 905    initialize, otherwise the initialization has already taken place
 906    and we can just return the next potential completion string.
 907
 908    LINE_BUFFER is available to be looked at; it contains the entire
 909    text of the line.  POINT is the offset in that line of the cursor.
 910    You should pretend that the line ends at POINT.
 911
 912    Returns NULL if there are no more completions, else a pointer to a
 913    string which is a possible completion, it is the caller's
 914    responsibility to free the string.  */
 915
 916 static char *
 917 line_completion_function (const char *text, int matches,
 918                           char *line_buffer, int point)
 919 {
 920   static VEC (char_ptr) *list = NULL;   /* Cache of completions.  */
 921   static int index;                     /* Next cached completion.  */
 922   char *output = NULL;
 923
 924   if (matches == 0)
 925     {
 926       /* The caller is beginning to accumulate a new set of
 927          completions, so we need to find all of them now, and cache
 928          them for returning one at a time on future calls.  */
 929
 930       if (list)
 931         {
 932           /* Free the storage used by LIST, but not by the strings
 933              inside.  This is because rl_complete_internal () frees
 934              the strings.  As complete_line may abort by calling
 935              `error' clear LIST now.  */
 936           VEC_free (char_ptr, list);
 937         }
 938       index = 0;
 939       list = complete_line (text, line_buffer, point);
 940     }
 941
 942   /* If we found a list of potential completions during initialization
 943      then dole them out one at a time.  After returning the last one,
 944      return NULL (and continue to do so) each time we are called after
 945      that, until a new list is available.  */
 946
 947   if (list)
 948     {
 949       if (index < VEC_length (char_ptr, list))
 950         {
 951           output = VEC_index (char_ptr, list, index);
 952           index++;
 953         }
 954     }
 955
 956 #if 0
 957   /* Can't do this because readline hasn't yet checked the word breaks
 958      for figuring out whether to insert a quote.  */
 959   if (output == NULL)
 960     /* Make sure the word break characters are set back to normal for
 961        the next time that readline tries to complete something.  */
 962     rl_completer_word_break_characters =
 963       current_language->la_word_break_characters();
 964 #endif
 965
 966   return (output);
 967 }
 968
 969 /* Skip over the possibly quoted word STR (as defined by the quote
 970    characters QUOTECHARS and the word break characters BREAKCHARS).
 971    Returns pointer to the location after the "word".  If either
 972    QUOTECHARS or BREAKCHARS is NULL, use the same values used by the
 973    completer.  */
 974
 975 const char *
 976 skip_quoted_chars (const char *str, const char *quotechars,
 977                    const char *breakchars)
 978 {
 979   char quote_char = '\0';
 980   const char *scan;
 981
 982   if (quotechars == NULL)
 983     quotechars = gdb_completer_quote_characters;
 984
 985   if (breakchars == NULL)
 986     breakchars = current_language->la_word_break_characters();
 987
 988   for (scan = str; *scan != '\0'; scan++)
 989     {
 990       if (quote_char != '\0')
 991         {
 992           /* Ignore everything until the matching close quote char.  */
 993           if (*scan == quote_char)
 994             {
 995               /* Found matching close quote.  */
 996               scan++;
 997               break;
 998             }
 999         }
1000       else if (strchr (quotechars, *scan))
1001         {
1002           /* Found start of a quoted string.  */
1003           quote_char = *scan;
1004         }
1005       else if (strchr (breakchars, *scan))
1006         {
1007           break;
1008         }
1009     }
1010
1011   return (scan);
1012 }
1013
1014 /* Skip over the possibly quoted word STR (as defined by the quote
1015    characters and word break characters used by the completer).
1016    Returns pointer to the location after the "word".  */
1017
1018 const char *
1019 skip_quoted (const char *str)
1020 {
1021   return skip_quoted_chars (str, NULL, NULL);
1022 }