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