st

simple terminal
git clone git://git.suckless.org/st
Log | Files | Refs | README | LICENSE

st.c (57092B)


      1 /* See LICENSE for license details. */
      2 #include <ctype.h>
      3 #include <errno.h>
      4 #include <fcntl.h>
      5 #include <limits.h>
      6 #include <pwd.h>
      7 #include <stdarg.h>
      8 #include <stdio.h>
      9 #include <stdlib.h>
     10 #include <string.h>
     11 #include <signal.h>
     12 #include <sys/ioctl.h>
     13 #include <sys/select.h>
     14 #include <sys/types.h>
     15 #include <sys/wait.h>
     16 #include <termios.h>
     17 #include <unistd.h>
     18 #include <wchar.h>
     19 
     20 #include "st.h"
     21 #include "win.h"
     22 
     23 #if   defined(__linux)
     24  #include <pty.h>
     25 #elif defined(__OpenBSD__) || defined(__NetBSD__) || defined(__APPLE__)
     26  #include <util.h>
     27 #elif defined(__FreeBSD__) || defined(__DragonFly__)
     28  #include <libutil.h>
     29 #endif
     30 
     31 /* Arbitrary sizes */
     32 #define UTF_INVALID   0xFFFD
     33 #define UTF_SIZ       4
     34 #define ESC_BUF_SIZ   (128*UTF_SIZ)
     35 #define ESC_ARG_SIZ   16
     36 #define STR_BUF_SIZ   ESC_BUF_SIZ
     37 #define STR_ARG_SIZ   ESC_ARG_SIZ
     38 
     39 /* macros */
     40 #define IS_SET(flag)		((term.mode & (flag)) != 0)
     41 #define ISCONTROLC0(c)		(BETWEEN(c, 0, 0x1f) || (c) == 0x7f)
     42 #define ISCONTROLC1(c)		(BETWEEN(c, 0x80, 0x9f))
     43 #define ISCONTROL(c)		(ISCONTROLC0(c) || ISCONTROLC1(c))
     44 #define ISDELIM(u)		(u && wcschr(worddelimiters, u))
     45 
     46 enum term_mode {
     47 	MODE_WRAP        = 1 << 0,
     48 	MODE_INSERT      = 1 << 1,
     49 	MODE_ALTSCREEN   = 1 << 2,
     50 	MODE_CRLF        = 1 << 3,
     51 	MODE_ECHO        = 1 << 4,
     52 	MODE_PRINT       = 1 << 5,
     53 	MODE_UTF8        = 1 << 6,
     54 };
     55 
     56 enum cursor_movement {
     57 	CURSOR_SAVE,
     58 	CURSOR_LOAD
     59 };
     60 
     61 enum cursor_state {
     62 	CURSOR_DEFAULT  = 0,
     63 	CURSOR_WRAPNEXT = 1,
     64 	CURSOR_ORIGIN   = 2
     65 };
     66 
     67 enum charset {
     68 	CS_GRAPHIC0,
     69 	CS_GRAPHIC1,
     70 	CS_UK,
     71 	CS_USA,
     72 	CS_MULTI,
     73 	CS_GER,
     74 	CS_FIN
     75 };
     76 
     77 enum escape_state {
     78 	ESC_START      = 1,
     79 	ESC_CSI        = 2,
     80 	ESC_STR        = 4,  /* DCS, OSC, PM, APC */
     81 	ESC_ALTCHARSET = 8,
     82 	ESC_STR_END    = 16, /* a final string was encountered */
     83 	ESC_TEST       = 32, /* Enter in test mode */
     84 	ESC_UTF8       = 64,
     85 };
     86 
     87 typedef struct {
     88 	Glyph attr; /* current char attributes */
     89 	int x;
     90 	int y;
     91 	char state;
     92 } TCursor;
     93 
     94 typedef struct {
     95 	int mode;
     96 	int type;
     97 	int snap;
     98 	/*
     99 	 * Selection variables:
    100 	 * nb – normalized coordinates of the beginning of the selection
    101 	 * ne – normalized coordinates of the end of the selection
    102 	 * ob – original coordinates of the beginning of the selection
    103 	 * oe – original coordinates of the end of the selection
    104 	 */
    105 	struct {
    106 		int x, y;
    107 	} nb, ne, ob, oe;
    108 
    109 	int alt;
    110 } Selection;
    111 
    112 /* Internal representation of the screen */
    113 typedef struct {
    114 	int row;      /* nb row */
    115 	int col;      /* nb col */
    116 	Line *line;   /* screen */
    117 	Line *alt;    /* alternate screen */
    118 	int *dirty;   /* dirtyness of lines */
    119 	TCursor c;    /* cursor */
    120 	int ocx;      /* old cursor col */
    121 	int ocy;      /* old cursor row */
    122 	int top;      /* top    scroll limit */
    123 	int bot;      /* bottom scroll limit */
    124 	int mode;     /* terminal mode flags */
    125 	int esc;      /* escape state flags */
    126 	char trantbl[4]; /* charset table translation */
    127 	int charset;  /* current charset */
    128 	int icharset; /* selected charset for sequence */
    129 	int *tabs;
    130 	Rune lastc;   /* last printed char outside of sequence, 0 if control */
    131 } Term;
    132 
    133 /* CSI Escape sequence structs */
    134 /* ESC '[' [[ [<priv>] <arg> [;]] <mode> [<mode>]] */
    135 typedef struct {
    136 	char buf[ESC_BUF_SIZ]; /* raw string */
    137 	size_t len;            /* raw string length */
    138 	char priv;
    139 	int arg[ESC_ARG_SIZ];
    140 	int narg;              /* nb of args */
    141 	char mode[2];
    142 } CSIEscape;
    143 
    144 /* STR Escape sequence structs */
    145 /* ESC type [[ [<priv>] <arg> [;]] <mode>] ESC '\' */
    146 typedef struct {
    147 	char type;             /* ESC type ... */
    148 	char *buf;             /* allocated raw string */
    149 	size_t siz;            /* allocation size */
    150 	size_t len;            /* raw string length */
    151 	char *args[STR_ARG_SIZ];
    152 	int narg;              /* nb of args */
    153 } STREscape;
    154 
    155 static void execsh(char *, char **);
    156 static void stty(char **);
    157 static void sigchld(int);
    158 static void ttywriteraw(const char *, size_t);
    159 
    160 static void csidump(void);
    161 static void csihandle(void);
    162 static void csiparse(void);
    163 static void csireset(void);
    164 static void osc_color_response(int, int, int);
    165 static int eschandle(uchar);
    166 static void strdump(void);
    167 static void strhandle(void);
    168 static void strparse(void);
    169 static void strreset(void);
    170 
    171 static void tprinter(char *, size_t);
    172 static void tdumpsel(void);
    173 static void tdumpline(int);
    174 static void tdump(void);
    175 static void tclearregion(int, int, int, int);
    176 static void tcursor(int);
    177 static void tdeletechar(int);
    178 static void tdeleteline(int);
    179 static void tinsertblank(int);
    180 static void tinsertblankline(int);
    181 static int tlinelen(int);
    182 static void tmoveto(int, int);
    183 static void tmoveato(int, int);
    184 static void tnewline(int);
    185 static void tputtab(int);
    186 static void tputc(Rune);
    187 static void treset(void);
    188 static void tscrollup(int, int);
    189 static void tscrolldown(int, int);
    190 static void tsetattr(const int *, int);
    191 static void tsetchar(Rune, const Glyph *, int, int);
    192 static void tsetdirt(int, int);
    193 static void tsetscroll(int, int);
    194 static void tswapscreen(void);
    195 static void tsetmode(int, int, const int *, int);
    196 static int twrite(const char *, int, int);
    197 static void tfulldirt(void);
    198 static void tcontrolcode(uchar );
    199 static void tdectest(char );
    200 static void tdefutf8(char);
    201 static int32_t tdefcolor(const int *, int *, int);
    202 static void tdeftran(char);
    203 static void tstrsequence(uchar);
    204 
    205 static void drawregion(int, int, int, int);
    206 
    207 static void selnormalize(void);
    208 static void selscroll(int, int);
    209 static void selsnap(int *, int *, int);
    210 
    211 static size_t utf8decode(const char *, Rune *, size_t);
    212 static Rune utf8decodebyte(char, size_t *);
    213 static char utf8encodebyte(Rune, size_t);
    214 static size_t utf8validate(Rune *, size_t);
    215 
    216 static char *base64dec(const char *);
    217 static char base64dec_getc(const char **);
    218 
    219 static ssize_t xwrite(int, const char *, size_t);
    220 
    221 /* Globals */
    222 static Term term;
    223 static Selection sel;
    224 static CSIEscape csiescseq;
    225 static STREscape strescseq;
    226 static int iofd = 1;
    227 static int cmdfd;
    228 static pid_t pid;
    229 
    230 static const uchar utfbyte[UTF_SIZ + 1] = {0x80,    0, 0xC0, 0xE0, 0xF0};
    231 static const uchar utfmask[UTF_SIZ + 1] = {0xC0, 0x80, 0xE0, 0xF0, 0xF8};
    232 static const Rune utfmin[UTF_SIZ + 1] = {       0,    0,  0x80,  0x800,  0x10000};
    233 static const Rune utfmax[UTF_SIZ + 1] = {0x10FFFF, 0x7F, 0x7FF, 0xFFFF, 0x10FFFF};
    234 
    235 ssize_t
    236 xwrite(int fd, const char *s, size_t len)
    237 {
    238 	size_t aux = len;
    239 	ssize_t r;
    240 
    241 	while (len > 0) {
    242 		r = write(fd, s, len);
    243 		if (r < 0)
    244 			return r;
    245 		len -= r;
    246 		s += r;
    247 	}
    248 
    249 	return aux;
    250 }
    251 
    252 void *
    253 xmalloc(size_t len)
    254 {
    255 	void *p;
    256 
    257 	if (!(p = malloc(len)))
    258 		die("malloc: %s\n", strerror(errno));
    259 
    260 	return p;
    261 }
    262 
    263 void *
    264 xrealloc(void *p, size_t len)
    265 {
    266 	if ((p = realloc(p, len)) == NULL)
    267 		die("realloc: %s\n", strerror(errno));
    268 
    269 	return p;
    270 }
    271 
    272 char *
    273 xstrdup(const char *s)
    274 {
    275 	char *p;
    276 
    277 	if ((p = strdup(s)) == NULL)
    278 		die("strdup: %s\n", strerror(errno));
    279 
    280 	return p;
    281 }
    282 
    283 size_t
    284 utf8decode(const char *c, Rune *u, size_t clen)
    285 {
    286 	size_t i, j, len, type;
    287 	Rune udecoded;
    288 
    289 	*u = UTF_INVALID;
    290 	if (!clen)
    291 		return 0;
    292 	udecoded = utf8decodebyte(c[0], &len);
    293 	if (!BETWEEN(len, 1, UTF_SIZ))
    294 		return 1;
    295 	for (i = 1, j = 1; i < clen && j < len; ++i, ++j) {
    296 		udecoded = (udecoded << 6) | utf8decodebyte(c[i], &type);
    297 		if (type != 0)
    298 			return j;
    299 	}
    300 	if (j < len)
    301 		return 0;
    302 	*u = udecoded;
    303 	utf8validate(u, len);
    304 
    305 	return len;
    306 }
    307 
    308 Rune
    309 utf8decodebyte(char c, size_t *i)
    310 {
    311 	for (*i = 0; *i < LEN(utfmask); ++(*i))
    312 		if (((uchar)c & utfmask[*i]) == utfbyte[*i])
    313 			return (uchar)c & ~utfmask[*i];
    314 
    315 	return 0;
    316 }
    317 
    318 size_t
    319 utf8encode(Rune u, char *c)
    320 {
    321 	size_t len, i;
    322 
    323 	len = utf8validate(&u, 0);
    324 	if (len > UTF_SIZ)
    325 		return 0;
    326 
    327 	for (i = len - 1; i != 0; --i) {
    328 		c[i] = utf8encodebyte(u, 0);
    329 		u >>= 6;
    330 	}
    331 	c[0] = utf8encodebyte(u, len);
    332 
    333 	return len;
    334 }
    335 
    336 char
    337 utf8encodebyte(Rune u, size_t i)
    338 {
    339 	return utfbyte[i] | (u & ~utfmask[i]);
    340 }
    341 
    342 size_t
    343 utf8validate(Rune *u, size_t i)
    344 {
    345 	if (!BETWEEN(*u, utfmin[i], utfmax[i]) || BETWEEN(*u, 0xD800, 0xDFFF))
    346 		*u = UTF_INVALID;
    347 	for (i = 1; *u > utfmax[i]; ++i)
    348 		;
    349 
    350 	return i;
    351 }
    352 
    353 char
    354 base64dec_getc(const char **src)
    355 {
    356 	while (**src && !isprint((unsigned char)**src))
    357 		(*src)++;
    358 	return **src ? *((*src)++) : '=';  /* emulate padding if string ends */
    359 }
    360 
    361 char *
    362 base64dec(const char *src)
    363 {
    364 	size_t in_len = strlen(src);
    365 	char *result, *dst;
    366 	static const char base64_digits[256] = {
    367 		[43] = 62, 0, 0, 0, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
    368 		0, 0, 0, -1, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
    369 		13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 0, 0,
    370 		0, 0, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
    371 		40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51
    372 	};
    373 
    374 	if (in_len % 4)
    375 		in_len += 4 - (in_len % 4);
    376 	result = dst = xmalloc(in_len / 4 * 3 + 1);
    377 	while (*src) {
    378 		int a = base64_digits[(unsigned char) base64dec_getc(&src)];
    379 		int b = base64_digits[(unsigned char) base64dec_getc(&src)];
    380 		int c = base64_digits[(unsigned char) base64dec_getc(&src)];
    381 		int d = base64_digits[(unsigned char) base64dec_getc(&src)];
    382 
    383 		/* invalid input. 'a' can be -1, e.g. if src is "\n" (c-str) */
    384 		if (a == -1 || b == -1)
    385 			break;
    386 
    387 		*dst++ = (a << 2) | ((b & 0x30) >> 4);
    388 		if (c == -1)
    389 			break;
    390 		*dst++ = ((b & 0x0f) << 4) | ((c & 0x3c) >> 2);
    391 		if (d == -1)
    392 			break;
    393 		*dst++ = ((c & 0x03) << 6) | d;
    394 	}
    395 	*dst = '\0';
    396 	return result;
    397 }
    398 
    399 void
    400 selinit(void)
    401 {
    402 	sel.mode = SEL_IDLE;
    403 	sel.snap = 0;
    404 	sel.ob.x = -1;
    405 }
    406 
    407 int
    408 tlinelen(int y)
    409 {
    410 	int i = term.col;
    411 
    412 	if (term.line[y][i - 1].mode & ATTR_WRAP)
    413 		return i;
    414 
    415 	while (i > 0 && term.line[y][i - 1].u == ' ')
    416 		--i;
    417 
    418 	return i;
    419 }
    420 
    421 void
    422 selstart(int col, int row, int snap)
    423 {
    424 	selclear();
    425 	sel.mode = SEL_EMPTY;
    426 	sel.type = SEL_REGULAR;
    427 	sel.alt = IS_SET(MODE_ALTSCREEN);
    428 	sel.snap = snap;
    429 	sel.oe.x = sel.ob.x = col;
    430 	sel.oe.y = sel.ob.y = row;
    431 	selnormalize();
    432 
    433 	if (sel.snap != 0)
    434 		sel.mode = SEL_READY;
    435 	tsetdirt(sel.nb.y, sel.ne.y);
    436 }
    437 
    438 void
    439 selextend(int col, int row, int type, int done)
    440 {
    441 	int oldey, oldex, oldsby, oldsey, oldtype;
    442 
    443 	if (sel.mode == SEL_IDLE)
    444 		return;
    445 	if (done && sel.mode == SEL_EMPTY) {
    446 		selclear();
    447 		return;
    448 	}
    449 
    450 	oldey = sel.oe.y;
    451 	oldex = sel.oe.x;
    452 	oldsby = sel.nb.y;
    453 	oldsey = sel.ne.y;
    454 	oldtype = sel.type;
    455 
    456 	sel.oe.x = col;
    457 	sel.oe.y = row;
    458 	selnormalize();
    459 	sel.type = type;
    460 
    461 	if (oldey != sel.oe.y || oldex != sel.oe.x || oldtype != sel.type || sel.mode == SEL_EMPTY)
    462 		tsetdirt(MIN(sel.nb.y, oldsby), MAX(sel.ne.y, oldsey));
    463 
    464 	sel.mode = done ? SEL_IDLE : SEL_READY;
    465 }
    466 
    467 void
    468 selnormalize(void)
    469 {
    470 	int i;
    471 
    472 	if (sel.type == SEL_REGULAR && sel.ob.y != sel.oe.y) {
    473 		sel.nb.x = sel.ob.y < sel.oe.y ? sel.ob.x : sel.oe.x;
    474 		sel.ne.x = sel.ob.y < sel.oe.y ? sel.oe.x : sel.ob.x;
    475 	} else {
    476 		sel.nb.x = MIN(sel.ob.x, sel.oe.x);
    477 		sel.ne.x = MAX(sel.ob.x, sel.oe.x);
    478 	}
    479 	sel.nb.y = MIN(sel.ob.y, sel.oe.y);
    480 	sel.ne.y = MAX(sel.ob.y, sel.oe.y);
    481 
    482 	selsnap(&sel.nb.x, &sel.nb.y, -1);
    483 	selsnap(&sel.ne.x, &sel.ne.y, +1);
    484 
    485 	/* expand selection over line breaks */
    486 	if (sel.type == SEL_RECTANGULAR)
    487 		return;
    488 	i = tlinelen(sel.nb.y);
    489 	if (i < sel.nb.x)
    490 		sel.nb.x = i;
    491 	if (tlinelen(sel.ne.y) <= sel.ne.x)
    492 		sel.ne.x = term.col - 1;
    493 }
    494 
    495 int
    496 selected(int x, int y)
    497 {
    498 	if (sel.mode == SEL_EMPTY || sel.ob.x == -1 ||
    499 			sel.alt != IS_SET(MODE_ALTSCREEN))
    500 		return 0;
    501 
    502 	if (sel.type == SEL_RECTANGULAR)
    503 		return BETWEEN(y, sel.nb.y, sel.ne.y)
    504 		    && BETWEEN(x, sel.nb.x, sel.ne.x);
    505 
    506 	return BETWEEN(y, sel.nb.y, sel.ne.y)
    507 	    && (y != sel.nb.y || x >= sel.nb.x)
    508 	    && (y != sel.ne.y || x <= sel.ne.x);
    509 }
    510 
    511 void
    512 selsnap(int *x, int *y, int direction)
    513 {
    514 	int newx, newy, xt, yt;
    515 	int delim, prevdelim;
    516 	const Glyph *gp, *prevgp;
    517 
    518 	switch (sel.snap) {
    519 	case SNAP_WORD:
    520 		/*
    521 		 * Snap around if the word wraps around at the end or
    522 		 * beginning of a line.
    523 		 */
    524 		prevgp = &term.line[*y][*x];
    525 		prevdelim = ISDELIM(prevgp->u);
    526 		for (;;) {
    527 			newx = *x + direction;
    528 			newy = *y;
    529 			if (!BETWEEN(newx, 0, term.col - 1)) {
    530 				newy += direction;
    531 				newx = (newx + term.col) % term.col;
    532 				if (!BETWEEN(newy, 0, term.row - 1))
    533 					break;
    534 
    535 				if (direction > 0)
    536 					yt = *y, xt = *x;
    537 				else
    538 					yt = newy, xt = newx;
    539 				if (!(term.line[yt][xt].mode & ATTR_WRAP))
    540 					break;
    541 			}
    542 
    543 			if (newx >= tlinelen(newy))
    544 				break;
    545 
    546 			gp = &term.line[newy][newx];
    547 			delim = ISDELIM(gp->u);
    548 			if (!(gp->mode & ATTR_WDUMMY) && (delim != prevdelim
    549 					|| (delim && gp->u != prevgp->u)))
    550 				break;
    551 
    552 			*x = newx;
    553 			*y = newy;
    554 			prevgp = gp;
    555 			prevdelim = delim;
    556 		}
    557 		break;
    558 	case SNAP_LINE:
    559 		/*
    560 		 * Snap around if the the previous line or the current one
    561 		 * has set ATTR_WRAP at its end. Then the whole next or
    562 		 * previous line will be selected.
    563 		 */
    564 		*x = (direction < 0) ? 0 : term.col - 1;
    565 		if (direction < 0) {
    566 			for (; *y > 0; *y += direction) {
    567 				if (!(term.line[*y-1][term.col-1].mode
    568 						& ATTR_WRAP)) {
    569 					break;
    570 				}
    571 			}
    572 		} else if (direction > 0) {
    573 			for (; *y < term.row-1; *y += direction) {
    574 				if (!(term.line[*y][term.col-1].mode
    575 						& ATTR_WRAP)) {
    576 					break;
    577 				}
    578 			}
    579 		}
    580 		break;
    581 	}
    582 }
    583 
    584 char *
    585 getsel(void)
    586 {
    587 	char *str, *ptr;
    588 	int y, bufsize, lastx, linelen;
    589 	const Glyph *gp, *last;
    590 
    591 	if (sel.ob.x == -1)
    592 		return NULL;
    593 
    594 	bufsize = (term.col+1) * (sel.ne.y-sel.nb.y+1) * UTF_SIZ;
    595 	ptr = str = xmalloc(bufsize);
    596 
    597 	/* append every set & selected glyph to the selection */
    598 	for (y = sel.nb.y; y <= sel.ne.y; y++) {
    599 		if ((linelen = tlinelen(y)) == 0) {
    600 			*ptr++ = '\n';
    601 			continue;
    602 		}
    603 
    604 		if (sel.type == SEL_RECTANGULAR) {
    605 			gp = &term.line[y][sel.nb.x];
    606 			lastx = sel.ne.x;
    607 		} else {
    608 			gp = &term.line[y][sel.nb.y == y ? sel.nb.x : 0];
    609 			lastx = (sel.ne.y == y) ? sel.ne.x : term.col-1;
    610 		}
    611 		last = &term.line[y][MIN(lastx, linelen-1)];
    612 		while (last >= gp && last->u == ' ')
    613 			--last;
    614 
    615 		for ( ; gp <= last; ++gp) {
    616 			if (gp->mode & ATTR_WDUMMY)
    617 				continue;
    618 
    619 			ptr += utf8encode(gp->u, ptr);
    620 		}
    621 
    622 		/*
    623 		 * Copy and pasting of line endings is inconsistent
    624 		 * in the inconsistent terminal and GUI world.
    625 		 * The best solution seems like to produce '\n' when
    626 		 * something is copied from st and convert '\n' to
    627 		 * '\r', when something to be pasted is received by
    628 		 * st.
    629 		 * FIXME: Fix the computer world.
    630 		 */
    631 		if ((y < sel.ne.y || lastx >= linelen) &&
    632 		    (!(last->mode & ATTR_WRAP) || sel.type == SEL_RECTANGULAR))
    633 			*ptr++ = '\n';
    634 	}
    635 	*ptr = 0;
    636 	return str;
    637 }
    638 
    639 void
    640 selclear(void)
    641 {
    642 	if (sel.ob.x == -1)
    643 		return;
    644 	sel.mode = SEL_IDLE;
    645 	sel.ob.x = -1;
    646 	tsetdirt(sel.nb.y, sel.ne.y);
    647 }
    648 
    649 void
    650 die(const char *errstr, ...)
    651 {
    652 	va_list ap;
    653 
    654 	va_start(ap, errstr);
    655 	vfprintf(stderr, errstr, ap);
    656 	va_end(ap);
    657 	exit(1);
    658 }
    659 
    660 void
    661 execsh(char *cmd, char **args)
    662 {
    663 	char *sh, *prog, *arg;
    664 	const struct passwd *pw;
    665 
    666 	errno = 0;
    667 	if ((pw = getpwuid(getuid())) == NULL) {
    668 		if (errno)
    669 			die("getpwuid: %s\n", strerror(errno));
    670 		else
    671 			die("who are you?\n");
    672 	}
    673 
    674 	if ((sh = getenv("SHELL")) == NULL)
    675 		sh = (pw->pw_shell[0]) ? pw->pw_shell : cmd;
    676 
    677 	if (args) {
    678 		prog = args[0];
    679 		arg = NULL;
    680 	} else if (scroll) {
    681 		prog = scroll;
    682 		arg = utmp ? utmp : sh;
    683 	} else if (utmp) {
    684 		prog = utmp;
    685 		arg = NULL;
    686 	} else {
    687 		prog = sh;
    688 		arg = NULL;
    689 	}
    690 	DEFAULT(args, ((char *[]) {prog, arg, NULL}));
    691 
    692 	unsetenv("COLUMNS");
    693 	unsetenv("LINES");
    694 	unsetenv("TERMCAP");
    695 	setenv("LOGNAME", pw->pw_name, 1);
    696 	setenv("USER", pw->pw_name, 1);
    697 	setenv("SHELL", sh, 1);
    698 	setenv("HOME", pw->pw_dir, 1);
    699 	setenv("TERM", termname, 1);
    700 
    701 	signal(SIGCHLD, SIG_DFL);
    702 	signal(SIGHUP, SIG_DFL);
    703 	signal(SIGINT, SIG_DFL);
    704 	signal(SIGQUIT, SIG_DFL);
    705 	signal(SIGTERM, SIG_DFL);
    706 	signal(SIGALRM, SIG_DFL);
    707 
    708 	execvp(prog, args);
    709 	_exit(1);
    710 }
    711 
    712 void
    713 sigchld(int a)
    714 {
    715 	int stat;
    716 	pid_t p;
    717 
    718 	if ((p = waitpid(pid, &stat, WNOHANG)) < 0)
    719 		die("waiting for pid %hd failed: %s\n", pid, strerror(errno));
    720 
    721 	if (pid != p)
    722 		return;
    723 
    724 	if (WIFEXITED(stat) && WEXITSTATUS(stat))
    725 		die("child exited with status %d\n", WEXITSTATUS(stat));
    726 	else if (WIFSIGNALED(stat))
    727 		die("child terminated due to signal %d\n", WTERMSIG(stat));
    728 	_exit(0);
    729 }
    730 
    731 void
    732 stty(char **args)
    733 {
    734 	char cmd[_POSIX_ARG_MAX], **p, *q, *s;
    735 	size_t n, siz;
    736 
    737 	if ((n = strlen(stty_args)) > sizeof(cmd)-1)
    738 		die("incorrect stty parameters\n");
    739 	memcpy(cmd, stty_args, n);
    740 	q = cmd + n;
    741 	siz = sizeof(cmd) - n;
    742 	for (p = args; p && (s = *p); ++p) {
    743 		if ((n = strlen(s)) > siz-1)
    744 			die("stty parameter length too long\n");
    745 		*q++ = ' ';
    746 		memcpy(q, s, n);
    747 		q += n;
    748 		siz -= n + 1;
    749 	}
    750 	*q = '\0';
    751 	if (system(cmd) != 0)
    752 		perror("Couldn't call stty");
    753 }
    754 
    755 int
    756 ttynew(const char *line, char *cmd, const char *out, char **args)
    757 {
    758 	int m, s;
    759 
    760 	if (out) {
    761 		term.mode |= MODE_PRINT;
    762 		iofd = (!strcmp(out, "-")) ?
    763 			  1 : open(out, O_WRONLY | O_CREAT, 0666);
    764 		if (iofd < 0) {
    765 			fprintf(stderr, "Error opening %s:%s\n",
    766 				out, strerror(errno));
    767 		}
    768 	}
    769 
    770 	if (line) {
    771 		if ((cmdfd = open(line, O_RDWR)) < 0)
    772 			die("open line '%s' failed: %s\n",
    773 			    line, strerror(errno));
    774 		dup2(cmdfd, 0);
    775 		stty(args);
    776 		return cmdfd;
    777 	}
    778 
    779 	/* seems to work fine on linux, openbsd and freebsd */
    780 	if (openpty(&m, &s, NULL, NULL, NULL) < 0)
    781 		die("openpty failed: %s\n", strerror(errno));
    782 
    783 	switch (pid = fork()) {
    784 	case -1:
    785 		die("fork failed: %s\n", strerror(errno));
    786 		break;
    787 	case 0:
    788 		close(iofd);
    789 		close(m);
    790 		setsid(); /* create a new process group */
    791 		dup2(s, 0);
    792 		dup2(s, 1);
    793 		dup2(s, 2);
    794 		if (ioctl(s, TIOCSCTTY, NULL) < 0)
    795 			die("ioctl TIOCSCTTY failed: %s\n", strerror(errno));
    796 		if (s > 2)
    797 			close(s);
    798 #ifdef __OpenBSD__
    799 		if (pledge("stdio getpw proc exec", NULL) == -1)
    800 			die("pledge\n");
    801 #endif
    802 		execsh(cmd, args);
    803 		break;
    804 	default:
    805 #ifdef __OpenBSD__
    806 		if (pledge("stdio rpath tty proc", NULL) == -1)
    807 			die("pledge\n");
    808 #endif
    809 		close(s);
    810 		cmdfd = m;
    811 		signal(SIGCHLD, sigchld);
    812 		break;
    813 	}
    814 	return cmdfd;
    815 }
    816 
    817 size_t
    818 ttyread(void)
    819 {
    820 	static char buf[BUFSIZ];
    821 	static int buflen = 0;
    822 	int ret, written;
    823 
    824 	/* append read bytes to unprocessed bytes */
    825 	ret = read(cmdfd, buf+buflen, LEN(buf)-buflen);
    826 
    827 	switch (ret) {
    828 	case 0:
    829 		exit(0);
    830 	case -1:
    831 		die("couldn't read from shell: %s\n", strerror(errno));
    832 	default:
    833 		buflen += ret;
    834 		written = twrite(buf, buflen, 0);
    835 		buflen -= written;
    836 		/* keep any incomplete UTF-8 byte sequence for the next call */
    837 		if (buflen > 0)
    838 			memmove(buf, buf + written, buflen);
    839 		return ret;
    840 	}
    841 }
    842 
    843 void
    844 ttywrite(const char *s, size_t n, int may_echo)
    845 {
    846 	const char *next;
    847 
    848 	if (may_echo && IS_SET(MODE_ECHO))
    849 		twrite(s, n, 1);
    850 
    851 	if (!IS_SET(MODE_CRLF)) {
    852 		ttywriteraw(s, n);
    853 		return;
    854 	}
    855 
    856 	/* This is similar to how the kernel handles ONLCR for ttys */
    857 	while (n > 0) {
    858 		if (*s == '\r') {
    859 			next = s + 1;
    860 			ttywriteraw("\r\n", 2);
    861 		} else {
    862 			next = memchr(s, '\r', n);
    863 			DEFAULT(next, s + n);
    864 			ttywriteraw(s, next - s);
    865 		}
    866 		n -= next - s;
    867 		s = next;
    868 	}
    869 }
    870 
    871 void
    872 ttywriteraw(const char *s, size_t n)
    873 {
    874 	fd_set wfd, rfd;
    875 	ssize_t r;
    876 	size_t lim = 256;
    877 
    878 	/*
    879 	 * Remember that we are using a pty, which might be a modem line.
    880 	 * Writing too much will clog the line. That's why we are doing this
    881 	 * dance.
    882 	 * FIXME: Migrate the world to Plan 9.
    883 	 */
    884 	while (n > 0) {
    885 		FD_ZERO(&wfd);
    886 		FD_ZERO(&rfd);
    887 		FD_SET(cmdfd, &wfd);
    888 		FD_SET(cmdfd, &rfd);
    889 
    890 		/* Check if we can write. */
    891 		if (pselect(cmdfd+1, &rfd, &wfd, NULL, NULL, NULL) < 0) {
    892 			if (errno == EINTR)
    893 				continue;
    894 			die("select failed: %s\n", strerror(errno));
    895 		}
    896 		if (FD_ISSET(cmdfd, &wfd)) {
    897 			/*
    898 			 * Only write the bytes written by ttywrite() or the
    899 			 * default of 256. This seems to be a reasonable value
    900 			 * for a serial line. Bigger values might clog the I/O.
    901 			 */
    902 			if ((r = write(cmdfd, s, (n < lim)? n : lim)) < 0)
    903 				goto write_error;
    904 			if (r < n) {
    905 				/*
    906 				 * We weren't able to write out everything.
    907 				 * This means the buffer is getting full
    908 				 * again. Empty it.
    909 				 */
    910 				if (n < lim)
    911 					lim = ttyread();
    912 				n -= r;
    913 				s += r;
    914 			} else {
    915 				/* All bytes have been written. */
    916 				break;
    917 			}
    918 		}
    919 		if (FD_ISSET(cmdfd, &rfd))
    920 			lim = ttyread();
    921 	}
    922 	return;
    923 
    924 write_error:
    925 	die("write error on tty: %s\n", strerror(errno));
    926 }
    927 
    928 void
    929 ttyresize(int tw, int th)
    930 {
    931 	struct winsize w;
    932 
    933 	w.ws_row = term.row;
    934 	w.ws_col = term.col;
    935 	w.ws_xpixel = tw;
    936 	w.ws_ypixel = th;
    937 	if (ioctl(cmdfd, TIOCSWINSZ, &w) < 0)
    938 		fprintf(stderr, "Couldn't set window size: %s\n", strerror(errno));
    939 }
    940 
    941 void
    942 ttyhangup(void)
    943 {
    944 	/* Send SIGHUP to shell */
    945 	kill(pid, SIGHUP);
    946 }
    947 
    948 int
    949 tattrset(int attr)
    950 {
    951 	int i, j;
    952 
    953 	for (i = 0; i < term.row-1; i++) {
    954 		for (j = 0; j < term.col-1; j++) {
    955 			if (term.line[i][j].mode & attr)
    956 				return 1;
    957 		}
    958 	}
    959 
    960 	return 0;
    961 }
    962 
    963 void
    964 tsetdirt(int top, int bot)
    965 {
    966 	int i;
    967 
    968 	LIMIT(top, 0, term.row-1);
    969 	LIMIT(bot, 0, term.row-1);
    970 
    971 	for (i = top; i <= bot; i++)
    972 		term.dirty[i] = 1;
    973 }
    974 
    975 void
    976 tsetdirtattr(int attr)
    977 {
    978 	int i, j;
    979 
    980 	for (i = 0; i < term.row-1; i++) {
    981 		for (j = 0; j < term.col-1; j++) {
    982 			if (term.line[i][j].mode & attr) {
    983 				tsetdirt(i, i);
    984 				break;
    985 			}
    986 		}
    987 	}
    988 }
    989 
    990 void
    991 tfulldirt(void)
    992 {
    993 	tsetdirt(0, term.row-1);
    994 }
    995 
    996 void
    997 tcursor(int mode)
    998 {
    999 	static TCursor c[2];
   1000 	int alt = IS_SET(MODE_ALTSCREEN);
   1001 
   1002 	if (mode == CURSOR_SAVE) {
   1003 		c[alt] = term.c;
   1004 	} else if (mode == CURSOR_LOAD) {
   1005 		term.c = c[alt];
   1006 		tmoveto(c[alt].x, c[alt].y);
   1007 	}
   1008 }
   1009 
   1010 void
   1011 treset(void)
   1012 {
   1013 	uint i;
   1014 
   1015 	term.c = (TCursor){{
   1016 		.mode = ATTR_NULL,
   1017 		.fg = defaultfg,
   1018 		.bg = defaultbg
   1019 	}, .x = 0, .y = 0, .state = CURSOR_DEFAULT};
   1020 
   1021 	memset(term.tabs, 0, term.col * sizeof(*term.tabs));
   1022 	for (i = tabspaces; i < term.col; i += tabspaces)
   1023 		term.tabs[i] = 1;
   1024 	term.top = 0;
   1025 	term.bot = term.row - 1;
   1026 	term.mode = MODE_WRAP|MODE_UTF8;
   1027 	memset(term.trantbl, CS_USA, sizeof(term.trantbl));
   1028 	term.charset = 0;
   1029 
   1030 	for (i = 0; i < 2; i++) {
   1031 		tmoveto(0, 0);
   1032 		tcursor(CURSOR_SAVE);
   1033 		tclearregion(0, 0, term.col-1, term.row-1);
   1034 		tswapscreen();
   1035 	}
   1036 }
   1037 
   1038 void
   1039 tnew(int col, int row)
   1040 {
   1041 	term = (Term){ .c = { .attr = { .fg = defaultfg, .bg = defaultbg } } };
   1042 	tresize(col, row);
   1043 	treset();
   1044 }
   1045 
   1046 void
   1047 tswapscreen(void)
   1048 {
   1049 	Line *tmp = term.line;
   1050 
   1051 	term.line = term.alt;
   1052 	term.alt = tmp;
   1053 	term.mode ^= MODE_ALTSCREEN;
   1054 	tfulldirt();
   1055 }
   1056 
   1057 void
   1058 tscrolldown(int orig, int n)
   1059 {
   1060 	int i;
   1061 	Line temp;
   1062 
   1063 	LIMIT(n, 0, term.bot-orig+1);
   1064 
   1065 	tsetdirt(orig, term.bot-n);
   1066 	tclearregion(0, term.bot-n+1, term.col-1, term.bot);
   1067 
   1068 	for (i = term.bot; i >= orig+n; i--) {
   1069 		temp = term.line[i];
   1070 		term.line[i] = term.line[i-n];
   1071 		term.line[i-n] = temp;
   1072 	}
   1073 
   1074 	selscroll(orig, n);
   1075 }
   1076 
   1077 void
   1078 tscrollup(int orig, int n)
   1079 {
   1080 	int i;
   1081 	Line temp;
   1082 
   1083 	LIMIT(n, 0, term.bot-orig+1);
   1084 
   1085 	tclearregion(0, orig, term.col-1, orig+n-1);
   1086 	tsetdirt(orig+n, term.bot);
   1087 
   1088 	for (i = orig; i <= term.bot-n; i++) {
   1089 		temp = term.line[i];
   1090 		term.line[i] = term.line[i+n];
   1091 		term.line[i+n] = temp;
   1092 	}
   1093 
   1094 	selscroll(orig, -n);
   1095 }
   1096 
   1097 void
   1098 selscroll(int orig, int n)
   1099 {
   1100 	if (sel.ob.x == -1)
   1101 		return;
   1102 
   1103 	if (BETWEEN(sel.nb.y, orig, term.bot) != BETWEEN(sel.ne.y, orig, term.bot)) {
   1104 		selclear();
   1105 	} else if (BETWEEN(sel.nb.y, orig, term.bot)) {
   1106 		sel.ob.y += n;
   1107 		sel.oe.y += n;
   1108 		if (sel.ob.y < term.top || sel.ob.y > term.bot ||
   1109 		    sel.oe.y < term.top || sel.oe.y > term.bot) {
   1110 			selclear();
   1111 		} else {
   1112 			selnormalize();
   1113 		}
   1114 	}
   1115 }
   1116 
   1117 void
   1118 tnewline(int first_col)
   1119 {
   1120 	int y = term.c.y;
   1121 
   1122 	if (y == term.bot) {
   1123 		tscrollup(term.top, 1);
   1124 	} else {
   1125 		y++;
   1126 	}
   1127 	tmoveto(first_col ? 0 : term.c.x, y);
   1128 }
   1129 
   1130 void
   1131 csiparse(void)
   1132 {
   1133 	char *p = csiescseq.buf, *np;
   1134 	long int v;
   1135 
   1136 	csiescseq.narg = 0;
   1137 	if (*p == '?') {
   1138 		csiescseq.priv = 1;
   1139 		p++;
   1140 	}
   1141 
   1142 	csiescseq.buf[csiescseq.len] = '\0';
   1143 	while (p < csiescseq.buf+csiescseq.len) {
   1144 		np = NULL;
   1145 		v = strtol(p, &np, 10);
   1146 		if (np == p)
   1147 			v = 0;
   1148 		if (v == LONG_MAX || v == LONG_MIN)
   1149 			v = -1;
   1150 		csiescseq.arg[csiescseq.narg++] = v;
   1151 		p = np;
   1152 		if (*p != ';' || csiescseq.narg == ESC_ARG_SIZ)
   1153 			break;
   1154 		p++;
   1155 	}
   1156 	csiescseq.mode[0] = *p++;
   1157 	csiescseq.mode[1] = (p < csiescseq.buf+csiescseq.len) ? *p : '\0';
   1158 }
   1159 
   1160 /* for absolute user moves, when decom is set */
   1161 void
   1162 tmoveato(int x, int y)
   1163 {
   1164 	tmoveto(x, y + ((term.c.state & CURSOR_ORIGIN) ? term.top: 0));
   1165 }
   1166 
   1167 void
   1168 tmoveto(int x, int y)
   1169 {
   1170 	int miny, maxy;
   1171 
   1172 	if (term.c.state & CURSOR_ORIGIN) {
   1173 		miny = term.top;
   1174 		maxy = term.bot;
   1175 	} else {
   1176 		miny = 0;
   1177 		maxy = term.row - 1;
   1178 	}
   1179 	term.c.state &= ~CURSOR_WRAPNEXT;
   1180 	term.c.x = LIMIT(x, 0, term.col-1);
   1181 	term.c.y = LIMIT(y, miny, maxy);
   1182 }
   1183 
   1184 void
   1185 tsetchar(Rune u, const Glyph *attr, int x, int y)
   1186 {
   1187 	static const char *vt100_0[62] = { /* 0x41 - 0x7e */
   1188 		"↑", "↓", "→", "←", "█", "▚", "☃", /* A - G */
   1189 		0, 0, 0, 0, 0, 0, 0, 0, /* H - O */
   1190 		0, 0, 0, 0, 0, 0, 0, 0, /* P - W */
   1191 		0, 0, 0, 0, 0, 0, 0, " ", /* X - _ */
   1192 		"◆", "▒", "␉", "␌", "␍", "␊", "°", "±", /* ` - g */
   1193 		"␤", "␋", "┘", "┐", "┌", "└", "┼", "⎺", /* h - o */
   1194 		"⎻", "─", "⎼", "⎽", "├", "┤", "┴", "┬", /* p - w */
   1195 		"│", "≤", "≥", "π", "≠", "£", "·", /* x - ~ */
   1196 	};
   1197 
   1198 	/*
   1199 	 * The table is proudly stolen from rxvt.
   1200 	 */
   1201 	if (term.trantbl[term.charset] == CS_GRAPHIC0 &&
   1202 	   BETWEEN(u, 0x41, 0x7e) && vt100_0[u - 0x41])
   1203 		utf8decode(vt100_0[u - 0x41], &u, UTF_SIZ);
   1204 
   1205 	if (term.line[y][x].mode & ATTR_WIDE) {
   1206 		if (x+1 < term.col) {
   1207 			term.line[y][x+1].u = ' ';
   1208 			term.line[y][x+1].mode &= ~ATTR_WDUMMY;
   1209 		}
   1210 	} else if (term.line[y][x].mode & ATTR_WDUMMY) {
   1211 		term.line[y][x-1].u = ' ';
   1212 		term.line[y][x-1].mode &= ~ATTR_WIDE;
   1213 	}
   1214 
   1215 	term.dirty[y] = 1;
   1216 	term.line[y][x] = *attr;
   1217 	term.line[y][x].u = u;
   1218 }
   1219 
   1220 void
   1221 tclearregion(int x1, int y1, int x2, int y2)
   1222 {
   1223 	int x, y, temp;
   1224 	Glyph *gp;
   1225 
   1226 	if (x1 > x2)
   1227 		temp = x1, x1 = x2, x2 = temp;
   1228 	if (y1 > y2)
   1229 		temp = y1, y1 = y2, y2 = temp;
   1230 
   1231 	LIMIT(x1, 0, term.col-1);
   1232 	LIMIT(x2, 0, term.col-1);
   1233 	LIMIT(y1, 0, term.row-1);
   1234 	LIMIT(y2, 0, term.row-1);
   1235 
   1236 	for (y = y1; y <= y2; y++) {
   1237 		term.dirty[y] = 1;
   1238 		for (x = x1; x <= x2; x++) {
   1239 			gp = &term.line[y][x];
   1240 			if (selected(x, y))
   1241 				selclear();
   1242 			gp->fg = term.c.attr.fg;
   1243 			gp->bg = term.c.attr.bg;
   1244 			gp->mode = 0;
   1245 			gp->u = ' ';
   1246 		}
   1247 	}
   1248 }
   1249 
   1250 void
   1251 tdeletechar(int n)
   1252 {
   1253 	int dst, src, size;
   1254 	Glyph *line;
   1255 
   1256 	LIMIT(n, 0, term.col - term.c.x);
   1257 
   1258 	dst = term.c.x;
   1259 	src = term.c.x + n;
   1260 	size = term.col - src;
   1261 	line = term.line[term.c.y];
   1262 
   1263 	memmove(&line[dst], &line[src], size * sizeof(Glyph));
   1264 	tclearregion(term.col-n, term.c.y, term.col-1, term.c.y);
   1265 }
   1266 
   1267 void
   1268 tinsertblank(int n)
   1269 {
   1270 	int dst, src, size;
   1271 	Glyph *line;
   1272 
   1273 	LIMIT(n, 0, term.col - term.c.x);
   1274 
   1275 	dst = term.c.x + n;
   1276 	src = term.c.x;
   1277 	size = term.col - dst;
   1278 	line = term.line[term.c.y];
   1279 
   1280 	memmove(&line[dst], &line[src], size * sizeof(Glyph));
   1281 	tclearregion(src, term.c.y, dst - 1, term.c.y);
   1282 }
   1283 
   1284 void
   1285 tinsertblankline(int n)
   1286 {
   1287 	if (BETWEEN(term.c.y, term.top, term.bot))
   1288 		tscrolldown(term.c.y, n);
   1289 }
   1290 
   1291 void
   1292 tdeleteline(int n)
   1293 {
   1294 	if (BETWEEN(term.c.y, term.top, term.bot))
   1295 		tscrollup(term.c.y, n);
   1296 }
   1297 
   1298 int32_t
   1299 tdefcolor(const int *attr, int *npar, int l)
   1300 {
   1301 	int32_t idx = -1;
   1302 	uint r, g, b;
   1303 
   1304 	switch (attr[*npar + 1]) {
   1305 	case 2: /* direct color in RGB space */
   1306 		if (*npar + 4 >= l) {
   1307 			fprintf(stderr,
   1308 				"erresc(38): Incorrect number of parameters (%d)\n",
   1309 				*npar);
   1310 			break;
   1311 		}
   1312 		r = attr[*npar + 2];
   1313 		g = attr[*npar + 3];
   1314 		b = attr[*npar + 4];
   1315 		*npar += 4;
   1316 		if (!BETWEEN(r, 0, 255) || !BETWEEN(g, 0, 255) || !BETWEEN(b, 0, 255))
   1317 			fprintf(stderr, "erresc: bad rgb color (%u,%u,%u)\n",
   1318 				r, g, b);
   1319 		else
   1320 			idx = TRUECOLOR(r, g, b);
   1321 		break;
   1322 	case 5: /* indexed color */
   1323 		if (*npar + 2 >= l) {
   1324 			fprintf(stderr,
   1325 				"erresc(38): Incorrect number of parameters (%d)\n",
   1326 				*npar);
   1327 			break;
   1328 		}
   1329 		*npar += 2;
   1330 		if (!BETWEEN(attr[*npar], 0, 255))
   1331 			fprintf(stderr, "erresc: bad fgcolor %d\n", attr[*npar]);
   1332 		else
   1333 			idx = attr[*npar];
   1334 		break;
   1335 	case 0: /* implemented defined (only foreground) */
   1336 	case 1: /* transparent */
   1337 	case 3: /* direct color in CMY space */
   1338 	case 4: /* direct color in CMYK space */
   1339 	default:
   1340 		fprintf(stderr,
   1341 		        "erresc(38): gfx attr %d unknown\n", attr[*npar]);
   1342 		break;
   1343 	}
   1344 
   1345 	return idx;
   1346 }
   1347 
   1348 void
   1349 tsetattr(const int *attr, int l)
   1350 {
   1351 	int i;
   1352 	int32_t idx;
   1353 
   1354 	for (i = 0; i < l; i++) {
   1355 		switch (attr[i]) {
   1356 		case 0:
   1357 			term.c.attr.mode &= ~(
   1358 				ATTR_BOLD       |
   1359 				ATTR_FAINT      |
   1360 				ATTR_ITALIC     |
   1361 				ATTR_UNDERLINE  |
   1362 				ATTR_BLINK      |
   1363 				ATTR_REVERSE    |
   1364 				ATTR_INVISIBLE  |
   1365 				ATTR_STRUCK     );
   1366 			term.c.attr.fg = defaultfg;
   1367 			term.c.attr.bg = defaultbg;
   1368 			break;
   1369 		case 1:
   1370 			term.c.attr.mode |= ATTR_BOLD;
   1371 			break;
   1372 		case 2:
   1373 			term.c.attr.mode |= ATTR_FAINT;
   1374 			break;
   1375 		case 3:
   1376 			term.c.attr.mode |= ATTR_ITALIC;
   1377 			break;
   1378 		case 4:
   1379 			term.c.attr.mode |= ATTR_UNDERLINE;
   1380 			break;
   1381 		case 5: /* slow blink */
   1382 			/* FALLTHROUGH */
   1383 		case 6: /* rapid blink */
   1384 			term.c.attr.mode |= ATTR_BLINK;
   1385 			break;
   1386 		case 7:
   1387 			term.c.attr.mode |= ATTR_REVERSE;
   1388 			break;
   1389 		case 8:
   1390 			term.c.attr.mode |= ATTR_INVISIBLE;
   1391 			break;
   1392 		case 9:
   1393 			term.c.attr.mode |= ATTR_STRUCK;
   1394 			break;
   1395 		case 22:
   1396 			term.c.attr.mode &= ~(ATTR_BOLD | ATTR_FAINT);
   1397 			break;
   1398 		case 23:
   1399 			term.c.attr.mode &= ~ATTR_ITALIC;
   1400 			break;
   1401 		case 24:
   1402 			term.c.attr.mode &= ~ATTR_UNDERLINE;
   1403 			break;
   1404 		case 25:
   1405 			term.c.attr.mode &= ~ATTR_BLINK;
   1406 			break;
   1407 		case 27:
   1408 			term.c.attr.mode &= ~ATTR_REVERSE;
   1409 			break;
   1410 		case 28:
   1411 			term.c.attr.mode &= ~ATTR_INVISIBLE;
   1412 			break;
   1413 		case 29:
   1414 			term.c.attr.mode &= ~ATTR_STRUCK;
   1415 			break;
   1416 		case 38:
   1417 			if ((idx = tdefcolor(attr, &i, l)) >= 0)
   1418 				term.c.attr.fg = idx;
   1419 			break;
   1420 		case 39:
   1421 			term.c.attr.fg = defaultfg;
   1422 			break;
   1423 		case 48:
   1424 			if ((idx = tdefcolor(attr, &i, l)) >= 0)
   1425 				term.c.attr.bg = idx;
   1426 			break;
   1427 		case 49:
   1428 			term.c.attr.bg = defaultbg;
   1429 			break;
   1430 		default:
   1431 			if (BETWEEN(attr[i], 30, 37)) {
   1432 				term.c.attr.fg = attr[i] - 30;
   1433 			} else if (BETWEEN(attr[i], 40, 47)) {
   1434 				term.c.attr.bg = attr[i] - 40;
   1435 			} else if (BETWEEN(attr[i], 90, 97)) {
   1436 				term.c.attr.fg = attr[i] - 90 + 8;
   1437 			} else if (BETWEEN(attr[i], 100, 107)) {
   1438 				term.c.attr.bg = attr[i] - 100 + 8;
   1439 			} else {
   1440 				fprintf(stderr,
   1441 					"erresc(default): gfx attr %d unknown\n",
   1442 					attr[i]);
   1443 				csidump();
   1444 			}
   1445 			break;
   1446 		}
   1447 	}
   1448 }
   1449 
   1450 void
   1451 tsetscroll(int t, int b)
   1452 {
   1453 	int temp;
   1454 
   1455 	LIMIT(t, 0, term.row-1);
   1456 	LIMIT(b, 0, term.row-1);
   1457 	if (t > b) {
   1458 		temp = t;
   1459 		t = b;
   1460 		b = temp;
   1461 	}
   1462 	term.top = t;
   1463 	term.bot = b;
   1464 }
   1465 
   1466 void
   1467 tsetmode(int priv, int set, const int *args, int narg)
   1468 {
   1469 	int alt; const int *lim;
   1470 
   1471 	for (lim = args + narg; args < lim; ++args) {
   1472 		if (priv) {
   1473 			switch (*args) {
   1474 			case 1: /* DECCKM -- Cursor key */
   1475 				xsetmode(set, MODE_APPCURSOR);
   1476 				break;
   1477 			case 5: /* DECSCNM -- Reverse video */
   1478 				xsetmode(set, MODE_REVERSE);
   1479 				break;
   1480 			case 6: /* DECOM -- Origin */
   1481 				MODBIT(term.c.state, set, CURSOR_ORIGIN);
   1482 				tmoveato(0, 0);
   1483 				break;
   1484 			case 7: /* DECAWM -- Auto wrap */
   1485 				MODBIT(term.mode, set, MODE_WRAP);
   1486 				break;
   1487 			case 0:  /* Error (IGNORED) */
   1488 			case 2:  /* DECANM -- ANSI/VT52 (IGNORED) */
   1489 			case 3:  /* DECCOLM -- Column  (IGNORED) */
   1490 			case 4:  /* DECSCLM -- Scroll (IGNORED) */
   1491 			case 8:  /* DECARM -- Auto repeat (IGNORED) */
   1492 			case 18: /* DECPFF -- Printer feed (IGNORED) */
   1493 			case 19: /* DECPEX -- Printer extent (IGNORED) */
   1494 			case 42: /* DECNRCM -- National characters (IGNORED) */
   1495 			case 12: /* att610 -- Start blinking cursor (IGNORED) */
   1496 				break;
   1497 			case 25: /* DECTCEM -- Text Cursor Enable Mode */
   1498 				xsetmode(!set, MODE_HIDE);
   1499 				break;
   1500 			case 9:    /* X10 mouse compatibility mode */
   1501 				xsetpointermotion(0);
   1502 				xsetmode(0, MODE_MOUSE);
   1503 				xsetmode(set, MODE_MOUSEX10);
   1504 				break;
   1505 			case 1000: /* 1000: report button press */
   1506 				xsetpointermotion(0);
   1507 				xsetmode(0, MODE_MOUSE);
   1508 				xsetmode(set, MODE_MOUSEBTN);
   1509 				break;
   1510 			case 1002: /* 1002: report motion on button press */
   1511 				xsetpointermotion(0);
   1512 				xsetmode(0, MODE_MOUSE);
   1513 				xsetmode(set, MODE_MOUSEMOTION);
   1514 				break;
   1515 			case 1003: /* 1003: enable all mouse motions */
   1516 				xsetpointermotion(set);
   1517 				xsetmode(0, MODE_MOUSE);
   1518 				xsetmode(set, MODE_MOUSEMANY);
   1519 				break;
   1520 			case 1004: /* 1004: send focus events to tty */
   1521 				xsetmode(set, MODE_FOCUS);
   1522 				break;
   1523 			case 1006: /* 1006: extended reporting mode */
   1524 				xsetmode(set, MODE_MOUSESGR);
   1525 				break;
   1526 			case 1034:
   1527 				xsetmode(set, MODE_8BIT);
   1528 				break;
   1529 			case 1049: /* swap screen & set/restore cursor as xterm */
   1530 				if (!allowaltscreen)
   1531 					break;
   1532 				tcursor((set) ? CURSOR_SAVE : CURSOR_LOAD);
   1533 				/* FALLTHROUGH */
   1534 			case 47: /* swap screen */
   1535 			case 1047:
   1536 				if (!allowaltscreen)
   1537 					break;
   1538 				alt = IS_SET(MODE_ALTSCREEN);
   1539 				if (alt) {
   1540 					tclearregion(0, 0, term.col-1,
   1541 							term.row-1);
   1542 				}
   1543 				if (set ^ alt) /* set is always 1 or 0 */
   1544 					tswapscreen();
   1545 				if (*args != 1049)
   1546 					break;
   1547 				/* FALLTHROUGH */
   1548 			case 1048:
   1549 				tcursor((set) ? CURSOR_SAVE : CURSOR_LOAD);
   1550 				break;
   1551 			case 2004: /* 2004: bracketed paste mode */
   1552 				xsetmode(set, MODE_BRCKTPASTE);
   1553 				break;
   1554 			/* Not implemented mouse modes. See comments there. */
   1555 			case 1001: /* mouse highlight mode; can hang the
   1556 				      terminal by design when implemented. */
   1557 			case 1005: /* UTF-8 mouse mode; will confuse
   1558 				      applications not supporting UTF-8
   1559 				      and luit. */
   1560 			case 1015: /* urxvt mangled mouse mode; incompatible
   1561 				      and can be mistaken for other control
   1562 				      codes. */
   1563 				break;
   1564 			default:
   1565 				fprintf(stderr,
   1566 					"erresc: unknown private set/reset mode %d\n",
   1567 					*args);
   1568 				break;
   1569 			}
   1570 		} else {
   1571 			switch (*args) {
   1572 			case 0:  /* Error (IGNORED) */
   1573 				break;
   1574 			case 2:
   1575 				xsetmode(set, MODE_KBDLOCK);
   1576 				break;
   1577 			case 4:  /* IRM -- Insertion-replacement */
   1578 				MODBIT(term.mode, set, MODE_INSERT);
   1579 				break;
   1580 			case 12: /* SRM -- Send/Receive */
   1581 				MODBIT(term.mode, !set, MODE_ECHO);
   1582 				break;
   1583 			case 20: /* LNM -- Linefeed/new line */
   1584 				MODBIT(term.mode, set, MODE_CRLF);
   1585 				break;
   1586 			default:
   1587 				fprintf(stderr,
   1588 					"erresc: unknown set/reset mode %d\n",
   1589 					*args);
   1590 				break;
   1591 			}
   1592 		}
   1593 	}
   1594 }
   1595 
   1596 void
   1597 csihandle(void)
   1598 {
   1599 	char buf[40];
   1600 	int len;
   1601 
   1602 	switch (csiescseq.mode[0]) {
   1603 	default:
   1604 	unknown:
   1605 		fprintf(stderr, "erresc: unknown csi ");
   1606 		csidump();
   1607 		/* die(""); */
   1608 		break;
   1609 	case '@': /* ICH -- Insert <n> blank char */
   1610 		DEFAULT(csiescseq.arg[0], 1);
   1611 		tinsertblank(csiescseq.arg[0]);
   1612 		break;
   1613 	case 'A': /* CUU -- Cursor <n> Up */
   1614 		DEFAULT(csiescseq.arg[0], 1);
   1615 		tmoveto(term.c.x, term.c.y-csiescseq.arg[0]);
   1616 		break;
   1617 	case 'B': /* CUD -- Cursor <n> Down */
   1618 	case 'e': /* VPR --Cursor <n> Down */
   1619 		DEFAULT(csiescseq.arg[0], 1);
   1620 		tmoveto(term.c.x, term.c.y+csiescseq.arg[0]);
   1621 		break;
   1622 	case 'i': /* MC -- Media Copy */
   1623 		switch (csiescseq.arg[0]) {
   1624 		case 0:
   1625 			tdump();
   1626 			break;
   1627 		case 1:
   1628 			tdumpline(term.c.y);
   1629 			break;
   1630 		case 2:
   1631 			tdumpsel();
   1632 			break;
   1633 		case 4:
   1634 			term.mode &= ~MODE_PRINT;
   1635 			break;
   1636 		case 5:
   1637 			term.mode |= MODE_PRINT;
   1638 			break;
   1639 		}
   1640 		break;
   1641 	case 'c': /* DA -- Device Attributes */
   1642 		if (csiescseq.arg[0] == 0)
   1643 			ttywrite(vtiden, strlen(vtiden), 0);
   1644 		break;
   1645 	case 'b': /* REP -- if last char is printable print it <n> more times */
   1646 		DEFAULT(csiescseq.arg[0], 1);
   1647 		if (term.lastc)
   1648 			while (csiescseq.arg[0]-- > 0)
   1649 				tputc(term.lastc);
   1650 		break;
   1651 	case 'C': /* CUF -- Cursor <n> Forward */
   1652 	case 'a': /* HPR -- Cursor <n> Forward */
   1653 		DEFAULT(csiescseq.arg[0], 1);
   1654 		tmoveto(term.c.x+csiescseq.arg[0], term.c.y);
   1655 		break;
   1656 	case 'D': /* CUB -- Cursor <n> Backward */
   1657 		DEFAULT(csiescseq.arg[0], 1);
   1658 		tmoveto(term.c.x-csiescseq.arg[0], term.c.y);
   1659 		break;
   1660 	case 'E': /* CNL -- Cursor <n> Down and first col */
   1661 		DEFAULT(csiescseq.arg[0], 1);
   1662 		tmoveto(0, term.c.y+csiescseq.arg[0]);
   1663 		break;
   1664 	case 'F': /* CPL -- Cursor <n> Up and first col */
   1665 		DEFAULT(csiescseq.arg[0], 1);
   1666 		tmoveto(0, term.c.y-csiescseq.arg[0]);
   1667 		break;
   1668 	case 'g': /* TBC -- Tabulation clear */
   1669 		switch (csiescseq.arg[0]) {
   1670 		case 0: /* clear current tab stop */
   1671 			term.tabs[term.c.x] = 0;
   1672 			break;
   1673 		case 3: /* clear all the tabs */
   1674 			memset(term.tabs, 0, term.col * sizeof(*term.tabs));
   1675 			break;
   1676 		default:
   1677 			goto unknown;
   1678 		}
   1679 		break;
   1680 	case 'G': /* CHA -- Move to <col> */
   1681 	case '`': /* HPA */
   1682 		DEFAULT(csiescseq.arg[0], 1);
   1683 		tmoveto(csiescseq.arg[0]-1, term.c.y);
   1684 		break;
   1685 	case 'H': /* CUP -- Move to <row> <col> */
   1686 	case 'f': /* HVP */
   1687 		DEFAULT(csiescseq.arg[0], 1);
   1688 		DEFAULT(csiescseq.arg[1], 1);
   1689 		tmoveato(csiescseq.arg[1]-1, csiescseq.arg[0]-1);
   1690 		break;
   1691 	case 'I': /* CHT -- Cursor Forward Tabulation <n> tab stops */
   1692 		DEFAULT(csiescseq.arg[0], 1);
   1693 		tputtab(csiescseq.arg[0]);
   1694 		break;
   1695 	case 'J': /* ED -- Clear screen */
   1696 		switch (csiescseq.arg[0]) {
   1697 		case 0: /* below */
   1698 			tclearregion(term.c.x, term.c.y, term.col-1, term.c.y);
   1699 			if (term.c.y < term.row-1) {
   1700 				tclearregion(0, term.c.y+1, term.col-1,
   1701 						term.row-1);
   1702 			}
   1703 			break;
   1704 		case 1: /* above */
   1705 			if (term.c.y > 1)
   1706 				tclearregion(0, 0, term.col-1, term.c.y-1);
   1707 			tclearregion(0, term.c.y, term.c.x, term.c.y);
   1708 			break;
   1709 		case 2: /* all */
   1710 			tclearregion(0, 0, term.col-1, term.row-1);
   1711 			break;
   1712 		default:
   1713 			goto unknown;
   1714 		}
   1715 		break;
   1716 	case 'K': /* EL -- Clear line */
   1717 		switch (csiescseq.arg[0]) {
   1718 		case 0: /* right */
   1719 			tclearregion(term.c.x, term.c.y, term.col-1,
   1720 					term.c.y);
   1721 			break;
   1722 		case 1: /* left */
   1723 			tclearregion(0, term.c.y, term.c.x, term.c.y);
   1724 			break;
   1725 		case 2: /* all */
   1726 			tclearregion(0, term.c.y, term.col-1, term.c.y);
   1727 			break;
   1728 		}
   1729 		break;
   1730 	case 'S': /* SU -- Scroll <n> line up */
   1731 		DEFAULT(csiescseq.arg[0], 1);
   1732 		tscrollup(term.top, csiescseq.arg[0]);
   1733 		break;
   1734 	case 'T': /* SD -- Scroll <n> line down */
   1735 		DEFAULT(csiescseq.arg[0], 1);
   1736 		tscrolldown(term.top, csiescseq.arg[0]);
   1737 		break;
   1738 	case 'L': /* IL -- Insert <n> blank lines */
   1739 		DEFAULT(csiescseq.arg[0], 1);
   1740 		tinsertblankline(csiescseq.arg[0]);
   1741 		break;
   1742 	case 'l': /* RM -- Reset Mode */
   1743 		tsetmode(csiescseq.priv, 0, csiescseq.arg, csiescseq.narg);
   1744 		break;
   1745 	case 'M': /* DL -- Delete <n> lines */
   1746 		DEFAULT(csiescseq.arg[0], 1);
   1747 		tdeleteline(csiescseq.arg[0]);
   1748 		break;
   1749 	case 'X': /* ECH -- Erase <n> char */
   1750 		DEFAULT(csiescseq.arg[0], 1);
   1751 		tclearregion(term.c.x, term.c.y,
   1752 				term.c.x + csiescseq.arg[0] - 1, term.c.y);
   1753 		break;
   1754 	case 'P': /* DCH -- Delete <n> char */
   1755 		DEFAULT(csiescseq.arg[0], 1);
   1756 		tdeletechar(csiescseq.arg[0]);
   1757 		break;
   1758 	case 'Z': /* CBT -- Cursor Backward Tabulation <n> tab stops */
   1759 		DEFAULT(csiescseq.arg[0], 1);
   1760 		tputtab(-csiescseq.arg[0]);
   1761 		break;
   1762 	case 'd': /* VPA -- Move to <row> */
   1763 		DEFAULT(csiescseq.arg[0], 1);
   1764 		tmoveato(term.c.x, csiescseq.arg[0]-1);
   1765 		break;
   1766 	case 'h': /* SM -- Set terminal mode */
   1767 		tsetmode(csiescseq.priv, 1, csiescseq.arg, csiescseq.narg);
   1768 		break;
   1769 	case 'm': /* SGR -- Terminal attribute (color) */
   1770 		tsetattr(csiescseq.arg, csiescseq.narg);
   1771 		break;
   1772 	case 'n': /* DSR – Device Status Report (cursor position) */
   1773 		if (csiescseq.arg[0] == 6) {
   1774 			len = snprintf(buf, sizeof(buf), "\033[%i;%iR",
   1775 					term.c.y+1, term.c.x+1);
   1776 			ttywrite(buf, len, 0);
   1777 		}
   1778 		break;
   1779 	case 'r': /* DECSTBM -- Set Scrolling Region */
   1780 		if (csiescseq.priv) {
   1781 			goto unknown;
   1782 		} else {
   1783 			DEFAULT(csiescseq.arg[0], 1);
   1784 			DEFAULT(csiescseq.arg[1], term.row);
   1785 			tsetscroll(csiescseq.arg[0]-1, csiescseq.arg[1]-1);
   1786 			tmoveato(0, 0);
   1787 		}
   1788 		break;
   1789 	case 's': /* DECSC -- Save cursor position (ANSI.SYS) */
   1790 		tcursor(CURSOR_SAVE);
   1791 		break;
   1792 	case 'u': /* DECRC -- Restore cursor position (ANSI.SYS) */
   1793 		tcursor(CURSOR_LOAD);
   1794 		break;
   1795 	case ' ':
   1796 		switch (csiescseq.mode[1]) {
   1797 		case 'q': /* DECSCUSR -- Set Cursor Style */
   1798 			if (xsetcursor(csiescseq.arg[0]))
   1799 				goto unknown;
   1800 			break;
   1801 		default:
   1802 			goto unknown;
   1803 		}
   1804 		break;
   1805 	}
   1806 }
   1807 
   1808 void
   1809 csidump(void)
   1810 {
   1811 	size_t i;
   1812 	uint c;
   1813 
   1814 	fprintf(stderr, "ESC[");
   1815 	for (i = 0; i < csiescseq.len; i++) {
   1816 		c = csiescseq.buf[i] & 0xff;
   1817 		if (isprint(c)) {
   1818 			putc(c, stderr);
   1819 		} else if (c == '\n') {
   1820 			fprintf(stderr, "(\\n)");
   1821 		} else if (c == '\r') {
   1822 			fprintf(stderr, "(\\r)");
   1823 		} else if (c == 0x1b) {
   1824 			fprintf(stderr, "(\\e)");
   1825 		} else {
   1826 			fprintf(stderr, "(%02x)", c);
   1827 		}
   1828 	}
   1829 	putc('\n', stderr);
   1830 }
   1831 
   1832 void
   1833 csireset(void)
   1834 {
   1835 	memset(&csiescseq, 0, sizeof(csiescseq));
   1836 }
   1837 
   1838 void
   1839 osc_color_response(int num, int index, int is_osc4)
   1840 {
   1841 	int n;
   1842 	char buf[32];
   1843 	unsigned char r, g, b;
   1844 
   1845 	if (xgetcolor(is_osc4 ? num : index, &r, &g, &b)) {
   1846 		fprintf(stderr, "erresc: failed to fetch %s color %d\n",
   1847 		        is_osc4 ? "osc4" : "osc",
   1848 		        is_osc4 ? num : index);
   1849 		return;
   1850 	}
   1851 
   1852 	n = snprintf(buf, sizeof buf, "\033]%s%d;rgb:%02x%02x/%02x%02x/%02x%02x\007",
   1853 	             is_osc4 ? "4;" : "", num, r, r, g, g, b, b);
   1854 	if (n < 0 || n >= sizeof(buf)) {
   1855 		fprintf(stderr, "error: %s while printing %s response\n",
   1856 		        n < 0 ? "snprintf failed" : "truncation occurred",
   1857 		        is_osc4 ? "osc4" : "osc");
   1858 	} else {
   1859 		ttywrite(buf, n, 1);
   1860 	}
   1861 }
   1862 
   1863 void
   1864 strhandle(void)
   1865 {
   1866 	char *p = NULL, *dec;
   1867 	int j, narg, par;
   1868 	const struct { int idx; char *str; } osc_table[] = {
   1869 		{ defaultfg, "foreground" },
   1870 		{ defaultbg, "background" },
   1871 		{ defaultcs, "cursor" }
   1872 	};
   1873 
   1874 	term.esc &= ~(ESC_STR_END|ESC_STR);
   1875 	strparse();
   1876 	par = (narg = strescseq.narg) ? atoi(strescseq.args[0]) : 0;
   1877 
   1878 	switch (strescseq.type) {
   1879 	case ']': /* OSC -- Operating System Command */
   1880 		switch (par) {
   1881 		case 0:
   1882 			if (narg > 1) {
   1883 				xsettitle(strescseq.args[1]);
   1884 				xseticontitle(strescseq.args[1]);
   1885 			}
   1886 			return;
   1887 		case 1:
   1888 			if (narg > 1)
   1889 				xseticontitle(strescseq.args[1]);
   1890 			return;
   1891 		case 2:
   1892 			if (narg > 1)
   1893 				xsettitle(strescseq.args[1]);
   1894 			return;
   1895 		case 52:
   1896 			if (narg > 2 && allowwindowops) {
   1897 				dec = base64dec(strescseq.args[2]);
   1898 				if (dec) {
   1899 					xsetsel(dec);
   1900 					xclipcopy();
   1901 				} else {
   1902 					fprintf(stderr, "erresc: invalid base64\n");
   1903 				}
   1904 			}
   1905 			return;
   1906 		case 10:
   1907 		case 11:
   1908 		case 12:
   1909 			if (narg < 2)
   1910 				break;
   1911 			p = strescseq.args[1];
   1912 			if ((j = par - 10) < 0 || j >= LEN(osc_table))
   1913 				break; /* shouldn't be possible */
   1914 
   1915 			if (!strcmp(p, "?")) {
   1916 				osc_color_response(par, osc_table[j].idx, 0);
   1917 			} else if (xsetcolorname(osc_table[j].idx, p)) {
   1918 				fprintf(stderr, "erresc: invalid %s color: %s\n",
   1919 				        osc_table[j].str, p);
   1920 			} else {
   1921 				tfulldirt();
   1922 			}
   1923 			return;
   1924 		case 4: /* color set */
   1925 			if (narg < 3)
   1926 				break;
   1927 			p = strescseq.args[2];
   1928 			/* FALLTHROUGH */
   1929 		case 104: /* color reset */
   1930 			j = (narg > 1) ? atoi(strescseq.args[1]) : -1;
   1931 
   1932 			if (p && !strcmp(p, "?")) {
   1933 				osc_color_response(j, 0, 1);
   1934 			} else if (xsetcolorname(j, p)) {
   1935 				if (par == 104 && narg <= 1)
   1936 					return; /* color reset without parameter */
   1937 				fprintf(stderr, "erresc: invalid color j=%d, p=%s\n",
   1938 				        j, p ? p : "(null)");
   1939 			} else {
   1940 				/*
   1941 				 * TODO if defaultbg color is changed, borders
   1942 				 * are dirty
   1943 				 */
   1944 				tfulldirt();
   1945 			}
   1946 			return;
   1947 		}
   1948 		break;
   1949 	case 'k': /* old title set compatibility */
   1950 		xsettitle(strescseq.args[0]);
   1951 		return;
   1952 	case 'P': /* DCS -- Device Control String */
   1953 	case '_': /* APC -- Application Program Command */
   1954 	case '^': /* PM -- Privacy Message */
   1955 		return;
   1956 	}
   1957 
   1958 	fprintf(stderr, "erresc: unknown str ");
   1959 	strdump();
   1960 }
   1961 
   1962 void
   1963 strparse(void)
   1964 {
   1965 	int c;
   1966 	char *p = strescseq.buf;
   1967 
   1968 	strescseq.narg = 0;
   1969 	strescseq.buf[strescseq.len] = '\0';
   1970 
   1971 	if (*p == '\0')
   1972 		return;
   1973 
   1974 	while (strescseq.narg < STR_ARG_SIZ) {
   1975 		strescseq.args[strescseq.narg++] = p;
   1976 		while ((c = *p) != ';' && c != '\0')
   1977 			++p;
   1978 		if (c == '\0')
   1979 			return;
   1980 		*p++ = '\0';
   1981 	}
   1982 }
   1983 
   1984 void
   1985 strdump(void)
   1986 {
   1987 	size_t i;
   1988 	uint c;
   1989 
   1990 	fprintf(stderr, "ESC%c", strescseq.type);
   1991 	for (i = 0; i < strescseq.len; i++) {
   1992 		c = strescseq.buf[i] & 0xff;
   1993 		if (c == '\0') {
   1994 			putc('\n', stderr);
   1995 			return;
   1996 		} else if (isprint(c)) {
   1997 			putc(c, stderr);
   1998 		} else if (c == '\n') {
   1999 			fprintf(stderr, "(\\n)");
   2000 		} else if (c == '\r') {
   2001 			fprintf(stderr, "(\\r)");
   2002 		} else if (c == 0x1b) {
   2003 			fprintf(stderr, "(\\e)");
   2004 		} else {
   2005 			fprintf(stderr, "(%02x)", c);
   2006 		}
   2007 	}
   2008 	fprintf(stderr, "ESC\\\n");
   2009 }
   2010 
   2011 void
   2012 strreset(void)
   2013 {
   2014 	strescseq = (STREscape){
   2015 		.buf = xrealloc(strescseq.buf, STR_BUF_SIZ),
   2016 		.siz = STR_BUF_SIZ,
   2017 	};
   2018 }
   2019 
   2020 void
   2021 sendbreak(const Arg *arg)
   2022 {
   2023 	if (tcsendbreak(cmdfd, 0))
   2024 		perror("Error sending break");
   2025 }
   2026 
   2027 void
   2028 tprinter(char *s, size_t len)
   2029 {
   2030 	if (iofd != -1 && xwrite(iofd, s, len) < 0) {
   2031 		perror("Error writing to output file");
   2032 		close(iofd);
   2033 		iofd = -1;
   2034 	}
   2035 }
   2036 
   2037 void
   2038 toggleprinter(const Arg *arg)
   2039 {
   2040 	term.mode ^= MODE_PRINT;
   2041 }
   2042 
   2043 void
   2044 printscreen(const Arg *arg)
   2045 {
   2046 	tdump();
   2047 }
   2048 
   2049 void
   2050 printsel(const Arg *arg)
   2051 {
   2052 	tdumpsel();
   2053 }
   2054 
   2055 void
   2056 tdumpsel(void)
   2057 {
   2058 	char *ptr;
   2059 
   2060 	if ((ptr = getsel())) {
   2061 		tprinter(ptr, strlen(ptr));
   2062 		free(ptr);
   2063 	}
   2064 }
   2065 
   2066 void
   2067 tdumpline(int n)
   2068 {
   2069 	char buf[UTF_SIZ];
   2070 	const Glyph *bp, *end;
   2071 
   2072 	bp = &term.line[n][0];
   2073 	end = &bp[MIN(tlinelen(n), term.col) - 1];
   2074 	if (bp != end || bp->u != ' ') {
   2075 		for ( ; bp <= end; ++bp)
   2076 			tprinter(buf, utf8encode(bp->u, buf));
   2077 	}
   2078 	tprinter("\n", 1);
   2079 }
   2080 
   2081 void
   2082 tdump(void)
   2083 {
   2084 	int i;
   2085 
   2086 	for (i = 0; i < term.row; ++i)
   2087 		tdumpline(i);
   2088 }
   2089 
   2090 void
   2091 tputtab(int n)
   2092 {
   2093 	uint x = term.c.x;
   2094 
   2095 	if (n > 0) {
   2096 		while (x < term.col && n--)
   2097 			for (++x; x < term.col && !term.tabs[x]; ++x)
   2098 				/* nothing */ ;
   2099 	} else if (n < 0) {
   2100 		while (x > 0 && n++)
   2101 			for (--x; x > 0 && !term.tabs[x]; --x)
   2102 				/* nothing */ ;
   2103 	}
   2104 	term.c.x = LIMIT(x, 0, term.col-1);
   2105 }
   2106 
   2107 void
   2108 tdefutf8(char ascii)
   2109 {
   2110 	if (ascii == 'G')
   2111 		term.mode |= MODE_UTF8;
   2112 	else if (ascii == '@')
   2113 		term.mode &= ~MODE_UTF8;
   2114 }
   2115 
   2116 void
   2117 tdeftran(char ascii)
   2118 {
   2119 	static char cs[] = "0B";
   2120 	static int vcs[] = {CS_GRAPHIC0, CS_USA};
   2121 	char *p;
   2122 
   2123 	if ((p = strchr(cs, ascii)) == NULL) {
   2124 		fprintf(stderr, "esc unhandled charset: ESC ( %c\n", ascii);
   2125 	} else {
   2126 		term.trantbl[term.icharset] = vcs[p - cs];
   2127 	}
   2128 }
   2129 
   2130 void
   2131 tdectest(char c)
   2132 {
   2133 	int x, y;
   2134 
   2135 	if (c == '8') { /* DEC screen alignment test. */
   2136 		for (x = 0; x < term.col; ++x) {
   2137 			for (y = 0; y < term.row; ++y)
   2138 				tsetchar('E', &term.c.attr, x, y);
   2139 		}
   2140 	}
   2141 }
   2142 
   2143 void
   2144 tstrsequence(uchar c)
   2145 {
   2146 	switch (c) {
   2147 	case 0x90:   /* DCS -- Device Control String */
   2148 		c = 'P';
   2149 		break;
   2150 	case 0x9f:   /* APC -- Application Program Command */
   2151 		c = '_';
   2152 		break;
   2153 	case 0x9e:   /* PM -- Privacy Message */
   2154 		c = '^';
   2155 		break;
   2156 	case 0x9d:   /* OSC -- Operating System Command */
   2157 		c = ']';
   2158 		break;
   2159 	}
   2160 	strreset();
   2161 	strescseq.type = c;
   2162 	term.esc |= ESC_STR;
   2163 }
   2164 
   2165 void
   2166 tcontrolcode(uchar ascii)
   2167 {
   2168 	switch (ascii) {
   2169 	case '\t':   /* HT */
   2170 		tputtab(1);
   2171 		return;
   2172 	case '\b':   /* BS */
   2173 		tmoveto(term.c.x-1, term.c.y);
   2174 		return;
   2175 	case '\r':   /* CR */
   2176 		tmoveto(0, term.c.y);
   2177 		return;
   2178 	case '\f':   /* LF */
   2179 	case '\v':   /* VT */
   2180 	case '\n':   /* LF */
   2181 		/* go to first col if the mode is set */
   2182 		tnewline(IS_SET(MODE_CRLF));
   2183 		return;
   2184 	case '\a':   /* BEL */
   2185 		if (term.esc & ESC_STR_END) {
   2186 			/* backwards compatibility to xterm */
   2187 			strhandle();
   2188 		} else {
   2189 			xbell();
   2190 		}
   2191 		break;
   2192 	case '\033': /* ESC */
   2193 		csireset();
   2194 		term.esc &= ~(ESC_CSI|ESC_ALTCHARSET|ESC_TEST);
   2195 		term.esc |= ESC_START;
   2196 		return;
   2197 	case '\016': /* SO (LS1 -- Locking shift 1) */
   2198 	case '\017': /* SI (LS0 -- Locking shift 0) */
   2199 		term.charset = 1 - (ascii - '\016');
   2200 		return;
   2201 	case '\032': /* SUB */
   2202 		tsetchar('?', &term.c.attr, term.c.x, term.c.y);
   2203 		/* FALLTHROUGH */
   2204 	case '\030': /* CAN */
   2205 		csireset();
   2206 		break;
   2207 	case '\005': /* ENQ (IGNORED) */
   2208 	case '\000': /* NUL (IGNORED) */
   2209 	case '\021': /* XON (IGNORED) */
   2210 	case '\023': /* XOFF (IGNORED) */
   2211 	case 0177:   /* DEL (IGNORED) */
   2212 		return;
   2213 	case 0x80:   /* TODO: PAD */
   2214 	case 0x81:   /* TODO: HOP */
   2215 	case 0x82:   /* TODO: BPH */
   2216 	case 0x83:   /* TODO: NBH */
   2217 	case 0x84:   /* TODO: IND */
   2218 		break;
   2219 	case 0x85:   /* NEL -- Next line */
   2220 		tnewline(1); /* always go to first col */
   2221 		break;
   2222 	case 0x86:   /* TODO: SSA */
   2223 	case 0x87:   /* TODO: ESA */
   2224 		break;
   2225 	case 0x88:   /* HTS -- Horizontal tab stop */
   2226 		term.tabs[term.c.x] = 1;
   2227 		break;
   2228 	case 0x89:   /* TODO: HTJ */
   2229 	case 0x8a:   /* TODO: VTS */
   2230 	case 0x8b:   /* TODO: PLD */
   2231 	case 0x8c:   /* TODO: PLU */
   2232 	case 0x8d:   /* TODO: RI */
   2233 	case 0x8e:   /* TODO: SS2 */
   2234 	case 0x8f:   /* TODO: SS3 */
   2235 	case 0x91:   /* TODO: PU1 */
   2236 	case 0x92:   /* TODO: PU2 */
   2237 	case 0x93:   /* TODO: STS */
   2238 	case 0x94:   /* TODO: CCH */
   2239 	case 0x95:   /* TODO: MW */
   2240 	case 0x96:   /* TODO: SPA */
   2241 	case 0x97:   /* TODO: EPA */
   2242 	case 0x98:   /* TODO: SOS */
   2243 	case 0x99:   /* TODO: SGCI */
   2244 		break;
   2245 	case 0x9a:   /* DECID -- Identify Terminal */
   2246 		ttywrite(vtiden, strlen(vtiden), 0);
   2247 		break;
   2248 	case 0x9b:   /* TODO: CSI */
   2249 	case 0x9c:   /* TODO: ST */
   2250 		break;
   2251 	case 0x90:   /* DCS -- Device Control String */
   2252 	case 0x9d:   /* OSC -- Operating System Command */
   2253 	case 0x9e:   /* PM -- Privacy Message */
   2254 	case 0x9f:   /* APC -- Application Program Command */
   2255 		tstrsequence(ascii);
   2256 		return;
   2257 	}
   2258 	/* only CAN, SUB, \a and C1 chars interrupt a sequence */
   2259 	term.esc &= ~(ESC_STR_END|ESC_STR);
   2260 }
   2261 
   2262 /*
   2263  * returns 1 when the sequence is finished and it hasn't to read
   2264  * more characters for this sequence, otherwise 0
   2265  */
   2266 int
   2267 eschandle(uchar ascii)
   2268 {
   2269 	switch (ascii) {
   2270 	case '[':
   2271 		term.esc |= ESC_CSI;
   2272 		return 0;
   2273 	case '#':
   2274 		term.esc |= ESC_TEST;
   2275 		return 0;
   2276 	case '%':
   2277 		term.esc |= ESC_UTF8;
   2278 		return 0;
   2279 	case 'P': /* DCS -- Device Control String */
   2280 	case '_': /* APC -- Application Program Command */
   2281 	case '^': /* PM -- Privacy Message */
   2282 	case ']': /* OSC -- Operating System Command */
   2283 	case 'k': /* old title set compatibility */
   2284 		tstrsequence(ascii);
   2285 		return 0;
   2286 	case 'n': /* LS2 -- Locking shift 2 */
   2287 	case 'o': /* LS3 -- Locking shift 3 */
   2288 		term.charset = 2 + (ascii - 'n');
   2289 		break;
   2290 	case '(': /* GZD4 -- set primary charset G0 */
   2291 	case ')': /* G1D4 -- set secondary charset G1 */
   2292 	case '*': /* G2D4 -- set tertiary charset G2 */
   2293 	case '+': /* G3D4 -- set quaternary charset G3 */
   2294 		term.icharset = ascii - '(';
   2295 		term.esc |= ESC_ALTCHARSET;
   2296 		return 0;
   2297 	case 'D': /* IND -- Linefeed */
   2298 		if (term.c.y == term.bot) {
   2299 			tscrollup(term.top, 1);
   2300 		} else {
   2301 			tmoveto(term.c.x, term.c.y+1);
   2302 		}
   2303 		break;
   2304 	case 'E': /* NEL -- Next line */
   2305 		tnewline(1); /* always go to first col */
   2306 		break;
   2307 	case 'H': /* HTS -- Horizontal tab stop */
   2308 		term.tabs[term.c.x] = 1;
   2309 		break;
   2310 	case 'M': /* RI -- Reverse index */
   2311 		if (term.c.y == term.top) {
   2312 			tscrolldown(term.top, 1);
   2313 		} else {
   2314 			tmoveto(term.c.x, term.c.y-1);
   2315 		}
   2316 		break;
   2317 	case 'Z': /* DECID -- Identify Terminal */
   2318 		ttywrite(vtiden, strlen(vtiden), 0);
   2319 		break;
   2320 	case 'c': /* RIS -- Reset to initial state */
   2321 		treset();
   2322 		resettitle();
   2323 		xloadcols();
   2324 		break;
   2325 	case '=': /* DECPAM -- Application keypad */
   2326 		xsetmode(1, MODE_APPKEYPAD);
   2327 		break;
   2328 	case '>': /* DECPNM -- Normal keypad */
   2329 		xsetmode(0, MODE_APPKEYPAD);
   2330 		break;
   2331 	case '7': /* DECSC -- Save Cursor */
   2332 		tcursor(CURSOR_SAVE);
   2333 		break;
   2334 	case '8': /* DECRC -- Restore Cursor */
   2335 		tcursor(CURSOR_LOAD);
   2336 		break;
   2337 	case '\\': /* ST -- String Terminator */
   2338 		if (term.esc & ESC_STR_END)
   2339 			strhandle();
   2340 		break;
   2341 	default:
   2342 		fprintf(stderr, "erresc: unknown sequence ESC 0x%02X '%c'\n",
   2343 			(uchar) ascii, isprint(ascii)? ascii:'.');
   2344 		break;
   2345 	}
   2346 	return 1;
   2347 }
   2348 
   2349 void
   2350 tputc(Rune u)
   2351 {
   2352 	char c[UTF_SIZ];
   2353 	int control;
   2354 	int width, len;
   2355 	Glyph *gp;
   2356 
   2357 	control = ISCONTROL(u);
   2358 	if (u < 127 || !IS_SET(MODE_UTF8)) {
   2359 		c[0] = u;
   2360 		width = len = 1;
   2361 	} else {
   2362 		len = utf8encode(u, c);
   2363 		if (!control && (width = wcwidth(u)) == -1)
   2364 			width = 1;
   2365 	}
   2366 
   2367 	if (IS_SET(MODE_PRINT))
   2368 		tprinter(c, len);
   2369 
   2370 	/*
   2371 	 * STR sequence must be checked before anything else
   2372 	 * because it uses all following characters until it
   2373 	 * receives a ESC, a SUB, a ST or any other C1 control
   2374 	 * character.
   2375 	 */
   2376 	if (term.esc & ESC_STR) {
   2377 		if (u == '\a' || u == 030 || u == 032 || u == 033 ||
   2378 		   ISCONTROLC1(u)) {
   2379 			term.esc &= ~(ESC_START|ESC_STR);
   2380 			term.esc |= ESC_STR_END;
   2381 			goto check_control_code;
   2382 		}
   2383 
   2384 		if (strescseq.len+len >= strescseq.siz) {
   2385 			/*
   2386 			 * Here is a bug in terminals. If the user never sends
   2387 			 * some code to stop the str or esc command, then st
   2388 			 * will stop responding. But this is better than
   2389 			 * silently failing with unknown characters. At least
   2390 			 * then users will report back.
   2391 			 *
   2392 			 * In the case users ever get fixed, here is the code:
   2393 			 */
   2394 			/*
   2395 			 * term.esc = 0;
   2396 			 * strhandle();
   2397 			 */
   2398 			if (strescseq.siz > (SIZE_MAX - UTF_SIZ) / 2)
   2399 				return;
   2400 			strescseq.siz *= 2;
   2401 			strescseq.buf = xrealloc(strescseq.buf, strescseq.siz);
   2402 		}
   2403 
   2404 		memmove(&strescseq.buf[strescseq.len], c, len);
   2405 		strescseq.len += len;
   2406 		return;
   2407 	}
   2408 
   2409 check_control_code:
   2410 	/*
   2411 	 * Actions of control codes must be performed as soon they arrive
   2412 	 * because they can be embedded inside a control sequence, and
   2413 	 * they must not cause conflicts with sequences.
   2414 	 */
   2415 	if (control) {
   2416 		tcontrolcode(u);
   2417 		/*
   2418 		 * control codes are not shown ever
   2419 		 */
   2420 		if (!term.esc)
   2421 			term.lastc = 0;
   2422 		return;
   2423 	} else if (term.esc & ESC_START) {
   2424 		if (term.esc & ESC_CSI) {
   2425 			csiescseq.buf[csiescseq.len++] = u;
   2426 			if (BETWEEN(u, 0x40, 0x7E)
   2427 					|| csiescseq.len >= \
   2428 					sizeof(csiescseq.buf)-1) {
   2429 				term.esc = 0;
   2430 				csiparse();
   2431 				csihandle();
   2432 			}
   2433 			return;
   2434 		} else if (term.esc & ESC_UTF8) {
   2435 			tdefutf8(u);
   2436 		} else if (term.esc & ESC_ALTCHARSET) {
   2437 			tdeftran(u);
   2438 		} else if (term.esc & ESC_TEST) {
   2439 			tdectest(u);
   2440 		} else {
   2441 			if (!eschandle(u))
   2442 				return;
   2443 			/* sequence already finished */
   2444 		}
   2445 		term.esc = 0;
   2446 		/*
   2447 		 * All characters which form part of a sequence are not
   2448 		 * printed
   2449 		 */
   2450 		return;
   2451 	}
   2452 	if (selected(term.c.x, term.c.y))
   2453 		selclear();
   2454 
   2455 	gp = &term.line[term.c.y][term.c.x];
   2456 	if (IS_SET(MODE_WRAP) && (term.c.state & CURSOR_WRAPNEXT)) {
   2457 		gp->mode |= ATTR_WRAP;
   2458 		tnewline(1);
   2459 		gp = &term.line[term.c.y][term.c.x];
   2460 	}
   2461 
   2462 	if (IS_SET(MODE_INSERT) && term.c.x+width < term.col)
   2463 		memmove(gp+width, gp, (term.col - term.c.x - width) * sizeof(Glyph));
   2464 
   2465 	if (term.c.x+width > term.col) {
   2466 		tnewline(1);
   2467 		gp = &term.line[term.c.y][term.c.x];
   2468 	}
   2469 
   2470 	tsetchar(u, &term.c.attr, term.c.x, term.c.y);
   2471 	term.lastc = u;
   2472 
   2473 	if (width == 2) {
   2474 		gp->mode |= ATTR_WIDE;
   2475 		if (term.c.x+1 < term.col) {
   2476 			if (gp[1].mode == ATTR_WIDE && term.c.x+2 < term.col) {
   2477 				gp[2].u = ' ';
   2478 				gp[2].mode &= ~ATTR_WDUMMY;
   2479 			}
   2480 			gp[1].u = '\0';
   2481 			gp[1].mode = ATTR_WDUMMY;
   2482 		}
   2483 	}
   2484 	if (term.c.x+width < term.col) {
   2485 		tmoveto(term.c.x+width, term.c.y);
   2486 	} else {
   2487 		term.c.state |= CURSOR_WRAPNEXT;
   2488 	}
   2489 }
   2490 
   2491 int
   2492 twrite(const char *buf, int buflen, int show_ctrl)
   2493 {
   2494 	int charsize;
   2495 	Rune u;
   2496 	int n;
   2497 
   2498 	for (n = 0; n < buflen; n += charsize) {
   2499 		if (IS_SET(MODE_UTF8)) {
   2500 			/* process a complete utf8 char */
   2501 			charsize = utf8decode(buf + n, &u, buflen - n);
   2502 			if (charsize == 0)
   2503 				break;
   2504 		} else {
   2505 			u = buf[n] & 0xFF;
   2506 			charsize = 1;
   2507 		}
   2508 		if (show_ctrl && ISCONTROL(u)) {
   2509 			if (u & 0x80) {
   2510 				u &= 0x7f;
   2511 				tputc('^');
   2512 				tputc('[');
   2513 			} else if (u != '\n' && u != '\r' && u != '\t') {
   2514 				u ^= 0x40;
   2515 				tputc('^');
   2516 			}
   2517 		}
   2518 		tputc(u);
   2519 	}
   2520 	return n;
   2521 }
   2522 
   2523 void
   2524 tresize(int col, int row)
   2525 {
   2526 	int i;
   2527 	int minrow = MIN(row, term.row);
   2528 	int mincol = MIN(col, term.col);
   2529 	int *bp;
   2530 	TCursor c;
   2531 
   2532 	if (col < 1 || row < 1) {
   2533 		fprintf(stderr,
   2534 		        "tresize: error resizing to %dx%d\n", col, row);
   2535 		return;
   2536 	}
   2537 
   2538 	/*
   2539 	 * slide screen to keep cursor where we expect it -
   2540 	 * tscrollup would work here, but we can optimize to
   2541 	 * memmove because we're freeing the earlier lines
   2542 	 */
   2543 	for (i = 0; i <= term.c.y - row; i++) {
   2544 		free(term.line[i]);
   2545 		free(term.alt[i]);
   2546 	}
   2547 	/* ensure that both src and dst are not NULL */
   2548 	if (i > 0) {
   2549 		memmove(term.line, term.line + i, row * sizeof(Line));
   2550 		memmove(term.alt, term.alt + i, row * sizeof(Line));
   2551 	}
   2552 	for (i += row; i < term.row; i++) {
   2553 		free(term.line[i]);
   2554 		free(term.alt[i]);
   2555 	}
   2556 
   2557 	/* resize to new height */
   2558 	term.line = xrealloc(term.line, row * sizeof(Line));
   2559 	term.alt  = xrealloc(term.alt,  row * sizeof(Line));
   2560 	term.dirty = xrealloc(term.dirty, row * sizeof(*term.dirty));
   2561 	term.tabs = xrealloc(term.tabs, col * sizeof(*term.tabs));
   2562 
   2563 	/* resize each row to new width, zero-pad if needed */
   2564 	for (i = 0; i < minrow; i++) {
   2565 		term.line[i] = xrealloc(term.line[i], col * sizeof(Glyph));
   2566 		term.alt[i]  = xrealloc(term.alt[i],  col * sizeof(Glyph));
   2567 	}
   2568 
   2569 	/* allocate any new rows */
   2570 	for (/* i = minrow */; i < row; i++) {
   2571 		term.line[i] = xmalloc(col * sizeof(Glyph));
   2572 		term.alt[i] = xmalloc(col * sizeof(Glyph));
   2573 	}
   2574 	if (col > term.col) {
   2575 		bp = term.tabs + term.col;
   2576 
   2577 		memset(bp, 0, sizeof(*term.tabs) * (col - term.col));
   2578 		while (--bp > term.tabs && !*bp)
   2579 			/* nothing */ ;
   2580 		for (bp += tabspaces; bp < term.tabs + col; bp += tabspaces)
   2581 			*bp = 1;
   2582 	}
   2583 	/* update terminal size */
   2584 	term.col = col;
   2585 	term.row = row;
   2586 	/* reset scrolling region */
   2587 	tsetscroll(0, row-1);
   2588 	/* make use of the LIMIT in tmoveto */
   2589 	tmoveto(term.c.x, term.c.y);
   2590 	/* Clearing both screens (it makes dirty all lines) */
   2591 	c = term.c;
   2592 	for (i = 0; i < 2; i++) {
   2593 		if (mincol < col && 0 < minrow) {
   2594 			tclearregion(mincol, 0, col - 1, minrow - 1);
   2595 		}
   2596 		if (0 < col && minrow < row) {
   2597 			tclearregion(0, minrow, col - 1, row - 1);
   2598 		}
   2599 		tswapscreen();
   2600 		tcursor(CURSOR_LOAD);
   2601 	}
   2602 	term.c = c;
   2603 }
   2604 
   2605 void
   2606 resettitle(void)
   2607 {
   2608 	xsettitle(NULL);
   2609 }
   2610 
   2611 void
   2612 drawregion(int x1, int y1, int x2, int y2)
   2613 {
   2614 	int y;
   2615 
   2616 	for (y = y1; y < y2; y++) {
   2617 		if (!term.dirty[y])
   2618 			continue;
   2619 
   2620 		term.dirty[y] = 0;
   2621 		xdrawline(term.line[y], x1, y, x2);
   2622 	}
   2623 }
   2624 
   2625 void
   2626 draw(void)
   2627 {
   2628 	int cx = term.c.x, ocx = term.ocx, ocy = term.ocy;
   2629 
   2630 	if (!xstartdraw())
   2631 		return;
   2632 
   2633 	/* adjust cursor position */
   2634 	LIMIT(term.ocx, 0, term.col-1);
   2635 	LIMIT(term.ocy, 0, term.row-1);
   2636 	if (term.line[term.ocy][term.ocx].mode & ATTR_WDUMMY)
   2637 		term.ocx--;
   2638 	if (term.line[term.c.y][cx].mode & ATTR_WDUMMY)
   2639 		cx--;
   2640 
   2641 	drawregion(0, 0, term.col, term.row);
   2642 	xdrawcursor(cx, term.c.y, term.line[term.c.y][cx],
   2643 			term.ocx, term.ocy, term.line[term.ocy][term.ocx]);
   2644 	term.ocx = cx;
   2645 	term.ocy = term.c.y;
   2646 	xfinishdraw();
   2647 	if (ocx != term.ocx || ocy != term.ocy)
   2648 		xximspot(term.ocx, term.ocy);
   2649 }
   2650 
   2651 void
   2652 redraw(void)
   2653 {
   2654 	tfulldirt();
   2655 	draw();
   2656 }