st.c

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