compile.c revision 1.3 
1/* $NetBSD: compile.c,v 1.3 2010/03/01 01:59:48 dholland 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.3 2010/03/01 01:59:48 dholland 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
54static void __attribute__((__format__(__printf__, 2, 3)))
55dowarn(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
67char *
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
89char *
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
123char *
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
159size_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
211ssize_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
317static int
318encode_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 = 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
416static char *
417get_token(char **cap)
418{
419	char *token;
420	int esc;
421
422	while (isspace((unsigned char)**cap))
423		(*cap)++;
424	if (**cap == '\0')
425		return NULL;
426
427	/* We can't use stresep(3) as ^ we need two escape chars */
428	esc = 0;
429	for (token = *cap;
430	     **cap != '\0' && (esc == 1 || **cap != ',');
431	     (*cap)++)
432	{
433		if (esc == 0) {
434			if (**cap == '\\' || **cap == '^')
435				esc = 1;
436		} else
437			esc = 0;
438	}
439
440	if (**cap != '\0')
441		*(*cap)++ = '\0';
442
443	return token;
444}
445
446TIC *
447_ti_compile(char *cap, int flags)
448{
449	char *token, *p, *e, *name, *desc, *alias;
450	signed char flag;
451	long num;
452	ssize_t ind;
453	size_t len;
454	TBUF buf;
455	TIC *tic;
456
457	_DIAGASSERT(cap != NULL);
458
459	name = get_token(&cap);
460	if (name == NULL) {
461		dowarn(flags, "no seperator found: %s", cap);
462		return NULL;
463	}
464	desc = strrchr(name, '|');
465	if (desc != NULL)
466		*desc++ = '\0';
467	alias = strchr(name, '|');
468	if (alias != NULL)
469		*alias++ = '\0';
470
471	tic = calloc(sizeof(*tic), 1);
472	if (tic == NULL)
473		return NULL;
474
475	buf.buf = NULL;
476	buf.buflen = 0;
477
478	tic->name = strdup(name);
479	if (tic->name == NULL)
480		goto error;
481	if (alias != NULL && flags & TIC_ALIAS) {
482		tic->alias = strdup(alias);
483		if (tic->alias == NULL)
484			goto error;
485	}
486	if (desc != NULL && flags & TIC_DESCRIPTION) {
487		tic->desc = strdup(desc);
488		if (tic->desc == NULL)
489			goto error;
490	}
491
492	for (token = get_token(&cap);
493	     token != NULL && *token != '\0';
494	     token = get_token(&cap))
495	{
496		/* Skip commented caps */
497		if (!(flags & TIC_COMMENT) && token[0] == '.')
498			continue;
499
500		/* Obsolete entries */
501		if (token[0] == 'O' && token[1] == 'T') {
502			if (!(flags & TIC_EXTRA))
503				continue;
504			token += 2;
505		}
506
507		/* str cap */
508		p = strchr(token, '=');
509		if (p != NULL) {
510			*p++ = '\0';
511			/* Don't use the string if we already have it */
512			ind = _ti_strindex(token);
513			if (ind != -1 &&
514			    _ti_find_cap(&tic->strs, 's', ind) != NULL)
515				continue;
516
517			/* Encode the string to our scratch buffer */
518			buf.bufpos = 0;
519			if (encode_string(tic->name, token,
520				&buf, p, flags) == -1)
521				goto error;
522			if (buf.bufpos > UINT16_T_MAX) {
523				dowarn(flags, "%s: %s: string is too long",
524				    tic->name, token);
525				continue;
526			}
527			if (!VALID_STRING(buf.buf)) {
528				dowarn(flags, "%s: %s: invalid string",
529				    tic->name, token);
530				continue;
531			}
532
533			if (ind == -1)
534				_ti_store_extra(tic, 1, token, 's', -1, -2,
535				    buf.buf, buf.bufpos, flags);
536			else {
537				if (!_ti_grow_tbuf(&tic->strs,
538					(sizeof(uint16_t) * 2) + buf.bufpos))
539					goto error;
540				le16enc(tic->strs.buf + tic->strs.bufpos, ind);
541				tic->strs.bufpos += sizeof(uint16_t);
542				le16enc(tic->strs.buf + tic->strs.bufpos,
543				    buf.bufpos);
544				tic->strs.bufpos += sizeof(uint16_t);
545				memcpy(tic->strs.buf + tic->strs.bufpos,
546				    buf.buf, buf.bufpos);
547				tic->strs.bufpos += buf.bufpos;
548				tic->strs.entries++;
549			}
550			continue;
551		}
552
553		/* num cap */
554		p = strchr(token, '#');
555		if (p != NULL) {
556			*p++ = '\0';
557			/* Don't use the number if we already have it */
558			ind = _ti_numindex(token);
559			if (ind != -1 &&
560			    _ti_find_cap(&tic->nums, 'n', ind) != NULL)
561				continue;
562
563			num = strtol(p, &e, 0);
564			if (*e != '\0') {
565				dowarn(flags, "%s: %s: not a number",
566				    tic->name, token);
567				continue;
568			}
569			if (!VALID_NUMERIC(num)) {
570				dowarn(flags, "%s: %s: number out of range",
571				    tic->name, token);
572				continue;
573			}
574			if (ind == -1)
575				_ti_store_extra(tic, 1, token, 'n', -1,
576				    num, NULL, 0, flags);
577			else {
578				if (_ti_grow_tbuf(&tic->nums,
579					sizeof(uint16_t) * 2) == NULL)
580					goto error;
581				le16enc(tic->nums.buf + tic->nums.bufpos, ind);
582				tic->nums.bufpos += sizeof(uint16_t);
583				le16enc(tic->nums.buf + tic->nums.bufpos, num);
584				tic->nums.bufpos += sizeof(uint16_t);
585				tic->nums.entries++;
586			}
587			continue;
588		}
589
590		flag = 1;
591		len = strlen(token) - 1;
592		if (token[len] == '@') {
593			flag = CANCELLED_BOOLEAN;
594			token[len] = '\0';
595		}
596		ind = _ti_flagindex(token);
597		if (ind == -1 && flag == CANCELLED_BOOLEAN) {
598			if ((ind = _ti_numindex(token)) != -1) {
599				if (_ti_find_cap(&tic->nums, 'n', ind) != NULL)
600					continue;
601				if (_ti_grow_tbuf(&tic->nums,
602					sizeof(uint16_t) * 2) == NULL)
603					goto error;
604				le16enc(tic->nums.buf + tic->nums.bufpos, ind);
605				tic->nums.bufpos += sizeof(uint16_t);
606				le16enc(tic->nums.buf + tic->nums.bufpos,
607					CANCELLED_NUMERIC);
608				tic->nums.bufpos += sizeof(uint16_t);
609				tic->nums.entries++;
610				continue;
611			} else if ((ind = _ti_strindex(token)) != -1) {
612				if (_ti_find_cap(&tic->strs, 's', ind) != NULL)
613					continue;
614				if (_ti_grow_tbuf(&tic->strs,
615					(sizeof(uint16_t) * 2) + 1) == NULL)
616					goto error;
617				le16enc(tic->strs.buf + tic->strs.bufpos, ind);
618				tic->strs.bufpos += sizeof(uint16_t);
619				le16enc(tic->strs.buf + tic->strs.bufpos, 0);
620				tic->strs.bufpos += sizeof(uint16_t);
621				tic->strs.entries++;
622				continue;
623			}
624		}
625		if (ind == -1)
626			_ti_store_extra(tic, 1, token, 'f', flag, 0, NULL, 0,
627			    flags);
628		else if (_ti_find_cap(&tic->flags, 'f', ind) == NULL) {
629			if (_ti_grow_tbuf(&tic->flags, sizeof(uint16_t) + 1)
630			    == NULL)
631				goto error;
632			le16enc(tic->flags.buf + tic->flags.bufpos, ind);
633			tic->flags.bufpos += sizeof(uint16_t);
634			tic->flags.buf[tic->flags.bufpos++] = flag;
635			tic->flags.entries++;
636		}
637	}
638
639	free(buf.buf);
640	return tic;
641
642error:
643	free(buf.buf);
644	_ti_freetic(tic);
645	return NULL;
646}
647
648void
649_ti_freetic(TIC *tic)
650{
651
652	if (tic != NULL) {
653		free(tic->name);
654		free(tic->alias);
655		free(tic->desc);
656		free(tic->flags.buf);
657		free(tic->nums.buf);
658		free(tic->strs.buf);
659		free(tic);
660	}
661}
662