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 current_command_line_count
++; /* for rl_newline above */
965 bash_add_history (rl_line_buffer
);
966 current_command_line_count
= 0; /* for dummy history entry */
967 bash_add_history ("");
968 history_lines_this_session
++;
970 command
= savestring (edit_command
);
973 metaval
= rl_variable_value ("input-meta");
974 metaflag
= RL_BOOLEAN_VARIABLE_VALUE (metaval
);
976 if (rl_deprep_term_function
)
977 (*rl_deprep_term_function
) ();
978 save_parser_state (&ps
);
979 r
= parse_and_execute (command
, (editing_mode
== VI_EDITING_MODE
) ? "v" : "C-xC-e", SEVAL_NOHIST
);
980 restore_parser_state (&ps
);
981 if (rl_prep_term_function
)
982 (*rl_prep_term_function
) (metaflag
);
984 current_command_line_count
= saved_command_line_count
;
986 /* Now erase the contents of the current line and undo the effects of the
987 rl_accept_line() above. We don't even want to make the text we just
988 executed available for undoing. */
989 rl_line_buffer
[0] = '\0'; /* XXX */
990 rl_point
= rl_end
= 0;
992 rl_readline_state
= rrs
;
994 #if defined (VI_MODE)
995 if (editing_mode
== VI_EDITING_MODE
)
996 rl_vi_insertion_mode (1, c
);
999 rl_forced_update_display ();
1004 #if defined (VI_MODE)
1006 vi_edit_and_execute_command (count
, c
)
1009 if (posixly_correct
)
1010 return (edit_and_execute_command (count
, c
, VI_EDITING_MODE
, POSIX_VI_EDIT_COMMAND
));
1012 return (edit_and_execute_command (count
, c
, VI_EDITING_MODE
, VI_EDIT_COMMAND
));
1014 #endif /* VI_MODE */
1017 emacs_edit_and_execute_command (count
, c
)
1020 return (edit_and_execute_command (count
, c
, EMACS_EDITING_MODE
, EMACS_EDIT_COMMAND
));
1025 posix_edit_macros (count
, key
)
1029 char alias_name
[3], *alias_value
, *macro
;
1032 alias_name
[0] = '_';
1034 alias_name
[2] = '\0';
1036 alias_value
= get_alias_value (alias_name
);
1037 if (alias_value
&& *alias_value
)
1039 macro
= savestring (alias_value
);
1040 rl_push_macro_input (macro
);
1046 /* Bindable commands that move `shell-words': that is, sequences of
1047 non-unquoted-metacharacters. */
1049 #define WORDDELIM(c) (shellmeta(c) || shellblank(c))
1052 bash_forward_shellword (count
, key
)
1060 return (bash_backward_shellword (-count
, key
));
1062 /* The tricky part of this is deciding whether or not the first character
1063 we're on is an unquoted metacharacter. Not completely handled yet. */
1064 /* XXX - need to test this stuff with backslash-escaped shell
1065 metacharacters and unclosed single- and double-quoted strings. */
1078 /* Are we in a quoted string? If we are, move to the end of the quoted
1079 string and continue the outer loop. We only want quoted strings, not
1080 backslash-escaped characters, but char_is_quoted doesn't
1082 if (char_is_quoted (rl_line_buffer
, p
) && p
> 0 && rl_line_buffer
[p
-1] != '\\')
1085 ADVANCE_CHAR (rl_line_buffer
, slen
, p
);
1086 while (p
< rl_end
&& char_is_quoted (rl_line_buffer
, p
));
1091 /* Rest of code assumes we are not in a quoted string. */
1092 /* Move forward until we hit a non-metacharacter. */
1093 while (p
< rl_end
&& (c
= rl_line_buffer
[p
]) && WORDDELIM (c
))
1098 ADVANCE_CHAR (rl_line_buffer
, slen
, p
);
1099 continue; /* straight back to loop, don't increment p */
1101 if (p
< rl_end
&& rl_line_buffer
[p
])
1102 ADVANCE_CHAR (rl_line_buffer
, slen
, p
);
1105 p
= skip_to_delim (rl_line_buffer
, ++p
, "'", SD_NOJMP
);
1108 p
= skip_to_delim (rl_line_buffer
, ++p
, "\"", SD_NOJMP
);
1116 if (rl_line_buffer
[p
] == 0 || p
== rl_end
)
1123 /* Now move forward until we hit a non-quoted metacharacter or EOL */
1124 while (p
< rl_end
&& (c
= rl_line_buffer
[p
]) && WORDDELIM (c
) == 0)
1129 ADVANCE_CHAR (rl_line_buffer
, slen
, p
);
1130 continue; /* straight back to loop, don't increment p */
1132 if (p
< rl_end
&& rl_line_buffer
[p
])
1133 ADVANCE_CHAR (rl_line_buffer
, slen
, p
);
1136 p
= skip_to_delim (rl_line_buffer
, ++p
, "'", SD_NOJMP
);
1139 p
= skip_to_delim (rl_line_buffer
, ++p
, "\"", SD_NOJMP
);
1147 if (p
== rl_end
|| rl_line_buffer
[p
] == 0)
1161 bash_backward_shellword (count
, key
)
1169 return (bash_forward_shellword (-count
, key
));
1174 if (p
== rl_end
&& p
> 0)
1185 /* Move backward until we hit a non-metacharacter. */
1188 c
= rl_line_buffer
[p
];
1189 if (WORDDELIM (c
) == 0 || char_is_quoted (rl_line_buffer
, p
))
1191 BACKUP_CHAR (rl_line_buffer
, slen
, p
);
1200 /* Now move backward until we hit a metacharacter or BOL. */
1203 c
= rl_line_buffer
[p
];
1204 if (WORDDELIM (c
) && char_is_quoted (rl_line_buffer
, p
) == 0)
1206 BACKUP_CHAR (rl_line_buffer
, slen
, p
);
1217 bash_kill_shellword (count
, key
)
1223 return (bash_backward_kill_shellword (-count
, key
));
1226 bash_forward_shellword (count
, key
);
1229 rl_kill_text (p
, rl_point
);
1232 if (rl_editing_mode
== 1) /* 1 == emacs_mode */
1239 bash_backward_kill_shellword (count
, key
)
1245 return (bash_kill_shellword (-count
, key
));
1248 bash_backward_shellword (count
, key
);
1251 rl_kill_text (p
, rl_point
);
1253 if (rl_editing_mode
== 1) /* 1 == emacs_mode */
1260 /* **************************************************************** */
1262 /* How To Do Shell Completion */
1264 /* **************************************************************** */
1266 #define COMMAND_SEPARATORS ";|&{(`"
1268 #define COMMAND_SEPARATORS_PLUS_WS ";|&{(` \t"
1271 /* check for redirections and other character combinations that are not
1272 command separators */
1277 register int this_char
, prev_char
;
1279 /* Handle the two character tokens `>&', `<&', and `>|'.
1280 We are not in a command position after one of these. */
1281 this_char
= rl_line_buffer
[ti
];
1282 prev_char
= (ti
> 0) ? rl_line_buffer
[ti
- 1] : 0;
1284 if ((this_char
== '&' && (prev_char
== '<' || prev_char
== '>')) ||
1285 (this_char
== '|' && prev_char
== '>'))
1287 else if (this_char
== '{' && prev_char
== '$') /*}*/
1290 else if (this_char
== '(' && prev_char
== '$') /*)*/
1292 else if (this_char
== '(' && prev_char
== '<') /*)*/
1294 #if defined (EXTENDED_GLOB)
1295 else if (extended_glob
&& this_char
== '(' && prev_char
== '!') /*)*/
1299 else if (char_is_quoted (rl_line_buffer
, ti
))
1304 #if defined (PROGRAMMABLE_COMPLETION)
1306 * XXX - because of the <= start test, and setting os = s+1, this can
1307 * potentially return os > start. This is probably not what we want to
1308 * happen, but fix later after 2.05a-release.
1311 find_cmd_start (start
)
1314 register int s
, os
, ns
;
1317 /* Flags == SD_NOJMP only because we want to skip over command substitutions
1318 in assignment statements. Have to test whether this affects `standalone'
1319 command substitutions as individual words. */
1320 while (((s
= skip_to_delim (rl_line_buffer
, os
, COMMAND_SEPARATORS
, SD_NOJMP
|SD_COMPLETE
/*|SD_NOSKIPCMD*/)) <= start
) &&
1323 /* Handle >| token crudely; treat as > not | */
1324 if (rl_line_buffer
[s
] == '|' && rl_line_buffer
[s
-1] == '>')
1326 ns
= skip_to_delim (rl_line_buffer
, s
+1, COMMAND_SEPARATORS
, SD_NOJMP
|SD_COMPLETE
/*|SD_NOSKIPCMD*/);
1327 if (ns
> start
|| rl_line_buffer
[ns
] == 0)
1343 e
= skip_to_delim (rl_line_buffer
, end
, COMMAND_SEPARATORS
, SD_NOJMP
|SD_COMPLETE
);
1348 find_cmd_name (start
, sp
, ep
)
1355 for (s
= start
; whitespace (rl_line_buffer
[s
]); s
++)
1358 /* skip until a shell break character */
1359 e
= skip_to_delim (rl_line_buffer
, s
, "()<>;&| \t\n", SD_NOJMP
|SD_COMPLETE
);
1361 name
= substring (rl_line_buffer
, s
, e
);
1372 prog_complete_return (text
, matchnum
)
1381 if (prog_complete_matches
== 0 || prog_complete_matches
[ind
] == 0)
1382 return (char *)NULL
;
1383 return (prog_complete_matches
[ind
++]);
1386 #endif /* PROGRAMMABLE_COMPLETION */
1388 /* Try and catch completion attempts that are syntax errors or otherwise
1391 invalid_completion (text
, ind
)
1397 /* If we don't catch these here, the next clause will */
1398 if (ind
> 0 && rl_line_buffer
[ind
] == '(' && /*)*/
1399 member (rl_line_buffer
[ind
-1], "$<>"))
1403 while (pind
> 0 && whitespace (rl_line_buffer
[pind
]))
1405 /* If we have only whitespace preceding a paren, it's valid */
1406 if (ind
>= 0 && pind
<= 0 && rl_line_buffer
[ind
] == '(') /*)*/
1408 /* Flag the invalid completions, which are mostly syntax errors */
1409 if (ind
> 0 && rl_line_buffer
[ind
] == '(' && /*)*/
1410 member (rl_line_buffer
[pind
], COMMAND_SEPARATORS
) == 0)
1416 /* Do some completion on TEXT. The indices of TEXT in RL_LINE_BUFFER are
1417 at START and END. Return an array of matches, or NULL if none. */
1419 attempt_shell_completion (text
, start
, end
)
1423 int in_command_position
, ti
, qc
, dflags
;
1424 char **matches
, *command_separator_chars
;
1425 #if defined (PROGRAMMABLE_COMPLETION)
1426 int have_progcomps
, was_assignment
;
1427 COMPSPEC
*iw_compspec
;
1430 command_separator_chars
= COMMAND_SEPARATORS
;
1431 matches
= (char **)NULL
;
1432 rl_ignore_some_completions_function
= filename_completion_ignore
;
1434 rl_filename_quote_characters
= default_filename_quote_characters
;
1435 set_filename_bstab (rl_filename_quote_characters
);
1436 set_directory_hook ();
1437 rl_filename_stat_hook
= bash_filename_stat_hook
;
1439 rl_sort_completion_matches
= 1; /* sort by default */
1441 /* Determine if this could be a command word. It is if it appears at
1442 the start of the line (ignoring preceding whitespace), or if it
1443 appears after a character that separates commands. It cannot be a
1444 command word if we aren't at the top-level prompt. */
1448 while ((ti
> -1) && (whitespace (rl_line_buffer
[ti
])))
1452 /* If this is an open quote, maybe we're trying to complete a quoted
1454 if (ti
>= 0 && (rl_line_buffer
[ti
] == '"' || rl_line_buffer
[ti
] == '\''))
1456 qc
= rl_line_buffer
[ti
];
1458 while (ti
> -1 && (whitespace (rl_line_buffer
[ti
])))
1463 in_command_position
= 0;
1466 /* Only do command completion at the start of a line when we
1467 are prompting at the top level. */
1468 if (current_prompt_string
== ps1_prompt
)
1469 in_command_position
++;
1470 else if (parser_in_command_position ())
1471 in_command_position
++;
1473 else if (member (rl_line_buffer
[ti
], command_separator_chars
))
1475 in_command_position
++;
1477 if (check_redir (ti
) == 1)
1478 in_command_position
= 0;
1482 /* This still could be in command position. It is possible
1483 that all of the previous words on the line are variable
1487 if (in_command_position
&& invalid_completion (text
, ti
))
1489 rl_attempted_completion_over
= 1;
1490 return ((char **)NULL
);
1493 /* Check that we haven't incorrectly flagged a closed command substitution
1494 as indicating we're in a command position. */
1495 if (in_command_position
&& ti
>= 0 && rl_line_buffer
[ti
] == '`' &&
1496 *text
!= '`' && unclosed_pair (rl_line_buffer
, end
, "`") == 0)
1497 in_command_position
= 0;
1499 /* Special handling for command substitution. If *TEXT is a backquote,
1500 it can be the start or end of an old-style command substitution, or
1501 unmatched. If it's unmatched, both calls to unclosed_pair will
1502 succeed. Don't bother if readline found a single quote and we are
1503 completing on the substring. */
1504 if (*text
== '`' && rl_completion_quote_character
!= '\'' &&
1505 (in_command_position
|| (unclosed_pair (rl_line_buffer
, start
, "`") &&
1506 unclosed_pair (rl_line_buffer
, end
, "`"))))
1507 matches
= rl_completion_matches (text
, command_subst_completion_function
);
1509 #if defined (PROGRAMMABLE_COMPLETION)
1510 /* Attempt programmable completion. */
1511 have_progcomps
= prog_completion_enabled
&& (progcomp_size () > 0);
1512 iw_compspec
= progcomp_search (INITIALWORD
);
1514 (in_command_position
== 0 || text
[0] == '\0' || (in_command_position
&& iw_compspec
)) &&
1515 current_prompt_string
== ps1_prompt
)
1517 int s
, e
, s1
, e1
, os
, foundcs
;
1520 /* XXX - don't free the members */
1521 if (prog_complete_matches
)
1522 free (prog_complete_matches
);
1523 prog_complete_matches
= (char **)NULL
;
1528 s
= find_cmd_start (os
);
1529 e
= find_cmd_end (end
);
1532 /* Don't read past the end of rl_line_buffer */
1538 /* Or past point if point is within an assignment statement */
1539 else if (was_assignment
&& s
> rl_point
)
1544 /* Skip over assignment statements preceding a command name. If we
1545 don't find a command name at all, we can perform command name
1546 completion. If we find a partial command name, we should perform
1547 command name completion on it. */
1549 n
= find_cmd_name (s
, &s1
, &e1
);
1552 while (was_assignment
= assignment (n
, 0));
1553 s
= s1
; /* reset to index where name begins */
1555 /* s == index of where command name begins (reset above)
1556 e == end of current command, may be end of line
1557 s1 = index of where command name begins
1558 e1 == index of where command name ends
1559 start == index of where word to be completed begins
1560 end == index of where word to be completed ends
1561 if (s == start) we are doing command word completion for sure
1562 if (e1 == end) we are at the end of the command name and completing it */
1563 if (start
== 0 && end
== 0 && e
!= 0 && text
[0] == '\0') /* beginning of non-empty line */
1565 else if (start
== end
&& start
== s1
&& e
!= 0 && e1
> end
) /* beginning of command name, leading whitespace */
1567 else if (e
== 0 && e
== s
&& text
[0] == '\0' && have_progcomps
) /* beginning of empty line */
1568 prog_complete_matches
= programmable_completions (EMPTYCMD
, text
, s
, e
, &foundcs
);
1569 else if (start
== end
&& text
[0] == '\0' && s1
> start
&& whitespace (rl_line_buffer
[start
]))
1570 foundcs
= 0; /* whitespace before command name */
1571 else if (e
> s
&& was_assignment
== 0 && e1
== end
&& rl_line_buffer
[e
] == 0 && whitespace (rl_line_buffer
[e
-1]) == 0)
1573 /* not assignment statement, but still want to perform command
1574 completion if we are composing command word. */
1576 in_command_position
= s
== start
&& STREQ (n
, text
); /* XXX */
1578 else if (e
> s
&& was_assignment
== 0 && have_progcomps
)
1580 prog_complete_matches
= programmable_completions (n
, text
, s
, e
, &foundcs
);
1581 /* command completion if programmable completion fails */
1582 /* If we have a completion for the initial word, we can prefer that */
1583 in_command_position
= s
== start
&& (iw_compspec
|| STREQ (n
, text
)); /* XXX */
1584 if (iw_compspec
&& in_command_position
)
1587 /* empty command name following command separator */
1588 else if (s
>= e
&& n
[0] == '\0' && text
[0] == '\0' && start
> 0 &&
1589 was_assignment
== 0 && member (rl_line_buffer
[start
-1], COMMAND_SEPARATORS
))
1592 in_command_position
= 1;
1594 else if (s
>= e
&& n
[0] == '\0' && text
[0] == '\0' && start
> 0)
1596 foundcs
= 0; /* empty command name following optional assignments */
1597 in_command_position
+= was_assignment
;
1599 else if (s
== start
&& e
== end
&& STREQ (n
, text
) && start
> 0)
1601 foundcs
= 0; /* partial command name following assignments */
1602 in_command_position
= 1;
1607 /* If we have defined a compspec for the initial (command) word, call
1608 it and process the results like any other programmable completion. */
1609 if (in_command_position
&& have_progcomps
&& foundcs
== 0 && iw_compspec
)
1610 prog_complete_matches
= programmable_completions (INITIALWORD
, text
, s
, e
, &foundcs
);
1613 /* XXX - if we found a COMPSPEC for the command, just return whatever
1614 the programmable completion code returns, and disable the default
1615 filename completion that readline will do unless the COPT_DEFAULT
1616 option has been set with the `-o default' option to complete or
1620 pcomp_set_readline_variables (foundcs
, 1);
1621 /* Turn what the programmable completion code returns into what
1622 readline wants. I should have made compute_lcd_of_matches
1624 matches
= rl_completion_matches (text
, prog_complete_return
);
1625 if ((foundcs
& COPT_DEFAULT
) == 0)
1626 rl_attempted_completion_over
= 1; /* no default */
1627 if (matches
|| ((foundcs
& COPT_BASHDEFAULT
) == 0))
1636 if (in_command_position
)
1637 dflags
|= DEFCOMP_CMDPOS
;
1638 matches
= bash_default_completion (text
, start
, end
, qc
, dflags
);
1645 bash_default_completion (text
, start
, end
, qc
, compflags
)
1647 int start
, end
, qc
, compflags
;
1651 matches
= (char **)NULL
;
1653 /* New posix-style command substitution or variable name? */
1656 if (qc
!= '\'' && text
[1] == '(') /* ) */
1657 matches
= rl_completion_matches (text
, command_subst_completion_function
);
1660 matches
= rl_completion_matches (text
, variable_completion_function
);
1661 /* If a single match, see if it expands to a directory name and append
1662 a slash if it does. This requires us to expand the variable name,
1663 so we don't want to display errors if the variable is unset. This
1664 can happen with dynamic variables whose value has never been
1666 if (matches
&& matches
[0] && matches
[1] == 0)
1668 t
= savestring (matches
[0]);
1669 bash_filename_stat_hook (&t
);
1670 /* doesn't use test_for_directory because that performs tilde
1673 rl_completion_append_character
= '/';
1679 /* If the word starts in `~', and there is no slash in the word, then
1680 try completing this word as a username. */
1681 if (matches
== 0 && *text
== '~' && mbschr (text
, '/') == 0)
1682 matches
= rl_completion_matches (text
, rl_username_completion_function
);
1684 /* Another one. Why not? If the word starts in '@', then look through
1685 the world of known hostnames for completion first. */
1686 if (matches
== 0 && perform_hostname_completion
&& *text
== '@')
1687 matches
= rl_completion_matches (text
, hostname_completion_function
);
1689 /* And last, (but not least) if this word is in a command position, then
1690 complete over possible command names, including aliases, functions,
1691 and command names. */
1692 if (matches
== 0 && (compflags
& DEFCOMP_CMDPOS
))
1694 /* If END == START and text[0] == 0, we are trying to complete an empty
1696 if (no_empty_command_completion
&& end
== start
&& text
[0] == '\0')
1698 matches
= (char **)NULL
;
1699 rl_ignore_some_completions_function
= bash_ignore_everything
;
1703 #define CMD_IS_DIR(x) (absolute_pathname(x) == 0 && absolute_program(x) == 0 && *(x) != '~' && test_for_directory (x))
1706 matches
= rl_completion_matches (text
, command_word_completion_function
);
1708 /* If we are attempting command completion and nothing matches, we
1709 do not want readline to perform filename completion for us. We
1710 still want to be able to complete partial pathnames, so set the
1711 completion ignore function to something which will remove
1712 filenames and leave directories in the match list. */
1713 if (matches
== (char **)NULL
)
1714 rl_ignore_some_completions_function
= bash_ignore_filenames
;
1715 else if (matches
[1] == 0 && CMD_IS_DIR(matches
[0]) && dot_in_path
== 0)
1716 /* If we found a single match, without looking in the current
1717 directory (because it's not in $PATH), but the found name is
1718 also a command in the current directory, suppress appending any
1719 terminating character, since it's ambiguous. */
1721 rl_completion_suppress_append
= 1;
1722 rl_filename_completion_desired
= 0;
1724 else if (matches
[0] && matches
[1] && STREQ (matches
[0], matches
[1]) && CMD_IS_DIR (matches
[0]))
1725 /* There are multiple instances of the same match (duplicate
1726 completions haven't yet been removed). In this case, all of
1727 the matches will be the same, and the duplicate removal code
1728 will distill them all down to one. We turn on
1729 rl_completion_suppress_append for the same reason as above.
1730 Remember: we only care if there's eventually a single unique
1731 completion. If there are multiple completions this won't
1732 make a difference and the problem won't occur. */
1734 rl_completion_suppress_append
= 1;
1735 rl_filename_completion_desired
= 0;
1740 /* This could be a globbing pattern, so try to expand it using pathname
1742 if (!matches
&& completion_glob_pattern ((char *)text
))
1744 matches
= rl_completion_matches (text
, glob_complete_word
);
1745 /* A glob expression that matches more than one filename is problematic.
1746 If we match more than one filename, punt. */
1747 if (matches
&& matches
[1] && rl_completion_type
== TAB
)
1749 strvec_dispose (matches
);
1750 matches
= (char **)0;
1752 else if (matches
&& matches
[1] && rl_completion_type
== '!')
1754 rl_completion_suppress_append
= 1;
1755 rl_filename_completion_desired
= 0;
1763 bash_command_name_stat_hook (name
)
1766 char *cname
, *result
;
1768 /* If it's not something we're going to look up in $PATH, just call the
1769 normal filename stat hook. */
1770 if (absolute_program (*name
))
1771 return (bash_filename_stat_hook (name
));
1774 /* XXX - we could do something here with converting aliases, builtins,
1775 and functions into something that came out as executable, but we don't. */
1776 result
= search_for_command (cname
, 0);
1786 executable_completion (filename
, searching_path
)
1787 const char *filename
;
1793 f
= savestring (filename
);
1794 bash_directory_completion_hook (&f
);
1796 r
= searching_path
? executable_file (f
) : executable_or_directory (f
);
1801 /* This is the function to call when the word to complete is in a position
1802 where a command word can be found. It grovels $PATH, looking for commands
1803 that match. It also scans aliases, function names, and the shell_builtin
1806 command_word_completion_function (hint_text
, state
)
1807 const char *hint_text
;
1810 static char *hint
= (char *)NULL
;
1811 static char *path
= (char *)NULL
;
1812 static char *val
= (char *)NULL
;
1813 static char *filename_hint
= (char *)NULL
;
1814 static char *fnhint
= (char *)NULL
;
1815 static char *dequoted_hint
= (char *)NULL
;
1816 static char *directory_part
= (char *)NULL
;
1817 static char **glob_matches
= (char **)NULL
;
1818 static int path_index
, hint_len
, istate
, igncase
;
1819 static int mapping_over
, local_index
, searching_path
, hint_is_dir
;
1820 static int old_glob_ignore_case
, globpat
;
1821 static SHELL_VAR
**varlist
= (SHELL_VAR
**)NULL
;
1823 static alias_t
**alias_list
= (alias_t
**)NULL
;
1827 /* We have to map over the possibilities for command words. If we have
1828 no state, then make one just for that purpose. */
1831 rl_filename_stat_hook
= bash_command_name_stat_hook
;
1833 if (dequoted_hint
&& dequoted_hint
!= hint
)
1834 free (dequoted_hint
);
1838 mapping_over
= searching_path
= 0;
1839 hint_is_dir
= CMD_IS_DIR (hint_text
);
1842 temp
= rl_variable_value ("completion-ignore-case");
1843 igncase
= RL_BOOLEAN_VARIABLE_VALUE (temp
);
1847 free (glob_matches
);
1848 glob_matches
= (char **)NULL
;
1851 globpat
= completion_glob_pattern ((char *)hint_text
);
1853 /* If this is an absolute program name, do not check it against
1854 aliases, reserved words, functions or builtins. We must check
1855 whether or not it is unique, and, if so, whether that filename
1857 if (globpat
|| absolute_program (hint_text
))
1859 /* Perform tilde expansion on what's passed, so we don't end up
1860 passing filenames with tildes directly to stat(). The rest of
1861 the shell doesn't do variable expansion on the word following
1862 the tilde, so we don't do it here even if direxpand is set. */
1863 if (*hint_text
== '~')
1865 hint
= bash_tilde_expand (hint_text
, 0);
1866 directory_part
= savestring (hint_text
);
1867 temp
= strchr (directory_part
, '/');
1872 free (directory_part
);
1873 directory_part
= (char *)NULL
;
1876 else if (dircomplete_expand
)
1878 hint
= savestring (hint_text
);
1879 bash_directory_completion_hook (&hint
);
1882 hint
= savestring (hint_text
);
1884 dequoted_hint
= hint
;
1885 /* If readline's completer found a quote character somewhere, but
1886 didn't set the quote character, there must have been a quote
1887 character embedded in the filename. It can't be at the start of
1888 the filename, so we need to dequote the filename before we look
1889 in the file system for it. */
1890 if (rl_completion_found_quote
&& rl_completion_quote_character
== 0)
1892 dequoted_hint
= bash_dequote_filename (hint
, 0);
1894 hint
= dequoted_hint
;
1896 hint_len
= strlen (hint
);
1899 free (filename_hint
);
1901 fnhint
= filename_hint
= savestring (hint
);
1912 if (dircomplete_expand
&& path_dot_or_dotdot (filename_hint
))
1914 dircomplete_expand
= 0;
1915 set_directory_hook ();
1916 dircomplete_expand
= 1;
1923 dequoted_hint
= hint
= savestring (hint_text
);
1924 hint_len
= strlen (hint
);
1926 if (rl_completion_found_quote
&& rl_completion_quote_character
== 0)
1927 dequoted_hint
= bash_dequote_filename (hint
, 0);
1929 path
= get_string_value ("PATH");
1930 path_index
= dot_in_path
= 0;
1932 /* Initialize the variables for each type of command word. */
1938 varlist
= all_visible_functions ();
1944 alias_list
= all_aliases ();
1948 /* mapping_over says what we are currently hacking. Note that every case
1949 in this list must fall through when there are no more possibilities. */
1951 switch (mapping_over
)
1953 case 0: /* Aliases come first. */
1955 while (alias_list
&& alias_list
[local_index
])
1957 register char *alias
;
1959 alias
= alias_list
[local_index
++]->name
;
1961 if (igncase
== 0 && (STREQN (alias
, hint
, hint_len
)))
1962 return (savestring (alias
));
1963 else if (igncase
&& strncasecmp (alias
, hint
, hint_len
) == 0)
1964 return (savestring (alias
));
1970 case 1: /* Then shell reserved words. */
1972 while (word_token_alist
[local_index
].word
)
1974 register char *reserved_word
;
1976 reserved_word
= word_token_alist
[local_index
++].word
;
1978 if (STREQN (reserved_word
, hint
, hint_len
))
1979 return (savestring (reserved_word
));
1985 case 2: /* Then function names. */
1986 while (varlist
&& varlist
[local_index
])
1988 register char *varname
;
1990 varname
= varlist
[local_index
++]->name
;
1992 /* Honor completion-ignore-case for shell function names. */
1993 if (igncase
== 0 && (STREQN (varname
, hint
, hint_len
)))
1994 return (savestring (varname
));
1995 else if (igncase
&& strncasecmp (varname
, hint
, hint_len
) == 0)
1996 return (savestring (varname
));
2001 case 3: /* Then shell builtins. */
2002 for (; local_index
< num_shell_builtins
; local_index
++)
2004 /* Ignore it if it doesn't have a function pointer or if it
2005 is not currently enabled. */
2006 if (!shell_builtins
[local_index
].function
||
2007 (shell_builtins
[local_index
].flags
& BUILTIN_ENABLED
) == 0)
2010 if (STREQN (shell_builtins
[local_index
].name
, hint
, hint_len
))
2012 int i
= local_index
++;
2014 return (savestring (shell_builtins
[i
].name
));
2022 /* Limited support for completing command words with globbing chars. Only
2023 a single match (multiple matches that end up reducing the number of
2024 characters in the common prefix are bad) will ever be returned on
2025 regular completion. */
2030 glob_ignore_case
= igncase
;
2031 glob_matches
= shell_glob_filename (hint
);
2032 glob_ignore_case
= old_glob_ignore_case
;
2034 if (GLOB_FAILED (glob_matches
) || glob_matches
== 0)
2036 glob_matches
= (char **)NULL
;
2037 return ((char *)NULL
);
2042 if (glob_matches
[1] && rl_completion_type
== TAB
) /* multiple matches are bad */
2043 return ((char *)NULL
);
2046 while (val
= glob_matches
[local_index
++])
2048 if (executable_or_directory (val
))
2050 if (*hint_text
== '~' && directory_part
)
2052 temp
= maybe_restore_tilde (val
, directory_part
);
2061 glob_ignore_case
= old_glob_ignore_case
;
2062 return ((char *)NULL
);
2065 /* If the text passed is a directory in the current directory, return it
2066 as a possible match. Executables in directories in the current
2067 directory can be specified using relative pathnames and successfully
2068 executed even when `.' is not in $PATH. */
2071 hint_is_dir
= 0; /* only return the hint text once */
2072 return (savestring (hint_text
));
2075 /* Repeatedly call filename_completion_function while we have
2076 members of PATH left. Question: should we stat each file?
2077 Answer: we call executable_file () on each file. */
2080 istate
= (val
!= (char *)NULL
);
2086 /* Get the next directory from the path. If there is none, then we
2088 if (path
== 0 || path
[path_index
] == 0 ||
2089 (current_path
= extract_colon_unit (path
, &path_index
)) == 0)
2090 return ((char *)NULL
);
2093 if (*current_path
== 0)
2095 free (current_path
);
2096 current_path
= savestring (".");
2099 if (*current_path
== '~')
2103 t
= bash_tilde_expand (current_path
, 0);
2104 free (current_path
);
2108 if (current_path
[0] == '.' && current_path
[1] == '\0')
2111 if (fnhint
&& fnhint
!= filename_hint
)
2114 free (filename_hint
);
2116 filename_hint
= sh_makepath (current_path
, hint
, 0);
2117 /* Need a quoted version (though it doesn't matter much in most
2118 cases) because rl_filename_completion_function dequotes the
2119 filename it gets, assuming that it's been quoted as part of
2120 the input line buffer. */
2121 if (strpbrk (filename_hint
, "\"'\\"))
2122 fnhint
= sh_backslash_quote (filename_hint
, filename_bstab
, 0);
2124 fnhint
= filename_hint
;
2125 free (current_path
); /* XXX */
2129 val
= rl_filename_completion_function (fnhint
, istate
);
2130 if (mapping_over
== 4 && dircomplete_expand
)
2131 set_directory_hook ();
2137 /* If the hint text is an absolute program, then don't bother
2138 searching through PATH. */
2139 if (absolute_program (hint
))
2140 return ((char *)NULL
);
2146 int match
, freetemp
;
2148 if (absolute_program (hint
))
2151 match
= strncmp (val
, hint
, hint_len
) == 0;
2153 match
= strncasecmp (val
, hint
, hint_len
) == 0;
2155 /* If we performed tilde expansion, restore the original
2157 if (*hint_text
== '~')
2158 temp
= maybe_restore_tilde (val
, directory_part
);
2160 temp
= savestring (val
);
2165 temp
= strrchr (val
, '/');
2171 freetemp
= match
= strncmp (temp
, hint
, hint_len
) == 0;
2173 freetemp
= match
= strncasecmp (temp
, hint
, hint_len
) == 0;
2175 temp
= savestring (temp
);
2178 freetemp
= match
= 0;
2181 /* If we have found a match, and it is an executable file, return it.
2182 We don't return directory names when searching $PATH, since the
2183 bash execution code won't find executables in directories which
2184 appear in directories in $PATH when they're specified using
2185 relative pathnames. */
2187 /* If we're not searching $PATH and we have a relative pathname, we
2188 need to re-canonicalize it before testing whether or not it's an
2189 executable or a directory so the shell treats .. relative to $PWD
2190 according to the physical/logical option. The shell already
2191 canonicalizes the directory name in order to tell readline where
2192 to look, so not doing it here will be inconsistent. */
2193 /* XXX -- currently not used -- will introduce more inconsistency,
2194 since shell does not canonicalize ../foo before passing it to
2196 if (match
&& searching_path
== 0 && *val
== '.')
2200 t
= get_working_directory ("command-word-completion");
2201 t1
= make_absolute (val
, t
);
2203 cval
= sh_canonpath (t1
, PATH_CHECKDOTDOT
|PATH_CHECKEXISTS
);
2209 if (match
&& executable_completion ((searching_path
? val
: cval
), searching_path
))
2214 val
= ""; /* So it won't be NULL. */
2229 /* Completion inside an unterminated command substitution. */
2231 command_subst_completion_function (text
, state
)
2235 static char **matches
= (char **)NULL
;
2236 static const char *orig_start
;
2237 static char *filename_text
= (char *)NULL
;
2238 static int cmd_index
, start_len
;
2244 free (filename_text
);
2248 else if (*text
== '$' && text
[1] == '(') /* ) */
2250 /* If the text was quoted, suppress any quote character that the
2251 readline completion code would insert. */
2252 rl_completion_suppress_quote
= 1;
2253 start_len
= text
- orig_start
;
2254 filename_text
= savestring (text
);
2259 * At this point we can entertain the idea of re-parsing
2260 * `filename_text' into a (possibly incomplete) command name and
2261 * arguments, and doing completion based on that. This is
2262 * currently very rudimentary, but it is a small improvement.
2264 for (value
= filename_text
+ strlen (filename_text
) - 1; value
> filename_text
; value
--)
2265 if (whitespace (*value
) || member (*value
, COMMAND_SEPARATORS
))
2267 if (value
<= filename_text
)
2268 matches
= rl_completion_matches (filename_text
, command_word_completion_function
);
2272 start_len
+= value
- filename_text
;
2273 if (whitespace (value
[-1]))
2274 matches
= rl_completion_matches (value
, rl_filename_completion_function
);
2276 matches
= rl_completion_matches (value
, command_word_completion_function
);
2279 /* If there is more than one match, rl_completion_matches has already
2280 put the lcd in matches[0]. Skip over it. */
2281 cmd_index
= matches
&& matches
[0] && matches
[1];
2283 /* If there's a single match and it's a directory, set the append char
2284 to the expected `/'. Otherwise, don't append anything. */
2285 if (matches
&& matches
[0] && matches
[1] == 0 && test_for_directory (matches
[0]))
2286 rl_completion_append_character
= '/';
2288 rl_completion_suppress_append
= 1;
2291 if (matches
== 0 || matches
[cmd_index
] == 0)
2293 rl_filename_quoting_desired
= 0; /* disable quoting */
2294 return ((char *)NULL
);
2298 value
= (char *)xmalloc (1 + start_len
+ strlen (matches
[cmd_index
]));
2301 value
[0] = *orig_start
;
2303 strncpy (value
, orig_start
, start_len
);
2305 strcpy (value
+ start_len
, matches
[cmd_index
]);
2312 /* Okay, now we write the entry_function for variable completion. */
2314 variable_completion_function (text
, state
)
2318 static char **varlist
= (char **)NULL
;
2319 static int varlist_index
;
2320 static char *varname
= (char *)NULL
;
2321 static int first_char
, first_char_loc
;
2329 first_char
= text
[0];
2331 if (first_char
== '$')
2334 if (text
[first_char_loc
] == '{')
2337 varname
= savestring (text
+ first_char_loc
);
2340 strvec_dispose (varlist
);
2342 varlist
= all_variables_matching_prefix (varname
);
2346 if (!varlist
|| !varlist
[varlist_index
])
2348 return ((char *)NULL
);
2354 value
= (char *)xmalloc (4 + strlen (varlist
[varlist_index
]));
2358 value
[0] = first_char
;
2359 if (first_char_loc
== 2)
2363 strcpy (value
+ first_char_loc
, varlist
[varlist_index
]);
2364 if (first_char_loc
== 2)
2365 strcat (value
, "}");
2372 /* How about a completion function for hostnames? */
2374 hostname_completion_function (text
, state
)
2378 static char **list
= (char **)NULL
;
2379 static int list_index
= 0;
2380 static int first_char
, first_char_loc
;
2382 /* If we don't have any state, make some. */
2387 list
= (char **)NULL
;
2392 if (first_char
== '@')
2395 list
= hostnames_matching ((char *)text
+first_char_loc
);
2399 if (list
&& list
[list_index
])
2403 t
= (char *)xmalloc (2 + strlen (list
[list_index
]));
2405 strcpy (t
+ first_char_loc
, list
[list_index
]);
2410 return ((char *)NULL
);
2414 * A completion function for service names from /etc/services (or wherever).
2417 bash_servicename_completion_function (text
, state
)
2421 #if defined (__WIN32__) || defined (__OPENNT) || !defined (HAVE_GETSERVENT)
2422 return ((char *)NULL
);
2424 static char *sname
= (char *)NULL
;
2425 static struct servent
*srvent
;
2426 static int snamelen
;
2428 char **alist
, *aentry
;
2435 sname
= savestring (text
);
2436 snamelen
= strlen (sname
);
2440 while (srvent
= getservent ())
2443 if (snamelen
== 0 || (STREQN (sname
, srvent
->s_name
, snamelen
)))
2445 /* Not primary, check aliases */
2446 for (alist
= srvent
->s_aliases
; *alist
; alist
++)
2449 if (STREQN (sname
, aentry
, snamelen
))
2463 return ((char *)NULL
);
2466 value
= afound
? savestring (aentry
) : savestring (srvent
->s_name
);
2472 * A completion function for group names from /etc/group (or wherever).
2475 bash_groupname_completion_function (text
, state
)
2479 #if defined (__WIN32__) || defined (__OPENNT) || !defined (HAVE_GRP_H)
2480 return ((char *)NULL
);
2482 static char *gname
= (char *)NULL
;
2483 static struct group
*grent
;
2484 static int gnamelen
;
2490 gname
= savestring (text
);
2491 gnamelen
= strlen (gname
);
2496 while (grent
= getgrent ())
2498 if (gnamelen
== 0 || (STREQN (gname
, grent
->gr_name
, gnamelen
)))
2505 return ((char *)NULL
);
2508 value
= savestring (grent
->gr_name
);
2513 /* Functions to perform history and alias expansions on the current line. */
2515 #if defined (BANG_HISTORY)
2516 /* Perform history expansion on the current line. If no history expansion
2517 is done, pre_process_line() returns what it was passed, so we need to
2518 allocate a new line here. */
2520 history_expand_line_internal (line
)
2526 old_verify
= hist_verify
;
2528 new_line
= pre_process_line (line
, 0, 0);
2529 hist_verify
= old_verify
;
2531 return (new_line
== line
) ? savestring (line
) : new_line
;
2535 /* There was an error in expansion. Let the preprocessor print
2538 cleanup_expansion_error ()
2541 #if defined (BANG_HISTORY)
2544 old_verify
= hist_verify
;
2548 fprintf (rl_outstream
, "\r\n");
2549 to_free
= pre_process_line (rl_line_buffer
, 1, 0);
2550 #if defined (BANG_HISTORY)
2551 hist_verify
= old_verify
;
2553 if (to_free
!= rl_line_buffer
)
2555 putc ('\r', rl_outstream
);
2556 rl_forced_update_display ();
2559 /* If NEW_LINE differs from what is in the readline line buffer, add an
2560 undo record to get from the readline line buffer contents to the new
2561 line and make NEW_LINE the current readline line. */
2563 maybe_make_readline_line (new_line
)
2566 if (new_line
&& strcmp (new_line
, rl_line_buffer
) != 0)
2570 rl_add_undo (UNDO_BEGIN
, 0, 0, 0);
2571 rl_delete_text (0, rl_point
);
2572 rl_point
= rl_end
= rl_mark
= 0;
2573 rl_insert_text (new_line
);
2574 rl_add_undo (UNDO_END
, 0, 0, 0);
2578 /* Make NEW_LINE be the current readline line. This frees NEW_LINE. */
2580 set_up_new_line (new_line
)
2583 int old_point
, at_end
;
2585 old_point
= rl_point
;
2586 at_end
= rl_point
== rl_end
;
2588 /* If the line was history and alias expanded, then make that
2589 be one thing to undo. */
2590 maybe_make_readline_line (new_line
);
2593 /* Place rl_point where we think it should go. */
2596 else if (old_point
< rl_end
)
2598 rl_point
= old_point
;
2599 if (!whitespace (rl_line_buffer
[rl_point
]))
2600 rl_forward_word (1, 0);
2605 /* Expand aliases in the current readline line. */
2607 alias_expand_line (count
, ignore
)
2612 new_line
= alias_expand (rl_line_buffer
);
2616 set_up_new_line (new_line
);
2621 cleanup_expansion_error ();
2627 #if defined (BANG_HISTORY)
2628 /* History expand the line. */
2630 history_expand_line (count
, ignore
)
2635 new_line
= history_expand_line_internal (rl_line_buffer
);
2639 set_up_new_line (new_line
);
2644 cleanup_expansion_error ();
2649 /* Expand history substitutions in the current line and then insert a
2650 space (hopefully close to where we were before). */
2652 tcsh_magic_space (count
, ignore
)
2655 int dist_from_end
, old_point
;
2657 old_point
= rl_point
;
2658 dist_from_end
= rl_end
- rl_point
;
2659 if (history_expand_line (count
, ignore
) == 0)
2661 /* Try a simple heuristic from Stephen Gildea <gildea@intouchsys.com>.
2662 This works if all expansions were before rl_point or if no expansions
2664 rl_point
= (old_point
== 0) ? old_point
: rl_end
- dist_from_end
;
2671 #endif /* BANG_HISTORY */
2673 /* History and alias expand the line. */
2675 history_and_alias_expand_line (count
, ignore
)
2681 #if defined (BANG_HISTORY)
2682 new_line
= history_expand_line_internal (rl_line_buffer
);
2690 alias_line
= alias_expand (new_line
);
2692 new_line
= alias_line
;
2698 set_up_new_line (new_line
);
2703 cleanup_expansion_error ();
2708 /* History and alias expand the line, then perform the shell word
2709 expansions by calling expand_string. This can't use set_up_new_line()
2710 because we want the variable expansions as a separate undo'able
2711 set of operations. */
2713 shell_expand_line (count
, ignore
)
2717 WORD_LIST
*expanded_string
;
2721 #if defined (BANG_HISTORY)
2722 new_line
= history_expand_line_internal (rl_line_buffer
);
2730 alias_line
= alias_expand (new_line
);
2732 new_line
= alias_line
;
2738 int old_point
= rl_point
;
2739 int at_end
= rl_point
== rl_end
;
2741 /* If the line was history and alias expanded, then make that
2742 be one thing to undo. */
2743 maybe_make_readline_line (new_line
);
2746 /* If there is variable expansion to perform, do that as a separate
2747 operation to be undone. */
2750 w
= alloc_word_desc ();
2751 w
->word
= savestring (rl_line_buffer
);
2752 w
->flags
= rl_explicit_arg
? (W_NOPROCSUB
|W_NOCOMSUB
) : 0;
2753 expanded_string
= expand_word (w
, rl_explicit_arg
? Q_HERE_DOCUMENT
: 0);
2756 new_line
= savestring (rl_line_buffer
);
2757 expanded_string
= expand_string (new_line
, 0);
2761 if (expanded_string
== 0)
2763 new_line
= (char *)xmalloc (1);
2768 new_line
= string_list (expanded_string
);
2769 dispose_words (expanded_string
);
2772 maybe_make_readline_line (new_line
);
2775 /* Place rl_point where we think it should go. */
2778 else if (old_point
< rl_end
)
2780 rl_point
= old_point
;
2781 if (!whitespace (rl_line_buffer
[rl_point
]))
2782 rl_forward_word (1, 0);
2788 cleanup_expansion_error ();
2793 /* If FIGNORE is set, then don't match files with the given suffixes when
2794 completing filenames. If only one of the possibilities has an acceptable
2795 suffix, delete the others, else just return and let the completer
2796 signal an error. It is called by the completer when real
2797 completions are done on filenames by the completer's internal
2798 function, not for completion lists (M-?) and not on "other"
2799 completion types, such as hostnames or commands. */
2801 static struct ignorevar fignore
=
2807 (sh_iv_item_func_t
*) 0,
2811 _ignore_completion_names (names
, name_func
)
2813 sh_ignore_func_t
*name_func
;
2820 /* If there is only one completion, see if it is acceptable. If it is
2821 not, free it up. In any case, short-circuit and return. This is a
2822 special case because names[0] is not the prefix of the list of names
2823 if there is only one completion; it is the completion itself. */
2824 if (names
[1] == (char *)0)
2827 if ((*name_func
) (names
[0]) == 0)
2830 names
[0] = (char *)NULL
;
2836 /* Allocate space for array to hold list of pointers to matching
2837 filenames. The pointers are copied back to NAMES when done. */
2838 for (nidx
= 1; names
[nidx
]; nidx
++)
2840 newnames
= strvec_create (nidx
+ 1);
2842 if (force_fignore
== 0)
2844 oldnames
= strvec_create (nidx
- 1);
2848 newnames
[0] = names
[0];
2849 for (idx
= nidx
= 1; names
[idx
]; idx
++)
2851 if ((*name_func
) (names
[idx
]))
2852 newnames
[nidx
++] = names
[idx
];
2853 else if (force_fignore
== 0)
2854 oldnames
[oidx
++] = names
[idx
];
2859 newnames
[nidx
] = (char *)NULL
;
2861 /* If none are acceptable then let the completer handle it. */
2867 names
[0] = (char *)NULL
;
2876 if (force_fignore
== 0)
2879 free (oldnames
[--oidx
]);
2883 /* If only one is acceptable, copy it to names[0] and return. */
2887 names
[0] = newnames
[1];
2888 names
[1] = (char *)NULL
;
2893 /* Copy the acceptable names back to NAMES, set the new array end,
2895 for (nidx
= 1; newnames
[nidx
]; nidx
++)
2896 names
[nidx
] = newnames
[nidx
];
2897 names
[nidx
] = (char *)NULL
;
2902 name_is_acceptable (name
)
2908 for (nlen
= strlen (name
), p
= fignore
.ignores
; p
->val
; p
++)
2910 if (nlen
> p
->len
&& p
->len
> 0 && STREQ (p
->val
, &name
[nlen
- p
->len
]))
2919 ignore_dot_names (name
)
2922 return (name
[0] != '.');
2927 filename_completion_ignore (names
)
2931 if (glob_dot_filenames
== 0)
2932 _ignore_completion_names (names
, ignore_dot_names
);
2935 setup_ignore_patterns (&fignore
);
2937 if (fignore
.num_ignores
== 0)
2940 _ignore_completion_names (names
, name_is_acceptable
);
2945 /* Return 1 if NAME is a directory. NAME undergoes tilde expansion. */
2947 test_for_directory (name
)
2953 fn
= bash_tilde_expand (name
, 0);
2954 r
= file_isdir (fn
);
2960 /* Remove files from NAMES, leaving directories. */
2962 bash_ignore_filenames (names
)
2965 _ignore_completion_names (names
, test_for_directory
);
2977 bash_ignore_everything (names
)
2980 _ignore_completion_names (names
, return_zero
);
2984 /* Replace a tilde-prefix in VAL with a `~', assuming the user typed it. VAL
2985 is an expanded filename. DIRECTORY_PART is the tilde-prefix portion
2986 of the un-tilde-expanded version of VAL (what the user typed). */
2988 restore_tilde (val
, directory_part
)
2989 char *val
, *directory_part
;
2992 char *dh2
, *expdir
, *ret
, *v
;
2996 /* We need to duplicate the expansions readline performs on the directory
2997 portion before passing it to our completion function. */
2998 dh2
= directory_part
? bash_dequote_filename (directory_part
, 0) : 0;
2999 bash_directory_expansion (&dh2
);
3002 expdir
= bash_tilde_expand (directory_part
, 0);
3003 xl
= strlen (expdir
);
3004 if (*directory_part
== '~' && STREQ (directory_part
, expdir
))
3006 /* tilde expansion failed, so what should we return? we use what the
3008 v
= mbschr (val
, '/');
3010 ret
= (char *)xmalloc (xl
+ vl
+ 2);
3011 strcpy (ret
, directory_part
);
3013 strcpy (ret
+ xl
, v
);
3023 dh2 = unexpanded but dequoted tilde-prefix
3024 dl2 = length of tilde-prefix
3025 expdir = tilde-expanded tilde-prefix
3026 xl = length of expanded tilde-prefix
3027 l = length of remainder after tilde-prefix
3033 return (savestring (val
)); /* XXX - just punt */
3036 ret
= (char *)xmalloc (dl2
+ 2 + l
);
3038 strcpy (ret
+ dl2
, val
+ xl
);
3045 maybe_restore_tilde (val
, directory_part
)
3046 char *val
, *directory_part
;
3048 rl_icppfunc_t
*save
;
3051 save
= (dircomplete_expand
== 0) ? save_directory_hook () : (rl_icppfunc_t
*)0;
3052 ret
= restore_tilde (val
, directory_part
);
3054 restore_directory_hook (save
);
3058 /* Simulate the expansions that will be performed by
3059 rl_filename_completion_function. This must be called with the address of
3060 a pointer to malloc'd memory. */
3062 bash_directory_expansion (dirname
)
3067 d
= savestring (*dirname
);
3069 if ((rl_directory_rewrite_hook
) && (*rl_directory_rewrite_hook
) (&d
))
3074 else if (rl_directory_completion_hook
&& (*rl_directory_completion_hook
) (&d
))
3079 else if (rl_completion_found_quote
)
3081 nd
= bash_dequote_filename (d
, rl_completion_quote_character
);
3088 /* If necessary, rewrite directory entry */
3090 bash_filename_rewrite_hook (fname
, fnlen
)
3096 conv
= fnx_fromfs (fname
, fnlen
);
3098 conv
= savestring (conv
);
3102 /* Functions to save and restore the appropriate directory hook */
3103 /* This is not static so the shopt code can call it */
3105 set_directory_hook ()
3107 if (dircomplete_expand
)
3109 rl_directory_completion_hook
= bash_directory_completion_hook
;
3110 rl_directory_rewrite_hook
= (rl_icppfunc_t
*)0;
3114 rl_directory_rewrite_hook
= bash_directory_completion_hook
;
3115 rl_directory_completion_hook
= (rl_icppfunc_t
*)0;
3119 static rl_icppfunc_t
*
3120 save_directory_hook ()
3124 if (dircomplete_expand
)
3126 ret
= rl_directory_completion_hook
;
3127 rl_directory_completion_hook
= (rl_icppfunc_t
*)NULL
;
3131 ret
= rl_directory_rewrite_hook
;
3132 rl_directory_rewrite_hook
= (rl_icppfunc_t
*)NULL
;
3139 restore_directory_hook (hookf
)
3140 rl_icppfunc_t
*hookf
;
3142 if (dircomplete_expand
)
3143 rl_directory_completion_hook
= hookf
;
3145 rl_directory_rewrite_hook
= hookf
;
3148 /* Check whether not DIRNAME, with any trailing slash removed, exists. If
3149 SHOULD_DEQUOTE is non-zero, we dequote the directory name first. */
3151 directory_exists (dirname
, should_dequote
)
3152 const char *dirname
;
3159 /* We save the string and chop the trailing slash because stat/lstat behave
3160 inconsistently if one is present. */
3161 new_dirname
= should_dequote
? bash_dequote_filename ((char *)dirname
, rl_completion_quote_character
) : savestring (dirname
);
3162 dirlen
= STRLEN (new_dirname
);
3163 if (new_dirname
[dirlen
- 1] == '/')
3164 new_dirname
[dirlen
- 1] = '\0';
3165 #if defined (HAVE_LSTAT)
3166 r
= lstat (new_dirname
, &sb
) == 0;
3168 r
= stat (new_dirname
, &sb
) == 0;
3174 /* Expand a filename before the readline completion code passes it to stat(2).
3175 The filename will already have had tilde expansion performed. */
3177 bash_filename_stat_hook (dirname
)
3180 char *local_dirname
, *new_dirname
, *t
;
3181 int should_expand_dirname
, return_value
;
3185 local_dirname
= *dirname
;
3186 should_expand_dirname
= return_value
= 0;
3187 if (t
= mbschr (local_dirname
, '$'))
3188 should_expand_dirname
= '$';
3189 else if (t
= mbschr (local_dirname
, '`')) /* XXX */
3190 should_expand_dirname
= '`';
3192 if (should_expand_dirname
&& directory_exists (local_dirname
, 0))
3193 should_expand_dirname
= 0;
3195 if (should_expand_dirname
)
3197 new_dirname
= savestring (local_dirname
);
3198 /* no error messages, and expand_prompt_string doesn't longjmp so we don't
3199 have to worry about restoring this setting. */
3200 global_nounset
= unbound_vars_is_error
;
3201 unbound_vars_is_error
= 0;
3202 wl
= expand_prompt_string (new_dirname
, 0, W_NOCOMSUB
|W_NOPROCSUB
|W_COMPLETE
); /* does the right thing */
3203 unbound_vars_is_error
= global_nounset
;
3207 new_dirname
= string_list (wl
);
3208 /* Tell the completer we actually expanded something and change
3209 *dirname only if we expanded to something non-null -- stat
3210 behaves unpredictably when passed null or empty strings */
3211 if (new_dirname
&& *new_dirname
)
3213 free (local_dirname
); /* XXX */
3214 local_dirname
= *dirname
= new_dirname
;
3215 return_value
= STREQ (local_dirname
, *dirname
) == 0;
3225 /* This is very similar to the code in bash_directory_completion_hook below,
3226 but without spelling correction and not worrying about whether or not
3227 we change relative pathnames. */
3228 if (no_symbolic_links
== 0 && (local_dirname
[0] != '.' || local_dirname
[1]))
3230 char *temp1
, *temp2
;
3232 t
= get_working_directory ("symlink-hook");
3233 temp1
= make_absolute (local_dirname
, t
);
3235 temp2
= sh_canonpath (temp1
, PATH_CHECKDOTDOT
|PATH_CHECKEXISTS
);
3237 /* If we can't canonicalize, bail. */
3241 return return_value
;
3244 free (local_dirname
);
3249 return (return_value
);
3252 /* Handle symbolic link references and other directory name
3253 expansions while hacking completion. This should return 1 if it modifies
3254 the DIRNAME argument, 0 otherwise. It should make sure not to modify
3255 DIRNAME if it returns 0. */
3257 bash_directory_completion_hook (dirname
)
3260 char *local_dirname
, *new_dirname
, *t
;
3261 int return_value
, should_expand_dirname
, nextch
, closer
;
3264 return_value
= should_expand_dirname
= nextch
= closer
= 0;
3265 local_dirname
= *dirname
;
3267 if (t
= mbschr (local_dirname
, '$'))
3269 should_expand_dirname
= '$';
3271 /* Deliberately does not handle the deprecated $[...] arithmetic
3275 else if (nextch
== '{')
3285 delims
[0] = closer
; delims
[1] = 0;
3286 p
= skip_to_delim (t
, 1, delims
, SD_NOJMP
|SD_COMPLETE
);
3288 should_expand_dirname
= 0;
3291 else if (local_dirname
[0] == '~')
3292 should_expand_dirname
= '~';
3295 t
= mbschr (local_dirname
, '`');
3296 if (t
&& unclosed_pair (local_dirname
, strlen (local_dirname
), "`") == 0)
3297 should_expand_dirname
= '`';
3300 if (should_expand_dirname
&& directory_exists (local_dirname
, 1))
3301 should_expand_dirname
= 0;
3303 if (should_expand_dirname
)
3305 new_dirname
= savestring (local_dirname
);
3306 wl
= expand_prompt_string (new_dirname
, 0, W_NOCOMSUB
|W_NOPROCSUB
|W_COMPLETE
); /* does the right thing */
3309 *dirname
= string_list (wl
);
3310 /* Tell the completer to replace the directory name only if we
3311 actually expanded something. */
3312 return_value
= STREQ (local_dirname
, *dirname
) == 0;
3313 free (local_dirname
);
3316 local_dirname
= *dirname
;
3317 /* XXX - change rl_filename_quote_characters here based on
3318 should_expand_dirname/nextch/closer. This is the only place
3319 custom_filename_quote_characters is modified. */
3320 if (rl_filename_quote_characters
&& *rl_filename_quote_characters
)
3323 i
= strlen (default_filename_quote_characters
);
3324 custom_filename_quote_characters
= xrealloc (custom_filename_quote_characters
, i
+1);
3325 for (i
= j
= 0; c
= default_filename_quote_characters
[i
]; i
++)
3327 if (c
== should_expand_dirname
|| c
== nextch
|| c
== closer
)
3329 custom_filename_quote_characters
[j
++] = c
;
3331 custom_filename_quote_characters
[j
] = '\0';
3332 rl_filename_quote_characters
= custom_filename_quote_characters
;
3333 set_filename_bstab (rl_filename_quote_characters
);
3339 free (local_dirname
);
3340 *dirname
= (char *)xmalloc (1);
3347 /* Dequote the filename even if we don't expand it. */
3348 new_dirname
= bash_dequote_filename (local_dirname
, rl_completion_quote_character
);
3349 return_value
= STREQ (local_dirname
, new_dirname
) == 0;
3350 free (local_dirname
);
3351 local_dirname
= *dirname
= new_dirname
;
3354 /* no_symbolic_links == 0 -> use (default) logical view of the file system.
3355 local_dirname[0] == '.' && local_dirname[1] == '/' means files in the
3356 current directory (./).
3357 local_dirname[0] == '.' && local_dirname[1] == 0 means relative pathnames
3358 in the current directory (e.g., lib/sh).
3359 XXX - should we do spelling correction on these? */
3361 /* This is test as it was in bash-4.2: skip relative pathnames in current
3362 directory. Change test to
3363 (local_dirname[0] != '.' || (local_dirname[1] && local_dirname[1] != '/'))
3364 if we want to skip paths beginning with ./ also. */
3365 if (no_symbolic_links
== 0 && (local_dirname
[0] != '.' || local_dirname
[1]))
3367 char *temp1
, *temp2
;
3370 /* If we have a relative path
3371 (local_dirname[0] != '/' && local_dirname[0] != '.')
3372 that is canonical after appending it to the current directory, then
3375 strcmp (temp1, temp2) == 0
3376 after adding a slash to temp2 below. It should be safe to not
3379 t
= get_working_directory ("symlink-hook");
3380 temp1
= make_absolute (local_dirname
, t
);
3382 temp2
= sh_canonpath (temp1
, PATH_CHECKDOTDOT
|PATH_CHECKEXISTS
);
3384 /* Try spelling correction if initial canonicalization fails. Make
3385 sure we are set to replace the directory name with the results so
3386 subsequent directory checks don't fail. */
3387 if (temp2
== 0 && dircomplete_spelling
&& dircomplete_expand
)
3389 temp2
= dirspell (temp1
);
3394 temp2
= sh_canonpath (temp1
, PATH_CHECKDOTDOT
|PATH_CHECKEXISTS
);
3395 return_value
|= temp2
!= 0;
3398 /* If we can't canonicalize, bail. */
3402 return return_value
;
3404 len1
= strlen (temp1
);
3405 if (temp1
[len1
- 1] == '/')
3407 len2
= strlen (temp2
);
3408 if (len2
> 2) /* don't append `/' to `/' or `//' */
3410 temp2
= (char *)xrealloc (temp2
, len2
+ 2);
3412 temp2
[len2
+ 1] = '\0';
3416 /* dircomplete_expand_relpath == 0 means we want to leave relative
3417 pathnames that are unchanged by canonicalization alone.
3418 *local_dirname != '/' && *local_dirname != '.' == relative pathname
3419 (consistent with general.c:absolute_pathname())
3420 temp1 == temp2 (after appending a slash to temp2) means the pathname
3421 is not changed by canonicalization as described above. */
3422 if (dircomplete_expand_relpath
|| ((local_dirname
[0] != '/' && local_dirname
[0] != '.') && STREQ (temp1
, temp2
) == 0))
3423 return_value
|= STREQ (local_dirname
, temp2
) == 0;
3424 free (local_dirname
);
3429 return (return_value
);
3432 static char **history_completion_array
= (char **)NULL
;
3433 static int harry_size
;
3434 static int harry_len
;
3437 build_history_completion_array ()
3443 /* First, clear out the current dynamic history completion list. */
3446 strvec_dispose (history_completion_array
);
3447 history_completion_array
= (char **)NULL
;
3452 /* Next, grovel each line of history, making each shell-sized token
3453 a separate entry in the history_completion_array. */
3454 hlist
= history_list ();
3458 for (i
= 0; hlist
[i
]; i
++)
3460 for ( --i
; i
>= 0; i
--)
3462 /* Separate each token, and place into an array. */
3463 tokens
= history_tokenize (hlist
[i
]->line
);
3465 for (j
= 0; tokens
&& tokens
[j
]; j
++)
3467 if (harry_len
+ 2 > harry_size
)
3468 history_completion_array
= strvec_resize (history_completion_array
, harry_size
+= 10);
3470 history_completion_array
[harry_len
++] = tokens
[j
];
3471 history_completion_array
[harry_len
] = (char *)NULL
;
3476 /* Sort the complete list of tokens. */
3477 if (dabbrev_expand_active
== 0)
3478 qsort (history_completion_array
, harry_len
, sizeof (char *), (QSFUNC
*)strvec_strcmp
);
3483 history_completion_generator (hint_text
, state
)
3484 const char *hint_text
;
3487 static int local_index
, len
;
3488 static const char *text
;
3490 /* If this is the first call to the generator, then initialize the
3491 list of strings to complete over. */
3494 if (dabbrev_expand_active
) /* This is kind of messy */
3495 rl_completion_suppress_append
= 1;
3497 build_history_completion_array ();
3499 len
= strlen (text
);
3502 while (history_completion_array
&& history_completion_array
[local_index
])
3504 /* XXX - should this use completion-ignore-case? */
3505 if (strncmp (text
, history_completion_array
[local_index
++], len
) == 0)
3506 return (savestring (history_completion_array
[local_index
- 1]));
3508 return ((char *)NULL
);
3512 dynamic_complete_history (count
, key
)
3516 rl_compentry_func_t
*orig_func
;
3517 rl_completion_func_t
*orig_attempt_func
;
3518 rl_compignore_func_t
*orig_ignore_func
;
3520 orig_func
= rl_completion_entry_function
;
3521 orig_attempt_func
= rl_attempted_completion_function
;
3522 orig_ignore_func
= rl_ignore_some_completions_function
;
3524 rl_completion_entry_function
= history_completion_generator
;
3525 rl_attempted_completion_function
= (rl_completion_func_t
*)NULL
;
3526 rl_ignore_some_completions_function
= filename_completion_ignore
;
3528 /* XXX - use rl_completion_mode here? */
3529 if (rl_last_func
== dynamic_complete_history
)
3530 r
= rl_complete_internal ('?');
3532 r
= rl_complete_internal (TAB
);
3534 rl_completion_entry_function
= orig_func
;
3535 rl_attempted_completion_function
= orig_attempt_func
;
3536 rl_ignore_some_completions_function
= orig_ignore_func
;
3542 bash_dabbrev_expand (count
, key
)
3545 int r
, orig_suppress
, orig_sort
;
3546 rl_compentry_func_t
*orig_func
;
3547 rl_completion_func_t
*orig_attempt_func
;
3548 rl_compignore_func_t
*orig_ignore_func
;
3550 orig_func
= rl_menu_completion_entry_function
;
3551 orig_attempt_func
= rl_attempted_completion_function
;
3552 orig_ignore_func
= rl_ignore_some_completions_function
;
3553 orig_suppress
= rl_completion_suppress_append
;
3554 orig_sort
= rl_sort_completion_matches
;
3556 rl_menu_completion_entry_function
= history_completion_generator
;
3557 rl_attempted_completion_function
= (rl_completion_func_t
*)NULL
;
3558 rl_ignore_some_completions_function
= filename_completion_ignore
;
3559 rl_filename_completion_desired
= 0;
3560 rl_completion_suppress_append
= 1;
3561 rl_sort_completion_matches
= 0;
3563 /* XXX - use rl_completion_mode here? */
3564 dabbrev_expand_active
= 1;
3565 if (rl_last_func
== bash_dabbrev_expand
)
3566 rl_last_func
= rl_menu_complete
;
3567 r
= rl_menu_complete (count
, key
);
3568 dabbrev_expand_active
= 0;
3570 rl_last_func
= bash_dabbrev_expand
;
3571 rl_menu_completion_entry_function
= orig_func
;
3572 rl_attempted_completion_function
= orig_attempt_func
;
3573 rl_ignore_some_completions_function
= orig_ignore_func
;
3574 rl_completion_suppress_append
= orig_suppress
;
3575 rl_sort_completion_matches
= orig_sort
;
3580 #if defined (SPECIFIC_COMPLETION_FUNCTIONS)
3582 bash_complete_username (ignore
, ignore2
)
3583 int ignore
, ignore2
;
3585 return bash_complete_username_internal (rl_completion_mode (bash_complete_username
));
3589 bash_possible_username_completions (ignore
, ignore2
)
3590 int ignore
, ignore2
;
3592 return bash_complete_username_internal ('?');
3596 bash_complete_username_internal (what_to_do
)
3599 return bash_specific_completion (what_to_do
, rl_username_completion_function
);
3603 bash_complete_filename (ignore
, ignore2
)
3604 int ignore
, ignore2
;
3606 return bash_complete_filename_internal (rl_completion_mode (bash_complete_filename
));
3610 bash_possible_filename_completions (ignore
, ignore2
)
3611 int ignore
, ignore2
;
3613 return bash_complete_filename_internal ('?');
3617 bash_complete_filename_internal (what_to_do
)
3620 rl_compentry_func_t
*orig_func
;
3621 rl_completion_func_t
*orig_attempt_func
;
3622 rl_icppfunc_t
*orig_dir_func
;
3623 rl_compignore_func_t
*orig_ignore_func
;
3624 /*const*/ char *orig_rl_completer_word_break_characters
;
3627 orig_func
= rl_completion_entry_function
;
3628 orig_attempt_func
= rl_attempted_completion_function
;
3629 orig_ignore_func
= rl_ignore_some_completions_function
;
3630 orig_rl_completer_word_break_characters
= rl_completer_word_break_characters
;
3632 orig_dir_func
= save_directory_hook ();
3634 rl_completion_entry_function
= rl_filename_completion_function
;
3635 rl_attempted_completion_function
= (rl_completion_func_t
*)NULL
;
3636 rl_ignore_some_completions_function
= filename_completion_ignore
;
3637 rl_completer_word_break_characters
= " \t\n\"\'";
3639 r
= rl_complete_internal (what_to_do
);
3641 rl_completion_entry_function
= orig_func
;
3642 rl_attempted_completion_function
= orig_attempt_func
;
3643 rl_ignore_some_completions_function
= orig_ignore_func
;
3644 rl_completer_word_break_characters
= orig_rl_completer_word_break_characters
;
3646 restore_directory_hook (orig_dir_func
);
3652 bash_complete_hostname (ignore
, ignore2
)
3653 int ignore
, ignore2
;
3655 return bash_complete_hostname_internal (rl_completion_mode (bash_complete_hostname
));
3659 bash_possible_hostname_completions (ignore
, ignore2
)
3660 int ignore
, ignore2
;
3662 return bash_complete_hostname_internal ('?');
3666 bash_complete_variable (ignore
, ignore2
)
3667 int ignore
, ignore2
;
3669 return bash_complete_variable_internal (rl_completion_mode (bash_complete_variable
));
3673 bash_possible_variable_completions (ignore
, ignore2
)
3674 int ignore
, ignore2
;
3676 return bash_complete_variable_internal ('?');
3680 bash_complete_command (ignore
, ignore2
)
3681 int ignore
, ignore2
;
3683 return bash_complete_command_internal (rl_completion_mode (bash_complete_command
));
3687 bash_possible_command_completions (ignore
, ignore2
)
3688 int ignore
, ignore2
;
3690 return bash_complete_command_internal ('?');
3694 bash_complete_hostname_internal (what_to_do
)
3697 return bash_specific_completion (what_to_do
, hostname_completion_function
);
3701 bash_complete_variable_internal (what_to_do
)
3704 return bash_specific_completion (what_to_do
, variable_completion_function
);
3708 bash_complete_command_internal (what_to_do
)
3711 return bash_specific_completion (what_to_do
, command_word_completion_function
);
3715 completion_glob_pattern (string
)
3725 send
= string
+ strlen (string
);
3727 while (c
= *string
++)
3747 if (*string
== '(') /*)*/
3756 /* Advance one fewer byte than an entire multibyte character to
3757 account for the auto-increment in the loop above. */
3758 #ifdef HANDLE_MULTIBYTE
3760 ADVANCE_CHAR_P (string
, send
- string
);
3763 ADVANCE_CHAR_P (string
, send
- string
);
3769 static char *globtext
;
3770 static char *globorig
;
3773 glob_complete_word (text
, state
)
3777 static char **matches
= (char **)NULL
;
3784 rl_filename_completion_desired
= 1;
3786 if (globorig
!= globtext
)
3790 ttext
= bash_tilde_expand (text
, 0);
3792 if (rl_explicit_arg
)
3794 globorig
= savestring (ttext
);
3795 glen
= strlen (ttext
);
3796 globtext
= (char *)xmalloc (glen
+ 2);
3797 strcpy (globtext
, ttext
);
3798 globtext
[glen
] = '*';
3799 globtext
[glen
+1] = '\0';
3802 globtext
= globorig
= savestring (ttext
);
3807 matches
= shell_glob_filename (globtext
);
3808 if (GLOB_FAILED (matches
))
3809 matches
= (char **)NULL
;
3813 ret
= matches
? matches
[ind
] : (char *)NULL
;
3819 bash_glob_completion_internal (what_to_do
)
3822 return bash_specific_completion (what_to_do
, glob_complete_word
);
3825 /* A special quoting function so we don't end up quoting globbing characters
3826 in the word if there are no matches or multiple matches. */
3828 bash_glob_quote_filename (s
, rtype
, qcp
)
3833 if (globorig
&& qcp
&& *qcp
== '\0' && STREQ (s
, globorig
))
3834 return (savestring (s
));
3836 return (bash_quote_filename (s
, rtype
, qcp
));
3840 bash_glob_complete_word (count
, key
)
3844 rl_quote_func_t
*orig_quoting_function
;
3846 if (rl_editing_mode
== EMACS_EDITING_MODE
)
3847 rl_explicit_arg
= 1; /* force `*' append */
3848 orig_quoting_function
= rl_filename_quoting_function
;
3849 rl_filename_quoting_function
= bash_glob_quote_filename
;
3851 r
= bash_glob_completion_internal (rl_completion_mode (bash_glob_complete_word
));
3853 rl_filename_quoting_function
= orig_quoting_function
;
3858 bash_glob_expand_word (count
, key
)
3861 return bash_glob_completion_internal ('*');
3865 bash_glob_list_expansions (count
, key
)
3868 return bash_glob_completion_internal ('?');
3872 bash_specific_completion (what_to_do
, generator
)
3874 rl_compentry_func_t
*generator
;
3876 rl_compentry_func_t
*orig_func
;
3877 rl_completion_func_t
*orig_attempt_func
;
3878 rl_compignore_func_t
*orig_ignore_func
;
3881 orig_func
= rl_completion_entry_function
;
3882 orig_attempt_func
= rl_attempted_completion_function
;
3883 orig_ignore_func
= rl_ignore_some_completions_function
;
3884 rl_completion_entry_function
= generator
;
3885 rl_attempted_completion_function
= NULL
;
3886 rl_ignore_some_completions_function
= orig_ignore_func
;
3888 r
= rl_complete_internal (what_to_do
);
3890 rl_completion_entry_function
= orig_func
;
3891 rl_attempted_completion_function
= orig_attempt_func
;
3892 rl_ignore_some_completions_function
= orig_ignore_func
;
3897 #endif /* SPECIFIC_COMPLETION_FUNCTIONS */
3899 #if defined (VI_MODE)
3900 /* Completion, from vi mode's point of view. This is a modified version of
3901 rl_vi_complete which uses the bash globbing code to implement what POSIX
3902 specifies, which is to append a `*' and attempt filename generation (which
3903 has the side effect of expanding any globbing characters in the word). */
3905 bash_vi_complete (count
, key
)
3908 #if defined (SPECIFIC_COMPLETION_FUNCTIONS)
3912 if ((rl_point
< rl_end
) && (!whitespace (rl_line_buffer
[rl_point
])))
3914 if (!whitespace (rl_line_buffer
[rl_point
+ 1]))
3915 rl_vi_end_word (1, 'E');
3919 /* Find boundaries of current word, according to vi definition of a
3925 rl_vi_bWord (1, 'B');
3930 t
= substring (rl_line_buffer
, p
, rl_point
);
3933 if (t
&& completion_glob_pattern (t
) == 0)
3934 rl_explicit_arg
= 1; /* XXX - force glob_complete_word to append `*' */
3937 if (key
== '*') /* Expansion and replacement. */
3938 r
= bash_glob_expand_word (count
, key
);
3939 else if (key
== '=') /* List possible completions. */
3940 r
= bash_glob_list_expansions (count
, key
);
3941 else if (key
== '\\') /* Standard completion */
3942 r
= bash_glob_complete_word (count
, key
);
3944 r
= rl_complete (0, key
);
3946 if (key
== '*' || key
== '\\')
3947 rl_vi_start_inserting (key
, 1, 1);
3951 return rl_vi_complete (count
, key
);
3952 #endif /* !SPECIFIC_COMPLETION_FUNCTIONS */
3954 #endif /* VI_MODE */
3956 /* Filename quoting for completion. */
3957 /* A function to strip unquoted quote characters (single quotes, double
3958 quotes, and backslashes). It allows single quotes to appear
3959 within double quotes, and vice versa. It should be smarter. */
3961 bash_dequote_filename (text
, quote_char
)
3969 ret
= (char *)xmalloc (l
+ 1);
3970 for (quoted
= quote_char
, p
= text
, r
= ret
; p
&& *p
; p
++)
3972 /* Allow backslash-escaped characters to pass through unscathed. */
3975 /* Backslashes are preserved within single quotes. */
3978 /* Backslashes are preserved within double quotes unless the
3979 character is one that is defined to be escaped */
3980 else if (quoted
== '"' && ((sh_syntaxtab
[(unsigned char)p
[1]] & CBSDQUOTE
) == 0))
3985 return ret
; /* XXX - was break; */
3989 if (quoted
&& *p
== quoted
)
3995 if (quoted
== 0 && (*p
== '\'' || *p
== '"'))
4006 /* Quote characters that the readline completion code would treat as
4007 word break characters with backslashes. Pass backslash-quoted
4008 characters through without examination. */
4010 quote_word_break_chars (text
)
4017 ret
= (char *)xmalloc ((2 * l
) + 1);
4018 for (s
= text
, r
= ret
; *s
; s
++)
4020 /* Pass backslash-quoted characters through, including the backslash. */
4029 /* OK, we have an unquoted character. Check its presence in
4030 rl_completer_word_break_characters. */
4031 if (mbschr (rl_completer_word_break_characters
, *s
))
4033 /* XXX -- check for standalone tildes here and backslash-quote them */
4034 if (s
== text
&& *s
== '~' && file_exists (text
))
4042 /* Use characters in STRING to populate the table of characters that should
4043 be backslash-quoted. The table will be used for sh_backslash_quote from
4046 set_filename_bstab (string
)
4051 memset (filename_bstab
, 0, sizeof (filename_bstab
));
4052 for (s
= string
; s
&& *s
; s
++)
4053 filename_bstab
[*s
] = 1;
4056 /* Quote a filename using double quotes, single quotes, or backslashes
4057 depending on the value of completion_quoting_style. If we're
4058 completing using backslashes, we need to quote some additional
4059 characters (those that readline treats as word breaks), so we call
4060 quote_word_break_chars on the result. This returns newly-allocated
4063 bash_quote_filename (s
, rtype
, qcp
)
4068 char *rtext
, *mtext
, *ret
;
4071 rtext
= (char *)NULL
;
4073 /* If RTYPE == MULT_MATCH, it means that there is
4074 more than one match. In this case, we do not add
4075 the closing quote or attempt to perform tilde
4076 expansion. If RTYPE == SINGLE_MATCH, we try
4077 to perform tilde expansion, because single and double
4078 quotes inhibit tilde expansion by the shell. */
4080 cs
= completion_quoting_style
;
4081 /* Might need to modify the default completion style based on *qcp,
4082 since it's set to any user-provided opening quote. We also change
4083 to single-quoting if there is no user-provided opening quote and
4084 the word being completed contains newlines, since those are not
4085 quoted correctly using backslashes (a backslash-newline pair is
4086 special to the shell parser). */
4087 if (*qcp
== '\0' && cs
== COMPLETE_BSQUOTE
&& mbschr (s
, '\n'))
4088 cs
= COMPLETE_SQUOTE
;
4089 else if (*qcp
== '"')
4090 cs
= COMPLETE_DQUOTE
;
4091 else if (*qcp
== '\'')
4092 cs
= COMPLETE_SQUOTE
;
4093 #if defined (BANG_HISTORY)
4094 else if (*qcp
== '\0' && history_expansion
&& cs
== COMPLETE_DQUOTE
&&
4095 history_expansion_inhibited
== 0 && mbschr (s
, '!'))
4096 cs
= COMPLETE_BSQUOTE
;
4098 if (*qcp
== '"' && history_expansion
&& cs
== COMPLETE_DQUOTE
&&
4099 history_expansion_inhibited
== 0 && mbschr (s
, '!'))
4101 cs
= COMPLETE_BSQUOTE
;
4106 /* Don't tilde-expand backslash-quoted filenames, since only single and
4107 double quotes inhibit tilde expansion. */
4109 if (mtext
[0] == '~' && rtype
== SINGLE_MATCH
&& cs
!= COMPLETE_BSQUOTE
)
4110 mtext
= bash_tilde_expand (s
, 0);
4114 case COMPLETE_DQUOTE
:
4115 rtext
= sh_double_quote (mtext
);
4117 case COMPLETE_SQUOTE
:
4118 rtext
= sh_single_quote (mtext
);
4120 case COMPLETE_BSQUOTE
:
4121 rtext
= sh_backslash_quote (mtext
, complete_fullquote
? 0 : filename_bstab
, 0);
4128 /* We may need to quote additional characters: those that readline treats
4129 as word breaks that are not quoted by backslash_quote. */
4130 if (rtext
&& cs
== COMPLETE_BSQUOTE
)
4132 mtext
= quote_word_break_chars (rtext
);
4137 /* Leave the opening quote intact. The readline completion code takes
4138 care of avoiding doubled opening quotes. */
4141 rlen
= strlen (rtext
);
4142 ret
= (char *)xmalloc (rlen
+ 1);
4143 strcpy (ret
, rtext
);
4147 ret
= (char *)xmalloc (rlen
= 1);
4151 /* If there are multiple matches, cut off the closing quote. */
4152 if (rtype
== MULT_MATCH
&& cs
!= COMPLETE_BSQUOTE
)
4153 ret
[rlen
- 1] = '\0';
4158 /* Support for binding readline key sequences to Unix commands. */
4159 static Keymap cmd_xmap
;
4170 x
= putc (c
, rl_outstream
);
4177 bash_execute_unix_command (count
, key
)
4178 int count
; /* ignored */
4184 sh_parser_state_t ps
;
4185 char *cmd
, *value
, *ce
, old_ch
;
4187 char ibuf
[INT_STRLEN_BOUND(int) + 1];
4189 /* First, we need to find the right command to execute. This is tricky,
4190 because we might have already indirected into another keymap, so we
4191 have to walk cmd_xmap using the entire key sequence. */
4192 cmd
= (char *)rl_function_of_keyseq_len (rl_executing_keyseq
, rl_key_sequence_length
, cmd_xmap
, &type
);
4194 if (cmd
== 0 || type
!= ISMACR
)
4197 internal_error (_("bash_execute_unix_command: cannot find keymap for command"));
4198 rl_forced_update_display ();
4202 ce
= rl_get_termcap ("ce");
4203 if (ce
) /* clear current line */
4206 fprintf (rl_outstream
, "\r");
4207 tputs (ce
, 1, putx
);
4209 rl_clear_visible_line ();
4211 fflush (rl_outstream
);
4214 rl_crlf (); /* move to a new line */
4216 v
= bind_variable ("READLINE_LINE", rl_line_buffer
, 0);
4218 VSETATTR (v
, att_exported
);
4220 #if defined (HANDLE_MULTIBYTE)
4223 old_ch
= rl_line_buffer
[rl_point
];
4224 rl_line_buffer
[rl_point
] = '\0';
4225 i
= MB_STRLEN (rl_line_buffer
);
4226 rl_line_buffer
[rl_point
] = old_ch
;
4229 value
= inttostr (i
, ibuf
, sizeof (ibuf
));
4230 v
= bind_int_variable ("READLINE_POINT", value
, 0);
4232 VSETATTR (v
, att_exported
);
4233 array_needs_making
= 1;
4235 save_parser_state (&ps
);
4236 r
= parse_and_execute (savestring (cmd
), "bash_execute_unix_command", SEVAL_NOHIST
|SEVAL_NOFREE
);
4237 restore_parser_state (&ps
);
4239 v
= find_variable ("READLINE_LINE");
4240 maybe_make_readline_line (v
? value_cell (v
) : 0);
4242 v
= find_variable ("READLINE_POINT");
4243 if (v
&& legal_number (value_cell (v
), &mi
))
4246 #if defined (HANDLE_MULTIBYTE)
4247 if (i
> 0 && MB_CUR_MAX
> 1)
4248 i
= _rl_find_next_mbchar (rl_line_buffer
, 0, i
, 0);
4253 if (rl_point
> rl_end
)
4255 else if (rl_point
< 0)
4260 check_unbind_variable ("READLINE_LINE");
4261 check_unbind_variable ("READLINE_POINT");
4262 array_needs_making
= 1;
4264 /* and restore the readline buffer and display after command execution. */
4265 /* If we clear the last line of the prompt above, redraw only that last
4266 line. If the command returns 124, we redraw unconditionally as in
4267 previous versions. */
4269 rl_redraw_prompt_last_line ();
4271 rl_forced_update_display ();
4277 print_unix_command_map ()
4281 save
= rl_get_keymap ();
4282 rl_set_keymap (cmd_xmap
);
4283 rl_macro_dumper (1);
4284 rl_set_keymap (save
);
4289 init_unix_command_map ()
4291 cmd_xmap
= rl_make_bare_keymap ();
4295 isolate_sequence (string
, ind
, need_dquote
, startp
)
4297 int ind
, need_dquote
, *startp
;
4300 int c
, passc
, delim
;
4302 for (i
= ind
; string
[i
] && whitespace (string
[i
]); i
++)
4304 /* NEED_DQUOTE means that the first non-white character *must* be `"'. */
4305 if (need_dquote
&& string
[i
] != '"')
4307 builtin_error (_("%s: first non-whitespace character is not `\"'"), string
);
4311 /* We can have delimited strings even if NEED_DQUOTE == 0, like the command
4312 string to bind the key sequence to. */
4313 delim
= (string
[i
] == '"' || string
[i
] == '\'') ? string
[i
] : 0;
4316 *startp
= delim
? ++i
: i
;
4318 for (passc
= 0; c
= string
[i
]; i
++)
4334 if (delim
&& string
[i
] != delim
)
4336 builtin_error (_("no closing `%c' in %s"), delim
, string
);
4344 bind_keyseq_to_unix_command (line
)
4352 init_unix_command_map ();
4354 kmap
= rl_get_keymap ();
4356 /* We duplicate some of the work done by rl_parse_and_bind here, but
4357 this code only has to handle `"keyseq": ["]command["]' and can
4358 generate an error for anything else. */
4359 i
= isolate_sequence (line
, 0, 1, &kstart
);
4363 /* Create the key sequence string to pass to rl_generic_bind */
4364 kseq
= substring (line
, kstart
, i
);
4366 for ( ; line
[i
] && line
[i
] != ':'; i
++)
4370 builtin_error (_("%s: missing colon separator"), line
);
4375 i
= isolate_sequence (line
, i
+ 1, 0, &kstart
);
4382 /* Create the value string containing the command to execute. */
4383 value
= substring (line
, kstart
, i
);
4385 /* Save the command to execute and the key sequence in the CMD_XMAP */
4386 rl_generic_bind (ISMACR
, kseq
, value
, cmd_xmap
);
4388 /* and bind the key sequence in the current keymap to a function that
4389 understands how to execute from CMD_XMAP */
4390 rl_bind_keyseq_in_map (kseq
, bash_execute_unix_command
, kmap
);
4396 /* Used by the programmable completion code. Complete TEXT as a filename,
4397 but return only directories as matches. Dequotes the filename before
4398 attempting to find matches. */
4400 bash_directory_completion_matches (text
)
4407 qc
= rl_dispatching
? rl_completion_quote_character
: 0;
4408 /* If rl_completion_found_quote != 0, rl_completion_matches will call the
4409 filename dequoting function, causing the directory name to be dequoted
4411 if (rl_dispatching
&& rl_completion_found_quote
== 0)
4412 dfn
= bash_dequote_filename ((char *)text
, qc
);
4415 m1
= rl_completion_matches (dfn
, rl_filename_completion_function
);
4419 if (m1
== 0 || m1
[0] == 0)
4421 /* We don't bother recomputing the lcd of the matches, because it will just
4422 get thrown away by the programmable completion code and recomputed
4424 (void)bash_ignore_filenames (m1
);
4429 bash_dequote_text (text
)
4435 qc
= (text
[0] == '"' || text
[0] == '\'') ? text
[0] : 0;
4436 dtxt
= bash_dequote_filename ((char *)text
, qc
);
4440 /* This event hook is designed to be called after readline receives a signal
4441 that interrupts read(2). It gives reasonable responsiveness to interrupts
4442 and fatal signals without executing too much code in a signal handler
4447 /* If we're going to longjmp to top_level, make sure we clean up readline.
4448 check_signals will call QUIT, which will eventually longjmp to top_level,
4449 calling run_interrupt_trap along the way. The check for sigalrm_seen is
4450 to clean up the read builtin's state. */
4451 if (terminating_signal
|| interrupt_state
|| sigalrm_seen
)
4452 rl_cleanup_after_signal ();
4453 bashline_reset_event_hook ();
4454 check_signals_and_traps (); /* XXX */
4458 #endif /* READLINE */