Xinqi Bao's Git

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