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