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