birdterm

birdterm - mrgrouse's fork of suckless' st.
Log | Files | Refs | README | LICENSE
commit 6124cd411fd10b40fc442026524bc94c6ebffa3c
parent caec1f7db31838337a21b667ee8eaadfa0ced198
Author: mrgrouse <bdmfegys@duck.com>
Date:   Thu,  3 Jul 2025 21:08:56 -0400

migrate to birdterm rename

Diffstat:

MMakefile | 46+++++++++++++++++++++++-----------------------


Abirdterm.1 | 177+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


Abirdterm.c | 2682+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


Rst.h -> birdterm.h | 0


Abirdterm.info | 243+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


Mconfig.mk | 2+-


Dst.1 | 177-------------------------------------------------------------------------------


Dst.c | 2682-------------------------------------------------------------------------------


Dst.info | 243-------------------------------------------------------------------------------


Mx.c | 2+-


10 files changed, 3127 insertions(+), 3127 deletions(-)

diff --git a/Makefile b/Makefile
@@ -1,13 +1,13 @@
-# st - simple terminal
+# birdterm - simple terminal for birds
 # See LICENSE file for copyright and license details.
 .POSIX:
 
 include config.mk
 
-SRC = st.c x.c
+SRC = birdterm.c x.c
 OBJ = $(SRC:.c=.o)
 
-all: st
+all: birdterm
 
 config.h:
 	cp config.def.h config.h
@@ -15,37 +15,37 @@ config.h:
 .c.o:
 	$(CC) $(STCFLAGS) -c $<
 
-st.o: config.h st.h win.h
-x.o: arg.h config.h st.h win.h
+birdterm.o: config.h birdterm.h win.h
+x.o: arg.h config.h birdterm.h win.h
 
 $(OBJ): config.h config.mk
 
-st: $(OBJ)
+birdterm: $(OBJ)
 	$(CC) -o $@ $(OBJ) $(STLDFLAGS)
 
 clean:
-	rm -f st $(OBJ) st-$(VERSION).tar.gz
+	rm -f birdterm $(OBJ) birdterm-$(VERSION).tar.gz
 
-dist: clean
-	mkdir -p st-$(VERSION)
+dibirdterm: clean
+	mkdir -p birdterm-$(VERSION)
 	cp -R FAQ LEGACY TODO LICENSE Makefile README config.mk\
-		config.def.h st.info st.1 arg.h st.h win.h $(SRC)\
-		st-$(VERSION)
-	tar -cf - st-$(VERSION) | gzip > st-$(VERSION).tar.gz
-	rm -rf st-$(VERSION)
+		config.def.h birdterm.info birdterm.1 arg.h birdterm.h win.h $(SRC)\
+		birdterm-$(VERSION)
+	tar -cf - birdterm-$(VERSION) | gzip > birdterm-$(VERSION).tar.gz
+	rm -rf birdterm-$(VERSION)
 
-install: st
+install: birdterm
 	mkdir -p $(DESTDIR)$(PREFIX)/bin
-	cp -f st $(DESTDIR)$(PREFIX)/bin
-	chmod 755 $(DESTDIR)$(PREFIX)/bin/st
+	cp -f birdterm $(DESTDIR)$(PREFIX)/bin
+	chmod 755 $(DESTDIR)$(PREFIX)/bin/birdterm
 	mkdir -p $(DESTDIR)$(MANPREFIX)/man1
-	sed "s/VERSION/$(VERSION)/g" < st.1 > $(DESTDIR)$(MANPREFIX)/man1/st.1
-	chmod 644 $(DESTDIR)$(MANPREFIX)/man1/st.1
-	tic -sx st.info
-	@echo Please see the README file regarding the terminfo entry of st.
+	sed "s/VERSION/$(VERSION)/g" < birdterm.1 > $(DESTDIR)$(MANPREFIX)/man1/birdterm.1
+	chmod 644 $(DESTDIR)$(MANPREFIX)/man1/birdterm.1
+	tic -sx birdterm.info
+	@echo Please see the README file regarding the terminfo entry of birdterm.
 
 uninstall:
-	rm -f $(DESTDIR)$(PREFIX)/bin/st
-	rm -f $(DESTDIR)$(MANPREFIX)/man1/st.1
+	rm -f $(DESTDIR)$(PREFIX)/bin/birdterm
+	rm -f $(DESTDIR)$(MANPREFIX)/man1/birdterm.1
 
-.PHONY: all clean dist install uninstall
+.PHONY: all clean dibirdterm install uninstall
diff --git a/birdterm.1 b/birdterm.1
@@ -0,0 +1,177 @@
+.TH BIRDTERM 1 birdterm\-VERSION
+.SH NAME
+birdterm \- simple terminal for birds
+.SH SYNOPSIS
+.B birdterm
+.RB [ \-aiv ]
+.RB [ \-c
+.IR class ]
+.RB [ \-f
+.IR font ]
+.RB [ \-g
+.IR geometry ]
+.RB [ \-n
+.IR name ]
+.RB [ \-o
+.IR iofile ]
+.RB [ \-T
+.IR title ]
+.RB [ \-t
+.IR title ]
+.RB [ \-l
+.IR line ]
+.RB [ \-w
+.IR windowid ]
+.RB [[ \-e ]
+.IR command
+.RI [ arguments ...]]
+.PP
+.B birdterm
+.RB [ \-aiv ]
+.RB [ \-c
+.IR class ]
+.RB [ \-f
+.IR font ]
+.RB [ \-g
+.IR geometry ]
+.RB [ \-n
+.IR name ]
+.RB [ \-o
+.IR iofile ]
+.RB [ \-T
+.IR title ]
+.RB [ \-t
+.IR title ]
+.RB [ \-w
+.IR windowid ]
+.RB \-l
+.IR line
+.RI [ stty_args ...]
+.SH DESCRIPTION
+.B birdterm
+is a simple terminal emulator.
+.SH OPTIONS
+.TP
+.B \-a
+disable alternate screens in terminal
+.TP
+.BI \-c " class"
+defines the window class (default $TERM).
+.TP
+.BI \-f " font"
+defines the
+.I font
+to use when birdterm is run.
+.TP
+.BI \-g " geometry"
+defines the X11 geometry string.
+The form is [=][<cols>{xX}<rows>][{+-}<xoffset>{+-}<yoffset>]. See
+.BR XParseGeometry (3)
+for further details.
+.TP
+.B \-i
+will fixate the position given with the -g option.
+.TP
+.BI \-n " name"
+defines the window instance name (default $TERM).
+.TP
+.BI \-o " iofile"
+writes all the I/O to
+.I iofile.
+This feature is useful when recording birdterm sessions. A value of "-" means
+standard output.
+.TP
+.BI \-T " title"
+defines the window title (default 'birdterm').
+.TP
+.BI \-t " title"
+defines the window title (default 'birdterm').
+.TP
+.BI \-w " windowid"
+embeds birdterm within the window identified by
+.I windowid
+.TP
+.BI \-l " line"
+use a tty
+.I line
+instead of a pseudo terminal.
+.I line
+should be a (pseudo-)serial device (e.g. /dev/ttyS0 on Linux for serial port
+0).
+When this flag is given
+remaining arguments are used as flags for
+.BR stty(1).
+By default birdterm initializes the serial line to 8 bits, no parity, 1 stop bit
+and a 38400 baud rate. The speed is set by appending it as last argument
+(e.g. 'birdterm -l /dev/ttyS0 115200'). Arguments before the last one are
+.BR stty(1)
+flags. If you want to set odd parity on 115200 baud use for example 'birdterm -l
+/dev/ttyS0 parenb parodd 115200'. Set the number of bits by using for
+example 'birdterm -l /dev/ttyS0 cs7 115200'. See
+.BR stty(1)
+for more arguments and cases.
+.TP
+.B \-v
+prints version information to stderr, then exits.
+.TP
+.BI \-e " command " [ " arguments " "... ]"
+birdterm executes
+.I command
+instead of the shell.  If this is used it
+.B must be the last option
+on the command line, as in xterm / rxvt.
+This option is only intended for compatibility,
+and all the remaining arguments are used as a command
+even without it.
+.SH SHORTCUTS
+.TP
+.B Break
+Send a break in the serial line.
+Break key is obtained in PC keyboards
+pressing at the same time control and pause.
+.TP
+.B Ctrl-Print Screen
+Toggle if birdterm should print to the
+.I iofile.
+.TP
+.B Shift-Print Screen
+Print the full screen to the
+.I iofile.
+.TP
+.B Print Screen
+Print the selection to the
+.I iofile.
+.TP
+.B Ctrl-Shift-Page Up
+Increase font size.
+.TP
+.B Ctrl-Shift-Page Down
+Decrease font size.
+.TP
+.B Ctrl-Shift-Home
+Reset to default font size.
+.TP
+.B Ctrl-Shift-y
+Paste from primary selection (middle mouse button).
+.TP
+.B Ctrl-Shift-c
+Copy the selected text to the clipboard selection.
+.TP
+.B Ctrl-Shift-v
+Paste from the clipboard selection.
+.SH CUSTOMIZATION
+.B birdterm
+can be customized by creating a custom config.h and (re)compiling the source
+code. This keeps it fast, secure and simple.
+.SH AUTHORS
+See the LICENSE file for the authors.
+.SH LICENSE
+See the LICENSE file for the terms of redistribution.
+.SH SEE ALSO
+.BR tabbed (1),
+.BR utmp (1),
+.BR stty (1),
+.BR scroll (1)
+.SH BUGS
+See the TODO file in the distribution.
+
diff --git a/birdterm.c b/birdterm.c
@@ -0,0 +1,2682 @@
+/* See LICENSE for license details. */
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <pwd.h>
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/ioctl.h>
+#include <sys/select.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <termios.h>
+#include <unistd.h>
+#include <wchar.h>
+
+#include "birdterm.h"
+#include "win.h"
+
+#if   defined(__linux)
+ #include <pty.h>
+#elif defined(__OpenBSD__) || defined(__NetBSD__) || defined(__APPLE__)
+ #include <util.h>
+#elif defined(__FreeBSD__) || defined(__DragonFly__)
+ #include <libutil.h>
+#endif
+
+/* Arbitrary sizes */
+#define UTF_INVALID   0xFFFD
+#define UTF_SIZ       4
+#define ESC_BUF_SIZ   (128*UTF_SIZ)
+#define ESC_ARG_SIZ   16
+#define STR_BUF_SIZ   ESC_BUF_SIZ
+#define STR_ARG_SIZ   ESC_ARG_SIZ
+
+/* macros */
+#define IS_SET(flag)		((term.mode & (flag)) != 0)
+#define ISCONTROLC0(c)		(BETWEEN(c, 0, 0x1f) || (c) == 0x7f)
+#define ISCONTROLC1(c)		(BETWEEN(c, 0x80, 0x9f))
+#define ISCONTROL(c)		(ISCONTROLC0(c) || ISCONTROLC1(c))
+#define ISDELIM(u)		(u && wcschr(worddelimiters, u))
+
+enum term_mode {
+	MODE_WRAP        = 1 << 0,
+	MODE_INSERT      = 1 << 1,
+	MODE_ALTSCREEN   = 1 << 2,
+	MODE_CRLF        = 1 << 3,
+	MODE_ECHO        = 1 << 4,
+	MODE_PRINT       = 1 << 5,
+	MODE_UTF8        = 1 << 6,
+};
+
+enum cursor_movement {
+	CURSOR_SAVE,
+	CURSOR_LOAD
+};
+
+enum cursor_state {
+	CURSOR_DEFAULT  = 0,
+	CURSOR_WRAPNEXT = 1,
+	CURSOR_ORIGIN   = 2
+};
+
+enum charset {
+	CS_GRAPHIC0,
+	CS_GRAPHIC1,
+	CS_UK,
+	CS_USA,
+	CS_MULTI,
+	CS_GER,
+	CS_FIN
+};
+
+enum escape_state {
+	ESC_START      = 1,
+	ESC_CSI        = 2,
+	ESC_STR        = 4,  /* DCS, OSC, PM, APC */
+	ESC_ALTCHARSET = 8,
+	ESC_STR_END    = 16, /* a final string was encountered */
+	ESC_TEST       = 32, /* Enter in test mode */
+	ESC_UTF8       = 64,
+};
+
+typedef struct {
+	Glyph attr; /* current char attributes */
+	int x;
+	int y;
+	char state;
+} TCursor;
+
+typedef struct {
+	int mode;
+	int type;
+	int snap;
+	/*
+	 * Selection variables:
+	 * nb – normalized coordinates of the beginning of the selection
+	 * ne – normalized coordinates of the end of the selection
+	 * ob – original coordinates of the beginning of the selection
+	 * oe – original coordinates of the end of the selection
+	 */
+	struct {
+		int x, y;
+	} nb, ne, ob, oe;
+
+	int alt;
+} Selection;
+
+/* Internal representation of the screen */
+typedef struct {
+	int row;      /* nb row */
+	int col;      /* nb col */
+	Line *line;   /* screen */
+	Line *alt;    /* alternate screen */
+	int *dirty;   /* dirtyness of lines */
+	TCursor c;    /* cursor */
+	int ocx;      /* old cursor col */
+	int ocy;      /* old cursor row */
+	int top;      /* top    scroll limit */
+	int bot;      /* bottom scroll limit */
+	int mode;     /* terminal mode flags */
+	int esc;      /* escape state flags */
+	char trantbl[4]; /* charset table translation */
+	int charset;  /* current charset */
+	int icharset; /* selected charset for sequence */
+	int *tabs;
+	Rune lastc;   /* last printed char outside of sequence, 0 if control */
+} Term;
+
+/* CSI Escape sequence structs */
+/* ESC '[' [[ [<priv>] <arg> [;]] <mode> [<mode>]] */
+typedef struct {
+	char buf[ESC_BUF_SIZ]; /* raw string */
+	size_t len;            /* raw string length */
+	char priv;
+	int arg[ESC_ARG_SIZ];
+	int narg;              /* nb of args */
+	char mode[2];
+} CSIEscape;
+
+/* STR Escape sequence structs */
+/* ESC type [[ [<priv>] <arg> [;]] <mode>] ESC '\' */
+typedef struct {
+	char type;             /* ESC type ... */
+	char *buf;             /* allocated raw string */
+	size_t siz;            /* allocation size */
+	size_t len;            /* raw string length */
+	char *args[STR_ARG_SIZ];
+	int narg;              /* nb of args */
+} STREscape;
+
+static void execsh(char *, char **);
+static void stty(char **);
+static void sigchld(int);
+static void ttywriteraw(const char *, size_t);
+
+static void csidump(void);
+static void csihandle(void);
+static void csiparse(void);
+static void csireset(void);
+static void osc_color_response(int, int, int);
+static int eschandle(uchar);
+static void strdump(void);
+static void strhandle(void);
+static void strparse(void);
+static void strreset(void);
+
+static void tprinter(char *, size_t);
+static void tdumpsel(void);
+static void tdumpline(int);
+static void tdump(void);
+static void tclearregion(int, int, int, int);
+static void tcursor(int);
+static void tdeletechar(int);
+static void tdeleteline(int);
+static void tinsertblank(int);
+static void tinsertblankline(int);
+static int tlinelen(int);
+static void tmoveto(int, int);
+static void tmoveato(int, int);
+static void tnewline(int);
+static void tputtab(int);
+static void tputc(Rune);
+static void treset(void);
+static void tscrollup(int, int);
+static void tscrolldown(int, int);
+static void tsetattr(const int *, int);
+static void tsetchar(Rune, const Glyph *, int, int);
+static void tsetdirt(int, int);
+static void tsetscroll(int, int);
+static void tswapscreen(void);
+static void tsetmode(int, int, const int *, int);
+static int twrite(const char *, int, int);
+static void tfulldirt(void);
+static void tcontrolcode(uchar );
+static void tdectest(char );
+static void tdefutf8(char);
+static int32_t tdefcolor(const int *, int *, int);
+static void tdeftran(char);
+static void tstrsequence(uchar);
+
+static void drawregion(int, int, int, int);
+
+static void selnormalize(void);
+static void selscroll(int, int);
+static void selsnap(int *, int *, int);
+
+static size_t utf8decode(const char *, Rune *, size_t);
+static Rune utf8decodebyte(char, size_t *);
+static char utf8encodebyte(Rune, size_t);
+static size_t utf8validate(Rune *, size_t);
+
+static char *base64dec(const char *);
+static char base64dec_getc(const char **);
+
+static ssize_t xwrite(int, const char *, size_t);
+
+/* Globals */
+static Term term;
+static Selection sel;
+static CSIEscape csiescseq;
+static STREscape strescseq;
+static int iofd = 1;
+static int cmdfd;
+static pid_t pid;
+
+static const uchar utfbyte[UTF_SIZ + 1] = {0x80,    0, 0xC0, 0xE0, 0xF0};
+static const uchar utfmask[UTF_SIZ + 1] = {0xC0, 0x80, 0xE0, 0xF0, 0xF8};
+static const Rune utfmin[UTF_SIZ + 1] = {       0,    0,  0x80,  0x800,  0x10000};
+static const Rune utfmax[UTF_SIZ + 1] = {0x10FFFF, 0x7F, 0x7FF, 0xFFFF, 0x10FFFF};
+
+ssize_t
+xwrite(int fd, const char *s, size_t len)
+{
+	size_t aux = len;
+	ssize_t r;
+
+	while (len > 0) {
+		r = write(fd, s, len);
+		if (r < 0)
+			return r;
+		len -= r;
+		s += r;
+	}
+
+	return aux;
+}
+
+void *
+xmalloc(size_t len)
+{
+	void *p;
+
+	if (!(p = malloc(len)))
+		die("malloc: %s\n", strerror(errno));
+
+	return p;
+}
+
+void *
+xrealloc(void *p, size_t len)
+{
+	if ((p = realloc(p, len)) == NULL)
+		die("realloc: %s\n", strerror(errno));
+
+	return p;
+}
+
+char *
+xstrdup(const char *s)
+{
+	char *p;
+
+	if ((p = strdup(s)) == NULL)
+		die("strdup: %s\n", strerror(errno));
+
+	return p;
+}
+
+size_t
+utf8decode(const char *c, Rune *u, size_t clen)
+{
+	size_t i, j, len, type;
+	Rune udecoded;
+
+	*u = UTF_INVALID;
+	if (!clen)
+		return 0;
+	udecoded = utf8decodebyte(c[0], &len);
+	if (!BETWEEN(len, 1, UTF_SIZ))
+		return 1;
+	for (i = 1, j = 1; i < clen && j < len; ++i, ++j) {
+		udecoded = (udecoded << 6) | utf8decodebyte(c[i], &type);
+		if (type != 0)
+			return j;
+	}
+	if (j < len)
+		return 0;
+	*u = udecoded;
+	utf8validate(u, len);
+
+	return len;
+}
+
+Rune
+utf8decodebyte(char c, size_t *i)
+{
+	for (*i = 0; *i < LEN(utfmask); ++(*i))
+		if (((uchar)c & utfmask[*i]) == utfbyte[*i])
+			return (uchar)c & ~utfmask[*i];
+
+	return 0;
+}
+
+size_t
+utf8encode(Rune u, char *c)
+{
+	size_t len, i;
+
+	len = utf8validate(&u, 0);
+	if (len > UTF_SIZ)
+		return 0;
+
+	for (i = len - 1; i != 0; --i) {
+		c[i] = utf8encodebyte(u, 0);
+		u >>= 6;
+	}
+	c[0] = utf8encodebyte(u, len);
+
+	return len;
+}
+
+char
+utf8encodebyte(Rune u, size_t i)
+{
+	return utfbyte[i] | (u & ~utfmask[i]);
+}
+
+size_t
+utf8validate(Rune *u, size_t i)
+{
+	if (!BETWEEN(*u, utfmin[i], utfmax[i]) || BETWEEN(*u, 0xD800, 0xDFFF))
+		*u = UTF_INVALID;
+	for (i = 1; *u > utfmax[i]; ++i)
+		;
+
+	return i;
+}
+
+char
+base64dec_getc(const char **src)
+{
+	while (**src && !isprint((unsigned char)**src))
+		(*src)++;
+	return **src ? *((*src)++) : '=';  /* emulate padding if string ends */
+}
+
+char *
+base64dec(const char *src)
+{
+	size_t in_len = strlen(src);
+	char *result, *dst;
+	static const char base64_digits[256] = {
+		[43] = 62, 0, 0, 0, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
+		0, 0, 0, -1, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
+		13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 0, 0,
+		0, 0, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
+		40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51
+	};
+
+	if (in_len % 4)
+		in_len += 4 - (in_len % 4);
+	result = dst = xmalloc(in_len / 4 * 3 + 1);
+	while (*src) {
+		int a = base64_digits[(unsigned char) base64dec_getc(&src)];
+		int b = base64_digits[(unsigned char) base64dec_getc(&src)];
+		int c = base64_digits[(unsigned char) base64dec_getc(&src)];
+		int d = base64_digits[(unsigned char) base64dec_getc(&src)];
+
+		/* invalid input. 'a' can be -1, e.g. if src is "\n" (c-str) */
+		if (a == -1 || b == -1)
+			break;
+
+		*dst++ = (a << 2) | ((b & 0x30) >> 4);
+		if (c == -1)
+			break;
+		*dst++ = ((b & 0x0f) << 4) | ((c & 0x3c) >> 2);
+		if (d == -1)
+			break;
+		*dst++ = ((c & 0x03) << 6) | d;
+	}
+	*dst = '\0';
+	return result;
+}
+
+void
+selinit(void)
+{
+	sel.mode = SEL_IDLE;
+	sel.snap = 0;
+	sel.ob.x = -1;
+}
+
+int
+tlinelen(int y)
+{
+	int i = term.col;
+
+	if (term.line[y][i - 1].mode & ATTR_WRAP)
+		return i;
+
+	while (i > 0 && term.line[y][i - 1].u == ' ')
+		--i;
+
+	return i;
+}
+
+void
+selstart(int col, int row, int snap)
+{
+	selclear();
+	sel.mode = SEL_EMPTY;
+	sel.type = SEL_REGULAR;
+	sel.alt = IS_SET(MODE_ALTSCREEN);
+	sel.snap = snap;
+	sel.oe.x = sel.ob.x = col;
+	sel.oe.y = sel.ob.y = row;
+	selnormalize();
+
+	if (sel.snap != 0)
+		sel.mode = SEL_READY;
+	tsetdirt(sel.nb.y, sel.ne.y);
+}
+
+void
+selextend(int col, int row, int type, int done)
+{
+	int oldey, oldex, oldsby, oldsey, oldtype;
+
+	if (sel.mode == SEL_IDLE)
+		return;
+	if (done && sel.mode == SEL_EMPTY) {
+		selclear();
+		return;
+	}
+
+	oldey = sel.oe.y;
+	oldex = sel.oe.x;
+	oldsby = sel.nb.y;
+	oldsey = sel.ne.y;
+	oldtype = sel.type;
+
+	sel.oe.x = col;
+	sel.oe.y = row;
+	selnormalize();
+	sel.type = type;
+
+	if (oldey != sel.oe.y || oldex != sel.oe.x || oldtype != sel.type || sel.mode == SEL_EMPTY)
+		tsetdirt(MIN(sel.nb.y, oldsby), MAX(sel.ne.y, oldsey));
+
+	sel.mode = done ? SEL_IDLE : SEL_READY;
+}
+
+void
+selnormalize(void)
+{
+	int i;
+
+	if (sel.type == SEL_REGULAR && sel.ob.y != sel.oe.y) {
+		sel.nb.x = sel.ob.y < sel.oe.y ? sel.ob.x : sel.oe.x;
+		sel.ne.x = sel.ob.y < sel.oe.y ? sel.oe.x : sel.ob.x;
+	} else {
+		sel.nb.x = MIN(sel.ob.x, sel.oe.x);
+		sel.ne.x = MAX(sel.ob.x, sel.oe.x);
+	}
+	sel.nb.y = MIN(sel.ob.y, sel.oe.y);
+	sel.ne.y = MAX(sel.ob.y, sel.oe.y);
+
+	selsnap(&sel.nb.x, &sel.nb.y, -1);
+	selsnap(&sel.ne.x, &sel.ne.y, +1);
+
+	/* expand selection over line breaks */
+	if (sel.type == SEL_RECTANGULAR)
+		return;
+	i = tlinelen(sel.nb.y);
+	if (i < sel.nb.x)
+		sel.nb.x = i;
+	if (tlinelen(sel.ne.y) <= sel.ne.x)
+		sel.ne.x = term.col - 1;
+}
+
+int
+selected(int x, int y)
+{
+	if (sel.mode == SEL_EMPTY || sel.ob.x == -1 ||
+			sel.alt != IS_SET(MODE_ALTSCREEN))
+		return 0;
+
+	if (sel.type == SEL_RECTANGULAR)
+		return BETWEEN(y, sel.nb.y, sel.ne.y)
+		    && BETWEEN(x, sel.nb.x, sel.ne.x);
+
+	return BETWEEN(y, sel.nb.y, sel.ne.y)
+	    && (y != sel.nb.y || x >= sel.nb.x)
+	    && (y != sel.ne.y || x <= sel.ne.x);
+}
+
+void
+selsnap(int *x, int *y, int direction)
+{
+	int newx, newy, xt, yt;
+	int delim, prevdelim;
+	const Glyph *gp, *prevgp;
+
+	switch (sel.snap) {
+	case SNAP_WORD:
+		/*
+		 * Snap around if the word wraps around at the end or
+		 * beginning of a line.
+		 */
+		prevgp = &term.line[*y][*x];
+		prevdelim = ISDELIM(prevgp->u);
+		for (;;) {
+			newx = *x + direction;
+			newy = *y;
+			if (!BETWEEN(newx, 0, term.col - 1)) {
+				newy += direction;
+				newx = (newx + term.col) % term.col;
+				if (!BETWEEN(newy, 0, term.row - 1))
+					break;
+
+				if (direction > 0)
+					yt = *y, xt = *x;
+				else
+					yt = newy, xt = newx;
+				if (!(term.line[yt][xt].mode & ATTR_WRAP))
+					break;
+			}
+
+			if (newx >= tlinelen(newy))
+				break;
+
+			gp = &term.line[newy][newx];
+			delim = ISDELIM(gp->u);
+			if (!(gp->mode & ATTR_WDUMMY) && (delim != prevdelim
+					|| (delim && gp->u != prevgp->u)))
+				break;
+
+			*x = newx;
+			*y = newy;
+			prevgp = gp;
+			prevdelim = delim;
+		}
+		break;
+	case SNAP_LINE:
+		/*
+		 * Snap around if the the previous line or the current one
+		 * has set ATTR_WRAP at its end. Then the whole next or
+		 * previous line will be selected.
+		 */
+		*x = (direction < 0) ? 0 : term.col - 1;
+		if (direction < 0) {
+			for (; *y > 0; *y += direction) {
+				if (!(term.line[*y-1][term.col-1].mode
+						& ATTR_WRAP)) {
+					break;
+				}
+			}
+		} else if (direction > 0) {
+			for (; *y < term.row-1; *y += direction) {
+				if (!(term.line[*y][term.col-1].mode
+						& ATTR_WRAP)) {
+					break;
+				}
+			}
+		}
+		break;
+	}
+}
+
+char *
+getsel(void)
+{
+	char *str, *ptr;
+	int y, bufsize, lastx, linelen;
+	const Glyph *gp, *last;
+
+	if (sel.ob.x == -1)
+		return NULL;
+
+	bufsize = (term.col+1) * (sel.ne.y-sel.nb.y+1) * UTF_SIZ;
+	ptr = str = xmalloc(bufsize);
+
+	/* append every set & selected glyph to the selection */
+	for (y = sel.nb.y; y <= sel.ne.y; y++) {
+		if ((linelen = tlinelen(y)) == 0) {
+			*ptr++ = '\n';
+			continue;
+		}
+
+		if (sel.type == SEL_RECTANGULAR) {
+			gp = &term.line[y][sel.nb.x];
+			lastx = sel.ne.x;
+		} else {
+			gp = &term.line[y][sel.nb.y == y ? sel.nb.x : 0];
+			lastx = (sel.ne.y == y) ? sel.ne.x : term.col-1;
+		}
+		last = &term.line[y][MIN(lastx, linelen-1)];
+		while (last >= gp && last->u == ' ')
+			--last;
+
+		for ( ; gp <= last; ++gp) {
+			if (gp->mode & ATTR_WDUMMY)
+				continue;
+
+			ptr += utf8encode(gp->u, ptr);
+		}
+
+		/*
+		 * Copy and pasting of line endings is inconsistent
+		 * in the inconsistent terminal and GUI world.
+		 * The best solution seems like to produce '\n' when
+		 * something is copied from st and convert '\n' to
+		 * '\r', when something to be pasted is received by
+		 * st.
+		 * FIXME: Fix the computer world.
+		 */
+		if ((y < sel.ne.y || lastx >= linelen) &&
+		    (!(last->mode & ATTR_WRAP) || sel.type == SEL_RECTANGULAR))
+			*ptr++ = '\n';
+	}
+	*ptr = 0;
+	return str;
+}
+
+void
+selclear(void)
+{
+	if (sel.ob.x == -1)
+		return;
+	sel.mode = SEL_IDLE;
+	sel.ob.x = -1;
+	tsetdirt(sel.nb.y, sel.ne.y);
+}
+
+void
+die(const char *errstr, ...)
+{
+	va_list ap;
+
+	va_start(ap, errstr);
+	vfprintf(stderr, errstr, ap);
+	va_end(ap);
+	exit(1);
+}
+
+void
+execsh(char *cmd, char **args)
+{
+	char *sh, *prog, *arg;
+	const struct passwd *pw;
+
+	errno = 0;
+	if ((pw = getpwuid(getuid())) == NULL) {
+		if (errno)
+			die("getpwuid: %s\n", strerror(errno));
+		else
+			die("who are you?\n");
+	}
+
+	if ((sh = getenv("SHELL")) == NULL)
+		sh = (pw->pw_shell[0]) ? pw->pw_shell : cmd;
+
+	if (args) {
+		prog = args[0];
+		arg = NULL;
+	} else if (scroll) {
+		prog = scroll;
+		arg = utmp ? utmp : sh;
+	} else if (utmp) {
+		prog = utmp;
+		arg = NULL;
+	} else {
+		prog = sh;
+		arg = NULL;
+	}
+	DEFAULT(args, ((char *[]) {prog, arg, NULL}));
+
+	unsetenv("COLUMNS");
+	unsetenv("LINES");
+	unsetenv("TERMCAP");
+	setenv("LOGNAME", pw->pw_name, 1);
+	setenv("USER", pw->pw_name, 1);
+	setenv("SHELL", sh, 1);
+	setenv("HOME", pw->pw_dir, 1);
+	setenv("TERM", termname, 1);
+
+	signal(SIGCHLD, SIG_DFL);
+	signal(SIGHUP, SIG_DFL);
+	signal(SIGINT, SIG_DFL);
+	signal(SIGQUIT, SIG_DFL);
+	signal(SIGTERM, SIG_DFL);
+	signal(SIGALRM, SIG_DFL);
+
+	execvp(prog, args);
+	_exit(1);
+}
+
+void
+sigchld(int a)
+{
+	int stat;
+	pid_t p;
+
+	if ((p = waitpid(pid, &stat, WNOHANG)) < 0)
+		die("waiting for pid %hd failed: %s\n", pid, strerror(errno));
+
+	if (pid != p)
+		return;
+
+	if (WIFEXITED(stat) && WEXITSTATUS(stat))
+		die("child exited with status %d\n", WEXITSTATUS(stat));
+	else if (WIFSIGNALED(stat))
+		die("child terminated due to signal %d\n", WTERMSIG(stat));
+	_exit(0);
+}
+
+void
+stty(char **args)
+{
+	char cmd[_POSIX_ARG_MAX], **p, *q, *s;
+	size_t n, siz;
+
+	if ((n = strlen(stty_args)) > sizeof(cmd)-1)
+		die("incorrect stty parameters\n");
+	memcpy(cmd, stty_args, n);
+	q = cmd + n;
+	siz = sizeof(cmd) - n;
+	for (p = args; p && (s = *p); ++p) {
+		if ((n = strlen(s)) > siz-1)
+			die("stty parameter length too long\n");
+		*q++ = ' ';
+		memcpy(q, s, n);
+		q += n;
+		siz -= n + 1;
+	}
+	*q = '\0';
+	if (system(cmd) != 0)
+		perror("Couldn't call stty");
+}
+
+int
+ttynew(const char *line, char *cmd, const char *out, char **args)
+{
+	int m, s;
+
+	if (out) {
+		term.mode |= MODE_PRINT;
+		iofd = (!strcmp(out, "-")) ?
+			  1 : open(out, O_WRONLY | O_CREAT, 0666);
+		if (iofd < 0) {
+			fprintf(stderr, "Error opening %s:%s\n",
+				out, strerror(errno));
+		}
+	}
+
+	if (line) {
+		if ((cmdfd = open(line, O_RDWR)) < 0)
+			die("open line '%s' failed: %s\n",
+			    line, strerror(errno));
+		dup2(cmdfd, 0);
+		stty(args);
+		return cmdfd;
+	}
+
+	/* seems to work fine on linux, openbsd and freebsd */
+	if (openpty(&m, &s, NULL, NULL, NULL) < 0)
+		die("openpty failed: %s\n", strerror(errno));
+
+	switch (pid = fork()) {
+	case -1:
+		die("fork failed: %s\n", strerror(errno));
+		break;
+	case 0:
+		close(iofd);
+		close(m);
+		setsid(); /* create a new process group */
+		dup2(s, 0);
+		dup2(s, 1);
+		dup2(s, 2);
+		if (ioctl(s, TIOCSCTTY, NULL) < 0)
+			die("ioctl TIOCSCTTY failed: %s\n", strerror(errno));
+		if (s > 2)
+			close(s);
+#ifdef __OpenBSD__
+		if (pledge("stdio getpw proc exec", NULL) == -1)
+			die("pledge\n");
+#endif
+		execsh(cmd, args);
+		break;
+	default:
+#ifdef __OpenBSD__
+		if (pledge("stdio rpath tty proc", NULL) == -1)
+			die("pledge\n");
+#endif
+		close(s);
+		cmdfd = m;
+		signal(SIGCHLD, sigchld);
+		break;
+	}
+	return cmdfd;
+}
+
+size_t
+ttyread(void)
+{
+	static char buf[BUFSIZ];
+	static int buflen = 0;
+	int ret, written;
+
+	/* append read bytes to unprocessed bytes */
+	ret = read(cmdfd, buf+buflen, LEN(buf)-buflen);
+
+	switch (ret) {
+	case 0:
+		exit(0);
+	case -1:
+		die("couldn't read from shell: %s\n", strerror(errno));
+	default:
+		buflen += ret;
+		written = twrite(buf, buflen, 0);
+		buflen -= written;
+		/* keep any incomplete UTF-8 byte sequence for the next call */
+		if (buflen > 0)
+			memmove(buf, buf + written, buflen);
+		return ret;
+	}
+}
+
+void
+ttywrite(const char *s, size_t n, int may_echo)
+{
+	const char *next;
+
+	if (may_echo && IS_SET(MODE_ECHO))
+		twrite(s, n, 1);
+
+	if (!IS_SET(MODE_CRLF)) {
+		ttywriteraw(s, n);
+		return;
+	}
+
+	/* This is similar to how the kernel handles ONLCR for ttys */
+	while (n > 0) {
+		if (*s == '\r') {
+			next = s + 1;
+			ttywriteraw("\r\n", 2);
+		} else {
+			next = memchr(s, '\r', n);
+			DEFAULT(next, s + n);
+			ttywriteraw(s, next - s);
+		}
+		n -= next - s;
+		s = next;
+	}
+}
+
+void
+ttywriteraw(const char *s, size_t n)
+{
+	fd_set wfd, rfd;
+	ssize_t r;
+	size_t lim = 256;
+
+	/*
+	 * Remember that we are using a pty, which might be a modem line.
+	 * Writing too much will clog the line. That's why we are doing this
+	 * dance.
+	 * FIXME: Migrate the world to Plan 9.
+	 */
+	while (n > 0) {
+		FD_ZERO(&wfd);
+		FD_ZERO(&rfd);
+		FD_SET(cmdfd, &wfd);
+		FD_SET(cmdfd, &rfd);
+
+		/* Check if we can write. */
+		if (pselect(cmdfd+1, &rfd, &wfd, NULL, NULL, NULL) < 0) {
+			if (errno == EINTR)
+				continue;
+			die("select failed: %s\n", strerror(errno));
+		}
+		if (FD_ISSET(cmdfd, &wfd)) {
+			/*
+			 * Only write the bytes written by ttywrite() or the
+			 * default of 256. This seems to be a reasonable value
+			 * for a serial line. Bigger values might clog the I/O.
+			 */
+			if ((r = write(cmdfd, s, (n < lim)? n : lim)) < 0)
+				goto write_error;
+			if (r < n) {
+				/*
+				 * We weren't able to write out everything.
+				 * This means the buffer is getting full
+				 * again. Empty it.
+				 */
+				if (n < lim)
+					lim = ttyread();
+				n -= r;
+				s += r;
+			} else {
+				/* All bytes have been written. */
+				break;
+			}
+		}
+		if (FD_ISSET(cmdfd, &rfd))
+			lim = ttyread();
+	}
+	return;
+
+write_error:
+	die("write error on tty: %s\n", strerror(errno));
+}
+
+void
+ttyresize(int tw, int th)
+{
+	struct winsize w;
+
+	w.ws_row = term.row;
+	w.ws_col = term.col;
+	w.ws_xpixel = tw;
+	w.ws_ypixel = th;
+	if (ioctl(cmdfd, TIOCSWINSZ, &w) < 0)
+		fprintf(stderr, "Couldn't set window size: %s\n", strerror(errno));
+}
+
+void
+ttyhangup(void)
+{
+	/* Send SIGHUP to shell */
+	kill(pid, SIGHUP);
+}
+
+int
+tattrset(int attr)
+{
+	int i, j;
+
+	for (i = 0; i < term.row-1; i++) {
+		for (j = 0; j < term.col-1; j++) {
+			if (term.line[i][j].mode & attr)
+				return 1;
+		}
+	}
+
+	return 0;
+}
+
+void
+tsetdirt(int top, int bot)
+{
+	int i;
+
+	LIMIT(top, 0, term.row-1);
+	LIMIT(bot, 0, term.row-1);
+
+	for (i = top; i <= bot; i++)
+		term.dirty[i] = 1;
+}
+
+void
+tsetdirtattr(int attr)
+{
+	int i, j;
+
+	for (i = 0; i < term.row-1; i++) {
+		for (j = 0; j < term.col-1; j++) {
+			if (term.line[i][j].mode & attr) {
+				tsetdirt(i, i);
+				break;
+			}
+		}
+	}
+}
+
+void
+tfulldirt(void)
+{
+	tsetdirt(0, term.row-1);
+}
+
+void
+tcursor(int mode)
+{
+	static TCursor c[2];
+	int alt = IS_SET(MODE_ALTSCREEN);
+
+	if (mode == CURSOR_SAVE) {
+		c[alt] = term.c;
+	} else if (mode == CURSOR_LOAD) {
+		term.c = c[alt];
+		tmoveto(c[alt].x, c[alt].y);
+	}
+}
+
+void
+treset(void)
+{
+	uint i;
+
+	term.c = (TCursor){{
+		.mode = ATTR_NULL,
+		.fg = defaultfg,
+		.bg = defaultbg
+	}, .x = 0, .y = 0, .state = CURSOR_DEFAULT};
+
+	memset(term.tabs, 0, term.col * sizeof(*term.tabs));
+	for (i = tabspaces; i < term.col; i += tabspaces)
+		term.tabs[i] = 1;
+	term.top = 0;
+	term.bot = term.row - 1;
+	term.mode = MODE_WRAP|MODE_UTF8;
+	memset(term.trantbl, CS_USA, sizeof(term.trantbl));
+	term.charset = 0;
+
+	for (i = 0; i < 2; i++) {
+		tmoveto(0, 0);
+		tcursor(CURSOR_SAVE);
+		tclearregion(0, 0, term.col-1, term.row-1);
+		tswapscreen();
+	}
+}
+
+void
+tnew(int col, int row)
+{
+	term = (Term){ .c = { .attr = { .fg = defaultfg, .bg = defaultbg } } };
+	tresize(col, row);
+	treset();
+}
+
+void
+tswapscreen(void)
+{
+	Line *tmp = term.line;
+
+	term.line = term.alt;
+	term.alt = tmp;
+	term.mode ^= MODE_ALTSCREEN;
+	tfulldirt();
+}
+
+void
+tscrolldown(int orig, int n)
+{
+	int i;
+	Line temp;
+
+	LIMIT(n, 0, term.bot-orig+1);
+
+	tsetdirt(orig, term.bot-n);
+	tclearregion(0, term.bot-n+1, term.col-1, term.bot);
+
+	for (i = term.bot; i >= orig+n; i--) {
+		temp = term.line[i];
+		term.line[i] = term.line[i-n];
+		term.line[i-n] = temp;
+	}
+
+	selscroll(orig, n);
+}
+
+void
+tscrollup(int orig, int n)
+{
+	int i;
+	Line temp;
+
+	LIMIT(n, 0, term.bot-orig+1);
+
+	tclearregion(0, orig, term.col-1, orig+n-1);
+	tsetdirt(orig+n, term.bot);
+
+	for (i = orig; i <= term.bot-n; i++) {
+		temp = term.line[i];
+		term.line[i] = term.line[i+n];
+		term.line[i+n] = temp;
+	}
+
+	selscroll(orig, -n);
+}
+
+void
+selscroll(int orig, int n)
+{
+	if (sel.ob.x == -1 || sel.alt != IS_SET(MODE_ALTSCREEN))
+		return;
+
+	if (BETWEEN(sel.nb.y, orig, term.bot) != BETWEEN(sel.ne.y, orig, term.bot)) {
+		selclear();
+	} else if (BETWEEN(sel.nb.y, orig, term.bot)) {
+		sel.ob.y += n;
+		sel.oe.y += n;
+		if (sel.ob.y < term.top || sel.ob.y > term.bot ||
+		    sel.oe.y < term.top || sel.oe.y > term.bot) {
+			selclear();
+		} else {
+			selnormalize();
+		}
+	}
+}
+
+void
+tnewline(int first_col)
+{
+	int y = term.c.y;
+
+	if (y == term.bot) {
+		tscrollup(term.top, 1);
+	} else {
+		y++;
+	}
+	tmoveto(first_col ? 0 : term.c.x, y);
+}
+
+void
+csiparse(void)
+{
+	char *p = csiescseq.buf, *np;
+	long int v;
+	int sep = ';'; /* colon or semi-colon, but not both */
+
+	csiescseq.narg = 0;
+	if (*p == '?') {
+		csiescseq.priv = 1;
+		p++;
+	}
+
+	csiescseq.buf[csiescseq.len] = '\0';
+	while (p < csiescseq.buf+csiescseq.len) {
+		np = NULL;
+		v = strtol(p, &np, 10);
+		if (np == p)
+			v = 0;
+		if (v == LONG_MAX || v == LONG_MIN)
+			v = -1;
+		csiescseq.arg[csiescseq.narg++] = v;
+		p = np;
+		if (sep == ';' && *p == ':')
+			sep = ':'; /* allow override to colon once */
+		if (*p != sep || csiescseq.narg == ESC_ARG_SIZ)
+			break;
+		p++;
+	}
+	csiescseq.mode[0] = *p++;
+	csiescseq.mode[1] = (p < csiescseq.buf+csiescseq.len) ? *p : '\0';
+}
+
+/* for absolute user moves, when decom is set */
+void
+tmoveato(int x, int y)
+{
+	tmoveto(x, y + ((term.c.state & CURSOR_ORIGIN) ? term.top: 0));
+}
+
+void
+tmoveto(int x, int y)
+{
+	int miny, maxy;
+
+	if (term.c.state & CURSOR_ORIGIN) {
+		miny = term.top;
+		maxy = term.bot;
+	} else {
+		miny = 0;
+		maxy = term.row - 1;
+	}
+	term.c.state &= ~CURSOR_WRAPNEXT;
+	term.c.x = LIMIT(x, 0, term.col-1);
+	term.c.y = LIMIT(y, miny, maxy);
+}
+
+void
+tsetchar(Rune u, const Glyph *attr, int x, int y)
+{
+	static const char *vt100_0[62] = { /* 0x41 - 0x7e */
+		"↑", "↓", "→", "←", "█", "▚", "☃", /* A - G */
+		0, 0, 0, 0, 0, 0, 0, 0, /* H - O */
+		0, 0, 0, 0, 0, 0, 0, 0, /* P - W */
+		0, 0, 0, 0, 0, 0, 0, " ", /* X - _ */
+		"◆", "▒", "␉", "␌", "␍", "␊", "°", "±", /* ` - g */
+		"␤", "␋", "┘", "┐", "┌", "└", "┼", "⎺", /* h - o */
+		"⎻", "─", "⎼", "⎽", "├", "┤", "┴", "┬", /* p - w */
+		"│", "≤", "≥", "π", "≠", "£", "·", /* x - ~ */
+	};
+
+	/*
+	 * The table is proudly stolen from rxvt.
+	 */
+	if (term.trantbl[term.charset] == CS_GRAPHIC0 &&
+	   BETWEEN(u, 0x41, 0x7e) && vt100_0[u - 0x41])
+		utf8decode(vt100_0[u - 0x41], &u, UTF_SIZ);
+
+	if (term.line[y][x].mode & ATTR_WIDE) {
+		if (x+1 < term.col) {
+			term.line[y][x+1].u = ' ';
+			term.line[y][x+1].mode &= ~ATTR_WDUMMY;
+		}
+	} else if (term.line[y][x].mode & ATTR_WDUMMY) {
+		term.line[y][x-1].u = ' ';
+		term.line[y][x-1].mode &= ~ATTR_WIDE;
+	}
+
+	term.dirty[y] = 1;
+	term.line[y][x] = *attr;
+	term.line[y][x].u = u;
+}
+
+void
+tclearregion(int x1, int y1, int x2, int y2)
+{
+	int x, y, temp;
+	Glyph *gp;
+
+	if (x1 > x2)
+		temp = x1, x1 = x2, x2 = temp;
+	if (y1 > y2)
+		temp = y1, y1 = y2, y2 = temp;
+
+	LIMIT(x1, 0, term.col-1);
+	LIMIT(x2, 0, term.col-1);
+	LIMIT(y1, 0, term.row-1);
+	LIMIT(y2, 0, term.row-1);
+
+	for (y = y1; y <= y2; y++) {
+		term.dirty[y] = 1;
+		for (x = x1; x <= x2; x++) {
+			gp = &term.line[y][x];
+			if (selected(x, y))
+				selclear();
+			gp->fg = term.c.attr.fg;
+			gp->bg = term.c.attr.bg;
+			gp->mode = 0;
+			gp->u = ' ';
+		}
+	}
+}
+
+void
+tdeletechar(int n)
+{
+	int dst, src, size;
+	Glyph *line;
+
+	LIMIT(n, 0, term.col - term.c.x);
+
+	dst = term.c.x;
+	src = term.c.x + n;
+	size = term.col - src;
+	line = term.line[term.c.y];
+
+	memmove(&line[dst], &line[src], size * sizeof(Glyph));
+	tclearregion(term.col-n, term.c.y, term.col-1, term.c.y);
+}
+
+void
+tinsertblank(int n)
+{
+	int dst, src, size;
+	Glyph *line;
+
+	LIMIT(n, 0, term.col - term.c.x);
+
+	dst = term.c.x + n;
+	src = term.c.x;
+	size = term.col - dst;
+	line = term.line[term.c.y];
+
+	memmove(&line[dst], &line[src], size * sizeof(Glyph));
+	tclearregion(src, term.c.y, dst - 1, term.c.y);
+}
+
+void
+tinsertblankline(int n)
+{
+	if (BETWEEN(term.c.y, term.top, term.bot))
+		tscrolldown(term.c.y, n);
+}
+
+void
+tdeleteline(int n)
+{
+	if (BETWEEN(term.c.y, term.top, term.bot))
+		tscrollup(term.c.y, n);
+}
+
+int32_t
+tdefcolor(const int *attr, int *npar, int l)
+{
+	int32_t idx = -1;
+	uint r, g, b;
+
+	switch (attr[*npar + 1]) {
+	case 2: /* direct color in RGB space */
+		if (*npar + 4 >= l) {
+			fprintf(stderr,
+				"erresc(38): Incorrect number of parameters (%d)\n",
+				*npar);
+			break;
+		}
+		r = attr[*npar + 2];
+		g = attr[*npar + 3];
+		b = attr[*npar + 4];
+		*npar += 4;
+		if (!BETWEEN(r, 0, 255) || !BETWEEN(g, 0, 255) || !BETWEEN(b, 0, 255))
+			fprintf(stderr, "erresc: bad rgb color (%u,%u,%u)\n",
+				r, g, b);
+		else
+			idx = TRUECOLOR(r, g, b);
+		break;
+	case 5: /* indexed color */
+		if (*npar + 2 >= l) {
+			fprintf(stderr,
+				"erresc(38): Incorrect number of parameters (%d)\n",
+				*npar);
+			break;
+		}
+		*npar += 2;
+		if (!BETWEEN(attr[*npar], 0, 255))
+			fprintf(stderr, "erresc: bad fgcolor %d\n", attr[*npar]);
+		else
+			idx = attr[*npar];
+		break;
+	case 0: /* implemented defined (only foreground) */
+	case 1: /* transparent */
+	case 3: /* direct color in CMY space */
+	case 4: /* direct color in CMYK space */
+	default:
+		fprintf(stderr,
+		        "erresc(38): gfx attr %d unknown\n", attr[*npar]);
+		break;
+	}
+
+	return idx;
+}
+
+void
+tsetattr(const int *attr, int l)
+{
+	int i;
+	int32_t idx;
+
+	for (i = 0; i < l; i++) {
+		switch (attr[i]) {
+		case 0:
+			term.c.attr.mode &= ~(
+				ATTR_BOLD       |
+				ATTR_FAINT      |
+				ATTR_ITALIC     |
+				ATTR_UNDERLINE  |
+				ATTR_BLINK      |
+				ATTR_REVERSE    |
+				ATTR_INVISIBLE  |
+				ATTR_STRUCK     );
+			term.c.attr.fg = defaultfg;
+			term.c.attr.bg = defaultbg;
+			break;
+		case 1:
+			term.c.attr.mode |= ATTR_BOLD;
+			break;
+		case 2:
+			term.c.attr.mode |= ATTR_FAINT;
+			break;
+		case 3:
+			term.c.attr.mode |= ATTR_ITALIC;
+			break;
+		case 4:
+			term.c.attr.mode |= ATTR_UNDERLINE;
+			break;
+		case 5: /* slow blink */
+			/* FALLTHROUGH */
+		case 6: /* rapid blink */
+			term.c.attr.mode |= ATTR_BLINK;
+			break;
+		case 7:
+			term.c.attr.mode |= ATTR_REVERSE;
+			break;
+		case 8:
+			term.c.attr.mode |= ATTR_INVISIBLE;
+			break;
+		case 9:
+			term.c.attr.mode |= ATTR_STRUCK;
+			break;
+		case 22:
+			term.c.attr.mode &= ~(ATTR_BOLD | ATTR_FAINT);
+			break;
+		case 23:
+			term.c.attr.mode &= ~ATTR_ITALIC;
+			break;
+		case 24:
+			term.c.attr.mode &= ~ATTR_UNDERLINE;
+			break;
+		case 25:
+			term.c.attr.mode &= ~ATTR_BLINK;
+			break;
+		case 27:
+			term.c.attr.mode &= ~ATTR_REVERSE;
+			break;
+		case 28:
+			term.c.attr.mode &= ~ATTR_INVISIBLE;
+			break;
+		case 29:
+			term.c.attr.mode &= ~ATTR_STRUCK;
+			break;
+		case 38:
+			if ((idx = tdefcolor(attr, &i, l)) >= 0)
+				term.c.attr.fg = idx;
+			break;
+		case 39:
+			term.c.attr.fg = defaultfg;
+			break;
+		case 48:
+			if ((idx = tdefcolor(attr, &i, l)) >= 0)
+				term.c.attr.bg = idx;
+			break;
+		case 49:
+			term.c.attr.bg = defaultbg;
+			break;
+		default:
+			if (BETWEEN(attr[i], 30, 37)) {
+				term.c.attr.fg = attr[i] - 30;
+			} else if (BETWEEN(attr[i], 40, 47)) {
+				term.c.attr.bg = attr[i] - 40;
+			} else if (BETWEEN(attr[i], 90, 97)) {
+				term.c.attr.fg = attr[i] - 90 + 8;
+			} else if (BETWEEN(attr[i], 100, 107)) {
+				term.c.attr.bg = attr[i] - 100 + 8;
+			} else {
+				fprintf(stderr,
+					"erresc(default): gfx attr %d unknown\n",
+					attr[i]);
+				csidump();
+			}
+			break;
+		}
+	}
+}
+
+void
+tsetscroll(int t, int b)
+{
+	int temp;
+
+	LIMIT(t, 0, term.row-1);
+	LIMIT(b, 0, term.row-1);
+	if (t > b) {
+		temp = t;
+		t = b;
+		b = temp;
+	}
+	term.top = t;
+	term.bot = b;
+}
+
+void
+tsetmode(int priv, int set, const int *args, int narg)
+{
+	int alt; const int *lim;
+
+	for (lim = args + narg; args < lim; ++args) {
+		if (priv) {
+			switch (*args) {
+			case 1: /* DECCKM -- Cursor key */
+				xsetmode(set, MODE_APPCURSOR);
+				break;
+			case 5: /* DECSCNM -- Reverse video */
+				xsetmode(set, MODE_REVERSE);
+				break;
+			case 6: /* DECOM -- Origin */
+				MODBIT(term.c.state, set, CURSOR_ORIGIN);
+				tmoveato(0, 0);
+				break;
+			case 7: /* DECAWM -- Auto wrap */
+				MODBIT(term.mode, set, MODE_WRAP);
+				break;
+			case 0:  /* Error (IGNORED) */
+			case 2:  /* DECANM -- ANSI/VT52 (IGNORED) */
+			case 3:  /* DECCOLM -- Column  (IGNORED) */
+			case 4:  /* DECSCLM -- Scroll (IGNORED) */
+			case 8:  /* DECARM -- Auto repeat (IGNORED) */
+			case 18: /* DECPFF -- Printer feed (IGNORED) */
+			case 19: /* DECPEX -- Printer extent (IGNORED) */
+			case 42: /* DECNRCM -- National characters (IGNORED) */
+			case 12: /* att610 -- Start blinking cursor (IGNORED) */
+				break;
+			case 25: /* DECTCEM -- Text Cursor Enable Mode */
+				xsetmode(!set, MODE_HIDE);
+				break;
+			case 9:    /* X10 mouse compatibility mode */
+				xsetpointermotion(0);
+				xsetmode(0, MODE_MOUSE);
+				xsetmode(set, MODE_MOUSEX10);
+				break;
+			case 1000: /* 1000: report button press */
+				xsetpointermotion(0);
+				xsetmode(0, MODE_MOUSE);
+				xsetmode(set, MODE_MOUSEBTN);
+				break;
+			case 1002: /* 1002: report motion on button press */
+				xsetpointermotion(0);
+				xsetmode(0, MODE_MOUSE);
+				xsetmode(set, MODE_MOUSEMOTION);
+				break;
+			case 1003: /* 1003: enable all mouse motions */
+				xsetpointermotion(set);
+				xsetmode(0, MODE_MOUSE);
+				xsetmode(set, MODE_MOUSEMANY);
+				break;
+			case 1004: /* 1004: send focus events to tty */
+				xsetmode(set, MODE_FOCUS);
+				break;
+			case 1006: /* 1006: extended reporting mode */
+				xsetmode(set, MODE_MOUSESGR);
+				break;
+			case 1034:
+				xsetmode(set, MODE_8BIT);
+				break;
+			case 1049: /* swap screen & set/restore cursor as xterm */
+				if (!allowaltscreen)
+					break;
+				tcursor((set) ? CURSOR_SAVE : CURSOR_LOAD);
+				/* FALLTHROUGH */
+			case 47: /* swap screen */
+			case 1047:
+				if (!allowaltscreen)
+					break;
+				alt = IS_SET(MODE_ALTSCREEN);
+				if (alt) {
+					tclearregion(0, 0, term.col-1,
+							term.row-1);
+				}
+				if (set ^ alt) /* set is always 1 or 0 */
+					tswapscreen();
+				if (*args != 1049)
+					break;
+				/* FALLTHROUGH */
+			case 1048:
+				tcursor((set) ? CURSOR_SAVE : CURSOR_LOAD);
+				break;
+			case 2004: /* 2004: bracketed paste mode */
+				xsetmode(set, MODE_BRCKTPASTE);
+				break;
+			/* Not implemented mouse modes. See comments there. */
+			case 1001: /* mouse highlight mode; can hang the
+				      terminal by design when implemented. */
+			case 1005: /* UTF-8 mouse mode; will confuse
+				      applications not supporting UTF-8
+				      and luit. */
+			case 1015: /* urxvt mangled mouse mode; incompatible
+				      and can be mistaken for other control
+				      codes. */
+				break;
+			default:
+				fprintf(stderr,
+					"erresc: unknown private set/reset mode %d\n",
+					*args);
+				break;
+			}
+		} else {
+			switch (*args) {
+			case 0:  /* Error (IGNORED) */
+				break;
+			case 2:
+				xsetmode(set, MODE_KBDLOCK);
+				break;
+			case 4:  /* IRM -- Insertion-replacement */
+				MODBIT(term.mode, set, MODE_INSERT);
+				break;
+			case 12: /* SRM -- Send/Receive */
+				MODBIT(term.mode, !set, MODE_ECHO);
+				break;
+			case 20: /* LNM -- Linefeed/new line */
+				MODBIT(term.mode, set, MODE_CRLF);
+				break;
+			default:
+				fprintf(stderr,
+					"erresc: unknown set/reset mode %d\n",
+					*args);
+				break;
+			}
+		}
+	}
+}
+
+void
+csihandle(void)
+{
+	char buf[40];
+	int len;
+
+	switch (csiescseq.mode[0]) {
+	default:
+	unknown:
+		fprintf(stderr, "erresc: unknown csi ");
+		csidump();
+		/* die(""); */
+		break;
+	case '@': /* ICH -- Insert <n> blank char */
+		DEFAULT(csiescseq.arg[0], 1);
+		tinsertblank(csiescseq.arg[0]);
+		break;
+	case 'A': /* CUU -- Cursor <n> Up */
+		DEFAULT(csiescseq.arg[0], 1);
+		tmoveto(term.c.x, term.c.y-csiescseq.arg[0]);
+		break;
+	case 'B': /* CUD -- Cursor <n> Down */
+	case 'e': /* VPR --Cursor <n> Down */
+		DEFAULT(csiescseq.arg[0], 1);
+		tmoveto(term.c.x, term.c.y+csiescseq.arg[0]);
+		break;
+	case 'i': /* MC -- Media Copy */
+		switch (csiescseq.arg[0]) {
+		case 0:
+			tdump();
+			break;
+		case 1:
+			tdumpline(term.c.y);
+			break;
+		case 2:
+			tdumpsel();
+			break;
+		case 4:
+			term.mode &= ~MODE_PRINT;
+			break;
+		case 5:
+			term.mode |= MODE_PRINT;
+			break;
+		}
+		break;
+	case 'c': /* DA -- Device Attributes */
+		if (csiescseq.arg[0] == 0)
+			ttywrite(vtiden, strlen(vtiden), 0);
+		break;
+	case 'b': /* REP -- if last char is printable print it <n> more times */
+		LIMIT(csiescseq.arg[0], 1, 65535);
+		if (term.lastc)
+			while (csiescseq.arg[0]-- > 0)
+				tputc(term.lastc);
+		break;
+	case 'C': /* CUF -- Cursor <n> Forward */
+	case 'a': /* HPR -- Cursor <n> Forward */
+		DEFAULT(csiescseq.arg[0], 1);
+		tmoveto(term.c.x+csiescseq.arg[0], term.c.y);
+		break;
+	case 'D': /* CUB -- Cursor <n> Backward */
+		DEFAULT(csiescseq.arg[0], 1);
+		tmoveto(term.c.x-csiescseq.arg[0], term.c.y);
+		break;
+	case 'E': /* CNL -- Cursor <n> Down and first col */
+		DEFAULT(csiescseq.arg[0], 1);
+		tmoveto(0, term.c.y+csiescseq.arg[0]);
+		break;
+	case 'F': /* CPL -- Cursor <n> Up and first col */
+		DEFAULT(csiescseq.arg[0], 1);
+		tmoveto(0, term.c.y-csiescseq.arg[0]);
+		break;
+	case 'g': /* TBC -- Tabulation clear */
+		switch (csiescseq.arg[0]) {
+		case 0: /* clear current tab stop */
+			term.tabs[term.c.x] = 0;
+			break;
+		case 3: /* clear all the tabs */
+			memset(term.tabs, 0, term.col * sizeof(*term.tabs));
+			break;
+		default:
+			goto unknown;
+		}
+		break;
+	case 'G': /* CHA -- Move to <col> */
+	case '`': /* HPA */
+		DEFAULT(csiescseq.arg[0], 1);
+		tmoveto(csiescseq.arg[0]-1, term.c.y);
+		break;
+	case 'H': /* CUP -- Move to <row> <col> */
+	case 'f': /* HVP */
+		DEFAULT(csiescseq.arg[0], 1);
+		DEFAULT(csiescseq.arg[1], 1);
+		tmoveato(csiescseq.arg[1]-1, csiescseq.arg[0]-1);
+		break;
+	case 'I': /* CHT -- Cursor Forward Tabulation <n> tab stops */
+		DEFAULT(csiescseq.arg[0], 1);
+		tputtab(csiescseq.arg[0]);
+		break;
+	case 'J': /* ED -- Clear screen */
+		switch (csiescseq.arg[0]) {
+		case 0: /* below */
+			tclearregion(term.c.x, term.c.y, term.col-1, term.c.y);
+			if (term.c.y < term.row-1) {
+				tclearregion(0, term.c.y+1, term.col-1,
+						term.row-1);
+			}
+			break;
+		case 1: /* above */
+			if (term.c.y > 0)
+				tclearregion(0, 0, term.col-1, term.c.y-1);
+			tclearregion(0, term.c.y, term.c.x, term.c.y);
+			break;
+		case 2: /* all */
+			tclearregion(0, 0, term.col-1, term.row-1);
+			break;
+		default:
+			goto unknown;
+		}
+		break;
+	case 'K': /* EL -- Clear line */
+		switch (csiescseq.arg[0]) {
+		case 0: /* right */
+			tclearregion(term.c.x, term.c.y, term.col-1,
+					term.c.y);
+			break;
+		case 1: /* left */
+			tclearregion(0, term.c.y, term.c.x, term.c.y);
+			break;
+		case 2: /* all */
+			tclearregion(0, term.c.y, term.col-1, term.c.y);
+			break;
+		}
+		break;
+	case 'S': /* SU -- Scroll <n> line up */
+		if (csiescseq.priv) break;
+		DEFAULT(csiescseq.arg[0], 1);
+		tscrollup(term.top, csiescseq.arg[0]);
+		break;
+	case 'T': /* SD -- Scroll <n> line down */
+		DEFAULT(csiescseq.arg[0], 1);
+		tscrolldown(term.top, csiescseq.arg[0]);
+		break;
+	case 'L': /* IL -- Insert <n> blank lines */
+		DEFAULT(csiescseq.arg[0], 1);
+		tinsertblankline(csiescseq.arg[0]);
+		break;
+	case 'l': /* RM -- Reset Mode */
+		tsetmode(csiescseq.priv, 0, csiescseq.arg, csiescseq.narg);
+		break;
+	case 'M': /* DL -- Delete <n> lines */
+		DEFAULT(csiescseq.arg[0], 1);
+		tdeleteline(csiescseq.arg[0]);
+		break;
+	case 'X': /* ECH -- Erase <n> char */
+		DEFAULT(csiescseq.arg[0], 1);
+		tclearregion(term.c.x, term.c.y,
+				term.c.x + csiescseq.arg[0] - 1, term.c.y);
+		break;
+	case 'P': /* DCH -- Delete <n> char */
+		DEFAULT(csiescseq.arg[0], 1);
+		tdeletechar(csiescseq.arg[0]);
+		break;
+	case 'Z': /* CBT -- Cursor Backward Tabulation <n> tab stops */
+		DEFAULT(csiescseq.arg[0], 1);
+		tputtab(-csiescseq.arg[0]);
+		break;
+	case 'd': /* VPA -- Move to <row> */
+		DEFAULT(csiescseq.arg[0], 1);
+		tmoveato(term.c.x, csiescseq.arg[0]-1);
+		break;
+	case 'h': /* SM -- Set terminal mode */
+		tsetmode(csiescseq.priv, 1, csiescseq.arg, csiescseq.narg);
+		break;
+	case 'm': /* SGR -- Terminal attribute (color) */
+		tsetattr(csiescseq.arg, csiescseq.narg);
+		break;
+	case 'n': /* DSR -- Device Status Report */
+		switch (csiescseq.arg[0]) {
+		case 5: /* Status Report "OK" `0n` */
+			ttywrite("\033[0n", sizeof("\033[0n") - 1, 0);
+			break;
+		case 6: /* Report Cursor Position (CPR) "<row>;<column>R" */
+			len = snprintf(buf, sizeof(buf), "\033[%i;%iR",
+			               term.c.y+1, term.c.x+1);
+			ttywrite(buf, len, 0);
+			break;
+		default:
+			goto unknown;
+		}
+		break;
+	case 'r': /* DECSTBM -- Set Scrolling Region */
+		if (csiescseq.priv) {
+			goto unknown;
+		} else {
+			DEFAULT(csiescseq.arg[0], 1);
+			DEFAULT(csiescseq.arg[1], term.row);
+			tsetscroll(csiescseq.arg[0]-1, csiescseq.arg[1]-1);
+			tmoveato(0, 0);
+		}
+		break;
+	case 's': /* DECSC -- Save cursor position (ANSI.SYS) */
+		tcursor(CURSOR_SAVE);
+		break;
+	case 'u': /* DECRC -- Restore cursor position (ANSI.SYS) */
+		if (csiescseq.priv) {
+			goto unknown;
+		} else {
+			tcursor(CURSOR_LOAD);
+		}
+		break;
+	case ' ':
+		switch (csiescseq.mode[1]) {
+		case 'q': /* DECSCUSR -- Set Cursor Style */
+			if (xsetcursor(csiescseq.arg[0]))
+				goto unknown;
+			break;
+		default:
+			goto unknown;
+		}
+		break;
+	}
+}
+
+void
+csidump(void)
+{
+	size_t i;
+	uint c;
+
+	fprintf(stderr, "ESC[");
+	for (i = 0; i < csiescseq.len; i++) {
+		c = csiescseq.buf[i] & 0xff;
+		if (isprint(c)) {
+			putc(c, stderr);
+		} else if (c == '\n') {
+			fprintf(stderr, "(\\n)");
+		} else if (c == '\r') {
+			fprintf(stderr, "(\\r)");
+		} else if (c == 0x1b) {
+			fprintf(stderr, "(\\e)");
+		} else {
+			fprintf(stderr, "(%02x)", c);
+		}
+	}
+	putc('\n', stderr);
+}
+
+void
+csireset(void)
+{
+	memset(&csiescseq, 0, sizeof(csiescseq));
+}
+
+void
+osc_color_response(int num, int index, int is_osc4)
+{
+	int n;
+	char buf[32];
+	unsigned char r, g, b;
+
+	if (xgetcolor(is_osc4 ? num : index, &r, &g, &b)) {
+		fprintf(stderr, "erresc: failed to fetch %s color %d\n",
+		        is_osc4 ? "osc4" : "osc",
+		        is_osc4 ? num : index);
+		return;
+	}
+
+	n = snprintf(buf, sizeof buf, "\033]%s%d;rgb:%02x%02x/%02x%02x/%02x%02x\007",
+	             is_osc4 ? "4;" : "", num, r, r, g, g, b, b);
+	if (n < 0 || n >= sizeof(buf)) {
+		fprintf(stderr, "error: %s while printing %s response\n",
+		        n < 0 ? "snprintf failed" : "truncation occurred",
+		        is_osc4 ? "osc4" : "osc");
+	} else {
+		ttywrite(buf, n, 1);
+	}
+}
+
+void
+strhandle(void)
+{
+	char *p = NULL, *dec;
+	int j, narg, par;
+	const struct { int idx; char *str; } osc_table[] = {
+		{ defaultfg, "foreground" },
+		{ defaultbg, "background" },
+		{ defaultcs, "cursor" }
+	};
+
+	term.esc &= ~(ESC_STR_END|ESC_STR);
+	strparse();
+	par = (narg = strescseq.narg) ? atoi(strescseq.args[0]) : 0;
+
+	switch (strescseq.type) {
+	case ']': /* OSC -- Operating System Command */
+		switch (par) {
+		case 0:
+			if (narg > 1) {
+				xsettitle(strescseq.args[1]);
+				xseticontitle(strescseq.args[1]);
+			}
+			return;
+		case 1:
+			if (narg > 1)
+				xseticontitle(strescseq.args[1]);
+			return;
+		case 2:
+			if (narg > 1)
+				xsettitle(strescseq.args[1]);
+			return;
+		case 52:
+			if (narg > 2 && allowwindowops) {
+				dec = base64dec(strescseq.args[2]);
+				if (dec) {
+					xsetsel(dec);
+					xclipcopy();
+				} else {
+					fprintf(stderr, "erresc: invalid base64\n");
+				}
+			}
+			return;
+		case 10:
+		case 11:
+		case 12:
+			if (narg < 2)
+				break;
+			p = strescseq.args[1];
+			if ((j = par - 10) < 0 || j >= LEN(osc_table))
+				break; /* shouldn't be possible */
+
+			if (!strcmp(p, "?")) {
+				osc_color_response(par, osc_table[j].idx, 0);
+			} else if (xsetcolorname(osc_table[j].idx, p)) {
+				fprintf(stderr, "erresc: invalid %s color: %s\n",
+				        osc_table[j].str, p);
+			} else {
+				tfulldirt();
+			}
+			return;
+		case 4: /* color set */
+			if (narg < 3)
+				break;
+			p = strescseq.args[2];
+			/* FALLTHROUGH */
+		case 104: /* color reset */
+			j = (narg > 1) ? atoi(strescseq.args[1]) : -1;
+
+			if (p && !strcmp(p, "?")) {
+				osc_color_response(j, 0, 1);
+			} else if (xsetcolorname(j, p)) {
+				if (par == 104 && narg <= 1) {
+					xloadcols();
+					return; /* color reset without parameter */
+				}
+				fprintf(stderr, "erresc: invalid color j=%d, p=%s\n",
+				        j, p ? p : "(null)");
+			} else {
+				/*
+				 * TODO if defaultbg color is changed, borders
+				 * are dirty
+				 */
+				tfulldirt();
+			}
+			return;
+		}
+		break;
+	case 'k': /* old title set compatibility */
+		xsettitle(strescseq.args[0]);
+		return;
+	case 'P': /* DCS -- Device Control String */
+	case '_': /* APC -- Application Program Command */
+	case '^': /* PM -- Privacy Message */
+		return;
+	}
+
+	fprintf(stderr, "erresc: unknown str ");
+	strdump();
+}
+
+void
+strparse(void)
+{
+	int c;
+	char *p = strescseq.buf;
+
+	strescseq.narg = 0;
+	strescseq.buf[strescseq.len] = '\0';
+
+	if (*p == '\0')
+		return;
+
+	while (strescseq.narg < STR_ARG_SIZ) {
+		strescseq.args[strescseq.narg++] = p;
+		while ((c = *p) != ';' && c != '\0')
+			++p;
+		if (c == '\0')
+			return;
+		*p++ = '\0';
+	}
+}
+
+void
+strdump(void)
+{
+	size_t i;
+	uint c;
+
+	fprintf(stderr, "ESC%c", strescseq.type);
+	for (i = 0; i < strescseq.len; i++) {
+		c = strescseq.buf[i] & 0xff;
+		if (c == '\0') {
+			putc('\n', stderr);
+			return;
+		} else if (isprint(c)) {
+			putc(c, stderr);
+		} else if (c == '\n') {
+			fprintf(stderr, "(\\n)");
+		} else if (c == '\r') {
+			fprintf(stderr, "(\\r)");
+		} else if (c == 0x1b) {
+			fprintf(stderr, "(\\e)");
+		} else {
+			fprintf(stderr, "(%02x)", c);
+		}
+	}
+	fprintf(stderr, "ESC\\\n");
+}
+
+void
+strreset(void)
+{
+	strescseq = (STREscape){
+		.buf = xrealloc(strescseq.buf, STR_BUF_SIZ),
+		.siz = STR_BUF_SIZ,
+	};
+}
+
+void
+sendbreak(const Arg *arg)
+{
+	if (tcsendbreak(cmdfd, 0))
+		perror("Error sending break");
+}
+
+void
+tprinter(char *s, size_t len)
+{
+	if (iofd != -1 && xwrite(iofd, s, len) < 0) {
+		perror("Error writing to output file");
+		close(iofd);
+		iofd = -1;
+	}
+}
+
+void
+toggleprinter(const Arg *arg)
+{
+	term.mode ^= MODE_PRINT;
+}
+
+void
+printscreen(const Arg *arg)
+{
+	tdump();
+}
+
+void
+printsel(const Arg *arg)
+{
+	tdumpsel();
+}
+
+void
+tdumpsel(void)
+{
+	char *ptr;
+
+	if ((ptr = getsel())) {
+		tprinter(ptr, strlen(ptr));
+		free(ptr);
+	}
+}
+
+void
+tdumpline(int n)
+{
+	char buf[UTF_SIZ];
+	const Glyph *bp, *end;
+
+	bp = &term.line[n][0];
+	end = &bp[MIN(tlinelen(n), term.col) - 1];
+	if (bp != end || bp->u != ' ') {
+		for ( ; bp <= end; ++bp)
+			tprinter(buf, utf8encode(bp->u, buf));
+	}
+	tprinter("\n", 1);
+}
+
+void
+tdump(void)
+{
+	int i;
+
+	for (i = 0; i < term.row; ++i)
+		tdumpline(i);
+}
+
+void
+tputtab(int n)
+{
+	uint x = term.c.x;
+
+	if (n > 0) {
+		while (x < term.col && n--)
+			for (++x; x < term.col && !term.tabs[x]; ++x)
+				/* nothing */ ;
+	} else if (n < 0) {
+		while (x > 0 && n++)
+			for (--x; x > 0 && !term.tabs[x]; --x)
+				/* nothing */ ;
+	}
+	term.c.x = LIMIT(x, 0, term.col-1);
+}
+
+void
+tdefutf8(char ascii)
+{
+	if (ascii == 'G')
+		term.mode |= MODE_UTF8;
+	else if (ascii == '@')
+		term.mode &= ~MODE_UTF8;
+}
+
+void
+tdeftran(char ascii)
+{
+	static char cs[] = "0B";
+	static int vcs[] = {CS_GRAPHIC0, CS_USA};
+	char *p;
+
+	if ((p = strchr(cs, ascii)) == NULL) {
+		fprintf(stderr, "esc unhandled charset: ESC ( %c\n", ascii);
+	} else {
+		term.trantbl[term.icharset] = vcs[p - cs];
+	}
+}
+
+void
+tdectest(char c)
+{
+	int x, y;
+
+	if (c == '8') { /* DEC screen alignment test. */
+		for (x = 0; x < term.col; ++x) {
+			for (y = 0; y < term.row; ++y)
+				tsetchar('E', &term.c.attr, x, y);
+		}
+	}
+}
+
+void
+tstrsequence(uchar c)
+{
+	switch (c) {
+	case 0x90:   /* DCS -- Device Control String */
+		c = 'P';
+		break;
+	case 0x9f:   /* APC -- Application Program Command */
+		c = '_';
+		break;
+	case 0x9e:   /* PM -- Privacy Message */
+		c = '^';
+		break;
+	case 0x9d:   /* OSC -- Operating System Command */
+		c = ']';
+		break;
+	}
+	strreset();
+	strescseq.type = c;
+	term.esc |= ESC_STR;
+}
+
+void
+tcontrolcode(uchar ascii)
+{
+	switch (ascii) {
+	case '\t':   /* HT */
+		tputtab(1);
+		return;
+	case '\b':   /* BS */
+		tmoveto(term.c.x-1, term.c.y);
+		return;
+	case '\r':   /* CR */
+		tmoveto(0, term.c.y);
+		return;
+	case '\f':   /* LF */
+	case '\v':   /* VT */
+	case '\n':   /* LF */
+		/* go to first col if the mode is set */
+		tnewline(IS_SET(MODE_CRLF));
+		return;
+	case '\a':   /* BEL */
+		if (term.esc & ESC_STR_END) {
+			/* backwards compatibility to xterm */
+			strhandle();
+		} else {
+			xbell();
+		}
+		break;
+	case '\033': /* ESC */
+		csireset();
+		term.esc &= ~(ESC_CSI|ESC_ALTCHARSET|ESC_TEST);
+		term.esc |= ESC_START;
+		return;
+	case '\016': /* SO (LS1 -- Locking shift 1) */
+	case '\017': /* SI (LS0 -- Locking shift 0) */
+		term.charset = 1 - (ascii - '\016');
+		return;
+	case '\032': /* SUB */
+		tsetchar('?', &term.c.attr, term.c.x, term.c.y);
+		/* FALLTHROUGH */
+	case '\030': /* CAN */
+		csireset();
+		break;
+	case '\005': /* ENQ (IGNORED) */
+	case '\000': /* NUL (IGNORED) */
+	case '\021': /* XON (IGNORED) */
+	case '\023': /* XOFF (IGNORED) */
+	case 0177:   /* DEL (IGNORED) */
+		return;
+	case 0x80:   /* TODO: PAD */
+	case 0x81:   /* TODO: HOP */
+	case 0x82:   /* TODO: BPH */
+	case 0x83:   /* TODO: NBH */
+	case 0x84:   /* TODO: IND */
+		break;
+	case 0x85:   /* NEL -- Next line */
+		tnewline(1); /* always go to first col */
+		break;
+	case 0x86:   /* TODO: SSA */
+	case 0x87:   /* TODO: ESA */
+		break;
+	case 0x88:   /* HTS -- Horizontal tab stop */
+		term.tabs[term.c.x] = 1;
+		break;
+	case 0x89:   /* TODO: HTJ */
+	case 0x8a:   /* TODO: VTS */
+	case 0x8b:   /* TODO: PLD */
+	case 0x8c:   /* TODO: PLU */
+	case 0x8d:   /* TODO: RI */
+	case 0x8e:   /* TODO: SS2 */
+	case 0x8f:   /* TODO: SS3 */
+	case 0x91:   /* TODO: PU1 */
+	case 0x92:   /* TODO: PU2 */
+	case 0x93:   /* TODO: STS */
+	case 0x94:   /* TODO: CCH */
+	case 0x95:   /* TODO: MW */
+	case 0x96:   /* TODO: SPA */
+	case 0x97:   /* TODO: EPA */
+	case 0x98:   /* TODO: SOS */
+	case 0x99:   /* TODO: SGCI */
+		break;
+	case 0x9a:   /* DECID -- Identify Terminal */
+		ttywrite(vtiden, strlen(vtiden), 0);
+		break;
+	case 0x9b:   /* TODO: CSI */
+	case 0x9c:   /* TODO: ST */
+		break;
+	case 0x90:   /* DCS -- Device Control String */
+	case 0x9d:   /* OSC -- Operating System Command */
+	case 0x9e:   /* PM -- Privacy Message */
+	case 0x9f:   /* APC -- Application Program Command */
+		tstrsequence(ascii);
+		return;
+	}
+	/* only CAN, SUB, \a and C1 chars interrupt a sequence */
+	term.esc &= ~(ESC_STR_END|ESC_STR);
+}
+
+/*
+ * returns 1 when the sequence is finished and it hasn't to read
+ * more characters for this sequence, otherwise 0
+ */
+int
+eschandle(uchar ascii)
+{
+	switch (ascii) {
+	case '[':
+		term.esc |= ESC_CSI;
+		return 0;
+	case '#':
+		term.esc |= ESC_TEST;
+		return 0;
+	case '%':
+		term.esc |= ESC_UTF8;
+		return 0;
+	case 'P': /* DCS -- Device Control String */
+	case '_': /* APC -- Application Program Command */
+	case '^': /* PM -- Privacy Message */
+	case ']': /* OSC -- Operating System Command */
+	case 'k': /* old title set compatibility */
+		tstrsequence(ascii);
+		return 0;
+	case 'n': /* LS2 -- Locking shift 2 */
+	case 'o': /* LS3 -- Locking shift 3 */
+		term.charset = 2 + (ascii - 'n');
+		break;
+	case '(': /* GZD4 -- set primary charset G0 */
+	case ')': /* G1D4 -- set secondary charset G1 */
+	case '*': /* G2D4 -- set tertiary charset G2 */
+	case '+': /* G3D4 -- set quaternary charset G3 */
+		term.icharset = ascii - '(';
+		term.esc |= ESC_ALTCHARSET;
+		return 0;
+	case 'D': /* IND -- Linefeed */
+		if (term.c.y == term.bot) {
+			tscrollup(term.top, 1);
+		} else {
+			tmoveto(term.c.x, term.c.y+1);
+		}
+		break;
+	case 'E': /* NEL -- Next line */
+		tnewline(1); /* always go to first col */
+		break;
+	case 'H': /* HTS -- Horizontal tab stop */
+		term.tabs[term.c.x] = 1;
+		break;
+	case 'M': /* RI -- Reverse index */
+		if (term.c.y == term.top) {
+			tscrolldown(term.top, 1);
+		} else {
+			tmoveto(term.c.x, term.c.y-1);
+		}
+		break;
+	case 'Z': /* DECID -- Identify Terminal */
+		ttywrite(vtiden, strlen(vtiden), 0);
+		break;
+	case 'c': /* RIS -- Reset to initial state */
+		treset();
+		resettitle();
+		xloadcols();
+		xsetmode(0, MODE_HIDE);
+		break;
+	case '=': /* DECPAM -- Application keypad */
+		xsetmode(1, MODE_APPKEYPAD);
+		break;
+	case '>': /* DECPNM -- Normal keypad */
+		xsetmode(0, MODE_APPKEYPAD);
+		break;
+	case '7': /* DECSC -- Save Cursor */
+		tcursor(CURSOR_SAVE);
+		break;
+	case '8': /* DECRC -- Restore Cursor */
+		tcursor(CURSOR_LOAD);
+		break;
+	case '\\': /* ST -- String Terminator */
+		if (term.esc & ESC_STR_END)
+			strhandle();
+		break;
+	default:
+		fprintf(stderr, "erresc: unknown sequence ESC 0x%02X '%c'\n",
+			(uchar) ascii, isprint(ascii)? ascii:'.');
+		break;
+	}
+	return 1;
+}
+
+void
+tputc(Rune u)
+{
+	char c[UTF_SIZ];
+	int control;
+	int width, len;
+	Glyph *gp;
+
+	control = ISCONTROL(u);
+	if (u < 127 || !IS_SET(MODE_UTF8)) {
+		c[0] = u;
+		width = len = 1;
+	} else {
+		len = utf8encode(u, c);
+		if (!control && (width = wcwidth(u)) == -1)
+			width = 1;
+	}
+
+	if (IS_SET(MODE_PRINT))
+		tprinter(c, len);
+
+	/*
+	 * STR sequence must be checked before anything else
+	 * because it uses all following characters until it
+	 * receives a ESC, a SUB, a ST or any other C1 control
+	 * character.
+	 */
+	if (term.esc & ESC_STR) {
+		if (u == '\a' || u == 030 || u == 032 || u == 033 ||
+		   ISCONTROLC1(u)) {
+			term.esc &= ~(ESC_START|ESC_STR);
+			term.esc |= ESC_STR_END;
+			goto check_control_code;
+		}
+
+		if (strescseq.len+len >= strescseq.siz) {
+			/*
+			 * Here is a bug in terminals. If the user never sends
+			 * some code to stop the str or esc command, then st
+			 * will stop responding. But this is better than
+			 * silently failing with unknown characters. At least
+			 * then users will report back.
+			 *
+			 * In the case users ever get fixed, here is the code:
+			 */
+			/*
+			 * term.esc = 0;
+			 * strhandle();
+			 */
+			if (strescseq.siz > (SIZE_MAX - UTF_SIZ) / 2)
+				return;
+			strescseq.siz *= 2;
+			strescseq.buf = xrealloc(strescseq.buf, strescseq.siz);
+		}
+
+		memmove(&strescseq.buf[strescseq.len], c, len);
+		strescseq.len += len;
+		return;
+	}
+
+check_control_code:
+	/*
+	 * Actions of control codes must be performed as soon they arrive
+	 * because they can be embedded inside a control sequence, and
+	 * they must not cause conflicts with sequences.
+	 */
+	if (control) {
+		/* in UTF-8 mode ignore handling C1 control characters */
+		if (IS_SET(MODE_UTF8) && ISCONTROLC1(u))
+			return;
+		tcontrolcode(u);
+		/*
+		 * control codes are not shown ever
+		 */
+		if (!term.esc)
+			term.lastc = 0;
+		return;
+	} else if (term.esc & ESC_START) {
+		if (term.esc & ESC_CSI) {
+			csiescseq.buf[csiescseq.len++] = u;
+			if (BETWEEN(u, 0x40, 0x7E)
+					|| csiescseq.len >= \
+					sizeof(csiescseq.buf)-1) {
+				term.esc = 0;
+				csiparse();
+				csihandle();
+			}
+			return;
+		} else if (term.esc & ESC_UTF8) {
+			tdefutf8(u);
+		} else if (term.esc & ESC_ALTCHARSET) {
+			tdeftran(u);
+		} else if (term.esc & ESC_TEST) {
+			tdectest(u);
+		} else {
+			if (!eschandle(u))
+				return;
+			/* sequence already finished */
+		}
+		term.esc = 0;
+		/*
+		 * All characters which form part of a sequence are not
+		 * printed
+		 */
+		return;
+	}
+	if (selected(term.c.x, term.c.y))
+		selclear();
+
+	gp = &term.line[term.c.y][term.c.x];
+	if (IS_SET(MODE_WRAP) && (term.c.state & CURSOR_WRAPNEXT)) {
+		gp->mode |= ATTR_WRAP;
+		tnewline(1);
+		gp = &term.line[term.c.y][term.c.x];
+	}
+
+	if (IS_SET(MODE_INSERT) && term.c.x+width < term.col) {
+		memmove(gp+width, gp, (term.col - term.c.x - width) * sizeof(Glyph));
+		gp->mode &= ~ATTR_WIDE;
+	}
+
+	if (term.c.x+width > term.col) {
+		if (IS_SET(MODE_WRAP))
+			tnewline(1);
+		else
+			tmoveto(term.col - width, term.c.y);
+		gp = &term.line[term.c.y][term.c.x];
+	}
+
+	tsetchar(u, &term.c.attr, term.c.x, term.c.y);
+	term.lastc = u;
+
+	if (width == 2) {
+		gp->mode |= ATTR_WIDE;
+		if (term.c.x+1 < term.col) {
+			if (gp[1].mode == ATTR_WIDE && term.c.x+2 < term.col) {
+				gp[2].u = ' ';
+				gp[2].mode &= ~ATTR_WDUMMY;
+			}
+			gp[1].u = '\0';
+			gp[1].mode = ATTR_WDUMMY;
+		}
+	}
+	if (term.c.x+width < term.col) {
+		tmoveto(term.c.x+width, term.c.y);
+	} else {
+		term.c.state |= CURSOR_WRAPNEXT;
+	}
+}
+
+int
+twrite(const char *buf, int buflen, int show_ctrl)
+{
+	int charsize;
+	Rune u;
+	int n;
+
+	for (n = 0; n < buflen; n += charsize) {
+		if (IS_SET(MODE_UTF8)) {
+			/* process a complete utf8 char */
+			charsize = utf8decode(buf + n, &u, buflen - n);
+			if (charsize == 0)
+				break;
+		} else {
+			u = buf[n] & 0xFF;
+			charsize = 1;
+		}
+		if (show_ctrl && ISCONTROL(u)) {
+			if (u & 0x80) {
+				u &= 0x7f;
+				tputc('^');
+				tputc('[');
+			} else if (u != '\n' && u != '\r' && u != '\t') {
+				u ^= 0x40;
+				tputc('^');
+			}
+		}
+		tputc(u);
+	}
+	return n;
+}
+
+void
+tresize(int col, int row)
+{
+	int i;
+	int minrow = MIN(row, term.row);
+	int mincol = MIN(col, term.col);
+	int *bp;
+	TCursor c;
+
+	if (col < 1 || row < 1) {
+		fprintf(stderr,
+		        "tresize: error resizing to %dx%d\n", col, row);
+		return;
+	}
+
+	/*
+	 * slide screen to keep cursor where we expect it -
+	 * tscrollup would work here, but we can optimize to
+	 * memmove because we're freeing the earlier lines
+	 */
+	for (i = 0; i <= term.c.y - row; i++) {
+		free(term.line[i]);
+		free(term.alt[i]);
+	}
+	/* ensure that both src and dst are not NULL */
+	if (i > 0) {
+		memmove(term.line, term.line + i, row * sizeof(Line));
+		memmove(term.alt, term.alt + i, row * sizeof(Line));
+	}
+	for (i += row; i < term.row; i++) {
+		free(term.line[i]);
+		free(term.alt[i]);
+	}
+
+	/* resize to new height */
+	term.line = xrealloc(term.line, row * sizeof(Line));
+	term.alt  = xrealloc(term.alt,  row * sizeof(Line));
+	term.dirty = xrealloc(term.dirty, row * sizeof(*term.dirty));
+	term.tabs = xrealloc(term.tabs, col * sizeof(*term.tabs));
+
+	/* resize each row to new width, zero-pad if needed */
+	for (i = 0; i < minrow; i++) {
+		term.line[i] = xrealloc(term.line[i], col * sizeof(Glyph));
+		term.alt[i]  = xrealloc(term.alt[i],  col * sizeof(Glyph));
+	}
+
+	/* allocate any new rows */
+	for (/* i = minrow */; i < row; i++) {
+		term.line[i] = xmalloc(col * sizeof(Glyph));
+		term.alt[i] = xmalloc(col * sizeof(Glyph));
+	}
+	if (col > term.col) {
+		bp = term.tabs + term.col;
+
+		memset(bp, 0, sizeof(*term.tabs) * (col - term.col));
+		while (--bp > term.tabs && !*bp)
+			/* nothing */ ;
+		for (bp += tabspaces; bp < term.tabs + col; bp += tabspaces)
+			*bp = 1;
+	}
+	/* update terminal size */
+	term.col = col;
+	term.row = row;
+	/* reset scrolling region */
+	tsetscroll(0, row-1);
+	/* make use of the LIMIT in tmoveto */
+	tmoveto(term.c.x, term.c.y);
+	/* Clearing both screens (it makes dirty all lines) */
+	c = term.c;
+	for (i = 0; i < 2; i++) {
+		if (mincol < col && 0 < minrow) {
+			tclearregion(mincol, 0, col - 1, minrow - 1);
+		}
+		if (0 < col && minrow < row) {
+			tclearregion(0, minrow, col - 1, row - 1);
+		}
+		tswapscreen();
+		tcursor(CURSOR_LOAD);
+	}
+	term.c = c;
+}
+
+void
+resettitle(void)
+{
+	xsettitle(NULL);
+}
+
+void
+drawregion(int x1, int y1, int x2, int y2)
+{
+	int y;
+
+	for (y = y1; y < y2; y++) {
+		if (!term.dirty[y])
+			continue;
+
+		term.dirty[y] = 0;
+		xdrawline(term.line[y], x1, y, x2);
+	}
+}
+
+void
+draw(void)
+{
+	int cx = term.c.x, ocx = term.ocx, ocy = term.ocy;
+
+	if (!xstartdraw())
+		return;
+
+	/* adjust cursor position */
+	LIMIT(term.ocx, 0, term.col-1);
+	LIMIT(term.ocy, 0, term.row-1);
+	if (term.line[term.ocy][term.ocx].mode & ATTR_WDUMMY)
+		term.ocx--;
+	if (term.line[term.c.y][cx].mode & ATTR_WDUMMY)
+		cx--;
+
+	drawregion(0, 0, term.col, term.row);
+	xdrawcursor(cx, term.c.y, term.line[term.c.y][cx],
+			term.ocx, term.ocy, term.line[term.ocy][term.ocx]);
+	term.ocx = cx;
+	term.ocy = term.c.y;
+	xfinishdraw();
+	if (ocx != term.ocx || ocy != term.ocy)
+		xximspot(term.ocx, term.ocy);
+}
+
+void
+redraw(void)
+{
+	tfulldirt();
+	draw();
+}
diff --git a/st.h b/birdterm.h
diff --git a/birdterm.info b/birdterm.info
@@ -0,0 +1,243 @@
+birdterm-mono| simpleterm monocolor,
+	acsc=+C\,D-A.B0E``aaffgghFiGjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~,
+	am,
+	bce,
+	bel=^G,
+	blink=\E[5m,
+	bold=\E[1m,
+	cbt=\E[Z,
+	cvvis=\E[?25h,
+	civis=\E[?25l,
+	clear=\E[H\E[2J,
+	cnorm=\E[?12l\E[?25h,
+	colors#2,
+	cols#80,
+	cr=^M,
+	csr=\E[%i%p1%d;%p2%dr,
+	cub=\E[%p1%dD,
+	cub1=^H,
+	cud1=^J,
+	cud=\E[%p1%dB,
+	cuf1=\E[C,
+	cuf=\E[%p1%dC,
+	cup=\E[%i%p1%d;%p2%dH,
+	cuu1=\E[A,
+	cuu=\E[%p1%dA,
+	dch=\E[%p1%dP,
+	dch1=\E[P,
+	dim=\E[2m,
+	dl=\E[%p1%dM,
+	dl1=\E[M,
+	ech=\E[%p1%dX,
+	ed=\E[J,
+	el=\E[K,
+	el1=\E[1K,
+	enacs=\E)0,
+	flash=\E[?5h$<80/>\E[?5l,
+	fsl=^G,
+	home=\E[H,
+	hpa=\E[%i%p1%dG,
+	hs,
+	ht=^I,
+	hts=\EH,
+	ich=\E[%p1%d@,
+	il1=\E[L,
+	il=\E[%p1%dL,
+	ind=^J,
+	indn=\E[%p1%dS,
+	invis=\E[8m,
+	is2=\E[4l\E>\E[?1034l,
+	it#8,
+	kel=\E[1;2F,
+	ked=\E[1;5F,
+	ka1=\E[1~,
+	ka3=\E[5~,
+	kc1=\E[4~,
+	kc3=\E[6~,
+	kbs=\177,
+	kcbt=\E[Z,
+	kb2=\EOu,
+	kcub1=\EOD,
+	kcud1=\EOB,
+	kcuf1=\EOC,
+	kcuu1=\EOA,
+	kDC=\E[3;2~,
+	kent=\EOM,
+	kEND=\E[1;2F,
+	kIC=\E[2;2~,
+	kNXT=\E[6;2~,
+	kPRV=\E[5;2~,
+	kHOM=\E[1;2H,
+	kLFT=\E[1;2D,
+	kRIT=\E[1;2C,
+	kind=\E[1;2B,
+	kri=\E[1;2A,
+	kclr=\E[3;5~,
+	kdl1=\E[3;2~,
+	kdch1=\E[3~,
+	kich1=\E[2~,
+	kend=\E[4~,
+	kf1=\EOP,
+	kf2=\EOQ,
+	kf3=\EOR,
+	kf4=\EOS,
+	kf5=\E[15~,
+	kf6=\E[17~,
+	kf7=\E[18~,
+	kf8=\E[19~,
+	kf9=\E[20~,
+	kf10=\E[21~,
+	kf11=\E[23~,
+	kf12=\E[24~,
+	kf13=\E[1;2P,
+	kf14=\E[1;2Q,
+	kf15=\E[1;2R,
+	kf16=\E[1;2S,
+	kf17=\E[15;2~,
+	kf18=\E[17;2~,
+	kf19=\E[18;2~,
+	kf20=\E[19;2~,
+	kf21=\E[20;2~,
+	kf22=\E[21;2~,
+	kf23=\E[23;2~,
+	kf24=\E[24;2~,
+	kf25=\E[1;5P,
+	kf26=\E[1;5Q,
+	kf27=\E[1;5R,
+	kf28=\E[1;5S,
+	kf29=\E[15;5~,
+	kf30=\E[17;5~,
+	kf31=\E[18;5~,
+	kf32=\E[19;5~,
+	kf33=\E[20;5~,
+	kf34=\E[21;5~,
+	kf35=\E[23;5~,
+	kf36=\E[24;5~,
+	kf37=\E[1;6P,
+	kf38=\E[1;6Q,
+	kf39=\E[1;6R,
+	kf40=\E[1;6S,
+	kf41=\E[15;6~,
+	kf42=\E[17;6~,
+	kf43=\E[18;6~,
+	kf44=\E[19;6~,
+	kf45=\E[20;6~,
+	kf46=\E[21;6~,
+	kf47=\E[23;6~,
+	kf48=\E[24;6~,
+	kf49=\E[1;3P,
+	kf50=\E[1;3Q,
+	kf51=\E[1;3R,
+	kf52=\E[1;3S,
+	kf53=\E[15;3~,
+	kf54=\E[17;3~,
+	kf55=\E[18;3~,
+	kf56=\E[19;3~,
+	kf57=\E[20;3~,
+	kf58=\E[21;3~,
+	kf59=\E[23;3~,
+	kf60=\E[24;3~,
+	kf61=\E[1;4P,
+	kf62=\E[1;4Q,
+	kf63=\E[1;4R,
+	khome=\E[1~,
+	kil1=\E[2;5~,
+	krmir=\E[2;2~,
+	knp=\E[6~,
+	kmous=\E[M,
+	kpp=\E[5~,
+	lines#24,
+	mir,
+	msgr,
+	npc,
+	op=\E[39;49m,
+	pairs#64,
+	mc0=\E[i,
+	mc4=\E[4i,
+	mc5=\E[5i,
+	rc=\E8,
+	rev=\E[7m,
+	ri=\EM,
+	rin=\E[%p1%dT,
+	ritm=\E[23m,
+	rmacs=\E(B,
+	rmcup=\E[?1049l,
+	rmir=\E[4l,
+	rmkx=\E[?1l\E>,
+	rmso=\E[27m,
+	rmul=\E[24m,
+	rs1=\Ec,
+	rs2=\E[4l\E>\E[?1034l,
+	sc=\E7,
+	sitm=\E[3m,
+	sgr0=\E[0m,
+	smacs=\E(0,
+	smcup=\E[?1049h,
+	smir=\E[4h,
+	smkx=\E[?1h\E=,
+	smso=\E[7m,
+	smul=\E[4m,
+	tbc=\E[3g,
+	tsl=\E]0;,
+	xenl,
+	vpa=\E[%i%p1%dd,
+# XTerm extensions
+	rmxx=\E[29m,
+	smxx=\E[9m,
+	BE=\E[?2004h,
+	BD=\E[?2004l,
+	PS=\E[200~,
+	PE=\E[201~,
+# disabled rep for now: causes some issues with older ncurses versions.
+#	rep=%p1%c\E[%p2%{1}%-%db,
+# tmux extensions, see TERMINFO EXTENSIONS in tmux(1)
+	Tc,
+	Ms=\E]52;%p1%s;%p2%s\007,
+	Se=\E[2 q,
+	Ss=\E[%p1%d q,
+
+st| simpleterm,
+	use=birdterm-mono,
+	colors#8,
+	setab=\E[4%p1%dm,
+	setaf=\E[3%p1%dm,
+	setb=\E[4%?%p1%{1}%=%t4%e%p1%{3}%=%t6%e%p1%{4}%=%t1%e%p1%{6}%=%t3%e%p1%d%;m,
+	setf=\E[3%?%p1%{1}%=%t4%e%p1%{3}%=%t6%e%p1%{4}%=%t1%e%p1%{6}%=%t3%e%p1%d%;m,
+	sgr=%?%p9%t\E(0%e\E(B%;\E[0%?%p6%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;%?%p7%t;8%;m,
+
+birdterm-256color| simpleterm with 256 colors,
+	use=st,
+	ccc,
+	colors#256,
+	oc=\E]104\007,
+	pairs#32767,
+#	Nicked from xterm-256color
+	initc=\E]4;%p1%d;rgb\:%p2%{255}%*%{1000}%/%2.2X/%p3%{255}%*%{1000}%/%2.2X/%p4%{255}%*%{1000}%/%2.2X\E\\,
+	setab=\E[%?%p1%{8}%<%t4%p1%d%e%p1%{16}%<%t10%p1%{8}%-%d%e48;5;%p1%d%;m,
+	setaf=\E[%?%p1%{8}%<%t3%p1%d%e%p1%{16}%<%t9%p1%{8}%-%d%e38;5;%p1%d%;m,
+
+birdterm-meta| simpleterm with meta key,
+	use=st,
+	km,
+	rmm=\E[?1034l,
+	smm=\E[?1034h,
+	rs2=\E[4l\E>\E[?1034h,
+	is2=\E[4l\E>\E[?1034h,
+
+birdterm-meta-256color| simpleterm with meta key and 256 colors,
+	use=birdterm-256color,
+	km,
+	rmm=\E[?1034l,
+	smm=\E[?1034h,
+	rs2=\E[4l\E>\E[?1034h,
+	is2=\E[4l\E>\E[?1034h,
+
+birdterm-bs| simpleterm with backspace as backspace,
+	use=st,
+	kbs=\010,
+	kdch1=\177,
+
+birdterm-bs-256color| simpleterm with backspace as backspace and 256colors,
+	use=birdterm-256color,
+	kbs=\010,
+	kdch1=\177,
diff --git a/config.mk b/config.mk
@@ -1,4 +1,4 @@
-# st version
+# birdterm version
 VERSION = 0.9.2
 
 # Customize below to fit your system
diff --git a/st.1 b/st.1
@@ -1,177 +0,0 @@
-.TH ST 1 st\-VERSION
-.SH NAME
-st \- simple terminal
-.SH SYNOPSIS
-.B st
-.RB [ \-aiv ]
-.RB [ \-c
-.IR class ]
-.RB [ \-f
-.IR font ]
-.RB [ \-g
-.IR geometry ]
-.RB [ \-n
-.IR name ]
-.RB [ \-o
-.IR iofile ]
-.RB [ \-T
-.IR title ]
-.RB [ \-t
-.IR title ]
-.RB [ \-l
-.IR line ]
-.RB [ \-w
-.IR windowid ]
-.RB [[ \-e ]
-.IR command
-.RI [ arguments ...]]
-.PP
-.B st
-.RB [ \-aiv ]
-.RB [ \-c
-.IR class ]
-.RB [ \-f
-.IR font ]
-.RB [ \-g
-.IR geometry ]
-.RB [ \-n
-.IR name ]
-.RB [ \-o
-.IR iofile ]
-.RB [ \-T
-.IR title ]
-.RB [ \-t
-.IR title ]
-.RB [ \-w
-.IR windowid ]
-.RB \-l
-.IR line
-.RI [ stty_args ...]
-.SH DESCRIPTION
-.B st
-is a simple terminal emulator.
-.SH OPTIONS
-.TP
-.B \-a
-disable alternate screens in terminal
-.TP
-.BI \-c " class"
-defines the window class (default $TERM).
-.TP
-.BI \-f " font"
-defines the
-.I font
-to use when st is run.
-.TP
-.BI \-g " geometry"
-defines the X11 geometry string.
-The form is [=][<cols>{xX}<rows>][{+-}<xoffset>{+-}<yoffset>]. See
-.BR XParseGeometry (3)
-for further details.
-.TP
-.B \-i
-will fixate the position given with the -g option.
-.TP
-.BI \-n " name"
-defines the window instance name (default $TERM).
-.TP
-.BI \-o " iofile"
-writes all the I/O to
-.I iofile.
-This feature is useful when recording st sessions. A value of "-" means
-standard output.
-.TP
-.BI \-T " title"
-defines the window title (default 'st').
-.TP
-.BI \-t " title"
-defines the window title (default 'st').
-.TP
-.BI \-w " windowid"
-embeds st within the window identified by
-.I windowid
-.TP
-.BI \-l " line"
-use a tty
-.I line
-instead of a pseudo terminal.
-.I line
-should be a (pseudo-)serial device (e.g. /dev/ttyS0 on Linux for serial port
-0).
-When this flag is given
-remaining arguments are used as flags for
-.BR stty(1).
-By default st initializes the serial line to 8 bits, no parity, 1 stop bit
-and a 38400 baud rate. The speed is set by appending it as last argument
-(e.g. 'st -l /dev/ttyS0 115200'). Arguments before the last one are
-.BR stty(1)
-flags. If you want to set odd parity on 115200 baud use for example 'st -l
-/dev/ttyS0 parenb parodd 115200'. Set the number of bits by using for
-example 'st -l /dev/ttyS0 cs7 115200'. See
-.BR stty(1)
-for more arguments and cases.
-.TP
-.B \-v
-prints version information to stderr, then exits.
-.TP
-.BI \-e " command " [ " arguments " "... ]"
-st executes
-.I command
-instead of the shell.  If this is used it
-.B must be the last option
-on the command line, as in xterm / rxvt.
-This option is only intended for compatibility,
-and all the remaining arguments are used as a command
-even without it.
-.SH SHORTCUTS
-.TP
-.B Break
-Send a break in the serial line.
-Break key is obtained in PC keyboards
-pressing at the same time control and pause.
-.TP
-.B Ctrl-Print Screen
-Toggle if st should print to the
-.I iofile.
-.TP
-.B Shift-Print Screen
-Print the full screen to the
-.I iofile.
-.TP
-.B Print Screen
-Print the selection to the
-.I iofile.
-.TP
-.B Ctrl-Shift-Page Up
-Increase font size.
-.TP
-.B Ctrl-Shift-Page Down
-Decrease font size.
-.TP
-.B Ctrl-Shift-Home
-Reset to default font size.
-.TP
-.B Ctrl-Shift-y
-Paste from primary selection (middle mouse button).
-.TP
-.B Ctrl-Shift-c
-Copy the selected text to the clipboard selection.
-.TP
-.B Ctrl-Shift-v
-Paste from the clipboard selection.
-.SH CUSTOMIZATION
-.B st
-can be customized by creating a custom config.h and (re)compiling the source
-code. This keeps it fast, secure and simple.
-.SH AUTHORS
-See the LICENSE file for the authors.
-.SH LICENSE
-See the LICENSE file for the terms of redistribution.
-.SH SEE ALSO
-.BR tabbed (1),
-.BR utmp (1),
-.BR stty (1),
-.BR scroll (1)
-.SH BUGS
-See the TODO file in the distribution.
-
diff --git a/st.c b/st.c
@@ -1,2682 +0,0 @@
-/* See LICENSE for license details. */
-#include <ctype.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <limits.h>
-#include <pwd.h>
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <signal.h>
-#include <sys/ioctl.h>
-#include <sys/select.h>
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <termios.h>
-#include <unistd.h>
-#include <wchar.h>
-
-#include "st.h"
-#include "win.h"
-
-#if   defined(__linux)
- #include <pty.h>
-#elif defined(__OpenBSD__) || defined(__NetBSD__) || defined(__APPLE__)
- #include <util.h>
-#elif defined(__FreeBSD__) || defined(__DragonFly__)
- #include <libutil.h>
-#endif
-
-/* Arbitrary sizes */
-#define UTF_INVALID   0xFFFD
-#define UTF_SIZ       4
-#define ESC_BUF_SIZ   (128*UTF_SIZ)
-#define ESC_ARG_SIZ   16
-#define STR_BUF_SIZ   ESC_BUF_SIZ
-#define STR_ARG_SIZ   ESC_ARG_SIZ
-
-/* macros */
-#define IS_SET(flag)		((term.mode & (flag)) != 0)
-#define ISCONTROLC0(c)		(BETWEEN(c, 0, 0x1f) || (c) == 0x7f)
-#define ISCONTROLC1(c)		(BETWEEN(c, 0x80, 0x9f))
-#define ISCONTROL(c)		(ISCONTROLC0(c) || ISCONTROLC1(c))
-#define ISDELIM(u)		(u && wcschr(worddelimiters, u))
-
-enum term_mode {
-	MODE_WRAP        = 1 << 0,
-	MODE_INSERT      = 1 << 1,
-	MODE_ALTSCREEN   = 1 << 2,
-	MODE_CRLF        = 1 << 3,
-	MODE_ECHO        = 1 << 4,
-	MODE_PRINT       = 1 << 5,
-	MODE_UTF8        = 1 << 6,
-};
-
-enum cursor_movement {
-	CURSOR_SAVE,
-	CURSOR_LOAD
-};
-
-enum cursor_state {
-	CURSOR_DEFAULT  = 0,
-	CURSOR_WRAPNEXT = 1,
-	CURSOR_ORIGIN   = 2
-};
-
-enum charset {
-	CS_GRAPHIC0,
-	CS_GRAPHIC1,
-	CS_UK,
-	CS_USA,
-	CS_MULTI,
-	CS_GER,
-	CS_FIN
-};
-
-enum escape_state {
-	ESC_START      = 1,
-	ESC_CSI        = 2,
-	ESC_STR        = 4,  /* DCS, OSC, PM, APC */
-	ESC_ALTCHARSET = 8,
-	ESC_STR_END    = 16, /* a final string was encountered */
-	ESC_TEST       = 32, /* Enter in test mode */
-	ESC_UTF8       = 64,
-};
-
-typedef struct {
-	Glyph attr; /* current char attributes */
-	int x;
-	int y;
-	char state;
-} TCursor;
-
-typedef struct {
-	int mode;
-	int type;
-	int snap;
-	/*
-	 * Selection variables:
-	 * nb – normalized coordinates of the beginning of the selection
-	 * ne – normalized coordinates of the end of the selection
-	 * ob – original coordinates of the beginning of the selection
-	 * oe – original coordinates of the end of the selection
-	 */
-	struct {
-		int x, y;
-	} nb, ne, ob, oe;
-
-	int alt;
-} Selection;
-
-/* Internal representation of the screen */
-typedef struct {
-	int row;      /* nb row */
-	int col;      /* nb col */
-	Line *line;   /* screen */
-	Line *alt;    /* alternate screen */
-	int *dirty;   /* dirtyness of lines */
-	TCursor c;    /* cursor */
-	int ocx;      /* old cursor col */
-	int ocy;      /* old cursor row */
-	int top;      /* top    scroll limit */
-	int bot;      /* bottom scroll limit */
-	int mode;     /* terminal mode flags */
-	int esc;      /* escape state flags */
-	char trantbl[4]; /* charset table translation */
-	int charset;  /* current charset */
-	int icharset; /* selected charset for sequence */
-	int *tabs;
-	Rune lastc;   /* last printed char outside of sequence, 0 if control */
-} Term;
-
-/* CSI Escape sequence structs */
-/* ESC '[' [[ [<priv>] <arg> [;]] <mode> [<mode>]] */
-typedef struct {
-	char buf[ESC_BUF_SIZ]; /* raw string */
-	size_t len;            /* raw string length */
-	char priv;
-	int arg[ESC_ARG_SIZ];
-	int narg;              /* nb of args */
-	char mode[2];
-} CSIEscape;
-
-/* STR Escape sequence structs */
-/* ESC type [[ [<priv>] <arg> [;]] <mode>] ESC '\' */
-typedef struct {
-	char type;             /* ESC type ... */
-	char *buf;             /* allocated raw string */
-	size_t siz;            /* allocation size */
-	size_t len;            /* raw string length */
-	char *args[STR_ARG_SIZ];
-	int narg;              /* nb of args */
-} STREscape;
-
-static void execsh(char *, char **);
-static void stty(char **);
-static void sigchld(int);
-static void ttywriteraw(const char *, size_t);
-
-static void csidump(void);
-static void csihandle(void);
-static void csiparse(void);
-static void csireset(void);
-static void osc_color_response(int, int, int);
-static int eschandle(uchar);
-static void strdump(void);
-static void strhandle(void);
-static void strparse(void);
-static void strreset(void);
-
-static void tprinter(char *, size_t);
-static void tdumpsel(void);
-static void tdumpline(int);
-static void tdump(void);
-static void tclearregion(int, int, int, int);
-static void tcursor(int);
-static void tdeletechar(int);
-static void tdeleteline(int);
-static void tinsertblank(int);
-static void tinsertblankline(int);
-static int tlinelen(int);
-static void tmoveto(int, int);
-static void tmoveato(int, int);
-static void tnewline(int);
-static void tputtab(int);
-static void tputc(Rune);
-static void treset(void);
-static void tscrollup(int, int);
-static void tscrolldown(int, int);
-static void tsetattr(const int *, int);
-static void tsetchar(Rune, const Glyph *, int, int);
-static void tsetdirt(int, int);
-static void tsetscroll(int, int);
-static void tswapscreen(void);
-static void tsetmode(int, int, const int *, int);
-static int twrite(const char *, int, int);
-static void tfulldirt(void);
-static void tcontrolcode(uchar );
-static void tdectest(char );
-static void tdefutf8(char);
-static int32_t tdefcolor(const int *, int *, int);
-static void tdeftran(char);
-static void tstrsequence(uchar);
-
-static void drawregion(int, int, int, int);
-
-static void selnormalize(void);
-static void selscroll(int, int);
-static void selsnap(int *, int *, int);
-
-static size_t utf8decode(const char *, Rune *, size_t);
-static Rune utf8decodebyte(char, size_t *);
-static char utf8encodebyte(Rune, size_t);
-static size_t utf8validate(Rune *, size_t);
-
-static char *base64dec(const char *);
-static char base64dec_getc(const char **);
-
-static ssize_t xwrite(int, const char *, size_t);
-
-/* Globals */
-static Term term;
-static Selection sel;
-static CSIEscape csiescseq;
-static STREscape strescseq;
-static int iofd = 1;
-static int cmdfd;
-static pid_t pid;
-
-static const uchar utfbyte[UTF_SIZ + 1] = {0x80,    0, 0xC0, 0xE0, 0xF0};
-static const uchar utfmask[UTF_SIZ + 1] = {0xC0, 0x80, 0xE0, 0xF0, 0xF8};
-static const Rune utfmin[UTF_SIZ + 1] = {       0,    0,  0x80,  0x800,  0x10000};
-static const Rune utfmax[UTF_SIZ + 1] = {0x10FFFF, 0x7F, 0x7FF, 0xFFFF, 0x10FFFF};
-
-ssize_t
-xwrite(int fd, const char *s, size_t len)
-{
-	size_t aux = len;
-	ssize_t r;
-
-	while (len > 0) {
-		r = write(fd, s, len);
-		if (r < 0)
-			return r;
-		len -= r;
-		s += r;
-	}
-
-	return aux;
-}
-
-void *
-xmalloc(size_t len)
-{
-	void *p;
-
-	if (!(p = malloc(len)))
-		die("malloc: %s\n", strerror(errno));
-
-	return p;
-}
-
-void *
-xrealloc(void *p, size_t len)
-{
-	if ((p = realloc(p, len)) == NULL)
-		die("realloc: %s\n", strerror(errno));
-
-	return p;
-}
-
-char *
-xstrdup(const char *s)
-{
-	char *p;
-
-	if ((p = strdup(s)) == NULL)
-		die("strdup: %s\n", strerror(errno));
-
-	return p;
-}
-
-size_t
-utf8decode(const char *c, Rune *u, size_t clen)
-{
-	size_t i, j, len, type;
-	Rune udecoded;
-
-	*u = UTF_INVALID;
-	if (!clen)
-		return 0;
-	udecoded = utf8decodebyte(c[0], &len);
-	if (!BETWEEN(len, 1, UTF_SIZ))
-		return 1;
-	for (i = 1, j = 1; i < clen && j < len; ++i, ++j) {
-		udecoded = (udecoded << 6) | utf8decodebyte(c[i], &type);
-		if (type != 0)
-			return j;
-	}
-	if (j < len)
-		return 0;
-	*u = udecoded;
-	utf8validate(u, len);
-
-	return len;
-}
-
-Rune
-utf8decodebyte(char c, size_t *i)
-{
-	for (*i = 0; *i < LEN(utfmask); ++(*i))
-		if (((uchar)c & utfmask[*i]) == utfbyte[*i])
-			return (uchar)c & ~utfmask[*i];
-
-	return 0;
-}
-
-size_t
-utf8encode(Rune u, char *c)
-{
-	size_t len, i;
-
-	len = utf8validate(&u, 0);
-	if (len > UTF_SIZ)
-		return 0;
-
-	for (i = len - 1; i != 0; --i) {
-		c[i] = utf8encodebyte(u, 0);
-		u >>= 6;
-	}
-	c[0] = utf8encodebyte(u, len);
-
-	return len;
-}
-
-char
-utf8encodebyte(Rune u, size_t i)
-{
-	return utfbyte[i] | (u & ~utfmask[i]);
-}
-
-size_t
-utf8validate(Rune *u, size_t i)
-{
-	if (!BETWEEN(*u, utfmin[i], utfmax[i]) || BETWEEN(*u, 0xD800, 0xDFFF))
-		*u = UTF_INVALID;
-	for (i = 1; *u > utfmax[i]; ++i)
-		;
-
-	return i;
-}
-
-char
-base64dec_getc(const char **src)
-{
-	while (**src && !isprint((unsigned char)**src))
-		(*src)++;
-	return **src ? *((*src)++) : '=';  /* emulate padding if string ends */
-}
-
-char *
-base64dec(const char *src)
-{
-	size_t in_len = strlen(src);
-	char *result, *dst;
-	static const char base64_digits[256] = {
-		[43] = 62, 0, 0, 0, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
-		0, 0, 0, -1, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
-		13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 0, 0,
-		0, 0, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
-		40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51
-	};
-
-	if (in_len % 4)
-		in_len += 4 - (in_len % 4);
-	result = dst = xmalloc(in_len / 4 * 3 + 1);
-	while (*src) {
-		int a = base64_digits[(unsigned char) base64dec_getc(&src)];
-		int b = base64_digits[(unsigned char) base64dec_getc(&src)];
-		int c = base64_digits[(unsigned char) base64dec_getc(&src)];
-		int d = base64_digits[(unsigned char) base64dec_getc(&src)];
-
-		/* invalid input. 'a' can be -1, e.g. if src is "\n" (c-str) */
-		if (a == -1 || b == -1)
-			break;
-
-		*dst++ = (a << 2) | ((b & 0x30) >> 4);
-		if (c == -1)
-			break;
-		*dst++ = ((b & 0x0f) << 4) | ((c & 0x3c) >> 2);
-		if (d == -1)
-			break;
-		*dst++ = ((c & 0x03) << 6) | d;
-	}
-	*dst = '\0';
-	return result;
-}
-
-void
-selinit(void)
-{
-	sel.mode = SEL_IDLE;
-	sel.snap = 0;
-	sel.ob.x = -1;
-}
-
-int
-tlinelen(int y)
-{
-	int i = term.col;
-
-	if (term.line[y][i - 1].mode & ATTR_WRAP)
-		return i;
-
-	while (i > 0 && term.line[y][i - 1].u == ' ')
-		--i;
-
-	return i;
-}
-
-void
-selstart(int col, int row, int snap)
-{
-	selclear();
-	sel.mode = SEL_EMPTY;
-	sel.type = SEL_REGULAR;
-	sel.alt = IS_SET(MODE_ALTSCREEN);
-	sel.snap = snap;
-	sel.oe.x = sel.ob.x = col;
-	sel.oe.y = sel.ob.y = row;
-	selnormalize();
-
-	if (sel.snap != 0)
-		sel.mode = SEL_READY;
-	tsetdirt(sel.nb.y, sel.ne.y);
-}
-
-void
-selextend(int col, int row, int type, int done)
-{
-	int oldey, oldex, oldsby, oldsey, oldtype;
-
-	if (sel.mode == SEL_IDLE)
-		return;
-	if (done && sel.mode == SEL_EMPTY) {
-		selclear();
-		return;
-	}
-
-	oldey = sel.oe.y;
-	oldex = sel.oe.x;
-	oldsby = sel.nb.y;
-	oldsey = sel.ne.y;
-	oldtype = sel.type;
-
-	sel.oe.x = col;
-	sel.oe.y = row;
-	selnormalize();
-	sel.type = type;
-
-	if (oldey != sel.oe.y || oldex != sel.oe.x || oldtype != sel.type || sel.mode == SEL_EMPTY)
-		tsetdirt(MIN(sel.nb.y, oldsby), MAX(sel.ne.y, oldsey));
-
-	sel.mode = done ? SEL_IDLE : SEL_READY;
-}
-
-void
-selnormalize(void)
-{
-	int i;
-
-	if (sel.type == SEL_REGULAR && sel.ob.y != sel.oe.y) {
-		sel.nb.x = sel.ob.y < sel.oe.y ? sel.ob.x : sel.oe.x;
-		sel.ne.x = sel.ob.y < sel.oe.y ? sel.oe.x : sel.ob.x;
-	} else {
-		sel.nb.x = MIN(sel.ob.x, sel.oe.x);
-		sel.ne.x = MAX(sel.ob.x, sel.oe.x);
-	}
-	sel.nb.y = MIN(sel.ob.y, sel.oe.y);
-	sel.ne.y = MAX(sel.ob.y, sel.oe.y);
-
-	selsnap(&sel.nb.x, &sel.nb.y, -1);
-	selsnap(&sel.ne.x, &sel.ne.y, +1);
-
-	/* expand selection over line breaks */
-	if (sel.type == SEL_RECTANGULAR)
-		return;
-	i = tlinelen(sel.nb.y);
-	if (i < sel.nb.x)
-		sel.nb.x = i;
-	if (tlinelen(sel.ne.y) <= sel.ne.x)
-		sel.ne.x = term.col - 1;
-}
-
-int
-selected(int x, int y)
-{
-	if (sel.mode == SEL_EMPTY || sel.ob.x == -1 ||
-			sel.alt != IS_SET(MODE_ALTSCREEN))
-		return 0;
-
-	if (sel.type == SEL_RECTANGULAR)
-		return BETWEEN(y, sel.nb.y, sel.ne.y)
-		    && BETWEEN(x, sel.nb.x, sel.ne.x);
-
-	return BETWEEN(y, sel.nb.y, sel.ne.y)
-	    && (y != sel.nb.y || x >= sel.nb.x)
-	    && (y != sel.ne.y || x <= sel.ne.x);
-}
-
-void
-selsnap(int *x, int *y, int direction)
-{
-	int newx, newy, xt, yt;
-	int delim, prevdelim;
-	const Glyph *gp, *prevgp;
-
-	switch (sel.snap) {
-	case SNAP_WORD:
-		/*
-		 * Snap around if the word wraps around at the end or
-		 * beginning of a line.
-		 */
-		prevgp = &term.line[*y][*x];
-		prevdelim = ISDELIM(prevgp->u);
-		for (;;) {
-			newx = *x + direction;
-			newy = *y;
-			if (!BETWEEN(newx, 0, term.col - 1)) {
-				newy += direction;
-				newx = (newx + term.col) % term.col;
-				if (!BETWEEN(newy, 0, term.row - 1))
-					break;
-
-				if (direction > 0)
-					yt = *y, xt = *x;
-				else
-					yt = newy, xt = newx;
-				if (!(term.line[yt][xt].mode & ATTR_WRAP))
-					break;
-			}
-
-			if (newx >= tlinelen(newy))
-				break;
-
-			gp = &term.line[newy][newx];
-			delim = ISDELIM(gp->u);
-			if (!(gp->mode & ATTR_WDUMMY) && (delim != prevdelim
-					|| (delim && gp->u != prevgp->u)))
-				break;
-
-			*x = newx;
-			*y = newy;
-			prevgp = gp;
-			prevdelim = delim;
-		}
-		break;
-	case SNAP_LINE:
-		/*
-		 * Snap around if the the previous line or the current one
-		 * has set ATTR_WRAP at its end. Then the whole next or
-		 * previous line will be selected.
-		 */
-		*x = (direction < 0) ? 0 : term.col - 1;
-		if (direction < 0) {
-			for (; *y > 0; *y += direction) {
-				if (!(term.line[*y-1][term.col-1].mode
-						& ATTR_WRAP)) {
-					break;
-				}
-			}
-		} else if (direction > 0) {
-			for (; *y < term.row-1; *y += direction) {
-				if (!(term.line[*y][term.col-1].mode
-						& ATTR_WRAP)) {
-					break;
-				}
-			}
-		}
-		break;
-	}
-}
-
-char *
-getsel(void)
-{
-	char *str, *ptr;
-	int y, bufsize, lastx, linelen;
-	const Glyph *gp, *last;
-
-	if (sel.ob.x == -1)
-		return NULL;
-
-	bufsize = (term.col+1) * (sel.ne.y-sel.nb.y+1) * UTF_SIZ;
-	ptr = str = xmalloc(bufsize);
-
-	/* append every set & selected glyph to the selection */
-	for (y = sel.nb.y; y <= sel.ne.y; y++) {
-		if ((linelen = tlinelen(y)) == 0) {
-			*ptr++ = '\n';
-			continue;
-		}
-
-		if (sel.type == SEL_RECTANGULAR) {
-			gp = &term.line[y][sel.nb.x];
-			lastx = sel.ne.x;
-		} else {
-			gp = &term.line[y][sel.nb.y == y ? sel.nb.x : 0];
-			lastx = (sel.ne.y == y) ? sel.ne.x : term.col-1;
-		}
-		last = &term.line[y][MIN(lastx, linelen-1)];
-		while (last >= gp && last->u == ' ')
-			--last;
-
-		for ( ; gp <= last; ++gp) {
-			if (gp->mode & ATTR_WDUMMY)
-				continue;
-
-			ptr += utf8encode(gp->u, ptr);
-		}
-
-		/*
-		 * Copy and pasting of line endings is inconsistent
-		 * in the inconsistent terminal and GUI world.
-		 * The best solution seems like to produce '\n' when
-		 * something is copied from st and convert '\n' to
-		 * '\r', when something to be pasted is received by
-		 * st.
-		 * FIXME: Fix the computer world.
-		 */
-		if ((y < sel.ne.y || lastx >= linelen) &&
-		    (!(last->mode & ATTR_WRAP) || sel.type == SEL_RECTANGULAR))
-			*ptr++ = '\n';
-	}
-	*ptr = 0;
-	return str;
-}
-
-void
-selclear(void)
-{
-	if (sel.ob.x == -1)
-		return;
-	sel.mode = SEL_IDLE;
-	sel.ob.x = -1;
-	tsetdirt(sel.nb.y, sel.ne.y);
-}
-
-void
-die(const char *errstr, ...)
-{
-	va_list ap;
-
-	va_start(ap, errstr);
-	vfprintf(stderr, errstr, ap);
-	va_end(ap);
-	exit(1);
-}
-
-void
-execsh(char *cmd, char **args)
-{
-	char *sh, *prog, *arg;
-	const struct passwd *pw;
-
-	errno = 0;
-	if ((pw = getpwuid(getuid())) == NULL) {
-		if (errno)
-			die("getpwuid: %s\n", strerror(errno));
-		else
-			die("who are you?\n");
-	}
-
-	if ((sh = getenv("SHELL")) == NULL)
-		sh = (pw->pw_shell[0]) ? pw->pw_shell : cmd;
-
-	if (args) {
-		prog = args[0];
-		arg = NULL;
-	} else if (scroll) {
-		prog = scroll;
-		arg = utmp ? utmp : sh;
-	} else if (utmp) {
-		prog = utmp;
-		arg = NULL;
-	} else {
-		prog = sh;
-		arg = NULL;
-	}
-	DEFAULT(args, ((char *[]) {prog, arg, NULL}));
-
-	unsetenv("COLUMNS");
-	unsetenv("LINES");
-	unsetenv("TERMCAP");
-	setenv("LOGNAME", pw->pw_name, 1);
-	setenv("USER", pw->pw_name, 1);
-	setenv("SHELL", sh, 1);
-	setenv("HOME", pw->pw_dir, 1);
-	setenv("TERM", termname, 1);
-
-	signal(SIGCHLD, SIG_DFL);
-	signal(SIGHUP, SIG_DFL);
-	signal(SIGINT, SIG_DFL);
-	signal(SIGQUIT, SIG_DFL);
-	signal(SIGTERM, SIG_DFL);
-	signal(SIGALRM, SIG_DFL);
-
-	execvp(prog, args);
-	_exit(1);
-}
-
-void
-sigchld(int a)
-{
-	int stat;
-	pid_t p;
-
-	if ((p = waitpid(pid, &stat, WNOHANG)) < 0)
-		die("waiting for pid %hd failed: %s\n", pid, strerror(errno));
-
-	if (pid != p)
-		return;
-
-	if (WIFEXITED(stat) && WEXITSTATUS(stat))
-		die("child exited with status %d\n", WEXITSTATUS(stat));
-	else if (WIFSIGNALED(stat))
-		die("child terminated due to signal %d\n", WTERMSIG(stat));
-	_exit(0);
-}
-
-void
-stty(char **args)
-{
-	char cmd[_POSIX_ARG_MAX], **p, *q, *s;
-	size_t n, siz;
-
-	if ((n = strlen(stty_args)) > sizeof(cmd)-1)
-		die("incorrect stty parameters\n");
-	memcpy(cmd, stty_args, n);
-	q = cmd + n;
-	siz = sizeof(cmd) - n;
-	for (p = args; p && (s = *p); ++p) {
-		if ((n = strlen(s)) > siz-1)
-			die("stty parameter length too long\n");
-		*q++ = ' ';
-		memcpy(q, s, n);
-		q += n;
-		siz -= n + 1;
-	}
-	*q = '\0';
-	if (system(cmd) != 0)
-		perror("Couldn't call stty");
-}
-
-int
-ttynew(const char *line, char *cmd, const char *out, char **args)
-{
-	int m, s;
-
-	if (out) {
-		term.mode |= MODE_PRINT;
-		iofd = (!strcmp(out, "-")) ?
-			  1 : open(out, O_WRONLY | O_CREAT, 0666);
-		if (iofd < 0) {
-			fprintf(stderr, "Error opening %s:%s\n",
-				out, strerror(errno));
-		}
-	}
-
-	if (line) {
-		if ((cmdfd = open(line, O_RDWR)) < 0)
-			die("open line '%s' failed: %s\n",
-			    line, strerror(errno));
-		dup2(cmdfd, 0);
-		stty(args);
-		return cmdfd;
-	}
-
-	/* seems to work fine on linux, openbsd and freebsd */
-	if (openpty(&m, &s, NULL, NULL, NULL) < 0)
-		die("openpty failed: %s\n", strerror(errno));
-
-	switch (pid = fork()) {
-	case -1:
-		die("fork failed: %s\n", strerror(errno));
-		break;
-	case 0:
-		close(iofd);
-		close(m);
-		setsid(); /* create a new process group */
-		dup2(s, 0);
-		dup2(s, 1);
-		dup2(s, 2);
-		if (ioctl(s, TIOCSCTTY, NULL) < 0)
-			die("ioctl TIOCSCTTY failed: %s\n", strerror(errno));
-		if (s > 2)
-			close(s);
-#ifdef __OpenBSD__
-		if (pledge("stdio getpw proc exec", NULL) == -1)
-			die("pledge\n");
-#endif
-		execsh(cmd, args);
-		break;
-	default:
-#ifdef __OpenBSD__
-		if (pledge("stdio rpath tty proc", NULL) == -1)
-			die("pledge\n");
-#endif
-		close(s);
-		cmdfd = m;
-		signal(SIGCHLD, sigchld);
-		break;
-	}
-	return cmdfd;
-}
-
-size_t
-ttyread(void)
-{
-	static char buf[BUFSIZ];
-	static int buflen = 0;
-	int ret, written;
-
-	/* append read bytes to unprocessed bytes */
-	ret = read(cmdfd, buf+buflen, LEN(buf)-buflen);
-
-	switch (ret) {
-	case 0:
-		exit(0);
-	case -1:
-		die("couldn't read from shell: %s\n", strerror(errno));
-	default:
-		buflen += ret;
-		written = twrite(buf, buflen, 0);
-		buflen -= written;
-		/* keep any incomplete UTF-8 byte sequence for the next call */
-		if (buflen > 0)
-			memmove(buf, buf + written, buflen);
-		return ret;
-	}
-}
-
-void
-ttywrite(const char *s, size_t n, int may_echo)
-{
-	const char *next;
-
-	if (may_echo && IS_SET(MODE_ECHO))
-		twrite(s, n, 1);
-
-	if (!IS_SET(MODE_CRLF)) {
-		ttywriteraw(s, n);
-		return;
-	}
-
-	/* This is similar to how the kernel handles ONLCR for ttys */
-	while (n > 0) {
-		if (*s == '\r') {
-			next = s + 1;
-			ttywriteraw("\r\n", 2);
-		} else {
-			next = memchr(s, '\r', n);
-			DEFAULT(next, s + n);
-			ttywriteraw(s, next - s);
-		}
-		n -= next - s;
-		s = next;
-	}
-}
-
-void
-ttywriteraw(const char *s, size_t n)
-{
-	fd_set wfd, rfd;
-	ssize_t r;
-	size_t lim = 256;
-
-	/*
-	 * Remember that we are using a pty, which might be a modem line.
-	 * Writing too much will clog the line. That's why we are doing this
-	 * dance.
-	 * FIXME: Migrate the world to Plan 9.
-	 */
-	while (n > 0) {
-		FD_ZERO(&wfd);
-		FD_ZERO(&rfd);
-		FD_SET(cmdfd, &wfd);
-		FD_SET(cmdfd, &rfd);
-
-		/* Check if we can write. */
-		if (pselect(cmdfd+1, &rfd, &wfd, NULL, NULL, NULL) < 0) {
-			if (errno == EINTR)
-				continue;
-			die("select failed: %s\n", strerror(errno));
-		}
-		if (FD_ISSET(cmdfd, &wfd)) {
-			/*
-			 * Only write the bytes written by ttywrite() or the
-			 * default of 256. This seems to be a reasonable value
-			 * for a serial line. Bigger values might clog the I/O.
-			 */
-			if ((r = write(cmdfd, s, (n < lim)? n : lim)) < 0)
-				goto write_error;
-			if (r < n) {
-				/*
-				 * We weren't able to write out everything.
-				 * This means the buffer is getting full
-				 * again. Empty it.
-				 */
-				if (n < lim)
-					lim = ttyread();
-				n -= r;
-				s += r;
-			} else {
-				/* All bytes have been written. */
-				break;
-			}
-		}
-		if (FD_ISSET(cmdfd, &rfd))
-			lim = ttyread();
-	}
-	return;
-
-write_error:
-	die("write error on tty: %s\n", strerror(errno));
-}
-
-void
-ttyresize(int tw, int th)
-{
-	struct winsize w;
-
-	w.ws_row = term.row;
-	w.ws_col = term.col;
-	w.ws_xpixel = tw;
-	w.ws_ypixel = th;
-	if (ioctl(cmdfd, TIOCSWINSZ, &w) < 0)
-		fprintf(stderr, "Couldn't set window size: %s\n", strerror(errno));
-}
-
-void
-ttyhangup(void)
-{
-	/* Send SIGHUP to shell */
-	kill(pid, SIGHUP);
-}
-
-int
-tattrset(int attr)
-{
-	int i, j;
-
-	for (i = 0; i < term.row-1; i++) {
-		for (j = 0; j < term.col-1; j++) {
-			if (term.line[i][j].mode & attr)
-				return 1;
-		}
-	}
-
-	return 0;
-}
-
-void
-tsetdirt(int top, int bot)
-{
-	int i;
-
-	LIMIT(top, 0, term.row-1);
-	LIMIT(bot, 0, term.row-1);
-
-	for (i = top; i <= bot; i++)
-		term.dirty[i] = 1;
-}
-
-void
-tsetdirtattr(int attr)
-{
-	int i, j;
-
-	for (i = 0; i < term.row-1; i++) {
-		for (j = 0; j < term.col-1; j++) {
-			if (term.line[i][j].mode & attr) {
-				tsetdirt(i, i);
-				break;
-			}
-		}
-	}
-}
-
-void
-tfulldirt(void)
-{
-	tsetdirt(0, term.row-1);
-}
-
-void
-tcursor(int mode)
-{
-	static TCursor c[2];
-	int alt = IS_SET(MODE_ALTSCREEN);
-
-	if (mode == CURSOR_SAVE) {
-		c[alt] = term.c;
-	} else if (mode == CURSOR_LOAD) {
-		term.c = c[alt];
-		tmoveto(c[alt].x, c[alt].y);
-	}
-}
-
-void
-treset(void)
-{
-	uint i;
-
-	term.c = (TCursor){{
-		.mode = ATTR_NULL,
-		.fg = defaultfg,
-		.bg = defaultbg
-	}, .x = 0, .y = 0, .state = CURSOR_DEFAULT};
-
-	memset(term.tabs, 0, term.col * sizeof(*term.tabs));
-	for (i = tabspaces; i < term.col; i += tabspaces)
-		term.tabs[i] = 1;
-	term.top = 0;
-	term.bot = term.row - 1;
-	term.mode = MODE_WRAP|MODE_UTF8;
-	memset(term.trantbl, CS_USA, sizeof(term.trantbl));
-	term.charset = 0;
-
-	for (i = 0; i < 2; i++) {
-		tmoveto(0, 0);
-		tcursor(CURSOR_SAVE);
-		tclearregion(0, 0, term.col-1, term.row-1);
-		tswapscreen();
-	}
-}
-
-void
-tnew(int col, int row)
-{
-	term = (Term){ .c = { .attr = { .fg = defaultfg, .bg = defaultbg } } };
-	tresize(col, row);
-	treset();
-}
-
-void
-tswapscreen(void)
-{
-	Line *tmp = term.line;
-
-	term.line = term.alt;
-	term.alt = tmp;
-	term.mode ^= MODE_ALTSCREEN;
-	tfulldirt();
-}
-
-void
-tscrolldown(int orig, int n)
-{
-	int i;
-	Line temp;
-
-	LIMIT(n, 0, term.bot-orig+1);
-
-	tsetdirt(orig, term.bot-n);
-	tclearregion(0, term.bot-n+1, term.col-1, term.bot);
-
-	for (i = term.bot; i >= orig+n; i--) {
-		temp = term.line[i];
-		term.line[i] = term.line[i-n];
-		term.line[i-n] = temp;
-	}
-
-	selscroll(orig, n);
-}
-
-void
-tscrollup(int orig, int n)
-{
-	int i;
-	Line temp;
-
-	LIMIT(n, 0, term.bot-orig+1);
-
-	tclearregion(0, orig, term.col-1, orig+n-1);
-	tsetdirt(orig+n, term.bot);
-
-	for (i = orig; i <= term.bot-n; i++) {
-		temp = term.line[i];
-		term.line[i] = term.line[i+n];
-		term.line[i+n] = temp;
-	}
-
-	selscroll(orig, -n);
-}
-
-void
-selscroll(int orig, int n)
-{
-	if (sel.ob.x == -1 || sel.alt != IS_SET(MODE_ALTSCREEN))
-		return;
-
-	if (BETWEEN(sel.nb.y, orig, term.bot) != BETWEEN(sel.ne.y, orig, term.bot)) {
-		selclear();
-	} else if (BETWEEN(sel.nb.y, orig, term.bot)) {
-		sel.ob.y += n;
-		sel.oe.y += n;
-		if (sel.ob.y < term.top || sel.ob.y > term.bot ||
-		    sel.oe.y < term.top || sel.oe.y > term.bot) {
-			selclear();
-		} else {
-			selnormalize();
-		}
-	}
-}
-
-void
-tnewline(int first_col)
-{
-	int y = term.c.y;
-
-	if (y == term.bot) {
-		tscrollup(term.top, 1);
-	} else {
-		y++;
-	}
-	tmoveto(first_col ? 0 : term.c.x, y);
-}
-
-void
-csiparse(void)
-{
-	char *p = csiescseq.buf, *np;
-	long int v;
-	int sep = ';'; /* colon or semi-colon, but not both */
-
-	csiescseq.narg = 0;
-	if (*p == '?') {
-		csiescseq.priv = 1;
-		p++;
-	}
-
-	csiescseq.buf[csiescseq.len] = '\0';
-	while (p < csiescseq.buf+csiescseq.len) {
-		np = NULL;
-		v = strtol(p, &np, 10);
-		if (np == p)
-			v = 0;
-		if (v == LONG_MAX || v == LONG_MIN)
-			v = -1;
-		csiescseq.arg[csiescseq.narg++] = v;
-		p = np;
-		if (sep == ';' && *p == ':')
-			sep = ':'; /* allow override to colon once */
-		if (*p != sep || csiescseq.narg == ESC_ARG_SIZ)
-			break;
-		p++;
-	}
-	csiescseq.mode[0] = *p++;
-	csiescseq.mode[1] = (p < csiescseq.buf+csiescseq.len) ? *p : '\0';
-}
-
-/* for absolute user moves, when decom is set */
-void
-tmoveato(int x, int y)
-{
-	tmoveto(x, y + ((term.c.state & CURSOR_ORIGIN) ? term.top: 0));
-}
-
-void
-tmoveto(int x, int y)
-{
-	int miny, maxy;
-
-	if (term.c.state & CURSOR_ORIGIN) {
-		miny = term.top;
-		maxy = term.bot;
-	} else {
-		miny = 0;
-		maxy = term.row - 1;
-	}
-	term.c.state &= ~CURSOR_WRAPNEXT;
-	term.c.x = LIMIT(x, 0, term.col-1);
-	term.c.y = LIMIT(y, miny, maxy);
-}
-
-void
-tsetchar(Rune u, const Glyph *attr, int x, int y)
-{
-	static const char *vt100_0[62] = { /* 0x41 - 0x7e */
-		"↑", "↓", "→", "←", "█", "▚", "☃", /* A - G */
-		0, 0, 0, 0, 0, 0, 0, 0, /* H - O */
-		0, 0, 0, 0, 0, 0, 0, 0, /* P - W */
-		0, 0, 0, 0, 0, 0, 0, " ", /* X - _ */
-		"◆", "▒", "␉", "␌", "␍", "␊", "°", "±", /* ` - g */
-		"␤", "␋", "┘", "┐", "┌", "└", "┼", "⎺", /* h - o */
-		"⎻", "─", "⎼", "⎽", "├", "┤", "┴", "┬", /* p - w */
-		"│", "≤", "≥", "π", "≠", "£", "·", /* x - ~ */
-	};
-
-	/*
-	 * The table is proudly stolen from rxvt.
-	 */
-	if (term.trantbl[term.charset] == CS_GRAPHIC0 &&
-	   BETWEEN(u, 0x41, 0x7e) && vt100_0[u - 0x41])
-		utf8decode(vt100_0[u - 0x41], &u, UTF_SIZ);
-
-	if (term.line[y][x].mode & ATTR_WIDE) {
-		if (x+1 < term.col) {
-			term.line[y][x+1].u = ' ';
-			term.line[y][x+1].mode &= ~ATTR_WDUMMY;
-		}
-	} else if (term.line[y][x].mode & ATTR_WDUMMY) {
-		term.line[y][x-1].u = ' ';
-		term.line[y][x-1].mode &= ~ATTR_WIDE;
-	}
-
-	term.dirty[y] = 1;
-	term.line[y][x] = *attr;
-	term.line[y][x].u = u;
-}
-
-void
-tclearregion(int x1, int y1, int x2, int y2)
-{
-	int x, y, temp;
-	Glyph *gp;
-
-	if (x1 > x2)
-		temp = x1, x1 = x2, x2 = temp;
-	if (y1 > y2)
-		temp = y1, y1 = y2, y2 = temp;
-
-	LIMIT(x1, 0, term.col-1);
-	LIMIT(x2, 0, term.col-1);
-	LIMIT(y1, 0, term.row-1);
-	LIMIT(y2, 0, term.row-1);
-
-	for (y = y1; y <= y2; y++) {
-		term.dirty[y] = 1;
-		for (x = x1; x <= x2; x++) {
-			gp = &term.line[y][x];
-			if (selected(x, y))
-				selclear();
-			gp->fg = term.c.attr.fg;
-			gp->bg = term.c.attr.bg;
-			gp->mode = 0;
-			gp->u = ' ';
-		}
-	}
-}
-
-void
-tdeletechar(int n)
-{
-	int dst, src, size;
-	Glyph *line;
-
-	LIMIT(n, 0, term.col - term.c.x);
-
-	dst = term.c.x;
-	src = term.c.x + n;
-	size = term.col - src;
-	line = term.line[term.c.y];
-
-	memmove(&line[dst], &line[src], size * sizeof(Glyph));
-	tclearregion(term.col-n, term.c.y, term.col-1, term.c.y);
-}
-
-void
-tinsertblank(int n)
-{
-	int dst, src, size;
-	Glyph *line;
-
-	LIMIT(n, 0, term.col - term.c.x);
-
-	dst = term.c.x + n;
-	src = term.c.x;
-	size = term.col - dst;
-	line = term.line[term.c.y];
-
-	memmove(&line[dst], &line[src], size * sizeof(Glyph));
-	tclearregion(src, term.c.y, dst - 1, term.c.y);
-}
-
-void
-tinsertblankline(int n)
-{
-	if (BETWEEN(term.c.y, term.top, term.bot))
-		tscrolldown(term.c.y, n);
-}
-
-void
-tdeleteline(int n)
-{
-	if (BETWEEN(term.c.y, term.top, term.bot))
-		tscrollup(term.c.y, n);
-}
-
-int32_t
-tdefcolor(const int *attr, int *npar, int l)
-{
-	int32_t idx = -1;
-	uint r, g, b;
-
-	switch (attr[*npar + 1]) {
-	case 2: /* direct color in RGB space */
-		if (*npar + 4 >= l) {
-			fprintf(stderr,
-				"erresc(38): Incorrect number of parameters (%d)\n",
-				*npar);
-			break;
-		}
-		r = attr[*npar + 2];
-		g = attr[*npar + 3];
-		b = attr[*npar + 4];
-		*npar += 4;
-		if (!BETWEEN(r, 0, 255) || !BETWEEN(g, 0, 255) || !BETWEEN(b, 0, 255))
-			fprintf(stderr, "erresc: bad rgb color (%u,%u,%u)\n",
-				r, g, b);
-		else
-			idx = TRUECOLOR(r, g, b);
-		break;
-	case 5: /* indexed color */
-		if (*npar + 2 >= l) {
-			fprintf(stderr,
-				"erresc(38): Incorrect number of parameters (%d)\n",
-				*npar);
-			break;
-		}
-		*npar += 2;
-		if (!BETWEEN(attr[*npar], 0, 255))
-			fprintf(stderr, "erresc: bad fgcolor %d\n", attr[*npar]);
-		else
-			idx = attr[*npar];
-		break;
-	case 0: /* implemented defined (only foreground) */
-	case 1: /* transparent */
-	case 3: /* direct color in CMY space */
-	case 4: /* direct color in CMYK space */
-	default:
-		fprintf(stderr,
-		        "erresc(38): gfx attr %d unknown\n", attr[*npar]);
-		break;
-	}
-
-	return idx;
-}
-
-void
-tsetattr(const int *attr, int l)
-{
-	int i;
-	int32_t idx;
-
-	for (i = 0; i < l; i++) {
-		switch (attr[i]) {
-		case 0:
-			term.c.attr.mode &= ~(
-				ATTR_BOLD       |
-				ATTR_FAINT      |
-				ATTR_ITALIC     |
-				ATTR_UNDERLINE  |
-				ATTR_BLINK      |
-				ATTR_REVERSE    |
-				ATTR_INVISIBLE  |
-				ATTR_STRUCK     );
-			term.c.attr.fg = defaultfg;
-			term.c.attr.bg = defaultbg;
-			break;
-		case 1:
-			term.c.attr.mode |= ATTR_BOLD;
-			break;
-		case 2:
-			term.c.attr.mode |= ATTR_FAINT;
-			break;
-		case 3:
-			term.c.attr.mode |= ATTR_ITALIC;
-			break;
-		case 4:
-			term.c.attr.mode |= ATTR_UNDERLINE;
-			break;
-		case 5: /* slow blink */
-			/* FALLTHROUGH */
-		case 6: /* rapid blink */
-			term.c.attr.mode |= ATTR_BLINK;
-			break;
-		case 7:
-			term.c.attr.mode |= ATTR_REVERSE;
-			break;
-		case 8:
-			term.c.attr.mode |= ATTR_INVISIBLE;
-			break;
-		case 9:
-			term.c.attr.mode |= ATTR_STRUCK;
-			break;
-		case 22:
-			term.c.attr.mode &= ~(ATTR_BOLD | ATTR_FAINT);
-			break;
-		case 23:
-			term.c.attr.mode &= ~ATTR_ITALIC;
-			break;
-		case 24:
-			term.c.attr.mode &= ~ATTR_UNDERLINE;
-			break;
-		case 25:
-			term.c.attr.mode &= ~ATTR_BLINK;
-			break;
-		case 27:
-			term.c.attr.mode &= ~ATTR_REVERSE;
-			break;
-		case 28:
-			term.c.attr.mode &= ~ATTR_INVISIBLE;
-			break;
-		case 29:
-			term.c.attr.mode &= ~ATTR_STRUCK;
-			break;
-		case 38:
-			if ((idx = tdefcolor(attr, &i, l)) >= 0)
-				term.c.attr.fg = idx;
-			break;
-		case 39:
-			term.c.attr.fg = defaultfg;
-			break;
-		case 48:
-			if ((idx = tdefcolor(attr, &i, l)) >= 0)
-				term.c.attr.bg = idx;
-			break;
-		case 49:
-			term.c.attr.bg = defaultbg;
-			break;
-		default:
-			if (BETWEEN(attr[i], 30, 37)) {
-				term.c.attr.fg = attr[i] - 30;
-			} else if (BETWEEN(attr[i], 40, 47)) {
-				term.c.attr.bg = attr[i] - 40;
-			} else if (BETWEEN(attr[i], 90, 97)) {
-				term.c.attr.fg = attr[i] - 90 + 8;
-			} else if (BETWEEN(attr[i], 100, 107)) {
-				term.c.attr.bg = attr[i] - 100 + 8;
-			} else {
-				fprintf(stderr,
-					"erresc(default): gfx attr %d unknown\n",
-					attr[i]);
-				csidump();
-			}
-			break;
-		}
-	}
-}
-
-void
-tsetscroll(int t, int b)
-{
-	int temp;
-
-	LIMIT(t, 0, term.row-1);
-	LIMIT(b, 0, term.row-1);
-	if (t > b) {
-		temp = t;
-		t = b;
-		b = temp;
-	}
-	term.top = t;
-	term.bot = b;
-}
-
-void
-tsetmode(int priv, int set, const int *args, int narg)
-{
-	int alt; const int *lim;
-
-	for (lim = args + narg; args < lim; ++args) {
-		if (priv) {
-			switch (*args) {
-			case 1: /* DECCKM -- Cursor key */
-				xsetmode(set, MODE_APPCURSOR);
-				break;
-			case 5: /* DECSCNM -- Reverse video */
-				xsetmode(set, MODE_REVERSE);
-				break;
-			case 6: /* DECOM -- Origin */
-				MODBIT(term.c.state, set, CURSOR_ORIGIN);
-				tmoveato(0, 0);
-				break;
-			case 7: /* DECAWM -- Auto wrap */
-				MODBIT(term.mode, set, MODE_WRAP);
-				break;
-			case 0:  /* Error (IGNORED) */
-			case 2:  /* DECANM -- ANSI/VT52 (IGNORED) */
-			case 3:  /* DECCOLM -- Column  (IGNORED) */
-			case 4:  /* DECSCLM -- Scroll (IGNORED) */
-			case 8:  /* DECARM -- Auto repeat (IGNORED) */
-			case 18: /* DECPFF -- Printer feed (IGNORED) */
-			case 19: /* DECPEX -- Printer extent (IGNORED) */
-			case 42: /* DECNRCM -- National characters (IGNORED) */
-			case 12: /* att610 -- Start blinking cursor (IGNORED) */
-				break;
-			case 25: /* DECTCEM -- Text Cursor Enable Mode */
-				xsetmode(!set, MODE_HIDE);
-				break;
-			case 9:    /* X10 mouse compatibility mode */
-				xsetpointermotion(0);
-				xsetmode(0, MODE_MOUSE);
-				xsetmode(set, MODE_MOUSEX10);
-				break;
-			case 1000: /* 1000: report button press */
-				xsetpointermotion(0);
-				xsetmode(0, MODE_MOUSE);
-				xsetmode(set, MODE_MOUSEBTN);
-				break;
-			case 1002: /* 1002: report motion on button press */
-				xsetpointermotion(0);
-				xsetmode(0, MODE_MOUSE);
-				xsetmode(set, MODE_MOUSEMOTION);
-				break;
-			case 1003: /* 1003: enable all mouse motions */
-				xsetpointermotion(set);
-				xsetmode(0, MODE_MOUSE);
-				xsetmode(set, MODE_MOUSEMANY);
-				break;
-			case 1004: /* 1004: send focus events to tty */
-				xsetmode(set, MODE_FOCUS);
-				break;
-			case 1006: /* 1006: extended reporting mode */
-				xsetmode(set, MODE_MOUSESGR);
-				break;
-			case 1034:
-				xsetmode(set, MODE_8BIT);
-				break;
-			case 1049: /* swap screen & set/restore cursor as xterm */
-				if (!allowaltscreen)
-					break;
-				tcursor((set) ? CURSOR_SAVE : CURSOR_LOAD);
-				/* FALLTHROUGH */
-			case 47: /* swap screen */
-			case 1047:
-				if (!allowaltscreen)
-					break;
-				alt = IS_SET(MODE_ALTSCREEN);
-				if (alt) {
-					tclearregion(0, 0, term.col-1,
-							term.row-1);
-				}
-				if (set ^ alt) /* set is always 1 or 0 */
-					tswapscreen();
-				if (*args != 1049)
-					break;
-				/* FALLTHROUGH */
-			case 1048:
-				tcursor((set) ? CURSOR_SAVE : CURSOR_LOAD);
-				break;
-			case 2004: /* 2004: bracketed paste mode */
-				xsetmode(set, MODE_BRCKTPASTE);
-				break;
-			/* Not implemented mouse modes. See comments there. */
-			case 1001: /* mouse highlight mode; can hang the
-				      terminal by design when implemented. */
-			case 1005: /* UTF-8 mouse mode; will confuse
-				      applications not supporting UTF-8
-				      and luit. */
-			case 1015: /* urxvt mangled mouse mode; incompatible
-				      and can be mistaken for other control
-				      codes. */
-				break;
-			default:
-				fprintf(stderr,
-					"erresc: unknown private set/reset mode %d\n",
-					*args);
-				break;
-			}
-		} else {
-			switch (*args) {
-			case 0:  /* Error (IGNORED) */
-				break;
-			case 2:
-				xsetmode(set, MODE_KBDLOCK);
-				break;
-			case 4:  /* IRM -- Insertion-replacement */
-				MODBIT(term.mode, set, MODE_INSERT);
-				break;
-			case 12: /* SRM -- Send/Receive */
-				MODBIT(term.mode, !set, MODE_ECHO);
-				break;
-			case 20: /* LNM -- Linefeed/new line */
-				MODBIT(term.mode, set, MODE_CRLF);
-				break;
-			default:
-				fprintf(stderr,
-					"erresc: unknown set/reset mode %d\n",
-					*args);
-				break;
-			}
-		}
-	}
-}
-
-void
-csihandle(void)
-{
-	char buf[40];
-	int len;
-
-	switch (csiescseq.mode[0]) {
-	default:
-	unknown:
-		fprintf(stderr, "erresc: unknown csi ");
-		csidump();
-		/* die(""); */
-		break;
-	case '@': /* ICH -- Insert <n> blank char */
-		DEFAULT(csiescseq.arg[0], 1);
-		tinsertblank(csiescseq.arg[0]);
-		break;
-	case 'A': /* CUU -- Cursor <n> Up */
-		DEFAULT(csiescseq.arg[0], 1);
-		tmoveto(term.c.x, term.c.y-csiescseq.arg[0]);
-		break;
-	case 'B': /* CUD -- Cursor <n> Down */
-	case 'e': /* VPR --Cursor <n> Down */
-		DEFAULT(csiescseq.arg[0], 1);
-		tmoveto(term.c.x, term.c.y+csiescseq.arg[0]);
-		break;
-	case 'i': /* MC -- Media Copy */
-		switch (csiescseq.arg[0]) {
-		case 0:
-			tdump();
-			break;
-		case 1:
-			tdumpline(term.c.y);
-			break;
-		case 2:
-			tdumpsel();
-			break;
-		case 4:
-			term.mode &= ~MODE_PRINT;
-			break;
-		case 5:
-			term.mode |= MODE_PRINT;
-			break;
-		}
-		break;
-	case 'c': /* DA -- Device Attributes */
-		if (csiescseq.arg[0] == 0)
-			ttywrite(vtiden, strlen(vtiden), 0);
-		break;
-	case 'b': /* REP -- if last char is printable print it <n> more times */
-		LIMIT(csiescseq.arg[0], 1, 65535);
-		if (term.lastc)
-			while (csiescseq.arg[0]-- > 0)
-				tputc(term.lastc);
-		break;
-	case 'C': /* CUF -- Cursor <n> Forward */
-	case 'a': /* HPR -- Cursor <n> Forward */
-		DEFAULT(csiescseq.arg[0], 1);
-		tmoveto(term.c.x+csiescseq.arg[0], term.c.y);
-		break;
-	case 'D': /* CUB -- Cursor <n> Backward */
-		DEFAULT(csiescseq.arg[0], 1);
-		tmoveto(term.c.x-csiescseq.arg[0], term.c.y);
-		break;
-	case 'E': /* CNL -- Cursor <n> Down and first col */
-		DEFAULT(csiescseq.arg[0], 1);
-		tmoveto(0, term.c.y+csiescseq.arg[0]);
-		break;
-	case 'F': /* CPL -- Cursor <n> Up and first col */
-		DEFAULT(csiescseq.arg[0], 1);
-		tmoveto(0, term.c.y-csiescseq.arg[0]);
-		break;
-	case 'g': /* TBC -- Tabulation clear */
-		switch (csiescseq.arg[0]) {
-		case 0: /* clear current tab stop */
-			term.tabs[term.c.x] = 0;
-			break;
-		case 3: /* clear all the tabs */
-			memset(term.tabs, 0, term.col * sizeof(*term.tabs));
-			break;
-		default:
-			goto unknown;
-		}
-		break;
-	case 'G': /* CHA -- Move to <col> */
-	case '`': /* HPA */
-		DEFAULT(csiescseq.arg[0], 1);
-		tmoveto(csiescseq.arg[0]-1, term.c.y);
-		break;
-	case 'H': /* CUP -- Move to <row> <col> */
-	case 'f': /* HVP */
-		DEFAULT(csiescseq.arg[0], 1);
-		DEFAULT(csiescseq.arg[1], 1);
-		tmoveato(csiescseq.arg[1]-1, csiescseq.arg[0]-1);
-		break;
-	case 'I': /* CHT -- Cursor Forward Tabulation <n> tab stops */
-		DEFAULT(csiescseq.arg[0], 1);
-		tputtab(csiescseq.arg[0]);
-		break;
-	case 'J': /* ED -- Clear screen */
-		switch (csiescseq.arg[0]) {
-		case 0: /* below */
-			tclearregion(term.c.x, term.c.y, term.col-1, term.c.y);
-			if (term.c.y < term.row-1) {
-				tclearregion(0, term.c.y+1, term.col-1,
-						term.row-1);
-			}
-			break;
-		case 1: /* above */
-			if (term.c.y > 0)
-				tclearregion(0, 0, term.col-1, term.c.y-1);
-			tclearregion(0, term.c.y, term.c.x, term.c.y);
-			break;
-		case 2: /* all */
-			tclearregion(0, 0, term.col-1, term.row-1);
-			break;
-		default:
-			goto unknown;
-		}
-		break;
-	case 'K': /* EL -- Clear line */
-		switch (csiescseq.arg[0]) {
-		case 0: /* right */
-			tclearregion(term.c.x, term.c.y, term.col-1,
-					term.c.y);
-			break;
-		case 1: /* left */
-			tclearregion(0, term.c.y, term.c.x, term.c.y);
-			break;
-		case 2: /* all */
-			tclearregion(0, term.c.y, term.col-1, term.c.y);
-			break;
-		}
-		break;
-	case 'S': /* SU -- Scroll <n> line up */
-		if (csiescseq.priv) break;
-		DEFAULT(csiescseq.arg[0], 1);
-		tscrollup(term.top, csiescseq.arg[0]);
-		break;
-	case 'T': /* SD -- Scroll <n> line down */
-		DEFAULT(csiescseq.arg[0], 1);
-		tscrolldown(term.top, csiescseq.arg[0]);
-		break;
-	case 'L': /* IL -- Insert <n> blank lines */
-		DEFAULT(csiescseq.arg[0], 1);
-		tinsertblankline(csiescseq.arg[0]);
-		break;
-	case 'l': /* RM -- Reset Mode */
-		tsetmode(csiescseq.priv, 0, csiescseq.arg, csiescseq.narg);
-		break;
-	case 'M': /* DL -- Delete <n> lines */
-		DEFAULT(csiescseq.arg[0], 1);
-		tdeleteline(csiescseq.arg[0]);
-		break;
-	case 'X': /* ECH -- Erase <n> char */
-		DEFAULT(csiescseq.arg[0], 1);
-		tclearregion(term.c.x, term.c.y,
-				term.c.x + csiescseq.arg[0] - 1, term.c.y);
-		break;
-	case 'P': /* DCH -- Delete <n> char */
-		DEFAULT(csiescseq.arg[0], 1);
-		tdeletechar(csiescseq.arg[0]);
-		break;
-	case 'Z': /* CBT -- Cursor Backward Tabulation <n> tab stops */
-		DEFAULT(csiescseq.arg[0], 1);
-		tputtab(-csiescseq.arg[0]);
-		break;
-	case 'd': /* VPA -- Move to <row> */
-		DEFAULT(csiescseq.arg[0], 1);
-		tmoveato(term.c.x, csiescseq.arg[0]-1);
-		break;
-	case 'h': /* SM -- Set terminal mode */
-		tsetmode(csiescseq.priv, 1, csiescseq.arg, csiescseq.narg);
-		break;
-	case 'm': /* SGR -- Terminal attribute (color) */
-		tsetattr(csiescseq.arg, csiescseq.narg);
-		break;
-	case 'n': /* DSR -- Device Status Report */
-		switch (csiescseq.arg[0]) {
-		case 5: /* Status Report "OK" `0n` */
-			ttywrite("\033[0n", sizeof("\033[0n") - 1, 0);
-			break;
-		case 6: /* Report Cursor Position (CPR) "<row>;<column>R" */
-			len = snprintf(buf, sizeof(buf), "\033[%i;%iR",
-			               term.c.y+1, term.c.x+1);
-			ttywrite(buf, len, 0);
-			break;
-		default:
-			goto unknown;
-		}
-		break;
-	case 'r': /* DECSTBM -- Set Scrolling Region */
-		if (csiescseq.priv) {
-			goto unknown;
-		} else {
-			DEFAULT(csiescseq.arg[0], 1);
-			DEFAULT(csiescseq.arg[1], term.row);
-			tsetscroll(csiescseq.arg[0]-1, csiescseq.arg[1]-1);
-			tmoveato(0, 0);
-		}
-		break;
-	case 's': /* DECSC -- Save cursor position (ANSI.SYS) */
-		tcursor(CURSOR_SAVE);
-		break;
-	case 'u': /* DECRC -- Restore cursor position (ANSI.SYS) */
-		if (csiescseq.priv) {
-			goto unknown;
-		} else {
-			tcursor(CURSOR_LOAD);
-		}
-		break;
-	case ' ':
-		switch (csiescseq.mode[1]) {
-		case 'q': /* DECSCUSR -- Set Cursor Style */
-			if (xsetcursor(csiescseq.arg[0]))
-				goto unknown;
-			break;
-		default:
-			goto unknown;
-		}
-		break;
-	}
-}
-
-void
-csidump(void)
-{
-	size_t i;
-	uint c;
-
-	fprintf(stderr, "ESC[");
-	for (i = 0; i < csiescseq.len; i++) {
-		c = csiescseq.buf[i] & 0xff;
-		if (isprint(c)) {
-			putc(c, stderr);
-		} else if (c == '\n') {
-			fprintf(stderr, "(\\n)");
-		} else if (c == '\r') {
-			fprintf(stderr, "(\\r)");
-		} else if (c == 0x1b) {
-			fprintf(stderr, "(\\e)");
-		} else {
-			fprintf(stderr, "(%02x)", c);
-		}
-	}
-	putc('\n', stderr);
-}
-
-void
-csireset(void)
-{
-	memset(&csiescseq, 0, sizeof(csiescseq));
-}
-
-void
-osc_color_response(int num, int index, int is_osc4)
-{
-	int n;
-	char buf[32];
-	unsigned char r, g, b;
-
-	if (xgetcolor(is_osc4 ? num : index, &r, &g, &b)) {
-		fprintf(stderr, "erresc: failed to fetch %s color %d\n",
-		        is_osc4 ? "osc4" : "osc",
-		        is_osc4 ? num : index);
-		return;
-	}
-
-	n = snprintf(buf, sizeof buf, "\033]%s%d;rgb:%02x%02x/%02x%02x/%02x%02x\007",
-	             is_osc4 ? "4;" : "", num, r, r, g, g, b, b);
-	if (n < 0 || n >= sizeof(buf)) {
-		fprintf(stderr, "error: %s while printing %s response\n",
-		        n < 0 ? "snprintf failed" : "truncation occurred",
-		        is_osc4 ? "osc4" : "osc");
-	} else {
-		ttywrite(buf, n, 1);
-	}
-}
-
-void
-strhandle(void)
-{
-	char *p = NULL, *dec;
-	int j, narg, par;
-	const struct { int idx; char *str; } osc_table[] = {
-		{ defaultfg, "foreground" },
-		{ defaultbg, "background" },
-		{ defaultcs, "cursor" }
-	};
-
-	term.esc &= ~(ESC_STR_END|ESC_STR);
-	strparse();
-	par = (narg = strescseq.narg) ? atoi(strescseq.args[0]) : 0;
-
-	switch (strescseq.type) {
-	case ']': /* OSC -- Operating System Command */
-		switch (par) {
-		case 0:
-			if (narg > 1) {
-				xsettitle(strescseq.args[1]);
-				xseticontitle(strescseq.args[1]);
-			}
-			return;
-		case 1:
-			if (narg > 1)
-				xseticontitle(strescseq.args[1]);
-			return;
-		case 2:
-			if (narg > 1)
-				xsettitle(strescseq.args[1]);
-			return;
-		case 52:
-			if (narg > 2 && allowwindowops) {
-				dec = base64dec(strescseq.args[2]);
-				if (dec) {
-					xsetsel(dec);
-					xclipcopy();
-				} else {
-					fprintf(stderr, "erresc: invalid base64\n");
-				}
-			}
-			return;
-		case 10:
-		case 11:
-		case 12:
-			if (narg < 2)
-				break;
-			p = strescseq.args[1];
-			if ((j = par - 10) < 0 || j >= LEN(osc_table))
-				break; /* shouldn't be possible */
-
-			if (!strcmp(p, "?")) {
-				osc_color_response(par, osc_table[j].idx, 0);
-			} else if (xsetcolorname(osc_table[j].idx, p)) {
-				fprintf(stderr, "erresc: invalid %s color: %s\n",
-				        osc_table[j].str, p);
-			} else {
-				tfulldirt();
-			}
-			return;
-		case 4: /* color set */
-			if (narg < 3)
-				break;
-			p = strescseq.args[2];
-			/* FALLTHROUGH */
-		case 104: /* color reset */
-			j = (narg > 1) ? atoi(strescseq.args[1]) : -1;
-
-			if (p && !strcmp(p, "?")) {
-				osc_color_response(j, 0, 1);
-			} else if (xsetcolorname(j, p)) {
-				if (par == 104 && narg <= 1) {
-					xloadcols();
-					return; /* color reset without parameter */
-				}
-				fprintf(stderr, "erresc: invalid color j=%d, p=%s\n",
-				        j, p ? p : "(null)");
-			} else {
-				/*
-				 * TODO if defaultbg color is changed, borders
-				 * are dirty
-				 */
-				tfulldirt();
-			}
-			return;
-		}
-		break;
-	case 'k': /* old title set compatibility */
-		xsettitle(strescseq.args[0]);
-		return;
-	case 'P': /* DCS -- Device Control String */
-	case '_': /* APC -- Application Program Command */
-	case '^': /* PM -- Privacy Message */
-		return;
-	}
-
-	fprintf(stderr, "erresc: unknown str ");
-	strdump();
-}
-
-void
-strparse(void)
-{
-	int c;
-	char *p = strescseq.buf;
-
-	strescseq.narg = 0;
-	strescseq.buf[strescseq.len] = '\0';
-
-	if (*p == '\0')
-		return;
-
-	while (strescseq.narg < STR_ARG_SIZ) {
-		strescseq.args[strescseq.narg++] = p;
-		while ((c = *p) != ';' && c != '\0')
-			++p;
-		if (c == '\0')
-			return;
-		*p++ = '\0';
-	}
-}
-
-void
-strdump(void)
-{
-	size_t i;
-	uint c;
-
-	fprintf(stderr, "ESC%c", strescseq.type);
-	for (i = 0; i < strescseq.len; i++) {
-		c = strescseq.buf[i] & 0xff;
-		if (c == '\0') {
-			putc('\n', stderr);
-			return;
-		} else if (isprint(c)) {
-			putc(c, stderr);
-		} else if (c == '\n') {
-			fprintf(stderr, "(\\n)");
-		} else if (c == '\r') {
-			fprintf(stderr, "(\\r)");
-		} else if (c == 0x1b) {
-			fprintf(stderr, "(\\e)");
-		} else {
-			fprintf(stderr, "(%02x)", c);
-		}
-	}
-	fprintf(stderr, "ESC\\\n");
-}
-
-void
-strreset(void)
-{
-	strescseq = (STREscape){
-		.buf = xrealloc(strescseq.buf, STR_BUF_SIZ),
-		.siz = STR_BUF_SIZ,
-	};
-}
-
-void
-sendbreak(const Arg *arg)
-{
-	if (tcsendbreak(cmdfd, 0))
-		perror("Error sending break");
-}
-
-void
-tprinter(char *s, size_t len)
-{
-	if (iofd != -1 && xwrite(iofd, s, len) < 0) {
-		perror("Error writing to output file");
-		close(iofd);
-		iofd = -1;
-	}
-}
-
-void
-toggleprinter(const Arg *arg)
-{
-	term.mode ^= MODE_PRINT;
-}
-
-void
-printscreen(const Arg *arg)
-{
-	tdump();
-}
-
-void
-printsel(const Arg *arg)
-{
-	tdumpsel();
-}
-
-void
-tdumpsel(void)
-{
-	char *ptr;
-
-	if ((ptr = getsel())) {
-		tprinter(ptr, strlen(ptr));
-		free(ptr);
-	}
-}
-
-void
-tdumpline(int n)
-{
-	char buf[UTF_SIZ];
-	const Glyph *bp, *end;
-
-	bp = &term.line[n][0];
-	end = &bp[MIN(tlinelen(n), term.col) - 1];
-	if (bp != end || bp->u != ' ') {
-		for ( ; bp <= end; ++bp)
-			tprinter(buf, utf8encode(bp->u, buf));
-	}
-	tprinter("\n", 1);
-}
-
-void
-tdump(void)
-{
-	int i;
-
-	for (i = 0; i < term.row; ++i)
-		tdumpline(i);
-}
-
-void
-tputtab(int n)
-{
-	uint x = term.c.x;
-
-	if (n > 0) {
-		while (x < term.col && n--)
-			for (++x; x < term.col && !term.tabs[x]; ++x)
-				/* nothing */ ;
-	} else if (n < 0) {
-		while (x > 0 && n++)
-			for (--x; x > 0 && !term.tabs[x]; --x)
-				/* nothing */ ;
-	}
-	term.c.x = LIMIT(x, 0, term.col-1);
-}
-
-void
-tdefutf8(char ascii)
-{
-	if (ascii == 'G')
-		term.mode |= MODE_UTF8;
-	else if (ascii == '@')
-		term.mode &= ~MODE_UTF8;
-}
-
-void
-tdeftran(char ascii)
-{
-	static char cs[] = "0B";
-	static int vcs[] = {CS_GRAPHIC0, CS_USA};
-	char *p;
-
-	if ((p = strchr(cs, ascii)) == NULL) {
-		fprintf(stderr, "esc unhandled charset: ESC ( %c\n", ascii);
-	} else {
-		term.trantbl[term.icharset] = vcs[p - cs];
-	}
-}
-
-void
-tdectest(char c)
-{
-	int x, y;
-
-	if (c == '8') { /* DEC screen alignment test. */
-		for (x = 0; x < term.col; ++x) {
-			for (y = 0; y < term.row; ++y)
-				tsetchar('E', &term.c.attr, x, y);
-		}
-	}
-}
-
-void
-tstrsequence(uchar c)
-{
-	switch (c) {
-	case 0x90:   /* DCS -- Device Control String */
-		c = 'P';
-		break;
-	case 0x9f:   /* APC -- Application Program Command */
-		c = '_';
-		break;
-	case 0x9e:   /* PM -- Privacy Message */
-		c = '^';
-		break;
-	case 0x9d:   /* OSC -- Operating System Command */
-		c = ']';
-		break;
-	}
-	strreset();
-	strescseq.type = c;
-	term.esc |= ESC_STR;
-}
-
-void
-tcontrolcode(uchar ascii)
-{
-	switch (ascii) {
-	case '\t':   /* HT */
-		tputtab(1);
-		return;
-	case '\b':   /* BS */
-		tmoveto(term.c.x-1, term.c.y);
-		return;
-	case '\r':   /* CR */
-		tmoveto(0, term.c.y);
-		return;
-	case '\f':   /* LF */
-	case '\v':   /* VT */
-	case '\n':   /* LF */
-		/* go to first col if the mode is set */
-		tnewline(IS_SET(MODE_CRLF));
-		return;
-	case '\a':   /* BEL */
-		if (term.esc & ESC_STR_END) {
-			/* backwards compatibility to xterm */
-			strhandle();
-		} else {
-			xbell();
-		}
-		break;
-	case '\033': /* ESC */
-		csireset();
-		term.esc &= ~(ESC_CSI|ESC_ALTCHARSET|ESC_TEST);
-		term.esc |= ESC_START;
-		return;
-	case '\016': /* SO (LS1 -- Locking shift 1) */
-	case '\017': /* SI (LS0 -- Locking shift 0) */
-		term.charset = 1 - (ascii - '\016');
-		return;
-	case '\032': /* SUB */
-		tsetchar('?', &term.c.attr, term.c.x, term.c.y);
-		/* FALLTHROUGH */
-	case '\030': /* CAN */
-		csireset();
-		break;
-	case '\005': /* ENQ (IGNORED) */
-	case '\000': /* NUL (IGNORED) */
-	case '\021': /* XON (IGNORED) */
-	case '\023': /* XOFF (IGNORED) */
-	case 0177:   /* DEL (IGNORED) */
-		return;
-	case 0x80:   /* TODO: PAD */
-	case 0x81:   /* TODO: HOP */
-	case 0x82:   /* TODO: BPH */
-	case 0x83:   /* TODO: NBH */
-	case 0x84:   /* TODO: IND */
-		break;
-	case 0x85:   /* NEL -- Next line */
-		tnewline(1); /* always go to first col */
-		break;
-	case 0x86:   /* TODO: SSA */
-	case 0x87:   /* TODO: ESA */
-		break;
-	case 0x88:   /* HTS -- Horizontal tab stop */
-		term.tabs[term.c.x] = 1;
-		break;
-	case 0x89:   /* TODO: HTJ */
-	case 0x8a:   /* TODO: VTS */
-	case 0x8b:   /* TODO: PLD */
-	case 0x8c:   /* TODO: PLU */
-	case 0x8d:   /* TODO: RI */
-	case 0x8e:   /* TODO: SS2 */
-	case 0x8f:   /* TODO: SS3 */
-	case 0x91:   /* TODO: PU1 */
-	case 0x92:   /* TODO: PU2 */
-	case 0x93:   /* TODO: STS */
-	case 0x94:   /* TODO: CCH */
-	case 0x95:   /* TODO: MW */
-	case 0x96:   /* TODO: SPA */
-	case 0x97:   /* TODO: EPA */
-	case 0x98:   /* TODO: SOS */
-	case 0x99:   /* TODO: SGCI */
-		break;
-	case 0x9a:   /* DECID -- Identify Terminal */
-		ttywrite(vtiden, strlen(vtiden), 0);
-		break;
-	case 0x9b:   /* TODO: CSI */
-	case 0x9c:   /* TODO: ST */
-		break;
-	case 0x90:   /* DCS -- Device Control String */
-	case 0x9d:   /* OSC -- Operating System Command */
-	case 0x9e:   /* PM -- Privacy Message */
-	case 0x9f:   /* APC -- Application Program Command */
-		tstrsequence(ascii);
-		return;
-	}
-	/* only CAN, SUB, \a and C1 chars interrupt a sequence */
-	term.esc &= ~(ESC_STR_END|ESC_STR);
-}
-
-/*
- * returns 1 when the sequence is finished and it hasn't to read
- * more characters for this sequence, otherwise 0
- */
-int
-eschandle(uchar ascii)
-{
-	switch (ascii) {
-	case '[':
-		term.esc |= ESC_CSI;
-		return 0;
-	case '#':
-		term.esc |= ESC_TEST;
-		return 0;
-	case '%':
-		term.esc |= ESC_UTF8;
-		return 0;
-	case 'P': /* DCS -- Device Control String */
-	case '_': /* APC -- Application Program Command */
-	case '^': /* PM -- Privacy Message */
-	case ']': /* OSC -- Operating System Command */
-	case 'k': /* old title set compatibility */
-		tstrsequence(ascii);
-		return 0;
-	case 'n': /* LS2 -- Locking shift 2 */
-	case 'o': /* LS3 -- Locking shift 3 */
-		term.charset = 2 + (ascii - 'n');
-		break;
-	case '(': /* GZD4 -- set primary charset G0 */
-	case ')': /* G1D4 -- set secondary charset G1 */
-	case '*': /* G2D4 -- set tertiary charset G2 */
-	case '+': /* G3D4 -- set quaternary charset G3 */
-		term.icharset = ascii - '(';
-		term.esc |= ESC_ALTCHARSET;
-		return 0;
-	case 'D': /* IND -- Linefeed */
-		if (term.c.y == term.bot) {
-			tscrollup(term.top, 1);
-		} else {
-			tmoveto(term.c.x, term.c.y+1);
-		}
-		break;
-	case 'E': /* NEL -- Next line */
-		tnewline(1); /* always go to first col */
-		break;
-	case 'H': /* HTS -- Horizontal tab stop */
-		term.tabs[term.c.x] = 1;
-		break;
-	case 'M': /* RI -- Reverse index */
-		if (term.c.y == term.top) {
-			tscrolldown(term.top, 1);
-		} else {
-			tmoveto(term.c.x, term.c.y-1);
-		}
-		break;
-	case 'Z': /* DECID -- Identify Terminal */
-		ttywrite(vtiden, strlen(vtiden), 0);
-		break;
-	case 'c': /* RIS -- Reset to initial state */
-		treset();
-		resettitle();
-		xloadcols();
-		xsetmode(0, MODE_HIDE);
-		break;
-	case '=': /* DECPAM -- Application keypad */
-		xsetmode(1, MODE_APPKEYPAD);
-		break;
-	case '>': /* DECPNM -- Normal keypad */
-		xsetmode(0, MODE_APPKEYPAD);
-		break;
-	case '7': /* DECSC -- Save Cursor */
-		tcursor(CURSOR_SAVE);
-		break;
-	case '8': /* DECRC -- Restore Cursor */
-		tcursor(CURSOR_LOAD);
-		break;
-	case '\\': /* ST -- String Terminator */
-		if (term.esc & ESC_STR_END)
-			strhandle();
-		break;
-	default:
-		fprintf(stderr, "erresc: unknown sequence ESC 0x%02X '%c'\n",
-			(uchar) ascii, isprint(ascii)? ascii:'.');
-		break;
-	}
-	return 1;
-}
-
-void
-tputc(Rune u)
-{
-	char c[UTF_SIZ];
-	int control;
-	int width, len;
-	Glyph *gp;
-
-	control = ISCONTROL(u);
-	if (u < 127 || !IS_SET(MODE_UTF8)) {
-		c[0] = u;
-		width = len = 1;
-	} else {
-		len = utf8encode(u, c);
-		if (!control && (width = wcwidth(u)) == -1)
-			width = 1;
-	}
-
-	if (IS_SET(MODE_PRINT))
-		tprinter(c, len);
-
-	/*
-	 * STR sequence must be checked before anything else
-	 * because it uses all following characters until it
-	 * receives a ESC, a SUB, a ST or any other C1 control
-	 * character.
-	 */
-	if (term.esc & ESC_STR) {
-		if (u == '\a' || u == 030 || u == 032 || u == 033 ||
-		   ISCONTROLC1(u)) {
-			term.esc &= ~(ESC_START|ESC_STR);
-			term.esc |= ESC_STR_END;
-			goto check_control_code;
-		}
-
-		if (strescseq.len+len >= strescseq.siz) {
-			/*
-			 * Here is a bug in terminals. If the user never sends
-			 * some code to stop the str or esc command, then st
-			 * will stop responding. But this is better than
-			 * silently failing with unknown characters. At least
-			 * then users will report back.
-			 *
-			 * In the case users ever get fixed, here is the code:
-			 */
-			/*
-			 * term.esc = 0;
-			 * strhandle();
-			 */
-			if (strescseq.siz > (SIZE_MAX - UTF_SIZ) / 2)
-				return;
-			strescseq.siz *= 2;
-			strescseq.buf = xrealloc(strescseq.buf, strescseq.siz);
-		}
-
-		memmove(&strescseq.buf[strescseq.len], c, len);
-		strescseq.len += len;
-		return;
-	}
-
-check_control_code:
-	/*
-	 * Actions of control codes must be performed as soon they arrive
-	 * because they can be embedded inside a control sequence, and
-	 * they must not cause conflicts with sequences.
-	 */
-	if (control) {
-		/* in UTF-8 mode ignore handling C1 control characters */
-		if (IS_SET(MODE_UTF8) && ISCONTROLC1(u))
-			return;
-		tcontrolcode(u);
-		/*
-		 * control codes are not shown ever
-		 */
-		if (!term.esc)
-			term.lastc = 0;
-		return;
-	} else if (term.esc & ESC_START) {
-		if (term.esc & ESC_CSI) {
-			csiescseq.buf[csiescseq.len++] = u;
-			if (BETWEEN(u, 0x40, 0x7E)
-					|| csiescseq.len >= \
-					sizeof(csiescseq.buf)-1) {
-				term.esc = 0;
-				csiparse();
-				csihandle();
-			}
-			return;
-		} else if (term.esc & ESC_UTF8) {
-			tdefutf8(u);
-		} else if (term.esc & ESC_ALTCHARSET) {
-			tdeftran(u);
-		} else if (term.esc & ESC_TEST) {
-			tdectest(u);
-		} else {
-			if (!eschandle(u))
-				return;
-			/* sequence already finished */
-		}
-		term.esc = 0;
-		/*
-		 * All characters which form part of a sequence are not
-		 * printed
-		 */
-		return;
-	}
-	if (selected(term.c.x, term.c.y))
-		selclear();
-
-	gp = &term.line[term.c.y][term.c.x];
-	if (IS_SET(MODE_WRAP) && (term.c.state & CURSOR_WRAPNEXT)) {
-		gp->mode |= ATTR_WRAP;
-		tnewline(1);
-		gp = &term.line[term.c.y][term.c.x];
-	}
-
-	if (IS_SET(MODE_INSERT) && term.c.x+width < term.col) {
-		memmove(gp+width, gp, (term.col - term.c.x - width) * sizeof(Glyph));
-		gp->mode &= ~ATTR_WIDE;
-	}
-
-	if (term.c.x+width > term.col) {
-		if (IS_SET(MODE_WRAP))
-			tnewline(1);
-		else
-			tmoveto(term.col - width, term.c.y);
-		gp = &term.line[term.c.y][term.c.x];
-	}
-
-	tsetchar(u, &term.c.attr, term.c.x, term.c.y);
-	term.lastc = u;
-
-	if (width == 2) {
-		gp->mode |= ATTR_WIDE;
-		if (term.c.x+1 < term.col) {
-			if (gp[1].mode == ATTR_WIDE && term.c.x+2 < term.col) {
-				gp[2].u = ' ';
-				gp[2].mode &= ~ATTR_WDUMMY;
-			}
-			gp[1].u = '\0';
-			gp[1].mode = ATTR_WDUMMY;
-		}
-	}
-	if (term.c.x+width < term.col) {
-		tmoveto(term.c.x+width, term.c.y);
-	} else {
-		term.c.state |= CURSOR_WRAPNEXT;
-	}
-}
-
-int
-twrite(const char *buf, int buflen, int show_ctrl)
-{
-	int charsize;
-	Rune u;
-	int n;
-
-	for (n = 0; n < buflen; n += charsize) {
-		if (IS_SET(MODE_UTF8)) {
-			/* process a complete utf8 char */
-			charsize = utf8decode(buf + n, &u, buflen - n);
-			if (charsize == 0)
-				break;
-		} else {
-			u = buf[n] & 0xFF;
-			charsize = 1;
-		}
-		if (show_ctrl && ISCONTROL(u)) {
-			if (u & 0x80) {
-				u &= 0x7f;
-				tputc('^');
-				tputc('[');
-			} else if (u != '\n' && u != '\r' && u != '\t') {
-				u ^= 0x40;
-				tputc('^');
-			}
-		}
-		tputc(u);
-	}
-	return n;
-}
-
-void
-tresize(int col, int row)
-{
-	int i;
-	int minrow = MIN(row, term.row);
-	int mincol = MIN(col, term.col);
-	int *bp;
-	TCursor c;
-
-	if (col < 1 || row < 1) {
-		fprintf(stderr,
-		        "tresize: error resizing to %dx%d\n", col, row);
-		return;
-	}
-
-	/*
-	 * slide screen to keep cursor where we expect it -
-	 * tscrollup would work here, but we can optimize to
-	 * memmove because we're freeing the earlier lines
-	 */
-	for (i = 0; i <= term.c.y - row; i++) {
-		free(term.line[i]);
-		free(term.alt[i]);
-	}
-	/* ensure that both src and dst are not NULL */
-	if (i > 0) {
-		memmove(term.line, term.line + i, row * sizeof(Line));
-		memmove(term.alt, term.alt + i, row * sizeof(Line));
-	}
-	for (i += row; i < term.row; i++) {
-		free(term.line[i]);
-		free(term.alt[i]);
-	}
-
-	/* resize to new height */
-	term.line = xrealloc(term.line, row * sizeof(Line));
-	term.alt  = xrealloc(term.alt,  row * sizeof(Line));
-	term.dirty = xrealloc(term.dirty, row * sizeof(*term.dirty));
-	term.tabs = xrealloc(term.tabs, col * sizeof(*term.tabs));
-
-	/* resize each row to new width, zero-pad if needed */
-	for (i = 0; i < minrow; i++) {
-		term.line[i] = xrealloc(term.line[i], col * sizeof(Glyph));
-		term.alt[i]  = xrealloc(term.alt[i],  col * sizeof(Glyph));
-	}
-
-	/* allocate any new rows */
-	for (/* i = minrow */; i < row; i++) {
-		term.line[i] = xmalloc(col * sizeof(Glyph));
-		term.alt[i] = xmalloc(col * sizeof(Glyph));
-	}
-	if (col > term.col) {
-		bp = term.tabs + term.col;
-
-		memset(bp, 0, sizeof(*term.tabs) * (col - term.col));
-		while (--bp > term.tabs && !*bp)
-			/* nothing */ ;
-		for (bp += tabspaces; bp < term.tabs + col; bp += tabspaces)
-			*bp = 1;
-	}
-	/* update terminal size */
-	term.col = col;
-	term.row = row;
-	/* reset scrolling region */
-	tsetscroll(0, row-1);
-	/* make use of the LIMIT in tmoveto */
-	tmoveto(term.c.x, term.c.y);
-	/* Clearing both screens (it makes dirty all lines) */
-	c = term.c;
-	for (i = 0; i < 2; i++) {
-		if (mincol < col && 0 < minrow) {
-			tclearregion(mincol, 0, col - 1, minrow - 1);
-		}
-		if (0 < col && minrow < row) {
-			tclearregion(0, minrow, col - 1, row - 1);
-		}
-		tswapscreen();
-		tcursor(CURSOR_LOAD);
-	}
-	term.c = c;
-}
-
-void
-resettitle(void)
-{
-	xsettitle(NULL);
-}
-
-void
-drawregion(int x1, int y1, int x2, int y2)
-{
-	int y;
-
-	for (y = y1; y < y2; y++) {
-		if (!term.dirty[y])
-			continue;
-
-		term.dirty[y] = 0;
-		xdrawline(term.line[y], x1, y, x2);
-	}
-}
-
-void
-draw(void)
-{
-	int cx = term.c.x, ocx = term.ocx, ocy = term.ocy;
-
-	if (!xstartdraw())
-		return;
-
-	/* adjust cursor position */
-	LIMIT(term.ocx, 0, term.col-1);
-	LIMIT(term.ocy, 0, term.row-1);
-	if (term.line[term.ocy][term.ocx].mode & ATTR_WDUMMY)
-		term.ocx--;
-	if (term.line[term.c.y][cx].mode & ATTR_WDUMMY)
-		cx--;
-
-	drawregion(0, 0, term.col, term.row);
-	xdrawcursor(cx, term.c.y, term.line[term.c.y][cx],
-			term.ocx, term.ocy, term.line[term.ocy][term.ocx]);
-	term.ocx = cx;
-	term.ocy = term.c.y;
-	xfinishdraw();
-	if (ocx != term.ocx || ocy != term.ocy)
-		xximspot(term.ocx, term.ocy);
-}
-
-void
-redraw(void)
-{
-	tfulldirt();
-	draw();
-}
diff --git a/st.info b/st.info
@@ -1,243 +0,0 @@
-st-mono| simpleterm monocolor,
-	acsc=+C\,D-A.B0E``aaffgghFiGjjkkllmmnnooppqqrrssttuuvvwwxxyyzz{{||}}~~,
-	am,
-	bce,
-	bel=^G,
-	blink=\E[5m,
-	bold=\E[1m,
-	cbt=\E[Z,
-	cvvis=\E[?25h,
-	civis=\E[?25l,
-	clear=\E[H\E[2J,
-	cnorm=\E[?12l\E[?25h,
-	colors#2,
-	cols#80,
-	cr=^M,
-	csr=\E[%i%p1%d;%p2%dr,
-	cub=\E[%p1%dD,
-	cub1=^H,
-	cud1=^J,
-	cud=\E[%p1%dB,
-	cuf1=\E[C,
-	cuf=\E[%p1%dC,
-	cup=\E[%i%p1%d;%p2%dH,
-	cuu1=\E[A,
-	cuu=\E[%p1%dA,
-	dch=\E[%p1%dP,
-	dch1=\E[P,
-	dim=\E[2m,
-	dl=\E[%p1%dM,
-	dl1=\E[M,
-	ech=\E[%p1%dX,
-	ed=\E[J,
-	el=\E[K,
-	el1=\E[1K,
-	enacs=\E)0,
-	flash=\E[?5h$<80/>\E[?5l,
-	fsl=^G,
-	home=\E[H,
-	hpa=\E[%i%p1%dG,
-	hs,
-	ht=^I,
-	hts=\EH,
-	ich=\E[%p1%d@,
-	il1=\E[L,
-	il=\E[%p1%dL,
-	ind=^J,
-	indn=\E[%p1%dS,
-	invis=\E[8m,
-	is2=\E[4l\E>\E[?1034l,
-	it#8,
-	kel=\E[1;2F,
-	ked=\E[1;5F,
-	ka1=\E[1~,
-	ka3=\E[5~,
-	kc1=\E[4~,
-	kc3=\E[6~,
-	kbs=\177,
-	kcbt=\E[Z,
-	kb2=\EOu,
-	kcub1=\EOD,
-	kcud1=\EOB,
-	kcuf1=\EOC,
-	kcuu1=\EOA,
-	kDC=\E[3;2~,
-	kent=\EOM,
-	kEND=\E[1;2F,
-	kIC=\E[2;2~,
-	kNXT=\E[6;2~,
-	kPRV=\E[5;2~,
-	kHOM=\E[1;2H,
-	kLFT=\E[1;2D,
-	kRIT=\E[1;2C,
-	kind=\E[1;2B,
-	kri=\E[1;2A,
-	kclr=\E[3;5~,
-	kdl1=\E[3;2~,
-	kdch1=\E[3~,
-	kich1=\E[2~,
-	kend=\E[4~,
-	kf1=\EOP,
-	kf2=\EOQ,
-	kf3=\EOR,
-	kf4=\EOS,
-	kf5=\E[15~,
-	kf6=\E[17~,
-	kf7=\E[18~,
-	kf8=\E[19~,
-	kf9=\E[20~,
-	kf10=\E[21~,
-	kf11=\E[23~,
-	kf12=\E[24~,
-	kf13=\E[1;2P,
-	kf14=\E[1;2Q,
-	kf15=\E[1;2R,
-	kf16=\E[1;2S,
-	kf17=\E[15;2~,
-	kf18=\E[17;2~,
-	kf19=\E[18;2~,
-	kf20=\E[19;2~,
-	kf21=\E[20;2~,
-	kf22=\E[21;2~,
-	kf23=\E[23;2~,
-	kf24=\E[24;2~,
-	kf25=\E[1;5P,
-	kf26=\E[1;5Q,
-	kf27=\E[1;5R,
-	kf28=\E[1;5S,
-	kf29=\E[15;5~,
-	kf30=\E[17;5~,
-	kf31=\E[18;5~,
-	kf32=\E[19;5~,
-	kf33=\E[20;5~,
-	kf34=\E[21;5~,
-	kf35=\E[23;5~,
-	kf36=\E[24;5~,
-	kf37=\E[1;6P,
-	kf38=\E[1;6Q,
-	kf39=\E[1;6R,
-	kf40=\E[1;6S,
-	kf41=\E[15;6~,
-	kf42=\E[17;6~,
-	kf43=\E[18;6~,
-	kf44=\E[19;6~,
-	kf45=\E[20;6~,
-	kf46=\E[21;6~,
-	kf47=\E[23;6~,
-	kf48=\E[24;6~,
-	kf49=\E[1;3P,
-	kf50=\E[1;3Q,
-	kf51=\E[1;3R,
-	kf52=\E[1;3S,
-	kf53=\E[15;3~,
-	kf54=\E[17;3~,
-	kf55=\E[18;3~,
-	kf56=\E[19;3~,
-	kf57=\E[20;3~,
-	kf58=\E[21;3~,
-	kf59=\E[23;3~,
-	kf60=\E[24;3~,
-	kf61=\E[1;4P,
-	kf62=\E[1;4Q,
-	kf63=\E[1;4R,
-	khome=\E[1~,
-	kil1=\E[2;5~,
-	krmir=\E[2;2~,
-	knp=\E[6~,
-	kmous=\E[M,
-	kpp=\E[5~,
-	lines#24,
-	mir,
-	msgr,
-	npc,
-	op=\E[39;49m,
-	pairs#64,
-	mc0=\E[i,
-	mc4=\E[4i,
-	mc5=\E[5i,
-	rc=\E8,
-	rev=\E[7m,
-	ri=\EM,
-	rin=\E[%p1%dT,
-	ritm=\E[23m,
-	rmacs=\E(B,
-	rmcup=\E[?1049l,
-	rmir=\E[4l,
-	rmkx=\E[?1l\E>,
-	rmso=\E[27m,
-	rmul=\E[24m,
-	rs1=\Ec,
-	rs2=\E[4l\E>\E[?1034l,
-	sc=\E7,
-	sitm=\E[3m,
-	sgr0=\E[0m,
-	smacs=\E(0,
-	smcup=\E[?1049h,
-	smir=\E[4h,
-	smkx=\E[?1h\E=,
-	smso=\E[7m,
-	smul=\E[4m,
-	tbc=\E[3g,
-	tsl=\E]0;,
-	xenl,
-	vpa=\E[%i%p1%dd,
-# XTerm extensions
-	rmxx=\E[29m,
-	smxx=\E[9m,
-	BE=\E[?2004h,
-	BD=\E[?2004l,
-	PS=\E[200~,
-	PE=\E[201~,
-# disabled rep for now: causes some issues with older ncurses versions.
-#	rep=%p1%c\E[%p2%{1}%-%db,
-# tmux extensions, see TERMINFO EXTENSIONS in tmux(1)
-	Tc,
-	Ms=\E]52;%p1%s;%p2%s\007,
-	Se=\E[2 q,
-	Ss=\E[%p1%d q,
-
-st| simpleterm,
-	use=st-mono,
-	colors#8,
-	setab=\E[4%p1%dm,
-	setaf=\E[3%p1%dm,
-	setb=\E[4%?%p1%{1}%=%t4%e%p1%{3}%=%t6%e%p1%{4}%=%t1%e%p1%{6}%=%t3%e%p1%d%;m,
-	setf=\E[3%?%p1%{1}%=%t4%e%p1%{3}%=%t6%e%p1%{4}%=%t1%e%p1%{6}%=%t3%e%p1%d%;m,
-	sgr=%?%p9%t\E(0%e\E(B%;\E[0%?%p6%t;1%;%?%p2%t;4%;%?%p1%p3%|%t;7%;%?%p4%t;5%;%?%p7%t;8%;m,
-
-st-256color| simpleterm with 256 colors,
-	use=st,
-	ccc,
-	colors#256,
-	oc=\E]104\007,
-	pairs#32767,
-#	Nicked from xterm-256color
-	initc=\E]4;%p1%d;rgb\:%p2%{255}%*%{1000}%/%2.2X/%p3%{255}%*%{1000}%/%2.2X/%p4%{255}%*%{1000}%/%2.2X\E\\,
-	setab=\E[%?%p1%{8}%<%t4%p1%d%e%p1%{16}%<%t10%p1%{8}%-%d%e48;5;%p1%d%;m,
-	setaf=\E[%?%p1%{8}%<%t3%p1%d%e%p1%{16}%<%t9%p1%{8}%-%d%e38;5;%p1%d%;m,
-
-st-meta| simpleterm with meta key,
-	use=st,
-	km,
-	rmm=\E[?1034l,
-	smm=\E[?1034h,
-	rs2=\E[4l\E>\E[?1034h,
-	is2=\E[4l\E>\E[?1034h,
-
-st-meta-256color| simpleterm with meta key and 256 colors,
-	use=st-256color,
-	km,
-	rmm=\E[?1034l,
-	smm=\E[?1034h,
-	rs2=\E[4l\E>\E[?1034h,
-	is2=\E[4l\E>\E[?1034h,
-
-st-bs| simpleterm with backspace as backspace,
-	use=st,
-	kbs=\010,
-	kdch1=\177,
-
-st-bs-256color| simpleterm with backspace as backspace and 256colors,
-	use=st-256color,
-	kbs=\010,
-	kdch1=\177,
diff --git a/x.c b/x.c
@@ -18,7 +18,7 @@
 
 char *argv0;
 #include "arg.h"
-#include "st.h"
+#include "birdterm.h"
 #include "win.h"
 
 /* types used in config.h */