Our libedit has been diverging from the mainstream version maintained in NetBSD. As a consequence it has been difficult to do an appropriate MFV and we have been bringing only partial updates. Here we update most of the files to at least match the version available in NetBSD's snapshot of 20091228. This version was chosen because it still doesn't include wide character support (UTF-8), which involves many changes and new files. From NetBSD's logs: Dec 15 22:13:33 2006 - editline.3 el.c el.h histedit.h add EL_GETFP, and EL_SETFP. Apr 5 15:53:28 2008 - editline.3 el.c histedit.h readline.c add EL_REFRESH for the benefit of readline Sep 10 15:45:37 2008 - common.c el.c read.c refresh.c sig.c term.c term.h tty.c Allow a single process to control multiple ttys (for pthreads using _REENTRANT) using multiple EditLine objects. Jan 18 12:17:24 2009 - el.c read.c readline.c fix -Wsign-compare issues Feb 6 14:40:32 2009 - history.c Plug memory leak, from MySQL. Feb 5 19:15:44 2009 - histedit.h read.c match documentation in el_push Feb 6 13:14:37 2009 - vi.c Portability fix. Feb 12 13:39:49 2009 - readline.c term.c More fixes for existing portability stuff. Feb 15 21:24:13 2009 - el.h read.c don't restart on EINTR, instead return NULL immediately. From Anon Ymous Feb 15 21:25:01 2009 - sig.c sig.h in order for read() to return EINTR we need to use sigaction, not signal, otherwise SA_RESTART is set. Feb 15 21:55:23 2009 - chared.c chared.h common.c emacs.c filecomplete.c filecomplete.h key.c key.h read.c readline.c refresh.c search.c term.c tokenizer.c tty.c vi.c pass lint on _LP64. Feb 17 21:34:26 2009 - el.c histedit.h prompt.c prompt.h allow for a prompt argument. Feb 18 15:04:40 2009 - sig.c SA_RESTART for all signals but SIGINT. From Anon Ymous. Feb 19 15:20:22 2009 - read.c sig.c sig.h reset and redraw on sigcont. From Anon Ymous. Feb 21 23:31:56 2009 - key.c key.h readline.c vi.c more size_t stuff. Mar 10 20:46:15 2009 - editline.3 read.c make el_gets set the count to -1 on error to distinguish between EOF and error. Mar 31 17:38:27 2009 - editline.3 el.c histedit.h prompt.c prompt.h refresh.c term.c term.h Implement literal prompt sequences. Now someone can implement RL_PROMPT_START_LITERAL/RL_PROMPT_END_LITERAL :-) Mar 31 21:33:17 2009 - term.c cast to size_t to avoid sign / unsigned comparison warning. Apr 23 02:03 2009 - term.c Apply patch (requested by msaitoh in ticket #2007): Coverity CID 1668: Plug memory leak when malloc() failed.:55 2009 May 11 18:33:30 2009 - editline.3 el.c histedit.h restore binary compatibility by providing new prompt functions that take an extra literal character. May 19 21:45:14 2009 - refresh.c always scroll when we advance past bottom. From Caleb Welton cwelton at greenplum dot com. Jul 17 12:27:57 2009 - term.c - off by one in the term.h case. - make code more similar to tcsh (if we want to handle wide chars, this is needed; for now it is a no-op) Jul 22 15:56:29 2009 - el.c Move filename to the scope it is being used. From Michael Cook mcook at bbn dot com Jul 22 15:57:00 2009 - read.c Always initialize nread since it is an out param. From Michael Cook mcook at bbn dot com Jul 22 18:25:26 2009 - el.c Only need path if we have issetugid... From Anon Ymous Jul 25 21:19:23 2009 - el.c Ignore comment lines in .editrc from Jess Thrysoee Sep 7 21:24:33 2009 histedit.h history.c readline.c apply apple patches from: http://opensource.apple.com/source/libedit/libedit-11/patches/ Dec 28 21:52:43 2009 - refresh.c Fix bug where tab completion on the second or > line that caused listing ended up corrupting the display by an extra space in the beginning. Reported by Mac Chan. Dec 28 22:15:36 2009 - refresh.c term.c reduce diff with tcsh Obtained from: NetBSD Tested by: bapt, jilles and current@ MFC after: 1 week
662 lines
15 KiB
C
662 lines
15 KiB
C
/*-
|
|
* Copyright (c) 1992, 1993
|
|
* The Regents of the University of California. All rights reserved.
|
|
*
|
|
* This code is derived from software contributed to Berkeley by
|
|
* Christos Zoulas of Cornell University.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
* 3. Neither the name of the University nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*
|
|
* $NetBSD: read.c,v 1.52 2009/07/22 15:57:00 christos Exp $
|
|
*/
|
|
|
|
#if !defined(lint) && !defined(SCCSID)
|
|
static char sccsid[] = "@(#)read.c 8.1 (Berkeley) 6/4/93";
|
|
#endif /* not lint && not SCCSID */
|
|
#include <sys/cdefs.h>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
/*
|
|
* read.c: Clean this junk up! This is horrible code.
|
|
* Terminal read functions
|
|
*/
|
|
#include "sys.h"
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
#include <stdlib.h>
|
|
#include "el.h"
|
|
|
|
#define OKCMD -1 /* must be -1! */
|
|
|
|
private int read__fixio(int, int);
|
|
private int read_preread(EditLine *);
|
|
private int read_char(EditLine *, char *);
|
|
private int read_getcmd(EditLine *, el_action_t *, char *);
|
|
private void read_pop(c_macro_t *);
|
|
|
|
/* read_init():
|
|
* Initialize the read stuff
|
|
*/
|
|
protected int
|
|
read_init(EditLine *el)
|
|
{
|
|
/* builtin read_char */
|
|
el->el_read.read_char = read_char;
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* el_read_setfn():
|
|
* Set the read char function to the one provided.
|
|
* If it is set to EL_BUILTIN_GETCFN, then reset to the builtin one.
|
|
*/
|
|
protected int
|
|
el_read_setfn(EditLine *el, el_rfunc_t rc)
|
|
{
|
|
el->el_read.read_char = (rc == EL_BUILTIN_GETCFN) ? read_char : rc;
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* el_read_getfn():
|
|
* return the current read char function, or EL_BUILTIN_GETCFN
|
|
* if it is the default one
|
|
*/
|
|
protected el_rfunc_t
|
|
el_read_getfn(EditLine *el)
|
|
{
|
|
return (el->el_read.read_char == read_char) ?
|
|
EL_BUILTIN_GETCFN : el->el_read.read_char;
|
|
}
|
|
|
|
|
|
#ifndef MIN
|
|
#define MIN(A,B) ((A) < (B) ? (A) : (B))
|
|
#endif
|
|
|
|
#ifdef DEBUG_EDIT
|
|
private void
|
|
read_debug(EditLine *el)
|
|
{
|
|
|
|
if (el->el_line.cursor > el->el_line.lastchar)
|
|
(void) fprintf(el->el_errfile, "cursor > lastchar\r\n");
|
|
if (el->el_line.cursor < el->el_line.buffer)
|
|
(void) fprintf(el->el_errfile, "cursor < buffer\r\n");
|
|
if (el->el_line.cursor > el->el_line.limit)
|
|
(void) fprintf(el->el_errfile, "cursor > limit\r\n");
|
|
if (el->el_line.lastchar > el->el_line.limit)
|
|
(void) fprintf(el->el_errfile, "lastchar > limit\r\n");
|
|
if (el->el_line.limit != &el->el_line.buffer[EL_BUFSIZ - 2])
|
|
(void) fprintf(el->el_errfile, "limit != &buffer[EL_BUFSIZ-2]\r\n");
|
|
}
|
|
#endif /* DEBUG_EDIT */
|
|
|
|
|
|
/* read__fixio():
|
|
* Try to recover from a read error
|
|
*/
|
|
/* ARGSUSED */
|
|
private int
|
|
read__fixio(int fd __unused, int e)
|
|
{
|
|
|
|
switch (e) {
|
|
case -1: /* Make sure that the code is reachable */
|
|
|
|
#ifdef EWOULDBLOCK
|
|
case EWOULDBLOCK:
|
|
#ifndef TRY_AGAIN
|
|
#define TRY_AGAIN
|
|
#endif
|
|
#endif /* EWOULDBLOCK */
|
|
|
|
#if defined(POSIX) && defined(EAGAIN)
|
|
#if defined(EWOULDBLOCK) && EWOULDBLOCK != EAGAIN
|
|
case EAGAIN:
|
|
#ifndef TRY_AGAIN
|
|
#define TRY_AGAIN
|
|
#endif
|
|
#endif /* EWOULDBLOCK && EWOULDBLOCK != EAGAIN */
|
|
#endif /* POSIX && EAGAIN */
|
|
|
|
e = 0;
|
|
#ifdef TRY_AGAIN
|
|
#if defined(F_SETFL) && defined(O_NDELAY)
|
|
if ((e = fcntl(fd, F_GETFL, 0)) == -1)
|
|
return (-1);
|
|
|
|
if (fcntl(fd, F_SETFL, e & ~O_NDELAY) == -1)
|
|
return (-1);
|
|
else
|
|
e = 1;
|
|
#endif /* F_SETFL && O_NDELAY */
|
|
|
|
#ifdef FIONBIO
|
|
{
|
|
int zero = 0;
|
|
|
|
if (ioctl(fd, FIONBIO, (ioctl_t) & zero) == -1)
|
|
return (-1);
|
|
else
|
|
e = 1;
|
|
}
|
|
#endif /* FIONBIO */
|
|
|
|
#endif /* TRY_AGAIN */
|
|
return (e ? 0 : -1);
|
|
|
|
case EINTR:
|
|
return (-1);
|
|
|
|
default:
|
|
return (-1);
|
|
}
|
|
}
|
|
|
|
|
|
/* read_preread():
|
|
* Try to read the stuff in the input queue;
|
|
*/
|
|
private int
|
|
read_preread(EditLine *el)
|
|
{
|
|
int chrs = 0;
|
|
|
|
if (el->el_tty.t_mode == ED_IO)
|
|
return (0);
|
|
|
|
#ifdef FIONREAD
|
|
(void) ioctl(el->el_infd, FIONREAD, (ioctl_t) & chrs);
|
|
if (chrs > 0) {
|
|
char buf[EL_BUFSIZ];
|
|
|
|
chrs = read(el->el_infd, buf,
|
|
(size_t) MIN(chrs, EL_BUFSIZ - 1));
|
|
if (chrs > 0) {
|
|
buf[chrs] = '\0';
|
|
el_push(el, buf);
|
|
}
|
|
}
|
|
#endif /* FIONREAD */
|
|
|
|
return (chrs > 0);
|
|
}
|
|
|
|
|
|
/* el_push():
|
|
* Push a macro
|
|
*/
|
|
public void
|
|
el_push(EditLine *el, const char *str)
|
|
{
|
|
c_macro_t *ma = &el->el_chared.c_macro;
|
|
|
|
if (str != NULL && ma->level + 1 < EL_MAXMACRO) {
|
|
ma->level++;
|
|
if ((ma->macro[ma->level] = el_strdup(str)) != NULL)
|
|
return;
|
|
ma->level--;
|
|
}
|
|
term_beep(el);
|
|
term__flush(el);
|
|
}
|
|
|
|
|
|
/* read_getcmd():
|
|
* Return next command from the input stream.
|
|
*/
|
|
private int
|
|
read_getcmd(EditLine *el, el_action_t *cmdnum, char *ch)
|
|
{
|
|
el_action_t cmd;
|
|
int num;
|
|
|
|
el->el_errno = 0;
|
|
do {
|
|
if ((num = el_getc(el, ch)) != 1) { /* if EOF or error */
|
|
el->el_errno = num == 0 ? 0 : errno;
|
|
return (num);
|
|
}
|
|
|
|
#ifdef KANJI
|
|
if ((*ch & 0200)) {
|
|
el->el_state.metanext = 0;
|
|
cmd = CcViMap[' '];
|
|
break;
|
|
} else
|
|
#endif /* KANJI */
|
|
|
|
if (el->el_state.metanext) {
|
|
el->el_state.metanext = 0;
|
|
*ch |= 0200;
|
|
}
|
|
cmd = el->el_map.current[(unsigned char) *ch];
|
|
if (cmd == ED_SEQUENCE_LEAD_IN) {
|
|
key_value_t val;
|
|
switch (key_get(el, ch, &val)) {
|
|
case XK_CMD:
|
|
cmd = val.cmd;
|
|
break;
|
|
case XK_STR:
|
|
el_push(el, val.str);
|
|
break;
|
|
#ifdef notyet
|
|
case XK_EXE:
|
|
/* XXX: In the future to run a user function */
|
|
RunCommand(val.str);
|
|
break;
|
|
#endif
|
|
default:
|
|
EL_ABORT((el->el_errfile, "Bad XK_ type \n"));
|
|
break;
|
|
}
|
|
}
|
|
if (el->el_map.alt == NULL)
|
|
el->el_map.current = el->el_map.key;
|
|
} while (cmd == ED_SEQUENCE_LEAD_IN);
|
|
*cmdnum = cmd;
|
|
return (OKCMD);
|
|
}
|
|
|
|
|
|
/* read_char():
|
|
* Read a character from the tty.
|
|
*/
|
|
private int
|
|
read_char(EditLine *el, char *cp)
|
|
{
|
|
ssize_t num_read;
|
|
int tried = 0;
|
|
|
|
again:
|
|
el->el_signal->sig_no = 0;
|
|
while ((num_read = read(el->el_infd, cp, 1)) == -1) {
|
|
if (el->el_signal->sig_no == SIGCONT) {
|
|
sig_set(el);
|
|
el_set(el, EL_REFRESH);
|
|
goto again;
|
|
}
|
|
if (!tried && read__fixio(el->el_infd, errno) == 0)
|
|
tried = 1;
|
|
else {
|
|
*cp = '\0';
|
|
return (-1);
|
|
}
|
|
}
|
|
return (int)num_read;
|
|
}
|
|
|
|
/* read_pop():
|
|
* Pop a macro from the stack
|
|
*/
|
|
private void
|
|
read_pop(c_macro_t *ma)
|
|
{
|
|
int i;
|
|
|
|
el_free(ma->macro[0]);
|
|
for (i = 0; i < ma->level; i++)
|
|
ma->macro[i] = ma->macro[i + 1];
|
|
ma->level--;
|
|
ma->offset = 0;
|
|
}
|
|
|
|
/* el_getc():
|
|
* Read a character
|
|
*/
|
|
public int
|
|
el_getc(EditLine *el, char *cp)
|
|
{
|
|
int num_read;
|
|
c_macro_t *ma = &el->el_chared.c_macro;
|
|
|
|
term__flush(el);
|
|
for (;;) {
|
|
if (ma->level < 0) {
|
|
if (!read_preread(el))
|
|
break;
|
|
}
|
|
|
|
if (ma->level < 0)
|
|
break;
|
|
|
|
if (ma->macro[0][ma->offset] == '\0') {
|
|
read_pop(ma);
|
|
continue;
|
|
}
|
|
|
|
*cp = ma->macro[0][ma->offset++] & 0377;
|
|
|
|
if (ma->macro[0][ma->offset] == '\0') {
|
|
/* Needed for QuoteMode On */
|
|
read_pop(ma);
|
|
}
|
|
|
|
return (1);
|
|
}
|
|
|
|
#ifdef DEBUG_READ
|
|
(void) fprintf(el->el_errfile, "Turning raw mode on\n");
|
|
#endif /* DEBUG_READ */
|
|
if (tty_rawmode(el) < 0)/* make sure the tty is set up correctly */
|
|
return (0);
|
|
|
|
#ifdef DEBUG_READ
|
|
(void) fprintf(el->el_errfile, "Reading a character\n");
|
|
#endif /* DEBUG_READ */
|
|
num_read = (*el->el_read.read_char)(el, cp);
|
|
#ifdef DEBUG_READ
|
|
(void) fprintf(el->el_errfile, "Got it %c\n", *cp);
|
|
#endif /* DEBUG_READ */
|
|
return (num_read);
|
|
}
|
|
|
|
protected void
|
|
read_prepare(EditLine *el)
|
|
{
|
|
if (el->el_flags & HANDLE_SIGNALS)
|
|
sig_set(el);
|
|
if (el->el_flags & NO_TTY)
|
|
return;
|
|
if ((el->el_flags & (UNBUFFERED|EDIT_DISABLED)) == UNBUFFERED)
|
|
tty_rawmode(el);
|
|
|
|
/* This is relatively cheap, and things go terribly wrong if
|
|
we have the wrong size. */
|
|
el_resize(el);
|
|
re_clear_display(el); /* reset the display stuff */
|
|
ch_reset(el, 0);
|
|
re_refresh(el); /* print the prompt */
|
|
|
|
if (el->el_flags & UNBUFFERED)
|
|
term__flush(el);
|
|
}
|
|
|
|
protected void
|
|
read_finish(EditLine *el)
|
|
{
|
|
if ((el->el_flags & UNBUFFERED) == 0)
|
|
(void) tty_cookedmode(el);
|
|
if (el->el_flags & HANDLE_SIGNALS)
|
|
sig_clr(el);
|
|
}
|
|
|
|
public const char *
|
|
el_gets(EditLine *el, int *nread)
|
|
{
|
|
int retval;
|
|
el_action_t cmdnum = 0;
|
|
int num; /* how many chars we have read at NL */
|
|
char ch;
|
|
int crlf = 0;
|
|
int nrb;
|
|
#ifdef FIONREAD
|
|
c_macro_t *ma = &el->el_chared.c_macro;
|
|
#endif /* FIONREAD */
|
|
|
|
if (nread == NULL)
|
|
nread = &nrb;
|
|
*nread = 0;
|
|
|
|
if (el->el_flags & NO_TTY) {
|
|
char *cp = el->el_line.buffer;
|
|
size_t idx;
|
|
|
|
while ((num = (*el->el_read.read_char)(el, cp)) == 1) {
|
|
/* make sure there is space for next character */
|
|
if (cp + 1 >= el->el_line.limit) {
|
|
idx = (cp - el->el_line.buffer);
|
|
if (!ch_enlargebufs(el, 2))
|
|
break;
|
|
cp = &el->el_line.buffer[idx];
|
|
}
|
|
cp++;
|
|
if (el->el_flags & UNBUFFERED)
|
|
break;
|
|
if (cp[-1] == '\r' || cp[-1] == '\n')
|
|
break;
|
|
}
|
|
if (num == -1) {
|
|
if (errno == EINTR)
|
|
cp = el->el_line.buffer;
|
|
el->el_errno = errno;
|
|
}
|
|
|
|
el->el_line.cursor = el->el_line.lastchar = cp;
|
|
*cp = '\0';
|
|
*nread = (int)(el->el_line.cursor - el->el_line.buffer);
|
|
goto done;
|
|
}
|
|
|
|
|
|
#ifdef FIONREAD
|
|
if (el->el_tty.t_mode == EX_IO && ma->level < 0) {
|
|
long chrs = 0;
|
|
|
|
(void) ioctl(el->el_infd, FIONREAD, (ioctl_t) & chrs);
|
|
if (chrs == 0) {
|
|
if (tty_rawmode(el) < 0) {
|
|
errno = 0;
|
|
*nread = 0;
|
|
return (NULL);
|
|
}
|
|
}
|
|
}
|
|
#endif /* FIONREAD */
|
|
|
|
if ((el->el_flags & UNBUFFERED) == 0)
|
|
read_prepare(el);
|
|
|
|
if (el->el_flags & EDIT_DISABLED) {
|
|
char *cp;
|
|
size_t idx;
|
|
|
|
if ((el->el_flags & UNBUFFERED) == 0)
|
|
cp = el->el_line.buffer;
|
|
else
|
|
cp = el->el_line.lastchar;
|
|
|
|
term__flush(el);
|
|
|
|
while ((num = (*el->el_read.read_char)(el, cp)) == 1) {
|
|
/* make sure there is space next character */
|
|
if (cp + 1 >= el->el_line.limit) {
|
|
idx = (cp - el->el_line.buffer);
|
|
if (!ch_enlargebufs(el, 2))
|
|
break;
|
|
cp = &el->el_line.buffer[idx];
|
|
}
|
|
cp++;
|
|
crlf = cp[-1] == '\r' || cp[-1] == '\n';
|
|
if (el->el_flags & UNBUFFERED)
|
|
break;
|
|
if (crlf)
|
|
break;
|
|
}
|
|
|
|
if (num == -1) {
|
|
if (errno == EINTR)
|
|
cp = el->el_line.buffer;
|
|
el->el_errno = errno;
|
|
}
|
|
|
|
el->el_line.cursor = el->el_line.lastchar = cp;
|
|
*cp = '\0';
|
|
goto done;
|
|
}
|
|
|
|
for (num = OKCMD; num == OKCMD;) { /* while still editing this
|
|
* line */
|
|
#ifdef DEBUG_EDIT
|
|
read_debug(el);
|
|
#endif /* DEBUG_EDIT */
|
|
/* if EOF or error */
|
|
if ((num = read_getcmd(el, &cmdnum, &ch)) != OKCMD) {
|
|
#ifdef DEBUG_READ
|
|
(void) fprintf(el->el_errfile,
|
|
"Returning from el_gets %d\n", num);
|
|
#endif /* DEBUG_READ */
|
|
break;
|
|
}
|
|
if (el->el_errno == EINTR) {
|
|
el->el_line.buffer[0] = '\0';
|
|
el->el_line.lastchar =
|
|
el->el_line.cursor = el->el_line.buffer;
|
|
break;
|
|
}
|
|
if ((unsigned int)cmdnum >= (unsigned int)el->el_map.nfunc) { /* BUG CHECK command */
|
|
#ifdef DEBUG_EDIT
|
|
(void) fprintf(el->el_errfile,
|
|
"ERROR: illegal command from key 0%o\r\n", ch);
|
|
#endif /* DEBUG_EDIT */
|
|
continue; /* try again */
|
|
}
|
|
/* now do the real command */
|
|
#ifdef DEBUG_READ
|
|
{
|
|
el_bindings_t *b;
|
|
for (b = el->el_map.help; b->name; b++)
|
|
if (b->func == cmdnum)
|
|
break;
|
|
if (b->name)
|
|
(void) fprintf(el->el_errfile,
|
|
"Executing %s\n", b->name);
|
|
else
|
|
(void) fprintf(el->el_errfile,
|
|
"Error command = %d\n", cmdnum);
|
|
}
|
|
#endif /* DEBUG_READ */
|
|
/* vi redo needs these way down the levels... */
|
|
el->el_state.thiscmd = cmdnum;
|
|
el->el_state.thisch = ch;
|
|
if (el->el_map.type == MAP_VI &&
|
|
el->el_map.current == el->el_map.key &&
|
|
el->el_chared.c_redo.pos < el->el_chared.c_redo.lim) {
|
|
if (cmdnum == VI_DELETE_PREV_CHAR &&
|
|
el->el_chared.c_redo.pos != el->el_chared.c_redo.buf
|
|
&& isprint((unsigned char)el->el_chared.c_redo.pos[-1]))
|
|
el->el_chared.c_redo.pos--;
|
|
else
|
|
*el->el_chared.c_redo.pos++ = ch;
|
|
}
|
|
retval = (*el->el_map.func[cmdnum]) (el, ch);
|
|
#ifdef DEBUG_READ
|
|
(void) fprintf(el->el_errfile,
|
|
"Returned state %d\n", retval );
|
|
#endif /* DEBUG_READ */
|
|
|
|
/* save the last command here */
|
|
el->el_state.lastcmd = cmdnum;
|
|
|
|
/* use any return value */
|
|
switch (retval) {
|
|
case CC_CURSOR:
|
|
re_refresh_cursor(el);
|
|
break;
|
|
|
|
case CC_REDISPLAY:
|
|
re_clear_lines(el);
|
|
re_clear_display(el);
|
|
/* FALLTHROUGH */
|
|
|
|
case CC_REFRESH:
|
|
re_refresh(el);
|
|
break;
|
|
|
|
case CC_REFRESH_BEEP:
|
|
re_refresh(el);
|
|
term_beep(el);
|
|
break;
|
|
|
|
case CC_NORM: /* normal char */
|
|
break;
|
|
|
|
case CC_ARGHACK: /* Suggested by Rich Salz */
|
|
/* <rsalz@pineapple.bbn.com> */
|
|
continue; /* keep going... */
|
|
|
|
case CC_EOF: /* end of file typed */
|
|
if ((el->el_flags & UNBUFFERED) == 0)
|
|
num = 0;
|
|
else if (num == -1) {
|
|
*el->el_line.lastchar++ = CONTROL('d');
|
|
el->el_line.cursor = el->el_line.lastchar;
|
|
num = 1;
|
|
}
|
|
break;
|
|
|
|
case CC_NEWLINE: /* normal end of line */
|
|
num = (int)(el->el_line.lastchar - el->el_line.buffer);
|
|
break;
|
|
|
|
case CC_FATAL: /* fatal error, reset to known state */
|
|
#ifdef DEBUG_READ
|
|
(void) fprintf(el->el_errfile,
|
|
"*** editor fatal ERROR ***\r\n\n");
|
|
#endif /* DEBUG_READ */
|
|
/* put (real) cursor in a known place */
|
|
re_clear_display(el); /* reset the display stuff */
|
|
ch_reset(el, 1); /* reset the input pointers */
|
|
re_refresh(el); /* print the prompt again */
|
|
break;
|
|
|
|
case CC_ERROR:
|
|
default: /* functions we don't know about */
|
|
#ifdef DEBUG_READ
|
|
(void) fprintf(el->el_errfile,
|
|
"*** editor ERROR ***\r\n\n");
|
|
#endif /* DEBUG_READ */
|
|
term_beep(el);
|
|
term__flush(el);
|
|
break;
|
|
}
|
|
el->el_state.argument = 1;
|
|
el->el_state.doingarg = 0;
|
|
el->el_chared.c_vcmd.action = NOP;
|
|
if (el->el_flags & UNBUFFERED)
|
|
break;
|
|
}
|
|
|
|
term__flush(el); /* flush any buffered output */
|
|
/* make sure the tty is set up correctly */
|
|
if ((el->el_flags & UNBUFFERED) == 0) {
|
|
read_finish(el);
|
|
*nread = num != -1 ? num : 0;
|
|
} else {
|
|
*nread = (int)(el->el_line.lastchar - el->el_line.buffer);
|
|
}
|
|
done:
|
|
if (*nread == 0) {
|
|
if (num == -1) {
|
|
*nread = -1;
|
|
errno = el->el_errno;
|
|
}
|
|
return NULL;
|
|
} else
|
|
return el->el_line.buffer;
|
|
}
|