Xinqi Bao's Git

projects / st.git / blob


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