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.100 and 1.121

version 1.100, 2011/11/18 20:38:42

version 1.121, 2016/02/16 14:06:05

Line 37 __RCSID("$NetBSD$");

#include <sys/types.h>

#include <sys/stat.h>

#include <stdio.h>

#include <stdint.h>

#include <dirent.h>

#include <string.h>

#include <pwd.h>

Line 50 __RCSID("$NetBSD$");

Line 51 __RCSID("$NetBSD$");

#include <vis.h>

#include "readline/readline.h"

#include "histedit.h"

#include "el.h"

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

#include "histedit.h"

#include "filecomplete.h"

void rl_prep_terminal(int);

Line 78 FILE *rl_outstream = NULL;

Line 79 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 99 int rl_attempted_completion_over = 0;

Line 108 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 108 char *rl_terminal_name = NULL;

Line 118 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 152 int rl_completion_append_character = ' '

Line 161 int rl_completion_append_character = ' '

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

Line 228 static const char *

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

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

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 323 rl_initialize(void)

Line 339 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 347 rl_initialize(void)

Line 363 rl_initialize(void)

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

Line 666 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 933 loop:

Line 980 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 1371 add_history(const char *line)

Line 1419 add_history(const char *line)

{

HistEvent ev;

if (line == NULL)

return 0;

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

rl_initialize();

Line 1464 clear_history(void)

Line 1515 clear_history(void)

{

HistEvent ev;

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

rl_initialize();

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

history_length = 0;

}

Line 1673 filename_completion_function(const char

Line 1727 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 1756 rl_complete(int ignore __attribute__((__

Line 1810 rl_complete(int ignore __attribute__((__

#ifdef WIDECHAR

static ct_buffer_t wbreak_conv, sprefix_conv;

#endif

char *breakchars;

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

rl_initialize();

Line 1768 rl_complete(int ignore __attribute__((__

Line 1823 rl_complete(int ignore __attribute__((__

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 1899 rl_bind_wrapper(EditLine *el __attribute

Line 1961 rl_bind_wrapper(EditLine *el __attribute

_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 1909 rl_bind_wrapper(EditLine *el __attribute

Line 1971 rl_bind_wrapper(EditLine *el __attribute

}

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 1917 rl_add_defun(const char *name, Function

Line 1979 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 1943 rl_callback_read_char()

Line 2005 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 2025 rl_variable_bind(const char *var, const

Line 2087 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 2094 void

Line 2156 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 2104 rl_set_screen_size(int rows, int cols)

Line 2166 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 2140 rl_completion_matches(const char *str, r

Line 2202 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 2257 rl_on_new_line(void)

Line 2319 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>