readline/complete.c

   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
  23 #include "sysdep.h"
  24 #include <stdio.h>
  25 #include <fcntl.h>
  26 #if !defined (NO_SYS_FILE)
  27 #  include <sys/file.h>
  28 #endif /* !NO_SYS_FILE */
  29
  30 #include <errno.h>
  31 /* Not all systems declare ERRNO in errno.h... and some systems #define it! */
  32 #if !defined (errno)
  33 extern int errno;
  34 #endif /* !errno */
  35
  36 /* These next are for filename completion.  Perhaps this belongs
  37    in a different place. */
  38 #if !defined(__MSDOS__) && !defined(_MSC_VER)
  39 #include <pwd.h>
  40 #endif /* __MSDOS__ */
  41 #if defined (USG) && !defined (isc386) && !defined (sgi)
  42 extern struct passwd *getpwuid (), *getpwent ();
  43 #endif
  44 #if defined (isc386) && !defined (__STDC__) && defined (_POSIX_SOURCE)
  45 extern struct passwd *getpwent ();
  46 #endif
  47
  48 /* Included by <fcntl.h> on some systems, but not SCO, so include it here.  */
  49 #include <sys/stat.h>
  50
  51 /* System-specific feature definitions and include files. */
  52 #include "rldefs.h"
  53
  54 /* Some standard library routines. */
  55 #include "readline.h"
  56
  57 /* Possible values for do_replace in rl_complete_internal. */
  58 #define NO_MATCH        0
  59 #define SINGLE_MATCH    1
  60 #define MULT_MATCH      2
  61
  62 #if !defined (strchr) && !defined (__STDC__)
  63 extern char *strchr (), *strrchr ();
  64 #endif /* !strchr && !__STDC__ */
  65
  66 extern char *tilde_expand ();
  67 extern char *rl_copy_text ();
  68
  69 extern Function *rl_last_func;
  70 extern int rl_editing_mode;
  71 extern int screenwidth;
  72
  73 /* Forward declarations for functions defined and used in this file. */
  74 char *filename_completion_function ();
  75 char **completion_matches ();
  76
  77 static int compare_strings ();
  78 static char *rl_strpbrk ();
  79
  80 #if defined (STATIC_MALLOC)
  81 static char *xmalloc (), *xrealloc ();
  82 #else
  83 extern char *xmalloc (), *xrealloc ();
  84 #endif /* STATIC_MALLOC */
  85 \f
  86 /* If non-zero, then this is the address of a function to call when
  87    completing on a directory name.  The function is called with
  88    the address of a string (the current directory name) as an arg. */
  89 Function *rl_symbolic_link_hook = (Function *)NULL;
  90
  91 /* Non-zero means readline completion functions perform tilde expansion. */
  92 int rl_complete_with_tilde_expansion = 0;
  93
  94 #define VISIBLE_STATS
  95
  96 #if defined (VISIBLE_STATS)
  97 #  if !defined (X_OK)
  98 #    define X_OK 1
  99 #  endif
 100
 101 static int stat_char ();
 102
 103 /* Non-zero means add an additional character to each filename displayed
 104    during listing completion iff rl_filename_completion_desired which helps
 105    to indicate the type of file being listed. */
 106 int rl_visible_stats = 0;
 107 #endif /* VISIBLE_STATS */
 108
 109 /* **************************************************************** */
 110 /*                                                                  */
 111 /*      Completion matching, from readline's point of view.         */
 112 /*                                                                  */
 113 /* **************************************************************** */
 114
 115 /* Pointer to the generator function for completion_matches ().
 116    NULL means to use filename_entry_function (), the default filename
 117    completer. */
 118 Function *rl_completion_entry_function = (Function *)NULL;
 119
 120 /* Pointer to alternative function to create matches.
 121    Function is called with TEXT, START, and END.
 122    START and END are indices in RL_LINE_BUFFER saying what the boundaries
 123    of TEXT are.
 124    If this function exists and returns NULL then call the value of
 125    rl_completion_entry_function to try to match, otherwise use the
 126    array of strings returned. */
 127 CPPFunction *rl_attempted_completion_function = (CPPFunction *)NULL;
 128
 129 /* Local variable states what happened during the last completion attempt. */
 130 static int completion_changed_buffer = 0;
 131
 132 /* Complete the word at or before point.  You have supplied the function
 133    that does the initial simple matching selection algorithm (see
 134    completion_matches ()).  The default is to do filename completion. */
 135
 136 rl_complete (ignore, invoking_key)
 137      int ignore, invoking_key;
 138 {
 139   if (rl_last_func == rl_complete && !completion_changed_buffer)
 140     rl_complete_internal ('?');
 141   else
 142     rl_complete_internal (TAB);
 143 }
 144
 145 /* List the possible completions.  See description of rl_complete (). */
 146 rl_possible_completions (ignore, invoking_key)
 147      int ignore, invoking_key;
 148 {
 149   rl_complete_internal ('?');
 150 }
 151
 152 rl_insert_completions (ignore, invoking_key)
 153      int ignore, invoking_key;
 154 {
 155   rl_complete_internal ('*');
 156 }
 157
 158 /* The user must press "y" or "n". Non-zero return means "y" pressed. */
 159 get_y_or_n ()
 160 {
 161   int c;
 162
 163   for (;;)
 164     {
 165       c = rl_read_key ();
 166       if (c == 'y' || c == 'Y')
 167         return (1);
 168       if (c == 'n' || c == 'N')
 169         return (0);
 170       if (c == ABORT_CHAR)
 171         rl_abort ();
 172       ding ();
 173     }
 174 }
 175
 176 /* Up to this many items will be displayed in response to a
 177    possible-completions call.  After that, we ask the user if
 178    she is sure she wants to see them all. */
 179 int rl_completion_query_items = 100;
 180
 181 /* The basic list of characters that signal a break between words for the
 182    completer routine.  The contents of this variable is what breaks words
 183    in the shell, i.e. " \t\n\"\\'`@$><=" */
 184 char *rl_basic_word_break_characters = " \t\n\"\\'`@$><=;|&{(";
 185
 186 /* The list of characters that signal a break between words for
 187    rl_complete_internal.  The default list is the contents of
 188    rl_basic_word_break_characters.  */
 189 char *rl_completer_word_break_characters = (char *)NULL;
 190
 191 /* List of characters which can be used to quote a substring of the line.
 192    Completion occurs on the entire substring, and within the substring
 193    rl_completer_word_break_characters are treated as any other character,
 194    unless they also appear within this list. */
 195 char *rl_completer_quote_characters = (char *)NULL;
 196
 197 /* List of characters that are word break characters, but should be left
 198    in TEXT when it is passed to the completion function.  The shell uses
 199    this to help determine what kind of completing to do. */
 200 char *rl_special_prefixes = (char *)NULL;
 201
 202 /* If non-zero, then disallow duplicates in the matches. */
 203 int rl_ignore_completion_duplicates = 1;
 204
 205 /* Non-zero means that the results of the matches are to be treated
 206    as filenames.  This is ALWAYS zero on entry, and can only be changed
 207    within a completion entry finder function. */
 208 int rl_filename_completion_desired = 0;
 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. */
 219 Function *rl_ignore_some_completions_function = (Function *)NULL;
 220
 221 #if defined (SHELL)
 222 /* A function to strip quotes that are not protected by backquotes.  It
 223    allows single quotes to appear within double quotes, and vice versa.
 224    It should be smarter.  It's fairly shell-specific, hence the SHELL
 225    definition wrapper. */
 226 static char *
 227 _delete_quotes (text)
 228      char *text;
 229 {
 230   char *ret, *p, *r;
 231   int l, quoted;
 232
 233   l = strlen (text);
 234   ret = xmalloc (l + 1);
 235   for (quoted = 0, p = text, r = ret; p && *p; p++)
 236     {
 237       /* Allow backslash-quoted characters to pass through unscathed. */
 238       if (*p == '\\')
 239         continue;
 240       /* Close quote. */
 241       if (quoted && *p == quoted)
 242         {
 243           quoted = 0;
 244           continue;
 245         }
 246       /* Open quote. */
 247       if (quoted == 0 && (*p == '\'' || *p == '"'))
 248         {
 249           quoted = *p;
 250           continue;
 251         }
 252       *r++ = *p;
 253     }
 254   *r = '\0';
 255   return ret;
 256 }
 257 #endif /* SHELL */
 258
 259 /* Complete the word at or before point.
 260    WHAT_TO_DO says what to do with the completion.
 261    `?' means list the possible completions.
 262    TAB means do standard completion.
 263    `*' means insert all of the possible completions. */
 264 rl_complete_internal (what_to_do)
 265      int what_to_do;
 266 {
 267   char **matches;
 268   Function *our_func;
 269   int start, scan, end, delimiter = 0, pass_next;
 270   char *text, *saved_line_buffer;
 271   char *replacement;
 272   char quote_char = '\0';
 273 #if defined (SHELL)
 274   int found_quote = 0;
 275 #endif
 276
 277   if (rl_line_buffer)
 278     saved_line_buffer = savestring (rl_line_buffer);
 279   else
 280     saved_line_buffer = (char *)NULL;
 281
 282   if (rl_completion_entry_function)
 283     our_func = rl_completion_entry_function;
 284   else
 285     our_func = (Function *)filename_completion_function;
 286
 287   /* Only the completion entry function can change this. */
 288   rl_filename_completion_desired = 0;
 289
 290   /* We now look backwards for the start of a filename/variable word. */
 291   end = rl_point;
 292
 293   if (rl_point)
 294     {
 295       if (rl_completer_quote_characters)
 296         {
 297           /* We have a list of characters which can be used in pairs to
 298              quote substrings for the completer.  Try to find the start
 299              of an unclosed quoted substring. */
 300           /* FOUND_QUOTE is set so we know what kind of quotes we found. */
 301           for (scan = pass_next = 0; scan < end; scan++)
 302             {
 303               if (pass_next)
 304                 {
 305                   pass_next = 0;
 306                   continue;
 307                 }
 308
 309               if (rl_line_buffer[scan] == '\\')
 310                 {
 311                   pass_next = 1;
 312                   continue;
 313                 }
 314
 315               if (quote_char != '\0')
 316                 {
 317                   /* Ignore everything until the matching close quote char. */
 318                   if (rl_line_buffer[scan] == quote_char)
 319                     {
 320                       /* Found matching close.  Abandon this substring. */
 321                       quote_char = '\0';
 322                       rl_point = end;
 323                     }
 324                 }
 325               else if (strchr (rl_completer_quote_characters, rl_line_buffer[scan]))
 326                 {
 327                   /* Found start of a quoted substring. */
 328                   quote_char = rl_line_buffer[scan];
 329                   rl_point = scan + 1;
 330 #if defined (SHELL)
 331                   if (quote_char == '\'')
 332                     found_quote |= 1;
 333                   else if (quote_char == '"')
 334                     found_quote |= 2;
 335 #endif
 336                 }
 337             }
 338         }
 339
 340       if (rl_point == end)
 341         {
 342           int quoted = 0;
 343           /* We didn't find an unclosed quoted substring up which to do
 344              completion, so use the word break characters to find the
 345              substring on which to complete. */
 346           while (--rl_point)
 347             {
 348 #if defined (SHELL)
 349               /* Don't let word break characters in quoted substrings break
 350                  words for the completer. */
 351               if (found_quote)
 352                 {
 353                   if (strchr (rl_completer_quote_characters, rl_line_buffer[rl_point]))
 354                     {
 355                       quoted = !quoted;
 356                       continue;
 357                     }
 358                   if (quoted)
 359                     continue;
 360                 }
 361 #endif /* SHELL */
 362               if (strchr (rl_completer_word_break_characters, rl_line_buffer[rl_point]))
 363                 break;
 364             }
 365         }
 366
 367       /* If we are at a word break, then advance past it. */
 368       if (strchr (rl_completer_word_break_characters, rl_line_buffer[rl_point]))
 369         {
 370           /* If the character that caused the word break was a quoting
 371              character, then remember it as the delimiter. */
 372           if (strchr ("\"'", rl_line_buffer[rl_point]) && (end - rl_point) > 1)
 373             delimiter = rl_line_buffer[rl_point];
 374
 375           /* If the character isn't needed to determine something special
 376              about what kind of completion to perform, then advance past it. */
 377           if (!rl_special_prefixes ||
 378               !strchr (rl_special_prefixes, rl_line_buffer[rl_point]))
 379             rl_point++;
 380         }
 381     }
 382
 383   /* At this point, we know we have an open quote if quote_char != '\0'. */
 384   start = rl_point;
 385   rl_point = end;
 386   text = rl_copy_text (start, end);
 387
 388   /* If the user wants to TRY to complete, but then wants to give
 389      up and use the default completion function, they set the
 390      variable rl_attempted_completion_function. */
 391   if (rl_attempted_completion_function)
 392     {
 393       matches = (*rl_attempted_completion_function) (text, start, end);
 394
 395       if (matches)
 396         {
 397           /* XXX - This is questionable code. - XXX */
 398           if (matches == (char **)-1)
 399             matches = (char **)NULL;
 400           our_func = (Function *)NULL;
 401           goto after_usual_completion;
 402         }
 403     }
 404
 405 #if defined (SHELL)
 406   /* Beware -- we're stripping the quotes here.  Do this only if we know
 407      we are doing filename completion. */
 408   if (found_quote && our_func == (Function *)filename_completion_function)
 409     {
 410       /* delete single and double quotes */
 411       replacement = _delete_quotes (text);
 412       free (text);
 413       text = replacement;
 414       replacement = (char *)0;
 415     }
 416 #endif /* SHELL */
 417
 418   matches = completion_matches (text, our_func);
 419
 420  after_usual_completion:
 421   free (text);
 422
 423   if (!matches)
 424     ding ();
 425   else
 426     {
 427       register int i;
 428
 429       /* It seems to me that in all the cases we handle we would like
 430          to ignore duplicate possiblilities.  Scan for the text to
 431          insert being identical to the other completions. */
 432       if (rl_ignore_completion_duplicates)
 433         {
 434           char *lowest_common;
 435           int j, newlen = 0;
 436           char dead_slot;
 437
 438           /* Sort the items. */
 439           /* It is safe to sort this array, because the lowest common
 440              denominator found in matches[0] will remain in place. */
 441           for (i = 0; matches[i]; i++);
 442           qsort (matches, i, sizeof (char *), compare_strings);
 443
 444           /* Remember the lowest common denominator for it may be unique. */
 445           lowest_common = savestring (matches[0]);
 446
 447           for (i = 0; matches[i + 1]; i++)
 448             {
 449               if (strcmp (matches[i], matches[i + 1]) == 0)
 450                 {
 451                   free (matches[i]);
 452                   matches[i] = (char *)&dead_slot;
 453                 }
 454               else
 455                 newlen++;
 456             }
 457
 458           /* We have marked all the dead slots with (char *)&dead_slot.
 459              Copy all the non-dead entries into a new array. */
 460           {
 461             char **temp_array =
 462               (char **)xmalloc ((3 + newlen) * sizeof (char *));
 463
 464             for (i = 1, j = 1; matches[i]; i++)
 465               {
 466                 if (matches[i] != (char *)&dead_slot)
 467                   temp_array[j++] = matches[i];
 468               }
 469
 470             temp_array[j] = (char *)NULL;
 471
 472             if (matches[0] != (char *)&dead_slot)
 473               free (matches[0]);
 474
 475             free (matches);
 476
 477             matches = temp_array;
 478           }
 479
 480           /* Place the lowest common denominator back in [0]. */
 481           matches[0] = lowest_common;
 482
 483           /* If there is one string left, and it is identical to the
 484              lowest common denominator, then the LCD is the string to
 485              insert. */
 486           if (j == 2 && strcmp (matches[0], matches[1]) == 0)
 487             {
 488               free (matches[1]);
 489               matches[1] = (char *)NULL;
 490             }
 491         }
 492
 493       switch (what_to_do)
 494         {
 495         case TAB:
 496           /* If we are matching filenames, then here is our chance to
 497              do clever processing by re-examining the list.  Call the
 498              ignore function with the array as a parameter.  It can
 499              munge the array, deleting matches as it desires. */
 500           if (rl_ignore_some_completions_function &&
 501               our_func == (Function *)filename_completion_function)
 502             (void)(*rl_ignore_some_completions_function)(matches);
 503
 504           /* If we are doing completion on quoted substrings, and any matches
 505              contain any of the completer_word_break_characters, then auto-
 506              matically prepend the substring with a quote character (just pick
 507              the first one from the list of such) if it does not already begin
 508              with a quote string.  FIXME: Need to remove any such automatically
 509              inserted quote character when it no longer is necessary, such as
 510              if we change the string we are completing on and the new set of
 511              matches don't require a quoted substring. */
 512           replacement = matches[0];
 513
 514           if (matches[0] && rl_completer_quote_characters && !quote_char &&
 515               rl_filename_completion_desired)
 516             {
 517               int do_replace;
 518
 519               do_replace = NO_MATCH;
 520
 521               /* If there is a single match, see if we need to quote it.
 522                  This also checks whether the common prefix of several
 523                  matches needs to be quoted.  If the common prefix should
 524                  not be checked, add !matches[1] to the if clause. */
 525               if (rl_strpbrk (matches[0], rl_completer_word_break_characters))
 526                 do_replace = matches[1] ? MULT_MATCH : SINGLE_MATCH;
 527
 528               if (do_replace != NO_MATCH)
 529                 {
 530 #if defined (SHELL)
 531                   /* XXX - experimental */
 532                   /* Quote the replacement, since we found an
 533                      embedded word break character in a potential
 534                      match. */
 535                   char *rtext, *mtext;
 536                   int rlen;
 537                   extern char *double_quote (); /* in builtins/common.c */
 538
 539                   /* If DO_REPLACE == MULT_MATCH, it means that there is
 540                      more than one match.  In this case, we do not add
 541                      the closing quote or attempt to perform tilde
 542                      expansion.  If DO_REPLACE == SINGLE_MATCH, we try
 543                      to perform tilde expansion, because double quotes
 544                      inhibit tilde expansion by the shell. */
 545
 546                   mtext = matches[0];
 547                   if (mtext[0] == '~' && do_replace == SINGLE_MATCH)
 548                     mtext = tilde_expand (matches[0]);
 549                   rtext = double_quote (mtext);
 550                   if (mtext != matches[0])
 551                     free (mtext);
 552
 553                   rlen = strlen (rtext);
 554                   replacement = (char *)alloca (rlen + 1);
 555                   strcpy (replacement, rtext);
 556                   if (do_replace == MULT_MATCH)
 557                     replacement[rlen - 1] = '\0';
 558                   free (rtext);
 559 #else /* !SHELL */
 560                   /* Found an embedded word break character in a potential
 561                      match, so we need to prepend a quote character if we
 562                      are replacing the completion string. */
 563                   replacement = (char *)alloca (strlen (matches[0]) + 2);
 564                   quote_char = *rl_completer_quote_characters;
 565                   *replacement = quote_char;
 566                   strcpy (replacement + 1, matches[0]);
 567 #endif /* SHELL */
 568                 }
 569             }
 570
 571           if (replacement)
 572             {
 573               rl_delete_text (start, rl_point);
 574               rl_point = start;
 575               rl_insert_text (replacement);
 576             }
 577
 578           /* If there are more matches, ring the bell to indicate.
 579              If this was the only match, and we are hacking files,
 580              check the file to see if it was a directory.  If so,
 581              add a '/' to the name.  If not, and we are at the end
 582              of the line, then add a space. */
 583           if (matches[1])
 584             {
 585               if (rl_editing_mode != vi_mode)
 586                 ding ();        /* There are other matches remaining. */
 587             }
 588           else
 589             {
 590               char temp_string[4];
 591               int temp_string_index = 0;
 592
 593               if (quote_char)
 594                 temp_string[temp_string_index++] = quote_char;
 595
 596               temp_string[temp_string_index++] = delimiter ? delimiter : ' ';
 597               temp_string[temp_string_index++] = '\0';
 598
 599               if (rl_filename_completion_desired)
 600                 {
 601                   struct stat finfo;
 602                   char *filename = tilde_expand (matches[0]);
 603
 604                   if ((stat (filename, &finfo) == 0) &&
 605                       S_ISDIR (finfo.st_mode))
 606                     {
 607                       if (rl_line_buffer[rl_point] != '/')
 608                         rl_insert_text ("/");
 609                     }
 610                   else
 611                     {
 612                       if (rl_point == rl_end)
 613                         rl_insert_text (temp_string);
 614                     }
 615                   free (filename);
 616                 }
 617               else
 618                 {
 619                   if (rl_point == rl_end)
 620                     rl_insert_text (temp_string);
 621                 }
 622             }
 623           break;
 624
 625         case '*':
 626           {
 627             int i = 1;
 628
 629             rl_delete_text (start, rl_point);
 630             rl_point = start;
 631             rl_begin_undo_group ();
 632             if (matches[1])
 633               {
 634                 while (matches[i])
 635                   {
 636                     rl_insert_text (matches[i++]);
 637                     rl_insert_text (" ");
 638                   }
 639               }
 640             else
 641               {
 642                 rl_insert_text (matches[0]);
 643                 rl_insert_text (" ");
 644               }
 645             rl_end_undo_group ();
 646           }
 647           break;
 648
 649         case '?':
 650           {
 651             int len, count, limit, max = 0;
 652             int j, k, l;
 653
 654             /* Handle simple case first.  What if there is only one answer? */
 655             if (!matches[1])
 656               {
 657                 char *temp = (char *)NULL;
 658
 659                 if (rl_filename_completion_desired)
 660                   temp = strrchr (matches[0], '/');
 661
 662                 if (!temp)
 663                   temp = matches[0];
 664                 else
 665                   temp++;
 666
 667                 crlf ();
 668                 fprintf (rl_outstream, "%s", temp);
 669 #if defined (VISIBLE_STATS)
 670                 if (rl_filename_completion_desired && rl_visible_stats)
 671                   {
 672                     int extension_char;
 673
 674                     extension_char = stat_char (matches[0]);
 675                     if (extension_char)
 676                       putc (extension_char, rl_outstream);
 677                   }
 678 #endif /* VISIBLE_STATS */
 679                 crlf ();
 680                 goto restart;
 681               }
 682
 683             /* There is more than one answer.  Find out how many there are,
 684                and find out what the maximum printed length of a single entry
 685                is. */
 686             for (i = 1; matches[i]; i++)
 687               {
 688                 char *temp;
 689                 int name_length;
 690
 691                 /* If we are hacking filenames, then only count the characters
 692                    after the last slash in the pathname. */
 693                 if (rl_filename_completion_desired)
 694                   temp = strrchr (matches[i], '/');
 695                 else
 696                   temp = (char *)NULL;
 697
 698                 if (!temp)
 699                   temp = matches[i];
 700                 else
 701                   temp++;
 702
 703                 name_length = strlen (temp);
 704
 705                 if (name_length > max)
 706                   max = name_length;
 707               }
 708
 709             len = i - 1;
 710
 711             /* If there are many items, then ask the user if she
 712                really wants to see them all. */
 713             if (len >= rl_completion_query_items)
 714               {
 715                 crlf ();
 716                 fprintf (rl_outstream,
 717                          "There are %d possibilities.  Do you really", len);
 718                 crlf ();
 719                 fprintf (rl_outstream, "wish to see them all? (y or n)");
 720                 fflush (rl_outstream);
 721                 if (!get_y_or_n ())
 722                   {
 723                     crlf ();
 724                     goto restart;
 725                   }
 726               }
 727
 728             /* How many items of MAX length can we fit in the screen window? */
 729             max += 2;
 730             limit = screenwidth / max;
 731             if (limit != 1 && (limit * max == screenwidth))
 732               limit--;
 733
 734             /* Avoid a possible floating exception.  If max > screenwidth,
 735                limit will be 0 and a divide-by-zero fault will result. */
 736             if (limit == 0)
 737               limit = 1;
 738
 739             /* How many iterations of the printing loop? */
 740             count = (len + (limit - 1)) / limit;
 741
 742             /* Watch out for special case.  If LEN is less than LIMIT, then
 743                just do the inner printing loop. */
 744             if (len < limit)
 745               count = 1;
 746
 747             /* Sort the items if they are not already sorted. */
 748             if (!rl_ignore_completion_duplicates)
 749               qsort (matches, len, sizeof (char *), compare_strings);
 750
 751             /* Print the sorted items, up-and-down alphabetically, like
 752                ls might. */
 753             crlf ();
 754
 755             for (i = 1; i < count + 1; i++)
 756               {
 757                 for (j = 0, l = i; j < limit; j++)
 758                   {
 759                     if (l > len || !matches[l])
 760                       {
 761                         break;
 762                       }
 763                     else
 764                       {
 765                         char *temp = (char *)NULL;
 766                         int printed_length;
 767
 768                         if (rl_filename_completion_desired)
 769                           temp = strrchr (matches[l], '/');
 770
 771                         if (!temp)
 772                           temp = matches[l];
 773                         else
 774                           temp++;
 775
 776                         printed_length = strlen (temp);
 777                         fprintf (rl_outstream, "%s", temp);
 778
 779 #if defined (VISIBLE_STATS)
 780                         if (rl_filename_completion_desired &&
 781                             rl_visible_stats)
 782                           {
 783                             int extension_char;
 784
 785                             extension_char = stat_char (matches[l]);
 786
 787                             if (extension_char)
 788                               {
 789                                 putc (extension_char, rl_outstream);
 790                                 printed_length++;
 791                               }
 792                           }
 793 #endif /* VISIBLE_STATS */
 794
 795                         if (j + 1 < limit)
 796                           {
 797                             for (k = 0; k < max - printed_length; k++)
 798                               putc (' ', rl_outstream);
 799                           }
 800                       }
 801                     l += count;
 802                   }
 803                 crlf ();
 804               }
 805           restart:
 806
 807             rl_on_new_line ();
 808           }
 809           break;
 810
 811         default:
 812           fprintf (stderr, "\r\nreadline: bad value for what_to_do in rl_complete\n");
 813           abort ();
 814         }
 815
 816       for (i = 0; matches[i]; i++)
 817         free (matches[i]);
 818       free (matches);
 819     }
 820
 821   /* Check to see if the line has changed through all of this manipulation. */
 822   if (saved_line_buffer)
 823     {
 824       if (strcmp (rl_line_buffer, saved_line_buffer) != 0)
 825         completion_changed_buffer = 1;
 826       else
 827         completion_changed_buffer = 0;
 828
 829       free (saved_line_buffer);
 830     }
 831 }
 832
 833 #if defined (VISIBLE_STATS)
 834 /* Return the character which best describes FILENAME.
 835      `@' for symbolic links
 836      `/' for directories
 837      `*' for executables
 838      `=' for sockets */
 839 static int
 840 stat_char (filename)
 841      char *filename;
 842 {
 843   struct stat finfo;
 844   int character = 0;
 845
 846   if (stat (filename, &finfo) == -1)
 847     return (character);
 848
 849   if (S_ISDIR (finfo.st_mode))
 850     character = '/';
 851 #if defined (S_ISLNK)
 852   else if (S_ISLNK (finfo.st_mode))
 853     character = '@';
 854 #endif /* S_ISLNK */
 855 #if defined (S_ISSOCK)
 856   else if (S_ISSOCK (finfo.st_mode))
 857     character = '=';
 858 #endif /* S_ISSOCK */
 859   else if (S_ISREG (finfo.st_mode))
 860     {
 861       if (access (filename, X_OK) == 0)
 862         character = '*';
 863     }
 864   return (character);
 865 }
 866 #endif /* VISIBLE_STATS */
 867
 868 /* Stupid comparison routine for qsort () ing strings. */
 869 static int
 870 compare_strings (s1, s2)
 871   char **s1, **s2;
 872 {
 873   return (strcmp (*s1, *s2));
 874 }
 875
 876 /* A completion function for usernames.
 877    TEXT contains a partial username preceded by a random
 878    character (usually `~').  */
 879 char *
 880 username_completion_function (text, state)
 881      int state;
 882      char *text;
 883 {
 884 #if defined (MINIMAL)
 885   return (char *)NULL;
 886 #else /* !MINIMAL */
 887   static char *username = (char *)NULL;
 888   static struct passwd *entry;
 889   static int namelen, first_char, first_char_loc;
 890
 891   if (!state)
 892     {
 893       if (username)
 894         free (username);
 895
 896       first_char = *text;
 897
 898       if (first_char == '~')
 899         first_char_loc = 1;
 900       else
 901         first_char_loc = 0;
 902
 903       username = savestring (&text[first_char_loc]);
 904       namelen = strlen (username);
 905       setpwent ();
 906     }
 907
 908   while (entry = getpwent ())
 909     {
 910       if (strncmp (username, entry->pw_name, namelen) == 0)
 911         break;
 912     }
 913
 914   if (!entry)
 915     {
 916       endpwent ();
 917       return ((char *)NULL);
 918     }
 919   else
 920     {
 921       char *value = (char *)xmalloc (2 + strlen (entry->pw_name));
 922
 923       *value = *text;
 924
 925       strcpy (value + first_char_loc, entry->pw_name);
 926
 927       if (first_char == '~')
 928         rl_filename_completion_desired = 1;
 929
 930       return (value);
 931     }
 932 #endif /* !MINIMAL */
 933 }
 934 \f
 935 /* **************************************************************** */
 936 /*                                                                  */
 937 /*                           Completion                             */
 938 /*                                                                  */
 939 /* **************************************************************** */
 940
 941 /* Non-zero means that case is not significant in completion. */
 942 int completion_case_fold = 0;
 943
 944 /* Return an array of (char *) which is a list of completions for TEXT.
 945    If there are no completions, return a NULL pointer.
 946    The first entry in the returned array is the substitution for TEXT.
 947    The remaining entries are the possible completions.
 948    The array is terminated with a NULL pointer.
 949
 950    ENTRY_FUNCTION is a function of two args, and returns a (char *).
 951      The first argument is TEXT.
 952      The second is a state argument; it should be zero on the first call, and
 953      non-zero on subsequent calls.  It returns a NULL pointer to the caller
 954      when there are no more matches.
 955  */
 956 char **
 957 completion_matches (text, entry_function)
 958      char *text;
 959      CPFunction *entry_function;
 960 {
 961   /* Number of slots in match_list. */
 962   int match_list_size;
 963
 964   /* The list of matches. */
 965   char **match_list =
 966     (char **)xmalloc (((match_list_size = 10) + 1) * sizeof (char *));
 967
 968   /* Number of matches actually found. */
 969   int matches = 0;
 970
 971   /* Temporary string binder. */
 972   char *string;
 973
 974   match_list[1] = (char *)NULL;
 975
 976   while (string = (*entry_function) (text, matches))
 977     {
 978       if (matches + 1 == match_list_size)
 979         match_list = (char **)xrealloc
 980           (match_list, ((match_list_size += 10) + 1) * sizeof (char *));
 981
 982       match_list[++matches] = string;
 983       match_list[matches + 1] = (char *)NULL;
 984     }
 985
 986   /* If there were any matches, then look through them finding out the
 987      lowest common denominator.  That then becomes match_list[0]. */
 988   if (matches)
 989     {
 990       register int i = 1;
 991       int low = 100000;         /* Count of max-matched characters. */
 992
 993       /* If only one match, just use that. */
 994       if (matches == 1)
 995         {
 996           match_list[0] = match_list[1];
 997           match_list[1] = (char *)NULL;
 998         }
 999       else
1000         {
1001           /* Otherwise, compare each member of the list with
1002              the next, finding out where they stop matching. */
1003
1004           while (i < matches)
1005             {
1006               register int c1, c2, si;
1007
1008               if (completion_case_fold)
1009                 {
1010                   for (si = 0;
1011                        (c1 = to_lower(match_list[i][si])) &&
1012                        (c2 = to_lower(match_list[i + 1][si]));
1013                        si++)
1014                     if (c1 != c2) break;
1015                 }
1016               else
1017                 {
1018                   for (si = 0;
1019                        (c1 = match_list[i][si]) &&
1020                        (c2 = match_list[i + 1][si]);
1021                        si++)
1022                     if (c1 != c2) break;
1023                 }
1024
1025               if (low > si) low = si;
1026               i++;
1027             }
1028           match_list[0] = (char *)xmalloc (low + 1);
1029           strncpy (match_list[0], match_list[1], low);
1030           match_list[0][low] = '\0';
1031         }
1032     }
1033   else                          /* There were no matches. */
1034     {
1035       free (match_list);
1036       match_list = (char **)NULL;
1037     }
1038   return (match_list);
1039 }
1040
1041 /* Okay, now we write the entry_function for filename completion.  In the
1042    general case.  Note that completion in the shell is a little different
1043    because of all the pathnames that must be followed when looking up the
1044    completion for a command. */
1045 char *
1046 filename_completion_function (text, state)
1047      int state;
1048      char *text;
1049 {
1050 #ifndef WIN32
1051   static DIR *directory;
1052   static char *filename = (char *)NULL;
1053   static char *dirname = (char *)NULL;
1054   static char *users_dirname = (char *)NULL;
1055   static int filename_len;
1056
1057   dirent *entry = (dirent *)NULL;
1058
1059   /* If we don't have any state, then do some initialization. */
1060   if (!state)
1061     {
1062       char *temp;
1063
1064       if (dirname) free (dirname);
1065       if (filename) free (filename);
1066       if (users_dirname) free (users_dirname);
1067
1068       filename = savestring (text);
1069       if (!*text) text = ".";
1070       dirname = savestring (text);
1071
1072       temp = strrchr (dirname, '/');
1073
1074       if (temp)
1075         {
1076           strcpy (filename, ++temp);
1077           *temp = '\0';
1078         }
1079       else
1080         strcpy (dirname, ".");
1081
1082       /* We aren't done yet.  We also support the "~user" syntax. */
1083
1084       /* Save the version of the directory that the user typed. */
1085       users_dirname = savestring (dirname);
1086       {
1087         char *temp_dirname;
1088
1089         temp_dirname = tilde_expand (dirname);
1090         free (dirname);
1091         dirname = temp_dirname;
1092
1093         if (rl_symbolic_link_hook)
1094           (*rl_symbolic_link_hook) (&dirname);
1095       }
1096       directory = opendir (dirname);
1097       filename_len = strlen (filename);
1098
1099       rl_filename_completion_desired = 1;
1100     }
1101
1102   /* At this point we should entertain the possibility of hacking wildcarded
1103      filenames, like /usr/man/man<WILD>/te<TAB>.  If the directory name
1104      contains globbing characters, then build an array of directories, and
1105      then map over that list while completing. */
1106   /* *** UNIMPLEMENTED *** */
1107
1108   /* Now that we have some state, we can read the directory. */
1109
1110   while (directory && (entry = readdir (directory)))
1111     {
1112       /* Special case for no filename.
1113          All entries except "." and ".." match. */
1114       if (!filename_len)
1115         {
1116           if ((strcmp (entry->d_name, ".") != 0) &&
1117               (strcmp (entry->d_name, "..") != 0))
1118             break;
1119         }
1120       else
1121         {
1122           /* Otherwise, if these match upto the length of filename, then
1123              it is a match. */
1124             if (((int)D_NAMLEN (entry)) >= filename_len &&
1125                 (entry->d_name[0] == filename[0]) &&
1126                 (strncmp (filename, entry->d_name, filename_len) == 0))
1127               {
1128                 break;
1129               }
1130         }
1131     }
1132
1133   if (!entry)
1134     {
1135       if (directory)
1136         {
1137           closedir (directory);
1138           directory = (DIR *)NULL;
1139         }
1140
1141       if (dirname)
1142         {
1143           free (dirname);
1144           dirname = (char *)NULL;
1145         }
1146       if (filename)
1147         {
1148           free (filename);
1149           filename = (char *)NULL;
1150         }
1151       if (users_dirname)
1152         {
1153           free (users_dirname);
1154           users_dirname = (char *)NULL;
1155         }
1156
1157       return (char *)NULL;
1158     }
1159   else
1160     {
1161       char *temp;
1162
1163       if (dirname && (strcmp (dirname, ".") != 0))
1164         {
1165           if (rl_complete_with_tilde_expansion && *users_dirname == '~')
1166             {
1167               int dirlen = strlen (dirname);
1168               temp = (char *)xmalloc (2 + dirlen + D_NAMLEN (entry));
1169               strcpy (temp, dirname);
1170               /* Canonicalization cuts off any final slash present.  We need
1171                  to add it back. */
1172               if (dirname[dirlen - 1] != '/')
1173                 {
1174                   temp[dirlen] = '/';
1175                   temp[dirlen + 1] = '\0';
1176                 }
1177             }
1178           else
1179             {
1180               temp = (char *)
1181                 xmalloc (1 + strlen (users_dirname) + D_NAMLEN (entry));
1182               strcpy (temp, users_dirname);
1183             }
1184
1185           strcat (temp, entry->d_name);
1186         }
1187       else
1188         {
1189           temp = (savestring (entry->d_name));
1190         }
1191       return (temp);
1192     }
1193 #endif
1194 }
1195
1196 /* A function for simple tilde expansion. */
1197 int
1198 rl_tilde_expand (ignore, key)
1199      int ignore, key;
1200 {
1201   register int start, end;
1202   char *homedir;
1203
1204   end = rl_point;
1205   start = end - 1;
1206
1207   if (rl_point == rl_end && rl_line_buffer[rl_point] == '~')
1208     {
1209       homedir = tilde_expand ("~");
1210       goto insert;
1211     }
1212   else if (rl_line_buffer[start] != '~')
1213     {
1214       for (; !whitespace (rl_line_buffer[start]) && start >= 0; start--);
1215       start++;
1216     }
1217
1218   end = start;
1219   do
1220     {
1221       end++;
1222     }
1223   while (!whitespace (rl_line_buffer[end]) && end < rl_end);
1224
1225   if (whitespace (rl_line_buffer[end]) || end >= rl_end)
1226     end--;
1227
1228   /* If the first character of the current word is a tilde, perform
1229      tilde expansion and insert the result.  If not a tilde, do
1230      nothing. */
1231   if (rl_line_buffer[start] == '~')
1232     {
1233       char *temp;
1234       int len;
1235
1236       len = end - start + 1;
1237       temp = (char *)alloca (len + 1);
1238       strncpy (temp, rl_line_buffer + start, len);
1239       temp[len] = '\0';
1240       homedir = tilde_expand (temp);
1241
1242     insert:
1243       rl_begin_undo_group ();
1244       rl_delete_text (start, end + 1);
1245       rl_point = start;
1246       rl_insert_text (homedir);
1247       rl_end_undo_group ();
1248     }
1249
1250   return (0);
1251 }
1252
1253 /* Find the first occurrence in STRING1 of any character from STRING2.
1254    Return a pointer to the character in STRING1. */
1255 static char *
1256 rl_strpbrk (string1, string2)
1257      char *string1, *string2;
1258 {
1259   register char *scan;
1260
1261   for (; *string1; string1++)
1262     {
1263       for (scan = string2; *scan; scan++)
1264         {
1265           if (*string1 == *scan)
1266             {
1267               return (string1);
1268             }
1269         }
1270     }
1271   return ((char *)NULL);
1272 }
1273
1274 #if defined (STATIC_MALLOC)
1275 \f
1276 /* **************************************************************** */
1277 /*                                                                  */
1278 /*                      xmalloc and xrealloc ()                     */
1279 /*                                                                  */
1280 /* **************************************************************** */
1281
1282 static void memory_error_and_abort ();
1283
1284 static char *
1285 xmalloc (bytes)
1286      int bytes;
1287 {
1288   char *temp = (char *)malloc (bytes);
1289
1290   if (!temp)
1291     memory_error_and_abort ();
1292   return (temp);
1293 }
1294
1295 static char *
1296 xrealloc (pointer, bytes)
1297      char *pointer;
1298      int bytes;
1299 {
1300   char *temp;
1301
1302   if (!pointer)
1303     temp = (char *)malloc (bytes);
1304   else
1305     temp = (char *)realloc (pointer, bytes);
1306
1307   if (!temp)
1308     memory_error_and_abort ();
1309
1310   return (temp);
1311 }
1312
1313 static void
1314 memory_error_and_abort ()
1315 {
1316   fprintf (stderr, "readline: Out of virtual memory!\n");
1317   abort ();
1318 }
1319 #endif /* STATIC_MALLOC */