d/freebsd-nq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Replace syscons terminal renderer by a new renderer that uses libteken.

Browse Source 
Some time ago I started working on a library called libteken, which is
terminal emulator. It does not buffer any screen contents, but only
keeps terminal state, such as cursor position, attributes, etc. It
should implement all escape sequences that are implemented by the
cons25 terminal emulator, but also a fair amount of sequences that are
present in VT100 and xterm.

A lot of random notes, which could be of interest to users/developers:

- Even though I'm leaving the terminal type set to `cons25', users can
  do experiments with placing `xterm-color' in /etc/ttys. Because we
  only implement a subset of features of xterm, this may cause
  artifacts. We should consider extending libteken, because in my
  opinion xterm is the way to go. Some missing features:

  - Keypad application mode (DECKPAM)
  - Character sets (SCS)

- libteken is filled with a fair amount of assertions, but unfortunately
  we cannot go into the debugger anymore if we fail them. I've done
  development of this library almost entirely in userspace. In
  sys/dev/syscons/teken there are two applications that can be helpful
  when debugging the code:

  - teken_demo: a terminal emulator that can be started from a regular
    xterm that emulates a terminal using libteken. This application can
    be very useful to debug any rendering issues.

  - teken_stress: a stress testing application that emulates random
    terminal output. libteken has literally survived multiple terabytes
    of random input.

- libteken also includes support for UTF-8, but unfortunately our input
  layer and font renderer don't support this. If users want to
  experiment with UTF-8 support, they can enable `TEKEN_UTF8' in
  teken.h. If you recompile your kernel or the teken_demo application,
  you can hold some nice experiments.

- I've left PC98 the way it is right now. The PC98 platform has a custom
  syscons renderer, which supports some form of localised input. Maybe
  we should port PC98 to libteken by the time syscons supports UTF-8?

- I've removed the `dumb' terminal emulator. It has been broken for
  years. It hasn't survived the `struct proc' -> `struct thread'
  conversion.

- To prevent confusion among people that want to hack on libteken:
  unlike syscons, the state machines that parse the escape sequences are
  machine generated. This means that if you want to add new escape
  sequences, you have to add an entry to the `sequences' file. This will
  cause new entries to be added to `teken_state.h'.

- Any rendering artifacts that didn't occur prior to this commit are by
  accident. They should be reported to me, so I can fix them.

Discussed on:	current@, hackers@
Discussed with:	philip (at 25C3)
This commit is contained in:
Ed Schouten 2009-01-01 13:26:53 +00:00
parent 64f91b28e2
commit b4b1c5169d
24 changed files with 3117 additions and 989 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
sys/conf/files
View File

@ -75,6 +75,11 @@ pccarddevs.h standard \
compile-with "${AWK} -f $S/tools/pccarddevs2h.awk $S/dev/pccard/pccarddevs" \
no-obj no-implicit-rule before-depend \
clean "pccarddevs.h"
teken_state.h optional sc \
dependency "$S/dev/syscons/teken/gensequences $S/dev/syscons/teken/sequences" \
compile-with "${AWK} -f $S/dev/syscons/teken/gensequences $S/dev/syscons/teken/sequences > teken_state.h" \
no-obj no-implicit-rule before-depend \
clean "teken_state.h"
usbdevs.h optional usb \
dependency "$S/tools/usbdevs2h.awk $S/dev/usb/usbdevs" \
compile-with "${AWK} -f $S/tools/usbdevs2h.awk $S/dev/usb/usbdevs -h" \
@ -1424,7 +1429,6 @@ dev/syscons/logo/logo_saver.c optional logo_saver
dev/syscons/rain/rain_saver.c optional rain_saver
dev/syscons/schistory.c optional sc
dev/syscons/scmouse.c optional sc
dev/syscons/scterm-dumb.c optional sc
dev/syscons/scterm.c optional sc
dev/syscons/scvidctl.c optional sc
dev/syscons/snake/snake_saver.c optional snake_saver

3
sys/conf/files.amd64
View File

@ -196,9 +196,10 @@ dev/sio/sio_pci.c optional sio pci
dev/sio/sio_puc.c optional sio puc
dev/speaker/spkr.c optional speaker
dev/syscons/apm/apm_saver.c optional apm_saver apm
dev/syscons/scterm-sc.c optional sc
dev/syscons/scterm-teken.c optional sc
dev/syscons/scvgarndr.c optional sc vga
dev/syscons/scvtb.c optional sc
dev/syscons/teken/teken.c optional sc
dev/uart/uart_cpu_amd64.c optional uart
dev/wpi/if_wpi.c optional wpi
isa/atrtc.c standard

3
sys/conf/files.i386
View File

@ -220,10 +220,11 @@ dev/sio/sio_puc.c optional sio puc
dev/speaker/spkr.c optional speaker
dev/sr/if_sr_isa.c optional sr isa
dev/syscons/apm/apm_saver.c optional apm_saver apm
dev/syscons/scterm-sc.c optional sc
dev/syscons/scterm-teken.c optional sc
dev/syscons/scvesactl.c optional sc vga vesa
dev/syscons/scvgarndr.c optional sc vga
dev/syscons/scvtb.c optional sc
dev/syscons/teken/teken.c optional sc
dev/uart/uart_cpu_i386.c optional uart
dev/acpica/acpi_if.m standard
dev/wpi/if_wpi.c optional wpi

3
sys/conf/files.ia64
View File

@ -57,9 +57,10 @@ dev/fb/fb.c optional fb | vga
dev/fb/vga.c optional vga
dev/hwpmc/hwpmc_ia64.c optional hwpmc
dev/kbd/kbd.c optional atkbd | sc | ukbd
dev/syscons/scterm-sc.c optional sc
dev/syscons/scterm-teken.c optional sc
dev/syscons/scvgarndr.c optional sc vga
dev/syscons/scvtb.c optional sc
dev/syscons/teken/teken.c optional sc
dev/uart/uart_cpu_ia64.c optional uart
dev/acpica/acpi_if.m standard
ia64/acpica/OsdEnvironment.c optional acpi

3
sys/conf/files.powerpc
View File

@ -39,8 +39,9 @@ dev/powermac_nvram/powermac_nvram.c optional powermac_nvram powermac
dev/quicc/quicc_bfe_ocp.c optional quicc mpc85xx
dev/scc/scc_bfe_macio.c optional scc powermac
dev/syscons/scgfbrndr.c optional sc
dev/syscons/scterm-sc.c optional sc
dev/syscons/scterm-teken.c optional sc
dev/syscons/scvtb.c optional sc
dev/syscons/teken/teken.c optional sc
dev/tsec/if_tsec.c optional tsec
dev/tsec/if_tsec_ocp.c optional tsec mpc85xx
dev/uart/uart_bus_ocp.c optional uart mpc85xx

3
sys/conf/files.sparc64
View File

@ -55,8 +55,9 @@ dev/pcf/pcf_ebus.c optional pcf ebus
dev/sound/sbus/cs4231.c optional snd_audiocs ebus | \
snd_audiocs sbus
dev/syscons/scgfbrndr.c optional sc
dev/syscons/scterm-sc.c optional sc
dev/syscons/scterm-teken.c optional sc
dev/syscons/scvtb.c optional sc
dev/syscons/teken/teken.c optional sc
dev/uart/uart_cpu_sparc64.c optional uart
dev/uart/uart_kbd_sun.c optional uart sc
kern/syscalls.c optional ktr

155
sys/dev/syscons/scterm-dumb.c
View File

@ -1,155 +0,0 @@
/*-
* Copyright (c) 1999 Kazutaka YOKOTA <yokota@zodiac.mech.utsunomiya-u.ac.jp>
* 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 as
* the first lines of this file unmodified.
* 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 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.
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include "opt_syscons.h"
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/consio.h>
#if defined(__sparc64__) || defined(__powerpc__)
#include <machine/sc_machdep.h>
#else
#include <machine/pc/display.h>
#endif
#include <dev/syscons/syscons.h>
#include <dev/syscons/sctermvar.h>
#ifdef SC_DUMB_TERMINAL
/* dumb terminal emulator */
static sc_term_init_t dumb_init;
static sc_term_term_t dumb_term;
static sc_term_puts_t dumb_puts;
static sc_term_ioctl_t dumb_ioctl;
static sc_term_clear_t dumb_clear;
static sc_term_input_t dumb_input;
static void dumb_nop(void);
static sc_term_sw_t sc_term_dumb = {
{ NULL, NULL },
"dumb", /* emulator name */
"dumb terminal", /* description */
"*", /* matching renderer */
0, /* softc size */
0,
dumb_init,
dumb_term,
dumb_puts,
dumb_ioctl,
(sc_term_reset_t *)dumb_nop,
(sc_term_default_attr_t *)dumb_nop,
dumb_clear,
(sc_term_notify_t *)dumb_nop,
dumb_input,
};
SCTERM_MODULE(dumb, sc_term_dumb);
static int
dumb_init(scr_stat *scp, void **softc, int code)
{
switch (code) {
case SC_TE_COLD_INIT:
++sc_term_dumb.te_refcount;
break;
case SC_TE_WARM_INIT:
break;
}
return 0;
}
static int
dumb_term(scr_stat *scp, void **softc)
{
--sc_term_dumb.te_refcount;
return 0;
}
static void
dumb_puts(scr_stat *scp, u_char *buf, int len)
{
while (len > 0) {
++scp->sc->write_in_progress;
sc_term_gen_print(scp, &buf, &len, SC_NORM_ATTR << 8);
sc_term_gen_scroll(scp, scp->sc->scr_map[0x20],
SC_NORM_ATTR << 8);
--scp->sc->write_in_progress;
}
}
static int
dumb_ioctl(scr_stat *scp, struct tty *tp, u_long cmd, caddr_t data,
int flag, struct proc *p)
{
vid_info_t *vi;
switch (cmd) {
case GIO_ATTR: /* get current attributes */
*(int*)data = SC_NORM_ATTR;
return 0;
case CONS_GETINFO: /* get current (virtual) console info */
vi = (vid_info_t *)data;
if (vi->size != sizeof(struct vid_info))
return EINVAL;
vi->mv_norm.fore = SC_NORM_ATTR & 0x0f;
vi->mv_norm.back = (SC_NORM_ATTR >> 4) & 0x0f;
vi->mv_rev.fore = SC_NORM_ATTR & 0x0f;
vi->mv_rev.back = (SC_NORM_ATTR >> 4) & 0x0f;
/*
* The other fields are filled by the upper routine. XXX
*/
return ENOIOCTL;
}
return ENOIOCTL;
}
static void
dumb_clear(scr_stat *scp)
{
sc_move_cursor(scp, 0, 0);
sc_vtb_clear(&scp->vtb, scp->sc->scr_map[0x20], SC_NORM_ATTR << 8);
mark_all(scp);
}
static int
dumb_input(scr_stat *scp, int c, struct tty *tp)
{
return FALSE;
}
static void
dumb_nop(void)
{
/* nothing */
}
#endif /* SC_DUMB_TERMINAL */

811
sys/dev/syscons/scterm-sc.c
View File

@ -1,811 +0,0 @@
/*-
* Copyright (c) 1999 Kazutaka YOKOTA <yokota@zodiac.mech.utsunomiya-u.ac.jp>
* Copyright (c) 1992-1998 Søren Schmidt
* 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 as
* the first lines of this file unmodified.
* 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 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.
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include "opt_syscons.h"
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/module.h>
#include <sys/consio.h>
#if defined(__sparc64__) || defined(__powerpc__)
#include <machine/sc_machdep.h>
#else
#include <machine/pc/display.h>
#endif
#include <dev/syscons/syscons.h>
#include <dev/syscons/sctermvar.h>
#ifndef SC_DUMB_TERMINAL
#define MAX_ESC_PAR 5
/* attribute flags */
typedef struct {
u_short fg; /* foreground color */
u_short bg; /* background color */
} color_t;
typedef struct {
int flags;
#define SCTERM_BUSY (1 << 0)
int esc;
int num_param;
int last_param;
int param[MAX_ESC_PAR];
int saved_xpos;
int saved_ypos;
int attr_mask; /* current logical attr mask */
#define NORMAL_ATTR 0x00
#define BLINK_ATTR 0x01
#define BOLD_ATTR 0x02
#define UNDERLINE_ATTR 0x04
#define REVERSE_ATTR 0x08
#define FG_CHANGED 0x10
#define BG_CHANGED 0x20
int cur_attr; /* current hardware attr word */
color_t cur_color; /* current hardware color */
color_t std_color; /* normal hardware color */
color_t rev_color; /* reverse hardware color */
color_t dflt_std_color; /* default normal color */
color_t dflt_rev_color; /* default reverse color */
} term_stat;
static sc_term_init_t scterm_init;
static sc_term_term_t scterm_term;
static sc_term_puts_t scterm_puts;
static sc_term_ioctl_t scterm_ioctl;
static sc_term_reset_t scterm_reset;
static sc_term_default_attr_t scterm_default_attr;
static sc_term_clear_t scterm_clear;
static sc_term_notify_t scterm_notify;
static sc_term_input_t scterm_input;
static sc_term_sw_t sc_term_sc = {
{ NULL, NULL },
"sc", /* emulator name */
"syscons terminal", /* description */
"*", /* matching renderer, any :-) */
sizeof(term_stat), /* softc size */
0,
scterm_init,
scterm_term,
scterm_puts,
scterm_ioctl,
scterm_reset,
scterm_default_attr,
scterm_clear,
scterm_notify,
scterm_input,
};
SCTERM_MODULE(sc, sc_term_sc);
static term_stat reserved_term_stat;
static void scterm_scan_esc(scr_stat *scp, term_stat *tcp,
u_char c);
static int mask2attr(term_stat *tcp);
static int
scterm_init(scr_stat *scp, void **softc, int code)
{
term_stat *tcp;
if (*softc == NULL) {
if (reserved_term_stat.flags & SCTERM_BUSY)
return EINVAL;
*softc = &reserved_term_stat;
}
tcp = *softc;
switch (code) {
case SC_TE_COLD_INIT:
bzero(tcp, sizeof(*tcp));
tcp->flags = SCTERM_BUSY;
tcp->esc = 0;
tcp->saved_xpos = -1;
tcp->saved_ypos = -1;
tcp->attr_mask = NORMAL_ATTR;
/* XXX */
tcp->dflt_std_color.fg = SC_NORM_ATTR & 0x0f;
tcp->dflt_std_color.bg = (SC_NORM_ATTR >> 4) & 0x0f;
tcp->dflt_rev_color.fg = SC_NORM_REV_ATTR & 0x0f;
tcp->dflt_rev_color.bg = (SC_NORM_REV_ATTR >> 4) & 0x0f;
tcp->std_color = tcp->dflt_std_color;
tcp->rev_color = tcp->dflt_rev_color;
tcp->cur_color = tcp->std_color;
tcp->cur_attr = mask2attr(tcp);
++sc_term_sc.te_refcount;
break;
case SC_TE_WARM_INIT:
tcp->esc = 0;
tcp->saved_xpos = -1;
tcp->saved_ypos = -1;
#if 0
tcp->std_color = tcp->dflt_std_color;
tcp->rev_color = tcp->dflt_rev_color;
#endif
tcp->cur_color = tcp->std_color;
tcp->cur_attr = mask2attr(tcp);
break;
}
return 0;
}
static int
scterm_term(scr_stat *scp, void **softc)
{
if (*softc == &reserved_term_stat) {
*softc = NULL;
bzero(&reserved_term_stat, sizeof(reserved_term_stat));
}
--sc_term_sc.te_refcount;
return 0;
}
static void
scterm_scan_esc(scr_stat *scp, term_stat *tcp, u_char c)
{
static u_char ansi_col[16] = {
FG_BLACK, FG_RED, FG_GREEN, FG_BROWN,
FG_BLUE, FG_MAGENTA, FG_CYAN, FG_LIGHTGREY,
FG_DARKGREY, FG_LIGHTRED, FG_LIGHTGREEN, FG_YELLOW,
FG_LIGHTBLUE, FG_LIGHTMAGENTA, FG_LIGHTCYAN, FG_WHITE
};
static int cattrs[] = {
0, /* block */
CONS_BLINK_CURSOR, /* blinking block */
CONS_CHAR_CURSOR, /* underline */
CONS_CHAR_CURSOR | CONS_BLINK_CURSOR, /* blinking underline */
CONS_RESET_CURSOR, /* reset to default */
CONS_HIDDEN_CURSOR, /* hide cursor */
};
static int tcattrs[] = {
CONS_RESET_CURSOR | CONS_LOCAL_CURSOR, /* normal */
CONS_HIDDEN_CURSOR | CONS_LOCAL_CURSOR, /* invisible */
CONS_BLINK_CURSOR | CONS_LOCAL_CURSOR, /* very visible */
};
sc_softc_t *sc;
int v0, v1, v2;
int i, n;
i = n = 0;
sc = scp->sc;
if (tcp->esc == 1) { /* seen ESC */
switch (c) {
case '7': /* Save cursor position */
tcp->saved_xpos = scp->xpos;
tcp->saved_ypos = scp->ypos;
break;
case '8': /* Restore saved cursor position */
if (tcp->saved_xpos >= 0 && tcp->saved_ypos >= 0)
sc_move_cursor(scp, tcp->saved_xpos,
tcp->saved_ypos);
break;
case '[': /* Start ESC [ sequence */
tcp->esc = 2;
tcp->last_param = -1;
for (i = tcp->num_param; i < MAX_ESC_PAR; i++)
tcp->param[i] = 1;
tcp->num_param = 0;
return;
case 'M': /* Move cursor up 1 line, scroll if at top */
sc_term_up_scroll(scp, 1, sc->scr_map[0x20],
tcp->cur_attr, 0, 0);
break;
#ifdef notyet
case 'Q':
tcp->esc = 4;
return;
#endif
case 'c': /* reset */
tcp->attr_mask = NORMAL_ATTR;
tcp->cur_color = tcp->std_color
= tcp->dflt_std_color;
tcp->rev_color = tcp->dflt_rev_color;
tcp->cur_attr = mask2attr(tcp);
sc_change_cursor_shape(scp,
CONS_RESET_CURSOR | CONS_LOCAL_CURSOR, -1, -1);
sc_clear_screen(scp);
break;
case '(': /* iso-2022: designate 94 character set to G0 */
tcp->esc = 5;
return;
}
} else if (tcp->esc == 2) { /* seen ESC [ */
if (c >= '0' && c <= '9') {
if (tcp->num_param < MAX_ESC_PAR) {
if (tcp->last_param != tcp->num_param) {
tcp->last_param = tcp->num_param;
tcp->param[tcp->num_param] = 0;
} else {
tcp->param[tcp->num_param] *= 10;
}
tcp->param[tcp->num_param] += c - '0';
return;
}
}
tcp->num_param = tcp->last_param + 1;
switch (c) {
case ';':
if (tcp->num_param < MAX_ESC_PAR)
return;
break;
case '=':
tcp->esc = 3;
tcp->last_param = -1;
for (i = tcp->num_param; i < MAX_ESC_PAR; i++)
tcp->param[i] = 1;
tcp->num_param = 0;
return;
case 'A': /* up n rows */
sc_term_up(scp, tcp->param[0], 0);
break;
case 'B': /* down n rows */
sc_term_down(scp, tcp->param[0], 0);
break;
case 'C': /* right n columns */
sc_term_right(scp, tcp->param[0]);
break;
case 'D': /* left n columns */
sc_term_left(scp, tcp->param[0]);
break;
case 'E': /* cursor to start of line n lines down */
n = tcp->param[0];
if (n < 1)
n = 1;
sc_move_cursor(scp, 0, scp->ypos + n);
break;
case 'F': /* cursor to start of line n lines up */
n = tcp->param[0];
if (n < 1)
n = 1;
sc_move_cursor(scp, 0, scp->ypos - n);
break;
case 'f': /* Cursor move */
case 'H':
if (tcp->num_param == 0)
sc_move_cursor(scp, 0, 0);
else if (tcp->num_param == 2)
sc_move_cursor(scp, tcp->param[1] - 1,
tcp->param[0] - 1);
break;
case 'J': /* Clear all or part of display */
if (tcp->num_param == 0)
n = 0;
else
n = tcp->param[0];
sc_term_clr_eos(scp, n, sc->scr_map[0x20],
tcp->cur_attr);
break;
case 'K': /* Clear all or part of line */
if (tcp->num_param == 0)
n = 0;
else
n = tcp->param[0];
sc_term_clr_eol(scp, n, sc->scr_map[0x20],
tcp->cur_attr);
break;
case 'L': /* Insert n lines */
sc_term_ins_line(scp, scp->ypos, tcp->param[0],
sc->scr_map[0x20], tcp->cur_attr, 0);
break;
case 'M': /* Delete n lines */
sc_term_del_line(scp, scp->ypos, tcp->param[0],
sc->scr_map[0x20], tcp->cur_attr, 0);
break;
case 'P': /* Delete n chars */
sc_term_del_char(scp, tcp->param[0],
sc->scr_map[0x20], tcp->cur_attr);
break;
case '@': /* Insert n chars */
sc_term_ins_char(scp, tcp->param[0],
sc->scr_map[0x20], tcp->cur_attr);
break;
case 'S': /* scroll up n lines */
sc_term_del_line(scp, 0, tcp->param[0],
sc->scr_map[0x20], tcp->cur_attr, 0);
break;
case 'T': /* scroll down n lines */
sc_term_ins_line(scp, 0, tcp->param[0],
sc->scr_map[0x20], tcp->cur_attr, 0);
break;
case 'X': /* erase n characters in line */
n = tcp->param[0];
if (n < 1)
n = 1;
if (n > scp->xsize - scp->xpos)
n = scp->xsize - scp->xpos;
sc_vtb_erase(&scp->vtb, scp->cursor_pos, n,
sc->scr_map[0x20], tcp->cur_attr);
mark_for_update(scp, scp->cursor_pos);
mark_for_update(scp, scp->cursor_pos + n - 1);
break;
case 'Z': /* move n tabs backwards */
sc_term_backtab(scp, tcp->param[0]);
break;
case '`': /* move cursor to column n */
sc_term_col(scp, tcp->param[0]);
break;
case 'a': /* move cursor n columns to the right */
sc_term_right(scp, tcp->param[0]);
break;
case 'd': /* move cursor to row n */
sc_term_row(scp, tcp->param[0]);
break;
case 'e': /* move cursor n rows down */
sc_term_down(scp, tcp->param[0], 0);
break;
case 'm': /* change attribute */
if (tcp->num_param == 0) {
tcp->attr_mask = NORMAL_ATTR;
tcp->cur_color = tcp->std_color;
tcp->cur_attr = mask2attr(tcp);
break;
}
for (i = 0; i < tcp->num_param; i++) {
switch (n = tcp->param[i]) {
case 0: /* back to normal */
tcp->attr_mask = NORMAL_ATTR;
tcp->cur_color = tcp->std_color;
tcp->cur_attr = mask2attr(tcp);
break;
case 1: /* bold */
tcp->attr_mask |= BOLD_ATTR;
tcp->cur_attr = mask2attr(tcp);
break;
case 4: /* underline */
tcp->attr_mask |= UNDERLINE_ATTR;
tcp->cur_attr = mask2attr(tcp);
break;
case 5: /* blink */
tcp->attr_mask |= BLINK_ATTR;
tcp->cur_attr = mask2attr(tcp);
break;
case 7: /* reverse */
tcp->attr_mask |= REVERSE_ATTR;
tcp->cur_attr = mask2attr(tcp);
break;
case 22: /* remove bold (or dim) */
tcp->attr_mask &= ~BOLD_ATTR;
tcp->cur_attr = mask2attr(tcp);
break;
case 24: /* remove underline */
tcp->attr_mask &= ~UNDERLINE_ATTR;
tcp->cur_attr = mask2attr(tcp);
break;
case 25: /* remove blink */
tcp->attr_mask &= ~BLINK_ATTR;
tcp->cur_attr = mask2attr(tcp);
break;
case 27: /* remove reverse */
tcp->attr_mask &= ~REVERSE_ATTR;
tcp->cur_attr = mask2attr(tcp);
break;
case 30: case 31: /* set ansi fg color */
case 32: case 33: case 34:
case 35: case 36: case 37:
tcp->attr_mask |= FG_CHANGED;
tcp->cur_color.fg = ansi_col[n - 30];
tcp->cur_attr = mask2attr(tcp);
break;
case 39: /* restore fg color back to normal */
tcp->attr_mask &= ~(FG_CHANGED|BOLD_ATTR);
tcp->cur_color.fg = tcp->std_color.fg;
tcp->cur_attr = mask2attr(tcp);
break;
case 40: case 41: /* set ansi bg color */
case 42: case 43: case 44:
case 45: case 46: case 47:
tcp->attr_mask |= BG_CHANGED;
tcp->cur_color.bg = ansi_col[n - 40];
tcp->cur_attr = mask2attr(tcp);
break;
case 49: /* restore bg color back to normal */
tcp->attr_mask &= ~BG_CHANGED;
tcp->cur_color.bg = tcp->std_color.bg;
tcp->cur_attr = mask2attr(tcp);
break;
}
}
break;
case 's': /* Save cursor position */
tcp->saved_xpos = scp->xpos;
tcp->saved_ypos = scp->ypos;
break;
case 'u': /* Restore saved cursor position */
if (tcp->saved_xpos >= 0 && tcp->saved_ypos >= 0)
sc_move_cursor(scp, tcp->saved_xpos,
tcp->saved_ypos);
break;
case 'x':
if (tcp->num_param == 0)
n = 0;
else
n = tcp->param[0];
switch (n) {
case 0: /* reset colors and attributes back to normal */
tcp->attr_mask = NORMAL_ATTR;
tcp->cur_color = tcp->std_color
= tcp->dflt_std_color;
tcp->rev_color = tcp->dflt_rev_color;
tcp->cur_attr = mask2attr(tcp);
break;
case 1: /* set ansi background */
tcp->attr_mask &= ~BG_CHANGED;
tcp->cur_color.bg = tcp->std_color.bg
= ansi_col[tcp->param[1] & 0x0f];
tcp->cur_attr = mask2attr(tcp);
break;
case 2: /* set ansi foreground */
tcp->attr_mask &= ~FG_CHANGED;
tcp->cur_color.fg = tcp->std_color.fg
= ansi_col[tcp->param[1] & 0x0f];
tcp->cur_attr = mask2attr(tcp);
break;
case 3: /* set adapter attribute directly */
tcp->attr_mask &= ~(FG_CHANGED | BG_CHANGED);
tcp->cur_color.fg = tcp->std_color.fg
= tcp->param[1] & 0x0f;
tcp->cur_color.bg = tcp->std_color.bg
= (tcp->param[1] >> 4) & 0x0f;
tcp->cur_attr = mask2attr(tcp);
break;
case 5: /* set ansi reverse background */
tcp->rev_color.bg = ansi_col[tcp->param[1] & 0x0f];
tcp->cur_attr = mask2attr(tcp);
break;
case 6: /* set ansi reverse foreground */
tcp->rev_color.fg = ansi_col[tcp->param[1] & 0x0f];
tcp->cur_attr = mask2attr(tcp);
break;
case 7: /* set adapter reverse attribute directly */
tcp->rev_color.fg = tcp->param[1] & 0x0f;
tcp->rev_color.bg = (tcp->param[1] >> 4) & 0x0f;
tcp->cur_attr = mask2attr(tcp);
break;
}
break;
case 'z': /* switch to (virtual) console n */
if (tcp->num_param == 1)
sc_switch_scr(sc, tcp->param[0]);
break;
}
} else if (tcp->esc == 3) { /* seen ESC [0-9]+ = */
if (c >= '0' && c <= '9') {
if (tcp->num_param < MAX_ESC_PAR) {
if (tcp->last_param != tcp->num_param) {
tcp->last_param = tcp->num_param;
tcp->param[tcp->num_param] = 0;
} else {
tcp->param[tcp->num_param] *= 10;
}
tcp->param[tcp->num_param] += c - '0';
return;
}
}
tcp->num_param = tcp->last_param + 1;
switch (c) {
case ';':
if (tcp->num_param < MAX_ESC_PAR)
return;
break;
case 'A': /* set display border color */
if (tcp->num_param == 1) {
scp->border=tcp->param[0] & 0xff;
if (scp == sc->cur_scp)
sc_set_border(scp, scp->border);
}
break;
case 'B': /* set bell pitch and duration */
if (tcp->num_param == 2) {
scp->bell_pitch = tcp->param[0];
scp->bell_duration =
(tcp->param[1] * hz + 99) / 100;
}
break;
case 'C': /* set global/parmanent cursor type & shape */
i = spltty();
n = tcp->num_param;
v0 = tcp->param[0];
v1 = tcp->param[1];
v2 = tcp->param[2];
switch (n) {
case 1: /* flags only */
if (v0 < sizeof(cattrs)/sizeof(cattrs[0]))
v0 = cattrs[v0];
else /* backward compatibility */
v0 = cattrs[v0 & 0x3];
sc_change_cursor_shape(scp, v0, -1, -1);
break;
case 2:
v2 = 0;
v0 &= 0x1f; /* backward compatibility */
v1 &= 0x1f;
/* FALL THROUGH */
case 3: /* base and height */
if (v2 == 0) /* count from top */
sc_change_cursor_shape(scp, -1,
scp->font_size - v1 - 1,
v1 - v0 + 1);
else if (v2 == 1) /* count from bottom */
sc_change_cursor_shape(scp, -1,
v0, v1 - v0 + 1);
break;
}
splx(i);
break;
case 'F': /* set adapter foreground */
if (tcp->num_param == 1) {
tcp->attr_mask &= ~FG_CHANGED;
tcp->cur_color.fg = tcp->std_color.fg
= tcp->param[0] & 0x0f;
tcp->cur_attr = mask2attr(tcp);
}
break;
case 'G': /* set adapter background */
if (tcp->num_param == 1) {
tcp->attr_mask &= ~BG_CHANGED;
tcp->cur_color.bg = tcp->std_color.bg
= tcp->param[0] & 0x0f;
tcp->cur_attr = mask2attr(tcp);
}
break;
case 'H': /* set adapter reverse foreground */
if (tcp->num_param == 1) {
tcp->rev_color.fg = tcp->param[0] & 0x0f;
tcp->cur_attr = mask2attr(tcp);
}
break;
case 'I': /* set adapter reverse background */
if (tcp->num_param == 1) {
tcp->rev_color.bg = tcp->param[0] & 0x0f;
tcp->cur_attr = mask2attr(tcp);
}
break;
case 'S': /* set local/temporary cursor type & shape */
i = spltty();
n = tcp->num_param;
v0 = tcp->param[0];
switch (n) {
case 0:
v0 = 0;
/* FALL THROUGH */
case 1:
if (v0 < sizeof(tcattrs)/sizeof(tcattrs[0]))
sc_change_cursor_shape(scp,
tcattrs[v0], -1, -1);
break;
}
splx(i);
break;
}
#ifdef notyet
} else if (tcp->esc == 4) { /* seen ESC Q */
/* to be filled */
#endif
} else if (tcp->esc == 5) { /* seen ESC ( */
switch (c) {
case 'B': /* iso-2022: desginate ASCII into G0 */
break;
/* other items to be filled */
default:
break;
}
}
tcp->esc = 0;
}
static void
scterm_puts(scr_stat *scp, u_char *buf, int len)
{
term_stat *tcp;
tcp = scp->ts;
outloop:
scp->sc->write_in_progress++;
if (tcp->esc) {
scterm_scan_esc(scp, tcp, *buf);
buf++;
len--;
} else {
switch (*buf) {
case 0x1b:
tcp->esc = 1;
tcp->num_param = 0;
buf++;
len--;
break;
default:
sc_term_gen_print(scp, &buf, &len, tcp->cur_attr);
break;
}
}
sc_term_gen_scroll(scp, scp->sc->scr_map[0x20], tcp->cur_attr);
scp->sc->write_in_progress--;
if (len)
goto outloop;
}
static int
scterm_ioctl(scr_stat *scp, struct tty *tp, u_long cmd, caddr_t data,
struct thread *td)
{
term_stat *tcp = scp->ts;
vid_info_t *vi;
switch (cmd) {
case GIO_ATTR: /* get current attributes */
/* FIXME: */
*(int*)data = (tcp->cur_attr >> 8) & 0xff;
return 0;
case CONS_GETINFO: /* get current (virtual) console info */
vi = (vid_info_t *)data;
if (vi->size != sizeof(struct vid_info))
return EINVAL;
vi->mv_norm.fore = tcp->std_color.fg;
vi->mv_norm.back = tcp->std_color.bg;
vi->mv_rev.fore = tcp->rev_color.fg;
vi->mv_rev.back = tcp->rev_color.bg;
/*
* The other fields are filled by the upper routine. XXX
*/
return ENOIOCTL;
}
return ENOIOCTL;
}
static int
scterm_reset(scr_stat *scp, int code)
{
/* FIXME */
return 0;
}
static void
scterm_default_attr(scr_stat *scp, int color, int rev_color)
{
term_stat *tcp = scp->ts;
tcp->dflt_std_color.fg = color & 0x0f;
tcp->dflt_std_color.bg = (color >> 4) & 0x0f;
tcp->dflt_rev_color.fg = rev_color & 0x0f;
tcp->dflt_rev_color.bg = (rev_color >> 4) & 0x0f;
tcp->std_color = tcp->dflt_std_color;
tcp->rev_color = tcp->dflt_rev_color;
tcp->cur_color = tcp->std_color;
tcp->cur_attr = mask2attr(tcp);
}
static void
scterm_clear(scr_stat *scp)
{
term_stat *tcp = scp->ts;
sc_move_cursor(scp, 0, 0);
sc_vtb_clear(&scp->vtb, scp->sc->scr_map[0x20], tcp->cur_attr);
mark_all(scp);
}
static void
scterm_notify(scr_stat *scp, int event)
{
switch (event) {
case SC_TE_NOTIFY_VTSWITCH_IN:
break;
case SC_TE_NOTIFY_VTSWITCH_OUT:
break;
}
}
static int
scterm_input(scr_stat *scp, int c, struct tty *tp)
{
return FALSE;
}
/*
* Calculate hardware attributes word using logical attributes mask and
* hardware colors
*/
/* FIXME */
static int
mask2attr(term_stat *tcp)
{
int attr, mask = tcp->attr_mask;
if (mask & REVERSE_ATTR) {
attr = ((mask & FG_CHANGED) ?
tcp->cur_color.bg : tcp->rev_color.fg) |
(((mask & BG_CHANGED) ?
tcp->cur_color.fg : tcp->rev_color.bg) << 4);
} else
attr = tcp->cur_color.fg | (tcp->cur_color.bg << 4);
/* XXX: underline mapping for Hercules adapter can be better */
if (mask & (BOLD_ATTR | UNDERLINE_ATTR))
attr ^= 0x08;
if (mask & BLINK_ATTR)
attr ^= 0x80;
return (attr << 8);
}
#endif /* SC_DUMB_TERMINAL */

504
sys/dev/syscons/scterm-teken.c Normal file
View File

@ -0,0 +1,504 @@
/*-
* Copyright (c) 1999 Kazutaka YOKOTA <yokota@zodiac.mech.utsunomiya-u.ac.jp>
* All rights reserved.
*
* Copyright (c) 2008-2009 Ed Schouten <ed@FreeBSD.org>
* 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 as
* the first lines of this file unmodified.
* 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 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.
*/
#include <sys/cdefs.h>
__FBSDID("$FreeBSD$");
#include "opt_syscons.h"
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/module.h>
#include <sys/consio.h>
#if defined(__sparc64__) || defined(__powerpc__)
#include <machine/sc_machdep.h>
#else
#include <machine/pc/display.h>
#endif
#include <dev/syscons/syscons.h>
#include <dev/syscons/teken/teken.h>
static void scteken_revattr(unsigned char, teken_attr_t *);
static sc_term_init_t scteken_init;
static sc_term_term_t scteken_term;
static sc_term_puts_t scteken_puts;
static sc_term_ioctl_t scteken_ioctl;
static sc_term_default_attr_t scteken_default_attr;
static sc_term_clear_t scteken_clear;
static sc_term_input_t scteken_input;
static void scteken_nop(void);
typedef struct {
teken_t ts_teken;
int ts_busy;
} teken_stat;
static teken_stat reserved_teken_stat;
static sc_term_sw_t sc_term_scteken = {
{ NULL, NULL },
"scteken", /* emulator name */
"teken terminal", /* description */
"*", /* matching renderer */
sizeof(teken_stat), /* softc size */
0,
scteken_init,
scteken_term,
scteken_puts,
scteken_ioctl,
(sc_term_reset_t *)scteken_nop,
scteken_default_attr,
scteken_clear,
(sc_term_notify_t *)scteken_nop,
scteken_input,
};
SCTERM_MODULE(scteken, sc_term_scteken);
static tf_bell_t scteken_bell;
static tf_cursor_t scteken_cursor;
static tf_putchar_t scteken_putchar;
static tf_fill_t scteken_fill;
static tf_copy_t scteken_copy;
static tf_param_t scteken_param;
static tf_respond_t scteken_respond;
static const teken_funcs_t scteken_funcs = {
.tf_bell = scteken_bell,
.tf_cursor = scteken_cursor,
.tf_putchar = scteken_putchar,
.tf_fill = scteken_fill,
.tf_copy = scteken_copy,
.tf_param = scteken_param,
.tf_respond = scteken_respond,
};
static int
scteken_init(scr_stat *scp, void **softc, int code)
{
teken_stat *ts = scp->ts;
teken_pos_t tp;
if (*softc == NULL) {
if (reserved_teken_stat.ts_busy)
return (EINVAL);
*softc = &reserved_teken_stat;
}
ts = *softc;
switch (code) {
case SC_TE_COLD_INIT:
++sc_term_scteken.te_refcount;
ts->ts_busy = 1;
/* FALLTHROUGH */
case SC_TE_WARM_INIT:
teken_init(&ts->ts_teken, &scteken_funcs, scp);
tp.tp_row = scp->ysize;
tp.tp_col = scp->xsize;
teken_set_winsize(&ts->ts_teken, &tp);
tp.tp_row = scp->cursor_pos / scp->xsize;
tp.tp_col = scp->cursor_pos % scp->xsize;
teken_set_cursor(&ts->ts_teken, &tp);
break;
}
return (0);
}
static int
scteken_term(scr_stat *scp, void **softc)
{
if (*softc == &reserved_teken_stat) {
*softc = NULL;
reserved_teken_stat.ts_busy = 0;
}
--sc_term_scteken.te_refcount;
return (0);
}
static void
scteken_puts(scr_stat *scp, u_char *buf, int len)
{
teken_stat *ts = scp->ts;
scp->sc->write_in_progress++;
teken_input(&ts->ts_teken, buf, len);
scp->sc->write_in_progress--;
}
static int
scteken_ioctl(scr_stat *scp, struct tty *tp, u_long cmd, caddr_t data,
struct thread *td)
{
vid_info_t *vi;
switch (cmd) {
case GIO_ATTR: /* get current attributes */
*(int*)data = SC_NORM_ATTR;
return (0);
case CONS_GETINFO: /* get current (virtual) console info */
/* XXX: INCORRECT! */
vi = (vid_info_t *)data;
if (vi->size != sizeof(struct vid_info))
return EINVAL;
vi->mv_norm.fore = SC_NORM_ATTR & 0x0f;
vi->mv_norm.back = (SC_NORM_ATTR >> 4) & 0x0f;
vi->mv_rev.fore = SC_NORM_ATTR & 0x0f;
vi->mv_rev.back = (SC_NORM_ATTR >> 4) & 0x0f;
/*
* The other fields are filled by the upper routine. XXX
*/
return (ENOIOCTL);
}
return (ENOIOCTL);
}
static void
scteken_default_attr(scr_stat *scp, int color, int rev_color)
{
teken_stat *ts = scp->ts;
teken_attr_t ta;
scteken_revattr(color, &ta);
teken_set_defattr(&ts->ts_teken, &ta);
}
static void
scteken_clear(scr_stat *scp)
{
sc_move_cursor(scp, 0, 0);
sc_vtb_clear(&scp->vtb, scp->sc->scr_map[0x20], SC_NORM_ATTR << 8);
mark_all(scp);
}
static int
scteken_input(scr_stat *scp, int c, struct tty *tp)
{
return FALSE;
}
static void
scteken_nop(void)
{
}
/*
* libteken routines.
*/
static const unsigned char fgcolors_normal[TC_NCOLORS] = {
FG_BLACK, FG_RED, FG_GREEN, FG_BROWN,
FG_BLUE, FG_MAGENTA, FG_CYAN, FG_LIGHTGREY,
};
static const unsigned char fgcolors_bold[TC_NCOLORS] = {
FG_DARKGREY, FG_LIGHTRED, FG_LIGHTGREEN, FG_YELLOW,
FG_LIGHTBLUE, FG_LIGHTMAGENTA, FG_LIGHTCYAN, FG_WHITE,
};
static const unsigned char bgcolors[TC_NCOLORS] = {
BG_BLACK, BG_RED, BG_GREEN, BG_BROWN,
BG_BLUE, BG_MAGENTA, BG_CYAN, BG_LIGHTGREY,
};
static void
scteken_revattr(unsigned char color, teken_attr_t *a)
{
teken_color_t fg, bg;
/*
* XXX: Reverse conversion of syscons to teken attributes. Not
* realiable. Maybe we should turn it into a 1:1 mapping one of
* these days?
*/
a->ta_format = 0;
a->ta_fgcolor = TC_WHITE;
a->ta_bgcolor = TC_BLACK;
#ifdef FG_BLINK
if (color & FG_BLINK) {
a->ta_format |= TF_BLINK;
color &= ~FG_BLINK;
}
#endif /* FG_BLINK */
for (fg = 0; fg < TC_NCOLORS; fg++) {
for (bg = 0; bg < TC_NCOLORS; bg++) {
if ((fgcolors_normal[fg] | bgcolors[bg]) == color) {
a->ta_fgcolor = fg;
a->ta_bgcolor = bg;
return;
}
if ((fgcolors_bold[fg] | bgcolors[bg]) == color) {
a->ta_fgcolor = fg;
a->ta_bgcolor = bg;
a->ta_format |= TF_BOLD;
return;
}
}
}
}
static inline unsigned int
scteken_attr(const teken_attr_t *a)
{
unsigned int attr = 0;
if (a->ta_format & TF_BOLD)
attr |= fgcolors_bold[a->ta_fgcolor];
else
attr |= fgcolors_normal[a->ta_fgcolor];
attr |= bgcolors[a->ta_bgcolor];
#ifdef FG_UNDERLINE
if (a->ta_format & TF_UNDERLINE)
attr |= FG_UNDERLINE;
#endif /* FG_UNDERLINE */
#ifdef FG_BLINK
if (a->ta_format & TF_BLINK)
attr |= FG_BLINK;
#endif /* FG_BLINK */
return (attr << 8);
}
static void
scteken_bell(void *arg)
{
scr_stat *scp = arg;
sc_bell(scp, scp->bell_pitch, scp->bell_duration);
}
static void
scteken_cursor(void *arg, const teken_pos_t *p)
{
scr_stat *scp = arg;
sc_move_cursor(scp, p->tp_col, p->tp_row);
}
static void
scteken_putchar(void *arg, const teken_pos_t *tp, teken_char_t c,
const teken_attr_t *a)
{
scr_stat *scp = arg;
u_char *map;
u_char ch;
vm_offset_t p;
int cursor, attr;
#ifdef TEKEN_UTF8
if (c >= 0x80) {
/* XXX: Don't display UTF-8 yet. */
attr = (FG_YELLOW|BG_RED) << 8;
ch = '?';
} else
#endif /* TEKEN_UTF8 */
{
attr = scteken_attr(a);
ch = c;
}
map = scp->sc->scr_map;
cursor = tp->tp_row * scp->xsize + tp->tp_col;
p = sc_vtb_pointer(&scp->vtb, cursor);
sc_vtb_putchar(&scp->vtb, p, map[ch], attr);
mark_for_update(scp, cursor);
/*
* XXX: Why do we need this? Only marking `cursor' should be
* enough. Without this line, we get artifacts.
*/
mark_for_update(scp, imin(cursor + 1, scp->xsize * scp->ysize - 1));
}
static void
scteken_fill(void *arg, const teken_rect_t *r, teken_char_t c,
const teken_attr_t *a)
{
scr_stat *scp = arg;
u_char *map;
u_char ch;
unsigned int width;
int attr, row;
#ifdef TEKEN_UTF8
if (c >= 0x80) {
/* XXX: Don't display UTF-8 yet. */
attr = (FG_YELLOW|BG_RED) << 8;
ch = '?';
} else
#endif /* TEKEN_UTF8 */
{
attr = scteken_attr(a);
ch = c;
}
map = scp->sc->scr_map;
if (r->tr_begin.tp_col == 0 && r->tr_end.tp_col == scp->xsize) {
/* Single contiguous region to fill. */
sc_vtb_erase(&scp->vtb, r->tr_begin.tp_row * scp->xsize,
(r->tr_end.tp_row - r->tr_begin.tp_row) * scp->xsize,
map[ch], attr);
} else {
/* Fill display line by line. */
width = r->tr_end.tp_col - r->tr_begin.tp_col;
for (row = r->tr_begin.tp_row; row < r->tr_end.tp_row; row++) {
sc_vtb_erase(&scp->vtb, r->tr_begin.tp_row *
scp->xsize + r->tr_begin.tp_col,
width, map[ch], attr);
}
}
/* Mark begin and end positions to be refreshed. */
mark_for_update(scp,
r->tr_begin.tp_row * scp->xsize + r->tr_begin.tp_col);
mark_for_update(scp,
(r->tr_end.tp_row - 1) * scp->xsize + (r->tr_end.tp_col - 1));
sc_remove_cutmarking(scp);
}
static void
scteken_copy(void *arg, const teken_rect_t *r, const teken_pos_t *p)
{
scr_stat *scp = arg;
unsigned int width;
int src, dst, end;
#ifndef SC_NO_HISTORY
/*
* We count a line of input as history if we perform a copy of
* one whole line upward. In other words: if a line of text gets
* overwritten by a rectangle that's right below it.
*/
if (scp->history != NULL &&
r->tr_begin.tp_col == 0 && r->tr_end.tp_col == scp->xsize &&
r->tr_begin.tp_row == p->tp_row + 1) {
sc_hist_save_one_line(scp, p->tp_row);
}
#endif
if (r->tr_begin.tp_col == 0 && r->tr_end.tp_col == scp->xsize) {
/* Single contiguous region to copy. */
sc_vtb_move(&scp->vtb, r->tr_begin.tp_row * scp->xsize,
p->tp_row * scp->xsize,
(r->tr_end.tp_row - r->tr_begin.tp_row) * scp->xsize);
} else {
/* Copy line by line. */
width = r->tr_end.tp_col - r->tr_begin.tp_col;
if (p->tp_row < r->tr_begin.tp_row) {
/* Copy from top to bottom. */
src = r->tr_begin.tp_row * scp->xsize +
r->tr_begin.tp_col;
end = r->tr_end.tp_row * scp->xsize +
r->tr_end.tp_col;
dst = p->tp_row * scp->xsize + p->tp_col;
while (src < end) {
sc_vtb_move(&scp->vtb, src, dst, width);
src += scp->xsize;
dst += scp->xsize;
}
} else {
/* Copy from bottom to top. */
src = (r->tr_end.tp_row - 1) * scp->xsize +
r->tr_begin.tp_col;
end = r->tr_begin.tp_row * scp->xsize +
r->tr_begin.tp_col;
dst = (p->tp_row + r->tr_end.tp_row -
r->tr_begin.tp_row - 1) * scp->xsize + p->tp_col;
while (src >= end) {
sc_vtb_move(&scp->vtb, src, dst, width);
src -= scp->xsize;
dst -= scp->xsize;
}
}
}
/* Mark begin and end positions to be refreshed. */
mark_for_update(scp,
p->tp_row * scp->xsize + p->tp_col);
mark_for_update(scp,
(p->tp_row + r->tr_end.tp_row - r->tr_begin.tp_row - 1) *
scp->xsize +
(p->tp_col + r->tr_end.tp_col - r->tr_begin.tp_col - 1));
sc_remove_cutmarking(scp);
}
static void
scteken_param(void *arg, int cmd, int value)
{
scr_stat *scp = arg;
switch (cmd) {
case TP_SHOWCURSOR:
if (value) {
sc_change_cursor_shape(scp,
CONS_RESET_CURSOR|CONS_LOCAL_CURSOR, -1, -1);
} else {
sc_change_cursor_shape(scp,
CONS_HIDDEN_CURSOR|CONS_LOCAL_CURSOR, -1, -1);
}
break;
case TP_SWITCHVT:
sc_switch_scr(scp->sc, value);
break;
}
}
static void
scteken_respond(void *arg, const void *buf, size_t len)
{
scr_stat *scp = arg;
sc_respond(scp, buf, len);
}

1
sys/dev/syscons/scterm.c
View File

@ -36,7 +36,6 @@ __FBSDID("$FreeBSD$");
#include <sys/consio.h>
#include <dev/syscons/syscons.h>
#include <dev/syscons/sctermvar.h>
SET_DECLARE(scterm_set, sc_term_sw_t);

37
sys/dev/syscons/syscons.c
View File

@ -2741,6 +2741,16 @@ scinit(int unit, int flags)
init_scp(sc, sc->first_vty, scp);
sc_vtb_init(&scp->vtb, VTB_MEMORY, scp->xsize, scp->ysize,
(void *)sc_buffer, FALSE);
/* move cursors to the initial positions */
if (col >= scp->xsize)
col = 0;
if (row >= scp->ysize)
row = scp->ysize - 1;
scp->xpos = col;
scp->ypos = row;
scp->cursor_pos = scp->cursor_oldpos = row*scp->xsize + col;
if (sc_init_emulator(scp, SC_DFLT_TERM))
sc_init_emulator(scp, "*");
(*scp->tsw->te_default_attr)(scp,
@ -2764,15 +2774,6 @@ scinit(int unit, int flags)
sc_vtb_copy(&scp->scr, 0, &scp->vtb, 0, scp->xsize*scp->ysize);
#endif
/* move cursors to the initial positions */
if (col >= scp->xsize)
col = 0;
if (row >= scp->ysize)
row = scp->ysize - 1;
scp->xpos = col;
scp->ypos = row;
scp->cursor_pos = scp->cursor_oldpos = row*scp->xsize + col;
if (bios_value.cursor_end < scp->font_size)
sc->dflt_curs_attr.base = scp->font_size -
bios_value.cursor_end - 1;
@ -3569,7 +3570,7 @@ sc_show_font(scr_stat *scp, int page)
#endif /* !SC_NO_FONT_LOADING */
void
sc_paste(scr_stat *scp, u_char *p, int count)
sc_paste(scr_stat *scp, const u_char *p, int count)
{
struct tty *tp;
u_char *rmap;
@ -3583,6 +3584,22 @@ sc_paste(scr_stat *scp, u_char *p, int count)
ttydisc_rint_done(tp);
}
void
sc_respond(scr_stat *scp, const u_char *p, int count)
{
struct tty *tp;
tp = SC_DEV(scp->sc, scp->sc->cur_scp->index);
if (!tty_opened(tp))
return;
for (; count > 0; --count)
ttydisc_rint(tp, *p++, 0);
#if 0
/* XXX: we can't call ttydisc_rint_done() here! */
ttydisc_rint_done(tp);
#endif
}
void
sc_bell(scr_stat *scp, int pitch, int duration)
{

3
sys/dev/syscons/syscons.h
View File

@ -563,7 +563,8 @@ int sc_clean_up(scr_stat *scp);
int sc_switch_scr(sc_softc_t *sc, u_int next_scr);
void sc_alloc_scr_buffer(scr_stat *scp, int wait, int discard);
int sc_init_emulator(scr_stat *scp, char *name);
void sc_paste(scr_stat *scp, u_char *p, int count);
void sc_paste(scr_stat *scp, const u_char *p, int count);
void sc_respond(scr_stat *scp, const u_char *p, int count);
void sc_bell(scr_stat *scp, int pitch, int duration);
/* schistory.c */

13
sys/dev/syscons/teken/Makefile Normal file
View File

@ -0,0 +1,13 @@
# $FreeBSD$
PROG= teken_demo
SRCS= teken_demo.c teken.c teken_state.h
CLEANFILES= teken_state.h teken.log
LDADD= -lncurses -lutil
NO_MAN=
WARNS?= 6
teken_state.h: gensequences sequences
awk -f gensequences sequences > ${.TARGET}
.include <bsd.prog.mk>

157
sys/dev/syscons/teken/gensequences Normal file
View File

@ -0,0 +1,157 @@
#!/usr/bin/awk -f
#-
# Copyright (c) 2008-2009 Ed Schouten <ed@FreeBSD.org>
# 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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.
#
# $FreeBSD$
function die(msg) {
print msg;
exit 1;
}
function cchar(str) {
if (str == "^[")
return "\\x1B";
return str;
}
BEGIN {
FS = "\t+"
while (getline > 0) {
if (NF == 0 || $1 ~ /^#/)
continue;
if (NF != 3 && NF != 4)
die("Invalid line layout: " NF " columns");
split($3, sequence, " +");
nsequences = 0;
for (s in sequence)
nsequences++;
prefix = "";
l_prefix_name[""] = "teken_state_init";
for (i = 1; i < nsequences; i++) {
n = prefix sequence[i];
l_prefix_parent[n] = prefix;
l_prefix_suffix[n] = sequence[i];
if (!l_prefix_name[n])
l_prefix_name[n] = "teken_state_" ++npr;
prefix = n;
}
suffix = sequence[nsequences];
cmd = prefix suffix;
# Fill lists
if (l_cmd_name[cmd] != "")
die(cmd " already exists");
l_cmd_prefix[cmd] = prefix;
l_cmd_suffix[cmd] = suffix;
l_cmd_args[cmd] = $4;
l_cmd_abbr[cmd] = $1;
l_cmd_name[cmd] = $2;
l_cmd_c_name[cmd] = "teken_subr_" tolower($2);
gsub(" ", "_", l_cmd_c_name[cmd]);
if ($4 != "")
l_prefix_numbercmds[prefix]++;
}
print "/* Generated file. Do not edit. */";
print "";
for (p in l_prefix_name) {
if (l_prefix_name[p] != "teken_state_init")
print "static teken_state_t " l_prefix_name[p] ";";
}
for (p in l_prefix_name) {
print "";
print "/* '" p "' */";
print "static void";
print l_prefix_name[p] "(teken_t *t, teken_char_t c)";
print "{";
if (l_prefix_numbercmds[p] > 0) {
print "";
print "\tif (teken_state_numbers(t, c))";
print "\t\treturn;";
}
print "";
print "\tswitch (c) {";
for (c in l_cmd_prefix) {
if (l_cmd_prefix[c] != p)
continue;
print "\tcase '" cchar(l_cmd_suffix[c]) "': /* " l_cmd_abbr[c] ": " l_cmd_name[c] " */";
if (l_cmd_args[c] == "v") {
print "\t\t" l_cmd_c_name[c] "(t, t->t_curnum, t->t_nums);";
} else {
printf "\t\t%s(t", l_cmd_c_name[c];
split(l_cmd_args[c], args, " ");
for (a = 1; args[a] != ""; a++) {
if (args[a] == "n")
printf ", (t->t_curnum < %d || t->t_nums[%d] == 0) ? 1 : t->t_nums[%d]", a, (a - 1), (a - 1);
else if (args[a] == "r")
printf ", t->t_curnum < %d ? 0 : t->t_nums[%d]", a, (a - 1);
else
die("Invalid argument type: " args[a]);
}
print ");";
}
print "\t\tbreak;";
}
for (pc in l_prefix_parent) {
if (l_prefix_parent[pc] != p)
continue;
print "\tcase '" cchar(l_prefix_suffix[pc]) "':";
print "\t\tteken_state_switch(t, " l_prefix_name[pc] ");";
print "\t\treturn;";
}
print "\tdefault:";
if (l_prefix_name[p] == "teken_state_init") {
print "\t\tteken_subr_regular_character(t, c);";
} else {
print "\t\tteken_printf(\"Unsupported sequence in " l_prefix_name[p] ": %u\\n\", (unsigned int)c);";
}
print "\t\tbreak;";
print "\t}";
if (l_prefix_name[p] != "teken_state_init") {
print "";
print "\tteken_state_switch(t, teken_state_init);";
}
print "}";
}
}

107
sys/dev/syscons/teken/sequences Normal file
View File

@ -0,0 +1,107 @@
#-
# Copyright (c) 2008-2009 Ed Schouten <ed@FreeBSD.org>
# 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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.
#
# $FreeBSD$
# File format is as follows:
# Abbr Abbreviation of sequence name
# Name Sequence name (will be converted to C function name)
# Sequence Bytes that form the sequence
# Arguments Standard value of arguments passed to this sequence
# - `n' non-zero number (0 gets converted to 1)
# - `r' regular numeric argument
# - `v' means a variable number of arguments
# Abbr Name Sequence Arguments
CBT Cursor Backward Tabulation ^[ [ Z n
CHT Cursor Forward Tabulation ^[ [ I n
CNL Cursor Next Line ^[ [ E n
CPL Cursor Previous Line ^[ [ F n
CPR Cursor Position Report ^[ [ n r
CUB Cursor Backward ^[ [ D n
CUD Cursor Down ^[ [ B n
CUD Cursor Down ^[ [ e n
CUF Cursor Forward ^[ [ C n
CUF Cursor Forward ^[ [ a n
CUP Cursor Position ^[ [ H n n
CUP Cursor Position ^[ [ f n n
CUU Cursor Up ^[ [ A n
DA1 Primary Device Attributes ^[ [ c r
DA2 Secondary Device Attributes ^[ [ > c r
DC Delete character ^[ [ P n
DCS Device Control String ^[ P
DECALN Alignment test ^[ # 8
DECDHL Double Height Double Width Line Top ^[ # 3
DECDHL Double Height Double Width Line Bottom ^[ # 4
DECDWL Single Height Double Width Line ^[ # 6
DECKPAM Keypad application mode ^[ =
DECKPNM Keypad numeric mode ^[ >
DECRC Restore cursor ^[ 8
DECRC Restore cursor ^[ [ u
DECRM Reset DEC mode ^[ [ ? l r
DECSC Save cursor ^[ 7
DECSC Save cursor ^[ [ s
DECSM Set DEC mode ^[ [ ? h r
DECSTBM Set top and bottom margins ^[ [ r r r
DECSWL Single Height Single Width Line ^[ # 5
DL Delete line ^[ [ M n
DSR Device Status Report ^[ [ ? n r
ECH Erase character ^[ [ X n
ED Erase display ^[ [ J r
EL Erase line ^[ [ K r
HPA Horizontal Position Absolute ^[ [ G n
HPA Horizontal Position Absolute ^[ [ ` n
HTS Horizontal Tab Set ^[ H
ICH Insert character ^[ [ @ n
IL Insert line ^[ [ L n
IND Index ^[ D
NEL Next line ^[ E
RI Reverse index ^[ M
RIS Reset to Initial State ^[ c
RM Reset Mode ^[ [ l r
SCS SCS ^[ ( 0
SCS SCS ^[ ( 1
SCS SCS ^[ ( 2
SCS SCS ^[ ( A
SCS SCS ^[ ( B
SCS SCS ^[ ) 0
SCS SCS ^[ ) 1
SCS SCS ^[ ) 2
SCS SCS ^[ ) A
SCS SCS ^[ ) B
SD Pan Up ^[ [ T n
SGR Set Graphic Rendition ^[ [ m v
SM Set Mode ^[ [ h r
ST String Terminator ^[ \\
SU Pan Down ^[ [ S n
TBC Tab Clear ^[ [ g r
VPA Vertical Position Absolute ^[ [ d n
# Cons25 compatibility sequences
C25CURS Cons25 set cursor type ^[ [ = S r
C25VTSW Cons25 switch virtual terminal ^[ [ z r
# VT52 compatibility
#DECID VT52 DECID ^[ Z

386
sys/dev/syscons/teken/teken.c Normal file
View File

@ -0,0 +1,386 @@
/*-
* Copyright (c) 2008-2009 Ed Schouten <ed@FreeBSD.org>
* 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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.
*
* $FreeBSD$
*/
#include <sys/cdefs.h>
#if defined(__FreeBSD__) && defined(_KERNEL)
#include <sys/param.h>
#include <sys/lock.h>
#include <sys/systm.h>
#define teken_assert(x) MPASS(x)
#define teken_printf(x,...)
#else /* !(__FreeBSD__ && _KERNEL) */
#include <sys/types.h>
#include <assert.h>
#include <inttypes.h>
#include <stdio.h>
#include <string.h>
#define teken_assert(x) assert(x)
#define teken_printf(x,...) do { \
if (df != NULL) \
fprintf(df, x, ## __VA_ARGS__); \
} while (0)
/* debug messages */
static FILE *df;
#endif /* __FreeBSD__ && _KERNEL */
#include "teken.h"
#ifdef TEKEN_UTF8
#include "teken_wcwidth.h"
#else /* !TEKEN_UTF8 */
static inline int
teken_wcwidth(teken_char_t c)
{
return (c <= 0x1B) ? -1 : 1;
}
#endif /* TEKEN_UTF8 */
/* Private flags for teken_format_t. */
#define TF_REVERSE 0x08
/* Private flags for t_stateflags. */
#define TS_FIRSTDIGIT 0x01 /* First numeric digit in escape sequence. */
#define TS_INSERT 0x02 /* Insert mode. */
#define TS_AUTOWRAP 0x04 /* Autowrap. */
#define TS_ORIGIN 0x08 /* Origin mode. */
#define TS_WRAPPED 0x10 /* Next character should be printed on col 0. */
/* Character that blanks a cell. */
#define BLANK ' '
static teken_state_t teken_state_init;
/*
* Wrappers for hooks.
*/
static inline void
teken_funcs_bell(teken_t *t)
{
t->t_funcs->tf_bell(t->t_softc);
}
static inline void
teken_funcs_cursor(teken_t *t)
{
teken_assert(t->t_cursor.tp_row < t->t_winsize.tp_row);
teken_assert(t->t_cursor.tp_col < t->t_winsize.tp_col);
t->t_funcs->tf_cursor(t->t_softc, &t->t_cursor);
}
static inline void
teken_funcs_putchar(teken_t *t, const teken_pos_t *p, teken_char_t c,
const teken_attr_t *a)
{
teken_attr_t ta;
teken_assert(p->tp_row < t->t_winsize.tp_row);
teken_assert(p->tp_col < t->t_winsize.tp_col);
/* Apply inversion. */
if (a->ta_format & TF_REVERSE) {
ta.ta_format = a->ta_format;
ta.ta_fgcolor = a->ta_bgcolor;
ta.ta_bgcolor = a->ta_fgcolor;
a = &ta;
}
t->t_funcs->tf_putchar(t->t_softc, p, c, a);
}
static inline void
teken_funcs_fill(teken_t *t, const teken_rect_t *r,
const teken_char_t c, const teken_attr_t *a)
{
teken_attr_t ta;
teken_assert(r->tr_end.tp_row > r->tr_begin.tp_row);
teken_assert(r->tr_end.tp_row <= t->t_winsize.tp_row);
teken_assert(r->tr_end.tp_col > r->tr_begin.tp_col);
teken_assert(r->tr_end.tp_col <= t->t_winsize.tp_col);
/* Apply inversion. */
if (a->ta_format & TF_REVERSE) {
ta.ta_format = a->ta_format;
ta.ta_fgcolor = a->ta_bgcolor;
ta.ta_bgcolor = a->ta_fgcolor;
a = &ta;
}
t->t_funcs->tf_fill(t->t_softc, r, c, a);
}
static inline void
teken_funcs_copy(teken_t *t, const teken_rect_t *r, const teken_pos_t *p)
{
teken_assert(r->tr_end.tp_row > r->tr_begin.tp_row);
teken_assert(r->tr_end.tp_row <= t->t_winsize.tp_row);
teken_assert(r->tr_end.tp_col > r->tr_begin.tp_col);
teken_assert(r->tr_end.tp_col <= t->t_winsize.tp_col);
teken_assert(p->tp_row + (r->tr_end.tp_row - r->tr_begin.tp_row) <= t->t_winsize.tp_row);
teken_assert(p->tp_col + (r->tr_end.tp_col - r->tr_begin.tp_col) <= t->t_winsize.tp_col);
t->t_funcs->tf_copy(t->t_softc, r, p);
}
static inline void
teken_funcs_param(teken_t *t, int cmd, int value)
{
t->t_funcs->tf_param(t->t_softc, cmd, value);
}
static inline void
teken_funcs_respond(teken_t *t, const void *buf, size_t len)
{
t->t_funcs->tf_respond(t->t_softc, buf, len);
}
#include "teken_subr.h"
#include "teken_subr_compat.h"
/*
* Programming interface.
*/
void
teken_init(teken_t *t, const teken_funcs_t *tf, void *softc)
{
teken_pos_t tp = { .tp_row = 24, .tp_col = 80 };
#if !(defined(__FreeBSD__) && defined(_KERNEL))
df = fopen("teken.log", "w");
if (df != NULL)
setvbuf(df, NULL, _IOLBF, BUFSIZ);
#endif /* !(__FreeBSD__ && _KERNEL) */
t->t_funcs = tf;
t->t_softc = softc;
t->t_nextstate = teken_state_init;
t->t_defattr.ta_format = 0;
t->t_defattr.ta_fgcolor = TC_WHITE;
t->t_defattr.ta_bgcolor = TC_BLACK;
teken_subr_do_reset(t);
#ifdef TEKEN_UTF8
t->t_utf8_left = 0;
#endif /* TEKEN_UTF8 */
teken_set_winsize(t, &tp);
}
static void
teken_input_char(teken_t *t, teken_char_t c)
{
switch (c) {
case '\0':
break;
case '\a':
teken_subr_bell(t);
break;
case '\b':
teken_subr_backspace(t);
break;
case '\n':
case '\x0B':
teken_subr_newline(t);
break;
case '\r':
teken_subr_carriage_return(t);
break;
case '\t':
teken_subr_horizontal_tab(t);
break;
default:
t->t_nextstate(t, c);
break;
}
/* Post-processing assertions. */
teken_assert(t->t_cursor.tp_row >= t->t_originreg.ts_begin);
teken_assert(t->t_cursor.tp_row < t->t_originreg.ts_end);
teken_assert(t->t_cursor.tp_row < t->t_winsize.tp_row);
teken_assert(t->t_cursor.tp_col < t->t_winsize.tp_col);
teken_assert(t->t_saved_cursor.tp_row < t->t_winsize.tp_row);
teken_assert(t->t_saved_cursor.tp_col < t->t_winsize.tp_col);
teken_assert(t->t_scrollreg.ts_end <= t->t_winsize.tp_row);
teken_assert(t->t_scrollreg.ts_begin < t->t_scrollreg.ts_end);
/* Origin region has to be window size or the same as scrollreg. */
teken_assert((t->t_originreg.ts_begin == t->t_scrollreg.ts_begin &&
t->t_originreg.ts_end == t->t_scrollreg.ts_end) ||
(t->t_originreg.ts_begin == 0 &&
t->t_originreg.ts_end == t->t_winsize.tp_row));
}
static void
teken_input_byte(teken_t *t, unsigned char c)
{
#ifdef TEKEN_UTF8
/*
* UTF-8 handling.
*/
if ((c & 0x80) == 0x00) {
/* One-byte sequence. */
t->t_utf8_left = 0;
teken_input_char(t, c);
} else if ((c & 0xe0) == 0xc0) {
/* Two-byte sequence. */
t->t_utf8_left = 1;
t->t_utf8_partial = c & 0x1f;
} else if ((c & 0xf0) == 0xe0) {
/* Three-byte sequence. */
t->t_utf8_left = 2;
t->t_utf8_partial = c & 0x0f;
} else if ((c & 0xf8) == 0xf0) {
/* Four-byte sequence. */
t->t_utf8_left = 3;
t->t_utf8_partial = c & 0x07;
} else if ((c & 0xc0) == 0x80) {
if (t->t_utf8_left == 0)
return;
t->t_utf8_left--;
t->t_utf8_partial = (t->t_utf8_partial << 6) | (c & 0x3f);
if (t->t_utf8_left == 0) {
teken_printf("Got UTF-8 char %u\n", t->t_utf8_partial);
teken_input_char(t, t->t_utf8_partial);
}
}
#else /* !TEKEN_UTF8 */
teken_input_char(t, c);
#endif /* TEKEN_UTF8 */
}
void
teken_input(teken_t *t, const void *buf, size_t len)
{
const char *c = buf;
while (len-- > 0)
teken_input_byte(t, *c++);
}
void
teken_set_cursor(teken_t *t, const teken_pos_t *p)
{
/* XXX: bounds checking with originreg! */
teken_assert(p->tp_row < t->t_winsize.tp_row);
teken_assert(p->tp_col < t->t_winsize.tp_col);
t->t_cursor = *p;
}
void
teken_set_defattr(teken_t *t, const teken_attr_t *a)
{
t->t_curattr = t->t_saved_curattr = t->t_defattr = *a;
}
void
teken_set_winsize(teken_t *t, const teken_pos_t *p)
{
teken_assert(p->tp_col <= T_NUMCOL);
t->t_winsize = *p;
/* XXX: bounds checking with cursor/etc! */
t->t_scrollreg.ts_begin = 0;
t->t_scrollreg.ts_end = t->t_winsize.tp_row;
t->t_originreg = t->t_scrollreg;
}
/*
* State machine.
*/
static void
teken_state_switch(teken_t *t, teken_state_t *s)
{
t->t_nextstate = s;
t->t_curnum = 0;
t->t_stateflags |= TS_FIRSTDIGIT;
}
static int
teken_state_numbers(teken_t *t, teken_char_t c)
{
teken_assert(t->t_curnum < T_NUMSIZE);
if (c >= '0' && c <= '9') {
/*
* Don't do math with the default value of 1 when a
* custom number is inserted.
*/
if (t->t_stateflags & TS_FIRSTDIGIT) {
t->t_stateflags &= ~TS_FIRSTDIGIT;
t->t_nums[t->t_curnum] = 0;
} else {
t->t_nums[t->t_curnum] *= 10;
}
t->t_nums[t->t_curnum] += c - '0';
return (1);
} else if (c == ';') {
if (t->t_stateflags & TS_FIRSTDIGIT)
t->t_nums[t->t_curnum] = 0;
/* Only allow a limited set of arguments. */
if (++t->t_curnum == T_NUMSIZE) {
teken_state_switch(t, teken_state_init);
return (1);
}
t->t_stateflags |= TS_FIRSTDIGIT;
return (1);
} else {
if (t->t_stateflags & TS_FIRSTDIGIT && t->t_curnum > 0) {
/* Finish off the last empty argument. */
t->t_nums[t->t_curnum] = 0;
t->t_curnum++;
} else if ((t->t_stateflags & TS_FIRSTDIGIT) == 0) {
/* Also count the last argument. */
t->t_curnum++;
}
}
return (0);
}
#include "teken_state.h"

168
sys/dev/syscons/teken/teken.h Normal file
View File

@ -0,0 +1,168 @@
/*-
* Copyright (c) 2008-2009 Ed Schouten <ed@FreeBSD.org>
* 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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.
*
* $FreeBSD$
*/
#ifndef _TEKEN_H_
#define _TEKEN_H_
/*
* libteken: terminal emulation library.
*
* This library converts an UTF-8 stream of bytes to terminal drawing
* commands. It implements commands similar to xterm-color.
*/
#if 0
/*
* XXX: Disable UTF-8 support for now. It requires UTF-8 keyboard input
* and rendering, which we do not yet support.
*/
#define TEKEN_UTF8
#endif
#ifdef TEKEN_UTF8
typedef uint32_t teken_char_t;
#else /* !TEKEN_UTF8 */
typedef unsigned char teken_char_t;
#endif /* TEKEN_UTF8 */
typedef unsigned short teken_unit_t;
typedef unsigned char teken_format_t;
#define TF_BOLD 0x01
#define TF_UNDERLINE 0x02
#define TF_BLINK 0x04
typedef unsigned char teken_color_t;
#define TC_BLACK 0
#define TC_RED 1
#define TC_GREEN 2
#define TC_BROWN 3
#define TC_BLUE 4
#define TC_MAGENTA 5
#define TC_CYAN 6
#define TC_WHITE 7
#define TC_NCOLORS 8
typedef struct {
teken_unit_t tp_row;
teken_unit_t tp_col;
} teken_pos_t;
typedef struct {
teken_pos_t tr_begin;
teken_pos_t tr_end;
} teken_rect_t;
typedef struct {
teken_format_t ta_format;
teken_color_t ta_fgcolor;
teken_color_t ta_bgcolor;
} teken_attr_t;
typedef struct {
teken_unit_t ts_begin;
teken_unit_t ts_end;
} teken_span_t;
typedef struct __teken teken_t;
typedef void teken_state_t(teken_t *, teken_char_t);
/*
* Drawing routines supplied by the user.
*/
typedef void tf_bell_t(void *);
typedef void tf_cursor_t(void *, const teken_pos_t *);
typedef void tf_putchar_t(void *, const teken_pos_t *, teken_char_t,
const teken_attr_t *);
typedef void tf_fill_t(void *, const teken_rect_t *, teken_char_t,
const teken_attr_t *);
typedef void tf_copy_t(void *, const teken_rect_t *, const teken_pos_t *);
typedef void tf_param_t(void *, int, int);
#define TP_SHOWCURSOR 0
#define TP_CURSORKEYS 1
#define TP_KEYPADAPP 2
#define TP_AUTOREPEAT 3
#define TP_SWITCHVT 4
#define TP_132COLS 5
typedef void tf_respond_t(void *, const void *, size_t);
typedef struct {
tf_bell_t *tf_bell;
tf_cursor_t *tf_cursor;
tf_putchar_t *tf_putchar;
tf_fill_t *tf_fill;
tf_copy_t *tf_copy;
tf_param_t *tf_param;
tf_respond_t *tf_respond;
} teken_funcs_t;
/*
* Terminal state.
*/
struct __teken {
const teken_funcs_t *t_funcs;
void *t_softc;
teken_state_t *t_nextstate;
unsigned int t_stateflags;
#define T_NUMSIZE 8
unsigned int t_nums[T_NUMSIZE];
unsigned int t_curnum;
teken_pos_t t_cursor;
teken_attr_t t_curattr;
teken_pos_t t_saved_cursor;
teken_attr_t t_saved_curattr;
teken_attr_t t_defattr;
teken_pos_t t_winsize;
/* For DECSTBM. */
teken_span_t t_scrollreg;
/* For DECOM. */
teken_span_t t_originreg;
#define T_NUMCOL 160
unsigned int t_tabstops[T_NUMCOL / (sizeof(unsigned int) * 8)];
#ifdef TEKEN_UTF8
unsigned int t_utf8_left;
teken_char_t t_utf8_partial;
#endif /* TEKEN_UTF8 */
};
/* Initialize teken structure. */
void teken_init(teken_t *, const teken_funcs_t *, void *);
/* Deliver character input. */
void teken_input(teken_t *, const void *, size_t);
/* Set teken attributes. */
void teken_set_cursor(teken_t *, const teken_pos_t *);
void teken_set_defattr(teken_t *, const teken_attr_t *);
void teken_set_winsize(teken_t *, const teken_pos_t *);
#endif /* !_TEKEN_H_ */

336
sys/dev/syscons/teken/teken_demo.c Normal file
View File

@ -0,0 +1,336 @@
/*-
* Copyright (c) 2008-2009 Ed Schouten <ed@FreeBSD.org>
* 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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.
*
* $FreeBSD$
*/
#include <sys/ioctl.h>
#include <assert.h>
#include <errno.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <ncurses.h>
#if defined(__FreeBSD__)
#include <libutil.h>
#elif defined(__linux__)
#include <pty.h>
#else
#include <util.h>
#endif
#include "teken.h"
static tf_bell_t test_bell;
static tf_cursor_t test_cursor;
static tf_putchar_t test_putchar;
static tf_fill_t test_fill;
static tf_copy_t test_copy;
static tf_param_t test_param;
static tf_respond_t test_respond;
static teken_funcs_t tf = {
.tf_bell = test_bell,
.tf_cursor = test_cursor,
.tf_putchar = test_putchar,
.tf_fill = test_fill,
.tf_copy = test_copy,
.tf_param = test_param,
.tf_respond = test_respond,
};
struct pixel {
teken_char_t c;
teken_attr_t a;
};
#define NCOLS 80
#define NROWS 24
struct pixel buffer[NCOLS][NROWS];
static int ptfd;
static void
printchar(const teken_pos_t *p)
{
int y, x, attr = 0;
struct pixel *px, pt;
assert(p->tp_row < NROWS);
assert(p->tp_col < NCOLS);
getyx(stdscr, y, x);
px = &buffer[p->tp_col][p->tp_row];
if (px->c >= 0x80) {
/* Mark UTF-8 chars (we don't support it). */
px = &pt;
px->c = '?';
px->a.ta_format = TF_BOLD;
px->a.ta_fgcolor = TC_BROWN;
px->a.ta_bgcolor = TC_RED;
}
if (px->a.ta_format & TF_BOLD)
attr |= A_BOLD;
if (px->a.ta_format & TF_UNDERLINE)
attr |= A_UNDERLINE;
if (px->a.ta_format & TF_BLINK)
attr |= A_BLINK;
bkgdset(attr | COLOR_PAIR(px->a.ta_fgcolor + 8 * px->a.ta_bgcolor + 1));
mvaddch(p->tp_row, p->tp_col, px->c);
move(y, x);
}
static void
test_bell(void *s __unused)
{
beep();
}
static void
test_cursor(void *s __unused, const teken_pos_t *p)
{
move(p->tp_row, p->tp_col);
}
static void
test_putchar(void *s __unused, const teken_pos_t *p, teken_char_t c,
const teken_attr_t *a)
{
buffer[p->tp_col][p->tp_row].c = c;
buffer[p->tp_col][p->tp_row].a = *a;
printchar(p);
}
static void
test_fill(void *s, const teken_rect_t *r, teken_char_t c,
const teken_attr_t *a)
{
teken_pos_t p;
/* Braindead implementation of fill() - just call putchar(). */
for (p.tp_row = r->tr_begin.tp_row; p.tp_row < r->tr_end.tp_row; p.tp_row++)
for (p.tp_col = r->tr_begin.tp_col; p.tp_col < r->tr_end.tp_col; p.tp_col++)
test_putchar(s, &p, c, a);
}
static void
test_copy(void *s __unused, const teken_rect_t *r, const teken_pos_t *p)
{
int nrow, ncol, x, y; /* Has to be signed - >= 0 comparison */
teken_pos_t d;
/*
* Copying is a little tricky. We must make sure we do it in
* correct order, to make sure we don't overwrite our own data.
*/
nrow = r->tr_end.tp_row - r->tr_begin.tp_row;
ncol = r->tr_end.tp_col - r->tr_begin.tp_col;
if (p->tp_row < r->tr_begin.tp_row) {
/* Copy from top to bottom. */
if (p->tp_col < r->tr_begin.tp_col) {
/* Copy from left to right. */
for (y = 0; y < nrow; y++) {
d.tp_row = p->tp_row + y;
for (x = 0; x < ncol; x++) {
d.tp_col = p->tp_col + x;
buffer[d.tp_col][d.tp_row] =
buffer[r->tr_begin.tp_col + x][r->tr_begin.tp_row + y];
printchar(&d);
}
}
} else {
/* Copy from right to left. */
for (y = 0; y < nrow; y++) {
d.tp_row = p->tp_row + y;
for (x = ncol - 1; x >= 0; x--) {
d.tp_col = p->tp_col + x;
buffer[d.tp_col][d.tp_row] =
buffer[r->tr_begin.tp_col + x][r->tr_begin.tp_row + y];
printchar(&d);
}
}
}
} else {
/* Copy from bottom to top. */
if (p->tp_col < r->tr_begin.tp_col) {
/* Copy from left to right. */
for (y = nrow - 1; y >= 0; y--) {
d.tp_row = p->tp_row + y;
for (x = 0; x < ncol; x++) {
d.tp_col = p->tp_col + x;
buffer[d.tp_col][d.tp_row] =
buffer[r->tr_begin.tp_col + x][r->tr_begin.tp_row + y];
printchar(&d);
}
}
} else {
/* Copy from right to left. */
for (y = nrow - 1; y >= 0; y--) {
d.tp_row = p->tp_row + y;
for (x = ncol - 1; x >= 0; x--) {
d.tp_col = p->tp_col + x;
buffer[d.tp_col][d.tp_row] =
buffer[r->tr_begin.tp_col + x][r->tr_begin.tp_row + y];
printchar(&d);
}
}
}
}
}
static void
test_param(void *s __unused, int cmd, int value)
{
switch (cmd) {
case TP_SHOWCURSOR:
curs_set(value);
break;
case TP_KEYPADAPP:
keypad(stdscr, value ? TRUE : FALSE);
break;
}
}
static void
test_respond(void *s __unused, const void *buf, size_t len)
{
write(ptfd, buf, len);
}
static void
redraw_border(void)
{
unsigned int i;
for (i = 0; i < NROWS; i++)
mvaddch(i, NCOLS, '|');
for (i = 0; i < NCOLS; i++)
mvaddch(NROWS, i, '-');
mvaddch(NROWS, NCOLS, '+');
}
static void
redraw_all(void)
{
teken_pos_t tp;
for (tp.tp_row = 0; tp.tp_row < NROWS; tp.tp_row++)
for (tp.tp_col = 0; tp.tp_col < NCOLS; tp.tp_col++)
printchar(&tp);
redraw_border();
}
int
main(int argc __unused, char *argv[] __unused)
{
struct winsize ws;
teken_t t;
teken_pos_t tp;
fd_set rfds;
char b[256];
ssize_t bl;
const int ccolors[8] = { COLOR_BLACK, COLOR_RED, COLOR_GREEN, COLOR_YELLOW, COLOR_BLUE, COLOR_MAGENTA, COLOR_CYAN, COLOR_WHITE };
int i, j;
tp.tp_row = ws.ws_row = NROWS;
tp.tp_col = ws.ws_col = NCOLS;
switch (forkpty(&ptfd, NULL, NULL, &ws)) {
case -1:
perror("forkpty");
exit(1);
case 0:
setenv("TERM", "xterm-color", 1);
setenv("LC_CTYPE", "UTF-8", 0);
execlp("zsh", "-zsh", NULL);
execlp("bash", "-bash", NULL);
execlp("sh", "-sh", NULL);
_exit(1);
}
teken_init(&t, &tf, NULL);
teken_set_winsize(&t, &tp);
initscr();
raw();
start_color();
for (i = 0; i < 8; i++)
for (j = 0; j < 8; j++)
init_pair(i + 8 * j + 1, ccolors[i], ccolors[j]);
redraw_border();
FD_ZERO(&rfds);
for (;;) {
FD_SET(STDIN_FILENO, &rfds);
FD_SET(ptfd, &rfds);
if (select(ptfd + 1, &rfds, NULL, NULL, NULL) < 0) {
if (errno == EINTR) {
redraw_all();
refresh();
continue;
}
break;
}
if (FD_ISSET(STDIN_FILENO, &rfds)) {
bl = read(STDIN_FILENO, b, sizeof b);
if (bl <= 0)
break;
write(ptfd, b, bl);
}
if (FD_ISSET(ptfd, &rfds)) {
bl = read(ptfd, b, sizeof b);
if (bl <= 0)
break;
teken_input(&t, b, bl);
refresh();
}
}
endwin();
return (0);
}

123
sys/dev/syscons/teken/teken_stress.c Normal file
View File

@ -0,0 +1,123 @@
/*-
* Copyright (c) 2008-2009 Ed Schouten <ed@FreeBSD.org>
* 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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.
*
* $FreeBSD$
*/
#include <sys/cdefs.h>
#include <fcntl.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "teken.h"
static tf_bell_t stress_bell;
static tf_cursor_t stress_cursor;
static tf_putchar_t stress_putchar;
static tf_fill_t stress_fill;
static tf_copy_t stress_copy;
static tf_param_t stress_param;
static tf_respond_t stress_respond;
static teken_funcs_t tf = {
.tf_bell = stress_bell,
.tf_cursor = stress_cursor,
.tf_putchar = stress_putchar,
.tf_fill = stress_fill,
.tf_copy = stress_copy,
.tf_param = stress_param,
.tf_respond = stress_respond,
};
static void
stress_bell(void *s __unused)
{
}
static void
stress_cursor(void *s __unused, const teken_pos_t *p __unused)
{
}
static void
stress_putchar(void *s __unused, const teken_pos_t *p __unused,
teken_char_t c __unused, const teken_attr_t *a __unused)
{
}
static void
stress_fill(void *s __unused, const teken_rect_t *r __unused,
teken_char_t c __unused, const teken_attr_t *a __unused)
{
}
static void
stress_copy(void *s __unused, const teken_rect_t *r __unused,
const teken_pos_t *p __unused)
{
}
static void
stress_param(void *s __unused, int cmd __unused, int value __unused)
{
}
static void
stress_respond(void *s __unused, const void *buf __unused, size_t len __unused)
{
}
int
main(int argc __unused, char *argv[] __unused)
{
teken_t t;
int rnd;
unsigned int iteration = 0;
char buf[2048];
rnd = open("/dev/urandom", O_RDONLY);
if (rnd < 0) {
perror("/dev/urandom");
exit(1);
}
teken_init(&t, &tf, NULL);
for (;;) {
if (read(rnd, buf, sizeof buf) != sizeof buf) {
perror("read");
exit(1);
}
teken_input(&t, buf, sizeof buf);
iteration++;
if ((iteration % 10000) == 0)
printf("Processed %u frames\n", iteration);
}
}

1107
sys/dev/syscons/teken/teken_subr.h Normal file
View File

File diff suppressed because it is too large Load Diff

51
sys/dev/syscons/teken/teken_subr_compat.h Normal file
View File

@ -0,0 +1,51 @@
/*-
* Copyright (c) 2008-2009 Ed Schouten <ed@FreeBSD.org>
* 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 AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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.
*
* $FreeBSD$
*/
static void
teken_subr_cons25_set_cursor_type(teken_t *t, unsigned int type)
{
teken_funcs_param(t, TP_SHOWCURSOR, type != 1);
}
static void
teken_subr_cons25_switch_virtual_terminal(teken_t *t, unsigned int vt)
{
teken_funcs_param(t, TP_SWITCHVT, vt);
}
#if 0
static void
teken_subr_vt52_decid(teken_t *t)
{
const char response[] = "\x1B/Z";
teken_funcs_respond(t, response, sizeof response - 1);
}
#endif

120
sys/dev/syscons/teken/teken_wcwidth.h Normal file
View File

@ -0,0 +1,120 @@
/*
* Markus Kuhn -- 2007-05-26 (Unicode 5.0)
*
* Permission to use, copy, modify, and distribute this software
* for any purpose and without fee is hereby granted. The author
* disclaims all warranties with regard to this software.
*
* Latest version: http://www.cl.cam.ac.uk/~mgk25/ucs/wcwidth.c
*
* $FreeBSD$
*/
struct interval {
teken_char_t first;
teken_char_t last;
};
/* auxiliary function for binary search in interval table */
static int bisearch(teken_char_t ucs, const struct interval *table, int max) {
int min = 0;
int mid;
if (ucs < table[0].first || ucs > table[max].last)
return 0;
while (max >= min) {
mid = (min + max) / 2;
if (ucs > table[mid].last)
min = mid + 1;
else if (ucs < table[mid].first)
max = mid - 1;
else
return 1;
}
return 0;
}
static int teken_wcwidth(teken_char_t ucs)
{
/* sorted list of non-overlapping intervals of non-spacing characters */
/* generated by "uniset +cat=Me +cat=Mn +cat=Cf -00AD +1160-11FF +200B c" */
static const struct interval combining[] = {
{ 0x0300, 0x036F }, { 0x0483, 0x0486 }, { 0x0488, 0x0489 },
{ 0x0591, 0x05BD }, { 0x05BF, 0x05BF }, { 0x05C1, 0x05C2 },
{ 0x05C4, 0x05C5 }, { 0x05C7, 0x05C7 }, { 0x0600, 0x0603 },
{ 0x0610, 0x0615 }, { 0x064B, 0x065E }, { 0x0670, 0x0670 },
{ 0x06D6, 0x06E4 }, { 0x06E7, 0x06E8 }, { 0x06EA, 0x06ED },
{ 0x070F, 0x070F }, { 0x0711, 0x0711 }, { 0x0730, 0x074A },
{ 0x07A6, 0x07B0 }, { 0x07EB, 0x07F3 }, { 0x0901, 0x0902 },
{ 0x093C, 0x093C }, { 0x0941, 0x0948 }, { 0x094D, 0x094D },
{ 0x0951, 0x0954 }, { 0x0962, 0x0963 }, { 0x0981, 0x0981 },
{ 0x09BC, 0x09BC }, { 0x09C1, 0x09C4 }, { 0x09CD, 0x09CD },
{ 0x09E2, 0x09E3 }, { 0x0A01, 0x0A02 }, { 0x0A3C, 0x0A3C },
{ 0x0A41, 0x0A42 }, { 0x0A47, 0x0A48 }, { 0x0A4B, 0x0A4D },
{ 0x0A70, 0x0A71 }, { 0x0A81, 0x0A82 }, { 0x0ABC, 0x0ABC },
{ 0x0AC1, 0x0AC5 }, { 0x0AC7, 0x0AC8 }, { 0x0ACD, 0x0ACD },
{ 0x0AE2, 0x0AE3 }, { 0x0B01, 0x0B01 }, { 0x0B3C, 0x0B3C },
{ 0x0B3F, 0x0B3F }, { 0x0B41, 0x0B43 }, { 0x0B4D, 0x0B4D },
{ 0x0B56, 0x0B56 }, { 0x0B82, 0x0B82 }, { 0x0BC0, 0x0BC0 },
{ 0x0BCD, 0x0BCD }, { 0x0C3E, 0x0C40 }, { 0x0C46, 0x0C48 },
{ 0x0C4A, 0x0C4D }, { 0x0C55, 0x0C56 }, { 0x0CBC, 0x0CBC },
{ 0x0CBF, 0x0CBF }, { 0x0CC6, 0x0CC6 }, { 0x0CCC, 0x0CCD },
{ 0x0CE2, 0x0CE3 }, { 0x0D41, 0x0D43 }, { 0x0D4D, 0x0D4D },
{ 0x0DCA, 0x0DCA }, { 0x0DD2, 0x0DD4 }, { 0x0DD6, 0x0DD6 },
{ 0x0E31, 0x0E31 }, { 0x0E34, 0x0E3A }, { 0x0E47, 0x0E4E },
{ 0x0EB1, 0x0EB1 }, { 0x0EB4, 0x0EB9 }, { 0x0EBB, 0x0EBC },
{ 0x0EC8, 0x0ECD }, { 0x0F18, 0x0F19 }, { 0x0F35, 0x0F35 },
{ 0x0F37, 0x0F37 }, { 0x0F39, 0x0F39 }, { 0x0F71, 0x0F7E },
{ 0x0F80, 0x0F84 }, { 0x0F86, 0x0F87 }, { 0x0F90, 0x0F97 },
{ 0x0F99, 0x0FBC }, { 0x0FC6, 0x0FC6 }, { 0x102D, 0x1030 },
{ 0x1032, 0x1032 }, { 0x1036, 0x1037 }, { 0x1039, 0x1039 },
{ 0x1058, 0x1059 }, { 0x1160, 0x11FF }, { 0x135F, 0x135F },
{ 0x1712, 0x1714 }, { 0x1732, 0x1734 }, { 0x1752, 0x1753 },
{ 0x1772, 0x1773 }, { 0x17B4, 0x17B5 }, { 0x17B7, 0x17BD },
{ 0x17C6, 0x17C6 }, { 0x17C9, 0x17D3 }, { 0x17DD, 0x17DD },
{ 0x180B, 0x180D }, { 0x18A9, 0x18A9 }, { 0x1920, 0x1922 },
{ 0x1927, 0x1928 }, { 0x1932, 0x1932 }, { 0x1939, 0x193B },
{ 0x1A17, 0x1A18 }, { 0x1B00, 0x1B03 }, { 0x1B34, 0x1B34 },
{ 0x1B36, 0x1B3A }, { 0x1B3C, 0x1B3C }, { 0x1B42, 0x1B42 },
{ 0x1B6B, 0x1B73 }, { 0x1DC0, 0x1DCA }, { 0x1DFE, 0x1DFF },
{ 0x200B, 0x200F }, { 0x202A, 0x202E }, { 0x2060, 0x2063 },
{ 0x206A, 0x206F }, { 0x20D0, 0x20EF }, { 0x302A, 0x302F },
{ 0x3099, 0x309A }, { 0xA806, 0xA806 }, { 0xA80B, 0xA80B },
{ 0xA825, 0xA826 }, { 0xFB1E, 0xFB1E }, { 0xFE00, 0xFE0F },
{ 0xFE20, 0xFE23 }, { 0xFEFF, 0xFEFF }, { 0xFFF9, 0xFFFB },
{ 0x10A01, 0x10A03 }, { 0x10A05, 0x10A06 }, { 0x10A0C, 0x10A0F },
{ 0x10A38, 0x10A3A }, { 0x10A3F, 0x10A3F }, { 0x1D167, 0x1D169 },
{ 0x1D173, 0x1D182 }, { 0x1D185, 0x1D18B }, { 0x1D1AA, 0x1D1AD },
{ 0x1D242, 0x1D244 }, { 0xE0001, 0xE0001 }, { 0xE0020, 0xE007F },
{ 0xE0100, 0xE01EF }
};
/* test for 8-bit control characters */
if (ucs == 0)
return 0;
if (ucs < 32 || (ucs >= 0x7f && ucs < 0xa0))
return -1;
/* binary search in table of non-spacing characters */
if (bisearch(ucs, combining,
sizeof(combining) / sizeof(struct interval) - 1))
return 0;
/* if we arrive here, ucs is not a combining or C0/C1 control character */
return 1 +
(ucs >= 0x1100 &&
(ucs <= 0x115f || /* Hangul Jamo init. consonants */
ucs == 0x2329 || ucs == 0x232a ||
(ucs >= 0x2e80 && ucs <= 0xa4cf &&
ucs != 0x303f) || /* CJK ... Yi */
(ucs >= 0xac00 && ucs <= 0xd7a3) || /* Hangul Syllables */
(ucs >= 0xf900 && ucs <= 0xfaff) || /* CJK Compatibility Ideographs */
(ucs >= 0xfe10 && ucs <= 0xfe19) || /* Vertical forms */
(ucs >= 0xfe30 && ucs <= 0xfe6f) || /* CJK Compatibility Forms */
(ucs >= 0xff00 && ucs <= 0xff60) || /* Fullwidth Forms */
(ucs >= 0xffe0 && ucs <= 0xffe6) ||
(ucs >= 0x20000 && ucs <= 0x2fffd) ||
(ucs >= 0x30000 && ucs <= 0x3fffd)));
}

6
sys/pc98/cbus/scterm-sck.c
View File

@ -37,9 +37,7 @@
#include <machine/pc/display.h>
#include <dev/syscons/syscons.h>
#include <dev/syscons/sctermvar.h>
#ifndef SC_DUMB_TERMINAL
#include <pc98/cbus/sctermvar.h>
#define MAX_ESC_PAR 5
@ -1212,5 +1210,3 @@ mask2attr(term_stat *tcp)
return (attr << 8);
}
#endif /* SC_DUMB_TERMINAL */

0
sys/dev/syscons/sctermvar.h → sys/pc98/cbus/sctermvar.h
View File