Debian Codegraph @

jtc.c

raw
1 /**************************************************************************
2 * This file is Copyright (C) 2020 by Mark Moraes. It is provided *
3 * without charge and without warranty. You may copy, modify, and/or *
4 * distribute it, provided that this notice is included in all the source *
5 * file and documentation. *
6 **************************************************************************/
7
8 /*
9 * Simple standalone hardwired terminfo/termcap replacement
10 * that only supports the subset of vt[123]xx/ANSI
11 * X3.64/ECMA-48/ISO6429 needed by Jove. Since everyone in
12 * the year 2020CE probably uses a terminal emulator that
13 * supports far more than the set needed by Jove, the approach
14 * here is to define a few levels of capabilities, use JOVEVT
15 * or TERM to select a level and fake out the tgetent/tputs
16 * routines. This does not provide tparm/tgoto to interpret
17 * the termcap/terminfo % operators, instead providing just
18 * the one and two-arg functions (jtcarg[12]) that Jove needs,
19 * and assuming the two-arg increments row/col as %i does. If
20 * someone finds themselves on a terminal that does not
21 * support the necessary minimal subset of ANSI X.3, then you
22 * need to compile jove with one of termcap/terminfo/curses/ncurses/ncursesw!
23 */
24 /* Mark Moraes, 20200109 */
25
26 #include "jove.h"
27
28 #ifndef JTC
29 extern int avoid_pedantic_complaints_about_empty_translation_unit;
30 #else
31 #include "jctype.h"
32 #include "fmt.h" /* for swritef */
33 #include "fp.h" /* for flushscreen */
34
35 #include <sys/time.h>
36 #include "select.h"
37
38 #include <termios.h>
39 #include <sys/ioctl.h>
40 #ifdef TIOCGWINSZ
41 private struct winsize jtwin;
42 # define JVTCOLS jtwin.ws_col
43 # define JVTROWS jtwin.ws_row
44 #endif /* TIOCGWINSZ */
45
46 #ifndef JVTCOLS
47 # define JVTCOLS 80
48 # define JVTROWS 24
49 #endif
50
51 #ifdef TEST_STANDALONE
52 extern int strncasecmp(const char *, const char *, size_t);
53 extern int snprintf(char *, size_t, const char *, ...);
54 #define flushscreen() fflush(stdout)
55 #define caseeqn(s1, s2, n) (strncasecmp(s1, s2, n) == 0)
56 #define swritef snprintf
57 #undef jisdigit
58 #define jisdigit(c) (c >= '0' && c <= '9')
59 #endif
60
61 /* symbolic values for capability level */
62 #define ANSI 99 /* cursor motions, standout/underline */
63 #define VT100 100 /* scrolling region, flash/visual bell, cursor 'application keypad' mode */
64 #define VT102 102 /* generally what most VT100 emulators handle */
65 #define VT125 125 /* anything above this has a meta- or alt- key */
66 #define VT320 320 /* SR/SF aka SU/SD to pan up or down by multiple lines */
67 #define VTALT 999 /* alternate screen, like xterm, rxvt, and friends */
68
69 typedef struct jtermcap {
70 const char *capname;
71 const char *capval;
72 unsigned caplevel;
73 } JTermcap;
74
75 #define JTMAX 128
76 private char jtarg[JTMAX];
77 private int jtlev = -1;
78
79 private JTermcap jtc[] = {
80 {"vs", "\033[?12;25h", VTALT}, /* ATT610 blinking cursor + DECTCEM show cursor*/
81 {"ve", "\033[?12l\033[?25h", VTALT}, /* turn off ATT610 but leave cursor? */
82 {"al", "\033[L", ANSI},
83 {"dl", "\033[M", ANSI},
84 {"cs", "\033[%d;%dr", VT100}, /* DECSTBM, so I assume not ANSI? targ2 so will do %i-like incr both args */
85 {"so", "\033[7m", ANSI},
86 {"se", "\033[27m", ANSI},
87 {"us", "\033[4m", ANSI},
88 {"ue", "\033[24m", ANSI},
89 {"cm", "\033[%d;%dH", ANSI}, /* targ2, so will do %i-like incr both args */
90 {"cl", "\033[H\033[J", ANSI}, /* more portable than \033[2J if we need the \033[H to position cursor anyway? */
91 {"ce", "\033[K", ANSI},
92 {"ho", "\033[H", ANSI},
93 {"up", "\033[A", ANSI},
94 {"do", "\n", 0}, /* shorter than \033[B */
95 {"sf", "\n", 0}, /* shorter than \033D */
96 {"sr", "\033M", ANSI},
97 {"vb", "\033[?5h$\033[?5l", VT100}, /* $ means 100ms delay, i.e. $<100/> */
98 {"ks", "\033[?1h\033=", VT100},
99 {"ke", "\033[?1l\033>", VT100},
100 {"ti", "\0337\033[?47h", VTALT}, /* or \033[?1049h */
101 {"te", "\033[2J\033[?47l\0338", VTALT}, /* or \033[?1049l */
102 {"bl", "\007", 0},
103 {"AL", "\033[%dL", VT102},
104 {"DL", "\033[%dM", VT102},
105 {"SF", "\033[%dS", VT320}, /* in ANSI, but not much support, it seems. vttest says it appeared in VT320 */
106 {"SR", "\033[%dT", VT320}, /* in ANSI, but not much support, it seems. vttest says it appeared in VT320 */
107 {"im", "\033[4h", VT102},
108 {"dc", "\033[P", VT102},
109 {"ei", "\033[4l", VT102},
110 {"IC", "\033[%d@", VT102},
111 {"DC", "\033[%dP", VT102},
112 };
113
114 typedef struct jtlevel {
115 const char *tprefix;
116 unsigned tlevel;
117 } JTLevel;
118
119 private JTLevel jtc_emu[] = {
120 {"ansi", ANSI},
121 {"xterm", VTALT},
122 {"rxvt", VTALT},
123 {"xnuppc", VTALT},
124 {"putty", VTALT},
125 {"linux", VT125},
126 {"screen", VTALT},
127 {"tmux", VTALT},
128 {"gnome", VTALT},
129 {"konsole", VTALT},
130 {"eterm", VTALT},
131 {"nsterm", VTALT},
132 {"kterm", VTALT},
133 {"vte", VTALT},
134 {"st", VTALT},
135 };
136
137 char *
138 jtcarg1(const char *fmt, int p)
139 {
140 if (fmt)
141 swritef(jtarg, sizeof jtarg, fmt, p);
142 else
143 jtarg[0] = '\0';
144 return jtarg;
145 }
146
147 /*
148 * XXX always increment both args because the capability
149 * strings for cm and cs on ANSI/ECMA/VTxxx terminals need
150 * that, and that is all JOVE uses targ2 for. i.e.
151 * hardwires the %i behaviour from terminfo/termcap
152 */
153 char *
154 jtcarg2(const char *fmt, int destcol, int destline)
155 {
156 if (fmt)
157 swritef(jtarg, sizeof jtarg, fmt, destline+1, destcol+1);
158 else
159 jtarg[0] = '\0';
160 return jtarg;
161 }
162
163 /*
164 * same as jove.c SitFor but without charp/redisplay to avoid
165 * risk of recursion. If you do not have select, use regular
166 * termcap. A jdelay function ought to be factored out of jove.c
167 * and moved to unix.c, ibmpcdos.c, win32.c, mac.c.
168 */
169 void
170 jdelay(int delay)
171 {
172 struct timeval timer;
173 fd_set readfds;
174
175 timer.tv_sec = (delay / 10);
176 timer.tv_usec = (delay % 10) * 100000;
177 FD_ZERO(&readfds);
178 FD_SET(0, &readfds);
179 (void) select(1,
180 &readfds, (fd_set *)NULL, (fd_set *)NULL,
181 &timer);
182 }
183
184 void
185 tputs(const char *str, int lines, void (*putfunc)(char))
186 {
187 const char *cp = str;
188 ZXchar c;
189 jbool needflush = NO;
190 while (cp && (c = ZXC(*cp++)) != '\0') {
191 if (c == '$') {
192 flushscreen();
193 needflush = YES;
194 jdelay(1); /* tenth of a second */
195 } else {
196 (*putfunc)(c);
197 }
198 }
199 if (needflush) flushscreen();
200 }
201
202 int
203 tgetent(char *buf, const char *tenv)
204 {
205 const char *jtcenv = getenv("JOVEVT");
206 if (jtcenv != NULL) {
207 if (caseeqn(jtcenv, "alt", 3) || caseeqn(jtcenv, "vtalt", 5)) {
208 jtlev = VTALT;
209 } else if (caseeqn(jtcenv, "vt", 2)) {
210 jtlev = atoi(jtcenv+2);
211 } else {
212 jtlev = atoi(jtcenv);
213 }
214 } else {
215 JTLevel *j = jtc_emu;
216 if (caseeqn(tenv, "vt", 2) && jisdigit(tenv[2])) {
217 jtlev = atoi(&tenv[2]);
218 }
219 for (j = jtc_emu;
220 j < jtc_emu + (sizeof(jtc_emu)/sizeof(jtc_emu[0])); j++) {
221 size_t tlen = strlen(j->tprefix);
222 if (caseeqn(tenv, j->tprefix, tlen) &&
223 (tenv[tlen] == '\0' || tenv[tlen] == '-' ||
224 tenv[tlen] == '.' || jisdigit(tenv[tlen]))) {
225 jtlev = j->tlevel;
226 break;
227 }
228 }
229 }
230 #ifdef TIOCGWINSZ
231 if (ioctl(0, TIOCGWINSZ, &jtwin) < 0)
232 return -1;
233 #endif
234 return jtlev >= 0;
235 }
236
237 #define capeq(cap, val) (cap[0] == val[0] && cap[1] == val[1] && \
238 cap[2] == val[2] && cap[2] == '\0')
239
240 int
241 tgetflag(const char *capname)
242 {
243 if (capeq(capname, "mi") && jtlev >= VT125)
244 return YES; /* terminfo for vt102 does not have move-in-insert */
245 else if (capeq(capname, "km") && jtlev >= VTALT)
246 return YES; /* metakey only on modern terminal emulators */
247 /*
248 * NP is not checked on modern machines with select(),
249 * which are the only ones with xterm etc where NP
250 * might be true.
251 */
252 return NO;
253 }
254
255
256 int
257 tgetnum(const char *capname)
258 {
259 if (capeq(capname, "co")) {
260 return JVTCOLS;
261 } else if (capeq(capname, "li")) {
262 return JVTROWS;
263 } else if (capeq(capname, "it")) {
264 return 8;
265 } else if (capeq(capname, "ug") || capeq(capname, "sg")) {
266 return 0;
267 }
268 return -1;
269 }
270
271 const char *
272 tgetstr(const char *capname, char **area)
273 {
274 JTermcap *j;
275 for (j = jtc; j < jtc + (sizeof(jtc)/sizeof(jtc[0])); j++) {
276 if (capeq(j->capname, capname) && j->caplevel <= jtlev) {
277 if (area && *area) {
278 size_t caplen = strlen(j->capval) + 1;
279 memcpy(*area, j->capval, caplen);
280 *area += caplen;
281 }
282 return j->capval;
283 }
284 }
285 return 0;
286 }
287
288 #ifdef TEST_STANDALONE
289 /* To test, build with
290 * LANG=C gcc -o testjtc jtc.c -g -O -Wall -DTEST_STANDALONE -DJTC
291 */
292
293 /* make terminfo string printable */
294 void
295 puts_encoded(s)
296 const char *s;
297 {
298 unsigned c;
299 if (s) while ((c = (*s++)&0xff) != '\0') {
300 /*printf(" 0x%x\n", c);*/
301 if (c == 0x1b) {
302 /* convention for ESC per terminfo(5) */
303 printf("\\E");
304 } else if (c == 0x7f) {
305 /* convention for DEL e.g. terminfo(5) */
306 printf("^?");
307 } else if (c < ' ') {
308 /* ^ followed up uppercase letter */
309 printf("^%c", c | 0x40);
310 } else if (c < 0x7f) {
311 printf("%c", c);
312 } else {
313 printf("\\%03o", c);
314 }
315 }
316 printf("\n");
317 }
318
319 void
320 xtputs(delay, s, li)
321 int delay, li;
322 const char *s;
323 {
324 tputs(s, li, (void (*)(char)) putchar);
325 fflush(stdout);
326 jdelay(delay);
327 }
328
329 int main(argc, argv)
330 int argc;
331 char **argv;
332 {
333 int i, j;
334 static const char *capn[] = {"co", "li", "it", "ug", "sg", "xx"};
335 static const char *capf[] = {"NP", "mi", "km", "ul", "xs", "hz"};
336 const char *cp;
337 for (i = 1; i < argc; i++) {
338 int r = tgetent(NULL, argv[i]);
339 printf("tgetent(%s) -> %d jtlev=%d\n", argv[i], r, jtlev);
340 for (j = 0; j < sizeof(capn)/sizeof(capn[0]); j++) {
341 int v = tgetnum(capn[j]);
342 printf(" %s=%d\n", capn[j], v);
343 }
344 for (j = 0; j < sizeof(capf)/sizeof(capf[0]); j++) {
345 int v = tgetflag(capf[j]);
346 printf(" %s=%s\n", capf[j], v == YES ? "YES" : "NO");
347 }
348 for (j = 0; j < sizeof(jtc)/sizeof(jtc[0]); j++) {
349 const char *s = tgetstr(jtc[j].capname, NULL);
350 printf(" %s=", jtc[j].capname);
351 puts_encoded(s);
352 }
353 }
354 if (argc > 1) exit(0);
355 printf("about to enter screen mode:\n");
356 fflush(stdout);
357 jdelay(10);
358 cp = getenv("TERM");
359 tgetent(NULL, cp);
360 xtputs(1, tgetstr("ti", NULL), 0);
361 xtputs(1, jtcarg1(tgetstr("ks", NULL),0), 0);
362 xtputs(10, tgetstr("cl", NULL), 24);
363 xtputs(10, "hello\nworld", 2);
364 xtputs(1, jtcarg2(tgetstr("cm", NULL), 4, 0), 1);
365 xtputs(10, jtcarg1(tgetstr("dc", NULL), 1), 1);
366 xtputs(1, jtcarg2(tgetstr("cm", NULL), 2, 1), 1);
367 xtputs(10, "wsa", 1);
368 xtputs(1, jtcarg2(tgetstr("cs", NULL), 5, 0), 1);
369 xtputs(1, tgetstr("ho", NULL), 1);
370 xtputs(10, tgetstr("sr", NULL), 1);
371 xtputs(10, "111111", 1);
372 xtputs(1, tgetstr("ho", NULL), 1);
373 xtputs(1, tgetstr("do", NULL), 1);
374 xtputs(1, tgetstr("do", NULL), 1);
375 xtputs(10, tgetstr("sf", NULL), 1);
376 xtputs(10, "222222", 1);
377 xtputs(5, jtcarg1(tgetstr("ho", NULL), 1), 1);
378 cp = tgetstr("SR", NULL);
379 if (cp)
380 xtputs(10, jtcarg1(cp, 2), 2);
381 else {
382 xtputs(5, jtcarg1(tgetstr("sr", NULL), 1), 1);
383 xtputs(5, jtcarg1(tgetstr("sr", NULL), 1), 1);
384 }
385 xtputs(5, jtcarg2(tgetstr("cm", NULL),0,5), 1);
386 cp = tgetstr("SF", NULL);
387 if (cp)
388 xtputs(10, jtcarg1(cp, 2), 2);
389 else {
390 xtputs(5, jtcarg1(tgetstr("sf", NULL),1), 1);
391 xtputs(5, jtcarg1(tgetstr("sf", NULL),1), 1);
392 }
393 j = tgetnum("li");
394 xtputs(5, tgetstr("dl", NULL), 1);
395 xtputs(5, tgetstr("so", NULL), 1);
396 printf("%d",j);
397 fflush(stdout);
398 xtputs(5, tgetstr("se", NULL), 1);
399 xtputs(5, tgetstr("vb", NULL), 1);
400 xtputs(5, jtcarg2(tgetstr("cs", NULL),j-1,0), 0);
401 xtputs(5, jtcarg2(tgetstr("cm", NULL),0,j-1), 0);
402 xtputs(5, tgetstr("ce", NULL), 0);
403 xtputs(0, tgetstr("ke", NULL), 0);
404 xtputs(0, tgetstr("te", NULL), 0);
405 printf("done.\n");
406 return 0;
407 }
408 #endif /* TEST_STANDALONE */
409 #endif /* JTC */