1 /* complete.c -- filename completion for readline. */
3 /* Copyright (C) 1987, 1989, 1992 Free Software Foundation, Inc.
5 This file is part of the GNU Readline Library, a library for
6 reading lines of text with interactive input and history editing.
8 The GNU Readline Library is free software; you can redistribute it
9 and/or modify it under the terms of the GNU General Public License
10 as published by the Free Software Foundation; either version 1, or
11 (at your option) any later version.
13 The GNU Readline Library is distributed in the hope that it will be
14 useful, but WITHOUT ANY WARRANTY; without even the implied warranty
15 of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 The GNU General Public License is often shipped with GNU software, and
19 is generally kept in a file called COPYING or LICENSE. If you do not
20 have a copy of the license, write to the Free Software Foundation,
21 675 Mass Ave, Cambridge, MA 02139, USA. */
22 #define READLINE_LIBRARY
24 #if defined (HAVE_CONFIG_H)
28 #include <sys/types.h>
30 #if defined (HAVE_SYS_FILE_H)
34 #if defined (HAVE_UNISTD_H)
36 #endif /* HAVE_UNISTD_H */
38 #if defined (HAVE_STDLIB_H)
41 # include "ansi_stdlib.h"
42 #endif /* HAVE_STDLIB_H */
52 #if !defined (HAVE_GETPW_DECLS)
53 extern struct passwd
*getpwent ();
54 #endif /* USG && !HAVE_GETPW_DECLS */
56 /* ISC systems don't define getpwent() if _POSIX_SOURCE is defined. */
57 #if defined (isc386) && defined (_POSIX_SOURCE)
58 # if defined (__STDC__)
59 extern struct passwd
*getpwent (void);
61 extern struct passwd
*getpwent ();
62 # endif /* !__STDC__ */
63 #endif /* isc386 && _POSIX_SOURCE */
66 #include "posixstat.h"
68 /* System-specific feature definitions and include files. */
71 /* Some standard library routines. */
74 extern char *tilde_expand ();
75 extern char *rl_copy_text ();
76 extern void _rl_abort_internal ();
77 extern int _rl_qsort_string_compare ();
79 extern Function
*rl_last_func
;
80 extern int rl_editing_mode
;
81 extern int screenwidth
;
83 extern void _rl_move_vert ();
84 extern int _rl_vis_botlin
;
85 extern int rl_display_fixed
;
87 /* Forward declarations for functions defined and used in this file. */
88 char *filename_completion_function ();
89 char **completion_matches ();
91 static char *rl_quote_filename ();
92 static char *rl_strpbrk ();
94 static char **remove_duplicate_matches ();
95 static void insert_text ();
96 static void insert_match ();
97 static void append_to_match ();
98 static void insert_all_matches ();
99 static void display_matches ();
100 static int compute_lcd_of_matches ();
102 extern char *xmalloc (), *xrealloc ();
104 /* If non-zero, then this is the address of a function to call when
105 completing on a directory name. The function is called with
106 the address of a string (the current directory name) as an arg. */
107 Function
*rl_directory_completion_hook
= (Function
*)NULL
;
109 /* Non-zero means readline completion functions perform tilde expansion. */
110 int rl_complete_with_tilde_expansion
= 0;
112 /* If non-zero, non-unique completions always show the list of matches. */
113 int _rl_complete_show_all
= 0;
115 /* If non-zero, completed directory names have a slash appended. */
116 int _rl_complete_mark_directories
= 1;
118 #if defined (VISIBLE_STATS)
123 static int stat_char ();
125 /* Non-zero means add an additional character to each filename displayed
126 during listing completion iff rl_filename_completion_desired which helps
127 to indicate the type of file being listed. */
128 int rl_visible_stats
= 0;
129 #endif /* VISIBLE_STATS */
131 /* **************************************************************** */
133 /* Completion matching, from readline's point of view. */
135 /* **************************************************************** */
137 /* Local variable states what happened during the last completion attempt. */
138 static int completion_changed_buffer
;
140 /* Pointer to the generator function for completion_matches ().
141 NULL means to use filename_completion_function (), the default filename
143 Function
*rl_completion_entry_function
= (Function
*)NULL
;
145 /* Pointer to alternative function to create matches.
146 Function is called with TEXT, START, and END.
147 START and END are indices in RL_LINE_BUFFER saying what the boundaries
149 If this function exists and returns NULL then call the value of
150 rl_completion_entry_function to try to match, otherwise use the
151 array of strings returned. */
152 CPPFunction
*rl_attempted_completion_function
= (CPPFunction
*)NULL
;
154 /* Non-zero means to suppress normal filename completion after the
155 user-specified completion function has been called. */
156 int rl_attempted_completion_over
= 0;
158 /* Set to a character indicating the type of completion being performed
159 by rl_complete_internal, available for use by application completion
161 int rl_completion_type
= 0;
163 /* Up to this many items will be displayed in response to a
164 possible-completions call. After that, we ask the user if
165 she is sure she wants to see them all. */
166 int rl_completion_query_items
= 100;
168 /* The basic list of characters that signal a break between words for the
169 completer routine. The contents of this variable is what breaks words
170 in the shell, i.e. " \t\n\"\\'`@$><=" */
171 char *rl_basic_word_break_characters
= " \t\n\"\\'`@$><=;|&{(";
173 /* List of basic quoting characters. */
174 char *rl_basic_quote_characters
= "\"'";
176 /* The list of characters that signal a break between words for
177 rl_complete_internal. The default list is the contents of
178 rl_basic_word_break_characters. */
179 char *rl_completer_word_break_characters
= (char *)NULL
;
181 /* List of characters which can be used to quote a substring of the line.
182 Completion occurs on the entire substring, and within the substring
183 rl_completer_word_break_characters are treated as any other character,
184 unless they also appear within this list. */
185 char *rl_completer_quote_characters
= (char *)NULL
;
187 /* List of characters that should be quoted in filenames by the completer. */
188 char *rl_filename_quote_characters
= (char *)NULL
;
190 /* List of characters that are word break characters, but should be left
191 in TEXT when it is passed to the completion function. The shell uses
192 this to help determine what kind of completing to do. */
193 char *rl_special_prefixes
= (char *)NULL
;
195 /* If non-zero, then disallow duplicates in the matches. */
196 int rl_ignore_completion_duplicates
= 1;
198 /* Non-zero means that the results of the matches are to be treated
199 as filenames. This is ALWAYS zero on entry, and can only be changed
200 within a completion entry finder function. */
201 int rl_filename_completion_desired
= 0;
203 /* Non-zero means that the results of the matches are to be quoted using
204 double quotes (or an application-specific quoting mechanism) if the
205 filename contains any characters in rl_filename_quote_chars. This is
206 ALWAYS non-zero on entry, and can only be changed within a completion
207 entry finder function. */
208 int rl_filename_quoting_desired
= 1;
210 /* This function, if defined, is called by the completer when real
211 filename completion is done, after all the matching names have been
212 generated. It is passed a (char**) known as matches in the code below.
213 It consists of a NULL-terminated array of pointers to potential
214 matching strings. The 1st element (matches[0]) is the maximal
215 substring that is common to all matches. This function can re-arrange
216 the list of matches as required, but all elements of the array must be
217 free()'d if they are deleted. The main intent of this function is
218 to implement FIGNORE a la SunOS csh. */
219 Function
*rl_ignore_some_completions_function
= (Function
*)NULL
;
221 /* Set to a function to quote a filename in an application-specific fashion.
222 Called with the text to quote, the type of match found (single or multiple)
223 and a pointer to the quoting character to be used, which the function can
225 CPFunction
*rl_filename_quoting_function
= rl_quote_filename
;
227 /* Function to call to remove quoting characters from a filename. Called
228 before completion is attempted, so the embedded quotes do not interfere
229 with matching names in the file system. Readline doesn't do anything
230 with this; it's set only by applications. */
231 CPFunction
*rl_filename_dequoting_function
= (CPFunction
*)NULL
;
233 /* Function to call to decide whether or not a word break character is
234 quoted. If a character is quoted, it does not break words for the
236 Function
*rl_char_is_quoted_p
= (Function
*)NULL
;
238 /* Character appended to completed words when at the end of the line. The
239 default is a space. */
240 int rl_completion_append_character
= ' ';
242 /* If non-zero, inhibit completion (temporarily). */
243 int rl_inhibit_completion
;
245 /* Complete the word at or before point. You have supplied the function
246 that does the initial simple matching selection algorithm (see
247 completion_matches ()). The default is to do filename completion. */
249 rl_complete (ignore
, invoking_key
)
250 int ignore
, invoking_key
;
252 if (rl_inhibit_completion
)
253 return (rl_insert (ignore
, invoking_key
));
254 else if (rl_last_func
== rl_complete
&& !completion_changed_buffer
)
255 return (rl_complete_internal ('?'));
256 else if (_rl_complete_show_all
)
257 return (rl_complete_internal ('!'));
259 return (rl_complete_internal (TAB
));
262 /* List the possible completions. See description of rl_complete (). */
264 rl_possible_completions (ignore
, invoking_key
)
265 int ignore
, invoking_key
;
267 return (rl_complete_internal ('?'));
271 rl_insert_completions (ignore
, invoking_key
)
272 int ignore
, invoking_key
;
274 return (rl_complete_internal ('*'));
277 /* The user must press "y" or "n". Non-zero return means "y" pressed. */
286 if (c
== 'y' || c
== 'Y' || c
== ' ')
288 if (c
== 'n' || c
== 'N' || c
== RUBOUT
)
291 _rl_abort_internal ();
296 /* Return the portion of PATHNAME that should be output when listing
297 possible completions. If we are hacking filename completion, we
298 are only interested in the basename, the portion following the
299 final slash. Otherwise, we return what we were passed. */
301 printable_part (pathname
)
306 temp
= rl_filename_completion_desired
? strrchr (pathname
, '/') : (char *)NULL
;
307 return (temp
? ++temp
: pathname
);
310 /* Output TO_PRINT to rl_outstream. If VISIBLE_STATS is defined and we
311 are using it, check for and output a single character for `special'
312 filenames. Return 1 if we printed an extension character, 0 if not. */
317 putc ('^', rl_outstream); \
318 putc (UNCTRL (c), rl_outstream); \
320 else if (c == RUBOUT) \
322 putc ('^', rl_outstream); \
323 putc ('?', rl_outstream); \
326 putc (c, rl_outstream)
329 print_filename (to_print
, full_pathname
)
330 char *to_print
, *full_pathname
;
332 #if !defined (VISIBLE_STATS)
335 for (s
= to_print
; *s
; s
++)
341 char *s
, c
, *new_full_pathname
;
342 int extension_char
, slen
, tlen
;
344 for (s
= to_print
; *s
; s
++)
349 if (rl_filename_completion_desired
&& rl_visible_stats
)
351 /* If to_print != full_pathname, to_print is the basename of the
352 path passed. In this case, we try to expand the directory
353 name before checking for the stat character. */
354 if (to_print
!= full_pathname
)
356 /* Terminate the directory name. */
360 s
= tilde_expand (full_pathname
);
361 if (rl_directory_completion_hook
)
362 (*rl_directory_completion_hook
) (&s
);
365 tlen
= strlen (to_print
);
366 new_full_pathname
= xmalloc (slen
+ tlen
+ 2);
367 strcpy (new_full_pathname
, s
);
368 new_full_pathname
[slen
] = '/';
369 strcpy (new_full_pathname
+ slen
+ 1, to_print
);
371 extension_char
= stat_char (new_full_pathname
);
373 free (new_full_pathname
);
378 s
= tilde_expand (full_pathname
);
379 extension_char
= stat_char (s
);
384 putc (extension_char
, rl_outstream
);
385 return (extension_char
!= 0);
389 #endif /* VISIBLE_STATS */
393 rl_quote_filename (s
, rtype
, qcp
)
400 r
= xmalloc (strlen (s
) + 2);
401 *r
= *rl_completer_quote_characters
;
404 *qcp
= *rl_completer_quote_characters
;
408 /* Find the bounds of the current word for completion purposes, and leave
409 rl_point set to the end of the word. This function skips quoted
410 substrings (characters between matched pairs of characters in
411 rl_completer_quote_characters. First we try to find an unclosed
412 quoted substring on which to do matching. If one is not found, we use
413 the word break characters to find the boundaries of the current word.
414 We call an application-specific function to decide whether or not a
415 particular word break character is quoted; if that function returns a
416 non-zero result, the character does not break a word. This function
417 returns the opening quote character if we found an unclosed quoted
418 substring, '\0' otherwise. FP, if non-null, is set to a value saying
419 which (shell-like) quote characters we found (single quote, double
420 quote, or backslash) anywhere in the string. DP, if non-null, is set to
421 the value of the delimiter character that caused a word break. */
424 find_completion_word (fp
, dp
)
427 int scan
, end
, found_quote
, delimiter
, pass_next
, isbrk
;
431 found_quote
= delimiter
= 0;
434 if (rl_completer_quote_characters
)
436 /* We have a list of characters which can be used in pairs to
437 quote substrings for the completer. Try to find the start
438 of an unclosed quoted substring. */
439 /* FOUND_QUOTE is set so we know what kind of quotes we found. */
440 for (scan
= pass_next
= 0; scan
< end
; scan
++)
448 if (rl_line_buffer
[scan
] == '\\')
451 found_quote
|= RL_QF_BACKSLASH
;
455 if (quote_char
!= '\0')
457 /* Ignore everything until the matching close quote char. */
458 if (rl_line_buffer
[scan
] == quote_char
)
460 /* Found matching close. Abandon this substring. */
465 else if (strchr (rl_completer_quote_characters
, rl_line_buffer
[scan
]))
467 /* Found start of a quoted substring. */
468 quote_char
= rl_line_buffer
[scan
];
470 /* Shell-like quoting conventions. */
471 if (quote_char
== '\'')
472 found_quote
|= RL_QF_SINGLE_QUOTE
;
473 else if (quote_char
== '"')
474 found_quote
|= RL_QF_DOUBLE_QUOTE
;
479 if (rl_point
== end
&& quote_char
== '\0')
481 /* We didn't find an unclosed quoted substring upon which to do
482 completion, so use the word break characters to find the
483 substring on which to complete. */
486 scan
= rl_line_buffer
[rl_point
];
488 if (strchr (rl_completer_word_break_characters
, scan
) == 0)
491 /* Call the application-specific function to tell us whether
492 this word break character is quoted and should be skipped. */
493 if (rl_char_is_quoted_p
&& found_quote
&&
494 (*rl_char_is_quoted_p
) (rl_line_buffer
, rl_point
))
497 /* Convoluted code, but it avoids an n^2 algorithm with calls
498 to char_is_quoted. */
503 /* If we are at an unquoted word break, then advance past it. */
504 scan
= rl_line_buffer
[rl_point
];
506 /* If there is an application-specific function to say whether or not
507 a character is quoted and we found a quote character, let that
508 function decide whether or not a character is a word break, even
509 if it is found in rl_completer_word_break_characters. */
510 if (rl_char_is_quoted_p
)
511 isbrk
= (found_quote
== 0 ||
512 (*rl_char_is_quoted_p
) (rl_line_buffer
, rl_point
) == 0) &&
513 strchr (rl_completer_word_break_characters
, scan
) != 0;
515 isbrk
= strchr (rl_completer_word_break_characters
, scan
) != 0;
519 /* If the character that caused the word break was a quoting
520 character, then remember it as the delimiter. */
521 if (rl_basic_quote_characters
&& strchr (rl_basic_quote_characters
, scan
) && (end
- rl_point
) > 1)
524 /* If the character isn't needed to determine something special
525 about what kind of completion to perform, then advance past it. */
526 if (rl_special_prefixes
== 0 || strchr (rl_special_prefixes
, scan
) == 0)
539 gen_completion_matches (text
, start
, end
, our_func
, found_quote
, quote_char
)
543 int found_quote
, quote_char
;
545 char **matches
, *temp
;
547 /* If the user wants to TRY to complete, but then wants to give
548 up and use the default completion function, they set the
549 variable rl_attempted_completion_function. */
550 if (rl_attempted_completion_function
)
552 matches
= (*rl_attempted_completion_function
) (text
, start
, end
);
554 if (matches
|| rl_attempted_completion_over
)
556 rl_attempted_completion_over
= 0;
561 /* Beware -- we're stripping the quotes here. Do this only if we know
562 we are doing filename completion and the application has defined a
563 filename dequoting function. */
565 if (found_quote
&& our_func
== (Function
*)filename_completion_function
&&
566 rl_filename_dequoting_function
)
568 /* delete single and double quotes */
569 temp
= (*rl_filename_dequoting_function
) (text
, quote_char
);
570 text
= temp
; /* not freeing text is not a memory leak */
573 matches
= completion_matches (text
, our_func
);
578 /* Filter out duplicates in MATCHES. This frees up the strings in
581 remove_duplicate_matches (matches
)
589 /* Sort the items. */
590 for (i
= 0; matches
[i
]; i
++)
593 /* Sort the array without matches[0], since we need it to
594 stay in place no matter what. */
596 qsort (matches
+1, i
-1, sizeof (char *), _rl_qsort_string_compare
);
598 /* Remember the lowest common denominator for it may be unique. */
599 lowest_common
= savestring (matches
[0]);
601 for (i
= newlen
= 0; matches
[i
+ 1]; i
++)
603 if (strcmp (matches
[i
], matches
[i
+ 1]) == 0)
606 matches
[i
] = (char *)&dead_slot
;
612 /* We have marked all the dead slots with (char *)&dead_slot.
613 Copy all the non-dead entries into a new array. */
614 temp_array
= (char **)xmalloc ((3 + newlen
) * sizeof (char *));
615 for (i
= j
= 1; matches
[i
]; i
++)
617 if (matches
[i
] != (char *)&dead_slot
)
618 temp_array
[j
++] = matches
[i
];
620 temp_array
[j
] = (char *)NULL
;
622 if (matches
[0] != (char *)&dead_slot
)
625 /* Place the lowest common denominator back in [0]. */
626 temp_array
[0] = lowest_common
;
628 /* If there is one string left, and it is identical to the
629 lowest common denominator, then the LCD is the string to
631 if (j
== 2 && strcmp (temp_array
[0], temp_array
[1]) == 0)
633 free (temp_array
[1]);
634 temp_array
[1] = (char *)NULL
;
640 display_matches (matches
)
643 int len
, count
, limit
, max
, printed_len
;
647 /* Move to the last visible line of a possibly-multiple-line command. */
648 _rl_move_vert (_rl_vis_botlin
);
650 /* Handle simple case first. What if there is only one answer? */
653 temp
= printable_part (matches
[0]);
655 print_filename (temp
, matches
[0]);
660 rl_forced_update_display ();
661 rl_display_fixed
= 1;
666 /* There is more than one answer. Find out how many there are,
667 and find the maximum printed length of a single entry. */
668 for (max
= 0, i
= 1; matches
[i
]; i
++)
670 temp
= printable_part (matches
[i
]);
679 /* If there are many items, then ask the user if she really wants to
681 if (len
>= rl_completion_query_items
)
684 fprintf (rl_outstream
, "Display all %d possibilities? (y or n)", len
);
685 fflush (rl_outstream
);
686 if (get_y_or_n () == 0)
692 rl_forced_update_display ();
693 rl_display_fixed
= 1;
699 /* How many items of MAX length can we fit in the screen window? */
701 limit
= screenwidth
/ max
;
702 if (limit
!= 1 && (limit
* max
== screenwidth
))
705 /* Avoid a possible floating exception. If max > screenwidth,
706 limit will be 0 and a divide-by-zero fault will result. */
710 /* How many iterations of the printing loop? */
711 count
= (len
+ (limit
- 1)) / limit
;
713 /* Watch out for special case. If LEN is less than LIMIT, then
714 just do the inner printing loop.
715 0 < len <= limit implies count = 1. */
717 /* Sort the items if they are not already sorted. */
718 if (rl_ignore_completion_duplicates
== 0)
719 qsort (matches
+ 1, len
, sizeof (char *), _rl_qsort_string_compare
);
721 /* Print the sorted items, up-and-down alphabetically, like ls. */
724 for (i
= 1; i
<= count
; i
++)
726 for (j
= 0, l
= i
; j
< limit
; j
++)
728 if (l
> len
|| matches
[l
] == 0)
732 temp
= printable_part (matches
[l
]);
733 printed_len
= strlen (temp
) + print_filename (temp
, matches
[l
]);
736 for (k
= 0; k
< max
- printed_len
; k
++)
737 putc (' ', rl_outstream
);
747 rl_forced_update_display ();
748 rl_display_fixed
= 1;
753 insert_text (text
, start
, end
)
757 rl_begin_undo_group ();
758 rl_delete_text (start
, end
+ 1);
760 rl_insert_text (text
);
761 rl_end_undo_group ();
765 make_quoted_replacement (match
, mtype
, qc
)
768 char *qc
; /* Pointer to quoting character, if any */
770 int should_quote
, do_replace
;
773 /* If we are doing completion on quoted substrings, and any matches
774 contain any of the completer_word_break_characters, then auto-
775 matically prepend the substring with a quote character (just pick
776 the first one from the list of such) if it does not already begin
777 with a quote string. FIXME: Need to remove any such automatically
778 inserted quote character when it no longer is necessary, such as
779 if we change the string we are completing on and the new set of
780 matches don't require a quoted substring. */
783 should_quote
= match
&& rl_completer_quote_characters
&&
784 rl_filename_completion_desired
&&
785 rl_filename_quoting_desired
;
789 should_quote
= should_quote
&& (!qc
|| !*qc
|| *qc
== '"' || *qc
== '\'');
791 should_quote
= should_quote
&& (!qc
|| !*qc
);
796 /* If there is a single match, see if we need to quote it.
797 This also checks whether the common prefix of several
798 matches needs to be quoted. */
799 should_quote
= rl_filename_quote_characters
800 ? (rl_strpbrk (match
, rl_filename_quote_characters
) != 0)
803 do_replace
= should_quote
? mtype
: NO_MATCH
;
804 /* Quote the replacement, since we found an embedded
805 word break character in a potential match. */
806 if (do_replace
!= NO_MATCH
&& rl_filename_quoting_function
)
807 replacement
= (*rl_filename_quoting_function
) (match
, do_replace
, qc
);
809 return (replacement
);
813 insert_match (match
, start
, mtype
, qc
)
821 oqc
= qc
? *qc
: '\0';
822 replacement
= make_quoted_replacement (match
, mtype
, qc
);
824 /* Now insert the match. */
827 /* Don't double an opening quote character. */
828 if (qc
&& *qc
&& start
&& rl_line_buffer
[start
- 1] == *qc
&&
829 replacement
[0] == *qc
)
831 /* If make_quoted_replacement changed the quoting character, remove
832 the opening quote and insert the (fully-quoted) replacement. */
833 else if (qc
&& (*qc
!= oqc
) && start
&& rl_line_buffer
[start
- 1] == oqc
&&
834 replacement
[0] != oqc
)
836 insert_text (replacement
, start
, rl_point
- 1);
837 if (replacement
!= match
)
842 /* Append any necessary closing quote and a separator character to the
843 just-inserted match. If the user has specified that directories
844 should be marked by a trailing `/', append one of those instead. The
845 default trailing character */
847 append_to_match (text
, delimiter
, quote_char
)
849 int delimiter
, quote_char
;
851 char temp_string
[4], *filename
;
852 int temp_string_index
;
855 temp_string_index
= 0;
856 if (quote_char
&& rl_point
&& rl_line_buffer
[rl_point
- 1] != quote_char
)
857 temp_string
[temp_string_index
++] = quote_char
;
860 temp_string
[temp_string_index
++] = delimiter
;
861 else if (rl_completion_append_character
)
862 temp_string
[temp_string_index
++] = rl_completion_append_character
;
864 temp_string
[temp_string_index
++] = '\0';
866 if (rl_filename_completion_desired
)
868 filename
= tilde_expand (text
);
869 if (stat (filename
, &finfo
) == 0 && S_ISDIR (finfo
.st_mode
))
871 if (_rl_complete_mark_directories
&& rl_line_buffer
[rl_point
] != '/')
872 rl_insert_text ("/");
876 if (rl_point
== rl_end
)
877 rl_insert_text (temp_string
);
883 if (rl_point
== rl_end
)
884 rl_insert_text (temp_string
);
889 insert_all_matches (matches
, point
, qc
)
897 rl_begin_undo_group ();
898 /* remove any opening quote character; make_quoted_replacement will add
900 if (qc
&& *qc
&& point
&& rl_line_buffer
[point
- 1] == *qc
)
902 rl_delete_text (point
, rl_point
);
907 for (i
= 1; matches
[i
]; i
++)
909 rp
= make_quoted_replacement (matches
[i
], SINGLE_MATCH
, qc
);
911 rl_insert_text (" ");
912 if (rp
!= matches
[i
])
918 rp
= make_quoted_replacement (matches
[0], SINGLE_MATCH
, qc
);
920 rl_insert_text (" ");
921 if (rp
!= matches
[0])
924 rl_end_undo_group ();
927 /* Complete the word at or before point.
928 WHAT_TO_DO says what to do with the completion.
929 `?' means list the possible completions.
930 TAB means do standard completion.
931 `*' means insert all of the possible completions.
932 `!' means to do standard completion, and list all possible completions if
933 there is more than one. */
935 rl_complete_internal (what_to_do
)
938 char **matches
, **temp_matches
;
940 int start
, end
, delimiter
, found_quote
, nmatch
, i
;
941 char *text
, *saved_line_buffer
, *t
;
944 saved_line_buffer
= rl_line_buffer
? savestring (rl_line_buffer
) : (char *)NULL
;
946 our_func
= rl_completion_entry_function
947 ? rl_completion_entry_function
948 : (Function
*)filename_completion_function
;
950 /* Only the completion entry function can change these. */
951 rl_filename_completion_desired
= 0;
952 rl_filename_quoting_desired
= 1;
954 rl_completion_type
= what_to_do
;
956 /* We now look backwards for the start of a filename/variable word. */
959 found_quote
= delimiter
= 0;
963 /* This (possibly) changes rl_point. If it returns a non-zero char,
964 we know we have an open quote. */
965 quote_char
= find_completion_word (&found_quote
, &delimiter
);
970 text
= rl_copy_text (start
, end
);
971 matches
= gen_completion_matches (text
, start
, end
, our_func
, found_quote
, quote_char
);
976 FREE (saved_line_buffer
);
981 /* It seems to me that in all the cases we handle we would like
982 to ignore duplicate possiblilities. Scan for the text to
983 insert being identical to the other completions. */
984 if (rl_ignore_completion_duplicates
)
986 temp_matches
= remove_duplicate_matches (matches
);
988 matches
= temp_matches
;
991 /* If we are matching filenames, then here is our chance to
992 do clever processing by re-examining the list. Call the
993 ignore function with the array as a parameter. It can
994 munge the array, deleting matches as it desires. */
995 if (rl_ignore_some_completions_function
&&
996 our_func
== (Function
*)filename_completion_function
)
998 for (nmatch
= 1; matches
[nmatch
]; nmatch
++)
1000 (void)(*rl_ignore_some_completions_function
) (matches
);
1001 if (matches
== 0 || matches
[0] == 0)
1005 FREE (saved_line_buffer
);
1011 /* If we removed some matches, recompute the common prefix. */
1012 for (i
= 1; matches
[i
]; i
++)
1014 if (i
> 1 && i
< nmatch
)
1017 compute_lcd_of_matches (matches
, i
- 1, text
);
1028 /* Insert the first match with proper quoting. */
1030 insert_match (matches
[0], start
, matches
[1] ? MULT_MATCH
: SINGLE_MATCH
, "e_char
);
1032 /* If there are more matches, ring the bell to indicate.
1033 If we are in vi mode, Posix.2 says to not ring the bell.
1034 If the `show-all-if-ambiguous' variable is set, display
1035 all the matches immediately. Otherwise, if this was the
1036 only match, and we are hacking files, check the file to
1037 see if it was a directory. If so, and the `mark-directories'
1038 variable is set, add a '/' to the name. If not, and we
1039 are at the end of the line, then add a space. */
1042 if (what_to_do
== '!')
1044 display_matches (matches
);
1047 else if (rl_editing_mode
!= vi_mode
)
1048 ding (); /* There are other matches remaining. */
1051 append_to_match (matches
[0], delimiter
, quote_char
);
1056 insert_all_matches (matches
, start
, "e_char
);
1060 display_matches (matches
);
1064 fprintf (stderr
, "\r\nreadline: bad value %d for what_to_do in rl_complete\n", what_to_do
);
1066 FREE (saved_line_buffer
);
1070 for (i
= 0; matches
[i
]; i
++)
1074 /* Check to see if the line has changed through all of this manipulation. */
1075 if (saved_line_buffer
)
1077 completion_changed_buffer
= strcmp (rl_line_buffer
, saved_line_buffer
) != 0;
1078 free (saved_line_buffer
);
1084 #if defined (VISIBLE_STATS)
1085 /* Return the character which best describes FILENAME.
1086 `@' for symbolic links
1091 `%' for character special devices
1092 `#' for block special devices */
1094 stat_char (filename
)
1100 #if defined (HAVE_LSTAT) && defined (S_ISLNK)
1101 r
= lstat (filename
, &finfo
);
1103 r
= stat (filename
, &finfo
);
1110 if (S_ISDIR (finfo
.st_mode
))
1112 #if defined (S_ISCHR)
1113 else if (S_ISCHR (finfo
.st_mode
))
1115 #endif /* S_ISCHR */
1116 #if defined (S_ISBLK)
1117 else if (S_ISBLK (finfo
.st_mode
))
1119 #endif /* S_ISBLK */
1120 #if defined (S_ISLNK)
1121 else if (S_ISLNK (finfo
.st_mode
))
1123 #endif /* S_ISLNK */
1124 #if defined (S_ISSOCK)
1125 else if (S_ISSOCK (finfo
.st_mode
))
1127 #endif /* S_ISSOCK */
1128 #if defined (S_ISFIFO)
1129 else if (S_ISFIFO (finfo
.st_mode
))
1132 else if (S_ISREG (finfo
.st_mode
))
1134 if (access (filename
, X_OK
) == 0)
1139 #endif /* VISIBLE_STATS */
1141 /* A completion function for usernames.
1142 TEXT contains a partial username preceded by a random
1143 character (usually `~'). */
1145 username_completion_function (text
, state
)
1149 #if defined (__GO32__) || defined (__WIN32__)
1150 return (char *)NULL
;
1151 #else /* !__GO32__ */
1152 static char *username
= (char *)NULL
;
1153 static struct passwd
*entry
;
1154 static int namelen
, first_char
, first_char_loc
;
1162 first_char_loc
= first_char
== '~';
1164 username
= savestring (&text
[first_char_loc
]);
1165 namelen
= strlen (username
);
1169 while (entry
= getpwent ())
1171 /* Null usernames should result in all users as possible completions. */
1172 if (namelen
== 0 || (STREQN (username
, entry
->pw_name
, namelen
)))
1179 return ((char *)NULL
);
1183 value
= xmalloc (2 + strlen (entry
->pw_name
));
1187 strcpy (value
+ first_char_loc
, entry
->pw_name
);
1189 if (first_char
== '~')
1190 rl_filename_completion_desired
= 1;
1194 #endif /* !__GO32__ */
1197 /* **************************************************************** */
1201 /* **************************************************************** */
1203 /* Non-zero means that case is not significant in completion. */
1204 int completion_case_fold
= 0;
1206 /* Find the common prefix of the list of matches, and put it into
1209 compute_lcd_of_matches (match_list
, matches
, text
)
1214 register int i
, c1
, c2
, si
;
1215 int low
; /* Count of max-matched characters. */
1217 /* If only one match, just use that. Otherwise, compare each
1218 member of the list with the next, finding out where they
1222 match_list
[0] = match_list
[1];
1223 match_list
[1] = (char *)NULL
;
1227 for (i
= 1, low
= 100000; i
< matches
; i
++)
1229 if (completion_case_fold
)
1232 (c1
= _rl_to_lower(match_list
[i
][si
])) &&
1233 (c2
= _rl_to_lower(match_list
[i
+ 1][si
]));
1241 (c1
= match_list
[i
][si
]) &&
1242 (c2
= match_list
[i
+ 1][si
]);
1252 /* If there were multiple matches, but none matched up to even the
1253 first character, and the user typed something, use that as the
1254 value of matches[0]. */
1255 if (low
== 0 && text
&& *text
)
1257 match_list
[0] = xmalloc (strlen (text
) + 1);
1258 strcpy (match_list
[0], text
);
1262 match_list
[0] = xmalloc (low
+ 1);
1263 strncpy (match_list
[0], match_list
[1], low
);
1264 match_list
[0][low
] = '\0';
1270 /* Return an array of (char *) which is a list of completions for TEXT.
1271 If there are no completions, return a NULL pointer.
1272 The first entry in the returned array is the substitution for TEXT.
1273 The remaining entries are the possible completions.
1274 The array is terminated with a NULL pointer.
1276 ENTRY_FUNCTION is a function of two args, and returns a (char *).
1277 The first argument is TEXT.
1278 The second is a state argument; it should be zero on the first call, and
1279 non-zero on subsequent calls. It returns a NULL pointer to the caller
1280 when there are no more matches.
1283 completion_matches (text
, entry_function
)
1285 CPFunction
*entry_function
;
1287 /* Number of slots in match_list. */
1288 int match_list_size
;
1290 /* The list of matches. */
1293 /* Number of matches actually found. */
1296 /* Temporary string binder. */
1300 match_list_size
= 10;
1301 match_list
= (char **)xmalloc ((match_list_size
+ 1) * sizeof (char *));
1302 match_list
[1] = (char *)NULL
;
1304 while (string
= (*entry_function
) (text
, matches
))
1306 if (matches
+ 1 == match_list_size
)
1307 match_list
= (char **)xrealloc
1308 (match_list
, ((match_list_size
+= 10) + 1) * sizeof (char *));
1310 match_list
[++matches
] = string
;
1311 match_list
[matches
+ 1] = (char *)NULL
;
1314 /* If there were any matches, then look through them finding out the
1315 lowest common denominator. That then becomes match_list[0]. */
1317 compute_lcd_of_matches (match_list
, matches
, text
);
1318 else /* There were no matches. */
1321 match_list
= (char **)NULL
;
1323 return (match_list
);
1326 /* Okay, now we write the entry_function for filename completion. In the
1327 general case. Note that completion in the shell is a little different
1328 because of all the pathnames that must be followed when looking up the
1329 completion for a command. */
1331 filename_completion_function (text
, state
)
1335 static DIR *directory
= (DIR *)NULL
;
1336 static char *filename
= (char *)NULL
;
1337 static char *dirname
= (char *)NULL
;
1338 static char *users_dirname
= (char *)NULL
;
1339 static int filename_len
;
1342 struct dirent
*entry
;
1344 /* If we don't have any state, then do some initialization. */
1347 /* If we were interrupted before closing the directory or reading
1348 all of its contents, close it. */
1351 closedir (directory
);
1352 directory
= (DIR *)NULL
;
1356 FREE (users_dirname
);
1358 filename
= savestring (text
);
1361 dirname
= savestring (text
);
1363 temp
= strrchr (dirname
, '/');
1367 strcpy (filename
, ++temp
);
1376 /* We aren't done yet. We also support the "~user" syntax. */
1378 /* Save the version of the directory that the user typed. */
1379 users_dirname
= savestring (dirname
);
1381 if (*dirname
== '~')
1383 temp
= tilde_expand (dirname
);
1388 if (rl_directory_completion_hook
&& (*rl_directory_completion_hook
) (&dirname
))
1390 free (users_dirname
);
1391 users_dirname
= savestring (dirname
);
1394 directory
= opendir (dirname
);
1395 filename_len
= strlen (filename
);
1397 rl_filename_completion_desired
= 1;
1400 /* At this point we should entertain the possibility of hacking wildcarded
1401 filenames, like /usr/man/man<WILD>/te<TAB>. If the directory name
1402 contains globbing characters, then build an array of directories, and
1403 then map over that list while completing. */
1404 /* *** UNIMPLEMENTED *** */
1406 /* Now that we have some state, we can read the directory. */
1408 entry
= (struct dirent
*)NULL
;
1409 while (directory
&& (entry
= readdir (directory
)))
1411 /* Special case for no filename.
1412 All entries except "." and ".." match. */
1413 if (filename_len
== 0)
1415 if (entry
->d_name
[0] != '.' ||
1416 (entry
->d_name
[1] &&
1417 (entry
->d_name
[1] != '.' || entry
->d_name
[2])))
1422 /* Otherwise, if these match up to the length of filename, then
1424 if ((entry
->d_name
[0] == filename
[0]) &&
1425 (((int)D_NAMLEN (entry
)) >= filename_len
) &&
1426 (strncmp (filename
, entry
->d_name
, filename_len
) == 0))
1435 closedir (directory
);
1436 directory
= (DIR *)NULL
;
1441 dirname
= (char *)NULL
;
1446 filename
= (char *)NULL
;
1450 free (users_dirname
);
1451 users_dirname
= (char *)NULL
;
1454 return (char *)NULL
;
1458 /* dirname && (strcmp (dirname, ".") != 0) */
1459 if (dirname
&& (dirname
[0] != '.' || dirname
[1]))
1461 if (rl_complete_with_tilde_expansion
&& *users_dirname
== '~')
1463 dirlen
= strlen (dirname
);
1464 temp
= xmalloc (2 + dirlen
+ D_NAMLEN (entry
));
1465 strcpy (temp
, dirname
);
1466 /* Canonicalization cuts off any final slash present. We
1467 may need to add it back. */
1468 if (dirname
[dirlen
- 1] != '/')
1470 temp
[dirlen
++] = '/';
1471 temp
[dirlen
] = '\0';
1476 dirlen
= strlen (users_dirname
);
1477 temp
= xmalloc (1 + dirlen
+ D_NAMLEN (entry
));
1478 strcpy (temp
, users_dirname
);
1481 strcpy (temp
+ dirlen
, entry
->d_name
); /* strcat (temp, entry->d_name); */
1484 temp
= savestring (entry
->d_name
);
1490 /* A function for simple tilde expansion. */
1492 rl_tilde_expand (ignore
, key
)
1495 register int start
, end
;
1496 char *homedir
, *temp
;
1502 if (rl_point
== rl_end
&& rl_line_buffer
[rl_point
] == '~')
1504 homedir
= tilde_expand ("~");
1505 insert_text (homedir
, start
, end
);
1508 else if (rl_line_buffer
[start
] != '~')
1510 for (; !whitespace (rl_line_buffer
[start
]) && start
>= 0; start
--)
1518 while (whitespace (rl_line_buffer
[end
]) == 0 && end
< rl_end
);
1520 if (whitespace (rl_line_buffer
[end
]) || end
>= rl_end
)
1523 /* If the first character of the current word is a tilde, perform
1524 tilde expansion and insert the result. If not a tilde, do
1526 if (rl_line_buffer
[start
] == '~')
1528 len
= end
- start
+ 1;
1529 temp
= xmalloc (len
+ 1);
1530 strncpy (temp
, rl_line_buffer
+ start
, len
);
1532 homedir
= tilde_expand (temp
);
1535 insert_text (homedir
, start
, end
);
1541 /* Find the first occurrence in STRING1 of any character from STRING2.
1542 Return a pointer to the character in STRING1. */
1544 rl_strpbrk (string1
, string2
)
1545 char *string1
, *string2
;
1547 register char *scan
;
1549 for (; *string1
; string1
++)
1551 for (scan
= string2
; *scan
; scan
++)
1553 if (*string1
== *scan
)
1559 return ((char *)NULL
);