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