Xinqi Bao's Git

projects / st.git / blob


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