ncurses 5.0
[ncurses.git] / progs / infocmp.c
1 /****************************************************************************
2  * Copyright (c) 1998,1999 Free Software Foundation, Inc.                   *
3  *                                                                          *
4  * Permission is hereby granted, free of charge, to any person obtaining a  *
5  * copy of this software and associated documentation files (the            *
6  * "Software"), to deal in the Software without restriction, including      *
7  * without limitation the rights to use, copy, modify, merge, publish,      *
8  * distribute, distribute with modifications, sublicense, and/or sell       *
9  * copies of the Software, and to permit persons to whom the Software is    *
10  * furnished to do so, subject to the following conditions:                 *
11  *                                                                          *
12  * The above copyright notice and this permission notice shall be included  *
13  * in all copies or substantial portions of the Software.                   *
14  *                                                                          *
15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
16  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
17  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
18  * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
21  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
22  *                                                                          *
23  * Except as contained in this notice, the name(s) of the above copyright   *
24  * holders shall not be used in advertising or otherwise to promote the     *
25  * sale, use or other dealings in this Software without prior written       *
26  * authorization.                                                           *
27  ****************************************************************************/
28
29 /****************************************************************************
30  *  Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995               *
31  *     and: Eric S. Raymond <esr@snark.thyrsus.com>                         *
32  ****************************************************************************/
33
34
35 /*
36  *      infocmp.c -- decompile an entry, or compare two entries
37  *              written by Eric S. Raymond
38  */
39
40 #include <progs.priv.h>
41
42 #include <term_entry.h>
43 #include <dump_entry.h>
44
45 MODULE_ID("$Id: infocmp.c,v 1.44 1999/06/16 00:39:48 tom Exp $")
46
47 #define L_CURL "{"
48 #define R_CURL "}"
49
50 #define MAXTERMS        32      /* max # terminal arguments we can handle */
51
52 const char *_nc_progname = "infocmp";
53
54 typedef char    path[PATH_MAX];
55
56 /***************************************************************************
57  *
58  * The following control variables, together with the contents of the
59  * terminfo entries, completely determine the actions of the program.
60  *
61  ***************************************************************************/
62
63 static char *tname[MAXTERMS];   /* terminal type names */
64 static TERMTYPE term[MAXTERMS]; /* terminfo entries */
65 static int termcount;           /* count of terminal entries */
66
67 static const char *tversion;    /* terminfo version selected */
68 static int numbers = 0;         /* format "%'char'" to/from "%{number}" */
69 static int outform;             /* output format */
70 static int sortmode;            /* sort_mode */
71 static int itrace;              /* trace flag for debugging */
72 static int mwidth = 60;
73
74 /* main comparison mode */
75 static int compare;
76 #define C_DEFAULT       0       /* don't force comparison mode */
77 #define C_DIFFERENCE    1       /* list differences between two terminals */
78 #define C_COMMON        2       /* list common capabilities */
79 #define C_NAND          3       /* list capabilities in neither terminal */
80 #define C_USEALL        4       /* generate relative use-form entry */
81 static bool ignorepads;         /* ignore pad prefixes when diffing */
82
83 #if NO_LEAKS
84 #undef ExitProgram
85 static void ExitProgram(int code) GCC_NORETURN;
86 static void ExitProgram(int code)
87 {
88         while (termcount-- > 0)
89                 _nc_free_termtype(&term[termcount]);
90         _nc_leaks_dump_entry();
91         _nc_free_and_exit(code);
92 }
93 #endif
94
95 static char *canonical_name(char *ptr, char *buf)
96 /* extract the terminal type's primary name */
97 {
98     char        *bp;
99
100     (void) strcpy(buf, ptr);
101     if ((bp = strchr(buf, '|')) != (char *)NULL)
102         *bp = '\0';
103
104     return(buf);
105 }
106
107 /***************************************************************************
108  *
109  * Predicates for dump function
110  *
111  ***************************************************************************/
112
113 static int capcmp(const char *s, const char *t)
114 /* capability comparison function */
115 {
116     if (!VALID_STRING(s) && !VALID_STRING(t))
117         return(0);
118     else if (!VALID_STRING(s) || !VALID_STRING(t))
119         return(1);
120
121     if (ignorepads)
122         return(_nc_capcmp(s, t));
123     else
124         return(strcmp(s, t));
125 }
126
127 static int use_predicate(int type, int idx)
128 /* predicate function to use for use decompilation */
129 {
130         TERMTYPE *tp;
131
132         switch(type)
133         {
134         case BOOLEAN: {
135                 int is_set = FALSE;
136
137                 /*
138                  * This assumes that multiple use entries are supposed
139                  * to contribute the logical or of their boolean capabilities.
140                  * This is true if we take the semantics of multiple uses to
141                  * be 'each capability gets the first non-default value found
142                  * in the sequence of use entries'.
143                  */
144                 for (tp = &term[1]; tp < term + termcount; tp++)
145                         if (tp->Booleans[idx]) {
146                                 is_set = TRUE;
147                                 break;
148                         }
149                         if (is_set != term->Booleans[idx])
150                                 return(!is_set);
151                         else
152                                 return(FAIL);
153                 }
154
155         case NUMBER: {
156                 int     value = ABSENT_NUMERIC;
157
158                 /*
159                  * We take the semantics of multiple uses to be 'each
160                  * capability gets the first non-default value found
161                  * in the sequence of use entries'.
162                  */
163                 for (tp = &term[1]; tp < term + termcount; tp++)
164                         if (tp->Numbers[idx] >= 0) {
165                                 value = tp->Numbers[idx];
166                                 break;
167                         }
168
169                 if (value != term->Numbers[idx])
170                         return(value != ABSENT_NUMERIC);
171                 else
172                         return(FAIL);
173                 }
174
175         case STRING: {
176                 char *termstr, *usestr = ABSENT_STRING;
177
178                 termstr = term->Strings[idx];
179
180                 /*
181                  * We take the semantics of multiple uses to be 'each
182                  * capability gets the first non-default value found
183                  * in the sequence of use entries'.
184                  */
185                 for (tp = &term[1]; tp < term + termcount; tp++)
186                         if (tp->Strings[idx])
187                         {
188                                 usestr = tp->Strings[idx];
189                                 break;
190                         }
191
192                 if (usestr == ABSENT_STRING && termstr == ABSENT_STRING)
193                         return(FAIL);
194                 else if (!usestr || !termstr || capcmp(usestr, termstr))
195                         return(TRUE);
196                 else
197                         return(FAIL);
198             }
199         }
200
201         return(FALSE);  /* pacify compiler */
202 }
203
204 static bool entryeq(TERMTYPE *t1, TERMTYPE *t2)
205 /* are two terminal types equal */
206 {
207     int i;
208
209     for (i = 0; i < NUM_BOOLEANS(t1); i++)
210         if (t1->Booleans[i] != t2->Booleans[i])
211             return(FALSE);
212
213     for (i = 0; i < NUM_NUMBERS(t1); i++)
214         if (t1->Numbers[i] != t2->Numbers[i])
215             return(FALSE);
216
217     for (i = 0; i < NUM_STRINGS(t1); i++)
218         if (capcmp(t1->Strings[i], t2->Strings[i]))
219             return(FALSE);
220
221     return(TRUE);
222 }
223
224 #define TIC_EXPAND(result) _nc_tic_expand(result, outform==F_TERMINFO, numbers)
225
226 static void compare_predicate(int type, int idx, const char *name)
227 /* predicate function to use for entry difference reports */
228 {
229         register TERMTYPE *t1 = &term[0];
230         register TERMTYPE *t2 = &term[1];
231         char *s1, *s2;
232
233         switch(type)
234         {
235         case BOOLEAN:
236                 switch(compare)
237                 {
238                 case C_DIFFERENCE:
239                         if (t1->Booleans[idx] != t2->Booleans[idx])
240                         (void) printf("\t%s: %c:%c.\n",
241                                           name,
242                                           t1->Booleans[idx] ? 'T' : 'F',
243                                           t2->Booleans[idx] ? 'T' : 'F');
244                         break;
245
246                 case C_COMMON:
247                         if (t1->Booleans[idx] && t2->Booleans[idx])
248                         (void) printf("\t%s= T.\n", name);
249                         break;
250
251                 case C_NAND:
252                         if (!t1->Booleans[idx] && !t2->Booleans[idx])
253                         (void) printf("\t!%s.\n", name);
254                         break;
255                 }
256                 break;
257
258         case NUMBER:
259                 switch(compare)
260                 {
261                 case C_DIFFERENCE:
262                         if (t1->Numbers[idx] != t2->Numbers[idx])
263                         (void) printf("\t%s: %d:%d.\n",
264                                           name, t1->Numbers[idx], t2->Numbers[idx]);
265                         break;
266
267                 case C_COMMON:
268                         if (t1->Numbers[idx]!=-1 && t2->Numbers[idx]!=-1
269                                 && t1->Numbers[idx] == t2->Numbers[idx])
270                         (void) printf("\t%s= %d.\n", name, t1->Numbers[idx]);
271                         break;
272
273                 case C_NAND:
274                         if (t1->Numbers[idx]==-1 && t2->Numbers[idx] == -1)
275                         (void) printf("\t!%s.\n", name);
276                         break;
277                 }
278         break;
279
280         case STRING:
281                 s1 = t1->Strings[idx];
282                 s2 = t2->Strings[idx];
283                 switch(compare)
284                 {
285                 case C_DIFFERENCE:
286                         if (capcmp(s1, s2))
287                         {
288                                 char    buf1[BUFSIZ], buf2[BUFSIZ];
289
290                                 if (s1 == (char *)NULL)
291                                         (void) strcpy(buf1, "NULL");
292                                 else
293                                 {
294                                         (void) strcpy(buf1, "'");
295                                         (void) strcat(buf1, TIC_EXPAND(s1));
296                                         (void) strcat(buf1, "'");
297                                 }
298
299                                 if (s2 == (char *)NULL)
300                                         (void) strcpy(buf2, "NULL");
301                                 else
302                                 {
303                                         (void) strcpy(buf2, "'");
304                                         (void) strcat(buf2, TIC_EXPAND(s2));
305                                         (void) strcat(buf2, "'");
306                                 }
307
308                                 if (strcmp(buf1, buf2))
309                                         (void) printf("\t%s: %s, %s.\n",
310                                                       name, buf1, buf2);
311                         }
312                         break;
313
314                 case C_COMMON:
315                         if (s1 && s2 && !capcmp(s1, s2))
316                                 (void) printf("\t%s= '%s'.\n", name, TIC_EXPAND(s1));
317                         break;
318
319                 case C_NAND:
320                         if (!s1 && !s2)
321                                 (void) printf("\t!%s.\n", name);
322                         break;
323                 }
324                 break;
325         }
326
327 }
328
329 /***************************************************************************
330  *
331  * Init string analysis
332  *
333  ***************************************************************************/
334
335 typedef struct {const char *from; const char *to;} assoc;
336
337 static const assoc std_caps[] =
338 {
339     /* these are specified by X.364 and iBCS2 */
340     {"\033c",   "RIS"},         /* full reset */
341     {"\0337",   "SC"},          /* save cursor */
342     {"\0338",   "RC"},          /* restore cursor */
343     {"\033[r",  "RSR"},         /* not an X.364 mnemonic */
344     {"\033[m",  "SGR0"},        /* not an X.364 mnemonic */
345     {"\033[2J", "ED2"},         /* clear page */
346
347     /* this group is specified by ISO 2022 */
348     {"\033(0",  "ISO DEC G0"},  /* enable DEC graphics for G0 */
349     {"\033(A",  "ISO UK G0"},   /* enable UK chars for G0 */
350     {"\033(B",  "ISO US G0"},   /* enable US chars for G0 */
351     {"\033)0",  "ISO DEC G1"},  /* enable DEC graphics for G1 */
352     {"\033)A",  "ISO UK G1"},   /* enable UK chars for G1 */
353     {"\033)B",  "ISO US G1"},   /* enable US chars for G1 */
354
355     /* these are DEC private modes widely supported by emulators */
356     {"\033=",   "DECPAM"},      /* application keypad mode */
357     {"\033>",   "DECPNM"},      /* normal keypad mode */
358     {"\033<",   "DECANSI"},     /* enter ANSI mode */
359
360     { (char *)0, (char *)0}
361 };
362
363 static const assoc private_modes[] =
364 /* DEC \E[ ... [hl] modes recognized by many emulators */
365 {
366     {"1",       "CKM"},         /* application cursor keys */
367     {"2",       "ANM"},         /* set VT52 mode */
368     {"3",       "COLM"},        /* 132-column mode */
369     {"4",       "SCLM"},        /* smooth scroll */
370     {"5",       "SCNM"},        /* reverse video mode */
371     {"6",       "OM"},          /* origin mode */
372     {"7",       "AWM"},         /* wraparound mode */
373     {"8",       "ARM"},         /* auto-repeat mode */
374     {(char *)0, (char *)0}
375 };
376
377 static const assoc ecma_highlights[] =
378 /* recognize ECMA attribute sequences */
379 {
380     {"0",       "NORMAL"},      /* normal */
381     {"1",       "+BOLD"},       /* bold on */
382     {"2",       "+DIM"},        /* dim on */
383     {"3",       "+ITALIC"},     /* italic on */
384     {"4",       "+UNDERLINE"},  /* underline on */
385     {"5",       "+BLINK"},      /* blink on */
386     {"6",       "+FASTBLINK"},  /* fastblink on */
387     {"7",       "+REVERSE"},    /* reverse on */
388     {"8",       "+INVISIBLE"},  /* invisible on */
389     {"9",       "+DELETED"},    /* deleted on */
390     {"10",      "MAIN-FONT"},   /* select primary font */
391     {"11",      "ALT-FONT-1"},  /* select alternate font 1 */
392     {"12",      "ALT-FONT-2"},  /* select alternate font 2 */
393     {"13",      "ALT-FONT-3"},  /* select alternate font 3 */
394     {"14",      "ALT-FONT-4"},  /* select alternate font 4 */
395     {"15",      "ALT-FONT-5"},  /* select alternate font 5 */
396     {"16",      "ALT-FONT-6"},  /* select alternate font 6 */
397     {"17",      "ALT-FONT-7"},  /* select alternate font 7 */
398     {"18",      "ALT-FONT-1"},  /* select alternate font 1 */
399     {"19",      "ALT-FONT-1"},  /* select alternate font 1 */
400     {"20",      "FRAKTUR"},     /* Fraktur font */
401     {"21",      "DOUBLEUNDER"}, /* double underline */
402     {"22",      "-DIM"},        /* dim off */
403     {"23",      "-ITALIC"},     /* italic off */
404     {"24",      "-UNDERLINE"},  /* underline off */
405     {"25",      "-BLINK"},      /* blink off */
406     {"26",      "-FASTBLINK"},  /* fastblink off */
407     {"27",      "-REVERSE"},    /* reverse off */
408     {"28",      "-INVISIBLE"},  /* invisible off */
409     {"29",      "-DELETED"},    /* deleted off */
410     {(char *)0, (char *)0}
411 };
412
413 static void analyze_string(const char *name, const char *cap, TERMTYPE *tp)
414 {
415     char        buf[MAX_TERMINFO_LENGTH];
416     char        buf2[MAX_TERMINFO_LENGTH];
417     const char  *sp, *ep;
418     const assoc *ap;
419
420     if (cap == ABSENT_STRING || cap == CANCELLED_STRING)
421         return;
422     (void) printf("%s: ", name);
423
424     buf[0] = '\0';
425     for (sp = cap; *sp; sp++)
426     {
427         int     i;
428         size_t  len = 0;
429         const char *expansion = 0;
430
431         /* first, check other capabilities in this entry */
432         for (i = 0; i < STRCOUNT; i++)
433         {
434             char        *cp = tp->Strings[i];
435
436             /* don't use soft-key capabilities */
437             if (strnames[i][0] == 'k' && strnames[i][0] == 'f')
438                 continue;
439
440
441             if (cp != ABSENT_STRING && cp != CANCELLED_STRING && cp[0] && cp != cap)
442             {
443                 len = strlen(cp);
444                 (void) strncpy(buf2, sp, len);
445                 buf2[len] = '\0';
446
447                 if (_nc_capcmp(cp, buf2))
448                     continue;
449
450 #define ISRS(s) (!strncmp((s), "is", 2) || !strncmp((s), "rs", 2))
451                 /*
452                  * Theoretically we just passed the test for translation
453                  * (equality once the padding is stripped).  However, there
454                  * are a few more hoops that need to be jumped so that
455                  * identical pairs of initialization and reset strings
456                  * don't just refer to each other.
457                  */
458                 if (ISRS(name) || ISRS(strnames[i]))
459                     if (cap < cp)
460                         continue;
461 #undef ISRS
462
463                 expansion = strnames[i];
464                 break;
465             }
466         }
467
468         /* now check the standard capabilities */
469         if (!expansion)
470             for (ap = std_caps; ap->from; ap++)
471             {
472                 len = strlen(ap->from);
473
474                 if (strncmp(ap->from, sp, len) == 0)
475                 {
476                     expansion = ap->to;
477                     break;
478                 }
479             }
480
481         /* now check for private-mode sequences */
482         if (!expansion
483                     && sp[0] == '\033' && sp[1] == '[' && sp[2] == '?'
484                     && (len = strspn(sp + 3, "0123456789;"))
485                     && ((sp[3 + len] == 'h') || (sp[3 + len] == 'l')))
486         {
487             char        buf3[MAX_TERMINFO_LENGTH];
488
489             (void) strcpy(buf2, (sp[3 + len] == 'h') ? "DEC+" : "DEC-");
490             (void) strncpy(buf3, sp + 3, len);
491             len += 4;
492             buf3[len] = '\0';
493
494             ep = strtok(buf3, ";");
495             do {
496                    bool found = FALSE;
497
498                    for (ap = private_modes; ap->from; ap++)
499                    {
500                        size_t tlen = strlen(ap->from);
501
502                        if (strncmp(ap->from, ep, tlen) == 0)
503                        {
504                            (void) strcat(buf2, ap->to);
505                            found = TRUE;
506                            break;
507                        }
508                    }
509
510                    if (!found)
511                        (void) strcat(buf2, ep);
512                    (void) strcat(buf2, ";");
513                } while
514                    ((ep = strtok((char *)NULL, ";")));
515             buf2[strlen(buf2) - 1] = '\0';
516             expansion = buf2;
517         }
518
519         /* now check for ECMA highlight sequences */
520         if (!expansion
521                     && sp[0] == '\033' && sp[1] == '['
522                     && (len = strspn(sp + 2, "0123456789;"))
523                     && sp[2 + len] == 'm')
524         {
525             char        buf3[MAX_TERMINFO_LENGTH];
526
527             (void) strcpy(buf2, "SGR:");
528             (void) strncpy(buf3, sp + 2, len);
529             len += 3;
530             buf3[len] = '\0';
531
532             ep = strtok(buf3, ";");
533             do {
534                    bool found = FALSE;
535
536                    for (ap = ecma_highlights; ap->from; ap++)
537                    {
538                        size_t tlen = strlen(ap->from);
539
540                        if (strncmp(ap->from, ep, tlen) == 0)
541                        {
542                            (void) strcat(buf2, ap->to);
543                            found = TRUE;
544                            break;
545                        }
546                    }
547
548                    if (!found)
549                        (void) strcat(buf2, ep);
550                    (void) strcat(buf2, ";");
551                } while
552                    ((ep = strtok((char *)NULL, ";")));
553
554             buf2[strlen(buf2) - 1] = '\0';
555             expansion = buf2;
556         }
557         /* now check for scroll region reset */
558         if (!expansion)
559         {
560             (void) sprintf(buf2, "\033[1;%dr", tp->Numbers[2]);
561             len = strlen(buf2);
562             if (strncmp(buf2, sp, len) == 0)
563                 expansion = "RSR";
564         }
565
566         /* now check for home-down */
567         if (!expansion)
568         {
569             (void) sprintf(buf2, "\033[%d;1H", tp->Numbers[2]);
570             len = strlen(buf2);
571             if (strncmp(buf2, sp, len) == 0)
572                     expansion = "LL";
573         }
574
575         /* now look at the expansion we got, if any */
576         if (expansion)
577         {
578             (void) sprintf(buf + strlen(buf), "{%s}", expansion);
579             sp += len - 1;
580             continue;
581         }
582         else
583         {
584             /* couldn't match anything */
585             buf2[0] = *sp;
586             buf2[1] = '\0';
587             (void) strcat(buf, TIC_EXPAND(buf2));
588         }
589     }
590     (void) printf("%s\n", buf);
591 }
592
593 /***************************************************************************
594  *
595  * File comparison
596  *
597  ***************************************************************************/
598
599 static void file_comparison(int argc, char *argv[])
600 {
601 #define MAXCOMPARE      2
602     /* someday we may allow comparisons on more files */
603     int filecount = 0;
604     ENTRY       *heads[MAXCOMPARE];
605     ENTRY       *tails[MAXCOMPARE];
606     ENTRY       *qp, *rp;
607     int         i, n;
608
609     dump_init((char *)NULL, F_LITERAL, S_TERMINFO, 0, itrace, FALSE);
610
611     for (n = 0; n < argc && n < MAXCOMPARE; n++)
612     {
613         if (freopen(argv[n], "r", stdin) == NULL)
614             _nc_err_abort("Can't open %s", argv[n]);
615
616         _nc_head = _nc_tail = (ENTRY *)NULL;
617
618         /* parse entries out of the source file */
619         _nc_set_source(argv[n]);
620         _nc_read_entry_source(stdin, NULL, TRUE, FALSE, NULLHOOK);
621
622         if (itrace)
623             (void) fprintf(stderr, "Resolving file %d...\n", n-0);
624
625         /* do use resolution */
626         if (!_nc_resolve_uses())
627         {
628             (void) fprintf(stderr,
629                            "There are unresolved use entries in %s:\n",
630                            argv[n]);
631             for_entry_list(qp)
632                 if (qp->nuses)
633                 {
634                     (void) fputs(qp->tterm.term_names, stderr);
635                     (void) fputc('\n', stderr);
636                 }
637             exit(EXIT_FAILURE);
638         }
639
640         heads[filecount] = _nc_head;
641         tails[filecount] = _nc_tail;
642         filecount++;
643     }
644
645     /* OK, all entries are in core.  Ready to do the comparison */
646     if (itrace)
647         (void) fprintf(stderr, "Entries are now in core...\n");
648
649     /*
650      * The entry-matching loop.  We're not using the use[]
651      * slots any more (they got zeroed out by resolve_uses) so
652      * we stash each entry's matches in the other file there.
653      * Sigh, this is intrinsically quadratic.
654      */
655     for (qp = heads[0]; qp; qp = qp->next)
656     {
657         for (rp = heads[1]; rp; rp = rp->next)
658             if (_nc_entry_match(qp->tterm.term_names, rp->tterm.term_names))
659             {
660                 /*
661                  * This is why the uses structure parent element is
662                  * (void *) -- so we can have either (char *) for
663                  * names or entry structure pointers in them and still
664                  * be type-safe.
665                  */
666                 if (qp->nuses < MAX_USES)
667                     qp->uses[qp->nuses].parent = (void *)rp;
668                 qp->nuses++;
669
670                 if (rp->nuses < MAX_USES)
671                     rp->uses[rp->nuses].parent = (void *)qp;
672                 rp->nuses++;
673             }
674     }
675
676     /* now we have two circular lists with crosslinks */
677     if (itrace)
678         (void) fprintf(stderr, "Name matches are done...\n");
679
680     for (qp = heads[0]; qp; qp = qp->next)
681         if (qp->nuses > 1)
682         {
683             (void) fprintf(stderr,
684                            "%s in file 1 (%s) has %d matches in file 2 (%s):\n",
685                            _nc_first_name(qp->tterm.term_names),
686                            argv[0],
687                            qp->nuses,
688                            argv[1]);
689             for (i = 0; i < qp->nuses; i++)
690                 (void) fprintf(stderr,
691                                "\t%s\n",
692                                _nc_first_name(((ENTRY *)qp->uses[i].parent)->tterm.term_names));
693         }
694     for (rp = heads[1]; rp; rp = rp->next)
695         if (rp->nuses > 1)
696         {
697             (void) fprintf(stderr,
698                            "%s in file 2 (%s) has %d matches in file 1 (%s):\n",
699                            _nc_first_name(rp->tterm.term_names),
700                            argv[1],
701                            rp->nuses,
702                            argv[0]);
703             for (i = 0; i < rp->nuses; i++)
704                 (void) fprintf(stderr,
705                                "\t%s\n",
706                                _nc_first_name(((ENTRY *)rp->uses[i].parent)->tterm.term_names));
707         }
708
709     (void) printf("In file 1 (%s) only:\n", argv[0]);
710     for (qp = heads[0]; qp; qp = qp->next)
711         if (qp->nuses == 0)
712             (void) printf("\t%s\n",
713                           _nc_first_name(qp->tterm.term_names));
714
715     (void) printf("In file 2 (%s) only:\n", argv[1]);
716     for (rp = heads[1]; rp; rp = rp->next)
717         if (rp->nuses == 0)
718             (void) printf("\t%s\n",
719                           _nc_first_name(rp->tterm.term_names));
720
721     (void) printf("The following entries are equivalent:\n");
722     for (qp = heads[0]; qp; qp = qp->next)
723     {
724         rp = (ENTRY *)qp->uses[0].parent;
725
726         if (qp->nuses == 1 && entryeq(&qp->tterm, &rp->tterm))
727         {
728             char name1[NAMESIZE], name2[NAMESIZE];
729
730             (void) canonical_name(qp->tterm.term_names, name1);
731             (void) canonical_name(rp->tterm.term_names, name2);
732
733             (void) printf("%s = %s\n", name1, name2);
734         }
735     }
736
737     (void) printf("Differing entries:\n");
738     termcount = 2;
739     for (qp = heads[0]; qp; qp = qp->next)
740     {
741         rp = (ENTRY *)qp->uses[0].parent;
742
743 #if NCURSES_XNAMES
744         if (termcount > 1)
745             _nc_align_termtype(&qp->tterm, &rp->tterm);
746 #endif
747         if (qp->nuses == 1 && !entryeq(&qp->tterm, &rp->tterm))
748         {
749             char name1[NAMESIZE], name2[NAMESIZE];
750
751             term[0] = qp->tterm;
752             term[1] = rp->tterm;
753
754             (void) canonical_name(qp->tterm.term_names, name1);
755             (void) canonical_name(rp->tterm.term_names, name2);
756
757             switch (compare)
758             {
759             case C_DIFFERENCE:
760                 if (itrace)
761                     (void)fprintf(stderr, "infocmp: dumping differences\n");
762                 (void) printf("comparing %s to %s.\n", name1, name2);
763                 compare_entry(compare_predicate, term);
764                 break;
765
766             case C_COMMON:
767                 if (itrace)
768                     (void) fprintf(stderr,
769                                    "infocmp: dumping common capabilities\n");
770                 (void) printf("comparing %s to %s.\n", name1, name2);
771                 compare_entry(compare_predicate, term);
772                 break;
773
774             case C_NAND:
775                 if (itrace)
776                     (void) fprintf(stderr,
777                                    "infocmp: dumping differences\n");
778                 (void) printf("comparing %s to %s.\n", name1, name2);
779                 compare_entry(compare_predicate, term);
780                 break;
781
782             }
783         }
784     }
785 }
786
787 static void usage(void)
788 {
789         static const char *tbl[] = {
790              "Usage: infocmp [options] [-A directory] [-B directory] [termname...]"
791             ,""
792             ,"Options:"
793             ,"  -1    print single-column"
794             ,"  -C    use termcap-names"
795             ,"  -F    compare terminfo-files"
796             ,"  -I    use terminfo-names"
797             ,"  -L    use long names"
798             ,"  -R subset (see manpage)"
799             ,"  -T    eliminate size limits (test)"
800             ,"  -V    print version"
801             ,"  -c    list common capabilities"
802             ,"  -d    list different capabilities"
803             ,"  -e    format output for C initializer"
804             ,"  -E    format output as C tables"
805             ,"  -f    with -1, format complex strings"
806             ,"  -G    format %{number} to %'char'"
807             ,"  -g    format %'char' to %{number}"
808             ,"  -i    analyze initialization/reset"
809             ,"  -l    output terminfo names"
810             ,"  -n    list capabilities in neither"
811             ,"  -p    ignore padding specifiers"
812             ,"  -r    with -C, output in termcap form"
813             ,"  -s [d|i|l|c] sort fields"
814             ,"  -u    produce source with 'use='"
815             ,"  -v number  (verbose)"
816             ,"  -w number  (width)"
817         };
818         const size_t first = 3;
819         const size_t last = sizeof(tbl)/sizeof(tbl[0]);
820         const size_t left = (last - first + 1) / 2 + first;
821         size_t n;
822
823         for (n = 0; n < left; n++) {
824                 size_t m = (n < first) ? last : n + left - first;
825                 if (m < last)
826                         fprintf(stderr, "%-40.40s%s\n", tbl[n], tbl[m]);
827                 else
828                         fprintf(stderr, "%s\n", tbl[n]);
829         }
830         exit(EXIT_FAILURE);
831 }
832
833 static char * name_initializer(const char *type)
834 {
835     static char *initializer;
836     char *s;
837
838     if (initializer == 0)
839         initializer = malloc(strlen(term->term_names) + 20);
840
841     (void) sprintf(initializer, "%s_data_%s", type, term->term_names);
842     for (s = initializer; *s != 0 && *s != '|'; s++)
843     {
844         if (!isalnum(*s))
845             *s = '_';
846     }
847     *s = 0;
848     return initializer;
849 }
850
851 /* dump C initializers for the terminal type */
852 static void dump_initializers(void)
853 {
854     int n;
855     const char *str = 0;
856     int size;
857
858     (void) printf("static bool %s[] = %s\n", name_initializer("bool"), L_CURL);
859
860     for_each_boolean(n,term)
861     {
862         switch((int)(term->Booleans[n]))
863         {
864         case TRUE:
865             str = "TRUE";
866             break;
867
868         case FALSE:
869             str = "FALSE";
870             break;
871
872         case ABSENT_BOOLEAN:
873             str = "ABSENT_BOOLEAN";
874             break;
875
876         case CANCELLED_BOOLEAN:
877             str = "CANCELLED_BOOLEAN";
878             break;
879         }
880         (void) printf("\t/* %3d: %-8s */\t%s,\n",
881                       n, ExtBoolname(term,n,boolnames), str);
882     }
883     (void) printf("%s;\n", R_CURL);
884
885     (void) printf("static short %s[] = %s\n", name_initializer("number"), L_CURL);
886
887     for_each_number(n,term)
888     {
889         char    buf[BUFSIZ];
890         switch (term->Numbers[n])
891         {
892         case ABSENT_NUMERIC:
893             str = "ABSENT_NUMERIC";
894             break;
895         case CANCELLED_NUMERIC:
896             str = "CANCELLED_NUMERIC";
897             break;
898         default:
899             sprintf(buf, "%d", term->Numbers[n]);
900             str = buf;
901             break;
902         }
903         (void) printf("\t/* %3d: %-8s */\t%s,\n", n, ExtNumname(term,n,numnames), str);
904     }
905     (void) printf("%s;\n", R_CURL);
906
907     size = sizeof(TERMTYPE)
908         + (NUM_BOOLEANS(term) * sizeof(term->Booleans[0]))
909         + (NUM_NUMBERS(term) * sizeof(term->Numbers[0]));
910
911     (void) printf("static char * %s[] = %s\n", name_initializer("string"), L_CURL);
912
913     for_each_string(n,term)
914     {
915         char    buf[BUFSIZ], *sp, *tp;
916
917         if (term->Strings[n] == ABSENT_STRING)
918             str = "ABSENT_STRING";
919         else if (term->Strings[n] == CANCELLED_STRING)
920             str = "CANCELLED_STRING";
921         else
922         {
923             tp = buf;
924             *tp++ = '"';
925             for (sp = term->Strings[n]; *sp; sp++)
926             {
927                 if (isascii(*sp) && isprint(*sp) && *sp !='\\' && *sp != '"')
928                     *tp++ = *sp;
929                 else
930                 {
931                     (void) sprintf(tp, "\\%03o", *sp & 0xff);
932                     tp += 4;
933                 }
934             }
935             *tp++ = '"';
936             *tp = '\0';
937             size += (strlen(term->Strings[n]) + 1);
938             str = buf;
939         }
940 #if NCURSES_XNAMES
941         if (n == STRCOUNT)
942         {
943             (void) printf("%s;\n", R_CURL);
944
945             (void) printf("static char * %s[] = %s\n", name_initializer("string_ext"), L_CURL);
946         }
947 #endif
948         (void) printf("\t/* %3d: %-8s */\t%s,\n", n, ExtStrname(term,n,strnames), str);
949     }
950     (void) printf("%s;\n", R_CURL);
951 }
952
953 /* dump C initializers for the terminal type */
954 static void dump_termtype(void)
955 {
956     (void) printf("\t%s\n\t\t\"%s\",\n", L_CURL, term->term_names);
957     (void) printf("\t\t(char *)0,\t/* pointer to string table */\n");
958
959     (void) printf("\t\t%s,\n", name_initializer("bool"));
960     (void) printf("\t\t%s,\n", name_initializer("number"));
961
962     (void) printf("\t\t%s,\n", name_initializer("string"));
963
964 #if NCURSES_XNAMES
965     (void) printf("#if NCURSES_XNAMES\n");
966     (void) printf("\t\t(char *)0,\t/* pointer to extended string table */\n");
967     (void) printf("\t\t%s,\t/* ...corresponding names */\n",
968         (NUM_STRINGS(term) != STRCOUNT)
969             ? name_initializer("string_ext")
970             : "(char **)0");
971
972     (void) printf("\t\t%d,\t\t/* count total Booleans */\n", NUM_BOOLEANS(term));
973     (void) printf("\t\t%d,\t\t/* count total Numbers */\n",  NUM_NUMBERS(term));
974     (void) printf("\t\t%d,\t\t/* count total Strings */\n",  NUM_STRINGS(term));
975
976     (void) printf("\t\t%d,\t\t/* count extensions to Booleans */\n", NUM_BOOLEANS(term) - BOOLCOUNT);
977     (void) printf("\t\t%d,\t\t/* count extensions to Numbers */\n",  NUM_NUMBERS(term) - NUMCOUNT);
978     (void) printf("\t\t%d,\t\t/* count extensions to Strings */\n",  NUM_STRINGS(term) - STRCOUNT);
979
980     (void) printf("#endif /* NCURSES_XNAMES */\n");
981 #endif /* NCURSES_XNAMES */
982     (void) printf("\t%s\n", R_CURL);
983 }
984
985 /***************************************************************************
986  *
987  * Main sequence
988  *
989  ***************************************************************************/
990
991 int main(int argc, char *argv[])
992 {
993         char *terminal, *firstdir, *restdir;
994         /* Avoid "local data >32k" error with mwcc */
995         /* Also avoid overflowing smaller stacks on systems like AmigaOS */
996         path *tfile = malloc(sizeof(path)*MAXTERMS);
997         int c, i, len;
998         bool formatted = FALSE;
999         bool filecompare = FALSE;
1000         int initdump = 0;
1001         bool init_analyze = FALSE;
1002         bool limited = TRUE;
1003
1004         if ((terminal = getenv("TERM")) == NULL)
1005         {
1006                 (void) fprintf(stderr,
1007                         "infocmp: environment variable TERM not set\n");
1008                 return EXIT_FAILURE;
1009         }
1010
1011         /* where is the terminfo database location going to default to? */
1012         restdir = firstdir = 0;
1013
1014         while ((c = getopt(argc, argv, "deEcCfFGgIinlLprR:s:uv:Vw:A:B:1T")) != EOF)
1015                 switch (c)
1016                 {
1017                 case 'd':
1018                         compare = C_DIFFERENCE;
1019                         break;
1020
1021                 case 'e':
1022                         initdump |= 1;
1023                         break;
1024
1025                 case 'E':
1026                         initdump |= 2;
1027                         break;
1028
1029                 case 'c':
1030                         compare = C_COMMON;
1031                         break;
1032
1033                 case 'C':
1034                         outform = F_TERMCAP;
1035                         tversion = "BSD";
1036                         if (sortmode == S_DEFAULT)
1037                             sortmode = S_TERMCAP;
1038                         break;
1039
1040                 case 'f':
1041                         formatted = TRUE;
1042                         break;
1043
1044                 case 'G':
1045                         numbers = 1;
1046                         break;
1047
1048                 case 'g':
1049                         numbers = -1;
1050                         break;
1051
1052                 case 'F':
1053                         filecompare = TRUE;
1054                         break;
1055
1056                 case 'I':
1057                         outform = F_TERMINFO;
1058                         if (sortmode == S_DEFAULT)
1059                             sortmode = S_VARIABLE;
1060                         tversion = 0;
1061                         break;
1062
1063                 case 'i':
1064                         init_analyze = TRUE;
1065                         break;
1066
1067                 case 'l':
1068                         outform = F_TERMINFO;
1069                         break;
1070
1071                 case 'L':
1072                         outform = F_VARIABLE;
1073                         if (sortmode == S_DEFAULT)
1074                             sortmode = S_VARIABLE;
1075                         break;
1076
1077                 case 'n':
1078                         compare = C_NAND;
1079                         break;
1080
1081                 case 'p':
1082                         ignorepads = TRUE;
1083                         break;
1084
1085                 case 'r':
1086                         tversion = 0;
1087                         limited = FALSE;
1088                         break;
1089
1090                 case 'R':
1091                         tversion = optarg;
1092                         break;
1093
1094                 case 's':
1095                         if (*optarg == 'd')
1096                                 sortmode = S_NOSORT;
1097                         else if (*optarg == 'i')
1098                                 sortmode = S_TERMINFO;
1099                         else if (*optarg == 'l')
1100                                 sortmode = S_VARIABLE;
1101                         else if (*optarg == 'c')
1102                                 sortmode = S_TERMCAP;
1103                         else
1104                         {
1105                                 (void) fprintf(stderr,
1106                                                "infocmp: unknown sort mode\n");
1107                                 return EXIT_FAILURE;
1108                         }
1109                         break;
1110
1111                 case 'u':
1112                         compare = C_USEALL;
1113                         break;
1114
1115                 case 'v':
1116                         itrace = atoi(optarg);
1117                         _nc_tracing = (1 << itrace) - 1;
1118                         break;
1119
1120                 case 'V':
1121                         (void) fputs(NCURSES_VERSION, stdout);
1122                         putchar('\n');
1123                         ExitProgram(EXIT_SUCCESS);
1124
1125                 case 'w':
1126                         mwidth = atoi(optarg);
1127                         break;
1128
1129                 case 'A':
1130                         firstdir = optarg;
1131                         break;
1132
1133                 case 'B':
1134                         restdir = optarg;
1135                         break;
1136
1137                 case '1':
1138                         mwidth = 0;
1139                         break;
1140
1141                 case 'T':
1142                         limited = FALSE;
1143                         break;
1144                 default:
1145                         usage();
1146                 }
1147
1148         /* by default, sort by terminfo name */
1149         if (sortmode == S_DEFAULT)
1150                 sortmode = S_TERMINFO;
1151
1152         /* set up for display */
1153         dump_init(tversion, outform, sortmode, mwidth, itrace, formatted);
1154
1155         /* make sure we have at least one terminal name to work with */
1156         if (optind >= argc)
1157                 argv[argc++] = terminal;
1158
1159         /* if user is after a comparison, make sure we have two entries */
1160         if (compare != C_DEFAULT && optind >= argc - 1)
1161                 argv[argc++] = terminal;
1162
1163         /* exactly two terminal names with no options means do -d */
1164         if (argc - optind == 2 && compare == C_DEFAULT)
1165                 compare = C_DIFFERENCE;
1166
1167         if (!filecompare)
1168         {
1169             /* grab the entries */
1170             termcount = 0;
1171             for (; optind < argc; optind++)
1172             {
1173                 if (termcount >= MAXTERMS)
1174                 {
1175                     (void) fprintf(stderr,
1176                            "infocmp: too many terminal type arguments\n");
1177                     return EXIT_FAILURE;
1178                 }
1179                 else
1180                 {
1181                     const char  *directory = termcount ? restdir : firstdir;
1182                     int         status;
1183
1184                     tname[termcount] = argv[optind];
1185
1186                     if (directory)
1187                     {
1188                         (void) sprintf(tfile[termcount], "%s/%c/%s",
1189                                        directory,
1190                                        *argv[optind], argv[optind]);
1191                         if (itrace)
1192                             (void) fprintf(stderr,
1193                                            "infocmp: reading entry %s from file %s\n",
1194                                            argv[optind], tfile[termcount]);
1195
1196                         status = _nc_read_file_entry(tfile[termcount],
1197                                                      &term[termcount]);
1198                     }
1199                     else
1200                     {
1201                         if (itrace)
1202                             (void) fprintf(stderr,
1203                                            "infocmp: reading entry %s from system directories %s\n",
1204                                            argv[optind], tname[termcount]);
1205
1206                         status = _nc_read_entry(tname[termcount],
1207                                                 tfile[termcount],
1208                                                 &term[termcount]);
1209                         directory = TERMINFO;   /* for error message */
1210                     }
1211
1212                     if (status <= 0)
1213                     {
1214                         (void) fprintf(stderr,
1215                                        "infocmp: couldn't open terminfo file %s.\n",
1216                                        tfile[termcount]);
1217                         return EXIT_FAILURE;
1218                     }
1219                     termcount++;
1220                 }
1221             }
1222
1223 #if NCURSES_XNAMES
1224             if (termcount > 1)
1225                 _nc_align_termtype(&term[0], &term[1]);
1226 #endif
1227
1228             /* dump as C initializer for the terminal type */
1229             if (initdump)
1230             {
1231                 if (initdump & 1)
1232                     dump_termtype();
1233                 if (initdump & 2)
1234                     dump_initializers();
1235                 ExitProgram(EXIT_SUCCESS);
1236             }
1237
1238             /* analyze the init strings */
1239             if (init_analyze)
1240             {
1241 #undef CUR
1242 #define CUR     term[0].
1243                 analyze_string("is1", init_1string, &term[0]);
1244                 analyze_string("is2", init_2string, &term[0]);
1245                 analyze_string("is3", init_3string, &term[0]);
1246                 analyze_string("rs1", reset_1string, &term[0]);
1247                 analyze_string("rs2", reset_2string, &term[0]);
1248                 analyze_string("rs3", reset_3string, &term[0]);
1249                 analyze_string("smcup", enter_ca_mode, &term[0]);
1250                 analyze_string("rmcup", exit_ca_mode, &term[0]);
1251 #undef CUR
1252                 ExitProgram(EXIT_SUCCESS);
1253             }
1254
1255             /*
1256              * Here's where the real work gets done
1257              */
1258             switch (compare)
1259             {
1260             case C_DEFAULT:
1261                 if (itrace)
1262                     (void) fprintf(stderr,
1263                                    "infocmp: about to dump %s\n",
1264                                    tname[0]);
1265                 (void) printf("#\tReconstructed via infocmp from file: %s\n",
1266                               tfile[0]);
1267                 len = dump_entry(&term[0], limited, numbers, NULL);
1268                 putchar('\n');
1269                 if (itrace)
1270                     (void)fprintf(stderr, "infocmp: length %d\n", len);
1271                 break;
1272
1273             case C_DIFFERENCE:
1274                 if (itrace)
1275                     (void)fprintf(stderr, "infocmp: dumping differences\n");
1276                 (void) printf("comparing %s to %s.\n", tname[0], tname[1]);
1277                 compare_entry(compare_predicate, term);
1278                 break;
1279
1280             case C_COMMON:
1281                 if (itrace)
1282                     (void) fprintf(stderr,
1283                                    "infocmp: dumping common capabilities\n");
1284                 (void) printf("comparing %s to %s.\n", tname[0], tname[1]);
1285                 compare_entry(compare_predicate, term);
1286                 break;
1287
1288             case C_NAND:
1289                 if (itrace)
1290                     (void) fprintf(stderr,
1291                                    "infocmp: dumping differences\n");
1292                 (void) printf("comparing %s to %s.\n", tname[0], tname[1]);
1293                 compare_entry(compare_predicate, term);
1294                 break;
1295
1296             case C_USEALL:
1297                 if (itrace)
1298                     (void) fprintf(stderr, "infocmp: dumping use entry\n");
1299                 len = dump_entry(&term[0], limited, numbers, use_predicate);
1300                 for (i = 1; i < termcount; i++)
1301                     len += dump_uses(tname[i], !(outform==F_TERMCAP || outform==F_TCONVERR));
1302                 putchar('\n');
1303                 if (itrace)
1304                     (void)fprintf(stderr, "infocmp: length %d\n", len);
1305                 break;
1306             }
1307         }
1308         else if (compare == C_USEALL)
1309             (void) fprintf(stderr, "Sorry, -u doesn't work with -F\n");
1310         else if (compare == C_DEFAULT)
1311             (void) fprintf(stderr, "Use `tic -[CI] <file>' for this.\n");
1312         else if (argc - optind != 2)
1313             (void) fprintf(stderr,
1314                 "File comparison needs exactly two file arguments.\n");
1315         else
1316             file_comparison(argc-optind, argv+optind);
1317
1318         ExitProgram(EXIT_SUCCESS);
1319 }
1320
1321 /* infocmp.c ends here */