Xinqi Bao's Git

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