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