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