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