?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
term: enable switching signals using the second argument of term_exec()
[fbpad.git] / term.c
blob2349577d5317b8158e91a7ab98276ba70c2daf5f
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 int l;
573 if (c > 0xffff) {
574 *d++ = 0xf0 | (c >> 18);
575 l = 3;
576 } else if (c > 0x7ff) {
577 *d++ = 0xe0 | (c >> 12);
578 l = 2;
579 } else if (c > 0x7f) {
580 *d++ = 0xc0 | (c >> 6);
581 l = 1;
582 } else {
583 *d++ = c > 0 ? c : ' ';
584 l = 0;
585 }
586 while (l--)
587 *d++ = 0x80 | ((c >> (l * 6)) & 0x3f);
588 return d - dst;
589 }
590
591 void term_screenshot(void)
592 {
593 char buf[1 << 11];
594 int fd = open(SCRSHOT, O_CREAT | O_TRUNC | O_WRONLY, 0600);
595 int i, j;
596 for (i = 0; i < pad_rows(); i++) {
597 char *s = buf;
598 for (j = 0; j < pad_cols(); j++)
599 if (~screen[OFFSET(i, j)] & DWCHAR)
600 s += writeutf8(s, screen[OFFSET(i, j)]);
601 *s++ = '\n';
602 write(fd, buf, s - buf);
603 }
604 close(fd);
605 }
606
607 /* high-level drawing functions */
608
609 static void empty_rows(int sr, int er)
610 {
611 screen_reset(OFFSET(sr, 0), (er - sr) * pad_cols());
612 }
613
614 static void blank_rows(int sr, int er)
615 {
616 empty_rows(sr, er);
617 draw_rows(sr, er);
618 draw_cursor(1);
619 }
620
621 #define HISTROW(pos) (term->hist + ((term->hrow + NHIST - (pos)) % NHIST) * pad_cols())
622
623 static void scrl_rows(int nr)
624 {
625 int i;
626 for (i = 0; i < nr; i++) {
627 memcpy(HISTROW(0), screen + i * pad_cols(),
628 pad_cols() * sizeof(screen[0]));
629 term->hrow = (term->hrow + 1) % NHIST;
630 }
631 }
632
633 void term_scrl(int scrl)
634 {
635 int i, j;
636 int hpos = LIMIT(term->hpos + scrl, 0, NHIST);
637 term->hpos = hpos;
638 if (!hpos) {
639 lazy_flush();
640 return;
641 }
642 lazy_start();
643 memset(dirty, 1, pad_rows() * sizeof(*dirty));
644 for (i = 0; i < pad_rows(); i++) {
645 int off = (i - hpos) * pad_cols();
646 int *_scr = i < hpos ? HISTROW(hpos - i) : term->screen + off;
647 int *_fgs = i < hpos ? NULL : term->fgs + off;
648 int *_bgs = i < hpos ? NULL : term->bgs + off;
649 for (j = 0; j < pad_cols(); j++)
650 pad_put(_scr[j], i, j, _fgs ? _fgs[j] : BGCOLOR,
651 _bgs ? _bgs[j] : FGCOLOR);
652 }
653 }
654
655 static void scroll_screen(int sr, int nr, int n)
656 {
657 draw_cursor(0);
658 if (sr + n == 0)
659 scrl_rows(sr);
660 screen_move(OFFSET(sr + n, 0), OFFSET(sr, 0), nr * pad_cols());
661 if (n > 0)
662 empty_rows(sr, sr + n);
663 else
664 empty_rows(sr + nr + n, sr + nr);
665 draw_rows(MIN(sr, sr + n), MAX(sr + nr, sr + nr + n));
666 draw_cursor(1);
667 }
668
669 static void insert_lines(int n)
670 {
671 int sr = MAX(top, row);
672 int nr = bot - row - n;
673 if (nr > 0)
674 scroll_screen(sr, nr, n);
675 }
676
677 static void delete_lines(int n)
678 {
679 int r = MAX(top, row);
680 int sr = r + n;
681 int nr = bot - r - n;
682 if (nr > 0)
683 scroll_screen(sr, nr, -n);
684 }
685
686 static int origin(void)
687 {
688 return mode & MODE_ORIGIN;
689 }
690
691 static void move_cursor(int r, int c)
692 {
693 int t, b;
694 draw_cursor(0);
695 t = origin() ? top : 0;
696 b = origin() ? bot : pad_rows();
697 row = LIMIT(r, t, b - 1);
698 col = LIMIT(c, 0, pad_cols() - 1);
699 draw_cursor(1);
700 mode = BIT_SET(mode, MODE_WRAPREADY, 0);
701 }
702
703 static void set_region(int t, int b)
704 {
705 top = LIMIT(t - 1, 0, pad_rows() - 1);
706 bot = LIMIT(b ? b : pad_rows(), top + 1, pad_rows());
707 if (origin())
708 move_cursor(top, 0);
709 }
710
711 static void setattr(int m)
712 {
713 if (!m || (m / 10) == 3)
714 mode |= MODE_CLR8;
715 switch (m) {
716 case 0:
717 fg = FGCOLOR;
718 bg = BGCOLOR;
719 mode &= ~ATTR_ALL;
720 break;
721 case 1:
722 mode |= ATTR_BOLD;
723 break;
724 case 3:
725 mode |= ATTR_ITALIC;
726 break;
727 case 7:
728 mode |= ATTR_REV;
729 break;
730 case 22:
731 mode &= ~ATTR_BOLD;
732 break;
733 case 23:
734 mode &= ~ATTR_ITALIC;
735 break;
736 case 27:
737 mode &= ~ATTR_REV;
738 break;
739 default:
740 if ((m / 10) == 3)
741 fg = m > 37 ? FGCOLOR : clrmap(m - 30);
742 if ((m / 10) == 4)
743 bg = m > 47 ? BGCOLOR : clrmap(m - 40);
744 if ((m / 10) == 9)
745 fg = clrmap(8 + m - 90);
746 if ((m / 10) == 10)
747 bg = clrmap(8 + m - 100);
748 }
749 }
750
751 static void kill_chars(int sc, int ec)
752 {
753 int i;
754 for (i = sc; i < ec; i++)
755 draw_char(0, row, i);
756 draw_cursor(1);
757 }
758
759 static void move_chars(int sc, int nc, int n)
760 {
761 draw_cursor(0);
762 screen_move(OFFSET(row, sc + n), OFFSET(row, sc), nc);
763 if (n > 0)
764 screen_reset(OFFSET(row, sc), n);
765 else
766 screen_reset(OFFSET(row, pad_cols() + n), -n);
767 draw_cols(row, MIN(sc, sc + n), pad_cols());
768 draw_cursor(1);
769 }
770
771 static void delete_chars(int n)
772 {
773 int sc = col + n;
774 int nc = pad_cols() - sc;
775 move_chars(sc, nc, -n);
776 }
777
778 static void insert_chars(int n)
779 {
780 int nc = pad_cols() - col - n;
781 move_chars(col, nc, n);
782 }
783
784 static void advance(int dr, int dc, int scrl)
785 {
786 int r = row + dr;
787 int c = col + dc;
788 if (dr && r >= bot && scrl) {
789 int n = bot - r - 1;
790 int nr = (bot - top) + n;
791 if (nr > 0)
792 scroll_screen(top + -n, nr, n);
793 }
794 if (dr && r < top && scrl) {
795 int n = top - r;
796 int nr = (bot - top) - n;
797 if (nr > 0)
798 scroll_screen(top, nr, n);
799 }
800 r = dr ? LIMIT(r, top, bot - 1) : r;
801 c = LIMIT(c, 0, pad_cols() - 1);
802 move_cursor(r, c);
803 }
804
805 static void insertchar(int c)
806 {
807 if (mode & MODE_WRAPREADY)
808 advance(1, -col, 1);
809 if (mode & MODE_INSERT)
810 insert_chars(1);
811 draw_char(c, row, col);
812 if (col == pad_cols() - 1)
813 mode = BIT_SET(mode, MODE_WRAPREADY, 1);
814 else
815 advance(0, 1, 1);
816 }
817
818
819 /* partial vt102 implementation */
820
821 static void escseq(void);
822 static void escseq_cs(void);
823 static void escseq_g0(void);
824 static void escseq_g1(void);
825 static void escseq_g2(void);
826 static void escseq_g3(void);
827 static void csiseq(void);
828 static void csiseq_da(int c);
829 static void csiseq_dsr(int c);
830 static void modeseq(int c, int set);
831
832 /* comments taken from: http://www.ivarch.com/programs/termvt102.shtml */
833
834 static int readutf8(int c)
835 {
836 int result;
837 int l = 1;
838 if (~c & 0xc0)
839 return c;
840 while (l < 6 && c & (0x40 >> l))
841 l++;
842 result = (0x3f >> l) & c;
843 while (l--)
844 result = (result << 6) | (readpty() & 0x3f);
845 return result;
846 }
847
848 #define unknown(ctl, c)
849
850 /* control sequences */
851 static void ctlseq(void)
852 {
853 int c = readpty();
854 switch (c) {
855 case 0x09: /* HT horizontal tab to next tab stop */
856 advance(0, 8 - col % 8, 0);
857 break;
858 case 0x0a: /* LF line feed */
859 case 0x0b: /* VT line feed */
860 case 0x0c: /* FF line feed */
861 advance(1, (mode & MODE_AUTOCR) ? -col : 0, 1);
862 break;
863 case 0x08: /* BS backspace one column */
864 advance(0, -1, 0);
865 break;
866 case 0x1b: /* ESC start escape sequence */
867 escseq();
868 break;
869 case 0x0d: /* CR carriage return */
870 advance(0, -col, 0);
871 break;
872 case 0x9b: /* CSI equivalent to ESC [ */
873 csiseq();
874 break;
875 case 0x00: /* NUL ignored */
876 case 0x07: /* BEL beep */
877 case 0x7f: /* DEL ignored */
878 break;
879 case 0x05: /* ENQ trigger answerback message */
880 case 0x0e: /* SO activate G1 character set & newline */
881 case 0x0f: /* SI activate G0 character set */
882 case 0x11: /* XON resume transmission */
883 case 0x13: /* XOFF stop transmission, ignore characters */
884 case 0x18: /* CAN interrupt escape sequence */
885 case 0x1a: /* SUB interrupt escape sequence */
886 unknown("ctlseq", c);
887 break;
888 default:
889 c = readutf8(c);
890 if (isdw(c) && col + 1 == pad_cols() && ~mode & MODE_WRAPREADY)
891 insertchar(0);
892 if (!iszw(c))
893 insertchar(c);
894 if (isdw(c))
895 insertchar(c | DWCHAR);
896 break;
897 }
898 }
899
900 #define ESCM(c) (((c) & 0xf0) == 0x20)
901 #define ESCF(c) ((c) > 0x30 && (c) < 0x7f)
902
903 /* escape sequences */
904 static void escseq(void)
905 {
906 int c = readpty();
907 while (ESCM(c))
908 c = readpty();
909 switch (c) {
910 case '[': /* CSI control sequence introducer */
911 csiseq();
912 break;
913 case '%': /* CS... escseq_cs table */
914 escseq_cs();
915 break;
916 case '(': /* G0... escseq_g0 table */
917 escseq_g0();
918 break;
919 case ')': /* G1... escseq_g1 table */
920 escseq_g1();
921 break;
922 case '*': /* G2... escseq_g2 table */
923 escseq_g2();
924 break;
925 case '+': /* G3... escseq_g3 table */
926 escseq_g3();
927 break;
928 case '7': /* DECSC save state (position, charset, attributes) */
929 misc_save(&term->sav);
930 break;
931 case '8': /* DECRC restore most recently saved state */
932 misc_load(&term->sav);
933 break;
934 case 'M': /* RI reverse line feed */
935 advance(-1, 0, 1);
936 break;
937 case 'D': /* IND line feed */
938 advance(1, 0, 1);
939 break;
940 case 'E': /* NEL newline */
941 advance(1, -col, 1);
942 break;
943 case 'c': /* RIS reset */
944 term_reset();
945 break;
946 case 'H': /* HTS set tab stop at current column */
947 case 'Z': /* DECID DEC private ID; return ESC [ ? 6 c (VT102) */
948 case '#': /* DECALN ("#8") DEC alignment test - fill screen with E's */
949 case '>': /* DECPNM set numeric keypad mode */
950 case '=': /* DECPAM set application keypad mode */
951 case 'N': /* SS2 select G2 charset for next char only */
952 case 'O': /* SS3 select G3 charset for next char only */
953 case 'P': /* DCS device control string (ended by ST) */
954 case 'X': /* SOS start of string */
955 case '^': /* PM privacy message (ended by ST) */
956 case '_': /* APC application program command (ended by ST) */
957 case '\\': /* ST string terminator */
958 case 'n': /* LS2 invoke G2 charset */
959 case 'o': /* LS3 invoke G3 charset */
960 case '|': /* LS3R invoke G3 charset as GR */
961 case '}': /* LS2R invoke G2 charset as GR */
962 case '~': /* LS1R invoke G1 charset as GR */
963 case ']': /* OSC operating system command */
964 case 'g': /* BEL alternate BEL */
965 default:
966 unknown("escseq", c);
967 break;
968 }
969 }
970
971 static void escseq_cs(void)
972 {
973 int c = readpty();
974 switch (c) {
975 case '@': /* CSDFL select default charset (ISO646/8859-1) */
976 case 'G': /* CSUTF8 select UTF-8 */
977 case '8': /* CSUTF8 select UTF-8 (obsolete) */
978 default:
979 unknown("escseq_cs", c);
980 break;
981 }
982 }
983
984 static void escseq_g0(void)
985 {
986 int c = readpty();
987 switch (c) {
988 case '8': /* G0DFL G0 charset = default mapping (ISO8859-1) */
989 case '0': /* G0GFX G0 charset = VT100 graphics mapping */
990 case 'U': /* G0ROM G0 charset = null mapping (straight to ROM) */
991 case 'K': /* G0USR G0 charset = user defined mapping */
992 case 'B': /* G0TXT G0 charset = ASCII mapping */
993 default:
994 unknown("escseq_g0", c);
995 break;
996 }
997 }
998
999 static void escseq_g1(void)
1000 {
1001 int c = readpty();
1002 switch (c) {
1003 case '8': /* G1DFL G1 charset = default mapping (ISO8859-1) */
1004 case '0': /* G1GFX G1 charset = VT100 graphics mapping */
1005 case 'U': /* G1ROM G1 charset = null mapping (straight to ROM) */
1006 case 'K': /* G1USR G1 charset = user defined mapping */
1007 case 'B': /* G1TXT G1 charset = ASCII mapping */
1008 default:
1009 unknown("escseq_g1", c);
1010 break;
1011 }
1012 }
1013
1014 static void escseq_g2(void)
1015 {
1016 int c = readpty();
1017 switch (c) {
1018 case '8': /* G2DFL G2 charset = default mapping (ISO8859-1) */
1019 case '0': /* G2GFX G2 charset = VT100 graphics mapping */
1020 case 'U': /* G2ROM G2 charset = null mapping (straight to ROM) */
1021 case 'K': /* G2USR G2 charset = user defined mapping */
1022 default:
1023 unknown("escseq_g2", c);
1024 break;
1025 }
1026 }
1027
1028 static void escseq_g3(void)
1029 {
1030 int c = readpty();
1031 switch (c) {
1032 case '8': /* G3DFL G3 charset = default mapping (ISO8859-1) */
1033 case '0': /* G3GFX G3 charset = VT100 graphics mapping */
1034 case 'U': /* G3ROM G3 charset = null mapping (straight to ROM) */
1035 case 'K': /* G3USR G3 charset = user defined mapping */
1036 default:
1037 unknown("escseq_g3", c);
1038 break;
1039 }
1040 }
1041
1042 static int absrow(int r)
1043 {
1044 return origin() ? top + r : r;
1045 }
1046
1047 #define CSIP(c) (((c) & 0xf0) == 0x30)
1048 #define CSII(c) (((c) & 0xf0) == 0x20)
1049 #define CSIF(c) ((c) >= 0x40 && (c) < 0x80)
1050
1051 #define MAXCSIARGS 32
1052 /* ECMA-48 CSI sequences */
1053 static void csiseq(void)
1054 {
1055 int args[MAXCSIARGS + 8] = {0};
1056 int i;
1057 int n = 0;
1058 int c = readpty();
1059 int priv = 0;
1060
1061 if (strchr("<=>?", c)) {
1062 priv = c;
1063 c = readpty();
1064 }
1065 while (CSIP(c)) {
1066 int arg = 0;
1067 while (isdigit(c)) {
1068 arg = arg * 10 + (c - '0');
1069 c = readpty();
1070 }
1071 if (CSIP(c))
1072 c = readpty();
1073 if (n < MAXCSIARGS)
1074 args[n++] = arg;
1075 }
1076 while (CSII(c))
1077 c = readpty();
1078 switch (c) {
1079 case 'H': /* CUP move cursor to row, column */
1080 case 'f': /* HVP move cursor to row, column */
1081 move_cursor(absrow(MAX(0, args[0] - 1)), MAX(0, args[1] - 1));
1082 break;
1083 case 'J': /* ED erase display */
1084 switch (args[0]) {
1085 case 0:
1086 kill_chars(col, pad_cols());
1087 blank_rows(row + 1, pad_rows());
1088 break;
1089 case 1:
1090 kill_chars(0, col + 1);
1091 blank_rows(0, row - 1);
1092 break;
1093 case 2:
1094 term_blank();
1095 break;
1096 }
1097 break;
1098 case 'A': /* CUU move cursor up */
1099 advance(-MAX(1, args[0]), 0, 0);
1100 break;
1101 case 'e': /* VPR move cursor down */
1102 case 'B': /* CUD move cursor down */
1103 advance(MAX(1, args[0]), 0, 0);
1104 break;
1105 case 'a': /* HPR move cursor right */
1106 case 'C': /* CUF move cursor right */
1107 advance(0, MAX(1, args[0]), 0);
1108 break;
1109 case 'D': /* CUB move cursor left */
1110 advance(0, -MAX(1, args[0]), 0);
1111 break;
1112 case 'K': /* EL erase line */
1113 switch (args[0]) {
1114 case 0:
1115 kill_chars(col, pad_cols());
1116 break;
1117 case 1:
1118 kill_chars(0, col + 1);
1119 break;
1120 case 2:
1121 kill_chars(0, pad_cols());
1122 break;
1123 }
1124 break;
1125 case 'L': /* IL insert blank lines */
1126 if (row >= top && row < bot)
1127 insert_lines(MAX(1, args[0]));
1128 break;
1129 case 'M': /* DL delete lines */
1130 if (row >= top && row < bot)
1131 delete_lines(MAX(1, args[0]));
1132 break;
1133 case 'S': /* SU scroll up */
1134 i = MAX(1, args[0]);
1135 scroll_screen(i, pad_rows() - i, -i);
1136 break;
1137 case 'T': /* SD scroll down */
1138 i = MAX(1, args[0]);
1139 scroll_screen(0, pad_rows() - i, i);
1140 break;
1141 case 'd': /* VPA move to row (current column) */
1142 move_cursor(absrow(MAX(1, args[0]) - 1), col);
1143 break;
1144 case 'm': /* SGR set graphic rendition */
1145 if (!n)
1146 setattr(0);
1147 for (i = 0; i < n; i++) {
1148 if (args[i] == 38 && args[i + 1] == 2) {
1149 mode &= ~MODE_CLR8;
1150 fg = (args[i + 2] << 16) |
1151 (args[i + 3] << 8) | args[i + 4];
1152 i += 5;
1153 continue;
1154 }
1155 if (args[i] == 38) {
1156 mode &= ~MODE_CLR8;
1157 fg = clrmap(args[i + 2]);
1158 i += 2;
1159 continue;
1160 }
1161 if (args[i] == 48 && args[i + 1] == 2) {
1162 bg = (args[i + 2] << 16) |
1163 (args[i + 3] << 8) | args[i + 4];
1164 i += 5;
1165 continue;
1166 }
1167 if (args[i] == 48) {
1168 bg = clrmap(args[i + 2]);
1169 i += 2;
1170 continue;
1171 }
1172 setattr(args[i]);
1173 }
1174 if (mode & MODE_CLR8 && mode & ATTR_BOLD && BRIGHTEN)
1175 for (i = 0; i < 8; i++)
1176 if (clr16[i] == fg)
1177 fg = clr16[8 + i];
1178 break;
1179 case 'r': /* DECSTBM set scrolling region to (top, bottom) rows */
1180 set_region(args[0], args[1]);
1181 break;
1182 case 'c': /* DA return ESC [ ? 6 c (VT102) */
1183 csiseq_da(priv == '?' ? args[0] | 0x80 : args[0]);
1184 break;
1185 case 'h': /* SM set mode */
1186 for (i = 0; i < n; i++)
1187 modeseq(priv == '?' ? args[i] | 0x80 : args[i], 1);
1188 draw_cursor(1);
1189 break;
1190 case 'l': /* RM reset mode */
1191 for (i = 0; i < n; i++)
1192 modeseq(priv == '?' ? args[i] | 0x80 : args[i], 0);
1193 draw_cursor(1);
1194 break;
1195 case 'P': /* DCH delete characters on current line */
1196 delete_chars(LIMIT(args[0], 1, pad_cols() - col));
1197 break;
1198 case '@': /* ICH insert blank characters */
1199 insert_chars(LIMIT(args[0], 1, pad_cols() - col));
1200 break;
1201 case 'n': /* DSR device status report */
1202 csiseq_dsr(args[0]);
1203 break;
1204 case 'G': /* CHA move cursor to column in current row */
1205 advance(0, MAX(0, args[0] - 1) - col, 0);
1206 break;
1207 case 'X': /* ECH erase characters on current line */
1208 kill_chars(col, MIN(col + MAX(1, args[0]), pad_cols()));
1209 break;
1210 case '[': /* IGN ignored control sequence */
1211 case 'E': /* CNL move cursor down and to column 1 */
1212 case 'F': /* CPL move cursor up and to column 1 */
1213 case 'g': /* TBC clear tab stop (CSI 3 g = clear all stops) */
1214 case 'q': /* DECLL set keyboard LEDs */
1215 case 's': /* CUPSV save cursor position */
1216 case 'u': /* CUPRS restore cursor position */
1217 case '`': /* HPA move cursor to column in current row */
1218 default:
1219 unknown("csiseq", c);
1220 break;
1221 }
1222 }
1223
1224 static void csiseq_da(int c)
1225 {
1226 switch (c) {
1227 case 0x00:
1228 term_sendstr("\x1b[?6c");
1229 break;
1230 default:
1231 /* we don't care much about cursor shape */
1232 /* printf("csiseq_da <0x%x>\n", c); */
1233 break;
1234 }
1235 }
1236
1237 static void csiseq_dsr(int c)
1238 {
1239 char status[1 << 5];
1240 switch (c) {
1241 case 0x05:
1242 term_sendstr("\x1b[0n");
1243 break;
1244 case 0x06:
1245 sprintf(status, "\x1b[%d;%dR",
1246 (origin() ? row - top : row) + 1, col + 1);
1247 term_sendstr(status);
1248 break;
1249 default:
1250 unknown("csiseq_dsr", c);
1251 break;
1252 }
1253 }
1254
1255 /* ANSI/DEC specified modes for SM/RM ANSI Specified Modes */
1256 static void modeseq(int c, int set)
1257 {
1258 switch (c) {
1259 case 0x87: /* DECAWM Auto Wrap */
1260 mode = BIT_SET(mode, MODE_WRAP, set);
1261 break;
1262 case 0x99: /* DECTCEM Cursor on (set); Cursor off (reset) */
1263 mode = BIT_SET(mode, MODE_CURSOR, set);
1264 break;
1265 case 0x86: /* DECOM Sets relative coordinates (set); Sets absolute coordinates (reset) */
1266 mode = BIT_SET(mode, MODE_ORIGIN, set);
1267 break;
1268 case 0x14: /* LNM Line Feed / New Line Mode */
1269 mode = BIT_SET(mode, MODE_AUTOCR, set);
1270 break;
1271 case 0x04: /* IRM insertion/replacement mode (always reset) */
1272 mode = BIT_SET(mode, MODE_INSERT, set);
1273 break;
1274 case 0x00: /* IGN error (ignored) */
1275 case 0x01: /* GATM guarded-area transfer mode (ignored) */
1276 case 0x02: /* KAM keyboard action mode (always reset) */
1277 case 0x03: /* CRM control representation mode (always reset) */
1278 case 0x05: /* SRTM status-reporting transfer mode */
1279 case 0x06: /* ERM erasure mode (always set) */
1280 case 0x07: /* VEM vertical editing mode (ignored) */
1281 case 0x08: /* BDSM bi-directional support mode */
1282 case 0x0a: /* HEM horizontal editing mode */
1283 case 0x0b: /* PUM positioning unit mode */
1284 case 0x0c: /* SRM send/receive mode (echo on/off) */
1285 case 0x0d: /* FEAM format effector action mode */
1286 case 0x0e: /* FETM format effector transfer mode */
1287 case 0x0f: /* MATM multiple area transfer mode */
1288 case 0x10: /* TTM transfer termination mode */
1289 case 0x11: /* SATM selected area transfer mode */
1290 case 0x12: /* TSM tabulation stop mode */
1291 case 0x13: /* EBM editing boundary mode */
1292 /* DEC Private Modes: "?NUM" -> (NUM | 0x80) */
1293 case 0x80: /* IGN error (ignored) */
1294 case 0x81: /* DECCKM cursorkeys application (set); cursorkeys normal (reset) */
1295 case 0x82: /* DECANM ANSI (set); VT52 (reset) */
1296 case 0x83: /* DECCOLM 132 columns (set); 80 columns (reset) */
1297 case 0x84: /* DECSCLM jump scroll (set); smooth scroll (reset) */
1298 case 0x85: /* DECSCNM reverse screen (set); normal screen (reset) */
1299 case 0x88: /* DECARM auto repeat */
1300 case 0x89: /* DECINLM interlace */
1301 case 0x92: /* DECPFF send FF to printer after print screen (set); no char after PS (reset) */
1302 case 0x93: /* DECPEX print screen: prints full screen (set); prints scroll region (reset) */
1303 default:
1304 unknown("modeseq", c);
1305 break;
1306 }
1307 }
A small linux framebuffer virtual terminal