src/lib/libedit/readline.c - diff

Return to readline.c CVS log

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.95 and 1.135

version 1.95, 2011/07/28 20:50:55

version 1.135, 2016/06/02 15:11:18

Line 36 __RCSID("$NetBSD$");

#include <sys/types.h>

#include <sys/stat.h>

#include <stdio.h>

#include <dirent.h>

#include <string.h>

#include <pwd.h>

#include <ctype.h>

#include <stdlib.h>

#include <dirent.h>

#include <unistd.h>

#include <limits.h>

#include <errno.h>

#include <fcntl.h>

#include <limits.h>

#include <pwd.h>

#include <setjmp.h>

#ifdef HAVE_VIS_H

#include <stdint.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <vis.h>

#else

#include "vis.h"

#endif

#include "readline/readline.h"

#include "el.h"

#include "fcns.h" /* for EL_NUM_FCNS */

#include "fcns.h"

#include "histedit.h"

#include "filecomplete.h"

void rl_prep_terminal(int);

Line 81 FILE *rl_outstream = NULL;

Line 78 FILE *rl_outstream = NULL;

int rl_point = 0;

int rl_end = 0;

char *rl_line_buffer = NULL;

VCPFunction *rl_linefunc = NULL;

rl_vcpfunc_t *rl_linefunc = NULL;

int rl_done = 0;

VFunction *rl_event_hook = NULL;

KEYMAP_ENTRY_ARRAY emacs_standard_keymap,

emacs_meta_keymap,

emacs_ctlx_keymap;

* The following is not implemented; we always catch signals in the

* libedit fashion: set handlers on entry to el_gets() and clear them

* on the way out. This simplistic approach works for most cases; if

* it does not work for your application, please let us know.

int rl_catch_signals = 1;

int rl_catch_sigwinch = 1;

int history_base = 1; /* probably never subject to change */

int history_length = 0;

Line 102 int rl_attempted_completion_over = 0;

Line 107 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;

rl_compentry_func_t *rl_completion_entry_function = NULL;

CPPFunction *rl_attempted_completion_function = NULL;

char *(*rl_completion_word_break_hook)(void) = NULL;

rl_completion_func_t *rl_attempted_completion_function = NULL;

Function *rl_pre_input_hook = NULL;

Function *rl_startup1_hook = NULL;

int (*rl_getc_function)(FILE *) = NULL;

Line 111 char *rl_terminal_name = NULL;

Line 117 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;

int readline_echoing_p = 1;

int _rl_print_completions_horizontally = 0;

VFunction *rl_redisplay_function = NULL;

Line 151 char *rl_special_prefixes = NULL;

Line 156 char *rl_special_prefixes = NULL;

int rl_completion_append_character = ' ';

* When the history cursor is on the newest element and next_history()

* is called, GNU readline moves the cursor beyond the newest element.

* The editline library does not provide data structures to express

* that state, so we need a local flag.

static int current_history_valid = 1;

/* stuff below is used internally by libedit for readline emulation */

static History *h = NULL;

static EditLine *e = NULL;

static Function *map[256];

static rl_command_func_t *map[256];

static jmp_buf topbuf;

/* internal functions */

static unsigned char _el_rl_complete(EditLine *, int);

static unsigned char _el_rl_tstp(EditLine *, int);

static char *_get_prompt(EditLine *);

static int _getc_function(EditLine *, char *);

static int _getc_function(EditLine *, wchar_t *);

static HIST_ENTRY *_move_history(int);

static int _history_expand_command(const char *, size_t, size_t,

char **);

static char *_rl_compat_sub(const char *, const char *,

const char *, int);

static int _rl_event_read_char(EditLine *, char *);

static int _rl_event_read_char(EditLine *, wchar_t *);

static void _rl_update_pos(void);

Line 177 static char *

Line 190 static char *

_get_prompt(EditLine *el __attribute__((__unused__)))

{

rl_already_prompted = 1;

return (rl_prompt);

return rl_prompt;

}

Line 191 _move_history(int op)

Line 204 _move_history(int op)

static HIST_ENTRY rl_he;

if (history(h, &ev, op) != 0)

return (HIST_ENTRY *) NULL;

return NULL;

rl_he.line = ev.str;

rl_he.data = NULL;

return (&rl_he);

return &rl_he;

}

Line 205 _move_history(int op)

Line 218 _move_history(int op)

static int

/*ARGSUSED*/

_getc_function(EditLine *el, char *c)

_getc_function(EditLine *el __attribute__((__unused__)), wchar_t *c)

{

int i;

i = (*rl_getc_function)(NULL);

if (i == -1)

return 0;

*c = i;

*c = (wchar_t)i;

return 1;

}

Line 224 _resize_fun(EditLine *el, void *a)

Line 237 _resize_fun(EditLine *el, void *a)

li = el_line(el);

/* a cheesy way to get rid of const cast. */

*ap = memchr(li->buffer, *li->buffer, 1);

*ap = memchr(li->buffer, *li->buffer, (size_t)1);

}

static const char _dothistory[] = "/.history";

static const char *

_default_history_file(void)

{

struct passwd *p;

static char path[PATH_MAX];

static char *path;

size_t len;

if (*path)

if (path)

return path;

if ((p = getpwuid(getuid())) == NULL)

return NULL;

strlcpy(path, p->pw_dir, PATH_MAX);

strlcat(path, _dothistory, PATH_MAX);

len = strlen(p->pw_dir) + sizeof("/.history");

if ((path = malloc(len)) == NULL)

return NULL;

(void)snprintf(path, len, "%s/.history", p->pw_dir);

return path;

}

Line 258 rl_set_prompt(const char *prompt)

Line 275 rl_set_prompt(const char *prompt)

if (!prompt)

prompt = "";

if (rl_prompt != NULL && strcmp(rl_prompt, prompt) == 0)

return 0;

if (rl_prompt)

el_free(rl_prompt);

Line 282 rl_initialize(void)

Line 299 rl_initialize(void)

int editmode = 1;

struct termios t;

current_history_valid = 1;

if (e != NULL)

el_end(e);

if (h != NULL)

Line 305 rl_initialize(void)

Line 324 rl_initialize(void)

h = history_init();

if (!e || !h)

return (-1);

return -1;

history(h, &ev, H_SETSIZE, INT_MAX); /* unlimited */

history_length = 0;

Line 329 rl_initialize(void)

Line 348 rl_initialize(void)

el_set(e, EL_SIGNAL, rl_catch_signals);

/* set default mode to "emacs"-style and read setting afterwards */

/* so this can be overriden */

/* so this can be overridden */

el_set(e, EL_EDITOR, "emacs");

if (rl_terminal_name != NULL)

el_set(e, EL_TERMINAL, rl_terminal_name);

Line 352 rl_initialize(void)

Line 371 rl_initialize(void)

"ReadLine compatible suspend function",

_el_rl_tstp);

el_set(e, EL_BIND, "^Z", "rl_tstp", NULL);

* Set some readline compatible key-bindings.

el_set(e, EL_BIND, "^R", "em-inc-search-prev", NULL);

* Allow the use of Home/End keys.

el_set(e, EL_BIND, "\\e[1~", "ed-move-to-beg", NULL);

el_set(e, EL_BIND, "\\e[4~", "ed-move-to-end", NULL);

el_set(e, EL_BIND, "\\e[7~", "ed-move-to-beg", NULL);

el_set(e, EL_BIND, "\\e[8~", "ed-move-to-end", NULL);

el_set(e, EL_BIND, "\\e[H", "ed-move-to-beg", NULL);

el_set(e, EL_BIND, "\\e[F", "ed-move-to-end", NULL);

* Allow the use of the Delete/Insert keys.

el_set(e, EL_BIND, "\\e[3~", "ed-delete-next-char", NULL);

el_set(e, EL_BIND, "\\e[2~", "ed-quoted-insert", NULL);

* Ctrl-left-arrow and Ctrl-right-arrow for word moving.

el_set(e, EL_BIND, "\\e[1;5C", "em-next-word", NULL);

el_set(e, EL_BIND, "\\e[1;5D", "ed-prev-word", NULL);

el_set(e, EL_BIND, "\\e[5C", "em-next-word", NULL);

el_set(e, EL_BIND, "\\e[5D", "ed-prev-word", NULL);

el_set(e, EL_BIND, "\\e\\e[C", "em-next-word", NULL);

el_set(e, EL_BIND, "\\e\\e[D", "ed-prev-word", NULL);

/* read settings from configuration file */

el_source(e, NULL);

Line 366 rl_initialize(void)

Line 416 rl_initialize(void)

if (rl_startup_hook)

(*rl_startup_hook)(NULL, 0);

return (0);

return 0;

}

Line 486 _rl_compat_sub(const char *str, const ch

Line 536 _rl_compat_sub(const char *str, const ch

s += what_len;

if (!globally) {

(void)strcpy(r, s);

return(result);

return result;

}

} else

*r++ = *s++;

}

*r = '\0';

return(result);

return result;

}

static char *last_search_pat; /* last !?pat[?] search pattern */

Line 509 get_history_event(const char *cmd, int *

Line 559 get_history_event(const char *cmd, int *

idx = *cindex;

if (cmd[idx++] != history_expansion_char)

return(NULL);

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);

return NULL;

*cindex = cmd[idx]? (idx + 1):idx;

return ev.str;

}

Line 536 get_history_event(const char *cmd, int *

Line 586 get_history_event(const char *cmd, int *

num = history_length - num + 1;

if (!(rl_he = history_get(num)))

return(NULL);

return NULL;

*cindex = idx;

return(rl_he->line);

return rl_he->line;

}

sub = 0;

if (cmd[idx] == '?') {

Line 557 get_history_event(const char *cmd, int *

Line 607 get_history_event(const char *cmd, int *

break;

idx++;

}

len = idx - begin;

len = (size_t)idx - (size_t)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);

return NULL;

else {

if ((pat = el_malloc((len + 1) * sizeof(*pat))) == NULL)

return NULL;

Line 574 get_history_event(const char *cmd, int *

Line 624 get_history_event(const char *cmd, int *

if (history(h, &ev, H_CURR) != 0) {

if (pat != last_search_pat)

el_free(pat);

return (NULL);

return NULL;

}

num = ev.num;

Line 594 get_history_event(const char *cmd, int *

Line 644 get_history_event(const char *cmd, int *

(void)fprintf(rl_outstream, "%s: Event not found\n", pat);

if (pat != last_search_pat)

el_free(pat);

return(NULL);

return NULL;

}

if (sub && len) {

Line 607 get_history_event(const char *cmd, int *

Line 657 get_history_event(const char *cmd, int *

el_free(pat);

if (history(h, &ev, H_CURR) != 0)

return(NULL);

return NULL;

*cindex = idx;

rptr = ev.str;

Line 625 get_history_event(const char *cmd, int *

Line 675 get_history_event(const char *cmd, int *

* 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,

* returns -1 and *result points to NULL

* it's callers responsibility to free() string returned in *result

* it's the caller's responsibility to free() the string returned in *result

static int

_history_expand_command(const char *command, size_t offs, size_t cmdlen,

Line 671 _history_expand_command(const char *comm

Line 721 _history_expand_command(const char *comm

qchar = (offs > 0 && command[offs - 1] == '"')? '"':0;

ptr = get_history_event(command + offs, &idx, qchar);

}

has_mods = command[offs + idx] == ':';

has_mods = command[offs + (size_t)idx] == ':';

}

if (ptr == NULL && aptr == NULL)

return(-1);

return -1;

if (!has_mods) {

*result = strdup(aptr ? aptr : ptr);

Line 683 _history_expand_command(const char *comm

Line 733 _history_expand_command(const char *comm

el_free(aptr);

if (*result == NULL)

return -1;

return(1);

return 1;

}

cmd = command + offs + idx + 1;

Line 729 _history_expand_command(const char *comm

Line 779 _history_expand_command(const char *comm

command + offs + idx);

if (aptr)

el_free(aptr);

return(-1);

return -1;

}

} else

tmp = strdup(aptr? aptr:ptr);

Line 739 _history_expand_command(const char *comm

Line 789 _history_expand_command(const char *comm

if (*cmd == '\0' || ((size_t)(cmd - (command + offs)) >= cmdlen)) {

*result = tmp;

return(1);

return 1;

}

for (; *cmd; cmd++) {

Line 814 _history_expand_command(const char *comm

Line 864 _history_expand_command(const char *comm

} else {

from = NULL;

el_free(tmp);

return (-1);

return -1;

}

cmd++; /* shift after delim */

Line 868 _history_expand_command(const char *comm

Line 918 _history_expand_command(const char *comm

}

*result = tmp;

return (p_on? 2:1);

return p_on? 2:1;

}

Line 887 history_expand(char *str, char **output)

Line 937 history_expand(char *str, char **output)

if (history_expansion_char == 0) {

*output = strdup(str);

return(0);

return 0;

}

*output = NULL;

if (str[0] == history_subst_char) {

/* ^foo^foo2^ is equivalent to !!:s^foo^foo2^ */

*output = el_malloc((strlen(str) + 4 + 1) * sizeof(*output));

*output = el_malloc((strlen(str) + 4 + 1) * sizeof(**output));

if (*output == NULL)

return 0;

(*output)[0] = (*output)[1] = history_expansion_char;

Line 939 loop:

Line 989 loop:

for (; str[j]; j++) {

if (str[j] == '\\' &&

str[j + 1] == history_expansion_char) {

(void)strcpy(&str[j], &str[j + 1]);

len = strlen(&str[j + 1]) + 1;

memmove(&str[j], &str[j + 1], len);

continue;

}

if (!loop_again) {

Line 1002 loop:

Line 1053 loop:

el_free(*output);

*output = result;

return (ret);

return ret;

}

Line 1037 history_arg_extract(int start, int end,

Line 1088 history_arg_extract(int start, int end,

(size_t)end > max || start > end)

goto out;

for (i = start, len = 0; i <= (size_t)end; i++)

for (i = (size_t)start, len = 0; i <= (size_t)end; i++)

len += strlen(arr[i]) + 1;

len++;

result = el_malloc(len * sizeof(*result));

if (result == NULL)

goto out;

for (i = start, len = 0; i <= (size_t)end; i++) {

for (i = (size_t)start, len = 0; i <= (size_t)end; i++) {

(void)strcpy(result + len, arr[i]);

len += strlen(arr[i]);

if (i < (size_t)end)

Line 1094 history_tokenize(const char *str)

Line 1145 history_tokenize(const char *str)

if (idx + 2 >= size) {

char **nresult;

size <<= 1;

nresult = el_realloc(result, size * sizeof(*nresult));

nresult = el_realloc(result, (size_t)size * sizeof(*nresult));

if (nresult == NULL) {

el_free(result);

return NULL;

}

result = nresult;

}

len = i - start;

len = (size_t)i - (size_t)start;

temp = el_malloc((len + 1) * sizeof(*temp));

temp = el_malloc((size_t)(len + 1) * sizeof(*temp));

if (temp == NULL) {

for (i = 0; i < idx; i++)

el_free(result[i]);

Line 1116 history_tokenize(const char *str)

Line 1167 history_tokenize(const char *str)

if (str[i])

i++;

}

return (result);

return result;

}

Line 1127 void

Line 1178 void

stifle_history(int max)

{

HistEvent ev;

HIST_ENTRY *he;

if (h == NULL || e == NULL)

rl_initialize();

if (history(h, &ev, H_SETSIZE, max) == 0)

if (history(h, &ev, H_SETSIZE, max) == 0) {

max_input_history = max;

while (history_length > max) {

he = remove_history(0);

el_free(he->data);

el_free((void *)(unsigned long)he->line);

el_free(he);

}

Line 1148 unstifle_history(void)

Line 1207 unstifle_history(void)

history(h, &ev, H_SETSIZE, INT_MAX);

omax = max_input_history;

max_input_history = INT_MAX;

return (omax); /* some value _must_ be returned */

return omax; /* some value _must_ be returned */

}

Line 1157 history_is_stifled(void)

Line 1216 history_is_stifled(void)

{

/* cannot return true answer */

return (max_input_history != INT_MAX);

return max_input_history != INT_MAX;

}

static const char _history_tmp_template[] = "/tmp/.historyXXXXXX";

Line 1192 history_truncate_file (const char *filen

Line 1251 history_truncate_file (const char *filen

}

for(;;) {

if (fread(buf, sizeof(buf), 1, fp) != 1) {

if (fread(buf, sizeof(buf), (size_t)1, fp) != 1) {

if (ferror(fp)) {

ret = errno;

break;

Line 1202 history_truncate_file (const char *filen

Line 1261 history_truncate_file (const char *filen

ret = errno;

break;

}

left = fread(buf, 1, sizeof(buf), fp);

left = (ssize_t)fread(buf, (size_t)1, sizeof(buf), fp);

if (ferror(fp)) {

ret = errno;

break;

Line 1210 history_truncate_file (const char *filen

Line 1269 history_truncate_file (const char *filen

if (left == 0) {

count--;

left = sizeof(buf);

} else if (fwrite(buf, (size_t)left, 1, tp) != 1) {

} else if (fwrite(buf, (size_t)left, (size_t)1, tp)

!= 1) {

ret = errno;

break;

}

fflush(tp);

break;

}

if (fwrite(buf, sizeof(buf), 1, tp) != 1) {

if (fwrite(buf, sizeof(buf), (size_t)1, tp) != 1) {

ret = errno;

break;

}

Line 1247 history_truncate_file (const char *filen

Line 1307 history_truncate_file (const char *filen

ret = errno;

break;

}

if (fread(buf, sizeof(buf), 1, tp) != 1) {

if (fread(buf, sizeof(buf), (size_t)1, tp) != 1) {

if (ferror(tp)) {

ret = errno;

break;

Line 1261 history_truncate_file (const char *filen

Line 1321 history_truncate_file (const char *filen

if (ret || nlines > 0)

goto out3;

if (fseeko(fp, 0, SEEK_SET) == (off_t)-1) {

if (fseeko(fp, (off_t)0, SEEK_SET) == (off_t)-1) {

ret = errno;

goto out3;

}

Line 1273 history_truncate_file (const char *filen

Line 1333 history_truncate_file (const char *filen

}

for(;;) {

if ((left = fread(buf, 1, sizeof(buf), tp)) == 0) {

if ((left = (ssize_t)fread(buf, (size_t)1, sizeof(buf), tp)) == 0) {

if (ferror(fp))

ret = errno;

break;

}

if (fwrite(buf, (size_t)left, 1, fp) != 1) {

if (fwrite(buf, (size_t)left, (size_t)1, fp) != 1) {

ret = errno;

break;

}

Line 1309 read_history(const char *filename)

Line 1369 read_history(const char *filename)

rl_initialize();

if (filename == NULL && (filename = _default_history_file()) == NULL)

return errno;

return (history(h, &ev, H_LOAD, filename) == -1 ?

return history(h, &ev, H_LOAD, filename) == -1 ?

(errno ? errno : EINVAL) : 0);

(errno ? errno : EINVAL) : 0;

}

Line 1326 write_history(const char *filename)

Line 1386 write_history(const char *filename)

rl_initialize();

if (filename == NULL && (filename = _default_history_file()) == NULL)

return errno;

return (history(h, &ev, H_SAVE, filename) == -1 ?

return history(h, &ev, H_SAVE, filename) == -1 ?

(errno ? errno : EINVAL) : 0);

(errno ? errno : EINVAL) : 0;

}

Line 1346 history_get(int num)

Line 1406 history_get(int num)

if (h == NULL || e == NULL)

rl_initialize();

if (num < history_base)

return NULL;

/* save current position */

if (history(h, &ev, H_CURR) != 0)

return (NULL);

return NULL;

curr_num = ev.num;

/* start from the oldest */

if (history(h, &ev, H_LAST) != 0)

* use H_DELDATA to set to nth history (without delete) by passing

return (NULL); /* error */

* (void **)-1 -- as in history_set_pos

/* look forwards for event matching specified offset */

if (history(h, &ev, H_DELDATA, num - history_base, (void **)-1) != 0)

if (history(h, &ev, H_NEXT_EVDATA, num, &she.data))

goto out;

return (NULL);

/* get current entry */

if (history(h, &ev, H_CURR) != 0)

goto out;

if (history(h, &ev, H_NEXT_EVDATA, ev.num, &she.data) != 0)

goto out;

she.line = ev.str;

/* restore pointer to where it was */

(void)history(h, &ev, H_SET, curr_num);

return (&she);

return &she;

out:

/* restore pointer to where it was */

(void)history(h, &ev, H_SET, curr_num);

return NULL;

}

Line 1379 add_history(const char *line)

Line 1451 add_history(const char *line)

if (h == NULL || e == NULL)

rl_initialize();

(void)history(h, &ev, H_ENTER, line);

if (history(h, &ev, H_ENTER, line) == -1)

if (history(h, &ev, H_GETSIZE) == 0)

return 0;

history_length = ev.num;

return (!(history_length > 0)); /* return 0 if all is okay */

(void)history(h, &ev, H_GETSIZE);

if (ev.num == history_length)

history_base++;

else

history_length = ev.num;

current_history_valid = 1;

return 0;

}

Line 1469 clear_history(void)

Line 1546 clear_history(void)

{

HistEvent ev;

if (h == NULL || e == NULL)

rl_initialize();

(void)history(h, &ev, H_CLEAR);

history_length = 0;

current_history_valid = 1;

}

Line 1484 where_history(void)

Line 1565 where_history(void)

int curr_num, off;

if (history(h, &ev, H_CURR) != 0)

return (0);

return 0;

curr_num = ev.num;

(void)history(h, &ev, H_FIRST);

/* start from the oldest */

off = 1;

(void)history(h, &ev, H_LAST);

while (ev.num != curr_num && history(h, &ev, H_NEXT) == 0)

/* position is zero-based */

off = 0;

while (ev.num != curr_num && history(h, &ev, H_PREV) == 0)

off++;

return (off);

return off;

}

Line 1503 HIST_ENTRY *

Line 1587 HIST_ENTRY *

current_history(void)

{

return (_move_history(H_CURR));

return current_history_valid ? _move_history(H_CURR) : NULL;

}

Line 1518 history_total_bytes(void)

Line 1602 history_total_bytes(void)

size_t size;

if (history(h, &ev, H_CURR) != 0)

return (-1);

return -1;

curr_num = ev.num;

(void)history(h, &ev, H_FIRST);

Line 1530 history_total_bytes(void)

Line 1614 history_total_bytes(void)

/* get to the same position as before */

history(h, &ev, H_PREV_EVENT, curr_num);

return (int)(size);

return (int)size;

}

Line 1544 history_set_pos(int pos)

Line 1628 history_set_pos(int pos)

int curr_num;

if (pos >= history_length || pos < 0)

return (-1);

return 0;

(void)history(h, &ev, H_CURR);

curr_num = ev.num;

current_history_valid = 1;

* use H_DELDATA to set to nth history (without delete) by passing

Line 1555 history_set_pos(int pos)

Line 1640 history_set_pos(int pos)

if (history(h, &ev, H_DELDATA, pos, (void **)-1)) {

(void)history(h, &ev, H_SET, curr_num);

return(-1);

return 0;

}

return (0);

return 1;

}

* returns previous event in history and shifts pointer accordingly

* Note that readline and editline define directions in opposite ways.

HIST_ENTRY *

previous_history(void)

{

return (_move_history(H_PREV));

if (current_history_valid == 0) {

current_history_valid = 1;

return _move_history(H_CURR);

}

return _move_history(H_NEXT);

}

Line 1578 previous_history(void)

Line 1668 previous_history(void)

HIST_ENTRY *

next_history(void)

{

HIST_ENTRY *he;

return (_move_history(H_NEXT));

he = _move_history(H_PREV);

if (he == NULL)

current_history_valid = 0;

return he;

}

Line 1594 history_search(const char *str, int dire

Line 1688 history_search(const char *str, int dire

int curr_num;

if (history(h, &ev, H_CURR) != 0)

return (-1);

return -1;

curr_num = ev.num;

for (;;) {

if ((strp = strstr(ev.str, str)) != NULL)

return (int) (strp - ev.str);

return (int)(strp - ev.str);

if (history(h, &ev, direction < 0 ? H_NEXT:H_PREV) != 0)

break;

}

(void)history(h, &ev, H_SET, curr_num);

return (-1);

return -1;

}

Line 1637 history_search_pos(const char *str,

Line 1731 history_search_pos(const char *str,

pos = (pos > 0) ? 1 : -1;

if (history(h, &ev, H_CURR) != 0)

return (-1);

return -1;

curr_num = ev.num;

if (history_set_pos(off) != 0 || history(h, &ev, H_CURR) != 0)

if (!history_set_pos(off) || history(h, &ev, H_CURR) != 0)

return (-1);

return -1;

for (;;) {

if (strstr(ev.str, str))

return (off);

return off;

if (history(h, &ev, (pos < 0) ? H_PREV : H_NEXT) != 0)

break;

}

Line 1654 history_search_pos(const char *str,

Line 1748 history_search_pos(const char *str,

(void)history(h, &ev,

pos < 0 ? H_NEXT_EVENT : H_PREV_EVENT, curr_num);

return (-1);

return -1;

}

Line 1678 filename_completion_function(const char

Line 1772 filename_completion_function(const char

* which starts with supplied text

* text contains a partial username preceded by random character

* (usually '~'); state resets search from start (??? should we do that anyway)

* it's callers responsibility to free returned value

* it's the caller's responsibility to free the returned value

char *

username_completion_function(const char *text, int state)

Line 1690 username_completion_function(const char

Line 1784 username_completion_function(const char

struct passwd *pass = NULL;

if (text[0] == '\0')

return (NULL);

return NULL;

if (*text == '~')

text++;

Line 1745 _rl_completion_append_character_function

Line 1839 _rl_completion_append_character_function

__attribute__((__unused__)))

{

static char buf[2];

buf[0] = rl_completion_append_character;

buf[0] = (char)rl_completion_append_character;

buf[1] = '\0';

return buf;

}

Line 1758 _rl_completion_append_character_function

Line 1852 _rl_completion_append_character_function

int

rl_complete(int ignore __attribute__((__unused__)), int invoking_key)

{

#ifdef WIDECHAR

static ct_buffer_t wbreak_conv, sprefix_conv;

#endif

char *breakchars;

if (h == NULL || e == NULL)

rl_initialize();

Line 1770 rl_complete(int ignore __attribute__((__

Line 1863 rl_complete(int ignore __attribute__((__

arr[0] = (char)invoking_key;

arr[1] = '\0';

el_insertstr(e, arr);

return (CC_REFRESH);

return CC_REFRESH;

}

if (rl_completion_word_break_hook != NULL)

breakchars = (*rl_completion_word_break_hook)();

else

breakchars = rl_basic_word_break_characters;

_rl_update_pos();

/* Just look at how many global variables modify this operation! */

return fn_complete(e,

(CPFunction *)rl_completion_entry_function,

(rl_compentry_func_t *)rl_completion_entry_function,

rl_attempted_completion_function,

ct_decode_string(rl_basic_word_break_characters, &wbreak_conv),

ct_decode_string(rl_special_prefixes, &sprefix_conv),

ct_decode_string(breakchars, &sprefix_conv),

_rl_completion_append_character_function,

(size_t)rl_completion_query_items,

&rl_completion_type, &rl_attempted_completion_over,

Line 1815 rl_bind_key(int c, rl_command_func_t *fu

Line 1915 rl_bind_key(int c, rl_command_func_t *fu

e->el_map.key[c] = ED_INSERT;

retval = 0;

}

return (retval);

return retval;

}

Line 1831 rl_read_key(void)

Line 1931 rl_read_key(void)

if (e == NULL || h == NULL)

rl_initialize();

return (el_getc(e, fooarr));

return el_getc(e, fooarr);

}

Line 1861 rl_insert(int count, int c)

Line 1961 rl_insert(int count, int c)

rl_initialize();

/* XXX - int -> char conversion can lose on multichars */

arr[0] = c;

arr[0] = (char)c;

arr[1] = '\0';

for (; count > 0; count--)

el_push(e, arr);

return (0);

return 0;

}

int

rl_insert_text(const char *text)

{

if (!text || *text == 0)

return (0);

return 0;

if (h == NULL || e == NULL)

rl_initialize();

if (el_insertstr(e, text) < 0)

return (0);

return 0;

return (int)strlen(text);

}

/*ARGSUSED*/

int

rl_newline(int count, int c)

rl_newline(int count __attribute__((__unused__)),

int c __attribute__((__unused__)))

{

* Readline-4.0 appears to ignore the args.

Line 1896 rl_newline(int count, int c)

Line 1997 rl_newline(int count, int c)

/*ARGSUSED*/

static unsigned char

rl_bind_wrapper(EditLine *el, unsigned char c)

rl_bind_wrapper(EditLine *el __attribute__((__unused__)), unsigned char c)

{

if (map[c] == NULL)

return CC_ERROR;

_rl_update_pos();

(*map[c])(NULL, c);

(*map[c])(1, c);

/* If rl_done was set by the above call, deal with it here */

if (rl_done)

Line 1913 rl_bind_wrapper(EditLine *el, unsigned c

Line 2014 rl_bind_wrapper(EditLine *el, unsigned c

}

int

rl_add_defun(const char *name, Function *fun, int c)

rl_add_defun(const char *name, rl_command_func_t *fun, int c)

{

char dest[8];

if ((size_t)c >= sizeof(map) / sizeof(map[0]) || c < 0)

Line 1921 rl_add_defun(const char *name, Function

Line 2022 rl_add_defun(const char *name, Function

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);

el_set(e, EL_BIND, dest, name, NULL);

return 0;

}

void

rl_callback_read_char()

rl_callback_read_char(void)

{

int count = 0, done = 0;

const char *buf = el_gets(e, &count);

Line 1947 rl_callback_read_char()

Line 2048 rl_callback_read_char()

} else

wbuf = NULL;

(*(void (*)(const char *))rl_linefunc)(wbuf);

//el_set(e, EL_UNBUFFERED, 1);

el_set(e, EL_UNBUFFERED, 1);

}

void

rl_callback_handler_install(const char *prompt, VCPFunction *linefunc)

rl_callback_handler_install(const char *prompt, rl_vcpfunc_t *linefunc)

{

if (e == NULL) {

rl_initialize();

Line 1960 rl_callback_handler_install(const char *

Line 2061 rl_callback_handler_install(const char *

(void)rl_set_prompt(prompt);

rl_linefunc = linefunc;

el_set(e, EL_UNBUFFERED, 1);

}

void

rl_callback_handler_remove(void)

{

el_set(e, EL_UNBUFFERED, 0);

Line 1973 void

Line 2074 void

rl_redisplay(void)

{

char a[2];

a[0] = e->el_tty.t_c[TS_IO][C_REPRINT];

a[0] = (char)e->el_tty.t_c[TS_IO][C_REPRINT];

a[1] = '\0';

el_push(e, a);

}

Line 1982 int

Line 2083 int

rl_get_previous_history(int count, int key)

{

char a[2];

a[0] = key;

a[0] = (char)key;

a[1] = '\0';

while (count--)

el_push(e, a);

Line 1991 rl_get_previous_history(int count, int k

Line 2092 rl_get_previous_history(int count, int k

void

/*ARGSUSED*/

rl_prep_terminal(int meta_flag)

rl_prep_terminal(int meta_flag __attribute__((__unused__)))

{

el_set(e, EL_PREP_TERM, 1);

}

Line 2005 rl_deprep_terminal(void)

Line 2106 rl_deprep_terminal(void)

int

rl_read_init_file(const char *s)

{

return(el_source(e, s));

return el_source(e, s);

}

int

Line 2019 rl_parse_and_bind(const char *line)

Line 2120 rl_parse_and_bind(const char *line)

tok_str(tok, line, &argc, &argv);

argc = el_parse(e, argc, argv);

tok_end(tok);

return (argc ? 1 : 0);

return argc ? 1 : 0;

}

int

Line 2029 rl_variable_bind(const char *var, const

Line 2130 rl_variable_bind(const char *var, const

* 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);

return el_set(e, EL_BIND, "", var, value, NULL) == -1 ? 1 : 0;

}

void

Line 2037 rl_stuff_char(int c)

Line 2138 rl_stuff_char(int c)

{

char buf[2];

buf[0] = c;

buf[0] = (char)c;

buf[1] = '\0';

el_insertstr(e, buf);

}

static int

_rl_event_read_char(EditLine *el, char *cp)

_rl_event_read_char(EditLine *el, wchar_t *wc)

{

char ch;

int n;

ssize_t num_read = 0;

*cp = '\0';

ch = '\0';

*wc = L'\0';

while (rl_event_hook) {

(*rl_event_hook)();

#if defined(FIONREAD)

if (ioctl(el->el_infd, FIONREAD, &n) < 0)

return(-1);

return -1;

if (n)

num_read = read(el->el_infd, cp, 1);

num_read = read(el->el_infd, &ch, (size_t)1);

else

num_read = 0;

#elif defined(F_SETFL) && defined(O_NDELAY)

if ((n = fcntl(el->el_infd, F_GETFL, 0)) < 0)

return(-1);

return -1;

if (fcntl(el->el_infd, F_SETFL, n|O_NDELAY) < 0)

return(-1);

return -1;

num_read = read(el->el_infd, cp, 1);

num_read = read(el->el_infd, &ch, 1);

if (fcntl(el->el_infd, F_SETFL, n))

return(-1);

return -1;

#else

/* not non-blocking, but what you gonna do? */

num_read = read(el->el_infd, cp, 1);

num_read = read(el->el_infd, &ch, 1);

return(-1);

return -1;

#endif

if (num_read < 0 && errno == EAGAIN)

Line 2082 _rl_event_read_char(EditLine *el, char *

Line 2185 _rl_event_read_char(EditLine *el, char *

}

if (!rl_event_hook)

el_set(el, EL_GETCFN, EL_BUILTIN_GETCFN);

*wc = (wchar_t)ch;

return (int)num_read;

}

Line 2098 void

Line 2202 void

rl_get_screen_size(int *rows, int *cols)

{

if (rows)

el_get(e, EL_GETTC, "li", rows);

el_get(e, EL_GETTC, "li", rows, (void *)0);

if (cols)

el_get(e, EL_GETTC, "co", cols);

el_get(e, EL_GETTC, "co", cols, (void *)0);

}

void

Line 2108 rl_set_screen_size(int rows, int cols)

Line 2212 rl_set_screen_size(int rows, int cols)

{

char buf[64];

(void)snprintf(buf, sizeof(buf), "%d", rows);

el_set(e, EL_SETTC, "li", buf);

el_set(e, EL_SETTC, "li", buf, NULL);

(void)snprintf(buf, sizeof(buf), "%d", cols);

el_set(e, EL_SETTC, "co", buf);

el_set(e, EL_SETTC, "co", buf, NULL);

}

char **

Line 2144 rl_completion_matches(const char *str, r

Line 2248 rl_completion_matches(const char *str, r

}

qsort(&list[1], len - 1, sizeof(*list),

(int (*)(const void *, const void *)) strcmp);

min = SIZE_T_MAX;

min = SIZE_MAX;

for (i = 1, a = list[i]; i < len - 1; i++, a = b) {

b = list[i + 1];

for (j = 0; a[j] && a[j] == b[j]; j++)

Line 2162 rl_completion_matches(const char *str, r

Line 2266 rl_completion_matches(const char *str, r

list[0][min] = '\0';

}

return list;

out:

el_free(list);

return NULL;

Line 2200 history_get_history_state(void)

Line 2304 history_get_history_state(void)

HISTORY_STATE *hs;

if ((hs = el_malloc(sizeof(*hs))) == NULL)

return (NULL);

return NULL;

hs->length = history_length;

return (hs);

return hs;

}

int

/*ARGSUSED*/

rl_kill_text(int from, int to)

rl_kill_text(int from __attribute__((__unused__)),

int to __attribute__((__unused__)))

{

return 0;

}

Line 2226 rl_get_keymap(void)

Line 2331 rl_get_keymap(void)

void

/*ARGSUSED*/

rl_set_keymap(Keymap k)

rl_set_keymap(Keymap k __attribute__((__unused__)))

{

}

int

/*ARGSUSED*/

rl_generic_bind(int type, const char * keyseq, const char * data, Keymap k)

rl_generic_bind(int type __attribute__((__unused__)),

const char * keyseq __attribute__((__unused__)),

const char * data __attribute__((__unused__)),

Keymap k __attribute__((__unused__)))

{

return 0;

}

int

/*ARGSUSED*/

rl_bind_key_in_map(int key, rl_command_func_t *fun, Keymap k)

rl_bind_key_in_map(int key __attribute__((__unused__)),

rl_command_func_t *fun __attribute__((__unused__)),

Keymap k __attribute__((__unused__)))

{

return 0;

}

Line 2255 rl_on_new_line(void)

Line 2365 rl_on_new_line(void)

{

return 0;

}

void

rl_free_line_state(void)

{

}

int

/*ARGSUSED*/

rl_set_keyboard_input_timeout(int u __attribute__((__unused__)))

{

return 0;

}

CVSweb <webmaster@jp.NetBSD.org>