 @@ -1,57 +1,59 @@
-/*	$NetBSD: key.h,v 1.3 2016/01/07 14:07:01 christos Exp $ */
+/*	$NetBSD: key.h,v 1.4 2017/11/21 07:43:47 rin Exp $ */
 /*-
  * Copyright (c) 1991, 1993, 1994
  *	The Regents of the University of California.  All rights reserved.
  * Copyright (c) 1991, 1993, 1994, 1995, 1996
  *	Keith Bostic.  All rights reserved.
+ *
  * See the LICENSE file for redistribution information.
+ *
  *	Id: key.h,v 10.50 2001/06/28 17:53:58 skimo Exp  (Berkeley) Date: 2001/06/28 17:53:58
  */
 #include "multibyte.h"
 #ifdef USE_WIDECHAR
 #define FILE2INT5(sp,buf,n,nlen,w,wlen)					    \
     sp->conv.file2int(sp, n, nlen, &buf, &wlen, &w)
 #define INT2FILE(sp,w,wlen,n,nlen) 					    \
     sp->conv.int2file(sp, w, wlen, &sp->wp->cw, &nlen, &n)
 #define CHAR2INT5(sp,buf,n,nlen,w,wlen)					    \
     sp->conv.sys2int(sp, n, nlen, &buf, &wlen, &w)
 #define INT2CHAR(sp,w,wlen,n,nlen) 					    \
     sp->conv.int2sys(sp, w, wlen, &sp->wp->cw, &nlen, &n)
 #define INT2SYS(sp,w,wlen,n,nlen) 					    \
     sp->conv.int2sys(sp, w, wlen, &sp->wp->cw, &nlen, &n)
 #define INPUT2INT5(sp,cw,n,nlen,w,wlen)					    \
     sp->conv.input2int(sp, n, nlen, &(cw), &wlen, &w)
-#define INTISWIDE(c)	(wctob(c) == EOF)	    /* XXX wrong name */
+#define INTISWIDE(c)	     (wctob(c) == EOF)	/* XXX wrong name */
-#define CHAR_WIDTH(sp, ch)  wcwidth(ch)
+#define CHAR_WIDTH(sp, ch)   wcwidth(ch)
 #define ISMULTIWIDTH(sp, ch) (INTISWIDE(ch) && CHAR_WIDTH(sp, ch) > 1)
 #else
 #define FILE2INT5(sp,buf,n,nlen,w,wlen) \
     (w = n, wlen = nlen, 0)
 #define INT2FILE(sp,w,wlen,n,nlen) \
     (n = w, nlen = wlen, 0)
 #define CHAR2INT5(sp,buf,n,nlen,w,wlen) \
     (w = n, wlen = nlen, 0)
 #define INT2CHAR(sp,w,wlen,n,nlen) \
     (n = w, nlen = wlen, 0)
 #define INT2SYS(sp,w,wlen,n,nlen) \
     (n = w, nlen = wlen, 0)
 #define INPUT2INT5(sp,buf,n,nlen,w,wlen) \
     (w = n, wlen = nlen, 0)
-#define INTISWIDE(c)	    0
+#define INTISWIDE(c)	     0
-#define CHAR_WIDTH(sp, ch)  1
+#define CHAR_WIDTH(sp, ch)   1
 #define ISMULTIWIDTH(sp, ch) 0
 #endif
 #define FILE2INT(sp,n,nlen,w,wlen)					    \
     FILE2INT5(sp,sp->wp->cw,n,nlen,w,wlen)
 #define CHAR2INT(sp,n,nlen,w,wlen)					    \
     CHAR2INT5(sp,sp->wp->cw,n,nlen,w,wlen)
 #define MEMCPYW(to, from, n) \
     memcpy(to, from, (n) * sizeof(CHAR_T))
 #define MEMMOVEW(to, from, n) \
     memmove(to, from, (n) * sizeof(CHAR_T))
 /* The maximum number of columns any character can take up on a screen. */
 #define	MAX_CHARACTER_COLUMNS	4

 @@ -1,32 +1,32 @@
-/*	$NetBSD: v_word.c,v 1.3 2014/01/26 21:43:45 christos Exp $ */
+/*	$NetBSD: v_word.c,v 1.4 2017/11/21 07:43:47 rin Exp $ */
 /*-
  * Copyright (c) 1992, 1993, 1994
  *	The Regents of the University of California.  All rights reserved.
  * Copyright (c) 1992, 1993, 1994, 1995, 1996
  *	Keith Bostic.  All rights reserved.
+ *
  * See the LICENSE file for redistribution information.
  */
 #include "config.h"
 #include <sys/cdefs.h>
 #if 0
 #ifndef lint
 static const char sccsid[] = "Id: v_word.c,v 10.6 2001/06/25 15:19:36 skimo Exp  (Berkeley) Date: 2001/06/25 15:19:36 ";
 #endif /* not lint */
 #else
-__RCSID("$NetBSD: v_word.c,v 1.3 2014/01/26 21:43:45 christos Exp $");
+__RCSID("$NetBSD: v_word.c,v 1.4 2017/11/21 07:43:47 rin Exp $");
 #endif
 #include <sys/types.h>
 #include <sys/queue.h>
 #include <sys/time.h>
 #include <bitstring.h>
 #include <ctype.h>
 #include <limits.h>
 #include <stdio.h>
 #include "../common/common.h"
 #include "vi.h"
 @@ -58,26 +58,29 @@ __RCSID("$NetBSD: v_word.c,v 1.3 2014/01
  * single character, and nothing else.  Ain't nothin' in here that's easy.
+ *
  * One historic note -- in the original vi, the 'w', 'W' and 'B' commands
  * would treat groups of empty lines as individual words, i.e. the command
  * would move the cursor to each new empty line.  The 'e' and 'E' commands
  * would treat groups of empty lines as a single word, i.e. the first use
  * would move past the group of lines.  The 'b' command would just beep at
  * you, or, if you did it from the start of the line as part of a motion
  * command, go absolutely nuts.  If the lines contained only white-space
  * characters, the 'w' and 'W' commands would just beep at you, and the 'B',
  * 'b', 'E' and 'e' commands would treat the group as a single word, and
  * the 'B' and 'b' commands will treat the lines as individual words.  This
  * implementation treats all of these cases as a single white-space word.
+ *
  * We regard a boundary between single- and multi-width characters as
  * a word boundary.
  */
 enum which {BIGWORD, LITTLEWORD};
 static int bword __P((SCR *, VICMD *, enum which));
 static int eword __P((SCR *, VICMD *, enum which));
 static int fword __P((SCR *, VICMD *, enum which));
 /*
  * v_wordW -- [count]W
  *	Move forward a bigword at a time.
+ *
  * PUBLIC: int v_wordW __P((SCR *, VICMD *));
 @@ -100,26 +103,27 @@ v_wordw(SCR *sp, VICMD *vp)
 	return (fword(sp, vp, LITTLEWORD));
+}
 /*
  * fword --
  *	Move forward by words.
  */
 static int
 fword(SCR *sp, VICMD *vp, enum which type)
+{
 	enum { INWORD, NOTWORD } state;
 	VCS cs;
 	u_long cnt;
 	int nmw, omw;
 	cnt = F_ISSET(vp, VC_C1SET) ? vp->count : 1;
 	cs.cs_lno = vp->m_start.lno;
 	cs.cs_cno = vp->m_start.cno;
 	if (cs_init(sp, &cs))
 		return (1);
 	/*
 	 * If in white-space:
 	 *	If the count is 1, and it's a change command, we're done.
 	 *	Else, move to the first non-white-space character, which
 	 *	counts as a single word move.  If it's a motion command,
 	 *	don't move off the end of the line.
 @@ -137,64 +141,70 @@ fword(SCR *sp, VICMD *vp, enum which typ
 		if (cs_fblank(sp, &cs))
 			return (1);
 		--cnt;
+	}
 	/*
 	 * Cyclically move to the next word -- this involves skipping
 	 * over word characters and then any trailing non-word characters.
 	 * Note, for the 'w' command, the definition of a word keeps
 	 * switching.
 	 */
 	if (type == BIGWORD)
 		while (cnt--) {
 			nmw = ISMULTIWIDTH(sp, cs.cs_ch);
 			for (;;) {
 				omw = nmw;
 				if (cs_next(sp, &cs))
 					return (1);
 				if (cs.cs_flags == CS_EOF)
 					goto ret;
-				if (cs.cs_flags != 0 || ISBLANK2(cs.cs_ch))
+				if (cs.cs_flags != 0 || ISBLANK2(cs.cs_ch) ||
 				    (nmw = ISMULTIWIDTH(sp, cs.cs_ch)) != omw)
 					break;
+			}
 			/*
 			 * If a motion command and we're at the end of the
 			 * last word, we're done.  Delete and yank eat any
 			 * trailing blanks, but we don't move off the end
 			 * of the line regardless.
 			 */
 			if (cnt == 0 && ISMOTION(vp)) {
 				if ((ISCMD(vp->rkp, 'd') ||
 				    ISCMD(vp->rkp, 'y')) &&
 				    cs_fspace(sp, &cs))
 					return (1);
 				break;
+			}
 			/* Eat whitespace characters. */
-			if (cs_fblank(sp, &cs))
+			if (nmw == omw && cs_fblank(sp, &cs))
 				return (1);
 			if (cs.cs_flags == CS_EOF)
 				goto ret;
+		}
 	else
 		while (cnt--) {
 			state = cs.cs_flags == 0 &&
 			    inword(cs.cs_ch) ? INWORD : NOTWORD;
 			nmw = ISMULTIWIDTH(sp, cs.cs_ch);
 			for (;;) {
 				omw = nmw;
 				if (cs_next(sp, &cs))
 					return (1);
 				if (cs.cs_flags == CS_EOF)
 					goto ret;
-				if (cs.cs_flags != 0 || ISBLANK2(cs.cs_ch))
+				if (cs.cs_flags != 0 || ISBLANK2(cs.cs_ch) ||
 				    (nmw = ISMULTIWIDTH(sp, cs.cs_ch)) != omw)
 					break;
 				if (state == INWORD) {
 					if (!inword(cs.cs_ch))
 						break;
 				} else
 					if (inword(cs.cs_ch))
 						break;
+			}
 			/* See comment above. */
 			if (cnt == 0 && ISMOTION(vp)) {
 				if ((ISCMD(vp->rkp, 'd') ||
 				    ISCMD(vp->rkp, 'y')) &&
 				    cs_fspace(sp, &cs))
 @@ -260,26 +270,27 @@ v_worde(SCR *sp, VICMD *vp)
 	return (eword(sp, vp, LITTLEWORD));
+}
 /*
  * eword --
  *	Move forward to the end of the word.
  */
 static int
 eword(SCR *sp, VICMD *vp, enum which type)
+{
 	enum { INWORD, NOTWORD } state;
 	VCS cs;
 	u_long cnt;
 	int nmw, omw;
 	cnt = F_ISSET(vp, VC_C1SET) ? vp->count : 1;
 	cs.cs_lno = vp->m_start.lno;
 	cs.cs_cno = vp->m_start.cno;
 	if (cs_init(sp, &cs))
 		return (1);
 	/*
 	 * !!!
 	 * If in whitespace, or the next character is whitespace, move past
 	 * it.  (This doesn't count as a word move.)  Stay at the character
 	 * past the current one, it sets word "state" for the 'e' command.
 	 */
 @@ -290,61 +301,67 @@ eword(SCR *sp, VICMD *vp, enum which typ
 			goto start;
+	}
 	if (cs_fblank(sp, &cs))
 		return (1);
 	/*
 	 * Cyclically move to the next word -- this involves skipping
 	 * over word characters and then any trailing non-word characters.
 	 * Note, for the 'e' command, the definition of a word keeps
 	 * switching.
 	 */
 start:	if (type == BIGWORD)
 		while (cnt--) {
 			nmw = ISMULTIWIDTH(sp, cs.cs_ch);
 			for (;;) {
 				omw = nmw;
 				if (cs_next(sp, &cs))
 					return (1);
 				if (cs.cs_flags == CS_EOF)
 					goto ret;
-				if (cs.cs_flags != 0 || ISBLANK2(cs.cs_ch))
+				if (cs.cs_flags != 0 || ISBLANK2(cs.cs_ch) ||
 				    (nmw = ISMULTIWIDTH(sp, cs.cs_ch)) != omw)
 					break;
+			}
 			/*
 			 * When we reach the start of the word after the last
 			 * word, we're done.  If we changed state, back up one
 			 * to the end of the previous word.
 			 */
 			if (cnt == 0) {
 				if (cs.cs_flags == 0 && cs_prev(sp, &cs))
 					return (1);
 				break;
+			}
 			/* Eat whitespace characters. */
-			if (cs_fblank(sp, &cs))
+			if (nmw == omw && cs_fblank(sp, &cs))
 				return (1);
 			if (cs.cs_flags == CS_EOF)
 				goto ret;
+		}
 	else
 		while (cnt--) {
 			state = cs.cs_flags == 0 &&
 			    inword(cs.cs_ch) ? INWORD : NOTWORD;
 			nmw = ISMULTIWIDTH(sp, cs.cs_ch);
 			for (;;) {
 				omw = nmw;
 				if (cs_next(sp, &cs))
 					return (1);
 				if (cs.cs_flags == CS_EOF)
 					goto ret;
-				if (cs.cs_flags != 0 || ISBLANK2(cs.cs_ch))
+				if (cs.cs_flags != 0 || ISBLANK2(cs.cs_ch) ||
 				    (nmw = ISMULTIWIDTH(sp, cs.cs_ch)) != omw)
 					break;
 				if (state == INWORD) {
 					if (!inword(cs.cs_ch))
 						break;
 				} else
 					if (inword(cs.cs_ch))
 						break;
+			}
 			/* See comment above. */
 			if (cnt == 0) {
 				if (cs.cs_flags == 0 && cs_prev(sp, &cs))
 					return (1);
 				break;
 @@ -406,26 +423,27 @@ v_wordb(SCR *sp, VICMD *vp)
 	return (bword(sp, vp, LITTLEWORD));
+}
 /*
  * bword --
  *	Move backward by words.
  */
 static int
 bword(SCR *sp, VICMD *vp, enum which type)
+{
 	enum { INWORD, NOTWORD } state;
 	VCS cs;
 	u_long cnt;
 	int nmw, omw;
 	cnt = F_ISSET(vp, VC_C1SET) ? vp->count : 1;
 	cs.cs_lno = vp->m_start.lno;
 	cs.cs_cno = vp->m_start.cno;
 	if (cs_init(sp, &cs))
 		return (1);
 	/*
 	 * !!!
 	 * If in whitespace, or the previous character is whitespace, move
 	 * past it.  (This doesn't count as a word move.)  Stay at the
 	 * character before the current one, it sets word "state" for the
 	 * 'b' command.
 @@ -437,61 +455,67 @@ bword(SCR *sp, VICMD *vp, enum which typ
 			goto start;
+	}
 	if (cs_bblank(sp, &cs))
 		return (1);
 	/*
 	 * Cyclically move to the beginning of the previous word -- this
 	 * involves skipping over word characters and then any trailing
 	 * non-word characters.  Note, for the 'b' command, the definition
 	 * of a word keeps switching.
 	 */
 start:	if (type == BIGWORD)
 		while (cnt--) {
 			nmw = ISMULTIWIDTH(sp, cs.cs_ch);
 			for (;;) {
 				omw = nmw;
 				if (cs_prev(sp, &cs))
 					return (1);
 				if (cs.cs_flags == CS_SOF)
 					goto ret;
-				if (cs.cs_flags != 0 || ISBLANK2(cs.cs_ch))
+				if (cs.cs_flags != 0 || ISBLANK2(cs.cs_ch) ||
 				    (nmw = ISMULTIWIDTH(sp, cs.cs_ch)) != omw)
 					break;
+			}
 			/*
 			 * When we reach the end of the word before the last
 			 * word, we're done.  If we changed state, move forward
 			 * one to the end of the next word.
 			 */
 			if (cnt == 0) {
 				if (cs.cs_flags == 0 && cs_next(sp, &cs))
 					return (1);
 				break;
+			}
 			/* Eat whitespace characters. */
-			if (cs_bblank(sp, &cs))
+			if (nmw == omw && cs_bblank(sp, &cs))
 				return (1);
 			if (cs.cs_flags == CS_SOF)
 				goto ret;
+		}
 	else
 		while (cnt--) {
 			state = cs.cs_flags == 0 &&
 			    inword(cs.cs_ch) ? INWORD : NOTWORD;
 			nmw = ISMULTIWIDTH(sp, cs.cs_ch);
 			for (;;) {
 				omw = nmw;
 				if (cs_prev(sp, &cs))
 					return (1);
 				if (cs.cs_flags == CS_SOF)
 					goto ret;
-				if (cs.cs_flags != 0 || ISBLANK2(cs.cs_ch))
+				if (cs.cs_flags != 0 || ISBLANK2(cs.cs_ch) ||
 				    (nmw = ISMULTIWIDTH(sp, cs.cs_ch)) != omw)
 					break;
 				if (state == INWORD) {
 					if (!inword(cs.cs_ch))
 						break;
 				} else
 					if (inword(cs.cs_ch))
 						break;
+			}
 			/* See comment above. */
 			if (cnt == 0) {
 				if (cs.cs_flags == 0 && cs_next(sp, &cs))
 					return (1);
 				break;