Xinqi Bao's Git

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