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