3 /* complete.c -- filename completion for readline. */
5 /* Copyright (C) 1987-2004 Free Software Foundation, Inc.
7 This file is part of the GNU Readline Library, a library for
8 reading lines of text with interactive input and history editing.
10 The GNU Readline Library is free software; you can redistribute it
11 and/or modify it under the terms of the GNU General Public License
12 as published by the Free Software Foundation; either version 2, or
13 (at your option) any later version.
15 The GNU Readline Library is distributed in the hope that it will be
16 useful, but WITHOUT ANY WARRANTY; without even the implied warranty
17 of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 The GNU General Public License is often shipped with GNU software, and
21 is generally kept in a file called COPYING or LICENSE. If you do not
22 have a copy of the license, write to the Free Software Foundation,
23 59 Temple Place, Suite 330, Boston, MA 02111 USA. */
24 #define READLINE_LIBRARY
26 #if defined (HAVE_CONFIG_H)
30 #include <sys/types.h>
32 #if defined (HAVE_SYS_FILE_H)
33 # include <sys/file.h>
36 #if defined (HAVE_UNISTD_H)
38 #endif /* HAVE_UNISTD_H */
40 #if defined (HAVE_STDLIB_H)
43 # include "ansi_stdlib.h"
44 #endif /* HAVE_STDLIB_H */
56 #include "posixstat.h"
58 /* System-specific feature definitions and include files. */
62 /* Some standard library routines. */
65 #include "rlprivate.h"
68 typedef int QSFUNC (const void *, const void *);
70 typedef int QSFUNC ();
79 /* Unix version of a hidden file. Could be different on other systems. */
80 #define HIDDEN_FILE(fname) ((fname)[0] == '.')
82 /* Most systems don't declare getpwent in <pwd.h> if _POSIX_SOURCE is
84 #if !defined (HAVE_GETPW_DECLS) || defined (_POSIX_SOURCE)
85 extern struct passwd *getpwent PARAMS((void));
86 #endif /* !HAVE_GETPW_DECLS || _POSIX_SOURCE */
88 /* If non-zero, then this is the address of a function to call when
89 completing a word would normally display the list of possible matches.
90 This function is called instead of actually doing the display.
91 It takes three arguments: (char **matches, int num_matches, int max_length)
92 where MATCHES is the array of strings that matched, NUM_MATCHES is the
93 number of strings in that array, and MAX_LENGTH is the length of the
94 longest string in that array. */
95 rl_compdisp_func_t *rl_completion_display_matches_hook = (rl_compdisp_func_t *)NULL;
97 #if defined (VISIBLE_STATS)
101 static int stat_char PARAMS((char *));
104 static int path_isdir PARAMS((const char *));
106 static char *rl_quote_filename PARAMS((char *, int, char *));
108 static void set_completion_defaults PARAMS((int));
109 static int get_y_or_n PARAMS((int));
110 static int _rl_internal_pager PARAMS((int));
111 static char *printable_part PARAMS((char *));
112 static int fnwidth PARAMS((const char *));
113 static int fnprint PARAMS((const char *));
114 static int print_filename PARAMS((char *, char *));
116 static char **gen_completion_matches PARAMS((char *, int, int, rl_compentry_func_t *, int, int));
118 static char **remove_duplicate_matches PARAMS((char **));
119 static void insert_match PARAMS((char *, int, int, char *));
120 static int append_to_match PARAMS((char *, int, int, int));
121 static void insert_all_matches PARAMS((char **, int, char *));
122 static void display_matches PARAMS((char **));
123 static int compute_lcd_of_matches PARAMS((char **, int, const char *));
124 static int postprocess_matches PARAMS((char ***, int));
126 static char *make_quoted_replacement PARAMS((char *, int, char *));
128 /* **************************************************************** */
130 /* Completion matching, from readline's point of view. */
132 /* **************************************************************** */
134 /* Variables known only to the readline library. */
136 /* If non-zero, non-unique completions always show the list of matches. */
137 int _rl_complete_show_all = 0;
139 /* If non-zero, non-unique completions show the list of matches, unless it
140 is not possible to do partial completion and modify the line. */
141 int _rl_complete_show_unmodified = 0;
143 /* If non-zero, completed directory names have a slash appended. */
144 int _rl_complete_mark_directories = 1;
146 /* If non-zero, the symlinked directory completion behavior introduced in
147 readline-4.2a is disabled, and symlinks that point to directories have
148 a slash appended (subject to the value of _rl_complete_mark_directories).
149 This is user-settable via the mark-symlinked-directories variable. */
150 int _rl_complete_mark_symlink_dirs = 0;
152 /* If non-zero, completions are printed horizontally in alphabetical order,
154 int _rl_print_completions_horizontally;
156 /* Non-zero means that case is not significant in filename completion. */
157 #if defined (__MSDOS__) && !defined (__DJGPP__)
158 int _rl_completion_case_fold = 1;
160 int _rl_completion_case_fold;
163 /* If non-zero, don't match hidden files (filenames beginning with a `.' on
164 Unix) when doing filename completion. */
165 int _rl_match_hidden_files = 1;
167 /* Global variables available to applications using readline. */
169 #if defined (VISIBLE_STATS)
170 /* Non-zero means add an additional character to each filename displayed
171 during listing completion iff rl_filename_completion_desired which helps
172 to indicate the type of file being listed. */
173 int rl_visible_stats = 0;
174 #endif /* VISIBLE_STATS */
176 /* If non-zero, then this is the address of a function to call when
177 completing on a directory name. The function is called with
178 the address of a string (the current directory name) as an arg. */
179 rl_icppfunc_t *rl_directory_completion_hook = (rl_icppfunc_t *)NULL;
181 rl_icppfunc_t *rl_directory_rewrite_hook = (rl_icppfunc_t *)NULL;
183 /* Non-zero means readline completion functions perform tilde expansion. */
184 int rl_complete_with_tilde_expansion = 0;
186 /* Pointer to the generator function for completion_matches ().
187 NULL means to use rl_filename_completion_function (), the default filename
189 rl_compentry_func_t *rl_completion_entry_function = (rl_compentry_func_t *)NULL;
191 /* Pointer to alternative function to create matches.
192 Function is called with TEXT, START, and END.
193 START and END are indices in RL_LINE_BUFFER saying what the boundaries
195 If this function exists and returns NULL then call the value of
196 rl_completion_entry_function to try to match, otherwise use the
197 array of strings returned. */
198 rl_completion_func_t *rl_attempted_completion_function = (rl_completion_func_t *)NULL;
200 /* Non-zero means to suppress normal filename completion after the
201 user-specified completion function has been called. */
202 int rl_attempted_completion_over = 0;
204 /* Set to a character indicating the type of completion being performed
205 by rl_complete_internal, available for use by application completion
207 int rl_completion_type = 0;
209 /* Up to this many items will be displayed in response to a
210 possible-completions call. After that, we ask the user if
211 she is sure she wants to see them all. */
212 int rl_completion_query_items = 100;
214 int _rl_page_completions = 1;
216 /* The basic list of characters that signal a break between words for the
217 completer routine. The contents of this variable is what breaks words
218 in the shell, i.e. " \t\n\"\\'`@$><=" */
219 const char *rl_basic_word_break_characters = " \t\n\"\\'`@$><=;|&{("; /* }) */
221 /* List of basic quoting characters. */
222 const char *rl_basic_quote_characters = "\"'";
224 /* The list of characters that signal a break between words for
225 rl_complete_internal. The default list is the contents of
226 rl_basic_word_break_characters. */
227 /*const*/ char *rl_completer_word_break_characters = (/*const*/ char *)NULL;
229 /* Hook function to allow an application to set the completion word
230 break characters before readline breaks up the line. Allows
231 position-dependent word break characters. */
232 rl_cpvfunc_t *rl_completion_word_break_hook = (rl_cpvfunc_t *)NULL;
234 /* List of characters which can be used to quote a substring of the line.
235 Completion occurs on the entire substring, and within the substring
236 rl_completer_word_break_characters are treated as any other character,
237 unless they also appear within this list. */
238 const char *rl_completer_quote_characters = (const char *)NULL;
240 /* List of characters that should be quoted in filenames by the completer. */
241 const char *rl_filename_quote_characters = (const char *)NULL;
243 /* List of characters that are word break characters, but should be left
244 in TEXT when it is passed to the completion function. The shell uses
245 this to help determine what kind of completing to do. */
246 const char *rl_special_prefixes = (const char *)NULL;
248 /* If non-zero, then disallow duplicates in the matches. */
249 int rl_ignore_completion_duplicates = 1;
251 /* Non-zero means that the results of the matches are to be treated
252 as filenames. This is ALWAYS zero on entry, and can only be changed
253 within a completion entry finder function. */
254 int rl_filename_completion_desired = 0;
256 /* Non-zero means that the results of the matches are to be quoted using
257 double quotes (or an application-specific quoting mechanism) if the
258 filename contains any characters in rl_filename_quote_chars. This is
259 ALWAYS non-zero on entry, and can only be changed within a completion
260 entry finder function. */
261 int rl_filename_quoting_desired = 1;
263 /* This function, if defined, is called by the completer when real
264 filename completion is done, after all the matching names have been
265 generated. It is passed a (char**) known as matches in the code below.
266 It consists of a NULL-terminated array of pointers to potential
267 matching strings. The 1st element (matches[0]) is the maximal
268 substring that is common to all matches. This function can re-arrange
269 the list of matches as required, but all elements of the array must be
270 free()'d if they are deleted. The main intent of this function is
271 to implement FIGNORE a la SunOS csh. */
272 rl_compignore_func_t *rl_ignore_some_completions_function = (rl_compignore_func_t *)NULL;
274 /* Set to a function to quote a filename in an application-specific fashion.
275 Called with the text to quote, the type of match found (single or multiple)
276 and a pointer to the quoting character to be used, which the function can
278 rl_quote_func_t *rl_filename_quoting_function = rl_quote_filename;
280 /* Function to call to remove quoting characters from a filename. Called
281 before completion is attempted, so the embedded quotes do not interfere
282 with matching names in the file system. Readline doesn't do anything
283 with this; it's set only by applications. */
284 rl_dequote_func_t *rl_filename_dequoting_function = (rl_dequote_func_t *)NULL;
286 /* Function to call to decide whether or not a word break character is
287 quoted. If a character is quoted, it does not break words for the
289 rl_linebuf_func_t *rl_char_is_quoted_p = (rl_linebuf_func_t *)NULL;
291 /* If non-zero, the completion functions don't append anything except a
292 possible closing quote. This is set to 0 by rl_complete_internal and
293 may be changed by an application-specific completion function. */
294 int rl_completion_suppress_append = 0;
296 /* Character appended to completed words when at the end of the line. The
297 default is a space. */
298 int rl_completion_append_character = ' ';
300 /* If non-zero, the completion functions don't append any closing quote.
301 This is set to 0 by rl_complete_internal and may be changed by an
302 application-specific completion function. */
303 int rl_completion_suppress_quote = 0;
305 /* Set to any quote character readline thinks it finds before any application
306 completion function is called. */
307 int rl_completion_quote_character;
309 /* Set to a non-zero value if readline found quoting anywhere in the word to
310 be completed; set before any application completion function is called. */
311 int rl_completion_found_quote;
313 /* If non-zero, a slash will be appended to completed filenames that are
314 symbolic links to directory names, subject to the value of the
315 mark-directories variable (which is user-settable). This exists so
316 that application completion functions can override the user's preference
317 (set via the mark-symlinked-directories variable) if appropriate.
318 It's set to the value of _rl_complete_mark_symlink_dirs in
319 rl_complete_internal before any application-specific completion
320 function is called, so without that function doing anything, the user's
321 preferences are honored. */
322 int rl_completion_mark_symlink_dirs;
324 /* If non-zero, inhibit completion (temporarily). */
325 int rl_inhibit_completion;
327 /* Variables local to this file. */
329 /* Local variable states what happened during the last completion attempt. */
330 static int completion_changed_buffer;
332 /*************************************/
334 /* Bindable completion functions */
336 /*************************************/
338 /* Complete the word at or before point. You have supplied the function
339 that does the initial simple matching selection algorithm (see
340 rl_completion_matches ()). The default is to do filename completion. */
342 rl_complete (ignore, invoking_key)
343 int ignore, invoking_key;
345 if (rl_inhibit_completion)
346 return (_rl_insert_char (ignore, invoking_key));
347 else if (rl_last_func == rl_complete && !completion_changed_buffer)
348 return (rl_complete_internal ('?'));
349 else if (_rl_complete_show_all)
350 return (rl_complete_internal ('!'));
351 else if (_rl_complete_show_unmodified)
352 return (rl_complete_internal ('@'));
354 return (rl_complete_internal (TAB));
357 /* List the possible completions. See description of rl_complete (). */
359 rl_possible_completions (ignore, invoking_key)
360 int ignore, invoking_key;
362 return (rl_complete_internal ('?'));
366 rl_insert_completions (ignore, invoking_key)
367 int ignore, invoking_key;
369 return (rl_complete_internal ('*'));
372 /* Return the correct value to pass to rl_complete_internal performing
373 the same tests as rl_complete. This allows consecutive calls to an
374 application's completion function to list possible completions and for
375 an application-specific completion function to honor the
376 show-all-if-ambiguous readline variable. */
378 rl_completion_mode (cfunc)
379 rl_command_func_t *cfunc;
381 if (rl_last_func == cfunc && !completion_changed_buffer)
383 else if (_rl_complete_show_all)
385 else if (_rl_complete_show_unmodified)
391 /************************************/
393 /* Completion utility functions */
395 /************************************/
397 /* Set default values for readline word completion. These are the variables
398 that application completion functions can change or inspect. */
400 set_completion_defaults (what_to_do)
403 /* Only the completion entry function can change these. */
404 rl_filename_completion_desired = 0;
405 rl_filename_quoting_desired = 1;
406 rl_completion_type = what_to_do;
407 rl_completion_suppress_append = rl_completion_suppress_quote = 0;
409 /* The completion entry function may optionally change this. */
410 rl_completion_mark_symlink_dirs = _rl_complete_mark_symlink_dirs;
413 /* The user must press "y" or "n". Non-zero return means "y" pressed. */
415 get_y_or_n (for_pager)
422 RL_SETSTATE(RL_STATE_MOREINPUT);
424 RL_UNSETSTATE(RL_STATE_MOREINPUT);
426 if (c == 'y' || c == 'Y' || c == ' ')
428 if (c == 'n' || c == 'N' || c == RUBOUT)
431 _rl_abort_internal ();
432 if (for_pager && (c == NEWLINE || c == RETURN))
434 if (for_pager && (c == 'q' || c == 'Q'))
441 _rl_internal_pager (lines)
446 fprintf (rl_outstream, "--More--");
447 fflush (rl_outstream);
449 _rl_erase_entire_line ();
459 path_isdir (filename)
460 const char *filename;
464 return (stat (filename, &finfo) == 0 && S_ISDIR (finfo.st_mode));
467 #if defined (VISIBLE_STATS)
468 /* Return the character which best describes FILENAME.
469 `@' for symbolic links
474 `%' for character special devices
475 `#' for block special devices */
483 #if defined (HAVE_LSTAT) && defined (S_ISLNK)
484 r = lstat (filename, &finfo);
486 r = stat (filename, &finfo);
493 if (S_ISDIR (finfo.st_mode))
495 #if defined (S_ISCHR)
496 else if (S_ISCHR (finfo.st_mode))
499 #if defined (S_ISBLK)
500 else if (S_ISBLK (finfo.st_mode))
503 #if defined (S_ISLNK)
504 else if (S_ISLNK (finfo.st_mode))
507 #if defined (S_ISSOCK)
508 else if (S_ISSOCK (finfo.st_mode))
510 #endif /* S_ISSOCK */
511 #if defined (S_ISFIFO)
512 else if (S_ISFIFO (finfo.st_mode))
515 else if (S_ISREG (finfo.st_mode))
517 if (access (filename, X_OK) == 0)
522 #endif /* VISIBLE_STATS */
524 /* Return the portion of PATHNAME that should be output when listing
525 possible completions. If we are hacking filename completion, we
526 are only interested in the basename, the portion following the
527 final slash. Otherwise, we return what we were passed. Since
528 printing empty strings is not very informative, if we're doing
529 filename completion, and the basename is the empty string, we look
530 for the previous slash and return the portion following that. If
531 there's no previous slash, we just return what we were passed. */
533 printable_part (pathname)
538 if (rl_filename_completion_desired == 0) /* don't need to do anything */
541 temp = strrchr (pathname, '/');
542 #if defined (__MSDOS__)
543 if (temp == 0 && ISALPHA ((unsigned char)pathname[0]) && pathname[1] == ':')
547 if (temp == 0 || *temp == '\0')
549 /* If the basename is NULL, we might have a pathname like '/usr/src/'.
550 Look for a previous slash and, if one is found, return the portion
551 following that slash. If there's no previous slash, just return the
552 pathname we were passed. */
553 else if (temp[1] == '\0')
555 for (x = temp - 1; x > pathname; x--)
558 return ((*x == '/') ? x + 1 : pathname);
564 /* Compute width of STRING when displayed on screen by print_filename */
570 #if defined (HANDLE_MULTIBYTE)
576 left = strlen (string) + 1;
577 memset (&ps, 0, sizeof (mbstate_t));
583 if (CTRL_CHAR (*string) || *string == RUBOUT)
590 #if defined (HANDLE_MULTIBYTE)
591 clen = mbrtowc (&wc, string + pos, left - pos, &ps);
592 if (MB_INVALIDCH (clen))
596 memset (&ps, 0, sizeof (mbstate_t));
598 else if (MB_NULLWCH (clen))
604 width += (w >= 0) ? w : 1;
618 const char *to_print;
622 #if defined (HANDLE_MULTIBYTE)
627 end = to_print + strlen (to_print) + 1;
628 memset (&ps, 0, sizeof (mbstate_t));
637 putc ('^', rl_outstream);
638 putc (UNCTRL (*s), rl_outstream);
641 #if defined (HANDLE_MULTIBYTE)
642 memset (&ps, 0, sizeof (mbstate_t));
645 else if (*s == RUBOUT)
647 putc ('^', rl_outstream);
648 putc ('?', rl_outstream);
651 #if defined (HANDLE_MULTIBYTE)
652 memset (&ps, 0, sizeof (mbstate_t));
657 #if defined (HANDLE_MULTIBYTE)
658 tlen = mbrlen (s, end - s, &ps);
659 if (MB_INVALIDCH (tlen))
662 memset (&ps, 0, sizeof (mbstate_t));
664 else if (MB_NULLWCH (tlen))
666 fwrite (s, 1, tlen, rl_outstream);
669 putc (*s, rl_outstream);
679 /* Output TO_PRINT to rl_outstream. If VISIBLE_STATS is defined and we
680 are using it, check for and output a single character for `special'
681 filenames. Return the number of characters we output. */
684 print_filename (to_print, full_pathname)
685 char *to_print, *full_pathname;
687 int printed_len, extension_char, slen, tlen;
688 char *s, c, *new_full_pathname;
691 printed_len = fnprint (to_print);
693 #if defined (VISIBLE_STATS)
694 if (rl_filename_completion_desired && (rl_visible_stats || _rl_complete_mark_directories))
696 if (rl_filename_completion_desired && _rl_complete_mark_directories)
699 /* If to_print != full_pathname, to_print is the basename of the
700 path passed. In this case, we try to expand the directory
701 name before checking for the stat character. */
702 if (to_print != full_pathname)
704 /* Terminate the directory name. */
708 /* If setting the last slash in full_pathname to a NUL results in
709 full_pathname being the empty string, we are trying to complete
710 files in the root directory. If we pass a null string to the
711 bash directory completion hook, for example, it will expand it
712 to the current directory. We just want the `/'. */
713 s = tilde_expand (full_pathname && *full_pathname ? full_pathname : "/");
714 if (rl_directory_completion_hook)
715 (*rl_directory_completion_hook) (&s);
718 tlen = strlen (to_print);
719 new_full_pathname = (char *)xmalloc (slen + tlen + 2);
720 strcpy (new_full_pathname, s);
721 new_full_pathname[slen] = '/';
722 strcpy (new_full_pathname + slen + 1, to_print);
724 #if defined (VISIBLE_STATS)
725 if (rl_visible_stats)
726 extension_char = stat_char (new_full_pathname);
729 if (path_isdir (new_full_pathname))
730 extension_char = '/';
732 free (new_full_pathname);
737 s = tilde_expand (full_pathname);
738 #if defined (VISIBLE_STATS)
739 if (rl_visible_stats)
740 extension_char = stat_char (s);
744 extension_char = '/';
750 putc (extension_char, rl_outstream);
759 rl_quote_filename (s, rtype, qcp)
766 r = (char *)xmalloc (strlen (s) + 2);
767 *r = *rl_completer_quote_characters;
770 *qcp = *rl_completer_quote_characters;
774 /* Find the bounds of the current word for completion purposes, and leave
775 rl_point set to the end of the word. This function skips quoted
776 substrings (characters between matched pairs of characters in
777 rl_completer_quote_characters). First we try to find an unclosed
778 quoted substring on which to do matching. If one is not found, we use
779 the word break characters to find the boundaries of the current word.
780 We call an application-specific function to decide whether or not a
781 particular word break character is quoted; if that function returns a
782 non-zero result, the character does not break a word. This function
783 returns the opening quote character if we found an unclosed quoted
784 substring, '\0' otherwise. FP, if non-null, is set to a value saying
785 which (shell-like) quote characters we found (single quote, double
786 quote, or backslash) anywhere in the string. DP, if non-null, is set to
787 the value of the delimiter character that caused a word break. */
790 _rl_find_completion_word (fp, dp)
793 int scan, end, found_quote, delimiter, pass_next, isbrk;
794 char quote_char, *brkchars;
797 found_quote = delimiter = 0;
801 if (rl_completion_word_break_hook)
802 brkchars = (*rl_completion_word_break_hook) ();
804 brkchars = rl_completer_word_break_characters;
806 if (rl_completer_quote_characters)
808 /* We have a list of characters which can be used in pairs to
809 quote substrings for the completer. Try to find the start
810 of an unclosed quoted substring. */
811 /* FOUND_QUOTE is set so we know what kind of quotes we found. */
812 #if defined (HANDLE_MULTIBYTE)
813 for (scan = pass_next = 0; scan < end;
814 scan = ((MB_CUR_MAX == 1 || rl_byte_oriented)
816 : _rl_find_next_mbchar (rl_line_buffer, scan, 1, MB_FIND_ANY)))
818 for (scan = pass_next = 0; scan < end; scan++)
827 /* Shell-like semantics for single quotes -- don't allow backslash
828 to quote anything in single quotes, especially not the closing
829 quote. If you don't like this, take out the check on the value
831 if (quote_char != '\'' && rl_line_buffer[scan] == '\\')
834 found_quote |= RL_QF_BACKSLASH;
838 if (quote_char != '\0')
840 /* Ignore everything until the matching close quote char. */
841 if (rl_line_buffer[scan] == quote_char)
843 /* Found matching close. Abandon this substring. */
848 else if (strchr (rl_completer_quote_characters, rl_line_buffer[scan]))
850 /* Found start of a quoted substring. */
851 quote_char = rl_line_buffer[scan];
853 /* Shell-like quoting conventions. */
854 if (quote_char == '\'')
855 found_quote |= RL_QF_SINGLE_QUOTE;
856 else if (quote_char == '"')
857 found_quote |= RL_QF_DOUBLE_QUOTE;
859 found_quote |= RL_QF_OTHER_QUOTE;
864 if (rl_point == end && quote_char == '\0')
866 /* We didn't find an unclosed quoted substring upon which to do
867 completion, so use the word break characters to find the
868 substring on which to complete. */
869 #if defined (HANDLE_MULTIBYTE)
870 while (rl_point = _rl_find_prev_mbchar (rl_line_buffer, rl_point, MB_FIND_ANY))
875 scan = rl_line_buffer[rl_point];
877 if (strchr (brkchars, scan) == 0)
880 /* Call the application-specific function to tell us whether
881 this word break character is quoted and should be skipped. */
882 if (rl_char_is_quoted_p && found_quote &&
883 (*rl_char_is_quoted_p) (rl_line_buffer, rl_point))
886 /* Convoluted code, but it avoids an n^2 algorithm with calls
887 to char_is_quoted. */
892 /* If we are at an unquoted word break, then advance past it. */
893 scan = rl_line_buffer[rl_point];
895 /* If there is an application-specific function to say whether or not
896 a character is quoted and we found a quote character, let that
897 function decide whether or not a character is a word break, even
898 if it is found in rl_completer_word_break_characters. Don't bother
899 if we're at the end of the line, though. */
902 if (rl_char_is_quoted_p)
903 isbrk = (found_quote == 0 ||
904 (*rl_char_is_quoted_p) (rl_line_buffer, rl_point) == 0) &&
905 strchr (brkchars, scan) != 0;
907 isbrk = strchr (brkchars, scan) != 0;
911 /* If the character that caused the word break was a quoting
912 character, then remember it as the delimiter. */
913 if (rl_basic_quote_characters &&
914 strchr (rl_basic_quote_characters, scan) &&
915 (end - rl_point) > 1)
918 /* If the character isn't needed to determine something special
919 about what kind of completion to perform, then advance past it. */
920 if (rl_special_prefixes == 0 || strchr (rl_special_prefixes, scan) == 0)
934 gen_completion_matches (text, start, end, our_func, found_quote, quote_char)
937 rl_compentry_func_t *our_func;
938 int found_quote, quote_char;
940 char **matches, *temp;
942 rl_completion_found_quote = found_quote;
943 rl_completion_quote_character = quote_char;
945 /* If the user wants to TRY to complete, but then wants to give
946 up and use the default completion function, they set the
947 variable rl_attempted_completion_function. */
948 if (rl_attempted_completion_function)
950 matches = (*rl_attempted_completion_function) (text, start, end);
952 if (matches || rl_attempted_completion_over)
954 rl_attempted_completion_over = 0;
959 /* Beware -- we're stripping the quotes here. Do this only if we know
960 we are doing filename completion and the application has defined a
961 filename dequoting function. */
964 if (found_quote && our_func == rl_filename_completion_function &&
965 rl_filename_dequoting_function)
967 /* delete single and double quotes */
968 temp = (*rl_filename_dequoting_function) (text, quote_char);
969 text = temp; /* not freeing text is not a memory leak */
972 matches = rl_completion_matches (text, our_func);
977 /* Filter out duplicates in MATCHES. This frees up the strings in
980 remove_duplicate_matches (matches)
988 /* Sort the items. */
989 for (i = 0; matches[i]; i++)
992 /* Sort the array without matches[0], since we need it to
993 stay in place no matter what. */
995 qsort (matches+1, i-1, sizeof (char *), (QSFUNC *)_rl_qsort_string_compare);
997 /* Remember the lowest common denominator for it may be unique. */
998 lowest_common = savestring (matches[0]);
1000 for (i = newlen = 0; matches[i + 1]; i++)
1002 if (strcmp (matches[i], matches[i + 1]) == 0)
1005 matches[i] = (char *)&dead_slot;
1011 /* We have marked all the dead slots with (char *)&dead_slot.
1012 Copy all the non-dead entries into a new array. */
1013 temp_array = (char **)xmalloc ((3 + newlen) * sizeof (char *));
1014 for (i = j = 1; matches[i]; i++)
1016 if (matches[i] != (char *)&dead_slot)
1017 temp_array[j++] = matches[i];
1019 temp_array[j] = (char *)NULL;
1021 if (matches[0] != (char *)&dead_slot)
1024 /* Place the lowest common denominator back in [0]. */
1025 temp_array[0] = lowest_common;
1027 /* If there is one string left, and it is identical to the
1028 lowest common denominator, then the LCD is the string to
1030 if (j == 2 && strcmp (temp_array[0], temp_array[1]) == 0)
1032 free (temp_array[1]);
1033 temp_array[1] = (char *)NULL;
1035 return (temp_array);
1038 /* Find the common prefix of the list of matches, and put it into
1041 compute_lcd_of_matches (match_list, matches, text)
1046 register int i, c1, c2, si;
1047 int low; /* Count of max-matched characters. */
1048 char *dtext; /* dequoted TEXT, if needed */
1049 #if defined (HANDLE_MULTIBYTE)
1055 /* If only one match, just use that. Otherwise, compare each
1056 member of the list with the next, finding out where they
1060 match_list[0] = match_list[1];
1061 match_list[1] = (char *)NULL;
1065 for (i = 1, low = 100000; i < matches; i++)
1067 #if defined (HANDLE_MULTIBYTE)
1068 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1070 memset (&ps1, 0, sizeof (mbstate_t));
1071 memset (&ps2, 0, sizeof (mbstate_t));
1074 if (_rl_completion_case_fold)
1077 (c1 = _rl_to_lower(match_list[i][si])) &&
1078 (c2 = _rl_to_lower(match_list[i + 1][si]));
1080 #if defined (HANDLE_MULTIBYTE)
1081 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1083 v = mbrtowc (&wc1, match_list[i]+si, strlen (match_list[i]+si), &ps1);
1084 mbrtowc (&wc2, match_list[i+1]+si, strlen (match_list[i+1]+si), &ps2);
1085 wc1 = towlower (wc1);
1086 wc2 = towlower (wc2);
1100 (c1 = match_list[i][si]) &&
1101 (c2 = match_list[i + 1][si]);
1103 #if defined (HANDLE_MULTIBYTE)
1104 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1106 mbstate_t ps_back = ps1;
1107 if (!_rl_compare_chars (match_list[i], si, &ps1, match_list[i+1], si, &ps2))
1109 else if ((v = _rl_get_char_len (&match_list[i][si], &ps_back)) > 1)
1122 /* If there were multiple matches, but none matched up to even the
1123 first character, and the user typed something, use that as the
1124 value of matches[0]. */
1125 if (low == 0 && text && *text)
1127 match_list[0] = (char *)xmalloc (strlen (text) + 1);
1128 strcpy (match_list[0], text);
1132 match_list[0] = (char *)xmalloc (low + 1);
1134 /* XXX - this might need changes in the presence of multibyte chars */
1136 /* If we are ignoring case, try to preserve the case of the string
1137 the user typed in the face of multiple matches differing in case. */
1138 if (_rl_completion_case_fold)
1140 /* We're making an assumption here:
1141 IF we're completing filenames AND
1142 the application has defined a filename dequoting function AND
1143 we found a quote character AND
1144 the application has requested filename quoting
1146 we assume that TEXT was dequoted before checking against
1147 the file system and needs to be dequoted here before we
1148 check against the list of matches
1150 dtext = (char *)NULL;
1151 if (rl_filename_completion_desired &&
1152 rl_filename_dequoting_function &&
1153 rl_completion_found_quote &&
1154 rl_filename_quoting_desired)
1156 dtext = (*rl_filename_dequoting_function) (text, rl_completion_quote_character);
1160 /* sort the list to get consistent answers. */
1161 qsort (match_list+1, matches, sizeof(char *), (QSFUNC *)_rl_qsort_string_compare);
1166 for (i = 1; i <= matches; i++)
1167 if (strncmp (match_list[i], text, si) == 0)
1169 strncpy (match_list[0], match_list[i], low);
1172 /* no casematch, use first entry */
1174 strncpy (match_list[0], match_list[1], low);
1177 /* otherwise, just use the text the user typed. */
1178 strncpy (match_list[0], text, low);
1183 strncpy (match_list[0], match_list[1], low);
1185 match_list[0][low] = '\0';
1192 postprocess_matches (matchesp, matching_filenames)
1194 int matching_filenames;
1196 char *t, **matches, **temp_matches;
1199 matches = *matchesp;
1204 /* It seems to me that in all the cases we handle we would like
1205 to ignore duplicate possiblilities. Scan for the text to
1206 insert being identical to the other completions. */
1207 if (rl_ignore_completion_duplicates)
1209 temp_matches = remove_duplicate_matches (matches);
1211 matches = temp_matches;
1214 /* If we are matching filenames, then here is our chance to
1215 do clever processing by re-examining the list. Call the
1216 ignore function with the array as a parameter. It can
1217 munge the array, deleting matches as it desires. */
1218 if (rl_ignore_some_completions_function && matching_filenames)
1220 for (nmatch = 1; matches[nmatch]; nmatch++)
1222 (void)(*rl_ignore_some_completions_function) (matches);
1223 if (matches == 0 || matches[0] == 0)
1226 *matchesp = (char **)0;
1231 /* If we removed some matches, recompute the common prefix. */
1232 for (i = 1; matches[i]; i++)
1234 if (i > 1 && i < nmatch)
1237 compute_lcd_of_matches (matches, i - 1, t);
1243 *matchesp = matches;
1247 /* A convenience function for displaying a list of strings in
1248 columnar format on readline's output stream. MATCHES is the list
1249 of strings, in argv format, LEN is the number of strings in MATCHES,
1250 and MAX is the length of the longest string in MATCHES. */
1252 rl_display_match_list (matches, len, max)
1256 int count, limit, printed_len, lines;
1260 /* How many items of MAX length can we fit in the screen window? */
1262 limit = _rl_screenwidth / max;
1263 if (limit != 1 && (limit * max == _rl_screenwidth))
1266 /* Avoid a possible floating exception. If max > _rl_screenwidth,
1267 limit will be 0 and a divide-by-zero fault will result. */
1271 /* How many iterations of the printing loop? */
1272 count = (len + (limit - 1)) / limit;
1274 /* Watch out for special case. If LEN is less than LIMIT, then
1275 just do the inner printing loop.
1276 0 < len <= limit implies count = 1. */
1278 /* Sort the items if they are not already sorted. */
1279 if (rl_ignore_completion_duplicates == 0)
1280 qsort (matches + 1, len, sizeof (char *), (QSFUNC *)_rl_qsort_string_compare);
1285 if (_rl_print_completions_horizontally == 0)
1287 /* Print the sorted items, up-and-down alphabetically, like ls. */
1288 for (i = 1; i <= count; i++)
1290 for (j = 0, l = i; j < limit; j++)
1292 if (l > len || matches[l] == 0)
1296 temp = printable_part (matches[l]);
1297 printed_len = print_filename (temp, matches[l]);
1300 for (k = 0; k < max - printed_len; k++)
1301 putc (' ', rl_outstream);
1307 if (_rl_page_completions && lines >= (_rl_screenheight - 1) && i < count)
1309 lines = _rl_internal_pager (lines);
1317 /* Print the sorted items, across alphabetically, like ls -x. */
1318 for (i = 1; matches[i]; i++)
1320 temp = printable_part (matches[i]);
1321 printed_len = print_filename (temp, matches[i]);
1322 /* Have we reached the end of this line? */
1325 if (i && (limit > 1) && (i % limit) == 0)
1329 if (_rl_page_completions && lines >= _rl_screenheight - 1)
1331 lines = _rl_internal_pager (lines);
1337 for (k = 0; k < max - printed_len; k++)
1338 putc (' ', rl_outstream);
1345 /* Display MATCHES, a list of matching filenames in argv format. This
1346 handles the simple case -- a single match -- first. If there is more
1347 than one match, we compute the number of strings in the list and the
1348 length of the longest string, which will be needed by the display
1349 function. If the application wants to handle displaying the list of
1350 matches itself, it sets RL_COMPLETION_DISPLAY_MATCHES_HOOK to the
1351 address of a function, and we just call it. If we're handling the
1352 display ourselves, we just call rl_display_match_list. We also check
1353 that the list of matches doesn't exceed the user-settable threshold,
1354 and ask the user if he wants to see the list if there are more matches
1355 than RL_COMPLETION_QUERY_ITEMS. */
1357 display_matches (matches)
1363 /* Move to the last visible line of a possibly-multiple-line command. */
1364 _rl_move_vert (_rl_vis_botlin);
1366 /* Handle simple case first. What if there is only one answer? */
1367 if (matches[1] == 0)
1369 temp = printable_part (matches[0]);
1371 print_filename (temp, matches[0]);
1374 rl_forced_update_display ();
1375 rl_display_fixed = 1;
1380 /* There is more than one answer. Find out how many there are,
1381 and find the maximum printed length of a single entry. */
1382 for (max = 0, i = 1; matches[i]; i++)
1384 temp = printable_part (matches[i]);
1385 len = fnwidth (temp);
1393 /* If the caller has defined a display hook, then call that now. */
1394 if (rl_completion_display_matches_hook)
1396 (*rl_completion_display_matches_hook) (matches, len, max);
1400 /* If there are many items, then ask the user if she really wants to
1402 if (len >= rl_completion_query_items)
1405 fprintf (rl_outstream, "Display all %d possibilities? (y or n)", len);
1406 fflush (rl_outstream);
1407 if (get_y_or_n (0) == 0)
1411 rl_forced_update_display ();
1412 rl_display_fixed = 1;
1418 rl_display_match_list (matches, len, max);
1420 rl_forced_update_display ();
1421 rl_display_fixed = 1;
1425 make_quoted_replacement (match, mtype, qc)
1428 char *qc; /* Pointer to quoting character, if any */
1430 int should_quote, do_replace;
1433 /* If we are doing completion on quoted substrings, and any matches
1434 contain any of the completer_word_break_characters, then auto-
1435 matically prepend the substring with a quote character (just pick
1436 the first one from the list of such) if it does not already begin
1437 with a quote string. FIXME: Need to remove any such automatically
1438 inserted quote character when it no longer is necessary, such as
1439 if we change the string we are completing on and the new set of
1440 matches don't require a quoted substring. */
1441 replacement = match;
1443 should_quote = match && rl_completer_quote_characters &&
1444 rl_filename_completion_desired &&
1445 rl_filename_quoting_desired;
1448 should_quote = should_quote && (!qc || !*qc ||
1449 (rl_completer_quote_characters && strchr (rl_completer_quote_characters, *qc)));
1453 /* If there is a single match, see if we need to quote it.
1454 This also checks whether the common prefix of several
1455 matches needs to be quoted. */
1456 should_quote = rl_filename_quote_characters
1457 ? (_rl_strpbrk (match, rl_filename_quote_characters) != 0)
1460 do_replace = should_quote ? mtype : NO_MATCH;
1461 /* Quote the replacement, since we found an embedded
1462 word break character in a potential match. */
1463 if (do_replace != NO_MATCH && rl_filename_quoting_function)
1464 replacement = (*rl_filename_quoting_function) (match, do_replace, qc);
1466 return (replacement);
1470 insert_match (match, start, mtype, qc)
1478 oqc = qc ? *qc : '\0';
1479 replacement = make_quoted_replacement (match, mtype, qc);
1481 /* Now insert the match. */
1484 /* Don't double an opening quote character. */
1485 if (qc && *qc && start && rl_line_buffer[start - 1] == *qc &&
1486 replacement[0] == *qc)
1488 /* If make_quoted_replacement changed the quoting character, remove
1489 the opening quote and insert the (fully-quoted) replacement. */
1490 else if (qc && (*qc != oqc) && start && rl_line_buffer[start - 1] == oqc &&
1491 replacement[0] != oqc)
1493 _rl_replace_text (replacement, start, rl_point - 1);
1494 if (replacement != match)
1499 /* Append any necessary closing quote and a separator character to the
1500 just-inserted match. If the user has specified that directories
1501 should be marked by a trailing `/', append one of those instead. The
1502 default trailing character is a space. Returns the number of characters
1503 appended. If NONTRIVIAL_MATCH is set, we test for a symlink (if the OS
1504 has them) and don't add a suffix for a symlink to a directory. A
1505 nontrivial match is one that actually adds to the word being completed.
1506 The variable rl_completion_mark_symlink_dirs controls this behavior
1507 (it's initially set to the what the user has chosen, indicated by the
1508 value of _rl_complete_mark_symlink_dirs, but may be modified by an
1509 application's completion function). */
1511 append_to_match (text, delimiter, quote_char, nontrivial_match)
1513 int delimiter, quote_char, nontrivial_match;
1515 char temp_string[4], *filename;
1516 int temp_string_index, s;
1519 temp_string_index = 0;
1520 if (quote_char && rl_point && rl_completion_suppress_quote == 0 &&
1521 rl_line_buffer[rl_point - 1] != quote_char)
1522 temp_string[temp_string_index++] = quote_char;
1525 temp_string[temp_string_index++] = delimiter;
1526 else if (rl_completion_suppress_append == 0 && rl_completion_append_character)
1527 temp_string[temp_string_index++] = rl_completion_append_character;
1529 temp_string[temp_string_index++] = '\0';
1531 if (rl_filename_completion_desired)
1533 filename = tilde_expand (text);
1534 s = (nontrivial_match && rl_completion_mark_symlink_dirs == 0)
1535 ? LSTAT (filename, &finfo)
1536 : stat (filename, &finfo);
1537 if (s == 0 && S_ISDIR (finfo.st_mode))
1539 if (_rl_complete_mark_directories)
1541 /* This is clumsy. Avoid putting in a double slash if point
1542 is at the end of the line and the previous character is a
1544 if (rl_point && rl_line_buffer[rl_point] == '\0' && rl_line_buffer[rl_point - 1] == '/')
1546 else if (rl_line_buffer[rl_point] != '/')
1547 rl_insert_text ("/");
1551 /* Don't add anything if the filename is a symlink and resolves to a
1553 else if (s == 0 && S_ISLNK (finfo.st_mode) &&
1554 stat (filename, &finfo) == 0 && S_ISDIR (finfo.st_mode))
1559 if (rl_point == rl_end && temp_string_index)
1560 rl_insert_text (temp_string);
1566 if (rl_point == rl_end && temp_string_index)
1567 rl_insert_text (temp_string);
1570 return (temp_string_index);
1574 insert_all_matches (matches, point, qc)
1582 rl_begin_undo_group ();
1583 /* remove any opening quote character; make_quoted_replacement will add
1585 if (qc && *qc && point && rl_line_buffer[point - 1] == *qc)
1587 rl_delete_text (point, rl_point);
1592 for (i = 1; matches[i]; i++)
1594 rp = make_quoted_replacement (matches[i], SINGLE_MATCH, qc);
1595 rl_insert_text (rp);
1596 rl_insert_text (" ");
1597 if (rp != matches[i])
1603 rp = make_quoted_replacement (matches[0], SINGLE_MATCH, qc);
1604 rl_insert_text (rp);
1605 rl_insert_text (" ");
1606 if (rp != matches[0])
1609 rl_end_undo_group ();
1613 _rl_free_match_list (matches)
1621 for (i = 0; matches[i]; i++)
1626 /* Complete the word at or before point.
1627 WHAT_TO_DO says what to do with the completion.
1628 `?' means list the possible completions.
1629 TAB means do standard completion.
1630 `*' means insert all of the possible completions.
1631 `!' means to do standard completion, and list all possible completions if
1632 there is more than one.
1633 `@' means to do standard completion, and list all possible completions if
1634 there is more than one and partial completion is not possible. */
1636 rl_complete_internal (what_to_do)
1640 rl_compentry_func_t *our_func;
1641 int start, end, delimiter, found_quote, i, nontrivial_lcd;
1642 char *text, *saved_line_buffer;
1645 RL_SETSTATE(RL_STATE_COMPLETING);
1647 set_completion_defaults (what_to_do);
1649 saved_line_buffer = rl_line_buffer ? savestring (rl_line_buffer) : (char *)NULL;
1650 our_func = rl_completion_entry_function
1651 ? rl_completion_entry_function
1652 : rl_filename_completion_function;
1653 /* We now look backwards for the start of a filename/variable word. */
1655 found_quote = delimiter = 0;
1659 /* This (possibly) changes rl_point. If it returns a non-zero char,
1660 we know we have an open quote. */
1661 quote_char = _rl_find_completion_word (&found_quote, &delimiter);
1666 text = rl_copy_text (start, end);
1667 matches = gen_completion_matches (text, start, end, our_func, found_quote, quote_char);
1668 /* nontrivial_lcd is set if the common prefix adds something to the word
1670 nontrivial_lcd = matches && strcmp (text, matches[0]) != 0;
1676 FREE (saved_line_buffer);
1677 completion_changed_buffer = 0;
1678 RL_UNSETSTATE(RL_STATE_COMPLETING);
1682 /* If we are matching filenames, the attempted completion function will
1683 have set rl_filename_completion_desired to a non-zero value. The basic
1684 rl_filename_completion_function does this. */
1685 i = rl_filename_completion_desired;
1687 if (postprocess_matches (&matches, i) == 0)
1690 FREE (saved_line_buffer);
1691 completion_changed_buffer = 0;
1692 RL_UNSETSTATE(RL_STATE_COMPLETING);
1701 /* Insert the first match with proper quoting. */
1703 insert_match (matches[0], start, matches[1] ? MULT_MATCH : SINGLE_MATCH, "e_char);
1705 /* If there are more matches, ring the bell to indicate.
1706 If we are in vi mode, Posix.2 says to not ring the bell.
1707 If the `show-all-if-ambiguous' variable is set, display
1708 all the matches immediately. Otherwise, if this was the
1709 only match, and we are hacking files, check the file to
1710 see if it was a directory. If so, and the `mark-directories'
1711 variable is set, add a '/' to the name. If not, and we
1712 are at the end of the line, then add a space. */
1715 if (what_to_do == '!')
1717 display_matches (matches);
1720 else if (what_to_do == '@')
1722 if (nontrivial_lcd == 0)
1723 display_matches (matches);
1726 else if (rl_editing_mode != vi_mode)
1727 rl_ding (); /* There are other matches remaining. */
1730 append_to_match (matches[0], delimiter, quote_char, nontrivial_lcd);
1735 insert_all_matches (matches, start, "e_char);
1739 display_matches (matches);
1743 fprintf (stderr, "\r\nreadline: bad value %d for what_to_do in rl_complete\n", what_to_do);
1745 FREE (saved_line_buffer);
1746 RL_UNSETSTATE(RL_STATE_COMPLETING);
1750 _rl_free_match_list (matches);
1752 /* Check to see if the line has changed through all of this manipulation. */
1753 if (saved_line_buffer)
1755 completion_changed_buffer = strcmp (rl_line_buffer, saved_line_buffer) != 0;
1756 free (saved_line_buffer);
1759 RL_UNSETSTATE(RL_STATE_COMPLETING);
1763 /***************************************************************/
1765 /* Application-callable completion match generator functions */
1767 /***************************************************************/
1769 /* Return an array of (char *) which is a list of completions for TEXT.
1770 If there are no completions, return a NULL pointer.
1771 The first entry in the returned array is the substitution for TEXT.
1772 The remaining entries are the possible completions.
1773 The array is terminated with a NULL pointer.
1775 ENTRY_FUNCTION is a function of two args, and returns a (char *).
1776 The first argument is TEXT.
1777 The second is a state argument; it should be zero on the first call, and
1778 non-zero on subsequent calls. It returns a NULL pointer to the caller
1779 when there are no more matches.
1782 rl_completion_matches (text, entry_function)
1784 rl_compentry_func_t *entry_function;
1786 /* Number of slots in match_list. */
1787 int match_list_size;
1789 /* The list of matches. */
1792 /* Number of matches actually found. */
1795 /* Temporary string binder. */
1799 match_list_size = 10;
1800 match_list = (char **)xmalloc ((match_list_size + 1) * sizeof (char *));
1801 match_list[1] = (char *)NULL;
1803 while (string = (*entry_function) (text, matches))
1805 if (matches + 1 == match_list_size)
1806 match_list = (char **)xrealloc
1807 (match_list, ((match_list_size += 10) + 1) * sizeof (char *));
1809 match_list[++matches] = string;
1810 match_list[matches + 1] = (char *)NULL;
1813 /* If there were any matches, then look through them finding out the
1814 lowest common denominator. That then becomes match_list[0]. */
1816 compute_lcd_of_matches (match_list, matches, text);
1817 else /* There were no matches. */
1820 match_list = (char **)NULL;
1822 return (match_list);
1825 /* A completion function for usernames.
1826 TEXT contains a partial username preceded by a random
1827 character (usually `~'). */
1829 rl_username_completion_function (text, state)
1833 #if defined (__WIN32__) || defined (__OPENNT)
1834 return (char *)NULL;
1835 #else /* !__WIN32__ && !__OPENNT) */
1836 static char *username = (char *)NULL;
1837 static struct passwd *entry;
1838 static int namelen, first_char, first_char_loc;
1846 first_char_loc = first_char == '~';
1848 username = savestring (&text[first_char_loc]);
1849 namelen = strlen (username);
1853 while (entry = getpwent ())
1855 /* Null usernames should result in all users as possible completions. */
1856 if (namelen == 0 || (STREQN (username, entry->pw_name, namelen)))
1863 return ((char *)NULL);
1867 value = (char *)xmalloc (2 + strlen (entry->pw_name));
1871 strcpy (value + first_char_loc, entry->pw_name);
1873 if (first_char == '~')
1874 rl_filename_completion_desired = 1;
1878 #endif /* !__WIN32__ && !__OPENNT */
1881 /* Okay, now we write the entry_function for filename completion. In the
1882 general case. Note that completion in the shell is a little different
1883 because of all the pathnames that must be followed when looking up the
1884 completion for a command. */
1886 rl_filename_completion_function (text, state)
1890 static DIR *directory = (DIR *)NULL;
1891 static char *filename = (char *)NULL;
1892 static char *dirname = (char *)NULL;
1893 static char *users_dirname = (char *)NULL;
1894 static int filename_len;
1897 struct dirent *entry;
1899 /* If we don't have any state, then do some initialization. */
1902 /* If we were interrupted before closing the directory or reading
1903 all of its contents, close it. */
1906 closedir (directory);
1907 directory = (DIR *)NULL;
1911 FREE (users_dirname);
1913 filename = savestring (text);
1916 dirname = savestring (text);
1918 temp = strrchr (dirname, '/');
1920 #if defined (__MSDOS__)
1921 /* special hack for //X/... */
1922 if (dirname[0] == '/' && dirname[1] == '/' && ISALPHA ((unsigned char)dirname[2]) && dirname[3] == '/')
1923 temp = strrchr (dirname + 3, '/');
1928 strcpy (filename, ++temp);
1931 #if defined (__MSDOS__)
1932 /* searches from current directory on the drive */
1933 else if (ISALPHA ((unsigned char)dirname[0]) && dirname[1] == ':')
1935 strcpy (filename, dirname + 2);
1945 /* We aren't done yet. We also support the "~user" syntax. */
1947 /* Save the version of the directory that the user typed. */
1948 users_dirname = savestring (dirname);
1950 if (*dirname == '~')
1952 temp = tilde_expand (dirname);
1957 if (rl_directory_rewrite_hook)
1958 (*rl_directory_rewrite_hook) (&dirname);
1960 if (rl_directory_completion_hook && (*rl_directory_completion_hook) (&dirname))
1962 free (users_dirname);
1963 users_dirname = savestring (dirname);
1966 directory = opendir (dirname);
1967 filename_len = strlen (filename);
1969 rl_filename_completion_desired = 1;
1972 /* At this point we should entertain the possibility of hacking wildcarded
1973 filenames, like /usr/man/man<WILD>/te<TAB>. If the directory name
1974 contains globbing characters, then build an array of directories, and
1975 then map over that list while completing. */
1976 /* *** UNIMPLEMENTED *** */
1978 /* Now that we have some state, we can read the directory. */
1980 entry = (struct dirent *)NULL;
1981 while (directory && (entry = readdir (directory)))
1983 /* Special case for no filename. If the user has disabled the
1984 `match-hidden-files' variable, skip filenames beginning with `.'.
1985 All other entries except "." and ".." match. */
1986 if (filename_len == 0)
1988 if (_rl_match_hidden_files == 0 && HIDDEN_FILE (entry->d_name))
1991 if (entry->d_name[0] != '.' ||
1992 (entry->d_name[1] &&
1993 (entry->d_name[1] != '.' || entry->d_name[2])))
1998 /* Otherwise, if these match up to the length of filename, then
2000 if (_rl_completion_case_fold)
2002 if ((_rl_to_lower (entry->d_name[0]) == _rl_to_lower (filename[0])) &&
2003 (((int)D_NAMLEN (entry)) >= filename_len) &&
2004 (_rl_strnicmp (filename, entry->d_name, filename_len) == 0))
2009 if ((entry->d_name[0] == filename[0]) &&
2010 (((int)D_NAMLEN (entry)) >= filename_len) &&
2011 (strncmp (filename, entry->d_name, filename_len) == 0))
2021 closedir (directory);
2022 directory = (DIR *)NULL;
2027 dirname = (char *)NULL;
2032 filename = (char *)NULL;
2036 free (users_dirname);
2037 users_dirname = (char *)NULL;
2040 return (char *)NULL;
2044 /* dirname && (strcmp (dirname, ".") != 0) */
2045 if (dirname && (dirname[0] != '.' || dirname[1]))
2047 if (rl_complete_with_tilde_expansion && *users_dirname == '~')
2049 dirlen = strlen (dirname);
2050 temp = (char *)xmalloc (2 + dirlen + D_NAMLEN (entry));
2051 strcpy (temp, dirname);
2052 /* Canonicalization cuts off any final slash present. We
2053 may need to add it back. */
2054 if (dirname[dirlen - 1] != '/')
2056 temp[dirlen++] = '/';
2057 temp[dirlen] = '\0';
2062 dirlen = strlen (users_dirname);
2063 temp = (char *)xmalloc (2 + dirlen + D_NAMLEN (entry));
2064 strcpy (temp, users_dirname);
2065 /* Make sure that temp has a trailing slash here. */
2066 if (users_dirname[dirlen - 1] != '/')
2067 temp[dirlen++] = '/';
2070 strcpy (temp + dirlen, entry->d_name);
2073 temp = savestring (entry->d_name);
2079 /* An initial implementation of a menu completion function a la tcsh. The
2080 first time (if the last readline command was not rl_menu_complete), we
2081 generate the list of matches. This code is very similar to the code in
2082 rl_complete_internal -- there should be a way to combine the two. Then,
2083 for each item in the list of matches, we insert the match in an undoable
2084 fashion, with the appropriate character appended (this happens on the
2085 second and subsequent consecutive calls to rl_menu_complete). When we
2086 hit the end of the match list, we restore the original unmatched text,
2087 ring the bell, and reset the counter to zero. */
2089 rl_menu_complete (count, ignore)
2092 rl_compentry_func_t *our_func;
2093 int matching_filenames, found_quote;
2095 static char *orig_text;
2096 static char **matches = (char **)0;
2097 static int match_list_index = 0;
2098 static int match_list_size = 0;
2099 static int orig_start, orig_end;
2100 static char quote_char;
2101 static int delimiter;
2103 /* The first time through, we generate the list of matches and set things
2104 up to insert them. */
2105 if (rl_last_func != rl_menu_complete)
2107 /* Clean up from previous call, if any. */
2110 _rl_free_match_list (matches);
2112 match_list_index = match_list_size = 0;
2113 matches = (char **)NULL;
2115 /* Only the completion entry function can change these. */
2116 set_completion_defaults ('%');
2118 our_func = rl_completion_entry_function
2119 ? rl_completion_entry_function
2120 : rl_filename_completion_function;
2122 /* We now look backwards for the start of a filename/variable word. */
2123 orig_end = rl_point;
2124 found_quote = delimiter = 0;
2128 /* This (possibly) changes rl_point. If it returns a non-zero char,
2129 we know we have an open quote. */
2130 quote_char = _rl_find_completion_word (&found_quote, &delimiter);
2132 orig_start = rl_point;
2133 rl_point = orig_end;
2135 orig_text = rl_copy_text (orig_start, orig_end);
2136 matches = gen_completion_matches (orig_text, orig_start, orig_end,
2137 our_func, found_quote, quote_char);
2139 /* If we are matching filenames, the attempted completion function will
2140 have set rl_filename_completion_desired to a non-zero value. The basic
2141 rl_filename_completion_function does this. */
2142 matching_filenames = rl_filename_completion_desired;
2144 if (matches == 0 || postprocess_matches (&matches, matching_filenames) == 0)
2148 matches = (char **)0;
2150 orig_text = (char *)0;
2151 completion_changed_buffer = 0;
2155 for (match_list_size = 0; matches[match_list_size]; match_list_size++)
2157 /* matches[0] is lcd if match_list_size > 1, but the circular buffer
2158 code below should take care of it. */
2161 /* Now we have the list of matches. Replace the text between
2162 rl_line_buffer[orig_start] and rl_line_buffer[rl_point] with
2163 matches[match_list_index], and add any necessary closing char. */
2165 if (matches == 0 || match_list_size == 0)
2169 matches = (char **)0;
2170 completion_changed_buffer = 0;
2174 match_list_index = (match_list_index + count) % match_list_size;
2175 if (match_list_index < 0)
2176 match_list_index += match_list_size;
2178 if (match_list_index == 0 && match_list_size > 1)
2181 insert_match (orig_text, orig_start, MULT_MATCH, "e_char);
2185 insert_match (matches[match_list_index], orig_start, SINGLE_MATCH, "e_char);
2186 append_to_match (matches[match_list_index], delimiter, quote_char,
2187 strcmp (orig_text, matches[match_list_index]));
2190 completion_changed_buffer = 1;