gdb/completer.c

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