term.c

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