snapshot of project "lynx", label v2-8-8dev_16q

1 files changed, 998 insertions, 1056 deletions

diff --git a/src/LYStrings.c b/src/LYStrings.c
index ac5405c3..66acf897 100644
--- a/src/LYStrings.c
+++ b/src/LYStrings.c
@@ -1,4 +1,4 @@
-/* $LynxId: LYStrings.c,v 1.215 2013/10/02 23:58:20 tom Exp $ */
+/* $LynxId: LYStrings.c,v 1.253 2013/10/13 20:47:25 tom Exp $ */
 #include <HTUtils.h>
 #include <HTCJK.h>
 #include <UCAux.h>
@@ -54,6 +54,12 @@
 #define CTRACE_EDIT(p)		/*nothing */
 #endif
 
+#ifdef SUPPORT_MULTIBYTE_EDIT
+#define IsWordChar(c) (isalnum(UCH(c)) || is8bits(c))
+#else
+#define IsWordChar(c) isalnum(UCH(c))
+#endif
+
 /*
  * The edit_history lists allow the user to press tab when entering URL to get
  * the closest match in the closet
@@ -406,7 +412,7 @@ static int set_clicked_link(int x,
 	else if (clicks > 1) {
 	    if (x < left + toolbar)
 		c = (code == FOR_PROMPT && y)
-		    ? HOME : LAC_TO_LKC0(LYK_MAIN_MENU);
+		    ? HOME_KEY : LAC_TO_LKC0(LYK_MAIN_MENU);
 	    else if (x > right)
 		c = (code == FOR_PROMPT && y)
 		    ? END_KEY : LAC_TO_LKC0(LYK_VLINKS);
@@ -417,7 +423,7 @@ static int set_clicked_link(int x,
 	} else {
 	    if (x < left + toolbar)
 		c = (code == FOR_PROMPT && y)
-		    ? LTARROW
+		    ? LTARROW_KEY
 		    : (
 #ifdef USE_COLOR_STYLE
 			  (s_forw_backw != NOSTYLE && x - toolbar >= 3)
@@ -429,7 +435,7 @@ static int set_clicked_link(int x,
 		    );
 	    else if (x > right)
 		c = (code == FOR_PROMPT && y)
-		    ? RTARROW : LAC_TO_LKC0(LYK_HISTORY);
+		    ? RTARROW_KEY : LAC_TO_LKC0(LYK_HISTORY);
 	    else if (y)		/* Last row */
 		c = LAC_TO_LKC0(LYK_NEXT_PAGE);
 	    else		/* First row */
@@ -569,28 +575,28 @@ static int set_clicked_link(int x,
 #endif /* USE_MOUSE */
 
 /*
- * LYstrncpy() terminates strings with a null byte.  Writes a null byte into
- * the n+1 byte of dst.
+ * LYstrncpy() ensures that the copied strings end with a nul byte.
+ * The nul is written to the n+1 position of the target.
  */
-char *LYstrncpy(char *dst,
-		const char *src,
+char *LYstrncpy(char *target,
+		const char *source,
 		int n)
 {
-    char *val = dst;
+    char *val = target;
     int len;
 
-    if (src == 0)
-	src = "";
-    len = (int) strlen(src);
+    if (source == 0)
+	source = "";
+    len = (int) strlen(source);
 
     if (n > 0) {
 	if (n > len)
 	    n = len;
-	(void) StrNCpy(dst, src, n);
+	(void) StrNCpy(target, source, n);
     } else {
 	n = 0;
     }
-    dst[n] = '\0';
+    target[n] = '\0';
     return val;
 }
 
@@ -599,17 +605,17 @@ char *LYstrncpy(char *dst,
 
 /*
  * LYmbcsstrncpy() terminates strings with a null byte.  It takes account of
- * multibyte characters.  The src string is copied until either end of string
+ * multibyte characters.  The source string is copied until either end of string
  * or max number of either bytes or glyphs (mbcs sequences) (CJK or UTF8).  The
  * utf_flag argument should be TRUE for UTF8.  - KW & FM
  */
-char *LYmbcsstrncpy(char *dst,
-		    const char *src,
+char *LYmbcsstrncpy(char *target,
+		    const char *source,
 		    int n_bytes,
 		    int n_glyphs,
 		    int utf_flag)
 {
-    char *val = dst;
+    char *val = target;
     int i_bytes = 0, i_glyphs = 0;
 
     if (n_bytes < 0)
@@ -617,16 +623,16 @@ char *LYmbcsstrncpy(char *dst,
     if (n_glyphs < 0)
 	n_glyphs = 0;
 
-    for (; *src != '\0' && i_bytes < n_bytes; i_bytes++) {
-	if (IS_NEW_GLYPH(*src)) {
+    for (; *source != '\0' && i_bytes < n_bytes; i_bytes++) {
+	if (IS_NEW_GLYPH(*source)) {
 	    if (i_glyphs++ >= n_glyphs) {
-		*dst = '\0';
+		*target = '\0';
 		return val;
 	    }
 	}
-	*(dst++) = *(src++);
+	*(target++) = *(source++);
     }
-    *dst = '\0';
+    *target = '\0';
 
     return val;
 }
@@ -900,8 +906,8 @@ void ena_csi(int flag)
 			    (unsigned) code, \
 			    Keymap_List)
 #if SLANG_VERSION < 20000
-#define expand_substring(dst, first, last, final) \
- 	(SLexpand_escaped_string(dst, \
+#define expand_substring(target, first, last, final) \
+ 	(SLexpand_escaped_string(target, \
 				 (char *)first, \
 				 (char *)last), 1)
 static int SLang_get_error(void)
@@ -911,8 +917,8 @@ static int SLang_get_error(void)
 #else
 int LY_Slang_UTF8_Mode = 0;
 
-#define expand_substring(dst, first, last, final) \
-	(SLexpand_escaped_string(dst, \
+#define expand_substring(target, first, last, final) \
+	(SLexpand_escaped_string(target, \
 				 (char *)first, \
 				 (char *)last, \
 				 LY_Slang_UTF8_Mode), 1)
@@ -934,28 +940,40 @@ static SLKeyMap_List_Type *Keymap_List;
 # else
 #  define EXTERN_KEY(string,string1,lynx,curses) {string,lynx},{string1,lynx}
 # endif
-# define INTERN_KEY(string,lynx,curses)          {string,lynx}
+# define INTERN_KEY(string,lynx,curses)          {string,lynx,lynx}
 #else
-#define INTERN_KEY(string,lynx,curses)           {string,curses}
-#define EXTERN_KEY(string,string1,lynx,curses)   {string,curses}
+# define INTERN_KEY(string,lynx,curses)          {string,curses,lynx}
+# define EXTERN_KEY(string,string1,lynx,curses)  {string,curses,lynx}
 #endif
 
 typedef struct {
     const char *string;
     int value;
+    LYExtraKeys internal;
 } Keysym_String_List;
 /* *INDENT-OFF* */
 static Keysym_String_List Keysym_Strings [] =
 {
-    INTERN_KEY( "UPARROW",	UPARROW,	KEY_UP ),
-    INTERN_KEY( "DNARROW",	DNARROW,	KEY_DOWN ),
-    INTERN_KEY( "RTARROW",	RTARROW,	KEY_RIGHT ),
-    INTERN_KEY( "LTARROW",	LTARROW,	KEY_LEFT ),
-    INTERN_KEY( "PGDOWN",	PGDOWN,		KEY_NPAGE ),
-    INTERN_KEY( "PGUP",		PGUP,		KEY_PPAGE ),
-    INTERN_KEY( "HOME",		HOME,		KEY_HOME ),
+    INTERN_KEY( "UPARROW",	UPARROW_KEY,	KEY_UP ),
+    INTERN_KEY( "DNARROW",	DNARROW_KEY,	KEY_DOWN ),
+    INTERN_KEY( "RTARROW",	RTARROW_KEY,	KEY_RIGHT ),
+    INTERN_KEY( "LTARROW",	LTARROW_KEY,	KEY_LEFT ),
+    INTERN_KEY( "PGDOWN",	PGDOWN_KEY,	KEY_NPAGE ),
+    INTERN_KEY( "PGUP",		PGUP_KEY,	KEY_PPAGE ),
+    INTERN_KEY( "HOME",		HOME_KEY,	KEY_HOME ),
     INTERN_KEY( "END",		END_KEY,	KEY_END ),
-    INTERN_KEY( "F1",		F1,		KEY_F(1) ),
+    INTERN_KEY( "F1",		F1_KEY,		KEY_F(1) ),
+    INTERN_KEY( "F2",		F2_KEY,		KEY_F(2) ),
+    INTERN_KEY( "F3",		F3_KEY,		KEY_F(3) ),
+    INTERN_KEY( "F4",		F4_KEY,		KEY_F(4) ),
+    INTERN_KEY( "F5",		F5_KEY,		KEY_F(5) ),
+    INTERN_KEY( "F6",		F6_KEY,		KEY_F(7) ),
+    INTERN_KEY( "F7",		F7_KEY,		KEY_F(7) ),
+    INTERN_KEY( "F8",		F8_KEY,		KEY_F(8) ),
+    INTERN_KEY( "F9",		F9_KEY,		KEY_F(9) ),
+    INTERN_KEY( "F10",		F10_KEY,	KEY_F(10) ),
+    INTERN_KEY( "F11",		F11_KEY,	KEY_F(11) ),
+    INTERN_KEY( "F12",		F12_KEY,	KEY_F(12) ),
     INTERN_KEY( "DO_KEY",	DO_KEY,		KEY_F(16) ),
     INTERN_KEY( "FIND_KEY",	FIND_KEY,	KEY_FIND ),
     INTERN_KEY( "SELECT_KEY",	SELECT_KEY,	KEY_SELECT ),
@@ -1070,7 +1088,7 @@ static const char *expand_tichar(const char *first, char **result, char *final)
     return first;
 }
 
-static BOOLEAN expand_substring(char *dst,
+static BOOLEAN expand_substring(char *target,
 				const char *first,
 				const char *last,
 				char *final)
@@ -1080,27 +1098,27 @@ static BOOLEAN expand_substring(char *dst,
     while (first < last) {
 	switch (ch = *first++) {
 	case ESCAPE:
-	    first = expand_tichar(first, &dst, final);
+	    first = expand_tichar(first, &target, final);
 	    break;
 	case '^':
 	    ch = *first++;
 	    if (ch == LPAREN) {
 		const char *s = strchr(first, RPAREN);
-		char *was = dst;
+		char *was = target;
 
 		if (s == 0)
 		    s = first + strlen(first);
-		first = expand_tiname(first, (size_t) (s - first), &dst, final);
-		if (dst == was)
+		first = expand_tiname(first, (size_t) (s - first), &target, final);
+		if (target == was)
 		    return FALSE;
 		if (*first)
 		    first++;
 	    } else if (ch == '?') {	/* ASCII delete? */
-		*dst++ = 127;
+		*target++ = 127;
 	    } else if ((ch & 0x3f) < 0x20) {	/* ASCII control char? */
-		*dst++ = (char) (ch & 0x1f);
+		*target++ = (char) (ch & 0x1f);
 	    } else {
-		*dst++ = '^';
+		*target++ = '^';
 		first--;	/* not legal... */
 	    }
 	    break;
@@ -1108,11 +1126,11 @@ static BOOLEAN expand_substring(char *dst,
 	    ch = 0200;
 	    /* FALLTHRU */
 	default:
-	    *dst++ = (char) ch;
+	    *target++ = (char) ch;
 	    break;
 	}
     }
-    *dst = '\0';
+    *target = '\0';
     return TRUE;
 }
 #endif
@@ -1132,27 +1150,43 @@ static void unescaped_char(const char *parse, int *keysym)
     }
 }
 
-static BOOLEAN unescape_string(char *src, char *dst, char *final)
+static BOOLEAN unescape_string(char *source, char *target, char *final)
 {
     BOOLEAN ok = FALSE;
 
-    if (*src == SQUOTE) {
+    if (*source == SQUOTE) {
 	int keysym = -1;
 
-	unescaped_char(src, &keysym);
+	unescaped_char(source, &keysym);
 	if (keysym >= 0) {
-	    dst[0] = (char) keysym;
-	    dst[1] = '\0';
+	    target[0] = (char) keysym;
+	    target[1] = '\0';
 	    ok = TRUE;
 	}
-    } else if (*src == DQUOTE) {
-	if (expand_substring(dst, src + 1, src + strlen(src) - 1, final))
+    } else if (*source == DQUOTE) {
+	if (expand_substring(target, source + 1, source + strlen(source) - 1, final))
 	    ok = TRUE;
 	(void) final;
     }
     return ok;
 }
 
+static Keysym_String_List *lookupKeysymByName(const char *name)
+{
+    Keysym_String_List *k;
+    Keysym_String_List *result = 0;
+
+    k = Keysym_Strings;
+    while (k->string != NULL) {
+	if (0 == strcasecomp(k->string, name)) {
+	    result = k;
+	    break;
+	}
+	k++;
+    }
+    return result;
+}
+
 int map_string_to_keysym(const char *str, int *keysym)
 {
     int modifier = 0;
@@ -1223,15 +1257,10 @@ int map_string_to_keysym(const char *str, int *keysym)
 #endif
 	}
     } else {
-	Keysym_String_List *k;
+	Keysym_String_List *k = lookupKeysymByName(str);
 
-	k = Keysym_Strings;
-	while (k->string != NULL) {
-	    if (0 == strcmp(k->string, str)) {
-		*keysym = k->value;
-		break;
-	    }
-	    k++;
+	if (k != 0) {
+	    *keysym = k->value;
 	}
     }
 
@@ -1240,6 +1269,32 @@ int map_string_to_keysym(const char *str, int *keysym)
     return (*keysym);
 }
 
+LYExtraKeys LYnameToExtraKeys(const char *name)
+{
+    Keysym_String_List *k = lookupKeysymByName(name);
+    LYExtraKeys result = -1;
+
+    if (k != 0)
+	result = k->internal;
+    return result;
+}
+
+const char *LYextraKeysToName(LYExtraKeys code)
+{
+    Keysym_String_List *k;
+    const char *result = 0;
+
+    k = Keysym_Strings;
+    while (k->string != NULL) {
+	if (k->internal == code) {
+	    result = k->string;
+	    break;
+	}
+	k++;
+    }
+    return result;
+}
+
 /*
  * Starting at a nonblank character, skip over a token, counting quoted and
  * escaped characters.
@@ -1404,55 +1459,68 @@ static void setup_vtXXX_keymap(void)
 {
     /* *INDENT-OFF* */
     static Keysym_String_List table[] = {
-	INTERN_KEY( "\033[A",	UPARROW,	KEY_UP ),
-	INTERN_KEY( "\033OA",	UPARROW,	KEY_UP ),
-	INTERN_KEY( "\033[B",	DNARROW,	KEY_DOWN ),
-	INTERN_KEY( "\033OB",	DNARROW,	KEY_DOWN ),
-	INTERN_KEY( "\033[C",	RTARROW,	KEY_RIGHT ),
-	INTERN_KEY( "\033OC",	RTARROW,	KEY_RIGHT ),
-	INTERN_KEY( "\033[D",	LTARROW,	KEY_LEFT ),
-	INTERN_KEY( "\033OD",	LTARROW,	KEY_LEFT ),
+	INTERN_KEY( "\033[A",	UPARROW_KEY,	KEY_UP ),
+	INTERN_KEY( "\033OA",	UPARROW_KEY,	KEY_UP ),
+	INTERN_KEY( "\033[B",	DNARROW_KEY,	KEY_DOWN ),
+	INTERN_KEY( "\033OB",	DNARROW_KEY,	KEY_DOWN ),
+	INTERN_KEY( "\033[C",	RTARROW_KEY,	KEY_RIGHT ),
+	INTERN_KEY( "\033OC",	RTARROW_KEY,	KEY_RIGHT ),
+	INTERN_KEY( "\033[D",	LTARROW_KEY,	KEY_LEFT ),
+	INTERN_KEY( "\033OD",	LTARROW_KEY,	KEY_LEFT ),
 	INTERN_KEY( "\033[1~",	FIND_KEY,	KEY_FIND ),
 	INTERN_KEY( "\033[2~",	INSERT_KEY,	KEY_IC ),
 	INTERN_KEY( "\033[3~",	REMOVE_KEY,	KEY_DC ),
 	INTERN_KEY( "\033[4~",	SELECT_KEY,	KEY_SELECT ),
-	INTERN_KEY( "\033[5~",	PGUP,		KEY_PPAGE ),
-	INTERN_KEY( "\033[6~",	PGDOWN,		KEY_NPAGE ),
-	INTERN_KEY( "\033[7~",	HOME,		KEY_HOME),
+	INTERN_KEY( "\033[5~",	PGUP_KEY,	KEY_PPAGE ),
+	INTERN_KEY( "\033[6~",	PGDOWN_KEY,	KEY_NPAGE ),
+	INTERN_KEY( "\033[7~",	HOME_KEY,	KEY_HOME),
 	INTERN_KEY( "\033[8~",	END_KEY,	KEY_END ),
-	INTERN_KEY( "\033[11~",	F1,		KEY_F(1) ),
-	INTERN_KEY( "\033[28~",	F1,		KEY_F(1) ),
-	INTERN_KEY( "\033OP",	F1,		KEY_F(1) ),
-	INTERN_KEY( "\033[OP",	F1,		KEY_F(1) ),
+	INTERN_KEY( "\033[11~",	F1_KEY,		KEY_F(1) ),
+	INTERN_KEY( "\033[28~",	F1_KEY,		KEY_F(1) ),
+	INTERN_KEY( "\033OP",	F1_KEY,		KEY_F(1) ),
+	INTERN_KEY( "\033[OP",	F1_KEY,		KEY_F(1) ),
 	INTERN_KEY( "\033[29~",	DO_KEY,		KEY_F(16) ),
-#if defined(USE_SLANG) && (defined(__WIN32__) || defined(__MINGW32__))
-	INTERN_KEY( "\xE0H",	UPARROW,	KEY_UP ),
-	INTERN_KEY( "\xE0P",	DNARROW,	KEY_DOWN ),
-	INTERN_KEY( "\xE0M",	RTARROW,	KEY_RIGHT ),
-	INTERN_KEY( "\xE0K",	LTARROW,	KEY_LEFT ),
+#if defined(USE_SLANG)
+#if defined(__WIN32__) || defined(__MINGW32__)
+	INTERN_KEY( "\xE0H",	UPARROW_KEY,	KEY_UP ),
+	INTERN_KEY( "\xE0P",	DNARROW_KEY,	KEY_DOWN ),
+	INTERN_KEY( "\xE0M",	RTARROW_KEY,	KEY_RIGHT ),
+	INTERN_KEY( "\xE0K",	LTARROW_KEY,	KEY_LEFT ),
 	INTERN_KEY( "\xE0R",	INSERT_KEY,	KEY_IC ),
 	INTERN_KEY( "\xE0S",	REMOVE_KEY,	KEY_DC ),
-	INTERN_KEY( "\xE0I",	PGUP,		KEY_PPAGE ),
-	INTERN_KEY( "\xE0Q",	PGDOWN,		KEY_NPAGE ),
-	INTERN_KEY( "\xE0G",	HOME,		KEY_HOME),
+	INTERN_KEY( "\xE0I",	PGUP_KEY,	KEY_PPAGE ),
+	INTERN_KEY( "\xE0Q",	PGDOWN_KEY,	KEY_NPAGE ),
+	INTERN_KEY( "\xE0G",	HOME_KEY,	KEY_HOME),
 	INTERN_KEY( "\xE0O",	END_KEY,	KEY_END ),
 #endif
-#if defined(USE_SLANG) && !defined(VMS)
-	INTERN_KEY(	"^(ku)", UPARROW,	KEY_UP ),
-	INTERN_KEY(	"^(kd)", DNARROW,	KEY_DOWN ),
-	INTERN_KEY(	"^(kr)", RTARROW,	KEY_RIGHT ),
-	INTERN_KEY(	"^(kl)", LTARROW,	KEY_LEFT ),
+#if !defined(VMS)
+	INTERN_KEY(	"^(ku)", UPARROW_KEY,	KEY_UP ),
+	INTERN_KEY(	"^(kd)", DNARROW_KEY,	KEY_DOWN ),
+	INTERN_KEY(	"^(kr)", RTARROW_KEY,	KEY_RIGHT ),
+	INTERN_KEY(	"^(kl)", LTARROW_KEY,	KEY_LEFT ),
 	INTERN_KEY(	"^(@0)", FIND_KEY,	KEY_FIND ),
 	INTERN_KEY(	"^(kI)", INSERT_KEY,	KEY_IC ),
 	INTERN_KEY(	"^(kD)", REMOVE_KEY,	KEY_DC ),
 	INTERN_KEY(	"^(*6)", SELECT_KEY,	KEY_SELECT ),
-	INTERN_KEY(	"^(kP)", PGUP,		KEY_PPAGE ),
-	INTERN_KEY(	"^(kN)", PGDOWN,	KEY_NPAGE ),
+	INTERN_KEY(	"^(kP)", PGUP_KEY,	KEY_PPAGE ),
+	INTERN_KEY(	"^(kN)", PGDOWN_KEY,	KEY_NPAGE ),
 	INTERN_KEY(	"^(@7)", END_KEY,	KEY_END ),
-	INTERN_KEY(	"^(kh)", HOME,		KEY_HOME),
-	INTERN_KEY(	"^(k1)", F1,		KEY_F(1) ),
+	INTERN_KEY(	"^(kh)", HOME_KEY,	KEY_HOME),
+	INTERN_KEY(	"^(k1)", F1_KEY,	KEY_F(1) ),
+	INTERN_KEY(	"^(k2)", F2_KEY,	KEY_F(2) ),
+	INTERN_KEY(	"^(k3)", F3_KEY,	KEY_F(3) ),
+	INTERN_KEY(	"^(k4)", F4_KEY,	KEY_F(4) ),
+	INTERN_KEY(	"^(k5)", F5_KEY,	KEY_F(5) ),
+	INTERN_KEY(	"^(k6)", F6_KEY,	KEY_F(6) ),
+	INTERN_KEY(	"^(k7)", F7_KEY,	KEY_F(7) ),
+	INTERN_KEY(	"^(k8)", F8_KEY,	KEY_F(8) ),
+	INTERN_KEY(	"^(k9)", F9_KEY,	KEY_F(9) ),
+	INTERN_KEY(	"^(k;)", F10_KEY,	KEY_F(10) ),
+	INTERN_KEY(	"^(F1)", F11_KEY,	KEY_F(11) ),
+	INTERN_KEY(	"^(F2)", F12_KEY,	KEY_F(12) ),
 	INTERN_KEY(	"^(F6)", DO_KEY,	KEY_F(16) ),
-#endif /* SLANG && !VMS */
+#endif /* !VMS */
+#endif /* SLANG */
     };
     /* *INDENT-ON* */
 
@@ -1647,16 +1715,16 @@ static int LYgetch_for(int code)
 	    keysym = key->f.keysym;
 	    switch (keysym) {
 	    case 'H':
-		keysym = UPARROW;
+		keysym = UPARROW_KEY;
 		break;
 	    case 'P':
-		keysym = DNARROW;
+		keysym = DNARROW_KEY;
 		break;
 	    case 'M':
-		keysym = RTARROW;
+		keysym = RTARROW_KEY;
 		break;
 	    case 'K':
-		keysym = LTARROW;
+		keysym = LTARROW_KEY;
 		break;
 	    case 'R':
 		keysym = INSERT_KEY;
@@ -1665,51 +1733,52 @@ static int LYgetch_for(int code)
 		keysym = REMOVE_KEY;
 		break;
 	    case 'I':
-		keysym = PGUP;
+		keysym = PGUP_KEY;
 		break;
 	    case 'Q':
-		keysym = PGDOWN;
+		keysym = PGDOWN_KEY;
 		break;
 	    case 'G':
-		keysym = HOME;
+		keysym = HOME_KEY;
 		break;
 	    case 'O':
 		keysym = END_KEY;
 		break;
 	    case ';':
-		keysym = F1;
+		keysym = F1_KEY;
 		break;
 	    }
 	    return (keysym);
 	}
 #endif
-
 	return (current_sl_modifier ? 0 : DO_NOTHING);
-    }
-
-    keysym = (int) key->f.keysym;
+    } else {
+	keysym = (int) key->f.keysym;
 
 #if defined (USE_MOUSE)
-    if (keysym == MOUSE_KEYSYM)
-	return sl_read_mouse_event(code);
+	if (keysym == MOUSE_KEYSYM)
+	    return sl_read_mouse_event(code);
 #endif
 
-    if (keysym < 0)
-	return 0;
+	if (keysym < 0) {
+	    return 0;
 
-    if (keysym & (LKC_ISLECLAC | LKC_ISLAC))
-	return (keysym);
+	} else if (keysym & (LKC_ISLECLAC | LKC_ISLAC)) {
+	    return (keysym);
+	} else {
+	    current_sl_modifier = 0;
+	    if (LKC_HAS_ESC_MOD(keysym)) {
+		current_sl_modifier = LKC_MOD2;
+		keysym &= LKC_MASK;
+	    }
 
-    current_sl_modifier = 0;
-    if (LKC_HAS_ESC_MOD(keysym)) {
-	current_sl_modifier = LKC_MOD2;
-	keysym &= LKC_MASK;
+	    if (keysym + 1 >= KEYMAP_SIZE) {
+		return 0;
+	    } else {
+		return (keysym | current_sl_modifier);
+	    }
+	}
     }
-
-    if (keysym + 1 >= KEYMAP_SIZE)
-	return 0;
-
-    return (keysym | current_sl_modifier);
 }
 
 /************************************************************************/
@@ -1854,40 +1923,40 @@ static int LYgetch_for(int code)
 
 	switch (a) {
 	case 'A':
-	    c = UPARROW;
+	    c = UPARROW_KEY;
 	    break;
 	case 'B':
-	    c = DNARROW;
+	    c = DNARROW_KEY;
 	    break;
 	case 'C':
-	    c = RTARROW;
+	    c = RTARROW_KEY;
 	    break;
 	case 'D':
-	    c = LTARROW;
+	    c = LTARROW_KEY;
 	    break;
 	case 'q':		/* vt100 application keypad 1 */
 	    c = END_KEY;
 	    break;
 	case 'r':		/* vt100 application keypad 2 */
-	    c = DNARROW;
+	    c = DNARROW_KEY;
 	    break;
 	case 's':		/* vt100 application keypad 3 */
-	    c = PGDOWN;
+	    c = PGDOWN_KEY;
 	    break;
 	case 't':		/* vt100 application keypad 4 */
-	    c = LTARROW;
+	    c = LTARROW_KEY;
 	    break;
 	case 'v':		/* vt100 application keypad 6 */
-	    c = RTARROW;
+	    c = RTARROW_KEY;
 	    break;
 	case 'w':		/* vt100 application keypad 7 */
-	    c = HOME;
+	    c = HOME_KEY;
 	    break;
 	case 'x':		/* vt100 application keypad 8 */
-	    c = UPARROW;
+	    c = UPARROW_KEY;
 	    break;
 	case 'y':		/* vt100 application keypad 9 */
-	    c = PGUP;
+	    c = PGUP_KEY;
 	    break;
 	case 'M':
 #if defined(USE_SLANG) && defined(USE_MOUSE)
@@ -1920,13 +1989,13 @@ static int LYgetch_for(int code)
 #ifdef VMS
 	    if (b != 'O')
 #endif /* VMS */
-		c = F1;
+		c = F1_KEY;
 	    break;
 	case 'u':
 #ifdef VMS
 	    if (b != 'O')
 #endif /* VMS */
-		c = F1;		/* macintosh help button */
+		c = F1_KEY;	/* macintosh help button */
 	    break;
 	case 'p':
 #ifdef VMS
@@ -1948,7 +2017,7 @@ static int LYgetch_for(int code)
 			  d == '9') &&
 			 found_TLD(GetChar())) {
 		    if (d == '8')	/* VTxxx   Help */
-			c = F1;
+			c = F1_KEY;
 		    else if (d == '9')	/* VTxxx    Do  */
 			c = DO_KEY;
 		    d = -1;
@@ -1970,20 +2039,20 @@ static int LYgetch_for(int code)
 	    break;
 	case '5':			     /** VTxxx PrevScreen **/
 	    if (found_CSI(c, b) && found_TLD(d = GetChar()))
-		c = PGUP;
+		c = PGUP_KEY;
 	    else
 		done_esc = FALSE;	/* we have another look below - kw */
 	    break;
 	case '6':			     /** VTxxx NextScreen **/
 	    if (found_CSI(c, b) && found_TLD(d = GetChar()))
-		c = PGDOWN;
+		c = PGDOWN_KEY;
 	    else
 		done_esc = FALSE;	/* we have another look below - kw */
 	    break;
 	case '[':			     /** Linux F1-F5: ^[[[A etc. **/
 	    if (found_CSI(c, b)) {
 		if ((d = GetChar()) == 'A')
-		    c = F1;
+		    c = F1_KEY;
 		break;
 	    }
 	    /* FALLTHRU */
@@ -2037,29 +2106,29 @@ static int LYgetch_for(int code)
 	 */
 	switch (c) {
 	case KEY_DOWN:		/* The four arrow keys ... */
-	    c = DNARROW;
+	    c = DNARROW_KEY;
 	    break;
 	case KEY_UP:
-	    c = UPARROW;
+	    c = UPARROW_KEY;
 	    break;
 	case KEY_LEFT:
-	    c = LTARROW;
+	    c = LTARROW_KEY;
 	    break;
 	case KEY_RIGHT:	/* ... */
-	    c = RTARROW;
+	    c = RTARROW_KEY;
 	    break;
 #if defined(PDCURSES)		/* for NEC PC-9800 1998/08/30 (Sun) 21:50:35 */
 	case KEY_C2:
-	    c = DNARROW;
+	    c = DNARROW_KEY;
 	    break;
 	case KEY_A2:
-	    c = UPARROW;
+	    c = UPARROW_KEY;
 	    break;
 	case KEY_B1:
-	    c = LTARROW;
+	    c = LTARROW_KEY;
 	    break;
 	case KEY_B3:
-	    c = RTARROW;
+	    c = RTARROW_KEY;
 	    break;
 	case PAD0:		/* PC-9800 Ins */
 	    c = INSERT_KEY;
@@ -2069,16 +2138,16 @@ static int LYgetch_for(int code)
 	    break;
 #endif /* PDCURSES */
 	case KEY_HOME:		/* Home key (upward+left arrow) */
-	    c = HOME;
+	    c = HOME_KEY;
 	    break;
 	case KEY_CLEAR:	/* Clear screen */
 	    c = 18;		/* CTRL-R */
 	    break;
 	case KEY_NPAGE:	/* Next page */
-	    c = PGDOWN;
+	    c = PGDOWN_KEY;
 	    break;
 	case KEY_PPAGE:	/* Previous page */
-	    c = PGUP;
+	    c = PGUP_KEY;
 	    break;
 	case KEY_LL:		/* home down or bottom (lower left) */
 	    c = END_KEY;
@@ -2089,10 +2158,10 @@ static int LYgetch_for(int code)
 	    /*   left   b2  right  */
 	    /*    c1   down   c3   */
 	case KEY_A1:		/* upper left of keypad */
-	    c = HOME;
+	    c = HOME_KEY;
 	    break;
 	case KEY_A3:		/* upper right of keypad */
-	    c = PGUP;
+	    c = PGUP_KEY;
 	    break;
 	case KEY_B2:		/* center of keypad */
 	    c = DO_NOTHING;
@@ -2101,7 +2170,7 @@ static int LYgetch_for(int code)
 	    c = END_KEY;
 	    break;
 	case KEY_C3:		/* lower right of keypad */
-	    c = PGDOWN;
+	    c = PGDOWN_KEY;
 	    break;
 #endif /* defined(KEY_A1) && defined(KEY_C3) */
 #ifdef KEY_ENTER
@@ -2121,7 +2190,7 @@ static int LYgetch_for(int code)
 #endif /* KEY_END */
 #ifdef KEY_HELP
 	case KEY_HELP:		/* help key          001 */
-	    c = F1;
+	    c = F1_KEY;
 	    break;
 #endif /* KEY_HELP */
 #ifdef KEY_BACKSPACE
@@ -2130,7 +2199,7 @@ static int LYgetch_for(int code)
 	    break;
 #endif /* KEY_BACKSPACE */
 	case KEY_F(1):
-	    c = F1;		/* VTxxx Help */
+	    c = F1_KEY;		/* VTxxx Help */
 	    break;
 #if defined(KEY_F) && !defined(__DJGPP__) && !defined(_WINDOWS)
 	case KEY_F(16):
@@ -2183,15 +2252,6 @@ static int LYgetch_for(int code)
 		    recent_sizechange));
 #endif /* HAVE_SIZECHANGE || USE_SLANG */
 	    if (!recent_sizechange) {
-#if 0				/* assumption seems flawed? */
-		/* Not detected by us or already processed by us.  It can
-		 * happens that ncurses lags behind us in detecting the change,
-		 * since its own SIGTSTP handler is not installed so detecting
-		 * happened *at the end* of the last refresh.  Tell it to
-		 * refresh again...  - kw
-		 */
-		LYrefresh();
-#endif
 #if defined(NCURSES)
 		/*
 		 * Work-around for scenario (Linux libc5) where we got a
@@ -2312,10 +2372,6 @@ static int LYgetch_for(int code)
 			lac = LYK_REFRESH;
 		    }
 		    c = LAC_TO_LKC(lac);
-#if 0				/* Probably not necessary any more - kw */
-		    lynx_force_repaint();
-		    LYrefresh();
-#endif
 		}
 #if NCURSES_MOUSE_VERSION > 1
 		else if (event.bstate & BUTTON4_PRESSED) {
@@ -2367,31 +2423,31 @@ static int LYgetch_for(int code)
 		    if (MOUSE_Y_POS > (LYlines - V_CMD_AREA - 1)) {
 			/* Screen BOTTOM */
 			if (MOUSE_X_POS < left) {
-			    c = LTARROW;
+			    c = LTARROW_KEY;
 			    p = "<-";
 			} else if (MOUSE_X_POS < HIST_CMD_2) {
-			    c = RTARROW;
+			    c = RTARROW_KEY;
 			    p = "->";
 			} else if (MOUSE_X_POS > right) {
 			    c = 'z';
 			    p = "Cancel";
 			} else {
-			    c = PGDOWN;
+			    c = PGDOWN_KEY;
 			    p = "PGDOWN";
 			}
 		    } else if (MOUSE_Y_POS < V_CMD_AREA) {
 			/* Screen TOP */
 			if (MOUSE_X_POS < left) {
-			    c = LTARROW;
+			    c = LTARROW_KEY;
 			    p = "<-";
 			} else if (MOUSE_X_POS < HIST_CMD_2) {
-			    c = RTARROW;
+			    c = RTARROW_KEY;
 			    p = "->";
 			} else if (MOUSE_X_POS > right) {
 			    c = 'z';
 			    p = "Cancel";
 			} else {
-			    c = PGUP;
+			    c = PGUP_KEY;
 			    p = "PGUP";
 			}
 		    } else {
@@ -2420,38 +2476,38 @@ static int LYgetch_for(int code)
 	switch (c) {
 	case K_Down:		/* The four arrow keys ... */
 	case K_EDown:
-	    c = DNARROW;
+	    c = DNARROW_KEY;
 	    break;
 	case K_Up:
 	case K_EUp:
-	    c = UPARROW;
+	    c = UPARROW_KEY;
 	    break;
 	case K_Left:
 	case K_ELeft:
-	    c = LTARROW;
+	    c = LTARROW_KEY;
 	    break;
 	case K_Right:		/* ... */
 	case K_ERight:
-	    c = RTARROW;
+	    c = RTARROW_KEY;
 	    break;
 	case K_Home:		/* Home key (upward+left arrow) */
 	case K_EHome:
-	    c = HOME;
+	    c = HOME_KEY;
 	    break;
 	case K_PageDown:	/* Next page */
 	case K_EPageDown:
-	    c = PGDOWN;
+	    c = PGDOWN_KEY;
 	    break;
 	case K_PageUp:		/* Previous page */
 	case K_EPageUp:
-	    c = PGUP;
+	    c = PGUP_KEY;
 	    break;
 	case K_End:		/* home down or bottom (lower left) */
 	case K_EEnd:
 	    c = END_KEY;
 	    break;
 	case K_F1:		/* F1 key */
-	    c = F1;
+	    c = F1_KEY;
 	    break;
 	case K_Insert:		/* Insert key */
 	case K_EInsert:
@@ -2478,35 +2534,35 @@ static int LYgetch_for(int code)
 #if defined(USE_SLANG) && (defined(__DJGPP__) || defined(__CYGWIN__)) && !defined(DJGPP_KEYHANDLER)  && !defined(USE_KEYMAPS)
 	switch (c) {
 	case SL_KEY_DOWN:	/* The four arrow keys ... */
-	    c = DNARROW;
+	    c = DNARROW_KEY;
 	    break;
 	case SL_KEY_UP:
-	    c = UPARROW;
+	    c = UPARROW_KEY;
 	    break;
 	case SL_KEY_LEFT:
-	    c = LTARROW;
+	    c = LTARROW_KEY;
 	    break;
 	case SL_KEY_RIGHT:	/* ... */
-	    c = RTARROW;
+	    c = RTARROW_KEY;
 	    break;
 	case SL_KEY_HOME:	/* Home key (upward+left arrow) */
 	case SL_KEY_A1:	/* upper left of keypad */
-	    c = HOME;
+	    c = HOME_KEY;
 	    break;
 	case SL_KEY_NPAGE:	/* Next page */
 	case SL_KEY_C3:	/* lower right of keypad */
-	    c = PGDOWN;
+	    c = PGDOWN_KEY;
 	    break;
 	case SL_KEY_PPAGE:	/* Previous page */
 	case SL_KEY_A3:	/* upper right of keypad */
-	    c = PGUP;
+	    c = PGUP_KEY;
 	    break;
 	case SL_KEY_END:	/* home down or bottom (lower left) */
 	case SL_KEY_C1:	/* lower left of keypad */
 	    c = END_KEY;
 	    break;
 	case SL_KEY_F(1):	/* F1 key */
-	    c = F1;
+	    c = F1_KEY;
 	    break;
 	case SL_KEY_IC:	/* Insert key */
 	    c = INSERT_KEY;
@@ -2518,9 +2574,9 @@ static int LYgetch_for(int code)
 #endif /* USE_SLANG && __DJGPP__ && !DJGPP_KEYHANDLER && !USE_KEYMAPS */
     }
 
-    if (c & (LKC_ISLAC | LKC_ISLECLAC))
+    if (c & (LKC_ISLAC | LKC_ISLECLAC)) {
 	return (c);
-    if ((c + 1) >= KEYMAP_SIZE) {
+    } else if ((c + 1) >= KEYMAP_SIZE) {
 	/*
 	 * Don't return raw values for KEYPAD symbols which we may have missed
 	 * in the switch above if they are obviously invalid when used as an
@@ -2587,9 +2643,8 @@ void LYLowerCase(char *arg_buffer)
     register unsigned char *buffer = (unsigned char *) arg_buffer;
     size_t i;
 
-    for (i = 0; buffer[i]; i++)
+    for (i = 0; buffer[i]; i++) {
 #ifdef SUPPORT_MULTIBYTE_EDIT	/* 1998/11/23 (Mon) 17:04:55 */
-    {
 	if ((buffer[i] & 0x80) != 0
 	    && buffer[i + 1] != 0) {
 	    if ((kanji_code == SJIS) && IS_SJIS_X0201KANA(UCH((buffer[i])))) {
@@ -2599,10 +2654,10 @@ void LYLowerCase(char *arg_buffer)
 	} else {
 	    buffer[i] = UCH(TOLOWER(buffer[i]));
 	}
-    }
 #else
 	buffer[i] = TOLOWER(buffer[i]);
 #endif
+    }
 }
 
 /*
@@ -2613,9 +2668,8 @@ void LYUpperCase(char *arg_buffer)
     register unsigned char *buffer = (unsigned char *) arg_buffer;
     size_t i;
 
-    for (i = 0; buffer[i]; i++)
+    for (i = 0; buffer[i]; i++) {
 #ifdef SUPPORT_MULTIBYTE_EDIT	/* 1998/11/23 (Mon) 17:05:10 */
-    {
 	if ((buffer[i] & 0x80) != 0
 	    && buffer[i + 1] != 0) {
 	    if ((kanji_code == SJIS) && IS_SJIS_X0201KANA(UCH((buffer[i])))) {
@@ -2625,10 +2679,10 @@ void LYUpperCase(char *arg_buffer)
 	} else {
 	    buffer[i] = UCH(TOUPPER(buffer[i]));
 	}
-    }
 #else
 	buffer[i] = UCH(TOUPPER(buffer[i]));
 #endif
+    }
 }
 
 /*
@@ -2636,6 +2690,8 @@ void LYUpperCase(char *arg_buffer)
  */
 BOOLEAN LYRemoveNewlines(char *buffer)
 {
+    BOOLEAN result = FALSE;
+
     if (buffer != 0) {
 	register char *buf = buffer;
 
@@ -2649,10 +2705,10 @@ BOOLEAN LYRemoveNewlines(char *buffer)
 		    *buf++ = *old;
 	    }
 	    *buf = '\0';
-	    return TRUE;
+	    result = TRUE;
 	}
     }
-    return FALSE;
+    return result;
 }
 
 /*
@@ -2675,6 +2731,8 @@ char *LYReduceBlanks(char *buffer)
  */
 char *LYRemoveBlanks(char *buffer)
 {
+    char *result = NULL;
+
     if (buffer != 0) {
 	register char *buf = buffer;
 
@@ -2689,9 +2747,9 @@ char *LYRemoveBlanks(char *buffer)
 	    }
 	    *buf = '\0';
 	}
-	return buf;
+	result = buf;
     }
-    return NULL;
+    return result;
 }
 
 /*
@@ -2799,6 +2857,8 @@ char *LYElideString(char *str,
  */
 BOOLEAN LYTrimStartfile(char *buffer)
 {
+    BOOLEAN result = FALSE;
+
     LYTrimHead(buffer);
     if (isLYNXEXEC(buffer) ||
 	isLYNXPROG(buffer)) {
@@ -2810,9 +2870,9 @@ BOOLEAN LYTrimStartfile(char *buffer)
 	 */
 	HTUnEscapeSome(buffer, " \r\n\t");
 	convert_to_spaces(buffer, TRUE);
-	return TRUE;
+	result = TRUE;
     }
-    return FALSE;
+    return result;
 }
 
 /*
@@ -2839,53 +2899,58 @@ void LYTrimAllStartfile(char *buffer)
 }
 
 /*
- *  Display the current value of the string and allow the user
- *  to edit it.
+ * Display the current value of the string and allow the user to edit it.
  */
 
-#define EDREC	 EditFieldData
-
 /*
  * Shorthand to get rid of the "edit->suchandsos".
  */
-#define IsDirty  edit->dirty
-#define IsHidden edit->hidden
-#define StartX	 edit->sx
-#define StartY	 edit->sy
-#define Buf	 edit->buffer
-#define Pos	 edit->pos	/* current editing position (bytes) */
-#define StrLen	 edit->buffer_used	/* length (bytes) */
-#define MaxLen	 edit->buffer_size
-#define BufLimit edit->buffer_limit
-#define DspWdth  edit->dspwdth
-#define DspStart edit->xpan	/* display-start (columns) */
-#define Margin	 edit->margin
-#define PanOn	 edit->panon
-#define PadChar  edit->pad
+#define IsDirty   edit->efIsDirty
+#define IsHidden  edit->efIsMasked
+#define StartX    edit->efStartX
+#define StartY    edit->efStartY
+#define Buffer    edit->efBuffer
+#define EditAt    edit->efEditAt	/* current editing position (bytes) */
+#define BufInUse  edit->efBufInUse	/* length (bytes) */
+#define BufAlloc  edit->efBufAlloc
+#define BufLimit  edit->efBufLimit
+#define DpyWidth  edit->efWidth
+#define DpyStart  edit->efDpyStart	/* display-start (columns) */
+#define PanMargin edit->efPanMargin
+#define IsPanned  edit->efIsPanned
+#define PadChar   edit->efPadChar
 #ifdef ENHANCED_LINEEDIT
-#define Mark	 edit->mark
+#define EditMark  edit->efEditMark
 #endif
-#define CurModif edit->current_modifiers
-#define Offs2Col edit->offset2col
+#define InputMods edit->efInputMods
+#define Offs2Col  edit->efOffs2Col
+
+#define enableEditMark() \
+	if (EditMark < 0) \
+	    EditMark = -(1 + EditMark)
+
+#define disableEditMark() \
+	if (EditMark >= 0) \
+	    EditMark = -(1 + EditMark)
 
 #ifdef ENHANCED_LINEEDIT
 static bstring *killbuffer;
 #endif
 
-static void updateMargin(EDREC * edit)
+static void updateMargin(FieldEditor * edit)
 {
-    if ((int) MaxLen > DspWdth) {	/* Need panning? */
-	if (DspWdth > 4)	/* Else "{}" take up precious screen space */
-	    PanOn = TRUE;
+    if ((int) BufAlloc > DpyWidth) {	/* Need panning? */
+	if (DpyWidth > 4)
+	    IsPanned = TRUE;
 
 	/*
 	 * Figure out margins.  If too big, we do a lot of unnecessary
 	 * scrolling.  If too small, user doesn't have sufficient look-ahead. 
 	 * Let's say 25% for each margin, upper bound is 10 columns.
 	 */
-	Margin = DspWdth / 4;
-	if (Margin > 10)
-	    Margin = 10;
+	PanMargin = DpyWidth / 4;
+	if (PanMargin > 10)
+	    PanMargin = 10;
     }
 }
 
@@ -2893,34 +2958,34 @@ static void updateMargin(EDREC * edit)
  * Before using an array position, make sure that the array is long enough.
  * Reallocate if needed.
  */
-static void ExtendEditor(EDREC * edit, int position)
+static void ExtendEditor(FieldEditor * edit, int position)
 {
     size_t need = (size_t) (++position);
 
-    if (need >= MaxLen && (BufLimit == 0 || need < BufLimit)) {
-	CTRACE((tfp, "ExtendEditor from %u to %u\n",
-		(unsigned) MaxLen,
-		(unsigned) need));
-	Buf = typeRealloc(char, Buf, need);
+    if (need >= BufAlloc && (BufLimit == 0 || need < BufLimit)) {
+	CTRACE((tfp, "ExtendEditor from %lu to %lu\n",
+		(unsigned long) BufAlloc,
+		(unsigned long) need));
+	Buffer = typeRealloc(char, Buffer, need);
 	Offs2Col = typeRealloc(int, Offs2Col, need + 1);
 
-	MaxLen = need;
+	BufAlloc = need;
 	updateMargin(edit);
     }
 }
 
-void LYFinishEdit(EDREC * edit)
+void LYFinishEdit(FieldEditor * edit)
 {
-    CTRACE((tfp, "LYFinishEdit:%s\n", NonNull(Buf)));
+    CTRACE((tfp, "LYFinishEdit:%s\n", NonNull(Buffer)));
 
-    FREE(Buf);
+    FREE(Buffer);
     FREE(Offs2Col);
 }
 
-void LYSetupEdit(EDREC * edit, char *old_value, size_t buffer_limit, int display_limit)
+void LYSetupEdit(FieldEditor * edit, char *old_value, size_t buffer_limit, int display_limit)
 {
-    CTRACE((tfp, "LYSetupEdit buffer %u, display %d:%s\n",
-	    (unsigned) buffer_limit,
+    CTRACE((tfp, "LYSetupEdit buffer %lu, display %d:%s\n",
+	    (unsigned long) buffer_limit,
 	    display_limit,
 	    old_value));
 
@@ -2934,28 +2999,28 @@ void LYSetupEdit(EDREC * edit, char *old_value, size_t buffer_limit, int display
     LYGetYX(StartY, StartX);
     PadChar = ' ';
     IsDirty = TRUE;
-    PanOn = FALSE;
-    CurModif = 0;
+    IsPanned = FALSE;
+    InputMods = 0;
 
-    MaxLen = buffer_limit;
-    DspWdth = display_limit;
-    Margin = 0;
-    Pos = (int) strlen(old_value);
+    BufAlloc = buffer_limit;
+    DpyWidth = display_limit;
+    PanMargin = 0;
+    EditAt = (int) strlen(old_value);
 #ifdef ENHANCED_LINEEDIT
-    Mark = -1;			/* pos=0, but do not show it yet */
+    EditMark = -1;		/* pos=0, but do not show it yet */
 #endif
-    DspStart = 0;
+    DpyStart = 0;
 
     updateMargin(edit);
 
-    StrLen = strlen(old_value);
-    Buf = typecallocn(char, MaxLen + 1);
+    BufInUse = strlen(old_value);
+    Buffer = typecallocn(char, BufAlloc + 1);
 
-    if (Buf == 0)
+    if (Buffer == 0)
 	outofmem(__FILE__, "LYSetupEdit");
 
-    LYStrNCpy(Buf, old_value, buffer_limit);
-    Offs2Col = typecallocn(int, MaxLen + 1);
+    LYStrNCpy(Buffer, old_value, buffer_limit);
+    Offs2Col = typecallocn(int, BufAlloc + 1);
 
     if (Offs2Col == 0)
 	outofmem(__FILE__, "LYSetupEdit");
@@ -3065,13 +3130,13 @@ static int map_active = 0;
 #define map_active 0
 #endif
 
-int LYEditInsert(EDREC * edit, unsigned const char *s,
+int LYEditInsert(FieldEditor * edit, unsigned const char *s,
 		 int len,
 		 int map GCC_UNUSED,
 		 int maxMessage)
 {
-    int length = (int) strlen(Buf);
-    int remains = (int) MaxLen - (length + len);
+    int length = (int) strlen(Buffer);
+    int remains = (int) BufAlloc - (length + len);
     int edited = 0, overflow = 0;
 
     /*
@@ -3080,20 +3145,20 @@ int LYEditInsert(EDREC * edit, unsigned const char *s,
     if (remains < 0) {
 	overflow = 1;
 	len = 0;
-	if ((int) MaxLen > length)	/* Insert as much as we can */
-	    len = (int) MaxLen - length;
+	if ((int) BufAlloc > length)	/* Insert as much as we can */
+	    len = (int) BufAlloc - length;
 	else
 	    goto finish;
     }
     ExtendEditor(edit, length + len);
-    Buf[length + len] = '\0';
-    for (; length >= Pos; length--)	/* Make room */
-	Buf[length + len] = Buf[length];
+    Buffer[length + len] = '\0';
+    for (; length >= EditAt; length--)	/* Make room */
+	Buffer[length + len] = Buffer[length];
 #ifdef EXP_KEYBOARD_LAYOUT
     if (map < 0)
 	map = map_active;
     if (map && IS_UTF8_TTY) {
-	int off = Pos;
+	int off = EditAt;
 	unsigned const char *e = s + len;
 	char *tail = 0;
 
@@ -3111,31 +3176,31 @@ int LYEditInsert(EDREC * edit, unsigned const char *s,
 			remains -= l - 1;
 			if (remains < 0) {
 			    if (tail)
-				strcpy(Buf + off, tail);
+				strcpy(Buffer + off, tail);
 			    FREE(tail);
 			    len = off;
 			    overflow = 1;
 			    goto finish;
 			}
 			if (l > 1 && !tail)
-			    StrAllocCopy(tail, Buf + Pos + len);
+			    StrAllocCopy(tail, Buffer + EditAt + len);
 		    } else
 			utfbuf[0] = '?';
 		} else
 		    utfbuf[0] = (char) ucode;
 	    }
-	    StrNCpy(Buf + off, utfbuf, l);
+	    StrNCpy(Buffer + off, utfbuf, l);
 	    edited = 1;
 	    off += l;
 	    s++;
 	}
 	if (tail)
-	    strcpy(Buf + off, tail);
-	len = off - Pos;
+	    strcpy(Buffer + off, tail);
+	len = off - EditAt;
 	FREE(tail);
     } else if (map) {
 	unsigned const char *e = s + len;
-	unsigned char *t = (unsigned char *) Buf + Pos;
+	unsigned char *t = (unsigned char *) Buffer + EditAt;
 
 	while (s < e) {
 	    int ch;
@@ -3154,46 +3219,48 @@ int LYEditInsert(EDREC * edit, unsigned const char *s,
     } else
 #endif /* defined EXP_KEYBOARD_LAYOUT */
     {
-	StrNCpy(Buf + Pos, (const char *) s, len);
+	StrNCpy(Buffer + EditAt, (const char *) s, len);
 	edited = 1;
     }
 
   finish:
-    Pos += len;
-    StrLen += (size_t) len;
+    EditAt += len;
+    BufInUse += (size_t) len;
     if (edited)
 	IsDirty = TRUE;
     if (overflow && maxMessage)
 	_statusline(MAXLEN_REACHED_DEL_OR_MOV);
 #ifdef ENHANCED_LINEEDIT
-    if (Mark > Pos)
-	Mark += len;
-    else if (Mark < -(1 + Pos))
-	Mark -= len;
-    if (Mark >= 0)
-	Mark = -(1 + Mark);	/* Disable it */
+    if (EditMark > EditAt)
+	EditMark += len;
+    else if (EditMark < -(1 + EditAt))
+	EditMark -= len;
+    disableEditMark();
 #endif
     return edited;
 }
 
-/* returns 0    character processed
- *         -ch  if action should be performed outside of line-editing mode
- *         ch   otherwise
+/*
+ * Do one edit-operation, given the input 'ch' and working buffer 'edit'.
+ *
+ * If the input is processed, returns zero.
+ * If the action should be performed outside of line-editing mode, return -ch.
+ * Otherwise, e.g., returns 'ch'.
  */
-int LYEdit1(EDREC * edit, int ch,
-	    int action,
-	    int maxMessage)
+int LYDoEdit(FieldEditor * edit, int ch,
+	     int action,
+	     int maxMessage)
 {
     int i;
     int length;
     unsigned char uch;
     int offset;
 
-    if ((int) MaxLen <= 0)
+    if ((int) BufAlloc <= 0)
 	return (0);		/* Be defensive */
 
-    StrLen = strlen(&Buf[0]);
-    length = (int) StrLen;
+    BufInUse = strlen(&Buffer[0]);
+    length = (int) BufInUse;
 
     switch (action) {
 #ifdef EXP_KEYBOARD_LAYOUT
@@ -3207,10 +3274,8 @@ int LYEdit1(EDREC * edit, int ch,
 #ifndef CJK_EX
     case LYE_AIX:
 	/*
-	 * Hex 97.
-	 * Fall through as a character for CJK, or if this is a valid character
-	 * in the current display character set.  Otherwise, we treat this as
-	 * LYE_ENTER.
+	 * Handle CJK characters, or as a valid character in the current
+	 * display character set.  Otherwise, we treat this as LYE_ENTER.
 	 */
 	if (!IS_CJK_TTY && LYlowest_eightbit[current_char_set] > 0x97)
 	    return (ch);
@@ -3227,28 +3292,27 @@ int LYEdit1(EDREC * edit, int ch,
 	 * replacement for a character in the 8-bit C1 control range.
 	 *
 	 * This is meant to undo transformations like 0x81 -> 0x1b 0x41 (ESC A)
-	 * etc.  done by slang on Unix and possibly some comm programs.  It's
+	 * etc., done by slang on Unix and possibly some comm programs.  It's
 	 * an imperfect workaround that doesn't work for all such characters.
 	 */
 	ch &= 0xFF;
 	if (ch + 64 >= LYlowest_eightbit[current_char_set])
 	    ch += 64;
 
-	if (Pos <= ((int) MaxLen) && StrLen < MaxLen) {
+	if (EditAt <= ((int) BufAlloc) && BufInUse < BufAlloc) {
 #ifdef ENHANCED_LINEEDIT
-	    if (Mark > Pos)
-		Mark++;
-	    else if (Mark < -(1 + Pos))
-		Mark--;
-	    if (Mark >= 0)
-		Mark = -(1 + Mark);	/* Disable it */
+	    if (EditMark > EditAt)
+		EditMark++;
+	    else if (EditMark < -(1 + EditAt))
+		EditMark--;
+	    disableEditMark();
 #endif
 	    ExtendEditor(edit, length + 1);
-	    for (i = length; i >= Pos; i--)	/* Make room */
-		Buf[i + 1] = Buf[i];
-	    Buf[length + 1] = '\0';
-	    Buf[Pos] = (char) ch;
-	    Pos++;
+	    for (i = length; i >= EditAt; i--)	/* Make room */
+		Buffer[i + 1] = Buffer[i];
+	    Buffer[length + 1] = '\0';
+	    Buffer[EditAt] = (char) ch;
+	    EditAt++;
 	} else {
 	    if (maxMessage) {
 		_statusline(MAXLEN_REACHED_DEL_OR_MOV);
@@ -3257,203 +3321,143 @@ int LYEdit1(EDREC * edit, int ch,
 	}
 	break;
 
-    case LYE_BACKW:
-	/*
-	 * Backword.
-	 * Definition of word is very naive:  1 or more a/n characters.
-	 */
-#ifndef SUPPORT_MULTIBYTE_EDIT
-	while (Pos && !isalnum(UCH(Buf[Pos - 1])))
-	    Pos--;
-	while (Pos && isalnum(UCH(Buf[Pos - 1])))
-	    Pos--;
-#else
-	while (Pos && !(isalnum(UCH(Buf[Pos - 1])) || is8bits(Buf[Pos - 1])))
-	    Pos--;
-	while (Pos && (isalnum(UCH(Buf[Pos - 1])) || is8bits(Buf[Pos - 1])))
-	    Pos--;
-#endif
+    case LYE_BACKW:		/* go backward one word */
+	while (EditAt && !IsWordChar(Buffer[EditAt - 1]))
+	    EditAt--;
+	while (EditAt && IsWordChar(UCH(Buffer[EditAt - 1])))
+	    EditAt--;
 	break;
 
-    case LYE_FORWW:
-	/*
-	 * Word forward.
-	 */
-#ifndef SUPPORT_MULTIBYTE_EDIT
-	while (isalnum(UCH(Buf[Pos])))
-	    Pos++;		/* '\0' is not a/n */
-	while (!isalnum(UCH(Buf[Pos])) && Buf[Pos])
-	    Pos++;
-#else
-	while (isalnum(UCH(Buf[Pos])) || is8bits(Buf[Pos]))
-	    Pos++;		/* '\0' is not a/n */
-	while (!(isalnum(UCH(Buf[Pos])) || is8bits(Buf[Pos])) && Buf[Pos])
-	    Pos++;
-#endif
+    case LYE_FORWW:		/* go forward one word */
+	while (IsWordChar(UCH(Buffer[EditAt])))
+	    EditAt++;
+	while (!IsWordChar(Buffer[EditAt]) && Buffer[EditAt])
+	    EditAt++;
 	break;
 
-    case LYE_ERASE:
-	/*
-	 * Erase the line to start fresh.
-	 */
-	Buf[0] = '\0';
+    case LYE_ERASE:		/* erase the line */
+	Buffer[0] = '\0';
 #ifdef ENHANCED_LINEEDIT
-	Mark = -1;		/* Do not show the mark */
+	EditMark = -1;		/* Do not show the mark */
 #endif
-	/* fall through */
+	/* FALLTHRU */
 
-    case LYE_BOL:
-	/*
-	 * Go to first column.
-	 */
-	Pos = 0;
+    case LYE_BOL:		/* go to beginning of line  */
+	EditAt = 0;
 	break;
 
-    case LYE_EOL:
-	/*
-	 * Go to last column.
-	 */
-	Pos = length;
+    case LYE_EOL:		/* go to end of line  */
+	EditAt = length;
 	break;
 
-    case LYE_DELNW:
-	/*
-	 * Delete next word.
-	 */
-	offset = Pos;
-	LYEdit1(edit, 0, LYE_FORWW, FALSE);
-	offset = Pos - offset;
-	Pos -= offset;
+    case LYE_DELNW:		/* delete next word  */
+	offset = EditAt;
+	LYDoEdit(edit, 0, LYE_FORWW, FALSE);
+	offset = EditAt - offset;
+	EditAt -= offset;
 
 	goto shrink;		/* right below */
 
-    case LYE_DELPW:
-	/*
-	 * Delete previous word.
-	 */
-	offset = Pos;
-	LYEdit1(edit, 0, LYE_BACKW, FALSE);
-	offset -= Pos;
+    case LYE_DELPW:		/* delete previous word  */
+	offset = EditAt;
+	LYDoEdit(edit, 0, LYE_BACKW, FALSE);
+	offset -= EditAt;
 
       shrink:
-	for (i = Pos; i < length - offset + 1; i++)
-	    Buf[i] = Buf[i + offset];
+	for (i = EditAt; i < length - offset + 1; i++)
+	    Buffer[i] = Buffer[i + offset];
 #ifdef ENHANCED_LINEEDIT
-	if (Mark >= 0)
-	    Mark = -(1 + Mark);	/* Disable it */
-	if (Mark <= -(1 + Pos + offset))
-	    Mark += offset;	/* Shift it */
-	if (-(1 + Pos + offset) < Mark && Mark < -(1 + Pos))
-	    Mark = -(1 + Pos);	/* Set to the current position */
+	disableEditMark();
+	if (EditMark <= -(1 + EditAt + offset))
+	    EditMark += offset;	/* Shift it */
+	if (-(1 + EditAt + offset) < EditMark && EditMark < -(1 + EditAt))
+	    EditMark = -(1 + EditAt);	/* Set to the current position */
 #endif
 
 	break;
 
-    case LYE_DELBL:
-	/*
-	 * Delete from current cursor position back to BOL.
-	 */
-	for (i = Pos; i < length + 1; i++)
-	    Buf[i - Pos] = Buf[i];
+    case LYE_DELBL:		/* delete from cursor to beginning of line */
+	for (i = EditAt; i < length + 1; i++)
+	    Buffer[i - EditAt] = Buffer[i];
 
 #ifdef ENHANCED_LINEEDIT
-	if (Mark >= 0)
-	    Mark = -(1 + Mark);	/* Disable it */
-	if (Mark <= -(1 + Pos))
-	    Mark += Pos;	/* Shift it */
+	disableEditMark();
+	if (EditMark <= -(1 + EditAt))
+	    EditMark += EditAt;	/* Shift it */
 	else
-	    Mark = -1;		/* Reset it */
+	    EditMark = -1;	/* Reset it */
 #endif
-	Pos = 0;
+	EditAt = 0;
 	break;
 
-    case LYE_DELEL:		/* @@@ */
-	/*
-	 * Delete from current cursor position thru EOL.
-	 */
-	Buf[Pos] = '\0';
+    case LYE_DELEL:		/* delete from cursor to end of line */
+	Buffer[EditAt] = '\0';
 #ifdef ENHANCED_LINEEDIT
-	if (Mark >= 0)
-	    Mark = -(1 + Mark);	/* Disable it */
-	if (Mark <= -(1 + Pos))
-	    Mark = -1;		/* Reset it */
+	disableEditMark();
+	if (EditMark <= -(1 + EditAt))
+	    EditMark = -1;	/* Reset it */
 #endif
 	break;
 
-    case LYE_DELN:
-	/*
-	 * Delete next character (I-beam style cursor), or current character
-	 * (box/underline style cursor).
-	 */
-	if (Pos >= length)
+    case LYE_DELN:		/* delete next character */
+	if (EditAt >= length)
 	    break;
 #ifndef SUPPORT_MULTIBYTE_EDIT
-	Pos++;
+	EditAt++;
 #else
-	Pos += mbcs_skip(Buf + Pos, 1);
+	EditAt += mbcs_skip(Buffer + EditAt, 1);
 #endif
-	/* fall through - DO NOT RELOCATE the LYE_DELN case wrt LYE_DELP */
+	/* FALLTHRU */
 
-    case LYE_DELP:
-	/*
-	 * Delete preceding character.
-	 */
-	if (length == 0 || Pos == 0)
+    case LYE_DELP:		/* delete previous character */
+	if (length == 0 || EditAt == 0)
 	    break;
 
 #ifndef SUPPORT_MULTIBYTE_EDIT
 #ifdef ENHANCED_LINEEDIT
-	if (Mark >= 0)
-	    Mark = -(1 + Mark);	/* Disable it */
-	if (Mark <= -(1 + Pos))
-	    Mark++;
+	disableEditMark();
+	if (EditMark <= -(1 + EditAt))
+	    EditMark++;
 #endif
-	Pos--;
-	for (i = Pos; i < length; i++)
-	    Buf[i] = Buf[i + 1];
+	EditAt--;
+	for (i = EditAt; i < length; i++)
+	    Buffer[i] = Buffer[i + 1];
 #else /* SUPPORT_MULTIBYTE_EDIT */
-	offset = Pos - mbcs_skip(Buf, mbcs_glyphs(Buf, Pos) - 1);
-	Pos -= offset;
-	for (i = Pos; i < length - offset + 1; i++)
-	    Buf[i] = Buf[i + offset];
+	offset = EditAt - mbcs_skip(Buffer, mbcs_glyphs(Buffer, EditAt) - 1);
+	EditAt -= offset;
+	for (i = EditAt; i < length - offset + 1; i++)
+	    Buffer[i] = Buffer[i + offset];
 
 #ifdef ENHANCED_LINEEDIT
-	if (Mark >= 0)
-	    Mark = -(1 + Mark);	/* Disable it */
-	if (Mark <= -(1 + Pos))
-	    Mark += offset;	/* Shift it */
+	disableEditMark();
+	if (EditMark <= -(1 + EditAt))
+	    EditMark += offset;	/* Shift it */
 #endif
 
 #endif /* SUPPORT_MULTIBYTE_EDIT */
 	break;
 
     case LYE_FORW_RL:
-    case LYE_FORW:
-	/*
-	 * Move cursor to the right.
-	 */
+    case LYE_FORW:		/* move cursor forward */
 #ifndef SUPPORT_MULTIBYTE_EDIT
-	if (Pos < length)
-	    Pos++;
+	if (EditAt < length)
+	    EditAt++;
 #else
-	if (Pos < length)
-	    Pos += mbcs_skip(Buf + Pos, 1);
+	if (EditAt < length)
+	    EditAt += mbcs_skip(Buffer + EditAt, 1);
 #endif
 	else if (action == LYE_FORW_RL)
 	    return -ch;
 	break;
 
     case LYE_BACK_LL:
-    case LYE_BACK:
-	/*
-	 * Left-arrow move cursor to the left.
-	 */
+    case LYE_BACK:		/* move cursor backward */
 #ifndef SUPPORT_MULTIBYTE_EDIT
-	if (Pos > 0)
-	    Pos--;
+	if (EditAt > 0)
+	    EditAt--;
 #else
-	if (Pos > 0)
-	    Pos = mbcs_skip(Buf, mbcs_glyphs(Buf, Pos) - 1);
+	if (EditAt > 0)
+	    EditAt = mbcs_skip(Buffer, mbcs_glyphs(Buffer, EditAt) - 1);
 #endif
 	else if (action == LYE_BACK_LL)
 	    return -ch;
@@ -3470,91 +3474,74 @@ int LYEdit1(EDREC * edit, int ch,
 	    break;		/* Can't help it now */
 #endif
 
-	if (length <= 1 || Pos == 0)
+	if (length <= 1 || EditAt == 0)
 	    return (ch);
-	if (Pos == length)
-	    Pos--;
-	if (Mark < 0)
-	    Mark = -(1 + Mark);	/* Temporary enable it */
-	if (Mark == Pos || Mark == Pos + 1)
-	    Mark = Pos - 1;
-	if (Mark >= 0)
-	    Mark = -(1 + Mark);	/* Disable it */
-	if (Buf[Pos - 1] == Buf[Pos]) {
-	    Pos++;
+	if (EditAt == length)
+	    EditAt--;
+	enableEditMark();
+	if (EditMark == EditAt || EditMark == EditAt + 1)
+	    EditMark = EditAt - 1;
+	disableEditMark();
+	if (Buffer[EditAt - 1] == Buffer[EditAt]) {
+	    EditAt++;
 	    break;
 	}
-	i = Buf[Pos - 1];
-	Buf[Pos - 1] = Buf[Pos];
-	Buf[Pos++] = (char) i;
+	i = Buffer[EditAt - 1];
+	Buffer[EditAt - 1] = Buffer[EditAt];
+	Buffer[EditAt++] = (char) i;
 	break;
 
-    case LYE_SETMARK:
-	/*
-	 * primitive emacs-like set-mark-command
-	 */
-	Mark = Pos;
+    case LYE_SETMARK:		/* Emacs-like set-mark-command */
+	EditMark = EditAt;
 	return (0);
 
-    case LYE_XPMARK:
-	/*
-	 * emacs-like exchange-point-and-mark
-	 */
-	if (Mark < 0)
-	    Mark = -(1 + Mark);	/* Enable it */
-	if (Mark == Pos)
+    case LYE_XPMARK:		/* Emacs-like exchange-point-and-mark */
+	enableEditMark();
+	if (EditMark == EditAt)
 	    return (0);
-	i = Pos;
-	Pos = Mark;
-	Mark = i;
+	i = EditAt;
+	EditAt = EditMark;
+	EditMark = i;
 	break;
 
-    case LYE_KILLREG:
-	/*
-	 * primitive emacs-like kill-region
-	 */
-	if (Mark < 0)
-	    Mark = -(1 + Mark);	/* Enable it */
-	if (Mark == Pos) {
+    case LYE_KILLREG:		/* Emacs-like kill-region */
+	enableEditMark();
+	if (EditMark == EditAt) {
 	    BStrFree(killbuffer);
 	    return (0);
 	}
-	if (Mark > Pos)
-	    LYEdit1(edit, 0, LYE_XPMARK, FALSE);
+	if (EditMark > EditAt)
+	    LYDoEdit(edit, 0, LYE_XPMARK, FALSE);
 	{
-	    int reglen = Pos - Mark;
+	    int reglen = EditAt - EditMark;
 
-	    BStrCopy1(killbuffer, Buf + Mark, reglen);
-	    for (i = Mark; Buf[i + reglen]; i++)
-		Buf[i] = Buf[i + reglen];
-	    Buf[i] = Buf[i + reglen];	/* terminate */
-	    Pos = Mark;
+	    BStrCopy1(killbuffer, Buffer + EditMark, reglen);
+	    for (i = EditMark; Buffer[i + reglen]; i++)
+		Buffer[i] = Buffer[i + reglen];
+	    Buffer[i] = Buffer[i + reglen];	/* terminate */
+	    EditAt = EditMark;
 	}
-	if (Mark >= 0)
-	    Mark = -(1 + Mark);	/* Disable it */
+	disableEditMark();
 	break;
 
-    case LYE_YANK:
-	/*
-	 * primitive emacs-like yank
-	 */
+    case LYE_YANK:		/* Emacs-like yank */
 	if (!killbuffer) {
-	    Mark = -(1 + Pos);
+	    EditMark = -(1 + EditAt);
 	    return (0);
 	} else {
 	    int yanklen = killbuffer->len;
 
-	    if ((Pos + yanklen) <= (int) MaxLen &&
-		StrLen + (size_t) yanklen <= MaxLen) {
+	    if ((EditAt + yanklen) <= (int) BufAlloc &&
+		BufInUse + (size_t) yanklen <= BufAlloc) {
 
-		ExtendEditor(edit, Pos + yanklen);
+		ExtendEditor(edit, EditAt + yanklen);
 
-		Mark = -(1 + Pos);
+		EditMark = -(1 + EditAt);
 
-		for (i = length; i >= Pos; i--)		/* Make room */
-		    Buf[i + yanklen] = Buf[i];
+		for (i = length; i >= EditAt; i--)	/* Make room */
+		    Buffer[i + yanklen] = Buffer[i];
 		for (i = 0; i < yanklen; i++)
-		    Buf[Pos++] = killbuffer->str[i];
+		    Buffer[EditAt++] = killbuffer->str[i];
 
 	    } else if (maxMessage) {
 		_statusline(MAXLEN_REACHED_DEL_OR_MOV);
@@ -3565,18 +3552,18 @@ int LYEdit1(EDREC * edit, int ch,
 #endif /* ENHANCED_LINEEDIT */
 
     case LYE_UPPER:
-	LYUpperCase(Buf);
+	LYUpperCase(Buffer);
 	break;
 
     case LYE_LOWER:
-	LYLowerCase(Buf);
+	LYLowerCase(Buffer);
 	break;
 
     default:
 	return (ch);
     }
     IsDirty = TRUE;
-    StrLen = strlen(&Buf[0]);
+    BufInUse = strlen(&Buffer[0]);
     return (0);
 }
 
@@ -3603,7 +3590,7 @@ int get_popup_number(const char *msg,
     /*
      * Get the number, possibly with a suffix, from the user.
      */
-    if (LYgetBString(&temp, VISIBLE, 0, NORECALL) < 0 || isBEmpty(temp)) {
+    if (LYgetBString(&temp, FALSE, 0, NORECALL) < 0 || isBEmpty(temp)) {
 	HTInfoMsg(CANCELLED);
 	*c = '\0';
 	*rel = '\0';
@@ -3655,7 +3642,7 @@ int get_popup_number(const char *msg,
 #  define TmpStyleOff(s)
 #endif /* defined USE_COLOR_STYLE */
 
-static void remember_column(EDREC * edit, int offset)
+static void remember_column(FieldEditor * edit, int offset)
 {
     int y0, x0;
 
@@ -3688,24 +3675,24 @@ static void fill_edited_line(int prompting GCC_UNUSED, int length, int ch)
 
 /*
  * Multibyte string display subroutine.
- * EDREC fields retain their values as byte offsets.
+ * FieldEditor fields retain their values as byte offsets.
  * All external logic still works fine with byte values.
  */
-void LYRefreshEdit(EDREC * edit)
+void LYRefreshEdit(FieldEditor * edit)
 {
     /* bytes and characters are not the same thing */
 #if defined(DEBUG_EDIT)
     int all_bytes;
 #endif
-    int pos_bytes = Pos;
+    int pos_bytes = EditAt;
     int dpy_bytes;
     int lft_bytes;		/* base of string which is displayed */
 
     /* cells refer to display-columns on the screen */
-    int all_cells;		/* total of display-cells in Buf */
+    int all_cells;		/* total of display-cells in Buffer */
     int dpy_cells;		/* number of cells which are displayed */
     int lft_cells;		/* number of cells before display (on left) */
-    int pos_cells;		/* number of display-cells up to Pos */
+    int pos_cells;		/* number of display-cells up to EditAt */
 
 #if defined(SUPPORT_MULTIBYTE_EDIT)
     int dpy_chars;
@@ -3734,63 +3721,62 @@ void LYRefreshEdit(EDREC * edit)
     /*
      * If we've made no changes, or if there is nothing to display, just leave.
      */
-    if (!IsDirty || (DspWdth == 0))
+    if (!IsDirty || (DpyWidth == 0))
 	return;
 
-    CTRACE((tfp, "LYRefreshEdit:%s\n", Buf));
+    CTRACE((tfp, "LYRefreshEdit:%s\n", Buffer));
 
     IsDirty = FALSE;
 
-    StrLen = strlen(&Buf[0]);
+    BufInUse = strlen(&Buffer[0]);
 
-    all_cells = LYstrCells(Buf);
-    pos_cells = LYstrExtent2(Buf, Pos);
+    all_cells = LYstrCells(Buffer);
+    pos_cells = LYstrExtent2(Buffer, EditAt);
 
 #if defined(SUPPORT_MULTIBYTE_EDIT) && defined(DEBUG_EDIT)
-    all_bytes = (int) StrLen;
-    lft_chars = mbcs_glyphs(Buf, DspStart);
-    pos_chars = mbcs_glyphs(Buf, Pos);
-    all_chars = mbcs_glyphs(Buf, all_bytes);
+    all_bytes = (int) BufInUse;
+    lft_chars = mbcs_glyphs(Buffer, DpyStart);
+    pos_chars = mbcs_glyphs(Buffer, EditAt);
+    all_chars = mbcs_glyphs(Buffer, all_bytes);
 #endif
 
     /*
      * Now we have:
-     *                .--DspWdth---.
+     *                .--DpyWidth--.
      *      +---------+=============+-----------+
-     *      |         |M           M|           |   (M=margin)
+     *      |         |M           M|           |   (M=PanMargin)
      *      +---------+=============+-----------+
-     *      0         DspStart                   StrLen
+     *      0         DpyStart                   BufInUse
      *
-     * Insertion point can be anywhere between 0 and stringlength.  Figure out
-     * new display starting point.
+     * Insertion point can be anywhere between 0 and stringlength.  Calculate
+     * a new display starting point.
      *
-     * The first "if" below makes Lynx scroll several columns at a time when
-     * extending the string.  Looks awful, but that way we can keep up with
-     * data entry at low baudrates.
+     * First, make Lynx scroll several columns at a time as needed when
+     * extending the string.   Doing this helps with lowspeed connections.
      */
 
-    lft_bytes = DspStart;
-    lft_cells = LYstrExtent2(Buf, DspStart);
+    lft_bytes = DpyStart;
+    lft_cells = LYstrExtent2(Buffer, DpyStart);
 
-    if ((lft_cells + DspWdth) <= all_cells) {
-	if (pos_cells >= (lft_cells + DspWdth) - Margin) {
-	    lft_cells = (pos_cells - DspWdth) + Margin;
+    if ((lft_cells + DpyWidth) <= all_cells) {
+	if (pos_cells >= (lft_cells + DpyWidth) - PanMargin) {
+	    lft_cells = (pos_cells - DpyWidth) + PanMargin;
 #ifdef SUPPORT_MULTIBYTE_EDIT
-	    lft_chars = cell2char(Buf, lft_cells);
-	    lft_bytes = mbcs_skip(Buf, lft_chars);
+	    lft_chars = cell2char(Buffer, lft_cells);
+	    lft_bytes = mbcs_skip(Buffer, lft_chars);
 #else
 	    lft_bytes = lft_cells;
 #endif /* SUPPORT_MULTIBYTE_EDIT */
 	}
     }
 
-    if (pos_cells < lft_cells + Margin) {
-	lft_cells = pos_cells - Margin;
+    if (pos_cells < lft_cells + PanMargin) {
+	lft_cells = pos_cells - PanMargin;
 	if (lft_cells < 0)
 	    lft_cells = 0;
 #ifdef SUPPORT_MULTIBYTE_EDIT
-	lft_chars = cell2char(Buf, lft_cells);
-	lft_bytes = mbcs_skip(Buf, lft_chars);
+	lft_chars = cell2char(Buffer, lft_cells);
+	lft_bytes = mbcs_skip(Buffer, lft_chars);
 #else
 	lft_bytes = lft_cells;
 #endif /* SUPPORT_MULTIBYTE_EDIT */
@@ -3803,7 +3789,7 @@ void LYRefreshEdit(EDREC * edit)
      * overwriting part of a multicolumn character which may lie in the first
      * position.
      */
-    if (PanOn && lft_cells) {
+    if (IsPanned && lft_cells) {
 	CTRACE_EDIT((tfp, "Draw left scroll-indicator\n"));
 	TmpStyleOn(prompting ? s_prompt_edit_arr : s_aedit_arr);
 	LYmove(StartY, StartX);
@@ -3812,15 +3798,15 @@ void LYRefreshEdit(EDREC * edit)
 	lft_shift = 1;
     }
 
-    str = &Buf[lft_bytes];
-    DspStart = lft_bytes;
+    str = &Buffer[lft_bytes];
+    DpyStart = lft_bytes;
 
     dpy_cells = all_cells - lft_cells;
     CTRACE_EDIT((tfp, "Comparing dpy_cells %d > (%d - %d)\n",
-		 dpy_cells, DspWdth, lft_shift));
-    if (dpy_cells > (DspWdth - lft_shift)) {
+		 dpy_cells, DpyWidth, lft_shift));
+    if (dpy_cells > (DpyWidth - lft_shift)) {
 	rgt_shift = 1;
-	dpy_cells = (DspWdth - lft_shift - rgt_shift);
+	dpy_cells = (DpyWidth - lft_shift - rgt_shift);
     }
     for (;;) {
 #ifdef SUPPORT_MULTIBYTE_EDIT
@@ -3899,17 +3885,17 @@ void LYRefreshEdit(EDREC * edit)
 	Offs2Col[i] = cell + StartX;
     } else {
 #if defined(ENHANCED_LINEEDIT) && defined(USE_COLOR_STYLE)
-	if (Mark >= 0 && DspStart > Mark)
+	if (EditMark >= 0 && DpyStart > EditMark)
 	    TmpStyleOn(prompting ? s_prompt_sel : s_aedit_sel);
 #endif
 	remember_column(edit, 0);
 	for (i = 0; i < dpy_bytes; i++) {
 #if defined(ENHANCED_LINEEDIT) && defined(USE_COLOR_STYLE)
-	    if (Mark >= 0 && ((DspStart + i == Mark && Pos > Mark)
-			      || (DspStart + i == Pos && Pos < Mark)))
+	    if (EditMark >= 0 && ((DpyStart + i == EditMark && EditAt > EditMark)
+				  || (DpyStart + i == EditAt && EditAt < EditMark)))
 		TmpStyleOn(prompting ? s_prompt_sel : s_aedit_sel);
-	    if (Mark >= 0 && ((DspStart + i == Mark && Pos < Mark)
-			      || (DspStart + i == Pos && Pos > Mark)))
+	    if (EditMark >= 0 && ((DpyStart + i == EditMark && EditAt < EditMark)
+				  || (DpyStart + i == EditAt && EditAt > EditMark)))
 		TmpStyleOff(prompting ? s_prompt_sel : s_aedit_sel);
 #endif
 	    if (str[i] == 1 || str[i] == 2 ||
@@ -3935,10 +3921,10 @@ void LYRefreshEdit(EDREC * edit)
 	    remember_column(edit, i + 1);
 	}
 #if defined(ENHANCED_LINEEDIT) && defined(USE_COLOR_STYLE)
-	if (Mark >= 0 &&
-	    ((DspStart + dpy_bytes <= Mark && DspStart + dpy_bytes > Pos)
-	     || (DspStart + dpy_bytes > Mark
-		 && DspStart + dpy_bytes <= Pos))) {
+	if (EditMark >= 0 &&
+	    ((DpyStart + dpy_bytes <= EditMark && DpyStart + dpy_bytes > EditAt)
+	     || (DpyStart + dpy_bytes > EditMark
+		 && DpyStart + dpy_bytes <= EditAt))) {
 	    TmpStyleOff(prompting ? s_prompt_sel : s_aedit_sel);
 	}
 #endif
@@ -3947,13 +3933,13 @@ void LYRefreshEdit(EDREC * edit)
     /*
      * Erase rest of input area.
      */
-    padsize = DspWdth - (Offs2Col[dpy_bytes] - StartX);
+    padsize = DpyWidth - (Offs2Col[dpy_bytes] - StartX);
     fill_edited_line(prompting, padsize, PadChar);
 
     /*
      * Scrolling indicators.
      */
-    if (PanOn && dpy_bytes && rgt_shift) {
+    if (IsPanned && dpy_bytes && rgt_shift) {
 	CTRACE((tfp, "Draw right-scroller offset (%d + %d)\n",
 		dpy_cells, lft_shift));
 	TmpStyleOn(prompting ? s_prompt_edit_arr : s_aedit_arr);
@@ -3965,7 +3951,7 @@ void LYRefreshEdit(EDREC * edit)
     /*
      * Finally, move the cursor to the point where the next edit will occur.
      */
-    LYmove(StartY, Offs2Col[Pos - DspStart]);
+    LYmove(StartY, Offs2Col[EditAt - DpyStart]);
 
 #ifdef USE_COLOR_STYLE
     if (estyle != NOSTYLE)
@@ -3974,10 +3960,10 @@ void LYRefreshEdit(EDREC * edit)
     LYrefresh();
 }
 
-static void reinsertEdit(EditFieldData *edit, char *result)
+static void reinsertEdit(FieldEditor * edit, char *result)
 {
     if (result != 0) {
-	LYEdit1(edit, '\0', LYE_ERASE, FALSE);
+	LYDoEdit(edit, '\0', LYE_ERASE, FALSE);
 	while (*result != '\0') {
 	    LYLineEdit(edit, (int) (*result), FALSE);
 	    result++;
@@ -4059,7 +4045,7 @@ int LYarrayWidth(STRING2PTR list)
     return result;
 }
 
-static void FormatChoiceNum(char *dst,
+static void FormatChoiceNum(char *target,
 			    int num_choices,
 			    int choice,
 			    const char *value)
@@ -4067,11 +4053,11 @@ static void FormatChoiceNum(char *dst,
     if (num_choices >= 0) {
 	int digits = (num_choices > 9) ? 2 : 1;
 
-	sprintf(dst, "%*d: %.*s",
+	sprintf(target, "%*d: %.*s",
 		digits, (choice + 1),
 		MAX_LINE - 9 - digits, value);
     } else {
-	LYStrNCpy(dst, value, MAX_LINE - 1);
+	LYStrNCpy(target, value, MAX_LINE - 1);
     }
 }
 
@@ -4829,7 +4815,7 @@ int LYhandlePopupList(int cur_choice,
 	case LYK_WHEREIS:
 	    if (isBEmpty(prev_target)) {
 		_statusline(ENTER_WHEREIS_QUERY);
-		if ((ch = LYgetBString(&prev_target, VISIBLE, 0, recall)) < 0) {
+		if ((ch = LYgetBString(&prev_target, FALSE, 0, recall)) < 0) {
 		    /*
 		     * User cancelled the search via ^G.  - FM
 		     */
@@ -4840,7 +4826,7 @@ int LYhandlePopupList(int cur_choice,
 
 	  check_recall:
 	    if (isBEmpty(prev_target) &&
-		!(recall && (ch == UPARROW || ch == DNARROW))) {
+		!(recall && (ch == UPARROW_KEY || ch == DNARROW_KEY))) {
 		/*
 		 * No entry.  Simply break.  - FM
 		 */
@@ -4848,7 +4834,7 @@ int LYhandlePopupList(int cur_choice,
 		goto restore_popup_statusline;
 	    }
 
-	    if (recall && ch == UPARROW) {
+	    if (recall && ch == UPARROW_KEY) {
 		if (FirstRecall) {
 		    /*
 		     * Use the current string or last query in the list.  - FM
@@ -4892,7 +4878,7 @@ int LYhandlePopupList(int cur_choice,
 			_statusline(EDIT_A_PREV_QUERY);
 		    }
 		    if ((ch = LYgetBString(&prev_target,
-					   VISIBLE, 0, recall)) < 0) {
+					   FALSE, 0, recall)) < 0) {
 			/*
 			 * User cancelled the search via ^G.  - FM
 			 */
@@ -4901,7 +4887,7 @@ int LYhandlePopupList(int cur_choice,
 		    }
 		    goto check_recall;
 		}
-	    } else if (recall && ch == DNARROW) {
+	    } else if (recall && ch == DNARROW_KEY) {
 		if (FirstRecall) {
 		    /*
 		     * Use the current string or first query in the list.  - FM
@@ -4945,7 +4931,7 @@ int LYhandlePopupList(int cur_choice,
 			_statusline(EDIT_A_PREV_QUERY);
 		    }
 		    if ((ch = LYgetBString(&prev_target,
-					   VISIBLE, 0, recall)) < 0) {
+					   FALSE, 0, recall)) < 0) {
 			/*
 			 * User cancelled the search via ^G. - FM
 			 */
@@ -5079,11 +5065,13 @@ int LYgetBString(bstring **inputline,
     int xlec = -2;
     int last_xlec = -1;
     int last_xlkc = -1;
-    EditFieldData MyEdit, *edit = &MyEdit;
+    FieldEditor MyEdit, *edit = &MyEdit;
 
 #ifdef SUPPORT_MULTIBYTE_EDIT
     BOOL refresh_mb = TRUE;
 #endif /* SUPPORT_MULTIBYTE_EDIT */
+    BOOL done = FALSE;
+    int result = -1;
 
     CTRACE((tfp, "called LYgetBString hidden %d, recall %d\n", hidden, (int) recall));
 
@@ -5101,8 +5089,8 @@ int LYgetBString(bstring **inputline,
     fep_on();
 #endif
 
-    for (;;) {
-      again:
+    while (!done) {
+      beginning:
 #ifndef SUPPORT_MULTIBYTE_EDIT
 	LYRefreshEdit(edit);
 #else /* SUPPORT_MULTIBYTE_EDIT */
@@ -5114,12 +5102,12 @@ int LYgetBString(bstring **inputline,
 #ifdef CJK_EX			/* for SJIS code */
 	if (!refresh_mb
 	    && (EditBinding(ch) != LYE_CHAR))
-	    goto again;
+	    goto beginning;
 #else
 	if (!refresh_mb
 	    && (EditBinding(ch) != LYE_CHAR)
 	    && (EditBinding(ch) != LYE_AIX))
-	    goto again;
+	    goto beginning;
 #endif
 #endif /* SUPPORT_MULTIBYTE_EDIT */
 
@@ -5137,18 +5125,20 @@ int LYgetBString(bstring **inputline,
 	    ch = LYCharINTERRUPT2;
 	}
 
-	if (recall != NORECALL && (ch == UPARROW || ch == DNARROW)) {
-	    BStrCopy0(*inputline, Buf);
-	    LYAddToCloset(recall, Buf);
+	if (recall != NORECALL && (ch == UPARROW_KEY || ch == DNARROW_KEY)) {
+	    BStrCopy0(*inputline, Buffer);
+	    LYAddToCloset(recall, Buffer);
 	    CTRACE((tfp, "LYgetstr(%s) recall\n", (*inputline)->str));
 #ifdef FEPCTRL
 	    fep_off();
 #endif
 	    LYFinishEdit(edit);
-	    return (ch);
+	    result = ch;
+	    done = TRUE;
+	    break;
 	}
-	ch |= CurModif;
-	CurModif = 0;
+	ch |= InputMods;
+	InputMods = 0;
 	if (last_xlkc != -1) {
 	    if (ch == last_xlkc)
 		ch |= LKC_MOD3;
@@ -5156,7 +5146,7 @@ int LYgetBString(bstring **inputline,
 	}
 #ifndef WIN_EX
 	if (LKC_TO_LAC(keymap, ch) == LYK_REFRESH)
-	    goto again;
+	    goto beginning;
 #endif
 	last_xlec = xlec;
 	xlec = EditBinding(ch);
@@ -5168,16 +5158,10 @@ int LYgetBString(bstring **inputline,
 	}
 	switch (xlec) {
 	case LYE_SETM1:
-	    /*
-	     * Set flag for modifier 1.
-	     */
-	    CurModif |= LKC_MOD1;
+	    InputMods |= LKC_MOD1;
 	    break;
 	case LYE_SETM2:
-	    /*
-	     * Set flag for modifier 2.
-	     */
-	    CurModif |= LKC_MOD2;
+	    InputMods |= LKC_MOD2;
 	    break;
 	case LYE_TAB:
 	    if (xlec == last_xlec && recall != NORECALL) {
@@ -5190,7 +5174,7 @@ int LYgetBString(bstring **inputline,
 		    int num_options = LYarrayLength((STRING2PTR) data);
 
 		    while (cur_choice < num_options
-			   && strcasecomp(data[cur_choice], Buf) < 0)
+			   && strcasecomp(data[cur_choice], Buffer) < 0)
 			cur_choice++;
 
 		    LYGetYX(old_y, old_x);
@@ -5211,17 +5195,15 @@ int LYgetBString(bstring **inputline,
 		    FREE(data);
 		}
 	    } else {
-		reinsertEdit(edit, LYFindInCloset(recall, Buf));
+		reinsertEdit(edit, LYFindInCloset(recall, Buffer));
 	    }
 	    break;
 
-#ifndef CJK_EX			/* 1997/11/03 (Mon) 20:13:45 */
+#ifndef CJK_EX
 	case LYE_AIX:
 	    /*
-	     * Hex 97.
-	     * Treat as a character for CJK, or if this is a valid character in
-	     * the current display character set.  Otherwise, we treat this as
-	     * LYE_ENTER.
+	     * Handle CJK characters, or as a valid character in the current
+	     * display character set.  Otherwise, we treat this as LYE_ENTER.
 	     */
 	    if (ch != '\t' &&
 		(IS_CJK_TTY ||
@@ -5232,33 +5214,30 @@ int LYgetBString(bstring **inputline,
 	    /* FALLTHRU */
 #endif
 	case LYE_ENTER:
-	    /*
-	     * Terminate the string and return.
-	     */
-	    BStrCopy0(*inputline, Buf);
+	    BStrCopy0(*inputline, Buffer);
 	    if (!hidden)
-		LYAddToCloset(recall, Buf);
+		LYAddToCloset(recall, Buffer);
 	    CTRACE((tfp, "LYgetstr(%s) LYE_ENTER\n", (*inputline)->str));
 #ifdef FEPCTRL
 	    fep_off();
 #endif
 	    LYFinishEdit(edit);
-	    return (ch);
+	    result = ch;
+	    done = TRUE;
+	    break;
 
 #ifdef CAN_CUT_AND_PASTE
-	    /* 1998/10/01 (Thu) 15:05:49 */
-
 	case LYE_PASTE:
 	    {
 		unsigned char *s = (unsigned char *) get_clip_grab(), *e;
-		int len;
+		size_t len;
 
 		if (!s)
 		    break;
-		len = (int) strlen((const char *) s);
+		len = strlen((const char *) s);
 		e = s + len;
 
-		if (len > 0) {
+		if (len != 0) {
 		    unsigned char *e1 = s;
 
 		    while (e1 < e) {
@@ -5274,13 +5253,16 @@ int LYgetBString(bstring **inputline,
 					     map_active,
 					     TRUE);
 				s = ++e1;
-			    } else
+			    } else {
 				break;
-			} else
+			    }
+			} else {
 			    ++e1;
+			}
 		    }
-		    if (e1 > s)
+		    if (e1 > s) {
 			LYEditInsert(edit, s, (int) (e1 - s), map_active, TRUE);
+		    }
 		}
 		get_clip_release();
 		break;
@@ -5288,31 +5270,26 @@ int LYgetBString(bstring **inputline,
 #endif
 
 	case LYE_ABORT:
-	    /*
-	     * Control-C or Control-G aborts.
-	     */
 	    CTRACE((tfp, "LYgetstr LYE_ABORT\n"));
 #ifdef FEPCTRL
 	    fep_off();
 #endif
 	    LYFinishEdit(edit);
 	    BStrCopy0(*inputline, "");
-	    return (-1);
+	    done = TRUE;
+	    break;
 
 	case LYE_STOP:
-	    /*
-	     * Deactivate.
-	     */
 	    CTRACE((tfp, "LYgetstr LYE_STOP\n"));
 #ifdef TEXTFIELDS_MAY_NEED_ACTIVATION
 	    textfields_need_activation = TRUE;
 	    LYFinishEdit(edit);
 	    BStrCopy0(*inputline, "");
-	    return (-1);
+	    done = TRUE;
+	    break;
 #else
 #ifdef ENHANCED_LINEEDIT
-	    if (Mark >= 0)
-		Mark = -(1 + Mark);	/* Disable it */
+	    disableEditMark();
 #endif
 	    break;
 #endif
@@ -5350,12 +5327,13 @@ int LYgetBString(bstring **inputline,
 		    refresh_mb = TRUE;
 	    } else {
 		if (!refresh_mb) {
-		    LYEdit1(edit, 0, LYE_DELP, FALSE);
+		    LYDoEdit(edit, 0, LYE_DELP, FALSE);
 		}
 	    }
 #endif /* SUPPORT_MULTIBYTE_EDIT */
 	}
     }
+    return result;
 }
 
 /*
@@ -5387,23 +5365,27 @@ const char *LYLineeditHelpURL(void)
     static int lasthelp_lineedit = -1;
     static char helpbuf[LY_MAXPATH] = "\0";
     static char *phelp = &helpbuf[0];
+    const char *result = NULL;
 
-    if (lasthelp_lineedit == current_lineedit)
-	return &helpbuf[0];
-    if (lasthelp_lineedit == -1) {
-	LYStrNCpy(helpbuf, helpfilepath, sizeof(helpbuf) - 1);
-	phelp += strlen(helpbuf);
-    }
-    if (LYLineeditHelpURLs[current_lineedit] &&
-	strlen(LYLineeditHelpURLs[current_lineedit]) &&
-	(strlen(LYLineeditHelpURLs[current_lineedit]) <=
-	 sizeof(helpbuf) - (unsigned) (phelp - helpbuf))) {
-	LYStrNCpy(phelp, LYLineeditHelpURLs[current_lineedit],
-		  (int) (sizeof(helpbuf) - (unsigned) (phelp - helpbuf) - 1));
-	lasthelp_lineedit = current_lineedit;
-	return (&helpbuf[0]);
+    if (lasthelp_lineedit == current_lineedit) {
+	result = helpbuf;
+    } else {
+	const char *source = LYLineeditHelpURLs[current_lineedit];
+	size_t available;
+
+	if (lasthelp_lineedit == -1) {
+	    LYStrNCpy(helpbuf, helpfilepath, sizeof(helpbuf) - 1);
+	    phelp += strlen(helpbuf);
+	}
+	available = (sizeof(helpbuf) - (size_t) (phelp - helpbuf));
+	if (non_empty(source) &&
+	    (strlen(source) <= available)) {
+	    LYStrNCpy(phelp, source, available);
+	    lasthelp_lineedit = current_lineedit;
+	    result = helpbuf;
+	}
     }
-    return NULL;
+    return result;
 }
 
 /*
@@ -5485,151 +5467,156 @@ int LYscanFloat(const char *source, float *result)
 char *LYstrsep(char **stringp,
 	       const char *delim)
 {
-    char *tmp, *out;
-
-    if (isEmpty(stringp))	/* nothing to do? */
-	return 0;		/* then don't fall on our faces */
+    char *marker;
+    char *result = 0;
 
-    out = *stringp;		/* save the start of the string */
-    tmp = strpbrk(*stringp, delim);
-    if (tmp) {
-	*tmp = '\0';		/* terminate the substring with \0 */
-	*stringp = ++tmp;	/* point at the next substring */
-    } else
-	*stringp = 0;		/* this was the last substring: */
-    /* let caller see he's done */
-    return out;
+    if (non_empty(stringp)) {
+	result = *stringp;	/* will return the old value */
+	marker = strpbrk(*stringp, delim);
+	if (marker) {
+	    *marker = '\0';	/* terminate the substring */
+	    *stringp = ++marker;	/* point to the next substring */
+	} else {
+	    *stringp = 0;	/* this was the last */
+	}
+    }
+    return result;
 }
 
 /*
- * LYstrstr will find the first occurrence of the string pointed to by tarptr
- * in the string pointed to by chptr.  It returns NULL if string not found.  It
- * is a case insensitive search.
+ * LYstrstr finds the first occurrence of the string pointed to by needle
+ * in the string pointed to by haystack.
+ *
+ * It returns NULL if the string is not found.
+ *
+ * It is a case insensitive search.
  */
-char *LYstrstr(char *chptr,
-	       const char *tarptr)
+char *LYstrstr(char *haystack,
+	       const char *needle)
 {
-    int len = (int) strlen(tarptr);
+    int len = (int) strlen(needle);
+    char *result = NULL;
 
-    for (; *chptr != '\0'; chptr++) {
-	if (0 == UPPER8(*chptr, *tarptr)) {
-	    if (0 == strncasecomp8(chptr + 1, tarptr + 1, len - 1))
-		return (chptr);
+    for (; *haystack != '\0'; haystack++) {
+	if (0 == UPPER8(*haystack, *needle)) {
+	    if (0 == strncasecomp8(haystack + 1, needle + 1, len - 1)) {
+		result = haystack;
+		break;
+	    }
 	}
-    }				/* end for */
+    }
 
-    return (NULL);		/* string not found or initial chptr was empty */
+    return (result);
 }
 
+#define SkipSpecialChars(p) \
+	while (IsSpecialAttrChar(*p) && *p != '\0') \
+	    p++
+
 /*
- * LYno_attr_char_case_strstr will find the first occurrence of the
- * string pointed to by tarptr in the string pointed to by chptr.
- * It ignores the characters:  LY_UNDERLINE_START_CHAR and
- *			       LY_UNDERLINE_END_CHAR
- *			       LY_BOLD_START_CHAR
- *			       LY_BOLD_END_CHAR
- *			       LY_SOFT_HYPHEN
- *			       if present in chptr.
+ * LYno_attr_char_case_strstr finds the first occurrence of the
+ * string pointed to by needle in the string pointed to by haystack.
+ *
+ * It ignores special characters, e.g., LY_UNDERLINE_START_CHAR in haystack.
+ *
  * It is a case insensitive search.
  */
-const char *LYno_attr_char_case_strstr(const char *chptr,
-				       const char *tarptr)
+const char *LYno_attr_char_case_strstr(const char *haystack,
+				       const char *needle)
 {
-    register const char *tmpchptr, *tmptarptr;
+    const char *refptr, *tstptr;
+    const char *result = NULL;
 
-    if (!chptr)
-	return (NULL);
+    if (haystack != NULL && needle != NULL) {
 
-    while (IsSpecialAttrChar(*chptr) && *chptr != '\0')
-	chptr++;
+	SkipSpecialChars(haystack);
 
-    for (; *chptr != '\0'; chptr++) {
-	if (0 == UPPER8(*chptr, *tarptr)) {
-	    /*
-	     * See if they line up.
-	     */
-	    tmpchptr = chptr + 1;
-	    tmptarptr = tarptr + 1;
+	for (; *haystack != '\0' && (result == NULL); haystack++) {
+	    if (0 == UPPER8(*haystack, *needle)) {
+		refptr = haystack + 1;
+		tstptr = needle + 1;
 
-	    if (*tmptarptr == '\0')	/* one char target */
-		return (chptr);
+		if (*tstptr == '\0') {
+		    result = haystack;
+		    break;
+		}
 
-	    while (1) {
-		if (!IsSpecialAttrChar(*tmpchptr)) {
-		    if (0 != UPPER8(*tmpchptr, *tmptarptr))
+		while (1) {
+		    if (!IsSpecialAttrChar(*refptr)) {
+			if (0 != UPPER8(*refptr, *tstptr))
+			    break;
+			refptr++;
+			tstptr++;
+		    } else {
+			refptr++;
+		    }
+		    if (*tstptr == '\0') {
+			result = haystack;
+			break;
+		    }
+		    if (*refptr == '\0')
 			break;
-		    tmpchptr++;
-		    tmptarptr++;
-		} else {
-		    tmpchptr++;
 		}
-		if (*tmptarptr == '\0')
-		    return (chptr);
-		if (*tmpchptr == '\0')
-		    break;
 	    }
 	}
-    }				/* end for */
+    }
 
-    return (NULL);
+    return (result);
 }
 
 /*
- * LYno_attr_char_strstr will find the first occurrence of the
- * string pointed to by tarptr in the string pointed to by chptr.
- * It ignores the characters:  LY_UNDERLINE_START_CHAR and
- *			       LY_UNDERLINE_END_CHAR
- *			       LY_BOLD_START_CHAR
- *			       LY_BOLD_END_CHAR
- *			       LY_SOFT_HYPHEN
- *			       if present in chptr.
+ * LYno_attr_char_strstr finds the first occurrence of the
+ * string pointed to by needle in the string pointed to by haystack.
+ * It ignores special characters, e.g., LY_UNDERLINE_START_CHAR in haystack.
+ *
  * It is a case sensitive search.
  */
-const char *LYno_attr_char_strstr(const char *chptr,
-				  const char *tarptr)
+const char *LYno_attr_char_strstr(const char *haystack,
+				  const char *needle)
 {
-    register const char *tmpchptr, *tmptarptr;
+    const char *refptr, *tstptr;
+    const char *result = NULL;
 
-    if (!chptr)
-	return (NULL);
+    if (haystack != NULL && needle != NULL) {
 
-    while (IsSpecialAttrChar(*chptr) && *chptr != '\0')
-	chptr++;
+	SkipSpecialChars(haystack);
 
-    for (; *chptr != '\0'; chptr++) {
-	if ((*chptr) == (*tarptr)) {
-	    /*
-	     * See if they line up.
-	     */
-	    tmpchptr = chptr + 1;
-	    tmptarptr = tarptr + 1;
+	for (; *haystack != '\0' && (result == NULL); haystack++) {
+	    if ((*haystack) == (*needle)) {
+		refptr = haystack + 1;
+		tstptr = needle + 1;
 
-	    if (*tmptarptr == '\0')	/* one char target */
-		return (chptr);
+		if (*tstptr == '\0') {
+		    result = haystack;
+		    break;
+		}
 
-	    while (1) {
-		if (!IsSpecialAttrChar(*tmpchptr)) {
-		    if ((*tmpchptr) != (*tmptarptr))
+		while (1) {
+		    if (!IsSpecialAttrChar(*refptr)) {
+			if ((*refptr) != (*tstptr))
+			    break;
+			refptr++;
+			tstptr++;
+		    } else {
+			refptr++;
+		    }
+		    if (*tstptr == '\0') {
+			result = haystack;
 			break;
-		    tmpchptr++;
-		    tmptarptr++;
-		} else {
-		    tmpchptr++;
+		    } else if (*refptr == '\0') {
+			break;
+		    }
 		}
-		if (*tmptarptr == '\0')
-		    return (chptr);
-		if (*tmpchptr == '\0')
-		    break;
 	    }
 	}
-    }				/* end for */
+    }
 
-    return (NULL);
+    return (result);
 }
 
 /*
- * LYno_attr_mbcs_case_strstr will find the first occurrence of the string
- * pointed to by tarptr in the string pointed to by chptr.  It takes account of
+ * LYno_attr_mbcs_case_strstr finds the first occurrence of the string pointed
+ * to by needle in the string pointed to by haystack.  It takes account of
  * MultiByte Character Sequences (UTF8).  The physical lengths of the displayed
  * string up to the start and end (= next position after) of the target string
  * are returned in *nstartp and *nendp if the search is successful.
@@ -5639,158 +5626,133 @@ const char *LYno_attr_char_strstr(const char *chptr,
  * count actual glyphs if count_gcells is unset.  (Full-width characters in CJK
  * mode count as one.)
  *
- * It ignores the characters: LY_UNDERLINE_START_CHAR and
- *			      LY_UNDERLINE_END_CHAR
- *			      LY_BOLD_START_CHAR
- *			      LY_BOLD_END_CHAR
- *			      LY_SOFT_HYPHEN
- *			      if present in chptr.
+ * It ignores special characters, e.g., LY_UNDERLINE_START_CHAR in haystack.
+ *
  * It assumes UTF8 if utf_flag is set.
- * It is a case insensitive search.  - KW & FM
+ *
+ * It is a case insensitive search.
  */
-const char *LYno_attr_mbcs_case_strstr(const char *chptr,
-				       const char *tarptr,
+const char *LYno_attr_mbcs_case_strstr(const char *haystack,
+				       const char *needle,
 				       int utf_flag,
 				       int count_gcells,
 				       int *nstartp,
 				       int *nendp)
 {
-    const char *tmpchptr;
-    const char *tmptarptr;
+    const char *refptr;
+    const char *tstptr;
     int len = 0;
     int offset;
+    const char *result = NULL;
 
-    if (!(chptr && tarptr))
-	return (NULL);
+    if (haystack != NULL && needle != NULL) {
 
-    /*
-     * Skip initial IsSpecial chars.  - FM
-     */
-    while (IsSpecialAttrChar(*chptr) && *chptr != '\0')
-	chptr++;
+	SkipSpecialChars(haystack);
 
-    /*
-     * Seek a first target match.  - FM
-     */
-    for (; *chptr != '\0'; chptr++) {
-	if ((!utf_flag && IS_CJK_TTY && is8bits(*chptr) &&
-	     *chptr == *tarptr &&
-	     IsNormalChar(*(chptr + 1))) ||
-	    (0 == UPPER8(*chptr, *tarptr))) {
-	    int tarlen = 0;
+	for (; *haystack != '\0' && (result == NULL); haystack++) {
+	    if ((!utf_flag && IS_CJK_TTY && is8bits(*haystack) &&
+		 *haystack == *needle &&
+		 IsNormalChar(*(haystack + 1))) ||
+		(0 == UPPER8(*haystack, *needle))) {
+		int tarlen = 0;
 
-	    offset = len;
-	    len++;
+		offset = len;
+		len++;
 
-	    /*
-	     * See if they line up.
-	     */
-	    tmpchptr = (chptr + 1);
-	    tmptarptr = (tarptr + 1);
+		refptr = (haystack + 1);
+		tstptr = (needle + 1);
 
-	    if (*tmptarptr == '\0') {
-		/*
-		 * One char target.
-		 */
-		if (nstartp)
-		    *nstartp = offset;
-		if (nendp)
-		    *nendp = len;
-		return (chptr);
-	    }
-	    if (!utf_flag && IS_CJK_TTY && is8bits(*chptr) &&
-		*chptr == *tarptr &&
-		IsNormalChar(*tmpchptr)) {
-		/*
-		 * Check the CJK multibyte.  - FM
-		 */
-		if (*tmpchptr == *tmptarptr) {
-		    /*
-		     * It's a match.  Advance to next char.  - FM
-		     */
-		    tmpchptr++;
-		    tmptarptr++;
-		    if (count_gcells)
-			tarlen++;
-		    if (*tmptarptr == '\0') {
-			/*
-			 * One character match.  - FM
-			 */
-			if (nstartp)
-			    *nstartp = offset;
-			if (nendp)
-			    *nendp = len + tarlen;
-			return (chptr);
-		    }
-		} else {
-		    /*
-		     * It's not a match, so go back to seeking a first target
-		     * match.  - FM
-		     */
-		    chptr++;
-		    if (count_gcells)
-			len++;
-		    continue;
+		if (*tstptr == '\0') {
+		    if (nstartp)
+			*nstartp = offset;
+		    if (nendp)
+			*nendp = len;
+		    result = haystack;
+		    break;
 		}
-	    }
-	    /*
-	     * See if the rest of the target matches.  - FM
-	     */
-	    while (1) {
-		if (!IsSpecialAttrChar(*tmpchptr)) {
-		    if (!utf_flag && IS_CJK_TTY && is8bits(*tmpchptr)) {
-			if (*tmpchptr == *tmptarptr &&
-			    *(tmpchptr + 1) == *(tmptarptr + 1) &&
-			    !IsSpecialAttrChar(*(tmpchptr + 1))) {
-			    tmpchptr++;
-			    tmptarptr++;
-			    if (count_gcells)
-				tarlen++;
-			} else {
+		if (!utf_flag && IS_CJK_TTY && is8bits(*haystack) &&
+		    *haystack == *needle &&
+		    IsNormalChar(*refptr)) {
+		    /* handle a CJK multibyte string */
+		    if (*refptr == *tstptr) {
+			refptr++;
+			tstptr++;
+			if (count_gcells)
+			    tarlen++;
+			if (*tstptr == '\0') {
+			    if (nstartp)
+				*nstartp = offset;
+			    if (nendp)
+				*nendp = len + tarlen;
+			    result = haystack;
 			    break;
 			}
-		    } else if (0 != UPPER8(*tmpchptr, *tmptarptr)) {
-			break;
+		    } else {
+			/* not a match */
+			haystack++;
+			if (count_gcells)
+			    len++;
+			continue;
 		    }
+		}
+		/* compare the remainder of the string */
+		while (1) {
+		    if (!IsSpecialAttrChar(*refptr)) {
+			if (!utf_flag && IS_CJK_TTY && is8bits(*refptr)) {
+			    if (*refptr == *tstptr &&
+				*(refptr + 1) == *(tstptr + 1) &&
+				!IsSpecialAttrChar(*(refptr + 1))) {
+				refptr++;
+				tstptr++;
+				if (count_gcells)
+				    tarlen++;
+			    } else {
+				break;
+			    }
+			} else if (0 != UPPER8(*refptr, *tstptr)) {
+			    break;
+			}
 
-		    if (!IS_UTF_EXTRA(*tmptarptr)) {
-			tarlen++;
+			if (!IS_UTF_EXTRA(*tstptr)) {
+			    tarlen++;
+			}
+			refptr++;
+			tstptr++;
+
+		    } else {
+			refptr++;
 		    }
-		    tmpchptr++;
-		    tmptarptr++;
 
-		} else {
-		    tmpchptr++;
+		    if (*tstptr == '\0') {
+			if (nstartp)
+			    *nstartp = offset;
+			if (nendp)
+			    *nendp = len + tarlen;
+			result = haystack;
+			break;
+		    }
+		    if (*refptr == '\0')
+			break;
 		}
-
-		if (*tmptarptr == '\0') {
-		    if (nstartp)
-			*nstartp = offset;
-		    if (nendp)
-			*nendp = len + tarlen;
-		    return (chptr);
+	    } else if (!(IS_UTF_EXTRA(*haystack) ||
+			 IsSpecialAttrChar(*haystack))) {
+		if (!utf_flag && IS_CJK_TTY && is8bits(*haystack) &&
+		    IsNormalChar(*(haystack + 1))) {
+		    haystack++;
+		    if (count_gcells)
+			len++;
 		}
-		if (*tmpchptr == '\0')
-		    break;
+		len++;
 	    }
-	} else if (!(IS_UTF_EXTRA(*chptr) ||
-		     IsSpecialAttrChar(*chptr))) {
-	    if (!utf_flag && IS_CJK_TTY && is8bits(*chptr) &&
-		IsNormalChar(*(chptr + 1))) {
-		chptr++;
-		if (count_gcells)
-		    len++;
-	    }
-	    len++;
 	}
-    }				/* end for */
+    }
 
-    return (NULL);
+    return (result);
 }
 
 /*
- * LYno_attr_mbcs_strstr will find the first occurrence of the string pointed
- * to by tarptr in the string pointed to by chptr.
+ * LYno_attr_mbcs_strstr finds the first occurrence of the string pointed
+ * to by needle in the string pointed to by haystack.
  *
  * It takes account of CJK and MultiByte Character Sequences (UTF8).  The
  * physical lengths of the displayed string up to the start and end (= next
@@ -5802,199 +5764,177 @@ const char *LYno_attr_mbcs_case_strstr(const char *chptr,
  * count actual glyphs if count_gcells is unset.  (Full-width characters in CJK
  * mode count as one.)
  *
- * It ignores the characters: LY_UNDERLINE_START_CHAR and
- *			      LY_UNDERLINE_END_CHAR
- *			      LY_BOLD_START_CHAR
- *			      LY_BOLD_END_CHAR
- *			      LY_SOFT_HYPHEN
- *			      if present in chptr.
+ * It ignores special characters, e.g., LY_UNDERLINE_START_CHAR in haystack.
+ *
  * It assumes UTF8 if utf_flag is set.
- * It is a case sensitive search.  - KW & FM
+ *
+ * It is a case sensitive search.
  */
-const char *LYno_attr_mbcs_strstr(const char *chptr,
-				  const char *tarptr,
+const char *LYno_attr_mbcs_strstr(const char *haystack,
+				  const char *needle,
 				  int utf_flag,
 				  int count_gcells,
 				  int *nstartp,
 				  int *nendp)
 {
-    const char *tmpchptr;
-    const char *tmptarptr;
+    const char *refptr;
+    const char *tstptr;
     int len = 0;
     int offset;
+    const char *result = NULL;
 
-    if (!(chptr && tarptr))
-	return (NULL);
+    if (haystack != NULL && needle != NULL) {
 
-    /*
-     * Skip initial IsSpecial chars.  - FM
-     */
-    while (IsSpecialAttrChar(*chptr) && *chptr != '\0')
-	chptr++;
+	SkipSpecialChars(haystack);
 
-    /*
-     * Seek a first target match.  - FM
-     */
-    for (; *chptr != '\0'; chptr++) {
-	if ((*chptr) == (*tarptr)) {
-	    int tarlen = 0;
+	for (; *haystack != '\0' && (result == NULL); haystack++) {
+	    if ((*haystack) == (*needle)) {
+		int tarlen = 0;
 
-	    offset = len;
-	    len++;
+		offset = len;
+		len++;
 
-	    /*
-	     * See if they line up.
-	     */
-	    tmpchptr = (chptr + 1);
-	    tmptarptr = (tarptr + 1);
+		refptr = (haystack + 1);
+		tstptr = (needle + 1);
 
-	    if (*tmptarptr == '\0') {
-		/*
-		 * One char target.
-		 */
-		if (nstartp)
-		    *nstartp = offset;
-		if (nendp)
-		    *nendp = len;
-		return (chptr);
-	    }
-	    if (!utf_flag && IS_CJK_TTY && is8bits(*chptr) &&
-		IsNormalChar(*tmpchptr)) {
-		/*
-		 * Check the CJK multibyte.  - FM
-		 */
-		if (*tmpchptr == *tmptarptr) {
-		    /*
-		     * It's a match.  Advance to next char.  - FM
-		     */
-		    tmpchptr++;
-		    tmptarptr++;
-		    if (count_gcells)
-			tarlen++;
-		    if (*tmptarptr == '\0') {
-			/*
-			 * One character match.  - FM
-			 */
-			if (nstartp)
-			    *nstartp = offset;
-			if (nendp)
-			    *nendp = len + tarlen;
-			return (chptr);
+		if (*tstptr == '\0') {
+		    if (nstartp)
+			*nstartp = offset;
+		    if (nendp)
+			*nendp = len;
+		    result = haystack;
+		    break;
+		} else if (!utf_flag &&
+			   IS_CJK_TTY &&
+			   is8bits(*haystack) &&
+			   IsNormalChar(*refptr)) {
+		    /* handle a CJK multibyte string */
+		    if (*refptr == *tstptr) {
+			/* found match */
+			refptr++;
+			tstptr++;
+			if (count_gcells)
+			    tarlen++;
+			if (*tstptr == '\0') {
+			    if (nstartp)
+				*nstartp = offset;
+			    if (nendp)
+				*nendp = len + tarlen;
+			    result = haystack;
+			    break;
+			}
+		    } else {
+			/* not a match - restart comparison */
+			haystack++;
+			if (count_gcells)
+			    len++;
+			continue;
 		    }
-		} else {
-		    /*
-		     * It's not a match, so go back to seeking a first target
-		     * match.  - FM
-		     */
-		    chptr++;
-		    if (count_gcells)
-			len++;
-		    continue;
 		}
-	    }
-	    /*
-	     * See if the rest of the target matches.  - FM
-	     */
-	    while (1) {
-		if (!IsSpecialAttrChar(*tmpchptr)) {
-		    if (!utf_flag && IS_CJK_TTY && is8bits(*tmpchptr)) {
-			if (*tmpchptr == *tmptarptr &&
-			    *(tmpchptr + 1) == *(tmptarptr + 1) &&
-			    !IsSpecialAttrChar(*(tmpchptr + 1))) {
-			    tmpchptr++;
-			    tmptarptr++;
-			    if (count_gcells)
-				tarlen++;
-			} else {
+		/* compare the remainder of the string */
+		while (1) {
+		    if (!IsSpecialAttrChar(*refptr)) {
+			if (!utf_flag && IS_CJK_TTY && is8bits(*refptr)) {
+			    if (*refptr == *tstptr &&
+				*(refptr + 1) == *(tstptr + 1) &&
+				!IsSpecialAttrChar(*(refptr + 1))) {
+				refptr++;
+				tstptr++;
+				if (count_gcells)
+				    tarlen++;
+			    } else {
+				break;
+			    }
+			} else if ((*refptr) != (*tstptr)) {
 			    break;
 			}
-		    } else if ((*tmpchptr) != (*tmptarptr)) {
-			break;
+
+			if (!IS_UTF_EXTRA(*tstptr)) {
+			    tarlen++;
+			}
+			refptr++;
+			tstptr++;
+		    } else {
+			refptr++;
 		    }
 
-		    if (!IS_UTF_EXTRA(*tmptarptr)) {
-			tarlen++;
+		    if (*tstptr == '\0') {
+			if (nstartp)
+			    *nstartp = offset;
+			if (nendp)
+			    *nendp = len + tarlen;
+			result = haystack;
+			break;
 		    }
-		    tmpchptr++;
-		    tmptarptr++;
-		} else {
-		    tmpchptr++;
+		    if (*refptr == '\0')
+			break;
 		}
-
-		if (*tmptarptr == '\0') {
-		    if (nstartp)
-			*nstartp = offset;
-		    if (nendp)
-			*nendp = len + tarlen;
-		    return (chptr);
+	    } else if (!(IS_UTF_EXTRA(*haystack) ||
+			 IsSpecialAttrChar(*haystack))) {
+		if (!utf_flag && IS_CJK_TTY && is8bits(*haystack) &&
+		    IsNormalChar(*(haystack + 1))) {
+		    haystack++;
+		    if (count_gcells)
+			len++;
 		}
-		if (*tmpchptr == '\0')
-		    break;
+		len++;
 	    }
-	} else if (!(IS_UTF_EXTRA(*chptr) ||
-		     IsSpecialAttrChar(*chptr))) {
-	    if (!utf_flag && IS_CJK_TTY && is8bits(*chptr) &&
-		IsNormalChar(*(chptr + 1))) {
-		chptr++;
-		if (count_gcells)
-		    len++;
-	    }
-	    len++;
 	}
-    }				/* end for */
-
-    return (NULL);
+    }
+    return (result);
 }
 
 /*
- * Allocate a new copy of a string, and returns it.
+ * Allocate and return a copy of a string.
+ * see StrAllocCopy
  */
-char *SNACopy(char **dest,
-	      const char *src,
-	      int n)
+char *SNACopy(char **target,
+	      const char *source,
+	      size_t n)
 {
-    FREE(*dest);
-    if (src) {
-	*dest = typeMallocn(char, (unsigned) n + 1);
+    FREE(*target);
+    if (source) {
+	*target = typeMallocn(char, n + 1);
 
-	if (*dest == NULL) {
-	    CTRACE((tfp, "Tried to malloc %d bytes\n", n));
+	if (*target == NULL) {
+	    CTRACE((tfp, "Tried to malloc %lu bytes\n", (unsigned long) n));
 	    outofmem(__FILE__, "SNACopy");
-	    assert(*dest != NULL);
+	    assert(*target != NULL);
 	}
-	LYStrNCpy(*dest, src, n);
+	LYStrNCpy(*target, source, n);
     }
-    return *dest;
+    return *target;
 }
 
 /*
- * String Allocate and Concatenate.
+ * Combinate string allocation and concatenation.
+ * see StrAllocCat
  */
-char *SNACat(char **dest,
-	     const char *src,
-	     int n)
+char *SNACat(char **target,
+	     const char *source,
+	     size_t n)
 {
-    if (non_empty(src)) {
-	if (*dest) {
-	    int length = (int) strlen(*dest);
+    if (non_empty(source)) {
+	if (*target) {
+	    size_t length = strlen(*target);
 
-	    *dest = typeRealloc(char, *dest, length + n + 1);
+	    *target = typeRealloc(char, *target, length + n + 1);
 
-	    if (*dest == NULL)
+	    if (*target == NULL)
 		outofmem(__FILE__, "SNACat");
-	    assert(*dest != NULL);
-	    LYStrNCpy(*dest + length, src, n);
+	    assert(*target != NULL);
+	    LYStrNCpy(*target + length, source, n);
 	} else {
-	    *dest = typeMallocn(char, (unsigned) n + 1);
+	    *target = typeMallocn(char, n + 1);
 
-	    if (*dest == NULL)
+	    if (*target == NULL)
 		outofmem(__FILE__, "SNACat");
-	    assert(*dest != NULL);
-	    MemCpy(*dest, src, n);
-	    (*dest)[n] = '\0';	/* terminate */
+	    assert(*target != NULL);
+	    MemCpy(*target, source, n);
+	    (*target)[n] = '\0';	/* terminate */
 	}
     }
-    return *dest;
+    return *target;
 }
 
 #include <caselower.h>
@@ -6007,33 +5947,32 @@ static long UniToLowerCase(long upper)
 {
     size_t i, high, low;
     long diff = 0;
+    long result = upper;
 
-    /*
-     * Make check for sure.
-     */
-    if (upper <= 0)
-	return (upper);
-
-    /*
-     * Try unicode_to_lower_case[].
-     */
-    low = 0;
-    high = TABLESIZE(unicode_to_lower_case);
-    while (low < high) {
+    if (upper > 0) {
 	/*
-	 * Binary search.
+	 * Try unicode_to_lower_case[].
 	 */
-	i = (low + (high - low) / 2);
-	diff = (unicode_to_lower_case[i].upper - upper);
-	if (diff < 0)
-	    low = i + 1;
-	if (diff > 0)
-	    high = i;
-	if (diff == 0)
-	    return (unicode_to_lower_case[i].lower);
+	low = 0;
+	high = TABLESIZE(unicode_to_lower_case);
+	while (low < high) {
+	    /*
+	     * Binary search.
+	     */
+	    i = (low + (high - low) / 2);
+	    diff = (unicode_to_lower_case[i].upper - upper);
+	    if (diff < 0) {
+		low = i + 1;
+	    } else if (diff > 0) {
+		high = i;
+	    } else if (diff == 0) {
+		result = unicode_to_lower_case[i].lower;
+		break;
+	    }
+	}
     }
 
-    return (upper);		/* if we came here */
+    return result;
 }
 
 /*
@@ -6051,35 +5990,38 @@ static long UniToLowerCase(long upper)
  */
 int UPPER8(int ch1, int ch2)
 {
-    /* if they are the same or one is a null characters return immediately. */
-    if (ch1 == ch2)
-	return 0;
-    if (!ch2)
-	return UCH(ch1);
-    else if (!ch1)
-	return -UCH(ch2);
-
-    /* case-insensitive match for us-ascii */
-    if (UCH(TOASCII(ch1)) < 128 && UCH(TOASCII(ch2)) < 128)
-	return (TOUPPER(ch1) - TOUPPER(ch2));
-
-    /* case-insensitive match for upper half */
-    if (UCH(TOASCII(ch1)) > 127 &&	/* S/390 -- gil -- 2066 */
-	UCH(TOASCII(ch2)) > 127) {
-	if (DisplayCharsetMatchLocale)
-	    return (TOUPPER(ch1) - TOUPPER(ch2));	/* old-style */
-	else {
+    int result = 0;
+
+    if (ch1 == ch2) {
+	result = 0;
+    } else if (!ch2) {
+	result = UCH(ch1);
+    } else if (!ch1) {
+	result = -UCH(ch2);
+    } else if (UCH(TOASCII(ch1)) < 128 && UCH(TOASCII(ch2)) < 128) {
+	/* case-insensitive match for us-ascii */
+	result = (TOUPPER(ch1) - TOUPPER(ch2));
+    } else if (UCH(TOASCII(ch1)) > 127 &&
+	       UCH(TOASCII(ch2)) > 127) {
+	/* case-insensitive match for upper half */
+	if (DisplayCharsetMatchLocale) {
+	    result = (TOUPPER(ch1) - TOUPPER(ch2));	/* old-style */
+	} else {
 	    long uni_ch2 = UCTransToUni((char) ch2, current_char_set);
 	    long uni_ch1;
 
-	    if (uni_ch2 < 0)
-		return UCH(ch1);
-	    uni_ch1 = UCTransToUni((char) ch1, current_char_set);
-	    return (int) (UniToLowerCase(uni_ch1) - UniToLowerCase(uni_ch2));
+	    if (uni_ch2 < 0) {
+		result = UCH(ch1);
+	    } else {
+		uni_ch1 = UCTransToUni((char) ch1, current_char_set);
+		result = (int) (UniToLowerCase(uni_ch1) - UniToLowerCase(uni_ch2));
+	    }
 	}
+    } else {
+	result = -10;		/* mismatch */
     }
 
-    return (-10);		/* mismatch, if we come to here */
+    return result;
 }
 
 /*
@@ -6087,14 +6029,14 @@ int UPPER8(int ch1, int ch2)
  * that is allocated.  When an EOF or error is found, the buffer is freed
  * automatically.
  */
-char *LYSafeGets(char **src,
+char *LYSafeGets(char **target,
 		 FILE *fp)
 {
     char buffer[BUFSIZ];
     char *result = 0;
 
-    if (src != 0)
-	result = *src;
+    if (target != 0)
+	result = *target;
     if (result != 0)
 	*result = 0;
 
@@ -6113,8 +6055,8 @@ char *LYSafeGets(char **src,
 	 */
 	FREE(result);
     }
-    if (src != 0)
-	*src = result;
+    if (target != 0)
+	*target = result;
     return result;
 }