ncurses 5.5
[ncurses.git] / progs / tic.c
1 /****************************************************************************
2  * Copyright (c) 1998-2004,2005 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.125 2005/09/25 00:39:43 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--) {
735                         if (infodump)
736                             (void) putchar(fgetc(tmp_fp));
737                         else
738                             put_translate(fgetc(tmp_fp));
739                     }
740
741                     len = dump_entry(&qp->tterm, suppress_untranslatable,
742                                      limited, 0, numbers, NULL);
743                     for (j = 0; j < qp->nuses; j++)
744                         len += dump_uses(qp->uses[j].name, !capdump);
745                     (void) putchar('\n');
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
797 TERMINAL *cur_term;             /* tweak to avoid linking lib_cur_term.c */
798
799 #undef CUR
800 #define CUR tp->
801
802 /*
803  * Check if the alternate character-set capabilities are consistent.
804  */
805 static void
806 check_acs(TERMTYPE *tp)
807 {
808     if (VALID_STRING(acs_chars)) {
809         const char *boxes = "lmkjtuvwqxn";
810         char mapped[256];
811         char missing[256];
812         const char *p;
813         char *q;
814
815         memset(mapped, 0, sizeof(mapped));
816         for (p = acs_chars; *p != '\0'; p += 2) {
817             if (p[1] == '\0') {
818                 _nc_warning("acsc has odd number of characters");
819                 break;
820             }
821             mapped[UChar(p[0])] = p[1];
822         }
823         if (mapped[UChar('I')] && !mapped[UChar('i')]) {
824             _nc_warning("acsc refers to 'I', which is probably an error");
825         }
826         for (p = boxes, q = missing; *p != '\0'; ++p) {
827             if (!mapped[UChar(p[0])]) {
828                 *q++ = p[0];
829             }
830             *q = '\0';
831         }
832         if (*missing != '\0' && strcmp(missing, boxes)) {
833             _nc_warning("acsc is missing some line-drawing mapping: %s", missing);
834         }
835     }
836 }
837
838 /*
839  * Check if the color capabilities are consistent
840  */
841 static void
842 check_colors(TERMTYPE *tp)
843 {
844     if ((max_colors > 0) != (max_pairs > 0)
845         || ((max_colors > max_pairs) && (initialize_pair == 0)))
846         _nc_warning("inconsistent values for max_colors (%d) and max_pairs (%d)",
847                     max_colors, max_pairs);
848
849     PAIRED(set_foreground, set_background);
850     PAIRED(set_a_foreground, set_a_background);
851     PAIRED(set_color_pair, initialize_pair);
852
853     if (VALID_STRING(set_foreground)
854         && VALID_STRING(set_a_foreground)
855         && !_nc_capcmp(set_foreground, set_a_foreground))
856         _nc_warning("expected setf/setaf to be different");
857
858     if (VALID_STRING(set_background)
859         && VALID_STRING(set_a_background)
860         && !_nc_capcmp(set_background, set_a_background))
861         _nc_warning("expected setb/setab to be different");
862
863     /* see: has_colors() */
864     if (VALID_NUMERIC(max_colors) && VALID_NUMERIC(max_pairs)
865         && (((set_foreground != NULL)
866              && (set_background != NULL))
867             || ((set_a_foreground != NULL)
868                 && (set_a_background != NULL))
869             || set_color_pair)) {
870         if (!VALID_STRING(orig_pair) && !VALID_STRING(orig_colors))
871             _nc_warning("expected either op/oc string for resetting colors");
872     }
873 }
874
875 static int
876 keypad_final(const char *string)
877 {
878     int result = '\0';
879
880     if (VALID_STRING(string)
881         && *string++ == '\033'
882         && *string++ == 'O'
883         && strlen(string) == 1) {
884         result = *string;
885     }
886
887     return result;
888 }
889
890 static int
891 keypad_index(const char *string)
892 {
893     char *test;
894     const char *list = "PQRSwxymtuvlqrsPpn";    /* app-keypad except "Enter" */
895     int ch;
896     int result = -1;
897
898     if ((ch = keypad_final(string)) != '\0') {
899         test = strchr(list, ch);
900         if (test != 0)
901             result = (test - list);
902     }
903     return result;
904 }
905
906 /*
907  * Do a quick sanity-check for vt100-style keypads to see if the 5-key keypad
908  * is mapped inconsistently.
909  */
910 static void
911 check_keypad(TERMTYPE *tp)
912 {
913     char show[80];
914
915     if (VALID_STRING(key_a1) &&
916         VALID_STRING(key_a3) &&
917         VALID_STRING(key_b2) &&
918         VALID_STRING(key_c1) &&
919         VALID_STRING(key_c3)) {
920         char final[6];
921         int list[5];
922         int increase = 0;
923         int j, k, kk;
924         int last;
925         int test;
926
927         final[0] = keypad_final(key_a1);
928         final[1] = keypad_final(key_a3);
929         final[2] = keypad_final(key_b2);
930         final[3] = keypad_final(key_c1);
931         final[4] = keypad_final(key_c3);
932         final[5] = '\0';
933
934         /* special case: legacy coding using 1,2,3,0,. on the bottom */
935         if (!strcmp(final, "qsrpn"))
936             return;
937
938         list[0] = keypad_index(key_a1);
939         list[1] = keypad_index(key_a3);
940         list[2] = keypad_index(key_b2);
941         list[3] = keypad_index(key_c1);
942         list[4] = keypad_index(key_c3);
943
944         /* check that they're all vt100 keys */
945         for (j = 0; j < 5; ++j) {
946             if (list[j] < 0) {
947                 return;
948             }
949         }
950
951         /* check if they're all in increasing order */
952         for (j = 1; j < 5; ++j) {
953             if (list[j] > list[j - 1]) {
954                 ++increase;
955             }
956         }
957         if (increase != 4) {
958             show[0] = '\0';
959
960             for (j = 0, last = -1; j < 5; ++j) {
961                 for (k = 0, kk = -1, test = 100; k < 5; ++k) {
962                     if (list[k] > last &&
963                         list[k] < test) {
964                         test = list[k];
965                         kk = k;
966                     }
967                 }
968                 last = test;
969                 switch (kk) {
970                 case 0:
971                     strcat(show, " ka1");
972                     break;
973                 case 1:
974                     strcat(show, " ka3");
975                     break;
976                 case 2:
977                     strcat(show, " kb2");
978                     break;
979                 case 3:
980                     strcat(show, " kc1");
981                     break;
982                 case 4:
983                     strcat(show, " kc3");
984                     break;
985                 }
986             }
987
988             _nc_warning("vt100 keypad order inconsistent: %s", show);
989         }
990
991     } else if (VALID_STRING(key_a1) ||
992                VALID_STRING(key_a3) ||
993                VALID_STRING(key_b2) ||
994                VALID_STRING(key_c1) ||
995                VALID_STRING(key_c3)) {
996         show[0] = '\0';
997         if (keypad_index(key_a1) >= 0)
998             strcat(show, " ka1");
999         if (keypad_index(key_a3) >= 0)
1000             strcat(show, " ka3");
1001         if (keypad_index(key_b2) >= 0)
1002             strcat(show, " kb2");
1003         if (keypad_index(key_c1) >= 0)
1004             strcat(show, " kc1");
1005         if (keypad_index(key_c3) >= 0)
1006             strcat(show, " kc3");
1007         if (*show != '\0')
1008             _nc_warning("vt100 keypad map incomplete:%s", show);
1009     }
1010 }
1011
1012 /*
1013  * Returns the expected number of parameters for the given capability.
1014  */
1015 static int
1016 expected_params(const char *name)
1017 {
1018     /* *INDENT-OFF* */
1019     static const struct {
1020         const char *name;
1021         int count;
1022     } table[] = {
1023         { "S0",                 1 },    /* 'screen' extension */
1024         { "birep",              2 },
1025         { "chr",                1 },
1026         { "colornm",            1 },
1027         { "cpi",                1 },
1028         { "csnm",               1 },
1029         { "csr",                2 },
1030         { "cub",                1 },
1031         { "cud",                1 },
1032         { "cuf",                1 },
1033         { "cup",                2 },
1034         { "cuu",                1 },
1035         { "cvr",                1 },
1036         { "cwin",               5 },
1037         { "dch",                1 },
1038         { "defc",               3 },
1039         { "dial",               1 },
1040         { "dispc",              1 },
1041         { "dl",                 1 },
1042         { "ech",                1 },
1043         { "getm",               1 },
1044         { "hpa",                1 },
1045         { "ich",                1 },
1046         { "il",                 1 },
1047         { "indn",               1 },
1048         { "initc",              4 },
1049         { "initp",              7 },
1050         { "lpi",                1 },
1051         { "mc5p",               1 },
1052         { "mrcup",              2 },
1053         { "mvpa",               1 },
1054         { "pfkey",              2 },
1055         { "pfloc",              2 },
1056         { "pfx",                2 },
1057         { "pfxl",               3 },
1058         { "pln",                2 },
1059         { "qdial",              1 },
1060         { "rcsd",               1 },
1061         { "rep",                2 },
1062         { "rin",                1 },
1063         { "sclk",               3 },
1064         { "scp",                1 },
1065         { "scs",                1 },
1066         { "scsd",               2 },
1067         { "setab",              1 },
1068         { "setaf",              1 },
1069         { "setb",               1 },
1070         { "setcolor",           1 },
1071         { "setf",               1 },
1072         { "sgr",                9 },
1073         { "sgr1",               6 },
1074         { "slength",            1 },
1075         { "slines",             1 },
1076         { "smgbp",              1 },    /* 2 if smgtp is not given */
1077         { "smglp",              1 },
1078         { "smglr",              2 },
1079         { "smgrp",              1 },
1080         { "smgtb",              2 },
1081         { "smgtp",              1 },
1082         { "tsl",                1 },
1083         { "u6",                 -1 },
1084         { "vpa",                1 },
1085         { "wind",               4 },
1086         { "wingo",              1 },
1087     };
1088     /* *INDENT-ON* */
1089
1090     unsigned n;
1091     int result = 0;             /* function-keys, etc., use none */
1092
1093     for (n = 0; n < SIZEOF(table); n++) {
1094         if (!strcmp(name, table[n].name)) {
1095             result = table[n].count;
1096             break;
1097         }
1098     }
1099
1100     return result;
1101 }
1102
1103 /*
1104  * Make a quick sanity check for the parameters which are used in the given
1105  * strings.  If there are no "%p" tokens, then there should be no other "%"
1106  * markers.
1107  */
1108 static void
1109 check_params(TERMTYPE *tp, const char *name, char *value)
1110 {
1111     int expected = expected_params(name);
1112     int actual = 0;
1113     int n;
1114     bool params[10];
1115     char *s = value;
1116
1117 #ifdef set_top_margin_parm
1118     if (!strcmp(name, "smgbp")
1119         && set_top_margin_parm == 0)
1120         expected = 2;
1121 #endif
1122
1123     for (n = 0; n < 10; n++)
1124         params[n] = FALSE;
1125
1126     while (*s != 0) {
1127         if (*s == '%') {
1128             if (*++s == '\0') {
1129                 _nc_warning("expected character after %% in %s", name);
1130                 break;
1131             } else if (*s == 'p') {
1132                 if (*++s == '\0' || !isdigit((int) *s)) {
1133                     _nc_warning("expected digit after %%p in %s", name);
1134                     return;
1135                 } else {
1136                     n = (*s - '0');
1137                     if (n > actual)
1138                         actual = n;
1139                     params[n] = TRUE;
1140                 }
1141             }
1142         }
1143         s++;
1144     }
1145
1146     if (params[0]) {
1147         _nc_warning("%s refers to parameter 0 (%%p0), which is not allowed", name);
1148     }
1149     if (value == set_attributes || expected < 0) {
1150         ;
1151     } else if (expected != actual) {
1152         _nc_warning("%s uses %d parameters, expected %d", name,
1153                     actual, expected);
1154         for (n = 1; n < actual; n++) {
1155             if (!params[n])
1156                 _nc_warning("%s omits parameter %d", name, n);
1157         }
1158     }
1159 }
1160
1161 static char *
1162 skip_delay(char *s)
1163 {
1164     while (*s == '/' || isdigit(UChar(*s)))
1165         ++s;
1166     return s;
1167 }
1168
1169 /*
1170  * Skip a delay altogether, e.g., when comparing a simple string to sgr,
1171  * the latter may have a worst-case delay on the end.
1172  */
1173 static char *
1174 ignore_delays(char *s)
1175 {
1176     int delaying = 0;
1177
1178     do {
1179         switch (*s) {
1180         case '$':
1181             if (delaying == 0)
1182                 delaying = 1;
1183             break;
1184         case '<':
1185             if (delaying == 1)
1186                 delaying = 2;
1187             break;
1188         case '\0':
1189             delaying = 0;
1190             break;
1191         default:
1192             if (delaying) {
1193                 s = skip_delay(s);
1194                 if (*s == '>')
1195                     ++s;
1196                 delaying = 0;
1197             }
1198             break;
1199         }
1200         if (delaying)
1201             ++s;
1202     } while (delaying);
1203     return s;
1204 }
1205
1206 /*
1207  * An sgr string may contain several settings other than the one we're
1208  * interested in, essentially sgr0 + rmacs + whatever.  As long as the
1209  * "whatever" is contained in the sgr string, that is close enough for our
1210  * sanity check.
1211  */
1212 static bool
1213 similar_sgr(int num, char *a, char *b)
1214 {
1215     static const char *names[] =
1216     {
1217         "none"
1218         ,"standout"
1219         ,"underline"
1220         ,"reverse"
1221         ,"blink"
1222         ,"dim"
1223         ,"bold"
1224         ,"invis"
1225         ,"protect"
1226         ,"altcharset"
1227     };
1228     char *base_a = a;
1229     char *base_b = b;
1230     int delaying = 0;
1231
1232     while (*b != 0) {
1233         while (*a != *b) {
1234             if (*a == 0) {
1235                 if (b[0] == '$'
1236                     && b[1] == '<') {
1237                     _nc_warning("Did not find delay %s", _nc_visbuf(b));
1238                 } else {
1239                     _nc_warning("checking sgr(%s) %s\n\tcompare to %s\n\tunmatched %s",
1240                                 names[num], _nc_visbuf2(1, base_a),
1241                                 _nc_visbuf2(2, base_b),
1242                                 _nc_visbuf2(3, b));
1243                 }
1244                 return FALSE;
1245             } else if (delaying) {
1246                 a = skip_delay(a);
1247                 b = skip_delay(b);
1248             } else {
1249                 a++;
1250             }
1251         }
1252         switch (*a) {
1253         case '$':
1254             if (delaying == 0)
1255                 delaying = 1;
1256             break;
1257         case '<':
1258             if (delaying == 1)
1259                 delaying = 2;
1260             break;
1261         default:
1262             delaying = 0;
1263             break;
1264         }
1265         a++;
1266         b++;
1267     }
1268     /* ignore delays on the end of the string */
1269     a = ignore_delays(a);
1270     return ((num != 0) || (*a == 0));
1271 }
1272
1273 static char *
1274 check_sgr(TERMTYPE *tp, char *zero, int num, char *cap, const char *name)
1275 {
1276     char *test;
1277
1278     _nc_tparm_err = 0;
1279     test = tparm(set_attributes,
1280                  num == 1,
1281                  num == 2,
1282                  num == 3,
1283                  num == 4,
1284                  num == 5,
1285                  num == 6,
1286                  num == 7,
1287                  num == 8,
1288                  num == 9);
1289     if (test != 0) {
1290         if (PRESENT(cap)) {
1291             if (!similar_sgr(num, test, cap)) {
1292                 _nc_warning("%s differs from sgr(%d)\n\t%s=%s\n\tsgr(%d)=%s",
1293                             name, num,
1294                             name, _nc_visbuf2(1, cap),
1295                             num, _nc_visbuf2(2, test));
1296             }
1297         } else if (_nc_capcmp(test, zero)) {
1298             _nc_warning("sgr(%d) present, but not %s", num, name);
1299         }
1300     } else if (PRESENT(cap)) {
1301         _nc_warning("sgr(%d) missing, but %s present", num, name);
1302     }
1303     if (_nc_tparm_err)
1304         _nc_warning("stack error in sgr(%d) string", num);
1305     return test;
1306 }
1307
1308 #define CHECK_SGR(num,name) check_sgr(tp, zero, num, name, #name)
1309
1310 #ifdef TRACE
1311 /*
1312  * If tic is compiled with TRACE, we'll be able to see the output from the
1313  * DEBUG() macro.  But since it doesn't use traceon(), it always goes to
1314  * the standard error.  Use this function to make it simpler to follow the
1315  * resulting debug traces.
1316  */
1317 static void
1318 show_where(unsigned level)
1319 {
1320     if (_nc_tracing >= level) {
1321         char my_name[256];
1322         _nc_get_type(my_name);
1323         fprintf(stderr, "\"%s\", line %d, '%s' ",
1324                 _nc_get_source(),
1325                 _nc_curr_line, my_name);
1326     }
1327 }
1328
1329 #else
1330 #define show_where(level) /* nothing */
1331 #endif
1332
1333 /* other sanity-checks (things that we don't want in the normal
1334  * logic that reads a terminfo entry)
1335  */
1336 static void
1337 check_termtype(TERMTYPE *tp, bool literal)
1338 {
1339     bool conflict = FALSE;
1340     unsigned j, k;
1341     char fkeys[STRCOUNT];
1342
1343     /*
1344      * A terminal entry may contain more than one keycode assigned to
1345      * a given string (e.g., KEY_END and KEY_LL).  But curses will only
1346      * return one (the last one assigned).
1347      */
1348     if (!(_nc_syntax == SYN_TERMCAP && capdump)) {
1349         memset(fkeys, 0, sizeof(fkeys));
1350         for (j = 0; _nc_tinfo_fkeys[j].code; j++) {
1351             char *a = tp->Strings[_nc_tinfo_fkeys[j].offset];
1352             bool first = TRUE;
1353             if (!VALID_STRING(a))
1354                 continue;
1355             for (k = j + 1; _nc_tinfo_fkeys[k].code; k++) {
1356                 char *b = tp->Strings[_nc_tinfo_fkeys[k].offset];
1357                 if (!VALID_STRING(b)
1358                     || fkeys[k])
1359                     continue;
1360                 if (!_nc_capcmp(a, b)) {
1361                     fkeys[j] = 1;
1362                     fkeys[k] = 1;
1363                     if (first) {
1364                         if (!conflict) {
1365                             _nc_warning("Conflicting key definitions (using the last)");
1366                             conflict = TRUE;
1367                         }
1368                         fprintf(stderr, "... %s is the same as %s",
1369                                 keyname((int) _nc_tinfo_fkeys[j].code),
1370                                 keyname((int) _nc_tinfo_fkeys[k].code));
1371                         first = FALSE;
1372                     } else {
1373                         fprintf(stderr, ", %s",
1374                                 keyname((int) _nc_tinfo_fkeys[k].code));
1375                     }
1376                 }
1377             }
1378             if (!first)
1379                 fprintf(stderr, "\n");
1380         }
1381     }
1382
1383     for (j = 0; j < NUM_STRINGS(tp); j++) {
1384         char *a = tp->Strings[j];
1385         if (VALID_STRING(a))
1386             check_params(tp, ExtStrname(tp, j, strnames), a);
1387     }
1388
1389     check_acs(tp);
1390     check_colors(tp);
1391     check_keypad(tp);
1392
1393     /*
1394      * These may be mismatched because the terminal description relies on
1395      * restoring the cursor visibility by resetting it.
1396      */
1397     ANDMISSING(cursor_invisible, cursor_normal);
1398     ANDMISSING(cursor_visible, cursor_normal);
1399
1400     if (PRESENT(cursor_visible) && PRESENT(cursor_normal)
1401         && !_nc_capcmp(cursor_visible, cursor_normal))
1402         _nc_warning("cursor_visible is same as cursor_normal");
1403
1404     /*
1405      * From XSI & O'Reilly, we gather that sc/rc are required if csr is
1406      * given, because the cursor position after the scrolling operation is
1407      * performed is undefined.
1408      */
1409     ANDMISSING(change_scroll_region, save_cursor);
1410     ANDMISSING(change_scroll_region, restore_cursor);
1411
1412     if (PRESENT(set_attributes)) {
1413         char *zero = 0;
1414
1415         _nc_tparm_err = 0;
1416         if (PRESENT(exit_attribute_mode)) {
1417             zero = strdup(CHECK_SGR(0, exit_attribute_mode));
1418         } else {
1419             zero = strdup(tparm(set_attributes, 0, 0, 0, 0, 0, 0, 0, 0, 0));
1420         }
1421         if (_nc_tparm_err)
1422             _nc_warning("stack error in sgr(0) string");
1423
1424         if (zero != 0) {
1425             CHECK_SGR(1, enter_standout_mode);
1426             CHECK_SGR(2, enter_underline_mode);
1427             CHECK_SGR(3, enter_reverse_mode);
1428             CHECK_SGR(4, enter_blink_mode);
1429             CHECK_SGR(5, enter_dim_mode);
1430             CHECK_SGR(6, enter_bold_mode);
1431             CHECK_SGR(7, enter_secure_mode);
1432             CHECK_SGR(8, enter_protected_mode);
1433             CHECK_SGR(9, enter_alt_charset_mode);
1434             free(zero);
1435         } else {
1436             _nc_warning("sgr(0) did not return a value");
1437         }
1438     } else if (PRESENT(exit_attribute_mode) &&
1439                set_attributes != CANCELLED_STRING) {
1440         if (_nc_syntax == SYN_TERMINFO)
1441             _nc_warning("missing sgr string");
1442     }
1443
1444     if (PRESENT(exit_attribute_mode)) {
1445         char *check_sgr0 = _nc_trim_sgr0(tp);
1446
1447         if (check_sgr0 == 0 || *check_sgr0 == '\0') {
1448             _nc_warning("trimmed sgr0 is empty");
1449         } else {
1450             show_where(2);
1451             if (check_sgr0 != exit_attribute_mode) {
1452                 DEBUG(2,
1453                       ("will trim sgr0\n\toriginal sgr0=%s\n\ttrimmed  sgr0=%s",
1454                        _nc_visbuf2(1, exit_attribute_mode),
1455                        _nc_visbuf2(2, check_sgr0)));
1456                 free(check_sgr0);
1457             } else {
1458                 DEBUG(2,
1459                       ("will not trim sgr0\n\toriginal sgr0=%s",
1460                        _nc_visbuf(exit_attribute_mode)));
1461             }
1462         }
1463     }
1464 #ifdef TRACE
1465     show_where(2);
1466     if (!auto_right_margin) {
1467         DEBUG(2,
1468               ("can write to lower-right directly"));
1469     } else if (PRESENT(enter_am_mode) && PRESENT(exit_am_mode)) {
1470         DEBUG(2,
1471               ("can write to lower-right by suppressing automargin"));
1472     } else if ((PRESENT(enter_insert_mode) && PRESENT(exit_insert_mode))
1473                || PRESENT(insert_character) || PRESENT(parm_ich)) {
1474         DEBUG(2,
1475               ("can write to lower-right by using inserts"));
1476     } else {
1477         DEBUG(2,
1478               ("cannot write to lower-right"));
1479     }
1480 #endif
1481
1482     /*
1483      * Some standard applications (e.g., vi) and some non-curses
1484      * applications (e.g., jove) get confused if we have both ich1 and
1485      * smir/rmir.  Let's be nice and warn about that, too, even though
1486      * ncurses handles it.
1487      */
1488     if ((PRESENT(enter_insert_mode) || PRESENT(exit_insert_mode))
1489         && PRESENT(parm_ich)) {
1490         _nc_warning("non-curses applications may be confused by ich1 with smir/rmir");
1491     }
1492
1493     /*
1494      * Finally, do the non-verbose checks
1495      */
1496     if (save_check_termtype != 0)
1497         save_check_termtype(tp, literal);
1498 }