Xinqi Bao's Git

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