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