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