265bc2e92c
wsemul_vt100_subr.c) to be used by alternative terminal emulators (which are not in-tree yet but can be loaded as LKMs). For this, split out that part of the state structure which is used by the sharable code and include that in the original vt100 state. This is only a query-replace and sed(1) job for now, it makes sense to rearrange things a bit so that even more code can be changed -- will do so later.
862 lines
22 KiB
C
862 lines
22 KiB
C
/* $NetBSD: wsemul_vt100_subr.c,v 1.20 2010/02/10 19:39:39 drochner 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.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 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.20 2010/02/10 19:39:39 drochner 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>
|
|
|
|
#include "opt_wsemul.h"
|
|
|
|
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)
|
|
{
|
|
int help;
|
|
|
|
if (n > edp->scrreg_nrows)
|
|
n = edp->scrreg_nrows;
|
|
|
|
help = edp->scrreg_nrows - n;
|
|
if (help > 0) {
|
|
(*edp->emulops->copyrows)(edp->emulcookie,
|
|
edp->scrreg_startrow + n,
|
|
edp->scrreg_startrow,
|
|
help);
|
|
if (edp->dblwid)
|
|
memmove(&edp->dblwid[edp->scrreg_startrow],
|
|
&edp->dblwid[edp->scrreg_startrow + n],
|
|
help);
|
|
}
|
|
(*edp->emulops->eraserows)(edp->emulcookie,
|
|
edp->scrreg_startrow + help, n,
|
|
edp->bkgdattr);
|
|
if (edp->dblwid)
|
|
memset(&edp->dblwid[edp->scrreg_startrow + help], 0, n);
|
|
CHECK_DW(edp);
|
|
}
|
|
|
|
/*
|
|
* scroll down within scrolling region
|
|
*/
|
|
void
|
|
wsemul_vt100_scrolldown(struct vt100base_data *edp, int n)
|
|
{
|
|
int help;
|
|
|
|
if (n > edp->scrreg_nrows)
|
|
n = edp->scrreg_nrows;
|
|
|
|
help = edp->scrreg_nrows - n;
|
|
if (help > 0) {
|
|
(*edp->emulops->copyrows)(edp->emulcookie,
|
|
edp->scrreg_startrow,
|
|
edp->scrreg_startrow + n,
|
|
help);
|
|
if (edp->dblwid)
|
|
memmove(&edp->dblwid[edp->scrreg_startrow + n],
|
|
&edp->dblwid[edp->scrreg_startrow],
|
|
help);
|
|
}
|
|
(*edp->emulops->eraserows)(edp->emulcookie,
|
|
edp->scrreg_startrow, n,
|
|
edp->bkgdattr);
|
|
if (edp->dblwid)
|
|
memset(&edp->dblwid[edp->scrreg_startrow], 0, n);
|
|
CHECK_DW(edp);
|
|
}
|
|
|
|
/*
|
|
* erase in display
|
|
*/
|
|
void
|
|
wsemul_vt100_ed(struct vt100base_data *edp, int arg)
|
|
{
|
|
int n;
|
|
|
|
switch (arg) {
|
|
case 0: /* cursor to end */
|
|
ERASECOLS(edp, edp->ccol, COLS_LEFT(edp) + 1, edp->bkgdattr);
|
|
n = edp->nrows - edp->crow - 1;
|
|
if (n > 0) {
|
|
(*edp->emulops->eraserows)(edp->emulcookie,
|
|
edp->crow + 1, n,
|
|
edp->bkgdattr);
|
|
if (edp->dblwid)
|
|
memset(&edp->dblwid[edp->crow + 1], 0, n);
|
|
}
|
|
break;
|
|
case 1: /* beginning to cursor */
|
|
if (edp->crow > 0) {
|
|
(*edp->emulops->eraserows)(edp->emulcookie,
|
|
0, edp->crow,
|
|
edp->bkgdattr);
|
|
if (edp->dblwid)
|
|
memset(&edp->dblwid[0], 0, edp->crow);
|
|
}
|
|
ERASECOLS(edp, 0, edp->ccol + 1, edp->bkgdattr);
|
|
break;
|
|
case 2: /* complete display */
|
|
(*edp->emulops->eraserows)(edp->emulcookie,
|
|
0, edp->nrows,
|
|
edp->bkgdattr);
|
|
if (edp->dblwid)
|
|
memset(&edp->dblwid[0], 0, edp->nrows);
|
|
break;
|
|
default:
|
|
#ifdef VT100_PRINTUNKNOWN
|
|
printf("ed(%d) unknown\n", arg);
|
|
#endif
|
|
break;
|
|
}
|
|
CHECK_DW(edp);
|
|
}
|
|
|
|
/*
|
|
* erase in line
|
|
*/
|
|
void
|
|
wsemul_vt100_el(struct vt100base_data *edp, int arg)
|
|
{
|
|
switch (arg) {
|
|
case 0: /* cursor to end */
|
|
ERASECOLS(edp, edp->ccol, COLS_LEFT(edp) + 1, edp->bkgdattr);
|
|
break;
|
|
case 1: /* beginning to cursor */
|
|
ERASECOLS(edp, 0, edp->ccol + 1, edp->bkgdattr);
|
|
break;
|
|
case 2: /* complete line */
|
|
(*edp->emulops->erasecols)(edp->emulcookie, edp->crow,
|
|
0, edp->ncols,
|
|
edp->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)
|
|
{
|
|
int n, help, flags, fgcol, bgcol;
|
|
long attr, bkgdattr;
|
|
|
|
#define A3(a, b, c) (((a) << 16) | ((b) << 8) | (c))
|
|
switch (A3(edp->modif1, edp->modif2, c)) {
|
|
case A3('>', '\0', 'c'): /* DA secondary */
|
|
wsdisplay_emulinput(edp->cbcookie, WSEMUL_VT_ID2,
|
|
sizeof(WSEMUL_VT_ID2));
|
|
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));
|
|
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));
|
|
break;
|
|
case A3('\0', '\0', 'h'): /* SM */
|
|
for (n = 0; n < edp->nargs; n++)
|
|
vt100_ansimode(edp, ARG(edp, n), VTMODE_SET);
|
|
break;
|
|
case A3('?', '\0', 'h'): /* DECSM */
|
|
for (n = 0; n < edp->nargs; n++)
|
|
vt100_decmode(edp, ARG(edp, n), VTMODE_SET);
|
|
break;
|
|
case A3('\0', '\0', 'l'): /* RM */
|
|
for (n = 0; n < edp->nargs; n++)
|
|
vt100_ansimode(edp, ARG(edp, n), VTMODE_RESET);
|
|
break;
|
|
case A3('?', '\0', 'l'): /* DECRM */
|
|
for (n = 0; n < edp->nargs; n++)
|
|
vt100_decmode(edp, ARG(edp, n), VTMODE_RESET);
|
|
break;
|
|
case A3('\0', '$', 'p'): /* DECRQM request mode ANSI */
|
|
vt100_ansimode(edp, ARG(edp, 0), VTMODE_REPORT);
|
|
break;
|
|
case A3('?', '$', 'p'): /* DECRQM request mode DEC */
|
|
vt100_decmode(edp, ARG(edp, 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)) {
|
|
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));
|
|
#endif
|
|
break;
|
|
default:
|
|
#ifdef VT100_PRINTUNKNOWN
|
|
printf("CSI%di unknown\n", ARG(edp, 0));
|
|
#endif
|
|
break;
|
|
}
|
|
break;
|
|
|
|
#define A2(a, b) (((a) << 8) | (b))
|
|
#if 0 /* XXX */
|
|
case A2('!', 'p'): /* DECSTR soft reset VT300 only */
|
|
wsemul_vt100_reset(edp);
|
|
break;
|
|
#endif
|
|
|
|
case A2('"', 'p'): /* DECSCL */
|
|
switch (ARG(edp, 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));
|
|
#endif
|
|
break;
|
|
}
|
|
switch (ARG(edp, 1)) {
|
|
case 0:
|
|
case 2: /* 8-bit controls */
|
|
#ifdef VT100_PRINTNOTIMPL
|
|
printf("CSI%d;%d\"p ignored\n", ARG(edp, 0), ARG(edp, 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));
|
|
#endif
|
|
break;
|
|
}
|
|
break;
|
|
case A2('"', 'q'): /* DECSCA select character attribute VT300 */
|
|
switch (ARG(edp, 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));
|
|
#endif
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case A2('$', 'u'): /* DECRQTSR request terminal status report */
|
|
switch (ARG(edp, 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));
|
|
#endif
|
|
break;
|
|
}
|
|
break;
|
|
case A2('$', 'w'): /* DECRQPSR request presentation status report
|
|
(VT300 only) */
|
|
switch (ARG(edp, 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);
|
|
wsdisplay_emulinput(edp->cbcookie, "\033P2$u", 5);
|
|
for (i = 0; i < edp->ncols; i++)
|
|
if (edp->tabs[i]) {
|
|
j = snprintf(buf, sizeof(buf), "%s%d",
|
|
(ps ? "/" : ""), i + 1);
|
|
wsdisplay_emulinput(edp->cbcookie,
|
|
buf, j);
|
|
ps = 1;
|
|
}
|
|
}
|
|
wsdisplay_emulinput(edp->cbcookie, "\033\\", 2);
|
|
break;
|
|
default:
|
|
#ifdef VT100_PRINTUNKNOWN
|
|
printf("CSI%d$w unknown\n", ARG(edp, 0));
|
|
#endif
|
|
break;
|
|
}
|
|
break;
|
|
case A2('$', '}'): /* DECSASD select active status display */
|
|
switch (ARG(edp, 0)) {
|
|
case 0: /* main display */
|
|
case 1: /* status line */
|
|
#ifdef VT100_PRINTNOTIMPL
|
|
printf("CSI%d$} ignored\n", ARG(edp, 0));
|
|
#endif
|
|
break;
|
|
default:
|
|
#ifdef VT100_PRINTUNKNOWN
|
|
printf("CSI%d$} unknown\n", ARG(edp, 0));
|
|
#endif
|
|
break;
|
|
}
|
|
break;
|
|
case A2('$', '~'): /* DECSSDD select status line type */
|
|
switch (ARG(edp, 0)) {
|
|
case 0: /* none */
|
|
case 1: /* indicator */
|
|
case 2: /* host-writable */
|
|
#ifdef VT100_PRINTNOTIMPL
|
|
printf("CSI%d$~ ignored\n", ARG(edp, 0));
|
|
#endif
|
|
break;
|
|
default:
|
|
#ifdef VT100_PRINTUNKNOWN
|
|
printf("CSI%d$~ unknown\n", ARG(edp, 0));
|
|
#endif
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case A2('&', 'u'): /* DECRQUPSS request user preferred
|
|
supplemental set */
|
|
wsdisplay_emulinput(edp->cbcookie, "\033P0!u%5\033\\", 9);
|
|
break;
|
|
|
|
case '@': /* ICH insert character VT300 only */
|
|
n = min(DEF1_ARG(edp, 0), COLS_LEFT(edp) + 1);
|
|
help = NCOLS(edp) - (edp->ccol + n);
|
|
if (help > 0)
|
|
COPYCOLS(edp, edp->ccol, edp->ccol + n, help);
|
|
ERASECOLS(edp, edp->ccol, n, edp->bkgdattr);
|
|
break;
|
|
case 'A': /* CUU */
|
|
edp->crow -= min(DEF1_ARG(edp, 0), ROWS_ABOVE(edp));
|
|
CHECK_DW(edp);
|
|
break;
|
|
case 'B': /* CUD */
|
|
edp->crow += min(DEF1_ARG(edp, 0), ROWS_BELOW(edp));
|
|
CHECK_DW(edp);
|
|
break;
|
|
case 'C': /* CUF */
|
|
edp->ccol += min(DEF1_ARG(edp, 0), COLS_LEFT(edp));
|
|
break;
|
|
case 'D': /* CUB */
|
|
edp->ccol -= min(DEF1_ARG(edp, 0), edp->ccol);
|
|
edp->flags &= ~VTFL_LASTCHAR;
|
|
break;
|
|
case 'H': /* CUP */
|
|
case 'f': /* HVP */
|
|
if (edp->flags & VTFL_DECOM)
|
|
edp->crow = edp->scrreg_startrow +
|
|
min(DEF1_ARG(edp, 0), edp->scrreg_nrows) - 1;
|
|
else
|
|
edp->crow = min(DEF1_ARG(edp, 0), edp->nrows) - 1;
|
|
CHECK_DW(edp);
|
|
edp->ccol = min(DEF1_ARG(edp, 1), NCOLS(edp)) - 1;
|
|
edp->flags &= ~VTFL_LASTCHAR;
|
|
break;
|
|
case 'L': /* IL insert line */
|
|
case 'M': /* DL delete line */
|
|
n = min(DEF1_ARG(edp, 0), ROWS_BELOW(edp) + 1);
|
|
{
|
|
int savscrstartrow, savscrnrows;
|
|
savscrstartrow = edp->scrreg_startrow;
|
|
savscrnrows = edp->scrreg_nrows;
|
|
edp->scrreg_nrows -= ROWS_ABOVE(edp);
|
|
edp->scrreg_startrow = edp->crow;
|
|
if (c == 'L')
|
|
wsemul_vt100_scrolldown(edp, n);
|
|
else
|
|
wsemul_vt100_scrollup(edp, n);
|
|
edp->scrreg_startrow = savscrstartrow;
|
|
edp->scrreg_nrows = savscrnrows;
|
|
}
|
|
break;
|
|
case 'P': /* DCH delete character */
|
|
n = min(DEF1_ARG(edp, 0), COLS_LEFT(edp) + 1);
|
|
help = NCOLS(edp) - (edp->ccol + n);
|
|
if (help > 0)
|
|
COPYCOLS(edp, edp->ccol + n, edp->ccol, help);
|
|
ERASECOLS(edp, NCOLS(edp) - n, n, edp->bkgdattr);
|
|
break;
|
|
case 'X': /* ECH erase character */
|
|
n = min(DEF1_ARG(edp, 0), COLS_LEFT(edp) + 1);
|
|
ERASECOLS(edp, edp->ccol, n, edp->bkgdattr);
|
|
break;
|
|
case 'c': /* DA primary */
|
|
if (ARG(edp, 0) == 0)
|
|
wsdisplay_emulinput(edp->cbcookie, WSEMUL_VT_ID1,
|
|
sizeof(WSEMUL_VT_ID1));
|
|
break;
|
|
case 'g': /* TBC */
|
|
KASSERT(edp->tabs != 0);
|
|
switch (ARG(edp, 0)) {
|
|
case 0:
|
|
edp->tabs[edp->ccol] = 0;
|
|
break;
|
|
case 3:
|
|
memset(edp->tabs, 0, edp->ncols);
|
|
break;
|
|
default:
|
|
#ifdef VT100_PRINTUNKNOWN
|
|
printf("CSI%dg unknown\n", ARG(edp, 0));
|
|
#endif
|
|
break;
|
|
}
|
|
break;
|
|
case 'm': /* SGR select graphic rendition */
|
|
flags = edp->attrflags;
|
|
fgcol = edp->fgcol;
|
|
bgcol = edp->bgcol;
|
|
for (n = 0; n < edp->nargs; n++) {
|
|
switch (ARG(edp, n)) {
|
|
case 0: /* reset */
|
|
if (n == edp->nargs - 1) {
|
|
edp->bkgdattr = edp->curattr = edp->defattr;
|
|
edp->attrflags = edp->msgattrs.default_attrs;
|
|
edp->fgcol = edp->msgattrs.default_fg;
|
|
edp->bgcol = edp->msgattrs.default_bg;
|
|
return;
|
|
}
|
|
flags = edp->msgattrs.default_attrs;
|
|
fgcol = edp->msgattrs.default_fg;
|
|
bgcol = edp->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;
|
|
case 22: /* ~bold VT300 only */
|
|
flags &= ~WSATTR_HILIT;
|
|
break;
|
|
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;
|
|
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;
|
|
break;
|
|
default:
|
|
#ifdef VT100_PRINTUNKNOWN
|
|
printf("CSI%dm unknown\n", ARG(edp, n));
|
|
#endif
|
|
break;
|
|
}
|
|
}
|
|
if (vt100_selectattribute(edp, flags, fgcol, bgcol, &attr,
|
|
&bkgdattr)) {
|
|
#ifdef VT100_DEBUG
|
|
printf("error allocating attr %d/%d/%x\n",
|
|
fgcol, bgcol, flags);
|
|
#endif
|
|
} else {
|
|
edp->curattr = attr;
|
|
edp->bkgdattr = bkgdattr;
|
|
edp->attrflags = flags;
|
|
edp->fgcol = fgcol;
|
|
edp->bgcol = bgcol;
|
|
}
|
|
break;
|
|
case 'n': /* reports */
|
|
switch (ARG(edp, 0)) {
|
|
case 5: /* DSR operating status */
|
|
/* 0 = OK, 3 = malfunction */
|
|
wsdisplay_emulinput(edp->cbcookie, "\033[0n", 4);
|
|
break;
|
|
case 6: { /* DSR cursor position report */
|
|
char buf[20];
|
|
int row;
|
|
if (edp->flags & VTFL_DECOM)
|
|
row = ROWS_ABOVE(edp);
|
|
else
|
|
row = edp->crow;
|
|
n = snprintf(buf, sizeof(buf), "\033[%d;%dR",
|
|
row + 1, edp->ccol + 1);
|
|
wsdisplay_emulinput(edp->cbcookie, buf, n);
|
|
}
|
|
break;
|
|
case 15: /* DSR printer status */
|
|
/* 13 = no printer, 10 = ready, 11 = not ready */
|
|
wsdisplay_emulinput(edp->cbcookie, "\033[?13n", 6);
|
|
break;
|
|
case 25: /* UDK status - VT300 only */
|
|
/* 20 = locked, 21 = unlocked */
|
|
wsdisplay_emulinput(edp->cbcookie, "\033[?21n", 6);
|
|
break;
|
|
case 26: /* keyboard dialect */
|
|
/* 1 = north american , 7 = german */
|
|
wsdisplay_emulinput(edp->cbcookie, "\033[?27;1n", 8);
|
|
break;
|
|
default:
|
|
#ifdef VT100_PRINTUNKNOWN
|
|
printf("CSI%dn unknown\n", ARG(edp, 0));
|
|
#endif
|
|
break;
|
|
}
|
|
break;
|
|
case 'r': /* DECSTBM set top/bottom margins */
|
|
help = min(DEF1_ARG(edp, 0), edp->nrows) - 1;
|
|
n = min(DEFx_ARG(edp, 1, edp->nrows), edp->nrows) - help;
|
|
if (n < 2) {
|
|
/* minimal scrolling region has 2 lines */
|
|
return;
|
|
} else {
|
|
edp->scrreg_startrow = help;
|
|
edp->scrreg_nrows = n;
|
|
}
|
|
edp->crow = ((edp->flags & VTFL_DECOM) ?
|
|
edp->scrreg_startrow : 0);
|
|
edp->ccol = 0;
|
|
break;
|
|
case 'y':
|
|
switch (ARG(edp, 0)) {
|
|
case 4: /* DECTST invoke confidence test */
|
|
/* ignore */
|
|
break;
|
|
default:
|
|
#ifdef VT100_PRINTUNKNOWN
|
|
printf("CSI%dy unknown\n", ARG(edp, 0));
|
|
#endif
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
#ifdef VT100_PRINTUNKNOWN
|
|
printf("CSI%c (%d, %d) unknown\n", c, ARG(edp, 0), ARG(edp, 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,
|
|
int flags, int fgcol, int bgcol, long *attr, long *bkgdattr)
|
|
{
|
|
int error;
|
|
|
|
if (!(edp->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,
|
|
flags & WSATTR_WSCOLORS, bkgdattr);
|
|
if (error)
|
|
return (error);
|
|
|
|
if ((flags & WSATTR_HILIT) &&
|
|
!(edp->scrcapabilities & WSSCREEN_HILIT)) {
|
|
flags &= ~WSATTR_HILIT;
|
|
if (edp->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)) {
|
|
flags &= ~WSATTR_UNDERLINE;
|
|
if (edp->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)) {
|
|
flags &= ~WSATTR_BLINK;
|
|
#ifdef VT100_DEBUG
|
|
printf("blink ignored (impossible)\n");
|
|
#endif
|
|
}
|
|
if ((flags & WSATTR_REVERSE) &&
|
|
!(edp->scrcapabilities & WSSCREEN_REVERSE)) {
|
|
flags &= ~WSATTR_REVERSE;
|
|
if (edp->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,
|
|
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
|
|
*/
|
|
void
|
|
wsemul_vt100_handle_dcs(struct vt100base_data *edp)
|
|
{
|
|
int i, pos;
|
|
|
|
switch (edp->dcstype) {
|
|
case 0: /* not handled */
|
|
return;
|
|
case DCSTYPE_TABRESTORE:
|
|
KASSERT(edp->tabs != 0);
|
|
memset(edp->tabs, 0, edp->ncols);
|
|
pos = 0;
|
|
for (i = 0; i < edp->dcspos; i++) {
|
|
char c = edp->dcsarg[i];
|
|
switch (c) {
|
|
case '0': case '1': case '2': case '3': case '4':
|
|
case '5': case '6': case '7': case '8': case '9':
|
|
pos = pos * 10 + (edp->dcsarg[i] - '0');
|
|
break;
|
|
case '/':
|
|
if (pos > 0)
|
|
edp->tabs[pos - 1] = 1;
|
|
pos = 0;
|
|
break;
|
|
default:
|
|
#ifdef VT100_PRINTUNKNOWN
|
|
printf("unknown char %c in DCS\n", c);
|
|
#endif
|
|
break;
|
|
}
|
|
}
|
|
if (pos > 0)
|
|
edp->tabs[pos - 1] = 1;
|
|
break;
|
|
default:
|
|
panic("wsemul_vt100_handle_dcs: bad type %d", edp->dcstype);
|
|
}
|
|
edp->dcstype = 0;
|
|
}
|
|
|
|
static int
|
|
vt100_ansimode(struct vt100base_data *edp, 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;
|
|
else if (op == VTMODE_RESET)
|
|
edp->flags &= ~VTFL_INSERTMODE;
|
|
res = ((edp->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)
|
|
{
|
|
int res = 0; /* default: unknown */
|
|
int flags;
|
|
|
|
flags = edp->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 */
|
|
case 5: /* DECSCNM light/dark background */
|
|
res = 4; /* all permanently reset ??? */
|
|
break;
|
|
case 6: /* DECOM move within/outside margins */
|
|
if (op == VTMODE_SET)
|
|
flags |= VTFL_DECOM;
|
|
else if (op == VTMODE_RESET)
|
|
flags &= ~VTFL_DECOM;
|
|
res = ((flags & VTFL_DECOM) ? 1 : 2);
|
|
break;
|
|
case 7: /* DECAWM autowrap */
|
|
if (op == VTMODE_SET)
|
|
flags |= VTFL_DECAWM;
|
|
else if (op == VTMODE_RESET)
|
|
flags &= ~VTFL_DECAWM;
|
|
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)
|
|
(*edp->emulops->cursor)(edp->emulcookie,
|
|
flags & VTFL_CURSORON,
|
|
edp->crow, edp->ccol);
|
|
res = ((flags & VTFL_CURSORON) ? 1 : 2);
|
|
break;
|
|
case 42: /* DECNRCM use 7-bit NRC /
|
|
7/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;
|
|
|
|
return (res);
|
|
}
|