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