Xinqi Bao's Git

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