Mercurial > nixos

comparison config/st/st.c @ 0:face7f4d84f7

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial commit
author Yasuri <yasuri@charliesmp.net>
date Mon, 28 Sep 2026 13:10:19 -0500
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:face7f4d84f7
1 /* See LICENSE for license details. */
2 #include <ctype.h>
3 #include <errno.h>
4 #include <fcntl.h>
5 #include <limits.h>
6 #include <pwd.h>
7 #include <stdarg.h>
8 #include <stdio.h>
9 #include <stdlib.h>
10 #include <string.h>
11 #include <signal.h>
12 #include <sys/ioctl.h>
13 #include <sys/select.h>
14 #include <sys/types.h>
15 #include <sys/wait.h>
16 #include <termios.h>
17 #include <unistd.h>
18 #include <wchar.h>
19
20 #include "st.h"
21 #include "win.h"
22
23 #if defined(__linux)
24 #include <pty.h>
25 #elif defined(__OpenBSD__) || defined(__NetBSD__) || defined(__APPLE__)
26 #include <util.h>
27 #elif defined(__FreeBSD__) || defined(__DragonFly__)
28 #include <libutil.h>
29 #endif
30
31 /* Arbitrary sizes */
32 #define UTF_INVALID 0xFFFD
33 #define UTF_SIZ 4
34 #define ESC_BUF_SIZ (128*UTF_SIZ)
35 #define ESC_ARG_SIZ 16
36 #define STR_BUF_SIZ ESC_BUF_SIZ
37 #define STR_ARG_SIZ ESC_ARG_SIZ
38
39 /* macros */
40 #define IS_SET(flag) ((term.mode & (flag)) != 0)
41 #define ISCONTROLC0(c) (BETWEEN(c, 0, 0x1f) || (c) == 0x7f)
42 #define ISCONTROLC1(c) (BETWEEN(c, 0x80, 0x9f))
43 #define ISCONTROL(c) (ISCONTROLC0(c) || ISCONTROLC1(c))
44 #define ISDELIM(u) (u && wcschr(worddelimiters, u))
45
46 enum term_mode {
47 MODE_WRAP = 1 << 0,
48 MODE_INSERT = 1 << 1,
49 MODE_ALTSCREEN = 1 << 2,
50 MODE_CRLF = 1 << 3,
51 MODE_ECHO = 1 << 4,
52 MODE_PRINT = 1 << 5,
53 MODE_UTF8 = 1 << 6,
54 };
55
56 enum cursor_movement {
57 CURSOR_SAVE,
58 CURSOR_LOAD
59 };
60
61 enum cursor_state {
62 CURSOR_DEFAULT = 0,
63 CURSOR_WRAPNEXT = 1,
64 CURSOR_ORIGIN = 2
65 };
66
67 enum charset {
68 CS_GRAPHIC0,
69 CS_GRAPHIC1,
70 CS_UK,
71 CS_USA,
72 CS_MULTI,
73 CS_GER,
74 CS_FIN
75 };
76
77 enum escape_state {
78 ESC_START = 1,
79 ESC_CSI = 2,
80 ESC_STR = 4, /* DCS, OSC, PM, APC */
81 ESC_ALTCHARSET = 8,
82 ESC_STR_END = 16, /* a final string was encountered */
83 ESC_TEST = 32, /* Enter in test mode */
84 ESC_UTF8 = 64,
85 };
86
87 typedef struct {
88 Glyph attr; /* current char attributes */
89 int x;
90 int y;
91 char state;
92 } TCursor;
93
94 typedef struct {
95 int mode;
96 int type;
97 int snap;
98 /*
99 * Selection variables:
100 * nb – normalized coordinates of the beginning of the selection
101 * ne – normalized coordinates of the end of the selection
102 * ob – original coordinates of the beginning of the selection
103 * oe – original coordinates of the end of the selection
104 */
105 struct {
106 int x, y;
107 } nb, ne, ob, oe;
108
109 int alt;
110 } Selection;
111
112 /* Internal representation of the screen */
113 typedef struct {
114 int row; /* nb row */
115 int col; /* nb col */
116 Line *line; /* screen */
117 Line *alt; /* alternate screen */
118 int *dirty; /* dirtyness of lines */
119 TCursor c; /* cursor */
120 int ocx; /* old cursor col */
121 int ocy; /* old cursor row */
122 int top; /* top scroll limit */
123 int bot; /* bottom scroll limit */
124 int mode; /* terminal mode flags */
125 int esc; /* escape state flags */
126 char trantbl[4]; /* charset table translation */
127 int charset; /* current charset */
128 int icharset; /* selected charset for sequence */
129 int *tabs;
130 Rune lastc; /* last printed char outside of sequence, 0 if control */
131 } Term;
132
133 /* CSI Escape sequence structs */
134 /* ESC '[' [[ [<priv>] <arg> [;]] <mode> [<mode>]] */
135 typedef struct {
136 char buf[ESC_BUF_SIZ]; /* raw string */
137 size_t len; /* raw string length */
138 char priv;
139 int arg[ESC_ARG_SIZ];
140 int narg; /* nb of args */
141 char mode[2];
142 } CSIEscape;
143
144 /* STR Escape sequence structs */
145 /* ESC type [[ [<priv>] <arg> [;]] <mode>] ESC '\' */
146 typedef struct {
147 char type; /* ESC type ... */
148 char *buf; /* allocated raw string */
149 size_t siz; /* allocation size */
150 size_t len; /* raw string length */
151 char *args[STR_ARG_SIZ];
152 int narg; /* nb of args */
153 } STREscape;
154
155 static void execsh(char *, char **);
156 static void stty(char **);
157 static void sigchld(int);
158 static void ttywriteraw(const char *, size_t);
159
160 static void csidump(void);
161 static void csihandle(void);
162 static void csiparse(void);
163 static void csireset(void);
164 static void osc_color_response(int, int, int);
165 static int eschandle(uchar);
166 static void strdump(void);
167 static void strhandle(void);
168 static void strparse(void);
169 static void strreset(void);
170
171 static void tprinter(char *, size_t);
172 static void tdumpsel(void);
173 static void tdumpline(int);
174 static void tdump(void);
175 static void tclearregion(int, int, int, int);
176 static void tcursor(int);
177 static void tdeletechar(int);
178 static void tdeleteline(int);
179 static void tinsertblank(int);
180 static void tinsertblankline(int);
181 static int tlinelen(int);
182 static void tmoveto(int, int);
183 static void tmoveato(int, int);
184 static void tnewline(int);
185 static void tputtab(int);
186 static void tputc(Rune);
187 static void treset(void);
188 static void tscrollup(int, int);
189 static void tscrolldown(int, int);
190 static void tsetattr(const int *, int);
191 static void tsetchar(Rune, const Glyph *, int, int);
192 static void tsetdirt(int, int);
193 static void tsetscroll(int, int);
194 static void tswapscreen(void);
195 static void tsetmode(int, int, const int *, int);
196 static int twrite(const char *, int, int);
197 static void tfulldirt(void);
198 static void tcontrolcode(uchar );
199 static void tdectest(char );
200 static void tdefutf8(char);
201 static int32_t tdefcolor(const int *, int *, int);
202 static void tdeftran(char);
203 static void tstrsequence(uchar);
204
205 static void drawregion(int, int, int, int);
206
207 static void selnormalize(void);
208 static void selscroll(int, int);
209 static void selsnap(int *, int *, int);
210
211 static size_t utf8decode(const char *, Rune *, size_t);
212 static Rune utf8decodebyte(char, size_t *);
213 static char utf8encodebyte(Rune, size_t);
214 static size_t utf8validate(Rune *, size_t);
215
216 static char *base64dec(const char *);
217 static char base64dec_getc(const char **);
218
219 static ssize_t xwrite(int, const char *, size_t);
220
221 /* Globals */
222 static Term term;
223 static Selection sel;
224 static CSIEscape csiescseq;
225 static STREscape strescseq;
226 static int iofd = 1;
227 static int cmdfd;
228 static pid_t pid;
229
230 static const uchar utfbyte[UTF_SIZ + 1] = {0x80, 0, 0xC0, 0xE0, 0xF0};
231 static const uchar utfmask[UTF_SIZ + 1] = {0xC0, 0x80, 0xE0, 0xF0, 0xF8};
232 static const Rune utfmin[UTF_SIZ + 1] = { 0, 0, 0x80, 0x800, 0x10000};
233 static const Rune utfmax[UTF_SIZ + 1] = {0x10FFFF, 0x7F, 0x7FF, 0xFFFF, 0x10FFFF};
234
235 ssize_t
236 xwrite(int fd, const char *s, size_t len)
237 {
238 size_t aux = len;
239 ssize_t r;
240
241 while (len > 0) {
242 r = write(fd, s, len);
243 if (r < 0)
244 return r;
245 len -= r;
246 s += r;
247 }
248
249 return aux;
250 }
251
252 void *
253 xmalloc(size_t len)
254 {
255 void *p;
256
257 if (!(p = malloc(len)))
258 die("malloc: %s\n", strerror(errno));
259
260 return p;
261 }
262
263 void *
264 xrealloc(void *p, size_t len)
265 {
266 if ((p = realloc(p, len)) == NULL)
267 die("realloc: %s\n", strerror(errno));
268
269 return p;
270 }
271
272 char *
273 xstrdup(const char *s)
274 {
275 char *p;
276
277 if ((p = strdup(s)) == NULL)
278 die("strdup: %s\n", strerror(errno));
279
280 return p;
281 }
282
283 size_t
284 utf8decode(const char *c, Rune *u, size_t clen)
285 {
286 size_t i, j, len, type;
287 Rune udecoded;
288
289 *u = UTF_INVALID;
290 if (!clen)
291 return 0;
292 udecoded = utf8decodebyte(c[0], &len);
293 if (!BETWEEN(len, 1, UTF_SIZ))
294 return 1;
295 for (i = 1, j = 1; i < clen && j < len; ++i, ++j) {
296 udecoded = (udecoded << 6) | utf8decodebyte(c[i], &type);
297 if (type != 0)
298 return j;
299 }
300 if (j < len)
301 return 0;
302 *u = udecoded;
303 utf8validate(u, len);
304
305 return len;
306 }
307
308 Rune
309 utf8decodebyte(char c, size_t *i)
310 {
311 for (*i = 0; *i < LEN(utfmask); ++(*i))
312 if (((uchar)c & utfmask[*i]) == utfbyte[*i])
313 return (uchar)c & ~utfmask[*i];
314
315 return 0;
316 }
317
318 size_t
319 utf8encode(Rune u, char *c)
320 {
321 size_t len, i;
322
323 len = utf8validate(&u, 0);
324 if (len > UTF_SIZ)
325 return 0;
326
327 for (i = len - 1; i != 0; --i) {
328 c[i] = utf8encodebyte(u, 0);
329 u >>= 6;
330 }
331 c[0] = utf8encodebyte(u, len);
332
333 return len;
334 }
335
336 char
337 utf8encodebyte(Rune u, size_t i)
338 {
339 return utfbyte[i] | (u & ~utfmask[i]);
340 }
341
342 size_t
343 utf8validate(Rune *u, size_t i)
344 {
345 if (!BETWEEN(*u, utfmin[i], utfmax[i]) || BETWEEN(*u, 0xD800, 0xDFFF))
346 *u = UTF_INVALID;
347 for (i = 1; *u > utfmax[i]; ++i)
348 ;
349
350 return i;
351 }
352
353 char
354 base64dec_getc(const char **src)
355 {
356 while (**src && !isprint((unsigned char)**src))
357 (*src)++;
358 return **src ? *((*src)++) : '='; /* emulate padding if string ends */
359 }
360
361 char *
362 base64dec(const char *src)
363 {
364 size_t in_len = strlen(src);
365 char *result, *dst;
366 static const char base64_digits[256] = {
367 [43] = 62, 0, 0, 0, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
368 0, 0, 0, -1, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
369 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0, 0, 0, 0,
370 0, 0, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
371 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51
372 };
373
374 if (in_len % 4)
375 in_len += 4 - (in_len % 4);
376 result = dst = xmalloc(in_len / 4 * 3 + 1);
377 while (*src) {
378 int a = base64_digits[(unsigned char) base64dec_getc(&src)];
379 int b = base64_digits[(unsigned char) base64dec_getc(&src)];
380 int c = base64_digits[(unsigned char) base64dec_getc(&src)];
381 int d = base64_digits[(unsigned char) base64dec_getc(&src)];
382
383 /* invalid input. 'a' can be -1, e.g. if src is "\n" (c-str) */
384 if (a == -1 || b == -1)
385 break;
386
387 *dst++ = (a << 2) | ((b & 0x30) >> 4);
388 if (c == -1)
389 break;
390 *dst++ = ((b & 0x0f) << 4) | ((c & 0x3c) >> 2);
391 if (d == -1)
392 break;
393 *dst++ = ((c & 0x03) << 6) | d;
394 }
395 *dst = '\0';
396 return result;
397 }
398
399 void
400 selinit(void)
401 {
402 sel.mode = SEL_IDLE;
403 sel.snap = 0;
404 sel.ob.x = -1;
405 }
406
407 int
408 tlinelen(int y)
409 {
410 int i = term.col;
411
412 if (term.line[y][i - 1].mode & ATTR_WRAP)
413 return i;
414
415 while (i > 0 && term.line[y][i - 1].u == ' ')
416 --i;
417
418 return i;
419 }
420
421 void
422 selstart(int col, int row, int snap)
423 {
424 selclear();
425 sel.mode = SEL_EMPTY;
426 sel.type = SEL_REGULAR;
427 sel.alt = IS_SET(MODE_ALTSCREEN);
428 sel.snap = snap;
429 sel.oe.x = sel.ob.x = col;
430 sel.oe.y = sel.ob.y = row;
431 selnormalize();
432
433 if (sel.snap != 0)
434 sel.mode = SEL_READY;
435 tsetdirt(sel.nb.y, sel.ne.y);
436 }
437
438 void
439 selextend(int col, int row, int type, int done)
440 {
441 int oldey, oldex, oldsby, oldsey, oldtype;
442
443 if (sel.mode == SEL_IDLE)
444 return;
445 if (done && sel.mode == SEL_EMPTY) {
446 selclear();
447 return;
448 }
449
450 oldey = sel.oe.y;
451 oldex = sel.oe.x;
452 oldsby = sel.nb.y;
453 oldsey = sel.ne.y;
454 oldtype = sel.type;
455
456 sel.oe.x = col;
457 sel.oe.y = row;
458 selnormalize();
459 sel.type = type;
460
461 if (oldey != sel.oe.y || oldex != sel.oe.x || oldtype != sel.type || sel.mode == SEL_EMPTY)
462 tsetdirt(MIN(sel.nb.y, oldsby), MAX(sel.ne.y, oldsey));
463
464 sel.mode = done ? SEL_IDLE : SEL_READY;
465 }
466
467 void
468 selnormalize(void)
469 {
470 int i;
471
472 if (sel.type == SEL_REGULAR && sel.ob.y != sel.oe.y) {
473 sel.nb.x = sel.ob.y < sel.oe.y ? sel.ob.x : sel.oe.x;
474 sel.ne.x = sel.ob.y < sel.oe.y ? sel.oe.x : sel.ob.x;
475 } else {
476 sel.nb.x = MIN(sel.ob.x, sel.oe.x);
477 sel.ne.x = MAX(sel.ob.x, sel.oe.x);
478 }
479 sel.nb.y = MIN(sel.ob.y, sel.oe.y);
480 sel.ne.y = MAX(sel.ob.y, sel.oe.y);
481
482 selsnap(&sel.nb.x, &sel.nb.y, -1);
483 selsnap(&sel.ne.x, &sel.ne.y, +1);
484
485 /* expand selection over line breaks */
486 if (sel.type == SEL_RECTANGULAR)
487 return;
488 i = tlinelen(sel.nb.y);
489 if (i < sel.nb.x)
490 sel.nb.x = i;
491 if (tlinelen(sel.ne.y) <= sel.ne.x)
492 sel.ne.x = term.col - 1;
493 }
494
495 int
496 selected(int x, int y)
497 {
498 if (sel.mode == SEL_EMPTY || sel.ob.x == -1 ||
499 sel.alt != IS_SET(MODE_ALTSCREEN))
500 return 0;
501
502 if (sel.type == SEL_RECTANGULAR)
503 return BETWEEN(y, sel.nb.y, sel.ne.y)
504 && BETWEEN(x, sel.nb.x, sel.ne.x);
505
506 return BETWEEN(y, sel.nb.y, sel.ne.y)
507 && (y != sel.nb.y || x >= sel.nb.x)
508 && (y != sel.ne.y || x <= sel.ne.x);
509 }
510
511 void
512 selsnap(int *x, int *y, int direction)
513 {
514 int newx, newy, xt, yt;
515 int delim, prevdelim;
516 const Glyph *gp, *prevgp;
517
518 switch (sel.snap) {
519 case SNAP_WORD:
520 /*
521 * Snap around if the word wraps around at the end or
522 * beginning of a line.
523 */
524 prevgp = &term.line[*y][*x];
525 prevdelim = ISDELIM(prevgp->u);
526 for (;;) {
527 newx = *x + direction;
528 newy = *y;
529 if (!BETWEEN(newx, 0, term.col - 1)) {
530 newy += direction;
531 newx = (newx + term.col) % term.col;
532 if (!BETWEEN(newy, 0, term.row - 1))
533 break;
534
535 if (direction > 0)
536 yt = *y, xt = *x;
537 else
538 yt = newy, xt = newx;
539 if (!(term.line[yt][xt].mode & ATTR_WRAP))
540 break;
541 }
542
543 if (newx >= tlinelen(newy))
544 break;
545
546 gp = &term.line[newy][newx];
547 delim = ISDELIM(gp->u);
548 if (!(gp->mode & ATTR_WDUMMY) && (delim != prevdelim
549 || (delim && gp->u != prevgp->u)))
550 break;
551
552 *x = newx;
553 *y = newy;
554 prevgp = gp;
555 prevdelim = delim;
556 }
557 break;
558 case SNAP_LINE:
559 /*
560 * Snap around if the the previous line or the current one
561 * has set ATTR_WRAP at its end. Then the whole next or
562 * previous line will be selected.
563 */
564 *x = (direction < 0) ? 0 : term.col - 1;
565 if (direction < 0) {
566 for (; *y > 0; *y += direction) {
567 if (!(term.line[*y-1][term.col-1].mode
568 & ATTR_WRAP)) {
569 break;
570 }
571 }
572 } else if (direction > 0) {
573 for (; *y < term.row-1; *y += direction) {
574 if (!(term.line[*y][term.col-1].mode
575 & ATTR_WRAP)) {
576 break;
577 }
578 }
579 }
580 break;
581 }
582 }
583
584 char *
585 getsel(void)
586 {
587 char *str, *ptr;
588 int y, bufsize, lastx, linelen;
589 const Glyph *gp, *last;
590
591 if (sel.ob.x == -1)
592 return NULL;
593
594 bufsize = (term.col+1) * (sel.ne.y-sel.nb.y+1) * UTF_SIZ;
595 ptr = str = xmalloc(bufsize);
596
597 /* append every set & selected glyph to the selection */
598 for (y = sel.nb.y; y <= sel.ne.y; y++) {
599 if ((linelen = tlinelen(y)) == 0) {
600 *ptr++ = '\n';
601 continue;
602 }
603
604 if (sel.type == SEL_RECTANGULAR) {
605 gp = &term.line[y][sel.nb.x];
606 lastx = sel.ne.x;
607 } else {
608 gp = &term.line[y][sel.nb.y == y ? sel.nb.x : 0];
609 lastx = (sel.ne.y == y) ? sel.ne.x : term.col-1;
610 }
611 last = &term.line[y][MIN(lastx, linelen-1)];
612 while (last >= gp && last->u == ' ')
613 --last;
614
615 for ( ; gp <= last; ++gp) {
616 if (gp->mode & ATTR_WDUMMY)
617 continue;
618
619 ptr += utf8encode(gp->u, ptr);
620 }
621
622 /*
623 * Copy and pasting of line endings is inconsistent
624 * in the inconsistent terminal and GUI world.
625 * The best solution seems like to produce '\n' when
626 * something is copied from st and convert '\n' to
627 * '\r', when something to be pasted is received by
628 * st.
629 * FIXME: Fix the computer world.
630 */
631 if ((y < sel.ne.y || lastx >= linelen) &&
632 (!(last->mode & ATTR_WRAP) || sel.type == SEL_RECTANGULAR))
633 *ptr++ = '\n';
634 }
635 *ptr = 0;
636 return str;
637 }
638
639 void
640 selclear(void)
641 {
642 if (sel.ob.x == -1)
643 return;
644 sel.mode = SEL_IDLE;
645 sel.ob.x = -1;
646 tsetdirt(sel.nb.y, sel.ne.y);
647 }
648
649 void
650 die(const char *errstr, ...)
651 {
652 va_list ap;
653
654 va_start(ap, errstr);
655 vfprintf(stderr, errstr, ap);
656 va_end(ap);
657 exit(1);
658 }
659
660 void
661 execsh(char *cmd, char **args)
662 {
663 char *sh, *prog, *arg;
664 const struct passwd *pw;
665
666 errno = 0;
667 if ((pw = getpwuid(getuid())) == NULL) {
668 if (errno)
669 die("getpwuid: %s\n", strerror(errno));
670 else
671 die("who are you?\n");
672 }
673
674 if ((sh = getenv("SHELL")) == NULL)
675 sh = (pw->pw_shell[0]) ? pw->pw_shell : cmd;
676
677 if (args) {
678 prog = args[0];
679 arg = NULL;
680 } else if (scroll) {
681 prog = scroll;
682 arg = utmp ? utmp : sh;
683 } else if (utmp) {
684 prog = utmp;
685 arg = NULL;
686 } else {
687 prog = sh;
688 arg = NULL;
689 }
690 DEFAULT(args, ((char *[]) {prog, arg, NULL}));
691
692 unsetenv("COLUMNS");
693 unsetenv("LINES");
694 unsetenv("TERMCAP");
695 setenv("LOGNAME", pw->pw_name, 1);
696 setenv("USER", pw->pw_name, 1);
697 setenv("SHELL", sh, 1);
698 setenv("HOME", pw->pw_dir, 1);
699 setenv("TERM", termname, 1);
700
701 signal(SIGCHLD, SIG_DFL);
702 signal(SIGHUP, SIG_DFL);
703 signal(SIGINT, SIG_DFL);
704 signal(SIGQUIT, SIG_DFL);
705 signal(SIGTERM, SIG_DFL);
706 signal(SIGALRM, SIG_DFL);
707
708 execvp(prog, args);
709 _exit(1);
710 }
711
712 void
713 sigchld(int a)
714 {
715 int stat, olderrno;
716 pid_t p;
717
718 olderrno = errno;
719 do {
720 p = waitpid(pid, &stat, WNOHANG);
721 } while (p < 0 && errno == EINTR);
722
723 if (p < 0)
724 _exit(1);
725
726 if (pid != p) {
727 errno = olderrno;
728 return;
729 }
730
731 if ((WIFEXITED(stat) && WEXITSTATUS(stat)) || WIFSIGNALED(stat))
732 _exit(1);
733 _exit(0);
734 }
735
736 void
737 stty(char **args)
738 {
739 char cmd[_POSIX_ARG_MAX], **p, *q, *s;
740 size_t n, siz;
741
742 if ((n = strlen(stty_args)) > sizeof(cmd)-1)
743 die("incorrect stty parameters\n");
744 memcpy(cmd, stty_args, n);
745 q = cmd + n;
746 siz = sizeof(cmd) - n;
747 for (p = args; p && (s = *p); ++p) {
748 if ((n = strlen(s)) > siz-1)
749 die("stty parameter length too long\n");
750 *q++ = ' ';
751 memcpy(q, s, n);
752 q += n;
753 siz -= n + 1;
754 }
755 *q = '\0';
756 if (system(cmd) != 0)
757 perror("Couldn't call stty");
758 }
759
760 int
761 ttynew(const char *line, char *cmd, const char *out, char **args)
762 {
763 int m, s;
764
765 if (out) {
766 term.mode |= MODE_PRINT;
767 iofd = (!strcmp(out, "-")) ?
768 1 : open(out, O_WRONLY | O_CREAT, 0666);
769 if (iofd < 0) {
770 fprintf(stderr, "Error opening %s:%s\n",
771 out, strerror(errno));
772 }
773 }
774
775 if (line) {
776 if ((cmdfd = open(line, O_RDWR)) < 0)
777 die("open line '%s' failed: %s\n",
778 line, strerror(errno));
779 dup2(cmdfd, 0);
780 stty(args);
781 return cmdfd;
782 }
783
784 /* seems to work fine on linux, openbsd and freebsd */
785 if (openpty(&m, &s, NULL, NULL, NULL) < 0)
786 die("openpty failed: %s\n", strerror(errno));
787
788 switch (pid = fork()) {
789 case -1:
790 die("fork failed: %s\n", strerror(errno));
791 break;
792 case 0:
793 close(iofd);
794 close(m);
795 setsid(); /* create a new process group */
796 dup2(s, 0);
797 dup2(s, 1);
798 dup2(s, 2);
799 if (ioctl(s, TIOCSCTTY, NULL) < 0)
800 die("ioctl TIOCSCTTY failed: %s\n", strerror(errno));
801 if (s > 2)
802 close(s);
803 #ifdef __OpenBSD__
804 if (pledge("stdio getpw proc exec", NULL) == -1)
805 die("pledge\n");
806 #endif
807 execsh(cmd, args);
808 break;
809 default:
810 #ifdef __OpenBSD__
811 if (pledge("stdio rpath tty proc", NULL) == -1)
812 die("pledge\n");
813 #endif
814 close(s);
815 cmdfd = m;
816 signal(SIGCHLD, sigchld);
817 break;
818 }
819 return cmdfd;
820 }
821
822 size_t
823 ttyread(void)
824 {
825 static char buf[BUFSIZ];
826 static int buflen = 0;
827 int ret, written;
828
829 /* append read bytes to unprocessed bytes */
830 ret = read(cmdfd, buf+buflen, LEN(buf)-buflen);
831
832 switch (ret) {
833 case 0:
834 exit(0);
835 case -1:
836 die("couldn't read from shell: %s\n", strerror(errno));
837 default:
838 buflen += ret;
839 written = twrite(buf, buflen, 0);
840 buflen -= written;
841 /* keep any incomplete UTF-8 byte sequence for the next call */
842 if (buflen > 0)
843 memmove(buf, buf + written, buflen);
844 return ret;
845 }
846 }
847
848 void
849 ttywrite(const char *s, size_t n, int may_echo)
850 {
851 const char *next;
852
853 if (may_echo && IS_SET(MODE_ECHO))
854 twrite(s, n, 1);
855
856 if (!IS_SET(MODE_CRLF)) {
857 ttywriteraw(s, n);
858 return;
859 }
860
861 /* This is similar to how the kernel handles ONLCR for ttys */
862 while (n > 0) {
863 if (*s == '\r') {
864 next = s + 1;
865 ttywriteraw("\r\n", 2);
866 } else {
867 next = memchr(s, '\r', n);
868 DEFAULT(next, s + n);
869 ttywriteraw(s, next - s);
870 }
871 n -= next - s;
872 s = next;
873 }
874 }
875
876 void
877 ttywriteraw(const char *s, size_t n)
878 {
879 fd_set wfd, rfd;
880 ssize_t r;
881 size_t lim = 256;
882
883 /*
884 * Remember that we are using a pty, which might be a modem line.
885 * Writing too much will clog the line. That's why we are doing this
886 * dance.
887 * FIXME: Migrate the world to Plan 9.
888 */
889 while (n > 0) {
890 FD_ZERO(&wfd);
891 FD_ZERO(&rfd);
892 FD_SET(cmdfd, &wfd);
893 FD_SET(cmdfd, &rfd);
894
895 /* Check if we can write. */
896 if (pselect(cmdfd+1, &rfd, &wfd, NULL, NULL, NULL) < 0) {
897 if (errno == EINTR)
898 continue;
899 die("select failed: %s\n", strerror(errno));
900 }
901 if (FD_ISSET(cmdfd, &wfd)) {
902 /*
903 * Only write the bytes written by ttywrite() or the
904 * default of 256. This seems to be a reasonable value
905 * for a serial line. Bigger values might clog the I/O.
906 */
907 if ((r = write(cmdfd, s, (n < lim)? n : lim)) < 0)
908 goto write_error;
909 if (r < n) {
910 /*
911 * We weren't able to write out everything.
912 * This means the buffer is getting full
913 * again. Empty it.
914 */
915 if (n < lim)
916 lim = ttyread();
917 n -= r;
918 s += r;
919 } else {
920 /* All bytes have been written. */
921 break;
922 }
923 }
924 if (FD_ISSET(cmdfd, &rfd))
925 lim = ttyread();
926 }
927 return;
928
929 write_error:
930 die("write error on tty: %s\n", strerror(errno));
931 }
932
933 void
934 ttyresize(int tw, int th)
935 {
936 struct winsize w;
937
938 w.ws_row = term.row;
939 w.ws_col = term.col;
940 w.ws_xpixel = tw;
941 w.ws_ypixel = th;
942 if (ioctl(cmdfd, TIOCSWINSZ, &w) < 0)
943 fprintf(stderr, "Couldn't set window size: %s\n", strerror(errno));
944 }
945
946 void
947 ttyhangup(void)
948 {
949 /* Send SIGHUP to shell */
950 kill(pid, SIGHUP);
951 }
952
953 int
954 tattrset(int attr)
955 {
956 int i, j;
957
958 for (i = 0; i < term.row-1; i++) {
959 for (j = 0; j < term.col-1; j++) {
960 if (term.line[i][j].mode & attr)
961 return 1;
962 }
963 }
964
965 return 0;
966 }
967
968 void
969 tsetdirt(int top, int bot)
970 {
971 int i;
972
973 if (term.row <= 0)
974 return;
975
976 LIMIT(top, 0, term.row-1);
977 LIMIT(bot, 0, term.row-1);
978
979 for (i = top; i <= bot; i++)
980 term.dirty[i] = 1;
981 }
982
983 void
984 tsetdirtattr(int attr)
985 {
986 int i, j;
987
988 for (i = 0; i < term.row-1; i++) {
989 for (j = 0; j < term.col-1; j++) {
990 if (term.line[i][j].mode & attr) {
991 tsetdirt(i, i);
992 break;
993 }
994 }
995 }
996 }
997
998 void
999 tfulldirt(void)
1000 {
1001 tsetdirt(0, term.row-1);
1002 }
1003
1004 void
1005 tcursor(int mode)
1006 {
1007 static TCursor c[2];
1008 int alt = IS_SET(MODE_ALTSCREEN);
1009
1010 if (mode == CURSOR_SAVE) {
1011 c[alt] = term.c;
1012 } else if (mode == CURSOR_LOAD) {
1013 term.c = c[alt];
1014 tmoveto(c[alt].x, c[alt].y);
1015 }
1016 }
1017
1018 void
1019 treset(void)
1020 {
1021 uint i;
1022
1023 term.c = (TCursor){{
1024 .mode = ATTR_NULL,
1025 .fg = defaultfg,
1026 .bg = defaultbg
1027 }, .x = 0, .y = 0, .state = CURSOR_DEFAULT};
1028
1029 memset(term.tabs, 0, term.col * sizeof(*term.tabs));
1030 for (i = tabspaces; i < term.col; i += tabspaces)
1031 term.tabs[i] = 1;
1032 term.top = 0;
1033 term.bot = term.row - 1;
1034 term.mode = MODE_WRAP|MODE_UTF8;
1035 memset(term.trantbl, CS_USA, sizeof(term.trantbl));
1036 term.charset = 0;
1037
1038 for (i = 0; i < 2; i++) {
1039 tmoveto(0, 0);
1040 tcursor(CURSOR_SAVE);
1041 tclearregion(0, 0, term.col-1, term.row-1);
1042 tswapscreen();
1043 }
1044 }
1045
1046 void
1047 tnew(int col, int row)
1048 {
1049 term = (Term){ .c = { .attr = { .fg = defaultfg, .bg = defaultbg } } };
1050 tresize(col, row);
1051 treset();
1052 }
1053
1054 void
1055 tswapscreen(void)
1056 {
1057 Line *tmp = term.line;
1058
1059 term.line = term.alt;
1060 term.alt = tmp;
1061 term.mode ^= MODE_ALTSCREEN;
1062 tfulldirt();
1063 }
1064
1065 void
1066 tscrolldown(int orig, int n)
1067 {
1068 int i;
1069 Line temp;
1070
1071 LIMIT(n, 0, term.bot-orig+1);
1072
1073 tsetdirt(orig, term.bot-n);
1074 tclearregion(0, term.bot-n+1, term.col-1, term.bot);
1075
1076 for (i = term.bot; i >= orig+n; i--) {
1077 temp = term.line[i];
1078 term.line[i] = term.line[i-n];
1079 term.line[i-n] = temp;
1080 }
1081
1082 selscroll(orig, n);
1083 }
1084
1085 void
1086 tscrollup(int orig, int n)
1087 {
1088 int i;
1089 Line temp;
1090
1091 LIMIT(n, 0, term.bot-orig+1);
1092
1093 tclearregion(0, orig, term.col-1, orig+n-1);
1094 tsetdirt(orig+n, term.bot);
1095
1096 for (i = orig; i <= term.bot-n; i++) {
1097 temp = term.line[i];
1098 term.line[i] = term.line[i+n];
1099 term.line[i+n] = temp;
1100 }
1101
1102 selscroll(orig, -n);
1103 }
1104
1105 void
1106 selscroll(int orig, int n)
1107 {
1108 if (sel.ob.x == -1 || sel.alt != IS_SET(MODE_ALTSCREEN))
1109 return;
1110
1111 if (BETWEEN(sel.nb.y, orig, term.bot) != BETWEEN(sel.ne.y, orig, term.bot)) {
1112 selclear();
1113 } else if (BETWEEN(sel.nb.y, orig, term.bot)) {
1114 sel.ob.y += n;
1115 sel.oe.y += n;
1116 if (sel.ob.y < term.top || sel.ob.y > term.bot ||
1117 sel.oe.y < term.top || sel.oe.y > term.bot) {
1118 selclear();
1119 } else {
1120 selnormalize();
1121 }
1122 }
1123 }
1124
1125 void
1126 tnewline(int first_col)
1127 {
1128 int y = term.c.y;
1129
1130 if (y == term.bot) {
1131 tscrollup(term.top, 1);
1132 } else {
1133 y++;
1134 }
1135 tmoveto(first_col ? 0 : term.c.x, y);
1136 }
1137
1138 void
1139 csiparse(void)
1140 {
1141 char *p = csiescseq.buf, *np;
1142 long int v;
1143 int sep = ';'; /* colon or semi-colon, but not both */
1144
1145 csiescseq.narg = 0;
1146 if (*p == '?') {
1147 csiescseq.priv = 1;
1148 p++;
1149 }
1150
1151 csiescseq.buf[csiescseq.len] = '\0';
1152 while (p < csiescseq.buf+csiescseq.len) {
1153 np = NULL;
1154 v = strtol(p, &np, 10);
1155 if (np == p)
1156 v = 0;
1157 if (v == LONG_MAX || v == LONG_MIN)
1158 v = -1;
1159 csiescseq.arg[csiescseq.narg++] = v;
1160 p = np;
1161 if (sep == ';' && *p == ':')
1162 sep = ':'; /* allow override to colon once */
1163 if (*p != sep || csiescseq.narg == ESC_ARG_SIZ)
1164 break;
1165 p++;
1166 }
1167 csiescseq.mode[0] = *p++;
1168 csiescseq.mode[1] = (p < csiescseq.buf+csiescseq.len) ? *p : '\0';
1169 }
1170
1171 /* for absolute user moves, when decom is set */
1172 void
1173 tmoveato(int x, int y)
1174 {
1175 tmoveto(x, y + ((term.c.state & CURSOR_ORIGIN) ? term.top: 0));
1176 }
1177
1178 void
1179 tmoveto(int x, int y)
1180 {
1181 int miny, maxy;
1182
1183 if (term.c.state & CURSOR_ORIGIN) {
1184 miny = term.top;
1185 maxy = term.bot;
1186 } else {
1187 miny = 0;
1188 maxy = term.row - 1;
1189 }
1190 term.c.state &= ~CURSOR_WRAPNEXT;
1191 term.c.x = LIMIT(x, 0, term.col-1);
1192 term.c.y = LIMIT(y, miny, maxy);
1193 }
1194
1195 void
1196 tsetchar(Rune u, const Glyph *attr, int x, int y)
1197 {
1198 static const char *vt100_0[62] = { /* 0x41 - 0x7e */
1199 "↑", "↓", "→", "←", "█", "▚", "☃", /* A - G */
1200 0, 0, 0, 0, 0, 0, 0, 0, /* H - O */
1201 0, 0, 0, 0, 0, 0, 0, 0, /* P - W */
1202 0, 0, 0, 0, 0, 0, 0, " ", /* X - _ */
1203 "◆", "▒", "␉", "␌", "␍", "␊", "°", "±", /* ` - g */
1204 "␤", "␋", "┘", "┐", "┌", "└", "┼", "⎺", /* h - o */
1205 "⎻", "─", "⎼", "⎽", "├", "┤", "┴", "┬", /* p - w */
1206 "│", "≤", "≥", "π", "≠", "£", "·", /* x - ~ */
1207 };
1208
1209 /*
1210 * The table is proudly stolen from rxvt.
1211 */
1212 if (term.trantbl[term.charset] == CS_GRAPHIC0 &&
1213 BETWEEN(u, 0x41, 0x7e) && vt100_0[u - 0x41])
1214 utf8decode(vt100_0[u - 0x41], &u, UTF_SIZ);
1215
1216 if (term.line[y][x].mode & ATTR_WIDE) {
1217 if (x+1 < term.col) {
1218 term.line[y][x+1].u = ' ';
1219 term.line[y][x+1].mode &= ~ATTR_WDUMMY;
1220 }
1221 } else if (term.line[y][x].mode & ATTR_WDUMMY) {
1222 term.line[y][x-1].u = ' ';
1223 term.line[y][x-1].mode &= ~ATTR_WIDE;
1224 }
1225
1226 term.dirty[y] = 1;
1227 term.line[y][x] = *attr;
1228 term.line[y][x].u = u;
1229 }
1230
1231 void
1232 tclearregion(int x1, int y1, int x2, int y2)
1233 {
1234 int x, y, temp;
1235 Glyph *gp;
1236
1237 if (x1 > x2)
1238 temp = x1, x1 = x2, x2 = temp;
1239 if (y1 > y2)
1240 temp = y1, y1 = y2, y2 = temp;
1241
1242 LIMIT(x1, 0, term.col-1);
1243 LIMIT(x2, 0, term.col-1);
1244 LIMIT(y1, 0, term.row-1);
1245 LIMIT(y2, 0, term.row-1);
1246
1247 for (y = y1; y <= y2; y++) {
1248 term.dirty[y] = 1;
1249 for (x = x1; x <= x2; x++) {
1250 gp = &term.line[y][x];
1251 if (selected(x, y))
1252 selclear();
1253 gp->fg = term.c.attr.fg;
1254 gp->bg = term.c.attr.bg;
1255 gp->mode = 0;
1256 gp->u = ' ';
1257 }
1258 }
1259 }
1260
1261 void
1262 tdeletechar(int n)
1263 {
1264 int dst, src, size;
1265 Glyph *line;
1266
1267 LIMIT(n, 0, term.col - term.c.x);
1268
1269 dst = term.c.x;
1270 src = term.c.x + n;
1271 size = term.col - src;
1272 line = term.line[term.c.y];
1273
1274 memmove(&line[dst], &line[src], size * sizeof(Glyph));
1275 tclearregion(term.col-n, term.c.y, term.col-1, term.c.y);
1276 }
1277
1278 void
1279 tinsertblank(int n)
1280 {
1281 int dst, src, size;
1282 Glyph *line;
1283
1284 LIMIT(n, 0, term.col - term.c.x);
1285
1286 dst = term.c.x + n;
1287 src = term.c.x;
1288 size = term.col - dst;
1289 line = term.line[term.c.y];
1290
1291 memmove(&line[dst], &line[src], size * sizeof(Glyph));
1292 tclearregion(src, term.c.y, dst - 1, term.c.y);
1293 }
1294
1295 void
1296 tinsertblankline(int n)
1297 {
1298 if (BETWEEN(term.c.y, term.top, term.bot))
1299 tscrolldown(term.c.y, n);
1300 }
1301
1302 void
1303 tdeleteline(int n)
1304 {
1305 if (BETWEEN(term.c.y, term.top, term.bot))
1306 tscrollup(term.c.y, n);
1307 }
1308
1309 int32_t
1310 tdefcolor(const int *attr, int *npar, int l)
1311 {
1312 int32_t idx = -1;
1313 uint r, g, b;
1314
1315 switch (attr[*npar + 1]) {
1316 case 2: /* direct color in RGB space */
1317 if (*npar + 4 >= l) {
1318 fprintf(stderr,
1319 "erresc(38): Incorrect number of parameters (%d)\n",
1320 *npar);
1321 break;
1322 }
1323 r = attr[*npar + 2];
1324 g = attr[*npar + 3];
1325 b = attr[*npar + 4];
1326 *npar += 4;
1327 if (!BETWEEN(r, 0, 255) || !BETWEEN(g, 0, 255) || !BETWEEN(b, 0, 255))
1328 fprintf(stderr, "erresc: bad rgb color (%u,%u,%u)\n",
1329 r, g, b);
1330 else
1331 idx = TRUECOLOR(r, g, b);
1332 break;
1333 case 5: /* indexed color */
1334 if (*npar + 2 >= l) {
1335 fprintf(stderr,
1336 "erresc(38): Incorrect number of parameters (%d)\n",
1337 *npar);
1338 break;
1339 }
1340 *npar += 2;
1341 if (!BETWEEN(attr[*npar], 0, 255))
1342 fprintf(stderr, "erresc: bad fgcolor %d\n", attr[*npar]);
1343 else
1344 idx = attr[*npar];
1345 break;
1346 case 0: /* implemented defined (only foreground) */
1347 case 1: /* transparent */
1348 case 3: /* direct color in CMY space */
1349 case 4: /* direct color in CMYK space */
1350 default:
1351 fprintf(stderr,
1352 "erresc(38): gfx attr %d unknown\n", attr[*npar]);
1353 break;
1354 }
1355
1356 return idx;
1357 }
1358
1359 void
1360 tsetattr(const int *attr, int l)
1361 {
1362 int i;
1363 int32_t idx;
1364
1365 for (i = 0; i < l; i++) {
1366 switch (attr[i]) {
1367 case 0:
1368 term.c.attr.mode &= ~(
1369 ATTR_BOLD |
1370 ATTR_FAINT |
1371 ATTR_ITALIC |
1372 ATTR_UNDERLINE |
1373 ATTR_BLINK |
1374 ATTR_REVERSE |
1375 ATTR_INVISIBLE |
1376 ATTR_STRUCK );
1377 term.c.attr.fg = defaultfg;
1378 term.c.attr.bg = defaultbg;
1379 break;
1380 case 1:
1381 term.c.attr.mode |= ATTR_BOLD;
1382 break;
1383 case 2:
1384 term.c.attr.mode |= ATTR_FAINT;
1385 break;
1386 case 3:
1387 term.c.attr.mode |= ATTR_ITALIC;
1388 break;
1389 case 4:
1390 term.c.attr.mode |= ATTR_UNDERLINE;
1391 break;
1392 case 5: /* slow blink */
1393 /* FALLTHROUGH */
1394 case 6: /* rapid blink */
1395 term.c.attr.mode |= ATTR_BLINK;
1396 break;
1397 case 7:
1398 term.c.attr.mode |= ATTR_REVERSE;
1399 break;
1400 case 8:
1401 term.c.attr.mode |= ATTR_INVISIBLE;
1402 break;
1403 case 9:
1404 term.c.attr.mode |= ATTR_STRUCK;
1405 break;
1406 case 22:
1407 term.c.attr.mode &= ~(ATTR_BOLD | ATTR_FAINT);
1408 break;
1409 case 23:
1410 term.c.attr.mode &= ~ATTR_ITALIC;
1411 break;
1412 case 24:
1413 term.c.attr.mode &= ~ATTR_UNDERLINE;
1414 break;
1415 case 25:
1416 term.c.attr.mode &= ~ATTR_BLINK;
1417 break;
1418 case 27:
1419 term.c.attr.mode &= ~ATTR_REVERSE;
1420 break;
1421 case 28:
1422 term.c.attr.mode &= ~ATTR_INVISIBLE;
1423 break;
1424 case 29:
1425 term.c.attr.mode &= ~ATTR_STRUCK;
1426 break;
1427 case 38:
1428 if ((idx = tdefcolor(attr, &i, l)) >= 0)
1429 term.c.attr.fg = idx;
1430 break;
1431 case 39: /* set foreground color to default */
1432 term.c.attr.fg = defaultfg;
1433 break;
1434 case 48:
1435 if ((idx = tdefcolor(attr, &i, l)) >= 0)
1436 term.c.attr.bg = idx;
1437 break;
1438 case 49: /* set background color to default */
1439 term.c.attr.bg = defaultbg;
1440 break;
1441 case 58:
1442 /* This starts a sequence to change the color of
1443 * "underline" pixels. We don't support that and
1444 * instead eat up a following "5;n" or "2;r;g;b". */
1445 tdefcolor(attr, &i, l);
1446 break;
1447 default:
1448 if (BETWEEN(attr[i], 30, 37)) {
1449 term.c.attr.fg = attr[i] - 30;
1450 } else if (BETWEEN(attr[i], 40, 47)) {
1451 term.c.attr.bg = attr[i] - 40;
1452 } else if (BETWEEN(attr[i], 90, 97)) {
1453 term.c.attr.fg = attr[i] - 90 + 8;
1454 } else if (BETWEEN(attr[i], 100, 107)) {
1455 term.c.attr.bg = attr[i] - 100 + 8;
1456 } else {
1457 fprintf(stderr,
1458 "erresc(default): gfx attr %d unknown\n",
1459 attr[i]);
1460 csidump();
1461 }
1462 break;
1463 }
1464 }
1465 }
1466
1467 void
1468 tsetscroll(int t, int b)
1469 {
1470 int temp;
1471
1472 LIMIT(t, 0, term.row-1);
1473 LIMIT(b, 0, term.row-1);
1474 if (t > b) {
1475 temp = t;
1476 t = b;
1477 b = temp;
1478 }
1479 term.top = t;
1480 term.bot = b;
1481 }
1482
1483 void
1484 tsetmode(int priv, int set, const int *args, int narg)
1485 {
1486 int alt; const int *lim;
1487
1488 for (lim = args + narg; args < lim; ++args) {
1489 if (priv) {
1490 switch (*args) {
1491 case 1: /* DECCKM -- Cursor key */
1492 xsetmode(set, MODE_APPCURSOR);
1493 break;
1494 case 5: /* DECSCNM -- Reverse video */
1495 xsetmode(set, MODE_REVERSE);
1496 break;
1497 case 6: /* DECOM -- Origin */
1498 MODBIT(term.c.state, set, CURSOR_ORIGIN);
1499 tmoveato(0, 0);
1500 break;
1501 case 7: /* DECAWM -- Auto wrap */
1502 MODBIT(term.mode, set, MODE_WRAP);
1503 break;
1504 case 0: /* Error (IGNORED) */
1505 case 2: /* DECANM -- ANSI/VT52 (IGNORED) */
1506 case 3: /* DECCOLM -- Column (IGNORED) */
1507 case 4: /* DECSCLM -- Scroll (IGNORED) */
1508 case 8: /* DECARM -- Auto repeat (IGNORED) */
1509 case 18: /* DECPFF -- Printer feed (IGNORED) */
1510 case 19: /* DECPEX -- Printer extent (IGNORED) */
1511 case 42: /* DECNRCM -- National characters (IGNORED) */
1512 case 12: /* att610 -- Start blinking cursor (IGNORED) */
1513 break;
1514 case 25: /* DECTCEM -- Text Cursor Enable Mode */
1515 xsetmode(!set, MODE_HIDE);
1516 break;
1517 case 9: /* X10 mouse compatibility mode */
1518 xsetpointermotion(0);
1519 xsetmode(0, MODE_MOUSE);
1520 xsetmode(set, MODE_MOUSEX10);
1521 break;
1522 case 1000: /* 1000: report button press */
1523 xsetpointermotion(0);
1524 xsetmode(0, MODE_MOUSE);
1525 xsetmode(set, MODE_MOUSEBTN);
1526 break;
1527 case 1002: /* 1002: report motion on button press */
1528 xsetpointermotion(0);
1529 xsetmode(0, MODE_MOUSE);
1530 xsetmode(set, MODE_MOUSEMOTION);
1531 break;
1532 case 1003: /* 1003: enable all mouse motions */
1533 xsetpointermotion(set);
1534 xsetmode(0, MODE_MOUSE);
1535 xsetmode(set, MODE_MOUSEMANY);
1536 break;
1537 case 1004: /* 1004: send focus events to tty */
1538 xsetmode(set, MODE_FOCUS);
1539 break;
1540 case 1006: /* 1006: extended reporting mode */
1541 xsetmode(set, MODE_MOUSESGR);
1542 break;
1543 case 1034: /* 1034: enable 8-bit mode for keyboard input */
1544 xsetmode(set, MODE_8BIT);
1545 break;
1546 case 1049: /* swap screen & set/restore cursor as xterm */
1547 if (!allowaltscreen)
1548 break;
1549 tcursor((set) ? CURSOR_SAVE : CURSOR_LOAD);
1550 /* FALLTHROUGH */
1551 case 47: /* swap screen buffer */
1552 case 1047: /* swap screen buffer */
1553 if (!allowaltscreen)
1554 break;
1555 alt = IS_SET(MODE_ALTSCREEN);
1556 if (alt) {
1557 tclearregion(0, 0, term.col-1,
1558 term.row-1);
1559 }
1560 if (set ^ alt) /* set is always 1 or 0 */
1561 tswapscreen();
1562 if (*args != 1049)
1563 break;
1564 /* FALLTHROUGH */
1565 case 1048: /* save/restore cursor (like DECSC/DECRC) */
1566 tcursor((set) ? CURSOR_SAVE : CURSOR_LOAD);
1567 break;
1568 case 2004: /* 2004: bracketed paste mode */
1569 xsetmode(set, MODE_BRCKTPASTE);
1570 break;
1571 /* Not implemented mouse modes. See comments there. */
1572 case 1001: /* mouse highlight mode; can hang the
1573 terminal by design when implemented. */
1574 case 1005: /* UTF-8 mouse mode; will confuse
1575 applications not supporting UTF-8
1576 and luit. */
1577 case 1015: /* urxvt mangled mouse mode; incompatible
1578 and can be mistaken for other control
1579 codes. */
1580 break;
1581 default:
1582 fprintf(stderr,
1583 "erresc: unknown private set/reset mode %d\n",
1584 *args);
1585 break;
1586 }
1587 } else {
1588 switch (*args) {
1589 case 0: /* Error (IGNORED) */
1590 break;
1591 case 2:
1592 xsetmode(set, MODE_KBDLOCK);
1593 break;
1594 case 4: /* IRM -- Insertion-replacement */
1595 MODBIT(term.mode, set, MODE_INSERT);
1596 break;
1597 case 12: /* SRM -- Send/Receive */
1598 MODBIT(term.mode, !set, MODE_ECHO);
1599 break;
1600 case 20: /* LNM -- Linefeed/new line */
1601 MODBIT(term.mode, set, MODE_CRLF);
1602 break;
1603 default:
1604 fprintf(stderr,
1605 "erresc: unknown set/reset mode %d\n",
1606 *args);
1607 break;
1608 }
1609 }
1610 }
1611 }
1612
1613 void
1614 csihandle(void)
1615 {
1616 char buf[40];
1617 int len;
1618
1619 switch (csiescseq.mode[0]) {
1620 default:
1621 unknown:
1622 fprintf(stderr, "erresc: unknown csi ");
1623 csidump();
1624 /* die(""); */
1625 break;
1626 case '@': /* ICH -- Insert <n> blank char */
1627 DEFAULT(csiescseq.arg[0], 1);
1628 tinsertblank(csiescseq.arg[0]);
1629 break;
1630 case 'A': /* CUU -- Cursor <n> Up */
1631 DEFAULT(csiescseq.arg[0], 1);
1632 tmoveto(term.c.x, term.c.y-csiescseq.arg[0]);
1633 break;
1634 case 'B': /* CUD -- Cursor <n> Down */
1635 case 'e': /* VPR --Cursor <n> Down */
1636 DEFAULT(csiescseq.arg[0], 1);
1637 tmoveto(term.c.x, term.c.y+csiescseq.arg[0]);
1638 break;
1639 case 'i': /* MC -- Media Copy */
1640 switch (csiescseq.arg[0]) {
1641 case 0:
1642 tdump();
1643 break;
1644 case 1:
1645 tdumpline(term.c.y);
1646 break;
1647 case 2:
1648 tdumpsel();
1649 break;
1650 case 4:
1651 term.mode &= ~MODE_PRINT;
1652 break;
1653 case 5:
1654 term.mode |= MODE_PRINT;
1655 break;
1656 }
1657 break;
1658 case 'c': /* DA -- Device Attributes */
1659 if (csiescseq.arg[0] == 0)
1660 ttywrite(vtiden, strlen(vtiden), 0);
1661 break;
1662 case 'b': /* REP -- if last char is printable print it <n> more times */
1663 LIMIT(csiescseq.arg[0], 1, 65535);
1664 if (term.lastc)
1665 while (csiescseq.arg[0]-- > 0)
1666 tputc(term.lastc);
1667 break;
1668 case 'C': /* CUF -- Cursor <n> Forward */
1669 case 'a': /* HPR -- Cursor <n> Forward */
1670 DEFAULT(csiescseq.arg[0], 1);
1671 tmoveto(term.c.x+csiescseq.arg[0], term.c.y);
1672 break;
1673 case 'D': /* CUB -- Cursor <n> Backward */
1674 DEFAULT(csiescseq.arg[0], 1);
1675 tmoveto(term.c.x-csiescseq.arg[0], term.c.y);
1676 break;
1677 case 'E': /* CNL -- Cursor <n> Down and first col */
1678 DEFAULT(csiescseq.arg[0], 1);
1679 tmoveto(0, term.c.y+csiescseq.arg[0]);
1680 break;
1681 case 'F': /* CPL -- Cursor <n> Up and first col */
1682 DEFAULT(csiescseq.arg[0], 1);
1683 tmoveto(0, term.c.y-csiescseq.arg[0]);
1684 break;
1685 case 'g': /* TBC -- Tabulation clear */
1686 switch (csiescseq.arg[0]) {
1687 case 0: /* clear current tab stop */
1688 term.tabs[term.c.x] = 0;
1689 break;
1690 case 3: /* clear all the tabs */
1691 memset(term.tabs, 0, term.col * sizeof(*term.tabs));
1692 break;
1693 default:
1694 goto unknown;
1695 }
1696 break;
1697 case 'G': /* CHA -- Move to <col> */
1698 case '`': /* HPA */
1699 DEFAULT(csiescseq.arg[0], 1);
1700 tmoveto(csiescseq.arg[0]-1, term.c.y);
1701 break;
1702 case 'H': /* CUP -- Move to <row> <col> */
1703 case 'f': /* HVP */
1704 DEFAULT(csiescseq.arg[0], 1);
1705 DEFAULT(csiescseq.arg[1], 1);
1706 tmoveato(csiescseq.arg[1]-1, csiescseq.arg[0]-1);
1707 break;
1708 case 'I': /* CHT -- Cursor Forward Tabulation <n> tab stops */
1709 DEFAULT(csiescseq.arg[0], 1);
1710 tputtab(csiescseq.arg[0]);
1711 break;
1712 case 'J': /* ED -- Clear screen */
1713 switch (csiescseq.arg[0]) {
1714 case 0: /* below */
1715 tclearregion(term.c.x, term.c.y, term.col-1, term.c.y);
1716 if (term.c.y < term.row-1) {
1717 tclearregion(0, term.c.y+1, term.col-1,
1718 term.row-1);
1719 }
1720 break;
1721 case 1: /* above */
1722 if (term.c.y > 0)
1723 tclearregion(0, 0, term.col-1, term.c.y-1);
1724 tclearregion(0, term.c.y, term.c.x, term.c.y);
1725 break;
1726 case 2: /* all */
1727 tclearregion(0, 0, term.col-1, term.row-1);
1728 break;
1729 default:
1730 goto unknown;
1731 }
1732 break;
1733 case 'K': /* EL -- Clear line */
1734 switch (csiescseq.arg[0]) {
1735 case 0: /* right */
1736 tclearregion(term.c.x, term.c.y, term.col-1,
1737 term.c.y);
1738 break;
1739 case 1: /* left */
1740 tclearregion(0, term.c.y, term.c.x, term.c.y);
1741 break;
1742 case 2: /* all */
1743 tclearregion(0, term.c.y, term.col-1, term.c.y);
1744 break;
1745 }
1746 break;
1747 case 'S': /* SU -- Scroll <n> line up */
1748 if (csiescseq.priv) break;
1749 DEFAULT(csiescseq.arg[0], 1);
1750 tscrollup(term.top, csiescseq.arg[0]);
1751 break;
1752 case 'T': /* SD -- Scroll <n> line down */
1753 DEFAULT(csiescseq.arg[0], 1);
1754 tscrolldown(term.top, csiescseq.arg[0]);
1755 break;
1756 case 'L': /* IL -- Insert <n> blank lines */
1757 DEFAULT(csiescseq.arg[0], 1);
1758 tinsertblankline(csiescseq.arg[0]);
1759 break;
1760 case 'l': /* RM -- Reset Mode */
1761 tsetmode(csiescseq.priv, 0, csiescseq.arg, csiescseq.narg);
1762 break;
1763 case 'M': /* DL -- Delete <n> lines */
1764 DEFAULT(csiescseq.arg[0], 1);
1765 tdeleteline(csiescseq.arg[0]);
1766 break;
1767 case 'X': /* ECH -- Erase <n> char */
1768 DEFAULT(csiescseq.arg[0], 1);
1769 tclearregion(term.c.x, term.c.y,
1770 term.c.x + csiescseq.arg[0] - 1, term.c.y);
1771 break;
1772 case 'P': /* DCH -- Delete <n> char */
1773 DEFAULT(csiescseq.arg[0], 1);
1774 tdeletechar(csiescseq.arg[0]);
1775 break;
1776 case 'Z': /* CBT -- Cursor Backward Tabulation <n> tab stops */
1777 DEFAULT(csiescseq.arg[0], 1);
1778 tputtab(-csiescseq.arg[0]);
1779 break;
1780 case 'd': /* VPA -- Move to <row> */
1781 DEFAULT(csiescseq.arg[0], 1);
1782 tmoveato(term.c.x, csiescseq.arg[0]-1);
1783 break;
1784 case 'h': /* SM -- Set terminal mode */
1785 tsetmode(csiescseq.priv, 1, csiescseq.arg, csiescseq.narg);
1786 break;
1787 case 'm': /* SGR -- Terminal attribute (color) */
1788 tsetattr(csiescseq.arg, csiescseq.narg);
1789 break;
1790 case 'n': /* DSR -- Device Status Report */
1791 switch (csiescseq.arg[0]) {
1792 case 5: /* Status Report "OK" `0n` */
1793 ttywrite("\033[0n", sizeof("\033[0n") - 1, 0);
1794 break;
1795 case 6: /* Report Cursor Position (CPR) "<row>;<column>R" */
1796 len = snprintf(buf, sizeof(buf), "\033[%i;%iR",
1797 term.c.y+1, term.c.x+1);
1798 ttywrite(buf, len, 0);
1799 break;
1800 default:
1801 goto unknown;
1802 }
1803 break;
1804 case 'r': /* DECSTBM -- Set Scrolling Region */
1805 if (csiescseq.priv) {
1806 goto unknown;
1807 } else {
1808 DEFAULT(csiescseq.arg[0], 1);
1809 DEFAULT(csiescseq.arg[1], term.row);
1810 tsetscroll(csiescseq.arg[0]-1, csiescseq.arg[1]-1);
1811 tmoveato(0, 0);
1812 }
1813 break;
1814 case 's': /* DECSC -- Save cursor position (ANSI.SYS) */
1815 tcursor(CURSOR_SAVE);
1816 break;
1817 case 'u': /* DECRC -- Restore cursor position (ANSI.SYS) */
1818 if (csiescseq.priv) {
1819 goto unknown;
1820 } else {
1821 tcursor(CURSOR_LOAD);
1822 }
1823 break;
1824 case ' ':
1825 switch (csiescseq.mode[1]) {
1826 case 'q': /* DECSCUSR -- Set Cursor Style */
1827 if (xsetcursor(csiescseq.arg[0]))
1828 goto unknown;
1829 break;
1830 default:
1831 goto unknown;
1832 }
1833 break;
1834 }
1835 }
1836
1837 void
1838 csidump(void)
1839 {
1840 size_t i;
1841 uint c;
1842
1843 fprintf(stderr, "ESC[");
1844 for (i = 0; i < csiescseq.len; i++) {
1845 c = csiescseq.buf[i] & 0xff;
1846 if (isprint(c)) {
1847 putc(c, stderr);
1848 } else if (c == '\n') {
1849 fprintf(stderr, "(\\n)");
1850 } else if (c == '\r') {
1851 fprintf(stderr, "(\\r)");
1852 } else if (c == 0x1b) {
1853 fprintf(stderr, "(\\e)");
1854 } else {
1855 fprintf(stderr, "(%02x)", c);
1856 }
1857 }
1858 putc('\n', stderr);
1859 }
1860
1861 void
1862 csireset(void)
1863 {
1864 memset(&csiescseq, 0, sizeof(csiescseq));
1865 }
1866
1867 void
1868 osc_color_response(int num, int index, int is_osc4)
1869 {
1870 int n;
1871 char buf[32];
1872 unsigned char r, g, b;
1873
1874 if (xgetcolor(is_osc4 ? num : index, &r, &g, &b)) {
1875 fprintf(stderr, "erresc: failed to fetch %s color %d\n",
1876 is_osc4 ? "osc4" : "osc",
1877 is_osc4 ? num : index);
1878 return;
1879 }
1880
1881 n = snprintf(buf, sizeof buf, "\033]%s%d;rgb:%02x%02x/%02x%02x/%02x%02x\007",
1882 is_osc4 ? "4;" : "", num, r, r, g, g, b, b);
1883 if (n < 0 || n >= sizeof(buf)) {
1884 fprintf(stderr, "error: %s while printing %s response\n",
1885 n < 0 ? "snprintf failed" : "truncation occurred",
1886 is_osc4 ? "osc4" : "osc");
1887 } else {
1888 ttywrite(buf, n, 1);
1889 }
1890 }
1891
1892 void
1893 strhandle(void)
1894 {
1895 char *p = NULL, *dec;
1896 int j, narg, par;
1897 const struct { int idx; char *str; } osc_table[] = {
1898 { defaultfg, "foreground" },
1899 { defaultbg, "background" },
1900 { defaultcs, "cursor" }
1901 };
1902
1903 term.esc &= ~(ESC_STR_END|ESC_STR);
1904 strparse();
1905 par = (narg = strescseq.narg) ? atoi(strescseq.args[0]) : 0;
1906
1907 switch (strescseq.type) {
1908 case ']': /* OSC -- Operating System Command */
1909 switch (par) {
1910 case 0:
1911 if (narg > 1) {
1912 xsettitle(strescseq.args[1]);
1913 xseticontitle(strescseq.args[1]);
1914 }
1915 return;
1916 case 1:
1917 if (narg > 1)
1918 xseticontitle(strescseq.args[1]);
1919 return;
1920 case 2:
1921 if (narg > 1)
1922 xsettitle(strescseq.args[1]);
1923 return;
1924 case 52: /* manipulate selection data */
1925 if (narg > 2 && allowwindowops) {
1926 dec = base64dec(strescseq.args[2]);
1927 if (dec) {
1928 xsetsel(dec);
1929 xclipcopy();
1930 } else {
1931 fprintf(stderr, "erresc: invalid base64\n");
1932 }
1933 }
1934 return;
1935 case 10: /* set dynamic VT100 text foreground color */
1936 case 11: /* set dynamic VT100 text background color */
1937 case 12: /* set dynamic text cursor color */
1938 if (narg < 2)
1939 break;
1940 p = strescseq.args[1];
1941 if ((j = par - 10) < 0 || j >= LEN(osc_table))
1942 break; /* shouldn't be possible */
1943
1944 if (!strcmp(p, "?")) {
1945 osc_color_response(par, osc_table[j].idx, 0);
1946 } else if (xsetcolorname(osc_table[j].idx, p)) {
1947 fprintf(stderr, "erresc: invalid %s color: %s\n",
1948 osc_table[j].str, p);
1949 } else {
1950 tfulldirt();
1951 }
1952 return;
1953 case 4: /* color set */
1954 if (narg < 3)
1955 break;
1956 p = strescseq.args[2];
1957 /* FALLTHROUGH */
1958 case 104: /* color reset */
1959 j = (narg > 1) ? atoi(strescseq.args[1]) : -1;
1960
1961 if (p && !strcmp(p, "?")) {
1962 osc_color_response(j, 0, 1);
1963 } else if (xsetcolorname(j, p)) {
1964 if (par == 104 && narg <= 1) {
1965 xloadcols();
1966 return; /* color reset without parameter */
1967 }
1968 fprintf(stderr, "erresc: invalid color j=%d, p=%s\n",
1969 j, p ? p : "(null)");
1970 } else {
1971 /*
1972 * TODO if defaultbg color is changed, borders
1973 * are dirty
1974 */
1975 tfulldirt();
1976 }
1977 return;
1978 case 110: /* reset dynamic VT100 text foreground color */
1979 case 111: /* reset dynamic VT100 text background color */
1980 case 112: /* reset dynamic text cursor color */
1981 if (narg != 1)
1982 break;
1983 if ((j = par - 110) < 0 || j >= LEN(osc_table))
1984 break; /* shouldn't be possible */
1985 if (xsetcolorname(osc_table[j].idx, NULL)) {
1986 fprintf(stderr, "erresc: %s color not found\n", osc_table[j].str);
1987 } else {
1988 tfulldirt();
1989 }
1990 return;
1991 }
1992 break;
1993 case 'k': /* old title set compatibility */
1994 xsettitle(strescseq.args[0]);
1995 return;
1996 case 'P': /* DCS -- Device Control String */
1997 case '_': /* APC -- Application Program Command */
1998 case '^': /* PM -- Privacy Message */
1999 return;
2000 }
2001
2002 fprintf(stderr, "erresc: unknown str ");
2003 strdump();
2004 }
2005
2006 void
2007 strparse(void)
2008 {
2009 int c;
2010 char *p = strescseq.buf;
2011
2012 strescseq.narg = 0;
2013 strescseq.buf[strescseq.len] = '\0';
2014
2015 if (*p == '\0')
2016 return;
2017
2018 while (strescseq.narg < STR_ARG_SIZ) {
2019 strescseq.args[strescseq.narg++] = p;
2020 while ((c = *p) != ';' && c != '\0')
2021 ++p;
2022 if (c == '\0')
2023 return;
2024 *p++ = '\0';
2025 }
2026 }
2027
2028 void
2029 strdump(void)
2030 {
2031 size_t i;
2032 uint c;
2033
2034 fprintf(stderr, "ESC%c", strescseq.type);
2035 for (i = 0; i < strescseq.len; i++) {
2036 c = strescseq.buf[i] & 0xff;
2037 if (c == '\0') {
2038 putc('\n', stderr);
2039 return;
2040 } else if (isprint(c)) {
2041 putc(c, stderr);
2042 } else if (c == '\n') {
2043 fprintf(stderr, "(\\n)");
2044 } else if (c == '\r') {
2045 fprintf(stderr, "(\\r)");
2046 } else if (c == 0x1b) {
2047 fprintf(stderr, "(\\e)");
2048 } else {
2049 fprintf(stderr, "(%02x)", c);
2050 }
2051 }
2052 fprintf(stderr, "ESC\\\n");
2053 }
2054
2055 void
2056 strreset(void)
2057 {
2058 strescseq = (STREscape){
2059 .buf = xrealloc(strescseq.buf, STR_BUF_SIZ),
2060 .siz = STR_BUF_SIZ,
2061 };
2062 }
2063
2064 void
2065 sendbreak(const Arg *arg)
2066 {
2067 if (tcsendbreak(cmdfd, 0))
2068 perror("Error sending break");
2069 }
2070
2071 void
2072 tprinter(char *s, size_t len)
2073 {
2074 if (iofd != -1 && xwrite(iofd, s, len) < 0) {
2075 perror("Error writing to output file");
2076 close(iofd);
2077 iofd = -1;
2078 }
2079 }
2080
2081 void
2082 toggleprinter(const Arg *arg)
2083 {
2084 term.mode ^= MODE_PRINT;
2085 }
2086
2087 void
2088 printscreen(const Arg *arg)
2089 {
2090 tdump();
2091 }
2092
2093 void
2094 printsel(const Arg *arg)
2095 {
2096 tdumpsel();
2097 }
2098
2099 void
2100 tdumpsel(void)
2101 {
2102 char *ptr;
2103
2104 if ((ptr = getsel())) {
2105 tprinter(ptr, strlen(ptr));
2106 free(ptr);
2107 }
2108 }
2109
2110 void
2111 tdumpline(int n)
2112 {
2113 char buf[UTF_SIZ];
2114 const Glyph *bp, *end;
2115
2116 bp = &term.line[n][0];
2117 end = &bp[MIN(tlinelen(n), term.col) - 1];
2118 if (bp != end || bp->u != ' ') {
2119 for ( ; bp <= end; ++bp)
2120 tprinter(buf, utf8encode(bp->u, buf));
2121 }
2122 tprinter("\n", 1);
2123 }
2124
2125 void
2126 tdump(void)
2127 {
2128 int i;
2129
2130 for (i = 0; i < term.row; ++i)
2131 tdumpline(i);
2132 }
2133
2134 void
2135 tputtab(int n)
2136 {
2137 uint x = term.c.x;
2138
2139 if (n > 0) {
2140 while (x < term.col && n--)
2141 for (++x; x < term.col && !term.tabs[x]; ++x)
2142 /* nothing */ ;
2143 } else if (n < 0) {
2144 while (x > 0 && n++)
2145 for (--x; x > 0 && !term.tabs[x]; --x)
2146 /* nothing */ ;
2147 }
2148 term.c.x = LIMIT(x, 0, term.col-1);
2149 }
2150
2151 void
2152 tdefutf8(char ascii)
2153 {
2154 if (ascii == 'G')
2155 term.mode |= MODE_UTF8;
2156 else if (ascii == '@')
2157 term.mode &= ~MODE_UTF8;
2158 }
2159
2160 void
2161 tdeftran(char ascii)
2162 {
2163 static char cs[] = "0B";
2164 static int vcs[] = {CS_GRAPHIC0, CS_USA};
2165 char *p;
2166
2167 if ((p = strchr(cs, ascii)) == NULL) {
2168 fprintf(stderr, "esc unhandled charset: ESC ( %c\n", ascii);
2169 } else {
2170 term.trantbl[term.icharset] = vcs[p - cs];
2171 }
2172 }
2173
2174 void
2175 tdectest(char c)
2176 {
2177 int x, y;
2178
2179 if (c == '8') { /* DEC screen alignment test. */
2180 for (x = 0; x < term.col; ++x) {
2181 for (y = 0; y < term.row; ++y)
2182 tsetchar('E', &term.c.attr, x, y);
2183 }
2184 }
2185 }
2186
2187 void
2188 tstrsequence(uchar c)
2189 {
2190 switch (c) {
2191 case 0x90: /* DCS -- Device Control String */
2192 c = 'P';
2193 break;
2194 case 0x9f: /* APC -- Application Program Command */
2195 c = '_';
2196 break;
2197 case 0x9e: /* PM -- Privacy Message */
2198 c = '^';
2199 break;
2200 case 0x9d: /* OSC -- Operating System Command */
2201 c = ']';
2202 break;
2203 }
2204 strreset();
2205 strescseq.type = c;
2206 term.esc |= ESC_STR;
2207 }
2208
2209 void
2210 tcontrolcode(uchar ascii)
2211 {
2212 switch (ascii) {
2213 case '\t': /* HT */
2214 tputtab(1);
2215 return;
2216 case '\b': /* BS */
2217 tmoveto(term.c.x-1, term.c.y);
2218 return;
2219 case '\r': /* CR */
2220 tmoveto(0, term.c.y);
2221 return;
2222 case '\f': /* LF */
2223 case '\v': /* VT */
2224 case '\n': /* LF */
2225 /* go to first col if the mode is set */
2226 tnewline(IS_SET(MODE_CRLF));
2227 return;
2228 case '\a': /* BEL */
2229 if (term.esc & ESC_STR_END) {
2230 /* backwards compatibility to xterm */
2231 strhandle();
2232 } else {
2233 xbell();
2234 }
2235 break;
2236 case '\033': /* ESC */
2237 csireset();
2238 term.esc &= ~(ESC_CSI|ESC_ALTCHARSET|ESC_TEST);
2239 term.esc |= ESC_START;
2240 return;
2241 case '\016': /* SO (LS1 -- Locking shift 1) */
2242 case '\017': /* SI (LS0 -- Locking shift 0) */
2243 term.charset = 1 - (ascii - '\016');
2244 return;
2245 case '\032': /* SUB */
2246 tsetchar('?', &term.c.attr, term.c.x, term.c.y);
2247 /* FALLTHROUGH */
2248 case '\030': /* CAN */
2249 csireset();
2250 break;
2251 case '\005': /* ENQ (IGNORED) */
2252 case '\000': /* NUL (IGNORED) */
2253 case '\021': /* XON (IGNORED) */
2254 case '\023': /* XOFF (IGNORED) */
2255 case 0177: /* DEL (IGNORED) */
2256 return;
2257 case 0x80: /* TODO: PAD */
2258 case 0x81: /* TODO: HOP */
2259 case 0x82: /* TODO: BPH */
2260 case 0x83: /* TODO: NBH */
2261 case 0x84: /* TODO: IND */
2262 break;
2263 case 0x85: /* NEL -- Next line */
2264 tnewline(1); /* always go to first col */
2265 break;
2266 case 0x86: /* TODO: SSA */
2267 case 0x87: /* TODO: ESA */
2268 break;
2269 case 0x88: /* HTS -- Horizontal tab stop */
2270 term.tabs[term.c.x] = 1;
2271 break;
2272 case 0x89: /* TODO: HTJ */
2273 case 0x8a: /* TODO: VTS */
2274 case 0x8b: /* TODO: PLD */
2275 case 0x8c: /* TODO: PLU */
2276 case 0x8d: /* TODO: RI */
2277 case 0x8e: /* TODO: SS2 */
2278 case 0x8f: /* TODO: SS3 */
2279 case 0x91: /* TODO: PU1 */
2280 case 0x92: /* TODO: PU2 */
2281 case 0x93: /* TODO: STS */
2282 case 0x94: /* TODO: CCH */
2283 case 0x95: /* TODO: MW */
2284 case 0x96: /* TODO: SPA */
2285 case 0x97: /* TODO: EPA */
2286 case 0x98: /* TODO: SOS */
2287 case 0x99: /* TODO: SGCI */
2288 break;
2289 case 0x9a: /* DECID -- Identify Terminal */
2290 ttywrite(vtiden, strlen(vtiden), 0);
2291 break;
2292 case 0x9b: /* TODO: CSI */
2293 case 0x9c: /* TODO: ST */
2294 break;
2295 case 0x90: /* DCS -- Device Control String */
2296 case 0x9d: /* OSC -- Operating System Command */
2297 case 0x9e: /* PM -- Privacy Message */
2298 case 0x9f: /* APC -- Application Program Command */
2299 tstrsequence(ascii);
2300 return;
2301 }
2302 /* only CAN, SUB, \a and C1 chars interrupt a sequence */
2303 term.esc &= ~(ESC_STR_END|ESC_STR);
2304 }
2305
2306 /*
2307 * returns 1 when the sequence is finished and it hasn't to read
2308 * more characters for this sequence, otherwise 0
2309 */
2310 int
2311 eschandle(uchar ascii)
2312 {
2313 switch (ascii) {
2314 case '[':
2315 term.esc |= ESC_CSI;
2316 return 0;
2317 case '#':
2318 term.esc |= ESC_TEST;
2319 return 0;
2320 case '%':
2321 term.esc |= ESC_UTF8;
2322 return 0;
2323 case 'P': /* DCS -- Device Control String */
2324 case '_': /* APC -- Application Program Command */
2325 case '^': /* PM -- Privacy Message */
2326 case ']': /* OSC -- Operating System Command */
2327 case 'k': /* old title set compatibility */
2328 tstrsequence(ascii);
2329 return 0;
2330 case 'n': /* LS2 -- Locking shift 2 */
2331 case 'o': /* LS3 -- Locking shift 3 */
2332 term.charset = 2 + (ascii - 'n');
2333 break;
2334 case '(': /* GZD4 -- set primary charset G0 */
2335 case ')': /* G1D4 -- set secondary charset G1 */
2336 case '*': /* G2D4 -- set tertiary charset G2 */
2337 case '+': /* G3D4 -- set quaternary charset G3 */
2338 term.icharset = ascii - '(';
2339 term.esc |= ESC_ALTCHARSET;
2340 return 0;
2341 case 'D': /* IND -- Linefeed */
2342 if (term.c.y == term.bot) {
2343 tscrollup(term.top, 1);
2344 } else {
2345 tmoveto(term.c.x, term.c.y+1);
2346 }
2347 break;
2348 case 'E': /* NEL -- Next line */
2349 tnewline(1); /* always go to first col */
2350 break;
2351 case 'H': /* HTS -- Horizontal tab stop */
2352 term.tabs[term.c.x] = 1;
2353 break;
2354 case 'M': /* RI -- Reverse index */
2355 if (term.c.y == term.top) {
2356 tscrolldown(term.top, 1);
2357 } else {
2358 tmoveto(term.c.x, term.c.y-1);
2359 }
2360 break;
2361 case 'Z': /* DECID -- Identify Terminal */
2362 ttywrite(vtiden, strlen(vtiden), 0);
2363 break;
2364 case 'c': /* RIS -- Reset to initial state */
2365 treset();
2366 resettitle();
2367 xloadcols();
2368 xsetmode(0, MODE_HIDE);
2369 xsetmode(0, MODE_BRCKTPASTE);
2370 break;
2371 case '=': /* DECPAM -- Application keypad */
2372 xsetmode(1, MODE_APPKEYPAD);
2373 break;
2374 case '>': /* DECPNM -- Normal keypad */
2375 xsetmode(0, MODE_APPKEYPAD);
2376 break;
2377 case '7': /* DECSC -- Save Cursor */
2378 tcursor(CURSOR_SAVE);
2379 break;
2380 case '8': /* DECRC -- Restore Cursor */
2381 tcursor(CURSOR_LOAD);
2382 break;
2383 case '\\': /* ST -- String Terminator */
2384 if (term.esc & ESC_STR_END)
2385 strhandle();
2386 break;
2387 default:
2388 fprintf(stderr, "erresc: unknown sequence ESC 0x%02X '%c'\n",
2389 (uchar) ascii, isprint(ascii)? ascii:'.');
2390 break;
2391 }
2392 return 1;
2393 }
2394
2395 void
2396 tputc(Rune u)
2397 {
2398 char c[UTF_SIZ];
2399 int control;
2400 int width, len;
2401 Glyph *gp;
2402
2403 control = ISCONTROL(u);
2404 if (u < 127 || !IS_SET(MODE_UTF8)) {
2405 c[0] = u;
2406 width = len = 1;
2407 } else {
2408 len = utf8encode(u, c);
2409 if (!control && (width = wcwidth(u)) == -1)
2410 width = 1;
2411 }
2412
2413 if (IS_SET(MODE_PRINT))
2414 tprinter(c, len);
2415
2416 /*
2417 * STR sequence must be checked before anything else
2418 * because it uses all following characters until it
2419 * receives a ESC, a SUB, a ST or any other C1 control
2420 * character.
2421 */
2422 if (term.esc & ESC_STR) {
2423 if (u == '\a' || u == 030 || u == 032 || u == 033 ||
2424 ISCONTROLC1(u)) {
2425 term.esc &= ~(ESC_START|ESC_STR);
2426 term.esc |= ESC_STR_END;
2427 goto check_control_code;
2428 }
2429
2430 if (strescseq.len+len >= strescseq.siz) {
2431 /*
2432 * Here is a bug in terminals. If the user never sends
2433 * some code to stop the str or esc command, then st
2434 * will stop responding. But this is better than
2435 * silently failing with unknown characters. At least
2436 * then users will report back.
2437 *
2438 * In the case users ever get fixed, here is the code:
2439 */
2440 /*
2441 * term.esc = 0;
2442 * strhandle();
2443 */
2444 if (strescseq.siz > (SIZE_MAX - UTF_SIZ) / 2)
2445 return;
2446 strescseq.siz *= 2;
2447 strescseq.buf = xrealloc(strescseq.buf, strescseq.siz);
2448 }
2449
2450 memmove(&strescseq.buf[strescseq.len], c, len);
2451 strescseq.len += len;
2452 return;
2453 }
2454
2455 check_control_code:
2456 /*
2457 * Actions of control codes must be performed as soon they arrive
2458 * because they can be embedded inside a control sequence, and
2459 * they must not cause conflicts with sequences.
2460 */
2461 if (control) {
2462 /* in UTF-8 mode ignore handling C1 control characters */
2463 if (IS_SET(MODE_UTF8) && ISCONTROLC1(u))
2464 return;
2465 tcontrolcode(u);
2466 /*
2467 * control codes are not shown ever
2468 */
2469 if (!term.esc)
2470 term.lastc = 0;
2471 return;
2472 } else if (term.esc & ESC_START) {
2473 if (term.esc & ESC_CSI) {
2474 csiescseq.buf[csiescseq.len++] = u;
2475 if (BETWEEN(u, 0x40, 0x7E)
2476 || csiescseq.len >= \
2477 sizeof(csiescseq.buf)-1) {
2478 term.esc = 0;
2479 csiparse();
2480 csihandle();
2481 }
2482 return;
2483 } else if (term.esc & ESC_UTF8) {
2484 tdefutf8(u);
2485 } else if (term.esc & ESC_ALTCHARSET) {
2486 tdeftran(u);
2487 } else if (term.esc & ESC_TEST) {
2488 tdectest(u);
2489 } else {
2490 if (!eschandle(u))
2491 return;
2492 /* sequence already finished */
2493 }
2494 term.esc = 0;
2495 /*
2496 * All characters which form part of a sequence are not
2497 * printed
2498 */
2499 return;
2500 }
2501 if (selected(term.c.x, term.c.y))
2502 selclear();
2503
2504 gp = &term.line[term.c.y][term.c.x];
2505 if (IS_SET(MODE_WRAP) && (term.c.state & CURSOR_WRAPNEXT)) {
2506 gp->mode |= ATTR_WRAP;
2507 tnewline(1);
2508 gp = &term.line[term.c.y][term.c.x];
2509 }
2510
2511 if (IS_SET(MODE_INSERT) && term.c.x+width < term.col) {
2512 memmove(gp+width, gp, (term.col - term.c.x - width) * sizeof(Glyph));
2513 gp->mode &= ~ATTR_WIDE;
2514 }
2515
2516 if (term.c.x+width > term.col) {
2517 if (IS_SET(MODE_WRAP))
2518 tnewline(1);
2519 else
2520 tmoveto(term.col - width, term.c.y);
2521 gp = &term.line[term.c.y][term.c.x];
2522 }
2523
2524 tsetchar(u, &term.c.attr, term.c.x, term.c.y);
2525 term.lastc = u;
2526
2527 if (width == 2) {
2528 gp->mode |= ATTR_WIDE;
2529 if (term.c.x+1 < term.col) {
2530 if (gp[1].mode == ATTR_WIDE && term.c.x+2 < term.col) {
2531 gp[2].u = ' ';
2532 gp[2].mode &= ~ATTR_WDUMMY;
2533 }
2534 gp[1].u = '\0';
2535 gp[1].mode = ATTR_WDUMMY;
2536 }
2537 }
2538 if (term.c.x+width < term.col) {
2539 tmoveto(term.c.x+width, term.c.y);
2540 } else {
2541 term.c.state |= CURSOR_WRAPNEXT;
2542 }
2543 }
2544
2545 int
2546 twrite(const char *buf, int buflen, int show_ctrl)
2547 {
2548 int charsize;
2549 Rune u;
2550 int n;
2551
2552 for (n = 0; n < buflen; n += charsize) {
2553 if (IS_SET(MODE_UTF8)) {
2554 /* process a complete utf8 char */
2555 charsize = utf8decode(buf + n, &u, buflen - n);
2556 if (charsize == 0)
2557 break;
2558 } else {
2559 u = buf[n] & 0xFF;
2560 charsize = 1;
2561 }
2562 if (show_ctrl && ISCONTROL(u)) {
2563 if (u & 0x80) {
2564 u &= 0x7f;
2565 tputc('^');
2566 tputc('[');
2567 } else if (u != '\n' && u != '\r' && u != '\t') {
2568 u ^= 0x40;
2569 tputc('^');
2570 }
2571 }
2572 tputc(u);
2573 }
2574 return n;
2575 }
2576
2577 void
2578 tresize(int col, int row)
2579 {
2580 int i;
2581 int minrow = MIN(row, term.row);
2582 int mincol = MIN(col, term.col);
2583 int *bp;
2584 TCursor c;
2585
2586 if (col < 1 || row < 1) {
2587 fprintf(stderr,
2588 "tresize: error resizing to %dx%d\n", col, row);
2589 return;
2590 }
2591
2592 /*
2593 * slide screen to keep cursor where we expect it -
2594 * tscrollup would work here, but we can optimize to
2595 * memmove because we're freeing the earlier lines
2596 */
2597 for (i = 0; i <= term.c.y - row; i++) {
2598 free(term.line[i]);
2599 free(term.alt[i]);
2600 }
2601 /* ensure that both src and dst are not NULL */
2602 if (i > 0) {
2603 memmove(term.line, term.line + i, row * sizeof(Line));
2604 memmove(term.alt, term.alt + i, row * sizeof(Line));
2605 }
2606 for (i += row; i < term.row; i++) {
2607 free(term.line[i]);
2608 free(term.alt[i]);
2609 }
2610
2611 /* resize to new height */
2612 term.line = xrealloc(term.line, row * sizeof(Line));
2613 term.alt = xrealloc(term.alt, row * sizeof(Line));
2614 term.dirty = xrealloc(term.dirty, row * sizeof(*term.dirty));
2615 term.tabs = xrealloc(term.tabs, col * sizeof(*term.tabs));
2616
2617 /* resize each row to new width, zero-pad if needed */
2618 for (i = 0; i < minrow; i++) {
2619 term.line[i] = xrealloc(term.line[i], col * sizeof(Glyph));
2620 term.alt[i] = xrealloc(term.alt[i], col * sizeof(Glyph));
2621 }
2622
2623 /* allocate any new rows */
2624 for (/* i = minrow */; i < row; i++) {
2625 term.line[i] = xmalloc(col * sizeof(Glyph));
2626 term.alt[i] = xmalloc(col * sizeof(Glyph));
2627 }
2628 if (col > term.col) {
2629 bp = term.tabs + term.col;
2630
2631 memset(bp, 0, sizeof(*term.tabs) * (col - term.col));
2632 while (--bp > term.tabs && !*bp)
2633 /* nothing */ ;
2634 for (bp += tabspaces; bp < term.tabs + col; bp += tabspaces)
2635 *bp = 1;
2636 }
2637 /* update terminal size */
2638 term.col = col;
2639 term.row = row;
2640 /* reset scrolling region */
2641 tsetscroll(0, row-1);
2642 /* make use of the LIMIT in tmoveto */
2643 tmoveto(term.c.x, term.c.y);
2644 /* Clearing both screens (it makes dirty all lines) */
2645 c = term.c;
2646 for (i = 0; i < 2; i++) {
2647 if (mincol < col && 0 < minrow) {
2648 tclearregion(mincol, 0, col - 1, minrow - 1);
2649 }
2650 if (0 < col && minrow < row) {
2651 tclearregion(0, minrow, col - 1, row - 1);
2652 }
2653 tswapscreen();
2654 tcursor(CURSOR_LOAD);
2655 }
2656 term.c = c;
2657 }
2658
2659 void
2660 resettitle(void)
2661 {
2662 xsettitle(NULL);
2663 }
2664
2665 void
2666 drawregion(int x1, int y1, int x2, int y2)
2667 {
2668 int y;
2669
2670 for (y = y1; y < y2; y++) {
2671 if (!term.dirty[y])
2672 continue;
2673
2674 term.dirty[y] = 0;
2675 xdrawline(term.line[y], x1, y, x2);
2676 }
2677 }
2678
2679 void
2680 draw(void)
2681 {
2682 int cx = term.c.x, ocx = term.ocx, ocy = term.ocy;
2683
2684 if (!xstartdraw())
2685 return;
2686
2687 /* adjust cursor position */
2688 LIMIT(term.ocx, 0, term.col-1);
2689 LIMIT(term.ocy, 0, term.row-1);
2690 if (term.line[term.ocy][term.ocx].mode & ATTR_WDUMMY)
2691 term.ocx--;
2692 if (term.line[term.c.y][cx].mode & ATTR_WDUMMY)
2693 cx--;
2694
2695 drawregion(0, 0, term.col, term.row);
2696 xdrawcursor(cx, term.c.y, term.line[term.c.y][cx],
2697 term.ocx, term.ocy, term.line[term.ocy][term.ocx]);
2698 term.ocx = cx;
2699 term.ocy = term.c.y;
2700 xfinishdraw();
2701 if (ocx != term.ocx || ocy != term.ocy)
2702 xximspot(term.ocx, term.ocy);
2703 }
2704
2705 void
2706 redraw(void)
2707 {
2708 tfulldirt();
2709 draw();
2710 }