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