aboutsummaryrefslogtreecommitdiff
path: root/contrib/ncurses/progs/tic.c
blob: d81af0a3cdc6241e8d55b9e1f639b6a4ee00489b (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
/****************************************************************************
 * Copyright (c) 1998,1999 Free Software Foundation, Inc.                   *
 *                                                                          *
 * Permission is hereby granted, free of charge, to any person obtaining a  *
 * copy of this software and associated documentation files (the            *
 * "Software"), to deal in the Software without restriction, including      *
 * without limitation the rights to use, copy, modify, merge, publish,      *
 * distribute, distribute with modifications, sublicense, and/or sell       *
 * copies of the Software, and to permit persons to whom the Software is    *
 * furnished to do so, subject to the following conditions:                 *
 *                                                                          *
 * The above copyright notice and this permission notice shall be included  *
 * in all copies or substantial portions of the Software.                   *
 *                                                                          *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
 * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
 * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
 *                                                                          *
 * Except as contained in this notice, the name(s) of the above copyright   *
 * holders shall not be used in advertising or otherwise to promote the     *
 * sale, use or other dealings in this Software without prior written       *
 * authorization.                                                           *
 ****************************************************************************/

/****************************************************************************
 *  Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995               *
 *     and: Eric S. Raymond <esr@snark.thyrsus.com>                         *
 ****************************************************************************/

/*
 *	tic.c --- Main program for terminfo compiler
 *			by Eric S. Raymond
 *
 */

#include <progs.priv.h>

#include <dump_entry.h>
#include <term_entry.h>

MODULE_ID("$Id: tic.c,v 1.51 1999/06/19 21:35:36 Philippe.De.Muyter Exp $")

const char *_nc_progname = "tic";

static	FILE	*log_fp;
static	FILE	*tmp_fp;
static	bool	showsummary = FALSE;
static	const char *to_remove;

static	void	(*save_check_termtype)(TERMTYPE *);
static	void	check_termtype(TERMTYPE *tt);

static	const	char usage_string[] = "[-h] [-v[n]] [-e names] [-CILNRTcfrswx1] source-file\n";

static void cleanup(void)
{
	if (tmp_fp != 0)
		fclose(tmp_fp);
	if (to_remove != 0) {
#if HAVE_REMOVE
		remove(to_remove);
#else
		unlink(to_remove);
#endif
	}
}

static void failed(const char *msg)
{
	perror(msg);
	cleanup();
	exit(EXIT_FAILURE);
}

static void usage(void)
{
	static const char *const tbl[] = {
	"Options:",
	"  -1         format translation output one capability per line",
	"  -C         translate entries to termcap source form",
	"  -I         translate entries to terminfo source form",
	"  -L         translate entries to full terminfo source form",
	"  -N         disable smart defaults for source translation",
	"  -R         restrict translation to given terminfo/termcap version",
	"  -T         remove size-restrictions on compiled description",
	"  -c         check only, validate input without compiling or translating",
	"  -f         format complex strings for readability",
	"  -G         format %{number} to %'char'",
	"  -g         format %'char' to %{number}",
	"  -e<names>  translate/compile only entries named by comma-separated list",
	"  -o<dir>    set output directory for compiled entry writes",
	"  -r         force resolution of all use entries in source translation",
	"  -s         print summary statistics",
	"  -v[n]      set verbosity level",
	"  -w[n]      set format width for translation output",
#if NCURSES_XNAMES
	"  -x         treat unknown capabilities as user-defined",
#endif
	"",
	"Parameters:",
	"  <file>     file to translate or compile"
	};
	size_t j;

	printf("Usage: %s %s\n", _nc_progname, usage_string);
	for (j = 0; j < sizeof(tbl)/sizeof(tbl[0]); j++)
		puts(tbl[j]);
	exit(EXIT_FAILURE);
}

#define L_BRACE '{'
#define R_BRACE '}'
#define S_QUOTE '\'';

static void write_it(ENTRY *ep)
{
	unsigned n;
	int ch;
	char *s, *d, *t;
	char result[MAX_ENTRY_SIZE];

	/*
	 * Look for strings that contain %{number}, convert them to %'char',
	 * which is shorter and runs a little faster.
	 */
	for (n = 0; n < STRCOUNT; n++) {
		s = ep->tterm.Strings[n];
		if (VALID_STRING(s)
		 && strchr(s, L_BRACE) != 0) {
			d = result;
			t = s;
			while ((ch = *t++) != 0) {
				*d++ = ch;
				if (ch == '\\') {
					*d++ = *t++;
				} else if ((ch == '%')
				 && (*t == L_BRACE)) {
					char *v = 0;
					long value = strtol(t+1, &v, 0);
					if (v != 0
					 && *v == R_BRACE
					 && value > 0
					 && value != '\\'	/* FIXME */
					 && value < 127
					 && isprint((int)value)) {
						*d++ = S_QUOTE;
						*d++ = (int)value;
						*d++ = S_QUOTE;
						t = (v + 1);
					}
				}
			}
			*d = 0;
			if (strlen(result) < strlen(s))
				strcpy(s, result);
		}
	}

	_nc_set_type(_nc_first_name(ep->tterm.term_names));
	_nc_curr_line = ep->startline;
	_nc_write_entry(&ep->tterm);
}

static bool immedhook(ENTRY *ep GCC_UNUSED)
/* write out entries with no use capabilities immediately to save storage */
{
#ifndef HAVE_BIG_CORE
    /*
     * This is strictly a core-economy kluge.  The really clean way to handle
     * compilation is to slurp the whole file into core and then do all the
     * name-collision checks and entry writes in one swell foop.  But the
     * terminfo master file is large enough that some core-poor systems swap
     * like crazy when you compile it this way...there have been reports of
     * this process taking *three hours*, rather than the twenty seconds or
     * less typical on my development box.
     *
     * So.  This hook *immediately* writes out the referenced entry if it
     * has no use capabilities.  The compiler main loop refrains from
     * adding the entry to the in-core list when this hook fires.  If some
     * other entry later needs to reference an entry that got written
     * immediately, that's OK; the resolution code will fetch it off disk
     * when it can't find it in core.
     *
     * Name collisions will still be detected, just not as cleanly.  The
     * write_entry() code complains before overwriting an entry that
     * postdates the time of tic's first call to write_entry().  Thus
     * it will complain about overwriting entries newly made during the
     * tic run, but not about overwriting ones that predate it.
     *
     * The reason this is a hook, and not in line with the rest of the
     * compiler code, is that the support for termcap fallback cannot assume
     * it has anywhere to spool out these entries!
     *
     * The _nc_set_type() call here requires a compensating one in
     * _nc_parse_entry().
     *
     * If you define HAVE_BIG_CORE, you'll disable this kluge.  This will
     * make tic a bit faster (because the resolution code won't have to do
     * disk I/O nearly as often).
     */
    if (ep->nuses == 0)
    {
	int	oldline = _nc_curr_line;

	write_it(ep);
	_nc_curr_line = oldline;
	free(ep->tterm.str_table);
	return(TRUE);
    }
#endif /* HAVE_BIG_CORE */
    return(FALSE);
}

static void put_translate(int c)
/* emit a comment char, translating terminfo names to termcap names */
{
    static bool in_name = FALSE;
    static char namebuf[132], suffix[132], *sp;

    if (!in_name)
    {
	if (c == '<')
	{
	    in_name = TRUE;
	    sp = namebuf;
	}
	else
	    putchar(c);
    }
    else if (c == '\n' || c == '@')
    {
	*sp++ = '\0';
	(void) putchar('<');
	(void) fputs(namebuf, stdout);
	putchar(c);
	in_name = FALSE;
    }
    else if (c != '>')
	*sp++ = c;
    else		/* ah! candidate name! */
    {
	char	*up;
	NCURSES_CONST char *tp;

	*sp++ = '\0';
	in_name = FALSE;

	suffix[0] = '\0';
	if ((up = strchr(namebuf, '#')) != 0
	 || (up = strchr(namebuf, '=')) != 0
	 || ((up = strchr(namebuf, '@')) != 0 && up[1] == '>'))
	{
	    (void) strcpy(suffix, up);
	    *up = '\0';
	}

	if ((tp = nametrans(namebuf)) != 0)
	{
	    (void) putchar(':');
	    (void) fputs(tp, stdout);
	    (void) fputs(suffix, stdout);
	    (void) putchar(':');
	}
	else
	{
	    /* couldn't find a translation, just dump the name */
	    (void) putchar('<');
	    (void) fputs(namebuf, stdout);
	    (void) fputs(suffix, stdout);
	    (void) putchar('>');
	}

    }
}

/* Returns a string, stripped of leading/trailing whitespace */
static char *stripped(char *src)
{
	while (isspace(*src))
		src++;
	if (*src != '\0') {
		char *dst = strcpy(malloc(strlen(src)+1), src);
		size_t len = strlen(dst);
		while (--len != 0 && isspace(dst[len]))
			dst[len] = '\0';
		return dst;
	}
	return 0;
}

/* Parse the "-e" option-value into a list of names */
static const char **make_namelist(char *src)
{
	const char **dst = 0;

	char *s, *base;
	unsigned pass, n, nn;
	char buffer[BUFSIZ];

	if (src == 0) {
		/* EMPTY */;
	} else if (strchr(src, '/') != 0) {	/* a filename */
		FILE *fp = fopen(src, "r");
		if (fp == 0)
			failed(src);

		for (pass = 1; pass <= 2; pass++) {
			nn = 0;
			while (fgets(buffer, sizeof(buffer), fp) != 0) {
				if ((s = stripped(buffer)) != 0) {
					if (dst != 0)
						dst[nn] = s;
					nn++;
				}
			}
			if (pass == 1) {
				dst = (const char **)calloc(nn+1, sizeof(*dst));
				rewind(fp);
			}
		}
		fclose(fp);
	} else {			/* literal list of names */
		for (pass = 1; pass <= 2; pass++) {
			for (n = nn = 0, base = src; ; n++) {
				int mark = src[n];
				if (mark == ',' || mark == '\0') {
					if (pass == 1) {
						nn++;
					} else {
						src[n] = '\0';
						if ((s = stripped(base)) != 0)
							dst[nn++] = s;
						base = &src[n+1];
					}
				}
				if (mark == '\0')
					break;
			}
			if (pass == 1)
				dst = (const char **)calloc(nn+1, sizeof(*dst));
		}
	}
	if (showsummary) {
		fprintf(log_fp, "Entries that will be compiled:\n");
		for (n = 0; dst[n] != 0; n++)
			fprintf(log_fp, "%d:%s\n", n+1, dst[n]);
	}
	return dst;
}

static bool matches(const char **needle, const char *haystack)
/* does entry in needle list match |-separated field in haystack? */
{
	bool code = FALSE;
	size_t n;

	if (needle != 0)
	{
		for (n = 0; needle[n] != 0; n++)
		{
			if (_nc_name_match(haystack, needle[n], "|"))
			{
				code = TRUE;
				break;
			}
		}
	}
	else
		code = TRUE;
	return(code);
}

int main (int argc, char *argv[])
{
char	my_tmpname[PATH_MAX];
int	v_opt = -1, debug_level;
int	smart_defaults = TRUE;
char    *termcap;
ENTRY	*qp;

int	this_opt, last_opt = '?';

int	outform = F_TERMINFO;	/* output format */
int	sortmode = S_TERMINFO;	/* sort_mode */

int	width = 60;
bool	formatted = FALSE;	/* reformat complex strings? */
int	numbers = 0;		/* format "%'char'" to/from "%{number}" */
bool	infodump = FALSE;	/* running as captoinfo? */
bool	capdump = FALSE;	/* running as infotocap? */
bool	forceresolve = FALSE;	/* force resolution */
bool	limited = TRUE;
char	*tversion = (char *)NULL;
const	char	*source_file = "terminfo";
const	char	**namelst = 0;
char	*outdir = (char *)NULL;
bool	check_only = FALSE;

	log_fp = stderr;

	if ((_nc_progname = strrchr(argv[0], '/')) == NULL)
		_nc_progname = argv[0];
	else
		_nc_progname++;

	infodump = (strcmp(_nc_progname, "captoinfo") == 0);
	capdump = (strcmp(_nc_progname, "infotocap") == 0);
#if NCURSES_XNAMES
	use_extended_names(FALSE);
#endif

	/*
	 * Processing arguments is a little complicated, since someone made a
	 * design decision to allow the numeric values for -w, -v options to
	 * be optional.
	 */
	while ((this_opt = getopt(argc, argv, "0123456789CILNR:TVce:fGgo:rsvwx")) != EOF) {
		if (isdigit(this_opt)) {
			switch (last_opt) {
			case 'v':
				v_opt = (v_opt * 10) + (this_opt - '0');
				break;
			case 'w':
				width = (width * 10) + (this_opt - '0');
				break;
			default:
				if (this_opt != '1')
					usage();
				last_opt = this_opt;
				width = 0;
			}
			continue;
		}
		switch (this_opt) {
		case 'C':
			capdump  = TRUE;
			outform  = F_TERMCAP;
			sortmode = S_TERMCAP;
			break;
		case 'I':
			infodump = TRUE;
			outform  = F_TERMINFO;
			sortmode = S_TERMINFO;
			break;
		case 'L':
			infodump = TRUE;
			outform  = F_VARIABLE;
			sortmode = S_VARIABLE;
			break;
		case 'N':
			smart_defaults = FALSE;
			break;
		case 'R':
			tversion = optarg;
			break;
		case 'T':
			limited = FALSE;
			break;
		case 'V':
			puts(NCURSES_VERSION);
			return EXIT_SUCCESS;
		case 'c':
			check_only = TRUE;
			break;
		case 'e':
			namelst = make_namelist(optarg);
			break;
		case 'f':
			formatted = TRUE;
			break;
		case 'G':
			numbers = 1;
			break;
		case 'g':
			numbers = -1;
			break;
		case 'o':
			outdir = optarg;
			break;
		case 'r':
			forceresolve = TRUE;
			break;
		case 's':
			showsummary = TRUE;
			break;
		case 'v':
			v_opt = 0;
			break;
		case 'w':
			width = 0;
			break;
#if NCURSES_XNAMES
		case 'x':
			use_extended_names(TRUE);
			break;
#endif
		default:
			usage();
		}
		last_opt = this_opt;
	}

	debug_level = (v_opt > 0) ? v_opt : (v_opt == 0);
	_nc_tracing = (1 << debug_level) - 1;

	if (_nc_tracing)
	{
		save_check_termtype = _nc_check_termtype;
		_nc_check_termtype = check_termtype;
	}

#ifndef HAVE_BIG_CORE
	/*
	 * Aaargh! immedhook seriously hoses us!
	 *
	 * One problem with immedhook is it means we can't do -e.  Problem
	 * is that we can't guarantee that for each terminal listed, all the
	 * terminals it depends on will have been kept in core for reference
	 * resolution -- in fact it's certain the primitive types at the end
	 * of reference chains *won't* be in core unless they were explicitly
	 * in the select list themselves.
	 */
	if (namelst && (!infodump && !capdump))
	{
	    (void) fprintf(stderr,
			   "Sorry, -e can't be used without -I or -C\n");
	    cleanup();
	    return EXIT_FAILURE;
	}
#endif /* HAVE_BIG_CORE */

	if (optind < argc) {
		source_file = argv[optind++];
		if (optind < argc) {
			fprintf (stderr,
				"%s: Too many file names.  Usage:\n\t%s %s",
				_nc_progname,
				_nc_progname,
				usage_string);
			return EXIT_FAILURE;
		}
	} else {
		if (infodump == TRUE) {
			/* captoinfo's no-argument case */
			source_file = "/etc/termcap";
			if ((termcap = getenv("TERMCAP")) != 0
			 && (namelst = make_namelist(getenv("TERM"))) != 0) {
				if (access(termcap, F_OK) == 0) {
					/* file exists */
					source_file = termcap;
				} else
				if ((source_file = tmpnam(my_tmpname)) != 0
				 && (tmp_fp = fopen(source_file, "w")) != 0) {
					fprintf(tmp_fp, "%s\n", termcap);
					fclose(tmp_fp);
					tmp_fp = fopen(source_file, "r");
					to_remove = source_file;
				} else {
					failed("tmpnam");
				}
			}
		} else {
		/* tic */
			fprintf (stderr,
				"%s: File name needed.  Usage:\n\t%s %s",
				_nc_progname,
				_nc_progname,
				usage_string);
			cleanup();
			return EXIT_FAILURE;
		}
	}

	if (tmp_fp == 0
	 && (tmp_fp = fopen(source_file, "r")) == 0) {
		fprintf (stderr, "%s: Can't open %s\n", _nc_progname, source_file);
		return EXIT_FAILURE;
	}

	if (infodump)
		dump_init(tversion,
			  smart_defaults
				? outform
				: F_LITERAL,
			  sortmode, width, debug_level, formatted);
	else if (capdump)
		dump_init(tversion,
			  outform,
			  sortmode, width, debug_level, FALSE);

	/* parse entries out of the source file */
	_nc_set_source(source_file);
#ifndef HAVE_BIG_CORE
	if (!(check_only || infodump || capdump))
	    _nc_set_writedir(outdir);
#endif /* HAVE_BIG_CORE */
	_nc_read_entry_source(tmp_fp, (char *)NULL,
			      !smart_defaults, FALSE,
			      (check_only || infodump || capdump) ? NULLHOOK : immedhook);

	/* do use resolution */
	if (check_only || (!infodump && !capdump) || forceresolve) {
	    if (!_nc_resolve_uses() && !check_only) {
		cleanup();
		return EXIT_FAILURE;
	    }
	}

	/* length check */
	if (check_only && (capdump || infodump))
	{
	    for_entry_list(qp)
	    {
		if (matches(namelst, qp->tterm.term_names))
		{
		    int	len = fmt_entry(&qp->tterm, NULL, TRUE, infodump, numbers);

		    if (len>(infodump?MAX_TERMINFO_LENGTH:MAX_TERMCAP_LENGTH))
			    (void) fprintf(stderr,
			   "warning: resolved %s entry is %d bytes long\n",
			   _nc_first_name(qp->tterm.term_names),
			   len);
		}
	    }
	}

	/* write or dump all entries */
	if (!check_only)
	{
	    if (!infodump && !capdump)
	    {
		_nc_set_writedir(outdir);
		for_entry_list(qp)
		    if (matches(namelst, qp->tterm.term_names))
			write_it(qp);
	    }
	    else
	    {
		/* this is in case infotocap() generates warnings */
		_nc_curr_col = _nc_curr_line = -1;

		for_entry_list(qp)
		    if (matches(namelst, qp->tterm.term_names))
		    {
			int	j = qp->cend - qp->cstart;
			int	len = 0;

			/* this is in case infotocap() generates warnings */
			_nc_set_type(_nc_first_name(qp->tterm.term_names));

			(void) fseek(tmp_fp, qp->cstart, SEEK_SET);
			while (j-- )
			    if (infodump)
				(void) putchar(fgetc(tmp_fp));
			    else
				put_translate(fgetc(tmp_fp));

			len = dump_entry(&qp->tterm, limited, numbers, NULL);
			for (j = 0; j < qp->nuses; j++)
			    len += dump_uses((char *)(qp->uses[j].parent), infodump);
			(void) putchar('\n');
			if (debug_level != 0 && !limited)
			    printf("# length=%d\n", len);
		    }
		if (!namelst)
		{
		    int  c, oldc = '\0';
		    bool in_comment = FALSE;
		    bool trailing_comment = FALSE;

		    (void) fseek(tmp_fp, _nc_tail->cend, SEEK_SET);
		    while ((c = fgetc(tmp_fp)) != EOF)
		    {
			if (oldc == '\n') {
			    if (c == '#') {
				trailing_comment = TRUE;
				in_comment = TRUE;
			    } else {
				in_comment = FALSE;
			    }
			}
			if (trailing_comment
			 && (in_comment || (oldc == '\n' && c == '\n')))
			    putchar(c);
			oldc = c;
		    }
		}
	    }
	}

	/* Show the directory into which entries were written, and the total
	 * number of entries
	 */
	if (showsummary
	 && (!(check_only || infodump || capdump))) {
		int total = _nc_tic_written();
		if (total != 0)
			fprintf(log_fp, "%d entries written to %s\n",
				total,
				_nc_tic_dir((char *)0));
		else
			fprintf(log_fp, "No entries written\n");
	}
	cleanup();
	return(EXIT_SUCCESS);
}

/*
 * This bit of legerdemain turns all the terminfo variable names into
 * references to locations in the arrays Booleans, Numbers, and Strings ---
 * precisely what's needed (see comp_parse.c).
 */

TERMINAL *cur_term;	/* tweak to avoid linking lib_cur_term.c */

#undef CUR
#define CUR tp->

/* other sanity-checks (things that we don't want in the normal
 * logic that reads a terminfo entry)
 */
static void check_termtype(TERMTYPE *tp)
{
	bool conflict = FALSE;
	unsigned j, k;
	char  fkeys[STRCOUNT];

	/*
	 * A terminal entry may contain more than one keycode assigned to
	 * a given string (e.g., KEY_END and KEY_LL).  But curses will only
	 * return one (the last one assigned).
	 */
	memset(fkeys, 0, sizeof(fkeys));
	for (j = 0; _nc_tinfo_fkeys[j].code; j++) {
	    char *a = tp->Strings[_nc_tinfo_fkeys[j].offset];
	    bool first = TRUE;
	    if (!VALID_STRING(a))
		continue;
	    for (k = j+1; _nc_tinfo_fkeys[k].code; k++) {
		char *b = tp->Strings[_nc_tinfo_fkeys[k].offset];
		if (!VALID_STRING(b)
		 || fkeys[k])
		    continue;
		if (!strcmp(a,b)) {
		    fkeys[j] = 1;
		    fkeys[k] = 1;
		    if (first) {
			if (!conflict) {
			    _nc_warning("Conflicting key definitions (using the last)");
			    conflict = TRUE;
			}
			fprintf(stderr, "... %s is the same as %s",
				keyname(_nc_tinfo_fkeys[j].code),
				keyname(_nc_tinfo_fkeys[k].code));
			first = FALSE;
		    } else {
			fprintf(stderr, ", %s",
				keyname(_nc_tinfo_fkeys[k].code));
		    }
		}
	    }
	    if (!first)
		fprintf(stderr, "\n");
	}

	/*
	 * Quick check for color.  We could also check if the ANSI versus
	 * non-ANSI strings are misused.
	 */
	if ((max_colors > 0) != (max_pairs > 0)
	 || (max_colors > max_pairs))
		_nc_warning("inconsistent values for max_colors and max_pairs");

	PAIRED(set_foreground,                  set_background)
	PAIRED(set_a_foreground,                set_a_background)

	/*
	 * These may be mismatched because the terminal description relies on
	 * restoring the cursor visibility by resetting it.
	 */
	ANDMISSING(cursor_invisible,            cursor_normal)
	ANDMISSING(cursor_visible,              cursor_normal)

	/*
	 * From XSI & O'Reilly, we gather that sc/rc are required if csr is
	 * given, because the cursor position after the scrolling operation is
	 * performed is undefined.
	 */
	ANDMISSING(change_scroll_region,	save_cursor)
	ANDMISSING(change_scroll_region,	restore_cursor)

	/*
	 * Some standard applications (e.g., vi) and some non-curses
	 * applications (e.g., jove) get confused if we have both ich/ich1 and
	 * smir/rmir.  Let's be nice and warn about that, too, even though
	 * ncurses handles it.
	 */
	if ((PRESENT(enter_insert_mode) || PRESENT(exit_insert_mode))
	 && (PRESENT(insert_character)  || PRESENT(parm_ich))) {
	   _nc_warning("non-curses applications may be confused by ich/ich1 with smir/rmir");
	}

	/*
	 * Finally, do the non-verbose checks
	 */
	if (save_check_termtype != 0)
	    save_check_termtype(tp);
}