st.c

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