progs/tic.c

   1 /****************************************************************************
   2  * Copyright (c) 1998,1999,2000 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  ****************************************************************************/
  33
  34 /*
  35  *      tic.c --- Main program for terminfo compiler
  36  *                      by Eric S. Raymond
  37  *
  38  */
  39
  40 #include <progs.priv.h>
  41
  42 #include <dump_entry.h>
  43 #include <term_entry.h>
  44
  45 MODULE_ID("$Id: tic.c,v 1.69 2000/04/08 23:53:49 tom Exp $")
  46
  47 const char *_nc_progname = "tic";
  48
  49 static FILE *log_fp;
  50 static FILE *tmp_fp;
  51 static bool showsummary = FALSE;
  52 static const char *to_remove;
  53
  54 static void (*save_check_termtype) (TERMTYPE *);
  55 static void check_termtype(TERMTYPE * tt);
  56
  57 static const char usage_string[] = "[-h] [-v[n]] [-e names] [-CILNRTcfrswx1] source-file\n";
  58
  59 static void
  60 cleanup(void)
  61 {
  62     if (tmp_fp != 0)
  63         fclose(tmp_fp);
  64     if (to_remove != 0) {
  65 #if HAVE_REMOVE
  66         remove(to_remove);
  67 #else
  68         unlink(to_remove);
  69 #endif
  70     }
  71 }
  72
  73 static void
  74 failed(const char *msg)
  75 {
  76     perror(msg);
  77     cleanup();
  78     exit(EXIT_FAILURE);
  79 }
  80
  81 static void
  82 usage(void)
  83 {
  84     static const char *const tbl[] =
  85     {
  86         "Options:",
  87         "  -1         format translation output one capability per line",
  88         "  -C         translate entries to termcap source form",
  89         "  -I         translate entries to terminfo source form",
  90         "  -L         translate entries to full terminfo source form",
  91         "  -N         disable smart defaults for source translation",
  92         "  -R         restrict translation to given terminfo/termcap version",
  93         "  -T         remove size-restrictions on compiled description",
  94 #if NCURSES_XNAMES
  95         "  -a         retain commented-out capabilities (sets -x also)",
  96 #endif
  97         "  -c         check only, validate input without compiling or translating",
  98         "  -f         format complex strings for readability",
  99         "  -G         format %{number} to %'char'",
 100         "  -g         format %'char' to %{number}",
 101         "  -e<names>  translate/compile only entries named by comma-separated list",
 102         "  -o<dir>    set output directory for compiled entry writes",
 103         "  -r         force resolution of all use entries in source translation",
 104         "  -s         print summary statistics",
 105         "  -v[n]      set verbosity level",
 106         "  -w[n]      set format width for translation output",
 107 #if NCURSES_XNAMES
 108         "  -x         treat unknown capabilities as user-defined",
 109 #endif
 110         "",
 111         "Parameters:",
 112         "  <file>     file to translate or compile"
 113     };
 114     size_t j;
 115
 116     fprintf(stderr, "Usage: %s %s\n", _nc_progname, usage_string);
 117     for (j = 0; j < sizeof(tbl) / sizeof(tbl[0]); j++) {
 118         fputs(tbl[j], stderr);
 119         putc('\n', stderr);
 120     }
 121     exit(EXIT_FAILURE);
 122 }
 123
 124 #define L_BRACE '{'
 125 #define R_BRACE '}'
 126 #define S_QUOTE '\'';
 127
 128 static void
 129 write_it(ENTRY * ep)
 130 {
 131     unsigned n;
 132     int ch;
 133     char *s, *d, *t;
 134     char result[MAX_ENTRY_SIZE];
 135
 136     /*
 137      * Look for strings that contain %{number}, convert them to %'char',
 138      * which is shorter and runs a little faster.
 139      */
 140     for (n = 0; n < STRCOUNT; n++) {
 141         s = ep->tterm.Strings[n];
 142         if (VALID_STRING(s)
 143             && strchr(s, L_BRACE) != 0) {
 144             d = result;
 145             t = s;
 146             while ((ch = *t++) != 0) {
 147                 *d++ = ch;
 148                 if (ch == '\\') {
 149                     *d++ = *t++;
 150                 } else if ((ch == '%')
 151                     && (*t == L_BRACE)) {
 152                     char *v = 0;
 153                     long value = strtol(t + 1, &v, 0);
 154                     if (v != 0
 155                         && *v == R_BRACE
 156                         && value > 0
 157                         && value != '\\'        /* FIXME */
 158                         && value < 127
 159                         && isprint((int) value)) {
 160                         *d++ = S_QUOTE;
 161                         *d++ = (int) value;
 162                         *d++ = S_QUOTE;
 163                         t = (v + 1);
 164                     }
 165                 }
 166             }
 167             *d = 0;
 168             if (strlen(result) < strlen(s))
 169                 strcpy(s, result);
 170         }
 171     }
 172
 173     _nc_set_type(_nc_first_name(ep->tterm.term_names));
 174     _nc_curr_line = ep->startline;
 175     _nc_write_entry(&ep->tterm);
 176 }
 177
 178 static bool
 179 immedhook(ENTRY * ep GCC_UNUSED)
 180 /* write out entries with no use capabilities immediately to save storage */
 181 {
 182 #ifndef HAVE_BIG_CORE
 183     /*
 184      * This is strictly a core-economy kluge.  The really clean way to handle
 185      * compilation is to slurp the whole file into core and then do all the
 186      * name-collision checks and entry writes in one swell foop.  But the
 187      * terminfo master file is large enough that some core-poor systems swap
 188      * like crazy when you compile it this way...there have been reports of
 189      * this process taking *three hours*, rather than the twenty seconds or
 190      * less typical on my development box.
 191      *
 192      * So.  This hook *immediately* writes out the referenced entry if it
 193      * has no use capabilities.  The compiler main loop refrains from
 194      * adding the entry to the in-core list when this hook fires.  If some
 195      * other entry later needs to reference an entry that got written
 196      * immediately, that's OK; the resolution code will fetch it off disk
 197      * when it can't find it in core.
 198      *
 199      * Name collisions will still be detected, just not as cleanly.  The
 200      * write_entry() code complains before overwriting an entry that
 201      * postdates the time of tic's first call to write_entry().  Thus
 202      * it will complain about overwriting entries newly made during the
 203      * tic run, but not about overwriting ones that predate it.
 204      *
 205      * The reason this is a hook, and not in line with the rest of the
 206      * compiler code, is that the support for termcap fallback cannot assume
 207      * it has anywhere to spool out these entries!
 208      *
 209      * The _nc_set_type() call here requires a compensating one in
 210      * _nc_parse_entry().
 211      *
 212      * If you define HAVE_BIG_CORE, you'll disable this kluge.  This will
 213      * make tic a bit faster (because the resolution code won't have to do
 214      * disk I/O nearly as often).
 215      */
 216     if (ep->nuses == 0) {
 217         int oldline = _nc_curr_line;
 218
 219         write_it(ep);
 220         _nc_curr_line = oldline;
 221         free(ep->tterm.str_table);
 222         return (TRUE);
 223     }
 224 #endif /* HAVE_BIG_CORE */
 225     return (FALSE);
 226 }
 227
 228 static void
 229 put_translate(int c)
 230 /* emit a comment char, translating terminfo names to termcap names */
 231 {
 232     static bool in_name = FALSE;
 233     static size_t have, used;
 234     static char *namebuf, *suffix;
 235
 236     if (in_name) {
 237         if (used + 1 >= have) {
 238             have += 132;
 239             namebuf = typeRealloc(char, have, namebuf);
 240             suffix = typeRealloc(char, have, suffix);
 241         }
 242         if (c == '\n' || c == '@') {
 243             namebuf[used++] = '\0';
 244             (void) putchar('<');
 245             (void) fputs(namebuf, stdout);
 246             putchar(c);
 247             in_name = FALSE;
 248         } else if (c != '>') {
 249             namebuf[used++] = c;
 250         } else {                /* ah! candidate name! */
 251             char *up;
 252             NCURSES_CONST char *tp;
 253
 254             namebuf[used++] = '\0';
 255             in_name = FALSE;
 256
 257             suffix[0] = '\0';
 258             if ((up = strchr(namebuf, '#')) != 0
 259                 || (up = strchr(namebuf, '=')) != 0
 260                 || ((up = strchr(namebuf, '@')) != 0 && up[1] == '>')) {
 261                 (void) strcpy(suffix, up);
 262                 *up = '\0';
 263             }
 264
 265             if ((tp = nametrans(namebuf)) != 0) {
 266                 (void) putchar(':');
 267                 (void) fputs(tp, stdout);
 268                 (void) fputs(suffix, stdout);
 269                 (void) putchar(':');
 270             } else {
 271                 /* couldn't find a translation, just dump the name */
 272                 (void) putchar('<');
 273                 (void) fputs(namebuf, stdout);
 274                 (void) fputs(suffix, stdout);
 275                 (void) putchar('>');
 276             }
 277         }
 278     } else {
 279         used = 0;
 280         if (c == '<') {
 281             in_name = TRUE;
 282         } else {
 283             putchar(c);
 284         }
 285     }
 286 }
 287
 288 /* Returns a string, stripped of leading/trailing whitespace */
 289 static char *
 290 stripped(char *src)
 291 {
 292     while (isspace(*src))
 293         src++;
 294     if (*src != '\0') {
 295         char *dst = strcpy(malloc(strlen(src) + 1), src);
 296         size_t len = strlen(dst);
 297         while (--len != 0 && isspace(dst[len]))
 298             dst[len] = '\0';
 299         return dst;
 300     }
 301     return 0;
 302 }
 303
 304 /* Parse the "-e" option-value into a list of names */
 305 static const char **
 306 make_namelist(char *src)
 307 {
 308     const char **dst = 0;
 309
 310     char *s, *base;
 311     unsigned pass, n, nn;
 312     char buffer[BUFSIZ];
 313
 314     if (src == 0) {
 315         /* EMPTY */ ;
 316     } else if (strchr(src, '/') != 0) {         /* a filename */
 317         FILE *fp = fopen(src, "r");
 318         if (fp == 0)
 319             failed(src);
 320
 321         for (pass = 1; pass <= 2; pass++) {
 322             nn = 0;
 323             while (fgets(buffer, sizeof(buffer), fp) != 0) {
 324                 if ((s = stripped(buffer)) != 0) {
 325                     if (dst != 0)
 326                         dst[nn] = s;
 327                     nn++;
 328                 }
 329             }
 330             if (pass == 1) {
 331                 dst = typeCalloc(const char *, nn + 1);
 332                 rewind(fp);
 333             }
 334         }
 335         fclose(fp);
 336     } else {                    /* literal list of names */
 337         for (pass = 1; pass <= 2; pass++) {
 338             for (n = nn = 0, base = src;; n++) {
 339                 int mark = src[n];
 340                 if (mark == ',' || mark == '\0') {
 341                     if (pass == 1) {
 342                         nn++;
 343                     } else {
 344                         src[n] = '\0';
 345                         if ((s = stripped(base)) != 0)
 346                             dst[nn++] = s;
 347                         base = &src[n + 1];
 348                     }
 349                 }
 350                 if (mark == '\0')
 351                     break;
 352             }
 353             if (pass == 1)
 354                 dst = typeCalloc(const char *, nn + 1);
 355         }
 356     }
 357     if (showsummary) {
 358         fprintf(log_fp, "Entries that will be compiled:\n");
 359         for (n = 0; dst[n] != 0; n++)
 360             fprintf(log_fp, "%d:%s\n", n + 1, dst[n]);
 361     }
 362     return dst;
 363 }
 364
 365 static bool
 366 matches(const char **needle, const char *haystack)
 367 /* does entry in needle list match |-separated field in haystack? */
 368 {
 369     bool code = FALSE;
 370     size_t n;
 371
 372     if (needle != 0) {
 373         for (n = 0; needle[n] != 0; n++) {
 374             if (_nc_name_match(haystack, needle[n], "|")) {
 375                 code = TRUE;
 376                 break;
 377             }
 378         }
 379     } else
 380         code = TRUE;
 381     return (code);
 382 }
 383
 384 static FILE *
 385 open_tempfile(char *name)
 386 {
 387     FILE *result = 0;
 388 #if HAVE_MKSTEMP
 389     int fd = mkstemp(name);
 390     if (fd >= 0)
 391         result = fdopen(fd, "w");
 392 #else
 393     if (tmpnam(name) != 0)
 394         result = fopen(name, "w");
 395 #endif
 396     return result;
 397 }
 398
 399 int
 400 main(int argc, char *argv[])
 401 {
 402     char my_tmpname[PATH_MAX];
 403     int v_opt = -1, debug_level;
 404     int smart_defaults = TRUE;
 405     char *termcap;
 406     ENTRY *qp;
 407
 408     int this_opt, last_opt = '?';
 409
 410     int outform = F_TERMINFO;   /* output format */
 411     int sortmode = S_TERMINFO;  /* sort_mode */
 412
 413     int width = 60;
 414     bool formatted = FALSE;     /* reformat complex strings? */
 415     int numbers = 0;            /* format "%'char'" to/from "%{number}" */
 416     bool infodump = FALSE;      /* running as captoinfo? */
 417     bool capdump = FALSE;       /* running as infotocap? */
 418     bool forceresolve = FALSE;  /* force resolution */
 419     bool limited = TRUE;
 420     char *tversion = (char *) NULL;
 421     const char *source_file = "terminfo";
 422     const char **namelst = 0;
 423     char *outdir = (char *) NULL;
 424     bool check_only = FALSE;
 425
 426     log_fp = stderr;
 427
 428     if ((_nc_progname = strrchr(argv[0], '/')) == NULL)
 429         _nc_progname = argv[0];
 430     else
 431         _nc_progname++;
 432
 433     if ((infodump = (strcmp(_nc_progname, "captoinfo") == 0)) != FALSE) {
 434         outform = F_TERMINFO;
 435         sortmode = S_TERMINFO;
 436     }
 437     if ((capdump = (strcmp(_nc_progname, "infotocap") == 0)) != FALSE) {
 438         outform = F_TERMCAP;
 439         sortmode = S_TERMCAP;
 440     }
 441 #if NCURSES_XNAMES
 442     use_extended_names(FALSE);
 443 #endif
 444
 445     /*
 446      * Processing arguments is a little complicated, since someone made a
 447      * design decision to allow the numeric values for -w, -v options to
 448      * be optional.
 449      */
 450     while ((this_opt = getopt(argc, argv,
 451                 "0123456789CILNR:TVace:fGgo:rsvwx")) != EOF) {
 452         if (isdigit(this_opt)) {
 453             switch (last_opt) {
 454             case 'v':
 455                 v_opt = (v_opt * 10) + (this_opt - '0');
 456                 break;
 457             case 'w':
 458                 width = (width * 10) + (this_opt - '0');
 459                 break;
 460             default:
 461                 if (this_opt != '1')
 462                     usage();
 463                 last_opt = this_opt;
 464                 width = 0;
 465             }
 466             continue;
 467         }
 468         switch (this_opt) {
 469         case 'C':
 470             capdump = TRUE;
 471             outform = F_TERMCAP;
 472             sortmode = S_TERMCAP;
 473             break;
 474         case 'I':
 475             infodump = TRUE;
 476             outform = F_TERMINFO;
 477             sortmode = S_TERMINFO;
 478             break;
 479         case 'L':
 480             infodump = TRUE;
 481             outform = F_VARIABLE;
 482             sortmode = S_VARIABLE;
 483             break;
 484         case 'N':
 485             smart_defaults = FALSE;
 486             break;
 487         case 'R':
 488             tversion = optarg;
 489             break;
 490         case 'T':
 491             limited = FALSE;
 492             break;
 493         case 'V':
 494             puts(NCURSES_VERSION);
 495             return EXIT_SUCCESS;
 496         case 'c':
 497             check_only = TRUE;
 498             break;
 499         case 'e':
 500             namelst = make_namelist(optarg);
 501             break;
 502         case 'f':
 503             formatted = TRUE;
 504             break;
 505         case 'G':
 506             numbers = 1;
 507             break;
 508         case 'g':
 509             numbers = -1;
 510             break;
 511         case 'o':
 512             outdir = optarg;
 513             break;
 514         case 'r':
 515             forceresolve = TRUE;
 516             break;
 517         case 's':
 518             showsummary = TRUE;
 519             break;
 520         case 'v':
 521             v_opt = 0;
 522             break;
 523         case 'w':
 524             width = 0;
 525             break;
 526 #if NCURSES_XNAMES
 527         case 'a':
 528             _nc_disable_period = TRUE;
 529             /* FALLTHRU */
 530         case 'x':
 531             use_extended_names(TRUE);
 532             break;
 533 #endif
 534         default:
 535             usage();
 536         }
 537         last_opt = this_opt;
 538     }
 539
 540     debug_level = (v_opt > 0) ? v_opt : (v_opt == 0);
 541     set_trace_level(debug_level);
 542
 543     if (_nc_tracing) {
 544         save_check_termtype = _nc_check_termtype;
 545         _nc_check_termtype = check_termtype;
 546     }
 547 #ifndef HAVE_BIG_CORE
 548     /*
 549      * Aaargh! immedhook seriously hoses us!
 550      *
 551      * One problem with immedhook is it means we can't do -e.  Problem
 552      * is that we can't guarantee that for each terminal listed, all the
 553      * terminals it depends on will have been kept in core for reference
 554      * resolution -- in fact it's certain the primitive types at the end
 555      * of reference chains *won't* be in core unless they were explicitly
 556      * in the select list themselves.
 557      */
 558     if (namelst && (!infodump && !capdump)) {
 559         (void) fprintf(stderr,
 560             "Sorry, -e can't be used without -I or -C\n");
 561         cleanup();
 562         return EXIT_FAILURE;
 563     }
 564 #endif /* HAVE_BIG_CORE */
 565
 566     if (optind < argc) {
 567         source_file = argv[optind++];
 568         if (optind < argc) {
 569             fprintf(stderr,
 570                 "%s: Too many file names.  Usage:\n\t%s %s",
 571                 _nc_progname,
 572                 _nc_progname,
 573                 usage_string);
 574             return EXIT_FAILURE;
 575         }
 576     } else {
 577         if (infodump == TRUE) {
 578             /* captoinfo's no-argument case */
 579             source_file = "/etc/termcap";
 580             if ((termcap = getenv("TERMCAP")) != 0
 581                 && (namelst = make_namelist(getenv("TERM"))) != 0) {
 582                 if (access(termcap, F_OK) == 0) {
 583                     /* file exists */
 584                     source_file = termcap;
 585                 } else if ((tmp_fp = open_tempfile(my_tmpname)) != 0) {
 586                     source_file = my_tmpname;
 587                     fprintf(tmp_fp, "%s\n", termcap);
 588                     fclose(tmp_fp);
 589                     tmp_fp = fopen(source_file, "r");
 590                     to_remove = source_file;
 591                 } else {
 592                     failed("tmpnam");
 593                 }
 594             }
 595         } else {
 596             /* tic */
 597             fprintf(stderr,
 598                 "%s: File name needed.  Usage:\n\t%s %s",
 599                 _nc_progname,
 600                 _nc_progname,
 601                 usage_string);
 602             cleanup();
 603             return EXIT_FAILURE;
 604         }
 605     }
 606
 607     if (tmp_fp == 0
 608         && (tmp_fp = fopen(source_file, "r")) == 0) {
 609         fprintf(stderr, "%s: Can't open %s\n", _nc_progname, source_file);
 610         return EXIT_FAILURE;
 611     }
 612
 613     if (infodump)
 614         dump_init(tversion,
 615             smart_defaults
 616             ? outform
 617             : F_LITERAL,
 618             sortmode, width, debug_level, formatted);
 619     else if (capdump)
 620         dump_init(tversion,
 621             outform,
 622             sortmode, width, debug_level, FALSE);
 623
 624     /* parse entries out of the source file */
 625     _nc_set_source(source_file);
 626 #ifndef HAVE_BIG_CORE
 627     if (!(check_only || infodump || capdump))
 628         _nc_set_writedir(outdir);
 629 #endif /* HAVE_BIG_CORE */
 630     _nc_read_entry_source(tmp_fp, (char *) NULL,
 631         !smart_defaults, FALSE,
 632         (check_only || infodump || capdump) ? NULLHOOK : immedhook);
 633
 634     /* do use resolution */
 635     if (check_only || (!infodump && !capdump) || forceresolve) {
 636         if (!_nc_resolve_uses(TRUE) && !check_only) {
 637             cleanup();
 638             return EXIT_FAILURE;
 639         }
 640     }
 641
 642     /* length check */
 643     if (check_only && (capdump || infodump)) {
 644         for_entry_list(qp) {
 645             if (matches(namelst, qp->tterm.term_names)) {
 646                 int len = fmt_entry(&qp->tterm, NULL, TRUE, infodump, numbers);
 647
 648                 if (len > (infodump ? MAX_TERMINFO_LENGTH : MAX_TERMCAP_LENGTH))
 649                     (void) fprintf(stderr,
 650                         "warning: resolved %s entry is %d bytes long\n",
 651                         _nc_first_name(qp->tterm.term_names),
 652                         len);
 653             }
 654         }
 655     }
 656
 657     /* write or dump all entries */
 658     if (!check_only) {
 659         if (!infodump && !capdump) {
 660             _nc_set_writedir(outdir);
 661             for_entry_list(qp) {
 662                 if (matches(namelst, qp->tterm.term_names))
 663                     write_it(qp);
 664             }
 665         } else {
 666             /* this is in case infotocap() generates warnings */
 667             _nc_curr_col = _nc_curr_line = -1;
 668
 669             for_entry_list(qp) {
 670                 if (matches(namelst, qp->tterm.term_names)) {
 671                     int j = qp->cend - qp->cstart;
 672                     int len = 0;
 673
 674                     /* this is in case infotocap() generates warnings */
 675                     _nc_set_type(_nc_first_name(qp->tterm.term_names));
 676
 677                     (void) fseek(tmp_fp, qp->cstart, SEEK_SET);
 678                     while (j--) {
 679                         if (infodump)
 680                             (void) putchar(fgetc(tmp_fp));
 681                         else
 682                             put_translate(fgetc(tmp_fp));
 683                     }
 684
 685                     len = dump_entry(&qp->tterm, limited, numbers, NULL);
 686                     for (j = 0; j < qp->nuses; j++)
 687                         len += dump_uses(qp->uses[j].name, !capdump);
 688                     (void) putchar('\n');
 689                     if (debug_level != 0 && !limited)
 690                         printf("# length=%d\n", len);
 691                 }
 692             }
 693             if (!namelst) {
 694                 int c, oldc = '\0';
 695                 bool in_comment = FALSE;
 696                 bool trailing_comment = FALSE;
 697
 698                 (void) fseek(tmp_fp, _nc_tail->cend, SEEK_SET);
 699                 while ((c = fgetc(tmp_fp)) != EOF) {
 700                     if (oldc == '\n') {
 701                         if (c == '#') {
 702                             trailing_comment = TRUE;
 703                             in_comment = TRUE;
 704                         } else {
 705                             in_comment = FALSE;
 706                         }
 707                     }
 708                     if (trailing_comment
 709                         && (in_comment || (oldc == '\n' && c == '\n')))
 710                         putchar(c);
 711                     oldc = c;
 712                 }
 713             }
 714         }
 715     }
 716
 717     /* Show the directory into which entries were written, and the total
 718      * number of entries
 719      */
 720     if (showsummary
 721         && (!(check_only || infodump || capdump))) {
 722         int total = _nc_tic_written();
 723         if (total != 0)
 724             fprintf(log_fp, "%d entries written to %s\n",
 725                 total,
 726                 _nc_tic_dir((char *) 0));
 727         else
 728             fprintf(log_fp, "No entries written\n");
 729     }
 730     cleanup();
 731     return (EXIT_SUCCESS);
 732 }
 733
 734 /*
 735  * This bit of legerdemain turns all the terminfo variable names into
 736  * references to locations in the arrays Booleans, Numbers, and Strings ---
 737  * precisely what's needed (see comp_parse.c).
 738  */
 739
 740 TERMINAL *cur_term;             /* tweak to avoid linking lib_cur_term.c */
 741
 742 #undef CUR
 743 #define CUR tp->
 744
 745 /*
 746  * An sgr string may contain several settings other than the one we're
 747  * interested in, essentially sgr0 + rmacs + whatever.  As long as the
 748  * "whatever" is contained in the sgr string, that is close enough for our
 749  * sanity check.
 750  */
 751 static bool
 752 similar_sgr(char *a, char *b)
 753 {
 754     while (*b != 0) {
 755         while (*a != *b) {
 756             if (*a == 0)
 757                 return FALSE;
 758             a++;
 759         }
 760         a++;
 761         b++;
 762     }
 763     return TRUE;
 764 }
 765
 766 static void
 767 check_sgr(TERMTYPE * tp, char *zero, int num, char *cap, const char *name)
 768 {
 769     char *test = tparm(set_attributes,
 770         num == 1,
 771         num == 2,
 772         num == 3,
 773         num == 4,
 774         num == 5,
 775         num == 6,
 776         num == 7,
 777         num == 8,
 778         num == 9);
 779     if (test != 0) {
 780         if (PRESENT(cap)) {
 781             if (!similar_sgr(test, cap)) {
 782                 _nc_warning("%s differs from sgr(%d): %s", name, num,
 783                     _nc_visbuf(test));
 784             }
 785         } else if (strcmp(test, zero)) {
 786             _nc_warning("sgr(%d) present, but not %s", num, name);
 787         }
 788     } else if (PRESENT(cap)) {
 789         _nc_warning("sgr(%d) missing, but %s present", num, name);
 790     }
 791 }
 792
 793 #define CHECK_SGR(num,name) check_sgr(tp, zero, num, name, #name)
 794
 795 /* other sanity-checks (things that we don't want in the normal
 796  * logic that reads a terminfo entry)
 797  */
 798 static void
 799 check_termtype(TERMTYPE * tp)
 800 {
 801     bool conflict = FALSE;
 802     unsigned j, k;
 803     char fkeys[STRCOUNT];
 804
 805     /*
 806      * A terminal entry may contain more than one keycode assigned to
 807      * a given string (e.g., KEY_END and KEY_LL).  But curses will only
 808      * return one (the last one assigned).
 809      */
 810     memset(fkeys, 0, sizeof(fkeys));
 811     for (j = 0; _nc_tinfo_fkeys[j].code; j++) {
 812         char *a = tp->Strings[_nc_tinfo_fkeys[j].offset];
 813         bool first = TRUE;
 814         if (!VALID_STRING(a))
 815             continue;
 816         for (k = j + 1; _nc_tinfo_fkeys[k].code; k++) {
 817             char *b = tp->Strings[_nc_tinfo_fkeys[k].offset];
 818             if (!VALID_STRING(b)
 819                 || fkeys[k])
 820                 continue;
 821             if (!strcmp(a, b)) {
 822                 fkeys[j] = 1;
 823                 fkeys[k] = 1;
 824                 if (first) {
 825                     if (!conflict) {
 826                         _nc_warning("Conflicting key definitions (using the last)");
 827                         conflict = TRUE;
 828                     }
 829                     fprintf(stderr, "... %s is the same as %s",
 830                         keyname(_nc_tinfo_fkeys[j].code),
 831                         keyname(_nc_tinfo_fkeys[k].code));
 832                     first = FALSE;
 833                 } else {
 834                     fprintf(stderr, ", %s",
 835                         keyname(_nc_tinfo_fkeys[k].code));
 836                 }
 837             }
 838         }
 839         if (!first)
 840             fprintf(stderr, "\n");
 841     }
 842
 843     /*
 844      * Quick check for color.  We could also check if the ANSI versus
 845      * non-ANSI strings are misused.
 846      */
 847     if ((max_colors > 0) != (max_pairs > 0)
 848         || (max_colors > max_pairs))
 849         _nc_warning("inconsistent values for max_colors and max_pairs");
 850
 851     PAIRED(set_foreground, set_background);
 852     PAIRED(set_a_foreground, set_a_background);
 853
 854     /*
 855      * These may be mismatched because the terminal description relies on
 856      * restoring the cursor visibility by resetting it.
 857      */
 858     ANDMISSING(cursor_invisible, cursor_normal);
 859     ANDMISSING(cursor_visible, cursor_normal);
 860
 861     if (PRESENT(cursor_visible) && PRESENT(cursor_normal)
 862         && !strcmp(cursor_visible, cursor_normal))
 863         _nc_warning("cursor_visible is same as cursor_normal");
 864
 865     /*
 866      * From XSI & O'Reilly, we gather that sc/rc are required if csr is
 867      * given, because the cursor position after the scrolling operation is
 868      * performed is undefined.
 869      */
 870     ANDMISSING(change_scroll_region, save_cursor);
 871     ANDMISSING(change_scroll_region, restore_cursor);
 872
 873     if (PRESENT(set_attributes)) {
 874         char *zero = tparm(set_attributes, 0, 0, 0, 0, 0, 0, 0, 0, 0);
 875
 876         zero = strdup(zero);
 877         CHECK_SGR(1, enter_standout_mode);
 878         CHECK_SGR(2, enter_underline_mode);
 879         CHECK_SGR(3, enter_reverse_mode);
 880         CHECK_SGR(4, enter_blink_mode);
 881         CHECK_SGR(5, enter_dim_mode);
 882         CHECK_SGR(6, enter_bold_mode);
 883         CHECK_SGR(7, enter_secure_mode);
 884         CHECK_SGR(8, enter_protected_mode);
 885         CHECK_SGR(9, enter_alt_charset_mode);
 886         free(zero);
 887     }
 888
 889     /*
 890      * Some standard applications (e.g., vi) and some non-curses
 891      * applications (e.g., jove) get confused if we have both ich/ich1 and
 892      * smir/rmir.  Let's be nice and warn about that, too, even though
 893      * ncurses handles it.
 894      */
 895     if ((PRESENT(enter_insert_mode) || PRESENT(exit_insert_mode))
 896         && (PRESENT(insert_character) || PRESENT(parm_ich))) {
 897         _nc_warning("non-curses applications may be confused by ich/ich1 with smir/rmir");
 898     }
 899
 900     /*
 901      * Finally, do the non-verbose checks
 902      */
 903     if (save_check_termtype != 0)
 904         save_check_termtype(tp);
 905 }