1/* $FreeBSD: head/contrib/libreadline/complete.c 136758 2004-10-21 20:02:02Z peter $ */ 2
| 1/* $FreeBSD: head/contrib/libreadline/complete.c 157188 2006-03-27 23:11:32Z ache $ */
|
3/* complete.c -- filename completion for readline. */ 4
| 2/* complete.c -- filename completion for readline. */ 3
|
5/* Copyright (C) 1987-2004 Free Software Foundation, Inc.
| 4/* Copyright (C) 1987-2005 Free Software Foundation, Inc.
|
6 7 This file is part of the GNU Readline Library, a library for 8 reading lines of text with interactive input and history editing. 9 10 The GNU Readline Library is free software; you can redistribute it 11 and/or modify it under the terms of the GNU General Public License 12 as published by the Free Software Foundation; either version 2, or 13 (at your option) any later version. 14 15 The GNU Readline Library is distributed in the hope that it will be 16 useful, but WITHOUT ANY WARRANTY; without even the implied warranty 17 of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 The GNU General Public License is often shipped with GNU software, and 21 is generally kept in a file called COPYING or LICENSE. If you do not 22 have a copy of the license, write to the Free Software Foundation, 23 59 Temple Place, Suite 330, Boston, MA 02111 USA. */ 24#define READLINE_LIBRARY 25 26#if defined (HAVE_CONFIG_H) 27# include <config.h> 28#endif 29 30#include <sys/types.h> 31#include <fcntl.h> 32#if defined (HAVE_SYS_FILE_H) 33# include <sys/file.h> 34#endif 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) 50extern int errno; 51#endif /* !errno */ 52
| 5 6 This file is part of the GNU Readline Library, a library for 7 reading lines of text with interactive input and history editing. 8 9 The GNU Readline Library is free software; you can redistribute it 10 and/or modify it under the terms of the GNU General Public License 11 as published by the Free Software Foundation; either version 2, or 12 (at your option) any later version. 13 14 The GNU Readline Library is distributed in the hope that it will be 15 useful, but WITHOUT ANY WARRANTY; without even the implied warranty 16 of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 The GNU General Public License is often shipped with GNU software, and 20 is generally kept in a file called COPYING or LICENSE. If you do not 21 have a copy of the license, write to the Free Software Foundation, 22 59 Temple Place, Suite 330, Boston, MA 02111 USA. */ 23#define READLINE_LIBRARY 24 25#if defined (HAVE_CONFIG_H) 26# include <config.h> 27#endif 28 29#include <sys/types.h> 30#include <fcntl.h> 31#if defined (HAVE_SYS_FILE_H) 32# include <sys/file.h> 33#endif 34 35#if defined (HAVE_UNISTD_H) 36# include <unistd.h> 37#endif /* HAVE_UNISTD_H */ 38 39#if defined (HAVE_STDLIB_H) 40# include <stdlib.h> 41#else 42# include "ansi_stdlib.h" 43#endif /* HAVE_STDLIB_H */ 44 45#include <stdio.h> 46 47#include <errno.h> 48#if !defined (errno) 49extern int errno; 50#endif /* !errno */ 51
|
| 52#if defined (HAVE_PWD_H)
|
53#include <pwd.h>
| 53#include <pwd.h>
|
| 54#endif
|
54 55#include "posixdir.h" 56#include "posixstat.h" 57 58/* System-specific feature definitions and include files. */ 59#include "rldefs.h" 60#include "rlmbutil.h" 61 62/* Some standard library routines. */ 63#include "readline.h" 64#include "xmalloc.h" 65#include "rlprivate.h" 66 67#ifdef __STDC__ 68typedef int QSFUNC (const void *, const void *); 69#else 70typedef int QSFUNC (); 71#endif 72 73#ifdef HAVE_LSTAT 74# define LSTAT lstat 75#else 76# define LSTAT stat 77#endif 78 79/* Unix version of a hidden file. Could be different on other systems. */ 80#define HIDDEN_FILE(fname) ((fname)[0] == '.') 81 82/* Most systems don't declare getpwent in <pwd.h> if _POSIX_SOURCE is 83 defined. */
| 55 56#include "posixdir.h" 57#include "posixstat.h" 58 59/* System-specific feature definitions and include files. */ 60#include "rldefs.h" 61#include "rlmbutil.h" 62 63/* Some standard library routines. */ 64#include "readline.h" 65#include "xmalloc.h" 66#include "rlprivate.h" 67 68#ifdef __STDC__ 69typedef int QSFUNC (const void *, const void *); 70#else 71typedef int QSFUNC (); 72#endif 73 74#ifdef HAVE_LSTAT 75# define LSTAT lstat 76#else 77# define LSTAT stat 78#endif 79 80/* Unix version of a hidden file. Could be different on other systems. */ 81#define HIDDEN_FILE(fname) ((fname)[0] == '.') 82 83/* Most systems don't declare getpwent in <pwd.h> if _POSIX_SOURCE is 84 defined. */
|
84#if !defined (HAVE_GETPW_DECLS) || defined (_POSIX_SOURCE)
| 85#if defined (HAVE_GETPWENT) && (!defined (HAVE_GETPW_DECLS) || defined (_POSIX_SOURCE))
|
85extern struct passwd *getpwent PARAMS((void));
| 86extern struct passwd *getpwent PARAMS((void));
|
86#endif /* !HAVE_GETPW_DECLS || _POSIX_SOURCE */
| 87#endif /* HAVE_GETPWENT && (!HAVE_GETPW_DECLS || _POSIX_SOURCE) */
|
87 88/* If non-zero, then this is the address of a function to call when 89 completing a word would normally display the list of possible matches. 90 This function is called instead of actually doing the display. 91 It takes three arguments: (char **matches, int num_matches, int max_length) 92 where MATCHES is the array of strings that matched, NUM_MATCHES is the 93 number of strings in that array, and MAX_LENGTH is the length of the 94 longest string in that array. */ 95rl_compdisp_func_t *rl_completion_display_matches_hook = (rl_compdisp_func_t *)NULL; 96 97#if defined (VISIBLE_STATS) 98# if !defined (X_OK) 99# define X_OK 1 100# endif 101static int stat_char PARAMS((char *)); 102#endif 103 104static int path_isdir PARAMS((const char *)); 105 106static char *rl_quote_filename PARAMS((char *, int, char *)); 107 108static void set_completion_defaults PARAMS((int)); 109static int get_y_or_n PARAMS((int)); 110static int _rl_internal_pager PARAMS((int)); 111static char *printable_part PARAMS((char *)); 112static int fnwidth PARAMS((const char *)); 113static int fnprint PARAMS((const char *)); 114static int print_filename PARAMS((char *, char *)); 115 116static char **gen_completion_matches PARAMS((char *, int, int, rl_compentry_func_t *, int, int)); 117 118static char **remove_duplicate_matches PARAMS((char **)); 119static void insert_match PARAMS((char *, int, int, char *)); 120static int append_to_match PARAMS((char *, int, int, int)); 121static void insert_all_matches PARAMS((char **, int, char *)); 122static void display_matches PARAMS((char **)); 123static int compute_lcd_of_matches PARAMS((char **, int, const char *)); 124static int postprocess_matches PARAMS((char ***, int)); 125 126static char *make_quoted_replacement PARAMS((char *, int, char *)); 127 128/* **************************************************************** */ 129/* */ 130/* Completion matching, from readline's point of view. */ 131/* */ 132/* **************************************************************** */ 133 134/* Variables known only to the readline library. */ 135 136/* If non-zero, non-unique completions always show the list of matches. */ 137int _rl_complete_show_all = 0; 138 139/* If non-zero, non-unique completions show the list of matches, unless it 140 is not possible to do partial completion and modify the line. */ 141int _rl_complete_show_unmodified = 0; 142 143/* If non-zero, completed directory names have a slash appended. */ 144int _rl_complete_mark_directories = 1; 145 146/* If non-zero, the symlinked directory completion behavior introduced in 147 readline-4.2a is disabled, and symlinks that point to directories have 148 a slash appended (subject to the value of _rl_complete_mark_directories). 149 This is user-settable via the mark-symlinked-directories variable. */ 150int _rl_complete_mark_symlink_dirs = 0; 151 152/* If non-zero, completions are printed horizontally in alphabetical order, 153 like `ls -x'. */ 154int _rl_print_completions_horizontally; 155 156/* Non-zero means that case is not significant in filename completion. */ 157#if defined (__MSDOS__) && !defined (__DJGPP__) 158int _rl_completion_case_fold = 1; 159#else 160int _rl_completion_case_fold; 161#endif 162 163/* If non-zero, don't match hidden files (filenames beginning with a `.' on 164 Unix) when doing filename completion. */ 165int _rl_match_hidden_files = 1; 166 167/* Global variables available to applications using readline. */ 168 169#if defined (VISIBLE_STATS) 170/* Non-zero means add an additional character to each filename displayed 171 during listing completion iff rl_filename_completion_desired which helps 172 to indicate the type of file being listed. */ 173int rl_visible_stats = 0; 174#endif /* VISIBLE_STATS */ 175 176/* If non-zero, then this is the address of a function to call when 177 completing on a directory name. The function is called with 178 the address of a string (the current directory name) as an arg. */ 179rl_icppfunc_t *rl_directory_completion_hook = (rl_icppfunc_t *)NULL; 180 181rl_icppfunc_t *rl_directory_rewrite_hook = (rl_icppfunc_t *)NULL; 182 183/* Non-zero means readline completion functions perform tilde expansion. */ 184int rl_complete_with_tilde_expansion = 0; 185 186/* Pointer to the generator function for completion_matches (). 187 NULL means to use rl_filename_completion_function (), the default filename 188 completer. */ 189rl_compentry_func_t *rl_completion_entry_function = (rl_compentry_func_t *)NULL; 190 191/* Pointer to alternative function to create matches. 192 Function is called with TEXT, START, and END. 193 START and END are indices in RL_LINE_BUFFER saying what the boundaries 194 of TEXT are. 195 If this function exists and returns NULL then call the value of 196 rl_completion_entry_function to try to match, otherwise use the 197 array of strings returned. */ 198rl_completion_func_t *rl_attempted_completion_function = (rl_completion_func_t *)NULL; 199 200/* Non-zero means to suppress normal filename completion after the 201 user-specified completion function has been called. */ 202int rl_attempted_completion_over = 0; 203 204/* Set to a character indicating the type of completion being performed 205 by rl_complete_internal, available for use by application completion 206 functions. */ 207int rl_completion_type = 0; 208 209/* Up to this many items will be displayed in response to a 210 possible-completions call. After that, we ask the user if
| 88 89/* If non-zero, then this is the address of a function to call when 90 completing a word would normally display the list of possible matches. 91 This function is called instead of actually doing the display. 92 It takes three arguments: (char **matches, int num_matches, int max_length) 93 where MATCHES is the array of strings that matched, NUM_MATCHES is the 94 number of strings in that array, and MAX_LENGTH is the length of the 95 longest string in that array. */ 96rl_compdisp_func_t *rl_completion_display_matches_hook = (rl_compdisp_func_t *)NULL; 97 98#if defined (VISIBLE_STATS) 99# if !defined (X_OK) 100# define X_OK 1 101# endif 102static int stat_char PARAMS((char *)); 103#endif 104 105static int path_isdir PARAMS((const char *)); 106 107static char *rl_quote_filename PARAMS((char *, int, char *)); 108 109static void set_completion_defaults PARAMS((int)); 110static int get_y_or_n PARAMS((int)); 111static int _rl_internal_pager PARAMS((int)); 112static char *printable_part PARAMS((char *)); 113static int fnwidth PARAMS((const char *)); 114static int fnprint PARAMS((const char *)); 115static int print_filename PARAMS((char *, char *)); 116 117static char **gen_completion_matches PARAMS((char *, int, int, rl_compentry_func_t *, int, int)); 118 119static char **remove_duplicate_matches PARAMS((char **)); 120static void insert_match PARAMS((char *, int, int, char *)); 121static int append_to_match PARAMS((char *, int, int, int)); 122static void insert_all_matches PARAMS((char **, int, char *)); 123static void display_matches PARAMS((char **)); 124static int compute_lcd_of_matches PARAMS((char **, int, const char *)); 125static int postprocess_matches PARAMS((char ***, int)); 126 127static char *make_quoted_replacement PARAMS((char *, int, char *)); 128 129/* **************************************************************** */ 130/* */ 131/* Completion matching, from readline's point of view. */ 132/* */ 133/* **************************************************************** */ 134 135/* Variables known only to the readline library. */ 136 137/* If non-zero, non-unique completions always show the list of matches. */ 138int _rl_complete_show_all = 0; 139 140/* If non-zero, non-unique completions show the list of matches, unless it 141 is not possible to do partial completion and modify the line. */ 142int _rl_complete_show_unmodified = 0; 143 144/* If non-zero, completed directory names have a slash appended. */ 145int _rl_complete_mark_directories = 1; 146 147/* If non-zero, the symlinked directory completion behavior introduced in 148 readline-4.2a is disabled, and symlinks that point to directories have 149 a slash appended (subject to the value of _rl_complete_mark_directories). 150 This is user-settable via the mark-symlinked-directories variable. */ 151int _rl_complete_mark_symlink_dirs = 0; 152 153/* If non-zero, completions are printed horizontally in alphabetical order, 154 like `ls -x'. */ 155int _rl_print_completions_horizontally; 156 157/* Non-zero means that case is not significant in filename completion. */ 158#if defined (__MSDOS__) && !defined (__DJGPP__) 159int _rl_completion_case_fold = 1; 160#else 161int _rl_completion_case_fold; 162#endif 163 164/* If non-zero, don't match hidden files (filenames beginning with a `.' on 165 Unix) when doing filename completion. */ 166int _rl_match_hidden_files = 1; 167 168/* Global variables available to applications using readline. */ 169 170#if defined (VISIBLE_STATS) 171/* Non-zero means add an additional character to each filename displayed 172 during listing completion iff rl_filename_completion_desired which helps 173 to indicate the type of file being listed. */ 174int rl_visible_stats = 0; 175#endif /* VISIBLE_STATS */ 176 177/* If non-zero, then this is the address of a function to call when 178 completing on a directory name. The function is called with 179 the address of a string (the current directory name) as an arg. */ 180rl_icppfunc_t *rl_directory_completion_hook = (rl_icppfunc_t *)NULL; 181 182rl_icppfunc_t *rl_directory_rewrite_hook = (rl_icppfunc_t *)NULL; 183 184/* Non-zero means readline completion functions perform tilde expansion. */ 185int rl_complete_with_tilde_expansion = 0; 186 187/* Pointer to the generator function for completion_matches (). 188 NULL means to use rl_filename_completion_function (), the default filename 189 completer. */ 190rl_compentry_func_t *rl_completion_entry_function = (rl_compentry_func_t *)NULL; 191 192/* Pointer to alternative function to create matches. 193 Function is called with TEXT, START, and END. 194 START and END are indices in RL_LINE_BUFFER saying what the boundaries 195 of TEXT are. 196 If this function exists and returns NULL then call the value of 197 rl_completion_entry_function to try to match, otherwise use the 198 array of strings returned. */ 199rl_completion_func_t *rl_attempted_completion_function = (rl_completion_func_t *)NULL; 200 201/* Non-zero means to suppress normal filename completion after the 202 user-specified completion function has been called. */ 203int rl_attempted_completion_over = 0; 204 205/* Set to a character indicating the type of completion being performed 206 by rl_complete_internal, available for use by application completion 207 functions. */ 208int rl_completion_type = 0; 209 210/* Up to this many items will be displayed in response to a 211 possible-completions call. After that, we ask the user if
|
211 she is sure she wants to see them all. */
| 212 she is sure she wants to see them all. A negative value means 213 don't ask. */
|
212int rl_completion_query_items = 100; 213 214int _rl_page_completions = 1; 215 216/* The basic list of characters that signal a break between words for the 217 completer routine. The contents of this variable is what breaks words 218 in the shell, i.e. " \t\n\"\\'`@$><=" */ 219const char *rl_basic_word_break_characters = " \t\n\"\\'`@$><=;|&{("; /* }) */ 220 221/* List of basic quoting characters. */ 222const char *rl_basic_quote_characters = "\"'"; 223 224/* The list of characters that signal a break between words for 225 rl_complete_internal. The default list is the contents of 226 rl_basic_word_break_characters. */ 227/*const*/ char *rl_completer_word_break_characters = (/*const*/ char *)NULL; 228 229/* Hook function to allow an application to set the completion word 230 break characters before readline breaks up the line. Allows 231 position-dependent word break characters. */ 232rl_cpvfunc_t *rl_completion_word_break_hook = (rl_cpvfunc_t *)NULL; 233 234/* List of characters which can be used to quote a substring of the line. 235 Completion occurs on the entire substring, and within the substring 236 rl_completer_word_break_characters are treated as any other character, 237 unless they also appear within this list. */ 238const char *rl_completer_quote_characters = (const char *)NULL; 239 240/* List of characters that should be quoted in filenames by the completer. */ 241const char *rl_filename_quote_characters = (const char *)NULL; 242 243/* List of characters that are word break characters, but should be left 244 in TEXT when it is passed to the completion function. The shell uses 245 this to help determine what kind of completing to do. */ 246const char *rl_special_prefixes = (const char *)NULL; 247 248/* If non-zero, then disallow duplicates in the matches. */ 249int rl_ignore_completion_duplicates = 1; 250 251/* Non-zero means that the results of the matches are to be treated 252 as filenames. This is ALWAYS zero on entry, and can only be changed 253 within a completion entry finder function. */ 254int rl_filename_completion_desired = 0; 255 256/* Non-zero means that the results of the matches are to be quoted using 257 double quotes (or an application-specific quoting mechanism) if the 258 filename contains any characters in rl_filename_quote_chars. This is 259 ALWAYS non-zero on entry, and can only be changed within a completion 260 entry finder function. */ 261int rl_filename_quoting_desired = 1; 262 263/* This function, if defined, is called by the completer when real 264 filename completion is done, after all the matching names have been 265 generated. It is passed a (char**) known as matches in the code below. 266 It consists of a NULL-terminated array of pointers to potential 267 matching strings. The 1st element (matches[0]) is the maximal 268 substring that is common to all matches. This function can re-arrange 269 the list of matches as required, but all elements of the array must be 270 free()'d if they are deleted. The main intent of this function is 271 to implement FIGNORE a la SunOS csh. */ 272rl_compignore_func_t *rl_ignore_some_completions_function = (rl_compignore_func_t *)NULL; 273 274/* Set to a function to quote a filename in an application-specific fashion. 275 Called with the text to quote, the type of match found (single or multiple) 276 and a pointer to the quoting character to be used, which the function can 277 reset if desired. */ 278rl_quote_func_t *rl_filename_quoting_function = rl_quote_filename; 279 280/* Function to call to remove quoting characters from a filename. Called 281 before completion is attempted, so the embedded quotes do not interfere 282 with matching names in the file system. Readline doesn't do anything 283 with this; it's set only by applications. */ 284rl_dequote_func_t *rl_filename_dequoting_function = (rl_dequote_func_t *)NULL; 285 286/* Function to call to decide whether or not a word break character is 287 quoted. If a character is quoted, it does not break words for the 288 completer. */ 289rl_linebuf_func_t *rl_char_is_quoted_p = (rl_linebuf_func_t *)NULL; 290 291/* If non-zero, the completion functions don't append anything except a 292 possible closing quote. This is set to 0 by rl_complete_internal and 293 may be changed by an application-specific completion function. */ 294int rl_completion_suppress_append = 0; 295 296/* Character appended to completed words when at the end of the line. The 297 default is a space. */ 298int rl_completion_append_character = ' '; 299 300/* If non-zero, the completion functions don't append any closing quote. 301 This is set to 0 by rl_complete_internal and may be changed by an 302 application-specific completion function. */ 303int rl_completion_suppress_quote = 0; 304 305/* Set to any quote character readline thinks it finds before any application 306 completion function is called. */ 307int rl_completion_quote_character; 308 309/* Set to a non-zero value if readline found quoting anywhere in the word to 310 be completed; set before any application completion function is called. */ 311int rl_completion_found_quote; 312 313/* If non-zero, a slash will be appended to completed filenames that are 314 symbolic links to directory names, subject to the value of the 315 mark-directories variable (which is user-settable). This exists so 316 that application completion functions can override the user's preference 317 (set via the mark-symlinked-directories variable) if appropriate. 318 It's set to the value of _rl_complete_mark_symlink_dirs in 319 rl_complete_internal before any application-specific completion 320 function is called, so without that function doing anything, the user's 321 preferences are honored. */ 322int rl_completion_mark_symlink_dirs; 323 324/* If non-zero, inhibit completion (temporarily). */ 325int rl_inhibit_completion; 326 327/* Variables local to this file. */ 328 329/* Local variable states what happened during the last completion attempt. */ 330static int completion_changed_buffer; 331 332/*************************************/ 333/* */ 334/* Bindable completion functions */ 335/* */ 336/*************************************/ 337 338/* Complete the word at or before point. You have supplied the function 339 that does the initial simple matching selection algorithm (see 340 rl_completion_matches ()). The default is to do filename completion. */ 341int 342rl_complete (ignore, invoking_key) 343 int ignore, invoking_key; 344{ 345 if (rl_inhibit_completion) 346 return (_rl_insert_char (ignore, invoking_key)); 347 else if (rl_last_func == rl_complete && !completion_changed_buffer) 348 return (rl_complete_internal ('?')); 349 else if (_rl_complete_show_all) 350 return (rl_complete_internal ('!')); 351 else if (_rl_complete_show_unmodified) 352 return (rl_complete_internal ('@')); 353 else 354 return (rl_complete_internal (TAB)); 355} 356 357/* List the possible completions. See description of rl_complete (). */ 358int 359rl_possible_completions (ignore, invoking_key) 360 int ignore, invoking_key; 361{ 362 return (rl_complete_internal ('?')); 363} 364 365int 366rl_insert_completions (ignore, invoking_key) 367 int ignore, invoking_key; 368{ 369 return (rl_complete_internal ('*')); 370} 371 372/* Return the correct value to pass to rl_complete_internal performing 373 the same tests as rl_complete. This allows consecutive calls to an 374 application's completion function to list possible completions and for 375 an application-specific completion function to honor the 376 show-all-if-ambiguous readline variable. */ 377int 378rl_completion_mode (cfunc) 379 rl_command_func_t *cfunc; 380{ 381 if (rl_last_func == cfunc && !completion_changed_buffer) 382 return '?'; 383 else if (_rl_complete_show_all) 384 return '!'; 385 else if (_rl_complete_show_unmodified) 386 return '@'; 387 else 388 return TAB; 389} 390 391/************************************/ 392/* */ 393/* Completion utility functions */ 394/* */ 395/************************************/ 396 397/* Set default values for readline word completion. These are the variables 398 that application completion functions can change or inspect. */ 399static void 400set_completion_defaults (what_to_do) 401 int what_to_do; 402{ 403 /* Only the completion entry function can change these. */ 404 rl_filename_completion_desired = 0; 405 rl_filename_quoting_desired = 1; 406 rl_completion_type = what_to_do; 407 rl_completion_suppress_append = rl_completion_suppress_quote = 0; 408 409 /* The completion entry function may optionally change this. */ 410 rl_completion_mark_symlink_dirs = _rl_complete_mark_symlink_dirs; 411} 412 413/* The user must press "y" or "n". Non-zero return means "y" pressed. */ 414static int 415get_y_or_n (for_pager) 416 int for_pager; 417{ 418 int c; 419 420 for (;;) 421 { 422 RL_SETSTATE(RL_STATE_MOREINPUT); 423 c = rl_read_key (); 424 RL_UNSETSTATE(RL_STATE_MOREINPUT); 425 426 if (c == 'y' || c == 'Y' || c == ' ') 427 return (1); 428 if (c == 'n' || c == 'N' || c == RUBOUT) 429 return (0); 430 if (c == ABORT_CHAR) 431 _rl_abort_internal (); 432 if (for_pager && (c == NEWLINE || c == RETURN)) 433 return (2); 434 if (for_pager && (c == 'q' || c == 'Q')) 435 return (0); 436 rl_ding (); 437 } 438} 439 440static int 441_rl_internal_pager (lines) 442 int lines; 443{ 444 int i; 445 446 fprintf (rl_outstream, "--More--"); 447 fflush (rl_outstream); 448 i = get_y_or_n (1); 449 _rl_erase_entire_line (); 450 if (i == 0) 451 return -1; 452 else if (i == 2) 453 return (lines - 1); 454 else 455 return 0; 456} 457 458static int 459path_isdir (filename) 460 const char *filename; 461{ 462 struct stat finfo; 463 464 return (stat (filename, &finfo) == 0 && S_ISDIR (finfo.st_mode)); 465} 466 467#if defined (VISIBLE_STATS) 468/* Return the character which best describes FILENAME. 469 `@' for symbolic links 470 `/' for directories 471 `*' for executables 472 `=' for sockets 473 `|' for FIFOs 474 `%' for character special devices 475 `#' for block special devices */ 476static int 477stat_char (filename) 478 char *filename; 479{ 480 struct stat finfo; 481 int character, r; 482 483#if defined (HAVE_LSTAT) && defined (S_ISLNK) 484 r = lstat (filename, &finfo); 485#else 486 r = stat (filename, &finfo); 487#endif 488 489 if (r == -1) 490 return (0); 491 492 character = 0; 493 if (S_ISDIR (finfo.st_mode)) 494 character = '/'; 495#if defined (S_ISCHR) 496 else if (S_ISCHR (finfo.st_mode)) 497 character = '%'; 498#endif /* S_ISCHR */ 499#if defined (S_ISBLK) 500 else if (S_ISBLK (finfo.st_mode)) 501 character = '#'; 502#endif /* S_ISBLK */ 503#if defined (S_ISLNK) 504 else if (S_ISLNK (finfo.st_mode)) 505 character = '@'; 506#endif /* S_ISLNK */ 507#if defined (S_ISSOCK) 508 else if (S_ISSOCK (finfo.st_mode)) 509 character = '='; 510#endif /* S_ISSOCK */ 511#if defined (S_ISFIFO) 512 else if (S_ISFIFO (finfo.st_mode)) 513 character = '|'; 514#endif 515 else if (S_ISREG (finfo.st_mode)) 516 { 517 if (access (filename, X_OK) == 0) 518 character = '*'; 519 } 520 return (character); 521} 522#endif /* VISIBLE_STATS */ 523 524/* Return the portion of PATHNAME that should be output when listing 525 possible completions. If we are hacking filename completion, we 526 are only interested in the basename, the portion following the 527 final slash. Otherwise, we return what we were passed. Since 528 printing empty strings is not very informative, if we're doing 529 filename completion, and the basename is the empty string, we look 530 for the previous slash and return the portion following that. If 531 there's no previous slash, we just return what we were passed. */ 532static char * 533printable_part (pathname) 534 char *pathname; 535{ 536 char *temp, *x; 537 538 if (rl_filename_completion_desired == 0) /* don't need to do anything */ 539 return (pathname); 540 541 temp = strrchr (pathname, '/'); 542#if defined (__MSDOS__) 543 if (temp == 0 && ISALPHA ((unsigned char)pathname[0]) && pathname[1] == ':') 544 temp = pathname + 1; 545#endif 546 547 if (temp == 0 || *temp == '\0') 548 return (pathname); 549 /* If the basename is NULL, we might have a pathname like '/usr/src/'. 550 Look for a previous slash and, if one is found, return the portion 551 following that slash. If there's no previous slash, just return the 552 pathname we were passed. */ 553 else if (temp[1] == '\0') 554 { 555 for (x = temp - 1; x > pathname; x--) 556 if (*x == '/') 557 break; 558 return ((*x == '/') ? x + 1 : pathname); 559 } 560 else 561 return ++temp; 562} 563 564/* Compute width of STRING when displayed on screen by print_filename */ 565static int 566fnwidth (string) 567 const char *string; 568{ 569 int width, pos; 570#if defined (HANDLE_MULTIBYTE) 571 mbstate_t ps; 572 int left, w; 573 size_t clen; 574 wchar_t wc; 575 576 left = strlen (string) + 1; 577 memset (&ps, 0, sizeof (mbstate_t)); 578#endif 579 580 width = pos = 0; 581 while (string[pos]) 582 { 583 if (CTRL_CHAR (*string) || *string == RUBOUT) 584 { 585 width += 2; 586 pos++; 587 } 588 else 589 { 590#if defined (HANDLE_MULTIBYTE) 591 clen = mbrtowc (&wc, string + pos, left - pos, &ps); 592 if (MB_INVALIDCH (clen)) 593 { 594 width++; 595 pos++; 596 memset (&ps, 0, sizeof (mbstate_t)); 597 } 598 else if (MB_NULLWCH (clen)) 599 break; 600 else 601 { 602 pos += clen; 603 w = wcwidth (wc); 604 width += (w >= 0) ? w : 1; 605 } 606#else 607 width++; 608 pos++; 609#endif 610 } 611 } 612 613 return width; 614} 615 616static int 617fnprint (to_print) 618 const char *to_print; 619{ 620 int printed_len; 621 const char *s; 622#if defined (HANDLE_MULTIBYTE) 623 mbstate_t ps; 624 const char *end; 625 size_t tlen;
| 214int rl_completion_query_items = 100; 215 216int _rl_page_completions = 1; 217 218/* The basic list of characters that signal a break between words for the 219 completer routine. The contents of this variable is what breaks words 220 in the shell, i.e. " \t\n\"\\'`@$><=" */ 221const char *rl_basic_word_break_characters = " \t\n\"\\'`@$><=;|&{("; /* }) */ 222 223/* List of basic quoting characters. */ 224const char *rl_basic_quote_characters = "\"'"; 225 226/* The list of characters that signal a break between words for 227 rl_complete_internal. The default list is the contents of 228 rl_basic_word_break_characters. */ 229/*const*/ char *rl_completer_word_break_characters = (/*const*/ char *)NULL; 230 231/* Hook function to allow an application to set the completion word 232 break characters before readline breaks up the line. Allows 233 position-dependent word break characters. */ 234rl_cpvfunc_t *rl_completion_word_break_hook = (rl_cpvfunc_t *)NULL; 235 236/* List of characters which can be used to quote a substring of the line. 237 Completion occurs on the entire substring, and within the substring 238 rl_completer_word_break_characters are treated as any other character, 239 unless they also appear within this list. */ 240const char *rl_completer_quote_characters = (const char *)NULL; 241 242/* List of characters that should be quoted in filenames by the completer. */ 243const char *rl_filename_quote_characters = (const char *)NULL; 244 245/* List of characters that are word break characters, but should be left 246 in TEXT when it is passed to the completion function. The shell uses 247 this to help determine what kind of completing to do. */ 248const char *rl_special_prefixes = (const char *)NULL; 249 250/* If non-zero, then disallow duplicates in the matches. */ 251int rl_ignore_completion_duplicates = 1; 252 253/* Non-zero means that the results of the matches are to be treated 254 as filenames. This is ALWAYS zero on entry, and can only be changed 255 within a completion entry finder function. */ 256int rl_filename_completion_desired = 0; 257 258/* Non-zero means that the results of the matches are to be quoted using 259 double quotes (or an application-specific quoting mechanism) if the 260 filename contains any characters in rl_filename_quote_chars. This is 261 ALWAYS non-zero on entry, and can only be changed within a completion 262 entry finder function. */ 263int rl_filename_quoting_desired = 1; 264 265/* This function, if defined, is called by the completer when real 266 filename completion is done, after all the matching names have been 267 generated. It is passed a (char**) known as matches in the code below. 268 It consists of a NULL-terminated array of pointers to potential 269 matching strings. The 1st element (matches[0]) is the maximal 270 substring that is common to all matches. This function can re-arrange 271 the list of matches as required, but all elements of the array must be 272 free()'d if they are deleted. The main intent of this function is 273 to implement FIGNORE a la SunOS csh. */ 274rl_compignore_func_t *rl_ignore_some_completions_function = (rl_compignore_func_t *)NULL; 275 276/* Set to a function to quote a filename in an application-specific fashion. 277 Called with the text to quote, the type of match found (single or multiple) 278 and a pointer to the quoting character to be used, which the function can 279 reset if desired. */ 280rl_quote_func_t *rl_filename_quoting_function = rl_quote_filename; 281 282/* Function to call to remove quoting characters from a filename. Called 283 before completion is attempted, so the embedded quotes do not interfere 284 with matching names in the file system. Readline doesn't do anything 285 with this; it's set only by applications. */ 286rl_dequote_func_t *rl_filename_dequoting_function = (rl_dequote_func_t *)NULL; 287 288/* Function to call to decide whether or not a word break character is 289 quoted. If a character is quoted, it does not break words for the 290 completer. */ 291rl_linebuf_func_t *rl_char_is_quoted_p = (rl_linebuf_func_t *)NULL; 292 293/* If non-zero, the completion functions don't append anything except a 294 possible closing quote. This is set to 0 by rl_complete_internal and 295 may be changed by an application-specific completion function. */ 296int rl_completion_suppress_append = 0; 297 298/* Character appended to completed words when at the end of the line. The 299 default is a space. */ 300int rl_completion_append_character = ' '; 301 302/* If non-zero, the completion functions don't append any closing quote. 303 This is set to 0 by rl_complete_internal and may be changed by an 304 application-specific completion function. */ 305int rl_completion_suppress_quote = 0; 306 307/* Set to any quote character readline thinks it finds before any application 308 completion function is called. */ 309int rl_completion_quote_character; 310 311/* Set to a non-zero value if readline found quoting anywhere in the word to 312 be completed; set before any application completion function is called. */ 313int rl_completion_found_quote; 314 315/* If non-zero, a slash will be appended to completed filenames that are 316 symbolic links to directory names, subject to the value of the 317 mark-directories variable (which is user-settable). This exists so 318 that application completion functions can override the user's preference 319 (set via the mark-symlinked-directories variable) if appropriate. 320 It's set to the value of _rl_complete_mark_symlink_dirs in 321 rl_complete_internal before any application-specific completion 322 function is called, so without that function doing anything, the user's 323 preferences are honored. */ 324int rl_completion_mark_symlink_dirs; 325 326/* If non-zero, inhibit completion (temporarily). */ 327int rl_inhibit_completion; 328 329/* Variables local to this file. */ 330 331/* Local variable states what happened during the last completion attempt. */ 332static int completion_changed_buffer; 333 334/*************************************/ 335/* */ 336/* Bindable completion functions */ 337/* */ 338/*************************************/ 339 340/* Complete the word at or before point. You have supplied the function 341 that does the initial simple matching selection algorithm (see 342 rl_completion_matches ()). The default is to do filename completion. */ 343int 344rl_complete (ignore, invoking_key) 345 int ignore, invoking_key; 346{ 347 if (rl_inhibit_completion) 348 return (_rl_insert_char (ignore, invoking_key)); 349 else if (rl_last_func == rl_complete && !completion_changed_buffer) 350 return (rl_complete_internal ('?')); 351 else if (_rl_complete_show_all) 352 return (rl_complete_internal ('!')); 353 else if (_rl_complete_show_unmodified) 354 return (rl_complete_internal ('@')); 355 else 356 return (rl_complete_internal (TAB)); 357} 358 359/* List the possible completions. See description of rl_complete (). */ 360int 361rl_possible_completions (ignore, invoking_key) 362 int ignore, invoking_key; 363{ 364 return (rl_complete_internal ('?')); 365} 366 367int 368rl_insert_completions (ignore, invoking_key) 369 int ignore, invoking_key; 370{ 371 return (rl_complete_internal ('*')); 372} 373 374/* Return the correct value to pass to rl_complete_internal performing 375 the same tests as rl_complete. This allows consecutive calls to an 376 application's completion function to list possible completions and for 377 an application-specific completion function to honor the 378 show-all-if-ambiguous readline variable. */ 379int 380rl_completion_mode (cfunc) 381 rl_command_func_t *cfunc; 382{ 383 if (rl_last_func == cfunc && !completion_changed_buffer) 384 return '?'; 385 else if (_rl_complete_show_all) 386 return '!'; 387 else if (_rl_complete_show_unmodified) 388 return '@'; 389 else 390 return TAB; 391} 392 393/************************************/ 394/* */ 395/* Completion utility functions */ 396/* */ 397/************************************/ 398 399/* Set default values for readline word completion. These are the variables 400 that application completion functions can change or inspect. */ 401static void 402set_completion_defaults (what_to_do) 403 int what_to_do; 404{ 405 /* Only the completion entry function can change these. */ 406 rl_filename_completion_desired = 0; 407 rl_filename_quoting_desired = 1; 408 rl_completion_type = what_to_do; 409 rl_completion_suppress_append = rl_completion_suppress_quote = 0; 410 411 /* The completion entry function may optionally change this. */ 412 rl_completion_mark_symlink_dirs = _rl_complete_mark_symlink_dirs; 413} 414 415/* The user must press "y" or "n". Non-zero return means "y" pressed. */ 416static int 417get_y_or_n (for_pager) 418 int for_pager; 419{ 420 int c; 421 422 for (;;) 423 { 424 RL_SETSTATE(RL_STATE_MOREINPUT); 425 c = rl_read_key (); 426 RL_UNSETSTATE(RL_STATE_MOREINPUT); 427 428 if (c == 'y' || c == 'Y' || c == ' ') 429 return (1); 430 if (c == 'n' || c == 'N' || c == RUBOUT) 431 return (0); 432 if (c == ABORT_CHAR) 433 _rl_abort_internal (); 434 if (for_pager && (c == NEWLINE || c == RETURN)) 435 return (2); 436 if (for_pager && (c == 'q' || c == 'Q')) 437 return (0); 438 rl_ding (); 439 } 440} 441 442static int 443_rl_internal_pager (lines) 444 int lines; 445{ 446 int i; 447 448 fprintf (rl_outstream, "--More--"); 449 fflush (rl_outstream); 450 i = get_y_or_n (1); 451 _rl_erase_entire_line (); 452 if (i == 0) 453 return -1; 454 else if (i == 2) 455 return (lines - 1); 456 else 457 return 0; 458} 459 460static int 461path_isdir (filename) 462 const char *filename; 463{ 464 struct stat finfo; 465 466 return (stat (filename, &finfo) == 0 && S_ISDIR (finfo.st_mode)); 467} 468 469#if defined (VISIBLE_STATS) 470/* Return the character which best describes FILENAME. 471 `@' for symbolic links 472 `/' for directories 473 `*' for executables 474 `=' for sockets 475 `|' for FIFOs 476 `%' for character special devices 477 `#' for block special devices */ 478static int 479stat_char (filename) 480 char *filename; 481{ 482 struct stat finfo; 483 int character, r; 484 485#if defined (HAVE_LSTAT) && defined (S_ISLNK) 486 r = lstat (filename, &finfo); 487#else 488 r = stat (filename, &finfo); 489#endif 490 491 if (r == -1) 492 return (0); 493 494 character = 0; 495 if (S_ISDIR (finfo.st_mode)) 496 character = '/'; 497#if defined (S_ISCHR) 498 else if (S_ISCHR (finfo.st_mode)) 499 character = '%'; 500#endif /* S_ISCHR */ 501#if defined (S_ISBLK) 502 else if (S_ISBLK (finfo.st_mode)) 503 character = '#'; 504#endif /* S_ISBLK */ 505#if defined (S_ISLNK) 506 else if (S_ISLNK (finfo.st_mode)) 507 character = '@'; 508#endif /* S_ISLNK */ 509#if defined (S_ISSOCK) 510 else if (S_ISSOCK (finfo.st_mode)) 511 character = '='; 512#endif /* S_ISSOCK */ 513#if defined (S_ISFIFO) 514 else if (S_ISFIFO (finfo.st_mode)) 515 character = '|'; 516#endif 517 else if (S_ISREG (finfo.st_mode)) 518 { 519 if (access (filename, X_OK) == 0) 520 character = '*'; 521 } 522 return (character); 523} 524#endif /* VISIBLE_STATS */ 525 526/* Return the portion of PATHNAME that should be output when listing 527 possible completions. If we are hacking filename completion, we 528 are only interested in the basename, the portion following the 529 final slash. Otherwise, we return what we were passed. Since 530 printing empty strings is not very informative, if we're doing 531 filename completion, and the basename is the empty string, we look 532 for the previous slash and return the portion following that. If 533 there's no previous slash, we just return what we were passed. */ 534static char * 535printable_part (pathname) 536 char *pathname; 537{ 538 char *temp, *x; 539 540 if (rl_filename_completion_desired == 0) /* don't need to do anything */ 541 return (pathname); 542 543 temp = strrchr (pathname, '/'); 544#if defined (__MSDOS__) 545 if (temp == 0 && ISALPHA ((unsigned char)pathname[0]) && pathname[1] == ':') 546 temp = pathname + 1; 547#endif 548 549 if (temp == 0 || *temp == '\0') 550 return (pathname); 551 /* If the basename is NULL, we might have a pathname like '/usr/src/'. 552 Look for a previous slash and, if one is found, return the portion 553 following that slash. If there's no previous slash, just return the 554 pathname we were passed. */ 555 else if (temp[1] == '\0') 556 { 557 for (x = temp - 1; x > pathname; x--) 558 if (*x == '/') 559 break; 560 return ((*x == '/') ? x + 1 : pathname); 561 } 562 else 563 return ++temp; 564} 565 566/* Compute width of STRING when displayed on screen by print_filename */ 567static int 568fnwidth (string) 569 const char *string; 570{ 571 int width, pos; 572#if defined (HANDLE_MULTIBYTE) 573 mbstate_t ps; 574 int left, w; 575 size_t clen; 576 wchar_t wc; 577 578 left = strlen (string) + 1; 579 memset (&ps, 0, sizeof (mbstate_t)); 580#endif 581 582 width = pos = 0; 583 while (string[pos]) 584 { 585 if (CTRL_CHAR (*string) || *string == RUBOUT) 586 { 587 width += 2; 588 pos++; 589 } 590 else 591 { 592#if defined (HANDLE_MULTIBYTE) 593 clen = mbrtowc (&wc, string + pos, left - pos, &ps); 594 if (MB_INVALIDCH (clen)) 595 { 596 width++; 597 pos++; 598 memset (&ps, 0, sizeof (mbstate_t)); 599 } 600 else if (MB_NULLWCH (clen)) 601 break; 602 else 603 { 604 pos += clen; 605 w = wcwidth (wc); 606 width += (w >= 0) ? w : 1; 607 } 608#else 609 width++; 610 pos++; 611#endif 612 } 613 } 614 615 return width; 616} 617 618static int 619fnprint (to_print) 620 const char *to_print; 621{ 622 int printed_len; 623 const char *s; 624#if defined (HANDLE_MULTIBYTE) 625 mbstate_t ps; 626 const char *end; 627 size_t tlen;
|
| 628 int width, w; 629 wchar_t wc;
|
626 627 end = to_print + strlen (to_print) + 1; 628 memset (&ps, 0, sizeof (mbstate_t)); 629#endif 630 631 printed_len = 0; 632 s = to_print; 633 while (*s) 634 { 635 if (CTRL_CHAR (*s)) 636 { 637 putc ('^', rl_outstream); 638 putc (UNCTRL (*s), rl_outstream); 639 printed_len += 2; 640 s++; 641#if defined (HANDLE_MULTIBYTE) 642 memset (&ps, 0, sizeof (mbstate_t)); 643#endif 644 } 645 else if (*s == RUBOUT) 646 { 647 putc ('^', rl_outstream); 648 putc ('?', rl_outstream); 649 printed_len += 2; 650 s++; 651#if defined (HANDLE_MULTIBYTE) 652 memset (&ps, 0, sizeof (mbstate_t)); 653#endif 654 } 655 else 656 { 657#if defined (HANDLE_MULTIBYTE)
| 630 631 end = to_print + strlen (to_print) + 1; 632 memset (&ps, 0, sizeof (mbstate_t)); 633#endif 634 635 printed_len = 0; 636 s = to_print; 637 while (*s) 638 { 639 if (CTRL_CHAR (*s)) 640 { 641 putc ('^', rl_outstream); 642 putc (UNCTRL (*s), rl_outstream); 643 printed_len += 2; 644 s++; 645#if defined (HANDLE_MULTIBYTE) 646 memset (&ps, 0, sizeof (mbstate_t)); 647#endif 648 } 649 else if (*s == RUBOUT) 650 { 651 putc ('^', rl_outstream); 652 putc ('?', rl_outstream); 653 printed_len += 2; 654 s++; 655#if defined (HANDLE_MULTIBYTE) 656 memset (&ps, 0, sizeof (mbstate_t)); 657#endif 658 } 659 else 660 { 661#if defined (HANDLE_MULTIBYTE)
|
658 tlen = mbrlen (s, end - s, &ps);
| 662 tlen = mbrtowc (&wc, s, end - s, &ps);
|
659 if (MB_INVALIDCH (tlen)) 660 { 661 tlen = 1;
| 663 if (MB_INVALIDCH (tlen)) 664 { 665 tlen = 1;
|
| 666 width = 1;
|
662 memset (&ps, 0, sizeof (mbstate_t)); 663 } 664 else if (MB_NULLWCH (tlen)) 665 break;
| 667 memset (&ps, 0, sizeof (mbstate_t)); 668 } 669 else if (MB_NULLWCH (tlen)) 670 break;
|
| 671 else 672 { 673 w = wcwidth (wc); 674 width = (w >= 0) ? w : 1; 675 }
|
666 fwrite (s, 1, tlen, rl_outstream); 667 s += tlen;
| 676 fwrite (s, 1, tlen, rl_outstream); 677 s += tlen;
|
| 678 printed_len += width;
|
668#else 669 putc (*s, rl_outstream); 670 s++;
| 679#else 680 putc (*s, rl_outstream); 681 s++;
|
671#endif
| |
672 printed_len++;
| 682 printed_len++;
|
| 683#endif
|
673 } 674 } 675 676 return printed_len; 677} 678 679/* Output TO_PRINT to rl_outstream. If VISIBLE_STATS is defined and we 680 are using it, check for and output a single character for `special' 681 filenames. Return the number of characters we output. */ 682 683static int 684print_filename (to_print, full_pathname) 685 char *to_print, *full_pathname; 686{ 687 int printed_len, extension_char, slen, tlen;
| 684 } 685 } 686 687 return printed_len; 688} 689 690/* Output TO_PRINT to rl_outstream. If VISIBLE_STATS is defined and we 691 are using it, check for and output a single character for `special' 692 filenames. Return the number of characters we output. */ 693 694static int 695print_filename (to_print, full_pathname) 696 char *to_print, *full_pathname; 697{ 698 int printed_len, extension_char, slen, tlen;
|
688 char *s, c, *new_full_pathname;
| 699 char *s, c, *new_full_pathname, *dn;
|
689 690 extension_char = 0; 691 printed_len = fnprint (to_print); 692 693#if defined (VISIBLE_STATS) 694 if (rl_filename_completion_desired && (rl_visible_stats || _rl_complete_mark_directories)) 695#else 696 if (rl_filename_completion_desired && _rl_complete_mark_directories) 697#endif 698 { 699 /* If to_print != full_pathname, to_print is the basename of the 700 path passed. In this case, we try to expand the directory 701 name before checking for the stat character. */ 702 if (to_print != full_pathname) 703 { 704 /* Terminate the directory name. */ 705 c = to_print[-1]; 706 to_print[-1] = '\0'; 707 708 /* If setting the last slash in full_pathname to a NUL results in 709 full_pathname being the empty string, we are trying to complete 710 files in the root directory. If we pass a null string to the 711 bash directory completion hook, for example, it will expand it 712 to the current directory. We just want the `/'. */
| 700 701 extension_char = 0; 702 printed_len = fnprint (to_print); 703 704#if defined (VISIBLE_STATS) 705 if (rl_filename_completion_desired && (rl_visible_stats || _rl_complete_mark_directories)) 706#else 707 if (rl_filename_completion_desired && _rl_complete_mark_directories) 708#endif 709 { 710 /* If to_print != full_pathname, to_print is the basename of the 711 path passed. In this case, we try to expand the directory 712 name before checking for the stat character. */ 713 if (to_print != full_pathname) 714 { 715 /* Terminate the directory name. */ 716 c = to_print[-1]; 717 to_print[-1] = '\0'; 718 719 /* If setting the last slash in full_pathname to a NUL results in 720 full_pathname being the empty string, we are trying to complete 721 files in the root directory. If we pass a null string to the 722 bash directory completion hook, for example, it will expand it 723 to the current directory. We just want the `/'. */
|
713 s = tilde_expand (full_pathname && *full_pathname ? full_pathname : "/");
| 724 if (full_pathname == 0 || *full_pathname == 0) 725 dn = "/"; 726 else if (full_pathname[0] != '/') 727 dn = full_pathname; 728 else if (full_pathname[1] == 0) 729 dn = "//"; /* restore trailing slash to `//' */ 730 else if (full_pathname[1] == '/' && full_pathname[2] == 0) 731 dn = "/"; /* don't turn /// into // */ 732 else 733 dn = full_pathname; 734 s = tilde_expand (dn);
|
714 if (rl_directory_completion_hook) 715 (*rl_directory_completion_hook) (&s); 716 717 slen = strlen (s); 718 tlen = strlen (to_print); 719 new_full_pathname = (char *)xmalloc (slen + tlen + 2); 720 strcpy (new_full_pathname, s);
| 735 if (rl_directory_completion_hook) 736 (*rl_directory_completion_hook) (&s); 737 738 slen = strlen (s); 739 tlen = strlen (to_print); 740 new_full_pathname = (char *)xmalloc (slen + tlen + 2); 741 strcpy (new_full_pathname, s);
|
| 742 if (s[slen - 1] == '/') 743 slen--; 744 else 745 new_full_pathname[slen] = '/';
|
721 new_full_pathname[slen] = '/'; 722 strcpy (new_full_pathname + slen + 1, to_print); 723 724#if defined (VISIBLE_STATS) 725 if (rl_visible_stats) 726 extension_char = stat_char (new_full_pathname); 727 else 728#endif 729 if (path_isdir (new_full_pathname)) 730 extension_char = '/'; 731 732 free (new_full_pathname); 733 to_print[-1] = c; 734 } 735 else 736 { 737 s = tilde_expand (full_pathname); 738#if defined (VISIBLE_STATS) 739 if (rl_visible_stats) 740 extension_char = stat_char (s); 741 else 742#endif 743 if (path_isdir (s)) 744 extension_char = '/'; 745 } 746 747 free (s); 748 if (extension_char) 749 { 750 putc (extension_char, rl_outstream); 751 printed_len++; 752 } 753 } 754 755 return printed_len; 756} 757 758static char * 759rl_quote_filename (s, rtype, qcp) 760 char *s; 761 int rtype; 762 char *qcp; 763{ 764 char *r; 765 766 r = (char *)xmalloc (strlen (s) + 2); 767 *r = *rl_completer_quote_characters; 768 strcpy (r + 1, s); 769 if (qcp) 770 *qcp = *rl_completer_quote_characters; 771 return r; 772} 773 774/* Find the bounds of the current word for completion purposes, and leave 775 rl_point set to the end of the word. This function skips quoted 776 substrings (characters between matched pairs of characters in 777 rl_completer_quote_characters). First we try to find an unclosed 778 quoted substring on which to do matching. If one is not found, we use 779 the word break characters to find the boundaries of the current word. 780 We call an application-specific function to decide whether or not a 781 particular word break character is quoted; if that function returns a 782 non-zero result, the character does not break a word. This function 783 returns the opening quote character if we found an unclosed quoted 784 substring, '\0' otherwise. FP, if non-null, is set to a value saying 785 which (shell-like) quote characters we found (single quote, double 786 quote, or backslash) anywhere in the string. DP, if non-null, is set to 787 the value of the delimiter character that caused a word break. */ 788 789char 790_rl_find_completion_word (fp, dp) 791 int *fp, *dp; 792{ 793 int scan, end, found_quote, delimiter, pass_next, isbrk; 794 char quote_char, *brkchars; 795 796 end = rl_point; 797 found_quote = delimiter = 0; 798 quote_char = '\0'; 799 800 brkchars = 0; 801 if (rl_completion_word_break_hook) 802 brkchars = (*rl_completion_word_break_hook) (); 803 if (brkchars == 0) 804 brkchars = rl_completer_word_break_characters; 805 806 if (rl_completer_quote_characters) 807 { 808 /* We have a list of characters which can be used in pairs to 809 quote substrings for the completer. Try to find the start 810 of an unclosed quoted substring. */ 811 /* FOUND_QUOTE is set so we know what kind of quotes we found. */
| 746 new_full_pathname[slen] = '/'; 747 strcpy (new_full_pathname + slen + 1, to_print); 748 749#if defined (VISIBLE_STATS) 750 if (rl_visible_stats) 751 extension_char = stat_char (new_full_pathname); 752 else 753#endif 754 if (path_isdir (new_full_pathname)) 755 extension_char = '/'; 756 757 free (new_full_pathname); 758 to_print[-1] = c; 759 } 760 else 761 { 762 s = tilde_expand (full_pathname); 763#if defined (VISIBLE_STATS) 764 if (rl_visible_stats) 765 extension_char = stat_char (s); 766 else 767#endif 768 if (path_isdir (s)) 769 extension_char = '/'; 770 } 771 772 free (s); 773 if (extension_char) 774 { 775 putc (extension_char, rl_outstream); 776 printed_len++; 777 } 778 } 779 780 return printed_len; 781} 782 783static char * 784rl_quote_filename (s, rtype, qcp) 785 char *s; 786 int rtype; 787 char *qcp; 788{ 789 char *r; 790 791 r = (char *)xmalloc (strlen (s) + 2); 792 *r = *rl_completer_quote_characters; 793 strcpy (r + 1, s); 794 if (qcp) 795 *qcp = *rl_completer_quote_characters; 796 return r; 797} 798 799/* Find the bounds of the current word for completion purposes, and leave 800 rl_point set to the end of the word. This function skips quoted 801 substrings (characters between matched pairs of characters in 802 rl_completer_quote_characters). First we try to find an unclosed 803 quoted substring on which to do matching. If one is not found, we use 804 the word break characters to find the boundaries of the current word. 805 We call an application-specific function to decide whether or not a 806 particular word break character is quoted; if that function returns a 807 non-zero result, the character does not break a word. This function 808 returns the opening quote character if we found an unclosed quoted 809 substring, '\0' otherwise. FP, if non-null, is set to a value saying 810 which (shell-like) quote characters we found (single quote, double 811 quote, or backslash) anywhere in the string. DP, if non-null, is set to 812 the value of the delimiter character that caused a word break. */ 813 814char 815_rl_find_completion_word (fp, dp) 816 int *fp, *dp; 817{ 818 int scan, end, found_quote, delimiter, pass_next, isbrk; 819 char quote_char, *brkchars; 820 821 end = rl_point; 822 found_quote = delimiter = 0; 823 quote_char = '\0'; 824 825 brkchars = 0; 826 if (rl_completion_word_break_hook) 827 brkchars = (*rl_completion_word_break_hook) (); 828 if (brkchars == 0) 829 brkchars = rl_completer_word_break_characters; 830 831 if (rl_completer_quote_characters) 832 { 833 /* We have a list of characters which can be used in pairs to 834 quote substrings for the completer. Try to find the start 835 of an unclosed quoted substring. */ 836 /* FOUND_QUOTE is set so we know what kind of quotes we found. */
|
812#if defined (HANDLE_MULTIBYTE) 813 for (scan = pass_next = 0; scan < end; 814 scan = ((MB_CUR_MAX == 1 || rl_byte_oriented) 815 ? (scan + 1) 816 : _rl_find_next_mbchar (rl_line_buffer, scan, 1, MB_FIND_ANY))) 817#else 818 for (scan = pass_next = 0; scan < end; scan++) 819#endif
| 837 for (scan = pass_next = 0; scan < end; scan = MB_NEXTCHAR (rl_line_buffer, scan, 1, MB_FIND_ANY))
|
820 { 821 if (pass_next) 822 { 823 pass_next = 0; 824 continue; 825 } 826 827 /* Shell-like semantics for single quotes -- don't allow backslash 828 to quote anything in single quotes, especially not the closing 829 quote. If you don't like this, take out the check on the value 830 of quote_char. */ 831 if (quote_char != '\'' && rl_line_buffer[scan] == '\\') 832 { 833 pass_next = 1; 834 found_quote |= RL_QF_BACKSLASH; 835 continue; 836 } 837 838 if (quote_char != '\0') 839 { 840 /* Ignore everything until the matching close quote char. */ 841 if (rl_line_buffer[scan] == quote_char) 842 { 843 /* Found matching close. Abandon this substring. */ 844 quote_char = '\0'; 845 rl_point = end; 846 } 847 } 848 else if (strchr (rl_completer_quote_characters, rl_line_buffer[scan])) 849 { 850 /* Found start of a quoted substring. */ 851 quote_char = rl_line_buffer[scan]; 852 rl_point = scan + 1; 853 /* Shell-like quoting conventions. */ 854 if (quote_char == '\'') 855 found_quote |= RL_QF_SINGLE_QUOTE; 856 else if (quote_char == '"') 857 found_quote |= RL_QF_DOUBLE_QUOTE; 858 else 859 found_quote |= RL_QF_OTHER_QUOTE; 860 } 861 } 862 } 863 864 if (rl_point == end && quote_char == '\0') 865 { 866 /* We didn't find an unclosed quoted substring upon which to do 867 completion, so use the word break characters to find the 868 substring on which to complete. */
| 838 { 839 if (pass_next) 840 { 841 pass_next = 0; 842 continue; 843 } 844 845 /* Shell-like semantics for single quotes -- don't allow backslash 846 to quote anything in single quotes, especially not the closing 847 quote. If you don't like this, take out the check on the value 848 of quote_char. */ 849 if (quote_char != '\'' && rl_line_buffer[scan] == '\\') 850 { 851 pass_next = 1; 852 found_quote |= RL_QF_BACKSLASH; 853 continue; 854 } 855 856 if (quote_char != '\0') 857 { 858 /* Ignore everything until the matching close quote char. */ 859 if (rl_line_buffer[scan] == quote_char) 860 { 861 /* Found matching close. Abandon this substring. */ 862 quote_char = '\0'; 863 rl_point = end; 864 } 865 } 866 else if (strchr (rl_completer_quote_characters, rl_line_buffer[scan])) 867 { 868 /* Found start of a quoted substring. */ 869 quote_char = rl_line_buffer[scan]; 870 rl_point = scan + 1; 871 /* Shell-like quoting conventions. */ 872 if (quote_char == '\'') 873 found_quote |= RL_QF_SINGLE_QUOTE; 874 else if (quote_char == '"') 875 found_quote |= RL_QF_DOUBLE_QUOTE; 876 else 877 found_quote |= RL_QF_OTHER_QUOTE; 878 } 879 } 880 } 881 882 if (rl_point == end && quote_char == '\0') 883 { 884 /* We didn't find an unclosed quoted substring upon which to do 885 completion, so use the word break characters to find the 886 substring on which to complete. */
|
869#if defined (HANDLE_MULTIBYTE) 870 while (rl_point = _rl_find_prev_mbchar (rl_line_buffer, rl_point, MB_FIND_ANY)) 871#else 872 while (--rl_point) 873#endif
| 887 while (rl_point = MB_PREVCHAR (rl_line_buffer, rl_point, MB_FIND_ANY))
|
874 { 875 scan = rl_line_buffer[rl_point]; 876 877 if (strchr (brkchars, scan) == 0) 878 continue; 879 880 /* Call the application-specific function to tell us whether 881 this word break character is quoted and should be skipped. */ 882 if (rl_char_is_quoted_p && found_quote && 883 (*rl_char_is_quoted_p) (rl_line_buffer, rl_point)) 884 continue; 885 886 /* Convoluted code, but it avoids an n^2 algorithm with calls 887 to char_is_quoted. */ 888 break; 889 } 890 } 891 892 /* If we are at an unquoted word break, then advance past it. */ 893 scan = rl_line_buffer[rl_point]; 894 895 /* If there is an application-specific function to say whether or not 896 a character is quoted and we found a quote character, let that 897 function decide whether or not a character is a word break, even 898 if it is found in rl_completer_word_break_characters. Don't bother 899 if we're at the end of the line, though. */ 900 if (scan) 901 { 902 if (rl_char_is_quoted_p) 903 isbrk = (found_quote == 0 || 904 (*rl_char_is_quoted_p) (rl_line_buffer, rl_point) == 0) && 905 strchr (brkchars, scan) != 0; 906 else 907 isbrk = strchr (brkchars, scan) != 0; 908 909 if (isbrk) 910 { 911 /* If the character that caused the word break was a quoting 912 character, then remember it as the delimiter. */ 913 if (rl_basic_quote_characters && 914 strchr (rl_basic_quote_characters, scan) && 915 (end - rl_point) > 1) 916 delimiter = scan; 917 918 /* If the character isn't needed to determine something special 919 about what kind of completion to perform, then advance past it. */ 920 if (rl_special_prefixes == 0 || strchr (rl_special_prefixes, scan) == 0) 921 rl_point++; 922 } 923 } 924 925 if (fp) 926 *fp = found_quote; 927 if (dp) 928 *dp = delimiter; 929 930 return (quote_char); 931} 932 933static char ** 934gen_completion_matches (text, start, end, our_func, found_quote, quote_char) 935 char *text; 936 int start, end; 937 rl_compentry_func_t *our_func; 938 int found_quote, quote_char; 939{ 940 char **matches, *temp; 941 942 rl_completion_found_quote = found_quote; 943 rl_completion_quote_character = quote_char; 944 945 /* If the user wants to TRY to complete, but then wants to give 946 up and use the default completion function, they set the 947 variable rl_attempted_completion_function. */ 948 if (rl_attempted_completion_function) 949 { 950 matches = (*rl_attempted_completion_function) (text, start, end); 951 952 if (matches || rl_attempted_completion_over) 953 { 954 rl_attempted_completion_over = 0; 955 return (matches); 956 } 957 } 958 959 /* Beware -- we're stripping the quotes here. Do this only if we know 960 we are doing filename completion and the application has defined a 961 filename dequoting function. */ 962 temp = (char *)NULL; 963 964 if (found_quote && our_func == rl_filename_completion_function && 965 rl_filename_dequoting_function) 966 { 967 /* delete single and double quotes */ 968 temp = (*rl_filename_dequoting_function) (text, quote_char); 969 text = temp; /* not freeing text is not a memory leak */ 970 } 971 972 matches = rl_completion_matches (text, our_func); 973 FREE (temp); 974 return matches; 975} 976 977/* Filter out duplicates in MATCHES. This frees up the strings in 978 MATCHES. */ 979static char ** 980remove_duplicate_matches (matches) 981 char **matches; 982{ 983 char *lowest_common; 984 int i, j, newlen; 985 char dead_slot; 986 char **temp_array; 987 988 /* Sort the items. */ 989 for (i = 0; matches[i]; i++) 990 ; 991 992 /* Sort the array without matches[0], since we need it to 993 stay in place no matter what. */ 994 if (i) 995 qsort (matches+1, i-1, sizeof (char *), (QSFUNC *)_rl_qsort_string_compare); 996 997 /* Remember the lowest common denominator for it may be unique. */ 998 lowest_common = savestring (matches[0]); 999 1000 for (i = newlen = 0; matches[i + 1]; i++) 1001 { 1002 if (strcmp (matches[i], matches[i + 1]) == 0) 1003 { 1004 free (matches[i]); 1005 matches[i] = (char *)&dead_slot; 1006 } 1007 else 1008 newlen++; 1009 } 1010 1011 /* We have marked all the dead slots with (char *)&dead_slot. 1012 Copy all the non-dead entries into a new array. */ 1013 temp_array = (char **)xmalloc ((3 + newlen) * sizeof (char *)); 1014 for (i = j = 1; matches[i]; i++) 1015 { 1016 if (matches[i] != (char *)&dead_slot) 1017 temp_array[j++] = matches[i]; 1018 } 1019 temp_array[j] = (char *)NULL; 1020 1021 if (matches[0] != (char *)&dead_slot) 1022 free (matches[0]); 1023 1024 /* Place the lowest common denominator back in [0]. */ 1025 temp_array[0] = lowest_common; 1026 1027 /* If there is one string left, and it is identical to the 1028 lowest common denominator, then the LCD is the string to 1029 insert. */ 1030 if (j == 2 && strcmp (temp_array[0], temp_array[1]) == 0) 1031 { 1032 free (temp_array[1]); 1033 temp_array[1] = (char *)NULL; 1034 } 1035 return (temp_array); 1036} 1037 1038/* Find the common prefix of the list of matches, and put it into 1039 matches[0]. */ 1040static int 1041compute_lcd_of_matches (match_list, matches, text) 1042 char **match_list; 1043 int matches; 1044 const char *text; 1045{ 1046 register int i, c1, c2, si; 1047 int low; /* Count of max-matched characters. */ 1048 char *dtext; /* dequoted TEXT, if needed */ 1049#if defined (HANDLE_MULTIBYTE) 1050 int v; 1051 mbstate_t ps1, ps2; 1052 wchar_t wc1, wc2; 1053#endif 1054 1055 /* If only one match, just use that. Otherwise, compare each 1056 member of the list with the next, finding out where they 1057 stop matching. */ 1058 if (matches == 1) 1059 { 1060 match_list[0] = match_list[1]; 1061 match_list[1] = (char *)NULL; 1062 return 1; 1063 } 1064 1065 for (i = 1, low = 100000; i < matches; i++) 1066 { 1067#if defined (HANDLE_MULTIBYTE) 1068 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0) 1069 { 1070 memset (&ps1, 0, sizeof (mbstate_t)); 1071 memset (&ps2, 0, sizeof (mbstate_t)); 1072 } 1073#endif 1074 if (_rl_completion_case_fold) 1075 { 1076 for (si = 0; 1077 (c1 = _rl_to_lower(match_list[i][si])) && 1078 (c2 = _rl_to_lower(match_list[i + 1][si])); 1079 si++) 1080#if defined (HANDLE_MULTIBYTE) 1081 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0) 1082 { 1083 v = mbrtowc (&wc1, match_list[i]+si, strlen (match_list[i]+si), &ps1); 1084 mbrtowc (&wc2, match_list[i+1]+si, strlen (match_list[i+1]+si), &ps2); 1085 wc1 = towlower (wc1); 1086 wc2 = towlower (wc2); 1087 if (wc1 != wc2) 1088 break; 1089 else if (v > 1) 1090 si += v - 1; 1091 } 1092 else 1093#endif 1094 if (c1 != c2) 1095 break; 1096 } 1097 else 1098 { 1099 for (si = 0; 1100 (c1 = match_list[i][si]) && 1101 (c2 = match_list[i + 1][si]); 1102 si++) 1103#if defined (HANDLE_MULTIBYTE) 1104 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0) 1105 { 1106 mbstate_t ps_back = ps1; 1107 if (!_rl_compare_chars (match_list[i], si, &ps1, match_list[i+1], si, &ps2)) 1108 break; 1109 else if ((v = _rl_get_char_len (&match_list[i][si], &ps_back)) > 1) 1110 si += v - 1; 1111 } 1112 else 1113#endif 1114 if (c1 != c2) 1115 break; 1116 } 1117 1118 if (low > si) 1119 low = si; 1120 } 1121 1122 /* If there were multiple matches, but none matched up to even the 1123 first character, and the user typed something, use that as the 1124 value of matches[0]. */ 1125 if (low == 0 && text && *text) 1126 { 1127 match_list[0] = (char *)xmalloc (strlen (text) + 1); 1128 strcpy (match_list[0], text); 1129 } 1130 else 1131 { 1132 match_list[0] = (char *)xmalloc (low + 1); 1133 1134 /* XXX - this might need changes in the presence of multibyte chars */ 1135 1136 /* If we are ignoring case, try to preserve the case of the string 1137 the user typed in the face of multiple matches differing in case. */ 1138 if (_rl_completion_case_fold) 1139 { 1140 /* We're making an assumption here: 1141 IF we're completing filenames AND 1142 the application has defined a filename dequoting function AND 1143 we found a quote character AND 1144 the application has requested filename quoting 1145 THEN 1146 we assume that TEXT was dequoted before checking against 1147 the file system and needs to be dequoted here before we 1148 check against the list of matches 1149 FI */ 1150 dtext = (char *)NULL; 1151 if (rl_filename_completion_desired && 1152 rl_filename_dequoting_function && 1153 rl_completion_found_quote && 1154 rl_filename_quoting_desired) 1155 {
| 888 { 889 scan = rl_line_buffer[rl_point]; 890 891 if (strchr (brkchars, scan) == 0) 892 continue; 893 894 /* Call the application-specific function to tell us whether 895 this word break character is quoted and should be skipped. */ 896 if (rl_char_is_quoted_p && found_quote && 897 (*rl_char_is_quoted_p) (rl_line_buffer, rl_point)) 898 continue; 899 900 /* Convoluted code, but it avoids an n^2 algorithm with calls 901 to char_is_quoted. */ 902 break; 903 } 904 } 905 906 /* If we are at an unquoted word break, then advance past it. */ 907 scan = rl_line_buffer[rl_point]; 908 909 /* If there is an application-specific function to say whether or not 910 a character is quoted and we found a quote character, let that 911 function decide whether or not a character is a word break, even 912 if it is found in rl_completer_word_break_characters. Don't bother 913 if we're at the end of the line, though. */ 914 if (scan) 915 { 916 if (rl_char_is_quoted_p) 917 isbrk = (found_quote == 0 || 918 (*rl_char_is_quoted_p) (rl_line_buffer, rl_point) == 0) && 919 strchr (brkchars, scan) != 0; 920 else 921 isbrk = strchr (brkchars, scan) != 0; 922 923 if (isbrk) 924 { 925 /* If the character that caused the word break was a quoting 926 character, then remember it as the delimiter. */ 927 if (rl_basic_quote_characters && 928 strchr (rl_basic_quote_characters, scan) && 929 (end - rl_point) > 1) 930 delimiter = scan; 931 932 /* If the character isn't needed to determine something special 933 about what kind of completion to perform, then advance past it. */ 934 if (rl_special_prefixes == 0 || strchr (rl_special_prefixes, scan) == 0) 935 rl_point++; 936 } 937 } 938 939 if (fp) 940 *fp = found_quote; 941 if (dp) 942 *dp = delimiter; 943 944 return (quote_char); 945} 946 947static char ** 948gen_completion_matches (text, start, end, our_func, found_quote, quote_char) 949 char *text; 950 int start, end; 951 rl_compentry_func_t *our_func; 952 int found_quote, quote_char; 953{ 954 char **matches, *temp; 955 956 rl_completion_found_quote = found_quote; 957 rl_completion_quote_character = quote_char; 958 959 /* If the user wants to TRY to complete, but then wants to give 960 up and use the default completion function, they set the 961 variable rl_attempted_completion_function. */ 962 if (rl_attempted_completion_function) 963 { 964 matches = (*rl_attempted_completion_function) (text, start, end); 965 966 if (matches || rl_attempted_completion_over) 967 { 968 rl_attempted_completion_over = 0; 969 return (matches); 970 } 971 } 972 973 /* Beware -- we're stripping the quotes here. Do this only if we know 974 we are doing filename completion and the application has defined a 975 filename dequoting function. */ 976 temp = (char *)NULL; 977 978 if (found_quote && our_func == rl_filename_completion_function && 979 rl_filename_dequoting_function) 980 { 981 /* delete single and double quotes */ 982 temp = (*rl_filename_dequoting_function) (text, quote_char); 983 text = temp; /* not freeing text is not a memory leak */ 984 } 985 986 matches = rl_completion_matches (text, our_func); 987 FREE (temp); 988 return matches; 989} 990 991/* Filter out duplicates in MATCHES. This frees up the strings in 992 MATCHES. */ 993static char ** 994remove_duplicate_matches (matches) 995 char **matches; 996{ 997 char *lowest_common; 998 int i, j, newlen; 999 char dead_slot; 1000 char **temp_array; 1001 1002 /* Sort the items. */ 1003 for (i = 0; matches[i]; i++) 1004 ; 1005 1006 /* Sort the array without matches[0], since we need it to 1007 stay in place no matter what. */ 1008 if (i) 1009 qsort (matches+1, i-1, sizeof (char *), (QSFUNC *)_rl_qsort_string_compare); 1010 1011 /* Remember the lowest common denominator for it may be unique. */ 1012 lowest_common = savestring (matches[0]); 1013 1014 for (i = newlen = 0; matches[i + 1]; i++) 1015 { 1016 if (strcmp (matches[i], matches[i + 1]) == 0) 1017 { 1018 free (matches[i]); 1019 matches[i] = (char *)&dead_slot; 1020 } 1021 else 1022 newlen++; 1023 } 1024 1025 /* We have marked all the dead slots with (char *)&dead_slot. 1026 Copy all the non-dead entries into a new array. */ 1027 temp_array = (char **)xmalloc ((3 + newlen) * sizeof (char *)); 1028 for (i = j = 1; matches[i]; i++) 1029 { 1030 if (matches[i] != (char *)&dead_slot) 1031 temp_array[j++] = matches[i]; 1032 } 1033 temp_array[j] = (char *)NULL; 1034 1035 if (matches[0] != (char *)&dead_slot) 1036 free (matches[0]); 1037 1038 /* Place the lowest common denominator back in [0]. */ 1039 temp_array[0] = lowest_common; 1040 1041 /* If there is one string left, and it is identical to the 1042 lowest common denominator, then the LCD is the string to 1043 insert. */ 1044 if (j == 2 && strcmp (temp_array[0], temp_array[1]) == 0) 1045 { 1046 free (temp_array[1]); 1047 temp_array[1] = (char *)NULL; 1048 } 1049 return (temp_array); 1050} 1051 1052/* Find the common prefix of the list of matches, and put it into 1053 matches[0]. */ 1054static int 1055compute_lcd_of_matches (match_list, matches, text) 1056 char **match_list; 1057 int matches; 1058 const char *text; 1059{ 1060 register int i, c1, c2, si; 1061 int low; /* Count of max-matched characters. */ 1062 char *dtext; /* dequoted TEXT, if needed */ 1063#if defined (HANDLE_MULTIBYTE) 1064 int v; 1065 mbstate_t ps1, ps2; 1066 wchar_t wc1, wc2; 1067#endif 1068 1069 /* If only one match, just use that. Otherwise, compare each 1070 member of the list with the next, finding out where they 1071 stop matching. */ 1072 if (matches == 1) 1073 { 1074 match_list[0] = match_list[1]; 1075 match_list[1] = (char *)NULL; 1076 return 1; 1077 } 1078 1079 for (i = 1, low = 100000; i < matches; i++) 1080 { 1081#if defined (HANDLE_MULTIBYTE) 1082 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0) 1083 { 1084 memset (&ps1, 0, sizeof (mbstate_t)); 1085 memset (&ps2, 0, sizeof (mbstate_t)); 1086 } 1087#endif 1088 if (_rl_completion_case_fold) 1089 { 1090 for (si = 0; 1091 (c1 = _rl_to_lower(match_list[i][si])) && 1092 (c2 = _rl_to_lower(match_list[i + 1][si])); 1093 si++) 1094#if defined (HANDLE_MULTIBYTE) 1095 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0) 1096 { 1097 v = mbrtowc (&wc1, match_list[i]+si, strlen (match_list[i]+si), &ps1); 1098 mbrtowc (&wc2, match_list[i+1]+si, strlen (match_list[i+1]+si), &ps2); 1099 wc1 = towlower (wc1); 1100 wc2 = towlower (wc2); 1101 if (wc1 != wc2) 1102 break; 1103 else if (v > 1) 1104 si += v - 1; 1105 } 1106 else 1107#endif 1108 if (c1 != c2) 1109 break; 1110 } 1111 else 1112 { 1113 for (si = 0; 1114 (c1 = match_list[i][si]) && 1115 (c2 = match_list[i + 1][si]); 1116 si++) 1117#if defined (HANDLE_MULTIBYTE) 1118 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0) 1119 { 1120 mbstate_t ps_back = ps1; 1121 if (!_rl_compare_chars (match_list[i], si, &ps1, match_list[i+1], si, &ps2)) 1122 break; 1123 else if ((v = _rl_get_char_len (&match_list[i][si], &ps_back)) > 1) 1124 si += v - 1; 1125 } 1126 else 1127#endif 1128 if (c1 != c2) 1129 break; 1130 } 1131 1132 if (low > si) 1133 low = si; 1134 } 1135 1136 /* If there were multiple matches, but none matched up to even the 1137 first character, and the user typed something, use that as the 1138 value of matches[0]. */ 1139 if (low == 0 && text && *text) 1140 { 1141 match_list[0] = (char *)xmalloc (strlen (text) + 1); 1142 strcpy (match_list[0], text); 1143 } 1144 else 1145 { 1146 match_list[0] = (char *)xmalloc (low + 1); 1147 1148 /* XXX - this might need changes in the presence of multibyte chars */ 1149 1150 /* If we are ignoring case, try to preserve the case of the string 1151 the user typed in the face of multiple matches differing in case. */ 1152 if (_rl_completion_case_fold) 1153 { 1154 /* We're making an assumption here: 1155 IF we're completing filenames AND 1156 the application has defined a filename dequoting function AND 1157 we found a quote character AND 1158 the application has requested filename quoting 1159 THEN 1160 we assume that TEXT was dequoted before checking against 1161 the file system and needs to be dequoted here before we 1162 check against the list of matches 1163 FI */ 1164 dtext = (char *)NULL; 1165 if (rl_filename_completion_desired && 1166 rl_filename_dequoting_function && 1167 rl_completion_found_quote && 1168 rl_filename_quoting_desired) 1169 {
|
1156 dtext = (*rl_filename_dequoting_function) (text, rl_completion_quote_character);
| 1170 dtext = (*rl_filename_dequoting_function) ((char *)text, rl_completion_quote_character);
|
1157 text = dtext; 1158 } 1159 1160 /* sort the list to get consistent answers. */ 1161 qsort (match_list+1, matches, sizeof(char *), (QSFUNC *)_rl_qsort_string_compare); 1162 1163 si = strlen (text); 1164 if (si <= low) 1165 { 1166 for (i = 1; i <= matches; i++) 1167 if (strncmp (match_list[i], text, si) == 0) 1168 { 1169 strncpy (match_list[0], match_list[i], low); 1170 break; 1171 } 1172 /* no casematch, use first entry */ 1173 if (i > matches) 1174 strncpy (match_list[0], match_list[1], low); 1175 } 1176 else 1177 /* otherwise, just use the text the user typed. */ 1178 strncpy (match_list[0], text, low); 1179 1180 FREE (dtext); 1181 } 1182 else 1183 strncpy (match_list[0], match_list[1], low); 1184 1185 match_list[0][low] = '\0'; 1186 } 1187 1188 return matches; 1189} 1190 1191static int 1192postprocess_matches (matchesp, matching_filenames) 1193 char ***matchesp; 1194 int matching_filenames; 1195{ 1196 char *t, **matches, **temp_matches; 1197 int nmatch, i; 1198 1199 matches = *matchesp; 1200 1201 if (matches == 0) 1202 return 0; 1203 1204 /* It seems to me that in all the cases we handle we would like 1205 to ignore duplicate possiblilities. Scan for the text to 1206 insert being identical to the other completions. */ 1207 if (rl_ignore_completion_duplicates) 1208 { 1209 temp_matches = remove_duplicate_matches (matches); 1210 free (matches); 1211 matches = temp_matches; 1212 } 1213 1214 /* If we are matching filenames, then here is our chance to 1215 do clever processing by re-examining the list. Call the 1216 ignore function with the array as a parameter. It can 1217 munge the array, deleting matches as it desires. */ 1218 if (rl_ignore_some_completions_function && matching_filenames) 1219 { 1220 for (nmatch = 1; matches[nmatch]; nmatch++) 1221 ; 1222 (void)(*rl_ignore_some_completions_function) (matches); 1223 if (matches == 0 || matches[0] == 0) 1224 { 1225 FREE (matches); 1226 *matchesp = (char **)0; 1227 return 0; 1228 } 1229 else 1230 { 1231 /* If we removed some matches, recompute the common prefix. */ 1232 for (i = 1; matches[i]; i++) 1233 ; 1234 if (i > 1 && i < nmatch) 1235 { 1236 t = matches[0]; 1237 compute_lcd_of_matches (matches, i - 1, t); 1238 FREE (t); 1239 } 1240 } 1241 } 1242 1243 *matchesp = matches; 1244 return (1); 1245} 1246 1247/* A convenience function for displaying a list of strings in 1248 columnar format on readline's output stream. MATCHES is the list 1249 of strings, in argv format, LEN is the number of strings in MATCHES, 1250 and MAX is the length of the longest string in MATCHES. */ 1251void 1252rl_display_match_list (matches, len, max) 1253 char **matches; 1254 int len, max; 1255{ 1256 int count, limit, printed_len, lines; 1257 int i, j, k, l; 1258 char *temp; 1259 1260 /* How many items of MAX length can we fit in the screen window? */ 1261 max += 2; 1262 limit = _rl_screenwidth / max; 1263 if (limit != 1 && (limit * max == _rl_screenwidth)) 1264 limit--; 1265 1266 /* Avoid a possible floating exception. If max > _rl_screenwidth, 1267 limit will be 0 and a divide-by-zero fault will result. */ 1268 if (limit == 0) 1269 limit = 1; 1270 1271 /* How many iterations of the printing loop? */ 1272 count = (len + (limit - 1)) / limit; 1273 1274 /* Watch out for special case. If LEN is less than LIMIT, then 1275 just do the inner printing loop. 1276 0 < len <= limit implies count = 1. */ 1277 1278 /* Sort the items if they are not already sorted. */ 1279 if (rl_ignore_completion_duplicates == 0) 1280 qsort (matches + 1, len, sizeof (char *), (QSFUNC *)_rl_qsort_string_compare); 1281 1282 rl_crlf (); 1283 1284 lines = 0; 1285 if (_rl_print_completions_horizontally == 0) 1286 { 1287 /* Print the sorted items, up-and-down alphabetically, like ls. */ 1288 for (i = 1; i <= count; i++) 1289 { 1290 for (j = 0, l = i; j < limit; j++) 1291 { 1292 if (l > len || matches[l] == 0) 1293 break; 1294 else 1295 { 1296 temp = printable_part (matches[l]); 1297 printed_len = print_filename (temp, matches[l]); 1298 1299 if (j + 1 < limit) 1300 for (k = 0; k < max - printed_len; k++) 1301 putc (' ', rl_outstream); 1302 } 1303 l += count; 1304 } 1305 rl_crlf (); 1306 lines++; 1307 if (_rl_page_completions && lines >= (_rl_screenheight - 1) && i < count) 1308 { 1309 lines = _rl_internal_pager (lines); 1310 if (lines < 0) 1311 return; 1312 } 1313 } 1314 } 1315 else 1316 { 1317 /* Print the sorted items, across alphabetically, like ls -x. */ 1318 for (i = 1; matches[i]; i++) 1319 { 1320 temp = printable_part (matches[i]); 1321 printed_len = print_filename (temp, matches[i]); 1322 /* Have we reached the end of this line? */ 1323 if (matches[i+1]) 1324 { 1325 if (i && (limit > 1) && (i % limit) == 0) 1326 { 1327 rl_crlf (); 1328 lines++; 1329 if (_rl_page_completions && lines >= _rl_screenheight - 1) 1330 { 1331 lines = _rl_internal_pager (lines); 1332 if (lines < 0) 1333 return; 1334 } 1335 } 1336 else 1337 for (k = 0; k < max - printed_len; k++) 1338 putc (' ', rl_outstream); 1339 } 1340 } 1341 rl_crlf (); 1342 } 1343} 1344 1345/* Display MATCHES, a list of matching filenames in argv format. This 1346 handles the simple case -- a single match -- first. If there is more 1347 than one match, we compute the number of strings in the list and the 1348 length of the longest string, which will be needed by the display 1349 function. If the application wants to handle displaying the list of 1350 matches itself, it sets RL_COMPLETION_DISPLAY_MATCHES_HOOK to the 1351 address of a function, and we just call it. If we're handling the 1352 display ourselves, we just call rl_display_match_list. We also check 1353 that the list of matches doesn't exceed the user-settable threshold, 1354 and ask the user if he wants to see the list if there are more matches 1355 than RL_COMPLETION_QUERY_ITEMS. */ 1356static void 1357display_matches (matches) 1358 char **matches; 1359{ 1360 int len, max, i; 1361 char *temp; 1362 1363 /* Move to the last visible line of a possibly-multiple-line command. */ 1364 _rl_move_vert (_rl_vis_botlin); 1365 1366 /* Handle simple case first. What if there is only one answer? */ 1367 if (matches[1] == 0) 1368 { 1369 temp = printable_part (matches[0]); 1370 rl_crlf (); 1371 print_filename (temp, matches[0]); 1372 rl_crlf (); 1373 1374 rl_forced_update_display (); 1375 rl_display_fixed = 1; 1376 1377 return; 1378 } 1379 1380 /* There is more than one answer. Find out how many there are, 1381 and find the maximum printed length of a single entry. */ 1382 for (max = 0, i = 1; matches[i]; i++) 1383 { 1384 temp = printable_part (matches[i]); 1385 len = fnwidth (temp); 1386 1387 if (len > max) 1388 max = len; 1389 } 1390 1391 len = i - 1; 1392 1393 /* If the caller has defined a display hook, then call that now. */ 1394 if (rl_completion_display_matches_hook) 1395 { 1396 (*rl_completion_display_matches_hook) (matches, len, max); 1397 return; 1398 } 1399 1400 /* If there are many items, then ask the user if she really wants to 1401 see them all. */
| 1171 text = dtext; 1172 } 1173 1174 /* sort the list to get consistent answers. */ 1175 qsort (match_list+1, matches, sizeof(char *), (QSFUNC *)_rl_qsort_string_compare); 1176 1177 si = strlen (text); 1178 if (si <= low) 1179 { 1180 for (i = 1; i <= matches; i++) 1181 if (strncmp (match_list[i], text, si) == 0) 1182 { 1183 strncpy (match_list[0], match_list[i], low); 1184 break; 1185 } 1186 /* no casematch, use first entry */ 1187 if (i > matches) 1188 strncpy (match_list[0], match_list[1], low); 1189 } 1190 else 1191 /* otherwise, just use the text the user typed. */ 1192 strncpy (match_list[0], text, low); 1193 1194 FREE (dtext); 1195 } 1196 else 1197 strncpy (match_list[0], match_list[1], low); 1198 1199 match_list[0][low] = '\0'; 1200 } 1201 1202 return matches; 1203} 1204 1205static int 1206postprocess_matches (matchesp, matching_filenames) 1207 char ***matchesp; 1208 int matching_filenames; 1209{ 1210 char *t, **matches, **temp_matches; 1211 int nmatch, i; 1212 1213 matches = *matchesp; 1214 1215 if (matches == 0) 1216 return 0; 1217 1218 /* It seems to me that in all the cases we handle we would like 1219 to ignore duplicate possiblilities. Scan for the text to 1220 insert being identical to the other completions. */ 1221 if (rl_ignore_completion_duplicates) 1222 { 1223 temp_matches = remove_duplicate_matches (matches); 1224 free (matches); 1225 matches = temp_matches; 1226 } 1227 1228 /* If we are matching filenames, then here is our chance to 1229 do clever processing by re-examining the list. Call the 1230 ignore function with the array as a parameter. It can 1231 munge the array, deleting matches as it desires. */ 1232 if (rl_ignore_some_completions_function && matching_filenames) 1233 { 1234 for (nmatch = 1; matches[nmatch]; nmatch++) 1235 ; 1236 (void)(*rl_ignore_some_completions_function) (matches); 1237 if (matches == 0 || matches[0] == 0) 1238 { 1239 FREE (matches); 1240 *matchesp = (char **)0; 1241 return 0; 1242 } 1243 else 1244 { 1245 /* If we removed some matches, recompute the common prefix. */ 1246 for (i = 1; matches[i]; i++) 1247 ; 1248 if (i > 1 && i < nmatch) 1249 { 1250 t = matches[0]; 1251 compute_lcd_of_matches (matches, i - 1, t); 1252 FREE (t); 1253 } 1254 } 1255 } 1256 1257 *matchesp = matches; 1258 return (1); 1259} 1260 1261/* A convenience function for displaying a list of strings in 1262 columnar format on readline's output stream. MATCHES is the list 1263 of strings, in argv format, LEN is the number of strings in MATCHES, 1264 and MAX is the length of the longest string in MATCHES. */ 1265void 1266rl_display_match_list (matches, len, max) 1267 char **matches; 1268 int len, max; 1269{ 1270 int count, limit, printed_len, lines; 1271 int i, j, k, l; 1272 char *temp; 1273 1274 /* How many items of MAX length can we fit in the screen window? */ 1275 max += 2; 1276 limit = _rl_screenwidth / max; 1277 if (limit != 1 && (limit * max == _rl_screenwidth)) 1278 limit--; 1279 1280 /* Avoid a possible floating exception. If max > _rl_screenwidth, 1281 limit will be 0 and a divide-by-zero fault will result. */ 1282 if (limit == 0) 1283 limit = 1; 1284 1285 /* How many iterations of the printing loop? */ 1286 count = (len + (limit - 1)) / limit; 1287 1288 /* Watch out for special case. If LEN is less than LIMIT, then 1289 just do the inner printing loop. 1290 0 < len <= limit implies count = 1. */ 1291 1292 /* Sort the items if they are not already sorted. */ 1293 if (rl_ignore_completion_duplicates == 0) 1294 qsort (matches + 1, len, sizeof (char *), (QSFUNC *)_rl_qsort_string_compare); 1295 1296 rl_crlf (); 1297 1298 lines = 0; 1299 if (_rl_print_completions_horizontally == 0) 1300 { 1301 /* Print the sorted items, up-and-down alphabetically, like ls. */ 1302 for (i = 1; i <= count; i++) 1303 { 1304 for (j = 0, l = i; j < limit; j++) 1305 { 1306 if (l > len || matches[l] == 0) 1307 break; 1308 else 1309 { 1310 temp = printable_part (matches[l]); 1311 printed_len = print_filename (temp, matches[l]); 1312 1313 if (j + 1 < limit) 1314 for (k = 0; k < max - printed_len; k++) 1315 putc (' ', rl_outstream); 1316 } 1317 l += count; 1318 } 1319 rl_crlf (); 1320 lines++; 1321 if (_rl_page_completions && lines >= (_rl_screenheight - 1) && i < count) 1322 { 1323 lines = _rl_internal_pager (lines); 1324 if (lines < 0) 1325 return; 1326 } 1327 } 1328 } 1329 else 1330 { 1331 /* Print the sorted items, across alphabetically, like ls -x. */ 1332 for (i = 1; matches[i]; i++) 1333 { 1334 temp = printable_part (matches[i]); 1335 printed_len = print_filename (temp, matches[i]); 1336 /* Have we reached the end of this line? */ 1337 if (matches[i+1]) 1338 { 1339 if (i && (limit > 1) && (i % limit) == 0) 1340 { 1341 rl_crlf (); 1342 lines++; 1343 if (_rl_page_completions && lines >= _rl_screenheight - 1) 1344 { 1345 lines = _rl_internal_pager (lines); 1346 if (lines < 0) 1347 return; 1348 } 1349 } 1350 else 1351 for (k = 0; k < max - printed_len; k++) 1352 putc (' ', rl_outstream); 1353 } 1354 } 1355 rl_crlf (); 1356 } 1357} 1358 1359/* Display MATCHES, a list of matching filenames in argv format. This 1360 handles the simple case -- a single match -- first. If there is more 1361 than one match, we compute the number of strings in the list and the 1362 length of the longest string, which will be needed by the display 1363 function. If the application wants to handle displaying the list of 1364 matches itself, it sets RL_COMPLETION_DISPLAY_MATCHES_HOOK to the 1365 address of a function, and we just call it. If we're handling the 1366 display ourselves, we just call rl_display_match_list. We also check 1367 that the list of matches doesn't exceed the user-settable threshold, 1368 and ask the user if he wants to see the list if there are more matches 1369 than RL_COMPLETION_QUERY_ITEMS. */ 1370static void 1371display_matches (matches) 1372 char **matches; 1373{ 1374 int len, max, i; 1375 char *temp; 1376 1377 /* Move to the last visible line of a possibly-multiple-line command. */ 1378 _rl_move_vert (_rl_vis_botlin); 1379 1380 /* Handle simple case first. What if there is only one answer? */ 1381 if (matches[1] == 0) 1382 { 1383 temp = printable_part (matches[0]); 1384 rl_crlf (); 1385 print_filename (temp, matches[0]); 1386 rl_crlf (); 1387 1388 rl_forced_update_display (); 1389 rl_display_fixed = 1; 1390 1391 return; 1392 } 1393 1394 /* There is more than one answer. Find out how many there are, 1395 and find the maximum printed length of a single entry. */ 1396 for (max = 0, i = 1; matches[i]; i++) 1397 { 1398 temp = printable_part (matches[i]); 1399 len = fnwidth (temp); 1400 1401 if (len > max) 1402 max = len; 1403 } 1404 1405 len = i - 1; 1406 1407 /* If the caller has defined a display hook, then call that now. */ 1408 if (rl_completion_display_matches_hook) 1409 { 1410 (*rl_completion_display_matches_hook) (matches, len, max); 1411 return; 1412 } 1413 1414 /* If there are many items, then ask the user if she really wants to 1415 see them all. */
|
1402 if (len >= rl_completion_query_items)
| 1416 if (rl_completion_query_items > 0 && len >= rl_completion_query_items)
|
1403 { 1404 rl_crlf (); 1405 fprintf (rl_outstream, "Display all %d possibilities? (y or n)", len); 1406 fflush (rl_outstream); 1407 if (get_y_or_n (0) == 0) 1408 { 1409 rl_crlf (); 1410 1411 rl_forced_update_display (); 1412 rl_display_fixed = 1; 1413 1414 return; 1415 } 1416 } 1417 1418 rl_display_match_list (matches, len, max); 1419 1420 rl_forced_update_display (); 1421 rl_display_fixed = 1; 1422} 1423 1424static char * 1425make_quoted_replacement (match, mtype, qc) 1426 char *match; 1427 int mtype; 1428 char *qc; /* Pointer to quoting character, if any */ 1429{ 1430 int should_quote, do_replace; 1431 char *replacement; 1432 1433 /* If we are doing completion on quoted substrings, and any matches 1434 contain any of the completer_word_break_characters, then auto- 1435 matically prepend the substring with a quote character (just pick 1436 the first one from the list of such) if it does not already begin 1437 with a quote string. FIXME: Need to remove any such automatically 1438 inserted quote character when it no longer is necessary, such as 1439 if we change the string we are completing on and the new set of 1440 matches don't require a quoted substring. */ 1441 replacement = match; 1442 1443 should_quote = match && rl_completer_quote_characters && 1444 rl_filename_completion_desired && 1445 rl_filename_quoting_desired; 1446 1447 if (should_quote) 1448 should_quote = should_quote && (!qc || !*qc || 1449 (rl_completer_quote_characters && strchr (rl_completer_quote_characters, *qc))); 1450 1451 if (should_quote) 1452 { 1453 /* If there is a single match, see if we need to quote it. 1454 This also checks whether the common prefix of several 1455 matches needs to be quoted. */ 1456 should_quote = rl_filename_quote_characters 1457 ? (_rl_strpbrk (match, rl_filename_quote_characters) != 0) 1458 : 0; 1459 1460 do_replace = should_quote ? mtype : NO_MATCH; 1461 /* Quote the replacement, since we found an embedded 1462 word break character in a potential match. */ 1463 if (do_replace != NO_MATCH && rl_filename_quoting_function) 1464 replacement = (*rl_filename_quoting_function) (match, do_replace, qc); 1465 } 1466 return (replacement); 1467} 1468 1469static void 1470insert_match (match, start, mtype, qc) 1471 char *match; 1472 int start, mtype; 1473 char *qc; 1474{ 1475 char *replacement; 1476 char oqc; 1477 1478 oqc = qc ? *qc : '\0'; 1479 replacement = make_quoted_replacement (match, mtype, qc); 1480 1481 /* Now insert the match. */ 1482 if (replacement) 1483 { 1484 /* Don't double an opening quote character. */ 1485 if (qc && *qc && start && rl_line_buffer[start - 1] == *qc && 1486 replacement[0] == *qc) 1487 start--; 1488 /* If make_quoted_replacement changed the quoting character, remove 1489 the opening quote and insert the (fully-quoted) replacement. */ 1490 else if (qc && (*qc != oqc) && start && rl_line_buffer[start - 1] == oqc && 1491 replacement[0] != oqc) 1492 start--; 1493 _rl_replace_text (replacement, start, rl_point - 1); 1494 if (replacement != match) 1495 free (replacement); 1496 } 1497} 1498 1499/* Append any necessary closing quote and a separator character to the 1500 just-inserted match. If the user has specified that directories 1501 should be marked by a trailing `/', append one of those instead. The 1502 default trailing character is a space. Returns the number of characters 1503 appended. If NONTRIVIAL_MATCH is set, we test for a symlink (if the OS 1504 has them) and don't add a suffix for a symlink to a directory. A 1505 nontrivial match is one that actually adds to the word being completed. 1506 The variable rl_completion_mark_symlink_dirs controls this behavior 1507 (it's initially set to the what the user has chosen, indicated by the 1508 value of _rl_complete_mark_symlink_dirs, but may be modified by an 1509 application's completion function). */ 1510static int 1511append_to_match (text, delimiter, quote_char, nontrivial_match) 1512 char *text; 1513 int delimiter, quote_char, nontrivial_match; 1514{ 1515 char temp_string[4], *filename; 1516 int temp_string_index, s; 1517 struct stat finfo; 1518 1519 temp_string_index = 0; 1520 if (quote_char && rl_point && rl_completion_suppress_quote == 0 && 1521 rl_line_buffer[rl_point - 1] != quote_char) 1522 temp_string[temp_string_index++] = quote_char; 1523 1524 if (delimiter) 1525 temp_string[temp_string_index++] = delimiter; 1526 else if (rl_completion_suppress_append == 0 && rl_completion_append_character) 1527 temp_string[temp_string_index++] = rl_completion_append_character; 1528 1529 temp_string[temp_string_index++] = '\0'; 1530 1531 if (rl_filename_completion_desired) 1532 { 1533 filename = tilde_expand (text); 1534 s = (nontrivial_match && rl_completion_mark_symlink_dirs == 0) 1535 ? LSTAT (filename, &finfo) 1536 : stat (filename, &finfo); 1537 if (s == 0 && S_ISDIR (finfo.st_mode)) 1538 {
| 1417 { 1418 rl_crlf (); 1419 fprintf (rl_outstream, "Display all %d possibilities? (y or n)", len); 1420 fflush (rl_outstream); 1421 if (get_y_or_n (0) == 0) 1422 { 1423 rl_crlf (); 1424 1425 rl_forced_update_display (); 1426 rl_display_fixed = 1; 1427 1428 return; 1429 } 1430 } 1431 1432 rl_display_match_list (matches, len, max); 1433 1434 rl_forced_update_display (); 1435 rl_display_fixed = 1; 1436} 1437 1438static char * 1439make_quoted_replacement (match, mtype, qc) 1440 char *match; 1441 int mtype; 1442 char *qc; /* Pointer to quoting character, if any */ 1443{ 1444 int should_quote, do_replace; 1445 char *replacement; 1446 1447 /* If we are doing completion on quoted substrings, and any matches 1448 contain any of the completer_word_break_characters, then auto- 1449 matically prepend the substring with a quote character (just pick 1450 the first one from the list of such) if it does not already begin 1451 with a quote string. FIXME: Need to remove any such automatically 1452 inserted quote character when it no longer is necessary, such as 1453 if we change the string we are completing on and the new set of 1454 matches don't require a quoted substring. */ 1455 replacement = match; 1456 1457 should_quote = match && rl_completer_quote_characters && 1458 rl_filename_completion_desired && 1459 rl_filename_quoting_desired; 1460 1461 if (should_quote) 1462 should_quote = should_quote && (!qc || !*qc || 1463 (rl_completer_quote_characters && strchr (rl_completer_quote_characters, *qc))); 1464 1465 if (should_quote) 1466 { 1467 /* If there is a single match, see if we need to quote it. 1468 This also checks whether the common prefix of several 1469 matches needs to be quoted. */ 1470 should_quote = rl_filename_quote_characters 1471 ? (_rl_strpbrk (match, rl_filename_quote_characters) != 0) 1472 : 0; 1473 1474 do_replace = should_quote ? mtype : NO_MATCH; 1475 /* Quote the replacement, since we found an embedded 1476 word break character in a potential match. */ 1477 if (do_replace != NO_MATCH && rl_filename_quoting_function) 1478 replacement = (*rl_filename_quoting_function) (match, do_replace, qc); 1479 } 1480 return (replacement); 1481} 1482 1483static void 1484insert_match (match, start, mtype, qc) 1485 char *match; 1486 int start, mtype; 1487 char *qc; 1488{ 1489 char *replacement; 1490 char oqc; 1491 1492 oqc = qc ? *qc : '\0'; 1493 replacement = make_quoted_replacement (match, mtype, qc); 1494 1495 /* Now insert the match. */ 1496 if (replacement) 1497 { 1498 /* Don't double an opening quote character. */ 1499 if (qc && *qc && start && rl_line_buffer[start - 1] == *qc && 1500 replacement[0] == *qc) 1501 start--; 1502 /* If make_quoted_replacement changed the quoting character, remove 1503 the opening quote and insert the (fully-quoted) replacement. */ 1504 else if (qc && (*qc != oqc) && start && rl_line_buffer[start - 1] == oqc && 1505 replacement[0] != oqc) 1506 start--; 1507 _rl_replace_text (replacement, start, rl_point - 1); 1508 if (replacement != match) 1509 free (replacement); 1510 } 1511} 1512 1513/* Append any necessary closing quote and a separator character to the 1514 just-inserted match. If the user has specified that directories 1515 should be marked by a trailing `/', append one of those instead. The 1516 default trailing character is a space. Returns the number of characters 1517 appended. If NONTRIVIAL_MATCH is set, we test for a symlink (if the OS 1518 has them) and don't add a suffix for a symlink to a directory. A 1519 nontrivial match is one that actually adds to the word being completed. 1520 The variable rl_completion_mark_symlink_dirs controls this behavior 1521 (it's initially set to the what the user has chosen, indicated by the 1522 value of _rl_complete_mark_symlink_dirs, but may be modified by an 1523 application's completion function). */ 1524static int 1525append_to_match (text, delimiter, quote_char, nontrivial_match) 1526 char *text; 1527 int delimiter, quote_char, nontrivial_match; 1528{ 1529 char temp_string[4], *filename; 1530 int temp_string_index, s; 1531 struct stat finfo; 1532 1533 temp_string_index = 0; 1534 if (quote_char && rl_point && rl_completion_suppress_quote == 0 && 1535 rl_line_buffer[rl_point - 1] != quote_char) 1536 temp_string[temp_string_index++] = quote_char; 1537 1538 if (delimiter) 1539 temp_string[temp_string_index++] = delimiter; 1540 else if (rl_completion_suppress_append == 0 && rl_completion_append_character) 1541 temp_string[temp_string_index++] = rl_completion_append_character; 1542 1543 temp_string[temp_string_index++] = '\0'; 1544 1545 if (rl_filename_completion_desired) 1546 { 1547 filename = tilde_expand (text); 1548 s = (nontrivial_match && rl_completion_mark_symlink_dirs == 0) 1549 ? LSTAT (filename, &finfo) 1550 : stat (filename, &finfo); 1551 if (s == 0 && S_ISDIR (finfo.st_mode)) 1552 {
|
1539 if (_rl_complete_mark_directories)
| 1553 if (_rl_complete_mark_directories /* && rl_completion_suppress_append == 0 */)
|
1540 { 1541 /* This is clumsy. Avoid putting in a double slash if point 1542 is at the end of the line and the previous character is a 1543 slash. */ 1544 if (rl_point && rl_line_buffer[rl_point] == '\0' && rl_line_buffer[rl_point - 1] == '/') 1545 ; 1546 else if (rl_line_buffer[rl_point] != '/') 1547 rl_insert_text ("/"); 1548 } 1549 } 1550#ifdef S_ISLNK 1551 /* Don't add anything if the filename is a symlink and resolves to a 1552 directory. */ 1553 else if (s == 0 && S_ISLNK (finfo.st_mode) && 1554 stat (filename, &finfo) == 0 && S_ISDIR (finfo.st_mode)) 1555 ; 1556#endif 1557 else 1558 { 1559 if (rl_point == rl_end && temp_string_index) 1560 rl_insert_text (temp_string); 1561 } 1562 free (filename); 1563 } 1564 else 1565 { 1566 if (rl_point == rl_end && temp_string_index) 1567 rl_insert_text (temp_string); 1568 } 1569 1570 return (temp_string_index); 1571} 1572 1573static void 1574insert_all_matches (matches, point, qc) 1575 char **matches; 1576 int point; 1577 char *qc; 1578{ 1579 int i; 1580 char *rp; 1581 1582 rl_begin_undo_group (); 1583 /* remove any opening quote character; make_quoted_replacement will add 1584 it back. */ 1585 if (qc && *qc && point && rl_line_buffer[point - 1] == *qc) 1586 point--; 1587 rl_delete_text (point, rl_point); 1588 rl_point = point; 1589 1590 if (matches[1]) 1591 { 1592 for (i = 1; matches[i]; i++) 1593 { 1594 rp = make_quoted_replacement (matches[i], SINGLE_MATCH, qc); 1595 rl_insert_text (rp); 1596 rl_insert_text (" "); 1597 if (rp != matches[i]) 1598 free (rp); 1599 } 1600 } 1601 else 1602 { 1603 rp = make_quoted_replacement (matches[0], SINGLE_MATCH, qc); 1604 rl_insert_text (rp); 1605 rl_insert_text (" "); 1606 if (rp != matches[0]) 1607 free (rp); 1608 } 1609 rl_end_undo_group (); 1610} 1611 1612void 1613_rl_free_match_list (matches) 1614 char **matches; 1615{ 1616 register int i; 1617 1618 if (matches == 0) 1619 return; 1620 1621 for (i = 0; matches[i]; i++) 1622 free (matches[i]); 1623 free (matches); 1624} 1625 1626/* Complete the word at or before point. 1627 WHAT_TO_DO says what to do with the completion. 1628 `?' means list the possible completions. 1629 TAB means do standard completion. 1630 `*' means insert all of the possible completions. 1631 `!' means to do standard completion, and list all possible completions if 1632 there is more than one. 1633 `@' means to do standard completion, and list all possible completions if 1634 there is more than one and partial completion is not possible. */ 1635int 1636rl_complete_internal (what_to_do) 1637 int what_to_do; 1638{ 1639 char **matches; 1640 rl_compentry_func_t *our_func; 1641 int start, end, delimiter, found_quote, i, nontrivial_lcd; 1642 char *text, *saved_line_buffer; 1643 char quote_char; 1644 1645 RL_SETSTATE(RL_STATE_COMPLETING); 1646 1647 set_completion_defaults (what_to_do); 1648 1649 saved_line_buffer = rl_line_buffer ? savestring (rl_line_buffer) : (char *)NULL; 1650 our_func = rl_completion_entry_function 1651 ? rl_completion_entry_function 1652 : rl_filename_completion_function; 1653 /* We now look backwards for the start of a filename/variable word. */ 1654 end = rl_point; 1655 found_quote = delimiter = 0; 1656 quote_char = '\0'; 1657 1658 if (rl_point) 1659 /* This (possibly) changes rl_point. If it returns a non-zero char, 1660 we know we have an open quote. */ 1661 quote_char = _rl_find_completion_word (&found_quote, &delimiter); 1662 1663 start = rl_point; 1664 rl_point = end; 1665 1666 text = rl_copy_text (start, end); 1667 matches = gen_completion_matches (text, start, end, our_func, found_quote, quote_char); 1668 /* nontrivial_lcd is set if the common prefix adds something to the word 1669 being completed. */ 1670 nontrivial_lcd = matches && strcmp (text, matches[0]) != 0; 1671 free (text); 1672 1673 if (matches == 0) 1674 { 1675 rl_ding (); 1676 FREE (saved_line_buffer); 1677 completion_changed_buffer = 0; 1678 RL_UNSETSTATE(RL_STATE_COMPLETING); 1679 return (0); 1680 } 1681 1682 /* If we are matching filenames, the attempted completion function will 1683 have set rl_filename_completion_desired to a non-zero value. The basic 1684 rl_filename_completion_function does this. */ 1685 i = rl_filename_completion_desired; 1686 1687 if (postprocess_matches (&matches, i) == 0) 1688 { 1689 rl_ding (); 1690 FREE (saved_line_buffer); 1691 completion_changed_buffer = 0; 1692 RL_UNSETSTATE(RL_STATE_COMPLETING); 1693 return (0); 1694 } 1695 1696 switch (what_to_do) 1697 { 1698 case TAB: 1699 case '!': 1700 case '@': 1701 /* Insert the first match with proper quoting. */ 1702 if (*matches[0]) 1703 insert_match (matches[0], start, matches[1] ? MULT_MATCH : SINGLE_MATCH, "e_char); 1704 1705 /* If there are more matches, ring the bell to indicate. 1706 If we are in vi mode, Posix.2 says to not ring the bell. 1707 If the `show-all-if-ambiguous' variable is set, display 1708 all the matches immediately. Otherwise, if this was the 1709 only match, and we are hacking files, check the file to 1710 see if it was a directory. If so, and the `mark-directories' 1711 variable is set, add a '/' to the name. If not, and we 1712 are at the end of the line, then add a space. */ 1713 if (matches[1]) 1714 { 1715 if (what_to_do == '!') 1716 { 1717 display_matches (matches); 1718 break; 1719 } 1720 else if (what_to_do == '@') 1721 { 1722 if (nontrivial_lcd == 0) 1723 display_matches (matches); 1724 break; 1725 } 1726 else if (rl_editing_mode != vi_mode) 1727 rl_ding (); /* There are other matches remaining. */ 1728 } 1729 else 1730 append_to_match (matches[0], delimiter, quote_char, nontrivial_lcd); 1731 1732 break; 1733 1734 case '*': 1735 insert_all_matches (matches, start, "e_char); 1736 break; 1737 1738 case '?': 1739 display_matches (matches); 1740 break; 1741 1742 default: 1743 fprintf (stderr, "\r\nreadline: bad value %d for what_to_do in rl_complete\n", what_to_do); 1744 rl_ding (); 1745 FREE (saved_line_buffer); 1746 RL_UNSETSTATE(RL_STATE_COMPLETING); 1747 return 1; 1748 } 1749 1750 _rl_free_match_list (matches); 1751 1752 /* Check to see if the line has changed through all of this manipulation. */ 1753 if (saved_line_buffer) 1754 { 1755 completion_changed_buffer = strcmp (rl_line_buffer, saved_line_buffer) != 0; 1756 free (saved_line_buffer); 1757 } 1758 1759 RL_UNSETSTATE(RL_STATE_COMPLETING); 1760 return 0; 1761} 1762 1763/***************************************************************/ 1764/* */ 1765/* Application-callable completion match generator functions */ 1766/* */ 1767/***************************************************************/ 1768 1769/* Return an array of (char *) which is a list of completions for TEXT. 1770 If there are no completions, return a NULL pointer. 1771 The first entry in the returned array is the substitution for TEXT. 1772 The remaining entries are the possible completions. 1773 The array is terminated with a NULL pointer. 1774 1775 ENTRY_FUNCTION is a function of two args, and returns a (char *). 1776 The first argument is TEXT. 1777 The second is a state argument; it should be zero on the first call, and 1778 non-zero on subsequent calls. It returns a NULL pointer to the caller 1779 when there are no more matches. 1780 */ 1781char ** 1782rl_completion_matches (text, entry_function) 1783 const char *text; 1784 rl_compentry_func_t *entry_function; 1785{ 1786 /* Number of slots in match_list. */ 1787 int match_list_size; 1788 1789 /* The list of matches. */ 1790 char **match_list; 1791 1792 /* Number of matches actually found. */ 1793 int matches; 1794 1795 /* Temporary string binder. */ 1796 char *string; 1797 1798 matches = 0; 1799 match_list_size = 10; 1800 match_list = (char **)xmalloc ((match_list_size + 1) * sizeof (char *)); 1801 match_list[1] = (char *)NULL; 1802 1803 while (string = (*entry_function) (text, matches)) 1804 { 1805 if (matches + 1 == match_list_size) 1806 match_list = (char **)xrealloc 1807 (match_list, ((match_list_size += 10) + 1) * sizeof (char *)); 1808 1809 match_list[++matches] = string; 1810 match_list[matches + 1] = (char *)NULL; 1811 } 1812 1813 /* If there were any matches, then look through them finding out the 1814 lowest common denominator. That then becomes match_list[0]. */ 1815 if (matches) 1816 compute_lcd_of_matches (match_list, matches, text); 1817 else /* There were no matches. */ 1818 { 1819 free (match_list); 1820 match_list = (char **)NULL; 1821 } 1822 return (match_list); 1823} 1824 1825/* A completion function for usernames. 1826 TEXT contains a partial username preceded by a random 1827 character (usually `~'). */ 1828char * 1829rl_username_completion_function (text, state) 1830 const char *text; 1831 int state; 1832{ 1833#if defined (__WIN32__) || defined (__OPENNT) 1834 return (char *)NULL; 1835#else /* !__WIN32__ && !__OPENNT) */ 1836 static char *username = (char *)NULL; 1837 static struct passwd *entry; 1838 static int namelen, first_char, first_char_loc; 1839 char *value; 1840 1841 if (state == 0) 1842 { 1843 FREE (username); 1844 1845 first_char = *text; 1846 first_char_loc = first_char == '~'; 1847 1848 username = savestring (&text[first_char_loc]); 1849 namelen = strlen (username); 1850 setpwent (); 1851 } 1852
| 1554 { 1555 /* This is clumsy. Avoid putting in a double slash if point 1556 is at the end of the line and the previous character is a 1557 slash. */ 1558 if (rl_point && rl_line_buffer[rl_point] == '\0' && rl_line_buffer[rl_point - 1] == '/') 1559 ; 1560 else if (rl_line_buffer[rl_point] != '/') 1561 rl_insert_text ("/"); 1562 } 1563 } 1564#ifdef S_ISLNK 1565 /* Don't add anything if the filename is a symlink and resolves to a 1566 directory. */ 1567 else if (s == 0 && S_ISLNK (finfo.st_mode) && 1568 stat (filename, &finfo) == 0 && S_ISDIR (finfo.st_mode)) 1569 ; 1570#endif 1571 else 1572 { 1573 if (rl_point == rl_end && temp_string_index) 1574 rl_insert_text (temp_string); 1575 } 1576 free (filename); 1577 } 1578 else 1579 { 1580 if (rl_point == rl_end && temp_string_index) 1581 rl_insert_text (temp_string); 1582 } 1583 1584 return (temp_string_index); 1585} 1586 1587static void 1588insert_all_matches (matches, point, qc) 1589 char **matches; 1590 int point; 1591 char *qc; 1592{ 1593 int i; 1594 char *rp; 1595 1596 rl_begin_undo_group (); 1597 /* remove any opening quote character; make_quoted_replacement will add 1598 it back. */ 1599 if (qc && *qc && point && rl_line_buffer[point - 1] == *qc) 1600 point--; 1601 rl_delete_text (point, rl_point); 1602 rl_point = point; 1603 1604 if (matches[1]) 1605 { 1606 for (i = 1; matches[i]; i++) 1607 { 1608 rp = make_quoted_replacement (matches[i], SINGLE_MATCH, qc); 1609 rl_insert_text (rp); 1610 rl_insert_text (" "); 1611 if (rp != matches[i]) 1612 free (rp); 1613 } 1614 } 1615 else 1616 { 1617 rp = make_quoted_replacement (matches[0], SINGLE_MATCH, qc); 1618 rl_insert_text (rp); 1619 rl_insert_text (" "); 1620 if (rp != matches[0]) 1621 free (rp); 1622 } 1623 rl_end_undo_group (); 1624} 1625 1626void 1627_rl_free_match_list (matches) 1628 char **matches; 1629{ 1630 register int i; 1631 1632 if (matches == 0) 1633 return; 1634 1635 for (i = 0; matches[i]; i++) 1636 free (matches[i]); 1637 free (matches); 1638} 1639 1640/* Complete the word at or before point. 1641 WHAT_TO_DO says what to do with the completion. 1642 `?' means list the possible completions. 1643 TAB means do standard completion. 1644 `*' means insert all of the possible completions. 1645 `!' means to do standard completion, and list all possible completions if 1646 there is more than one. 1647 `@' means to do standard completion, and list all possible completions if 1648 there is more than one and partial completion is not possible. */ 1649int 1650rl_complete_internal (what_to_do) 1651 int what_to_do; 1652{ 1653 char **matches; 1654 rl_compentry_func_t *our_func; 1655 int start, end, delimiter, found_quote, i, nontrivial_lcd; 1656 char *text, *saved_line_buffer; 1657 char quote_char; 1658 1659 RL_SETSTATE(RL_STATE_COMPLETING); 1660 1661 set_completion_defaults (what_to_do); 1662 1663 saved_line_buffer = rl_line_buffer ? savestring (rl_line_buffer) : (char *)NULL; 1664 our_func = rl_completion_entry_function 1665 ? rl_completion_entry_function 1666 : rl_filename_completion_function; 1667 /* We now look backwards for the start of a filename/variable word. */ 1668 end = rl_point; 1669 found_quote = delimiter = 0; 1670 quote_char = '\0'; 1671 1672 if (rl_point) 1673 /* This (possibly) changes rl_point. If it returns a non-zero char, 1674 we know we have an open quote. */ 1675 quote_char = _rl_find_completion_word (&found_quote, &delimiter); 1676 1677 start = rl_point; 1678 rl_point = end; 1679 1680 text = rl_copy_text (start, end); 1681 matches = gen_completion_matches (text, start, end, our_func, found_quote, quote_char); 1682 /* nontrivial_lcd is set if the common prefix adds something to the word 1683 being completed. */ 1684 nontrivial_lcd = matches && strcmp (text, matches[0]) != 0; 1685 free (text); 1686 1687 if (matches == 0) 1688 { 1689 rl_ding (); 1690 FREE (saved_line_buffer); 1691 completion_changed_buffer = 0; 1692 RL_UNSETSTATE(RL_STATE_COMPLETING); 1693 return (0); 1694 } 1695 1696 /* If we are matching filenames, the attempted completion function will 1697 have set rl_filename_completion_desired to a non-zero value. The basic 1698 rl_filename_completion_function does this. */ 1699 i = rl_filename_completion_desired; 1700 1701 if (postprocess_matches (&matches, i) == 0) 1702 { 1703 rl_ding (); 1704 FREE (saved_line_buffer); 1705 completion_changed_buffer = 0; 1706 RL_UNSETSTATE(RL_STATE_COMPLETING); 1707 return (0); 1708 } 1709 1710 switch (what_to_do) 1711 { 1712 case TAB: 1713 case '!': 1714 case '@': 1715 /* Insert the first match with proper quoting. */ 1716 if (*matches[0]) 1717 insert_match (matches[0], start, matches[1] ? MULT_MATCH : SINGLE_MATCH, "e_char); 1718 1719 /* If there are more matches, ring the bell to indicate. 1720 If we are in vi mode, Posix.2 says to not ring the bell. 1721 If the `show-all-if-ambiguous' variable is set, display 1722 all the matches immediately. Otherwise, if this was the 1723 only match, and we are hacking files, check the file to 1724 see if it was a directory. If so, and the `mark-directories' 1725 variable is set, add a '/' to the name. If not, and we 1726 are at the end of the line, then add a space. */ 1727 if (matches[1]) 1728 { 1729 if (what_to_do == '!') 1730 { 1731 display_matches (matches); 1732 break; 1733 } 1734 else if (what_to_do == '@') 1735 { 1736 if (nontrivial_lcd == 0) 1737 display_matches (matches); 1738 break; 1739 } 1740 else if (rl_editing_mode != vi_mode) 1741 rl_ding (); /* There are other matches remaining. */ 1742 } 1743 else 1744 append_to_match (matches[0], delimiter, quote_char, nontrivial_lcd); 1745 1746 break; 1747 1748 case '*': 1749 insert_all_matches (matches, start, "e_char); 1750 break; 1751 1752 case '?': 1753 display_matches (matches); 1754 break; 1755 1756 default: 1757 fprintf (stderr, "\r\nreadline: bad value %d for what_to_do in rl_complete\n", what_to_do); 1758 rl_ding (); 1759 FREE (saved_line_buffer); 1760 RL_UNSETSTATE(RL_STATE_COMPLETING); 1761 return 1; 1762 } 1763 1764 _rl_free_match_list (matches); 1765 1766 /* Check to see if the line has changed through all of this manipulation. */ 1767 if (saved_line_buffer) 1768 { 1769 completion_changed_buffer = strcmp (rl_line_buffer, saved_line_buffer) != 0; 1770 free (saved_line_buffer); 1771 } 1772 1773 RL_UNSETSTATE(RL_STATE_COMPLETING); 1774 return 0; 1775} 1776 1777/***************************************************************/ 1778/* */ 1779/* Application-callable completion match generator functions */ 1780/* */ 1781/***************************************************************/ 1782 1783/* Return an array of (char *) which is a list of completions for TEXT. 1784 If there are no completions, return a NULL pointer. 1785 The first entry in the returned array is the substitution for TEXT. 1786 The remaining entries are the possible completions. 1787 The array is terminated with a NULL pointer. 1788 1789 ENTRY_FUNCTION is a function of two args, and returns a (char *). 1790 The first argument is TEXT. 1791 The second is a state argument; it should be zero on the first call, and 1792 non-zero on subsequent calls. It returns a NULL pointer to the caller 1793 when there are no more matches. 1794 */ 1795char ** 1796rl_completion_matches (text, entry_function) 1797 const char *text; 1798 rl_compentry_func_t *entry_function; 1799{ 1800 /* Number of slots in match_list. */ 1801 int match_list_size; 1802 1803 /* The list of matches. */ 1804 char **match_list; 1805 1806 /* Number of matches actually found. */ 1807 int matches; 1808 1809 /* Temporary string binder. */ 1810 char *string; 1811 1812 matches = 0; 1813 match_list_size = 10; 1814 match_list = (char **)xmalloc ((match_list_size + 1) * sizeof (char *)); 1815 match_list[1] = (char *)NULL; 1816 1817 while (string = (*entry_function) (text, matches)) 1818 { 1819 if (matches + 1 == match_list_size) 1820 match_list = (char **)xrealloc 1821 (match_list, ((match_list_size += 10) + 1) * sizeof (char *)); 1822 1823 match_list[++matches] = string; 1824 match_list[matches + 1] = (char *)NULL; 1825 } 1826 1827 /* If there were any matches, then look through them finding out the 1828 lowest common denominator. That then becomes match_list[0]. */ 1829 if (matches) 1830 compute_lcd_of_matches (match_list, matches, text); 1831 else /* There were no matches. */ 1832 { 1833 free (match_list); 1834 match_list = (char **)NULL; 1835 } 1836 return (match_list); 1837} 1838 1839/* A completion function for usernames. 1840 TEXT contains a partial username preceded by a random 1841 character (usually `~'). */ 1842char * 1843rl_username_completion_function (text, state) 1844 const char *text; 1845 int state; 1846{ 1847#if defined (__WIN32__) || defined (__OPENNT) 1848 return (char *)NULL; 1849#else /* !__WIN32__ && !__OPENNT) */ 1850 static char *username = (char *)NULL; 1851 static struct passwd *entry; 1852 static int namelen, first_char, first_char_loc; 1853 char *value; 1854 1855 if (state == 0) 1856 { 1857 FREE (username); 1858 1859 first_char = *text; 1860 first_char_loc = first_char == '~'; 1861 1862 username = savestring (&text[first_char_loc]); 1863 namelen = strlen (username); 1864 setpwent (); 1865 } 1866
|
| 1867#if defined (HAVE_GETPWENT)
|
1853 while (entry = getpwent ()) 1854 { 1855 /* Null usernames should result in all users as possible completions. */ 1856 if (namelen == 0 || (STREQN (username, entry->pw_name, namelen))) 1857 break; 1858 }
| 1868 while (entry = getpwent ()) 1869 { 1870 /* Null usernames should result in all users as possible completions. */ 1871 if (namelen == 0 || (STREQN (username, entry->pw_name, namelen))) 1872 break; 1873 }
|
| 1874#endif
|
1859 1860 if (entry == 0) 1861 {
| 1875 1876 if (entry == 0) 1877 {
|
| 1878#if defined (HAVE_GETPWENT)
|
1862 endpwent ();
| 1879 endpwent ();
|
| 1880#endif
|
1863 return ((char *)NULL); 1864 } 1865 else 1866 { 1867 value = (char *)xmalloc (2 + strlen (entry->pw_name)); 1868 1869 *value = *text; 1870 1871 strcpy (value + first_char_loc, entry->pw_name); 1872 1873 if (first_char == '~') 1874 rl_filename_completion_desired = 1; 1875 1876 return (value); 1877 } 1878#endif /* !__WIN32__ && !__OPENNT */ 1879} 1880 1881/* Okay, now we write the entry_function for filename completion. In the 1882 general case. Note that completion in the shell is a little different 1883 because of all the pathnames that must be followed when looking up the 1884 completion for a command. */ 1885char * 1886rl_filename_completion_function (text, state) 1887 const char *text; 1888 int state; 1889{ 1890 static DIR *directory = (DIR *)NULL; 1891 static char *filename = (char *)NULL; 1892 static char *dirname = (char *)NULL; 1893 static char *users_dirname = (char *)NULL; 1894 static int filename_len; 1895 char *temp; 1896 int dirlen; 1897 struct dirent *entry; 1898 1899 /* If we don't have any state, then do some initialization. */ 1900 if (state == 0) 1901 { 1902 /* If we were interrupted before closing the directory or reading 1903 all of its contents, close it. */ 1904 if (directory) 1905 { 1906 closedir (directory); 1907 directory = (DIR *)NULL; 1908 } 1909 FREE (dirname); 1910 FREE (filename); 1911 FREE (users_dirname); 1912 1913 filename = savestring (text); 1914 if (*text == 0) 1915 text = "."; 1916 dirname = savestring (text); 1917 1918 temp = strrchr (dirname, '/'); 1919 1920#if defined (__MSDOS__) 1921 /* special hack for //X/... */ 1922 if (dirname[0] == '/' && dirname[1] == '/' && ISALPHA ((unsigned char)dirname[2]) && dirname[3] == '/') 1923 temp = strrchr (dirname + 3, '/'); 1924#endif 1925 1926 if (temp) 1927 { 1928 strcpy (filename, ++temp); 1929 *temp = '\0'; 1930 } 1931#if defined (__MSDOS__) 1932 /* searches from current directory on the drive */ 1933 else if (ISALPHA ((unsigned char)dirname[0]) && dirname[1] == ':') 1934 { 1935 strcpy (filename, dirname + 2); 1936 dirname[2] = '\0'; 1937 } 1938#endif 1939 else 1940 { 1941 dirname[0] = '.'; 1942 dirname[1] = '\0'; 1943 } 1944 1945 /* We aren't done yet. We also support the "~user" syntax. */ 1946 1947 /* Save the version of the directory that the user typed. */ 1948 users_dirname = savestring (dirname); 1949 1950 if (*dirname == '~') 1951 { 1952 temp = tilde_expand (dirname); 1953 free (dirname); 1954 dirname = temp; 1955 } 1956 1957 if (rl_directory_rewrite_hook) 1958 (*rl_directory_rewrite_hook) (&dirname); 1959 1960 if (rl_directory_completion_hook && (*rl_directory_completion_hook) (&dirname)) 1961 { 1962 free (users_dirname); 1963 users_dirname = savestring (dirname); 1964 } 1965 1966 directory = opendir (dirname); 1967 filename_len = strlen (filename); 1968 1969 rl_filename_completion_desired = 1; 1970 } 1971 1972 /* At this point we should entertain the possibility of hacking wildcarded 1973 filenames, like /usr/man/man<WILD>/te<TAB>. If the directory name 1974 contains globbing characters, then build an array of directories, and 1975 then map over that list while completing. */ 1976 /* *** UNIMPLEMENTED *** */ 1977 1978 /* Now that we have some state, we can read the directory. */ 1979 1980 entry = (struct dirent *)NULL; 1981 while (directory && (entry = readdir (directory))) 1982 { 1983 /* Special case for no filename. If the user has disabled the 1984 `match-hidden-files' variable, skip filenames beginning with `.'. 1985 All other entries except "." and ".." match. */ 1986 if (filename_len == 0) 1987 { 1988 if (_rl_match_hidden_files == 0 && HIDDEN_FILE (entry->d_name)) 1989 continue; 1990 1991 if (entry->d_name[0] != '.' || 1992 (entry->d_name[1] && 1993 (entry->d_name[1] != '.' || entry->d_name[2]))) 1994 break; 1995 } 1996 else 1997 { 1998 /* Otherwise, if these match up to the length of filename, then 1999 it is a match. */ 2000 if (_rl_completion_case_fold) 2001 { 2002 if ((_rl_to_lower (entry->d_name[0]) == _rl_to_lower (filename[0])) && 2003 (((int)D_NAMLEN (entry)) >= filename_len) && 2004 (_rl_strnicmp (filename, entry->d_name, filename_len) == 0)) 2005 break; 2006 } 2007 else 2008 { 2009 if ((entry->d_name[0] == filename[0]) && 2010 (((int)D_NAMLEN (entry)) >= filename_len) && 2011 (strncmp (filename, entry->d_name, filename_len) == 0)) 2012 break; 2013 } 2014 } 2015 } 2016 2017 if (entry == 0) 2018 { 2019 if (directory) 2020 { 2021 closedir (directory); 2022 directory = (DIR *)NULL; 2023 } 2024 if (dirname) 2025 { 2026 free (dirname); 2027 dirname = (char *)NULL; 2028 } 2029 if (filename) 2030 { 2031 free (filename); 2032 filename = (char *)NULL; 2033 } 2034 if (users_dirname) 2035 { 2036 free (users_dirname); 2037 users_dirname = (char *)NULL; 2038 } 2039 2040 return (char *)NULL; 2041 } 2042 else 2043 { 2044 /* dirname && (strcmp (dirname, ".") != 0) */ 2045 if (dirname && (dirname[0] != '.' || dirname[1])) 2046 { 2047 if (rl_complete_with_tilde_expansion && *users_dirname == '~') 2048 { 2049 dirlen = strlen (dirname); 2050 temp = (char *)xmalloc (2 + dirlen + D_NAMLEN (entry)); 2051 strcpy (temp, dirname); 2052 /* Canonicalization cuts off any final slash present. We 2053 may need to add it back. */ 2054 if (dirname[dirlen - 1] != '/') 2055 { 2056 temp[dirlen++] = '/'; 2057 temp[dirlen] = '\0'; 2058 } 2059 } 2060 else 2061 { 2062 dirlen = strlen (users_dirname); 2063 temp = (char *)xmalloc (2 + dirlen + D_NAMLEN (entry)); 2064 strcpy (temp, users_dirname); 2065 /* Make sure that temp has a trailing slash here. */ 2066 if (users_dirname[dirlen - 1] != '/') 2067 temp[dirlen++] = '/'; 2068 } 2069 2070 strcpy (temp + dirlen, entry->d_name); 2071 } 2072 else 2073 temp = savestring (entry->d_name); 2074 2075 return (temp); 2076 } 2077} 2078 2079/* An initial implementation of a menu completion function a la tcsh. The 2080 first time (if the last readline command was not rl_menu_complete), we 2081 generate the list of matches. This code is very similar to the code in 2082 rl_complete_internal -- there should be a way to combine the two. Then, 2083 for each item in the list of matches, we insert the match in an undoable 2084 fashion, with the appropriate character appended (this happens on the 2085 second and subsequent consecutive calls to rl_menu_complete). When we 2086 hit the end of the match list, we restore the original unmatched text, 2087 ring the bell, and reset the counter to zero. */ 2088int 2089rl_menu_complete (count, ignore) 2090 int count, ignore; 2091{ 2092 rl_compentry_func_t *our_func; 2093 int matching_filenames, found_quote; 2094 2095 static char *orig_text; 2096 static char **matches = (char **)0; 2097 static int match_list_index = 0; 2098 static int match_list_size = 0; 2099 static int orig_start, orig_end; 2100 static char quote_char; 2101 static int delimiter; 2102 2103 /* The first time through, we generate the list of matches and set things 2104 up to insert them. */ 2105 if (rl_last_func != rl_menu_complete) 2106 { 2107 /* Clean up from previous call, if any. */ 2108 FREE (orig_text); 2109 if (matches) 2110 _rl_free_match_list (matches); 2111 2112 match_list_index = match_list_size = 0; 2113 matches = (char **)NULL; 2114 2115 /* Only the completion entry function can change these. */ 2116 set_completion_defaults ('%'); 2117 2118 our_func = rl_completion_entry_function 2119 ? rl_completion_entry_function 2120 : rl_filename_completion_function; 2121 2122 /* We now look backwards for the start of a filename/variable word. */ 2123 orig_end = rl_point; 2124 found_quote = delimiter = 0; 2125 quote_char = '\0'; 2126 2127 if (rl_point) 2128 /* This (possibly) changes rl_point. If it returns a non-zero char, 2129 we know we have an open quote. */ 2130 quote_char = _rl_find_completion_word (&found_quote, &delimiter); 2131 2132 orig_start = rl_point; 2133 rl_point = orig_end; 2134 2135 orig_text = rl_copy_text (orig_start, orig_end); 2136 matches = gen_completion_matches (orig_text, orig_start, orig_end, 2137 our_func, found_quote, quote_char); 2138 2139 /* If we are matching filenames, the attempted completion function will 2140 have set rl_filename_completion_desired to a non-zero value. The basic 2141 rl_filename_completion_function does this. */ 2142 matching_filenames = rl_filename_completion_desired; 2143 2144 if (matches == 0 || postprocess_matches (&matches, matching_filenames) == 0) 2145 { 2146 rl_ding (); 2147 FREE (matches); 2148 matches = (char **)0; 2149 FREE (orig_text); 2150 orig_text = (char *)0; 2151 completion_changed_buffer = 0; 2152 return (0); 2153 } 2154 2155 for (match_list_size = 0; matches[match_list_size]; match_list_size++) 2156 ; 2157 /* matches[0] is lcd if match_list_size > 1, but the circular buffer 2158 code below should take care of it. */ 2159 } 2160 2161 /* Now we have the list of matches. Replace the text between 2162 rl_line_buffer[orig_start] and rl_line_buffer[rl_point] with 2163 matches[match_list_index], and add any necessary closing char. */ 2164 2165 if (matches == 0 || match_list_size == 0) 2166 { 2167 rl_ding (); 2168 FREE (matches); 2169 matches = (char **)0; 2170 completion_changed_buffer = 0; 2171 return (0); 2172 } 2173
| 1881 return ((char *)NULL); 1882 } 1883 else 1884 { 1885 value = (char *)xmalloc (2 + strlen (entry->pw_name)); 1886 1887 *value = *text; 1888 1889 strcpy (value + first_char_loc, entry->pw_name); 1890 1891 if (first_char == '~') 1892 rl_filename_completion_desired = 1; 1893 1894 return (value); 1895 } 1896#endif /* !__WIN32__ && !__OPENNT */ 1897} 1898 1899/* Okay, now we write the entry_function for filename completion. In the 1900 general case. Note that completion in the shell is a little different 1901 because of all the pathnames that must be followed when looking up the 1902 completion for a command. */ 1903char * 1904rl_filename_completion_function (text, state) 1905 const char *text; 1906 int state; 1907{ 1908 static DIR *directory = (DIR *)NULL; 1909 static char *filename = (char *)NULL; 1910 static char *dirname = (char *)NULL; 1911 static char *users_dirname = (char *)NULL; 1912 static int filename_len; 1913 char *temp; 1914 int dirlen; 1915 struct dirent *entry; 1916 1917 /* If we don't have any state, then do some initialization. */ 1918 if (state == 0) 1919 { 1920 /* If we were interrupted before closing the directory or reading 1921 all of its contents, close it. */ 1922 if (directory) 1923 { 1924 closedir (directory); 1925 directory = (DIR *)NULL; 1926 } 1927 FREE (dirname); 1928 FREE (filename); 1929 FREE (users_dirname); 1930 1931 filename = savestring (text); 1932 if (*text == 0) 1933 text = "."; 1934 dirname = savestring (text); 1935 1936 temp = strrchr (dirname, '/'); 1937 1938#if defined (__MSDOS__) 1939 /* special hack for //X/... */ 1940 if (dirname[0] == '/' && dirname[1] == '/' && ISALPHA ((unsigned char)dirname[2]) && dirname[3] == '/') 1941 temp = strrchr (dirname + 3, '/'); 1942#endif 1943 1944 if (temp) 1945 { 1946 strcpy (filename, ++temp); 1947 *temp = '\0'; 1948 } 1949#if defined (__MSDOS__) 1950 /* searches from current directory on the drive */ 1951 else if (ISALPHA ((unsigned char)dirname[0]) && dirname[1] == ':') 1952 { 1953 strcpy (filename, dirname + 2); 1954 dirname[2] = '\0'; 1955 } 1956#endif 1957 else 1958 { 1959 dirname[0] = '.'; 1960 dirname[1] = '\0'; 1961 } 1962 1963 /* We aren't done yet. We also support the "~user" syntax. */ 1964 1965 /* Save the version of the directory that the user typed. */ 1966 users_dirname = savestring (dirname); 1967 1968 if (*dirname == '~') 1969 { 1970 temp = tilde_expand (dirname); 1971 free (dirname); 1972 dirname = temp; 1973 } 1974 1975 if (rl_directory_rewrite_hook) 1976 (*rl_directory_rewrite_hook) (&dirname); 1977 1978 if (rl_directory_completion_hook && (*rl_directory_completion_hook) (&dirname)) 1979 { 1980 free (users_dirname); 1981 users_dirname = savestring (dirname); 1982 } 1983 1984 directory = opendir (dirname); 1985 filename_len = strlen (filename); 1986 1987 rl_filename_completion_desired = 1; 1988 } 1989 1990 /* At this point we should entertain the possibility of hacking wildcarded 1991 filenames, like /usr/man/man<WILD>/te<TAB>. If the directory name 1992 contains globbing characters, then build an array of directories, and 1993 then map over that list while completing. */ 1994 /* *** UNIMPLEMENTED *** */ 1995 1996 /* Now that we have some state, we can read the directory. */ 1997 1998 entry = (struct dirent *)NULL; 1999 while (directory && (entry = readdir (directory))) 2000 { 2001 /* Special case for no filename. If the user has disabled the 2002 `match-hidden-files' variable, skip filenames beginning with `.'. 2003 All other entries except "." and ".." match. */ 2004 if (filename_len == 0) 2005 { 2006 if (_rl_match_hidden_files == 0 && HIDDEN_FILE (entry->d_name)) 2007 continue; 2008 2009 if (entry->d_name[0] != '.' || 2010 (entry->d_name[1] && 2011 (entry->d_name[1] != '.' || entry->d_name[2]))) 2012 break; 2013 } 2014 else 2015 { 2016 /* Otherwise, if these match up to the length of filename, then 2017 it is a match. */ 2018 if (_rl_completion_case_fold) 2019 { 2020 if ((_rl_to_lower (entry->d_name[0]) == _rl_to_lower (filename[0])) && 2021 (((int)D_NAMLEN (entry)) >= filename_len) && 2022 (_rl_strnicmp (filename, entry->d_name, filename_len) == 0)) 2023 break; 2024 } 2025 else 2026 { 2027 if ((entry->d_name[0] == filename[0]) && 2028 (((int)D_NAMLEN (entry)) >= filename_len) && 2029 (strncmp (filename, entry->d_name, filename_len) == 0)) 2030 break; 2031 } 2032 } 2033 } 2034 2035 if (entry == 0) 2036 { 2037 if (directory) 2038 { 2039 closedir (directory); 2040 directory = (DIR *)NULL; 2041 } 2042 if (dirname) 2043 { 2044 free (dirname); 2045 dirname = (char *)NULL; 2046 } 2047 if (filename) 2048 { 2049 free (filename); 2050 filename = (char *)NULL; 2051 } 2052 if (users_dirname) 2053 { 2054 free (users_dirname); 2055 users_dirname = (char *)NULL; 2056 } 2057 2058 return (char *)NULL; 2059 } 2060 else 2061 { 2062 /* dirname && (strcmp (dirname, ".") != 0) */ 2063 if (dirname && (dirname[0] != '.' || dirname[1])) 2064 { 2065 if (rl_complete_with_tilde_expansion && *users_dirname == '~') 2066 { 2067 dirlen = strlen (dirname); 2068 temp = (char *)xmalloc (2 + dirlen + D_NAMLEN (entry)); 2069 strcpy (temp, dirname); 2070 /* Canonicalization cuts off any final slash present. We 2071 may need to add it back. */ 2072 if (dirname[dirlen - 1] != '/') 2073 { 2074 temp[dirlen++] = '/'; 2075 temp[dirlen] = '\0'; 2076 } 2077 } 2078 else 2079 { 2080 dirlen = strlen (users_dirname); 2081 temp = (char *)xmalloc (2 + dirlen + D_NAMLEN (entry)); 2082 strcpy (temp, users_dirname); 2083 /* Make sure that temp has a trailing slash here. */ 2084 if (users_dirname[dirlen - 1] != '/') 2085 temp[dirlen++] = '/'; 2086 } 2087 2088 strcpy (temp + dirlen, entry->d_name); 2089 } 2090 else 2091 temp = savestring (entry->d_name); 2092 2093 return (temp); 2094 } 2095} 2096 2097/* An initial implementation of a menu completion function a la tcsh. The 2098 first time (if the last readline command was not rl_menu_complete), we 2099 generate the list of matches. This code is very similar to the code in 2100 rl_complete_internal -- there should be a way to combine the two. Then, 2101 for each item in the list of matches, we insert the match in an undoable 2102 fashion, with the appropriate character appended (this happens on the 2103 second and subsequent consecutive calls to rl_menu_complete). When we 2104 hit the end of the match list, we restore the original unmatched text, 2105 ring the bell, and reset the counter to zero. */ 2106int 2107rl_menu_complete (count, ignore) 2108 int count, ignore; 2109{ 2110 rl_compentry_func_t *our_func; 2111 int matching_filenames, found_quote; 2112 2113 static char *orig_text; 2114 static char **matches = (char **)0; 2115 static int match_list_index = 0; 2116 static int match_list_size = 0; 2117 static int orig_start, orig_end; 2118 static char quote_char; 2119 static int delimiter; 2120 2121 /* The first time through, we generate the list of matches and set things 2122 up to insert them. */ 2123 if (rl_last_func != rl_menu_complete) 2124 { 2125 /* Clean up from previous call, if any. */ 2126 FREE (orig_text); 2127 if (matches) 2128 _rl_free_match_list (matches); 2129 2130 match_list_index = match_list_size = 0; 2131 matches = (char **)NULL; 2132 2133 /* Only the completion entry function can change these. */ 2134 set_completion_defaults ('%'); 2135 2136 our_func = rl_completion_entry_function 2137 ? rl_completion_entry_function 2138 : rl_filename_completion_function; 2139 2140 /* We now look backwards for the start of a filename/variable word. */ 2141 orig_end = rl_point; 2142 found_quote = delimiter = 0; 2143 quote_char = '\0'; 2144 2145 if (rl_point) 2146 /* This (possibly) changes rl_point. If it returns a non-zero char, 2147 we know we have an open quote. */ 2148 quote_char = _rl_find_completion_word (&found_quote, &delimiter); 2149 2150 orig_start = rl_point; 2151 rl_point = orig_end; 2152 2153 orig_text = rl_copy_text (orig_start, orig_end); 2154 matches = gen_completion_matches (orig_text, orig_start, orig_end, 2155 our_func, found_quote, quote_char); 2156 2157 /* If we are matching filenames, the attempted completion function will 2158 have set rl_filename_completion_desired to a non-zero value. The basic 2159 rl_filename_completion_function does this. */ 2160 matching_filenames = rl_filename_completion_desired; 2161 2162 if (matches == 0 || postprocess_matches (&matches, matching_filenames) == 0) 2163 { 2164 rl_ding (); 2165 FREE (matches); 2166 matches = (char **)0; 2167 FREE (orig_text); 2168 orig_text = (char *)0; 2169 completion_changed_buffer = 0; 2170 return (0); 2171 } 2172 2173 for (match_list_size = 0; matches[match_list_size]; match_list_size++) 2174 ; 2175 /* matches[0] is lcd if match_list_size > 1, but the circular buffer 2176 code below should take care of it. */ 2177 } 2178 2179 /* Now we have the list of matches. Replace the text between 2180 rl_line_buffer[orig_start] and rl_line_buffer[rl_point] with 2181 matches[match_list_index], and add any necessary closing char. */ 2182 2183 if (matches == 0 || match_list_size == 0) 2184 { 2185 rl_ding (); 2186 FREE (matches); 2187 matches = (char **)0; 2188 completion_changed_buffer = 0; 2189 return (0); 2190 } 2191
|
2174 match_list_index = (match_list_index + count) % match_list_size;
| 2192 match_list_index += count;
|
2175 if (match_list_index < 0) 2176 match_list_index += match_list_size;
| 2193 if (match_list_index < 0) 2194 match_list_index += match_list_size;
|
| 2195 else 2196 match_list_index %= match_list_size;
|
2177 2178 if (match_list_index == 0 && match_list_size > 1) 2179 { 2180 rl_ding (); 2181 insert_match (orig_text, orig_start, MULT_MATCH, "e_char); 2182 } 2183 else 2184 { 2185 insert_match (matches[match_list_index], orig_start, SINGLE_MATCH, "e_char); 2186 append_to_match (matches[match_list_index], delimiter, quote_char, 2187 strcmp (orig_text, matches[match_list_index])); 2188 } 2189 2190 completion_changed_buffer = 1; 2191 return (0); 2192}
| 2197 2198 if (match_list_index == 0 && match_list_size > 1) 2199 { 2200 rl_ding (); 2201 insert_match (orig_text, orig_start, MULT_MATCH, "e_char); 2202 } 2203 else 2204 { 2205 insert_match (matches[match_list_index], orig_start, SINGLE_MATCH, "e_char); 2206 append_to_match (matches[match_list_index], delimiter, quote_char, 2207 strcmp (orig_text, matches[match_list_index])); 2208 } 2209 2210 completion_changed_buffer = 1; 2211 return (0); 2212}
|