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