1 /* complete.c -- filename completion for readline. */ 2 3 /* Copyright (C) 1987-2005 Free Software Foundation, Inc. 4 5 This file is part of the GNU Readline Library, a library for 6 reading lines of text with interactive input and history editing. 7 8 The GNU Readline Library is free software; you can redistribute it 9 and/or modify it under the terms of the GNU General Public License 10 as published by the Free Software Foundation; either version 2, or 11 (at your option) any later version. 12 13 The GNU Readline Library is distributed in the hope that it will be 14 useful, but WITHOUT ANY WARRANTY; without even the implied warranty 15 of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 The GNU General Public License is often shipped with GNU software, and 19 is generally kept in a file called COPYING or LICENSE. If you do not 20 have a copy of the license, write to the Free Software Foundation, 21 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA. */ 22 #define READLINE_LIBRARY 23 24 #if defined (HAVE_CONFIG_H) 25 # include "config_readline.h" 26 #endif 27 28 #include <sys/types.h> 29 #include <fcntl.h> 30 /* FreeBSD 5.3 will not declare u_int in sys/types.h, file.h needs it */ 31 #if defined (HAVE_SYS_FILE_H) && !defined(__FreeBSD__) 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) 49 extern int errno; 50 #endif /* !errno */ 51 52 #if defined (HAVE_PWD_H) 53 #include <pwd.h> 54 #endif 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__ 69 typedef int QSFUNC (const void *, const void *); 70 #else 71 typedef 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. */ 85 #if defined (HAVE_GETPWENT) && (!defined (HAVE_GETPW_DECLS) || defined (_POSIX_SOURCE)) 86 extern struct passwd *getpwent PARAMS((void)); 87 #endif /* HAVE_GETPWENT && (!HAVE_GETPW_DECLS || _POSIX_SOURCE) */ 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. */ 96 rl_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 102 static int stat_char PARAMS((char *)); 103 #endif 104 105 static int path_isdir PARAMS((const char *)); 106 107 static char *rl_quote_filename PARAMS((char *, int, char *)); 108 109 static void set_completion_defaults PARAMS((int)); 110 static int get_y_or_n PARAMS((int)); 111 static int _rl_internal_pager PARAMS((int)); 112 static char *printable_part PARAMS((char *)); 113 static int fnwidth PARAMS((const char *)); 114 static int fnprint PARAMS((const char *)); 115 static int print_filename PARAMS((char *, char *)); 116 117 static char **gen_completion_matches PARAMS((char *, int, int, rl_compentry_func_t *, int, int)); 118 119 static char **remove_duplicate_matches PARAMS((char **)); 120 static void insert_match PARAMS((char *, int, int, char *)); 121 static int append_to_match PARAMS((char *, int, int, int)); 122 static void insert_all_matches PARAMS((char **, int, char *)); 123 static void display_matches PARAMS((char **)); 124 static int compute_lcd_of_matches PARAMS((char **, int, const char *)); 125 static int postprocess_matches PARAMS((char ***, int)); 126 127 static 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. */ 138 int _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. */ 142 int _rl_complete_show_unmodified = 0; 143 144 /* If non-zero, completed directory names have a slash appended. */ 145 int _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. */ 151 int _rl_complete_mark_symlink_dirs = 0; 152 153 /* If non-zero, completions are printed horizontally in alphabetical order, 154 like `ls -x'. */ 155 int _rl_print_completions_horizontally; 156 157 /* Non-zero means that case is not significant in filename completion. */ 158 #if defined (__MSDOS__) && !defined (__DJGPP__) 159 int _rl_completion_case_fold = 1; 160 #else 161 int _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. */ 166 int _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. */ 174 int 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. */ 180 rl_icppfunc_t *rl_directory_completion_hook = (rl_icppfunc_t *)NULL; 181 182 rl_icppfunc_t *rl_directory_rewrite_hook = (rl_icppfunc_t *)NULL; 183 184 /* Non-zero means readline completion functions perform tilde expansion. */ 185 int 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. */ 190 rl_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. */ 199 rl_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. */ 203 int 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. */ 208 int 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 212 she is sure she wants to see them all. A negative value means 213 don't ask. */ 214 int rl_completion_query_items = 100; 215 216 int _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\"\\'`@$><=" */ 221 const char *rl_basic_word_break_characters = " \t\n\"\\'`@$><=;|&{("; /* }) */ 222 223 /* List of basic quoting characters. */ 224 const 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. */ 234 rl_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. */ 240 const char *rl_completer_quote_characters = (const char *)NULL; 241 242 /* List of characters that should be quoted in filenames by the completer. */ 243 const 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. */ 248 const char *rl_special_prefixes = (const char *)NULL; 249 250 /* If non-zero, then disallow duplicates in the matches. */ 251 int 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. */ 256 int 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. */ 263 int 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. */ 274 rl_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. */ 280 rl_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. */ 286 rl_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. */ 291 rl_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. */ 296 int 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. */ 300 int 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. */ 305 int rl_completion_suppress_quote = 0; 306 307 /* Set to any quote character readline thinks it finds before any application 308 completion function is called. */ 309 int 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. */ 313 int 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. */ 324 int rl_completion_mark_symlink_dirs; 325 326 /* If non-zero, inhibit completion (temporarily). */ 327 int rl_inhibit_completion; 328 329 /* Variables local to this file. */ 330 331 /* Local variable states what happened during the last completion attempt. */ 332 static 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. */ 343 int 344 rl_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 (). */ 360 int 361 rl_possible_completions (ignore, invoking_key) 362 int ignore __attribute__((unused)), invoking_key __attribute__((unused)); 363 { 364 return (rl_complete_internal ('?')); 365 } 366 367 int 368 rl_insert_completions (ignore, invoking_key) 369 int ignore __attribute__((unused)), invoking_key __attribute__((unused)); 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. */ 379 int 380 rl_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. */ 401 static void 402 set_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. */ 416 static int 417 get_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 442 static 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 460 static int 461 path_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 */ 478 static int 479 stat_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. */ 534 static char * 535 printable_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 */ 567 static int 568 fnwidth (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 618 static int 619 fnprint (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; 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) 662 tlen = mbrtowc (&wc, s, end - s, &ps); 663 if (MB_INVALIDCH (tlen)) 664 { 665 tlen = 1; 666 width = 1; 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 } 676 s+= fwrite (s, 1, tlen, rl_outstream); 677 printed_len += width; 678 #else 679 putc (*s, rl_outstream); 680 s++; 681 printed_len++; 682 #endif 683 } 684 } 685 686 return printed_len; 687 } 688 689 /* Output TO_PRINT to rl_outstream. If VISIBLE_STATS is defined and we 690 are using it, check for and output a single character for `special' 691 filenames. Return the number of characters we output. */ 692 693 static int 694 print_filename (to_print, full_pathname) 695 char *to_print, *full_pathname; 696 { 697 int printed_len, extension_char, slen, tlen; 698 char *s, c, *new_full_pathname; 699 const char *dn; 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 `/'. */ 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); 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] = '/'; 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 783 static char * 784 rl_quote_filename (s, rtype, qcp) 785 char *s; 786 int rtype __attribute__((unused)); 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 814 char 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. */ 837 for (scan = pass_next = 0; scan < end; scan = MB_NEXTCHAR (rl_line_buffer, scan, 1, MB_FIND_ANY)) 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. */ 887 while ((rl_point = MB_PREVCHAR (rl_line_buffer, rl_point, MB_FIND_ANY))) 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 947 static char ** 948 gen_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; 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 /* XXX -- filename dequoting moved into rl_filename_completion_function */ 974 975 matches = rl_completion_matches (text, our_func); 976 return matches; 977 } 978 979 /* Filter out duplicates in MATCHES. This frees up the strings in 980 MATCHES. */ 981 static char ** 982 remove_duplicate_matches (matches) 983 char **matches; 984 { 985 char *lowest_common; 986 int i, j, newlen; 987 char dead_slot; 988 char **temp_array; 989 990 /* Sort the items. */ 991 for (i = 0; matches[i]; i++) 992 ; 993 994 /* Sort the array without matches[0], since we need it to 995 stay in place no matter what. */ 996 if (i) 997 qsort (matches+1, i-1, sizeof (char *), (QSFUNC *)_rl_qsort_string_compare); 998 999 /* Remember the lowest common denominator for it may be unique. */ 1000 lowest_common = savestring (matches[0]); 1001 1002 for (i = newlen = 0; matches[i + 1]; i++) 1003 { 1004 if (strcmp (matches[i], matches[i + 1]) == 0) 1005 { 1006 free (matches[i]); 1007 matches[i] = (char *)&dead_slot; 1008 } 1009 else 1010 newlen++; 1011 } 1012 1013 /* We have marked all the dead slots with (char *)&dead_slot. 1014 Copy all the non-dead entries into a new array. */ 1015 temp_array = (char **)xmalloc ((3 + newlen) * sizeof (char *)); 1016 for (i = j = 1; matches[i]; i++) 1017 { 1018 if (matches[i] != (char *)&dead_slot) 1019 temp_array[j++] = matches[i]; 1020 } 1021 temp_array[j] = (char *)NULL; 1022 1023 if (matches[0] != (char *)&dead_slot) 1024 free (matches[0]); 1025 1026 /* Place the lowest common denominator back in [0]. */ 1027 temp_array[0] = lowest_common; 1028 1029 /* If there is one string left, and it is identical to the 1030 lowest common denominator, then the LCD is the string to 1031 insert. */ 1032 if (j == 2 && strcmp (temp_array[0], temp_array[1]) == 0) 1033 { 1034 free (temp_array[1]); 1035 temp_array[1] = (char *)NULL; 1036 } 1037 return (temp_array); 1038 } 1039 1040 /* Find the common prefix of the list of matches, and put it into 1041 matches[0]. */ 1042 static int 1043 compute_lcd_of_matches (match_list, matches, text) 1044 char **match_list; 1045 int matches; 1046 const char *text; 1047 { 1048 register int i, c1, c2, si; 1049 int low; /* Count of max-matched characters. */ 1050 char *dtext; /* dequoted TEXT, if needed */ 1051 #if defined (HANDLE_MULTIBYTE) 1052 int v; 1053 mbstate_t ps1, ps2; 1054 wchar_t wc1, wc2; 1055 #endif 1056 1057 /* If only one match, just use that. Otherwise, compare each 1058 member of the list with the next, finding out where they 1059 stop matching. */ 1060 if (matches == 1) 1061 { 1062 match_list[0] = match_list[1]; 1063 match_list[1] = (char *)NULL; 1064 return 1; 1065 } 1066 1067 for (i = 1, low = 100000; i < matches; i++) 1068 { 1069 #if defined (HANDLE_MULTIBYTE) 1070 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0) 1071 { 1072 memset (&ps1, 0, sizeof (mbstate_t)); 1073 memset (&ps2, 0, sizeof (mbstate_t)); 1074 } 1075 #endif 1076 if (_rl_completion_case_fold) 1077 { 1078 for (si = 0; 1079 (c1 = _rl_to_lower(match_list[i][si])) && 1080 (c2 = _rl_to_lower(match_list[i + 1][si])); 1081 si++) 1082 #if defined (HANDLE_MULTIBYTE) 1083 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0) 1084 { 1085 v = mbrtowc (&wc1, match_list[i]+si, strlen (match_list[i]+si), &ps1); 1086 mbrtowc (&wc2, match_list[i+1]+si, strlen (match_list[i+1]+si), &ps2); 1087 wc1 = towlower (wc1); 1088 wc2 = towlower (wc2); 1089 if (wc1 != wc2) 1090 break; 1091 else if (v > 1) 1092 si += v - 1; 1093 } 1094 else 1095 #endif 1096 if (c1 != c2) 1097 break; 1098 } 1099 else 1100 { 1101 for (si = 0; 1102 (c1 = match_list[i][si]) && 1103 (c2 = match_list[i + 1][si]); 1104 si++) 1105 #if defined (HANDLE_MULTIBYTE) 1106 if (MB_CUR_MAX > 1 && rl_byte_oriented == 0) 1107 { 1108 mbstate_t ps_back; 1109 ps_back = ps1; 1110 if (!_rl_compare_chars (match_list[i], si, &ps1, match_list[i+1], si, &ps2)) 1111 break; 1112 else if ((v = _rl_get_char_len (&match_list[i][si], &ps_back)) > 1) 1113 si += v - 1; 1114 } 1115 else 1116 #endif 1117 if (c1 != c2) 1118 break; 1119 } 1120 1121 if (low > si) 1122 low = si; 1123 } 1124 1125 /* If there were multiple matches, but none matched up to even the 1126 first character, and the user typed something, use that as the 1127 value of matches[0]. */ 1128 if (low == 0 && text && *text) 1129 { 1130 match_list[0] = (char *)xmalloc (strlen (text) + 1); 1131 strcpy (match_list[0], text); 1132 } 1133 else 1134 { 1135 match_list[0] = (char *)xmalloc (low + 1); 1136 1137 /* XXX - this might need changes in the presence of multibyte chars */ 1138 1139 /* If we are ignoring case, try to preserve the case of the string 1140 the user typed in the face of multiple matches differing in case. */ 1141 if (_rl_completion_case_fold) 1142 { 1143 /* We're making an assumption here: 1144 IF we're completing filenames AND 1145 the application has defined a filename dequoting function AND 1146 we found a quote character AND 1147 the application has requested filename quoting 1148 THEN 1149 we assume that TEXT was dequoted before checking against 1150 the file system and needs to be dequoted here before we 1151 check against the list of matches 1152 FI */ 1153 dtext = (char *)NULL; 1154 if (rl_filename_completion_desired && 1155 rl_filename_dequoting_function && 1156 rl_completion_found_quote && 1157 rl_filename_quoting_desired) 1158 { 1159 dtext = (*rl_filename_dequoting_function) ((char *)text, rl_completion_quote_character); 1160 text = dtext; 1161 } 1162 1163 /* sort the list to get consistent answers. */ 1164 qsort (match_list+1, matches, sizeof(char *), (QSFUNC *)_rl_qsort_string_compare); 1165 1166 si = strlen (text); 1167 if (si <= low) 1168 { 1169 for (i = 1; i <= matches; i++) 1170 if (strncmp (match_list[i], text, si) == 0) 1171 { 1172 strncpy (match_list[0], match_list[i], low); 1173 break; 1174 } 1175 /* no casematch, use first entry */ 1176 if (i > matches) 1177 strncpy (match_list[0], match_list[1], low); 1178 } 1179 else 1180 /* otherwise, just use the text the user typed. */ 1181 strncpy (match_list[0], text, low); 1182 1183 FREE (dtext); 1184 } 1185 else 1186 strncpy (match_list[0], match_list[1], low); 1187 1188 match_list[0][low] = '\0'; 1189 } 1190 1191 return matches; 1192 } 1193 1194 static int 1195 postprocess_matches (matchesp, matching_filenames) 1196 char ***matchesp; 1197 int matching_filenames; 1198 { 1199 char *t, **matches, **temp_matches; 1200 int nmatch, i; 1201 1202 matches = *matchesp; 1203 1204 if (matches == 0) 1205 return 0; 1206 1207 /* It seems to me that in all the cases we handle we would like 1208 to ignore duplicate possiblilities. Scan for the text to 1209 insert being identical to the other completions. */ 1210 if (rl_ignore_completion_duplicates) 1211 { 1212 temp_matches = remove_duplicate_matches (matches); 1213 free (matches); 1214 matches = temp_matches; 1215 } 1216 1217 /* If we are matching filenames, then here is our chance to 1218 do clever processing by re-examining the list. Call the 1219 ignore function with the array as a parameter. It can 1220 munge the array, deleting matches as it desires. */ 1221 if (rl_ignore_some_completions_function && matching_filenames) 1222 { 1223 for (nmatch = 1; matches[nmatch]; nmatch++) 1224 ; 1225 (void)(*rl_ignore_some_completions_function) (matches); 1226 if (matches == 0 || matches[0] == 0) 1227 { 1228 FREE (matches); 1229 *matchesp = (char **)0; 1230 return 0; 1231 } 1232 else 1233 { 1234 /* If we removed some matches, recompute the common prefix. */ 1235 for (i = 1; matches[i]; i++) 1236 ; 1237 if (i > 1 && i < nmatch) 1238 { 1239 t = matches[0]; 1240 compute_lcd_of_matches (matches, i - 1, t); 1241 FREE (t); 1242 } 1243 } 1244 } 1245 1246 *matchesp = matches; 1247 return (1); 1248 } 1249 1250 /* A convenience function for displaying a list of strings in 1251 columnar format on readline's output stream. MATCHES is the list 1252 of strings, in argv format, LEN is the number of strings in MATCHES, 1253 and MAX is the length of the longest string in MATCHES. */ 1254 void 1255 rl_display_match_list (matches, len, max) 1256 char **matches; 1257 int len, max; 1258 { 1259 int count, limit, printed_len, lines; 1260 int i, j, k, l; 1261 char *temp; 1262 1263 /* How many items of MAX length can we fit in the screen window? */ 1264 max += 2; 1265 limit = _rl_screenwidth / max; 1266 if (limit != 1 && (limit * max == _rl_screenwidth)) 1267 limit--; 1268 1269 /* Avoid a possible floating exception. If max > _rl_screenwidth, 1270 limit will be 0 and a divide-by-zero fault will result. */ 1271 if (limit == 0) 1272 limit = 1; 1273 1274 /* How many iterations of the printing loop? */ 1275 count = (len + (limit - 1)) / limit; 1276 1277 /* Watch out for special case. If LEN is less than LIMIT, then 1278 just do the inner printing loop. 1279 0 < len <= limit implies count = 1. */ 1280 1281 /* Sort the items if they are not already sorted. */ 1282 if (rl_ignore_completion_duplicates == 0) 1283 qsort (matches + 1, len, sizeof (char *), (QSFUNC *)_rl_qsort_string_compare); 1284 1285 rl_crlf (); 1286 1287 lines = 0; 1288 if (_rl_print_completions_horizontally == 0) 1289 { 1290 /* Print the sorted items, up-and-down alphabetically, like ls. */ 1291 for (i = 1; i <= count; i++) 1292 { 1293 for (j = 0, l = i; j < limit; j++) 1294 { 1295 if (l > len || matches[l] == 0) 1296 break; 1297 else 1298 { 1299 temp = printable_part (matches[l]); 1300 printed_len = print_filename (temp, matches[l]); 1301 1302 if (j + 1 < limit) 1303 for (k = 0; k < max - printed_len; k++) 1304 putc (' ', rl_outstream); 1305 } 1306 l += count; 1307 } 1308 rl_crlf (); 1309 lines++; 1310 if (_rl_page_completions && lines >= (_rl_screenheight - 1) && i < count) 1311 { 1312 lines = _rl_internal_pager (lines); 1313 if (lines < 0) 1314 return; 1315 } 1316 } 1317 } 1318 else 1319 { 1320 /* Print the sorted items, across alphabetically, like ls -x. */ 1321 for (i = 1; matches[i]; i++) 1322 { 1323 temp = printable_part (matches[i]); 1324 printed_len = print_filename (temp, matches[i]); 1325 /* Have we reached the end of this line? */ 1326 if (matches[i+1]) 1327 { 1328 if (i && (limit > 1) && (i % limit) == 0) 1329 { 1330 rl_crlf (); 1331 lines++; 1332 if (_rl_page_completions && lines >= _rl_screenheight - 1) 1333 { 1334 lines = _rl_internal_pager (lines); 1335 if (lines < 0) 1336 return; 1337 } 1338 } 1339 else 1340 for (k = 0; k < max - printed_len; k++) 1341 putc (' ', rl_outstream); 1342 } 1343 } 1344 rl_crlf (); 1345 } 1346 } 1347 1348 /* Display MATCHES, a list of matching filenames in argv format. This 1349 handles the simple case -- a single match -- first. If there is more 1350 than one match, we compute the number of strings in the list and the 1351 length of the longest string, which will be needed by the display 1352 function. If the application wants to handle displaying the list of 1353 matches itself, it sets RL_COMPLETION_DISPLAY_MATCHES_HOOK to the 1354 address of a function, and we just call it. If we're handling the 1355 display ourselves, we just call rl_display_match_list. We also check 1356 that the list of matches doesn't exceed the user-settable threshold, 1357 and ask the user if he wants to see the list if there are more matches 1358 than RL_COMPLETION_QUERY_ITEMS. */ 1359 static void 1360 display_matches (matches) 1361 char **matches; 1362 { 1363 int len, max, i; 1364 char *temp; 1365 1366 /* Move to the last visible line of a possibly-multiple-line command. */ 1367 _rl_move_vert (_rl_vis_botlin); 1368 1369 /* Handle simple case first. What if there is only one answer? */ 1370 if (matches[1] == 0) 1371 { 1372 temp = printable_part (matches[0]); 1373 rl_crlf (); 1374 print_filename (temp, matches[0]); 1375 rl_crlf (); 1376 1377 rl_forced_update_display (); 1378 rl_display_fixed = 1; 1379 1380 return; 1381 } 1382 1383 /* There is more than one answer. Find out how many there are, 1384 and find the maximum printed length of a single entry. */ 1385 for (max = 0, i = 1; matches[i]; i++) 1386 { 1387 temp = printable_part (matches[i]); 1388 len = fnwidth (temp); 1389 1390 if (len > max) 1391 max = len; 1392 } 1393 1394 len = i - 1; 1395 1396 /* If the caller has defined a display hook, then call that now. */ 1397 if (rl_completion_display_matches_hook) 1398 { 1399 (*rl_completion_display_matches_hook) (matches, len, max); 1400 return; 1401 } 1402 1403 /* If there are many items, then ask the user if she really wants to 1404 see them all. */ 1405 if (rl_completion_query_items > 0 && len >= rl_completion_query_items) 1406 { 1407 rl_crlf (); 1408 fprintf (rl_outstream, "Display all %d possibilities? (y or n)", len); 1409 fflush (rl_outstream); 1410 if (get_y_or_n (0) == 0) 1411 { 1412 rl_crlf (); 1413 1414 rl_forced_update_display (); 1415 rl_display_fixed = 1; 1416 1417 return; 1418 } 1419 } 1420 1421 rl_display_match_list (matches, len, max); 1422 1423 rl_forced_update_display (); 1424 rl_display_fixed = 1; 1425 } 1426 1427 static char * 1428 make_quoted_replacement (match, mtype, qc) 1429 char *match; 1430 int mtype; 1431 char *qc; /* Pointer to quoting character, if any */ 1432 { 1433 int should_quote, do_replace; 1434 char *replacement; 1435 1436 /* If we are doing completion on quoted substrings, and any matches 1437 contain any of the completer_word_break_characters, then auto- 1438 matically prepend the substring with a quote character (just pick 1439 the first one from the list of such) if it does not already begin 1440 with a quote string. FIXME: Need to remove any such automatically 1441 inserted quote character when it no longer is necessary, such as 1442 if we change the string we are completing on and the new set of 1443 matches don't require a quoted substring. */ 1444 replacement = match; 1445 1446 should_quote = match && rl_completer_quote_characters && 1447 rl_filename_completion_desired && 1448 rl_filename_quoting_desired; 1449 1450 if (should_quote) 1451 should_quote = should_quote && (!qc || !*qc || 1452 (rl_completer_quote_characters && strchr (rl_completer_quote_characters, *qc))); 1453 1454 if (should_quote) 1455 { 1456 /* If there is a single match, see if we need to quote it. 1457 This also checks whether the common prefix of several 1458 matches needs to be quoted. */ 1459 should_quote = rl_filename_quote_characters 1460 ? (_rl_strpbrk (match, rl_filename_quote_characters) != 0) 1461 : 0; 1462 1463 do_replace = should_quote ? mtype : NO_MATCH; 1464 /* Quote the replacement, since we found an embedded 1465 word break character in a potential match. */ 1466 if (do_replace != NO_MATCH && rl_filename_quoting_function) 1467 replacement = (*rl_filename_quoting_function) (match, do_replace, qc); 1468 } 1469 return (replacement); 1470 } 1471 1472 static void 1473 insert_match (match, start, mtype, qc) 1474 char *match; 1475 int start, mtype; 1476 char *qc; 1477 { 1478 char *replacement; 1479 char oqc; 1480 1481 oqc = qc ? *qc : '\0'; 1482 replacement = make_quoted_replacement (match, mtype, qc); 1483 1484 /* Now insert the match. */ 1485 if (replacement) 1486 { 1487 /* Don't double an opening quote character. */ 1488 if (qc && *qc && start && rl_line_buffer[start - 1] == *qc && 1489 replacement[0] == *qc) 1490 start--; 1491 /* If make_quoted_replacement changed the quoting character, remove 1492 the opening quote and insert the (fully-quoted) replacement. */ 1493 else if (qc && (*qc != oqc) && start && rl_line_buffer[start - 1] == oqc && 1494 replacement[0] != oqc) 1495 start--; 1496 _rl_replace_text (replacement, start, rl_point - 1); 1497 if (replacement != match) 1498 free (replacement); 1499 } 1500 } 1501 1502 /* Append any necessary closing quote and a separator character to the 1503 just-inserted match. If the user has specified that directories 1504 should be marked by a trailing `/', append one of those instead. The 1505 default trailing character is a space. Returns the number of characters 1506 appended. If NONTRIVIAL_MATCH is set, we test for a symlink (if the OS 1507 has them) and don't add a suffix for a symlink to a directory. A 1508 nontrivial match is one that actually adds to the word being completed. 1509 The variable rl_completion_mark_symlink_dirs controls this behavior 1510 (it's initially set to the what the user has chosen, indicated by the 1511 value of _rl_complete_mark_symlink_dirs, but may be modified by an 1512 application's completion function). */ 1513 static int 1514 append_to_match (text, delimiter, quote_char, nontrivial_match) 1515 char *text; 1516 int delimiter, quote_char, nontrivial_match; 1517 { 1518 char temp_string[4], *filename; 1519 int temp_string_index, s; 1520 struct stat finfo; 1521 1522 temp_string_index = 0; 1523 if (quote_char && rl_point && rl_completion_suppress_quote == 0 && 1524 rl_line_buffer[rl_point - 1] != quote_char) 1525 temp_string[temp_string_index++] = quote_char; 1526 1527 if (delimiter) 1528 temp_string[temp_string_index++] = delimiter; 1529 else if (rl_completion_suppress_append == 0 && rl_completion_append_character) 1530 temp_string[temp_string_index++] = rl_completion_append_character; 1531 1532 temp_string[temp_string_index++] = '\0'; 1533 1534 if (rl_filename_completion_desired) 1535 { 1536 filename = tilde_expand (text); 1537 s = (nontrivial_match && rl_completion_mark_symlink_dirs == 0) 1538 ? LSTAT (filename, &finfo) 1539 : stat (filename, &finfo); 1540 if (s == 0 && S_ISDIR (finfo.st_mode)) 1541 { 1542 if (_rl_complete_mark_directories /* && rl_completion_suppress_append == 0 */) 1543 { 1544 /* This is clumsy. Avoid putting in a double slash if point 1545 is at the end of the line and the previous character is a 1546 slash. */ 1547 if (rl_point && rl_line_buffer[rl_point] == '\0' && rl_line_buffer[rl_point - 1] == '/') 1548 ; 1549 else if (rl_line_buffer[rl_point] != '/') 1550 rl_insert_text ("/"); 1551 } 1552 } 1553 #ifdef S_ISLNK 1554 /* Don't add anything if the filename is a symlink and resolves to a 1555 directory. */ 1556 else if (s == 0 && S_ISLNK (finfo.st_mode) && 1557 stat (filename, &finfo) == 0 && S_ISDIR (finfo.st_mode)) 1558 ; 1559 #endif 1560 else 1561 { 1562 if (rl_point == rl_end && temp_string_index) 1563 rl_insert_text (temp_string); 1564 } 1565 free (filename); 1566 } 1567 else 1568 { 1569 if (rl_point == rl_end && temp_string_index) 1570 rl_insert_text (temp_string); 1571 } 1572 1573 return (temp_string_index); 1574 } 1575 1576 static void 1577 insert_all_matches (matches, point, qc) 1578 char **matches; 1579 int point; 1580 char *qc; 1581 { 1582 int i; 1583 char *rp; 1584 1585 rl_begin_undo_group (); 1586 /* remove any opening quote character; make_quoted_replacement will add 1587 it back. */ 1588 if (qc && *qc && point && rl_line_buffer[point - 1] == *qc) 1589 point--; 1590 rl_delete_text (point, rl_point); 1591 rl_point = point; 1592 1593 if (matches[1]) 1594 { 1595 for (i = 1; matches[i]; i++) 1596 { 1597 rp = make_quoted_replacement (matches[i], SINGLE_MATCH, qc); 1598 rl_insert_text (rp); 1599 rl_insert_text (" "); 1600 if (rp != matches[i]) 1601 free (rp); 1602 } 1603 } 1604 else 1605 { 1606 rp = make_quoted_replacement (matches[0], SINGLE_MATCH, qc); 1607 rl_insert_text (rp); 1608 rl_insert_text (" "); 1609 if (rp != matches[0]) 1610 free (rp); 1611 } 1612 rl_end_undo_group (); 1613 } 1614 1615 void 1616 _rl_free_match_list (matches) 1617 char **matches; 1618 { 1619 register int i; 1620 1621 if (matches == 0) 1622 return; 1623 1624 for (i = 0; matches[i]; i++) 1625 free (matches[i]); 1626 free (matches); 1627 } 1628 1629 /* Complete the word at or before point. 1630 WHAT_TO_DO says what to do with the completion. 1631 `?' means list the possible completions. 1632 TAB means do standard completion. 1633 `*' means insert all of the possible completions. 1634 `!' means to do standard completion, and list all possible completions if 1635 there is more than one. 1636 `@' means to do standard completion, and list all possible completions if 1637 there is more than one and partial completion is not possible. */ 1638 int 1639 rl_complete_internal (what_to_do) 1640 int what_to_do; 1641 { 1642 char **matches; 1643 rl_compentry_func_t *our_func; 1644 int start, end, delimiter, found_quote, i, nontrivial_lcd; 1645 char *text, *saved_line_buffer; 1646 char quote_char; 1647 1648 RL_SETSTATE(RL_STATE_COMPLETING); 1649 1650 set_completion_defaults (what_to_do); 1651 1652 saved_line_buffer = rl_line_buffer ? savestring (rl_line_buffer) : (char *)NULL; 1653 our_func = rl_completion_entry_function 1654 ? rl_completion_entry_function 1655 : rl_filename_completion_function; 1656 /* We now look backwards for the start of a filename/variable word. */ 1657 end = rl_point; 1658 found_quote = delimiter = 0; 1659 quote_char = '\0'; 1660 1661 if (rl_point) 1662 /* This (possibly) changes rl_point. If it returns a non-zero char, 1663 we know we have an open quote. */ 1664 quote_char = _rl_find_completion_word (&found_quote, &delimiter); 1665 1666 start = rl_point; 1667 rl_point = end; 1668 1669 text = rl_copy_text (start, end); 1670 matches = gen_completion_matches (text, start, end, our_func, found_quote, quote_char); 1671 /* nontrivial_lcd is set if the common prefix adds something to the word 1672 being completed. */ 1673 nontrivial_lcd = matches && strcmp (text, matches[0]) != 0; 1674 free (text); 1675 1676 if (matches == 0) 1677 { 1678 rl_ding (); 1679 FREE (saved_line_buffer); 1680 completion_changed_buffer = 0; 1681 RL_UNSETSTATE(RL_STATE_COMPLETING); 1682 return (0); 1683 } 1684 1685 /* If we are matching filenames, the attempted completion function will 1686 have set rl_filename_completion_desired to a non-zero value. The basic 1687 rl_filename_completion_function does this. */ 1688 i = rl_filename_completion_desired; 1689 1690 if (postprocess_matches (&matches, i) == 0) 1691 { 1692 rl_ding (); 1693 FREE (saved_line_buffer); 1694 completion_changed_buffer = 0; 1695 RL_UNSETSTATE(RL_STATE_COMPLETING); 1696 return (0); 1697 } 1698 1699 switch (what_to_do) 1700 { 1701 case TAB: 1702 case '!': 1703 case '@': 1704 /* Insert the first match with proper quoting. */ 1705 if (*matches[0]) 1706 insert_match (matches[0], start, matches[1] ? MULT_MATCH : SINGLE_MATCH, "e_char); 1707 1708 /* If there are more matches, ring the bell to indicate. 1709 If we are in vi mode, Posix.2 says to not ring the bell. 1710 If the `show-all-if-ambiguous' variable is set, display 1711 all the matches immediately. Otherwise, if this was the 1712 only match, and we are hacking files, check the file to 1713 see if it was a directory. If so, and the `mark-directories' 1714 variable is set, add a '/' to the name. If not, and we 1715 are at the end of the line, then add a space. */ 1716 if (matches[1]) 1717 { 1718 if (what_to_do == '!') 1719 { 1720 display_matches (matches); 1721 break; 1722 } 1723 else if (what_to_do == '@') 1724 { 1725 if (nontrivial_lcd == 0) 1726 display_matches (matches); 1727 break; 1728 } 1729 else if (rl_editing_mode != vi_mode) 1730 rl_ding (); /* There are other matches remaining. */ 1731 } 1732 else 1733 append_to_match (matches[0], delimiter, quote_char, nontrivial_lcd); 1734 1735 break; 1736 1737 case '*': 1738 insert_all_matches (matches, start, "e_char); 1739 break; 1740 1741 case '?': 1742 display_matches (matches); 1743 break; 1744 1745 default: 1746 fprintf (stderr, "\r\nreadline: bad value %d for what_to_do in rl_complete\n", what_to_do); 1747 rl_ding (); 1748 FREE (saved_line_buffer); 1749 RL_UNSETSTATE(RL_STATE_COMPLETING); 1750 return 1; 1751 } 1752 1753 _rl_free_match_list (matches); 1754 1755 /* Check to see if the line has changed through all of this manipulation. */ 1756 if (saved_line_buffer) 1757 { 1758 completion_changed_buffer = strcmp (rl_line_buffer, saved_line_buffer) != 0; 1759 free (saved_line_buffer); 1760 } 1761 1762 RL_UNSETSTATE(RL_STATE_COMPLETING); 1763 return 0; 1764 } 1765 1766 /***************************************************************/ 1767 /* */ 1768 /* Application-callable completion match generator functions */ 1769 /* */ 1770 /***************************************************************/ 1771 1772 /* Return an array of (char *) which is a list of completions for TEXT. 1773 If there are no completions, return a NULL pointer. 1774 The first entry in the returned array is the substitution for TEXT. 1775 The remaining entries are the possible completions. 1776 The array is terminated with a NULL pointer. 1777 1778 ENTRY_FUNCTION is a function of two args, and returns a (char *). 1779 The first argument is TEXT. 1780 The second is a state argument; it should be zero on the first call, and 1781 non-zero on subsequent calls. It returns a NULL pointer to the caller 1782 when there are no more matches. 1783 */ 1784 char ** 1785 rl_completion_matches (text, entry_function) 1786 const char *text; 1787 rl_compentry_func_t *entry_function; 1788 { 1789 /* Number of slots in match_list. */ 1790 int match_list_size; 1791 1792 /* The list of matches. */ 1793 char **match_list; 1794 1795 /* Number of matches actually found. */ 1796 int matches; 1797 1798 /* Temporary string binder. */ 1799 char *string; 1800 1801 matches = 0; 1802 match_list_size = 10; 1803 match_list = (char **)xmalloc ((match_list_size + 1) * sizeof (char *)); 1804 match_list[1] = (char *)NULL; 1805 1806 while ((string = (*entry_function) (text, matches))) 1807 { 1808 if (matches + 1 == match_list_size) 1809 match_list = (char **)xrealloc 1810 (match_list, ((match_list_size += 10) + 1) * sizeof (char *)); 1811 1812 match_list[++matches] = string; 1813 match_list[matches + 1] = (char *)NULL; 1814 } 1815 1816 /* If there were any matches, then look through them finding out the 1817 lowest common denominator. That then becomes match_list[0]. */ 1818 if (matches) 1819 compute_lcd_of_matches (match_list, matches, text); 1820 else /* There were no matches. */ 1821 { 1822 free (match_list); 1823 match_list = (char **)NULL; 1824 } 1825 return (match_list); 1826 } 1827 1828 /* A completion function for usernames. 1829 TEXT contains a partial username preceded by a random 1830 character (usually `~'). */ 1831 char * 1832 rl_username_completion_function (text, state) 1833 const char *text; 1834 int state; 1835 { 1836 #if defined (__WIN32__) || defined (__OPENNT) 1837 return (char *)NULL; 1838 #else /* !__WIN32__ && !__OPENNT) */ 1839 static char *username = (char *)NULL; 1840 static struct passwd *entry; 1841 static int first_char, first_char_loc; 1842 char *value; 1843 #if defined (HAVE_GETPWENT) 1844 static int namelen; 1845 #endif 1846 1847 if (state == 0) 1848 { 1849 FREE (username); 1850 1851 first_char = *text; 1852 first_char_loc = first_char == '~'; 1853 1854 username = savestring (&text[first_char_loc]); 1855 #if defined (HAVE_GETPWENT) 1856 namelen = strlen (username); 1857 #endif 1858 setpwent (); 1859 } 1860 1861 #if defined (HAVE_GETPWENT) 1862 while (entry = getpwent ()) 1863 { 1864 /* Null usernames should result in all users as possible completions. */ 1865 if (namelen == 0 || (STREQN (username, entry->pw_name, namelen))) 1866 break; 1867 } 1868 #endif 1869 1870 if (entry == 0) 1871 { 1872 #if defined (HAVE_GETPWENT) 1873 endpwent (); 1874 #endif 1875 return ((char *)NULL); 1876 } 1877 else 1878 { 1879 value = (char *)xmalloc (2 + strlen (entry->pw_name)); 1880 1881 *value = *text; 1882 1883 strcpy (value + first_char_loc, entry->pw_name); 1884 1885 if (first_char == '~') 1886 rl_filename_completion_desired = 1; 1887 1888 return (value); 1889 } 1890 #endif /* !__WIN32__ && !__OPENNT */ 1891 } 1892 1893 /* Okay, now we write the entry_function for filename completion. In the 1894 general case. Note that completion in the shell is a little different 1895 because of all the pathnames that must be followed when looking up the 1896 completion for a command. */ 1897 char * 1898 rl_filename_completion_function (text, state) 1899 const char *text; 1900 int state; 1901 { 1902 static DIR *directory = (DIR *)NULL; 1903 static char *filename = (char *)NULL; 1904 static char *dirname = (char *)NULL; 1905 static char *users_dirname = (char *)NULL; 1906 static int filename_len; 1907 char *temp; 1908 int dirlen; 1909 struct dirent *entry; 1910 1911 /* If we don't have any state, then do some initialization. */ 1912 if (state == 0) 1913 { 1914 /* If we were interrupted before closing the directory or reading 1915 all of its contents, close it. */ 1916 if (directory) 1917 { 1918 closedir (directory); 1919 directory = (DIR *)NULL; 1920 } 1921 FREE (dirname); 1922 FREE (filename); 1923 FREE (users_dirname); 1924 1925 filename = savestring (text); 1926 if (*text == 0) 1927 text = "."; 1928 dirname = savestring (text); 1929 1930 temp = strrchr (dirname, '/'); 1931 1932 #if defined (__MSDOS__) 1933 /* special hack for //X/... */ 1934 if (dirname[0] == '/' && dirname[1] == '/' && ISALPHA ((unsigned char)dirname[2]) && dirname[3] == '/') 1935 temp = strrchr (dirname + 3, '/'); 1936 #endif 1937 1938 if (temp) 1939 { 1940 strcpy (filename, ++temp); 1941 *temp = '\0'; 1942 } 1943 #if defined (__MSDOS__) 1944 /* searches from current directory on the drive */ 1945 else if (ISALPHA ((unsigned char)dirname[0]) && dirname[1] == ':') 1946 { 1947 strcpy (filename, dirname + 2); 1948 dirname[2] = '\0'; 1949 } 1950 #endif 1951 else 1952 { 1953 dirname[0] = '.'; 1954 dirname[1] = '\0'; 1955 } 1956 1957 /* We aren't done yet. We also support the "~user" syntax. */ 1958 1959 /* Save the version of the directory that the user typed. */ 1960 users_dirname = savestring (dirname); 1961 1962 if (*dirname == '~') 1963 { 1964 temp = tilde_expand (dirname); 1965 free (dirname); 1966 dirname = temp; 1967 } 1968 1969 if (rl_directory_rewrite_hook) 1970 (*rl_directory_rewrite_hook) (&dirname); 1971 1972 /* The directory completion hook should perform any necessary 1973 dequoting. */ 1974 if (rl_directory_completion_hook && (*rl_directory_completion_hook) (&dirname)) 1975 { 1976 free (users_dirname); 1977 users_dirname = savestring (dirname); 1978 } 1979 else if (rl_completion_found_quote && rl_filename_dequoting_function) 1980 { 1981 /* delete single and double quotes */ 1982 temp = (*rl_filename_dequoting_function) (users_dirname, rl_completion_quote_character); 1983 free (users_dirname); 1984 users_dirname = temp; 1985 } 1986 directory = opendir (dirname); 1987 1988 /* Now dequote a non-null filename. */ 1989 if (filename && *filename && rl_completion_found_quote && rl_filename_dequoting_function) 1990 { 1991 /* delete single and double quotes */ 1992 temp = (*rl_filename_dequoting_function) (filename, rl_completion_quote_character); 1993 free (filename); 1994 filename = temp; 1995 } 1996 filename_len = strlen (filename); 1997 1998 rl_filename_completion_desired = 1; 1999 } 2000 2001 /* At this point we should entertain the possibility of hacking wildcarded 2002 filenames, like /usr/man/man<WILD>/te<TAB>. If the directory name 2003 contains globbing characters, then build an array of directories, and 2004 then map over that list while completing. */ 2005 /* *** UNIMPLEMENTED *** */ 2006 2007 /* Now that we have some state, we can read the directory. */ 2008 2009 entry = (struct dirent *)NULL; 2010 while (directory && (entry = readdir (directory))) 2011 { 2012 /* Special case for no filename. If the user has disabled the 2013 `match-hidden-files' variable, skip filenames beginning with `.'. 2014 All other entries except "." and ".." match. */ 2015 if (filename_len == 0) 2016 { 2017 if (_rl_match_hidden_files == 0 && HIDDEN_FILE (entry->d_name)) 2018 continue; 2019 2020 if (entry->d_name[0] != '.' || 2021 (entry->d_name[1] && 2022 (entry->d_name[1] != '.' || entry->d_name[2]))) 2023 break; 2024 } 2025 else 2026 { 2027 /* Otherwise, if these match up to the length of filename, then 2028 it is a match. */ 2029 if (_rl_completion_case_fold) 2030 { 2031 if ((_rl_to_lower (entry->d_name[0]) == _rl_to_lower (filename[0])) && 2032 (((int)D_NAMLEN (entry)) >= filename_len) && 2033 (_rl_strnicmp (filename, entry->d_name, filename_len) == 0)) 2034 break; 2035 } 2036 else 2037 { 2038 if ((entry->d_name[0] == filename[0]) && 2039 (((int)D_NAMLEN (entry)) >= filename_len) && 2040 (strncmp (filename, entry->d_name, filename_len) == 0)) 2041 break; 2042 } 2043 } 2044 } 2045 2046 if (entry == 0) 2047 { 2048 if (directory) 2049 { 2050 closedir (directory); 2051 directory = (DIR *)NULL; 2052 } 2053 if (dirname) 2054 { 2055 free (dirname); 2056 dirname = (char *)NULL; 2057 } 2058 if (filename) 2059 { 2060 free (filename); 2061 filename = (char *)NULL; 2062 } 2063 if (users_dirname) 2064 { 2065 free (users_dirname); 2066 users_dirname = (char *)NULL; 2067 } 2068 2069 return (char *)NULL; 2070 } 2071 else 2072 { 2073 /* dirname && (strcmp (dirname, ".") != 0) */ 2074 if (dirname && (dirname[0] != '.' || dirname[1])) 2075 { 2076 if (rl_complete_with_tilde_expansion && *users_dirname == '~') 2077 { 2078 dirlen = strlen (dirname); 2079 temp = (char *)xmalloc (2 + dirlen + D_NAMLEN (entry)); 2080 strcpy (temp, dirname); 2081 /* Canonicalization cuts off any final slash present. We 2082 may need to add it back. */ 2083 if (dirname[dirlen - 1] != '/') 2084 { 2085 temp[dirlen++] = '/'; 2086 temp[dirlen] = '\0'; 2087 } 2088 } 2089 else 2090 { 2091 dirlen = strlen (users_dirname); 2092 temp = (char *)xmalloc (2 + dirlen + D_NAMLEN (entry)); 2093 strcpy (temp, users_dirname); 2094 /* Make sure that temp has a trailing slash here. */ 2095 if (users_dirname[dirlen - 1] != '/') 2096 temp[dirlen++] = '/'; 2097 } 2098 2099 strcpy (temp + dirlen, entry->d_name); 2100 } 2101 else 2102 temp = savestring (entry->d_name); 2103 2104 return (temp); 2105 } 2106 } 2107 2108 /* An initial implementation of a menu completion function a la tcsh. The 2109 first time (if the last readline command was not rl_menu_complete), we 2110 generate the list of matches. This code is very similar to the code in 2111 rl_complete_internal -- there should be a way to combine the two. Then, 2112 for each item in the list of matches, we insert the match in an undoable 2113 fashion, with the appropriate character appended (this happens on the 2114 second and subsequent consecutive calls to rl_menu_complete). When we 2115 hit the end of the match list, we restore the original unmatched text, 2116 ring the bell, and reset the counter to zero. */ 2117 int 2118 rl_menu_complete (count, ignore) 2119 int count, ignore __attribute__((unused)); 2120 { 2121 rl_compentry_func_t *our_func; 2122 int matching_filenames, found_quote; 2123 2124 static char *orig_text; 2125 static char **matches = (char **)0; 2126 static int match_list_index = 0; 2127 static int match_list_size = 0; 2128 static int orig_start, orig_end; 2129 static char quote_char; 2130 static int delimiter; 2131 2132 /* The first time through, we generate the list of matches and set things 2133 up to insert them. */ 2134 if (rl_last_func != rl_menu_complete) 2135 { 2136 /* Clean up from previous call, if any. */ 2137 FREE (orig_text); 2138 if (matches) 2139 _rl_free_match_list (matches); 2140 2141 match_list_index = match_list_size = 0; 2142 matches = (char **)NULL; 2143 2144 /* Only the completion entry function can change these. */ 2145 set_completion_defaults ('%'); 2146 2147 our_func = rl_completion_entry_function 2148 ? rl_completion_entry_function 2149 : rl_filename_completion_function; 2150 2151 /* We now look backwards for the start of a filename/variable word. */ 2152 orig_end = rl_point; 2153 found_quote = delimiter = 0; 2154 quote_char = '\0'; 2155 2156 if (rl_point) 2157 /* This (possibly) changes rl_point. If it returns a non-zero char, 2158 we know we have an open quote. */ 2159 quote_char = _rl_find_completion_word (&found_quote, &delimiter); 2160 2161 orig_start = rl_point; 2162 rl_point = orig_end; 2163 2164 orig_text = rl_copy_text (orig_start, orig_end); 2165 matches = gen_completion_matches (orig_text, orig_start, orig_end, 2166 our_func, found_quote, quote_char); 2167 2168 /* If we are matching filenames, the attempted completion function will 2169 have set rl_filename_completion_desired to a non-zero value. The basic 2170 rl_filename_completion_function does this. */ 2171 matching_filenames = rl_filename_completion_desired; 2172 2173 if (matches == 0 || postprocess_matches (&matches, matching_filenames) == 0) 2174 { 2175 rl_ding (); 2176 FREE (matches); 2177 matches = (char **)0; 2178 FREE (orig_text); 2179 orig_text = (char *)0; 2180 completion_changed_buffer = 0; 2181 return (0); 2182 } 2183 2184 for (match_list_size = 0; matches[match_list_size]; match_list_size++) 2185 ; 2186 /* matches[0] is lcd if match_list_size > 1, but the circular buffer 2187 code below should take care of it. */ 2188 } 2189 2190 /* Now we have the list of matches. Replace the text between 2191 rl_line_buffer[orig_start] and rl_line_buffer[rl_point] with 2192 matches[match_list_index], and add any necessary closing char. */ 2193 2194 if (matches == 0 || match_list_size == 0) 2195 { 2196 rl_ding (); 2197 FREE (matches); 2198 matches = (char **)0; 2199 completion_changed_buffer = 0; 2200 return (0); 2201 } 2202 2203 match_list_index += count; 2204 if (match_list_index < 0) 2205 match_list_index += match_list_size; 2206 else 2207 match_list_index %= match_list_size; 2208 2209 if (match_list_index == 0 && match_list_size > 1) 2210 { 2211 rl_ding (); 2212 insert_match (orig_text, orig_start, MULT_MATCH, "e_char); 2213 } 2214 else 2215 { 2216 insert_match (matches[match_list_index], orig_start, SINGLE_MATCH, "e_char); 2217 append_to_match (matches[match_list_index], delimiter, quote_char, 2218 strcmp (orig_text, matches[match_list_index])); 2219 } 2220 2221 completion_changed_buffer = 1; 2222 return (0); 2223 } 2224