1b03f380725e589a181cb623a20daaa96f9f1424
[ncurses.git] / progs / tic.c
1 /****************************************************************************
2  * Copyright (c) 1998-2005,2006 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  *
39  */
40
41 #include <progs.priv.h>
42 #include <sys/stat.h>
43
44 #include <dump_entry.h>
45 #include <transform.h>
46
47 MODULE_ID("$Id: tic.c,v 1.131 2006/12/02 22:13:17 tom Exp $")
48
49 const char *_nc_progname = "tic";
50
51 static FILE *log_fp;
52 static FILE *tmp_fp;
53 static bool capdump = FALSE;    /* running as infotocap? */
54 static bool infodump = FALSE;   /* running as captoinfo? */
55 static bool showsummary = FALSE;
56 static const char *to_remove;
57
58 static void (*save_check_termtype) (TERMTYPE *, bool);
59 static void check_termtype(TERMTYPE *tt, bool);
60
61 static const char usage_string[] = "\
62 [-e names] \
63 [-o dir] \
64 [-R name] \
65 [-v[n]] \
66 [-V] \
67 [-w[n]] \
68 [-\
69 1\
70 a\
71 C\
72 c\
73 f\
74 G\
75 g\
76 I\
77 L\
78 N\
79 r\
80 s\
81 T\
82 t\
83 U\
84 x\
85 ] \
86 source-file\n";
87
88 static void
89 cleanup(void)
90 {
91     if (tmp_fp != 0)
92         fclose(tmp_fp);
93     if (to_remove != 0) {
94 #if HAVE_REMOVE
95         remove(to_remove);
96 #else
97         unlink(to_remove);
98 #endif
99     }
100 }
101
102 static void
103 failed(const char *msg)
104 {
105     perror(msg);
106     cleanup();
107     ExitProgram(EXIT_FAILURE);
108 }
109
110 static void
111 usage(void)
112 {
113     static const char *const tbl[] =
114     {
115         "Options:",
116         "  -1         format translation output one capability per line",
117 #if NCURSES_XNAMES
118         "  -a         retain commented-out capabilities (sets -x also)",
119 #endif
120         "  -C         translate entries to termcap source form",
121         "  -c         check only, validate input without compiling or translating",
122         "  -e<names>  translate/compile only entries named by comma-separated list",
123         "  -f         format complex strings for readability",
124         "  -G         format %{number} to %'char'",
125         "  -g         format %'char' to %{number}",
126         "  -I         translate entries to terminfo source form",
127         "  -L         translate entries to full terminfo source form",
128         "  -N         disable smart defaults for source translation",
129         "  -o<dir>    set output directory for compiled entry writes",
130         "  -R<name>   restrict translation to given terminfo/termcap version",
131         "  -r         force resolution of all use entries in source translation",
132         "  -s         print summary statistics",
133         "  -T         remove size-restrictions on compiled description",
134 #if NCURSES_XNAMES
135         "  -t         suppress commented-out capabilities",
136 #endif
137         "  -U         suppress post-processing of entries",
138         "  -V         print version",
139         "  -v[n]      set verbosity level",
140         "  -w[n]      set format width for translation output",
141 #if NCURSES_XNAMES
142         "  -x         treat unknown capabilities as user-defined",
143 #endif
144         "",
145         "Parameters:",
146         "  <file>     file to translate or compile"
147     };
148     size_t j;
149
150     fprintf(stderr, "Usage: %s %s\n", _nc_progname, usage_string);
151     for (j = 0; j < SIZEOF(tbl); j++) {
152         fputs(tbl[j], stderr);
153         putc('\n', stderr);
154     }
155     ExitProgram(EXIT_FAILURE);
156 }
157
158 #define L_BRACE '{'
159 #define R_BRACE '}'
160 #define S_QUOTE '\'';
161
162 static void
163 write_it(ENTRY * ep)
164 {
165     unsigned n;
166     int ch;
167     char *s, *d, *t;
168     char result[MAX_ENTRY_SIZE];
169
170     /*
171      * Look for strings that contain %{number}, convert them to %'char',
172      * which is shorter and runs a little faster.
173      */
174     for (n = 0; n < STRCOUNT; n++) {
175         s = ep->tterm.Strings[n];
176         if (VALID_STRING(s)
177             && strchr(s, L_BRACE) != 0) {
178             d = result;
179             t = s;
180             while ((ch = *t++) != 0) {
181                 *d++ = ch;
182                 if (ch == '\\') {
183                     *d++ = *t++;
184                 } else if ((ch == '%')
185                            && (*t == L_BRACE)) {
186                     char *v = 0;
187                     long value = strtol(t + 1, &v, 0);
188                     if (v != 0
189                         && *v == R_BRACE
190                         && value > 0
191                         && value != '\\'        /* FIXME */
192                         && value < 127
193                         && isprint((int) value)) {
194                         *d++ = S_QUOTE;
195                         *d++ = (int) value;
196                         *d++ = S_QUOTE;
197                         t = (v + 1);
198                     }
199                 }
200             }
201             *d = 0;
202             if (strlen(result) < strlen(s))
203                 strcpy(s, result);
204         }
205     }
206
207     _nc_set_type(_nc_first_name(ep->tterm.term_names));
208     _nc_curr_line = ep->startline;
209     _nc_write_entry(&ep->tterm);
210 }
211
212 static bool
213 immedhook(ENTRY * ep GCC_UNUSED)
214 /* write out entries with no use capabilities immediately to save storage */
215 {
216 #if !HAVE_BIG_CORE
217     /*
218      * This is strictly a core-economy kluge.  The really clean way to handle
219      * compilation is to slurp the whole file into core and then do all the
220      * name-collision checks and entry writes in one swell foop.  But the
221      * terminfo master file is large enough that some core-poor systems swap
222      * like crazy when you compile it this way...there have been reports of
223      * this process taking *three hours*, rather than the twenty seconds or
224      * less typical on my development box.
225      *
226      * So.  This hook *immediately* writes out the referenced entry if it
227      * has no use capabilities.  The compiler main loop refrains from
228      * adding the entry to the in-core list when this hook fires.  If some
229      * other entry later needs to reference an entry that got written
230      * immediately, that's OK; the resolution code will fetch it off disk
231      * when it can't find it in core.
232      *
233      * Name collisions will still be detected, just not as cleanly.  The
234      * write_entry() code complains before overwriting an entry that
235      * postdates the time of tic's first call to write_entry().  Thus
236      * it will complain about overwriting entries newly made during the
237      * tic run, but not about overwriting ones that predate it.
238      *
239      * The reason this is a hook, and not in line with the rest of the
240      * compiler code, is that the support for termcap fallback cannot assume
241      * it has anywhere to spool out these entries!
242      *
243      * The _nc_set_type() call here requires a compensating one in
244      * _nc_parse_entry().
245      *
246      * If you define HAVE_BIG_CORE, you'll disable this kluge.  This will
247      * make tic a bit faster (because the resolution code won't have to do
248      * disk I/O nearly as often).
249      */
250     if (ep->nuses == 0) {
251         int oldline = _nc_curr_line;
252
253         write_it(ep);
254         _nc_curr_line = oldline;
255         free(ep->tterm.str_table);
256         return (TRUE);
257     }
258 #endif /* HAVE_BIG_CORE */
259     return (FALSE);
260 }
261
262 static void
263 put_translate(int c)
264 /* emit a comment char, translating terminfo names to termcap names */
265 {
266     static bool in_name = FALSE;
267     static size_t have, used;
268     static char *namebuf, *suffix;
269
270     if (in_name) {
271         if (used + 1 >= have) {
272             have += 132;
273             namebuf = typeRealloc(char, have, namebuf);
274             suffix = typeRealloc(char, have, suffix);
275         }
276         if (c == '\n' || c == '@') {
277             namebuf[used++] = '\0';
278             (void) putchar('<');
279             (void) fputs(namebuf, stdout);
280             putchar(c);
281             in_name = FALSE;
282         } else if (c != '>') {
283             namebuf[used++] = c;
284         } else {                /* ah! candidate name! */
285             char *up;
286             NCURSES_CONST char *tp;
287
288             namebuf[used++] = '\0';
289             in_name = FALSE;
290
291             suffix[0] = '\0';
292             if ((up = strchr(namebuf, '#')) != 0
293                 || (up = strchr(namebuf, '=')) != 0
294                 || ((up = strchr(namebuf, '@')) != 0 && up[1] == '>')) {
295                 (void) strcpy(suffix, up);
296                 *up = '\0';
297             }
298
299             if ((tp = nametrans(namebuf)) != 0) {
300                 (void) putchar(':');
301                 (void) fputs(tp, stdout);
302                 (void) fputs(suffix, stdout);
303                 (void) putchar(':');
304             } else {
305                 /* couldn't find a translation, just dump the name */
306                 (void) putchar('<');
307                 (void) fputs(namebuf, stdout);
308                 (void) fputs(suffix, stdout);
309                 (void) putchar('>');
310             }
311         }
312     } else {
313         used = 0;
314         if (c == '<') {
315             in_name = TRUE;
316         } else {
317             putchar(c);
318         }
319     }
320 }
321
322 /* Returns a string, stripped of leading/trailing whitespace */
323 static char *
324 stripped(char *src)
325 {
326     while (isspace(UChar(*src)))
327         src++;
328     if (*src != '\0') {
329         char *dst = strcpy((char *) malloc(strlen(src) + 1), src);
330         size_t len = strlen(dst);
331         while (--len != 0 && isspace(UChar(dst[len])))
332             dst[len] = '\0';
333         return dst;
334     }
335     return 0;
336 }
337
338 static FILE *
339 open_input(const char *filename)
340 {
341     FILE *fp = fopen(filename, "r");
342     struct stat sb;
343
344     if (fp == 0) {
345         fprintf(stderr, "%s: Can't open %s\n", _nc_progname, filename);
346         ExitProgram(EXIT_FAILURE);
347     }
348     if (fstat(fileno(fp), &sb) < 0
349         || (sb.st_mode & S_IFMT) != S_IFREG) {
350         fprintf(stderr, "%s: %s is not a file\n", _nc_progname, filename);
351         ExitProgram(EXIT_FAILURE);
352     }
353     return fp;
354 }
355
356 /* Parse the "-e" option-value into a list of names */
357 static const char **
358 make_namelist(char *src)
359 {
360     const char **dst = 0;
361
362     char *s, *base;
363     unsigned pass, n, nn;
364     char buffer[BUFSIZ];
365
366     if (src == 0) {
367         /* EMPTY */ ;
368     } else if (strchr(src, '/') != 0) {         /* a filename */
369         FILE *fp = open_input(src);
370
371         for (pass = 1; pass <= 2; pass++) {
372             nn = 0;
373             while (fgets(buffer, sizeof(buffer), fp) != 0) {
374                 if ((s = stripped(buffer)) != 0) {
375                     if (dst != 0)
376                         dst[nn] = s;
377                     nn++;
378                 }
379             }
380             if (pass == 1) {
381                 dst = typeCalloc(const char *, nn + 1);
382                 rewind(fp);
383             }
384         }
385         fclose(fp);
386     } else {                    /* literal list of names */
387         for (pass = 1; pass <= 2; pass++) {
388             for (n = nn = 0, base = src;; n++) {
389                 int mark = src[n];
390                 if (mark == ',' || mark == '\0') {
391                     if (pass == 1) {
392                         nn++;
393                     } else {
394                         src[n] = '\0';
395                         if ((s = stripped(base)) != 0)
396                             dst[nn++] = s;
397                         base = &src[n + 1];
398                     }
399                 }
400                 if (mark == '\0')
401                     break;
402             }
403             if (pass == 1)
404                 dst = typeCalloc(const char *, nn + 1);
405         }
406     }
407     if (showsummary) {
408         fprintf(log_fp, "Entries that will be compiled:\n");
409         for (n = 0; dst[n] != 0; n++)
410             fprintf(log_fp, "%u:%s\n", n + 1, dst[n]);
411     }
412     return dst;
413 }
414
415 static bool
416 matches(const char **needle, const char *haystack)
417 /* does entry in needle list match |-separated field in haystack? */
418 {
419     bool code = FALSE;
420     size_t n;
421
422     if (needle != 0) {
423         for (n = 0; needle[n] != 0; n++) {
424             if (_nc_name_match(haystack, needle[n], "|")) {
425                 code = TRUE;
426                 break;
427             }
428         }
429     } else
430         code = TRUE;
431     return (code);
432 }
433
434 static FILE *
435 open_tempfile(char *name)
436 {
437     FILE *result = 0;
438 #if HAVE_MKSTEMP
439     int fd = mkstemp(name);
440     if (fd >= 0)
441         result = fdopen(fd, "w");
442 #else
443     if (tmpnam(name) != 0)
444         result = fopen(name, "w");
445 #endif
446     return result;
447 }
448
449 int
450 main(int argc, char *argv[])
451 {
452     char my_tmpname[PATH_MAX];
453     int v_opt = -1, debug_level;
454     int smart_defaults = TRUE;
455     char *termcap;
456     ENTRY *qp;
457
458     int this_opt, last_opt = '?';
459
460     int outform = F_TERMINFO;   /* output format */
461     int sortmode = S_TERMINFO;  /* sort_mode */
462
463     int width = 60;
464     bool formatted = FALSE;     /* reformat complex strings? */
465     bool literal = FALSE;       /* suppress post-processing? */
466     int numbers = 0;            /* format "%'char'" to/from "%{number}" */
467     bool forceresolve = FALSE;  /* force resolution */
468     bool limited = TRUE;
469     char *tversion = (char *) NULL;
470     const char *source_file = "terminfo";
471     const char **namelst = 0;
472     char *outdir = (char *) NULL;
473     bool check_only = FALSE;
474     bool suppress_untranslatable = FALSE;
475
476     log_fp = stderr;
477
478     _nc_progname = _nc_rootname(argv[0]);
479
480     if ((infodump = (strcmp(_nc_progname, PROG_CAPTOINFO) == 0)) != FALSE) {
481         outform = F_TERMINFO;
482         sortmode = S_TERMINFO;
483     }
484     if ((capdump = (strcmp(_nc_progname, PROG_INFOTOCAP) == 0)) != FALSE) {
485         outform = F_TERMCAP;
486         sortmode = S_TERMCAP;
487     }
488 #if NCURSES_XNAMES
489     use_extended_names(FALSE);
490 #endif
491
492     /*
493      * Processing arguments is a little complicated, since someone made a
494      * design decision to allow the numeric values for -w, -v options to
495      * be optional.
496      */
497     while ((this_opt = getopt(argc, argv,
498                               "0123456789CILNR:TUVace:fGgo:rstvwx")) != EOF) {
499         if (isdigit(this_opt)) {
500             switch (last_opt) {
501             case 'v':
502                 v_opt = (v_opt * 10) + (this_opt - '0');
503                 break;
504             case 'w':
505                 width = (width * 10) + (this_opt - '0');
506                 break;
507             default:
508                 if (this_opt != '1')
509                     usage();
510                 last_opt = this_opt;
511                 width = 0;
512             }
513             continue;
514         }
515         switch (this_opt) {
516         case 'C':
517             capdump = TRUE;
518             outform = F_TERMCAP;
519             sortmode = S_TERMCAP;
520             break;
521         case 'I':
522             infodump = TRUE;
523             outform = F_TERMINFO;
524             sortmode = S_TERMINFO;
525             break;
526         case 'L':
527             infodump = TRUE;
528             outform = F_VARIABLE;
529             sortmode = S_VARIABLE;
530             break;
531         case 'N':
532             smart_defaults = FALSE;
533             literal = TRUE;
534             break;
535         case 'R':
536             tversion = optarg;
537             break;
538         case 'T':
539             limited = FALSE;
540             break;
541         case 'U':
542             literal = TRUE;
543             break;
544         case 'V':
545             puts(curses_version());
546             return EXIT_SUCCESS;
547         case 'c':
548             check_only = TRUE;
549             break;
550         case 'e':
551             namelst = make_namelist(optarg);
552             break;
553         case 'f':
554             formatted = TRUE;
555             break;
556         case 'G':
557             numbers = 1;
558             break;
559         case 'g':
560             numbers = -1;
561             break;
562         case 'o':
563             outdir = optarg;
564             break;
565         case 'r':
566             forceresolve = TRUE;
567             break;
568         case 's':
569             showsummary = TRUE;
570             break;
571         case 'v':
572             v_opt = 0;
573             break;
574         case 'w':
575             width = 0;
576             break;
577 #if NCURSES_XNAMES
578         case 't':
579             _nc_disable_period = FALSE;
580             suppress_untranslatable = TRUE;
581             break;
582         case 'a':
583             _nc_disable_period = TRUE;
584             /* FALLTHRU */
585         case 'x':
586             use_extended_names(TRUE);
587             break;
588 #endif
589         default:
590             usage();
591         }
592         last_opt = this_opt;
593     }
594
595     debug_level = (v_opt > 0) ? v_opt : (v_opt == 0);
596     set_trace_level(debug_level);
597
598     if (_nc_tracing) {
599         save_check_termtype = _nc_check_termtype2;
600         _nc_check_termtype2 = check_termtype;
601     }
602 #if !HAVE_BIG_CORE
603     /*
604      * Aaargh! immedhook seriously hoses us!
605      *
606      * One problem with immedhook is it means we can't do -e.  Problem
607      * is that we can't guarantee that for each terminal listed, all the
608      * terminals it depends on will have been kept in core for reference
609      * resolution -- in fact it's certain the primitive types at the end
610      * of reference chains *won't* be in core unless they were explicitly
611      * in the select list themselves.
612      */
613     if (namelst && (!infodump && !capdump)) {
614         (void) fprintf(stderr,
615                        "Sorry, -e can't be used without -I or -C\n");
616         cleanup();
617         ExitProgram(EXIT_FAILURE);
618     }
619 #endif /* HAVE_BIG_CORE */
620
621     if (optind < argc) {
622         source_file = argv[optind++];
623         if (optind < argc) {
624             fprintf(stderr,
625                     "%s: Too many file names.  Usage:\n\t%s %s",
626                     _nc_progname,
627                     _nc_progname,
628                     usage_string);
629             ExitProgram(EXIT_FAILURE);
630         }
631     } else {
632         if (infodump == TRUE) {
633             /* captoinfo's no-argument case */
634             source_file = "/etc/termcap";
635             if ((termcap = getenv("TERMCAP")) != 0
636                 && (namelst = make_namelist(getenv("TERM"))) != 0) {
637                 if (access(termcap, F_OK) == 0) {
638                     /* file exists */
639                     source_file = termcap;
640                 } else if ((tmp_fp = open_tempfile(strcpy(my_tmpname,
641                                                           "/tmp/XXXXXX")))
642                            != 0) {
643                     source_file = my_tmpname;
644                     fprintf(tmp_fp, "%s\n", termcap);
645                     fclose(tmp_fp);
646                     tmp_fp = open_input(source_file);
647                     to_remove = source_file;
648                 } else {
649                     failed("tmpnam");
650                 }
651             }
652         } else {
653             /* tic */
654             fprintf(stderr,
655                     "%s: File name needed.  Usage:\n\t%s %s",
656                     _nc_progname,
657                     _nc_progname,
658                     usage_string);
659             cleanup();
660             ExitProgram(EXIT_FAILURE);
661         }
662     }
663
664     if (tmp_fp == 0)
665         tmp_fp = open_input(source_file);
666
667     if (infodump)
668         dump_init(tversion,
669                   smart_defaults
670                   ? outform
671                   : F_LITERAL,
672                   sortmode, width, debug_level, formatted);
673     else if (capdump)
674         dump_init(tversion,
675                   outform,
676                   sortmode, width, debug_level, FALSE);
677
678     /* parse entries out of the source file */
679     _nc_set_source(source_file);
680 #if !HAVE_BIG_CORE
681     if (!(check_only || infodump || capdump))
682         _nc_set_writedir(outdir);
683 #endif /* HAVE_BIG_CORE */
684     _nc_read_entry_source(tmp_fp, (char *) NULL,
685                           !smart_defaults || literal, FALSE,
686                           ((check_only || infodump || capdump)
687                            ? NULLHOOK
688                            : immedhook));
689
690     /* do use resolution */
691     if (check_only || (!infodump && !capdump) || forceresolve) {
692         if (!_nc_resolve_uses2(TRUE, literal) && !check_only) {
693             cleanup();
694             ExitProgram(EXIT_FAILURE);
695         }
696     }
697
698     /* length check */
699     if (check_only && (capdump || infodump)) {
700         for_entry_list(qp) {
701             if (matches(namelst, qp->tterm.term_names)) {
702                 int len = fmt_entry(&qp->tterm, NULL, FALSE, TRUE, infodump, numbers);
703
704                 if (len > (infodump ? MAX_TERMINFO_LENGTH : MAX_TERMCAP_LENGTH))
705                     (void) fprintf(stderr,
706                                    "warning: resolved %s entry is %d bytes long\n",
707                                    _nc_first_name(qp->tterm.term_names),
708                                    len);
709             }
710         }
711     }
712
713     /* write or dump all entries */
714     if (!check_only) {
715         if (!infodump && !capdump) {
716             _nc_set_writedir(outdir);
717             for_entry_list(qp) {
718                 if (matches(namelst, qp->tterm.term_names))
719                     write_it(qp);
720             }
721         } else {
722             /* this is in case infotocap() generates warnings */
723             _nc_curr_col = _nc_curr_line = -1;
724
725             for_entry_list(qp) {
726                 if (matches(namelst, qp->tterm.term_names)) {
727                     int j = qp->cend - qp->cstart;
728                     int len = 0;
729
730                     /* this is in case infotocap() generates warnings */
731                     _nc_set_type(_nc_first_name(qp->tterm.term_names));
732
733                     (void) fseek(tmp_fp, qp->cstart, SEEK_SET);
734                     while (j-- > 0) {
735                         if (infodump)
736                             (void) putchar(fgetc(tmp_fp));
737                         else
738                             put_translate(fgetc(tmp_fp));
739                     }
740
741                     dump_entry(&qp->tterm, suppress_untranslatable,
742                                limited, numbers, NULL);
743                     for (j = 0; j < qp->nuses; j++)
744                         dump_uses(qp->uses[j].name, !capdump);
745                     len = show_entry();
746                     if (debug_level != 0 && !limited)
747                         printf("# length=%d\n", len);
748                 }
749             }
750             if (!namelst && _nc_tail) {
751                 int c, oldc = '\0';
752                 bool in_comment = FALSE;
753                 bool trailing_comment = FALSE;
754
755                 (void) fseek(tmp_fp, _nc_tail->cend, SEEK_SET);
756                 while ((c = fgetc(tmp_fp)) != EOF) {
757                     if (oldc == '\n') {
758                         if (c == '#') {
759                             trailing_comment = TRUE;
760                             in_comment = TRUE;
761                         } else {
762                             in_comment = FALSE;
763                         }
764                     }
765                     if (trailing_comment
766                         && (in_comment || (oldc == '\n' && c == '\n')))
767                         putchar(c);
768                     oldc = c;
769                 }
770             }
771         }
772     }
773
774     /* Show the directory into which entries were written, and the total
775      * number of entries
776      */
777     if (showsummary
778         && (!(check_only || infodump || capdump))) {
779         int total = _nc_tic_written();
780         if (total != 0)
781             fprintf(log_fp, "%d entries written to %s\n",
782                     total,
783                     _nc_tic_dir((char *) 0));
784         else
785             fprintf(log_fp, "No entries written\n");
786     }
787     cleanup();
788     ExitProgram(EXIT_SUCCESS);
789 }
790
791 /*
792  * This bit of legerdemain turns all the terminfo variable names into
793  * references to locations in the arrays Booleans, Numbers, and Strings ---
794  * precisely what's needed (see comp_parse.c).
795  */
796 #undef CUR
797 #define CUR tp->
798
799 /*
800  * Check if the alternate character-set capabilities are consistent.
801  */
802 static void
803 check_acs(TERMTYPE *tp)
804 {
805     if (VALID_STRING(acs_chars)) {
806         const char *boxes = "lmkjtuvwqxn";
807         char mapped[256];
808         char missing[256];
809         const char *p;
810         char *q;
811
812         memset(mapped, 0, sizeof(mapped));
813         for (p = acs_chars; *p != '\0'; p += 2) {
814             if (p[1] == '\0') {
815                 _nc_warning("acsc has odd number of characters");
816                 break;
817             }
818             mapped[UChar(p[0])] = p[1];
819         }
820         if (mapped[UChar('I')] && !mapped[UChar('i')]) {
821             _nc_warning("acsc refers to 'I', which is probably an error");
822         }
823         for (p = boxes, q = missing; *p != '\0'; ++p) {
824             if (!mapped[UChar(p[0])]) {
825                 *q++ = p[0];
826             }
827             *q = '\0';
828         }
829         if (*missing != '\0' && strcmp(missing, boxes)) {
830             _nc_warning("acsc is missing some line-drawing mapping: %s", missing);
831         }
832     }
833 }
834
835 /*
836  * Check if the color capabilities are consistent
837  */
838 static void
839 check_colors(TERMTYPE *tp)
840 {
841     if ((max_colors > 0) != (max_pairs > 0)
842         || ((max_colors > max_pairs) && (initialize_pair == 0)))
843         _nc_warning("inconsistent values for max_colors (%d) and max_pairs (%d)",
844                     max_colors, max_pairs);
845
846     PAIRED(set_foreground, set_background);
847     PAIRED(set_a_foreground, set_a_background);
848     PAIRED(set_color_pair, initialize_pair);
849
850     if (VALID_STRING(set_foreground)
851         && VALID_STRING(set_a_foreground)
852         && !_nc_capcmp(set_foreground, set_a_foreground))
853         _nc_warning("expected setf/setaf to be different");
854
855     if (VALID_STRING(set_background)
856         && VALID_STRING(set_a_background)
857         && !_nc_capcmp(set_background, set_a_background))
858         _nc_warning("expected setb/setab to be different");
859
860     /* see: has_colors() */
861     if (VALID_NUMERIC(max_colors) && VALID_NUMERIC(max_pairs)
862         && (((set_foreground != NULL)
863              && (set_background != NULL))
864             || ((set_a_foreground != NULL)
865                 && (set_a_background != NULL))
866             || set_color_pair)) {
867         if (!VALID_STRING(orig_pair) && !VALID_STRING(orig_colors))
868             _nc_warning("expected either op/oc string for resetting colors");
869     }
870 }
871
872 static int
873 keypad_final(const char *string)
874 {
875     int result = '\0';
876
877     if (VALID_STRING(string)
878         && *string++ == '\033'
879         && *string++ == 'O'
880         && strlen(string) == 1) {
881         result = *string;
882     }
883
884     return result;
885 }
886
887 static int
888 keypad_index(const char *string)
889 {
890     char *test;
891     const char *list = "PQRSwxymtuvlqrsPpn";    /* app-keypad except "Enter" */
892     int ch;
893     int result = -1;
894
895     if ((ch = keypad_final(string)) != '\0') {
896         test = strchr(list, ch);
897         if (test != 0)
898             result = (test - list);
899     }
900     return result;
901 }
902
903 /*
904  * Do a quick sanity-check for vt100-style keypads to see if the 5-key keypad
905  * is mapped inconsistently.
906  */
907 static void
908 check_keypad(TERMTYPE *tp)
909 {
910     char show[80];
911
912     if (VALID_STRING(key_a1) &&
913         VALID_STRING(key_a3) &&
914         VALID_STRING(key_b2) &&
915         VALID_STRING(key_c1) &&
916         VALID_STRING(key_c3)) {
917         char final[6];
918         int list[5];
919         int increase = 0;
920         int j, k, kk;
921         int last;
922         int test;
923
924         final[0] = keypad_final(key_a1);
925         final[1] = keypad_final(key_a3);
926         final[2] = keypad_final(key_b2);
927         final[3] = keypad_final(key_c1);
928         final[4] = keypad_final(key_c3);
929         final[5] = '\0';
930
931         /* special case: legacy coding using 1,2,3,0,. on the bottom */
932         if (!strcmp(final, "qsrpn"))
933             return;
934
935         list[0] = keypad_index(key_a1);
936         list[1] = keypad_index(key_a3);
937         list[2] = keypad_index(key_b2);
938         list[3] = keypad_index(key_c1);
939         list[4] = keypad_index(key_c3);
940
941         /* check that they're all vt100 keys */
942         for (j = 0; j < 5; ++j) {
943             if (list[j] < 0) {
944                 return;
945             }
946         }
947
948         /* check if they're all in increasing order */
949         for (j = 1; j < 5; ++j) {
950             if (list[j] > list[j - 1]) {
951                 ++increase;
952             }
953         }
954         if (increase != 4) {
955             show[0] = '\0';
956
957             for (j = 0, last = -1; j < 5; ++j) {
958                 for (k = 0, kk = -1, test = 100; k < 5; ++k) {
959                     if (list[k] > last &&
960                         list[k] < test) {
961                         test = list[k];
962                         kk = k;
963                     }
964                 }
965                 last = test;
966                 switch (kk) {
967                 case 0:
968                     strcat(show, " ka1");
969                     break;
970                 case 1:
971                     strcat(show, " ka3");
972                     break;
973                 case 2:
974                     strcat(show, " kb2");
975                     break;
976                 case 3:
977                     strcat(show, " kc1");
978                     break;
979                 case 4:
980                     strcat(show, " kc3");
981                     break;
982                 }
983             }
984
985             _nc_warning("vt100 keypad order inconsistent: %s", show);
986         }
987
988     } else if (VALID_STRING(key_a1) ||
989                VALID_STRING(key_a3) ||
990                VALID_STRING(key_b2) ||
991                VALID_STRING(key_c1) ||
992                VALID_STRING(key_c3)) {
993         show[0] = '\0';
994         if (keypad_index(key_a1) >= 0)
995             strcat(show, " ka1");
996         if (keypad_index(key_a3) >= 0)
997             strcat(show, " ka3");
998         if (keypad_index(key_b2) >= 0)
999             strcat(show, " kb2");
1000         if (keypad_index(key_c1) >= 0)
1001             strcat(show, " kc1");
1002         if (keypad_index(key_c3) >= 0)
1003             strcat(show, " kc3");
1004         if (*show != '\0')
1005             _nc_warning("vt100 keypad map incomplete:%s", show);
1006     }
1007 }
1008
1009 /*
1010  * Returns the expected number of parameters for the given capability.
1011  */
1012 static int
1013 expected_params(const char *name)
1014 {
1015     /* *INDENT-OFF* */
1016     static const struct {
1017         const char *name;
1018         int count;
1019     } table[] = {
1020         { "S0",                 1 },    /* 'screen' extension */
1021         { "birep",              2 },
1022         { "chr",                1 },
1023         { "colornm",            1 },
1024         { "cpi",                1 },
1025         { "csnm",               1 },
1026         { "csr",                2 },
1027         { "cub",                1 },
1028         { "cud",                1 },
1029         { "cuf",                1 },
1030         { "cup",                2 },
1031         { "cuu",                1 },
1032         { "cvr",                1 },
1033         { "cwin",               5 },
1034         { "dch",                1 },
1035         { "defc",               3 },
1036         { "dial",               1 },
1037         { "dispc",              1 },
1038         { "dl",                 1 },
1039         { "ech",                1 },
1040         { "getm",               1 },
1041         { "hpa",                1 },
1042         { "ich",                1 },
1043         { "il",                 1 },
1044         { "indn",               1 },
1045         { "initc",              4 },
1046         { "initp",              7 },
1047         { "lpi",                1 },
1048         { "mc5p",               1 },
1049         { "mrcup",              2 },
1050         { "mvpa",               1 },
1051         { "pfkey",              2 },
1052         { "pfloc",              2 },
1053         { "pfx",                2 },
1054         { "pfxl",               3 },
1055         { "pln",                2 },
1056         { "qdial",              1 },
1057         { "rcsd",               1 },
1058         { "rep",                2 },
1059         { "rin",                1 },
1060         { "sclk",               3 },
1061         { "scp",                1 },
1062         { "scs",                1 },
1063         { "scsd",               2 },
1064         { "setab",              1 },
1065         { "setaf",              1 },
1066         { "setb",               1 },
1067         { "setcolor",           1 },
1068         { "setf",               1 },
1069         { "sgr",                9 },
1070         { "sgr1",               6 },
1071         { "slength",            1 },
1072         { "slines",             1 },
1073         { "smgbp",              1 },    /* 2 if smgtp is not given */
1074         { "smglp",              1 },
1075         { "smglr",              2 },
1076         { "smgrp",              1 },
1077         { "smgtb",              2 },
1078         { "smgtp",              1 },
1079         { "tsl",                1 },
1080         { "u6",                 -1 },
1081         { "vpa",                1 },
1082         { "wind",               4 },
1083         { "wingo",              1 },
1084     };
1085     /* *INDENT-ON* */
1086
1087     unsigned n;
1088     int result = 0;             /* function-keys, etc., use none */
1089
1090     for (n = 0; n < SIZEOF(table); n++) {
1091         if (!strcmp(name, table[n].name)) {
1092             result = table[n].count;
1093             break;
1094         }
1095     }
1096
1097     return result;
1098 }
1099
1100 /*
1101  * Make a quick sanity check for the parameters which are used in the given
1102  * strings.  If there are no "%p" tokens, then there should be no other "%"
1103  * markers.
1104  */
1105 static void
1106 check_params(TERMTYPE *tp, const char *name, char *value)
1107 {
1108     int expected = expected_params(name);
1109     int actual = 0;
1110     int n;
1111     bool params[10];
1112     char *s = value;
1113
1114 #ifdef set_top_margin_parm
1115     if (!strcmp(name, "smgbp")
1116         && set_top_margin_parm == 0)
1117         expected = 2;
1118 #endif
1119
1120     for (n = 0; n < 10; n++)
1121         params[n] = FALSE;
1122
1123     while (*s != 0) {
1124         if (*s == '%') {
1125             if (*++s == '\0') {
1126                 _nc_warning("expected character after %% in %s", name);
1127                 break;
1128             } else if (*s == 'p') {
1129                 if (*++s == '\0' || !isdigit((int) *s)) {
1130                     _nc_warning("expected digit after %%p in %s", name);
1131                     return;
1132                 } else {
1133                     n = (*s - '0');
1134                     if (n > actual)
1135                         actual = n;
1136                     params[n] = TRUE;
1137                 }
1138             }
1139         }
1140         s++;
1141     }
1142
1143     if (params[0]) {
1144         _nc_warning("%s refers to parameter 0 (%%p0), which is not allowed", name);
1145     }
1146     if (value == set_attributes || expected < 0) {
1147         ;
1148     } else if (expected != actual) {
1149         _nc_warning("%s uses %d parameters, expected %d", name,
1150                     actual, expected);
1151         for (n = 1; n < actual; n++) {
1152             if (!params[n])
1153                 _nc_warning("%s omits parameter %d", name, n);
1154         }
1155     }
1156 }
1157
1158 static char *
1159 skip_delay(char *s)
1160 {
1161     while (*s == '/' || isdigit(UChar(*s)))
1162         ++s;
1163     return s;
1164 }
1165
1166 /*
1167  * Skip a delay altogether, e.g., when comparing a simple string to sgr,
1168  * the latter may have a worst-case delay on the end.
1169  */
1170 static char *
1171 ignore_delays(char *s)
1172 {
1173     int delaying = 0;
1174
1175     do {
1176         switch (*s) {
1177         case '$':
1178             if (delaying == 0)
1179                 delaying = 1;
1180             break;
1181         case '<':
1182             if (delaying == 1)
1183                 delaying = 2;
1184             break;
1185         case '\0':
1186             delaying = 0;
1187             break;
1188         default:
1189             if (delaying) {
1190                 s = skip_delay(s);
1191                 if (*s == '>')
1192                     ++s;
1193                 delaying = 0;
1194             }
1195             break;
1196         }
1197         if (delaying)
1198             ++s;
1199     } while (delaying);
1200     return s;
1201 }
1202
1203 /*
1204  * An sgr string may contain several settings other than the one we're
1205  * interested in, essentially sgr0 + rmacs + whatever.  As long as the
1206  * "whatever" is contained in the sgr string, that is close enough for our
1207  * sanity check.
1208  */
1209 static bool
1210 similar_sgr(int num, char *a, char *b)
1211 {
1212     static const char *names[] =
1213     {
1214         "none"
1215         ,"standout"
1216         ,"underline"
1217         ,"reverse"
1218         ,"blink"
1219         ,"dim"
1220         ,"bold"
1221         ,"invis"
1222         ,"protect"
1223         ,"altcharset"
1224     };
1225     char *base_a = a;
1226     char *base_b = b;
1227     int delaying = 0;
1228
1229     while (*b != 0) {
1230         while (*a != *b) {
1231             if (*a == 0) {
1232                 if (b[0] == '$'
1233                     && b[1] == '<') {
1234                     _nc_warning("Did not find delay %s", _nc_visbuf(b));
1235                 } else {
1236                     _nc_warning("checking sgr(%s) %s\n\tcompare to %s\n\tunmatched %s",
1237                                 names[num], _nc_visbuf2(1, base_a),
1238                                 _nc_visbuf2(2, base_b),
1239                                 _nc_visbuf2(3, b));
1240                 }
1241                 return FALSE;
1242             } else if (delaying) {
1243                 a = skip_delay(a);
1244                 b = skip_delay(b);
1245             } else {
1246                 a++;
1247             }
1248         }
1249         switch (*a) {
1250         case '$':
1251             if (delaying == 0)
1252                 delaying = 1;
1253             break;
1254         case '<':
1255             if (delaying == 1)
1256                 delaying = 2;
1257             break;
1258         default:
1259             delaying = 0;
1260             break;
1261         }
1262         a++;
1263         b++;
1264     }
1265     /* ignore delays on the end of the string */
1266     a = ignore_delays(a);
1267     return ((num != 0) || (*a == 0));
1268 }
1269
1270 static char *
1271 check_sgr(TERMTYPE *tp, char *zero, int num, char *cap, const char *name)
1272 {
1273     char *test;
1274
1275     _nc_tparm_err = 0;
1276     test = TPARM_9(set_attributes,
1277                    num == 1,
1278                    num == 2,
1279                    num == 3,
1280                    num == 4,
1281                    num == 5,
1282                    num == 6,
1283                    num == 7,
1284                    num == 8,
1285                    num == 9);
1286     if (test != 0) {
1287         if (PRESENT(cap)) {
1288             if (!similar_sgr(num, test, cap)) {
1289                 _nc_warning("%s differs from sgr(%d)\n\t%s=%s\n\tsgr(%d)=%s",
1290                             name, num,
1291                             name, _nc_visbuf2(1, cap),
1292                             num, _nc_visbuf2(2, test));
1293             }
1294         } else if (_nc_capcmp(test, zero)) {
1295             _nc_warning("sgr(%d) present, but not %s", num, name);
1296         }
1297     } else if (PRESENT(cap)) {
1298         _nc_warning("sgr(%d) missing, but %s present", num, name);
1299     }
1300     if (_nc_tparm_err)
1301         _nc_warning("stack error in sgr(%d) string", num);
1302     return test;
1303 }
1304
1305 #define CHECK_SGR(num,name) check_sgr(tp, zero, num, name, #name)
1306
1307 #ifdef TRACE
1308 /*
1309  * If tic is compiled with TRACE, we'll be able to see the output from the
1310  * DEBUG() macro.  But since it doesn't use traceon(), it always goes to
1311  * the standard error.  Use this function to make it simpler to follow the
1312  * resulting debug traces.
1313  */
1314 static void
1315 show_where(unsigned level)
1316 {
1317     if (_nc_tracing >= DEBUG_LEVEL(level)) {
1318         char my_name[256];
1319         _nc_get_type(my_name);
1320         fprintf(stderr, "\"%s\", line %d, '%s' ",
1321                 _nc_get_source(),
1322                 _nc_curr_line, my_name);
1323     }
1324 }
1325
1326 #else
1327 #define show_where(level)       /* nothing */
1328 #endif
1329
1330 /* other sanity-checks (things that we don't want in the normal
1331  * logic that reads a terminfo entry)
1332  */
1333 static void
1334 check_termtype(TERMTYPE *tp, bool literal)
1335 {
1336     bool conflict = FALSE;
1337     unsigned j, k;
1338     char fkeys[STRCOUNT];
1339
1340     /*
1341      * A terminal entry may contain more than one keycode assigned to
1342      * a given string (e.g., KEY_END and KEY_LL).  But curses will only
1343      * return one (the last one assigned).
1344      */
1345     if (!(_nc_syntax == SYN_TERMCAP && capdump)) {
1346         memset(fkeys, 0, sizeof(fkeys));
1347         for (j = 0; _nc_tinfo_fkeys[j].code; j++) {
1348             char *a = tp->Strings[_nc_tinfo_fkeys[j].offset];
1349             bool first = TRUE;
1350             if (!VALID_STRING(a))
1351                 continue;
1352             for (k = j + 1; _nc_tinfo_fkeys[k].code; k++) {
1353                 char *b = tp->Strings[_nc_tinfo_fkeys[k].offset];
1354                 if (!VALID_STRING(b)
1355                     || fkeys[k])
1356                     continue;
1357                 if (!_nc_capcmp(a, b)) {
1358                     fkeys[j] = 1;
1359                     fkeys[k] = 1;
1360                     if (first) {
1361                         if (!conflict) {
1362                             _nc_warning("Conflicting key definitions (using the last)");
1363                             conflict = TRUE;
1364                         }
1365                         fprintf(stderr, "... %s is the same as %s",
1366                                 keyname((int) _nc_tinfo_fkeys[j].code),
1367                                 keyname((int) _nc_tinfo_fkeys[k].code));
1368                         first = FALSE;
1369                     } else {
1370                         fprintf(stderr, ", %s",
1371                                 keyname((int) _nc_tinfo_fkeys[k].code));
1372                     }
1373                 }
1374             }
1375             if (!first)
1376                 fprintf(stderr, "\n");
1377         }
1378     }
1379
1380     for (j = 0; j < NUM_STRINGS(tp); j++) {
1381         char *a = tp->Strings[j];
1382         if (VALID_STRING(a))
1383             check_params(tp, ExtStrname(tp, j, strnames), a);
1384     }
1385
1386     check_acs(tp);
1387     check_colors(tp);
1388     check_keypad(tp);
1389
1390     /*
1391      * These may be mismatched because the terminal description relies on
1392      * restoring the cursor visibility by resetting it.
1393      */
1394     ANDMISSING(cursor_invisible, cursor_normal);
1395     ANDMISSING(cursor_visible, cursor_normal);
1396
1397     if (PRESENT(cursor_visible) && PRESENT(cursor_normal)
1398         && !_nc_capcmp(cursor_visible, cursor_normal))
1399         _nc_warning("cursor_visible is same as cursor_normal");
1400
1401     /*
1402      * From XSI & O'Reilly, we gather that sc/rc are required if csr is
1403      * given, because the cursor position after the scrolling operation is
1404      * performed is undefined.
1405      */
1406     ANDMISSING(change_scroll_region, save_cursor);
1407     ANDMISSING(change_scroll_region, restore_cursor);
1408
1409     if (PRESENT(set_attributes)) {
1410         char *zero = 0;
1411
1412         _nc_tparm_err = 0;
1413         if (PRESENT(exit_attribute_mode)) {
1414             zero = strdup(CHECK_SGR(0, exit_attribute_mode));
1415         } else {
1416             zero = strdup(TPARM_9(set_attributes, 0, 0, 0, 0, 0, 0, 0, 0, 0));
1417         }
1418         if (_nc_tparm_err)
1419             _nc_warning("stack error in sgr(0) string");
1420
1421         if (zero != 0) {
1422             CHECK_SGR(1, enter_standout_mode);
1423             CHECK_SGR(2, enter_underline_mode);
1424             CHECK_SGR(3, enter_reverse_mode);
1425             CHECK_SGR(4, enter_blink_mode);
1426             CHECK_SGR(5, enter_dim_mode);
1427             CHECK_SGR(6, enter_bold_mode);
1428             CHECK_SGR(7, enter_secure_mode);
1429             CHECK_SGR(8, enter_protected_mode);
1430             CHECK_SGR(9, enter_alt_charset_mode);
1431             free(zero);
1432         } else {
1433             _nc_warning("sgr(0) did not return a value");
1434         }
1435     } else if (PRESENT(exit_attribute_mode) &&
1436                set_attributes != CANCELLED_STRING) {
1437         if (_nc_syntax == SYN_TERMINFO)
1438             _nc_warning("missing sgr string");
1439     }
1440
1441     if (PRESENT(exit_attribute_mode)) {
1442         char *check_sgr0 = _nc_trim_sgr0(tp);
1443
1444         if (check_sgr0 == 0 || *check_sgr0 == '\0') {
1445             _nc_warning("trimmed sgr0 is empty");
1446         } else {
1447             show_where(2);
1448             if (check_sgr0 != exit_attribute_mode) {
1449                 DEBUG(2,
1450                       ("will trim sgr0\n\toriginal sgr0=%s\n\ttrimmed  sgr0=%s",
1451                        _nc_visbuf2(1, exit_attribute_mode),
1452                        _nc_visbuf2(2, check_sgr0)));
1453                 free(check_sgr0);
1454             } else {
1455                 DEBUG(2,
1456                       ("will not trim sgr0\n\toriginal sgr0=%s",
1457                        _nc_visbuf(exit_attribute_mode)));
1458             }
1459         }
1460     }
1461 #ifdef TRACE
1462     show_where(2);
1463     if (!auto_right_margin) {
1464         DEBUG(2,
1465               ("can write to lower-right directly"));
1466     } else if (PRESENT(enter_am_mode) && PRESENT(exit_am_mode)) {
1467         DEBUG(2,
1468               ("can write to lower-right by suppressing automargin"));
1469     } else if ((PRESENT(enter_insert_mode) && PRESENT(exit_insert_mode))
1470                || PRESENT(insert_character) || PRESENT(parm_ich)) {
1471         DEBUG(2,
1472               ("can write to lower-right by using inserts"));
1473     } else {
1474         DEBUG(2,
1475               ("cannot write to lower-right"));
1476     }
1477 #endif
1478
1479     /*
1480      * Some standard applications (e.g., vi) and some non-curses
1481      * applications (e.g., jove) get confused if we have both ich1 and
1482      * smir/rmir.  Let's be nice and warn about that, too, even though
1483      * ncurses handles it.
1484      */
1485     if ((PRESENT(enter_insert_mode) || PRESENT(exit_insert_mode))
1486         && PRESENT(parm_ich)) {
1487         _nc_warning("non-curses applications may be confused by ich1 with smir/rmir");
1488     }
1489
1490     /*
1491      * Finally, do the non-verbose checks
1492      */
1493     if (save_check_termtype != 0)
1494         save_check_termtype(tp, literal);
1495 }