1 /* complete.c -- filename completion for readline. */
3 /* Copyright (C) 1987-2010 Free Software Foundation, Inc.
5 This file is part of the GNU Readline Library (Readline), a library
6 for reading lines of text with interactive input and history editing.
8 Readline is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 Readline is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with Readline. If not, see <http://www.gnu.org/licenses/>.
22 #define READLINE_LIBRARY
24 #if defined (HAVE_CONFIG_H)
28 #include <sys/types.h>
30 #if defined (HAVE_SYS_FILE_H)
31 # include <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 */
51 #if defined (HAVE_PWD_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_GETPWENT) && (!defined (HAVE_GETPW_DECLS) || defined (_POSIX_SOURCE))
85 extern struct passwd
*getpwent
PARAMS((void));
86 #endif /* HAVE_GETPWENT && (!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 *, int));
114 static int print_filename
PARAMS((char *, char *, int));
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 int complete_fncmp
PARAMS((const char *, int, const char *, int));
123 static void display_matches
PARAMS((char **));
124 static int compute_lcd_of_matches
PARAMS((char **, int, const char *));
125 static int postprocess_matches
PARAMS((char ***, int));
126 static int complete_get_screenwidth
PARAMS((void));
128 static char *make_quoted_replacement
PARAMS((char *, int, char *));
130 /* **************************************************************** */
132 /* Completion matching, from readline's point of view. */
134 /* **************************************************************** */
136 /* Variables known only to the readline library. */
138 /* If non-zero, non-unique completions always show the list of matches. */
139 int _rl_complete_show_all
= 0;
141 /* If non-zero, non-unique completions show the list of matches, unless it
142 is not possible to do partial completion and modify the line. */
143 int _rl_complete_show_unmodified
= 0;
145 /* If non-zero, completed directory names have a slash appended. */
146 int _rl_complete_mark_directories
= 1;
148 /* If non-zero, the symlinked directory completion behavior introduced in
149 readline-4.2a is disabled, and symlinks that point to directories have
150 a slash appended (subject to the value of _rl_complete_mark_directories).
151 This is user-settable via the mark-symlinked-directories variable. */
152 int _rl_complete_mark_symlink_dirs
= 0;
154 /* If non-zero, completions are printed horizontally in alphabetical order,
156 int _rl_print_completions_horizontally
;
158 /* Non-zero means that case is not significant in filename completion. */
159 #if defined (__MSDOS__) && !defined (__DJGPP__)
160 int _rl_completion_case_fold
= 1;
162 int _rl_completion_case_fold
= 0;
165 /* Non-zero means that `-' and `_' are equivalent when comparing filenames
167 int _rl_completion_case_map
= 0;
169 /* If zero, don't match hidden files (filenames beginning with a `.' on
170 Unix) when doing filename completion. */
171 int _rl_match_hidden_files
= 1;
173 /* Length in characters of a common prefix replaced with an ellipsis (`...')
174 when displaying completion matches. Matches whose printable portion has
175 more than this number of displaying characters in common will have the common
176 display prefix replaced with an ellipsis. */
177 int _rl_completion_prefix_display_length
= 0;
179 /* The readline-private number of screen columns to use when displaying
180 matches. If < 0 or > _rl_screenwidth, it is ignored. */
181 int _rl_completion_columns
= -1;
183 /* Global variables available to applications using readline. */
185 #if defined (VISIBLE_STATS)
186 /* Non-zero means add an additional character to each filename displayed
187 during listing completion iff rl_filename_completion_desired which helps
188 to indicate the type of file being listed. */
189 int rl_visible_stats
= 0;
190 #endif /* VISIBLE_STATS */
192 /* If non-zero, when completing in the middle of a word, don't insert
193 characters from the match that match characters following point in
194 the word. This means, for instance, completing when the cursor is
195 after the `e' in `Makefile' won't result in `Makefilefile'. */
196 int _rl_skip_completed_text
= 0;
198 /* If non-zero, menu completion displays the common prefix first in the
199 cycle of possible completions instead of the last. */
200 int _rl_menu_complete_prefix_first
= 0;
202 /* If non-zero, then this is the address of a function to call when
203 completing on a directory name. The function is called with
204 the address of a string (the current directory name) as an arg. */
205 rl_icppfunc_t
*rl_directory_completion_hook
= (rl_icppfunc_t
*)NULL
;
207 rl_icppfunc_t
*rl_directory_rewrite_hook
= (rl_icppfunc_t
*)NULL
;
209 /* If non-zero, this is the address of a function to call when reading
210 directory entries from the filesystem for completion and comparing
211 them to the partial word to be completed. The function should
212 either return its first argument (if no conversion takes place) or
213 newly-allocated memory. This can, for instance, convert filenames
214 between character sets for comparison against what's typed at the
215 keyboard. The returned value is what is added to the list of
216 matches. The second argument is the length of the filename to be
218 rl_dequote_func_t
*rl_filename_rewrite_hook
= (rl_dequote_func_t
*)NULL
;
220 /* Non-zero means readline completion functions perform tilde expansion. */
221 int rl_complete_with_tilde_expansion
= 0;
223 /* Pointer to the generator function for completion_matches ().
224 NULL means to use rl_filename_completion_function (), the default filename
226 rl_compentry_func_t
*rl_completion_entry_function
= (rl_compentry_func_t
*)NULL
;
228 /* Pointer to generator function for rl_menu_complete (). NULL means to use
229 *rl_completion_entry_function (see above). */
230 rl_compentry_func_t
*rl_menu_completion_entry_function
= (rl_compentry_func_t
*)NULL
;
232 /* Pointer to alternative function to create matches.
233 Function is called with TEXT, START, and END.
234 START and END are indices in RL_LINE_BUFFER saying what the boundaries
236 If this function exists and returns NULL then call the value of
237 rl_completion_entry_function to try to match, otherwise use the
238 array of strings returned. */
239 rl_completion_func_t
*rl_attempted_completion_function
= (rl_completion_func_t
*)NULL
;
241 /* Non-zero means to suppress normal filename completion after the
242 user-specified completion function has been called. */
243 int rl_attempted_completion_over
= 0;
245 /* Set to a character indicating the type of completion being performed
246 by rl_complete_internal, available for use by application completion
248 int rl_completion_type
= 0;
250 /* Up to this many items will be displayed in response to a
251 possible-completions call. After that, we ask the user if
252 she is sure she wants to see them all. A negative value means
254 int rl_completion_query_items
= 100;
256 int _rl_page_completions
= 1;
258 /* The basic list of characters that signal a break between words for the
259 completer routine. The contents of this variable is what breaks words
260 in the shell, i.e. " \t\n\"\\'`@$><=" */
261 const char *rl_basic_word_break_characters
= " \t\n\"\\'`@$><=;|&{("; /* }) */
263 /* List of basic quoting characters. */
264 const char *rl_basic_quote_characters
= "\"'";
266 /* The list of characters that signal a break between words for
267 rl_complete_internal. The default list is the contents of
268 rl_basic_word_break_characters. */
269 /*const*/ char *rl_completer_word_break_characters
= (/*const*/ char *)NULL
;
271 /* Hook function to allow an application to set the completion word
272 break characters before readline breaks up the line. Allows
273 position-dependent word break characters. */
274 rl_cpvfunc_t
*rl_completion_word_break_hook
= (rl_cpvfunc_t
*)NULL
;
276 /* List of characters which can be used to quote a substring of the line.
277 Completion occurs on the entire substring, and within the substring
278 rl_completer_word_break_characters are treated as any other character,
279 unless they also appear within this list. */
280 const char *rl_completer_quote_characters
= (const char *)NULL
;
282 /* List of characters that should be quoted in filenames by the completer. */
283 const char *rl_filename_quote_characters
= (const char *)NULL
;
285 /* List of characters that are word break characters, but should be left
286 in TEXT when it is passed to the completion function. The shell uses
287 this to help determine what kind of completing to do. */
288 const char *rl_special_prefixes
= (const char *)NULL
;
290 /* If non-zero, then disallow duplicates in the matches. */
291 int rl_ignore_completion_duplicates
= 1;
293 /* Non-zero means that the results of the matches are to be treated
294 as filenames. This is ALWAYS zero on entry, and can only be changed
295 within a completion entry finder function. */
296 int rl_filename_completion_desired
= 0;
298 /* Non-zero means that the results of the matches are to be quoted using
299 double quotes (or an application-specific quoting mechanism) if the
300 filename contains any characters in rl_filename_quote_chars. This is
301 ALWAYS non-zero on entry, and can only be changed within a completion
302 entry finder function. */
303 int rl_filename_quoting_desired
= 1;
305 /* This function, if defined, is called by the completer when real
306 filename completion is done, after all the matching names have been
307 generated. It is passed a (char**) known as matches in the code below.
308 It consists of a NULL-terminated array of pointers to potential
309 matching strings. The 1st element (matches[0]) is the maximal
310 substring that is common to all matches. This function can re-arrange
311 the list of matches as required, but all elements of the array must be
312 free()'d if they are deleted. The main intent of this function is
313 to implement FIGNORE a la SunOS csh. */
314 rl_compignore_func_t
*rl_ignore_some_completions_function
= (rl_compignore_func_t
*)NULL
;
316 /* Set to a function to quote a filename in an application-specific fashion.
317 Called with the text to quote, the type of match found (single or multiple)
318 and a pointer to the quoting character to be used, which the function can
320 rl_quote_func_t
*rl_filename_quoting_function
= rl_quote_filename
;
322 /* Function to call to remove quoting characters from a filename. Called
323 before completion is attempted, so the embedded quotes do not interfere
324 with matching names in the file system. Readline doesn't do anything
325 with this; it's set only by applications. */
326 rl_dequote_func_t
*rl_filename_dequoting_function
= (rl_dequote_func_t
*)NULL
;
328 /* Function to call to decide whether or not a word break character is
329 quoted. If a character is quoted, it does not break words for the
331 rl_linebuf_func_t
*rl_char_is_quoted_p
= (rl_linebuf_func_t
*)NULL
;
333 /* If non-zero, the completion functions don't append anything except a
334 possible closing quote. This is set to 0 by rl_complete_internal and
335 may be changed by an application-specific completion function. */
336 int rl_completion_suppress_append
= 0;
338 /* Character appended to completed words when at the end of the line. The
339 default is a space. */
340 int rl_completion_append_character
= ' ';
342 /* If non-zero, the completion functions don't append any closing quote.
343 This is set to 0 by rl_complete_internal and may be changed by an
344 application-specific completion function. */
345 int rl_completion_suppress_quote
= 0;
347 /* Set to any quote character readline thinks it finds before any application
348 completion function is called. */
349 int rl_completion_quote_character
;
351 /* Set to a non-zero value if readline found quoting anywhere in the word to
352 be completed; set before any application completion function is called. */
353 int rl_completion_found_quote
;
355 /* If non-zero, a slash will be appended to completed filenames that are
356 symbolic links to directory names, subject to the value of the
357 mark-directories variable (which is user-settable). This exists so
358 that application completion functions can override the user's preference
359 (set via the mark-symlinked-directories variable) if appropriate.
360 It's set to the value of _rl_complete_mark_symlink_dirs in
361 rl_complete_internal before any application-specific completion
362 function is called, so without that function doing anything, the user's
363 preferences are honored. */
364 int rl_completion_mark_symlink_dirs
;
366 /* If non-zero, inhibit completion (temporarily). */
367 int rl_inhibit_completion
;
369 /* Set to the last key used to invoke one of the completion functions */
370 int rl_completion_invoking_key
;
372 /* If non-zero, sort the completion matches. On by default. */
373 int rl_sort_completion_matches
= 1;
375 /* Variables local to this file. */
377 /* Local variable states what happened during the last completion attempt. */
378 static int completion_changed_buffer
;
380 /* The result of the query to the user about displaying completion matches */
381 static int completion_y_or_n
;
383 /*************************************/
385 /* Bindable completion functions */
387 /*************************************/
389 /* Complete the word at or before point. You have supplied the function
390 that does the initial simple matching selection algorithm (see
391 rl_completion_matches ()). The default is to do filename completion. */
393 rl_complete (ignore
, invoking_key
)
394 int ignore
, invoking_key
;
396 rl_completion_invoking_key
= invoking_key
;
398 if (rl_inhibit_completion
)
399 return (_rl_insert_char (ignore
, invoking_key
));
400 else if (rl_last_func
== rl_complete
&& !completion_changed_buffer
)
401 return (rl_complete_internal ('?'));
402 else if (_rl_complete_show_all
)
403 return (rl_complete_internal ('!'));
404 else if (_rl_complete_show_unmodified
)
405 return (rl_complete_internal ('@'));
407 return (rl_complete_internal (TAB
));
410 /* List the possible completions. See description of rl_complete (). */
412 rl_possible_completions (ignore
, invoking_key
)
413 int ignore
, invoking_key
;
415 rl_completion_invoking_key
= invoking_key
;
416 return (rl_complete_internal ('?'));
420 rl_insert_completions (ignore
, invoking_key
)
421 int ignore
, invoking_key
;
423 rl_completion_invoking_key
= invoking_key
;
424 return (rl_complete_internal ('*'));
427 /* Return the correct value to pass to rl_complete_internal performing
428 the same tests as rl_complete. This allows consecutive calls to an
429 application's completion function to list possible completions and for
430 an application-specific completion function to honor the
431 show-all-if-ambiguous readline variable. */
433 rl_completion_mode (cfunc
)
434 rl_command_func_t
*cfunc
;
436 if (rl_last_func
== cfunc
&& !completion_changed_buffer
)
438 else if (_rl_complete_show_all
)
440 else if (_rl_complete_show_unmodified
)
446 /************************************/
448 /* Completion utility functions */
450 /************************************/
452 /* Reset readline state on a signal or other event. */
454 _rl_reset_completion_state ()
456 rl_completion_found_quote
= 0;
457 rl_completion_quote_character
= 0;
460 /* Set default values for readline word completion. These are the variables
461 that application completion functions can change or inspect. */
463 set_completion_defaults (what_to_do
)
466 /* Only the completion entry function can change these. */
467 rl_filename_completion_desired
= 0;
468 rl_filename_quoting_desired
= 1;
469 rl_completion_type
= what_to_do
;
470 rl_completion_suppress_append
= rl_completion_suppress_quote
= 0;
471 rl_completion_append_character
= ' ';
473 /* The completion entry function may optionally change this. */
474 rl_completion_mark_symlink_dirs
= _rl_complete_mark_symlink_dirs
;
477 /* The user must press "y" or "n". Non-zero return means "y" pressed. */
479 get_y_or_n (for_pager
)
484 /* For now, disable pager in callback mode, until we later convert to state
485 driven functions. Have to wait until next major version to add new
486 state definition, since it will change value of RL_STATE_DONE. */
487 #if defined (READLINE_CALLBACKS)
488 if (RL_ISSTATE (RL_STATE_CALLBACK
))
494 RL_SETSTATE(RL_STATE_MOREINPUT
);
496 RL_UNSETSTATE(RL_STATE_MOREINPUT
);
498 if (c
== 'y' || c
== 'Y' || c
== ' ')
500 if (c
== 'n' || c
== 'N' || c
== RUBOUT
)
502 if (c
== ABORT_CHAR
|| c
< 0)
503 _rl_abort_internal ();
504 if (for_pager
&& (c
== NEWLINE
|| c
== RETURN
))
506 if (for_pager
&& (c
== 'q' || c
== 'Q'))
513 _rl_internal_pager (lines
)
518 fprintf (rl_outstream
, "--More--");
519 fflush (rl_outstream
);
521 _rl_erase_entire_line ();
531 path_isdir (filename
)
532 const char *filename
;
536 return (stat (filename
, &finfo
) == 0 && S_ISDIR (finfo
.st_mode
));
539 #if defined (VISIBLE_STATS)
540 /* Return the character which best describes FILENAME.
541 `@' for symbolic links
546 `%' for character special devices
547 `#' for block special devices */
555 /* Short-circuit a //server on cygwin, since that will always behave as
558 if (filename
[0] == '/' && filename
[1] == '/' && strchr (filename
+2, '/') == 0)
562 #if defined (HAVE_LSTAT) && defined (S_ISLNK)
563 r
= lstat (filename
, &finfo
);
565 r
= stat (filename
, &finfo
);
572 if (S_ISDIR (finfo
.st_mode
))
574 #if defined (S_ISCHR)
575 else if (S_ISCHR (finfo
.st_mode
))
578 #if defined (S_ISBLK)
579 else if (S_ISBLK (finfo
.st_mode
))
582 #if defined (S_ISLNK)
583 else if (S_ISLNK (finfo
.st_mode
))
586 #if defined (S_ISSOCK)
587 else if (S_ISSOCK (finfo
.st_mode
))
589 #endif /* S_ISSOCK */
590 #if defined (S_ISFIFO)
591 else if (S_ISFIFO (finfo
.st_mode
))
594 else if (S_ISREG (finfo
.st_mode
))
596 if (access (filename
, X_OK
) == 0)
601 #endif /* VISIBLE_STATS */
603 /* Return the portion of PATHNAME that should be output when listing
604 possible completions. If we are hacking filename completion, we
605 are only interested in the basename, the portion following the
606 final slash. Otherwise, we return what we were passed. Since
607 printing empty strings is not very informative, if we're doing
608 filename completion, and the basename is the empty string, we look
609 for the previous slash and return the portion following that. If
610 there's no previous slash, we just return what we were passed. */
612 printable_part (pathname
)
617 if (rl_filename_completion_desired
== 0) /* don't need to do anything */
620 temp
= strrchr (pathname
, '/');
621 #if defined (__MSDOS__)
622 if (temp
== 0 && ISALPHA ((unsigned char)pathname
[0]) && pathname
[1] == ':')
626 if (temp
== 0 || *temp
== '\0')
628 /* If the basename is NULL, we might have a pathname like '/usr/src/'.
629 Look for a previous slash and, if one is found, return the portion
630 following that slash. If there's no previous slash, just return the
631 pathname we were passed. */
632 else if (temp
[1] == '\0')
634 for (x
= temp
- 1; x
> pathname
; x
--)
637 return ((*x
== '/') ? x
+ 1 : pathname
);
643 /* Compute width of STRING when displayed on screen by print_filename */
649 #if defined (HANDLE_MULTIBYTE)
655 left
= strlen (string
) + 1;
656 memset (&ps
, 0, sizeof (mbstate_t));
662 if (CTRL_CHAR (string
[pos
]) || string
[pos
] == RUBOUT
)
669 #if defined (HANDLE_MULTIBYTE)
670 clen
= mbrtowc (&wc
, string
+ pos
, left
- pos
, &ps
);
671 if (MB_INVALIDCH (clen
))
675 memset (&ps
, 0, sizeof (mbstate_t));
677 else if (MB_NULLWCH (clen
))
683 width
+= (w
>= 0) ? w
: 1;
695 #define ELLIPSIS_LEN 3
698 fnprint (to_print
, prefix_bytes
)
699 const char *to_print
;
704 #if defined (HANDLE_MULTIBYTE)
711 end
= to_print
+ strlen (to_print
) + 1;
712 memset (&ps
, 0, sizeof (mbstate_t));
717 /* Don't print only the ellipsis if the common prefix is one of the
718 possible completions */
719 if (to_print
[prefix_bytes
] == '\0')
726 ellipsis
= (to_print
[prefix_bytes
] == '.') ? '_' : '.';
727 for (w
= 0; w
< ELLIPSIS_LEN
; w
++)
728 putc (ellipsis
, rl_outstream
);
729 printed_len
= ELLIPSIS_LEN
;
732 s
= to_print
+ prefix_bytes
;
737 putc ('^', rl_outstream
);
738 putc (UNCTRL (*s
), rl_outstream
);
741 #if defined (HANDLE_MULTIBYTE)
742 memset (&ps
, 0, sizeof (mbstate_t));
745 else if (*s
== RUBOUT
)
747 putc ('^', rl_outstream
);
748 putc ('?', rl_outstream
);
751 #if defined (HANDLE_MULTIBYTE)
752 memset (&ps
, 0, sizeof (mbstate_t));
757 #if defined (HANDLE_MULTIBYTE)
758 tlen
= mbrtowc (&wc
, s
, end
- s
, &ps
);
759 if (MB_INVALIDCH (tlen
))
763 memset (&ps
, 0, sizeof (mbstate_t));
765 else if (MB_NULLWCH (tlen
))
770 width
= (w
>= 0) ? w
: 1;
772 fwrite (s
, 1, tlen
, rl_outstream
);
774 printed_len
+= width
;
776 putc (*s
, rl_outstream
);
786 /* Output TO_PRINT to rl_outstream. If VISIBLE_STATS is defined and we
787 are using it, check for and output a single character for `special'
788 filenames. Return the number of characters we output. */
791 print_filename (to_print
, full_pathname
, prefix_bytes
)
792 char *to_print
, *full_pathname
;
795 int printed_len
, extension_char
, slen
, tlen
;
796 char *s
, c
, *new_full_pathname
, *dn
;
799 printed_len
= fnprint (to_print
, prefix_bytes
);
801 #if defined (VISIBLE_STATS)
802 if (rl_filename_completion_desired
&& (rl_visible_stats
|| _rl_complete_mark_directories
))
804 if (rl_filename_completion_desired
&& _rl_complete_mark_directories
)
807 /* If to_print != full_pathname, to_print is the basename of the
808 path passed. In this case, we try to expand the directory
809 name before checking for the stat character. */
810 if (to_print
!= full_pathname
)
812 /* Terminate the directory name. */
816 /* If setting the last slash in full_pathname to a NUL results in
817 full_pathname being the empty string, we are trying to complete
818 files in the root directory. If we pass a null string to the
819 bash directory completion hook, for example, it will expand it
820 to the current directory. We just want the `/'. */
821 if (full_pathname
== 0 || *full_pathname
== 0)
823 else if (full_pathname
[0] != '/')
825 else if (full_pathname
[1] == 0)
826 dn
= "//"; /* restore trailing slash to `//' */
827 else if (full_pathname
[1] == '/' && full_pathname
[2] == 0)
828 dn
= "/"; /* don't turn /// into // */
831 s
= tilde_expand (dn
);
832 if (rl_directory_completion_hook
)
833 (*rl_directory_completion_hook
) (&s
);
836 tlen
= strlen (to_print
);
837 new_full_pathname
= (char *)xmalloc (slen
+ tlen
+ 2);
838 strcpy (new_full_pathname
, s
);
839 if (s
[slen
- 1] == '/')
842 new_full_pathname
[slen
] = '/';
843 new_full_pathname
[slen
] = '/';
844 strcpy (new_full_pathname
+ slen
+ 1, to_print
);
846 #if defined (VISIBLE_STATS)
847 if (rl_visible_stats
)
848 extension_char
= stat_char (new_full_pathname
);
851 if (path_isdir (new_full_pathname
))
852 extension_char
= '/';
854 xfree (new_full_pathname
);
859 s
= tilde_expand (full_pathname
);
860 #if defined (VISIBLE_STATS)
861 if (rl_visible_stats
)
862 extension_char
= stat_char (s
);
866 extension_char
= '/';
872 putc (extension_char
, rl_outstream
);
881 rl_quote_filename (s
, rtype
, qcp
)
888 r
= (char *)xmalloc (strlen (s
) + 2);
889 *r
= *rl_completer_quote_characters
;
892 *qcp
= *rl_completer_quote_characters
;
896 /* Find the bounds of the current word for completion purposes, and leave
897 rl_point set to the end of the word. This function skips quoted
898 substrings (characters between matched pairs of characters in
899 rl_completer_quote_characters). First we try to find an unclosed
900 quoted substring on which to do matching. If one is not found, we use
901 the word break characters to find the boundaries of the current word.
902 We call an application-specific function to decide whether or not a
903 particular word break character is quoted; if that function returns a
904 non-zero result, the character does not break a word. This function
905 returns the opening quote character if we found an unclosed quoted
906 substring, '\0' otherwise. FP, if non-null, is set to a value saying
907 which (shell-like) quote characters we found (single quote, double
908 quote, or backslash) anywhere in the string. DP, if non-null, is set to
909 the value of the delimiter character that caused a word break. */
912 _rl_find_completion_word (fp
, dp
)
915 int scan
, end
, found_quote
, delimiter
, pass_next
, isbrk
;
916 char quote_char
, *brkchars
;
919 found_quote
= delimiter
= 0;
923 if (rl_completion_word_break_hook
)
924 brkchars
= (*rl_completion_word_break_hook
) ();
926 brkchars
= rl_completer_word_break_characters
;
928 if (rl_completer_quote_characters
)
930 /* We have a list of characters which can be used in pairs to
931 quote substrings for the completer. Try to find the start
932 of an unclosed quoted substring. */
933 /* FOUND_QUOTE is set so we know what kind of quotes we found. */
934 for (scan
= pass_next
= 0; scan
< end
; scan
= MB_NEXTCHAR (rl_line_buffer
, scan
, 1, MB_FIND_ANY
))
942 /* Shell-like semantics for single quotes -- don't allow backslash
943 to quote anything in single quotes, especially not the closing
944 quote. If you don't like this, take out the check on the value
946 if (quote_char
!= '\'' && rl_line_buffer
[scan
] == '\\')
949 found_quote
|= RL_QF_BACKSLASH
;
953 if (quote_char
!= '\0')
955 /* Ignore everything until the matching close quote char. */
956 if (rl_line_buffer
[scan
] == quote_char
)
958 /* Found matching close. Abandon this substring. */
963 else if (strchr (rl_completer_quote_characters
, rl_line_buffer
[scan
]))
965 /* Found start of a quoted substring. */
966 quote_char
= rl_line_buffer
[scan
];
968 /* Shell-like quoting conventions. */
969 if (quote_char
== '\'')
970 found_quote
|= RL_QF_SINGLE_QUOTE
;
971 else if (quote_char
== '"')
972 found_quote
|= RL_QF_DOUBLE_QUOTE
;
974 found_quote
|= RL_QF_OTHER_QUOTE
;
979 if (rl_point
== end
&& quote_char
== '\0')
981 /* We didn't find an unclosed quoted substring upon which to do
982 completion, so use the word break characters to find the
983 substring on which to complete. */
984 while (rl_point
= MB_PREVCHAR (rl_line_buffer
, rl_point
, MB_FIND_ANY
))
986 scan
= rl_line_buffer
[rl_point
];
988 if (strchr (brkchars
, scan
) == 0)
991 /* Call the application-specific function to tell us whether
992 this word break character is quoted and should be skipped. */
993 if (rl_char_is_quoted_p
&& found_quote
&&
994 (*rl_char_is_quoted_p
) (rl_line_buffer
, rl_point
))
997 /* Convoluted code, but it avoids an n^2 algorithm with calls
998 to char_is_quoted. */
1003 /* If we are at an unquoted word break, then advance past it. */
1004 scan
= rl_line_buffer
[rl_point
];
1006 /* If there is an application-specific function to say whether or not
1007 a character is quoted and we found a quote character, let that
1008 function decide whether or not a character is a word break, even
1009 if it is found in rl_completer_word_break_characters. Don't bother
1010 if we're at the end of the line, though. */
1013 if (rl_char_is_quoted_p
)
1014 isbrk
= (found_quote
== 0 ||
1015 (*rl_char_is_quoted_p
) (rl_line_buffer
, rl_point
) == 0) &&
1016 strchr (brkchars
, scan
) != 0;
1018 isbrk
= strchr (brkchars
, scan
) != 0;
1022 /* If the character that caused the word break was a quoting
1023 character, then remember it as the delimiter. */
1024 if (rl_basic_quote_characters
&&
1025 strchr (rl_basic_quote_characters
, scan
) &&
1026 (end
- rl_point
) > 1)
1029 /* If the character isn't needed to determine something special
1030 about what kind of completion to perform, then advance past it. */
1031 if (rl_special_prefixes
== 0 || strchr (rl_special_prefixes
, scan
) == 0)
1041 return (quote_char
);
1045 gen_completion_matches (text
, start
, end
, our_func
, found_quote
, quote_char
)
1048 rl_compentry_func_t
*our_func
;
1049 int found_quote
, quote_char
;
1053 rl_completion_found_quote
= found_quote
;
1054 rl_completion_quote_character
= quote_char
;
1056 /* If the user wants to TRY to complete, but then wants to give
1057 up and use the default completion function, they set the
1058 variable rl_attempted_completion_function. */
1059 if (rl_attempted_completion_function
)
1061 _rl_interrupt_immediately
++;
1062 matches
= (*rl_attempted_completion_function
) (text
, start
, end
);
1063 if (_rl_interrupt_immediately
> 0)
1064 _rl_interrupt_immediately
--;
1066 if (matches
|| rl_attempted_completion_over
)
1068 rl_attempted_completion_over
= 0;
1073 /* XXX -- filename dequoting moved into rl_filename_completion_function */
1075 matches
= rl_completion_matches (text
, our_func
);
1079 /* Filter out duplicates in MATCHES. This frees up the strings in
1082 remove_duplicate_matches (matches
)
1085 char *lowest_common
;
1090 /* Sort the items. */
1091 for (i
= 0; matches
[i
]; i
++)
1094 /* Sort the array without matches[0], since we need it to
1095 stay in place no matter what. */
1096 if (i
&& rl_sort_completion_matches
)
1097 qsort (matches
+1, i
-1, sizeof (char *), (QSFUNC
*)_rl_qsort_string_compare
);
1099 /* Remember the lowest common denominator for it may be unique. */
1100 lowest_common
= savestring (matches
[0]);
1102 for (i
= newlen
= 0; matches
[i
+ 1]; i
++)
1104 if (strcmp (matches
[i
], matches
[i
+ 1]) == 0)
1107 matches
[i
] = (char *)&dead_slot
;
1113 /* We have marked all the dead slots with (char *)&dead_slot.
1114 Copy all the non-dead entries into a new array. */
1115 temp_array
= (char **)xmalloc ((3 + newlen
) * sizeof (char *));
1116 for (i
= j
= 1; matches
[i
]; i
++)
1118 if (matches
[i
] != (char *)&dead_slot
)
1119 temp_array
[j
++] = matches
[i
];
1121 temp_array
[j
] = (char *)NULL
;
1123 if (matches
[0] != (char *)&dead_slot
)
1126 /* Place the lowest common denominator back in [0]. */
1127 temp_array
[0] = lowest_common
;
1129 /* If there is one string left, and it is identical to the
1130 lowest common denominator, then the LCD is the string to
1132 if (j
== 2 && strcmp (temp_array
[0], temp_array
[1]) == 0)
1134 xfree (temp_array
[1]);
1135 temp_array
[1] = (char *)NULL
;
1137 return (temp_array
);
1140 /* Find the common prefix of the list of matches, and put it into
1143 compute_lcd_of_matches (match_list
, matches
, text
)
1148 register int i
, c1
, c2
, si
;
1149 int low
; /* Count of max-matched characters. */
1150 char *dtext
; /* dequoted TEXT, if needed */
1151 #if defined (HANDLE_MULTIBYTE)
1157 /* If only one match, just use that. Otherwise, compare each
1158 member of the list with the next, finding out where they
1162 match_list
[0] = match_list
[1];
1163 match_list
[1] = (char *)NULL
;
1167 for (i
= 1, low
= 100000; i
< matches
; i
++)
1169 #if defined (HANDLE_MULTIBYTE)
1170 if (MB_CUR_MAX
> 1 && rl_byte_oriented
== 0)
1172 memset (&ps1
, 0, sizeof (mbstate_t));
1173 memset (&ps2
, 0, sizeof (mbstate_t));
1176 if (_rl_completion_case_fold
)
1179 (c1
= _rl_to_lower(match_list
[i
][si
])) &&
1180 (c2
= _rl_to_lower(match_list
[i
+ 1][si
]));
1182 #if defined (HANDLE_MULTIBYTE)
1183 if (MB_CUR_MAX
> 1 && rl_byte_oriented
== 0)
1185 v
= mbrtowc (&wc1
, match_list
[i
]+si
, strlen (match_list
[i
]+si
), &ps1
);
1186 mbrtowc (&wc2
, match_list
[i
+1]+si
, strlen (match_list
[i
+1]+si
), &ps2
);
1187 wc1
= towlower (wc1
);
1188 wc2
= towlower (wc2
);
1202 (c1
= match_list
[i
][si
]) &&
1203 (c2
= match_list
[i
+ 1][si
]);
1205 #if defined (HANDLE_MULTIBYTE)
1206 if (MB_CUR_MAX
> 1 && rl_byte_oriented
== 0)
1210 if (!_rl_compare_chars (match_list
[i
], si
, &ps1
, match_list
[i
+1], si
, &ps2
))
1212 else if ((v
= _rl_get_char_len (&match_list
[i
][si
], &ps_back
)) > 1)
1225 /* If there were multiple matches, but none matched up to even the
1226 first character, and the user typed something, use that as the
1227 value of matches[0]. */
1228 if (low
== 0 && text
&& *text
)
1230 match_list
[0] = (char *)xmalloc (strlen (text
) + 1);
1231 strcpy (match_list
[0], text
);
1235 match_list
[0] = (char *)xmalloc (low
+ 1);
1237 /* XXX - this might need changes in the presence of multibyte chars */
1239 /* If we are ignoring case, try to preserve the case of the string
1240 the user typed in the face of multiple matches differing in case. */
1241 if (_rl_completion_case_fold
)
1243 /* We're making an assumption here:
1244 IF we're completing filenames AND
1245 the application has defined a filename dequoting function AND
1246 we found a quote character AND
1247 the application has requested filename quoting
1249 we assume that TEXT was dequoted before checking against
1250 the file system and needs to be dequoted here before we
1251 check against the list of matches
1253 dtext
= (char *)NULL
;
1254 if (rl_filename_completion_desired
&&
1255 rl_filename_dequoting_function
&&
1256 rl_completion_found_quote
&&
1257 rl_filename_quoting_desired
)
1259 dtext
= (*rl_filename_dequoting_function
) ((char *)text
, rl_completion_quote_character
);
1263 /* sort the list to get consistent answers. */
1264 qsort (match_list
+1, matches
, sizeof(char *), (QSFUNC
*)_rl_qsort_string_compare
);
1269 for (i
= 1; i
<= matches
; i
++)
1270 if (strncmp (match_list
[i
], text
, si
) == 0)
1272 strncpy (match_list
[0], match_list
[i
], low
);
1275 /* no casematch, use first entry */
1277 strncpy (match_list
[0], match_list
[1], low
);
1280 /* otherwise, just use the text the user typed. */
1281 strncpy (match_list
[0], text
, low
);
1286 strncpy (match_list
[0], match_list
[1], low
);
1288 match_list
[0][low
] = '\0';
1295 postprocess_matches (matchesp
, matching_filenames
)
1297 int matching_filenames
;
1299 char *t
, **matches
, **temp_matches
;
1302 matches
= *matchesp
;
1307 /* It seems to me that in all the cases we handle we would like
1308 to ignore duplicate possiblilities. Scan for the text to
1309 insert being identical to the other completions. */
1310 if (rl_ignore_completion_duplicates
)
1312 temp_matches
= remove_duplicate_matches (matches
);
1314 matches
= temp_matches
;
1317 /* If we are matching filenames, then here is our chance to
1318 do clever processing by re-examining the list. Call the
1319 ignore function with the array as a parameter. It can
1320 munge the array, deleting matches as it desires. */
1321 if (rl_ignore_some_completions_function
&& matching_filenames
)
1323 for (nmatch
= 1; matches
[nmatch
]; nmatch
++)
1325 (void)(*rl_ignore_some_completions_function
) (matches
);
1326 if (matches
== 0 || matches
[0] == 0)
1329 *matchesp
= (char **)0;
1334 /* If we removed some matches, recompute the common prefix. */
1335 for (i
= 1; matches
[i
]; i
++)
1337 if (i
> 1 && i
< nmatch
)
1340 compute_lcd_of_matches (matches
, i
- 1, t
);
1346 *matchesp
= matches
;
1351 complete_get_screenwidth ()
1356 cols
= _rl_completion_columns
;
1357 if (cols
>= 0 && cols
<= _rl_screenwidth
)
1359 envcols
= getenv ("COLUMNS");
1360 if (envcols
&& *envcols
)
1361 cols
= atoi (envcols
);
1362 if (cols
>= 0 && cols
<= _rl_screenwidth
)
1364 return _rl_screenwidth
;
1367 /* A convenience function for displaying a list of strings in
1368 columnar format on readline's output stream. MATCHES is the list
1369 of strings, in argv format, LEN is the number of strings in MATCHES,
1370 and MAX is the length of the longest string in MATCHES. */
1372 rl_display_match_list (matches
, len
, max
)
1376 int count
, limit
, printed_len
, lines
, cols
;
1377 int i
, j
, k
, l
, common_length
, sind
;
1380 /* Find the length of the prefix common to all items: length as displayed
1381 characters (common_length) and as a byte index into the matches (sind) */
1382 common_length
= sind
= 0;
1383 if (_rl_completion_prefix_display_length
> 0)
1385 t
= printable_part (matches
[0]);
1386 temp
= strrchr (t
, '/');
1387 common_length
= temp
? fnwidth (temp
) : fnwidth (t
);
1388 sind
= temp
? strlen (temp
) : strlen (t
);
1390 if (common_length
> _rl_completion_prefix_display_length
&& common_length
> ELLIPSIS_LEN
)
1391 max
-= common_length
- ELLIPSIS_LEN
;
1393 common_length
= sind
= 0;
1396 /* How many items of MAX length can we fit in the screen window? */
1397 cols
= complete_get_screenwidth ();
1400 if (limit
!= 1 && (limit
* max
== cols
))
1403 /* If cols == 0, limit will end up -1 */
1404 if (cols
< _rl_screenwidth
&& limit
< 0)
1407 /* Avoid a possible floating exception. If max > cols,
1408 limit will be 0 and a divide-by-zero fault will result. */
1412 /* How many iterations of the printing loop? */
1413 count
= (len
+ (limit
- 1)) / limit
;
1415 /* Watch out for special case. If LEN is less than LIMIT, then
1416 just do the inner printing loop.
1417 0 < len <= limit implies count = 1. */
1419 /* Sort the items if they are not already sorted. */
1420 if (rl_ignore_completion_duplicates
== 0 && rl_sort_completion_matches
)
1421 qsort (matches
+ 1, len
, sizeof (char *), (QSFUNC
*)_rl_qsort_string_compare
);
1426 if (_rl_print_completions_horizontally
== 0)
1428 /* Print the sorted items, up-and-down alphabetically, like ls. */
1429 for (i
= 1; i
<= count
; i
++)
1431 for (j
= 0, l
= i
; j
< limit
; j
++)
1433 if (l
> len
|| matches
[l
] == 0)
1437 temp
= printable_part (matches
[l
]);
1438 printed_len
= print_filename (temp
, matches
[l
], sind
);
1441 for (k
= 0; k
< max
- printed_len
; k
++)
1442 putc (' ', rl_outstream
);
1448 if (_rl_page_completions
&& lines
>= (_rl_screenheight
- 1) && i
< count
)
1450 lines
= _rl_internal_pager (lines
);
1458 /* Print the sorted items, across alphabetically, like ls -x. */
1459 for (i
= 1; matches
[i
]; i
++)
1461 temp
= printable_part (matches
[i
]);
1462 printed_len
= print_filename (temp
, matches
[i
], sind
);
1463 /* Have we reached the end of this line? */
1466 if (i
&& (limit
> 1) && (i
% limit
) == 0)
1470 if (_rl_page_completions
&& lines
>= _rl_screenheight
- 1)
1472 lines
= _rl_internal_pager (lines
);
1478 for (k
= 0; k
< max
- printed_len
; k
++)
1479 putc (' ', rl_outstream
);
1486 /* Display MATCHES, a list of matching filenames in argv format. This
1487 handles the simple case -- a single match -- first. If there is more
1488 than one match, we compute the number of strings in the list and the
1489 length of the longest string, which will be needed by the display
1490 function. If the application wants to handle displaying the list of
1491 matches itself, it sets RL_COMPLETION_DISPLAY_MATCHES_HOOK to the
1492 address of a function, and we just call it. If we're handling the
1493 display ourselves, we just call rl_display_match_list. We also check
1494 that the list of matches doesn't exceed the user-settable threshold,
1495 and ask the user if he wants to see the list if there are more matches
1496 than RL_COMPLETION_QUERY_ITEMS. */
1498 display_matches (matches
)
1504 /* Move to the last visible line of a possibly-multiple-line command. */
1505 _rl_move_vert (_rl_vis_botlin
);
1507 /* Handle simple case first. What if there is only one answer? */
1508 if (matches
[1] == 0)
1510 temp
= printable_part (matches
[0]);
1512 print_filename (temp
, matches
[0], 0);
1515 rl_forced_update_display ();
1516 rl_display_fixed
= 1;
1521 /* There is more than one answer. Find out how many there are,
1522 and find the maximum printed length of a single entry. */
1523 for (max
= 0, i
= 1; matches
[i
]; i
++)
1525 temp
= printable_part (matches
[i
]);
1526 len
= fnwidth (temp
);
1534 /* If the caller has defined a display hook, then call that now. */
1535 if (rl_completion_display_matches_hook
)
1537 (*rl_completion_display_matches_hook
) (matches
, len
, max
);
1541 /* If there are many items, then ask the user if she really wants to
1543 if (rl_completion_query_items
> 0 && len
>= rl_completion_query_items
)
1546 fprintf (rl_outstream
, "Display all %d possibilities? (y or n)", len
);
1547 fflush (rl_outstream
);
1548 if ((completion_y_or_n
= get_y_or_n (0)) == 0)
1552 rl_forced_update_display ();
1553 rl_display_fixed
= 1;
1559 rl_display_match_list (matches
, len
, max
);
1561 rl_forced_update_display ();
1562 rl_display_fixed
= 1;
1566 make_quoted_replacement (match
, mtype
, qc
)
1569 char *qc
; /* Pointer to quoting character, if any */
1571 int should_quote
, do_replace
;
1574 /* If we are doing completion on quoted substrings, and any matches
1575 contain any of the completer_word_break_characters, then auto-
1576 matically prepend the substring with a quote character (just pick
1577 the first one from the list of such) if it does not already begin
1578 with a quote string. FIXME: Need to remove any such automatically
1579 inserted quote character when it no longer is necessary, such as
1580 if we change the string we are completing on and the new set of
1581 matches don't require a quoted substring. */
1582 replacement
= match
;
1584 should_quote
= match
&& rl_completer_quote_characters
&&
1585 rl_filename_completion_desired
&&
1586 rl_filename_quoting_desired
;
1589 should_quote
= should_quote
&& (!qc
|| !*qc
||
1590 (rl_completer_quote_characters
&& strchr (rl_completer_quote_characters
, *qc
)));
1594 /* If there is a single match, see if we need to quote it.
1595 This also checks whether the common prefix of several
1596 matches needs to be quoted. */
1597 should_quote
= rl_filename_quote_characters
1598 ? (_rl_strpbrk (match
, rl_filename_quote_characters
) != 0)
1601 do_replace
= should_quote
? mtype
: NO_MATCH
;
1602 /* Quote the replacement, since we found an embedded
1603 word break character in a potential match. */
1604 if (do_replace
!= NO_MATCH
&& rl_filename_quoting_function
)
1605 replacement
= (*rl_filename_quoting_function
) (match
, do_replace
, qc
);
1607 return (replacement
);
1611 insert_match (match
, start
, mtype
, qc
)
1616 char *replacement
, *r
;
1620 oqc
= qc
? *qc
: '\0';
1621 replacement
= make_quoted_replacement (match
, mtype
, qc
);
1623 /* Now insert the match. */
1626 rlen
= strlen (replacement
);
1627 /* Don't double an opening quote character. */
1628 if (qc
&& *qc
&& start
&& rl_line_buffer
[start
- 1] == *qc
&&
1629 replacement
[0] == *qc
)
1631 /* If make_quoted_replacement changed the quoting character, remove
1632 the opening quote and insert the (fully-quoted) replacement. */
1633 else if (qc
&& (*qc
!= oqc
) && start
&& rl_line_buffer
[start
- 1] == oqc
&&
1634 replacement
[0] != oqc
)
1637 /* Don't double a closing quote character */
1638 if (qc
&& *qc
&& end
&& rl_line_buffer
[rl_point
] == *qc
&& replacement
[rlen
- 1] == *qc
)
1640 if (_rl_skip_completed_text
)
1643 while (start
< rl_end
&& *r
&& rl_line_buffer
[start
] == *r
)
1648 if (start
<= end
|| *r
)
1649 _rl_replace_text (r
, start
, end
);
1650 rl_point
= start
+ strlen (r
);
1653 _rl_replace_text (replacement
, start
, end
);
1654 if (replacement
!= match
)
1655 xfree (replacement
);
1659 /* Append any necessary closing quote and a separator character to the
1660 just-inserted match. If the user has specified that directories
1661 should be marked by a trailing `/', append one of those instead. The
1662 default trailing character is a space. Returns the number of characters
1663 appended. If NONTRIVIAL_MATCH is set, we test for a symlink (if the OS
1664 has them) and don't add a suffix for a symlink to a directory. A
1665 nontrivial match is one that actually adds to the word being completed.
1666 The variable rl_completion_mark_symlink_dirs controls this behavior
1667 (it's initially set to the what the user has chosen, indicated by the
1668 value of _rl_complete_mark_symlink_dirs, but may be modified by an
1669 application's completion function). */
1671 append_to_match (text
, delimiter
, quote_char
, nontrivial_match
)
1673 int delimiter
, quote_char
, nontrivial_match
;
1675 char temp_string
[4], *filename
;
1676 int temp_string_index
, s
;
1679 temp_string_index
= 0;
1680 if (quote_char
&& rl_point
&& rl_completion_suppress_quote
== 0 &&
1681 rl_line_buffer
[rl_point
- 1] != quote_char
)
1682 temp_string
[temp_string_index
++] = quote_char
;
1685 temp_string
[temp_string_index
++] = delimiter
;
1686 else if (rl_completion_suppress_append
== 0 && rl_completion_append_character
)
1687 temp_string
[temp_string_index
++] = rl_completion_append_character
;
1689 temp_string
[temp_string_index
++] = '\0';
1691 if (rl_filename_completion_desired
)
1693 filename
= tilde_expand (text
);
1694 s
= (nontrivial_match
&& rl_completion_mark_symlink_dirs
== 0)
1695 ? LSTAT (filename
, &finfo
)
1696 : stat (filename
, &finfo
);
1697 if (s
== 0 && S_ISDIR (finfo
.st_mode
))
1699 if (_rl_complete_mark_directories
/* && rl_completion_suppress_append == 0 */)
1701 /* This is clumsy. Avoid putting in a double slash if point
1702 is at the end of the line and the previous character is a
1704 if (rl_point
&& rl_line_buffer
[rl_point
] == '\0' && rl_line_buffer
[rl_point
- 1] == '/')
1706 else if (rl_line_buffer
[rl_point
] != '/')
1707 rl_insert_text ("/");
1711 /* Don't add anything if the filename is a symlink and resolves to a
1713 else if (s
== 0 && S_ISLNK (finfo
.st_mode
) &&
1714 stat (filename
, &finfo
) == 0 && S_ISDIR (finfo
.st_mode
))
1719 if (rl_point
== rl_end
&& temp_string_index
)
1720 rl_insert_text (temp_string
);
1726 if (rl_point
== rl_end
&& temp_string_index
)
1727 rl_insert_text (temp_string
);
1730 return (temp_string_index
);
1734 insert_all_matches (matches
, point
, qc
)
1742 rl_begin_undo_group ();
1743 /* remove any opening quote character; make_quoted_replacement will add
1745 if (qc
&& *qc
&& point
&& rl_line_buffer
[point
- 1] == *qc
)
1747 rl_delete_text (point
, rl_point
);
1752 for (i
= 1; matches
[i
]; i
++)
1754 rp
= make_quoted_replacement (matches
[i
], SINGLE_MATCH
, qc
);
1755 rl_insert_text (rp
);
1756 rl_insert_text (" ");
1757 if (rp
!= matches
[i
])
1763 rp
= make_quoted_replacement (matches
[0], SINGLE_MATCH
, qc
);
1764 rl_insert_text (rp
);
1765 rl_insert_text (" ");
1766 if (rp
!= matches
[0])
1769 rl_end_undo_group ();
1773 _rl_free_match_list (matches
)
1781 for (i
= 0; matches
[i
]; i
++)
1786 /* Complete the word at or before point.
1787 WHAT_TO_DO says what to do with the completion.
1788 `?' means list the possible completions.
1789 TAB means do standard completion.
1790 `*' means insert all of the possible completions.
1791 `!' means to do standard completion, and list all possible completions if
1792 there is more than one.
1793 `@' means to do standard completion, and list all possible completions if
1794 there is more than one and partial completion is not possible. */
1796 rl_complete_internal (what_to_do
)
1800 rl_compentry_func_t
*our_func
;
1801 int start
, end
, delimiter
, found_quote
, i
, nontrivial_lcd
;
1802 char *text
, *saved_line_buffer
;
1808 RL_SETSTATE(RL_STATE_COMPLETING
);
1810 set_completion_defaults (what_to_do
);
1812 saved_line_buffer
= rl_line_buffer
? savestring (rl_line_buffer
) : (char *)NULL
;
1813 our_func
= rl_completion_entry_function
1814 ? rl_completion_entry_function
1815 : rl_filename_completion_function
;
1816 /* We now look backwards for the start of a filename/variable word. */
1818 found_quote
= delimiter
= 0;
1822 /* This (possibly) changes rl_point. If it returns a non-zero char,
1823 we know we have an open quote. */
1824 quote_char
= _rl_find_completion_word (&found_quote
, &delimiter
);
1829 text
= rl_copy_text (start
, end
);
1830 matches
= gen_completion_matches (text
, start
, end
, our_func
, found_quote
, quote_char
);
1831 /* nontrivial_lcd is set if the common prefix adds something to the word
1833 nontrivial_lcd
= matches
&& strcmp (text
, matches
[0]) != 0;
1835 if (what_to_do
== '!' || what_to_do
== '@')
1836 tlen
= strlen (text
);
1843 FREE (saved_line_buffer
);
1844 completion_changed_buffer
= 0;
1845 RL_UNSETSTATE(RL_STATE_COMPLETING
);
1846 _rl_reset_completion_state ();
1850 /* If we are matching filenames, the attempted completion function will
1851 have set rl_filename_completion_desired to a non-zero value. The basic
1852 rl_filename_completion_function does this. */
1853 i
= rl_filename_completion_desired
;
1855 if (postprocess_matches (&matches
, i
) == 0)
1858 FREE (saved_line_buffer
);
1859 completion_changed_buffer
= 0;
1860 RL_UNSETSTATE(RL_STATE_COMPLETING
);
1861 _rl_reset_completion_state ();
1870 /* Insert the first match with proper quoting. */
1873 insert_match (matches
[0], start
, matches
[1] ? MULT_MATCH
: SINGLE_MATCH
, "e_char
);
1875 if (what_to_do
== TAB
)
1878 insert_match (matches
[0], start
, matches
[1] ? MULT_MATCH
: SINGLE_MATCH
, "e_char
);
1880 else if (*matches
[0] && matches
[1] == 0)
1881 /* should we perform the check only if there are multiple matches? */
1882 insert_match (matches
[0], start
, matches
[1] ? MULT_MATCH
: SINGLE_MATCH
, "e_char
);
1883 else if (*matches
[0]) /* what_to_do != TAB && multiple matches */
1885 mlen
= *matches
[0] ? strlen (matches
[0]) : 0;
1887 insert_match (matches
[0], start
, matches
[1] ? MULT_MATCH
: SINGLE_MATCH
, "e_char
);
1891 /* If there are more matches, ring the bell to indicate.
1892 If we are in vi mode, Posix.2 says to not ring the bell.
1893 If the `show-all-if-ambiguous' variable is set, display
1894 all the matches immediately. Otherwise, if this was the
1895 only match, and we are hacking files, check the file to
1896 see if it was a directory. If so, and the `mark-directories'
1897 variable is set, add a '/' to the name. If not, and we
1898 are at the end of the line, then add a space. */
1901 if (what_to_do
== '!')
1903 display_matches (matches
);
1906 else if (what_to_do
== '@')
1908 if (nontrivial_lcd
== 0)
1909 display_matches (matches
);
1912 else if (rl_editing_mode
!= vi_mode
)
1913 rl_ding (); /* There are other matches remaining. */
1916 append_to_match (matches
[0], delimiter
, quote_char
, nontrivial_lcd
);
1921 insert_all_matches (matches
, start
, "e_char
);
1925 display_matches (matches
);
1929 _rl_ttymsg ("bad value %d for what_to_do in rl_complete", what_to_do
);
1931 FREE (saved_line_buffer
);
1932 RL_UNSETSTATE(RL_STATE_COMPLETING
);
1933 _rl_reset_completion_state ();
1937 _rl_free_match_list (matches
);
1939 /* Check to see if the line has changed through all of this manipulation. */
1940 if (saved_line_buffer
)
1942 completion_changed_buffer
= strcmp (rl_line_buffer
, saved_line_buffer
) != 0;
1943 xfree (saved_line_buffer
);
1946 RL_UNSETSTATE(RL_STATE_COMPLETING
);
1947 _rl_reset_completion_state ();
1951 /***************************************************************/
1953 /* Application-callable completion match generator functions */
1955 /***************************************************************/
1957 /* Return an array of (char *) which is a list of completions for TEXT.
1958 If there are no completions, return a NULL pointer.
1959 The first entry in the returned array is the substitution for TEXT.
1960 The remaining entries are the possible completions.
1961 The array is terminated with a NULL pointer.
1963 ENTRY_FUNCTION is a function of two args, and returns a (char *).
1964 The first argument is TEXT.
1965 The second is a state argument; it should be zero on the first call, and
1966 non-zero on subsequent calls. It returns a NULL pointer to the caller
1967 when there are no more matches.
1970 rl_completion_matches (text
, entry_function
)
1972 rl_compentry_func_t
*entry_function
;
1974 /* Number of slots in match_list. */
1975 int match_list_size
;
1977 /* The list of matches. */
1980 /* Number of matches actually found. */
1983 /* Temporary string binder. */
1987 match_list_size
= 10;
1988 match_list
= (char **)xmalloc ((match_list_size
+ 1) * sizeof (char *));
1989 match_list
[1] = (char *)NULL
;
1991 _rl_interrupt_immediately
++;
1992 while (string
= (*entry_function
) (text
, matches
))
1994 if (matches
+ 1 == match_list_size
)
1995 match_list
= (char **)xrealloc
1996 (match_list
, ((match_list_size
+= 10) + 1) * sizeof (char *));
1998 match_list
[++matches
] = string
;
1999 match_list
[matches
+ 1] = (char *)NULL
;
2001 if (_rl_interrupt_immediately
> 0)
2002 _rl_interrupt_immediately
--;
2004 /* If there were any matches, then look through them finding out the
2005 lowest common denominator. That then becomes match_list[0]. */
2007 compute_lcd_of_matches (match_list
, matches
, text
);
2008 else /* There were no matches. */
2011 match_list
= (char **)NULL
;
2013 return (match_list
);
2016 /* A completion function for usernames.
2017 TEXT contains a partial username preceded by a random
2018 character (usually `~'). */
2020 rl_username_completion_function (text
, state
)
2024 #if defined (__WIN32__) || defined (__OPENNT)
2025 return (char *)NULL
;
2026 #else /* !__WIN32__ && !__OPENNT) */
2027 static char *username
= (char *)NULL
;
2028 static struct passwd
*entry
;
2029 static int namelen
, first_char
, first_char_loc
;
2037 first_char_loc
= first_char
== '~';
2039 username
= savestring (&text
[first_char_loc
]);
2040 namelen
= strlen (username
);
2044 #if defined (HAVE_GETPWENT)
2045 while (entry
= getpwent ())
2047 /* Null usernames should result in all users as possible completions. */
2048 if (namelen
== 0 || (STREQN (username
, entry
->pw_name
, namelen
)))
2055 #if defined (HAVE_GETPWENT)
2058 return ((char *)NULL
);
2062 value
= (char *)xmalloc (2 + strlen (entry
->pw_name
));
2066 strcpy (value
+ first_char_loc
, entry
->pw_name
);
2068 if (first_char
== '~')
2069 rl_filename_completion_desired
= 1;
2073 #endif /* !__WIN32__ && !__OPENNT */
2076 /* Return non-zero if CONVFN matches FILENAME up to the length of FILENAME
2077 (FILENAME_LEN). If _rl_completion_case_fold is set, compare without
2078 regard to the alphabetic case of characters. CONVFN is the possibly-
2079 converted directory entry; FILENAME is what the user typed. */
2081 complete_fncmp (convfn
, convlen
, filename
, filename_len
)
2084 const char *filename
;
2087 register char *s1
, *s2
;
2090 /* Otherwise, if these match up to the length of filename, then
2092 if (_rl_completion_case_fold
&& _rl_completion_case_map
)
2094 /* Case-insensitive comparison treating _ and - as equivalent */
2095 if (filename_len
== 0)
2097 if (convlen
< filename_len
)
2099 s1
= (char *)convfn
;
2100 s2
= (char *)filename
;
2104 d
= _rl_to_lower (*s1
) - _rl_to_lower (*s2
);
2105 /* *s1 == [-_] && *s2 == [-_] */
2106 if ((*s1
== '-' || *s1
== '_') && (*s2
== '-' || *s2
== '_'))
2110 s1
++; s2
++; /* already checked convlen >= filename_len */
2115 else if (_rl_completion_case_fold
)
2117 if ((_rl_to_lower (convfn
[0]) == _rl_to_lower (filename
[0])) &&
2118 (convlen
>= filename_len
) &&
2119 (_rl_strnicmp (filename
, convfn
, filename_len
) == 0))
2124 if ((convfn
[0] == filename
[0]) &&
2125 (convlen
>= filename_len
) &&
2126 (strncmp (filename
, convfn
, filename_len
) == 0))
2132 /* Okay, now we write the entry_function for filename completion. In the
2133 general case. Note that completion in the shell is a little different
2134 because of all the pathnames that must be followed when looking up the
2135 completion for a command. */
2137 rl_filename_completion_function (text
, state
)
2141 static DIR *directory
= (DIR *)NULL
;
2142 static char *filename
= (char *)NULL
;
2143 static char *dirname
= (char *)NULL
;
2144 static char *users_dirname
= (char *)NULL
;
2145 static int filename_len
;
2146 char *temp
, *dentry
, *convfn
;
2147 int dirlen
, dentlen
, convlen
;
2148 struct dirent
*entry
;
2150 /* If we don't have any state, then do some initialization. */
2153 /* If we were interrupted before closing the directory or reading
2154 all of its contents, close it. */
2157 closedir (directory
);
2158 directory
= (DIR *)NULL
;
2162 FREE (users_dirname
);
2164 filename
= savestring (text
);
2167 dirname
= savestring (text
);
2169 temp
= strrchr (dirname
, '/');
2171 #if defined (__MSDOS__)
2172 /* special hack for //X/... */
2173 if (dirname
[0] == '/' && dirname
[1] == '/' && ISALPHA ((unsigned char)dirname
[2]) && dirname
[3] == '/')
2174 temp
= strrchr (dirname
+ 3, '/');
2179 strcpy (filename
, ++temp
);
2182 #if defined (__MSDOS__)
2183 /* searches from current directory on the drive */
2184 else if (ISALPHA ((unsigned char)dirname
[0]) && dirname
[1] == ':')
2186 strcpy (filename
, dirname
+ 2);
2196 /* We aren't done yet. We also support the "~user" syntax. */
2198 /* Save the version of the directory that the user typed. */
2199 users_dirname
= savestring (dirname
);
2201 if (*dirname
== '~')
2203 temp
= tilde_expand (dirname
);
2208 if (rl_directory_rewrite_hook
)
2209 (*rl_directory_rewrite_hook
) (&dirname
);
2211 /* The directory completion hook should perform any necessary
2213 if (rl_directory_completion_hook
&& (*rl_directory_completion_hook
) (&dirname
))
2215 xfree (users_dirname
);
2216 users_dirname
= savestring (dirname
);
2218 else if (rl_completion_found_quote
&& rl_filename_dequoting_function
)
2220 /* delete single and double quotes */
2221 temp
= (*rl_filename_dequoting_function
) (dirname
, rl_completion_quote_character
);
2225 directory
= opendir (dirname
);
2227 /* Now dequote a non-null filename. */
2228 if (filename
&& *filename
&& rl_completion_found_quote
&& rl_filename_dequoting_function
)
2230 /* delete single and double quotes */
2231 temp
= (*rl_filename_dequoting_function
) (filename
, rl_completion_quote_character
);
2235 filename_len
= strlen (filename
);
2237 rl_filename_completion_desired
= 1;
2240 /* At this point we should entertain the possibility of hacking wildcarded
2241 filenames, like /usr/man/man<WILD>/te<TAB>. If the directory name
2242 contains globbing characters, then build an array of directories, and
2243 then map over that list while completing. */
2244 /* *** UNIMPLEMENTED *** */
2246 /* Now that we have some state, we can read the directory. */
2248 entry
= (struct dirent
*)NULL
;
2249 while (directory
&& (entry
= readdir (directory
)))
2251 convfn
= dentry
= entry
->d_name
;
2252 convlen
= dentlen
= D_NAMLEN (entry
);
2254 if (rl_filename_rewrite_hook
)
2256 convfn
= (*rl_filename_rewrite_hook
) (dentry
, dentlen
);
2257 convlen
= (convfn
== dentry
) ? dentlen
: strlen (convfn
);
2260 /* Special case for no filename. If the user has disabled the
2261 `match-hidden-files' variable, skip filenames beginning with `.'.
2262 All other entries except "." and ".." match. */
2263 if (filename_len
== 0)
2265 if (_rl_match_hidden_files
== 0 && HIDDEN_FILE (convfn
))
2268 if (convfn
[0] != '.' ||
2269 (convfn
[1] && (convfn
[1] != '.' || convfn
[2])))
2274 if (complete_fncmp (convfn
, convlen
, filename
, filename_len
))
2283 closedir (directory
);
2284 directory
= (DIR *)NULL
;
2289 dirname
= (char *)NULL
;
2294 filename
= (char *)NULL
;
2298 xfree (users_dirname
);
2299 users_dirname
= (char *)NULL
;
2302 return (char *)NULL
;
2306 /* dirname && (strcmp (dirname, ".") != 0) */
2307 if (dirname
&& (dirname
[0] != '.' || dirname
[1]))
2309 if (rl_complete_with_tilde_expansion
&& *users_dirname
== '~')
2311 dirlen
= strlen (dirname
);
2312 temp
= (char *)xmalloc (2 + dirlen
+ D_NAMLEN (entry
));
2313 strcpy (temp
, dirname
);
2314 /* Canonicalization cuts off any final slash present. We
2315 may need to add it back. */
2316 if (dirname
[dirlen
- 1] != '/')
2318 temp
[dirlen
++] = '/';
2319 temp
[dirlen
] = '\0';
2324 dirlen
= strlen (users_dirname
);
2325 temp
= (char *)xmalloc (2 + dirlen
+ D_NAMLEN (entry
));
2326 strcpy (temp
, users_dirname
);
2327 /* Make sure that temp has a trailing slash here. */
2328 if (users_dirname
[dirlen
- 1] != '/')
2329 temp
[dirlen
++] = '/';
2332 strcpy (temp
+ dirlen
, convfn
);
2335 temp
= savestring (convfn
);
2337 if (convfn
!= dentry
)
2344 /* An initial implementation of a menu completion function a la tcsh. The
2345 first time (if the last readline command was not rl_old_menu_complete), we
2346 generate the list of matches. This code is very similar to the code in
2347 rl_complete_internal -- there should be a way to combine the two. Then,
2348 for each item in the list of matches, we insert the match in an undoable
2349 fashion, with the appropriate character appended (this happens on the
2350 second and subsequent consecutive calls to rl_old_menu_complete). When we
2351 hit the end of the match list, we restore the original unmatched text,
2352 ring the bell, and reset the counter to zero. */
2354 rl_old_menu_complete (count
, invoking_key
)
2355 int count
, invoking_key
;
2357 rl_compentry_func_t
*our_func
;
2358 int matching_filenames
, found_quote
;
2360 static char *orig_text
;
2361 static char **matches
= (char **)0;
2362 static int match_list_index
= 0;
2363 static int match_list_size
= 0;
2364 static int orig_start
, orig_end
;
2365 static char quote_char
;
2366 static int delimiter
;
2368 /* The first time through, we generate the list of matches and set things
2369 up to insert them. */
2370 if (rl_last_func
!= rl_old_menu_complete
)
2372 /* Clean up from previous call, if any. */
2375 _rl_free_match_list (matches
);
2377 match_list_index
= match_list_size
= 0;
2378 matches
= (char **)NULL
;
2380 rl_completion_invoking_key
= invoking_key
;
2382 RL_SETSTATE(RL_STATE_COMPLETING
);
2384 /* Only the completion entry function can change these. */
2385 set_completion_defaults ('%');
2387 our_func
= rl_menu_completion_entry_function
;
2389 our_func
= rl_completion_entry_function
2390 ? rl_completion_entry_function
2391 : rl_filename_completion_function
;
2393 /* We now look backwards for the start of a filename/variable word. */
2394 orig_end
= rl_point
;
2395 found_quote
= delimiter
= 0;
2399 /* This (possibly) changes rl_point. If it returns a non-zero char,
2400 we know we have an open quote. */
2401 quote_char
= _rl_find_completion_word (&found_quote
, &delimiter
);
2403 orig_start
= rl_point
;
2404 rl_point
= orig_end
;
2406 orig_text
= rl_copy_text (orig_start
, orig_end
);
2407 matches
= gen_completion_matches (orig_text
, orig_start
, orig_end
,
2408 our_func
, found_quote
, quote_char
);
2410 /* If we are matching filenames, the attempted completion function will
2411 have set rl_filename_completion_desired to a non-zero value. The basic
2412 rl_filename_completion_function does this. */
2413 matching_filenames
= rl_filename_completion_desired
;
2415 if (matches
== 0 || postprocess_matches (&matches
, matching_filenames
) == 0)
2419 matches
= (char **)0;
2421 orig_text
= (char *)0;
2422 completion_changed_buffer
= 0;
2423 RL_UNSETSTATE(RL_STATE_COMPLETING
);
2427 RL_UNSETSTATE(RL_STATE_COMPLETING
);
2429 for (match_list_size
= 0; matches
[match_list_size
]; match_list_size
++)
2431 /* matches[0] is lcd if match_list_size > 1, but the circular buffer
2432 code below should take care of it. */
2434 if (match_list_size
> 1 && _rl_complete_show_all
)
2435 display_matches (matches
);
2438 /* Now we have the list of matches. Replace the text between
2439 rl_line_buffer[orig_start] and rl_line_buffer[rl_point] with
2440 matches[match_list_index], and add any necessary closing char. */
2442 if (matches
== 0 || match_list_size
== 0)
2446 matches
= (char **)0;
2447 completion_changed_buffer
= 0;
2451 match_list_index
+= count
;
2452 if (match_list_index
< 0)
2454 while (match_list_index
< 0)
2455 match_list_index
+= match_list_size
;
2458 match_list_index
%= match_list_size
;
2460 if (match_list_index
== 0 && match_list_size
> 1)
2463 insert_match (orig_text
, orig_start
, MULT_MATCH
, "e_char
);
2467 insert_match (matches
[match_list_index
], orig_start
, SINGLE_MATCH
, "e_char
);
2468 append_to_match (matches
[match_list_index
], delimiter
, quote_char
,
2469 strcmp (orig_text
, matches
[match_list_index
]));
2472 completion_changed_buffer
= 1;
2477 rl_menu_complete (count
, ignore
)
2480 rl_compentry_func_t
*our_func
;
2481 int matching_filenames
, found_quote
;
2483 static char *orig_text
;
2484 static char **matches
= (char **)0;
2485 static int match_list_index
= 0;
2486 static int match_list_size
= 0;
2487 static int nontrivial_lcd
= 0;
2488 static int full_completion
= 0; /* set to 1 if menu completion should reinitialize on next call */
2489 static int orig_start
, orig_end
;
2490 static char quote_char
;
2491 static int delimiter
, cstate
;
2493 /* The first time through, we generate the list of matches and set things
2494 up to insert them. */
2495 if ((rl_last_func
!= rl_menu_complete
&& rl_last_func
!= rl_backward_menu_complete
) || full_completion
)
2497 /* Clean up from previous call, if any. */
2500 _rl_free_match_list (matches
);
2502 match_list_index
= match_list_size
= 0;
2503 matches
= (char **)NULL
;
2505 full_completion
= 0;
2507 RL_SETSTATE(RL_STATE_COMPLETING
);
2509 /* Only the completion entry function can change these. */
2510 set_completion_defaults ('%');
2512 our_func
= rl_menu_completion_entry_function
;
2514 our_func
= rl_completion_entry_function
2515 ? rl_completion_entry_function
2516 : rl_filename_completion_function
;
2518 /* We now look backwards for the start of a filename/variable word. */
2519 orig_end
= rl_point
;
2520 found_quote
= delimiter
= 0;
2524 /* This (possibly) changes rl_point. If it returns a non-zero char,
2525 we know we have an open quote. */
2526 quote_char
= _rl_find_completion_word (&found_quote
, &delimiter
);
2528 orig_start
= rl_point
;
2529 rl_point
= orig_end
;
2531 orig_text
= rl_copy_text (orig_start
, orig_end
);
2532 matches
= gen_completion_matches (orig_text
, orig_start
, orig_end
,
2533 our_func
, found_quote
, quote_char
);
2535 nontrivial_lcd
= matches
&& strcmp (orig_text
, matches
[0]) != 0;
2537 /* If we are matching filenames, the attempted completion function will
2538 have set rl_filename_completion_desired to a non-zero value. The basic
2539 rl_filename_completion_function does this. */
2540 matching_filenames
= rl_filename_completion_desired
;
2542 if (matches
== 0 || postprocess_matches (&matches
, matching_filenames
) == 0)
2546 matches
= (char **)0;
2548 orig_text
= (char *)0;
2549 completion_changed_buffer
= 0;
2550 RL_UNSETSTATE(RL_STATE_COMPLETING
);
2554 RL_UNSETSTATE(RL_STATE_COMPLETING
);
2556 for (match_list_size
= 0; matches
[match_list_size
]; match_list_size
++)
2559 if (match_list_size
== 0)
2563 matches
= (char **)0;
2564 match_list_index
= 0;
2565 completion_changed_buffer
= 0;
2569 /* matches[0] is lcd if match_list_size > 1, but the circular buffer
2570 code below should take care of it. */
2573 insert_match (matches
[0], orig_start
, matches
[1] ? MULT_MATCH
: SINGLE_MATCH
, "e_char
);
2574 orig_end
= orig_start
+ strlen (matches
[0]);
2575 completion_changed_buffer
= STREQ (orig_text
, matches
[0]) == 0;
2578 if (match_list_size
> 1 && _rl_complete_show_all
)
2580 display_matches (matches
);
2581 /* If there are so many matches that the user has to be asked
2582 whether or not he wants to see the matches, menu completion
2584 if (rl_completion_query_items
> 0 && match_list_size
>= rl_completion_query_items
)
2588 matches
= (char **)0;
2589 full_completion
= 1;
2593 else if (match_list_size
<= 1)
2595 append_to_match (matches
[0], delimiter
, quote_char
, nontrivial_lcd
);
2596 full_completion
= 1;
2599 else if (_rl_menu_complete_prefix_first
&& match_list_size
> 1)
2606 /* Now we have the list of matches. Replace the text between
2607 rl_line_buffer[orig_start] and rl_line_buffer[rl_point] with
2608 matches[match_list_index], and add any necessary closing char. */
2610 if (matches
== 0 || match_list_size
== 0)
2614 matches
= (char **)0;
2615 completion_changed_buffer
= 0;
2619 match_list_index
+= count
;
2620 if (match_list_index
< 0)
2622 while (match_list_index
< 0)
2623 match_list_index
+= match_list_size
;
2626 match_list_index
%= match_list_size
;
2628 if (match_list_index
== 0 && match_list_size
> 1)
2631 insert_match (matches
[0], orig_start
, MULT_MATCH
, "e_char
);
2635 insert_match (matches
[match_list_index
], orig_start
, SINGLE_MATCH
, "e_char
);
2636 append_to_match (matches
[match_list_index
], delimiter
, quote_char
,
2637 strcmp (orig_text
, matches
[match_list_index
]));
2640 completion_changed_buffer
= 1;
2645 rl_backward_menu_complete (count
, key
)
2648 /* Positive arguments to backward-menu-complete translate into negative
2649 arguments for menu-complete, and vice versa. */
2650 return (rl_menu_complete (-count
, key
));