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.91 and 1.99

version 1.91, 2010/08/28 15:44:59

version 1.99, 2011/08/16 16:25:15

Line 47 __RCSID("$NetBSD$");

#include <errno.h>

#include <fcntl.h>

#include <setjmp.h>

#ifdef HAVE_VIS_H

#include <vis.h>

#else

#include "np/vis.h"

#endif

#include "readline/readline.h"

#include "el.h"

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

Line 121 VFunction *rl_prep_term_function = (VFun

Line 118 VFunction *rl_prep_term_function = (VFun

VFunction *rl_deprep_term_function = (VFunction *)rl_deprep_terminal;

KEYMAP_ENTRY_ARRAY emacs_meta_keymap;

#ifdef WIDECHAR

static ct_buffer_t conv;

#endif

* The current prompt string.

Line 157 int rl_completion_append_character = ' '

Line 150 int rl_completion_append_character = ' '

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

static TYPE(History) *h = NULL;

static History *h = NULL;

static EditLine *e = NULL;

static Function *map[256];

static jmp_buf topbuf;

Line 181 static char *

Line 174 static char *

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

{

rl_already_prompted = 1;

return (rl_prompt);

return rl_prompt;

}

Line 191 _get_prompt(EditLine *el __attribute__((

Line 184 _get_prompt(EditLine *el __attribute__((

static HIST_ENTRY *

_move_history(int op)

{

TYPE(HistEvent) ev;

HistEvent ev;

static HIST_ENTRY rl_he;

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

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

return (HIST_ENTRY *) NULL;

return NULL;

rl_he.line = ct_encode_string(ev.str, &conv);

rl_he.line = ev.str;

rl_he.data = NULL;

return (&rl_he);

return &rl_he;

}

Line 209 _move_history(int op)

Line 202 _move_history(int op)

static int

/*ARGSUSED*/

_getc_function(EditLine *el, char *c)

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

{

int i;

i = (*rl_getc_function)(NULL);

if (i == -1)

return 0;

*c = i;

*c = (char)i;

return 1;

}

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

Line 221 _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)

{

Line 243 _default_history_file(void)

Line 234 _default_history_file(void)

return path;

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

return NULL;

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

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

strlcat(path, _dothistory, PATH_MAX);

return path;

}

Line 265 rl_set_prompt(const char *prompt)

Line 255 rl_set_prompt(const char *prompt)

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

return 0;

if (rl_prompt)

free(rl_prompt);

el_free(rl_prompt);

rl_prompt = strdup(prompt);

if (rl_prompt == NULL)

return -1;

Line 282 rl_set_prompt(const char *prompt)

Line 272 rl_set_prompt(const char *prompt)

int

rl_initialize(void)

{

TYPE(HistEvent) ev;

HistEvent ev;

int editmode = 1;

struct termios t;

if (e != NULL)

el_end(e);

if (h != NULL)

FUN(history,end)(h);

history_end(h);

if (!rl_instream)

rl_instream = stdin;

Line 305 rl_initialize(void)

Line 295 rl_initialize(void)

e = el_init(rl_readline_name, rl_instream, rl_outstream, stderr);

if (!editmode)

FUN(el,set)(e, EL_EDITMODE, 0);

el_set(e, EL_EDITMODE, 0);

h = FUN(history,init)();

h = history_init();

if (!e || !h)

return (-1);

return -1;

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

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

history_length = 0;

max_input_history = INT_MAX;

el_set(e, EL_HIST, history, h);

Line 325 rl_initialize(void)

Line 315 rl_initialize(void)

/* for proper prompt printing in readline() */

if (rl_set_prompt("") == -1) {

FUN(history,end)(h);

history_end(h);

el_end(e);

return -1;

}

Line 370 rl_initialize(void)

Line 360 rl_initialize(void)

if (rl_startup_hook)

(*rl_startup_hook)(NULL, 0);

return (0);

return 0;

}

Line 381 rl_initialize(void)

Line 371 rl_initialize(void)

char *

readline(const char *p)

{

TYPE(HistEvent) ev;

HistEvent ev;

const char * volatile prompt = p;

int count;

const char *ret;

Line 429 readline(const char *p)

Line 419 readline(const char *p)

} else

buf = NULL;

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

history(h, &ev, H_GETSIZE);

history_length = ev.num;

return buf;

Line 479 _rl_compat_sub(const char *str, const ch

Line 469 _rl_compat_sub(const char *str, const ch

} else

s++;

}

r = result = malloc(len + 1);

r = result = el_malloc((len + 1) * sizeof(*r));

if (result == NULL)

return NULL;

s = str;

Line 490 _rl_compat_sub(const char *str, const ch

Line 480 _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 499 get_history_event(const char *cmd, int *

size_t len;

char *pat;

const char *rptr;

TYPE(HistEvent) ev;

HistEvent ev;

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 (FUNW(history)(h, &ev, H_FIRST) != 0)

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

return(NULL);

return NULL;

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

return ct_encode_string(ev.str, &conv);

return ev.str;

}

sign = 0;

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

Line 540 get_history_event(const char *cmd, int *

Line 530 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 561 get_history_event(const char *cmd, int *

Line 551 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 = malloc(len + 1)) == NULL)

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

return NULL;

(void)strncpy(pat, cmd + begin, len);

pat[len] = '\0';

}

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

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

if (pat != last_search_pat)

free(pat);

el_free(pat);

return (NULL);

return NULL;

}

num = ev.num;

if (sub) {

if (pat != last_search_pat) {

if (last_search_pat)

free(last_search_pat);

el_free(last_search_pat);

last_search_pat = pat;

}

ret = history_search(pat, -1);

Line 594 get_history_event(const char *cmd, int *

Line 584 get_history_event(const char *cmd, int *

if (ret == -1) {

/* restore to end of list on failed search */

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

history(h, &ev, H_FIRST);

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

if (pat != last_search_pat)

free(pat);

el_free(pat);

return(NULL);

return NULL;

}

if (sub && len) {

if (last_search_match && last_search_match != pat)

free(last_search_match);

el_free(last_search_match);

last_search_match = pat;

}

if (pat != last_search_pat)

free(pat);

el_free(pat);

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

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

return(NULL);

return NULL;

*cindex = idx;

rptr = ct_encode_string(ev.str, &conv);

rptr = ev.str;

/* roll back to original position */

(void)FUNW(history)(h, &ev, H_SET, num);

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

return rptr;

}

Line 663 _history_expand_command(const char *comm

Line 653 _history_expand_command(const char *comm

} else {

if (command[offs + 1] == '#') {

/* use command so far */

if ((aptr = malloc(offs + 1)) == NULL)

if ((aptr = el_malloc((offs + 1) * sizeof(*aptr)))

== NULL)

return -1;

(void)strncpy(aptr, command, offs);

aptr[offs] = '\0';

Line 674 _history_expand_command(const char *comm

Line 665 _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);

if (aptr)

free(aptr);

el_free(aptr);

if (*result == NULL)

return -1;

return(1);

return 1;

}

cmd = command + offs + idx + 1;

Line 731 _history_expand_command(const char *comm

Line 722 _history_expand_command(const char *comm

(void)fprintf(rl_outstream, "%s: Bad word specifier",

command + offs + idx);

if (aptr)

free(aptr);

el_free(aptr);

return(-1);

return -1;

}

} else

tmp = strdup(aptr? aptr:ptr);

if (aptr)

free(aptr);

el_free(aptr);

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

*result = tmp;

return(1);

return 1;

}

for (; *cmd; cmd++) {

Line 754 _history_expand_command(const char *comm

Line 745 _history_expand_command(const char *comm

} else if (*cmd == 't') { /* remove leading path */

if ((aptr = strrchr(tmp, '/')) != NULL) {

aptr = strdup(aptr + 1);

free(tmp);

el_free(tmp);

tmp = aptr;

}

} else if (*cmd == 'r') { /* remove trailing suffix */

Line 763 _history_expand_command(const char *comm

Line 754 _history_expand_command(const char *comm

} else if (*cmd == 'e') { /* remove all but suffix */

if ((aptr = strrchr(tmp, '.')) != NULL) {

aptr = strdup(aptr);

free(tmp);

el_free(tmp);

tmp = aptr;

}

} else if (*cmd == 'p') /* print only */

Line 780 _history_expand_command(const char *comm

Line 771 _history_expand_command(const char *comm

else if (*cmd == 's') {

delim = *(++cmd), cmd++;

size = 16;

what = realloc(from, size);

what = el_realloc(from, size * sizeof(*what));

if (what == NULL) {

free(from);

el_free(from);

free(tmp);

el_free(tmp);

return 0;

}

len = 0;

Line 792 _history_expand_command(const char *comm

Line 783 _history_expand_command(const char *comm

cmd++;

if (len >= size) {

char *nwhat;

nwhat = realloc(what,

nwhat = el_realloc(what,

(size <<= 1));

(size <<= 1) *

sizeof(*nwhat));

if (nwhat == NULL) {

free(what);

el_free(what);

free(tmp);

el_free(tmp);

return 0;

}

what = nwhat;

Line 806 _history_expand_command(const char *comm

Line 798 _history_expand_command(const char *comm

what[len] = '\0';

from = what;

if (*what == '\0') {

free(what);

el_free(what);

if (search) {

from = strdup(search);

if (from == NULL) {

free(tmp);

el_free(tmp);

return 0;

}

} else {

from = NULL;

free(tmp);

el_free(tmp);

return (-1);

return -1;

}

cmd++; /* shift after delim */

Line 824 _history_expand_command(const char *comm

Line 816 _history_expand_command(const char *comm

continue;

size = 16;

with = realloc(to, size);

with = el_realloc(to, size * sizeof(*with));

if (with == NULL) {

free(to);

el_free(to);

free(tmp);

el_free(tmp);

return -1;

}

len = 0;

Line 836 _history_expand_command(const char *comm

Line 828 _history_expand_command(const char *comm

if (len + from_len + 1 >= size) {

char *nwith;

size += from_len + 1;

nwith = realloc(with, size);

nwith = el_realloc(with,

size * sizeof(*nwith));

if (nwith == NULL) {

free(with);

el_free(with);

free(tmp);

el_free(tmp);

return -1;

}

with = nwith;

Line 862 _history_expand_command(const char *comm

Line 855 _history_expand_command(const char *comm

aptr = _rl_compat_sub(tmp, from, to, g_on);

if (aptr) {

free(tmp);

el_free(tmp);

tmp = aptr;

}

g_on = 0;

}

*result = tmp;

return (p_on? 2:1);

return p_on? 2:1;

}

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

Line 881 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 = malloc(strlen(str) + 4 + 1);

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

if (*output == NULL)

return 0;

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

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

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

#define ADD_STRING(what, len, fr) \

{ \

if (idx + len + 1 > size) { \

char *nresult = realloc(result, (size += len + 1));\

char *nresult = el_realloc(result, \

(size += len + 1) * sizeof(*nresult)); \

if (nresult == NULL) { \

free(*output); \

el_free(*output); \

if (/*CONSTCOND*/fr) \

free(tmp); \

el_free(tmp); \

return 0; \

} \

result = nresult; \

Line 982 loop:

Line 976 loop:

ADD_STRING(tmp, len, 1);

}

if (tmp) {

free(tmp);

el_free(tmp);

tmp = NULL;

}

i = j;

Line 999 loop:

Line 993 loop:

ret = -1;

#endif

}

free(*output);

el_free(*output);

*output = result;

return (ret);

return ret;

}

Line 1037 history_arg_extract(int start, int end,

Line 1031 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 = malloc(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 1054 history_arg_extract(int start, int end,

Line 1048 history_arg_extract(int start, int end,

out:

for (i = 0; arr[i]; i++)

free(arr[i]);

el_free(arr[i]);

free(arr);

el_free(arr);

return result;

}

Line 1094 history_tokenize(const char *str)

Line 1088 history_tokenize(const char *str)

if (idx + 2 >= size) {

char **nresult;

size <<= 1;

nresult = realloc(result, size * sizeof(char *));

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

if (nresult == NULL) {

free(result);

el_free(result);

return NULL;

}

result = nresult;

}

len = i - start;

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

temp = malloc(len + 1);

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

if (temp == NULL) {

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

free(result[i]);

el_free(result[i]);

free(result);

el_free(result);

return NULL;

}

(void)strncpy(temp, &str[start], len);

Line 1116 history_tokenize(const char *str)

Line 1110 history_tokenize(const char *str)

if (str[i])

i++;

}

return (result);

return result;

}

Line 1126 history_tokenize(const char *str)

Line 1120 history_tokenize(const char *str)

void

stifle_history(int max)

{

TYPE(HistEvent) ev;

HistEvent ev;

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

rl_initialize();

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

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

max_input_history = max;

}

Line 1142 stifle_history(int max)

Line 1136 stifle_history(int max)

int

unstifle_history(void)

{

TYPE(HistEvent) ev;

HistEvent ev;

int omax;

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

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 1151 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 1186 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 1196 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 1204 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 1242 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 1256 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 1268 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 1303 out1:

Line 1298 out1:

int

read_history(const char *filename)

{

TYPE(HistEvent) ev;

HistEvent ev;

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

rl_initialize();

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

return errno;

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

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

(errno ? errno : EINVAL) : 0);

(errno ? errno : EINVAL) : 0;

}

Line 1320 read_history(const char *filename)

Line 1315 read_history(const char *filename)

int

write_history(const char *filename)

{

TYPE(HistEvent) ev;

HistEvent ev;

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

rl_initialize();

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

return errno;

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

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

(errno ? errno : EINVAL) : 0);

(errno ? errno : EINVAL) : 0;

}

Line 1340 HIST_ENTRY *

Line 1335 HIST_ENTRY *

history_get(int num)

{

static HIST_ENTRY she;

TYPE(HistEvent) ev;

HistEvent ev;

int curr_num;

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

rl_initialize();

/* save current position */

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

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

return (NULL);

return NULL;

curr_num = ev.num;

/* start from the oldest */

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

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

return (NULL); /* error */

return NULL; /* error */

/* look forwards for event matching specified offset */

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

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

return (NULL);

return NULL;

she.line = ct_encode_string(ev.str, &conv);

she.line = ev.str;

/* restore pointer to where it was */

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

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

return (&she);

return &she;

}

Line 1374 history_get(int num)

Line 1369 history_get(int num)

int

add_history(const char *line)

{

TYPE(HistEvent) ev;

HistEvent ev;

const Char *wline;

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

rl_initialize();

wline = ct_decode_string(line, &conv);

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

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

(void)FUNW(history)(h, &ev, H_ENTER, wline);

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

history_length = ev.num;

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

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

}

Line 1397 HIST_ENTRY *

Line 1389 HIST_ENTRY *

remove_history(int num)

{

HIST_ENTRY *he;

TYPE(HistEvent) ev;

HistEvent ev;

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

rl_initialize();

if ((he = malloc(sizeof(*he))) == NULL)

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

return NULL;

if (FUNW(history)(h, &ev, H_DELDATA, num, &he->data) != 0) {

if (history(h, &ev, H_DELDATA, num, &he->data) != 0) {

free(he);

el_free(he);

return NULL;

}

he->line = ct_encode_string(ev.str, &conv);

he->line = ev.str;

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

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

history_length = ev.num;

return he;

Line 1425 HIST_ENTRY *

Line 1417 HIST_ENTRY *

replace_history_entry(int num, const char *line, histdata_t data)

{

HIST_ENTRY *he;

TYPE(HistEvent) ev;

HistEvent ev;

int curr_num;

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

rl_initialize();

/* save current position */

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

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

return NULL;

curr_num = ev.num;

/* start from the oldest */

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

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

return NULL; /* error */

if ((he = malloc(sizeof(*he))) == NULL)

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

return NULL;

/* look forwards for event matching specified offset */

if (FUNW(history)(h, &ev, H_NEXT_EVDATA, num, &he->data))

if (history(h, &ev, H_NEXT_EVDATA, num, &he->data))

goto out;

he->line = strdup(ct_encode_string(ev.str, &e->el_scratch));

he->line = strdup(ev.str);

if (he->line == NULL)

goto out;

if (FUNW(history)(h, &ev, H_REPLACE, line, data))

if (history(h, &ev, H_REPLACE, line, data))

goto out;

/* restore pointer to where it was */

if (FUNW(history)(h, &ev, H_SET, curr_num))

if (history(h, &ev, H_SET, curr_num))

goto out;

return he;

out:

free(he);

el_free(he);

return NULL;

}

Line 1470 out:

Line 1462 out:

void

clear_history(void)

{

TYPE(HistEvent) ev;

HistEvent ev;

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

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

history_length = 0;

}

Line 1483 clear_history(void)

Line 1475 clear_history(void)

int

where_history(void)

{

TYPE(HistEvent) ev;

HistEvent ev;

int curr_num, off;

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

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

return (0);

return 0;

curr_num = ev.num;

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

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

off = 1;

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

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

off++;

return (off);

return off;

}

Line 1506 HIST_ENTRY *

Line 1498 HIST_ENTRY *

current_history(void)

{

return (_move_history(H_CURR));

return _move_history(H_CURR);

}

Line 1516 current_history(void)

Line 1508 current_history(void)

int

history_total_bytes(void)

{

TYPE(HistEvent) ev;

HistEvent ev;

int curr_num;

size_t size;

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

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

return (-1);

return -1;

curr_num = ev.num;

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

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

size = 0;

size += Strlen(ev.str) * sizeof(*ev.str);

size += strlen(ev.str) * sizeof(*ev.str);

while (FUNW(history)(h, &ev, H_NEXT) == 0);

while (history(h, &ev, H_NEXT) == 0);

/* get to the same position as before */

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

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

return (int)(size);

return (int)size;

}

Line 1543 history_total_bytes(void)

Line 1535 history_total_bytes(void)

int

history_set_pos(int pos)

{

TYPE(HistEvent) ev;

HistEvent ev;

int curr_num;

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

return (-1);

return -1;

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

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

curr_num = ev.num;

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

* (void **)-1

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

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

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

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

return(-1);

return -1;

}

return (0);

return 0;

}

Line 1571 HIST_ENTRY *

Line 1563 HIST_ENTRY *

previous_history(void)

{

return (_move_history(H_PREV));

return _move_history(H_PREV);

}

Line 1582 HIST_ENTRY *

Line 1574 HIST_ENTRY *

next_history(void)

{

return (_move_history(H_NEXT));

return _move_history(H_NEXT);

}

Line 1592 next_history(void)

Line 1584 next_history(void)

int

history_search(const char *str, int direction)

{

TYPE(HistEvent) ev;

HistEvent ev;

const Char *strp;

const char *strp;

const Char *wstr;

int curr_num;

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

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

return (-1);

return -1;

curr_num = ev.num;

wstr = ct_decode_string(str, &conv);

for (;;) {

if ((strp = Strstr(ev.str, wstr)) != NULL)

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

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

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

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

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

break;

}

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

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

return (-1);

return -1;

}

Line 1619 history_search(const char *str, int dire

Line 1609 history_search(const char *str, int dire

int

history_search_prefix(const char *str, int direction)

{

TYPE(HistEvent) ev;

HistEvent ev;

return (FUNW(history)(h, &ev, direction < 0 ?

return (history(h, &ev, direction < 0 ?

H_PREV_STR : H_NEXT_STR, str));

}

Line 1635 int

Line 1625 int

history_search_pos(const char *str,

int direction __attribute__((__unused__)), int pos)

{

TYPE(HistEvent) ev;

HistEvent ev;

int curr_num, off;

const Char *wstr;

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

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

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

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

return (-1);

return -1;

curr_num = ev.num;

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

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

return (-1);

return -1;

wstr = ct_decode_string(str, &conv);

for (;;) {

if (Strstr(ev.str, wstr))

if (strstr(ev.str, str))

return (off);

return off;

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

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

break;

}

/* set "current" pointer back to previous state */

(void)FUNW(history)(h, &ev,

(void)history(h, &ev,

pos < 0 ? H_NEXT_EVENT : H_PREV_EVENT, curr_num);

return (-1);

return -1;

}

Line 1684 filename_completion_function(const char

Line 1672 filename_completion_function(const char

* a completion generator for usernames; returns _first_ username

* which starts with supplied text

* text contains a partial username preceded by random character

* (usually '~'); state is ignored

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

* it's callers responsibility to free returned value

char *

username_completion_function(const char *text, int state)

{

struct passwd *pwd, pwres;

#if defined(HAVE_GETPW_R_POSIX) || defined(HAVE_GETPW_R_DRAFT)

struct passwd pwres;

char pwbuf[1024];

#endif

struct passwd *pass = NULL;

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

return (NULL);

return NULL;

if (*text == '~')

text++;

Line 1702 username_completion_function(const char

Line 1693 username_completion_function(const char

if (state == 0)

setpwent();

while (getpwent_r(&pwres, pwbuf, sizeof(pwbuf), &pwd) == 0

while (

&& pwd != NULL && text[0] == pwd->pw_name[0]

#if defined(HAVE_GETPW_R_POSIX) || defined(HAVE_GETPW_R_DRAFT)

&& strcmp(text, pwd->pw_name) == 0);

getpwent_r(&pwres, pwbuf, sizeof(pwbuf), &pass) == 0 && pass != NULL

#else

(pass = getpwent()) != NULL

#endif

&& text[0] == pass->pw_name[0]

&& strcmp(text, pass->pw_name) == 0)

continue;

if (pwd == NULL) {

if (pass == NULL) {

endpwent();

return NULL;

}

return strdup(pwd->pw_name);

return strdup(pass->pw_name);

}

Line 1743 _rl_completion_append_character_function

Line 1740 _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 1768 rl_complete(int ignore __attribute__((__

Line 1765 rl_complete(int ignore __attribute__((__

arr[0] = (char)invoking_key;

arr[1] = '\0';

el_insertstr(e, arr);

return (CC_REFRESH);

return CC_REFRESH;

}

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

Line 1781 rl_complete(int ignore __attribute__((__

Line 1778 rl_complete(int ignore __attribute__((__

(size_t)rl_completion_query_items,

&rl_completion_type, &rl_attempted_completion_over,

&rl_point, &rl_end);

}

Line 1811 rl_bind_key(int c, rl_command_func_t *fu

Line 1810 rl_bind_key(int c, rl_command_func_t *fu

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

retval = 0;

}

return (retval);

return retval;

}

Line 1827 rl_read_key(void)

Line 1826 rl_read_key(void)

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

rl_initialize();

return (el_getc(e, fooarr));

return el_getc(e, fooarr);

}

Line 1857 rl_insert(int count, int c)

Line 1856 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 1892 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;

Line 1969 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 1978 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 1987 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 2001 rl_deprep_terminal(void)

int

rl_read_init_file(const char *s)

{

return(el_source(e, s));

return el_source(e, s);

}

int

Line 2015 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 2025 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) == -1 ? 1 : 0;

}

void

Line 2033 rl_stuff_char(int c)

{

char buf[2];

buf[0] = c;

buf[0] = (char)c;

buf[1] = '\0';

el_insertstr(e, buf);

}

Line 2051 _rl_event_read_char(EditLine *el, char *

#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, cp, (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);

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

return(-1);

return -1;

#endif

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

Line 2117 rl_completion_matches(const char *str, r

len = 1;

max = 10;

if ((list = malloc(max * sizeof(*list))) == NULL)

if ((list = el_malloc(max * sizeof(*list))) == NULL)

return NULL;

while ((match = (*fun)(str, (int)(len - 1))) != NULL) {

Line 2125 rl_completion_matches(const char *str, r

if (len == max) {

char **nl;

max += 10;

if ((nl = realloc(list, max * sizeof(*nl))) == NULL)

if ((nl = el_realloc(list, max * sizeof(*nl))) == NULL)

goto out;

list = nl;

}

Line 2152 rl_completion_matches(const char *str, r

if ((list[0] = strdup(str)) == NULL)

goto out;

} else {

if ((list[0] = malloc(min + 1)) == NULL)

if ((list[0] = el_malloc((min + 1) * sizeof(*list[0]))) == NULL)

goto out;

(void)memcpy(list[0], list[1], min);

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

Line 2160 rl_completion_matches(const char *str, r

return list;

out:

free(list);

el_free(list);

return NULL;

}

Line 2195 history_get_history_state(void)

{

HISTORY_STATE *hs;

if ((hs = malloc(sizeof(HISTORY_STATE))) == NULL)

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 2222 rl_get_keymap(void)

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

}

CVSweb <webmaster@jp.NetBSD.org>