1 /**************************************************************************** 2 * Copyright (c) 1998-2012,2013 Free Software Foundation, Inc. * 3 * * 4 * Permission is hereby granted, free of charge, to any person obtaining a * 5 * copy of this software and associated documentation files (the * 6 * "Software"), to deal in the Software without restriction, including * 7 * without limitation the rights to use, copy, modify, merge, publish, * 8 * distribute, distribute with modifications, sublicense, and/or sell * 9 * copies of the Software, and to permit persons to whom the Software is * 10 * furnished to do so, subject to the following conditions: * 11 * * 12 * The above copyright notice and this permission notice shall be included * 13 * in all copies or substantial portions of the Software. * 14 * * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS * 16 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF * 17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * 18 * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, * 19 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR * 20 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR * 21 * THE USE OR OTHER DEALINGS IN THE SOFTWARE. * 22 * * 23 * Except as contained in this notice, the name(s) of the above copyright * 24 * holders shall not be used in advertising or otherwise to promote the * 25 * sale, use or other dealings in this Software without prior written * 26 * authorization. * 27 ****************************************************************************/ 28 29 /**************************************************************************** 30 * Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995 * 31 * and: Eric S. Raymond <esr@snark.thyrsus.com> * 32 * and: Thomas E. Dickey 1996 on * 33 ****************************************************************************/ 34 35 /* 36 * tic.c --- Main program for terminfo compiler 37 * by Eric S. Raymond 38 * and Thomas E Dickey 39 * 40 */ 41 42 #include <progs.priv.h> 43 #include <sys/stat.h> 44 45 #include <dump_entry.h> 46 #include <hashed_db.h> 47 #include <transform.h> 48 49 MODULE_ID("$Id: tic.c,v 1.189 2013/11/16 19:58:09 tom Exp $") 50 51 #define STDIN_NAME "<stdin>" 52 53 const char *_nc_progname = "tic"; 54 55 static FILE *log_fp; 56 static FILE *tmp_fp; 57 static bool capdump = FALSE; /* running as infotocap? */ 58 static bool infodump = FALSE; /* running as captoinfo? */ 59 static bool showsummary = FALSE; 60 static char **namelst = 0; 61 static const char *to_remove; 62 63 static void (*save_check_termtype) (TERMTYPE *, bool); 64 static void check_termtype(TERMTYPE *tt, bool); 65 66 static const char usage_string[] = "\ 67 [-e names] \ 68 [-o dir] \ 69 [-R name] \ 70 [-v[n]] \ 71 [-V] \ 72 [-w[n]] \ 73 [-\ 74 1\ 75 a\ 76 C\ 77 D\ 78 c\ 79 f\ 80 G\ 81 g\ 82 I\ 83 K\ 84 L\ 85 N\ 86 r\ 87 s\ 88 T\ 89 t\ 90 U\ 91 x\ 92 ] \ 93 source-file\n"; 94 95 #if NO_LEAKS 96 static void 97 free_namelist(char **src) 98 { 99 if (src != 0) { 100 int n; 101 for (n = 0; src[n] != 0; ++n) 102 free(src[n]); 103 free(src); 104 } 105 } 106 #endif 107 108 static void 109 cleanup(void) 110 { 111 int rc; 112 113 #if NO_LEAKS 114 free_namelist(namelst); 115 #endif 116 if (tmp_fp != 0) 117 fclose(tmp_fp); 118 if (to_remove != 0) { 119 #if HAVE_REMOVE 120 rc = remove(to_remove); 121 #else 122 rc = unlink(to_remove); 123 #endif 124 if (rc != 0) 125 perror(to_remove); 126 } 127 } 128 129 static void 130 failed(const char *msg) 131 { 132 perror(msg); 133 ExitProgram(EXIT_FAILURE); 134 } 135 136 static void 137 usage(void) 138 { 139 static const char *const tbl[] = 140 { 141 "Options:", 142 " -1 format translation output one capability per line", 143 #if NCURSES_XNAMES 144 " -a retain commented-out capabilities (sets -x also)", 145 #endif 146 " -K translate entries to termcap source form with BSD syntax", 147 " -C translate entries to termcap source form", 148 " -D print list of tic's database locations (first must be writable)", 149 " -c check only, validate input without compiling or translating", 150 " -e<names> translate/compile only entries named by comma-separated list", 151 " -f format complex strings for readability", 152 " -G format %{number} to %'char'", 153 " -g format %'char' to %{number}", 154 " -I translate entries to terminfo source form", 155 " -L translate entries to full terminfo source form", 156 " -N disable smart defaults for source translation", 157 " -o<dir> set output directory for compiled entry writes", 158 " -R<name> restrict translation to given terminfo/termcap version", 159 " -r force resolution of all use entries in source translation", 160 " -s print summary statistics", 161 " -T remove size-restrictions on compiled description", 162 #if NCURSES_XNAMES 163 " -t suppress commented-out capabilities", 164 #endif 165 " -U suppress post-processing of entries", 166 " -V print version", 167 " -v[n] set verbosity level", 168 " -w[n] set format width for translation output", 169 #if NCURSES_XNAMES 170 " -x treat unknown capabilities as user-defined", 171 #endif 172 "", 173 "Parameters:", 174 " <file> file to translate or compile" 175 }; 176 size_t j; 177 178 fprintf(stderr, "Usage: %s %s\n", _nc_progname, usage_string); 179 for (j = 0; j < SIZEOF(tbl); j++) { 180 fputs(tbl[j], stderr); 181 putc('\n', stderr); 182 } 183 ExitProgram(EXIT_FAILURE); 184 } 185 186 #define L_BRACE '{' 187 #define R_BRACE '}' 188 #define S_QUOTE '\'' 189 190 static void 191 write_it(ENTRY * ep) 192 { 193 unsigned n; 194 int ch; 195 char *s, *d, *t; 196 char result[MAX_ENTRY_SIZE]; 197 198 /* 199 * Look for strings that contain %{number}, convert them to %'char', 200 * which is shorter and runs a little faster. 201 */ 202 for (n = 0; n < STRCOUNT; n++) { 203 s = ep->tterm.Strings[n]; 204 if (VALID_STRING(s) 205 && strchr(s, L_BRACE) != 0) { 206 d = result; 207 t = s; 208 while ((ch = *t++) != 0) { 209 *d++ = (char) ch; 210 if (ch == '\\') { 211 *d++ = *t++; 212 } else if ((ch == '%') 213 && (*t == L_BRACE)) { 214 char *v = 0; 215 long value = strtol(t + 1, &v, 0); 216 if (v != 0 217 && *v == R_BRACE 218 && value > 0 219 && value != '\\' /* FIXME */ 220 && value < 127 221 && isprint((int) value)) { 222 *d++ = S_QUOTE; 223 *d++ = (char) value; 224 *d++ = S_QUOTE; 225 t = (v + 1); 226 } 227 } 228 } 229 *d = 0; 230 if (strlen(result) < strlen(s)) 231 _nc_STRCPY(s, result, strlen(s) + 1); 232 } 233 } 234 235 _nc_set_type(_nc_first_name(ep->tterm.term_names)); 236 _nc_curr_line = (int) ep->startline; 237 _nc_write_entry(&ep->tterm); 238 } 239 240 static bool 241 immedhook(ENTRY * ep GCC_UNUSED) 242 /* write out entries with no use capabilities immediately to save storage */ 243 { 244 #if !HAVE_BIG_CORE 245 /* 246 * This is strictly a core-economy kluge. The really clean way to handle 247 * compilation is to slurp the whole file into core and then do all the 248 * name-collision checks and entry writes in one swell foop. But the 249 * terminfo master file is large enough that some core-poor systems swap 250 * like crazy when you compile it this way...there have been reports of 251 * this process taking *three hours*, rather than the twenty seconds or 252 * less typical on my development box. 253 * 254 * So. This hook *immediately* writes out the referenced entry if it 255 * has no use capabilities. The compiler main loop refrains from 256 * adding the entry to the in-core list when this hook fires. If some 257 * other entry later needs to reference an entry that got written 258 * immediately, that's OK; the resolution code will fetch it off disk 259 * when it can't find it in core. 260 * 261 * Name collisions will still be detected, just not as cleanly. The 262 * write_entry() code complains before overwriting an entry that 263 * postdates the time of tic's first call to write_entry(). Thus 264 * it will complain about overwriting entries newly made during the 265 * tic run, but not about overwriting ones that predate it. 266 * 267 * The reason this is a hook, and not in line with the rest of the 268 * compiler code, is that the support for termcap fallback cannot assume 269 * it has anywhere to spool out these entries! 270 * 271 * The _nc_set_type() call here requires a compensating one in 272 * _nc_parse_entry(). 273 * 274 * If you define HAVE_BIG_CORE, you'll disable this kluge. This will 275 * make tic a bit faster (because the resolution code won't have to do 276 * disk I/O nearly as often). 277 */ 278 if (ep->nuses == 0) { 279 int oldline = _nc_curr_line; 280 281 write_it(ep); 282 _nc_curr_line = oldline; 283 free(ep->tterm.str_table); 284 return (TRUE); 285 } 286 #endif /* HAVE_BIG_CORE */ 287 return (FALSE); 288 } 289 290 static void 291 put_translate(int c) 292 /* emit a comment char, translating terminfo names to termcap names */ 293 { 294 static bool in_name = FALSE; 295 static size_t have, used; 296 static char *namebuf, *suffix; 297 298 if (in_name) { 299 if (used + 1 >= have) { 300 have += 132; 301 if ((namebuf = typeRealloc(char, have, namebuf)) == 0) 302 failed("put_translate namebuf"); 303 if ((suffix = typeRealloc(char, have, suffix)) == 0) 304 failed("put_translate suffix"); 305 } 306 if (c == '\n' || c == '@') { 307 namebuf[used++] = '\0'; 308 (void) putchar('<'); 309 (void) fputs(namebuf, stdout); 310 putchar(c); 311 in_name = FALSE; 312 } else if (c != '>') { 313 namebuf[used++] = (char) c; 314 } else { /* ah! candidate name! */ 315 char *up; 316 NCURSES_CONST char *tp; 317 318 namebuf[used++] = '\0'; 319 in_name = FALSE; 320 321 suffix[0] = '\0'; 322 if ((up = strchr(namebuf, '#')) != 0 323 || (up = strchr(namebuf, '=')) != 0 324 || ((up = strchr(namebuf, '@')) != 0 && up[1] == '>')) { 325 _nc_STRCPY(suffix, up, have); 326 *up = '\0'; 327 } 328 329 if ((tp = nametrans(namebuf)) != 0) { 330 (void) putchar(':'); 331 (void) fputs(tp, stdout); 332 (void) fputs(suffix, stdout); 333 (void) putchar(':'); 334 } else { 335 /* couldn't find a translation, just dump the name */ 336 (void) putchar('<'); 337 (void) fputs(namebuf, stdout); 338 (void) fputs(suffix, stdout); 339 (void) putchar('>'); 340 } 341 } 342 } else { 343 used = 0; 344 if (c == '<') { 345 in_name = TRUE; 346 } else { 347 putchar(c); 348 } 349 } 350 } 351 352 /* Returns a string, stripped of leading/trailing whitespace */ 353 static char * 354 stripped(char *src) 355 { 356 char *dst = 0; 357 358 while (isspace(UChar(*src))) 359 src++; 360 361 if (*src != '\0') { 362 size_t len; 363 364 if ((dst = strdup(src)) == NULL) { 365 failed("strdup"); 366 } else { 367 len = strlen(dst); 368 while (--len != 0 && isspace(UChar(dst[len]))) 369 dst[len] = '\0'; 370 } 371 } 372 return dst; 373 } 374 375 static FILE * 376 open_tempfile(char *filename) 377 { 378 FILE *result = 0; 379 380 _nc_STRCPY(filename, "/tmp/XXXXXX", PATH_MAX); 381 #if HAVE_MKSTEMP 382 { 383 int oldmask = (int) umask(077); 384 int fd = mkstemp(filename); 385 if (fd >= 0) 386 result = fdopen(fd, "w"); 387 umask((mode_t) oldmask); 388 } 389 #else 390 if (tmpnam(filename) != 0) 391 result = fopen(filename, "w"); 392 #endif 393 return result; 394 } 395 396 static FILE * 397 copy_input(FILE *source, const char *filename, char *alt_file) 398 { 399 char my_altfile[PATH_MAX]; 400 FILE *result = 0; 401 FILE *target = 0; 402 int ch; 403 404 if (alt_file == 0) 405 alt_file = my_altfile; 406 407 if (source == 0) { 408 failed("copy_input (source)"); 409 } else if ((target = open_tempfile(alt_file)) == 0) { 410 failed("copy_input (target)"); 411 } else { 412 clearerr(source); 413 for (;;) { 414 ch = fgetc(source); 415 if (feof(source)) { 416 break; 417 } else if (ferror(source)) { 418 failed(filename); 419 } else if (ch == 0) { 420 /* don't loop in case someone wants to convert /dev/zero */ 421 fprintf(stderr, "%s: %s is not a text-file\n", _nc_progname, filename); 422 ExitProgram(EXIT_FAILURE); 423 } 424 fputc(ch, target); 425 } 426 fclose(source); 427 /* 428 * rewind() does not force the target file's data to disk (not does 429 * fflush()...). So open a second stream on the data and then close 430 * the one that we were writing on before starting to read from the 431 * second stream. 432 */ 433 result = fopen(alt_file, "r+"); 434 fclose(target); 435 to_remove = strdup(alt_file); 436 } 437 return result; 438 } 439 440 static FILE * 441 open_input(const char *filename, char *alt_file) 442 { 443 FILE *fp; 444 struct stat sb; 445 int mode; 446 447 if (!strcmp(filename, "-")) { 448 fp = copy_input(stdin, STDIN_NAME, alt_file); 449 } else if (stat(filename, &sb) < 0) { 450 fprintf(stderr, "%s: %s %s\n", _nc_progname, filename, strerror(errno)); 451 ExitProgram(EXIT_FAILURE); 452 } else if ((mode = (sb.st_mode & S_IFMT)) == S_IFDIR 453 || (mode != S_IFREG && mode != S_IFCHR)) { 454 fprintf(stderr, "%s: %s is not a file\n", _nc_progname, filename); 455 ExitProgram(EXIT_FAILURE); 456 } else { 457 fp = fopen(filename, "r"); 458 459 if (fp == 0) { 460 fprintf(stderr, "%s: Can't open %s\n", _nc_progname, filename); 461 ExitProgram(EXIT_FAILURE); 462 } 463 if (mode != S_IFREG) { 464 if (alt_file != 0) { 465 FILE *fp2 = copy_input(fp, filename, alt_file); 466 fp = fp2; 467 } else { 468 fprintf(stderr, "%s: %s is not a file\n", _nc_progname, filename); 469 ExitProgram(EXIT_FAILURE); 470 } 471 } 472 } 473 return fp; 474 } 475 476 /* Parse the "-e" option-value into a list of names */ 477 static char ** 478 make_namelist(char *src) 479 { 480 char **dst = 0; 481 482 char *s, *base; 483 unsigned pass, n, nn; 484 char buffer[BUFSIZ]; 485 486 if (src == 0) { 487 /* EMPTY */ ; 488 } else if (strchr(src, '/') != 0) { /* a filename */ 489 FILE *fp = open_input(src, (char *) 0); 490 491 for (pass = 1; pass <= 2; pass++) { 492 nn = 0; 493 while (fgets(buffer, sizeof(buffer), fp) != 0) { 494 if ((s = stripped(buffer)) != 0) { 495 if (dst != 0) 496 dst[nn] = s; 497 else 498 free(s); 499 nn++; 500 } 501 } 502 if (pass == 1) { 503 if ((dst = typeCalloc(char *, nn + 1)) == 0) 504 failed("make_namelist"); 505 rewind(fp); 506 } 507 } 508 fclose(fp); 509 } else { /* literal list of names */ 510 for (pass = 1; pass <= 2; pass++) { 511 for (n = nn = 0, base = src;; n++) { 512 int mark = src[n]; 513 if (mark == ',' || mark == '\0') { 514 if (pass == 1) { 515 nn++; 516 } else { 517 src[n] = '\0'; 518 if ((s = stripped(base)) != 0) 519 dst[nn++] = s; 520 base = &src[n + 1]; 521 } 522 } 523 if (mark == '\0') 524 break; 525 } 526 if (pass == 1) { 527 if ((dst = typeCalloc(char *, nn + 1)) == 0) 528 failed("make_namelist"); 529 } 530 } 531 } 532 if (showsummary && (dst != 0)) { 533 fprintf(log_fp, "Entries that will be compiled:\n"); 534 for (n = 0; dst[n] != 0; n++) 535 fprintf(log_fp, "%u:%s\n", n + 1, dst[n]); 536 } 537 return dst; 538 } 539 540 static bool 541 matches(char **needle, const char *haystack) 542 /* does entry in needle list match |-separated field in haystack? */ 543 { 544 bool code = FALSE; 545 size_t n; 546 547 if (needle != 0) { 548 for (n = 0; needle[n] != 0; n++) { 549 if (_nc_name_match(haystack, needle[n], "|")) { 550 code = TRUE; 551 break; 552 } 553 } 554 } else 555 code = TRUE; 556 return (code); 557 } 558 559 static char * 560 valid_db_path(const char *nominal) 561 { 562 struct stat sb; 563 #if USE_HASHED_DB 564 char suffix[] = DBM_SUFFIX; 565 size_t need = strlen(nominal) + sizeof(suffix); 566 char *result = malloc(need); 567 568 if (result == 0) 569 failed("valid_db_path"); 570 _nc_STRCPY(result, nominal, need); 571 if (strcmp(result + need - sizeof(suffix), suffix)) { 572 _nc_STRCAT(result, suffix, need); 573 } 574 #else 575 char *result = strdup(nominal); 576 #endif 577 578 DEBUG(1, ("** stat(%s)", result)); 579 if (stat(result, &sb) >= 0) { 580 #if USE_HASHED_DB 581 if (!S_ISREG(sb.st_mode) 582 || access(result, R_OK | W_OK) != 0) { 583 DEBUG(1, ("...not a writable file")); 584 free(result); 585 result = 0; 586 } 587 #else 588 if (!S_ISDIR(sb.st_mode) 589 || access(result, R_OK | W_OK | X_OK) != 0) { 590 DEBUG(1, ("...not a writable directory")); 591 free(result); 592 result = 0; 593 } 594 #endif 595 } else { 596 /* check if parent is directory and is writable */ 597 unsigned leaf = _nc_pathlast(result); 598 599 DEBUG(1, ("...not found")); 600 if (leaf) { 601 char save = result[leaf]; 602 result[leaf] = 0; 603 if (stat(result, &sb) >= 0 604 && S_ISDIR(sb.st_mode) 605 && access(result, R_OK | W_OK | X_OK) == 0) { 606 result[leaf] = save; 607 } else { 608 DEBUG(1, ("...parent directory %s is not writable", result)); 609 free(result); 610 result = 0; 611 } 612 } else { 613 DEBUG(1, ("... no parent directory")); 614 free(result); 615 result = 0; 616 } 617 } 618 return result; 619 } 620 621 /* 622 * Show the databases to which tic could write. The location to which it 623 * writes is always the first one. If none are writable, print an error 624 * message. 625 */ 626 static void 627 show_databases(const char *outdir) 628 { 629 bool specific = (outdir != 0) || getenv("TERMINFO") != 0; 630 char *result; 631 const char *tried = 0; 632 633 if (outdir == 0) { 634 outdir = _nc_tic_dir(0); 635 } 636 if ((result = valid_db_path(outdir)) != 0) { 637 printf("%s\n", result); 638 free(result); 639 } else { 640 tried = outdir; 641 } 642 643 if ((outdir = _nc_home_terminfo())) { 644 if ((result = valid_db_path(outdir)) != 0) { 645 printf("%s\n", result); 646 free(result); 647 } else if (!specific) { 648 tried = outdir; 649 } 650 } 651 652 /* 653 * If we can write in neither location, give an error message. 654 */ 655 if (tried) { 656 fflush(stdout); 657 fprintf(stderr, "%s: %s (no permission)\n", _nc_progname, tried); 658 ExitProgram(EXIT_FAILURE); 659 } 660 } 661 662 #define VtoTrace(opt) (unsigned) ((opt > 0) ? opt : (opt == 0)) 663 664 int 665 main(int argc, char *argv[]) 666 { 667 char my_tmpname[PATH_MAX]; 668 char my_altfile[PATH_MAX]; 669 int v_opt = -1; 670 unsigned debug_level; 671 int smart_defaults = TRUE; 672 char *termcap; 673 ENTRY *qp; 674 675 int this_opt, last_opt = '?'; 676 677 int outform = F_TERMINFO; /* output format */ 678 int sortmode = S_TERMINFO; /* sort_mode */ 679 680 int width = 60; 681 int height = 65535; 682 bool formatted = FALSE; /* reformat complex strings? */ 683 bool literal = FALSE; /* suppress post-processing? */ 684 int numbers = 0; /* format "%'char'" to/from "%{number}" */ 685 bool forceresolve = FALSE; /* force resolution */ 686 bool limited = TRUE; 687 char *tversion = (char *) NULL; 688 const char *source_file = "terminfo"; 689 char *outdir = (char *) NULL; 690 bool check_only = FALSE; 691 bool suppress_untranslatable = FALSE; 692 693 log_fp = stderr; 694 695 _nc_progname = _nc_rootname(argv[0]); 696 atexit(cleanup); 697 698 if ((infodump = same_program(_nc_progname, PROG_CAPTOINFO)) != FALSE) { 699 outform = F_TERMINFO; 700 sortmode = S_TERMINFO; 701 } 702 if ((capdump = same_program(_nc_progname, PROG_INFOTOCAP)) != FALSE) { 703 outform = F_TERMCAP; 704 sortmode = S_TERMCAP; 705 } 706 #if NCURSES_XNAMES 707 use_extended_names(FALSE); 708 #endif 709 _nc_strict_bsd = 0; 710 711 /* 712 * Processing arguments is a little complicated, since someone made a 713 * design decision to allow the numeric values for -w, -v options to 714 * be optional. 715 */ 716 while ((this_opt = getopt(argc, argv, 717 "0123456789CDIKLNR:TUVace:fGgo:rstvwx")) != -1) { 718 if (isdigit(this_opt)) { 719 switch (last_opt) { 720 case 'v': 721 v_opt = (v_opt * 10) + (this_opt - '0'); 722 break; 723 case 'w': 724 width = (width * 10) + (this_opt - '0'); 725 break; 726 default: 727 switch (this_opt) { 728 case '0': 729 last_opt = this_opt; 730 width = 65535; 731 height = 1; 732 break; 733 case '1': 734 last_opt = this_opt; 735 width = 0; 736 break; 737 default: 738 usage(); 739 } 740 } 741 continue; 742 } 743 switch (this_opt) { 744 case 'K': 745 _nc_strict_bsd = 1; 746 /* the initial version of -K in 20110730 fell-thru here, but the 747 * same flag is useful when reading sources -TD 748 */ 749 break; 750 case 'C': 751 capdump = TRUE; 752 outform = F_TERMCAP; 753 sortmode = S_TERMCAP; 754 break; 755 case 'D': 756 debug_level = VtoTrace(v_opt); 757 set_trace_level(debug_level); 758 show_databases(outdir); 759 ExitProgram(EXIT_SUCCESS); 760 break; 761 case 'I': 762 infodump = TRUE; 763 outform = F_TERMINFO; 764 sortmode = S_TERMINFO; 765 break; 766 case 'L': 767 infodump = TRUE; 768 outform = F_VARIABLE; 769 sortmode = S_VARIABLE; 770 break; 771 case 'N': 772 smart_defaults = FALSE; 773 literal = TRUE; 774 break; 775 case 'R': 776 tversion = optarg; 777 break; 778 case 'T': 779 limited = FALSE; 780 break; 781 case 'U': 782 literal = TRUE; 783 break; 784 case 'V': 785 puts(curses_version()); 786 ExitProgram(EXIT_SUCCESS); 787 case 'c': 788 check_only = TRUE; 789 break; 790 case 'e': 791 namelst = make_namelist(optarg); 792 break; 793 case 'f': 794 formatted = TRUE; 795 break; 796 case 'G': 797 numbers = 1; 798 break; 799 case 'g': 800 numbers = -1; 801 break; 802 case 'o': 803 outdir = optarg; 804 break; 805 case 'r': 806 forceresolve = TRUE; 807 break; 808 case 's': 809 showsummary = TRUE; 810 break; 811 case 'v': 812 v_opt = 0; 813 break; 814 case 'w': 815 width = 0; 816 break; 817 #if NCURSES_XNAMES 818 case 't': 819 _nc_disable_period = FALSE; 820 suppress_untranslatable = TRUE; 821 break; 822 case 'a': 823 _nc_disable_period = TRUE; 824 /* FALLTHRU */ 825 case 'x': 826 use_extended_names(TRUE); 827 break; 828 #endif 829 default: 830 usage(); 831 } 832 last_opt = this_opt; 833 } 834 835 debug_level = VtoTrace(v_opt); 836 set_trace_level(debug_level); 837 838 if (_nc_tracing) { 839 save_check_termtype = _nc_check_termtype2; 840 _nc_check_termtype2 = check_termtype; 841 } 842 #if !HAVE_BIG_CORE 843 /* 844 * Aaargh! immedhook seriously hoses us! 845 * 846 * One problem with immedhook is it means we can't do -e. Problem 847 * is that we can't guarantee that for each terminal listed, all the 848 * terminals it depends on will have been kept in core for reference 849 * resolution -- in fact it's certain the primitive types at the end 850 * of reference chains *won't* be in core unless they were explicitly 851 * in the select list themselves. 852 */ 853 if (namelst && (!infodump && !capdump)) { 854 (void) fprintf(stderr, 855 "%s: Sorry, -e can't be used without -I or -C\n", 856 _nc_progname); 857 ExitProgram(EXIT_FAILURE); 858 } 859 #endif /* HAVE_BIG_CORE */ 860 861 if (optind < argc) { 862 source_file = argv[optind++]; 863 if (optind < argc) { 864 fprintf(stderr, 865 "%s: Too many file names. Usage:\n\t%s %s", 866 _nc_progname, 867 _nc_progname, 868 usage_string); 869 ExitProgram(EXIT_FAILURE); 870 } 871 } else { 872 if (infodump == TRUE) { 873 /* captoinfo's no-argument case */ 874 source_file = "/etc/termcap"; 875 if ((termcap = getenv("TERMCAP")) != 0 876 && (namelst = make_namelist(getenv("TERM"))) != 0) { 877 if (access(termcap, F_OK) == 0) { 878 /* file exists */ 879 source_file = termcap; 880 } else { 881 if ((tmp_fp = open_tempfile(my_tmpname)) != 0) { 882 source_file = my_tmpname; 883 fprintf(tmp_fp, "%s\n", termcap); 884 fclose(tmp_fp); 885 tmp_fp = open_input(source_file, (char *) 0); 886 to_remove = source_file; 887 } else { 888 failed("tmpnam"); 889 } 890 } 891 } 892 } else { 893 /* tic */ 894 fprintf(stderr, 895 "%s: File name needed. Usage:\n\t%s %s", 896 _nc_progname, 897 _nc_progname, 898 usage_string); 899 ExitProgram(EXIT_FAILURE); 900 } 901 } 902 903 if (tmp_fp == 0) { 904 tmp_fp = open_input(source_file, my_altfile); 905 if (!strcmp(source_file, "-")) { 906 source_file = STDIN_NAME; 907 } 908 } 909 910 if (infodump) { 911 dump_init(tversion, 912 smart_defaults 913 ? outform 914 : F_LITERAL, 915 sortmode, width, height, debug_level, formatted); 916 } else if (capdump) { 917 dump_init(tversion, 918 outform, 919 sortmode, width, height, debug_level, FALSE); 920 } 921 922 /* parse entries out of the source file */ 923 _nc_set_source(source_file); 924 #if !HAVE_BIG_CORE 925 if (!(check_only || infodump || capdump)) 926 _nc_set_writedir(outdir); 927 #endif /* HAVE_BIG_CORE */ 928 _nc_read_entry_source(tmp_fp, (char *) NULL, 929 !smart_defaults || literal, FALSE, 930 ((check_only || infodump || capdump) 931 ? NULLHOOK 932 : immedhook)); 933 934 /* do use resolution */ 935 if (check_only || (!infodump && !capdump) || forceresolve) { 936 if (!_nc_resolve_uses2(TRUE, literal) && !check_only) { 937 ExitProgram(EXIT_FAILURE); 938 } 939 } 940 941 /* length check */ 942 if (check_only && (capdump || infodump)) { 943 for_entry_list(qp) { 944 if (matches(namelst, qp->tterm.term_names)) { 945 int len = fmt_entry(&qp->tterm, NULL, FALSE, TRUE, infodump, numbers); 946 947 if (len > (infodump ? MAX_TERMINFO_LENGTH : MAX_TERMCAP_LENGTH)) 948 (void) fprintf(stderr, 949 "warning: resolved %s entry is %d bytes long\n", 950 _nc_first_name(qp->tterm.term_names), 951 len); 952 } 953 } 954 } 955 956 /* write or dump all entries */ 957 if (!check_only) { 958 if (!infodump && !capdump) { 959 _nc_set_writedir(outdir); 960 for_entry_list(qp) { 961 if (matches(namelst, qp->tterm.term_names)) 962 write_it(qp); 963 } 964 } else { 965 /* this is in case infotocap() generates warnings */ 966 _nc_curr_col = _nc_curr_line = -1; 967 968 for_entry_list(qp) { 969 if (matches(namelst, qp->tterm.term_names)) { 970 long j = qp->cend - qp->cstart; 971 int len = 0; 972 973 /* this is in case infotocap() generates warnings */ 974 _nc_set_type(_nc_first_name(qp->tterm.term_names)); 975 976 (void) fseek(tmp_fp, qp->cstart, SEEK_SET); 977 while (j-- > 0) { 978 if (infodump) 979 (void) putchar(fgetc(tmp_fp)); 980 else 981 put_translate(fgetc(tmp_fp)); 982 } 983 984 repair_acsc(&qp->tterm); 985 dump_entry(&qp->tterm, suppress_untranslatable, 986 limited, numbers, NULL); 987 for (j = 0; j < (long) qp->nuses; j++) 988 dump_uses(qp->uses[j].name, !capdump); 989 len = show_entry(); 990 if (debug_level != 0 && !limited) 991 printf("# length=%d\n", len); 992 } 993 } 994 if (!namelst && _nc_tail) { 995 int c, oldc = '\0'; 996 bool in_comment = FALSE; 997 bool trailing_comment = FALSE; 998 999 (void) fseek(tmp_fp, _nc_tail->cend, SEEK_SET); 1000 while ((c = fgetc(tmp_fp)) != EOF) { 1001 if (oldc == '\n') { 1002 if (c == '#') { 1003 trailing_comment = TRUE; 1004 in_comment = TRUE; 1005 } else { 1006 in_comment = FALSE; 1007 } 1008 } 1009 if (trailing_comment 1010 && (in_comment || (oldc == '\n' && c == '\n'))) 1011 putchar(c); 1012 oldc = c; 1013 } 1014 } 1015 } 1016 } 1017 1018 /* Show the directory into which entries were written, and the total 1019 * number of entries 1020 */ 1021 if (showsummary 1022 && (!(check_only || infodump || capdump))) { 1023 int total = _nc_tic_written(); 1024 if (total != 0) 1025 fprintf(log_fp, "%d entries written to %s\n", 1026 total, 1027 _nc_tic_dir((char *) 0)); 1028 else 1029 fprintf(log_fp, "No entries written\n"); 1030 } 1031 ExitProgram(EXIT_SUCCESS); 1032 } 1033 1034 /* 1035 * This bit of legerdemain turns all the terminfo variable names into 1036 * references to locations in the arrays Booleans, Numbers, and Strings --- 1037 * precisely what's needed (see comp_parse.c). 1038 */ 1039 #undef CUR 1040 #define CUR tp-> 1041 1042 /* 1043 * Check if the alternate character-set capabilities are consistent. 1044 */ 1045 static void 1046 check_acs(TERMTYPE *tp) 1047 { 1048 if (VALID_STRING(acs_chars)) { 1049 const char *boxes = "lmkjtuvwqxn"; 1050 char mapped[256]; 1051 char missing[256]; 1052 const char *p; 1053 char *q; 1054 1055 memset(mapped, 0, sizeof(mapped)); 1056 for (p = acs_chars; *p != '\0'; p += 2) { 1057 if (p[1] == '\0') { 1058 _nc_warning("acsc has odd number of characters"); 1059 break; 1060 } 1061 mapped[UChar(p[0])] = p[1]; 1062 } 1063 1064 if (mapped[UChar('I')] && !mapped[UChar('i')]) { 1065 _nc_warning("acsc refers to 'I', which is probably an error"); 1066 } 1067 1068 for (p = boxes, q = missing; *p != '\0'; ++p) { 1069 if (!mapped[UChar(p[0])]) { 1070 *q++ = p[0]; 1071 } 1072 } 1073 *q = '\0'; 1074 1075 assert(strlen(missing) <= strlen(boxes)); 1076 if (*missing != '\0' && strcmp(missing, boxes)) { 1077 _nc_warning("acsc is missing some line-drawing mapping: %s", missing); 1078 } 1079 } 1080 } 1081 1082 /* 1083 * Check if the color capabilities are consistent 1084 */ 1085 static void 1086 check_colors(TERMTYPE *tp) 1087 { 1088 if ((max_colors > 0) != (max_pairs > 0) 1089 || ((max_colors > max_pairs) && (initialize_pair == 0))) 1090 _nc_warning("inconsistent values for max_colors (%d) and max_pairs (%d)", 1091 max_colors, max_pairs); 1092 1093 PAIRED(set_foreground, set_background); 1094 PAIRED(set_a_foreground, set_a_background); 1095 PAIRED(set_color_pair, initialize_pair); 1096 1097 if (VALID_STRING(set_foreground) 1098 && VALID_STRING(set_a_foreground) 1099 && !_nc_capcmp(set_foreground, set_a_foreground)) 1100 _nc_warning("expected setf/setaf to be different"); 1101 1102 if (VALID_STRING(set_background) 1103 && VALID_STRING(set_a_background) 1104 && !_nc_capcmp(set_background, set_a_background)) 1105 _nc_warning("expected setb/setab to be different"); 1106 1107 /* see: has_colors() */ 1108 if (VALID_NUMERIC(max_colors) && VALID_NUMERIC(max_pairs) 1109 && (((set_foreground != NULL) 1110 && (set_background != NULL)) 1111 || ((set_a_foreground != NULL) 1112 && (set_a_background != NULL)) 1113 || set_color_pair)) { 1114 if (!VALID_STRING(orig_pair) && !VALID_STRING(orig_colors)) 1115 _nc_warning("expected either op/oc string for resetting colors"); 1116 } 1117 } 1118 1119 static char 1120 keypad_final(const char *string) 1121 { 1122 char result = '\0'; 1123 1124 if (VALID_STRING(string) 1125 && *string++ == '\033' 1126 && *string++ == 'O' 1127 && strlen(string) == 1) { 1128 result = *string; 1129 } 1130 1131 return result; 1132 } 1133 1134 static long 1135 keypad_index(const char *string) 1136 { 1137 char *test; 1138 const char *list = "PQRSwxymtuvlqrsPpn"; /* app-keypad except "Enter" */ 1139 int ch; 1140 long result = -1; 1141 1142 if ((ch = keypad_final(string)) != '\0') { 1143 test = (strchr) (list, ch); 1144 if (test != 0) 1145 result = (long) (test - list); 1146 } 1147 return result; 1148 } 1149 1150 /* 1151 * list[] is down, up, left, right 1152 * "left" may be ^H rather than \E[D 1153 * "down" may be ^J rather than \E[B 1154 * But up/right are generally consistently escape sequences for ANSI terminals. 1155 */ 1156 static void 1157 check_ansi_cursor(char *list[4]) 1158 { 1159 int j, k; 1160 int want; 1161 size_t prefix = 0; 1162 size_t suffix; 1163 bool skip[4]; 1164 bool repeated = FALSE; 1165 1166 for (j = 0; j < 4; ++j) { 1167 skip[j] = FALSE; 1168 for (k = 0; k < j; ++k) { 1169 if (j != k 1170 && !strcmp(list[j], list[k])) { 1171 char *value = _nc_tic_expand(list[k], TRUE, 0); 1172 _nc_warning("repeated cursor control %s\n", value); 1173 repeated = TRUE; 1174 } 1175 } 1176 } 1177 if (!repeated) { 1178 char *up = list[1]; 1179 1180 if (UChar(up[0]) == '\033') { 1181 if (up[1] == '[') { 1182 prefix = 2; 1183 } else { 1184 prefix = 1; 1185 } 1186 } else if (UChar(up[0]) == UChar('\233')) { 1187 prefix = 1; 1188 } 1189 if (prefix) { 1190 suffix = prefix; 1191 while (up[suffix] && isdigit(UChar(up[suffix]))) 1192 ++suffix; 1193 } 1194 if (prefix && up[suffix] == 'A') { 1195 skip[1] = TRUE; 1196 if (!strcmp(list[0], "\n")) 1197 skip[0] = TRUE; 1198 if (!strcmp(list[2], "\b")) 1199 skip[2] = TRUE; 1200 1201 for (j = 0; j < 4; ++j) { 1202 if (skip[j] || strlen(list[j]) == 1) 1203 continue; 1204 if (memcmp(list[j], up, prefix)) { 1205 char *value = _nc_tic_expand(list[j], TRUE, 0); 1206 _nc_warning("inconsistent prefix for %s\n", value); 1207 continue; 1208 } 1209 if (strlen(list[j]) < suffix) { 1210 char *value = _nc_tic_expand(list[j], TRUE, 0); 1211 _nc_warning("inconsistent length for %s, expected %d\n", 1212 value, (int) suffix + 1); 1213 continue; 1214 } 1215 want = "BADC"[j]; 1216 if (list[j][suffix] != want) { 1217 char *value = _nc_tic_expand(list[j], TRUE, 0); 1218 _nc_warning("inconsistent suffix for %s, expected %c, have %c\n", 1219 value, want, list[j][suffix]); 1220 } 1221 } 1222 } 1223 } 1224 } 1225 1226 #define EXPECTED(name) if (!PRESENT(name)) _nc_warning("expected " #name) 1227 #define UNEXPECTED(name) if (PRESENT(name)) _nc_warning("unexpected " #name ", for %s", why) 1228 1229 static void 1230 check_noaddress(TERMTYPE *tp, const char *why) 1231 { 1232 UNEXPECTED(column_address); 1233 UNEXPECTED(cursor_address); 1234 UNEXPECTED(cursor_home); 1235 UNEXPECTED(cursor_mem_address); 1236 UNEXPECTED(cursor_to_ll); 1237 UNEXPECTED(row_address); 1238 UNEXPECTED(row_address); 1239 } 1240 1241 static void 1242 check_cursor(TERMTYPE *tp) 1243 { 1244 int count; 1245 char *list[4]; 1246 1247 if (hard_copy) { 1248 check_noaddress(tp, "hard_copy"); 1249 } else if (generic_type) { 1250 check_noaddress(tp, "generic_type"); 1251 } else if (strchr(tp->term_names, '+') == 0) { 1252 int y = 0; 1253 int x = 0; 1254 if (PRESENT(column_address)) 1255 ++y; 1256 if (PRESENT(cursor_address)) 1257 y = x = 10; 1258 if (PRESENT(cursor_home)) 1259 ++y, ++x; 1260 if (PRESENT(cursor_mem_address)) 1261 y = x = 10; 1262 if (PRESENT(cursor_to_ll)) 1263 ++y, ++x; 1264 if (PRESENT(row_address)) 1265 ++x; 1266 if (PRESENT(cursor_down)) 1267 ++y; 1268 if (PRESENT(cursor_up)) 1269 ++y; 1270 if (PRESENT(cursor_left)) 1271 ++x; 1272 if (PRESENT(cursor_right)) 1273 ++x; 1274 if (x < 2 && y < 2) { 1275 _nc_warning("terminal lacks cursor addressing"); 1276 } else { 1277 if (x < 2) 1278 _nc_warning("terminal lacks cursor column-addressing"); 1279 if (y < 2) 1280 _nc_warning("terminal lacks cursor row-addressing"); 1281 } 1282 } 1283 1284 /* it is rare to have an insert-line feature without a matching delete */ 1285 ANDMISSING(parm_insert_line, insert_line); 1286 ANDMISSING(parm_delete_line, delete_line); 1287 ANDMISSING(parm_insert_line, parm_delete_line); 1288 1289 /* if we have a parameterized form, then the non-parameterized is easy */ 1290 ANDMISSING(parm_down_cursor, cursor_down); 1291 ANDMISSING(parm_up_cursor, cursor_up); 1292 ANDMISSING(parm_left_cursor, cursor_left); 1293 ANDMISSING(parm_right_cursor, cursor_right); 1294 1295 /* Given any of a set of cursor movement, the whole set should be present. 1296 * Technically this is not true (we could use cursor_address to fill in 1297 * unsupported controls), but it is likely. 1298 */ 1299 count = 0; 1300 if (PRESENT(parm_down_cursor)) { 1301 list[count++] = parm_down_cursor; 1302 } 1303 if (PRESENT(parm_up_cursor)) { 1304 list[count++] = parm_up_cursor; 1305 } 1306 if (PRESENT(parm_left_cursor)) { 1307 list[count++] = parm_left_cursor; 1308 } 1309 if (PRESENT(parm_right_cursor)) { 1310 list[count++] = parm_right_cursor; 1311 } 1312 if (count == 4) { 1313 check_ansi_cursor(list); 1314 } else if (count != 0) { 1315 EXPECTED(parm_down_cursor); 1316 EXPECTED(parm_up_cursor); 1317 EXPECTED(parm_left_cursor); 1318 EXPECTED(parm_right_cursor); 1319 } 1320 1321 count = 0; 1322 if (PRESENT(cursor_down)) { 1323 list[count++] = cursor_down; 1324 } 1325 if (PRESENT(cursor_up)) { 1326 list[count++] = cursor_up; 1327 } 1328 if (PRESENT(cursor_left)) { 1329 list[count++] = cursor_left; 1330 } 1331 if (PRESENT(cursor_right)) { 1332 list[count++] = cursor_right; 1333 } 1334 if (count == 4) { 1335 check_ansi_cursor(list); 1336 } else if (count != 0) { 1337 count = 0; 1338 if (PRESENT(cursor_down) && strcmp(cursor_down, "\n")) 1339 ++count; 1340 if (PRESENT(cursor_left) && strcmp(cursor_left, "\b")) 1341 ++count; 1342 if (PRESENT(cursor_up) && strlen(cursor_up) > 1) 1343 ++count; 1344 if (PRESENT(cursor_right) && strlen(cursor_right) > 1) 1345 ++count; 1346 if (count) { 1347 EXPECTED(cursor_down); 1348 EXPECTED(cursor_up); 1349 EXPECTED(cursor_left); 1350 EXPECTED(cursor_right); 1351 } 1352 } 1353 } 1354 1355 #define MAX_KP 5 1356 /* 1357 * Do a quick sanity-check for vt100-style keypads to see if the 5-key keypad 1358 * is mapped inconsistently. 1359 */ 1360 static void 1361 check_keypad(TERMTYPE *tp) 1362 { 1363 char show[80]; 1364 1365 if (VALID_STRING(key_a1) && 1366 VALID_STRING(key_a3) && 1367 VALID_STRING(key_b2) && 1368 VALID_STRING(key_c1) && 1369 VALID_STRING(key_c3)) { 1370 char final[MAX_KP + 1]; 1371 long list[MAX_KP]; 1372 int increase = 0; 1373 int j, k, kk; 1374 long last; 1375 long test; 1376 1377 final[0] = keypad_final(key_a1); 1378 final[1] = keypad_final(key_a3); 1379 final[2] = keypad_final(key_b2); 1380 final[3] = keypad_final(key_c1); 1381 final[4] = keypad_final(key_c3); 1382 final[5] = '\0'; 1383 1384 /* special case: legacy coding using 1,2,3,0,. on the bottom */ 1385 assert(strlen(final) <= MAX_KP); 1386 if (!strcmp(final, "qsrpn")) 1387 return; 1388 1389 list[0] = keypad_index(key_a1); 1390 list[1] = keypad_index(key_a3); 1391 list[2] = keypad_index(key_b2); 1392 list[3] = keypad_index(key_c1); 1393 list[4] = keypad_index(key_c3); 1394 1395 /* check that they're all vt100 keys */ 1396 for (j = 0; j < MAX_KP; ++j) { 1397 if (list[j] < 0) { 1398 return; 1399 } 1400 } 1401 1402 /* check if they're all in increasing order */ 1403 for (j = 1; j < MAX_KP; ++j) { 1404 if (list[j] > list[j - 1]) { 1405 ++increase; 1406 } 1407 } 1408 if (increase != (MAX_KP - 1)) { 1409 show[0] = '\0'; 1410 1411 for (j = 0, last = -1; j < MAX_KP; ++j) { 1412 for (k = 0, kk = -1, test = 100; k < 5; ++k) { 1413 if (list[k] > last && 1414 list[k] < test) { 1415 test = list[k]; 1416 kk = k; 1417 } 1418 } 1419 last = test; 1420 assert(strlen(show) < (MAX_KP * 4)); 1421 switch (kk) { 1422 case 0: 1423 _nc_STRCAT(show, " ka1", sizeof(show)); 1424 break; 1425 case 1: 1426 _nc_STRCAT(show, " ka3", sizeof(show)); 1427 break; 1428 case 2: 1429 _nc_STRCAT(show, " kb2", sizeof(show)); 1430 break; 1431 case 3: 1432 _nc_STRCAT(show, " kc1", sizeof(show)); 1433 break; 1434 case 4: 1435 _nc_STRCAT(show, " kc3", sizeof(show)); 1436 break; 1437 } 1438 } 1439 1440 _nc_warning("vt100 keypad order inconsistent: %s", show); 1441 } 1442 1443 } else if (VALID_STRING(key_a1) || 1444 VALID_STRING(key_a3) || 1445 VALID_STRING(key_b2) || 1446 VALID_STRING(key_c1) || 1447 VALID_STRING(key_c3)) { 1448 show[0] = '\0'; 1449 if (keypad_index(key_a1) >= 0) 1450 _nc_STRCAT(show, " ka1", sizeof(show)); 1451 if (keypad_index(key_a3) >= 0) 1452 _nc_STRCAT(show, " ka3", sizeof(show)); 1453 if (keypad_index(key_b2) >= 0) 1454 _nc_STRCAT(show, " kb2", sizeof(show)); 1455 if (keypad_index(key_c1) >= 0) 1456 _nc_STRCAT(show, " kc1", sizeof(show)); 1457 if (keypad_index(key_c3) >= 0) 1458 _nc_STRCAT(show, " kc3", sizeof(show)); 1459 if (*show != '\0') 1460 _nc_warning("vt100 keypad map incomplete:%s", show); 1461 } 1462 1463 /* 1464 * These warnings are useful for consistency checks - it is possible that 1465 * there are real terminals with mismatches in these 1466 */ 1467 ANDMISSING(key_ic, key_dc); 1468 } 1469 1470 static void 1471 check_printer(TERMTYPE *tp) 1472 { 1473 PAIRED(enter_doublewide_mode, exit_doublewide_mode); 1474 PAIRED(enter_italics_mode, exit_italics_mode); 1475 PAIRED(enter_leftward_mode, exit_leftward_mode); 1476 PAIRED(enter_micro_mode, exit_micro_mode); 1477 PAIRED(enter_shadow_mode, exit_shadow_mode); 1478 PAIRED(enter_subscript_mode, exit_subscript_mode); 1479 PAIRED(enter_superscript_mode, exit_superscript_mode); 1480 PAIRED(enter_upward_mode, exit_upward_mode); 1481 1482 ANDMISSING(start_char_set_def, stop_char_set_def); 1483 1484 /* if we have a parameterized form, then the non-parameterized is easy */ 1485 ANDMISSING(set_bottom_margin_parm, set_bottom_margin); 1486 ANDMISSING(set_left_margin_parm, set_left_margin); 1487 ANDMISSING(set_right_margin_parm, set_right_margin); 1488 ANDMISSING(set_top_margin_parm, set_top_margin); 1489 1490 ANDMISSING(parm_down_micro, micro_down); 1491 ANDMISSING(parm_left_micro, micro_left); 1492 ANDMISSING(parm_right_micro, micro_right); 1493 ANDMISSING(parm_up_micro, micro_up); 1494 } 1495 1496 static bool 1497 uses_SGR_39_49(const char *value) 1498 { 1499 return (strstr(value, "39;49") != 0 1500 || strstr(value, "49;39") != 0); 1501 } 1502 1503 /* 1504 * Check consistency of termcap extensions related to "screen". 1505 */ 1506 static void 1507 check_screen(TERMTYPE *tp) 1508 { 1509 #if NCURSES_XNAMES 1510 if (_nc_user_definable) { 1511 int have_XT = tigetflag("XT"); 1512 int have_XM = tigetflag("XM"); 1513 int have_bce = back_color_erase; 1514 bool have_kmouse = FALSE; 1515 bool use_sgr_39_49 = FALSE; 1516 char *name = _nc_first_name(tp->term_names); 1517 1518 if (!VALID_BOOLEAN(have_bce)) { 1519 have_bce = FALSE; 1520 } 1521 if (!VALID_BOOLEAN(have_XM)) { 1522 have_XM = FALSE; 1523 } 1524 if (!VALID_BOOLEAN(have_XT)) { 1525 have_XT = FALSE; 1526 } 1527 if (VALID_STRING(key_mouse)) { 1528 have_kmouse = !strcmp("\033[M", key_mouse); 1529 } 1530 if (VALID_STRING(orig_colors)) { 1531 use_sgr_39_49 = uses_SGR_39_49(orig_colors); 1532 } else if (VALID_STRING(orig_pair)) { 1533 use_sgr_39_49 = uses_SGR_39_49(orig_pair); 1534 } 1535 1536 if (have_XM && have_XT) { 1537 _nc_warning("Screen's XT capability conflicts with XM"); 1538 } else if (have_XT 1539 && strstr(name, "screen") != 0 1540 && strchr(name, '.') != 0) { 1541 _nc_warning("Screen's \"screen\" entries should not have XT set"); 1542 } else if (have_XT) { 1543 if (!have_kmouse && have_bce) { 1544 if (VALID_STRING(key_mouse)) { 1545 _nc_warning("Value of kmous inconsistent with screen's usage"); 1546 } else { 1547 _nc_warning("Expected kmous capability with XT"); 1548 } 1549 } 1550 if (!have_bce && max_colors > 0) 1551 _nc_warning("Expected bce capability with XT"); 1552 if (!use_sgr_39_49 && have_bce && max_colors > 0) 1553 _nc_warning("Expected orig_colors capability with XT to have 39/49 parameters"); 1554 if (VALID_STRING(to_status_line)) 1555 _nc_warning("\"tsl\" capability is redundant, given XT"); 1556 } else { 1557 if (have_kmouse && !have_XM) 1558 _nc_warning("Expected XT to be set, given kmous"); 1559 } 1560 } 1561 #endif 1562 } 1563 1564 /* 1565 * Returns the expected number of parameters for the given capability. 1566 */ 1567 static int 1568 expected_params(const char *name) 1569 { 1570 /* *INDENT-OFF* */ 1571 static const struct { 1572 const char *name; 1573 int count; 1574 } table[] = { 1575 { "S0", 1 }, /* 'screen' extension */ 1576 { "birep", 2 }, 1577 { "chr", 1 }, 1578 { "colornm", 1 }, 1579 { "cpi", 1 }, 1580 { "csnm", 1 }, 1581 { "csr", 2 }, 1582 { "cub", 1 }, 1583 { "cud", 1 }, 1584 { "cuf", 1 }, 1585 { "cup", 2 }, 1586 { "cuu", 1 }, 1587 { "cvr", 1 }, 1588 { "cwin", 5 }, 1589 { "dch", 1 }, 1590 { "defc", 3 }, 1591 { "dial", 1 }, 1592 { "dispc", 1 }, 1593 { "dl", 1 }, 1594 { "ech", 1 }, 1595 { "getm", 1 }, 1596 { "hpa", 1 }, 1597 { "ich", 1 }, 1598 { "il", 1 }, 1599 { "indn", 1 }, 1600 { "initc", 4 }, 1601 { "initp", 7 }, 1602 { "lpi", 1 }, 1603 { "mc5p", 1 }, 1604 { "mrcup", 2 }, 1605 { "mvpa", 1 }, 1606 { "pfkey", 2 }, 1607 { "pfloc", 2 }, 1608 { "pfx", 2 }, 1609 { "pfxl", 3 }, 1610 { "pln", 2 }, 1611 { "qdial", 1 }, 1612 { "rcsd", 1 }, 1613 { "rep", 2 }, 1614 { "rin", 1 }, 1615 { "sclk", 3 }, 1616 { "scp", 1 }, 1617 { "scs", 1 }, 1618 { "scsd", 2 }, 1619 { "setab", 1 }, 1620 { "setaf", 1 }, 1621 { "setb", 1 }, 1622 { "setcolor", 1 }, 1623 { "setf", 1 }, 1624 { "sgr", 9 }, 1625 { "sgr1", 6 }, 1626 { "slength", 1 }, 1627 { "slines", 1 }, 1628 { "smgbp", 1 }, /* 2 if smgtp is not given */ 1629 { "smglp", 1 }, 1630 { "smglr", 2 }, 1631 { "smgrp", 1 }, 1632 { "smgtb", 2 }, 1633 { "smgtp", 1 }, 1634 { "tsl", 1 }, 1635 { "u6", -1 }, 1636 { "vpa", 1 }, 1637 { "wind", 4 }, 1638 { "wingo", 1 }, 1639 }; 1640 /* *INDENT-ON* */ 1641 1642 unsigned n; 1643 int result = 0; /* function-keys, etc., use none */ 1644 1645 for (n = 0; n < SIZEOF(table); n++) { 1646 if (!strcmp(name, table[n].name)) { 1647 result = table[n].count; 1648 break; 1649 } 1650 } 1651 1652 return result; 1653 } 1654 1655 /* 1656 * Make a quick sanity check for the parameters which are used in the given 1657 * strings. If there are no "%p" tokens, then there should be no other "%" 1658 * markers. 1659 */ 1660 static void 1661 check_params(TERMTYPE *tp, const char *name, char *value) 1662 { 1663 int expected = expected_params(name); 1664 int actual = 0; 1665 int n; 1666 bool params[10]; 1667 char *s = value; 1668 1669 #ifdef set_top_margin_parm 1670 if (!strcmp(name, "smgbp") 1671 && set_top_margin_parm == 0) 1672 expected = 2; 1673 #endif 1674 1675 for (n = 0; n < 10; n++) 1676 params[n] = FALSE; 1677 1678 while (*s != 0) { 1679 if (*s == '%') { 1680 if (*++s == '\0') { 1681 _nc_warning("expected character after %% in %s", name); 1682 break; 1683 } else if (*s == 'p') { 1684 if (*++s == '\0' || !isdigit((int) *s)) { 1685 _nc_warning("expected digit after %%p in %s", name); 1686 return; 1687 } else { 1688 n = (*s - '0'); 1689 if (n > actual) 1690 actual = n; 1691 params[n] = TRUE; 1692 } 1693 } 1694 } 1695 s++; 1696 } 1697 1698 if (params[0]) { 1699 _nc_warning("%s refers to parameter 0 (%%p0), which is not allowed", name); 1700 } 1701 if (value == set_attributes || expected < 0) { 1702 ; 1703 } else if (expected != actual) { 1704 _nc_warning("%s uses %d parameters, expected %d", name, 1705 actual, expected); 1706 for (n = 1; n < actual; n++) { 1707 if (!params[n]) 1708 _nc_warning("%s omits parameter %d", name, n); 1709 } 1710 } 1711 } 1712 1713 static char * 1714 skip_delay(char *s) 1715 { 1716 while (*s == '/' || isdigit(UChar(*s))) 1717 ++s; 1718 return s; 1719 } 1720 1721 /* 1722 * Skip a delay altogether, e.g., when comparing a simple string to sgr, 1723 * the latter may have a worst-case delay on the end. 1724 */ 1725 static char * 1726 ignore_delays(char *s) 1727 { 1728 int delaying = 0; 1729 1730 do { 1731 switch (*s) { 1732 case '$': 1733 if (delaying == 0) 1734 delaying = 1; 1735 break; 1736 case '<': 1737 if (delaying == 1) 1738 delaying = 2; 1739 break; 1740 case '\0': 1741 delaying = 0; 1742 break; 1743 default: 1744 if (delaying) { 1745 s = skip_delay(s); 1746 if (*s == '>') 1747 ++s; 1748 delaying = 0; 1749 } 1750 break; 1751 } 1752 if (delaying) 1753 ++s; 1754 } while (delaying); 1755 return s; 1756 } 1757 1758 /* 1759 * An sgr string may contain several settings other than the one we're 1760 * interested in, essentially sgr0 + rmacs + whatever. As long as the 1761 * "whatever" is contained in the sgr string, that is close enough for our 1762 * sanity check. 1763 */ 1764 static bool 1765 similar_sgr(int num, char *a, char *b) 1766 { 1767 static const char *names[] = 1768 { 1769 "none" 1770 ,"standout" 1771 ,"underline" 1772 ,"reverse" 1773 ,"blink" 1774 ,"dim" 1775 ,"bold" 1776 ,"invis" 1777 ,"protect" 1778 ,"altcharset" 1779 }; 1780 char *base_a = a; 1781 char *base_b = b; 1782 int delaying = 0; 1783 1784 while (*b != 0) { 1785 while (*a != *b) { 1786 if (*a == 0) { 1787 if (b[0] == '$' 1788 && b[1] == '<') { 1789 _nc_warning("Did not find delay %s", _nc_visbuf(b)); 1790 } else { 1791 _nc_warning("checking sgr(%s) %s\n\tcompare to %s\n\tunmatched %s", 1792 names[num], _nc_visbuf2(1, base_a), 1793 _nc_visbuf2(2, base_b), 1794 _nc_visbuf2(3, b)); 1795 } 1796 return FALSE; 1797 } else if (delaying) { 1798 a = skip_delay(a); 1799 b = skip_delay(b); 1800 } else if ((*b == '0' || (*b == ';')) && *a == 'm') { 1801 b++; 1802 } else { 1803 a++; 1804 } 1805 } 1806 switch (*a) { 1807 case '$': 1808 if (delaying == 0) 1809 delaying = 1; 1810 break; 1811 case '<': 1812 if (delaying == 1) 1813 delaying = 2; 1814 break; 1815 default: 1816 delaying = 0; 1817 break; 1818 } 1819 a++; 1820 b++; 1821 } 1822 /* ignore delays on the end of the string */ 1823 a = ignore_delays(a); 1824 return ((num != 0) || (*a == 0)); 1825 } 1826 1827 static char * 1828 check_sgr(TERMTYPE *tp, char *zero, int num, char *cap, const char *name) 1829 { 1830 char *test; 1831 1832 _nc_tparm_err = 0; 1833 test = TPARM_9(set_attributes, 1834 num == 1, 1835 num == 2, 1836 num == 3, 1837 num == 4, 1838 num == 5, 1839 num == 6, 1840 num == 7, 1841 num == 8, 1842 num == 9); 1843 if (test != 0) { 1844 if (PRESENT(cap)) { 1845 if (!similar_sgr(num, test, cap)) { 1846 _nc_warning("%s differs from sgr(%d)\n\t%s=%s\n\tsgr(%d)=%s", 1847 name, num, 1848 name, _nc_visbuf2(1, cap), 1849 num, _nc_visbuf2(2, test)); 1850 } 1851 } else if (_nc_capcmp(test, zero)) { 1852 _nc_warning("sgr(%d) present, but not %s", num, name); 1853 } 1854 } else if (PRESENT(cap)) { 1855 _nc_warning("sgr(%d) missing, but %s present", num, name); 1856 } 1857 if (_nc_tparm_err) 1858 _nc_warning("stack error in sgr(%d) string", num); 1859 return test; 1860 } 1861 1862 #define CHECK_SGR(num,name) check_sgr(tp, zero, num, name, #name) 1863 1864 #ifdef TRACE 1865 /* 1866 * If tic is compiled with TRACE, we'll be able to see the output from the 1867 * DEBUG() macro. But since it doesn't use traceon(), it always goes to 1868 * the standard error. Use this function to make it simpler to follow the 1869 * resulting debug traces. 1870 */ 1871 static void 1872 show_where(unsigned level) 1873 { 1874 if (_nc_tracing >= DEBUG_LEVEL(level)) { 1875 char my_name[MAX_NAME_SIZE]; 1876 _nc_get_type(my_name); 1877 _tracef("\"%s\", line %d, '%s'", 1878 _nc_get_source(), 1879 _nc_curr_line, my_name); 1880 } 1881 } 1882 1883 #else 1884 #define show_where(level) /* nothing */ 1885 #endif 1886 1887 typedef struct { 1888 int keycode; 1889 const char *name; 1890 const char *value; 1891 } NAME_VALUE; 1892 1893 static NAME_VALUE * 1894 get_fkey_list(TERMTYPE *tp) 1895 { 1896 NAME_VALUE *result = typeMalloc(NAME_VALUE, NUM_STRINGS(tp) + 1); 1897 const struct tinfo_fkeys *all_fkeys = _nc_tinfo_fkeys; 1898 int used = 0; 1899 int j; 1900 1901 if (result == 0) 1902 failed("get_fkey_list"); 1903 1904 for (j = 0; all_fkeys[j].code; j++) { 1905 char *a = tp->Strings[all_fkeys[j].offset]; 1906 if (VALID_STRING(a)) { 1907 result[used].keycode = (int) all_fkeys[j].code; 1908 result[used].name = strnames[all_fkeys[j].offset]; 1909 result[used].value = a; 1910 ++used; 1911 } 1912 } 1913 #if NCURSES_XNAMES 1914 for (j = STRCOUNT; j < NUM_STRINGS(tp); ++j) { 1915 const char *name = ExtStrname(tp, j, strnames); 1916 if (*name == 'k') { 1917 result[used].keycode = -1; 1918 result[used].name = name; 1919 result[used].value = tp->Strings[j]; 1920 ++used; 1921 } 1922 } 1923 #endif 1924 result[used].keycode = 0; 1925 return result; 1926 } 1927 1928 static void 1929 show_fkey_name(NAME_VALUE * data) 1930 { 1931 if (data->keycode > 0) { 1932 fprintf(stderr, " %s", keyname(data->keycode)); 1933 fprintf(stderr, " (capability \"%s\")", data->name); 1934 } else { 1935 fprintf(stderr, " capability \"%s\"", data->name); 1936 } 1937 } 1938 1939 /* other sanity-checks (things that we don't want in the normal 1940 * logic that reads a terminfo entry) 1941 */ 1942 static void 1943 check_termtype(TERMTYPE *tp, bool literal) 1944 { 1945 bool conflict = FALSE; 1946 unsigned j, k; 1947 1948 /* 1949 * A terminal entry may contain more than one keycode assigned to 1950 * a given string (e.g., KEY_END and KEY_LL). But curses will only 1951 * return one (the last one assigned). 1952 */ 1953 if (!(_nc_syntax == SYN_TERMCAP && capdump)) { 1954 char *check = calloc((size_t) (NUM_STRINGS(tp) + 1), sizeof(char)); 1955 NAME_VALUE *given = get_fkey_list(tp); 1956 1957 if (check == 0) 1958 failed("check_termtype"); 1959 1960 for (j = 0; given[j].keycode; ++j) { 1961 const char *a = given[j].value; 1962 bool first = TRUE; 1963 1964 for (k = j + 1; given[k].keycode; k++) { 1965 const char *b = given[k].value; 1966 if (check[k]) 1967 continue; 1968 if (!_nc_capcmp(a, b)) { 1969 check[j] = 1; 1970 check[k] = 1; 1971 if (first) { 1972 if (!conflict) { 1973 _nc_warning("Conflicting key definitions (using the last)"); 1974 conflict = TRUE; 1975 } 1976 fprintf(stderr, "..."); 1977 show_fkey_name(given + j); 1978 fprintf(stderr, " is the same as"); 1979 show_fkey_name(given + k); 1980 first = FALSE; 1981 } else { 1982 fprintf(stderr, ", "); 1983 show_fkey_name(given + k); 1984 } 1985 } 1986 } 1987 if (!first) 1988 fprintf(stderr, "\n"); 1989 } 1990 free(given); 1991 free(check); 1992 } 1993 1994 for_each_string(j, tp) { 1995 char *a = tp->Strings[j]; 1996 if (VALID_STRING(a)) 1997 check_params(tp, ExtStrname(tp, (int) j, strnames), a); 1998 } 1999 2000 check_acs(tp); 2001 check_colors(tp); 2002 check_cursor(tp); 2003 check_keypad(tp); 2004 check_printer(tp); 2005 check_screen(tp); 2006 2007 /* 2008 * These may be mismatched because the terminal description relies on 2009 * restoring the cursor visibility by resetting it. 2010 */ 2011 ANDMISSING(cursor_invisible, cursor_normal); 2012 ANDMISSING(cursor_visible, cursor_normal); 2013 2014 if (PRESENT(cursor_visible) && PRESENT(cursor_normal) 2015 && !_nc_capcmp(cursor_visible, cursor_normal)) 2016 _nc_warning("cursor_visible is same as cursor_normal"); 2017 2018 /* 2019 * From XSI & O'Reilly, we gather that sc/rc are required if csr is 2020 * given, because the cursor position after the scrolling operation is 2021 * performed is undefined. 2022 */ 2023 ANDMISSING(change_scroll_region, save_cursor); 2024 ANDMISSING(change_scroll_region, restore_cursor); 2025 2026 /* 2027 * If we can clear tabs, we should be able to initialize them. 2028 */ 2029 ANDMISSING(clear_all_tabs, set_tab); 2030 2031 if (PRESENT(set_attributes)) { 2032 char *zero = 0; 2033 2034 _nc_tparm_err = 0; 2035 if (PRESENT(exit_attribute_mode)) { 2036 zero = strdup(CHECK_SGR(0, exit_attribute_mode)); 2037 } else { 2038 zero = strdup(TPARM_9(set_attributes, 0, 0, 0, 0, 0, 0, 0, 0, 0)); 2039 } 2040 if (_nc_tparm_err) 2041 _nc_warning("stack error in sgr(0) string"); 2042 2043 if (zero != 0) { 2044 CHECK_SGR(1, enter_standout_mode); 2045 CHECK_SGR(2, enter_underline_mode); 2046 CHECK_SGR(3, enter_reverse_mode); 2047 CHECK_SGR(4, enter_blink_mode); 2048 CHECK_SGR(5, enter_dim_mode); 2049 CHECK_SGR(6, enter_bold_mode); 2050 CHECK_SGR(7, enter_secure_mode); 2051 CHECK_SGR(8, enter_protected_mode); 2052 CHECK_SGR(9, enter_alt_charset_mode); 2053 free(zero); 2054 } else { 2055 _nc_warning("sgr(0) did not return a value"); 2056 } 2057 } else if (PRESENT(exit_attribute_mode) && 2058 set_attributes != CANCELLED_STRING) { 2059 if (_nc_syntax == SYN_TERMINFO) 2060 _nc_warning("missing sgr string"); 2061 } 2062 2063 if (PRESENT(exit_attribute_mode)) { 2064 char *check_sgr0 = _nc_trim_sgr0(tp); 2065 2066 if (check_sgr0 == 0 || *check_sgr0 == '\0') { 2067 _nc_warning("trimmed sgr0 is empty"); 2068 } else { 2069 show_where(2); 2070 if (check_sgr0 != exit_attribute_mode) { 2071 DEBUG(2, 2072 ("will trim sgr0\n\toriginal sgr0=%s\n\ttrimmed sgr0=%s", 2073 _nc_visbuf2(1, exit_attribute_mode), 2074 _nc_visbuf2(2, check_sgr0))); 2075 free(check_sgr0); 2076 } else { 2077 DEBUG(2, 2078 ("will not trim sgr0\n\toriginal sgr0=%s", 2079 _nc_visbuf(exit_attribute_mode))); 2080 } 2081 } 2082 } 2083 #ifdef TRACE 2084 show_where(2); 2085 if (!auto_right_margin) { 2086 DEBUG(2, 2087 ("can write to lower-right directly")); 2088 } else if (PRESENT(enter_am_mode) && PRESENT(exit_am_mode)) { 2089 DEBUG(2, 2090 ("can write to lower-right by suppressing automargin")); 2091 } else if ((PRESENT(enter_insert_mode) && PRESENT(exit_insert_mode)) 2092 || PRESENT(insert_character) || PRESENT(parm_ich)) { 2093 DEBUG(2, 2094 ("can write to lower-right by using inserts")); 2095 } else { 2096 DEBUG(2, 2097 ("cannot write to lower-right")); 2098 } 2099 #endif 2100 2101 /* 2102 * Some standard applications (e.g., vi) and some non-curses 2103 * applications (e.g., jove) get confused if we have both ich1 and 2104 * smir/rmir. Let's be nice and warn about that, too, even though 2105 * ncurses handles it. 2106 */ 2107 if ((PRESENT(enter_insert_mode) || PRESENT(exit_insert_mode)) 2108 && PRESENT(parm_ich)) { 2109 _nc_warning("non-curses applications may be confused by ich1 with smir/rmir"); 2110 } 2111 2112 /* 2113 * Finally, do the non-verbose checks 2114 */ 2115 if (save_check_termtype != 0) 2116 save_check_termtype(tp, literal); 2117 } 2118