1 /* Line completion stuff for GDB, the GNU debugger.
2 Copyright (C) 2000-2014 Free Software Foundation, Inc.
4 This file is part of GDB.
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.
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.
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/>. */
22 #include "expression.h"
23 #include "filenames.h" /* For DOSish file names. */
25 #include "gdb_signals.h"
27 #include "cli/cli-decode.h"
29 /* FIXME: This is needed because of lookup_cmd_1 (). We should be
30 calling a hook instead so we eliminate the CLI dependency. */
33 /* Needed for rl_completer_word_break_characters() and for
34 rl_filename_completion_function. */
35 #include "readline/readline.h"
37 /* readline defines this. */
40 #include "completer.h"
42 /* Prototypes for local functions. */
44 char *line_completion_function (const char *text
, int matches
,
48 /* readline uses the word breaks for two things:
49 (1) In figuring out where to point the TEXT parameter to the
50 rl_completion_entry_function. Since we don't use TEXT for much,
51 it doesn't matter a lot what the word breaks are for this purpose,
52 but it does affect how much stuff M-? lists.
53 (2) If one of the matches contains a word break character, readline
54 will quote it. That's why we switch between
55 current_language->la_word_break_characters() and
56 gdb_completer_command_word_break_characters. I'm not sure when
57 we need this behavior (perhaps for funky characters in C++
60 /* Variables which are necessary for fancy command line editing. */
62 /* When completing on command names, we remove '-' from the list of
63 word break characters, since we use it in command names. If the
64 readline library sees one in any of the current completion strings,
65 it thinks that the string needs to be quoted and automatically
66 supplies a leading quote. */
67 static char *gdb_completer_command_word_break_characters
=
68 " \t\n!@#$%^&*()+=|~`}{[]\"';:?/>.<,";
70 /* When completing on file names, we remove from the list of word
71 break characters any characters that are commonly used in file
72 names, such as '-', '+', '~', etc. Otherwise, readline displays
73 incorrect completion candidates. */
74 #ifdef HAVE_DOS_BASED_FILE_SYSTEM
75 /* MS-DOS and MS-Windows use colon as part of the drive spec, and most
76 programs support @foo style response files. */
77 static char *gdb_completer_file_name_break_characters
= " \t\n*|\"';?><@";
79 static char *gdb_completer_file_name_break_characters
= " \t\n*|\"';:?><";
82 /* Characters that can be used to quote completion strings. Note that
83 we can't include '"' because the gdb C parser treats such quoted
84 sequences as strings. */
85 static char *gdb_completer_quote_characters
= "'";
87 /* Accessor for some completer data that may interest other files. */
90 get_gdb_completer_quote_characters (void)
92 return gdb_completer_quote_characters
;
95 /* Line completion interface function for readline. */
98 readline_line_completion_function (const char *text
, int matches
)
100 return line_completion_function (text
, matches
,
101 rl_line_buffer
, rl_point
);
104 /* This can be used for functions which don't want to complete on
105 symbols but don't want to complete on anything else either. */
107 noop_completer (struct cmd_list_element
*ignore
,
108 const char *text
, const char *prefix
)
113 /* Complete on filenames. */
115 filename_completer (struct cmd_list_element
*ignore
,
116 const char *text
, const char *word
)
119 VEC (char_ptr
) *return_val
= NULL
;
126 p
= rl_filename_completion_function (text
, subsequent_name
);
129 /* We need to set subsequent_name to a non-zero value before the
130 continue line below, because otherwise, if the first file
131 seen by GDB is a backup file whose name ends in a `~', we
132 will loop indefinitely. */
134 /* Like emacs, don't complete on old versions. Especially
135 useful in the "source" command. */
136 if (p
[strlen (p
) - 1] == '~')
143 /* Return exactly p. */
145 else if (word
> text
)
147 /* Return some portion of p. */
148 q
= xmalloc (strlen (p
) + 5);
149 strcpy (q
, p
+ (word
- text
));
154 /* Return some of TEXT plus p. */
155 q
= xmalloc (strlen (p
) + (text
- word
) + 5);
156 strncpy (q
, word
, text
- word
);
157 q
[text
- word
] = '\0';
161 VEC_safe_push (char_ptr
, return_val
, q
);
164 /* There is no way to do this just long enough to affect quote
165 inserting without also affecting the next completion. This
166 should be fixed in readline. FIXME. */
167 /* Ensure that readline does the right thing
168 with respect to inserting quotes. */
169 rl_completer_word_break_characters
= "";
174 /* Complete on locations, which might be of two possible forms:
180 This is intended to be used in commands that set breakpoints
184 location_completer (struct cmd_list_element
*ignore
,
185 const char *text
, const char *word
)
187 int n_syms
, n_files
, ix
;
188 VEC (char_ptr
) *fn_list
= NULL
;
189 VEC (char_ptr
) *list
= NULL
;
192 int quoted
= *text
== '\'' || *text
== '"';
193 int quote_char
= '\0';
194 const char *colon
= NULL
;
195 char *file_to_match
= NULL
;
196 const char *symbol_start
= text
;
197 const char *orig_text
= text
;
200 /* Do we have an unquoted colon, as in "break foo.c:bar"? */
201 for (p
= text
; *p
!= '\0'; ++p
)
203 if (*p
== '\\' && p
[1] == '\'')
205 else if (*p
== '\'' || *p
== '"')
209 while (*p
!= '\0' && *p
!= quote_found
)
211 if (*p
== '\\' && p
[1] == quote_found
)
216 if (*p
== quote_found
)
219 break; /* Hit the end of text. */
221 #if HAVE_DOS_BASED_FILE_SYSTEM
222 /* If we have a DOS-style absolute file name at the beginning of
223 TEXT, and the colon after the drive letter is the only colon
224 we found, pretend the colon is not there. */
225 else if (p
< text
+ 3 && *p
== ':' && p
== text
+ 1 + quoted
)
228 else if (*p
== ':' && !colon
)
231 symbol_start
= p
+ 1;
233 else if (strchr (current_language
->la_word_break_characters(), *p
))
234 symbol_start
= p
+ 1;
239 text_len
= strlen (text
);
241 /* Where is the file name? */
246 file_to_match
= (char *) xmalloc (colon
- text
+ 1);
247 strncpy (file_to_match
, text
, colon
- text
+ 1);
248 /* Remove trailing colons and quotes from the file name. */
249 for (s
= file_to_match
+ (colon
- text
);
252 if (*s
== ':' || *s
== quote_char
)
255 /* If the text includes a colon, they want completion only on a
256 symbol name after the colon. Otherwise, we need to complete on
257 symbols as well as on files. */
260 list
= make_file_symbol_completion_list (symbol_start
, word
,
262 xfree (file_to_match
);
266 list
= make_symbol_completion_list (symbol_start
, word
);
267 /* If text includes characters which cannot appear in a file
268 name, they cannot be asking for completion on files. */
270 gdb_completer_file_name_break_characters
) == text_len
)
271 fn_list
= make_source_files_completion_list (text
, text
);
274 n_syms
= VEC_length (char_ptr
, list
);
275 n_files
= VEC_length (char_ptr
, fn_list
);
277 /* Catenate fn_list[] onto the end of list[]. */
280 VEC_free (char_ptr
, list
); /* Paranoia. */
288 for (ix
= 0; VEC_iterate (char_ptr
, fn_list
, ix
, fn
); ++ix
)
289 VEC_safe_push (char_ptr
, list
, fn
);
290 VEC_free (char_ptr
, fn_list
);
293 if (n_syms
&& n_files
)
301 /* If we only have file names as possible completion, we should
302 bring them in sync with what rl_complete expects. The
303 problem is that if the user types "break /foo/b TAB", and the
304 possible completions are "/foo/bar" and "/foo/baz"
305 rl_complete expects us to return "bar" and "baz", without the
306 leading directories, as possible completions, because `word'
307 starts at the "b". But we ignore the value of `word' when we
308 call make_source_files_completion_list above (because that
309 would not DTRT when the completion results in both symbols
310 and file names), so make_source_files_completion_list returns
311 the full "/foo/bar" and "/foo/baz" strings. This produces
312 wrong results when, e.g., there's only one possible
313 completion, because rl_complete will prepend "/foo/" to each
314 candidate completion. The loop below removes that leading
316 for (ix
= 0; VEC_iterate (char_ptr
, list
, ix
, fn
); ++ix
)
318 memmove (fn
, fn
+ (word
- text
),
319 strlen (fn
) + 1 - (word
- text
));
324 /* No completions at all. As the final resort, try completing
325 on the entire text as a symbol. */
326 list
= make_symbol_completion_list (orig_text
, word
);
332 /* Helper for expression_completer which recursively adds field and
333 method names from TYPE, a struct or union type, to the array
336 add_struct_fields (struct type
*type
, VEC (char_ptr
) **output
,
337 char *fieldname
, int namelen
)
340 int computed_type_name
= 0;
341 const char *type_name
= NULL
;
343 CHECK_TYPEDEF (type
);
344 for (i
= 0; i
< TYPE_NFIELDS (type
); ++i
)
346 if (i
< TYPE_N_BASECLASSES (type
))
347 add_struct_fields (TYPE_BASECLASS (type
, i
),
348 output
, fieldname
, namelen
);
349 else if (TYPE_FIELD_NAME (type
, i
))
351 if (TYPE_FIELD_NAME (type
, i
)[0] != '\0')
353 if (! strncmp (TYPE_FIELD_NAME (type
, i
),
355 VEC_safe_push (char_ptr
, *output
,
356 xstrdup (TYPE_FIELD_NAME (type
, i
)));
358 else if (TYPE_CODE (TYPE_FIELD_TYPE (type
, i
)) == TYPE_CODE_UNION
)
360 /* Recurse into anonymous unions. */
361 add_struct_fields (TYPE_FIELD_TYPE (type
, i
),
362 output
, fieldname
, namelen
);
367 for (i
= TYPE_NFN_FIELDS (type
) - 1; i
>= 0; --i
)
369 const char *name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
371 if (name
&& ! strncmp (name
, fieldname
, namelen
))
373 if (!computed_type_name
)
375 type_name
= type_name_no_tag (type
);
376 computed_type_name
= 1;
378 /* Omit constructors from the completion list. */
379 if (!type_name
|| strcmp (type_name
, name
))
380 VEC_safe_push (char_ptr
, *output
, xstrdup (name
));
385 /* Complete on expressions. Often this means completing on symbol
386 names, but some language parsers also have support for completing
389 expression_completer (struct cmd_list_element
*ignore
,
390 const char *text
, const char *word
)
392 struct type
*type
= NULL
;
395 volatile struct gdb_exception except
;
396 enum type_code code
= TYPE_CODE_UNDEF
;
398 /* Perform a tentative parse of the expression, to see whether a
399 field completion is required. */
401 TRY_CATCH (except
, RETURN_MASK_ERROR
)
403 type
= parse_expression_for_completion (text
, &fieldname
, &code
);
405 if (except
.reason
< 0)
407 if (fieldname
&& type
)
411 CHECK_TYPEDEF (type
);
412 if (TYPE_CODE (type
) != TYPE_CODE_PTR
413 && TYPE_CODE (type
) != TYPE_CODE_REF
)
415 type
= TYPE_TARGET_TYPE (type
);
418 if (TYPE_CODE (type
) == TYPE_CODE_UNION
419 || TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
421 int flen
= strlen (fieldname
);
422 VEC (char_ptr
) *result
= NULL
;
424 add_struct_fields (type
, &result
, fieldname
, flen
);
429 else if (fieldname
&& code
!= TYPE_CODE_UNDEF
)
431 VEC (char_ptr
) *result
;
432 struct cleanup
*cleanup
= make_cleanup (xfree
, fieldname
);
434 result
= make_symbol_completion_type (fieldname
, fieldname
, code
);
435 do_cleanups (cleanup
);
440 /* Commands which complete on locations want to see the entire
443 p
> text
&& p
[-1] != ' ' && p
[-1] != '\t';
447 /* Not ideal but it is what we used to do before... */
448 return location_completer (ignore
, p
, word
);
451 /* See definition in completer.h. */
454 set_gdb_completion_word_break_characters (completer_ftype
*fn
)
456 /* So far we are only interested in differentiating filename
457 completers from everything else. */
458 if (fn
== filename_completer
)
459 rl_completer_word_break_characters
460 = gdb_completer_file_name_break_characters
;
462 rl_completer_word_break_characters
463 = gdb_completer_command_word_break_characters
;
466 /* Here are some useful test cases for completion. FIXME: These
467 should be put in the test suite. They should be tested with both
470 "show output-" "radix"
471 "show output" "-radix"
472 "p" ambiguous (commands starting with p--path, print, printf, etc.)
473 "p " ambiguous (all symbols)
474 "info t foo" no completions
475 "info t " no completions
476 "info t" ambiguous ("info target", "info terminal", etc.)
477 "info ajksdlfk" no completions
478 "info ajksdlfk " no completions
480 "info " ambiguous (all info commands)
481 "p \"a" no completions (string constant)
482 "p 'a" ambiguous (all symbols starting with a)
483 "p b-a" ambiguous (all symbols starting with a)
484 "p b-" ambiguous (all symbols)
485 "file Make" "file" (word break hard to screw up here)
486 "file ../gdb.stabs/we" "ird" (needs to not break word at slash)
495 complete_line_internal_reason
;
498 /* Internal function used to handle completions.
501 TEXT is the caller's idea of the "word" we are looking at.
503 LINE_BUFFER is available to be looked at; it contains the entire
504 text of the line. POINT is the offset in that line of the cursor.
505 You should pretend that the line ends at POINT.
507 REASON is of type complete_line_internal_reason.
509 If REASON is handle_brkchars:
510 Preliminary phase, called by gdb_completion_word_break_characters
511 function, is used to determine the correct set of chars that are
512 word delimiters depending on the current command in line_buffer.
513 No completion list should be generated; the return value should be
514 NULL. This is checked by an assertion in that function.
516 If REASON is handle_completions:
517 Main phase, called by complete_line function, is used to get the list
518 of posible completions.
520 If REASON is handle_help:
521 Special case when completing a 'help' command. In this case,
522 once sub-command completions are exhausted, we simply return NULL.
525 static VEC (char_ptr
) *
526 complete_line_internal (const char *text
,
527 const char *line_buffer
, int point
,
528 complete_line_internal_reason reason
)
530 VEC (char_ptr
) *list
= NULL
;
533 int ignore_help_classes
;
534 /* Pointer within tmp_command which corresponds to text. */
536 struct cmd_list_element
*c
, *result_list
;
538 /* Choose the default set of word break characters to break
539 completions. If we later find out that we are doing completions
540 on command strings (as opposed to strings supplied by the
541 individual command completer functions, which can be any string)
542 then we will switch to the special word break set for command
543 strings, which leaves out the '-' character used in some
545 rl_completer_word_break_characters
=
546 current_language
->la_word_break_characters();
548 /* Decide whether to complete on a list of gdb commands or on
550 tmp_command
= (char *) alloca (point
+ 1);
553 /* The help command should complete help aliases. */
554 ignore_help_classes
= reason
!= handle_help
;
556 strncpy (tmp_command
, line_buffer
, point
);
557 tmp_command
[point
] = '\0';
558 /* Since text always contains some number of characters leading up
559 to point, we can find the equivalent position in tmp_command
560 by subtracting that many characters from the end of tmp_command. */
561 word
= tmp_command
+ point
- strlen (text
);
565 /* An empty line we want to consider ambiguous; that is, it
566 could be any command. */
567 c
= CMD_LIST_AMBIGUOUS
;
572 c
= lookup_cmd_1 (&p
, cmdlist
, &result_list
, ignore_help_classes
);
575 /* Move p up to the next interesting thing. */
576 while (*p
== ' ' || *p
== '\t')
583 /* It is an unrecognized command. So there are no
584 possible completions. */
587 else if (c
== CMD_LIST_AMBIGUOUS
)
591 /* lookup_cmd_1 advances p up to the first ambiguous thing, but
592 doesn't advance over that thing itself. Do so now. */
594 while (*q
&& (isalnum (*q
) || *q
== '-' || *q
== '_'))
596 if (q
!= tmp_command
+ point
)
598 /* There is something beyond the ambiguous
599 command, so there are no possible completions. For
600 example, "info t " or "info t foo" does not complete
601 to anything, because "info t" can be "info target" or
607 /* We're trying to complete on the command which was ambiguous.
608 This we can deal with. */
611 if (reason
!= handle_brkchars
)
612 list
= complete_on_cmdlist (*result_list
->prefixlist
, p
,
613 word
, ignore_help_classes
);
617 if (reason
!= handle_brkchars
)
618 list
= complete_on_cmdlist (cmdlist
, p
, word
,
619 ignore_help_classes
);
621 /* Ensure that readline does the right thing with respect to
623 rl_completer_word_break_characters
=
624 gdb_completer_command_word_break_characters
;
629 /* We've recognized a full command. */
631 if (p
== tmp_command
+ point
)
633 /* There is no non-whitespace in the line beyond the
636 if (p
[-1] == ' ' || p
[-1] == '\t')
638 /* The command is followed by whitespace; we need to
639 complete on whatever comes after command. */
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 ignore_help_classes
);
648 /* Ensure that readline does the right thing
649 with respect to inserting quotes. */
650 rl_completer_word_break_characters
=
651 gdb_completer_command_word_break_characters
;
653 else if (reason
== handle_help
)
657 if (reason
!= handle_brkchars
)
658 list
= complete_on_enum (c
->enums
, p
, word
);
659 rl_completer_word_break_characters
=
660 gdb_completer_command_word_break_characters
;
664 /* It is a normal command; what comes after it is
665 completed by the command's completer function. */
666 if (c
->completer
== filename_completer
)
668 /* Many commands which want to complete on
669 file names accept several file names, as
670 in "run foo bar >>baz". So we don't want
671 to complete the entire text after the
672 command, just the last word. To this
673 end, we need to find the beginning of the
674 file name by starting at `word' and going
678 && strchr (gdb_completer_file_name_break_characters
, p
[-1]) == NULL
;
681 rl_completer_word_break_characters
=
682 gdb_completer_file_name_break_characters
;
684 else if (c
->completer
== location_completer
)
686 /* Commands which complete on locations want to
687 see the entire argument. */
690 && p
[-1] != ' ' && p
[-1] != '\t';
694 if (reason
== handle_brkchars
695 && c
->completer_handle_brkchars
!= NULL
)
696 (*c
->completer_handle_brkchars
) (c
, p
, word
);
697 if (reason
!= handle_brkchars
&& c
->completer
!= NULL
)
698 list
= (*c
->completer
) (c
, p
, word
);
703 /* The command is not followed by whitespace; we need to
704 complete on the command itself, e.g. "p" which is a
705 command itself but also can complete to "print", "ptype"
709 /* Find the command we are completing on. */
711 while (q
> tmp_command
)
713 if (isalnum (q
[-1]) || q
[-1] == '-' || q
[-1] == '_')
719 if (reason
!= handle_brkchars
)
720 list
= complete_on_cmdlist (result_list
, q
, word
,
721 ignore_help_classes
);
723 /* Ensure that readline does the right thing
724 with respect to inserting quotes. */
725 rl_completer_word_break_characters
=
726 gdb_completer_command_word_break_characters
;
729 else if (reason
== handle_help
)
733 /* There is non-whitespace beyond the command. */
735 if (c
->prefixlist
&& !c
->allow_unknown
)
737 /* It is an unrecognized subcommand of a prefix command,
738 e.g. "info adsfkdj". */
743 if (reason
!= handle_brkchars
)
744 list
= complete_on_enum (c
->enums
, p
, word
);
748 /* It is a normal command. */
749 if (c
->completer
== filename_completer
)
751 /* See the commentary above about the specifics
752 of file-name completion. */
755 && strchr (gdb_completer_file_name_break_characters
,
759 rl_completer_word_break_characters
=
760 gdb_completer_file_name_break_characters
;
762 else if (c
->completer
== location_completer
)
766 && p
[-1] != ' ' && p
[-1] != '\t';
770 if (reason
== handle_brkchars
771 && c
->completer_handle_brkchars
!= NULL
)
772 (*c
->completer_handle_brkchars
) (c
, p
, word
);
773 if (reason
!= handle_brkchars
&& c
->completer
!= NULL
)
774 list
= (*c
->completer
) (c
, p
, word
);
781 /* Generate completions all at once. Returns a vector of strings.
782 Each element is allocated with xmalloc. It can also return NULL if
783 there are no completions.
785 TEXT is the caller's idea of the "word" we are looking at.
787 LINE_BUFFER is available to be looked at; it contains the entire
790 POINT is the offset in that line of the cursor. You
791 should pretend that the line ends at POINT. */
794 complete_line (const char *text
, const char *line_buffer
, int point
)
796 return complete_line_internal (text
, line_buffer
,
797 point
, handle_completions
);
800 /* Complete on command names. Used by "help". */
802 command_completer (struct cmd_list_element
*ignore
,
803 const char *text
, const char *word
)
805 return complete_line_internal (word
, text
,
806 strlen (text
), handle_help
);
809 /* Complete on signals. */
812 signal_completer (struct cmd_list_element
*ignore
,
813 const char *text
, const char *word
)
815 VEC (char_ptr
) *return_val
= NULL
;
816 size_t len
= strlen (word
);
817 enum gdb_signal signum
;
820 for (signum
= GDB_SIGNAL_FIRST
; signum
!= GDB_SIGNAL_LAST
; ++signum
)
822 /* Can't handle this, so skip it. */
823 if (signum
== GDB_SIGNAL_0
)
826 signame
= gdb_signal_to_name (signum
);
828 /* Ignore the unknown signal case. */
829 if (!signame
|| strcmp (signame
, "?") == 0)
832 if (strncasecmp (signame
, word
, len
) == 0)
833 VEC_safe_push (char_ptr
, return_val
, xstrdup (signame
));
839 /* Get the list of chars that are considered as word breaks
840 for the current command. */
843 gdb_completion_word_break_characters (void)
845 VEC (char_ptr
) *list
;
847 list
= complete_line_internal (rl_line_buffer
, rl_line_buffer
, rl_point
,
849 gdb_assert (list
== NULL
);
850 return rl_completer_word_break_characters
;
853 /* Generate completions one by one for the completer. Each time we
854 are called return another potential completion to the caller.
855 line_completion just completes on commands or passes the buck to
856 the command's completer function, the stuff specific to symbol
857 completion is in make_symbol_completion_list.
859 TEXT is the caller's idea of the "word" we are looking at.
861 MATCHES is the number of matches that have currently been collected
862 from calling this completion function. When zero, then we need to
863 initialize, otherwise the initialization has already taken place
864 and we can just return the next potential completion string.
866 LINE_BUFFER is available to be looked at; it contains the entire
867 text of the line. POINT is the offset in that line of the cursor.
868 You should pretend that the line ends at POINT.
870 Returns NULL if there are no more completions, else a pointer to a
871 string which is a possible completion, it is the caller's
872 responsibility to free the string. */
875 line_completion_function (const char *text
, int matches
,
876 char *line_buffer
, int point
)
878 static VEC (char_ptr
) *list
= NULL
; /* Cache of completions. */
879 static int index
; /* Next cached completion. */
884 /* The caller is beginning to accumulate a new set of
885 completions, so we need to find all of them now, and cache
886 them for returning one at a time on future calls. */
890 /* Free the storage used by LIST, but not by the strings
891 inside. This is because rl_complete_internal () frees
892 the strings. As complete_line may abort by calling
893 `error' clear LIST now. */
894 VEC_free (char_ptr
, list
);
897 list
= complete_line (text
, line_buffer
, point
);
900 /* If we found a list of potential completions during initialization
901 then dole them out one at a time. After returning the last one,
902 return NULL (and continue to do so) each time we are called after
903 that, until a new list is available. */
907 if (index
< VEC_length (char_ptr
, list
))
909 output
= VEC_index (char_ptr
, list
, index
);
915 /* Can't do this because readline hasn't yet checked the word breaks
916 for figuring out whether to insert a quote. */
918 /* Make sure the word break characters are set back to normal for
919 the next time that readline tries to complete something. */
920 rl_completer_word_break_characters
=
921 current_language
->la_word_break_characters();
927 /* Skip over the possibly quoted word STR (as defined by the quote
928 characters QUOTECHARS and the word break characters BREAKCHARS).
929 Returns pointer to the location after the "word". If either
930 QUOTECHARS or BREAKCHARS is NULL, use the same values used by the
934 skip_quoted_chars (const char *str
, const char *quotechars
,
935 const char *breakchars
)
937 char quote_char
= '\0';
940 if (quotechars
== NULL
)
941 quotechars
= gdb_completer_quote_characters
;
943 if (breakchars
== NULL
)
944 breakchars
= current_language
->la_word_break_characters();
946 for (scan
= str
; *scan
!= '\0'; scan
++)
948 if (quote_char
!= '\0')
950 /* Ignore everything until the matching close quote char. */
951 if (*scan
== quote_char
)
953 /* Found matching close quote. */
958 else if (strchr (quotechars
, *scan
))
960 /* Found start of a quoted string. */
963 else if (strchr (breakchars
, *scan
))
972 /* Skip over the possibly quoted word STR (as defined by the quote
973 characters and word break characters used by the completer).
974 Returns pointer to the location after the "word". */
977 skip_quoted (const char *str
)
979 return skip_quoted_chars (str
, NULL
, NULL
);