Part 3 of the pcvt/voxware revival.

Reviewed by:	core

1 files changed, 2187 insertions, 0 deletions

diff --git a/sys/i386/isa/pcvt/pcvt_vtf.c b/sys/i386/isa/pcvt/pcvt_vtf.c
new file mode 100644
index 0000000..e3f7878
--- /dev/null
+++ b/sys/i386/isa/pcvt/pcvt_vtf.c
@@ -0,0 +1,2187 @@
+/*
+ * Copyright (c) 1992, 1995 Hellmuth Michaelis and Joerg Wunsch.
+ *
+ * Copyright (c) 1992, 1993 Brian Dunford-Shore.
+ *
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * William Jolitz and Don Ahn.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *	This product includes software developed by Hellmuth Michaelis,
+ *	Brian Dunford-Shore and Joerg Wunsch.
+ * 4. The name authors may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHORS 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.
+ *
+ *
+ * @(#)pcvt_vtf.c, 3.20, Last Edit-Date: [Wed Apr  5 18:08:50 1995]
+ */
+
+/*---------------------------------------------------------------------------*
+ *
+ *	pcvt_vtf.c	VT220 Terminal Emulator Functions
+ *	-------------------------------------------------
+ *	-hm	------------ Release 3.00 --------------
+ *	-hm	integrating NetBSD-current patches
+ *	-hm	integrating patch from Thomas Gellekum
+ *	-hm	fixed bug fkey labels not properly (re)set after ris
+ *	-hm	Michael Havemester fixed NOFASTSCROLL define bug
+ *	-hm	set caps/scroll/num_lock in vt_str() and made led_update()
+ *	-hm	applying patch from Joerg fixing Crtat bug
+ *	-hm	fixing NOFASTSCROLL operation for MDA/Hercules
+ *	-jw/hm	fixing bug in roll_up() and roll_down()
+ *	-hm	fastscroll/Crtat bugfix from Lon Willett
+ *	-hm	patch for non-XSERVER/UCONSOLE compiles from Rafal Boni
+ *	-hm	bugfix: PCVT_USL_COMPAT renamed to PCVT_USL_VT_COMPAT ...
+ *
+ *---------------------------------------------------------------------------*/
+
+#include "vt.h"
+#if NVT > 0
+
+#define PCVT_INCLUDE_VT_SELATTR	/* get inline function from pcvt_hdr.h */
+
+#include <i386/isa/pcvt/pcvt_hdr.h>	/* global include */
+#include <i386/isa/pcvt/pcvt_tbl.h>	/* character set conversion tables */
+
+static void clear_dld ( struct video_state *svsp );
+static void init_dld ( struct video_state *svsp );
+static void init_udk ( struct video_state *svsp );
+static void respond ( struct video_state *svsp );
+static void roll_down ( struct video_state *svsp, int n );
+static void selective_erase ( struct video_state *svsp, u_short *pcrtat,
+			      int length );
+static void swcsp ( struct video_state *svsp, u_short *ctp );
+
+/*---------------------------------------------------------------------------*
+ *	DECSTBM - set top and bottom margins
+ *---------------------------------------------------------------------------*/
+void
+vt_stbm(struct video_state *svsp)
+{
+	/* both 0 => scrolling region = entire screen */
+
+	if((svsp->parms[0] == 0) && (svsp->parms[1] == 0))
+	{
+		svsp->cur_offset = 0;
+		svsp->scrr_beg = 0;
+		svsp->scrr_len = svsp->screen_rows;
+		svsp->scrr_end = svsp->scrr_len - 1;
+		svsp->col = 0;
+		return;
+	}
+
+	if(svsp->parms[1] <= svsp->parms[0])
+		return;
+
+	/* range parm 1 */
+
+	if(svsp->parms[0] < 1)
+		svsp->parms[0] = 1;
+	else if(svsp->parms[0] > svsp->screen_rows-1)
+		svsp->parms[0] = svsp->screen_rows-1;
+
+	/* range parm 2 */
+
+	if(svsp->parms[1] < 2)
+		svsp->parms[1] = 2;
+	else if(svsp->parms[1] > svsp->screen_rows)
+		svsp->parms[1] = svsp->screen_rows;
+
+	svsp->scrr_beg = svsp->parms[0]-1;	/* begin of scrolling region */
+	svsp->scrr_len = svsp->parms[1] - svsp->parms[0] + 1; /* no of lines */
+	svsp->scrr_end = svsp->parms[1]-1;
+
+	/* cursor to first pos */
+	if(svsp->m_om)
+		svsp->cur_offset = svsp->scrr_beg * svsp->maxcol;
+	else
+		svsp->cur_offset = 0;
+
+	svsp->col = 0;
+}
+
+/*---------------------------------------------------------------------------*
+ *	SGR - set graphic rendition
+ *---------------------------------------------------------------------------*/
+void
+vt_sgr(struct video_state *svsp)
+{
+	register int i = 0;
+	u_short setcolor = 0;
+	char colortouched = 0;
+
+	do
+	{
+		switch(svsp->parms[i++])
+		{
+			case 0:		/* reset to normal attributes */
+				svsp->vtsgr = VT_NORMAL;
+				break;
+
+			case 1:		/* bold */
+				svsp->vtsgr |= VT_BOLD;
+				break;
+
+			case 4:		/* underline */
+				svsp->vtsgr |= VT_UNDER;
+				break;
+
+			case 5:		/* blinking */
+				svsp->vtsgr |= VT_BLINK;
+				break;
+
+			case 7:		/* reverse */
+				svsp->vtsgr |= VT_INVERSE;
+				break;
+
+			case 22:	/* not bold */
+				svsp->vtsgr &= ~VT_BOLD;
+				break;
+
+			case 24:	/* not underlined */
+				svsp->vtsgr &= ~VT_UNDER;
+				break;
+
+			case 25:	/* not blinking */
+				svsp->vtsgr &= ~VT_BLINK;
+				break;
+
+			case 27:	/* not reverse */
+				svsp->vtsgr &= ~VT_INVERSE;
+				break;
+
+			case 30:	/* foreground colors */
+			case 31:
+			case 32:
+			case 33:
+			case 34:
+			case 35:
+			case 36:
+			case 37:
+				if(color)
+				{
+				 colortouched = 1;
+				 setcolor |= ((fgansitopc[(svsp->parms[i-1]-30) & 7]) << 8);
+				}
+				break;
+
+			case 40:	/* background colors */
+			case 41:
+			case 42:
+			case 43:
+			case 44:
+			case 45:
+			case 46:
+			case 47:
+				if(color)
+				{
+				 colortouched = 1;
+				 setcolor |= ((bgansitopc[(svsp->parms[i-1]-40) & 7]) << 8);
+				}
+				break;
+		}
+	}
+	while(i <= svsp->parmi);
+	if(color)
+	{
+		if(colortouched)
+			svsp->c_attr = setcolor;
+		else
+			svsp->c_attr = ((sgr_tab_color[svsp->vtsgr]) << 8);
+	}
+	else
+	{
+		if(adaptor_type == MDA_ADAPTOR)
+			svsp->c_attr = ((sgr_tab_imono[svsp->vtsgr]) << 8);
+		else
+			svsp->c_attr = ((sgr_tab_mono[svsp->vtsgr]) << 8);
+	}
+}
+
+/*---------------------------------------------------------------------------*
+ *	CUU - cursor up
+ *---------------------------------------------------------------------------*/
+void
+vt_cuu(struct video_state *svsp)
+{
+	register int p = svsp->parms[0];
+
+	if (p <= 0)				/* parameter min */
+		p = 1;
+
+	p = min(p, svsp->row - svsp->scrr_beg);
+
+	if (p <= 0)
+		return;
+
+	svsp->cur_offset -= (svsp->maxcol * p);
+}
+
+/*---------------------------------------------------------------------------*
+ *	CUD - cursor down
+ *---------------------------------------------------------------------------*/
+void
+vt_cud(struct video_state *svsp)
+{
+	register int p = svsp->parms[0];
+
+	if (p <= 0)
+		p = 1;
+
+	p = min(p, svsp->scrr_end - svsp->row);
+
+	if (p <= 0)
+		return;
+
+	svsp->cur_offset += (svsp->maxcol * p);
+}
+
+/*---------------------------------------------------------------------------*
+ *	CUF - cursor forward
+ *---------------------------------------------------------------------------*/
+void
+vt_cuf(struct video_state *svsp)
+{
+	register int p = svsp->parms[0];
+
+	if(svsp->col == ((svsp->maxcol)-1))	/* already at right margin */
+		return;
+
+	if(p <= 0)				/* parameter min = 1 */
+		p = 1;
+	else if(p > ((svsp->maxcol)-1))		/* parameter max = 79 */
+		p = ((svsp->maxcol)-1);
+
+	if((svsp->col + p) > ((svsp->maxcol)-1))/* not more than right margin */
+		p = ((svsp->maxcol)-1) - svsp->col;
+
+	svsp->cur_offset += p;
+	svsp->col += p;
+}
+
+/*---------------------------------------------------------------------------*
+ *	CUB - cursor backward
+ *---------------------------------------------------------------------------*/
+void
+vt_cub(struct video_state *svsp)
+{
+	register int p = svsp->parms[0];
+
+	if(svsp->col == 0)			/* already at left margin ? */
+		return;
+
+	if(p <= 0)				/* parameter min = 1 */
+		p = 1;
+	else if(p > ((svsp->maxcol)-1))		/* parameter max = 79 */
+		p = ((svsp->maxcol)-1);
+
+	if((svsp->col - p) <= 0)		/* not more than left margin */
+		p = svsp->col;
+
+	svsp->cur_offset -= p;
+	svsp->col -= p;
+}
+
+/*---------------------------------------------------------------------------*
+ *	ED - erase in display
+ *---------------------------------------------------------------------------*/
+void
+vt_clreos(struct video_state *svsp)
+{
+	switch(svsp->parms[0])
+	{
+		case 0:
+			fillw(user_attr | ' ', svsp->Crtat + svsp->cur_offset,
+				svsp->Crtat +
+				(svsp->maxcol * svsp->screen_rows) -
+				(svsp->Crtat + svsp->cur_offset));
+			break;
+
+		case 1:
+			fillw(user_attr | ' ', svsp->Crtat,
+				svsp->Crtat + svsp->cur_offset -
+				svsp->Crtat + 1 );
+			break;
+
+		case 2:
+			fillw(user_attr | ' ', svsp->Crtat,
+				svsp->maxcol * svsp->screen_rows);
+			break;
+	}
+}
+
+/*---------------------------------------------------------------------------*
+ *	EL - erase in line
+ *---------------------------------------------------------------------------*/
+void
+vt_clreol(struct video_state *svsp)
+{
+	switch(svsp->parms[0])
+	{
+		case 0:
+			fillw(user_attr | ' ',
+				svsp->Crtat + svsp->cur_offset,
+				svsp->maxcol-svsp->col);
+			break;
+
+		case 1:
+			fillw(user_attr | ' ',
+				svsp->Crtat + svsp->cur_offset - svsp->col,
+				svsp->col + 1);
+			break;
+
+		case 2:
+			fillw(user_attr | ' ',
+				svsp->Crtat + svsp->cur_offset - svsp->col,
+				svsp->maxcol);
+			break;
+	}
+}
+
+/*---------------------------------------------------------------------------*
+ *	CUP - cursor position / HVP - horizontal & vertical position
+ *---------------------------------------------------------------------------*/
+void
+vt_curadr(struct video_state *svsp)
+{
+	if(svsp->m_om)	/* relative to scrolling region */
+	{
+		if((svsp->parms[0] == 0) && (svsp->parms[1] == 0))
+		{
+			svsp->cur_offset = svsp->scrr_beg * svsp->maxcol;
+			svsp->col = 0;
+                        svsp->abs_write = 0;
+			return;
+		}
+
+		if(svsp->parms[0] <= 0)
+			svsp->parms[0] = 1;
+		else if(svsp->parms[0] > svsp->scrr_len)
+			svsp->parms[0] = svsp->scrr_len;
+
+		if(svsp->parms[1] <= 0 )
+			svsp->parms[1] = 1;
+		if(svsp->parms[1] > svsp->maxcol)
+			svsp->parms[1] = svsp->maxcol;
+
+		svsp->cur_offset = (svsp->scrr_beg * svsp->maxcol) +
+				   ((svsp->parms[0] - 1) * svsp->maxcol) +
+				   svsp->parms[1] - 1;
+		svsp->col = svsp->parms[1] - 1;
+                svsp->abs_write = 0;
+	}
+	else	/* relative to screen start */
+	{
+		if((svsp->parms[0] == 0) && (svsp->parms[1] == 0))
+		{
+			svsp->cur_offset = 0;
+			svsp->col = 0;
+                        svsp->abs_write = 0;
+			return;
+		}
+
+		if(svsp->parms[0] <= 0)
+			svsp->parms[0] = 1;
+		else if(svsp->parms[0] > svsp->screen_rows)
+			svsp->parms[0] = svsp->screen_rows;
+
+		if(svsp->parms[1] <= 0 )
+			svsp->parms[1] = 1;
+		if(svsp->parms[1] > svsp->maxcol)	/* col */
+			svsp->parms[1] = svsp->maxcol;
+
+		svsp->cur_offset = (((svsp->parms[0]-1)*svsp->maxcol) +
+				    (svsp->parms[1]-1));
+		svsp->col = svsp->parms[1]-1;
+
+                if (svsp->cur_offset >=
+                        ((svsp->scrr_beg + svsp->scrr_len + 1) * svsp->maxcol))
+
+                        svsp->abs_write = 1;
+                else
+                        svsp->abs_write = 0;
+	}
+}
+
+/*---------------------------------------------------------------------------*
+ *	RIS - reset to initial state (hard emulator runtime reset)
+ *---------------------------------------------------------------------------*/
+void
+vt_ris(struct video_state *svsp)
+{
+	fillw(user_attr | ' ', svsp->Crtat, svsp->maxcol * svsp->screen_rows);
+	svsp->cur_offset = 0;		/* cursor upper left corner */
+	svsp->col = 0;
+	svsp->row = 0;
+	svsp->lnm = 0;			/* CR only */
+	clear_dld(svsp);		/* clear download charset */
+	vt_clearudk(svsp);		/* clear user defined keys */
+	svsp->selchar = 0;		/* selective attribute off */
+	vt_str(svsp);			/* and soft terminal reset */
+}
+
+/*---------------------------------------------------------------------------*
+ *	DECSTR - soft terminal reset (SOFT emulator runtime reset)
+ *---------------------------------------------------------------------------*/
+void
+vt_str(struct video_state *svsp)
+{
+	int i;
+
+	clr_parms(svsp);			/* escape parameter init */
+	svsp->state = STATE_INIT;		/* initial state */
+
+	svsp->dis_fnc = 0;			/* display functions reset */
+
+	svsp->sc_flag = 0;			/* save cursor position */
+	svsp->transparent = 0;			/* enable control code processing */
+
+	for(i = 0; i < MAXTAB; i++)		/* setup tabstops */
+	{
+		if(!(i % 8))
+			svsp->tab_stops[i] = 1;
+		else
+			svsp->tab_stops[i] = 0;
+	}
+
+	svsp->irm = 0;				/* replace mode */
+	svsp->m_om = 0;				/* origin mode */
+	svsp->m_awm = 1;			/* auto wrap mode */
+
+#if PCVT_INHIBIT_NUMLOCK
+	svsp->num_lock = 0;			/* keypad application mode */
+#else
+	svsp->num_lock = 1;			/* keypad numeric mode */
+#endif
+
+	svsp->scroll_lock = 0;			/* reset keyboard modes */
+	svsp->caps_lock = 0;
+
+	svsp->ckm = 1;				/* cursor key mode = "normal" ... */
+	svsp->scrr_beg = 0;			/* start of scrolling region */
+	svsp->scrr_len = svsp->screen_rows;	/* no. of lines in scrolling region */
+	svsp->abs_write = 0;			/* scrr is complete screen */
+	svsp->scrr_end = svsp->scrr_len - 1;
+
+	if(adaptor_type == EGA_ADAPTOR || adaptor_type == VGA_ADAPTOR)
+	{
+		svsp->G0 = cse_ascii;		/* G0 = ascii	*/
+		svsp->G1 = cse_ascii;		/* G1 = ascii	*/
+		svsp->G2 = cse_supplemental;	/* G2 = supplemental */
+		svsp->G3 = cse_supplemental;	/* G3 = supplemental */
+		svsp->GL = &svsp->G0;		/* GL = G0 */
+		svsp->GR = &svsp->G2;		/* GR = G2 */
+	}
+	else
+	{
+		svsp->G0 = csd_ascii;		/* G0 = ascii	*/
+		svsp->G1 = csd_ascii;		/* G1 = ascii	*/
+		svsp->G2 = csd_supplemental;	/* G2 = supplemental */
+		svsp->G3 = csd_supplemental;	/* G3 = supplemental */
+		svsp->GL = &svsp->G0;		/* GL = G0 */
+		svsp->GR = &svsp->G2;		/* GR = G2 */
+	}
+
+	svsp->vtsgr = VT_NORMAL;		/* no attributes */
+	svsp->c_attr = user_attr;		/* reset sgr to normal */
+
+	svsp->selchar = 0;			/* selective attribute off */
+	vt_initsel(svsp);
+
+	init_ufkl(svsp);			/* init user fkey labels */
+	init_sfkl(svsp);			/* init system fkey labels */
+
+	update_led();				/* update keyboard LED's */
+}
+
+/*---------------------------------------------------------------------------*
+ *	RI - reverse index, move cursor up
+ *---------------------------------------------------------------------------*/
+void
+vt_ri(struct video_state *svsp)
+{
+	if(svsp->cur_offset >= ((svsp->scrr_beg * svsp->maxcol) + svsp->maxcol))
+		svsp->cur_offset -= svsp->maxcol;
+	else
+		roll_down(svsp, 1);
+}
+
+/*---------------------------------------------------------------------------*
+ *	IND - index, move cursor down
+ *---------------------------------------------------------------------------*/
+void
+vt_ind(struct video_state *svsp)
+{
+	if(svsp->cur_offset < (svsp->scrr_end * svsp->maxcol))
+		svsp->cur_offset += svsp->maxcol;
+	else
+		roll_up(svsp, 1);
+}
+
+/*---------------------------------------------------------------------------*
+ *	NEL - next line, first pos of next line
+ *---------------------------------------------------------------------------*/
+void
+vt_nel(struct video_state *svsp)
+{
+	if(svsp->cur_offset < (svsp->scrr_end * svsp->maxcol))
+	{
+		svsp->cur_offset += (svsp->maxcol-svsp->col);
+		svsp->col = 0;
+	}
+	else
+	{
+		roll_up(svsp, 1);
+		svsp->cur_offset -= svsp->col;
+		svsp->col = 0;
+	}
+}
+
+/*---------------------------------------------------------------------------*
+ *	set dec private modes, esc [ ? x h
+ *---------------------------------------------------------------------------*/
+void
+vt_set_dec_priv_qm(struct video_state *svsp)
+{
+	switch(svsp->parms[0])
+	{
+		case 0:		/* error, ignored */
+		case 1:		/* CKM - cursor key mode */
+			svsp->ckm = 1;
+			break;
+
+		case 2:		/* ANM - ansi/vt52 mode */
+			break;
+
+		case 3:		/* COLM - column mode */
+			vt_col(svsp, SCR_COL132);
+			break;
+
+		case 4:		/* SCLM - scrolling mode */
+		case 5:		/* SCNM - screen mode */
+			break;
+
+		case 6:		/* OM - origin mode */
+			svsp->m_om = 1;
+			break;
+
+		case 7:		/* AWM - auto wrap mode */
+			svsp->m_awm = 1;
+			swritefkl(7,(u_char *)"AUTOWRAPENABLE *",svsp);
+			break;
+
+		case 8:		/* ARM - auto repeat mode */
+			kbrepflag = 1;
+			break;
+
+		case 9:		/* INLM - interlace mode */
+		case 10:	/* EDM - edit mode */
+		case 11:	/* LTM - line transmit mode */
+		case 12:	/* */
+		case 13:	/* SCFDM - space compression / field delimiting */
+		case 14:	/* TEM - transmit execution mode */
+		case 15:	/* */
+		case 16:	/* EKEM - edit key execution mode */
+			break;
+
+		case 25:	/* TCEM - text cursor enable mode */
+			if(vsp == svsp)
+				sw_cursor(1);	/* cursor on */
+			svsp->cursor_on = 1;
+			break;
+
+		case 42:	/* NRCM - 7bit NRC characters */
+			break;
+	}
+}
+
+/*---------------------------------------------------------------------------*
+ *	reset dec private modes, esc [ ? x l
+ *---------------------------------------------------------------------------*/
+void
+vt_reset_dec_priv_qm(struct video_state *svsp)
+{
+	switch(svsp->parms[0])
+	{
+		case 0:		/* error, ignored */
+		case 1:		/* CKM - cursor key mode */
+			svsp->ckm = 0;
+			break;
+
+		case 2:		/* ANM - ansi/vt52 mode */
+			break;
+
+		case 3:		/* COLM - column mode */
+			vt_col(svsp, SCR_COL80);
+			break;
+
+		case 4:		/* SCLM - scrolling mode */
+		case 5:		/* SCNM - screen mode */
+			break;
+
+		case 6:		/* OM - origin mode */
+			svsp->m_om = 0;
+			break;
+
+		case 7:		/* AWM - auto wrap mode */
+			svsp->m_awm = 0;
+			swritefkl(7,(u_char *)"AUTOWRAPENABLE  ",svsp);
+			break;
+
+		case 8:		/* ARM - auto repeat mode */
+			kbrepflag = 0;
+			break;
+
+		case 9:		/* INLM - interlace mode */
+		case 10:	/* EDM - edit mode */
+		case 11:	/* LTM - line transmit mode */
+		case 12:	/* */
+		case 13:	/* SCFDM - space compression / field delimiting */
+		case 14:	/* TEM - transmit execution mode */
+		case 15:	/* */
+		case 16:	/* EKEM - edit key execution mode */
+			break;
+
+		case 25:	/* TCEM - text cursor enable mode */
+			if(vsp == svsp)
+				sw_cursor(0);	/* cursor off */
+			svsp->cursor_on = 0;
+			break;
+
+		case 42:	/* NRCM - 7bit NRC characters */
+			break;
+	}
+}
+
+/*---------------------------------------------------------------------------*
+ *	set ansi modes, esc [ x
+ *---------------------------------------------------------------------------*/
+void
+vt_set_ansi(struct video_state *svsp)
+{
+	switch(svsp->parms[0])
+	{
+		case 0:		/* error, ignored */
+		case 1:		/* GATM - guarded area transfer mode */
+		case 2:		/* KAM - keyboard action mode */
+		case 3:		/* CRM - Control Representation mode */
+			break;
+
+		case 4:		/* IRM - insert replacement mode */
+			svsp->irm = 1; /* Insert mode */
+			break;
+
+		case 5:		/* SRTM - status report transfer mode */
+		case 6:		/* ERM - erasue mode */
+		case 7:		/* VEM - vertical editing mode */
+		case 10:	/* HEM - horizontal editing mode */
+		case 11:	/* PUM - position unit mode */
+		case 12:	/* SRM - send-receive mode */
+		case 13:	/* FEAM - format effector action mode */
+		case 14:	/* FETM - format effector transfer mode */
+		case 15:	/* MATM - multiple area transfer mode */
+		case 16:	/* TTM - transfer termination */
+		case 17:	/* SATM - selected area transfer mode */
+		case 18:	/* TSM - tabulation stop mode */
+		case 19:	/* EBM - editing boundary mode */
+			break;
+
+		case 20:	/* LNM - line feed / newline mode */
+			svsp->lnm = 1;
+			break;
+	}
+}
+
+/*---------------------------------------------------------------------------*
+ *	reset ansi modes, esc [ x
+ *---------------------------------------------------------------------------*/
+void
+vt_reset_ansi(struct video_state *svsp)
+{
+	switch(svsp->parms[0])
+	{
+		case 0:		/* error, ignored */
+		case 1:		/* GATM - guarded area transfer mode */
+		case 2:		/* KAM - keyboard action mode */
+		case 3:		/* CRM - Control Representation mode */
+			break;
+
+		case 4:		/* IRM - insert replacement mode */
+			svsp->irm = 0;  /* Replace mode */
+			break;
+
+		case 5:		/* SRTM - status report transfer mode */
+		case 6:		/* ERM - erasue mode */
+		case 7:		/* VEM - vertical editing mode */
+		case 10:	/* HEM - horizontal editing mode */
+		case 11:	/* PUM - position unit mode */
+		case 12:	/* SRM - send-receive mode */
+		case 13:	/* FEAM - format effector action mode */
+		case 14:	/* FETM - format effector transfer mode */
+		case 15:	/* MATM - multiple area transfer mode */
+		case 16:	/* TTM - transfer termination */
+		case 17:	/* SATM - selected area transfer mode */
+		case 18:	/* TSM - tabulation stop mode */
+		case 19:	/* EBM - editing boundary mode */
+			break;
+
+		case 20:	/* LNM - line feed / newline mode */
+			svsp->lnm = 0;
+			break;
+	}
+}
+
+/*---------------------------------------------------------------------------*
+ *	clear tab stop(s)
+ *---------------------------------------------------------------------------*/
+void
+vt_clrtab(struct video_state *svsp)
+{
+	int i;
+
+	if(svsp->parms[0] == 0)
+		svsp->tab_stops[svsp->col] = 0;
+	else if(svsp->parms[0] == 3)
+	{
+		for(i=0; i<MAXTAB; i++)
+			svsp->tab_stops[i] = 0;
+	}
+}
+
+/*---------------------------------------------------------------------------*
+ *	DECSC - save cursor & attributes
+ *---------------------------------------------------------------------------*/
+void
+vt_sc(struct video_state *svsp)
+{
+	svsp->sc_flag = 1;
+	svsp->sc_row = svsp->row;
+	svsp->sc_col = svsp->col;
+	svsp->sc_cur_offset = svsp->cur_offset;
+	svsp->sc_attr = svsp->c_attr;
+	svsp->sc_awm = svsp->m_awm;
+	svsp->sc_om = svsp->m_om;
+	svsp->sc_G0 = svsp->G0;
+	svsp->sc_G1 = svsp->G1;
+	svsp->sc_G2 = svsp->G2;
+	svsp->sc_G3 = svsp->G3;
+	svsp->sc_GL = svsp->GL;
+	svsp->sc_GR = svsp->GR;
+	svsp->sc_sel = svsp->selchar;
+	svsp->sc_vtsgr = svsp->vtsgr;
+}
+
+/*---------------------------------------------------------------------------*
+ *	DECRC - restore cursor & attributes
+ *---------------------------------------------------------------------------*/
+void
+vt_rc(struct video_state *svsp)
+{
+	if(svsp->sc_flag == 1)
+	{
+		svsp->sc_flag = 0;
+		svsp->row = svsp->sc_row;
+		svsp->col = svsp->sc_col;
+		svsp->cur_offset = svsp->sc_cur_offset;
+		svsp->c_attr = svsp->sc_attr;
+		svsp->m_awm = svsp->sc_awm;
+		svsp->m_om = svsp->sc_om;
+		svsp->G0 = svsp->sc_G0;
+		svsp->G1 = svsp->sc_G1;
+		svsp->G2 = svsp->sc_G2;
+		svsp->G3 = svsp->sc_G3;
+		svsp->GL = svsp->sc_GL;
+		svsp->GR = svsp->sc_GR;
+		svsp->selchar = svsp->sc_sel;
+		svsp->vtsgr = svsp->sc_vtsgr;
+	}
+}
+
+/*---------------------------------------------------------------------------*
+ *	designate a character set as G0, G1, G2 or G3 for 94/96 char sets
+ *---------------------------------------------------------------------------*/
+void
+vt_designate(struct video_state *svsp)
+{
+	u_short *ctp = NULL;
+	u_char ch;
+
+	if(svsp->whichi == 1)
+		ch = svsp->which[0];
+	else
+	{
+		int i;
+
+		if(svsp->dld_id[0] == '\0')
+			return;
+
+		if(!(((adaptor_type == EGA_ADAPTOR) ||
+		     (adaptor_type == VGA_ADAPTOR)) &&
+		     (vgacs[svsp->vga_charset].secondloaded)))
+		{
+			return;
+		}
+
+		for(i = (svsp->whichi)-1; i >= 0; i--)
+		{
+			 if(svsp->which[i] != svsp->dld_id[i])
+				return;
+		}
+#ifdef HAVECSE_DOWNLOADABLE
+		ctp = cse_downloadable;
+		swcsp(svsp, ctp);
+#endif
+		return;
+	}
+
+	if(((adaptor_type == EGA_ADAPTOR) || (adaptor_type == VGA_ADAPTOR)) &&
+	   (vgacs[svsp->vga_charset].secondloaded))
+	{
+		if((ch == svsp->dld_id[0]) && (svsp->dld_id[1] == '\0'))
+		{
+#ifdef HAVECSE_DOWNLOADABLE
+			ctp = cse_downloadable;
+			swcsp(svsp, ctp);
+#endif
+			return;
+		}
+
+		switch(ch)
+		{
+			case 'A': /* British or ISO-Latin-1 */
+				switch(svsp->state)
+				{
+					case STATE_BROPN: /* designate G0 */
+					case STATE_BRCLO: /* designate G1 */
+					case STATE_STAR:  /* designate G2 */
+					case STATE_PLUS:  /* designate G3 */
+#ifdef HAVECSE_BRITISH
+						ctp = cse_british;
+#endif
+						break;
+
+					case STATE_MINUS: /* designate G1 (96)*/
+					case STATE_DOT:	  /* designate G2 (96)*/
+					case STATE_SLASH: /* designate G3 (96)*/
+#ifdef HAVECSE_ISOLATIN
+						ctp = cse_isolatin;
+#endif
+						break;
+				}
+				break;
+
+			case 'B': /* USASCII */
+#ifdef HAVECSE_ASCII
+				ctp = cse_ascii;
+#endif
+				break;
+
+			case 'C': /* Finnish */
+			case '5': /* Finnish */
+#ifdef HAVECSE_FINNISH
+				ctp = cse_finnish;
+#endif
+				break;
+
+			case 'E': /* Norwegian/Danish */
+			case '6': /* Norwegian/Danish */
+#ifdef HAVECSE_NORWEGIANDANISH
+				ctp = cse_norwegiandanish;
+#endif
+				break;
+
+			case 'H': /* Swedish */
+			case '7': /* Swedish */
+#ifdef HAVECSE_SWEDISH
+				ctp = cse_swedish;
+#endif
+				break;
+
+			case 'K': /* German */
+#ifdef HAVECSE_GERMAN
+				ctp = cse_german;
+#endif
+				break;
+
+			case 'Q': /* French Canadien */
+#ifdef HAVECSE_FRENCHCANADA
+				ctp = cse_frenchcanada;
+#endif
+				break;
+
+			case 'R': /* French */
+#ifdef HAVECSE_FRENCH
+				ctp = cse_french;
+#endif
+				break;
+
+			case 'Y': /* Italian */
+#ifdef HAVECSE_ITALIAN
+				ctp = cse_italian;
+#endif
+				break;
+
+			case 'Z': /* Spanish */
+#ifdef HAVECSE_SPANISH
+				ctp = cse_spanish;
+#endif
+				break;
+
+			case '0': /* special graphics */
+#ifdef HAVECSE_SPECIAL
+				ctp = cse_special;
+#endif
+				break;
+
+			case '1': /* alternate ROM */
+#ifdef HAVECSE_ALTERNATEROM1
+				ctp = cse_alternaterom1;
+#endif
+				break;
+
+			case '2': /* alt ROM, spec graphics */
+#ifdef HAVECSE_ALTERNATEROM2
+				ctp = cse_alternaterom2;
+#endif
+				break;
+
+			case '3': /* HP Roman 8, upper 128 chars*/
+#ifdef HAVECSE_ROMAN8
+				ctp = cse_roman8;
+#endif
+				break;
+
+			case '4': /* Dutch */
+#ifdef HAVECSE_DUTCH
+				ctp = cse_dutch;
+#endif
+				break;
+
+			case '<': /* DEC Supplemental */
+#ifdef HAVECSE_SUPPLEMENTAL
+				ctp = cse_supplemental;
+#endif
+				break;
+
+			case '=': /* Swiss */
+#ifdef HAVECSE_SWISS
+				ctp = cse_swiss;
+#endif
+				break;
+
+			case '>': /* DEC Technical */
+#ifdef HAVECSE_TECHNICAL
+				ctp = cse_technical;
+#endif
+				break;
+
+			default:
+				break;
+		}
+	}
+	else
+	{
+		switch(ch)
+		{
+			case 'A': /* British or ISO-Latin-1 */
+				switch(svsp->state)
+				{
+					case STATE_BROPN: /* designate G0 */
+					case STATE_BRCLO: /* designate G1 */
+					case STATE_STAR:  /* designate G2 */
+					case STATE_PLUS:  /* designate G3 */
+#ifdef HAVECSD_BRITISH
+						ctp = csd_british;
+#endif
+						break;
+
+					case STATE_MINUS: /* designate G1 (96)*/
+					case STATE_DOT:	  /* designate G2 (96)*/
+					case STATE_SLASH: /* designate G3 (96)*/
+#ifdef HAVECSD_ISOLATIN
+						ctp = csd_isolatin;
+#endif
+						break;
+				}
+				break;
+
+			case 'B': /* USASCII */
+#ifdef HAVECSD_ASCII
+				ctp = csd_ascii;
+#endif
+				break;
+
+			case 'C': /* Finnish */
+			case '5': /* Finnish */
+#ifdef HAVECSD_FINNISH
+				ctp = csd_finnish;
+#endif
+				break;
+
+			case 'E': /* Norwegian/Danish */
+			case '6': /* Norwegian/Danish */
+#ifdef HAVECSD_NORWEGIANDANISH
+				ctp = csd_norwegiandanish;
+#endif
+				break;
+
+			case 'H': /* Swedish */
+			case '7': /* Swedish */
+#ifdef HAVECSD_SWEDISH
+				ctp = csd_swedish;
+#endif
+				break;
+
+			case 'K': /* German */
+#ifdef HAVECSD_GERMAN
+				ctp = csd_german;
+#endif
+				break;
+
+			case 'Q': /* French Canadien */
+#ifdef HAVECSD_FRENCHCANADA
+				ctp = csd_frenchcanada;
+#endif
+				break;
+
+			case 'R': /* French */
+#ifdef HAVECSD_FRENCH
+				ctp = csd_french;
+#endif
+				break;
+
+			case 'Y': /* Italian */
+#ifdef HAVECSD_ITALIAN
+				ctp = csd_italian;
+#endif
+				break;
+
+			case 'Z': /* Spanish */
+#ifdef HAVECSD_SPANISH
+				ctp = csd_spanish;
+#endif
+				break;
+
+			case '0': /* special graphics */
+#ifdef HAVECSD_SPECIAL
+				ctp = csd_special;
+#endif
+				break;
+
+			case '1': /* alternate ROM */
+#ifdef HAVECSD_ALTERNATEROM1
+				ctp = csd_alternaterom1;
+#endif
+				break;
+
+			case '2': /* alt ROM, spec graphics */
+#ifdef HAVECSD_ALTERNATEROM2
+				ctp = csd_alternaterom2;
+#endif
+				break;
+
+			case '3': /* HP Roman 8, upper 128 chars*/
+#ifdef HAVECSD_ROMAN8
+				ctp = csd_roman8;
+#endif
+				break;
+
+			case '4': /* Dutch */
+#ifdef HAVECSD_DUTCH
+				ctp = csd_dutch;
+#endif
+				break;
+
+			case '<': /* DEC Supplemental */
+#ifdef HAVECSD_SUPPLEMENTAL
+				ctp = csd_supplemental;
+#endif
+				break;
+
+			case '=': /* Swiss */
+#ifdef HAVECSD_SWISS
+				ctp = csd_swiss;
+#endif
+				break;
+
+			case '>': /* DEC Technical */
+#ifdef HAVECSD_TECHNICAL
+				ctp = csd_technical;
+#endif
+				break;
+
+			default:
+				break;
+		}
+	}
+	swcsp(svsp, ctp);
+}
+
+/*---------------------------------------------------------------------------*
+ *	device attributes
+ *---------------------------------------------------------------------------*/
+void
+vt_da(struct video_state *svsp)
+{
+	static u_char *response = (u_char *)DA_VT220;
+
+	svsp->report_chars = response;
+	svsp->report_count = 18;
+	respond(svsp);
+}
+
+/*---------------------------------------------------------------------------*
+ *	screen alignment display
+ *---------------------------------------------------------------------------*/
+void
+vt_aln(struct video_state *svsp)
+{
+	register int i;
+
+	svsp->cur_offset = 0;
+	svsp->col = 0;
+
+	for(i=0; i < (svsp->screen_rows*svsp->maxcol); i++)
+	{
+		*(svsp->Crtat + svsp->cur_offset) = user_attr | 'E';
+		vt_selattr(svsp);
+		svsp->cur_offset++;
+		svsp->col++;
+	}
+
+	svsp->cur_offset = 0;	/* reset everything ! */
+	svsp->col = 0;
+	svsp->row = 0;
+}
+
+/*---------------------------------------------------------------------------*
+ *	request terminal parameters
+ *---------------------------------------------------------------------------*/
+void
+vt_reqtparm(struct video_state *svsp)
+{
+	static u_char *answr = (u_char *)"\033[3;1;1;120;120;1;0x";
+
+	svsp->report_chars = answr;
+	svsp->report_count = 20;
+	respond(svsp);
+}
+
+/*---------------------------------------------------------------------------*
+ *	invoke selftest
+ *---------------------------------------------------------------------------*/
+void
+vt_tst(struct video_state *svsp)
+{
+	clear_dld(svsp);
+}
+
+/*---------------------------------------------------------------------------*
+ *	device status reports
+ *---------------------------------------------------------------------------*/
+void
+vt_dsr(struct video_state *svsp)
+{
+	static u_char *answr = (u_char *)"\033[0n";
+	static u_char *panswr = (u_char *)"\033[?13n"; /* Printer Unattached */
+	static u_char *udkanswr = (u_char *)"\033[?21n"; /* UDK Locked */
+	static u_char *langanswr = (u_char *)"\033[?27;1n"; /* North American*/
+	static u_char buffer[16];
+	int i = 0;
+
+	switch(svsp->parms[0])
+	{
+		case 5:		/* return status */
+			svsp->report_chars = answr;
+			svsp->report_count = 4;
+			respond(svsp);
+			break;
+
+		case 6:		/* return cursor position */
+			buffer[i++] = 0x1b;
+			buffer[i++] = '[';
+			if((svsp->row+1) > 10)
+				buffer[i++] = ((svsp->row+1) / 10) + '0';
+			buffer[i++] = ((svsp->row+1) % 10) + '0';
+			buffer[i++] = ';';
+			if((svsp->col+1) > 10)
+				buffer[i++] = ((svsp->col+1) / 10) + '0';
+			buffer[i++] = ((svsp->col+1) % 10) + '0';
+			buffer[i++] = 'R';
+			buffer[i++] = '\0';
+
+			svsp->report_chars = buffer;
+			svsp->report_count = i;
+			respond(svsp);
+			break;
+
+		case 15:	/* return printer status */
+			svsp->report_chars = panswr;
+			svsp->report_count = 6;
+			respond(svsp);
+			break;
+
+		case 25:	/* return udk status */
+			svsp->report_chars = udkanswr;
+			svsp->report_count = 6;
+			respond(svsp);
+			break;
+
+		case 26:	/* return language status */
+			svsp->report_chars = langanswr;
+			svsp->report_count = 8;
+			respond(svsp);
+			break;
+
+		default:	/* nothing else valid */
+			break;
+	}
+}
+
+/*---------------------------------------------------------------------------*
+ *	IL - insert line
+ *---------------------------------------------------------------------------*/
+void
+vt_il(struct video_state *svsp)
+{
+	register int p = svsp->parms[0];
+
+	if((svsp->row >= svsp->scrr_beg) && (svsp->row <= svsp->scrr_end))
+	{
+		if(p <= 0)
+			p = 1;
+		else if(p > svsp->scrr_end - svsp->row)
+			p = svsp->scrr_end - svsp->row;
+
+		svsp->cur_offset -= svsp->col;
+		svsp->col = 0;
+		if(svsp->row == svsp->scrr_beg)
+			roll_down(svsp, p);
+		else
+		{
+		    bcopy(svsp->Crtat + svsp->cur_offset,
+		          svsp->Crtat + svsp->cur_offset + (p * svsp->maxcol),
+		          svsp->maxcol * (svsp->scrr_end-svsp->row+1-p) * CHR );
+
+		    fillw(user_attr | ' ',
+			  svsp->Crtat + svsp->cur_offset,
+			  p * svsp->maxcol);
+		}
+	}
+}
+
+/*---------------------------------------------------------------------------*
+ *	ICH - insert character
+ *---------------------------------------------------------------------------*/
+void
+vt_ic(struct video_state *svsp)
+{
+	register int p = svsp->parms[0];
+
+	if(p <= 0)
+		p = 1;
+	else if(p > svsp->maxcol-svsp->col)
+		p = svsp->maxcol-svsp->col;
+
+	while(p--)
+	{
+		bcopy((svsp->Crtat + svsp->cur_offset),
+		      (svsp->Crtat + svsp->cur_offset) + 1,
+		      (((svsp->maxcol)-1)-svsp->col) * CHR);
+
+		*(svsp->Crtat + svsp->cur_offset) = user_attr | ' ';
+		vt_selattr(svsp);
+	}
+}
+
+/*---------------------------------------------------------------------------*
+ *	DL - delete line
+ *---------------------------------------------------------------------------*/
+void
+vt_dl(struct video_state *svsp)
+{
+	register int p = svsp->parms[0];
+
+	if((svsp->row >= svsp->scrr_beg) && (svsp->row <= svsp->scrr_end))
+	{
+		if(p <= 0)
+			p = 1;
+		else if(p > svsp->scrr_end - svsp->row)
+			p = svsp->scrr_end - svsp->row;
+
+		svsp->cur_offset -= svsp->col;
+		svsp->col = 0;
+
+		if(svsp->row == svsp->scrr_beg)
+			roll_up(svsp, p);
+		else
+		{
+		    bcopy(svsp->Crtat + svsp->cur_offset + (p * svsp->maxcol),
+			  svsp->Crtat + svsp->cur_offset,
+			  svsp->maxcol * (svsp->scrr_end-svsp->row+1-p) * CHR );
+
+		    fillw(user_attr | ' ',
+			  svsp->Crtat + ((svsp->scrr_end-p+1) * svsp->maxcol),
+			  p * svsp->maxcol);
+		}
+	}
+}
+
+/*---------------------------------------------------------------------------*
+ *	DCH - delete character
+ *---------------------------------------------------------------------------*/
+void
+vt_dch(struct video_state *svsp)
+{
+	register int p = svsp->parms[0];
+
+	if(p <= 0)
+		p = 1;
+	else if(p > svsp->maxcol-svsp->col)
+		p = svsp->maxcol-svsp->col;
+
+	while(p--)
+	{
+		bcopy((svsp->Crtat + svsp->cur_offset)+1,
+		      (svsp->Crtat + svsp->cur_offset),
+		      (((svsp->maxcol)-1) - svsp->col)* CHR );
+
+		*((svsp->Crtat + svsp->cur_offset) +
+			((svsp->maxcol)-1)-svsp->col) = user_attr | ' ';
+	}
+}
+
+/*---------------------------------------------------------------------------*
+ *	scroll up
+ *---------------------------------------------------------------------------*/
+void
+vt_su(struct video_state *svsp)
+{
+	register int p = svsp->parms[0];
+
+	if(p <= 0)
+		p = 1;
+	else if(p > svsp->screen_rows-1)
+		p = svsp->screen_rows-1;
+
+	roll_up(svsp, p);
+}
+
+/*---------------------------------------------------------------------------*
+ *	scroll down
+ *---------------------------------------------------------------------------*/
+void
+vt_sd(struct video_state *svsp)
+{
+	register int p = svsp->parms[0];
+
+	if(p <= 0)
+		p = 1;
+	else if(p > svsp->screen_rows-1)
+		p = svsp->screen_rows-1;
+
+	roll_down(svsp, p);
+}
+
+/*---------------------------------------------------------------------------*
+ *	ECH - erase character
+ *---------------------------------------------------------------------------*/
+void
+vt_ech(struct video_state *svsp)
+{
+	register int p = svsp->parms[0];
+
+	if(p <= 0)
+		p = 1;
+	else if(p > svsp->maxcol-svsp->col)
+		p = svsp->maxcol-svsp->col;
+
+	fillw(user_attr | ' ', (svsp->Crtat + svsp->cur_offset), p);
+}
+
+/*---------------------------------------------------------------------------*
+ *	media copy	(NO PRINTER AVAILABLE IN KERNEL ...)
+ *---------------------------------------------------------------------------*/
+void
+vt_mc(struct video_state *svsp)
+{
+}
+
+/*---------------------------------------------------------------------------*
+ *	Device Control String State Machine Entry for:
+ *
+ *	DECUDK - user-defined keys	and
+ *	DECDLD - downloadable charset
+ *
+ *---------------------------------------------------------------------------*/
+void
+vt_dcsentry(U_char ch, struct video_state *svsp)
+{
+	switch(svsp->dcs_state)
+	{
+		case DCS_INIT:
+			switch(ch)
+			{
+				case '0':
+				case '1':
+				case '2':
+				case '3':
+				case '4':
+				case '5':
+				case '6':
+				case '7':
+				case '8':
+				case '9':	/* parameters */
+					svsp->parms[svsp->parmi] *= 10;
+					svsp->parms[svsp->parmi] += (ch -'0');
+					break;
+
+				case ';':	/* next parameter */
+					svsp->parmi =
+						(svsp->parmi+1 < MAXPARMS) ?
+						svsp->parmi+1 : svsp->parmi;
+					break;
+
+				case '|':	/* DECUDK */
+					svsp->transparent = 1;
+					init_udk(svsp);
+					svsp->dcs_state = DCS_AND_UDK;
+					break;
+
+				case '{':	/* DECDLD */
+					svsp->transparent = 1;
+					init_dld(svsp);
+					svsp->dcs_state = DCS_DLD_DSCS;
+					break;
+
+				default:	 /* failsafe */
+					svsp->transparent = 0;
+					svsp->state = STATE_INIT;
+					svsp->dcs_state = DCS_INIT;
+					break;
+			}
+			break;
+
+		case DCS_AND_UDK:	 /* DCS ... | */
+			switch(ch)
+			{
+				case '0':
+				case '1':
+				case '2':
+				case '3':
+				case '4':
+				case '5':
+				case '6':
+				case '7':
+				case '8':
+				case '9':	/* fkey number */
+					svsp->udk_fnckey *= 10;
+					svsp->udk_fnckey += (ch -'0');
+					break;
+
+				case '/':	/* Key */
+					svsp->dcs_state = DCS_UDK_DEF;
+					break;
+
+				case 0x1b:	 /* ESC */
+					svsp->dcs_state = DCS_UDK_ESC;
+					break;
+
+				default:
+					svsp->transparent = 0;
+					svsp->state = STATE_INIT;
+					svsp->dcs_state = DCS_INIT;
+					break;
+			}
+			break;
+
+		case DCS_UDK_DEF:	 /* DCS ... | fnckey / */
+			switch(ch)
+			{
+				case '0':
+				case '1':
+				case '2':
+				case '3':
+				case '4':
+				case '5':
+				case '6':
+				case '7':
+				case '8':
+				case '9':
+					if(svsp->udk_deflow)	/* low nibble */
+					{
+						svsp->udk_def[svsp->udk_defi] |= (ch -'0');
+						svsp->udk_deflow = 0;
+						svsp->udk_defi = (svsp->udk_defi+1 >= MAXUDKDEF) ?
+						svsp->udk_defi : svsp->udk_defi+1;
+					}
+					else			/* high nibble */
+					{
+						svsp->udk_def[svsp->udk_defi] = ((ch -'0') << 4);
+						svsp->udk_deflow = 1;
+					}
+					break;
+
+				case 'a':
+				case 'b':
+				case 'c':
+				case 'd':
+				case 'e':
+				case 'f':
+					if(svsp->udk_deflow) 	/* low nibble */
+					{
+						svsp->udk_def[svsp->udk_defi] |= (ch - 'a' + 10);
+						svsp->udk_deflow = 0;
+						svsp->udk_defi = (svsp->udk_defi+1 >= MAXUDKDEF) ?
+						svsp->udk_defi : svsp->udk_defi+1;
+					}
+					else			/* high nibble */
+					{
+						svsp->udk_def[svsp->udk_defi] = ((ch - 'a' + 10) << 4);
+						svsp->udk_deflow = 1;
+					}
+					break;
+
+
+
+				case 'A':
+				case 'B':
+				case 'C':
+				case 'D':
+				case 'E':
+				case 'F':
+					if(svsp->udk_deflow) 	/* low nibble */
+					{
+						svsp->udk_def[svsp->udk_defi] |= (ch - 'A' + 10);
+						svsp->udk_deflow = 0;
+						svsp->udk_defi = (svsp->udk_defi+1 >= MAXUDKDEF) ?
+						svsp->udk_defi : svsp->udk_defi+1;
+					}
+					else			/* high nibble */
+					{
+						svsp->udk_def[svsp->udk_defi] = ((ch - 'A' + 10) << 4);
+						svsp->udk_deflow = 1;
+					}
+					break;
+
+				case ';':	/* next function key */
+					vt_udk(svsp);
+					svsp->dcs_state = DCS_AND_UDK;
+					break;
+
+				case 0x1b:	 /* ESC */
+					svsp->dcs_state = DCS_UDK_ESC;
+					break;
+
+				default:
+					svsp->transparent = 0;
+					svsp->state = STATE_INIT;
+					svsp->dcs_state = DCS_INIT;
+					break;
+			}
+			break;
+
+		case DCS_UDK_ESC:	 /* DCS ... | fkey/def ... ESC */
+			switch(ch)
+			{
+				case '\\':	/* ST */
+					vt_udk(svsp);
+					svsp->transparent = 0;
+					svsp->state = STATE_INIT;
+					svsp->dcs_state = DCS_INIT;
+					break;
+
+				default:
+					svsp->transparent = 0;
+					svsp->state = STATE_INIT;
+					svsp->dcs_state = DCS_INIT;
+					break;
+			}
+			break;
+
+
+		case DCS_DLD_DSCS:	 /* got DCS ... { */
+			if(ch >= ' ' && ch <= '/')	/* intermediates ... */
+			{
+				svsp->dld_dscs[svsp->dld_dscsi] = ch;
+				svsp->dld_id[svsp->dld_dscsi] = ch;
+				if(svsp->dld_dscsi >= DSCS_LENGTH)
+				{
+					svsp->transparent = 0;
+					svsp->state = STATE_INIT;
+					svsp->dcs_state = DCS_INIT;
+					svsp->dld_id[0] = '\0';
+				}
+				else
+				{
+					svsp->dld_dscsi++;
+				}
+			}
+			else if(ch >= '0' && ch <= '~')	/* final .... */
+			{
+				svsp->dld_dscs[svsp->dld_dscsi] = ch;
+				svsp->dld_id[svsp->dld_dscsi++] = ch;
+				svsp->dld_id[svsp->dld_dscsi] = '\0';
+				svsp->dcs_state = DCS_DLD_DEF;
+			}
+			else
+			{
+				svsp->transparent = 0;
+				svsp->state = STATE_INIT;
+				svsp->dcs_state = DCS_INIT;
+				svsp->dld_id[0] = '\0';
+			}
+			break;
+
+		case DCS_DLD_DEF:	 /* DCS ... { dscs */
+			switch(ch)
+			{
+				case 0x1b:	 /* ESC */
+					svsp->dcs_state = DCS_DLD_ESC;
+					break;
+
+				case '/':	 /* sixel upper / lower divider */
+					svsp->dld_sixel_lower = 1;
+					break;
+
+				case ';':	 /* character divider */
+					vt_dld(svsp);
+					svsp->parms[1]++;	/* next char */
+					break;
+
+ 				default:
+					if (svsp->dld_sixel_lower)
+					{
+						if(ch >= '?' && ch <= '~')
+							svsp->sixel.lower[svsp->dld_sixelli] = ch - '?';
+						svsp->dld_sixelli =
+						 (svsp->dld_sixelli+1 < MAXSIXEL) ?
+						 svsp->dld_sixelli+1 : svsp->dld_sixelli;
+					}
+					else
+					{
+						if(ch >= '?' && ch <= '~')
+							svsp->sixel.upper[svsp->dld_sixelui] = ch - '?';
+						svsp->dld_sixelui =
+						 (svsp->dld_sixelui+1 < MAXSIXEL) ?
+						 svsp->dld_sixelui+1 : svsp->dld_sixelui;
+					}
+					break;
+			}
+			break;
+
+		case DCS_DLD_ESC:	 /* DCS ... { dscs ... / ... ESC */
+			switch(ch)
+			{
+				case '\\':	/* String Terminator ST */
+					vt_dld(svsp);
+					svsp->transparent = 0;
+					svsp->state = STATE_INIT;
+					svsp->dcs_state = DCS_INIT;
+					break;
+
+ 				default:
+					svsp->transparent = 0;
+					svsp->state = STATE_INIT;
+					svsp->dcs_state = DCS_INIT;
+					svsp->dld_id[0] = '\0';
+					break;
+			}
+			break;
+
+		default:
+			svsp->transparent = 0;
+			svsp->state = STATE_INIT;
+			svsp->dcs_state = DCS_INIT;
+			break;
+	}
+}
+
+/*---------------------------------------------------------------------------*
+ *	User Defineable Keys
+ *---------------------------------------------------------------------------*/
+void
+vt_udk(struct video_state *svsp)
+{
+	int key, start, max, i;
+	int usedff = 0;
+
+	if(svsp->parms[0] != 1)		/* clear all ? */
+	{
+		vt_clearudk(svsp);
+		svsp->parms[0] = 1;
+	}
+
+	if(svsp->udk_fnckey < 17 || svsp->udk_fnckey > 34)
+	{
+		init_udk(svsp);
+		return;
+	}
+
+	key = svsp->udk_fnckey - 17;	/* index into table */
+
+	if(svsp->ukt.length[key] == 0)			/* never used ? */
+	{
+		if(svsp->udkff < MAXUDKDEF-2)		/* space available ? */
+		{
+			start = svsp->udkff;		/* next sequential */
+			max = MAXUDKDEF - svsp->udkff;	/* space available */
+			svsp->ukt.first[key] = start;	/* start entry */
+			usedff = 1;			/* flag to update later */
+		}
+		else					/* no space */
+		{
+			init_udk(svsp);
+			return;
+		}
+	}
+	else						/* in use, redefine */
+	{
+		start = svsp->ukt.first[key];		/* start entry */
+		max = svsp->ukt.length[key];		/* space available */
+	}
+
+	if(max < 2)				/* hmmm .. */
+	{
+		init_udk(svsp);
+		return;
+	}
+
+	max--;		/* adjust for tailing '\0' */
+
+	for(i = 0; i < max && i < svsp->udk_defi; i++)
+		svsp->udkbuf[start++] = svsp->udk_def[i];
+
+	svsp->udkbuf[start] = '\0';	/* make it a string, see pcvt_kbd.c */
+	svsp->ukt.length[key] = i+1;	/* count for tailing '\0' */
+	if(usedff)
+		svsp->udkff += (i+2);	/* new start location */
+
+	init_udk(svsp);
+}
+
+/*---------------------------------------------------------------------------*
+ *	clear all User Defineable Keys
+ *---------------------------------------------------------------------------*/
+void
+vt_clearudk(struct video_state *svsp)
+{
+	register int i;
+
+	for(i = 0; i < MAXUDKEYS; i++)
+	{
+		svsp->ukt.first[i] = 0;
+		svsp->ukt.length[i] = 0;
+	}
+	svsp->udkff = 0;
+}
+
+/*---------------------------------------------------------------------------*
+ *	Down line LoaDable Fonts
+ *---------------------------------------------------------------------------*/
+void
+vt_dld(struct video_state *svsp)
+{
+	unsigned char vgacharset;
+	unsigned char vgachar[16];
+	unsigned char vgacharb[16];
+
+	if(vgacs[svsp->vga_charset].secondloaded)
+		vgacharset = vgacs[svsp->vga_charset].secondloaded;
+	else
+		return;
+
+	svsp->parms[1] = (svsp->parms[1] < 1) ? 1 :
+		((svsp->parms[1] > 0x7E) ? 0x7E : svsp->parms[1]);
+
+	if(svsp->parms[2] != 1)   /* Erase all characters ? */
+	{
+		clear_dld(svsp);
+		svsp->parms[2] = 1;   /* Only erase all characters once per sequence */
+	}
+
+	sixel_vga(&(svsp->sixel),vgachar);
+
+	switch(vgacs[vgacharset].char_scanlines & 0x1F)
+	{
+		case 7:
+			vga10_vga8(vgachar,vgacharb);
+			break;
+
+		case 9:
+		default:
+			vga10_vga10(vgachar,vgacharb);
+			break;
+
+		case 13:
+			vga10_vga14(vgachar,vgacharb);
+			break;
+
+		case 15:
+			vga10_vga16(vgachar,vgacharb);
+			break;
+	}
+
+	loadchar(vgacharset, svsp->parms[1] + 0xA0, 16, vgacharb);
+
+	init_dld(svsp);
+}
+
+/*---------------------------------------------------------------------------*
+ *	select character attributes
+ *---------------------------------------------------------------------------*/
+void
+vt_sca(struct video_state *svsp)
+{
+	switch(svsp->parms[0])
+	{
+		case 1:
+			svsp->selchar = 1;
+			break;
+		case 0:
+		case 2:
+		default:
+			svsp->selchar = 0;
+			break;
+	}
+}
+
+/*---------------------------------------------------------------------------*
+ *	initalize selective attribute bit array
+ *---------------------------------------------------------------------------*/
+void
+vt_initsel(struct video_state *svsp)
+{
+	register int i;
+
+	for(i = 0;i < MAXDECSCA;i++)
+		svsp->decsca[i] = 0;
+}
+
+/*---------------------------------------------------------------------------*
+ *	DECSEL - selective erase in line
+ *---------------------------------------------------------------------------*/
+void
+vt_sel(struct video_state *svsp)
+{
+	switch(svsp->parms[0])
+	{
+		case 0:
+			selective_erase(svsp, (svsp->Crtat + svsp->cur_offset),
+					 svsp->maxcol-svsp->col);
+			break;
+
+		case 1:
+			selective_erase(svsp, (svsp->Crtat + svsp->cur_offset)-
+					svsp->col, svsp->col + 1);
+			break;
+
+		case 2:
+			selective_erase(svsp, (svsp->Crtat + svsp->cur_offset)-
+					svsp->col, svsp->maxcol);
+			break;
+	}
+}
+
+/*---------------------------------------------------------------------------*
+ *	DECSED - selective erase in display
+ *---------------------------------------------------------------------------*/
+void
+vt_sed(struct video_state *svsp)
+{
+	switch(svsp->parms[0])
+	{
+		case 0:
+			selective_erase(svsp, (svsp->Crtat + svsp->cur_offset),
+			      svsp->Crtat + (svsp->maxcol * svsp->screen_rows) -
+			      (svsp->Crtat + svsp->cur_offset));
+			break;
+
+		case 1:
+			selective_erase(svsp, svsp->Crtat,
+			   (svsp->Crtat + svsp->cur_offset) - svsp->Crtat + 1 );
+			break;
+
+		case 2:
+			selective_erase(svsp, svsp->Crtat,
+				svsp->maxcol * svsp->screen_rows);
+			break;
+	}
+}
+
+/*---------------------------------------------------------------------------*
+ *	scroll screen n lines up
+ *---------------------------------------------------------------------------*/
+void
+roll_up(struct video_state *svsp, int n)
+{
+
+#if (PCVT_NOFASTSCROLL==0)
+
+	if(svsp->scrr_beg == 0 &&	/* if scroll region is whole screen */
+           svsp->scrr_len == svsp->screen_rows &&
+	   (svsp != vsp ||		/* and either running in memory */
+	    (svsp->screen_rows == svsp->screen_rowsize && /* or no fkeys */
+	     adaptor_type != MDA_ADAPTOR)))	/* and not on MDA/Hercules */
+	{
+		u_short *Memory =
+
+#if PCVT_USL_VT_COMPAT
+		    (vsp != svsp || (vsp->vt_status & VT_GRAFX)) ?
+#else
+		    (vsp != svsp) ?
+#endif
+
+				svsp->Memory : Crtat;
+
+		if(svsp->Crtat > (Memory + (svsp->screen_rows - n) *
+					svsp->maxcol))
+		{
+			bcopy(svsp->Crtat + svsp->maxcol * n, Memory,
+		       	      svsp->maxcol * (svsp->screen_rows - n) * CHR);
+
+			svsp->Crtat = Memory;
+		}
+		else
+		{
+			svsp->Crtat += n * svsp->maxcol;
+		}
+
+#if PCVT_USL_VT_COMPAT
+		if(vsp == svsp && !(vsp->vt_status & VT_GRAFX))
+#else
+		if(vsp == svsp)
+#endif
+
+		{
+			outb(addr_6845, CRTC_STARTADRH);
+			outb(addr_6845+1, (svsp->Crtat - Crtat) >> 8);
+			outb(addr_6845, CRTC_STARTADRL);
+			outb(addr_6845+1, (svsp->Crtat - Crtat));
+		}
+	}
+	else
+#endif
+	{
+		bcopy(	svsp->Crtat + ((svsp->scrr_beg + n) * svsp->maxcol),
+			svsp->Crtat + (svsp->scrr_beg * svsp->maxcol),
+			svsp->maxcol * (svsp->scrr_len - n) * CHR );
+	}
+
+	fillw(	user_attr | ' ',
+		svsp->Crtat + ((svsp->scrr_end - n + 1) * svsp->maxcol),
+		n * svsp->maxcol);
+
+/*XXX*/	if(svsp->scroll_lock && svsp->openf && curproc)
+		tsleep((caddr_t)&(svsp->scroll_lock), PPAUSE, "scrlck", 0);
+}
+
+/*---------------------------------------------------------------------------*
+ *	scroll screen n lines down
+ *---------------------------------------------------------------------------*/
+static void
+roll_down(struct video_state *svsp, int n)
+{
+
+#if (PCVT_NOFASTSCROLL==0)
+
+	if(svsp->scrr_beg == 0 &&	/* if scroll region is whole screen */
+           svsp->scrr_len == svsp->screen_rows &&
+	   (svsp != vsp ||		/* and either running in memory */
+	    (svsp->screen_rows == svsp->screen_rowsize && /* or no fkeys */
+	     adaptor_type != MDA_ADAPTOR)))	/* and not on MDA/Hercules */
+	{
+		u_short *Memory =
+
+#if PCVT_USL_VT_COMPAT
+		    (vsp != svsp || (vsp->vt_status & VT_GRAFX)) ?
+#else
+		    (vsp != svsp) ?
+#endif
+				svsp->Memory : Crtat;
+
+		if (svsp->Crtat < (Memory + n * svsp->maxcol))
+		{
+			bcopy(svsp->Crtat,
+			      Memory + svsp->maxcol * (svsp->screen_rows + n),
+		       	      svsp->maxcol * (svsp->screen_rows - n) * CHR);
+
+			svsp->Crtat = Memory + svsp->maxcol * svsp->screen_rows;
+		}
+		else
+		{
+			svsp->Crtat -= n * svsp->maxcol;
+		}
+
+#if PCVT_USL_VT_COMPAT
+		if(vsp == svsp && !(vsp->vt_status & VT_GRAFX))
+#else
+		if(vsp == svsp)
+#endif
+
+		{
+			outb(addr_6845, CRTC_STARTADRH);
+			outb(addr_6845+1, (svsp->Crtat - Crtat) >> 8);
+			outb(addr_6845, CRTC_STARTADRL);
+			outb(addr_6845+1, (svsp->Crtat - Crtat));
+		}
+	}
+	else
+#endif
+	{
+		bcopy(  svsp->Crtat + (svsp->scrr_beg * svsp->maxcol),
+			svsp->Crtat + ((svsp->scrr_beg + n) * svsp->maxcol),
+			svsp->maxcol * (svsp->scrr_len - n) * CHR );
+	}
+
+	fillw(	user_attr | ' ',
+		svsp->Crtat + (svsp->scrr_beg * svsp->maxcol),
+		n * svsp->maxcol);
+
+/*XXX*/	if(svsp->scroll_lock && svsp->openf && curproc)
+		tsleep((caddr_t)&(svsp->scroll_lock), PPAUSE, "scrlck", 0);
+}
+
+/*---------------------------------------------------------------------------*
+ *	switch charset pointers
+ *---------------------------------------------------------------------------*/
+static void
+swcsp(struct video_state *svsp, u_short *ctp)
+{
+	if(ctp == NULL)
+		return;
+
+	switch(svsp->state)
+	{
+		case STATE_BROPN:	/* designate G0 */
+			svsp->G0 = ctp;
+			break;
+
+		case STATE_BRCLO:	/* designate G1 */
+		case STATE_MINUS:	/* designate G1 (96) */
+			svsp->G1 = ctp;
+			break;
+
+		case STATE_STAR:	/* designate G2 */
+		case STATE_DOT:		/* designate G2 (96) */
+			svsp->G2 = ctp;
+			break;
+
+		case STATE_PLUS:	/* designate G3 */
+		case STATE_SLASH:	/* designate G3 (96) */
+			svsp->G3 = ctp;
+			break;
+	}
+}
+
+/*---------------------------------------------------------------------------*
+ *	process terminal responses
+ *---------------------------------------------------------------------------*/
+static void
+respond(struct video_state *svsp)
+{
+        if(!(svsp->openf))              /* are we opened ? */
+                return;
+
+        while (*svsp->report_chars && svsp->report_count > 0)
+        {
+		(*linesw[svsp->vs_tty->t_line].l_rint)
+			(*svsp->report_chars++ & 0xff, svsp->vs_tty);
+		svsp->report_count--;
+        }
+}
+
+/*---------------------------------------------------------------------------*
+ *	Initialization for User Defineable Keys
+ *---------------------------------------------------------------------------*/
+static void
+init_udk(struct video_state *svsp)
+{
+	svsp->udk_defi = 0;
+	svsp->udk_deflow = 0;
+	svsp->udk_fnckey = 0;
+}
+
+/*---------------------------------------------------------------------------*
+ *	Clear loaded downloadable (DLD) character set
+ *---------------------------------------------------------------------------*/
+static void
+clear_dld(struct video_state *svsp)
+{
+	register int i;
+	unsigned char vgacharset;
+	unsigned char vgachar[16];
+
+	if(vgacs[svsp->vga_charset].secondloaded)
+		vgacharset = vgacs[svsp->vga_charset].secondloaded;
+	else
+		return;
+
+	for(i=0;i < 16;i++)  /* A zeroed character, vt220 has inverted '?' */
+		vgachar[i] = 0x00;
+
+	for(i=1;i <= 94;i++) /* Load (erase) all characters */
+		loadchar(vgacharset, i + 0xA0, 16, vgachar);
+}
+
+/*---------------------------------------------------------------------------*
+ *	Initialization for Down line LoaDable Fonts
+ *---------------------------------------------------------------------------*/
+static void
+init_dld(struct video_state *svsp)
+{
+	register int i;
+
+	svsp->dld_dscsi = 0;
+	svsp->dld_sixel_lower = 0;
+	svsp->dld_sixelli = 0;
+	svsp->dld_sixelui = 0;
+
+	for(i = 0;i < MAXSIXEL;i++)
+		svsp->sixel.lower[i] = svsp->sixel.upper[i] = 0;
+}
+
+/*---------------------------------------------------------------------------*
+ *	selective erase a region
+ *---------------------------------------------------------------------------*/
+static void
+selective_erase(struct video_state *svsp, u_short *pcrtat, int length)
+{
+	register int i, j;
+
+	for(j = pcrtat - svsp->Crtat, i = 0;i < length;i++,pcrtat++)
+	{
+		if(!(svsp->decsca[INT_INDEX(j+i)] & (1 << BIT_INDEX(j+i))))
+		{
+			*pcrtat &= 0xFF00; /* Keep the video character attributes */
+			*pcrtat += ' ';	   /* Erase the character */
+		}
+	}
+}
+
+#endif	/* NVT > 0 */
+
+/* ------------------------- E O F ------------------------------------------*/
+