term.c

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