1 /* complete.c -- filename completion for readline. */
3 /* Copyright (C) 1987, 1989, 1992 Free Software Foundation, Inc.
5 This file is part of the GNU Readline Library, a library for
6 reading lines of text with interactive input and history editing.
8 The GNU Readline Library is free software; you can redistribute it
9 and/or modify it under the terms of the GNU General Public License
10 as published by the Free Software Foundation; either version 2, or
11 (at your option) any later version.
13 The GNU Readline Library is distributed in the hope that it will be
14 useful, but WITHOUT ANY WARRANTY; without even the implied warranty
15 of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 The GNU General Public License is often shipped with GNU software, and
19 is generally kept in a file called COPYING or LICENSE. If you do not
20 have a copy of the license, write to the Free Software Foundation,
21 59 Temple Place, Suite 330, Boston, MA 02111 USA. */
22 #define READLINE_LIBRARY
24 #if defined (HAVE_CONFIG_H)
28 #include <sys/types.h>
30 #if defined (HAVE_SYS_FILE_H)
34 #if defined (HAVE_UNISTD_H)
36 #endif /* HAVE_UNISTD_H */
38 #if defined (HAVE_STDLIB_H)
41 # include "ansi_stdlib.h"
42 #endif /* HAVE_STDLIB_H */
54 #include "posixstat.h"
56 /* System-specific feature definitions and include files. */
59 /* Some standard library routines. */
62 #include "rlprivate.h"
65 typedef int QSFUNC (const void *, const void *);
67 typedef int QSFUNC ();
76 /* Unix version of a hidden file. Could be different on other systems. */
77 #define HIDDEN_FILE(fname) ((fname)[0] == '.')
79 /* Most systems don't declare getpwent in <pwd.h> if _POSIX_SOURCE is
81 #if !defined (HAVE_GETPW_DECLS) || defined (_POSIX_SOURCE)
82 extern struct passwd *getpwent PARAMS((void));
83 #endif /* !HAVE_GETPW_DECLS || _POSIX_SOURCE */
85 /* If non-zero, then this is the address of a function to call when
86 completing a word would normally display the list of possible matches.
87 This function is called instead of actually doing the display.
88 It takes three arguments: (char **matches, int num_matches, int max_length)
89 where MATCHES is the array of strings that matched, NUM_MATCHES is the
90 number of strings in that array, and MAX_LENGTH is the length of the
91 longest string in that array. */
92 rl_compdisp_func_t *rl_completion_display_matches_hook = (rl_compdisp_func_t *)NULL;
94 #if defined (VISIBLE_STATS)
98 static int stat_char PARAMS((char *));
101 static char *rl_quote_filename PARAMS((char *, int, char *));
103 static int get_y_or_n PARAMS((void));
104 static char *printable_part PARAMS((char *));
105 static int print_filename PARAMS((char *, char *));
106 static char find_completion_word PARAMS((int *, int *));
108 static char **gen_completion_matches PARAMS((char *, int, int, rl_compentry_func_t *, int, int));
110 static char **remove_duplicate_matches PARAMS((char **));
111 static void insert_match PARAMS((char *, int, int, char *));
112 static int append_to_match PARAMS((char *, int, int, int));
113 static void insert_all_matches PARAMS((char **, int, char *));
114 static void display_matches PARAMS((char **));
115 static int compute_lcd_of_matches PARAMS((char **, int, const char *));
116 static int postprocess_matches PARAMS((char ***, int));
118 static char *make_quoted_replacement PARAMS((char *, int, char *));
119 static void free_match_list PARAMS((char **));
121 /* **************************************************************** */
123 /* Completion matching, from readline's point of view. */
125 /* **************************************************************** */
127 /* Variables known only to the readline library. */
129 /* If non-zero, non-unique completions always show the list of matches. */
130 int _rl_complete_show_all = 0;
132 /* If non-zero, completed directory names have a slash appended. */
133 int _rl_complete_mark_directories = 1;
135 /* If non-zero, completions are printed horizontally in alphabetical order,
137 int _rl_print_completions_horizontally;
139 /* Non-zero means that case is not significant in filename completion. */
140 #if defined (__MSDOS__) && !defined (__DJGPP__)
141 int _rl_completion_case_fold = 1;
143 int _rl_completion_case_fold;
146 /* If non-zero, don't match hidden files (filenames beginning with a `.' on
147 Unix) when doing filename completion. */
148 int _rl_match_hidden_files = 1;
150 /* Global variables available to applications using readline. */
152 #if defined (VISIBLE_STATS)
153 /* Non-zero means add an additional character to each filename displayed
154 during listing completion iff rl_filename_completion_desired which helps
155 to indicate the type of file being listed. */
156 int rl_visible_stats = 0;
157 #endif /* VISIBLE_STATS */
159 /* If non-zero, then this is the address of a function to call when
160 completing on a directory name. The function is called with
161 the address of a string (the current directory name) as an arg. */
162 rl_icppfunc_t *rl_directory_completion_hook = (rl_icppfunc_t *)NULL;
164 rl_icppfunc_t *rl_directory_rewrite_hook = (rl_icppfunc_t *)NULL;
166 /* Non-zero means readline completion functions perform tilde expansion. */
167 int rl_complete_with_tilde_expansion = 0;
169 /* Pointer to the generator function for completion_matches ().
170 NULL means to use rl_filename_completion_function (), the default filename
172 rl_compentry_func_t *rl_completion_entry_function = (rl_compentry_func_t *)NULL;
174 /* Pointer to alternative function to create matches.
175 Function is called with TEXT, START, and END.
176 START and END are indices in RL_LINE_BUFFER saying what the boundaries
178 If this function exists and returns NULL then call the value of
179 rl_completion_entry_function to try to match, otherwise use the
180 array of strings returned. */
181 rl_completion_func_t *rl_attempted_completion_function = (rl_completion_func_t *)NULL;
183 /* Non-zero means to suppress normal filename completion after the
184 user-specified completion function has been called. */
185 int rl_attempted_completion_over = 0;
187 /* Set to a character indicating the type of completion being performed
188 by rl_complete_internal, available for use by application completion
190 int rl_completion_type = 0;
192 /* Up to this many items will be displayed in response to a
193 possible-completions call. After that, we ask the user if
194 she is sure she wants to see them all. */
195 int rl_completion_query_items = 100;
197 /* The basic list of characters that signal a break between words for the
198 completer routine. The contents of this variable is what breaks words
199 in the shell, i.e. " \t\n\"\\'`@$><=" */
200 const char *rl_basic_word_break_characters = " \t\n\"\\'`@$><=;|&{(";
202 /* List of basic quoting characters. */
203 const char *rl_basic_quote_characters = "\"'";
205 /* The list of characters that signal a break between words for
206 rl_complete_internal. The default list is the contents of
207 rl_basic_word_break_characters. */
208 const char *rl_completer_word_break_characters = (const char *)NULL;
210 /* List of characters which can be used to quote a substring of the line.
211 Completion occurs on the entire substring, and within the substring
212 rl_completer_word_break_characters are treated as any other character,
213 unless they also appear within this list. */
214 const char *rl_completer_quote_characters = (const char *)NULL;
216 /* List of characters that should be quoted in filenames by the completer. */
217 const char *rl_filename_quote_characters = (const char *)NULL;
219 /* List of characters that are word break characters, but should be left
220 in TEXT when it is passed to the completion function. The shell uses
221 this to help determine what kind of completing to do. */
222 const char *rl_special_prefixes = (const char *)NULL;
224 /* If non-zero, then disallow duplicates in the matches. */
225 int rl_ignore_completion_duplicates = 1;
227 /* Non-zero means that the results of the matches are to be treated
228 as filenames. This is ALWAYS zero on entry, and can only be changed
229 within a completion entry finder function. */
230 int rl_filename_completion_desired = 0;
232 /* Non-zero means that the results of the matches are to be quoted using
233 double quotes (or an application-specific quoting mechanism) if the
234 filename contains any characters in rl_filename_quote_chars. This is
235 ALWAYS non-zero on entry, and can only be changed within a completion
236 entry finder function. */
237 int rl_filename_quoting_desired = 1;
239 /* This function, if defined, is called by the completer when real
240 filename completion is done, after all the matching names have been
241 generated. It is passed a (char**) known as matches in the code below.
242 It consists of a NULL-terminated array of pointers to potential
243 matching strings. The 1st element (matches[0]) is the maximal
244 substring that is common to all matches. This function can re-arrange
245 the list of matches as required, but all elements of the array must be
246 free()'d if they are deleted. The main intent of this function is
247 to implement FIGNORE a la SunOS csh. */
248 rl_compignore_func_t *rl_ignore_some_completions_function = (rl_compignore_func_t *)NULL;
250 /* Set to a function to quote a filename in an application-specific fashion.
251 Called with the text to quote, the type of match found (single or multiple)
252 and a pointer to the quoting character to be used, which the function can
254 rl_quote_func_t *rl_filename_quoting_function = rl_quote_filename;
256 /* Function to call to remove quoting characters from a filename. Called
257 before completion is attempted, so the embedded quotes do not interfere
258 with matching names in the file system. Readline doesn't do anything
259 with this; it's set only by applications. */
260 rl_dequote_func_t *rl_filename_dequoting_function = (rl_dequote_func_t *)NULL;
262 /* Function to call to decide whether or not a word break character is
263 quoted. If a character is quoted, it does not break words for the
265 rl_linebuf_func_t *rl_char_is_quoted_p = (rl_linebuf_func_t *)NULL;
267 /* Character appended to completed words when at the end of the line. The
268 default is a space. */
269 int rl_completion_append_character = ' ';
271 /* If non-zero, inhibit completion (temporarily). */
272 int rl_inhibit_completion;
274 /* Variables local to this file. */
276 /* Local variable states what happened during the last completion attempt. */
277 static int completion_changed_buffer;
279 /*************************************/
281 /* Bindable completion functions */
283 /*************************************/
285 /* Complete the word at or before point. You have supplied the function
286 that does the initial simple matching selection algorithm (see
287 rl_completion_matches ()). The default is to do filename completion. */
289 rl_complete (ignore, invoking_key)
290 int ignore, invoking_key;
292 if (rl_inhibit_completion)
293 return (rl_insert (ignore, invoking_key));
294 else if (rl_last_func == rl_complete && !completion_changed_buffer)
295 return (rl_complete_internal ('?'));
296 else if (_rl_complete_show_all)
297 return (rl_complete_internal ('!'));
299 return (rl_complete_internal (TAB));
302 /* List the possible completions. See description of rl_complete (). */
304 rl_possible_completions (ignore, invoking_key)
305 int ignore, invoking_key;
307 return (rl_complete_internal ('?'));
311 rl_insert_completions (ignore, invoking_key)
312 int ignore, invoking_key;
314 return (rl_complete_internal ('*'));
317 /************************************/
319 /* Completion utility functions */
321 /************************************/
323 /* The user must press "y" or "n". Non-zero return means "y" pressed. */
331 RL_SETSTATE(RL_STATE_MOREINPUT);
333 RL_UNSETSTATE(RL_STATE_MOREINPUT);
335 if (c == 'y' || c == 'Y' || c == ' ')
337 if (c == 'n' || c == 'N' || c == RUBOUT)
340 _rl_abort_internal ();
345 #if defined (VISIBLE_STATS)
346 /* Return the character which best describes FILENAME.
347 `@' for symbolic links
352 `%' for character special devices
353 `#' for block special devices */
361 #if defined (HAVE_LSTAT) && defined (S_ISLNK)
362 r = lstat (filename, &finfo);
364 r = stat (filename, &finfo);
371 if (S_ISDIR (finfo.st_mode))
373 #if defined (S_ISCHR)
374 else if (S_ISCHR (finfo.st_mode))
377 #if defined (S_ISBLK)
378 else if (S_ISBLK (finfo.st_mode))
381 #if defined (S_ISLNK)
382 else if (S_ISLNK (finfo.st_mode))
385 #if defined (S_ISSOCK)
386 else if (S_ISSOCK (finfo.st_mode))
388 #endif /* S_ISSOCK */
389 #if defined (S_ISFIFO)
390 else if (S_ISFIFO (finfo.st_mode))
393 else if (S_ISREG (finfo.st_mode))
395 if (access (filename, X_OK) == 0)
400 #endif /* VISIBLE_STATS */
402 /* Return the portion of PATHNAME that should be output when listing
403 possible completions. If we are hacking filename completion, we
404 are only interested in the basename, the portion following the
405 final slash. Otherwise, we return what we were passed. */
407 printable_part (pathname)
412 temp = rl_filename_completion_desired ? strrchr (pathname, '/') : (char *)NULL;
413 #if defined (__MSDOS__)
414 if (rl_filename_completion_desired && temp == 0 && ISALPHA ((unsigned char)pathname[0]) && pathname[1] == ':')
417 return (temp ? ++temp : pathname);
420 /* Output TO_PRINT to rl_outstream. If VISIBLE_STATS is defined and we
421 are using it, check for and output a single character for `special'
422 filenames. Return the number of characters we output. */
428 putc ('^', rl_outstream); \
429 putc (UNCTRL (c), rl_outstream); \
432 else if (c == RUBOUT) \
434 putc ('^', rl_outstream); \
435 putc ('?', rl_outstream); \
440 putc (c, rl_outstream); \
446 print_filename (to_print, full_pathname)
447 char *to_print, *full_pathname;
450 #if !defined (VISIBLE_STATS)
453 for (s = to_print; *s; s++)
458 char *s, c, *new_full_pathname;
459 int extension_char, slen, tlen;
461 for (s = to_print; *s; s++)
466 if (rl_filename_completion_desired && rl_visible_stats)
468 /* If to_print != full_pathname, to_print is the basename of the
469 path passed. In this case, we try to expand the directory
470 name before checking for the stat character. */
471 if (to_print != full_pathname)
473 /* Terminate the directory name. */
477 /* If setting the last slash in full_pathname to a NUL results in
478 full_pathname being the empty string, we are trying to complete
479 files in the root directory. If we pass a null string to the
480 bash directory completion hook, for example, it will expand it
481 to the current directory. We just want the `/'. */
482 s = tilde_expand (full_pathname && *full_pathname ? full_pathname : "/");
483 if (rl_directory_completion_hook)
484 (*rl_directory_completion_hook) (&s);
487 tlen = strlen (to_print);
488 new_full_pathname = (char *)xmalloc (slen + tlen + 2);
489 strcpy (new_full_pathname, s);
490 new_full_pathname[slen] = '/';
491 strcpy (new_full_pathname + slen + 1, to_print);
493 extension_char = stat_char (new_full_pathname);
495 free (new_full_pathname);
500 s = tilde_expand (full_pathname);
501 extension_char = stat_char (s);
507 putc (extension_char, rl_outstream);
511 #endif /* VISIBLE_STATS */
516 rl_quote_filename (s, rtype, qcp)
523 r = (char *)xmalloc (strlen (s) + 2);
524 *r = *rl_completer_quote_characters;
527 *qcp = *rl_completer_quote_characters;
531 /* Find the bounds of the current word for completion purposes, and leave
532 rl_point set to the end of the word. This function skips quoted
533 substrings (characters between matched pairs of characters in
534 rl_completer_quote_characters). First we try to find an unclosed
535 quoted substring on which to do matching. If one is not found, we use
536 the word break characters to find the boundaries of the current word.
537 We call an application-specific function to decide whether or not a
538 particular word break character is quoted; if that function returns a
539 non-zero result, the character does not break a word. This function
540 returns the opening quote character if we found an unclosed quoted
541 substring, '\0' otherwise. FP, if non-null, is set to a value saying
542 which (shell-like) quote characters we found (single quote, double
543 quote, or backslash) anywhere in the string. DP, if non-null, is set to
544 the value of the delimiter character that caused a word break. */
547 find_completion_word (fp, dp)
550 int scan, end, found_quote, delimiter, pass_next, isbrk;
554 found_quote = delimiter = 0;
557 if (rl_completer_quote_characters)
559 /* We have a list of characters which can be used in pairs to
560 quote substrings for the completer. Try to find the start
561 of an unclosed quoted substring. */
562 /* FOUND_QUOTE is set so we know what kind of quotes we found. */
563 for (scan = pass_next = 0; scan < end; scan++)
571 /* Shell-like semantics for single quotes -- don't allow backslash
572 to quote anything in single quotes, especially not the closing
573 quote. If you don't like this, take out the check on the value
575 if (quote_char != '\'' && rl_line_buffer[scan] == '\\')
578 found_quote |= RL_QF_BACKSLASH;
582 if (quote_char != '\0')
584 /* Ignore everything until the matching close quote char. */
585 if (rl_line_buffer[scan] == quote_char)
587 /* Found matching close. Abandon this substring. */
592 else if (strchr (rl_completer_quote_characters, rl_line_buffer[scan]))
594 /* Found start of a quoted substring. */
595 quote_char = rl_line_buffer[scan];
597 /* Shell-like quoting conventions. */
598 if (quote_char == '\'')
599 found_quote |= RL_QF_SINGLE_QUOTE;
600 else if (quote_char == '"')
601 found_quote |= RL_QF_DOUBLE_QUOTE;
606 if (rl_point == end && quote_char == '\0')
608 /* We didn't find an unclosed quoted substring upon which to do
609 completion, so use the word break characters to find the
610 substring on which to complete. */
613 scan = rl_line_buffer[rl_point];
615 if (strchr (rl_completer_word_break_characters, scan) == 0)
618 /* Call the application-specific function to tell us whether
619 this word break character is quoted and should be skipped. */
620 if (rl_char_is_quoted_p && found_quote &&
621 (*rl_char_is_quoted_p) (rl_line_buffer, rl_point))
624 /* Convoluted code, but it avoids an n^2 algorithm with calls
625 to char_is_quoted. */
630 /* If we are at an unquoted word break, then advance past it. */
631 scan = rl_line_buffer[rl_point];
633 /* If there is an application-specific function to say whether or not
634 a character is quoted and we found a quote character, let that
635 function decide whether or not a character is a word break, even
636 if it is found in rl_completer_word_break_characters. Don't bother
637 if we're at the end of the line, though. */
640 if (rl_char_is_quoted_p)
641 isbrk = (found_quote == 0 ||
642 (*rl_char_is_quoted_p) (rl_line_buffer, rl_point) == 0) &&
643 strchr (rl_completer_word_break_characters, scan) != 0;
645 isbrk = strchr (rl_completer_word_break_characters, scan) != 0;
649 /* If the character that caused the word break was a quoting
650 character, then remember it as the delimiter. */
651 if (rl_basic_quote_characters &&
652 strchr (rl_basic_quote_characters, scan) &&
653 (end - rl_point) > 1)
656 /* If the character isn't needed to determine something special
657 about what kind of completion to perform, then advance past it. */
658 if (rl_special_prefixes == 0 || strchr (rl_special_prefixes, scan) == 0)
672 gen_completion_matches (text, start, end, our_func, found_quote, quote_char)
675 rl_compentry_func_t *our_func;
676 int found_quote, quote_char;
678 char **matches, *temp;
680 /* If the user wants to TRY to complete, but then wants to give
681 up and use the default completion function, they set the
682 variable rl_attempted_completion_function. */
683 if (rl_attempted_completion_function)
685 matches = (*rl_attempted_completion_function) (text, start, end);
687 if (matches || rl_attempted_completion_over)
689 rl_attempted_completion_over = 0;
694 /* Beware -- we're stripping the quotes here. Do this only if we know
695 we are doing filename completion and the application has defined a
696 filename dequoting function. */
699 if (found_quote && our_func == rl_filename_completion_function &&
700 rl_filename_dequoting_function)
702 /* delete single and double quotes */
703 temp = (*rl_filename_dequoting_function) (text, quote_char);
704 text = temp; /* not freeing text is not a memory leak */
707 matches = rl_completion_matches (text, our_func);
712 /* Filter out duplicates in MATCHES. This frees up the strings in
715 remove_duplicate_matches (matches)
723 /* Sort the items. */
724 for (i = 0; matches[i]; i++)
727 /* Sort the array without matches[0], since we need it to
728 stay in place no matter what. */
730 qsort (matches+1, i-1, sizeof (char *), (QSFUNC *)_rl_qsort_string_compare);
732 /* Remember the lowest common denominator for it may be unique. */
733 lowest_common = savestring (matches[0]);
735 for (i = newlen = 0; matches[i + 1]; i++)
737 if (strcmp (matches[i], matches[i + 1]) == 0)
740 matches[i] = (char *)&dead_slot;
746 /* We have marked all the dead slots with (char *)&dead_slot.
747 Copy all the non-dead entries into a new array. */
748 temp_array = (char **)xmalloc ((3 + newlen) * sizeof (char *));
749 for (i = j = 1; matches[i]; i++)
751 if (matches[i] != (char *)&dead_slot)
752 temp_array[j++] = matches[i];
754 temp_array[j] = (char *)NULL;
756 if (matches[0] != (char *)&dead_slot)
759 /* Place the lowest common denominator back in [0]. */
760 temp_array[0] = lowest_common;
762 /* If there is one string left, and it is identical to the
763 lowest common denominator, then the LCD is the string to
765 if (j == 2 && strcmp (temp_array[0], temp_array[1]) == 0)
767 free (temp_array[1]);
768 temp_array[1] = (char *)NULL;
773 /* Find the common prefix of the list of matches, and put it into
776 compute_lcd_of_matches (match_list, matches, text)
781 register int i, c1, c2, si;
782 int low; /* Count of max-matched characters. */
784 /* If only one match, just use that. Otherwise, compare each
785 member of the list with the next, finding out where they
789 match_list[0] = match_list[1];
790 match_list[1] = (char *)NULL;
794 for (i = 1, low = 100000; i < matches; i++)
796 if (_rl_completion_case_fold)
799 (c1 = _rl_to_lower(match_list[i][si])) &&
800 (c2 = _rl_to_lower(match_list[i + 1][si]));
808 (c1 = match_list[i][si]) &&
809 (c2 = match_list[i + 1][si]);
819 /* If there were multiple matches, but none matched up to even the
820 first character, and the user typed something, use that as the
821 value of matches[0]. */
822 if (low == 0 && text && *text)
824 match_list[0] = (char *)xmalloc (strlen (text) + 1);
825 strcpy (match_list[0], text);
829 match_list[0] = (char *)xmalloc (low + 1);
831 /* If we are ignoring case, try to preserve the case of the string
832 the user typed in the face of multiple matches differing in case. */
833 if (_rl_completion_case_fold)
835 /* sort the list to get consistent answers. */
836 qsort (match_list+1, matches, sizeof(char *), (QSFUNC *)_rl_qsort_string_compare);
841 for (i = 1; i <= matches; i++)
842 if (strncmp (match_list[i], text, si) == 0)
844 strncpy (match_list[0], match_list[i], low);
847 /* no casematch, use first entry */
849 strncpy (match_list[0], match_list[1], low);
852 /* otherwise, just use the text the user typed. */
853 strncpy (match_list[0], text, low);
856 strncpy (match_list[0], match_list[1], low);
858 match_list[0][low] = '\0';
865 postprocess_matches (matchesp, matching_filenames)
867 int matching_filenames;
869 char *t, **matches, **temp_matches;
874 /* It seems to me that in all the cases we handle we would like
875 to ignore duplicate possiblilities. Scan for the text to
876 insert being identical to the other completions. */
877 if (rl_ignore_completion_duplicates)
879 temp_matches = remove_duplicate_matches (matches);
881 matches = temp_matches;
884 /* If we are matching filenames, then here is our chance to
885 do clever processing by re-examining the list. Call the
886 ignore function with the array as a parameter. It can
887 munge the array, deleting matches as it desires. */
888 if (rl_ignore_some_completions_function && matching_filenames)
890 for (nmatch = 1; matches[nmatch]; nmatch++)
892 (void)(*rl_ignore_some_completions_function) (matches);
893 if (matches == 0 || matches[0] == 0)
896 *matchesp = (char **)0;
901 /* If we removed some matches, recompute the common prefix. */
902 for (i = 1; matches[i]; i++)
904 if (i > 1 && i < nmatch)
907 compute_lcd_of_matches (matches, i - 1, t);
917 /* A convenience function for displaying a list of strings in
918 columnar format on readline's output stream. MATCHES is the list
919 of strings, in argv format, LEN is the number of strings in MATCHES,
920 and MAX is the length of the longest string in MATCHES. */
922 rl_display_match_list (matches, len, max)
926 int count, limit, printed_len;
930 /* How many items of MAX length can we fit in the screen window? */
932 limit = _rl_screenwidth / max;
933 if (limit != 1 && (limit * max == _rl_screenwidth))
936 /* Avoid a possible floating exception. If max > _rl_screenwidth,
937 limit will be 0 and a divide-by-zero fault will result. */
941 /* How many iterations of the printing loop? */
942 count = (len + (limit - 1)) / limit;
944 /* Watch out for special case. If LEN is less than LIMIT, then
945 just do the inner printing loop.
946 0 < len <= limit implies count = 1. */
948 /* Sort the items if they are not already sorted. */
949 if (rl_ignore_completion_duplicates == 0)
950 qsort (matches + 1, len, sizeof (char *), (QSFUNC *)_rl_qsort_string_compare);
954 if (_rl_print_completions_horizontally == 0)
956 /* Print the sorted items, up-and-down alphabetically, like ls. */
957 for (i = 1; i <= count; i++)
959 for (j = 0, l = i; j < limit; j++)
961 if (l > len || matches[l] == 0)
965 temp = printable_part (matches[l]);
966 printed_len = print_filename (temp, matches[l]);
969 for (k = 0; k < max - printed_len; k++)
970 putc (' ', rl_outstream);
979 /* Print the sorted items, across alphabetically, like ls -x. */
980 for (i = 1; matches[i]; i++)
982 temp = printable_part (matches[i]);
983 printed_len = print_filename (temp, matches[i]);
984 /* Have we reached the end of this line? */
987 if (i && (limit > 1) && (i % limit) == 0)
990 for (k = 0; k < max - printed_len; k++)
991 putc (' ', rl_outstream);
998 /* Display MATCHES, a list of matching filenames in argv format. This
999 handles the simple case -- a single match -- first. If there is more
1000 than one match, we compute the number of strings in the list and the
1001 length of the longest string, which will be needed by the display
1002 function. If the application wants to handle displaying the list of
1003 matches itself, it sets RL_COMPLETION_DISPLAY_MATCHES_HOOK to the
1004 address of a function, and we just call it. If we're handling the
1005 display ourselves, we just call rl_display_match_list. We also check
1006 that the list of matches doesn't exceed the user-settable threshold,
1007 and ask the user if he wants to see the list if there are more matches
1008 than RL_COMPLETION_QUERY_ITEMS. */
1010 display_matches (matches)
1016 /* Move to the last visible line of a possibly-multiple-line command. */
1017 _rl_move_vert (_rl_vis_botlin);
1019 /* Handle simple case first. What if there is only one answer? */
1020 if (matches[1] == 0)
1022 temp = printable_part (matches[0]);
1024 print_filename (temp, matches[0]);
1027 rl_forced_update_display ();
1028 rl_display_fixed = 1;
1033 /* There is more than one answer. Find out how many there are,
1034 and find the maximum printed length of a single entry. */
1035 for (max = 0, i = 1; matches[i]; i++)
1037 temp = printable_part (matches[i]);
1038 len = strlen (temp);
1046 /* If the caller has defined a display hook, then call that now. */
1047 if (rl_completion_display_matches_hook)
1049 (*rl_completion_display_matches_hook) (matches, len, max);
1053 /* If there are many items, then ask the user if she really wants to
1055 if (len >= rl_completion_query_items)
1058 fprintf (rl_outstream, "Display all %d possibilities? (y or n)", len);
1059 fflush (rl_outstream);
1060 if (get_y_or_n () == 0)
1064 rl_forced_update_display ();
1065 rl_display_fixed = 1;
1071 rl_display_match_list (matches, len, max);
1073 rl_forced_update_display ();
1074 rl_display_fixed = 1;
1078 make_quoted_replacement (match, mtype, qc)
1081 char *qc; /* Pointer to quoting character, if any */
1083 int should_quote, do_replace;
1086 /* If we are doing completion on quoted substrings, and any matches
1087 contain any of the completer_word_break_characters, then auto-
1088 matically prepend the substring with a quote character (just pick
1089 the first one from the list of such) if it does not already begin
1090 with a quote string. FIXME: Need to remove any such automatically
1091 inserted quote character when it no longer is necessary, such as
1092 if we change the string we are completing on and the new set of
1093 matches don't require a quoted substring. */
1094 replacement = match;
1096 should_quote = match && rl_completer_quote_characters &&
1097 rl_filename_completion_desired &&
1098 rl_filename_quoting_desired;
1101 should_quote = should_quote && (!qc || !*qc ||
1102 (rl_completer_quote_characters && strchr (rl_completer_quote_characters, *qc)));
1106 /* If there is a single match, see if we need to quote it.
1107 This also checks whether the common prefix of several
1108 matches needs to be quoted. */
1109 should_quote = rl_filename_quote_characters
1110 ? (_rl_strpbrk (match, rl_filename_quote_characters) != 0)
1113 do_replace = should_quote ? mtype : NO_MATCH;
1114 /* Quote the replacement, since we found an embedded
1115 word break character in a potential match. */
1116 if (do_replace != NO_MATCH && rl_filename_quoting_function)
1117 replacement = (*rl_filename_quoting_function) (match, do_replace, qc);
1119 return (replacement);
1123 insert_match (match, start, mtype, qc)
1131 oqc = qc ? *qc : '\0';
1132 replacement = make_quoted_replacement (match, mtype, qc);
1134 /* Now insert the match. */
1137 /* Don't double an opening quote character. */
1138 if (qc && *qc && start && rl_line_buffer[start - 1] == *qc &&
1139 replacement[0] == *qc)
1141 /* If make_quoted_replacement changed the quoting character, remove
1142 the opening quote and insert the (fully-quoted) replacement. */
1143 else if (qc && (*qc != oqc) && start && rl_line_buffer[start - 1] == oqc &&
1144 replacement[0] != oqc)
1146 _rl_replace_text (replacement, start, rl_point - 1);
1147 if (replacement != match)
1152 /* Append any necessary closing quote and a separator character to the
1153 just-inserted match. If the user has specified that directories
1154 should be marked by a trailing `/', append one of those instead. The
1155 default trailing character is a space. Returns the number of characters
1156 appended. If NONTRIVIAL_MATCH is set, we test for a symlink (if the OS
1157 has them) and don't add a suffix for a symlink to a directory. A
1158 nontrivial match is one that actually adds to the word being completed. */
1160 append_to_match (text, delimiter, quote_char, nontrivial_match)
1162 int delimiter, quote_char, nontrivial_match;
1164 char temp_string[4], *filename;
1165 int temp_string_index, s;
1168 temp_string_index = 0;
1169 if (quote_char && rl_point && rl_line_buffer[rl_point - 1] != quote_char)
1170 temp_string[temp_string_index++] = quote_char;
1173 temp_string[temp_string_index++] = delimiter;
1174 else if (rl_completion_append_character)
1175 temp_string[temp_string_index++] = rl_completion_append_character;
1177 temp_string[temp_string_index++] = '\0';
1179 if (rl_filename_completion_desired)
1181 filename = tilde_expand (text);
1182 s = nontrivial_match ? LSTAT (filename, &finfo) : stat (filename, &finfo);
1183 if (s == 0 && S_ISDIR (finfo.st_mode))
1185 if (_rl_complete_mark_directories && rl_line_buffer[rl_point] != '/')
1186 rl_insert_text ("/");
1189 /* Don't add anything if the filename is a symlink and resolves to a
1191 else if (s == 0 && S_ISLNK (finfo.st_mode) &&
1192 stat (filename, &finfo) == 0 && S_ISDIR (finfo.st_mode))
1197 if (rl_point == rl_end)
1198 rl_insert_text (temp_string);
1204 if (rl_point == rl_end)
1205 rl_insert_text (temp_string);
1208 return (temp_string_index);
1212 insert_all_matches (matches, point, qc)
1220 rl_begin_undo_group ();
1221 /* remove any opening quote character; make_quoted_replacement will add
1223 if (qc && *qc && point && rl_line_buffer[point - 1] == *qc)
1225 rl_delete_text (point, rl_point);
1230 for (i = 1; matches[i]; i++)
1232 rp = make_quoted_replacement (matches[i], SINGLE_MATCH, qc);
1233 rl_insert_text (rp);
1234 rl_insert_text (" ");
1235 if (rp != matches[i])
1241 rp = make_quoted_replacement (matches[0], SINGLE_MATCH, qc);
1242 rl_insert_text (rp);
1243 rl_insert_text (" ");
1244 if (rp != matches[0])
1247 rl_end_undo_group ();
1251 free_match_list (matches)
1256 for (i = 0; matches[i]; i++)
1261 /* Complete the word at or before point.
1262 WHAT_TO_DO says what to do with the completion.
1263 `?' means list the possible completions.
1264 TAB means do standard completion.
1265 `*' means insert all of the possible completions.
1266 `!' means to do standard completion, and list all possible completions if
1267 there is more than one. */
1269 rl_complete_internal (what_to_do)
1273 rl_compentry_func_t *our_func;
1274 int start, end, delimiter, found_quote, i, nontrivial_lcd;
1275 char *text, *saved_line_buffer;
1278 RL_SETSTATE(RL_STATE_COMPLETING);
1279 /* Only the completion entry function can change these. */
1280 rl_filename_completion_desired = 0;
1281 rl_filename_quoting_desired = 1;
1282 rl_completion_type = what_to_do;
1284 saved_line_buffer = rl_line_buffer ? savestring (rl_line_buffer) : (char *)NULL;
1285 our_func = rl_completion_entry_function
1286 ? rl_completion_entry_function
1287 : rl_filename_completion_function;
1289 /* We now look backwards for the start of a filename/variable word. */
1291 found_quote = delimiter = 0;
1295 /* This (possibly) changes rl_point. If it returns a non-zero char,
1296 we know we have an open quote. */
1297 quote_char = find_completion_word (&found_quote, &delimiter);
1302 text = rl_copy_text (start, end);
1303 matches = gen_completion_matches (text, start, end, our_func, found_quote, quote_char);
1304 /* nontrivial_lcd is set if the common prefix adds something to the word
1306 nontrivial_lcd = matches && strcmp (text, matches[0]) != 0;
1312 FREE (saved_line_buffer);
1313 RL_UNSETSTATE(RL_STATE_COMPLETING);
1317 /* If we are matching filenames, the attempted completion function will
1318 have set rl_filename_completion_desired to a non-zero value. The basic
1319 rl_filename_completion_function does this. */
1320 i = rl_filename_completion_desired;
1322 if (postprocess_matches (&matches, i) == 0)
1325 FREE (saved_line_buffer);
1326 completion_changed_buffer = 0;
1327 RL_UNSETSTATE(RL_STATE_COMPLETING);
1335 /* Insert the first match with proper quoting. */
1337 insert_match (matches[0], start, matches[1] ? MULT_MATCH : SINGLE_MATCH, "e_char);
1339 /* If there are more matches, ring the bell to indicate.
1340 If we are in vi mode, Posix.2 says to not ring the bell.
1341 If the `show-all-if-ambiguous' variable is set, display
1342 all the matches immediately. Otherwise, if this was the
1343 only match, and we are hacking files, check the file to
1344 see if it was a directory. If so, and the `mark-directories'
1345 variable is set, add a '/' to the name. If not, and we
1346 are at the end of the line, then add a space. */
1349 if (what_to_do == '!')
1351 display_matches (matches);
1354 else if (rl_editing_mode != vi_mode)
1355 rl_ding (); /* There are other matches remaining. */
1358 append_to_match (matches[0], delimiter, quote_char, nontrivial_lcd);
1363 insert_all_matches (matches, start, "e_char);
1367 display_matches (matches);
1371 fprintf (stderr, "\r\nreadline: bad value %d for what_to_do in rl_complete\n", what_to_do);
1373 FREE (saved_line_buffer);
1374 RL_UNSETSTATE(RL_STATE_COMPLETING);
1378 free_match_list (matches);
1380 /* Check to see if the line has changed through all of this manipulation. */
1381 if (saved_line_buffer)
1383 completion_changed_buffer = strcmp (rl_line_buffer, saved_line_buffer) != 0;
1384 free (saved_line_buffer);
1387 RL_UNSETSTATE(RL_STATE_COMPLETING);
1391 /***************************************************************/
1393 /* Application-callable completion match generator functions */
1395 /***************************************************************/
1397 /* Return an array of (char *) which is a list of completions for TEXT.
1398 If there are no completions, return a NULL pointer.
1399 The first entry in the returned array is the substitution for TEXT.
1400 The remaining entries are the possible completions.
1401 The array is terminated with a NULL pointer.
1403 ENTRY_FUNCTION is a function of two args, and returns a (char *).
1404 The first argument is TEXT.
1405 The second is a state argument; it should be zero on the first call, and
1406 non-zero on subsequent calls. It returns a NULL pointer to the caller
1407 when there are no more matches.
1410 rl_completion_matches (text, entry_function)
1412 rl_compentry_func_t *entry_function;
1414 /* Number of slots in match_list. */
1415 int match_list_size;
1417 /* The list of matches. */
1420 /* Number of matches actually found. */
1423 /* Temporary string binder. */
1427 match_list_size = 10;
1428 match_list = (char **)xmalloc ((match_list_size + 1) * sizeof (char *));
1429 match_list[1] = (char *)NULL;
1431 while (string = (*entry_function) (text, matches))
1433 if (matches + 1 == match_list_size)
1434 match_list = (char **)xrealloc
1435 (match_list, ((match_list_size += 10) + 1) * sizeof (char *));
1437 match_list[++matches] = string;
1438 match_list[matches + 1] = (char *)NULL;
1441 /* If there were any matches, then look through them finding out the
1442 lowest common denominator. That then becomes match_list[0]. */
1444 compute_lcd_of_matches (match_list, matches, text);
1445 else /* There were no matches. */
1448 match_list = (char **)NULL;
1450 return (match_list);
1453 /* A completion function for usernames.
1454 TEXT contains a partial username preceded by a random
1455 character (usually `~'). */
1457 rl_username_completion_function (text, state)
1461 #if defined (__WIN32__) || defined (__OPENNT)
1462 return (char *)NULL;
1463 #else /* !__WIN32__ && !__OPENNT) */
1464 static char *username = (char *)NULL;
1465 static struct passwd *entry;
1466 static int namelen, first_char, first_char_loc;
1474 first_char_loc = first_char == '~';
1476 username = savestring (&text[first_char_loc]);
1477 namelen = strlen (username);
1481 while (entry = getpwent ())
1483 /* Null usernames should result in all users as possible completions. */
1484 if (namelen == 0 || (STREQN (username, entry->pw_name, namelen)))
1491 return ((char *)NULL);
1495 value = (char *)xmalloc (2 + strlen (entry->pw_name));
1499 strcpy (value + first_char_loc, entry->pw_name);
1501 if (first_char == '~')
1502 rl_filename_completion_desired = 1;
1506 #endif /* !__WIN32__ && !__OPENNT */
1509 /* Okay, now we write the entry_function for filename completion. In the
1510 general case. Note that completion in the shell is a little different
1511 because of all the pathnames that must be followed when looking up the
1512 completion for a command. */
1514 rl_filename_completion_function (text, state)
1518 static DIR *directory = (DIR *)NULL;
1519 static char *filename = (char *)NULL;
1520 static char *dirname = (char *)NULL;
1521 static char *users_dirname = (char *)NULL;
1522 static int filename_len;
1525 struct dirent *entry;
1527 /* If we don't have any state, then do some initialization. */
1530 /* If we were interrupted before closing the directory or reading
1531 all of its contents, close it. */
1534 closedir (directory);
1535 directory = (DIR *)NULL;
1539 FREE (users_dirname);
1541 filename = savestring (text);
1544 dirname = savestring (text);
1546 temp = strrchr (dirname, '/');
1548 #if defined (__MSDOS__)
1549 /* special hack for //X/... */
1550 if (dirname[0] == '/' && dirname[1] == '/' && ISALPHA ((unsigned char)dirname[2]) && dirname[3] == '/')
1551 temp = strrchr (dirname + 3, '/');
1556 strcpy (filename, ++temp);
1559 #if defined (__MSDOS__)
1560 /* searches from current directory on the drive */
1561 else if (ISALPHA ((unsigned char)dirname[0]) && dirname[1] == ':')
1563 strcpy (filename, dirname + 2);
1573 /* We aren't done yet. We also support the "~user" syntax. */
1575 /* Save the version of the directory that the user typed. */
1576 users_dirname = savestring (dirname);
1578 if (*dirname == '~')
1580 temp = tilde_expand (dirname);
1585 if (rl_directory_rewrite_hook)
1586 (*rl_directory_rewrite_hook) (&dirname);
1588 if (rl_directory_completion_hook && (*rl_directory_completion_hook) (&dirname))
1590 free (users_dirname);
1591 users_dirname = savestring (dirname);
1594 directory = opendir (dirname);
1595 filename_len = strlen (filename);
1597 rl_filename_completion_desired = 1;
1600 /* At this point we should entertain the possibility of hacking wildcarded
1601 filenames, like /usr/man/man<WILD>/te<TAB>. If the directory name
1602 contains globbing characters, then build an array of directories, and
1603 then map over that list while completing. */
1604 /* *** UNIMPLEMENTED *** */
1606 /* Now that we have some state, we can read the directory. */
1608 entry = (struct dirent *)NULL;
1609 while (directory && (entry = readdir (directory)))
1611 /* Special case for no filename. If the user has disabled the
1612 `match-hidden-files' variable, skip filenames beginning with `.'.
1613 All other entries except "." and ".." match. */
1614 if (filename_len == 0)
1616 if (_rl_match_hidden_files == 0 && HIDDEN_FILE (entry->d_name))
1619 if (entry->d_name[0] != '.' ||
1620 (entry->d_name[1] &&
1621 (entry->d_name[1] != '.' || entry->d_name[2])))
1626 /* Otherwise, if these match up to the length of filename, then
1628 if (_rl_completion_case_fold)
1630 if ((_rl_to_lower (entry->d_name[0]) == _rl_to_lower (filename[0])) &&
1631 (((int)D_NAMLEN (entry)) >= filename_len) &&
1632 (_rl_strnicmp (filename, entry->d_name, filename_len) == 0))
1637 if ((entry->d_name[0] == filename[0]) &&
1638 (((int)D_NAMLEN (entry)) >= filename_len) &&
1639 (strncmp (filename, entry->d_name, filename_len) == 0))
1649 closedir (directory);
1650 directory = (DIR *)NULL;
1655 dirname = (char *)NULL;
1660 filename = (char *)NULL;
1664 free (users_dirname);
1665 users_dirname = (char *)NULL;
1668 return (char *)NULL;
1672 /* dirname && (strcmp (dirname, ".") != 0) */
1673 if (dirname && (dirname[0] != '.' || dirname[1]))
1675 if (rl_complete_with_tilde_expansion && *users_dirname == '~')
1677 dirlen = strlen (dirname);
1678 temp = (char *)xmalloc (2 + dirlen + D_NAMLEN (entry));
1679 strcpy (temp, dirname);
1680 /* Canonicalization cuts off any final slash present. We
1681 may need to add it back. */
1682 if (dirname[dirlen - 1] != '/')
1684 temp[dirlen++] = '/';
1685 temp[dirlen] = '\0';
1690 dirlen = strlen (users_dirname);
1691 temp = (char *)xmalloc (2 + dirlen + D_NAMLEN (entry));
1692 strcpy (temp, users_dirname);
1693 /* Make sure that temp has a trailing slash here. */
1694 if (users_dirname[dirlen - 1] != '/')
1695 temp[dirlen++] = '/';
1698 strcpy (temp + dirlen, entry->d_name);
1701 temp = savestring (entry->d_name);
1707 /* An initial implementation of a menu completion function a la tcsh. The
1708 first time (if the last readline command was not rl_menu_complete), we
1709 generate the list of matches. This code is very similar to the code in
1710 rl_complete_internal -- there should be a way to combine the two. Then,
1711 for each item in the list of matches, we insert the match in an undoable
1712 fashion, with the appropriate character appended (this happens on the
1713 second and subsequent consecutive calls to rl_menu_complete). When we
1714 hit the end of the match list, we restore the original unmatched text,
1715 ring the bell, and reset the counter to zero. */
1717 rl_menu_complete (count, ignore)
1720 rl_compentry_func_t *our_func;
1721 int matching_filenames, found_quote;
1723 static char *orig_text;
1724 static char **matches = (char **)0;
1725 static int match_list_index = 0;
1726 static int match_list_size = 0;
1727 static int orig_start, orig_end;
1728 static char quote_char;
1729 static int delimiter;
1731 /* The first time through, we generate the list of matches and set things
1732 up to insert them. */
1733 if (rl_last_func != rl_menu_complete)
1735 /* Clean up from previous call, if any. */
1738 free_match_list (matches);
1740 match_list_index = match_list_size = 0;
1741 matches = (char **)NULL;
1743 /* Only the completion entry function can change these. */
1744 rl_filename_completion_desired = 0;
1745 rl_filename_quoting_desired = 1;
1746 rl_completion_type = '%';
1748 our_func = rl_completion_entry_function
1749 ? rl_completion_entry_function
1750 : rl_filename_completion_function;
1752 /* We now look backwards for the start of a filename/variable word. */
1753 orig_end = rl_point;
1754 found_quote = delimiter = 0;
1758 /* This (possibly) changes rl_point. If it returns a non-zero char,
1759 we know we have an open quote. */
1760 quote_char = find_completion_word (&found_quote, &delimiter);
1762 orig_start = rl_point;
1763 rl_point = orig_end;
1765 orig_text = rl_copy_text (orig_start, orig_end);
1766 matches = gen_completion_matches (orig_text, orig_start, orig_end,
1767 our_func, found_quote, quote_char);
1769 /* If we are matching filenames, the attempted completion function will
1770 have set rl_filename_completion_desired to a non-zero value. The basic
1771 rl_filename_completion_function does this. */
1772 matching_filenames = rl_filename_completion_desired;
1774 if (matches == 0 || postprocess_matches (&matches, matching_filenames) == 0)
1778 matches = (char **)0;
1780 orig_text = (char *)0;
1781 completion_changed_buffer = 0;
1785 for (match_list_size = 0; matches[match_list_size]; match_list_size++)
1787 /* matches[0] is lcd if match_list_size > 1, but the circular buffer
1788 code below should take care of it. */
1791 /* Now we have the list of matches. Replace the text between
1792 rl_line_buffer[orig_start] and rl_line_buffer[rl_point] with
1793 matches[match_list_index], and add any necessary closing char. */
1795 if (matches == 0 || match_list_size == 0)
1799 matches = (char **)0;
1800 completion_changed_buffer = 0;
1804 match_list_index = (match_list_index + count) % match_list_size;
1805 if (match_list_index < 0)
1806 match_list_index += match_list_size;
1808 if (match_list_index == 0 && match_list_size > 1)
1811 insert_match (orig_text, orig_start, MULT_MATCH, "e_char);
1815 insert_match (matches[match_list_index], orig_start, SINGLE_MATCH, "e_char);
1816 append_to_match (matches[match_list_index], delimiter, quote_char,
1817 strcmp (orig_text, matches[match_list_index]));
1820 completion_changed_buffer = 1;