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