Xinqi Bao's Git

projects / st.git / blob


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