term.c

   1 #include <ctype.h>
   2 #include <errno.h>
   3 #include <fcntl.h>
   4 #include <poll.h>
   5 #include <stdlib.h>
   6 #include <stdio.h>
   7 #include <string.h>
   8 #include <sys/types.h>
   9 #include <sys/ioctl.h>
  10 #include <termios.h>
  11 #include <unistd.h>
  12 #include "conf.h"
  13 #include "fbpad.h"
  14
  15 #define MODE_CURSOR             0x01
  16 #define MODE_WRAP               0x02
  17 #define MODE_ORIGIN             0x04
  18 #define MODE_AUTOCR             0x08
  19 #define ATTR_BOLD               0x10
  20 #define ATTR_ITALIC             0x20
  21 #define ATTR_REV                0x40
  22 #define ATTR_ALL                (ATTR_BOLD | ATTR_ITALIC | ATTR_REV)
  23 #define MODE_INSERT             0x100
  24 #define MODE_WRAPREADY          0x200
  25
  26 #define LIMIT(n, a, b)          ((n) < (a) ? (a) : ((n) > (b) ? (b) : (n)))
  27 #define BIT_SET(i, b, val)      ((val) ? ((i) | (b)) : ((i) & ~(b)))
  28 #define OFFSET(r, c)            ((r) * pad_cols() + (c))
  29
  30 static struct term *term;
  31 static int *screen;
  32 static int *fgs, *bgs;
  33 static int *dirty;
  34 static int lazy;
  35 static int row, col;
  36 static int fg, bg;
  37 static int top, bot;
  38 static int mode;
  39 static int visible;
  40
  41 static unsigned int clr16[16] = {
  42         COLOR0, COLOR1, COLOR2, COLOR3, COLOR4, COLOR5, COLOR6, COLOR7,
  43         COLOR8, COLOR9, COLORA, COLORB, COLORC, COLORD, COLORE, COLORF,
  44 };
  45
  46 static int clrmap(int c)
  47 {
  48         int g = (c - 232) * 10 + 8;
  49         if (c < 16) {
  50                 return clr16[c];
  51         }
  52         if (c < 232) {
  53                 int ri = (c - 16) / 36 ;
  54                 int gi = (c - 16) % 36 / 6;
  55                 int bi = (c - 16) % 6;
  56                 int rc = ri ? (ri * 40 + 55) : 0;
  57                 int gc = gi ? (gi * 40 + 55) : 0;
  58                 int bc = bi ? (bi * 40 + 55) : 0;
  59                 return (rc << 16) | (gc << 8) | bc;
  60         }
  61         return (g << 16) | (g << 8) | g;
  62 }
  63
  64 /* low level drawing and lazy updating */
  65
  66 static int fgcolor(void)
  67 {
  68         int c = mode & ATTR_REV ? bg : fg;
  69         if (mode & ATTR_BOLD)
  70                 c |= FN_B;
  71         if (mode & ATTR_ITALIC)
  72                 c |= FN_I;
  73         return c;
  74 }
  75
  76 static int bgcolor(void)
  77 {
  78         return mode & ATTR_REV ? fg : bg;
  79 }
  80
  81 /* assumes visible && !lazy */
  82 static void _draw_pos(int r, int c, int cursor)
  83 {
  84         int rev = cursor && mode & MODE_CURSOR;
  85         int i = OFFSET(r, c);
  86         int fg = rev ? bgs[i] : fgs[i];
  87         int bg = rev ? fgs[i] : bgs[i];
  88         pad_put(screen[i], r, c, fg, bg);
  89 }
  90
  91 /* assumes visible && !lazy */
  92 static void _draw_row(int r)
  93 {
  94         int cbg, cch;           /* current background and character */
  95         int fbg, fsc = -1;      /* filling background and start column */
  96         int i;
  97         /* call pad_fill() only once for blank columns with identical backgrounds */
  98         for (i = 0; i < pad_cols(); i++) {
  99                 cbg = bgs[OFFSET(r, i)];
 100                 cch = screen[OFFSET(r, i)] ? screen[OFFSET(r, i)] : ' ';
 101                 if (fsc >= 0 && (cbg != fbg || cch != ' ')) {
 102                         pad_fill(r, r + 1, fsc, i, fbg & FN_C);
 103                         fsc = -1;
 104                 }
 105                 if (cch != ' ') {
 106                         _draw_pos(r, i, 0);
 107                 } else if (fsc < 0) {
 108                         fsc = i;
 109                         fbg = cbg;
 110                 }
 111         }
 112         pad_fill(r, r + 1, fsc >= 0 ? fsc : pad_cols(), -1, cbg & FN_C);
 113 }
 114
 115 static int candraw(int sr, int er)
 116 {
 117         int i;
 118         if (lazy)
 119                 for (i = sr; i < er; i++)
 120                         dirty[i] = 1;
 121         return visible && !lazy;
 122 }
 123
 124 static void draw_rows(int sr, int er)
 125 {
 126         int i;
 127         if (candraw(sr, er))
 128                 for (i = sr; i < er; i++)
 129                         _draw_row(i);
 130 }
 131
 132 static void draw_cols(int r, int sc, int ec)
 133 {
 134         int i;
 135         if (candraw(r, r + 1))
 136                 for (i = sc; i < ec; i++)
 137                         _draw_pos(r, i, 0);
 138 }
 139
 140 static void draw_char(int ch, int r, int c)
 141 {
 142         int i = OFFSET(r, c);
 143         screen[i] = ch;
 144         fgs[i] = fgcolor();
 145         bgs[i] = bgcolor();
 146         if (candraw(r, r + 1))
 147                 _draw_pos(r, c, 0);
 148 }
 149
 150 static void draw_cursor(int put)
 151 {
 152         if (candraw(row, row + 1))
 153                 _draw_pos(row, col, put);
 154 }
 155
 156 static void lazy_start(void)
 157 {
 158         memset(dirty, 0, pad_rows() * sizeof(*dirty));
 159         lazy = 1;
 160 }
 161
 162 static void lazy_flush(void)
 163 {
 164         int i;
 165         if (!visible || !lazy)
 166                 return;
 167         for (i = 0; i < pad_rows(); i++)
 168                 if (dirty[i])
 169                         _draw_row(i);
 170         if (dirty[row])
 171                 _draw_pos(row, col, 1);
 172         lazy = 0;
 173         term->hpos = 0;
 174 }
 175
 176 static void screen_reset(int i, int n)
 177 {
 178         int c;
 179         candraw(i / pad_cols(), (i + n) / pad_cols() + 1);
 180         memset(screen + i, 0, n * sizeof(*screen));
 181         for (c = 0; c < n; c++)
 182                 fgs[i + c] = fg;
 183         for (c = 0; c < n; c++)
 184                 bgs[i + c] = bg;
 185 }
 186
 187 static void screen_move(int dst, int src, int n)
 188 {
 189         int srow = (MIN(src, dst) + (n > 0 ? 0 : n)) / pad_cols();
 190         int drow = (MAX(src, dst) + (n > 0 ? n : 0)) / pad_cols() + 1;
 191         candraw(srow, drow);
 192         memmove(screen + dst, screen + src, n * sizeof(*screen));
 193         memmove(fgs + dst, fgs + src, n * sizeof(*fgs));
 194         memmove(bgs + dst, bgs + src, n * sizeof(*bgs));
 195 }
 196
 197 /* terminal input buffering */
 198
 199 #define PTYLEN                  (1 << 16)
 200
 201 static char ptybuf[PTYLEN];             /* always emptied in term_read() */
 202 static int ptylen;                      /* buffer length */
 203 static int ptycur;                      /* current offset */
 204
 205 static int waitpty(int us)
 206 {
 207         struct pollfd ufds[1];
 208         ufds[0].fd = term->fd;
 209         ufds[0].events = POLLIN;
 210         return poll(ufds, 1, us) <= 0;
 211 }
 212
 213 static int readpty(void)
 214 {
 215         int nr;
 216         if (ptycur < ptylen)
 217                 return (unsigned char) ptybuf[ptycur++];
 218         if (!term->fd)
 219                 return -1;
 220         ptylen = 0;
 221         while ((nr = read(term->fd, ptybuf + ptylen, PTYLEN - ptylen)) > 0)
 222                 ptylen += nr;
 223         if (!ptylen && errno == EAGAIN && !waitpty(100))
 224                 ptylen = read(term->fd, ptybuf, PTYLEN);
 225         ptycur = 1;
 226         return ptylen > 0 ? (unsigned char) ptybuf[0] : -1;
 227 }
 228
 229 /* term interface functions */
 230
 231 void term_send(int c)
 232 {
 233         char b = c;
 234         if (term->fd)
 235                 write(term->fd, &b, 1);
 236 }
 237
 238 static void term_sendstr(char *s)
 239 {
 240         if (term->fd)
 241                 write(term->fd, s, strlen(s));
 242 }
 243
 244 static void term_blank(void)
 245 {
 246         screen_reset(0, pad_rows() * pad_cols());
 247         if (visible)
 248                 pad_fill(0, -1, 0, -1, bgcolor() & FN_C);
 249 }
 250
 251 static void ctlseq(void);
 252 void term_read(void)
 253 {
 254         ctlseq();
 255         while (ptycur < ptylen) {
 256                 if (visible && !lazy && ptylen - ptycur > 15)
 257                         lazy_start();
 258                 ctlseq();
 259         }
 260         lazy_flush();
 261 }
 262
 263 static void term_reset(void)
 264 {
 265         row = col = 0;
 266         top = 0;
 267         bot = pad_rows();
 268         mode = MODE_CURSOR | MODE_WRAP;
 269         fg = FGCOLOR;
 270         bg = BGCOLOR;
 271         term_blank();
 272 }
 273
 274 static int _openpty(int *master, int *slave)
 275 {
 276         int unlock = 0;
 277         int ptyno = 0;
 278         char name[20];
 279         if ((*master = open("/dev/ptmx", O_RDWR)) == -1)
 280                 return -1;
 281         if (ioctl(*master, TIOCSPTLCK, &unlock) == -1)
 282                 return -1;
 283         if (ioctl(*master, TIOCGPTN, &ptyno) == -1)
 284                 return -1;
 285         sprintf(name, "/dev/pts/%d", ptyno);
 286         *slave = open(name, O_RDWR | O_NOCTTY);
 287         return 0;
 288 }
 289
 290 static void _login(int fd)
 291 {
 292         struct winsize winp;
 293         winp.ws_col = pad_cols();
 294         winp.ws_row = pad_rows();
 295         winp.ws_xpixel = 0;
 296         winp.ws_ypixel = 0;
 297         setsid();
 298         ioctl(fd, TIOCSCTTY, NULL);
 299         ioctl(fd, TIOCSWINSZ, &winp);
 300         dup2(fd, 0);
 301         dup2(fd, 1);
 302         dup2(fd, 2);
 303         if (fd > 2)
 304                 close(fd);
 305 }
 306
 307 #define MAXENV          (1 << 8)
 308
 309 static void envcpy(char **d, char **s)
 310 {
 311         while (*s)
 312                 *d++ = *s++;
 313         *d = NULL;
 314 }
 315
 316 static void execvep(char *cmd, char **argv, char **envp)
 317 {
 318         char path[512];
 319         char *p = getenv("PATH");
 320         execve(cmd, argv, envp);
 321         while (*p) {
 322                 char *s = path;
 323                 while (*p && *p != ':')
 324                         *s++ = *p++;
 325                 *s++ = '/';
 326                 strcpy(s, cmd);
 327                 execve(path, argv, envp);
 328                 while (*p == ':')
 329                         p++;
 330         }
 331 }
 332
 333 extern char **environ;
 334 void term_exec(char **args)
 335 {
 336         int master, slave;
 337         memset(term, 0, sizeof(*term));
 338         if (_openpty(&master, &slave) == -1)
 339                 return;
 340         if ((term->pid = fork()) == -1)
 341                 return;
 342         if (!term->pid) {
 343                 char *envp[MAXENV] = {"TERM=linux"};
 344                 envcpy(envp + 1, environ);
 345                 _login(slave);
 346                 close(master);
 347                 execvep(args[0], args, envp);
 348                 exit(1);
 349         }
 350         close(slave);
 351         term->fd = master;
 352         fcntl(term->fd, F_SETFD, fcntl(term->fd, F_GETFD) | FD_CLOEXEC);
 353         fcntl(term->fd, F_SETFL, fcntl(term->fd, F_GETFL) | O_NONBLOCK);
 354         term_reset();
 355         memset(term->hist, 0, sizeof(term->hist));
 356 }
 357
 358 static void misc_save(struct term_state *state)
 359 {
 360         state->row = row;
 361         state->col = col;
 362         state->fg = fg;
 363         state->bg = bg;
 364         state->mode = mode;
 365 }
 366
 367 static void misc_load(struct term_state *state)
 368 {
 369         row = state->row;
 370         col = state->col;
 371         fg = state->fg;
 372         bg = state->bg;
 373         mode = state->mode;
 374 }
 375
 376 void term_save(struct term *term)
 377 {
 378         visible = 0;
 379         if (!lazy)
 380                 lazy_start();
 381         misc_save(&term->cur);
 382         term->top = top;
 383         term->bot = bot;
 384         term->lazy = lazy;
 385 }
 386
 387 /* redraw the screen; if all is zero, update changed lines only */
 388 void term_redraw(int all)
 389 {
 390         if (term->fd) {
 391                 if (all) {
 392                         pad_fill(pad_rows(), -1, 0, -1, BGCOLOR);
 393                         lazy_start();
 394                         memset(dirty, 1, pad_rows() * sizeof(*dirty));
 395                 }
 396                 if (all || !term->hpos)
 397                         lazy_flush();
 398         } else {
 399                 if (all)
 400                         pad_fill(0, -1, 0, -1, 0);
 401         }
 402 }
 403
 404 void term_load(struct term *t, int flags)
 405 {
 406         term = t;
 407         misc_load(&term->cur);
 408         screen = term->screen;
 409         fgs = term->fgs;
 410         bgs = term->bgs;
 411         visible = flags;
 412         top = term->top;
 413         bot = term->bot;
 414         lazy = term->lazy;
 415         dirty = term->dirty;
 416 }
 417
 418 void term_end(void)
 419 {
 420         if (term->fd)
 421                 close(term->fd);
 422         memset(term, 0, sizeof(*term));
 423         term_load(term, visible);
 424         if (visible)
 425                 term_redraw(1);
 426 }
 427
 428 static int writeutf8(char *dst, int c)
 429 {
 430         char *d = dst;
 431         int l;
 432         if (c > 0xffff) {
 433                 *d++ = 0xf0 | (c >> 18);
 434                 l = 3;
 435         } else if (c > 0x7ff) {
 436                 *d++ = 0xe0 | (c >> 12);
 437                 l = 2;
 438         } else if (c > 0x7f) {
 439                 *d++ = 0xc0 | (c >> 6);
 440                 l = 1;
 441         } else {
 442                 *d++ = c > 0 ? c : ' ';
 443                 l = 0;
 444         }
 445         while (l--)
 446                 *d++ = 0x80 | ((c >> (l * 6)) & 0x3f);
 447         return d - dst;
 448 }
 449
 450 void term_screenshot(void)
 451 {
 452         char buf[1 << 11];
 453         int fd = open(SCRSHOT, O_CREAT | O_TRUNC | O_WRONLY, 0600);
 454         int i, j;
 455         for (i = 0; i < pad_rows(); i++) {
 456                 char *s = buf;
 457                 for (j = 0; j < pad_cols(); j++)
 458                         if (~screen[OFFSET(i, j)] & DWCHAR)
 459                                 s += writeutf8(s, screen[OFFSET(i, j)]);
 460                 *s++ = '\n';
 461                 write(fd, buf, s - buf);
 462         }
 463         close(fd);
 464 }
 465
 466 /* high-level drawing functions */
 467
 468 static void empty_rows(int sr, int er)
 469 {
 470         screen_reset(OFFSET(sr, 0), (er - sr) * pad_cols());
 471 }
 472
 473 static void blank_rows(int sr, int er)
 474 {
 475         empty_rows(sr, er);
 476         draw_rows(sr, er);
 477         draw_cursor(1);
 478 }
 479
 480 #define HISTROW(pos)    (term->hist + ((term->hrow + NHIST - (pos)) % NHIST) * pad_cols())
 481
 482 static void scrl_rows(int nr)
 483 {
 484         int i;
 485         for (i = 0; i < nr; i++) {
 486                 memcpy(HISTROW(0), screen + i * pad_cols(),
 487                                 pad_cols() * sizeof(screen[0]));
 488                 term->hrow = (term->hrow + 1) % NHIST;
 489         }
 490 }
 491
 492 void term_scrl(int scrl)
 493 {
 494         int i, j;
 495         int hpos = LIMIT(term->hpos + scrl, 0, NHIST);
 496         term->hpos = hpos;
 497         if (!hpos) {
 498                 lazy_flush();
 499                 return;
 500         }
 501         lazy_start();
 502         memset(dirty, 1, pad_rows() * sizeof(*dirty));
 503         for (i = 0; i < pad_rows(); i++) {
 504                 int off = (i - hpos) * pad_cols();
 505                 int *_scr = i < hpos ? HISTROW(hpos - i) : term->screen + off;
 506                 int *_fgs = i < hpos ? NULL : term->fgs + off;
 507                 int *_bgs = i < hpos ? NULL : term->bgs + off;
 508                 for (j = 0; j < pad_cols(); j++)
 509                         pad_put(_scr[j], i, j, _fgs ? _fgs[j] : BGCOLOR,
 510                                                 _bgs ? _bgs[j] : FGCOLOR);
 511         }
 512 }
 513
 514 static void scroll_screen(int sr, int nr, int n)
 515 {
 516         draw_cursor(0);
 517         if (sr + n == 0)
 518                 scrl_rows(sr);
 519         screen_move(OFFSET(sr + n, 0), OFFSET(sr, 0), nr * pad_cols());
 520         if (n > 0)
 521                 empty_rows(sr, sr + n);
 522         else
 523                 empty_rows(sr + nr + n, sr + nr);
 524         draw_rows(MIN(sr, sr + n), MAX(sr + nr, sr + nr + n));
 525         draw_cursor(1);
 526 }
 527
 528 static void insert_lines(int n)
 529 {
 530         int sr = MAX(top, row);
 531         int nr = bot - row - n;
 532         if (nr > 0)
 533                 scroll_screen(sr, nr, n);
 534 }
 535
 536 static void delete_lines(int n)
 537 {
 538         int r = MAX(top, row);
 539         int sr = r + n;
 540         int nr = bot - r - n;
 541         if (nr > 0)
 542                 scroll_screen(sr, nr, -n);
 543 }
 544
 545 static int origin(void)
 546 {
 547         return mode & MODE_ORIGIN;
 548 }
 549
 550 static void move_cursor(int r, int c)
 551 {
 552         int t, b;
 553         draw_cursor(0);
 554         t = origin() ? top : 0;
 555         b = origin() ? bot : pad_rows();
 556         row = LIMIT(r, t, b - 1);
 557         col = LIMIT(c, 0, pad_cols() - 1);
 558         draw_cursor(1);
 559         mode = BIT_SET(mode, MODE_WRAPREADY, 0);
 560 }
 561
 562 static void set_region(int t, int b)
 563 {
 564         top = LIMIT(t - 1, 0, pad_rows() - 1);
 565         bot = LIMIT(b ? b : pad_rows(), top + 1, pad_rows());
 566         if (origin())
 567                 move_cursor(top, 0);
 568 }
 569
 570 static void setattr(int m)
 571 {
 572         switch (m) {
 573         case 0:
 574                 fg = FGCOLOR;
 575                 bg = BGCOLOR;
 576                 mode &= ~ATTR_ALL;
 577                 break;
 578         case 1:
 579                 mode |= ATTR_BOLD;
 580                 break;
 581         case 3:
 582                 mode |= ATTR_ITALIC;
 583                 break;
 584         case 7:
 585                 mode |= ATTR_REV;
 586                 break;
 587         case 22:
 588                 mode &= ~ATTR_BOLD;
 589                 break;
 590         case 23:
 591                 mode &= ~ATTR_ITALIC;
 592                 break;
 593         case 27:
 594                 mode &= ~ATTR_REV;
 595                 break;
 596         default:
 597                 if ((m / 10) == 3)
 598                         fg = m > 37 ? FGCOLOR : clrmap(m - 30);
 599                 if ((m / 10) == 4)
 600                         bg = m > 47 ? BGCOLOR : clrmap(m - 40);
 601                 if ((m / 10) == 9)
 602                         fg = clrmap(8 + m - 90);
 603                 if ((m / 10) == 10)
 604                         bg = clrmap(8 + m - 100);
 605         }
 606 }
 607
 608 static void kill_chars(int sc, int ec)
 609 {
 610         int i;
 611         for (i = sc; i < ec; i++)
 612                 draw_char(0, row, i);
 613         draw_cursor(1);
 614 }
 615
 616 static void move_chars(int sc, int nc, int n)
 617 {
 618         draw_cursor(0);
 619         screen_move(OFFSET(row, sc + n), OFFSET(row, sc), nc);
 620         if (n > 0)
 621                 screen_reset(OFFSET(row, sc), n);
 622         else
 623                 screen_reset(OFFSET(row, pad_cols() + n), -n);
 624         draw_cols(row, MIN(sc, sc + n), pad_cols());
 625         draw_cursor(1);
 626 }
 627
 628 static void delete_chars(int n)
 629 {
 630         int sc = col + n;
 631         int nc = pad_cols() - sc;
 632         move_chars(sc, nc, -n);
 633 }
 634
 635 static void insert_chars(int n)
 636 {
 637         int nc = pad_cols() - col - n;
 638         move_chars(col, nc, n);
 639 }
 640
 641 static void advance(int dr, int dc, int scrl)
 642 {
 643         int r = row + dr;
 644         int c = col + dc;
 645         if (dr && r >= bot && scrl) {
 646                 int n = bot - r - 1;
 647                 int nr = (bot - top) + n;
 648                 scroll_screen(top + -n, nr, n);
 649         }
 650         if (dr && r < top && scrl) {
 651                 int n = top - r;
 652                 int nr = (bot - top) - n;
 653                 scroll_screen(top, nr, n);
 654         }
 655         r = dr ? LIMIT(r, top, bot - 1) : r;
 656         c = LIMIT(c, 0, pad_cols() - 1);
 657         move_cursor(r, c);
 658 }
 659
 660 static void insertchar(int c)
 661 {
 662         if (mode & MODE_WRAPREADY)
 663                 advance(1, -col, 1);
 664         if (mode & MODE_INSERT)
 665                 insert_chars(1);
 666         draw_char(c, row, col);
 667         if (col == pad_cols() - 1)
 668                 mode = BIT_SET(mode, MODE_WRAPREADY, 1);
 669         else
 670                 advance(0, 1, 1);
 671 }
 672
 673
 674 /* partial vt102 implementation */
 675
 676 static void escseq(void);
 677 static void escseq_cs(void);
 678 static void escseq_g0(void);
 679 static void escseq_g1(void);
 680 static void escseq_g2(void);
 681 static void escseq_g3(void);
 682 static void csiseq(void);
 683 static void csiseq_da(int c);
 684 static void csiseq_dsr(int c);
 685 static void modeseq(int c, int set);
 686
 687 /* comments taken from: http://www.ivarch.com/programs/termvt102.shtml */
 688
 689 static int readutf8(int c)
 690 {
 691         int result;
 692         int l = 1;
 693         if (~c & 0xc0)
 694                 return c;
 695         while (l < 6 && c & (0x40 >> l))
 696                 l++;
 697         result = (0x3f >> l) & c;
 698         while (l--)
 699                 result = (result << 6) | (readpty() & 0x3f);
 700         return result;
 701 }
 702
 703 #define unknown(ctl, c)
 704
 705 /* control sequences */
 706 static void ctlseq(void)
 707 {
 708         int c = readpty();
 709         switch (c) {
 710         case 0x09:      /* HT           horizontal tab to next tab stop */
 711                 advance(0, 8 - col % 8, 0);
 712                 break;
 713         case 0x0a:      /* LF           line feed */
 714         case 0x0b:      /* VT           line feed */
 715         case 0x0c:      /* FF           line feed */
 716                 advance(1, (mode & MODE_AUTOCR) ? -col : 0, 1);
 717                 break;
 718         case 0x08:      /* BS           backspace one column */
 719                 advance(0, -1, 0);
 720                 break;
 721         case 0x1b:      /* ESC          start escape sequence */
 722                 escseq();
 723                 break;
 724         case 0x0d:      /* CR           carriage return */
 725                 advance(0, -col, 0);
 726                 break;
 727         case 0x9b:      /* CSI          equivalent to ESC [ */
 728                 csiseq();
 729                 break;
 730         case 0x00:      /* NUL          ignored */
 731         case 0x07:      /* BEL          beep */
 732         case 0x7f:      /* DEL          ignored */
 733                 break;
 734         case 0x05:      /* ENQ          trigger answerback message */
 735         case 0x0e:      /* SO           activate G1 character set & newline */
 736         case 0x0f:      /* SI           activate G0 character set */
 737         case 0x11:      /* XON          resume transmission */
 738         case 0x13:      /* XOFF         stop transmission, ignore characters */
 739         case 0x18:      /* CAN          interrupt escape sequence */
 740         case 0x1a:      /* SUB          interrupt escape sequence */
 741                 unknown("ctlseq", c);
 742                 break;
 743         default:
 744                 c = readutf8(c);
 745                 if (isdw(c) && col + 1 == pad_cols() && ~mode & MODE_WRAPREADY)
 746                         insertchar(0);
 747                 if (!iszw(c))
 748                         insertchar(c);
 749                 if (isdw(c))
 750                         insertchar(c | DWCHAR);
 751                 break;
 752         }
 753 }
 754
 755 #define ESCM(c)         (((c) & 0xf0) == 0x20)
 756 #define ESCF(c)         ((c) > 0x30 && (c) < 0x7f)
 757
 758 /* escape sequences */
 759 static void escseq(void)
 760 {
 761         int c = readpty();
 762         while (ESCM(c))
 763                 c = readpty();
 764         switch (c) {
 765         case '[':       /* CSI          control sequence introducer */
 766                 csiseq();
 767                 break;
 768         case '%':       /* CS...        escseq_cs table */
 769                 escseq_cs();
 770                 break;
 771         case '(':       /* G0...        escseq_g0 table */
 772                 escseq_g0();
 773                 break;
 774         case ')':       /* G1...        escseq_g1 table */
 775                 escseq_g1();
 776                 break;
 777         case '*':       /* G2...        escseq_g2 table */
 778                 escseq_g2();
 779                 break;
 780         case '+':       /* G3...        escseq_g3 table */
 781                 escseq_g3();
 782                 break;
 783         case '7':       /* DECSC        save state (position, charset, attributes) */
 784                 misc_save(&term->sav);
 785                 break;
 786         case '8':       /* DECRC        restore most recently saved state */
 787                 misc_load(&term->sav);
 788                 break;
 789         case 'M':       /* RI           reverse line feed */
 790                 advance(-1, 0, 1);
 791                 break;
 792         case 'D':       /* IND          line feed */
 793                 advance(1, 0, 1);
 794                 break;
 795         case 'E':       /* NEL          newline */
 796                 advance(1, -col, 1);
 797                 break;
 798         case 'c':       /* RIS          reset */
 799                 term_reset();
 800                 break;
 801         case 'H':       /* HTS          set tab stop at current column */
 802         case 'Z':       /* DECID        DEC private ID; return ESC [ ? 6 c (VT102) */
 803         case '#':       /* DECALN       ("#8") DEC alignment test - fill screen with E's */
 804         case '>':       /* DECPNM       set numeric keypad mode */
 805         case '=':       /* DECPAM       set application keypad mode */
 806         case 'N':       /* SS2          select G2 charset for next char only */
 807         case 'O':       /* SS3          select G3 charset for next char only */
 808         case 'P':       /* DCS          device control string (ended by ST) */
 809         case 'X':       /* SOS          start of string */
 810         case '^':       /* PM           privacy message (ended by ST) */
 811         case '_':       /* APC          application program command (ended by ST) */
 812         case '\\':      /* ST           string terminator */
 813         case 'n':       /* LS2          invoke G2 charset */
 814         case 'o':       /* LS3          invoke G3 charset */
 815         case '|':       /* LS3R         invoke G3 charset as GR */
 816         case '}':       /* LS2R         invoke G2 charset as GR */
 817         case '~':       /* LS1R         invoke G1 charset as GR */
 818         case ']':       /* OSC          operating system command */
 819         case 'g':       /* BEL          alternate BEL */
 820         default:
 821                 unknown("escseq", c);
 822                 break;
 823         }
 824 }
 825
 826 static void escseq_cs(void)
 827 {
 828         int c = readpty();
 829         switch (c) {
 830         case '@':       /* CSDFL        select default charset (ISO646/8859-1) */
 831         case 'G':       /* CSUTF8       select UTF-8 */
 832         case '8':       /* CSUTF8       select UTF-8 (obsolete) */
 833         default:
 834                 unknown("escseq_cs", c);
 835                 break;
 836         }
 837 }
 838
 839 static void escseq_g0(void)
 840 {
 841         int c = readpty();
 842         switch (c) {
 843         case '8':       /* G0DFL        G0 charset = default mapping (ISO8859-1) */
 844         case '0':       /* G0GFX        G0 charset = VT100 graphics mapping */
 845         case 'U':       /* G0ROM        G0 charset = null mapping (straight to ROM) */
 846         case 'K':       /* G0USR        G0 charset = user defined mapping */
 847         case 'B':       /* G0TXT        G0 charset = ASCII mapping */
 848         default:
 849                 unknown("escseq_g0", c);
 850                 break;
 851         }
 852 }
 853
 854 static void escseq_g1(void)
 855 {
 856         int c = readpty();
 857         switch (c) {
 858         case '8':       /* G1DFL        G1 charset = default mapping (ISO8859-1) */
 859         case '0':       /* G1GFX        G1 charset = VT100 graphics mapping */
 860         case 'U':       /* G1ROM        G1 charset = null mapping (straight to ROM) */
 861         case 'K':       /* G1USR        G1 charset = user defined mapping */
 862         case 'B':       /* G1TXT        G1 charset = ASCII mapping */
 863         default:
 864                 unknown("escseq_g1", c);
 865                 break;
 866         }
 867 }
 868
 869 static void escseq_g2(void)
 870 {
 871         int c = readpty();
 872         switch (c) {
 873         case '8':       /* G2DFL        G2 charset = default mapping (ISO8859-1) */
 874         case '0':       /* G2GFX        G2 charset = VT100 graphics mapping */
 875         case 'U':       /* G2ROM        G2 charset = null mapping (straight to ROM) */
 876         case 'K':       /* G2USR        G2 charset = user defined mapping */
 877         default:
 878                 unknown("escseq_g2", c);
 879                 break;
 880         }
 881 }
 882
 883 static void escseq_g3(void)
 884 {
 885         int c = readpty();
 886         switch (c) {
 887         case '8':       /* G3DFL        G3 charset = default mapping (ISO8859-1) */
 888         case '0':       /* G3GFX        G3 charset = VT100 graphics mapping */
 889         case 'U':       /* G3ROM        G3 charset = null mapping (straight to ROM) */
 890         case 'K':       /* G3USR        G3 charset = user defined mapping */
 891         default:
 892                 unknown("escseq_g3", c);
 893                 break;
 894         }
 895 }
 896
 897 static int absrow(int r)
 898 {
 899         return origin() ? top + r : r;
 900 }
 901
 902 #define CSIP(c)                 (((c) & 0xf0) == 0x30)
 903 #define CSII(c)                 (((c) & 0xf0) == 0x20)
 904 #define CSIF(c)                 ((c) >= 0x40 && (c) < 0x80)
 905
 906 #define MAXCSIARGS      32
 907 /* ECMA-48 CSI sequences */
 908 static void csiseq(void)
 909 {
 910         int args[MAXCSIARGS + 8] = {0};
 911         int i;
 912         int n = 0;
 913         int c = readpty();
 914         int priv = 0;
 915
 916         if (strchr("<=>?", c)) {
 917                 priv = c;
 918                 c = readpty();
 919         }
 920         while (CSIP(c)) {
 921                 int arg = 0;
 922                 while (isdigit(c)) {
 923                         arg = arg * 10 + (c - '0');
 924                         c = readpty();
 925                 }
 926                 if (CSIP(c))
 927                         c = readpty();
 928                 if (n < MAXCSIARGS)
 929                         args[n++] = arg;
 930         }
 931         while (CSII(c))
 932                 c = readpty();
 933         switch (c) {
 934         case 'H':       /* CUP          move cursor to row, column */
 935         case 'f':       /* HVP          move cursor to row, column */
 936                 move_cursor(absrow(MAX(0, args[0] - 1)), MAX(0, args[1] - 1));
 937                 break;
 938         case 'J':       /* ED           erase display */
 939                 switch (args[0]) {
 940                 case 0:
 941                         kill_chars(col, pad_cols());
 942                         blank_rows(row + 1, pad_rows());
 943                         break;
 944                 case 1:
 945                         kill_chars(0, col + 1);
 946                         blank_rows(0, row - 1);
 947                         break;
 948                 case 2:
 949                         term_blank();
 950                         break;
 951                 }
 952                 break;
 953         case 'A':       /* CUU          move cursor up */
 954                 advance(-MAX(1, args[0]), 0, 0);
 955                 break;
 956         case 'e':       /* VPR          move cursor down */
 957         case 'B':       /* CUD          move cursor down */
 958                 advance(MAX(1, args[0]), 0, 0);
 959                 break;
 960         case 'a':       /* HPR          move cursor right */
 961         case 'C':       /* CUF          move cursor right */
 962                 advance(0, MAX(1, args[0]), 0);
 963                 break;
 964         case 'D':       /* CUB          move cursor left */
 965                 advance(0, -MAX(1, args[0]), 0);
 966                 break;
 967         case 'K':       /* EL           erase line */
 968                 switch (args[0]) {
 969                 case 0:
 970                         kill_chars(col, pad_cols());
 971                         break;
 972                 case 1:
 973                         kill_chars(0, col + 1);
 974                         break;
 975                 case 2:
 976                         kill_chars(0, pad_cols());
 977                         break;
 978                 }
 979                 break;
 980         case 'L':       /* IL           insert blank lines */
 981                 if (row >= top && row < bot)
 982                         insert_lines(MAX(1, args[0]));
 983                 break;
 984         case 'M':       /* DL           delete lines */
 985                 if (row >= top && row < bot)
 986                         delete_lines(MAX(1, args[0]));
 987                 break;
 988         case 'd':       /* VPA          move to row (current column) */
 989                 move_cursor(absrow(MAX(1, args[0]) - 1), col);
 990                 break;
 991         case 'm':       /* SGR          set graphic rendition */
 992                 if (!n)
 993                         setattr(0);
 994                 for (i = 0; i < n; i++) {
 995                         if (args[i] == 38 && args[i + 1] == 2) {
 996                                 fg = (args[i + 2] << 16) |
 997                                         (args[i + 3] << 8) | args[i + 4];
 998                                 i += 5;
 999                                 continue;
1000                         }
1001                         if (args[i] == 38) {
1002                                 fg = clrmap(args[i + 2]);
1003                                 i += 2;
1004                                 continue;
1005                         }
1006                         if (args[i] == 48 && args[i + 1] == 2) {
1007                                 bg = (args[i + 2] << 16) |
1008                                         (args[i + 3] << 8) | args[i + 4];
1009                                 i += 5;
1010                                 continue;
1011                         }
1012                         if (args[i] == 48) {
1013                                 bg = clrmap(args[i + 2]);
1014                                 i += 2;
1015                                 continue;
1016                         }
1017                         setattr(args[i]);
1018                 }
1019                 break;
1020         case 'r':       /* DECSTBM      set scrolling region to (top, bottom) rows */
1021                 set_region(args[0], args[1]);
1022                 break;
1023         case 'c':       /* DA           return ESC [ ? 6 c (VT102) */
1024                 csiseq_da(priv == '?' ? args[0] | 0x80 : args[0]);
1025                 break;
1026         case 'h':       /* SM           set mode */
1027                 for (i = 0; i < n; i++)
1028                         modeseq(priv == '?' ? args[i] | 0x80 : args[i], 1);
1029                 draw_cursor(1);
1030                 break;
1031         case 'l':       /* RM           reset mode */
1032                 for (i = 0; i < n; i++)
1033                         modeseq(priv == '?' ? args[i] | 0x80 : args[i], 0);
1034                 draw_cursor(1);
1035                 break;
1036         case 'P':       /* DCH          delete characters on current line */
1037                 delete_chars(LIMIT(args[0], 1, pad_cols() - col));
1038                 break;
1039         case '@':       /* ICH          insert blank characters */
1040                 insert_chars(LIMIT(args[0], 1, pad_cols() - col));
1041                 break;
1042         case 'n':       /* DSR          device status report */
1043                 csiseq_dsr(args[0]);
1044                 break;
1045         case 'G':       /* CHA          move cursor to column in current row */
1046                 advance(0, MAX(0, args[0] - 1) - col, 0);
1047                 break;
1048         case 'X':       /* ECH          erase characters on current line */
1049                 kill_chars(col, MIN(col + MAX(1, args[0]), pad_cols()));
1050                 break;
1051         case '[':       /* IGN          ignored control sequence */
1052         case 'E':       /* CNL          move cursor down and to column 1 */
1053         case 'F':       /* CPL          move cursor up and to column 1 */
1054         case 'g':       /* TBC          clear tab stop (CSI 3 g = clear all stops) */
1055         case 'q':       /* DECLL        set keyboard LEDs */
1056         case 's':       /* CUPSV        save cursor position */
1057         case 'u':       /* CUPRS        restore cursor position */
1058         case '`':       /* HPA          move cursor to column in current row */
1059         default:
1060                 unknown("csiseq", c);
1061                 break;
1062         }
1063 }
1064
1065 static void csiseq_da(int c)
1066 {
1067         switch (c) {
1068         case 0x00:
1069                 term_sendstr("\x1b[?6c");
1070                 break;
1071         default:
1072                 /* we don't care much about cursor shape */
1073                 /* printf("csiseq_da <0x%x>\n", c); */
1074                 break;
1075         }
1076 }
1077
1078 static void csiseq_dsr(int c)
1079 {
1080         char status[1 << 5];
1081         switch (c) {
1082         case 0x05:
1083                 term_sendstr("\x1b[0n");
1084                 break;
1085         case 0x06:
1086                 sprintf(status, "\x1b[%d;%dR",
1087                          (origin() ? row - top : row) + 1, col + 1);
1088                 term_sendstr(status);
1089                 break;
1090         default:
1091                 unknown("csiseq_dsr", c);
1092                 break;
1093         }
1094 }
1095
1096 /* ANSI/DEC specified modes for SM/RM ANSI Specified Modes */
1097 static void modeseq(int c, int set)
1098 {
1099         switch (c) {
1100         case 0x87:      /* DECAWM       Auto Wrap */
1101                 mode = BIT_SET(mode, MODE_WRAP, set);
1102                 break;
1103         case 0x99:      /* DECTCEM      Cursor on (set); Cursor off (reset) */
1104                 mode = BIT_SET(mode, MODE_CURSOR, set);
1105                 break;
1106         case 0x86:      /* DECOM        Sets relative coordinates (set); Sets absolute coordinates (reset) */
1107                 mode = BIT_SET(mode, MODE_ORIGIN, set);
1108                 break;
1109         case 0x14:      /* LNM          Line Feed / New Line Mode */
1110                 mode = BIT_SET(mode, MODE_AUTOCR, set);
1111                 break;
1112         case 0x04:      /* IRM          insertion/replacement mode (always reset) */
1113                 mode = BIT_SET(mode, MODE_INSERT, set);
1114                 break;
1115         case 0x00:      /* IGN          Error (Ignored) */
1116         case 0x01:      /* GATM         guarded-area transfer mode (ignored) */
1117         case 0x02:      /* KAM          keyboard action mode (always reset) */
1118         case 0x03:      /* CRM          control representation mode (always reset) */
1119         case 0x05:      /* SRTM         status-reporting transfer mode */
1120         case 0x06:      /* ERM          erasure mode (always set) */
1121         case 0x07:      /* VEM          vertical editing mode (ignored) */
1122         case 0x0a:      /* HEM          horizontal editing mode */
1123         case 0x0b:      /* PUM          positioning unit mode */
1124         case 0x0c:      /* SRM          send/receive mode (echo on/off) */
1125         case 0x0d:      /* FEAM         format effector action mode */
1126         case 0x0e:      /* FETM         format effector transfer mode */
1127         case 0x0f:      /* MATM         multiple area transfer mode */
1128         case 0x10:      /* TTM          transfer termination mode */
1129         case 0x11:      /* SATM         selected area transfer mode */
1130         case 0x12:      /* TSM          tabulation stop mode */
1131         case 0x13:      /* EBM          editing boundary mode */
1132 /* DEC Private Modes: "?NUM" -> (NUM | 0x80) */
1133         case 0x80:      /* IGN          Error (Ignored) */
1134         case 0x81:      /* DECCKM       Cursorkeys application (set); Cursorkeys normal (reset) */
1135         case 0x82:      /* DECANM       ANSI (set); VT52 (reset) */
1136         case 0x83:      /* DECCOLM      132 columns (set); 80 columns (reset) */
1137         case 0x84:      /* DECSCLM      Jump scroll (set); Smooth scroll (reset) */
1138         case 0x85:      /* DECSCNM      Reverse screen (set); Normal screen (reset) */
1139         case 0x88:      /* DECARM       Auto Repeat */
1140         case 0x89:      /* DECINLM      Interlace */
1141         case 0x92:      /* DECPFF       Send FF to printer after print screen (set); No char after PS (reset) */
1142         case 0x93:      /* DECPEX       Print screen: prints full screen (set); prints scroll region (reset) */
1143         default:
1144                 unknown("modeseq", c);
1145                 break;
1146         }
1147 }