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