Update to NetBSD libedit (from Oct 1, 2003), adding some string

cleaning and history bug fixes. The code includes GNU libreadline
functionality, but the corresponding header files are not installed,
since some libreadline functions are missing. There are some minor API
changes, notably:

old: EditLine *el_init(const char *, FILE *, FILE *);
new: EditLine *el_init(const char *, FILE *, FILE *, FILE *);

old: HistEvent *history(History *h, int op, ...);
new: int history(History *h, HistEvent *ev, int op, ...); plus some
changes in operation names. See editline(3) for details.

Tested by djm@, mouring@, jmc@.

ok deraadt@

1 files changed, 500 insertions, 574 deletions

diff --git a/lib/libedit/common.c b/lib/libedit/common.c
index 07318aa4c9f..35176dd75ee 100644
--- a/lib/libedit/common.c
+++ b/lib/libedit/common.c
@@ -1,5 +1,5 @@
-/*	$OpenBSD: common.c,v 1.5 2003/06/02 20:18:40 millert Exp $	*/
-/*	$NetBSD: common.c,v 1.3 1997/01/14 04:17:22 lukem Exp $	*/
+/*	$OpenBSD: common.c,v 1.6 2003/10/31 08:42:24 otto Exp $	*/
+/*	$NetBSD: common.c,v 1.16 2003/08/07 16:44:30 agc Exp $	*/
 
 /*-
  * Copyright (c) 1992, 1993
@@ -33,456 +33,411 @@
  * SUCH DAMAGE.
  */
 
+#include "config.h"
 #if !defined(lint) && !defined(SCCSID)
 #if 0
 static char sccsid[] = "@(#)common.c	8.1 (Berkeley) 6/4/93";
 #else
-static const char rcsid[] = "$OpenBSD: common.c,v 1.5 2003/06/02 20:18:40 millert Exp $";
+static const char rcsid[] = "$OpenBSD: common.c,v 1.6 2003/10/31 08:42:24 otto Exp $";
 #endif
 #endif /* not lint && not SCCSID */
 
 /*
  * common.c: Common Editor functions
  */
-#include "sys.h"
 #include "el.h"
 
-/* ed_end_of_file(): 
+/* ed_end_of_file():
  *	Indicate end of file
  *	[^D]
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_end_of_file(el, c)
-    EditLine *el;
-    int c;
+ed_end_of_file(EditLine *el, int c __attribute__((__unused__)))
 {
-    re_goto_bottom(el);
-    *el->el_line.lastchar = '\0';
-    return CC_EOF;
+
+	re_goto_bottom(el);
+	*el->el_line.lastchar = '\0';
+	return (CC_EOF);
 }
 
 
-/* ed_insert(): 
+/* ed_insert():
  *	Add character to the line
  *	Insert a character [bound to all insert keys]
  */
 protected el_action_t
-ed_insert(el, c)
-    EditLine *el;
-    int c;
+ed_insert(EditLine *el, int c)
 {
-    int i;
-
-    if (c == '\0')
-	return CC_ERROR;
-
-    if (el->el_line.lastchar + el->el_state.argument >= 
-	el->el_line.limit)
-	return CC_ERROR;	/* end of buffer space */
+	int count = el->el_state.argument;
 
-    if (el->el_state.argument == 1) {
-	if (el->el_state.inputmode != MODE_INSERT) {
-	    el->el_chared.c_undo.buf[el->el_chared.c_undo.isize++] = 
-		*el->el_line.cursor;
-	    el->el_chared.c_undo.buf[el->el_chared.c_undo.isize] = '\0';
-	    c_delafter(el, 1);   
-    	}
+	if (c == '\0')
+		return (CC_ERROR);
 
-        c_insert(el, 1);
-
-	*el->el_line.cursor++ = c;
-	el->el_state.doingarg = 0;		/* just in case */
-	re_fastaddc(el);			/* fast refresh for one char. */
-    }
-    else {
-	if (el->el_state.inputmode != MODE_INSERT) {
-
-	    for(i = 0;i < el->el_state.argument; i++) 
-		el->el_chared.c_undo.buf[el->el_chared.c_undo.isize++] = 
-			el->el_line.cursor[i];
+	if (el->el_line.lastchar + el->el_state.argument >=
+	    el->el_line.limit) {
+		/* end of buffer space, try to allocate more */
+		if (!ch_enlargebufs(el, (size_t) count))
+			return CC_ERROR;	/* error allocating more */
+	}
 
-	    el->el_chared.c_undo.buf[el->el_chared.c_undo.isize] = '\0';
-	    c_delafter(el, el->el_state.argument);   
-    	}
+	if (count == 1) {
+		if (el->el_state.inputmode == MODE_INSERT
+		    || el->el_line.cursor >= el->el_line.lastchar)
+			c_insert(el, 1);
 
-        c_insert(el, el->el_state.argument);
+		*el->el_line.cursor++ = c;
+		re_fastaddc(el);		/* fast refresh for one char. */
+	} else {
+		if (el->el_state.inputmode != MODE_REPLACE_1)
+			c_insert(el, el->el_state.argument);
 
-	while (el->el_state.argument--)
-	    *el->el_line.cursor++ = c;
-	re_refresh(el);
-    }
+		while (count-- && el->el_line.cursor < el->el_line.lastchar)
+			*el->el_line.cursor++ = c;
+		re_refresh(el);
+	}
 
-    if (el->el_state.inputmode == MODE_REPLACE_1)
-	(void)vi_command_mode(el, 0);
+	if (el->el_state.inputmode == MODE_REPLACE_1)
+		return vi_command_mode(el, 0);
 
-    return CC_NORM;
+	return (CC_NORM);
 }
 
 
-/* ed_delete_prev_word(): 
+/* ed_delete_prev_word():
  *	Delete from beginning of current word to cursor
  *	[M-^?] [^W]
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_delete_prev_word(el, c)
-    EditLine *el;
-    int c;
+ed_delete_prev_word(EditLine *el, int c __attribute__((__unused__)))
 {
-    char *cp, *p, *kp;
+	char *cp, *p, *kp;
 
-    if (el->el_line.cursor == el->el_line.buffer)
-	return CC_ERROR;
+	if (el->el_line.cursor == el->el_line.buffer)
+		return (CC_ERROR);
 
-    cp = c__prev_word(el->el_line.cursor, el->el_line.buffer, 
-		      el->el_state.argument, ce__isword);
+	cp = c__prev_word(el->el_line.cursor, el->el_line.buffer,
+	    el->el_state.argument, ce__isword);
 
-    for (p = cp, kp = el->el_chared.c_kill.buf; p < el->el_line.cursor; p++)
-	*kp++ = *p;
-    el->el_chared.c_kill.last = kp;
+	for (p = cp, kp = el->el_chared.c_kill.buf; p < el->el_line.cursor; p++)
+		*kp++ = *p;
+	el->el_chared.c_kill.last = kp;
 
-    c_delbefore(el, el->el_line.cursor - cp);	/* delete before dot */
-    el->el_line.cursor = cp;
-    if (el->el_line.cursor < el->el_line.buffer)
-	el->el_line.cursor = el->el_line.buffer;	/* bounds check */
-    return CC_REFRESH;
+	c_delbefore(el, el->el_line.cursor - cp);	/* delete before dot */
+	el->el_line.cursor = cp;
+	if (el->el_line.cursor < el->el_line.buffer)
+		el->el_line.cursor = el->el_line.buffer; /* bounds check */
+	return (CC_REFRESH);
 }
 
 
-/* ed_delete_next_char(): 
+/* ed_delete_next_char():
  *	Delete character under cursor
  *	[^D] [x]
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_delete_next_char(el, c)
-    EditLine *el;
-    int c;
-{
-#ifdef notdef /* XXX */
-#define EL el->el_line
-fprintf(stderr, "\nD(b: %x(%s)  c: %x(%s) last: %x(%s) limit: %x(%s)\n", 
-	EL.buffer, EL.buffer, EL.cursor, EL.cursor, EL.lastchar, EL.lastchar, EL.limit, EL.limit);
+ed_delete_next_char(EditLine *el, int c __attribute__((__unused__)))
+{
+#ifdef notdef			/* XXX */
+#define	EL	el->el_line
+	(void) fprintf(el->el_errlfile,
+	    "\nD(b: %x(%s)  c: %x(%s) last: %x(%s) limit: %x(%s)\n",
+	    EL.buffer, EL.buffer, EL.cursor, EL.cursor, EL.lastchar,
+	    EL.lastchar, EL.limit, EL.limit);
 #endif
-    if (el->el_line.cursor == el->el_line.lastchar) {/* if I'm at the end */
-	if (el->el_map.type == MAP_VI) {
-	    if (el->el_line.cursor == el->el_line.buffer) {	
-		/* if I'm also at the beginning */
+	if (el->el_line.cursor == el->el_line.lastchar) {
+			/* if I'm at the end */
+		if (el->el_map.type == MAP_VI) {
+			if (el->el_line.cursor == el->el_line.buffer) {
+				/* if I'm also at the beginning */
 #ifdef KSHVI
-		return CC_ERROR;
+				return (CC_ERROR);
 #else
-		term_overwrite(el, STReof, 4);/* then do a EOF */
-		term__flush();
-		return CC_EOF;
+				term_overwrite(el, STReof, 4);
+					/* then do a EOF */
+				term__flush();
+				return (CC_EOF);
 #endif
-	    }
-	    else  {
+			} else {
 #ifdef KSHVI
-		el->el_line.cursor--;
+				el->el_line.cursor--;
 #else
-		return CC_ERROR;
+				return (CC_ERROR);
 #endif
-	    }
-	}
-	else {
-	    if (el->el_line.cursor != el->el_line.buffer)
-		el->el_line.cursor--;
-	    else
-		return CC_ERROR;
+			}
+		} else {
+			if (el->el_line.cursor != el->el_line.buffer)
+				el->el_line.cursor--;
+			else
+				return (CC_ERROR);
+		}
 	}
-    }
-    c_delafter(el, el->el_state.argument);	/* delete after dot */
-    if (el->el_line.cursor >= el->el_line.lastchar && el->el_line.cursor > el->el_line.buffer)
-	el->el_line.cursor = el->el_line.lastchar - 1;	/* bounds check */
-    return CC_REFRESH;
+	c_delafter(el, el->el_state.argument);	/* delete after dot */
+	if (el->el_line.cursor >= el->el_line.lastchar &&
+	    el->el_line.cursor > el->el_line.buffer)
+			/* bounds check */
+		el->el_line.cursor = el->el_line.lastchar - 1;
+	return (CC_REFRESH);
 }
 
 
-/* ed_kill_line(): 
+/* ed_kill_line():
  *	Cut to the end of line
  *	[^K] [^K]
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_kill_line(el, c)
-    EditLine *el;
-    int c;
+ed_kill_line(EditLine *el, int c __attribute__((__unused__)))
 {
-    char *kp, *cp;
+	char *kp, *cp;
 
-    cp = el->el_line.cursor;
-    kp = el->el_chared.c_kill.buf;
-    while (cp < el->el_line.lastchar)
-	*kp++ = *cp++;		/* copy it */
-    el->el_chared.c_kill.last = kp;
-    el->el_line.lastchar = el->el_line.cursor; /* zap! -- delete to end */
-    return CC_REFRESH;
+	cp = el->el_line.cursor;
+	kp = el->el_chared.c_kill.buf;
+	while (cp < el->el_line.lastchar)
+		*kp++ = *cp++;	/* copy it */
+	el->el_chared.c_kill.last = kp;
+			/* zap! -- delete to end */
+	el->el_line.lastchar = el->el_line.cursor;
+	return (CC_REFRESH);
 }
 
 
-/* ed_move_to_end(): 
+/* ed_move_to_end():
  *	Move cursor to the end of line
  *	[^E] [^E]
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_move_to_end(el, c)
-    EditLine *el;
-    int c;
+ed_move_to_end(EditLine *el, int c __attribute__((__unused__)))
 {
-    el->el_line.cursor = el->el_line.lastchar;
-    if (el->el_map.type == MAP_VI) {
+
+	el->el_line.cursor = el->el_line.lastchar;
+	if (el->el_map.type == MAP_VI) {
 #ifdef VI_MOVE
-	el->el_line.cursor--;
+		el->el_line.cursor--;
 #endif
-	if (el->el_chared.c_vcmd.action & DELETE) {
-	    cv_delfini(el);
-	    return CC_REFRESH;
+		if (el->el_chared.c_vcmd.action != NOP) {
+			cv_delfini(el);
+			return (CC_REFRESH);
+		}
 	}
-    }
-    return CC_CURSOR;
+	return (CC_CURSOR);
 }
 
 
-/* ed_move_to_beg(): 
+/* ed_move_to_beg():
  *	Move cursor to the beginning of line
  *	[^A] [^A]
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_move_to_beg(el, c)
-    EditLine *el;
-    int c;
-{
-    el->el_line.cursor = el->el_line.buffer;
-
-    if (el->el_map.type == MAP_VI) {
-        /* We want FIRST non space character */
-        while (isspace(*el->el_line.cursor)) 
-	    el->el_line.cursor++;
-	if (el->el_chared.c_vcmd.action & DELETE) {
-	    cv_delfini(el);
-	    return CC_REFRESH;
-	}
-    }
+ed_move_to_beg(EditLine *el, int c __attribute__((__unused__)))
+{
 
-    return CC_CURSOR;
+	el->el_line.cursor = el->el_line.buffer;
+
+	if (el->el_map.type == MAP_VI) {
+			/* We want FIRST non space character */
+		while (isspace((unsigned char) *el->el_line.cursor))
+			el->el_line.cursor++;
+		if (el->el_chared.c_vcmd.action != NOP) {
+			cv_delfini(el);
+			return (CC_REFRESH);
+		}
+	}
+	return (CC_CURSOR);
 }
 
 
-/* ed_transpose_chars(): 
+/* ed_transpose_chars():
  *	Exchange the character to the left of the cursor with the one under it
  *	[^T] [^T]
  */
 protected el_action_t
-ed_transpose_chars(el, c)
-    EditLine *el;
-    int c;
-{
-    if (el->el_line.cursor < el->el_line.lastchar) {
-	if (el->el_line.lastchar <= &el->el_line.buffer[1])
-	    return CC_ERROR;
-	else 
-	    el->el_line.cursor++;
-    }
-    if (el->el_line.cursor > &el->el_line.buffer[1]) {
-	/* must have at least two chars entered */
-	c = el->el_line.cursor[-2];
-	el->el_line.cursor[-2] = el->el_line.cursor[-1];
-	el->el_line.cursor[-1] = c;
-	return CC_REFRESH;
-    }
-    else 
-	return CC_ERROR;
+ed_transpose_chars(EditLine *el, int c)
+{
+
+	if (el->el_line.cursor < el->el_line.lastchar) {
+		if (el->el_line.lastchar <= &el->el_line.buffer[1])
+			return (CC_ERROR);
+		else
+			el->el_line.cursor++;
+	}
+	if (el->el_line.cursor > &el->el_line.buffer[1]) {
+		/* must have at least two chars entered */
+		c = el->el_line.cursor[-2];
+		el->el_line.cursor[-2] = el->el_line.cursor[-1];
+		el->el_line.cursor[-1] = c;
+		return (CC_REFRESH);
+	} else
+		return (CC_ERROR);
 }
 
 
-/* ed_next_char(): 
+/* ed_next_char():
  *	Move to the right one character
  *	[^F] [^F]
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_next_char(el, c)
-    EditLine *el;
-    int c;
+ed_next_char(EditLine *el, int c __attribute__((__unused__)))
 {
-    if (el->el_line.cursor >= el->el_line.lastchar)
-	return CC_ERROR;
+	char *lim = el->el_line.lastchar;
 
-    el->el_line.cursor += el->el_state.argument;
-    if (el->el_line.cursor > el->el_line.lastchar)
-	el->el_line.cursor = el->el_line.lastchar;
+	if (el->el_line.cursor >= lim ||
+	    (el->el_line.cursor == lim - 1 &&
+	    el->el_map.type == MAP_VI &&
+	    el->el_chared.c_vcmd.action == NOP))
+		return (CC_ERROR);
 
-    if (el->el_map.type == MAP_VI)
-	if (el->el_chared.c_vcmd.action & DELETE) {
-	    cv_delfini(el);
-	    return CC_REFRESH;
-	}
+	el->el_line.cursor += el->el_state.argument;
+	if (el->el_line.cursor > lim)
+		el->el_line.cursor = lim;
 
-    return CC_CURSOR;
+	if (el->el_map.type == MAP_VI)
+		if (el->el_chared.c_vcmd.action != NOP) {
+			cv_delfini(el);
+			return (CC_REFRESH);
+		}
+	return (CC_CURSOR);
 }
 
 
-/* ed_prev_word(): 
+/* ed_prev_word():
  *	Move to the beginning of the current word
  *	[M-b] [b]
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_prev_word(el, c)
-    EditLine *el;
-    int c;
+ed_prev_word(EditLine *el, int c __attribute__((__unused__)))
 {
-    if (el->el_line.cursor == el->el_line.buffer)
-	return CC_ERROR;
 
-    el->el_line.cursor = c__prev_word(el->el_line.cursor, el->el_line.buffer, 
-				      el->el_state.argument, 
-				      ce__isword);
+	if (el->el_line.cursor == el->el_line.buffer)
+		return (CC_ERROR);
 
-    if (el->el_map.type == MAP_VI)
-	if (el->el_chared.c_vcmd.action & DELETE) {
-	    cv_delfini(el);
-	    return CC_REFRESH;
-	}
+	el->el_line.cursor = c__prev_word(el->el_line.cursor,
+	    el->el_line.buffer,
+	    el->el_state.argument,
+	    ce__isword);
 
-    return CC_CURSOR;
+	if (el->el_map.type == MAP_VI)
+		if (el->el_chared.c_vcmd.action != NOP) {
+			cv_delfini(el);
+			return (CC_REFRESH);
+		}
+	return (CC_CURSOR);
 }
 
 
-/* ed_prev_char(): 
+/* ed_prev_char():
  *	Move to the left one character
  *	[^B] [^B]
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_prev_char(el, c)
-    EditLine *el;
-    int c;
+ed_prev_char(EditLine *el, int c __attribute__((__unused__)))
 {
-    if (el->el_line.cursor > el->el_line.buffer) {
-	el->el_line.cursor -= el->el_state.argument;
-	if (el->el_line.cursor < el->el_line.buffer)
-	    el->el_line.cursor = el->el_line.buffer;
 
-	if (el->el_map.type == MAP_VI)
-	    if (el->el_chared.c_vcmd.action & DELETE) {
-		cv_delfini(el);
-		return CC_REFRESH;
-	    }
+	if (el->el_line.cursor > el->el_line.buffer) {
+		el->el_line.cursor -= el->el_state.argument;
+		if (el->el_line.cursor < el->el_line.buffer)
+			el->el_line.cursor = el->el_line.buffer;
 
-	return CC_CURSOR;
-    }
-    else 
-	return CC_ERROR;
+		if (el->el_map.type == MAP_VI)
+			if (el->el_chared.c_vcmd.action != NOP) {
+				cv_delfini(el);
+				return (CC_REFRESH);
+			}
+		return (CC_CURSOR);
+	} else
+		return (CC_ERROR);
 }
 
 
-/* ed_quoted_insert(): 
+/* ed_quoted_insert():
  *	Add the next character typed verbatim
  *	[^V] [^V]
  */
 protected el_action_t
-ed_quoted_insert(el, c)
-    EditLine *el;
-    int c;
+ed_quoted_insert(EditLine *el, int c)
 {
-    int     num;
-    char    tc;
+	int num;
+	char tc;
 
-    tty_quotemode(el);
-    num = el_getc(el, &tc);
-    c = (unsigned char) tc;
-    tty_noquotemode(el);
-    if (num == 1)
-	return ed_insert(el, c);
-    else
-	return ed_end_of_file(el, 0);
+	tty_quotemode(el);
+	num = el_getc(el, &tc);
+	c = (unsigned char) tc;
+	tty_noquotemode(el);
+	if (num == 1)
+		return (ed_insert(el, c));
+	else
+		return (ed_end_of_file(el, 0));
 }
 
 
-/* ed_digit(): 
+/* ed_digit():
  *	Adds to argument or enters a digit
  */
 protected el_action_t
-ed_digit(el, c)
-    EditLine *el;
-    int c;
+ed_digit(EditLine *el, int c)
 {
-    if (!isdigit(c))
-	return CC_ERROR;
 
-    if (el->el_state.doingarg) {	
-	/* if doing an arg, add this in... */
-	if (el->el_state.lastcmd == EM_UNIVERSAL_ARGUMENT)	
-	    el->el_state.argument = c - '0';
-	else {
-	    if (el->el_state.argument > 1000000)
-		return CC_ERROR;
-	    el->el_state.argument = 
-		(el->el_state.argument * 10) + (c - '0');
+	if (!isdigit(c))
+		return (CC_ERROR);
+
+	if (el->el_state.doingarg) {
+			/* if doing an arg, add this in... */
+		if (el->el_state.lastcmd == EM_UNIVERSAL_ARGUMENT)
+			el->el_state.argument = c - '0';
+		else {
+			if (el->el_state.argument > 1000000)
+				return (CC_ERROR);
+			el->el_state.argument =
+			    (el->el_state.argument * 10) + (c - '0');
+		}
+		return (CC_ARGHACK);
 	}
-	return CC_ARGHACK;
-    }
-    else {
-	if (el->el_line.lastchar + 1 >= el->el_line.limit)
-	    return CC_ERROR;
-
-	if (el->el_state.inputmode != MODE_INSERT) {
-	    el->el_chared.c_undo.buf[el->el_chared.c_undo.isize++] = 
-		*el->el_line.cursor;
-	    el->el_chared.c_undo.buf[el->el_chared.c_undo.isize] = '\0';
-	    c_delafter(el, 1);  
-    	}
-	c_insert(el, 1);
-	*el->el_line.cursor++ = c;
-	el->el_state.doingarg = 0;
-	re_fastaddc(el);
-    }
-    return CC_NORM;
-}
-
-
-/* ed_argument_digit(): 
+
+	return ed_insert(el, c);
+}
+
+
+/* ed_argument_digit():
  *	Digit that starts argument
  *	For ESC-n
  */
 protected el_action_t
-ed_argument_digit(el, c)
-    EditLine *el;
-    register int c;
+ed_argument_digit(EditLine *el, int c)
 {
-    if (!isdigit(c))
-	return CC_ERROR;
 
-    if (el->el_state.doingarg) {
-	if (el->el_state.argument > 1000000)
-	    return CC_ERROR;
-	el->el_state.argument = (el->el_state.argument * 10) + (c - '0');
-    }
-    else {			/* else starting an argument */
-	el->el_state.argument = c - '0';
-	el->el_state.doingarg = 1;
-    }
-    return CC_ARGHACK;
+	if (!isdigit(c))
+		return (CC_ERROR);
+
+	if (el->el_state.doingarg) {
+		if (el->el_state.argument > 1000000)
+			return (CC_ERROR);
+		el->el_state.argument = (el->el_state.argument * 10) +
+		    (c - '0');
+	} else {		/* else starting an argument */
+		el->el_state.argument = c - '0';
+		el->el_state.doingarg = 1;
+	}
+	return (CC_ARGHACK);
 }
 
 
-/* ed_unassigned(): 
+/* ed_unassigned():
  *	Indicates unbound character
  *	Bound to keys that are not assigned
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_unassigned(el, c)
-    EditLine *el;
-    int c;
+ed_unassigned(EditLine *el, int c __attribute__((__unused__)))
 {
-    term_beep(el);
-    term__flush();
-    return CC_NORM;
+
+	return (CC_ERROR);
 }
 
 
@@ -490,392 +445,381 @@ ed_unassigned(el, c)
  ** TTY key handling.
  **/
 
-/* ed_tty_sigint(): 
+/* ed_tty_sigint():
  *	Tty interrupt character
  *	[^C]
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_tty_sigint(el, c)
-    EditLine *el;
-    int c;
-{			
-    return CC_NORM;
+ed_tty_sigint(EditLine *el __attribute__((__unused__)), 
+	      int c __attribute__((__unused__)))
+{
+
+	return (CC_NORM);
 }
 
 
-/* ed_tty_dsusp(): 
+/* ed_tty_dsusp():
  *	Tty delayed suspend character
  *	[^Y]
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_tty_dsusp(el, c)
-    EditLine *el;
-    int c;
+ed_tty_dsusp(EditLine *el __attribute__((__unused__)), 
+	     int c __attribute__((__unused__)))
 {
-    return CC_NORM;
+
+	return (CC_NORM);
 }
 
 
-/* ed_tty_flush_output(): 
+/* ed_tty_flush_output():
  *	Tty flush output characters
  *	[^O]
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_tty_flush_output(el, c)
-    EditLine *el;
-    int c;
+ed_tty_flush_output(EditLine *el __attribute__((__unused__)), 
+		    int c __attribute__((__unused__)))
 {
-    return CC_NORM;
+
+	return (CC_NORM);
 }
 
 
-/* ed_tty_sigquit(): 
+/* ed_tty_sigquit():
  *	Tty quit character
  *	[^\]
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_tty_sigquit(el, c)
-    EditLine *el;
-    int c;
+ed_tty_sigquit(EditLine *el __attribute__((__unused__)), 
+	       int c __attribute__((__unused__)))
 {
-    return CC_NORM;
+
+	return (CC_NORM);
 }
 
 
-/* ed_tty_sigtstp(): 
+/* ed_tty_sigtstp():
  *	Tty suspend character
  *	[^Z]
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_tty_sigtstp(el, c)
-    EditLine *el;
-    int c;
+ed_tty_sigtstp(EditLine *el __attribute__((__unused__)), 
+	       int c __attribute__((__unused__)))
 {
-    return CC_NORM;
+
+	return (CC_NORM);
 }
 
 
-/* ed_tty_stop_output(): 
+/* ed_tty_stop_output():
  *	Tty disallow output characters
  *	[^S]
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_tty_stop_output(el, c)
-    EditLine *el;
-    int c;
+ed_tty_stop_output(EditLine *el __attribute__((__unused__)), 
+		   int c __attribute__((__unused__)))
 {
-    return CC_NORM;
+
+	return (CC_NORM);
 }
 
 
-/* ed_tty_start_output(): 
+/* ed_tty_start_output():
  *	Tty allow output characters
  *	[^Q]
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_tty_start_output(el, c)
-    EditLine *el;
-    int c;
+ed_tty_start_output(EditLine *el __attribute__((__unused__)), 
+		    int c __attribute__((__unused__)))
 {
-    return CC_NORM;
+
+	return (CC_NORM);
 }
 
 
-/* ed_newline(): 
+/* ed_newline():
  *	Execute command
  *	[^J]
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_newline(el, c)
-    EditLine *el;
-    int c;
+ed_newline(EditLine *el, int c __attribute__((__unused__)))
 {
-    re_goto_bottom(el);
-    *el->el_line.lastchar++ = '\n';
-    *el->el_line.lastchar = '\0';
-    if (el->el_map.type == MAP_VI)
-	el->el_chared.c_vcmd.ins = el->el_line.buffer;
-    return CC_NEWLINE;
+
+	re_goto_bottom(el);
+	*el->el_line.lastchar++ = '\n';
+	*el->el_line.lastchar = '\0';
+	return (CC_NEWLINE);
 }
 
 
-/* ed_delete_prev_char(): 
+/* ed_delete_prev_char():
  *	Delete the character to the left of the cursor
  *	[^?]
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_delete_prev_char(el, c)
-    EditLine *el;
-    int c;
+ed_delete_prev_char(EditLine *el, int c __attribute__((__unused__)))
 {
-    if (el->el_line.cursor <= el->el_line.buffer) 
-	return CC_ERROR;
 
-    c_delbefore(el, el->el_state.argument);	
-    el->el_line.cursor -= el->el_state.argument;
-    if (el->el_line.cursor < el->el_line.buffer)
-	el->el_line.cursor = el->el_line.buffer;
-    return CC_REFRESH;
+	if (el->el_line.cursor <= el->el_line.buffer)
+		return (CC_ERROR);
+
+	c_delbefore(el, el->el_state.argument);
+	el->el_line.cursor -= el->el_state.argument;
+	if (el->el_line.cursor < el->el_line.buffer)
+		el->el_line.cursor = el->el_line.buffer;
+	return (CC_REFRESH);
 }
 
 
-/* ed_clear_screen(): 
+/* ed_clear_screen():
  *	Clear screen leaving current line at the top
  *	[^L]
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_clear_screen(el, c)
-    EditLine *el;
-    int c;
+ed_clear_screen(EditLine *el, int c __attribute__((__unused__)))
 {
-    term_clear_screen(el);	/* clear the whole real screen */
-    re_clear_display(el);		/* reset everything */
-    return CC_REFRESH;
+
+	term_clear_screen(el);	/* clear the whole real screen */
+	re_clear_display(el);	/* reset everything */
+	return (CC_REFRESH);
 }
 
 
-/* ed_redisplay(): 
+/* ed_redisplay():
  *	Redisplay everything
  *	^R
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_redisplay(el, c)
-    EditLine *el;
-    int c;
+ed_redisplay(EditLine *el __attribute__((__unused__)), 
+	     int c __attribute__((__unused__)))
 {
-    return CC_REDISPLAY;
+
+	return (CC_REDISPLAY);
 }
 
 
-/* ed_start_over(): 
+/* ed_start_over():
  *	Erase current line and start from scratch
  *	[^G]
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_start_over(el, c)
-    EditLine *el;
-    int c;
+ed_start_over(EditLine *el, int c __attribute__((__unused__)))
 {
-    ch_reset(el);
-    return CC_REFRESH;
+
+	ch_reset(el);
+	return (CC_REFRESH);
 }
 
 
-/* ed_sequence_lead_in(): 
+/* ed_sequence_lead_in():
  *	First character in a bound sequence
  *	Placeholder for external keys
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_sequence_lead_in(el, c)
-    EditLine *el;
-    int c;
+ed_sequence_lead_in(EditLine *el __attribute__((__unused__)), 
+		    int c __attribute__((__unused__)))
 {
-    return CC_NORM;
+
+	return (CC_NORM);
 }
 
 
-/* ed_prev_history(): 
+/* ed_prev_history():
  *	Move to the previous history line
  *	[^P] [k]
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_prev_history(el, c)
-    EditLine *el;
-    int c;
+ed_prev_history(EditLine *el, int c __attribute__((__unused__)))
 {
-    char    beep = 0;
-
-    el->el_chared.c_undo.action = NOP;
-    *el->el_line.lastchar = '\0';		/* just in case */
-
-    if (el->el_history.eventno == 0) {	/* save the current buffer away */
-	(void)strncpy(el->el_history.buf, el->el_line.buffer, EL_BUFSIZ - 1);
-	el->el_history.buf[EL_BUFSIZ - 1] = '\0';
-	el->el_history.last = el->el_history.buf + 
-		(el->el_line.lastchar - el->el_line.buffer);
-    }
-
-    el->el_history.eventno += el->el_state.argument;
+	char beep = 0;
+	int sv_event = el->el_history.eventno;
 
-    if (hist_get(el) == CC_ERROR) {
-	beep = 1;
-	/* el->el_history.eventno was fixed by first call */
-	(void)hist_get(el); 
-    }
+	el->el_chared.c_undo.len = -1;
+	*el->el_line.lastchar = '\0';		/* just in case */
 
-    re_refresh(el);
-    if (beep)
-	return CC_ERROR;
-    else
-	return CC_NORM;	/* was CC_UP_HIST */
+	if (el->el_history.eventno == 0) {	/* save the current buffer
+						 * away */
+		(void) strncpy(el->el_history.buf, el->el_line.buffer,
+		    EL_BUFSIZ);
+		el->el_history.last = el->el_history.buf +
+		    (el->el_line.lastchar - el->el_line.buffer);
+	}
+	el->el_history.eventno += el->el_state.argument;
+
+	if (hist_get(el) == CC_ERROR) {
+		if (el->el_map.type == MAP_VI) {
+			el->el_history.eventno = sv_event;
+			return CC_ERROR;
+		}
+		beep = 1;
+		/* el->el_history.eventno was fixed by first call */
+		(void) hist_get(el);
+	}
+	if (beep)
+		return CC_REFRESH_BEEP;
+	return CC_REFRESH;
 }
 
 
-/* ed_next_history(): 
+/* ed_next_history():
  *	Move to the next history line
  *	[^N] [j]
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_next_history(el, c)
-    EditLine *el;
-    int c;
+ed_next_history(EditLine *el, int c __attribute__((__unused__)))
 {
-    el->el_chared.c_undo.action = NOP;
-    *el->el_line.lastchar = '\0';		/* just in case */
+	el_action_t beep = CC_REFRESH, rval;
 
-    el->el_history.eventno -= el->el_state.argument;
+	el->el_chared.c_undo.len = -1;
+	*el->el_line.lastchar = '\0';	/* just in case */
 
-    if (el->el_history.eventno < 0) {
-	el->el_history.eventno = 0;
-	return CC_ERROR;	/* make it beep */
-    }
+	el->el_history.eventno -= el->el_state.argument;
+
+	if (el->el_history.eventno < 0) {
+		el->el_history.eventno = 0;
+		beep = CC_REFRESH_BEEP;
+	}
+	rval = hist_get(el);
+	if (rval == CC_REFRESH)
+		return beep;
+	return rval;
 
-    return hist_get(el);
 }
 
 
-/* ed_search_prev_history(): 
+/* ed_search_prev_history():
  *	Search previous in history for a line matching the current
  *	next search history [M-P] [K]
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_search_prev_history(el, c)
-    EditLine *el;
-    int c;
-{
-    const char *hp;
-    int h;
-    bool_t    found = 0;
-
-    el->el_chared.c_vcmd.action = NOP;
-    el->el_chared.c_undo.action = NOP;
-    *el->el_line.lastchar = '\0';		/* just in case */
-    if (el->el_history.eventno < 0) {
+ed_search_prev_history(EditLine *el, int c __attribute__((__unused__)))
+{
+	const char *hp;
+	int h;
+	bool_t found = 0;
+
+	el->el_chared.c_vcmd.action = NOP;
+	el->el_chared.c_undo.len = -1;
+	*el->el_line.lastchar = '\0';	/* just in case */
+	if (el->el_history.eventno < 0) {
 #ifdef DEBUG_EDIT
-	(void)fprintf(el->el_errfile, "e_prev_search_hist(): eventno < 0;\n");
+		(void) fprintf(el->el_errfile,
+		    "e_prev_search_hist(): eventno < 0;\n");
 #endif
-	el->el_history.eventno = 0;
-	return CC_ERROR;
-    }
-
-    if (el->el_history.eventno == 0) {
-	(void)strncpy(el->el_history.buf, el->el_line.buffer, EL_BUFSIZ - 1);
-	el->el_history.buf[EL_BUFSIZ - 1] = '\0';
-	el->el_history.last = el->el_history.buf + 
-		(el->el_line.lastchar - el->el_line.buffer);
-    }
-
-
-    if (el->el_history.ref == NULL)
-	return CC_ERROR;
+		el->el_history.eventno = 0;
+		return (CC_ERROR);
+	}
+	if (el->el_history.eventno == 0) {
+		(void) strncpy(el->el_history.buf, el->el_line.buffer,
+		    EL_BUFSIZ);
+		el->el_history.last = el->el_history.buf +
+		    (el->el_line.lastchar - el->el_line.buffer);
+	}
+	if (el->el_history.ref == NULL)
+		return (CC_ERROR);
 
-    hp = HIST_FIRST(el);
-    if (hp == NULL)
-	return CC_ERROR;
+	hp = HIST_FIRST(el);
+	if (hp == NULL)
+		return (CC_ERROR);
 
-    c_setpat(el);		/* Set search pattern !! */
+	c_setpat(el);		/* Set search pattern !! */
 
-    for (h = 1; h <= el->el_history.eventno; h++)
-	hp = HIST_NEXT(el);
+	for (h = 1; h <= el->el_history.eventno; h++)
+		hp = HIST_NEXT(el);
 
-    while (hp != NULL) {
+	while (hp != NULL) {
 #ifdef SDEBUG
-	(void)fprintf(el->el_errfile, "Comparing with \"%s\"\n", hp);
+		(void) fprintf(el->el_errfile, "Comparing with \"%s\"\n", hp);
 #endif
-	if ((strncmp(hp, el->el_line.buffer, 
-		     el->el_line.lastchar - el->el_line.buffer) || 
-	    hp[el->el_line.lastchar-el->el_line.buffer]) && 
-	    c_hmatch(el, hp)) {
-	    found++;
-	    break;
+		if ((strncmp(hp, el->el_line.buffer, (size_t)
+			    (el->el_line.lastchar - el->el_line.buffer)) ||
+			hp[el->el_line.lastchar - el->el_line.buffer]) &&
+		    c_hmatch(el, hp)) {
+			found++;
+			break;
+		}
+		h++;
+		hp = HIST_NEXT(el);
 	}
-	h++;
-	hp = HIST_NEXT(el);
-    }
 
-    if (!found) {
+	if (!found) {
 #ifdef SDEBUG
-	(void)fprintf(el->el_errfile, "not found\n"); 
+		(void) fprintf(el->el_errfile, "not found\n");
 #endif
-	return CC_ERROR;
-    }
-
-    el->el_history.eventno = h;
+		return (CC_ERROR);
+	}
+	el->el_history.eventno = h;
 
-    return hist_get(el);
+	return (hist_get(el));
 }
 
 
-/* ed_search_next_history(): 
+/* ed_search_next_history():
  *	Search next in history for a line matching the current
  *	[M-N] [J]
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_search_next_history(el, c)
-    EditLine *el;
-    int c;
+ed_search_next_history(EditLine *el, int c __attribute__((__unused__)))
 {
-    const char *hp;
-    int h;
-    bool_t    found = 0;
+	const char *hp;
+	int h;
+	bool_t found = 0;
 
-    el->el_chared.c_vcmd.action = NOP;
-    el->el_chared.c_undo.action = NOP;
-    *el->el_line.lastchar = '\0';		/* just in case */
+	el->el_chared.c_vcmd.action = NOP;
+	el->el_chared.c_undo.len = -1;
+	*el->el_line.lastchar = '\0';	/* just in case */
 
-    if (el->el_history.eventno == 0)
-	return CC_ERROR;
+	if (el->el_history.eventno == 0)
+		return (CC_ERROR);
 
-    if (el->el_history.ref == NULL)
-	return CC_ERROR;
+	if (el->el_history.ref == NULL)
+		return (CC_ERROR);
 
-    hp = HIST_FIRST(el);
-    if (hp == NULL)
-	return CC_ERROR;
+	hp = HIST_FIRST(el);
+	if (hp == NULL)
+		return (CC_ERROR);
 
-    c_setpat(el);		/* Set search pattern !! */
+	c_setpat(el);		/* Set search pattern !! */
 
-    for (h = 1; h < el->el_history.eventno && hp; h++) {
+	for (h = 1; h < el->el_history.eventno && hp; h++) {
 #ifdef SDEBUG
-	(void)fprintf(el->el_errfile, "Comparing with \"%s\"\n", hp);
+		(void) fprintf(el->el_errfile, "Comparing with \"%s\"\n", hp);
 #endif
-	if ((strncmp(hp, el->el_line.buffer, 
-		     el->el_line.lastchar - el->el_line.buffer) || 
-	     hp[el->el_line.lastchar-el->el_line.buffer]) && 
-	    c_hmatch(el, hp))
-	    found = h;
-	hp = HIST_NEXT(el);
-    }
-
-    if (!found) {		/* is it the current history number? */
-	if (!c_hmatch(el, el->el_history.buf)) {
+		if ((strncmp(hp, el->el_line.buffer, (size_t)
+			    (el->el_line.lastchar - el->el_line.buffer)) ||
+			hp[el->el_line.lastchar - el->el_line.buffer]) &&
+		    c_hmatch(el, hp))
+			found = h;
+		hp = HIST_NEXT(el);
+	}
+
+	if (!found) {		/* is it the current history number? */
+		if (!c_hmatch(el, el->el_history.buf)) {
 #ifdef SDEBUG
-	    (void)fprintf(el->el_errfile, "not found\n"); 
+			(void) fprintf(el->el_errfile, "not found\n");
 #endif
-	    return CC_ERROR;
+			return (CC_ERROR);
+		}
 	}
-    }
+	el->el_history.eventno = found;
 
-    el->el_history.eventno = found;
-
-    return hist_get(el);
+	return (hist_get(el));
 }
 
 
@@ -885,42 +829,40 @@ ed_search_next_history(el, c)
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_prev_line(el, c)
-    EditLine *el;
-    int c;
-{
-    char *ptr;
-    int nchars = c_hpos(el);
-    
-    /*
-     * Move to the line requested
-     */
-    if (*(ptr = el->el_line.cursor) == '\n')
-	ptr--;
-
-    for (; ptr >= el->el_line.buffer; ptr--)
-	if (*ptr == '\n' && --el->el_state.argument <= 0)
-	    break;
-
-    if (el->el_state.argument > 0)
-	return CC_ERROR;
-
-    /*
-     * Move to the beginning of the line
-     */
-    for (ptr--; ptr >= el->el_line.buffer && *ptr != '\n'; ptr--)
-	continue;
-    
-    /*
-     * Move to the character requested
-     */
-    for (ptr++; 
-	 nchars-- > 0 && ptr < el->el_line.lastchar && *ptr != '\n'; 
-	 ptr++)
-	continue;
-    
-    el->el_line.cursor = ptr;
-    return CC_CURSOR;
+ed_prev_line(EditLine *el, int c __attribute__((__unused__)))
+{
+	char *ptr;
+	int nchars = c_hpos(el);
+
+	/*
+         * Move to the line requested
+         */
+	if (*(ptr = el->el_line.cursor) == '\n')
+		ptr--;
+
+	for (; ptr >= el->el_line.buffer; ptr--)
+		if (*ptr == '\n' && --el->el_state.argument <= 0)
+			break;
+
+	if (el->el_state.argument > 0)
+		return (CC_ERROR);
+
+	/*
+         * Move to the beginning of the line
+         */
+	for (ptr--; ptr >= el->el_line.buffer && *ptr != '\n'; ptr--)
+		continue;
+
+	/*
+         * Move to the character requested
+         */
+	for (ptr++;
+	    nchars-- > 0 && ptr < el->el_line.lastchar && *ptr != '\n';
+	    ptr++)
+		continue;
+
+	el->el_line.cursor = ptr;
+	return (CC_CURSOR);
 }
 
 
@@ -930,68 +872,52 @@ ed_prev_line(el, c)
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_next_line(el, c)
-    EditLine *el;
-    int c;
+ed_next_line(EditLine *el, int c __attribute__((__unused__)))
 {
-    char *ptr;
-    int nchars = c_hpos(el);
+	char *ptr;
+	int nchars = c_hpos(el);
+
+	/*
+         * Move to the line requested
+         */
+	for (ptr = el->el_line.cursor; ptr < el->el_line.lastchar; ptr++)
+		if (*ptr == '\n' && --el->el_state.argument <= 0)
+			break;
 
-    /*
-     * Move to the line requested
-     */
-    for (ptr = el->el_line.cursor; ptr < el->el_line.lastchar; ptr++)
-	if (*ptr == '\n' && --el->el_state.argument <= 0)
-	    break;
+	if (el->el_state.argument > 0)
+		return (CC_ERROR);
 
-    if (el->el_state.argument > 0)
-	return CC_ERROR;
+	/*
+         * Move to the character requested
+         */
+	for (ptr++;
+	    nchars-- > 0 && ptr < el->el_line.lastchar && *ptr != '\n';
+	    ptr++)
+		continue;
 
-    /*
-     * Move to the character requested
-     */
-    for (ptr++;
-	 nchars-- > 0 && ptr < el->el_line.lastchar && *ptr != '\n'; 
-    	 ptr++)
-	continue;
-    
-    el->el_line.cursor = ptr;
-    return CC_CURSOR;
+	el->el_line.cursor = ptr;
+	return (CC_CURSOR);
 }
 
 
-/* ed_command(): 
+/* ed_command():
  *	Editline extended command
  *	[M-X] [:]
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_command(el, c)
-    EditLine *el;
-    int c;
+ed_command(EditLine *el, int c __attribute__((__unused__)))
 {
-    char tmpbuf[EL_BUFSIZ];
-    int tmplen;
-
-    el->el_line.buffer[0] = '\0';
-    el->el_line.lastchar = el->el_line.buffer;
-    el->el_line.cursor = el->el_line.buffer;
-
-    c_insert(el, 3);	/* prompt + ": " */
-    *el->el_line.cursor++ = '\n';
-    *el->el_line.cursor++ = ':';
-    *el->el_line.cursor++ = ' ';
-    re_refresh(el);
+	char tmpbuf[EL_BUFSIZ];
+	int tmplen;
 
-    tmplen = c_gets(el, tmpbuf);
-    tmpbuf[tmplen] = '\0';
+	tmplen = c_gets(el, tmpbuf, "\n: ");
+	term__putc('\n');
 
-    el->el_line.buffer[0] = '\0';
-    el->el_line.lastchar = el->el_line.buffer;
-    el->el_line.cursor = el->el_line.buffer;
+	if (tmplen < 0 || (tmpbuf[tmplen] = 0, parse_line(el, tmpbuf)) == -1)
+		term_beep(el);
 
-    if (parse_line(el, tmpbuf) == -1)
-	return CC_ERROR;
-    else
+	el->el_map.current = el->el_map.key;
+	re_clear_display(el);
 	return CC_REFRESH;
 }