lib/libterminfo/compile.c

   1 /* $NetBSD: compile.c,v 1.8 2012/06/03 23:19:10 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.8 2012/06/03 23:19:10 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
  54 static void __printflike(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->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 *
  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         *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
 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
 396                         /* We should warn here */
 397                 case '^':
 398                 case ',':
 399                 case ':':
 400                 case '|':
 401                         *p++ = ch;
 402                         break;
 403                 }
 404                 last = ch;
 405         }
 406         *p++ = '\0';
 407         tbuf->bufpos += p - s;
 408         return 0;
 409 }
 410
 411 char *
 412 _ti_get_token(char **cap, char sep)
 413 {
 414         char esc, *token;
 415
 416         while (isspace((unsigned char)**cap))
 417                 (*cap)++;
 418         if (**cap == '\0')
 419                 return NULL;
 420
 421         /* We can't use stresep(3) as ^ we need two escape chars */
 422         esc = '\0';
 423         for (token = *cap;
 424              **cap != '\0' && (esc != '\0' || **cap != sep);
 425              (*cap)++)
 426         {
 427                 if (esc == '\0') {
 428                         if (**cap == '\\' || **cap == '^')
 429                                 esc = **cap;
 430                 } else {
 431                         /* termcap /E/ is valid */
 432                         if (sep == ':' && esc == '\\' && **cap == 'E')
 433                                 esc = 'x';
 434                         else
 435                                 esc = '\0';
 436                 }
 437         }
 438
 439         if (**cap != '\0')
 440                 *(*cap)++ = '\0';
 441
 442         return token;
 443 }
 444
 445 TIC *
 446 _ti_compile(char *cap, int flags)
 447 {
 448         char *token, *p, *e, *name, *desc, *alias;
 449         signed char flag;
 450         long cnum;
 451         short num;
 452         ssize_t ind;
 453         size_t len;
 454         TBUF buf;
 455         TIC *tic;
 456
 457         _DIAGASSERT(cap != NULL);
 458
 459         name = _ti_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 = _ti_get_token(&cap, ',');
 493              token != NULL && *token != '\0';
 494              token = _ti_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                         cnum = 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(cnum)) {
 570                                 dowarn(flags, "%s: %s: number out of range",
 571                                     tic->name, token);
 572                                 continue;
 573                         }
 574                         num = (short)cnum;
 575                         if (ind == -1)
 576                                 _ti_store_extra(tic, 1, token, 'n', -1,
 577                                     num, NULL, 0, flags);
 578                         else {
 579                                 if (_ti_grow_tbuf(&tic->nums,
 580                                         sizeof(uint16_t) * 2) == NULL)
 581                                         goto error;
 582                                 le16enc(tic->nums.buf + tic->nums.bufpos, ind);
 583                                 tic->nums.bufpos += sizeof(uint16_t);
 584                                 le16enc(tic->nums.buf + tic->nums.bufpos, num);
 585                                 tic->nums.bufpos += sizeof(uint16_t);
 586                                 tic->nums.entries++;
 587                         }
 588                         continue;
 589                 }
 590
 591                 flag = 1;
 592                 len = strlen(token) - 1;
 593                 if (token[len] == '@') {
 594                         flag = CANCELLED_BOOLEAN;
 595                         token[len] = '\0';
 596                 }
 597                 ind = _ti_flagindex(token);
 598                 if (ind == -1 && flag == CANCELLED_BOOLEAN) {
 599                         if ((ind = _ti_numindex(token)) != -1) {
 600                                 if (_ti_find_cap(&tic->nums, 'n', ind) != NULL)
 601                                         continue;
 602                                 if (_ti_grow_tbuf(&tic->nums,
 603                                         sizeof(uint16_t) * 2) == NULL)
 604                                         goto error;
 605                                 le16enc(tic->nums.buf + tic->nums.bufpos, ind);
 606                                 tic->nums.bufpos += sizeof(uint16_t);
 607                                 le16enc(tic->nums.buf + tic->nums.bufpos,
 608                                         (uint16_t)CANCELLED_NUMERIC);
 609                                 tic->nums.bufpos += sizeof(uint16_t);
 610                                 tic->nums.entries++;
 611                                 continue;
 612                         } else if ((ind = _ti_strindex(token)) != -1) {
 613                                 if (_ti_find_cap(&tic->strs, 's', ind) != NULL)
 614                                         continue;
 615                                 if (_ti_grow_tbuf(&tic->strs,
 616                                         (sizeof(uint16_t) * 2) + 1) == NULL)
 617                                         goto error;
 618                                 le16enc(tic->strs.buf + tic->strs.bufpos, ind);
 619                                 tic->strs.bufpos += sizeof(uint16_t);
 620                                 le16enc(tic->strs.buf + tic->strs.bufpos, 0);
 621                                 tic->strs.bufpos += sizeof(uint16_t);
 622                                 tic->strs.entries++;
 623                                 continue;
 624                         }
 625                 }
 626                 if (ind == -1)
 627                         _ti_store_extra(tic, 1, token, 'f', flag, 0, NULL, 0,
 628                             flags);
 629                 else if (_ti_find_cap(&tic->flags, 'f', ind) == NULL) {
 630                         if (_ti_grow_tbuf(&tic->flags, sizeof(uint16_t) + 1)
 631                             == NULL)
 632                                 goto error;
 633                         le16enc(tic->flags.buf + tic->flags.bufpos, ind);
 634                         tic->flags.bufpos += sizeof(uint16_t);
 635                         tic->flags.buf[tic->flags.bufpos++] = flag;
 636                         tic->flags.entries++;
 637                 }
 638         }
 639
 640         free(buf.buf);
 641         return tic;
 642
 643 error:
 644         free(buf.buf);
 645         _ti_freetic(tic);
 646         return NULL;
 647 }
 648
 649 void
 650 _ti_freetic(TIC *tic)
 651 {
 652
 653         if (tic != NULL) {
 654                 free(tic->name);
 655                 free(tic->alias);
 656                 free(tic->desc);
 657                 free(tic->extras.buf);
 658                 free(tic->flags.buf);
 659                 free(tic->nums.buf);
 660                 free(tic->strs.buf);
 661                 free(tic);
 662         }
 663 }