1 /* pcomplete.c - functions to generate lists of matches for programmable
4 /* Copyright (C) 1999-2005 Free Software Foundation, Inc.
6 This file is part of GNU Bash, the Bourne Again SHell.
8 Bash is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 2, or (at your option) any later
13 Bash is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License along
19 with Bash; see the file COPYING. If not, write to the Free Software
20 Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA. */
24 #if defined (PROGRAMMABLE_COMPLETION)
26 #include "bashtypes.h"
27 #include "posixstat.h"
29 #if defined (HAVE_UNISTD_H)
35 #if defined (PREFER_STDARG)
46 #include "pcomplete.h"
49 #include "execute_cmd.h"
52 #if defined (JOB_CONTROL)
61 #include "builtins/common.h"
63 #include <glob/glob.h>
64 #include <glob/strmatch.h>
66 #include <readline/rlconf.h>
67 #include <readline/readline.h>
68 #include <readline/history.h>
73 #define STRDUP(x) ((x) ? savestring (x) : (char *)NULL)
75 typedef SHELL_VAR **SVFUNC ();
78 extern char *strpbrk __P((char *, char *));
81 extern int array_needs_making;
82 extern STRING_INT_ALIST word_token_alist[];
83 extern char *signal_names[];
86 #if defined (PREFER_STDARG)
87 static void debug_printf (const char *, ...) __attribute__((__format__ (printf, 1, 2)));
91 static int it_init_joblist __P((ITEMLIST *, int));
93 static int it_init_aliases __P((ITEMLIST *));
94 static int it_init_arrayvars __P((ITEMLIST *));
95 static int it_init_bindings __P((ITEMLIST *));
96 static int it_init_builtins __P((ITEMLIST *));
97 static int it_init_disabled __P((ITEMLIST *));
98 static int it_init_enabled __P((ITEMLIST *));
99 static int it_init_exported __P((ITEMLIST *));
100 static int it_init_functions __P((ITEMLIST *));
101 static int it_init_hostnames __P((ITEMLIST *));
102 static int it_init_jobs __P((ITEMLIST *));
103 static int it_init_running __P((ITEMLIST *));
104 static int it_init_stopped __P((ITEMLIST *));
105 static int it_init_keywords __P((ITEMLIST *));
106 static int it_init_signals __P((ITEMLIST *));
107 static int it_init_variables __P((ITEMLIST *));
108 static int it_init_setopts __P((ITEMLIST *));
109 static int it_init_shopts __P((ITEMLIST *));
111 static int shouldexp_filterpat __P((char *));
112 static char *preproc_filterpat __P((char *, char *));
114 static void init_itemlist_from_varlist __P((ITEMLIST *, SVFUNC *));
116 static STRINGLIST *gen_matches_from_itemlist __P((ITEMLIST *, const char *));
117 static STRINGLIST *gen_action_completions __P((COMPSPEC *, const char *));
118 static STRINGLIST *gen_globpat_matches __P((COMPSPEC *, const char *));
119 static STRINGLIST *gen_wordlist_matches __P((COMPSPEC *, const char *));
120 static STRINGLIST *gen_shell_function_matches __P((COMPSPEC *, const char *,
121 char *, int, WORD_LIST *,
123 static STRINGLIST *gen_command_matches __P((COMPSPEC *, const char *, char *,
124 int, WORD_LIST *, int, int));
126 static char *pcomp_filename_completion_function __P((const char *, int));
128 #if defined (ARRAY_VARS)
129 static SHELL_VAR *bind_comp_words __P((WORD_LIST *));
131 static void bind_compfunc_variables __P((char *, int, WORD_LIST *, int, int));
132 static void unbind_compfunc_variables __P((int));
133 static WORD_LIST *build_arg_list __P((char *, const char *, WORD_LIST *, int));
134 static WORD_LIST *command_line_to_word_list __P((char *, int, int, int *, int *));
137 static int progcomp_debug = 0;
140 int prog_completion_enabled = 1;
142 /* These are used to manage the arrays of strings for possible completions. */
143 ITEMLIST it_aliases = { 0, it_init_aliases, (STRINGLIST *)0 };
144 ITEMLIST it_arrayvars = { LIST_DYNAMIC, it_init_arrayvars, (STRINGLIST *)0 };
145 ITEMLIST it_bindings = { 0, it_init_bindings, (STRINGLIST *)0 };
146 ITEMLIST it_builtins = { 0, it_init_builtins, (STRINGLIST *)0 };
147 ITEMLIST it_commands = { LIST_DYNAMIC }; /* unused */
148 ITEMLIST it_directories = { LIST_DYNAMIC }; /* unused */
149 ITEMLIST it_disabled = { 0, it_init_disabled, (STRINGLIST *)0 };
150 ITEMLIST it_enabled = { 0, it_init_enabled, (STRINGLIST *)0 };
151 ITEMLIST it_exports = { LIST_DYNAMIC, it_init_exported, (STRINGLIST *)0 };
152 ITEMLIST it_files = { LIST_DYNAMIC }; /* unused */
153 ITEMLIST it_functions = { 0, it_init_functions, (STRINGLIST *)0 };
154 ITEMLIST it_hostnames = { LIST_DYNAMIC, it_init_hostnames, (STRINGLIST *)0 };
155 ITEMLIST it_groups = { LIST_DYNAMIC }; /* unused */
156 ITEMLIST it_jobs = { LIST_DYNAMIC, it_init_jobs, (STRINGLIST *)0 };
157 ITEMLIST it_keywords = { 0, it_init_keywords, (STRINGLIST *)0 };
158 ITEMLIST it_running = { LIST_DYNAMIC, it_init_running, (STRINGLIST *)0 };
159 ITEMLIST it_services = { LIST_DYNAMIC }; /* unused */
160 ITEMLIST it_setopts = { 0, it_init_setopts, (STRINGLIST *)0 };
161 ITEMLIST it_shopts = { 0, it_init_shopts, (STRINGLIST *)0 };
162 ITEMLIST it_signals = { 0, it_init_signals, (STRINGLIST *)0 };
163 ITEMLIST it_stopped = { LIST_DYNAMIC, it_init_stopped, (STRINGLIST *)0 };
164 ITEMLIST it_users = { LIST_DYNAMIC }; /* unused */
165 ITEMLIST it_variables = { LIST_DYNAMIC, it_init_variables, (STRINGLIST *)0 };
170 #if defined (PREFER_STDARG)
171 debug_printf (const char *format, ...)
173 debug_printf (format, va_alist)
180 if (progcomp_debug == 0)
183 SH_VA_START (args, format);
185 fprintf (stdout, "DEBUG: ");
186 vfprintf (stdout, format, args);
187 fprintf (stdout, "\n");
195 /* Functions to manage the item lists */
198 set_itemlist_dirty (it)
201 it->flags |= LIST_DIRTY;
205 initialize_itemlist (itp)
208 (*itp->list_getter) (itp);
209 itp->flags |= LIST_INITIALIZED;
210 itp->flags &= ~LIST_DIRTY;
222 if ((itp->flags & (LIST_DONTFREEMEMBERS|LIST_DONTFREE)) == 0)
223 strvec_flush (sl->list);
224 if ((itp->flags & LIST_DONTFREE) == 0)
228 itp->slist = (STRINGLIST *)NULL;
229 itp->flags &= ~(LIST_DONTFREE|LIST_DONTFREEMEMBERS|LIST_INITIALIZED|LIST_DIRTY);
234 shouldexp_filterpat (s)
239 for (p = s; p && *p; p++)
249 /* Replace any instance of `&' in PAT with TEXT. Backslash may be used to
250 quote a `&' and inhibit substitution. Returns a new string. This just
251 calls stringlib.c:strcreplace(). */
253 preproc_filterpat (pat, text)
259 ret = strcreplace (pat, '&', text, 1);
263 /* Remove any match of FILTERPAT from SL. A `&' in FILTERPAT is replaced by
264 TEXT. A leading `!' in FILTERPAT negates the pattern; in this case
265 any member of SL->list that does *not* match will be removed. This returns
266 a new STRINGLIST with the matching members of SL *copied*. Any
267 non-matching members of SL->list are *freed*. */
269 filter_stringlist (sl, filterpat, text)
271 char *filterpat, *text;
277 if (sl == 0 || sl->list == 0 || sl->list_len == 0)
280 npat = shouldexp_filterpat (filterpat) ? preproc_filterpat (filterpat, text) : filterpat;
282 not = (npat[0] == '!');
283 t = not ? npat + 1 : npat;
285 ret = strlist_create (sl->list_size);
286 for (i = 0; i < sl->list_len; i++)
288 m = strmatch (t, sl->list[i], FNMATCH_EXTFLAG);
289 if ((not && m == FNM_NOMATCH) || (not == 0 && m != FNM_NOMATCH))
292 ret->list[ret->list_len++] = sl->list[i];
295 ret->list[ret->list_len] = (char *)NULL;
296 if (npat != filterpat)
302 /* Turn an array of strings returned by rl_completion_matches into a STRINGLIST.
303 This understands how rl_completion_matches sets matches[0] (the lcd of the
304 strings in the list, unless it's the only match). */
306 completions_to_stringlist (matches)
312 mlen = (matches == 0) ? 0 : strvec_len (matches);
313 sl = strlist_create (mlen + 1);
315 if (matches == 0 || matches[0] == 0)
320 sl->list[0] = STRDUP (matches[0]);
321 sl->list[sl->list_len = 1] = (char *)NULL;
325 for (i = 1, n = 0; i < mlen; i++, n++)
326 sl->list[n] = STRDUP (matches[i]);
328 sl->list[n] = (char *)NULL;
333 /* Functions to manage the various ITEMLISTs that we populate internally.
334 The caller is responsible for setting ITP->flags correctly. */
337 it_init_aliases (itp)
341 alias_t **alias_list;
345 alias_list = all_aliases ();
348 itp->slist = (STRINGLIST *)NULL;
351 for (n = 0; alias_list[n]; n++)
353 sl = strlist_create (n+1);
354 for (i = 0; i < n; i++)
355 sl->list[i] = STRDUP (alias_list[i]->name);
356 sl->list[n] = (char *)NULL;
357 sl->list_size = sl->list_len = n;
360 itp->slist = (STRINGLIST *)NULL;
366 init_itemlist_from_varlist (itp, svfunc)
374 vlist = (*svfunc) ();
377 itp->slist = (STRINGLIST *)NULL;
380 for (n = 0; vlist[n]; n++)
382 sl = strlist_create (n+1);
383 for (i = 0; i < n; i++)
384 sl->list[i] = savestring (vlist[i]->name);
385 sl->list[sl->list_len = n] = (char *)NULL;
390 it_init_arrayvars (itp)
393 #if defined (ARRAY_VARS)
394 init_itemlist_from_varlist (itp, all_array_variables);
402 it_init_bindings (itp)
408 /* rl_funmap_names allocates blist, but not its members */
409 blist = (char **)rl_funmap_names (); /* XXX fix const later */
410 sl = strlist_create (0);
413 sl->list_len = strvec_len (sl->list);
414 itp->flags |= LIST_DONTFREEMEMBERS;
421 it_init_builtins (itp)
427 sl = strlist_create (num_shell_builtins);
428 for (i = n = 0; i < num_shell_builtins; i++)
429 if (shell_builtins[i].function)
430 sl->list[n++] = shell_builtins[i].name;
431 sl->list[sl->list_len = n] = (char *)NULL;
432 itp->flags |= LIST_DONTFREEMEMBERS;
438 it_init_enabled (itp)
444 sl = strlist_create (num_shell_builtins);
445 for (i = n = 0; i < num_shell_builtins; i++)
447 if (shell_builtins[i].function && (shell_builtins[i].flags & BUILTIN_ENABLED))
448 sl->list[n++] = shell_builtins[i].name;
450 sl->list[sl->list_len = n] = (char *)NULL;
451 itp->flags |= LIST_DONTFREEMEMBERS;
457 it_init_disabled (itp)
463 sl = strlist_create (num_shell_builtins);
464 for (i = n = 0; i < num_shell_builtins; i++)
466 if (shell_builtins[i].function && ((shell_builtins[i].flags & BUILTIN_ENABLED) == 0))
467 sl->list[n++] = shell_builtins[i].name;
469 sl->list[sl->list_len = n] = (char *)NULL;
470 itp->flags |= LIST_DONTFREEMEMBERS;
476 it_init_exported (itp)
479 init_itemlist_from_varlist (itp, all_exported_variables);
484 it_init_functions (itp)
487 init_itemlist_from_varlist (itp, all_visible_functions);
492 it_init_hostnames (itp)
497 sl = strlist_create (0);
498 sl->list = get_hostname_list ();
499 sl->list_len = sl->list ? strvec_len (sl->list) : 0;
500 sl->list_size = sl->list_len;
502 itp->flags |= LIST_DONTFREEMEMBERS|LIST_DONTFREE;
507 it_init_joblist (itp, jstate)
511 #if defined (JOB_CONTROL)
517 JOB_STATE ws; /* wanted state */
521 else if (jstate == 1)
524 sl = strlist_create (js.j_jobslots);
525 for (i = js.j_jobslots - 1; i >= 0; i--)
527 j = get_job_by_jid (i);
531 if (jstate == -1 || JOBSTATE(i) == ws)
533 s = savestring (p->command);
534 t = strpbrk (s, " \t\n");
537 sl->list[sl->list_len++] = s;
542 itp->slist = (STRINGLIST *)NULL;
551 return (it_init_joblist (itp, -1));
555 it_init_running (itp)
558 return (it_init_joblist (itp, 0));
562 it_init_stopped (itp)
565 return (it_init_joblist (itp, 1));
569 it_init_keywords (itp)
575 for (n = 0; word_token_alist[n].word; n++)
577 sl = strlist_create (n);
578 for (i = 0; i < n; i++)
579 sl->list[i] = word_token_alist[i].word;
580 sl->list[sl->list_len = i] = (char *)NULL;
581 itp->flags |= LIST_DONTFREEMEMBERS;
587 it_init_signals (itp)
592 sl = strlist_create (0);
593 sl->list = signal_names;
594 sl->list_len = strvec_len (sl->list);
595 itp->flags |= LIST_DONTFREE;
601 it_init_variables (itp)
604 init_itemlist_from_varlist (itp, all_visible_variables);
609 it_init_setopts (itp)
614 sl = strlist_create (0);
615 sl->list = get_minus_o_opts ();
616 sl->list_len = strvec_len (sl->list);
618 itp->flags |= LIST_DONTFREEMEMBERS;
628 sl = strlist_create (0);
629 sl->list = get_shopt_options ();
630 sl->list_len = strvec_len (sl->list);
632 itp->flags |= LIST_DONTFREEMEMBERS;
636 /* Generate a list of all matches for TEXT using the STRINGLIST in itp->slist
637 as the list of possibilities. If the itemlist has been marked dirty or
638 it should be regenerated every time, destroy the old STRINGLIST and make a
639 new one before trying the match. TEXT is dequoted before attempting a
642 gen_matches_from_itemlist (itp, text)
646 STRINGLIST *ret, *sl;
650 if ((itp->flags & (LIST_DIRTY|LIST_DYNAMIC)) ||
651 (itp->flags & LIST_INITIALIZED) == 0)
653 if (itp->flags & (LIST_DIRTY | LIST_DYNAMIC))
654 clean_itemlist (itp);
655 if ((itp->flags & LIST_INITIALIZED) == 0)
656 initialize_itemlist (itp);
659 return ((STRINGLIST *)NULL);
660 ret = strlist_create (itp->slist->list_len+1);
663 ntxt = bash_dequote_text (text);
664 tlen = STRLEN (ntxt);
666 for (i = n = 0; i < sl->list_len; i++)
668 if (tlen == 0 || STREQN (sl->list[i], ntxt, tlen))
669 ret->list[n++] = STRDUP (sl->list[i]);
671 ret->list[ret->list_len = n] = (char *)NULL;
677 /* A wrapper for rl_filename_completion_function that dequotes the filename
678 before attempting completions. */
680 pcomp_filename_completion_function (text, state)
684 static char *dfn; /* dequoted filename */
690 /* remove backslashes quoting special characters in filenames. */
691 if (rl_filename_dequoting_function)
694 qc = (text[0] == '"' || text[0] == '\'') ? text[0] : 0;
696 /* Use rl_completion_quote_character because any single or
697 double quotes have been removed by the time TEXT makes it
698 here, and we don't want to remove backslashes inside
700 qc = rl_dispatching ? rl_completion_quote_character : 0;
702 dfn = (*rl_filename_dequoting_function) ((char *)text, qc);
705 dfn = savestring (text);
708 return (rl_filename_completion_function (dfn, state));
711 #define GEN_COMPS(bmap, flag, it, text, glist, tlist) \
715 tlist = gen_matches_from_itemlist (it, text); \
718 glist = strlist_append (glist, tlist); \
719 strlist_dispose (tlist); \
724 #define GEN_XCOMPS(bmap, flag, text, func, cmatches, glist, tlist) \
728 cmatches = rl_completion_matches (text, func); \
729 tlist = completions_to_stringlist (cmatches); \
730 glist = strlist_append (glist, tlist); \
731 strvec_dispose (cmatches); \
732 strlist_dispose (tlist); \
736 /* Functions to generate lists of matches from the actions member of CS. */
739 gen_action_completions (cs, text)
743 STRINGLIST *ret, *tmatches;
744 char **cmatches; /* from rl_completion_matches ... */
747 ret = tmatches = (STRINGLIST *)NULL;
750 GEN_COMPS (flags, CA_ALIAS, &it_aliases, text, ret, tmatches);
751 GEN_COMPS (flags, CA_ARRAYVAR, &it_arrayvars, text, ret, tmatches);
752 GEN_COMPS (flags, CA_BINDING, &it_bindings, text, ret, tmatches);
753 GEN_COMPS (flags, CA_BUILTIN, &it_builtins, text, ret, tmatches);
754 GEN_COMPS (flags, CA_DISABLED, &it_disabled, text, ret, tmatches);
755 GEN_COMPS (flags, CA_ENABLED, &it_enabled, text, ret, tmatches);
756 GEN_COMPS (flags, CA_EXPORT, &it_exports, text, ret, tmatches);
757 GEN_COMPS (flags, CA_FUNCTION, &it_functions, text, ret, tmatches);
758 GEN_COMPS (flags, CA_HOSTNAME, &it_hostnames, text, ret, tmatches);
759 GEN_COMPS (flags, CA_JOB, &it_jobs, text, ret, tmatches);
760 GEN_COMPS (flags, CA_KEYWORD, &it_keywords, text, ret, tmatches);
761 GEN_COMPS (flags, CA_RUNNING, &it_running, text, ret, tmatches);
762 GEN_COMPS (flags, CA_SETOPT, &it_setopts, text, ret, tmatches);
763 GEN_COMPS (flags, CA_SHOPT, &it_shopts, text, ret, tmatches);
764 GEN_COMPS (flags, CA_SIGNAL, &it_signals, text, ret, tmatches);
765 GEN_COMPS (flags, CA_STOPPED, &it_stopped, text, ret, tmatches);
766 GEN_COMPS (flags, CA_VARIABLE, &it_variables, text, ret, tmatches);
768 GEN_XCOMPS(flags, CA_COMMAND, text, command_word_completion_function, cmatches, ret, tmatches);
769 GEN_XCOMPS(flags, CA_FILE, text, pcomp_filename_completion_function, cmatches, ret, tmatches);
770 GEN_XCOMPS(flags, CA_USER, text, rl_username_completion_function, cmatches, ret, tmatches);
771 GEN_XCOMPS(flags, CA_GROUP, text, bash_groupname_completion_function, cmatches, ret, tmatches);
772 GEN_XCOMPS(flags, CA_SERVICE, text, bash_servicename_completion_function, cmatches, ret, tmatches);
774 /* And lastly, the special case for directories */
775 if (flags & CA_DIRECTORY)
777 rl_completion_mark_symlink_dirs = 1; /* override user preference */
778 cmatches = bash_directory_completion_matches (text);
779 tmatches = completions_to_stringlist (cmatches);
780 ret = strlist_append (ret, tmatches);
781 strvec_dispose (cmatches);
782 strlist_dispose (tmatches);
788 /* Generate a list of matches for CS->globpat. Unresolved: should this use
789 TEXT as a match prefix, or just go without? Currently, the code does not
790 use TEXT, just globs CS->globpat and returns the results. If we do decide
791 to use TEXT, we should call quote_string_for_globbing before the call to
794 gen_globpat_matches (cs, text)
800 sl = strlist_create (0);
801 sl->list = glob_filename (cs->globpat, 0);
802 if (GLOB_FAILED (sl->list))
803 sl->list = (char **)NULL;
805 sl->list_len = sl->list_size = strvec_len (sl->list);
809 /* Perform the shell word expansions on CS->words and return the results.
810 Again, this ignores TEXT. */
812 gen_wordlist_matches (cs, text)
819 char *ntxt; /* dequoted TEXT to use in comparisons */
821 if (cs->words == 0 || cs->words[0] == '\0')
822 return ((STRINGLIST *)NULL);
824 /* This used to be a simple expand_string(cs->words, 0), but that won't
825 do -- there's no way to split a simple list into individual words
826 that way, since the shell semantics say that word splitting is done
827 only on the results of expansion. */
828 l = split_at_delims (cs->words, strlen (cs->words), (char *)NULL, -1, (int *)NULL, (int *)NULL);
830 return ((STRINGLIST *)NULL);
831 /* This will jump back to the top level if the expansion fails... */
832 l2 = expand_words_shellexp (l);
835 nw = list_length (l2);
836 sl = strlist_create (nw + 1);
838 ntxt = bash_dequote_text (text);
839 tlen = STRLEN (ntxt);
841 for (nw = 0, l = l2; l; l = l->next)
843 if (tlen == 0 || STREQN (l->word->word, ntxt, tlen))
844 sl->list[nw++] = STRDUP (l->word->word);
846 sl->list[sl->list_len = nw] = (char *)NULL;
856 bind_comp_words (lwords)
861 v = find_variable ("COMP_WORDS");
863 v = make_new_array_variable ("COMP_WORDS");
865 VUNSETATTR (v, att_readonly);
866 if (array_p (v) == 0)
867 v = convert_var_to_array (v);
868 v = assign_array_var_from_word_list (v, lwords, 0);
870 VUNSETATTR (v, att_invisible);
873 #endif /* ARRAY_VARS */
876 bind_compfunc_variables (line, ind, lwords, cw, exported)
882 char ibuf[INT_STRLEN_BOUND(int) + 1];
886 /* Set the variables that the function expects while it executes. Maybe
887 these should be in the function environment (temporary_env). */
888 v = bind_variable ("COMP_LINE", line, 0);
890 VSETATTR(v, att_exported);
892 value = inttostr (ind, ibuf, sizeof(ibuf));
893 v = bind_int_variable ("COMP_POINT", value);
895 VSETATTR(v, att_exported);
897 /* Since array variables can't be exported, we don't bother making the
902 v = bind_comp_words (lwords);
903 value = inttostr (cw, ibuf, sizeof(ibuf));
904 bind_int_variable ("COMP_CWORD", value);
908 array_needs_making = 1;
912 unbind_compfunc_variables (exported)
915 unbind_variable ("COMP_LINE");
916 unbind_variable ("COMP_POINT");
918 unbind_variable ("COMP_WORDS");
919 unbind_variable ("COMP_CWORD");
922 array_needs_making = 1;
925 /* Build the list of words to pass to a function or external command
926 as arguments. When the function or command is invoked,
928 $0 == function or command being invoked
930 $2 = word to be completed (possibly null)
933 Functions can access all of the words in the current command line
934 with the COMP_WORDS array. External commands cannot. */
937 build_arg_list (cmd, text, lwords, ind)
943 WORD_LIST *ret, *cl, *l;
947 ret = (WORD_LIST *)NULL;
949 ret = make_word_list (w, (WORD_LIST *)NULL);
951 w = (lwords && lwords->word) ? copy_word (lwords->word) : make_word ("");
952 cl = ret->next = make_word_list (w, (WORD_LIST *)NULL);
954 w = make_word (text);
955 cl->next = make_word_list (w, (WORD_LIST *)NULL);
958 /* Search lwords for current word */
959 for (l = lwords, i = 1; l && i < ind-1; l = l->next, i++)
961 w = (l && l->word) ? copy_word (l->word) : make_word ("");
962 cl->next = make_word_list (w, (WORD_LIST *)NULL);
967 /* Build a command string with
968 $0 == cs->funcname (function to execute for completion list)
969 $1 == command name (command being completed)
970 $2 = word to be completed (possibly null)
972 and run in the current shell. The function should put its completion
973 list into the array variable COMPREPLY. We build a STRINGLIST
974 from the results and return it.
976 Since the shell function should return its list of matches in an array
977 variable, this does nothing if arrays are not compiled into the shell. */
980 gen_shell_function_matches (cs, text, line, ind, lwords, nw, cw)
993 sh_parser_state_t ps;
994 #if defined (ARRAY_VARS)
998 funcname = cs->funcname;
999 f = find_function (funcname);
1002 internal_error (_("completion: function `%s' not found"), funcname);
1005 return ((STRINGLIST *)NULL);
1008 #if !defined (ARRAY_VARS)
1009 return ((STRINGLIST *)NULL);
1012 /* We pass cw - 1 because command_line_to_word_list returns indices that are
1013 1-based, while bash arrays are 0-based. */
1014 bind_compfunc_variables (line, ind, lwords, cw - 1, 0);
1016 cmdlist = build_arg_list (funcname, text, lwords, cw);
1018 save_parser_state (&ps);
1019 fval = execute_shell_function (f, cmdlist);
1020 restore_parser_state (&ps);
1022 /* Now clean up and destroy everything. */
1023 dispose_words (cmdlist);
1024 unbind_compfunc_variables (0);
1026 /* The list of completions is returned in the array variable COMPREPLY. */
1027 v = find_variable ("COMPREPLY");
1029 return ((STRINGLIST *)NULL);
1030 if (array_p (v) == 0)
1031 v = convert_var_to_array (v);
1033 VUNSETATTR (v, att_invisible);
1036 if (a == 0 || array_empty (a))
1037 sl = (STRINGLIST *)NULL;
1040 /* XXX - should we filter the list of completions so only those matching
1041 TEXT are returned? Right now, we do not. */
1042 sl = strlist_create (0);
1043 sl->list = array_to_argv (a);
1044 sl->list_len = sl->list_size = array_num_elements (a);
1047 /* XXX - should we unbind COMPREPLY here? */
1048 unbind_variable ("COMPREPLY");
1054 /* Build a command string with
1055 $0 == cs->command (command to execute for completion list)
1056 $1 == command name (command being completed)
1057 $2 = word to be completed (possibly null)
1059 and run in with command substitution. Parse the results, one word
1060 per line, with backslashes allowed to escape newlines. Build a
1061 STRINGLIST from the results and return it. */
1064 gen_command_matches (cs, text, line, ind, lwords, nw, cw)
1072 char *csbuf, *cscmd, *t;
1073 int cmdlen, cmdsize, n, ws, we;
1074 WORD_LIST *cmdlist, *cl;
1077 bind_compfunc_variables (line, ind, lwords, cw, 1);
1078 cmdlist = build_arg_list (cs->command, text, lwords, cw);
1080 /* Estimate the size needed for the buffer. */
1081 n = strlen (cs->command);
1083 for (cl = cmdlist->next; cl; cl = cl->next)
1084 cmdsize += STRLEN (cl->word->word) + 3;
1087 /* allocate the string for the command and fill it in. */
1088 cscmd = (char *)xmalloc (cmdsize + 1);
1090 strcpy (cscmd, cs->command); /* $0 */
1092 cscmd[cmdlen++] = ' ';
1093 for (cl = cmdlist->next; cl; cl = cl->next) /* $1, $2, $3, ... */
1095 t = sh_single_quote (cl->word->word ? cl->word->word : "");
1097 RESIZE_MALLOCED_BUFFER (cscmd, cmdlen, n + 2, cmdsize, 64);
1098 strcpy (cscmd + cmdlen, t);
1101 cscmd[cmdlen++] = ' ';
1104 cscmd[cmdlen] = '\0';
1106 csbuf = command_substitute (cscmd, 0);
1108 /* Now clean up and destroy everything. */
1109 dispose_words (cmdlist);
1111 unbind_compfunc_variables (1);
1113 if (csbuf == 0 || *csbuf == '\0')
1116 return ((STRINGLIST *)NULL);
1119 /* Now break CSBUF up at newlines, with backslash allowed to escape a
1120 newline, and put the individual words into a STRINGLIST. */
1121 sl = strlist_create (16);
1122 for (ws = 0; csbuf[ws]; )
1125 while (csbuf[we] && csbuf[we] != '\n')
1127 if (csbuf[we] == '\\' && csbuf[we+1] == '\n')
1131 t = substring (csbuf, ws, we);
1132 if (sl->list_len >= sl->list_size - 1)
1133 strlist_resize (sl, sl->list_size + 16);
1134 sl->list[sl->list_len++] = t;
1135 while (csbuf[we] == '\n') we++;
1138 sl->list[sl->list_len] = (char *)NULL;
1145 command_line_to_word_list (line, llen, sentinel, nwp, cwp)
1147 int llen, sentinel, *nwp, *cwp;
1152 delims = "()<>;&| \t\n"; /* shell metacharacters break words */
1153 ret = split_at_delims (line, llen, delims, sentinel, nwp, cwp);
1157 /* Evaluate COMPSPEC *cs and return all matches for WORD. */
1160 gen_compspec_completions (cs, cmd, word, start, end)
1166 STRINGLIST *ret, *tmatches;
1173 debug_printf ("gen_compspec_completions (%s, %s, %d, %d)", cmd, word, start, end);
1174 debug_printf ("gen_compspec_completions: %s -> %p", cmd, cs);
1176 ret = gen_action_completions (cs, word);
1178 if (ret && progcomp_debug)
1180 debug_printf ("gen_action_completions (%p, %s) -->", cs, word);
1181 strlist_print (ret, "\t");
1186 /* Now we start generating completions based on the other members of CS. */
1189 tmatches = gen_globpat_matches (cs, word);
1195 debug_printf ("gen_globpat_matches (%p, %s) -->", cs, word);
1196 strlist_print (tmatches, "\t");
1200 ret = strlist_append (ret, tmatches);
1201 strlist_dispose (tmatches);
1202 rl_filename_completion_desired = 1;
1208 tmatches = gen_wordlist_matches (cs, word);
1214 debug_printf ("gen_wordlist_matches (%p, %s) -->", cs, word);
1215 strlist_print (tmatches, "\t");
1219 ret = strlist_append (ret, tmatches);
1220 strlist_dispose (tmatches);
1224 lwords = (WORD_LIST *)NULL;
1225 line = (char *)NULL;
1226 if (cs->command || cs->funcname)
1228 /* If we have a command or function to execute, we need to first break
1229 the command line into individual words, find the number of words,
1230 and find the word in the list containing the word to be completed. */
1231 line = substring (rl_line_buffer, start, end);
1235 debug_printf ("command_line_to_word_list (%s, %d, %d, %p, %p)",
1236 line, llen, rl_point - start, &nw, &cw);
1238 lwords = command_line_to_word_list (line, llen, rl_point - start, &nw, &cw);
1240 if (lwords == 0 && llen > 0)
1241 debug_printf ("ERROR: command_line_to_word_list returns NULL");
1242 else if (progcomp_debug)
1244 debug_printf ("command_line_to_word_list -->");
1246 print_word_list (lwords, "!");
1256 tmatches = gen_shell_function_matches (cs, word, line, rl_point - start, lwords, nw, cw);
1262 debug_printf ("gen_shell_function_matches (%p, %s, %p, %d, %d) -->", cs, word, lwords, nw, cw);
1263 strlist_print (tmatches, "\t");
1267 ret = strlist_append (ret, tmatches);
1268 strlist_dispose (tmatches);
1274 tmatches = gen_command_matches (cs, word, line, rl_point - start, lwords, nw, cw);
1280 debug_printf ("gen_command_matches (%p, %s, %p, %d, %d) -->", cs, word, lwords, nw, cw);
1281 strlist_print (tmatches, "\t");
1285 ret = strlist_append (ret, tmatches);
1286 strlist_dispose (tmatches);
1290 if (cs->command || cs->funcname)
1293 dispose_words (lwords);
1299 tmatches = filter_stringlist (ret, cs->filterpat, word);
1303 debug_printf ("filter_stringlist (%p, %s, %s) -->", ret, cs->filterpat, word);
1304 strlist_print (tmatches, "\t");
1308 if (ret && ret != tmatches)
1316 if (cs->prefix || cs->suffix)
1317 ret = strlist_prefix_suffix (ret, cs->prefix, cs->suffix);
1319 /* If no matches have been generated and the user has specified that
1320 directory completion should be done as a default, call
1321 gen_action_completions again to generate a list of matching directory
1323 if ((ret == 0 || ret->list_len == 0) && (cs->options & COPT_DIRNAMES))
1325 tcs = compspec_create ();
1326 tcs->actions = CA_DIRECTORY;
1327 ret = gen_action_completions (tcs, word);
1328 compspec_dispose (tcs);
1330 else if (cs->options & COPT_PLUSDIRS)
1332 tcs = compspec_create ();
1333 tcs->actions = CA_DIRECTORY;
1334 tmatches = gen_action_completions (tcs, word);
1335 ret = strlist_append (ret, tmatches);
1336 strlist_dispose (tmatches);
1337 compspec_dispose (tcs);
1343 /* The driver function for the programmable completion code. Returns a list
1344 of matches for WORD, which is an argument to command CMD. START and END
1345 bound the command currently being completed in rl_line_buffer. */
1347 programmable_completions (cmd, word, start, end, foundp)
1350 int start, end, *foundp;
1354 char **rmatches, *t;
1356 /* We look at the basename of CMD if the full command does not have
1357 an associated COMPSPEC. */
1358 cs = progcomp_search (cmd);
1361 t = strrchr (cmd, '/');
1363 cs = progcomp_search (++t);
1369 return ((char **)NULL);
1372 cs = compspec_copy (cs);
1374 /* Signal the caller that we found a COMPSPEC for this command, and pass
1375 back any meta-options associated with the compspec. */
1377 *foundp = 1|cs->options;
1379 ret = gen_compspec_completions (cs, cmd, word, start, end);
1381 compspec_dispose (cs);
1385 rmatches = ret->list;
1389 rmatches = (char **)NULL;
1394 #endif /* PROGRAMMABLE_COMPLETION */