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