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