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