Xinqi Bao's Git

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