1 /* pcomplete.c - functions to generate lists of matches for programmable
4 /* Copyright (C) 1999-2002 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)
45 #include "pcomplete.h"
48 #include "execute_cmd.h"
51 #if defined (JOB_CONTROL)
60 #include "builtins/common.h"
62 #include <glob/glob.h>
63 #include <glob/strmatch.h>
65 #include <readline/rlconf.h>
66 #include <readline/readline.h>
67 #include <readline/history.h>
72 #define STRDUP(x) ((x) ? savestring (x) : (char *)NULL)
74 typedef SHELL_VAR
**SVFUNC ();
77 extern char *strpbrk
__P((char *, char *));
80 extern int array_needs_making
;
81 extern STRING_INT_ALIST word_token_alist
[];
82 extern char *signal_names
[];
85 #if defined (PREFER_STDARG)
86 static void debug_printf (const char *, ...) __attribute__((__format__ (printf
, 1, 2)));
90 static int it_init_joblist
__P((ITEMLIST
*, int));
92 static int it_init_aliases
__P((ITEMLIST
*));
93 static int it_init_arrayvars
__P((ITEMLIST
*));
94 static int it_init_bindings
__P((ITEMLIST
*));
95 static int it_init_builtins
__P((ITEMLIST
*));
96 static int it_init_disabled
__P((ITEMLIST
*));
97 static int it_init_enabled
__P((ITEMLIST
*));
98 static int it_init_exported
__P((ITEMLIST
*));
99 static int it_init_functions
__P((ITEMLIST
*));
100 static int it_init_hostnames
__P((ITEMLIST
*));
101 static int it_init_jobs
__P((ITEMLIST
*));
102 static int it_init_running
__P((ITEMLIST
*));
103 static int it_init_stopped
__P((ITEMLIST
*));
104 static int it_init_keywords
__P((ITEMLIST
*));
105 static int it_init_signals
__P((ITEMLIST
*));
106 static int it_init_variables
__P((ITEMLIST
*));
107 static int it_init_setopts
__P((ITEMLIST
*));
108 static int it_init_shopts
__P((ITEMLIST
*));
110 static int shouldexp_filterpat
__P((char *));
111 static char *preproc_filterpat
__P((char *, char *));
113 static void init_itemlist_from_varlist
__P((ITEMLIST
*, SVFUNC
*));
115 static STRINGLIST
*gen_matches_from_itemlist
__P((ITEMLIST
*, const char *));
116 static STRINGLIST
*gen_action_completions
__P((COMPSPEC
*, const char *));
117 static STRINGLIST
*gen_globpat_matches
__P((COMPSPEC
*, const char *));
118 static STRINGLIST
*gen_wordlist_matches
__P((COMPSPEC
*, const char *));
119 static STRINGLIST
*gen_shell_function_matches
__P((COMPSPEC
*, const char *,
120 char *, int, WORD_LIST
*,
122 static STRINGLIST
*gen_command_matches
__P((COMPSPEC
*, const char *, char *,
123 int, WORD_LIST
*, int, int));
125 static char *pcomp_filename_completion_function
__P((const char *, int));
127 #if defined (ARRAY_VARS)
128 static SHELL_VAR
*bind_comp_words
__P((WORD_LIST
*));
130 static void bind_compfunc_variables
__P((char *, int, WORD_LIST
*, int, int));
131 static void unbind_compfunc_variables
__P((int));
132 static WORD_LIST
*build_arg_list
__P((char *, const char *, WORD_LIST
*, int));
133 static WORD_LIST
*command_line_to_word_list
__P((char *, int, int, int *, int *));
136 static int progcomp_debug
= 0;
139 int prog_completion_enabled
= 1;
141 /* These are used to manage the arrays of strings for possible completions. */
142 ITEMLIST it_aliases
= { 0, it_init_aliases
, (STRINGLIST
*)0 };
143 ITEMLIST it_arrayvars
= { LIST_DYNAMIC
, it_init_arrayvars
, (STRINGLIST
*)0 };
144 ITEMLIST it_bindings
= { 0, it_init_bindings
, (STRINGLIST
*)0 };
145 ITEMLIST it_builtins
= { 0, it_init_builtins
, (STRINGLIST
*)0 };
146 ITEMLIST it_commands
= { LIST_DYNAMIC
}; /* unused */
147 ITEMLIST it_directories
= { LIST_DYNAMIC
}; /* unused */
148 ITEMLIST it_disabled
= { 0, it_init_disabled
, (STRINGLIST
*)0 };
149 ITEMLIST it_enabled
= { 0, it_init_enabled
, (STRINGLIST
*)0 };
150 ITEMLIST it_exports
= { LIST_DYNAMIC
, it_init_exported
, (STRINGLIST
*)0 };
151 ITEMLIST it_files
= { LIST_DYNAMIC
}; /* unused */
152 ITEMLIST it_functions
= { 0, it_init_functions
, (STRINGLIST
*)0 };
153 ITEMLIST it_hostnames
= { LIST_DYNAMIC
, it_init_hostnames
, (STRINGLIST
*)0 };
154 ITEMLIST it_groups
= { LIST_DYNAMIC
}; /* unused */
155 ITEMLIST it_jobs
= { LIST_DYNAMIC
, it_init_jobs
, (STRINGLIST
*)0 };
156 ITEMLIST it_keywords
= { 0, it_init_keywords
, (STRINGLIST
*)0 };
157 ITEMLIST it_running
= { LIST_DYNAMIC
, it_init_running
, (STRINGLIST
*)0 };
158 ITEMLIST it_services
= { LIST_DYNAMIC
}; /* unused */
159 ITEMLIST it_setopts
= { 0, it_init_setopts
, (STRINGLIST
*)0 };
160 ITEMLIST it_shopts
= { 0, it_init_shopts
, (STRINGLIST
*)0 };
161 ITEMLIST it_signals
= { 0, it_init_signals
, (STRINGLIST
*)0 };
162 ITEMLIST it_stopped
= { LIST_DYNAMIC
, it_init_stopped
, (STRINGLIST
*)0 };
163 ITEMLIST it_users
= { LIST_DYNAMIC
}; /* unused */
164 ITEMLIST it_variables
= { LIST_DYNAMIC
, it_init_variables
, (STRINGLIST
*)0 };
169 #if defined (PREFER_STDARG)
170 debug_printf (const char *format
, ...)
172 debug_printf (format
, va_alist
)
179 if (progcomp_debug
== 0)
182 SH_VA_START (args
, format
);
184 fprintf (stdout
, "DEBUG: ");
185 vfprintf (stdout
, format
, args
);
186 fprintf (stdout
, "\n");
194 /* Functions to manage the item lists */
197 set_itemlist_dirty (it
)
200 it
->flags
|= LIST_DIRTY
;
204 initialize_itemlist (itp
)
207 (*itp
->list_getter
) (itp
);
208 itp
->flags
|= LIST_INITIALIZED
;
209 itp
->flags
&= ~LIST_DIRTY
;
221 if ((itp
->flags
& (LIST_DONTFREEMEMBERS
|LIST_DONTFREE
)) == 0)
222 strvec_flush (sl
->list
);
223 if ((itp
->flags
& LIST_DONTFREE
) == 0)
227 itp
->slist
= (STRINGLIST
*)NULL
;
228 itp
->flags
&= ~(LIST_DONTFREE
|LIST_DONTFREEMEMBERS
|LIST_INITIALIZED
|LIST_DIRTY
);
233 shouldexp_filterpat (s
)
238 for (p
= s
; p
&& *p
; p
++)
248 /* Replace any instance of `&' in PAT with TEXT. Backslash may be used to
249 quote a `&' and inhibit substitution. Returns a new string. This just
250 calls stringlib.c:strcreplace(). */
252 preproc_filterpat (pat
, text
)
258 ret
= strcreplace (pat
, '&', text
, 1);
262 /* Remove any match of FILTERPAT from SL. A `&' in FILTERPAT is replaced by
263 TEXT. A leading `!' in FILTERPAT negates the pattern; in this case
264 any member of SL->list that does *not* match will be removed. This returns
265 a new STRINGLIST with the matching members of SL *copied*. Any
266 non-matching members of SL->list are *freed*. */
268 filter_stringlist (sl
, filterpat
, text
)
270 char *filterpat
, *text
;
276 if (sl
== 0 || sl
->list
== 0 || sl
->list_len
== 0)
279 npat
= shouldexp_filterpat (filterpat
) ? preproc_filterpat (filterpat
, text
) : filterpat
;
281 not = (npat
[0] == '!');
282 t
= not ? npat
+ 1 : npat
;
284 ret
= strlist_create (sl
->list_size
);
285 for (i
= 0; i
< sl
->list_len
; i
++)
287 m
= strmatch (t
, sl
->list
[i
], FNMATCH_EXTFLAG
);
288 if ((not && m
== FNM_NOMATCH
) || (not == 0 && m
!= FNM_NOMATCH
))
291 ret
->list
[ret
->list_len
++] = sl
->list
[i
];
294 ret
->list
[ret
->list_len
] = (char *)NULL
;
295 if (npat
!= filterpat
)
301 /* Turn an array of strings returned by rl_completion_matches into a STRINGLIST.
302 This understands how rl_completion_matches sets matches[0] (the lcd of the
303 strings in the list, unless it's the only match). */
305 completions_to_stringlist (matches
)
311 mlen
= (matches
== 0) ? 0 : strvec_len (matches
);
312 sl
= strlist_create (mlen
+ 1);
314 if (matches
== 0 || matches
[0] == 0)
319 sl
->list
[0] = STRDUP (matches
[0]);
320 sl
->list
[sl
->list_len
= 1] = (char *)NULL
;
324 for (i
= 1, n
= 0; i
< mlen
; i
++, n
++)
325 sl
->list
[n
] = STRDUP (matches
[i
]);
327 sl
->list
[n
] = (char *)NULL
;
332 /* Functions to manage the various ITEMLISTs that we populate internally.
333 The caller is responsible for setting ITP->flags correctly. */
336 it_init_aliases (itp
)
340 alias_t
**alias_list
;
344 alias_list
= all_aliases ();
347 itp
->slist
= (STRINGLIST
*)NULL
;
350 for (n
= 0; alias_list
[n
]; n
++)
352 sl
= strlist_create (n
+1);
353 for (i
= 0; i
< n
; i
++)
354 sl
->list
[i
] = STRDUP (alias_list
[i
]->name
);
355 sl
->list
[n
] = (char *)NULL
;
356 sl
->list_size
= sl
->list_len
= n
;
359 itp
->slist
= (STRINGLIST
*)NULL
;
365 init_itemlist_from_varlist (itp
, svfunc
)
373 vlist
= (*svfunc
) ();
374 for (n
= 0; vlist
[n
]; n
++)
376 sl
= strlist_create (n
+1);
377 for (i
= 0; i
< n
; i
++)
378 sl
->list
[i
] = savestring (vlist
[i
]->name
);
379 sl
->list
[sl
->list_len
= n
] = (char *)NULL
;
384 it_init_arrayvars (itp
)
387 #if defined (ARRAY_VARS)
388 init_itemlist_from_varlist (itp
, all_array_variables
);
396 it_init_bindings (itp
)
402 /* rl_funmap_names allocates blist, but not its members */
403 blist
= (char **)rl_funmap_names (); /* XXX fix const later */
404 sl
= strlist_create (0);
407 sl
->list_len
= strvec_len (sl
->list
);
408 itp
->flags
|= LIST_DONTFREEMEMBERS
;
415 it_init_builtins (itp
)
421 sl
= strlist_create (num_shell_builtins
);
422 for (i
= n
= 0; i
< num_shell_builtins
; i
++)
423 if (shell_builtins
[i
].function
)
424 sl
->list
[n
++] = shell_builtins
[i
].name
;
425 sl
->list
[sl
->list_len
= n
] = (char *)NULL
;
426 itp
->flags
|= LIST_DONTFREEMEMBERS
;
432 it_init_enabled (itp
)
438 sl
= strlist_create (num_shell_builtins
);
439 for (i
= n
= 0; i
< num_shell_builtins
; i
++)
441 if (shell_builtins
[i
].function
&& (shell_builtins
[i
].flags
& BUILTIN_ENABLED
))
442 sl
->list
[n
++] = shell_builtins
[i
].name
;
444 sl
->list
[sl
->list_len
= n
] = (char *)NULL
;
445 itp
->flags
|= LIST_DONTFREEMEMBERS
;
451 it_init_disabled (itp
)
457 sl
= strlist_create (num_shell_builtins
);
458 for (i
= n
= 0; i
< num_shell_builtins
; i
++)
460 if (shell_builtins
[i
].function
&& ((shell_builtins
[i
].flags
& BUILTIN_ENABLED
) == 0))
461 sl
->list
[n
++] = shell_builtins
[i
].name
;
463 sl
->list
[sl
->list_len
= n
] = (char *)NULL
;
464 itp
->flags
|= LIST_DONTFREEMEMBERS
;
470 it_init_exported (itp
)
473 init_itemlist_from_varlist (itp
, all_exported_variables
);
478 it_init_functions (itp
)
481 init_itemlist_from_varlist (itp
, all_visible_functions
);
486 it_init_hostnames (itp
)
491 sl
= strlist_create (0);
492 sl
->list
= get_hostname_list ();
493 sl
->list_len
= sl
->list
? strvec_len (sl
->list
) : 0;
494 sl
->list_size
= sl
->list_len
;
496 itp
->flags
|= LIST_DONTFREEMEMBERS
|LIST_DONTFREE
;
501 it_init_joblist (itp
, jstate
)
505 #if defined (JOB_CONTROL)
514 else if (jstate
== 1)
517 sl
= strlist_create (job_slots
);
518 for (i
= job_slots
- 1; i
>= 0; i
--)
523 if (jstate
== -1 || JOBSTATE(i
) == js
)
525 s
= savestring (p
->command
);
526 t
= strpbrk (s
, " \t\n");
529 sl
->list
[sl
->list_len
++] = s
;
534 itp
->slist
= (STRINGLIST
*)NULL
;
543 return (it_init_joblist (itp
, -1));
547 it_init_running (itp
)
550 return (it_init_joblist (itp
, 0));
554 it_init_stopped (itp
)
557 return (it_init_joblist (itp
, 1));
561 it_init_keywords (itp
)
567 for (n
= 0; word_token_alist
[n
].word
; n
++)
569 sl
= strlist_create (n
);
570 for (i
= 0; i
< n
; i
++)
571 sl
->list
[i
] = word_token_alist
[i
].word
;
572 sl
->list
[sl
->list_len
= i
] = (char *)NULL
;
573 itp
->flags
|= LIST_DONTFREEMEMBERS
;
579 it_init_signals (itp
)
584 sl
= strlist_create (0);
585 sl
->list
= signal_names
;
586 sl
->list_len
= strvec_len (sl
->list
);
587 itp
->flags
|= LIST_DONTFREE
;
593 it_init_variables (itp
)
596 init_itemlist_from_varlist (itp
, all_visible_variables
);
601 it_init_setopts (itp
)
606 sl
= strlist_create (0);
607 sl
->list
= get_minus_o_opts ();
608 sl
->list_len
= strvec_len (sl
->list
);
610 itp
->flags
|= LIST_DONTFREEMEMBERS
;
620 sl
= strlist_create (0);
621 sl
->list
= get_shopt_options ();
622 sl
->list_len
= strvec_len (sl
->list
);
624 itp
->flags
|= LIST_DONTFREEMEMBERS
;
628 /* Generate a list of all matches for TEXT using the STRINGLIST in itp->slist
629 as the list of possibilities. If the itemlist has been marked dirty or
630 it should be regenerated every time, destroy the old STRINGLIST and make a
631 new one before trying the match. */
633 gen_matches_from_itemlist (itp
, text
)
637 STRINGLIST
*ret
, *sl
;
640 if ((itp
->flags
& (LIST_DIRTY
|LIST_DYNAMIC
)) ||
641 (itp
->flags
& LIST_INITIALIZED
) == 0)
643 if (itp
->flags
& (LIST_DIRTY
| LIST_DYNAMIC
))
644 clean_itemlist (itp
);
645 if ((itp
->flags
& LIST_INITIALIZED
) == 0)
646 initialize_itemlist (itp
);
649 return ((STRINGLIST
*)NULL
);
650 ret
= strlist_create (itp
->slist
->list_len
+1);
652 tlen
= STRLEN (text
);
653 for (i
= n
= 0; i
< sl
->list_len
; i
++)
655 if (tlen
== 0 || STREQN (sl
->list
[i
], text
, tlen
))
656 ret
->list
[n
++] = STRDUP (sl
->list
[i
]);
658 ret
->list
[ret
->list_len
= n
] = (char *)NULL
;
662 /* A wrapper for rl_filename_completion_function that dequotes the filename
663 before attempting completions. */
665 pcomp_filename_completion_function (text
, state
)
669 static char *dfn
; /* dequoted filename */
675 /* remove backslashes quoting special characters in filenames. */
676 if (rl_filename_dequoting_function
)
678 qc
= (text
[0] == '"' || text
[0] == '\'') ? text
[0] : 0;
679 dfn
= (*rl_filename_dequoting_function
) ((char *)text
, qc
);
682 dfn
= savestring (text
);
685 return (rl_filename_completion_function (dfn
, state
));
688 #define GEN_COMPS(bmap, flag, it, text, glist, tlist) \
692 tlist = gen_matches_from_itemlist (it, text); \
695 glist = strlist_append (glist, tlist); \
696 strlist_dispose (tlist); \
701 #define GEN_XCOMPS(bmap, flag, text, func, cmatches, glist, tlist) \
705 cmatches = rl_completion_matches (text, func); \
706 tlist = completions_to_stringlist (cmatches); \
707 glist = strlist_append (glist, tlist); \
708 strvec_dispose (cmatches); \
709 strlist_dispose (tlist); \
713 /* Functions to generate lists of matches from the actions member of CS. */
716 gen_action_completions (cs
, text
)
720 STRINGLIST
*ret
, *tmatches
;
721 char **cmatches
; /* from rl_completion_matches ... */
724 ret
= tmatches
= (STRINGLIST
*)NULL
;
727 GEN_COMPS (flags
, CA_ALIAS
, &it_aliases
, text
, ret
, tmatches
);
728 GEN_COMPS (flags
, CA_ARRAYVAR
, &it_arrayvars
, text
, ret
, tmatches
);
729 GEN_COMPS (flags
, CA_BINDING
, &it_bindings
, text
, ret
, tmatches
);
730 GEN_COMPS (flags
, CA_BUILTIN
, &it_builtins
, text
, ret
, tmatches
);
731 GEN_COMPS (flags
, CA_DISABLED
, &it_disabled
, text
, ret
, tmatches
);
732 GEN_COMPS (flags
, CA_ENABLED
, &it_enabled
, text
, ret
, tmatches
);
733 GEN_COMPS (flags
, CA_EXPORT
, &it_exports
, text
, ret
, tmatches
);
734 GEN_COMPS (flags
, CA_FUNCTION
, &it_functions
, text
, ret
, tmatches
);
735 GEN_COMPS (flags
, CA_HOSTNAME
, &it_hostnames
, text
, ret
, tmatches
);
736 GEN_COMPS (flags
, CA_JOB
, &it_jobs
, text
, ret
, tmatches
);
737 GEN_COMPS (flags
, CA_KEYWORD
, &it_keywords
, text
, ret
, tmatches
);
738 GEN_COMPS (flags
, CA_RUNNING
, &it_running
, text
, ret
, tmatches
);
739 GEN_COMPS (flags
, CA_SETOPT
, &it_setopts
, text
, ret
, tmatches
);
740 GEN_COMPS (flags
, CA_SHOPT
, &it_shopts
, text
, ret
, tmatches
);
741 GEN_COMPS (flags
, CA_SIGNAL
, &it_signals
, text
, ret
, tmatches
);
742 GEN_COMPS (flags
, CA_STOPPED
, &it_stopped
, text
, ret
, tmatches
);
743 GEN_COMPS (flags
, CA_VARIABLE
, &it_variables
, text
, ret
, tmatches
);
745 GEN_XCOMPS(flags
, CA_COMMAND
, text
, command_word_completion_function
, cmatches
, ret
, tmatches
);
746 GEN_XCOMPS(flags
, CA_FILE
, text
, pcomp_filename_completion_function
, cmatches
, ret
, tmatches
);
747 GEN_XCOMPS(flags
, CA_USER
, text
, rl_username_completion_function
, cmatches
, ret
, tmatches
);
748 GEN_XCOMPS(flags
, CA_GROUP
, text
, bash_groupname_completion_function
, cmatches
, ret
, tmatches
);
749 GEN_XCOMPS(flags
, CA_SERVICE
, text
, bash_servicename_completion_function
, cmatches
, ret
, tmatches
);
751 /* And lastly, the special case for directories */
752 if (flags
& CA_DIRECTORY
)
754 rl_completion_mark_symlink_dirs
= 1; /* override user preference */
755 cmatches
= bash_directory_completion_matches (text
);
756 tmatches
= completions_to_stringlist (cmatches
);
757 ret
= strlist_append (ret
, tmatches
);
758 strvec_dispose (cmatches
);
759 strlist_dispose (tmatches
);
765 /* Generate a list of matches for CS->globpat. Unresolved: should this use
766 TEXT as a match prefix, or just go without? Currently, the code does not
767 use TEXT, just globs CS->globpat and returns the results. If we do decide
768 to use TEXT, we should call quote_string_for_globbing before the call to
771 gen_globpat_matches (cs
, text
)
777 sl
= strlist_create (0);
778 sl
->list
= glob_filename (cs
->globpat
, 0);
779 if (GLOB_FAILED (sl
->list
))
780 sl
->list
= (char **)NULL
;
782 sl
->list_len
= sl
->list_size
= strvec_len (sl
->list
);
786 /* Perform the shell word expansions on CS->words and return the results.
787 Again, this ignores TEXT. */
789 gen_wordlist_matches (cs
, text
)
797 if (cs
->words
== 0 || cs
->words
[0] == '\0')
798 return ((STRINGLIST
*)NULL
);
800 /* This used to be a simple expand_string(cs->words, 0), but that won't
801 do -- there's no way to split a simple list into individual words
802 that way, since the shell semantics say that word splitting is done
803 only on the results of expansion. */
804 l
= split_at_delims (cs
->words
, strlen (cs
->words
), (char *)NULL
, -1, (int *)NULL
, (int *)NULL
);
806 return ((STRINGLIST
*)NULL
);
807 /* This will jump back to the top level if the expansion fails... */
808 l2
= expand_words_shellexp (l
);
811 nw
= list_length (l2
);
812 sl
= strlist_create (nw
+ 1);
813 tlen
= STRLEN (text
);
815 for (nw
= 0, l
= l2
; l
; l
= l
->next
)
817 if (tlen
== 0 || STREQN (l
->word
->word
, text
, tlen
))
818 sl
->list
[nw
++] = STRDUP (l
->word
->word
);
820 sl
->list
[sl
->list_len
= nw
] = (char *)NULL
;
828 bind_comp_words (lwords
)
833 v
= find_variable ("COMP_WORDS");
835 v
= make_new_array_variable ("COMP_WORDS");
837 VUNSETATTR (v
, att_readonly
);
838 if (array_p (v
) == 0)
839 v
= convert_var_to_array (v
);
840 v
= assign_array_var_from_word_list (v
, lwords
);
843 #endif /* ARRAY_VARS */
846 bind_compfunc_variables (line
, ind
, lwords
, cw
, exported
)
852 char ibuf
[INT_STRLEN_BOUND(int) + 1];
856 /* Set the variables that the function expects while it executes. Maybe
857 these should be in the function environment (temporary_env). */
858 v
= bind_variable ("COMP_LINE", line
);
860 VSETATTR(v
, att_exported
);
862 value
= inttostr (ind
, ibuf
, sizeof(ibuf
));
863 v
= bind_int_variable ("COMP_POINT", value
);
865 VSETATTR(v
, att_exported
);
867 /* Since array variables can't be exported, we don't bother making the
872 v
= bind_comp_words (lwords
);
873 value
= inttostr (cw
, ibuf
, sizeof(ibuf
));
874 bind_int_variable ("COMP_CWORD", value
);
878 array_needs_making
= 1;
882 unbind_compfunc_variables (exported
)
885 unbind_variable ("COMP_LINE");
886 unbind_variable ("COMP_POINT");
888 unbind_variable ("COMP_WORDS");
889 unbind_variable ("COMP_CWORD");
892 array_needs_making
= 1;
895 /* Build the list of words to pass to a function or external command
896 as arguments. When the function or command is invoked,
898 $0 == function or command being invoked
900 $2 = word to be completed (possibly null)
903 Functions can access all of the words in the current command line
904 with the COMP_WORDS array. External commands cannot. */
907 build_arg_list (cmd
, text
, lwords
, ind
)
913 WORD_LIST
*ret
, *cl
, *l
;
917 ret
= (WORD_LIST
*)NULL
;
919 ret
= make_word_list (w
, (WORD_LIST
*)NULL
);
921 w
= (lwords
&& lwords
->word
) ? copy_word (lwords
->word
) : make_word ("");
922 cl
= ret
->next
= make_word_list (w
, (WORD_LIST
*)NULL
);
924 w
= make_word (text
);
925 cl
->next
= make_word_list (w
, (WORD_LIST
*)NULL
);
928 /* Search lwords for current word */
929 for (l
= lwords
, i
= 1; l
&& i
< ind
-1; l
= l
->next
, i
++)
931 w
= (l
&& l
->word
) ? copy_word (l
->word
) : make_word ("");
932 cl
->next
= make_word_list (w
, (WORD_LIST
*)NULL
);
937 /* Build a command string with
938 $0 == cs->funcname (function to execute for completion list)
939 $1 == command name (command being completed)
940 $2 = word to be completed (possibly null)
942 and run in the current shell. The function should put its completion
943 list into the array variable COMPREPLY. We build a STRINGLIST
944 from the results and return it.
946 Since the shell function should return its list of matches in an array
947 variable, this does nothing if arrays are not compiled into the shell. */
950 gen_shell_function_matches (cs
, text
, line
, ind
, lwords
, nw
, cw
)
963 #if defined (ARRAY_VARS)
967 funcname
= cs
->funcname
;
968 f
= find_function (funcname
);
971 internal_error ("completion: function `%s' not found", funcname
);
974 return ((STRINGLIST
*)NULL
);
977 #if !defined (ARRAY_VARS)
978 return ((STRINGLIST
*)NULL
);
981 /* We pass cw - 1 because command_line_to_word_list returns indices that are
982 1-based, while bash arrays are 0-based. */
983 bind_compfunc_variables (line
, ind
, lwords
, cw
- 1, 0);
985 cmdlist
= build_arg_list (funcname
, text
, lwords
, cw
);
987 fval
= execute_shell_function (f
, cmdlist
);
989 /* Now clean up and destroy everything. */
990 dispose_words (cmdlist
);
991 unbind_compfunc_variables (0);
993 /* The list of completions is returned in the array variable COMPREPLY. */
994 v
= find_variable ("COMPREPLY");
996 return ((STRINGLIST
*)NULL
);
997 if (array_p (v
) == 0)
998 v
= convert_var_to_array (v
);
1001 if (a
== 0 || array_empty (a
))
1002 sl
= (STRINGLIST
*)NULL
;
1005 /* XXX - should we filter the list of completions so only those matching
1006 TEXT are returned? Right now, we do not. */
1007 sl
= strlist_create (0);
1008 sl
->list
= array_to_argv (a
);
1009 sl
->list_len
= sl
->list_size
= array_num_elements (a
);
1012 /* XXX - should we unbind COMPREPLY here? */
1013 unbind_variable ("COMPREPLY");
1019 /* Build a command string with
1020 $0 == cs->command (command to execute for completion list)
1021 $1 == command name (command being completed)
1022 $2 = word to be completed (possibly null)
1024 and run in with command substitution. Parse the results, one word
1025 per line, with backslashes allowed to escape newlines. Build a
1026 STRINGLIST from the results and return it. */
1029 gen_command_matches (cs
, text
, line
, ind
, lwords
, nw
, cw
)
1037 char *csbuf
, *cscmd
, *t
;
1038 int cmdlen
, cmdsize
, n
, ws
, we
;
1039 WORD_LIST
*cmdlist
, *cl
;
1042 bind_compfunc_variables (line
, ind
, lwords
, cw
, 1);
1043 cmdlist
= build_arg_list (cs
->command
, text
, lwords
, cw
);
1045 /* Estimate the size needed for the buffer. */
1046 n
= strlen (cs
->command
);
1048 for (cl
= cmdlist
->next
; cl
; cl
= cl
->next
)
1049 cmdsize
+= STRLEN (cl
->word
->word
) + 3;
1052 /* allocate the string for the command and fill it in. */
1053 cscmd
= (char *)xmalloc (cmdsize
+ 1);
1055 strcpy (cscmd
, cs
->command
); /* $0 */
1057 cscmd
[cmdlen
++] = ' ';
1058 for (cl
= cmdlist
->next
; cl
; cl
= cl
->next
) /* $1, $2, $3, ... */
1060 t
= sh_single_quote (cl
->word
->word
? cl
->word
->word
: "");
1062 RESIZE_MALLOCED_BUFFER (cscmd
, cmdlen
, n
+ 2, cmdsize
, 64);
1063 strcpy (cscmd
+ cmdlen
, t
);
1066 cscmd
[cmdlen
++] = ' ';
1069 cscmd
[cmdlen
] = '\0';
1071 csbuf
= command_substitute (cscmd
, 0);
1073 /* Now clean up and destroy everything. */
1074 dispose_words (cmdlist
);
1076 unbind_compfunc_variables (1);
1078 if (csbuf
== 0 || *csbuf
== '\0')
1081 return ((STRINGLIST
*)NULL
);
1084 /* Now break CSBUF up at newlines, with backslash allowed to escape a
1085 newline, and put the individual words into a STRINGLIST. */
1086 sl
= strlist_create (16);
1087 for (ws
= 0; csbuf
[ws
]; )
1090 while (csbuf
[we
] && csbuf
[we
] != '\n')
1092 if (csbuf
[we
] == '\\' && csbuf
[we
+1] == '\n')
1096 t
= substring (csbuf
, ws
, we
);
1097 if (sl
->list_len
>= sl
->list_size
- 1)
1098 strlist_resize (sl
, sl
->list_size
+ 16);
1099 sl
->list
[sl
->list_len
++] = t
;
1100 while (csbuf
[we
] == '\n') we
++;
1103 sl
->list
[sl
->list_len
] = (char *)NULL
;
1110 command_line_to_word_list (line
, llen
, sentinel
, nwp
, cwp
)
1112 int llen
, sentinel
, *nwp
, *cwp
;
1117 delims
= "()<>;&| \t\n"; /* shell metacharacters break words */
1118 ret
= split_at_delims (line
, llen
, delims
, sentinel
, nwp
, cwp
);
1122 /* Evaluate COMPSPEC *cs and return all matches for WORD. */
1125 gen_compspec_completions (cs
, cmd
, word
, start
, end
)
1131 STRINGLIST
*ret
, *tmatches
;
1137 debug_printf ("gen_compspec_completions (%s, %s, %d, %d)", cmd
, word
, start
, end
);
1138 debug_printf ("gen_compspec_completions: %s -> %p", cmd
, cs
);
1140 ret
= gen_action_completions (cs
, word
);
1142 if (ret
&& progcomp_debug
)
1144 debug_printf ("gen_action_completions (%p, %s) -->", cs
, word
);
1145 strlist_print (ret
, "\t");
1150 /* Now we start generating completions based on the other members of CS. */
1153 tmatches
= gen_globpat_matches (cs
, word
);
1159 debug_printf ("gen_globpat_matches (%p, %s) -->", cs
, word
);
1160 strlist_print (tmatches
, "\t");
1164 ret
= strlist_append (ret
, tmatches
);
1165 strlist_dispose (tmatches
);
1166 rl_filename_completion_desired
= 1;
1172 tmatches
= gen_wordlist_matches (cs
, word
);
1178 debug_printf ("gen_wordlist_matches (%p, %s) -->", cs
, word
);
1179 strlist_print (tmatches
, "\t");
1183 ret
= strlist_append (ret
, tmatches
);
1184 strlist_dispose (tmatches
);
1188 lwords
= (WORD_LIST
*)NULL
;
1189 line
= (char *)NULL
;
1190 if (cs
->command
|| cs
->funcname
)
1192 /* If we have a command or function to execute, we need to first break
1193 the command line into individual words, find the number of words,
1194 and find the word in the list containing the word to be completed. */
1195 line
= substring (rl_line_buffer
, start
, end
);
1199 debug_printf ("command_line_to_word_list (%s, %d, %d, %p, %p)",
1200 line
, llen
, rl_point
- start
, &nw
, &cw
);
1202 lwords
= command_line_to_word_list (line
, llen
, rl_point
- start
, &nw
, &cw
);
1204 if (lwords
== 0 && llen
> 0)
1205 debug_printf ("ERROR: command_line_to_word_list returns NULL");
1206 else if (progcomp_debug
)
1208 debug_printf ("command_line_to_word_list -->");
1210 print_word_list (lwords
, "!");
1220 tmatches
= gen_shell_function_matches (cs
, word
, line
, rl_point
- start
, lwords
, nw
, cw
);
1226 debug_printf ("gen_shell_function_matches (%p, %s, %p, %d, %d) -->", cs
, word
, lwords
, nw
, cw
);
1227 strlist_print (tmatches
, "\t");
1231 ret
= strlist_append (ret
, tmatches
);
1232 strlist_dispose (tmatches
);
1238 tmatches
= gen_command_matches (cs
, word
, line
, rl_point
- start
, lwords
, nw
, cw
);
1244 debug_printf ("gen_command_matches (%p, %s, %p, %d, %d) -->", cs
, word
, lwords
, nw
, cw
);
1245 strlist_print (tmatches
, "\t");
1249 ret
= strlist_append (ret
, tmatches
);
1250 strlist_dispose (tmatches
);
1254 if (cs
->command
|| cs
->funcname
)
1257 dispose_words (lwords
);
1263 tmatches
= filter_stringlist (ret
, cs
->filterpat
, word
);
1267 debug_printf ("filter_stringlist (%p, %s, %s) -->", ret
, cs
->filterpat
, word
);
1268 strlist_print (tmatches
, "\t");
1272 if (ret
&& ret
!= tmatches
)
1280 if (cs
->prefix
|| cs
->suffix
)
1281 ret
= strlist_prefix_suffix (ret
, cs
->prefix
, cs
->suffix
);
1283 /* If no matches have been generated and the user has specified that
1284 directory completion should be done as a default, call
1285 gen_action_completions again to generate a list of matching directory
1287 if ((ret
== 0 || ret
->list_len
== 0) && (cs
->options
& COPT_DIRNAMES
))
1291 dummy
= compspec_create ();
1292 dummy
->actions
= CA_DIRECTORY
;
1293 ret
= gen_action_completions (dummy
, word
);
1294 compspec_dispose (dummy
);
1300 /* The driver function for the programmable completion code. Returns a list
1301 of matches for WORD, which is an argument to command CMD. START and END
1302 bound the command currently being completed in rl_line_buffer. */
1304 programmable_completions (cmd
, word
, start
, end
, foundp
)
1307 int start
, end
, *foundp
;
1311 char **rmatches
, *t
;
1313 /* We look at the basename of CMD if the full command does not have
1314 an associated COMPSPEC. */
1315 cs
= progcomp_search (cmd
);
1318 t
= strrchr (cmd
, '/');
1320 cs
= progcomp_search (++t
);
1326 return ((char **)NULL
);
1329 /* Signal the caller that we found a COMPSPEC for this command, and pass
1330 back any meta-options associated with the compspec. */
1332 *foundp
= 1|cs
->options
;
1334 ret
= gen_compspec_completions (cs
, cmd
, word
, start
, end
);
1338 rmatches
= ret
->list
;
1342 rmatches
= (char **)NULL
;
1347 #endif /* PROGRAMMABLE_COMPLETION */