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