1: /* complete.c -- filename completion for readline. */
2:
3: /* Copyright (C) 1987-2012 Free Software Foundation, Inc.
4:
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.
7:
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.
12:
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.
17:
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/>.
20: */
21:
22: #define READLINE_LIBRARY
23:
24: #if defined (HAVE_CONFIG_H)
25: # include <config.h>
26: #endif
27:
28: #include <sys/types.h>
29: #include <fcntl.h>
30: #if defined (HAVE_SYS_FILE_H)
31: # include <sys/file.h>
32: #endif
33:
34: #include <signal.h>
35:
36: #if defined (HAVE_UNISTD_H)
37: # include <unistd.h>
38: #endif /* HAVE_UNISTD_H */
39:
40: #if defined (HAVE_STDLIB_H)
41: # include <stdlib.h>
42: #else
43: # include "ansi_stdlib.h"
44: #endif /* HAVE_STDLIB_H */
45:
46: #include <stdio.h>
47:
48: #include <errno.h>
49: #if !defined (errno)
50: extern int errno;
51: #endif /* !errno */
52:
53: #if defined (HAVE_PWD_H)
54: #include <pwd.h>
55: #endif
56:
57: #include "posixdir.h"
58: #include "posixstat.h"
59:
60: /* System-specific feature definitions and include files. */
61: #include "rldefs.h"
62: #include "rlmbutil.h"
63:
64: /* Some standard library routines. */
65: #include "readline.h"
66: #include "xmalloc.h"
67: #include "rlprivate.h"
68:
69: #if defined (COLOR_SUPPORT)
70: # include "colors.h"
71: #endif
72:
73: #ifdef __STDC__
74: typedef int QSFUNC (const void *, const void *);
75: #else
76: typedef int QSFUNC ();
77: #endif
78:
79: #ifdef HAVE_LSTAT
80: # define LSTAT lstat
81: #else
82: # define LSTAT stat
83: #endif
84:
85: /* Unix version of a hidden file. Could be different on other systems. */
86: #define HIDDEN_FILE(fname) ((fname)[0] == '.')
87:
88: /* Most systems don't declare getpwent in <pwd.h> if _POSIX_SOURCE is
89: defined. */
90: #if defined (HAVE_GETPWENT) && (!defined (HAVE_GETPW_DECLS) || defined (_POSIX_SOURCE))
91: extern struct passwd *getpwent PARAMS((void));
92: #endif /* HAVE_GETPWENT && (!HAVE_GETPW_DECLS || _POSIX_SOURCE) */
93:
94: /* If non-zero, then this is the address of a function to call when
95: completing a word would normally display the list of possible matches.
96: This function is called instead of actually doing the display.
97: It takes three arguments: (char **matches, int num_matches, int max_length)
98: where MATCHES is the array of strings that matched, NUM_MATCHES is the
99: number of strings in that array, and MAX_LENGTH is the length of the
100: longest string in that array. */
101: rl_compdisp_func_t *rl_completion_display_matches_hook = (rl_compdisp_func_t *)NULL;
102:
103: #if defined (VISIBLE_STATS) || defined (COLOR_SUPPORT)
104: # if !defined (X_OK)
105: # define X_OK 1
106: # endif
107: #endif
108:
109: #if defined (VISIBLE_STATS)
110: static int stat_char PARAMS((char *));
111: #endif
112:
113: #if defined (COLOR_SUPPORT)
114: static int colored_stat_start PARAMS((char *));
115: static void colored_stat_end PARAMS((void));
116: #endif
117:
118: static int path_isdir PARAMS((const char *));
119:
120: static char *rl_quote_filename PARAMS((char *, int, char *));
121:
122: static void _rl_complete_sigcleanup PARAMS((int, void *));
123:
124: static void set_completion_defaults PARAMS((int));
125: static int get_y_or_n PARAMS((int));
126: static int _rl_internal_pager PARAMS((int));
127: static char *printable_part PARAMS((char *));
128: static int fnwidth PARAMS((const char *));
129: static int fnprint PARAMS((const char *, int));
130: static int print_filename PARAMS((char *, char *, int));
131:
132: static char **gen_completion_matches PARAMS((char *, int, int, rl_compentry_func_t *, int, int));
133:
134: static char **remove_duplicate_matches PARAMS((char **));
135: static void insert_match PARAMS((char *, int, int, char *));
136: static int append_to_match PARAMS((char *, int, int, int));
137: static void insert_all_matches PARAMS((char **, int, char *));
138: static int complete_fncmp PARAMS((const char *, int, const char *, int));
139: static void display_matches PARAMS((char **));
140: static int compute_lcd_of_matches PARAMS((char **, int, const char *));
141: static int postprocess_matches PARAMS((char ***, int));
142: static int complete_get_screenwidth PARAMS((void));
143:
144: static char *make_quoted_replacement PARAMS((char *, int, char *));
145:
146: /* **************************************************************** */
147: /* */
148: /* Completion matching, from readline's point of view. */
149: /* */
150: /* **************************************************************** */
151:
152: /* Variables known only to the readline library. */
153:
154: /* If non-zero, non-unique completions always show the list of matches. */
155: int _rl_complete_show_all = 0;
156:
157: /* If non-zero, non-unique completions show the list of matches, unless it
158: is not possible to do partial completion and modify the line. */
159: int _rl_complete_show_unmodified = 0;
160:
161: /* If non-zero, completed directory names have a slash appended. */
162: int _rl_complete_mark_directories = 1;
163:
164: /* If non-zero, the symlinked directory completion behavior introduced in
165: readline-4.2a is disabled, and symlinks that point to directories have
166: a slash appended (subject to the value of _rl_complete_mark_directories).
167: This is user-settable via the mark-symlinked-directories variable. */
168: int _rl_complete_mark_symlink_dirs = 0;
169:
170: /* If non-zero, completions are printed horizontally in alphabetical order,
171: like `ls -x'. */
172: int _rl_print_completions_horizontally;
173:
174: /* Non-zero means that case is not significant in filename completion. */
175: #if defined (__MSDOS__) && !defined (__DJGPP__)
176: int _rl_completion_case_fold = 1;
177: #else
178: int _rl_completion_case_fold = 0;
179: #endif
180:
181: /* Non-zero means that `-' and `_' are equivalent when comparing filenames
182: for completion. */
183: int _rl_completion_case_map = 0;
184:
185: /* If zero, don't match hidden files (filenames beginning with a `.' on
186: Unix) when doing filename completion. */
187: int _rl_match_hidden_files = 1;
188:
189: /* Length in characters of a common prefix replaced with an ellipsis (`...')
190: when displaying completion matches. Matches whose printable portion has
191: more than this number of displaying characters in common will have the common
192: display prefix replaced with an ellipsis. */
193: int _rl_completion_prefix_display_length = 0;
194:
195: /* The readline-private number of screen columns to use when displaying
196: matches. If < 0 or > _rl_screenwidth, it is ignored. */
197: int _rl_completion_columns = -1;
198:
199: /* Global variables available to applications using readline. */
200:
201: #if defined (VISIBLE_STATS)
202: /* Non-zero means add an additional character to each filename displayed
203: during listing completion iff rl_filename_completion_desired which helps
204: to indicate the type of file being listed. */
205: int rl_visible_stats = 0;
206: #endif /* VISIBLE_STATS */
207:
208: #if defined (COLOR_SUPPORT)
209: /* Non-zero means to use colors to indicate file type when listing possible
210: completions. The colors used are taken from $LS_COLORS, if set. */
211: int _rl_colored_stats = 0;
212: #endif
213:
214: /* If non-zero, when completing in the middle of a word, don't insert
215: characters from the match that match characters following point in
216: the word. This means, for instance, completing when the cursor is
217: after the `e' in `Makefile' won't result in `Makefilefile'. */
218: int _rl_skip_completed_text = 0;
219:
220: /* If non-zero, menu completion displays the common prefix first in the
221: cycle of possible completions instead of the last. */
222: int _rl_menu_complete_prefix_first = 0;
223:
224: /* If non-zero, then this is the address of a function to call when
225: completing on a directory name. The function is called with
226: the address of a string (the current directory name) as an arg. */
227: rl_icppfunc_t *rl_directory_completion_hook = (rl_icppfunc_t *)NULL;
228:
229: rl_icppfunc_t *rl_directory_rewrite_hook = (rl_icppfunc_t *)NULL;
230:
231: rl_icppfunc_t *rl_filename_stat_hook = (rl_icppfunc_t *)NULL;
232:
233: /* If non-zero, this is the address of a function to call when reading
234: directory entries from the filesystem for completion and comparing
235: them to the partial word to be completed. The function should
236: either return its first argument (if no conversion takes place) or
237: newly-allocated memory. This can, for instance, convert filenames
238: between character sets for comparison against what's typed at the
239: keyboard. The returned value is what is added to the list of
240: matches. The second argument is the length of the filename to be
241: converted. */
242: rl_dequote_func_t *rl_filename_rewrite_hook = (rl_dequote_func_t *)NULL;
243:
244: /* Non-zero means readline completion functions perform tilde expansion. */
245: int rl_complete_with_tilde_expansion = 0;
246:
247: /* Pointer to the generator function for completion_matches ().
248: NULL means to use rl_filename_completion_function (), the default filename
249: completer. */
250: rl_compentry_func_t *rl_completion_entry_function = (rl_compentry_func_t *)NULL;
251:
252: /* Pointer to generator function for rl_menu_complete (). NULL means to use
253: *rl_completion_entry_function (see above). */
254: rl_compentry_func_t *rl_menu_completion_entry_function = (rl_compentry_func_t *)NULL;
255:
256: /* Pointer to alternative function to create matches.
257: Function is called with TEXT, START, and END.
258: START and END are indices in RL_LINE_BUFFER saying what the boundaries
259: of TEXT are.
260: If this function exists and returns NULL then call the value of
261: rl_completion_entry_function to try to match, otherwise use the
262: array of strings returned. */
263: rl_completion_func_t *rl_attempted_completion_function = (rl_completion_func_t *)NULL;
264:
265: /* Non-zero means to suppress normal filename completion after the
266: user-specified completion function has been called. */
267: int rl_attempted_completion_over = 0;
268:
269: /* Set to a character indicating the type of completion being performed
270: by rl_complete_internal, available for use by application completion
271: functions. */
272: int rl_completion_type = 0;
273:
274: /* Up to this many items will be displayed in response to a
275: possible-completions call. After that, we ask the user if
276: she is sure she wants to see them all. A negative value means
277: don't ask. */
278: int rl_completion_query_items = 100;
279:
280: int _rl_page_completions = 1;
281:
282: /* The basic list of characters that signal a break between words for the
283: completer routine. The contents of this variable is what breaks words
284: in the shell, i.e. " \t\n\"\\'`@$><=" */
285: const char *rl_basic_word_break_characters = " \t\n\"\\'`@$><=;|&{("; /* }) */
286:
287: /* List of basic quoting characters. */
288: const char *rl_basic_quote_characters = "\"'";
289:
290: /* The list of characters that signal a break between words for
291: rl_complete_internal. The default list is the contents of
292: rl_basic_word_break_characters. */
293: /*const*/ char *rl_completer_word_break_characters = (/*const*/ char *)NULL;
294:
295: /* Hook function to allow an application to set the completion word
296: break characters before readline breaks up the line. Allows
297: position-dependent word break characters. */
298: rl_cpvfunc_t *rl_completion_word_break_hook = (rl_cpvfunc_t *)NULL;
299:
300: /* List of characters which can be used to quote a substring of the line.
301: Completion occurs on the entire substring, and within the substring
302: rl_completer_word_break_characters are treated as any other character,
303: unless they also appear within this list. */
304: const char *rl_completer_quote_characters = (const char *)NULL;
305:
306: /* List of characters that should be quoted in filenames by the completer. */
307: const char *rl_filename_quote_characters = (const char *)NULL;
308:
309: /* List of characters that are word break characters, but should be left
310: in TEXT when it is passed to the completion function. The shell uses
311: this to help determine what kind of completing to do. */
312: const char *rl_special_prefixes = (const char *)NULL;
313:
314: /* If non-zero, then disallow duplicates in the matches. */
315: int rl_ignore_completion_duplicates = 1;
316:
317: /* Non-zero means that the results of the matches are to be treated
318: as filenames. This is ALWAYS zero on entry, and can only be changed
319: within a completion entry finder function. */
320: int rl_filename_completion_desired = 0;
321:
322: /* Non-zero means that the results of the matches are to be quoted using
323: double quotes (or an application-specific quoting mechanism) if the
324: filename contains any characters in rl_filename_quote_chars. This is
325: ALWAYS non-zero on entry, and can only be changed within a completion
326: entry finder function. */
327: int rl_filename_quoting_desired = 1;
328:
329: /* This function, if defined, is called by the completer when real
330: filename completion is done, after all the matching names have been
331: generated. It is passed a (char**) known as matches in the code below.
332: It consists of a NULL-terminated array of pointers to potential
333: matching strings. The 1st element (matches[0]) is the maximal
334: substring that is common to all matches. This function can re-arrange
335: the list of matches as required, but all elements of the array must be
336: free()'d if they are deleted. The main intent of this function is
337: to implement FIGNORE a la SunOS csh. */
338: rl_compignore_func_t *rl_ignore_some_completions_function = (rl_compignore_func_t *)NULL;
339:
340: /* Set to a function to quote a filename in an application-specific fashion.
341: Called with the text to quote, the type of match found (single or multiple)
342: and a pointer to the quoting character to be used, which the function can
343: reset if desired. */
344: rl_quote_func_t *rl_filename_quoting_function = rl_quote_filename;
345:
346: /* Function to call to remove quoting characters from a filename. Called
347: before completion is attempted, so the embedded quotes do not interfere
348: with matching names in the file system. Readline doesn't do anything
349: with this; it's set only by applications. */
350: rl_dequote_func_t *rl_filename_dequoting_function = (rl_dequote_func_t *)NULL;
351:
352: /* Function to call to decide whether or not a word break character is
353: quoted. If a character is quoted, it does not break words for the
354: completer. */
355: rl_linebuf_func_t *rl_char_is_quoted_p = (rl_linebuf_func_t *)NULL;
356:
357: /* If non-zero, the completion functions don't append anything except a
358: possible closing quote. This is set to 0 by rl_complete_internal and
359: may be changed by an application-specific completion function. */
360: int rl_completion_suppress_append = 0;
361:
362: /* Character appended to completed words when at the end of the line. The
363: default is a space. */
364: int rl_completion_append_character = ' ';
365:
366: /* If non-zero, the completion functions don't append any closing quote.
367: This is set to 0 by rl_complete_internal and may be changed by an
368: application-specific completion function. */
369: int rl_completion_suppress_quote = 0;
370:
371: /* Set to any quote character readline thinks it finds before any application
372: completion function is called. */
373: int rl_completion_quote_character;
374:
375: /* Set to a non-zero value if readline found quoting anywhere in the word to
376: be completed; set before any application completion function is called. */
377: int rl_completion_found_quote;
378:
379: /* If non-zero, a slash will be appended to completed filenames that are
380: symbolic links to directory names, subject to the value of the
381: mark-directories variable (which is user-settable). This exists so
382: that application completion functions can override the user's preference
383: (set via the mark-symlinked-directories variable) if appropriate.
384: It's set to the value of _rl_complete_mark_symlink_dirs in
385: rl_complete_internal before any application-specific completion
386: function is called, so without that function doing anything, the user's
387: preferences are honored. */
388: int rl_completion_mark_symlink_dirs;
389:
390: /* If non-zero, inhibit completion (temporarily). */
391: int rl_inhibit_completion;
392:
393: /* Set to the last key used to invoke one of the completion functions */
394: int rl_completion_invoking_key;
395:
396: /* If non-zero, sort the completion matches. On by default. */
397: int rl_sort_completion_matches = 1;
398:
399: /* Variables local to this file. */
400:
401: /* Local variable states what happened during the last completion attempt. */
402: static int completion_changed_buffer;
403:
404: /* The result of the query to the user about displaying completion matches */
405: static int completion_y_or_n;
406:
407: /*************************************/
408: /* */
409: /* Bindable completion functions */
410: /* */
411: /*************************************/
412:
413: /* Complete the word at or before point. You have supplied the function
414: that does the initial simple matching selection algorithm (see
415: rl_completion_matches ()). The default is to do filename completion. */
416: int
417: rl_complete (ignore, invoking_key)
418: int ignore, invoking_key;
419: {
420: rl_completion_invoking_key = invoking_key;
421:
422: if (rl_inhibit_completion)
423: return (_rl_insert_char (ignore, invoking_key));
424: else if (rl_last_func == rl_complete && !completion_changed_buffer)
425: return (rl_complete_internal ('?'));
426: else if (_rl_complete_show_all)
427: return (rl_complete_internal ('!'));
428: else if (_rl_complete_show_unmodified)
429: return (rl_complete_internal ('@'));
430: else
431: return (rl_complete_internal (TAB));
432: }
433:
434: /* List the possible completions. See description of rl_complete (). */
435: int
436: rl_possible_completions (ignore, invoking_key)
437: int ignore, invoking_key;
438: {
439: rl_completion_invoking_key = invoking_key;
440: return (rl_complete_internal ('?'));
441: }
442:
443: int
444: rl_insert_completions (ignore, invoking_key)
445: int ignore, invoking_key;
446: {
447: rl_completion_invoking_key = invoking_key;
448: return (rl_complete_internal ('*'));
449: }
450:
451: /* Return the correct value to pass to rl_complete_internal performing
452: the same tests as rl_complete. This allows consecutive calls to an
453: application's completion function to list possible completions and for
454: an application-specific completion function to honor the
455: show-all-if-ambiguous readline variable. */
456: int
457: rl_completion_mode (cfunc)
458: rl_command_func_t *cfunc;
459: {
460: if (rl_last_func == cfunc && !completion_changed_buffer)
461: return '?';
462: else if (_rl_complete_show_all)
463: return '!';
464: else if (_rl_complete_show_unmodified)
465: return '@';
466: else
467: return TAB;
468: }
469:
470: /************************************/
471: /* */
472: /* Completion utility functions */
473: /* */
474: /************************************/
475:
476: /* Reset readline state on a signal or other event. */
477: void
478: _rl_reset_completion_state ()
479: {
480: rl_completion_found_quote = 0;
481: rl_completion_quote_character = 0;
482: }
483:
484: static void
485: _rl_complete_sigcleanup (sig, ptr)
486: int sig;
487: void *ptr;
488: {
489: if (sig == SIGINT) /* XXX - for now */
490: _rl_free_match_list ((char **)ptr);
491: }
492:
493: /* Set default values for readline word completion. These are the variables
494: that application completion functions can change or inspect. */
495: static void
496: set_completion_defaults (what_to_do)
497: int what_to_do;
498: {
499: /* Only the completion entry function can change these. */
500: rl_filename_completion_desired = 0;
501: rl_filename_quoting_desired = 1;
502: rl_completion_type = what_to_do;
503: rl_completion_suppress_append = rl_completion_suppress_quote = 0;
504: rl_completion_append_character = ' ';
505:
506: /* The completion entry function may optionally change this. */
507: rl_completion_mark_symlink_dirs = _rl_complete_mark_symlink_dirs;
508: }
509:
510: /* The user must press "y" or "n". Non-zero return means "y" pressed. */
511: static int
512: get_y_or_n (for_pager)
513: int for_pager;
514: {
515: int c;
516:
517: /* For now, disable pager in callback mode, until we later convert to state
518: driven functions. Have to wait until next major version to add new
519: state definition, since it will change value of RL_STATE_DONE. */
520: #if defined (READLINE_CALLBACKS)
521: if (RL_ISSTATE (RL_STATE_CALLBACK))
522: return 1;
523: #endif
524:
525: for (;;)
526: {
527: RL_SETSTATE(RL_STATE_MOREINPUT);
528: c = rl_read_key ();
529: RL_UNSETSTATE(RL_STATE_MOREINPUT);
530:
531: if (c == 'y' || c == 'Y' || c == ' ')
532: return (1);
533: if (c == 'n' || c == 'N' || c == RUBOUT)
534: return (0);
535: if (c == ABORT_CHAR || c < 0)
536: _rl_abort_internal ();
537: if (for_pager && (c == NEWLINE || c == RETURN))
538: return (2);
539: if (for_pager && (c == 'q' || c == 'Q'))
540: return (0);
541: rl_ding ();
542: }
543: }
544:
545: static int
546: _rl_internal_pager (lines)
547: int lines;
548: {
549: int i;
550:
551: fprintf (rl_outstream, "--More--");
552: fflush (rl_outstream);
553: i = get_y_or_n (1);
554: _rl_erase_entire_line ();
555: if (i == 0)
556: return -1;
557: else if (i == 2)
558: return (lines - 1);
559: else
560: return 0;
561: }
562:
563: static int
564: path_isdir (filename)
565: const char *filename;
566: {
567: struct stat finfo;
568:
569: return (stat (filename, &finfo) == 0 && S_ISDIR (finfo.st_mode));
570: }
571:
572: #if defined (VISIBLE_STATS)
573: /* Return the character which best describes FILENAME.
574: `@' for symbolic links
575: `/' for directories
576: `*' for executables
577: `=' for sockets
578: `|' for FIFOs
579: `%' for character special devices
580: `#' for block special devices */
581: static int
582: stat_char (filename)
583: char *filename;
584: {
585: struct stat finfo;
586: int character, r;
587: char *f;
588: const char *fn;
589:
590: /* Short-circuit a //server on cygwin, since that will always behave as
591: a directory. */
592: #if __CYGWIN__
593: if (filename[0] == '/' && filename[1] == '/' && strchr (filename+2, '/') == 0)
594: return '/';
595: #endif
596:
597: f = 0;
598: if (rl_filename_stat_hook)
599: {
600: f = savestring (filename);
601: (*rl_filename_stat_hook) (&f);
602: fn = f;
603: }
604: else
605: fn = filename;
606:
607: #if defined (HAVE_LSTAT) && defined (S_ISLNK)
608: r = lstat (fn, &finfo);
609: #else
610: r = stat (fn, &finfo);
611: #endif
612:
613: if (r == -1)
614: return (0);
615:
616: character = 0;
617: if (S_ISDIR (finfo.st_mode))
618: character = '/';
619: #if defined (S_ISCHR)
620: else if (S_ISCHR (finfo.st_mode))
621: character = '%';
622: #endif /* S_ISCHR */
623: #if defined (S_ISBLK)
624: else if (S_ISBLK (finfo.st_mode))
625: character = '#';
626: #endif /* S_ISBLK */
627: #if defined (S_ISLNK)
628: else if (S_ISLNK (finfo.st_mode))
629: character = '@';
630: #endif /* S_ISLNK */
631: #if defined (S_ISSOCK)
632: else if (S_ISSOCK (finfo.st_mode))
633: character = '=';
634: #endif /* S_ISSOCK */
635: #if defined (S_ISFIFO)
636: else if (S_ISFIFO (finfo.st_mode))
637: character = '|';
638: #endif
639: else if (S_ISREG (finfo.st_mode))
640: {
641: if (access (filename, X_OK) == 0)
642: character = '*';
643: }
644:
645: free (f);
646: return (character);
647: }
648: #endif /* VISIBLE_STATS */
649:
650: #if defined (COLOR_SUPPORT)
651: static int
652: colored_stat_start (filename)
653: char *filename;
654: {
655: _rl_set_normal_color ();
656: return (_rl_print_color_indicator (filename));
657: }
658:
659: static void
660: colored_stat_end ()
661: {
662: _rl_prep_non_filename_text ();
663: _rl_put_indicator (&_rl_color_indicator[C_CLR_TO_EOL]);
664: }
665: #endif
666:
667: /* Return the portion of PATHNAME that should be output when listing
668: possible completions. If we are hacking filename completion, we
669: are only interested in the basename, the portion following the
670: final slash. Otherwise, we return what we were passed. Since
671: printing empty strings is not very informative, if we're doing
672: filename completion, and the basename is the empty string, we look
673: for the previous slash and return the portion following that. If
674: there's no previous slash, we just return what we were passed. */
675: static char *
676: printable_part (pathname)
677: char *pathname;
678: {
679: char *temp, *x;
680:
681: if (rl_filename_completion_desired == 0) /* don't need to do anything */
682: return (pathname);
683:
684: temp = strrchr (pathname, '/');
685: #if defined (__MSDOS__)
686: if (temp == 0 && ISALPHA ((unsigned char)pathname[0]) && pathname[1] == ':')
687: temp = pathname + 1;
688: #endif
689:
690: if (temp == 0 || *temp == '\0')
691: return (pathname);
692: /* If the basename is NULL, we might have a pathname like '/usr/src/'.
693: Look for a previous slash and, if one is found, return the portion
694: following that slash. If there's no previous slash, just return the
695: pathname we were passed. */
696: else if (temp[1] == '\0')
697: {
698: for (x = temp - 1; x > pathname; x--)
699: if (*x == '/')
700: break;
701: return ((*x == '/') ? x + 1 : pathname);
702: }
703: else
704: return ++temp;
705: }
706:
707: /* Compute width of STRING when displayed on screen by print_filename */
708: static int
709: fnwidth (string)
710: const char *string;
711: {
712: int width, pos;
713: #if defined (HANDLE_MULTIBYTE)
714: mbstate_t ps;
715: int left, w;
716: size_t clen;
717: wchar_t wc;
718:
719: left = strlen (string) + 1;
720: memset (&ps, 0, sizeof (mbstate_t));
721: #endif
722:
723: width = pos = 0;
724: while (string[pos])
725: {
726: if (CTRL_CHAR (string[pos]) || string[pos] == RUBOUT)
727: {
728: width += 2;
729: pos++;
730: }
731: else
732: {
733: #if defined (HANDLE_MULTIBYTE)
734: clen = mbrtowc (&wc, string + pos, left - pos, &ps);
735: if (MB_INVALIDCH (clen))
736: {
737: width++;
738: pos++;
739: memset (&ps, 0, sizeof (mbstate_t));
740: }
741: else if (MB_NULLWCH (clen))
742: break;
743: else
744: {
745: pos += clen;
746: w = WCWIDTH (wc);
747: width += (w >= 0) ? w : 1;
748: }
749: #else
750: width++;
751: pos++;
752: #endif
753: }
754: }
755:
756: return width;
757: }
758:
759: #define ELLIPSIS_LEN 3
760:
761: static int
762: fnprint (to_print, prefix_bytes)
763: const char *to_print;
764: int prefix_bytes;
765: {
766: int printed_len, w;
767: const char *s;
768: #if defined (HANDLE_MULTIBYTE)
769: mbstate_t ps;
770: const char *end;
771: size_t tlen;
772: int width;
773: wchar_t wc;
774:
775: end = to_print + strlen (to_print) + 1;
776: memset (&ps, 0, sizeof (mbstate_t));
777: #endif
778:
779: printed_len = 0;
780:
781: /* Don't print only the ellipsis if the common prefix is one of the
782: possible completions */
783: if (to_print[prefix_bytes] == '\0')
784: prefix_bytes = 0;
785:
786: if (prefix_bytes)
787: {
788: char ellipsis;
789:
790: ellipsis = (to_print[prefix_bytes] == '.') ? '_' : '.';
791: for (w = 0; w < ELLIPSIS_LEN; w++)
792: putc (ellipsis, rl_outstream);
793: printed_len = ELLIPSIS_LEN;
794: }
795:
796: s = to_print + prefix_bytes;
797: while (*s)
798: {
799: if (CTRL_CHAR (*s))
800: {
801: putc ('^', rl_outstream);
802: putc (UNCTRL (*s), rl_outstream);
803: printed_len += 2;
804: s++;
805: #if defined (HANDLE_MULTIBYTE)
806: memset (&ps, 0, sizeof (mbstate_t));
807: #endif
808: }
809: else if (*s == RUBOUT)
810: {
811: putc ('^', rl_outstream);
812: putc ('?', rl_outstream);
813: printed_len += 2;
814: s++;
815: #if defined (HANDLE_MULTIBYTE)
816: memset (&ps, 0, sizeof (mbstate_t));
817: #endif
818: }
819: else
820: {
821: #if defined (HANDLE_MULTIBYTE)
822: tlen = mbrtowc (&wc, s, end - s, &ps);
823: if (MB_INVALIDCH (tlen))
824: {
825: tlen = 1;
826: width = 1;
827: memset (&ps, 0, sizeof (mbstate_t));
828: }
829: else if (MB_NULLWCH (tlen))
830: break;
831: else
832: {
833: w = WCWIDTH (wc);
834: width = (w >= 0) ? w : 1;
835: }
836: fwrite (s, 1, tlen, rl_outstream);
837: s += tlen;
838: printed_len += width;
839: #else
840: putc (*s, rl_outstream);
841: s++;
842: printed_len++;
843: #endif
844: }
845: }
846:
847: return printed_len;
848: }
849:
850: /* Output TO_PRINT to rl_outstream. If VISIBLE_STATS is defined and we
851: are using it, check for and output a single character for `special'
852: filenames. Return the number of characters we output. */
853:
854: static int
855: print_filename (to_print, full_pathname, prefix_bytes)
856: char *to_print, *full_pathname;
857: int prefix_bytes;
858: {
859: int printed_len, extension_char, slen, tlen;
860: char *s, c, *new_full_pathname, *dn;
861:
862: extension_char = 0;
863: #if defined (COLOR_SUPPORT)
864: /* Defer printing if we want to prefix with a color indicator */
865: if (_rl_colored_stats == 0 || rl_filename_completion_desired == 0)
866: #endif
867: printed_len = fnprint (to_print, prefix_bytes);
868:
869: if (rl_filename_completion_desired && (
870: #if defined (VISIBLE_STATS)
871: rl_visible_stats ||
872: #endif
873: #if defined (COLOR_SUPPORT)
874: _rl_colored_stats ||
875: #endif
876: _rl_complete_mark_directories))
877: {
878: /* If to_print != full_pathname, to_print is the basename of the
879: path passed. In this case, we try to expand the directory
880: name before checking for the stat character. */
881: if (to_print != full_pathname)
882: {
883: /* Terminate the directory name. */
884: c = to_print[-1];
885: to_print[-1] = '\0';
886:
887: /* If setting the last slash in full_pathname to a NUL results in
888: full_pathname being the empty string, we are trying to complete
889: files in the root directory. If we pass a null string to the
890: bash directory completion hook, for example, it will expand it
891: to the current directory. We just want the `/'. */
892: if (full_pathname == 0 || *full_pathname == 0)
893: dn = "/";
894: else if (full_pathname[0] != '/')
895: dn = full_pathname;
896: else if (full_pathname[1] == 0)
897: dn = "//"; /* restore trailing slash to `//' */
898: else if (full_pathname[1] == '/' && full_pathname[2] == 0)
899: dn = "/"; /* don't turn /// into // */
900: else
901: dn = full_pathname;
902: s = tilde_expand (dn);
903: if (rl_directory_completion_hook)
904: (*rl_directory_completion_hook) (&s);
905:
906: slen = strlen (s);
907: tlen = strlen (to_print);
908: new_full_pathname = (char *)xmalloc (slen + tlen + 2);
909: strcpy (new_full_pathname, s);
910: if (s[slen - 1] == '/')
911: slen--;
912: else
913: new_full_pathname[slen] = '/';
914: new_full_pathname[slen] = '/';
915: strcpy (new_full_pathname + slen + 1, to_print);
916:
917: #if defined (VISIBLE_STATS)
918: if (rl_visible_stats)
919: extension_char = stat_char (new_full_pathname);
920: else
921: #endif
922: if (_rl_complete_mark_directories)
923: {
924: dn = 0;
925: if (rl_directory_completion_hook == 0 && rl_filename_stat_hook)
926: {
927: dn = savestring (new_full_pathname);
928: (*rl_filename_stat_hook) (&dn);
929: free (new_full_pathname);
930: new_full_pathname = dn;
931: }
932: if (path_isdir (new_full_pathname))
933: extension_char = '/';
934: }
935:
936: #if defined (COLOR_SUPPORT)
937: if (_rl_colored_stats)
938: {
939: colored_stat_start (new_full_pathname);
940: printed_len = fnprint (to_print, prefix_bytes);
941: colored_stat_end ();
942: }
943: #endif
944:
945: xfree (new_full_pathname);
946: to_print[-1] = c;
947: }
948: else
949: {
950: s = tilde_expand (full_pathname);
951: #if defined (VISIBLE_STATS)
952: if (rl_visible_stats)
953: extension_char = stat_char (s);
954: else
955: #endif
956: if (_rl_complete_mark_directories && path_isdir (s))
957: extension_char = '/';
958:
959: #if defined (COLOR_SUPPORT)
960: if (_rl_colored_stats)
961: {
962: colored_stat_start (s);
963: printed_len = fnprint (to_print, prefix_bytes);
964: colored_stat_end ();
965: }
966: #endif
967:
968: }
969:
970: xfree (s);
971: if (extension_char)
972: {
973: putc (extension_char, rl_outstream);
974: printed_len++;
975: }
976: }
977:
978: return printed_len;
979: }
980:
981: static char *
982: rl_quote_filename (s, rtype, qcp)
983: char *s;
984: int rtype;
985: char *qcp;
986: {
987: char *r;
988:
989: r = (char *)xmalloc (strlen (s) + 2);
990: *r = *rl_completer_quote_characters;
991: strcpy (r + 1, s);
992: if (qcp)
993: *qcp = *rl_completer_quote_characters;
994: return r;
995: }
996:
997: /* Find the bounds of the current word for completion purposes, and leave
998: rl_point set to the end of the word. This function skips quoted
999: substrings (characters between matched pairs of characters in
1000: rl_completer_quote_characters). First we try to find an unclosed
1001: quoted substring on which to do matching. If one is not found, we use
1002: the word break characters to find the boundaries of the current word.
1003: We call an application-specific function to decide whether or not a
1004: particular word break character is quoted; if that function returns a
1005: non-zero result, the character does not break a word. This function
1006: returns the opening quote character if we found an unclosed quoted
1007: substring, '\0' otherwise. FP, if non-null, is set to a value saying
1008: which (shell-like) quote characters we found (single quote, double
1009: quote, or backslash) anywhere in the string. DP, if non-null, is set to
1010: the value of the delimiter character that caused a word break. */
1011:
1012: char
1013: _rl_find_completion_word (fp, dp)
1014: int *fp, *dp;
1015: {
1016: int scan, end, found_quote, delimiter, pass_next, isbrk;
1017: char quote_char, *brkchars;
1018:
1019: end = rl_point;
1020: found_quote = delimiter = 0;
1021: quote_char = '\0';
1022:
1023: brkchars = 0;
1024: if (rl_completion_word_break_hook)
1025: brkchars = (*rl_completion_word_break_hook) ();
1026: if (brkchars == 0)
1027: brkchars = rl_completer_word_break_characters;
1028:
1029: if (rl_completer_quote_characters)
1030: {
1031: /* We have a list of characters which can be used in pairs to
1032: quote substrings for the completer. Try to find the start
1033: of an unclosed quoted substring. */
1034: /* FOUND_QUOTE is set so we know what kind of quotes we found. */
1035: for (scan = pass_next = 0; scan < end; scan = MB_NEXTCHAR (rl_line_buffer, scan, 1, MB_FIND_ANY))
1036: {
1037: if (pass_next)
1038: {
1039: pass_next = 0;
1040: continue;
1041: }
1042:
1043: /* Shell-like semantics for single quotes -- don't allow backslash
1044: to quote anything in single quotes, especially not the closing
1045: quote. If you don't like this, take out the check on the value
1046: of quote_char. */
1047: if (quote_char != '\'' && rl_line_buffer[scan] == '\\')
1048: {
1049: pass_next = 1;
1050: found_quote |= RL_QF_BACKSLASH;
1051: continue;
1052: }
1053:
1054: if (quote_char != '\0')
1055: {
1056: /* Ignore everything until the matching close quote char. */
1057: if (rl_line_buffer[scan] == quote_char)
1058: {
1059: /* Found matching close. Abandon this substring. */
1060: quote_char = '\0';
1061: rl_point = end;
1062: }
1063: }
1064: else if (strchr (rl_completer_quote_characters, rl_line_buffer[scan]))
1065: {
1066: /* Found start of a quoted substring. */
1067: quote_char = rl_line_buffer[scan];
1068: rl_point = scan + 1;
1069: /* Shell-like quoting conventions. */
1070: if (quote_char == '\'')
1071: found_quote |= RL_QF_SINGLE_QUOTE;
1072: else if (quote_char == '"')
1073: found_quote |= RL_QF_DOUBLE_QUOTE;
1074: else
1075: found_quote |= RL_QF_OTHER_QUOTE;
1076: }
1077: }
1078: }
1079:
1080: if (rl_point == end && quote_char == '\0')
1081: {
1082: /* We didn't find an unclosed quoted substring upon which to do
1083: completion, so use the word break characters to find the
1084: substring on which to complete. */
1085: while (rl_point = MB_PREVCHAR (rl_line_buffer, rl_point, MB_FIND_ANY))
1086: {
1087: scan = rl_line_buffer[rl_point];
1088:
1089: if (strchr (brkchars, scan) == 0)
1090: continue;
1091:
1092: /* Call the application-specific function to tell us whether
1093: this word break character is quoted and should be skipped. */
1094: if (rl_char_is_quoted_p && found_quote &&
1095: (*rl_char_is_quoted_p) (rl_line_buffer, rl_point))
1096: continue;
1097:
1098: /* Convoluted code, but it avoids an n^2 algorithm with calls
1099: to char_is_quoted. */
1100: break;
1101: }
1102: }
1103:
1104: /* If we are at an unquoted word break, then advance past it. */
1105: scan = rl_line_buffer[rl_point];
1106:
1107: /* If there is an application-specific function to say whether or not
1108: a character is quoted and we found a quote character, let that
1109: function decide whether or not a character is a word break, even
1110: if it is found in rl_completer_word_break_characters. Don't bother
1111: if we're at the end of the line, though. */
1112: if (scan)
1113: {
1114: if (rl_char_is_quoted_p)
1115: isbrk = (found_quote == 0 ||
1116: (*rl_char_is_quoted_p) (rl_line_buffer, rl_point) == 0) &&
1117: strchr (brkchars, scan) != 0;
1118: else
1119: isbrk = strchr (brkchars, scan) != 0;
1120:
1121: if (isbrk)
1122: {
1123: /* If the character that caused the word break was a quoting
1124: character, then remember it as the delimiter. */
1125: if (rl_basic_quote_characters &&
1126: strchr (rl_basic_quote_characters, scan) &&
1127: (end - rl_point) > 1)
1128: delimiter = scan;
1129:
1130: /* If the character isn't needed to determine something special
1131: about what kind of completion to perform, then advance past it. */
1132: if (rl_special_prefixes == 0 || strchr (rl_special_prefixes, scan) == 0)
1133: rl_point++;
1134: }
1135: }
1136:
1137: if (fp)
1138: *fp = found_quote;
1139: if (dp)
1140: *dp = delimiter;
1141:
1142: return (quote_char);
1143: }
1144:
1145: static char **
1146: gen_completion_matches (text, start, end, our_func, found_quote, quote_char)
1147: char *text;
1148: int start, end;
1149: rl_compentry_func_t *our_func;
1150: int found_quote, quote_char;
1151: {
1152: char **matches;
1153:
1154: rl_completion_found_quote = found_quote;
1155: rl_completion_quote_character = quote_char;
1156:
1157: /* If the user wants to TRY to complete, but then wants to give
1158: up and use the default completion function, they set the
1159: variable rl_attempted_completion_function. */
1160: if (rl_attempted_completion_function)
1161: {
1162: matches = (*rl_attempted_completion_function) (text, start, end);
1163: if (RL_SIG_RECEIVED())
1164: {
1165: _rl_free_match_list (matches);
1166: matches = 0;
1167: RL_CHECK_SIGNALS ();
1168: }
1169:
1170: if (matches || rl_attempted_completion_over)
1171: {
1172: rl_attempted_completion_over = 0;
1173: return (matches);
1174: }
1175: }
1176:
1177: /* XXX -- filename dequoting moved into rl_filename_completion_function */
1178:
1179: /* rl_completion_matches will check for signals as well to avoid a long
1180: delay while reading a directory. */
1181: matches = rl_completion_matches (text, our_func);
1182: if (RL_SIG_RECEIVED())
1183: {
1184: _rl_free_match_list (matches);
1185: matches = 0;
1186: RL_CHECK_SIGNALS ();
1187: }
1188: return matches;
1189: }
1190:
1191: /* Filter out duplicates in MATCHES. This frees up the strings in
1192: MATCHES. */
1193: static char **
1194: remove_duplicate_matches (matches)
1195: char **matches;
1196: {
1197: char *lowest_common;
1198: int i, j, newlen;
1199: char dead_slot;
1200: char **temp_array;
1201:
1202: /* Sort the items. */
1203: for (i = 0; matches[i]; i++)
1204: ;
1205:
1206: /* Sort the array without matches[0], since we need it to
1207: stay in place no matter what. */
1208: if (i && rl_sort_completion_matches)
1209: qsort (matches+1, i-1, sizeof (char *), (QSFUNC *)_rl_qsort_string_compare);
1210:
1211: /* Remember the lowest common denominator for it may be unique. */
1212: lowest_common = savestring (matches[0]);
1213:
1214: for (i = newlen = 0; matches[i + 1]; i++)
1215: {
1216: if (strcmp (matches[i], matches[i + 1]) == 0)
1217: {
1218: xfree (matches[i]);
1219: matches[i] = (char *)&dead_slot;
1220: }
1221: else
1222: newlen++;
1223: }
1224:
1225: /* We have marked all the dead slots with (char *)&dead_slot.
1226: Copy all the non-dead entries into a new array. */
1227: temp_array = (char **)xmalloc ((3 + newlen) * sizeof (char *));
1228: for (i = j = 1; matches[i]; i++)
1229: {
1230: if (matches[i] != (char *)&dead_slot)
1231: temp_array[j++] = matches[i];
1232: }
1233: temp_array[j] = (char *)NULL;
1234:
1235: if (matches[0] != (char *)&dead_slot)
1236: xfree (matches[0]);
1237:
1238: /* Place the lowest common denominator back in [0]. */
1239: temp_array[0] = lowest_common;
1240:
1241: /* If there is one string left, and it is identical to the
1242: lowest common denominator, then the LCD is the string to
1243: insert. */
1244: if (j == 2 && strcmp (temp_array[0], temp_array[1]) == 0)
1245: {
1246: xfree (temp_array[1]);
1247: temp_array[1] = (char *)NULL;
1248: }
1249: return (temp_array);
1250: }
1251:
1252: /* Find the common prefix of the list of matches, and put it into
1253: matches[0]. */
1254: static int
1255: compute_lcd_of_matches (match_list, matches, text)
1256: char **match_list;
1257: int matches;
1258: const char *text;
1259: {
1260: register int i, c1, c2, si;
1261: int low; /* Count of max-matched characters. */
1262: int lx;
1263: char *dtext; /* dequoted TEXT, if needed */
1264: #if defined (HANDLE_MULTIBYTE)
1265: int v;
1266: size_t v1, v2;
1267: mbstate_t ps1, ps2;
1268: wchar_t wc1, wc2;
1269: #endif
1270:
1271: /* If only one match, just use that. Otherwise, compare each
1272: member of the list with the next, finding out where they
1273: stop matching. */
1274: if (matches == 1)
1275: {
1276: match_list[0] = match_list[1];
1277: match_list[1] = (char *)NULL;
1278: return 1;
1279: }
1280:
1281: for (i = 1, low = 100000; i < matches; i++)
1282: {
1283: #if defined (HANDLE_MULTIBYTE)
1284: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1285: {
1286: memset (&ps1, 0, sizeof (mbstate_t));
1287: memset (&ps2, 0, sizeof (mbstate_t));
1288: }
1289: #endif
1290: if (_rl_completion_case_fold)
1291: {
1292: for (si = 0;
1293: (c1 = _rl_to_lower(match_list[i][si])) &&
1294: (c2 = _rl_to_lower(match_list[i + 1][si]));
1295: si++)
1296: #if defined (HANDLE_MULTIBYTE)
1297: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1298: {
1299: v1 = mbrtowc(&wc1, match_list[i]+si, strlen (match_list[i]+si), &ps1);
1300: v2 = mbrtowc (&wc2, match_list[i+1]+si, strlen (match_list[i+1]+si), &ps2);
1301: if (MB_INVALIDCH (v1) || MB_INVALIDCH (v2))
1302: {
1303: if (c1 != c2) /* do byte comparison */
1304: break;
1305: continue;
1306: }
1307: wc1 = towlower (wc1);
1308: wc2 = towlower (wc2);
1309: if (wc1 != wc2)
1310: break;
1311: else if (v1 > 1)
1312: si += v1 - 1;
1313: }
1314: else
1315: #endif
1316: if (c1 != c2)
1317: break;
1318: }
1319: else
1320: {
1321: for (si = 0;
1322: (c1 = match_list[i][si]) &&
1323: (c2 = match_list[i + 1][si]);
1324: si++)
1325: #if defined (HANDLE_MULTIBYTE)
1326: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
1327: {
1328: mbstate_t ps_back;
1329: ps_back = ps1;
1330: if (!_rl_compare_chars (match_list[i], si, &ps1, match_list[i+1], si, &ps2))
1331: break;
1332: else if ((v = _rl_get_char_len (&match_list[i][si], &ps_back)) > 1)
1333: si += v - 1;
1334: }
1335: else
1336: #endif
1337: if (c1 != c2)
1338: break;
1339: }
1340:
1341: if (low > si)
1342: low = si;
1343: }
1344:
1345: /* If there were multiple matches, but none matched up to even the
1346: first character, and the user typed something, use that as the
1347: value of matches[0]. */
1348: if (low == 0 && text && *text)
1349: {
1350: match_list[0] = (char *)xmalloc (strlen (text) + 1);
1351: strcpy (match_list[0], text);
1352: }
1353: else
1354: {
1355: match_list[0] = (char *)xmalloc (low + 1);
1356:
1357: /* XXX - this might need changes in the presence of multibyte chars */
1358:
1359: /* If we are ignoring case, try to preserve the case of the string
1360: the user typed in the face of multiple matches differing in case. */
1361: if (_rl_completion_case_fold)
1362: {
1363: /* We're making an assumption here:
1364: IF we're completing filenames AND
1365: the application has defined a filename dequoting function AND
1366: we found a quote character AND
1367: the application has requested filename quoting
1368: THEN
1369: we assume that TEXT was dequoted before checking against
1370: the file system and needs to be dequoted here before we
1371: check against the list of matches
1372: FI */
1373: dtext = (char *)NULL;
1374: if (rl_filename_completion_desired &&
1375: rl_filename_dequoting_function &&
1376: rl_completion_found_quote &&
1377: rl_filename_quoting_desired)
1378: {
1379: dtext = (*rl_filename_dequoting_function) ((char *)text, rl_completion_quote_character);
1380: text = dtext;
1381: }
1382:
1383: /* sort the list to get consistent answers. */
1384: qsort (match_list+1, matches, sizeof(char *), (QSFUNC *)_rl_qsort_string_compare);
1385:
1386: si = strlen (text);
1387: lx = (si <= low) ? si : low; /* check shorter of text and matches */
1388: /* Try to preserve the case of what the user typed in the presence of
1389: multiple matches: check each match for something that matches
1390: what the user typed taking case into account; use it up to common
1391: length of matches if one is found. If not, just use first match. */
1392: for (i = 1; i <= matches; i++)
1393: if (strncmp (match_list[i], text, lx) == 0)
1394: {
1395: strncpy (match_list[0], match_list[i], low);
1396: break;
1397: }
1398: /* no casematch, use first entry */
1399: if (i > matches)
1400: strncpy (match_list[0], match_list[1], low);
1401:
1402: FREE (dtext);
1403: }
1404: else
1405: strncpy (match_list[0], match_list[1], low);
1406:
1407: match_list[0][low] = '\0';
1408: }
1409:
1410: return matches;
1411: }
1412:
1413: static int
1414: postprocess_matches (matchesp, matching_filenames)
1415: char ***matchesp;
1416: int matching_filenames;
1417: {
1418: char *t, **matches, **temp_matches;
1419: int nmatch, i;
1420:
1421: matches = *matchesp;
1422:
1423: if (matches == 0)
1424: return 0;
1425:
1426: /* It seems to me that in all the cases we handle we would like
1427: to ignore duplicate possibilities. Scan for the text to
1428: insert being identical to the other completions. */
1429: if (rl_ignore_completion_duplicates)
1430: {
1431: temp_matches = remove_duplicate_matches (matches);
1432: xfree (matches);
1433: matches = temp_matches;
1434: }
1435:
1436: /* If we are matching filenames, then here is our chance to
1437: do clever processing by re-examining the list. Call the
1438: ignore function with the array as a parameter. It can
1439: munge the array, deleting matches as it desires. */
1440: if (rl_ignore_some_completions_function && matching_filenames)
1441: {
1442: for (nmatch = 1; matches[nmatch]; nmatch++)
1443: ;
1444: (void)(*rl_ignore_some_completions_function) (matches);
1445: if (matches == 0 || matches[0] == 0)
1446: {
1447: FREE (matches);
1448: *matchesp = (char **)0;
1449: return 0;
1450: }
1451: else
1452: {
1453: /* If we removed some matches, recompute the common prefix. */
1454: for (i = 1; matches[i]; i++)
1455: ;
1456: if (i > 1 && i < nmatch)
1457: {
1458: t = matches[0];
1459: compute_lcd_of_matches (matches, i - 1, t);
1460: FREE (t);
1461: }
1462: }
1463: }
1464:
1465: *matchesp = matches;
1466: return (1);
1467: }
1468:
1469: static int
1470: complete_get_screenwidth ()
1471: {
1472: int cols;
1473: char *envcols;
1474:
1475: cols = _rl_completion_columns;
1476: if (cols >= 0 && cols <= _rl_screenwidth)
1477: return cols;
1478: envcols = getenv ("COLUMNS");
1479: if (envcols && *envcols)
1480: cols = atoi (envcols);
1481: if (cols >= 0 && cols <= _rl_screenwidth)
1482: return cols;
1483: return _rl_screenwidth;
1484: }
1485:
1486: /* A convenience function for displaying a list of strings in
1487: columnar format on readline's output stream. MATCHES is the list
1488: of strings, in argv format, LEN is the number of strings in MATCHES,
1489: and MAX is the length of the longest string in MATCHES. */
1490: void
1491: rl_display_match_list (matches, len, max)
1492: char **matches;
1493: int len, max;
1494: {
1495: int count, limit, printed_len, lines, cols;
1496: int i, j, k, l, common_length, sind;
1497: char *temp, *t;
1498:
1499: /* Find the length of the prefix common to all items: length as displayed
1500: characters (common_length) and as a byte index into the matches (sind) */
1501: common_length = sind = 0;
1502: if (_rl_completion_prefix_display_length > 0)
1503: {
1504: t = printable_part (matches[0]);
1505: temp = strrchr (t, '/');
1506: common_length = temp ? fnwidth (temp) : fnwidth (t);
1507: sind = temp ? strlen (temp) : strlen (t);
1508:
1509: if (common_length > _rl_completion_prefix_display_length && common_length > ELLIPSIS_LEN)
1510: max -= common_length - ELLIPSIS_LEN;
1511: else
1512: common_length = sind = 0;
1513: }
1514:
1515: /* How many items of MAX length can we fit in the screen window? */
1516: cols = complete_get_screenwidth ();
1517: max += 2;
1518: limit = cols / max;
1519: if (limit != 1 && (limit * max == cols))
1520: limit--;
1521:
1522: /* If cols == 0, limit will end up -1 */
1523: if (cols < _rl_screenwidth && limit < 0)
1524: limit = 1;
1525:
1526: /* Avoid a possible floating exception. If max > cols,
1527: limit will be 0 and a divide-by-zero fault will result. */
1528: if (limit == 0)
1529: limit = 1;
1530:
1531: /* How many iterations of the printing loop? */
1532: count = (len + (limit - 1)) / limit;
1533:
1534: /* Watch out for special case. If LEN is less than LIMIT, then
1535: just do the inner printing loop.
1536: 0 < len <= limit implies count = 1. */
1537:
1538: /* Sort the items if they are not already sorted. */
1539: if (rl_ignore_completion_duplicates == 0 && rl_sort_completion_matches)
1540: qsort (matches + 1, len, sizeof (char *), (QSFUNC *)_rl_qsort_string_compare);
1541:
1542: rl_crlf ();
1543:
1544: lines = 0;
1545: if (_rl_print_completions_horizontally == 0)
1546: {
1547: /* Print the sorted items, up-and-down alphabetically, like ls. */
1548: for (i = 1; i <= count; i++)
1549: {
1550: for (j = 0, l = i; j < limit; j++)
1551: {
1552: if (l > len || matches[l] == 0)
1553: break;
1554: else
1555: {
1556: temp = printable_part (matches[l]);
1557: printed_len = print_filename (temp, matches[l], sind);
1558:
1559: if (j + 1 < limit)
1560: for (k = 0; k < max - printed_len; k++)
1561: putc (' ', rl_outstream);
1562: }
1563: l += count;
1564: }
1565: rl_crlf ();
1566: lines++;
1567: if (_rl_page_completions && lines >= (_rl_screenheight - 1) && i < count)
1568: {
1569: lines = _rl_internal_pager (lines);
1570: if (lines < 0)
1571: return;
1572: }
1573: }
1574: }
1575: else
1576: {
1577: /* Print the sorted items, across alphabetically, like ls -x. */
1578: for (i = 1; matches[i]; i++)
1579: {
1580: temp = printable_part (matches[i]);
1581: printed_len = print_filename (temp, matches[i], sind);
1582: /* Have we reached the end of this line? */
1583: if (matches[i+1])
1584: {
1585: if (limit == 1 || (i && (limit > 1) && (i % limit) == 0))
1586: {
1587: rl_crlf ();
1588: lines++;
1589: if (_rl_page_completions && lines >= _rl_screenheight - 1)
1590: {
1591: lines = _rl_internal_pager (lines);
1592: if (lines < 0)
1593: return;
1594: }
1595: }
1596: else
1597: for (k = 0; k < max - printed_len; k++)
1598: putc (' ', rl_outstream);
1599: }
1600: }
1601: rl_crlf ();
1602: }
1603: }
1604:
1605: /* Display MATCHES, a list of matching filenames in argv format. This
1606: handles the simple case -- a single match -- first. If there is more
1607: than one match, we compute the number of strings in the list and the
1608: length of the longest string, which will be needed by the display
1609: function. If the application wants to handle displaying the list of
1610: matches itself, it sets RL_COMPLETION_DISPLAY_MATCHES_HOOK to the
1611: address of a function, and we just call it. If we're handling the
1612: display ourselves, we just call rl_display_match_list. We also check
1613: that the list of matches doesn't exceed the user-settable threshold,
1614: and ask the user if he wants to see the list if there are more matches
1615: than RL_COMPLETION_QUERY_ITEMS. */
1616: static void
1617: display_matches (matches)
1618: char **matches;
1619: {
1620: int len, max, i;
1621: char *temp;
1622:
1623: /* Move to the last visible line of a possibly-multiple-line command. */
1624: _rl_move_vert (_rl_vis_botlin);
1625:
1626: /* Handle simple case first. What if there is only one answer? */
1627: if (matches[1] == 0)
1628: {
1629: temp = printable_part (matches[0]);
1630: rl_crlf ();
1631: print_filename (temp, matches[0], 0);
1632: rl_crlf ();
1633:
1634: rl_forced_update_display ();
1635: rl_display_fixed = 1;
1636:
1637: return;
1638: }
1639:
1640: /* There is more than one answer. Find out how many there are,
1641: and find the maximum printed length of a single entry. */
1642: for (max = 0, i = 1; matches[i]; i++)
1643: {
1644: temp = printable_part (matches[i]);
1645: len = fnwidth (temp);
1646:
1647: if (len > max)
1648: max = len;
1649: }
1650:
1651: len = i - 1;
1652:
1653: /* If the caller has defined a display hook, then call that now. */
1654: if (rl_completion_display_matches_hook)
1655: {
1656: (*rl_completion_display_matches_hook) (matches, len, max);
1657: return;
1658: }
1659:
1660: /* If there are many items, then ask the user if she really wants to
1661: see them all. */
1662: if (rl_completion_query_items > 0 && len >= rl_completion_query_items)
1663: {
1664: rl_crlf ();
1665: fprintf (rl_outstream, "Display all %d possibilities? (y or n)", len);
1666: fflush (rl_outstream);
1667: if ((completion_y_or_n = get_y_or_n (0)) == 0)
1668: {
1669: rl_crlf ();
1670:
1671: rl_forced_update_display ();
1672: rl_display_fixed = 1;
1673:
1674: return;
1675: }
1676: }
1677:
1678: rl_display_match_list (matches, len, max);
1679:
1680: rl_forced_update_display ();
1681: rl_display_fixed = 1;
1682: }
1683:
1684: static char *
1685: make_quoted_replacement (match, mtype, qc)
1686: char *match;
1687: int mtype;
1688: char *qc; /* Pointer to quoting character, if any */
1689: {
1690: int should_quote, do_replace;
1691: char *replacement;
1692:
1693: /* If we are doing completion on quoted substrings, and any matches
1694: contain any of the completer_word_break_characters, then auto-
1695: matically prepend the substring with a quote character (just pick
1696: the first one from the list of such) if it does not already begin
1697: with a quote string. FIXME: Need to remove any such automatically
1698: inserted quote character when it no longer is necessary, such as
1699: if we change the string we are completing on and the new set of
1700: matches don't require a quoted substring. */
1701: replacement = match;
1702:
1703: should_quote = match && rl_completer_quote_characters &&
1704: rl_filename_completion_desired &&
1705: rl_filename_quoting_desired;
1706:
1707: if (should_quote)
1708: should_quote = should_quote && (!qc || !*qc ||
1709: (rl_completer_quote_characters && strchr (rl_completer_quote_characters, *qc)));
1710:
1711: if (should_quote)
1712: {
1713: /* If there is a single match, see if we need to quote it.
1714: This also checks whether the common prefix of several
1715: matches needs to be quoted. */
1716: should_quote = rl_filename_quote_characters
1717: ? (_rl_strpbrk (match, rl_filename_quote_characters) != 0)
1718: : 0;
1719:
1720: do_replace = should_quote ? mtype : NO_MATCH;
1721: /* Quote the replacement, since we found an embedded
1722: word break character in a potential match. */
1723: if (do_replace != NO_MATCH && rl_filename_quoting_function)
1724: replacement = (*rl_filename_quoting_function) (match, do_replace, qc);
1725: }
1726: return (replacement);
1727: }
1728:
1729: static void
1730: insert_match (match, start, mtype, qc)
1731: char *match;
1732: int start, mtype;
1733: char *qc;
1734: {
1735: char *replacement, *r;
1736: char oqc;
1737: int end, rlen;
1738:
1739: oqc = qc ? *qc : '\0';
1740: replacement = make_quoted_replacement (match, mtype, qc);
1741:
1742: /* Now insert the match. */
1743: if (replacement)
1744: {
1745: rlen = strlen (replacement);
1746: /* Don't double an opening quote character. */
1747: if (qc && *qc && start && rl_line_buffer[start - 1] == *qc &&
1748: replacement[0] == *qc)
1749: start--;
1750: /* If make_quoted_replacement changed the quoting character, remove
1751: the opening quote and insert the (fully-quoted) replacement. */
1752: else if (qc && (*qc != oqc) && start && rl_line_buffer[start - 1] == oqc &&
1753: replacement[0] != oqc)
1754: start--;
1755: end = rl_point - 1;
1756: /* Don't double a closing quote character */
1757: if (qc && *qc && end && rl_line_buffer[rl_point] == *qc && replacement[rlen - 1] == *qc)
1758: end++;
1759: if (_rl_skip_completed_text)
1760: {
1761: r = replacement;
1762: while (start < rl_end && *r && rl_line_buffer[start] == *r)
1763: {
1764: start++;
1765: r++;
1766: }
1767: if (start <= end || *r)
1768: _rl_replace_text (r, start, end);
1769: rl_point = start + strlen (r);
1770: }
1771: else
1772: _rl_replace_text (replacement, start, end);
1773: if (replacement != match)
1774: xfree (replacement);
1775: }
1776: }
1777:
1778: /* Append any necessary closing quote and a separator character to the
1779: just-inserted match. If the user has specified that directories
1780: should be marked by a trailing `/', append one of those instead. The
1781: default trailing character is a space. Returns the number of characters
1782: appended. If NONTRIVIAL_MATCH is set, we test for a symlink (if the OS
1783: has them) and don't add a suffix for a symlink to a directory. A
1784: nontrivial match is one that actually adds to the word being completed.
1785: The variable rl_completion_mark_symlink_dirs controls this behavior
1786: (it's initially set to the what the user has chosen, indicated by the
1787: value of _rl_complete_mark_symlink_dirs, but may be modified by an
1788: application's completion function). */
1789: static int
1790: append_to_match (text, delimiter, quote_char, nontrivial_match)
1791: char *text;
1792: int delimiter, quote_char, nontrivial_match;
1793: {
1794: char temp_string[4], *filename, *fn;
1795: int temp_string_index, s;
1796: struct stat finfo;
1797:
1798: temp_string_index = 0;
1799: if (quote_char && rl_point && rl_completion_suppress_quote == 0 &&
1800: rl_line_buffer[rl_point - 1] != quote_char)
1801: temp_string[temp_string_index++] = quote_char;
1802:
1803: if (delimiter)
1804: temp_string[temp_string_index++] = delimiter;
1805: else if (rl_completion_suppress_append == 0 && rl_completion_append_character)
1806: temp_string[temp_string_index++] = rl_completion_append_character;
1807:
1808: temp_string[temp_string_index++] = '\0';
1809:
1810: if (rl_filename_completion_desired)
1811: {
1812: filename = tilde_expand (text);
1813: if (rl_filename_stat_hook)
1814: {
1815: fn = savestring (filename);
1816: (*rl_filename_stat_hook) (&fn);
1817: xfree (filename);
1818: filename = fn;
1819: }
1820: s = (nontrivial_match && rl_completion_mark_symlink_dirs == 0)
1821: ? LSTAT (filename, &finfo)
1822: : stat (filename, &finfo);
1823: if (s == 0 && S_ISDIR (finfo.st_mode))
1824: {
1825: if (_rl_complete_mark_directories /* && rl_completion_suppress_append == 0 */)
1826: {
1827: /* This is clumsy. Avoid putting in a double slash if point
1828: is at the end of the line and the previous character is a
1829: slash. */
1830: if (rl_point && rl_line_buffer[rl_point] == '\0' && rl_line_buffer[rl_point - 1] == '/')
1831: ;
1832: else if (rl_line_buffer[rl_point] != '/')
1833: rl_insert_text ("/");
1834: }
1835: }
1836: #ifdef S_ISLNK
1837: /* Don't add anything if the filename is a symlink and resolves to a
1838: directory. */
1839: else if (s == 0 && S_ISLNK (finfo.st_mode) && path_isdir (filename))
1840: ;
1841: #endif
1842: else
1843: {
1844: if (rl_point == rl_end && temp_string_index)
1845: rl_insert_text (temp_string);
1846: }
1847: xfree (filename);
1848: }
1849: else
1850: {
1851: if (rl_point == rl_end && temp_string_index)
1852: rl_insert_text (temp_string);
1853: }
1854:
1855: return (temp_string_index);
1856: }
1857:
1858: static void
1859: insert_all_matches (matches, point, qc)
1860: char **matches;
1861: int point;
1862: char *qc;
1863: {
1864: int i;
1865: char *rp;
1866:
1867: rl_begin_undo_group ();
1868: /* remove any opening quote character; make_quoted_replacement will add
1869: it back. */
1870: if (qc && *qc && point && rl_line_buffer[point - 1] == *qc)
1871: point--;
1872: rl_delete_text (point, rl_point);
1873: rl_point = point;
1874:
1875: if (matches[1])
1876: {
1877: for (i = 1; matches[i]; i++)
1878: {
1879: rp = make_quoted_replacement (matches[i], SINGLE_MATCH, qc);
1880: rl_insert_text (rp);
1881: rl_insert_text (" ");
1882: if (rp != matches[i])
1883: xfree (rp);
1884: }
1885: }
1886: else
1887: {
1888: rp = make_quoted_replacement (matches[0], SINGLE_MATCH, qc);
1889: rl_insert_text (rp);
1890: rl_insert_text (" ");
1891: if (rp != matches[0])
1892: xfree (rp);
1893: }
1894: rl_end_undo_group ();
1895: }
1896:
1897: void
1898: _rl_free_match_list (matches)
1899: char **matches;
1900: {
1901: register int i;
1902:
1903: if (matches == 0)
1904: return;
1905:
1906: for (i = 0; matches[i]; i++)
1907: xfree (matches[i]);
1908: xfree (matches);
1909: }
1910:
1911: /* Complete the word at or before point.
1912: WHAT_TO_DO says what to do with the completion.
1913: `?' means list the possible completions.
1914: TAB means do standard completion.
1915: `*' means insert all of the possible completions.
1916: `!' means to do standard completion, and list all possible completions if
1917: there is more than one.
1918: `@' means to do standard completion, and list all possible completions if
1919: there is more than one and partial completion is not possible. */
1920: int
1921: rl_complete_internal (what_to_do)
1922: int what_to_do;
1923: {
1924: char **matches;
1925: rl_compentry_func_t *our_func;
1926: int start, end, delimiter, found_quote, i, nontrivial_lcd;
1927: char *text, *saved_line_buffer;
1928: char quote_char;
1929: #if 1
1930: int tlen, mlen;
1931: #endif
1932:
1933: RL_SETSTATE(RL_STATE_COMPLETING);
1934:
1935: set_completion_defaults (what_to_do);
1936:
1937: saved_line_buffer = rl_line_buffer ? savestring (rl_line_buffer) : (char *)NULL;
1938: our_func = rl_completion_entry_function
1939: ? rl_completion_entry_function
1940: : rl_filename_completion_function;
1941: /* We now look backwards for the start of a filename/variable word. */
1942: end = rl_point;
1943: found_quote = delimiter = 0;
1944: quote_char = '\0';
1945:
1946: if (rl_point)
1947: /* This (possibly) changes rl_point. If it returns a non-zero char,
1948: we know we have an open quote. */
1949: quote_char = _rl_find_completion_word (&found_quote, &delimiter);
1950:
1951: start = rl_point;
1952: rl_point = end;
1953:
1954: text = rl_copy_text (start, end);
1955: matches = gen_completion_matches (text, start, end, our_func, found_quote, quote_char);
1956: /* nontrivial_lcd is set if the common prefix adds something to the word
1957: being completed. */
1958: nontrivial_lcd = matches && strcmp (text, matches[0]) != 0;
1959: if (what_to_do == '!' || what_to_do == '@')
1960: tlen = strlen (text);
1961: xfree (text);
1962:
1963: if (matches == 0)
1964: {
1965: rl_ding ();
1966: FREE (saved_line_buffer);
1967: completion_changed_buffer = 0;
1968: RL_UNSETSTATE(RL_STATE_COMPLETING);
1969: _rl_reset_completion_state ();
1970: return (0);
1971: }
1972:
1973: /* If we are matching filenames, the attempted completion function will
1974: have set rl_filename_completion_desired to a non-zero value. The basic
1975: rl_filename_completion_function does this. */
1976: i = rl_filename_completion_desired;
1977:
1978: if (postprocess_matches (&matches, i) == 0)
1979: {
1980: rl_ding ();
1981: FREE (saved_line_buffer);
1982: completion_changed_buffer = 0;
1983: RL_UNSETSTATE(RL_STATE_COMPLETING);
1984: _rl_reset_completion_state ();
1985: return (0);
1986: }
1987:
1988: switch (what_to_do)
1989: {
1990: case TAB:
1991: case '!':
1992: case '@':
1993: /* Insert the first match with proper quoting. */
1994: if (what_to_do == TAB)
1995: {
1996: if (*matches[0])
1997: insert_match (matches[0], start, matches[1] ? MULT_MATCH : SINGLE_MATCH, "e_char);
1998: }
1999: else if (*matches[0] && matches[1] == 0)
2000: /* should we perform the check only if there are multiple matches? */
2001: insert_match (matches[0], start, matches[1] ? MULT_MATCH : SINGLE_MATCH, "e_char);
2002: else if (*matches[0]) /* what_to_do != TAB && multiple matches */
2003: {
2004: mlen = *matches[0] ? strlen (matches[0]) : 0;
2005: if (mlen >= tlen)
2006: insert_match (matches[0], start, matches[1] ? MULT_MATCH : SINGLE_MATCH, "e_char);
2007: }
2008:
2009: /* If there are more matches, ring the bell to indicate.
2010: If we are in vi mode, Posix.2 says to not ring the bell.
2011: If the `show-all-if-ambiguous' variable is set, display
2012: all the matches immediately. Otherwise, if this was the
2013: only match, and we are hacking files, check the file to
2014: see if it was a directory. If so, and the `mark-directories'
2015: variable is set, add a '/' to the name. If not, and we
2016: are at the end of the line, then add a space. */
2017: if (matches[1])
2018: {
2019: if (what_to_do == '!')
2020: {
2021: display_matches (matches);
2022: break;
2023: }
2024: else if (what_to_do == '@')
2025: {
2026: if (nontrivial_lcd == 0)
2027: display_matches (matches);
2028: break;
2029: }
2030: else if (rl_editing_mode != vi_mode)
2031: rl_ding (); /* There are other matches remaining. */
2032: }
2033: else
2034: append_to_match (matches[0], delimiter, quote_char, nontrivial_lcd);
2035:
2036: break;
2037:
2038: case '*':
2039: insert_all_matches (matches, start, "e_char);
2040: break;
2041:
2042: case '?':
2043: if (rl_completion_display_matches_hook == 0)
2044: {
2045: _rl_sigcleanup = _rl_complete_sigcleanup;
2046: _rl_sigcleanarg = matches;
2047: }
2048: display_matches (matches);
2049: _rl_sigcleanup = 0;
2050: _rl_sigcleanarg = 0;
2051: break;
2052:
2053: default:
2054: _rl_ttymsg ("bad value %d for what_to_do in rl_complete", what_to_do);
2055: rl_ding ();
2056: FREE (saved_line_buffer);
2057: RL_UNSETSTATE(RL_STATE_COMPLETING);
2058: _rl_free_match_list (matches);
2059: _rl_reset_completion_state ();
2060: return 1;
2061: }
2062:
2063: _rl_free_match_list (matches);
2064:
2065: /* Check to see if the line has changed through all of this manipulation. */
2066: if (saved_line_buffer)
2067: {
2068: completion_changed_buffer = strcmp (rl_line_buffer, saved_line_buffer) != 0;
2069: xfree (saved_line_buffer);
2070: }
2071:
2072: RL_UNSETSTATE(RL_STATE_COMPLETING);
2073: _rl_reset_completion_state ();
2074: return 0;
2075: }
2076:
2077: /***************************************************************/
2078: /* */
2079: /* Application-callable completion match generator functions */
2080: /* */
2081: /***************************************************************/
2082:
2083: /* Return an array of (char *) which is a list of completions for TEXT.
2084: If there are no completions, return a NULL pointer.
2085: The first entry in the returned array is the substitution for TEXT.
2086: The remaining entries are the possible completions.
2087: The array is terminated with a NULL pointer.
2088:
2089: ENTRY_FUNCTION is a function of two args, and returns a (char *).
2090: The first argument is TEXT.
2091: The second is a state argument; it should be zero on the first call, and
2092: non-zero on subsequent calls. It returns a NULL pointer to the caller
2093: when there are no more matches.
2094: */
2095: char **
2096: rl_completion_matches (text, entry_function)
2097: const char *text;
2098: rl_compentry_func_t *entry_function;
2099: {
2100: register int i;
2101:
2102: /* Number of slots in match_list. */
2103: int match_list_size;
2104:
2105: /* The list of matches. */
2106: char **match_list;
2107:
2108: /* Number of matches actually found. */
2109: int matches;
2110:
2111: /* Temporary string binder. */
2112: char *string;
2113:
2114: matches = 0;
2115: match_list_size = 10;
2116: match_list = (char **)xmalloc ((match_list_size + 1) * sizeof (char *));
2117: match_list[1] = (char *)NULL;
2118:
2119: while (string = (*entry_function) (text, matches))
2120: {
2121: if (RL_SIG_RECEIVED ())
2122: {
2123: /* Start at 1 because we don't set matches[0] in this function.
2124: Only free the list members if we're building match list from
2125: rl_filename_completion_function, since we know that doesn't
2126: free the strings it returns. */
2127: if (entry_function == rl_filename_completion_function)
2128: {
2129: for (i = 1; match_list[i]; i++)
2130: xfree (match_list[i]);
2131: }
2132: xfree (match_list);
2133: match_list = 0;
2134: match_list_size = 0;
2135: matches = 0;
2136: RL_CHECK_SIGNALS ();
2137: }
2138:
2139: if (matches + 1 >= match_list_size)
2140: match_list = (char **)xrealloc
2141: (match_list, ((match_list_size += 10) + 1) * sizeof (char *));
2142:
2143: if (match_list == 0)
2144: return (match_list);
2145:
2146: match_list[++matches] = string;
2147: match_list[matches + 1] = (char *)NULL;
2148: }
2149:
2150: /* If there were any matches, then look through them finding out the
2151: lowest common denominator. That then becomes match_list[0]. */
2152: if (matches)
2153: compute_lcd_of_matches (match_list, matches, text);
2154: else /* There were no matches. */
2155: {
2156: xfree (match_list);
2157: match_list = (char **)NULL;
2158: }
2159: return (match_list);
2160: }
2161:
2162: /* A completion function for usernames.
2163: TEXT contains a partial username preceded by a random
2164: character (usually `~'). */
2165: char *
2166: rl_username_completion_function (text, state)
2167: const char *text;
2168: int state;
2169: {
2170: #if defined (__WIN32__) || defined (__OPENNT)
2171: return (char *)NULL;
2172: #else /* !__WIN32__ && !__OPENNT) */
2173: static char *username = (char *)NULL;
2174: static struct passwd *entry;
2175: static int namelen, first_char, first_char_loc;
2176: char *value;
2177:
2178: if (state == 0)
2179: {
2180: FREE (username);
2181:
2182: first_char = *text;
2183: first_char_loc = first_char == '~';
2184:
2185: username = savestring (&text[first_char_loc]);
2186: namelen = strlen (username);
2187: #if defined (HAVE_GETPWENT)
2188: setpwent ();
2189: #endif
2190: }
2191:
2192: #if defined (HAVE_GETPWENT)
2193: while (entry = getpwent ())
2194: {
2195: /* Null usernames should result in all users as possible completions. */
2196: if (namelen == 0 || (STREQN (username, entry->pw_name, namelen)))
2197: break;
2198: }
2199: #endif
2200:
2201: if (entry == 0)
2202: {
2203: #if defined (HAVE_GETPWENT)
2204: endpwent ();
2205: #endif
2206: return ((char *)NULL);
2207: }
2208: else
2209: {
2210: value = (char *)xmalloc (2 + strlen (entry->pw_name));
2211:
2212: *value = *text;
2213:
2214: strcpy (value + first_char_loc, entry->pw_name);
2215:
2216: if (first_char == '~')
2217: rl_filename_completion_desired = 1;
2218:
2219: return (value);
2220: }
2221: #endif /* !__WIN32__ && !__OPENNT */
2222: }
2223:
2224: /* Return non-zero if CONVFN matches FILENAME up to the length of FILENAME
2225: (FILENAME_LEN). If _rl_completion_case_fold is set, compare without
2226: regard to the alphabetic case of characters. If
2227: _rl_completion_case_map is set, make `-' and `_' equivalent. CONVFN is
2228: the possibly-converted directory entry; FILENAME is what the user typed. */
2229: static int
2230: complete_fncmp (convfn, convlen, filename, filename_len)
2231: const char *convfn;
2232: int convlen;
2233: const char *filename;
2234: int filename_len;
2235: {
2236: register char *s1, *s2;
2237: int d, len;
2238: #if defined (HANDLE_MULTIBYTE)
2239: size_t v1, v2;
2240: mbstate_t ps1, ps2;
2241: wchar_t wc1, wc2;
2242: #endif
2243:
2244: #if defined (HANDLE_MULTIBYTE)
2245: memset (&ps1, 0, sizeof (mbstate_t));
2246: memset (&ps2, 0, sizeof (mbstate_t));
2247: #endif
2248:
2249: if (filename_len == 0)
2250: return 1;
2251: if (convlen < filename_len)
2252: return 0;
2253:
2254: len = filename_len;
2255: s1 = (char *)convfn;
2256: s2 = (char *)filename;
2257:
2258: /* Otherwise, if these match up to the length of filename, then
2259: it is a match. */
2260: if (_rl_completion_case_fold && _rl_completion_case_map)
2261: {
2262: /* Case-insensitive comparison treating _ and - as equivalent */
2263: #if defined (HANDLE_MULTIBYTE)
2264: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
2265: {
2266: do
2267: {
2268: v1 = mbrtowc (&wc1, s1, convlen, &ps1);
2269: v2 = mbrtowc (&wc2, s2, filename_len, &ps2);
2270: if (v1 == 0 && v2 == 0)
2271: return 1;
2272: else if (MB_INVALIDCH (v1) || MB_INVALIDCH (v2))
2273: {
2274: if (*s1 != *s2) /* do byte comparison */
2275: return 0;
2276: else if ((*s1 == '-' || *s1 == '_') && (*s2 == '-' || *s2 == '_'))
2277: return 0;
2278: s1++; s2++; len--;
2279: continue;
2280: }
2281: wc1 = towlower (wc1);
2282: wc2 = towlower (wc2);
2283: s1 += v1;
2284: s2 += v1;
2285: len -= v1;
2286: if ((wc1 == L'-' || wc1 == L'_') && (wc2 == L'-' || wc2 == L'_'))
2287: continue;
2288: if (wc1 != wc2)
2289: return 0;
2290: }
2291: while (len != 0);
2292: }
2293: else
2294: #endif
2295: {
2296: do
2297: {
2298: d = _rl_to_lower (*s1) - _rl_to_lower (*s2);
2299: /* *s1 == [-_] && *s2 == [-_] */
2300: if ((*s1 == '-' || *s1 == '_') && (*s2 == '-' || *s2 == '_'))
2301: d = 0;
2302: if (d != 0)
2303: return 0;
2304: s1++; s2++; /* already checked convlen >= filename_len */
2305: }
2306: while (--len != 0);
2307: }
2308:
2309: return 1;
2310: }
2311: else if (_rl_completion_case_fold)
2312: {
2313: #if defined (HANDLE_MULTIBYTE)
2314: if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
2315: {
2316: do
2317: {
2318: v1 = mbrtowc (&wc1, s1, convlen, &ps1);
2319: v2 = mbrtowc (&wc2, s2, filename_len, &ps2);
2320: if (v1 == 0 && v2 == 0)
2321: return 1;
2322: else if (MB_INVALIDCH (v1) || MB_INVALIDCH (v2))
2323: {
2324: if (*s1 != *s2) /* do byte comparison */
2325: return 0;
2326: s1++; s2++; len--;
2327: continue;
2328: }
2329: wc1 = towlower (wc1);
2330: wc2 = towlower (wc2);
2331: if (wc1 != wc2)
2332: return 0;
2333: s1 += v1;
2334: s2 += v1;
2335: len -= v1;
2336: }
2337: while (len != 0);
2338: return 1;
2339: }
2340: else
2341: #endif
2342: if ((_rl_to_lower (convfn[0]) == _rl_to_lower (filename[0])) &&
2343: (convlen >= filename_len) &&
2344: (_rl_strnicmp (filename, convfn, filename_len) == 0))
2345: return 1;
2346: }
2347: else
2348: {
2349: if ((convfn[0] == filename[0]) &&
2350: (convlen >= filename_len) &&
2351: (strncmp (filename, convfn, filename_len) == 0))
2352: return 1;
2353: }
2354: return 0;
2355: }
2356:
2357: /* Okay, now we write the entry_function for filename completion. In the
2358: general case. Note that completion in the shell is a little different
2359: because of all the pathnames that must be followed when looking up the
2360: completion for a command. */
2361: char *
2362: rl_filename_completion_function (text, state)
2363: const char *text;
2364: int state;
2365: {
2366: static DIR *directory = (DIR *)NULL;
2367: static char *filename = (char *)NULL;
2368: static char *dirname = (char *)NULL;
2369: static char *users_dirname = (char *)NULL;
2370: static int filename_len;
2371: char *temp, *dentry, *convfn;
2372: int dirlen, dentlen, convlen;
2373: struct dirent *entry;
2374:
2375: /* If we don't have any state, then do some initialization. */
2376: if (state == 0)
2377: {
2378: /* If we were interrupted before closing the directory or reading
2379: all of its contents, close it. */
2380: if (directory)
2381: {
2382: closedir (directory);
2383: directory = (DIR *)NULL;
2384: }
2385: FREE (dirname);
2386: FREE (filename);
2387: FREE (users_dirname);
2388:
2389: filename = savestring (text);
2390: if (*text == 0)
2391: text = ".";
2392: dirname = savestring (text);
2393:
2394: temp = strrchr (dirname, '/');
2395:
2396: #if defined (__MSDOS__)
2397: /* special hack for //X/... */
2398: if (dirname[0] == '/' && dirname[1] == '/' && ISALPHA ((unsigned char)dirname[2]) && dirname[3] == '/')
2399: temp = strrchr (dirname + 3, '/');
2400: #endif
2401:
2402: if (temp)
2403: {
2404: strcpy (filename, ++temp);
2405: *temp = '\0';
2406: }
2407: #if defined (__MSDOS__)
2408: /* searches from current directory on the drive */
2409: else if (ISALPHA ((unsigned char)dirname[0]) && dirname[1] == ':')
2410: {
2411: strcpy (filename, dirname + 2);
2412: dirname[2] = '\0';
2413: }
2414: #endif
2415: else
2416: {
2417: dirname[0] = '.';
2418: dirname[1] = '\0';
2419: }
2420:
2421: /* We aren't done yet. We also support the "~user" syntax. */
2422:
2423: /* Save the version of the directory that the user typed, dequoting
2424: it if necessary. */
2425: if (rl_completion_found_quote && rl_filename_dequoting_function)
2426: users_dirname = (*rl_filename_dequoting_function) (dirname, rl_completion_quote_character);
2427: else
2428: users_dirname = savestring (dirname);
2429:
2430: if (*dirname == '~')
2431: {
2432: temp = tilde_expand (dirname);
2433: xfree (dirname);
2434: dirname = temp;
2435: }
2436:
2437: /* We have saved the possibly-dequoted version of the directory name
2438: the user typed. Now transform the directory name we're going to
2439: pass to opendir(2). The directory rewrite hook modifies only the
2440: directory name; the directory completion hook modifies both the
2441: directory name passed to opendir(2) and the version the user
2442: typed. Both the directory completion and rewrite hooks should perform
2443: any necessary dequoting. The hook functions return 1 if they modify
2444: the directory name argument. If either hook returns 0, it should
2445: not modify the directory name pointer passed as an argument. */
2446: if (rl_directory_rewrite_hook)
2447: (*rl_directory_rewrite_hook) (&dirname);
2448: else if (rl_directory_completion_hook && (*rl_directory_completion_hook) (&dirname))
2449: {
2450: xfree (users_dirname);
2451: users_dirname = savestring (dirname);
2452: }
2453: else if (rl_completion_found_quote && rl_filename_dequoting_function)
2454: {
2455: /* delete single and double quotes */
2456: xfree (dirname);
2457: dirname = savestring (users_dirname);
2458: }
2459: directory = opendir (dirname);
2460:
2461: /* Now dequote a non-null filename. FILENAME will not be NULL, but may
2462: be empty. */
2463: if (*filename && rl_completion_found_quote && rl_filename_dequoting_function)
2464: {
2465: /* delete single and double quotes */
2466: temp = (*rl_filename_dequoting_function) (filename, rl_completion_quote_character);
2467: xfree (filename);
2468: filename = temp;
2469: }
2470: filename_len = strlen (filename);
2471:
2472: rl_filename_completion_desired = 1;
2473: }
2474:
2475: /* At this point we should entertain the possibility of hacking wildcarded
2476: filenames, like /usr/man/man<WILD>/te<TAB>. If the directory name
2477: contains globbing characters, then build an array of directories, and
2478: then map over that list while completing. */
2479: /* *** UNIMPLEMENTED *** */
2480:
2481: /* Now that we have some state, we can read the directory. */
2482:
2483: entry = (struct dirent *)NULL;
2484: while (directory && (entry = readdir (directory)))
2485: {
2486: convfn = dentry = entry->d_name;
2487: convlen = dentlen = D_NAMLEN (entry);
2488:
2489: if (rl_filename_rewrite_hook)
2490: {
2491: convfn = (*rl_filename_rewrite_hook) (dentry, dentlen);
2492: convlen = (convfn == dentry) ? dentlen : strlen (convfn);
2493: }
2494:
2495: /* Special case for no filename. If the user has disabled the
2496: `match-hidden-files' variable, skip filenames beginning with `.'.
2497: All other entries except "." and ".." match. */
2498: if (filename_len == 0)
2499: {
2500: if (_rl_match_hidden_files == 0 && HIDDEN_FILE (convfn))
2501: continue;
2502:
2503: if (convfn[0] != '.' ||
2504: (convfn[1] && (convfn[1] != '.' || convfn[2])))
2505: break;
2506: }
2507: else
2508: {
2509: if (complete_fncmp (convfn, convlen, filename, filename_len))
2510: break;
2511: }
2512: }
2513:
2514: if (entry == 0)
2515: {
2516: if (directory)
2517: {
2518: closedir (directory);
2519: directory = (DIR *)NULL;
2520: }
2521: if (dirname)
2522: {
2523: xfree (dirname);
2524: dirname = (char *)NULL;
2525: }
2526: if (filename)
2527: {
2528: xfree (filename);
2529: filename = (char *)NULL;
2530: }
2531: if (users_dirname)
2532: {
2533: xfree (users_dirname);
2534: users_dirname = (char *)NULL;
2535: }
2536:
2537: return (char *)NULL;
2538: }
2539: else
2540: {
2541: /* dirname && (strcmp (dirname, ".") != 0) */
2542: if (dirname && (dirname[0] != '.' || dirname[1]))
2543: {
2544: if (rl_complete_with_tilde_expansion && *users_dirname == '~')
2545: {
2546: dirlen = strlen (dirname);
2547: temp = (char *)xmalloc (2 + dirlen + D_NAMLEN (entry));
2548: strcpy (temp, dirname);
2549: /* Canonicalization cuts off any final slash present. We
2550: may need to add it back. */
2551: if (dirname[dirlen - 1] != '/')
2552: {
2553: temp[dirlen++] = '/';
2554: temp[dirlen] = '\0';
2555: }
2556: }
2557: else
2558: {
2559: dirlen = strlen (users_dirname);
2560: temp = (char *)xmalloc (2 + dirlen + D_NAMLEN (entry));
2561: strcpy (temp, users_dirname);
2562: /* Make sure that temp has a trailing slash here. */
2563: if (users_dirname[dirlen - 1] != '/')
2564: temp[dirlen++] = '/';
2565: }
2566:
2567: strcpy (temp + dirlen, convfn);
2568: }
2569: else
2570: temp = savestring (convfn);
2571:
2572: if (convfn != dentry)
2573: xfree (convfn);
2574:
2575: return (temp);
2576: }
2577: }
2578:
2579: /* An initial implementation of a menu completion function a la tcsh. The
2580: first time (if the last readline command was not rl_old_menu_complete), we
2581: generate the list of matches. This code is very similar to the code in
2582: rl_complete_internal -- there should be a way to combine the two. Then,
2583: for each item in the list of matches, we insert the match in an undoable
2584: fashion, with the appropriate character appended (this happens on the
2585: second and subsequent consecutive calls to rl_old_menu_complete). When we
2586: hit the end of the match list, we restore the original unmatched text,
2587: ring the bell, and reset the counter to zero. */
2588: int
2589: rl_old_menu_complete (count, invoking_key)
2590: int count, invoking_key;
2591: {
2592: rl_compentry_func_t *our_func;
2593: int matching_filenames, found_quote;
2594:
2595: static char *orig_text;
2596: static char **matches = (char **)0;
2597: static int match_list_index = 0;
2598: static int match_list_size = 0;
2599: static int orig_start, orig_end;
2600: static char quote_char;
2601: static int delimiter;
2602:
2603: /* The first time through, we generate the list of matches and set things
2604: up to insert them. */
2605: if (rl_last_func != rl_old_menu_complete)
2606: {
2607: /* Clean up from previous call, if any. */
2608: FREE (orig_text);
2609: if (matches)
2610: _rl_free_match_list (matches);
2611:
2612: match_list_index = match_list_size = 0;
2613: matches = (char **)NULL;
2614:
2615: rl_completion_invoking_key = invoking_key;
2616:
2617: RL_SETSTATE(RL_STATE_COMPLETING);
2618:
2619: /* Only the completion entry function can change these. */
2620: set_completion_defaults ('%');
2621:
2622: our_func = rl_menu_completion_entry_function;
2623: if (our_func == 0)
2624: our_func = rl_completion_entry_function
2625: ? rl_completion_entry_function
2626: : rl_filename_completion_function;
2627:
2628: /* We now look backwards for the start of a filename/variable word. */
2629: orig_end = rl_point;
2630: found_quote = delimiter = 0;
2631: quote_char = '\0';
2632:
2633: if (rl_point)
2634: /* This (possibly) changes rl_point. If it returns a non-zero char,
2635: we know we have an open quote. */
2636: quote_char = _rl_find_completion_word (&found_quote, &delimiter);
2637:
2638: orig_start = rl_point;
2639: rl_point = orig_end;
2640:
2641: orig_text = rl_copy_text (orig_start, orig_end);
2642: matches = gen_completion_matches (orig_text, orig_start, orig_end,
2643: our_func, found_quote, quote_char);
2644:
2645: /* If we are matching filenames, the attempted completion function will
2646: have set rl_filename_completion_desired to a non-zero value. The basic
2647: rl_filename_completion_function does this. */
2648: matching_filenames = rl_filename_completion_desired;
2649:
2650: if (matches == 0 || postprocess_matches (&matches, matching_filenames) == 0)
2651: {
2652: rl_ding ();
2653: FREE (matches);
2654: matches = (char **)0;
2655: FREE (orig_text);
2656: orig_text = (char *)0;
2657: completion_changed_buffer = 0;
2658: RL_UNSETSTATE(RL_STATE_COMPLETING);
2659: return (0);
2660: }
2661:
2662: RL_UNSETSTATE(RL_STATE_COMPLETING);
2663:
2664: for (match_list_size = 0; matches[match_list_size]; match_list_size++)
2665: ;
2666: /* matches[0] is lcd if match_list_size > 1, but the circular buffer
2667: code below should take care of it. */
2668:
2669: if (match_list_size > 1 && _rl_complete_show_all)
2670: display_matches (matches);
2671: }
2672:
2673: /* Now we have the list of matches. Replace the text between
2674: rl_line_buffer[orig_start] and rl_line_buffer[rl_point] with
2675: matches[match_list_index], and add any necessary closing char. */
2676:
2677: if (matches == 0 || match_list_size == 0)
2678: {
2679: rl_ding ();
2680: FREE (matches);
2681: matches = (char **)0;
2682: completion_changed_buffer = 0;
2683: return (0);
2684: }
2685:
2686: match_list_index += count;
2687: if (match_list_index < 0)
2688: {
2689: while (match_list_index < 0)
2690: match_list_index += match_list_size;
2691: }
2692: else
2693: match_list_index %= match_list_size;
2694:
2695: if (match_list_index == 0 && match_list_size > 1)
2696: {
2697: rl_ding ();
2698: insert_match (orig_text, orig_start, MULT_MATCH, "e_char);
2699: }
2700: else
2701: {
2702: insert_match (matches[match_list_index], orig_start, SINGLE_MATCH, "e_char);
2703: append_to_match (matches[match_list_index], delimiter, quote_char,
2704: strcmp (orig_text, matches[match_list_index]));
2705: }
2706:
2707: completion_changed_buffer = 1;
2708: return (0);
2709: }
2710:
2711: int
2712: rl_menu_complete (count, ignore)
2713: int count, ignore;
2714: {
2715: rl_compentry_func_t *our_func;
2716: int matching_filenames, found_quote;
2717:
2718: static char *orig_text;
2719: static char **matches = (char **)0;
2720: static int match_list_index = 0;
2721: static int match_list_size = 0;
2722: static int nontrivial_lcd = 0;
2723: static int full_completion = 0; /* set to 1 if menu completion should reinitialize on next call */
2724: static int orig_start, orig_end;
2725: static char quote_char;
2726: static int delimiter, cstate;
2727:
2728: /* The first time through, we generate the list of matches and set things
2729: up to insert them. */
2730: if ((rl_last_func != rl_menu_complete && rl_last_func != rl_backward_menu_complete) || full_completion)
2731: {
2732: /* Clean up from previous call, if any. */
2733: FREE (orig_text);
2734: if (matches)
2735: _rl_free_match_list (matches);
2736:
2737: match_list_index = match_list_size = 0;
2738: matches = (char **)NULL;
2739:
2740: full_completion = 0;
2741:
2742: RL_SETSTATE(RL_STATE_COMPLETING);
2743:
2744: /* Only the completion entry function can change these. */
2745: set_completion_defaults ('%');
2746:
2747: our_func = rl_menu_completion_entry_function;
2748: if (our_func == 0)
2749: our_func = rl_completion_entry_function
2750: ? rl_completion_entry_function
2751: : rl_filename_completion_function;
2752:
2753: /* We now look backwards for the start of a filename/variable word. */
2754: orig_end = rl_point;
2755: found_quote = delimiter = 0;
2756: quote_char = '\0';
2757:
2758: if (rl_point)
2759: /* This (possibly) changes rl_point. If it returns a non-zero char,
2760: we know we have an open quote. */
2761: quote_char = _rl_find_completion_word (&found_quote, &delimiter);
2762:
2763: orig_start = rl_point;
2764: rl_point = orig_end;
2765:
2766: orig_text = rl_copy_text (orig_start, orig_end);
2767: matches = gen_completion_matches (orig_text, orig_start, orig_end,
2768: our_func, found_quote, quote_char);
2769:
2770: nontrivial_lcd = matches && strcmp (orig_text, matches[0]) != 0;
2771:
2772: /* If we are matching filenames, the attempted completion function will
2773: have set rl_filename_completion_desired to a non-zero value. The basic
2774: rl_filename_completion_function does this. */
2775: matching_filenames = rl_filename_completion_desired;
2776:
2777: if (matches == 0 || postprocess_matches (&matches, matching_filenames) == 0)
2778: {
2779: rl_ding ();
2780: FREE (matches);
2781: matches = (char **)0;
2782: FREE (orig_text);
2783: orig_text = (char *)0;
2784: completion_changed_buffer = 0;
2785: RL_UNSETSTATE(RL_STATE_COMPLETING);
2786: return (0);
2787: }
2788:
2789: RL_UNSETSTATE(RL_STATE_COMPLETING);
2790:
2791: for (match_list_size = 0; matches[match_list_size]; match_list_size++)
2792: ;
2793:
2794: if (match_list_size == 0)
2795: {
2796: rl_ding ();
2797: FREE (matches);
2798: matches = (char **)0;
2799: match_list_index = 0;
2800: completion_changed_buffer = 0;
2801: return (0);
2802: }
2803:
2804: /* matches[0] is lcd if match_list_size > 1, but the circular buffer
2805: code below should take care of it. */
2806: if (*matches[0])
2807: {
2808: insert_match (matches[0], orig_start, matches[1] ? MULT_MATCH : SINGLE_MATCH, "e_char);
2809: orig_end = orig_start + strlen (matches[0]);
2810: completion_changed_buffer = STREQ (orig_text, matches[0]) == 0;
2811: }
2812:
2813: if (match_list_size > 1 && _rl_complete_show_all)
2814: {
2815: display_matches (matches);
2816: /* If there are so many matches that the user has to be asked
2817: whether or not he wants to see the matches, menu completion
2818: is unwieldy. */
2819: if (rl_completion_query_items > 0 && match_list_size >= rl_completion_query_items)
2820: {
2821: rl_ding ();
2822: FREE (matches);
2823: matches = (char **)0;
2824: full_completion = 1;
2825: return (0);
2826: }
2827: else if (_rl_menu_complete_prefix_first)
2828: {
2829: rl_ding ();
2830: return (0);
2831: }
2832: }
2833: else if (match_list_size <= 1)
2834: {
2835: append_to_match (matches[0], delimiter, quote_char, nontrivial_lcd);
2836: full_completion = 1;
2837: return (0);
2838: }
2839: else if (_rl_menu_complete_prefix_first && match_list_size > 1)
2840: {
2841: rl_ding ();
2842: return (0);
2843: }
2844: }
2845:
2846: /* Now we have the list of matches. Replace the text between
2847: rl_line_buffer[orig_start] and rl_line_buffer[rl_point] with
2848: matches[match_list_index], and add any necessary closing char. */
2849:
2850: if (matches == 0 || match_list_size == 0)
2851: {
2852: rl_ding ();
2853: FREE (matches);
2854: matches = (char **)0;
2855: completion_changed_buffer = 0;
2856: return (0);
2857: }
2858:
2859: match_list_index += count;
2860: if (match_list_index < 0)
2861: {
2862: while (match_list_index < 0)
2863: match_list_index += match_list_size;
2864: }
2865: else
2866: match_list_index %= match_list_size;
2867:
2868: if (match_list_index == 0 && match_list_size > 1)
2869: {
2870: rl_ding ();
2871: insert_match (matches[0], orig_start, MULT_MATCH, "e_char);
2872: }
2873: else
2874: {
2875: insert_match (matches[match_list_index], orig_start, SINGLE_MATCH, "e_char);
2876: append_to_match (matches[match_list_index], delimiter, quote_char,
2877: strcmp (orig_text, matches[match_list_index]));
2878: }
2879:
2880: completion_changed_buffer = 1;
2881: return (0);
2882: }
2883:
2884: int
2885: rl_backward_menu_complete (count, key)
2886: int count, key;
2887: {
2888: /* Positive arguments to backward-menu-complete translate into negative
2889: arguments for menu-complete, and vice versa. */
2890: return (rl_menu_complete (-count, key));
2891: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to complete.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / readline