Replace syscons terminal renderer by a new renderer that uses libteken.
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:
parent
64f91b28e2
commit
b4b1c5169d
Notes:
svn2git
2020-12-20 02:59:44 +00:00
svn path=/head/; revision=186681
@ -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
|
||||
|
@ -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
|
||||
|
@ -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
|
||||
|
@ -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
|
||||
|
@ -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
|
||||
|
@ -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
|
||||
|
@ -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 */
|
@ -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
504
sys/dev/syscons/scterm-teken.c
Normal 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);
|
||||
}
|
@ -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);
|
||||
|
||||
|
@ -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)
|
||||
{
|
||||
|
@ -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
13
sys/dev/syscons/teken/Makefile
Normal 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
157
sys/dev/syscons/teken/gensequences
Normal 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
107
sys/dev/syscons/teken/sequences
Normal 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
386
sys/dev/syscons/teken/teken.c
Normal 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
168
sys/dev/syscons/teken/teken.h
Normal 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
336
sys/dev/syscons/teken/teken_demo.c
Normal 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
123
sys/dev/syscons/teken/teken_stress.c
Normal 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
1107
sys/dev/syscons/teken/teken_subr.h
Normal file
File diff suppressed because it is too large
Load Diff
51
sys/dev/syscons/teken/teken_subr_compat.h
Normal file
51
sys/dev/syscons/teken/teken_subr_compat.h
Normal 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
120
sys/dev/syscons/teken/teken_wcwidth.h
Normal 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)));
|
||||
}
|
@ -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 */
|
||||
|
Loading…
Reference in New Issue
Block a user