2 /* complete.c -- filename completion for readline. */
4 /* Copyright (C) 1987-2005 Free Software Foundation, Inc.
6 This file is part of the GNU Readline Library, a library for
7 reading lines of text with interactive input and history editing.
9 The GNU Readline Library is free software; you can redistribute it
10 and/or modify it under the terms of the GNU General Public License
11 as published by the Free Software Foundation; either version 2, or
12 (at your option) any later version.
14 The GNU Readline Library is distributed in the hope that it will be
15 useful, but WITHOUT ANY WARRANTY; without even the implied warranty
16 of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 The GNU General Public License is often shipped with GNU software, and
20 is generally kept in a file called COPYING or LICENSE. If you do not
21 have a copy of the license, write to the Free Software Foundation,
22 59 Temple Place, Suite 330, Boston, MA 02111 USA. */
23 #define READLINE_LIBRARY
25 #if defined (HAVE_CONFIG_H)
29 #include <sys/types.h>
31 #if defined (HAVE_SYS_FILE_H)
32 # include <sys/file.h>
35 #if defined (HAVE_UNISTD_H)
37 #endif /* HAVE_UNISTD_H */
39 #if defined (HAVE_STDLIB_H)
42 # include "ansi_stdlib.h"
43 #endif /* HAVE_STDLIB_H */
52 #if defined (HAVE_PWD_H)
57 #include "posixstat.h"
59 /* System-specific feature definitions and include files. */
63 /* Some standard library routines. */
66 #include "rlprivate.h"
69 typedef int QSFUNC (const void *, const void *);
71 typedef int QSFUNC ();
80 /* Unix version of a hidden file. Could be different on other systems. */
81 #define HIDDEN_FILE(fname) ((fname)[0] == '.')
83 /* Most systems don't declare getpwent in <pwd.h> if _POSIX_SOURCE is
85 #if defined (HAVE_GETPWENT) && (!defined (HAVE_GETPW_DECLS) || defined (_POSIX_SOURCE))
86 extern struct passwd *getpwent PARAMS((void));
87 #endif /* HAVE_GETPWENT && (!HAVE_GETPW_DECLS || _POSIX_SOURCE) */
89 /* If non-zero, then this is the address of a function to call when
90 completing a word would normally display the list of possible matches.
91 This function is called instead of actually doing the display.
92 It takes three arguments: (char **matches, int num_matches, int max_length)
93 where MATCHES is the array of strings that matched, NUM_MATCHES is the
94 number of strings in that array, and MAX_LENGTH is the length of the
95 longest string in that array. */
96 rl_compdisp_func_t *rl_completion_display_matches_hook = (rl_compdisp_func_t *)NULL;
98 #if defined (VISIBLE_STATS)
102 static int stat_char PARAMS((char *));
105 static int path_isdir PARAMS((const char *));
107 static char *rl_quote_filename PARAMS((char *, int, char *));
109 static void set_completion_defaults PARAMS((int));
110 static int get_y_or_n PARAMS((int));
111 static int _rl_internal_pager PARAMS((int));
112 static char *printable_part PARAMS((char *));
113 static int fnwidth PARAMS((const char *));
114 static int fnprint PARAMS((const char *));
115 static int print_filename PARAMS((char *, char *));
117 static char **gen_completion_matches PARAMS((char *, int, int, rl_compentry_func_t *, int, int));
119 static char **remove_duplicate_matches PARAMS((char **));
120 static void insert_match PARAMS((char *, int, int, char *));
121 static int append_to_match PARAMS((char *, int, int, int));
122 static void insert_all_matches PARAMS((char **, int, char *));
123 static void display_matches PARAMS((char **));
124 static int compute_lcd_of_matches PARAMS((char **, int, const char *));
125 static int postprocess_matches PARAMS((char ***, int));
127 static char *make_quoted_replacement PARAMS((char *, int, char *));
129 /* **************************************************************** */
131 /* Completion matching, from readline's point of view. */
133 /* **************************************************************** */
135 /* Variables known only to the readline library. */
137 /* If non-zero, non-unique completions always show the list of matches. */
138 int _rl_complete_show_all = 0;
140 /* If non-zero, non-unique completions show the list of matches, unless it
141 is not possible to do partial completion and modify the line. */
142 int _rl_complete_show_unmodified = 0;
144 /* If non-zero, completed directory names have a slash appended. */
145 int _rl_complete_mark_directories = 1;
147 /* If non-zero, the symlinked directory completion behavior introduced in
148 readline-4.2a is disabled, and symlinks that point to directories have
149 a slash appended (subject to the value of _rl_complete_mark_directories).
150 This is user-settable via the mark-symlinked-directories variable. */
151 int _rl_complete_mark_symlink_dirs = 0;
153 /* If non-zero, completions are printed horizontally in alphabetical order,
155 int _rl_print_completions_horizontally;
157 /* Non-zero means that case is not significant in filename completion. */
158 #if defined (__MSDOS__) && !defined (__DJGPP__)
159 int _rl_completion_case_fold = 1;
161 int _rl_completion_case_fold;
164 /* If non-zero, don't match hidden files (filenames beginning with a `.' on
165 Unix) when doing filename completion. */
166 int _rl_match_hidden_files = 1;
168 /* Global variables available to applications using readline. */
170 #if defined (VISIBLE_STATS)
171 /* Non-zero means add an additional character to each filename displayed
172 during listing completion iff rl_filename_completion_desired which helps
173 to indicate the type of file being listed. */
174 int rl_visible_stats = 0;
175 #endif /* VISIBLE_STATS */
177 /* If non-zero, then this is the address of a function to call when
178 completing on a directory name. The function is called with
179 the address of a string (the current directory name) as an arg. */
180 rl_icppfunc_t *rl_directory_completion_hook = (rl_icppfunc_t *)NULL;
182 rl_icppfunc_t *rl_directory_rewrite_hook = (rl_icppfunc_t *)NULL;
184 /* Non-zero means readline completion functions perform tilde expansion. */
185 int rl_complete_with_tilde_expansion = 0;
187 /* Pointer to the generator function for completion_matches ().
188 NULL means to use rl_filename_completion_function (), the default filename
190 rl_compentry_func_t *rl_completion_entry_function = (rl_compentry_func_t *)NULL;
192 /* Pointer to alternative function to create matches.
193 Function is called with TEXT, START, and END.
194 START and END are indices in RL_LINE_BUFFER saying what the boundaries
196 If this function exists and returns NULL then call the value of
197 rl_completion_entry_function to try to match, otherwise use the
198 array of strings returned. */
199 rl_completion_func_t *rl_attempted_completion_function = (rl_completion_func_t *)NULL;
201 /* Non-zero means to suppress normal filename completion after the
202 user-specified completion function has been called. */
203 int rl_attempted_completion_over = 0;
205 /* Set to a character indicating the type of completion being performed
206 by rl_complete_internal, available for use by application completion
208 int rl_completion_type = 0;
210 /* Up to this many items will be displayed in response to a
211 possible-completions call. After that, we ask the user if
212 she is sure she wants to see them all. A negative value means
214 int rl_completion_query_items = 100;
216 int _rl_page_completions = 1;
218 /* The basic list of characters that signal a break between words for the
219 completer routine. The contents of this variable is what breaks words
220 in the shell, i.e. " \t\n\"\\'`@$><=" */
221 const char *rl_basic_word_break_characters = " \t\n\"\\'`@$><=;|&{("; /* }) */
223 /* List of basic quoting characters. */
224 const char *rl_basic_quote_characters = "\"'";
226 /* The list of characters that signal a break between words for
227 rl_complete_internal. The default list is the contents of
228 rl_basic_word_break_characters. */
229 /*const*/ char *rl_completer_word_break_characters = (/*const*/ char *)NULL;
231 /* Hook function to allow an application to set the completion word
232 break characters before readline breaks up the line. Allows
233 position-dependent word break characters. */
234 rl_cpvfunc_t *rl_completion_word_break_hook = (rl_cpvfunc_t *)NULL;
236 /* List of characters which can be used to quote a substring of the line.
237 Completion occurs on the entire substring, and within the substring
238 rl_completer_word_break_characters are treated as any other character,
239 unless they also appear within this list. */
240 const char *rl_completer_quote_characters = (const char *)NULL;
242 /* List of characters that should be quoted in filenames by the completer. */
243 const char *rl_filename_quote_characters = (const char *)NULL;
245 /* List of characters that are word break characters, but should be left
246 in TEXT when it is passed to the completion function. The shell uses
247 this to help determine what kind of completing to do. */
248 const char *rl_special_prefixes = (const char *)NULL;
250 /* If non-zero, then disallow duplicates in the matches. */
251 int rl_ignore_completion_duplicates = 1;
253 /* Non-zero means that the results of the matches are to be treated
254 as filenames. This is ALWAYS zero on entry, and can only be changed
255 within a completion entry finder function. */
256 int rl_filename_completion_desired = 0;
258 /* Non-zero means that the results of the matches are to be quoted using
259 double quotes (or an application-specific quoting mechanism) if the
260 filename contains any characters in rl_filename_quote_chars. This is
261 ALWAYS non-zero on entry, and can only be changed within a completion
262 entry finder function. */
263 int rl_filename_quoting_desired = 1;
265 /* This function, if defined, is called by the completer when real
266 filename completion is done, after all the matching names have been
267 generated. It is passed a (char**) known as matches in the code below.
268 It consists of a NULL-terminated array of pointers to potential
269 matching strings. The 1st element (matches[0]) is the maximal
270 substring that is common to all matches. This function can re-arrange
271 the list of matches as required, but all elements of the array must be
272 free()'d if they are deleted. The main intent of this function is
273 to implement FIGNORE a la SunOS csh. */
274 rl_compignore_func_t *rl_ignore_some_completions_function = (rl_compignore_func_t *)NULL;
276 /* Set to a function to quote a filename in an application-specific fashion.
277 Called with the text to quote, the type of match found (single or multiple)
278 and a pointer to the quoting character to be used, which the function can
280 rl_quote_func_t *rl_filename_quoting_function = rl_quote_filename;
282 /* Function to call to remove quoting characters from a filename. Called
283 before completion is attempted, so the embedded quotes do not interfere
284 with matching names in the file system. Readline doesn't do anything
285 with this; it's set only by applications. */
286 rl_dequote_func_t *rl_filename_dequoting_function = (rl_dequote_func_t *)NULL;
288 /* Function to call to decide whether or not a word break character is
289 quoted. If a character is quoted, it does not break words for the
291 rl_linebuf_func_t *rl_char_is_quoted_p = (rl_linebuf_func_t *)NULL;
293 /* If non-zero, the completion functions don't append anything except a
294 possible closing quote. This is set to 0 by rl_complete_internal and
295 may be changed by an application-specific completion function. */
296 int rl_completion_suppress_append = 0;
298 /* Character appended to completed words when at the end of the line. The
299 default is a space. */
300 int rl_completion_append_character = ' ';
302 /* If non-zero, the completion functions don't append any closing quote.
303 This is set to 0 by rl_complete_internal and may be changed by an
304 application-specific completion function. */
305 int rl_completion_suppress_quote = 0;
307 /* Set to any quote character readline thinks it finds before any application
308 completion function is called. */
309 int rl_completion_quote_character;
311 /* Set to a non-zero value if readline found quoting anywhere in the word to
312 be completed; set before any application completion function is called. */
313 int rl_completion_found_quote;
315 /* If non-zero, a slash will be appended to completed filenames that are
316 symbolic links to directory names, subject to the value of the
317 mark-directories variable (which is user-settable). This exists so
318 that application completion functions can override the user's preference
319 (set via the mark-symlinked-directories variable) if appropriate.
320 It's set to the value of _rl_complete_mark_symlink_dirs in
321 rl_complete_internal before any application-specific completion
322 function is called, so without that function doing anything, the user's
323 preferences are honored. */
324 int rl_completion_mark_symlink_dirs;
326 /* If non-zero, inhibit completion (temporarily). */
327 int rl_inhibit_completion;
329 /* Variables local to this file. */
331 /* Local variable states what happened during the last completion attempt. */
332 static int completion_changed_buffer;
334 /*************************************/
336 /* Bindable completion functions */
338 /*************************************/
340 /* Complete the word at or before point. You have supplied the function
341 that does the initial simple matching selection algorithm (see
342 rl_completion_matches ()). The default is to do filename completion. */
344 rl_complete (ignore, invoking_key)
345 int ignore, invoking_key;
347 if (rl_inhibit_completion)
348 return (_rl_insert_char (ignore, invoking_key));
349 else if (rl_last_func == rl_complete && !completion_changed_buffer)
350 return (rl_complete_internal ('?'));
351 else if (_rl_complete_show_all)
352 return (rl_complete_internal ('!'));
353 else if (_rl_complete_show_unmodified)
354 return (rl_complete_internal ('@'));
356 return (rl_complete_internal (TAB));
359 /* List the possible completions. See description of rl_complete (). */
361 rl_possible_completions (ignore, invoking_key)
362 int ignore, invoking_key;
364 return (rl_complete_internal ('?'));
368 rl_insert_completions (ignore, invoking_key)
369 int ignore, invoking_key;
371 return (rl_complete_internal ('*'));
374 /* Return the correct value to pass to rl_complete_internal performing
375 the same tests as rl_complete. This allows consecutive calls to an
376 application's completion function to list possible completions and for
377 an application-specific completion function to honor the
378 show-all-if-ambiguous readline variable. */
380 rl_completion_mode (cfunc)
381 rl_command_func_t *cfunc;
383 if (rl_last_func == cfunc && !completion_changed_buffer)
385 else if (_rl_complete_show_all)
387 else if (_rl_complete_show_unmodified)
393 /************************************/
395 /* Completion utility functions */
397 /************************************/
399 /* Set default values for readline word completion. These are the variables
400 that application completion functions can change or inspect. */
402 set_completion_defaults (what_to_do)
405 /* Only the completion entry function can change these. */
406 rl_filename_completion_desired = 0;
407 rl_filename_quoting_desired = 1;
408 rl_completion_type = what_to_do;
409 rl_completion_suppress_append = rl_completion_suppress_quote = 0;
411 /* The completion entry function may optionally change this. */
412 rl_completion_mark_symlink_dirs = _rl_complete_mark_symlink_dirs;
415 /* The user must press "y" or "n". Non-zero return means "y" pressed. */
417 get_y_or_n (for_pager)
424 RL_SETSTATE(RL_STATE_MOREINPUT);
426 RL_UNSETSTATE(RL_STATE_MOREINPUT);
428 if (c == 'y' || c == 'Y' || c == ' ')
430 if (c == 'n' || c == 'N' || c == RUBOUT)
432 if (c == ABORT_CHAR || c < 0)
433 _rl_abort_internal ();
434 if (for_pager && (c == NEWLINE || c == RETURN))
436 if (for_pager && (c == 'q' || c == 'Q'))
443 _rl_internal_pager (lines)
448 fprintf (rl_outstream, "--More--");
449 fflush (rl_outstream);
451 _rl_erase_entire_line ();
461 path_isdir (filename)
462 const char *filename;
466 return (stat (filename, &finfo) == 0 && S_ISDIR (finfo.st_mode));
469 #if defined (VISIBLE_STATS)
470 /* Return the character which best describes FILENAME.
471 `@' for symbolic links
476 `%' for character special devices
477 `#' for block special devices */
485 #if defined (HAVE_LSTAT) && defined (S_ISLNK)
486 r = lstat (filename, &finfo);
488 r = stat (filename, &finfo);
495 if (S_ISDIR (finfo.st_mode))
497 #if defined (S_ISCHR)
498 else if (S_ISCHR (finfo.st_mode))
501 #if defined (S_ISBLK)
502 else if (S_ISBLK (finfo.st_mode))
505 #if defined (S_ISLNK)
506 else if (S_ISLNK (finfo.st_mode))
509 #if defined (S_ISSOCK)
510 else if (S_ISSOCK (finfo.st_mode))
512 #endif /* S_ISSOCK */
513 #if defined (S_ISFIFO)
514 else if (S_ISFIFO (finfo.st_mode))
517 else if (S_ISREG (finfo.st_mode))
519 if (access (filename, X_OK) == 0)
524 #endif /* VISIBLE_STATS */
526 /* Return the portion of PATHNAME that should be output when listing
527 possible completions. If we are hacking filename completion, we
528 are only interested in the basename, the portion following the
529 final slash. Otherwise, we return what we were passed. Since
530 printing empty strings is not very informative, if we're doing
531 filename completion, and the basename is the empty string, we look
532 for the previous slash and return the portion following that. If
533 there's no previous slash, we just return what we were passed. */
535 printable_part (pathname)
540 if (rl_filename_completion_desired == 0) /* don't need to do anything */
543 temp = strrchr (pathname, '/');
544 #if defined (__MSDOS__)
545 if (temp == 0 && ISALPHA ((unsigned char)pathname[0]) && pathname[1] == ':')
549 if (temp == 0 || *temp == '\0')
551 /* If the basename is NULL, we might have a pathname like '/usr/src/'.
552 Look for a previous slash and, if one is found, return the portion
553 following that slash. If there's no previous slash, just return the
554 pathname we were passed. */
555 else if (temp[1] == '\0')
557 for (x = temp - 1; x > pathname; x--)
560 return ((*x == '/') ? x + 1 : pathname);
566 /* Compute width of STRING when displayed on screen by print_filename */
572 #if defined (HANDLE_MULTIBYTE)
578 left = strlen (string) + 1;
579 memset (&ps, 0, sizeof (mbstate_t));
585 if (CTRL_CHAR (*string) || *string == RUBOUT)
592 #if defined (HANDLE_MULTIBYTE)
593 clen = mbrtowc (&wc, string + pos, left - pos, &ps);
594 if (MB_INVALIDCH (clen))
598 memset (&ps, 0, sizeof (mbstate_t));
600 else if (MB_NULLWCH (clen))
606 width += (w >= 0) ? w : 1;
620 const char *to_print;
624 #if defined (HANDLE_MULTIBYTE)
631 end = to_print + strlen (to_print) + 1;
632 memset (&ps, 0, sizeof (mbstate_t));
641 putc ('^', rl_outstream);
642 putc (UNCTRL (*s), rl_outstream);
645 #if defined (HANDLE_MULTIBYTE)
646 memset (&ps, 0, sizeof (mbstate_t));
649 else if (*s == RUBOUT)
651 putc ('^', rl_outstream);
652 putc ('?', rl_outstream);
655 #if defined (HANDLE_MULTIBYTE)
656 memset (&ps, 0, sizeof (mbstate_t));
661 #if defined (HANDLE_MULTIBYTE)
662 tlen = mbrtowc (&wc, s, end - s, &ps);
663 if (MB_INVALIDCH (tlen))
667 memset (&ps, 0, sizeof (mbstate_t));
669 else if (MB_NULLWCH (tlen))
674 width = (w >= 0) ? w : 1;
676 fwrite (s, 1, tlen, rl_outstream);
678 printed_len += width;
680 putc (*s, rl_outstream);
690 /* Output TO_PRINT to rl_outstream. If VISIBLE_STATS is defined and we
691 are using it, check for and output a single character for `special'
692 filenames. Return the number of characters we output. */
695 print_filename (to_print, full_pathname)
696 char *to_print, *full_pathname;
698 int printed_len, extension_char, slen, tlen;
699 char *s, c, *new_full_pathname, *dn;
702 printed_len = fnprint (to_print);
704 #if defined (VISIBLE_STATS)
705 if (rl_filename_completion_desired && (rl_visible_stats || _rl_complete_mark_directories))
707 if (rl_filename_completion_desired && _rl_complete_mark_directories)
710 /* If to_print != full_pathname, to_print is the basename of the
711 path passed. In this case, we try to expand the directory
712 name before checking for the stat character. */
713 if (to_print != full_pathname)
715 /* Terminate the directory name. */
719 /* If setting the last slash in full_pathname to a NUL results in
720 full_pathname being the empty string, we are trying to complete
721 files in the root directory. If we pass a null string to the
722 bash directory completion hook, for example, it will expand it
723 to the current directory. We just want the `/'. */
724 if (full_pathname == 0 || *full_pathname == 0)
726 else if (full_pathname[0] != '/')
728 else if (full_pathname[1] == 0)
729 dn = "//"; /* restore trailing slash to `//' */
730 else if (full_pathname[1] == '/' && full_pathname[2] == 0)
731 dn = "/"; /* don't turn /// into // */
734 s = tilde_expand (dn);
735 if (rl_directory_completion_hook)
736 (*rl_directory_completion_hook) (&s);
739 tlen = strlen (to_print);
740 new_full_pathname = (char *)xmalloc (slen + tlen + 2);
741 strcpy (new_full_pathname, s);
742 if (s[slen - 1] == '/')
745 new_full_pathname[slen] = '/';
746 new_full_pathname[slen] = '/';
747 strcpy (new_full_pathname + slen + 1, to_print);
749 #if defined (VISIBLE_STATS)
750 if (rl_visible_stats)
751 extension_char = stat_char (new_full_pathname);
754 if (path_isdir (new_full_pathname))
755 extension_char = '/';
757 free (new_full_pathname);
762 s = tilde_expand (full_pathname);
763 #if defined (VISIBLE_STATS)
764 if (rl_visible_stats)
765 extension_char = stat_char (s);
769 extension_char = '/';
775 putc (extension_char, rl_outstream);
784 rl_quote_filename (s, rtype, qcp)
791 r = (char *)xmalloc (strlen (s) + 2);
792 *r = *rl_completer_quote_characters;
795 *qcp = *rl_completer_quote_characters;
799 /* Find the bounds of the current word for completion purposes, and leave
800 rl_point set to the end of the word. This function skips quoted
801 substrings (characters between matched pairs of characters in
802 rl_completer_quote_characters). First we try to find an unclosed
803 quoted substring on which to do matching. If one is not found, we use
804 the word break characters to find the boundaries of the current word.
805 We call an application-specific function to decide whether or not a
806 particular word break character is quoted; if that function returns a
807 non-zero result, the character does not break a word. This function
808 returns the opening quote character if we found an unclosed quoted
809 substring, '\0' otherwise. FP, if non-null, is set to a value saying
810 which (shell-like) quote characters we found (single quote, double
811 quote, or backslash) anywhere in the string. DP, if non-null, is set to
812 the value of the delimiter character that caused a word break. */
815 _rl_find_completion_word (fp, dp)
818 int scan, end, found_quote, delimiter, pass_next, isbrk;
819 char quote_char, *brkchars;
822 found_quote = delimiter = 0;
826 if (rl_completion_word_break_hook)
827 brkchars = (*rl_completion_word_break_hook) ();
829 brkchars = rl_completer_word_break_characters;
831 if (rl_completer_quote_characters)
833 /* We have a list of characters which can be used in pairs to
834 quote substrings for the completer. Try to find the start
835 of an unclosed quoted substring. */
836 /* FOUND_QUOTE is set so we know what kind of quotes we found. */
837 for (scan = pass_next = 0; scan < end; scan = MB_NEXTCHAR (rl_line_buffer, scan, 1, MB_FIND_ANY))
845 /* Shell-like semantics for single quotes -- don't allow backslash
846 to quote anything in single quotes, especially not the closing
847 quote. If you don't like this, take out the check on the value
849 if (quote_char != '\'' && rl_line_buffer[scan] == '\\')
852 found_quote |= RL_QF_BACKSLASH;
856 if (quote_char != '\0')
858 /* Ignore everything until the matching close quote char. */
859 if (rl_line_buffer[scan] == quote_char)
861 /* Found matching close. Abandon this substring. */
866 else if (strchr (rl_completer_quote_characters, rl_line_buffer[scan]))
868 /* Found start of a quoted substring. */
869 quote_char = rl_line_buffer[scan];
871 /* Shell-like quoting conventions. */
872 if (quote_char == '\'')
873 found_quote |= RL_QF_SINGLE_QUOTE;
874 else if (quote_char == '"')
875 found_quote |= RL_QF_DOUBLE_QUOTE;
877 found_quote |= RL_QF_OTHER_QUOTE;
882 if (rl_point == end && quote_char == '\0')
884 /* We didn't find an unclosed quoted substring upon which to do
885 completion, so use the word break characters to find the
886 substring on which to complete. */
887 while (rl_point = MB_PREVCHAR (rl_line_buffer, rl_point, MB_FIND_ANY))
889 scan = rl_line_buffer[rl_point];
891 if (strchr (brkchars, scan) == 0)
894 /* Call the application-specific function to tell us whether
895 this word break character is quoted and should be skipped. */
896 if (rl_char_is_quoted_p && found_quote &&
897 (*rl_char_is_quoted_p) (rl_line_buffer, rl_point))
900 /* Convoluted code, but it avoids an n^2 algorithm with calls
901 to char_is_quoted. */
906 /* If we are at an unquoted word break, then advance past it. */
907 scan = rl_line_buffer[rl_point];
909 /* If there is an application-specific function to say whether or not
910 a character is quoted and we found a quote character, let that
911 function decide whether or not a character is a word break, even
912 if it is found in rl_completer_word_break_characters. Don't bother
913 if we're at the end of the line, though. */
916 if (rl_char_is_quoted_p)
917 isbrk = (found_quote == 0 ||
918 (*rl_char_is_quoted_p) (rl_line_buffer, rl_point) == 0) &&
919 strchr (brkchars, scan) != 0;
921 isbrk = strchr (brkchars, scan) != 0;
925 /* If the character that caused the word break was a quoting
926 character, then remember it as the delimiter. */
927 if (rl_basic_quote_characters &&
928 strchr (rl_basic_quote_characters, scan) &&
929 (end - rl_point) > 1)
932 /* If the character isn't needed to determine something special
933 about what kind of completion to perform, then advance past it. */
934 if (rl_special_prefixes == 0 || strchr (rl_special_prefixes, scan) == 0)
948 gen_completion_matches (text, start, end, our_func, found_quote, quote_char)
951 rl_compentry_func_t *our_func;
952 int found_quote, quote_char;
956 rl_completion_found_quote = found_quote;
957 rl_completion_quote_character = quote_char;
959 /* If the user wants to TRY to complete, but then wants to give
960 up and use the default completion function, they set the
961 variable rl_attempted_completion_function. */
962 if (rl_attempted_completion_function)
964 matches = (*rl_attempted_completion_function) (text, start, end);
966 if (matches || rl_attempted_completion_over)
968 rl_attempted_completion_over = 0;
973 /* XXX -- filename dequoting moved into rl_filename_completion_function */
975 matches = rl_completion_matches (text, our_func);
979 /* Filter out duplicates in MATCHES. This frees up the strings in
982 remove_duplicate_matches (matches)
990 /* Sort the items. */
991 for (i = 0; matches[i]; i++)
994 /* Sort the array without matches[0], since we need it to
995 stay in place no matter what. */
997 qsort (matches+1, i-1, sizeof (char *), (QSFUNC *)_rl_qsort_string_compare);
999 /* Remember the lowest common denominator for it may be unique. */
1000 lowest_common = savestring (matches[0]);
1002 for (i = newlen = 0; matches[i + 1]; i++)
1004 if (strcmp (matches[i], matches[i + 1]) == 0)
1007 matches[i] = (char *)&dead_slot;
1013 /* We have marked all the dead slots with (char *)&dead_slot.
1014 Copy all the non-dead entries into a new array. */
1015 temp_array = (char **)xmalloc ((3 + newlen) * sizeof (char *));
1016 for (i = j = 1; matches[i]; i++)
1018 if (matches[i] != (char *)&dead_slot)
1019 temp_array[j++] = matches[i];
1021 temp_array[j] = (char *)NULL;
1023 if (matches[0] != (char *)&dead_slot)
1026 /* Place the lowest common denominator back in [0]. */
1027 temp_array[0] = lowest_common;
1029 /* If there is one string left, and it is identical to the
1030 lowest common denominator, then the LCD is the string to
1032 if (j == 2 && strcmp (temp_array[0], temp_array[1]) == 0)
1034 free (temp_array[1]);
1035 temp_array[1] = (char *)NULL;
1037 return (temp_array);
1040 /* Find the common prefix of the list of matches, and put it into
1043 compute_lcd_of_matches (match_list, matches, text)
1048 register int i, c1, c2, si;
1049 int low; /* Count of max-matched characters. */
1050 char *dtext; /* dequoted TEXT, if needed */
1051 #if defined (HANDLE_MULTIBYTE)
1057 /* If only one match, just use that. Otherwise, compare each
1058 member of the list with the next, finding out where they
1062 match_list[0] = match_list[1];
1063 match_list[1] = (char *)NULL;
1067 for (i = 1, low = 100000; i < matches; i++)
1069 #if defined (HANDLE_MULTIBYTE)
1070 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1072 memset (&ps1, 0, sizeof (mbstate_t));
1073 memset (&ps2, 0, sizeof (mbstate_t));
1076 if (_rl_completion_case_fold)
1079 (c1 = _rl_to_lower(match_list[i][si])) &&
1080 (c2 = _rl_to_lower(match_list[i + 1][si]));
1082 #if defined (HANDLE_MULTIBYTE)
1083 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1085 v = mbrtowc (&wc1, match_list[i]+si, strlen (match_list[i]+si), &ps1);
1086 mbrtowc (&wc2, match_list[i+1]+si, strlen (match_list[i+1]+si), &ps2);
1087 wc1 = towlower (wc1);
1088 wc2 = towlower (wc2);
1102 (c1 = match_list[i][si]) &&
1103 (c2 = match_list[i + 1][si]);
1105 #if defined (HANDLE_MULTIBYTE)
1106 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1110 if (!_rl_compare_chars (match_list[i], si, &ps1, match_list[i+1], si, &ps2))
1112 else if ((v = _rl_get_char_len (&match_list[i][si], &ps_back)) > 1)
1125 /* If there were multiple matches, but none matched up to even the
1126 first character, and the user typed something, use that as the
1127 value of matches[0]. */
1128 if (low == 0 && text && *text)
1130 match_list[0] = (char *)xmalloc (strlen (text) + 1);
1131 strcpy (match_list[0], text);
1135 match_list[0] = (char *)xmalloc (low + 1);
1137 /* XXX - this might need changes in the presence of multibyte chars */
1139 /* If we are ignoring case, try to preserve the case of the string
1140 the user typed in the face of multiple matches differing in case. */
1141 if (_rl_completion_case_fold)
1143 /* We're making an assumption here:
1144 IF we're completing filenames AND
1145 the application has defined a filename dequoting function AND
1146 we found a quote character AND
1147 the application has requested filename quoting
1149 we assume that TEXT was dequoted before checking against
1150 the file system and needs to be dequoted here before we
1151 check against the list of matches
1153 dtext = (char *)NULL;
1154 if (rl_filename_completion_desired &&
1155 rl_filename_dequoting_function &&
1156 rl_completion_found_quote &&
1157 rl_filename_quoting_desired)
1159 dtext = (*rl_filename_dequoting_function) ((char *)text, rl_completion_quote_character);
1163 /* sort the list to get consistent answers. */
1164 qsort (match_list+1, matches, sizeof(char *), (QSFUNC *)_rl_qsort_string_compare);
1169 for (i = 1; i <= matches; i++)
1170 if (strncmp (match_list[i], text, si) == 0)
1172 strncpy (match_list[0], match_list[i], low);
1175 /* no casematch, use first entry */
1177 strncpy (match_list[0], match_list[1], low);
1180 /* otherwise, just use the text the user typed. */
1181 strncpy (match_list[0], text, low);
1186 strncpy (match_list[0], match_list[1], low);
1188 match_list[0][low] = '\0';
1195 postprocess_matches (matchesp, matching_filenames)
1197 int matching_filenames;
1199 char *t, **matches, **temp_matches;
1202 matches = *matchesp;
1207 /* It seems to me that in all the cases we handle we would like
1208 to ignore duplicate possiblilities. Scan for the text to
1209 insert being identical to the other completions. */
1210 if (rl_ignore_completion_duplicates)
1212 temp_matches = remove_duplicate_matches (matches);
1214 matches = temp_matches;
1217 /* If we are matching filenames, then here is our chance to
1218 do clever processing by re-examining the list. Call the
1219 ignore function with the array as a parameter. It can
1220 munge the array, deleting matches as it desires. */
1221 if (rl_ignore_some_completions_function && matching_filenames)
1223 for (nmatch = 1; matches[nmatch]; nmatch++)
1225 (void)(*rl_ignore_some_completions_function) (matches);
1226 if (matches == 0 || matches[0] == 0)
1229 *matchesp = (char **)0;
1234 /* If we removed some matches, recompute the common prefix. */
1235 for (i = 1; matches[i]; i++)
1237 if (i > 1 && i < nmatch)
1240 compute_lcd_of_matches (matches, i - 1, t);
1246 *matchesp = matches;
1250 /* A convenience function for displaying a list of strings in
1251 columnar format on readline's output stream. MATCHES is the list
1252 of strings, in argv format, LEN is the number of strings in MATCHES,
1253 and MAX is the length of the longest string in MATCHES. */
1255 rl_display_match_list (matches, len, max)
1259 int count, limit, printed_len, lines;
1263 /* How many items of MAX length can we fit in the screen window? */
1265 limit = _rl_screenwidth / max;
1266 if (limit != 1 && (limit * max == _rl_screenwidth))
1269 /* Avoid a possible floating exception. If max > _rl_screenwidth,
1270 limit will be 0 and a divide-by-zero fault will result. */
1274 /* How many iterations of the printing loop? */
1275 count = (len + (limit - 1)) / limit;
1277 /* Watch out for special case. If LEN is less than LIMIT, then
1278 just do the inner printing loop.
1279 0 < len <= limit implies count = 1. */
1281 /* Sort the items if they are not already sorted. */
1282 if (rl_ignore_completion_duplicates == 0)
1283 qsort (matches + 1, len, sizeof (char *), (QSFUNC *)_rl_qsort_string_compare);
1288 if (_rl_print_completions_horizontally == 0)
1290 /* Print the sorted items, up-and-down alphabetically, like ls. */
1291 for (i = 1; i <= count; i++)
1293 for (j = 0, l = i; j < limit; j++)
1295 if (l > len || matches[l] == 0)
1299 temp = printable_part (matches[l]);
1300 printed_len = print_filename (temp, matches[l]);
1303 for (k = 0; k < max - printed_len; k++)
1304 putc (' ', rl_outstream);
1310 if (_rl_page_completions && lines >= (_rl_screenheight - 1) && i < count)
1312 lines = _rl_internal_pager (lines);
1320 /* Print the sorted items, across alphabetically, like ls -x. */
1321 for (i = 1; matches[i]; i++)
1323 temp = printable_part (matches[i]);
1324 printed_len = print_filename (temp, matches[i]);
1325 /* Have we reached the end of this line? */
1328 if (i && (limit > 1) && (i % limit) == 0)
1332 if (_rl_page_completions && lines >= _rl_screenheight - 1)
1334 lines = _rl_internal_pager (lines);
1340 for (k = 0; k < max - printed_len; k++)
1341 putc (' ', rl_outstream);
1348 /* Display MATCHES, a list of matching filenames in argv format. This
1349 handles the simple case -- a single match -- first. If there is more
1350 than one match, we compute the number of strings in the list and the
1351 length of the longest string, which will be needed by the display
1352 function. If the application wants to handle displaying the list of
1353 matches itself, it sets RL_COMPLETION_DISPLAY_MATCHES_HOOK to the
1354 address of a function, and we just call it. If we're handling the
1355 display ourselves, we just call rl_display_match_list. We also check
1356 that the list of matches doesn't exceed the user-settable threshold,
1357 and ask the user if he wants to see the list if there are more matches
1358 than RL_COMPLETION_QUERY_ITEMS. */
1360 display_matches (matches)
1366 /* Move to the last visible line of a possibly-multiple-line command. */
1367 _rl_move_vert (_rl_vis_botlin);
1369 /* Handle simple case first. What if there is only one answer? */
1370 if (matches[1] == 0)
1372 temp = printable_part (matches[0]);
1374 print_filename (temp, matches[0]);
1377 rl_forced_update_display ();
1378 rl_display_fixed = 1;
1383 /* There is more than one answer. Find out how many there are,
1384 and find the maximum printed length of a single entry. */
1385 for (max = 0, i = 1; matches[i]; i++)
1387 temp = printable_part (matches[i]);
1388 len = fnwidth (temp);
1396 /* If the caller has defined a display hook, then call that now. */
1397 if (rl_completion_display_matches_hook)
1399 (*rl_completion_display_matches_hook) (matches, len, max);
1403 /* If there are many items, then ask the user if she really wants to
1405 if (rl_completion_query_items > 0 && len >= rl_completion_query_items)
1408 fprintf (rl_outstream, "Display all %d possibilities? (y or n)", len);
1409 fflush (rl_outstream);
1410 if (get_y_or_n (0) == 0)
1414 rl_forced_update_display ();
1415 rl_display_fixed = 1;
1421 rl_display_match_list (matches, len, max);
1423 rl_forced_update_display ();
1424 rl_display_fixed = 1;
1428 make_quoted_replacement (match, mtype, qc)
1431 char *qc; /* Pointer to quoting character, if any */
1433 int should_quote, do_replace;
1436 /* If we are doing completion on quoted substrings, and any matches
1437 contain any of the completer_word_break_characters, then auto-
1438 matically prepend the substring with a quote character (just pick
1439 the first one from the list of such) if it does not already begin
1440 with a quote string. FIXME: Need to remove any such automatically
1441 inserted quote character when it no longer is necessary, such as
1442 if we change the string we are completing on and the new set of
1443 matches don't require a quoted substring. */
1444 replacement = match;
1446 should_quote = match && rl_completer_quote_characters &&
1447 rl_filename_completion_desired &&
1448 rl_filename_quoting_desired;
1451 should_quote = should_quote && (!qc || !*qc ||
1452 (rl_completer_quote_characters && strchr (rl_completer_quote_characters, *qc)));
1456 /* If there is a single match, see if we need to quote it.
1457 This also checks whether the common prefix of several
1458 matches needs to be quoted. */
1459 should_quote = rl_filename_quote_characters
1460 ? (_rl_strpbrk (match, rl_filename_quote_characters) != 0)
1463 do_replace = should_quote ? mtype : NO_MATCH;
1464 /* Quote the replacement, since we found an embedded
1465 word break character in a potential match. */
1466 if (do_replace != NO_MATCH && rl_filename_quoting_function)
1467 replacement = (*rl_filename_quoting_function) (match, do_replace, qc);
1469 return (replacement);
1473 insert_match (match, start, mtype, qc)
1481 oqc = qc ? *qc : '\0';
1482 replacement = make_quoted_replacement (match, mtype, qc);
1484 /* Now insert the match. */
1487 /* Don't double an opening quote character. */
1488 if (qc && *qc && start && rl_line_buffer[start - 1] == *qc &&
1489 replacement[0] == *qc)
1491 /* If make_quoted_replacement changed the quoting character, remove
1492 the opening quote and insert the (fully-quoted) replacement. */
1493 else if (qc && (*qc != oqc) && start && rl_line_buffer[start - 1] == oqc &&
1494 replacement[0] != oqc)
1496 _rl_replace_text (replacement, start, rl_point - 1);
1497 if (replacement != match)
1502 /* Append any necessary closing quote and a separator character to the
1503 just-inserted match. If the user has specified that directories
1504 should be marked by a trailing `/', append one of those instead. The
1505 default trailing character is a space. Returns the number of characters
1506 appended. If NONTRIVIAL_MATCH is set, we test for a symlink (if the OS
1507 has them) and don't add a suffix for a symlink to a directory. A
1508 nontrivial match is one that actually adds to the word being completed.
1509 The variable rl_completion_mark_symlink_dirs controls this behavior
1510 (it's initially set to the what the user has chosen, indicated by the
1511 value of _rl_complete_mark_symlink_dirs, but may be modified by an
1512 application's completion function). */
1514 append_to_match (text, delimiter, quote_char, nontrivial_match)
1516 int delimiter, quote_char, nontrivial_match;
1518 char temp_string[4], *filename;
1519 int temp_string_index, s;
1522 temp_string_index = 0;
1523 if (quote_char && rl_point && rl_completion_suppress_quote == 0 &&
1524 rl_line_buffer[rl_point - 1] != quote_char)
1525 temp_string[temp_string_index++] = quote_char;
1528 temp_string[temp_string_index++] = delimiter;
1529 else if (rl_completion_suppress_append == 0 && rl_completion_append_character)
1530 temp_string[temp_string_index++] = rl_completion_append_character;
1532 temp_string[temp_string_index++] = '\0';
1534 if (rl_filename_completion_desired)
1536 filename = tilde_expand (text);
1537 s = (nontrivial_match && rl_completion_mark_symlink_dirs == 0)
1538 ? LSTAT (filename, &finfo)
1539 : stat (filename, &finfo);
1540 if (s == 0 && S_ISDIR (finfo.st_mode))
1542 if (_rl_complete_mark_directories /* && rl_completion_suppress_append == 0 */)
1544 /* This is clumsy. Avoid putting in a double slash if point
1545 is at the end of the line and the previous character is a
1547 if (rl_point && rl_line_buffer[rl_point] == '\0' && rl_line_buffer[rl_point - 1] == '/')
1549 else if (rl_line_buffer[rl_point] != '/')
1550 rl_insert_text ("/");
1554 /* Don't add anything if the filename is a symlink and resolves to a
1556 else if (s == 0 && S_ISLNK (finfo.st_mode) &&
1557 stat (filename, &finfo) == 0 && S_ISDIR (finfo.st_mode))
1562 if (rl_point == rl_end && temp_string_index)
1563 rl_insert_text (temp_string);
1569 if (rl_point == rl_end && temp_string_index)
1570 rl_insert_text (temp_string);
1573 return (temp_string_index);
1577 insert_all_matches (matches, point, qc)
1585 rl_begin_undo_group ();
1586 /* remove any opening quote character; make_quoted_replacement will add
1588 if (qc && *qc && point && rl_line_buffer[point - 1] == *qc)
1590 rl_delete_text (point, rl_point);
1595 for (i = 1; matches[i]; i++)
1597 rp = make_quoted_replacement (matches[i], SINGLE_MATCH, qc);
1598 rl_insert_text (rp);
1599 rl_insert_text (" ");
1600 if (rp != matches[i])
1606 rp = make_quoted_replacement (matches[0], SINGLE_MATCH, qc);
1607 rl_insert_text (rp);
1608 rl_insert_text (" ");
1609 if (rp != matches[0])
1612 rl_end_undo_group ();
1616 _rl_free_match_list (matches)
1624 for (i = 0; matches[i]; i++)
1629 /* Complete the word at or before point.
1630 WHAT_TO_DO says what to do with the completion.
1631 `?' means list the possible completions.
1632 TAB means do standard completion.
1633 `*' means insert all of the possible completions.
1634 `!' means to do standard completion, and list all possible completions if
1635 there is more than one.
1636 `@' means to do standard completion, and list all possible completions if
1637 there is more than one and partial completion is not possible. */
1639 rl_complete_internal (what_to_do)
1643 rl_compentry_func_t *our_func;
1644 int start, end, delimiter, found_quote, i, nontrivial_lcd;
1645 char *text, *saved_line_buffer;
1648 RL_SETSTATE(RL_STATE_COMPLETING);
1650 set_completion_defaults (what_to_do);
1652 saved_line_buffer = rl_line_buffer ? savestring (rl_line_buffer) : (char *)NULL;
1653 our_func = rl_completion_entry_function
1654 ? rl_completion_entry_function
1655 : rl_filename_completion_function;
1656 /* We now look backwards for the start of a filename/variable word. */
1658 found_quote = delimiter = 0;
1662 /* This (possibly) changes rl_point. If it returns a non-zero char,
1663 we know we have an open quote. */
1664 quote_char = _rl_find_completion_word (&found_quote, &delimiter);
1669 text = rl_copy_text (start, end);
1670 matches = gen_completion_matches (text, start, end, our_func, found_quote, quote_char);
1671 /* nontrivial_lcd is set if the common prefix adds something to the word
1673 nontrivial_lcd = matches && strcmp (text, matches[0]) != 0;
1679 FREE (saved_line_buffer);
1680 completion_changed_buffer = 0;
1681 RL_UNSETSTATE(RL_STATE_COMPLETING);
1685 /* If we are matching filenames, the attempted completion function will
1686 have set rl_filename_completion_desired to a non-zero value. The basic
1687 rl_filename_completion_function does this. */
1688 i = rl_filename_completion_desired;
1690 if (postprocess_matches (&matches, i) == 0)
1693 FREE (saved_line_buffer);
1694 completion_changed_buffer = 0;
1695 RL_UNSETSTATE(RL_STATE_COMPLETING);
1704 /* Insert the first match with proper quoting. */
1706 insert_match (matches[0], start, matches[1] ? MULT_MATCH : SINGLE_MATCH, "e_char);
1708 /* If there are more matches, ring the bell to indicate.
1709 If we are in vi mode, Posix.2 says to not ring the bell.
1710 If the `show-all-if-ambiguous' variable is set, display
1711 all the matches immediately. Otherwise, if this was the
1712 only match, and we are hacking files, check the file to
1713 see if it was a directory. If so, and the `mark-directories'
1714 variable is set, add a '/' to the name. If not, and we
1715 are at the end of the line, then add a space. */
1718 if (what_to_do == '!')
1720 display_matches (matches);
1723 else if (what_to_do == '@')
1725 if (nontrivial_lcd == 0)
1726 display_matches (matches);
1729 else if (rl_editing_mode != vi_mode)
1730 rl_ding (); /* There are other matches remaining. */
1733 append_to_match (matches[0], delimiter, quote_char, nontrivial_lcd);
1738 insert_all_matches (matches, start, "e_char);
1742 display_matches (matches);
1746 fprintf (stderr, "\r\nreadline: bad value %d for what_to_do in rl_complete\n", what_to_do);
1748 FREE (saved_line_buffer);
1749 RL_UNSETSTATE(RL_STATE_COMPLETING);
1753 _rl_free_match_list (matches);
1755 /* Check to see if the line has changed through all of this manipulation. */
1756 if (saved_line_buffer)
1758 completion_changed_buffer = strcmp (rl_line_buffer, saved_line_buffer) != 0;
1759 free (saved_line_buffer);
1762 RL_UNSETSTATE(RL_STATE_COMPLETING);
1766 /***************************************************************/
1768 /* Application-callable completion match generator functions */
1770 /***************************************************************/
1772 /* Return an array of (char *) which is a list of completions for TEXT.
1773 If there are no completions, return a NULL pointer.
1774 The first entry in the returned array is the substitution for TEXT.
1775 The remaining entries are the possible completions.
1776 The array is terminated with a NULL pointer.
1778 ENTRY_FUNCTION is a function of two args, and returns a (char *).
1779 The first argument is TEXT.
1780 The second is a state argument; it should be zero on the first call, and
1781 non-zero on subsequent calls. It returns a NULL pointer to the caller
1782 when there are no more matches.
1785 rl_completion_matches (text, entry_function)
1787 rl_compentry_func_t *entry_function;
1789 /* Number of slots in match_list. */
1790 int match_list_size;
1792 /* The list of matches. */
1795 /* Number of matches actually found. */
1798 /* Temporary string binder. */
1802 match_list_size = 10;
1803 match_list = (char **)xmalloc ((match_list_size + 1) * sizeof (char *));
1804 match_list[1] = (char *)NULL;
1806 while (string = (*entry_function) (text, matches))
1808 if (matches + 1 == match_list_size)
1809 match_list = (char **)xrealloc
1810 (match_list, ((match_list_size += 10) + 1) * sizeof (char *));
1812 match_list[++matches] = string;
1813 match_list[matches + 1] = (char *)NULL;
1816 /* If there were any matches, then look through them finding out the
1817 lowest common denominator. That then becomes match_list[0]. */
1819 compute_lcd_of_matches (match_list, matches, text);
1820 else /* There were no matches. */
1823 match_list = (char **)NULL;
1825 return (match_list);
1828 /* A completion function for usernames.
1829 TEXT contains a partial username preceded by a random
1830 character (usually `~'). */
1832 rl_username_completion_function (text, state)
1836 #if defined (__WIN32__) || defined (__OPENNT)
1837 return (char *)NULL;
1838 #else /* !__WIN32__ && !__OPENNT) */
1839 static char *username = (char *)NULL;
1840 static struct passwd *entry;
1841 static int namelen, first_char, first_char_loc;
1849 first_char_loc = first_char == '~';
1851 username = savestring (&text[first_char_loc]);
1852 namelen = strlen (username);
1856 #if defined (HAVE_GETPWENT)
1857 while (entry = getpwent ())
1859 /* Null usernames should result in all users as possible completions. */
1860 if (namelen == 0 || (STREQN (username, entry->pw_name, namelen)))
1867 #if defined (HAVE_GETPWENT)
1870 return ((char *)NULL);
1874 value = (char *)xmalloc (2 + strlen (entry->pw_name));
1878 strcpy (value + first_char_loc, entry->pw_name);
1880 if (first_char == '~')
1881 rl_filename_completion_desired = 1;
1885 #endif /* !__WIN32__ && !__OPENNT */
1888 /* Okay, now we write the entry_function for filename completion. In the
1889 general case. Note that completion in the shell is a little different
1890 because of all the pathnames that must be followed when looking up the
1891 completion for a command. */
1893 rl_filename_completion_function (text, state)
1897 static DIR *directory = (DIR *)NULL;
1898 static char *filename = (char *)NULL;
1899 static char *dirname = (char *)NULL;
1900 static char *users_dirname = (char *)NULL;
1901 static int filename_len;
1904 struct dirent *entry;
1906 /* If we don't have any state, then do some initialization. */
1909 /* If we were interrupted before closing the directory or reading
1910 all of its contents, close it. */
1913 closedir (directory);
1914 directory = (DIR *)NULL;
1918 FREE (users_dirname);
1920 filename = savestring (text);
1923 dirname = savestring (text);
1925 temp = strrchr (dirname, '/');
1927 #if defined (__MSDOS__)
1928 /* special hack for //X/... */
1929 if (dirname[0] == '/' && dirname[1] == '/' && ISALPHA ((unsigned char)dirname[2]) && dirname[3] == '/')
1930 temp = strrchr (dirname + 3, '/');
1935 strcpy (filename, ++temp);
1938 #if defined (__MSDOS__)
1939 /* searches from current directory on the drive */
1940 else if (ISALPHA ((unsigned char)dirname[0]) && dirname[1] == ':')
1942 strcpy (filename, dirname + 2);
1952 /* We aren't done yet. We also support the "~user" syntax. */
1954 /* Save the version of the directory that the user typed. */
1955 users_dirname = savestring (dirname);
1957 if (*dirname == '~')
1959 temp = tilde_expand (dirname);
1964 if (rl_directory_rewrite_hook)
1965 (*rl_directory_rewrite_hook) (&dirname);
1967 /* The directory completion hook should perform any necessary
1969 if (rl_directory_completion_hook && (*rl_directory_completion_hook) (&dirname))
1971 free (users_dirname);
1972 users_dirname = savestring (dirname);
1974 else if (rl_completion_found_quote && rl_filename_dequoting_function)
1976 /* delete single and double quotes */
1977 temp = (*rl_filename_dequoting_function) (users_dirname, rl_completion_quote_character);
1978 free (users_dirname);
1979 users_dirname = temp;
1981 directory = opendir (dirname);
1983 /* Now dequote a non-null filename. */
1984 if (filename && *filename && rl_completion_found_quote && rl_filename_dequoting_function)
1986 /* delete single and double quotes */
1987 temp = (*rl_filename_dequoting_function) (filename, rl_completion_quote_character);
1991 filename_len = strlen (filename);
1993 rl_filename_completion_desired = 1;
1996 /* At this point we should entertain the possibility of hacking wildcarded
1997 filenames, like /usr/man/man<WILD>/te<TAB>. If the directory name
1998 contains globbing characters, then build an array of directories, and
1999 then map over that list while completing. */
2000 /* *** UNIMPLEMENTED *** */
2002 /* Now that we have some state, we can read the directory. */
2004 entry = (struct dirent *)NULL;
2005 while (directory && (entry = readdir (directory)))
2007 /* Special case for no filename. If the user has disabled the
2008 `match-hidden-files' variable, skip filenames beginning with `.'.
2009 All other entries except "." and ".." match. */
2010 if (filename_len == 0)
2012 if (_rl_match_hidden_files == 0 && HIDDEN_FILE (entry->d_name))
2015 if (entry->d_name[0] != '.' ||
2016 (entry->d_name[1] &&
2017 (entry->d_name[1] != '.' || entry->d_name[2])))
2022 /* Otherwise, if these match up to the length of filename, then
2024 if (_rl_completion_case_fold)
2026 if ((_rl_to_lower (entry->d_name[0]) == _rl_to_lower (filename[0])) &&
2027 (((int)D_NAMLEN (entry)) >= filename_len) &&
2028 (_rl_strnicmp (filename, entry->d_name, filename_len) == 0))
2033 if ((entry->d_name[0] == filename[0]) &&
2034 (((int)D_NAMLEN (entry)) >= filename_len) &&
2035 (strncmp (filename, entry->d_name, filename_len) == 0))
2045 closedir (directory);
2046 directory = (DIR *)NULL;
2051 dirname = (char *)NULL;
2056 filename = (char *)NULL;
2060 free (users_dirname);
2061 users_dirname = (char *)NULL;
2064 return (char *)NULL;
2068 /* dirname && (strcmp (dirname, ".") != 0) */
2069 if (dirname && (dirname[0] != '.' || dirname[1]))
2071 if (rl_complete_with_tilde_expansion && *users_dirname == '~')
2073 dirlen = strlen (dirname);
2074 temp = (char *)xmalloc (2 + dirlen + D_NAMLEN (entry));
2075 strcpy (temp, dirname);
2076 /* Canonicalization cuts off any final slash present. We
2077 may need to add it back. */
2078 if (dirname[dirlen - 1] != '/')
2080 temp[dirlen++] = '/';
2081 temp[dirlen] = '\0';
2086 dirlen = strlen (users_dirname);
2087 temp = (char *)xmalloc (2 + dirlen + D_NAMLEN (entry));
2088 strcpy (temp, users_dirname);
2089 /* Make sure that temp has a trailing slash here. */
2090 if (users_dirname[dirlen - 1] != '/')
2091 temp[dirlen++] = '/';
2094 strcpy (temp + dirlen, entry->d_name);
2097 temp = savestring (entry->d_name);
2103 /* An initial implementation of a menu completion function a la tcsh. The
2104 first time (if the last readline command was not rl_menu_complete), we
2105 generate the list of matches. This code is very similar to the code in
2106 rl_complete_internal -- there should be a way to combine the two. Then,
2107 for each item in the list of matches, we insert the match in an undoable
2108 fashion, with the appropriate character appended (this happens on the
2109 second and subsequent consecutive calls to rl_menu_complete). When we
2110 hit the end of the match list, we restore the original unmatched text,
2111 ring the bell, and reset the counter to zero. */
2113 rl_menu_complete (count, ignore)
2116 rl_compentry_func_t *our_func;
2117 int matching_filenames, found_quote;
2119 static char *orig_text;
2120 static char **matches = (char **)0;
2121 static int match_list_index = 0;
2122 static int match_list_size = 0;
2123 static int orig_start, orig_end;
2124 static char quote_char;
2125 static int delimiter;
2127 /* The first time through, we generate the list of matches and set things
2128 up to insert them. */
2129 if (rl_last_func != rl_menu_complete)
2131 /* Clean up from previous call, if any. */
2134 _rl_free_match_list (matches);
2136 match_list_index = match_list_size = 0;
2137 matches = (char **)NULL;
2139 /* Only the completion entry function can change these. */
2140 set_completion_defaults ('%');
2142 our_func = rl_completion_entry_function
2143 ? rl_completion_entry_function
2144 : rl_filename_completion_function;
2146 /* We now look backwards for the start of a filename/variable word. */
2147 orig_end = rl_point;
2148 found_quote = delimiter = 0;
2152 /* This (possibly) changes rl_point. If it returns a non-zero char,
2153 we know we have an open quote. */
2154 quote_char = _rl_find_completion_word (&found_quote, &delimiter);
2156 orig_start = rl_point;
2157 rl_point = orig_end;
2159 orig_text = rl_copy_text (orig_start, orig_end);
2160 matches = gen_completion_matches (orig_text, orig_start, orig_end,
2161 our_func, found_quote, quote_char);
2163 /* If we are matching filenames, the attempted completion function will
2164 have set rl_filename_completion_desired to a non-zero value. The basic
2165 rl_filename_completion_function does this. */
2166 matching_filenames = rl_filename_completion_desired;
2168 if (matches == 0 || postprocess_matches (&matches, matching_filenames) == 0)
2172 matches = (char **)0;
2174 orig_text = (char *)0;
2175 completion_changed_buffer = 0;
2179 for (match_list_size = 0; matches[match_list_size]; match_list_size++)
2181 /* matches[0] is lcd if match_list_size > 1, but the circular buffer
2182 code below should take care of it. */
2185 /* Now we have the list of matches. Replace the text between
2186 rl_line_buffer[orig_start] and rl_line_buffer[rl_point] with
2187 matches[match_list_index], and add any necessary closing char. */
2189 if (matches == 0 || match_list_size == 0)
2193 matches = (char **)0;
2194 completion_changed_buffer = 0;
2198 match_list_index += count;
2199 if (match_list_index < 0)
2200 match_list_index += match_list_size;
2202 match_list_index %= match_list_size;
2204 if (match_list_index == 0 && match_list_size > 1)
2207 insert_match (orig_text, orig_start, MULT_MATCH, "e_char);
2211 insert_match (matches[match_list_index], orig_start, SINGLE_MATCH, "e_char);
2212 append_to_match (matches[match_list_index], delimiter, quote_char,
2213 strcmp (orig_text, matches[match_list_index]));
2216 completion_changed_buffer = 1;