 @@ -1,921 +1,922 @@
-/*	$NetBSD: common.c,v 1.27 2011/07/29 15:20:39 christos Exp $	*/
+/*	$NetBSD: common.c,v 1.28 2011/07/29 20:58:07 christos Exp $	*/
 /*-
  * 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.
  */
 #include "config.h"
 #if !defined(lint) && !defined(SCCSID)
 #if 0
 static char sccsid[] = "@(#)common.c	8.1 (Berkeley) 6/4/93";
 #else
-__RCSID("$NetBSD: common.c,v 1.27 2011/07/29 15:20:39 christos Exp $");
+__RCSID("$NetBSD: common.c,v 1.28 2011/07/29 20:58:07 christos Exp $");
 #endif
 #endif /* not lint && not SCCSID */
 /*
  * common.c: Common Editor functions
  */
 #include "el.h"
 /* ed_end_of_file():
  *	Indicate end of file
  *	[^D]
  */
 protected el_action_t
 /*ARGSUSED*/
 ed_end_of_file(EditLine *el, Int c __attribute__((__unused__)))
+{
 	re_goto_bottom(el);
 	*el->el_line.lastchar = '\0';
 	return CC_EOF;
+}
 /* ed_insert():
  *	Add character to the line
  *	Insert a character [bound to all insert keys]
  */
 protected el_action_t
 ed_insert(EditLine *el, Int c)
+{
 	int count = el->el_state.argument;
 	if (c == '\0')
 		return CC_ERROR;
 	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 */
+	}
 	if (count == 1) {
 		if (el->el_state.inputmode == MODE_INSERT
 		    || el->el_line.cursor >= el->el_line.lastchar)
 			c_insert(el, 1);
 		*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 (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)
 		return vi_command_mode(el, 0);
 	return CC_NORM;
+}
 /* ed_delete_prev_word():
  *	Delete from beginning of current word to cursor
  *	[M-^?] [^W]
  */
 protected el_action_t
 /*ARGSUSED*/
 ed_delete_prev_word(EditLine *el, Int c __attribute__((__unused__)))
+{
 	Char *cp, *p, *kp;
 	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);
 	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, (int)(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():
  *	Delete character under cursor
  *	[^D] [x]
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_delete_next_char(EditLine *el, Int c)
+ed_delete_next_char(EditLine *el, Int c __attribute__((__unused__)))
+{
 #ifdef DEBUG_EDIT
 #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 */
 #ifdef KSHVI
 				return CC_ERROR;
 #else
 				/* then do an EOF */
 				terminal_writec(el, c);
 				return CC_EOF;
 #endif
 			} else {
 #ifdef KSHVI
 				el->el_line.cursor--;
 #else
 				return CC_ERROR;
 #endif
+			}
 		} 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)
 			/* bounds check */
 		el->el_line.cursor = el->el_line.lastchar - 1;
 	return CC_REFRESH;
+}
 /* ed_kill_line():
  *	Cut to the end of line
  *	[^K] [^K]
  */
 protected el_action_t
 /*ARGSUSED*/
 ed_kill_line(EditLine *el, Int c __attribute__((__unused__)))
+{
 	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;
 			/* zap! -- delete to end */
 	el->el_line.lastchar = el->el_line.cursor;
 	return CC_REFRESH;
+}
 /* ed_move_to_end():
  *	Move cursor to the end of line
  *	[^E] [^E]
  */
 protected el_action_t
 /*ARGSUSED*/
 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) {
 		if (el->el_chared.c_vcmd.action != NOP) {
 			cv_delfini(el);
 			return CC_REFRESH;
+		}
 #ifdef VI_MOVE
 		el->el_line.cursor--;
 #endif
+	}
 	return CC_CURSOR;
+}
 /* ed_move_to_beg():
  *	Move cursor to the beginning of line
  *	[^A] [^A]
  */
 protected el_action_t
 /*ARGSUSED*/
 ed_move_to_beg(EditLine *el, Int c __attribute__((__unused__)))
+{
 	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 != NOP) {
 			cv_delfini(el);
 			return CC_REFRESH;
+		}
+	}
 	return CC_CURSOR;
+}
 /* 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(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():
  *	Move to the right one character
  *	[^F] [^F]
  */
 protected el_action_t
 /*ARGSUSED*/
 ed_next_char(EditLine *el, Int c __attribute__((__unused__)))
+{
 	Char *lim = 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;
 	el->el_line.cursor += el->el_state.argument;
 	if (el->el_line.cursor > lim)
 		el->el_line.cursor = lim;
 	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():
  *	Move to the beginning of the current word
  *	[M-b] [b]
  */
 protected el_action_t
 /*ARGSUSED*/
 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_map.type == MAP_VI)
 		if (el->el_chared.c_vcmd.action != NOP) {
 			cv_delfini(el);
 			return CC_REFRESH;
+		}
 	return CC_CURSOR;
+}
 /* ed_prev_char():
  *	Move to the left one character
  *	[^B] [^B]
  */
 protected el_action_t
 /*ARGSUSED*/
 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 != NOP) {
 				cv_delfini(el);
 				return CC_REFRESH;
+			}
 		return CC_CURSOR;
 	} else
 		return CC_ERROR;
+}
 /* ed_quoted_insert():
  *	Add the next character typed verbatim
  *	[^V] [^V]
  */
 protected el_action_t
 ed_quoted_insert(EditLine *el, Int c)
+{
 	int num;
 	Char tc;
 	tty_quotemode(el);
 	num = FUN(el,getc)(el, &tc);
 	c = tc;
 	tty_noquotemode(el);
 	if (num == 1)
 		return ed_insert(el, c);
 	else
 		return ed_end_of_file(el, 0);
+}
 /* ed_digit():
  *	Adds to argument or enters a digit
  */
 protected el_action_t
 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');
+		}
 		return CC_ARGHACK;
+	}
 	return ed_insert(el, c);
+}
 /* ed_argument_digit():
  *	Digit that starts argument
  *	For ESC-n
  */
 protected el_action_t
 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;
+}
 /* ed_unassigned():
  *	Indicates unbound character
  *	Bound to keys that are not assigned
  */
 protected el_action_t
 /*ARGSUSED*/
-ed_unassigned(EditLine *el, Int c __attribute__((__unused__)))
+ed_unassigned(EditLine *el __attribute__((__unused__)),
     Int c __attribute__((__unused__)))
+{
 	return CC_ERROR;
+}
 /**
  ** TTY key handling.
  **/
 /* ed_tty_sigint():
  *	Tty interrupt character
  *	[^C]
  */
 protected el_action_t
 /*ARGSUSED*/
 ed_tty_sigint(EditLine *el __attribute__((__unused__)),
 	      Int c __attribute__((__unused__)))
+{
 	return CC_NORM;
+}
 /* ed_tty_dsusp():
  *	Tty delayed suspend character
  *	[^Y]
  */
 protected el_action_t
 /*ARGSUSED*/
 ed_tty_dsusp(EditLine *el __attribute__((__unused__)),
 	     Int c __attribute__((__unused__)))
+{
 	return CC_NORM;
+}
 /* ed_tty_flush_output():
  *	Tty flush output characters
  *	[^O]
  */
 protected el_action_t
 /*ARGSUSED*/
 ed_tty_flush_output(EditLine *el __attribute__((__unused__)),
 		    Int c __attribute__((__unused__)))
+{
 	return CC_NORM;
+}
 /* ed_tty_sigquit():
  *	Tty quit character
  *	[^\]
  */
 protected el_action_t
 /*ARGSUSED*/
 ed_tty_sigquit(EditLine *el __attribute__((__unused__)),
 	       Int c __attribute__((__unused__)))
+{
 	return CC_NORM;
+}
 /* ed_tty_sigtstp():
  *	Tty suspend character
  *	[^Z]
  */
 protected el_action_t
 /*ARGSUSED*/
 ed_tty_sigtstp(EditLine *el __attribute__((__unused__)),
 	       Int c __attribute__((__unused__)))
+{
 	return CC_NORM;
+}
 /* ed_tty_stop_output():
  *	Tty disallow output characters
  *	[^S]
  */
 protected el_action_t
 /*ARGSUSED*/
 ed_tty_stop_output(EditLine *el __attribute__((__unused__)),
 		   Int c __attribute__((__unused__)))
+{
 	return CC_NORM;
+}
 /* ed_tty_start_output():
  *	Tty allow output characters
  *	[^Q]
  */
 protected el_action_t
 /*ARGSUSED*/
 ed_tty_start_output(EditLine *el __attribute__((__unused__)),
 		    Int c __attribute__((__unused__)))
+{
 	return CC_NORM;
+}
 /* ed_newline():
  *	Execute command
  *	[^J]
  */
 protected el_action_t
 /*ARGSUSED*/
 ed_newline(EditLine *el, Int c __attribute__((__unused__)))
+{
 	re_goto_bottom(el);
 	*el->el_line.lastchar++ = '\n';
 	*el->el_line.lastchar = '\0';
 	return CC_NEWLINE;
+}
 /* ed_delete_prev_char():
  *	Delete the character to the left of the cursor
  *	[^?]
  */
 protected el_action_t
 /*ARGSUSED*/
 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;
+}
 /* ed_clear_screen():
  *	Clear screen leaving current line at the top
  *	[^L]
  */
 protected el_action_t
 /*ARGSUSED*/
 ed_clear_screen(EditLine *el, Int c __attribute__((__unused__)))
+{
 	terminal_clear_screen(el);	/* clear the whole real screen */
 	re_clear_display(el);	/* reset everything */
 	return CC_REFRESH;
+}
 /* ed_redisplay():
  *	Redisplay everything
  *	^R
  */
 protected el_action_t
 /*ARGSUSED*/
 ed_redisplay(EditLine *el __attribute__((__unused__)),
 	     Int c __attribute__((__unused__)))
+{
 	return CC_REDISPLAY;
+}
 /* ed_start_over():
  *	Erase current line and start from scratch
  *	[^G]
  */
 protected el_action_t
 /*ARGSUSED*/
 ed_start_over(EditLine *el, Int c __attribute__((__unused__)))
+{
 	ch_reset(el, 0);
 	return CC_REFRESH;
+}
 /* ed_sequence_lead_in():
  *	First character in a bound sequence
  *	Placeholder for external keys
  */
 protected el_action_t
 /*ARGSUSED*/
 ed_sequence_lead_in(EditLine *el __attribute__((__unused__)),
 		    Int c __attribute__((__unused__)))
+{
 	return CC_NORM;
+}
 /* ed_prev_history():
  *	Move to the previous history line
  *	[^P] [k]
  */
 protected el_action_t
 /*ARGSUSED*/
 ed_prev_history(EditLine *el, Int c __attribute__((__unused__)))
+{
 	char beep = 0;
 	int sv_event = el->el_history.eventno;
 	el->el_chared.c_undo.len = -1;
 	*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);
 		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;
+		}
 		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():
  *	Move to the next history line
  *	[^N] [j]
  */
 protected el_action_t
 /*ARGSUSED*/
 ed_next_history(EditLine *el, Int c __attribute__((__unused__)))
+{
 	el_action_t beep = CC_REFRESH, rval;
 	el->el_chared.c_undo.len = -1;
 	*el->el_line.lastchar = '\0';	/* just in case */
 	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;
+}
 /* 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(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");
 #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);
 		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;
 	c_setpat(el);		/* Set search pattern !! */
 	for (h = 1; h <= el->el_history.eventno; h++)
 		hp = HIST_NEXT(el);
 	while (hp != NULL) {
 #ifdef SDEBUG
 		(void) fprintf(el->el_errfile, "Comparing with \"%s\"\n", hp);
 #endif
 		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);
+	}
 	if (!found) {
 #ifdef SDEBUG
 		(void) fprintf(el->el_errfile, "not found\n");
 #endif
 		return CC_ERROR;
+	}
 	el->el_history.eventno = h;
 	return hist_get(el);
+}
 /* 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(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)
 		return CC_ERROR;
 	if (el->el_history.ref == NULL)
 		return CC_ERROR;
 	hp = HIST_FIRST(el);
 	if (hp == NULL)
 		return CC_ERROR;
 	c_setpat(el);		/* Set search pattern !! */
 	for (h = 1; h < el->el_history.eventno && hp; h++) {
 #ifdef SDEBUG
 		(void) fprintf(el->el_errfile, "Comparing with \"%s\"\n", hp);
 #endif
 		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");
 #endif
 			return CC_ERROR;
+		}
+	}
 	el->el_history.eventno = found;
 	return hist_get(el);
+}
 /* ed_prev_line():
  *	Move up one line
  *	Could be [k] [^p]
  */
 protected el_action_t
 /*ARGSUSED*/
 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;
+}
 /* ed_next_line():
  *	Move down one line
  *	Could be [j] [^n]
  */
 protected el_action_t
 /*ARGSUSED*/
 ed_next_line(EditLine *el, Int c __attribute__((__unused__)))
+{
 	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;
 	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;
 	el->el_line.cursor = ptr;
 	return CC_CURSOR;
+}
 /* ed_command():
  *	Editline extended command
  *	[M-X] [:]
  */
 protected el_action_t
 /*ARGSUSED*/
 ed_command(EditLine *el, Int c __attribute__((__unused__)))
+{
 	Char tmpbuf[EL_BUFSIZ];
 	int tmplen;
 	tmplen = c_gets(el, tmpbuf, STR("\n: "));
 	terminal__putc(el, '\n');
 	if (tmplen < 0 || (tmpbuf[tmplen] = 0, parse_line(el, tmpbuf)) == -1)
 		terminal_beep(el);
 	el->el_map.current = el->el_map.key;
 	re_clear_display(el);
 	return CC_REFRESH;
+}

 @@ -1,581 +1,577 @@
-/*	$NetBSD: filecomplete.c,v 1.27 2011/07/29 15:16:33 christos Exp $	*/
+/*	$NetBSD: filecomplete.c,v 1.28 2011/07/29 20:58:07 christos Exp $	*/
 /*-
  * Copyright (c) 1997 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jaromir Dolecek.
+ *
  * 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.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
  */
 #include "config.h"
 #if !defined(lint) && !defined(SCCSID)
-__RCSID("$NetBSD: filecomplete.c,v 1.27 2011/07/29 15:16:33 christos Exp $");
+__RCSID("$NetBSD: filecomplete.c,v 1.28 2011/07/29 20:58:07 christos Exp $");
 #endif /* not lint && not SCCSID */
 #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 <unistd.h>
 #include <limits.h>
 #include <errno.h>
 #include <fcntl.h>
 #ifdef HAVE_VIS_H
 #include <vis.h>
 #else
 #include "vis.h"
 #endif
 #include "el.h"
 #include "fcns.h"		/* for EL_NUM_FCNS */
 #include "histedit.h"
 #include "filecomplete.h"
 static const Char break_chars[] = { ' ', '\t', '\n', '"', '\\', '\'', '`', '@',
     '$', '>', '<', '=', ';', '|', '&', '{', '(', '\0' };
 /********************************/
 /* completion functions */
 /*
  * does tilde expansion of strings of type ``~user/foo''
  * if ``user'' isn't valid user name or ``txt'' doesn't start
  * w/ '~', returns pointer to strdup()ed copy of ``txt''
+ *
  * it's callers's responsibility to free() returned string
  */
 char *
 fn_tilde_expand(const char *txt)
+{
 #if defined(HAVE_GETPW_R_POSIX) || defined(HAVE_GETPW_R_DRAFT)
 	struct passwd pwres;
 	char pwbuf[1024];
 #endif
 	struct passwd *pass;
 	char *temp;
 	size_t len = 0;
 	if (txt[0] != '~')
 		return strdup(txt);
 	temp = strchr(txt + 1, '/');
 	if (temp == NULL) {
 		temp = strdup(txt + 1);
 		if (temp == NULL)
 			return NULL;
 	} else {
 		len = temp - txt + 1;	/* text until string after slash */
 		temp = el_malloc(len * sizeof(*temp));
 		if (temp == NULL)
 			return NULL;
 		(void)strncpy(temp, txt + 1, len - 2);
 		temp[len - 2] = '\0';
+	}
 	if (temp[0] == 0) {
 #ifdef HAVE_GETPW_R_POSIX
  		if (getpwuid_r(getuid(), &pwres, pwbuf, sizeof(pwbuf),
 		    &pass) != 0)
  			pass = NULL;
 #elif HAVE_GETPW_R_DRAFT
 		pass = getpwuid_r(getuid(), &pwres, pwbuf, sizeof(pwbuf));
 #else
 		pass = getpwuid(getuid());
 #endif
 	} else {
 #ifdef HAVE_GETPW_R_POSIX
 		if (getpwnam_r(temp, &pwres, pwbuf, sizeof(pwbuf), &pass) != 0)
 			pass = NULL;
 #elif HAVE_GETPW_R_DRAFT
 		pass = getpwnam_r(temp, &pwres, pwbuf, sizeof(pwbuf));
 #else
 		pass = getpwnam(temp);
 #endif
+	}
 	el_free(temp);		/* value no more needed */
 	if (pass == NULL)
 		return strdup(txt);
 	/* update pointer txt to point at string immedially following */
 	/* first slash */
 	txt += len;
 	len = strlen(pass->pw_dir) + 1 + strlen(txt) + 1;
 	temp = el_malloc(len * sizeof(*temp));
 	if (temp == NULL)
 		return NULL;
 	(void)snprintf(temp, len, "%s/%s", pass->pw_dir, txt);
 	return temp;
+}
 /*
  * return first found file name starting by the ``text'' or NULL if no
  * such file can be found
  * value of ``state'' is ignored
+ *
  * it's caller's responsibility to free returned string
  */
 char *
 fn_filename_completion_function(const char *text, int state)
+{
 	static DIR *dir = NULL;
 	static char *filename = NULL, *dirname = NULL, *dirpath = NULL;
 	static size_t filename_len = 0;
 	struct dirent *entry;
 	char *temp;
 	size_t len;
 	if (state == 0 || dir == NULL) {
 		temp = strrchr(text, '/');
 		if (temp) {
 			char *nptr;
 			temp++;
 			nptr = el_realloc(filename, (strlen(temp) + 1) *
 			    sizeof(*nptr));
 			if (nptr == NULL) {
 				el_free(filename);
 				filename = NULL;
 				return NULL;
+			}
 			filename = nptr;
 			(void)strcpy(filename, temp);
 			len = temp - text;	/* including last slash */
 			nptr = el_realloc(dirname, (len + 1) *
 			    sizeof(*nptr));
 			if (nptr == NULL) {
 				el_free(dirname);
 				dirname = NULL;
 				return NULL;
+			}
 			dirname = nptr;
 			(void)strncpy(dirname, text, len);
 			dirname[len] = '\0';
 		} else {
 			el_free(filename);
 			if (*text == 0)
 				filename = NULL;
 			else {
 				filename = strdup(text);
 				if (filename == NULL)
 					return NULL;
+			}
 			el_free(dirname);
 			dirname = NULL;
+		}
 		if (dir != NULL) {
 			(void)closedir(dir);
 			dir = NULL;
+		}
 		/* support for ``~user'' syntax */
 		el_free(dirpath);
 		dirpath = NULL;
 		if (dirname == NULL) {
 			if ((dirname = strdup("")) == NULL)
 				return NULL;
 			dirpath = strdup("./");
 		} else if (*dirname == '~')
 			dirpath = fn_tilde_expand(dirname);
 		else
 			dirpath = strdup(dirname);
 		if (dirpath == NULL)
 			return NULL;
 		dir = opendir(dirpath);
 		if (!dir)
 			return NULL;	/* cannot open the directory */
 		/* will be used in cycle */
 		filename_len = filename ? strlen(filename) : 0;
+	}
 	/* find the match */
 	while ((entry = readdir(dir)) != NULL) {
 		/* skip . and .. */
 		if (entry->d_name[0] == '.' && (!entry->d_name[1]
 		    || (entry->d_name[1] == '.' && !entry->d_name[2])))
 			continue;
 		if (filename_len == 0)
 			break;
 		/* otherwise, get first entry where first */
 		/* filename_len characters are equal	  */
 		if (entry->d_name[0] == filename[0]
 #if HAVE_STRUCT_DIRENT_D_NAMLEN
 		    && entry->d_namlen >= filename_len
 #else
 		    && strlen(entry->d_name) >= filename_len
 #endif
 		    && strncmp(entry->d_name, filename,
 			filename_len) == 0)
 			break;
+	}
 	if (entry) {		/* match found */
 #if HAVE_STRUCT_DIRENT_D_NAMLEN
 		len = entry->d_namlen;
 #else
 		len = strlen(entry->d_name);
 #endif
 		len = strlen(dirname) + len + 1;
 		temp = el_malloc(len * sizeof(*temp));
 		if (temp == NULL)
 			return NULL;
 		(void)snprintf(temp, len, "%s%s", dirname, entry->d_name);
 	} else {
 		(void)closedir(dir);
 		dir = NULL;
 		temp = NULL;
+	}
 	return temp;
+}
 static const char *
 append_char_function(const char *name)
+{
 	struct stat stbuf;
 	char *expname = *name == '~' ? fn_tilde_expand(name) : NULL;
 	const char *rs = " ";
 	if (stat(expname ? expname : name, &stbuf) == -1)
 		goto out;
 	if (S_ISDIR(stbuf.st_mode))
 		rs = "/";
 out:
 	if (expname)
 		el_free(expname);
 	return rs;
+}
 /*
  * returns list of completions for text given
  * non-static for readline.
  */
 char ** completion_matches(const char *, char *(*)(const char *, int));
 char **
 completion_matches(const char *text, char *(*genfunc)(const char *, int))
+{
 	char **match_list = NULL, *retstr, *prevstr;
 	size_t match_list_len, max_equal, which, i;
 	size_t matches;
 	matches = 0;
 	match_list_len = 1;
 	while ((retstr = (*genfunc) (text, (int)matches)) != NULL) {
 		/* allow for list terminator here */
 		if (matches + 3 >= match_list_len) {
 			char **nmatch_list;
 			while (matches + 3 >= match_list_len)
 				match_list_len <<= 1;
 			nmatch_list = el_realloc(match_list,
 			    match_list_len * sizeof(*nmatch_list));
 			if (nmatch_list == NULL) {
 				el_free(match_list);
 				return NULL;
+			}
 			match_list = nmatch_list;
+		}
 		match_list[++matches] = retstr;
+	}
 	if (!match_list)
 		return NULL;	/* nothing found */
 	/* find least denominator and insert it to match_list[0] */
 	which = 2;
 	prevstr = match_list[1];
 	max_equal = strlen(prevstr);
 	for (; which <= matches; which++) {
 		for (i = 0; i < max_equal &&
 		    prevstr[i] == match_list[which][i]; i++)
 			continue;
 		max_equal = i;
+	}
 	retstr = el_malloc((max_equal + 1) * sizeof(*retstr));
 	if (retstr == NULL) {
 		el_free(match_list);
 		return NULL;
+	}
 	(void)strncpy(retstr, match_list[1], max_equal);
 	retstr[max_equal] = '\0';
 	match_list[0] = retstr;
 	/* add NULL as last pointer to the array */
 	match_list[matches + 1] = (char *) NULL;
 	return match_list;
+}
 /*
  * Sort function for qsort(). Just wrapper around strcasecmp().
  */
 static int
 _fn_qsort_string_compare(const void *i1, const void *i2)
+{
 	const char *s1 = ((const char * const *)i1)[0];
 	const char *s2 = ((const char * const *)i2)[0];
 	return strcasecmp(s1, s2);
+}
 /*
  * Display list of strings in columnar format on readline's output stream.
  * 'matches' is list of strings, 'num' is number of strings in 'matches',
  * 'width' is maximum length of string in 'matches'.
+ *
  * matches[0] is not one of the match strings, but it is counted in
  * num, so the strings are matches[1] *through* matches[num-1].
  */
 void
 fn_display_match_list (EditLine *el, char **matches, size_t num, size_t width)
+{
 	size_t line, lines, col, cols, thisguy;
 	int screenwidth = el->el_terminal.t_size.h;
 	/* Ignore matches[0]. Avoid 1-based array logic below. */
 	matches++;
 	num--;
 	/*
 	 * Find out how many entries can be put on one line; count
 	 * with one space between strings the same way it's printed.
 	 */
 	cols = screenwidth / (width + 1);
 	if (cols == 0)
 		cols = 1;
 	/* how many lines of output, rounded up */
 	lines = (num + cols - 1) / cols;
 	/* Sort the items. */
 	qsort(matches, num, sizeof(char *), _fn_qsort_string_compare);
 	/*
 	 * On the ith line print elements i, i+lines, i+lines*2, etc.
 	 */
 	for (line = 0; line < lines; line++) {
 		for (col = 0; col < cols; col++) {
 			thisguy = line + col * lines;
 			if (thisguy >= num)
 				break;
 			(void)fprintf(el->el_outfile, "%s%-*s",
 			    col == 0 ? "" : " ", (int)width, matches[thisguy]);
+		}
 		(void)fprintf(el->el_outfile, "\n");
+	}
+}
 /*
  * Complete the word at or before point,
  * 'what_to_do' says what to do with the completion.
  * \t   means do standard completion.
  * `?' means list the possible completions.
  * `*' means insert all of the possible completions.
  * `!' means to do standard completion, and list all possible completions if
  * there is more than one.
+ *
  * Note: '*' support is not implemented
  *       '!' could never be invoked
  */
 int
 fn_complete(EditLine *el,
 	char *(*complet_func)(const char *, int),
 	char **(*attempted_completion_function)(const char *, int, int),
 	const Char *word_break, const Char *special_prefixes,
 	const char *(*app_func)(const char *), size_t query_items,
 	int *completion_type, int *over, int *point, int *end)
+{
 	const TYPE(LineInfo) *li;
 	Char *temp;
         char **matches;
 	const Char *ctemp;
 	size_t len;
 	int what_to_do = '\t';
 	int retval = CC_NORM;
 	if (el->el_state.lastcmd == el->el_state.thiscmd)
 		what_to_do = '?';
 	/* readline's rl_complete() has to be told what we did... */
 	if (completion_type != NULL)
 		*completion_type = what_to_do;
 	if (!complet_func)
 		complet_func = fn_filename_completion_function;
 	if (!app_func)
 		app_func = append_char_function;
 	/* We now look backwards for the start of a filename/variable word */
 	li = FUN(el,line)(el);
 	ctemp = li->cursor;
 	while (ctemp > li->buffer
 	    && !Strchr(word_break, ctemp[-1])
 	    && (!special_prefixes || !Strchr(special_prefixes, ctemp[-1]) ) )
 		ctemp--;
 	len = li->cursor - ctemp;
 	temp = el_malloc((len + 1) * sizeof(*temp));
 	(void)Strncpy(temp, ctemp, len);
 	temp[len] = '\0';
 	/* these can be used by function called in completion_matches() */
 	/* or (*attempted_completion_function)() */
 	if (point != 0)
 		*point = (int)(li->cursor - li->buffer);
 	if (end != NULL)
 		*end = (int)(li->lastchar - li->buffer);
 	if (attempted_completion_function) {
 		int cur_off = (int)(li->cursor - li->buffer);
 		matches = (*attempted_completion_function) (ct_encode_string(temp, &el->el_scratch),
 		    (int)(cur_off - len), cur_off);
 	} else
 		matches = 0;
 	if (!attempted_completion_function ||
 	    (over != NULL && !*over && !matches))
 		matches = completion_matches(ct_encode_string(temp, &el->el_scratch), complet_func);
 	if (over != NULL)
 		*over = 0;
 	if (matches) {
 		int i;
 		size_t matches_num, maxlen, match_len, match_display=1;
 		retval = CC_REFRESH;
 		/*
 		 * Only replace the completed string with common part of
 		 * possible matches if there is possible completion.
 		 */
 		if (matches[0][0] != '\0') {
 			el_deletestr(el, (int) len);
 			FUN(el,insertstr)(el,
 			    ct_decode_string(matches[0], &el->el_scratch));
+		}
 		if (what_to_do == '?')
 			goto display_matches;
 		if (matches[2] == NULL && strcmp(matches[0], matches[1]) == 0) {
 			/*
 			 * We found exact match. Add a space after
 			 * it, unless we do filename completion and the
 			 * object is a directory.
 			 */
 			FUN(el,insertstr)(el,
 			    ct_decode_string((*app_func)(matches[0]),
 			    &el->el_scratch));
 		} else if (what_to_do == '!') {
     display_matches:
 			/*
 			 * More than one match and requested to list possible
 			 * matches.
 			 */
 			for(i = 1, maxlen = 0; matches[i]; i++) {
 				match_len = strlen(matches[i]);
 				if (match_len > maxlen)
 					maxlen = match_len;
+			}
 			/* matches[1] through matches[i-1] are available */
 			matches_num = i - 1;
 			/* newline to get on next line from command line */
 			(void)fprintf(el->el_outfile, "\n");
 			/*
 			 * If there are too many items, ask user for display
 			 * confirmation.
 			 */
 			if (matches_num > query_items) {
 				(void)fprintf(el->el_outfile,
 				    "Display all %zu possibilities? (y or n) ",
 				    matches_num);
 				(void)fflush(el->el_outfile);
 				if (getc(stdin) != 'y')
 					match_display = 0;
 				(void)fprintf(el->el_outfile, "\n");
+			}
 			if (match_display) {
 				/*
 				 * Interface of this function requires the
 				 * strings be matches[1..num-1] for compat.
 				 * We have matches_num strings not counting
 				 * the prefix in matches[0], so we need to
 				 * add 1 to matches_num for the call.
 				 */
 				fn_display_match_list(el, matches,
 				    matches_num+1, maxlen);
+			}
 			retval = CC_REDISPLAY;
 		} else if (matches[0][0]) {
 			/*
 			 * There was some common match, but the name was
 			 * not complete enough. Next tab will print possible
 			 * completions.
 			 */
 			el_beep(el);
 		} else {
 			/* lcd is not a valid object - further specification */
 			/* is needed */
 			el_beep(el);
 			retval = CC_NORM;
+		}
 		/* free elements of array and the array itself */
 		for (i = 0; matches[i]; i++)
 			el_free(matches[i]);
 		el_free(matches);
 		matches = NULL;
+	}
 	el_free(temp);
 	return retval;
+}
 /*
  * el-compatible wrapper around rl_complete; needed for key binding
  */
 /* ARGSUSED */
 unsigned char
 _el_fn_complete(EditLine *el, int ch __attribute__((__unused__)))
+{
 	return (unsigned char)fn_complete(el, NULL, NULL,
 	    break_chars, NULL, NULL, 100,
 	    NULL, NULL, NULL, NULL);
+}

 @@ -1,1053 +1,1049 @@
-/*	$NetBSD: history.c,v 1.43 2011/07/29 15:16:33 christos Exp $	*/
+/*	$NetBSD: history.c,v 1.44 2011/07/29 20:58:07 christos Exp $	*/
 /*-
  * 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.
  */
 #include "config.h"
 #if !defined(lint) && !defined(SCCSID)
 #if 0
 static char sccsid[] = "@(#)history.c	8.1 (Berkeley) 6/4/93";
 #else
-__RCSID("$NetBSD: history.c,v 1.43 2011/07/29 15:16:33 christos Exp $");
+__RCSID("$NetBSD: history.c,v 1.44 2011/07/29 20:58:07 christos Exp $");
 #endif
 #endif /* not lint && not SCCSID */
 /*
  * hist.c: TYPE(History) access functions
  */
 #include <string.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #ifdef HAVE_VIS_H
 #include <vis.h>
 #else
 #include "vis.h"
 #endif
 #include <sys/stat.h>
 static const char hist_cookie[] = "_HiStOrY_V2_\n";
 #include "histedit.h"
 #include "chartype.h"
 typedef int (*history_gfun_t)(void *, TYPE(HistEvent) *);
 typedef int (*history_efun_t)(void *, TYPE(HistEvent) *, const Char *);
 typedef void (*history_vfun_t)(void *, TYPE(HistEvent) *);
 typedef int (*history_sfun_t)(void *, TYPE(HistEvent) *, const int);
 struct TYPE(history) {
 	void *h_ref;		/* Argument for history fcns	 */
 	int h_ent;		/* Last entry point for history	 */
 	history_gfun_t h_first;	/* Get the first element	 */
 	history_gfun_t h_next;	/* Get the next element		 */
 	history_gfun_t h_last;	/* Get the last element		 */
 	history_gfun_t h_prev;	/* Get the previous element	 */
 	history_gfun_t h_curr;	/* Get the current element	 */
 	history_sfun_t h_set;	/* Set the current element	 */
 	history_sfun_t h_del;	/* Set the given element	 */
 	history_vfun_t h_clear;	/* Clear the history list	 */
 	history_efun_t h_enter;	/* Add an element		 */
 	history_efun_t h_add;	/* Append to an element		 */
 };
 #define	HNEXT(h, ev)		(*(h)->h_next)((h)->h_ref, ev)
 #define	HFIRST(h, ev)		(*(h)->h_first)((h)->h_ref, ev)
 #define	HPREV(h, ev)		(*(h)->h_prev)((h)->h_ref, ev)
 #define	HLAST(h, ev)		(*(h)->h_last)((h)->h_ref, ev)
 #define	HCURR(h, ev)		(*(h)->h_curr)((h)->h_ref, ev)
 #define	HSET(h, ev, n)		(*(h)->h_set)((h)->h_ref, ev, n)
 #define	HCLEAR(h, ev)		(*(h)->h_clear)((h)->h_ref, ev)
 #define	HENTER(h, ev, str)	(*(h)->h_enter)((h)->h_ref, ev, str)
 #define	HADD(h, ev, str)	(*(h)->h_add)((h)->h_ref, ev, str)
 #define	HDEL(h, ev, n)		(*(h)->h_del)((h)->h_ref, ev, n)
 #define	h_strdup(a)	Strdup(a)
 #define	h_malloc(a)	malloc(a)
 #define	h_realloc(a, b)	realloc((a), (b))
 #define	h_free(a)	free(a)
 typedef struct {
     int		num;
     Char	*str;
 } HistEventPrivate;
 private int history_setsize(TYPE(History) *, TYPE(HistEvent) *, int);
 private int history_getsize(TYPE(History) *, TYPE(HistEvent) *);
 private int history_setunique(TYPE(History) *, TYPE(HistEvent) *, int);
 private int history_getunique(TYPE(History) *, TYPE(HistEvent) *);
 private int history_set_fun(TYPE(History) *, TYPE(History) *);
 private int history_load(TYPE(History) *, const char *);
 private int history_save(TYPE(History) *, const char *);
 private int history_prev_event(TYPE(History) *, TYPE(HistEvent) *, int);
 private int history_next_event(TYPE(History) *, TYPE(HistEvent) *, int);
 private int history_next_string(TYPE(History) *, TYPE(HistEvent) *, const Char *);
 private int history_prev_string(TYPE(History) *, TYPE(HistEvent) *, const Char *);
 /***********************************************************************/
 /*
  * Builtin- history implementation
  */
 typedef struct hentry_t {
 	TYPE(HistEvent) ev;		/* What we return		 */
 	void *data;		/* data				 */
 	struct hentry_t *next;	/* Next entry			 */
 	struct hentry_t *prev;	/* Previous entry		 */
 } hentry_t;
 typedef struct history_t {
 	hentry_t list;		/* Fake list header element	*/
 	hentry_t *cursor;	/* Current element in the list	*/
 	int max;		/* Maximum number of events	*/
 	int cur;		/* Current number of events	*/
 	int eventid;		/* For generation of unique event id	 */
 	int flags;		/* TYPE(History) flags		*/
 #define H_UNIQUE	1	/* Store only unique elements	*/
 } history_t;
 private int history_def_next(void *, TYPE(HistEvent) *);
 private int history_def_first(void *, TYPE(HistEvent) *);
 private int history_def_prev(void *, TYPE(HistEvent) *);
 private int history_def_last(void *, TYPE(HistEvent) *);
 private int history_def_curr(void *, TYPE(HistEvent) *);
 private int history_def_set(void *, TYPE(HistEvent) *, const int);
 private void history_def_clear(void *, TYPE(HistEvent) *);
 private int history_def_enter(void *, TYPE(HistEvent) *, const Char *);
 private int history_def_add(void *, TYPE(HistEvent) *, const Char *);
 private int history_def_del(void *, TYPE(HistEvent) *, const int);
 private int history_def_init(void **, TYPE(HistEvent) *, int);
 private int history_def_insert(history_t *, TYPE(HistEvent) *, const Char *);
 private void history_def_delete(history_t *, TYPE(HistEvent) *, hentry_t *);
 private int history_deldata_nth(history_t *, TYPE(HistEvent) *, int, void **);
 private int history_set_nth(void *, TYPE(HistEvent) *, int);
 #define	history_def_setsize(p, num)(void) (((history_t *)p)->max = (num))
 #define	history_def_getsize(p)  (((history_t *)p)->cur)
 #define	history_def_getunique(p) (((((history_t *)p)->flags) & H_UNIQUE) != 0)
 #define	history_def_setunique(p, uni) \
     if (uni) \
 	(((history_t *)p)->flags) |= H_UNIQUE; \
     else \
 	(((history_t *)p)->flags) &= ~H_UNIQUE
 #define	he_strerror(code)	he_errlist[code]
 #define	he_seterrev(evp, code)	{\
 				    evp->num = code;\
 				    evp->str = he_strerror(code);\
+				}
 /* error messages */
 static const Char *const he_errlist[] = {
 	STR("OK"),
 	STR("unknown error"),
 	STR("malloc() failed"),
 	STR("first event not found"),
 	STR("last event not found"),
 	STR("empty list"),
 	STR("no next event"),
 	STR("no previous event"),
 	STR("current event is invalid"),
 	STR("event not found"),
 	STR("can't read history from file"),
 	STR("can't write history"),
 	STR("required parameter(s) not supplied"),
 	STR("history size negative"),
 	STR("function not allowed with other history-functions-set the default"),
 	STR("bad parameters")
 };
 /* error codes */
 #define	_HE_OK                   0
 #define	_HE_UNKNOWN		 1
 #define	_HE_MALLOC_FAILED        2
 #define	_HE_FIRST_NOTFOUND       3
 #define	_HE_LAST_NOTFOUND        4
 #define	_HE_EMPTY_LIST           5
 #define	_HE_END_REACHED          6
 #define	_HE_START_REACHED	 7
 #define	_HE_CURR_INVALID	 8
 #define	_HE_NOT_FOUND		 9
 #define	_HE_HIST_READ		10
 #define	_HE_HIST_WRITE		11
 #define	_HE_PARAM_MISSING	12
 #define	_HE_SIZE_NEGATIVE	13
 #define	_HE_NOT_ALLOWED		14
 #define	_HE_BAD_PARAM		15
 /* history_def_first():
  *	Default function to return the first event in the history.
  */
 private int
 history_def_first(void *p, TYPE(HistEvent) *ev)
+{
 	history_t *h = (history_t *) p;
 	h->cursor = h->list.next;
 	if (h->cursor != &h->list)
 		*ev = h->cursor->ev;
 	else {
 		he_seterrev(ev, _HE_FIRST_NOTFOUND);
 		return -1;
+	}
 	return 0;
+}
 /* history_def_last():
  *	Default function to return the last event in the history.
  */
 private int
 history_def_last(void *p, TYPE(HistEvent) *ev)
+{
 	history_t *h = (history_t *) p;
 	h->cursor = h->list.prev;
 	if (h->cursor != &h->list)
 		*ev = h->cursor->ev;
 	else {
 		he_seterrev(ev, _HE_LAST_NOTFOUND);
 		return -1;
+	}
 	return 0;
+}
 /* history_def_next():
  *	Default function to return the next event in the history.
  */
 private int
 history_def_next(void *p, TYPE(HistEvent) *ev)
+{
 	history_t *h = (history_t *) p;
 	if (h->cursor == &h->list) {
 		he_seterrev(ev, _HE_EMPTY_LIST);
 		return -1;
+	}
 	if (h->cursor->next == &h->list) {
 		he_seterrev(ev, _HE_END_REACHED);
 		return -1;
+	}
         h->cursor = h->cursor->next;
         *ev = h->cursor->ev;
 	return 0;
+}
 /* history_def_prev():
  *	Default function to return the previous event in the history.
  */
 private int
 history_def_prev(void *p, TYPE(HistEvent) *ev)
+{
 	history_t *h = (history_t *) p;
 	if (h->cursor == &h->list) {
 		he_seterrev(ev,
 		    (h->cur > 0) ? _HE_END_REACHED : _HE_EMPTY_LIST);
 		return -1;
+	}
 	if (h->cursor->prev == &h->list) {
 		he_seterrev(ev, _HE_START_REACHED);
 		return -1;
+	}
         h->cursor = h->cursor->prev;
         *ev = h->cursor->ev;
 	return 0;
+}
 /* history_def_curr():
  *	Default function to return the current event in the history.
  */
 private int
 history_def_curr(void *p, TYPE(HistEvent) *ev)
+{
 	history_t *h = (history_t *) p;
 	if (h->cursor != &h->list)
 		*ev = h->cursor->ev;
 	else {
 		he_seterrev(ev,
 		    (h->cur > 0) ? _HE_CURR_INVALID : _HE_EMPTY_LIST);
 		return -1;
+	}
 	return 0;
+}
 /* history_def_set():
  *	Default function to set the current event in the history to the
  *	given one.
  */
 private int
 history_def_set(void *p, TYPE(HistEvent) *ev, const int n)
+{
 	history_t *h = (history_t *) p;
 	if (h->cur == 0) {
 		he_seterrev(ev, _HE_EMPTY_LIST);
 		return -1;
+	}
 	if (h->cursor == &h->list || h->cursor->ev.num != n) {
 		for (h->cursor = h->list.next; h->cursor != &h->list;
 		    h->cursor = h->cursor->next)
 			if (h->cursor->ev.num == n)
 				break;
+	}
 	if (h->cursor == &h->list) {
 		he_seterrev(ev, _HE_NOT_FOUND);
 		return -1;
+	}
 	return 0;
+}
 /* history_set_nth():
  *	Default function to set the current event in the history to the
  *	n-th one.
  */
 private int
 history_set_nth(void *p, TYPE(HistEvent) *ev, int n)
+{
 	history_t *h = (history_t *) p;
 	if (h->cur == 0) {
 		he_seterrev(ev, _HE_EMPTY_LIST);
 		return -1;
+	}
 	for (h->cursor = h->list.prev; h->cursor != &h->list;
 	    h->cursor = h->cursor->prev)
 		if (n-- <= 0)
 			break;
 	if (h->cursor == &h->list) {
 		he_seterrev(ev, _HE_NOT_FOUND);
 		return -1;
+	}
 	return 0;
+}
 /* history_def_add():
  *	Append string to element
  */
 private int
 history_def_add(void *p, TYPE(HistEvent) *ev, const Char *str)
+{
 	history_t *h = (history_t *) p;
 	size_t len;
 	Char *s;
 	HistEventPrivate *evp = (void *)&h->cursor->ev;
 	if (h->cursor == &h->list)
 		return history_def_enter(p, ev, str);
 	len = Strlen(evp->str) + Strlen(str) + 1;
 	s = h_malloc(len * sizeof(*s));
 	if (s == NULL) {
 		he_seterrev(ev, _HE_MALLOC_FAILED);
 		return -1;
+	}
 	(void) Strncpy(s, h->cursor->ev.str, len);
         s[len - 1] = '\0';
 	(void) Strncat(s, str, len - Strlen(s) - 1);
 	h_free(evp->str);
 	evp->str = s;
 	*ev = h->cursor->ev;
 	return 0;
+}
 private int
 history_deldata_nth(history_t *h, TYPE(HistEvent) *ev,
     int num, void **data)
+{
 	if (history_set_nth(h, ev, num) != 0)
 		return -1;
 	/* magic value to skip delete (just set to n-th history) */
 	if (data == (void **)-1)
 		return 0;
 	ev->str = Strdup(h->cursor->ev.str);
 	ev->num = h->cursor->ev.num;
 	if (data)
 		*data = h->cursor->data;
 	history_def_delete(h, ev, h->cursor);
 	return 0;
+}
 /* history_def_del():
  *	Delete element hp of the h list
  */
 /* ARGSUSED */
 private int
 history_def_del(void *p, TYPE(HistEvent) *ev __attribute__((__unused__)),
     const int num)
+{
 	history_t *h = (history_t *) p;
 	if (history_def_set(h, ev, num) != 0)
 		return -1;
 	ev->str = Strdup(h->cursor->ev.str);
 	ev->num = h->cursor->ev.num;
 	history_def_delete(h, ev, h->cursor);
 	return 0;
+}
 /* history_def_delete():
  *	Delete element hp of the h list
  */
 /* ARGSUSED */
 private void
 history_def_delete(history_t *h,
 		   TYPE(HistEvent) *ev __attribute__((__unused__)), hentry_t *hp)
+{
 	HistEventPrivate *evp = (void *)&hp->ev;
 	if (hp == &h->list)
 		abort();
 	if (h->cursor == hp) {
 		h->cursor = hp->prev;
 		if (h->cursor == &h->list)
 			h->cursor = hp->next;
+	}
 	hp->prev->next = hp->next;
 	hp->next->prev = hp->prev;
 	h_free(evp->str);
 	h_free(hp);
 	h->cur--;
+}
 /* history_def_insert():
  *	Insert element with string str in the h list
  */
 private int
 history_def_insert(history_t *h, TYPE(HistEvent) *ev, const Char *str)
+{
 	hentry_t *c;
 	c = h_malloc(sizeof(*c));
 	if (c == NULL)
 		goto oomem;
 	if ((c->ev.str = h_strdup(str)) == NULL) {
 		h_free(c);
 		goto oomem;
+	}
 	c->data = NULL;
 	c->ev.num = ++h->eventid;
 	c->next = h->list.next;
 	c->prev = &h->list;
 	h->list.next->prev = c;
 	h->list.next = c;
 	h->cur++;
 	h->cursor = c;
 	*ev = c->ev;
 	return 0;
 oomem:
 	he_seterrev(ev, _HE_MALLOC_FAILED);
 	return -1;
+}
 /* history_def_enter():
  *	Default function to enter an item in the history
  */
 private int
 history_def_enter(void *p, TYPE(HistEvent) *ev, const Char *str)
+{
 	history_t *h = (history_t *) p;
 	if ((h->flags & H_UNIQUE) != 0 && h->list.next != &h->list &&
 	    Strcmp(h->list.next->ev.str, str) == 0)
 	    return 0;
 	if (history_def_insert(h, ev, str) == -1)
 		return -1;	/* error, keep error message */
 	/*
          * Always keep at least one entry.
          * This way we don't have to check for the empty list.
          */
 	while (h->cur > h->max && h->cur > 0)
 		history_def_delete(h, ev, h->list.prev);
 	return 1;
+}
 /* history_def_init():
  *	Default history initialization function
  */
 /* ARGSUSED */
 private int
 history_def_init(void **p, TYPE(HistEvent) *ev __attribute__((__unused__)), int n)
+{
 	history_t *h = (history_t *) h_malloc(sizeof(*h));
 	if (h == NULL)
 		return -1;
 	if (n <= 0)
 		n = 0;
 	h->eventid = 0;
 	h->cur = 0;
 	h->max = n;
 	h->list.next = h->list.prev = &h->list;
 	h->list.ev.str = NULL;
 	h->list.ev.num = 0;
 	h->cursor = &h->list;
 	h->flags = 0;
 	*p = h;
 	return 0;
+}
 /* history_def_clear():
  *	Default history cleanup function
  */
 private void
 history_def_clear(void *p, TYPE(HistEvent) *ev)
+{
 	history_t *h = (history_t *) p;
 	while (h->list.prev != &h->list)
 		history_def_delete(h, ev, h->list.prev);
 	h->cursor = &h->list;
 	h->eventid = 0;
 	h->cur = 0;
+}
 /************************************************************************/
 /* history_init():
  *	Initialization function.
  */
 public TYPE(History) *
 FUN(history,init)(void)
+{
 	TYPE(HistEvent) ev;
 	TYPE(History) *h = (TYPE(History) *) h_malloc(sizeof(*h));
 	if (h == NULL)
 		return NULL;
 	if (history_def_init(&h->h_ref, &ev, 0) == -1) {
 		h_free(h);
 		return NULL;
+	}
 	h->h_ent = -1;
 	h->h_next = history_def_next;
 	h->h_first = history_def_first;
 	h->h_last = history_def_last;
 	h->h_prev = history_def_prev;
 	h->h_curr = history_def_curr;
 	h->h_set = history_def_set;
 	h->h_clear = history_def_clear;
 	h->h_enter = history_def_enter;
 	h->h_add = history_def_add;
 	h->h_del = history_def_del;
 	return h;
+}
 /* history_end():
  *	clean up history;
  */
 public void
 FUN(history,end)(TYPE(History) *h)
+{
 	TYPE(HistEvent) ev;
 	if (h->h_next == history_def_next)
 		history_def_clear(h->h_ref, &ev);
 	h_free(h->h_ref);
 	h_free(h);
+}
 /* history_setsize():
  *	Set history number of events
  */
 private int
 history_setsize(TYPE(History) *h, TYPE(HistEvent) *ev, int num)
+{
 	if (h->h_next != history_def_next) {
 		he_seterrev(ev, _HE_NOT_ALLOWED);
 		return -1;
+	}
 	if (num < 0) {
 		he_seterrev(ev, _HE_BAD_PARAM);
 		return -1;
+	}
 	history_def_setsize(h->h_ref, num);
 	return 0;
+}
 /* history_getsize():
  *      Get number of events currently in history
  */
 private int
 history_getsize(TYPE(History) *h, TYPE(HistEvent) *ev)
+{
 	if (h->h_next != history_def_next) {
 		he_seterrev(ev, _HE_NOT_ALLOWED);
 		return -1;
+	}
 	ev->num = history_def_getsize(h->h_ref);
 	if (ev->num < -1) {
 		he_seterrev(ev, _HE_SIZE_NEGATIVE);
 		return -1;
+	}
 	return 0;
+}
 /* history_setunique():
  *	Set if adjacent equal events should not be entered in history.
  */
 private int
 history_setunique(TYPE(History) *h, TYPE(HistEvent) *ev, int uni)
+{
 	if (h->h_next != history_def_next) {
 		he_seterrev(ev, _HE_NOT_ALLOWED);
 		return -1;
+	}
 	history_def_setunique(h->h_ref, uni);
 	return 0;
+}
 /* history_getunique():
  *	Get if adjacent equal events should not be entered in history.
  */
 private int
 history_getunique(TYPE(History) *h, TYPE(HistEvent) *ev)
+{
 	if (h->h_next != history_def_next) {
 		he_seterrev(ev, _HE_NOT_ALLOWED);
 		return -1;
+	}
 	ev->num = history_def_getunique(h->h_ref);
 	return 0;
+}
 /* history_set_fun():
  *	Set history functions
  */
 private int
 history_set_fun(TYPE(History) *h, TYPE(History) *nh)
+{
 	TYPE(HistEvent) ev;
 	if (nh->h_first == NULL || nh->h_next == NULL || nh->h_last == NULL ||
 	    nh->h_prev == NULL || nh->h_curr == NULL || nh->h_set == NULL ||
 	    nh->h_enter == NULL || nh->h_add == NULL || nh->h_clear == NULL ||
 	    nh->h_del == NULL || nh->h_ref == NULL) {
 		if (h->h_next != history_def_next) {
 			history_def_init(&h->h_ref, &ev, 0);
 			h->h_first = history_def_first;
 			h->h_next = history_def_next;
 			h->h_last = history_def_last;
 			h->h_prev = history_def_prev;
 			h->h_curr = history_def_curr;
 			h->h_set = history_def_set;
 			h->h_clear = history_def_clear;
 			h->h_enter = history_def_enter;
 			h->h_add = history_def_add;
 			h->h_del = history_def_del;
+		}
 		return -1;
+	}
 	if (h->h_next == history_def_next)
 		history_def_clear(h->h_ref, &ev);
 	h->h_ent = -1;
 	h->h_first = nh->h_first;
 	h->h_next = nh->h_next;
 	h->h_last = nh->h_last;
 	h->h_prev = nh->h_prev;
 	h->h_curr = nh->h_curr;
 	h->h_set = nh->h_set;
 	h->h_clear = nh->h_clear;
 	h->h_enter = nh->h_enter;
 	h->h_add = nh->h_add;
 	h->h_del = nh->h_del;
 	return 0;
+}
 /* history_load():
  *	TYPE(History) load function
  */
 private int
 history_load(TYPE(History) *h, const char *fname)
+{
 	FILE *fp;
 	char *line;
 	size_t sz, max_size;
 	char *ptr;
 	int i = -1;
 	TYPE(HistEvent) ev;
 #ifdef WIDECHAR
 	static ct_buffer_t conv;
 #endif
 	if ((fp = fopen(fname, "r")) == NULL)
 		return i;
 	if ((line = fgetln(fp, &sz)) == NULL)
 		goto done;
 	if (strncmp(line, hist_cookie, sz) != 0)
 		goto done;
 	ptr = h_malloc((max_size = 1024) * sizeof(*ptr));
 	if (ptr == NULL)
 		goto done;
 	for (i = 0; (line = fgetln(fp, &sz)) != NULL; i++) {
 		char c = line[sz];
 		if (sz != 0 && line[sz - 1] == '\n')
 			line[--sz] = '\0';
 		else
 			line[sz] = '\0';
 		if (max_size < sz) {
 			char *nptr;
 			max_size = (sz + 1024) & ~1023;
 			nptr = h_realloc(ptr, max_size * sizeof(*ptr));
 			if (nptr == NULL) {
 				i = -1;
 				goto oomem;
+			}
 			ptr = nptr;
+		}
 		(void) strunvis(ptr, line);
 		line[sz] = c;
 		if (HENTER(h, &ev, ct_decode_string(ptr, &conv)) == -1) {
 			i = -1;
 			goto oomem;
+		}
+	}
 oomem:
 	h_free(ptr);
 done:
 	(void) fclose(fp);
 	return i;
+}
 /* history_save():
  *	TYPE(History) save function
  */
 private int
 history_save(TYPE(History) *h, const char *fname)
+{
 	FILE *fp;
 	TYPE(HistEvent) ev;
 	int i = -1, retval;
 	size_t len, max_size;
 	char *ptr;
 	const char *str;
 #ifdef WIDECHAR
 	static ct_buffer_t conv;
 #endif
 	if ((fp = fopen(fname, "w")) == NULL)
 		return -1;
 	if (fchmod(fileno(fp), S_IRUSR|S_IWUSR) == -1)
 		goto done;
 	if (fputs(hist_cookie, fp) == EOF)
 		goto done;
 	ptr = h_malloc((max_size = 1024) * sizeof(*ptr));
 	if (ptr == NULL)
 		goto done;
 	for (i = 0, retval = HLAST(h, &ev);
 	    retval != -1;
 	    retval = HPREV(h, &ev), i++) {
 		str = ct_encode_string(ev.str, &conv);
 		len = strlen(str) * 4;
 		if (len >= max_size) {
 			char *nptr;
 			max_size = (len + 1024) & ~1023;
 			nptr = h_realloc(ptr, max_size * sizeof(*ptr));
 			if (nptr == NULL) {
 				i = -1;
 				goto oomem;
+			}
 			ptr = nptr;
+		}
 		(void) strvis(ptr, str, VIS_WHITE);
 		(void) fprintf(fp, "%s\n", ptr);
+	}
 oomem:
 	h_free(ptr);
 done:
 	(void) fclose(fp);
 	return i;
+}
 /* history_prev_event():
  *	Find the previous event, with number given
  */
 private int
 history_prev_event(TYPE(History) *h, TYPE(HistEvent) *ev, int num)
+{
 	int retval;
 	for (retval = HCURR(h, ev); retval != -1; retval = HPREV(h, ev))
 		if (ev->num == num)
 			return 0;
 	he_seterrev(ev, _HE_NOT_FOUND);
 	return -1;
+}
 private int
 history_next_evdata(TYPE(History) *h, TYPE(HistEvent) *ev, int num, void **d)
+{
 	int retval;
 	for (retval = HCURR(h, ev); retval != -1; retval = HPREV(h, ev))
 		if (ev->num == num) {
 			if (d)
 				*d = ((history_t *)h->h_ref)->cursor->data;
 			return 0;
+		}
 	he_seterrev(ev, _HE_NOT_FOUND);
 	return -1;
+}
 /* history_next_event():
  *	Find the next event, with number given
  */
 private int
 history_next_event(TYPE(History) *h, TYPE(HistEvent) *ev, int num)
+{
 	int retval;
 	for (retval = HCURR(h, ev); retval != -1; retval = HNEXT(h, ev))
 		if (ev->num == num)
 			return 0;
 	he_seterrev(ev, _HE_NOT_FOUND);
 	return -1;
+}
 /* history_prev_string():
  *	Find the previous event beginning with string
  */
 private int
 history_prev_string(TYPE(History) *h, TYPE(HistEvent) *ev, const Char *str)
+{
 	size_t len = Strlen(str);
 	int retval;
 	for (retval = HCURR(h, ev); retval != -1; retval = HNEXT(h, ev))
 		if (Strncmp(str, ev->str, len) == 0)
 			return 0;
 	he_seterrev(ev, _HE_NOT_FOUND);
 	return -1;
+}
 /* history_next_string():
  *	Find the next event beginning with string
  */
 private int
 history_next_string(TYPE(History) *h, TYPE(HistEvent) *ev, const Char *str)
+{
 	size_t len = Strlen(str);
 	int retval;
 	for (retval = HCURR(h, ev); retval != -1; retval = HPREV(h, ev))
 		if (Strncmp(str, ev->str, len) == 0)
 			return 0;
 	he_seterrev(ev, _HE_NOT_FOUND);
 	return -1;
+}
 /* history():
  *	User interface to history functions.
  */
 int
 FUNW(history)(TYPE(History) *h, TYPE(HistEvent) *ev, int fun, ...)
+{
 	va_list va;
 	const Char *str;
 	int retval;
 	va_start(va, fun);
 	he_seterrev(ev, _HE_OK);
 	switch (fun) {
 	case H_GETSIZE:
 		retval = history_getsize(h, ev);
 		break;
 	case H_SETSIZE:
 		retval = history_setsize(h, ev, va_arg(va, int));
 		break;
 	case H_GETUNIQUE:
 		retval = history_getunique(h, ev);
 		break;
 	case H_SETUNIQUE:
 		retval = history_setunique(h, ev, va_arg(va, int));
 		break;
 	case H_ADD:
 		str = va_arg(va, const Char *);
 		retval = HADD(h, ev, str);
 		break;
 	case H_DEL:
 		retval = HDEL(h, ev, va_arg(va, const int));
 		break;
 	case H_ENTER:
 		str = va_arg(va, const Char *);
 		if ((retval = HENTER(h, ev, str)) != -1)
 			h->h_ent = ev->num;
 		break;
 	case H_APPEND:
 		str = va_arg(va, const Char *);
 		if ((retval = HSET(h, ev, h->h_ent)) != -1)
 			retval = HADD(h, ev, str);
 		break;
 	case H_FIRST:
 		retval = HFIRST(h, ev);
 		break;
 	case H_NEXT:
 		retval = HNEXT(h, ev);
 		break;
 	case H_LAST:
 		retval = HLAST(h, ev);
 		break;
 	case H_PREV:
 		retval = HPREV(h, ev);
 		break;
 	case H_CURR:
 		retval = HCURR(h, ev);
 		break;
 	case H_SET:
 		retval = HSET(h, ev, va_arg(va, const int));
 		break;
 	case H_CLEAR:
 		HCLEAR(h, ev);
 		retval = 0;
 		break;
 	case H_LOAD:
 		retval = history_load(h, va_arg(va, const char *));
 		if (retval == -1)
 			he_seterrev(ev, _HE_HIST_READ);
 		break;
 	case H_SAVE:
 		retval = history_save(h, va_arg(va, const char *));
 		if (retval == -1)
 			he_seterrev(ev, _HE_HIST_WRITE);
 		break;
 	case H_PREV_EVENT:
 		retval = history_prev_event(h, ev, va_arg(va, int));
 		break;
 	case H_NEXT_EVENT:
 		retval = history_next_event(h, ev, va_arg(va, int));
 		break;
 	case H_PREV_STR:
 		retval = history_prev_string(h, ev, va_arg(va, const Char *));
 		break;
 	case H_NEXT_STR:
 		retval = history_next_string(h, ev, va_arg(va, const Char *));
 		break;
 	case H_FUNC:
+	{
 		TYPE(History) hf;
 		hf.h_ref = va_arg(va, void *);
 		h->h_ent = -1;
 		hf.h_first = va_arg(va, history_gfun_t);
 		hf.h_next = va_arg(va, history_gfun_t);
 		hf.h_last = va_arg(va, history_gfun_t);
 		hf.h_prev = va_arg(va, history_gfun_t);
 		hf.h_curr = va_arg(va, history_gfun_t);
 		hf.h_set = va_arg(va, history_sfun_t);
 		hf.h_clear = va_arg(va, history_vfun_t);
 		hf.h_enter = va_arg(va, history_efun_t);
 		hf.h_add = va_arg(va, history_efun_t);
 		hf.h_del = va_arg(va, history_sfun_t);

 @@ -1,2257 +1,2261 @@
-/*	$NetBSD: readline.c,v 1.96 2011/07/29 15:16:33 christos Exp $	*/
+/*	$NetBSD: readline.c,v 1.97 2011/07/29 20:58:07 christos Exp $	*/
 /*-
  * Copyright (c) 1997 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jaromir Dolecek.
+ *
  * 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.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
  */
 #include "config.h"
 #if !defined(lint) && !defined(SCCSID)
-__RCSID("$NetBSD: readline.c,v 1.96 2011/07/29 15:16:33 christos Exp $");
+__RCSID("$NetBSD: readline.c,v 1.97 2011/07/29 20:58:07 christos Exp $");
 #endif /* not lint && not SCCSID */
 #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 <unistd.h>
 #include <limits.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <setjmp.h>
 #ifdef HAVE_VIS_H
 #include <vis.h>
 #else
 #include "vis.h"
 #endif
 #include "readline/readline.h"
 #include "el.h"
 #include "fcns.h"		/* for EL_NUM_FCNS */
 #include "histedit.h"
 #include "filecomplete.h"
 void rl_prep_terminal(int);
 void rl_deprep_terminal(void);
 /* for rl_complete() */
 #define TAB		'\r'
 /* see comment at the #ifdef for sense of this */
 /* #define GDB_411_HACK */
 /* readline compatibility stuff - look at readline sources/documentation */
 /* to see what these variables mean */
 const char *rl_library_version = "EditLine wrapper";
 int rl_readline_version = RL_READLINE_VERSION;
 static char empty[] = { '\0' };
 static char expand_chars[] = { ' ', '\t', '\n', '=', '(', '\0' };
 static char break_chars[] = { ' ', '\t', '\n', '"', '\\', '\'', '`', '@', '$',
     '>', '<', '=', ';', '|', '&', '{', '(', '\0' };
 char *rl_readline_name = empty;
 FILE *rl_instream = NULL;
 FILE *rl_outstream = NULL;
 int rl_point = 0;
 int rl_end = 0;
 char *rl_line_buffer = NULL;
 VCPFunction *rl_linefunc = NULL;
 int rl_done = 0;
 VFunction *rl_event_hook = NULL;
 KEYMAP_ENTRY_ARRAY emacs_standard_keymap,
     emacs_meta_keymap,
     emacs_ctlx_keymap;
 int history_base = 1;		/* probably never subject to change */
 int history_length = 0;
 int max_input_history = 0;
 char history_expansion_char = '!';
 char history_subst_char = '^';
 char *history_no_expand_chars = expand_chars;
 Function *history_inhibit_expansion_function = NULL;
 char *history_arg_extract(int start, int end, const char *str);
 int rl_inhibit_completion = 0;
 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;
 CPPFunction *rl_attempted_completion_function = NULL;
 Function *rl_pre_input_hook = NULL;
 Function *rl_startup1_hook = NULL;
 int (*rl_getc_function)(FILE *) = NULL;
 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;
 Function *rl_startup_hook = NULL;
 VFunction *rl_completion_display_matches_hook = NULL;
 VFunction *rl_prep_term_function = (VFunction *)rl_prep_terminal;
 VFunction *rl_deprep_term_function = (VFunction *)rl_deprep_terminal;
 KEYMAP_ENTRY_ARRAY emacs_meta_keymap;
 /*
  * The current prompt string.
  */
 char *rl_prompt = NULL;
 /*
  * This is set to character indicating type of completion being done by
  * rl_complete_internal(); this is available for application completion
  * functions.
  */
 int rl_completion_type = 0;
 /*
  * If more than this number of items results from query for possible
  * completions, we ask user if they are sure to really display the list.
  */
 int rl_completion_query_items = 100;
 /*
  * List of characters which are word break characters, but should be left
  * in the parsed text when it is passed to the completion function.
  * Shell uses this to help determine what kind of completing to do.
  */
 char *rl_special_prefixes = NULL;
 /*
  * This is the character appended to the completed words if at the end of
  * the line. Default is ' ' (a space).
  */
 int rl_completion_append_character = ' ';
 /* stuff below is used internally by libedit for readline emulation */
 static History *h = NULL;
 static EditLine *e = NULL;
 static Function *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 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 void		 _rl_update_pos(void);
 /* ARGSUSED */
 static char *
 _get_prompt(EditLine *el __attribute__((__unused__)))
+{
 	rl_already_prompted = 1;
 	return rl_prompt;
+}
 /*
  * generic function for moving around history
  */
 static HIST_ENTRY *
 _move_history(int op)
+{
 	HistEvent ev;
 	static HIST_ENTRY rl_he;
 	if (history(h, &ev, op) != 0)
 		return NULL;
 	rl_he.line = ev.str;
 	rl_he.data = NULL;
 	return &rl_he;
+}
 /*
  * read one key from user defined input function
  */
 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;
 	return 1;
+}
 static void
 _resize_fun(EditLine *el, void *a)
+{
 	const LineInfo *li;
 	char **ap = a;
 	li = el_line(el);
 	/* a cheesy way to get rid of const cast. */
 	*ap = memchr(li->buffer, *li->buffer, 1);
+}
 static const char _dothistory[] = "/.history";
 static const char *
 _default_history_file(void)
+{
 	struct passwd *p;
 	static char path[PATH_MAX];
 	if (*path)
 		return path;
 	if ((p = getpwuid(getuid())) == NULL)
 		return NULL;
 	strlcpy(path, p->pw_dir, PATH_MAX);
 	strlcat(path, _dothistory, PATH_MAX);
 	return path;
+}
 /*
  * READLINE compatibility stuff
  */
 /*
  * Set the prompt
  */
 int
 rl_set_prompt(const char *prompt)
+{
 	char *p;
 	if (!prompt)
 		prompt = "";
 	if (rl_prompt != NULL && strcmp(rl_prompt, prompt) == 0)
 		return 0;
 	if (rl_prompt)
 		el_free(rl_prompt);
 	rl_prompt = strdup(prompt);
 	if (rl_prompt == NULL)
 		return -1;
 	while ((p = strchr(rl_prompt, RL_PROMPT_END_IGNORE)) != NULL)
 		*p = RL_PROMPT_START_IGNORE;
 	return 0;
+}
 /*
  * initialize rl compat stuff
  */
 int
 rl_initialize(void)
+{
 	HistEvent ev;
 	int editmode = 1;
 	struct termios t;
 	if (e != NULL)
 		el_end(e);
 	if (h != NULL)
 		history_end(h);
 	if (!rl_instream)
 		rl_instream = stdin;
 	if (!rl_outstream)
 		rl_outstream = stdout;
 	/*
 	 * See if we don't really want to run the editor
 	 */
 	if (tcgetattr(fileno(rl_instream), &t) != -1 && (t.c_lflag & ECHO) == 0)
 		editmode = 0;
 	e = el_init(rl_readline_name, rl_instream, rl_outstream, stderr);
 	if (!editmode)
 		el_set(e, EL_EDITMODE, 0);
 	h = history_init();
 	if (!e || !h)
 		return -1;
 	history(h, &ev, H_SETSIZE, INT_MAX);	/* unlimited */
 	history_length = 0;
 	max_input_history = INT_MAX;
 	el_set(e, EL_HIST, history, h);
 	/* Setup resize function */
 	el_set(e, EL_RESIZE, _resize_fun, &rl_line_buffer);
 	/* setup getc function if valid */
 	if (rl_getc_function)
 		el_set(e, EL_GETCFN, _getc_function);
 	/* for proper prompt printing in readline() */
 	if (rl_set_prompt("") == -1) {
 		history_end(h);
 		el_end(e);
 		return -1;
+	}
 	el_set(e, EL_PROMPT, _get_prompt, RL_PROMPT_START_IGNORE);
 	el_set(e, EL_SIGNAL, rl_catch_signals);
 	/* set default mode to "emacs"-style and read setting afterwards */
 	/* so this can be overriden */
 	el_set(e, EL_EDITOR, "emacs");
 	if (rl_terminal_name != NULL)
 		el_set(e, EL_TERMINAL, rl_terminal_name);
 	else
 		el_get(e, EL_TERMINAL, &rl_terminal_name);
 	/*
 	 * Word completion - this has to go AFTER rebinding keys
 	 * to emacs-style.
 	 */
 	el_set(e, EL_ADDFN, "rl_complete",
 	    "ReadLine compatible completion function",
 	    _el_rl_complete);
 	el_set(e, EL_BIND, "^I", "rl_complete", NULL);
 	/*
 	 * Send TSTP when ^Z is pressed.
 	 */
 	el_set(e, EL_ADDFN, "rl_tstp",
 	    "ReadLine compatible suspend function",
 	    _el_rl_tstp);
 	el_set(e, EL_BIND, "^Z", "rl_tstp", NULL);
 	/* read settings from configuration file */
 	el_source(e, NULL);
 	/*
 	 * Unfortunately, some applications really do use rl_point
 	 * and rl_line_buffer directly.
 	 */
 	_resize_fun(e, &rl_line_buffer);
 	_rl_update_pos();
 	if (rl_startup_hook)
 		(*rl_startup_hook)(NULL, 0);
 	return 0;
+}
 /*
  * read one line from input stream and return it, chomping
  * trailing newline (if there is any)
  */
 char *
 readline(const char *p)
+{
 	HistEvent ev;
 	const char * volatile prompt = p;
 	int count;
 	const char *ret;
 	char *buf;
 	static int used_event_hook;
 	if (e == NULL || h == NULL)
 		rl_initialize();
 	rl_done = 0;
 	(void)setjmp(topbuf);
 	/* update prompt accordingly to what has been passed */
 	if (rl_set_prompt(prompt) == -1)
 		return NULL;
 	if (rl_pre_input_hook)
 		(*rl_pre_input_hook)(NULL, 0);
 	if (rl_event_hook && !(e->el_flags&NO_TTY)) {
 		el_set(e, EL_GETCFN, _rl_event_read_char);
 		used_event_hook = 1;
+	}
 	if (!rl_event_hook && used_event_hook) {
 		el_set(e, EL_GETCFN, EL_BUILTIN_GETCFN);
 		used_event_hook = 0;
+	}
 	rl_already_prompted = 0;
 	/* get one line from input stream */
 	ret = el_gets(e, &count);
 	if (ret && count > 0) {
 		int lastidx;
 		buf = strdup(ret);
 		if (buf == NULL)
 			return NULL;
 		lastidx = count - 1;
 		if (buf[lastidx] == '\n')
 			buf[lastidx] = '\0';
 	} else
 		buf = NULL;
 	history(h, &ev, H_GETSIZE);
 	history_length = ev.num;
 	return buf;
+}
 /*
  * history functions
  */
 /*
  * is normally called before application starts to use
  * history expansion functions
  */
 void
 using_history(void)
+{
 	if (h == NULL || e == NULL)
 		rl_initialize();
+}
 /*
  * substitute ``what'' with ``with'', returning resulting string; if
  * globally == 1, substitutes all occurrences of what, otherwise only the
  * first one
  */
 static char *
 _rl_compat_sub(const char *str, const char *what, const char *with,
     int globally)
+{
 	const	char	*s;
 	char	*r, *result;
 	size_t	len, with_len, what_len;
 	len = strlen(str);
 	with_len = strlen(with);
 	what_len = strlen(what);
 	/* calculate length we need for result */
 	s = str;
 	while (*s) {
 		if (*s == *what && !strncmp(s, what, what_len)) {
 			len += with_len - what_len;
 			if (!globally)
 				break;
 			s += what_len;
 		} else
 			s++;
+	}
 	r = result = el_malloc((len + 1) * sizeof(*r));
 	if (result == NULL)
 		return NULL;
 	s = str;
 	while (*s) {
 		if (*s == *what && !strncmp(s, what, what_len)) {
 			(void)strncpy(r, with, with_len);
 			r += with_len;
 			s += what_len;
 			if (!globally) {
 				(void)strcpy(r, s);
 				return result;
+			}
 		} else
 			*r++ = *s++;
+	}
 	*r = '\0';
 	return result;
+}
 static	char	*last_search_pat;	/* last !?pat[?] search pattern */
 static	char	*last_search_match;	/* last !?pat[?] that matched */
 const char *
 get_history_event(const char *cmd, int *cindex, int qchar)
+{
 	int idx, sign, sub, num, begin, ret;
 	size_t len;
 	char	*pat;
 	const char *rptr;
 	HistEvent ev;
 	idx = *cindex;
 	if (cmd[idx++] != history_expansion_char)
 		return NULL;
 	/* find out which event to take */
 	if (cmd[idx] == history_expansion_char || cmd[idx] == '\0') {
 		if (history(h, &ev, H_FIRST) != 0)
 			return NULL;
 		*cindex = cmd[idx]? (idx + 1):idx;
 		return ev.str;
+	}
 	sign = 0;
 	if (cmd[idx] == '-') {
 		sign = 1;
 		idx++;
+	}
 	if ('0' <= cmd[idx] && cmd[idx] <= '9') {
 		HIST_ENTRY *rl_he;
 		num = 0;
 		while (cmd[idx] && '0' <= cmd[idx] && cmd[idx] <= '9') {
 			num = num * 10 + cmd[idx] - '0';
 			idx++;
+		}
 		if (sign)
 			num = history_length - num + 1;
 		if (!(rl_he = history_get(num)))
 			return NULL;
 		*cindex = idx;
 		return rl_he->line;
+	}
 	sub = 0;
 	if (cmd[idx] == '?') {
 		sub = 1;
 		idx++;
+	}
 	begin = idx;
 	while (cmd[idx]) {
 		if (cmd[idx] == '\n')
 			break;
 		if (sub && cmd[idx] == '?')
 			break;
 		if (!sub && (cmd[idx] == ':' || cmd[idx] == ' '
 				    || cmd[idx] == '\t' || cmd[idx] == qchar))
 			break;
 		idx++;
+	}
 	len = idx - 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;
 	else {
 		if ((pat = el_malloc((len + 1) * sizeof(*pat))) == NULL)
 			return NULL;
 		(void)strncpy(pat, cmd + begin, len);
 		pat[len] = '\0';
+	}
 	if (history(h, &ev, H_CURR) != 0) {
 		if (pat != last_search_pat)
 			el_free(pat);
 		return NULL;
+	}
 	num = ev.num;
 	if (sub) {
 		if (pat != last_search_pat) {
 			if (last_search_pat)
 				el_free(last_search_pat);
 			last_search_pat = pat;
+		}
 		ret = history_search(pat, -1);
 	} else
 		ret = history_search_prefix(pat, -1);
 	if (ret == -1) {
 		/* restore to end of list on failed search */
 		history(h, &ev, H_FIRST);
 		(void)fprintf(rl_outstream, "%s: Event not found\n", pat);
 		if (pat != last_search_pat)
 			el_free(pat);
 		return NULL;
+	}
 	if (sub && len) {
 		if (last_search_match && last_search_match != pat)
 			el_free(last_search_match);
 		last_search_match = pat;
+	}
 	if (pat != last_search_pat)
 		el_free(pat);
 	if (history(h, &ev, H_CURR) != 0)
 		return NULL;
 	*cindex = idx;
 	rptr = ev.str;
 	/* roll back to original position */
 	(void)history(h, &ev, H_SET, num);
 	return rptr;
+}
 /*
  * the real function doing history expansion - takes as argument command
  * to do and data upon which the command should be executed
  * does expansion the way I've understood readline documentation
+ *
  * 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
  */
 static int
 _history_expand_command(const char *command, size_t offs, size_t cmdlen,
     char **result)
+{
 	char *tmp, *search = NULL, *aptr;
 	const char *ptr, *cmd;
 	static char *from = NULL, *to = NULL;
 	int start, end, idx, has_mods = 0;
 	int p_on = 0, g_on = 0;
 	*result = NULL;
 	aptr = NULL;
 	ptr = NULL;
 	/* First get event specifier */
 	idx = 0;
 	if (strchr(":^*$", command[offs + 1])) {
 		char str[4];
 		/*
 		* "!:" is shorthand for "!!:".
 		* "!^", "!*" and "!$" are shorthand for
 		* "!!:^", "!!:*" and "!!:$" respectively.
 		*/
 		str[0] = str[1] = '!';
 		str[2] = '0';
 		ptr = get_history_event(str, &idx, 0);
 		idx = (command[offs + 1] == ':')? 1:0;
 		has_mods = 1;
 	} else {
 		if (command[offs + 1] == '#') {
 			/* use command so far */
 			if ((aptr = el_malloc((offs + 1) * sizeof(*aptr)))
 			    == NULL)
 				return -1;
 			(void)strncpy(aptr, command, offs);
 			aptr[offs] = '\0';
 			idx = 1;
 		} else {
 			int	qchar;
 			qchar = (offs > 0 && command[offs - 1] == '"')? '"':0;
 			ptr = get_history_event(command + offs, &idx, qchar);
+		}
 		has_mods = command[offs + idx] == ':';
+	}
 	if (ptr == NULL && aptr == NULL)
 		return -1;
 	if (!has_mods) {
 		*result = strdup(aptr ? aptr : ptr);
 		if (aptr)
 			el_free(aptr);
 		if (*result == NULL)
 			return -1;
 		return 1;
+	}
 	cmd = command + offs + idx + 1;
 	/* Now parse any word designators */
 	if (*cmd == '%')	/* last word matched by ?pat? */
 		tmp = strdup(last_search_match? last_search_match:"");
 	else if (strchr("^*$-0123456789", *cmd)) {
 		start = end = -1;
 		if (*cmd == '^')
 			start = end = 1, cmd++;
 		else if (*cmd == '$')
 			start = -1, cmd++;
 		else if (*cmd == '*')
 			start = 1, cmd++;
 	       else if (*cmd == '-' || isdigit((unsigned char) *cmd)) {
 			start = 0;
 			while (*cmd && '0' <= *cmd && *cmd <= '9')
 				start = start * 10 + *cmd++ - '0';
 			if (*cmd == '-') {
 				if (isdigit((unsigned char) cmd[1])) {
 					cmd++;
 					end = 0;
 					while (*cmd && '0' <= *cmd && *cmd <= '9')
 						end = end * 10 + *cmd++ - '0';
 				} else if (cmd[1] == '$') {
 					cmd += 2;
 					end = -1;
 				} else {
 					cmd++;
 					end = -2;
+				}
 			} else if (*cmd == '*')
 				end = -1, cmd++;
 			else
 				end = start;
+		}
 		tmp = history_arg_extract(start, end, aptr? aptr:ptr);
 		if (tmp == NULL) {
 			(void)fprintf(rl_outstream, "%s: Bad word specifier",
 			    command + offs + idx);
 			if (aptr)
 				el_free(aptr);
 			return -1;
+		}
 	} else
 		tmp = strdup(aptr? aptr:ptr);
 	if (aptr)
 		el_free(aptr);
 	if (*cmd == '\0' || ((size_t)(cmd - (command + offs)) >= cmdlen)) {
 		*result = tmp;
 		return 1;
+	}
 	for (; *cmd; cmd++) {
 		if (*cmd == ':')
 			continue;
 		else if (*cmd == 'h') {		/* remove trailing path */
 			if ((aptr = strrchr(tmp, '/')) != NULL)
 				*aptr = '\0';
 		} else if (*cmd == 't') {	/* remove leading path */
 			if ((aptr = strrchr(tmp, '/')) != NULL) {
 				aptr = strdup(aptr + 1);
 				el_free(tmp);
 				tmp = aptr;
+			}
 		} else if (*cmd == 'r') {	/* remove trailing suffix */
 			if ((aptr = strrchr(tmp, '.')) != NULL)
 				*aptr = '\0';
 		} else if (*cmd == 'e') {	/* remove all but suffix */
 			if ((aptr = strrchr(tmp, '.')) != NULL) {
 				aptr = strdup(aptr);
 				el_free(tmp);
 				tmp = aptr;
+			}
 		} else if (*cmd == 'p')		/* print only */
 			p_on = 1;
 		else if (*cmd == 'g')
 			g_on = 2;
 		else if (*cmd == 's' || *cmd == '&') {
 			char *what, *with, delim;
 			size_t len, from_len;
 			size_t size;
 			if (*cmd == '&' && (from == NULL || to == NULL))
 				continue;
 			else if (*cmd == 's') {
 				delim = *(++cmd), cmd++;
 				size = 16;
 				what = el_realloc(from, size * sizeof(*what));
 				if (what == NULL) {
 					el_free(from);
 					el_free(tmp);
 					return 0;
+				}
 				len = 0;
 				for (; *cmd && *cmd != delim; cmd++) {
 					if (*cmd == '\\' && cmd[1] == delim)
 						cmd++;
 					if (len >= size) {
 						char *nwhat;
 						nwhat = el_realloc(what,
 						    (size <<= 1) *
 						    sizeof(*nwhat));
 						if (nwhat == NULL) {
 							el_free(what);
 							el_free(tmp);
 							return 0;
+						}
 						what = nwhat;
+					}
 					what[len++] = *cmd;
+				}
 				what[len] = '\0';
 				from = what;
 				if (*what == '\0') {
 					el_free(what);
 					if (search) {
 						from = strdup(search);
 						if (from == NULL) {
 							el_free(tmp);
 							return 0;
+						}
 					} else {
 						from = NULL;
 						el_free(tmp);
 						return -1;
+					}
+				}
 				cmd++;	/* shift after delim */
 				if (!*cmd)
 					continue;
 				size = 16;
 				with = el_realloc(to, size * sizeof(*with));
 				if (with == NULL) {
 					el_free(to);
 					el_free(tmp);
 					return -1;
+				}
 				len = 0;
 				from_len = strlen(from);
 				for (; *cmd && *cmd != delim; cmd++) {
 					if (len + from_len + 1 >= size) {
 						char *nwith;
 						size += from_len + 1;
 						nwith = el_realloc(with,
 						    size * sizeof(*nwith));
 						if (nwith == NULL) {
 							el_free(with);
 							el_free(tmp);
 							return -1;
+						}
 						with = nwith;
+					}
 					if (*cmd == '&') {
 						/* safe */
 						(void)strcpy(&with[len], from);
 						len += from_len;
 						continue;
+					}
 					if (*cmd == '\\'
 					    && (*(cmd + 1) == delim
 						|| *(cmd + 1) == '&'))
 						cmd++;
 					with[len++] = *cmd;
+				}
 				with[len] = '\0';
 				to = with;
+			}
 			aptr = _rl_compat_sub(tmp, from, to, g_on);
 			if (aptr) {
 				el_free(tmp);
 				tmp = aptr;
+			}
 			g_on = 0;
+		}
+	}
 	*result = tmp;
 	return p_on? 2:1;
+}
 /*
  * csh-style history expansion
  */
 int
 history_expand(char *str, char **output)
+{
 	int ret = 0;
 	size_t idx, i, size;
 	char *tmp, *result;
 	if (h == NULL || e == NULL)
 		rl_initialize();
 	if (history_expansion_char == 0) {
 		*output = strdup(str);
 		return 0;
+	}
 	*output = NULL;
 	if (str[0] == history_subst_char) {
 		/* ^foo^foo2^ is equivalent to !!:s^foo^foo2^ */
 		*output = el_malloc((strlen(str) + 4 + 1) * sizeof(*output));
 		if (*output == NULL)
 			return 0;
 		(*output)[0] = (*output)[1] = history_expansion_char;
 		(*output)[2] = ':';
 		(*output)[3] = 's';
 		(void)strcpy((*output) + 4, str);
 		str = *output;
 	} else {
 		*output = strdup(str);
 		if (*output == NULL)
 			return 0;
+	}
 #define ADD_STRING(what, len, fr)					\
 	{								\
 		if (idx + len + 1 > size) {				\
 			char *nresult = el_realloc(result,		\
 			    (size += len + 1) * sizeof(*nresult));	\
 			if (nresult == NULL) {				\
 				el_free(*output);			\
 				if (/*CONSTCOND*/fr)			\
 					el_free(tmp);			\
 				return 0;				\
 			}						\
 			result = nresult;				\
 		}							\
 		(void)strncpy(&result[idx], what, len);			\
 		idx += len;						\
 		result[idx] = '\0';					\
+	}
 	result = NULL;
 	size = idx = 0;
 	tmp = NULL;
 	for (i = 0; str[i];) {
 		int qchar, loop_again;
 		size_t len, start, j;
 		qchar = 0;
 		loop_again = 1;
 		start = j = i;
 loop:
 		for (; str[j]; j++) {
 			if (str[j] == '\\' &&
 			    str[j + 1] == history_expansion_char) {
 				(void)strcpy(&str[j], &str[j + 1]);
 				continue;
+			}
 			if (!loop_again) {
 				if (isspace((unsigned char) str[j])
 				    || str[j] == qchar)
 					break;
+			}
 			if (str[j] == history_expansion_char
 			    && !strchr(history_no_expand_chars, str[j + 1])
 			    && (!history_inhibit_expansion_function ||
 			    (*history_inhibit_expansion_function)(str,
 			    (int)j) == 0))
 				break;
+		}
 		if (str[j] && loop_again) {
 			i = j;
 			qchar = (j > 0 && str[j - 1] == '"' )? '"':0;
 			j++;
 			if (str[j] == history_expansion_char)
 				j++;
 			loop_again = 0;
 			goto loop;
+		}
 		len = i - start;
 		ADD_STRING(&str[start], len, 0);
 		if (str[i] == '\0' || str[i] != history_expansion_char) {
 			len = j - i;
 			ADD_STRING(&str[i], len, 0);
 			if (start == 0)
 				ret = 0;
 			else
 				ret = 1;
 			break;
+		}
 		ret = _history_expand_command (str, i, (j - i), &tmp);
 		if (ret > 0 && tmp) {
 			len = strlen(tmp);
 			ADD_STRING(tmp, len, 1);
+		}
 		if (tmp) {
 			el_free(tmp);
 			tmp = NULL;
+		}
 		i = j;
+	}
 	/* ret is 2 for "print only" option */
 	if (ret == 2) {
 		add_history(result);
 #ifdef GDB_411_HACK
 		/* gdb 4.11 has been shipped with readline, where */
 		/* history_expand() returned -1 when the line	  */
 		/* should not be executed; in readline 2.1+	  */
 		/* it should return 2 in such a case		  */
 		ret = -1;
 #endif
+	}
 	el_free(*output);
 	*output = result;
 	return ret;
+}
 /*
 * Return a string consisting of arguments of "str" from "start" to "end".
 */
 char *
 history_arg_extract(int start, int end, const char *str)
+{
 	size_t  i, len, max;
 	char	**arr, *result = NULL;
 	arr = history_tokenize(str);
 	if (!arr)
 		return NULL;
 	if (arr && *arr == NULL)
 		goto out;
 	for (max = 0; arr[max]; max++)
 		continue;
 	max--;
 	if (start == '$')
 		start = (int)max;
 	if (end == '$')
 		end = (int)max;
 	if (end < 0)
 		end = (int)max + end + 1;
 	if (start < 0)
 		start = end;
 	if (start < 0 || end < 0 || (size_t)start > max ||
 	    (size_t)end > max || start > end)
 		goto out;
 	for (i = start, len = 0; i <= (size_t)end; i++)
 		len += strlen(arr[i]) + 1;
 	len++;
 	result = el_malloc(len * sizeof(*result));
 	if (result == NULL)
 		goto out;
 	for (i = start, len = 0; i <= (size_t)end; i++) {
 		(void)strcpy(result + len, arr[i]);
 		len += strlen(arr[i]);
 		if (i < (size_t)end)
 			result[len++] = ' ';
+	}
 	result[len] = '\0';
 out:
 	for (i = 0; arr[i]; i++)
 		el_free(arr[i]);
 	el_free(arr);
 	return result;
+}
 /*
  * Parse the string into individual tokens,
  * similar to how shell would do it.
  */
 char **
 history_tokenize(const char *str)
+{
 	int size = 1, idx = 0, i, start;
 	size_t len;
 	char **result = NULL, *temp, delim = '\0';
 	for (i = 0; str[i];) {
 		while (isspace((unsigned char) str[i]))
 			i++;
 		start = i;
 		for (; str[i];) {
 			if (str[i] == '\\') {
 				if (str[i+1] != '\0')
 					i++;
 			} else if (str[i] == delim)
 				delim = '\0';
 			else if (!delim &&
 				    (isspace((unsigned char) str[i]) ||
 				strchr("()<>;&|$", str[i])))
 				break;
 			else if (!delim && strchr("'`\"", str[i]))
 				delim = str[i];
 			if (str[i])
 				i++;
+		}
 		if (idx + 2 >= size) {
 			char **nresult;
 			size <<= 1;
 			nresult = el_realloc(result, size * sizeof(*nresult));
 			if (nresult == NULL) {
 				el_free(result);
 				return NULL;
+			}
 			result = nresult;
+		}
 		len = i - start;
 		temp = el_malloc((len + 1) * sizeof(*temp));
 		if (temp == NULL) {
 			for (i = 0; i < idx; i++)
 				el_free(result[i]);
 			el_free(result);
 			return NULL;
+		}
 		(void)strncpy(temp, &str[start], len);
 		temp[len] = '\0';
 		result[idx++] = temp;
 		result[idx] = NULL;
 		if (str[i])
 			i++;
+	}
 	return result;
+}
 /*
  * limit size of history record to ``max'' events
  */
 void
 stifle_history(int max)
+{
 	HistEvent ev;
 	if (h == NULL || e == NULL)
 		rl_initialize();
 	if (history(h, &ev, H_SETSIZE, max) == 0)
 		max_input_history = max;
+}
 /*
  * "unlimit" size of history - set the limit to maximum allowed int value
  */
 int
 unstifle_history(void)
+{
 	HistEvent ev;
 	int omax;
 	history(h, &ev, H_SETSIZE, INT_MAX);
 	omax = max_input_history;
 	max_input_history = INT_MAX;
 	return omax;		/* some value _must_ be returned */
+}
 int
 history_is_stifled(void)
+{
 	/* cannot return true answer */
 	return max_input_history != INT_MAX;
+}
 static const char _history_tmp_template[] = "/tmp/.historyXXXXXX";
 int
 history_truncate_file (const char *filename, int nlines)
+{
 	int ret = 0;
 	FILE *fp, *tp;
 	char template[sizeof(_history_tmp_template)];
 	char buf[4096];
 	int fd;
 	char *cp;
 	off_t off;
 	int count = 0;
 	ssize_t left = 0;
 	if (filename == NULL && (filename = _default_history_file()) == NULL)
 		return errno;
 	if ((fp = fopen(filename, "r+")) == NULL)
 		return errno;
 	strcpy(template, _history_tmp_template);
 	if ((fd = mkstemp(template)) == -1) {
 		ret = errno;
 		goto out1;
+	}
 	if ((tp = fdopen(fd, "r+")) == NULL) {
 		close(fd);
 		ret = errno;
 		goto out2;
+	}
 	for(;;) {
 		if (fread(buf, sizeof(buf), 1, fp) != 1) {
 			if (ferror(fp)) {
 				ret = errno;
 				break;
+			}
 			if (fseeko(fp, (off_t)sizeof(buf) * count, SEEK_SET) ==
 			    (off_t)-1) {
 				ret = errno;
 				break;
+			}
 			left = fread(buf, 1, sizeof(buf), fp);
 			if (ferror(fp)) {
 				ret = errno;
 				break;
+			}
 			if (left == 0) {
 				count--;
 				left = sizeof(buf);
 			} else if (fwrite(buf, (size_t)left, 1, tp) != 1) {
 				ret = errno;
 				break;
+			}
 			fflush(tp);
 			break;
+		}
 		if (fwrite(buf, sizeof(buf), 1, tp) != 1) {
 			ret = errno;
 			break;
+		}
 		count++;
+	}
 	if (ret)
 		goto out3;
 	cp = buf + left - 1;
 	if(*cp != '\n')
 		cp++;
 	for(;;) {
 		while (--cp >= buf) {
 			if (*cp == '\n') {
 				if (--nlines == 0) {
 					if (++cp >= buf + sizeof(buf)) {
 						count++;
 						cp = buf;
+					}
 					break;
+				}
+			}
+		}
 		if (nlines <= 0 || count == 0)
 			break;
 		count--;
 		if (fseeko(tp, (off_t)sizeof(buf) * count, SEEK_SET) < 0) {
 			ret = errno;
 			break;
+		}
 		if (fread(buf, sizeof(buf), 1, tp) != 1) {
 			if (ferror(tp)) {
 				ret = errno;
 				break;
+			}
 			ret = EAGAIN;
 			break;
+		}
 		cp = buf + sizeof(buf);
+	}
 	if (ret || nlines > 0)
 		goto out3;
 	if (fseeko(fp, 0, SEEK_SET) == (off_t)-1) {
 		ret = errno;
 		goto out3;
+	}
 	if (fseeko(tp, (off_t)sizeof(buf) * count + (cp - buf), SEEK_SET) ==
 	    (off_t)-1) {
 		ret = errno;
 		goto out3;
+	}
 	for(;;) {
 		if ((left = fread(buf, 1, sizeof(buf), tp)) == 0) {
 			if (ferror(fp))
 				ret = errno;
 			break;
+		}
 		if (fwrite(buf, (size_t)left, 1, fp) != 1) {
 			ret = errno;
 			break;
+		}
+	}
 	fflush(fp);
 	if((off = ftello(fp)) > 0)
 		(void)ftruncate(fileno(fp), off);
 out3:
 	fclose(tp);
 out2:
 	unlink(template);
 out1:
 	fclose(fp);
 	return ret;
+}
 /*
  * read history from a file given
  */
 int
 read_history(const char *filename)
+{
 	HistEvent ev;
 	if (h == NULL || e == NULL)
 		rl_initialize();
 	if (filename == NULL && (filename = _default_history_file()) == NULL)
 		return errno;
 	return history(h, &ev, H_LOAD, filename) == -1 ?
 	    (errno ? errno : EINVAL) : 0;
+}
 /*
  * write history to a file given
  */
 int
 write_history(const char *filename)
+{
 	HistEvent ev;
 	if (h == NULL || e == NULL)
 		rl_initialize();
 	if (filename == NULL && (filename = _default_history_file()) == NULL)
 		return errno;
 	return history(h, &ev, H_SAVE, filename) == -1 ?
 	    (errno ? errno : EINVAL) : 0;
+}
 /*
  * returns history ``num''th event
+ *
  * returned pointer points to static variable
  */
 HIST_ENTRY *
 history_get(int num)
+{
 	static HIST_ENTRY she;
 	HistEvent ev;
 	int curr_num;
 	if (h == NULL || e == NULL)
 		rl_initialize();
 	/* save current position */
 	if (history(h, &ev, H_CURR) != 0)
 		return NULL;
 	curr_num = ev.num;
 	/* start from the oldest */
 	if (history(h, &ev, H_LAST) != 0)
 		return NULL;	/* error */
 	/* look forwards for event matching specified offset */
 	if (history(h, &ev, H_NEXT_EVDATA, num, &she.data))
 		return NULL;
 	she.line = ev.str;
 	/* restore pointer to where it was */
 	(void)history(h, &ev, H_SET, curr_num);
 	return &she;
+}
 /*
  * add the line to history table
  */
 int
 add_history(const char *line)
+{
 	HistEvent ev;
 	if (h == NULL || e == NULL)
 		rl_initialize();
 	(void)history(h, &ev, H_ENTER, line);
 	if (history(h, &ev, H_GETSIZE) == 0)
 		history_length = ev.num;
 	return !(history_length > 0); /* return 0 if all is okay */
+}
 /*
  * remove the specified entry from the history list and return it.
  */
 HIST_ENTRY *
 remove_history(int num)
+{
 	HIST_ENTRY *he;
 	HistEvent ev;
 	if (h == NULL || e == NULL)
 		rl_initialize();
 	if ((he = el_malloc(sizeof(*he))) == NULL)
 		return NULL;
 	if (history(h, &ev, H_DELDATA, num, &he->data) != 0) {
 		el_free(he);
 		return NULL;
+	}
 	he->line = ev.str;
 	if (history(h, &ev, H_GETSIZE) == 0)
 		history_length = ev.num;
 	return he;
+}
 /*
  * replace the line and data of the num-th entry
  */
 HIST_ENTRY *
 replace_history_entry(int num, const char *line, histdata_t data)
+{
 	HIST_ENTRY *he;
 	HistEvent ev;
 	int curr_num;
 	if (h == NULL || e == NULL)
 		rl_initialize();
 	/* save current position */
 	if (history(h, &ev, H_CURR) != 0)
 		return NULL;
 	curr_num = ev.num;
 	/* start from the oldest */
 	if (history(h, &ev, H_LAST) != 0)
 		return NULL;	/* error */
 	if ((he = el_malloc(sizeof(*he))) == NULL)
 		return NULL;
 	/* look forwards for event matching specified offset */
 	if (history(h, &ev, H_NEXT_EVDATA, num, &he->data))
 		goto out;
 	he->line = strdup(ev.str);
 	if (he->line == NULL)
 		goto out;
 	if (history(h, &ev, H_REPLACE, line, data))
 		goto out;
 	/* restore pointer to where it was */
 	if (history(h, &ev, H_SET, curr_num))
 		goto out;
 	return he;
 out:
 	el_free(he);
 	return NULL;
+}
 /*
  * clear the history list - delete all entries
  */
 void
 clear_history(void)
+{
 	HistEvent ev;
 	(void)history(h, &ev, H_CLEAR);
 	history_length = 0;
+}
 /*
  * returns offset of the current history event
  */
 int
 where_history(void)
+{
 	HistEvent ev;
 	int curr_num, off;
 	if (history(h, &ev, H_CURR) != 0)
 		return 0;
 	curr_num = ev.num;
 	(void)history(h, &ev, H_FIRST);
 	off = 1;
 	while (ev.num != curr_num && history(h, &ev, H_NEXT) == 0)
 		off++;
 	return off;
+}
 /*
  * returns current history event or NULL if there is no such event
  */
 HIST_ENTRY *
 current_history(void)
+{
 	return _move_history(H_CURR);
+}
 /*
  * returns total number of bytes history events' data are using
  */
 int
 history_total_bytes(void)
+{
 	HistEvent ev;
 	int curr_num;
 	size_t size;
 	if (history(h, &ev, H_CURR) != 0)
 		return -1;
 	curr_num = ev.num;
 	(void)history(h, &ev, H_FIRST);
 	size = 0;
 	do
 		size += strlen(ev.str) * sizeof(*ev.str);
 	while (history(h, &ev, H_NEXT) == 0);
 	/* get to the same position as before */
 	history(h, &ev, H_PREV_EVENT, curr_num);
 	return (int)size;
+}
 /*
  * sets the position in the history list to ``pos''
  */
 int
 history_set_pos(int pos)
+{
 	HistEvent ev;
 	int curr_num;
 	if (pos >= history_length || pos < 0)
 		return -1;
 	(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 (history(h, &ev, H_DELDATA, pos, (void **)-1)) {
 		(void)history(h, &ev, H_SET, curr_num);
 		return -1;
+	}
 	return 0;
+}
 /*
  * returns previous event in history and shifts pointer accordingly
  */
 HIST_ENTRY *
 previous_history(void)
+{
 	return _move_history(H_PREV);
+}
 /*
  * returns next event in history and shifts pointer accordingly
  */
 HIST_ENTRY *
 next_history(void)
+{
 	return _move_history(H_NEXT);
+}
 /*
  * searches for first history event containing the str
  */
 int
 history_search(const char *str, int direction)
+{
 	HistEvent ev;
 	const char *strp;
 	int curr_num;
 	if (history(h, &ev, H_CURR) != 0)
 		return -1;
 	curr_num = ev.num;
 	for (;;) {
 		if ((strp = strstr(ev.str, str)) != NULL)
 			return (int)(strp - ev.str);
 		if (history(h, &ev, direction < 0 ? H_NEXT:H_PREV) != 0)
 			break;
+	}
 	(void)history(h, &ev, H_SET, curr_num);
 	return -1;
+}
 /*
  * searches for first history event beginning with str
  */
 int
 history_search_prefix(const char *str, int direction)
+{
 	HistEvent ev;
 	return (history(h, &ev, direction < 0 ?
 	    H_PREV_STR : H_NEXT_STR, str));
+}
 /*
  * search for event in history containing str, starting at offset
  * abs(pos); continue backward, if pos<0, forward otherwise
  */
 /* ARGSUSED */
 int
 history_search_pos(const char *str,
 		   int direction __attribute__((__unused__)), int pos)
+{
 	HistEvent ev;
 	int curr_num, off;
 	off = (pos > 0) ? pos : -pos;
 	pos = (pos > 0) ? 1 : -1;
 	if (history(h, &ev, H_CURR) != 0)
 		return -1;
 	curr_num = ev.num;
 	if (history_set_pos(off) != 0 || history(h, &ev, H_CURR) != 0)
 		return -1;
 	for (;;) {
 		if (strstr(ev.str, str))
 			return off;
 		if (history(h, &ev, (pos < 0) ? H_PREV : H_NEXT) != 0)
 			break;
+	}
 	/* set "current" pointer back to previous state */
 	(void)history(h, &ev,
 	    pos < 0 ? H_NEXT_EVENT : H_PREV_EVENT, curr_num);
 	return -1;
+}
 /********************************/
 /* completion functions */
 char *
 tilde_expand(char *name)
+{
 	return fn_tilde_expand(name);
+}
 char *
 filename_completion_function(const char *name, int state)
+{
 	return fn_filename_completion_function(name, state);
+}
 /*
  * a completion generator for usernames; returns _first_ username
  * 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
  */
 char *
 username_completion_function(const char *text, int state)
+{
 #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;
 	if (*text == '~')
 		text++;
 	if (state == 0)
 		setpwent();
 	while (
 #if defined(HAVE_GETPW_R_POSIX) || defined(HAVE_GETPW_R_DRAFT)
 	    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 (pass == NULL) {
 		endpwent();
 		return NULL;
+	}
 	return strdup(pass->pw_name);
+}
 /*
  * el-compatible wrapper to send TSTP on ^Z
  */
 /* ARGSUSED */
 static unsigned char
 _el_rl_tstp(EditLine *el __attribute__((__unused__)), int ch __attribute__((__unused__)))
+{
 	(void)kill(0, SIGTSTP);
 	return CC_NORM;
+}
 /*
  * Display list of strings in columnar format on readline's output stream.
  * 'matches' is list of strings, 'len' is number of strings in 'matches',
  * 'max' is maximum length of string in 'matches'.
  */
 void
 rl_display_match_list(char **matches, int len, int max)
+{
 	fn_display_match_list(e, matches, (size_t)len, (size_t)max);
+}
 static const char *
 /*ARGSUSED*/
 _rl_completion_append_character_function(const char *dummy
     __attribute__((__unused__)))
+{
 	static char buf[2];
 	buf[0] = rl_completion_append_character;
 	buf[1] = '\0';
 	return buf;
+}
 /*
  * complete word at current point
  */
 /* ARGSUSED */
 int
 rl_complete(int ignore __attribute__((__unused__)), int invoking_key)
+{
 #ifdef WIDECHAR
 	static ct_buffer_t wbreak_conv, sprefix_conv;
 #endif
 	if (h == NULL || e == NULL)
 		rl_initialize();
 	if (rl_inhibit_completion) {
 		char arr[2];
 		arr[0] = (char)invoking_key;
 		arr[1] = '\0';
 		el_insertstr(e, arr);
 		return CC_REFRESH;
+	}
 	/* Just look at how many global variables modify this operation! */
 	return fn_complete(e,
 	    (CPFunction *)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),
 	    _rl_completion_append_character_function,
 	    (size_t)rl_completion_query_items,
 	    &rl_completion_type, &rl_attempted_completion_over,
 	    &rl_point, &rl_end);
+}
 /* ARGSUSED */
 static unsigned char
 _el_rl_complete(EditLine *el __attribute__((__unused__)), int ch)
+{
 	return (unsigned char)rl_complete(0, ch);
+}
 /*
  * misc other functions
  */
 /*
  * bind key c to readline-type function func
  */
 int
 rl_bind_key(int c, rl_command_func_t *func)
+{
 	int retval = -1;
 	if (h == NULL || e == NULL)
 		rl_initialize();
 	if (func == rl_insert) {
 		/* XXX notice there is no range checking of ``c'' */
 		e->el_map.key[c] = ED_INSERT;
 		retval = 0;
+	}
 	return retval;
+}
 /*
  * read one key from input - handles chars pushed back
  * to input stream also
  */
 int
 rl_read_key(void)
+{
 	char fooarr[2 * sizeof(int)];
 	if (e == NULL || h == NULL)
 		rl_initialize();
 	return el_getc(e, fooarr);
+}
 /*
  * reset the terminal
  */
 /* ARGSUSED */
 void
 rl_reset_terminal(const char *p __attribute__((__unused__)))
+{
 	if (h == NULL || e == NULL)
 		rl_initialize();
 	el_reset(e);
+}
 /*
  * insert character ``c'' back into input stream, ``count'' times
  */
 int
 rl_insert(int count, int c)
+{
 	char arr[2];
 	if (h == NULL || e == NULL)
 		rl_initialize();
 	/* XXX - int -> char conversion can lose on multichars */
 	arr[0] = c;
 	arr[1] = '\0';
 	for (; count > 0; count--)
 		el_push(e, arr);
 	return 0;
+}
 int
 rl_insert_text(const char *text)
+{
 	if (!text || *text == 0)
 		return 0;
 	if (h == NULL || e == NULL)
 		rl_initialize();
 	if (el_insertstr(e, text) < 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.
 	 */
 	return rl_insert(1, '\n');
+}
 /*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;
 	_rl_update_pos();
 	(*map[c])(NULL, c);
 	/* If rl_done was set by the above call, deal with it here */
 	if (rl_done)
 		return CC_EOF;
 	return CC_NORM;
+}
 int
 rl_add_defun(const char *name, Function *fun, int c)
+{
 	char dest[8];
 	if ((size_t)c >= sizeof(map) / sizeof(map[0]) || c < 0)
 		return -1;
 	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);
 	return 0;
+}
 void
 rl_callback_read_char()
+{
 	int count = 0, done = 0;
 	const char *buf = el_gets(e, &count);
 	char *wbuf;
 	if (buf == NULL || count-- <= 0)
 		return;
 	if (count == 0 && buf[0] == e->el_tty.t_c[TS_IO][C_EOF])
 		done = 1;
 	if (buf[count] == '\n' || buf[count] == '\r')
 		done = 2;
 	if (done && rl_linefunc != NULL) {
 		el_set(e, EL_UNBUFFERED, 0);
 		if (done == 2) {
 		    if ((wbuf = strdup(buf)) != NULL)
 			wbuf[count] = '\0';
 		} else
 			wbuf = NULL;
 		(*(void (*)(const char *))rl_linefunc)(wbuf);
 		//el_set(e, EL_UNBUFFERED, 1);
+	}
+}
 void
 rl_callback_handler_install(const char *prompt, VCPFunction *linefunc)
+{
 	if (e == NULL) {
 		rl_initialize();
+	}
 	(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);
 	rl_linefunc = NULL;
+}
 void
 rl_redisplay(void)
+{
 	char a[2];
 	a[0] = e->el_tty.t_c[TS_IO][C_REPRINT];
 	a[1] = '\0';
 	el_push(e, a);
+}
 int
 rl_get_previous_history(int count, int key)
+{
 	char a[2];
 	a[0] = key;
 	a[1] = '\0';
 	while (count--)
 		el_push(e, a);
 	return 0;
+}
 void
 /*ARGSUSED*/
-rl_prep_terminal(int meta_flag)
+rl_prep_terminal(int meta_flag __attribute__((__unused__)))
+{
 	el_set(e, EL_PREP_TERM, 1);
+}
 void
 rl_deprep_terminal(void)
+{
 	el_set(e, EL_PREP_TERM, 0);
+}
 int
 rl_read_init_file(const char *s)
+{
 	return el_source(e, s);
+}
 int
 rl_parse_and_bind(const char *line)
+{
 	const char **argv;
 	int argc;
 	Tokenizer *tok;
 	tok = tok_init(NULL);
 	tok_str(tok, line, &argc, &argv);
 	argc = el_parse(e, argc, argv);
 	tok_end(tok);
 	return argc ? 1 : 0;
+}
 int
 rl_variable_bind(const char *var, const char *value)
+{
 	/*
 	 * 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;
+}
 void
 rl_stuff_char(int c)
+{
 	char buf[2];
 	buf[0] = c;
 	buf[1] = '\0';
 	el_insertstr(e, buf);
+}
 static int
 _rl_event_read_char(EditLine *el, char *cp)
+{
 	int	n;
 	ssize_t num_read = 0;
 	*cp = '\0';
 	while (rl_event_hook) {
 		(*rl_event_hook)();
 #if defined(FIONREAD)
 		if (ioctl(el->el_infd, FIONREAD, &n) < 0)
 			return -1;
 		if (n)
 			num_read = read(el->el_infd, cp, 1);
 		else
 			num_read = 0;
 #elif defined(F_SETFL) && defined(O_NDELAY)
 		if ((n = fcntl(el->el_infd, F_GETFL, 0)) < 0)
 			return -1;
 		if (fcntl(el->el_infd, F_SETFL, n|O_NDELAY) < 0)
 			return -1;
 		num_read = read(el->el_infd, cp, 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);
 		return -1;
 #endif
 		if (num_read < 0 && errno == EAGAIN)
 			continue;
 		if (num_read == 0)
 			continue;
 		break;
+	}
 	if (!rl_event_hook)
 		el_set(el, EL_GETCFN, EL_BUILTIN_GETCFN);
 	return (int)num_read;
+}
 static void
 _rl_update_pos(void)
+{
 	const LineInfo *li = el_line(e);
 	rl_point = (int)(li->cursor - li->buffer);
 	rl_end = (int)(li->lastchar - li->buffer);
+}
 void
 rl_get_screen_size(int *rows, int *cols)
+{
 	if (rows)
 		el_get(e, EL_GETTC, "li", rows);
 	if (cols)
 		el_get(e, EL_GETTC, "co", cols);
+}
 void
 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);
 	(void)snprintf(buf, sizeof(buf), "%d", cols);
 	el_set(e, EL_SETTC, "co", buf);
+}
 char **
 rl_completion_matches(const char *str, rl_compentry_func_t *fun)
+{
 	size_t len, max, i, j, min;
 	char **list, *match, *a, *b;
 	len = 1;
 	max = 10;
 	if ((list = el_malloc(max * sizeof(*list))) == NULL)
 		return NULL;
 	while ((match = (*fun)(str, (int)(len - 1))) != NULL) {
 		list[len++] = match;
 		if (len == max) {
 			char **nl;
 			max += 10;
 			if ((nl = el_realloc(list, max * sizeof(*nl))) == NULL)
 				goto out;
 			list = nl;
+		}
+	}
 	if (len == 1)
 		goto out;
 	list[len] = NULL;
 	if (len == 2) {
 		if ((list[0] = strdup(list[1])) == NULL)
 			goto out;
 		return list;
+	}
 	qsort(&list[1], len - 1, sizeof(*list),
 	    (int (*)(const void *, const void *)) strcmp);
 	min = SIZE_T_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++)
 			continue;
 		if (min > j)
 			min = j;
+	}
 	if (min == 0 && *str) {
 		if ((list[0] = strdup(str)) == NULL)
 			goto out;
 	} else {
 		if ((list[0] = el_malloc((min + 1) * sizeof(*list[0]))) == NULL)
 			goto out;
 		(void)memcpy(list[0], list[1], min);
 		list[0][min] = '\0';
+	}
 	return list;
 out:
 	el_free(list);
 	return NULL;
+}
 char *
 rl_filename_completion_function (const char *text, int state)
+{
 	return fn_filename_completion_function(text, state);
+}
 void
 rl_forced_update_display(void)
+{
 	el_set(e, EL_REFRESH);
+}
 int
 _rl_abort_internal(void)
+{
 	el_beep(e);
 	longjmp(topbuf, 1);
 	/*NOTREACHED*/
+}
 int
 _rl_qsort_string_compare(char **s1, char **s2)
+{
 	return strcoll(*s1, *s2);
+}
 HISTORY_STATE *
 history_get_history_state(void)
+{
 	HISTORY_STATE *hs;
 	if ((hs = el_malloc(sizeof(*hs))) == NULL)
 		return NULL;
 	hs->length = history_length;
 	return hs;
+}
 int
 /*ARGSUSED*/
-rl_kill_text(int from, int to)
+rl_kill_text(int from __attribute__((__unused__)),
     int to __attribute__((__unused__)))
+{
 	return 0;
+}
 Keymap
 rl_make_bare_keymap(void)
+{
 	return NULL;
+}
 Keymap
 rl_get_keymap(void)
+{
 	return NULL;
+}
 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;
+}
 /* unsupported, but needed by python */
 void
 rl_cleanup_after_signal(void)
+{
+}
 int
 rl_on_new_line(void)
+{
 	return 0;
+}

 @@ -1,1161 +1,1161 @@
-/*	$NetBSD: vi.c,v 1.37 2011/07/29 15:16:33 christos Exp $	*/
+/*	$NetBSD: vi.c,v 1.38 2011/07/29 20:58:07 christos Exp $	*/
 /*-
  * 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.
  */
 #include "config.h"
 #include <stdlib.h>
 #include <unistd.h>
 #include <limits.h>
 #include <sys/wait.h>
 #if !defined(lint) && !defined(SCCSID)
 #if 0
 static char sccsid[] = "@(#)vi.c	8.1 (Berkeley) 6/4/93";
 #else
-__RCSID("$NetBSD: vi.c,v 1.37 2011/07/29 15:16:33 christos Exp $");
+__RCSID("$NetBSD: vi.c,v 1.38 2011/07/29 20:58:07 christos Exp $");
 #endif
 #endif /* not lint && not SCCSID */
 /*
  * vi.c: Vi mode commands.
  */
 #include "el.h"
 private el_action_t	cv_action(EditLine *, Int);
 private el_action_t	cv_paste(EditLine *, Int);
 /* cv_action():
  *	Handle vi actions.
  */
 private el_action_t
 cv_action(EditLine *el, Int c)
+{
 	if (el->el_chared.c_vcmd.action != NOP) {
 		/* 'cc', 'dd' and (possibly) friends */
 		if (c != el->el_chared.c_vcmd.action)
 			return CC_ERROR;
 		if (!(c & YANK))
 			cv_undo(el);
 		cv_yank(el, el->el_line.buffer,
 		    (int)(el->el_line.lastchar - el->el_line.buffer));
 		el->el_chared.c_vcmd.action = NOP;
 		el->el_chared.c_vcmd.pos = 0;
 		if (!(c & YANK)) {
 			el->el_line.lastchar = el->el_line.buffer;
 			el->el_line.cursor = el->el_line.buffer;
+		}
 		if (c & INSERT)
 			el->el_map.current = el->el_map.key;
 		return CC_REFRESH;
+	}
 	el->el_chared.c_vcmd.pos = el->el_line.cursor;
 	el->el_chared.c_vcmd.action = c;
 	return CC_ARGHACK;
+}
 /* cv_paste():
  *	Paste previous deletion before or after the cursor
  */
 private el_action_t
 cv_paste(EditLine *el, Int c)
+{
 	c_kill_t *k = &el->el_chared.c_kill;
 	size_t len = (size_t)(k->last - k->buf);
 	if (k->buf == NULL || len == 0)
 		return CC_ERROR;
 #ifdef DEBUG_PASTE
 	(void) fprintf(el->el_errfile, "Paste: \"%.*s\"\n", (int)len, k->buf);
 #endif
 	cv_undo(el);
 	if (!c && el->el_line.cursor < el->el_line.lastchar)
 		el->el_line.cursor++;
 	c_insert(el, (int)len);
 	if (el->el_line.cursor + len > el->el_line.lastchar)
 		return CC_ERROR;
 	(void) memcpy(el->el_line.cursor, k->buf, len *
 	    sizeof(*el->el_line.cursor));
 	return CC_REFRESH;
+}
 /* vi_paste_next():
  *	Vi paste previous deletion to the right of the cursor
  *	[p]
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_paste_next(EditLine *el, Int c __attribute__((__unused__)))
+{
 	return cv_paste(el, 0);
+}
 /* vi_paste_prev():
  *	Vi paste previous deletion to the left of the cursor
  *	[P]
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_paste_prev(EditLine *el, Int c __attribute__((__unused__)))
+{
 	return cv_paste(el, 1);
+}
 /* vi_prev_big_word():
  *	Vi move to the previous space delimited word
  *	[B]
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_prev_big_word(EditLine *el, Int c __attribute__((__unused__)))
+{
 	if (el->el_line.cursor == el->el_line.buffer)
 		return CC_ERROR;
 	el->el_line.cursor = cv_prev_word(el->el_line.cursor,
 	    el->el_line.buffer,
 	    el->el_state.argument,
 	    cv__isWord);
 	if (el->el_chared.c_vcmd.action != NOP) {
 		cv_delfini(el);
 		return CC_REFRESH;
+	}
 	return CC_CURSOR;
+}
 /* vi_prev_word():
  *	Vi move to the previous word
  *	[b]
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_prev_word(EditLine *el, Int c __attribute__((__unused__)))
+{
 	if (el->el_line.cursor == el->el_line.buffer)
 		return CC_ERROR;
 	el->el_line.cursor = cv_prev_word(el->el_line.cursor,
 	    el->el_line.buffer,
 	    el->el_state.argument,
 	    cv__isword);
 	if (el->el_chared.c_vcmd.action != NOP) {
 		cv_delfini(el);
 		return CC_REFRESH;
+	}
 	return CC_CURSOR;
+}
 /* vi_next_big_word():
  *	Vi move to the next space delimited word
  *	[W]
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_next_big_word(EditLine *el, Int c __attribute__((__unused__)))
+{
 	if (el->el_line.cursor >= el->el_line.lastchar - 1)
 		return CC_ERROR;
 	el->el_line.cursor = cv_next_word(el, el->el_line.cursor,
 	    el->el_line.lastchar, el->el_state.argument, cv__isWord);
 	if (el->el_map.type == MAP_VI)
 		if (el->el_chared.c_vcmd.action != NOP) {
 			cv_delfini(el);
 			return CC_REFRESH;
+		}
 	return CC_CURSOR;
+}
 /* vi_next_word():
  *	Vi move to the next word
  *	[w]
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_next_word(EditLine *el, Int c __attribute__((__unused__)))
+{
 	if (el->el_line.cursor >= el->el_line.lastchar - 1)
 		return CC_ERROR;
 	el->el_line.cursor = cv_next_word(el, el->el_line.cursor,
 	    el->el_line.lastchar, el->el_state.argument, cv__isword);
 	if (el->el_map.type == MAP_VI)
 		if (el->el_chared.c_vcmd.action != NOP) {
 			cv_delfini(el);
 			return CC_REFRESH;
+		}
 	return CC_CURSOR;
+}
 /* vi_change_case():
  *	Vi change case of character under the cursor and advance one character
  *	[~]
  */
 protected el_action_t
 vi_change_case(EditLine *el, Int c)
+{
 	int i;
 	if (el->el_line.cursor >= el->el_line.lastchar)
 		return CC_ERROR;
 	cv_undo(el);
 	for (i = 0; i < el->el_state.argument; i++) {
 		c = *el->el_line.cursor;
 		if (Isupper(c))
 			*el->el_line.cursor = Tolower(c);
 		else if (Islower(c))
 			*el->el_line.cursor = Toupper(c);
 		if (++el->el_line.cursor >= el->el_line.lastchar) {
 			el->el_line.cursor--;
 			re_fastaddc(el);
 			break;
+		}
 		re_fastaddc(el);
+	}
 	return CC_NORM;
+}
 /* vi_change_meta():
  *	Vi change prefix command
  *	[c]
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_change_meta(EditLine *el, Int c __attribute__((__unused__)))
+{
 	/*
          * Delete with insert == change: first we delete and then we leave in
          * insert mode.
          */
 	return cv_action(el, DELETE | INSERT);
+}
 /* vi_insert_at_bol():
  *	Vi enter insert mode at the beginning of line
  *	[I]
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_insert_at_bol(EditLine *el, Int c __attribute__((__unused__)))
+{
 	el->el_line.cursor = el->el_line.buffer;
 	cv_undo(el);
 	el->el_map.current = el->el_map.key;
 	return CC_CURSOR;
+}
 /* vi_replace_char():
  *	Vi replace character under the cursor with the next character typed
  *	[r]
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_replace_char(EditLine *el, Int c __attribute__((__unused__)))
+{
 	if (el->el_line.cursor >= el->el_line.lastchar)
 		return CC_ERROR;
 	el->el_map.current = el->el_map.key;
 	el->el_state.inputmode = MODE_REPLACE_1;
 	cv_undo(el);
 	return CC_ARGHACK;
+}
 /* vi_replace_mode():
  *	Vi enter replace mode
  *	[R]
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_replace_mode(EditLine *el, Int c __attribute__((__unused__)))
+{
 	el->el_map.current = el->el_map.key;
 	el->el_state.inputmode = MODE_REPLACE;
 	cv_undo(el);
 	return CC_NORM;
+}
 /* vi_substitute_char():
  *	Vi replace character under the cursor and enter insert mode
  *	[s]
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_substitute_char(EditLine *el, Int c __attribute__((__unused__)))
+{
 	c_delafter(el, el->el_state.argument);
 	el->el_map.current = el->el_map.key;
 	return CC_REFRESH;
+}
 /* vi_substitute_line():
  *	Vi substitute entire line
  *	[S]
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_substitute_line(EditLine *el, Int c __attribute__((__unused__)))
+{
 	cv_undo(el);
 	cv_yank(el, el->el_line.buffer,
 	    (int)(el->el_line.lastchar - el->el_line.buffer));
 	(void) em_kill_line(el, 0);
 	el->el_map.current = el->el_map.key;
 	return CC_REFRESH;
+}
 /* vi_change_to_eol():
  *	Vi change to end of line
  *	[C]
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_change_to_eol(EditLine *el, Int c __attribute__((__unused__)))
+{
 	cv_undo(el);
 	cv_yank(el, el->el_line.cursor,
 	    (int)(el->el_line.lastchar - el->el_line.cursor));
 	(void) ed_kill_line(el, 0);
 	el->el_map.current = el->el_map.key;
 	return CC_REFRESH;
+}
 /* vi_insert():
  *	Vi enter insert mode
  *	[i]
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_insert(EditLine *el, Int c __attribute__((__unused__)))
+{
 	el->el_map.current = el->el_map.key;
 	cv_undo(el);
 	return CC_NORM;
+}
 /* vi_add():
  *	Vi enter insert mode after the cursor
  *	[a]
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_add(EditLine *el, Int c __attribute__((__unused__)))
+{
 	int ret;
 	el->el_map.current = el->el_map.key;
 	if (el->el_line.cursor < el->el_line.lastchar) {
 		el->el_line.cursor++;
 		if (el->el_line.cursor > el->el_line.lastchar)
 			el->el_line.cursor = el->el_line.lastchar;
 		ret = CC_CURSOR;
 	} else
 		ret = CC_NORM;
 	cv_undo(el);
 	return ret;
+}
 /* vi_add_at_eol():
  *	Vi enter insert mode at end of line
  *	[A]
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_add_at_eol(EditLine *el, Int c __attribute__((__unused__)))
+{
 	el->el_map.current = el->el_map.key;
 	el->el_line.cursor = el->el_line.lastchar;
 	cv_undo(el);
 	return CC_CURSOR;
+}
 /* vi_delete_meta():
  *	Vi delete prefix command
  *	[d]
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_delete_meta(EditLine *el, Int c __attribute__((__unused__)))
+{
 	return cv_action(el, DELETE);
+}
 /* vi_end_big_word():
  *	Vi move to the end of the current space delimited word
  *	[E]
  */
 protected el_action_t
 /*ARGSUSED*/
-vi_end_big_word(EditLine *el, Int c)
+vi_end_big_word(EditLine *el, Int c __attribute__((__unused__)))
+{
 	if (el->el_line.cursor == el->el_line.lastchar)
 		return CC_ERROR;
 	el->el_line.cursor = cv__endword(el->el_line.cursor,
 	    el->el_line.lastchar, el->el_state.argument, cv__isWord);
 	if (el->el_chared.c_vcmd.action != NOP) {
 		el->el_line.cursor++;
 		cv_delfini(el);
 		return CC_REFRESH;
+	}
 	return CC_CURSOR;
+}
 /* vi_end_word():
  *	Vi move to the end of the current word
  *	[e]
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_end_word(EditLine *el, Int c __attribute__((__unused__)))
+{
 	if (el->el_line.cursor == el->el_line.lastchar)
 		return CC_ERROR;
 	el->el_line.cursor = cv__endword(el->el_line.cursor,
 	    el->el_line.lastchar, el->el_state.argument, cv__isword);
 	if (el->el_chared.c_vcmd.action != NOP) {
 		el->el_line.cursor++;
 		cv_delfini(el);
 		return CC_REFRESH;
+	}
 	return CC_CURSOR;
+}
 /* vi_undo():
  *	Vi undo last change
  *	[u]
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_undo(EditLine *el, Int c __attribute__((__unused__)))
+{
 	c_undo_t un = el->el_chared.c_undo;
 	if (un.len == -1)
 		return CC_ERROR;
 	/* switch line buffer and undo buffer */
 	el->el_chared.c_undo.buf = el->el_line.buffer;
 	el->el_chared.c_undo.len = el->el_line.lastchar - el->el_line.buffer;
 	el->el_chared.c_undo.cursor =
 	    (int)(el->el_line.cursor - el->el_line.buffer);
 	el->el_line.limit = un.buf + (el->el_line.limit - el->el_line.buffer);
 	el->el_line.buffer = un.buf;
 	el->el_line.cursor = un.buf + un.cursor;
 	el->el_line.lastchar = un.buf + un.len;
 	return CC_REFRESH;
+}
 /* vi_command_mode():
  *	Vi enter command mode (use alternative key bindings)
  *	[<ESC>]
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_command_mode(EditLine *el, Int c __attribute__((__unused__)))
+{
 	/* [Esc] cancels pending action */
 	el->el_chared.c_vcmd.action = NOP;
 	el->el_chared.c_vcmd.pos = 0;
 	el->el_state.doingarg = 0;
 	el->el_state.inputmode = MODE_INSERT;
 	el->el_map.current = el->el_map.alt;
 #ifdef VI_MOVE
 	if (el->el_line.cursor > el->el_line.buffer)
 		el->el_line.cursor--;
 #endif
 	return CC_CURSOR;
+}
 /* vi_zero():
  *	Vi move to the beginning of line
  *	[0]
  */
 protected el_action_t
 vi_zero(EditLine *el, Int c)
+{
 	if (el->el_state.doingarg)
 		return ed_argument_digit(el, c);
 	el->el_line.cursor = el->el_line.buffer;
 	if (el->el_chared.c_vcmd.action != NOP) {
 		cv_delfini(el);
 		return CC_REFRESH;
+	}
 	return CC_CURSOR;
+}
 /* vi_delete_prev_char():
  * 	Vi move to previous character (backspace)
  *	[^H] in insert mode only
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_delete_prev_char(EditLine *el, Int c __attribute__((__unused__)))
+{
 	if (el->el_line.cursor <= el->el_line.buffer)
 		return CC_ERROR;
 	c_delbefore1(el);
 	el->el_line.cursor--;
 	return CC_REFRESH;
+}
 /* vi_list_or_eof():
  *	Vi list choices for completion or indicate end of file if empty line
  *	[^D]
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_list_or_eof(EditLine *el, Int c)
+{
 	if (el->el_line.cursor == el->el_line.lastchar) {
 		if (el->el_line.cursor == el->el_line.buffer) {
 			terminal_writec(el, c);	/* then do a EOF */
 			return CC_EOF;
 		} else {
 			/*
 			 * Here we could list completions, but it is an
 			 * error right now
 			 */
 			terminal_beep(el);
 			return CC_ERROR;
+		}
 	} else {
 #ifdef notyet
 		re_goto_bottom(el);
 		*el->el_line.lastchar = '\0';	/* just in case */
 		return CC_LIST_CHOICES;
 #else
 		/*
 		 * Just complain for now.
 		 */
 		terminal_beep(el);
 		return CC_ERROR;
 #endif
+	}
+}
 /* vi_kill_line_prev():
  *	Vi cut from beginning of line to cursor
  *	[^U]
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_kill_line_prev(EditLine *el, Int c __attribute__((__unused__)))
+{
 	Char *kp, *cp;
 	cp = el->el_line.buffer;
 	kp = el->el_chared.c_kill.buf;
 	while (cp < el->el_line.cursor)
 		*kp++ = *cp++;	/* copy it */
 	el->el_chared.c_kill.last = kp;
 	c_delbefore(el, (int)(el->el_line.cursor - el->el_line.buffer));
 	el->el_line.cursor = el->el_line.buffer;	/* zap! */
 	return CC_REFRESH;
+}
 /* vi_search_prev():
  *	Vi search history previous
  *	[?]
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_search_prev(EditLine *el, Int c __attribute__((__unused__)))
+{
 	return cv_search(el, ED_SEARCH_PREV_HISTORY);
+}
 /* vi_search_next():
  *	Vi search history next
  *	[/]
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_search_next(EditLine *el, Int c __attribute__((__unused__)))
+{
 	return cv_search(el, ED_SEARCH_NEXT_HISTORY);
+}
 /* vi_repeat_search_next():
  *	Vi repeat current search in the same search direction
  *	[n]
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_repeat_search_next(EditLine *el, Int c __attribute__((__unused__)))
+{
 	if (el->el_search.patlen == 0)
 		return CC_ERROR;
 	else
 		return cv_repeat_srch(el, el->el_search.patdir);
+}
 /* vi_repeat_search_prev():
  *	Vi repeat current search in the opposite search direction
  *	[N]
  */
 /*ARGSUSED*/
 protected el_action_t
 vi_repeat_search_prev(EditLine *el, Int c __attribute__((__unused__)))
+{
 	if (el->el_search.patlen == 0)
 		return CC_ERROR;
 	else
 		return (cv_repeat_srch(el,
 		    el->el_search.patdir == ED_SEARCH_PREV_HISTORY ?
 		    ED_SEARCH_NEXT_HISTORY : ED_SEARCH_PREV_HISTORY));
+}
 /* vi_next_char():
  *	Vi move to the character specified next
  *	[f]
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_next_char(EditLine *el, Int c __attribute__((__unused__)))
+{
 	return cv_csearch(el, CHAR_FWD, -1, el->el_state.argument, 0);
+}
 /* vi_prev_char():
  *	Vi move to the character specified previous
  *	[F]
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_prev_char(EditLine *el, Int c __attribute__((__unused__)))
+{
 	return cv_csearch(el, CHAR_BACK, -1, el->el_state.argument, 0);
+}
 /* vi_to_next_char():
  *	Vi move up to the character specified next
  *	[t]
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_to_next_char(EditLine *el, Int c __attribute__((__unused__)))
+{
 	return cv_csearch(el, CHAR_FWD, -1, el->el_state.argument, 1);
+}
 /* vi_to_prev_char():
  *	Vi move up to the character specified previous
  *	[T]
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_to_prev_char(EditLine *el, Int c __attribute__((__unused__)))
+{
 	return cv_csearch(el, CHAR_BACK, -1, el->el_state.argument, 1);
+}
 /* vi_repeat_next_char():
  *	Vi repeat current character search in the same search direction
  *	[;]
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_repeat_next_char(EditLine *el, Int c __attribute__((__unused__)))
+{
 	return cv_csearch(el, el->el_search.chadir, el->el_search.chacha,
 		el->el_state.argument, el->el_search.chatflg);
+}
 /* vi_repeat_prev_char():
  *	Vi repeat current character search in the opposite search direction
  *	[,]
  */
 protected el_action_t
 /*ARGSUSED*/
 vi_repeat_prev_char(EditLine *el, Int c __attribute__((__unused__)))
+{
 	el_action_t r;
 	int dir = el->el_search.chadir;
 	r = cv_csearch(el, -dir, el->el_search.chacha,
 		el->el_state.argument, el->el_search.chatflg);
 	el->el_search.chadir = dir;
 	return r;
+}
 /* vi_match():
  *	Vi go to matching () {} or []
  *	[%]
  */
 protected el_action_t
 /*ARGSUSED*/
-vi_match(EditLine *el, Int c)
+vi_match(EditLine *el, Int c __attribute__((__unused__)))
+{
 	const Char match_chars[] = STR("()[]{}");
 	Char *cp;
 	size_t delta, i, count;
 	Char o_ch, c_ch;
 	*el->el_line.lastchar = '\0';		/* just in case */
 	i = Strcspn(el->el_line.cursor, match_chars);
 	o_ch = el->el_line.cursor[i];
 	if (o_ch == 0)
 		return CC_ERROR;
 	delta = Strchr(match_chars, o_ch) - match_chars;
 	c_ch = match_chars[delta ^ 1];
 	count = 1;
 	delta = 1 - (delta & 1) * 2;
 	for (cp = &el->el_line.cursor[i]; count; ) {
 		cp += delta;
 		if (cp < el->el_line.buffer || cp >= el->el_line.lastchar)
 			return CC_ERROR;
 		if (*cp == o_ch)
 			count++;
 		else if (*cp == c_ch)
 			count--;
+	}
 	el->el_line.cursor = cp;
 	if (el->el_chared.c_vcmd.action != NOP) {
 		/* NB posix says char under cursor should NOT be deleted
 		   for -ve delta - this is different to netbsd vi. */
 		if (delta > 0)
 			el->el_line.cursor++;
 		cv_delfini(el);
 		return CC_REFRESH;
+	}
 	return CC_CURSOR;
+}
 /* vi_undo_line():
  *	Vi undo all changes to line
  *	[U]
  */
 protected el_action_t
 /*ARGSUSED*/
-vi_undo_line(EditLine *el, Int c)
+vi_undo_line(EditLine *el, Int c __attribute__((__unused__)))
+{
 	cv_undo(el);
 	return hist_get(el);
+}
 /* vi_to_column():
  *	Vi go to specified column
  *	[|]
  * NB netbsd vi goes to screen column 'n', posix says nth character
  */
 protected el_action_t
 /*ARGSUSED*/
-vi_to_column(EditLine *el, Int c)
+vi_to_column(EditLine *el, Int c __attribute__((__unused__)))
+{
 	el->el_line.cursor = el->el_line.buffer;
 	el->el_state.argument--;
 	return ed_next_char(el, 0);
+}
 /* vi_yank_end():
  *	Vi yank to end of line
  *	[Y]
  */
 protected el_action_t
 /*ARGSUSED*/
-vi_yank_end(EditLine *el, Int c)
+vi_yank_end(EditLine *el, Int c __attribute__((__unused__)))
+{
 	cv_yank(el, el->el_line.cursor,
 	    (int)(el->el_line.lastchar - el->el_line.cursor));
 	return CC_REFRESH;
+}
 /* vi_yank():
  *	Vi yank
  *	[y]
  */
 protected el_action_t
 /*ARGSUSED*/
-vi_yank(EditLine *el, Int c)
+vi_yank(EditLine *el, Int c __attribute__((__unused__)))
+{
 	return cv_action(el, YANK);
+}
 /* vi_comment_out():
  *	Vi comment out current command
  *	[#]
  */
 protected el_action_t
 /*ARGSUSED*/
-vi_comment_out(EditLine *el, Int c)
+vi_comment_out(EditLine *el, Int c __attribute__((__unused__)))
+{
 	el->el_line.cursor = el->el_line.buffer;
 	c_insert(el, 1);
 	*el->el_line.cursor = '#';
 	re_refresh(el);
 	return ed_newline(el, 0);
+}
 /* vi_alias():
  *	Vi include shell alias
  *	[@]
  * NB: posix implies that we should enter insert mode, however
  * this is against historical precedent...
  */
 #ifdef __weak_reference
 __weakref_visible char *my_get_alias_text(const char *)
     __weak_reference(get_alias_text);
 #endif
 protected el_action_t
 /*ARGSUSED*/
-vi_alias(EditLine *el, Int c)
+vi_alias(EditLine *el, Int c __attribute__((__unused__)))
+{
 #ifdef __weak_reference
 	char alias_name[3];
 	char *alias_text;
 	if (my_get_alias_text == 0) {
 		return CC_ERROR;
+	}
 	alias_name[0] = '_';
 	alias_name[2] = 0;
 	if (el_getc(el, &alias_name[1]) != 1)
 		return CC_ERROR;
 	alias_text = my_get_alias_text(alias_name);
 	if (alias_text != NULL)
 		FUN(el,push)(el, ct_decode_string(alias_text, &el->el_scratch));
 	return CC_NORM;
 #else
 	return CC_ERROR;
 #endif
+}
 /* vi_to_history_line():
  *	Vi go to specified history file line.
  *	[G]
  */
 protected el_action_t
 /*ARGSUSED*/
-vi_to_history_line(EditLine *el, Int c)
+vi_to_history_line(EditLine *el, Int c __attribute__((__unused__)))
+{
 	int sv_event_no = el->el_history.eventno;
 	el_action_t rval;
 	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);
+	}
 	/* Lack of a 'count' means oldest, not 1 */
 	if (!el->el_state.doingarg) {
 		el->el_history.eventno = 0x7fffffff;
 		hist_get(el);
 	} else {
 		/* This is brain dead, all the rest of this code counts
 		 * upwards going into the past.  Here we need count in the
 		 * other direction (to match the output of fc -l).
 		 * I could change the world, but this seems to suffice.
 		 */
 		el->el_history.eventno = 1;
 		if (hist_get(el) == CC_ERROR)
 			return CC_ERROR;
 		el->el_history.eventno = 1 + el->el_history.ev.num
 					- el->el_state.argument;
 		if (el->el_history.eventno < 0) {
 			el->el_history.eventno = sv_event_no;
 			return CC_ERROR;
+		}
+	}
 	rval = hist_get(el);
 	if (rval == CC_ERROR)
 		el->el_history.eventno = sv_event_no;
 	return rval;
+}
 /* vi_histedit():
  *	Vi edit history line with vi
  *	[v]
  */
 protected el_action_t
 /*ARGSUSED*/
-vi_histedit(EditLine *el, Int c)
+vi_histedit(EditLine *el, Int c __attribute__((__unused__)))
+{
 	int fd;
 	pid_t pid;
 	ssize_t st;
 	int status;
 	char tempfile[] = "/tmp/histedit.XXXXXXXXXX";
 	char *cp;
 	size_t len;
 	Char *line;
 	if (el->el_state.doingarg) {
 		if (vi_to_history_line(el, 0) == CC_ERROR)
 			return CC_ERROR;
+	}
 	fd = mkstemp(tempfile);
 	if (fd < 0)
 		return CC_ERROR;
 	len = (size_t)(el->el_line.lastchar - el->el_line.buffer);
 #define TMP_BUFSIZ (EL_BUFSIZ * MB_LEN_MAX)
 	cp = el_malloc(TMP_BUFSIZ * sizeof(*cp));
 	if (cp == NULL) {
 		unlink(tempfile);
 		close(fd);
 		return CC_ERROR;
+	}
 	line = el_malloc(len * sizeof(*line));
 	if (line == NULL) {
 		el_free(cp);
 		return CC_ERROR;
+	}
 	Strncpy(line, el->el_line.buffer, len);
 	line[len] = '\0';
 	ct_wcstombs(cp, line, TMP_BUFSIZ - 1);
 	cp[TMP_BUFSIZ - 1] = '\0';
 	len = strlen(cp);
 	write(fd, cp, len);
 	write(fd, "\n", 1);
 	pid = fork();
 	switch (pid) {
 	case -1:
 		close(fd);
 		unlink(tempfile);
 		el_free(cp);
                 el_free(line);
 		return CC_ERROR;
 	case 0:
 		close(fd);
 		execlp("vi", "vi", tempfile, (char *)NULL);
 		exit(0);
 		/*NOTREACHED*/
 	default:
 		while (waitpid(pid, &status, 0) != pid)
 			continue;
 		lseek(fd, (off_t)0, SEEK_SET);
 		st = read(fd, cp, TMP_BUFSIZ);
 		if (st > 0) {
 			len = (size_t)(el->el_line.lastchar -
 			    el->el_line.buffer);
 			len = ct_mbstowcs(el->el_line.buffer, cp, len);
 			if (len > 0 && el->el_line.buffer[len -1] == '\n')
 				--len;
+		}
 		else
 			len = 0;
                 el->el_line.cursor = el->el_line.buffer;
                 el->el_line.lastchar = el->el_line.buffer + len;
 		el_free(cp);
                 el_free(line);
 		break;
+	}
 	close(fd);
 	unlink(tempfile);
 	/* return CC_REFRESH; */
 	return ed_newline(el, 0);
+}
 /* vi_history_word():
  *	Vi append word from previous input line
  *	[_]
  * Who knows where this one came from!
  * '_' in vi means 'entire current line', so 'cc' is a synonym for 'c_'
  */
 protected el_action_t
 /*ARGSUSED*/
-vi_history_word(EditLine *el, Int c)
+vi_history_word(EditLine *el, Int c __attribute__((__unused__)))
+{
 	const Char *wp = HIST_FIRST(el);
 	const Char *wep, *wsp;
 	int len;
 	Char *cp;
 	const Char *lim;
 	if (wp == NULL)
 		return CC_ERROR;
 	wep = wsp = 0;
 	do {
 		while (Isspace(*wp))
 			wp++;
 		if (*wp == 0)
 			break;
 		wsp = wp;
 		while (*wp && !Isspace(*wp))
 			wp++;
 		wep = wp;
 	} while ((!el->el_state.doingarg || --el->el_state.argument > 0)
 	    && *wp != 0);
 	if (wsp == 0 || (el->el_state.doingarg && el->el_state.argument != 0))
 		return CC_ERROR;
 	cv_undo(el);
 	len = (int)(wep - wsp);
 	if (el->el_line.cursor < el->el_line.lastchar)
 		el->el_line.cursor++;
 	c_insert(el, len + 1);
 	cp = el->el_line.cursor;
 	lim = el->el_line.limit;
 	if (cp < lim)
 		*cp++ = ' ';
 	while (wsp < wep && cp < lim)
 		*cp++ = *wsp++;
 	el->el_line.cursor = cp;
 	el->el_map.current = el->el_map.key;
 	return CC_REFRESH;
+}
 /* vi_redo():
  *	Vi redo last non-motion command
  *	[.]
  */
 protected el_action_t
 /*ARGSUSED*/
-vi_redo(EditLine *el, Int c)
+vi_redo(EditLine *el, Int c __attribute__((__unused__)))
+{
 	c_redo_t *r = &el->el_chared.c_redo;
 	if (!el->el_state.doingarg && r->count) {
 		el->el_state.doingarg = 1;
 		el->el_state.argument = r->count;
+	}
 	el->el_chared.c_vcmd.pos = el->el_line.cursor;
 	el->el_chared.c_vcmd.action = r->action;
 	if (r->pos != r->buf) {
 		if (r->pos + 1 > r->lim)
 			/* sanity */
 			r->pos = r->lim - 1;
 		r->pos[0] = 0;
 		FUN(el,push)(el, r->buf);
+	}
 	el->el_state.thiscmd = r->cmd;
 	el->el_state.thisch = r->ch;
 	return (*el->el_map.func[r->cmd])(el, r->ch);
+}