contrib/libedit/filecomplete.c

   1 /*      $NetBSD: filecomplete.c,v 1.72 2023/02/03 22:01:42 christos Exp $       */
   2
   3 /*-
   4  * Copyright (c) 1997 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Jaromir Dolecek.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include "config.h"
  33 #if !defined(lint) && !defined(SCCSID)
  34 __RCSID("$NetBSD: filecomplete.c,v 1.72 2023/02/03 22:01:42 christos Exp $");
  35 #endif /* not lint && not SCCSID */
  36
  37 #include <sys/types.h>
  38 #include <sys/stat.h>
  39 #include <dirent.h>
  40 #include <errno.h>
  41 #include <fcntl.h>
  42 #include <limits.h>
  43 #include <pwd.h>
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <string.h>
  47 #include <unistd.h>
  48
  49 #include "el.h"
  50 #include "filecomplete.h"
  51
  52 static const wchar_t break_chars[] = L" \t\n\"\\'`@$><=;|&{(";
  53
  54 /********************************/
  55 /* completion functions */
  56
  57 /*
  58  * does tilde expansion of strings of type ``~user/foo''
  59  * if ``user'' isn't valid user name or ``txt'' doesn't start
  60  * w/ '~', returns pointer to strdup()ed copy of ``txt''
  61  *
  62  * it's the caller's responsibility to free() the returned string
  63  */
  64 char *
  65 fn_tilde_expand(const char *txt)
  66 {
  67 #if defined(HAVE_GETPW_R_POSIX) || defined(HAVE_GETPW_R_DRAFT)
  68         struct passwd pwres;
  69         char pwbuf[1024];
  70 #endif
  71         struct passwd *pass;
  72         const char *pos;
  73         char *temp;
  74         size_t len = 0;
  75
  76         if (txt[0] != '~')
  77                 return strdup(txt);
  78
  79         pos = strchr(txt + 1, '/');
  80         if (pos == NULL) {
  81                 temp = strdup(txt + 1);
  82                 if (temp == NULL)
  83                         return NULL;
  84         } else {
  85                 /* text until string after slash */
  86                 len = (size_t)(pos - txt + 1);
  87                 temp = el_calloc(len, sizeof(*temp));
  88                 if (temp == NULL)
  89                         return NULL;
  90                 (void)strlcpy(temp, txt + 1, len - 1);
  91         }
  92         if (temp[0] == 0) {
  93 #ifdef HAVE_GETPW_R_POSIX
  94                 if (getpwuid_r(getuid(), &pwres, pwbuf, sizeof(pwbuf),
  95                     &pass) != 0)
  96                         pass = NULL;
  97 #elif HAVE_GETPW_R_DRAFT
  98                 pass = getpwuid_r(getuid(), &pwres, pwbuf, sizeof(pwbuf));
  99 #else
 100                 pass = getpwuid(getuid());
 101 #endif
 102         } else {
 103 #ifdef HAVE_GETPW_R_POSIX
 104                 if (getpwnam_r(temp, &pwres, pwbuf, sizeof(pwbuf), &pass) != 0)
 105                         pass = NULL;
 106 #elif HAVE_GETPW_R_DRAFT
 107                 pass = getpwnam_r(temp, &pwres, pwbuf, sizeof(pwbuf));
 108 #else
 109                 pass = getpwnam(temp);
 110 #endif
 111         }
 112         el_free(temp);          /* value no more needed */
 113         if (pass == NULL)
 114                 return strdup(txt);
 115
 116         /* update pointer txt to point at string immedially following */
 117         /* first slash */
 118         txt += len;
 119
 120         len = strlen(pass->pw_dir) + 1 + strlen(txt) + 1;
 121         temp = el_calloc(len, sizeof(*temp));
 122         if (temp == NULL)
 123                 return NULL;
 124         (void)snprintf(temp, len, "%s/%s", pass->pw_dir, txt);
 125
 126         return temp;
 127 }
 128
 129 static int
 130 needs_escaping(wchar_t c)
 131 {
 132         switch (c) {
 133         case '\'':
 134         case '"':
 135         case '(':
 136         case ')':
 137         case '\\':
 138         case '<':
 139         case '>':
 140         case '$':
 141         case '#':
 142         case ' ':
 143         case '\n':
 144         case '\t':
 145         case '?':
 146         case ';':
 147         case '`':
 148         case '@':
 149         case '=':
 150         case '|':
 151         case '{':
 152         case '}':
 153         case '&':
 154         case '*':
 155         case '[':
 156                 return 1;
 157         default:
 158                 return 0;
 159         }
 160 }
 161
 162 static int
 163 needs_dquote_escaping(char c)
 164 {
 165         switch (c) {
 166         case '"':
 167         case '\\':
 168         case '`':
 169         case '$':
 170                 return 1;
 171         default:
 172                 return 0;
 173         }
 174 }
 175
 176
 177 static wchar_t *
 178 unescape_string(const wchar_t *string, size_t length)
 179 {
 180         size_t i;
 181         size_t j = 0;
 182         wchar_t *unescaped = el_calloc(length + 1, sizeof(*string));
 183         if (unescaped == NULL)
 184                 return NULL;
 185         for (i = 0; i < length ; i++) {
 186                 if (string[i] == '\\')
 187                         continue;
 188                 unescaped[j++] = string[i];
 189         }
 190         unescaped[j] = 0;
 191         return unescaped;
 192 }
 193
 194 static char *
 195 escape_filename(EditLine * el, const char *filename, int single_match,
 196                 const char *(*app_func)(const char *))
 197 {
 198         size_t original_len = 0;
 199         size_t escaped_character_count = 0;
 200         size_t offset = 0;
 201         size_t newlen;
 202         const char *s;
 203         char c;
 204         size_t s_quoted = 0;    /* does the input contain a single quote */
 205         size_t d_quoted = 0;    /* does the input contain a double quote */
 206         char *escaped_str;
 207         wchar_t *temp = el->el_line.buffer;
 208         const char *append_char = NULL;
 209
 210         if (filename == NULL)
 211                 return NULL;
 212
 213         while (temp != el->el_line.cursor) {
 214                 /*
 215                  * If we see a single quote but have not seen a double quote
 216                  * so far set/unset s_quote, unless it is already quoted
 217                  */
 218                 if (temp[0] == '\'' && !d_quoted &&
 219                     (temp == el->el_line.buffer || temp[-1] != '\\'))
 220                         s_quoted = !s_quoted;
 221                 /*
 222                  * vice versa to the above condition
 223                  */
 224                 else if (temp[0] == '"' && !s_quoted)
 225                         d_quoted = !d_quoted;
 226                 temp++;
 227         }
 228
 229         /* Count number of special characters so that we can calculate
 230          * number of extra bytes needed in the new string
 231          */
 232         for (s = filename; *s; s++, original_len++) {
 233                 c = *s;
 234                 /* Inside a single quote only single quotes need escaping */
 235                 if (s_quoted && c == '\'') {
 236                         escaped_character_count += 3;
 237                         continue;
 238                 }
 239                 /* Inside double quotes only ", \, ` and $ need escaping */
 240                 if (d_quoted && needs_dquote_escaping(c)) {
 241                         escaped_character_count++;
 242                         continue;
 243                 }
 244                 if (!s_quoted && !d_quoted && needs_escaping(c))
 245                         escaped_character_count++;
 246         }
 247
 248         newlen = original_len + escaped_character_count + 1;
 249         if (s_quoted || d_quoted)
 250                 newlen++;
 251
 252         if (single_match && app_func)
 253                 newlen++;
 254
 255         if ((escaped_str = el_malloc(newlen)) == NULL)
 256                 return NULL;
 257
 258         for (s = filename; *s; s++) {
 259                 c = *s;
 260                 if (!needs_escaping(c)) {
 261                         /* no escaping is required continue as usual */
 262                         escaped_str[offset++] = c;
 263                         continue;
 264                 }
 265
 266                 /* single quotes inside single quotes require special handling */
 267                 if (c == '\'' && s_quoted) {
 268                         escaped_str[offset++] = '\'';
 269                         escaped_str[offset++] = '\\';
 270                         escaped_str[offset++] = '\'';
 271                         escaped_str[offset++] = '\'';
 272                         continue;
 273                 }
 274
 275                 /* Otherwise no escaping needed inside single quotes */
 276                 if (s_quoted) {
 277                         escaped_str[offset++] = c;
 278                         continue;
 279                 }
 280
 281                 /* No escaping needed inside a double quoted string either
 282                  * unless we see a '$', '\', '`', or '"' (itself)
 283                  */
 284                 if (d_quoted && !needs_dquote_escaping(c)) {
 285                         escaped_str[offset++] = c;
 286                         continue;
 287                 }
 288
 289                 /* If we reach here that means escaping is actually needed */
 290                 escaped_str[offset++] = '\\';
 291                 escaped_str[offset++] = c;
 292         }
 293
 294         if (single_match && app_func) {
 295                 escaped_str[offset] = 0;
 296                 append_char = app_func(filename);
 297                 /* we want to append space only if we are not inside quotes */
 298                 if (append_char[0] == ' ') {
 299                         if (!s_quoted && !d_quoted)
 300                                 escaped_str[offset++] = append_char[0];
 301                 } else
 302                         escaped_str[offset++] = append_char[0];
 303         }
 304
 305         /* close the quotes if single match and the match is not a directory */
 306         if (single_match && (append_char && append_char[0] == ' ')) {
 307                 if (s_quoted)
 308                         escaped_str[offset++] = '\'';
 309                 else if (d_quoted)
 310                         escaped_str[offset++] = '"';
 311         }
 312
 313         escaped_str[offset] = 0;
 314         return escaped_str;
 315 }
 316
 317 /*
 318  * return first found file name starting by the ``text'' or NULL if no
 319  * such file can be found
 320  * value of ``state'' is ignored
 321  *
 322  * it's the caller's responsibility to free the returned string
 323  */
 324 char *
 325 fn_filename_completion_function(const char *text, int state)
 326 {
 327         static DIR *dir = NULL;
 328         static char *filename = NULL, *dirname = NULL, *dirpath = NULL;
 329         static size_t filename_len = 0;
 330         struct dirent *entry;
 331         char *temp;
 332         const char *pos;
 333         size_t len;
 334
 335         if (state == 0 || dir == NULL) {
 336                 pos = strrchr(text, '/');
 337                 if (pos) {
 338                         char *nptr;
 339                         pos++;
 340                         nptr = el_realloc(filename, (strlen(pos) + 1) *
 341                             sizeof(*nptr));
 342                         if (nptr == NULL) {
 343                                 el_free(filename);
 344                                 filename = NULL;
 345                                 return NULL;
 346                         }
 347                         filename = nptr;
 348                         (void)strcpy(filename, pos);
 349                         len = (size_t)(pos - text);     /* including last slash */
 350
 351                         nptr = el_realloc(dirname, (len + 1) *
 352                             sizeof(*nptr));
 353                         if (nptr == NULL) {
 354                                 el_free(dirname);
 355                                 dirname = NULL;
 356                                 return NULL;
 357                         }
 358                         dirname = nptr;
 359                         (void)strlcpy(dirname, text, len + 1);
 360                 } else {
 361                         el_free(filename);
 362                         if (*text == 0)
 363                                 filename = NULL;
 364                         else {
 365                                 filename = strdup(text);
 366                                 if (filename == NULL)
 367                                         return NULL;
 368                         }
 369                         el_free(dirname);
 370                         dirname = NULL;
 371                 }
 372
 373                 if (dir != NULL) {
 374                         (void)closedir(dir);
 375                         dir = NULL;
 376                 }
 377
 378                 /* support for ``~user'' syntax */
 379
 380                 el_free(dirpath);
 381                 dirpath = NULL;
 382                 if (dirname == NULL) {
 383                         if ((dirname = strdup("")) == NULL)
 384                                 return NULL;
 385                         dirpath = strdup("./");
 386                 } else if (*dirname == '~')
 387                         dirpath = fn_tilde_expand(dirname);
 388                 else
 389                         dirpath = strdup(dirname);
 390
 391                 if (dirpath == NULL)
 392                         return NULL;
 393
 394                 dir = opendir(dirpath);
 395                 if (!dir)
 396                         return NULL;    /* cannot open the directory */
 397
 398                 /* will be used in cycle */
 399                 filename_len = filename ? strlen(filename) : 0;
 400         }
 401
 402         /* find the match */
 403         while ((entry = readdir(dir)) != NULL) {
 404                 /* skip . and .. */
 405                 if (entry->d_name[0] == '.' && (!entry->d_name[1]
 406                     || (entry->d_name[1] == '.' && !entry->d_name[2])))
 407                         continue;
 408                 if (filename_len == 0)
 409                         break;
 410                 /* otherwise, get first entry where first */
 411                 /* filename_len characters are equal      */
 412                 if (entry->d_name[0] == filename[0]
 413 #if HAVE_STRUCT_DIRENT_D_NAMLEN
 414                     && entry->d_namlen >= filename_len
 415 #else
 416                     && strlen(entry->d_name) >= filename_len
 417 #endif
 418                     && strncmp(entry->d_name, filename,
 419                         filename_len) == 0)
 420                         break;
 421         }
 422
 423         if (entry) {            /* match found */
 424
 425 #if HAVE_STRUCT_DIRENT_D_NAMLEN
 426                 len = entry->d_namlen;
 427 #else
 428                 len = strlen(entry->d_name);
 429 #endif
 430
 431                 len = strlen(dirname) + len + 1;
 432                 temp = el_calloc(len, sizeof(*temp));
 433                 if (temp == NULL)
 434                         return NULL;
 435                 (void)snprintf(temp, len, "%s%s", dirname, entry->d_name);
 436         } else {
 437                 (void)closedir(dir);
 438                 dir = NULL;
 439                 temp = NULL;
 440         }
 441
 442         return temp;
 443 }
 444
 445
 446 static const char *
 447 append_char_function(const char *name)
 448 {
 449         struct stat stbuf;
 450         char *expname = *name == '~' ? fn_tilde_expand(name) : NULL;
 451         const char *rs = " ";
 452
 453         if (stat(expname ? expname : name, &stbuf) == -1)
 454                 goto out;
 455         if (S_ISDIR(stbuf.st_mode))
 456                 rs = "/";
 457 out:
 458         if (expname)
 459                 el_free(expname);
 460         return rs;
 461 }
 462 /*
 463  * returns list of completions for text given
 464  * non-static for readline.
 465  */
 466 char ** completion_matches(const char *, char *(*)(const char *, int));
 467 char **
 468 completion_matches(const char *text, char *(*genfunc)(const char *, int))
 469 {
 470         char **match_list = NULL, *retstr, *prevstr;
 471         size_t match_list_len, max_equal, which, i;
 472         size_t matches;
 473
 474         matches = 0;
 475         match_list_len = 1;
 476         while ((retstr = (*genfunc) (text, (int)matches)) != NULL) {
 477                 /* allow for list terminator here */
 478                 if (matches + 3 >= match_list_len) {
 479                         char **nmatch_list;
 480                         while (matches + 3 >= match_list_len)
 481                                 match_list_len <<= 1;
 482                         nmatch_list = el_realloc(match_list,
 483                             match_list_len * sizeof(*nmatch_list));
 484                         if (nmatch_list == NULL) {
 485                                 el_free(match_list);
 486                                 return NULL;
 487                         }
 488                         match_list = nmatch_list;
 489
 490                 }
 491                 match_list[++matches] = retstr;
 492         }
 493
 494         if (!match_list)
 495                 return NULL;    /* nothing found */
 496
 497         /* find least denominator and insert it to match_list[0] */
 498         which = 2;
 499         prevstr = match_list[1];
 500         max_equal = strlen(prevstr);
 501         for (; which <= matches; which++) {
 502                 for (i = 0; i < max_equal &&
 503                     prevstr[i] == match_list[which][i]; i++)
 504                         continue;
 505                 max_equal = i;
 506         }
 507
 508         retstr = el_calloc(max_equal + 1, sizeof(*retstr));
 509         if (retstr == NULL) {
 510                 el_free(match_list);
 511                 return NULL;
 512         }
 513         (void)strlcpy(retstr, match_list[1], max_equal + 1);
 514         match_list[0] = retstr;
 515
 516         /* add NULL as last pointer to the array */
 517         match_list[matches + 1] = NULL;
 518
 519         return match_list;
 520 }
 521
 522 /*
 523  * Sort function for qsort(). Just wrapper around strcasecmp().
 524  */
 525 static int
 526 _fn_qsort_string_compare(const void *i1, const void *i2)
 527 {
 528         const char *s1 = ((const char * const *)i1)[0];
 529         const char *s2 = ((const char * const *)i2)[0];
 530
 531         return strcasecmp(s1, s2);
 532 }
 533
 534 /*
 535  * Display list of strings in columnar format on readline's output stream.
 536  * 'matches' is list of strings, 'num' is number of strings in 'matches',
 537  * 'width' is maximum length of string in 'matches'.
 538  *
 539  * matches[0] is not one of the match strings, but it is counted in
 540  * num, so the strings are matches[1] *through* matches[num-1].
 541  */
 542 void
 543 fn_display_match_list(EditLine * el, char **matches, size_t num, size_t width,
 544     const char *(*app_func) (const char *))
 545 {
 546         size_t line, lines, col, cols, thisguy;
 547         int screenwidth = el->el_terminal.t_size.h;
 548         if (app_func == NULL)
 549                 app_func = append_char_function;
 550
 551         /* Ignore matches[0]. Avoid 1-based array logic below. */
 552         matches++;
 553         num--;
 554
 555         /*
 556          * Find out how many entries can be put on one line; count
 557          * with one space between strings the same way it's printed.
 558          */
 559         cols = (size_t)screenwidth / (width + 2);
 560         if (cols == 0)
 561                 cols = 1;
 562
 563         /* how many lines of output, rounded up */
 564         lines = (num + cols - 1) / cols;
 565
 566         /* Sort the items. */
 567         qsort(matches, num, sizeof(char *), _fn_qsort_string_compare);
 568
 569         /*
 570          * On the ith line print elements i, i+lines, i+lines*2, etc.
 571          */
 572         for (line = 0; line < lines; line++) {
 573                 for (col = 0; col < cols; col++) {
 574                         thisguy = line + col * lines;
 575                         if (thisguy >= num)
 576                                 break;
 577                         (void)fprintf(el->el_outfile, "%s%s%s",
 578                             col == 0 ? "" : " ", matches[thisguy],
 579                                 (*app_func)(matches[thisguy]));
 580                         (void)fprintf(el->el_outfile, "%-*s",
 581                                 (int) (width - strlen(matches[thisguy])), "");
 582                 }
 583                 (void)fprintf(el->el_outfile, "\n");
 584         }
 585 }
 586
 587 static wchar_t *
 588 find_word_to_complete(const wchar_t * cursor, const wchar_t * buffer,
 589     const wchar_t * word_break, const wchar_t * special_prefixes, size_t * length,
 590         int do_unescape)
 591 {
 592         /* We now look backwards for the start of a filename/variable word */
 593         const wchar_t *ctemp = cursor;
 594         wchar_t *temp;
 595         size_t len;
 596
 597         /* if the cursor is placed at a slash or a quote, we need to find the
 598          * word before it
 599          */
 600         if (ctemp > buffer) {
 601                 switch (ctemp[-1]) {
 602                 case '\\':
 603                 case '\'':
 604                 case '"':
 605                         ctemp--;
 606                         break;
 607                 default:
 608                         break;
 609                 }
 610         }
 611
 612         for (;;) {
 613                 if (ctemp <= buffer)
 614                         break;
 615                 if (ctemp - buffer >= 2 && ctemp[-2] == '\\' &&
 616                     needs_escaping(ctemp[-1])) {
 617                         ctemp -= 2;
 618                         continue;
 619                 }
 620                 if (wcschr(word_break, ctemp[-1]))
 621                         break;
 622                 if (special_prefixes && wcschr(special_prefixes, ctemp[-1]))
 623                         break;
 624                 ctemp--;
 625         }
 626
 627         len = (size_t) (cursor - ctemp);
 628         if (len == 1 && (ctemp[0] == '\'' || ctemp[0] == '"')) {
 629                 len = 0;
 630                 ctemp++;
 631         }
 632         *length = len;
 633         if (do_unescape) {
 634                 wchar_t *unescaped_word = unescape_string(ctemp, len);
 635                 if (unescaped_word == NULL)
 636                         return NULL;
 637                 return unescaped_word;
 638         }
 639         temp = el_malloc((len + 1) * sizeof(*temp));
 640         if (temp == NULL)
 641                 return NULL;
 642         (void) wcsncpy(temp, ctemp, len);
 643         temp[len] = '\0';
 644         return temp;
 645 }
 646
 647 /*
 648  * Complete the word at or before point,
 649  * 'what_to_do' says what to do with the completion.
 650  * \t   means do standard completion.
 651  * `?' means list the possible completions.
 652  * `*' means insert all of the possible completions.
 653  * `!' means to do standard completion, and list all possible completions if
 654  * there is more than one.
 655  *
 656  * Note: '*' support is not implemented
 657  *       '!' could never be invoked
 658  */
 659 int
 660 fn_complete2(EditLine *el,
 661     char *(*complete_func)(const char *, int),
 662     char **(*attempted_completion_function)(const char *, int, int),
 663     const wchar_t *word_break, const wchar_t *special_prefixes,
 664     const char *(*app_func)(const char *), size_t query_items,
 665     int *completion_type, int *over, int *point, int *end,
 666     unsigned int flags)
 667 {
 668         const LineInfoW *li;
 669         wchar_t *temp;
 670         char **matches;
 671         char *completion;
 672         size_t len;
 673         int what_to_do = '\t';
 674         int retval = CC_NORM;
 675         int do_unescape = flags & FN_QUOTE_MATCH;
 676
 677         if (el->el_state.lastcmd == el->el_state.thiscmd)
 678                 what_to_do = '?';
 679
 680         /* readline's rl_complete() has to be told what we did... */
 681         if (completion_type != NULL)
 682                 *completion_type = what_to_do;
 683
 684         if (!complete_func)
 685                 complete_func = fn_filename_completion_function;
 686         if (!app_func)
 687                 app_func = append_char_function;
 688
 689         li = el_wline(el);
 690         temp = find_word_to_complete(li->cursor,
 691             li->buffer, word_break, special_prefixes, &len, do_unescape);
 692         if (temp == NULL)
 693                 goto out;
 694
 695         /* these can be used by function called in completion_matches() */
 696         /* or (*attempted_completion_function)() */
 697         if (point != NULL)
 698                 *point = (int)(li->cursor - li->buffer);
 699         if (end != NULL)
 700                 *end = (int)(li->lastchar - li->buffer);
 701
 702         if (attempted_completion_function) {
 703                 int cur_off = (int)(li->cursor - li->buffer);
 704                 matches = (*attempted_completion_function)(
 705                     ct_encode_string(temp, &el->el_scratch),
 706                     cur_off - (int)len, cur_off);
 707         } else
 708                 matches = NULL;
 709         if (!attempted_completion_function ||
 710             (over != NULL && !*over && !matches))
 711                 matches = completion_matches(
 712                     ct_encode_string(temp, &el->el_scratch), complete_func);
 713
 714         if (over != NULL)
 715                 *over = 0;
 716
 717         if (matches == NULL) {
 718                 goto out;
 719         }
 720         int i;
 721         size_t matches_num, maxlen, match_len, match_display=1;
 722         int single_match = matches[2] == NULL &&
 723                 (matches[1] == NULL || strcmp(matches[0], matches[1]) == 0);
 724
 725         retval = CC_REFRESH;
 726
 727         if (matches[0][0] != '\0') {
 728                 el_deletestr(el, (int)len);
 729                 if (flags & FN_QUOTE_MATCH)
 730                         completion = escape_filename(el, matches[0],
 731                             single_match, app_func);
 732                 else
 733                         completion = strdup(matches[0]);
 734                 if (completion == NULL)
 735                         goto out2;
 736
 737                 /*
 738                  * Replace the completed string with the common part of
 739                  * all possible matches if there is a possible completion.
 740                  */
 741                 el_winsertstr(el,
 742                     ct_decode_string(completion, &el->el_scratch));
 743
 744                 if (single_match && attempted_completion_function &&
 745                     !(flags & FN_QUOTE_MATCH))
 746                 {
 747                         /*
 748                          * We found an exact match. Add a space after
 749                          * it, unless we do filename completion and the
 750                          * object is a directory. Also do necessary
 751                          * escape quoting
 752                          */
 753                         el_winsertstr(el, ct_decode_string(
 754                             (*app_func)(completion), &el->el_scratch));
 755                 }
 756                 free(completion);
 757         }
 758
 759
 760         if (!single_match && (what_to_do == '!' || what_to_do == '?')) {
 761                 /*
 762                  * More than one match and requested to list possible
 763                  * matches.
 764                  */
 765
 766                 for(i = 1, maxlen = 0; matches[i]; i++) {
 767                         match_len = strlen(matches[i]);
 768                         if (match_len > maxlen)
 769                                 maxlen = match_len;
 770                 }
 771                 /* matches[1] through matches[i-1] are available */
 772                 matches_num = (size_t)(i - 1);
 773
 774                 /* newline to get on next line from command line */
 775                 (void)fprintf(el->el_outfile, "\n");
 776
 777                 /*
 778                  * If there are too many items, ask user for display
 779                  * confirmation.
 780                  */
 781                 if (matches_num > query_items) {
 782                         (void)fprintf(el->el_outfile,
 783                             "Display all %zu possibilities? (y or n) ",
 784                             matches_num);
 785                         (void)fflush(el->el_outfile);
 786                         if (getc(stdin) != 'y')
 787                                 match_display = 0;
 788                         (void)fprintf(el->el_outfile, "\n");
 789                 }
 790
 791                 if (match_display) {
 792                         /*
 793                          * Interface of this function requires the
 794                          * strings be matches[1..num-1] for compat.
 795                          * We have matches_num strings not counting
 796                          * the prefix in matches[0], so we need to
 797                          * add 1 to matches_num for the call.
 798                          */
 799                         fn_display_match_list(el, matches,
 800                             matches_num+1, maxlen, app_func);
 801                 }
 802                 retval = CC_REDISPLAY;
 803         } else if (matches[0][0]) {
 804                 /*
 805                  * There was some common match, but the name was
 806                  * not complete enough. Next tab will print possible
 807                  * completions.
 808                  */
 809                 el_beep(el);
 810         } else {
 811                 /* lcd is not a valid object - further specification */
 812                 /* is needed */
 813                 el_beep(el);
 814                 retval = CC_NORM;
 815         }
 816
 817         /* free elements of array and the array itself */
 818 out2:
 819         for (i = 0; matches[i]; i++)
 820                 el_free(matches[i]);
 821         el_free(matches);
 822         matches = NULL;
 823
 824 out:
 825         el_free(temp);
 826         return retval;
 827 }
 828
 829 int
 830 fn_complete(EditLine *el,
 831     char *(*complete_func)(const char *, int),
 832     char **(*attempted_completion_function)(const char *, int, int),
 833     const wchar_t *word_break, const wchar_t *special_prefixes,
 834     const char *(*app_func)(const char *), size_t query_items,
 835     int *completion_type, int *over, int *point, int *end)
 836 {
 837         return fn_complete2(el, complete_func, attempted_completion_function,
 838             word_break, special_prefixes, app_func, query_items,
 839             completion_type, over, point, end,
 840             attempted_completion_function ? 0 : FN_QUOTE_MATCH);
 841 }
 842
 843 /*
 844  * el-compatible wrapper around rl_complete; needed for key binding
 845  */
 846 /* ARGSUSED */
 847 unsigned char
 848 _el_fn_complete(EditLine *el, int ch __attribute__((__unused__)))
 849 {
 850         return (unsigned char)fn_complete(el, NULL, NULL,
 851             break_chars, NULL, NULL, (size_t)100,
 852             NULL, NULL, NULL, NULL);
 853 }
 854
 855 /*
 856  * el-compatible wrapper around rl_complete; needed for key binding
 857  */
 858 /* ARGSUSED */
 859 unsigned char
 860 _el_fn_sh_complete(EditLine *el, int ch)
 861 {
 862         return _el_fn_complete(el, ch);
 863 }