1 /* $NetBSD: compile.c,v 1.9 2013/06/07 13:16:18 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.9 2013/06/07 13:16:18 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 __printflike(2, 3)
dowarn(int flags,const char * fmt,...)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 *
_ti_grow_tbuf(TBUF * tbuf,size_t len)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->buflen == 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 *
_ti_find_cap(TBUF * tbuf,char type,short ind)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 *
_ti_find_extra(TBUF * tbuf,const char * code)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
_ti_store_extra(TIC * tic,int wrn,char * id,char type,char flag,short num,char * str,size_t strl,int flags)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
_ti_flatten(uint8_t ** buf,const TIC * tic)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 *cap++ = 1;
243 le16enc(cap, len);
244 cap += sizeof(uint16_t);
245 memcpy(cap, tic->name, len);
246 cap += len;
247
248 le16enc(cap, alen);
249 cap += sizeof(uint16_t);
250 if (tic->alias != NULL) {
251 memcpy(cap, tic->alias, alen);
252 cap += alen;
253 }
254 le16enc(cap, dlen);
255 cap += sizeof(uint16_t);
256 if (tic->desc != NULL) {
257 memcpy(cap, tic->desc, dlen);
258 cap += dlen;
259 }
260
261 if (tic->flags.entries == 0) {
262 le16enc(cap, 0);
263 cap += sizeof(uint16_t);
264 } else {
265 le16enc(cap, (tic->flags.bufpos + sizeof(uint16_t)));
266 cap += sizeof(uint16_t);
267 le16enc(cap, tic->flags.entries);
268 cap += sizeof(uint16_t);
269 memcpy(cap, tic->flags.buf, tic->flags.bufpos);
270 cap += tic->flags.bufpos;
271 }
272
273 if (tic->nums.entries == 0) {
274 le16enc(cap, 0);
275 cap += sizeof(uint16_t);
276 } else {
277 le16enc(cap, (tic->nums.bufpos + sizeof(uint16_t)));
278 cap += sizeof(uint16_t);
279 le16enc(cap, tic->nums.entries);
280 cap += sizeof(uint16_t);
281 memcpy(cap, tic->nums.buf, tic->nums.bufpos);
282 cap += tic->nums.bufpos;
283 }
284
285 if (tic->strs.entries == 0) {
286 le16enc(cap, 0);
287 cap += sizeof(uint16_t);
288 } else {
289 le16enc(cap, (tic->strs.bufpos + sizeof(uint16_t)));
290 cap += sizeof(uint16_t);
291 le16enc(cap, tic->strs.entries);
292 cap += sizeof(uint16_t);
293 memcpy(cap, tic->strs.buf, tic->strs.bufpos);
294 cap += tic->strs.bufpos;
295 }
296
297 if (tic->extras.entries == 0) {
298 le16enc(cap, 0);
299 cap += sizeof(uint16_t);
300 } else {
301 le16enc(cap, (tic->extras.bufpos + sizeof(uint16_t)));
302 cap += sizeof(uint16_t);
303 le16enc(cap, tic->extras.entries);
304 cap += sizeof(uint16_t);
305 memcpy(cap, tic->extras.buf, tic->extras.bufpos);
306 cap += tic->extras.bufpos;
307 }
308
309 return cap - *buf;
310 }
311
312 static int
encode_string(const char * term,const char * cap,TBUF * tbuf,const char * str,int flags)313 encode_string(const char *term, const char *cap, TBUF *tbuf, const char *str,
314 int flags)
315 {
316 int slash, i, num;
317 char ch, *p, *s, last;
318
319 if (_ti_grow_tbuf(tbuf, strlen(str) + 1) == NULL)
320 return -1;
321 p = s = tbuf->buf + tbuf->bufpos;
322 slash = 0;
323 last = '\0';
324 /* Convert escape codes */
325 while ((ch = *str++) != '\0') {
326 if (slash == 0 && ch == '\\') {
327 slash = 1;
328 continue;
329 }
330 if (slash == 0) {
331 if (last != '%' && ch == '^') {
332 ch = *str++;
333 if (((unsigned char)ch) >= 128)
334 dowarn(flags,
335 "%s: %s: illegal ^ character",
336 term, cap);
337 if (ch == '\0')
338 break;
339 if (ch == '?')
340 ch = '\177';
341 else if ((ch &= 037) == 0)
342 ch = (char)128;
343 }
344 *p++ = ch;
345 last = ch;
346 continue;
347 }
348 slash = 0;
349 if (ch >= '0' && ch <= '7') {
350 num = ch - '0';
351 for (i = 0; i < 2; i++) {
352 if (*str < '0' || *str > '7') {
353 if (isdigit((unsigned char)*str))
354 dowarn(flags,
355 "%s: %s: non octal"
356 " digit", term, cap);
357 else
358 break;
359 }
360 num = num * 8 + *str++ - '0';
361 }
362 if (num == 0)
363 num = 0200;
364 *p++ = (char)num;
365 continue;
366 }
367 switch (ch) {
368 case 'a':
369 *p++ = '\a';
370 break;
371 case 'b':
372 *p++ = '\b';
373 break;
374 case 'e': /* FALLTHROUGH */
375 case 'E':
376 *p++ = '\033';
377 break;
378 case 'f':
379 *p++ = '\014';
380 break;
381 case 'l': /* FALLTHROUGH */
382 case 'n':
383 *p++ = '\n';
384 break;
385 case 'r':
386 *p++ = '\r';
387 break;
388 case 's':
389 *p++ = ' ';
390 break;
391 case 't':
392 *p++ = '\t';
393 break;
394 default:
395 /* We should warn here */
396 case '^':
397 case ',':
398 case ':':
399 case '|':
400 *p++ = ch;
401 break;
402 }
403 last = ch;
404 }
405 *p++ = '\0';
406 tbuf->bufpos += p - s;
407 return 0;
408 }
409
410 char *
_ti_get_token(char ** cap,char sep)411 _ti_get_token(char **cap, char sep)
412 {
413 char esc, *token;
414
415 while (isspace((unsigned char)**cap))
416 (*cap)++;
417 if (**cap == '\0')
418 return NULL;
419
420 /* We can't use stresep(3) as ^ we need two escape chars */
421 esc = '\0';
422 for (token = *cap;
423 **cap != '\0' && (esc != '\0' || **cap != sep);
424 (*cap)++)
425 {
426 if (esc == '\0') {
427 if (**cap == '\\' || **cap == '^')
428 esc = **cap;
429 } else {
430 /* termcap /E/ is valid */
431 if (sep == ':' && esc == '\\' && **cap == 'E')
432 esc = 'x';
433 else
434 esc = '\0';
435 }
436 }
437
438 if (**cap != '\0')
439 *(*cap)++ = '\0';
440
441 return token;
442 }
443
444 TIC *
_ti_compile(char * cap,int flags)445 _ti_compile(char *cap, int flags)
446 {
447 char *token, *p, *e, *name, *desc, *alias;
448 signed char flag;
449 long cnum;
450 short num;
451 ssize_t ind;
452 size_t len;
453 TBUF buf;
454 TIC *tic;
455
456 _DIAGASSERT(cap != NULL);
457
458 name = _ti_get_token(&cap, ',');
459 if (name == NULL) {
460 dowarn(flags, "no seperator found: %s", cap);
461 return NULL;
462 }
463 desc = strrchr(name, '|');
464 if (desc != NULL)
465 *desc++ = '\0';
466 alias = strchr(name, '|');
467 if (alias != NULL)
468 *alias++ = '\0';
469
470 tic = calloc(sizeof(*tic), 1);
471 if (tic == NULL)
472 return NULL;
473
474 buf.buf = NULL;
475 buf.buflen = 0;
476
477 tic->name = strdup(name);
478 if (tic->name == NULL)
479 goto error;
480 if (alias != NULL && flags & TIC_ALIAS) {
481 tic->alias = strdup(alias);
482 if (tic->alias == NULL)
483 goto error;
484 }
485 if (desc != NULL && flags & TIC_DESCRIPTION) {
486 tic->desc = strdup(desc);
487 if (tic->desc == NULL)
488 goto error;
489 }
490
491 for (token = _ti_get_token(&cap, ',');
492 token != NULL && *token != '\0';
493 token = _ti_get_token(&cap, ','))
494 {
495 /* Skip commented caps */
496 if (!(flags & TIC_COMMENT) && token[0] == '.')
497 continue;
498
499 /* Obsolete entries */
500 if (token[0] == 'O' && token[1] == 'T') {
501 if (!(flags & TIC_EXTRA))
502 continue;
503 token += 2;
504 }
505
506 /* str cap */
507 p = strchr(token, '=');
508 if (p != NULL) {
509 *p++ = '\0';
510 /* Don't use the string if we already have it */
511 ind = _ti_strindex(token);
512 if (ind != -1 &&
513 _ti_find_cap(&tic->strs, 's', ind) != NULL)
514 continue;
515
516 /* Encode the string to our scratch buffer */
517 buf.bufpos = 0;
518 if (encode_string(tic->name, token,
519 &buf, p, flags) == -1)
520 goto error;
521 if (buf.bufpos > UINT16_T_MAX) {
522 dowarn(flags, "%s: %s: string is too long",
523 tic->name, token);
524 continue;
525 }
526 if (!VALID_STRING(buf.buf)) {
527 dowarn(flags, "%s: %s: invalid string",
528 tic->name, token);
529 continue;
530 }
531
532 if (ind == -1)
533 _ti_store_extra(tic, 1, token, 's', -1, -2,
534 buf.buf, buf.bufpos, flags);
535 else {
536 if (!_ti_grow_tbuf(&tic->strs,
537 (sizeof(uint16_t) * 2) + buf.bufpos))
538 goto error;
539 le16enc(tic->strs.buf + tic->strs.bufpos, ind);
540 tic->strs.bufpos += sizeof(uint16_t);
541 le16enc(tic->strs.buf + tic->strs.bufpos,
542 buf.bufpos);
543 tic->strs.bufpos += sizeof(uint16_t);
544 memcpy(tic->strs.buf + tic->strs.bufpos,
545 buf.buf, buf.bufpos);
546 tic->strs.bufpos += buf.bufpos;
547 tic->strs.entries++;
548 }
549 continue;
550 }
551
552 /* num cap */
553 p = strchr(token, '#');
554 if (p != NULL) {
555 *p++ = '\0';
556 /* Don't use the number if we already have it */
557 ind = _ti_numindex(token);
558 if (ind != -1 &&
559 _ti_find_cap(&tic->nums, 'n', ind) != NULL)
560 continue;
561
562 cnum = strtol(p, &e, 0);
563 if (*e != '\0') {
564 dowarn(flags, "%s: %s: not a number",
565 tic->name, token);
566 continue;
567 }
568 if (!VALID_NUMERIC(cnum)) {
569 dowarn(flags, "%s: %s: number out of range",
570 tic->name, token);
571 continue;
572 }
573 num = (short)cnum;
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 (uint16_t)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
642 error:
643 free(buf.buf);
644 _ti_freetic(tic);
645 return NULL;
646 }
647
648 void
_ti_freetic(TIC * tic)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->extras.buf);
657 free(tic->flags.buf);
658 free(tic->nums.buf);
659 free(tic->strs.buf);
660 free(tic);
661 }
662 }
663