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