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 #if defined (HAVE_MBSTR_H) && defined (HAVE_MBSCHR)
59 # include <mbstr.h> /* mbschr */
62 #include "builtins/common.h"
64 #include <readline/rlconf.h>
65 #include <readline/readline.h>
66 #include <readline/history.h>
68 #include <glob/glob.h>
74 #if defined (PROGRAMMABLE_COMPLETION)
75 # include "pcomplete.h"
78 /* These should agree with the defines for emacs_mode and vi_mode in
79 rldefs.h, even though that's not a public readline header file. */
80 #ifndef EMACS_EDITING_MODE
81 # define NO_EDITING_MODE -1
82 # define EMACS_EDITING_MODE 1
83 # define VI_EDITING_MODE 0
86 #define RL_BOOLEAN_VARIABLE_VALUE(s) ((s)[0] == 'o' && (s)[1] == 'n' && (s)[2] == '\0')
88 #if defined (BRACE_COMPLETION)
89 extern int bash_brace_completion
__P((int, int));
90 #endif /* BRACE_COMPLETION */
92 /* To avoid including curses.h/term.h/termcap.h and that whole mess. */
94 extern int tputs
__P((const char *string
, int nlines
, void (*outx
)(int)));
96 extern int tputs
__P((const char *string
, int nlines
, int (*outx
)(int)));
99 /* Forward declarations */
101 /* Functions bound to keys in Readline for Bash users. */
102 static int shell_expand_line
__P((int, int));
103 static int display_shell_version
__P((int, int));
104 static int operate_and_get_next
__P((int, int));
106 static int bash_ignore_filenames
__P((char **));
107 static int bash_ignore_everything
__P((char **));
109 #if defined (BANG_HISTORY)
110 static char *history_expand_line_internal
__P((char *));
111 static int history_expand_line
__P((int, int));
112 static int tcsh_magic_space
__P((int, int));
113 #endif /* BANG_HISTORY */
115 static int alias_expand_line
__P((int, int));
117 #if defined (BANG_HISTORY) && defined (ALIAS)
118 static int history_and_alias_expand_line
__P((int, int));
121 static int bash_forward_shellword
__P((int, int));
122 static int bash_backward_shellword
__P((int, int));
123 static int bash_kill_shellword
__P((int, int));
124 static int bash_backward_kill_shellword
__P((int, int));
126 /* Helper functions for Readline. */
127 static char *restore_tilde
__P((char *, char *));
128 static char *maybe_restore_tilde
__P((char *, char *));
130 static char *bash_filename_rewrite_hook
__P((char *, int));
132 static void bash_directory_expansion
__P((char **));
133 static int bash_filename_stat_hook
__P((char **));
134 static int bash_command_name_stat_hook
__P((char **));
135 static int bash_directory_completion_hook
__P((char **));
136 static int filename_completion_ignore
__P((char **));
137 static int bash_push_line
__P((void));
139 static int executable_completion
__P((const char *, int));
141 static rl_icppfunc_t
*save_directory_hook
__P((void));
142 static void restore_directory_hook
__P((rl_icppfunc_t
));
144 static int directory_exists
__P((const char *));
146 static void cleanup_expansion_error
__P((void));
147 static void maybe_make_readline_line
__P((char *));
148 static void set_up_new_line
__P((char *));
150 static int check_redir
__P((int));
151 static char **attempt_shell_completion
__P((const char *, int, int));
152 static char *variable_completion_function
__P((const char *, int));
153 static char *hostname_completion_function
__P((const char *, int));
154 static char *command_subst_completion_function
__P((const char *, int));
156 static void build_history_completion_array
__P((void));
157 static char *history_completion_generator
__P((const char *, int));
158 static int dynamic_complete_history
__P((int, int));
159 static int bash_dabbrev_expand
__P((int, int));
161 static void initialize_hostname_list
__P((void));
162 static void add_host_name
__P((char *));
163 static void snarf_hosts_from_file
__P((char *));
164 static char **hostnames_matching
__P((char *));
166 static void _ignore_completion_names
__P((char **, sh_ignore_func_t
*));
167 static int name_is_acceptable
__P((const char *));
168 static int test_for_directory
__P((const char *));
169 static int return_zero
__P((const char *));
171 static char *bash_dequote_filename
__P((char *, int));
172 static char *quote_word_break_chars
__P((char *));
173 static void set_filename_bstab
__P((const char *));
174 static char *bash_quote_filename
__P((char *, int, char *));
177 static void putx
__P((int));
179 static int putx
__P((int));
181 static int bash_execute_unix_command
__P((int, int));
182 static void init_unix_command_map
__P((void));
183 static int isolate_sequence
__P((char *, int, int, int *));
185 static int set_saved_history
__P((void));
188 static int posix_edit_macros
__P((int, int));
191 static int bash_event_hook
__P((void));
193 #if defined (PROGRAMMABLE_COMPLETION)
194 static int find_cmd_start
__P((int));
195 static int find_cmd_end
__P((int));
196 static char *find_cmd_name
__P((int, int *, int *));
197 static char *prog_complete_return
__P((const char *, int));
199 static char **prog_complete_matches
;
202 /* Variables used here but defined in other files. */
203 #if defined (BANG_HISTORY)
204 extern int hist_verify
;
207 extern int current_command_line_count
, saved_command_line_count
;
208 extern int last_command_exit_value
;
209 extern int array_needs_making
;
210 extern int posixly_correct
, no_symbolic_links
;
211 extern int sigalrm_seen
;
212 extern char *current_prompt_string
, *ps1_prompt
;
213 extern STRING_INT_ALIST word_token_alist
[];
214 extern sh_builtin_func_t
*last_shell_builtin
, *this_shell_builtin
;
216 /* SPECIFIC_COMPLETION_FUNCTIONS specifies that we have individual
217 completion functions which indicate what type of completion should be
218 done (at or before point) that can be bound to key sequences with
219 the readline library. */
220 #define SPECIFIC_COMPLETION_FUNCTIONS
222 #if defined (SPECIFIC_COMPLETION_FUNCTIONS)
223 static int bash_specific_completion
__P((int, rl_compentry_func_t
*));
225 static int bash_complete_filename_internal
__P((int));
226 static int bash_complete_username_internal
__P((int));
227 static int bash_complete_hostname_internal
__P((int));
228 static int bash_complete_variable_internal
__P((int));
229 static int bash_complete_command_internal
__P((int));
231 static int bash_complete_filename
__P((int, int));
232 static int bash_possible_filename_completions
__P((int, int));
233 static int bash_complete_username
__P((int, int));
234 static int bash_possible_username_completions
__P((int, int));
235 static int bash_complete_hostname
__P((int, int));
236 static int bash_possible_hostname_completions
__P((int, int));
237 static int bash_complete_variable
__P((int, int));
238 static int bash_possible_variable_completions
__P((int, int));
239 static int bash_complete_command
__P((int, int));
240 static int bash_possible_command_completions
__P((int, int));
242 static char *glob_complete_word
__P((const char *, int));
243 static int bash_glob_completion_internal
__P((int));
244 static int bash_glob_complete_word
__P((int, int));
245 static int bash_glob_expand_word
__P((int, int));
246 static int bash_glob_list_expansions
__P((int, int));
248 #endif /* SPECIFIC_COMPLETION_FUNCTIONS */
250 static int edit_and_execute_command
__P((int, int, int, char *));
251 #if defined (VI_MODE)
252 static int vi_edit_and_execute_command
__P((int, int));
253 static int bash_vi_complete
__P((int, int));
255 static int emacs_edit_and_execute_command
__P((int, int));
257 /* Non-zero once initalize_readline () has been called. */
258 int bash_readline_initialized
= 0;
260 /* If non-zero, we do hostname completion, breaking words at `@' and
261 trying to complete the stuff after the `@' from our own internal
263 int perform_hostname_completion
= 1;
265 /* If non-zero, we don't do command completion on an empty line. */
266 int no_empty_command_completion
;
268 /* Set FORCE_FIGNORE if you want to honor FIGNORE even if it ignores the
269 only possible matches. Set to 0 if you want to match filenames if they
270 are the only possible matches, even if FIGNORE says to. */
271 int force_fignore
= 1;
273 /* Perform spelling correction on directory names during word completion */
274 int dircomplete_spelling
= 0;
276 /* Expand directory names during word/filename completion. */
277 #if DIRCOMPLETE_EXPAND_DEFAULT
278 int dircomplete_expand
= 1;
279 int dircomplete_expand_relpath
= 1;
281 int dircomplete_expand
= 0;
282 int dircomplete_expand_relpath
= 0;
285 /* When non-zero, perform `normal' shell quoting on completed filenames
286 even when the completed name contains a directory name with a shell
287 variable referene, so dollar signs in a filename get quoted appropriately.
288 Set to zero to remove dollar sign (and braces or parens as needed) from
289 the set of characters that will be quoted. */
290 int complete_fullquote
= 1;
292 static char *bash_completer_word_break_characters
= " \t\n\"'@><=;|&(:";
293 static char *bash_nohostname_word_break_characters
= " \t\n\"'><=;|&(:";
296 static const char *default_filename_quote_characters
= " \t\n\\\"'@<>=;|&()#$`?*[!:{~"; /*}*/
297 static char *custom_filename_quote_characters
= 0;
298 static char filename_bstab
[256];
300 static rl_hook_func_t
*old_rl_startup_hook
= (rl_hook_func_t
*)NULL
;
302 static int dot_in_path
= 0;
304 /* Set to non-zero when dabbrev-expand is running */
305 static int dabbrev_expand_active
= 0;
307 /* What kind of quoting is performed by bash_quote_filename:
308 COMPLETE_DQUOTE = double-quoting the filename
309 COMPLETE_SQUOTE = single_quoting the filename
310 COMPLETE_BSQUOTE = backslash-quoting special chars in the filename
312 #define COMPLETE_DQUOTE 1
313 #define COMPLETE_SQUOTE 2
314 #define COMPLETE_BSQUOTE 3
315 static int completion_quoting_style
= COMPLETE_BSQUOTE
;
317 /* Flag values for the final argument to bash_default_completion */
318 #define DEFCOMP_CMDPOS 1
320 /* Change the readline VI-mode keymaps into or out of Posix.2 compliance.
321 Called when the shell is put into or out of `posix' mode. */
323 posix_readline_initialize (on_or_off
)
327 rl_variable_bind ("comment-begin", "#");
328 #if defined (VI_MODE)
329 rl_bind_key_in_map (CTRL ('I'), on_or_off
? rl_insert
: rl_complete
, vi_insertion_keymap
);
334 reset_completer_word_break_chars ()
336 rl_completer_word_break_characters
= perform_hostname_completion
? savestring (bash_completer_word_break_characters
) : savestring (bash_nohostname_word_break_characters
);
339 /* When this function returns, rl_completer_word_break_characters points to
340 dynamically allocated memory. */
342 enable_hostname_completion (on_or_off
)
346 char *at
, *nv
, *nval
;
348 old_value
= perform_hostname_completion
;
352 perform_hostname_completion
= 1;
353 rl_special_prefixes
= "$@";
357 perform_hostname_completion
= 0;
358 rl_special_prefixes
= "$";
361 /* Now we need to figure out how to appropriately modify and assign
362 rl_completer_word_break_characters depending on whether we want
363 hostname completion on or off. */
365 /* If this is the first time this has been called
366 (bash_readline_initialized == 0), use the sames values as before, but
367 allocate new memory for rl_completer_word_break_characters. */
369 if (bash_readline_initialized
== 0 &&
370 (rl_completer_word_break_characters
== 0 ||
371 rl_completer_word_break_characters
== rl_basic_word_break_characters
))
374 rl_completer_word_break_characters
= savestring (bash_completer_word_break_characters
);
376 rl_completer_word_break_characters
= savestring (bash_nohostname_word_break_characters
);
380 /* See if we have anything to do. */
381 at
= strchr (rl_completer_word_break_characters
, '@');
382 if ((at
== 0 && on_or_off
== 0) || (at
!= 0 && on_or_off
!= 0))
385 /* We have something to do. Do it. */
386 nval
= (char *)xmalloc (strlen (rl_completer_word_break_characters
) + 1 + on_or_off
);
390 /* Turn it off -- just remove `@' from word break chars. We want
391 to remove all occurrences of `@' from the char list, so we loop
392 rather than just copy the rest of the list over AT. */
393 for (nv
= nval
, at
= rl_completer_word_break_characters
; *at
; )
403 strcpy (nval
+ 1, rl_completer_word_break_characters
);
406 free (rl_completer_word_break_characters
);
407 rl_completer_word_break_characters
= nval
;
413 /* Called once from parse.y if we are going to use readline. */
415 initialize_readline ()
417 rl_command_func_t
*func
;
420 if (bash_readline_initialized
)
423 rl_terminal_name
= get_string_value ("TERM");
425 rl_outstream
= stderr
;
427 /* Allow conditional parsing of the ~/.inputrc file. */
428 rl_readline_name
= "Bash";
430 /* Add bindable names before calling rl_initialize so they may be
431 referenced in the various inputrc files. */
432 rl_add_defun ("shell-expand-line", shell_expand_line
, -1);
434 rl_add_defun ("history-expand-line", history_expand_line
, -1);
435 rl_add_defun ("magic-space", tcsh_magic_space
, -1);
438 rl_add_defun ("shell-forward-word", bash_forward_shellword
, -1);
439 rl_add_defun ("shell-backward-word", bash_backward_shellword
, -1);
440 rl_add_defun ("shell-kill-word", bash_kill_shellword
, -1);
441 rl_add_defun ("shell-backward-kill-word", bash_backward_kill_shellword
, -1);
444 rl_add_defun ("alias-expand-line", alias_expand_line
, -1);
446 rl_add_defun ("history-and-alias-expand-line", history_and_alias_expand_line
, -1);
450 /* Backwards compatibility. */
451 rl_add_defun ("insert-last-argument", rl_yank_last_arg
, -1);
453 rl_add_defun ("operate-and-get-next", operate_and_get_next
, -1);
454 rl_add_defun ("display-shell-version", display_shell_version
, -1);
455 rl_add_defun ("edit-and-execute-command", emacs_edit_and_execute_command
, -1);
457 #if defined (BRACE_COMPLETION)
458 rl_add_defun ("complete-into-braces", bash_brace_completion
, -1);
461 #if defined (SPECIFIC_COMPLETION_FUNCTIONS)
462 rl_add_defun ("complete-filename", bash_complete_filename
, -1);
463 rl_add_defun ("possible-filename-completions", bash_possible_filename_completions
, -1);
464 rl_add_defun ("complete-username", bash_complete_username
, -1);
465 rl_add_defun ("possible-username-completions", bash_possible_username_completions
, -1);
466 rl_add_defun ("complete-hostname", bash_complete_hostname
, -1);
467 rl_add_defun ("possible-hostname-completions", bash_possible_hostname_completions
, -1);
468 rl_add_defun ("complete-variable", bash_complete_variable
, -1);
469 rl_add_defun ("possible-variable-completions", bash_possible_variable_completions
, -1);
470 rl_add_defun ("complete-command", bash_complete_command
, -1);
471 rl_add_defun ("possible-command-completions", bash_possible_command_completions
, -1);
472 rl_add_defun ("glob-complete-word", bash_glob_complete_word
, -1);
473 rl_add_defun ("glob-expand-word", bash_glob_expand_word
, -1);
474 rl_add_defun ("glob-list-expansions", bash_glob_list_expansions
, -1);
477 rl_add_defun ("dynamic-complete-history", dynamic_complete_history
, -1);
478 rl_add_defun ("dabbrev-expand", bash_dabbrev_expand
, -1);
480 /* Bind defaults before binding our custom shell keybindings. */
481 if (RL_ISSTATE(RL_STATE_INITIALIZED
) == 0)
484 /* Bind up our special shell functions. */
485 rl_bind_key_if_unbound_in_map (CTRL('E'), shell_expand_line
, emacs_meta_keymap
);
488 rl_bind_key_if_unbound_in_map ('^', history_expand_line
, emacs_meta_keymap
);
491 rl_bind_key_if_unbound_in_map (CTRL ('O'), operate_and_get_next
, emacs_standard_keymap
);
492 rl_bind_key_if_unbound_in_map (CTRL ('V'), display_shell_version
, emacs_ctlx_keymap
);
494 /* In Bash, the user can switch editing modes with "set -o [vi emacs]",
495 so it is not necessary to allow C-M-j for context switching. Turn
496 off this occasionally confusing behaviour. */
499 func
= rl_function_of_keyseq (kseq
, emacs_meta_keymap
, (int *)NULL
);
500 if (func
== rl_vi_editing_mode
)
501 rl_unbind_key_in_map (CTRL('J'), emacs_meta_keymap
);
503 func
= rl_function_of_keyseq (kseq
, emacs_meta_keymap
, (int *)NULL
);
504 if (func
== rl_vi_editing_mode
)
505 rl_unbind_key_in_map (CTRL('M'), emacs_meta_keymap
);
506 #if defined (VI_MODE)
507 rl_unbind_key_in_map (CTRL('E'), vi_movement_keymap
);
510 #if defined (BRACE_COMPLETION)
511 rl_bind_key_if_unbound_in_map ('{', bash_brace_completion
, emacs_meta_keymap
); /*}*/
512 #endif /* BRACE_COMPLETION */
514 #if defined (SPECIFIC_COMPLETION_FUNCTIONS)
515 rl_bind_key_if_unbound_in_map ('/', bash_complete_filename
, emacs_meta_keymap
);
516 rl_bind_key_if_unbound_in_map ('/', bash_possible_filename_completions
, emacs_ctlx_keymap
);
518 /* Have to jump through hoops here because there is a default binding for
519 M-~ (rl_tilde_expand) */
522 func
= rl_function_of_keyseq (kseq
, emacs_meta_keymap
, (int *)NULL
);
523 if (func
== 0 || func
== rl_tilde_expand
)
524 rl_bind_keyseq_in_map (kseq
, bash_complete_username
, emacs_meta_keymap
);
526 rl_bind_key_if_unbound_in_map ('~', bash_possible_username_completions
, emacs_ctlx_keymap
);
528 rl_bind_key_if_unbound_in_map ('@', bash_complete_hostname
, emacs_meta_keymap
);
529 rl_bind_key_if_unbound_in_map ('@', bash_possible_hostname_completions
, emacs_ctlx_keymap
);
531 rl_bind_key_if_unbound_in_map ('$', bash_complete_variable
, emacs_meta_keymap
);
532 rl_bind_key_if_unbound_in_map ('$', bash_possible_variable_completions
, emacs_ctlx_keymap
);
534 rl_bind_key_if_unbound_in_map ('!', bash_complete_command
, emacs_meta_keymap
);
535 rl_bind_key_if_unbound_in_map ('!', bash_possible_command_completions
, emacs_ctlx_keymap
);
537 rl_bind_key_if_unbound_in_map ('g', bash_glob_complete_word
, emacs_meta_keymap
);
538 rl_bind_key_if_unbound_in_map ('*', bash_glob_expand_word
, emacs_ctlx_keymap
);
539 rl_bind_key_if_unbound_in_map ('g', bash_glob_list_expansions
, emacs_ctlx_keymap
);
541 #endif /* SPECIFIC_COMPLETION_FUNCTIONS */
545 func
= rl_function_of_keyseq (kseq
, emacs_meta_keymap
, (int *)NULL
);
546 if (func
== 0 || func
== rl_tab_insert
)
547 rl_bind_key_in_map (TAB
, dynamic_complete_history
, emacs_meta_keymap
);
549 /* Tell the completer that we want a crack first. */
550 rl_attempted_completion_function
= attempt_shell_completion
;
552 /* Tell the completer that we might want to follow symbolic links or
553 do other expansion on directory names. */
554 set_directory_hook ();
556 rl_filename_rewrite_hook
= bash_filename_rewrite_hook
;
558 rl_filename_stat_hook
= bash_filename_stat_hook
;
560 /* Tell the filename completer we want a chance to ignore some names. */
561 rl_ignore_some_completions_function
= filename_completion_ignore
;
563 /* Bind C-xC-e to invoke emacs and run result as commands. */
564 rl_bind_key_if_unbound_in_map (CTRL ('E'), emacs_edit_and_execute_command
, emacs_ctlx_keymap
);
565 #if defined (VI_MODE)
566 rl_bind_key_if_unbound_in_map ('v', vi_edit_and_execute_command
, vi_movement_keymap
);
568 rl_bind_key_if_unbound_in_map ('@', posix_edit_macros
, vi_movement_keymap
);
571 rl_bind_key_in_map ('\\', bash_vi_complete
, vi_movement_keymap
);
572 rl_bind_key_in_map ('*', bash_vi_complete
, vi_movement_keymap
);
573 rl_bind_key_in_map ('=', bash_vi_complete
, vi_movement_keymap
);
576 rl_completer_quote_characters
= "'\"";
578 /* This sets rl_completer_word_break_characters and rl_special_prefixes
579 to the appropriate values, depending on whether or not hostname
580 completion is enabled. */
581 enable_hostname_completion (perform_hostname_completion
);
583 /* characters that need to be quoted when appearing in filenames. */
584 rl_filename_quote_characters
= default_filename_quote_characters
;
585 set_filename_bstab (rl_filename_quote_characters
);
587 rl_filename_quoting_function
= bash_quote_filename
;
588 rl_filename_dequoting_function
= bash_dequote_filename
;
589 rl_char_is_quoted_p
= char_is_quoted
;
592 /* This is superfluous and makes it impossible to use tab completion in
593 vi mode even when explicitly binding it in ~/.inputrc. sv_strict_posix()
594 should already have called posix_readline_initialize() when
595 posixly_correct was set. */
597 posix_readline_initialize (1);
600 bash_readline_initialized
= 1;
604 bashline_reinitialize ()
606 bash_readline_initialized
= 0;
610 bashline_set_event_hook ()
612 rl_signal_event_hook
= bash_event_hook
;
616 bashline_reset_event_hook ()
618 rl_signal_event_hook
= 0;
621 /* On Sun systems at least, rl_attempted_completion_function can end up
622 getting set to NULL, and rl_completion_entry_function set to do command
623 word completion if Bash is interrupted while trying to complete a command
624 word. This just resets all the completion functions to the right thing.
625 It's called from throw_to_top_level(). */
630 rl_attempted_completion_function
= attempt_shell_completion
;
631 rl_completion_entry_function
= NULL
;
632 rl_ignore_some_completions_function
= filename_completion_ignore
;
633 rl_filename_quote_characters
= default_filename_quote_characters
;
634 set_filename_bstab (rl_filename_quote_characters
);
636 set_directory_hook ();
637 rl_filename_stat_hook
= bash_filename_stat_hook
;
639 bashline_reset_event_hook ();
641 rl_sort_completion_matches
= 1;
644 /* Contains the line to push into readline. */
645 static char *push_to_readline
= (char *)NULL
;
647 /* Push the contents of push_to_readline into the
652 if (push_to_readline
)
654 rl_insert_text (push_to_readline
);
655 free (push_to_readline
);
656 push_to_readline
= (char *)NULL
;
657 rl_startup_hook
= old_rl_startup_hook
;
662 /* Call this to set the initial text for the next line to read
668 FREE (push_to_readline
);
670 push_to_readline
= savestring (line
);
671 old_rl_startup_hook
= rl_startup_hook
;
672 rl_startup_hook
= bash_push_line
;
678 display_shell_version (count
, c
)
682 show_shell_version (0);
683 putc ('\r', rl_outstream
);
684 fflush (rl_outstream
);
690 /* **************************************************************** */
694 /* **************************************************************** */
696 /* If the user requests hostname completion, then simply build a list
697 of hosts, and complete from that forever more, or at least until
698 HOSTFILE is unset. */
700 /* THIS SHOULD BE A STRINGLIST. */
701 /* The kept list of hostnames. */
702 static char **hostname_list
= (char **)NULL
;
704 /* The physical size of the above list. */
705 static int hostname_list_size
;
707 /* The number of hostnames in the above list. */
708 static int hostname_list_length
;
710 /* Whether or not HOSTNAME_LIST has been initialized. */
711 int hostname_list_initialized
= 0;
713 /* Initialize the hostname completion table. */
715 initialize_hostname_list ()
719 temp
= get_string_value ("HOSTFILE");
721 temp
= get_string_value ("hostname_completion_file");
723 temp
= DEFAULT_HOSTS_FILE
;
725 snarf_hosts_from_file (temp
);
728 hostname_list_initialized
++;
731 /* Add NAME to the list of hosts. */
736 if (hostname_list_length
+ 2 > hostname_list_size
)
738 hostname_list_size
= (hostname_list_size
+ 32) - (hostname_list_size
% 32);
739 hostname_list
= strvec_resize (hostname_list
, hostname_list_size
);
742 hostname_list
[hostname_list_length
++] = savestring (name
);
743 hostname_list
[hostname_list_length
] = (char *)NULL
;
746 #define cr_whitespace(c) ((c) == '\r' || (c) == '\n' || whitespace(c))
749 snarf_hosts_from_file (filename
)
753 char *temp
, buffer
[256], name
[256];
754 register int i
, start
;
756 file
= fopen (filename
, "r");
760 while (temp
= fgets (buffer
, 255, file
))
762 /* Skip to first character. */
763 for (i
= 0; buffer
[i
] && cr_whitespace (buffer
[i
]); i
++)
766 /* If comment or blank line, ignore. */
767 if (buffer
[i
] == '\0' || buffer
[i
] == '#')
770 /* If `preprocessor' directive, do the include. */
771 if (strncmp (buffer
+ i
, "$include ", 9) == 0)
775 /* Find start of filename. */
776 for (incfile
= buffer
+ i
+ 9; *incfile
&& whitespace (*incfile
); incfile
++)
779 /* Find end of filename. */
780 for (t
= incfile
; *t
&& cr_whitespace (*t
) == 0; t
++)
785 snarf_hosts_from_file (incfile
);
789 /* Skip internet address if present. */
790 if (DIGIT (buffer
[i
]))
791 for (; buffer
[i
] && cr_whitespace (buffer
[i
]) == 0; i
++);
793 /* Gobble up names. Each name is separated with whitespace. */
796 for (; cr_whitespace (buffer
[i
]); i
++)
798 if (buffer
[i
] == '\0' || buffer
[i
] == '#')
801 /* Isolate the current word. */
802 for (start
= i
; buffer
[i
] && cr_whitespace (buffer
[i
]) == 0; i
++)
806 strncpy (name
, buffer
+ start
, i
- start
);
807 name
[i
- start
] = '\0';
808 add_host_name (name
);
814 /* Return the hostname list. */
818 if (hostname_list_initialized
== 0)
819 initialize_hostname_list ();
820 return (hostname_list
);
824 clear_hostname_list ()
828 if (hostname_list_initialized
== 0)
830 for (i
= 0; i
< hostname_list_length
; i
++)
831 free (hostname_list
[i
]);
832 hostname_list_length
= hostname_list_initialized
= 0;
835 /* Return a NULL terminated list of hostnames which begin with TEXT.
836 Initialize the hostname list the first time if necessary.
837 The array is malloc ()'ed, but not the individual strings. */
839 hostnames_matching (text
)
842 register int i
, len
, nmatch
, rsize
;
845 if (hostname_list_initialized
== 0)
846 initialize_hostname_list ();
848 if (hostname_list_initialized
== 0)
849 return ((char **)NULL
);
851 /* Special case. If TEXT consists of nothing, then the whole list is
855 result
= strvec_create (1 + hostname_list_length
);
856 for (i
= 0; i
< hostname_list_length
; i
++)
857 result
[i
] = hostname_list
[i
];
858 result
[i
] = (char *)NULL
;
862 /* Scan until found, or failure. */
864 result
= (char **)NULL
;
865 for (i
= nmatch
= rsize
= 0; i
< hostname_list_length
; i
++)
867 if (STREQN (text
, hostname_list
[i
], len
) == 0)
870 /* OK, it matches. Add it to the list. */
871 if (nmatch
>= (rsize
- 1))
873 rsize
= (rsize
+ 16) - (rsize
% 16);
874 result
= strvec_resize (result
, rsize
);
877 result
[nmatch
++] = hostname_list
[i
];
880 result
[nmatch
] = (char *)NULL
;
884 /* The equivalent of the Korn shell C-o operate-and-get-next-history-line
886 static int saved_history_line_to_use
= -1;
887 static int last_saved_history_line
= -1;
889 #define HISTORY_FULL() (history_is_stifled () && history_length >= history_max_entries)
894 /* XXX - compensate for assumption that history was `shuffled' if it was
896 if (HISTORY_FULL () &&
897 hist_last_line_added
== 0 &&
898 saved_history_line_to_use
< history_length
- 1)
899 saved_history_line_to_use
++;
901 if (saved_history_line_to_use
>= 0)
903 rl_get_previous_history (history_length
- saved_history_line_to_use
, 0);
904 last_saved_history_line
= saved_history_line_to_use
;
906 saved_history_line_to_use
= -1;
907 rl_startup_hook
= old_rl_startup_hook
;
912 operate_and_get_next (count
, c
)
917 /* Accept the current line. */
920 /* Find the current line, and find the next line to use. */
921 where
= where_history ();
923 if (HISTORY_FULL () || (where
>= history_length
- 1))
924 saved_history_line_to_use
= where
;
926 saved_history_line_to_use
= where
+ 1;
928 old_rl_startup_hook
= rl_startup_hook
;
929 rl_startup_hook
= set_saved_history
;
934 /* This vi mode command causes VI_EDIT_COMMAND to be run on the current
935 command being entered (if no explicit argument is given), otherwise on
936 a command from the history file. */
938 #define VI_EDIT_COMMAND "fc -e \"${VISUAL:-${EDITOR:-vi}}\""
939 #define EMACS_EDIT_COMMAND "fc -e \"${VISUAL:-${EDITOR:-emacs}}\""
940 #define POSIX_VI_EDIT_COMMAND "fc -e vi"
943 edit_and_execute_command (count
, c
, editing_mode
, edit_command
)
944 int count
, c
, editing_mode
;
947 char *command
, *metaval
;
948 int r
, rrs
, metaflag
;
949 sh_parser_state_t ps
;
951 rrs
= rl_readline_state
;
952 saved_command_line_count
= current_command_line_count
;
954 /* Accept the current line. */
959 command
= (char *)xmalloc (strlen (edit_command
) + 8);
960 sprintf (command
, "%s %d", edit_command
, count
);
964 /* Take the command we were just editing, add it to the history file,
965 then call fc to operate on it. We have to add a dummy command to
966 the end of the history because fc ignores the last command (assumes
967 it's supposed to deal with the command before the `fc'). */
968 /* This breaks down when using command-oriented history and are not
969 finished with the command, so we should not ignore the last command */
971 current_command_line_count
++; /* for rl_newline above */
972 bash_add_history (rl_line_buffer
);
973 current_command_line_count
= 0; /* for dummy history entry */
974 bash_add_history ("");
975 history_lines_this_session
++;
977 command
= savestring (edit_command
);
980 metaval
= rl_variable_value ("input-meta");
981 metaflag
= RL_BOOLEAN_VARIABLE_VALUE (metaval
);
983 /* Now, POSIX.1-2001 and SUSv3 say that the commands executed from the
984 temporary file should be placed into the history. We don't do that
986 if (rl_deprep_term_function
)
987 (*rl_deprep_term_function
) ();
988 save_parser_state (&ps
);
989 r
= parse_and_execute (command
, (editing_mode
== VI_EDITING_MODE
) ? "v" : "C-xC-e", SEVAL_NOHIST
);
990 restore_parser_state (&ps
);
991 if (rl_prep_term_function
)
992 (*rl_prep_term_function
) (metaflag
);
994 current_command_line_count
= saved_command_line_count
;
996 /* Now erase the contents of the current line and undo the effects of the
997 rl_accept_line() above. We don't even want to make the text we just
998 executed available for undoing. */
999 rl_line_buffer
[0] = '\0'; /* XXX */
1000 rl_point
= rl_end
= 0;
1002 rl_readline_state
= rrs
;
1004 rl_forced_update_display ();
1009 #if defined (VI_MODE)
1011 vi_edit_and_execute_command (count
, c
)
1014 if (posixly_correct
)
1015 return (edit_and_execute_command (count
, c
, VI_EDITING_MODE
, POSIX_VI_EDIT_COMMAND
));
1017 return (edit_and_execute_command (count
, c
, VI_EDITING_MODE
, VI_EDIT_COMMAND
));
1019 #endif /* VI_MODE */
1022 emacs_edit_and_execute_command (count
, c
)
1025 return (edit_and_execute_command (count
, c
, EMACS_EDITING_MODE
, EMACS_EDIT_COMMAND
));
1030 posix_edit_macros (count
, key
)
1034 char alias_name
[3], *alias_value
, *macro
;
1037 alias_name
[0] = '_';
1039 alias_name
[2] = '\0';
1041 alias_value
= get_alias_value (alias_name
);
1042 if (alias_value
&& *alias_value
)
1044 macro
= savestring (alias_value
);
1045 rl_push_macro_input (macro
);
1051 /* Bindable commands that move `shell-words': that is, sequences of
1052 non-unquoted-metacharacters. */
1054 #define WORDDELIM(c) (shellmeta(c) || shellblank(c))
1057 bash_forward_shellword (count
, key
)
1065 return (bash_backward_shellword (-count
, key
));
1067 /* The tricky part of this is deciding whether or not the first character
1068 we're on is an unquoted metacharacter. Not completely handled yet. */
1069 /* XXX - need to test this stuff with backslash-escaped shell
1070 metacharacters and unclosed single- and double-quoted strings. */
1083 /* Are we in a quoted string? If we are, move to the end of the quoted
1084 string and continue the outer loop. We only want quoted strings, not
1085 backslash-escaped characters, but char_is_quoted doesn't
1087 if (char_is_quoted (rl_line_buffer
, p
) && p
> 0 && rl_line_buffer
[p
-1] != '\\')
1090 ADVANCE_CHAR (rl_line_buffer
, slen
, p
);
1091 while (p
< rl_end
&& char_is_quoted (rl_line_buffer
, p
));
1096 /* Rest of code assumes we are not in a quoted string. */
1097 /* Move forward until we hit a non-metacharacter. */
1098 while (p
< rl_end
&& (c
= rl_line_buffer
[p
]) && WORDDELIM (c
))
1103 ADVANCE_CHAR (rl_line_buffer
, slen
, p
);
1104 continue; /* straight back to loop, don't increment p */
1106 if (p
< rl_end
&& rl_line_buffer
[p
])
1107 ADVANCE_CHAR (rl_line_buffer
, slen
, p
);
1110 p
= skip_to_delim (rl_line_buffer
, ++p
, "'", SD_NOJMP
);
1113 p
= skip_to_delim (rl_line_buffer
, ++p
, "\"", SD_NOJMP
);
1121 if (rl_line_buffer
[p
] == 0 || p
== rl_end
)
1128 /* Now move forward until we hit a non-quoted metacharacter or EOL */
1129 while (p
< rl_end
&& (c
= rl_line_buffer
[p
]) && WORDDELIM (c
) == 0)
1134 ADVANCE_CHAR (rl_line_buffer
, slen
, p
);
1135 continue; /* straight back to loop, don't increment p */
1137 if (p
< rl_end
&& rl_line_buffer
[p
])
1138 ADVANCE_CHAR (rl_line_buffer
, slen
, p
);
1141 p
= skip_to_delim (rl_line_buffer
, ++p
, "'", SD_NOJMP
);
1144 p
= skip_to_delim (rl_line_buffer
, ++p
, "\"", SD_NOJMP
);
1152 if (p
== rl_end
|| rl_line_buffer
[p
] == 0)
1166 bash_backward_shellword (count
, key
)
1174 return (bash_forward_shellword (-count
, key
));
1187 /* Move backward until we hit a non-metacharacter. */
1190 c
= rl_line_buffer
[p
];
1191 if (WORDDELIM (c
) && char_is_quoted (rl_line_buffer
, p
) == 0)
1192 BACKUP_CHAR (rl_line_buffer
, slen
, p
);
1202 /* Now move backward until we hit a metacharacter or BOL. */
1205 c
= rl_line_buffer
[p
];
1206 if (WORDDELIM (c
) && char_is_quoted (rl_line_buffer
, p
) == 0)
1208 BACKUP_CHAR (rl_line_buffer
, slen
, p
);
1219 bash_kill_shellword (count
, key
)
1225 return (bash_backward_kill_shellword (-count
, key
));
1228 bash_forward_shellword (count
, key
);
1231 rl_kill_text (p
, rl_point
);
1234 if (rl_editing_mode
== 1) /* 1 == emacs_mode */
1241 bash_backward_kill_shellword (count
, key
)
1247 return (bash_kill_shellword (-count
, key
));
1250 bash_backward_shellword (count
, key
);
1253 rl_kill_text (p
, rl_point
);
1255 if (rl_editing_mode
== 1) /* 1 == emacs_mode */
1262 /* **************************************************************** */
1264 /* How To Do Shell Completion */
1266 /* **************************************************************** */
1268 #define COMMAND_SEPARATORS ";|&{(`"
1270 #define COMMAND_SEPARATORS_PLUS_WS ";|&{(` \t"
1273 /* check for redirections and other character combinations that are not
1274 command separators */
1279 register int this_char
, prev_char
;
1281 /* Handle the two character tokens `>&', `<&', and `>|'.
1282 We are not in a command position after one of these. */
1283 this_char
= rl_line_buffer
[ti
];
1284 prev_char
= rl_line_buffer
[ti
- 1];
1286 if ((this_char
== '&' && (prev_char
== '<' || prev_char
== '>')) ||
1287 (this_char
== '|' && prev_char
== '>'))
1289 else if (this_char
== '{' && prev_char
== '$') /*}*/
1292 else if (this_char
== '(' && prev_char
== '$') /*)*/
1294 else if (this_char
== '(' && prev_char
== '<') /*)*/
1296 #if defined (EXTENDED_GLOB)
1297 else if (extended_glob
&& this_char
== '(' && prev_char
== '!') /*)*/
1301 else if (char_is_quoted (rl_line_buffer
, ti
))
1306 #if defined (PROGRAMMABLE_COMPLETION)
1308 * XXX - because of the <= start test, and setting os = s+1, this can
1309 * potentially return os > start. This is probably not what we want to
1310 * happen, but fix later after 2.05a-release.
1313 find_cmd_start (start
)
1316 register int s
, os
, ns
;
1319 /* Flags == SD_NOJMP only because we want to skip over command substitutions
1320 in assignment statements. Have to test whether this affects `standalone'
1321 command substitutions as individual words. */
1322 while (((s
= skip_to_delim (rl_line_buffer
, os
, COMMAND_SEPARATORS
, SD_NOJMP
|SD_COMPLETE
/*|SD_NOSKIPCMD*/)) <= start
) &&
1325 /* Handle >| token crudely; treat as > not | */
1326 if (rl_line_buffer
[s
] == '|' && rl_line_buffer
[s
-1] == '>')
1328 ns
= skip_to_delim (rl_line_buffer
, s
+1, COMMAND_SEPARATORS
, SD_NOJMP
|SD_COMPLETE
/*|SD_NOSKIPCMD*/);
1329 if (ns
> start
|| rl_line_buffer
[ns
] == 0)
1345 e
= skip_to_delim (rl_line_buffer
, end
, COMMAND_SEPARATORS
, SD_NOJMP
|SD_COMPLETE
);
1350 find_cmd_name (start
, sp
, ep
)
1357 for (s
= start
; whitespace (rl_line_buffer
[s
]); s
++)
1360 /* skip until a shell break character */
1361 e
= skip_to_delim (rl_line_buffer
, s
, "()<>;&| \t\n", SD_NOJMP
|SD_COMPLETE
);
1363 name
= substring (rl_line_buffer
, s
, e
);
1374 prog_complete_return (text
, matchnum
)
1383 if (prog_complete_matches
== 0 || prog_complete_matches
[ind
] == 0)
1384 return (char *)NULL
;
1385 return (prog_complete_matches
[ind
++]);
1388 #endif /* PROGRAMMABLE_COMPLETION */
1390 /* Try and catch completion attempts that are syntax errors or otherwise
1393 invalid_completion (text
, ind
)
1399 /* If we don't catch these here, the next clause will */
1400 if (ind
> 0 && rl_line_buffer
[ind
] == '(' && /*)*/
1401 member (rl_line_buffer
[ind
-1], "$<>"))
1405 while (pind
> 0 && whitespace (rl_line_buffer
[pind
]))
1407 /* If we have only whitespace preceding a paren, it's valid */
1408 if (ind
>= 0 && pind
<= 0 && rl_line_buffer
[ind
] == '(') /*)*/
1410 /* Flag the invalid completions, which are mostly syntax errors */
1411 if (ind
> 0 && rl_line_buffer
[ind
] == '(' && /*)*/
1412 member (rl_line_buffer
[pind
], COMMAND_SEPARATORS
) == 0)
1418 /* Do some completion on TEXT. The indices of TEXT in RL_LINE_BUFFER are
1419 at START and END. Return an array of matches, or NULL if none. */
1421 attempt_shell_completion (text
, start
, end
)
1425 int in_command_position
, ti
, saveti
, qc
, dflags
;
1426 char **matches
, *command_separator_chars
;
1427 #if defined (PROGRAMMABLE_COMPLETION)
1428 int have_progcomps
, was_assignment
;
1431 command_separator_chars
= COMMAND_SEPARATORS
;
1432 matches
= (char **)NULL
;
1433 rl_ignore_some_completions_function
= filename_completion_ignore
;
1435 rl_filename_quote_characters
= default_filename_quote_characters
;
1436 set_filename_bstab (rl_filename_quote_characters
);
1437 set_directory_hook ();
1438 rl_filename_stat_hook
= bash_filename_stat_hook
;
1440 rl_sort_completion_matches
= 1; /* sort by default */
1442 /* Determine if this could be a command word. It is if it appears at
1443 the start of the line (ignoring preceding whitespace), or if it
1444 appears after a character that separates commands. It cannot be a
1445 command word if we aren't at the top-level prompt. */
1449 while ((ti
> -1) && (whitespace (rl_line_buffer
[ti
])))
1453 /* If this is an open quote, maybe we're trying to complete a quoted
1455 if (ti
>= 0 && (rl_line_buffer
[ti
] == '"' || rl_line_buffer
[ti
] == '\''))
1457 qc
= rl_line_buffer
[ti
];
1459 while (ti
> -1 && (whitespace (rl_line_buffer
[ti
])))
1464 in_command_position
= 0;
1467 /* Only do command completion at the start of a line when we
1468 are prompting at the top level. */
1469 if (current_prompt_string
== ps1_prompt
)
1470 in_command_position
++;
1471 else if (parser_in_command_position ())
1472 in_command_position
++;
1474 else if (member (rl_line_buffer
[ti
], command_separator_chars
))
1476 in_command_position
++;
1478 if (check_redir (ti
) == 1)
1479 in_command_position
= 0;
1483 /* This still could be in command position. It is possible
1484 that all of the previous words on the line are variable
1488 if (in_command_position
&& invalid_completion (text
, ti
))
1490 rl_attempted_completion_over
= 1;
1491 return ((char **)NULL
);
1494 /* Check that we haven't incorrectly flagged a closed command substitution
1495 as indicating we're in a command position. */
1496 if (in_command_position
&& ti
>= 0 && rl_line_buffer
[ti
] == '`' &&
1497 *text
!= '`' && unclosed_pair (rl_line_buffer
, end
, "`") == 0)
1498 in_command_position
= 0;
1500 /* Special handling for command substitution. If *TEXT is a backquote,
1501 it can be the start or end of an old-style command substitution, or
1502 unmatched. If it's unmatched, both calls to unclosed_pair will
1503 succeed. Don't bother if readline found a single quote and we are
1504 completing on the substring. */
1505 if (*text
== '`' && rl_completion_quote_character
!= '\'' &&
1506 (in_command_position
|| (unclosed_pair (rl_line_buffer
, start
, "`") &&
1507 unclosed_pair (rl_line_buffer
, end
, "`"))))
1508 matches
= rl_completion_matches (text
, command_subst_completion_function
);
1510 #if defined (PROGRAMMABLE_COMPLETION)
1511 /* Attempt programmable completion. */
1512 have_progcomps
= prog_completion_enabled
&& (progcomp_size () > 0);
1513 if (matches
== 0 && (in_command_position
== 0 || text
[0] == '\0') &&
1514 current_prompt_string
== ps1_prompt
)
1516 int s
, e
, s1
, e1
, os
, foundcs
;
1519 /* XXX - don't free the members */
1520 if (prog_complete_matches
)
1521 free (prog_complete_matches
);
1522 prog_complete_matches
= (char **)NULL
;
1527 s
= find_cmd_start (os
);
1528 e
= find_cmd_end (end
);
1531 /* Don't read past the end of rl_line_buffer */
1537 /* Or past point if point is within an assignment statement */
1538 else if (was_assignment
&& s
> rl_point
)
1543 /* Skip over assignment statements preceding a command name. If we
1544 don't find a command name at all, we can perform command name
1545 completion. If we find a partial command name, we should perform
1546 command name completion on it. */
1548 n
= find_cmd_name (s
, &s1
, &e1
);
1551 while (was_assignment
= assignment (n
, 0));
1552 s
= s1
; /* reset to index where name begins */
1554 /* s == index of where command name begins (reset above)
1555 e == end of current command, may be end of line
1556 s1 = index of where command name begins
1557 e1 == index of where command name ends
1558 start == index of where word to be completed begins
1559 end == index of where word to be completed ends
1560 if (s == start) we are doing command word completion for sure
1561 if (e1 == end) we are at the end of the command name and completing it */
1562 if (start
== 0 && end
== 0 && e
!= 0 && text
[0] == '\0') /* beginning of non-empty line */
1564 else if (start
== end
&& start
== s1
&& e
!= 0 && e1
> end
) /* beginning of command name, leading whitespace */
1566 else if (e
== 0 && e
== s
&& text
[0] == '\0' && have_progcomps
) /* beginning of empty line */
1567 prog_complete_matches
= programmable_completions ("_EmptycmD_", text
, s
, e
, &foundcs
);
1568 else if (start
== end
&& text
[0] == '\0' && s1
> start
&& whitespace (rl_line_buffer
[start
]))
1569 foundcs
= 0; /* whitespace before command name */
1570 else if (e
> s
&& was_assignment
== 0 && e1
== end
&& rl_line_buffer
[e
] == 0 && whitespace (rl_line_buffer
[e
-1]) == 0)
1572 /* not assignment statement, but still want to perform command
1573 completion if we are composing command word. */
1575 in_command_position
= s
== start
&& STREQ (n
, text
); /* XXX */
1577 else if (e
> s
&& was_assignment
== 0 && have_progcomps
)
1579 prog_complete_matches
= programmable_completions (n
, text
, s
, e
, &foundcs
);
1580 /* command completion if programmable completion fails */
1581 in_command_position
= s
== start
&& STREQ (n
, text
); /* XXX */
1583 /* empty command name following command separator */
1584 else if (s
>= e
&& n
[0] == '\0' && text
[0] == '\0' && start
> 0 &&
1585 was_assignment
== 0 && member (rl_line_buffer
[start
-1], COMMAND_SEPARATORS
))
1588 in_command_position
= 1;
1590 else if (s
>= e
&& n
[0] == '\0' && text
[0] == '\0' && start
> 0)
1592 foundcs
= 0; /* empty command name following assignments */
1593 in_command_position
= was_assignment
;
1595 else if (s
== start
&& e
== end
&& STREQ (n
, text
) && start
> 0)
1597 foundcs
= 0; /* partial command name following assignments */
1598 in_command_position
= 1;
1603 /* XXX - if we found a COMPSPEC for the command, just return whatever
1604 the programmable completion code returns, and disable the default
1605 filename completion that readline will do unless the COPT_DEFAULT
1606 option has been set with the `-o default' option to complete or
1610 pcomp_set_readline_variables (foundcs
, 1);
1611 /* Turn what the programmable completion code returns into what
1612 readline wants. I should have made compute_lcd_of_matches
1614 matches
= rl_completion_matches (text
, prog_complete_return
);
1615 if ((foundcs
& COPT_DEFAULT
) == 0)
1616 rl_attempted_completion_over
= 1; /* no default */
1617 if (matches
|| ((foundcs
& COPT_BASHDEFAULT
) == 0))
1626 if (in_command_position
)
1627 dflags
|= DEFCOMP_CMDPOS
;
1628 matches
= bash_default_completion (text
, start
, end
, qc
, dflags
);
1635 bash_default_completion (text
, start
, end
, qc
, compflags
)
1637 int start
, end
, qc
, compflags
;
1641 matches
= (char **)NULL
;
1643 /* New posix-style command substitution or variable name? */
1644 if (!matches
&& *text
== '$')
1646 if (qc
!= '\'' && text
[1] == '(') /* ) */
1647 matches
= rl_completion_matches (text
, command_subst_completion_function
);
1650 matches
= rl_completion_matches (text
, variable_completion_function
);
1651 if (matches
&& matches
[0] && matches
[1] == 0)
1653 t
= savestring (matches
[0]);
1654 bash_filename_stat_hook (&t
);
1655 /* doesn't use test_for_directory because that performs tilde
1658 rl_completion_append_character
= '/';
1664 /* If the word starts in `~', and there is no slash in the word, then
1665 try completing this word as a username. */
1666 if (matches
== 0 && *text
== '~' && mbschr (text
, '/') == 0)
1667 matches
= rl_completion_matches (text
, rl_username_completion_function
);
1669 /* Another one. Why not? If the word starts in '@', then look through
1670 the world of known hostnames for completion first. */
1671 if (matches
== 0 && perform_hostname_completion
&& *text
== '@')
1672 matches
= rl_completion_matches (text
, hostname_completion_function
);
1674 /* And last, (but not least) if this word is in a command position, then
1675 complete over possible command names, including aliases, functions,
1676 and command names. */
1677 if (matches
== 0 && (compflags
& DEFCOMP_CMDPOS
))
1679 /* If END == START and text[0] == 0, we are trying to complete an empty
1681 if (no_empty_command_completion
&& end
== start
&& text
[0] == '\0')
1683 matches
= (char **)NULL
;
1684 rl_ignore_some_completions_function
= bash_ignore_everything
;
1688 #define CMD_IS_DIR(x) (absolute_pathname(x) == 0 && absolute_program(x) == 0 && *(x) != '~' && test_for_directory (x))
1691 matches
= rl_completion_matches (text
, command_word_completion_function
);
1693 /* If we are attempting command completion and nothing matches, we
1694 do not want readline to perform filename completion for us. We
1695 still want to be able to complete partial pathnames, so set the
1696 completion ignore function to something which will remove
1697 filenames and leave directories in the match list. */
1698 if (matches
== (char **)NULL
)
1699 rl_ignore_some_completions_function
= bash_ignore_filenames
;
1700 else if (matches
[1] == 0 && CMD_IS_DIR(matches
[0]) && dot_in_path
== 0)
1701 /* If we found a single match, without looking in the current
1702 directory (because it's not in $PATH), but the found name is
1703 also a command in the current directory, suppress appending any
1704 terminating character, since it's ambiguous. */
1706 rl_completion_suppress_append
= 1;
1707 rl_filename_completion_desired
= 0;
1709 else if (matches
[0] && matches
[1] && STREQ (matches
[0], matches
[1]) && CMD_IS_DIR (matches
[0]))
1710 /* There are multiple instances of the same match (duplicate
1711 completions haven't yet been removed). In this case, all of
1712 the matches will be the same, and the duplicate removal code
1713 will distill them all down to one. We turn on
1714 rl_completion_suppress_append for the same reason as above.
1715 Remember: we only care if there's eventually a single unique
1716 completion. If there are multiple completions this won't
1717 make a difference and the problem won't occur. */
1719 rl_completion_suppress_append
= 1;
1720 rl_filename_completion_desired
= 0;
1725 /* This could be a globbing pattern, so try to expand it using pathname
1727 if (!matches
&& glob_pattern_p (text
))
1729 matches
= rl_completion_matches (text
, glob_complete_word
);
1730 /* A glob expression that matches more than one filename is problematic.
1731 If we match more than one filename, punt. */
1732 if (matches
&& matches
[1] && rl_completion_type
== TAB
)
1734 strvec_dispose (matches
);
1735 matches
= (char **)0;
1737 else if (matches
&& matches
[1] && rl_completion_type
== '!')
1739 rl_completion_suppress_append
= 1;
1740 rl_filename_completion_desired
= 0;
1748 bash_command_name_stat_hook (name
)
1751 char *cname
, *result
;
1753 /* If it's not something we're going to look up in $PATH, just call the
1754 normal filename stat hook. */
1755 if (absolute_program (*name
))
1756 return (bash_filename_stat_hook (name
));
1759 /* XXX - we could do something here with converting aliases, builtins,
1760 and functions into something that came out as executable, but we don't. */
1761 result
= search_for_command (cname
, 0);
1771 executable_completion (filename
, searching_path
)
1772 const char *filename
;
1778 f
= savestring (filename
);
1779 bash_directory_completion_hook (&f
);
1781 r
= searching_path
? executable_file (f
) : executable_or_directory (f
);
1786 /* This is the function to call when the word to complete is in a position
1787 where a command word can be found. It grovels $PATH, looking for commands
1788 that match. It also scans aliases, function names, and the shell_builtin
1791 command_word_completion_function (hint_text
, state
)
1792 const char *hint_text
;
1795 static char *hint
= (char *)NULL
;
1796 static char *path
= (char *)NULL
;
1797 static char *val
= (char *)NULL
;
1798 static char *filename_hint
= (char *)NULL
;
1799 static char *fnhint
= (char *)NULL
;
1800 static char *dequoted_hint
= (char *)NULL
;
1801 static char *directory_part
= (char *)NULL
;
1802 static char **glob_matches
= (char **)NULL
;
1803 static int path_index
, hint_len
, dequoted_len
, istate
, igncase
;
1804 static int mapping_over
, local_index
, searching_path
, hint_is_dir
;
1805 static int old_glob_ignore_case
, globpat
;
1806 static SHELL_VAR
**varlist
= (SHELL_VAR
**)NULL
;
1808 static alias_t
**alias_list
= (alias_t
**)NULL
;
1812 /* We have to map over the possibilities for command words. If we have
1813 no state, then make one just for that purpose. */
1816 rl_filename_stat_hook
= bash_command_name_stat_hook
;
1818 if (dequoted_hint
&& dequoted_hint
!= hint
)
1819 free (dequoted_hint
);
1823 mapping_over
= searching_path
= 0;
1824 hint_is_dir
= CMD_IS_DIR (hint_text
);
1827 temp
= rl_variable_value ("completion-ignore-case");
1828 igncase
= RL_BOOLEAN_VARIABLE_VALUE (temp
);
1832 free (glob_matches
);
1833 glob_matches
= (char **)NULL
;
1836 globpat
= glob_pattern_p (hint_text
);
1838 /* If this is an absolute program name, do not check it against
1839 aliases, reserved words, functions or builtins. We must check
1840 whether or not it is unique, and, if so, whether that filename
1842 if (globpat
|| absolute_program (hint_text
))
1844 /* Perform tilde expansion on what's passed, so we don't end up
1845 passing filenames with tildes directly to stat(). */
1846 if (*hint_text
== '~')
1848 hint
= bash_tilde_expand (hint_text
, 0);
1849 directory_part
= savestring (hint_text
);
1850 temp
= strchr (directory_part
, '/');
1855 free (directory_part
);
1856 directory_part
= (char *)NULL
;
1860 hint
= savestring (hint_text
);
1862 dequoted_hint
= hint
;
1863 /* If readline's completer found a quote character somewhere, but
1864 didn't set the quote character, there must have been a quote
1865 character embedded in the filename. It can't be at the start of
1866 the filename, so we need to dequote the filename before we look
1867 in the file system for it. */
1868 if (rl_completion_found_quote
&& rl_completion_quote_character
== 0)
1870 dequoted_hint
= bash_dequote_filename (hint
, 0);
1872 hint
= dequoted_hint
;
1874 dequoted_len
= hint_len
= strlen (hint
);
1877 free (filename_hint
);
1879 fnhint
= filename_hint
= savestring (hint
);
1890 if (dircomplete_expand
&& path_dot_or_dotdot (filename_hint
))
1892 dircomplete_expand
= 0;
1893 set_directory_hook ();
1894 dircomplete_expand
= 1;
1901 dequoted_hint
= hint
= savestring (hint_text
);
1902 dequoted_len
= hint_len
= strlen (hint
);
1904 if (rl_completion_found_quote
&& rl_completion_quote_character
== 0)
1906 dequoted_hint
= bash_dequote_filename (hint
, 0);
1907 dequoted_len
= strlen (dequoted_hint
);
1910 path
= get_string_value ("PATH");
1911 path_index
= dot_in_path
= 0;
1913 /* Initialize the variables for each type of command word. */
1919 varlist
= all_visible_functions ();
1925 alias_list
= all_aliases ();
1929 /* mapping_over says what we are currently hacking. Note that every case
1930 in this list must fall through when there are no more possibilities. */
1932 switch (mapping_over
)
1934 case 0: /* Aliases come first. */
1936 while (alias_list
&& alias_list
[local_index
])
1938 register char *alias
;
1940 alias
= alias_list
[local_index
++]->name
;
1942 if (STREQN (alias
, hint
, hint_len
))
1943 return (savestring (alias
));
1949 case 1: /* Then shell reserved words. */
1951 while (word_token_alist
[local_index
].word
)
1953 register char *reserved_word
;
1955 reserved_word
= word_token_alist
[local_index
++].word
;
1957 if (STREQN (reserved_word
, hint
, hint_len
))
1958 return (savestring (reserved_word
));
1964 case 2: /* Then function names. */
1965 while (varlist
&& varlist
[local_index
])
1967 register char *varname
;
1969 varname
= varlist
[local_index
++]->name
;
1971 if (STREQN (varname
, hint
, hint_len
))
1972 return (savestring (varname
));
1977 case 3: /* Then shell builtins. */
1978 for (; local_index
< num_shell_builtins
; local_index
++)
1980 /* Ignore it if it doesn't have a function pointer or if it
1981 is not currently enabled. */
1982 if (!shell_builtins
[local_index
].function
||
1983 (shell_builtins
[local_index
].flags
& BUILTIN_ENABLED
) == 0)
1986 if (STREQN (shell_builtins
[local_index
].name
, hint
, hint_len
))
1988 int i
= local_index
++;
1990 return (savestring (shell_builtins
[i
].name
));
1998 /* Limited support for completing command words with globbing chars. Only
1999 a single match (multiple matches that end up reducing the number of
2000 characters in the common prefix are bad) will ever be returned on
2001 regular completion. */
2006 glob_ignore_case
= igncase
;
2007 glob_matches
= shell_glob_filename (hint
);
2008 glob_ignore_case
= old_glob_ignore_case
;
2010 if (GLOB_FAILED (glob_matches
) || glob_matches
== 0)
2012 glob_matches
= (char **)NULL
;
2013 return ((char *)NULL
);
2018 if (glob_matches
[1] && rl_completion_type
== TAB
) /* multiple matches are bad */
2019 return ((char *)NULL
);
2022 while (val
= glob_matches
[local_index
++])
2024 if (executable_or_directory (val
))
2026 if (*hint_text
== '~' && directory_part
)
2028 temp
= maybe_restore_tilde (val
, directory_part
);
2037 glob_ignore_case
= old_glob_ignore_case
;
2038 return ((char *)NULL
);
2041 /* If the text passed is a directory in the current directory, return it
2042 as a possible match. Executables in directories in the current
2043 directory can be specified using relative pathnames and successfully
2044 executed even when `.' is not in $PATH. */
2047 hint_is_dir
= 0; /* only return the hint text once */
2048 return (savestring (hint_text
));
2051 /* Repeatedly call filename_completion_function while we have
2052 members of PATH left. Question: should we stat each file?
2053 Answer: we call executable_file () on each file. */
2056 istate
= (val
!= (char *)NULL
);
2062 /* Get the next directory from the path. If there is none, then we
2064 if (path
== 0 || path
[path_index
] == 0 ||
2065 (current_path
= extract_colon_unit (path
, &path_index
)) == 0)
2066 return ((char *)NULL
);
2069 if (*current_path
== 0)
2071 free (current_path
);
2072 current_path
= savestring (".");
2075 if (*current_path
== '~')
2079 t
= bash_tilde_expand (current_path
, 0);
2080 free (current_path
);
2084 if (current_path
[0] == '.' && current_path
[1] == '\0')
2087 if (fnhint
&& fnhint
!= filename_hint
)
2090 free (filename_hint
);
2092 filename_hint
= sh_makepath (current_path
, hint
, 0);
2093 /* Need a quoted version (though it doesn't matter much in most
2094 cases) because rl_filename_completion_function dequotes the
2095 filename it gets, assuming that it's been quoted as part of
2096 the input line buffer. */
2097 if (strpbrk (filename_hint
, "\"'\\"))
2098 fnhint
= sh_backslash_quote (filename_hint
, filename_bstab
, 0);
2100 fnhint
= filename_hint
;
2101 free (current_path
); /* XXX */
2105 val
= rl_filename_completion_function (fnhint
, istate
);
2106 if (mapping_over
== 4 && dircomplete_expand
)
2107 set_directory_hook ();
2113 /* If the hint text is an absolute program, then don't bother
2114 searching through PATH. */
2115 if (absolute_program (hint
))
2116 return ((char *)NULL
);
2122 int match
, freetemp
;
2124 if (absolute_program (hint
))
2127 match
= strncmp (val
, hint
, hint_len
) == 0;
2129 match
= strncasecmp (val
, hint
, hint_len
) == 0;
2131 /* If we performed tilde expansion, restore the original
2133 if (*hint_text
== '~')
2134 temp
= maybe_restore_tilde (val
, directory_part
);
2136 temp
= savestring (val
);
2141 temp
= strrchr (val
, '/');
2147 freetemp
= match
= strncmp (temp
, hint
, hint_len
) == 0;
2149 freetemp
= match
= strncasecmp (temp
, hint
, hint_len
) == 0;
2151 temp
= savestring (temp
);
2154 freetemp
= match
= 0;
2157 /* If we have found a match, and it is an executable file, return it.
2158 We don't return directory names when searching $PATH, since the
2159 bash execution code won't find executables in directories which
2160 appear in directories in $PATH when they're specified using
2161 relative pathnames. */
2163 /* If we're not searching $PATH and we have a relative pathname, we
2164 need to re-canonicalize it before testing whether or not it's an
2165 executable or a directory so the shell treats .. relative to $PWD
2166 according to the physical/logical option. The shell already
2167 canonicalizes the directory name in order to tell readline where
2168 to look, so not doing it here will be inconsistent. */
2169 /* XXX -- currently not used -- will introduce more inconsistency,
2170 since shell does not canonicalize ../foo before passing it to
2172 if (match
&& searching_path
== 0 && *val
== '.')
2176 t
= get_working_directory ("command-word-completion");
2177 t1
= make_absolute (val
, t
);
2179 cval
= sh_canonpath (t1
, PATH_CHECKDOTDOT
|PATH_CHECKEXISTS
);
2185 if (match
&& executable_completion ((searching_path
? val
: cval
), searching_path
))
2190 val
= ""; /* So it won't be NULL. */
2205 /* Completion inside an unterminated command substitution. */
2207 command_subst_completion_function (text
, state
)
2211 static char **matches
= (char **)NULL
;
2212 static const char *orig_start
;
2213 static char *filename_text
= (char *)NULL
;
2214 static int cmd_index
, start_len
;
2220 free (filename_text
);
2224 else if (*text
== '$' && text
[1] == '(') /* ) */
2226 /* If the text was quoted, suppress any quote character that the
2227 readline completion code would insert. */
2228 rl_completion_suppress_quote
= 1;
2229 start_len
= text
- orig_start
;
2230 filename_text
= savestring (text
);
2235 * At this point we can entertain the idea of re-parsing
2236 * `filename_text' into a (possibly incomplete) command name and
2237 * arguments, and doing completion based on that. This is
2238 * currently very rudimentary, but it is a small improvement.
2240 for (value
= filename_text
+ strlen (filename_text
) - 1; value
> filename_text
; value
--)
2241 if (whitespace (*value
) || member (*value
, COMMAND_SEPARATORS
))
2243 if (value
<= filename_text
)
2244 matches
= rl_completion_matches (filename_text
, command_word_completion_function
);
2248 start_len
+= value
- filename_text
;
2249 if (whitespace (value
[-1]))
2250 matches
= rl_completion_matches (value
, rl_filename_completion_function
);
2252 matches
= rl_completion_matches (value
, command_word_completion_function
);
2255 /* If there is more than one match, rl_completion_matches has already
2256 put the lcd in matches[0]. Skip over it. */
2257 cmd_index
= matches
&& matches
[0] && matches
[1];
2259 /* If there's a single match and it's a directory, set the append char
2260 to the expected `/'. Otherwise, don't append anything. */
2261 if (matches
&& matches
[0] && matches
[1] == 0 && test_for_directory (matches
[0]))
2262 rl_completion_append_character
= '/';
2264 rl_completion_suppress_append
= 1;
2267 if (matches
== 0 || matches
[cmd_index
] == 0)
2269 rl_filename_quoting_desired
= 0; /* disable quoting */
2270 return ((char *)NULL
);
2274 value
= (char *)xmalloc (1 + start_len
+ strlen (matches
[cmd_index
]));
2277 value
[0] = *orig_start
;
2279 strncpy (value
, orig_start
, start_len
);
2281 strcpy (value
+ start_len
, matches
[cmd_index
]);
2288 /* Okay, now we write the entry_function for variable completion. */
2290 variable_completion_function (text
, state
)
2294 static char **varlist
= (char **)NULL
;
2295 static int varlist_index
;
2296 static char *varname
= (char *)NULL
;
2298 static int first_char
, first_char_loc
;
2306 first_char
= text
[0];
2308 if (first_char
== '$')
2311 if (text
[first_char_loc
] == '{')
2314 varname
= savestring (text
+ first_char_loc
);
2316 namelen
= strlen (varname
);
2318 strvec_dispose (varlist
);
2320 varlist
= all_variables_matching_prefix (varname
);
2324 if (!varlist
|| !varlist
[varlist_index
])
2326 return ((char *)NULL
);
2332 value
= (char *)xmalloc (4 + strlen (varlist
[varlist_index
]));
2336 value
[0] = first_char
;
2337 if (first_char_loc
== 2)
2341 strcpy (value
+ first_char_loc
, varlist
[varlist_index
]);
2342 if (first_char_loc
== 2)
2343 strcat (value
, "}");
2350 /* How about a completion function for hostnames? */
2352 hostname_completion_function (text
, state
)
2356 static char **list
= (char **)NULL
;
2357 static int list_index
= 0;
2358 static int first_char
, first_char_loc
;
2360 /* If we don't have any state, make some. */
2365 list
= (char **)NULL
;
2370 if (first_char
== '@')
2373 list
= hostnames_matching ((char *)text
+first_char_loc
);
2377 if (list
&& list
[list_index
])
2381 t
= (char *)xmalloc (2 + strlen (list
[list_index
]));
2383 strcpy (t
+ first_char_loc
, list
[list_index
]);
2388 return ((char *)NULL
);
2392 * A completion function for service names from /etc/services (or wherever).
2395 bash_servicename_completion_function (text
, state
)
2399 #if defined (__WIN32__) || defined (__OPENNT) || !defined (HAVE_GETSERVENT)
2400 return ((char *)NULL
);
2402 static char *sname
= (char *)NULL
;
2403 static struct servent
*srvent
;
2404 static int snamelen
, firstc
;
2406 char **alist
, *aentry
;
2414 sname
= savestring (text
);
2415 snamelen
= strlen (sname
);
2419 while (srvent
= getservent ())
2422 if (snamelen
== 0 || (STREQN (sname
, srvent
->s_name
, snamelen
)))
2424 /* Not primary, check aliases */
2425 for (alist
= srvent
->s_aliases
; *alist
; alist
++)
2428 if (STREQN (sname
, aentry
, snamelen
))
2442 return ((char *)NULL
);
2445 value
= afound
? savestring (aentry
) : savestring (srvent
->s_name
);
2451 * A completion function for group names from /etc/group (or wherever).
2454 bash_groupname_completion_function (text
, state
)
2458 #if defined (__WIN32__) || defined (__OPENNT) || !defined (HAVE_GRP_H)
2459 return ((char *)NULL
);
2461 static char *gname
= (char *)NULL
;
2462 static struct group
*grent
;
2463 static int gnamelen
;
2469 gname
= savestring (text
);
2470 gnamelen
= strlen (gname
);
2475 while (grent
= getgrent ())
2477 if (gnamelen
== 0 || (STREQN (gname
, grent
->gr_name
, gnamelen
)))
2484 return ((char *)NULL
);
2487 value
= savestring (grent
->gr_name
);
2492 /* Functions to perform history and alias expansions on the current line. */
2494 #if defined (BANG_HISTORY)
2495 /* Perform history expansion on the current line. If no history expansion
2496 is done, pre_process_line() returns what it was passed, so we need to
2497 allocate a new line here. */
2499 history_expand_line_internal (line
)
2505 old_verify
= hist_verify
;
2507 new_line
= pre_process_line (line
, 0, 0);
2508 hist_verify
= old_verify
;
2510 return (new_line
== line
) ? savestring (line
) : new_line
;
2514 /* There was an error in expansion. Let the preprocessor print
2517 cleanup_expansion_error ()
2520 #if defined (BANG_HISTORY)
2523 old_verify
= hist_verify
;
2527 fprintf (rl_outstream
, "\r\n");
2528 to_free
= pre_process_line (rl_line_buffer
, 1, 0);
2529 #if defined (BANG_HISTORY)
2530 hist_verify
= old_verify
;
2532 if (to_free
!= rl_line_buffer
)
2534 putc ('\r', rl_outstream
);
2535 rl_forced_update_display ();
2538 /* If NEW_LINE differs from what is in the readline line buffer, add an
2539 undo record to get from the readline line buffer contents to the new
2540 line and make NEW_LINE the current readline line. */
2542 maybe_make_readline_line (new_line
)
2545 if (strcmp (new_line
, rl_line_buffer
) != 0)
2549 rl_add_undo (UNDO_BEGIN
, 0, 0, 0);
2550 rl_delete_text (0, rl_point
);
2551 rl_point
= rl_end
= rl_mark
= 0;
2552 rl_insert_text (new_line
);
2553 rl_add_undo (UNDO_END
, 0, 0, 0);
2557 /* Make NEW_LINE be the current readline line. This frees NEW_LINE. */
2559 set_up_new_line (new_line
)
2562 int old_point
, at_end
;
2564 old_point
= rl_point
;
2565 at_end
= rl_point
== rl_end
;
2567 /* If the line was history and alias expanded, then make that
2568 be one thing to undo. */
2569 maybe_make_readline_line (new_line
);
2572 /* Place rl_point where we think it should go. */
2575 else if (old_point
< rl_end
)
2577 rl_point
= old_point
;
2578 if (!whitespace (rl_line_buffer
[rl_point
]))
2579 rl_forward_word (1, 0);
2584 /* Expand aliases in the current readline line. */
2586 alias_expand_line (count
, ignore
)
2591 new_line
= alias_expand (rl_line_buffer
);
2595 set_up_new_line (new_line
);
2600 cleanup_expansion_error ();
2606 #if defined (BANG_HISTORY)
2607 /* History expand the line. */
2609 history_expand_line (count
, ignore
)
2614 new_line
= history_expand_line_internal (rl_line_buffer
);
2618 set_up_new_line (new_line
);
2623 cleanup_expansion_error ();
2628 /* Expand history substitutions in the current line and then insert a
2629 space (hopefully close to where we were before). */
2631 tcsh_magic_space (count
, ignore
)
2634 int dist_from_end
, old_point
;
2636 old_point
= rl_point
;
2637 dist_from_end
= rl_end
- rl_point
;
2638 if (history_expand_line (count
, ignore
) == 0)
2640 /* Try a simple heuristic from Stephen Gildea <gildea@intouchsys.com>.
2641 This works if all expansions were before rl_point or if no expansions
2643 rl_point
= (old_point
== 0) ? old_point
: rl_end
- dist_from_end
;
2650 #endif /* BANG_HISTORY */
2652 /* History and alias expand the line. */
2654 history_and_alias_expand_line (count
, ignore
)
2660 #if defined (BANG_HISTORY)
2661 new_line
= history_expand_line_internal (rl_line_buffer
);
2669 alias_line
= alias_expand (new_line
);
2671 new_line
= alias_line
;
2677 set_up_new_line (new_line
);
2682 cleanup_expansion_error ();
2687 /* History and alias expand the line, then perform the shell word
2688 expansions by calling expand_string. This can't use set_up_new_line()
2689 because we want the variable expansions as a separate undo'able
2690 set of operations. */
2692 shell_expand_line (count
, ignore
)
2696 WORD_LIST
*expanded_string
;
2699 #if defined (BANG_HISTORY)
2700 new_line
= history_expand_line_internal (rl_line_buffer
);
2708 alias_line
= alias_expand (new_line
);
2710 new_line
= alias_line
;
2716 int old_point
= rl_point
;
2717 int at_end
= rl_point
== rl_end
;
2719 /* If the line was history and alias expanded, then make that
2720 be one thing to undo. */
2721 maybe_make_readline_line (new_line
);
2724 /* If there is variable expansion to perform, do that as a separate
2725 operation to be undone. */
2726 new_line
= savestring (rl_line_buffer
);
2727 expanded_string
= expand_string (new_line
, 0);
2729 if (expanded_string
== 0)
2731 new_line
= (char *)xmalloc (1);
2736 new_line
= string_list (expanded_string
);
2737 dispose_words (expanded_string
);
2740 maybe_make_readline_line (new_line
);
2743 /* Place rl_point where we think it should go. */
2746 else if (old_point
< rl_end
)
2748 rl_point
= old_point
;
2749 if (!whitespace (rl_line_buffer
[rl_point
]))
2750 rl_forward_word (1, 0);
2756 cleanup_expansion_error ();
2761 /* If FIGNORE is set, then don't match files with the given suffixes when
2762 completing filenames. If only one of the possibilities has an acceptable
2763 suffix, delete the others, else just return and let the completer
2764 signal an error. It is called by the completer when real
2765 completions are done on filenames by the completer's internal
2766 function, not for completion lists (M-?) and not on "other"
2767 completion types, such as hostnames or commands. */
2769 static struct ignorevar fignore
=
2775 (sh_iv_item_func_t
*) 0,
2779 _ignore_completion_names (names
, name_func
)
2781 sh_ignore_func_t
*name_func
;
2788 /* If there is only one completion, see if it is acceptable. If it is
2789 not, free it up. In any case, short-circuit and return. This is a
2790 special case because names[0] is not the prefix of the list of names
2791 if there is only one completion; it is the completion itself. */
2792 if (names
[1] == (char *)0)
2795 if ((*name_func
) (names
[0]) == 0)
2798 names
[0] = (char *)NULL
;
2804 /* Allocate space for array to hold list of pointers to matching
2805 filenames. The pointers are copied back to NAMES when done. */
2806 for (nidx
= 1; names
[nidx
]; nidx
++)
2808 newnames
= strvec_create (nidx
+ 1);
2810 if (force_fignore
== 0)
2812 oldnames
= strvec_create (nidx
- 1);
2816 newnames
[0] = names
[0];
2817 for (idx
= nidx
= 1; names
[idx
]; idx
++)
2819 if ((*name_func
) (names
[idx
]))
2820 newnames
[nidx
++] = names
[idx
];
2821 else if (force_fignore
== 0)
2822 oldnames
[oidx
++] = names
[idx
];
2827 newnames
[nidx
] = (char *)NULL
;
2829 /* If none are acceptable then let the completer handle it. */
2835 names
[0] = (char *)NULL
;
2844 if (force_fignore
== 0)
2847 free (oldnames
[--oidx
]);
2851 /* If only one is acceptable, copy it to names[0] and return. */
2855 names
[0] = newnames
[1];
2856 names
[1] = (char *)NULL
;
2861 /* Copy the acceptable names back to NAMES, set the new array end,
2863 for (nidx
= 1; newnames
[nidx
]; nidx
++)
2864 names
[nidx
] = newnames
[nidx
];
2865 names
[nidx
] = (char *)NULL
;
2870 name_is_acceptable (name
)
2876 for (nlen
= strlen (name
), p
= fignore
.ignores
; p
->val
; p
++)
2878 if (nlen
> p
->len
&& p
->len
> 0 && STREQ (p
->val
, &name
[nlen
- p
->len
]))
2887 ignore_dot_names (name
)
2890 return (name
[0] != '.');
2895 filename_completion_ignore (names
)
2899 if (glob_dot_filenames
== 0)
2900 _ignore_completion_names (names
, ignore_dot_names
);
2903 setup_ignore_patterns (&fignore
);
2905 if (fignore
.num_ignores
== 0)
2908 _ignore_completion_names (names
, name_is_acceptable
);
2913 /* Return 1 if NAME is a directory. NAME undergoes tilde expansion. */
2915 test_for_directory (name
)
2921 fn
= bash_tilde_expand (name
, 0);
2922 r
= file_isdir (fn
);
2928 /* Remove files from NAMES, leaving directories. */
2930 bash_ignore_filenames (names
)
2933 _ignore_completion_names (names
, test_for_directory
);
2945 bash_ignore_everything (names
)
2948 _ignore_completion_names (names
, return_zero
);
2952 /* Replace a tilde-prefix in VAL with a `~', assuming the user typed it. VAL
2953 is an expanded filename. DIRECTORY_PART is the tilde-prefix portion
2954 of the un-tilde-expanded version of VAL (what the user typed). */
2956 restore_tilde (val
, directory_part
)
2957 char *val
, *directory_part
;
2960 char *dh2
, *expdir
, *ret
;
2964 /* We need to duplicate the expansions readline performs on the directory
2965 portion before passing it to our completion function. */
2966 dh2
= directory_part
? bash_dequote_filename (directory_part
, 0) : 0;
2967 bash_directory_expansion (&dh2
);
2970 expdir
= bash_tilde_expand (directory_part
, 0);
2971 xl
= strlen (expdir
);
2975 dh2 = unexpanded but dequoted tilde-prefix
2976 dl2 = length of tilde-prefix
2977 expdir = tilde-expanded tilde-prefix
2978 xl = length of expanded tilde-prefix
2979 l = length of remainder after tilde-prefix
2983 ret
= (char *)xmalloc (dl2
+ 2 + l
);
2985 strcpy (ret
+ dl2
, val
+ xl
);
2992 maybe_restore_tilde (val
, directory_part
)
2993 char *val
, *directory_part
;
2995 rl_icppfunc_t
*save
;
2998 save
= (dircomplete_expand
== 0) ? save_directory_hook () : (rl_icppfunc_t
*)0;
2999 ret
= restore_tilde (val
, directory_part
);
3001 restore_directory_hook (save
);
3005 /* Simulate the expansions that will be performed by
3006 rl_filename_completion_function. This must be called with the address of
3007 a pointer to malloc'd memory. */
3009 bash_directory_expansion (dirname
)
3014 d
= savestring (*dirname
);
3016 if ((rl_directory_rewrite_hook
) && (*rl_directory_rewrite_hook
) (&d
))
3021 else if (rl_directory_completion_hook
&& (*rl_directory_completion_hook
) (&d
))
3026 else if (rl_completion_found_quote
)
3028 nd
= bash_dequote_filename (d
, rl_completion_quote_character
);
3035 /* If necessary, rewrite directory entry */
3037 bash_filename_rewrite_hook (fname
, fnlen
)
3043 conv
= fnx_fromfs (fname
, fnlen
);
3045 conv
= savestring (conv
);
3049 /* Functions to save and restore the appropriate directory hook */
3050 /* This is not static so the shopt code can call it */
3052 set_directory_hook ()
3054 if (dircomplete_expand
)
3056 rl_directory_completion_hook
= bash_directory_completion_hook
;
3057 rl_directory_rewrite_hook
= (rl_icppfunc_t
*)0;
3061 rl_directory_rewrite_hook
= bash_directory_completion_hook
;
3062 rl_directory_completion_hook
= (rl_icppfunc_t
*)0;
3066 static rl_icppfunc_t
*
3067 save_directory_hook ()
3071 if (dircomplete_expand
)
3073 ret
= rl_directory_completion_hook
;
3074 rl_directory_completion_hook
= (rl_icppfunc_t
*)NULL
;
3078 ret
= rl_directory_rewrite_hook
;
3079 rl_directory_rewrite_hook
= (rl_icppfunc_t
*)NULL
;
3086 restore_directory_hook (hookf
)
3087 rl_icppfunc_t
*hookf
;
3089 if (dircomplete_expand
)
3090 rl_directory_completion_hook
= hookf
;
3092 rl_directory_rewrite_hook
= hookf
;
3095 /* Check whether not the (dequoted) version of DIRNAME, with any trailing slash
3098 directory_exists (dirname
)
3099 const char *dirname
;
3105 /* First, dequote the directory name */
3106 new_dirname
= bash_dequote_filename ((char *)dirname
, rl_completion_quote_character
);
3107 dirlen
= STRLEN (new_dirname
);
3108 if (new_dirname
[dirlen
- 1] == '/')
3109 new_dirname
[dirlen
- 1] = '\0';
3110 #if defined (HAVE_LSTAT)
3111 r
= lstat (new_dirname
, &sb
) == 0;
3113 r
= stat (new_dirname
, &sb
) == 0;
3119 /* Expand a filename before the readline completion code passes it to stat(2).
3120 The filename will already have had tilde expansion performed. */
3122 bash_filename_stat_hook (dirname
)
3125 char *local_dirname
, *new_dirname
, *t
;
3126 int should_expand_dirname
, return_value
;
3130 local_dirname
= *dirname
;
3131 should_expand_dirname
= return_value
= 0;
3132 if (t
= mbschr (local_dirname
, '$'))
3133 should_expand_dirname
= '$';
3134 else if (t
= mbschr (local_dirname
, '`')) /* XXX */
3135 should_expand_dirname
= '`';
3137 if (should_expand_dirname
&& directory_exists (local_dirname
))
3138 should_expand_dirname
= 0;
3140 if (should_expand_dirname
)
3142 new_dirname
= savestring (local_dirname
);
3143 wl
= expand_prompt_string (new_dirname
, 0, W_NOCOMSUB
); /* does the right thing */
3147 new_dirname
= string_list (wl
);
3148 /* Tell the completer we actually expanded something and change
3149 *dirname only if we expanded to something non-null -- stat
3150 behaves unpredictably when passed null or empty strings */
3151 if (new_dirname
&& *new_dirname
)
3153 free (local_dirname
); /* XXX */
3154 local_dirname
= *dirname
= new_dirname
;
3155 return_value
= STREQ (local_dirname
, *dirname
) == 0;
3165 /* This is very similar to the code in bash_directory_completion_hook below,
3166 but without spelling correction and not worrying about whether or not
3167 we change relative pathnames. */
3168 if (no_symbolic_links
== 0 && (local_dirname
[0] != '.' || local_dirname
[1]))
3170 char *temp1
, *temp2
;
3172 t
= get_working_directory ("symlink-hook");
3173 temp1
= make_absolute (local_dirname
, t
);
3175 temp2
= sh_canonpath (temp1
, PATH_CHECKDOTDOT
|PATH_CHECKEXISTS
);
3177 /* If we can't canonicalize, bail. */
3181 return return_value
;
3184 free (local_dirname
);
3189 return (return_value
);
3192 /* Handle symbolic link references and other directory name
3193 expansions while hacking completion. This should return 1 if it modifies
3194 the DIRNAME argument, 0 otherwise. It should make sure not to modify
3195 DIRNAME if it returns 0. */
3197 bash_directory_completion_hook (dirname
)
3200 char *local_dirname
, *new_dirname
, *t
;
3201 int return_value
, should_expand_dirname
, nextch
, closer
, changed
;
3202 size_t local_dirlen
;
3206 return_value
= should_expand_dirname
= nextch
= closer
= 0;
3207 local_dirname
= *dirname
;
3209 if (t
= mbschr (local_dirname
, '$'))
3211 should_expand_dirname
= '$';
3213 /* Deliberately does not handle the deprecated $[...] arithmetic
3217 else if (nextch
== '{')
3222 else if (local_dirname
[0] == '~')
3223 should_expand_dirname
= '~';
3226 t
= mbschr (local_dirname
, '`');
3227 if (t
&& unclosed_pair (local_dirname
, strlen (local_dirname
), "`") == 0)
3228 should_expand_dirname
= '`';
3231 if (should_expand_dirname
&& directory_exists (local_dirname
))
3232 should_expand_dirname
= 0;
3234 if (should_expand_dirname
)
3236 new_dirname
= savestring (local_dirname
);
3237 wl
= expand_prompt_string (new_dirname
, 0, W_NOCOMSUB
); /* does the right thing */
3240 *dirname
= string_list (wl
);
3241 /* Tell the completer to replace the directory name only if we
3242 actually expanded something. */
3243 return_value
= STREQ (local_dirname
, *dirname
) == 0;
3244 free (local_dirname
);
3247 local_dirname
= *dirname
;
3248 /* XXX - change rl_filename_quote_characters here based on
3249 should_expand_dirname/nextch/closer. This is the only place
3250 custom_filename_quote_characters is modified. */
3251 if (rl_filename_quote_characters
&& *rl_filename_quote_characters
)
3254 i
= strlen (default_filename_quote_characters
);
3255 custom_filename_quote_characters
= xrealloc (custom_filename_quote_characters
, i
+1);
3256 for (i
= j
= 0; c
= default_filename_quote_characters
[i
]; i
++)
3258 if (c
== should_expand_dirname
|| c
== nextch
|| c
== closer
)
3260 custom_filename_quote_characters
[j
++] = c
;
3262 custom_filename_quote_characters
[j
] = '\0';
3263 rl_filename_quote_characters
= custom_filename_quote_characters
;
3264 set_filename_bstab (rl_filename_quote_characters
);
3270 free (local_dirname
);
3271 *dirname
= (char *)xmalloc (1);
3278 /* Dequote the filename even if we don't expand it. */
3279 new_dirname
= bash_dequote_filename (local_dirname
, rl_completion_quote_character
);
3280 return_value
= STREQ (local_dirname
, new_dirname
) == 0;
3281 free (local_dirname
);
3282 local_dirname
= *dirname
= new_dirname
;
3285 /* no_symbolic_links == 0 -> use (default) logical view of the file system.
3286 local_dirname[0] == '.' && local_dirname[1] == '/' means files in the
3287 current directory (./).
3288 local_dirname[0] == '.' && local_dirname[1] == 0 means relative pathnames
3289 in the current directory (e.g., lib/sh).
3290 XXX - should we do spelling correction on these? */
3292 /* This is test as it was in bash-4.2: skip relative pathnames in current
3293 directory. Change test to
3294 (local_dirname[0] != '.' || (local_dirname[1] && local_dirname[1] != '/'))
3295 if we want to skip paths beginning with ./ also. */
3296 if (no_symbolic_links
== 0 && (local_dirname
[0] != '.' || local_dirname
[1]))
3298 char *temp1
, *temp2
;
3301 /* If we have a relative path
3302 (local_dirname[0] != '/' && local_dirname[0] != '.')
3303 that is canonical after appending it to the current directory, then
3306 strcmp (temp1, temp2) == 0
3307 after adding a slash to temp2 below. It should be safe to not
3310 t
= get_working_directory ("symlink-hook");
3311 temp1
= make_absolute (local_dirname
, t
);
3313 temp2
= sh_canonpath (temp1
, PATH_CHECKDOTDOT
|PATH_CHECKEXISTS
);
3315 /* Try spelling correction if initial canonicalization fails. Make
3316 sure we are set to replace the directory name with the results so
3317 subsequent directory checks don't fail. */
3318 if (temp2
== 0 && dircomplete_spelling
&& dircomplete_expand
)
3320 temp2
= dirspell (temp1
);
3325 temp2
= sh_canonpath (temp1
, PATH_CHECKDOTDOT
|PATH_CHECKEXISTS
);
3326 return_value
|= temp2
!= 0;
3329 /* If we can't canonicalize, bail. */
3333 return return_value
;
3335 len1
= strlen (temp1
);
3336 if (temp1
[len1
- 1] == '/')
3338 len2
= strlen (temp2
);
3339 if (len2
> 2) /* don't append `/' to `/' or `//' */
3341 temp2
= (char *)xrealloc (temp2
, len2
+ 2);
3343 temp2
[len2
+ 1] = '\0';
3347 /* dircomplete_expand_relpath == 0 means we want to leave relative
3348 pathnames that are unchanged by canonicalization alone.
3349 *local_dirname != '/' && *local_dirname != '.' == relative pathname
3350 (consistent with general.c:absolute_pathname())
3351 temp1 == temp2 (after appending a slash to temp2) means the pathname
3352 is not changed by canonicalization as described above. */
3353 if (dircomplete_expand_relpath
|| ((local_dirname
[0] != '/' && local_dirname
[0] != '.') && STREQ (temp1
, temp2
) == 0))
3354 return_value
|= STREQ (local_dirname
, temp2
) == 0;
3355 free (local_dirname
);
3360 return (return_value
);
3363 static char **history_completion_array
= (char **)NULL
;
3364 static int harry_size
;
3365 static int harry_len
;
3368 build_history_completion_array ()
3374 /* First, clear out the current dynamic history completion list. */
3377 strvec_dispose (history_completion_array
);
3378 history_completion_array
= (char **)NULL
;
3383 /* Next, grovel each line of history, making each shell-sized token
3384 a separate entry in the history_completion_array. */
3385 hlist
= history_list ();
3389 for (i
= 0; hlist
[i
]; i
++)
3391 for ( --i
; i
>= 0; i
--)
3393 /* Separate each token, and place into an array. */
3394 tokens
= history_tokenize (hlist
[i
]->line
);
3396 for (j
= 0; tokens
&& tokens
[j
]; j
++)
3398 if (harry_len
+ 2 > harry_size
)
3399 history_completion_array
= strvec_resize (history_completion_array
, harry_size
+= 10);
3401 history_completion_array
[harry_len
++] = tokens
[j
];
3402 history_completion_array
[harry_len
] = (char *)NULL
;
3407 /* Sort the complete list of tokens. */
3408 if (dabbrev_expand_active
== 0)
3409 qsort (history_completion_array
, harry_len
, sizeof (char *), (QSFUNC
*)strvec_strcmp
);
3414 history_completion_generator (hint_text
, state
)
3415 const char *hint_text
;
3418 static int local_index
, len
;
3419 static const char *text
;
3421 /* If this is the first call to the generator, then initialize the
3422 list of strings to complete over. */
3425 if (dabbrev_expand_active
) /* This is kind of messy */
3426 rl_completion_suppress_append
= 1;
3428 build_history_completion_array ();
3430 len
= strlen (text
);
3433 while (history_completion_array
&& history_completion_array
[local_index
])
3435 if (strncmp (text
, history_completion_array
[local_index
++], len
) == 0)
3436 return (savestring (history_completion_array
[local_index
- 1]));
3438 return ((char *)NULL
);
3442 dynamic_complete_history (count
, key
)
3446 rl_compentry_func_t
*orig_func
;
3447 rl_completion_func_t
*orig_attempt_func
;
3448 rl_compignore_func_t
*orig_ignore_func
;
3450 orig_func
= rl_completion_entry_function
;
3451 orig_attempt_func
= rl_attempted_completion_function
;
3452 orig_ignore_func
= rl_ignore_some_completions_function
;
3454 rl_completion_entry_function
= history_completion_generator
;
3455 rl_attempted_completion_function
= (rl_completion_func_t
*)NULL
;
3456 rl_ignore_some_completions_function
= filename_completion_ignore
;
3458 /* XXX - use rl_completion_mode here? */
3459 if (rl_last_func
== dynamic_complete_history
)
3460 r
= rl_complete_internal ('?');
3462 r
= rl_complete_internal (TAB
);
3464 rl_completion_entry_function
= orig_func
;
3465 rl_attempted_completion_function
= orig_attempt_func
;
3466 rl_ignore_some_completions_function
= orig_ignore_func
;
3472 bash_dabbrev_expand (count
, key
)
3475 int r
, orig_suppress
, orig_sort
;
3476 rl_compentry_func_t
*orig_func
;
3477 rl_completion_func_t
*orig_attempt_func
;
3478 rl_compignore_func_t
*orig_ignore_func
;
3480 orig_func
= rl_menu_completion_entry_function
;
3481 orig_attempt_func
= rl_attempted_completion_function
;
3482 orig_ignore_func
= rl_ignore_some_completions_function
;
3483 orig_suppress
= rl_completion_suppress_append
;
3484 orig_sort
= rl_sort_completion_matches
;
3486 rl_menu_completion_entry_function
= history_completion_generator
;
3487 rl_attempted_completion_function
= (rl_completion_func_t
*)NULL
;
3488 rl_ignore_some_completions_function
= filename_completion_ignore
;
3489 rl_filename_completion_desired
= 0;
3490 rl_completion_suppress_append
= 1;
3491 rl_sort_completion_matches
= 0;
3493 /* XXX - use rl_completion_mode here? */
3494 dabbrev_expand_active
= 1;
3495 if (rl_last_func
== bash_dabbrev_expand
)
3496 rl_last_func
= rl_menu_complete
;
3497 r
= rl_menu_complete (count
, key
);
3498 dabbrev_expand_active
= 0;
3500 rl_last_func
= bash_dabbrev_expand
;
3501 rl_menu_completion_entry_function
= orig_func
;
3502 rl_attempted_completion_function
= orig_attempt_func
;
3503 rl_ignore_some_completions_function
= orig_ignore_func
;
3504 rl_completion_suppress_append
= orig_suppress
;
3505 rl_sort_completion_matches
= orig_sort
;
3510 #if defined (SPECIFIC_COMPLETION_FUNCTIONS)
3512 bash_complete_username (ignore
, ignore2
)
3513 int ignore
, ignore2
;
3515 return bash_complete_username_internal (rl_completion_mode (bash_complete_username
));
3519 bash_possible_username_completions (ignore
, ignore2
)
3520 int ignore
, ignore2
;
3522 return bash_complete_username_internal ('?');
3526 bash_complete_username_internal (what_to_do
)
3529 return bash_specific_completion (what_to_do
, rl_username_completion_function
);
3533 bash_complete_filename (ignore
, ignore2
)
3534 int ignore
, ignore2
;
3536 return bash_complete_filename_internal (rl_completion_mode (bash_complete_filename
));
3540 bash_possible_filename_completions (ignore
, ignore2
)
3541 int ignore
, ignore2
;
3543 return bash_complete_filename_internal ('?');
3547 bash_complete_filename_internal (what_to_do
)
3550 rl_compentry_func_t
*orig_func
;
3551 rl_completion_func_t
*orig_attempt_func
;
3552 rl_icppfunc_t
*orig_dir_func
;
3553 rl_compignore_func_t
*orig_ignore_func
;
3554 /*const*/ char *orig_rl_completer_word_break_characters
;
3557 orig_func
= rl_completion_entry_function
;
3558 orig_attempt_func
= rl_attempted_completion_function
;
3559 orig_ignore_func
= rl_ignore_some_completions_function
;
3560 orig_rl_completer_word_break_characters
= rl_completer_word_break_characters
;
3562 orig_dir_func
= save_directory_hook ();
3564 rl_completion_entry_function
= rl_filename_completion_function
;
3565 rl_attempted_completion_function
= (rl_completion_func_t
*)NULL
;
3566 rl_ignore_some_completions_function
= filename_completion_ignore
;
3567 rl_completer_word_break_characters
= " \t\n\"\'";
3569 r
= rl_complete_internal (what_to_do
);
3571 rl_completion_entry_function
= orig_func
;
3572 rl_attempted_completion_function
= orig_attempt_func
;
3573 rl_ignore_some_completions_function
= orig_ignore_func
;
3574 rl_completer_word_break_characters
= orig_rl_completer_word_break_characters
;
3576 restore_directory_hook (orig_dir_func
);
3582 bash_complete_hostname (ignore
, ignore2
)
3583 int ignore
, ignore2
;
3585 return bash_complete_hostname_internal (rl_completion_mode (bash_complete_hostname
));
3589 bash_possible_hostname_completions (ignore
, ignore2
)
3590 int ignore
, ignore2
;
3592 return bash_complete_hostname_internal ('?');
3596 bash_complete_variable (ignore
, ignore2
)
3597 int ignore
, ignore2
;
3599 return bash_complete_variable_internal (rl_completion_mode (bash_complete_variable
));
3603 bash_possible_variable_completions (ignore
, ignore2
)
3604 int ignore
, ignore2
;
3606 return bash_complete_variable_internal ('?');
3610 bash_complete_command (ignore
, ignore2
)
3611 int ignore
, ignore2
;
3613 return bash_complete_command_internal (rl_completion_mode (bash_complete_command
));
3617 bash_possible_command_completions (ignore
, ignore2
)
3618 int ignore
, ignore2
;
3620 return bash_complete_command_internal ('?');
3624 bash_complete_hostname_internal (what_to_do
)
3627 return bash_specific_completion (what_to_do
, hostname_completion_function
);
3631 bash_complete_variable_internal (what_to_do
)
3634 return bash_specific_completion (what_to_do
, variable_completion_function
);
3638 bash_complete_command_internal (what_to_do
)
3641 return bash_specific_completion (what_to_do
, command_word_completion_function
);
3644 static char *globtext
;
3645 static char *globorig
;
3648 glob_complete_word (text
, state
)
3652 static char **matches
= (char **)NULL
;
3659 rl_filename_completion_desired
= 1;
3661 if (globorig
!= globtext
)
3665 ttext
= bash_tilde_expand (text
, 0);
3667 if (rl_explicit_arg
)
3669 globorig
= savestring (ttext
);
3670 glen
= strlen (ttext
);
3671 globtext
= (char *)xmalloc (glen
+ 2);
3672 strcpy (globtext
, ttext
);
3673 globtext
[glen
] = '*';
3674 globtext
[glen
+1] = '\0';
3677 globtext
= globorig
= savestring (ttext
);
3682 matches
= shell_glob_filename (globtext
);
3683 if (GLOB_FAILED (matches
))
3684 matches
= (char **)NULL
;
3688 ret
= matches
? matches
[ind
] : (char *)NULL
;
3694 bash_glob_completion_internal (what_to_do
)
3697 return bash_specific_completion (what_to_do
, glob_complete_word
);
3700 /* A special quoting function so we don't end up quoting globbing characters
3701 in the word if there are no matches or multiple matches. */
3703 bash_glob_quote_filename (s
, rtype
, qcp
)
3708 if (globorig
&& qcp
&& *qcp
== '\0' && STREQ (s
, globorig
))
3709 return (savestring (s
));
3711 return (bash_quote_filename (s
, rtype
, qcp
));
3715 bash_glob_complete_word (count
, key
)
3719 rl_quote_func_t
*orig_quoting_function
;
3721 if (rl_editing_mode
== EMACS_EDITING_MODE
)
3722 rl_explicit_arg
= 1; /* force `*' append */
3723 orig_quoting_function
= rl_filename_quoting_function
;
3724 rl_filename_quoting_function
= bash_glob_quote_filename
;
3726 r
= bash_glob_completion_internal (rl_completion_mode (bash_glob_complete_word
));
3728 rl_filename_quoting_function
= orig_quoting_function
;
3733 bash_glob_expand_word (count
, key
)
3736 return bash_glob_completion_internal ('*');
3740 bash_glob_list_expansions (count
, key
)
3743 return bash_glob_completion_internal ('?');
3747 bash_specific_completion (what_to_do
, generator
)
3749 rl_compentry_func_t
*generator
;
3751 rl_compentry_func_t
*orig_func
;
3752 rl_completion_func_t
*orig_attempt_func
;
3753 rl_compignore_func_t
*orig_ignore_func
;
3756 orig_func
= rl_completion_entry_function
;
3757 orig_attempt_func
= rl_attempted_completion_function
;
3758 orig_ignore_func
= rl_ignore_some_completions_function
;
3759 rl_completion_entry_function
= generator
;
3760 rl_attempted_completion_function
= NULL
;
3761 rl_ignore_some_completions_function
= orig_ignore_func
;
3763 r
= rl_complete_internal (what_to_do
);
3765 rl_completion_entry_function
= orig_func
;
3766 rl_attempted_completion_function
= orig_attempt_func
;
3767 rl_ignore_some_completions_function
= orig_ignore_func
;
3772 #endif /* SPECIFIC_COMPLETION_FUNCTIONS */
3774 #if defined (VI_MODE)
3775 /* Completion, from vi mode's point of view. This is a modified version of
3776 rl_vi_complete which uses the bash globbing code to implement what POSIX
3777 specifies, which is to append a `*' and attempt filename generation (which
3778 has the side effect of expanding any globbing characters in the word). */
3780 bash_vi_complete (count
, key
)
3783 #if defined (SPECIFIC_COMPLETION_FUNCTIONS)
3787 if ((rl_point
< rl_end
) && (!whitespace (rl_line_buffer
[rl_point
])))
3789 if (!whitespace (rl_line_buffer
[rl_point
+ 1]))
3790 rl_vi_end_word (1, 'E');
3794 /* Find boundaries of current word, according to vi definition of a
3800 rl_vi_bWord (1, 'B');
3805 t
= substring (rl_line_buffer
, p
, rl_point
);
3808 if (t
&& glob_pattern_p (t
) == 0)
3809 rl_explicit_arg
= 1; /* XXX - force glob_complete_word to append `*' */
3812 if (key
== '*') /* Expansion and replacement. */
3813 r
= bash_glob_expand_word (count
, key
);
3814 else if (key
== '=') /* List possible completions. */
3815 r
= bash_glob_list_expansions (count
, key
);
3816 else if (key
== '\\') /* Standard completion */
3817 r
= bash_glob_complete_word (count
, key
);
3819 r
= rl_complete (0, key
);
3821 if (key
== '*' || key
== '\\')
3822 rl_vi_start_inserting (key
, 1, 1);
3826 return rl_vi_complete (count
, key
);
3827 #endif /* !SPECIFIC_COMPLETION_FUNCTIONS */
3829 #endif /* VI_MODE */
3831 /* Filename quoting for completion. */
3832 /* A function to strip unquoted quote characters (single quotes, double
3833 quotes, and backslashes). It allows single quotes to appear
3834 within double quotes, and vice versa. It should be smarter. */
3836 bash_dequote_filename (text
, quote_char
)
3844 ret
= (char *)xmalloc (l
+ 1);
3845 for (quoted
= quote_char
, p
= text
, r
= ret
; p
&& *p
; p
++)
3847 /* Allow backslash-escaped characters to pass through unscathed. */
3850 /* Backslashes are preserved within single quotes. */
3853 /* Backslashes are preserved within double quotes unless the
3854 character is one that is defined to be escaped */
3855 else if (quoted
== '"' && ((sh_syntaxtab
[p
[1]] & CBSDQUOTE
) == 0))
3860 return ret
; /* XXX - was break; */
3864 if (quoted
&& *p
== quoted
)
3870 if (quoted
== 0 && (*p
== '\'' || *p
== '"'))
3881 /* Quote characters that the readline completion code would treat as
3882 word break characters with backslashes. Pass backslash-quoted
3883 characters through without examination. */
3885 quote_word_break_chars (text
)
3892 ret
= (char *)xmalloc ((2 * l
) + 1);
3893 for (s
= text
, r
= ret
; *s
; s
++)
3895 /* Pass backslash-quoted characters through, including the backslash. */
3904 /* OK, we have an unquoted character. Check its presence in
3905 rl_completer_word_break_characters. */
3906 if (mbschr (rl_completer_word_break_characters
, *s
))
3908 /* XXX -- check for standalone tildes here and backslash-quote them */
3909 if (s
== text
&& *s
== '~' && file_exists (text
))
3917 /* Use characters in STRING to populate the table of characters that should
3918 be backslash-quoted. The table will be used for sh_backslash_quote from
3921 set_filename_bstab (string
)
3926 memset (filename_bstab
, 0, sizeof (filename_bstab
));
3927 for (s
= string
; s
&& *s
; s
++)
3928 filename_bstab
[*s
] = 1;
3931 /* Quote a filename using double quotes, single quotes, or backslashes
3932 depending on the value of completion_quoting_style. If we're
3933 completing using backslashes, we need to quote some additional
3934 characters (those that readline treats as word breaks), so we call
3935 quote_word_break_chars on the result. This returns newly-allocated
3938 bash_quote_filename (s
, rtype
, qcp
)
3943 char *rtext
, *mtext
, *ret
;
3946 rtext
= (char *)NULL
;
3948 /* If RTYPE == MULT_MATCH, it means that there is
3949 more than one match. In this case, we do not add
3950 the closing quote or attempt to perform tilde
3951 expansion. If RTYPE == SINGLE_MATCH, we try
3952 to perform tilde expansion, because single and double
3953 quotes inhibit tilde expansion by the shell. */
3955 cs
= completion_quoting_style
;
3956 /* Might need to modify the default completion style based on *qcp,
3957 since it's set to any user-provided opening quote. We also change
3958 to single-quoting if there is no user-provided opening quote and
3959 the word being completed contains newlines, since those are not
3960 quoted correctly using backslashes (a backslash-newline pair is
3961 special to the shell parser). */
3962 if (*qcp
== '\0' && cs
== COMPLETE_BSQUOTE
&& mbschr (s
, '\n'))
3963 cs
= COMPLETE_SQUOTE
;
3964 else if (*qcp
== '"')
3965 cs
= COMPLETE_DQUOTE
;
3966 else if (*qcp
== '\'')
3967 cs
= COMPLETE_SQUOTE
;
3968 #if defined (BANG_HISTORY)
3969 else if (*qcp
== '\0' && history_expansion
&& cs
== COMPLETE_DQUOTE
&&
3970 history_expansion_inhibited
== 0 && mbschr (s
, '!'))
3971 cs
= COMPLETE_BSQUOTE
;
3973 if (*qcp
== '"' && history_expansion
&& cs
== COMPLETE_DQUOTE
&&
3974 history_expansion_inhibited
== 0 && mbschr (s
, '!'))
3976 cs
= COMPLETE_BSQUOTE
;
3981 /* Don't tilde-expand backslash-quoted filenames, since only single and
3982 double quotes inhibit tilde expansion. */
3984 if (mtext
[0] == '~' && rtype
== SINGLE_MATCH
&& cs
!= COMPLETE_BSQUOTE
)
3985 mtext
= bash_tilde_expand (s
, 0);
3989 case COMPLETE_DQUOTE
:
3990 rtext
= sh_double_quote (mtext
);
3992 case COMPLETE_SQUOTE
:
3993 rtext
= sh_single_quote (mtext
);
3995 case COMPLETE_BSQUOTE
:
3996 rtext
= sh_backslash_quote (mtext
, complete_fullquote
? 0 : filename_bstab
, 0);
4003 /* We may need to quote additional characters: those that readline treats
4004 as word breaks that are not quoted by backslash_quote. */
4005 if (rtext
&& cs
== COMPLETE_BSQUOTE
)
4007 mtext
= quote_word_break_chars (rtext
);
4012 /* Leave the opening quote intact. The readline completion code takes
4013 care of avoiding doubled opening quotes. */
4016 rlen
= strlen (rtext
);
4017 ret
= (char *)xmalloc (rlen
+ 1);
4018 strcpy (ret
, rtext
);
4022 ret
= (char *)xmalloc (rlen
= 1);
4026 /* If there are multiple matches, cut off the closing quote. */
4027 if (rtype
== MULT_MATCH
&& cs
!= COMPLETE_BSQUOTE
)
4028 ret
[rlen
- 1] = '\0';
4033 /* Support for binding readline key sequences to Unix commands. */
4034 static Keymap cmd_xmap
;
4045 x
= putc (c
, rl_outstream
);
4052 bash_execute_unix_command (count
, key
)
4053 int count
; /* ignored */
4056 Keymap ckmap
; /* current keymap */
4057 Keymap xkmap
; /* unix command executing keymap */
4058 rl_command_func_t
*func
;
4062 sh_parser_state_t ps
;
4063 char *cmd
, *value
, *l
, *l1
, *ce
;
4065 char ibuf
[INT_STRLEN_BOUND(int) + 1];
4067 /* First, we need to find the right command to execute. This is tricky,
4068 because we might have already indirected into another keymap, so we
4069 have to walk cmd_xmap using the entire key sequence. */
4070 cmd
= (char *)rl_function_of_keyseq (rl_executing_keyseq
, cmd_xmap
, &type
);
4072 if (cmd
== 0 || type
!= ISMACR
)
4075 internal_error (_("bash_execute_unix_command: cannot find keymap for command"));
4076 rl_forced_update_display ();
4080 ce
= rl_get_termcap ("ce");
4081 if (ce
) /* clear current line */
4084 fprintf (rl_outstream
, "\r");
4085 tputs (ce
, 1, putx
);
4087 rl_clear_visible_line ();
4089 fflush (rl_outstream
);
4092 rl_crlf (); /* move to a new line */
4094 v
= bind_variable ("READLINE_LINE", rl_line_buffer
, 0);
4096 VSETATTR (v
, att_exported
);
4097 l
= v
? value_cell (v
) : 0;
4098 value
= inttostr (rl_point
, ibuf
, sizeof (ibuf
));
4099 v
= bind_int_variable ("READLINE_POINT", value
);
4101 VSETATTR (v
, att_exported
);
4102 array_needs_making
= 1;
4104 save_parser_state (&ps
);
4105 r
= parse_and_execute (cmd
, "bash_execute_unix_command", SEVAL_NOHIST
|SEVAL_NOFREE
);
4106 restore_parser_state (&ps
);
4108 v
= find_variable ("READLINE_LINE");
4109 l1
= v
? value_cell (v
) : 0;
4111 maybe_make_readline_line (value_cell (v
));
4112 v
= find_variable ("READLINE_POINT");
4113 if (v
&& legal_number (value_cell (v
), &mi
))
4119 if (rl_point
> rl_end
)
4121 else if (rl_point
< 0)
4126 unbind_variable ("READLINE_LINE");
4127 unbind_variable ("READLINE_POINT");
4128 array_needs_making
= 1;
4130 /* and restore the readline buffer and display after command execution. */
4131 /* If we clear the last line of the prompt above, redraw only that last
4132 line. If the command returns 124, we redraw unconditionally as in
4133 previous versions. */
4135 rl_redraw_prompt_last_line ();
4137 rl_forced_update_display ();
4143 print_unix_command_map ()
4147 save
= rl_get_keymap ();
4148 rl_set_keymap (cmd_xmap
);
4149 rl_macro_dumper (1);
4150 rl_set_keymap (save
);
4155 init_unix_command_map ()
4157 cmd_xmap
= rl_make_bare_keymap ();
4161 isolate_sequence (string
, ind
, need_dquote
, startp
)
4163 int ind
, need_dquote
, *startp
;
4166 int c
, passc
, delim
;
4168 for (i
= ind
; string
[i
] && whitespace (string
[i
]); i
++)
4170 /* NEED_DQUOTE means that the first non-white character *must* be `"'. */
4171 if (need_dquote
&& string
[i
] != '"')
4173 builtin_error (_("%s: first non-whitespace character is not `\"'"), string
);
4177 /* We can have delimited strings even if NEED_DQUOTE == 0, like the command
4178 string to bind the key sequence to. */
4179 delim
= (string
[i
] == '"' || string
[i
] == '\'') ? string
[i
] : 0;
4182 *startp
= delim
? ++i
: i
;
4184 for (passc
= 0; c
= string
[i
]; i
++)
4200 if (delim
&& string
[i
] != delim
)
4202 builtin_error (_("no closing `%c' in %s"), delim
, string
);
4210 bind_keyseq_to_unix_command (line
)
4218 init_unix_command_map ();
4220 kmap
= rl_get_keymap ();
4222 /* We duplicate some of the work done by rl_parse_and_bind here, but
4223 this code only has to handle `"keyseq": ["]command["]' and can
4224 generate an error for anything else. */
4225 i
= isolate_sequence (line
, 0, 1, &kstart
);
4229 /* Create the key sequence string to pass to rl_generic_bind */
4230 kseq
= substring (line
, kstart
, i
);
4232 for ( ; line
[i
] && line
[i
] != ':'; i
++)
4236 builtin_error (_("%s: missing colon separator"), line
);
4241 i
= isolate_sequence (line
, i
+ 1, 0, &kstart
);
4248 /* Create the value string containing the command to execute. */
4249 value
= substring (line
, kstart
, i
);
4251 /* Save the command to execute and the key sequence in the CMD_XMAP */
4252 rl_generic_bind (ISMACR
, kseq
, value
, cmd_xmap
);
4254 /* and bind the key sequence in the current keymap to a function that
4255 understands how to execute from CMD_XMAP */
4256 rl_bind_keyseq_in_map (kseq
, bash_execute_unix_command
, kmap
);
4262 /* Used by the programmable completion code. Complete TEXT as a filename,
4263 but return only directories as matches. Dequotes the filename before
4264 attempting to find matches. */
4266 bash_directory_completion_matches (text
)
4273 qc
= rl_dispatching
? rl_completion_quote_character
: 0;
4274 /* If rl_completion_found_quote != 0, rl_completion_matches will call the
4275 filename dequoting function, causing the directory name to be dequoted
4277 if (rl_dispatching
&& rl_completion_found_quote
== 0)
4278 dfn
= bash_dequote_filename ((char *)text
, qc
);
4281 m1
= rl_completion_matches (dfn
, rl_filename_completion_function
);
4285 if (m1
== 0 || m1
[0] == 0)
4287 /* We don't bother recomputing the lcd of the matches, because it will just
4288 get thrown away by the programmable completion code and recomputed
4290 (void)bash_ignore_filenames (m1
);
4295 bash_dequote_text (text
)
4301 qc
= (text
[0] == '"' || text
[0] == '\'') ? text
[0] : 0;
4302 dtxt
= bash_dequote_filename ((char *)text
, qc
);
4306 /* This event hook is designed to be called after readline receives a signal
4307 that interrupts read(2). It gives reasonable responsiveness to interrupts
4308 and fatal signals without executing too much code in a signal handler
4313 /* If we're going to longjmp to top_level, make sure we clean up readline.
4314 check_signals will call QUIT, which will eventually longjmp to top_level,
4315 calling run_interrupt_trap along the way. The check for sigalrm_seen is
4316 to clean up the read builtin's state. */
4317 if (terminating_signal
|| interrupt_state
|| sigalrm_seen
)
4318 rl_cleanup_after_signal ();
4319 bashline_reset_event_hook ();
4320 check_signals_and_traps (); /* XXX */
4324 #endif /* READLINE */