Xinqi Bao's Git

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