417 lines
9.5 KiB
C
417 lines
9.5 KiB
C
/* $NetBSD: wscons_emul.c,v 1.2 1996/04/12 06:10:29 cgd Exp $ */
|
|
|
|
/*
|
|
* Copyright (c) 1995, 1996 Carnegie-Mellon University.
|
|
* All rights reserved.
|
|
*
|
|
* Author: Chris G. Demetriou
|
|
*
|
|
* Permission to use, copy, modify and distribute this software and
|
|
* its documentation is hereby granted, provided that both the copyright
|
|
* notice and this permission notice appear in all copies of the
|
|
* software, derivative works or modified versions, and any portions
|
|
* thereof, and that both notices appear in supporting documentation.
|
|
*
|
|
* CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
|
|
* CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND
|
|
* FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
|
|
*
|
|
* Carnegie Mellon requests users of this software to return to
|
|
*
|
|
* Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
|
|
* School of Computer Science
|
|
* Carnegie Mellon University
|
|
* Pittsburgh PA 15213-3890
|
|
*
|
|
* any improvements or extensions that they make and grant Carnegie the
|
|
* rights to redistribute these changes.
|
|
*/
|
|
|
|
/*
|
|
* Console emulator for a 'generic' ANSI X3.64 console.
|
|
*/
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/systm.h>
|
|
#include <alpha/wscons/wsconsvar.h>
|
|
#include <alpha/wscons/wscons_emul.h>
|
|
#include <alpha/wscons/ascii.h>
|
|
|
|
void
|
|
wscons_emul_attach(we, wo)
|
|
struct wscons_emul_data *we;
|
|
const struct wscons_odev_spec *wo;
|
|
{
|
|
int i;
|
|
|
|
#ifdef DIAGNOSTIC
|
|
if (we == NULL || wo == NULL)
|
|
panic("wscons_emul_attach: bogus args");
|
|
if (wo->wo_ef == NULL)
|
|
panic("wscons_emul_attach: bogus emul functions");
|
|
#endif
|
|
if (wo->wo_nrows < 0 || wo->wo_ncols < 0)
|
|
panic("wscons_emul_attach: bogus size");
|
|
if (wo->wo_crow < 0 || wo->wo_ccol < 0 ||
|
|
wo->wo_crow >= wo->wo_nrows || wo->wo_ccol >= wo->wo_ncols)
|
|
panic("wscons_emul_attach: bogus location (n: %d/%d, c: %d/%d",
|
|
wo->wo_nrows, wo->wo_ncols, wo->wo_crow, wo->wo_ccol);
|
|
|
|
we->ac_state = ANSICONS_STATE_NORMAL;
|
|
we->ac_ef = wo->wo_ef;
|
|
we->ac_efa = wo->wo_efa;
|
|
|
|
we->ac_nrow = wo->wo_nrows;
|
|
we->ac_ncol = wo->wo_ncols;
|
|
|
|
we->ac_crow = wo->wo_crow;
|
|
we->ac_ccol = wo->wo_ccol;
|
|
|
|
for (i = 0; i < ANSICONS_NARGS; i++)
|
|
we->ac_args[i] = 0;
|
|
|
|
(*we->ac_ef->wef_cursor)(we->ac_efa, 1, we->ac_crow, we->ac_ccol);
|
|
}
|
|
|
|
static inline int
|
|
wscons_emul_input_normal(we, c)
|
|
struct wscons_emul_data *we;
|
|
char c;
|
|
{
|
|
int newstate = ANSICONS_STATE_NORMAL;
|
|
int n;
|
|
|
|
switch (c) {
|
|
case ASCII_BEL:
|
|
wscons_kbd_bell();
|
|
break;
|
|
|
|
case ASCII_BS:
|
|
if (we->ac_ccol > 0)
|
|
we->ac_ccol--;
|
|
break;
|
|
|
|
case ASCII_HT:
|
|
n = 8 - (we->ac_ccol & 7);
|
|
if (we->ac_ccol + n >= we->ac_ncol)
|
|
n = we->ac_ncol - we->ac_ccol - 1;
|
|
|
|
(*we->ac_ef->wef_erasecols)(we->ac_efa, we->ac_crow,
|
|
we->ac_ccol, we->ac_ccol + n);
|
|
|
|
we->ac_ccol += n;
|
|
break;
|
|
|
|
case ASCII_LF:
|
|
if (we->ac_crow < we->ac_nrow - 1) {
|
|
we->ac_crow++;
|
|
break;
|
|
}
|
|
|
|
#ifdef DIAGNOSTIC
|
|
if (we->ac_crow >= we->ac_nrow)
|
|
panic("wscons_emul: didn't scroll (1)");
|
|
#endif
|
|
|
|
#if 0
|
|
(*we->ac_ef->wef_copyrows)(we->ac_efa, 1, 0,
|
|
we->ac_nrow - 1);
|
|
(*we->ac_ef->wef_eraserows)(we->ac_efa,
|
|
we->ac_nrow - 1, 1);
|
|
#else
|
|
(*we->ac_ef->wef_copyrows)(we->ac_efa, 10, 0,
|
|
we->ac_nrow - 10);
|
|
(*we->ac_ef->wef_eraserows)(we->ac_efa,
|
|
we->ac_nrow - 10, 10);
|
|
we->ac_crow -= 10 - 1;
|
|
#endif
|
|
break;
|
|
|
|
case ASCII_VT:
|
|
if (we->ac_crow > 0)
|
|
we->ac_crow--;
|
|
break;
|
|
|
|
case ASCII_NP:
|
|
(*we->ac_ef->wef_eraserows)(we->ac_efa,
|
|
0, we->ac_nrow - 1);
|
|
|
|
we->ac_ccol = 0;
|
|
we->ac_crow = 0;
|
|
break;
|
|
|
|
case ASCII_CR:
|
|
we->ac_ccol = 0;
|
|
break;
|
|
|
|
case ASCII_ESC:
|
|
if (we->ac_state == ANSICONS_STATE_NORMAL) {
|
|
newstate = ANSICONS_STATE_HAVEESC;
|
|
break;
|
|
}
|
|
/* else fall through; we're printing one out */
|
|
|
|
default:
|
|
(*we->ac_ef->wef_putstr)(we->ac_efa,
|
|
we->ac_crow, we->ac_ccol, &c, 1);
|
|
we->ac_ccol++;
|
|
|
|
/* if the current column is still on the current line, done. */
|
|
if (we->ac_ccol < we->ac_ncol)
|
|
break;
|
|
|
|
/* wrap the column around. */
|
|
we->ac_ccol = 0;
|
|
|
|
/* if the current row isn't the last, increment and leave. */
|
|
if (we->ac_crow < we->ac_nrow - 1) {
|
|
we->ac_crow++;
|
|
break;
|
|
}
|
|
|
|
#ifdef DIAGNOSTIC
|
|
/* check against row overflow */
|
|
if (we->ac_crow >= we->ac_nrow)
|
|
panic("wscons_emul: didn't scroll (2)");
|
|
#endif
|
|
|
|
#if 0
|
|
/* scroll all of the rows up one; leave current row # alone */
|
|
(*we->ac_ef->wef_copyrows)(we->ac_efa, 1, 0,
|
|
we->ac_nrow - 1);
|
|
(*we->ac_ef->wef_eraserows)(we->ac_efa,
|
|
we->ac_nrow - 1, 1);
|
|
#else
|
|
(*we->ac_ef->wef_copyrows)(we->ac_efa, 10, 0,
|
|
we->ac_nrow - 10);
|
|
(*we->ac_ef->wef_eraserows)(we->ac_efa,
|
|
we->ac_nrow - 10, 10);
|
|
we->ac_crow -= 10 - 1;
|
|
#endif
|
|
break;
|
|
}
|
|
|
|
return newstate;
|
|
}
|
|
|
|
static inline int
|
|
wscons_emul_input_haveesc(we, c)
|
|
struct wscons_emul_data *we;
|
|
char c;
|
|
{
|
|
int newstate = ANSICONS_STATE_NORMAL;
|
|
int i;
|
|
|
|
switch (c) {
|
|
case '[':
|
|
for (i = 0; i < ANSICONS_NARGS; i++)
|
|
we->ac_args[i] = 0;
|
|
newstate = ANSICONS_STATE_CONTROL;
|
|
break;
|
|
|
|
default:
|
|
wscons_emul_input_normal(we, ASCII_ESC); /* special cased */
|
|
newstate = wscons_emul_input_normal(we, c);
|
|
break;
|
|
}
|
|
|
|
return newstate;
|
|
}
|
|
|
|
static inline void
|
|
wscons_emul_docontrol(we, c)
|
|
struct wscons_emul_data *we;
|
|
char c;
|
|
{
|
|
int n, m;
|
|
|
|
#if 0
|
|
printf("control: %c: %d, %d\n", c, we->ac_args[0], we->ac_args[1]);
|
|
#endif
|
|
switch (c) {
|
|
case 'A': /* Cursor Up */
|
|
n = we->ac_args[0] ? we->ac_args[0] : 1;
|
|
n = min(n, we->ac_crow);
|
|
we->ac_crow -= n;
|
|
break;
|
|
|
|
case 'B': /* Cursor Down */
|
|
n = we->ac_args[0] ? we->ac_args[0] : 1;
|
|
n = min(n, we->ac_nrow - we->ac_crow - 1);
|
|
we->ac_crow += n;
|
|
break;
|
|
|
|
case 'C': /* Cursor Forward */
|
|
n = we->ac_args[0] ? we->ac_args[0] : 1;
|
|
n = min(n, we->ac_ncol - we->ac_ccol - 1);
|
|
we->ac_ccol += n;
|
|
break;
|
|
|
|
case 'D': /* Cursor Backward */
|
|
n = we->ac_args[0] ? we->ac_args[0] : 1;
|
|
n = min(n, we->ac_ccol);
|
|
we->ac_ccol -= n;
|
|
break;
|
|
|
|
case 'E': /* Cursor Next Line */
|
|
n = we->ac_args[0] ? we->ac_args[0] : 1;
|
|
n = min(n, we->ac_nrow - we->ac_crow - 1);
|
|
we->ac_crow += n;
|
|
we->ac_ccol = 0;
|
|
break;
|
|
|
|
case 'f': /* Horizontal and Vertical Position */
|
|
case 'H': /* Cursor Position */
|
|
m = we->ac_args[1] ? we->ac_args[1] : 1; /* arg 1 */
|
|
m = min(m, we->ac_nrow);
|
|
|
|
n = we->ac_args[0] ? we->ac_args[0] : 1; /* arg 2 */
|
|
n = min(n, we->ac_ncol);
|
|
|
|
we->ac_crow = m - 1;
|
|
we->ac_ccol = n - 1;
|
|
break;
|
|
|
|
case 'J': /* Erase in Display */
|
|
(*we->ac_ef->wef_erasecols)(we->ac_efa, we->ac_crow,
|
|
we->ac_ccol, we->ac_ncol - we->ac_ccol);
|
|
if (we->ac_crow + 1 < we->ac_nrow)
|
|
(*we->ac_ef->wef_eraserows)(we->ac_efa,
|
|
we->ac_crow + 1, we->ac_nrow - we->ac_crow - 1);
|
|
break;
|
|
|
|
case 'K': /* Erase in Line */
|
|
(*we->ac_ef->wef_erasecols)(we->ac_efa, we->ac_crow,
|
|
we->ac_ccol, we->ac_ncol - we->ac_ccol);
|
|
break;
|
|
|
|
case 'L': /* Insert Line */
|
|
{
|
|
int copy_src, copy_dst, copy_nlines;
|
|
|
|
n = we->ac_args[0] ? we->ac_args[0] : 1;
|
|
n = min(n, we->ac_nrow - we->ac_crow);
|
|
|
|
copy_src = we->ac_crow;
|
|
copy_dst = we->ac_crow + n;
|
|
copy_nlines = we->ac_nrow - copy_dst;
|
|
if (copy_nlines > 0)
|
|
(*we->ac_ef->wef_copyrows)(we->ac_efa,
|
|
copy_src, copy_dst, copy_nlines);
|
|
|
|
(*we->ac_ef->wef_eraserows)(we->ac_efa,
|
|
we->ac_crow, n);
|
|
}
|
|
break;
|
|
|
|
case 'M': /* Delete Line */
|
|
{
|
|
int copy_src, copy_dst, copy_nlines;
|
|
|
|
n = we->ac_args[0] ? we->ac_args[0] : 1;
|
|
n = min(n, we->ac_nrow - we->ac_crow);
|
|
|
|
copy_src = we->ac_crow + n;
|
|
copy_dst = we->ac_crow;
|
|
copy_nlines = we->ac_nrow - copy_src;
|
|
if (copy_nlines > 0)
|
|
(*we->ac_ef->wef_copyrows)(we->ac_efa,
|
|
copy_src, copy_dst, copy_nlines);
|
|
|
|
(*we->ac_ef->wef_eraserows)(we->ac_efa,
|
|
we->ac_crow + copy_nlines,
|
|
we->ac_nrow - (we->ac_crow + copy_nlines));
|
|
}
|
|
break;
|
|
|
|
case 'P': /* Delete Character */
|
|
{
|
|
int copy_src, copy_dst, copy_ncols;
|
|
|
|
n = we->ac_args[0] ? we->ac_args[0] : 1;
|
|
n = min(n, we->ac_ncol - we->ac_ccol);
|
|
|
|
copy_src = we->ac_ccol + n;
|
|
copy_dst = we->ac_ccol;
|
|
copy_ncols = we->ac_ncol - copy_src;
|
|
if (copy_ncols > 0)
|
|
(*we->ac_ef->wef_copycols)(we->ac_efa,
|
|
we->ac_crow, copy_src, copy_dst,
|
|
copy_ncols);
|
|
|
|
(*we->ac_ef->wef_erasecols)(we->ac_efa,
|
|
we->ac_crow, we->ac_ccol + copy_ncols,
|
|
we->ac_ncol - (we->ac_ccol + copy_ncols));
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
static inline int
|
|
wscons_emul_input_control(we, c)
|
|
struct wscons_emul_data *we;
|
|
char c;
|
|
{
|
|
int newstate = ANSICONS_STATE_CONTROL;
|
|
int i;
|
|
|
|
switch (c) {
|
|
case '0': case '1': case '2': case '3': case '4':
|
|
case '5': case '6': case '7': case '8': case '9':
|
|
we->ac_args[0] *= 10;
|
|
we->ac_args[0] += c - '0';
|
|
break;
|
|
|
|
case ';':
|
|
for (i = 0; i < ANSICONS_NARGS - 1; i++)
|
|
we->ac_args[i + 1] = we->ac_args[i];
|
|
we->ac_args[0] = 0;
|
|
break;
|
|
|
|
default:
|
|
wscons_emul_docontrol(we, c);
|
|
newstate = ANSICONS_STATE_NORMAL;
|
|
break;
|
|
}
|
|
|
|
return newstate;
|
|
}
|
|
|
|
void
|
|
wscons_emul_input(we, cp, n)
|
|
struct wscons_emul_data *we;
|
|
char *cp;
|
|
int n;
|
|
{
|
|
int newstate;
|
|
|
|
(*we->ac_ef->wef_cursor)(we->ac_efa, 0, we->ac_crow, we->ac_ccol);
|
|
for (; n; n--, cp++) {
|
|
switch (we->ac_state) {
|
|
case ANSICONS_STATE_NORMAL:
|
|
newstate = wscons_emul_input_normal(we, *cp);
|
|
break;
|
|
|
|
case ANSICONS_STATE_HAVEESC:
|
|
newstate = wscons_emul_input_haveesc(we, *cp);
|
|
break;
|
|
|
|
case ANSICONS_STATE_CONTROL:
|
|
newstate = wscons_emul_input_control(we, *cp);
|
|
break;
|
|
|
|
default:
|
|
#ifdef DIAGNOSTIC
|
|
panic("wscons_emul: invalid state %d\n", we->ac_state);
|
|
#endif
|
|
/* try to recover, if things get screwed up... */
|
|
newstate = ANSICONS_STATE_NORMAL;
|
|
break;
|
|
}
|
|
|
|
we->ac_state = newstate;
|
|
}
|
|
(*we->ac_ef->wef_cursor)(we->ac_efa, 1, we->ac_crow, we->ac_ccol);
|
|
}
|