main/editline/readline.c

   1 /*      $NetBSD: readline.c,v 1.21 2002/03/18 16:20:36 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  * 3. All advertising materials mentioning features or use of this software
  19  *    must display the following acknowledgement:
  20  *      This product includes software developed by the NetBSD
  21  *      Foundation, Inc. and its contributors.
  22  * 4. Neither the name of The NetBSD Foundation nor the names of its
  23  *    contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  27  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  28  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  29  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  30  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  31  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  32  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  33  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  34  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  35  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  36  * POSSIBILITY OF SUCH DAMAGE.
  37  */
  38
  39 #include "asterisk.h"
  40 #include "config.h"
  41 #if !defined(lint) && !defined(SCCSID)
  42 __RCSID("$NetBSD: readline.c,v 1.21 2002/03/18 16:20:36 christos Exp $");
  43 #endif /* not lint && not SCCSID */
  44
  45 #include <sys/types.h>
  46 #include <sys/stat.h>
  47 #include <stdio.h>
  48 #include <dirent.h>
  49 #include <string.h>
  50 #include <pwd.h>
  51 #include <ctype.h>
  52 #include <stdlib.h>
  53 #include <unistd.h>
  54 #include <limits.h>
  55
  56 #ifdef SOLARIS
  57 #include <alloca.h>
  58 #endif
  59
  60 #include "histedit.h"
  61 #include "readline.h"
  62 #include "el.h"
  63 #include "fcns.h"               /* for EL_NUM_FCNS */
  64
  65 /* for rl_complete() */
  66 #define TAB             '\r'
  67
  68 /* see comment at the #ifdef for sense of this */
  69 #define GDB_411_HACK
  70
  71 /* readline compatibility stuff - look at readline sources/documentation */
  72 /* to see what these variables mean */
  73 const char *rl_library_version = "EditLine wrapper";
  74 static char empty[] = { '\0' };
  75 static char expand_chars[] = { ' ', '\t', '\n', '=', '(', '\0' };
  76 static char break_chars[] = { ' ', '\t', '\n', '"', '\\', '\'', '`', '@', '$',
  77     '>', '<', '=', ';', '|', '&', '{', '(', '\0' };
  78 char *rl_readline_name = empty;
  79 FILE *rl_instream = NULL;
  80 FILE *rl_outstream = NULL;
  81 int rl_point = 0;
  82 int rl_end = 0;
  83 char *rl_line_buffer = NULL;
  84
  85 int history_base = 1;           /* probably never subject to change */
  86 int history_length = 0;
  87 int max_input_history = 0;
  88 char history_expansion_char = '!';
  89 char history_subst_char = '^';
  90 char *history_no_expand_chars = expand_chars;
  91 Function *history_inhibit_expansion_function = NULL;
  92
  93 int rl_inhibit_completion = 0;
  94 int rl_attempted_completion_over = 0;
  95 char *rl_basic_word_break_characters = break_chars;
  96 char *rl_completer_word_break_characters = NULL;
  97 char *rl_completer_quote_characters = NULL;
  98 CPFunction *rl_completion_entry_function = NULL;
  99 CPPFunction *rl_attempted_completion_function = NULL;
 100
 101 /*
 102  * This is set to character indicating type of completion being done by
 103  * rl_complete_internal(); this is available for application completion
 104  * functions.
 105  */
 106 int rl_completion_type = 0;
 107
 108 /*
 109  * If more than this number of items results from query for possible
 110  * completions, we ask user if they are sure to really display the list.
 111  */
 112 int rl_completion_query_items = 100;
 113
 114 /*
 115  * List of characters which are word break characters, but should be left
 116  * in the parsed text when it is passed to the completion function.
 117  * Shell uses this to help determine what kind of completing to do.
 118  */
 119 char *rl_special_prefixes = (char *)NULL;
 120
 121 /*
 122  * This is the character appended to the completed words if at the end of
 123  * the line. Default is ' ' (a space).
 124  */
 125 int rl_completion_append_character = ' ';
 126
 127 /* stuff below is used internally by libedit for readline emulation */
 128
 129 /* if not zero, non-unique completions always show list of possible matches */
 130 static int _rl_complete_show_all = 0;
 131
 132 static History *h = NULL;
 133 static EditLine *e = NULL;
 134 static int el_rl_complete_cmdnum = 0;
 135
 136 /* internal functions */
 137 static unsigned char     _el_rl_complete(EditLine *, int);
 138 static char             *_get_prompt(EditLine *);
 139 static HIST_ENTRY       *_move_history(int);
 140 static int               _history_search_gen(const char *, int, int);
 141 static int               _history_expand_command(const char *, size_t, char **);
 142 static char             *_rl_compat_sub(const char *, const char *,
 143                             const char *, int);
 144 static int               rl_complete_internal(int);
 145 static int               _rl_qsort_string_compare(const void *, const void *);
 146
 147 /*
 148  * needed for prompt switching in readline()
 149  */
 150 static char *el_rl_prompt = NULL;
 151
 152
 153 /* ARGSUSED */
 154 static char *
 155 _get_prompt(EditLine *el)
 156 {
 157         return (el_rl_prompt);
 158 }
 159
 160
 161 /*
 162  * generic function for moving around history
 163  */
 164 static HIST_ENTRY *
 165 _move_history(int op)
 166 {
 167         HistEvent ev;
 168         static HIST_ENTRY rl_he;
 169
 170         if (history(h, &ev, op) != 0)
 171                 return (HIST_ENTRY *) NULL;
 172
 173         rl_he.line = ev.str;
 174         rl_he.data = "";
 175
 176         return (&rl_he);
 177 }
 178
 179
 180 /*
 181  * READLINE compatibility stuff
 182  */
 183
 184 /*
 185  * initialize rl compat stuff
 186  */
 187 int
 188 rl_initialize(void)
 189 {
 190         HistEvent ev;
 191         const LineInfo *li;
 192         int i;
 193         int editmode = 1;
 194         struct termios t;
 195
 196         if (e != NULL)
 197                 el_end(e);
 198         if (h != NULL)
 199                 history_end(h);
 200
 201         if (!rl_instream)
 202                 rl_instream = stdin;
 203         if (!rl_outstream)
 204                 rl_outstream = stdout;
 205
 206         /*
 207          * See if we don't really want to run the editor
 208          */
 209         if (tcgetattr(fileno(rl_instream), &t) != -1 && (t.c_lflag & ECHO) == 0)
 210                 editmode = 0;
 211
 212         e = el_init(rl_readline_name, rl_instream, rl_outstream, stderr);
 213
 214         if (!editmode)
 215                 el_set(e, EL_EDITMODE, 0);
 216
 217         h = history_init();
 218         if (!e || !h)
 219                 return (-1);
 220
 221         history(h, &ev, H_SETSIZE, INT_MAX);    /* unlimited */
 222         history_length = 0;
 223         max_input_history = INT_MAX;
 224         el_set(e, EL_HIST, history, h);
 225
 226         /* for proper prompt printing in readline() */
 227         el_rl_prompt = strdup("");
 228         el_set(e, EL_PROMPT, _get_prompt);
 229         el_set(e, EL_SIGNAL, 1);
 230
 231         /* set default mode to "emacs"-style and read setting afterwards */
 232         /* so this can be overriden */
 233         el_set(e, EL_EDITOR, "emacs");
 234
 235         /*
 236          * Word completition - this has to go AFTER rebinding keys
 237          * to emacs-style.
 238          */
 239         el_set(e, EL_ADDFN, "rl_complete",
 240             "ReadLine compatible completition function",
 241             _el_rl_complete);
 242         el_set(e, EL_BIND, "^I", "rl_complete", NULL);
 243
 244         /*
 245          * Find out where the rl_complete function was added; this is
 246          * used later to detect that lastcmd was also rl_complete.
 247          */
 248         for(i=EL_NUM_FCNS; i < e->el_map.nfunc; i++) {
 249                 if (e->el_map.func[i] == _el_rl_complete) {
 250                         el_rl_complete_cmdnum = i;
 251                         break;
 252                 }
 253         }
 254
 255         /* read settings from configuration file */
 256         el_source(e, NULL);
 257
 258         /*
 259          * Unfortunately, some applications really do use rl_point
 260          * and rl_line_buffer directly.
 261          */
 262         li = el_line(e);
 263         /* a cheesy way to get rid of const cast. */
 264         rl_line_buffer = memchr(li->buffer, *li->buffer, 1);
 265         rl_point = rl_end = 0;
 266
 267         return (0);
 268 }
 269
 270
 271 /*
 272  * read one line from input stream and return it, chomping
 273  * trailing newline (if there is any)
 274  */
 275 char *
 276 readline(const char *prompt)
 277 {
 278         HistEvent ev;
 279         int count;
 280         const char *ret;
 281         char *buf;
 282
 283         if (e == NULL || h == NULL)
 284                 rl_initialize();
 285
 286         /* update prompt accordingly to what has been passed */
 287         if (!prompt)
 288                 prompt = "";
 289         if (strcmp(el_rl_prompt, prompt) != 0) {
 290                 free(el_rl_prompt);
 291                 el_rl_prompt = strdup(prompt);
 292         }
 293         /* get one line from input stream */
 294         ret = el_gets(e, &count);
 295
 296         if (ret && count > 0) {
 297                 int lastidx;
 298
 299                 buf = strdup(ret);
 300                 lastidx = count - 1;
 301                 if (buf[lastidx] == '\n')
 302                         buf[lastidx] = '\0';
 303         } else
 304                 buf = NULL;
 305
 306         history(h, &ev, H_GETSIZE);
 307         history_length = ev.num;
 308
 309         return buf;
 310 }
 311
 312 /*
 313  * history functions
 314  */
 315
 316 /*
 317  * is normally called before application starts to use
 318  * history expansion functions
 319  */
 320 void
 321 using_history(void)
 322 {
 323         if (h == NULL || e == NULL)
 324                 rl_initialize();
 325 }
 326
 327
 328 /*
 329  * substitute ``what'' with ``with'', returning resulting string; if
 330  * globally == 1, substitutes all occurences of what, otherwise only the
 331  * first one
 332  */
 333 static char *
 334 _rl_compat_sub(const char *str, const char *what, const char *with,
 335     int globally)
 336 {
 337         char *result;
 338         const char *temp, *new;
 339         int len, with_len, what_len, add;
 340         size_t size, i;
 341
 342         result = malloc((size = 16));
 343         temp = str;
 344         with_len = strlen(with);
 345         what_len = strlen(what);
 346         len = 0;
 347         do {
 348                 new = strstr(temp, what);
 349                 if (new) {
 350                         i = new - temp;
 351                         add = i + with_len;
 352                         if (i + add + 1 >= size) {
 353                                 size += add + 1;
 354                                 result = realloc(result, size);
 355                         }
 356                         (void) strncpy(&result[len], temp, i);
 357                         len += i;
 358                         (void) strcpy(&result[len], with);      /* safe */
 359                         len += with_len;
 360                         temp = new + what_len;
 361                 } else {
 362                         add = strlen(temp);
 363                         if (len + add + 1 >= size) {
 364                                 size += add + 1;
 365                                 result = realloc(result, size);
 366                         }
 367                         (void) strcpy(&result[len], temp);      /* safe */
 368                         len += add;
 369                         temp = NULL;
 370                 }
 371         } while (temp && globally);
 372         result[len] = '\0';
 373
 374         return (result);
 375 }
 376
 377
 378 /*
 379  * the real function doing history expansion - takes as argument command
 380  * to do and data upon which the command should be executed
 381  * does expansion the way I've understood readline documentation
 382  * word designator ``%'' isn't supported (yet ?)
 383  *
 384  * returns 0 if data was not modified, 1 if it was and 2 if the string
 385  * should be only printed and not executed; in case of error,
 386  * returns -1 and *result points to NULL
 387  * it's callers responsibility to free() string returned in *result
 388  */
 389 static int
 390 _history_expand_command(const char *command, size_t cmdlen, char **result)
 391 {
 392         char **arr, *tempcmd, *line, *search = NULL, *cmd;
 393         const char *event_data = NULL;
 394         static char *from = NULL, *to = NULL;
 395         int start = -1, end = -1, max, i, idx;
 396         int h_on = 0, t_on = 0, r_on = 0, e_on = 0, p_on = 0, g_on = 0;
 397         int event_num = 0, retval;
 398         size_t cmdsize;
 399
 400         *result = NULL;
 401
 402         cmd = alloca(cmdlen + 1);
 403         (void) strncpy(cmd, command, cmdlen);
 404         cmd[cmdlen] = 0;
 405
 406         idx = 1;
 407         /* find out which event to take */
 408         if (cmd[idx] == history_expansion_char) {
 409                 event_num = history_length;
 410                 idx++;
 411         } else {
 412                 int off, num;
 413                 size_t len;
 414                 off = idx;
 415                 while (cmd[off] && !strchr(":^$*-%", cmd[off]))
 416                         off++;
 417                 num = atoi(&cmd[idx]);
 418                 if (num != 0) {
 419                         event_num = num;
 420                         if (num < 0)
 421                                 event_num += history_length + 1;
 422                 } else {
 423                         int prefix = 1, curr_num;
 424                         HistEvent ev;
 425
 426                         len = off - idx;
 427                         if (cmd[idx] == '?') {
 428                                 idx++, len--;
 429                                 if (cmd[off - 1] == '?')
 430                                         len--;
 431                                 else if (cmd[off] != '\n' && cmd[off] != '\0')
 432                                         return (-1);
 433                                 prefix = 0;
 434                         }
 435                         search = alloca(len + 1);
 436                         (void) strncpy(search, &cmd[idx], len);
 437                         search[len] = '\0';
 438
 439                         if (history(h, &ev, H_CURR) != 0)
 440                                 return (-1);
 441                         curr_num = ev.num;
 442
 443                         if (prefix)
 444                                 retval = history_search_prefix(search, -1);
 445                         else
 446                                 retval = history_search(search, -1);
 447
 448                         if (retval == -1) {
 449                                 fprintf(rl_outstream, "%s: Event not found\n",
 450                                     search);
 451                                 return (-1);
 452                         }
 453                         if (history(h, &ev, H_CURR) != 0)
 454                                 return (-1);
 455                         event_data = ev.str;
 456
 457                         /* roll back to original position */
 458                         history(h, &ev, H_NEXT_EVENT, curr_num);
 459                 }
 460                 idx = off;
 461         }
 462
 463         if (!event_data && event_num >= 0) {
 464                 HIST_ENTRY *rl_he;
 465                 rl_he = history_get(event_num);
 466                 if (!rl_he)
 467                         return (0);
 468                 event_data = rl_he->line;
 469         } else
 470                 return (-1);
 471
 472         if (cmd[idx] != ':')
 473                 return (-1);
 474         cmd += idx + 1;
 475
 476         /* recognize cmd */
 477         if (*cmd == '^')
 478                 start = end = 1, cmd++;
 479         else if (*cmd == '$')
 480                 start = end = -1, cmd++;
 481         else if (*cmd == '*')
 482                 start = 1, end = -1, cmd++;
 483         else if (isdigit((unsigned char) *cmd)) {
 484                 const char *temp;
 485                 int shifted = 0;
 486
 487                 start = atoi(cmd);
 488                 temp = cmd;
 489                 for (; isdigit((unsigned char) *cmd); cmd++);
 490                 if (temp != cmd)
 491                         shifted = 1;
 492                 if (shifted && *cmd == '-') {
 493                         if (!isdigit((unsigned char) *(cmd + 1)))
 494                                 end = -2;
 495                         else {
 496                                 end = atoi(cmd + 1);
 497                                 for (; isdigit((unsigned char) *cmd); cmd++);
 498                         }
 499                 } else if (shifted && *cmd == '*')
 500                         end = -1, cmd++;
 501                 else if (shifted)
 502                         end = start;
 503         }
 504         if (*cmd == ':')
 505                 cmd++;
 506
 507         line = strdup(event_data);
 508         for (; *cmd; cmd++) {
 509                 if (*cmd == ':')
 510                         continue;
 511                 else if (*cmd == 'h')
 512                         h_on = 1 | g_on, g_on = 0;
 513                 else if (*cmd == 't')
 514                         t_on = 1 | g_on, g_on = 0;
 515                 else if (*cmd == 'r')
 516                         r_on = 1 | g_on, g_on = 0;
 517                 else if (*cmd == 'e')
 518                         e_on = 1 | g_on, g_on = 0;
 519                 else if (*cmd == 'p')
 520                         p_on = 1 | g_on, g_on = 0;
 521                 else if (*cmd == 'g')
 522                         g_on = 2;
 523                 else if (*cmd == 's' || *cmd == '&') {
 524                         char *what, *with, delim;
 525                         int len, from_len;
 526                         size_t size;
 527
 528                         if (*cmd == '&' && (from == NULL || to == NULL))
 529                                 continue;
 530                         else if (*cmd == 's') {
 531                                 delim = *(++cmd), cmd++;
 532                                 size = 16;
 533                                 what = realloc(from, size);
 534                                 len = 0;
 535                                 for (; *cmd && *cmd != delim; cmd++) {
 536                                         if (*cmd == '\\'
 537                                             && *(cmd + 1) == delim)
 538                                                 cmd++;
 539                                         if (len >= size)
 540                                                 what = realloc(what,
 541                                                     (size <<= 1));
 542                                         what[len++] = *cmd;
 543                                 }
 544                                 what[len] = '\0';
 545                                 from = what;
 546                                 if (*what == '\0') {
 547                                         free(what);
 548                                         if (search)
 549                                                 from = strdup(search);
 550                                         else {
 551                                                 from = NULL;
 552                                                 free(line);
 553                                                 return (-1);
 554                                         }
 555                                 }
 556                                 cmd++;  /* shift after delim */
 557                                 if (!*cmd)
 558                                         continue;
 559
 560                                 size = 16;
 561                                 with = realloc(to, size);
 562                                 len = 0;
 563                                 from_len = strlen(from);
 564                                 for (; *cmd && *cmd != delim; cmd++) {
 565                                         if (len + from_len + 1 >= size) {
 566                                                 size += from_len + 1;
 567                                                 with = realloc(with, size);
 568                                         }
 569                                         if (*cmd == '&') {
 570                                                 /* safe */
 571                                                 (void) strcpy(&with[len], from);
 572                                                 len += from_len;
 573                                                 continue;
 574                                         }
 575                                         if (*cmd == '\\'
 576                                             && (*(cmd + 1) == delim
 577                                                 || *(cmd + 1) == '&'))
 578                                                 cmd++;
 579                                         with[len++] = *cmd;
 580                                 }
 581                                 with[len] = '\0';
 582                                 to = with;
 583
 584                                 tempcmd = _rl_compat_sub(line, from, to,
 585                                     (g_on) ? 1 : 0);
 586                                 free(line);
 587                                 line = tempcmd;
 588                                 g_on = 0;
 589                         }
 590                 }
 591         }
 592
 593         arr = history_tokenize(line);
 594         free(line);             /* no more needed */
 595         if (arr && *arr == NULL)
 596                 free(arr), arr = NULL;
 597         if (!arr)
 598                 return (-1);
 599
 600         /* find out max valid idx to array of array */
 601         max = 0;
 602         for (i = 0; arr[i]; i++)
 603                 max++;
 604         max--;
 605
 606         /* set boundaries to something relevant */
 607         if (start < 0)
 608                 start = 1;
 609         if (end < 0)
 610                 end = max - ((end < -1) ? 1 : 0);
 611
 612         /* check boundaries ... */
 613         if (start > max || end > max || start > end) {
 614                 for (i = 0; i <= max; i++) {
 615                         free(arr[i]);
 616                 }
 617                 free(arr), arr = (char **) NULL;
 618                 return (-1);
 619         }
 620
 621         for (i = 0; i <= max; i++) {
 622                 char *temp;
 623                 if (h_on && (i == 1 || h_on > 1) &&
 624                     (temp = strrchr(arr[i], '/')))
 625                         *(temp + 1) = '\0';
 626                 if (t_on && (i == 1 || t_on > 1) &&
 627                     (temp = strrchr(arr[i], '/')))
 628                         (void) strcpy(arr[i], temp + 1);
 629                 if (r_on && (i == 1 || r_on > 1) &&
 630                     (temp = strrchr(arr[i], '.')))
 631                         *temp = '\0';
 632                 if (e_on && (i == 1 || e_on > 1) &&
 633                     (temp = strrchr(arr[i], '.')))
 634                         (void) strcpy(arr[i], temp);
 635         }
 636
 637         cmdsize = 1, cmdlen = 0;
 638         tempcmd = malloc(cmdsize);
 639         for (i = start; start <= i && i <= end; i++) {
 640                 int arr_len;
 641
 642                 arr_len = strlen(arr[i]);
 643                 if (cmdlen + arr_len + 1 >= cmdsize) {
 644                         cmdsize += arr_len + 1;
 645                         tempcmd = realloc(tempcmd, cmdsize);
 646                 }
 647                 (void) strcpy(&tempcmd[cmdlen], arr[i]);        /* safe */
 648                 cmdlen += arr_len;
 649                 tempcmd[cmdlen++] = ' ';        /* add a space */
 650         }
 651         while (cmdlen > 0 && isspace((unsigned char) tempcmd[cmdlen - 1]))
 652                 cmdlen--;
 653         tempcmd[cmdlen] = '\0';
 654
 655         *result = tempcmd;
 656
 657         for (i = 0; i <= max; i++)
 658                 free(arr[i]);
 659         free(arr), arr = (char **) NULL;
 660         return (p_on) ? 2 : 1;
 661 }
 662
 663
 664 /*
 665  * csh-style history expansion
 666  */
 667 int
 668 history_expand(char *str, char **output)
 669 {
 670         int i, retval = 0, idx;
 671         size_t size;
 672         char *temp, *result;
 673
 674         if (h == NULL || e == NULL)
 675                 rl_initialize();
 676
 677         *output = strdup(str);  /* do it early */
 678
 679         if (str[0] == history_subst_char) {
 680                 /* ^foo^foo2^ is equivalent to !!:s^foo^foo2^ */
 681                 temp = alloca(4 + strlen(str) + 1);
 682                 temp[0] = temp[1] = history_expansion_char;
 683                 temp[2] = ':';
 684                 temp[3] = 's';
 685                 (void) strcpy(temp + 4, str);
 686                 str = temp;
 687         }
 688 #define ADD_STRING(what, len)                                           \
 689         {                                                               \
 690                 if (idx + len + 1 > size)                               \
 691                         result = realloc(result, (size += len + 1));    \
 692                 (void)strncpy(&result[idx], what, len);                 \
 693                 idx += len;                                             \
 694                 result[idx] = '\0';                                     \
 695         }
 696
 697         result = NULL;
 698         size = idx = 0;
 699         for (i = 0; str[i];) {
 700                 int start, j, loop_again;
 701                 size_t len;
 702
 703                 loop_again = 1;
 704                 start = j = i;
 705 loop:
 706                 for (; str[j]; j++) {
 707                         if (str[j] == '\\' &&
 708                             str[j + 1] == history_expansion_char) {
 709                                 (void) strcpy(&str[j], &str[j + 1]);
 710                                 continue;
 711                         }
 712                         if (!loop_again) {
 713                                 if (str[j] == '?') {
 714                                         while (str[j] && str[++j] != '?');
 715                                         if (str[j] == '?')
 716                                                 j++;
 717                                 } else if (isspace((unsigned char) str[j]))
 718                                         break;
 719                         }
 720                         if (str[j] == history_expansion_char
 721                             && !strchr(history_no_expand_chars, str[j + 1])
 722                             && (!history_inhibit_expansion_function ||
 723                             (*history_inhibit_expansion_function)(str, j) == 0))
 724                                 break;
 725                 }
 726
 727                 if (str[j] && str[j + 1] != '#' && loop_again) {
 728                         i = j;
 729                         j++;
 730                         if (str[j] == history_expansion_char)
 731                                 j++;
 732                         loop_again = 0;
 733                         goto loop;
 734                 }
 735                 len = i - start;
 736                 temp = &str[start];
 737                 ADD_STRING(temp, len);
 738
 739                 if (str[i] == '\0' || str[i] != history_expansion_char
 740                     || str[i + 1] == '#') {
 741                         len = j - i;
 742                         temp = &str[i];
 743                         ADD_STRING(temp, len);
 744                         if (start == 0)
 745                                 retval = 0;
 746                         else
 747                                 retval = 1;
 748                         break;
 749                 }
 750                 retval = _history_expand_command(&str[i], (size_t) (j - i),
 751                     &temp);
 752                 if (retval != -1) {
 753                         len = strlen(temp);
 754                         ADD_STRING(temp, len);
 755                 }
 756                 i = j;
 757         }                       /* for(i ...) */
 758
 759         if (retval == 2) {
 760                 add_history(temp);
 761 #ifdef GDB_411_HACK
 762                 /* gdb 4.11 has been shipped with readline, where */
 763                 /* history_expand() returned -1 when the line     */
 764                 /* should not be executed; in readline 2.1+       */
 765                 /* it should return 2 in such a case              */
 766                 retval = -1;
 767 #endif
 768         }
 769         free(*output);
 770         *output = result;
 771
 772         return (retval);
 773 }
 774
 775
 776 /*
 777  * Parse the string into individual tokens, similarily to how shell would do it.
 778  */
 779 char **
 780 history_tokenize(const char *str)
 781 {
 782         int size = 1, result_idx = 0, i, start;
 783         size_t len;
 784         char **result = NULL, *temp, delim = '\0';
 785
 786         for (i = 0; str[i]; i++) {
 787                 while (isspace((unsigned char) str[i]))
 788                         i++;
 789                 start = i;
 790                 for (; str[i]; i++) {
 791                         if (str[i] == '\\') {
 792                                 if (str[i+1] != '\0')
 793                                         i++;
 794                         } else if (str[i] == delim)
 795                                 delim = '\0';
 796                         else if (!delim &&
 797                                     (isspace((unsigned char) str[i]) ||
 798                                 strchr("()<>;&|$", str[i])))
 799                                 break;
 800                         else if (!delim && strchr("'`\"", str[i]))
 801                                 delim = str[i];
 802                 }
 803
 804                 if (result_idx + 2 >= size) {
 805                         size <<= 1;
 806                         result = realloc(result, size * sizeof(char *));
 807                 }
 808                 len = i - start;
 809                 temp = malloc(len + 1);
 810                 (void) strncpy(temp, &str[start], len);
 811                 temp[len] = '\0';
 812                 result[result_idx++] = temp;
 813                 result[result_idx] = NULL;
 814         }
 815
 816         return (result);
 817 }
 818
 819
 820 /*
 821  * limit size of history record to ``max'' events
 822  */
 823 void
 824 stifle_history(int max)
 825 {
 826         HistEvent ev;
 827
 828         if (h == NULL || e == NULL)
 829                 rl_initialize();
 830
 831         if (history(h, &ev, H_SETSIZE, max) == 0)
 832                 max_input_history = max;
 833 }
 834
 835
 836 /*
 837  * "unlimit" size of history - set the limit to maximum allowed int value
 838  */
 839 int
 840 unstifle_history(void)
 841 {
 842         HistEvent ev;
 843         int omax;
 844
 845         history(h, &ev, H_SETSIZE, INT_MAX);
 846         omax = max_input_history;
 847         max_input_history = INT_MAX;
 848         return (omax);          /* some value _must_ be returned */
 849 }
 850
 851
 852 int
 853 history_is_stifled(void)
 854 {
 855
 856         /* cannot return true answer */
 857         return (max_input_history != INT_MAX);
 858 }
 859
 860
 861 /*
 862  * read history from a file given
 863  */
 864 int
 865 read_history(const char *filename)
 866 {
 867         HistEvent ev;
 868
 869         if (h == NULL || e == NULL)
 870                 rl_initialize();
 871         return (history(h, &ev, H_LOAD, filename));
 872 }
 873
 874
 875 /*
 876  * write history to a file given
 877  */
 878 int
 879 write_history(const char *filename)
 880 {
 881         HistEvent ev;
 882
 883         if (h == NULL || e == NULL)
 884                 rl_initialize();
 885         return (history(h, &ev, H_SAVE, filename));
 886 }
 887
 888
 889 /*
 890  * returns history ``num''th event
 891  *
 892  * returned pointer points to static variable
 893  */
 894 HIST_ENTRY *
 895 history_get(int num)
 896 {
 897         static HIST_ENTRY she;
 898         HistEvent ev;
 899         int i = 1, curr_num;
 900
 901         if (h == NULL || e == NULL)
 902                 rl_initialize();
 903
 904         /* rewind to beginning */
 905         if (history(h, &ev, H_CURR) != 0)
 906                 return (NULL);
 907         curr_num = ev.num;
 908         if (history(h, &ev, H_LAST) != 0)
 909                 return (NULL);  /* error */
 910         while (i < num && history(h, &ev, H_PREV) == 0)
 911                 i++;
 912         if (i != num)
 913                 return (NULL);  /* not so many entries */
 914
 915         she.line = ev.str;
 916         she.data = NULL;
 917
 918         /* rewind history to the same event it was before */
 919         (void) history(h, &ev, H_FIRST);
 920         (void) history(h, &ev, H_NEXT_EVENT, curr_num);
 921
 922         return (&she);
 923 }
 924
 925
 926 /*
 927  * add the line to history table
 928  */
 929 int
 930 add_history(const char *line)
 931 {
 932         HistEvent ev;
 933
 934         if (h == NULL || e == NULL)
 935                 rl_initialize();
 936
 937         (void) history(h, &ev, H_ENTER, line);
 938         if (history(h, &ev, H_GETSIZE) == 0)
 939                 history_length = ev.num;
 940
 941         return (!(history_length > 0)); /* return 0 if all is okay */
 942 }
 943
 944
 945 /*
 946  * clear the history list - delete all entries
 947  */
 948 void
 949 clear_history(void)
 950 {
 951         HistEvent ev;
 952
 953         history(h, &ev, H_CLEAR);
 954 }
 955
 956
 957 /*
 958  * returns offset of the current history event
 959  */
 960 int
 961 where_history(void)
 962 {
 963         HistEvent ev;
 964         int curr_num, off;
 965
 966         if (history(h, &ev, H_CURR) != 0)
 967                 return (0);
 968         curr_num = ev.num;
 969
 970         history(h, &ev, H_FIRST);
 971         off = 1;
 972         while (ev.num != curr_num && history(h, &ev, H_NEXT) == 0)
 973                 off++;
 974
 975         return (off);
 976 }
 977
 978
 979 /*
 980  * returns current history event or NULL if there is no such event
 981  */
 982 HIST_ENTRY *
 983 current_history(void)
 984 {
 985
 986         return (_move_history(H_CURR));
 987 }
 988
 989
 990 /*
 991  * returns total number of bytes history events' data are using
 992  */
 993 int
 994 history_total_bytes(void)
 995 {
 996         HistEvent ev;
 997         int curr_num, size;
 998
 999         if (history(h, &ev, H_CURR) != 0)
1000                 return (-1);
1001         curr_num = ev.num;
1002
1003         history(h, &ev, H_FIRST);
1004         size = 0;
1005         do
1006                 size += strlen(ev.str);
1007         while (history(h, &ev, H_NEXT) == 0);
1008
1009         /* get to the same position as before */
1010         history(h, &ev, H_PREV_EVENT, curr_num);
1011
1012         return (size);
1013 }
1014
1015
1016 /*
1017  * sets the position in the history list to ``pos''
1018  */
1019 int
1020 history_set_pos(int pos)
1021 {
1022         HistEvent ev;
1023         int off, curr_num;
1024
1025         if (pos > history_length || pos < 0)
1026                 return (-1);
1027
1028         history(h, &ev, H_CURR);
1029         curr_num = ev.num;
1030         history(h, &ev, H_FIRST);
1031         off = 0;
1032         while (off < pos && history(h, &ev, H_NEXT) == 0)
1033                 off++;
1034
1035         if (off != pos) {       /* do a rollback in case of error */
1036                 history(h, &ev, H_FIRST);
1037                 history(h, &ev, H_NEXT_EVENT, curr_num);
1038                 return (-1);
1039         }
1040         return (0);
1041 }
1042
1043
1044 /*
1045  * returns previous event in history and shifts pointer accordingly
1046  */
1047 HIST_ENTRY *
1048 previous_history(void)
1049 {
1050
1051         return (_move_history(H_PREV));
1052 }
1053
1054
1055 /*
1056  * returns next event in history and shifts pointer accordingly
1057  */
1058 HIST_ENTRY *
1059 next_history(void)
1060 {
1061
1062         return (_move_history(H_NEXT));
1063 }
1064
1065
1066 /*
1067  * generic history search function
1068  */
1069 static int
1070 _history_search_gen(const char *str, int direction, int pos)
1071 {
1072         HistEvent ev;
1073         const char *strp;
1074         int curr_num;
1075
1076         if (history(h, &ev, H_CURR) != 0)
1077                 return (-1);
1078         curr_num = ev.num;
1079
1080         for (;;) {
1081                 strp = strstr(ev.str, str);
1082                 if (strp && (pos < 0 || &ev.str[pos] == strp))
1083                         return (int) (strp - ev.str);
1084                 if (history(h, &ev, direction < 0 ? H_PREV : H_NEXT) != 0)
1085                         break;
1086         }
1087
1088         history(h, &ev, direction < 0 ? H_NEXT_EVENT : H_PREV_EVENT, curr_num);
1089
1090         return (-1);
1091 }
1092
1093
1094 /*
1095  * searches for first history event containing the str
1096  */
1097 int
1098 history_search(const char *str, int direction)
1099 {
1100
1101         return (_history_search_gen(str, direction, -1));
1102 }
1103
1104
1105 /*
1106  * searches for first history event beginning with str
1107  */
1108 int
1109 history_search_prefix(const char *str, int direction)
1110 {
1111
1112         return (_history_search_gen(str, direction, 0));
1113 }
1114
1115
1116 /*
1117  * search for event in history containing str, starting at offset
1118  * abs(pos); continue backward, if pos<0, forward otherwise
1119  */
1120 /* ARGSUSED */
1121 int
1122 history_search_pos(const char *str, int direction, int pos)
1123 {
1124         HistEvent ev;
1125         int curr_num, off;
1126
1127         off = (pos > 0) ? pos : -pos;
1128         pos = (pos > 0) ? 1 : -1;
1129
1130         if (history(h, &ev, H_CURR) != 0)
1131                 return (-1);
1132         curr_num = ev.num;
1133
1134         if (history_set_pos(off) != 0 || history(h, &ev, H_CURR) != 0)
1135                 return (-1);
1136
1137
1138         for (;;) {
1139                 if (strstr(ev.str, str))
1140                         return (off);
1141                 if (history(h, &ev, (pos < 0) ? H_PREV : H_NEXT) != 0)
1142                         break;
1143         }
1144
1145         /* set "current" pointer back to previous state */
1146         history(h, &ev, (pos < 0) ? H_NEXT_EVENT : H_PREV_EVENT, curr_num);
1147
1148         return (-1);
1149 }
1150
1151
1152 /********************************/
1153 /* completition functions       */
1154
1155 /*
1156  * does tilde expansion of strings of type ``~user/foo''
1157  * if ``user'' isn't valid user name or ``txt'' doesn't start
1158  * w/ '~', returns pointer to strdup()ed copy of ``txt''
1159  *
1160  * it's callers's responsibility to free() returned string
1161  */
1162 char *
1163 tilde_expand(char *txt)
1164 {
1165         struct passwd *pass;
1166         char *temp;
1167         size_t len = 0;
1168
1169         if (txt[0] != '~')
1170                 return (strdup(txt));
1171
1172         temp = strchr(txt + 1, '/');
1173         if (temp == NULL)
1174                 temp = strdup(txt + 1);
1175         else {
1176                 len = temp - txt + 1;   /* text until string after slash */
1177                 temp = malloc(len);
1178                 (void) strncpy(temp, txt + 1, len - 2);
1179                 temp[len - 2] = '\0';
1180         }
1181         pass = getpwnam(temp);
1182         free(temp);             /* value no more needed */
1183         if (pass == NULL)
1184                 return (strdup(txt));
1185
1186         /* update pointer txt to point at string immedially following */
1187         /* first slash */
1188         txt += len;
1189
1190         temp = malloc(strlen(pass->pw_dir) + 1 + strlen(txt) + 1);
1191         (void) sprintf(temp, "%s/%s", pass->pw_dir, txt);
1192
1193         return (temp);
1194 }
1195
1196
1197 /*
1198  * return first found file name starting by the ``text'' or NULL if no
1199  * such file can be found.
1200  * The first ``state'' matches are ignored.
1201  *
1202  * it's caller's responsibility to free returned string
1203  */
1204 char *
1205 filename_completion_function(const char *text, int state)
1206 {
1207         DIR *dir = NULL;
1208         char *filename = NULL, *dirname = NULL;
1209         size_t filename_len = 0;
1210         struct dirent *entry;
1211         char *temp;
1212         size_t len;
1213
1214         temp = strrchr(text, '/');
1215         if (temp) {
1216                 temp++;
1217                 filename = realloc(filename, strlen(temp) + 1);
1218                 (void) strcpy(filename, temp);
1219                 len = temp - text;      /* including last slash */
1220                 dirname = realloc(dirname, len + 1);
1221                 (void) strncpy(dirname, text, len);
1222                 dirname[len] = '\0';
1223         } else {
1224                 filename = strdup(text);
1225                 dirname = NULL;
1226         }
1227
1228         /* support for ``~user'' syntax */
1229         if (dirname && *dirname == '~') {
1230                 temp = tilde_expand(dirname);
1231                 dirname = realloc(dirname, strlen(temp) + 1);
1232                 (void) strcpy(dirname, temp);   /* safe */
1233                 free(temp);     /* no longer needed */
1234         }
1235         /* will be used in cycle */
1236         filename_len = strlen(filename);
1237
1238         dir = opendir(dirname ? dirname : ".");
1239         if (!dir)
1240                 return (NULL);  /* cannot open the directory */
1241
1242         /* find the match */
1243         while ((entry = readdir(dir)) != NULL) {
1244                 /* otherwise, get first entry where first */
1245                 /* filename_len characters are equal      */
1246                 if (
1247 #if defined(__SVR4) || defined(__linux__)
1248                     strlen(entry->d_name) >= filename_len
1249 #else
1250                     entry->d_namlen >= filename_len
1251 #endif
1252                     && strncmp(entry->d_name, filename,
1253                         filename_len) == 0
1254                         && (state-- == 0))
1255                         break;
1256         }
1257
1258         if (entry) {            /* match found */
1259
1260                 struct stat stbuf;
1261 #if defined(__SVR4) || defined(__linux__)
1262                 len = strlen(entry->d_name) +
1263 #else
1264                 len = entry->d_namlen +
1265 #endif
1266                     ((dirname) ? strlen(dirname) : 0) + 1 + 1;
1267                 temp = malloc(len);
1268                 (void) sprintf(temp, "%s%s",
1269                     dirname ? dirname : "", entry->d_name);     /* safe */
1270
1271                 /* test, if it's directory */
1272                 if (stat(temp, &stbuf) == 0 && S_ISDIR(stbuf.st_mode))
1273                         strcat(temp, "/");      /* safe */
1274         } else
1275                 temp = NULL;
1276         closedir(dir);
1277
1278         return (temp);
1279 }
1280
1281
1282 /*
1283  * a completion generator for usernames; returns _first_ username
1284  * which starts with supplied text
1285  * text contains a partial username preceded by random character
1286  * (usually '~'); state is ignored
1287  * it's callers responsibility to free returned value
1288  */
1289 char *
1290 username_completion_function(const char *text, int state)
1291 {
1292         struct passwd *pwd;
1293
1294         if (text[0] == '\0')
1295                 return (NULL);
1296
1297         if (*text == '~')
1298                 text++;
1299
1300         if (state == 0)
1301                 setpwent();
1302
1303         while ((pwd = getpwent()) && text[0] == pwd->pw_name[0]
1304             && strcmp(text, pwd->pw_name) == 0);
1305
1306         if (pwd == NULL) {
1307                 endpwent();
1308                 return (NULL);
1309         }
1310         return (strdup(pwd->pw_name));
1311 }
1312
1313
1314 /*
1315  * el-compatible wrapper around rl_complete; needed for key binding
1316  */
1317 /* ARGSUSED */
1318 static unsigned char
1319 _el_rl_complete(EditLine *el, int ch)
1320 {
1321         return (unsigned char) rl_complete(0, ch);
1322 }
1323
1324
1325 /*
1326  * returns list of completitions for text given
1327  */
1328 char **
1329 completion_matches(const char *text, CPFunction *genfunc)
1330 {
1331         char **match_list = NULL, *retstr, *prevstr;
1332         size_t match_list_len, max_equal, which, i;
1333         int matches;
1334
1335         if (h == NULL || e == NULL)
1336                 rl_initialize();
1337
1338         matches = 0;
1339         match_list_len = 1;
1340         while ((retstr = (*genfunc) (text, matches)) != NULL) {
1341                 if (matches + 1 >= match_list_len) {
1342                         match_list_len <<= 1;
1343                         match_list = realloc(match_list,
1344                             match_list_len * sizeof(char *));
1345                 }
1346                 match_list[++matches] = retstr;
1347         }
1348
1349         if (!match_list)
1350                 return (char **) NULL;  /* nothing found */
1351
1352         /* find least denominator and insert it to match_list[0] */
1353         which = 2;
1354         prevstr = match_list[1];
1355         max_equal = strlen(prevstr);
1356         for (; which <= matches; which++) {
1357                 for (i = 0; i < max_equal &&
1358                     prevstr[i] == match_list[which][i]; i++)
1359                         continue;
1360                 max_equal = i;
1361         }
1362
1363         retstr = malloc(max_equal + 1);
1364         (void) strncpy(retstr, match_list[1], max_equal);
1365         retstr[max_equal] = '\0';
1366         match_list[0] = retstr;
1367
1368         /* add NULL as last pointer to the array */
1369         if (matches + 1 >= match_list_len)
1370                 match_list = realloc(match_list,
1371                     (match_list_len + 1) * sizeof(char *));
1372         match_list[matches + 1] = (char *) NULL;
1373
1374         return (match_list);
1375 }
1376
1377 /*
1378  * Sort function for qsort(). Just wrapper around strcasecmp().
1379  */
1380 static int
1381 _rl_qsort_string_compare(i1, i2)
1382         const void *i1, *i2;
1383 {
1384         /* LINTED const castaway */
1385         const char *s1 = ((const char **)i1)[0];
1386         /* LINTED const castaway */
1387         const char *s2 = ((const char **)i2)[0];
1388
1389         return strcasecmp(s1, s2);
1390 }
1391
1392 /*
1393  * Display list of strings in columnar format on readline's output stream.
1394  * 'matches' is list of strings, 'len' is number of strings in 'matches',
1395  * 'max' is maximum length of string in 'matches'.
1396  */
1397 void
1398 rl_display_match_list (matches, len, max)
1399      char **matches;
1400      int len, max;
1401 {
1402         int i, idx, limit, count;
1403         int screenwidth = e->el_term.t_size.h;
1404
1405         /*
1406          * Find out how many entries can be put on one line, count
1407          * with two spaces between strings.
1408          */
1409         limit = screenwidth / (max + 2);
1410         if (limit == 0)
1411                 limit = 1;
1412
1413         /* how many lines of output */
1414         count = len / limit;
1415         if (count * limit < len)
1416                 count++;
1417
1418         /* Sort the items if they are not already sorted. */
1419         qsort(&matches[1], (size_t)(len - 1), sizeof(char *),
1420             _rl_qsort_string_compare);
1421
1422         idx = 1;
1423         for(; count > 0; count--) {
1424                 for(i=0; i < limit && matches[idx]; i++, idx++)
1425                         fprintf(e->el_outfile, "%-*s  ", max, matches[idx]);
1426                 fprintf(e->el_outfile, "\n");
1427         }
1428 }
1429
1430 /*
1431  * Complete the word at or before point, called by rl_complete()
1432  * 'what_to_do' says what to do with the completion.
1433  * `?' means list the possible completions.
1434  * TAB means do standard completion.
1435  * `*' means insert all of the possible completions.
1436  * `!' means to do standard completion, and list all possible completions if
1437  * there is more than one.
1438  *
1439  * Note: '*' support is not implemented
1440  */
1441 static int
1442 rl_complete_internal(int what_to_do)
1443 {
1444         CPFunction *complet_func;
1445         const LineInfo *li;
1446         char *temp, **matches;
1447         const char *ctemp;
1448         size_t len;
1449
1450         rl_completion_type = what_to_do;
1451
1452         if (h == NULL || e == NULL)
1453                 rl_initialize();
1454
1455         complet_func = rl_completion_entry_function;
1456         if (!complet_func)
1457                 complet_func = filename_completion_function;
1458
1459         /* We now look backwards for the start of a filename/variable word */
1460         li = el_line(e);
1461         ctemp = (const char *) li->cursor;
1462         while (ctemp > li->buffer
1463             && !strchr(rl_basic_word_break_characters, ctemp[-1])
1464             && (!rl_special_prefixes
1465                         || !strchr(rl_special_prefixes, ctemp[-1]) ) )
1466                 ctemp--;
1467
1468         len = li->cursor - ctemp;
1469         temp = alloca(len + 1);
1470         (void) strncpy(temp, ctemp, len);
1471         temp[len] = '\0';
1472
1473         /* these can be used by function called in completion_matches() */
1474         /* or (*rl_attempted_completion_function)() */
1475         rl_point = li->cursor - li->buffer;
1476         rl_end = li->lastchar - li->buffer;
1477
1478         if (!rl_attempted_completion_function)
1479                 matches = completion_matches(temp, complet_func);
1480         else {
1481                 int end = li->cursor - li->buffer;
1482                 matches = (*rl_attempted_completion_function) (temp, (int)
1483                     (end - len), end);
1484         }
1485
1486         if (matches) {
1487                 int i, retval = CC_REFRESH;
1488                 int matches_num, maxlen, match_len, match_display=1;
1489
1490                 /*
1491                  * Only replace the completed string with common part of
1492                  * possible matches if there is possible completion.
1493                  */
1494                 if (matches[0][0] != '\0') {
1495                         el_deletestr(e, (int) len);
1496                         el_insertstr(e, matches[0]);
1497                 }
1498
1499                 if (what_to_do == '?')
1500                         goto display_matches;
1501
1502                 if (matches[2] == NULL && strcmp(matches[0], matches[1]) == 0) {
1503                         /*
1504                          * We found exact match. Add a space after
1505                          * it, unless we do filename completition and the
1506                          * object is a directory.
1507                          */
1508                         size_t alen = strlen(matches[0]);
1509                         if ((complet_func != filename_completion_function
1510                               || (alen > 0 && (matches[0])[alen - 1] != '/'))
1511                             && rl_completion_append_character) {
1512                                 char buf[2];
1513                                 buf[0] = rl_completion_append_character;
1514                                 buf[1] = '\0';
1515                                 el_insertstr(e, buf);
1516                         }
1517                 } else if (what_to_do == '!') {
1518     display_matches:
1519                         /*
1520                          * More than one match and requested to list possible
1521                          * matches.
1522                          */
1523
1524                         for(i=1, maxlen=0; matches[i]; i++) {
1525                                 match_len = strlen(matches[i]);
1526                                 if (match_len > maxlen)
1527                                         maxlen = match_len;
1528                         }
1529                         matches_num = i - 1;
1530
1531                         /* newline to get on next line from command line */
1532                         fprintf(e->el_outfile, "\n");
1533
1534                         /*
1535                          * If there are too many items, ask user for display
1536                          * confirmation.
1537                          */
1538                         if (matches_num > rl_completion_query_items) {
1539                                 fprintf(e->el_outfile,
1540                                 "Display all %d possibilities? (y or n) ",
1541                                         matches_num);
1542                                 fflush(e->el_outfile);
1543                                 if (getc(stdin) != 'y')
1544                                         match_display = 0;
1545                                 fprintf(e->el_outfile, "\n");
1546                         }
1547
1548                         if (match_display)
1549                                 rl_display_match_list(matches, matches_num,
1550                                         maxlen);
1551                         retval = CC_REDISPLAY;
1552                 } else if (matches[0][0]) {
1553                         /*
1554                          * There was some common match, but the name was
1555                          * not complete enough. Next tab will print possible
1556                          * completions.
1557                          */
1558                         el_beep(e);
1559                 } else {
1560                         /* lcd is not a valid object - further specification */
1561                         /* is needed */
1562                         el_beep(e);
1563                         retval = CC_NORM;
1564                 }
1565
1566                 /* free elements of array and the array itself */
1567                 for (i = 0; matches[i]; i++)
1568                         free(matches[i]);
1569                 free(matches), matches = NULL;
1570
1571                 return (retval);
1572         }
1573         return (CC_NORM);
1574 }
1575
1576
1577 /*
1578  * complete word at current point
1579  */
1580 int
1581 rl_complete(int ignore, int invoking_key)
1582 {
1583         if (h == NULL || e == NULL)
1584                 rl_initialize();
1585
1586         if (rl_inhibit_completion) {
1587                 rl_insert(ignore, invoking_key);
1588                 return (CC_REFRESH);
1589         } else if (e->el_state.lastcmd == el_rl_complete_cmdnum)
1590                 return rl_complete_internal('?');
1591         else if (_rl_complete_show_all)
1592                 return rl_complete_internal('!');
1593         else
1594                 return (rl_complete_internal(TAB));
1595 }
1596
1597
1598 /*
1599  * misc other functions
1600  */
1601
1602 /*
1603  * bind key c to readline-type function func
1604  */
1605 int
1606 rl_bind_key(int c, int func(int, int))
1607 {
1608         int retval = -1;
1609
1610         if (h == NULL || e == NULL)
1611                 rl_initialize();
1612
1613         if (func == rl_insert) {
1614                 /* XXX notice there is no range checking of ``c'' */
1615                 e->el_map.key[c] = ED_INSERT;
1616                 retval = 0;
1617         }
1618         return (retval);
1619 }
1620
1621
1622 /*
1623  * read one key from input - handles chars pushed back
1624  * to input stream also
1625  */
1626 int
1627 rl_read_key(void)
1628 {
1629         char fooarr[2 * sizeof(int)];
1630
1631         if (e == NULL || h == NULL)
1632                 rl_initialize();
1633
1634         return (el_getc(e, fooarr));
1635 }
1636
1637
1638 /*
1639  * reset the terminal
1640  */
1641 /* ARGSUSED */
1642 void
1643 rl_reset_terminal(const char *p)
1644 {
1645
1646         if (h == NULL || e == NULL)
1647                 rl_initialize();
1648         el_reset(e);
1649 }
1650
1651
1652 /*
1653  * insert character ``c'' back into input stream, ``count'' times
1654  */
1655 int
1656 rl_insert(int count, int c)
1657 {
1658         char arr[2];
1659
1660         if (h == NULL || e == NULL)
1661                 rl_initialize();
1662
1663         /* XXX - int -> char conversion can lose on multichars */
1664         arr[0] = c;
1665         arr[1] = '\0';
1666
1667         for (; count > 0; count--)
1668                 el_push(e, arr);
1669
1670         return (0);
1671 }