 @@ -1,14 +1,14 @@
-/*	$NetBSD: wsemul_vt100.c,v 1.49 2022/01/02 23:46:21 uwe Exp $	*/
+/*	$NetBSD: wsemul_vt100.c,v 1.49.4.1 2023/07/30 11:47:08 martin Exp $	*/
 /*
  * Copyright (c) 1998
  *	Matthias Drochner.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
 @@ -17,27 +17,27 @@
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: wsemul_vt100.c,v 1.49 2022/01/02 23:46:21 uwe Exp $");
+__KERNEL_RCSID(0, "$NetBSD: wsemul_vt100.c,v 1.49.4.1 2023/07/30 11:47:08 martin Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_wsmsgattrs.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/time.h>
 #include <sys/malloc.h>
 #include <sys/fcntl.h>
 #include <dev/wscons/wsconsio.h>
 #include <dev/wscons/wsdisplayvar.h>
 @@ -283,28 +283,34 @@ wsemul_vt100_detach(void *cookie, u_int
 	f(edp->decgraphtab)
 	f(edp->dectechtab)
 	f(edp->nrctab)
 #undef f
 	if (edp != &wsemul_vt100_console_emuldata)
 		free(edp, M_DEVBUF);
+}
 static void
 wsemul_vt100_resize(void * cookie, const struct wsscreen_descr *type)
+{
 	struct wsemul_vt100_emuldata *edp = cookie;
-	edp->bd.nrows = type->nrows;
+	/* XXX match malloc size in wsemul_vt100_attach */
-	edp->bd.ncols = type->ncols;
+	KASSERT(type->nrows >= 0);
 	KASSERT(type->ncols >= 0);
 	KASSERT(type->nrows <= 1024);
 	KASSERT(type->ncols <= 1024);
 	edp->bd.nrows = MAX(0, MIN(type->nrows, 1024));
 	edp->bd.ncols = MAX(0, MIN(type->ncols, 1024));
 	wsemul_vt100_reset(edp);
 	wsemul_vt100_resetop(cookie, WSEMUL_CLEARSCREEN);
+}
 static void
 wsemul_vt100_resetop(void *cookie, enum wsemul_resetops op)
+{
 	struct wsemul_vt100_emuldata *edp = cookie;
 	struct vt100base_data *vd = &edp->bd;
 	switch (op) {
 	case WSEMUL_RESET:
 		wsemul_vt100_reset(edp);
 @@ -612,27 +618,27 @@ wsemul_vt100_output_esc(struct wsemul_vt
 	case '#':
 		return VT100_EMUL_STATE_ESC_HASH;
 	case ' ': /* 7/8 bit */
 		return VT100_EMUL_STATE_ESC_SPC;
 	case ']': /* OSC operating system command */
 	case '^': /* PM privacy message */
 	case '_': /* APC application program command */
 		/* ignored */
 		return VT100_EMUL_STATE_STRING;
 	case '<': /* exit VT52 mode - ignored */
 		break;
 	default:
 #ifdef VT100_PRINTUNKNOWN
-		printf("ESC%c unknown\n", c);
+		printf("%s: ESC%c unknown\n", __func__, c);
 #endif
 		break;
+	}
 	return VT100_EMUL_STATE_NORMAL;
+}
 static u_int
 wsemul_vt100_output_scs94(struct wsemul_vt100_emuldata *edp, u_char c)
+{
 	switch (c) {
 	case '%': /* probably DEC supplemental graphic */
 		return VT100_EMUL_STATE_SCS94_PERCENT;
 	case 'A': /* british / national */
 @@ -643,44 +649,46 @@ wsemul_vt100_output_scs94(struct wsemul_
 		break;
 	case '<': /* user preferred supplemental */
 		/* XXX not really "user" preferred */
 		edp->chartab_G[edp->designating] = edp->isolatin1tab;
 		break;
 	case '0': /* DEC special graphic */
 		edp->chartab_G[edp->designating] = edp->decgraphtab;
 		break;
 	case '>': /* DEC tech */
 		edp->chartab_G[edp->designating] = edp->dectechtab;
 		break;
 	default:
 #ifdef VT100_PRINTUNKNOWN
-		printf("ESC%c%c unknown\n", edp->designating + '(', c);
+		printf("%s: ESC%c%c unknown\n", __func__,
 		    edp->designating + '(', c);
 #endif
 		break;
+	}
 	return VT100_EMUL_STATE_NORMAL;
+}
 static u_int
 wsemul_vt100_output_scs94_percent(struct wsemul_vt100_emuldata *edp, u_char c)
+{
 	switch (c) {
 	case '5': /* DEC supplemental graphic */
 		/* XXX there are differences */
 		edp->chartab_G[edp->designating] = edp->isolatin1tab;
 		break;
 	default:
 #ifdef VT100_PRINTUNKNOWN
-		printf("ESC%c%%%c unknown\n", edp->designating + '(', c);
+		printf("%s: ESC%c%%%c unknown\n",
 		    __func__, edp->designating + '(', c);
 #endif
 		break;
+	}
 	return VT100_EMUL_STATE_NORMAL;
+}
 static u_int
 wsemul_vt100_output_scs96(struct wsemul_vt100_emuldata *edp, u_char c)
+{
 	int nrc;
 	switch (c) {
 	case '%': /* probably portuguese */
 @@ -712,63 +720,65 @@ wsemul_vt100_output_scs96(struct wsemul_
 	case 'Z': /* spanish */
 		nrc = 9;
 		goto setnrc;
 	case '7': case 'H': /* swedish */
 		nrc = 10;
 		goto setnrc;
 	case '=': /* swiss */
 		nrc = 11;
 setnrc:
 		vt100_setnrc(edp, nrc); /* what table ??? */
 		break;
 	default:
 #ifdef VT100_PRINTUNKNOWN
-		printf("ESC%c%c unknown\n", edp->designating + '-' - 1, c);
+		printf("%s: ESC%c%c unknown\n",
 		    __func__, edp->designating + '-' - 1, c);
 #endif
 		break;
+	}
 	return VT100_EMUL_STATE_NORMAL;
+}
 static u_int
 wsemul_vt100_output_scs96_percent(struct wsemul_vt100_emuldata *edp, u_char c)
+{
 	switch (c) {
 	case '6': /* portuguese */
 		vt100_setnrc(edp, 8);
 		break;
 	default:
 #ifdef VT100_PRINTUNKNOWN
-		printf("ESC%c%%%c unknown\n", edp->designating + '-', c);
+		printf("%s: ESC%c%%%c unknown\n",
 		    __func__, edp->designating + '-', c);
 #endif
 		break;
+	}
 	return VT100_EMUL_STATE_NORMAL;
+}
 static u_int
 wsemul_vt100_output_esc_spc(struct wsemul_vt100_emuldata *edp,
     u_char c)
+{
 	switch (c) {
 	case 'F': /* 7-bit controls */
 	case 'G': /* 8-bit controls */
 #ifdef VT100_PRINTNOTIMPL
-		printf("ESC<SPC>%c ignored\n", c);
+		printf("%s: ESC<SPC>%c ignored\n", __func__, c);
 #endif
 		break;
 	default:
 #ifdef VT100_PRINTUNKNOWN
-		printf("ESC<SPC>%c unknown\n", c);
+		printf("%s: ESC<SPC>%c unknown\n", __func__, c);
 #endif
 		break;
+	}
 	return VT100_EMUL_STATE_NORMAL;
+}
 static u_int
 wsemul_vt100_output_string(struct wsemul_vt100_emuldata *edp, u_char c)
+{
 	struct vt100base_data *vd = &edp->bd;
 	if (vd->dcstype && vd->dcspos < DCS_MAXLEN)
 		vd->dcsarg[vd->dcspos++] = c;
 @@ -791,95 +801,96 @@ static u_int
 wsemul_vt100_output_dcs(struct wsemul_vt100_emuldata *edp, u_char c)
+{
 	struct vt100base_data *vd = &edp->bd;
 	switch (c) {
 	case '0': case '1': case '2': case '3': case '4':
 	case '5': case '6': case '7': case '8': case '9':
 		/* argument digit */
 		if (vd->nargs > VT100_EMUL_NARGS - 1)
 			break;
 		vd->args[vd->nargs] = (vd->args[vd->nargs] * 10) +
 		    (c - '0');
 		break;
 	case ';': /* argument terminator */
 		vd->nargs++;
 		break;
 	default:
 		vd->nargs++;
 		if (vd->nargs > VT100_EMUL_NARGS) {
 #ifdef VT100_DEBUG
-			printf("vt100: too many arguments\n");
+			printf("%s: too many arguments\n", __func__);
 #endif
 			vd->nargs = VT100_EMUL_NARGS;
+		}
 		if (c == ';')	/* argument terminator */
 			break;
 		switch (c) {
 		case '$':
 			return VT100_EMUL_STATE_DCS_DOLLAR;
 		case '{': /* DECDLD soft charset */
 		case '!': /* DECRQUPSS user preferred supplemental set */
 			/* 'u' must follow - need another state */
 		case '|': /* DECUDK program F6..F20 */
 #ifdef VT100_PRINTNOTIMPL
-			printf("DCS%c ignored\n", c);
+			printf("%s: DCS%c ignored\n", __func__, c);
 #endif
 			break;
 		default:
 #ifdef VT100_PRINTUNKNOWN
-			printf("DCS%c (%d, %d) unknown\n", c, ARG(vd, 0), ARG(vd, 1));
+			printf("%s: DCS%c (%d, %d) unknown\n",
 			    __func__, c, ARG(vd, 0), ARG(vd, 1));
 #endif
 			break;
+		}
 		return VT100_EMUL_STATE_STRING;
+	}
 	return VT100_EMUL_STATE_DCS;
+}
 static u_int
 wsemul_vt100_output_dcs_dollar(struct wsemul_vt100_emuldata *edp, u_char c)
+{
 	struct vt100base_data *vd = &edp->bd;
 	switch (c) {
 	case 'p': /* DECRSTS terminal state restore */
 	case 'q': /* DECRQSS control function request */
 #ifdef VT100_PRINTNOTIMPL
-		printf("DCS$%c ignored\n", c);
+		printf("%s: DCS$%c ignored\n", __func__, c);
 #endif
 		break;
 	case 't': /* DECRSPS restore presentation state */
 		switch (ARG(vd, 0)) {
 		case 0: /* error */
 			break;
 		case 1: /* cursor information restore */
 #ifdef VT100_PRINTNOTIMPL
-			printf("DCS1$t ignored\n");
+			printf("%s: DCS1$t ignored\n", __func__);
 #endif
 			break;
 		case 2: /* tab stop restore */
 			vd->dcspos = 0;
 			vd->dcstype = DCSTYPE_TABRESTORE;
 			break;
 		default:
 #ifdef VT100_PRINTUNKNOWN
-			printf("DCS%d$t unknown\n", ARG(vd, 0));
+			printf("%s: DCS%d$t unknown\n", __func__, ARG(vd, 0));
 #endif
 			break;
+		}
 		break;
 	default:
 #ifdef VT100_PRINTUNKNOWN
-		printf("DCS$%c (%d, %d) unknown\n", c, ARG(vd, 0), ARG(vd, 1));
+		printf("%s: DCS$%c (%d, %d) unknown\n",
 		    __func__, c, ARG(vd, 0), ARG(vd, 1));
 #endif
 		break;
+	}
 	return VT100_EMUL_STATE_STRING;
+}
 static u_int
 wsemul_vt100_output_esc_hash(struct wsemul_vt100_emuldata *edp, u_char c)
+{
 	struct vt100base_data *vd = &edp->bd;
 	int i, j;
 	switch (c) {
 @@ -915,68 +926,67 @@ wsemul_vt100_output_esc_hash(struct wsem
 				vd->ccol = (vd->ncols >> 1) - 1;
+		}
 		break;
 	case '8': /* DECALN */
 		for (i = 0; i < vd->nrows; i++)
 			for (j = 0; j < vd->ncols; j++)
 				(*vd->emulops->putchar)(vd->emulcookie, i, j,
 							 'E', vd->curattr);
 		vd->ccol = 0;
 		vd->crow = 0;
 		break;
 	default:
 #ifdef VT100_PRINTUNKNOWN
-		printf("ESC#%c unknown\n", c);
+		printf("%s: ESC#%c unknown\n", __func__, c);
 #endif
 		break;
+	}
 	return VT100_EMUL_STATE_NORMAL;
+}
 static u_int
 wsemul_vt100_output_csi(struct wsemul_vt100_emuldata *edp, u_char c)
+{
 	struct vt100base_data *vd = &edp->bd;
 	switch (c) {
 	case '0': case '1': case '2': case '3': case '4':
 	case '5': case '6': case '7': case '8': case '9':
 		/* argument digit */
 		if (vd->nargs > VT100_EMUL_NARGS - 1)
 			break;
 		vd->args[vd->nargs] = (vd->args[vd->nargs] * 10) +
 		    (c - '0');
 		break;
 	case ';': /* argument terminator */
 		vd->nargs++;
 		break;
 	case '?': /* DEC specific */
 	case '>': /* DA query */
 		vd->modif1 = c;
 		break;
 	case '!':
 	case '"':
 	case '$':
 	case '&':
 		vd->modif2 = c;
 		break;
-	default: /* end of escape sequence */
+	default: /* end of escape sequence, argument terminator */
 		vd->nargs++;
 		if (vd->nargs > VT100_EMUL_NARGS) {
 #ifdef VT100_DEBUG
-			printf("vt100: too many arguments\n");
+			printf("%s: too many arguments\n", __func__);
 #endif
 			vd->nargs = VT100_EMUL_NARGS;
+		}
 		if (c == ';')	/* argument terminator */
 			break;
 		wsemul_vt100_handle_csi(vd, c);
 		return VT100_EMUL_STATE_NORMAL;
+	}
 	return VT100_EMUL_STATE_CSI;
+}
 static void
 wsemul_vt100_output(void *cookie, const u_char *data, u_int count, int kernel)
+{
 	struct wsemul_vt100_emuldata *edp = cookie;
 	struct vt100base_data *vd = &edp->bd;
 #ifdef DIAGNOSTIC
 @@ -1032,28 +1042,28 @@ wsemul_vt100_setmsgattrs(void *cookie, c
 		vd->msgattrs.default_bg = vd->msgattrs.kernel_bg = 0;
 		vd->msgattrs.default_fg = vd->msgattrs.kernel_fg = 0;
+	}
 	error = (*vd->emulops->allocattr)(vd->emulcookie,
 	                                   vd->msgattrs.default_fg,
 					   vd->msgattrs.default_bg,
 	                                   vd->msgattrs.default_attrs,
 	                                   &tmp);
 #ifndef VT100_DEBUG
 	__USE(error);
 #else
 	if (error)
-		printf("vt100: failed to allocate attribute for default "
+		printf("%s: failed to allocate attribute for default "
-		       "messages\n");
+		    "messages\n", __func__);
 	else
 #endif
+	{
 		if (vd->curattr == vd->defattr) {
 			vd->bkgdattr = vd->curattr = tmp;
 			vd->attrflags = vd->msgattrs.default_attrs;
 			vd->bgcol = vd->msgattrs.default_bg;
 			vd->fgcol = vd->msgattrs.default_fg;
 		} else {
 			edp->savedbkgdattr = edp->savedattr = tmp;
 			edp->savedattrflags = vd->msgattrs.default_attrs;
 			edp->savedbgcol = vd->msgattrs.default_bg;
 			edp->savedfgcol = vd->msgattrs.default_fg;
 @@ -1061,25 +1071,25 @@ wsemul_vt100_setmsgattrs(void *cookie, c
 		if (vd->emulops->replaceattr != NULL)
 			(*vd->emulops->replaceattr)(vd->emulcookie,
 			                             vd->defattr, tmp);
 		vd->defattr = tmp;
+	}
 	error = (*vd->emulops->allocattr)(vd->emulcookie,
 	                                   vd->msgattrs.kernel_fg,
 					   vd->msgattrs.kernel_bg,
 	                                   vd->msgattrs.kernel_attrs,
 	                                   &tmp);
 #ifdef VT100_DEBUG
 	if (error)
-		printf("vt100: failed to allocate attribute for kernel "
+		printf("%s: failed to allocate attribute for kernel "
-		       "messages\n");
+		    "messages\n", __func__);
 	else
 #endif
+	{
 		if (vd->emulops->replaceattr != NULL)
 			(*vd->emulops->replaceattr)(vd->emulcookie,
 			                             edp->kernattr, tmp);
 		edp->kernattr = tmp;
+	}
+}
 #endif /* WSDISPLAY_CUSTOM_OUTPUT */

 @@ -1,14 +1,14 @@
-/* $NetBSD: wsemul_vt100_subr.c,v 1.24 2018/12/06 01:42:20 uwe Exp $ */
+/* $NetBSD: wsemul_vt100_subr.c,v 1.24.30.1 2023/07/30 11:47:08 martin Exp $ */
 /*
  * Copyright (c) 1998
  *	Matthias Drochner.  All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
 @@ -17,486 +17,514 @@
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: wsemul_vt100_subr.c,v 1.24 2018/12/06 01:42:20 uwe Exp $");
+__KERNEL_RCSID(0, "$NetBSD: wsemul_vt100_subr.c,v 1.24.30.1 2023/07/30 11:47:08 martin Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <dev/wscons/wsconsio.h>
 #include <dev/wscons/wsksymvar.h>
 #include <dev/wscons/wsdisplayvar.h>
 #include <dev/wscons/wsemulvar.h>
 #include <dev/wscons/vt100_base.h>
 #ifdef _KERNEL_OPT
 #include "opt_wsemul.h"
 #endif
 static int vt100_selectattribute(struct vt100base_data *,
 				      int, int, int, long *, long *);
 static int vt100_ansimode(struct vt100base_data *, int, int);
 static int vt100_decmode(struct vt100base_data *, int, int);
 #define VTMODE_SET 33
 #define VTMODE_RESET 44
 #define VTMODE_REPORT 55
 /*
  * scroll up within scrolling region
  */
 void
-wsemul_vt100_scrollup(struct vt100base_data *edp, int n)
+wsemul_vt100_scrollup(struct vt100base_data *vd, int n)
+{
 	int help;
-	if (n > edp->scrreg_nrows)
+	if (n > vd->scrreg_nrows)
-		n = edp->scrreg_nrows;
+		n = vd->scrreg_nrows;
-	help = edp->scrreg_nrows - n;
+	help = vd->scrreg_nrows - n;
 	if (help > 0) {
-		(*edp->emulops->copyrows)(edp->emulcookie,
+		(*vd->emulops->copyrows)(vd->emulcookie,
-					  edp->scrreg_startrow + n,
+					  vd->scrreg_startrow + n,
-					  edp->scrreg_startrow,
+					  vd->scrreg_startrow,
 					  help);
-		if (edp->dblwid)
+		if (vd->dblwid)
-			memmove(&edp->dblwid[edp->scrreg_startrow],
+			memmove(&vd->dblwid[vd->scrreg_startrow],
-				&edp->dblwid[edp->scrreg_startrow + n],
+				&vd->dblwid[vd->scrreg_startrow + n],
 				help);
+	}
-	(*edp->emulops->eraserows)(edp->emulcookie,
+	(*vd->emulops->eraserows)(vd->emulcookie,
-				   edp->scrreg_startrow + help, n,
+				   vd->scrreg_startrow + help, n,
-				   edp->bkgdattr);
+				   vd->bkgdattr);
-	if (edp->dblwid)
+	if (vd->dblwid)
-		memset(&edp->dblwid[edp->scrreg_startrow + help], 0, n);
+		memset(&vd->dblwid[vd->scrreg_startrow + help], 0, n);
-	CHECK_DW(edp);
+	CHECK_DW(vd);
+}
 /*
  * scroll down within scrolling region
  */
 void
-wsemul_vt100_scrolldown(struct vt100base_data *edp, int n)
+wsemul_vt100_scrolldown(struct vt100base_data *vd, int n)
+{
 	int help;
-	if (n > edp->scrreg_nrows)
+	if (n > vd->scrreg_nrows)
-		n = edp->scrreg_nrows;
+		n = vd->scrreg_nrows;
-	help = edp->scrreg_nrows - n;
+	help = vd->scrreg_nrows - n;
 	if (help > 0) {
-		(*edp->emulops->copyrows)(edp->emulcookie,
+		(*vd->emulops->copyrows)(vd->emulcookie,
-					  edp->scrreg_startrow,
+					  vd->scrreg_startrow,
-					  edp->scrreg_startrow + n,
+					  vd->scrreg_startrow + n,
 					  help);
-		if (edp->dblwid)
+		if (vd->dblwid)
-			memmove(&edp->dblwid[edp->scrreg_startrow + n],
+			memmove(&vd->dblwid[vd->scrreg_startrow + n],
-				&edp->dblwid[edp->scrreg_startrow],
+				&vd->dblwid[vd->scrreg_startrow],
 				help);
+	}
-	(*edp->emulops->eraserows)(edp->emulcookie,
+	(*vd->emulops->eraserows)(vd->emulcookie,
-				   edp->scrreg_startrow, n,
+				   vd->scrreg_startrow, n,
-				   edp->bkgdattr);
+				   vd->bkgdattr);
-	if (edp->dblwid)
+	if (vd->dblwid)
-		memset(&edp->dblwid[edp->scrreg_startrow], 0, n);
+		memset(&vd->dblwid[vd->scrreg_startrow], 0, n);
-	CHECK_DW(edp);
+	CHECK_DW(vd);
+}
 /*
  * erase in display
  */
 void
-wsemul_vt100_ed(struct vt100base_data *edp, int arg)
+wsemul_vt100_ed(struct vt100base_data *vd, int arg)
+{
 	int n;
 	switch (arg) {
 	    case 0: /* cursor to end */
-		ERASECOLS(edp, edp->ccol, COLS_LEFT(edp) + 1, edp->bkgdattr);
+		ERASECOLS(vd, vd->ccol, COLS_LEFT(vd) + 1, vd->bkgdattr);
-		n = edp->nrows - edp->crow - 1;
+		n = vd->nrows - vd->crow - 1;
 		if (n > 0) {
-			(*edp->emulops->eraserows)(edp->emulcookie,
+			(*vd->emulops->eraserows)(vd->emulcookie,
-						   edp->crow + 1, n,
+						   vd->crow + 1, n,
-						   edp->bkgdattr);
+						   vd->bkgdattr);
-			if (edp->dblwid)
+			if (vd->dblwid)
-				memset(&edp->dblwid[edp->crow + 1], 0, n);
+				memset(&vd->dblwid[vd->crow + 1], 0, n);
+		}
 		break;
 	    case 1: /* beginning to cursor */
-		if (edp->crow > 0) {
+		if (vd->crow > 0) {
-			(*edp->emulops->eraserows)(edp->emulcookie,
+			(*vd->emulops->eraserows)(vd->emulcookie,
-, edp->crow,
+, vd->crow,
-						   edp->bkgdattr);
+						   vd->bkgdattr);
-			if (edp->dblwid)
+			if (vd->dblwid)
-				memset(&edp->dblwid[0], 0, edp->crow);
+				memset(&vd->dblwid[0], 0, vd->crow);
+		}
-		ERASECOLS(edp, 0, edp->ccol + 1, edp->bkgdattr);
+		ERASECOLS(vd, 0, vd->ccol + 1, vd->bkgdattr);
 		break;
 	    case 2: /* complete display */
-		(*edp->emulops->eraserows)(edp->emulcookie,
+		(*vd->emulops->eraserows)(vd->emulcookie,
-, edp->nrows,
+, vd->nrows,
-					   edp->bkgdattr);
+					   vd->bkgdattr);
-		if (edp->dblwid)
+		if (vd->dblwid)
-			memset(&edp->dblwid[0], 0, edp->nrows);
+			memset(&vd->dblwid[0], 0, vd->nrows);
 		break;
 	    default:
 #ifdef VT100_PRINTUNKNOWN
 		printf("ed(%d) unknown\n", arg);
 #endif
 		break;
+	}
-	CHECK_DW(edp);
+	CHECK_DW(vd);
+}
 /*
  * erase in line
  */
 void
-wsemul_vt100_el(struct vt100base_data *edp, int arg)
+wsemul_vt100_el(struct vt100base_data *vd, int arg)
+{
 	switch (arg) {
 	    case 0: /* cursor to end */
-		ERASECOLS(edp, edp->ccol, COLS_LEFT(edp) + 1, edp->bkgdattr);
+		ERASECOLS(vd, vd->ccol, COLS_LEFT(vd) + 1, vd->bkgdattr);
 		break;
 	    case 1: /* beginning to cursor */
-		ERASECOLS(edp, 0, edp->ccol + 1, edp->bkgdattr);
+		ERASECOLS(vd, 0, vd->ccol + 1, vd->bkgdattr);
 		break;
 	    case 2: /* complete line */
-		(*edp->emulops->erasecols)(edp->emulcookie, edp->crow,
+		(*vd->emulops->erasecols)(vd->emulcookie, vd->crow,
-, edp->ncols,
+, vd->ncols,
-					   edp->bkgdattr);
+					   vd->bkgdattr);
 		break;
 	    default:
 #ifdef VT100_PRINTUNKNOWN
 		printf("el(%d) unknown\n", arg);
 #endif
 		break;
+	}
+}
 /*
  * handle commands after CSI (ESC[)
  */
 void
-wsemul_vt100_handle_csi(struct vt100base_data *edp, u_char c)
+wsemul_vt100_handle_csi(struct vt100base_data *vd, u_char c)
+{
-	int n, help, flags, fgcol, bgcol;
+	int n, m, help, flags, fgcol, bgcol;
 	long attr, bkgdattr;
 #define A3(a, b, c) (((a) << 16) | ((b) << 8) | (c))
-	switch (A3(edp->modif1, edp->modif2, c)) {
+	switch (A3(vd->modif1, vd->modif2, c)) {
 	    case A3('>', '\0', 'c'): /* DA secondary */
-		wsdisplay_emulinput(edp->cbcookie, WSEMUL_VT_ID2,
+		wsdisplay_emulinput(vd->cbcookie, WSEMUL_VT_ID2,
-				    sizeof(WSEMUL_VT_ID2));
+				    sizeof(WSEMUL_VT_ID2) - 1);
 		break;
 	    case A3('\0', '\0', 'J'): /* ED selective erase in display */
 	    case A3('?', '\0', 'J'): /* DECSED selective erase in display */
-		wsemul_vt100_ed(edp, ARG(edp, 0));
+		wsemul_vt100_ed(vd, ARG(vd, 0));
 		break;
 	    case A3('\0', '\0', 'K'): /* EL selective erase in line */
 	    case A3('?', '\0', 'K'): /* DECSEL selective erase in line */
-		wsemul_vt100_el(edp, ARG(edp, 0));
+		wsemul_vt100_el(vd, ARG(vd, 0));
 		break;
 	    case A3('\0', '\0', 'h'): /* SM */
-		for (n = 0; n < edp->nargs; n++)
+		for (n = 0; n < vd->nargs; n++)
-			vt100_ansimode(edp, ARG(edp, n), VTMODE_SET);
+			vt100_ansimode(vd, ARG(vd, n), VTMODE_SET);
 		break;
 	    case A3('?', '\0', 'h'): /* DECSM */
-		for (n = 0; n < edp->nargs; n++)
+		for (n = 0; n < vd->nargs; n++)
-			vt100_decmode(edp, ARG(edp, n), VTMODE_SET);
+			vt100_decmode(vd, ARG(vd, n), VTMODE_SET);
 		break;
 	    case A3('\0', '\0', 'l'): /* RM */
-		for (n = 0; n < edp->nargs; n++)
+		for (n = 0; n < vd->nargs; n++)
-			vt100_ansimode(edp, ARG(edp, n), VTMODE_RESET);
+			vt100_ansimode(vd, ARG(vd, n), VTMODE_RESET);
 		break;
 	    case A3('?', '\0', 'l'): /* DECRM */
-		for (n = 0; n < edp->nargs; n++)
+		for (n = 0; n < vd->nargs; n++)
-			vt100_decmode(edp, ARG(edp, n), VTMODE_RESET);
+			vt100_decmode(vd, ARG(vd, n), VTMODE_RESET);
 		break;
 	    case A3('\0', '$', 'p'): /* DECRQM request mode ANSI */
-		vt100_ansimode(edp, ARG(edp, 0), VTMODE_REPORT);
+		vt100_ansimode(vd, ARG(vd, 0), VTMODE_REPORT);
 		break;
 	    case A3('?', '$', 'p'): /* DECRQM request mode DEC */
-		vt100_decmode(edp, ARG(edp, 0), VTMODE_REPORT);
+		vt100_decmode(vd, ARG(vd, 0), VTMODE_REPORT);
 		break;
 	    case A3('\0', '\0', 'i'): /* MC printer controller mode */
 	    case A3('?', '\0', 'i'): /* MC printer controller mode */
-		switch (ARG(edp, 0)) {
+		switch (ARG(vd, 0)) {
 		    case 0: /* print screen */
 		    case 1: /* print cursor line */
 		    case 4: /* off */
 		    case 5: /* on */
 #ifdef VT100_PRINTNOTIMPL
-			printf("CSI%di ignored\n", ARG(edp, 0));
+			printf("CSI%di ignored\n", ARG(vd, 0));
 #endif
 			break;
 		    default:
 #ifdef VT100_PRINTUNKNOWN
-			printf("CSI%di unknown\n", ARG(edp, 0));
+			printf("CSI%di unknown\n", ARG(vd, 0));
 #endif
 			break;
+		}
 		break;
 #define A2(a, b) (((a) << 8) | (b))
-#if 0 /* XXX */
+#if 0 /* XXX: edp not available here */
 	    case A2('!', 'p'): /* DECSTR soft reset VT300 only */
 		wsemul_vt100_reset(edp);
 		break;
 #endif
 	    case A2('"', 'p'): /* DECSCL */
-		switch (ARG(edp, 0)) {
+		switch (ARG(vd, 0)) {
 		    case 61: /* VT100 mode (no further arguments!) */
 			break;
 		    case 62:
 		    case 63: /* VT300 mode */
 			break;
 		    default:
 #ifdef VT100_PRINTUNKNOWN
-			printf("CSI%d\"p unknown\n", ARG(edp, 0));
+			printf("CSI%d\"p unknown\n", ARG(vd, 0));
 #endif
 			break;
+		}
-		switch (ARG(edp, 1)) {
+		switch (ARG(vd, 1)) {
 		    case 0:
 		    case 2: /* 8-bit controls */
 #ifdef VT100_PRINTNOTIMPL
-			printf("CSI%d;%d\"p ignored\n", ARG(edp, 0), ARG(edp, 1));
+			printf("CSI%d;%d\"p ignored\n", ARG(vd, 0), ARG(vd, 1));
 #endif
 			break;
 		    case 1: /* 7-bit controls */
 			break;
 		    default:
 #ifdef VT100_PRINTUNKNOWN
-			printf("CSI%d;%d\"p unknown\n", ARG(edp, 0), ARG(edp, 1));
+			printf("CSI%d;%d\"p unknown\n", ARG(vd, 0), ARG(vd, 1));
 #endif
 			break;
+		}
 		break;
 	    case A2('"', 'q'): /* DECSCA select character attribute VT300 */
-		switch (ARG(edp, 0)) {
+		switch (ARG(vd, 0)) {
 		    case 0:
 		    case 1: /* erasable */
 			break;
 		    case 2: /* not erasable */
 #ifdef VT100_PRINTNOTIMPL
 			printf("CSI2\"q ignored\n");
 #endif
 			break;
 		    default:
 #ifdef VT100_PRINTUNKNOWN
-			printf("CSI%d\"q unknown\n", ARG(edp, 0));
+			printf("CSI%d\"q unknown\n", ARG(vd, 0));
 #endif
 			break;
+		}
 		break;
 	    case A2('$', 'u'): /* DECRQTSR request terminal status report */
-		switch (ARG(edp, 0)) {
+		switch (ARG(vd, 0)) {
 		    case 0: /* ignored */
 			break;
 		    case 1: /* terminal state report */
 #ifdef VT100_PRINTNOTIMPL
 			printf("CSI1$u ignored\n");
 #endif
 			break;
 		    default:
 #ifdef VT100_PRINTUNKNOWN
-			printf("CSI%d$u unknown\n", ARG(edp, 0));
+			printf("CSI%d$u unknown\n", ARG(vd, 0));
 #endif
 			break;
+		}
 		break;
 	    case A2('$', 'w'): /* DECRQPSR request presentation status report
 				(VT300 only) */
-		switch (ARG(edp, 0)) {
+		switch (ARG(vd, 0)) {
 		    case 0: /* error */
 			break;
 		    case 1: /* cursor information report */
 #ifdef VT100_PRINTNOTIMPL
 			printf("CSI1$w ignored\n");
 #endif
 			break;
 		    case 2: /* tab stop report */
+			{
 			int i, j, ps = 0;
 			char buf[20];
-			KASSERT(edp->tabs != 0);
+			KASSERT(vd->tabs != NULL);
-			wsdisplay_emulinput(edp->cbcookie, "\033P2$u", 5);
+			wsdisplay_emulinput(vd->cbcookie, "\033P2$u", 5);
-			for (i = 0; i < edp->ncols; i++)
+			for (i = 0; i < vd->ncols; i++)
-				if (edp->tabs[i]) {
+				if (vd->tabs[i]) {
 					j = snprintf(buf, sizeof(buf), "%s%d",
 					    (ps ? "/" : ""), i + 1);
-					wsdisplay_emulinput(edp->cbcookie,
+					wsdisplay_emulinput(vd->cbcookie,
 							    buf, j);
 					ps = 1;
+				}
+			}
-			wsdisplay_emulinput(edp->cbcookie, "\033\\", 2);
+			wsdisplay_emulinput(vd->cbcookie, "\033\\", 2);
 			break;
 		    default:
 #ifdef VT100_PRINTUNKNOWN
-			printf("CSI%d$w unknown\n", ARG(edp, 0));
+			printf("CSI%d$w unknown\n", ARG(vd, 0));
 #endif
 			break;
+		}
 		break;
 	    case A2('$', '}'): /* DECSASD select active status display */
-		switch (ARG(edp, 0)) {
+		switch (ARG(vd, 0)) {
 		    case 0: /* main display */
 		    case 1: /* status line */
 #ifdef VT100_PRINTNOTIMPL
-			printf("CSI%d$} ignored\n", ARG(edp, 0));
+			printf("CSI%d$} ignored\n", ARG(vd, 0));
 #endif
 			break;
 		    default:
 #ifdef VT100_PRINTUNKNOWN
-			printf("CSI%d$} unknown\n", ARG(edp, 0));
+			printf("CSI%d$} unknown\n", ARG(vd, 0));
 #endif
 			break;
+		}
 		break;
 	    case A2('$', '~'): /* DECSSDD select status line type */
-		switch (ARG(edp, 0)) {
+		switch (ARG(vd, 0)) {
 		    case 0: /* none */
 		    case 1: /* indicator */
 		    case 2: /* host-writable */
 #ifdef VT100_PRINTNOTIMPL
-			printf("CSI%d$~ ignored\n", ARG(edp, 0));
+			printf("CSI%d$~ ignored\n", ARG(vd, 0));
 #endif
 			break;
 		    default:
 #ifdef VT100_PRINTUNKNOWN
-			printf("CSI%d$~ unknown\n", ARG(edp, 0));
+			printf("CSI%d$~ unknown\n", ARG(vd, 0));
 #endif
 			break;
+		}
 		break;
 	    case A2('&', 'u'): /* DECRQUPSS request user preferred
 				  supplemental set */
-		wsdisplay_emulinput(edp->cbcookie, "\033P0!u%5\033\\", 9);
+		wsdisplay_emulinput(vd->cbcookie, "\033P0!u%5\033\\", 9);
 		break;
 	    case '@': /* ICH insert character VT300 only */
-		n = uimin(DEF1_ARG(edp, 0), COLS_LEFT(edp) + 1);
+		n = uimin(DEF1_ARG(vd, 0), COLS_LEFT(vd) + 1);
-		help = NCOLS(edp) - (edp->ccol + n);
+		help = NCOLS(vd) - (vd->ccol + n);
 		if (help > 0)
-			COPYCOLS(edp, edp->ccol, edp->ccol + n, help);
+			COPYCOLS(vd, vd->ccol, vd->ccol + n, help);
-		ERASECOLS(edp, edp->ccol, n, edp->bkgdattr);
+		ERASECOLS(vd, vd->ccol, n, vd->bkgdattr);
 		break;
 	    case 'A': /* CUU */
-		edp->crow -= uimin(DEF1_ARG(edp, 0), ROWS_ABOVE(edp));
+		vd->crow -= uimin(DEF1_ARG(vd, 0), ROWS_ABOVE(vd));
-		CHECK_DW(edp);
+		CHECK_DW(vd);
 		break;
 	    case 'B': /* CUD */
-		edp->crow += uimin(DEF1_ARG(edp, 0), ROWS_BELOW(edp));
+		vd->crow += uimin(DEF1_ARG(vd, 0), ROWS_BELOW(vd));
-		CHECK_DW(edp);
+		CHECK_DW(vd);
 		break;
 	    case 'C': /* CUF */
-		edp->ccol += uimin(DEF1_ARG(edp, 0), COLS_LEFT(edp));
+		vd->ccol += uimin(DEF1_ARG(vd, 0), COLS_LEFT(vd));
 		break;
 	    case 'D': /* CUB */
-		edp->ccol -= uimin(DEF1_ARG(edp, 0), edp->ccol);
+		vd->ccol -= uimin(DEF1_ARG(vd, 0), vd->ccol);
-		edp->flags &= ~VTFL_LASTCHAR;
+		vd->flags &= ~VTFL_LASTCHAR;
 		break;
 	    case 'G': /* CHA */
 		vd->ccol = uimin(DEF1_ARG(vd, 0) - 1, vd->ncols -1);
 		break;
 	    case 'H': /* CUP */
 	    case 'f': /* HVP */
-		if (edp->flags & VTFL_DECOM)
+		if (vd->flags & VTFL_DECOM)
-			edp->crow = edp->scrreg_startrow +
+			vd->crow = vd->scrreg_startrow +
-			    uimin(DEF1_ARG(edp, 0), edp->scrreg_nrows) - 1;
+			    uimin(DEF1_ARG(vd, 0), vd->scrreg_nrows) - 1;
 		else
-			edp->crow = uimin(DEF1_ARG(edp, 0), edp->nrows) - 1;
+			vd->crow = uimin(DEF1_ARG(vd, 0), vd->nrows) - 1;
-		CHECK_DW(edp);
+		CHECK_DW(vd);
-		edp->ccol = uimin(DEF1_ARG(edp, 1), NCOLS(edp)) - 1;
+		vd->ccol = uimin(DEF1_ARG(vd, 1), NCOLS(vd)) - 1;
-		edp->flags &= ~VTFL_LASTCHAR;
+		vd->flags &= ~VTFL_LASTCHAR;
 		break;
 	    case 'L': /* IL insert line */
 	    case 'M': /* DL delete line */
-		n = uimin(DEF1_ARG(edp, 0), ROWS_BELOW(edp) + 1);
+		n = uimin(DEF1_ARG(vd, 0), ROWS_BELOW(vd) + 1);
+		{
 		int savscrstartrow, savscrnrows;
-		savscrstartrow = edp->scrreg_startrow;
+		savscrstartrow = vd->scrreg_startrow;
-		savscrnrows = edp->scrreg_nrows;
+		savscrnrows = vd->scrreg_nrows;
-		edp->scrreg_nrows -= ROWS_ABOVE(edp);
+		vd->scrreg_nrows -= ROWS_ABOVE(vd);
-		edp->scrreg_startrow = edp->crow;
+		vd->scrreg_startrow = vd->crow;
 		if (c == 'L')
-			wsemul_vt100_scrolldown(edp, n);
+			wsemul_vt100_scrolldown(vd, n);
 		else
-			wsemul_vt100_scrollup(edp, n);
+			wsemul_vt100_scrollup(vd, n);
-		edp->scrreg_startrow = savscrstartrow;
+		vd->scrreg_startrow = savscrstartrow;
-		edp->scrreg_nrows = savscrnrows;
+		vd->scrreg_nrows = savscrnrows;
+		}
 		break;
 	    case 'P': /* DCH delete character */
-		n = uimin(DEF1_ARG(edp, 0), COLS_LEFT(edp) + 1);
+		n = uimin(DEF1_ARG(vd, 0), COLS_LEFT(vd) + 1);
-		help = NCOLS(edp) - (edp->ccol + n);
+		help = NCOLS(vd) - (vd->ccol + n);
 		if (help > 0)
-			COPYCOLS(edp, edp->ccol + n, edp->ccol, help);
+			COPYCOLS(vd, vd->ccol + n, vd->ccol, help);
-		ERASECOLS(edp, NCOLS(edp) - n, n, edp->bkgdattr);
+		ERASECOLS(vd, NCOLS(vd) - n, n, vd->bkgdattr);
 		break;
 	    case 'S': /* SU */
 		wsemul_vt100_scrollup(vd, DEF1_ARG(vd, 0));
 		break;
 	    case 'T': /* SD */
 		wsemul_vt100_scrolldown(vd, DEF1_ARG(vd, 0));
 		break;
 	    case 'X': /* ECH erase character */
-		n = uimin(DEF1_ARG(edp, 0), COLS_LEFT(edp) + 1);
+		n = uimin(DEF1_ARG(vd, 0), COLS_LEFT(vd) + 1);
-		ERASECOLS(edp, edp->ccol, n, edp->bkgdattr);
+		ERASECOLS(vd, vd->ccol, n, vd->bkgdattr);
 		break;
-	    case 'c': /* DA primary */
+	    case 'Z': /* CBT */
-		if (ARG(edp, 0) == 0)
+		if (vd->ccol == 0)
-			wsdisplay_emulinput(edp->cbcookie, WSEMUL_VT_ID1,
+			break;
-					    sizeof(WSEMUL_VT_ID1));
+		for (m = 0; m < DEF1_ARG(vd, 0); m++) {
 			if (vd->tabs) {
 				for (n = vd->ccol - 1; n > 0; n--) {
 					if (vd->tabs[n])
 						break;
+				}
 			} else
 				n = (vd->ccol - 1) & ~7;
 			vd->ccol = n;
 			if (n == 0)
 				break;
+		}
 		break;
 	    case 'c': /* DA primary */
 		if (ARG(vd, 0) == 0)
 			wsdisplay_emulinput(vd->cbcookie, WSEMUL_VT_ID1,
 					    sizeof(WSEMUL_VT_ID1) - 1);
 		break;
 	    case 'd': /* VPA */
 		vd->crow = uimin(DEF1_ARG(vd, 0) - 1, vd->nrows - 1);
  		break;
 	    case 'g': /* TBC */
-		KASSERT(edp->tabs != 0);
+		KASSERT(vd->tabs != NULL);
-		switch (ARG(edp, 0)) {
+		switch (ARG(vd, 0)) {
 		    case 0:
-			edp->tabs[edp->ccol] = 0;
+			vd->tabs[vd->ccol] = 0;
 			break;
 		    case 3:
-			memset(edp->tabs, 0, edp->ncols);
+			memset(vd->tabs, 0, vd->ncols);
 			break;
 		    default:
 #ifdef VT100_PRINTUNKNOWN
-			printf("CSI%dg unknown\n", ARG(edp, 0));
+			printf("CSI%dg unknown\n", ARG(vd, 0));
 #endif
 			break;
+		}
 		break;
 	    case 'm': /* SGR select graphic rendition */
-		flags = edp->attrflags;
+		flags = vd->attrflags;
-		fgcol = edp->fgcol;
+		fgcol = vd->fgcol;
-		bgcol = edp->bgcol;
+		bgcol = vd->bgcol;
-		for (n = 0; n < edp->nargs; n++) {
+		for (n = 0; n < vd->nargs; n++) {
-			switch (ARG(edp, n)) {
+			switch (ARG(vd, n)) {
 			    case 0: /* reset */
-				if (n == edp->nargs - 1) {
+				if (n == vd->nargs - 1) {
-					edp->bkgdattr = edp->curattr = edp->defattr;
+					vd->bkgdattr = vd->curattr = vd->defattr;
-					edp->attrflags = edp->msgattrs.default_attrs;
+					vd->attrflags = vd->msgattrs.default_attrs;
-					edp->fgcol = edp->msgattrs.default_fg;
+					vd->fgcol = vd->msgattrs.default_fg;
-					edp->bgcol = edp->msgattrs.default_bg;
+					vd->bgcol = vd->msgattrs.default_bg;
 					return;
+				}
-				flags = edp->msgattrs.default_attrs;
+				flags = vd->msgattrs.default_attrs;
-				fgcol = edp->msgattrs.default_fg;
+				fgcol = vd->msgattrs.default_fg;
-				bgcol = edp->msgattrs.default_bg;
+				bgcol = vd->msgattrs.default_bg;
 				break;
 			    case 1: /* bold */
 				flags |= WSATTR_HILIT;
 				break;
 			    case 4: /* underline */
 				flags |= WSATTR_UNDERLINE;
 				break;
 			    case 5: /* blink */
 				flags |= WSATTR_BLINK;
 				break;
 			    case 7: /* reverse */
 				flags |= WSATTR_REVERSE;
 				break;
 @@ -506,320 +534,333 @@ wsemul_vt100_handle_csi(struct vt100base
 			    case 24: /* ~underline VT300 only */
 				flags &= ~WSATTR_UNDERLINE;
 				break;
 			    case 25: /* ~blink VT300 only */
 				flags &= ~WSATTR_BLINK;
 				break;
 			    case 27: /* ~reverse VT300 only */
 				flags &= ~WSATTR_REVERSE;
 				break;
 			    case 30: case 31: case 32: case 33:
 			    case 34: case 35: case 36: case 37:
 				/* fg color */
 				flags |= WSATTR_WSCOLORS;
-				fgcol = ARG(edp, n) - 30;
+				fgcol = ARG(vd, n) - 30;
 				break;
 			    case 39:
-				fgcol = edp->msgattrs.default_fg;
+				fgcol = vd->msgattrs.default_fg;
 				break;
 			    case 40: case 41: case 42: case 43:
 			    case 44: case 45: case 46: case 47:
 				/* bg color */
 				flags |= WSATTR_WSCOLORS;
-				bgcol = ARG(edp, n) - 40;
+				bgcol = ARG(vd, n) - 40;
 				break;
 			    case 49:
-				bgcol = edp->msgattrs.default_bg;
+				bgcol = vd->msgattrs.default_bg;
 				break;
 			    default:
 #ifdef VT100_PRINTUNKNOWN
-				printf("CSI%dm unknown\n", ARG(edp, n));
+				printf("CSI%dm unknown\n", ARG(vd, n));
 #endif
 				break;
+			}
+		}
-		if (vt100_selectattribute(edp, flags, fgcol, bgcol, &attr,
+		if (vt100_selectattribute(vd, flags, fgcol, bgcol, &attr,
 		    &bkgdattr)) {
 #ifdef VT100_DEBUG
 			printf("error allocating attr %d/%d/%x\n",
 			       fgcol, bgcol, flags);
 #endif
 		} else {
-			edp->curattr = attr;
+			vd->curattr = attr;
-			edp->bkgdattr = bkgdattr;
+			vd->bkgdattr = bkgdattr;
-			edp->attrflags = flags;
+			vd->attrflags = flags;
-			edp->fgcol = fgcol;
+			vd->fgcol = fgcol;
-			edp->bgcol = bgcol;
+			vd->bgcol = bgcol;
+		}
 		break;
 	    case 't': /* terminal size and such */
-		switch (ARG(edp, 0)) {
+		switch (ARG(vd, 0)) {
 		    case 18: {	/* xterm size */
 			char buf[20];
 			n = snprintf(buf, sizeof(buf), "\033[8;%d;%dt",
-			    edp->nrows, edp->ncols);
+			    vd->nrows, vd->ncols);
-			wsdisplay_emulinput(edp->cbcookie, buf, n);
+			wsdisplay_emulinput(vd->cbcookie, buf, n);
+			}
 			break;
+		}
 		break;
 	    case 'n': /* reports */
-		switch (ARG(edp, 0)) {
+		switch (ARG(vd, 0)) {
 		    case 5: /* DSR operating status */
 			/* 0 = OK, 3 = malfunction */
-			wsdisplay_emulinput(edp->cbcookie, "\033[0n", 4);
+			wsdisplay_emulinput(vd->cbcookie, "\033[0n", 4);
 			break;
 		    case 6: { /* DSR cursor position report */
 			char buf[20];
 			int row;
-			if (edp->flags & VTFL_DECOM)
+			if (vd->flags & VTFL_DECOM)
-				row = ROWS_ABOVE(edp);
+				row = ROWS_ABOVE(vd);
 			else
-				row = edp->crow;
+				row = vd->crow;
 			n = snprintf(buf, sizeof(buf), "\033[%d;%dR",
-			    row + 1, edp->ccol + 1);
+			    row + 1, vd->ccol + 1);
-			wsdisplay_emulinput(edp->cbcookie, buf, n);
+			wsdisplay_emulinput(vd->cbcookie, buf, n);
+			}
 			break;
 		    case 15: /* DSR printer status */
 			/* 13 = no printer, 10 = ready, 11 = not ready */
-			wsdisplay_emulinput(edp->cbcookie, "\033[?13n", 6);
+			wsdisplay_emulinput(vd->cbcookie, "\033[?13n", 6);
 			break;
 		    case 25: /* UDK status - VT300 only */
 			/* 20 = locked, 21 = unlocked */
-			wsdisplay_emulinput(edp->cbcookie, "\033[?21n", 6);
+			wsdisplay_emulinput(vd->cbcookie, "\033[?21n", 6);
 			break;
 		    case 26: /* keyboard dialect */
 			/* 1 = north american , 7 = german */
-			wsdisplay_emulinput(edp->cbcookie, "\033[?27;1n", 8);
+			wsdisplay_emulinput(vd->cbcookie, "\033[?27;1n", 8);
 			break;
 		    default:
 #ifdef VT100_PRINTUNKNOWN
-			printf("CSI%dn unknown\n", ARG(edp, 0));
+			printf("CSI%dn unknown\n", ARG(vd, 0));
 #endif
 			break;
+		}
 		break;
 	    case 'r': /* DECSTBM set top/bottom margins */
-		help = uimin(DEF1_ARG(edp, 0), edp->nrows) - 1;
+		help = uimin(DEF1_ARG(vd, 0), vd->nrows) - 1;
-		n = uimin(DEFx_ARG(edp, 1, edp->nrows), edp->nrows) - help;
+		n = uimin(DEFx_ARG(vd, 1, vd->nrows), vd->nrows) - help;
 		if (n < 2) {
 			/* minimal scrolling region has 2 lines */
 			return;
 		} else {
-			edp->scrreg_startrow = help;
+			vd->scrreg_startrow = help;
-			edp->scrreg_nrows = n;
+			vd->scrreg_nrows = n;
+		}
-		edp->crow = ((edp->flags & VTFL_DECOM) ?
+		vd->crow = ((vd->flags & VTFL_DECOM) ?
-			     edp->scrreg_startrow : 0);
+			     vd->scrreg_startrow : 0);
-		edp->ccol = 0;
+		vd->ccol = 0;
 		break;
 	    case 'y':
-		switch (ARG(edp, 0)) {
+		switch (ARG(vd, 0)) {
 		    case 4: /* DECTST invoke confidence test */
 			/* ignore */
 			break;
 		    default:
 #ifdef VT100_PRINTUNKNOWN
-			printf("CSI%dy unknown\n", ARG(edp, 0));
+			printf("CSI%dy unknown\n", ARG(vd, 0));
 #endif
 			break;
+		}
 		break;
 	    default:
 #ifdef VT100_PRINTUNKNOWN
-		printf("CSI%c (%d, %d) unknown\n", c, ARG(edp, 0), ARG(edp, 1));
+		printf("CSI%c (%d, %d) unknown\n", c, ARG(vd, 0), ARG(vd, 1));
 #endif
 		break;
+	}
+}
 /*
  * get an attribute from the graphics driver,
  * try to find replacements if the desired appearance
  * is not supported
  */
 static int
-vt100_selectattribute(struct vt100base_data *edp,
+vt100_selectattribute(struct vt100base_data *vd,
 	int flags, int fgcol, int bgcol, long *attr, long *bkgdattr)
+{
 	int error;
-	if (!(edp->scrcapabilities & WSSCREEN_WSCOLORS)) {
+	if (!(vd->scrcapabilities & WSSCREEN_WSCOLORS)) {
 		flags &= ~WSATTR_WSCOLORS;
 #ifdef VT100_DEBUG
 		printf("colors ignored (impossible)\n");
 #endif
 	} else
 		flags |= WSATTR_WSCOLORS;
-	error = (*edp->emulops->allocattr)(edp->emulcookie, fgcol, bgcol,
+	error = (*vd->emulops->allocattr)(vd->emulcookie, fgcol, bgcol,
 					   flags & WSATTR_WSCOLORS, bkgdattr);
 	if (error)
 		return (error);
 	if ((flags & WSATTR_HILIT) &&
-	    !(edp->scrcapabilities & WSSCREEN_HILIT)) {
+	    !(vd->scrcapabilities & WSSCREEN_HILIT)) {
 		flags &= ~WSATTR_HILIT;
-		if (edp->scrcapabilities & WSSCREEN_WSCOLORS) {
+		if (vd->scrcapabilities & WSSCREEN_WSCOLORS) {
 #if defined(WSEMUL_VT100_HILIT_FG) && WSEMUL_VT100_HILIT_FG != -1
 			fgcol = WSEMUL_VT100_HILIT_FG;
 #elif !defined(WSEMUL_VT100_HILIT_FG)
 			fgcol = WSCOL_RED;
 #endif
 #if defined(WSEMUL_VT100_HILIT_BG) && WSEMUL_VT100_HILIT_BG != -1
 			bgcol = WSEMUL_VT100_HILIT_BG;
 #endif
 			flags |= WSATTR_WSCOLORS;
 		} else {
 #ifdef VT100_DEBUG
 			printf("bold ignored (impossible)\n");
 #endif
+		}
+	}
 	if ((flags & WSATTR_UNDERLINE) &&
-	    !(edp->scrcapabilities & WSSCREEN_UNDERLINE)) {
+	    !(vd->scrcapabilities & WSSCREEN_UNDERLINE)) {
 		flags &= ~WSATTR_UNDERLINE;
-		if (edp->scrcapabilities & WSSCREEN_WSCOLORS) {
+		if (vd->scrcapabilities & WSSCREEN_WSCOLORS) {
 #if defined(WSEMUL_VT100_UNDERLINE_FG) && WSEMUL_VT100_UNDERLINE_FG != -1
 			fgcol = WSEMUL_VT100_UNDERLINE_FG;
 #endif
 #if defined(WSEMUL_VT100_UNDERLINE_BG) && WSEMUL_VT100_UNDERLINE_BG != -1
 			bgcol = WSEMUL_VT100_UNDERLINE_BG;
 #elif !defined(WSEMUL_VT100_UNDERLINE_BG)
 			bgcol = WSCOL_BROWN;
 #endif
 			flags |= WSATTR_WSCOLORS;
 		} else {
 #ifdef VT100_DEBUG
 			printf("underline ignored (impossible)\n");
 #endif
+		}
+	}
 	if ((flags & WSATTR_BLINK) &&
-	    !(edp->scrcapabilities & WSSCREEN_BLINK)) {
+	    !(vd->scrcapabilities & WSSCREEN_BLINK)) {
 		flags &= ~WSATTR_BLINK;
 #ifdef VT100_DEBUG
 		printf("blink ignored (impossible)\n");
 #endif
+	}
 	if ((flags & WSATTR_REVERSE) &&
-	    !(edp->scrcapabilities & WSSCREEN_REVERSE)) {
+	    !(vd->scrcapabilities & WSSCREEN_REVERSE)) {
 		flags &= ~WSATTR_REVERSE;
-		if (edp->scrcapabilities & WSSCREEN_WSCOLORS) {
+		if (vd->scrcapabilities & WSSCREEN_WSCOLORS) {
 			int help;
 			help = bgcol;
 			bgcol = fgcol;
 			fgcol = help;
 			flags |= WSATTR_WSCOLORS;
 		} else {
 #ifdef VT100_DEBUG
 			printf("reverse ignored (impossible)\n");
 #endif
+		}
+	}
-	error = (*edp->emulops->allocattr)(edp->emulcookie, fgcol, bgcol,
+	error = (*vd->emulops->allocattr)(vd->emulcookie, fgcol, bgcol,
 					   flags, attr);
 	if (error)
 		return (error);
 	return (0);
+}
 /*
  * handle device control sequences if the main state machine
- * told so by setting edp->dcstype to a nonzero value
+ * told so by setting vd->dcstype to a nonzero value
  */
 void
-wsemul_vt100_handle_dcs(struct vt100base_data *edp)
+wsemul_vt100_handle_dcs(struct vt100base_data *vd)
+{
 	int i, pos;
-	switch (edp->dcstype) {
+	switch (vd->dcstype) {
 	    case 0: /* not handled */
 		return;
 	    case DCSTYPE_TABRESTORE:
-		KASSERT(edp->tabs != 0);
+		KASSERT(vd->tabs != NULL);
-		memset(edp->tabs, 0, edp->ncols);
+		KASSERT(vd->ncols <= 1024);
 		memset(vd->tabs, 0, vd->ncols);
 		pos = 0;
-		for (i = 0; i < edp->dcspos; i++) {
+		for (i = 0; i < vd->dcspos; i++) {
-			char c = edp->dcsarg[i];
+			char c = vd->dcsarg[i];
 			switch (c) {
 			    case '0': case '1': case '2': case '3': case '4':
-			    case '5': case '6': case '7': case '8': case '9':
+			    case '5': case '6': case '7': case '8': case '9': {
-				pos = pos * 10 + (edp->dcsarg[i] - '0');
+				const int c0 = c - '0';
 				if (pos < 0 ||
 				    pos > INT_MAX/10 ||
 				    pos * 10 > vd->ncols - c0) {
 					pos = -1;
 					break;
+				}
 				pos = pos * 10 + c0;
 				break;
+			    }
 			    case '/':
-				if (pos > 0)
+				if (pos > 0) {
-					edp->tabs[pos - 1] = 1;
+					KASSERT(pos <= vd->ncols);
 					vd->tabs[pos - 1] = 1;
+				}
 				pos = 0;
 				break;
 			    default:
 #ifdef VT100_PRINTUNKNOWN
 				printf("unknown char %c in DCS\n", c);
 #endif
 				break;
+			}
+		}
-		if (pos > 0)
+		if (pos > 0) {
-			edp->tabs[pos - 1] = 1;
+			KASSERT(pos <= vd->ncols);
 			vd->tabs[pos - 1] = 1;
+		}
 		break;
 	    default:
-		panic("wsemul_vt100_handle_dcs: bad type %d", edp->dcstype);
+		panic("wsemul_vt100_handle_dcs: bad type %d", vd->dcstype);
+	}
-	edp->dcstype = 0;
+	vd->dcstype = 0;
+}
 static int
-vt100_ansimode(struct vt100base_data *edp, int nr, int op)
+vt100_ansimode(struct vt100base_data *vd, int nr, int op)
+{
 	int res = 0; /* default: unknown */
 	switch (nr) {
 	    case 2: /* KAM keyboard locked/unlocked */
 		break;
 	    case 3: /* CRM control representation */
 		break;
 	    case 4: /* IRM insert/replace characters */
 		if (op == VTMODE_SET)
-			edp->flags |= VTFL_INSERTMODE;
+			vd->flags |= VTFL_INSERTMODE;
 		else if (op == VTMODE_RESET)
-			edp->flags &= ~VTFL_INSERTMODE;
+			vd->flags &= ~VTFL_INSERTMODE;
-		res = ((edp->flags & VTFL_INSERTMODE) ? 1 : 2);
+		res = ((vd->flags & VTFL_INSERTMODE) ? 1 : 2);
 		break;
 	    case 10: /* HEM horizontal editing (permanently reset) */
 		res = 4;
 		break;
 	    case 12: /* SRM local echo off/on */
 		res = 4; /* permanently reset ??? */
 		break;
 	    case 20: /* LNM newline = newline/linefeed */
 		break;
 	    default:
 #ifdef VT100_PRINTUNKNOWN
 		printf("ANSI mode %d unknown\n", nr);
 #endif
 		break;
+	}
 	return (res);
+}
 static int
-vt100_decmode(struct vt100base_data *edp, int nr, int op)
+vt100_decmode(struct vt100base_data *vd, int nr, int op)
+{
 	int res = 0; /* default: unknown */
 	int flags;
-	flags = edp->flags;
+	flags = vd->flags;
 	switch (nr) {
 	    case 1: /* DECCKM application/nomal cursor keys */
 		if (op == VTMODE_SET)
 			flags |= VTFL_APPLCURSOR;
 		else if (op == VTMODE_RESET)
 			flags &= ~VTFL_APPLCURSOR;
 		res = ((flags & VTFL_APPLCURSOR) ? 1 : 2);
 		break;
 	    case 2: /* DECANM ANSI vt100/vt52 */
 		res = 3; /* permanently set ??? */
 		break;
 	    case 3: /* DECCOLM 132/80 cols */
 	    case 4: /* DECSCLM smooth/jump scroll */
 @@ -841,41 +882,41 @@ vt100_decmode(struct vt100base_data *edp
 		res = ((flags & VTFL_DECAWM) ? 1 : 2);
 		break;
 	    case 8: /* DECARM keyboard autorepeat */
 		break;
 	    case 18: /* DECPFF print form feed */
 		break;
 	    case 19: /* DECPEX printer extent: screen/scrolling region */
 		break;
 	    case 25: /* DECTCEM text cursor on/off */
 		if (op == VTMODE_SET)
 			flags |= VTFL_CURSORON;
 		else if (op == VTMODE_RESET)
 			flags &= ~VTFL_CURSORON;
-		if (flags != edp->flags)
+		if (flags != vd->flags)
-			(*edp->emulops->cursor)(edp->emulcookie,
+			(*vd->emulops->cursor)(vd->emulcookie,
 						flags & VTFL_CURSORON,
-						edp->crow, edp->ccol);
+						vd->crow, vd->ccol);
 		res = ((flags & VTFL_CURSORON) ? 1 : 2);
 		break;
 	    case 42: /* DECNRCM use 7-bit NRC /
 /8 bit from DEC multilingual or ISO-latin-1*/
 		if (op == VTMODE_SET)
 			flags |= VTFL_NATCHARSET;
 		else if (op == VTMODE_RESET)
 			flags &= ~VTFL_NATCHARSET;
 		res = ((flags & VTFL_NATCHARSET) ? 1 : 2);
 		break;
 	    case 66: /* DECNKM numeric keypad */
 		break;
 	    case 68: /* DECKBUM keyboard usage data processing/typewriter */
 		break;
 	    default:
 #ifdef VT100_PRINTUNKNOWN
 		printf("DEC mode %d unknown\n", nr);
 #endif
 		break;
+	}
-	edp->flags = flags;
+	vd->flags = flags;
 	return (res);
+}