Xinqi Bao's Git

projects / st.git / blob


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