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