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