[BACK]Return to readline.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / lib / libedit

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/lib/libedit/readline.c between version 1.10 and 1.59

version 1.10, 2000/03/10 13:06:43 version 1.59, 2006/02/12 16:15:07
Line 36 
Line 36 
  * POSSIBILITY OF SUCH DAMAGE.   * POSSIBILITY OF SUCH DAMAGE.
  */   */
   
 #include <sys/cdefs.h>  #include "config.h"
 #if !defined(lint) && !defined(SCCSID)  #if !defined(lint) && !defined(SCCSID)
 __RCSID("$NetBSD$");  __RCSID("$NetBSD$");
 #endif /* not lint && not SCCSID */  #endif /* not lint && not SCCSID */
Line 51  __RCSID("$NetBSD$");
Line 51  __RCSID("$NetBSD$");
 #include <stdlib.h>  #include <stdlib.h>
 #include <unistd.h>  #include <unistd.h>
 #include <limits.h>  #include <limits.h>
 #include "histedit.h"  #include <errno.h>
 #include "readline.h"  #include <fcntl.h>
 #include "sys.h"  #ifdef HAVE_VIS_H
   #include <vis.h>
   #else
   #include "np/vis.h"
   #endif
   #ifdef HAVE_ALLOCA_H
   #include <alloca.h>
   #endif
 #include "el.h"  #include "el.h"
   #include "fcns.h"               /* for EL_NUM_FCNS */
   #include "histedit.h"
   #include "readline/readline.h"
   #include "filecomplete.h"
   
 /* for rl_complete() */  /* for rl_complete() */
 #define TAB             '\r'  #define TAB             '\r'
   
 /* see comment at the #ifdef for sense of this */  /* see comment at the #ifdef for sense of this */
 #define GDB_411_HACK  /* #define GDB_411_HACK */
   
 /* readline compatibility stuff - look at readline sources/documentation */  /* readline compatibility stuff - look at readline sources/documentation */
 /* to see what these variables mean */  /* to see what these variables mean */
 const char     *rl_library_version = "EditLine wrapper";  const char *rl_library_version = "EditLine wrapper";
 char           *rl_readline_name = "";  static char empty[] = { '\0' };
 FILE           *rl_instream = NULL;  static char expand_chars[] = { ' ', '\t', '\n', '=', '(', '\0' };
 FILE           *rl_outstream = NULL;  static char break_chars[] = { ' ', '\t', '\n', '"', '\\', '\'', '`', '@', '$',
 int             rl_point = 0;      '>', '<', '=', ';', '|', '&', '{', '(', '\0' };
 int             rl_end = 0;  char *rl_readline_name = empty;
 char           *rl_line_buffer = NULL;  FILE *rl_instream = NULL;
   FILE *rl_outstream = NULL;
 int             history_base = 1;       /* probably never subject to change */  int rl_point = 0;
 int             history_length = 0;  int rl_end = 0;
 int             max_input_history = 0;  char *rl_line_buffer = NULL;
 char            history_expansion_char = '!';  VCPFunction *rl_linefunc = NULL;
 char            history_subst_char = '^';  int rl_done = 0;
 char           *history_no_expand_chars = " \t\n=(";  VFunction *rl_event_hook = NULL;
 Function       *history_inhibit_expansion_function = NULL;  
   int history_base = 1;           /* probably never subject to change */
 int             rl_inhibit_completion = 0;  int history_length = 0;
 int             rl_attempted_completion_over = 0;  int max_input_history = 0;
 char           *rl_basic_word_break_characters = " \t\n\"\\'`@$><=;|&{(";  char history_expansion_char = '!';
 char           *rl_completer_word_break_characters = NULL;  char history_subst_char = '^';
 char           *rl_completer_quote_characters = NULL;  char *history_no_expand_chars = expand_chars;
 CPFunction     *rl_completion_entry_function = NULL;  Function *history_inhibit_expansion_function = NULL;
 CPPFunction    *rl_attempted_completion_function = NULL;  char *history_arg_extract(int start, int end, const char *str);
   
   int rl_inhibit_completion = 0;
   int rl_attempted_completion_over = 0;
   char *rl_basic_word_break_characters = break_chars;
   char *rl_completer_word_break_characters = NULL;
   char *rl_completer_quote_characters = NULL;
   Function *rl_completion_entry_function = NULL;
   CPPFunction *rl_attempted_completion_function = NULL;
   Function *rl_pre_input_hook = NULL;
   Function *rl_startup1_hook = NULL;
   Function *rl_getc_function = NULL;
   char *rl_terminal_name = NULL;
   int rl_already_prompted = 0;
   int rl_filename_completion_desired = 0;
   int rl_ignore_completion_duplicates = 0;
   int rl_catch_signals = 1;
   VFunction *rl_redisplay_function = NULL;
   Function *rl_startup_hook = NULL;
   VFunction *rl_completion_display_matches_hook = NULL;
   VFunction *rl_prep_term_function = NULL;
   VFunction *rl_deprep_term_function = NULL;
   
   /*
    * The current prompt string.
    */
   char *rl_prompt = NULL;
   /*
    * This is set to character indicating type of completion being done by
    * rl_complete_internal(); this is available for application completion
    * functions.
    */
   int rl_completion_type = 0;
   
   /*
    * If more than this number of items results from query for possible
    * completions, we ask user if they are sure to really display the list.
    */
   int rl_completion_query_items = 100;
   
   /*
    * List of characters which are word break characters, but should be left
    * in the parsed text when it is passed to the completion function.
    * Shell uses this to help determine what kind of completing to do.
    */
   char *rl_special_prefixes = NULL;
   
   /*
    * This is the character appended to the completed words if at the end of
    * the line. Default is ' ' (a space).
    */
   int rl_completion_append_character = ' ';
   
   /* stuff below is used internally by libedit for readline emulation */
   
 /* used for readline emulation */  
 static History *h = NULL;  static History *h = NULL;
 static EditLine *e = NULL;  static EditLine *e = NULL;
   static Function *map[256];
   
 /* internal functions */  /* internal functions */
 static unsigned char _el_rl_complete __P((EditLine *, int));  static unsigned char     _el_rl_complete(EditLine *, int);
 static char *_get_prompt __P((EditLine *));  static unsigned char     _el_rl_tstp(EditLine *, int);
 static HIST_ENTRY *_move_history __P((int));  static char             *_get_prompt(EditLine *);
 static int _history_search_gen __P((const char *, int, int));  static int               _getc_function(EditLine *, char *);
 static int _history_expand_command __P((const char *, size_t, char **));  static HIST_ENTRY       *_move_history(int);
 static char *_rl_compat_sub __P((const char *, const char *,  static int               _history_expand_command(const char *, size_t, size_t,
      const char *, int));      char **);
 static int rl_complete_internal __P((int));  static char             *_rl_compat_sub(const char *, const char *,
       const char *, int);
   static int               _rl_event_read_char(EditLine *, char *);
   static void              _rl_update_pos(void);
   
 /*  
  * needed for prompt switching in readline()  
  */  
 static char    *el_rl_prompt = NULL;  
   
 /* ARGSUSED */  /* ARGSUSED */
 static char *  static char *
 _get_prompt(el)  _get_prompt(EditLine *el __attribute__((__unused__)))
         EditLine *el;  
 {  {
         return el_rl_prompt;          rl_already_prompted = 1;
           return (rl_prompt);
 }  }
   
   
 /*  /*
  * generic function for moving around history   * generic function for moving around history
  */   */
 static HIST_ENTRY *  static HIST_ENTRY *
 _move_history(op)  _move_history(int op)
         int op;  
 {  {
         HistEvent ev;          HistEvent ev;
         static HIST_ENTRY rl_he;          static HIST_ENTRY rl_he;
Line 129  _move_history(op)
Line 192  _move_history(op)
                 return (HIST_ENTRY *) NULL;                  return (HIST_ENTRY *) NULL;
   
         rl_he.line = ev.str;          rl_he.line = ev.str;
         rl_he.data = "";          rl_he.data = NULL;
   
           return (&rl_he);
   }
   
   
   /*
    * read one key from user defined input function
    */
   static int
   _getc_function(EditLine *el, char *c)
   {
           int i;
   
         return &rl_he;          i = (*rl_getc_function)(NULL, 0);
           if (i == -1)
                   return 0;
           *c = i;
           return 1;
 }  }
   
   
Line 143  _move_history(op)
Line 222  _move_history(op)
  * initialize rl compat stuff   * initialize rl compat stuff
  */   */
 int  int
 rl_initialize()  rl_initialize(void)
 {  {
         HistEvent ev;          HistEvent ev;
         const LineInfo *li;          const LineInfo *li;
           int editmode = 1;
           struct termios t;
   
         if (e != NULL)          if (e != NULL)
                 el_end(e);                  el_end(e);
Line 157  rl_initialize()
Line 238  rl_initialize()
                 rl_instream = stdin;                  rl_instream = stdin;
         if (!rl_outstream)          if (!rl_outstream)
                 rl_outstream = stdout;                  rl_outstream = stdout;
   
           /*
            * See if we don't really want to run the editor
            */
           if (tcgetattr(fileno(rl_instream), &t) != -1 && (t.c_lflag & ECHO) == 0)
                   editmode = 0;
   
         e = el_init(rl_readline_name, rl_instream, rl_outstream, stderr);          e = el_init(rl_readline_name, rl_instream, rl_outstream, stderr);
   
           if (!editmode)
                   el_set(e, EL_EDITMODE, 0);
   
         h = history_init();          h = history_init();
         if (!e || !h)          if (!e || !h)
                 return -1;                  return (-1);
   
         history(h, &ev, H_SETSIZE, INT_MAX);    /* unlimited */          history(h, &ev, H_SETSIZE, INT_MAX);    /* unlimited */
         history_length = 0;          history_length = 0;
         max_input_history = INT_MAX;          max_input_history = INT_MAX;
         el_set(e, EL_HIST, history, h);          el_set(e, EL_HIST, history, h);
   
           /* setup getc function if valid */
           if (rl_getc_function)
                   el_set(e, EL_GETCFN, _getc_function);
   
         /* for proper prompt printing in readline() */          /* for proper prompt printing in readline() */
         el_rl_prompt = strdup("");          rl_prompt = strdup("");
           if (rl_prompt == NULL) {
                   history_end(h);
                   el_end(e);
                   return -1;
           }
         el_set(e, EL_PROMPT, _get_prompt);          el_set(e, EL_PROMPT, _get_prompt);
         el_set(e, EL_SIGNAL, 1);          el_set(e, EL_SIGNAL, rl_catch_signals);
   
         /* set default mode to "emacs"-style and read setting afterwards */          /* set default mode to "emacs"-style and read setting afterwards */
         /* so this can be overriden */          /* so this can be overriden */
         el_set(e, EL_EDITOR, "emacs");          el_set(e, EL_EDITOR, "emacs");
           if (rl_terminal_name != NULL)
         /* for word completition - this has to go AFTER rebinding keys */                  el_set(e, EL_TERMINAL, rl_terminal_name);
         /* to emacs-style */          else
                   el_get(e, EL_TERMINAL, &rl_terminal_name);
   
           /*
            * Word completion - this has to go AFTER rebinding keys
            * to emacs-style.
            */
         el_set(e, EL_ADDFN, "rl_complete",          el_set(e, EL_ADDFN, "rl_complete",
                "ReadLine compatible completition function",              "ReadLine compatible completion function",
                _el_rl_complete);              _el_rl_complete);
         el_set(e, EL_BIND, "^I", "rl_complete", NULL);          el_set(e, EL_BIND, "^I", "rl_complete", NULL);
   
           /*
            * Send TSTP when ^Z is pressed.
            */
           el_set(e, EL_ADDFN, "rl_tstp",
               "ReadLine compatible suspend function",
               _el_rl_tstp);
           el_set(e, EL_BIND, "^Z", "rl_tstp", NULL);
   
         /* read settings from configuration file */          /* read settings from configuration file */
         el_source(e, NULL);          el_source(e, NULL);
   
         /* some readline apps do use this */          /*
            * Unfortunately, some applications really do use rl_point
            * and rl_line_buffer directly.
            */
         li = el_line(e);          li = el_line(e);
         /* LINTED const cast */          /* a cheesy way to get rid of const cast. */
         rl_line_buffer = (char *) li->buffer;          rl_line_buffer = memchr(li->buffer, *li->buffer, 1);
         rl_point = rl_end = 0;          _rl_update_pos();
   
         return 0;          if (rl_startup_hook)
                   (*rl_startup_hook)(NULL, 0);
   
           return (0);
 }  }
   
   
 /*  /*
  * read one line from input stream and return it, chomping   * read one line from input stream and return it, chomping
  * trailing newline (if there is any)   * trailing newline (if there is any)
Line 206  readline(const char *prompt)
Line 327  readline(const char *prompt)
         HistEvent ev;          HistEvent ev;
         int count;          int count;
         const char *ret;          const char *ret;
           char *buf;
           static int used_event_hook;
   
         if (e == NULL || h == NULL)          if (e == NULL || h == NULL)
                 rl_initialize();                  rl_initialize();
   
           rl_done = 0;
   
         /* update prompt accordingly to what has been passed */          /* update prompt accordingly to what has been passed */
         if (!prompt) prompt = "";          if (!prompt)
         if (strcmp(el_rl_prompt, prompt) != 0) {                  prompt = "";
                 free(el_rl_prompt);          if (strcmp(rl_prompt, prompt) != 0) {
                 el_rl_prompt = strdup(prompt);                  free(rl_prompt);
                   rl_prompt = strdup(prompt);
                   if (rl_prompt == NULL)
                           return NULL;
           }
   
           if (rl_pre_input_hook)
                   (*rl_pre_input_hook)(NULL, 0);
   
           if (rl_event_hook && !(e->el_flags&NO_TTY)) {
                   el_set(e, EL_GETCFN, _rl_event_read_char);
                   used_event_hook = 1;
           }
   
           if (!rl_event_hook && used_event_hook) {
                   el_set(e, EL_GETCFN, EL_BUILTIN_GETCFN);
                   used_event_hook = 0;
         }          }
   
           rl_already_prompted = 0;
   
         /* get one line from input stream */          /* get one line from input stream */
         ret = el_gets(e, &count);          ret = el_gets(e, &count);
   
         if (ret && count > 0) {          if (ret && count > 0) {
                 char *foo;  
                 int lastidx;                  int lastidx;
   
                 foo = strdup(ret);                  buf = strdup(ret);
                   if (buf == NULL)
                           return NULL;
                 lastidx = count - 1;                  lastidx = count - 1;
                 if (foo[lastidx] == '\n')                  if (buf[lastidx] == '\n')
                         foo[lastidx] = '\0';                          buf[lastidx] = '\0';
   
                 ret = foo;  
         } else          } else
                 ret = NULL;                  buf = NULL;
   
         history(h, &ev, H_GETSIZE);          history(h, &ev, H_GETSIZE);
         history_length = ev.num;          history_length = ev.num;
   
         /* LINTED const cast */          return buf;
         return (char *) ret;  
 }  }
   
 /*  /*
Line 249  readline(const char *prompt)
Line 390  readline(const char *prompt)
  * history expansion functions   * history expansion functions
  */   */
 void  void
 using_history()  using_history(void)
 {  {
         if (h == NULL || e == NULL)          if (h == NULL || e == NULL)
                 rl_initialize();                  rl_initialize();
 }  }
   
   
 /*  /*
  * substitute ``what'' with ``with'', returning resulting string; if   * substitute ``what'' with ``with'', returning resulting string; if
  * globally == 1, substitutes all occurences of what, otherwise only the   * globally == 1, substitutes all occurrences of what, otherwise only the
  * first one   * first one
  */   */
 static char    *  static char *
 _rl_compat_sub(str, what, with, globally)  _rl_compat_sub(const char *str, const char *what, const char *with,
         const char     *str, *what, *with;      int globally)
         int             globally;  {
 {          const   char    *s;
         char           *result;          char    *r, *result;
         const char     *temp, *new;          size_t  len, with_len, what_len;
         int             len, with_len, what_len, add;  
         size_t          size, i;  
   
         result = malloc((size = 16));          len = strlen(str);
         temp = str;  
         with_len = strlen(with);          with_len = strlen(with);
         what_len = strlen(what);          what_len = strlen(what);
         len = 0;  
         do {          /* calculate length we need for result */
                 new = strstr(temp, what);          s = str;
                 if (new) {          while (*s) {
                         i = new - temp;                  if (*s == *what && !strncmp(s, what, what_len)) {
                         add = i + with_len;                          len += with_len - what_len;
                         if (i + add + 1 >= size) {                          if (!globally)
                                 size += add + 1;                                  break;
                                 result = realloc(result, size);                          s += what_len;
                         }                  } else
                         (void)strncpy(&result[len], temp, i);                          s++;
                         len += i;          }
                         (void)strcpy(&result[len], with);       /* safe */          r = result = malloc(len + 1);
                         len += with_len;          if (result == NULL)
                         temp = new + what_len;                  return NULL;
                 } else {          s = str;
                         add = strlen(temp);          while (*s) {
                         if (len + add + 1 >= size) {                  if (*s == *what && !strncmp(s, what, what_len)) {
                                 size += add + 1;                          (void)strncpy(r, with, with_len);
                                 result = realloc(result, size);                          r += with_len;
                           s += what_len;
                           if (!globally) {
                                   (void)strcpy(r, s);
                                   return(result);
                         }                          }
                         (void)strcpy(&result[len], temp);       /* safe */                  } else
                         len += add;                          *r++ = *s++;
                         temp = NULL;          }
           *r = 0;
           return(result);
   }
   
   static  char    *last_search_pat;       /* last !?pat[?] search pattern */
   static  char    *last_search_match;     /* last !?pat[?] that matched */
   
   const char *
   get_history_event(const char *cmd, int *cindex, int qchar)
   {
           int idx, sign, sub, num, begin, ret;
           size_t len;
           char    *pat;
           const char *rptr;
           HistEvent ev;
   
           idx = *cindex;
           if (cmd[idx++] != history_expansion_char)
                   return(NULL);
   
           /* find out which event to take */
           if (cmd[idx] == history_expansion_char || cmd[idx] == 0) {
                   if (history(h, &ev, H_FIRST) != 0)
                           return(NULL);
                   *cindex = cmd[idx]? (idx + 1):idx;
                   return(ev.str);
           }
           sign = 0;
           if (cmd[idx] == '-') {
                   sign = 1;
                   idx++;
           }
   
           if ('0' <= cmd[idx] && cmd[idx] <= '9') {
                   HIST_ENTRY *rl_he;
   
                   num = 0;
                   while (cmd[idx] && '0' <= cmd[idx] && cmd[idx] <= '9') {
                           num = num * 10 + cmd[idx] - '0';
                           idx++;
                 }                  }
         } while (temp && globally);                  if (sign)
         result[len] = '\0';                          num = history_length - num + 1;
   
                   if (!(rl_he = history_get(num)))
                           return(NULL);
   
         return result;                  *cindex = idx;
                   return(rl_he->line);
           }
           sub = 0;
           if (cmd[idx] == '?') {
                   sub = 1;
                   idx++;
           }
           begin = idx;
           while (cmd[idx]) {
                   if (cmd[idx] == '\n')
                           break;
                   if (sub && cmd[idx] == '?')
                           break;
                   if (!sub && (cmd[idx] == ':' || cmd[idx] == ' '
                                       || cmd[idx] == '\t' || cmd[idx] == qchar))
                           break;
                   idx++;
           }
           len = idx - begin;
           if (sub && cmd[idx] == '?')
                   idx++;
           if (sub && len == 0 && last_search_pat && *last_search_pat)
                   pat = last_search_pat;
           else if (len == 0)
                   return(NULL);
           else {
                   if ((pat = malloc(len + 1)) == NULL)
                           return NULL;
                   (void)strncpy(pat, cmd + begin, len);
                   pat[len] = '\0';
           }
   
           if (history(h, &ev, H_CURR) != 0) {
                   if (pat != last_search_pat)
                           free(pat);
                   return (NULL);
           }
           num = ev.num;
   
           if (sub) {
                   if (pat != last_search_pat) {
                           if (last_search_pat)
                                   free(last_search_pat);
                           last_search_pat = pat;
                   }
                   ret = history_search(pat, -1);
           } else
                   ret = history_search_prefix(pat, -1);
   
           if (ret == -1) {
                   /* restore to end of list on failed search */
                   history(h, &ev, H_FIRST);
                   (void)fprintf(rl_outstream, "%s: Event not found\n", pat);
                   if (pat != last_search_pat)
                           free(pat);
                   return(NULL);
           }
   
           if (sub && len) {
                   if (last_search_match && last_search_match != pat)
                           free(last_search_match);
                   last_search_match = pat;
           }
   
           if (pat != last_search_pat)
                   free(pat);
   
           if (history(h, &ev, H_CURR) != 0)
                   return(NULL);
           *cindex = idx;
           rptr = ev.str;
   
           /* roll back to original position */
           (void)history(h, &ev, H_SET, num);
   
           return rptr;
 }  }
   
 /*  /*
  * the real function doing history expansion - takes as argument command   * the real function doing history expansion - takes as argument command
  * to do and data upon which the command should be executed   * to do and data upon which the command should be executed
  * does expansion the way I've understood readline documentation   * does expansion the way I've understood readline documentation
  * word designator ``%'' isn't supported (yet ?)  
  *   *
  * returns 0 if data was not modified, 1 if it was and 2 if the string   * returns 0 if data was not modified, 1 if it was and 2 if the string
  * should be only printed and not executed; in case of error,   * should be only printed and not executed; in case of error,
Line 317  _rl_compat_sub(str, what, with, globally
Line 578  _rl_compat_sub(str, what, with, globally
  * it's callers responsibility to free() string returned in *result   * it's callers responsibility to free() string returned in *result
  */   */
 static int  static int
 _history_expand_command(command, cmdlen, result)  _history_expand_command(const char *command, size_t offs, size_t cmdlen,
         const char     *command;      char **result)
         size_t          cmdlen;  {
         char          **result;          char *tmp, *search = NULL, *aptr;
 {          const char *ptr, *cmd;
         char          **arr, *tempcmd, *line, *search = NULL, *cmd;          static char *from = NULL, *to = NULL;
         const char     *event_data = NULL;          int start, end, idx, has_mods = 0;
         static char    *from = NULL, *to = NULL;          int p_on = 0, g_on = 0;
         int             start = -1, end = -1, max, i, idx;  
         int             h_on = 0, t_on = 0, r_on = 0, e_on = 0, p_on = 0,  
                         g_on = 0;  
         int             event_num = 0, retval;  
         size_t          cmdsize;  
   
         *result = NULL;          *result = NULL;
           aptr = NULL;
           ptr = NULL;
   
         cmd = alloca(cmdlen + 1);          /* First get event specifier */
         (void)strncpy(cmd, command, cmdlen);          idx = 0;
         cmd[cmdlen] = 0;  
   
         idx = 1;          if (strchr(":^*$", command[offs + 1])) {
         /* find out which event to take */                  char str[4];
         if (cmd[idx] == history_expansion_char) {                  /*
                 event_num = history_length;                  * "!:" is shorthand for "!!:".
                 idx++;                  * "!^", "!*" and "!$" are shorthand for
                   * "!!:^", "!!:*" and "!!:$" respectively.
                   */
                   str[0] = str[1] = '!';
                   str[2] = '0';
                   ptr = get_history_event(str, &idx, 0);
                   idx = (command[offs + 1] == ':')? 1:0;
                   has_mods = 1;
         } else {          } else {
                 int    off, num;                  if (command[offs + 1] == '#') {
                 size_t len;                          /* use command so far */
                 off = idx;                          if ((aptr = malloc(offs + 1)) == NULL)
                 while (cmd[off] && !strchr(":^$*-%", cmd[off]))                                  return -1;
                         off++;                          (void)strncpy(aptr, command, offs);
                 num = atoi(&cmd[idx]);                          aptr[offs] = '\0';
                 if (num != 0) {                          idx = 1;
                         event_num = num;  
                         if (num < 0)  
                                 event_num += history_length + 1;  
                 } else {                  } else {
                         int prefix = 1, curr_num;                          int     qchar;
                         HistEvent ev;  
   
                         len = off - idx;                          qchar = (offs > 0 && command[offs - 1] == '"')? '"':0;
                         if (cmd[idx] == '?') {                          ptr = get_history_event(command + offs, &idx, qchar);
                                 idx++, len--;                  }
                                 if (cmd[off - 1] == '?')                  has_mods = command[offs + idx] == ':';
                                         len--;          }
                                 else if (cmd[off] != '\n' && cmd[off] != '\0')  
                                         return -1;  
                                 prefix = 0;  
                         }  
                         search = alloca(len + 1);  
                         (void)strncpy(search, &cmd[idx], len);  
                         search[len] = '\0';  
   
                         if (history(h, &ev, H_CURR) != 0)          if (ptr == NULL && aptr == NULL)
                                 return -1;                  return(-1);
                         curr_num = ev.num;  
   
                         if (prefix)          if (!has_mods) {
                                 retval = history_search_prefix(search, -1);                  *result = strdup(aptr? aptr : ptr);
                   if (aptr)
                           free(aptr);
                   return(1);
           }
   
           cmd = command + offs + idx + 1;
   
           /* Now parse any word designators */
   
           if (*cmd == '%')        /* last word matched by ?pat? */
                   tmp = strdup(last_search_match? last_search_match:"");
           else if (strchr("^*$-0123456789", *cmd)) {
                   start = end = -1;
                   if (*cmd == '^')
                           start = end = 1, cmd++;
                   else if (*cmd == '$')
                           start = -1, cmd++;
                   else if (*cmd == '*')
                           start = 1, cmd++;
                  else if (*cmd == '-' || isdigit((unsigned char) *cmd)) {
                           start = 0;
                           while (*cmd && '0' <= *cmd && *cmd <= '9')
                                   start = start * 10 + *cmd++ - '0';
   
                           if (*cmd == '-') {
                                   if (isdigit((unsigned char) cmd[1])) {
                                           cmd++;
                                           end = 0;
                                           while (*cmd && '0' <= *cmd && *cmd <= '9')
                                                   end = end * 10 + *cmd++ - '0';
                                   } else if (cmd[1] == '$') {
                                           cmd += 2;
                                           end = -1;
                                   } else {
                                           cmd++;
                                           end = -2;
                                   }
                           } else if (*cmd == '*')
                                   end = -1, cmd++;
                         else                          else
                                 retval = history_search(search, -1);                                  end = start;
                   }
                         if (retval == -1) {                  tmp = history_arg_extract(start, end, aptr? aptr:ptr);
                                 fprintf(rl_outstream, "%s: Event not found\n",                  if (tmp == NULL) {
                                         search);                          (void)fprintf(rl_outstream, "%s: Bad word specifier",
                                 return -1;                              command + offs + idx);
                         }                          if (aptr)
                         if (history(h, &ev, H_CURR) != 0)                                  free(aptr);
                                 return -1;                          return(-1);
                         event_data = ev.str;  
   
                         /* roll back to original position */  
                         history(h, &ev, H_NEXT_EVENT, curr_num);  
                 }                  }
                 idx = off;  
         }  
   
         if (!event_data && event_num >= 0) {  
                 HIST_ENTRY *rl_he;  
                 rl_he = history_get(event_num);  
                 if (!rl_he)  
                         return 0;  
                 event_data = rl_he->line;  
         } else          } else
                 return -1;                  tmp = strdup(aptr? aptr:ptr);
   
         if (cmd[idx] != ':')          if (aptr)
                 return -1;                  free(aptr);
         cmd += idx + 1;  
   
         /* recognize cmd */          if (*cmd == 0 || (cmd - (command + offs) >= cmdlen)) {
         if (*cmd == '^')                  *result = tmp;
                 start = end = 1, cmd++;                  return(1);
         else if (*cmd == '$')  
                 start = end = -1, cmd++;  
         else if (*cmd == '*')  
                 start = 1, end = -1, cmd++;  
         else if (isdigit((unsigned char) *cmd)) {  
                 const char *temp;  
                 int shifted = 0;  
   
                 start = atoi(cmd);  
                 temp = cmd;  
                 for (; isdigit((unsigned char) *cmd); cmd++);  
                 if (temp != cmd)  
                         shifted = 1;  
                 if (shifted && *cmd == '-') {  
                         if (!isdigit((unsigned char) *(cmd + 1)))  
                                 end = -2;  
                         else {  
                                 end = atoi(cmd + 1);  
                                 for (; isdigit((unsigned char) *cmd); cmd++);  
                         }  
                 } else if (shifted && *cmd == '*')  
                         end = -1, cmd++;  
                 else if (shifted)  
                         end = start;  
         }          }
         if (*cmd == ':')  
                 cmd++;  
   
         line = strdup(event_data);  
         for (; *cmd; cmd++) {          for (; *cmd; cmd++) {
                 if (*cmd == ':')                  if (*cmd == ':')
                         continue;                          continue;
                 else if (*cmd == 'h')                  else if (*cmd == 'h') {         /* remove trailing path */
                         h_on = 1 | g_on, g_on = 0;                          if ((aptr = strrchr(tmp, '/')) != NULL)
                 else if (*cmd == 't')                                  *aptr = 0;
                         t_on = 1 | g_on, g_on = 0;                  } else if (*cmd == 't') {       /* remove leading path */
                 else if (*cmd == 'r')                          if ((aptr = strrchr(tmp, '/')) != NULL) {
                         r_on = 1 | g_on, g_on = 0;                                  aptr = strdup(aptr + 1);
                 else if (*cmd == 'e')                                  free(tmp);
                         e_on = 1 | g_on, g_on = 0;                                  tmp = aptr;
                 else if (*cmd == 'p')                          }
                         p_on = 1 | g_on, g_on = 0;                  } else if (*cmd == 'r') {       /* remove trailing suffix */
                           if ((aptr = strrchr(tmp, '.')) != NULL)
                                   *aptr = 0;
                   } else if (*cmd == 'e') {       /* remove all but suffix */
                           if ((aptr = strrchr(tmp, '.')) != NULL) {
                                   aptr = strdup(aptr);
                                   free(tmp);
                                   tmp = aptr;
                           }
                   } else if (*cmd == 'p')         /* print only */
                           p_on = 1;
                 else if (*cmd == 'g')                  else if (*cmd == 'g')
                         g_on = 2;                          g_on = 2;
                 else if (*cmd == 's' || *cmd == '&') {                  else if (*cmd == 's' || *cmd == '&') {
                         char  *what, *with, delim;                          char *what, *with, delim;
                         int    len, from_len;                          size_t len, from_len;
                         size_t size;                          size_t size;
   
                         if (*cmd == '&' && (from == NULL || to == NULL))                          if (*cmd == '&' && (from == NULL || to == NULL))
Line 465  _history_expand_command(command, cmdlen,
Line 725  _history_expand_command(command, cmdlen,
                                 delim = *(++cmd), cmd++;                                  delim = *(++cmd), cmd++;
                                 size = 16;                                  size = 16;
                                 what = realloc(from, size);                                  what = realloc(from, size);
                                   if (what == NULL) {
                                           free(from);
                                           return 0;
                                   }
                                 len = 0;                                  len = 0;
                                 for (; *cmd && *cmd != delim; cmd++) {                                  for (; *cmd && *cmd != delim; cmd++) {
                                         if (*cmd == '\\'                                          if (*cmd == '\\' && cmd[1] == delim)
                                             && *(cmd + 1) == delim)  
                                                 cmd++;                                                  cmd++;
                                         if (len >= size)                                          if (len >= size) {
                                                 what = realloc(what,                                                  char *nwhat;
                                                     (size <<= 1));                                                  nwhat = realloc(what,
                                                                   (size <<= 1));
                                                   if (nwhat == NULL) {
                                                           free(what);
                                                           return 0;
                                                   }
                                                   what = nwhat;
                                           }
                                         what[len++] = *cmd;                                          what[len++] = *cmd;
                                 }                                  }
                                 what[len] = '\0';                                  what[len] = '\0';
                                 from = what;                                  from = what;
                                 if (*what == '\0') {                                  if (*what == '\0') {
                                         free(what);                                          free(what);
                                         if (search)                                          if (search) {
                                                 from = strdup(search);                                                  from = strdup(search);
                                         else {                                                  if (from == NULL)
                                                           return 0;
                                           } else {
                                                 from = NULL;                                                  from = NULL;
                                                 return -1;                                                  return (-1);
                                         }                                          }
                                 }                                  }
                                 cmd++;  /* shift after delim */                                  cmd++;  /* shift after delim */
Line 492  _history_expand_command(command, cmdlen,
Line 764  _history_expand_command(command, cmdlen,
   
                                 size = 16;                                  size = 16;
                                 with = realloc(to, size);                                  with = realloc(to, size);
                                   if (with == NULL) {
                                           free(to);
                                           return -1;
                                   }
                                 len = 0;                                  len = 0;
                                 from_len = strlen(from);                                  from_len = strlen(from);
                                 for (; *cmd && *cmd != delim; cmd++) {                                  for (; *cmd && *cmd != delim; cmd++) {
                                         if (len + from_len + 1 >= size) {                                          if (len + from_len + 1 >= size) {
                                                   char *nwith;
                                                 size += from_len + 1;                                                  size += from_len + 1;
                                                 with = realloc(with, size);                                                  nwith = realloc(with, size);
                                                   if (nwith == NULL) {
                                                           free(with);
                                                           return -1;
                                                   }
                                                   with = nwith;
                                         }                                          }
                                         if (*cmd == '&') {                                          if (*cmd == '&') {
                                                 /* safe */                                                  /* safe */
Line 513  _history_expand_command(command, cmdlen,
Line 795  _history_expand_command(command, cmdlen,
                                 }                                  }
                                 with[len] = '\0';                                  with[len] = '\0';
                                 to = with;                                  to = with;
   
                                 tempcmd = _rl_compat_sub(line, from, to,  
                                     (g_on) ? 1 : 0);  
                                 free(line);  
                                 line = tempcmd;  
                                 g_on = 0;  
                         }                          }
                 }  
         }  
   
         arr = history_tokenize(line);  
         free(line);             /* no more needed */  
         if (arr && *arr == NULL)  
                 free(arr), arr = NULL;  
         if (!arr)  
                 return -1;  
   
         /* find out max valid idx to array of array */                          aptr = _rl_compat_sub(tmp, from, to, g_on);
         max = 0;                          if (aptr) {
         for (i = 0; arr[i]; i++)                                  free(tmp);
                 max++;                                  tmp = aptr;
         max--;                          }
                           g_on = 0;
         /* set boundaries to something relevant */  
         if (start < 0)  
                 start = 1;  
         if (end < 0)  
                 end = max - ((end < -1) ? 1 : 0);  
   
         /* check boundaries ... */  
         if (start > max || end > max || start > end)  
                 return -1;  
   
         for (i = 0; i <= max; i++) {  
                 char           *temp;  
                 if (h_on && (i == 1 || h_on > 1) &&  
                     (temp = strrchr(arr[i], '/')))  
                         *(temp + 1) = '\0';  
                 if (t_on && (i == 1 || t_on > 1) &&  
                     (temp = strrchr(arr[i], '/')))  
                         (void)strcpy(arr[i], temp + 1);  
                 if (r_on && (i == 1 || r_on > 1) &&  
                     (temp = strrchr(arr[i], '.')))  
                         *temp = '\0';  
                 if (e_on && (i == 1 || e_on > 1) &&  
                     (temp = strrchr(arr[i], '.')))  
                         (void)strcpy(arr[i], temp);  
         }  
   
         cmdsize = 1, cmdlen = 0;  
         tempcmd = malloc(cmdsize);  
         for (i = start; start <= i && i <= end; i++) {  
                 int             arr_len;  
   
                 arr_len = strlen(arr[i]);  
                 if (cmdlen + arr_len + 1 >= cmdsize) {  
                         cmdsize += arr_len + 1;  
                         tempcmd = realloc(tempcmd, cmdsize);  
                 }                  }
                 (void)strcpy(&tempcmd[cmdlen], arr[i]); /* safe */  
                 cmdlen += arr_len;  
                 tempcmd[cmdlen++] = ' ';        /* add a space */  
         }          }
         while (cmdlen > 0 && isspace((unsigned char) tempcmd[cmdlen - 1]))          *result = tmp;
                 cmdlen--;          return (p_on? 2:1);
         tempcmd[cmdlen] = '\0';  
   
         *result = tempcmd;  
   
         for (i = 0; i <= max; i++)  
                 free(arr[i]);  
         free(arr), arr = (char **) NULL;  
         return (p_on) ? 2 : 1;  
 }  }
   
   
 /*  /*
  * csh-style history expansion   * csh-style history expansion
  */   */
 int  int
 history_expand(str, output)  history_expand(char *str, char **output)
         char           *str;  {
         char          **output;          int ret = 0;
 {          size_t idx, i, size;
         int             i, retval = 0, idx;          char *tmp, *result;
         size_t          size;  
         char           *temp, *result;  
   
         if (h == NULL || e == NULL)          if (h == NULL || e == NULL)
                 rl_initialize();                  rl_initialize();
   
         *output = strdup(str);  /* do it early */          if (history_expansion_char == 0) {
                   *output = strdup(str);
                   return(0);
           }
   
           *output = NULL;
         if (str[0] == history_subst_char) {          if (str[0] == history_subst_char) {
                 /* ^foo^foo2^ is equivalent to !!:s^foo^foo2^ */                  /* ^foo^foo2^ is equivalent to !!:s^foo^foo2^ */
                 temp = alloca(4 + strlen(str) + 1);                  *output = malloc(strlen(str) + 4 + 1);
                 temp[0] = temp[1] = history_expansion_char;                  if (*output == NULL)
                 temp[2] = ':';                          return 0;
                 temp[3] = 's';                  (*output)[0] = (*output)[1] = history_expansion_char;
                 (void)strcpy(temp + 4, str);                  (*output)[2] = ':';
                 str = temp;                  (*output)[3] = 's';
                   (void)strcpy((*output) + 4, str);
                   str = *output;
           } else {
                   *output = strdup(str);
                   if (*output == NULL)
                           return 0;
         }          }
 #define ADD_STRING(what, len)                                           \  
   #define ADD_STRING(what, len)                                           \
         {                                                               \          {                                                               \
                 if (idx + len + 1 > size)                               \                  if (idx + len + 1 > size) {                             \
                         result = realloc(result, (size += len + 1));    \                          char *nresult = realloc(result, (size += len + 1));\
                           if (nresult == NULL) {                          \
                                   free(*output);                          \
                                   return 0;                               \
                           }                                               \
                           result = nresult;                               \
                   }                                                       \
                 (void)strncpy(&result[idx], what, len);                 \                  (void)strncpy(&result[idx], what, len);                 \
                 idx += len;                                             \                  idx += len;                                             \
                 result[idx] = '\0';                                     \                  result[idx] = '\0';                                     \
Line 626  history_expand(str, output)
Line 863  history_expand(str, output)
         result = NULL;          result = NULL;
         size = idx = 0;          size = idx = 0;
         for (i = 0; str[i];) {          for (i = 0; str[i];) {
                 int start, j, loop_again;                  int qchar, loop_again;
                 size_t len;                  size_t len, start, j;
   
                   qchar = 0;
                 loop_again = 1;                  loop_again = 1;
                 start = j = i;                  start = j = i;
 loop:  loop:
Line 639  loop:
Line 877  loop:
                                 continue;                                  continue;
                         }                          }
                         if (!loop_again) {                          if (!loop_again) {
                                 if (str[j] == '?') {                                  if (isspace((unsigned char) str[j])
                                         while (str[j] && str[++j] != '?');                                      || str[j] == qchar)
                                         if (str[j] == '?')  
                                                 j++;  
                                 } else if (isspace((unsigned char) str[j]))  
                                         break;                                          break;
                         }                          }
                         if (str[j] == history_expansion_char                          if (str[j] == history_expansion_char
                             && !strchr(history_no_expand_chars, str[j + 1])                              && !strchr(history_no_expand_chars, str[j + 1])
                             && (!history_inhibit_expansion_function ||                              && (!history_inhibit_expansion_function ||
                         (*history_inhibit_expansion_function) (str, j) == 0))                              (*history_inhibit_expansion_function)(str,
                               (int)j) == 0))
                                 break;                                  break;
                 }                  }
   
                 if (str[j] && str[j + 1] != '#' && loop_again) {                  if (str[j] && loop_again) {
                         i = j;                          i = j;
                           qchar = (j > 0 && str[j - 1] == '"' )? '"':0;
                         j++;                          j++;
                         if (str[j] == history_expansion_char)                          if (str[j] == history_expansion_char)
                                 j++;                                  j++;
Line 662  loop:
Line 899  loop:
                         goto loop;                          goto loop;
                 }                  }
                 len = i - start;                  len = i - start;
                 temp = &str[start];                  tmp = &str[start];
                 ADD_STRING(temp, len);                  ADD_STRING(tmp, len);
   
                 if (str[i] == '\0' || str[i] != history_expansion_char                  if (str[i] == '\0' || str[i] != history_expansion_char) {
                     || str[i + 1] == '#') {  
                         len = j - i;                          len = j - i;
                         temp = &str[i];                          tmp = &str[i];
                         ADD_STRING(temp, len);                          ADD_STRING(tmp, len);
                         if (start == 0)                          if (start == 0)
                                 retval = 0;                                  ret = 0;
                         else                          else
                                 retval = 1;                                  ret = 1;
                         break;                          break;
                 }                  }
                 retval = _history_expand_command(&str[i], (size_t)(j - i),                  ret = _history_expand_command (str, i, (j - i), &tmp);
                                                  &temp);                  if (ret > 0 && tmp) {
                 if (retval != -1) {                          len = strlen(tmp);
                         len = strlen(temp);                          ADD_STRING(tmp, len);
                         ADD_STRING(temp, len);                          free(tmp);
                 }                  }
                 i = j;                  i = j;
         }                       /* for(i ...) */          }
   
         if (retval == 2) {          /* ret is 2 for "print only" option */
                 add_history(temp);          if (ret == 2) {
                   add_history(result);
 #ifdef GDB_411_HACK  #ifdef GDB_411_HACK
                 /* gdb 4.11 has been shipped with readline, where */                  /* gdb 4.11 has been shipped with readline, where */
                 /* history_expand() returned -1 when the line     */                  /* history_expand() returned -1 when the line     */
                 /* should not be executed; in readline 2.1+       */                  /* should not be executed; in readline 2.1+       */
                 /* it should return 2 in such a case              */                  /* it should return 2 in such a case              */
                 retval = -1;                  ret = -1;
 #endif  #endif
         }          }
         free(*output);          free(*output);
         *output = result;          *output = result;
   
         return retval;          return (ret);
   }
   
   /*
   * Return a string consisting of arguments of "str" from "start" to "end".
   */
   char *
   history_arg_extract(int start, int end, const char *str)
   {
           size_t  i, len, max;
           char    **arr, *result;
   
           arr = history_tokenize(str);
           if (!arr)
                   return(NULL);
           if (arr && *arr == NULL) {
                   free(arr);
                   return(NULL);
           }
   
           for (max = 0; arr[max]; max++)
                   continue;
           max--;
   
           if (start == '$')
                   start = max;
           if (end == '$')
                   end = max;
           if (end < 0)
                   end = max + end + 1;
           if (start < 0)
                   start = end;
   
           if (start < 0 || end < 0 || start > max || end > max || start > end)
                   return(NULL);
   
           for (i = start, len = 0; i <= end; i++)
                   len += strlen(arr[i]) + 1;
           len++;
           result = malloc(len);
           if (result == NULL)
                   return NULL;
   
           for (i = start, len = 0; i <= end; i++) {
                   (void)strcpy(result + len, arr[i]);
                   len += strlen(arr[i]);
                   if (i < end)
                           result[len++] = ' ';
           }
           result[len] = 0;
   
           for (i = 0; arr[i]; i++)
                   free(arr[i]);
           free(arr);
   
           return(result);
 }  }
   
 /*  /*
  * Parse the string into individual tokens, similarily to how shell would do it.   * Parse the string into individual tokens,
    * similar to how shell would do it.
  */   */
 char **  char **
 history_tokenize(str)  history_tokenize(const char *str)
         const char     *str;  
 {  {
         int  size = 1, result_idx = 0, i, start;          int size = 1, idx = 0, i, start;
         size_t len;          size_t len;
         char **result = NULL, *temp, delim = '\0';          char **result = NULL, *temp, delim = '\0';
   
         for (i = 0; str[i]; i++) {          for (i = 0; str[i];) {
                 while (isspace((unsigned char) str[i]))                  while (isspace((unsigned char) str[i]))
                         i++;                          i++;
                 start = i;                  start = i;
                 for (; str[i]; i++) {                  for (; str[i];) {
                         if (str[i] == '\\') {                          if (str[i] == '\\') {
                                 if (str[i] != '\0')                                  if (str[i+1] != '\0')
                                         i++;                                          i++;
                         } else if (str[i] == delim)                          } else if (str[i] == delim)
                                 delim = '\0';                                  delim = '\0';
                         else if (!delim &&                          else if (!delim &&
                             (isspace((unsigned char) str[i]) ||                                      (isspace((unsigned char) str[i]) ||
                             strchr("()<>;&|$", str[i])))                                  strchr("()<>;&|$", str[i])))
                                 break;                                  break;
                         else if (!delim && strchr("'`\"", str[i]))                          else if (!delim && strchr("'`\"", str[i]))
                                 delim = str[i];                                  delim = str[i];
                           if (str[i])
                                   i++;
                 }                  }
   
                 if (result_idx + 2 >= size) {                  if (idx + 2 >= size) {
                           char **nresult;
                         size <<= 1;                          size <<= 1;
                         result = realloc(result, size * sizeof(char *));                          nresult = realloc(result, size * sizeof(char *));
                           if (nresult == NULL) {
                                   free(result);
                                   return NULL;
                           }
                           result = nresult;
                 }                  }
                 len = i - start;                  len = i - start;
                 temp = malloc(len + 1);                  temp = malloc(len + 1);
                   if (temp == NULL) {
                           for (i = 0; i < idx; i++)
                                   free(result[i]);
                           free(result);
                           return NULL;
                   }
                 (void)strncpy(temp, &str[start], len);                  (void)strncpy(temp, &str[start], len);
                 temp[len] = '\0';                  temp[len] = '\0';
                 result[result_idx++] = temp;                  result[idx++] = temp;
                 result[result_idx] = NULL;                  result[idx] = NULL;
                   if (str[i])
                           i++;
         }          }
           return (result);
         return result;  
 }  }
   
   
 /*  /*
  * limit size of history record to ``max'' events   * limit size of history record to ``max'' events
  */   */
 void  void
 stifle_history(max)  stifle_history(int max)
         int max;  
 {  {
         HistEvent ev;          HistEvent ev;
   
Line 761  stifle_history(max)
Line 1068  stifle_history(max)
                 max_input_history = max;                  max_input_history = max;
 }  }
   
   
 /*  /*
  * "unlimit" size of history - set the limit to maximum allowed int value   * "unlimit" size of history - set the limit to maximum allowed int value
  */   */
 int  int
 unstifle_history()  unstifle_history(void)
 {  {
         HistEvent ev;          HistEvent ev;
         int omax;          int omax;
Line 773  unstifle_history()
Line 1081  unstifle_history()
         history(h, &ev, H_SETSIZE, INT_MAX);          history(h, &ev, H_SETSIZE, INT_MAX);
         omax = max_input_history;          omax = max_input_history;
         max_input_history = INT_MAX;          max_input_history = INT_MAX;
         return omax;            /* some value _must_ be returned */          return (omax);          /* some value _must_ be returned */
 }  }
   
   
 int  int
 history_is_stifled()  history_is_stifled(void)
 {  {
   
         /* cannot return true answer */          /* cannot return true answer */
         return (max_input_history != INT_MAX);          return (max_input_history != INT_MAX);
 }  }
   
   
 /*  /*
  * read history from a file given   * read history from a file given
  */   */
 int  int
 read_history(filename)  read_history(const char *filename)
         const char *filename;  
 {  {
         HistEvent ev;          HistEvent ev;
   
         if (h == NULL || e == NULL)          if (h == NULL || e == NULL)
                 rl_initialize();                  rl_initialize();
         return history(h, &ev, H_LOAD, filename);          return (history(h, &ev, H_LOAD, filename));
 }  }
   
   
 /*  /*
  * write history to a file given   * write history to a file given
  */   */
 int  int
 write_history(filename)  write_history(const char *filename)
         const char *filename;  
 {  {
         HistEvent ev;          HistEvent ev;
   
         if (h == NULL || e == NULL)          if (h == NULL || e == NULL)
                 rl_initialize();                  rl_initialize();
         return history(h, &ev, H_SAVE, filename);          return (history(h, &ev, H_SAVE, filename));
 }  }
   
   
 /*  /*
  * returns history ``num''th event   * returns history ``num''th event
  *   *
  * returned pointer points to static variable   * returned pointer points to static variable
  */   */
 HIST_ENTRY *  HIST_ENTRY *
 history_get(num)  history_get(int num)
         int             num;  
 {  {
         static HIST_ENTRY she;          static HIST_ENTRY she;
         HistEvent ev;          HistEvent ev;
         int i = 1, curr_num;          int curr_num;
   
         if (h == NULL || e == NULL)          if (h == NULL || e == NULL)
                 rl_initialize();                  rl_initialize();
   
         /* rewind to beginning */          /* save current position */
         if (history(h, &ev, H_CURR) != 0)          if (history(h, &ev, H_CURR) != 0)
                 return NULL;                  return (NULL);
         curr_num = ev.num;          curr_num = ev.num;
         if (history(h, &ev, H_LAST) != 0)  
                 return NULL;    /* error */          /* start from most recent */
         while (i < num && history(h, &ev, H_PREV) == 0)          if (history(h, &ev, H_FIRST) != 0)
                 i++;                  return (NULL);  /* error */
         if (i != num)  
                 return NULL;    /* not so many entries */          /* look backwards for event matching specified offset */
           if (history(h, &ev, H_NEXT_EVENT, num))
                   return (NULL);
   
         she.line = ev.str;          she.line = ev.str;
         she.data = NULL;          she.data = NULL;
   
         /* rewind history to the same event it was before */          /* restore pointer to where it was */
         (void) history(h, &ev, H_FIRST);          (void)history(h, &ev, H_SET, curr_num);
         (void) history(h, &ev, H_NEXT_EVENT, curr_num);  
   
         return &she;          return (&she);
 }  }
   
   
 /*  /*
  * add the line to history table   * add the line to history table
  */   */
 int  int
 add_history(line)  add_history(const char *line)
         const char *line;  
 {  {
         HistEvent ev;          HistEvent ev;
   
         if (h == NULL || e == NULL)          if (h == NULL || e == NULL)
                 rl_initialize();                  rl_initialize();
   
         (void) history(h, &ev, H_ENTER, line);          (void)history(h, &ev, H_ENTER, line);
         if (history(h, &ev, H_GETSIZE) == 0)          if (history(h, &ev, H_GETSIZE) == 0)
                 history_length = ev.num;                  history_length = ev.num;
   
         return (!(history_length > 0)); /* return 0 if all is okay */          return (!(history_length > 0)); /* return 0 if all is okay */
 }  }
   
   
   /*
    * remove the specified entry from the history list and return it.
    */
   HIST_ENTRY *
   remove_history(int num)
   {
           static HIST_ENTRY she;
           HistEvent ev;
   
           if (h == NULL || e == NULL)
                   rl_initialize();
   
           if (history(h, &ev, H_DEL, num) != 0)
                   return NULL;
   
           she.line = ev.str;
           she.data = NULL;
   
           return &she;
   }
   
   
 /*  /*
  * clear the history list - delete all entries   * clear the history list - delete all entries
  */   */
 void  void
 clear_history()  clear_history(void)
 {  {
         HistEvent ev;          HistEvent ev;
   
         history(h, &ev, H_CLEAR);          history(h, &ev, H_CLEAR);
 }  }
   
   
 /*  /*
  * returns offset of the current history event   * returns offset of the current history event
  */   */
 int  int
 where_history()  where_history(void)
 {  {
         HistEvent ev;          HistEvent ev;
         int curr_num, off;          int curr_num, off;
   
         if (history(h, &ev, H_CURR) != 0)          if (history(h, &ev, H_CURR) != 0)
                 return 0;                  return (0);
         curr_num = ev.num;          curr_num = ev.num;
   
         history(h, &ev, H_FIRST);          history(h, &ev, H_FIRST);
Line 895  where_history()
Line 1231  where_history()
         while (ev.num != curr_num && history(h, &ev, H_NEXT) == 0)          while (ev.num != curr_num && history(h, &ev, H_NEXT) == 0)
                 off++;                  off++;
   
         return off;          return (off);
 }  }
   
   
 /*  /*
  * returns current history event or NULL if there is no such event   * returns current history event or NULL if there is no such event
  */   */
 HIST_ENTRY *  HIST_ENTRY *
 current_history()  current_history(void)
 {  {
         return _move_history(H_CURR);  
           return (_move_history(H_CURR));
 }  }
   
   
 /*  /*
  * returns total number of bytes history events' data are using   * returns total number of bytes history events' data are using
  */   */
 int  int
 history_total_bytes()  history_total_bytes(void)
 {  {
         HistEvent ev;          HistEvent ev;
         int curr_num, size;          int curr_num, size;
   
         if (history(h, &ev, H_CURR) != 0)          if (history(h, &ev, H_CURR) != 0)
                 return -1;                  return (-1);
         curr_num = ev.num;          curr_num = ev.num;
   
         history(h, &ev, H_FIRST);          history(h, &ev, H_FIRST);
Line 929  history_total_bytes()
Line 1268  history_total_bytes()
         /* get to the same position as before */          /* get to the same position as before */
         history(h, &ev, H_PREV_EVENT, curr_num);          history(h, &ev, H_PREV_EVENT, curr_num);
   
         return size;          return (size);
 }  }
   
   
 /*  /*
  * sets the position in the history list to ``pos''   * sets the position in the history list to ``pos''
  */   */
 int  int
 history_set_pos(pos)  history_set_pos(int pos)
         int pos;  
 {  {
         HistEvent ev;          HistEvent ev;
         int off, curr_num;          int curr_num;
   
         if (pos > history_length || pos < 0)          if (pos > history_length || pos < 0)
                 return -1;                  return (-1);
   
         history(h, &ev, H_CURR);          history(h, &ev, H_CURR);
         curr_num = ev.num;          curr_num = ev.num;
         history(h, &ev, H_FIRST);  
         off = 0;  
         while (off < pos && history(h, &ev, H_NEXT) == 0)  
                 off++;  
   
         if (off != pos) {       /* do a rollback in case of error */          if (history(h, &ev, H_SET, pos)) {
                 history(h, &ev, H_FIRST);                  history(h, &ev, H_SET, curr_num);
                 history(h, &ev, H_NEXT_EVENT, curr_num);                  return(-1);
                 return -1;  
         }          }
         return 0;          return (0);
 }  }
   
   
 /*  /*
  * returns previous event in history and shifts pointer accordingly   * returns previous event in history and shifts pointer accordingly
  */   */
 HIST_ENTRY *  HIST_ENTRY *
 previous_history()  previous_history(void)
 {  {
         return _move_history(H_PREV);  
           return (_move_history(H_PREV));
 }  }
   
   
 /*  /*
  * returns next event in history and shifts pointer accordingly   * returns next event in history and shifts pointer accordingly
  */   */
 HIST_ENTRY *  HIST_ENTRY *
 next_history()  next_history(void)
 {  {
         return _move_history(H_NEXT);  
           return (_move_history(H_NEXT));
 }  }
   
   
 /*  /*
  * generic history search function   * searches for first history event containing the str
  */   */
 static int  int
 _history_search_gen(str, direction, pos)  history_search(const char *str, int direction)
         const char *str;  {
         int direction, pos;          HistEvent ev;
 {          const char *strp;
         HistEvent       ev;          int curr_num;
         const char     *strp;  
         int             curr_num;  
   
         if (history(h, &ev, H_CURR) != 0)          if (history(h, &ev, H_CURR) != 0)
                 return -1;                  return (-1);
         curr_num = ev.num;          curr_num = ev.num;
   
         for (;;) {          for (;;) {
                 strp = strstr(ev.str, str);                  if ((strp = strstr(ev.str, str)) != NULL)
                 if (strp && (pos < 0 || &ev.str[pos] == strp))  
                         return (int) (strp - ev.str);                          return (int) (strp - ev.str);
                 if (history(h, &ev, direction < 0 ? H_PREV : H_NEXT) != 0)                  if (history(h, &ev, direction < 0 ? H_NEXT:H_PREV) != 0)
                         break;                          break;
         }          }
           history(h, &ev, H_SET, curr_num);
         history(h, &ev, direction < 0 ? H_NEXT_EVENT : H_PREV_EVENT, curr_num);          return (-1);
   
         return -1;  
 }  }
   
 /*  
  * searches for first history event containing the str  
  */  
 int  
 history_search(str, direction)  
         const char     *str;  
         int             direction;  
 {  
         return _history_search_gen(str, direction, -1);  
 }  
   
 /*  /*
  * searches for first history event beginning with str   * searches for first history event beginning with str
  */   */
 int  int
 history_search_prefix(str, direction)  history_search_prefix(const char *str, int direction)
         const char     *str;  
         int             direction;  
 {  {
         return _history_search_gen(str, direction, 0);          HistEvent ev;
   
           return (history(h, &ev, direction < 0? H_PREV_STR:H_NEXT_STR, str));
 }  }
   
   
 /*  /*
  * search for event in history containing str, starting at offset   * search for event in history containing str, starting at offset
  * abs(pos); continue backward, if pos<0, forward otherwise   * abs(pos); continue backward, if pos<0, forward otherwise
  */   */
 /* ARGSUSED */  /* ARGSUSED */
 int  int
 history_search_pos(str, direction, pos)  history_search_pos(const char *str,
         const char     *str;                     int direction __attribute__((__unused__)), int pos)
         int             direction, pos;  
 {  {
         HistEvent       ev;          HistEvent ev;
         int             curr_num, off;          int curr_num, off;
   
         off = (pos > 0) ? pos : -pos;          off = (pos > 0) ? pos : -pos;
         pos = (pos > 0) ? 1 : -1;          pos = (pos > 0) ? 1 : -1;
   
         if (history(h, &ev, H_CURR) != 0)          if (history(h, &ev, H_CURR) != 0)
                 return -1;                  return (-1);
         curr_num = ev.num;          curr_num = ev.num;
   
         if (history_set_pos(off) != 0 || history(h, &ev, H_CURR) != 0)          if (history_set_pos(off) != 0 || history(h, &ev, H_CURR) != 0)
                 return -1;                  return (-1);
   
   
         for (;;) {          for (;;) {
                 if (strstr(ev.str, str))                  if (strstr(ev.str, str))
                         return off;                          return (off);
                 if (history(h, &ev, (pos < 0) ? H_PREV : H_NEXT) != 0)                  if (history(h, &ev, (pos < 0) ? H_PREV : H_NEXT) != 0)
                         break;                          break;
         }          }
Line 1063  history_search_pos(str, direction, pos)
Line 1387  history_search_pos(str, direction, pos)
         /* set "current" pointer back to previous state */          /* set "current" pointer back to previous state */
         history(h, &ev, (pos < 0) ? H_NEXT_EVENT : H_PREV_EVENT, curr_num);          history(h, &ev, (pos < 0) ? H_NEXT_EVENT : H_PREV_EVENT, curr_num);
   
         return -1;          return (-1);
 }  }
   
   
 /********************************/  /********************************/
 /* completition functions        */  /* completion functions */
   
 /*  
  * does tilde expansion of strings of type ``~user/foo''  
  * if ``user'' isn't valid user name or ``txt'' doesn't start  
  * w/ '~', returns pointer to strdup()ed copy of ``txt''  
  *  
  * it's callers's responsibility to free() returned string  
  */  
 char *  char *
 tilde_expand(txt)  tilde_expand(char *name)
         char     *txt;  
 {  {
         struct passwd  *pass;          return fn_tilde_expand(name);
         char           *temp;  
         size_t          len = 0;  
   
         if (txt[0] != '~')  
                 return strdup(txt);  
   
         temp = strchr(txt + 1, '/');  
         if (temp == NULL)  
                 temp = strdup(txt + 1);  
         else {  
                 len = temp - txt + 1;   /* text until string after slash */  
                 temp = malloc(len);  
                 (void)strncpy(temp, txt + 1, len - 2);  
                 temp[len - 2] = '\0';  
         }  
         pass = getpwnam(temp);  
         free(temp);             /* value no more needed */  
         if (pass == NULL)  
                 return strdup(txt);  
   
         /* update pointer txt to point at string immedially following */  
         /* first slash */  
         txt += len;  
   
         temp = malloc(strlen(pass->pw_dir) + 1 + strlen(txt) + 1);  
         (void)sprintf(temp, "%s/%s", pass->pw_dir, txt);  
   
         return temp;  
 }  }
   
 /*  char *
  * return first found file name starting by the ``text'' or NULL if no  filename_completion_function(const char *name, int state)
  * such file can be found  {
  * value of ``state'' is ignored          return fn_filename_completion_function(name, state);
  *  
  * it's caller's responsibility to free returned string  
  */  
 char           *  
 filename_completion_function(text, state)  
         const char     *text;  
         int             state;  
 {  
         static DIR     *dir = NULL;  
         static char    *filename = NULL, *dirname = NULL;  
         static size_t   filename_len = 0;  
         struct dirent  *entry;  
         char           *temp;  
         size_t          len;  
   
         if (state == 0 || dir == NULL) {  
                 if (dir != NULL) {  
                         closedir(dir);  
                         dir = NULL;  
                 }  
                 temp = strrchr(text, '/');  
                 if (temp) {  
                         temp++;  
                         filename = realloc(filename, strlen(temp) + 1);  
                         (void)strcpy(filename, temp);  
                         len = temp - text;      /* including last slash */  
                         dirname = realloc(dirname, len + 1);  
                         (void)strncpy(dirname, text, len);  
                         dirname[len] = '\0';  
                 } else {  
                         filename = strdup(text);  
                         dirname = NULL;  
                 }  
   
                 /* support for ``~user'' syntax */  
                 if (dirname && *dirname == '~') {  
                         temp = tilde_expand(dirname);  
                         dirname = realloc(dirname, strlen(temp) + 1);  
                         (void)strcpy(dirname, temp);    /* safe */  
                         free(temp);     /* no more needed */  
                 }  
                 /* will be used in cycle */  
                 filename_len = strlen(filename);  
                 if (filename_len == 0)  
                         return NULL;    /* no expansion possible */  
   
                 dir = opendir(dirname ? dirname : ".");  
                 if (!dir)  
                         return NULL;    /* cannot open the directory */  
         }  
         /* find the match */  
         while ((entry = readdir(dir)) != NULL) {  
                 /* otherwise, get first entry where first */  
                 /* filename_len characters are equal      */  
                 if (entry->d_name[0] == filename[0]  
 #if defined(__SVR4) || defined(__linux__)  
                     && strlen(entry->d_name) >= filename_len  
 #else  
                     && entry->d_namlen >= filename_len  
 #endif  
                     && strncmp(entry->d_name, filename,  
                                filename_len) == 0)  
                         break;  
         }  
   
         if (entry) {            /* match found */  
   
                 struct stat     stbuf;  
 #if defined(__SVR4) || defined(__linux__)  
                 len = strlen(entry->d_name) +  
 #else  
                 len = entry->d_namlen +  
 #endif  
                         ((dirname) ? strlen(dirname) : 0) + 1 + 1;  
                 temp = malloc(len);  
                 (void)sprintf(temp, "%s%s",  
                         dirname ? dirname : "", entry->d_name); /* safe */  
   
                 /* test, if it's directory */  
                 if (stat(temp, &stbuf) == 0 && S_ISDIR(stbuf.st_mode))  
                         strcat(temp, "/");      /* safe */  
         } else  
                 temp = NULL;  
   
         return temp;  
 }  }
   
 /*  /*
Line 1210  filename_completion_function(text, state
Line 1413  filename_completion_function(text, state
  * (usually '~'); state is ignored   * (usually '~'); state is ignored
  * it's callers responsibility to free returned value   * it's callers responsibility to free returned value
  */   */
 char           *  char *
 username_completion_function(text, state)  username_completion_function(const char *text, int state)
         const char     *text;  
         int             state;  
 {  {
         struct passwd  *pwd;          struct passwd *pwd, pwres;
           char pwbuf[1024];
   
         if (text[0] == '\0')          if (text[0] == '\0')
                 return NULL;                  return (NULL);
   
         if (*text == '~')          if (*text == '~')
                 text++;                  text++;
Line 1226  username_completion_function(text, state
Line 1428  username_completion_function(text, state
         if (state == 0)          if (state == 0)
                 setpwent();                  setpwent();
   
         while ((pwd = getpwent()) && text[0] == pwd->pw_name[0]          while (getpwent_r(&pwres, pwbuf, sizeof(pwbuf), &pwd) == 0
                && strcmp(text, pwd->pw_name) == 0);              && pwd != NULL && text[0] == pwd->pw_name[0]
               && strcmp(text, pwd->pw_name) == 0);
   
         if (pwd == NULL) {          if (pwd == NULL) {
                 endpwent();                  endpwent();
                 return NULL;                  return (NULL);
         }          }
         return strdup(pwd->pw_name);          return (strdup(pwd->pw_name));
 }  }
   
   
 /*  /*
  * el-compatible wrapper around rl_complete; needed for key binding   * el-compatible wrapper to send TSTP on ^Z
  */   */
 /* ARGSUSED */  /* ARGSUSED */
 static unsigned char  static unsigned char
 _el_rl_complete(el, ch)  _el_rl_tstp(EditLine *el __attribute__((__unused__)), int ch __attribute__((__unused__)))
         EditLine       *el;  
         int             ch;  
 {  {
         return (unsigned char) rl_complete(0, ch);          (void)kill(0, SIGTSTP);
           return CC_NORM;
 }  }
   
 /*  /*
  * returns list of completitions for text given   * Display list of strings in columnar format on readline's output stream.
    * 'matches' is list of strings, 'len' is number of strings in 'matches',
    * 'max' is maximum length of string in 'matches'.
  */   */
 char          **  void
 completion_matches(text, genfunc)  rl_display_match_list(char **matches, int len, int max)
         const char     *text;  
         CPFunction     *genfunc;  
 {  {
         char          **match_list = NULL, *retstr, *prevstr;  
         size_t          math_list_len, max_equal, which, i;  
         int             matches;  
   
         if (h == NULL || e == NULL)  
                 rl_initialize();  
   
         matches = 0;          fn_display_match_list(e, matches, len, max);
         math_list_len = 1;  
         while ((retstr = (*genfunc) (text, matches)) != NULL) {  
                 if (matches + 1 >= math_list_len) {  
                         math_list_len <<= 1;  
                         match_list = realloc(match_list,  
                             math_list_len * sizeof(char *));  
                 }  
                 match_list[++matches] = retstr;  
         }  
   
         if (!match_list)  
                 return (char **) NULL;  /* nothing found */  
   
         /* find least denominator and insert it to match_list[0] */  
         which = 2;  
         prevstr = match_list[1];  
         max_equal = strlen(prevstr);  
         for (; which < matches; which++) {  
                 for (i = 0; i < max_equal &&  
                     prevstr[i] == match_list[which][i]; i++)  
                         continue;  
                 max_equal = i;  
         }  
   
         retstr = malloc(max_equal + 1);  
         (void)strncpy(retstr, match_list[1], max_equal);  
         retstr[max_equal] = '\0';  
         match_list[0] = retstr;  
   
         /* add NULL as last pointer to the array */  
         if (matches + 1 >= math_list_len)  
                 match_list = realloc(match_list,  
                     (math_list_len + 1) * sizeof(char *));  
         match_list[matches + 1] = (char *) NULL;  
   
         return match_list;  
 }  }
   
 /*  static const char *
  * called by rl_complete()  /*ARGSUSED*/
  */  _rl_completion_append_character_function(const char *dummy
 /* ARGSUSED */      __attribute__((__unused__)))
 static int  
 rl_complete_internal(what_to_do)  
         int             what_to_do;  
 {  {
         CPFunction     *complet_func;          static char buf[2];
         const LineInfo *li;          buf[1] = rl_completion_append_character;
         char           *temp, *temp2, **arr;          return buf;
         size_t          len;  
   
         if (h == NULL || e == NULL)  
                 rl_initialize();  
   
         complet_func = rl_completion_entry_function;  
         if (!complet_func)  
                 complet_func = filename_completion_function;  
   
         li = el_line(e);  
         /* LINTED const cast */  
         temp = (char *) li->cursor;  
         while (temp > li->buffer &&  
             !strchr(rl_basic_word_break_characters, *(temp - 1)))  
                 temp--;  
   
         len = li->cursor - temp;  
         temp2 = alloca(len + 1);  
         (void)strncpy(temp2, temp, len);  
         temp = temp2;  
         temp[len] = '\0';  
   
         /* these can be used by function called in completion_matches() */  
         /* or (*rl_attempted_completion_function)() */  
         rl_point = li->cursor - li->buffer;  
         rl_end = li->lastchar - li->buffer;  
   
         if (!rl_attempted_completion_function)  
                 arr = completion_matches(temp, complet_func);  
         else {  
                 int             end = li->cursor - li->buffer;  
                 arr = (*rl_attempted_completion_function) (temp, (int)  
                                                            (end - len), end);  
         }  
   
         if (arr) {  
                 int             i;  
   
                 el_deletestr(e, (int)len);  
                 el_insertstr(e, arr[0]);  
                 if (strcmp(arr[0], arr[1]) == 0) {  
                         /* lcd is valid object, so add a space to mark it */  
                         /* in case of filename completition, add a space  */  
                         /* only if object found is not directory          */  
                         size_t alen = strlen(arr[0]);  
                         if (complet_func != filename_completion_function  
                             || (alen > 0 && (arr[0])[alen - 1] != '/'))  
                                 el_insertstr(e, " ");  
                 } else  
                         /* lcd is not a valid object - further specification */  
                         /* is needed */  
                         el_beep(e);  
   
                 /* free elements of array and the array itself */  
                 for (i = 0; arr[i]; i++)  
                         free(arr[i]);  
                 free(arr), arr = NULL;  
   
                 return CC_REFRESH;  
         }  
         return CC_NORM;  
 }  }
   
   
 /*  /*
  * complete word at current point   * complete word at current point
  */   */
   /* ARGSUSED */
 int  int
 rl_complete(ignore, invoking_key)  rl_complete(int ignore __attribute__((__unused__)), int invoking_key)
         int             ignore, invoking_key;  
 {  {
         if (h == NULL || e == NULL)          if (h == NULL || e == NULL)
                 rl_initialize();                  rl_initialize();
   
         if (rl_inhibit_completion) {          if (rl_inhibit_completion) {
                 rl_insert(ignore, invoking_key);                  char arr[2];
                 return CC_REFRESH;                  arr[0] = (char)invoking_key;
         } else                  arr[1] = '\0';
                 return rl_complete_internal(invoking_key);                  el_insertstr(e, arr);
                   return (CC_REFRESH);
           }
   
           /* Just look at how many global variables modify this operation! */
           return fn_complete(e,
               (CPFunction *)rl_completion_entry_function,
               rl_attempted_completion_function,
               rl_basic_word_break_characters, rl_special_prefixes,
               _rl_completion_append_character_function, rl_completion_query_items,
               &rl_completion_type, &rl_attempted_completion_over,
               &rl_point, &rl_end);
   }
   
   
   /* ARGSUSED */
   static unsigned char
   _el_rl_complete(EditLine *el __attribute__((__unused__)), int ch)
   {
           return (unsigned char)rl_complete(0, ch);
 }  }
   
 /*  /*
Line 1401  rl_complete(ignore, invoking_key)
Line 1518  rl_complete(ignore, invoking_key)
  * bind key c to readline-type function func   * bind key c to readline-type function func
  */   */
 int  int
 rl_bind_key(c, func)  rl_bind_key(int c, int func(int, int))
         int             c;  
         int func        __P((int, int));  
 {  {
         int             retval = -1;          int retval = -1;
   
         if (h == NULL || e == NULL)          if (h == NULL || e == NULL)
                 rl_initialize();                  rl_initialize();
Line 1415  rl_bind_key(c, func)
Line 1530  rl_bind_key(c, func)
                 e->el_map.key[c] = ED_INSERT;                  e->el_map.key[c] = ED_INSERT;
                 retval = 0;                  retval = 0;
         }          }
         return retval;          return (retval);
 }  }
   
   
 /*  /*
  * read one key from input - handles chars pushed back   * read one key from input - handles chars pushed back
  * to input stream also   * to input stream also
  */   */
 int  int
 rl_read_key()  rl_read_key(void)
 {  {
         char            fooarr[2 * sizeof(int)];          char fooarr[2 * sizeof(int)];
   
         if (e == NULL || h == NULL)          if (e == NULL || h == NULL)
                 rl_initialize();                  rl_initialize();
   
         return el_getc(e, fooarr);          return (el_getc(e, fooarr));
 }  }
   
   
 /*  /*
  * reset the terminal   * reset the terminal
  */   */
 /* ARGSUSED */  /* ARGSUSED */
 void  void
 rl_reset_terminal(p)  rl_reset_terminal(const char *p __attribute__((__unused__)))
         const char     *p;  
 {  {
   
         if (h == NULL || e == NULL)          if (h == NULL || e == NULL)
                 rl_initialize();                  rl_initialize();
         el_reset(e);          el_reset(e);
 }  }
   
   
 /*  /*
  * insert character ``c'' back into input stream, ``count'' times   * insert character ``c'' back into input stream, ``count'' times
  */   */
 int  int
 rl_insert(count, c)  rl_insert(int count, int c)
         int             count, c;  
 {  {
         char            arr[2];          char arr[2];
   
         if (h == NULL || e == NULL)          if (h == NULL || e == NULL)
                 rl_initialize();                  rl_initialize();
Line 1465  rl_insert(count, c)
Line 1582  rl_insert(count, c)
         for (; count > 0; count--)          for (; count > 0; count--)
                 el_push(e, arr);                  el_push(e, arr);
   
           return (0);
   }
   
   /*ARGSUSED*/
   int
   rl_newline(int count, int c)
   {
           /*
            * Readline-4.0 appears to ignore the args.
            */
           return rl_insert(1, '\n');
   }
   
   /*ARGSUSED*/
   static unsigned char
   rl_bind_wrapper(EditLine *el, unsigned char c)
   {
           if (map[c] == NULL)
               return CC_ERROR;
   
           _rl_update_pos();
   
           (*map[c])(NULL, c);
   
           /* If rl_done was set by the above call, deal with it here */
           if (rl_done)
                   return CC_EOF;
   
           return CC_NORM;
   }
   
   int
   rl_add_defun(const char *name, Function *fun, int c)
   {
           char dest[8];
           if (c >= sizeof(map) / sizeof(map[0]) || c < 0)
                   return -1;
           map[(unsigned char)c] = fun;
           el_set(e, EL_ADDFN, name, name, rl_bind_wrapper);
           vis(dest, c, VIS_WHITE|VIS_NOSLASH, 0);
           el_set(e, EL_BIND, dest, name);
           return 0;
   }
   
   void
   rl_callback_read_char()
   {
           int count = 0, done = 0;
           const char *buf = el_gets(e, &count);
           char *wbuf;
   
           if (buf == NULL || count-- <= 0)
                   return;
           if (count == 0 && buf[0] == CTRL('d'))
                   done = 1;
           if (buf[count] == '\n' || buf[count] == '\r')
                   done = 2;
   
           if (done && rl_linefunc != NULL) {
                   el_set(e, EL_UNBUFFERED, 0);
                   if (done == 2) {
                       if ((wbuf = strdup(buf)) != NULL)
                           wbuf[count] = '\0';
                   } else
                           wbuf = NULL;
                   (*(void (*)(const char *))rl_linefunc)(wbuf);
                   el_set(e, EL_UNBUFFERED, 1);
           }
   }
   
   void
   rl_callback_handler_install (const char *prompt, VCPFunction *linefunc)
   {
           if (e == NULL) {
                   rl_initialize();
           }
           if (rl_prompt)
                   free(rl_prompt);
           rl_prompt = prompt ? strdup(strchr(prompt, *prompt)) : NULL;
           rl_linefunc = linefunc;
           el_set(e, EL_UNBUFFERED, 1);
   }
   
   void
   rl_callback_handler_remove(void)
   {
           el_set(e, EL_UNBUFFERED, 0);
   }
   
   void
   rl_redisplay(void)
   {
           char a[2];
           a[0] = CTRL('r');
           a[1] = '\0';
           el_push(e, a);
   }
   
   int
   rl_get_previous_history(int count, int key)
   {
           char a[2];
           a[0] = key;
           a[1] = '\0';
           while (count--)
                   el_push(e, a);
         return 0;          return 0;
 }  }
   
   void
   /*ARGSUSED*/
   rl_prep_terminal(int meta_flag)
   {
           el_set(e, EL_PREP_TERM, 1);
   }
   
   void
   rl_deprep_terminal()
   {
           el_set(e, EL_PREP_TERM, 0);
   }
   
   int
   rl_read_init_file(const char *s)
   {
           return(el_source(e, s));
   }
   
   int
   rl_parse_and_bind(const char *line)
   {
           const char **argv;
           int argc;
           Tokenizer *tok;
   
           tok = tok_init(NULL);
           tok_str(tok, line, &argc, &argv);
           argc = el_parse(e, argc, argv);
           tok_end(tok);
           return (argc ? 1 : 0);
   }
   
   int
   rl_variable_bind(const char *var, const char *value)
   {
           /*
            * The proper return value is undocument, but this is what the
            * readline source seems to do.
            */
           return ((el_set(e, EL_BIND, "", var, value) == -1) ? 1 : 0);
   }
   
   void
   rl_stuff_char(int c)
   {
           char buf[2];
   
           buf[0] = c;
           buf[1] = '\0';
           el_insertstr(e, buf);
   }
   
   static int
   _rl_event_read_char(EditLine *el, char *cp)
   {
           int     n, num_read = 0;
   
           *cp = 0;
           while (rl_event_hook) {
   
                   (*rl_event_hook)();
   
   #if defined(FIONREAD)
                   if (ioctl(el->el_infd, FIONREAD, &n) < 0)
                           return(-1);
                   if (n)
                           num_read = read(el->el_infd, cp, 1);
                   else
                           num_read = 0;
   #elif defined(F_SETFL) && defined(O_NDELAY)
                   if ((n = fcntl(el->el_infd, F_GETFL, 0)) < 0)
                           return(-1);
                   if (fcntl(el->el_infd, F_SETFL, n|O_NDELAY) < 0)
                           return(-1);
                   num_read = read(el->el_infd, cp, 1);
                   if (fcntl(el->el_infd, F_SETFL, n))
                           return(-1);
   #else
                   /* not non-blocking, but what you gonna do? */
                   num_read = read(el->el_infd, cp, 1);
                   return(-1);
   #endif
   
                   if (num_read < 0 && errno == EAGAIN)
                           continue;
                   if (num_read == 0)
                           continue;
                   break;
           }
           if (!rl_event_hook)
                   el_set(el, EL_GETCFN, EL_BUILTIN_GETCFN);
           return(num_read);
   }
   
   static void
   _rl_update_pos(void)
   {
           const LineInfo *li = el_line(e);
   
           rl_point = li->cursor - li->buffer;
           rl_end = li->lastchar - li->buffer;
   }

Legend:
Removed from v.1.10  
changed lines
  Added in v.1.59

CVSweb <webmaster@jp.NetBSD.org>