Move libteken out of the syscons directory.

I initially committed libteken to sys/dev/syscons/teken, but now that
I'm working on a console driver myself, I noticed this was not a good
decision. Move it to sys/teken to make it easier for other drivers to
use a terminal emulator.

Also list teken.c in sys/conf/files, instead of listing it in all the
files.arch files separately.

11 files changed, 2897 insertions, 0 deletions

diff --git a/sys/teken/Makefile b/sys/teken/Makefile
new file mode 100644
index 0000000..cbdd12b
--- /dev/null
+++ b/sys/teken/Makefile
@@ -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>
diff --git a/sys/teken/gensequences b/sys/teken/gensequences
new file mode 100644
index 0000000..86c7979
--- /dev/null
+++ b/sys/teken/gensequences
@@ -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 "}";
+}
+
+}
diff --git a/sys/teken/sequences b/sys/teken/sequences
new file mode 100644
index 0000000..8f7bfb4
--- /dev/null
+++ b/sys/teken/sequences
@@ -0,0 +1,110 @@
+#-
+# 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
+G0SCS0	G0 SCS Special Graphics			^[ ( 0
+G0SCS1	G0 SCS US ASCII				^[ ( 1
+G0SCS2	G0 SCS Special Graphics			^[ ( 2
+G0SCSA	G0 SCS UK National			^[ ( A
+G0SCSB	G0 SCS US ASCII				^[ ( B
+G1SCS0	G1 SCS Special Graphics			^[ ) 0
+G1SCS1	G1 SCS US ASCII				^[ ) 1
+G1SCS2	G1 SCS Special Graphics			^[ ) 2
+G1SCSA	G1 SCS UK National			^[ ) A
+G1SCSB	G1 SCS US ASCII				^[ ) B
+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
+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
+C25ADBG	Cons25 set adapter background		^[ [ = G	r
+C25ADFG	Cons25 set adapter foreground		^[ [ = F	r
+C25BLPD	Cons25 set bell pitch duration		^[ [ = B	r r
+C25CURS	Cons25 set cursor type			^[ [ = S	r
+C25VTSW	Cons25 switch virtual terminal		^[ [ z		r
+
+# VT52 compatibility
+#DECID	VT52 DECID				^[ Z
diff --git a/sys/teken/teken.c b/sys/teken/teken.c
new file mode 100644
index 0000000..5a16f8d
--- /dev/null
+++ b/sys/teken/teken.c
@@ -0,0 +1,430 @@
+/*-
+ * 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 */
+#ifdef TEKEN_XTERM
+#define	teken_wcwidth(c)	((c <= 0x1B) ? -1 : 1)
+#else /* !TEKEN_XTERM */
+#define	teken_wcwidth(c)	(1)
+#endif /* TEKEN_XTERM */
+#endif /* TEKEN_UTF8 */
+
+#if defined(TEKEN_XTERM) && defined(TEKEN_UTF8)
+#include "teken_scs.h"
+#else /* !(TEKEN_XTERM && TEKEN_UTF8) */
+#define	teken_scs_process(t, c)	(c)
+#define	teken_scs_restore(t)
+#define	teken_scs_save(t)
+#define	teken_scs_set(t, g, ts)
+#define	teken_scs_switch(t, g)
+#endif /* TEKEN_XTERM && 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. */
+#ifdef TEKEN_XTERM
+#define	TS_WRAPPED	0x10	/* Next character should be printed on col 0. */
+#else /* !TEKEN_XTERM */
+#define	TS_WRAPPED	0x00	/* Simple line wrapping. */
+#endif /* TEKEN_XTERM */
+
+/* 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, unsigned 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 '\x0C':
+		teken_subr_newpage(t);
+		break;
+#if defined(TEKEN_XTERM) && defined(TEKEN_UTF8)
+	case '\x0E':
+		teken_scs_switch(t, 1);
+		break;
+	case '\x0F':
+		teken_scs_switch(t, 0);
+		break;
+#endif /* TEKEN_XTERM && TEKEN_UTF8 */
+	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 %x\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;
+}
+
+const teken_attr_t *
+teken_get_curattr(teken_t *t)
+{
+
+	return (&t->t_curattr);
+}
+
+void
+teken_set_curattr(teken_t *t, const teken_attr_t *a)
+{
+
+	t->t_curattr = *a;
+}
+
+const teken_attr_t *
+teken_get_defattr(teken_t *t)
+{
+
+	return (&t->t_defattr);
+}
+
+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)
+{
+
+	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"
diff --git a/sys/teken/teken.h b/sys/teken/teken.h
new file mode 100644
index 0000000..dd19e76
--- /dev/null
+++ b/sys/teken/teken.h
@@ -0,0 +1,184 @@
+/*-
+ * 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.
+ *
+ * Configuration switches:
+ * - TEKEN_UTF8: Enable/disable UTF-8 handling.
+ * - TEKEN_XTERM: Enable xterm-style emulation, instead of cons25.
+ */
+
+#if defined(__FreeBSD__) && defined(_KERNEL)
+#include "opt_teken.h"
+#endif /* __FreeBSD__ && _KERNEL */
+
+#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, unsigned 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
+#define	TP_SETBELLPD	6
+#define	TP_SETBELLPD_PITCH(pd)		((pd) >> 16)
+#define	TP_SETBELLPD_DURATION(pd)	((pd) & 0xffff)
+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;
+
+#if defined(TEKEN_XTERM) && defined(TEKEN_UTF8)
+typedef teken_char_t teken_scs_t(teken_char_t);
+#endif /* TEKEN_XTERM && TEKEN_UTF8 */
+
+/*
+ * 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 */
+
+#if defined(TEKEN_XTERM) && defined(TEKEN_UTF8)
+	unsigned int	 t_curscs;
+	teken_scs_t	*t_saved_curscs;
+	teken_scs_t	*t_scs[2];
+#endif /* TEKEN_XTERM && 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);
+
+/* Get/set teken attributes. */
+const teken_attr_t *teken_get_curattr(teken_t *);
+const teken_attr_t *teken_get_defattr(teken_t *);
+void	teken_set_cursor(teken_t *, const teken_pos_t *);
+void	teken_set_curattr(teken_t *, const teken_attr_t *);
+void	teken_set_defattr(teken_t *, const teken_attr_t *);
+void	teken_set_winsize(teken_t *, const teken_pos_t *);
+
+#endif /* !_TEKEN_H_ */
diff --git a/sys/teken/teken_demo.c b/sys/teken/teken_demo.c
new file mode 100644
index 0000000..02463a7
--- /dev/null
+++ b/sys/teken/teken_demo.c
@@ -0,0 +1,367 @@
+/*-
+ * 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 <locale.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
+#ifdef TEKEN_XTERM
+#define NROWS	24
+#else /* !TEKEN_XTERM */
+#define NROWS	25
+#endif /* TEKEN_XTERM */
+struct pixel buffer[NCOLS][NROWS];
+
+static int ptfd;
+
+static void
+printchar(const teken_pos_t *p)
+{
+	int y, x, attr = 0;
+	struct pixel *px;
+	char str[5] = { 0 };
+
+	assert(p->tp_row < NROWS);
+	assert(p->tp_col < NCOLS);
+
+	getyx(stdscr, y, x);
+
+ 	px = &buffer[p->tp_col][p->tp_row];
+
+	/* Convert Unicode to UTF-8. */
+#ifdef TEKEN_UTF8
+	if (px->c < 0x80) {
+		str[0] = px->c;
+	} else if (px->c < 0x800) {
+		str[0] = 0xc0 | (px->c >> 6);
+		str[1] = 0x80 | (px->c & 0x3f);
+	} else if (px->c < 0x10000) {
+		str[0] = 0xe0 | (px->c >> 12);
+		str[1] = 0x80 | ((px->c >> 6) & 0x3f);
+		str[2] = 0x80 | (px->c & 0x3f);
+	} else {
+		str[0] = 0xf0 | (px->c >> 18);
+		str[1] = 0x80 | ((px->c >> 12) & 0x3f);
+		str[2] = 0x80 | ((px->c >> 6) & 0x3f);
+		str[3] = 0x80 | (px->c & 0x3f);
+	}
+#else /* !TEKEN_UTF8 */
+	str[0] = px->c;
+#endif /* TEKEN_UTF8 */
+
+	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));
+	mvaddstr(p->tp_row, p->tp_col, str);
+
+	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, unsigned 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;
+
+#ifdef TEKEN_UTF8
+	setlocale(LC_CTYPE, "UTF-8");
+#endif /* TEKEN_UTF8 */
+
+	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:
+#ifdef TEKEN_XTERM
+		setenv("TERM", "xterm", 1);
+#else /* !TEKEN_XTERM */
+		setenv("TERM", "cons25", 1);
+#endif /* TEKEN_XTERM */
+#ifdef TEKEN_UTF8
+		setenv("LC_CTYPE", "UTF-8", 0);
+#endif /* TEKEN_UTF8 */
+		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, 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);
+}
diff --git a/sys/teken/teken_scs.h b/sys/teken/teken_scs.h
new file mode 100644
index 0000000..baeb296
--- /dev/null
+++ b/sys/teken/teken_scs.h
@@ -0,0 +1,98 @@
+/*-
+ * Copyright (c) 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_scs_set(teken_t *t, unsigned int g, teken_scs_t *ts)
+{
+
+	t->t_scs[g] = ts;
+}
+
+static void
+teken_scs_switch(teken_t *t, unsigned int g)
+{
+
+	t->t_curscs = g;
+}
+
+static void
+teken_scs_restore(teken_t *t)
+{
+
+	t->t_scs[t->t_curscs] = t->t_saved_curscs;
+}
+
+static void
+teken_scs_save(teken_t *t)
+{
+
+	t->t_saved_curscs = t->t_scs[t->t_curscs];
+}
+
+static teken_char_t
+teken_scs_process(teken_t *t, teken_char_t c)
+{
+
+	return (t->t_scs[t->t_curscs](c));
+}
+
+/* Unicode points for VT100 box drawing. */
+static const uint16_t teken_boxdrawing[31] = {
+    0x25c6, 0x2592, 0x2409, 0x240c, 0x240d, 0x240a, 0x00b0, 0x00b1,
+    0x2424, 0x240b, 0x2518, 0x2510, 0x250c, 0x2514, 0x253c, 0x23ba,
+    0x23bb, 0x2500, 0x23bc, 0x23bd, 0x251c, 0x2524, 0x2534, 0x252c,
+    0x2502, 0x2264, 0x2265, 0x03c0, 0x2260, 0x00a3, 0x00b7
+};
+
+static teken_char_t
+teken_scs_special_graphics(teken_char_t c)
+{
+
+	/* Box drawing. */
+	if (c >= '`' && c <= '~')
+		return (teken_boxdrawing[c - '`']);
+	return (c);
+}
+
+static teken_char_t
+teken_scs_uk_national(teken_char_t c)
+{
+
+	/* Pound sign. */
+	if (c == '#')
+		return (0xa3);
+	return (c);
+}
+
+static teken_char_t
+teken_scs_us_ascii(teken_char_t c)
+{
+
+	/* No processing. */
+	return (c);
+}
diff --git a/sys/teken/teken_stress.c b/sys/teken/teken_stress.c
new file mode 100644
index 0000000..40d09bf
--- /dev/null
+++ b/sys/teken/teken_stress.c
@@ -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, unsigned 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);
+	}
+}
diff --git a/sys/teken/teken_subr.h b/sys/teken/teken_subr.h
new file mode 100644
index 0000000..21982e2
--- /dev/null
+++ b/sys/teken/teken_subr.h
@@ -0,0 +1,1209 @@
+/*-
+ * 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_cursor_up(teken_t *, unsigned int);
+static void teken_subr_erase_line(teken_t *, unsigned int);
+static void teken_subr_regular_character(teken_t *, teken_char_t);
+static void teken_subr_reset_to_initial_state(teken_t *);
+static void teken_subr_save_cursor(teken_t *);
+
+static inline int
+teken_tab_isset(teken_t *t, unsigned int col)
+{
+	unsigned int b, o;
+
+	if (col >= T_NUMCOL)
+		return ((col % 8) == 0);
+
+	b = col / (sizeof(unsigned int) * 8);
+	o = col % (sizeof(unsigned int) * 8);
+
+	return (t->t_tabstops[b] & (1 << o));
+}
+
+static inline void
+teken_tab_clear(teken_t *t, unsigned int col)
+{
+	unsigned int b, o;
+
+	if (col >= T_NUMCOL)
+		return;
+
+	b = col / (sizeof(unsigned int) * 8);
+	o = col % (sizeof(unsigned int) * 8);
+
+	t->t_tabstops[b] &= ~(1 << o);
+}
+
+static inline void
+teken_tab_set(teken_t *t, unsigned int col)
+{
+	unsigned int b, o;
+
+	if (col >= T_NUMCOL)
+		return;
+
+	b = col / (sizeof(unsigned int) * 8);
+	o = col % (sizeof(unsigned int) * 8);
+
+	t->t_tabstops[b] |= 1 << o;
+}
+
+static void
+teken_tab_default(teken_t *t)
+{
+	unsigned int i;
+
+	memset(&t->t_tabstops, 0, T_NUMCOL / 8);
+
+	for (i = 8; i < T_NUMCOL; i += 8)
+		teken_tab_set(t, i);
+}
+
+static void
+teken_subr_do_scroll(teken_t *t, int amount)
+{
+	teken_rect_t tr;
+	teken_pos_t tp;
+
+	teken_assert(t->t_cursor.tp_row <= t->t_winsize.tp_row);
+	teken_assert(t->t_scrollreg.ts_end <= t->t_winsize.tp_row);
+	teken_assert(amount != 0);
+
+	/* Copy existing data 1 line up. */
+	if (amount > 0) {
+		/* Scroll down. */
+
+		/* Copy existing data up. */
+		if (t->t_scrollreg.ts_begin + amount < t->t_scrollreg.ts_end) {
+			tr.tr_begin.tp_row = t->t_scrollreg.ts_begin + amount;
+			tr.tr_begin.tp_col = 0;
+			tr.tr_end.tp_row = t->t_scrollreg.ts_end;
+			tr.tr_end.tp_col = t->t_winsize.tp_col;
+			tp.tp_row = t->t_scrollreg.ts_begin;
+			tp.tp_col = 0;
+			teken_funcs_copy(t, &tr, &tp);
+
+			tr.tr_begin.tp_row = t->t_scrollreg.ts_end - amount;
+		} else {
+			tr.tr_begin.tp_row = t->t_scrollreg.ts_begin;
+		}
+
+		/* Clear the last lines. */
+		tr.tr_begin.tp_col = 0;
+		tr.tr_end.tp_row = t->t_scrollreg.ts_end;
+		tr.tr_end.tp_col = t->t_winsize.tp_col;
+		teken_funcs_fill(t, &tr, BLANK, &t->t_curattr);
+	} else {
+		/* Scroll up. */
+		amount = -amount;
+
+		/* Copy existing data down. */
+		if (t->t_scrollreg.ts_begin + amount < t->t_scrollreg.ts_end) {
+			tr.tr_begin.tp_row = t->t_scrollreg.ts_begin;
+			tr.tr_begin.tp_col = 0;
+			tr.tr_end.tp_row = t->t_scrollreg.ts_end - amount;
+			tr.tr_end.tp_col = t->t_winsize.tp_col;
+			tp.tp_row = t->t_scrollreg.ts_begin + amount;
+			tp.tp_col = 0;
+			teken_funcs_copy(t, &tr, &tp);
+
+			tr.tr_end.tp_row = t->t_scrollreg.ts_begin + amount;
+		} else {
+			tr.tr_end.tp_row = t->t_scrollreg.ts_end;
+		}
+
+		/* Clear the first lines. */
+		tr.tr_begin.tp_row = t->t_scrollreg.ts_begin;
+		tr.tr_begin.tp_col = 0;
+		tr.tr_end.tp_col = t->t_winsize.tp_col;
+		teken_funcs_fill(t, &tr, BLANK, &t->t_curattr);
+	}
+}
+
+static ssize_t
+teken_subr_do_cpr(teken_t *t, unsigned int cmd, char response[16])
+{
+
+	switch (cmd) {
+	case 5: /* Operating status. */
+		strcpy(response, "0n");
+		return (2);
+	case 6: { /* Cursor position. */
+		int len;
+
+		len = snprintf(response, 16, "%u;%uR",
+		    (t->t_cursor.tp_row - t->t_originreg.ts_begin) + 1,
+		    t->t_cursor.tp_col + 1);
+
+		if (len >= 16)
+			return (-1);
+		return (len);
+	}
+	case 15: /* Printer status. */
+		strcpy(response, "13n");
+		return (3);
+	case 25: /* UDK status. */
+		strcpy(response, "20n");
+		return (3);
+	case 26: /* Keyboard status. */
+		strcpy(response, "27;1n");
+		return (5);
+	default:
+		teken_printf("Unknown DSR\n");
+		return (-1);
+	}
+}
+
+static void
+teken_subr_alignment_test(teken_t *t)
+{
+	teken_rect_t tr;
+
+	t->t_scrollreg.ts_begin = 0;
+	t->t_scrollreg.ts_end = t->t_winsize.tp_row;
+
+	t->t_cursor.tp_row = t->t_cursor.tp_col = 0;
+	t->t_stateflags &= ~TS_WRAPPED;
+	teken_funcs_cursor(t);
+
+	tr.tr_begin.tp_row = 0;
+	tr.tr_begin.tp_col = 0;
+	tr.tr_end = t->t_winsize;
+	teken_funcs_fill(t, &tr, 'E', &t->t_defattr);
+}
+
+static void
+teken_subr_backspace(teken_t *t)
+{
+
+#ifdef TEKEN_XTERM
+	if (t->t_cursor.tp_col == 0)
+		return;
+
+	t->t_cursor.tp_col--;
+	t->t_stateflags &= ~TS_WRAPPED;
+#else /* !TEKEN_XTERM */
+	if (t->t_cursor.tp_col == 0) {
+		if (t->t_cursor.tp_row == t->t_originreg.ts_begin)
+			return;
+		t->t_cursor.tp_row--;
+		t->t_cursor.tp_col = t->t_winsize.tp_col - 1;
+	} else {
+		t->t_cursor.tp_col--;
+	}
+#endif /* TEKEN_XTERM */
+
+	teken_funcs_cursor(t);
+}
+
+static void
+teken_subr_bell(teken_t *t)
+{
+
+	teken_funcs_bell(t);
+}
+
+static void
+teken_subr_carriage_return(teken_t *t)
+{
+
+	t->t_cursor.tp_col = 0;
+	t->t_stateflags &= ~TS_WRAPPED;
+	teken_funcs_cursor(t);
+}
+
+static void
+teken_subr_cursor_backward(teken_t *t, unsigned int ncols)
+{
+
+	if (ncols > t->t_cursor.tp_col)
+		t->t_cursor.tp_col = 0;
+	else
+		t->t_cursor.tp_col -= ncols;
+	t->t_stateflags &= ~TS_WRAPPED;
+	teken_funcs_cursor(t);
+}
+
+static void
+teken_subr_cursor_backward_tabulation(teken_t *t, unsigned int ntabs)
+{
+
+	do {
+		/* Stop when we've reached the beginning of the line. */
+		if (t->t_cursor.tp_col == 0)
+			break;
+
+		t->t_cursor.tp_col--;
+		
+		/* Tab marker set. */
+		if (teken_tab_isset(t, t->t_cursor.tp_col))
+			ntabs--;
+	} while (ntabs > 0);
+
+	teken_funcs_cursor(t);
+}
+
+static void
+teken_subr_cursor_down(teken_t *t, unsigned int nrows)
+{
+
+	if (t->t_cursor.tp_row + nrows >= t->t_scrollreg.ts_end)
+		t->t_cursor.tp_row = t->t_scrollreg.ts_end - 1;
+	else
+		t->t_cursor.tp_row += nrows;
+	t->t_stateflags &= ~TS_WRAPPED;
+	teken_funcs_cursor(t);
+}
+
+static void
+teken_subr_cursor_forward(teken_t *t, unsigned int ncols)
+{
+
+	if (t->t_cursor.tp_col + ncols >= t->t_winsize.tp_col)
+		t->t_cursor.tp_col = t->t_winsize.tp_col - 1;
+	else
+		t->t_cursor.tp_col += ncols;
+	t->t_stateflags &= ~TS_WRAPPED;
+	teken_funcs_cursor(t);
+}
+
+static void
+teken_subr_cursor_forward_tabulation(teken_t *t, unsigned int ntabs)
+{
+
+	do {
+		/* Stop when we've reached the end of the line. */
+		if (t->t_cursor.tp_col == t->t_winsize.tp_col - 1)
+			break;
+
+		t->t_cursor.tp_col++;
+		
+		/* Tab marker set. */
+		if (teken_tab_isset(t, t->t_cursor.tp_col))
+			ntabs--;
+	} while (ntabs > 0);
+
+	teken_funcs_cursor(t);
+}
+
+static void
+teken_subr_cursor_next_line(teken_t *t, unsigned int ncols)
+{
+
+	t->t_cursor.tp_col = 0;
+	teken_subr_cursor_down(t, ncols);
+}
+
+static void
+teken_subr_cursor_position(teken_t *t, unsigned int row, unsigned int col)
+{
+
+	t->t_cursor.tp_row = t->t_originreg.ts_begin + row - 1;
+	if (row >= t->t_originreg.ts_end)
+		t->t_cursor.tp_row = t->t_originreg.ts_end - 1;
+
+	t->t_cursor.tp_col = col - 1;
+	if (t->t_cursor.tp_col >= t->t_winsize.tp_col)
+		t->t_cursor.tp_col = t->t_winsize.tp_col - 1;
+
+	t->t_stateflags &= ~TS_WRAPPED;
+	teken_funcs_cursor(t);
+}
+
+static void
+teken_subr_cursor_position_report(teken_t *t, unsigned int cmd)
+{
+	char response[18] = "\x1B[";
+	ssize_t len;
+
+	len = teken_subr_do_cpr(t, cmd, response + 2);
+	if (len < 0)
+		return;
+
+	teken_funcs_respond(t, response, len + 2);
+}
+
+static void
+teken_subr_cursor_previous_line(teken_t *t, unsigned int ncols)
+{
+
+	t->t_cursor.tp_col = 0;
+	teken_subr_cursor_up(t, ncols);
+}
+
+static void
+teken_subr_cursor_up(teken_t *t, unsigned int nrows)
+{
+
+	if (t->t_scrollreg.ts_begin + nrows >= t->t_cursor.tp_row)
+		t->t_cursor.tp_row = t->t_scrollreg.ts_begin;
+	else
+		t->t_cursor.tp_row -= nrows;
+	t->t_stateflags &= ~TS_WRAPPED;
+	teken_funcs_cursor(t);
+}
+
+static void
+teken_subr_delete_character(teken_t *t, unsigned int ncols)
+{
+	teken_rect_t tr;
+
+	tr.tr_begin.tp_row = t->t_cursor.tp_row;
+	tr.tr_end.tp_row = t->t_cursor.tp_row + 1;
+	tr.tr_end.tp_col = t->t_winsize.tp_col;
+
+	if (t->t_cursor.tp_col + ncols >= t->t_winsize.tp_col) {
+		tr.tr_begin.tp_col = t->t_cursor.tp_col;
+	} else {
+		/* Copy characters to the left. */
+		tr.tr_begin.tp_col = t->t_cursor.tp_col + ncols;
+		teken_funcs_copy(t, &tr, &t->t_cursor);
+
+		tr.tr_begin.tp_col = t->t_winsize.tp_col - ncols;
+	}
+
+	/* Blank trailing columns. */
+	teken_funcs_fill(t, &tr, BLANK, &t->t_curattr);
+}
+
+static void
+teken_subr_delete_line(teken_t *t, unsigned int nrows)
+{
+	teken_rect_t tr;
+
+	tr.tr_begin.tp_col = 0;
+	tr.tr_end.tp_row = t->t_scrollreg.ts_end;
+	tr.tr_end.tp_col = t->t_winsize.tp_col;
+
+	if (t->t_cursor.tp_row + nrows >= t->t_scrollreg.ts_end) {
+		tr.tr_begin.tp_row = t->t_cursor.tp_row;
+	} else {
+		teken_pos_t tp;
+
+		/* Copy rows up. */
+		tr.tr_begin.tp_row = t->t_cursor.tp_row + nrows;
+		tp.tp_row = t->t_cursor.tp_row;
+		tp.tp_col = 0;
+		teken_funcs_copy(t, &tr, &tp);
+
+		tr.tr_begin.tp_row = t->t_scrollreg.ts_end - nrows;
+	}
+
+	/* Blank trailing rows. */
+	teken_funcs_fill(t, &tr, BLANK, &t->t_curattr);
+}
+
+static void
+teken_subr_device_control_string(teken_t *t __unused)
+{
+
+	teken_printf("device control string???\n");
+}
+
+static void
+teken_subr_device_status_report(teken_t *t, unsigned int cmd)
+{
+	char response[19] = "\x1B[?";
+	ssize_t len;
+
+	len = teken_subr_do_cpr(t, cmd, response + 3);
+	if (len < 0)
+		return;
+
+	teken_funcs_respond(t, response, len + 3);
+}
+
+static void
+teken_subr_double_height_double_width_line_top(teken_t *t __unused)
+{
+
+	teken_printf("double height double width top\n");
+}
+
+static void
+teken_subr_double_height_double_width_line_bottom(teken_t *t __unused)
+{
+
+	teken_printf("double height double width bottom\n");
+}
+
+static void
+teken_subr_erase_character(teken_t *t, unsigned int ncols)
+{
+	teken_rect_t tr;
+
+	tr.tr_begin = t->t_cursor;
+	tr.tr_end.tp_row = t->t_cursor.tp_row + 1;
+
+	if (t->t_cursor.tp_col + ncols >= t->t_winsize.tp_col)
+		tr.tr_end.tp_col = t->t_winsize.tp_col;
+	else
+		tr.tr_end.tp_col = t->t_cursor.tp_col + ncols;
+
+	teken_funcs_fill(t, &tr, BLANK, &t->t_curattr);
+}
+
+static void
+teken_subr_erase_display(teken_t *t, unsigned int mode)
+{
+	teken_rect_t r;
+
+	r.tr_begin.tp_col = 0;
+	r.tr_end.tp_col = t->t_winsize.tp_col;
+
+	switch (mode) {
+	case 1: /* Erase from the top to the cursor. */
+		teken_subr_erase_line(t, 1);
+
+		/* Erase lines above. */
+		if (t->t_cursor.tp_row == 0)
+			return;
+		r.tr_begin.tp_row = 0;
+		r.tr_end.tp_row = t->t_cursor.tp_row;
+		break;
+	case 2: /* Erase entire display. */
+		r.tr_begin.tp_row = 0;
+		r.tr_end.tp_row = t->t_winsize.tp_row;
+		break;
+	default: /* Erase from cursor to the bottom. */
+		teken_subr_erase_line(t, 0);
+
+		/* Erase lines below. */
+		if (t->t_cursor.tp_row == t->t_winsize.tp_row - 1)
+			return;
+		r.tr_begin.tp_row = t->t_cursor.tp_row + 1;
+		r.tr_end.tp_row = t->t_winsize.tp_row;
+		break;
+	}
+
+	teken_funcs_fill(t, &r, BLANK, &t->t_curattr);
+}
+
+static void
+teken_subr_erase_line(teken_t *t, unsigned int mode)
+{
+	teken_rect_t r;
+
+	r.tr_begin.tp_row = t->t_cursor.tp_row;
+	r.tr_end.tp_row = t->t_cursor.tp_row + 1;
+
+	switch (mode) {
+	case 1: /* Erase from the beginning of the line to the cursor. */
+		r.tr_begin.tp_col = 0;
+		r.tr_end.tp_col = t->t_cursor.tp_col + 1;
+		break;
+	case 2: /* Erase entire line. */
+		r.tr_begin.tp_col = 0;
+		r.tr_end.tp_col = t->t_winsize.tp_col;
+		break;
+	default: /* Erase from cursor to the end of the line. */
+		r.tr_begin.tp_col = t->t_cursor.tp_col;
+		r.tr_end.tp_col = t->t_winsize.tp_col;
+		break;
+	}
+
+	teken_funcs_fill(t, &r, BLANK, &t->t_curattr);
+}
+
+static void
+teken_subr_g0_scs_special_graphics(teken_t *t __unused)
+{
+
+	teken_scs_set(t, 0, teken_scs_special_graphics);
+}
+
+static void
+teken_subr_g0_scs_uk_national(teken_t *t __unused)
+{
+
+	teken_scs_set(t, 0, teken_scs_uk_national);
+}
+
+static void
+teken_subr_g0_scs_us_ascii(teken_t *t __unused)
+{
+
+	teken_scs_set(t, 0, teken_scs_us_ascii);
+}
+
+static void
+teken_subr_g1_scs_special_graphics(teken_t *t __unused)
+{
+
+	teken_scs_set(t, 1, teken_scs_special_graphics);
+}
+
+static void
+teken_subr_g1_scs_uk_national(teken_t *t __unused)
+{
+
+	teken_scs_set(t, 1, teken_scs_uk_national);
+}
+
+static void
+teken_subr_g1_scs_us_ascii(teken_t *t __unused)
+{
+
+	teken_scs_set(t, 1, teken_scs_us_ascii);
+}
+
+static void
+teken_subr_horizontal_position_absolute(teken_t *t, unsigned int col)
+{
+
+	t->t_cursor.tp_col = col - 1;
+	if (t->t_cursor.tp_col >= t->t_winsize.tp_col)
+		t->t_cursor.tp_col = t->t_winsize.tp_col - 1;
+
+	t->t_stateflags &= ~TS_WRAPPED;
+	teken_funcs_cursor(t);
+}
+
+static void
+teken_subr_horizontal_tab(teken_t *t)
+{
+#ifdef TEKEN_XTERM
+	teken_rect_t tr;
+
+	tr.tr_begin = t->t_cursor;
+	teken_subr_cursor_forward_tabulation(t, 1);
+	tr.tr_end.tp_row = tr.tr_begin.tp_row + 1;
+	tr.tr_end.tp_col = t->t_cursor.tp_col;
+
+	/* Blank region that we skipped. */
+	if (tr.tr_end.tp_col > tr.tr_begin.tp_col)
+		teken_funcs_fill(t, &tr, BLANK, &t->t_curattr);
+#else /* !TEKEN_XTERM */
+
+	teken_subr_cursor_forward_tabulation(t, 1);
+#endif /* TEKEN_XTERM */
+}
+
+static void
+teken_subr_horizontal_tab_set(teken_t *t)
+{
+
+	teken_tab_set(t, t->t_cursor.tp_col);
+}
+
+static void
+teken_subr_index(teken_t *t)
+{
+
+	if (t->t_cursor.tp_row < t->t_scrollreg.ts_end - 1) {
+		t->t_cursor.tp_row++;
+		t->t_stateflags &= ~TS_WRAPPED;
+		teken_funcs_cursor(t);
+	} else {
+		teken_subr_do_scroll(t, 1);
+	}
+}
+
+static void
+teken_subr_insert_character(teken_t *t, unsigned int ncols)
+{
+	teken_rect_t tr;
+
+	tr.tr_begin = t->t_cursor;
+	tr.tr_end.tp_row = t->t_cursor.tp_row + 1;
+
+	if (t->t_cursor.tp_col + ncols >= t->t_winsize.tp_col) {
+		tr.tr_end.tp_col = t->t_winsize.tp_col;
+	} else {
+		teken_pos_t tp;
+
+		/* Copy characters to the right. */
+		tr.tr_end.tp_col = t->t_winsize.tp_col - ncols;
+		tp.tp_row = t->t_cursor.tp_row;
+		tp.tp_col = t->t_cursor.tp_col + ncols;
+		teken_funcs_copy(t, &tr, &tp);
+
+		tr.tr_end.tp_col = t->t_cursor.tp_col + ncols;
+	}
+
+	/* Blank current location. */
+	teken_funcs_fill(t, &tr, BLANK, &t->t_curattr);
+}
+
+static void
+teken_subr_insert_line(teken_t *t, unsigned int nrows)
+{
+	teken_rect_t tr;
+
+	tr.tr_begin.tp_row = t->t_cursor.tp_row;
+	tr.tr_begin.tp_col = 0;
+	tr.tr_end.tp_col = t->t_winsize.tp_col;
+
+	if (t->t_cursor.tp_row + nrows >= t->t_scrollreg.ts_end) {
+		tr.tr_end.tp_row = t->t_scrollreg.ts_end;
+	} else {
+		teken_pos_t tp;
+
+		/* Copy lines down. */
+		tr.tr_end.tp_row = t->t_scrollreg.ts_end - nrows;
+		tp.tp_row = t->t_cursor.tp_row + nrows;
+		tp.tp_col = 0;
+		teken_funcs_copy(t, &tr, &tp);
+
+		tr.tr_end.tp_row = t->t_cursor.tp_row + nrows;
+	}
+
+	/* Blank current location. */
+	teken_funcs_fill(t, &tr, BLANK, &t->t_curattr);
+}
+
+static void
+teken_subr_keypad_application_mode(teken_t *t)
+{
+
+	teken_funcs_param(t, TP_KEYPADAPP, 1);
+}
+
+static void
+teken_subr_keypad_numeric_mode(teken_t *t)
+{
+
+	teken_funcs_param(t, TP_KEYPADAPP, 0);
+}
+
+static void
+teken_subr_newline(teken_t *t)
+{
+
+	t->t_cursor.tp_row++;
+
+	if (t->t_cursor.tp_row >= t->t_scrollreg.ts_end) {
+		teken_subr_do_scroll(t, 1);
+		t->t_cursor.tp_row = t->t_scrollreg.ts_end - 1;
+	}
+
+	t->t_stateflags &= ~TS_WRAPPED;
+	teken_funcs_cursor(t);
+}
+
+static void
+teken_subr_newpage(teken_t *t)
+{
+#ifdef TEKEN_XTERM
+
+	teken_subr_newline(t);
+#else /* !TEKEN_XTERM */
+	teken_rect_t tr;
+
+	tr.tr_begin.tp_row = tr.tr_begin.tp_col = 0;
+	tr.tr_end = t->t_winsize;
+	teken_funcs_fill(t, &tr, BLANK, &t->t_curattr);
+
+	t->t_cursor.tp_row = t->t_cursor.tp_col = 0;
+	teken_funcs_cursor(t);
+#endif /* TEKEN_XTERM */
+}
+
+static void
+teken_subr_next_line(teken_t *t)
+{
+
+	t->t_cursor.tp_col = 0;
+	teken_subr_newline(t);
+}
+
+static void
+teken_subr_pan_down(teken_t *t, unsigned int nrows)
+{
+
+	teken_subr_do_scroll(t, (int)nrows);
+}
+
+static void
+teken_subr_pan_up(teken_t *t, unsigned int nrows)
+{
+
+	teken_subr_do_scroll(t, -(int)nrows);
+}
+
+static void
+teken_subr_primary_device_attributes(teken_t *t, unsigned int request)
+{
+
+	if (request == 0) {
+		const char response[] = "\x1B[?1;2c";
+
+		teken_funcs_respond(t, response, sizeof response - 1);
+	} else {
+		teken_printf("Unknown DA1\n");
+	}
+}
+
+static void
+teken_subr_do_putchar(teken_t *t, const teken_pos_t *tp, teken_char_t c,
+    int width)
+{
+
+	if (t->t_stateflags & TS_INSERT &&
+	    tp->tp_col < t->t_winsize.tp_col - width) {
+		teken_rect_t ctr;
+		teken_pos_t ctp;
+
+		/* Insert mode. Move existing characters to the right. */
+		ctr.tr_begin = *tp;
+		ctr.tr_end.tp_row = tp->tp_row + 1;
+		ctr.tr_end.tp_col = t->t_winsize.tp_col - width;
+		ctp.tp_row = tp->tp_row;
+		ctp.tp_col = tp->tp_col + width;
+		teken_funcs_copy(t, &ctr, &ctp);
+	}
+
+	teken_funcs_putchar(t, tp, c, &t->t_curattr);
+}
+
+static void
+teken_subr_regular_character(teken_t *t, teken_char_t c)
+{
+	int width;
+	
+	c = teken_scs_process(t, c);
+
+	/* XXX: Don't process zero-width characters yet. */
+	width = teken_wcwidth(c);
+	if (width <= 0)
+		return;
+
+#ifdef TEKEN_XTERM
+	if (t->t_cursor.tp_col == t->t_winsize.tp_col - 1 &&
+	    (t->t_stateflags & (TS_WRAPPED|TS_AUTOWRAP)) ==
+	    (TS_WRAPPED|TS_AUTOWRAP)) {
+		teken_pos_t tp;
+
+		/* Perform line wrapping. */
+
+		if (t->t_cursor.tp_row == t->t_scrollreg.ts_end - 1) {
+			/* Perform scrolling. */
+			teken_subr_do_scroll(t, 1);
+			tp.tp_row = t->t_scrollreg.ts_end - 1;
+		} else {
+			/* No scrolling needed. */
+			tp.tp_row = t->t_cursor.tp_row + 1;
+			if (tp.tp_row == t->t_winsize.tp_row) {
+				/*
+				 * Corner case: regular character
+				 * outside scrolling region, but at the
+				 * bottom of the screen.
+				 */
+				teken_subr_do_putchar(t, &t->t_cursor,
+				    c, width);
+				return;
+			}
+		}
+
+		tp.tp_col = 0;
+		teken_subr_do_putchar(t, &tp, c, width);
+
+		t->t_cursor.tp_row = tp.tp_row;
+		t->t_cursor.tp_col = width;
+		t->t_stateflags &= ~TS_WRAPPED;
+	} else {
+		/* No line wrapping needed. */
+		teken_subr_do_putchar(t, &t->t_cursor, c, width);
+		t->t_cursor.tp_col += width;
+
+		if (t->t_cursor.tp_col >= t->t_winsize.tp_col) {
+			t->t_stateflags |= TS_WRAPPED;
+			t->t_cursor.tp_col = t->t_winsize.tp_col - 1;
+		} else {
+			t->t_stateflags &= ~TS_WRAPPED;
+		}
+	}
+#else /* !TEKEN_XTERM */
+	teken_subr_do_putchar(t, &t->t_cursor, c, width);
+	t->t_cursor.tp_col += width;
+
+	if (t->t_cursor.tp_col >= t->t_winsize.tp_col) {
+		if (t->t_cursor.tp_row == t->t_scrollreg.ts_end - 1) {
+			/* Perform scrolling. */
+			teken_subr_do_scroll(t, 1);
+		} else {
+			/* No scrolling needed. */
+			if (t->t_cursor.tp_row < t->t_winsize.tp_row - 1)
+				t->t_cursor.tp_row++;
+		}
+		t->t_cursor.tp_col = 0;
+	}
+#endif /* TEKEN_XTERM */
+
+	teken_funcs_cursor(t);
+}
+
+static void
+teken_subr_reset_dec_mode(teken_t *t, unsigned int cmd)
+{
+
+	switch (cmd) {
+	case 1: /* Cursor keys mode. */
+		teken_funcs_param(t, TP_CURSORKEYS, 0);
+		break;
+	case 2: /* DECANM: ANSI/VT52 mode. */
+		teken_printf("DECRST VT52\n");
+		break;
+	case 3: /* 132 column mode. */
+		teken_funcs_param(t, TP_132COLS, 0);
+		teken_subr_reset_to_initial_state(t);
+		break;
+	case 5: /* Inverse video. */
+		teken_printf("DECRST inverse video\n");
+		break;
+	case 6: /* Origin mode. */
+		t->t_stateflags &= ~TS_ORIGIN;
+		t->t_originreg.ts_begin = 0;
+		t->t_originreg.ts_end = t->t_winsize.tp_row;
+		t->t_cursor.tp_row = t->t_cursor.tp_col = 0;
+		t->t_stateflags &= ~TS_WRAPPED;
+		teken_funcs_cursor(t);
+		break;
+	case 7: /* Autowrap mode. */
+		t->t_stateflags &= ~TS_AUTOWRAP;
+		break;
+	case 8: /* Autorepeat mode. */
+		teken_funcs_param(t, TP_AUTOREPEAT, 0);
+		break;
+	case 25: /* Hide cursor. */
+		teken_funcs_param(t, TP_SHOWCURSOR, 0);
+		break;
+	case 40: /* Disallow 132 columns. */
+		teken_printf("DECRST allow 132\n");
+		break;
+	case 45: /* Disable reverse wraparound. */
+		teken_printf("DECRST reverse wraparound\n");
+		break;
+	case 47: /* Switch to alternate buffer. */
+		teken_printf("Switch to alternate buffer\n");
+		break;
+	default:
+		teken_printf("Unknown DECRST: %u\n", cmd);
+	}
+}
+
+static void
+teken_subr_reset_mode(teken_t *t, unsigned int cmd)
+{
+
+	switch (cmd) {
+	case 4:
+		t->t_stateflags &= ~TS_INSERT;
+		break;
+	default:
+		teken_printf("Unknown reset mode: %u\n", cmd);
+	}
+}
+
+static void
+teken_subr_do_reset(teken_t *t)
+{
+
+	t->t_curattr = t->t_defattr;
+	t->t_cursor.tp_row = t->t_cursor.tp_col = 0;
+	t->t_stateflags = TS_AUTOWRAP;
+
+	teken_scs_set(t, 0, teken_scs_us_ascii);
+	teken_scs_set(t, 1, teken_scs_us_ascii);
+	teken_scs_switch(t, 0);
+
+	teken_subr_save_cursor(t);
+	teken_tab_default(t);
+}
+
+static void
+teken_subr_reset_to_initial_state(teken_t *t)
+{
+
+	teken_subr_do_reset(t);
+	teken_subr_erase_display(t, 2);
+	teken_funcs_param(t, TP_SHOWCURSOR, 1);
+	teken_funcs_cursor(t);
+}
+
+static void
+teken_subr_restore_cursor(teken_t *t)
+{
+
+	t->t_cursor = t->t_saved_cursor;
+	t->t_curattr = t->t_saved_curattr;
+	t->t_stateflags &= ~TS_WRAPPED;
+	teken_scs_restore(t);
+	teken_funcs_cursor(t);
+}
+
+static void
+teken_subr_reverse_index(teken_t *t)
+{
+
+	if (t->t_cursor.tp_row > t->t_scrollreg.ts_begin) {
+		t->t_cursor.tp_row--;
+		t->t_stateflags &= ~TS_WRAPPED;
+		teken_funcs_cursor(t);
+	} else {
+		teken_subr_do_scroll(t, -1);
+	}
+}
+
+static void
+teken_subr_save_cursor(teken_t *t)
+{
+
+	t->t_saved_cursor = t->t_cursor;
+	t->t_saved_curattr = t->t_curattr;
+	teken_scs_save(t);
+}
+
+static void
+teken_subr_secondary_device_attributes(teken_t *t, unsigned int request)
+{
+
+	if (request == 0) {
+		const char response[] = "\x1B[>0;10;0c";
+		teken_funcs_respond(t, response, sizeof response - 1);
+	} else {
+		teken_printf("Unknown DA2\n");
+	}
+}
+
+static void
+teken_subr_set_dec_mode(teken_t *t, unsigned int cmd)
+{
+
+	switch (cmd) {
+	case 1: /* Cursor keys mode. */
+		teken_funcs_param(t, TP_CURSORKEYS, 1);
+		break;
+	case 2: /* DECANM: ANSI/VT52 mode. */
+		teken_printf("DECSET VT52\n");
+		break;
+	case 3: /* 132 column mode. */
+		teken_funcs_param(t, TP_132COLS, 1);
+		teken_subr_reset_to_initial_state(t);
+		break;
+	case 5: /* Inverse video. */
+		teken_printf("DECSET inverse video\n");
+		break;
+	case 6: /* Origin mode. */
+		t->t_stateflags |= TS_ORIGIN;
+		t->t_originreg = t->t_scrollreg;
+		t->t_cursor.tp_row = t->t_scrollreg.ts_begin;
+		t->t_cursor.tp_col = 0;
+		t->t_stateflags &= ~TS_WRAPPED;
+		teken_funcs_cursor(t);
+		break;
+	case 7: /* Autowrap mode. */
+		t->t_stateflags |= TS_AUTOWRAP;
+		break;
+	case 8: /* Autorepeat mode. */
+		teken_funcs_param(t, TP_AUTOREPEAT, 1);
+		break;
+	case 25: /* Display cursor. */
+		teken_funcs_param(t, TP_SHOWCURSOR, 1);
+		break;
+	case 40: /* Allow 132 columns. */
+		teken_printf("DECSET allow 132\n");
+		break;
+	case 45: /* Enable reverse wraparound. */
+		teken_printf("DECSET reverse wraparound\n");
+		break;
+	case 47: /* Switch to alternate buffer. */
+		teken_printf("Switch away from alternate buffer\n");
+		break;
+	default:
+		teken_printf("Unknown DECSET: %u\n", cmd);
+	}
+}
+
+static void
+teken_subr_set_mode(teken_t *t, unsigned int cmd)
+{
+
+	switch (cmd) {
+	case 4:
+		teken_printf("Insert mode\n");
+		t->t_stateflags |= TS_INSERT;
+		break;
+	default:
+		teken_printf("Unknown set mode: %u\n", cmd);
+	}
+}
+
+static void
+teken_subr_set_graphic_rendition(teken_t *t, unsigned int ncmds,
+    unsigned int cmds[])
+{
+	unsigned int i, n;
+
+	/* No attributes means reset. */
+	if (ncmds == 0) {
+		t->t_curattr = t->t_defattr;
+		return;
+	}
+
+	for (i = 0; i < ncmds; i++) {
+		n = cmds[i];
+
+		switch (n) {
+		case 0: /* Reset. */
+			t->t_curattr = t->t_defattr;
+			break;
+		case 1: /* Bold. */
+			t->t_curattr.ta_format |= TF_BOLD;
+			break;
+		case 4: /* Underline. */
+			t->t_curattr.ta_format |= TF_UNDERLINE;
+			break;
+		case 5: /* Blink. */
+			t->t_curattr.ta_format |= TF_BLINK;
+			break;
+		case 7: /* Reverse. */
+			t->t_curattr.ta_format |= TF_REVERSE;
+			break;
+		case 22: /* Remove bold. */
+			t->t_curattr.ta_format &= ~TF_BOLD;
+			break;
+		case 24: /* Remove underline. */
+			t->t_curattr.ta_format &= ~TF_UNDERLINE;
+			break;
+		case 25: /* Remove blink. */
+			t->t_curattr.ta_format &= ~TF_BLINK;
+			break;
+		case 27: /* Remove reverse. */
+			t->t_curattr.ta_format &= ~TF_REVERSE;
+			break;
+		case 30: /* Set foreground color: black */
+		case 31: /* Set foreground color: red */
+		case 32: /* Set foreground color: green */
+		case 33: /* Set foreground color: brown */
+		case 34: /* Set foreground color: blue */
+		case 35: /* Set foreground color: magenta */
+		case 36: /* Set foreground color: cyan */
+		case 37: /* Set foreground color: white */
+			t->t_curattr.ta_fgcolor = n - 30;
+			break;
+		case 39: /* Set default foreground color. */
+			t->t_curattr.ta_fgcolor = t->t_defattr.ta_fgcolor;
+			break;
+		case 40: /* Set background color: black */
+		case 41: /* Set background color: red */
+		case 42: /* Set background color: green */
+		case 43: /* Set background color: brown */
+		case 44: /* Set background color: blue */
+		case 45: /* Set background color: magenta */
+		case 46: /* Set background color: cyan */
+		case 47: /* Set background color: white */
+			t->t_curattr.ta_bgcolor = n - 40;
+			break;
+		case 49: /* Set default background color. */
+			t->t_curattr.ta_bgcolor = t->t_defattr.ta_bgcolor;
+			break;
+		default:
+			teken_printf("unsupported attribute %u\n", n);
+		}
+	}
+}
+
+static void
+teken_subr_set_top_and_bottom_margins(teken_t *t, unsigned int top,
+    unsigned int bottom)
+{
+
+	/* Adjust top row number. */
+	if (top > 0)
+		top--;
+	/* Adjust bottom row number. */
+	if (bottom == 0 || bottom > t->t_winsize.tp_row)
+		bottom = t->t_winsize.tp_row;
+
+	/* Invalid arguments. */
+	if (top >= bottom - 1) {
+		top = 0;
+		bottom = t->t_winsize.tp_row;
+	}
+
+	t->t_scrollreg.ts_begin = top;
+	t->t_scrollreg.ts_end = bottom;
+	if (t->t_stateflags & TS_ORIGIN) {
+		/* XXX: home cursor? */
+		t->t_originreg = t->t_scrollreg;
+		t->t_cursor.tp_row = t->t_originreg.ts_begin;
+		t->t_cursor.tp_col = 0;
+		t->t_stateflags &= ~TS_WRAPPED;
+		teken_funcs_cursor(t);
+	}
+}
+
+static void
+teken_subr_single_height_double_width_line(teken_t *t __unused)
+{
+
+	teken_printf("single height double width???\n");
+}
+
+static void
+teken_subr_single_height_single_width_line(teken_t *t __unused)
+{
+
+	teken_printf("single height single width???\n");
+}
+
+static void
+teken_subr_string_terminator(teken_t *t __unused)
+{
+
+	teken_printf("string terminator???\n");
+}
+
+static void
+teken_subr_tab_clear(teken_t *t, unsigned int cmd)
+{
+
+	switch (cmd) {
+	case 0:
+		teken_tab_clear(t, t->t_cursor.tp_col);
+		break;
+	case 3:
+		memset(&t->t_tabstops, 0, T_NUMCOL / 8);
+		break;
+	}
+}
+
+static void
+teken_subr_vertical_position_absolute(teken_t *t, unsigned int row)
+{
+
+	t->t_cursor.tp_row = t->t_originreg.ts_begin + row - 1;
+	if (row >= t->t_originreg.ts_end)
+		t->t_cursor.tp_row = t->t_originreg.ts_end - 1;
+
+
+	t->t_stateflags &= ~TS_WRAPPED;
+	teken_funcs_cursor(t);
+}
diff --git a/sys/teken/teken_subr_compat.h b/sys/teken/teken_subr_compat.h
new file mode 100644
index 0000000..4e03c66
--- /dev/null
+++ b/sys/teken/teken_subr_compat.h
@@ -0,0 +1,86 @@
+/*-
+ * 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 const teken_color_t cons25_colors[8] = { TC_BLACK, TC_BLUE,
+    TC_GREEN, TC_CYAN, TC_RED, TC_MAGENTA, TC_BROWN, TC_WHITE };
+
+static void
+teken_subr_cons25_set_adapter_background(teken_t *t, unsigned int c)
+{
+
+	t->t_defattr.ta_bgcolor = cons25_colors[c % 8];
+	t->t_curattr.ta_bgcolor = cons25_colors[c % 8];
+}
+
+static void
+teken_subr_cons25_set_adapter_foreground(teken_t *t, unsigned int c)
+{
+
+	t->t_defattr.ta_fgcolor = cons25_colors[c % 8];
+	t->t_curattr.ta_fgcolor = cons25_colors[c % 8];
+	if (c >= 8) {
+		t->t_defattr.ta_format |= TF_BOLD;
+		t->t_curattr.ta_format |= TF_BOLD;
+	} else {
+		t->t_defattr.ta_format &= ~TF_BOLD;
+		t->t_curattr.ta_format &= ~TF_BOLD;
+	}
+}
+
+static void
+teken_subr_cons25_switch_virtual_terminal(teken_t *t, unsigned int vt)
+{
+
+	teken_funcs_param(t, TP_SWITCHVT, vt);
+}
+
+static void
+teken_subr_cons25_set_bell_pitch_duration(teken_t *t, unsigned int pitch,
+    unsigned int duration)
+{
+
+	teken_funcs_param(t, TP_SETBELLPD, (pitch << 16) |
+	    (duration & 0xffff));
+}
+
+#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
diff --git a/sys/teken/teken_wcwidth.h b/sys/teken/teken_wcwidth.h
new file mode 100644
index 0000000..838fb3d
--- /dev/null
+++ b/sys/teken/teken_wcwidth.h
@@ -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)));
+}