1 /* bashline.c -- Bash's interface to the readline library. */
3 /* Copyright (C) 1987-2017 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"
53 #include "execute_cmd.h"
60 #if defined (HAVE_MBSTR_H) && defined (HAVE_MBSCHR)
61 # include <mbstr.h> /* mbschr */
64 #include "builtins/common.h"
66 #include <readline/rlconf.h>
67 #include <readline/readline.h>
68 #include <readline/history.h>
69 #include <readline/rlmbutil.h>
71 #include <glob/glob.h>
77 #if defined (PROGRAMMABLE_COMPLETION)
78 # include "pcomplete.h"
81 /* These should agree with the defines for emacs_mode and vi_mode in
82 rldefs.h, even though that's not a public readline header file. */
83 #ifndef EMACS_EDITING_MODE
84 # define NO_EDITING_MODE -1
85 # define EMACS_EDITING_MODE 1
86 # define VI_EDITING_MODE 0
89 #define RL_BOOLEAN_VARIABLE_VALUE(s) ((s)[0] == 'o' && (s)[1] == 'n' && (s)[2] == '\0')
91 #if defined (BRACE_COMPLETION)
92 extern int bash_brace_completion
__P((int, int));
93 #endif /* BRACE_COMPLETION */
95 /* To avoid including curses.h/term.h/termcap.h and that whole mess. */
97 extern int tputs
__P((const char *string
, int nlines
, void (*outx
)(int)));
99 extern int tputs
__P((const char *string
, int nlines
, int (*outx
)(int)));
102 /* Forward declarations */
104 /* Functions bound to keys in Readline for Bash users. */
105 static int shell_expand_line
__P((int, int));
106 static int display_shell_version
__P((int, int));
107 static int operate_and_get_next
__P((int, int));
109 static int bash_ignore_filenames
__P((char **));
110 static int bash_ignore_everything
__P((char **));
112 #if defined (BANG_HISTORY)
113 static char *history_expand_line_internal
__P((char *));
114 static int history_expand_line
__P((int, int));
115 static int tcsh_magic_space
__P((int, int));
116 #endif /* BANG_HISTORY */
118 static int alias_expand_line
__P((int, int));
120 #if defined (BANG_HISTORY) && defined (ALIAS)
121 static int history_and_alias_expand_line
__P((int, int));
124 static int bash_forward_shellword
__P((int, int));
125 static int bash_backward_shellword
__P((int, int));
126 static int bash_kill_shellword
__P((int, int));
127 static int bash_backward_kill_shellword
__P((int, int));
129 /* Helper functions for Readline. */
130 static char *restore_tilde
__P((char *, char *));
131 static char *maybe_restore_tilde
__P((char *, char *));
133 static char *bash_filename_rewrite_hook
__P((char *, int));
135 static void bash_directory_expansion
__P((char **));
136 static int bash_filename_stat_hook
__P((char **));
137 static int bash_command_name_stat_hook
__P((char **));
138 static int bash_directory_completion_hook
__P((char **));
139 static int filename_completion_ignore
__P((char **));
140 static int bash_push_line
__P((void));
142 static int executable_completion
__P((const char *, int));
144 static rl_icppfunc_t
*save_directory_hook
__P((void));
145 static void restore_directory_hook
__P((rl_icppfunc_t
));
147 static int directory_exists
__P((const char *, int));
149 static void cleanup_expansion_error
__P((void));
150 static void maybe_make_readline_line
__P((char *));
151 static void set_up_new_line
__P((char *));
153 static int check_redir
__P((int));
154 static char **attempt_shell_completion
__P((const char *, int, int));
155 static char *variable_completion_function
__P((const char *, int));
156 static char *hostname_completion_function
__P((const char *, int));
157 static char *command_subst_completion_function
__P((const char *, int));
159 static void build_history_completion_array
__P((void));
160 static char *history_completion_generator
__P((const char *, int));
161 static int dynamic_complete_history
__P((int, int));
162 static int bash_dabbrev_expand
__P((int, int));
164 static void initialize_hostname_list
__P((void));
165 static void add_host_name
__P((char *));
166 static void snarf_hosts_from_file
__P((char *));
167 static char **hostnames_matching
__P((char *));
169 static void _ignore_completion_names
__P((char **, sh_ignore_func_t
*));
170 static int name_is_acceptable
__P((const char *));
171 static int test_for_directory
__P((const char *));
172 static int return_zero
__P((const char *));
174 static char *bash_dequote_filename
__P((char *, int));
175 static char *quote_word_break_chars
__P((char *));
176 static void set_filename_bstab
__P((const char *));
177 static char *bash_quote_filename
__P((char *, int, char *));
180 static void putx
__P((int));
182 static int putx
__P((int));
184 static int bash_execute_unix_command
__P((int, int));
185 static void init_unix_command_map
__P((void));
186 static int isolate_sequence
__P((char *, int, int, int *));
188 static int set_saved_history
__P((void));
191 static int posix_edit_macros
__P((int, int));
194 static int bash_event_hook
__P((void));
196 #if defined (PROGRAMMABLE_COMPLETION)
197 static int find_cmd_start
__P((int));
198 static int find_cmd_end
__P((int));
199 static char *find_cmd_name
__P((int, int *, int *));
200 static char *prog_complete_return
__P((const char *, int));
202 static char **prog_complete_matches
;
205 extern int no_symbolic_links
;
206 extern STRING_INT_ALIST word_token_alist
[];
208 /* SPECIFIC_COMPLETION_FUNCTIONS specifies that we have individual
209 completion functions which indicate what type of completion should be
210 done (at or before point) that can be bound to key sequences with
211 the readline library. */
212 #define SPECIFIC_COMPLETION_FUNCTIONS
214 #if defined (SPECIFIC_COMPLETION_FUNCTIONS)
215 static int bash_specific_completion
__P((int, rl_compentry_func_t
*));
217 static int bash_complete_filename_internal
__P((int));
218 static int bash_complete_username_internal
__P((int));
219 static int bash_complete_hostname_internal
__P((int));
220 static int bash_complete_variable_internal
__P((int));
221 static int bash_complete_command_internal
__P((int));
223 static int bash_complete_filename
__P((int, int));
224 static int bash_possible_filename_completions
__P((int, int));
225 static int bash_complete_username
__P((int, int));
226 static int bash_possible_username_completions
__P((int, int));
227 static int bash_complete_hostname
__P((int, int));
228 static int bash_possible_hostname_completions
__P((int, int));
229 static int bash_complete_variable
__P((int, int));
230 static int bash_possible_variable_completions
__P((int, int));
231 static int bash_complete_command
__P((int, int));
232 static int bash_possible_command_completions
__P((int, int));
234 static int completion_glob_pattern
__P((char *));
235 static char *glob_complete_word
__P((const char *, int));
236 static int bash_glob_completion_internal
__P((int));
237 static int bash_glob_complete_word
__P((int, int));
238 static int bash_glob_expand_word
__P((int, int));
239 static int bash_glob_list_expansions
__P((int, int));
241 #endif /* SPECIFIC_COMPLETION_FUNCTIONS */
243 static int edit_and_execute_command
__P((int, int, int, char *));
244 #if defined (VI_MODE)
245 static int vi_edit_and_execute_command
__P((int, int));
246 static int bash_vi_complete
__P((int, int));
248 static int emacs_edit_and_execute_command
__P((int, int));
250 /* Non-zero once initalize_readline () has been called. */
251 int bash_readline_initialized
= 0;
253 /* If non-zero, we do hostname completion, breaking words at `@' and
254 trying to complete the stuff after the `@' from our own internal
256 int perform_hostname_completion
= 1;
258 /* If non-zero, we don't do command completion on an empty line. */
259 int no_empty_command_completion
;
261 /* Set FORCE_FIGNORE if you want to honor FIGNORE even if it ignores the
262 only possible matches. Set to 0 if you want to match filenames if they
263 are the only possible matches, even if FIGNORE says to. */
264 int force_fignore
= 1;
266 /* Perform spelling correction on directory names during word completion */
267 int dircomplete_spelling
= 0;
269 /* Expand directory names during word/filename completion. */
270 #if DIRCOMPLETE_EXPAND_DEFAULT
271 int dircomplete_expand
= 1;
272 int dircomplete_expand_relpath
= 1;
274 int dircomplete_expand
= 0;
275 int dircomplete_expand_relpath
= 0;
278 /* When non-zero, perform `normal' shell quoting on completed filenames
279 even when the completed name contains a directory name with a shell
280 variable referene, so dollar signs in a filename get quoted appropriately.
281 Set to zero to remove dollar sign (and braces or parens as needed) from
282 the set of characters that will be quoted. */
283 int complete_fullquote
= 1;
285 static char *bash_completer_word_break_characters
= " \t\n\"'@><=;|&(:";
286 static char *bash_nohostname_word_break_characters
= " \t\n\"'><=;|&(:";
289 static const char *default_filename_quote_characters
= " \t\n\\\"'@<>=;|&()#$`?*[!:{~"; /*}*/
290 static char *custom_filename_quote_characters
= 0;
291 static char filename_bstab
[256];
293 static rl_hook_func_t
*old_rl_startup_hook
= (rl_hook_func_t
*)NULL
;
295 static int dot_in_path
= 0;
297 /* Set to non-zero when dabbrev-expand is running */
298 static int dabbrev_expand_active
= 0;
300 /* What kind of quoting is performed by bash_quote_filename:
301 COMPLETE_DQUOTE = double-quoting the filename
302 COMPLETE_SQUOTE = single_quoting the filename
303 COMPLETE_BSQUOTE = backslash-quoting special chars in the filename
305 #define COMPLETE_DQUOTE 1
306 #define COMPLETE_SQUOTE 2
307 #define COMPLETE_BSQUOTE 3
308 static int completion_quoting_style
= COMPLETE_BSQUOTE
;
310 /* Flag values for the final argument to bash_default_completion */
311 #define DEFCOMP_CMDPOS 1
313 /* Change the readline VI-mode keymaps into or out of Posix.2 compliance.
314 Called when the shell is put into or out of `posix' mode. */
316 posix_readline_initialize (on_or_off
)
320 rl_variable_bind ("comment-begin", "#");
321 #if defined (VI_MODE)
322 rl_bind_key_in_map (CTRL ('I'), on_or_off
? rl_insert
: rl_complete
, vi_insertion_keymap
);
327 reset_completer_word_break_chars ()
329 rl_completer_word_break_characters
= perform_hostname_completion
? savestring (bash_completer_word_break_characters
) : savestring (bash_nohostname_word_break_characters
);
332 /* When this function returns, rl_completer_word_break_characters points to
333 dynamically allocated memory. */
335 enable_hostname_completion (on_or_off
)
339 char *at
, *nv
, *nval
;
341 old_value
= perform_hostname_completion
;
345 perform_hostname_completion
= 1;
346 rl_special_prefixes
= "$@";
350 perform_hostname_completion
= 0;
351 rl_special_prefixes
= "$";
354 /* Now we need to figure out how to appropriately modify and assign
355 rl_completer_word_break_characters depending on whether we want
356 hostname completion on or off. */
358 /* If this is the first time this has been called
359 (bash_readline_initialized == 0), use the sames values as before, but
360 allocate new memory for rl_completer_word_break_characters. */
362 if (bash_readline_initialized
== 0 &&
363 (rl_completer_word_break_characters
== 0 ||
364 rl_completer_word_break_characters
== rl_basic_word_break_characters
))
367 rl_completer_word_break_characters
= savestring (bash_completer_word_break_characters
);
369 rl_completer_word_break_characters
= savestring (bash_nohostname_word_break_characters
);
373 /* See if we have anything to do. */
374 at
= strchr (rl_completer_word_break_characters
, '@');
375 if ((at
== 0 && on_or_off
== 0) || (at
!= 0 && on_or_off
!= 0))
378 /* We have something to do. Do it. */
379 nval
= (char *)xmalloc (strlen (rl_completer_word_break_characters
) + 1 + on_or_off
);
383 /* Turn it off -- just remove `@' from word break chars. We want
384 to remove all occurrences of `@' from the char list, so we loop
385 rather than just copy the rest of the list over AT. */
386 for (nv
= nval
, at
= rl_completer_word_break_characters
; *at
; )
396 strcpy (nval
+ 1, rl_completer_word_break_characters
);
399 free (rl_completer_word_break_characters
);
400 rl_completer_word_break_characters
= nval
;
406 /* Called once from parse.y if we are going to use readline. */
408 initialize_readline ()
410 rl_command_func_t
*func
;
413 if (bash_readline_initialized
)
416 rl_terminal_name
= get_string_value ("TERM");
418 rl_outstream
= stderr
;
420 /* Allow conditional parsing of the ~/.inputrc file. */
421 rl_readline_name
= "Bash";
423 /* Add bindable names before calling rl_initialize so they may be
424 referenced in the various inputrc files. */
425 rl_add_defun ("shell-expand-line", shell_expand_line
, -1);
427 rl_add_defun ("history-expand-line", history_expand_line
, -1);
428 rl_add_defun ("magic-space", tcsh_magic_space
, -1);
431 rl_add_defun ("shell-forward-word", bash_forward_shellword
, -1);
432 rl_add_defun ("shell-backward-word", bash_backward_shellword
, -1);
433 rl_add_defun ("shell-kill-word", bash_kill_shellword
, -1);
434 rl_add_defun ("shell-backward-kill-word", bash_backward_kill_shellword
, -1);
437 rl_add_defun ("alias-expand-line", alias_expand_line
, -1);
439 rl_add_defun ("history-and-alias-expand-line", history_and_alias_expand_line
, -1);
443 /* Backwards compatibility. */
444 rl_add_defun ("insert-last-argument", rl_yank_last_arg
, -1);
446 rl_add_defun ("operate-and-get-next", operate_and_get_next
, -1);
447 rl_add_defun ("display-shell-version", display_shell_version
, -1);
448 rl_add_defun ("edit-and-execute-command", emacs_edit_and_execute_command
, -1);
450 #if defined (BRACE_COMPLETION)
451 rl_add_defun ("complete-into-braces", bash_brace_completion
, -1);
454 #if defined (SPECIFIC_COMPLETION_FUNCTIONS)
455 rl_add_defun ("complete-filename", bash_complete_filename
, -1);
456 rl_add_defun ("possible-filename-completions", bash_possible_filename_completions
, -1);
457 rl_add_defun ("complete-username", bash_complete_username
, -1);
458 rl_add_defun ("possible-username-completions", bash_possible_username_completions
, -1);
459 rl_add_defun ("complete-hostname", bash_complete_hostname
, -1);
460 rl_add_defun ("possible-hostname-completions", bash_possible_hostname_completions
, -1);
461 rl_add_defun ("complete-variable", bash_complete_variable
, -1);
462 rl_add_defun ("possible-variable-completions", bash_possible_variable_completions
, -1);
463 rl_add_defun ("complete-command", bash_complete_command
, -1);
464 rl_add_defun ("possible-command-completions", bash_possible_command_completions
, -1);
465 rl_add_defun ("glob-complete-word", bash_glob_complete_word
, -1);
466 rl_add_defun ("glob-expand-word", bash_glob_expand_word
, -1);
467 rl_add_defun ("glob-list-expansions", bash_glob_list_expansions
, -1);
470 rl_add_defun ("dynamic-complete-history", dynamic_complete_history
, -1);
471 rl_add_defun ("dabbrev-expand", bash_dabbrev_expand
, -1);
473 /* Bind defaults before binding our custom shell keybindings. */
474 if (RL_ISSTATE(RL_STATE_INITIALIZED
) == 0)
477 /* Bind up our special shell functions. */
478 rl_bind_key_if_unbound_in_map (CTRL('E'), shell_expand_line
, emacs_meta_keymap
);
481 rl_bind_key_if_unbound_in_map ('^', history_expand_line
, emacs_meta_keymap
);
484 rl_bind_key_if_unbound_in_map (CTRL ('O'), operate_and_get_next
, emacs_standard_keymap
);
485 rl_bind_key_if_unbound_in_map (CTRL ('V'), display_shell_version
, emacs_ctlx_keymap
);
487 /* In Bash, the user can switch editing modes with "set -o [vi emacs]",
488 so it is not necessary to allow C-M-j for context switching. Turn
489 off this occasionally confusing behaviour. */
492 func
= rl_function_of_keyseq (kseq
, emacs_meta_keymap
, (int *)NULL
);
493 if (func
== rl_vi_editing_mode
)
494 rl_unbind_key_in_map (CTRL('J'), emacs_meta_keymap
);
496 func
= rl_function_of_keyseq (kseq
, emacs_meta_keymap
, (int *)NULL
);
497 if (func
== rl_vi_editing_mode
)
498 rl_unbind_key_in_map (CTRL('M'), emacs_meta_keymap
);
499 #if defined (VI_MODE)
500 rl_unbind_key_in_map (CTRL('E'), vi_movement_keymap
);
503 #if defined (BRACE_COMPLETION)
504 rl_bind_key_if_unbound_in_map ('{', bash_brace_completion
, emacs_meta_keymap
); /*}*/
505 #endif /* BRACE_COMPLETION */
507 #if defined (SPECIFIC_COMPLETION_FUNCTIONS)
508 rl_bind_key_if_unbound_in_map ('/', bash_complete_filename
, emacs_meta_keymap
);
509 rl_bind_key_if_unbound_in_map ('/', bash_possible_filename_completions
, emacs_ctlx_keymap
);
511 /* Have to jump through hoops here because there is a default binding for
512 M-~ (rl_tilde_expand) */
515 func
= rl_function_of_keyseq (kseq
, emacs_meta_keymap
, (int *)NULL
);
516 if (func
== 0 || func
== rl_tilde_expand
)
517 rl_bind_keyseq_in_map (kseq
, bash_complete_username
, emacs_meta_keymap
);
519 rl_bind_key_if_unbound_in_map ('~', bash_possible_username_completions
, emacs_ctlx_keymap
);
521 rl_bind_key_if_unbound_in_map ('@', bash_complete_hostname
, emacs_meta_keymap
);
522 rl_bind_key_if_unbound_in_map ('@', bash_possible_hostname_completions
, emacs_ctlx_keymap
);
524 rl_bind_key_if_unbound_in_map ('$', bash_complete_variable
, emacs_meta_keymap
);
525 rl_bind_key_if_unbound_in_map ('$', bash_possible_variable_completions
, emacs_ctlx_keymap
);
527 rl_bind_key_if_unbound_in_map ('!', bash_complete_command
, emacs_meta_keymap
);
528 rl_bind_key_if_unbound_in_map ('!', bash_possible_command_completions
, emacs_ctlx_keymap
);
530 rl_bind_key_if_unbound_in_map ('g', bash_glob_complete_word
, emacs_meta_keymap
);
531 rl_bind_key_if_unbound_in_map ('*', bash_glob_expand_word
, emacs_ctlx_keymap
);
532 rl_bind_key_if_unbound_in_map ('g', bash_glob_list_expansions
, emacs_ctlx_keymap
);
534 #endif /* SPECIFIC_COMPLETION_FUNCTIONS */
538 func
= rl_function_of_keyseq (kseq
, emacs_meta_keymap
, (int *)NULL
);
539 if (func
== 0 || func
== rl_tab_insert
)
540 rl_bind_key_in_map (TAB
, dynamic_complete_history
, emacs_meta_keymap
);
542 /* Tell the completer that we want a crack first. */
543 rl_attempted_completion_function
= attempt_shell_completion
;
545 /* Tell the completer that we might want to follow symbolic links or
546 do other expansion on directory names. */
547 set_directory_hook ();
549 rl_filename_rewrite_hook
= bash_filename_rewrite_hook
;
551 rl_filename_stat_hook
= bash_filename_stat_hook
;
553 /* Tell the filename completer we want a chance to ignore some names. */
554 rl_ignore_some_completions_function
= filename_completion_ignore
;
556 /* Bind C-xC-e to invoke emacs and run result as commands. */
557 rl_bind_key_if_unbound_in_map (CTRL ('E'), emacs_edit_and_execute_command
, emacs_ctlx_keymap
);
558 #if defined (VI_MODE)
559 rl_bind_key_if_unbound_in_map ('v', vi_edit_and_execute_command
, vi_movement_keymap
);
561 rl_bind_key_if_unbound_in_map ('@', posix_edit_macros
, vi_movement_keymap
);
564 rl_bind_key_in_map ('\\', bash_vi_complete
, 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
);
569 rl_completer_quote_characters
= "'\"";
571 /* This sets rl_completer_word_break_characters and rl_special_prefixes
572 to the appropriate values, depending on whether or not hostname
573 completion is enabled. */
574 enable_hostname_completion (perform_hostname_completion
);
576 /* characters that need to be quoted when appearing in filenames. */
577 rl_filename_quote_characters
= default_filename_quote_characters
;
578 set_filename_bstab (rl_filename_quote_characters
);
580 rl_filename_quoting_function
= bash_quote_filename
;
581 rl_filename_dequoting_function
= bash_dequote_filename
;
582 rl_char_is_quoted_p
= char_is_quoted
;
585 /* This is superfluous and makes it impossible to use tab completion in
586 vi mode even when explicitly binding it in ~/.inputrc. sv_strict_posix()
587 should already have called posix_readline_initialize() when
588 posixly_correct was set. */
590 posix_readline_initialize (1);
593 bash_readline_initialized
= 1;
597 bashline_reinitialize ()
599 bash_readline_initialized
= 0;
603 bashline_set_event_hook ()
605 rl_signal_event_hook
= bash_event_hook
;
609 bashline_reset_event_hook ()
611 rl_signal_event_hook
= 0;
614 /* On Sun systems at least, rl_attempted_completion_function can end up
615 getting set to NULL, and rl_completion_entry_function set to do command
616 word completion if Bash is interrupted while trying to complete a command
617 word. This just resets all the completion functions to the right thing.
618 It's called from throw_to_top_level(). */
623 rl_attempted_completion_function
= attempt_shell_completion
;
624 rl_completion_entry_function
= NULL
;
625 rl_ignore_some_completions_function
= filename_completion_ignore
;
626 rl_filename_quote_characters
= default_filename_quote_characters
;
627 set_filename_bstab (rl_filename_quote_characters
);
629 set_directory_hook ();
630 rl_filename_stat_hook
= bash_filename_stat_hook
;
632 bashline_reset_event_hook ();
634 rl_sort_completion_matches
= 1;
637 /* Contains the line to push into readline. */
638 static char *push_to_readline
= (char *)NULL
;
640 /* Push the contents of push_to_readline into the
645 if (push_to_readline
)
647 rl_insert_text (push_to_readline
);
648 free (push_to_readline
);
649 push_to_readline
= (char *)NULL
;
650 rl_startup_hook
= old_rl_startup_hook
;
655 /* Call this to set the initial text for the next line to read
661 FREE (push_to_readline
);
663 push_to_readline
= savestring (line
);
664 old_rl_startup_hook
= rl_startup_hook
;
665 rl_startup_hook
= bash_push_line
;
671 display_shell_version (count
, c
)
675 show_shell_version (0);
676 putc ('\r', rl_outstream
);
677 fflush (rl_outstream
);
683 /* **************************************************************** */
687 /* **************************************************************** */
689 /* If the user requests hostname completion, then simply build a list
690 of hosts, and complete from that forever more, or at least until
691 HOSTFILE is unset. */
693 /* THIS SHOULD BE A STRINGLIST. */
694 /* The kept list of hostnames. */
695 static char **hostname_list
= (char **)NULL
;
697 /* The physical size of the above list. */
698 static int hostname_list_size
;
700 /* The number of hostnames in the above list. */
701 static int hostname_list_length
;
703 /* Whether or not HOSTNAME_LIST has been initialized. */
704 int hostname_list_initialized
= 0;
706 /* Initialize the hostname completion table. */
708 initialize_hostname_list ()
712 temp
= get_string_value ("HOSTFILE");
714 temp
= get_string_value ("hostname_completion_file");
716 temp
= DEFAULT_HOSTS_FILE
;
718 snarf_hosts_from_file (temp
);
721 hostname_list_initialized
++;
724 /* Add NAME to the list of hosts. */
729 if (hostname_list_length
+ 2 > hostname_list_size
)
731 hostname_list_size
= (hostname_list_size
+ 32) - (hostname_list_size
% 32);
732 hostname_list
= strvec_resize (hostname_list
, hostname_list_size
);
735 hostname_list
[hostname_list_length
++] = savestring (name
);
736 hostname_list
[hostname_list_length
] = (char *)NULL
;
739 #define cr_whitespace(c) ((c) == '\r' || (c) == '\n' || whitespace(c))
742 snarf_hosts_from_file (filename
)
746 char *temp
, buffer
[256], name
[256];
747 register int i
, start
;
749 file
= fopen (filename
, "r");
753 while (temp
= fgets (buffer
, 255, file
))
755 /* Skip to first character. */
756 for (i
= 0; buffer
[i
] && cr_whitespace (buffer
[i
]); i
++)
759 /* If comment or blank line, ignore. */
760 if (buffer
[i
] == '\0' || buffer
[i
] == '#')
763 /* If `preprocessor' directive, do the include. */
764 if (strncmp (buffer
+ i
, "$include ", 9) == 0)
768 /* Find start of filename. */
769 for (incfile
= buffer
+ i
+ 9; *incfile
&& whitespace (*incfile
); incfile
++)
772 /* Find end of filename. */
773 for (t
= incfile
; *t
&& cr_whitespace (*t
) == 0; t
++)
778 snarf_hosts_from_file (incfile
);
782 /* Skip internet address if present. */
783 if (DIGIT (buffer
[i
]))
784 for (; buffer
[i
] && cr_whitespace (buffer
[i
]) == 0; i
++);
786 /* Gobble up names. Each name is separated with whitespace. */
789 for (; cr_whitespace (buffer
[i
]); i
++)
791 if (buffer
[i
] == '\0' || buffer
[i
] == '#')
794 /* Isolate the current word. */
795 for (start
= i
; buffer
[i
] && cr_whitespace (buffer
[i
]) == 0; i
++)
799 strncpy (name
, buffer
+ start
, i
- start
);
800 name
[i
- start
] = '\0';
801 add_host_name (name
);
807 /* Return the hostname list. */
811 if (hostname_list_initialized
== 0)
812 initialize_hostname_list ();
813 return (hostname_list
);
817 clear_hostname_list ()
821 if (hostname_list_initialized
== 0)
823 for (i
= 0; i
< hostname_list_length
; i
++)
824 free (hostname_list
[i
]);
825 hostname_list_length
= hostname_list_initialized
= 0;
828 /* Return a NULL terminated list of hostnames which begin with TEXT.
829 Initialize the hostname list the first time if necessary.
830 The array is malloc ()'ed, but not the individual strings. */
832 hostnames_matching (text
)
835 register int i
, len
, nmatch
, rsize
;
838 if (hostname_list_initialized
== 0)
839 initialize_hostname_list ();
841 if (hostname_list_initialized
== 0)
842 return ((char **)NULL
);
844 /* Special case. If TEXT consists of nothing, then the whole list is
848 result
= strvec_create (1 + hostname_list_length
);
849 for (i
= 0; i
< hostname_list_length
; i
++)
850 result
[i
] = hostname_list
[i
];
851 result
[i
] = (char *)NULL
;
855 /* Scan until found, or failure. */
857 result
= (char **)NULL
;
858 for (i
= nmatch
= rsize
= 0; i
< hostname_list_length
; i
++)
860 if (STREQN (text
, hostname_list
[i
], len
) == 0)
863 /* OK, it matches. Add it to the list. */
864 if (nmatch
>= (rsize
- 1))
866 rsize
= (rsize
+ 16) - (rsize
% 16);
867 result
= strvec_resize (result
, rsize
);
870 result
[nmatch
++] = hostname_list
[i
];
873 result
[nmatch
] = (char *)NULL
;
877 /* The equivalent of the Korn shell C-o operate-and-get-next-history-line
879 static int saved_history_line_to_use
= -1;
880 static int last_saved_history_line
= -1;
882 #define HISTORY_FULL() (history_is_stifled () && history_length >= history_max_entries)
887 /* XXX - compensate for assumption that history was `shuffled' if it was
889 if (HISTORY_FULL () &&
890 hist_last_line_added
== 0 &&
891 saved_history_line_to_use
< history_length
- 1)
892 saved_history_line_to_use
++;
894 if (saved_history_line_to_use
>= 0)
896 rl_get_previous_history (history_length
- saved_history_line_to_use
, 0);
897 last_saved_history_line
= saved_history_line_to_use
;
899 saved_history_line_to_use
= -1;
900 rl_startup_hook
= old_rl_startup_hook
;
905 operate_and_get_next (count
, c
)
910 /* Accept the current line. */
913 /* Find the current line, and find the next line to use. */
914 where
= rl_explicit_arg
? count
: where_history ();
916 if (HISTORY_FULL () || (where
>= history_length
- 1) || rl_explicit_arg
)
917 saved_history_line_to_use
= where
;
919 saved_history_line_to_use
= where
+ 1;
921 old_rl_startup_hook
= rl_startup_hook
;
922 rl_startup_hook
= set_saved_history
;
927 /* This vi mode command causes VI_EDIT_COMMAND to be run on the current
928 command being entered (if no explicit argument is given), otherwise on
929 a command from the history file. */
931 #define VI_EDIT_COMMAND "fc -e \"${VISUAL:-${EDITOR:-vi}}\""
932 #define EMACS_EDIT_COMMAND "fc -e \"${VISUAL:-${EDITOR:-emacs}}\""
933 #define POSIX_VI_EDIT_COMMAND "fc -e vi"
936 edit_and_execute_command (count
, c
, editing_mode
, edit_command
)
937 int count
, c
, editing_mode
;
940 char *command
, *metaval
;
941 int r
, rrs
, metaflag
;
942 sh_parser_state_t ps
;
944 rrs
= rl_readline_state
;
945 saved_command_line_count
= current_command_line_count
;
947 /* Accept the current line. */
952 command
= (char *)xmalloc (strlen (edit_command
) + 8);
953 sprintf (command
, "%s %d", edit_command
, count
);
957 /* Take the command we were just editing, add it to the history file,
958 then call fc to operate on it. We have to add a dummy command to
959 the end of the history because fc ignores the last command (assumes
960 it's supposed to deal with the command before the `fc'). */
961 /* This breaks down when using command-oriented history and are not
962 finished with the command, so we should not ignore the last command */
964 if (rl_line_buffer
[0])
966 current_command_line_count
++; /* for rl_newline above */
967 bash_add_history (rl_line_buffer
);
969 current_command_line_count
= 0; /* for dummy history entry */
970 bash_add_history ("");
971 history_lines_this_session
++;
973 command
= savestring (edit_command
);
976 metaval
= rl_variable_value ("input-meta");
977 metaflag
= RL_BOOLEAN_VARIABLE_VALUE (metaval
);
979 if (rl_deprep_term_function
)
980 (*rl_deprep_term_function
) ();
981 save_parser_state (&ps
);
982 r
= parse_and_execute (command
, (editing_mode
== VI_EDITING_MODE
) ? "v" : "C-xC-e", SEVAL_NOHIST
);
983 restore_parser_state (&ps
);
984 if (rl_prep_term_function
)
985 (*rl_prep_term_function
) (metaflag
);
987 current_command_line_count
= saved_command_line_count
;
989 /* Now erase the contents of the current line and undo the effects of the
990 rl_accept_line() above. We don't even want to make the text we just
991 executed available for undoing. */
992 rl_line_buffer
[0] = '\0'; /* XXX */
993 rl_point
= rl_end
= 0;
995 rl_readline_state
= rrs
;
997 #if defined (VI_MODE)
998 if (editing_mode
== VI_EDITING_MODE
)
999 rl_vi_insertion_mode (1, c
);
1002 rl_forced_update_display ();
1007 #if defined (VI_MODE)
1009 vi_edit_and_execute_command (count
, c
)
1012 if (posixly_correct
)
1013 return (edit_and_execute_command (count
, c
, VI_EDITING_MODE
, POSIX_VI_EDIT_COMMAND
));
1015 return (edit_and_execute_command (count
, c
, VI_EDITING_MODE
, VI_EDIT_COMMAND
));
1017 #endif /* VI_MODE */
1020 emacs_edit_and_execute_command (count
, c
)
1023 return (edit_and_execute_command (count
, c
, EMACS_EDITING_MODE
, EMACS_EDIT_COMMAND
));
1028 posix_edit_macros (count
, key
)
1032 char alias_name
[3], *alias_value
, *macro
;
1035 alias_name
[0] = '_';
1037 alias_name
[2] = '\0';
1039 alias_value
= get_alias_value (alias_name
);
1040 if (alias_value
&& *alias_value
)
1042 macro
= savestring (alias_value
);
1043 rl_push_macro_input (macro
);
1049 /* Bindable commands that move `shell-words': that is, sequences of
1050 non-unquoted-metacharacters. */
1052 #define WORDDELIM(c) (shellmeta(c) || shellblank(c))
1055 bash_forward_shellword (count
, key
)
1063 return (bash_backward_shellword (-count
, key
));
1065 /* The tricky part of this is deciding whether or not the first character
1066 we're on is an unquoted metacharacter. Not completely handled yet. */
1067 /* XXX - need to test this stuff with backslash-escaped shell
1068 metacharacters and unclosed single- and double-quoted strings. */
1081 /* Are we in a quoted string? If we are, move to the end of the quoted
1082 string and continue the outer loop. We only want quoted strings, not
1083 backslash-escaped characters, but char_is_quoted doesn't
1085 if (char_is_quoted (rl_line_buffer
, p
) && p
> 0 && rl_line_buffer
[p
-1] != '\\')
1088 ADVANCE_CHAR (rl_line_buffer
, slen
, p
);
1089 while (p
< rl_end
&& char_is_quoted (rl_line_buffer
, p
));
1094 /* Rest of code assumes we are not in a quoted string. */
1095 /* Move forward until we hit a non-metacharacter. */
1096 while (p
< rl_end
&& (c
= rl_line_buffer
[p
]) && WORDDELIM (c
))
1101 ADVANCE_CHAR (rl_line_buffer
, slen
, p
);
1102 continue; /* straight back to loop, don't increment p */
1104 if (p
< rl_end
&& rl_line_buffer
[p
])
1105 ADVANCE_CHAR (rl_line_buffer
, slen
, p
);
1108 p
= skip_to_delim (rl_line_buffer
, ++p
, "'", SD_NOJMP
);
1111 p
= skip_to_delim (rl_line_buffer
, ++p
, "\"", SD_NOJMP
);
1119 if (rl_line_buffer
[p
] == 0 || p
== rl_end
)
1126 /* Now move forward until we hit a non-quoted metacharacter or EOL */
1127 while (p
< rl_end
&& (c
= rl_line_buffer
[p
]) && WORDDELIM (c
) == 0)
1132 ADVANCE_CHAR (rl_line_buffer
, slen
, p
);
1133 continue; /* straight back to loop, don't increment p */
1135 if (p
< rl_end
&& rl_line_buffer
[p
])
1136 ADVANCE_CHAR (rl_line_buffer
, slen
, p
);
1139 p
= skip_to_delim (rl_line_buffer
, ++p
, "'", SD_NOJMP
);
1142 p
= skip_to_delim (rl_line_buffer
, ++p
, "\"", SD_NOJMP
);
1150 if (p
== rl_end
|| rl_line_buffer
[p
] == 0)
1164 bash_backward_shellword (count
, key
)
1172 return (bash_forward_shellword (-count
, key
));
1177 if (p
== rl_end
&& p
> 0)
1188 /* Move backward until we hit a non-metacharacter. */
1191 c
= rl_line_buffer
[p
];
1192 if (WORDDELIM (c
) == 0 || char_is_quoted (rl_line_buffer
, p
))
1194 BACKUP_CHAR (rl_line_buffer
, slen
, p
);
1203 /* Now move backward until we hit a metacharacter or BOL. */
1206 c
= rl_line_buffer
[p
];
1207 if (WORDDELIM (c
) && char_is_quoted (rl_line_buffer
, p
) == 0)
1209 BACKUP_CHAR (rl_line_buffer
, slen
, p
);
1220 bash_kill_shellword (count
, key
)
1226 return (bash_backward_kill_shellword (-count
, key
));
1229 bash_forward_shellword (count
, key
);
1232 rl_kill_text (p
, rl_point
);
1235 if (rl_editing_mode
== 1) /* 1 == emacs_mode */
1242 bash_backward_kill_shellword (count
, key
)
1248 return (bash_kill_shellword (-count
, key
));
1251 bash_backward_shellword (count
, key
);
1254 rl_kill_text (p
, rl_point
);
1256 if (rl_editing_mode
== 1) /* 1 == emacs_mode */
1263 /* **************************************************************** */
1265 /* How To Do Shell Completion */
1267 /* **************************************************************** */
1269 #define COMMAND_SEPARATORS ";|&{(`"
1271 #define COMMAND_SEPARATORS_PLUS_WS ";|&{(` \t"
1274 /* check for redirections and other character combinations that are not
1275 command separators */
1280 register int this_char
, prev_char
;
1282 /* Handle the two character tokens `>&', `<&', and `>|'.
1283 We are not in a command position after one of these. */
1284 this_char
= rl_line_buffer
[ti
];
1285 prev_char
= (ti
> 0) ? rl_line_buffer
[ti
- 1] : 0;
1287 if ((this_char
== '&' && (prev_char
== '<' || prev_char
== '>')) ||
1288 (this_char
== '|' && prev_char
== '>'))
1290 else if (this_char
== '{' && prev_char
== '$') /*}*/
1293 else if (this_char
== '(' && prev_char
== '$') /*)*/
1295 else if (this_char
== '(' && prev_char
== '<') /*)*/
1297 #if defined (EXTENDED_GLOB)
1298 else if (extended_glob
&& this_char
== '(' && prev_char
== '!') /*)*/
1302 else if (char_is_quoted (rl_line_buffer
, ti
))
1307 #if defined (PROGRAMMABLE_COMPLETION)
1309 * XXX - because of the <= start test, and setting os = s+1, this can
1310 * potentially return os > start. This is probably not what we want to
1311 * happen, but fix later after 2.05a-release.
1314 find_cmd_start (start
)
1317 register int s
, os
, ns
;
1320 /* Flags == SD_NOJMP only because we want to skip over command substitutions
1321 in assignment statements. Have to test whether this affects `standalone'
1322 command substitutions as individual words. */
1323 while (((s
= skip_to_delim (rl_line_buffer
, os
, COMMAND_SEPARATORS
, SD_NOJMP
|SD_COMPLETE
/*|SD_NOSKIPCMD*/)) <= start
) &&
1326 /* Handle >| token crudely; treat as > not | */
1327 if (rl_line_buffer
[s
] == '|' && rl_line_buffer
[s
-1] == '>')
1329 ns
= skip_to_delim (rl_line_buffer
, s
+1, COMMAND_SEPARATORS
, SD_NOJMP
|SD_COMPLETE
/*|SD_NOSKIPCMD*/);
1330 if (ns
> start
|| rl_line_buffer
[ns
] == 0)
1346 e
= skip_to_delim (rl_line_buffer
, end
, COMMAND_SEPARATORS
, SD_NOJMP
|SD_COMPLETE
);
1351 find_cmd_name (start
, sp
, ep
)
1358 for (s
= start
; whitespace (rl_line_buffer
[s
]); s
++)
1361 /* skip until a shell break character */
1362 e
= skip_to_delim (rl_line_buffer
, s
, "()<>;&| \t\n", SD_NOJMP
|SD_COMPLETE
);
1364 name
= substring (rl_line_buffer
, s
, e
);
1375 prog_complete_return (text
, matchnum
)
1384 if (prog_complete_matches
== 0 || prog_complete_matches
[ind
] == 0)
1385 return (char *)NULL
;
1386 return (prog_complete_matches
[ind
++]);
1389 #endif /* PROGRAMMABLE_COMPLETION */
1391 /* Try and catch completion attempts that are syntax errors or otherwise
1394 invalid_completion (text
, ind
)
1400 /* If we don't catch these here, the next clause will */
1401 if (ind
> 0 && rl_line_buffer
[ind
] == '(' && /*)*/
1402 member (rl_line_buffer
[ind
-1], "$<>"))
1406 while (pind
> 0 && whitespace (rl_line_buffer
[pind
]))
1408 /* If we have only whitespace preceding a paren, it's valid */
1409 if (ind
>= 0 && pind
<= 0 && rl_line_buffer
[ind
] == '(') /*)*/
1411 /* Flag the invalid completions, which are mostly syntax errors */
1412 if (ind
> 0 && rl_line_buffer
[ind
] == '(' && /*)*/
1413 member (rl_line_buffer
[pind
], COMMAND_SEPARATORS
) == 0)
1419 /* Do some completion on TEXT. The indices of TEXT in RL_LINE_BUFFER are
1420 at START and END. Return an array of matches, or NULL if none. */
1422 attempt_shell_completion (text
, start
, end
)
1426 int in_command_position
, ti
, qc
, dflags
;
1427 char **matches
, *command_separator_chars
;
1428 #if defined (PROGRAMMABLE_COMPLETION)
1429 int have_progcomps
, was_assignment
;
1430 COMPSPEC
*iw_compspec
;
1433 command_separator_chars
= COMMAND_SEPARATORS
;
1434 matches
= (char **)NULL
;
1435 rl_ignore_some_completions_function
= filename_completion_ignore
;
1437 rl_filename_quote_characters
= default_filename_quote_characters
;
1438 set_filename_bstab (rl_filename_quote_characters
);
1439 set_directory_hook ();
1440 rl_filename_stat_hook
= bash_filename_stat_hook
;
1442 rl_sort_completion_matches
= 1; /* sort by default */
1444 /* Determine if this could be a command word. It is if it appears at
1445 the start of the line (ignoring preceding whitespace), or if it
1446 appears after a character that separates commands. It cannot be a
1447 command word if we aren't at the top-level prompt. */
1451 while ((ti
> -1) && (whitespace (rl_line_buffer
[ti
])))
1455 /* If this is an open quote, maybe we're trying to complete a quoted
1457 if (ti
>= 0 && (rl_line_buffer
[ti
] == '"' || rl_line_buffer
[ti
] == '\''))
1459 qc
= rl_line_buffer
[ti
];
1461 while (ti
> -1 && (whitespace (rl_line_buffer
[ti
])))
1466 in_command_position
= 0;
1469 /* Only do command completion at the start of a line when we
1470 are prompting at the top level. */
1471 if (current_prompt_string
== ps1_prompt
)
1472 in_command_position
++;
1473 else if (parser_in_command_position ())
1474 in_command_position
++;
1476 else if (member (rl_line_buffer
[ti
], command_separator_chars
))
1478 in_command_position
++;
1480 if (check_redir (ti
) == 1)
1481 in_command_position
= 0;
1485 /* This still could be in command position. It is possible
1486 that all of the previous words on the line are variable
1490 if (in_command_position
&& invalid_completion (text
, ti
))
1492 rl_attempted_completion_over
= 1;
1493 return ((char **)NULL
);
1496 /* Check that we haven't incorrectly flagged a closed command substitution
1497 as indicating we're in a command position. */
1498 if (in_command_position
&& ti
>= 0 && rl_line_buffer
[ti
] == '`' &&
1499 *text
!= '`' && unclosed_pair (rl_line_buffer
, end
, "`") == 0)
1500 in_command_position
= 0;
1502 /* Special handling for command substitution. If *TEXT is a backquote,
1503 it can be the start or end of an old-style command substitution, or
1504 unmatched. If it's unmatched, both calls to unclosed_pair will
1505 succeed. Don't bother if readline found a single quote and we are
1506 completing on the substring. */
1507 if (*text
== '`' && rl_completion_quote_character
!= '\'' &&
1508 (in_command_position
|| (unclosed_pair (rl_line_buffer
, start
, "`") &&
1509 unclosed_pair (rl_line_buffer
, end
, "`"))))
1510 matches
= rl_completion_matches (text
, command_subst_completion_function
);
1512 #if defined (PROGRAMMABLE_COMPLETION)
1513 /* Attempt programmable completion. */
1514 have_progcomps
= prog_completion_enabled
&& (progcomp_size () > 0);
1515 iw_compspec
= progcomp_search (INITIALWORD
);
1517 (in_command_position
== 0 || text
[0] == '\0' || (in_command_position
&& iw_compspec
)) &&
1518 current_prompt_string
== ps1_prompt
)
1520 int s
, e
, s1
, e1
, os
, foundcs
;
1523 /* XXX - don't free the members */
1524 if (prog_complete_matches
)
1525 free (prog_complete_matches
);
1526 prog_complete_matches
= (char **)NULL
;
1531 s
= find_cmd_start (os
);
1532 e
= find_cmd_end (end
);
1535 /* Don't read past the end of rl_line_buffer */
1541 /* Or past point if point is within an assignment statement */
1542 else if (was_assignment
&& s
> rl_point
)
1547 /* Skip over assignment statements preceding a command name. If we
1548 don't find a command name at all, we can perform command name
1549 completion. If we find a partial command name, we should perform
1550 command name completion on it. */
1552 n
= find_cmd_name (s
, &s1
, &e1
);
1555 while (was_assignment
= assignment (n
, 0));
1556 s
= s1
; /* reset to index where name begins */
1558 /* s == index of where command name begins (reset above)
1559 e == end of current command, may be end of line
1560 s1 = index of where command name begins
1561 e1 == index of where command name ends
1562 start == index of where word to be completed begins
1563 end == index of where word to be completed ends
1564 if (s == start) we are doing command word completion for sure
1565 if (e1 == end) we are at the end of the command name and completing it */
1566 if (start
== 0 && end
== 0 && e
!= 0 && text
[0] == '\0') /* beginning of non-empty line */
1568 else if (start
== end
&& start
== s1
&& e
!= 0 && e1
> end
) /* beginning of command name, leading whitespace */
1570 else if (e
== 0 && e
== s
&& text
[0] == '\0' && have_progcomps
) /* beginning of empty line */
1571 prog_complete_matches
= programmable_completions (EMPTYCMD
, text
, s
, e
, &foundcs
);
1572 else if (start
== end
&& text
[0] == '\0' && s1
> start
&& whitespace (rl_line_buffer
[start
]))
1573 foundcs
= 0; /* whitespace before command name */
1574 else if (e
> s
&& was_assignment
== 0 && e1
== end
&& rl_line_buffer
[e
] == 0 && whitespace (rl_line_buffer
[e
-1]) == 0)
1576 /* not assignment statement, but still want to perform command
1577 completion if we are composing command word. */
1579 in_command_position
= s
== start
&& STREQ (n
, text
); /* XXX */
1581 else if (e
> s
&& was_assignment
== 0 && have_progcomps
)
1583 prog_complete_matches
= programmable_completions (n
, text
, s
, e
, &foundcs
);
1584 /* command completion if programmable completion fails */
1585 /* If we have a completion for the initial word, we can prefer that */
1586 in_command_position
= s
== start
&& (iw_compspec
|| STREQ (n
, text
)); /* XXX */
1587 if (iw_compspec
&& in_command_position
)
1590 /* empty command name following command separator */
1591 else if (s
>= e
&& n
[0] == '\0' && text
[0] == '\0' && start
> 0 &&
1592 was_assignment
== 0 && member (rl_line_buffer
[start
-1], COMMAND_SEPARATORS
))
1595 in_command_position
= 1;
1597 else if (s
>= e
&& n
[0] == '\0' && text
[0] == '\0' && start
> 0)
1599 foundcs
= 0; /* empty command name following optional assignments */
1600 in_command_position
+= was_assignment
;
1602 else if (s
== start
&& e
== end
&& STREQ (n
, text
) && start
> 0)
1604 foundcs
= 0; /* partial command name following assignments */
1605 in_command_position
= 1;
1610 /* If we have defined a compspec for the initial (command) word, call
1611 it and process the results like any other programmable completion. */
1612 if (in_command_position
&& have_progcomps
&& foundcs
== 0 && iw_compspec
)
1613 prog_complete_matches
= programmable_completions (INITIALWORD
, text
, s
, e
, &foundcs
);
1616 /* XXX - if we found a COMPSPEC for the command, just return whatever
1617 the programmable completion code returns, and disable the default
1618 filename completion that readline will do unless the COPT_DEFAULT
1619 option has been set with the `-o default' option to complete or
1623 pcomp_set_readline_variables (foundcs
, 1);
1624 /* Turn what the programmable completion code returns into what
1625 readline wants. I should have made compute_lcd_of_matches
1627 matches
= rl_completion_matches (text
, prog_complete_return
);
1628 if ((foundcs
& COPT_DEFAULT
) == 0)
1629 rl_attempted_completion_over
= 1; /* no default */
1630 if (matches
|| ((foundcs
& COPT_BASHDEFAULT
) == 0))
1639 if (in_command_position
)
1640 dflags
|= DEFCOMP_CMDPOS
;
1641 matches
= bash_default_completion (text
, start
, end
, qc
, dflags
);
1648 bash_default_completion (text
, start
, end
, qc
, compflags
)
1650 int start
, end
, qc
, compflags
;
1654 matches
= (char **)NULL
;
1656 /* New posix-style command substitution or variable name? */
1659 if (qc
!= '\'' && text
[1] == '(') /* ) */
1660 matches
= rl_completion_matches (text
, command_subst_completion_function
);
1663 matches
= rl_completion_matches (text
, variable_completion_function
);
1664 /* If a single match, see if it expands to a directory name and append
1665 a slash if it does. This requires us to expand the variable name,
1666 so we don't want to display errors if the variable is unset. This
1667 can happen with dynamic variables whose value has never been
1669 if (matches
&& matches
[0] && matches
[1] == 0)
1671 t
= savestring (matches
[0]);
1672 bash_filename_stat_hook (&t
);
1673 /* doesn't use test_for_directory because that performs tilde
1676 rl_completion_append_character
= '/';
1682 /* If the word starts in `~', and there is no slash in the word, then
1683 try completing this word as a username. */
1684 if (matches
== 0 && *text
== '~' && mbschr (text
, '/') == 0)
1685 matches
= rl_completion_matches (text
, rl_username_completion_function
);
1687 /* Another one. Why not? If the word starts in '@', then look through
1688 the world of known hostnames for completion first. */
1689 if (matches
== 0 && perform_hostname_completion
&& *text
== '@')
1690 matches
= rl_completion_matches (text
, hostname_completion_function
);
1692 /* And last, (but not least) if this word is in a command position, then
1693 complete over possible command names, including aliases, functions,
1694 and command names. */
1695 if (matches
== 0 && (compflags
& DEFCOMP_CMDPOS
))
1697 /* If END == START and text[0] == 0, we are trying to complete an empty
1699 if (no_empty_command_completion
&& end
== start
&& text
[0] == '\0')
1701 matches
= (char **)NULL
;
1702 rl_ignore_some_completions_function
= bash_ignore_everything
;
1706 #define CMD_IS_DIR(x) (absolute_pathname(x) == 0 && absolute_program(x) == 0 && *(x) != '~' && test_for_directory (x))
1709 matches
= rl_completion_matches (text
, command_word_completion_function
);
1711 /* If we are attempting command completion and nothing matches, we
1712 do not want readline to perform filename completion for us. We
1713 still want to be able to complete partial pathnames, so set the
1714 completion ignore function to something which will remove
1715 filenames and leave directories in the match list. */
1716 if (matches
== (char **)NULL
)
1717 rl_ignore_some_completions_function
= bash_ignore_filenames
;
1718 else if (matches
[1] == 0 && CMD_IS_DIR(matches
[0]) && dot_in_path
== 0)
1719 /* If we found a single match, without looking in the current
1720 directory (because it's not in $PATH), but the found name is
1721 also a command in the current directory, suppress appending any
1722 terminating character, since it's ambiguous. */
1724 rl_completion_suppress_append
= 1;
1725 rl_filename_completion_desired
= 0;
1727 else if (matches
[0] && matches
[1] && STREQ (matches
[0], matches
[1]) && CMD_IS_DIR (matches
[0]))
1728 /* There are multiple instances of the same match (duplicate
1729 completions haven't yet been removed). In this case, all of
1730 the matches will be the same, and the duplicate removal code
1731 will distill them all down to one. We turn on
1732 rl_completion_suppress_append for the same reason as above.
1733 Remember: we only care if there's eventually a single unique
1734 completion. If there are multiple completions this won't
1735 make a difference and the problem won't occur. */
1737 rl_completion_suppress_append
= 1;
1738 rl_filename_completion_desired
= 0;
1743 /* This could be a globbing pattern, so try to expand it using pathname
1745 if (!matches
&& completion_glob_pattern ((char *)text
))
1747 matches
= rl_completion_matches (text
, glob_complete_word
);
1748 /* A glob expression that matches more than one filename is problematic.
1749 If we match more than one filename, punt. */
1750 if (matches
&& matches
[1] && rl_completion_type
== TAB
)
1752 strvec_dispose (matches
);
1753 matches
= (char **)0;
1755 else if (matches
&& matches
[1] && rl_completion_type
== '!')
1757 rl_completion_suppress_append
= 1;
1758 rl_filename_completion_desired
= 0;
1766 bash_command_name_stat_hook (name
)
1769 char *cname
, *result
;
1771 /* If it's not something we're going to look up in $PATH, just call the
1772 normal filename stat hook. */
1773 if (absolute_program (*name
))
1774 return (bash_filename_stat_hook (name
));
1777 /* XXX - we could do something here with converting aliases, builtins,
1778 and functions into something that came out as executable, but we don't. */
1779 result
= search_for_command (cname
, 0);
1789 executable_completion (filename
, searching_path
)
1790 const char *filename
;
1796 f
= savestring (filename
);
1797 bash_directory_completion_hook (&f
);
1799 r
= searching_path
? executable_file (f
) : executable_or_directory (f
);
1804 /* This is the function to call when the word to complete is in a position
1805 where a command word can be found. It grovels $PATH, looking for commands
1806 that match. It also scans aliases, function names, and the shell_builtin
1809 command_word_completion_function (hint_text
, state
)
1810 const char *hint_text
;
1813 static char *hint
= (char *)NULL
;
1814 static char *path
= (char *)NULL
;
1815 static char *val
= (char *)NULL
;
1816 static char *filename_hint
= (char *)NULL
;
1817 static char *fnhint
= (char *)NULL
;
1818 static char *dequoted_hint
= (char *)NULL
;
1819 static char *directory_part
= (char *)NULL
;
1820 static char **glob_matches
= (char **)NULL
;
1821 static int path_index
, hint_len
, istate
, igncase
;
1822 static int mapping_over
, local_index
, searching_path
, hint_is_dir
;
1823 static int old_glob_ignore_case
, globpat
;
1824 static SHELL_VAR
**varlist
= (SHELL_VAR
**)NULL
;
1826 static alias_t
**alias_list
= (alias_t
**)NULL
;
1830 /* We have to map over the possibilities for command words. If we have
1831 no state, then make one just for that purpose. */
1834 rl_filename_stat_hook
= bash_command_name_stat_hook
;
1836 if (dequoted_hint
&& dequoted_hint
!= hint
)
1837 free (dequoted_hint
);
1841 mapping_over
= searching_path
= 0;
1842 hint_is_dir
= CMD_IS_DIR (hint_text
);
1845 temp
= rl_variable_value ("completion-ignore-case");
1846 igncase
= RL_BOOLEAN_VARIABLE_VALUE (temp
);
1850 free (glob_matches
);
1851 glob_matches
= (char **)NULL
;
1854 globpat
= completion_glob_pattern ((char *)hint_text
);
1856 /* If this is an absolute program name, do not check it against
1857 aliases, reserved words, functions or builtins. We must check
1858 whether or not it is unique, and, if so, whether that filename
1860 if (globpat
|| absolute_program (hint_text
))
1862 /* Perform tilde expansion on what's passed, so we don't end up
1863 passing filenames with tildes directly to stat(). The rest of
1864 the shell doesn't do variable expansion on the word following
1865 the tilde, so we don't do it here even if direxpand is set. */
1866 if (*hint_text
== '~')
1868 hint
= bash_tilde_expand (hint_text
, 0);
1869 directory_part
= savestring (hint_text
);
1870 temp
= strchr (directory_part
, '/');
1875 free (directory_part
);
1876 directory_part
= (char *)NULL
;
1879 else if (dircomplete_expand
)
1881 hint
= savestring (hint_text
);
1882 bash_directory_completion_hook (&hint
);
1885 hint
= savestring (hint_text
);
1887 dequoted_hint
= hint
;
1888 /* If readline's completer found a quote character somewhere, but
1889 didn't set the quote character, there must have been a quote
1890 character embedded in the filename. It can't be at the start of
1891 the filename, so we need to dequote the filename before we look
1892 in the file system for it. */
1893 if (rl_completion_found_quote
&& rl_completion_quote_character
== 0)
1895 dequoted_hint
= bash_dequote_filename (hint
, 0);
1897 hint
= dequoted_hint
;
1899 hint_len
= strlen (hint
);
1902 free (filename_hint
);
1904 fnhint
= filename_hint
= savestring (hint
);
1915 if (dircomplete_expand
&& path_dot_or_dotdot (filename_hint
))
1917 dircomplete_expand
= 0;
1918 set_directory_hook ();
1919 dircomplete_expand
= 1;
1926 dequoted_hint
= hint
= savestring (hint_text
);
1927 hint_len
= strlen (hint
);
1929 if (rl_completion_found_quote
&& rl_completion_quote_character
== 0)
1930 dequoted_hint
= bash_dequote_filename (hint
, 0);
1932 path
= get_string_value ("PATH");
1933 path_index
= dot_in_path
= 0;
1935 /* Initialize the variables for each type of command word. */
1941 varlist
= all_visible_functions ();
1947 alias_list
= all_aliases ();
1951 /* mapping_over says what we are currently hacking. Note that every case
1952 in this list must fall through when there are no more possibilities. */
1954 switch (mapping_over
)
1956 case 0: /* Aliases come first. */
1958 while (alias_list
&& alias_list
[local_index
])
1960 register char *alias
;
1962 alias
= alias_list
[local_index
++]->name
;
1964 if (igncase
== 0 && (STREQN (alias
, hint
, hint_len
)))
1965 return (savestring (alias
));
1966 else if (igncase
&& strncasecmp (alias
, hint
, hint_len
) == 0)
1967 return (savestring (alias
));
1973 case 1: /* Then shell reserved words. */
1975 while (word_token_alist
[local_index
].word
)
1977 register char *reserved_word
;
1979 reserved_word
= word_token_alist
[local_index
++].word
;
1981 if (STREQN (reserved_word
, hint
, hint_len
))
1982 return (savestring (reserved_word
));
1988 case 2: /* Then function names. */
1989 while (varlist
&& varlist
[local_index
])
1991 register char *varname
;
1993 varname
= varlist
[local_index
++]->name
;
1995 /* Honor completion-ignore-case for shell function names. */
1996 if (igncase
== 0 && (STREQN (varname
, hint
, hint_len
)))
1997 return (savestring (varname
));
1998 else if (igncase
&& strncasecmp (varname
, hint
, hint_len
) == 0)
1999 return (savestring (varname
));
2004 case 3: /* Then shell builtins. */
2005 for (; local_index
< num_shell_builtins
; local_index
++)
2007 /* Ignore it if it doesn't have a function pointer or if it
2008 is not currently enabled. */
2009 if (!shell_builtins
[local_index
].function
||
2010 (shell_builtins
[local_index
].flags
& BUILTIN_ENABLED
) == 0)
2013 if (STREQN (shell_builtins
[local_index
].name
, hint
, hint_len
))
2015 int i
= local_index
++;
2017 return (savestring (shell_builtins
[i
].name
));
2025 /* Limited support for completing command words with globbing chars. Only
2026 a single match (multiple matches that end up reducing the number of
2027 characters in the common prefix are bad) will ever be returned on
2028 regular completion. */
2033 glob_ignore_case
= igncase
;
2034 glob_matches
= shell_glob_filename (hint
);
2035 glob_ignore_case
= old_glob_ignore_case
;
2037 if (GLOB_FAILED (glob_matches
) || glob_matches
== 0)
2039 glob_matches
= (char **)NULL
;
2040 return ((char *)NULL
);
2045 if (glob_matches
[1] && rl_completion_type
== TAB
) /* multiple matches are bad */
2046 return ((char *)NULL
);
2049 while (val
= glob_matches
[local_index
++])
2051 if (executable_or_directory (val
))
2053 if (*hint_text
== '~' && directory_part
)
2055 temp
= maybe_restore_tilde (val
, directory_part
);
2064 glob_ignore_case
= old_glob_ignore_case
;
2065 return ((char *)NULL
);
2068 /* If the text passed is a directory in the current directory, return it
2069 as a possible match. Executables in directories in the current
2070 directory can be specified using relative pathnames and successfully
2071 executed even when `.' is not in $PATH. */
2074 hint_is_dir
= 0; /* only return the hint text once */
2075 return (savestring (hint_text
));
2078 /* Repeatedly call filename_completion_function while we have
2079 members of PATH left. Question: should we stat each file?
2080 Answer: we call executable_file () on each file. */
2083 istate
= (val
!= (char *)NULL
);
2089 /* Get the next directory from the path. If there is none, then we
2091 if (path
== 0 || path
[path_index
] == 0 ||
2092 (current_path
= extract_colon_unit (path
, &path_index
)) == 0)
2093 return ((char *)NULL
);
2096 if (*current_path
== 0)
2098 free (current_path
);
2099 current_path
= savestring (".");
2102 if (*current_path
== '~')
2106 t
= bash_tilde_expand (current_path
, 0);
2107 free (current_path
);
2111 if (current_path
[0] == '.' && current_path
[1] == '\0')
2114 if (fnhint
&& fnhint
!= filename_hint
)
2117 free (filename_hint
);
2119 filename_hint
= sh_makepath (current_path
, hint
, 0);
2120 /* Need a quoted version (though it doesn't matter much in most
2121 cases) because rl_filename_completion_function dequotes the
2122 filename it gets, assuming that it's been quoted as part of
2123 the input line buffer. */
2124 if (strpbrk (filename_hint
, "\"'\\"))
2125 fnhint
= sh_backslash_quote (filename_hint
, filename_bstab
, 0);
2127 fnhint
= filename_hint
;
2128 free (current_path
); /* XXX */
2132 val
= rl_filename_completion_function (fnhint
, istate
);
2133 if (mapping_over
== 4 && dircomplete_expand
)
2134 set_directory_hook ();
2140 /* If the hint text is an absolute program, then don't bother
2141 searching through PATH. */
2142 if (absolute_program (hint
))
2143 return ((char *)NULL
);
2149 int match
, freetemp
;
2151 if (absolute_program (hint
))
2154 match
= strncmp (val
, hint
, hint_len
) == 0;
2156 match
= strncasecmp (val
, hint
, hint_len
) == 0;
2158 /* If we performed tilde expansion, restore the original
2160 if (*hint_text
== '~')
2161 temp
= maybe_restore_tilde (val
, directory_part
);
2163 temp
= savestring (val
);
2168 temp
= strrchr (val
, '/');
2174 freetemp
= match
= strncmp (temp
, hint
, hint_len
) == 0;
2176 freetemp
= match
= strncasecmp (temp
, hint
, hint_len
) == 0;
2178 temp
= savestring (temp
);
2181 freetemp
= match
= 0;
2184 /* If we have found a match, and it is an executable file, return it.
2185 We don't return directory names when searching $PATH, since the
2186 bash execution code won't find executables in directories which
2187 appear in directories in $PATH when they're specified using
2188 relative pathnames. */
2190 /* If we're not searching $PATH and we have a relative pathname, we
2191 need to re-canonicalize it before testing whether or not it's an
2192 executable or a directory so the shell treats .. relative to $PWD
2193 according to the physical/logical option. The shell already
2194 canonicalizes the directory name in order to tell readline where
2195 to look, so not doing it here will be inconsistent. */
2196 /* XXX -- currently not used -- will introduce more inconsistency,
2197 since shell does not canonicalize ../foo before passing it to
2199 if (match
&& searching_path
== 0 && *val
== '.')
2203 t
= get_working_directory ("command-word-completion");
2204 t1
= make_absolute (val
, t
);
2206 cval
= sh_canonpath (t1
, PATH_CHECKDOTDOT
|PATH_CHECKEXISTS
);
2212 if (match
&& executable_completion ((searching_path
? val
: cval
), searching_path
))
2217 val
= ""; /* So it won't be NULL. */
2232 /* Completion inside an unterminated command substitution. */
2234 command_subst_completion_function (text
, state
)
2238 static char **matches
= (char **)NULL
;
2239 static const char *orig_start
;
2240 static char *filename_text
= (char *)NULL
;
2241 static int cmd_index
, start_len
;
2247 free (filename_text
);
2251 else if (*text
== '$' && text
[1] == '(') /* ) */
2253 /* If the text was quoted, suppress any quote character that the
2254 readline completion code would insert. */
2255 rl_completion_suppress_quote
= 1;
2256 start_len
= text
- orig_start
;
2257 filename_text
= savestring (text
);
2262 * At this point we can entertain the idea of re-parsing
2263 * `filename_text' into a (possibly incomplete) command name and
2264 * arguments, and doing completion based on that. This is
2265 * currently very rudimentary, but it is a small improvement.
2267 for (value
= filename_text
+ strlen (filename_text
) - 1; value
> filename_text
; value
--)
2268 if (whitespace (*value
) || member (*value
, COMMAND_SEPARATORS
))
2270 if (value
<= filename_text
)
2271 matches
= rl_completion_matches (filename_text
, command_word_completion_function
);
2275 start_len
+= value
- filename_text
;
2276 if (whitespace (value
[-1]))
2277 matches
= rl_completion_matches (value
, rl_filename_completion_function
);
2279 matches
= rl_completion_matches (value
, command_word_completion_function
);
2282 /* If there is more than one match, rl_completion_matches has already
2283 put the lcd in matches[0]. Skip over it. */
2284 cmd_index
= matches
&& matches
[0] && matches
[1];
2286 /* If there's a single match and it's a directory, set the append char
2287 to the expected `/'. Otherwise, don't append anything. */
2288 if (matches
&& matches
[0] && matches
[1] == 0 && test_for_directory (matches
[0]))
2289 rl_completion_append_character
= '/';
2291 rl_completion_suppress_append
= 1;
2294 if (matches
== 0 || matches
[cmd_index
] == 0)
2296 rl_filename_quoting_desired
= 0; /* disable quoting */
2297 return ((char *)NULL
);
2301 value
= (char *)xmalloc (1 + start_len
+ strlen (matches
[cmd_index
]));
2304 value
[0] = *orig_start
;
2306 strncpy (value
, orig_start
, start_len
);
2308 strcpy (value
+ start_len
, matches
[cmd_index
]);
2315 /* Okay, now we write the entry_function for variable completion. */
2317 variable_completion_function (text
, state
)
2321 static char **varlist
= (char **)NULL
;
2322 static int varlist_index
;
2323 static char *varname
= (char *)NULL
;
2324 static int first_char
, first_char_loc
;
2332 first_char
= text
[0];
2334 if (first_char
== '$')
2337 if (text
[first_char_loc
] == '{')
2340 varname
= savestring (text
+ first_char_loc
);
2343 strvec_dispose (varlist
);
2345 varlist
= all_variables_matching_prefix (varname
);
2349 if (!varlist
|| !varlist
[varlist_index
])
2351 return ((char *)NULL
);
2357 value
= (char *)xmalloc (4 + strlen (varlist
[varlist_index
]));
2361 value
[0] = first_char
;
2362 if (first_char_loc
== 2)
2366 strcpy (value
+ first_char_loc
, varlist
[varlist_index
]);
2367 if (first_char_loc
== 2)
2368 strcat (value
, "}");
2375 /* How about a completion function for hostnames? */
2377 hostname_completion_function (text
, state
)
2381 static char **list
= (char **)NULL
;
2382 static int list_index
= 0;
2383 static int first_char
, first_char_loc
;
2385 /* If we don't have any state, make some. */
2390 list
= (char **)NULL
;
2395 if (first_char
== '@')
2398 list
= hostnames_matching ((char *)text
+first_char_loc
);
2402 if (list
&& list
[list_index
])
2406 t
= (char *)xmalloc (2 + strlen (list
[list_index
]));
2408 strcpy (t
+ first_char_loc
, list
[list_index
]);
2413 return ((char *)NULL
);
2417 * A completion function for service names from /etc/services (or wherever).
2420 bash_servicename_completion_function (text
, state
)
2424 #if defined (__WIN32__) || defined (__OPENNT) || !defined (HAVE_GETSERVENT)
2425 return ((char *)NULL
);
2427 static char *sname
= (char *)NULL
;
2428 static struct servent
*srvent
;
2429 static int snamelen
;
2431 char **alist
, *aentry
;
2438 sname
= savestring (text
);
2439 snamelen
= strlen (sname
);
2443 while (srvent
= getservent ())
2446 if (snamelen
== 0 || (STREQN (sname
, srvent
->s_name
, snamelen
)))
2448 /* Not primary, check aliases */
2449 for (alist
= srvent
->s_aliases
; *alist
; alist
++)
2452 if (STREQN (sname
, aentry
, snamelen
))
2466 return ((char *)NULL
);
2469 value
= afound
? savestring (aentry
) : savestring (srvent
->s_name
);
2475 * A completion function for group names from /etc/group (or wherever).
2478 bash_groupname_completion_function (text
, state
)
2482 #if defined (__WIN32__) || defined (__OPENNT) || !defined (HAVE_GRP_H)
2483 return ((char *)NULL
);
2485 static char *gname
= (char *)NULL
;
2486 static struct group
*grent
;
2487 static int gnamelen
;
2493 gname
= savestring (text
);
2494 gnamelen
= strlen (gname
);
2499 while (grent
= getgrent ())
2501 if (gnamelen
== 0 || (STREQN (gname
, grent
->gr_name
, gnamelen
)))
2508 return ((char *)NULL
);
2511 value
= savestring (grent
->gr_name
);
2516 /* Functions to perform history and alias expansions on the current line. */
2518 #if defined (BANG_HISTORY)
2519 /* Perform history expansion on the current line. If no history expansion
2520 is done, pre_process_line() returns what it was passed, so we need to
2521 allocate a new line here. */
2523 history_expand_line_internal (line
)
2529 old_verify
= hist_verify
;
2531 new_line
= pre_process_line (line
, 0, 0);
2532 hist_verify
= old_verify
;
2534 return (new_line
== line
) ? savestring (line
) : new_line
;
2538 /* There was an error in expansion. Let the preprocessor print
2541 cleanup_expansion_error ()
2544 #if defined (BANG_HISTORY)
2547 old_verify
= hist_verify
;
2551 fprintf (rl_outstream
, "\r\n");
2552 to_free
= pre_process_line (rl_line_buffer
, 1, 0);
2553 #if defined (BANG_HISTORY)
2554 hist_verify
= old_verify
;
2556 if (to_free
!= rl_line_buffer
)
2558 putc ('\r', rl_outstream
);
2559 rl_forced_update_display ();
2562 /* If NEW_LINE differs from what is in the readline line buffer, add an
2563 undo record to get from the readline line buffer contents to the new
2564 line and make NEW_LINE the current readline line. */
2566 maybe_make_readline_line (new_line
)
2569 if (new_line
&& strcmp (new_line
, rl_line_buffer
) != 0)
2573 rl_add_undo (UNDO_BEGIN
, 0, 0, 0);
2574 rl_delete_text (0, rl_point
);
2575 rl_point
= rl_end
= rl_mark
= 0;
2576 rl_insert_text (new_line
);
2577 rl_add_undo (UNDO_END
, 0, 0, 0);
2581 /* Make NEW_LINE be the current readline line. This frees NEW_LINE. */
2583 set_up_new_line (new_line
)
2586 int old_point
, at_end
;
2588 old_point
= rl_point
;
2589 at_end
= rl_point
== rl_end
;
2591 /* If the line was history and alias expanded, then make that
2592 be one thing to undo. */
2593 maybe_make_readline_line (new_line
);
2596 /* Place rl_point where we think it should go. */
2599 else if (old_point
< rl_end
)
2601 rl_point
= old_point
;
2602 if (!whitespace (rl_line_buffer
[rl_point
]))
2603 rl_forward_word (1, 0);
2608 /* Expand aliases in the current readline line. */
2610 alias_expand_line (count
, ignore
)
2615 new_line
= alias_expand (rl_line_buffer
);
2619 set_up_new_line (new_line
);
2624 cleanup_expansion_error ();
2630 #if defined (BANG_HISTORY)
2631 /* History expand the line. */
2633 history_expand_line (count
, ignore
)
2638 new_line
= history_expand_line_internal (rl_line_buffer
);
2642 set_up_new_line (new_line
);
2647 cleanup_expansion_error ();
2652 /* Expand history substitutions in the current line and then insert a
2653 space (hopefully close to where we were before). */
2655 tcsh_magic_space (count
, ignore
)
2658 int dist_from_end
, old_point
;
2660 old_point
= rl_point
;
2661 dist_from_end
= rl_end
- rl_point
;
2662 if (history_expand_line (count
, ignore
) == 0)
2664 /* Try a simple heuristic from Stephen Gildea <gildea@intouchsys.com>.
2665 This works if all expansions were before rl_point or if no expansions
2667 rl_point
= (old_point
== 0) ? old_point
: rl_end
- dist_from_end
;
2674 #endif /* BANG_HISTORY */
2676 /* History and alias expand the line. */
2678 history_and_alias_expand_line (count
, ignore
)
2684 #if defined (BANG_HISTORY)
2685 new_line
= history_expand_line_internal (rl_line_buffer
);
2693 alias_line
= alias_expand (new_line
);
2695 new_line
= alias_line
;
2701 set_up_new_line (new_line
);
2706 cleanup_expansion_error ();
2711 /* History and alias expand the line, then perform the shell word
2712 expansions by calling expand_string. This can't use set_up_new_line()
2713 because we want the variable expansions as a separate undo'able
2714 set of operations. */
2716 shell_expand_line (count
, ignore
)
2720 WORD_LIST
*expanded_string
;
2724 #if defined (BANG_HISTORY)
2725 new_line
= history_expand_line_internal (rl_line_buffer
);
2733 alias_line
= alias_expand (new_line
);
2735 new_line
= alias_line
;
2741 int old_point
= rl_point
;
2742 int at_end
= rl_point
== rl_end
;
2744 /* If the line was history and alias expanded, then make that
2745 be one thing to undo. */
2746 maybe_make_readline_line (new_line
);
2749 /* If there is variable expansion to perform, do that as a separate
2750 operation to be undone. */
2753 w
= alloc_word_desc ();
2754 w
->word
= savestring (rl_line_buffer
);
2755 w
->flags
= rl_explicit_arg
? (W_NOPROCSUB
|W_NOCOMSUB
) : 0;
2756 expanded_string
= expand_word (w
, rl_explicit_arg
? Q_HERE_DOCUMENT
: 0);
2759 new_line
= savestring (rl_line_buffer
);
2760 expanded_string
= expand_string (new_line
, 0);
2764 if (expanded_string
== 0)
2766 new_line
= (char *)xmalloc (1);
2771 new_line
= string_list (expanded_string
);
2772 dispose_words (expanded_string
);
2775 maybe_make_readline_line (new_line
);
2778 /* Place rl_point where we think it should go. */
2781 else if (old_point
< rl_end
)
2783 rl_point
= old_point
;
2784 if (!whitespace (rl_line_buffer
[rl_point
]))
2785 rl_forward_word (1, 0);
2791 cleanup_expansion_error ();
2796 /* If FIGNORE is set, then don't match files with the given suffixes when
2797 completing filenames. If only one of the possibilities has an acceptable
2798 suffix, delete the others, else just return and let the completer
2799 signal an error. It is called by the completer when real
2800 completions are done on filenames by the completer's internal
2801 function, not for completion lists (M-?) and not on "other"
2802 completion types, such as hostnames or commands. */
2804 static struct ignorevar fignore
=
2810 (sh_iv_item_func_t
*) 0,
2814 _ignore_completion_names (names
, name_func
)
2816 sh_ignore_func_t
*name_func
;
2823 /* If there is only one completion, see if it is acceptable. If it is
2824 not, free it up. In any case, short-circuit and return. This is a
2825 special case because names[0] is not the prefix of the list of names
2826 if there is only one completion; it is the completion itself. */
2827 if (names
[1] == (char *)0)
2830 if ((*name_func
) (names
[0]) == 0)
2833 names
[0] = (char *)NULL
;
2839 /* Allocate space for array to hold list of pointers to matching
2840 filenames. The pointers are copied back to NAMES when done. */
2841 for (nidx
= 1; names
[nidx
]; nidx
++)
2843 newnames
= strvec_create (nidx
+ 1);
2845 if (force_fignore
== 0)
2847 oldnames
= strvec_create (nidx
- 1);
2851 newnames
[0] = names
[0];
2852 for (idx
= nidx
= 1; names
[idx
]; idx
++)
2854 if ((*name_func
) (names
[idx
]))
2855 newnames
[nidx
++] = names
[idx
];
2856 else if (force_fignore
== 0)
2857 oldnames
[oidx
++] = names
[idx
];
2862 newnames
[nidx
] = (char *)NULL
;
2864 /* If none are acceptable then let the completer handle it. */
2870 names
[0] = (char *)NULL
;
2879 if (force_fignore
== 0)
2882 free (oldnames
[--oidx
]);
2886 /* If only one is acceptable, copy it to names[0] and return. */
2890 names
[0] = newnames
[1];
2891 names
[1] = (char *)NULL
;
2896 /* Copy the acceptable names back to NAMES, set the new array end,
2898 for (nidx
= 1; newnames
[nidx
]; nidx
++)
2899 names
[nidx
] = newnames
[nidx
];
2900 names
[nidx
] = (char *)NULL
;
2905 name_is_acceptable (name
)
2911 for (nlen
= strlen (name
), p
= fignore
.ignores
; p
->val
; p
++)
2913 if (nlen
> p
->len
&& p
->len
> 0 && STREQ (p
->val
, &name
[nlen
- p
->len
]))
2922 ignore_dot_names (name
)
2925 return (name
[0] != '.');
2930 filename_completion_ignore (names
)
2934 if (glob_dot_filenames
== 0)
2935 _ignore_completion_names (names
, ignore_dot_names
);
2938 setup_ignore_patterns (&fignore
);
2940 if (fignore
.num_ignores
== 0)
2943 _ignore_completion_names (names
, name_is_acceptable
);
2948 /* Return 1 if NAME is a directory. NAME undergoes tilde expansion. */
2950 test_for_directory (name
)
2956 fn
= bash_tilde_expand (name
, 0);
2957 r
= file_isdir (fn
);
2963 /* Remove files from NAMES, leaving directories. */
2965 bash_ignore_filenames (names
)
2968 _ignore_completion_names (names
, test_for_directory
);
2980 bash_ignore_everything (names
)
2983 _ignore_completion_names (names
, return_zero
);
2987 /* Replace a tilde-prefix in VAL with a `~', assuming the user typed it. VAL
2988 is an expanded filename. DIRECTORY_PART is the tilde-prefix portion
2989 of the un-tilde-expanded version of VAL (what the user typed). */
2991 restore_tilde (val
, directory_part
)
2992 char *val
, *directory_part
;
2995 char *dh2
, *expdir
, *ret
, *v
;
2999 /* We need to duplicate the expansions readline performs on the directory
3000 portion before passing it to our completion function. */
3001 dh2
= directory_part
? bash_dequote_filename (directory_part
, 0) : 0;
3002 bash_directory_expansion (&dh2
);
3005 expdir
= bash_tilde_expand (directory_part
, 0);
3006 xl
= strlen (expdir
);
3007 if (*directory_part
== '~' && STREQ (directory_part
, expdir
))
3009 /* tilde expansion failed, so what should we return? we use what the
3011 v
= mbschr (val
, '/');
3013 ret
= (char *)xmalloc (xl
+ vl
+ 2);
3014 strcpy (ret
, directory_part
);
3016 strcpy (ret
+ xl
, v
);
3026 dh2 = unexpanded but dequoted tilde-prefix
3027 dl2 = length of tilde-prefix
3028 expdir = tilde-expanded tilde-prefix
3029 xl = length of expanded tilde-prefix
3030 l = length of remainder after tilde-prefix
3036 return (savestring (val
)); /* XXX - just punt */
3039 ret
= (char *)xmalloc (dl2
+ 2 + l
);
3041 strcpy (ret
+ dl2
, val
+ xl
);
3048 maybe_restore_tilde (val
, directory_part
)
3049 char *val
, *directory_part
;
3051 rl_icppfunc_t
*save
;
3054 save
= (dircomplete_expand
== 0) ? save_directory_hook () : (rl_icppfunc_t
*)0;
3055 ret
= restore_tilde (val
, directory_part
);
3057 restore_directory_hook (save
);
3061 /* Simulate the expansions that will be performed by
3062 rl_filename_completion_function. This must be called with the address of
3063 a pointer to malloc'd memory. */
3065 bash_directory_expansion (dirname
)
3070 d
= savestring (*dirname
);
3072 if ((rl_directory_rewrite_hook
) && (*rl_directory_rewrite_hook
) (&d
))
3077 else if (rl_directory_completion_hook
&& (*rl_directory_completion_hook
) (&d
))
3082 else if (rl_completion_found_quote
)
3084 nd
= bash_dequote_filename (d
, rl_completion_quote_character
);
3091 /* If necessary, rewrite directory entry */
3093 bash_filename_rewrite_hook (fname
, fnlen
)
3099 conv
= fnx_fromfs (fname
, fnlen
);
3101 conv
= savestring (conv
);
3105 /* Functions to save and restore the appropriate directory hook */
3106 /* This is not static so the shopt code can call it */
3108 set_directory_hook ()
3110 if (dircomplete_expand
)
3112 rl_directory_completion_hook
= bash_directory_completion_hook
;
3113 rl_directory_rewrite_hook
= (rl_icppfunc_t
*)0;
3117 rl_directory_rewrite_hook
= bash_directory_completion_hook
;
3118 rl_directory_completion_hook
= (rl_icppfunc_t
*)0;
3122 static rl_icppfunc_t
*
3123 save_directory_hook ()
3127 if (dircomplete_expand
)
3129 ret
= rl_directory_completion_hook
;
3130 rl_directory_completion_hook
= (rl_icppfunc_t
*)NULL
;
3134 ret
= rl_directory_rewrite_hook
;
3135 rl_directory_rewrite_hook
= (rl_icppfunc_t
*)NULL
;
3142 restore_directory_hook (hookf
)
3143 rl_icppfunc_t
*hookf
;
3145 if (dircomplete_expand
)
3146 rl_directory_completion_hook
= hookf
;
3148 rl_directory_rewrite_hook
= hookf
;
3151 /* Check whether not DIRNAME, with any trailing slash removed, exists. If
3152 SHOULD_DEQUOTE is non-zero, we dequote the directory name first. */
3154 directory_exists (dirname
, should_dequote
)
3155 const char *dirname
;
3162 /* We save the string and chop the trailing slash because stat/lstat behave
3163 inconsistently if one is present. */
3164 new_dirname
= should_dequote
? bash_dequote_filename ((char *)dirname
, rl_completion_quote_character
) : savestring (dirname
);
3165 dirlen
= STRLEN (new_dirname
);
3166 if (new_dirname
[dirlen
- 1] == '/')
3167 new_dirname
[dirlen
- 1] = '\0';
3168 #if defined (HAVE_LSTAT)
3169 r
= lstat (new_dirname
, &sb
) == 0;
3171 r
= stat (new_dirname
, &sb
) == 0;
3177 /* Expand a filename before the readline completion code passes it to stat(2).
3178 The filename will already have had tilde expansion performed. */
3180 bash_filename_stat_hook (dirname
)
3183 char *local_dirname
, *new_dirname
, *t
;
3184 int should_expand_dirname
, return_value
;
3188 local_dirname
= *dirname
;
3189 should_expand_dirname
= return_value
= 0;
3190 if (t
= mbschr (local_dirname
, '$'))
3191 should_expand_dirname
= '$';
3192 else if (t
= mbschr (local_dirname
, '`')) /* XXX */
3193 should_expand_dirname
= '`';
3195 if (should_expand_dirname
&& directory_exists (local_dirname
, 0))
3196 should_expand_dirname
= 0;
3198 if (should_expand_dirname
)
3200 new_dirname
= savestring (local_dirname
);
3201 /* no error messages, and expand_prompt_string doesn't longjmp so we don't
3202 have to worry about restoring this setting. */
3203 global_nounset
= unbound_vars_is_error
;
3204 unbound_vars_is_error
= 0;
3205 wl
= expand_prompt_string (new_dirname
, 0, W_NOCOMSUB
|W_NOPROCSUB
|W_COMPLETE
); /* does the right thing */
3206 unbound_vars_is_error
= global_nounset
;
3210 new_dirname
= string_list (wl
);
3211 /* Tell the completer we actually expanded something and change
3212 *dirname only if we expanded to something non-null -- stat
3213 behaves unpredictably when passed null or empty strings */
3214 if (new_dirname
&& *new_dirname
)
3216 free (local_dirname
); /* XXX */
3217 local_dirname
= *dirname
= new_dirname
;
3218 return_value
= STREQ (local_dirname
, *dirname
) == 0;
3228 /* This is very similar to the code in bash_directory_completion_hook below,
3229 but without spelling correction and not worrying about whether or not
3230 we change relative pathnames. */
3231 if (no_symbolic_links
== 0 && (local_dirname
[0] != '.' || local_dirname
[1]))
3233 char *temp1
, *temp2
;
3235 t
= get_working_directory ("symlink-hook");
3236 temp1
= make_absolute (local_dirname
, t
);
3238 temp2
= sh_canonpath (temp1
, PATH_CHECKDOTDOT
|PATH_CHECKEXISTS
);
3240 /* If we can't canonicalize, bail. */
3244 return return_value
;
3247 free (local_dirname
);
3252 return (return_value
);
3255 /* Handle symbolic link references and other directory name
3256 expansions while hacking completion. This should return 1 if it modifies
3257 the DIRNAME argument, 0 otherwise. It should make sure not to modify
3258 DIRNAME if it returns 0. */
3260 bash_directory_completion_hook (dirname
)
3263 char *local_dirname
, *new_dirname
, *t
;
3264 int return_value
, should_expand_dirname
, nextch
, closer
;
3267 return_value
= should_expand_dirname
= nextch
= closer
= 0;
3268 local_dirname
= *dirname
;
3270 if (t
= mbschr (local_dirname
, '$'))
3272 should_expand_dirname
= '$';
3274 /* Deliberately does not handle the deprecated $[...] arithmetic
3278 else if (nextch
== '{')
3288 delims
[0] = closer
; delims
[1] = 0;
3289 p
= skip_to_delim (t
, 1, delims
, SD_NOJMP
|SD_COMPLETE
);
3291 should_expand_dirname
= 0;
3294 else if (local_dirname
[0] == '~')
3295 should_expand_dirname
= '~';
3298 t
= mbschr (local_dirname
, '`');
3299 if (t
&& unclosed_pair (local_dirname
, strlen (local_dirname
), "`") == 0)
3300 should_expand_dirname
= '`';
3303 if (should_expand_dirname
&& directory_exists (local_dirname
, 1))
3304 should_expand_dirname
= 0;
3306 if (should_expand_dirname
)
3308 new_dirname
= savestring (local_dirname
);
3309 wl
= expand_prompt_string (new_dirname
, 0, W_NOCOMSUB
|W_NOPROCSUB
|W_COMPLETE
); /* does the right thing */
3312 *dirname
= string_list (wl
);
3313 /* Tell the completer to replace the directory name only if we
3314 actually expanded something. */
3315 return_value
= STREQ (local_dirname
, *dirname
) == 0;
3316 free (local_dirname
);
3319 local_dirname
= *dirname
;
3320 /* XXX - change rl_filename_quote_characters here based on
3321 should_expand_dirname/nextch/closer. This is the only place
3322 custom_filename_quote_characters is modified. */
3323 if (rl_filename_quote_characters
&& *rl_filename_quote_characters
)
3326 i
= strlen (default_filename_quote_characters
);
3327 custom_filename_quote_characters
= xrealloc (custom_filename_quote_characters
, i
+1);
3328 for (i
= j
= 0; c
= default_filename_quote_characters
[i
]; i
++)
3330 if (c
== should_expand_dirname
|| c
== nextch
|| c
== closer
)
3332 custom_filename_quote_characters
[j
++] = c
;
3334 custom_filename_quote_characters
[j
] = '\0';
3335 rl_filename_quote_characters
= custom_filename_quote_characters
;
3336 set_filename_bstab (rl_filename_quote_characters
);
3342 free (local_dirname
);
3343 *dirname
= (char *)xmalloc (1);
3350 /* Dequote the filename even if we don't expand it. */
3351 new_dirname
= bash_dequote_filename (local_dirname
, rl_completion_quote_character
);
3352 return_value
= STREQ (local_dirname
, new_dirname
) == 0;
3353 free (local_dirname
);
3354 local_dirname
= *dirname
= new_dirname
;
3357 /* no_symbolic_links == 0 -> use (default) logical view of the file system.
3358 local_dirname[0] == '.' && local_dirname[1] == '/' means files in the
3359 current directory (./).
3360 local_dirname[0] == '.' && local_dirname[1] == 0 means relative pathnames
3361 in the current directory (e.g., lib/sh).
3362 XXX - should we do spelling correction on these? */
3364 /* This is test as it was in bash-4.2: skip relative pathnames in current
3365 directory. Change test to
3366 (local_dirname[0] != '.' || (local_dirname[1] && local_dirname[1] != '/'))
3367 if we want to skip paths beginning with ./ also. */
3368 if (no_symbolic_links
== 0 && (local_dirname
[0] != '.' || local_dirname
[1]))
3370 char *temp1
, *temp2
;
3373 /* If we have a relative path
3374 (local_dirname[0] != '/' && local_dirname[0] != '.')
3375 that is canonical after appending it to the current directory, then
3378 strcmp (temp1, temp2) == 0
3379 after adding a slash to temp2 below. It should be safe to not
3382 t
= get_working_directory ("symlink-hook");
3383 temp1
= make_absolute (local_dirname
, t
);
3385 temp2
= sh_canonpath (temp1
, PATH_CHECKDOTDOT
|PATH_CHECKEXISTS
);
3387 /* Try spelling correction if initial canonicalization fails. Make
3388 sure we are set to replace the directory name with the results so
3389 subsequent directory checks don't fail. */
3390 if (temp2
== 0 && dircomplete_spelling
&& dircomplete_expand
)
3392 temp2
= dirspell (temp1
);
3397 temp2
= sh_canonpath (temp1
, PATH_CHECKDOTDOT
|PATH_CHECKEXISTS
);
3398 return_value
|= temp2
!= 0;
3401 /* If we can't canonicalize, bail. */
3405 return return_value
;
3407 len1
= strlen (temp1
);
3408 if (temp1
[len1
- 1] == '/')
3410 len2
= strlen (temp2
);
3411 if (len2
> 2) /* don't append `/' to `/' or `//' */
3413 temp2
= (char *)xrealloc (temp2
, len2
+ 2);
3415 temp2
[len2
+ 1] = '\0';
3419 /* dircomplete_expand_relpath == 0 means we want to leave relative
3420 pathnames that are unchanged by canonicalization alone.
3421 *local_dirname != '/' && *local_dirname != '.' == relative pathname
3422 (consistent with general.c:absolute_pathname())
3423 temp1 == temp2 (after appending a slash to temp2) means the pathname
3424 is not changed by canonicalization as described above. */
3425 if (dircomplete_expand_relpath
|| ((local_dirname
[0] != '/' && local_dirname
[0] != '.') && STREQ (temp1
, temp2
) == 0))
3426 return_value
|= STREQ (local_dirname
, temp2
) == 0;
3427 free (local_dirname
);
3432 return (return_value
);
3435 static char **history_completion_array
= (char **)NULL
;
3436 static int harry_size
;
3437 static int harry_len
;
3440 build_history_completion_array ()
3446 /* First, clear out the current dynamic history completion list. */
3449 strvec_dispose (history_completion_array
);
3450 history_completion_array
= (char **)NULL
;
3455 /* Next, grovel each line of history, making each shell-sized token
3456 a separate entry in the history_completion_array. */
3457 hlist
= history_list ();
3461 for (i
= 0; hlist
[i
]; i
++)
3463 for ( --i
; i
>= 0; i
--)
3465 /* Separate each token, and place into an array. */
3466 tokens
= history_tokenize (hlist
[i
]->line
);
3468 for (j
= 0; tokens
&& tokens
[j
]; j
++)
3470 if (harry_len
+ 2 > harry_size
)
3471 history_completion_array
= strvec_resize (history_completion_array
, harry_size
+= 10);
3473 history_completion_array
[harry_len
++] = tokens
[j
];
3474 history_completion_array
[harry_len
] = (char *)NULL
;
3479 /* Sort the complete list of tokens. */
3480 if (dabbrev_expand_active
== 0)
3481 qsort (history_completion_array
, harry_len
, sizeof (char *), (QSFUNC
*)strvec_strcmp
);
3486 history_completion_generator (hint_text
, state
)
3487 const char *hint_text
;
3490 static int local_index
, len
;
3491 static const char *text
;
3493 /* If this is the first call to the generator, then initialize the
3494 list of strings to complete over. */
3497 if (dabbrev_expand_active
) /* This is kind of messy */
3498 rl_completion_suppress_append
= 1;
3500 build_history_completion_array ();
3502 len
= strlen (text
);
3505 while (history_completion_array
&& history_completion_array
[local_index
])
3507 /* XXX - should this use completion-ignore-case? */
3508 if (strncmp (text
, history_completion_array
[local_index
++], len
) == 0)
3509 return (savestring (history_completion_array
[local_index
- 1]));
3511 return ((char *)NULL
);
3515 dynamic_complete_history (count
, key
)
3519 rl_compentry_func_t
*orig_func
;
3520 rl_completion_func_t
*orig_attempt_func
;
3521 rl_compignore_func_t
*orig_ignore_func
;
3523 orig_func
= rl_completion_entry_function
;
3524 orig_attempt_func
= rl_attempted_completion_function
;
3525 orig_ignore_func
= rl_ignore_some_completions_function
;
3527 rl_completion_entry_function
= history_completion_generator
;
3528 rl_attempted_completion_function
= (rl_completion_func_t
*)NULL
;
3529 rl_ignore_some_completions_function
= filename_completion_ignore
;
3531 /* XXX - use rl_completion_mode here? */
3532 if (rl_last_func
== dynamic_complete_history
)
3533 r
= rl_complete_internal ('?');
3535 r
= rl_complete_internal (TAB
);
3537 rl_completion_entry_function
= orig_func
;
3538 rl_attempted_completion_function
= orig_attempt_func
;
3539 rl_ignore_some_completions_function
= orig_ignore_func
;
3545 bash_dabbrev_expand (count
, key
)
3548 int r
, orig_suppress
, orig_sort
;
3549 rl_compentry_func_t
*orig_func
;
3550 rl_completion_func_t
*orig_attempt_func
;
3551 rl_compignore_func_t
*orig_ignore_func
;
3553 orig_func
= rl_menu_completion_entry_function
;
3554 orig_attempt_func
= rl_attempted_completion_function
;
3555 orig_ignore_func
= rl_ignore_some_completions_function
;
3556 orig_suppress
= rl_completion_suppress_append
;
3557 orig_sort
= rl_sort_completion_matches
;
3559 rl_menu_completion_entry_function
= history_completion_generator
;
3560 rl_attempted_completion_function
= (rl_completion_func_t
*)NULL
;
3561 rl_ignore_some_completions_function
= filename_completion_ignore
;
3562 rl_filename_completion_desired
= 0;
3563 rl_completion_suppress_append
= 1;
3564 rl_sort_completion_matches
= 0;
3566 /* XXX - use rl_completion_mode here? */
3567 dabbrev_expand_active
= 1;
3568 if (rl_last_func
== bash_dabbrev_expand
)
3569 rl_last_func
= rl_menu_complete
;
3570 r
= rl_menu_complete (count
, key
);
3571 dabbrev_expand_active
= 0;
3573 rl_last_func
= bash_dabbrev_expand
;
3574 rl_menu_completion_entry_function
= orig_func
;
3575 rl_attempted_completion_function
= orig_attempt_func
;
3576 rl_ignore_some_completions_function
= orig_ignore_func
;
3577 rl_completion_suppress_append
= orig_suppress
;
3578 rl_sort_completion_matches
= orig_sort
;
3583 #if defined (SPECIFIC_COMPLETION_FUNCTIONS)
3585 bash_complete_username (ignore
, ignore2
)
3586 int ignore
, ignore2
;
3588 return bash_complete_username_internal (rl_completion_mode (bash_complete_username
));
3592 bash_possible_username_completions (ignore
, ignore2
)
3593 int ignore
, ignore2
;
3595 return bash_complete_username_internal ('?');
3599 bash_complete_username_internal (what_to_do
)
3602 return bash_specific_completion (what_to_do
, rl_username_completion_function
);
3606 bash_complete_filename (ignore
, ignore2
)
3607 int ignore
, ignore2
;
3609 return bash_complete_filename_internal (rl_completion_mode (bash_complete_filename
));
3613 bash_possible_filename_completions (ignore
, ignore2
)
3614 int ignore
, ignore2
;
3616 return bash_complete_filename_internal ('?');
3620 bash_complete_filename_internal (what_to_do
)
3623 rl_compentry_func_t
*orig_func
;
3624 rl_completion_func_t
*orig_attempt_func
;
3625 rl_icppfunc_t
*orig_dir_func
;
3626 rl_compignore_func_t
*orig_ignore_func
;
3627 /*const*/ char *orig_rl_completer_word_break_characters
;
3630 orig_func
= rl_completion_entry_function
;
3631 orig_attempt_func
= rl_attempted_completion_function
;
3632 orig_ignore_func
= rl_ignore_some_completions_function
;
3633 orig_rl_completer_word_break_characters
= rl_completer_word_break_characters
;
3635 orig_dir_func
= save_directory_hook ();
3637 rl_completion_entry_function
= rl_filename_completion_function
;
3638 rl_attempted_completion_function
= (rl_completion_func_t
*)NULL
;
3639 rl_ignore_some_completions_function
= filename_completion_ignore
;
3640 rl_completer_word_break_characters
= " \t\n\"\'";
3642 r
= rl_complete_internal (what_to_do
);
3644 rl_completion_entry_function
= orig_func
;
3645 rl_attempted_completion_function
= orig_attempt_func
;
3646 rl_ignore_some_completions_function
= orig_ignore_func
;
3647 rl_completer_word_break_characters
= orig_rl_completer_word_break_characters
;
3649 restore_directory_hook (orig_dir_func
);
3655 bash_complete_hostname (ignore
, ignore2
)
3656 int ignore
, ignore2
;
3658 return bash_complete_hostname_internal (rl_completion_mode (bash_complete_hostname
));
3662 bash_possible_hostname_completions (ignore
, ignore2
)
3663 int ignore
, ignore2
;
3665 return bash_complete_hostname_internal ('?');
3669 bash_complete_variable (ignore
, ignore2
)
3670 int ignore
, ignore2
;
3672 return bash_complete_variable_internal (rl_completion_mode (bash_complete_variable
));
3676 bash_possible_variable_completions (ignore
, ignore2
)
3677 int ignore
, ignore2
;
3679 return bash_complete_variable_internal ('?');
3683 bash_complete_command (ignore
, ignore2
)
3684 int ignore
, ignore2
;
3686 return bash_complete_command_internal (rl_completion_mode (bash_complete_command
));
3690 bash_possible_command_completions (ignore
, ignore2
)
3691 int ignore
, ignore2
;
3693 return bash_complete_command_internal ('?');
3697 bash_complete_hostname_internal (what_to_do
)
3700 return bash_specific_completion (what_to_do
, hostname_completion_function
);
3704 bash_complete_variable_internal (what_to_do
)
3707 return bash_specific_completion (what_to_do
, variable_completion_function
);
3711 bash_complete_command_internal (what_to_do
)
3714 return bash_specific_completion (what_to_do
, command_word_completion_function
);
3718 completion_glob_pattern (string
)
3728 send
= string
+ strlen (string
);
3730 while (c
= *string
++)
3750 if (*string
== '(') /*)*/
3759 /* Advance one fewer byte than an entire multibyte character to
3760 account for the auto-increment in the loop above. */
3761 #ifdef HANDLE_MULTIBYTE
3763 ADVANCE_CHAR_P (string
, send
- string
);
3766 ADVANCE_CHAR_P (string
, send
- string
);
3772 static char *globtext
;
3773 static char *globorig
;
3776 glob_complete_word (text
, state
)
3780 static char **matches
= (char **)NULL
;
3787 rl_filename_completion_desired
= 1;
3789 if (globorig
!= globtext
)
3793 ttext
= bash_tilde_expand (text
, 0);
3795 if (rl_explicit_arg
)
3797 globorig
= savestring (ttext
);
3798 glen
= strlen (ttext
);
3799 globtext
= (char *)xmalloc (glen
+ 2);
3800 strcpy (globtext
, ttext
);
3801 globtext
[glen
] = '*';
3802 globtext
[glen
+1] = '\0';
3805 globtext
= globorig
= savestring (ttext
);
3810 matches
= shell_glob_filename (globtext
);
3811 if (GLOB_FAILED (matches
))
3812 matches
= (char **)NULL
;
3816 ret
= matches
? matches
[ind
] : (char *)NULL
;
3822 bash_glob_completion_internal (what_to_do
)
3825 return bash_specific_completion (what_to_do
, glob_complete_word
);
3828 /* A special quoting function so we don't end up quoting globbing characters
3829 in the word if there are no matches or multiple matches. */
3831 bash_glob_quote_filename (s
, rtype
, qcp
)
3836 if (globorig
&& qcp
&& *qcp
== '\0' && STREQ (s
, globorig
))
3837 return (savestring (s
));
3839 return (bash_quote_filename (s
, rtype
, qcp
));
3843 bash_glob_complete_word (count
, key
)
3847 rl_quote_func_t
*orig_quoting_function
;
3849 if (rl_editing_mode
== EMACS_EDITING_MODE
)
3850 rl_explicit_arg
= 1; /* force `*' append */
3851 orig_quoting_function
= rl_filename_quoting_function
;
3852 rl_filename_quoting_function
= bash_glob_quote_filename
;
3854 r
= bash_glob_completion_internal (rl_completion_mode (bash_glob_complete_word
));
3856 rl_filename_quoting_function
= orig_quoting_function
;
3861 bash_glob_expand_word (count
, key
)
3864 return bash_glob_completion_internal ('*');
3868 bash_glob_list_expansions (count
, key
)
3871 return bash_glob_completion_internal ('?');
3875 bash_specific_completion (what_to_do
, generator
)
3877 rl_compentry_func_t
*generator
;
3879 rl_compentry_func_t
*orig_func
;
3880 rl_completion_func_t
*orig_attempt_func
;
3881 rl_compignore_func_t
*orig_ignore_func
;
3884 orig_func
= rl_completion_entry_function
;
3885 orig_attempt_func
= rl_attempted_completion_function
;
3886 orig_ignore_func
= rl_ignore_some_completions_function
;
3887 rl_completion_entry_function
= generator
;
3888 rl_attempted_completion_function
= NULL
;
3889 rl_ignore_some_completions_function
= orig_ignore_func
;
3891 r
= rl_complete_internal (what_to_do
);
3893 rl_completion_entry_function
= orig_func
;
3894 rl_attempted_completion_function
= orig_attempt_func
;
3895 rl_ignore_some_completions_function
= orig_ignore_func
;
3900 #endif /* SPECIFIC_COMPLETION_FUNCTIONS */
3902 #if defined (VI_MODE)
3903 /* Completion, from vi mode's point of view. This is a modified version of
3904 rl_vi_complete which uses the bash globbing code to implement what POSIX
3905 specifies, which is to append a `*' and attempt filename generation (which
3906 has the side effect of expanding any globbing characters in the word). */
3908 bash_vi_complete (count
, key
)
3911 #if defined (SPECIFIC_COMPLETION_FUNCTIONS)
3915 if ((rl_point
< rl_end
) && (!whitespace (rl_line_buffer
[rl_point
])))
3917 if (!whitespace (rl_line_buffer
[rl_point
+ 1]))
3918 rl_vi_end_word (1, 'E');
3922 /* Find boundaries of current word, according to vi definition of a
3928 rl_vi_bWord (1, 'B');
3933 t
= substring (rl_line_buffer
, p
, rl_point
);
3936 if (t
&& completion_glob_pattern (t
) == 0)
3937 rl_explicit_arg
= 1; /* XXX - force glob_complete_word to append `*' */
3940 if (key
== '*') /* Expansion and replacement. */
3941 r
= bash_glob_expand_word (count
, key
);
3942 else if (key
== '=') /* List possible completions. */
3943 r
= bash_glob_list_expansions (count
, key
);
3944 else if (key
== '\\') /* Standard completion */
3945 r
= bash_glob_complete_word (count
, key
);
3947 r
= rl_complete (0, key
);
3949 if (key
== '*' || key
== '\\')
3950 rl_vi_start_inserting (key
, 1, 1);
3954 return rl_vi_complete (count
, key
);
3955 #endif /* !SPECIFIC_COMPLETION_FUNCTIONS */
3957 #endif /* VI_MODE */
3959 /* Filename quoting for completion. */
3960 /* A function to strip unquoted quote characters (single quotes, double
3961 quotes, and backslashes). It allows single quotes to appear
3962 within double quotes, and vice versa. It should be smarter. */
3964 bash_dequote_filename (text
, quote_char
)
3972 ret
= (char *)xmalloc (l
+ 1);
3973 for (quoted
= quote_char
, p
= text
, r
= ret
; p
&& *p
; p
++)
3975 /* Allow backslash-escaped characters to pass through unscathed. */
3978 /* Backslashes are preserved within single quotes. */
3981 /* Backslashes are preserved within double quotes unless the
3982 character is one that is defined to be escaped */
3983 else if (quoted
== '"' && ((sh_syntaxtab
[(unsigned char)p
[1]] & CBSDQUOTE
) == 0))
3988 return ret
; /* XXX - was break; */
3992 if (quoted
&& *p
== quoted
)
3998 if (quoted
== 0 && (*p
== '\'' || *p
== '"'))
4009 /* Quote characters that the readline completion code would treat as
4010 word break characters with backslashes. Pass backslash-quoted
4011 characters through without examination. */
4013 quote_word_break_chars (text
)
4020 ret
= (char *)xmalloc ((2 * l
) + 1);
4021 for (s
= text
, r
= ret
; *s
; s
++)
4023 /* Pass backslash-quoted characters through, including the backslash. */
4032 /* OK, we have an unquoted character. Check its presence in
4033 rl_completer_word_break_characters. */
4034 if (mbschr (rl_completer_word_break_characters
, *s
))
4036 /* XXX -- check for standalone tildes here and backslash-quote them */
4037 if (s
== text
&& *s
== '~' && file_exists (text
))
4045 /* Use characters in STRING to populate the table of characters that should
4046 be backslash-quoted. The table will be used for sh_backslash_quote from
4049 set_filename_bstab (string
)
4054 memset (filename_bstab
, 0, sizeof (filename_bstab
));
4055 for (s
= string
; s
&& *s
; s
++)
4056 filename_bstab
[*s
] = 1;
4059 /* Quote a filename using double quotes, single quotes, or backslashes
4060 depending on the value of completion_quoting_style. If we're
4061 completing using backslashes, we need to quote some additional
4062 characters (those that readline treats as word breaks), so we call
4063 quote_word_break_chars on the result. This returns newly-allocated
4066 bash_quote_filename (s
, rtype
, qcp
)
4071 char *rtext
, *mtext
, *ret
;
4074 rtext
= (char *)NULL
;
4076 /* If RTYPE == MULT_MATCH, it means that there is
4077 more than one match. In this case, we do not add
4078 the closing quote or attempt to perform tilde
4079 expansion. If RTYPE == SINGLE_MATCH, we try
4080 to perform tilde expansion, because single and double
4081 quotes inhibit tilde expansion by the shell. */
4083 cs
= completion_quoting_style
;
4084 /* Might need to modify the default completion style based on *qcp,
4085 since it's set to any user-provided opening quote. We also change
4086 to single-quoting if there is no user-provided opening quote and
4087 the word being completed contains newlines, since those are not
4088 quoted correctly using backslashes (a backslash-newline pair is
4089 special to the shell parser). */
4090 if (*qcp
== '\0' && cs
== COMPLETE_BSQUOTE
&& mbschr (s
, '\n'))
4091 cs
= COMPLETE_SQUOTE
;
4092 else if (*qcp
== '"')
4093 cs
= COMPLETE_DQUOTE
;
4094 else if (*qcp
== '\'')
4095 cs
= COMPLETE_SQUOTE
;
4096 #if defined (BANG_HISTORY)
4097 else if (*qcp
== '\0' && history_expansion
&& cs
== COMPLETE_DQUOTE
&&
4098 history_expansion_inhibited
== 0 && mbschr (s
, '!'))
4099 cs
= COMPLETE_BSQUOTE
;
4101 if (*qcp
== '"' && history_expansion
&& cs
== COMPLETE_DQUOTE
&&
4102 history_expansion_inhibited
== 0 && mbschr (s
, '!'))
4104 cs
= COMPLETE_BSQUOTE
;
4109 /* Don't tilde-expand backslash-quoted filenames, since only single and
4110 double quotes inhibit tilde expansion. */
4112 if (mtext
[0] == '~' && rtype
== SINGLE_MATCH
&& cs
!= COMPLETE_BSQUOTE
)
4113 mtext
= bash_tilde_expand (s
, 0);
4117 case COMPLETE_DQUOTE
:
4118 rtext
= sh_double_quote (mtext
);
4120 case COMPLETE_SQUOTE
:
4121 rtext
= sh_single_quote (mtext
);
4123 case COMPLETE_BSQUOTE
:
4124 rtext
= sh_backslash_quote (mtext
, complete_fullquote
? 0 : filename_bstab
, 0);
4131 /* We may need to quote additional characters: those that readline treats
4132 as word breaks that are not quoted by backslash_quote. */
4133 if (rtext
&& cs
== COMPLETE_BSQUOTE
)
4135 mtext
= quote_word_break_chars (rtext
);
4140 /* Leave the opening quote intact. The readline completion code takes
4141 care of avoiding doubled opening quotes. */
4144 rlen
= strlen (rtext
);
4145 ret
= (char *)xmalloc (rlen
+ 1);
4146 strcpy (ret
, rtext
);
4150 ret
= (char *)xmalloc (rlen
= 1);
4154 /* If there are multiple matches, cut off the closing quote. */
4155 if (rtype
== MULT_MATCH
&& cs
!= COMPLETE_BSQUOTE
)
4156 ret
[rlen
- 1] = '\0';
4161 /* Support for binding readline key sequences to Unix commands. */
4162 static Keymap cmd_xmap
;
4173 x
= putc (c
, rl_outstream
);
4180 bash_execute_unix_command (count
, key
)
4181 int count
; /* ignored */
4187 sh_parser_state_t ps
;
4188 char *cmd
, *value
, *ce
, old_ch
;
4190 char ibuf
[INT_STRLEN_BOUND(int) + 1];
4192 /* First, we need to find the right command to execute. This is tricky,
4193 because we might have already indirected into another keymap, so we
4194 have to walk cmd_xmap using the entire key sequence. */
4195 cmd
= (char *)rl_function_of_keyseq_len (rl_executing_keyseq
, rl_key_sequence_length
, cmd_xmap
, &type
);
4197 if (cmd
== 0 || type
!= ISMACR
)
4200 internal_error (_("bash_execute_unix_command: cannot find keymap for command"));
4201 rl_forced_update_display ();
4205 ce
= rl_get_termcap ("ce");
4206 if (ce
) /* clear current line */
4209 fprintf (rl_outstream
, "\r");
4210 tputs (ce
, 1, putx
);
4212 rl_clear_visible_line ();
4214 fflush (rl_outstream
);
4217 rl_crlf (); /* move to a new line */
4219 v
= bind_variable ("READLINE_LINE", rl_line_buffer
, 0);
4221 VSETATTR (v
, att_exported
);
4223 #if defined (HANDLE_MULTIBYTE)
4226 old_ch
= rl_line_buffer
[rl_point
];
4227 rl_line_buffer
[rl_point
] = '\0';
4228 i
= MB_STRLEN (rl_line_buffer
);
4229 rl_line_buffer
[rl_point
] = old_ch
;
4232 value
= inttostr (i
, ibuf
, sizeof (ibuf
));
4233 v
= bind_int_variable ("READLINE_POINT", value
, 0);
4235 VSETATTR (v
, att_exported
);
4236 array_needs_making
= 1;
4238 save_parser_state (&ps
);
4239 r
= parse_and_execute (savestring (cmd
), "bash_execute_unix_command", SEVAL_NOHIST
|SEVAL_NOFREE
);
4240 restore_parser_state (&ps
);
4242 v
= find_variable ("READLINE_LINE");
4243 maybe_make_readline_line (v
? value_cell (v
) : 0);
4245 v
= find_variable ("READLINE_POINT");
4246 if (v
&& legal_number (value_cell (v
), &mi
))
4249 #if defined (HANDLE_MULTIBYTE)
4250 if (i
> 0 && MB_CUR_MAX
> 1)
4251 i
= _rl_find_next_mbchar (rl_line_buffer
, 0, i
, 0);
4256 if (rl_point
> rl_end
)
4258 else if (rl_point
< 0)
4263 check_unbind_variable ("READLINE_LINE");
4264 check_unbind_variable ("READLINE_POINT");
4265 array_needs_making
= 1;
4267 /* and restore the readline buffer and display after command execution. */
4268 /* If we clear the last line of the prompt above, redraw only that last
4269 line. If the command returns 124, we redraw unconditionally as in
4270 previous versions. */
4272 rl_redraw_prompt_last_line ();
4274 rl_forced_update_display ();
4280 print_unix_command_map ()
4284 save
= rl_get_keymap ();
4285 rl_set_keymap (cmd_xmap
);
4286 rl_macro_dumper (1);
4287 rl_set_keymap (save
);
4292 init_unix_command_map ()
4294 cmd_xmap
= rl_make_bare_keymap ();
4298 isolate_sequence (string
, ind
, need_dquote
, startp
)
4300 int ind
, need_dquote
, *startp
;
4303 int c
, passc
, delim
;
4305 for (i
= ind
; string
[i
] && whitespace (string
[i
]); i
++)
4307 /* NEED_DQUOTE means that the first non-white character *must* be `"'. */
4308 if (need_dquote
&& string
[i
] != '"')
4310 builtin_error (_("%s: first non-whitespace character is not `\"'"), string
);
4314 /* We can have delimited strings even if NEED_DQUOTE == 0, like the command
4315 string to bind the key sequence to. */
4316 delim
= (string
[i
] == '"' || string
[i
] == '\'') ? string
[i
] : 0;
4319 *startp
= delim
? ++i
: i
;
4321 for (passc
= 0; c
= string
[i
]; i
++)
4337 if (delim
&& string
[i
] != delim
)
4339 builtin_error (_("no closing `%c' in %s"), delim
, string
);
4347 bind_keyseq_to_unix_command (line
)
4355 init_unix_command_map ();
4357 kmap
= rl_get_keymap ();
4359 /* We duplicate some of the work done by rl_parse_and_bind here, but
4360 this code only has to handle `"keyseq": ["]command["]' and can
4361 generate an error for anything else. */
4362 i
= isolate_sequence (line
, 0, 1, &kstart
);
4366 /* Create the key sequence string to pass to rl_generic_bind */
4367 kseq
= substring (line
, kstart
, i
);
4369 for ( ; line
[i
] && line
[i
] != ':'; i
++)
4373 builtin_error (_("%s: missing colon separator"), line
);
4378 i
= isolate_sequence (line
, i
+ 1, 0, &kstart
);
4385 /* Create the value string containing the command to execute. */
4386 value
= substring (line
, kstart
, i
);
4388 /* Save the command to execute and the key sequence in the CMD_XMAP */
4389 rl_generic_bind (ISMACR
, kseq
, value
, cmd_xmap
);
4391 /* and bind the key sequence in the current keymap to a function that
4392 understands how to execute from CMD_XMAP */
4393 rl_bind_keyseq_in_map (kseq
, bash_execute_unix_command
, kmap
);
4399 /* Used by the programmable completion code. Complete TEXT as a filename,
4400 but return only directories as matches. Dequotes the filename before
4401 attempting to find matches. */
4403 bash_directory_completion_matches (text
)
4410 qc
= rl_dispatching
? rl_completion_quote_character
: 0;
4411 /* If rl_completion_found_quote != 0, rl_completion_matches will call the
4412 filename dequoting function, causing the directory name to be dequoted
4414 if (rl_dispatching
&& rl_completion_found_quote
== 0)
4415 dfn
= bash_dequote_filename ((char *)text
, qc
);
4418 m1
= rl_completion_matches (dfn
, rl_filename_completion_function
);
4422 if (m1
== 0 || m1
[0] == 0)
4424 /* We don't bother recomputing the lcd of the matches, because it will just
4425 get thrown away by the programmable completion code and recomputed
4427 (void)bash_ignore_filenames (m1
);
4432 bash_dequote_text (text
)
4438 qc
= (text
[0] == '"' || text
[0] == '\'') ? text
[0] : 0;
4439 dtxt
= bash_dequote_filename ((char *)text
, qc
);
4443 /* This event hook is designed to be called after readline receives a signal
4444 that interrupts read(2). It gives reasonable responsiveness to interrupts
4445 and fatal signals without executing too much code in a signal handler
4450 /* If we're going to longjmp to top_level, make sure we clean up readline.
4451 check_signals will call QUIT, which will eventually longjmp to top_level,
4452 calling run_interrupt_trap along the way. The check for sigalrm_seen is
4453 to clean up the read builtin's state. */
4454 if (terminating_signal
|| interrupt_state
|| sigalrm_seen
)
4455 rl_cleanup_after_signal ();
4456 bashline_reset_event_hook ();
4457 check_signals_and_traps (); /* XXX */
4461 #endif /* READLINE */