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