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