compile.c revision 1.7
1/* $NetBSD: compile.c,v 1.7 2012/06/01 12:08:40 joerg 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.7 2012/06/01 12:08:40 joerg 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 __printflike(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->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 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 = (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 416char * 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 450TIC * 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 648error: 649 free(buf.buf); 650 _ti_freetic(tic); 651 return NULL; 652} 653 654void 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->extras.buf); 663 free(tic->flags.buf); 664 free(tic->nums.buf); 665 free(tic->strs.buf); 666 free(tic); 667 } 668} 669