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