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.115 and 1.128

version 1.115, 2015/04/01 15:23:15

version 1.128, 2016/04/18 17:01:19

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>

#include <stdint.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include <vis.h>

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

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;

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

CPPFunction *rl_attempted_completion_function = 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 160 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 */

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 210 _move_history(int op)

static int

/*ARGSUSED*/

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

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

{

int i;

i = (*rl_getc_function)(NULL);

if (i == -1)

return 0;

*c = (char)i;

*c = (wchar_t)i;

return 1;

}

Line 267 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 361 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.

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

Line 1827 rl_complete(int ignore __attribute__((__

Line 1825 rl_complete(int ignore __attribute__((__

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(breakchars, &sprefix_conv),

Line 1958 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 1968 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 2006 rl_callback_read_char(void)

}

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 2015 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 2098 rl_stuff_char(int c)

}

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

Line 2112 _rl_event_read_char(EditLine *el, char *

Line 2114 _rl_event_read_char(EditLine *el, char *

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

return -1;

if (n)

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

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

else

num_read = 0;

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

Line 2120 _rl_event_read_char(EditLine *el, char *

Line 2122 _rl_event_read_char(EditLine *el, char *

return -1;

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

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;

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

#endif

Line 2137 _rl_event_read_char(EditLine *el, char *

Line 2139 _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 2199 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 2217 rl_completion_matches(const char *str, r

Line 2220 rl_completion_matches(const char *str, r

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

}

return list;

out:

el_free(list);

return NULL;

Line 2321 void

Line 2324 void

rl_free_line_state(void)

{

}

int

/*ARGSUSED*/

rl_set_keyboard_input_timeout(int u __attribute__((__unused__)))

{

return 0;

}

CVSweb <webmaster@jp.NetBSD.org>