Xinqi Bao's Git

projects / st.git / blob


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