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