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