1 /* $NetBSD: compile.c,v 1.24 2020/03/30 02:08:11 roy Exp $ */ 2 3 /* 4 * Copyright (c) 2009, 2010, 2011, 2020 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.24 2020/03/30 02:08:11 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) 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 int 68 _ti_promote(TIC *tic) 69 { 70 char *obuf, type, flag, *buf, *delim, *name, *nbuf; 71 const char *cap, *code, *str; 72 size_t n, entries, strl; 73 uint16_t ind; 74 int num, ortype, error = 0; 75 76 ortype = tic->rtype; 77 tic->rtype = TERMINFO_RTYPE; 78 obuf = tic->name; 79 tic->name = _ti_getname(tic->rtype, tic->name); 80 if (tic->name == NULL) { 81 warn("_ti_getname"); 82 tic->name = obuf; 83 return -1; 84 } 85 free(obuf); 86 87 n = 0; 88 obuf = buf = tic->alias; 89 tic->alias = NULL; 90 while (buf != NULL) { 91 delim = strchr(buf, '|'); 92 if (delim != NULL) 93 *delim++ = '\0'; 94 name = _ti_getname(tic->rtype, buf); 95 strl = strlen(name) + 1; 96 nbuf = realloc(tic->alias, n + strl); 97 if (nbuf == NULL) { 98 free(name); 99 return -1; 100 } 101 tic->alias = nbuf; 102 memcpy(tic->alias + n, name, strl); 103 n += strl; 104 free(name); 105 buf = delim; 106 } 107 free(obuf); 108 109 obuf = tic->nums.buf; 110 cap = obuf; 111 entries = tic->nums.entries; 112 tic->nums.buf = NULL; 113 tic->nums.entries = tic->nums.buflen = tic->nums.bufpos = 0; 114 for (n = entries; n > 0; n--) { 115 ind = _ti_decode_16(&cap); 116 num = _ti_decode_num(&cap, ortype); 117 if (VALID_NUMERIC(num) && 118 !_ti_encode_buf_id_num(&tic->nums, ind, num, 119 _ti_numsize(tic))) 120 { 121 warn("promote num"); 122 error = -1; 123 break; 124 } 125 } 126 free(obuf); 127 128 obuf = tic->extras.buf; 129 cap = obuf; 130 entries = tic->extras.entries; 131 tic->extras.buf = NULL; 132 tic->extras.entries = tic->extras.buflen = tic->extras.bufpos = 0; 133 for (n = entries; n > 0; n--) { 134 num = _ti_decode_16(&cap); 135 flag = 0; /* satisfy gcc, won't be used for non flag types */ 136 str = NULL; /* satisfy gcc, won't be used as strl is 0 */ 137 strl = 0; 138 code = cap; 139 cap += num; 140 type = *cap++; 141 switch (type) { 142 case 'f': 143 flag = *cap++; 144 break; 145 case 'n': 146 num = _ti_decode_num(&cap, ortype); 147 break; 148 case 's': 149 strl = _ti_decode_16(&cap); 150 str = cap; 151 cap += strl; 152 break; 153 default: 154 errno = EINVAL; 155 break; 156 } 157 if (!_ti_store_extra(tic, 0, code, type, flag, num, 158 str, strl, TIC_EXTRA)) 159 { 160 error = -1; 161 break; 162 } 163 } 164 free(obuf); 165 166 return error; 167 } 168 169 char * 170 _ti_grow_tbuf(TBUF *tbuf, size_t len) 171 { 172 char *buf; 173 size_t l; 174 175 _DIAGASSERT(tbuf != NULL); 176 177 l = tbuf->bufpos + len; 178 if (l > tbuf->buflen) { 179 if (tbuf->buflen == 0) 180 buf = malloc(l); 181 else 182 buf = realloc(tbuf->buf, l); 183 if (buf == NULL) 184 return NULL; 185 tbuf->buf = buf; 186 tbuf->buflen = l; 187 } 188 return tbuf->buf; 189 } 190 191 const char * 192 _ti_find_cap(TIC *tic, TBUF *tbuf, char type, short ind) 193 { 194 size_t n; 195 uint16_t num; 196 const char *cap; 197 198 _DIAGASSERT(tbuf != NULL); 199 200 cap = tbuf->buf; 201 for (n = tbuf->entries; n > 0; n--) { 202 num = _ti_decode_16(&cap); 203 if ((short)num == ind) 204 return cap; 205 switch (type) { 206 case 'f': 207 cap++; 208 break; 209 case 'n': 210 cap += _ti_numsize(tic); 211 break; 212 case 's': 213 num = _ti_decode_16(&cap); 214 cap += num; 215 break; 216 } 217 } 218 219 errno = ESRCH; 220 return NULL; 221 } 222 223 const char * 224 _ti_find_extra(TIC *tic, TBUF *tbuf, const char *code) 225 { 226 size_t n; 227 uint16_t num; 228 const char *cap; 229 230 _DIAGASSERT(tbuf != NULL); 231 _DIAGASSERT(code != NULL); 232 233 cap = tbuf->buf; 234 for (n = tbuf->entries; n > 0; n--) { 235 num = _ti_decode_16(&cap); 236 if (strcmp(cap, code) == 0) 237 return cap + num; 238 cap += num; 239 switch (*cap++) { 240 case 'f': 241 cap++; 242 break; 243 case 'n': 244 cap += _ti_numsize(tic); 245 break; 246 case 's': 247 num = _ti_decode_16(&cap); 248 cap += num; 249 break; 250 } 251 } 252 253 errno = ESRCH; 254 return NULL; 255 } 256 257 char * 258 _ti_getname(int rtype, const char *orig) 259 { 260 const char *delim; 261 char *name; 262 const char *verstr; 263 size_t diff, vlen; 264 265 switch (rtype) { 266 case TERMINFO_RTYPE: 267 verstr = TERMINFO_VDELIMSTR "v3"; 268 break; 269 case TERMINFO_RTYPE_O1: 270 verstr = ""; 271 break; 272 default: 273 errno = EINVAL; 274 return NULL; 275 } 276 277 delim = orig; 278 while (*delim != '\0' && *delim != TERMINFO_VDELIM) 279 delim++; 280 diff = delim - orig; 281 vlen = strlen(verstr); 282 name = malloc(diff + vlen + 1); 283 if (name == NULL) 284 return NULL; 285 286 memcpy(name, orig, diff); 287 memcpy(name + diff, verstr, vlen + 1); 288 return name; 289 } 290 291 size_t 292 _ti_store_extra(TIC *tic, int wrn, const char *id, char type, char flag, 293 int num, const char *str, size_t strl, int flags) 294 { 295 size_t l, capl; 296 297 _DIAGASSERT(tic != NULL); 298 299 if (strcmp(id, "use") != 0) { 300 if (_ti_find_extra(tic, &tic->extras, id) != NULL) 301 return 0; 302 if (!(flags & TIC_EXTRA)) { 303 if (wrn != 0) 304 dowarn(flags, "%s: %s: unknown capability", 305 tic->name, id); 306 return 0; 307 } 308 } 309 310 l = strlen(id) + 1; 311 if (l > UINT16_MAX) { 312 dowarn(flags, "%s: %s: cap name is too long", tic->name, id); 313 return 0; 314 } 315 316 capl = sizeof(uint16_t) + l + 1; 317 switch (type) { 318 case 'f': 319 capl++; 320 break; 321 case 'n': 322 capl += _ti_numsize(tic); 323 break; 324 case 's': 325 capl += sizeof(uint16_t) + strl; 326 break; 327 } 328 329 if (!_ti_grow_tbuf(&tic->extras, capl)) 330 return 0; 331 _ti_encode_buf_count_str(&tic->extras, id, l); 332 tic->extras.buf[tic->extras.bufpos++] = type; 333 switch (type) { 334 case 'f': 335 tic->extras.buf[tic->extras.bufpos++] = flag; 336 break; 337 case 'n': 338 _ti_encode_buf_num(&tic->extras, num, tic->rtype); 339 break; 340 case 's': 341 _ti_encode_buf_count_str(&tic->extras, str, strl); 342 break; 343 } 344 tic->extras.entries++; 345 return 1; 346 } 347 348 static void 349 _ti_encode_buf(char **cap, const TBUF *buf) 350 { 351 if (buf->entries == 0) { 352 _ti_encode_16(cap, 0); 353 } else { 354 _ti_encode_16(cap, buf->bufpos + sizeof(uint16_t)); 355 _ti_encode_16(cap, buf->entries); 356 _ti_encode_str(cap, buf->buf, buf->bufpos); 357 } 358 } 359 360 ssize_t 361 _ti_flatten(uint8_t **buf, const TIC *tic) 362 { 363 size_t buflen, len, alen, dlen; 364 char *cap; 365 366 _DIAGASSERT(buf != NULL); 367 _DIAGASSERT(tic != NULL); 368 369 len = strlen(tic->name) + 1; 370 if (tic->alias == NULL) 371 alen = 0; 372 else 373 alen = strlen(tic->alias) + 1; 374 if (tic->desc == NULL) 375 dlen = 0; 376 else 377 dlen = strlen(tic->desc) + 1; 378 379 buflen = sizeof(char) + 380 sizeof(uint16_t) + len + 381 sizeof(uint16_t) + alen + 382 sizeof(uint16_t) + dlen + 383 (sizeof(uint16_t) * 2) + tic->flags.bufpos + 384 (sizeof(uint16_t) * 2) + tic->nums.bufpos + 385 (sizeof(uint16_t) * 2) + tic->strs.bufpos + 386 (sizeof(uint16_t) * 2) + tic->extras.bufpos; 387 388 *buf = malloc(buflen); 389 if (*buf == NULL) 390 return -1; 391 392 cap = (char *)*buf; 393 *cap++ = tic->rtype; 394 395 _ti_encode_count_str(&cap, tic->name, len); 396 _ti_encode_count_str(&cap, tic->alias, alen); 397 _ti_encode_count_str(&cap, tic->desc, dlen); 398 399 _ti_encode_buf(&cap, &tic->flags); 400 401 _ti_encode_buf(&cap, &tic->nums); 402 _ti_encode_buf(&cap, &tic->strs); 403 _ti_encode_buf(&cap, &tic->extras); 404 405 return (uint8_t *)cap - *buf; 406 } 407 408 static int 409 encode_string(const char *term, const char *cap, TBUF *tbuf, const char *str, 410 int flags) 411 { 412 int slash, i, num; 413 char ch, *p, *s, last; 414 415 if (_ti_grow_tbuf(tbuf, strlen(str) + 1) == NULL) 416 return -1; 417 p = s = tbuf->buf + tbuf->bufpos; 418 slash = 0; 419 last = '\0'; 420 /* Convert escape codes */ 421 while ((ch = *str++) != '\0') { 422 if (ch == '\n') { 423 /* Following a newline, strip leading whitespace from 424 * capability strings. */ 425 while (isspace((unsigned char)*str)) 426 str++; 427 continue; 428 } 429 if (slash == 0 && ch == '\\') { 430 slash = 1; 431 continue; 432 } 433 if (slash == 0) { 434 if (last != '%' && ch == '^') { 435 ch = *str++; 436 if (((unsigned char)ch) >= 128) 437 dowarn(flags, 438 "%s: %s: illegal ^ character", 439 term, cap); 440 if (ch == '\0') 441 break; 442 if (ch == '?') 443 ch = '\177'; 444 else if ((ch &= 037) == 0) 445 ch = (char)128; 446 } else if (!isprint((unsigned char)ch)) 447 dowarn(flags, 448 "%s: %s: unprintable character", 449 term, cap); 450 *p++ = ch; 451 last = ch; 452 continue; 453 } 454 slash = 0; 455 if (ch >= '0' && ch <= '7') { 456 num = ch - '0'; 457 for (i = 0; i < 2; i++) { 458 if (*str < '0' || *str > '7') { 459 if (isdigit((unsigned char)*str)) 460 dowarn(flags, 461 "%s: %s: non octal" 462 " digit", term, cap); 463 else 464 break; 465 } 466 num = num * 8 + *str++ - '0'; 467 } 468 if (num == 0) 469 num = 0200; 470 *p++ = (char)num; 471 continue; 472 } 473 switch (ch) { 474 case 'a': 475 *p++ = '\a'; 476 break; 477 case 'b': 478 *p++ = '\b'; 479 break; 480 case 'e': /* FALLTHROUGH */ 481 case 'E': 482 *p++ = '\033'; 483 break; 484 case 'f': 485 *p++ = '\014'; 486 break; 487 case 'l': /* FALLTHROUGH */ 488 case 'n': 489 *p++ = '\n'; 490 break; 491 case 'r': 492 *p++ = '\r'; 493 break; 494 case 's': 495 *p++ = ' '; 496 break; 497 case 't': 498 *p++ = '\t'; 499 break; 500 default: 501 /* We should warn here */ 502 case '^': 503 case ',': 504 case ':': 505 case '|': 506 *p++ = ch; 507 break; 508 } 509 last = ch; 510 } 511 *p++ = '\0'; 512 tbuf->bufpos += (size_t)(p - s); 513 return 0; 514 } 515 516 char * 517 _ti_get_token(char **cap, char sep) 518 { 519 char esc, *token; 520 521 while (isspace((unsigned char)**cap)) 522 (*cap)++; 523 if (**cap == '\0') 524 return NULL; 525 526 /* We can't use stresep(3) as ^ we need two escape chars */ 527 esc = '\0'; 528 for (token = *cap; 529 **cap != '\0' && (esc != '\0' || **cap != sep); 530 (*cap)++) 531 { 532 if (esc == '\0') { 533 if (**cap == '\\' || **cap == '^') 534 esc = **cap; 535 } else { 536 /* termcap /E/ is valid */ 537 if (sep == ':' && esc == '\\' && **cap == 'E') 538 esc = 'x'; 539 else 540 esc = '\0'; 541 } 542 } 543 544 if (**cap != '\0') 545 *(*cap)++ = '\0'; 546 547 return token; 548 } 549 550 int 551 _ti_encode_buf_id_num(TBUF *tbuf, int ind, int num, size_t len) 552 { 553 if (!_ti_grow_tbuf(tbuf, sizeof(uint16_t) + len)) 554 return 0; 555 _ti_encode_buf_16(tbuf, ind); 556 if (len == sizeof(uint32_t)) 557 _ti_encode_buf_32(tbuf, num); 558 else 559 _ti_encode_buf_16(tbuf, num); 560 tbuf->entries++; 561 return 1; 562 } 563 564 int 565 _ti_encode_buf_id_count_str(TBUF *tbuf, int ind, const void *buf, size_t len) 566 { 567 if (!_ti_grow_tbuf(tbuf, 2 * sizeof(uint16_t) + len)) 568 return 0; 569 _ti_encode_buf_16(tbuf, ind); 570 _ti_encode_buf_count_str(tbuf, buf, len); 571 tbuf->entries++; 572 return 1; 573 } 574 575 int 576 _ti_encode_buf_id_flags(TBUF *tbuf, int ind, int flag) 577 { 578 if (!_ti_grow_tbuf(tbuf, sizeof(uint16_t) + 1)) 579 return 0; 580 _ti_encode_buf_16(tbuf, ind); 581 tbuf->buf[tbuf->bufpos++] = flag; 582 tbuf->entries++; 583 return 1; 584 } 585 586 TIC * 587 _ti_compile(char *cap, int flags) 588 { 589 char *token, *p, *e, *name, *desc, *alias; 590 signed char flag; 591 long cnum; 592 short ind; 593 int num; 594 size_t len; 595 TBUF buf; 596 TIC *tic; 597 598 _DIAGASSERT(cap != NULL); 599 600 name = _ti_get_token(&cap, ','); 601 if (name == NULL) { 602 dowarn(flags, "no separator found: %s", cap); 603 return NULL; 604 } 605 desc = strrchr(name, '|'); 606 if (desc != NULL) 607 *desc++ = '\0'; 608 alias = strchr(name, '|'); 609 if (alias != NULL) 610 *alias++ = '\0'; 611 612 if (strlen(name) > UINT16_MAX - 1) { 613 dowarn(flags, "%s: name too long", name); 614 return NULL; 615 } 616 if (desc != NULL && strlen(desc) > UINT16_MAX - 1) { 617 dowarn(flags, "%s: description too long: %s", name, desc); 618 return NULL; 619 } 620 if (alias != NULL && strlen(alias) > UINT16_MAX - 1) { 621 dowarn(flags, "%s: alias too long: %s", name, alias); 622 return NULL; 623 } 624 625 tic = calloc(sizeof(*tic), 1); 626 if (tic == NULL) 627 return NULL; 628 629 tic->rtype = TERMINFO_RTYPE_O1; /* will promote if needed */ 630 buf.buf = NULL; 631 buf.buflen = 0; 632 633 tic->name = _ti_getname(tic->rtype, name); 634 if (tic->name == NULL) 635 goto error; 636 if (alias != NULL && flags & TIC_ALIAS) { 637 tic->alias = _ti_getname(tic->rtype, alias); 638 if (tic->alias == NULL) 639 goto error; 640 } 641 if (desc != NULL && flags & TIC_DESCRIPTION) { 642 tic->desc = strdup(desc); 643 if (tic->desc == NULL) 644 goto error; 645 } 646 647 for (token = _ti_get_token(&cap, ','); 648 token != NULL && *token != '\0'; 649 token = _ti_get_token(&cap, ',')) 650 { 651 /* Skip commented caps */ 652 if (!(flags & TIC_COMMENT) && token[0] == '.') 653 continue; 654 655 /* Obsolete entries */ 656 if (token[0] == 'O' && token[1] == 'T') { 657 if (!(flags & TIC_EXTRA)) 658 continue; 659 token += 2; 660 } 661 662 /* str cap */ 663 p = strchr(token, '='); 664 if (p != NULL) { 665 *p++ = '\0'; 666 /* Don't use the string if we already have it */ 667 ind = (short)_ti_strindex(token); 668 if (ind != -1 && 669 _ti_find_cap(tic, &tic->strs, 's', ind) != NULL) 670 continue; 671 672 /* Encode the string to our scratch buffer */ 673 buf.bufpos = 0; 674 if (encode_string(tic->name, token, 675 &buf, p, flags) == -1) 676 goto error; 677 if (buf.bufpos > UINT16_MAX - 1) { 678 dowarn(flags, "%s: %s: string is too long", 679 tic->name, token); 680 continue; 681 } 682 if (!VALID_STRING(buf.buf)) { 683 dowarn(flags, "%s: %s: invalid string", 684 tic->name, token); 685 continue; 686 } 687 688 if (ind == -1) { 689 if (!_ti_store_extra(tic, 1, token, 's', -1, -2, 690 buf.buf, buf.bufpos, flags)) 691 goto error; 692 } else { 693 if (!_ti_encode_buf_id_count_str(&tic->strs, 694 ind, buf.buf, buf.bufpos)) 695 goto error; 696 } 697 continue; 698 } 699 700 /* num cap */ 701 p = strchr(token, '#'); 702 if (p != NULL) { 703 *p++ = '\0'; 704 /* Don't use the number if we already have it */ 705 ind = (short)_ti_numindex(token); 706 if (ind != -1 && 707 _ti_find_cap(tic, &tic->nums, 'n', ind) != NULL) 708 continue; 709 710 cnum = strtol(p, &e, 0); 711 if (*e != '\0') { 712 dowarn(flags, "%s: %s: not a number", 713 tic->name, token); 714 continue; 715 } 716 if (!VALID_NUMERIC(cnum) || cnum > INT32_MAX) { 717 dowarn(flags, "%s: %s: number %ld out of range", 718 tic->name, token, cnum); 719 continue; 720 } 721 if (cnum > INT16_MAX) { 722 if (flags & TIC_COMPAT_V1) 723 cnum = INT16_MAX; 724 else if (tic->rtype == TERMINFO_RTYPE_O1) 725 if (_ti_promote(tic) == -1) 726 goto error; 727 } 728 729 num = (int)cnum; 730 if (ind == -1) { 731 if (!_ti_store_extra(tic, 1, token, 'n', -1, 732 num, NULL, 0, flags)) 733 goto error; 734 } else { 735 if (!_ti_encode_buf_id_num(&tic->nums, 736 ind, num, _ti_numsize(tic))) 737 goto error; 738 } 739 continue; 740 } 741 742 flag = 1; 743 len = strlen(token) - 1; 744 if (token[len] == '@') { 745 flag = CANCELLED_BOOLEAN; 746 token[len] = '\0'; 747 } 748 ind = (short)_ti_flagindex(token); 749 if (ind == -1 && flag == CANCELLED_BOOLEAN) { 750 if ((ind = (short)_ti_numindex(token)) != -1) { 751 if (_ti_find_cap(tic, &tic->nums, 'n', ind) 752 != NULL) 753 continue; 754 if (!_ti_encode_buf_id_num(&tic->nums, ind, 755 CANCELLED_NUMERIC, _ti_numsize(tic))) 756 goto error; 757 continue; 758 } else if ((ind = (short)_ti_strindex(token)) != -1) { 759 if (_ti_find_cap(tic, &tic->strs, 's', ind) 760 != NULL) 761 continue; 762 if (!_ti_encode_buf_id_num( 763 &tic->strs, ind, 0, sizeof(uint16_t))) 764 goto error; 765 continue; 766 } 767 } 768 if (ind == -1) { 769 if (!_ti_store_extra(tic, 1, token, 'f', flag, 0, NULL, 770 0, flags)) 771 goto error; 772 } else if (_ti_find_cap(tic, &tic->flags, 'f', ind) == NULL) { 773 if (!_ti_encode_buf_id_flags(&tic->flags, ind, flag)) 774 goto error; 775 } 776 } 777 778 free(buf.buf); 779 return tic; 780 781 error: 782 free(buf.buf); 783 _ti_freetic(tic); 784 return NULL; 785 } 786 787 void 788 _ti_freetic(TIC *tic) 789 { 790 791 if (tic != NULL) { 792 free(tic->name); 793 free(tic->alias); 794 free(tic->desc); 795 free(tic->extras.buf); 796 free(tic->flags.buf); 797 free(tic->nums.buf); 798 free(tic->strs.buf); 799 free(tic); 800 } 801 } 802