Xinqi Bao's Git

projects / st.git / blob


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