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