xref: /netbsd-src/lib/libterminfo/compile.c (revision 88fcb00c0357f2d7c1774f86a352637bfda96184) 
1 /* $NetBSD: compile.c,v 1.5 2011/04/11 21:37:19 roy Exp $ */
2 
3 /*
4  * Copyright (c) 2009, 2010, 2011 The NetBSD Foundation, Inc.
5  *
6  * This code is derived from software contributed to The NetBSD Foundation
7  * by Roy Marples.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  *
18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29 
30 #if HAVE_NBTOOL_CONFIG_H
31 #include "nbtool_config.h"
32 #endif
33 
34 #include <sys/cdefs.h>
35 __RCSID("$NetBSD: compile.c,v 1.5 2011/04/11 21:37:19 roy Exp $");
36 
37 #if !HAVE_NBTOOL_CONFIG_H || HAVE_SYS_ENDIAN_H
38 #include <sys/endian.h>
39 #endif
40 
41 #include <assert.h>
42 #include <ctype.h>
43 #include <err.h>
44 #include <errno.h>
45 #include <limits.h>
46 #include <stdarg.h>
47 #include <stdlib.h>
48 #include <stdint.h>
49 #include <stdio.h>
50 #include <string.h>
51 #include <term_private.h>
52 #include <term.h>
53 
54 static void __attribute__((__format__(__printf__, 2, 3)))
55 dowarn(int flags, const char *fmt, ...)
56 {
57 	va_list va;
58 
59 	errno = EINVAL;
60 	if (flags & TIC_WARNING) {
61 		va_start(va, fmt);
62 		vwarnx(fmt, va);
63 		va_end(va);
64 	}
65 }
66 
67 char *
68 _ti_grow_tbuf(TBUF *tbuf, size_t len)
69 {
70 	char *buf;
71 	size_t l;
72 
73 	_DIAGASSERT(tbuf != NULL);
74 
75 	l = tbuf->bufpos + len;
76 	if (l > tbuf->buflen) {
77 		if (tbuf->bufpos == 0)
78 			buf = malloc(l);
79 		else
80 			buf = realloc(tbuf->buf, l);
81 		if (buf == NULL)
82 			return NULL;
83 		tbuf->buf = buf;
84 		tbuf->buflen = l;
85 	}
86 	return tbuf->buf;
87 }
88 
89 char *
90 _ti_find_cap(TBUF *tbuf, char type, short ind)
91 {
92 	size_t n;
93 	short num;
94 	char *cap;
95 
96 	_DIAGASSERT(tbuf != NULL);
97 
98 	cap = tbuf->buf;
99 	for (n = tbuf->entries; n > 0; n--) {
100 		num = le16dec(cap);
101 		cap += sizeof(uint16_t);
102 		if (num == ind)
103 			return cap;
104 		switch (type) {
105 		case 'f':
106 			cap++;
107 			break;
108 		case 'n':
109 			cap += sizeof(uint16_t);
110 			break;
111 		case 's':
112 			num = le16dec(cap);
113 			cap += sizeof(uint16_t);
114 			cap += num;
115 			break;
116 		}
117 	}
118 
119 	errno = ESRCH;
120 	return NULL;
121 }
122 
123 char *
124 _ti_find_extra(TBUF *tbuf, const char *code)
125 {
126 	size_t n;
127 	short num;
128 	char *cap;
129 
130 	_DIAGASSERT(tbuf != NULL);
131 	_DIAGASSERT(code != NULL);
132 
133 	cap = tbuf->buf;
134 	for (n = tbuf->entries; n > 0; n--) {
135 		num = le16dec(cap);
136 		cap += sizeof(uint16_t);
137 		if (strcmp(cap, code) == 0)
138 			return cap + num;
139 		cap += num;
140 		switch (*cap++) {
141 		case 'f':
142 			cap++;
143 			break;
144 		case 'n':
145 			cap += sizeof(uint16_t);
146 			break;
147 		case 's':
148 			num = le16dec(cap);
149 			cap += sizeof(uint16_t);
150 			cap += num;
151 			break;
152 		}
153 	}
154 
155 	errno = ESRCH;
156 	return NULL;
157 }
158 
159 size_t
160 _ti_store_extra(TIC *tic, int wrn, char *id, char type, char flag, short num,
161     char *str, size_t strl, int flags)
162 {
163 	size_t l;
164 
165 	_DIAGASSERT(tic != NULL);
166 
167 	if (strcmp(id, "use") != 0) {
168 		if (_ti_find_extra(&tic->extras, id) != NULL)
169 			return 0;
170 		if (!(flags & TIC_EXTRA)) {
171 			if (wrn != 0)
172 				dowarn(flags, "%s: %s: unknown capability",
173 				    tic->name, id);
174 			return 0;
175 		}
176 	}
177 
178 	l = strlen(id) + 1;
179 	if (l > UINT16_T_MAX) {
180 		dowarn(flags, "%s: %s: cap name is too long", tic->name, id);
181 		return 0;
182 	}
183 
184 	if (!_ti_grow_tbuf(&tic->extras,
185 		l + strl + (sizeof(uint16_t) * 2) + 1))
186 		return 0;
187 	le16enc(tic->extras.buf + tic->extras.bufpos, l);
188 	tic->extras.bufpos += sizeof(uint16_t);
189      	memcpy(tic->extras.buf + tic->extras.bufpos, id, l);
190 	tic->extras.bufpos += l;
191 	tic->extras.buf[tic->extras.bufpos++] = type;
192 	switch (type) {
193 	case 'f':
194 		tic->extras.buf[tic->extras.bufpos++] = flag;
195 		break;
196 	case 'n':
197 		le16enc(tic->extras.buf + tic->extras.bufpos, num);
198 		tic->extras.bufpos += sizeof(uint16_t);
199 		break;
200 	case 's':
201 		le16enc(tic->extras.buf + tic->extras.bufpos, strl);
202 		tic->extras.bufpos += sizeof(uint16_t);
203 		memcpy(tic->extras.buf + tic->extras.bufpos, str, strl);
204 		tic->extras.bufpos += strl;
205 		break;
206 	}
207 	tic->extras.entries++;
208 	return 1;
209 }
210 
211 ssize_t
212 _ti_flatten(uint8_t **buf, const TIC *tic)
213 {
214 	size_t buflen, len, alen, dlen;
215 	uint8_t *cap;
216 
217 	_DIAGASSERT(buf != NULL);
218 	_DIAGASSERT(tic != NULL);
219 
220 	len = strlen(tic->name) + 1;
221 	if (tic->alias == NULL)
222 		alen = 0;
223 	else
224 		alen = strlen(tic->alias) + 1;
225 	if (tic->desc == NULL)
226 		dlen = 0;
227 	else
228 		dlen = strlen(tic->desc) + 1;
229 	buflen = sizeof(char) +
230 	    sizeof(uint16_t) + len +
231 	    sizeof(uint16_t) + alen +
232 	    sizeof(uint16_t) + dlen +
233 	    (sizeof(uint16_t) * 2) + tic->flags.bufpos +
234 	    (sizeof(uint16_t) * 2) + tic->nums.bufpos +
235 	    (sizeof(uint16_t) * 2) + tic->strs.bufpos +
236 	    (sizeof(uint16_t) * 2) + tic->extras.bufpos;
237 	*buf = malloc(buflen);
238 	if (*buf == NULL)
239 		return -1;
240 
241 	cap = *buf;
242 	if (alen == 0 && dlen == 0 && tic->flags.bufpos == 0 &&
243 	    tic->nums.bufpos == 0 && tic->strs.bufpos == 0 &&
244 	    tic->extras.bufpos == 0)
245 		*cap++ = 0; /* alias */
246 	else
247 		*cap++ = 2; /* version */
248 	le16enc(cap, len);
249 	cap += sizeof(uint16_t);
250 	memcpy(cap, tic->name, len);
251 	cap += len;
252 
253 	le16enc(cap, alen);
254 	cap += sizeof(uint16_t);
255 	if (tic->alias != NULL) {
256 		memcpy(cap, tic->alias, alen);
257 		cap += alen;
258 	}
259 	le16enc(cap, dlen);
260 	cap += sizeof(uint16_t);
261 	if (tic->desc != NULL) {
262 		memcpy(cap, tic->desc, dlen);
263 		cap += dlen;
264 	}
265 
266 	if (tic->flags.entries == 0) {
267 		le16enc(cap, 0);
268 		cap += sizeof(uint16_t);
269 	} else {
270 		le16enc(cap, (tic->flags.bufpos + sizeof(uint16_t)));
271 		cap += sizeof(uint16_t);
272 		le16enc(cap, tic->flags.entries);
273 		cap += sizeof(uint16_t);
274 		memcpy(cap, tic->flags.buf, tic->flags.bufpos);
275 		cap += tic->flags.bufpos;
276 	}
277 
278 	if (tic->nums.entries == 0) {
279 		le16enc(cap, 0);
280 		cap += sizeof(uint16_t);
281 	} else {
282 		le16enc(cap, (tic->nums.bufpos + sizeof(uint16_t)));
283 		cap += sizeof(uint16_t);
284 		le16enc(cap, tic->nums.entries);
285 		cap += sizeof(uint16_t);
286 		memcpy(cap, tic->nums.buf, tic->nums.bufpos);
287 		cap += tic->nums.bufpos;
288 	}
289 
290 	if (tic->strs.entries == 0) {
291 		le16enc(cap, 0);
292 		cap += sizeof(uint16_t);
293 	} else {
294 		le16enc(cap, (tic->strs.bufpos + sizeof(uint16_t)));
295 		cap += sizeof(uint16_t);
296 		le16enc(cap, tic->strs.entries);
297 		cap += sizeof(uint16_t);
298 		memcpy(cap, tic->strs.buf, tic->strs.bufpos);
299 		cap += tic->strs.bufpos;
300 	}
301 
302 	if (tic->extras.entries == 0) {
303 		le16enc(cap, 0);
304 		cap += sizeof(uint16_t);
305 	} else {
306 		le16enc(cap, (tic->extras.bufpos + sizeof(uint16_t)));
307 		cap += sizeof(uint16_t);
308 		le16enc(cap, tic->extras.entries);
309 		cap += sizeof(uint16_t);
310 		memcpy(cap, tic->extras.buf, tic->extras.bufpos);
311 		cap += tic->extras.bufpos;
312 	}
313 
314 	return cap - *buf;
315 }
316 
317 static int
318 encode_string(const char *term, const char *cap, TBUF *tbuf, const char *str,
319     int flags)
320 {
321 	int slash, i, num;
322 	char ch, *p, *s, last;
323 
324 	if (_ti_grow_tbuf(tbuf, strlen(str) + 1) == NULL)
325 		return -1;
326 	p = s = tbuf->buf + tbuf->bufpos;
327 	slash = 0;
328 	last = '\0';
329 	/* Convert escape codes */
330 	while ((ch = *str++) != '\0') {
331 		if (slash == 0 && ch == '\\') {
332 			slash = 1;
333 			continue;
334 		}
335 		if (slash == 0) {
336 			if (last != '%' && ch == '^') {
337 				ch = *str++;
338 				if (((unsigned char)ch) >= 128)
339 					dowarn(flags,
340 					    "%s: %s: illegal ^ character",
341 					    term, cap);
342 				if (ch == '\0')
343 					break;
344 				if (ch == '?')
345 					ch = '\177';
346 				else if ((ch &= 037) == 0)
347 					ch = (char)128;
348 			}
349 			*p++ = ch;
350 			last = ch;
351 			continue;
352 		}
353 		slash = 0;
354 		if (ch >= '0' && ch <= '7') {
355 			num = ch - '0';
356 			for (i = 0; i < 2; i++) {
357 				if (*str < '0' || *str > '7') {
358 					if (isdigit((unsigned char)*str))
359 						dowarn(flags,
360 						    "%s: %s: non octal"
361 						    " digit", term, cap);
362 					else
363 						break;
364 				}
365 				num = num * 8 + *str++ - '0';
366 			}
367 			if (num == 0)
368 				num = 0200;
369 			*p++ = (char)num;
370 			continue;
371 		}
372 		switch (ch) {
373 		case 'a':
374 			*p++ = '\a';
375 			break;
376 		case 'b':
377 			*p++ = '\b';
378 			break;
379 		case 'e': /* FALLTHROUGH */
380 		case 'E':
381 			*p++ = '\033';
382 			break;
383 		case 'f':
384 			*p++ = '\014';
385 			break;
386 		case 'l': /* FALLTHROUGH */
387 		case 'n':
388 			*p++ = '\n';
389 			break;
390 		case 'r':
391 			*p++ = '\r';
392 			break;
393 		case 's':
394 			*p++ = ' ';
395 			break;
396 		case 't':
397 			*p++ = '\t';
398 			break;
399 		default:
400 
401 			/* We should warn here */
402 		case '^':
403 		case ',':
404 		case ':':
405 		case '|':
406 			*p++ = ch;
407 			break;
408 		}
409 		last = ch;
410 	}
411 	*p++ = '\0';
412 	tbuf->bufpos += p - s;
413 	return 0;
414 }
415 
416 char *
417 _ti_get_token(char **cap, char sep)
418 {
419 	char esc, *token;
420 
421 	while (isspace((unsigned char)**cap))
422 		(*cap)++;
423 	if (**cap == '\0')
424 		return NULL;
425 
426 	/* We can't use stresep(3) as ^ we need two escape chars */
427 	esc = '\0';
428 	for (token = *cap;
429 	     **cap != '\0' && (esc != '\0' || **cap != sep);
430 	     (*cap)++)
431 	{
432 		if (esc == '\0') {
433 			if (**cap == '\\' || **cap == '^')
434 				esc = **cap;
435 		} else {
436 			/* termcap /E/ is valid */
437 			if (sep == ':' && esc == '\\' && **cap == 'E')
438 				esc = 'x';
439 			else
440 				esc = '\0';
441 		}
442 	}
443 
444 	if (**cap != '\0')
445 		*(*cap)++ = '\0';
446 
447 	return token;
448 }
449 
450 TIC *
451 _ti_compile(char *cap, int flags)
452 {
453 	char *token, *p, *e, *name, *desc, *alias;
454 	signed char flag;
455 	long cnum;
456 	short num;
457 	ssize_t ind;
458 	size_t len;
459 	TBUF buf;
460 	TIC *tic;
461 
462 	_DIAGASSERT(cap != NULL);
463 
464 	name = _ti_get_token(&cap, ',');
465 	if (name == NULL) {
466 		dowarn(flags, "no seperator found: %s", cap);
467 		return NULL;
468 	}
469 	desc = strrchr(name, '|');
470 	if (desc != NULL)
471 		*desc++ = '\0';
472 	alias = strchr(name, '|');
473 	if (alias != NULL)
474 		*alias++ = '\0';
475 
476 	tic = calloc(sizeof(*tic), 1);
477 	if (tic == NULL)
478 		return NULL;
479 
480 	buf.buf = NULL;
481 	buf.buflen = 0;
482 
483 	tic->name = strdup(name);
484 	if (tic->name == NULL)
485 		goto error;
486 	if (alias != NULL && flags & TIC_ALIAS) {
487 		tic->alias = strdup(alias);
488 		if (tic->alias == NULL)
489 			goto error;
490 	}
491 	if (desc != NULL && flags & TIC_DESCRIPTION) {
492 		tic->desc = strdup(desc);
493 		if (tic->desc == NULL)
494 			goto error;
495 	}
496 
497 	for (token = _ti_get_token(&cap, ',');
498 	     token != NULL && *token != '\0';
499 	     token = _ti_get_token(&cap, ','))
500 	{
501 		/* Skip commented caps */
502 		if (!(flags & TIC_COMMENT) && token[0] == '.')
503 			continue;
504 
505 		/* Obsolete entries */
506 		if (token[0] == 'O' && token[1] == 'T') {
507 			if (!(flags & TIC_EXTRA))
508 				continue;
509 			token += 2;
510 		}
511 
512 		/* str cap */
513 		p = strchr(token, '=');
514 		if (p != NULL) {
515 			*p++ = '\0';
516 			/* Don't use the string if we already have it */
517 			ind = _ti_strindex(token);
518 			if (ind != -1 &&
519 			    _ti_find_cap(&tic->strs, 's', ind) != NULL)
520 				continue;
521 
522 			/* Encode the string to our scratch buffer */
523 			buf.bufpos = 0;
524 			if (encode_string(tic->name, token,
525 				&buf, p, flags) == -1)
526 				goto error;
527 			if (buf.bufpos > UINT16_T_MAX) {
528 				dowarn(flags, "%s: %s: string is too long",
529 				    tic->name, token);
530 				continue;
531 			}
532 			if (!VALID_STRING(buf.buf)) {
533 				dowarn(flags, "%s: %s: invalid string",
534 				    tic->name, token);
535 				continue;
536 			}
537 
538 			if (ind == -1)
539 				_ti_store_extra(tic, 1, token, 's', -1, -2,
540 				    buf.buf, buf.bufpos, flags);
541 			else {
542 				if (!_ti_grow_tbuf(&tic->strs,
543 					(sizeof(uint16_t) * 2) + buf.bufpos))
544 					goto error;
545 				le16enc(tic->strs.buf + tic->strs.bufpos, ind);
546 				tic->strs.bufpos += sizeof(uint16_t);
547 				le16enc(tic->strs.buf + tic->strs.bufpos,
548 				    buf.bufpos);
549 				tic->strs.bufpos += sizeof(uint16_t);
550 				memcpy(tic->strs.buf + tic->strs.bufpos,
551 				    buf.buf, buf.bufpos);
552 				tic->strs.bufpos += buf.bufpos;
553 				tic->strs.entries++;
554 			}
555 			continue;
556 		}
557 
558 		/* num cap */
559 		p = strchr(token, '#');
560 		if (p != NULL) {
561 			*p++ = '\0';
562 			/* Don't use the number if we already have it */
563 			ind = _ti_numindex(token);
564 			if (ind != -1 &&
565 			    _ti_find_cap(&tic->nums, 'n', ind) != NULL)
566 				continue;
567 
568 			cnum = strtol(p, &e, 0);
569 			if (*e != '\0') {
570 				dowarn(flags, "%s: %s: not a number",
571 				    tic->name, token);
572 				continue;
573 			}
574 			if (!VALID_NUMERIC(cnum)) {
575 				dowarn(flags, "%s: %s: number out of range",
576 				    tic->name, token);
577 				continue;
578 			}
579 			num = (short)cnum;
580 			if (ind == -1)
581 				_ti_store_extra(tic, 1, token, 'n', -1,
582 				    num, NULL, 0, flags);
583 			else {
584 				if (_ti_grow_tbuf(&tic->nums,
585 					sizeof(uint16_t) * 2) == NULL)
586 					goto error;
587 				le16enc(tic->nums.buf + tic->nums.bufpos, ind);
588 				tic->nums.bufpos += sizeof(uint16_t);
589 				le16enc(tic->nums.buf + tic->nums.bufpos, num);
590 				tic->nums.bufpos += sizeof(uint16_t);
591 				tic->nums.entries++;
592 			}
593 			continue;
594 		}
595 
596 		flag = 1;
597 		len = strlen(token) - 1;
598 		if (token[len] == '@') {
599 			flag = CANCELLED_BOOLEAN;
600 			token[len] = '\0';
601 		}
602 		ind = _ti_flagindex(token);
603 		if (ind == -1 && flag == CANCELLED_BOOLEAN) {
604 			if ((ind = _ti_numindex(token)) != -1) {
605 				if (_ti_find_cap(&tic->nums, 'n', ind) != NULL)
606 					continue;
607 				if (_ti_grow_tbuf(&tic->nums,
608 					sizeof(uint16_t) * 2) == NULL)
609 					goto error;
610 				le16enc(tic->nums.buf + tic->nums.bufpos, ind);
611 				tic->nums.bufpos += sizeof(uint16_t);
612 				le16enc(tic->nums.buf + tic->nums.bufpos,
613 					(uint16_t)CANCELLED_NUMERIC);
614 				tic->nums.bufpos += sizeof(uint16_t);
615 				tic->nums.entries++;
616 				continue;
617 			} else if ((ind = _ti_strindex(token)) != -1) {
618 				if (_ti_find_cap(&tic->strs, 's', ind) != NULL)
619 					continue;
620 				if (_ti_grow_tbuf(&tic->strs,
621 					(sizeof(uint16_t) * 2) + 1) == NULL)
622 					goto error;
623 				le16enc(tic->strs.buf + tic->strs.bufpos, ind);
624 				tic->strs.bufpos += sizeof(uint16_t);
625 				le16enc(tic->strs.buf + tic->strs.bufpos, 0);
626 				tic->strs.bufpos += sizeof(uint16_t);
627 				tic->strs.entries++;
628 				continue;
629 			}
630 		}
631 		if (ind == -1)
632 			_ti_store_extra(tic, 1, token, 'f', flag, 0, NULL, 0,
633 			    flags);
634 		else if (_ti_find_cap(&tic->flags, 'f', ind) == NULL) {
635 			if (_ti_grow_tbuf(&tic->flags, sizeof(uint16_t) + 1)
636 			    == NULL)
637 				goto error;
638 			le16enc(tic->flags.buf + tic->flags.bufpos, ind);
639 			tic->flags.bufpos += sizeof(uint16_t);
640 			tic->flags.buf[tic->flags.bufpos++] = flag;
641 			tic->flags.entries++;
642 		}
643 	}
644 
645 	free(buf.buf);
646 	return tic;
647 
648 error:
649 	free(buf.buf);
650 	_ti_freetic(tic);
651 	return NULL;
652 }
653 
654 void
655 _ti_freetic(TIC *tic)
656 {
657 
658 	if (tic != NULL) {
659 		free(tic->name);
660 		free(tic->alias);
661 		free(tic->desc);
662 		free(tic->flags.buf);
663 		free(tic->nums.buf);
664 		free(tic->strs.buf);
665 		free(tic);
666 	}
667 }
668