1 /* bashline.c -- Bash's interface to the readline library. */
3 /* Copyright (C) 1987-2013 Free Software Foundation, Inc.
5 This file is part of GNU Bash, the Bourne Again SHell.
7 Bash is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 Bash is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with Bash. If not, see <http://www.gnu.org/licenses/>.
23 #if defined (READLINE)
25 #include "bashtypes.h"
26 #include "posixstat.h"
28 #if defined (HAVE_UNISTD_H)
32 #if defined (HAVE_GRP_H)
36 #if defined (HAVE_NETDB_H)
43 #include "chartypes.h"
52 #include "execute_cmd.h"
58 #include "builtins/common.h"
60 #include <readline/rlconf.h>
61 #include <readline/readline.h>
62 #include <readline/history.h>
64 #include <glob/glob.h>
70 #if defined (PROGRAMMABLE_COMPLETION)
71 # include "pcomplete.h"
74 /* These should agree with the defines for emacs_mode and vi_mode in
75 rldefs.h, even though that's not a public readline header file. */
76 #ifndef EMACS_EDITING_MODE
77 # define NO_EDITING_MODE -1
78 # define EMACS_EDITING_MODE 1
79 # define VI_EDITING_MODE 0
82 #define RL_BOOLEAN_VARIABLE_VALUE(s) ((s)[0] == 'o' && (s)[1] == 'n' && (s)[2] == '\0')
84 #if defined (BRACE_COMPLETION)
85 extern int bash_brace_completion
__P((int, int));
86 #endif /* BRACE_COMPLETION */
88 /* To avoid including curses.h/term.h/termcap.h and that whole mess. */
90 extern int tputs
__P((const char *string
, int nlines
, void (*outx
)(int)));
92 extern int tputs
__P((const char *string
, int nlines
, int (*outx
)(int)));
95 /* Forward declarations */
97 /* Functions bound to keys in Readline for Bash users. */
98 static int shell_expand_line
__P((int, int));
99 static int display_shell_version
__P((int, int));
100 static int operate_and_get_next
__P((int, int));
102 static int bash_ignore_filenames
__P((char **));
103 static int bash_ignore_everything
__P((char **));
105 #if defined (BANG_HISTORY)
106 static char *history_expand_line_internal
__P((char *));
107 static int history_expand_line
__P((int, int));
108 static int tcsh_magic_space
__P((int, int));
109 #endif /* BANG_HISTORY */
111 static int alias_expand_line
__P((int, int));
113 #if defined (BANG_HISTORY) && defined (ALIAS)
114 static int history_and_alias_expand_line
__P((int, int));
117 static int bash_forward_shellword
__P((int, int));
118 static int bash_backward_shellword
__P((int, int));
119 static int bash_kill_shellword
__P((int, int));
120 static int bash_backward_kill_shellword
__P((int, int));
122 /* Helper functions for Readline. */
123 static char *restore_tilde
__P((char *, char *));
124 static char *maybe_restore_tilde
__P((char *, char *));
126 static char *bash_filename_rewrite_hook
__P((char *, int));
128 static void bash_directory_expansion
__P((char **));
129 static int bash_filename_stat_hook
__P((char **));
130 static int bash_command_name_stat_hook
__P((char **));
131 static int bash_directory_completion_hook
__P((char **));
132 static int filename_completion_ignore
__P((char **));
133 static int bash_push_line
__P((void));
135 static int executable_completion
__P((const char *, int));
137 static rl_icppfunc_t
*save_directory_hook
__P((void));
138 static void restore_directory_hook
__P((rl_icppfunc_t
));
140 static void cleanup_expansion_error
__P((void));
141 static void maybe_make_readline_line
__P((char *));
142 static void set_up_new_line
__P((char *));
144 static int check_redir
__P((int));
145 static char **attempt_shell_completion
__P((const char *, int, int));
146 static char *variable_completion_function
__P((const char *, int));
147 static char *hostname_completion_function
__P((const char *, int));
148 static char *command_subst_completion_function
__P((const char *, int));
150 static void build_history_completion_array
__P((void));
151 static char *history_completion_generator
__P((const char *, int));
152 static int dynamic_complete_history
__P((int, int));
153 static int bash_dabbrev_expand
__P((int, int));
155 static void initialize_hostname_list
__P((void));
156 static void add_host_name
__P((char *));
157 static void snarf_hosts_from_file
__P((char *));
158 static char **hostnames_matching
__P((char *));
160 static void _ignore_completion_names
__P((char **, sh_ignore_func_t
*));
161 static int name_is_acceptable
__P((const char *));
162 static int test_for_directory
__P((const char *));
163 static int return_zero
__P((const char *));
165 static char *bash_dequote_filename
__P((char *, int));
166 static char *quote_word_break_chars
__P((char *));
167 static void set_filename_bstab
__P((const char *));
168 static char *bash_quote_filename
__P((char *, int, char *));
171 static void putx
__P((int));
173 static int putx
__P((int));
175 static int bash_execute_unix_command
__P((int, int));
176 static void init_unix_command_map
__P((void));
177 static int isolate_sequence
__P((char *, int, int, int *));
179 static int set_saved_history
__P((void));
182 static int posix_edit_macros
__P((int, int));
185 static int bash_event_hook
__P((void));
187 #if defined (PROGRAMMABLE_COMPLETION)
188 static int find_cmd_start
__P((int));
189 static int find_cmd_end
__P((int));
190 static char *find_cmd_name
__P((int, int *, int *));
191 static char *prog_complete_return
__P((const char *, int));
193 static char **prog_complete_matches
;
196 /* Variables used here but defined in other files. */
197 #if defined (BANG_HISTORY)
198 extern int hist_verify
;
201 extern int current_command_line_count
, saved_command_line_count
;
202 extern int last_command_exit_value
;
203 extern int array_needs_making
;
204 extern int posixly_correct
, no_symbolic_links
;
205 extern int sigalrm_seen
;
206 extern char *current_prompt_string
, *ps1_prompt
;
207 extern STRING_INT_ALIST word_token_alist
[];
208 extern sh_builtin_func_t
*last_shell_builtin
, *this_shell_builtin
;
210 /* SPECIFIC_COMPLETION_FUNCTIONS specifies that we have individual
211 completion functions which indicate what type of completion should be
212 done (at or before point) that can be bound to key sequences with
213 the readline library. */
214 #define SPECIFIC_COMPLETION_FUNCTIONS
216 #if defined (SPECIFIC_COMPLETION_FUNCTIONS)
217 static int bash_specific_completion
__P((int, rl_compentry_func_t
*));
219 static int bash_complete_filename_internal
__P((int));
220 static int bash_complete_username_internal
__P((int));
221 static int bash_complete_hostname_internal
__P((int));
222 static int bash_complete_variable_internal
__P((int));
223 static int bash_complete_command_internal
__P((int));
225 static int bash_complete_filename
__P((int, int));
226 static int bash_possible_filename_completions
__P((int, int));
227 static int bash_complete_username
__P((int, int));
228 static int bash_possible_username_completions
__P((int, int));
229 static int bash_complete_hostname
__P((int, int));
230 static int bash_possible_hostname_completions
__P((int, int));
231 static int bash_complete_variable
__P((int, int));
232 static int bash_possible_variable_completions
__P((int, int));
233 static int bash_complete_command
__P((int, int));
234 static int bash_possible_command_completions
__P((int, int));
236 static char *glob_complete_word
__P((const char *, int));
237 static int bash_glob_completion_internal
__P((int));
238 static int bash_glob_complete_word
__P((int, int));
239 static int bash_glob_expand_word
__P((int, int));
240 static int bash_glob_list_expansions
__P((int, int));
242 #endif /* SPECIFIC_COMPLETION_FUNCTIONS */
244 static int edit_and_execute_command
__P((int, int, int, char *));
245 #if defined (VI_MODE)
246 static int vi_edit_and_execute_command
__P((int, int));
247 static int bash_vi_complete
__P((int, int));
249 static int emacs_edit_and_execute_command
__P((int, int));
251 /* Non-zero once initalize_readline () has been called. */
252 int bash_readline_initialized
= 0;
254 /* If non-zero, we do hostname completion, breaking words at `@' and
255 trying to complete the stuff after the `@' from our own internal
257 int perform_hostname_completion
= 1;
259 /* If non-zero, we don't do command completion on an empty line. */
260 int no_empty_command_completion
;
262 /* Set FORCE_FIGNORE if you want to honor FIGNORE even if it ignores the
263 only possible matches. Set to 0 if you want to match filenames if they
264 are the only possible matches, even if FIGNORE says to. */
265 int force_fignore
= 1;
267 /* Perform spelling correction on directory names during word completion */
268 int dircomplete_spelling
= 0;
270 /* Expand directory names during word/filename completion. */
271 #if DIRCOMPLETE_EXPAND_DEFAULT
272 int dircomplete_expand
= 1;
273 int dircomplete_expand_relpath
= 1;
275 int dircomplete_expand
= 0;
276 int dircomplete_expand_relpath
= 0;
279 /* When non-zero, perform `normal' shell quoting on completed filenames
280 even when the completed name contains a directory name with a shell
281 variable referene, so dollar signs in a filename get quoted appropriately.
282 Set to zero to remove dollar sign (and braces or parens as needed) from
283 the set of characters that will be quoted. */
284 int complete_fullquote
= 1;
286 static char *bash_completer_word_break_characters
= " \t\n\"'@><=;|&(:";
287 static char *bash_nohostname_word_break_characters
= " \t\n\"'><=;|&(:";
290 static const char *default_filename_quote_characters
= " \t\n\\\"'@<>=;|&()#$`?*[!:{~"; /*}*/
291 static char *custom_filename_quote_characters
= 0;
292 static char filename_bstab
[256];
294 static rl_hook_func_t
*old_rl_startup_hook
= (rl_hook_func_t
*)NULL
;
296 static int dot_in_path
= 0;
298 /* Set to non-zero when dabbrev-expand is running */
299 static int dabbrev_expand_active
= 0;
301 /* What kind of quoting is performed by bash_quote_filename:
302 COMPLETE_DQUOTE = double-quoting the filename
303 COMPLETE_SQUOTE = single_quoting the filename
304 COMPLETE_BSQUOTE = backslash-quoting special chars in the filename
306 #define COMPLETE_DQUOTE 1
307 #define COMPLETE_SQUOTE 2
308 #define COMPLETE_BSQUOTE 3
309 static int completion_quoting_style
= COMPLETE_BSQUOTE
;
311 /* Flag values for the final argument to bash_default_completion */
312 #define DEFCOMP_CMDPOS 1
314 /* Change the readline VI-mode keymaps into or out of Posix.2 compliance.
315 Called when the shell is put into or out of `posix' mode. */
317 posix_readline_initialize (on_or_off
)
321 rl_variable_bind ("comment-begin", "#");
322 #if defined (VI_MODE)
323 rl_bind_key_in_map (CTRL ('I'), on_or_off
? rl_insert
: rl_complete
, vi_insertion_keymap
);
328 reset_completer_word_break_chars ()
330 rl_completer_word_break_characters
= perform_hostname_completion
? savestring (bash_completer_word_break_characters
) : savestring (bash_nohostname_word_break_characters
);
333 /* When this function returns, rl_completer_word_break_characters points to
334 dynamically allocated memory. */
336 enable_hostname_completion (on_or_off
)
340 char *at
, *nv
, *nval
;
342 old_value
= perform_hostname_completion
;
346 perform_hostname_completion
= 1;
347 rl_special_prefixes
= "$@";
351 perform_hostname_completion
= 0;
352 rl_special_prefixes
= "$";
355 /* Now we need to figure out how to appropriately modify and assign
356 rl_completer_word_break_characters depending on whether we want
357 hostname completion on or off. */
359 /* If this is the first time this has been called
360 (bash_readline_initialized == 0), use the sames values as before, but
361 allocate new memory for rl_completer_word_break_characters. */
363 if (bash_readline_initialized
== 0 &&
364 (rl_completer_word_break_characters
== 0 ||
365 rl_completer_word_break_characters
== rl_basic_word_break_characters
))
368 rl_completer_word_break_characters
= savestring (bash_completer_word_break_characters
);
370 rl_completer_word_break_characters
= savestring (bash_nohostname_word_break_characters
);
374 /* See if we have anything to do. */
375 at
= strchr (rl_completer_word_break_characters
, '@');
376 if ((at
== 0 && on_or_off
== 0) || (at
!= 0 && on_or_off
!= 0))
379 /* We have something to do. Do it. */
380 nval
= (char *)xmalloc (strlen (rl_completer_word_break_characters
) + 1 + on_or_off
);
384 /* Turn it off -- just remove `@' from word break chars. We want
385 to remove all occurrences of `@' from the char list, so we loop
386 rather than just copy the rest of the list over AT. */
387 for (nv
= nval
, at
= rl_completer_word_break_characters
; *at
; )
397 strcpy (nval
+ 1, rl_completer_word_break_characters
);
400 free (rl_completer_word_break_characters
);
401 rl_completer_word_break_characters
= nval
;
407 /* Called once from parse.y if we are going to use readline. */
409 initialize_readline ()
411 rl_command_func_t
*func
;
414 if (bash_readline_initialized
)
417 rl_terminal_name
= get_string_value ("TERM");
419 rl_outstream
= stderr
;
421 /* Allow conditional parsing of the ~/.inputrc file. */
422 rl_readline_name
= "Bash";
424 /* Add bindable names before calling rl_initialize so they may be
425 referenced in the various inputrc files. */
426 rl_add_defun ("shell-expand-line", shell_expand_line
, -1);
428 rl_add_defun ("history-expand-line", history_expand_line
, -1);
429 rl_add_defun ("magic-space", tcsh_magic_space
, -1);
432 rl_add_defun ("shell-forward-word", bash_forward_shellword
, -1);
433 rl_add_defun ("shell-backward-word", bash_backward_shellword
, -1);
434 rl_add_defun ("shell-kill-word", bash_kill_shellword
, -1);
435 rl_add_defun ("shell-backward-kill-word", bash_backward_kill_shellword
, -1);
438 rl_add_defun ("alias-expand-line", alias_expand_line
, -1);
440 rl_add_defun ("history-and-alias-expand-line", history_and_alias_expand_line
, -1);
444 /* Backwards compatibility. */
445 rl_add_defun ("insert-last-argument", rl_yank_last_arg
, -1);
447 rl_add_defun ("operate-and-get-next", operate_and_get_next
, -1);
448 rl_add_defun ("display-shell-version", display_shell_version
, -1);
449 rl_add_defun ("edit-and-execute-command", emacs_edit_and_execute_command
, -1);
451 #if defined (BRACE_COMPLETION)
452 rl_add_defun ("complete-into-braces", bash_brace_completion
, -1);
455 #if defined (SPECIFIC_COMPLETION_FUNCTIONS)
456 rl_add_defun ("complete-filename", bash_complete_filename
, -1);
457 rl_add_defun ("possible-filename-completions", bash_possible_filename_completions
, -1);
458 rl_add_defun ("complete-username", bash_complete_username
, -1);
459 rl_add_defun ("possible-username-completions", bash_possible_username_completions
, -1);
460 rl_add_defun ("complete-hostname", bash_complete_hostname
, -1);
461 rl_add_defun ("possible-hostname-completions", bash_possible_hostname_completions
, -1);
462 rl_add_defun ("complete-variable", bash_complete_variable
, -1);
463 rl_add_defun ("possible-variable-completions", bash_possible_variable_completions
, -1);
464 rl_add_defun ("complete-command", bash_complete_command
, -1);
465 rl_add_defun ("possible-command-completions", bash_possible_command_completions
, -1);
466 rl_add_defun ("glob-complete-word", bash_glob_complete_word
, -1);
467 rl_add_defun ("glob-expand-word", bash_glob_expand_word
, -1);
468 rl_add_defun ("glob-list-expansions", bash_glob_list_expansions
, -1);
471 rl_add_defun ("dynamic-complete-history", dynamic_complete_history
, -1);
472 rl_add_defun ("dabbrev-expand", bash_dabbrev_expand
, -1);
474 /* Bind defaults before binding our custom shell keybindings. */
475 if (RL_ISSTATE(RL_STATE_INITIALIZED
) == 0)
478 /* Bind up our special shell functions. */
479 rl_bind_key_if_unbound_in_map (CTRL('E'), shell_expand_line
, emacs_meta_keymap
);
482 rl_bind_key_if_unbound_in_map ('^', history_expand_line
, emacs_meta_keymap
);
485 rl_bind_key_if_unbound_in_map (CTRL ('O'), operate_and_get_next
, emacs_standard_keymap
);
486 rl_bind_key_if_unbound_in_map (CTRL ('V'), display_shell_version
, emacs_ctlx_keymap
);
488 /* In Bash, the user can switch editing modes with "set -o [vi emacs]",
489 so it is not necessary to allow C-M-j for context switching. Turn
490 off this occasionally confusing behaviour. */
493 func
= rl_function_of_keyseq (kseq
, emacs_meta_keymap
, (int *)NULL
);
494 if (func
== rl_vi_editing_mode
)
495 rl_unbind_key_in_map (CTRL('J'), emacs_meta_keymap
);
497 func
= rl_function_of_keyseq (kseq
, emacs_meta_keymap
, (int *)NULL
);
498 if (func
== rl_vi_editing_mode
)
499 rl_unbind_key_in_map (CTRL('M'), emacs_meta_keymap
);
500 #if defined (VI_MODE)
501 rl_unbind_key_in_map (CTRL('E'), vi_movement_keymap
);
504 #if defined (BRACE_COMPLETION)
505 rl_bind_key_if_unbound_in_map ('{', bash_brace_completion
, emacs_meta_keymap
); /*}*/
506 #endif /* BRACE_COMPLETION */
508 #if defined (SPECIFIC_COMPLETION_FUNCTIONS)
509 rl_bind_key_if_unbound_in_map ('/', bash_complete_filename
, emacs_meta_keymap
);
510 rl_bind_key_if_unbound_in_map ('/', bash_possible_filename_completions
, emacs_ctlx_keymap
);
512 /* Have to jump through hoops here because there is a default binding for
513 M-~ (rl_tilde_expand) */
516 func
= rl_function_of_keyseq (kseq
, emacs_meta_keymap
, (int *)NULL
);
517 if (func
== 0 || func
== rl_tilde_expand
)
518 rl_bind_keyseq_in_map (kseq
, bash_complete_username
, emacs_meta_keymap
);
520 rl_bind_key_if_unbound_in_map ('~', bash_possible_username_completions
, emacs_ctlx_keymap
);
522 rl_bind_key_if_unbound_in_map ('@', bash_complete_hostname
, emacs_meta_keymap
);
523 rl_bind_key_if_unbound_in_map ('@', bash_possible_hostname_completions
, emacs_ctlx_keymap
);
525 rl_bind_key_if_unbound_in_map ('$', bash_complete_variable
, emacs_meta_keymap
);
526 rl_bind_key_if_unbound_in_map ('$', bash_possible_variable_completions
, emacs_ctlx_keymap
);
528 rl_bind_key_if_unbound_in_map ('!', bash_complete_command
, emacs_meta_keymap
);
529 rl_bind_key_if_unbound_in_map ('!', bash_possible_command_completions
, emacs_ctlx_keymap
);
531 rl_bind_key_if_unbound_in_map ('g', bash_glob_complete_word
, emacs_meta_keymap
);
532 rl_bind_key_if_unbound_in_map ('*', bash_glob_expand_word
, emacs_ctlx_keymap
);
533 rl_bind_key_if_unbound_in_map ('g', bash_glob_list_expansions
, emacs_ctlx_keymap
);
535 #endif /* SPECIFIC_COMPLETION_FUNCTIONS */
539 func
= rl_function_of_keyseq (kseq
, emacs_meta_keymap
, (int *)NULL
);
540 if (func
== 0 || func
== rl_tab_insert
)
541 rl_bind_key_in_map (TAB
, dynamic_complete_history
, emacs_meta_keymap
);
543 /* Tell the completer that we want a crack first. */
544 rl_attempted_completion_function
= attempt_shell_completion
;
546 /* Tell the completer that we might want to follow symbolic links or
547 do other expansion on directory names. */
548 set_directory_hook ();
550 rl_filename_rewrite_hook
= bash_filename_rewrite_hook
;
552 rl_filename_stat_hook
= bash_filename_stat_hook
;
554 /* Tell the filename completer we want a chance to ignore some names. */
555 rl_ignore_some_completions_function
= filename_completion_ignore
;
557 /* Bind C-xC-e to invoke emacs and run result as commands. */
558 rl_bind_key_if_unbound_in_map (CTRL ('E'), emacs_edit_and_execute_command
, emacs_ctlx_keymap
);
559 #if defined (VI_MODE)
560 rl_bind_key_if_unbound_in_map ('v', vi_edit_and_execute_command
, vi_movement_keymap
);
562 rl_bind_key_if_unbound_in_map ('@', posix_edit_macros
, vi_movement_keymap
);
565 rl_bind_key_in_map ('\\', bash_vi_complete
, vi_movement_keymap
);
566 rl_bind_key_in_map ('*', bash_vi_complete
, vi_movement_keymap
);
567 rl_bind_key_in_map ('=', bash_vi_complete
, vi_movement_keymap
);
570 rl_completer_quote_characters
= "'\"";
572 /* This sets rl_completer_word_break_characters and rl_special_prefixes
573 to the appropriate values, depending on whether or not hostname
574 completion is enabled. */
575 enable_hostname_completion (perform_hostname_completion
);
577 /* characters that need to be quoted when appearing in filenames. */
578 rl_filename_quote_characters
= default_filename_quote_characters
;
579 set_filename_bstab (rl_filename_quote_characters
);
581 rl_filename_quoting_function
= bash_quote_filename
;
582 rl_filename_dequoting_function
= bash_dequote_filename
;
583 rl_char_is_quoted_p
= char_is_quoted
;
586 /* This is superfluous and makes it impossible to use tab completion in
587 vi mode even when explicitly binding it in ~/.inputrc. sv_strict_posix()
588 should already have called posix_readline_initialize() when
589 posixly_correct was set. */
591 posix_readline_initialize (1);
594 bash_readline_initialized
= 1;
598 bashline_reinitialize ()
600 bash_readline_initialized
= 0;
604 bashline_set_event_hook ()
606 rl_signal_event_hook
= bash_event_hook
;
610 bashline_reset_event_hook ()
612 rl_signal_event_hook
= 0;
615 /* On Sun systems at least, rl_attempted_completion_function can end up
616 getting set to NULL, and rl_completion_entry_function set to do command
617 word completion if Bash is interrupted while trying to complete a command
618 word. This just resets all the completion functions to the right thing.
619 It's called from throw_to_top_level(). */
624 rl_attempted_completion_function
= attempt_shell_completion
;
625 rl_completion_entry_function
= NULL
;
626 rl_ignore_some_completions_function
= filename_completion_ignore
;
627 rl_filename_quote_characters
= default_filename_quote_characters
;
628 set_filename_bstab (rl_filename_quote_characters
);
630 set_directory_hook ();
631 rl_filename_stat_hook
= bash_filename_stat_hook
;
633 bashline_reset_event_hook ();
636 /* Contains the line to push into readline. */
637 static char *push_to_readline
= (char *)NULL
;
639 /* Push the contents of push_to_readline into the
644 if (push_to_readline
)
646 rl_insert_text (push_to_readline
);
647 free (push_to_readline
);
648 push_to_readline
= (char *)NULL
;
649 rl_startup_hook
= old_rl_startup_hook
;
654 /* Call this to set the initial text for the next line to read
660 FREE (push_to_readline
);
662 push_to_readline
= savestring (line
);
663 old_rl_startup_hook
= rl_startup_hook
;
664 rl_startup_hook
= bash_push_line
;
670 display_shell_version (count
, c
)
674 show_shell_version (0);
675 putc ('\r', rl_outstream
);
676 fflush (rl_outstream
);
682 /* **************************************************************** */
686 /* **************************************************************** */
688 /* If the user requests hostname completion, then simply build a list
689 of hosts, and complete from that forever more, or at least until
690 HOSTFILE is unset. */
692 /* THIS SHOULD BE A STRINGLIST. */
693 /* The kept list of hostnames. */
694 static char **hostname_list
= (char **)NULL
;
696 /* The physical size of the above list. */
697 static int hostname_list_size
;
699 /* The number of hostnames in the above list. */
700 static int hostname_list_length
;
702 /* Whether or not HOSTNAME_LIST has been initialized. */
703 int hostname_list_initialized
= 0;
705 /* Initialize the hostname completion table. */
707 initialize_hostname_list ()
711 temp
= get_string_value ("HOSTFILE");
713 temp
= get_string_value ("hostname_completion_file");
715 temp
= DEFAULT_HOSTS_FILE
;
717 snarf_hosts_from_file (temp
);
720 hostname_list_initialized
++;
723 /* Add NAME to the list of hosts. */
728 if (hostname_list_length
+ 2 > hostname_list_size
)
730 hostname_list_size
= (hostname_list_size
+ 32) - (hostname_list_size
% 32);
731 hostname_list
= strvec_resize (hostname_list
, hostname_list_size
);
734 hostname_list
[hostname_list_length
++] = savestring (name
);
735 hostname_list
[hostname_list_length
] = (char *)NULL
;
738 #define cr_whitespace(c) ((c) == '\r' || (c) == '\n' || whitespace(c))
741 snarf_hosts_from_file (filename
)
745 char *temp
, buffer
[256], name
[256];
746 register int i
, start
;
748 file
= fopen (filename
, "r");
752 while (temp
= fgets (buffer
, 255, file
))
754 /* Skip to first character. */
755 for (i
= 0; buffer
[i
] && cr_whitespace (buffer
[i
]); i
++)
758 /* If comment or blank line, ignore. */
759 if (buffer
[i
] == '\0' || buffer
[i
] == '#')
762 /* If `preprocessor' directive, do the include. */
763 if (strncmp (buffer
+ i
, "$include ", 9) == 0)
767 /* Find start of filename. */
768 for (incfile
= buffer
+ i
+ 9; *incfile
&& whitespace (*incfile
); incfile
++)
771 /* Find end of filename. */
772 for (t
= incfile
; *t
&& cr_whitespace (*t
) == 0; t
++)
777 snarf_hosts_from_file (incfile
);
781 /* Skip internet address if present. */
782 if (DIGIT (buffer
[i
]))
783 for (; buffer
[i
] && cr_whitespace (buffer
[i
]) == 0; i
++);
785 /* Gobble up names. Each name is separated with whitespace. */
788 for (; cr_whitespace (buffer
[i
]); i
++)
790 if (buffer
[i
] == '\0' || buffer
[i
] == '#')
793 /* Isolate the current word. */
794 for (start
= i
; buffer
[i
] && cr_whitespace (buffer
[i
]) == 0; i
++)
798 strncpy (name
, buffer
+ start
, i
- start
);
799 name
[i
- start
] = '\0';
800 add_host_name (name
);
806 /* Return the hostname list. */
810 if (hostname_list_initialized
== 0)
811 initialize_hostname_list ();
812 return (hostname_list
);
816 clear_hostname_list ()
820 if (hostname_list_initialized
== 0)
822 for (i
= 0; i
< hostname_list_length
; i
++)
823 free (hostname_list
[i
]);
824 hostname_list_length
= hostname_list_initialized
= 0;
827 /* Return a NULL terminated list of hostnames which begin with TEXT.
828 Initialize the hostname list the first time if necessary.
829 The array is malloc ()'ed, but not the individual strings. */
831 hostnames_matching (text
)
834 register int i
, len
, nmatch
, rsize
;
837 if (hostname_list_initialized
== 0)
838 initialize_hostname_list ();
840 if (hostname_list_initialized
== 0)
841 return ((char **)NULL
);
843 /* Special case. If TEXT consists of nothing, then the whole list is
847 result
= strvec_create (1 + hostname_list_length
);
848 for (i
= 0; i
< hostname_list_length
; i
++)
849 result
[i
] = hostname_list
[i
];
850 result
[i
] = (char *)NULL
;
854 /* Scan until found, or failure. */
856 result
= (char **)NULL
;
857 for (i
= nmatch
= rsize
= 0; i
< hostname_list_length
; i
++)
859 if (STREQN (text
, hostname_list
[i
], len
) == 0)
862 /* OK, it matches. Add it to the list. */
863 if (nmatch
>= (rsize
- 1))
865 rsize
= (rsize
+ 16) - (rsize
% 16);
866 result
= strvec_resize (result
, rsize
);
869 result
[nmatch
++] = hostname_list
[i
];
872 result
[nmatch
] = (char *)NULL
;
876 /* The equivalent of the Korn shell C-o operate-and-get-next-history-line
878 static int saved_history_line_to_use
= -1;
879 static int last_saved_history_line
= -1;
881 #define HISTORY_FULL() (history_is_stifled () && history_length >= history_max_entries)
886 /* XXX - compensate for assumption that history was `shuffled' if it was
888 if (HISTORY_FULL () &&
889 hist_last_line_added
== 0 &&
890 saved_history_line_to_use
< history_length
- 1)
891 saved_history_line_to_use
++;
893 if (saved_history_line_to_use
>= 0)
895 rl_get_previous_history (history_length
- saved_history_line_to_use
, 0);
896 last_saved_history_line
= saved_history_line_to_use
;
898 saved_history_line_to_use
= -1;
899 rl_startup_hook
= old_rl_startup_hook
;
904 operate_and_get_next (count
, c
)
909 /* Accept the current line. */
912 /* Find the current line, and find the next line to use. */
913 where
= where_history ();
915 if (HISTORY_FULL () || (where
>= history_length
- 1))
916 saved_history_line_to_use
= where
;
918 saved_history_line_to_use
= where
+ 1;
920 old_rl_startup_hook
= rl_startup_hook
;
921 rl_startup_hook
= set_saved_history
;
926 /* This vi mode command causes VI_EDIT_COMMAND to be run on the current
927 command being entered (if no explicit argument is given), otherwise on
928 a command from the history file. */
930 #define VI_EDIT_COMMAND "fc -e \"${VISUAL:-${EDITOR:-vi}}\""
931 #define EMACS_EDIT_COMMAND "fc -e \"${VISUAL:-${EDITOR:-emacs}}\""
932 #define POSIX_VI_EDIT_COMMAND "fc -e vi"
935 edit_and_execute_command (count
, c
, editing_mode
, edit_command
)
936 int count
, c
, editing_mode
;
939 char *command
, *metaval
;
940 int r
, rrs
, metaflag
;
941 sh_parser_state_t ps
;
943 rrs
= rl_readline_state
;
944 saved_command_line_count
= current_command_line_count
;
946 /* Accept the current line. */
951 command
= (char *)xmalloc (strlen (edit_command
) + 8);
952 sprintf (command
, "%s %d", edit_command
, count
);
956 /* Take the command we were just editing, add it to the history file,
957 then call fc to operate on it. We have to add a dummy command to
958 the end of the history because fc ignores the last command (assumes
959 it's supposed to deal with the command before the `fc'). */
960 /* This breaks down when using command-oriented history and are not
961 finished with the command, so we should not ignore the last command */
963 current_command_line_count
++; /* for rl_newline above */
964 bash_add_history (rl_line_buffer
);
965 current_command_line_count
= 0; /* for dummy history entry */
966 bash_add_history ("");
967 history_lines_this_session
++;
969 command
= savestring (edit_command
);
972 metaval
= rl_variable_value ("input-meta");
973 metaflag
= RL_BOOLEAN_VARIABLE_VALUE (metaval
);
975 /* Now, POSIX.1-2001 and SUSv3 say that the commands executed from the
976 temporary file should be placed into the history. We don't do that
978 if (rl_deprep_term_function
)
979 (*rl_deprep_term_function
) ();
980 save_parser_state (&ps
);
981 r
= parse_and_execute (command
, (editing_mode
== VI_EDITING_MODE
) ? "v" : "C-xC-e", SEVAL_NOHIST
);
982 restore_parser_state (&ps
);
983 if (rl_prep_term_function
)
984 (*rl_prep_term_function
) (metaflag
);
986 current_command_line_count
= saved_command_line_count
;
988 /* Now erase the contents of the current line and undo the effects of the
989 rl_accept_line() above. We don't even want to make the text we just
990 executed available for undoing. */
991 rl_line_buffer
[0] = '\0'; /* XXX */
992 rl_point
= rl_end
= 0;
994 rl_readline_state
= rrs
;
996 rl_forced_update_display ();
1001 #if defined (VI_MODE)
1003 vi_edit_and_execute_command (count
, c
)
1006 if (posixly_correct
)
1007 return (edit_and_execute_command (count
, c
, VI_EDITING_MODE
, POSIX_VI_EDIT_COMMAND
));
1009 return (edit_and_execute_command (count
, c
, VI_EDITING_MODE
, VI_EDIT_COMMAND
));
1011 #endif /* VI_MODE */
1014 emacs_edit_and_execute_command (count
, c
)
1017 return (edit_and_execute_command (count
, c
, EMACS_EDITING_MODE
, EMACS_EDIT_COMMAND
));
1022 posix_edit_macros (count
, key
)
1026 char alias_name
[3], *alias_value
, *macro
;
1029 alias_name
[0] = '_';
1031 alias_name
[2] = '\0';
1033 alias_value
= get_alias_value (alias_name
);
1034 if (alias_value
&& *alias_value
)
1036 macro
= savestring (alias_value
);
1037 rl_push_macro_input (macro
);
1043 /* Bindable commands that move `shell-words': that is, sequences of
1044 non-unquoted-metacharacters. */
1046 #define WORDDELIM(c) (shellmeta(c) || shellblank(c))
1049 bash_forward_shellword (count
, key
)
1057 return (bash_backward_shellword (-count
, key
));
1059 /* The tricky part of this is deciding whether or not the first character
1060 we're on is an unquoted metacharacter. Not completely handled yet. */
1061 /* XXX - need to test this stuff with backslash-escaped shell
1062 metacharacters and unclosed single- and double-quoted strings. */
1075 /* Are we in a quoted string? If we are, move to the end of the quoted
1076 string and continue the outer loop. We only want quoted strings, not
1077 backslash-escaped characters, but char_is_quoted doesn't
1079 if (char_is_quoted (rl_line_buffer
, p
) && p
> 0 && rl_line_buffer
[p
-1] != '\\')
1082 ADVANCE_CHAR (rl_line_buffer
, slen
, p
);
1083 while (p
< rl_end
&& char_is_quoted (rl_line_buffer
, p
));
1088 /* Rest of code assumes we are not in a quoted string. */
1089 /* Move forward until we hit a non-metacharacter. */
1090 while (p
< rl_end
&& (c
= rl_line_buffer
[p
]) && WORDDELIM (c
))
1095 ADVANCE_CHAR (rl_line_buffer
, slen
, p
);
1096 continue; /* straight back to loop, don't increment p */
1098 if (p
< rl_end
&& rl_line_buffer
[p
])
1099 ADVANCE_CHAR (rl_line_buffer
, slen
, p
);
1102 p
= skip_to_delim (rl_line_buffer
, ++p
, "'", SD_NOJMP
);
1105 p
= skip_to_delim (rl_line_buffer
, ++p
, "\"", SD_NOJMP
);
1113 if (rl_line_buffer
[p
] == 0 || p
== rl_end
)
1120 /* Now move forward until we hit a non-quoted metacharacter or EOL */
1121 while (p
< rl_end
&& (c
= rl_line_buffer
[p
]) && WORDDELIM (c
) == 0)
1126 ADVANCE_CHAR (rl_line_buffer
, slen
, p
);
1127 continue; /* straight back to loop, don't increment p */
1129 if (p
< rl_end
&& rl_line_buffer
[p
])
1130 ADVANCE_CHAR (rl_line_buffer
, slen
, p
);
1133 p
= skip_to_delim (rl_line_buffer
, ++p
, "'", SD_NOJMP
);
1136 p
= skip_to_delim (rl_line_buffer
, ++p
, "\"", SD_NOJMP
);
1144 if (p
== rl_end
|| rl_line_buffer
[p
] == 0)
1158 bash_backward_shellword (count
, key
)
1166 return (bash_forward_shellword (-count
, key
));
1179 /* Move backward until we hit a non-metacharacter. */
1182 c
= rl_line_buffer
[p
];
1183 if (WORDDELIM (c
) && char_is_quoted (rl_line_buffer
, p
) == 0)
1184 BACKUP_CHAR (rl_line_buffer
, slen
, p
);
1194 /* Now move backward until we hit a metacharacter or BOL. */
1197 c
= rl_line_buffer
[p
];
1198 if (WORDDELIM (c
) && char_is_quoted (rl_line_buffer
, p
) == 0)
1200 BACKUP_CHAR (rl_line_buffer
, slen
, p
);
1211 bash_kill_shellword (count
, key
)
1217 return (bash_backward_kill_shellword (-count
, key
));
1220 bash_forward_shellword (count
, key
);
1223 rl_kill_text (p
, rl_point
);
1226 if (rl_editing_mode
== 1) /* 1 == emacs_mode */
1233 bash_backward_kill_shellword (count
, key
)
1239 return (bash_kill_shellword (-count
, key
));
1242 bash_backward_shellword (count
, key
);
1245 rl_kill_text (p
, rl_point
);
1247 if (rl_editing_mode
== 1) /* 1 == emacs_mode */
1254 /* **************************************************************** */
1256 /* How To Do Shell Completion */
1258 /* **************************************************************** */
1260 #define COMMAND_SEPARATORS ";|&{(`"
1262 #define COMMAND_SEPARATORS_PLUS_WS ";|&{(` \t"
1265 /* check for redirections and other character combinations that are not
1266 command separators */
1271 register int this_char
, prev_char
;
1273 /* Handle the two character tokens `>&', `<&', and `>|'.
1274 We are not in a command position after one of these. */
1275 this_char
= rl_line_buffer
[ti
];
1276 prev_char
= rl_line_buffer
[ti
- 1];
1278 if ((this_char
== '&' && (prev_char
== '<' || prev_char
== '>')) ||
1279 (this_char
== '|' && prev_char
== '>'))
1281 else if (this_char
== '{' && prev_char
== '$') /*}*/
1284 else if (this_char
== '(' && prev_char
== '$') /*)*/
1286 else if (this_char
== '(' && prev_char
== '<') /*)*/
1288 #if defined (EXTENDED_GLOB)
1289 else if (extended_glob
&& this_char
== '(' && prev_char
== '!') /*)*/
1293 else if (char_is_quoted (rl_line_buffer
, ti
))
1298 #if defined (PROGRAMMABLE_COMPLETION)
1300 * XXX - because of the <= start test, and setting os = s+1, this can
1301 * potentially return os > start. This is probably not what we want to
1302 * happen, but fix later after 2.05a-release.
1305 find_cmd_start (start
)
1308 register int s
, os
, ns
;
1311 /* Flags == SD_NOJMP only because we want to skip over command substitutions
1312 in assignment statements. Have to test whether this affects `standalone'
1313 command substitutions as individual words. */
1314 while (((s
= skip_to_delim (rl_line_buffer
, os
, COMMAND_SEPARATORS
, SD_NOJMP
/*|SD_NOSKIPCMD*/)) <= start
) &&
1317 /* Handle >| token crudely; treat as > not | */
1318 if (rl_line_buffer
[s
] == '|' && rl_line_buffer
[s
-1] == '>')
1320 ns
= skip_to_delim (rl_line_buffer
, s
+1, COMMAND_SEPARATORS
, SD_NOJMP
/*|SD_NOSKIPCMD*/);
1321 if (ns
> start
|| rl_line_buffer
[ns
] == 0)
1337 e
= skip_to_delim (rl_line_buffer
, end
, COMMAND_SEPARATORS
, SD_NOJMP
);
1342 find_cmd_name (start
, sp
, ep
)
1349 for (s
= start
; whitespace (rl_line_buffer
[s
]); s
++)
1352 /* skip until a shell break character */
1353 e
= skip_to_delim (rl_line_buffer
, s
, "()<>;&| \t\n", SD_NOJMP
);
1355 name
= substring (rl_line_buffer
, s
, e
);
1366 prog_complete_return (text
, matchnum
)
1375 if (prog_complete_matches
== 0 || prog_complete_matches
[ind
] == 0)
1376 return (char *)NULL
;
1377 return (prog_complete_matches
[ind
++]);
1380 #endif /* PROGRAMMABLE_COMPLETION */
1382 /* Try and catch completion attempts that are syntax errors or otherwise
1385 invalid_completion (text
, ind
)
1391 /* If we don't catch these here, the next clause will */
1392 if (ind
> 0 && rl_line_buffer
[ind
] == '(' && /*)*/
1393 member (rl_line_buffer
[ind
-1], "$<>"))
1397 while (pind
> 0 && whitespace (rl_line_buffer
[pind
]))
1399 /* If we have only whitespace preceding a paren, it's valid */
1400 if (ind
>= 0 && pind
<= 0 && rl_line_buffer
[ind
] == '(') /*)*/
1402 /* Flag the invalid completions, which are mostly syntax errors */
1403 if (ind
> 0 && rl_line_buffer
[ind
] == '(' && /*)*/
1404 member (rl_line_buffer
[pind
], COMMAND_SEPARATORS
) == 0)
1410 /* Do some completion on TEXT. The indices of TEXT in RL_LINE_BUFFER are
1411 at START and END. Return an array of matches, or NULL if none. */
1413 attempt_shell_completion (text
, start
, end
)
1417 int in_command_position
, ti
, saveti
, qc
, dflags
;
1418 char **matches
, *command_separator_chars
;
1419 #if defined (PROGRAMMABLE_COMPLETION)
1420 int have_progcomps
, was_assignment
;
1423 command_separator_chars
= COMMAND_SEPARATORS
;
1424 matches
= (char **)NULL
;
1425 rl_ignore_some_completions_function
= filename_completion_ignore
;
1427 rl_filename_quote_characters
= default_filename_quote_characters
;
1428 set_filename_bstab (rl_filename_quote_characters
);
1429 set_directory_hook ();
1430 rl_filename_stat_hook
= bash_filename_stat_hook
;
1432 /* Determine if this could be a command word. It is if it appears at
1433 the start of the line (ignoring preceding whitespace), or if it
1434 appears after a character that separates commands. It cannot be a
1435 command word if we aren't at the top-level prompt. */
1439 while ((ti
> -1) && (whitespace (rl_line_buffer
[ti
])))
1443 /* If this is an open quote, maybe we're trying to complete a quoted
1445 if (ti
>= 0 && (rl_line_buffer
[ti
] == '"' || rl_line_buffer
[ti
] == '\''))
1447 qc
= rl_line_buffer
[ti
];
1449 while (ti
> -1 && (whitespace (rl_line_buffer
[ti
])))
1454 in_command_position
= 0;
1457 /* Only do command completion at the start of a line when we
1458 are prompting at the top level. */
1459 if (current_prompt_string
== ps1_prompt
)
1460 in_command_position
++;
1461 else if (parser_in_command_position ())
1462 in_command_position
++;
1464 else if (member (rl_line_buffer
[ti
], command_separator_chars
))
1466 in_command_position
++;
1468 if (check_redir (ti
) == 1)
1469 in_command_position
= 0;
1473 /* This still could be in command position. It is possible
1474 that all of the previous words on the line are variable
1478 if (in_command_position
&& invalid_completion (text
, ti
))
1480 rl_attempted_completion_over
= 1;
1481 return ((char **)NULL
);
1484 /* Check that we haven't incorrectly flagged a closed command substitution
1485 as indicating we're in a command position. */
1486 if (in_command_position
&& ti
>= 0 && rl_line_buffer
[ti
] == '`' &&
1487 *text
!= '`' && unclosed_pair (rl_line_buffer
, end
, "`") == 0)
1488 in_command_position
= 0;
1490 /* Special handling for command substitution. If *TEXT is a backquote,
1491 it can be the start or end of an old-style command substitution, or
1492 unmatched. If it's unmatched, both calls to unclosed_pair will
1493 succeed. Don't bother if readline found a single quote and we are
1494 completing on the substring. */
1495 if (*text
== '`' && rl_completion_quote_character
!= '\'' &&
1496 (in_command_position
|| (unclosed_pair (rl_line_buffer
, start
, "`") &&
1497 unclosed_pair (rl_line_buffer
, end
, "`"))))
1498 matches
= rl_completion_matches (text
, command_subst_completion_function
);
1500 #if defined (PROGRAMMABLE_COMPLETION)
1501 /* Attempt programmable completion. */
1502 have_progcomps
= prog_completion_enabled
&& (progcomp_size () > 0);
1503 if (matches
== 0 && (in_command_position
== 0 || text
[0] == '\0') &&
1504 current_prompt_string
== ps1_prompt
)
1506 int s
, e
, s1
, e1
, os
, foundcs
;
1509 /* XXX - don't free the members */
1510 if (prog_complete_matches
)
1511 free (prog_complete_matches
);
1512 prog_complete_matches
= (char **)NULL
;
1516 s
= find_cmd_start (os
);
1517 e
= find_cmd_end (end
);
1520 /* Skip over assignment statements preceding a command name. If we
1521 don't find a command name at all, we can perform command name
1522 completion. If we find a partial command name, we should perform
1523 command name completion on it. */
1525 n
= find_cmd_name (s
, &s1
, &e1
);
1528 while (was_assignment
= assignment (n
, 0));
1529 s
= s1
; /* reset to index where name begins */
1531 /* s == index of where command name begins (reset above)
1532 e == end of current command, may be end of line
1533 s1 = index of where command name begins
1534 e1 == index of where command name ends
1535 start == index of where word to be completed begins
1536 end == index of where word to be completed ends
1537 if (s == start) we are doing command word completion for sure
1538 if (e1 == end) we are at the end of the command name and completing it */
1539 if (start
== 0 && end
== 0 && e
!= 0 && text
[0] == '\0') /* beginning of non-empty line */
1541 else if (start
== end
&& start
== s1
&& e
!= 0 && e1
> end
) /* beginning of command name, leading whitespace */
1543 else if (e
== 0 && e
== s
&& text
[0] == '\0' && have_progcomps
) /* beginning of empty line */
1544 prog_complete_matches
= programmable_completions ("_EmptycmD_", text
, s
, e
, &foundcs
);
1545 else if (start
== end
&& text
[0] == '\0' && s1
> start
&& whitespace (rl_line_buffer
[start
]))
1546 foundcs
= 0; /* whitespace before command name */
1547 else if (e
> s
&& was_assignment
== 0 && e1
== end
&& rl_line_buffer
[e
] == 0 && whitespace (rl_line_buffer
[e
-1]) == 0)
1549 /* not assignment statement, but still want to perform command
1550 completion if we are composing command word. */
1552 in_command_position
= s
== start
&& STREQ (n
, text
); /* XXX */
1554 else if (e
> s
&& was_assignment
== 0 && have_progcomps
)
1556 prog_complete_matches
= programmable_completions (n
, text
, s
, e
, &foundcs
);
1557 /* command completion if programmable completion fails */
1558 in_command_position
= s
== start
&& STREQ (n
, text
); /* XXX */
1560 /* empty command name following command separator */
1561 else if (s
>= e
&& n
[0] == '\0' && text
[0] == '\0' && start
> 0 &&
1562 was_assignment
== 0 && member (rl_line_buffer
[start
-1], COMMAND_SEPARATORS
))
1565 in_command_position
= 1;
1567 else if (s
>= e
&& n
[0] == '\0' && text
[0] == '\0' && start
> 0)
1569 foundcs
= 0; /* empty command name following assignments */
1570 in_command_position
= was_assignment
;
1572 else if (s
== start
&& e
== end
&& STREQ (n
, text
) && start
> 0)
1574 foundcs
= 0; /* partial command name following assignments */
1575 in_command_position
= 1;
1580 /* XXX - if we found a COMPSPEC for the command, just return whatever
1581 the programmable completion code returns, and disable the default
1582 filename completion that readline will do unless the COPT_DEFAULT
1583 option has been set with the `-o default' option to complete or
1587 pcomp_set_readline_variables (foundcs
, 1);
1588 /* Turn what the programmable completion code returns into what
1589 readline wants. I should have made compute_lcd_of_matches
1591 matches
= rl_completion_matches (text
, prog_complete_return
);
1592 if ((foundcs
& COPT_DEFAULT
) == 0)
1593 rl_attempted_completion_over
= 1; /* no default */
1594 if (matches
|| ((foundcs
& COPT_BASHDEFAULT
) == 0))
1603 if (in_command_position
)
1604 dflags
|= DEFCOMP_CMDPOS
;
1605 matches
= bash_default_completion (text
, start
, end
, qc
, dflags
);
1612 bash_default_completion (text
, start
, end
, qc
, compflags
)
1614 int start
, end
, qc
, compflags
;
1618 matches
= (char **)NULL
;
1620 /* New posix-style command substitution or variable name? */
1621 if (!matches
&& *text
== '$')
1623 if (qc
!= '\'' && text
[1] == '(') /* ) */
1624 matches
= rl_completion_matches (text
, command_subst_completion_function
);
1627 matches
= rl_completion_matches (text
, variable_completion_function
);
1628 if (matches
&& matches
[0] && matches
[1] == 0)
1630 t
= savestring (matches
[0]);
1631 bash_filename_stat_hook (&t
);
1632 /* doesn't use test_for_directory because that performs tilde
1635 rl_completion_append_character
= '/';
1641 /* If the word starts in `~', and there is no slash in the word, then
1642 try completing this word as a username. */
1643 if (matches
== 0 && *text
== '~' && mbschr (text
, '/') == 0)
1644 matches
= rl_completion_matches (text
, rl_username_completion_function
);
1646 /* Another one. Why not? If the word starts in '@', then look through
1647 the world of known hostnames for completion first. */
1648 if (matches
== 0 && perform_hostname_completion
&& *text
== '@')
1649 matches
= rl_completion_matches (text
, hostname_completion_function
);
1651 /* And last, (but not least) if this word is in a command position, then
1652 complete over possible command names, including aliases, functions,
1653 and command names. */
1654 if (matches
== 0 && (compflags
& DEFCOMP_CMDPOS
))
1656 /* If END == START and text[0] == 0, we are trying to complete an empty
1658 if (no_empty_command_completion
&& end
== start
&& text
[0] == '\0')
1660 matches
= (char **)NULL
;
1661 rl_ignore_some_completions_function
= bash_ignore_everything
;
1665 #define CMD_IS_DIR(x) (absolute_pathname(x) == 0 && absolute_program(x) == 0 && *(x) != '~' && test_for_directory (x))
1668 matches
= rl_completion_matches (text
, command_word_completion_function
);
1670 /* If we are attempting command completion and nothing matches, we
1671 do not want readline to perform filename completion for us. We
1672 still want to be able to complete partial pathnames, so set the
1673 completion ignore function to something which will remove
1674 filenames and leave directories in the match list. */
1675 if (matches
== (char **)NULL
)
1676 rl_ignore_some_completions_function
= bash_ignore_filenames
;
1677 else if (matches
[1] == 0 && CMD_IS_DIR(matches
[0]) && dot_in_path
== 0)
1678 /* If we found a single match, without looking in the current
1679 directory (because it's not in $PATH), but the found name is
1680 also a command in the current directory, suppress appending any
1681 terminating character, since it's ambiguous. */
1683 rl_completion_suppress_append
= 1;
1684 rl_filename_completion_desired
= 0;
1686 else if (matches
[0] && matches
[1] && STREQ (matches
[0], matches
[1]) && CMD_IS_DIR (matches
[0]))
1687 /* There are multiple instances of the same match (duplicate
1688 completions haven't yet been removed). In this case, all of
1689 the matches will be the same, and the duplicate removal code
1690 will distill them all down to one. We turn on
1691 rl_completion_suppress_append for the same reason as above.
1692 Remember: we only care if there's eventually a single unique
1693 completion. If there are multiple completions this won't
1694 make a difference and the problem won't occur. */
1696 rl_completion_suppress_append
= 1;
1697 rl_filename_completion_desired
= 0;
1702 /* This could be a globbing pattern, so try to expand it using pathname
1704 if (!matches
&& glob_pattern_p (text
))
1706 matches
= rl_completion_matches (text
, glob_complete_word
);
1707 /* A glob expression that matches more than one filename is problematic.
1708 If we match more than one filename, punt. */
1709 if (matches
&& matches
[1] && rl_completion_type
== TAB
)
1711 strvec_dispose (matches
);
1712 matches
= (char **)0;
1714 else if (matches
&& matches
[1] && rl_completion_type
== '!')
1716 rl_completion_suppress_append
= 1;
1717 rl_filename_completion_desired
= 0;
1725 bash_command_name_stat_hook (name
)
1728 char *cname
, *result
;
1730 /* If it's not something we're going to look up in $PATH, just call the
1731 normal filename stat hook. */
1732 if (absolute_program (*name
))
1733 return (bash_filename_stat_hook (name
));
1736 /* XXX - we could do something here with converting aliases, builtins,
1737 and functions into something that came out as executable, but we don't. */
1738 result
= search_for_command (cname
, 0);
1748 executable_completion (filename
, searching_path
)
1749 const char *filename
;
1755 f
= savestring (filename
);
1756 bash_directory_completion_hook (&f
);
1758 r
= searching_path
? executable_file (f
) : executable_or_directory (f
);
1763 /* This is the function to call when the word to complete is in a position
1764 where a command word can be found. It grovels $PATH, looking for commands
1765 that match. It also scans aliases, function names, and the shell_builtin
1768 command_word_completion_function (hint_text
, state
)
1769 const char *hint_text
;
1772 static char *hint
= (char *)NULL
;
1773 static char *path
= (char *)NULL
;
1774 static char *val
= (char *)NULL
;
1775 static char *filename_hint
= (char *)NULL
;
1776 static char *fnhint
= (char *)NULL
;
1777 static char *dequoted_hint
= (char *)NULL
;
1778 static char *directory_part
= (char *)NULL
;
1779 static char **glob_matches
= (char **)NULL
;
1780 static int path_index
, hint_len
, dequoted_len
, istate
, igncase
;
1781 static int mapping_over
, local_index
, searching_path
, hint_is_dir
;
1782 static int old_glob_ignore_case
, globpat
;
1783 static SHELL_VAR
**varlist
= (SHELL_VAR
**)NULL
;
1785 static alias_t
**alias_list
= (alias_t
**)NULL
;
1789 /* We have to map over the possibilities for command words. If we have
1790 no state, then make one just for that purpose. */
1793 rl_filename_stat_hook
= bash_command_name_stat_hook
;
1795 if (dequoted_hint
&& dequoted_hint
!= hint
)
1796 free (dequoted_hint
);
1800 mapping_over
= searching_path
= 0;
1801 hint_is_dir
= CMD_IS_DIR (hint_text
);
1804 temp
= rl_variable_value ("completion-ignore-case");
1805 igncase
= RL_BOOLEAN_VARIABLE_VALUE (temp
);
1809 free (glob_matches
);
1810 glob_matches
= (char **)NULL
;
1813 globpat
= glob_pattern_p (hint_text
);
1815 /* If this is an absolute program name, do not check it against
1816 aliases, reserved words, functions or builtins. We must check
1817 whether or not it is unique, and, if so, whether that filename
1819 if (globpat
|| absolute_program (hint_text
))
1821 /* Perform tilde expansion on what's passed, so we don't end up
1822 passing filenames with tildes directly to stat(). */
1823 if (*hint_text
== '~')
1825 hint
= bash_tilde_expand (hint_text
, 0);
1826 directory_part
= savestring (hint_text
);
1827 temp
= strchr (directory_part
, '/');
1832 free (directory_part
);
1833 directory_part
= (char *)NULL
;
1837 hint
= savestring (hint_text
);
1839 dequoted_hint
= hint
;
1840 /* If readline's completer found a quote character somewhere, but
1841 didn't set the quote character, there must have been a quote
1842 character embedded in the filename. It can't be at the start of
1843 the filename, so we need to dequote the filename before we look
1844 in the file system for it. */
1845 if (rl_completion_found_quote
&& rl_completion_quote_character
== 0)
1847 dequoted_hint
= bash_dequote_filename (hint
, 0);
1849 hint
= dequoted_hint
;
1851 dequoted_len
= hint_len
= strlen (hint
);
1854 free (filename_hint
);
1856 fnhint
= filename_hint
= savestring (hint
);
1867 if (dircomplete_expand
&& path_dot_or_dotdot (filename_hint
))
1869 dircomplete_expand
= 0;
1870 set_directory_hook ();
1871 dircomplete_expand
= 1;
1878 dequoted_hint
= hint
= savestring (hint_text
);
1879 dequoted_len
= hint_len
= strlen (hint
);
1881 if (rl_completion_found_quote
&& rl_completion_quote_character
== 0)
1883 dequoted_hint
= bash_dequote_filename (hint
, 0);
1884 dequoted_len
= strlen (dequoted_hint
);
1887 path
= get_string_value ("PATH");
1888 path_index
= dot_in_path
= 0;
1890 /* Initialize the variables for each type of command word. */
1896 varlist
= all_visible_functions ();
1902 alias_list
= all_aliases ();
1906 /* mapping_over says what we are currently hacking. Note that every case
1907 in this list must fall through when there are no more possibilities. */
1909 switch (mapping_over
)
1911 case 0: /* Aliases come first. */
1913 while (alias_list
&& alias_list
[local_index
])
1915 register char *alias
;
1917 alias
= alias_list
[local_index
++]->name
;
1919 if (STREQN (alias
, hint
, hint_len
))
1920 return (savestring (alias
));
1926 case 1: /* Then shell reserved words. */
1928 while (word_token_alist
[local_index
].word
)
1930 register char *reserved_word
;
1932 reserved_word
= word_token_alist
[local_index
++].word
;
1934 if (STREQN (reserved_word
, hint
, hint_len
))
1935 return (savestring (reserved_word
));
1941 case 2: /* Then function names. */
1942 while (varlist
&& varlist
[local_index
])
1944 register char *varname
;
1946 varname
= varlist
[local_index
++]->name
;
1948 if (STREQN (varname
, hint
, hint_len
))
1949 return (savestring (varname
));
1954 case 3: /* Then shell builtins. */
1955 for (; local_index
< num_shell_builtins
; local_index
++)
1957 /* Ignore it if it doesn't have a function pointer or if it
1958 is not currently enabled. */
1959 if (!shell_builtins
[local_index
].function
||
1960 (shell_builtins
[local_index
].flags
& BUILTIN_ENABLED
) == 0)
1963 if (STREQN (shell_builtins
[local_index
].name
, hint
, hint_len
))
1965 int i
= local_index
++;
1967 return (savestring (shell_builtins
[i
].name
));
1975 /* Limited support for completing command words with globbing chars. Only
1976 a single match (multiple matches that end up reducing the number of
1977 characters in the common prefix are bad) will ever be returned on
1978 regular completion. */
1983 glob_ignore_case
= igncase
;
1984 glob_matches
= shell_glob_filename (hint
);
1985 glob_ignore_case
= old_glob_ignore_case
;
1987 if (GLOB_FAILED (glob_matches
) || glob_matches
== 0)
1989 glob_matches
= (char **)NULL
;
1990 return ((char *)NULL
);
1995 if (glob_matches
[1] && rl_completion_type
== TAB
) /* multiple matches are bad */
1996 return ((char *)NULL
);
1999 while (val
= glob_matches
[local_index
++])
2001 if (executable_or_directory (val
))
2003 if (*hint_text
== '~' && directory_part
)
2005 temp
= maybe_restore_tilde (val
, directory_part
);
2014 glob_ignore_case
= old_glob_ignore_case
;
2015 return ((char *)NULL
);
2018 /* If the text passed is a directory in the current directory, return it
2019 as a possible match. Executables in directories in the current
2020 directory can be specified using relative pathnames and successfully
2021 executed even when `.' is not in $PATH. */
2024 hint_is_dir
= 0; /* only return the hint text once */
2025 return (savestring (hint_text
));
2028 /* Repeatedly call filename_completion_function while we have
2029 members of PATH left. Question: should we stat each file?
2030 Answer: we call executable_file () on each file. */
2033 istate
= (val
!= (char *)NULL
);
2039 /* Get the next directory from the path. If there is none, then we
2041 if (path
== 0 || path
[path_index
] == 0 ||
2042 (current_path
= extract_colon_unit (path
, &path_index
)) == 0)
2043 return ((char *)NULL
);
2046 if (*current_path
== 0)
2048 free (current_path
);
2049 current_path
= savestring (".");
2052 if (*current_path
== '~')
2056 t
= bash_tilde_expand (current_path
, 0);
2057 free (current_path
);
2061 if (current_path
[0] == '.' && current_path
[1] == '\0')
2064 if (fnhint
&& fnhint
!= filename_hint
)
2067 free (filename_hint
);
2069 filename_hint
= sh_makepath (current_path
, hint
, 0);
2070 /* Need a quoted version (though it doesn't matter much in most
2071 cases) because rl_filename_completion_function dequotes the
2072 filename it gets, assuming that it's been quoted as part of
2073 the input line buffer. */
2074 if (strpbrk (filename_hint
, "\"'\\"))
2075 fnhint
= sh_backslash_quote (filename_hint
, filename_bstab
, 0);
2077 fnhint
= filename_hint
;
2078 free (current_path
); /* XXX */
2082 val
= rl_filename_completion_function (fnhint
, istate
);
2083 if (mapping_over
== 4 && dircomplete_expand
)
2084 set_directory_hook ();
2090 /* If the hint text is an absolute program, then don't bother
2091 searching through PATH. */
2092 if (absolute_program (hint
))
2093 return ((char *)NULL
);
2099 int match
, freetemp
;
2101 if (absolute_program (hint
))
2104 match
= strncmp (val
, hint
, hint_len
) == 0;
2106 match
= strncasecmp (val
, hint
, hint_len
) == 0;
2108 /* If we performed tilde expansion, restore the original
2110 if (*hint_text
== '~')
2111 temp
= maybe_restore_tilde (val
, directory_part
);
2113 temp
= savestring (val
);
2118 temp
= strrchr (val
, '/');
2124 freetemp
= match
= strncmp (temp
, hint
, hint_len
) == 0;
2126 freetemp
= match
= strncasecmp (temp
, hint
, hint_len
) == 0;
2128 temp
= savestring (temp
);
2131 freetemp
= match
= 0;
2134 /* If we have found a match, and it is an executable file, return it.
2135 We don't return directory names when searching $PATH, since the
2136 bash execution code won't find executables in directories which
2137 appear in directories in $PATH when they're specified using
2138 relative pathnames. */
2140 /* If we're not searching $PATH and we have a relative pathname, we
2141 need to re-canonicalize it before testing whether or not it's an
2142 executable or a directory so the shell treats .. relative to $PWD
2143 according to the physical/logical option. The shell already
2144 canonicalizes the directory name in order to tell readline where
2145 to look, so not doing it here will be inconsistent. */
2146 /* XXX -- currently not used -- will introduce more inconsistency,
2147 since shell does not canonicalize ../foo before passing it to
2149 if (match
&& searching_path
== 0 && *val
== '.')
2153 t
= get_working_directory ("command-word-completion");
2154 t1
= make_absolute (val
, t
);
2156 cval
= sh_canonpath (t1
, PATH_CHECKDOTDOT
|PATH_CHECKEXISTS
);
2162 if (match
&& executable_completion ((searching_path
? val
: cval
), searching_path
))
2167 val
= ""; /* So it won't be NULL. */
2182 /* Completion inside an unterminated command substitution. */
2184 command_subst_completion_function (text
, state
)
2188 static char **matches
= (char **)NULL
;
2189 static const char *orig_start
;
2190 static char *filename_text
= (char *)NULL
;
2191 static int cmd_index
, start_len
;
2197 free (filename_text
);
2201 else if (*text
== '$' && text
[1] == '(') /* ) */
2203 /* If the text was quoted, suppress any quote character that the
2204 readline completion code would insert. */
2205 rl_completion_suppress_quote
= 1;
2206 start_len
= text
- orig_start
;
2207 filename_text
= savestring (text
);
2212 * At this point we can entertain the idea of re-parsing
2213 * `filename_text' into a (possibly incomplete) command name and
2214 * arguments, and doing completion based on that. This is
2215 * currently very rudimentary, but it is a small improvement.
2217 for (value
= filename_text
+ strlen (filename_text
) - 1; value
> filename_text
; value
--)
2218 if (whitespace (*value
) || member (*value
, COMMAND_SEPARATORS
))
2220 if (value
<= filename_text
)
2221 matches
= rl_completion_matches (filename_text
, command_word_completion_function
);
2225 start_len
+= value
- filename_text
;
2226 if (whitespace (value
[-1]))
2227 matches
= rl_completion_matches (value
, rl_filename_completion_function
);
2229 matches
= rl_completion_matches (value
, command_word_completion_function
);
2232 /* If there is more than one match, rl_completion_matches has already
2233 put the lcd in matches[0]. Skip over it. */
2234 cmd_index
= matches
&& matches
[0] && matches
[1];
2236 /* If there's a single match and it's a directory, set the append char
2237 to the expected `/'. Otherwise, don't append anything. */
2238 if (matches
&& matches
[0] && matches
[1] == 0 && test_for_directory (matches
[0]))
2239 rl_completion_append_character
= '/';
2241 rl_completion_suppress_append
= 1;
2244 if (matches
== 0 || matches
[cmd_index
] == 0)
2246 rl_filename_quoting_desired
= 0; /* disable quoting */
2247 return ((char *)NULL
);
2251 value
= (char *)xmalloc (1 + start_len
+ strlen (matches
[cmd_index
]));
2254 value
[0] = *orig_start
;
2256 strncpy (value
, orig_start
, start_len
);
2258 strcpy (value
+ start_len
, matches
[cmd_index
]);
2265 /* Okay, now we write the entry_function for variable completion. */
2267 variable_completion_function (text
, state
)
2271 static char **varlist
= (char **)NULL
;
2272 static int varlist_index
;
2273 static char *varname
= (char *)NULL
;
2275 static int first_char
, first_char_loc
;
2283 first_char
= text
[0];
2285 if (first_char
== '$')
2288 if (text
[first_char_loc
] == '{')
2291 varname
= savestring (text
+ first_char_loc
);
2293 namelen
= strlen (varname
);
2295 strvec_dispose (varlist
);
2297 varlist
= all_variables_matching_prefix (varname
);
2301 if (!varlist
|| !varlist
[varlist_index
])
2303 return ((char *)NULL
);
2309 value
= (char *)xmalloc (4 + strlen (varlist
[varlist_index
]));
2313 value
[0] = first_char
;
2314 if (first_char_loc
== 2)
2318 strcpy (value
+ first_char_loc
, varlist
[varlist_index
]);
2319 if (first_char_loc
== 2)
2320 strcat (value
, "}");
2327 /* How about a completion function for hostnames? */
2329 hostname_completion_function (text
, state
)
2333 static char **list
= (char **)NULL
;
2334 static int list_index
= 0;
2335 static int first_char
, first_char_loc
;
2337 /* If we don't have any state, make some. */
2342 list
= (char **)NULL
;
2347 if (first_char
== '@')
2350 list
= hostnames_matching ((char *)text
+first_char_loc
);
2354 if (list
&& list
[list_index
])
2358 t
= (char *)xmalloc (2 + strlen (list
[list_index
]));
2360 strcpy (t
+ first_char_loc
, list
[list_index
]);
2365 return ((char *)NULL
);
2369 * A completion function for service names from /etc/services (or wherever).
2372 bash_servicename_completion_function (text
, state
)
2376 #if defined (__WIN32__) || defined (__OPENNT) || !defined (HAVE_GETSERVENT)
2377 return ((char *)NULL
);
2379 static char *sname
= (char *)NULL
;
2380 static struct servent
*srvent
;
2381 static int snamelen
, firstc
;
2383 char **alist
, *aentry
;
2391 sname
= savestring (text
);
2392 snamelen
= strlen (sname
);
2396 while (srvent
= getservent ())
2399 if (snamelen
== 0 || (STREQN (sname
, srvent
->s_name
, snamelen
)))
2401 /* Not primary, check aliases */
2402 for (alist
= srvent
->s_aliases
; *alist
; alist
++)
2405 if (STREQN (sname
, aentry
, snamelen
))
2419 return ((char *)NULL
);
2422 value
= afound
? savestring (aentry
) : savestring (srvent
->s_name
);
2428 * A completion function for group names from /etc/group (or wherever).
2431 bash_groupname_completion_function (text
, state
)
2435 #if defined (__WIN32__) || defined (__OPENNT) || !defined (HAVE_GRP_H)
2436 return ((char *)NULL
);
2438 static char *gname
= (char *)NULL
;
2439 static struct group
*grent
;
2440 static int gnamelen
;
2446 gname
= savestring (text
);
2447 gnamelen
= strlen (gname
);
2452 while (grent
= getgrent ())
2454 if (gnamelen
== 0 || (STREQN (gname
, grent
->gr_name
, gnamelen
)))
2461 return ((char *)NULL
);
2464 value
= savestring (grent
->gr_name
);
2469 /* Functions to perform history and alias expansions on the current line. */
2471 #if defined (BANG_HISTORY)
2472 /* Perform history expansion on the current line. If no history expansion
2473 is done, pre_process_line() returns what it was passed, so we need to
2474 allocate a new line here. */
2476 history_expand_line_internal (line
)
2482 old_verify
= hist_verify
;
2484 new_line
= pre_process_line (line
, 0, 0);
2485 hist_verify
= old_verify
;
2487 return (new_line
== line
) ? savestring (line
) : new_line
;
2491 /* There was an error in expansion. Let the preprocessor print
2494 cleanup_expansion_error ()
2497 #if defined (BANG_HISTORY)
2500 old_verify
= hist_verify
;
2504 fprintf (rl_outstream
, "\r\n");
2505 to_free
= pre_process_line (rl_line_buffer
, 1, 0);
2506 #if defined (BANG_HISTORY)
2507 hist_verify
= old_verify
;
2509 if (to_free
!= rl_line_buffer
)
2511 putc ('\r', rl_outstream
);
2512 rl_forced_update_display ();
2515 /* If NEW_LINE differs from what is in the readline line buffer, add an
2516 undo record to get from the readline line buffer contents to the new
2517 line and make NEW_LINE the current readline line. */
2519 maybe_make_readline_line (new_line
)
2522 if (strcmp (new_line
, rl_line_buffer
) != 0)
2526 rl_add_undo (UNDO_BEGIN
, 0, 0, 0);
2527 rl_delete_text (0, rl_point
);
2528 rl_point
= rl_end
= rl_mark
= 0;
2529 rl_insert_text (new_line
);
2530 rl_add_undo (UNDO_END
, 0, 0, 0);
2534 /* Make NEW_LINE be the current readline line. This frees NEW_LINE. */
2536 set_up_new_line (new_line
)
2539 int old_point
, at_end
;
2541 old_point
= rl_point
;
2542 at_end
= rl_point
== rl_end
;
2544 /* If the line was history and alias expanded, then make that
2545 be one thing to undo. */
2546 maybe_make_readline_line (new_line
);
2549 /* Place rl_point where we think it should go. */
2552 else if (old_point
< rl_end
)
2554 rl_point
= old_point
;
2555 if (!whitespace (rl_line_buffer
[rl_point
]))
2556 rl_forward_word (1, 0);
2561 /* Expand aliases in the current readline line. */
2563 alias_expand_line (count
, ignore
)
2568 new_line
= alias_expand (rl_line_buffer
);
2572 set_up_new_line (new_line
);
2577 cleanup_expansion_error ();
2583 #if defined (BANG_HISTORY)
2584 /* History expand the line. */
2586 history_expand_line (count
, ignore
)
2591 new_line
= history_expand_line_internal (rl_line_buffer
);
2595 set_up_new_line (new_line
);
2600 cleanup_expansion_error ();
2605 /* Expand history substitutions in the current line and then insert a
2606 space (hopefully close to where we were before). */
2608 tcsh_magic_space (count
, ignore
)
2611 int dist_from_end
, old_point
;
2613 old_point
= rl_point
;
2614 dist_from_end
= rl_end
- rl_point
;
2615 if (history_expand_line (count
, ignore
) == 0)
2617 /* Try a simple heuristic from Stephen Gildea <gildea@intouchsys.com>.
2618 This works if all expansions were before rl_point or if no expansions
2620 rl_point
= (old_point
== 0) ? old_point
: rl_end
- dist_from_end
;
2627 #endif /* BANG_HISTORY */
2629 /* History and alias expand the line. */
2631 history_and_alias_expand_line (count
, ignore
)
2637 #if defined (BANG_HISTORY)
2638 new_line
= history_expand_line_internal (rl_line_buffer
);
2646 alias_line
= alias_expand (new_line
);
2648 new_line
= alias_line
;
2654 set_up_new_line (new_line
);
2659 cleanup_expansion_error ();
2664 /* History and alias expand the line, then perform the shell word
2665 expansions by calling expand_string. This can't use set_up_new_line()
2666 because we want the variable expansions as a separate undo'able
2667 set of operations. */
2669 shell_expand_line (count
, ignore
)
2673 WORD_LIST
*expanded_string
;
2676 #if defined (BANG_HISTORY)
2677 new_line
= history_expand_line_internal (rl_line_buffer
);
2685 alias_line
= alias_expand (new_line
);
2687 new_line
= alias_line
;
2693 int old_point
= rl_point
;
2694 int at_end
= rl_point
== rl_end
;
2696 /* If the line was history and alias expanded, then make that
2697 be one thing to undo. */
2698 maybe_make_readline_line (new_line
);
2701 /* If there is variable expansion to perform, do that as a separate
2702 operation to be undone. */
2703 new_line
= savestring (rl_line_buffer
);
2704 expanded_string
= expand_string (new_line
, 0);
2706 if (expanded_string
== 0)
2708 new_line
= (char *)xmalloc (1);
2713 new_line
= string_list (expanded_string
);
2714 dispose_words (expanded_string
);
2717 maybe_make_readline_line (new_line
);
2720 /* Place rl_point where we think it should go. */
2723 else if (old_point
< rl_end
)
2725 rl_point
= old_point
;
2726 if (!whitespace (rl_line_buffer
[rl_point
]))
2727 rl_forward_word (1, 0);
2733 cleanup_expansion_error ();
2738 /* If FIGNORE is set, then don't match files with the given suffixes when
2739 completing filenames. If only one of the possibilities has an acceptable
2740 suffix, delete the others, else just return and let the completer
2741 signal an error. It is called by the completer when real
2742 completions are done on filenames by the completer's internal
2743 function, not for completion lists (M-?) and not on "other"
2744 completion types, such as hostnames or commands. */
2746 static struct ignorevar fignore
=
2752 (sh_iv_item_func_t
*) 0,
2756 _ignore_completion_names (names
, name_func
)
2758 sh_ignore_func_t
*name_func
;
2765 /* If there is only one completion, see if it is acceptable. If it is
2766 not, free it up. In any case, short-circuit and return. This is a
2767 special case because names[0] is not the prefix of the list of names
2768 if there is only one completion; it is the completion itself. */
2769 if (names
[1] == (char *)0)
2772 if ((*name_func
) (names
[0]) == 0)
2775 names
[0] = (char *)NULL
;
2781 /* Allocate space for array to hold list of pointers to matching
2782 filenames. The pointers are copied back to NAMES when done. */
2783 for (nidx
= 1; names
[nidx
]; nidx
++)
2785 newnames
= strvec_create (nidx
+ 1);
2787 if (force_fignore
== 0)
2789 oldnames
= strvec_create (nidx
- 1);
2793 newnames
[0] = names
[0];
2794 for (idx
= nidx
= 1; names
[idx
]; idx
++)
2796 if ((*name_func
) (names
[idx
]))
2797 newnames
[nidx
++] = names
[idx
];
2798 else if (force_fignore
== 0)
2799 oldnames
[oidx
++] = names
[idx
];
2804 newnames
[nidx
] = (char *)NULL
;
2806 /* If none are acceptable then let the completer handle it. */
2812 names
[0] = (char *)NULL
;
2821 if (force_fignore
== 0)
2824 free (oldnames
[--oidx
]);
2828 /* If only one is acceptable, copy it to names[0] and return. */
2832 names
[0] = newnames
[1];
2833 names
[1] = (char *)NULL
;
2838 /* Copy the acceptable names back to NAMES, set the new array end,
2840 for (nidx
= 1; newnames
[nidx
]; nidx
++)
2841 names
[nidx
] = newnames
[nidx
];
2842 names
[nidx
] = (char *)NULL
;
2847 name_is_acceptable (name
)
2853 for (nlen
= strlen (name
), p
= fignore
.ignores
; p
->val
; p
++)
2855 if (nlen
> p
->len
&& p
->len
> 0 && STREQ (p
->val
, &name
[nlen
- p
->len
]))
2864 ignore_dot_names (name
)
2867 return (name
[0] != '.');
2872 filename_completion_ignore (names
)
2876 if (glob_dot_filenames
== 0)
2877 _ignore_completion_names (names
, ignore_dot_names
);
2880 setup_ignore_patterns (&fignore
);
2882 if (fignore
.num_ignores
== 0)
2885 _ignore_completion_names (names
, name_is_acceptable
);
2890 /* Return 1 if NAME is a directory. NAME undergoes tilde expansion. */
2892 test_for_directory (name
)
2898 fn
= bash_tilde_expand (name
, 0);
2899 r
= file_isdir (fn
);
2905 /* Remove files from NAMES, leaving directories. */
2907 bash_ignore_filenames (names
)
2910 _ignore_completion_names (names
, test_for_directory
);
2922 bash_ignore_everything (names
)
2925 _ignore_completion_names (names
, return_zero
);
2929 /* Replace a tilde-prefix in VAL with a `~', assuming the user typed it. VAL
2930 is an expanded filename. DIRECTORY_PART is the tilde-prefix portion
2931 of the un-tilde-expanded version of VAL (what the user typed). */
2933 restore_tilde (val
, directory_part
)
2934 char *val
, *directory_part
;
2937 char *dh2
, *expdir
, *ret
;
2941 /* We need to duplicate the expansions readline performs on the directory
2942 portion before passing it to our completion function. */
2943 dh2
= directory_part
? bash_dequote_filename (directory_part
, 0) : 0;
2944 bash_directory_expansion (&dh2
);
2947 expdir
= bash_tilde_expand (directory_part
, 0);
2948 xl
= strlen (expdir
);
2952 dh2 = unexpanded but dequoted tilde-prefix
2953 dl2 = length of tilde-prefix
2954 expdir = tilde-expanded tilde-prefix
2955 xl = length of expanded tilde-prefix
2956 l = length of remainder after tilde-prefix
2960 ret
= (char *)xmalloc (dl2
+ 2 + l
);
2962 strcpy (ret
+ dl2
, val
+ xl
);
2969 maybe_restore_tilde (val
, directory_part
)
2970 char *val
, *directory_part
;
2972 rl_icppfunc_t
*save
;
2975 save
= (dircomplete_expand
== 0) ? save_directory_hook () : (rl_icppfunc_t
*)0;
2976 ret
= restore_tilde (val
, directory_part
);
2978 restore_directory_hook (save
);
2982 /* Simulate the expansions that will be performed by
2983 rl_filename_completion_function. This must be called with the address of
2984 a pointer to malloc'd memory. */
2986 bash_directory_expansion (dirname
)
2991 d
= savestring (*dirname
);
2993 if ((rl_directory_rewrite_hook
) && (*rl_directory_rewrite_hook
) (&d
))
2998 else if (rl_directory_completion_hook
&& (*rl_directory_completion_hook
) (&d
))
3003 else if (rl_completion_found_quote
)
3005 nd
= bash_dequote_filename (d
, rl_completion_quote_character
);
3012 /* If necessary, rewrite directory entry */
3014 bash_filename_rewrite_hook (fname
, fnlen
)
3020 conv
= fnx_fromfs (fname
, fnlen
);
3022 conv
= savestring (conv
);
3026 /* Functions to save and restore the appropriate directory hook */
3027 /* This is not static so the shopt code can call it */
3029 set_directory_hook ()
3031 if (dircomplete_expand
)
3033 rl_directory_completion_hook
= bash_directory_completion_hook
;
3034 rl_directory_rewrite_hook
= (rl_icppfunc_t
*)0;
3038 rl_directory_rewrite_hook
= bash_directory_completion_hook
;
3039 rl_directory_completion_hook
= (rl_icppfunc_t
*)0;
3043 static rl_icppfunc_t
*
3044 save_directory_hook ()
3048 if (dircomplete_expand
)
3050 ret
= rl_directory_completion_hook
;
3051 rl_directory_completion_hook
= (rl_icppfunc_t
*)NULL
;
3055 ret
= rl_directory_rewrite_hook
;
3056 rl_directory_rewrite_hook
= (rl_icppfunc_t
*)NULL
;
3063 restore_directory_hook (hookf
)
3064 rl_icppfunc_t
*hookf
;
3066 if (dircomplete_expand
)
3067 rl_directory_completion_hook
= hookf
;
3069 rl_directory_rewrite_hook
= hookf
;
3072 /* Expand a filename before the readline completion code passes it to stat(2).
3073 The filename will already have had tilde expansion performed. */
3075 bash_filename_stat_hook (dirname
)
3078 char *local_dirname
, *new_dirname
, *t
;
3079 int should_expand_dirname
, return_value
;
3083 local_dirname
= *dirname
;
3084 should_expand_dirname
= return_value
= 0;
3085 if (t
= mbschr (local_dirname
, '$'))
3086 should_expand_dirname
= '$';
3087 else if (t
= mbschr (local_dirname
, '`')) /* XXX */
3088 should_expand_dirname
= '`';
3090 #if defined (HAVE_LSTAT)
3091 if (should_expand_dirname
&& lstat (local_dirname
, &sb
) == 0)
3093 if (should_expand_dirname
&& stat (local_dirname
, &sb
) == 0)
3095 should_expand_dirname
= 0;
3097 if (should_expand_dirname
)
3099 new_dirname
= savestring (local_dirname
);
3100 wl
= expand_prompt_string (new_dirname
, 0, W_NOCOMSUB
); /* does the right thing */
3104 new_dirname
= string_list (wl
);
3105 /* Tell the completer we actually expanded something and change
3106 *dirname only if we expanded to something non-null -- stat
3107 behaves unpredictably when passed null or empty strings */
3108 if (new_dirname
&& *new_dirname
)
3110 free (local_dirname
); /* XXX */
3111 local_dirname
= *dirname
= new_dirname
;
3112 return_value
= STREQ (local_dirname
, *dirname
) == 0;
3122 /* This is very similar to the code in bash_directory_completion_hook below,
3123 but without spelling correction and not worrying about whether or not
3124 we change relative pathnames. */
3125 if (no_symbolic_links
== 0 && (local_dirname
[0] != '.' || local_dirname
[1]))
3127 char *temp1
, *temp2
;
3129 t
= get_working_directory ("symlink-hook");
3130 temp1
= make_absolute (local_dirname
, t
);
3132 temp2
= sh_canonpath (temp1
, PATH_CHECKDOTDOT
|PATH_CHECKEXISTS
);
3134 /* If we can't canonicalize, bail. */
3138 return return_value
;
3141 free (local_dirname
);
3146 return (return_value
);
3149 /* Handle symbolic link references and other directory name
3150 expansions while hacking completion. This should return 1 if it modifies
3151 the DIRNAME argument, 0 otherwise. It should make sure not to modify
3152 DIRNAME if it returns 0. */
3154 bash_directory_completion_hook (dirname
)
3157 char *local_dirname
, *new_dirname
, *t
;
3158 int return_value
, should_expand_dirname
, nextch
, closer
;
3162 return_value
= should_expand_dirname
= nextch
= closer
= 0;
3163 local_dirname
= *dirname
;
3165 if (t
= mbschr (local_dirname
, '$'))
3167 should_expand_dirname
= '$';
3169 /* Deliberately does not handle the deprecated $[...] arithmetic
3173 else if (nextch
== '{')
3178 else if (local_dirname
[0] == '~')
3179 should_expand_dirname
= '~';
3182 t
= mbschr (local_dirname
, '`');
3183 if (t
&& unclosed_pair (local_dirname
, strlen (local_dirname
), "`") == 0)
3184 should_expand_dirname
= '`';
3187 #if defined (HAVE_LSTAT)
3188 if (should_expand_dirname
&& lstat (local_dirname
, &sb
) == 0)
3190 if (should_expand_dirname
&& stat (local_dirname
, &sb
) == 0)
3192 should_expand_dirname
= 0;
3194 if (should_expand_dirname
)
3196 new_dirname
= savestring (local_dirname
);
3197 wl
= expand_prompt_string (new_dirname
, 0, W_NOCOMSUB
); /* does the right thing */
3200 *dirname
= string_list (wl
);
3201 /* Tell the completer to replace the directory name only if we
3202 actually expanded something. */
3203 return_value
= STREQ (local_dirname
, *dirname
) == 0;
3204 free (local_dirname
);
3207 local_dirname
= *dirname
;
3208 /* XXX - change rl_filename_quote_characters here based on
3209 should_expand_dirname/nextch/closer. This is the only place
3210 custom_filename_quote_characters is modified. */
3211 if (rl_filename_quote_characters
&& *rl_filename_quote_characters
)
3214 i
= strlen (default_filename_quote_characters
);
3215 custom_filename_quote_characters
= xrealloc (custom_filename_quote_characters
, i
+1);
3216 for (i
= j
= 0; c
= default_filename_quote_characters
[i
]; i
++)
3218 if (c
== should_expand_dirname
|| c
== nextch
|| c
== closer
)
3220 custom_filename_quote_characters
[j
++] = c
;
3222 custom_filename_quote_characters
[j
] = '\0';
3223 rl_filename_quote_characters
= custom_filename_quote_characters
;
3224 set_filename_bstab (rl_filename_quote_characters
);
3230 free (local_dirname
);
3231 *dirname
= (char *)xmalloc (1);
3238 /* Dequote the filename even if we don't expand it. */
3239 new_dirname
= bash_dequote_filename (local_dirname
, rl_completion_quote_character
);
3240 return_value
= STREQ (local_dirname
, new_dirname
) == 0;
3241 free (local_dirname
);
3242 local_dirname
= *dirname
= new_dirname
;
3245 /* no_symbolic_links == 0 -> use (default) logical view of the file system.
3246 local_dirname[0] == '.' && local_dirname[1] == '/' means files in the
3247 current directory (./).
3248 local_dirname[0] == '.' && local_dirname[1] == 0 means relative pathnames
3249 in the current directory (e.g., lib/sh).
3250 XXX - should we do spelling correction on these? */
3252 /* This is test as it was in bash-4.2: skip relative pathnames in current
3253 directory. Change test to
3254 (local_dirname[0] != '.' || (local_dirname[1] && local_dirname[1] != '/'))
3255 if we want to skip paths beginning with ./ also. */
3256 if (no_symbolic_links
== 0 && (local_dirname
[0] != '.' || local_dirname
[1]))
3258 char *temp1
, *temp2
;
3261 /* If we have a relative path
3262 (local_dirname[0] != '/' && local_dirname[0] != '.')
3263 that is canonical after appending it to the current directory, then
3266 strcmp (temp1, temp2) == 0
3267 after adding a slash to temp2 below. It should be safe to not
3270 t
= get_working_directory ("symlink-hook");
3271 temp1
= make_absolute (local_dirname
, t
);
3273 temp2
= sh_canonpath (temp1
, PATH_CHECKDOTDOT
|PATH_CHECKEXISTS
);
3275 /* Try spelling correction if initial canonicalization fails. Make
3276 sure we are set to replace the directory name with the results so
3277 subsequent directory checks don't fail. */
3278 if (temp2
== 0 && dircomplete_spelling
&& dircomplete_expand
)
3280 temp2
= dirspell (temp1
);
3285 temp2
= sh_canonpath (temp1
, PATH_CHECKDOTDOT
|PATH_CHECKEXISTS
);
3286 return_value
|= temp2
!= 0;
3289 /* If we can't canonicalize, bail. */
3293 return return_value
;
3295 len1
= strlen (temp1
);
3296 if (temp1
[len1
- 1] == '/')
3298 len2
= strlen (temp2
);
3299 if (len2
> 2) /* don't append `/' to `/' or `//' */
3301 temp2
= (char *)xrealloc (temp2
, len2
+ 2);
3303 temp2
[len2
+ 1] = '\0';
3307 /* dircomplete_expand_relpath == 0 means we want to leave relative
3308 pathnames that are unchanged by canonicalization alone.
3309 *local_dirname != '/' && *local_dirname != '.' == relative pathname
3310 (consistent with general.c:absolute_pathname())
3311 temp1 == temp2 (after appending a slash to temp2) means the pathname
3312 is not changed by canonicalization as described above. */
3313 if (dircomplete_expand_relpath
|| ((local_dirname
[0] != '/' && local_dirname
[0] != '.') && STREQ (temp1
, temp2
) == 0))
3314 return_value
|= STREQ (local_dirname
, temp2
) == 0;
3315 free (local_dirname
);
3320 return (return_value
);
3323 static char **history_completion_array
= (char **)NULL
;
3324 static int harry_size
;
3325 static int harry_len
;
3328 build_history_completion_array ()
3334 /* First, clear out the current dynamic history completion list. */
3337 strvec_dispose (history_completion_array
);
3338 history_completion_array
= (char **)NULL
;
3343 /* Next, grovel each line of history, making each shell-sized token
3344 a separate entry in the history_completion_array. */
3345 hlist
= history_list ();
3349 for (i
= 0; hlist
[i
]; i
++)
3351 for ( --i
; i
>= 0; i
--)
3353 /* Separate each token, and place into an array. */
3354 tokens
= history_tokenize (hlist
[i
]->line
);
3356 for (j
= 0; tokens
&& tokens
[j
]; j
++)
3358 if (harry_len
+ 2 > harry_size
)
3359 history_completion_array
= strvec_resize (history_completion_array
, harry_size
+= 10);
3361 history_completion_array
[harry_len
++] = tokens
[j
];
3362 history_completion_array
[harry_len
] = (char *)NULL
;
3367 /* Sort the complete list of tokens. */
3368 if (dabbrev_expand_active
== 0)
3369 qsort (history_completion_array
, harry_len
, sizeof (char *), (QSFUNC
*)strvec_strcmp
);
3374 history_completion_generator (hint_text
, state
)
3375 const char *hint_text
;
3378 static int local_index
, len
;
3379 static const char *text
;
3381 /* If this is the first call to the generator, then initialize the
3382 list of strings to complete over. */
3385 if (dabbrev_expand_active
) /* This is kind of messy */
3386 rl_completion_suppress_append
= 1;
3388 build_history_completion_array ();
3390 len
= strlen (text
);
3393 while (history_completion_array
&& history_completion_array
[local_index
])
3395 if (strncmp (text
, history_completion_array
[local_index
++], len
) == 0)
3396 return (savestring (history_completion_array
[local_index
- 1]));
3398 return ((char *)NULL
);
3402 dynamic_complete_history (count
, key
)
3406 rl_compentry_func_t
*orig_func
;
3407 rl_completion_func_t
*orig_attempt_func
;
3408 rl_compignore_func_t
*orig_ignore_func
;
3410 orig_func
= rl_completion_entry_function
;
3411 orig_attempt_func
= rl_attempted_completion_function
;
3412 orig_ignore_func
= rl_ignore_some_completions_function
;
3414 rl_completion_entry_function
= history_completion_generator
;
3415 rl_attempted_completion_function
= (rl_completion_func_t
*)NULL
;
3416 rl_ignore_some_completions_function
= filename_completion_ignore
;
3418 /* XXX - use rl_completion_mode here? */
3419 if (rl_last_func
== dynamic_complete_history
)
3420 r
= rl_complete_internal ('?');
3422 r
= rl_complete_internal (TAB
);
3424 rl_completion_entry_function
= orig_func
;
3425 rl_attempted_completion_function
= orig_attempt_func
;
3426 rl_ignore_some_completions_function
= orig_ignore_func
;
3432 bash_dabbrev_expand (count
, key
)
3435 int r
, orig_suppress
, orig_sort
;
3436 rl_compentry_func_t
*orig_func
;
3437 rl_completion_func_t
*orig_attempt_func
;
3438 rl_compignore_func_t
*orig_ignore_func
;
3440 orig_func
= rl_menu_completion_entry_function
;
3441 orig_attempt_func
= rl_attempted_completion_function
;
3442 orig_ignore_func
= rl_ignore_some_completions_function
;
3443 orig_suppress
= rl_completion_suppress_append
;
3444 orig_sort
= rl_sort_completion_matches
;
3446 rl_menu_completion_entry_function
= history_completion_generator
;
3447 rl_attempted_completion_function
= (rl_completion_func_t
*)NULL
;
3448 rl_ignore_some_completions_function
= filename_completion_ignore
;
3449 rl_filename_completion_desired
= 0;
3450 rl_completion_suppress_append
= 1;
3451 rl_sort_completion_matches
= 0;
3453 /* XXX - use rl_completion_mode here? */
3454 dabbrev_expand_active
= 1;
3455 if (rl_last_func
== bash_dabbrev_expand
)
3456 rl_last_func
= rl_menu_complete
;
3457 r
= rl_menu_complete (count
, key
);
3458 dabbrev_expand_active
= 0;
3460 rl_last_func
= bash_dabbrev_expand
;
3461 rl_menu_completion_entry_function
= orig_func
;
3462 rl_attempted_completion_function
= orig_attempt_func
;
3463 rl_ignore_some_completions_function
= orig_ignore_func
;
3464 rl_completion_suppress_append
= orig_suppress
;
3465 rl_sort_completion_matches
= orig_sort
;
3470 #if defined (SPECIFIC_COMPLETION_FUNCTIONS)
3472 bash_complete_username (ignore
, ignore2
)
3473 int ignore
, ignore2
;
3475 return bash_complete_username_internal (rl_completion_mode (bash_complete_username
));
3479 bash_possible_username_completions (ignore
, ignore2
)
3480 int ignore
, ignore2
;
3482 return bash_complete_username_internal ('?');
3486 bash_complete_username_internal (what_to_do
)
3489 return bash_specific_completion (what_to_do
, rl_username_completion_function
);
3493 bash_complete_filename (ignore
, ignore2
)
3494 int ignore
, ignore2
;
3496 return bash_complete_filename_internal (rl_completion_mode (bash_complete_filename
));
3500 bash_possible_filename_completions (ignore
, ignore2
)
3501 int ignore
, ignore2
;
3503 return bash_complete_filename_internal ('?');
3507 bash_complete_filename_internal (what_to_do
)
3510 rl_compentry_func_t
*orig_func
;
3511 rl_completion_func_t
*orig_attempt_func
;
3512 rl_icppfunc_t
*orig_dir_func
;
3513 rl_compignore_func_t
*orig_ignore_func
;
3514 /*const*/ char *orig_rl_completer_word_break_characters
;
3517 orig_func
= rl_completion_entry_function
;
3518 orig_attempt_func
= rl_attempted_completion_function
;
3519 orig_ignore_func
= rl_ignore_some_completions_function
;
3520 orig_rl_completer_word_break_characters
= rl_completer_word_break_characters
;
3522 orig_dir_func
= save_directory_hook ();
3524 rl_completion_entry_function
= rl_filename_completion_function
;
3525 rl_attempted_completion_function
= (rl_completion_func_t
*)NULL
;
3526 rl_ignore_some_completions_function
= filename_completion_ignore
;
3527 rl_completer_word_break_characters
= " \t\n\"\'";
3529 r
= rl_complete_internal (what_to_do
);
3531 rl_completion_entry_function
= orig_func
;
3532 rl_attempted_completion_function
= orig_attempt_func
;
3533 rl_ignore_some_completions_function
= orig_ignore_func
;
3534 rl_completer_word_break_characters
= orig_rl_completer_word_break_characters
;
3536 restore_directory_hook (orig_dir_func
);
3542 bash_complete_hostname (ignore
, ignore2
)
3543 int ignore
, ignore2
;
3545 return bash_complete_hostname_internal (rl_completion_mode (bash_complete_hostname
));
3549 bash_possible_hostname_completions (ignore
, ignore2
)
3550 int ignore
, ignore2
;
3552 return bash_complete_hostname_internal ('?');
3556 bash_complete_variable (ignore
, ignore2
)
3557 int ignore
, ignore2
;
3559 return bash_complete_variable_internal (rl_completion_mode (bash_complete_variable
));
3563 bash_possible_variable_completions (ignore
, ignore2
)
3564 int ignore
, ignore2
;
3566 return bash_complete_variable_internal ('?');
3570 bash_complete_command (ignore
, ignore2
)
3571 int ignore
, ignore2
;
3573 return bash_complete_command_internal (rl_completion_mode (bash_complete_command
));
3577 bash_possible_command_completions (ignore
, ignore2
)
3578 int ignore
, ignore2
;
3580 return bash_complete_command_internal ('?');
3584 bash_complete_hostname_internal (what_to_do
)
3587 return bash_specific_completion (what_to_do
, hostname_completion_function
);
3591 bash_complete_variable_internal (what_to_do
)
3594 return bash_specific_completion (what_to_do
, variable_completion_function
);
3598 bash_complete_command_internal (what_to_do
)
3601 return bash_specific_completion (what_to_do
, command_word_completion_function
);
3604 static char *globtext
;
3605 static char *globorig
;
3608 glob_complete_word (text
, state
)
3612 static char **matches
= (char **)NULL
;
3619 rl_filename_completion_desired
= 1;
3621 if (globorig
!= globtext
)
3625 ttext
= bash_tilde_expand (text
, 0);
3627 if (rl_explicit_arg
)
3629 globorig
= savestring (ttext
);
3630 glen
= strlen (ttext
);
3631 globtext
= (char *)xmalloc (glen
+ 2);
3632 strcpy (globtext
, ttext
);
3633 globtext
[glen
] = '*';
3634 globtext
[glen
+1] = '\0';
3637 globtext
= globorig
= savestring (ttext
);
3642 matches
= shell_glob_filename (globtext
);
3643 if (GLOB_FAILED (matches
))
3644 matches
= (char **)NULL
;
3648 ret
= matches
? matches
[ind
] : (char *)NULL
;
3654 bash_glob_completion_internal (what_to_do
)
3657 return bash_specific_completion (what_to_do
, glob_complete_word
);
3660 /* A special quoting function so we don't end up quoting globbing characters
3661 in the word if there are no matches or multiple matches. */
3663 bash_glob_quote_filename (s
, rtype
, qcp
)
3668 if (globorig
&& qcp
&& *qcp
== '\0' && STREQ (s
, globorig
))
3669 return (savestring (s
));
3671 return (bash_quote_filename (s
, rtype
, qcp
));
3675 bash_glob_complete_word (count
, key
)
3679 rl_quote_func_t
*orig_quoting_function
;
3681 if (rl_editing_mode
== EMACS_EDITING_MODE
)
3682 rl_explicit_arg
= 1; /* force `*' append */
3683 orig_quoting_function
= rl_filename_quoting_function
;
3684 rl_filename_quoting_function
= bash_glob_quote_filename
;
3686 r
= bash_glob_completion_internal (rl_completion_mode (bash_glob_complete_word
));
3688 rl_filename_quoting_function
= orig_quoting_function
;
3693 bash_glob_expand_word (count
, key
)
3696 return bash_glob_completion_internal ('*');
3700 bash_glob_list_expansions (count
, key
)
3703 return bash_glob_completion_internal ('?');
3707 bash_specific_completion (what_to_do
, generator
)
3709 rl_compentry_func_t
*generator
;
3711 rl_compentry_func_t
*orig_func
;
3712 rl_completion_func_t
*orig_attempt_func
;
3713 rl_compignore_func_t
*orig_ignore_func
;
3716 orig_func
= rl_completion_entry_function
;
3717 orig_attempt_func
= rl_attempted_completion_function
;
3718 orig_ignore_func
= rl_ignore_some_completions_function
;
3719 rl_completion_entry_function
= generator
;
3720 rl_attempted_completion_function
= NULL
;
3721 rl_ignore_some_completions_function
= orig_ignore_func
;
3723 r
= rl_complete_internal (what_to_do
);
3725 rl_completion_entry_function
= orig_func
;
3726 rl_attempted_completion_function
= orig_attempt_func
;
3727 rl_ignore_some_completions_function
= orig_ignore_func
;
3732 #endif /* SPECIFIC_COMPLETION_FUNCTIONS */
3734 #if defined (VI_MODE)
3735 /* Completion, from vi mode's point of view. This is a modified version of
3736 rl_vi_complete which uses the bash globbing code to implement what POSIX
3737 specifies, which is to append a `*' and attempt filename generation (which
3738 has the side effect of expanding any globbing characters in the word). */
3740 bash_vi_complete (count
, key
)
3743 #if defined (SPECIFIC_COMPLETION_FUNCTIONS)
3747 if ((rl_point
< rl_end
) && (!whitespace (rl_line_buffer
[rl_point
])))
3749 if (!whitespace (rl_line_buffer
[rl_point
+ 1]))
3750 rl_vi_end_word (1, 'E');
3754 /* Find boundaries of current word, according to vi definition of a
3760 rl_vi_bWord (1, 'B');
3765 t
= substring (rl_line_buffer
, p
, rl_point
);
3768 if (t
&& glob_pattern_p (t
) == 0)
3769 rl_explicit_arg
= 1; /* XXX - force glob_complete_word to append `*' */
3772 if (key
== '*') /* Expansion and replacement. */
3773 r
= bash_glob_expand_word (count
, key
);
3774 else if (key
== '=') /* List possible completions. */
3775 r
= bash_glob_list_expansions (count
, key
);
3776 else if (key
== '\\') /* Standard completion */
3777 r
= bash_glob_complete_word (count
, key
);
3779 r
= rl_complete (0, key
);
3781 if (key
== '*' || key
== '\\')
3782 rl_vi_start_inserting (key
, 1, 1);
3786 return rl_vi_complete (count
, key
);
3787 #endif /* !SPECIFIC_COMPLETION_FUNCTIONS */
3789 #endif /* VI_MODE */
3791 /* Filename quoting for completion. */
3792 /* A function to strip unquoted quote characters (single quotes, double
3793 quotes, and backslashes). It allows single quotes to appear
3794 within double quotes, and vice versa. It should be smarter. */
3796 bash_dequote_filename (text
, quote_char
)
3804 ret
= (char *)xmalloc (l
+ 1);
3805 for (quoted
= quote_char
, p
= text
, r
= ret
; p
&& *p
; p
++)
3807 /* Allow backslash-escaped characters to pass through unscathed. */
3810 /* Backslashes are preserved within single quotes. */
3813 /* Backslashes are preserved within double quotes unless the
3814 character is one that is defined to be escaped */
3815 else if (quoted
== '"' && ((sh_syntaxtab
[p
[1]] & CBSDQUOTE
) == 0))
3820 return ret
; /* XXX - was break; */
3824 if (quoted
&& *p
== quoted
)
3830 if (quoted
== 0 && (*p
== '\'' || *p
== '"'))
3841 /* Quote characters that the readline completion code would treat as
3842 word break characters with backslashes. Pass backslash-quoted
3843 characters through without examination. */
3845 quote_word_break_chars (text
)
3852 ret
= (char *)xmalloc ((2 * l
) + 1);
3853 for (s
= text
, r
= ret
; *s
; s
++)
3855 /* Pass backslash-quoted characters through, including the backslash. */
3864 /* OK, we have an unquoted character. Check its presence in
3865 rl_completer_word_break_characters. */
3866 if (mbschr (rl_completer_word_break_characters
, *s
))
3868 /* XXX -- check for standalone tildes here and backslash-quote them */
3869 if (s
== text
&& *s
== '~' && file_exists (text
))
3877 /* Use characters in STRING to populate the table of characters that should
3878 be backslash-quoted. The table will be used for sh_backslash_quote from
3881 set_filename_bstab (string
)
3886 memset (filename_bstab
, 0, sizeof (filename_bstab
));
3887 for (s
= string
; s
&& *s
; s
++)
3888 filename_bstab
[*s
] = 1;
3891 /* Quote a filename using double quotes, single quotes, or backslashes
3892 depending on the value of completion_quoting_style. If we're
3893 completing using backslashes, we need to quote some additional
3894 characters (those that readline treats as word breaks), so we call
3895 quote_word_break_chars on the result. This returns newly-allocated
3898 bash_quote_filename (s
, rtype
, qcp
)
3903 char *rtext
, *mtext
, *ret
;
3906 rtext
= (char *)NULL
;
3908 /* If RTYPE == MULT_MATCH, it means that there is
3909 more than one match. In this case, we do not add
3910 the closing quote or attempt to perform tilde
3911 expansion. If RTYPE == SINGLE_MATCH, we try
3912 to perform tilde expansion, because single and double
3913 quotes inhibit tilde expansion by the shell. */
3915 cs
= completion_quoting_style
;
3916 /* Might need to modify the default completion style based on *qcp,
3917 since it's set to any user-provided opening quote. We also change
3918 to single-quoting if there is no user-provided opening quote and
3919 the word being completed contains newlines, since those are not
3920 quoted correctly using backslashes (a backslash-newline pair is
3921 special to the shell parser). */
3922 if (*qcp
== '\0' && cs
== COMPLETE_BSQUOTE
&& mbschr (s
, '\n'))
3923 cs
= COMPLETE_SQUOTE
;
3924 else if (*qcp
== '"')
3925 cs
= COMPLETE_DQUOTE
;
3926 else if (*qcp
== '\'')
3927 cs
= COMPLETE_SQUOTE
;
3928 #if defined (BANG_HISTORY)
3929 else if (*qcp
== '\0' && history_expansion
&& cs
== COMPLETE_DQUOTE
&&
3930 history_expansion_inhibited
== 0 && mbschr (s
, '!'))
3931 cs
= COMPLETE_BSQUOTE
;
3933 if (*qcp
== '"' && history_expansion
&& cs
== COMPLETE_DQUOTE
&&
3934 history_expansion_inhibited
== 0 && mbschr (s
, '!'))
3936 cs
= COMPLETE_BSQUOTE
;
3941 /* Don't tilde-expand backslash-quoted filenames, since only single and
3942 double quotes inhibit tilde expansion. */
3944 if (mtext
[0] == '~' && rtype
== SINGLE_MATCH
&& cs
!= COMPLETE_BSQUOTE
)
3945 mtext
= bash_tilde_expand (s
, 0);
3949 case COMPLETE_DQUOTE
:
3950 rtext
= sh_double_quote (mtext
);
3952 case COMPLETE_SQUOTE
:
3953 rtext
= sh_single_quote (mtext
);
3955 case COMPLETE_BSQUOTE
:
3956 rtext
= sh_backslash_quote (mtext
, complete_fullquote
? 0 : filename_bstab
, 0);
3963 /* We may need to quote additional characters: those that readline treats
3964 as word breaks that are not quoted by backslash_quote. */
3965 if (rtext
&& cs
== COMPLETE_BSQUOTE
)
3967 mtext
= quote_word_break_chars (rtext
);
3972 /* Leave the opening quote intact. The readline completion code takes
3973 care of avoiding doubled opening quotes. */
3976 rlen
= strlen (rtext
);
3977 ret
= (char *)xmalloc (rlen
+ 1);
3978 strcpy (ret
, rtext
);
3982 ret
= (char *)xmalloc (rlen
= 1);
3986 /* If there are multiple matches, cut off the closing quote. */
3987 if (rtype
== MULT_MATCH
&& cs
!= COMPLETE_BSQUOTE
)
3988 ret
[rlen
- 1] = '\0';
3993 /* Support for binding readline key sequences to Unix commands. */
3994 static Keymap cmd_xmap
;
4005 x
= putc (c
, rl_outstream
);
4012 bash_execute_unix_command (count
, key
)
4013 int count
; /* ignored */
4016 Keymap ckmap
; /* current keymap */
4017 Keymap xkmap
; /* unix command executing keymap */
4018 rl_command_func_t
*func
;
4022 sh_parser_state_t ps
;
4023 char *cmd
, *value
, *l
, *l1
, *ce
;
4025 char ibuf
[INT_STRLEN_BOUND(int) + 1];
4027 /* First, we need to find the right command to execute. This is tricky,
4028 because we might have already indirected into another keymap, so we
4029 have to walk cmd_xmap using the entire key sequence. */
4030 cmd
= (char *)rl_function_of_keyseq (rl_executing_keyseq
, cmd_xmap
, &type
);
4032 if (cmd
== 0 || type
!= ISMACR
)
4035 internal_error (_("bash_execute_unix_command: cannot find keymap for command"));
4036 rl_forced_update_display ();
4040 ce
= rl_get_termcap ("ce");
4041 if (ce
) /* clear current line */
4043 fprintf (rl_outstream
, "\r");
4044 tputs (ce
, 1, putx
);
4045 fflush (rl_outstream
);
4048 rl_crlf (); /* move to a new line */
4050 v
= bind_variable ("READLINE_LINE", rl_line_buffer
, 0);
4052 VSETATTR (v
, att_exported
);
4053 l
= v
? value_cell (v
) : 0;
4054 value
= inttostr (rl_point
, ibuf
, sizeof (ibuf
));
4055 v
= bind_int_variable ("READLINE_POINT", value
);
4057 VSETATTR (v
, att_exported
);
4058 array_needs_making
= 1;
4060 save_parser_state (&ps
);
4061 r
= parse_and_execute (cmd
, "bash_execute_unix_command", SEVAL_NOHIST
|SEVAL_NOFREE
);
4062 restore_parser_state (&ps
);
4064 v
= find_variable ("READLINE_LINE");
4065 l1
= v
? value_cell (v
) : 0;
4067 maybe_make_readline_line (value_cell (v
));
4068 v
= find_variable ("READLINE_POINT");
4069 if (v
&& legal_number (value_cell (v
), &mi
))
4075 if (rl_point
> rl_end
)
4077 else if (rl_point
< 0)
4082 unbind_variable ("READLINE_LINE");
4083 unbind_variable ("READLINE_POINT");
4084 array_needs_making
= 1;
4086 /* and restore the readline buffer and display after command execution. */
4087 rl_forced_update_display ();
4092 print_unix_command_map ()
4096 save
= rl_get_keymap ();
4097 rl_set_keymap (cmd_xmap
);
4098 rl_macro_dumper (1);
4099 rl_set_keymap (save
);
4104 init_unix_command_map ()
4106 cmd_xmap
= rl_make_bare_keymap ();
4110 isolate_sequence (string
, ind
, need_dquote
, startp
)
4112 int ind
, need_dquote
, *startp
;
4115 int c
, passc
, delim
;
4117 for (i
= ind
; string
[i
] && whitespace (string
[i
]); i
++)
4119 /* NEED_DQUOTE means that the first non-white character *must* be `"'. */
4120 if (need_dquote
&& string
[i
] != '"')
4122 builtin_error (_("%s: first non-whitespace character is not `\"'"), string
);
4126 /* We can have delimited strings even if NEED_DQUOTE == 0, like the command
4127 string to bind the key sequence to. */
4128 delim
= (string
[i
] == '"' || string
[i
] == '\'') ? string
[i
] : 0;
4131 *startp
= delim
? ++i
: i
;
4133 for (passc
= 0; c
= string
[i
]; i
++)
4149 if (delim
&& string
[i
] != delim
)
4151 builtin_error (_("no closing `%c' in %s"), delim
, string
);
4159 bind_keyseq_to_unix_command (line
)
4167 init_unix_command_map ();
4169 kmap
= rl_get_keymap ();
4171 /* We duplicate some of the work done by rl_parse_and_bind here, but
4172 this code only has to handle `"keyseq": ["]command["]' and can
4173 generate an error for anything else. */
4174 i
= isolate_sequence (line
, 0, 1, &kstart
);
4178 /* Create the key sequence string to pass to rl_generic_bind */
4179 kseq
= substring (line
, kstart
, i
);
4181 for ( ; line
[i
] && line
[i
] != ':'; i
++)
4185 builtin_error (_("%s: missing colon separator"), line
);
4190 i
= isolate_sequence (line
, i
+ 1, 0, &kstart
);
4197 /* Create the value string containing the command to execute. */
4198 value
= substring (line
, kstart
, i
);
4200 /* Save the command to execute and the key sequence in the CMD_XMAP */
4201 rl_generic_bind (ISMACR
, kseq
, value
, cmd_xmap
);
4203 /* and bind the key sequence in the current keymap to a function that
4204 understands how to execute from CMD_XMAP */
4205 rl_bind_keyseq_in_map (kseq
, bash_execute_unix_command
, kmap
);
4211 /* Used by the programmable completion code. Complete TEXT as a filename,
4212 but return only directories as matches. Dequotes the filename before
4213 attempting to find matches. */
4215 bash_directory_completion_matches (text
)
4222 qc
= rl_dispatching
? rl_completion_quote_character
: 0;
4223 /* If rl_completion_found_quote != 0, rl_completion_matches will call the
4224 filename dequoting function, causing the directory name to be dequoted
4226 if (rl_dispatching
&& rl_completion_found_quote
== 0)
4227 dfn
= bash_dequote_filename ((char *)text
, qc
);
4230 m1
= rl_completion_matches (dfn
, rl_filename_completion_function
);
4234 if (m1
== 0 || m1
[0] == 0)
4236 /* We don't bother recomputing the lcd of the matches, because it will just
4237 get thrown away by the programmable completion code and recomputed
4239 (void)bash_ignore_filenames (m1
);
4244 bash_dequote_text (text
)
4250 qc
= (text
[0] == '"' || text
[0] == '\'') ? text
[0] : 0;
4251 dtxt
= bash_dequote_filename ((char *)text
, qc
);
4255 /* This event hook is designed to be called after readline receives a signal
4256 that interrupts read(2). It gives reasonable responsiveness to interrupts
4257 and fatal signals without executing too much code in a signal handler
4262 /* If we're going to longjmp to top_level, make sure we clean up readline.
4263 check_signals will call QUIT, which will eventually longjmp to top_level,
4264 calling run_interrupt_trap along the way. The check for sigalrm_seen is
4265 to clean up the read builtin's state. */
4266 if (terminating_signal
|| interrupt_state
|| sigalrm_seen
)
4267 rl_cleanup_after_signal ();
4268 bashline_reset_event_hook ();
4269 check_signals_and_traps (); /* XXX */
4273 #endif /* READLINE */