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