complete.c revision 30974
1/* complete.c -- filename completion for readline. */ 2 3/* Copyright (C) 1987, 1989, 1992 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 1, 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 675 Mass Ave, Cambridge, MA 02139, USA. */ 22#define READLINE_LIBRARY 23 24#if defined (HAVE_CONFIG_H) 25# include <config.h> 26#endif 27 28#include <sys/types.h> 29#include <fcntl.h> 30#if defined (HAVE_SYS_FILE_H) 31#include <sys/file.h> 32#endif 33 34#if defined (HAVE_UNISTD_H) 35# include <unistd.h> 36#endif /* HAVE_UNISTD_H */ 37 38#if defined (HAVE_STDLIB_H) 39# include <stdlib.h> 40#else 41# include "ansi_stdlib.h" 42#endif /* HAVE_STDLIB_H */ 43 44#include <stdio.h> 45 46#include <errno.h> 47#if !defined (errno) 48extern int errno; 49#endif /* !errno */ 50 51#include <pwd.h> 52#if !defined (HAVE_GETPW_DECLS) 53extern struct passwd *getpwent (); 54#endif /* USG && !HAVE_GETPW_DECLS */ 55 56/* ISC systems don't define getpwent() if _POSIX_SOURCE is defined. */ 57#if defined (isc386) && defined (_POSIX_SOURCE) 58# if defined (__STDC__) 59extern struct passwd *getpwent (void); 60# else 61extern struct passwd *getpwent (); 62# endif /* !__STDC__ */ 63#endif /* isc386 && _POSIX_SOURCE */ 64 65#include "posixdir.h" 66#include "posixstat.h" 67 68/* System-specific feature definitions and include files. */ 69#include "rldefs.h" 70 71/* Some standard library routines. */ 72#include "readline.h" 73 74extern char *tilde_expand (); 75extern char *rl_copy_text (); 76extern void _rl_abort_internal (); 77extern int _rl_qsort_string_compare (); 78 79extern Function *rl_last_func; 80extern int rl_editing_mode; 81extern int screenwidth; 82 83extern void _rl_move_vert (); 84extern int _rl_vis_botlin; 85extern int rl_display_fixed; 86 87/* Forward declarations for functions defined and used in this file. */ 88char *filename_completion_function (); 89char **completion_matches (); 90 91static char *rl_quote_filename (); 92static char *rl_strpbrk (); 93 94static char **remove_duplicate_matches (); 95static void insert_text (); 96static void insert_match (); 97static void append_to_match (); 98static void insert_all_matches (); 99static void display_matches (); 100static int compute_lcd_of_matches (); 101 102extern char *xmalloc (), *xrealloc (); 103 104/* If non-zero, then this is the address of a function to call when 105 completing on a directory name. The function is called with 106 the address of a string (the current directory name) as an arg. */ 107Function *rl_directory_completion_hook = (Function *)NULL; 108 109/* Non-zero means readline completion functions perform tilde expansion. */ 110int rl_complete_with_tilde_expansion = 0; 111 112/* If non-zero, non-unique completions always show the list of matches. */ 113int _rl_complete_show_all = 0; 114 115/* If non-zero, completed directory names have a slash appended. */ 116int _rl_complete_mark_directories = 1; 117 118#if defined (VISIBLE_STATS) 119# if !defined (X_OK) 120# define X_OK 1 121# endif 122 123static int stat_char (); 124 125/* Non-zero means add an additional character to each filename displayed 126 during listing completion iff rl_filename_completion_desired which helps 127 to indicate the type of file being listed. */ 128int rl_visible_stats = 0; 129#endif /* VISIBLE_STATS */ 130 131/* **************************************************************** */ 132/* */ 133/* Completion matching, from readline's point of view. */ 134/* */ 135/* **************************************************************** */ 136 137/* Local variable states what happened during the last completion attempt. */ 138static int completion_changed_buffer; 139 140/* Pointer to the generator function for completion_matches (). 141 NULL means to use filename_completion_function (), the default filename 142 completer. */ 143Function *rl_completion_entry_function = (Function *)NULL; 144 145/* Pointer to alternative function to create matches. 146 Function is called with TEXT, START, and END. 147 START and END are indices in RL_LINE_BUFFER saying what the boundaries 148 of TEXT are. 149 If this function exists and returns NULL then call the value of 150 rl_completion_entry_function to try to match, otherwise use the 151 array of strings returned. */ 152CPPFunction *rl_attempted_completion_function = (CPPFunction *)NULL; 153 154/* Non-zero means to suppress normal filename completion after the 155 user-specified completion function has been called. */ 156int rl_attempted_completion_over = 0; 157 158/* Set to a character indicating the type of completion being performed 159 by rl_complete_internal, available for use by application completion 160 functions. */ 161int rl_completion_type = 0; 162 163/* Up to this many items will be displayed in response to a 164 possible-completions call. After that, we ask the user if 165 she is sure she wants to see them all. */ 166int rl_completion_query_items = 100; 167 168/* The basic list of characters that signal a break between words for the 169 completer routine. The contents of this variable is what breaks words 170 in the shell, i.e. " \t\n\"\\'`@$><=" */ 171char *rl_basic_word_break_characters = " \t\n\"\\'`@$><=;|&{("; 172 173/* List of basic quoting characters. */ 174char *rl_basic_quote_characters = "\"'"; 175 176/* The list of characters that signal a break between words for 177 rl_complete_internal. The default list is the contents of 178 rl_basic_word_break_characters. */ 179char *rl_completer_word_break_characters = (char *)NULL; 180 181/* List of characters which can be used to quote a substring of the line. 182 Completion occurs on the entire substring, and within the substring 183 rl_completer_word_break_characters are treated as any other character, 184 unless they also appear within this list. */ 185char *rl_completer_quote_characters = (char *)NULL; 186 187/* List of characters that should be quoted in filenames by the completer. */ 188char *rl_filename_quote_characters = (char *)NULL; 189 190/* List of characters that are word break characters, but should be left 191 in TEXT when it is passed to the completion function. The shell uses 192 this to help determine what kind of completing to do. */ 193char *rl_special_prefixes = (char *)NULL; 194 195/* If non-zero, then disallow duplicates in the matches. */ 196int rl_ignore_completion_duplicates = 1; 197 198/* Non-zero means that the results of the matches are to be treated 199 as filenames. This is ALWAYS zero on entry, and can only be changed 200 within a completion entry finder function. */ 201int rl_filename_completion_desired = 0; 202 203/* Non-zero means that the results of the matches are to be quoted using 204 double quotes (or an application-specific quoting mechanism) if the 205 filename contains any characters in rl_filename_quote_chars. This is 206 ALWAYS non-zero on entry, and can only be changed within a completion 207 entry finder function. */ 208int rl_filename_quoting_desired = 1; 209 210/* This function, if defined, is called by the completer when real 211 filename completion is done, after all the matching names have been 212 generated. It is passed a (char**) known as matches in the code below. 213 It consists of a NULL-terminated array of pointers to potential 214 matching strings. The 1st element (matches[0]) is the maximal 215 substring that is common to all matches. This function can re-arrange 216 the list of matches as required, but all elements of the array must be 217 free()'d if they are deleted. The main intent of this function is 218 to implement FIGNORE a la SunOS csh. */ 219Function *rl_ignore_some_completions_function = (Function *)NULL; 220 221/* Set to a function to quote a filename in an application-specific fashion. 222 Called with the text to quote, the type of match found (single or multiple) 223 and a pointer to the quoting character to be used, which the function can 224 reset if desired. */ 225CPFunction *rl_filename_quoting_function = rl_quote_filename; 226 227/* Function to call to remove quoting characters from a filename. Called 228 before completion is attempted, so the embedded quotes do not interfere 229 with matching names in the file system. Readline doesn't do anything 230 with this; it's set only by applications. */ 231CPFunction *rl_filename_dequoting_function = (CPFunction *)NULL; 232 233/* Function to call to decide whether or not a word break character is 234 quoted. If a character is quoted, it does not break words for the 235 completer. */ 236Function *rl_char_is_quoted_p = (Function *)NULL; 237 238/* Character appended to completed words when at the end of the line. The 239 default is a space. */ 240int rl_completion_append_character = ' '; 241 242/* If non-zero, inhibit completion (temporarily). */ 243int rl_inhibit_completion; 244 245/* Complete the word at or before point. You have supplied the function 246 that does the initial simple matching selection algorithm (see 247 completion_matches ()). The default is to do filename completion. */ 248int 249rl_complete (ignore, invoking_key) 250 int ignore, invoking_key; 251{ 252 if (rl_inhibit_completion) 253 return (rl_insert (ignore, invoking_key)); 254 else if (rl_last_func == rl_complete && !completion_changed_buffer) 255 return (rl_complete_internal ('?')); 256 else if (_rl_complete_show_all) 257 return (rl_complete_internal ('!')); 258 else 259 return (rl_complete_internal (TAB)); 260} 261 262/* List the possible completions. See description of rl_complete (). */ 263int 264rl_possible_completions (ignore, invoking_key) 265 int ignore, invoking_key; 266{ 267 return (rl_complete_internal ('?')); 268} 269 270int 271rl_insert_completions (ignore, invoking_key) 272 int ignore, invoking_key; 273{ 274 return (rl_complete_internal ('*')); 275} 276 277/* The user must press "y" or "n". Non-zero return means "y" pressed. */ 278static int 279get_y_or_n () 280{ 281 int c; 282 283 for (;;) 284 { 285 c = rl_read_key (); 286 if (c == 'y' || c == 'Y' || c == ' ') 287 return (1); 288 if (c == 'n' || c == 'N' || c == RUBOUT) 289 return (0); 290 if (c == ABORT_CHAR) 291 _rl_abort_internal (); 292 ding (); 293 } 294} 295 296/* Return the portion of PATHNAME that should be output when listing 297 possible completions. If we are hacking filename completion, we 298 are only interested in the basename, the portion following the 299 final slash. Otherwise, we return what we were passed. */ 300static char * 301printable_part (pathname) 302 char *pathname; 303{ 304 char *temp; 305 306 temp = rl_filename_completion_desired ? strrchr (pathname, '/') : (char *)NULL; 307 return (temp ? ++temp : pathname); 308} 309 310/* Output TO_PRINT to rl_outstream. If VISIBLE_STATS is defined and we 311 are using it, check for and output a single character for `special' 312 filenames. Return 1 if we printed an extension character, 0 if not. */ 313 314#define PUTX(c) \ 315 if (CTRL_CHAR (c)) \ 316 { \ 317 putc ('^', rl_outstream); \ 318 putc (UNCTRL (c), rl_outstream); \ 319 } \ 320 else if (c == RUBOUT) \ 321 { \ 322 putc ('^', rl_outstream); \ 323 putc ('?', rl_outstream); \ 324 } \ 325 else \ 326 putc (c, rl_outstream) 327 328static int 329print_filename (to_print, full_pathname) 330 char *to_print, *full_pathname; 331{ 332#if !defined (VISIBLE_STATS) 333 char *s; 334 335 for (s = to_print; *s; s++) 336 { 337 PUTX (*s); 338 } 339 return 0; 340#else 341 char *s, c, *new_full_pathname; 342 int extension_char, slen, tlen; 343 344 for (s = to_print; *s; s++) 345 { 346 PUTX (*s); 347 } 348 349 if (rl_filename_completion_desired && rl_visible_stats) 350 { 351 /* If to_print != full_pathname, to_print is the basename of the 352 path passed. In this case, we try to expand the directory 353 name before checking for the stat character. */ 354 if (to_print != full_pathname) 355 { 356 /* Terminate the directory name. */ 357 c = to_print[-1]; 358 to_print[-1] = '\0'; 359 360 s = tilde_expand (full_pathname); 361 if (rl_directory_completion_hook) 362 (*rl_directory_completion_hook) (&s); 363 364 slen = strlen (s); 365 tlen = strlen (to_print); 366 new_full_pathname = xmalloc (slen + tlen + 2); 367 strcpy (new_full_pathname, s); 368 new_full_pathname[slen] = '/'; 369 strcpy (new_full_pathname + slen + 1, to_print); 370 371 extension_char = stat_char (new_full_pathname); 372 373 free (new_full_pathname); 374 to_print[-1] = c; 375 } 376 else 377 { 378 s = tilde_expand (full_pathname); 379 extension_char = stat_char (s); 380 } 381 382 free (s); 383 if (extension_char) 384 putc (extension_char, rl_outstream); 385 return (extension_char != 0); 386 } 387 else 388 return 0; 389#endif /* VISIBLE_STATS */ 390} 391 392static char * 393rl_quote_filename (s, rtype, qcp) 394 char *s; 395 int rtype; 396 char *qcp; 397{ 398 char *r; 399 400 r = xmalloc (strlen (s) + 2); 401 *r = *rl_completer_quote_characters; 402 strcpy (r + 1, s); 403 if (qcp) 404 *qcp = *rl_completer_quote_characters; 405 return r; 406} 407 408/* Find the bounds of the current word for completion purposes, and leave 409 rl_point set to the end of the word. This function skips quoted 410 substrings (characters between matched pairs of characters in 411 rl_completer_quote_characters. First we try to find an unclosed 412 quoted substring on which to do matching. If one is not found, we use 413 the word break characters to find the boundaries of the current word. 414 We call an application-specific function to decide whether or not a 415 particular word break character is quoted; if that function returns a 416 non-zero result, the character does not break a word. This function 417 returns the opening quote character if we found an unclosed quoted 418 substring, '\0' otherwise. FP, if non-null, is set to a value saying 419 which (shell-like) quote characters we found (single quote, double 420 quote, or backslash) anywhere in the string. DP, if non-null, is set to 421 the value of the delimiter character that caused a word break. */ 422 423static char 424find_completion_word (fp, dp) 425 int *fp, *dp; 426{ 427 int scan, end, found_quote, delimiter, pass_next, isbrk; 428 char quote_char; 429 430 end = rl_point; 431 found_quote = delimiter = 0; 432 quote_char = '\0'; 433 434 if (rl_completer_quote_characters) 435 { 436 /* We have a list of characters which can be used in pairs to 437 quote substrings for the completer. Try to find the start 438 of an unclosed quoted substring. */ 439 /* FOUND_QUOTE is set so we know what kind of quotes we found. */ 440 for (scan = pass_next = 0; scan < end; scan++) 441 { 442 if (pass_next) 443 { 444 pass_next = 0; 445 continue; 446 } 447 448 if (rl_line_buffer[scan] == '\\') 449 { 450 pass_next = 1; 451 found_quote |= RL_QF_BACKSLASH; 452 continue; 453 } 454 455 if (quote_char != '\0') 456 { 457 /* Ignore everything until the matching close quote char. */ 458 if (rl_line_buffer[scan] == quote_char) 459 { 460 /* Found matching close. Abandon this substring. */ 461 quote_char = '\0'; 462 rl_point = end; 463 } 464 } 465 else if (strchr (rl_completer_quote_characters, rl_line_buffer[scan])) 466 { 467 /* Found start of a quoted substring. */ 468 quote_char = rl_line_buffer[scan]; 469 rl_point = scan + 1; 470 /* Shell-like quoting conventions. */ 471 if (quote_char == '\'') 472 found_quote |= RL_QF_SINGLE_QUOTE; 473 else if (quote_char == '"') 474 found_quote |= RL_QF_DOUBLE_QUOTE; 475 } 476 } 477 } 478 479 if (rl_point == end && quote_char == '\0') 480 { 481 /* We didn't find an unclosed quoted substring upon which to do 482 completion, so use the word break characters to find the 483 substring on which to complete. */ 484 while (--rl_point) 485 { 486 scan = rl_line_buffer[rl_point]; 487 488 if (strchr (rl_completer_word_break_characters, scan) == 0) 489 continue; 490 491 /* Call the application-specific function to tell us whether 492 this word break character is quoted and should be skipped. */ 493 if (rl_char_is_quoted_p && found_quote && 494 (*rl_char_is_quoted_p) (rl_line_buffer, rl_point)) 495 continue; 496 497 /* Convoluted code, but it avoids an n^2 algorithm with calls 498 to char_is_quoted. */ 499 break; 500 } 501 } 502 503 /* If we are at an unquoted word break, then advance past it. */ 504 scan = rl_line_buffer[rl_point]; 505 506 /* If there is an application-specific function to say whether or not 507 a character is quoted and we found a quote character, let that 508 function decide whether or not a character is a word break, even 509 if it is found in rl_completer_word_break_characters. */ 510 if (rl_char_is_quoted_p) 511 isbrk = (found_quote == 0 || 512 (*rl_char_is_quoted_p) (rl_line_buffer, rl_point) == 0) && 513 strchr (rl_completer_word_break_characters, scan) != 0; 514 else 515 isbrk = strchr (rl_completer_word_break_characters, scan) != 0; 516 517 if (isbrk) 518 { 519 /* If the character that caused the word break was a quoting 520 character, then remember it as the delimiter. */ 521 if (rl_basic_quote_characters && strchr (rl_basic_quote_characters, scan) && (end - rl_point) > 1) 522 delimiter = scan; 523 524 /* If the character isn't needed to determine something special 525 about what kind of completion to perform, then advance past it. */ 526 if (rl_special_prefixes == 0 || strchr (rl_special_prefixes, scan) == 0) 527 rl_point++; 528 } 529 530 if (fp) 531 *fp = found_quote; 532 if (dp) 533 *dp = delimiter; 534 535 return (quote_char); 536} 537 538static char ** 539gen_completion_matches (text, start, end, our_func, found_quote, quote_char) 540 char *text; 541 int start, end; 542 Function *our_func; 543 int found_quote, quote_char; 544{ 545 char **matches, *temp; 546 547 /* If the user wants to TRY to complete, but then wants to give 548 up and use the default completion function, they set the 549 variable rl_attempted_completion_function. */ 550 if (rl_attempted_completion_function) 551 { 552 matches = (*rl_attempted_completion_function) (text, start, end); 553 554 if (matches || rl_attempted_completion_over) 555 { 556 rl_attempted_completion_over = 0; 557 return (matches); 558 } 559 } 560 561 /* Beware -- we're stripping the quotes here. Do this only if we know 562 we are doing filename completion and the application has defined a 563 filename dequoting function. */ 564 temp = (char *)NULL; 565 if (found_quote && our_func == (Function *)filename_completion_function && 566 rl_filename_dequoting_function) 567 { 568 /* delete single and double quotes */ 569 temp = (*rl_filename_dequoting_function) (text, quote_char); 570 text = temp; /* not freeing text is not a memory leak */ 571 } 572 573 matches = completion_matches (text, our_func); 574 FREE (temp); 575 return matches; 576} 577 578/* Filter out duplicates in MATCHES. This frees up the strings in 579 MATCHES. */ 580static char ** 581remove_duplicate_matches (matches) 582 char **matches; 583{ 584 char *lowest_common; 585 int i, j, newlen; 586 char dead_slot; 587 char **temp_array; 588 589 /* Sort the items. */ 590 for (i = 0; matches[i]; i++) 591 ; 592 593 /* Sort the array without matches[0], since we need it to 594 stay in place no matter what. */ 595 if (i) 596 qsort (matches+1, i-1, sizeof (char *), _rl_qsort_string_compare); 597 598 /* Remember the lowest common denominator for it may be unique. */ 599 lowest_common = savestring (matches[0]); 600 601 for (i = newlen = 0; matches[i + 1]; i++) 602 { 603 if (strcmp (matches[i], matches[i + 1]) == 0) 604 { 605 free (matches[i]); 606 matches[i] = (char *)&dead_slot; 607 } 608 else 609 newlen++; 610 } 611 612 /* We have marked all the dead slots with (char *)&dead_slot. 613 Copy all the non-dead entries into a new array. */ 614 temp_array = (char **)xmalloc ((3 + newlen) * sizeof (char *)); 615 for (i = j = 1; matches[i]; i++) 616 { 617 if (matches[i] != (char *)&dead_slot) 618 temp_array[j++] = matches[i]; 619 } 620 temp_array[j] = (char *)NULL; 621 622 if (matches[0] != (char *)&dead_slot) 623 free (matches[0]); 624 625 /* Place the lowest common denominator back in [0]. */ 626 temp_array[0] = lowest_common; 627 628 /* If there is one string left, and it is identical to the 629 lowest common denominator, then the LCD is the string to 630 insert. */ 631 if (j == 2 && strcmp (temp_array[0], temp_array[1]) == 0) 632 { 633 free (temp_array[1]); 634 temp_array[1] = (char *)NULL; 635 } 636 return (temp_array); 637} 638 639static void 640display_matches (matches) 641 char **matches; 642{ 643 int len, count, limit, max, printed_len; 644 int i, j, k, l; 645 char *temp; 646 647 /* Move to the last visible line of a possibly-multiple-line command. */ 648 _rl_move_vert (_rl_vis_botlin); 649 650 /* Handle simple case first. What if there is only one answer? */ 651 if (matches[1] == 0) 652 { 653 temp = printable_part (matches[0]); 654 crlf (); 655 print_filename (temp, matches[0]); 656 crlf (); 657#if 0 658 rl_on_new_line (); 659#else 660 rl_forced_update_display (); 661 rl_display_fixed = 1; 662#endif 663 return; 664 } 665 666 /* There is more than one answer. Find out how many there are, 667 and find the maximum printed length of a single entry. */ 668 for (max = 0, i = 1; matches[i]; i++) 669 { 670 temp = printable_part (matches[i]); 671 len = strlen (temp); 672 673 if (len > max) 674 max = len; 675 } 676 677 len = i - 1; 678 679 /* If there are many items, then ask the user if she really wants to 680 see them all. */ 681 if (len >= rl_completion_query_items) 682 { 683 crlf (); 684 fprintf (rl_outstream, "Display all %d possibilities? (y or n)", len); 685 fflush (rl_outstream); 686 if (get_y_or_n () == 0) 687 { 688 crlf (); 689#if 0 690 rl_on_new_line (); 691#else 692 rl_forced_update_display (); 693 rl_display_fixed = 1; 694#endif 695 return; 696 } 697 } 698 699 /* How many items of MAX length can we fit in the screen window? */ 700 max += 2; 701 limit = screenwidth / max; 702 if (limit != 1 && (limit * max == screenwidth)) 703 limit--; 704 705 /* Avoid a possible floating exception. If max > screenwidth, 706 limit will be 0 and a divide-by-zero fault will result. */ 707 if (limit == 0) 708 limit = 1; 709 710 /* How many iterations of the printing loop? */ 711 count = (len + (limit - 1)) / limit; 712 713 /* Watch out for special case. If LEN is less than LIMIT, then 714 just do the inner printing loop. 715 0 < len <= limit implies count = 1. */ 716 717 /* Sort the items if they are not already sorted. */ 718 if (rl_ignore_completion_duplicates == 0) 719 qsort (matches + 1, len, sizeof (char *), _rl_qsort_string_compare); 720 721 /* Print the sorted items, up-and-down alphabetically, like ls. */ 722 crlf (); 723 724 for (i = 1; i <= count; i++) 725 { 726 for (j = 0, l = i; j < limit; j++) 727 { 728 if (l > len || matches[l] == 0) 729 break; 730 else 731 { 732 temp = printable_part (matches[l]); 733 printed_len = strlen (temp) + print_filename (temp, matches[l]); 734 735 if (j + 1 < limit) 736 for (k = 0; k < max - printed_len; k++) 737 putc (' ', rl_outstream); 738 } 739 l += count; 740 } 741 crlf (); 742 } 743 744#if 0 745 rl_on_new_line (); 746#else 747 rl_forced_update_display (); 748 rl_display_fixed = 1; 749#endif 750} 751 752static void 753insert_text (text, start, end) 754 char *text; 755 int start, end; 756{ 757 rl_begin_undo_group (); 758 rl_delete_text (start, end + 1); 759 rl_point = start; 760 rl_insert_text (text); 761 rl_end_undo_group (); 762} 763 764static char * 765make_quoted_replacement (match, mtype, qc) 766 char *match; 767 int mtype; 768 char *qc; /* Pointer to quoting character, if any */ 769{ 770 int should_quote, do_replace; 771 char *replacement; 772 773 /* If we are doing completion on quoted substrings, and any matches 774 contain any of the completer_word_break_characters, then auto- 775 matically prepend the substring with a quote character (just pick 776 the first one from the list of such) if it does not already begin 777 with a quote string. FIXME: Need to remove any such automatically 778 inserted quote character when it no longer is necessary, such as 779 if we change the string we are completing on and the new set of 780 matches don't require a quoted substring. */ 781 replacement = match; 782 783 should_quote = match && rl_completer_quote_characters && 784 rl_filename_completion_desired && 785 rl_filename_quoting_desired; 786 787 if (should_quote) 788#if defined (SHELL) 789 should_quote = should_quote && (!qc || !*qc || *qc == '"' || *qc == '\''); 790#else /* !SHELL */ 791 should_quote = should_quote && (!qc || !*qc); 792#endif /* !SHELL */ 793 794 if (should_quote) 795 { 796 /* If there is a single match, see if we need to quote it. 797 This also checks whether the common prefix of several 798 matches needs to be quoted. */ 799 should_quote = rl_filename_quote_characters 800 ? (rl_strpbrk (match, rl_filename_quote_characters) != 0) 801 : 0; 802 803 do_replace = should_quote ? mtype : NO_MATCH; 804 /* Quote the replacement, since we found an embedded 805 word break character in a potential match. */ 806 if (do_replace != NO_MATCH && rl_filename_quoting_function) 807 replacement = (*rl_filename_quoting_function) (match, do_replace, qc); 808 } 809 return (replacement); 810} 811 812static void 813insert_match (match, start, mtype, qc) 814 char *match; 815 int start, mtype; 816 char *qc; 817{ 818 char *replacement; 819 char oqc; 820 821 oqc = qc ? *qc : '\0'; 822 replacement = make_quoted_replacement (match, mtype, qc); 823 824 /* Now insert the match. */ 825 if (replacement) 826 { 827 /* Don't double an opening quote character. */ 828 if (qc && *qc && start && rl_line_buffer[start - 1] == *qc && 829 replacement[0] == *qc) 830 start--; 831 /* If make_quoted_replacement changed the quoting character, remove 832 the opening quote and insert the (fully-quoted) replacement. */ 833 else if (qc && (*qc != oqc) && start && rl_line_buffer[start - 1] == oqc && 834 replacement[0] != oqc) 835 start--; 836 insert_text (replacement, start, rl_point - 1); 837 if (replacement != match) 838 free (replacement); 839 } 840} 841 842/* Append any necessary closing quote and a separator character to the 843 just-inserted match. If the user has specified that directories 844 should be marked by a trailing `/', append one of those instead. The 845 default trailing character */ 846static void 847append_to_match (text, delimiter, quote_char) 848 char *text; 849 int delimiter, quote_char; 850{ 851 char temp_string[4], *filename; 852 int temp_string_index; 853 struct stat finfo; 854 855 temp_string_index = 0; 856 if (quote_char && rl_point && rl_line_buffer[rl_point - 1] != quote_char) 857 temp_string[temp_string_index++] = quote_char; 858 859 if (delimiter) 860 temp_string[temp_string_index++] = delimiter; 861 else if (rl_completion_append_character) 862 temp_string[temp_string_index++] = rl_completion_append_character; 863 864 temp_string[temp_string_index++] = '\0'; 865 866 if (rl_filename_completion_desired) 867 { 868 filename = tilde_expand (text); 869 if (stat (filename, &finfo) == 0 && S_ISDIR (finfo.st_mode)) 870 { 871 if (_rl_complete_mark_directories && rl_line_buffer[rl_point] != '/') 872 rl_insert_text ("/"); 873 } 874 else 875 { 876 if (rl_point == rl_end) 877 rl_insert_text (temp_string); 878 } 879 free (filename); 880 } 881 else 882 { 883 if (rl_point == rl_end) 884 rl_insert_text (temp_string); 885 } 886} 887 888static void 889insert_all_matches (matches, point, qc) 890 char **matches; 891 int point; 892 char *qc; 893{ 894 int i; 895 char *rp; 896 897 rl_begin_undo_group (); 898 /* remove any opening quote character; make_quoted_replacement will add 899 it back. */ 900 if (qc && *qc && point && rl_line_buffer[point - 1] == *qc) 901 point--; 902 rl_delete_text (point, rl_point); 903 rl_point = point; 904 905 if (matches[1]) 906 { 907 for (i = 1; matches[i]; i++) 908 { 909 rp = make_quoted_replacement (matches[i], SINGLE_MATCH, qc); 910 rl_insert_text (rp); 911 rl_insert_text (" "); 912 if (rp != matches[i]) 913 free (rp); 914 } 915 } 916 else 917 { 918 rp = make_quoted_replacement (matches[0], SINGLE_MATCH, qc); 919 rl_insert_text (rp); 920 rl_insert_text (" "); 921 if (rp != matches[0]) 922 free (rp); 923 } 924 rl_end_undo_group (); 925} 926 927/* Complete the word at or before point. 928 WHAT_TO_DO says what to do with the completion. 929 `?' means list the possible completions. 930 TAB means do standard completion. 931 `*' means insert all of the possible completions. 932 `!' means to do standard completion, and list all possible completions if 933 there is more than one. */ 934int 935rl_complete_internal (what_to_do) 936 int what_to_do; 937{ 938 char **matches, **temp_matches; 939 Function *our_func; 940 int start, end, delimiter, found_quote, nmatch, i; 941 char *text, *saved_line_buffer, *t; 942 char quote_char; 943 944 saved_line_buffer = rl_line_buffer ? savestring (rl_line_buffer) : (char *)NULL; 945 946 our_func = rl_completion_entry_function 947 ? rl_completion_entry_function 948 : (Function *)filename_completion_function; 949 950 /* Only the completion entry function can change these. */ 951 rl_filename_completion_desired = 0; 952 rl_filename_quoting_desired = 1; 953 954 rl_completion_type = what_to_do; 955 956 /* We now look backwards for the start of a filename/variable word. */ 957 end = rl_point; 958 959 found_quote = delimiter = 0; 960 quote_char = '\0'; 961 962 if (rl_point) 963 /* This (possibly) changes rl_point. If it returns a non-zero char, 964 we know we have an open quote. */ 965 quote_char = find_completion_word (&found_quote, &delimiter); 966 967 start = rl_point; 968 rl_point = end; 969 970 text = rl_copy_text (start, end); 971 matches = gen_completion_matches (text, start, end, our_func, found_quote, quote_char); 972 973 if (matches == 0) 974 { 975 ding (); 976 FREE (saved_line_buffer); 977 free (text); 978 return 0; 979 } 980 981 /* It seems to me that in all the cases we handle we would like 982 to ignore duplicate possiblilities. Scan for the text to 983 insert being identical to the other completions. */ 984 if (rl_ignore_completion_duplicates) 985 { 986 temp_matches = remove_duplicate_matches (matches); 987 free (matches); 988 matches = temp_matches; 989 } 990 991 /* If we are matching filenames, then here is our chance to 992 do clever processing by re-examining the list. Call the 993 ignore function with the array as a parameter. It can 994 munge the array, deleting matches as it desires. */ 995 if (rl_ignore_some_completions_function && 996 our_func == (Function *)filename_completion_function) 997 { 998 for (nmatch = 1; matches[nmatch]; nmatch++) 999 ; 1000 (void)(*rl_ignore_some_completions_function) (matches); 1001 if (matches == 0 || matches[0] == 0) 1002 { 1003 FREE (matches); 1004 ding (); 1005 FREE (saved_line_buffer); 1006 FREE (text); 1007 return 0; 1008 } 1009 else 1010 { 1011 /* If we removed some matches, recompute the common prefix. */ 1012 for (i = 1; matches[i]; i++) 1013 ; 1014 if (i > 1 && i < nmatch) 1015 { 1016 t = matches[0]; 1017 compute_lcd_of_matches (matches, i - 1, text); 1018 FREE (t); 1019 } 1020 } 1021 } 1022 free (text); 1023 1024 switch (what_to_do) 1025 { 1026 case TAB: 1027 case '!': 1028 /* Insert the first match with proper quoting. */ 1029 if (*matches[0]) 1030 insert_match (matches[0], start, matches[1] ? MULT_MATCH : SINGLE_MATCH, "e_char); 1031 1032 /* If there are more matches, ring the bell to indicate. 1033 If we are in vi mode, Posix.2 says to not ring the bell. 1034 If the `show-all-if-ambiguous' variable is set, display 1035 all the matches immediately. Otherwise, if this was the 1036 only match, and we are hacking files, check the file to 1037 see if it was a directory. If so, and the `mark-directories' 1038 variable is set, add a '/' to the name. If not, and we 1039 are at the end of the line, then add a space. */ 1040 if (matches[1]) 1041 { 1042 if (what_to_do == '!') 1043 { 1044 display_matches (matches); 1045 break; 1046 } 1047 else if (rl_editing_mode != vi_mode) 1048 ding (); /* There are other matches remaining. */ 1049 } 1050 else 1051 append_to_match (matches[0], delimiter, quote_char); 1052 1053 break; 1054 1055 case '*': 1056 insert_all_matches (matches, start, "e_char); 1057 break; 1058 1059 case '?': 1060 display_matches (matches); 1061 break; 1062 1063 default: 1064 fprintf (stderr, "\r\nreadline: bad value %d for what_to_do in rl_complete\n", what_to_do); 1065 ding (); 1066 FREE (saved_line_buffer); 1067 return 1; 1068 } 1069 1070 for (i = 0; matches[i]; i++) 1071 free (matches[i]); 1072 free (matches); 1073 1074 /* Check to see if the line has changed through all of this manipulation. */ 1075 if (saved_line_buffer) 1076 { 1077 completion_changed_buffer = strcmp (rl_line_buffer, saved_line_buffer) != 0; 1078 free (saved_line_buffer); 1079 } 1080 1081 return 0; 1082} 1083 1084#if defined (VISIBLE_STATS) 1085/* Return the character which best describes FILENAME. 1086 `@' for symbolic links 1087 `/' for directories 1088 `*' for executables 1089 `=' for sockets 1090 `|' for FIFOs 1091 `%' for character special devices 1092 `#' for block special devices */ 1093static int 1094stat_char (filename) 1095 char *filename; 1096{ 1097 struct stat finfo; 1098 int character, r; 1099 1100#if defined (HAVE_LSTAT) && defined (S_ISLNK) 1101 r = lstat (filename, &finfo); 1102#else 1103 r = stat (filename, &finfo); 1104#endif 1105 1106 if (r == -1) 1107 return (0); 1108 1109 character = 0; 1110 if (S_ISDIR (finfo.st_mode)) 1111 character = '/'; 1112#if defined (S_ISCHR) 1113 else if (S_ISCHR (finfo.st_mode)) 1114 character = '%'; 1115#endif /* S_ISCHR */ 1116#if defined (S_ISBLK) 1117 else if (S_ISBLK (finfo.st_mode)) 1118 character = '#'; 1119#endif /* S_ISBLK */ 1120#if defined (S_ISLNK) 1121 else if (S_ISLNK (finfo.st_mode)) 1122 character = '@'; 1123#endif /* S_ISLNK */ 1124#if defined (S_ISSOCK) 1125 else if (S_ISSOCK (finfo.st_mode)) 1126 character = '='; 1127#endif /* S_ISSOCK */ 1128#if defined (S_ISFIFO) 1129 else if (S_ISFIFO (finfo.st_mode)) 1130 character = '|'; 1131#endif 1132 else if (S_ISREG (finfo.st_mode)) 1133 { 1134 if (access (filename, X_OK) == 0) 1135 character = '*'; 1136 } 1137 return (character); 1138} 1139#endif /* VISIBLE_STATS */ 1140 1141/* A completion function for usernames. 1142 TEXT contains a partial username preceded by a random 1143 character (usually `~'). */ 1144char * 1145username_completion_function (text, state) 1146 int state; 1147 char *text; 1148{ 1149#if defined (__GO32__) || defined (__WIN32__) 1150 return (char *)NULL; 1151#else /* !__GO32__ */ 1152 static char *username = (char *)NULL; 1153 static struct passwd *entry; 1154 static int namelen, first_char, first_char_loc; 1155 char *value; 1156 1157 if (state == 0) 1158 { 1159 FREE (username); 1160 1161 first_char = *text; 1162 first_char_loc = first_char == '~'; 1163 1164 username = savestring (&text[first_char_loc]); 1165 namelen = strlen (username); 1166 setpwent (); 1167 } 1168 1169 while (entry = getpwent ()) 1170 { 1171 /* Null usernames should result in all users as possible completions. */ 1172 if (namelen == 0 || (STREQN (username, entry->pw_name, namelen))) 1173 break; 1174 } 1175 1176 if (entry == 0) 1177 { 1178 endpwent (); 1179 return ((char *)NULL); 1180 } 1181 else 1182 { 1183 value = xmalloc (2 + strlen (entry->pw_name)); 1184 1185 *value = *text; 1186 1187 strcpy (value + first_char_loc, entry->pw_name); 1188 1189 if (first_char == '~') 1190 rl_filename_completion_desired = 1; 1191 1192 return (value); 1193 } 1194#endif /* !__GO32__ */ 1195} 1196 1197/* **************************************************************** */ 1198/* */ 1199/* Completion */ 1200/* */ 1201/* **************************************************************** */ 1202 1203/* Non-zero means that case is not significant in completion. */ 1204int completion_case_fold = 0; 1205 1206/* Find the common prefix of the list of matches, and put it into 1207 matches[0]. */ 1208static int 1209compute_lcd_of_matches (match_list, matches, text) 1210 char **match_list; 1211 int matches; 1212 char *text; 1213{ 1214 register int i, c1, c2, si; 1215 int low; /* Count of max-matched characters. */ 1216 1217 /* If only one match, just use that. Otherwise, compare each 1218 member of the list with the next, finding out where they 1219 stop matching. */ 1220 if (matches == 1) 1221 { 1222 match_list[0] = match_list[1]; 1223 match_list[1] = (char *)NULL; 1224 return 1; 1225 } 1226 1227 for (i = 1, low = 100000; i < matches; i++) 1228 { 1229 if (completion_case_fold) 1230 { 1231 for (si = 0; 1232 (c1 = _rl_to_lower(match_list[i][si])) && 1233 (c2 = _rl_to_lower(match_list[i + 1][si])); 1234 si++) 1235 if (c1 != c2) 1236 break; 1237 } 1238 else 1239 { 1240 for (si = 0; 1241 (c1 = match_list[i][si]) && 1242 (c2 = match_list[i + 1][si]); 1243 si++) 1244 if (c1 != c2) 1245 break; 1246 } 1247 1248 if (low > si) 1249 low = si; 1250 } 1251 1252 /* If there were multiple matches, but none matched up to even the 1253 first character, and the user typed something, use that as the 1254 value of matches[0]. */ 1255 if (low == 0 && text && *text) 1256 { 1257 match_list[0] = xmalloc (strlen (text) + 1); 1258 strcpy (match_list[0], text); 1259 } 1260 else 1261 { 1262 match_list[0] = xmalloc (low + 1); 1263 strncpy (match_list[0], match_list[1], low); 1264 match_list[0][low] = '\0'; 1265 } 1266 1267 return matches; 1268} 1269 1270/* Return an array of (char *) which is a list of completions for TEXT. 1271 If there are no completions, return a NULL pointer. 1272 The first entry in the returned array is the substitution for TEXT. 1273 The remaining entries are the possible completions. 1274 The array is terminated with a NULL pointer. 1275 1276 ENTRY_FUNCTION is a function of two args, and returns a (char *). 1277 The first argument is TEXT. 1278 The second is a state argument; it should be zero on the first call, and 1279 non-zero on subsequent calls. It returns a NULL pointer to the caller 1280 when there are no more matches. 1281 */ 1282char ** 1283completion_matches (text, entry_function) 1284 char *text; 1285 CPFunction *entry_function; 1286{ 1287 /* Number of slots in match_list. */ 1288 int match_list_size; 1289 1290 /* The list of matches. */ 1291 char **match_list; 1292 1293 /* Number of matches actually found. */ 1294 int matches; 1295 1296 /* Temporary string binder. */ 1297 char *string; 1298 1299 matches = 0; 1300 match_list_size = 10; 1301 match_list = (char **)xmalloc ((match_list_size + 1) * sizeof (char *)); 1302 match_list[1] = (char *)NULL; 1303 1304 while (string = (*entry_function) (text, matches)) 1305 { 1306 if (matches + 1 == match_list_size) 1307 match_list = (char **)xrealloc 1308 (match_list, ((match_list_size += 10) + 1) * sizeof (char *)); 1309 1310 match_list[++matches] = string; 1311 match_list[matches + 1] = (char *)NULL; 1312 } 1313 1314 /* If there were any matches, then look through them finding out the 1315 lowest common denominator. That then becomes match_list[0]. */ 1316 if (matches) 1317 compute_lcd_of_matches (match_list, matches, text); 1318 else /* There were no matches. */ 1319 { 1320 free (match_list); 1321 match_list = (char **)NULL; 1322 } 1323 return (match_list); 1324} 1325 1326/* Okay, now we write the entry_function for filename completion. In the 1327 general case. Note that completion in the shell is a little different 1328 because of all the pathnames that must be followed when looking up the 1329 completion for a command. */ 1330char * 1331filename_completion_function (text, state) 1332 int state; 1333 char *text; 1334{ 1335 static DIR *directory = (DIR *)NULL; 1336 static char *filename = (char *)NULL; 1337 static char *dirname = (char *)NULL; 1338 static char *users_dirname = (char *)NULL; 1339 static int filename_len; 1340 char *temp; 1341 int dirlen; 1342 struct dirent *entry; 1343 1344 /* If we don't have any state, then do some initialization. */ 1345 if (state == 0) 1346 { 1347 /* If we were interrupted before closing the directory or reading 1348 all of its contents, close it. */ 1349 if (directory) 1350 { 1351 closedir (directory); 1352 directory = (DIR *)NULL; 1353 } 1354 FREE (dirname); 1355 FREE (filename); 1356 FREE (users_dirname); 1357 1358 filename = savestring (text); 1359 if (*text == 0) 1360 text = "."; 1361 dirname = savestring (text); 1362 1363 temp = strrchr (dirname, '/'); 1364 1365 if (temp) 1366 { 1367 strcpy (filename, ++temp); 1368 *temp = '\0'; 1369 } 1370 else 1371 { 1372 dirname[0] = '.'; 1373 dirname[1] = '\0'; 1374 } 1375 1376 /* We aren't done yet. We also support the "~user" syntax. */ 1377 1378 /* Save the version of the directory that the user typed. */ 1379 users_dirname = savestring (dirname); 1380 1381 if (*dirname == '~') 1382 { 1383 temp = tilde_expand (dirname); 1384 free (dirname); 1385 dirname = temp; 1386 } 1387 1388 if (rl_directory_completion_hook && (*rl_directory_completion_hook) (&dirname)) 1389 { 1390 free (users_dirname); 1391 users_dirname = savestring (dirname); 1392 } 1393 1394 directory = opendir (dirname); 1395 filename_len = strlen (filename); 1396 1397 rl_filename_completion_desired = 1; 1398 } 1399 1400 /* At this point we should entertain the possibility of hacking wildcarded 1401 filenames, like /usr/man/man<WILD>/te<TAB>. If the directory name 1402 contains globbing characters, then build an array of directories, and 1403 then map over that list while completing. */ 1404 /* *** UNIMPLEMENTED *** */ 1405 1406 /* Now that we have some state, we can read the directory. */ 1407 1408 entry = (struct dirent *)NULL; 1409 while (directory && (entry = readdir (directory))) 1410 { 1411 /* Special case for no filename. 1412 All entries except "." and ".." match. */ 1413 if (filename_len == 0) 1414 { 1415 if (entry->d_name[0] != '.' || 1416 (entry->d_name[1] && 1417 (entry->d_name[1] != '.' || entry->d_name[2]))) 1418 break; 1419 } 1420 else 1421 { 1422 /* Otherwise, if these match up to the length of filename, then 1423 it is a match. */ 1424 if ((entry->d_name[0] == filename[0]) && 1425 (((int)D_NAMLEN (entry)) >= filename_len) && 1426 (strncmp (filename, entry->d_name, filename_len) == 0)) 1427 break; 1428 } 1429 } 1430 1431 if (entry == 0) 1432 { 1433 if (directory) 1434 { 1435 closedir (directory); 1436 directory = (DIR *)NULL; 1437 } 1438 if (dirname) 1439 { 1440 free (dirname); 1441 dirname = (char *)NULL; 1442 } 1443 if (filename) 1444 { 1445 free (filename); 1446 filename = (char *)NULL; 1447 } 1448 if (users_dirname) 1449 { 1450 free (users_dirname); 1451 users_dirname = (char *)NULL; 1452 } 1453 1454 return (char *)NULL; 1455 } 1456 else 1457 { 1458 /* dirname && (strcmp (dirname, ".") != 0) */ 1459 if (dirname && (dirname[0] != '.' || dirname[1])) 1460 { 1461 if (rl_complete_with_tilde_expansion && *users_dirname == '~') 1462 { 1463 dirlen = strlen (dirname); 1464 temp = xmalloc (2 + dirlen + D_NAMLEN (entry)); 1465 strcpy (temp, dirname); 1466 /* Canonicalization cuts off any final slash present. We 1467 may need to add it back. */ 1468 if (dirname[dirlen - 1] != '/') 1469 { 1470 temp[dirlen++] = '/'; 1471 temp[dirlen] = '\0'; 1472 } 1473 } 1474 else 1475 { 1476 dirlen = strlen (users_dirname); 1477 temp = xmalloc (1 + dirlen + D_NAMLEN (entry)); 1478 strcpy (temp, users_dirname); 1479 } 1480 1481 strcpy (temp + dirlen, entry->d_name); /* strcat (temp, entry->d_name); */ 1482 } 1483 else 1484 temp = savestring (entry->d_name); 1485 1486 return (temp); 1487 } 1488} 1489 1490/* A function for simple tilde expansion. */ 1491int 1492rl_tilde_expand (ignore, key) 1493 int ignore, key; 1494{ 1495 register int start, end; 1496 char *homedir, *temp; 1497 int len; 1498 1499 end = rl_point; 1500 start = end - 1; 1501 1502 if (rl_point == rl_end && rl_line_buffer[rl_point] == '~') 1503 { 1504 homedir = tilde_expand ("~"); 1505 insert_text (homedir, start, end); 1506 return (0); 1507 } 1508 else if (rl_line_buffer[start] != '~') 1509 { 1510 for (; !whitespace (rl_line_buffer[start]) && start >= 0; start--) 1511 ; 1512 start++; 1513 } 1514 1515 end = start; 1516 do 1517 end++; 1518 while (whitespace (rl_line_buffer[end]) == 0 && end < rl_end); 1519 1520 if (whitespace (rl_line_buffer[end]) || end >= rl_end) 1521 end--; 1522 1523 /* If the first character of the current word is a tilde, perform 1524 tilde expansion and insert the result. If not a tilde, do 1525 nothing. */ 1526 if (rl_line_buffer[start] == '~') 1527 { 1528 len = end - start + 1; 1529 temp = xmalloc (len + 1); 1530 strncpy (temp, rl_line_buffer + start, len); 1531 temp[len] = '\0'; 1532 homedir = tilde_expand (temp); 1533 free (temp); 1534 1535 insert_text (homedir, start, end); 1536 } 1537 1538 return (0); 1539} 1540 1541/* Find the first occurrence in STRING1 of any character from STRING2. 1542 Return a pointer to the character in STRING1. */ 1543static char * 1544rl_strpbrk (string1, string2) 1545 char *string1, *string2; 1546{ 1547 register char *scan; 1548 1549 for (; *string1; string1++) 1550 { 1551 for (scan = string2; *scan; scan++) 1552 { 1553 if (*string1 == *scan) 1554 { 1555 return (string1); 1556 } 1557 } 1558 } 1559 return ((char *)NULL); 1560} 1561