[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.84 and 1.85

version 1.84, 2009/07/22 15:57:40 version 1.85, 2009/09/07 21:24:33
Line 70  void rl_deprep_terminal(void);
Line 70  void rl_deprep_terminal(void);
 /* 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";
   int rl_readline_version = RL_READLINE_VERSION;
 static char empty[] = { '\0' };  static char empty[] = { '\0' };
 static char expand_chars[] = { ' ', '\t', '\n', '=', '(', '\0' };  static char expand_chars[] = { ' ', '\t', '\n', '=', '(', '\0' };
 static char break_chars[] = { ' ', '\t', '\n', '"', '\\', '\'', '`', '@', '$',  static char break_chars[] = { ' ', '\t', '\n', '"', '\\', '\'', '`', '@', '$',
Line 118  Function *rl_startup_hook = NULL;
Line 119  Function *rl_startup_hook = NULL;
 VFunction *rl_completion_display_matches_hook = NULL;  VFunction *rl_completion_display_matches_hook = NULL;
 VFunction *rl_prep_term_function = (VFunction *)rl_prep_terminal;  VFunction *rl_prep_term_function = (VFunction *)rl_prep_terminal;
 VFunction *rl_deprep_term_function = (VFunction *)rl_deprep_terminal;  VFunction *rl_deprep_term_function = (VFunction *)rl_deprep_terminal;
   KEYMAP_ENTRY_ARRAY emacs_meta_keymap;
   
 /*  /*
  * The current prompt string.   * The current prompt string.
Line 214  _getc_function(EditLine *el, char *c)
Line 216  _getc_function(EditLine *el, char *c)
         return 1;          return 1;
 }  }
   
   static const char _dothistory[] = "/.history";
   
   static const char *
   _default_history_file(void)
   {
           struct passwd *p;
           static char path[PATH_MAX];
   
           if (*path)
                   return path;
           if ((p = getpwuid(getuid())) == NULL)
                   return NULL;
           strlcpy(path, p->pw_dir, PATH_MAX);
           strlcat(path, _dothistory, PATH_MAX);
           return path;
   }
   
 /*  /*
  * READLINE compatibility stuff   * READLINE compatibility stuff
Line 648  _history_expand_command(const char *comm
Line 666  _history_expand_command(const char *comm
                 return(-1);                  return(-1);
   
         if (!has_mods) {          if (!has_mods) {
                 *result = strdup(aptr? aptr : ptr);                  *result = strdup(aptr ? aptr : ptr);
                 if (aptr)                  if (aptr)
                         free(aptr);                          free(aptr);
                   if (*result == NULL)
                           return -1;
                 return(1);                  return(1);
         }          }
   
Line 1125  history_is_stifled(void)
Line 1145  history_is_stifled(void)
         return (max_input_history != INT_MAX);          return (max_input_history != INT_MAX);
 }  }
   
   static const char _history_tmp_template[] = "/tmp/.historyXXXXXX";
   
   int
   history_truncate_file (const char *filename, int nlines)
   {
           int ret = 0;
           FILE *fp, *tp;
           char template[sizeof(_history_tmp_template)];
           char buf[4096];
           int fd;
           char *cp;
           off_t off;
           int count = 0;
           ssize_t left = 0;
   
           if (filename == NULL && (filename = _default_history_file()) == NULL)
                   return errno;
           if ((fp = fopen(filename, "r+")) == NULL)
                   return errno;
           strcpy(template, _history_tmp_template);
           if ((fd = mkstemp(template)) == -1) {
                   ret = errno;
                   goto out1;
           }
   
           if ((tp = fdopen(fd, "r+")) == NULL) {
                   close(fd);
                   ret = errno;
                   goto out2;
           }
   
           for(;;) {
                   if (fread(buf, sizeof(buf), 1, fp) != 1) {
                           if (ferror(fp)) {
                                   ret = errno;
                                   break;
                           }
                           if (fseeko(fp, (off_t)sizeof(buf) * count, SEEK_SET) ==
                               (off_t)-1) {
                                   ret = errno;
                                   break;
                           }
                           left = fread(buf, 1, sizeof(buf), fp);
                           if (ferror(fp)) {
                                   ret = errno;
                                   break;
                           }
                           if (left == 0) {
                                   count--;
                                   left = sizeof(buf);
                           } else if (fwrite(buf, (size_t)left, 1, tp) != 1) {
                                   ret = errno;
                                   break;
                           }
                           fflush(tp);
                           break;
                   }
                   if (fwrite(buf, sizeof(buf), 1, tp) != 1) {
                           ret = errno;
                           break;
                   }
                   count++;
           }
           if (ret)
                   goto out3;
           cp = buf + left - 1;
           if(*cp != '\n')
                   cp++;
           for(;;) {
                   while (--cp >= buf) {
                           if (*cp == '\n') {
                                   if (--nlines == 0) {
                                           if (++cp >= buf + sizeof(buf)) {
                                                   count++;
                                                   cp = buf;
                                           }
                                           break;
                                   }
                           }
                   }
                   if (nlines <= 0 || count == 0)
                           break;
                   count--;
                   if (fseeko(tp, (off_t)sizeof(buf) * count, SEEK_SET) < 0) {
                           ret = errno;
                           break;
                   }
                   if (fread(buf, sizeof(buf), 1, tp) != 1) {
                           if (ferror(tp)) {
                                   ret = errno;
                                   break;
                           }
                           ret = EAGAIN;
                           break;
                   }
                   cp = buf + sizeof(buf);
           }
   
           if (ret || nlines > 0)
                   goto out3;
   
           if (fseeko(fp, 0, SEEK_SET) == (off_t)-1) {
                   ret = errno;
                   goto out3;
           }
   
           if (fseeko(tp, (off_t)sizeof(buf) * count + (cp - buf), SEEK_SET) ==
               (off_t)-1) {
                   ret = errno;
                   goto out3;
           }
   
           for(;;) {
                   if ((left = fread(buf, 1, sizeof(buf), tp)) == 0) {
                           if (ferror(fp))
                                   ret = errno;
                           break;
                   }
                   if (fwrite(buf, (size_t)left, 1, fp) != 1) {
                           ret = errno;
                           break;
                   }
           }
           fflush(fp);
           if((off = ftello(fp)) > 0)
                   (void)ftruncate(fileno(fp), off);
   out3:
           fclose(tp);
   out2:
           unlink(template);
   out1:
           fclose(fp);
   
           return ret;
   }
   
   
 /*  /*
  * read history from a file given   * read history from a file given
Line 1136  read_history(const char *filename)
Line 1292  read_history(const char *filename)
   
         if (h == NULL || e == NULL)          if (h == NULL || e == NULL)
                 rl_initialize();                  rl_initialize();
         return (history(h, &ev, H_LOAD, filename) == -1);          if (filename == NULL && (filename = _default_history_file()) == NULL)
                   return errno;
           return (history(h, &ev, H_LOAD, filename) == -1 ? (errno ? errno : EINVAL) : 0);
 }  }
   
   
Line 1150  write_history(const char *filename)
Line 1308  write_history(const char *filename)
   
         if (h == NULL || e == NULL)          if (h == NULL || e == NULL)
                 rl_initialize();                  rl_initialize();
         return (history(h, &ev, H_SAVE, filename) == -1);          if (filename == NULL && (filename = _default_history_file()) == NULL)
                   return errno;
           return (history(h, &ev, H_SAVE, filename) == -1 ? (errno ? errno : EINVAL) : 0);
 }  }
   
   
Line 1174  history_get(int num)
Line 1334  history_get(int num)
                 return (NULL);                  return (NULL);
         curr_num = ev.num;          curr_num = ev.num;
   
         /* start from most recent */          /* start from the oldest */
         if (history(h, &ev, H_FIRST) != 0)          if (history(h, &ev, H_LAST) != 0)
                 return (NULL);  /* error */                  return (NULL);  /* error */
   
         /* look backwards for event matching specified offset */          /* look forwards for event matching specified offset */
         if (history(h, &ev, H_NEXT_EVENT, num + 1))          if (history(h, &ev, H_NEXT_EVDATA, num, &she.data))
                 return (NULL);                  return (NULL);
   
         she.line = ev.str;          she.line = ev.str;
         she.data = NULL;  
   
         /* restore pointer to where it was */          /* restore pointer to where it was */
         (void)history(h, &ev, H_SET, curr_num);          (void)history(h, &ev, H_SET, curr_num);
Line 1217  add_history(const char *line)
Line 1376  add_history(const char *line)
 HIST_ENTRY *  HIST_ENTRY *
 remove_history(int num)  remove_history(int num)
 {  {
         HIST_ENTRY *she;          HIST_ENTRY *he;
         HistEvent ev;          HistEvent ev;
   
         if (h == NULL || e == NULL)          if (h == NULL || e == NULL)
                 rl_initialize();                  rl_initialize();
   
         if (history(h, &ev, H_DEL, num) != 0)          if ((he = malloc(sizeof(*he))) == NULL)
                 return NULL;                  return NULL;
   
         if ((she = malloc(sizeof(*she))) == NULL)          if (history(h, &ev, H_DELDATA, num, &he->data) != 0) {
                   free(he);
                 return NULL;                  return NULL;
           }
   
         she->line = ev.str;          he->line = ev.str;
         she->data = NULL;          if (history(h, &ev, H_GETSIZE) == 0)
                   history_length = ev.num;
   
         return she;          return he;
 }  }
   
   
 /*  /*
    * replace the line and data of the num-th entry
    */
   HIST_ENTRY *
   replace_history_entry(int num, const char *line, histdata_t data)
   {
           HIST_ENTRY *he;
           HistEvent ev;
           int curr_num;
   
           if (h == NULL || e == NULL)
                   rl_initialize();
   
           /* save current position */
           if (history(h, &ev, H_CURR) != 0)
                   return NULL;
           curr_num = ev.num;
   
           /* start from the oldest */
           if (history(h, &ev, H_LAST) != 0)
                   return NULL;    /* error */
   
           if ((he = malloc(sizeof(*he))) == NULL)
                   return NULL;
   
           /* look forwards for event matching specified offset */
           if (history(h, &ev, H_NEXT_EVDATA, num, &he->data))
                   goto out;
   
           he->line = strdup(ev.str);
           if (he->line == NULL)
                   goto out;
   
           if (history(h, &ev, H_REPLACE, line, data))
                   goto out;
   
           /* restore pointer to where it was */
           if (history(h, &ev, H_SET, curr_num))
                   goto out;
   
           return he;
   out:
           free(he);
           return NULL;
   }
   
   /*
  * clear the history list - delete all entries   * clear the history list - delete all entries
  */   */
 void  void
Line 1245  clear_history(void)
Line 1453  clear_history(void)
         HistEvent ev;          HistEvent ev;
   
         history(h, &ev, H_CLEAR);          history(h, &ev, H_CLEAR);
           history_length = 0;
 }  }
   
   
Line 1317  history_set_pos(int pos)
Line 1526  history_set_pos(int pos)
         HistEvent ev;          HistEvent ev;
         int 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;
   
         if (history(h, &ev, H_SET, pos)) {          /*
            * use H_DELDATA to set to nth history (without delete) by passing
            * (void **)-1
            */
           if (history(h, &ev, H_DELDATA, pos, (void **)-1)) {
                 history(h, &ev, H_SET, curr_num);                  history(h, &ev, H_SET, curr_num);
                 return(-1);                  return(-1);
         }          }
Line 1470  username_completion_function(const char 
Line 1683  username_completion_function(const char 
   
         if (pwd == NULL) {          if (pwd == NULL) {
                 endpwent();                  endpwent();
                 return (NULL);                  return NULL;
         }          }
         return (strdup(pwd->pw_name));          return strdup(pwd->pw_name);
 }  }
   
   
Line 1556  _el_rl_complete(EditLine *el __attribute
Line 1769  _el_rl_complete(EditLine *el __attribute
  * bind key c to readline-type function func   * bind key c to readline-type function func
  */   */
 int  int
 rl_bind_key(int c, int func(int, int))  rl_bind_key(int c, rl_command_func_t *func)
 {  {
         int retval = -1;          int retval = -1;
   
Line 1623  rl_insert(int count, int c)
Line 1836  rl_insert(int count, int c)
         return (0);          return (0);
 }  }
   
   int
   rl_insert_text(const char *text)
   {
           if (!text || *text == 0)
                   return (0);
   
           if (h == NULL || e == NULL)
                   rl_initialize();
   
           if (el_insertstr(e, text) < 0)
                   return (0);
           return (int)strlen(text);
   }
   
 /*ARGSUSED*/  /*ARGSUSED*/
 int  int
 rl_newline(int count, int c)  rl_newline(int count, int c)
Line 1686  rl_callback_read_char()
Line 1913  rl_callback_read_char()
                 } else                  } else
                         wbuf = NULL;                          wbuf = NULL;
                 (*(void (*)(const char *))rl_linefunc)(wbuf);                  (*(void (*)(const char *))rl_linefunc)(wbuf);
                 el_set(e, EL_UNBUFFERED, 1);                  //el_set(e, EL_UNBUFFERED, 1);
         }          }
 }  }
   
Line 1933  _rl_qsort_string_compare(char **s1, char
Line 2160  _rl_qsort_string_compare(char **s1, char
         return strcoll(*s1, *s2);          return strcoll(*s1, *s2);
 }  }
   
   HISTORY_STATE *
   history_get_history_state(void)
   {
           HISTORY_STATE *hs;
   
           if ((hs = malloc(sizeof(HISTORY_STATE))) == NULL)
                   return (NULL);
           hs->length = history_length;
           return (hs);
   }
   
 int  int
 /*ARGSUSED*/  /*ARGSUSED*/
 rl_kill_text(int from, int to)  rl_kill_text(int from, int to)
Line 1967  rl_generic_bind(int type, const char * k
Line 2205  rl_generic_bind(int type, const char * k
   
 int  int
 /*ARGSUSED*/  /*ARGSUSED*/
 rl_bind_key_in_map(int key, Function *fun, Keymap k)  rl_bind_key_in_map(int key, rl_command_func_t *fun, Keymap k)
 {  {
         return 0;          return 0;
 }  }
   
   /* unsupported, but needed by python */
   void
   rl_cleanup_after_signal(void)
   {
   }

Legend:
Removed from v.1.84  
changed lines
  Added in v.1.85

CVSweb <webmaster@jp.NetBSD.org>