1 /* pcomplete.c - functions to generate lists of matches for programmable completion. */
3 /* Copyright (C) 1999-2012 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 (PROGRAMMABLE_COMPLETION)
25 #include "bashtypes.h"
26 #include "posixstat.h"
28 #if defined (HAVE_UNISTD_H)
34 #if defined (PREFER_STDARG)
47 #include "pcomplete.h"
50 #include "execute_cmd.h"
53 #if defined (JOB_CONTROL)
64 #include "builtins/common.h"
65 #include "builtins/builtext.h"
67 #include <glob/glob.h>
68 #include <glob/strmatch.h>
70 #include <readline/rlconf.h>
71 #include <readline/readline.h>
72 #include <readline/history.h>
74 #define PCOMP_RETRYFAIL 256
79 #define STRDUP(x) ((x) ? savestring (x) : (char *)NULL)
81 typedef SHELL_VAR **SVFUNC ();
84 extern char *strpbrk __P((char *, char *));
87 extern int array_needs_making;
88 extern STRING_INT_ALIST word_token_alist[];
89 extern char *signal_names[];
90 extern sh_builtin_func_t *last_shell_builtin, *this_shell_builtin;
93 #if defined (PREFER_STDARG)
94 static void debug_printf (const char *, ...) __attribute__((__format__ (printf, 1, 2)));
98 static int it_init_joblist __P((ITEMLIST *, int));
100 static int it_init_aliases __P((ITEMLIST *));
101 static int it_init_arrayvars __P((ITEMLIST *));
102 static int it_init_bindings __P((ITEMLIST *));
103 static int it_init_builtins __P((ITEMLIST *));
104 static int it_init_disabled __P((ITEMLIST *));
105 static int it_init_enabled __P((ITEMLIST *));
106 static int it_init_exported __P((ITEMLIST *));
107 static int it_init_functions __P((ITEMLIST *));
108 static int it_init_helptopics __P((ITEMLIST *));
109 static int it_init_hostnames __P((ITEMLIST *));
110 static int it_init_jobs __P((ITEMLIST *));
111 static int it_init_running __P((ITEMLIST *));
112 static int it_init_stopped __P((ITEMLIST *));
113 static int it_init_keywords __P((ITEMLIST *));
114 static int it_init_signals __P((ITEMLIST *));
115 static int it_init_variables __P((ITEMLIST *));
116 static int it_init_setopts __P((ITEMLIST *));
117 static int it_init_shopts __P((ITEMLIST *));
119 static int shouldexp_filterpat __P((char *));
120 static char *preproc_filterpat __P((char *, char *));
122 static void init_itemlist_from_varlist __P((ITEMLIST *, SVFUNC *));
124 static STRINGLIST *gen_matches_from_itemlist __P((ITEMLIST *, const char *));
125 static STRINGLIST *gen_action_completions __P((COMPSPEC *, const char *));
126 static STRINGLIST *gen_globpat_matches __P((COMPSPEC *, const char *));
127 static STRINGLIST *gen_wordlist_matches __P((COMPSPEC *, const char *));
128 static STRINGLIST *gen_shell_function_matches __P((COMPSPEC *, const char *,
130 char *, int, WORD_LIST *,
132 static STRINGLIST *gen_command_matches __P((COMPSPEC *, const char *,
134 char *, int, WORD_LIST *,
137 static STRINGLIST *gen_progcomp_completions __P((const char *, const char *,
139 int, int, int *, int *,
142 static char *pcomp_filename_completion_function __P((const char *, int));
144 #if defined (ARRAY_VARS)
145 static SHELL_VAR *bind_comp_words __P((WORD_LIST *));
147 static void bind_compfunc_variables __P((char *, int, WORD_LIST *, int, int));
148 static void unbind_compfunc_variables __P((int));
149 static WORD_LIST *build_arg_list __P((char *, const char *, const char *, WORD_LIST *, int));
150 static WORD_LIST *command_line_to_word_list __P((char *, int, int, int *, int *));
153 static int progcomp_debug = 0;
156 int prog_completion_enabled = 1;
158 /* These are used to manage the arrays of strings for possible completions. */
159 ITEMLIST it_aliases = { 0, it_init_aliases, (STRINGLIST *)0 };
160 ITEMLIST it_arrayvars = { LIST_DYNAMIC, it_init_arrayvars, (STRINGLIST *)0 };
161 ITEMLIST it_bindings = { 0, it_init_bindings, (STRINGLIST *)0 };
162 ITEMLIST it_builtins = { 0, it_init_builtins, (STRINGLIST *)0 };
163 ITEMLIST it_commands = { LIST_DYNAMIC }; /* unused */
164 ITEMLIST it_directories = { LIST_DYNAMIC }; /* unused */
165 ITEMLIST it_disabled = { 0, it_init_disabled, (STRINGLIST *)0 };
166 ITEMLIST it_enabled = { 0, it_init_enabled, (STRINGLIST *)0 };
167 ITEMLIST it_exports = { LIST_DYNAMIC, it_init_exported, (STRINGLIST *)0 };
168 ITEMLIST it_files = { LIST_DYNAMIC }; /* unused */
169 ITEMLIST it_functions = { 0, it_init_functions, (STRINGLIST *)0 };
170 ITEMLIST it_helptopics = { 0, it_init_helptopics, (STRINGLIST *)0 };
171 ITEMLIST it_hostnames = { LIST_DYNAMIC, it_init_hostnames, (STRINGLIST *)0 };
172 ITEMLIST it_groups = { LIST_DYNAMIC }; /* unused */
173 ITEMLIST it_jobs = { LIST_DYNAMIC, it_init_jobs, (STRINGLIST *)0 };
174 ITEMLIST it_keywords = { 0, it_init_keywords, (STRINGLIST *)0 };
175 ITEMLIST it_running = { LIST_DYNAMIC, it_init_running, (STRINGLIST *)0 };
176 ITEMLIST it_services = { LIST_DYNAMIC }; /* unused */
177 ITEMLIST it_setopts = { 0, it_init_setopts, (STRINGLIST *)0 };
178 ITEMLIST it_shopts = { 0, it_init_shopts, (STRINGLIST *)0 };
179 ITEMLIST it_signals = { 0, it_init_signals, (STRINGLIST *)0 };
180 ITEMLIST it_stopped = { LIST_DYNAMIC, it_init_stopped, (STRINGLIST *)0 };
181 ITEMLIST it_users = { LIST_DYNAMIC }; /* unused */
182 ITEMLIST it_variables = { LIST_DYNAMIC, it_init_variables, (STRINGLIST *)0 };
184 COMPSPEC *pcomp_curcs;
185 const char *pcomp_curcmd;
186 const char *pcomp_curtxt;
191 #if defined (PREFER_STDARG)
192 debug_printf (const char *format, ...)
194 debug_printf (format, va_alist)
201 if (progcomp_debug == 0)
204 SH_VA_START (args, format);
206 fprintf (stdout, "DEBUG: ");
207 vfprintf (stdout, format, args);
208 fprintf (stdout, "\n");
216 /* Functions to manage the item lists */
219 set_itemlist_dirty (it)
222 it->flags |= LIST_DIRTY;
226 initialize_itemlist (itp)
229 (*itp->list_getter) (itp);
230 itp->flags |= LIST_INITIALIZED;
231 itp->flags &= ~LIST_DIRTY;
243 if ((itp->flags & (LIST_DONTFREEMEMBERS|LIST_DONTFREE)) == 0)
244 strvec_flush (sl->list);
245 if ((itp->flags & LIST_DONTFREE) == 0)
249 itp->slist = (STRINGLIST *)NULL;
250 itp->flags &= ~(LIST_DONTFREE|LIST_DONTFREEMEMBERS|LIST_INITIALIZED|LIST_DIRTY);
255 shouldexp_filterpat (s)
260 for (p = s; p && *p; p++)
270 /* Replace any instance of `&' in PAT with TEXT. Backslash may be used to
271 quote a `&' and inhibit substitution. Returns a new string. This just
272 calls stringlib.c:strcreplace(). */
274 preproc_filterpat (pat, text)
280 ret = strcreplace (pat, '&', text, 1);
284 /* Remove any match of FILTERPAT from SL. A `&' in FILTERPAT is replaced by
285 TEXT. A leading `!' in FILTERPAT negates the pattern; in this case
286 any member of SL->list that does *not* match will be removed. This returns
287 a new STRINGLIST with the matching members of SL *copied*. Any
288 non-matching members of SL->list are *freed*. */
290 filter_stringlist (sl, filterpat, text)
292 char *filterpat, *text;
298 if (sl == 0 || sl->list == 0 || sl->list_len == 0)
301 npat = shouldexp_filterpat (filterpat) ? preproc_filterpat (filterpat, text) : filterpat;
303 not = (npat[0] == '!');
304 t = not ? npat + 1 : npat;
306 ret = strlist_create (sl->list_size);
307 for (i = 0; i < sl->list_len; i++)
309 m = strmatch (t, sl->list[i], FNMATCH_EXTFLAG);
310 if ((not && m == FNM_NOMATCH) || (not == 0 && m != FNM_NOMATCH))
313 ret->list[ret->list_len++] = sl->list[i];
316 ret->list[ret->list_len] = (char *)NULL;
317 if (npat != filterpat)
323 /* Turn an array of strings returned by rl_completion_matches into a STRINGLIST.
324 This understands how rl_completion_matches sets matches[0] (the lcd of the
325 strings in the list, unless it's the only match). */
327 completions_to_stringlist (matches)
333 mlen = (matches == 0) ? 0 : strvec_len (matches);
334 sl = strlist_create (mlen + 1);
336 if (matches == 0 || matches[0] == 0)
341 sl->list[0] = STRDUP (matches[0]);
342 sl->list[sl->list_len = 1] = (char *)NULL;
346 for (i = 1, n = 0; i < mlen; i++, n++)
347 sl->list[n] = STRDUP (matches[i]);
349 sl->list[n] = (char *)NULL;
354 /* Functions to manage the various ITEMLISTs that we populate internally.
355 The caller is responsible for setting ITP->flags correctly. */
358 it_init_aliases (itp)
362 alias_t **alias_list;
366 alias_list = all_aliases ();
369 itp->slist = (STRINGLIST *)NULL;
372 for (n = 0; alias_list[n]; n++)
374 sl = strlist_create (n+1);
375 for (i = 0; i < n; i++)
376 sl->list[i] = STRDUP (alias_list[i]->name);
377 sl->list[n] = (char *)NULL;
378 sl->list_size = sl->list_len = n;
381 itp->slist = (STRINGLIST *)NULL;
388 init_itemlist_from_varlist (itp, svfunc)
396 vlist = (*svfunc) ();
399 itp->slist = (STRINGLIST *)NULL;
402 for (n = 0; vlist[n]; n++)
404 sl = strlist_create (n+1);
405 for (i = 0; i < n; i++)
406 sl->list[i] = savestring (vlist[i]->name);
407 sl->list[sl->list_len = n] = (char *)NULL;
412 it_init_arrayvars (itp)
415 #if defined (ARRAY_VARS)
416 init_itemlist_from_varlist (itp, all_array_variables);
424 it_init_bindings (itp)
430 /* rl_funmap_names allocates blist, but not its members */
431 blist = (char **)rl_funmap_names (); /* XXX fix const later */
432 sl = strlist_create (0);
435 sl->list_len = strvec_len (sl->list);
436 itp->flags |= LIST_DONTFREEMEMBERS;
443 it_init_builtins (itp)
449 sl = strlist_create (num_shell_builtins);
450 for (i = n = 0; i < num_shell_builtins; i++)
451 if (shell_builtins[i].function)
452 sl->list[n++] = shell_builtins[i].name;
453 sl->list[sl->list_len = n] = (char *)NULL;
454 itp->flags |= LIST_DONTFREEMEMBERS;
460 it_init_enabled (itp)
466 sl = strlist_create (num_shell_builtins);
467 for (i = n = 0; i < num_shell_builtins; i++)
469 if (shell_builtins[i].function && (shell_builtins[i].flags & BUILTIN_ENABLED))
470 sl->list[n++] = shell_builtins[i].name;
472 sl->list[sl->list_len = n] = (char *)NULL;
473 itp->flags |= LIST_DONTFREEMEMBERS;
479 it_init_disabled (itp)
485 sl = strlist_create (num_shell_builtins);
486 for (i = n = 0; i < num_shell_builtins; i++)
488 if (shell_builtins[i].function && ((shell_builtins[i].flags & BUILTIN_ENABLED) == 0))
489 sl->list[n++] = shell_builtins[i].name;
491 sl->list[sl->list_len = n] = (char *)NULL;
492 itp->flags |= LIST_DONTFREEMEMBERS;
498 it_init_exported (itp)
501 init_itemlist_from_varlist (itp, all_exported_variables);
506 it_init_functions (itp)
509 init_itemlist_from_varlist (itp, all_visible_functions);
513 /* Like it_init_builtins, but includes everything the help builtin looks at,
514 not just builtins with an active implementing function. */
516 it_init_helptopics (itp)
522 sl = strlist_create (num_shell_builtins);
523 for (i = n = 0; i < num_shell_builtins; i++)
524 sl->list[n++] = shell_builtins[i].name;
525 sl->list[sl->list_len = n] = (char *)NULL;
526 itp->flags |= LIST_DONTFREEMEMBERS;
532 it_init_hostnames (itp)
537 sl = strlist_create (0);
538 sl->list = get_hostname_list ();
539 sl->list_len = sl->list ? strvec_len (sl->list) : 0;
540 sl->list_size = sl->list_len;
542 itp->flags |= LIST_DONTFREEMEMBERS|LIST_DONTFREE;
547 it_init_joblist (itp, jstate)
551 #if defined (JOB_CONTROL)
557 JOB_STATE ws; /* wanted state */
562 else if (jstate == 1)
565 sl = strlist_create (js.j_jobslots);
566 for (i = js.j_jobslots - 1; i >= 0; i--)
568 j = get_job_by_jid (i);
572 if (jstate == -1 || JOBSTATE(i) == ws)
574 s = savestring (p->command);
575 t = strpbrk (s, " \t\n");
578 sl->list[sl->list_len++] = s;
583 itp->slist = (STRINGLIST *)NULL;
592 return (it_init_joblist (itp, -1));
596 it_init_running (itp)
599 return (it_init_joblist (itp, 0));
603 it_init_stopped (itp)
606 return (it_init_joblist (itp, 1));
610 it_init_keywords (itp)
616 for (n = 0; word_token_alist[n].word; n++)
618 sl = strlist_create (n);
619 for (i = 0; i < n; i++)
620 sl->list[i] = word_token_alist[i].word;
621 sl->list[sl->list_len = i] = (char *)NULL;
622 itp->flags |= LIST_DONTFREEMEMBERS;
628 it_init_signals (itp)
633 sl = strlist_create (0);
634 sl->list = signal_names;
635 sl->list_len = strvec_len (sl->list);
636 itp->flags |= LIST_DONTFREE;
642 it_init_variables (itp)
645 init_itemlist_from_varlist (itp, all_visible_variables);
650 it_init_setopts (itp)
655 sl = strlist_create (0);
656 sl->list = get_minus_o_opts ();
657 sl->list_len = strvec_len (sl->list);
659 itp->flags |= LIST_DONTFREEMEMBERS;
669 sl = strlist_create (0);
670 sl->list = get_shopt_options ();
671 sl->list_len = strvec_len (sl->list);
673 itp->flags |= LIST_DONTFREEMEMBERS;
677 /* Generate a list of all matches for TEXT using the STRINGLIST in itp->slist
678 as the list of possibilities. If the itemlist has been marked dirty or
679 it should be regenerated every time, destroy the old STRINGLIST and make a
680 new one before trying the match. TEXT is dequoted before attempting a
683 gen_matches_from_itemlist (itp, text)
687 STRINGLIST *ret, *sl;
691 if ((itp->flags & (LIST_DIRTY|LIST_DYNAMIC)) ||
692 (itp->flags & LIST_INITIALIZED) == 0)
694 if (itp->flags & (LIST_DIRTY|LIST_DYNAMIC))
695 clean_itemlist (itp);
696 if ((itp->flags & LIST_INITIALIZED) == 0)
697 initialize_itemlist (itp);
700 return ((STRINGLIST *)NULL);
701 ret = strlist_create (itp->slist->list_len+1);
704 ntxt = bash_dequote_text (text);
705 tlen = STRLEN (ntxt);
707 for (i = n = 0; i < sl->list_len; i++)
709 if (tlen == 0 || STREQN (sl->list[i], ntxt, tlen))
710 ret->list[n++] = STRDUP (sl->list[i]);
712 ret->list[ret->list_len = n] = (char *)NULL;
718 /* A wrapper for rl_filename_completion_function that dequotes the filename
719 before attempting completions. */
721 pcomp_filename_completion_function (text, state)
725 static char *dfn; /* dequoted filename */
727 int iscompgen, iscompleting;
732 /* remove backslashes quoting special characters in filenames. */
733 /* There are roughly three paths we can follow to get here:
735 2. compgen -f "$word" from a completion function
736 3. compgen -f "$word" from the command line
737 They all need to be handled.
739 In the first two cases, readline will run the filename dequoting
740 function in rl_filename_completion_function if it found a filename
741 quoting character in the word to be completed
742 (rl_completion_found_quote). We run the dequoting function here
743 if we're running compgen, we're not completing, and the
744 rl_filename_completion_function won't dequote the filename
745 (rl_completion_found_quote == 0). */
746 iscompgen = this_shell_builtin == compgen_builtin;
747 iscompleting = RL_ISSTATE (RL_STATE_COMPLETING);
748 if (iscompgen && iscompleting == 0 && rl_completion_found_quote == 0
749 && rl_filename_dequoting_function)
751 /* Use rl_completion_quote_character because any single or
752 double quotes have been removed by the time TEXT makes it
753 here, and we don't want to remove backslashes inside
755 dfn = (*rl_filename_dequoting_function) ((char *)text, rl_completion_quote_character);
757 /* Intended to solve a mismatched assumption by bash-completion. If
758 the text to be completed is empty, but bash-completion turns it into
759 a quoted string ('') assuming that this code will dequote it before
760 calling readline, do the dequoting. */
761 else if (iscompgen && iscompleting &&
762 pcomp_curtxt && *pcomp_curtxt == 0 &&
763 text && (*text == '\'' || *text == '"') && text[1] == text[0] && text[2] == 0 &&
764 rl_filename_dequoting_function)
765 dfn = (*rl_filename_dequoting_function) ((char *)text, rl_completion_quote_character);
766 /* Another mismatched assumption by bash-completion. If compgen is being
767 run as part of bash-completion, and the argument to compgen is not
768 the same as the word originally passed to the programmable completion
769 code, dequote the argument if it has quote characters. It's an
770 attempt to detect when bash-completion is quoting its filename
771 argument before calling compgen. */
772 /* We could check whether gen_shell_function_matches is in the call
773 stack by checking whether the gen-shell-function-matches tag is in
774 the unwind-protect stack, but there's no function to do that yet.
775 We could simply check whether we're executing in a function by
776 checking variable_context, and may end up doing that. */
777 else if (iscompgen && iscompleting && rl_filename_dequoting_function &&
778 pcomp_curtxt && text &&
779 STREQ (pcomp_curtxt, text) == 0 &&
781 sh_contains_quotes (text)) /* guess */
782 dfn = (*rl_filename_dequoting_function) ((char *)text, rl_completion_quote_character);
784 dfn = savestring (text);
787 return (rl_filename_completion_function (dfn, state));
790 #define GEN_COMPS(bmap, flag, it, text, glist, tlist) \
794 tlist = gen_matches_from_itemlist (it, text); \
797 glist = strlist_append (glist, tlist); \
798 strlist_dispose (tlist); \
803 #define GEN_XCOMPS(bmap, flag, text, func, cmatches, glist, tlist) \
807 cmatches = rl_completion_matches (text, func); \
808 tlist = completions_to_stringlist (cmatches); \
809 glist = strlist_append (glist, tlist); \
810 strvec_dispose (cmatches); \
811 strlist_dispose (tlist); \
815 /* Functions to generate lists of matches from the actions member of CS. */
818 gen_action_completions (cs, text)
822 STRINGLIST *ret, *tmatches;
823 char **cmatches; /* from rl_completion_matches ... */
827 ret = tmatches = (STRINGLIST *)NULL;
830 GEN_COMPS (flags, CA_ALIAS, &it_aliases, text, ret, tmatches);
831 GEN_COMPS (flags, CA_ARRAYVAR, &it_arrayvars, text, ret, tmatches);
832 GEN_COMPS (flags, CA_BINDING, &it_bindings, text, ret, tmatches);
833 GEN_COMPS (flags, CA_BUILTIN, &it_builtins, text, ret, tmatches);
834 GEN_COMPS (flags, CA_DISABLED, &it_disabled, text, ret, tmatches);
835 GEN_COMPS (flags, CA_ENABLED, &it_enabled, text, ret, tmatches);
836 GEN_COMPS (flags, CA_EXPORT, &it_exports, text, ret, tmatches);
837 GEN_COMPS (flags, CA_FUNCTION, &it_functions, text, ret, tmatches);
838 GEN_COMPS (flags, CA_HELPTOPIC, &it_helptopics, text, ret, tmatches);
839 GEN_COMPS (flags, CA_HOSTNAME, &it_hostnames, text, ret, tmatches);
840 GEN_COMPS (flags, CA_JOB, &it_jobs, text, ret, tmatches);
841 GEN_COMPS (flags, CA_KEYWORD, &it_keywords, text, ret, tmatches);
842 GEN_COMPS (flags, CA_RUNNING, &it_running, text, ret, tmatches);
843 GEN_COMPS (flags, CA_SETOPT, &it_setopts, text, ret, tmatches);
844 GEN_COMPS (flags, CA_SHOPT, &it_shopts, text, ret, tmatches);
845 GEN_COMPS (flags, CA_SIGNAL, &it_signals, text, ret, tmatches);
846 GEN_COMPS (flags, CA_STOPPED, &it_stopped, text, ret, tmatches);
847 GEN_COMPS (flags, CA_VARIABLE, &it_variables, text, ret, tmatches);
849 GEN_XCOMPS(flags, CA_COMMAND, text, command_word_completion_function, cmatches, ret, tmatches);
850 GEN_XCOMPS(flags, CA_FILE, text, pcomp_filename_completion_function, cmatches, ret, tmatches);
851 GEN_XCOMPS(flags, CA_USER, text, rl_username_completion_function, cmatches, ret, tmatches);
852 GEN_XCOMPS(flags, CA_GROUP, text, bash_groupname_completion_function, cmatches, ret, tmatches);
853 GEN_XCOMPS(flags, CA_SERVICE, text, bash_servicename_completion_function, cmatches, ret, tmatches);
855 /* And lastly, the special case for directories */
856 if (flags & CA_DIRECTORY)
858 t = rl_filename_completion_desired;
859 rl_completion_mark_symlink_dirs = 1; /* override user preference */
860 cmatches = bash_directory_completion_matches (text);
861 /* If we did not want filename completion before this, and there are
862 no matches, turn off rl_filename_completion_desired so whatever
863 matches we get are not treated as filenames (it gets turned on by
864 rl_filename_completion_function unconditionally). */
865 if (t == 0 && cmatches == 0 && rl_filename_completion_desired == 1)
866 rl_filename_completion_desired = 0;
867 tmatches = completions_to_stringlist (cmatches);
868 ret = strlist_append (ret, tmatches);
869 strvec_dispose (cmatches);
870 strlist_dispose (tmatches);
876 /* Generate a list of matches for CS->globpat. Unresolved: should this use
877 TEXT as a match prefix, or just go without? Currently, the code does not
878 use TEXT, just globs CS->globpat and returns the results. If we do decide
879 to use TEXT, we should call quote_string_for_globbing before the call to
882 gen_globpat_matches (cs, text)
888 sl = strlist_create (0);
889 sl->list = glob_filename (cs->globpat, 0);
890 if (GLOB_FAILED (sl->list))
891 sl->list = (char **)NULL;
893 sl->list_len = sl->list_size = strvec_len (sl->list);
897 /* Perform the shell word expansions on CS->words and return the results.
898 Again, this ignores TEXT. */
900 gen_wordlist_matches (cs, text)
907 char *ntxt; /* dequoted TEXT to use in comparisons */
909 if (cs->words == 0 || cs->words[0] == '\0')
910 return ((STRINGLIST *)NULL);
912 /* This used to be a simple expand_string(cs->words, 0), but that won't
913 do -- there's no way to split a simple list into individual words
914 that way, since the shell semantics say that word splitting is done
915 only on the results of expansion. split_at_delims also handles embedded
916 quoted strings and preserves the quotes for the expand_words_shellexp
917 function call that follows. */
918 /* XXX - this is where this function spends most of its time */
919 l = split_at_delims (cs->words, strlen (cs->words), (char *)NULL, -1, 0, (int *)NULL, (int *)NULL);
921 return ((STRINGLIST *)NULL);
922 /* This will jump back to the top level if the expansion fails... */
923 l2 = expand_words_shellexp (l);
926 nw = list_length (l2);
927 sl = strlist_create (nw + 1);
929 ntxt = bash_dequote_text (text);
930 tlen = STRLEN (ntxt);
932 for (nw = 0, l = l2; l; l = l->next)
934 if (tlen == 0 || STREQN (l->word->word, ntxt, tlen))
935 sl->list[nw++] = STRDUP (l->word->word);
937 sl->list[sl->list_len = nw] = (char *)NULL;
947 bind_comp_words (lwords)
952 v = find_variable ("COMP_WORDS");
954 v = make_new_array_variable ("COMP_WORDS");
956 VUNSETATTR (v, att_readonly);
957 if (array_p (v) == 0)
958 v = convert_var_to_array (v);
959 v = assign_array_var_from_word_list (v, lwords, 0);
961 VUNSETATTR (v, att_invisible);
964 #endif /* ARRAY_VARS */
967 bind_compfunc_variables (line, ind, lwords, cw, exported)
973 char ibuf[INT_STRLEN_BOUND(int) + 1];
979 /* Set the variables that the function expects while it executes. Maybe
980 these should be in the function environment (temporary_env). */
981 v = bind_variable ("COMP_LINE", line, 0);
983 VSETATTR(v, att_exported);
985 /* Post bash-4.2: COMP_POINT is characters instead of bytes. */
988 llen = MB_STRLEN (line);
990 value = inttostr (llen, ibuf, sizeof(ibuf));
991 v = bind_int_variable ("COMP_POINT", value);
993 VSETATTR(v, att_exported);
995 value = inttostr (rl_completion_type, ibuf, sizeof (ibuf));
996 v = bind_int_variable ("COMP_TYPE", value);
998 VSETATTR(v, att_exported);
1000 value = inttostr (rl_completion_invoking_key, ibuf, sizeof (ibuf));
1001 v = bind_int_variable ("COMP_KEY", value);
1003 VSETATTR(v, att_exported);
1005 /* Since array variables can't be exported, we don't bother making the
1010 v = bind_comp_words (lwords);
1011 value = inttostr (cw, ibuf, sizeof(ibuf));
1012 bind_int_variable ("COMP_CWORD", value);
1016 array_needs_making = 1;
1020 unbind_compfunc_variables (exported)
1023 unbind_variable ("COMP_LINE");
1024 unbind_variable ("COMP_POINT");
1025 unbind_variable ("COMP_TYPE");
1026 unbind_variable ("COMP_KEY");
1028 unbind_variable ("COMP_WORDS");
1029 unbind_variable ("COMP_CWORD");
1032 array_needs_making = 1;
1035 /* Build the list of words to pass to a function or external command
1036 as arguments. When the function or command is invoked,
1038 $0 == function or command being invoked
1040 $2 == word to be completed (possibly null)
1043 Functions can access all of the words in the current command line
1044 with the COMP_WORDS array. External commands cannot; they have to
1045 make do with the COMP_LINE and COMP_POINT variables. */
1048 build_arg_list (cmd, cname, text, lwords, ind)
1055 WORD_LIST *ret, *cl, *l;
1059 ret = (WORD_LIST *)NULL;
1060 w = make_word (cmd);
1061 ret = make_word_list (w, (WORD_LIST *)NULL); /* $0 */
1063 w = make_word (cname); /* $1 */
1064 cl = ret->next = make_word_list (w, (WORD_LIST *)NULL);
1066 w = make_word (text);
1067 cl->next = make_word_list (w, (WORD_LIST *)NULL); /* $2 */
1070 /* Search lwords for current word */
1071 for (l = lwords, i = 1; l && i < ind-1; l = l->next, i++)
1073 w = (l && l->word) ? copy_word (l->word) : make_word ("");
1074 cl->next = make_word_list (w, (WORD_LIST *)NULL);
1079 /* Build a command string with
1080 $0 == cs->funcname (function to execute for completion list)
1081 $1 == command name (command being completed)
1082 $2 = word to be completed (possibly null)
1084 and run in the current shell. The function should put its completion
1085 list into the array variable COMPREPLY. We build a STRINGLIST
1086 from the results and return it.
1088 Since the shell function should return its list of matches in an array
1089 variable, this does nothing if arrays are not compiled into the shell. */
1092 gen_shell_function_matches (cs, cmd, text, line, ind, lwords, nw, cw, foundp)
1107 sh_parser_state_t ps;
1108 sh_parser_state_t * restrict pps;
1109 #if defined (ARRAY_VARS)
1117 funcname = cs->funcname;
1118 f = find_function (funcname);
1121 internal_error (_("completion: function `%s' not found"), funcname);
1124 return ((STRINGLIST *)NULL);
1127 #if !defined (ARRAY_VARS)
1128 return ((STRINGLIST *)NULL);
1131 /* We pass cw - 1 because command_line_to_word_list returns indices that are
1132 1-based, while bash arrays are 0-based. */
1133 bind_compfunc_variables (line, ind, lwords, cw - 1, 0);
1135 cmdlist = build_arg_list (funcname, cmd, text, lwords, cw);
1138 save_parser_state (pps);
1139 begin_unwind_frame ("gen-shell-function-matches");
1140 add_unwind_protect (restore_parser_state, (char *)pps);
1141 add_unwind_protect (dispose_words, (char *)cmdlist);
1142 add_unwind_protect (unbind_compfunc_variables, (char *)0);
1144 fval = execute_shell_function (f, cmdlist);
1146 discard_unwind_frame ("gen-shell-function-matches");
1147 restore_parser_state (pps);
1149 found = fval != EX_NOTFOUND;
1150 if (fval == EX_RETRYFAIL)
1151 found |= PCOMP_RETRYFAIL;
1155 /* Now clean up and destroy everything. */
1156 dispose_words (cmdlist);
1157 unbind_compfunc_variables (0);
1159 /* The list of completions is returned in the array variable COMPREPLY. */
1160 v = find_variable ("COMPREPLY");
1162 return ((STRINGLIST *)NULL);
1163 if (array_p (v) == 0)
1164 v = convert_var_to_array (v);
1166 VUNSETATTR (v, att_invisible);
1169 if (found == 0 || (found & PCOMP_RETRYFAIL) || a == 0 || array_empty (a))
1170 sl = (STRINGLIST *)NULL;
1173 /* XXX - should we filter the list of completions so only those matching
1174 TEXT are returned? Right now, we do not. */
1175 sl = strlist_create (0);
1176 sl->list = array_to_argv (a);
1177 sl->list_len = sl->list_size = array_num_elements (a);
1180 /* XXX - should we unbind COMPREPLY here? */
1181 unbind_variable ("COMPREPLY");
1187 /* Build a command string with
1188 $0 == cs->command (command to execute for completion list)
1189 $1 == command name (command being completed)
1190 $2 = word to be completed (possibly null)
1192 and run in with command substitution. Parse the results, one word
1193 per line, with backslashes allowed to escape newlines. Build a
1194 STRINGLIST from the results and return it. */
1197 gen_command_matches (cs, cmd, text, line, ind, lwords, nw, cw)
1206 char *csbuf, *cscmd, *t;
1207 int cmdlen, cmdsize, n, ws, we;
1208 WORD_LIST *cmdlist, *cl;
1212 bind_compfunc_variables (line, ind, lwords, cw, 1);
1213 cmdlist = build_arg_list (cs->command, cmd, text, lwords, cw);
1215 /* Estimate the size needed for the buffer. */
1216 n = strlen (cs->command);
1218 for (cl = cmdlist->next; cl; cl = cl->next)
1219 cmdsize += STRLEN (cl->word->word) + 3;
1222 /* allocate the string for the command and fill it in. */
1223 cscmd = (char *)xmalloc (cmdsize + 1);
1225 strcpy (cscmd, cs->command); /* $0 */
1227 cscmd[cmdlen++] = ' ';
1228 for (cl = cmdlist->next; cl; cl = cl->next) /* $1, $2, $3, ... */
1230 t = sh_single_quote (cl->word->word ? cl->word->word : "");
1232 RESIZE_MALLOCED_BUFFER (cscmd, cmdlen, n + 2, cmdsize, 64);
1233 strcpy (cscmd + cmdlen, t);
1236 cscmd[cmdlen++] = ' ';
1239 cscmd[cmdlen] = '\0';
1241 tw = command_substitute (cscmd, 0);
1242 csbuf = tw ? tw->word : (char *)NULL;
1244 dispose_word_desc (tw);
1246 /* Now clean up and destroy everything. */
1247 dispose_words (cmdlist);
1249 unbind_compfunc_variables (1);
1251 if (csbuf == 0 || *csbuf == '\0')
1254 return ((STRINGLIST *)NULL);
1257 /* Now break CSBUF up at newlines, with backslash allowed to escape a
1258 newline, and put the individual words into a STRINGLIST. */
1259 sl = strlist_create (16);
1260 for (ws = 0; csbuf[ws]; )
1263 while (csbuf[we] && csbuf[we] != '\n')
1265 if (csbuf[we] == '\\' && csbuf[we+1] == '\n')
1269 t = substring (csbuf, ws, we);
1270 if (sl->list_len >= sl->list_size - 1)
1271 strlist_resize (sl, sl->list_size + 16);
1272 sl->list[sl->list_len++] = t;
1273 while (csbuf[we] == '\n') we++;
1276 sl->list[sl->list_len] = (char *)NULL;
1283 command_line_to_word_list (line, llen, sentinel, nwp, cwp)
1285 int llen, sentinel, *nwp, *cwp;
1291 delims = "()<>;&| \t\n"; /* shell metacharacters break words */
1293 delims = rl_completer_word_break_characters;
1295 ret = split_at_delims (line, llen, delims, sentinel, SD_NOQUOTEDELIM, nwp, cwp);
1299 /* Evaluate COMPSPEC *cs and return all matches for WORD. */
1302 gen_compspec_completions (cs, cmd, word, start, end, foundp)
1309 STRINGLIST *ret, *tmatches;
1311 int llen, nw, cw, found, foundf;
1319 debug_printf ("gen_compspec_completions (%s, %s, %d, %d)", cmd, word, start, end);
1320 debug_printf ("gen_compspec_completions: %s -> %p", cmd, cs);
1322 ret = gen_action_completions (cs, word);
1324 if (ret && progcomp_debug)
1326 debug_printf ("gen_action_completions (%p, %s) -->", cs, word);
1327 strlist_print (ret, "\t");
1332 /* Now we start generating completions based on the other members of CS. */
1335 tmatches = gen_globpat_matches (cs, word);
1341 debug_printf ("gen_globpat_matches (%p, %s) -->", cs, word);
1342 strlist_print (tmatches, "\t");
1346 ret = strlist_append (ret, tmatches);
1347 strlist_dispose (tmatches);
1348 rl_filename_completion_desired = 1;
1354 tmatches = gen_wordlist_matches (cs, word);
1360 debug_printf ("gen_wordlist_matches (%p, %s) -->", cs, word);
1361 strlist_print (tmatches, "\t");
1365 ret = strlist_append (ret, tmatches);
1366 strlist_dispose (tmatches);
1370 lwords = (WORD_LIST *)NULL;
1371 line = (char *)NULL;
1372 if (cs->command || cs->funcname)
1374 /* If we have a command or function to execute, we need to first break
1375 the command line into individual words, find the number of words,
1376 and find the word in the list containing the word to be completed. */
1377 line = substring (rl_line_buffer, start, end);
1381 debug_printf ("command_line_to_word_list (%s, %d, %d, %p, %p)",
1382 line, llen, rl_point - start, &nw, &cw);
1384 lwords = command_line_to_word_list (line, llen, rl_point - start, &nw, &cw);
1385 /* If we skipped a NULL word at the beginning of the line, add it back */
1386 if (lwords && lwords->word && cmd[0] == 0 && lwords->word->word[0] != 0)
1388 lw = make_bare_word (cmd);
1389 lwords = make_word_list (lw, lwords);
1394 if (lwords == 0 && llen > 0)
1395 debug_printf ("ERROR: command_line_to_word_list returns NULL");
1396 else if (progcomp_debug)
1398 debug_printf ("command_line_to_word_list -->");
1400 print_word_list (lwords, "!");
1411 tmatches = gen_shell_function_matches (cs, cmd, word, line, rl_point - start, lwords, nw, cw, &foundf);
1419 debug_printf ("gen_shell_function_matches (%p, %s, %s, %p, %d, %d) -->", cs, cmd, word, lwords, nw, cw);
1420 strlist_print (tmatches, "\t");
1424 ret = strlist_append (ret, tmatches);
1425 strlist_dispose (tmatches);
1431 tmatches = gen_command_matches (cs, cmd, word, line, rl_point - start, lwords, nw, cw);
1437 debug_printf ("gen_command_matches (%p, %s, %s, %p, %d, %d) -->", cs, cmd, word, lwords, nw, cw);
1438 strlist_print (tmatches, "\t");
1442 ret = strlist_append (ret, tmatches);
1443 strlist_dispose (tmatches);
1447 if (cs->command || cs->funcname)
1450 dispose_words (lwords);
1457 if (found == 0 || (found & PCOMP_RETRYFAIL))
1459 strlist_dispose (ret);
1465 tmatches = filter_stringlist (ret, cs->filterpat, word);
1469 debug_printf ("filter_stringlist (%p, %s, %s) -->", ret, cs->filterpat, word);
1470 strlist_print (tmatches, "\t");
1474 if (ret && ret != tmatches)
1482 if (cs->prefix || cs->suffix)
1483 ret = strlist_prefix_suffix (ret, cs->prefix, cs->suffix);
1485 /* If no matches have been generated and the user has specified that
1486 directory completion should be done as a default, call
1487 gen_action_completions again to generate a list of matching directory
1489 if ((ret == 0 || ret->list_len == 0) && (cs->options & COPT_DIRNAMES))
1491 tcs = compspec_create ();
1492 tcs->actions = CA_DIRECTORY;
1494 ret = gen_action_completions (tcs, word);
1495 compspec_dispose (tcs);
1497 else if (cs->options & COPT_PLUSDIRS)
1499 tcs = compspec_create ();
1500 tcs->actions = CA_DIRECTORY;
1501 tmatches = gen_action_completions (tcs, word);
1502 ret = strlist_append (ret, tmatches);
1503 strlist_dispose (tmatches);
1504 compspec_dispose (tcs);
1511 pcomp_set_readline_variables (flags, nval)
1514 /* If the user specified that the compspec returns filenames, make
1515 sure that readline knows it. */
1516 if (flags & COPT_FILENAMES)
1517 rl_filename_completion_desired = nval;
1518 /* If the user doesn't want a space appended, tell readline. */
1519 if (flags & COPT_NOSPACE)
1520 rl_completion_suppress_append = nval;
1521 /* The value here is inverted, since the default is on and the `noquote'
1522 option is supposed to turn it off */
1523 if (flags & COPT_NOQUOTE)
1524 rl_filename_quoting_desired = 1 - nval;
1527 /* Set or unset FLAGS in the options word of the current compspec.
1528 SET_OR_UNSET is 1 for setting, 0 for unsetting. */
1530 pcomp_set_compspec_options (cs, flags, set_or_unset)
1532 int flags, set_or_unset;
1534 if (cs == 0 && ((cs = pcomp_curcs) == 0))
1537 cs->options |= flags;
1539 cs->options &= ~flags;
1543 gen_progcomp_completions (ocmd, cmd, word, start, end, foundp, retryp, lastcs)
1548 int *foundp, *retryp;
1551 COMPSPEC *cs, *oldcs;
1552 const char *oldcmd, *oldtxt;
1555 cs = progcomp_search (ocmd);
1557 if (cs == 0 || cs == *lastcs)
1567 compspec_dispose (*lastcs);
1568 cs->refcount++; /* XXX */
1571 cs = compspec_copy (cs);
1573 oldcs = pcomp_curcs;
1574 oldcmd = pcomp_curcmd;
1575 oldtxt = pcomp_curtxt;
1579 pcomp_curtxt = word;
1581 ret = gen_compspec_completions (cs, cmd, word, start, end, foundp);
1583 pcomp_curcs = oldcs;
1584 pcomp_curcmd = oldcmd;
1585 pcomp_curtxt = oldtxt;
1587 /* We need to conditionally handle setting *retryp here */
1589 *retryp = foundp && (*foundp & PCOMP_RETRYFAIL);
1593 *foundp &= ~PCOMP_RETRYFAIL;
1594 *foundp |= cs->options;
1597 compspec_dispose (cs);
1601 /* The driver function for the programmable completion code. Returns a list
1602 of matches for WORD, which is an argument to command CMD. START and END
1603 bound the command currently being completed in rl_line_buffer. */
1605 programmable_completions (cmd, word, start, end, foundp)
1608 int start, end, *foundp;
1610 COMPSPEC *cs, *lastcs;
1612 char **rmatches, *t;
1613 int found, retry, count;
1622 /* We look at the basename of CMD if the full command does not have
1623 an associated COMPSPEC. */
1624 ret = gen_progcomp_completions (cmd, cmd, word, start, end, &found, &retry, &lastcs);
1627 t = strrchr (cmd, '/');
1629 ret = gen_progcomp_completions (t, cmd, word, start, end, &found, &retry, &lastcs);
1633 ret = gen_progcomp_completions (DEFAULTCMD, cmd, word, start, end, &found, &retry, &lastcs);
1639 internal_warning ("programmable_completion: %s: possible retry loop", cmd);
1647 rmatches = ret->list;
1651 rmatches = (char **)NULL;
1656 if (lastcs) /* XXX - should be while? */
1657 compspec_dispose (lastcs);
1662 #endif /* PROGRAMMABLE_COMPLETION */