st.c

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