Xinqi Bao's Git

projects / st.git / blob


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