?  search:
summary | log | graphiclog1 | graphiclog2 | refs | edit | fork

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