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