Xinqi Bao's Git

projects / st.git / blob
summary | log | commit | diff | tree
history | raw | HEAD
Remove the ISO 14755 feature
[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 finished with error '%d'\n", stat);
736 exit(0);
737 }
738
739 void
740 stty(char **args)
741 {
742 char cmd[_POSIX_ARG_MAX], **p, *q, *s;
743 size_t n, siz;
744
745 if ((n = strlen(stty_args)) > sizeof(cmd)-1)
746 die("incorrect stty parameters\n");
747 memcpy(cmd, stty_args, n);
748 q = cmd + n;
749 siz = sizeof(cmd) - n;
750 for (p = args; p && (s = *p); ++p) {
751 if ((n = strlen(s)) > siz-1)
752 die("stty parameter length too long\n");
753 *q++ = ' ';
754 memcpy(q, s, n);
755 q += n;
756 siz -= n + 1;
757 }
758 *q = '\0';
759 if (system(cmd) != 0)
760 perror("Couldn't call stty");
761 }
762
763 int
764 ttynew(char *line, char *cmd, char *out, char **args)
765 {
766 int m, s;
767
768 if (out) {
769 term.mode |= MODE_PRINT;
770 iofd = (!strcmp(out, "-")) ?
771 1 : open(out, O_WRONLY | O_CREAT, 0666);
772 if (iofd < 0) {
773 fprintf(stderr, "Error opening %s:%s\n",
774 out, strerror(errno));
775 }
776 }
777
778 if (line) {
779 if ((cmdfd = open(line, O_RDWR)) < 0)
780 die("open line '%s' failed: %s\n",
781 line, strerror(errno));
782 dup2(cmdfd, 0);
783 stty(args);
784 return cmdfd;
785 }
786
787 /* seems to work fine on linux, openbsd and freebsd */
788 if (openpty(&m, &s, NULL, NULL, NULL) < 0)
789 die("openpty failed: %s\n", strerror(errno));
790
791 switch (pid = fork()) {
792 case -1:
793 die("fork failed: %s\n", strerror(errno));
794 break;
795 case 0:
796 close(iofd);
797 setsid(); /* create a new process group */
798 dup2(s, 0);
799 dup2(s, 1);
800 dup2(s, 2);
801 if (ioctl(s, TIOCSCTTY, NULL) < 0)
802 die("ioctl TIOCSCTTY failed: %s\n", strerror(errno));
803 close(s);
804 close(m);
805 #ifdef __OpenBSD__
806 if (pledge("stdio getpw proc exec", NULL) == -1)
807 die("pledge\n");
808 #endif
809 execsh(cmd, args);
810 break;
811 default:
812 #ifdef __OpenBSD__
813 if (pledge("stdio rpath tty proc", NULL) == -1)
814 die("pledge\n");
815 #endif
816 close(s);
817 cmdfd = m;
818 signal(SIGCHLD, sigchld);
819 break;
820 }
821 return cmdfd;
822 }
823
824 size_t
825 ttyread(void)
826 {
827 static char buf[BUFSIZ];
828 static int buflen = 0;
829 int written;
830 int ret;
831
832 /* append read bytes to unprocessed bytes */
833 if ((ret = read(cmdfd, buf+buflen, LEN(buf)-buflen)) < 0)
834 die("couldn't read from shell: %s\n", strerror(errno));
835 buflen += ret;
836
837 written = twrite(buf, buflen, 0);
838 buflen -= written;
839 /* keep any uncomplete utf8 char for the next call */
840 if (buflen > 0)
841 memmove(buf, buf + written, buflen);
842
843 return ret;
844 }
845
846 void
847 ttywrite(const char *s, size_t n, int may_echo)
848 {
849 const char *next;
850
851 if (may_echo && IS_SET(MODE_ECHO))
852 twrite(s, n, 1);
853
854 if (!IS_SET(MODE_CRLF)) {
855 ttywriteraw(s, n);
856 return;
857 }
858
859 /* This is similar to how the kernel handles ONLCR for ttys */
860 while (n > 0) {
861 if (*s == '\r') {
862 next = s + 1;
863 ttywriteraw("\r\n", 2);
864 } else {
865 next = memchr(s, '\r', n);
866 DEFAULT(next, s + n);
867 ttywriteraw(s, next - s);
868 }
869 n -= next - s;
870 s = next;
871 }
872 }
873
874 void
875 ttywriteraw(const char *s, size_t n)
876 {
877 fd_set wfd, rfd;
878 ssize_t r;
879 size_t lim = 256;
880
881 /*
882 * Remember that we are using a pty, which might be a modem line.
883 * Writing too much will clog the line. That's why we are doing this
884 * dance.
885 * FIXME: Migrate the world to Plan 9.
886 */
887 while (n > 0) {
888 FD_ZERO(&wfd);
889 FD_ZERO(&rfd);
890 FD_SET(cmdfd, &wfd);
891 FD_SET(cmdfd, &rfd);
892
893 /* Check if we can write. */
894 if (pselect(cmdfd+1, &rfd, &wfd, NULL, NULL, NULL) < 0) {
895 if (errno == EINTR)
896 continue;
897 die("select failed: %s\n", strerror(errno));
898 }
899 if (FD_ISSET(cmdfd, &wfd)) {
900 /*
901 * Only write the bytes written by ttywrite() or the
902 * default of 256. This seems to be a reasonable value
903 * for a serial line. Bigger values might clog the I/O.
904 */
905 if ((r = write(cmdfd, s, (n < lim)? n : lim)) < 0)
906 goto write_error;
907 if (r < n) {
908 /*
909 * We weren't able to write out everything.
910 * This means the buffer is getting full
911 * again. Empty it.
912 */
913 if (n < lim)
914 lim = ttyread();
915 n -= r;
916 s += r;
917 } else {
918 /* All bytes have been written. */
919 break;
920 }
921 }
922 if (FD_ISSET(cmdfd, &rfd))
923 lim = ttyread();
924 }
925 return;
926
927 write_error:
928 die("write error on tty: %s\n", strerror(errno));
929 }
930
931 void
932 ttyresize(int tw, int th)
933 {
934 struct winsize w;
935
936 w.ws_row = term.row;
937 w.ws_col = term.col;
938 w.ws_xpixel = tw;
939 w.ws_ypixel = th;
940 if (ioctl(cmdfd, TIOCSWINSZ, &w) < 0)
941 fprintf(stderr, "Couldn't set window size: %s\n", strerror(errno));
942 }
943
944 void
945 ttyhangup()
946 {
947 /* Send SIGHUP to shell */
948 kill(pid, SIGHUP);
949 }
950
951 int
952 tattrset(int attr)
953 {
954 int i, j;
955
956 for (i = 0; i < term.row-1; i++) {
957 for (j = 0; j < term.col-1; j++) {
958 if (term.line[i][j].mode & attr)
959 return 1;
960 }
961 }
962
963 return 0;
964 }
965
966 void
967 tsetdirt(int top, int bot)
968 {
969 int i;
970
971 LIMIT(top, 0, term.row-1);
972 LIMIT(bot, 0, term.row-1);
973
974 for (i = top; i <= bot; i++)
975 term.dirty[i] = 1;
976 }
977
978 void
979 tsetdirtattr(int attr)
980 {
981 int i, j;
982
983 for (i = 0; i < term.row-1; i++) {
984 for (j = 0; j < term.col-1; j++) {
985 if (term.line[i][j].mode & attr) {
986 tsetdirt(i, i);
987 break;
988 }
989 }
990 }
991 }
992
993 void
994 tfulldirt(void)
995 {
996 tsetdirt(0, term.row-1);
997 }
998
999 void
1000 tcursor(int mode)
1001 {
1002 static TCursor c[2];
1003 int alt = IS_SET(MODE_ALTSCREEN);
1004
1005 if (mode == CURSOR_SAVE) {
1006 c[alt] = term.c;
1007 } else if (mode == CURSOR_LOAD) {
1008 term.c = c[alt];
1009 tmoveto(c[alt].x, c[alt].y);
1010 }
1011 }
1012
1013 void
1014 treset(void)
1015 {
1016 uint i;
1017
1018 term.c = (TCursor){{
1019 .mode = ATTR_NULL,
1020 .fg = defaultfg,
1021 .bg = defaultbg
1022 }, .x = 0, .y = 0, .state = CURSOR_DEFAULT};
1023
1024 memset(term.tabs, 0, term.col * sizeof(*term.tabs));
1025 for (i = tabspaces; i < term.col; i += tabspaces)
1026 term.tabs[i] = 1;
1027 term.top = 0;
1028 term.bot = term.row - 1;
1029 term.mode = MODE_WRAP|MODE_UTF8;
1030 memset(term.trantbl, CS_USA, sizeof(term.trantbl));
1031 term.charset = 0;
1032
1033 for (i = 0; i < 2; i++) {
1034 tmoveto(0, 0);
1035 tcursor(CURSOR_SAVE);
1036 tclearregion(0, 0, term.col-1, term.row-1);
1037 tswapscreen();
1038 }
1039 }
1040
1041 void
1042 tnew(int col, int row)
1043 {
1044 term = (Term){ .c = { .attr = { .fg = defaultfg, .bg = defaultbg } } };
1045 tresize(col, row);
1046 treset();
1047 }
1048
1049 void
1050 tswapscreen(void)
1051 {
1052 Line *tmp = term.line;
1053
1054 term.line = term.alt;
1055 term.alt = tmp;
1056 term.mode ^= MODE_ALTSCREEN;
1057 tfulldirt();
1058 }
1059
1060 void
1061 tscrolldown(int orig, int n)
1062 {
1063 int i;
1064 Line temp;
1065
1066 LIMIT(n, 0, term.bot-orig+1);
1067
1068 tsetdirt(orig, term.bot-n);
1069 tclearregion(0, term.bot-n+1, term.col-1, term.bot);
1070
1071 for (i = term.bot; i >= orig+n; i--) {
1072 temp = term.line[i];
1073 term.line[i] = term.line[i-n];
1074 term.line[i-n] = temp;
1075 }
1076
1077 selscroll(orig, n);
1078 }
1079
1080 void
1081 tscrollup(int orig, int n)
1082 {
1083 int i;
1084 Line temp;
1085
1086 LIMIT(n, 0, term.bot-orig+1);
1087
1088 tclearregion(0, orig, term.col-1, orig+n-1);
1089 tsetdirt(orig+n, term.bot);
1090
1091 for (i = orig; i <= term.bot-n; i++) {
1092 temp = term.line[i];
1093 term.line[i] = term.line[i+n];
1094 term.line[i+n] = temp;
1095 }
1096
1097 selscroll(orig, -n);
1098 }
1099
1100 void
1101 selscroll(int orig, int n)
1102 {
1103 if (sel.ob.x == -1)
1104 return;
1105
1106 if (BETWEEN(sel.ob.y, orig, term.bot) || BETWEEN(sel.oe.y, orig, term.bot)) {
1107 if ((sel.ob.y += n) > term.bot || (sel.oe.y += n) < term.top) {
1108 selclear();
1109 return;
1110 }
1111 if (sel.type == SEL_RECTANGULAR) {
1112 if (sel.ob.y < term.top)
1113 sel.ob.y = term.top;
1114 if (sel.oe.y > term.bot)
1115 sel.oe.y = term.bot;
1116 } else {
1117 if (sel.ob.y < term.top) {
1118 sel.ob.y = term.top;
1119 sel.ob.x = 0;
1120 }
1121 if (sel.oe.y > term.bot) {
1122 sel.oe.y = term.bot;
1123 sel.oe.x = term.col;
1124 }
1125 }
1126 selnormalize();
1127 }
1128 }
1129
1130 void
1131 tnewline(int first_col)
1132 {
1133 int y = term.c.y;
1134
1135 if (y == term.bot) {
1136 tscrollup(term.top, 1);
1137 } else {
1138 y++;
1139 }
1140 tmoveto(first_col ? 0 : term.c.x, y);
1141 }
1142
1143 void
1144 csiparse(void)
1145 {
1146 char *p = csiescseq.buf, *np;
1147 long int v;
1148
1149 csiescseq.narg = 0;
1150 if (*p == '?') {
1151 csiescseq.priv = 1;
1152 p++;
1153 }
1154
1155 csiescseq.buf[csiescseq.len] = '\0';
1156 while (p < csiescseq.buf+csiescseq.len) {
1157 np = NULL;
1158 v = strtol(p, &np, 10);
1159 if (np == p)
1160 v = 0;
1161 if (v == LONG_MAX || v == LONG_MIN)
1162 v = -1;
1163 csiescseq.arg[csiescseq.narg++] = v;
1164 p = np;
1165 if (*p != ';' || csiescseq.narg == ESC_ARG_SIZ)
1166 break;
1167 p++;
1168 }
1169 csiescseq.mode[0] = *p++;
1170 csiescseq.mode[1] = (p < csiescseq.buf+csiescseq.len) ? *p : '\0';
1171 }
1172
1173 /* for absolute user moves, when decom is set */
1174 void
1175 tmoveato(int x, int y)
1176 {
1177 tmoveto(x, y + ((term.c.state & CURSOR_ORIGIN) ? term.top: 0));
1178 }
1179
1180 void
1181 tmoveto(int x, int y)
1182 {
1183 int miny, maxy;
1184
1185 if (term.c.state & CURSOR_ORIGIN) {
1186 miny = term.top;
1187 maxy = term.bot;
1188 } else {
1189 miny = 0;
1190 maxy = term.row - 1;
1191 }
1192 term.c.state &= ~CURSOR_WRAPNEXT;
1193 term.c.x = LIMIT(x, 0, term.col-1);
1194 term.c.y = LIMIT(y, miny, maxy);
1195 }
1196
1197 void
1198 tsetchar(Rune u, Glyph *attr, int x, int y)
1199 {
1200 static char *vt100_0[62] = { /* 0x41 - 0x7e */
1201 "↑", "↓", "→", "←", "█", "▚", "☃", /* A - G */
1202 0, 0, 0, 0, 0, 0, 0, 0, /* H - O */
1203 0, 0, 0, 0, 0, 0, 0, 0, /* P - W */
1204 0, 0, 0, 0, 0, 0, 0, " ", /* X - _ */
1205 "◆", "▒", "␉", "␌", "␍", "␊", "°", "±", /* ` - g */
1206 "␤", "␋", "┘", "┐", "┌", "└", "┼", "⎺", /* h - o */
1207 "⎻", "─", "⎼", "⎽", "├", "┤", "┴", "┬", /* p - w */
1208 "│", "≤", "≥", "π", "≠", "£", "·", /* x - ~ */
1209 };
1210
1211 /*
1212 * The table is proudly stolen from rxvt.
1213 */
1214 if (term.trantbl[term.charset] == CS_GRAPHIC0 &&
1215 BETWEEN(u, 0x41, 0x7e) && vt100_0[u - 0x41])
1216 utf8decode(vt100_0[u - 0x41], &u, UTF_SIZ);
1217
1218 if (term.line[y][x].mode & ATTR_WIDE) {
1219 if (x+1 < term.col) {
1220 term.line[y][x+1].u = ' ';
1221 term.line[y][x+1].mode &= ~ATTR_WDUMMY;
1222 }
1223 } else if (term.line[y][x].mode & ATTR_WDUMMY) {
1224 term.line[y][x-1].u = ' ';
1225 term.line[y][x-1].mode &= ~ATTR_WIDE;
1226 }
1227
1228 term.dirty[y] = 1;
1229 term.line[y][x] = *attr;
1230 term.line[y][x].u = u;
1231 }
1232
1233 void
1234 tclearregion(int x1, int y1, int x2, int y2)
1235 {
1236 int x, y, temp;
1237 Glyph *gp;
1238
1239 if (x1 > x2)
1240 temp = x1, x1 = x2, x2 = temp;
1241 if (y1 > y2)
1242 temp = y1, y1 = y2, y2 = temp;
1243
1244 LIMIT(x1, 0, term.col-1);
1245 LIMIT(x2, 0, term.col-1);
1246 LIMIT(y1, 0, term.row-1);
1247 LIMIT(y2, 0, term.row-1);
1248
1249 for (y = y1; y <= y2; y++) {
1250 term.dirty[y] = 1;
1251 for (x = x1; x <= x2; x++) {
1252 gp = &term.line[y][x];
1253 if (selected(x, y))
1254 selclear();
1255 gp->fg = term.c.attr.fg;
1256 gp->bg = term.c.attr.bg;
1257 gp->mode = 0;
1258 gp->u = ' ';
1259 }
1260 }
1261 }
1262
1263 void
1264 tdeletechar(int n)
1265 {
1266 int dst, src, size;
1267 Glyph *line;
1268
1269 LIMIT(n, 0, term.col - term.c.x);
1270
1271 dst = term.c.x;
1272 src = term.c.x + n;
1273 size = term.col - src;
1274 line = term.line[term.c.y];
1275
1276 memmove(&line[dst], &line[src], size * sizeof(Glyph));
1277 tclearregion(term.col-n, term.c.y, term.col-1, term.c.y);
1278 }
1279
1280 void
1281 tinsertblank(int n)
1282 {
1283 int dst, src, size;
1284 Glyph *line;
1285
1286 LIMIT(n, 0, term.col - term.c.x);
1287
1288 dst = term.c.x + n;
1289 src = term.c.x;
1290 size = term.col - dst;
1291 line = term.line[term.c.y];
1292
1293 memmove(&line[dst], &line[src], size * sizeof(Glyph));
1294 tclearregion(src, term.c.y, dst - 1, term.c.y);
1295 }
1296
1297 void
1298 tinsertblankline(int n)
1299 {
1300 if (BETWEEN(term.c.y, term.top, term.bot))
1301 tscrolldown(term.c.y, n);
1302 }
1303
1304 void
1305 tdeleteline(int n)
1306 {
1307 if (BETWEEN(term.c.y, term.top, term.bot))
1308 tscrollup(term.c.y, n);
1309 }
1310
1311 int32_t
1312 tdefcolor(int *attr, int *npar, int l)
1313 {
1314 int32_t idx = -1;
1315 uint r, g, b;
1316
1317 switch (attr[*npar + 1]) {
1318 case 2: /* direct color in RGB space */
1319 if (*npar + 4 >= l) {
1320 fprintf(stderr,
1321 "erresc(38): Incorrect number of parameters (%d)\n",
1322 *npar);
1323 break;
1324 }
1325 r = attr[*npar + 2];
1326 g = attr[*npar + 3];
1327 b = attr[*npar + 4];
1328 *npar += 4;
1329 if (!BETWEEN(r, 0, 255) || !BETWEEN(g, 0, 255) || !BETWEEN(b, 0, 255))
1330 fprintf(stderr, "erresc: bad rgb color (%u,%u,%u)\n",
1331 r, g, b);
1332 else
1333 idx = TRUECOLOR(r, g, b);
1334 break;
1335 case 5: /* indexed color */
1336 if (*npar + 2 >= l) {
1337 fprintf(stderr,
1338 "erresc(38): Incorrect number of parameters (%d)\n",
1339 *npar);
1340 break;
1341 }
1342 *npar += 2;
1343 if (!BETWEEN(attr[*npar], 0, 255))
1344 fprintf(stderr, "erresc: bad fgcolor %d\n", attr[*npar]);
1345 else
1346 idx = attr[*npar];
1347 break;
1348 case 0: /* implemented defined (only foreground) */
1349 case 1: /* transparent */
1350 case 3: /* direct color in CMY space */
1351 case 4: /* direct color in CMYK space */
1352 default:
1353 fprintf(stderr,
1354 "erresc(38): gfx attr %d unknown\n", attr[*npar]);
1355 break;
1356 }
1357
1358 return idx;
1359 }
1360
1361 void
1362 tsetattr(int *attr, int l)
1363 {
1364 int i;
1365 int32_t idx;
1366
1367 for (i = 0; i < l; i++) {
1368 switch (attr[i]) {
1369 case 0:
1370 term.c.attr.mode &= ~(
1371 ATTR_BOLD |
1372 ATTR_FAINT |
1373 ATTR_ITALIC |
1374 ATTR_UNDERLINE |
1375 ATTR_BLINK |
1376 ATTR_REVERSE |
1377 ATTR_INVISIBLE |
1378 ATTR_STRUCK );
1379 term.c.attr.fg = defaultfg;
1380 term.c.attr.bg = defaultbg;
1381 break;
1382 case 1:
1383 term.c.attr.mode |= ATTR_BOLD;
1384 break;
1385 case 2:
1386 term.c.attr.mode |= ATTR_FAINT;
1387 break;
1388 case 3:
1389 term.c.attr.mode |= ATTR_ITALIC;
1390 break;
1391 case 4:
1392 term.c.attr.mode |= ATTR_UNDERLINE;
1393 break;
1394 case 5: /* slow blink */
1395 /* FALLTHROUGH */
1396 case 6: /* rapid blink */
1397 term.c.attr.mode |= ATTR_BLINK;
1398 break;
1399 case 7:
1400 term.c.attr.mode |= ATTR_REVERSE;
1401 break;
1402 case 8:
1403 term.c.attr.mode |= ATTR_INVISIBLE;
1404 break;
1405 case 9:
1406 term.c.attr.mode |= ATTR_STRUCK;
1407 break;
1408 case 22:
1409 term.c.attr.mode &= ~(ATTR_BOLD | ATTR_FAINT);
1410 break;
1411 case 23:
1412 term.c.attr.mode &= ~ATTR_ITALIC;
1413 break;
1414 case 24:
1415 term.c.attr.mode &= ~ATTR_UNDERLINE;
1416 break;
1417 case 25:
1418 term.c.attr.mode &= ~ATTR_BLINK;
1419 break;
1420 case 27:
1421 term.c.attr.mode &= ~ATTR_REVERSE;
1422 break;
1423 case 28:
1424 term.c.attr.mode &= ~ATTR_INVISIBLE;
1425 break;
1426 case 29:
1427 term.c.attr.mode &= ~ATTR_STRUCK;
1428 break;
1429 case 38:
1430 if ((idx = tdefcolor(attr, &i, l)) >= 0)
1431 term.c.attr.fg = idx;
1432 break;
1433 case 39:
1434 term.c.attr.fg = defaultfg;
1435 break;
1436 case 48:
1437 if ((idx = tdefcolor(attr, &i, l)) >= 0)
1438 term.c.attr.bg = idx;
1439 break;
1440 case 49:
1441 term.c.attr.bg = defaultbg;
1442 break;
1443 default:
1444 if (BETWEEN(attr[i], 30, 37)) {
1445 term.c.attr.fg = attr[i] - 30;
1446 } else if (BETWEEN(attr[i], 40, 47)) {
1447 term.c.attr.bg = attr[i] - 40;
1448 } else if (BETWEEN(attr[i], 90, 97)) {
1449 term.c.attr.fg = attr[i] - 90 + 8;
1450 } else if (BETWEEN(attr[i], 100, 107)) {
1451 term.c.attr.bg = attr[i] - 100 + 8;
1452 } else {
1453 fprintf(stderr,
1454 "erresc(default): gfx attr %d unknown\n",
1455 attr[i]), csidump();
1456 }
1457 break;
1458 }
1459 }
1460 }
1461
1462 void
1463 tsetscroll(int t, int b)
1464 {
1465 int temp;
1466
1467 LIMIT(t, 0, term.row-1);
1468 LIMIT(b, 0, term.row-1);
1469 if (t > b) {
1470 temp = t;
1471 t = b;
1472 b = temp;
1473 }
1474 term.top = t;
1475 term.bot = b;
1476 }
1477
1478 void
1479 tsetmode(int priv, int set, int *args, int narg)
1480 {
1481 int alt, *lim;
1482
1483 for (lim = args + narg; args < lim; ++args) {
1484 if (priv) {
1485 switch (*args) {
1486 case 1: /* DECCKM -- Cursor key */
1487 xsetmode(set, MODE_APPCURSOR);
1488 break;
1489 case 5: /* DECSCNM -- Reverse video */
1490 xsetmode(set, MODE_REVERSE);
1491 break;
1492 case 6: /* DECOM -- Origin */
1493 MODBIT(term.c.state, set, CURSOR_ORIGIN);
1494 tmoveato(0, 0);
1495 break;
1496 case 7: /* DECAWM -- Auto wrap */
1497 MODBIT(term.mode, set, MODE_WRAP);
1498 break;
1499 case 0: /* Error (IGNORED) */
1500 case 2: /* DECANM -- ANSI/VT52 (IGNORED) */
1501 case 3: /* DECCOLM -- Column (IGNORED) */
1502 case 4: /* DECSCLM -- Scroll (IGNORED) */
1503 case 8: /* DECARM -- Auto repeat (IGNORED) */
1504 case 18: /* DECPFF -- Printer feed (IGNORED) */
1505 case 19: /* DECPEX -- Printer extent (IGNORED) */
1506 case 42: /* DECNRCM -- National characters (IGNORED) */
1507 case 12: /* att610 -- Start blinking cursor (IGNORED) */
1508 break;
1509 case 25: /* DECTCEM -- Text Cursor Enable Mode */
1510 xsetmode(!set, MODE_HIDE);
1511 break;
1512 case 9: /* X10 mouse compatibility mode */
1513 xsetpointermotion(0);
1514 xsetmode(0, MODE_MOUSE);
1515 xsetmode(set, MODE_MOUSEX10);
1516 break;
1517 case 1000: /* 1000: report button press */
1518 xsetpointermotion(0);
1519 xsetmode(0, MODE_MOUSE);
1520 xsetmode(set, MODE_MOUSEBTN);
1521 break;
1522 case 1002: /* 1002: report motion on button press */
1523 xsetpointermotion(0);
1524 xsetmode(0, MODE_MOUSE);
1525 xsetmode(set, MODE_MOUSEMOTION);
1526 break;
1527 case 1003: /* 1003: enable all mouse motions */
1528 xsetpointermotion(set);
1529 xsetmode(0, MODE_MOUSE);
1530 xsetmode(set, MODE_MOUSEMANY);
1531 break;
1532 case 1004: /* 1004: send focus events to tty */
1533 xsetmode(set, MODE_FOCUS);
1534 break;
1535 case 1006: /* 1006: extended reporting mode */
1536 xsetmode(set, MODE_MOUSESGR);
1537 break;
1538 case 1034:
1539 xsetmode(set, MODE_8BIT);
1540 break;
1541 case 1049: /* swap screen & set/restore cursor as xterm */
1542 if (!allowaltscreen)
1543 break;
1544 tcursor((set) ? CURSOR_SAVE : CURSOR_LOAD);
1545 /* FALLTHROUGH */
1546 case 47: /* swap screen */
1547 case 1047:
1548 if (!allowaltscreen)
1549 break;
1550 alt = IS_SET(MODE_ALTSCREEN);
1551 if (alt) {
1552 tclearregion(0, 0, term.col-1,
1553 term.row-1);
1554 }
1555 if (set ^ alt) /* set is always 1 or 0 */
1556 tswapscreen();
1557 if (*args != 1049)
1558 break;
1559 /* FALLTHROUGH */
1560 case 1048:
1561 tcursor((set) ? CURSOR_SAVE : CURSOR_LOAD);
1562 break;
1563 case 2004: /* 2004: bracketed paste mode */
1564 xsetmode(set, MODE_BRCKTPASTE);
1565 break;
1566 /* Not implemented mouse modes. See comments there. */
1567 case 1001: /* mouse highlight mode; can hang the
1568 terminal by design when implemented. */
1569 case 1005: /* UTF-8 mouse mode; will confuse
1570 applications not supporting UTF-8
1571 and luit. */
1572 case 1015: /* urxvt mangled mouse mode; incompatible
1573 and can be mistaken for other control
1574 codes. */
1575 default:
1576 fprintf(stderr,
1577 "erresc: unknown private set/reset mode %d\n",
1578 *args);
1579 break;
1580 }
1581 } else {
1582 switch (*args) {
1583 case 0: /* Error (IGNORED) */
1584 break;
1585 case 2:
1586 xsetmode(set, MODE_KBDLOCK);
1587 break;
1588 case 4: /* IRM -- Insertion-replacement */
1589 MODBIT(term.mode, set, MODE_INSERT);
1590 break;
1591 case 12: /* SRM -- Send/Receive */
1592 MODBIT(term.mode, !set, MODE_ECHO);
1593 break;
1594 case 20: /* LNM -- Linefeed/new line */
1595 MODBIT(term.mode, set, MODE_CRLF);
1596 break;
1597 default:
1598 fprintf(stderr,
1599 "erresc: unknown set/reset mode %d\n",
1600 *args);
1601 break;
1602 }
1603 }
1604 }
1605 }
1606
1607 void
1608 csihandle(void)
1609 {
1610 char buf[40];
1611 int len;
1612
1613 switch (csiescseq.mode[0]) {
1614 default:
1615 unknown:
1616 fprintf(stderr, "erresc: unknown csi ");
1617 csidump();
1618 /* die(""); */
1619 break;
1620 case '@': /* ICH -- Insert <n> blank char */
1621 DEFAULT(csiescseq.arg[0], 1);
1622 tinsertblank(csiescseq.arg[0]);
1623 break;
1624 case 'A': /* CUU -- Cursor <n> Up */
1625 DEFAULT(csiescseq.arg[0], 1);
1626 tmoveto(term.c.x, term.c.y-csiescseq.arg[0]);
1627 break;
1628 case 'B': /* CUD -- Cursor <n> Down */
1629 case 'e': /* VPR --Cursor <n> Down */
1630 DEFAULT(csiescseq.arg[0], 1);
1631 tmoveto(term.c.x, term.c.y+csiescseq.arg[0]);
1632 break;
1633 case 'i': /* MC -- Media Copy */
1634 switch (csiescseq.arg[0]) {
1635 case 0:
1636 tdump();
1637 break;
1638 case 1:
1639 tdumpline(term.c.y);
1640 break;
1641 case 2:
1642 tdumpsel();
1643 break;
1644 case 4:
1645 term.mode &= ~MODE_PRINT;
1646 break;
1647 case 5:
1648 term.mode |= MODE_PRINT;
1649 break;
1650 }
1651 break;
1652 case 'c': /* DA -- Device Attributes */
1653 if (csiescseq.arg[0] == 0)
1654 ttywrite(vtiden, strlen(vtiden), 0);
1655 break;
1656 case 'C': /* CUF -- Cursor <n> Forward */
1657 case 'a': /* HPR -- Cursor <n> Forward */
1658 DEFAULT(csiescseq.arg[0], 1);
1659 tmoveto(term.c.x+csiescseq.arg[0], term.c.y);
1660 break;
1661 case 'D': /* CUB -- Cursor <n> Backward */
1662 DEFAULT(csiescseq.arg[0], 1);
1663 tmoveto(term.c.x-csiescseq.arg[0], term.c.y);
1664 break;
1665 case 'E': /* CNL -- Cursor <n> Down and first col */
1666 DEFAULT(csiescseq.arg[0], 1);
1667 tmoveto(0, term.c.y+csiescseq.arg[0]);
1668 break;
1669 case 'F': /* CPL -- Cursor <n> Up and first col */
1670 DEFAULT(csiescseq.arg[0], 1);
1671 tmoveto(0, term.c.y-csiescseq.arg[0]);
1672 break;
1673 case 'g': /* TBC -- Tabulation clear */
1674 switch (csiescseq.arg[0]) {
1675 case 0: /* clear current tab stop */
1676 term.tabs[term.c.x] = 0;
1677 break;
1678 case 3: /* clear all the tabs */
1679 memset(term.tabs, 0, term.col * sizeof(*term.tabs));
1680 break;
1681 default:
1682 goto unknown;
1683 }
1684 break;
1685 case 'G': /* CHA -- Move to <col> */
1686 case '`': /* HPA */
1687 DEFAULT(csiescseq.arg[0], 1);
1688 tmoveto(csiescseq.arg[0]-1, term.c.y);
1689 break;
1690 case 'H': /* CUP -- Move to <row> <col> */
1691 case 'f': /* HVP */
1692 DEFAULT(csiescseq.arg[0], 1);
1693 DEFAULT(csiescseq.arg[1], 1);
1694 tmoveato(csiescseq.arg[1]-1, csiescseq.arg[0]-1);
1695 break;
1696 case 'I': /* CHT -- Cursor Forward Tabulation <n> tab stops */
1697 DEFAULT(csiescseq.arg[0], 1);
1698 tputtab(csiescseq.arg[0]);
1699 break;
1700 case 'J': /* ED -- Clear screen */
1701 switch (csiescseq.arg[0]) {
1702 case 0: /* below */
1703 tclearregion(term.c.x, term.c.y, term.col-1, term.c.y);
1704 if (term.c.y < term.row-1) {
1705 tclearregion(0, term.c.y+1, term.col-1,
1706 term.row-1);
1707 }
1708 break;
1709 case 1: /* above */
1710 if (term.c.y > 1)
1711 tclearregion(0, 0, term.col-1, term.c.y-1);
1712 tclearregion(0, term.c.y, term.c.x, term.c.y);
1713 break;
1714 case 2: /* all */
1715 tclearregion(0, 0, term.col-1, term.row-1);
1716 break;
1717 default:
1718 goto unknown;
1719 }
1720 break;
1721 case 'K': /* EL -- Clear line */
1722 switch (csiescseq.arg[0]) {
1723 case 0: /* right */
1724 tclearregion(term.c.x, term.c.y, term.col-1,
1725 term.c.y);
1726 break;
1727 case 1: /* left */
1728 tclearregion(0, term.c.y, term.c.x, term.c.y);
1729 break;
1730 case 2: /* all */
1731 tclearregion(0, term.c.y, term.col-1, term.c.y);
1732 break;
1733 }
1734 break;
1735 case 'S': /* SU -- Scroll <n> line up */
1736 DEFAULT(csiescseq.arg[0], 1);
1737 tscrollup(term.top, csiescseq.arg[0]);
1738 break;
1739 case 'T': /* SD -- Scroll <n> line down */
1740 DEFAULT(csiescseq.arg[0], 1);
1741 tscrolldown(term.top, csiescseq.arg[0]);
1742 break;
1743 case 'L': /* IL -- Insert <n> blank lines */
1744 DEFAULT(csiescseq.arg[0], 1);
1745 tinsertblankline(csiescseq.arg[0]);
1746 break;
1747 case 'l': /* RM -- Reset Mode */
1748 tsetmode(csiescseq.priv, 0, csiescseq.arg, csiescseq.narg);
1749 break;
1750 case 'M': /* DL -- Delete <n> lines */
1751 DEFAULT(csiescseq.arg[0], 1);
1752 tdeleteline(csiescseq.arg[0]);
1753 break;
1754 case 'X': /* ECH -- Erase <n> char */
1755 DEFAULT(csiescseq.arg[0], 1);
1756 tclearregion(term.c.x, term.c.y,
1757 term.c.x + csiescseq.arg[0] - 1, term.c.y);
1758 break;
1759 case 'P': /* DCH -- Delete <n> char */
1760 DEFAULT(csiescseq.arg[0], 1);
1761 tdeletechar(csiescseq.arg[0]);
1762 break;
1763 case 'Z': /* CBT -- Cursor Backward Tabulation <n> tab stops */
1764 DEFAULT(csiescseq.arg[0], 1);
1765 tputtab(-csiescseq.arg[0]);
1766 break;
1767 case 'd': /* VPA -- Move to <row> */
1768 DEFAULT(csiescseq.arg[0], 1);
1769 tmoveato(term.c.x, csiescseq.arg[0]-1);
1770 break;
1771 case 'h': /* SM -- Set terminal mode */
1772 tsetmode(csiescseq.priv, 1, csiescseq.arg, csiescseq.narg);
1773 break;
1774 case 'm': /* SGR -- Terminal attribute (color) */
1775 tsetattr(csiescseq.arg, csiescseq.narg);
1776 break;
1777 case 'n': /* DSR – Device Status Report (cursor position) */
1778 if (csiescseq.arg[0] == 6) {
1779 len = snprintf(buf, sizeof(buf),"\033[%i;%iR",
1780 term.c.y+1, term.c.x+1);
1781 ttywrite(buf, len, 0);
1782 }
1783 break;
1784 case 'r': /* DECSTBM -- Set Scrolling Region */
1785 if (csiescseq.priv) {
1786 goto unknown;
1787 } else {
1788 DEFAULT(csiescseq.arg[0], 1);
1789 DEFAULT(csiescseq.arg[1], term.row);
1790 tsetscroll(csiescseq.arg[0]-1, csiescseq.arg[1]-1);
1791 tmoveato(0, 0);
1792 }
1793 break;
1794 case 's': /* DECSC -- Save cursor position (ANSI.SYS) */
1795 tcursor(CURSOR_SAVE);
1796 break;
1797 case 'u': /* DECRC -- Restore cursor position (ANSI.SYS) */
1798 tcursor(CURSOR_LOAD);
1799 break;
1800 case ' ':
1801 switch (csiescseq.mode[1]) {
1802 case 'q': /* DECSCUSR -- Set Cursor Style */
1803 if (xsetcursor(csiescseq.arg[0]))
1804 goto unknown;
1805 break;
1806 default:
1807 goto unknown;
1808 }
1809 break;
1810 }
1811 }
1812
1813 void
1814 csidump(void)
1815 {
1816 int i;
1817 uint c;
1818
1819 fprintf(stderr, "ESC[");
1820 for (i = 0; i < csiescseq.len; i++) {
1821 c = csiescseq.buf[i] & 0xff;
1822 if (isprint(c)) {
1823 putc(c, stderr);
1824 } else if (c == '\n') {
1825 fprintf(stderr, "(\\n)");
1826 } else if (c == '\r') {
1827 fprintf(stderr, "(\\r)");
1828 } else if (c == 0x1b) {
1829 fprintf(stderr, "(\\e)");
1830 } else {
1831 fprintf(stderr, "(%02x)", c);
1832 }
1833 }
1834 putc('\n', stderr);
1835 }
1836
1837 void
1838 csireset(void)
1839 {
1840 memset(&csiescseq, 0, sizeof(csiescseq));
1841 }
1842
1843 void
1844 strhandle(void)
1845 {
1846 char *p = NULL;
1847 int j, narg, par;
1848
1849 term.esc &= ~(ESC_STR_END|ESC_STR);
1850 strparse();
1851 par = (narg = strescseq.narg) ? atoi(strescseq.args[0]) : 0;
1852
1853 switch (strescseq.type) {
1854 case ']': /* OSC -- Operating System Command */
1855 switch (par) {
1856 case 0:
1857 case 1:
1858 case 2:
1859 if (narg > 1)
1860 xsettitle(strescseq.args[1]);
1861 return;
1862 case 52:
1863 if (narg > 2) {
1864 char *dec;
1865
1866 dec = base64dec(strescseq.args[2]);
1867 if (dec) {
1868 xsetsel(dec);
1869 xclipcopy();
1870 } else {
1871 fprintf(stderr, "erresc: invalid base64\n");
1872 }
1873 }
1874 return;
1875 case 4: /* color set */
1876 if (narg < 3)
1877 break;
1878 p = strescseq.args[2];
1879 /* FALLTHROUGH */
1880 case 104: /* color reset, here p = NULL */
1881 j = (narg > 1) ? atoi(strescseq.args[1]) : -1;
1882 if (xsetcolorname(j, p)) {
1883 fprintf(stderr, "erresc: invalid color %s\n", p);
1884 } else {
1885 /*
1886 * TODO if defaultbg color is changed, borders
1887 * are dirty
1888 */
1889 redraw();
1890 }
1891 return;
1892 }
1893 break;
1894 case 'k': /* old title set compatibility */
1895 xsettitle(strescseq.args[0]);
1896 return;
1897 case 'P': /* DCS -- Device Control String */
1898 term.mode |= ESC_DCS;
1899 case '_': /* APC -- Application Program Command */
1900 case '^': /* PM -- Privacy Message */
1901 return;
1902 }
1903
1904 fprintf(stderr, "erresc: unknown str ");
1905 strdump();
1906 }
1907
1908 void
1909 strparse(void)
1910 {
1911 int c;
1912 char *p = strescseq.buf;
1913
1914 strescseq.narg = 0;
1915 strescseq.buf[strescseq.len] = '\0';
1916
1917 if (*p == '\0')
1918 return;
1919
1920 while (strescseq.narg < STR_ARG_SIZ) {
1921 strescseq.args[strescseq.narg++] = p;
1922 while ((c = *p) != ';' && c != '\0')
1923 ++p;
1924 if (c == '\0')
1925 return;
1926 *p++ = '\0';
1927 }
1928 }
1929
1930 void
1931 strdump(void)
1932 {
1933 int i;
1934 uint c;
1935
1936 fprintf(stderr, "ESC%c", strescseq.type);
1937 for (i = 0; i < strescseq.len; i++) {
1938 c = strescseq.buf[i] & 0xff;
1939 if (c == '\0') {
1940 putc('\n', stderr);
1941 return;
1942 } else if (isprint(c)) {
1943 putc(c, stderr);
1944 } else if (c == '\n') {
1945 fprintf(stderr, "(\\n)");
1946 } else if (c == '\r') {
1947 fprintf(stderr, "(\\r)");
1948 } else if (c == 0x1b) {
1949 fprintf(stderr, "(\\e)");
1950 } else {
1951 fprintf(stderr, "(%02x)", c);
1952 }
1953 }
1954 fprintf(stderr, "ESC\\\n");
1955 }
1956
1957 void
1958 strreset(void)
1959 {
1960 memset(&strescseq, 0, sizeof(strescseq));
1961 }
1962
1963 void
1964 sendbreak(const Arg *arg)
1965 {
1966 if (tcsendbreak(cmdfd, 0))
1967 perror("Error sending break");
1968 }
1969
1970 void
1971 tprinter(char *s, size_t len)
1972 {
1973 if (iofd != -1 && xwrite(iofd, s, len) < 0) {
1974 perror("Error writing to output file");
1975 close(iofd);
1976 iofd = -1;
1977 }
1978 }
1979
1980 void
1981 toggleprinter(const Arg *arg)
1982 {
1983 term.mode ^= MODE_PRINT;
1984 }
1985
1986 void
1987 printscreen(const Arg *arg)
1988 {
1989 tdump();
1990 }
1991
1992 void
1993 printsel(const Arg *arg)
1994 {
1995 tdumpsel();
1996 }
1997
1998 void
1999 tdumpsel(void)
2000 {
2001 char *ptr;
2002
2003 if ((ptr = getsel())) {
2004 tprinter(ptr, strlen(ptr));
2005 free(ptr);
2006 }
2007 }
2008
2009 void
2010 tdumpline(int n)
2011 {
2012 char buf[UTF_SIZ];
2013 Glyph *bp, *end;
2014
2015 bp = &term.line[n][0];
2016 end = &bp[MIN(tlinelen(n), term.col) - 1];
2017 if (bp != end || bp->u != ' ') {
2018 for ( ;bp <= end; ++bp)
2019 tprinter(buf, utf8encode(bp->u, buf));
2020 }
2021 tprinter("\n", 1);
2022 }
2023
2024 void
2025 tdump(void)
2026 {
2027 int i;
2028
2029 for (i = 0; i < term.row; ++i)
2030 tdumpline(i);
2031 }
2032
2033 void
2034 tputtab(int n)
2035 {
2036 uint x = term.c.x;
2037
2038 if (n > 0) {
2039 while (x < term.col && n--)
2040 for (++x; x < term.col && !term.tabs[x]; ++x)
2041 /* nothing */ ;
2042 } else if (n < 0) {
2043 while (x > 0 && n++)
2044 for (--x; x > 0 && !term.tabs[x]; --x)
2045 /* nothing */ ;
2046 }
2047 term.c.x = LIMIT(x, 0, term.col-1);
2048 }
2049
2050 void
2051 tdefutf8(char ascii)
2052 {
2053 if (ascii == 'G')
2054 term.mode |= MODE_UTF8;
2055 else if (ascii == '@')
2056 term.mode &= ~MODE_UTF8;
2057 }
2058
2059 void
2060 tdeftran(char ascii)
2061 {
2062 static char cs[] = "0B";
2063 static int vcs[] = {CS_GRAPHIC0, CS_USA};
2064 char *p;
2065
2066 if ((p = strchr(cs, ascii)) == NULL) {
2067 fprintf(stderr, "esc unhandled charset: ESC ( %c\n", ascii);
2068 } else {
2069 term.trantbl[term.icharset] = vcs[p - cs];
2070 }
2071 }
2072
2073 void
2074 tdectest(char c)
2075 {
2076 int x, y;
2077
2078 if (c == '8') { /* DEC screen alignment test. */
2079 for (x = 0; x < term.col; ++x) {
2080 for (y = 0; y < term.row; ++y)
2081 tsetchar('E', &term.c.attr, x, y);
2082 }
2083 }
2084 }
2085
2086 void
2087 tstrsequence(uchar c)
2088 {
2089 strreset();
2090
2091 switch (c) {
2092 case 0x90: /* DCS -- Device Control String */
2093 c = 'P';
2094 term.esc |= ESC_DCS;
2095 break;
2096 case 0x9f: /* APC -- Application Program Command */
2097 c = '_';
2098 break;
2099 case 0x9e: /* PM -- Privacy Message */
2100 c = '^';
2101 break;
2102 case 0x9d: /* OSC -- Operating System Command */
2103 c = ']';
2104 break;
2105 }
2106 strescseq.type = c;
2107 term.esc |= ESC_STR;
2108 }
2109
2110 void
2111 tcontrolcode(uchar ascii)
2112 {
2113 switch (ascii) {
2114 case '\t': /* HT */
2115 tputtab(1);
2116 return;
2117 case '\b': /* BS */
2118 tmoveto(term.c.x-1, term.c.y);
2119 return;
2120 case '\r': /* CR */
2121 tmoveto(0, term.c.y);
2122 return;
2123 case '\f': /* LF */
2124 case '\v': /* VT */
2125 case '\n': /* LF */
2126 /* go to first col if the mode is set */
2127 tnewline(IS_SET(MODE_CRLF));
2128 return;
2129 case '\a': /* BEL */
2130 if (term.esc & ESC_STR_END) {
2131 /* backwards compatibility to xterm */
2132 strhandle();
2133 } else {
2134 xbell();
2135 }
2136 break;
2137 case '\033': /* ESC */
2138 csireset();
2139 term.esc &= ~(ESC_CSI|ESC_ALTCHARSET|ESC_TEST);
2140 term.esc |= ESC_START;
2141 return;
2142 case '\016': /* SO (LS1 -- Locking shift 1) */
2143 case '\017': /* SI (LS0 -- Locking shift 0) */
2144 term.charset = 1 - (ascii - '\016');
2145 return;
2146 case '\032': /* SUB */
2147 tsetchar('?', &term.c.attr, term.c.x, term.c.y);
2148 case '\030': /* CAN */
2149 csireset();
2150 break;
2151 case '\005': /* ENQ (IGNORED) */
2152 case '\000': /* NUL (IGNORED) */
2153 case '\021': /* XON (IGNORED) */
2154 case '\023': /* XOFF (IGNORED) */
2155 case 0177: /* DEL (IGNORED) */
2156 return;
2157 case 0x80: /* TODO: PAD */
2158 case 0x81: /* TODO: HOP */
2159 case 0x82: /* TODO: BPH */
2160 case 0x83: /* TODO: NBH */
2161 case 0x84: /* TODO: IND */
2162 break;
2163 case 0x85: /* NEL -- Next line */
2164 tnewline(1); /* always go to first col */
2165 break;
2166 case 0x86: /* TODO: SSA */
2167 case 0x87: /* TODO: ESA */
2168 break;
2169 case 0x88: /* HTS -- Horizontal tab stop */
2170 term.tabs[term.c.x] = 1;
2171 break;
2172 case 0x89: /* TODO: HTJ */
2173 case 0x8a: /* TODO: VTS */
2174 case 0x8b: /* TODO: PLD */
2175 case 0x8c: /* TODO: PLU */
2176 case 0x8d: /* TODO: RI */
2177 case 0x8e: /* TODO: SS2 */
2178 case 0x8f: /* TODO: SS3 */
2179 case 0x91: /* TODO: PU1 */
2180 case 0x92: /* TODO: PU2 */
2181 case 0x93: /* TODO: STS */
2182 case 0x94: /* TODO: CCH */
2183 case 0x95: /* TODO: MW */
2184 case 0x96: /* TODO: SPA */
2185 case 0x97: /* TODO: EPA */
2186 case 0x98: /* TODO: SOS */
2187 case 0x99: /* TODO: SGCI */
2188 break;
2189 case 0x9a: /* DECID -- Identify Terminal */
2190 ttywrite(vtiden, strlen(vtiden), 0);
2191 break;
2192 case 0x9b: /* TODO: CSI */
2193 case 0x9c: /* TODO: ST */
2194 break;
2195 case 0x90: /* DCS -- Device Control String */
2196 case 0x9d: /* OSC -- Operating System Command */
2197 case 0x9e: /* PM -- Privacy Message */
2198 case 0x9f: /* APC -- Application Program Command */
2199 tstrsequence(ascii);
2200 return;
2201 }
2202 /* only CAN, SUB, \a and C1 chars interrupt a sequence */
2203 term.esc &= ~(ESC_STR_END|ESC_STR);
2204 }
2205
2206 /*
2207 * returns 1 when the sequence is finished and it hasn't to read
2208 * more characters for this sequence, otherwise 0
2209 */
2210 int
2211 eschandle(uchar ascii)
2212 {
2213 switch (ascii) {
2214 case '[':
2215 term.esc |= ESC_CSI;
2216 return 0;
2217 case '#':
2218 term.esc |= ESC_TEST;
2219 return 0;
2220 case '%':
2221 term.esc |= ESC_UTF8;
2222 return 0;
2223 case 'P': /* DCS -- Device Control String */
2224 case '_': /* APC -- Application Program Command */
2225 case '^': /* PM -- Privacy Message */
2226 case ']': /* OSC -- Operating System Command */
2227 case 'k': /* old title set compatibility */
2228 tstrsequence(ascii);
2229 return 0;
2230 case 'n': /* LS2 -- Locking shift 2 */
2231 case 'o': /* LS3 -- Locking shift 3 */
2232 term.charset = 2 + (ascii - 'n');
2233 break;
2234 case '(': /* GZD4 -- set primary charset G0 */
2235 case ')': /* G1D4 -- set secondary charset G1 */
2236 case '*': /* G2D4 -- set tertiary charset G2 */
2237 case '+': /* G3D4 -- set quaternary charset G3 */
2238 term.icharset = ascii - '(';
2239 term.esc |= ESC_ALTCHARSET;
2240 return 0;
2241 case 'D': /* IND -- Linefeed */
2242 if (term.c.y == term.bot) {
2243 tscrollup(term.top, 1);
2244 } else {
2245 tmoveto(term.c.x, term.c.y+1);
2246 }
2247 break;
2248 case 'E': /* NEL -- Next line */
2249 tnewline(1); /* always go to first col */
2250 break;
2251 case 'H': /* HTS -- Horizontal tab stop */
2252 term.tabs[term.c.x] = 1;
2253 break;
2254 case 'M': /* RI -- Reverse index */
2255 if (term.c.y == term.top) {
2256 tscrolldown(term.top, 1);
2257 } else {
2258 tmoveto(term.c.x, term.c.y-1);
2259 }
2260 break;
2261 case 'Z': /* DECID -- Identify Terminal */
2262 ttywrite(vtiden, strlen(vtiden), 0);
2263 break;
2264 case 'c': /* RIS -- Reset to inital state */
2265 treset();
2266 resettitle();
2267 xloadcols();
2268 break;
2269 case '=': /* DECPAM -- Application keypad */
2270 xsetmode(1, MODE_APPKEYPAD);
2271 break;
2272 case '>': /* DECPNM -- Normal keypad */
2273 xsetmode(0, MODE_APPKEYPAD);
2274 break;
2275 case '7': /* DECSC -- Save Cursor */
2276 tcursor(CURSOR_SAVE);
2277 break;
2278 case '8': /* DECRC -- Restore Cursor */
2279 tcursor(CURSOR_LOAD);
2280 break;
2281 case '\\': /* ST -- String Terminator */
2282 if (term.esc & ESC_STR_END)
2283 strhandle();
2284 break;
2285 default:
2286 fprintf(stderr, "erresc: unknown sequence ESC 0x%02X '%c'\n",
2287 (uchar) ascii, isprint(ascii)? ascii:'.');
2288 break;
2289 }
2290 return 1;
2291 }
2292
2293 void
2294 tputc(Rune u)
2295 {
2296 char c[UTF_SIZ];
2297 int control;
2298 int width, len;
2299 Glyph *gp;
2300
2301 control = ISCONTROL(u);
2302 if (!IS_SET(MODE_UTF8) && !IS_SET(MODE_SIXEL)) {
2303 c[0] = u;
2304 width = len = 1;
2305 } else {
2306 len = utf8encode(u, c);
2307 if (!control && (width = wcwidth(u)) == -1) {
2308 memcpy(c, "\357\277\275", 4); /* UTF_INVALID */
2309 width = 1;
2310 }
2311 }
2312
2313 if (IS_SET(MODE_PRINT))
2314 tprinter(c, len);
2315
2316 /*
2317 * STR sequence must be checked before anything else
2318 * because it uses all following characters until it
2319 * receives a ESC, a SUB, a ST or any other C1 control
2320 * character.
2321 */
2322 if (term.esc & ESC_STR) {
2323 if (u == '\a' || u == 030 || u == 032 || u == 033 ||
2324 ISCONTROLC1(u)) {
2325 term.esc &= ~(ESC_START|ESC_STR|ESC_DCS);
2326 if (IS_SET(MODE_SIXEL)) {
2327 /* TODO: render sixel */;
2328 term.mode &= ~MODE_SIXEL;
2329 return;
2330 }
2331 term.esc |= ESC_STR_END;
2332 goto check_control_code;
2333 }
2334
2335
2336 if (IS_SET(MODE_SIXEL)) {
2337 /* TODO: implement sixel mode */
2338 return;
2339 }
2340 if (term.esc&ESC_DCS && strescseq.len == 0 && u == 'q')
2341 term.mode |= MODE_SIXEL;
2342
2343 if (strescseq.len+len >= sizeof(strescseq.buf)-1) {
2344 /*
2345 * Here is a bug in terminals. If the user never sends
2346 * some code to stop the str or esc command, then st
2347 * will stop responding. But this is better than
2348 * silently failing with unknown characters. At least
2349 * then users will report back.
2350 *
2351 * In the case users ever get fixed, here is the code:
2352 */
2353 /*
2354 * term.esc = 0;
2355 * strhandle();
2356 */
2357 return;
2358 }
2359
2360 memmove(&strescseq.buf[strescseq.len], c, len);
2361 strescseq.len += len;
2362 return;
2363 }
2364
2365 check_control_code:
2366 /*
2367 * Actions of control codes must be performed as soon they arrive
2368 * because they can be embedded inside a control sequence, and
2369 * they must not cause conflicts with sequences.
2370 */
2371 if (control) {
2372 tcontrolcode(u);
2373 /*
2374 * control codes are not shown ever
2375 */
2376 return;
2377 } else if (term.esc & ESC_START) {
2378 if (term.esc & ESC_CSI) {
2379 csiescseq.buf[csiescseq.len++] = u;
2380 if (BETWEEN(u, 0x40, 0x7E)
2381 || csiescseq.len >= \
2382 sizeof(csiescseq.buf)-1) {
2383 term.esc = 0;
2384 csiparse();
2385 csihandle();
2386 }
2387 return;
2388 } else if (term.esc & ESC_UTF8) {
2389 tdefutf8(u);
2390 } else if (term.esc & ESC_ALTCHARSET) {
2391 tdeftran(u);
2392 } else if (term.esc & ESC_TEST) {
2393 tdectest(u);
2394 } else {
2395 if (!eschandle(u))
2396 return;
2397 /* sequence already finished */
2398 }
2399 term.esc = 0;
2400 /*
2401 * All characters which form part of a sequence are not
2402 * printed
2403 */
2404 return;
2405 }
2406 if (sel.ob.x != -1 && BETWEEN(term.c.y, sel.ob.y, sel.oe.y))
2407 selclear();
2408
2409 gp = &term.line[term.c.y][term.c.x];
2410 if (IS_SET(MODE_WRAP) && (term.c.state & CURSOR_WRAPNEXT)) {
2411 gp->mode |= ATTR_WRAP;
2412 tnewline(1);
2413 gp = &term.line[term.c.y][term.c.x];
2414 }
2415
2416 if (IS_SET(MODE_INSERT) && term.c.x+width < term.col)
2417 memmove(gp+width, gp, (term.col - term.c.x - width) * sizeof(Glyph));
2418
2419 if (term.c.x+width > term.col) {
2420 tnewline(1);
2421 gp = &term.line[term.c.y][term.c.x];
2422 }
2423
2424 tsetchar(u, &term.c.attr, term.c.x, term.c.y);
2425
2426 if (width == 2) {
2427 gp->mode |= ATTR_WIDE;
2428 if (term.c.x+1 < term.col) {
2429 gp[1].u = '\0';
2430 gp[1].mode = ATTR_WDUMMY;
2431 }
2432 }
2433 if (term.c.x+width < term.col) {
2434 tmoveto(term.c.x+width, term.c.y);
2435 } else {
2436 term.c.state |= CURSOR_WRAPNEXT;
2437 }
2438 }
2439
2440 int
2441 twrite(const char *buf, int buflen, int show_ctrl)
2442 {
2443 int charsize;
2444 Rune u;
2445 int n;
2446
2447 for (n = 0; n < buflen; n += charsize) {
2448 if (IS_SET(MODE_UTF8) && !IS_SET(MODE_SIXEL)) {
2449 /* process a complete utf8 char */
2450 charsize = utf8decode(buf + n, &u, buflen - n);
2451 if (charsize == 0)
2452 break;
2453 } else {
2454 u = buf[n] & 0xFF;
2455 charsize = 1;
2456 }
2457 if (show_ctrl && ISCONTROL(u)) {
2458 if (u & 0x80) {
2459 u &= 0x7f;
2460 tputc('^');
2461 tputc('[');
2462 } else if (u != '\n' && u != '\r' && u != '\t') {
2463 u ^= 0x40;
2464 tputc('^');
2465 }
2466 }
2467 tputc(u);
2468 }
2469 return n;
2470 }
2471
2472 void
2473 tresize(int col, int row)
2474 {
2475 int i;
2476 int minrow = MIN(row, term.row);
2477 int mincol = MIN(col, term.col);
2478 int *bp;
2479 TCursor c;
2480
2481 if (col < 1 || row < 1) {
2482 fprintf(stderr,
2483 "tresize: error resizing to %dx%d\n", col, row);
2484 return;
2485 }
2486
2487 /*
2488 * slide screen to keep cursor where we expect it -
2489 * tscrollup would work here, but we can optimize to
2490 * memmove because we're freeing the earlier lines
2491 */
2492 for (i = 0; i <= term.c.y - row; i++) {
2493 free(term.line[i]);
2494 free(term.alt[i]);
2495 }
2496 /* ensure that both src and dst are not NULL */
2497 if (i > 0) {
2498 memmove(term.line, term.line + i, row * sizeof(Line));
2499 memmove(term.alt, term.alt + i, row * sizeof(Line));
2500 }
2501 for (i += row; i < term.row; i++) {
2502 free(term.line[i]);
2503 free(term.alt[i]);
2504 }
2505
2506 /* resize to new height */
2507 term.line = xrealloc(term.line, row * sizeof(Line));
2508 term.alt = xrealloc(term.alt, row * sizeof(Line));
2509 term.dirty = xrealloc(term.dirty, row * sizeof(*term.dirty));
2510 term.tabs = xrealloc(term.tabs, col * sizeof(*term.tabs));
2511
2512 /* resize each row to new width, zero-pad if needed */
2513 for (i = 0; i < minrow; i++) {
2514 term.line[i] = xrealloc(term.line[i], col * sizeof(Glyph));
2515 term.alt[i] = xrealloc(term.alt[i], col * sizeof(Glyph));
2516 }
2517
2518 /* allocate any new rows */
2519 for (/* i = minrow */; i < row; i++) {
2520 term.line[i] = xmalloc(col * sizeof(Glyph));
2521 term.alt[i] = xmalloc(col * sizeof(Glyph));
2522 }
2523 if (col > term.col) {
2524 bp = term.tabs + term.col;
2525
2526 memset(bp, 0, sizeof(*term.tabs) * (col - term.col));
2527 while (--bp > term.tabs && !*bp)
2528 /* nothing */ ;
2529 for (bp += tabspaces; bp < term.tabs + col; bp += tabspaces)
2530 *bp = 1;
2531 }
2532 /* update terminal size */
2533 term.col = col;
2534 term.row = row;
2535 /* reset scrolling region */
2536 tsetscroll(0, row-1);
2537 /* make use of the LIMIT in tmoveto */
2538 tmoveto(term.c.x, term.c.y);
2539 /* Clearing both screens (it makes dirty all lines) */
2540 c = term.c;
2541 for (i = 0; i < 2; i++) {
2542 if (mincol < col && 0 < minrow) {
2543 tclearregion(mincol, 0, col - 1, minrow - 1);
2544 }
2545 if (0 < col && minrow < row) {
2546 tclearregion(0, minrow, col - 1, row - 1);
2547 }
2548 tswapscreen();
2549 tcursor(CURSOR_LOAD);
2550 }
2551 term.c = c;
2552 }
2553
2554 void
2555 resettitle(void)
2556 {
2557 xsettitle(NULL);
2558 }
2559
2560 void
2561 drawregion(int x1, int y1, int x2, int y2)
2562 {
2563 int y;
2564 for (y = y1; y < y2; y++) {
2565 if (!term.dirty[y])
2566 continue;
2567
2568 term.dirty[y] = 0;
2569 xdrawline(term.line[y], x1, y, x2);
2570 }
2571 }
2572
2573 void
2574 draw(void)
2575 {
2576 int cx = term.c.x;
2577
2578 if (!xstartdraw())
2579 return;
2580
2581 /* adjust cursor position */
2582 LIMIT(term.ocx, 0, term.col-1);
2583 LIMIT(term.ocy, 0, term.row-1);
2584 if (term.line[term.ocy][term.ocx].mode & ATTR_WDUMMY)
2585 term.ocx--;
2586 if (term.line[term.c.y][cx].mode & ATTR_WDUMMY)
2587 cx--;
2588
2589 drawregion(0, 0, term.col, term.row);
2590 xdrawcursor(cx, term.c.y, term.line[term.c.y][cx],
2591 term.ocx, term.ocy, term.line[term.ocy][term.ocx]);
2592 term.ocx = cx, term.ocy = term.c.y;
2593 xfinishdraw();
2594 }
2595
2596 void
2597 redraw(void)
2598 {
2599 tfulldirt();
2600 draw();
2601 }