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