1 /* bashline.c -- Bash's interface to the readline library. */
3 /* Copyright (C) 1987-2013 Free Software Foundation, Inc.
5 This file is part of GNU Bash, the Bourne Again SHell.
7 Bash is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 Bash is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with Bash. If not, see <http://www.gnu.org/licenses/>.
23 #if defined (READLINE)
25 #include "bashtypes.h"
26 #include "posixstat.h"
28 #if defined (HAVE_UNISTD_H)
32 #if defined (HAVE_GRP_H)
36 #if defined (HAVE_NETDB_H)
43 #include "chartypes.h"
52 #include "execute_cmd.h"
58 #include "builtins/common.h"
60 #include <readline/rlconf.h>
61 #include <readline/readline.h>
62 #include <readline/history.h>
64 #include <glob/glob.h>
70 #if defined (PROGRAMMABLE_COMPLETION)
71 # include "pcomplete.h"
74 /* These should agree with the defines for emacs_mode and vi_mode in
75 rldefs.h, even though that's not a public readline header file. */
76 #ifndef EMACS_EDITING_MODE
77 # define NO_EDITING_MODE -1
78 # define EMACS_EDITING_MODE 1
79 # define VI_EDITING_MODE 0
82 #define RL_BOOLEAN_VARIABLE_VALUE(s) ((s)[0] == 'o' && (s)[1] == 'n' && (s)[2] == '\0')
84 #if defined (BRACE_COMPLETION)
85 extern int bash_brace_completion
__P((int, int));
86 #endif /* BRACE_COMPLETION */
88 /* To avoid including curses.h/term.h/termcap.h and that whole mess. */
90 extern int tputs
__P((const char *string
, int nlines
, void (*outx
)(int)));
92 extern int tputs
__P((const char *string
, int nlines
, int (*outx
)(int)));
95 /* Forward declarations */
97 /* Functions bound to keys in Readline for Bash users. */
98 static int shell_expand_line
__P((int, int));
99 static int display_shell_version
__P((int, int));
100 static int operate_and_get_next
__P((int, int));
102 static int bash_ignore_filenames
__P((char **));
103 static int bash_ignore_everything
__P((char **));
105 #if defined (BANG_HISTORY)
106 static char *history_expand_line_internal
__P((char *));
107 static int history_expand_line
__P((int, int));
108 static int tcsh_magic_space
__P((int, int));
109 #endif /* BANG_HISTORY */
111 static int alias_expand_line
__P((int, int));
113 #if defined (BANG_HISTORY) && defined (ALIAS)
114 static int history_and_alias_expand_line
__P((int, int));
117 static int bash_forward_shellword
__P((int, int));
118 static int bash_backward_shellword
__P((int, int));
119 static int bash_kill_shellword
__P((int, int));
120 static int bash_backward_kill_shellword
__P((int, int));
122 /* Helper functions for Readline. */
123 static char *restore_tilde
__P((char *, char *));
124 static char *maybe_restore_tilde
__P((char *, char *));
126 static char *bash_filename_rewrite_hook
__P((char *, int));
128 static void bash_directory_expansion
__P((char **));
129 static int bash_filename_stat_hook
__P((char **));
130 static int bash_command_name_stat_hook
__P((char **));
131 static int bash_directory_completion_hook
__P((char **));
132 static int filename_completion_ignore
__P((char **));
133 static int bash_push_line
__P((void));
135 static int executable_completion
__P((const char *, int));
137 static rl_icppfunc_t
*save_directory_hook
__P((void));
138 static void restore_directory_hook
__P((rl_icppfunc_t
));
140 static void cleanup_expansion_error
__P((void));
141 static void maybe_make_readline_line
__P((char *));
142 static void set_up_new_line
__P((char *));
144 static int check_redir
__P((int));
145 static char **attempt_shell_completion
__P((const char *, int, int));
146 static char *variable_completion_function
__P((const char *, int));
147 static char *hostname_completion_function
__P((const char *, int));
148 static char *command_subst_completion_function
__P((const char *, int));
150 static void build_history_completion_array
__P((void));
151 static char *history_completion_generator
__P((const char *, int));
152 static int dynamic_complete_history
__P((int, int));
153 static int bash_dabbrev_expand
__P((int, int));
155 static void initialize_hostname_list
__P((void));
156 static void add_host_name
__P((char *));
157 static void snarf_hosts_from_file
__P((char *));
158 static char **hostnames_matching
__P((char *));
160 static void _ignore_completion_names
__P((char **, sh_ignore_func_t
*));
161 static int name_is_acceptable
__P((const char *));
162 static int test_for_directory
__P((const char *));
163 static int return_zero
__P((const char *));
165 static char *bash_dequote_filename
__P((char *, int));
166 static char *quote_word_break_chars
__P((char *));
167 static void set_filename_bstab
__P((const char *));
168 static char *bash_quote_filename
__P((char *, int, char *));
171 static void putx
__P((int));
173 static int putx
__P((int));
175 static int bash_execute_unix_command
__P((int, int));
176 static void init_unix_command_map
__P((void));
177 static int isolate_sequence
__P((char *, int, int, int *));
179 static int set_saved_history
__P((void));
182 static int posix_edit_macros
__P((int, int));
185 static int bash_event_hook
__P((void));
187 #if defined (PROGRAMMABLE_COMPLETION)
188 static int find_cmd_start
__P((int));
189 static int find_cmd_end
__P((int));
190 static char *find_cmd_name
__P((int, int *, int *));
191 static char *prog_complete_return
__P((const char *, int));
193 static char **prog_complete_matches
;
196 /* Variables used here but defined in other files. */
197 #if defined (BANG_HISTORY)
198 extern int hist_verify
;
201 extern int current_command_line_count
, saved_command_line_count
;
202 extern int last_command_exit_value
;
203 extern int array_needs_making
;
204 extern int posixly_correct
, no_symbolic_links
;
205 extern char *current_prompt_string
, *ps1_prompt
;
206 extern STRING_INT_ALIST word_token_alist
[];
207 extern sh_builtin_func_t
*last_shell_builtin
, *this_shell_builtin
;
209 /* SPECIFIC_COMPLETION_FUNCTIONS specifies that we have individual
210 completion functions which indicate what type of completion should be
211 done (at or before point) that can be bound to key sequences with
212 the readline library. */
213 #define SPECIFIC_COMPLETION_FUNCTIONS
215 #if defined (SPECIFIC_COMPLETION_FUNCTIONS)
216 static int bash_specific_completion
__P((int, rl_compentry_func_t
*));
218 static int bash_complete_filename_internal
__P((int));
219 static int bash_complete_username_internal
__P((int));
220 static int bash_complete_hostname_internal
__P((int));
221 static int bash_complete_variable_internal
__P((int));
222 static int bash_complete_command_internal
__P((int));
224 static int bash_complete_filename
__P((int, int));
225 static int bash_possible_filename_completions
__P((int, int));
226 static int bash_complete_username
__P((int, int));
227 static int bash_possible_username_completions
__P((int, int));
228 static int bash_complete_hostname
__P((int, int));
229 static int bash_possible_hostname_completions
__P((int, int));
230 static int bash_complete_variable
__P((int, int));
231 static int bash_possible_variable_completions
__P((int, int));
232 static int bash_complete_command
__P((int, int));
233 static int bash_possible_command_completions
__P((int, int));
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 ();
635 /* Contains the line to push into readline. */
636 static char *push_to_readline
= (char *)NULL
;
638 /* Push the contents of push_to_readline into the
643 if (push_to_readline
)
645 rl_insert_text (push_to_readline
);
646 free (push_to_readline
);
647 push_to_readline
= (char *)NULL
;
648 rl_startup_hook
= old_rl_startup_hook
;
653 /* Call this to set the initial text for the next line to read
659 FREE (push_to_readline
);
661 push_to_readline
= savestring (line
);
662 old_rl_startup_hook
= rl_startup_hook
;
663 rl_startup_hook
= bash_push_line
;
669 display_shell_version (count
, c
)
673 show_shell_version (0);
674 putc ('\r', rl_outstream
);
675 fflush (rl_outstream
);
681 /* **************************************************************** */
685 /* **************************************************************** */
687 /* If the user requests hostname completion, then simply build a list
688 of hosts, and complete from that forever more, or at least until
689 HOSTFILE is unset. */
691 /* THIS SHOULD BE A STRINGLIST. */
692 /* The kept list of hostnames. */
693 static char **hostname_list
= (char **)NULL
;
695 /* The physical size of the above list. */
696 static int hostname_list_size
;
698 /* The number of hostnames in the above list. */
699 static int hostname_list_length
;
701 /* Whether or not HOSTNAME_LIST has been initialized. */
702 int hostname_list_initialized
= 0;
704 /* Initialize the hostname completion table. */
706 initialize_hostname_list ()
710 temp
= get_string_value ("HOSTFILE");
712 temp
= get_string_value ("hostname_completion_file");
714 temp
= DEFAULT_HOSTS_FILE
;
716 snarf_hosts_from_file (temp
);
719 hostname_list_initialized
++;
722 /* Add NAME to the list of hosts. */
727 if (hostname_list_length
+ 2 > hostname_list_size
)
729 hostname_list_size
= (hostname_list_size
+ 32) - (hostname_list_size
% 32);
730 hostname_list
= strvec_resize (hostname_list
, hostname_list_size
);
733 hostname_list
[hostname_list_length
++] = savestring (name
);
734 hostname_list
[hostname_list_length
] = (char *)NULL
;
737 #define cr_whitespace(c) ((c) == '\r' || (c) == '\n' || whitespace(c))
740 snarf_hosts_from_file (filename
)
744 char *temp
, buffer
[256], name
[256];
745 register int i
, start
;
747 file
= fopen (filename
, "r");
751 while (temp
= fgets (buffer
, 255, file
))
753 /* Skip to first character. */
754 for (i
= 0; buffer
[i
] && cr_whitespace (buffer
[i
]); i
++)
757 /* If comment or blank line, ignore. */
758 if (buffer
[i
] == '\0' || buffer
[i
] == '#')
761 /* If `preprocessor' directive, do the include. */
762 if (strncmp (buffer
+ i
, "$include ", 9) == 0)
766 /* Find start of filename. */
767 for (incfile
= buffer
+ i
+ 9; *incfile
&& whitespace (*incfile
); incfile
++)
770 /* Find end of filename. */
771 for (t
= incfile
; *t
&& cr_whitespace (*t
) == 0; t
++)
776 snarf_hosts_from_file (incfile
);
780 /* Skip internet address if present. */
781 if (DIGIT (buffer
[i
]))
782 for (; buffer
[i
] && cr_whitespace (buffer
[i
]) == 0; i
++);
784 /* Gobble up names. Each name is separated with whitespace. */
787 for (; cr_whitespace (buffer
[i
]); i
++)
789 if (buffer
[i
] == '\0' || buffer
[i
] == '#')
792 /* Isolate the current word. */
793 for (start
= i
; buffer
[i
] && cr_whitespace (buffer
[i
]) == 0; i
++)
797 strncpy (name
, buffer
+ start
, i
- start
);
798 name
[i
- start
] = '\0';
799 add_host_name (name
);
805 /* Return the hostname list. */
809 if (hostname_list_initialized
== 0)
810 initialize_hostname_list ();
811 return (hostname_list
);
815 clear_hostname_list ()
819 if (hostname_list_initialized
== 0)
821 for (i
= 0; i
< hostname_list_length
; i
++)
822 free (hostname_list
[i
]);
823 hostname_list_length
= hostname_list_initialized
= 0;
826 /* Return a NULL terminated list of hostnames which begin with TEXT.
827 Initialize the hostname list the first time if necessary.
828 The array is malloc ()'ed, but not the individual strings. */
830 hostnames_matching (text
)
833 register int i
, len
, nmatch
, rsize
;
836 if (hostname_list_initialized
== 0)
837 initialize_hostname_list ();
839 if (hostname_list_initialized
== 0)
840 return ((char **)NULL
);
842 /* Special case. If TEXT consists of nothing, then the whole list is
846 result
= strvec_create (1 + hostname_list_length
);
847 for (i
= 0; i
< hostname_list_length
; i
++)
848 result
[i
] = hostname_list
[i
];
849 result
[i
] = (char *)NULL
;
853 /* Scan until found, or failure. */
855 result
= (char **)NULL
;
856 for (i
= nmatch
= rsize
= 0; i
< hostname_list_length
; i
++)
858 if (STREQN (text
, hostname_list
[i
], len
) == 0)
861 /* OK, it matches. Add it to the list. */
862 if (nmatch
>= (rsize
- 1))
864 rsize
= (rsize
+ 16) - (rsize
% 16);
865 result
= strvec_resize (result
, rsize
);
868 result
[nmatch
++] = hostname_list
[i
];
871 result
[nmatch
] = (char *)NULL
;
875 /* The equivalent of the Korn shell C-o operate-and-get-next-history-line
877 static int saved_history_line_to_use
= -1;
878 static int last_saved_history_line
= -1;
880 #define HISTORY_FULL() (history_is_stifled () && history_length >= history_max_entries)
885 /* XXX - compensate for assumption that history was `shuffled' if it was
887 if (HISTORY_FULL () &&
888 hist_last_line_added
== 0 &&
889 saved_history_line_to_use
< history_length
- 1)
890 saved_history_line_to_use
++;
892 if (saved_history_line_to_use
>= 0)
894 rl_get_previous_history (history_length
- saved_history_line_to_use
, 0);
895 last_saved_history_line
= saved_history_line_to_use
;
897 saved_history_line_to_use
= -1;
898 rl_startup_hook
= old_rl_startup_hook
;
903 operate_and_get_next (count
, c
)
908 /* Accept the current line. */
911 /* Find the current line, and find the next line to use. */
912 where
= where_history ();
914 if (HISTORY_FULL () || (where
>= history_length
- 1))
915 saved_history_line_to_use
= where
;
917 saved_history_line_to_use
= where
+ 1;
919 old_rl_startup_hook
= rl_startup_hook
;
920 rl_startup_hook
= set_saved_history
;
925 /* This vi mode command causes VI_EDIT_COMMAND to be run on the current
926 command being entered (if no explicit argument is given), otherwise on
927 a command from the history file. */
929 #define VI_EDIT_COMMAND "fc -e \"${VISUAL:-${EDITOR:-vi}}\""
930 #define EMACS_EDIT_COMMAND "fc -e \"${VISUAL:-${EDITOR:-emacs}}\""
931 #define POSIX_VI_EDIT_COMMAND "fc -e vi"
934 edit_and_execute_command (count
, c
, editing_mode
, edit_command
)
935 int count
, c
, editing_mode
;
938 char *command
, *metaval
;
939 int r
, rrs
, metaflag
;
940 sh_parser_state_t ps
;
942 rrs
= rl_readline_state
;
943 saved_command_line_count
= current_command_line_count
;
945 /* Accept the current line. */
950 command
= (char *)xmalloc (strlen (edit_command
) + 8);
951 sprintf (command
, "%s %d", edit_command
, count
);
955 /* Take the command we were just editing, add it to the history file,
956 then call fc to operate on it. We have to add a dummy command to
957 the end of the history because fc ignores the last command (assumes
958 it's supposed to deal with the command before the `fc'). */
959 /* This breaks down when using command-oriented history and are not
960 finished with the command, so we should not ignore the last command */
962 current_command_line_count
++; /* for rl_newline above */
963 bash_add_history (rl_line_buffer
);
964 current_command_line_count
= 0; /* for dummy history entry */
965 bash_add_history ("");
966 history_lines_this_session
++;
968 command
= savestring (edit_command
);
971 metaval
= rl_variable_value ("input-meta");
972 metaflag
= RL_BOOLEAN_VARIABLE_VALUE (metaval
);
974 /* Now, POSIX.1-2001 and SUSv3 say that the commands executed from the
975 temporary file should be placed into the history. We don't do that
977 if (rl_deprep_term_function
)
978 (*rl_deprep_term_function
) ();
979 save_parser_state (&ps
);
980 r
= parse_and_execute (command
, (editing_mode
== VI_EDITING_MODE
) ? "v" : "C-xC-e", SEVAL_NOHIST
);
981 restore_parser_state (&ps
);
982 if (rl_prep_term_function
)
983 (*rl_prep_term_function
) (metaflag
);
985 current_command_line_count
= saved_command_line_count
;
987 /* Now erase the contents of the current line and undo the effects of the
988 rl_accept_line() above. We don't even want to make the text we just
989 executed available for undoing. */
990 rl_line_buffer
[0] = '\0'; /* XXX */
991 rl_point
= rl_end
= 0;
993 rl_readline_state
= rrs
;
995 rl_forced_update_display ();
1000 #if defined (VI_MODE)
1002 vi_edit_and_execute_command (count
, c
)
1005 if (posixly_correct
)
1006 return (edit_and_execute_command (count
, c
, VI_EDITING_MODE
, POSIX_VI_EDIT_COMMAND
));
1008 return (edit_and_execute_command (count
, c
, VI_EDITING_MODE
, VI_EDIT_COMMAND
));
1010 #endif /* VI_MODE */
1013 emacs_edit_and_execute_command (count
, c
)
1016 return (edit_and_execute_command (count
, c
, EMACS_EDITING_MODE
, EMACS_EDIT_COMMAND
));
1021 posix_edit_macros (count
, key
)
1025 char alias_name
[3], *alias_value
, *macro
;
1028 alias_name
[0] = '_';
1030 alias_name
[2] = '\0';
1032 alias_value
= get_alias_value (alias_name
);
1033 if (alias_value
&& *alias_value
)
1035 macro
= savestring (alias_value
);
1036 rl_push_macro_input (macro
);
1042 /* Bindable commands that move `shell-words': that is, sequences of
1043 non-unquoted-metacharacters. */
1045 #define WORDDELIM(c) (shellmeta(c) || shellblank(c))
1048 bash_forward_shellword (count
, key
)
1056 return (bash_backward_shellword (-count
, key
));
1058 /* The tricky part of this is deciding whether or not the first character
1059 we're on is an unquoted metacharacter. Not completely handled yet. */
1060 /* XXX - need to test this stuff with backslash-escaped shell
1061 metacharacters and unclosed single- and double-quoted strings. */
1074 /* Are we in a quoted string? If we are, move to the end of the quoted
1075 string and continue the outer loop. We only want quoted strings, not
1076 backslash-escaped characters, but char_is_quoted doesn't
1078 if (char_is_quoted (rl_line_buffer
, p
) && p
> 0 && rl_line_buffer
[p
-1] != '\\')
1081 ADVANCE_CHAR (rl_line_buffer
, slen
, p
);
1082 while (p
< rl_end
&& char_is_quoted (rl_line_buffer
, p
));
1087 /* Rest of code assumes we are not in a quoted string. */
1088 /* Move forward until we hit a non-metacharacter. */
1089 while (p
< rl_end
&& (c
= rl_line_buffer
[p
]) && WORDDELIM (c
))
1094 ADVANCE_CHAR (rl_line_buffer
, slen
, p
);
1095 continue; /* straight back to loop, don't increment p */
1097 if (p
< rl_end
&& rl_line_buffer
[p
])
1098 ADVANCE_CHAR (rl_line_buffer
, slen
, p
);
1101 p
= skip_to_delim (rl_line_buffer
, ++p
, "'", SD_NOJMP
);
1104 p
= skip_to_delim (rl_line_buffer
, ++p
, "\"", SD_NOJMP
);
1112 if (rl_line_buffer
[p
] == 0 || p
== rl_end
)
1119 /* Now move forward until we hit a non-quoted metacharacter or EOL */
1120 while (p
< rl_end
&& (c
= rl_line_buffer
[p
]) && WORDDELIM (c
) == 0)
1125 ADVANCE_CHAR (rl_line_buffer
, slen
, p
);
1126 continue; /* straight back to loop, don't increment p */
1128 if (p
< rl_end
&& rl_line_buffer
[p
])
1129 ADVANCE_CHAR (rl_line_buffer
, slen
, p
);
1132 p
= skip_to_delim (rl_line_buffer
, ++p
, "'", SD_NOJMP
);
1135 p
= skip_to_delim (rl_line_buffer
, ++p
, "\"", SD_NOJMP
);
1143 if (p
== rl_end
|| rl_line_buffer
[p
] == 0)
1157 bash_backward_shellword (count
, key
)
1165 return (bash_forward_shellword (-count
, key
));
1178 /* Move backward until we hit a non-metacharacter. */
1181 c
= rl_line_buffer
[p
];
1182 if (WORDDELIM (c
) && char_is_quoted (rl_line_buffer
, p
) == 0)
1183 BACKUP_CHAR (rl_line_buffer
, slen
, p
);
1193 /* Now move backward until we hit a metacharacter or BOL. */
1196 c
= rl_line_buffer
[p
];
1197 if (WORDDELIM (c
) && char_is_quoted (rl_line_buffer
, p
) == 0)
1199 BACKUP_CHAR (rl_line_buffer
, slen
, p
);
1210 bash_kill_shellword (count
, key
)
1216 return (bash_backward_kill_shellword (-count
, key
));
1219 bash_forward_shellword (count
, key
);
1222 rl_kill_text (p
, rl_point
);
1225 if (rl_editing_mode
== 1) /* 1 == emacs_mode */
1232 bash_backward_kill_shellword (count
, key
)
1238 return (bash_kill_shellword (-count
, key
));
1241 bash_backward_shellword (count
, key
);
1244 rl_kill_text (p
, rl_point
);
1246 if (rl_editing_mode
== 1) /* 1 == emacs_mode */
1253 /* **************************************************************** */
1255 /* How To Do Shell Completion */
1257 /* **************************************************************** */
1259 #define COMMAND_SEPARATORS ";|&{(`"
1261 #define COMMAND_SEPARATORS_PLUS_WS ";|&{(` \t"
1264 /* check for redirections and other character combinations that are not
1265 command separators */
1270 register int this_char
, prev_char
;
1272 /* Handle the two character tokens `>&', `<&', and `>|'.
1273 We are not in a command position after one of these. */
1274 this_char
= rl_line_buffer
[ti
];
1275 prev_char
= rl_line_buffer
[ti
- 1];
1277 if ((this_char
== '&' && (prev_char
== '<' || prev_char
== '>')) ||
1278 (this_char
== '|' && prev_char
== '>'))
1280 else if (this_char
== '{' && prev_char
== '$') /*}*/
1283 else if (this_char
== '(' && prev_char
== '$') /*)*/
1285 else if (this_char
== '(' && prev_char
== '<') /*)*/
1287 #if defined (EXTENDED_GLOB)
1288 else if (extended_glob
&& this_char
== '(' && prev_char
== '!') /*)*/
1292 else if (char_is_quoted (rl_line_buffer
, ti
))
1297 #if defined (PROGRAMMABLE_COMPLETION)
1299 * XXX - because of the <= start test, and setting os = s+1, this can
1300 * potentially return os > start. This is probably not what we want to
1301 * happen, but fix later after 2.05a-release.
1304 find_cmd_start (start
)
1310 /* Flags == SD_NOJMP only because we want to skip over command substitutions
1311 in assignment statements. Have to test whether this affects `standalone'
1312 command substitutions as individual words. */
1313 while (((s
= skip_to_delim (rl_line_buffer
, os
, COMMAND_SEPARATORS
, SD_NOJMP
/*|SD_NOSKIPCMD*/)) <= start
) &&
1325 e
= skip_to_delim (rl_line_buffer
, end
, COMMAND_SEPARATORS
, SD_NOJMP
);
1330 find_cmd_name (start
, sp
, ep
)
1337 for (s
= start
; whitespace (rl_line_buffer
[s
]); s
++)
1340 /* skip until a shell break character */
1341 e
= skip_to_delim (rl_line_buffer
, s
, "()<>;&| \t\n", SD_NOJMP
);
1343 name
= substring (rl_line_buffer
, s
, e
);
1354 prog_complete_return (text
, matchnum
)
1363 if (prog_complete_matches
== 0 || prog_complete_matches
[ind
] == 0)
1364 return (char *)NULL
;
1365 return (prog_complete_matches
[ind
++]);
1368 #endif /* PROGRAMMABLE_COMPLETION */
1370 /* Try and catch completion attempts that are syntax errors or otherwise
1373 invalid_completion (text
, ind
)
1379 /* If we don't catch these here, the next clause will */
1380 if (ind
> 0 && rl_line_buffer
[ind
] == '(' && /*)*/
1381 member (rl_line_buffer
[ind
-1], "$<>"))
1385 while (pind
> 0 && whitespace (rl_line_buffer
[pind
]))
1387 /* If we have only whitespace preceding a paren, it's valid */
1388 if (ind
>= 0 && pind
<= 0 && rl_line_buffer
[ind
] == '(') /*)*/
1390 /* Flag the invalid completions, which are mostly syntax errors */
1391 if (ind
> 0 && rl_line_buffer
[ind
] == '(' && /*)*/
1392 member (rl_line_buffer
[pind
], COMMAND_SEPARATORS
) == 0)
1398 /* Do some completion on TEXT. The indices of TEXT in RL_LINE_BUFFER are
1399 at START and END. Return an array of matches, or NULL if none. */
1401 attempt_shell_completion (text
, start
, end
)
1405 int in_command_position
, ti
, saveti
, qc
, dflags
;
1406 char **matches
, *command_separator_chars
;
1407 #if defined (PROGRAMMABLE_COMPLETION)
1408 int have_progcomps
, was_assignment
;
1411 command_separator_chars
= COMMAND_SEPARATORS
;
1412 matches
= (char **)NULL
;
1413 rl_ignore_some_completions_function
= filename_completion_ignore
;
1415 rl_filename_quote_characters
= default_filename_quote_characters
;
1416 set_filename_bstab (rl_filename_quote_characters
);
1417 set_directory_hook ();
1418 rl_filename_stat_hook
= bash_filename_stat_hook
;
1420 /* Determine if this could be a command word. It is if it appears at
1421 the start of the line (ignoring preceding whitespace), or if it
1422 appears after a character that separates commands. It cannot be a
1423 command word if we aren't at the top-level prompt. */
1427 while ((ti
> -1) && (whitespace (rl_line_buffer
[ti
])))
1431 /* If this is an open quote, maybe we're trying to complete a quoted
1433 if (ti
>= 0 && (rl_line_buffer
[ti
] == '"' || rl_line_buffer
[ti
] == '\''))
1435 qc
= rl_line_buffer
[ti
];
1437 while (ti
> -1 && (whitespace (rl_line_buffer
[ti
])))
1442 in_command_position
= 0;
1445 /* Only do command completion at the start of a line when we
1446 are prompting at the top level. */
1447 if (current_prompt_string
== ps1_prompt
)
1448 in_command_position
++;
1449 else if (parser_in_command_position ())
1450 in_command_position
++;
1452 else if (member (rl_line_buffer
[ti
], command_separator_chars
))
1454 in_command_position
++;
1456 if (check_redir (ti
) == 1)
1457 in_command_position
= 0;
1461 /* This still could be in command position. It is possible
1462 that all of the previous words on the line are variable
1466 if (in_command_position
&& invalid_completion (text
, ti
))
1468 rl_attempted_completion_over
= 1;
1469 return ((char **)NULL
);
1472 /* Check that we haven't incorrectly flagged a closed command substitution
1473 as indicating we're in a command position. */
1474 if (in_command_position
&& ti
>= 0 && rl_line_buffer
[ti
] == '`' &&
1475 *text
!= '`' && unclosed_pair (rl_line_buffer
, end
, "`") == 0)
1476 in_command_position
= 0;
1478 /* Special handling for command substitution. If *TEXT is a backquote,
1479 it can be the start or end of an old-style command substitution, or
1480 unmatched. If it's unmatched, both calls to unclosed_pair will
1481 succeed. Don't bother if readline found a single quote and we are
1482 completing on the substring. */
1483 if (*text
== '`' && rl_completion_quote_character
!= '\'' &&
1484 (in_command_position
|| (unclosed_pair (rl_line_buffer
, start
, "`") &&
1485 unclosed_pair (rl_line_buffer
, end
, "`"))))
1486 matches
= rl_completion_matches (text
, command_subst_completion_function
);
1488 #if defined (PROGRAMMABLE_COMPLETION)
1489 /* Attempt programmable completion. */
1490 have_progcomps
= prog_completion_enabled
&& (progcomp_size () > 0);
1491 if (matches
== 0 && (in_command_position
== 0 || text
[0] == '\0') &&
1492 current_prompt_string
== ps1_prompt
)
1494 int s
, e
, s1
, e1
, os
, foundcs
;
1497 /* XXX - don't free the members */
1498 if (prog_complete_matches
)
1499 free (prog_complete_matches
);
1500 prog_complete_matches
= (char **)NULL
;
1504 s
= find_cmd_start (os
);
1505 e
= find_cmd_end (end
);
1508 /* Skip over assignment statements preceding a command name. If we
1509 don't find a command name at all, we can perform command name
1510 completion. If we find a partial command name, we should perform
1511 command name completion on it. */
1513 n
= find_cmd_name (s
, &s1
, &e1
);
1516 while (was_assignment
= assignment (n
, 0));
1517 s
= s1
; /* reset to index where name begins */
1519 /* s == index of where command name begins (reset above)
1520 e == end of current command, may be end of line
1521 s1 = index of where command name begins
1522 e1 == index of where command name ends
1523 start == index of where word to be completed begins
1524 end == index of where word to be completed ends
1525 if (s == start) we are doing command word completion for sure
1526 if (e1 == end) we are at the end of the command name and completing it */
1527 if (start
== 0 && end
== 0 && e
!= 0 && text
[0] == '\0') /* beginning of non-empty line */
1529 else if (start
== end
&& start
== s1
&& e
!= 0 && e1
> end
) /* beginning of command name, leading whitespace */
1531 else if (e
== 0 && e
== s
&& text
[0] == '\0' && have_progcomps
) /* beginning of empty line */
1532 prog_complete_matches
= programmable_completions ("_EmptycmD_", text
, s
, e
, &foundcs
);
1533 else if (start
== end
&& text
[0] == '\0' && s1
> start
&& whitespace (rl_line_buffer
[start
]))
1534 foundcs
= 0; /* whitespace before command name */
1535 else if (e
> s
&& was_assignment
== 0 && e1
== end
&& rl_line_buffer
[e
] == 0 && whitespace (rl_line_buffer
[e
-1]) == 0)
1537 /* not assignment statement, but still want to perform command
1538 completion if we are composing command word. */
1540 in_command_position
= s
== start
&& STREQ (n
, text
); /* XXX */
1542 else if (e
> s
&& was_assignment
== 0 && have_progcomps
)
1544 prog_complete_matches
= programmable_completions (n
, text
, s
, e
, &foundcs
);
1545 /* command completion if programmable completion fails */
1546 in_command_position
= s
== start
&& STREQ (n
, text
); /* XXX */
1548 /* empty command name following command separator */
1549 else if (s
>= e
&& n
[0] == '\0' && text
[0] == '\0' && start
> 0 &&
1550 was_assignment
== 0 && member (rl_line_buffer
[start
-1], COMMAND_SEPARATORS
))
1553 in_command_position
= 1;
1555 else if (s
>= e
&& n
[0] == '\0' && text
[0] == '\0' && start
> 0)
1557 foundcs
= 0; /* empty command name following assignments */
1558 in_command_position
= was_assignment
;
1560 else if (s
== start
&& e
== end
&& STREQ (n
, text
) && start
> 0)
1562 foundcs
= 0; /* partial command name following assignments */
1563 in_command_position
= 1;
1568 /* XXX - if we found a COMPSPEC for the command, just return whatever
1569 the programmable completion code returns, and disable the default
1570 filename completion that readline will do unless the COPT_DEFAULT
1571 option has been set with the `-o default' option to complete or
1575 pcomp_set_readline_variables (foundcs
, 1);
1576 /* Turn what the programmable completion code returns into what
1577 readline wants. I should have made compute_lcd_of_matches
1579 matches
= rl_completion_matches (text
, prog_complete_return
);
1580 if ((foundcs
& COPT_DEFAULT
) == 0)
1581 rl_attempted_completion_over
= 1; /* no default */
1582 if (matches
|| ((foundcs
& COPT_BASHDEFAULT
) == 0))
1591 if (in_command_position
)
1592 dflags
|= DEFCOMP_CMDPOS
;
1593 matches
= bash_default_completion (text
, start
, end
, qc
, dflags
);
1600 bash_default_completion (text
, start
, end
, qc
, compflags
)
1602 int start
, end
, qc
, compflags
;
1606 matches
= (char **)NULL
;
1608 /* New posix-style command substitution or variable name? */
1609 if (!matches
&& *text
== '$')
1611 if (qc
!= '\'' && text
[1] == '(') /* ) */
1612 matches
= rl_completion_matches (text
, command_subst_completion_function
);
1615 matches
= rl_completion_matches (text
, variable_completion_function
);
1616 if (matches
&& matches
[0] && matches
[1] == 0)
1618 t
= savestring (matches
[0]);
1619 bash_filename_stat_hook (&t
);
1620 /* doesn't use test_for_directory because that performs tilde
1623 rl_completion_append_character
= '/';
1629 /* If the word starts in `~', and there is no slash in the word, then
1630 try completing this word as a username. */
1631 if (matches
== 0 && *text
== '~' && mbschr (text
, '/') == 0)
1632 matches
= rl_completion_matches (text
, rl_username_completion_function
);
1634 /* Another one. Why not? If the word starts in '@', then look through
1635 the world of known hostnames for completion first. */
1636 if (matches
== 0 && perform_hostname_completion
&& *text
== '@')
1637 matches
= rl_completion_matches (text
, hostname_completion_function
);
1639 /* And last, (but not least) if this word is in a command position, then
1640 complete over possible command names, including aliases, functions,
1641 and command names. */
1642 if (matches
== 0 && (compflags
& DEFCOMP_CMDPOS
))
1644 /* If END == START and text[0] == 0, we are trying to complete an empty
1646 if (no_empty_command_completion
&& end
== start
&& text
[0] == '\0')
1648 matches
= (char **)NULL
;
1649 rl_ignore_some_completions_function
= bash_ignore_everything
;
1653 #define CMD_IS_DIR(x) (absolute_pathname(x) == 0 && absolute_program(x) == 0 && *(x) != '~' && test_for_directory (x))
1656 matches
= rl_completion_matches (text
, command_word_completion_function
);
1658 /* If we are attempting command completion and nothing matches, we
1659 do not want readline to perform filename completion for us. We
1660 still want to be able to complete partial pathnames, so set the
1661 completion ignore function to something which will remove
1662 filenames and leave directories in the match list. */
1663 if (matches
== (char **)NULL
)
1664 rl_ignore_some_completions_function
= bash_ignore_filenames
;
1665 else if (matches
[1] == 0 && CMD_IS_DIR(matches
[0]) && dot_in_path
== 0)
1666 /* If we found a single match, without looking in the current
1667 directory (because it's not in $PATH), but the found name is
1668 also a command in the current directory, suppress appending any
1669 terminating character, since it's ambiguous. */
1671 rl_completion_suppress_append
= 1;
1672 rl_filename_completion_desired
= 0;
1674 else if (matches
[0] && matches
[1] && STREQ (matches
[0], matches
[1]) && CMD_IS_DIR (matches
[0]))
1675 /* There are multiple instances of the same match (duplicate
1676 completions haven't yet been removed). In this case, all of
1677 the matches will be the same, and the duplicate removal code
1678 will distill them all down to one. We turn on
1679 rl_completion_suppress_append for the same reason as above.
1680 Remember: we only care if there's eventually a single unique
1681 completion. If there are multiple completions this won't
1682 make a difference and the problem won't occur. */
1684 rl_completion_suppress_append
= 1;
1685 rl_filename_completion_desired
= 0;
1690 /* This could be a globbing pattern, so try to expand it using pathname
1692 if (!matches
&& glob_pattern_p (text
))
1694 matches
= rl_completion_matches (text
, glob_complete_word
);
1695 /* A glob expression that matches more than one filename is problematic.
1696 If we match more than one filename, punt. */
1697 if (matches
&& matches
[1] && rl_completion_type
== TAB
)
1699 strvec_dispose (matches
);
1700 matches
= (char **)0;
1702 else if (matches
&& matches
[1] && rl_completion_type
== '!')
1704 rl_completion_suppress_append
= 1;
1705 rl_filename_completion_desired
= 0;
1713 bash_command_name_stat_hook (name
)
1716 char *cname
, *result
;
1718 /* If it's not something we're going to look up in $PATH, just call the
1719 normal filename stat hook. */
1720 if (absolute_program (*name
))
1721 return (bash_filename_stat_hook (name
));
1724 /* XXX - we could do something here with converting aliases, builtins,
1725 and functions into something that came out as executable, but we don't. */
1726 result
= search_for_command (cname
, 0);
1736 executable_completion (filename
, searching_path
)
1737 const char *filename
;
1743 f
= savestring (filename
);
1744 bash_directory_completion_hook (&f
);
1746 r
= searching_path
? executable_file (f
) : executable_or_directory (f
);
1751 /* This is the function to call when the word to complete is in a position
1752 where a command word can be found. It grovels $PATH, looking for commands
1753 that match. It also scans aliases, function names, and the shell_builtin
1756 command_word_completion_function (hint_text
, state
)
1757 const char *hint_text
;
1760 static char *hint
= (char *)NULL
;
1761 static char *path
= (char *)NULL
;
1762 static char *val
= (char *)NULL
;
1763 static char *filename_hint
= (char *)NULL
;
1764 static char *fnhint
= (char *)NULL
;
1765 static char *dequoted_hint
= (char *)NULL
;
1766 static char *directory_part
= (char *)NULL
;
1767 static char **glob_matches
= (char **)NULL
;
1768 static int path_index
, hint_len
, dequoted_len
, istate
, igncase
;
1769 static int mapping_over
, local_index
, searching_path
, hint_is_dir
;
1770 static int old_glob_ignore_case
, globpat
;
1771 static SHELL_VAR
**varlist
= (SHELL_VAR
**)NULL
;
1773 static alias_t
**alias_list
= (alias_t
**)NULL
;
1777 /* We have to map over the possibilities for command words. If we have
1778 no state, then make one just for that purpose. */
1781 rl_filename_stat_hook
= bash_command_name_stat_hook
;
1783 if (dequoted_hint
&& dequoted_hint
!= hint
)
1784 free (dequoted_hint
);
1788 mapping_over
= searching_path
= 0;
1789 hint_is_dir
= CMD_IS_DIR (hint_text
);
1792 temp
= rl_variable_value ("completion-ignore-case");
1793 igncase
= RL_BOOLEAN_VARIABLE_VALUE (temp
);
1797 free (glob_matches
);
1798 glob_matches
= (char **)NULL
;
1801 globpat
= glob_pattern_p (hint_text
);
1803 /* If this is an absolute program name, do not check it against
1804 aliases, reserved words, functions or builtins. We must check
1805 whether or not it is unique, and, if so, whether that filename
1807 if (globpat
|| absolute_program (hint_text
))
1809 /* Perform tilde expansion on what's passed, so we don't end up
1810 passing filenames with tildes directly to stat(). */
1811 if (*hint_text
== '~')
1813 hint
= bash_tilde_expand (hint_text
, 0);
1814 directory_part
= savestring (hint_text
);
1815 temp
= strchr (directory_part
, '/');
1820 free (directory_part
);
1821 directory_part
= (char *)NULL
;
1825 hint
= savestring (hint_text
);
1827 dequoted_hint
= hint
;
1828 /* If readline's completer found a quote character somewhere, but
1829 didn't set the quote character, there must have been a quote
1830 character embedded in the filename. It can't be at the start of
1831 the filename, so we need to dequote the filename before we look
1832 in the file system for it. */
1833 if (rl_completion_found_quote
&& rl_completion_quote_character
== 0)
1835 dequoted_hint
= bash_dequote_filename (hint
, 0);
1837 hint
= dequoted_hint
;
1839 dequoted_len
= hint_len
= strlen (hint
);
1842 free (filename_hint
);
1844 fnhint
= filename_hint
= savestring (hint
);
1855 if (dircomplete_expand
&& path_dot_or_dotdot (filename_hint
))
1857 dircomplete_expand
= 0;
1858 set_directory_hook ();
1859 dircomplete_expand
= 1;
1866 dequoted_hint
= hint
= savestring (hint_text
);
1867 dequoted_len
= hint_len
= strlen (hint
);
1869 if (rl_completion_found_quote
&& rl_completion_quote_character
== 0)
1871 dequoted_hint
= bash_dequote_filename (hint
, 0);
1872 dequoted_len
= strlen (dequoted_hint
);
1875 path
= get_string_value ("PATH");
1876 path_index
= dot_in_path
= 0;
1878 /* Initialize the variables for each type of command word. */
1884 varlist
= all_visible_functions ();
1890 alias_list
= all_aliases ();
1894 /* mapping_over says what we are currently hacking. Note that every case
1895 in this list must fall through when there are no more possibilities. */
1897 switch (mapping_over
)
1899 case 0: /* Aliases come first. */
1901 while (alias_list
&& alias_list
[local_index
])
1903 register char *alias
;
1905 alias
= alias_list
[local_index
++]->name
;
1907 if (STREQN (alias
, hint
, hint_len
))
1908 return (savestring (alias
));
1914 case 1: /* Then shell reserved words. */
1916 while (word_token_alist
[local_index
].word
)
1918 register char *reserved_word
;
1920 reserved_word
= word_token_alist
[local_index
++].word
;
1922 if (STREQN (reserved_word
, hint
, hint_len
))
1923 return (savestring (reserved_word
));
1929 case 2: /* Then function names. */
1930 while (varlist
&& varlist
[local_index
])
1932 register char *varname
;
1934 varname
= varlist
[local_index
++]->name
;
1936 if (STREQN (varname
, hint
, hint_len
))
1937 return (savestring (varname
));
1942 case 3: /* Then shell builtins. */
1943 for (; local_index
< num_shell_builtins
; local_index
++)
1945 /* Ignore it if it doesn't have a function pointer or if it
1946 is not currently enabled. */
1947 if (!shell_builtins
[local_index
].function
||
1948 (shell_builtins
[local_index
].flags
& BUILTIN_ENABLED
) == 0)
1951 if (STREQN (shell_builtins
[local_index
].name
, hint
, hint_len
))
1953 int i
= local_index
++;
1955 return (savestring (shell_builtins
[i
].name
));
1963 /* Limited support for completing command words with globbing chars. Only
1964 a single match (multiple matches that end up reducing the number of
1965 characters in the common prefix are bad) will ever be returned on
1966 regular completion. */
1971 glob_ignore_case
= igncase
;
1972 glob_matches
= shell_glob_filename (hint
);
1973 glob_ignore_case
= old_glob_ignore_case
;
1975 if (GLOB_FAILED (glob_matches
) || glob_matches
== 0)
1977 glob_matches
= (char **)NULL
;
1978 return ((char *)NULL
);
1983 if (glob_matches
[1] && rl_completion_type
== TAB
) /* multiple matches are bad */
1984 return ((char *)NULL
);
1987 while (val
= glob_matches
[local_index
++])
1989 if (executable_or_directory (val
))
1991 if (*hint_text
== '~' && directory_part
)
1993 temp
= maybe_restore_tilde (val
, directory_part
);
2002 glob_ignore_case
= old_glob_ignore_case
;
2003 return ((char *)NULL
);
2006 /* If the text passed is a directory in the current directory, return it
2007 as a possible match. Executables in directories in the current
2008 directory can be specified using relative pathnames and successfully
2009 executed even when `.' is not in $PATH. */
2012 hint_is_dir
= 0; /* only return the hint text once */
2013 return (savestring (hint_text
));
2016 /* Repeatedly call filename_completion_function while we have
2017 members of PATH left. Question: should we stat each file?
2018 Answer: we call executable_file () on each file. */
2021 istate
= (val
!= (char *)NULL
);
2027 /* Get the next directory from the path. If there is none, then we
2029 if (path
== 0 || path
[path_index
] == 0 ||
2030 (current_path
= extract_colon_unit (path
, &path_index
)) == 0)
2031 return ((char *)NULL
);
2034 if (*current_path
== 0)
2036 free (current_path
);
2037 current_path
= savestring (".");
2040 if (*current_path
== '~')
2044 t
= bash_tilde_expand (current_path
, 0);
2045 free (current_path
);
2049 if (current_path
[0] == '.' && current_path
[1] == '\0')
2052 if (fnhint
&& fnhint
!= filename_hint
)
2055 free (filename_hint
);
2057 filename_hint
= sh_makepath (current_path
, hint
, 0);
2058 /* Need a quoted version (though it doesn't matter much in most
2059 cases) because rl_filename_completion_function dequotes the
2060 filename it gets, assuming that it's been quoted as part of
2061 the input line buffer. */
2062 if (strpbrk (filename_hint
, "\"'\\"))
2063 fnhint
= sh_backslash_quote (filename_hint
, filename_bstab
, 0);
2065 fnhint
= filename_hint
;
2066 free (current_path
); /* XXX */
2070 val
= rl_filename_completion_function (fnhint
, istate
);
2071 if (mapping_over
== 4 && dircomplete_expand
)
2072 set_directory_hook ();
2078 /* If the hint text is an absolute program, then don't bother
2079 searching through PATH. */
2080 if (absolute_program (hint
))
2081 return ((char *)NULL
);
2087 int match
, freetemp
;
2089 if (absolute_program (hint
))
2092 match
= strncmp (val
, hint
, hint_len
) == 0;
2094 match
= strncasecmp (val
, hint
, hint_len
) == 0;
2096 /* If we performed tilde expansion, restore the original
2098 if (*hint_text
== '~')
2099 temp
= maybe_restore_tilde (val
, directory_part
);
2101 temp
= savestring (val
);
2106 temp
= strrchr (val
, '/');
2112 freetemp
= match
= strncmp (temp
, hint
, hint_len
) == 0;
2114 freetemp
= match
= strncasecmp (temp
, hint
, hint_len
) == 0;
2116 temp
= savestring (temp
);
2119 freetemp
= match
= 0;
2122 /* If we have found a match, and it is an executable file, return it.
2123 We don't return directory names when searching $PATH, since the
2124 bash execution code won't find executables in directories which
2125 appear in directories in $PATH when they're specified using
2126 relative pathnames. */
2128 /* If we're not searching $PATH and we have a relative pathname, we
2129 need to re-canonicalize it before testing whether or not it's an
2130 executable or a directory so the shell treats .. relative to $PWD
2131 according to the physical/logical option. The shell already
2132 canonicalizes the directory name in order to tell readline where
2133 to look, so not doing it here will be inconsistent. */
2134 /* XXX -- currently not used -- will introduce more inconsistency,
2135 since shell does not canonicalize ../foo before passing it to
2137 if (match
&& searching_path
== 0 && *val
== '.')
2141 t
= get_working_directory ("command-word-completion");
2142 t1
= make_absolute (val
, t
);
2144 cval
= sh_canonpath (t1
, PATH_CHECKDOTDOT
|PATH_CHECKEXISTS
);
2150 if (match
&& executable_completion ((searching_path
? val
: cval
), searching_path
))
2155 val
= ""; /* So it won't be NULL. */
2170 /* Completion inside an unterminated command substitution. */
2172 command_subst_completion_function (text
, state
)
2176 static char **matches
= (char **)NULL
;
2177 static const char *orig_start
;
2178 static char *filename_text
= (char *)NULL
;
2179 static int cmd_index
, start_len
;
2185 free (filename_text
);
2189 else if (*text
== '$' && text
[1] == '(') /* ) */
2191 /* If the text was quoted, suppress any quote character that the
2192 readline completion code would insert. */
2193 rl_completion_suppress_quote
= 1;
2194 start_len
= text
- orig_start
;
2195 filename_text
= savestring (text
);
2200 * At this point we can entertain the idea of re-parsing
2201 * `filename_text' into a (possibly incomplete) command name and
2202 * arguments, and doing completion based on that. This is
2203 * currently very rudimentary, but it is a small improvement.
2205 for (value
= filename_text
+ strlen (filename_text
) - 1; value
> filename_text
; value
--)
2206 if (whitespace (*value
) || member (*value
, COMMAND_SEPARATORS
))
2208 if (value
<= filename_text
)
2209 matches
= rl_completion_matches (filename_text
, command_word_completion_function
);
2213 start_len
+= value
- filename_text
;
2214 if (whitespace (value
[-1]))
2215 matches
= rl_completion_matches (value
, rl_filename_completion_function
);
2217 matches
= rl_completion_matches (value
, command_word_completion_function
);
2220 /* If there is more than one match, rl_completion_matches has already
2221 put the lcd in matches[0]. Skip over it. */
2222 cmd_index
= matches
&& matches
[0] && matches
[1];
2224 /* If there's a single match and it's a directory, set the append char
2225 to the expected `/'. Otherwise, don't append anything. */
2226 if (matches
&& matches
[0] && matches
[1] == 0 && test_for_directory (matches
[0]))
2227 rl_completion_append_character
= '/';
2229 rl_completion_suppress_append
= 1;
2232 if (matches
== 0 || matches
[cmd_index
] == 0)
2234 rl_filename_quoting_desired
= 0; /* disable quoting */
2235 return ((char *)NULL
);
2239 value
= (char *)xmalloc (1 + start_len
+ strlen (matches
[cmd_index
]));
2242 value
[0] = *orig_start
;
2244 strncpy (value
, orig_start
, start_len
);
2246 strcpy (value
+ start_len
, matches
[cmd_index
]);
2253 /* Okay, now we write the entry_function for variable completion. */
2255 variable_completion_function (text
, state
)
2259 static char **varlist
= (char **)NULL
;
2260 static int varlist_index
;
2261 static char *varname
= (char *)NULL
;
2263 static int first_char
, first_char_loc
;
2271 first_char
= text
[0];
2273 if (first_char
== '$')
2276 if (text
[first_char_loc
] == '{')
2279 varname
= savestring (text
+ first_char_loc
);
2281 namelen
= strlen (varname
);
2283 strvec_dispose (varlist
);
2285 varlist
= all_variables_matching_prefix (varname
);
2289 if (!varlist
|| !varlist
[varlist_index
])
2291 return ((char *)NULL
);
2297 value
= (char *)xmalloc (4 + strlen (varlist
[varlist_index
]));
2301 value
[0] = first_char
;
2302 if (first_char_loc
== 2)
2306 strcpy (value
+ first_char_loc
, varlist
[varlist_index
]);
2307 if (first_char_loc
== 2)
2308 strcat (value
, "}");
2315 /* How about a completion function for hostnames? */
2317 hostname_completion_function (text
, state
)
2321 static char **list
= (char **)NULL
;
2322 static int list_index
= 0;
2323 static int first_char
, first_char_loc
;
2325 /* If we don't have any state, make some. */
2330 list
= (char **)NULL
;
2335 if (first_char
== '@')
2338 list
= hostnames_matching ((char *)text
+first_char_loc
);
2342 if (list
&& list
[list_index
])
2346 t
= (char *)xmalloc (2 + strlen (list
[list_index
]));
2348 strcpy (t
+ first_char_loc
, list
[list_index
]);
2353 return ((char *)NULL
);
2357 * A completion function for service names from /etc/services (or wherever).
2360 bash_servicename_completion_function (text
, state
)
2364 #if defined (__WIN32__) || defined (__OPENNT) || !defined (HAVE_GETSERVENT)
2365 return ((char *)NULL
);
2367 static char *sname
= (char *)NULL
;
2368 static struct servent
*srvent
;
2369 static int snamelen
, firstc
;
2371 char **alist
, *aentry
;
2379 sname
= savestring (text
);
2380 snamelen
= strlen (sname
);
2384 while (srvent
= getservent ())
2387 if (snamelen
== 0 || (STREQN (sname
, srvent
->s_name
, snamelen
)))
2389 /* Not primary, check aliases */
2390 for (alist
= srvent
->s_aliases
; *alist
; alist
++)
2393 if (STREQN (sname
, aentry
, snamelen
))
2407 return ((char *)NULL
);
2410 value
= afound
? savestring (aentry
) : savestring (srvent
->s_name
);
2416 * A completion function for group names from /etc/group (or wherever).
2419 bash_groupname_completion_function (text
, state
)
2423 #if defined (__WIN32__) || defined (__OPENNT) || !defined (HAVE_GRP_H)
2424 return ((char *)NULL
);
2426 static char *gname
= (char *)NULL
;
2427 static struct group
*grent
;
2428 static int gnamelen
;
2434 gname
= savestring (text
);
2435 gnamelen
= strlen (gname
);
2440 while (grent
= getgrent ())
2442 if (gnamelen
== 0 || (STREQN (gname
, grent
->gr_name
, gnamelen
)))
2449 return ((char *)NULL
);
2452 value
= savestring (grent
->gr_name
);
2457 /* Functions to perform history and alias expansions on the current line. */
2459 #if defined (BANG_HISTORY)
2460 /* Perform history expansion on the current line. If no history expansion
2461 is done, pre_process_line() returns what it was passed, so we need to
2462 allocate a new line here. */
2464 history_expand_line_internal (line
)
2470 old_verify
= hist_verify
;
2472 new_line
= pre_process_line (line
, 0, 0);
2473 hist_verify
= old_verify
;
2475 return (new_line
== line
) ? savestring (line
) : new_line
;
2479 /* There was an error in expansion. Let the preprocessor print
2482 cleanup_expansion_error ()
2485 #if defined (BANG_HISTORY)
2488 old_verify
= hist_verify
;
2492 fprintf (rl_outstream
, "\r\n");
2493 to_free
= pre_process_line (rl_line_buffer
, 1, 0);
2494 #if defined (BANG_HISTORY)
2495 hist_verify
= old_verify
;
2497 if (to_free
!= rl_line_buffer
)
2499 putc ('\r', rl_outstream
);
2500 rl_forced_update_display ();
2503 /* If NEW_LINE differs from what is in the readline line buffer, add an
2504 undo record to get from the readline line buffer contents to the new
2505 line and make NEW_LINE the current readline line. */
2507 maybe_make_readline_line (new_line
)
2510 if (strcmp (new_line
, rl_line_buffer
) != 0)
2514 rl_add_undo (UNDO_BEGIN
, 0, 0, 0);
2515 rl_delete_text (0, rl_point
);
2516 rl_point
= rl_end
= rl_mark
= 0;
2517 rl_insert_text (new_line
);
2518 rl_add_undo (UNDO_END
, 0, 0, 0);
2522 /* Make NEW_LINE be the current readline line. This frees NEW_LINE. */
2524 set_up_new_line (new_line
)
2527 int old_point
, at_end
;
2529 old_point
= rl_point
;
2530 at_end
= rl_point
== rl_end
;
2532 /* If the line was history and alias expanded, then make that
2533 be one thing to undo. */
2534 maybe_make_readline_line (new_line
);
2537 /* Place rl_point where we think it should go. */
2540 else if (old_point
< rl_end
)
2542 rl_point
= old_point
;
2543 if (!whitespace (rl_line_buffer
[rl_point
]))
2544 rl_forward_word (1, 0);
2549 /* Expand aliases in the current readline line. */
2551 alias_expand_line (count
, ignore
)
2556 new_line
= alias_expand (rl_line_buffer
);
2560 set_up_new_line (new_line
);
2565 cleanup_expansion_error ();
2571 #if defined (BANG_HISTORY)
2572 /* History expand the line. */
2574 history_expand_line (count
, ignore
)
2579 new_line
= history_expand_line_internal (rl_line_buffer
);
2583 set_up_new_line (new_line
);
2588 cleanup_expansion_error ();
2593 /* Expand history substitutions in the current line and then insert a
2594 space (hopefully close to where we were before). */
2596 tcsh_magic_space (count
, ignore
)
2599 int dist_from_end
, old_point
;
2601 old_point
= rl_point
;
2602 dist_from_end
= rl_end
- rl_point
;
2603 if (history_expand_line (count
, ignore
) == 0)
2605 /* Try a simple heuristic from Stephen Gildea <gildea@intouchsys.com>.
2606 This works if all expansions were before rl_point or if no expansions
2608 rl_point
= (old_point
== 0) ? old_point
: rl_end
- dist_from_end
;
2615 #endif /* BANG_HISTORY */
2617 /* History and alias expand the line. */
2619 history_and_alias_expand_line (count
, ignore
)
2625 #if defined (BANG_HISTORY)
2626 new_line
= history_expand_line_internal (rl_line_buffer
);
2634 alias_line
= alias_expand (new_line
);
2636 new_line
= alias_line
;
2642 set_up_new_line (new_line
);
2647 cleanup_expansion_error ();
2652 /* History and alias expand the line, then perform the shell word
2653 expansions by calling expand_string. This can't use set_up_new_line()
2654 because we want the variable expansions as a separate undo'able
2655 set of operations. */
2657 shell_expand_line (count
, ignore
)
2661 WORD_LIST
*expanded_string
;
2664 #if defined (BANG_HISTORY)
2665 new_line
= history_expand_line_internal (rl_line_buffer
);
2673 alias_line
= alias_expand (new_line
);
2675 new_line
= alias_line
;
2681 int old_point
= rl_point
;
2682 int at_end
= rl_point
== rl_end
;
2684 /* If the line was history and alias expanded, then make that
2685 be one thing to undo. */
2686 maybe_make_readline_line (new_line
);
2689 /* If there is variable expansion to perform, do that as a separate
2690 operation to be undone. */
2691 new_line
= savestring (rl_line_buffer
);
2692 expanded_string
= expand_string (new_line
, 0);
2694 if (expanded_string
== 0)
2696 new_line
= (char *)xmalloc (1);
2701 new_line
= string_list (expanded_string
);
2702 dispose_words (expanded_string
);
2705 maybe_make_readline_line (new_line
);
2708 /* Place rl_point where we think it should go. */
2711 else if (old_point
< rl_end
)
2713 rl_point
= old_point
;
2714 if (!whitespace (rl_line_buffer
[rl_point
]))
2715 rl_forward_word (1, 0);
2721 cleanup_expansion_error ();
2726 /* If FIGNORE is set, then don't match files with the given suffixes when
2727 completing filenames. If only one of the possibilities has an acceptable
2728 suffix, delete the others, else just return and let the completer
2729 signal an error. It is called by the completer when real
2730 completions are done on filenames by the completer's internal
2731 function, not for completion lists (M-?) and not on "other"
2732 completion types, such as hostnames or commands. */
2734 static struct ignorevar fignore
=
2740 (sh_iv_item_func_t
*) 0,
2744 _ignore_completion_names (names
, name_func
)
2746 sh_ignore_func_t
*name_func
;
2753 /* If there is only one completion, see if it is acceptable. If it is
2754 not, free it up. In any case, short-circuit and return. This is a
2755 special case because names[0] is not the prefix of the list of names
2756 if there is only one completion; it is the completion itself. */
2757 if (names
[1] == (char *)0)
2760 if ((*name_func
) (names
[0]) == 0)
2763 names
[0] = (char *)NULL
;
2769 /* Allocate space for array to hold list of pointers to matching
2770 filenames. The pointers are copied back to NAMES when done. */
2771 for (nidx
= 1; names
[nidx
]; nidx
++)
2773 newnames
= strvec_create (nidx
+ 1);
2775 if (force_fignore
== 0)
2777 oldnames
= strvec_create (nidx
- 1);
2781 newnames
[0] = names
[0];
2782 for (idx
= nidx
= 1; names
[idx
]; idx
++)
2784 if ((*name_func
) (names
[idx
]))
2785 newnames
[nidx
++] = names
[idx
];
2786 else if (force_fignore
== 0)
2787 oldnames
[oidx
++] = names
[idx
];
2792 newnames
[nidx
] = (char *)NULL
;
2794 /* If none are acceptable then let the completer handle it. */
2800 names
[0] = (char *)NULL
;
2809 if (force_fignore
== 0)
2812 free (oldnames
[--oidx
]);
2816 /* If only one is acceptable, copy it to names[0] and return. */
2820 names
[0] = newnames
[1];
2821 names
[1] = (char *)NULL
;
2826 /* Copy the acceptable names back to NAMES, set the new array end,
2828 for (nidx
= 1; newnames
[nidx
]; nidx
++)
2829 names
[nidx
] = newnames
[nidx
];
2830 names
[nidx
] = (char *)NULL
;
2835 name_is_acceptable (name
)
2841 for (nlen
= strlen (name
), p
= fignore
.ignores
; p
->val
; p
++)
2843 if (nlen
> p
->len
&& p
->len
> 0 && STREQ (p
->val
, &name
[nlen
- p
->len
]))
2852 ignore_dot_names (name
)
2855 return (name
[0] != '.');
2860 filename_completion_ignore (names
)
2864 if (glob_dot_filenames
== 0)
2865 _ignore_completion_names (names
, ignore_dot_names
);
2868 setup_ignore_patterns (&fignore
);
2870 if (fignore
.num_ignores
== 0)
2873 _ignore_completion_names (names
, name_is_acceptable
);
2878 /* Return 1 if NAME is a directory. NAME undergoes tilde expansion. */
2880 test_for_directory (name
)
2886 fn
= bash_tilde_expand (name
, 0);
2887 r
= file_isdir (fn
);
2893 /* Remove files from NAMES, leaving directories. */
2895 bash_ignore_filenames (names
)
2898 _ignore_completion_names (names
, test_for_directory
);
2910 bash_ignore_everything (names
)
2913 _ignore_completion_names (names
, return_zero
);
2917 /* Replace a tilde-prefix in VAL with a `~', assuming the user typed it. VAL
2918 is an expanded filename. DIRECTORY_PART is the tilde-prefix portion
2919 of the un-tilde-expanded version of VAL (what the user typed). */
2921 restore_tilde (val
, directory_part
)
2922 char *val
, *directory_part
;
2925 char *dh2
, *expdir
, *ret
;
2929 /* We need to duplicate the expansions readline performs on the directory
2930 portion before passing it to our completion function. */
2931 dh2
= directory_part
? bash_dequote_filename (directory_part
, 0) : 0;
2932 bash_directory_expansion (&dh2
);
2935 expdir
= bash_tilde_expand (directory_part
, 0);
2936 xl
= strlen (expdir
);
2940 dh2 = unexpanded but dequoted tilde-prefix
2941 dl2 = length of tilde-prefix
2942 expdir = tilde-expanded tilde-prefix
2943 xl = length of expanded tilde-prefix
2944 l = length of remainder after tilde-prefix
2948 ret
= (char *)xmalloc (dl2
+ 2 + l
);
2950 strcpy (ret
+ dl2
, val
+ xl
);
2957 maybe_restore_tilde (val
, directory_part
)
2958 char *val
, *directory_part
;
2960 rl_icppfunc_t
*save
;
2963 save
= (dircomplete_expand
== 0) ? save_directory_hook () : (rl_icppfunc_t
*)0;
2964 ret
= restore_tilde (val
, directory_part
);
2966 restore_directory_hook (save
);
2970 /* Simulate the expansions that will be performed by
2971 rl_filename_completion_function. This must be called with the address of
2972 a pointer to malloc'd memory. */
2974 bash_directory_expansion (dirname
)
2979 d
= savestring (*dirname
);
2981 if ((rl_directory_rewrite_hook
) && (*rl_directory_rewrite_hook
) (&d
))
2986 else if (rl_directory_completion_hook
&& (*rl_directory_completion_hook
) (&d
))
2991 else if (rl_completion_found_quote
)
2993 nd
= bash_dequote_filename (d
, rl_completion_quote_character
);
3000 /* If necessary, rewrite directory entry */
3002 bash_filename_rewrite_hook (fname
, fnlen
)
3008 conv
= fnx_fromfs (fname
, fnlen
);
3010 conv
= savestring (conv
);
3014 /* Functions to save and restore the appropriate directory hook */
3015 /* This is not static so the shopt code can call it */
3017 set_directory_hook ()
3019 if (dircomplete_expand
)
3021 rl_directory_completion_hook
= bash_directory_completion_hook
;
3022 rl_directory_rewrite_hook
= (rl_icppfunc_t
*)0;
3026 rl_directory_rewrite_hook
= bash_directory_completion_hook
;
3027 rl_directory_completion_hook
= (rl_icppfunc_t
*)0;
3031 static rl_icppfunc_t
*
3032 save_directory_hook ()
3036 if (dircomplete_expand
)
3038 ret
= rl_directory_completion_hook
;
3039 rl_directory_completion_hook
= (rl_icppfunc_t
*)NULL
;
3043 ret
= rl_directory_rewrite_hook
;
3044 rl_directory_rewrite_hook
= (rl_icppfunc_t
*)NULL
;
3051 restore_directory_hook (hookf
)
3052 rl_icppfunc_t
*hookf
;
3054 if (dircomplete_expand
)
3055 rl_directory_completion_hook
= hookf
;
3057 rl_directory_rewrite_hook
= hookf
;
3060 /* Expand a filename before the readline completion code passes it to stat(2).
3061 The filename will already have had tilde expansion performed. */
3063 bash_filename_stat_hook (dirname
)
3066 char *local_dirname
, *new_dirname
, *t
;
3067 int should_expand_dirname
, return_value
;
3071 local_dirname
= *dirname
;
3072 should_expand_dirname
= return_value
= 0;
3073 if (t
= mbschr (local_dirname
, '$'))
3074 should_expand_dirname
= '$';
3075 else if (t
= mbschr (local_dirname
, '`')) /* XXX */
3076 should_expand_dirname
= '`';
3078 #if defined (HAVE_LSTAT)
3079 if (should_expand_dirname
&& lstat (local_dirname
, &sb
) == 0)
3081 if (should_expand_dirname
&& stat (local_dirname
, &sb
) == 0)
3083 should_expand_dirname
= 0;
3085 if (should_expand_dirname
)
3087 new_dirname
= savestring (local_dirname
);
3088 wl
= expand_prompt_string (new_dirname
, 0, W_NOCOMSUB
); /* does the right thing */
3092 new_dirname
= string_list (wl
);
3093 /* Tell the completer we actually expanded something and change
3094 *dirname only if we expanded to something non-null -- stat
3095 behaves unpredictably when passed null or empty strings */
3096 if (new_dirname
&& *new_dirname
)
3098 free (local_dirname
); /* XXX */
3099 local_dirname
= *dirname
= new_dirname
;
3100 return_value
= STREQ (local_dirname
, *dirname
) == 0;
3110 /* This is very similar to the code in bash_directory_completion_hook below,
3111 but without spelling correction and not worrying about whether or not
3112 we change relative pathnames. */
3113 if (no_symbolic_links
== 0 && (local_dirname
[0] != '.' || local_dirname
[1]))
3115 char *temp1
, *temp2
;
3117 t
= get_working_directory ("symlink-hook");
3118 temp1
= make_absolute (local_dirname
, t
);
3120 temp2
= sh_canonpath (temp1
, PATH_CHECKDOTDOT
|PATH_CHECKEXISTS
);
3122 /* If we can't canonicalize, bail. */
3126 return return_value
;
3129 free (local_dirname
);
3134 return (return_value
);
3137 /* Handle symbolic link references and other directory name
3138 expansions while hacking completion. This should return 1 if it modifies
3139 the DIRNAME argument, 0 otherwise. It should make sure not to modify
3140 DIRNAME if it returns 0. */
3142 bash_directory_completion_hook (dirname
)
3145 char *local_dirname
, *new_dirname
, *t
;
3146 int return_value
, should_expand_dirname
, nextch
, closer
;
3150 return_value
= should_expand_dirname
= nextch
= closer
= 0;
3151 local_dirname
= *dirname
;
3153 if (t
= mbschr (local_dirname
, '$'))
3155 should_expand_dirname
= '$';
3157 /* Deliberately does not handle the deprecated $[...] arithmetic
3161 else if (nextch
== '{')
3166 else if (local_dirname
[0] == '~')
3167 should_expand_dirname
= '~';
3170 t
= mbschr (local_dirname
, '`');
3171 if (t
&& unclosed_pair (local_dirname
, strlen (local_dirname
), "`") == 0)
3172 should_expand_dirname
= '`';
3175 #if defined (HAVE_LSTAT)
3176 if (should_expand_dirname
&& lstat (local_dirname
, &sb
) == 0)
3178 if (should_expand_dirname
&& stat (local_dirname
, &sb
) == 0)
3180 should_expand_dirname
= 0;
3182 if (should_expand_dirname
)
3184 new_dirname
= savestring (local_dirname
);
3185 wl
= expand_prompt_string (new_dirname
, 0, W_NOCOMSUB
); /* does the right thing */
3188 *dirname
= string_list (wl
);
3189 /* Tell the completer to replace the directory name only if we
3190 actually expanded something. */
3191 return_value
= STREQ (local_dirname
, *dirname
) == 0;
3192 free (local_dirname
);
3195 local_dirname
= *dirname
;
3196 /* XXX - change rl_filename_quote_characters here based on
3197 should_expand_dirname/nextch/closer. This is the only place
3198 custom_filename_quote_characters is modified. */
3199 if (rl_filename_quote_characters
&& *rl_filename_quote_characters
)
3202 i
= strlen (default_filename_quote_characters
);
3203 custom_filename_quote_characters
= xrealloc (custom_filename_quote_characters
, i
+1);
3204 for (i
= j
= 0; c
= default_filename_quote_characters
[i
]; i
++)
3206 if (c
== should_expand_dirname
|| c
== nextch
|| c
== closer
)
3208 custom_filename_quote_characters
[j
++] = c
;
3210 custom_filename_quote_characters
[j
] = '\0';
3211 rl_filename_quote_characters
= custom_filename_quote_characters
;
3212 set_filename_bstab (rl_filename_quote_characters
);
3218 free (local_dirname
);
3219 *dirname
= (char *)xmalloc (1);
3226 /* Dequote the filename even if we don't expand it. */
3227 new_dirname
= bash_dequote_filename (local_dirname
, rl_completion_quote_character
);
3228 return_value
= STREQ (local_dirname
, new_dirname
) == 0;
3229 free (local_dirname
);
3230 local_dirname
= *dirname
= new_dirname
;
3233 /* no_symbolic_links == 0 -> use (default) logical view of the file system.
3234 local_dirname[0] == '.' && local_dirname[1] == '/' means files in the
3235 current directory (./).
3236 local_dirname[0] == '.' && local_dirname[1] == 0 means relative pathnames
3237 in the current directory (e.g., lib/sh).
3238 XXX - should we do spelling correction on these? */
3240 /* This is test as it was in bash-4.2: skip relative pathnames in current
3241 directory. Change test to
3242 (local_dirname[0] != '.' || (local_dirname[1] && local_dirname[1] != '/'))
3243 if we want to skip paths beginning with ./ also. */
3244 if (no_symbolic_links
== 0 && (local_dirname
[0] != '.' || local_dirname
[1]))
3246 char *temp1
, *temp2
;
3249 /* If we have a relative path
3250 (local_dirname[0] != '/' && local_dirname[0] != '.')
3251 that is canonical after appending it to the current directory, then
3254 strcmp (temp1, temp2) == 0
3255 after adding a slash to temp2 below. It should be safe to not
3258 t
= get_working_directory ("symlink-hook");
3259 temp1
= make_absolute (local_dirname
, t
);
3261 temp2
= sh_canonpath (temp1
, PATH_CHECKDOTDOT
|PATH_CHECKEXISTS
);
3263 /* Try spelling correction if initial canonicalization fails. Make
3264 sure we are set to replace the directory name with the results so
3265 subsequent directory checks don't fail. */
3266 if (temp2
== 0 && dircomplete_spelling
&& dircomplete_expand
)
3268 temp2
= dirspell (temp1
);
3273 temp2
= sh_canonpath (temp1
, PATH_CHECKDOTDOT
|PATH_CHECKEXISTS
);
3274 return_value
|= temp2
!= 0;
3277 /* If we can't canonicalize, bail. */
3281 return return_value
;
3283 len1
= strlen (temp1
);
3284 if (temp1
[len1
- 1] == '/')
3286 len2
= strlen (temp2
);
3287 if (len2
> 2) /* don't append `/' to `/' or `//' */
3289 temp2
= (char *)xrealloc (temp2
, len2
+ 2);
3291 temp2
[len2
+ 1] = '\0';
3295 /* dircomplete_expand_relpath == 0 means we want to leave relative
3296 pathnames that are unchanged by canonicalization alone.
3297 *local_dirname != '/' && *local_dirname != '.' == relative pathname
3298 (consistent with general.c:absolute_pathname())
3299 temp1 == temp2 (after appending a slash to temp2) means the pathname
3300 is not changed by canonicalization as described above. */
3301 if (dircomplete_expand_relpath
|| ((local_dirname
[0] != '/' && local_dirname
[0] != '.') && STREQ (temp1
, temp2
) == 0))
3302 return_value
|= STREQ (local_dirname
, temp2
) == 0;
3303 free (local_dirname
);
3308 return (return_value
);
3311 static char **history_completion_array
= (char **)NULL
;
3312 static int harry_size
;
3313 static int harry_len
;
3316 build_history_completion_array ()
3322 /* First, clear out the current dynamic history completion list. */
3325 strvec_dispose (history_completion_array
);
3326 history_completion_array
= (char **)NULL
;
3331 /* Next, grovel each line of history, making each shell-sized token
3332 a separate entry in the history_completion_array. */
3333 hlist
= history_list ();
3337 for (i
= 0; hlist
[i
]; i
++)
3339 for ( --i
; i
>= 0; i
--)
3341 /* Separate each token, and place into an array. */
3342 tokens
= history_tokenize (hlist
[i
]->line
);
3344 for (j
= 0; tokens
&& tokens
[j
]; j
++)
3346 if (harry_len
+ 2 > harry_size
)
3347 history_completion_array
= strvec_resize (history_completion_array
, harry_size
+= 10);
3349 history_completion_array
[harry_len
++] = tokens
[j
];
3350 history_completion_array
[harry_len
] = (char *)NULL
;
3355 /* Sort the complete list of tokens. */
3356 if (dabbrev_expand_active
== 0)
3357 qsort (history_completion_array
, harry_len
, sizeof (char *), (QSFUNC
*)strvec_strcmp
);
3362 history_completion_generator (hint_text
, state
)
3363 const char *hint_text
;
3366 static int local_index
, len
;
3367 static const char *text
;
3369 /* If this is the first call to the generator, then initialize the
3370 list of strings to complete over. */
3373 if (dabbrev_expand_active
) /* This is kind of messy */
3374 rl_completion_suppress_append
= 1;
3376 build_history_completion_array ();
3378 len
= strlen (text
);
3381 while (history_completion_array
&& history_completion_array
[local_index
])
3383 if (strncmp (text
, history_completion_array
[local_index
++], len
) == 0)
3384 return (savestring (history_completion_array
[local_index
- 1]));
3386 return ((char *)NULL
);
3390 dynamic_complete_history (count
, key
)
3394 rl_compentry_func_t
*orig_func
;
3395 rl_completion_func_t
*orig_attempt_func
;
3396 rl_compignore_func_t
*orig_ignore_func
;
3398 orig_func
= rl_completion_entry_function
;
3399 orig_attempt_func
= rl_attempted_completion_function
;
3400 orig_ignore_func
= rl_ignore_some_completions_function
;
3402 rl_completion_entry_function
= history_completion_generator
;
3403 rl_attempted_completion_function
= (rl_completion_func_t
*)NULL
;
3404 rl_ignore_some_completions_function
= filename_completion_ignore
;
3406 /* XXX - use rl_completion_mode here? */
3407 if (rl_last_func
== dynamic_complete_history
)
3408 r
= rl_complete_internal ('?');
3410 r
= rl_complete_internal (TAB
);
3412 rl_completion_entry_function
= orig_func
;
3413 rl_attempted_completion_function
= orig_attempt_func
;
3414 rl_ignore_some_completions_function
= orig_ignore_func
;
3420 bash_dabbrev_expand (count
, key
)
3423 int r
, orig_suppress
, orig_sort
;
3424 rl_compentry_func_t
*orig_func
;
3425 rl_completion_func_t
*orig_attempt_func
;
3426 rl_compignore_func_t
*orig_ignore_func
;
3428 orig_func
= rl_menu_completion_entry_function
;
3429 orig_attempt_func
= rl_attempted_completion_function
;
3430 orig_ignore_func
= rl_ignore_some_completions_function
;
3431 orig_suppress
= rl_completion_suppress_append
;
3432 orig_sort
= rl_sort_completion_matches
;
3434 rl_menu_completion_entry_function
= history_completion_generator
;
3435 rl_attempted_completion_function
= (rl_completion_func_t
*)NULL
;
3436 rl_ignore_some_completions_function
= filename_completion_ignore
;
3437 rl_filename_completion_desired
= 0;
3438 rl_completion_suppress_append
= 1;
3439 rl_sort_completion_matches
= 0;
3441 /* XXX - use rl_completion_mode here? */
3442 dabbrev_expand_active
= 1;
3443 if (rl_last_func
== bash_dabbrev_expand
)
3444 rl_last_func
= rl_menu_complete
;
3445 r
= rl_menu_complete (count
, key
);
3446 dabbrev_expand_active
= 0;
3448 rl_last_func
= bash_dabbrev_expand
;
3449 rl_menu_completion_entry_function
= orig_func
;
3450 rl_attempted_completion_function
= orig_attempt_func
;
3451 rl_ignore_some_completions_function
= orig_ignore_func
;
3452 rl_completion_suppress_append
= orig_suppress
;
3453 rl_sort_completion_matches
= orig_sort
;
3458 #if defined (SPECIFIC_COMPLETION_FUNCTIONS)
3460 bash_complete_username (ignore
, ignore2
)
3461 int ignore
, ignore2
;
3463 return bash_complete_username_internal (rl_completion_mode (bash_complete_username
));
3467 bash_possible_username_completions (ignore
, ignore2
)
3468 int ignore
, ignore2
;
3470 return bash_complete_username_internal ('?');
3474 bash_complete_username_internal (what_to_do
)
3477 return bash_specific_completion (what_to_do
, rl_username_completion_function
);
3481 bash_complete_filename (ignore
, ignore2
)
3482 int ignore
, ignore2
;
3484 return bash_complete_filename_internal (rl_completion_mode (bash_complete_filename
));
3488 bash_possible_filename_completions (ignore
, ignore2
)
3489 int ignore
, ignore2
;
3491 return bash_complete_filename_internal ('?');
3495 bash_complete_filename_internal (what_to_do
)
3498 rl_compentry_func_t
*orig_func
;
3499 rl_completion_func_t
*orig_attempt_func
;
3500 rl_icppfunc_t
*orig_dir_func
;
3501 rl_compignore_func_t
*orig_ignore_func
;
3502 /*const*/ char *orig_rl_completer_word_break_characters
;
3505 orig_func
= rl_completion_entry_function
;
3506 orig_attempt_func
= rl_attempted_completion_function
;
3507 orig_ignore_func
= rl_ignore_some_completions_function
;
3508 orig_rl_completer_word_break_characters
= rl_completer_word_break_characters
;
3510 orig_dir_func
= save_directory_hook ();
3512 rl_completion_entry_function
= rl_filename_completion_function
;
3513 rl_attempted_completion_function
= (rl_completion_func_t
*)NULL
;
3514 rl_ignore_some_completions_function
= filename_completion_ignore
;
3515 rl_completer_word_break_characters
= " \t\n\"\'";
3517 r
= rl_complete_internal (what_to_do
);
3519 rl_completion_entry_function
= orig_func
;
3520 rl_attempted_completion_function
= orig_attempt_func
;
3521 rl_ignore_some_completions_function
= orig_ignore_func
;
3522 rl_completer_word_break_characters
= orig_rl_completer_word_break_characters
;
3524 restore_directory_hook (orig_dir_func
);
3530 bash_complete_hostname (ignore
, ignore2
)
3531 int ignore
, ignore2
;
3533 return bash_complete_hostname_internal (rl_completion_mode (bash_complete_hostname
));
3537 bash_possible_hostname_completions (ignore
, ignore2
)
3538 int ignore
, ignore2
;
3540 return bash_complete_hostname_internal ('?');
3544 bash_complete_variable (ignore
, ignore2
)
3545 int ignore
, ignore2
;
3547 return bash_complete_variable_internal (rl_completion_mode (bash_complete_variable
));
3551 bash_possible_variable_completions (ignore
, ignore2
)
3552 int ignore
, ignore2
;
3554 return bash_complete_variable_internal ('?');
3558 bash_complete_command (ignore
, ignore2
)
3559 int ignore
, ignore2
;
3561 return bash_complete_command_internal (rl_completion_mode (bash_complete_command
));
3565 bash_possible_command_completions (ignore
, ignore2
)
3566 int ignore
, ignore2
;
3568 return bash_complete_command_internal ('?');
3572 bash_complete_hostname_internal (what_to_do
)
3575 return bash_specific_completion (what_to_do
, hostname_completion_function
);
3579 bash_complete_variable_internal (what_to_do
)
3582 return bash_specific_completion (what_to_do
, variable_completion_function
);
3586 bash_complete_command_internal (what_to_do
)
3589 return bash_specific_completion (what_to_do
, command_word_completion_function
);
3592 static char *globtext
;
3593 static char *globorig
;
3596 glob_complete_word (text
, state
)
3600 static char **matches
= (char **)NULL
;
3607 rl_filename_completion_desired
= 1;
3609 if (globorig
!= globtext
)
3613 ttext
= bash_tilde_expand (text
, 0);
3615 if (rl_explicit_arg
)
3617 globorig
= savestring (ttext
);
3618 glen
= strlen (ttext
);
3619 globtext
= (char *)xmalloc (glen
+ 2);
3620 strcpy (globtext
, ttext
);
3621 globtext
[glen
] = '*';
3622 globtext
[glen
+1] = '\0';
3625 globtext
= globorig
= savestring (ttext
);
3630 matches
= shell_glob_filename (globtext
);
3631 if (GLOB_FAILED (matches
))
3632 matches
= (char **)NULL
;
3636 ret
= matches
? matches
[ind
] : (char *)NULL
;
3642 bash_glob_completion_internal (what_to_do
)
3645 return bash_specific_completion (what_to_do
, glob_complete_word
);
3648 /* A special quoting function so we don't end up quoting globbing characters
3649 in the word if there are no matches or multiple matches. */
3651 bash_glob_quote_filename (s
, rtype
, qcp
)
3656 if (globorig
&& qcp
&& *qcp
== '\0' && STREQ (s
, globorig
))
3657 return (savestring (s
));
3659 return (bash_quote_filename (s
, rtype
, qcp
));
3663 bash_glob_complete_word (count
, key
)
3667 rl_quote_func_t
*orig_quoting_function
;
3669 if (rl_editing_mode
== EMACS_EDITING_MODE
)
3670 rl_explicit_arg
= 1; /* force `*' append */
3671 orig_quoting_function
= rl_filename_quoting_function
;
3672 rl_filename_quoting_function
= bash_glob_quote_filename
;
3674 r
= bash_glob_completion_internal (rl_completion_mode (bash_glob_complete_word
));
3676 rl_filename_quoting_function
= orig_quoting_function
;
3681 bash_glob_expand_word (count
, key
)
3684 return bash_glob_completion_internal ('*');
3688 bash_glob_list_expansions (count
, key
)
3691 return bash_glob_completion_internal ('?');
3695 bash_specific_completion (what_to_do
, generator
)
3697 rl_compentry_func_t
*generator
;
3699 rl_compentry_func_t
*orig_func
;
3700 rl_completion_func_t
*orig_attempt_func
;
3701 rl_compignore_func_t
*orig_ignore_func
;
3704 orig_func
= rl_completion_entry_function
;
3705 orig_attempt_func
= rl_attempted_completion_function
;
3706 orig_ignore_func
= rl_ignore_some_completions_function
;
3707 rl_completion_entry_function
= generator
;
3708 rl_attempted_completion_function
= NULL
;
3709 rl_ignore_some_completions_function
= orig_ignore_func
;
3711 r
= rl_complete_internal (what_to_do
);
3713 rl_completion_entry_function
= orig_func
;
3714 rl_attempted_completion_function
= orig_attempt_func
;
3715 rl_ignore_some_completions_function
= orig_ignore_func
;
3720 #endif /* SPECIFIC_COMPLETION_FUNCTIONS */
3722 #if defined (VI_MODE)
3723 /* Completion, from vi mode's point of view. This is a modified version of
3724 rl_vi_complete which uses the bash globbing code to implement what POSIX
3725 specifies, which is to append a `*' and attempt filename generation (which
3726 has the side effect of expanding any globbing characters in the word). */
3728 bash_vi_complete (count
, key
)
3731 #if defined (SPECIFIC_COMPLETION_FUNCTIONS)
3735 if ((rl_point
< rl_end
) && (!whitespace (rl_line_buffer
[rl_point
])))
3737 if (!whitespace (rl_line_buffer
[rl_point
+ 1]))
3738 rl_vi_end_word (1, 'E');
3742 /* Find boundaries of current word, according to vi definition of a
3748 rl_vi_bWord (1, 'B');
3753 t
= substring (rl_line_buffer
, p
, rl_point
);
3756 if (t
&& glob_pattern_p (t
) == 0)
3757 rl_explicit_arg
= 1; /* XXX - force glob_complete_word to append `*' */
3760 if (key
== '*') /* Expansion and replacement. */
3761 r
= bash_glob_expand_word (count
, key
);
3762 else if (key
== '=') /* List possible completions. */
3763 r
= bash_glob_list_expansions (count
, key
);
3764 else if (key
== '\\') /* Standard completion */
3765 r
= bash_glob_complete_word (count
, key
);
3767 r
= rl_complete (0, key
);
3769 if (key
== '*' || key
== '\\')
3770 rl_vi_start_inserting (key
, 1, 1);
3774 return rl_vi_complete (count
, key
);
3775 #endif /* !SPECIFIC_COMPLETION_FUNCTIONS */
3777 #endif /* VI_MODE */
3779 /* Filename quoting for completion. */
3780 /* A function to strip unquoted quote characters (single quotes, double
3781 quotes, and backslashes). It allows single quotes to appear
3782 within double quotes, and vice versa. It should be smarter. */
3784 bash_dequote_filename (text
, quote_char
)
3792 ret
= (char *)xmalloc (l
+ 1);
3793 for (quoted
= quote_char
, p
= text
, r
= ret
; p
&& *p
; p
++)
3795 /* Allow backslash-escaped characters to pass through unscathed. */
3798 /* Backslashes are preserved within single quotes. */
3801 /* Backslashes are preserved within double quotes unless the
3802 character is one that is defined to be escaped */
3803 else if (quoted
== '"' && ((sh_syntaxtab
[p
[1]] & CBSDQUOTE
) == 0))
3808 return ret
; /* XXX - was break; */
3812 if (quoted
&& *p
== quoted
)
3818 if (quoted
== 0 && (*p
== '\'' || *p
== '"'))
3829 /* Quote characters that the readline completion code would treat as
3830 word break characters with backslashes. Pass backslash-quoted
3831 characters through without examination. */
3833 quote_word_break_chars (text
)
3840 ret
= (char *)xmalloc ((2 * l
) + 1);
3841 for (s
= text
, r
= ret
; *s
; s
++)
3843 /* Pass backslash-quoted characters through, including the backslash. */
3852 /* OK, we have an unquoted character. Check its presence in
3853 rl_completer_word_break_characters. */
3854 if (mbschr (rl_completer_word_break_characters
, *s
))
3856 /* XXX -- check for standalone tildes here and backslash-quote them */
3857 if (s
== text
&& *s
== '~' && file_exists (text
))
3865 /* Use characters in STRING to populate the table of characters that should
3866 be backslash-quoted. The table will be used for sh_backslash_quote from
3869 set_filename_bstab (string
)
3874 memset (filename_bstab
, 0, sizeof (filename_bstab
));
3875 for (s
= string
; s
&& *s
; s
++)
3876 filename_bstab
[*s
] = 1;
3879 /* Quote a filename using double quotes, single quotes, or backslashes
3880 depending on the value of completion_quoting_style. If we're
3881 completing using backslashes, we need to quote some additional
3882 characters (those that readline treats as word breaks), so we call
3883 quote_word_break_chars on the result. This returns newly-allocated
3886 bash_quote_filename (s
, rtype
, qcp
)
3891 char *rtext
, *mtext
, *ret
;
3894 rtext
= (char *)NULL
;
3896 /* If RTYPE == MULT_MATCH, it means that there is
3897 more than one match. In this case, we do not add
3898 the closing quote or attempt to perform tilde
3899 expansion. If RTYPE == SINGLE_MATCH, we try
3900 to perform tilde expansion, because single and double
3901 quotes inhibit tilde expansion by the shell. */
3903 cs
= completion_quoting_style
;
3904 /* Might need to modify the default completion style based on *qcp,
3905 since it's set to any user-provided opening quote. We also change
3906 to single-quoting if there is no user-provided opening quote and
3907 the word being completed contains newlines, since those are not
3908 quoted correctly using backslashes (a backslash-newline pair is
3909 special to the shell parser). */
3910 if (*qcp
== '\0' && cs
== COMPLETE_BSQUOTE
&& mbschr (s
, '\n'))
3911 cs
= COMPLETE_SQUOTE
;
3912 else if (*qcp
== '"')
3913 cs
= COMPLETE_DQUOTE
;
3914 else if (*qcp
== '\'')
3915 cs
= COMPLETE_SQUOTE
;
3916 #if defined (BANG_HISTORY)
3917 else if (*qcp
== '\0' && history_expansion
&& cs
== COMPLETE_DQUOTE
&&
3918 history_expansion_inhibited
== 0 && mbschr (s
, '!'))
3919 cs
= COMPLETE_BSQUOTE
;
3921 if (*qcp
== '"' && history_expansion
&& cs
== COMPLETE_DQUOTE
&&
3922 history_expansion_inhibited
== 0 && mbschr (s
, '!'))
3924 cs
= COMPLETE_BSQUOTE
;
3929 /* Don't tilde-expand backslash-quoted filenames, since only single and
3930 double quotes inhibit tilde expansion. */
3932 if (mtext
[0] == '~' && rtype
== SINGLE_MATCH
&& cs
!= COMPLETE_BSQUOTE
)
3933 mtext
= bash_tilde_expand (s
, 0);
3937 case COMPLETE_DQUOTE
:
3938 rtext
= sh_double_quote (mtext
);
3940 case COMPLETE_SQUOTE
:
3941 rtext
= sh_single_quote (mtext
);
3943 case COMPLETE_BSQUOTE
:
3944 rtext
= sh_backslash_quote (mtext
, complete_fullquote
? 0 : filename_bstab
, 0);
3951 /* We may need to quote additional characters: those that readline treats
3952 as word breaks that are not quoted by backslash_quote. */
3953 if (rtext
&& cs
== COMPLETE_BSQUOTE
)
3955 mtext
= quote_word_break_chars (rtext
);
3960 /* Leave the opening quote intact. The readline completion code takes
3961 care of avoiding doubled opening quotes. */
3964 rlen
= strlen (rtext
);
3965 ret
= (char *)xmalloc (rlen
+ 1);
3966 strcpy (ret
, rtext
);
3970 ret
= (char *)xmalloc (rlen
= 1);
3974 /* If there are multiple matches, cut off the closing quote. */
3975 if (rtype
== MULT_MATCH
&& cs
!= COMPLETE_BSQUOTE
)
3976 ret
[rlen
- 1] = '\0';
3981 /* Support for binding readline key sequences to Unix commands. */
3982 static Keymap cmd_xmap
;
3993 x
= putc (c
, rl_outstream
);
4000 bash_execute_unix_command (count
, key
)
4001 int count
; /* ignored */
4004 Keymap ckmap
; /* current keymap */
4005 Keymap xkmap
; /* unix command executing keymap */
4006 rl_command_func_t
*func
;
4010 sh_parser_state_t ps
;
4011 char *cmd
, *value
, *l
, *l1
, *ce
;
4013 char ibuf
[INT_STRLEN_BOUND(int) + 1];
4015 /* First, we need to find the right command to execute. This is tricky,
4016 because we might have already indirected into another keymap, so we
4017 have to walk cmd_xmap using the entire key sequence. */
4018 cmd
= (char *)rl_function_of_keyseq (rl_executing_keyseq
, cmd_xmap
, &type
);
4020 if (cmd
== 0 || type
!= ISMACR
)
4023 internal_error (_("bash_execute_unix_command: cannot find keymap for command"));
4024 rl_forced_update_display ();
4028 ce
= rl_get_termcap ("ce");
4029 if (ce
) /* clear current line */
4031 fprintf (rl_outstream
, "\r");
4032 tputs (ce
, 1, putx
);
4033 fflush (rl_outstream
);
4036 rl_crlf (); /* move to a new line */
4038 v
= bind_variable ("READLINE_LINE", rl_line_buffer
, 0);
4040 VSETATTR (v
, att_exported
);
4041 l
= v
? value_cell (v
) : 0;
4042 value
= inttostr (rl_point
, ibuf
, sizeof (ibuf
));
4043 v
= bind_int_variable ("READLINE_POINT", value
);
4045 VSETATTR (v
, att_exported
);
4046 array_needs_making
= 1;
4048 save_parser_state (&ps
);
4049 r
= parse_and_execute (cmd
, "bash_execute_unix_command", SEVAL_NOHIST
|SEVAL_NOFREE
);
4050 restore_parser_state (&ps
);
4052 v
= find_variable ("READLINE_LINE");
4053 l1
= v
? value_cell (v
) : 0;
4055 maybe_make_readline_line (value_cell (v
));
4056 v
= find_variable ("READLINE_POINT");
4057 if (v
&& legal_number (value_cell (v
), &mi
))
4063 if (rl_point
> rl_end
)
4065 else if (rl_point
< 0)
4070 unbind_variable ("READLINE_LINE");
4071 unbind_variable ("READLINE_POINT");
4072 array_needs_making
= 1;
4074 /* and restore the readline buffer and display after command execution. */
4075 rl_forced_update_display ();
4080 print_unix_command_map ()
4084 save
= rl_get_keymap ();
4085 rl_set_keymap (cmd_xmap
);
4086 rl_macro_dumper (1);
4087 rl_set_keymap (save
);
4092 init_unix_command_map ()
4094 cmd_xmap
= rl_make_bare_keymap ();
4098 isolate_sequence (string
, ind
, need_dquote
, startp
)
4100 int ind
, need_dquote
, *startp
;
4103 int c
, passc
, delim
;
4105 for (i
= ind
; string
[i
] && whitespace (string
[i
]); i
++)
4107 /* NEED_DQUOTE means that the first non-white character *must* be `"'. */
4108 if (need_dquote
&& string
[i
] != '"')
4110 builtin_error (_("%s: first non-whitespace character is not `\"'"), string
);
4114 /* We can have delimited strings even if NEED_DQUOTE == 0, like the command
4115 string to bind the key sequence to. */
4116 delim
= (string
[i
] == '"' || string
[i
] == '\'') ? string
[i
] : 0;
4119 *startp
= delim
? ++i
: i
;
4121 for (passc
= 0; c
= string
[i
]; i
++)
4137 if (delim
&& string
[i
] != delim
)
4139 builtin_error (_("no closing `%c' in %s"), delim
, string
);
4147 bind_keyseq_to_unix_command (line
)
4155 init_unix_command_map ();
4157 kmap
= rl_get_keymap ();
4159 /* We duplicate some of the work done by rl_parse_and_bind here, but
4160 this code only has to handle `"keyseq": ["]command["]' and can
4161 generate an error for anything else. */
4162 i
= isolate_sequence (line
, 0, 1, &kstart
);
4166 /* Create the key sequence string to pass to rl_generic_bind */
4167 kseq
= substring (line
, kstart
, i
);
4169 for ( ; line
[i
] && line
[i
] != ':'; i
++)
4173 builtin_error (_("%s: missing colon separator"), line
);
4178 i
= isolate_sequence (line
, i
+ 1, 0, &kstart
);
4185 /* Create the value string containing the command to execute. */
4186 value
= substring (line
, kstart
, i
);
4188 /* Save the command to execute and the key sequence in the CMD_XMAP */
4189 rl_generic_bind (ISMACR
, kseq
, value
, cmd_xmap
);
4191 /* and bind the key sequence in the current keymap to a function that
4192 understands how to execute from CMD_XMAP */
4193 rl_bind_keyseq_in_map (kseq
, bash_execute_unix_command
, kmap
);
4199 /* Used by the programmable completion code. Complete TEXT as a filename,
4200 but return only directories as matches. Dequotes the filename before
4201 attempting to find matches. */
4203 bash_directory_completion_matches (text
)
4210 qc
= rl_dispatching
? rl_completion_quote_character
: 0;
4211 dfn
= bash_dequote_filename ((char *)text
, qc
);
4212 m1
= rl_completion_matches (dfn
, rl_filename_completion_function
);
4215 if (m1
== 0 || m1
[0] == 0)
4217 /* We don't bother recomputing the lcd of the matches, because it will just
4218 get thrown away by the programmable completion code and recomputed
4220 (void)bash_ignore_filenames (m1
);
4225 bash_dequote_text (text
)
4231 qc
= (text
[0] == '"' || text
[0] == '\'') ? text
[0] : 0;
4232 dtxt
= bash_dequote_filename ((char *)text
, qc
);
4236 /* This event hook is designed to be called after readline receives a signal
4237 that interrupts read(2). It gives reasonable responsiveness to interrupts
4238 and fatal signals without executing too much code in a signal handler
4243 /* If we're going to longjmp to top_level, make sure we clean up readline.
4244 check_signals will call QUIT, which will eventually longjmp to top_level,
4245 calling run_interrupt_trap along the way. */
4246 if (interrupt_state
)
4247 rl_cleanup_after_signal ();
4248 bashline_reset_event_hook ();
4249 check_signals_and_traps (); /* XXX */
4253 #endif /* READLINE */