ncurses 6.1 - patch 20190105
[ncurses.git] / progs / infocmp.c
index add5efb9b4d09030c9c79451b0cfe62379f7ac5f..82c48419a047f6ddce2ff02d350c103b604b7ad7 100644 (file)
@@ -1,5 +1,5 @@
 /****************************************************************************
 /****************************************************************************
- * Copyright (c) 1998,1999,2000 Free Software Foundation, Inc.              *
+ * Copyright (c) 1998-2016,2017 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            *
  *                                                                          *
  * Permission is hereby granted, free of charge, to any person obtaining a  *
  * copy of this software and associated documentation files (the            *
 /****************************************************************************
  *  Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995               *
  *     and: Eric S. Raymond <esr@snark.thyrsus.com>                         *
 /****************************************************************************
  *  Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995               *
  *     and: Eric S. Raymond <esr@snark.thyrsus.com>                         *
+ *     and: Thomas E. Dickey                        1996-on                 *
  ****************************************************************************/
 
 /*
  *     infocmp.c -- decompile an entry, or compare two entries
  *             written by Eric S. Raymond
  ****************************************************************************/
 
 /*
  *     infocmp.c -- decompile an entry, or compare two entries
  *             written by Eric S. Raymond
+ *             and Thomas E Dickey
  */
 
 #include <progs.priv.h>
 
  */
 
 #include <progs.priv.h>
 
-#include <term_entry.h>
 #include <dump_entry.h>
 
 #include <dump_entry.h>
 
-MODULE_ID("$Id: infocmp.c,v 1.54 2000/03/19 02:56:14 tom Exp $")
+MODULE_ID("$Id: infocmp.c,v 1.143 2017/04/05 09:27:51 tom Exp $")
 
 
-#define L_CURL "{"
-#define R_CURL "}"
-
-#define MAXTERMS       32      /* max # terminal arguments we can handle */
 #define MAX_STRING     1024    /* maximum formatted string */
 
 const char *_nc_progname = "infocmp";
 #define MAX_STRING     1024    /* maximum formatted string */
 
 const char *_nc_progname = "infocmp";
@@ -60,20 +57,21 @@ typedef char path[PATH_MAX];
  *
  ***************************************************************************/
 
  *
  ***************************************************************************/
 
-static char *tname[MAXTERMS];  /* terminal type names */
-static ENTRY entries[MAXTERMS];        /* terminfo entries */
+static ENTRY *entries;         /* terminfo entries */
 static int termcount;          /* count of terminal entries */
 
 static bool limited = TRUE;    /* "-r" option is not set */
 static bool quiet = FALSE;
 static int termcount;          /* count of terminal entries */
 
 static bool limited = TRUE;    /* "-r" option is not set */
 static bool quiet = FALSE;
+static bool literal = FALSE;
 static const char *bool_sep = ":";
 static const char *s_absent = "NULL";
 static const char *s_cancel = "NULL";
 static const char *tversion;   /* terminfo version selected */
 static const char *bool_sep = ":";
 static const char *s_absent = "NULL";
 static const char *s_cancel = "NULL";
 static const char *tversion;   /* terminfo version selected */
-static int itrace;             /* trace flag for debugging */
+static unsigned itrace;                /* trace flag for debugging */
 static int mwidth = 60;
 static int mwidth = 60;
+static int mheight = 65535;
 static int numbers = 0;                /* format "%'char'" to/from "%{number}" */
 static int numbers = 0;                /* format "%'char'" to/from "%{number}" */
-static int outform = F_TERMINFO;/* output format */
+static int outform = F_TERMINFO;       /* output format */
 static int sortmode;           /* sort_mode */
 
 /* main comparison mode */
 static int sortmode;           /* sort_mode */
 
 /* main comparison mode */
@@ -86,33 +84,85 @@ static int compare;
 static bool ignorepads;                /* ignore pad prefixes when diffing */
 
 #if NO_LEAKS
 static bool ignorepads;                /* ignore pad prefixes when diffing */
 
 #if NO_LEAKS
+
+typedef struct {
+    ENTRY *head;
+    ENTRY *tail;
+} ENTERED;
+
+static ENTERED *entered;
+
 #undef ExitProgram
 #undef ExitProgram
-static void
-ExitProgram(int code) GCC_NORETURN;
+static void ExitProgram(int code) GCC_NORETURN;
 /* prototype is to get gcc to accept the noreturn attribute */
 static void
 ExitProgram(int code)
 {
 /* prototype is to get gcc to accept the noreturn attribute */
 static void
 ExitProgram(int code)
 {
-    while (termcount-- > 0)
-       _nc_free_termtype(&entries[termcount].tterm);
+    int n;
+
+    for (n = 0; n < termcount; ++n) {
+       ENTRY *new_head = _nc_head;
+       ENTRY *new_tail = _nc_tail;
+       _nc_head = entered[n].head;
+       _nc_tail = entered[n].tail;
+       _nc_free_entries(entered[n].head);
+       _nc_head = new_head;
+       _nc_tail = new_tail;
+    }
     _nc_leaks_dump_entry();
     _nc_leaks_dump_entry();
-    _nc_free_and_exit(code);
+    free(entries);
+    free(entered);
+    _nc_free_tic(code);
 }
 #endif
 
 }
 #endif
 
+static void
+failed(const char *s)
+{
+    perror(s);
+    ExitProgram(EXIT_FAILURE);
+}
+
 static char *
 canonical_name(char *ptr, char *buf)
 /* extract the terminal type's primary name */
 {
     char *bp;
 
 static char *
 canonical_name(char *ptr, char *buf)
 /* extract the terminal type's primary name */
 {
     char *bp;
 
-    (void) strcpy(buf, ptr);
+    _nc_STRCPY(buf, ptr, NAMESIZE);
     if ((bp = strchr(buf, '|')) != 0)
        *bp = '\0';
 
     return (buf);
 }
 
     if ((bp = strchr(buf, '|')) != 0)
        *bp = '\0';
 
     return (buf);
 }
 
+static bool
+no_boolean(int value)
+{
+    bool result = (value == ABSENT_BOOLEAN);
+    if (!strcmp(s_absent, s_cancel))
+       result = !VALID_BOOLEAN(value);
+    return result;
+}
+
+static bool
+no_numeric(int value)
+{
+    bool result = (value == ABSENT_NUMERIC);
+    if (!strcmp(s_absent, s_cancel))
+       result = !VALID_NUMERIC(value);
+    return result;
+}
+
+static bool
+no_string(char *value)
+{
+    bool result = (value == ABSENT_STRING);
+    if (!strcmp(s_absent, s_cancel))
+       result = !VALID_STRING(value);
+    return result;
+}
+
 /***************************************************************************
  *
  * Predicates for dump function
 /***************************************************************************
  *
  * Predicates for dump function
@@ -120,7 +170,7 @@ canonical_name(char *ptr, char *buf)
  ***************************************************************************/
 
 static int
  ***************************************************************************/
 
 static int
-capcmp(int idx, const char *s, const char *t)
+capcmp(PredIdx idx, const char *s, const char *t)
 /* capability comparison function */
 {
     if (!VALID_STRING(s) && !VALID_STRING(t))
 /* capability comparison function */
 {
     if (!VALID_STRING(s) && !VALID_STRING(t))
@@ -135,7 +185,7 @@ capcmp(int idx, const char *s, const char *t)
 }
 
 static int
 }
 
 static int
-use_predicate(int type, int idx)
+use_predicate(unsigned type, PredIdx idx)
 /* predicate function to use for use decompilation */
 {
     ENTRY *ep;
 /* predicate function to use for use decompilation */
 {
     ENTRY *ep;
@@ -221,7 +271,7 @@ static bool
 useeq(ENTRY * e1, ENTRY * e2)
 /* are the use references in two entries equivalent? */
 {
 useeq(ENTRY * e1, ENTRY * e2)
 /* are the use references in two entries equivalent? */
 {
-    int i, j;
+    unsigned i, j;
 
     if (e1->nuses != e2->nuses)
        return (FALSE);
 
     if (e1->nuses != e2->nuses)
        return (FALSE);
@@ -245,10 +295,10 @@ useeq(ENTRY * e1, ENTRY * e2)
 }
 
 static bool
 }
 
 static bool
-entryeq(TERMTYPE * t1, TERMTYPE * t2)
+entryeq(TERMTYPE2 *t1, TERMTYPE2 *t2)
 /* are two entries equivalent? */
 {
 /* are two entries equivalent? */
 {
-    int i;
+    unsigned i;
 
     for (i = 0; i < NUM_BOOLEANS(t1); i++)
        if (t1->Booleans[i] != t2->Booleans[i])
 
     for (i = 0; i < NUM_BOOLEANS(t1); i++)
        if (t1->Booleans[i] != t2->Booleans[i])
@@ -259,7 +309,7 @@ entryeq(TERMTYPE * t1, TERMTYPE * t2)
            return (FALSE);
 
     for (i = 0; i < NUM_STRINGS(t1); i++)
            return (FALSE);
 
     for (i = 0; i < NUM_STRINGS(t1); i++)
-       if (capcmp(i, t1->Strings[i], t2->Strings[i]))
+       if (capcmp((PredIdx) i, t1->Strings[i], t2->Strings[i]))
            return (FALSE);
 
     return (TRUE);
            return (FALSE);
 
     return (TRUE);
@@ -268,10 +318,10 @@ entryeq(TERMTYPE * t1, TERMTYPE * t2)
 #define TIC_EXPAND(result) _nc_tic_expand(result, outform==F_TERMINFO, numbers)
 
 static void
 #define TIC_EXPAND(result) _nc_tic_expand(result, outform==F_TERMINFO, numbers)
 
 static void
-print_uses(ENTRY * ep, FILE * fp)
+print_uses(ENTRY * ep, FILE *fp)
 /* print an entry's use references */
 {
 /* print an entry's use references */
 {
-    int i;
+    unsigned i;
 
     if (!ep->nuses)
        fputs("NULL", fp);
 
     if (!ep->nuses)
        fputs("NULL", fp);
@@ -303,17 +353,17 @@ dump_boolean(int val)
 
 static void
 dump_numeric(int val, char *buf)
 
 static void
 dump_numeric(int val, char *buf)
-/* display the value of a boolean capability */
+/* display the value of a numeric capability */
 {
     switch (val) {
     case ABSENT_NUMERIC:
 {
     switch (val) {
     case ABSENT_NUMERIC:
-       strcpy(buf, s_absent);
+       _nc_STRCPY(buf, s_absent, MAX_STRING);
        break;
     case CANCELLED_NUMERIC:
        break;
     case CANCELLED_NUMERIC:
-       strcpy(buf, s_cancel);
+       _nc_STRCPY(buf, s_cancel, MAX_STRING);
        break;
     default:
        break;
     default:
-       sprintf(buf, "%d", val);
+       _nc_SPRINTF(buf, _nc_SLIMIT(MAX_STRING) "%d", val);
        break;
     }
 }
        break;
     }
 }
@@ -323,80 +373,191 @@ dump_string(char *val, char *buf)
 /* display the value of a string capability */
 {
     if (val == ABSENT_STRING)
 /* display the value of a string capability */
 {
     if (val == ABSENT_STRING)
-       strcpy(buf, s_absent);
+       _nc_STRCPY(buf, s_absent, MAX_STRING);
     else if (val == CANCELLED_STRING)
     else if (val == CANCELLED_STRING)
-       strcpy(buf, s_cancel);
+       _nc_STRCPY(buf, s_cancel, MAX_STRING);
     else {
     else {
-       sprintf(buf, "'%.*s'", MAX_STRING - 3, TIC_EXPAND(val));
+       _nc_SPRINTF(buf, _nc_SLIMIT(MAX_STRING)
+                   "'%.*s'", MAX_STRING - 3, TIC_EXPAND(val));
     }
 }
 
     }
 }
 
+/*
+ * Show "comparing..." message for the given terminal names.
+ */
+static void
+show_comparing(char **names)
+{
+    if (itrace) {
+       switch (compare) {
+       case C_DIFFERENCE:
+           (void) fprintf(stderr, "%s: dumping differences\n", _nc_progname);
+           break;
+
+       case C_COMMON:
+           (void) fprintf(stderr, "%s: dumping common capabilities\n", _nc_progname);
+           break;
+
+       case C_NAND:
+           (void) fprintf(stderr, "%s: dumping differences\n", _nc_progname);
+           break;
+       }
+    }
+    if (*names) {
+       printf("comparing %s", *names++);
+       if (*names) {
+           printf(" to %s", *names++);
+           while (*names) {
+               printf(", %s", *names++);
+           }
+       }
+       printf(".\n");
+    }
+}
+
+/*
+ * ncurses stores two types of non-standard capabilities:
+ * a) capabilities listed past the "STOP-HERE" comment in the Caps file. 
+ *    These are used in the terminfo source file to provide data for termcaps,
+ *    e.g., when there is no equivalent capability in terminfo, as well as for
+ *    widely-used non-standard capabilities.
+ * b) user-definable capabilities, via "tic -x".
+ *
+ * However, if "-x" is omitted from the tic command, both types of
+ * non-standard capability are not loaded into the terminfo database.  This
+ * macro is used for limit-checks against the symbols that tic uses to omit
+ * the two types of non-standard entry.
+ */
+#if NCURSES_XNAMES
+#define check_user_definable(n,limit) if (!_nc_user_definable && (n) > (limit)) break
+#else
+#define check_user_definable(n,limit) if ((n) > (limit)) break
+#endif
+
+/*
+ * Use these macros to simplify loops on C_COMMON and C_NAND:
+ */
+#define for_each_entry() while (entries[extra].tterm.term_names)
+#define next_entry           (&(entries[extra++].tterm))
+
 static void
 static void
-compare_predicate(int type, int idx, const char *name)
+compare_predicate(PredType type, PredIdx idx, const char *name)
 /* predicate function to use for entry difference reports */
 {
 /* predicate function to use for entry difference reports */
 {
-    register ENTRY *e1 = &entries[0];
-    register ENTRY *e2 = &entries[1];
-    char buf1[MAX_STRING], buf2[MAX_STRING];
+    ENTRY *e1 = &entries[0];
+    ENTRY *e2 = &entries[1];
+    char buf1[MAX_STRING];
+    char buf2[MAX_STRING];
     int b1, b2;
     int n1, n2;
     char *s1, *s2;
     int b1, b2;
     int n1, n2;
     char *s1, *s2;
+    bool found;
+    int extra = 1;
 
     switch (type) {
     case CMP_BOOLEAN:
 
     switch (type) {
     case CMP_BOOLEAN:
+       check_user_definable(idx, BOOLWRITE);
        b1 = e1->tterm.Booleans[idx];
        b1 = e1->tterm.Booleans[idx];
-       b2 = e2->tterm.Booleans[idx];
        switch (compare) {
        case C_DIFFERENCE:
        switch (compare) {
        case C_DIFFERENCE:
-           if (!(b1 == ABSENT_BOOLEAN && b2 == ABSENT_BOOLEAN) && b1 != b2)
+           b2 = next_entry->Booleans[idx];
+           if (!(no_boolean(b1) && no_boolean(b2)) && (b1 != b2))
                (void) printf("\t%s: %s%s%s.\n",
                (void) printf("\t%s: %s%s%s.\n",
-                   name,
-                   dump_boolean(b1),
-                   bool_sep,
-                   dump_boolean(b2));
+                             name,
+                             dump_boolean(b1),
+                             bool_sep,
+                             dump_boolean(b2));
            break;
 
        case C_COMMON:
            break;
 
        case C_COMMON:
-           if (b1 == b2 && b1 != ABSENT_BOOLEAN)
-               (void) printf("\t%s= %s.\n", name, dump_boolean(b1));
+           if (b1 != ABSENT_BOOLEAN) {
+               found = TRUE;
+               for_each_entry() {
+                   b2 = next_entry->Booleans[idx];
+                   if (b1 != b2) {
+                       found = FALSE;
+                       break;
+                   }
+               }
+               if (found) {
+                   (void) printf("\t%s= %s.\n", name, dump_boolean(b1));
+               }
+           }
            break;
 
        case C_NAND:
            break;
 
        case C_NAND:
-           if (b1 == ABSENT_BOOLEAN && b2 == ABSENT_BOOLEAN)
-               (void) printf("\t!%s.\n", name);
+           if (b1 == ABSENT_BOOLEAN) {
+               found = TRUE;
+               for_each_entry() {
+                   b2 = next_entry->Booleans[idx];
+                   if (b1 != b2) {
+                       found = FALSE;
+                       break;
+                   }
+               }
+               if (found) {
+                   (void) printf("\t!%s.\n", name);
+               }
+           }
            break;
        }
        break;
 
     case CMP_NUMBER:
            break;
        }
        break;
 
     case CMP_NUMBER:
+       check_user_definable(idx, NUMWRITE);
        n1 = e1->tterm.Numbers[idx];
        n1 = e1->tterm.Numbers[idx];
-       n2 = e2->tterm.Numbers[idx];
-       dump_numeric(n1, buf1);
-       dump_numeric(n2, buf2);
        switch (compare) {
        case C_DIFFERENCE:
        switch (compare) {
        case C_DIFFERENCE:
-           if (!((n1 == ABSENT_NUMERIC && n2 == ABSENT_NUMERIC)) && n1 != n2)
+           n2 = next_entry->Numbers[idx];
+           if (!(no_numeric(n1) && no_numeric(n2)) && n1 != n2) {
+               dump_numeric(n1, buf1);
+               dump_numeric(n2, buf2);
                (void) printf("\t%s: %s, %s.\n", name, buf1, buf2);
                (void) printf("\t%s: %s, %s.\n", name, buf1, buf2);
+           }
            break;
 
        case C_COMMON:
            break;
 
        case C_COMMON:
-           if (n1 != ABSENT_NUMERIC && n2 != ABSENT_NUMERIC && n1 == n2)
-               (void) printf("\t%s= %s.\n", name, buf1);
+           if (n1 != ABSENT_NUMERIC) {
+               found = TRUE;
+               for_each_entry() {
+                   n2 = next_entry->Numbers[idx];
+                   if (n1 != n2) {
+                       found = FALSE;
+                       break;
+                   }
+               }
+               if (found) {
+                   dump_numeric(n1, buf1);
+                   (void) printf("\t%s= %s.\n", name, buf1);
+               }
+           }
            break;
 
        case C_NAND:
            break;
 
        case C_NAND:
-           if (n1 == ABSENT_NUMERIC && n2 == ABSENT_NUMERIC)
-               (void) printf("\t!%s.\n", name);
+           if (n1 == ABSENT_NUMERIC) {
+               found = TRUE;
+               for_each_entry() {
+                   n2 = next_entry->Numbers[idx];
+                   if (n1 != n2) {
+                       found = FALSE;
+                       break;
+                   }
+               }
+               if (found) {
+                   (void) printf("\t!%s.\n", name);
+               }
+           }
            break;
        }
        break;
 
     case CMP_STRING:
            break;
        }
        break;
 
     case CMP_STRING:
+       check_user_definable(idx, STRWRITE);
        s1 = e1->tterm.Strings[idx];
        s1 = e1->tterm.Strings[idx];
-       s2 = e2->tterm.Strings[idx];
        switch (compare) {
        case C_DIFFERENCE:
        switch (compare) {
        case C_DIFFERENCE:
-           if (capcmp(idx, s1, s2)) {
+           s2 = next_entry->Strings[idx];
+           if (!(no_string(s1) && no_string(s2)) && capcmp(idx, s1, s2)) {
                dump_string(s1, buf1);
                dump_string(s2, buf2);
                if (strcmp(buf1, buf2))
                dump_string(s1, buf1);
                dump_string(s2, buf2);
                if (strcmp(buf1, buf2))
@@ -405,13 +566,35 @@ compare_predicate(int type, int idx, const char *name)
            break;
 
        case C_COMMON:
            break;
 
        case C_COMMON:
-           if (s1 && s2 && !capcmp(idx, s1, s2))
-               (void) printf("\t%s= '%s'.\n", name, TIC_EXPAND(s1));
+           if (s1 != ABSENT_STRING) {
+               found = TRUE;
+               for_each_entry() {
+                   s2 = next_entry->Strings[idx];
+                   if (capcmp(idx, s1, s2) != 0) {
+                       found = FALSE;
+                       break;
+                   }
+               }
+               if (found) {
+                   (void) printf("\t%s= '%s'.\n", name, TIC_EXPAND(s1));
+               }
+           }
            break;
 
        case C_NAND:
            break;
 
        case C_NAND:
-           if (!s1 && !s2)
-               (void) printf("\t!%s.\n", name);
+           if (s1 == ABSENT_STRING) {
+               found = TRUE;
+               for_each_entry() {
+                   s2 = next_entry->Strings[idx];
+                   if (s2 != s1) {
+                       found = FALSE;
+                       break;
+                   }
+               }
+               if (found) {
+                   (void) printf("\t!%s.\n", name);
+               }
+           }
            break;
        }
        break;
            break;
        }
        break;
@@ -430,16 +613,37 @@ compare_predicate(int type, int idx, const char *name)
            break;
 
        case C_COMMON:
            break;
 
        case C_COMMON:
-           if (e1->nuses && e2->nuses && useeq(e1, e2)) {
-               (void) fputs("\tuse: ", stdout);
-               print_uses(e1, stdout);
-               fputs(".\n", stdout);
+           if (e1->nuses) {
+               found = TRUE;
+               for_each_entry() {
+                   e2 = &entries[extra++];
+                   if (e2->nuses != e1->nuses || !useeq(e1, e2)) {
+                       found = FALSE;
+                       break;
+                   }
+               }
+               if (found) {
+                   (void) fputs("\tuse: ", stdout);
+                   print_uses(e1, stdout);
+                   fputs(".\n", stdout);
+               }
            }
            break;
 
        case C_NAND:
            }
            break;
 
        case C_NAND:
-           if (!e1->nuses && !e2->nuses)
-               (void) printf("\t!use.\n");
+           if (!e1->nuses) {
+               found = TRUE;
+               for_each_entry() {
+                   e2 = &entries[extra++];
+                   if (e2->nuses != e1->nuses) {
+                       found = FALSE;
+                       break;
+                   }
+               }
+               if (found) {
+                   (void) printf("\t!use.\n");
+               }
+           }
            break;
        }
     }
            break;
        }
     }
@@ -451,123 +655,199 @@ compare_predicate(int type, int idx, const char *name)
  *
  ***************************************************************************/
 
  *
  ***************************************************************************/
 
+#define DATA(from, to) { { from }, { to } }
+#define DATAX()        DATA("", "")
+
 typedef struct {
 typedef struct {
-    const char *from;
-    const char *to;
+    const char from[4];
+    const char to[12];
 } assoc;
 
 static const assoc std_caps[] =
 {
     /* these are specified by X.364 and iBCS2 */
 } assoc;
 
 static const assoc std_caps[] =
 {
     /* these are specified by X.364 and iBCS2 */
-    {"\033c", "RIS"},          /* full reset */
-    {"\0337", "SC"},           /* save cursor */
-    {"\0338", "RC"},           /* restore cursor */
-    {"\033[r", "RSR"},         /* not an X.364 mnemonic */
-    {"\033[m", "SGR0"},                /* not an X.364 mnemonic */
-    {"\033[2J", "ED2"},                /* clear page */
+    DATA("\033c", "RIS"),      /* full reset */
+    DATA("\0337", "SC"),       /* save cursor */
+    DATA("\0338", "RC"),       /* restore cursor */
+    DATA("\033[r", "RSR"),     /* not an X.364 mnemonic */
+    DATA("\033[m", "SGR0"),    /* not an X.364 mnemonic */
+    DATA("\033[2J", "ED2"),    /* clear page */
 
     /* this group is specified by ISO 2022 */
 
     /* this group is specified by ISO 2022 */
-    {"\033(0", "ISO DEC G0"},  /* enable DEC graphics for G0 */
-    {"\033(A", "ISO UK G0"},   /* enable UK chars for G0 */
-    {"\033(B", "ISO US G0"},   /* enable US chars for G0 */
-    {"\033)0", "ISO DEC G1"},  /* enable DEC graphics for G1 */
-    {"\033)A", "ISO UK G1"},   /* enable UK chars for G1 */
-    {"\033)B", "ISO US G1"},   /* enable US chars for G1 */
-
-    /* these are DEC private modes widely supported by emulators */
-    {"\033=", "DECPAM"},       /* application keypad mode */
-    {"\033>", "DECPNM"},       /* normal keypad mode */
-    {"\033<", "DECANSI"},      /* enter ANSI mode */
-
-    {(char *) 0, (char *) 0}
+    DATA("\033(0", "ISO DEC G0"),      /* enable DEC graphics for G0 */
+    DATA("\033(A", "ISO UK G0"),       /* enable UK chars for G0 */
+    DATA("\033(B", "ISO US G0"),       /* enable US chars for G0 */
+    DATA("\033)0", "ISO DEC G1"),      /* enable DEC graphics for G1 */
+    DATA("\033)A", "ISO UK G1"),       /* enable UK chars for G1 */
+    DATA("\033)B", "ISO US G1"),       /* enable US chars for G1 */
+
+    /* these are DEC private controls widely supported by emulators */
+    DATA("\033=", "DECPAM"),   /* application keypad mode */
+    DATA("\033>", "DECPNM"),   /* normal keypad mode */
+    DATA("\033<", "DECANSI"),  /* enter ANSI mode */
+    DATA("\033[!p", "DECSTR"), /* soft reset */
+    DATA("\033 F", "S7C1T"),   /* 7-bit controls */
+
+    DATAX()
+};
+
+static const assoc std_modes[] =
+/* ECMA \E[ ... [hl] modes recognized by many emulators */
+{
+    DATA("2", "AM"),           /* keyboard action mode */
+    DATA("4", "IRM"),          /* insert/replace mode */
+    DATA("12", "SRM"),         /* send/receive mode */
+    DATA("20", "LNM"),         /* linefeed mode */
+    DATAX()
 };
 
 static const assoc private_modes[] =
 /* DEC \E[ ... [hl] modes recognized by many emulators */
 {
 };
 
 static const assoc private_modes[] =
 /* DEC \E[ ... [hl] modes recognized by many emulators */
 {
-    {"1", "CKM"},              /* application cursor keys */
-    {"2", "ANM"},              /* set VT52 mode */
-    {"3", "COLM"},             /* 132-column mode */
-    {"4", "SCLM"},             /* smooth scroll */
-    {"5", "SCNM"},             /* reverse video mode */
-    {"6", "OM"},               /* origin mode */
-    {"7", "AWM"},              /* wraparound mode */
-    {"8", "ARM"},              /* auto-repeat mode */
-    {(char *) 0, (char *) 0}
+    DATA("1", "CKM"),          /* application cursor keys */
+    DATA("2", "ANM"),          /* set VT52 mode */
+    DATA("3", "COLM"),         /* 132-column mode */
+    DATA("4", "SCLM"),         /* smooth scroll */
+    DATA("5", "SCNM"),         /* reverse video mode */
+    DATA("6", "OM"),           /* origin mode */
+    DATA("7", "AWM"),          /* wraparound mode */
+    DATA("8", "ARM"),          /* auto-repeat mode */
+    DATAX()
 };
 
 static const assoc ecma_highlights[] =
 /* recognize ECMA attribute sequences */
 {
 };
 
 static const assoc ecma_highlights[] =
 /* recognize ECMA attribute sequences */
 {
-    {"0", "NORMAL"},           /* normal */
-    {"1", "+BOLD"},            /* bold on */
-    {"2", "+DIM"},             /* dim on */
-    {"3", "+ITALIC"},          /* italic on */
-    {"4", "+UNDERLINE"},       /* underline on */
-    {"5", "+BLINK"},           /* blink on */
-    {"6", "+FASTBLINK"},       /* fastblink on */
-    {"7", "+REVERSE"},         /* reverse on */
-    {"8", "+INVISIBLE"},       /* invisible on */
-    {"9", "+DELETED"},         /* deleted on */
-    {"10", "MAIN-FONT"},       /* select primary font */
-    {"11", "ALT-FONT-1"},      /* select alternate font 1 */
-    {"12", "ALT-FONT-2"},      /* select alternate font 2 */
-    {"13", "ALT-FONT-3"},      /* select alternate font 3 */
-    {"14", "ALT-FONT-4"},      /* select alternate font 4 */
-    {"15", "ALT-FONT-5"},      /* select alternate font 5 */
-    {"16", "ALT-FONT-6"},      /* select alternate font 6 */
-    {"17", "ALT-FONT-7"},      /* select alternate font 7 */
-    {"18", "ALT-FONT-1"},      /* select alternate font 1 */
-    {"19", "ALT-FONT-1"},      /* select alternate font 1 */
-    {"20", "FRAKTUR"},         /* Fraktur font */
-    {"21", "DOUBLEUNDER"},     /* double underline */
-    {"22", "-DIM"},            /* dim off */
-    {"23", "-ITALIC"},         /* italic off */
-    {"24", "-UNDERLINE"},      /* underline off */
-    {"25", "-BLINK"},          /* blink off */
-    {"26", "-FASTBLINK"},      /* fastblink off */
-    {"27", "-REVERSE"},                /* reverse off */
-    {"28", "-INVISIBLE"},      /* invisible off */
-    {"29", "-DELETED"},                /* deleted off */
-    {(char *) 0, (char *) 0}
+    DATA("0", "NORMAL"),       /* normal */
+    DATA("1", "+BOLD"),                /* bold on */
+    DATA("2", "+DIM"),         /* dim on */
+    DATA("3", "+ITALIC"),      /* italic on */
+    DATA("4", "+UNDERLINE"),   /* underline on */
+    DATA("5", "+BLINK"),       /* blink on */
+    DATA("6", "+FASTBLINK"),   /* fastblink on */
+    DATA("7", "+REVERSE"),     /* reverse on */
+    DATA("8", "+INVISIBLE"),   /* invisible on */
+    DATA("9", "+DELETED"),     /* deleted on */
+    DATA("10", "MAIN-FONT"),   /* select primary font */
+    DATA("11", "ALT-FONT-1"),  /* select alternate font 1 */
+    DATA("12", "ALT-FONT-2"),  /* select alternate font 2 */
+    DATA("13", "ALT-FONT-3"),  /* select alternate font 3 */
+    DATA("14", "ALT-FONT-4"),  /* select alternate font 4 */
+    DATA("15", "ALT-FONT-5"),  /* select alternate font 5 */
+    DATA("16", "ALT-FONT-6"),  /* select alternate font 6 */
+    DATA("17", "ALT-FONT-7"),  /* select alternate font 7 */
+    DATA("18", "ALT-FONT-1"),  /* select alternate font 1 */
+    DATA("19", "ALT-FONT-1"),  /* select alternate font 1 */
+    DATA("20", "FRAKTUR"),     /* Fraktur font */
+    DATA("21", "DOUBLEUNDER"), /* double underline */
+    DATA("22", "-DIM"),                /* dim off */
+    DATA("23", "-ITALIC"),     /* italic off */
+    DATA("24", "-UNDERLINE"),  /* underline off */
+    DATA("25", "-BLINK"),      /* blink off */
+    DATA("26", "-FASTBLINK"),  /* fastblink off */
+    DATA("27", "-REVERSE"),    /* reverse off */
+    DATA("28", "-INVISIBLE"),  /* invisible off */
+    DATA("29", "-DELETED"),    /* deleted off */
+    DATAX()
 };
 
 };
 
+#undef DATA
+
+static int
+skip_csi(const char *cap)
+{
+    int result = 0;
+    if (cap[0] == '\033' && cap[1] == '[')
+       result = 2;
+    else if (UChar(cap[0]) == 0233)
+       result = 1;
+    return result;
+}
+
+static bool
+same_param(const char *table, const char *param, size_t length)
+{
+    bool result = FALSE;
+    if (strncmp(table, param, length) == 0) {
+       result = !isdigit(UChar(param[length]));
+    }
+    return result;
+}
+
+static char *
+lookup_params(const assoc * table, char *dst, char *src)
+{
+    char *result = 0;
+    const char *ep = strtok(src, ";");
+
+    if (ep != 0) {
+       const assoc *ap;
+
+       do {
+           bool found = FALSE;
+
+           for (ap = table; ap->from[0]; ap++) {
+               size_t tlen = strlen(ap->from);
+
+               if (same_param(ap->from, ep, tlen)) {
+                   _nc_STRCAT(dst, ap->to, MAX_TERMINFO_LENGTH);
+                   found = TRUE;
+                   break;
+               }
+           }
+
+           if (!found)
+               _nc_STRCAT(dst, ep, MAX_TERMINFO_LENGTH);
+           _nc_STRCAT(dst, ";", MAX_TERMINFO_LENGTH);
+       } while
+           ((ep = strtok((char *) 0, ";")));
+
+       dst[strlen(dst) - 1] = '\0';
+
+       result = dst;
+    }
+    return result;
+}
+
 static void
 static void
-analyze_string(const char *name, const char *cap, TERMTYPE * tp)
+analyze_string(const char *name, const char *cap, TERMTYPE2 *tp)
 {
 {
-    char buf[MAX_TERMINFO_LENGTH];
     char buf2[MAX_TERMINFO_LENGTH];
     char buf2[MAX_TERMINFO_LENGTH];
-    const char *sp, *ep;
+    const char *sp;
     const assoc *ap;
     const assoc *ap;
+    int tp_lines = tp->Numbers[2];
 
 
-    if (cap == ABSENT_STRING || cap == CANCELLED_STRING)
+    if (!VALID_STRING(cap))
        return;
     (void) printf("%s: ", name);
 
        return;
     (void) printf("%s: ", name);
 
-    buf[0] = '\0';
     for (sp = cap; *sp; sp++) {
        int i;
     for (sp = cap; *sp; sp++) {
        int i;
+       int csi;
        size_t len = 0;
        size_t len = 0;
+       size_t next;
        const char *expansion = 0;
        const char *expansion = 0;
+       char buf3[MAX_TERMINFO_LENGTH];
 
        /* first, check other capabilities in this entry */
        for (i = 0; i < STRCOUNT; i++) {
            char *cp = tp->Strings[i];
 
 
        /* first, check other capabilities in this entry */
        for (i = 0; i < STRCOUNT; i++) {
            char *cp = tp->Strings[i];
 
-           /* don't use soft-key capabilities */
-           if (strnames[i][0] == 'k' && strnames[i][0] == 'f')
+           /* don't use function-key capabilities */
+           if (strnames[i][0] == 'k' && strnames[i][1] == 'f')
                continue;
 
                continue;
 
-           if (cp != ABSENT_STRING && cp != CANCELLED_STRING && cp[0] && cp
-               != cap) {
+           if (VALID_STRING(cp) &&
+               cp[0] != '\0' &&
+               cp != cap) {
                len = strlen(cp);
                len = strlen(cp);
-               (void) strncpy(buf2, sp, len);
+               _nc_STRNCPY(buf2, sp, len);
                buf2[len] = '\0';
 
                if (_nc_capcmp(cp, buf2))
                    continue;
 
                buf2[len] = '\0';
 
                if (_nc_capcmp(cp, buf2))
                    continue;
 
-#define ISRS(s)        (!strncmp((s), "is", 2) || !strncmp((s), "rs", 2))
+#define ISRS(s)        (!strncmp((s), "is", (size_t) 2) || !strncmp((s), "rs", (size_t) 2))
                /*
                 * Theoretically we just passed the test for translation
                 * (equality once the padding is stripped).  However, there
                /*
                 * Theoretically we just passed the test for translation
                 * (equality once the padding is stripped).  However, there
@@ -586,115 +866,134 @@ analyze_string(const char *name, const char *cap, TERMTYPE * tp)
        }
 
        /* now check the standard capabilities */
        }
 
        /* now check the standard capabilities */
-       if (!expansion)
-           for (ap = std_caps; ap->from; ap++) {
-               len = strlen(ap->from);
+       if (!expansion) {
+           csi = skip_csi(sp);
+           for (ap = std_caps; ap->from[0]; ap++) {
+               size_t adj = (size_t) (csi ? 2 : 0);
 
 
-               if (strncmp(ap->from, sp, len) == 0) {
+               len = strlen(ap->from);
+               if (csi && skip_csi(ap->from) != csi)
+                   continue;
+               if (len > adj
+                   && strncmp(ap->from + adj, sp + csi, len - adj) == 0) {
                    expansion = ap->to;
                    expansion = ap->to;
+                   len -= adj;
+                   len += (size_t) csi;
                    break;
                }
            }
                    break;
                }
            }
+       }
 
 
-       /* now check for private-mode sequences */
+       /* now check for standard-mode sequences */
        if (!expansion
        if (!expansion
-           && sp[0] == '\033' && sp[1] == '[' && sp[2] == '?'
-           && (len = strspn(sp + 3, "0123456789;"))
-           && ((sp[3 + len] == 'h') || (sp[3 + len] == 'l'))) {
-           char buf3[MAX_TERMINFO_LENGTH];
-
-           (void) strcpy(buf2, (sp[3 + len] == 'h') ? "DEC+" : "DEC-");
-           (void) strncpy(buf3, sp + 3, len);
-           len += 4;
+           && (csi = skip_csi(sp)) != 0
+           && (len = (strspn) (sp + csi, "0123456789;"))
+           && (len < sizeof(buf3))
+           && (next = (size_t) csi + len)
+           && ((sp[next] == 'h') || (sp[next] == 'l'))) {
+
+           _nc_STRCPY(buf2,
+                      ((sp[next] == 'h')
+                       ? "ECMA+"
+                       : "ECMA-"),
+                      sizeof(buf2));
+           _nc_STRNCPY(buf3, sp + csi, len);
            buf3[len] = '\0';
            buf3[len] = '\0';
+           len += (size_t) csi + 1;
 
 
-           ep = strtok(buf3, ";");
-           do {
-               bool found = FALSE;
-
-               for (ap = private_modes; ap->from; ap++) {
-                   size_t tlen = strlen(ap->from);
+           expansion = lookup_params(std_modes, buf2, buf3);
+       }
 
 
-                   if (strncmp(ap->from, ep, tlen) == 0) {
-                       (void) strcat(buf2, ap->to);
-                       found = TRUE;
-                       break;
-                   }
-               }
+       /* now check for private-mode sequences */
+       if (!expansion
+           && (csi = skip_csi(sp)) != 0
+           && sp[csi] == '?'
+           && (len = (strspn) (sp + csi + 1, "0123456789;"))
+           && (len < sizeof(buf3))
+           && (next = (size_t) csi + 1 + len)
+           && ((sp[next] == 'h') || (sp[next] == 'l'))) {
+
+           _nc_STRCPY(buf2,
+                      ((sp[next] == 'h')
+                       ? "DEC+"
+                       : "DEC-"),
+                      sizeof(buf2));
+           _nc_STRNCPY(buf3, sp + csi + 1, len);
+           buf3[len] = '\0';
+           len += (size_t) csi + 2;
 
 
-               if (!found)
-                   (void) strcat(buf2, ep);
-               (void) strcat(buf2, ";");
-           } while
-               ((ep = strtok((char *) 0, ";")));
-           buf2[strlen(buf2) - 1] = '\0';
-           expansion = buf2;
+           expansion = lookup_params(private_modes, buf2, buf3);
        }
 
        /* now check for ECMA highlight sequences */
        if (!expansion
        }
 
        /* now check for ECMA highlight sequences */
        if (!expansion
-           && sp[0] == '\033' && sp[1] == '['
-           && (len = strspn(sp + 2, "0123456789;"))
-           && sp[2 + len] == 'm') {
-           char buf3[MAX_TERMINFO_LENGTH];
-
-           (void) strcpy(buf2, "SGR:");
-           (void) strncpy(buf3, sp + 2, len);
-           len += 3;
+           && (csi = skip_csi(sp)) != 0
+           && (len = (strspn) (sp + csi, "0123456789;")) != 0
+           && (len < sizeof(buf3))
+           && (next = (size_t) csi + len)
+           && sp[next] == 'm') {
+
+           _nc_STRCPY(buf2, "SGR:", sizeof(buf2));
+           _nc_STRNCPY(buf3, sp + csi, len);
            buf3[len] = '\0';
            buf3[len] = '\0';
+           len += (size_t) csi + 1;
 
 
-           ep = strtok(buf3, ";");
-           do {
-               bool found = FALSE;
-
-               for (ap = ecma_highlights; ap->from; ap++) {
-                   size_t tlen = strlen(ap->from);
-
-                   if (strncmp(ap->from, ep, tlen) == 0) {
-                       (void) strcat(buf2, ap->to);
-                       found = TRUE;
-                       break;
-                   }
-               }
-
-               if (!found)
-                   (void) strcat(buf2, ep);
-               (void) strcat(buf2, ";");
-           } while
-               ((ep = strtok((char *) 0, ";")));
+           expansion = lookup_params(ecma_highlights, buf2, buf3);
+       }
 
 
-           buf2[strlen(buf2) - 1] = '\0';
+       if (!expansion
+           && (csi = skip_csi(sp)) != 0
+           && sp[csi] == 'm') {
+           len = (size_t) csi + 1;
+           _nc_STRCPY(buf2, "SGR:", sizeof(buf2));
+           _nc_STRCAT(buf2, ecma_highlights[0].to, sizeof(buf2));
            expansion = buf2;
        }
            expansion = buf2;
        }
+
        /* now check for scroll region reset */
        /* now check for scroll region reset */
-       if (!expansion) {
-           (void) sprintf(buf2, "\033[1;%dr", tp->Numbers[2]);
-           len = strlen(buf2);
-           if (strncmp(buf2, sp, len) == 0)
+       if (!expansion
+           && (csi = skip_csi(sp)) != 0) {
+           if (sp[csi] == 'r') {
                expansion = "RSR";
                expansion = "RSR";
+               len = 1;
+           } else {
+               _nc_SPRINTF(buf2, _nc_SLIMIT(sizeof(buf2)) "1;%dr", tp_lines);
+               len = strlen(buf2);
+               if (strncmp(buf2, sp + csi, len) == 0)
+                   expansion = "RSR";
+           }
+           len += (size_t) csi;
        }
 
        /* now check for home-down */
        }
 
        /* now check for home-down */
-       if (!expansion) {
-           (void) sprintf(buf2, "\033[%d;1H", tp->Numbers[2]);
+       if (!expansion
+           && (csi = skip_csi(sp)) != 0) {
+           _nc_SPRINTF(buf2, _nc_SLIMIT(sizeof(buf2)) "%d;1H", tp_lines);
            len = strlen(buf2);
            len = strlen(buf2);
-           if (strncmp(buf2, sp, len) == 0)
+           if (strncmp(buf2, sp + csi, len) == 0) {
                expansion = "LL";
                expansion = "LL";
+           } else {
+               _nc_SPRINTF(buf2, _nc_SLIMIT(sizeof(buf2)) "%dH", tp_lines);
+               len = strlen(buf2);
+               if (strncmp(buf2, sp + csi, len) == 0) {
+                   expansion = "LL";
+               }
+           }
+           len += (size_t) csi;
        }
 
        /* now look at the expansion we got, if any */
        if (expansion) {
        }
 
        /* now look at the expansion we got, if any */
        if (expansion) {
-           (void) sprintf(buf + strlen(buf), "{%s}", expansion);
+           printf("{%s}", expansion);
            sp += len - 1;
            sp += len - 1;
-           continue;
        } else {
            /* couldn't match anything */
            buf2[0] = *sp;
            buf2[1] = '\0';
        } else {
            /* couldn't match anything */
            buf2[0] = *sp;
            buf2[1] = '\0';
-           (void) strcat(buf, TIC_EXPAND(buf2));
+           fputs(TIC_EXPAND(buf2), stdout);
        }
     }
        }
     }
-    (void) printf("%s\n", buf);
+    putchar('\n');
 }
 
 /***************************************************************************
 }
 
 /***************************************************************************
@@ -710,41 +1009,45 @@ file_comparison(int argc, char *argv[])
     /* someday we may allow comparisons on more files */
     int filecount = 0;
     ENTRY *heads[MAXCOMPARE];
     /* someday we may allow comparisons on more files */
     int filecount = 0;
     ENTRY *heads[MAXCOMPARE];
-    ENTRY *tails[MAXCOMPARE];
     ENTRY *qp, *rp;
     int i, n;
 
     ENTRY *qp, *rp;
     int i, n;
 
-    dump_init((char *) 0, F_LITERAL, S_TERMINFO, 0, itrace, FALSE);
+    memset(heads, 0, sizeof(heads));
+    dump_init((char *) 0, F_LITERAL, S_TERMINFO,
+             FALSE, 0, 65535, itrace, FALSE, FALSE, FALSE);
 
     for (n = 0; n < argc && n < MAXCOMPARE; n++) {
        if (freopen(argv[n], "r", stdin) == 0)
            _nc_err_abort("Can't open %s", argv[n]);
 
 
     for (n = 0; n < argc && n < MAXCOMPARE; n++) {
        if (freopen(argv[n], "r", stdin) == 0)
            _nc_err_abort("Can't open %s", argv[n]);
 
+#if NO_LEAKS
+       entered[n].head = _nc_head;
+       entered[n].tail = _nc_tail;
+#endif
        _nc_head = _nc_tail = 0;
 
        /* parse entries out of the source file */
        _nc_set_source(argv[n]);
        _nc_head = _nc_tail = 0;
 
        /* parse entries out of the source file */
        _nc_set_source(argv[n]);
-       _nc_read_entry_source(stdin, NULL, TRUE, FALSE, NULLHOOK);
+       _nc_read_entry_source(stdin, NULL, TRUE, literal, NULLHOOK);
 
        if (itrace)
            (void) fprintf(stderr, "Resolving file %d...\n", n - 0);
 
        /* maybe do use resolution */
 
        if (itrace)
            (void) fprintf(stderr, "Resolving file %d...\n", n - 0);
 
        /* maybe do use resolution */
-       if (!_nc_resolve_uses(!limited)) {
+       if (!_nc_resolve_uses2(!limited, literal)) {
            (void) fprintf(stderr,
            (void) fprintf(stderr,
-               "There are unresolved use entries in %s:\n",
-               argv[n]);
+                          "There are unresolved use entries in %s:\n",
+                          argv[n]);
            for_entry_list(qp) {
                if (qp->nuses) {
                    (void) fputs(qp->tterm.term_names, stderr);
                    (void) fputc('\n', stderr);
                }
            }
            for_entry_list(qp) {
                if (qp->nuses) {
                    (void) fputs(qp->tterm.term_names, stderr);
                    (void) fputc('\n', stderr);
                }
            }
-           exit(EXIT_FAILURE);
+           ExitProgram(EXIT_FAILURE);
        }
 
        heads[filecount] = _nc_head;
        }
 
        heads[filecount] = _nc_head;
-       tails[filecount] = _nc_tail;
        filecount++;
     }
 
        filecount++;
     }
 
@@ -773,30 +1076,30 @@ file_comparison(int argc, char *argv[])
     for (qp = heads[0]; qp; qp = qp->next) {
        if (qp->ncrosslinks > 1) {
            (void) fprintf(stderr,
     for (qp = heads[0]; qp; qp = qp->next) {
        if (qp->ncrosslinks > 1) {
            (void) fprintf(stderr,
-               "%s in file 1 (%s) has %d matches in file 2 (%s):\n",
-               _nc_first_name(qp->tterm.term_names),
-               argv[0],
-               qp->ncrosslinks,
-               argv[1]);
+                          "%s in file 1 (%s) has %d matches in file 2 (%s):\n",
+                          _nc_first_name(qp->tterm.term_names),
+                          argv[0],
+                          qp->ncrosslinks,
+                          argv[1]);
            for (i = 0; i < qp->ncrosslinks; i++)
                (void) fprintf(stderr,
            for (i = 0; i < qp->ncrosslinks; i++)
                (void) fprintf(stderr,
-                   "\t%s\n",
-                   _nc_first_name((qp->crosslinks[i])->tterm.term_names));
+                              "\t%s\n",
+                              _nc_first_name((qp->crosslinks[i])->tterm.term_names));
        }
     }
 
     for (rp = heads[1]; rp; rp = rp->next) {
        if (rp->ncrosslinks > 1) {
            (void) fprintf(stderr,
        }
     }
 
     for (rp = heads[1]; rp; rp = rp->next) {
        if (rp->ncrosslinks > 1) {
            (void) fprintf(stderr,
-               "%s in file 2 (%s) has %d matches in file 1 (%s):\n",
-               _nc_first_name(rp->tterm.term_names),
-               argv[1],
-               rp->ncrosslinks,
-               argv[0]);
+                          "%s in file 2 (%s) has %d matches in file 1 (%s):\n",
+                          _nc_first_name(rp->tterm.term_names),
+                          argv[1],
+                          rp->ncrosslinks,
+                          argv[0]);
            for (i = 0; i < rp->ncrosslinks; i++)
                (void) fprintf(stderr,
            for (i = 0; i < rp->ncrosslinks; i++)
                (void) fprintf(stderr,
-                   "\t%s\n",
-                   _nc_first_name((rp->crosslinks[i])->tterm.term_names));
+                              "\t%s\n",
+                              _nc_first_name((rp->crosslinks[i])->tterm.term_names));
        }
     }
 
        }
     }
 
@@ -804,18 +1107,16 @@ file_comparison(int argc, char *argv[])
     for (qp = heads[0]; qp; qp = qp->next)
        if (qp->ncrosslinks == 0)
            (void) printf("\t%s\n",
     for (qp = heads[0]; qp; qp = qp->next)
        if (qp->ncrosslinks == 0)
            (void) printf("\t%s\n",
-               _nc_first_name(qp->tterm.term_names));
+                         _nc_first_name(qp->tterm.term_names));
 
     (void) printf("In file 2 (%s) only:\n", argv[1]);
     for (rp = heads[1]; rp; rp = rp->next)
        if (rp->ncrosslinks == 0)
            (void) printf("\t%s\n",
 
     (void) printf("In file 2 (%s) only:\n", argv[1]);
     for (rp = heads[1]; rp; rp = rp->next)
        if (rp->ncrosslinks == 0)
            (void) printf("\t%s\n",
-               _nc_first_name(rp->tterm.term_names));
+                         _nc_first_name(rp->tterm.term_names));
 
     (void) printf("The following entries are equivalent:\n");
     for (qp = heads[0]; qp; qp = qp->next) {
 
     (void) printf("The following entries are equivalent:\n");
     for (qp = heads[0]; qp; qp = qp->next) {
-       rp = qp->crosslinks[0];
-
        if (qp->ncrosslinks == 1) {
            rp = qp->crosslinks[0];
 
        if (qp->ncrosslinks == 1) {
            rp = qp->crosslinks[0];
 
@@ -847,6 +1148,11 @@ file_comparison(int argc, char *argv[])
 #endif
            if (!(entryeq(&qp->tterm, &rp->tterm) && useeq(qp, rp))) {
                char name1[NAMESIZE], name2[NAMESIZE];
 #endif
            if (!(entryeq(&qp->tterm, &rp->tterm) && useeq(qp, rp))) {
                char name1[NAMESIZE], name2[NAMESIZE];
+               char *names[3];
+
+               names[0] = name1;
+               names[1] = name2;
+               names[2] = 0;
 
                entries[0] = *qp;
                entries[1] = *rp;
 
                entries[0] = *qp;
                entries[1] = *rp;
@@ -856,26 +1162,17 @@ file_comparison(int argc, char *argv[])
 
                switch (compare) {
                case C_DIFFERENCE:
 
                switch (compare) {
                case C_DIFFERENCE:
-                   if (itrace)
-                       (void) fprintf(stderr,
-                           "infocmp: dumping differences\n");
-                   (void) printf("comparing %s to %s.\n", name1, name2);
+                   show_comparing(names);
                    compare_entry(compare_predicate, &entries->tterm, quiet);
                    break;
 
                case C_COMMON:
                    compare_entry(compare_predicate, &entries->tterm, quiet);
                    break;
 
                case C_COMMON:
-                   if (itrace)
-                       (void) fprintf(stderr,
-                           "infocmp: dumping common capabilities\n");
-                   (void) printf("comparing %s to %s.\n", name1, name2);
+                   show_comparing(names);
                    compare_entry(compare_predicate, &entries->tterm, quiet);
                    break;
 
                case C_NAND:
                    compare_entry(compare_predicate, &entries->tterm, quiet);
                    break;
 
                case C_NAND:
-                   if (itrace)
-                       (void) fprintf(stderr,
-                           "infocmp: dumping differences\n");
-                   (void) printf("comparing %s to %s.\n", name1, name2);
+                   show_comparing(names);
                    compare_entry(compare_predicate, &entries->tterm, quiet);
                    break;
 
                    compare_entry(compare_predicate, &entries->tterm, quiet);
                    break;
 
@@ -888,81 +1185,151 @@ file_comparison(int argc, char *argv[])
 static void
 usage(void)
 {
 static void
 usage(void)
 {
-    static const char *tbl[] =
+#define DATA(s) s "\n"
+    static const char head[] =
+    {
+       DATA("Usage: infocmp [options] [-A directory] [-B directory] [termname...]")
+       DATA("")
+       DATA("Options:")
+    };
+#undef DATA
+#define DATA(s) s
+    static const char options[][45] =
     {
     {
-       "Usage: infocmp [options] [-A directory] [-B directory] [termname...]"
-       ,""
-       ,"Options:"
+       "  -0    print single-row"
        ,"  -1    print single-column"
        ,"  -C    use termcap-names"
        ,"  -1    print single-column"
        ,"  -C    use termcap-names"
+       ,"  -D    print database locations"
+       ,"  -E    format output as C tables"
        ,"  -F    compare terminfo-files"
        ,"  -F    compare terminfo-files"
+       ,"  -G    format %{number} to %'char'"
        ,"  -I    use terminfo-names"
        ,"  -I    use terminfo-names"
+       ,"  -K    use termcap-names and BSD syntax"
        ,"  -L    use long names"
        ,"  -R subset (see manpage)"
        ,"  -T    eliminate size limits (test)"
        ,"  -L    use long names"
        ,"  -R subset (see manpage)"
        ,"  -T    eliminate size limits (test)"
+       ,"  -U    do not post-process entries"
        ,"  -V    print version"
        ,"  -V    print version"
+       ,"  -W    wrap long strings per -w[n]"
 #if NCURSES_XNAMES
        ,"  -a    with -F, list commented-out caps"
 #endif
        ,"  -c    list common capabilities"
        ,"  -d    list different capabilities"
        ,"  -e    format output for C initializer"
 #if NCURSES_XNAMES
        ,"  -a    with -F, list commented-out caps"
 #endif
        ,"  -c    list common capabilities"
        ,"  -d    list different capabilities"
        ,"  -e    format output for C initializer"
-       ,"  -E    format output as C tables"
        ,"  -f    with -1, format complex strings"
        ,"  -f    with -1, format complex strings"
-       ,"  -G    format %{number} to %'char'"
        ,"  -g    format %'char' to %{number}"
        ,"  -i    analyze initialization/reset"
        ,"  -l    output terminfo names"
        ,"  -n    list capabilities in neither"
        ,"  -p    ignore padding specifiers"
        ,"  -g    format %'char' to %{number}"
        ,"  -i    analyze initialization/reset"
        ,"  -l    output terminfo names"
        ,"  -n    list capabilities in neither"
        ,"  -p    ignore padding specifiers"
+       ,"  -Q number  dump compiled description"
        ,"  -q    brief listing, removes headers"
        ,"  -r    with -C, output in termcap form"
        ,"  -r    with -F, resolve use-references"
        ,"  -s [d|i|l|c] sort fields"
        ,"  -q    brief listing, removes headers"
        ,"  -r    with -C, output in termcap form"
        ,"  -r    with -F, resolve use-references"
        ,"  -s [d|i|l|c] sort fields"
+#if NCURSES_XNAMES
+       ,"  -t    suppress commented-out capabilities"
+#endif
        ,"  -u    produce source with 'use='"
        ,"  -v number  (verbose)"
        ,"  -w number  (width)"
        ,"  -u    produce source with 'use='"
        ,"  -v number  (verbose)"
        ,"  -w number  (width)"
+#if NCURSES_XNAMES
+       ,"  -x    unknown capabilities are user-defined"
+#endif
     };
     };
-    const size_t first = 3;
-    const size_t last = sizeof(tbl) / sizeof(tbl[0]);
-    const size_t left = (last - first + 1) / 2 + first;
+#undef DATA
+    const size_t last = SIZEOF(options);
+    const size_t left = (last + 1) / 2;
     size_t n;
 
     size_t n;
 
+    fputs(head, stderr);
     for (n = 0; n < left; n++) {
     for (n = 0; n < left; n++) {
-       size_t m = (n < first) ? last : n + left - first;
+       size_t m = n + left;
        if (m < last)
        if (m < last)
-           fprintf(stderr, "%-40.40s%s\n", tbl[n], tbl[m]);
+           fprintf(stderr, "%-40.40s%s\n", options[n], options[m]);
        else
        else
-           fprintf(stderr, "%s\n", tbl[n]);
+           fprintf(stderr, "%s\n", options[n]);
     }
     }
-    exit(EXIT_FAILURE);
+    ExitProgram(EXIT_FAILURE);
 }
 
 static char *
 }
 
 static char *
-name_initializer(const char *type)
+any_initializer(const char *fmt, const char *type)
 {
     static char *initializer;
 {
     static char *initializer;
+    static size_t need;
     char *s;
 
     char *s;
 
-    if (initializer == 0)
-       initializer = (char *) malloc(strlen(entries->tterm.term_names) + 20);
+    if (initializer == 0) {
+       need = (strlen(entries->tterm.term_names)
+               + strlen(type)
+               + strlen(fmt));
+       initializer = (char *) malloc(need + 1);
+       if (initializer == 0)
+           failed("any_initializer");
+    }
 
 
-    (void) sprintf(initializer, "%s_data_%s", type, entries->tterm.term_names);
+    _nc_STRCPY(initializer, entries->tterm.term_names, need);
     for (s = initializer; *s != 0 && *s != '|'; s++) {
     for (s = initializer; *s != 0 && *s != '|'; s++) {
-       if (!isalnum(*s))
+       if (!isalnum(UChar(*s)))
            *s = '_';
     }
     *s = 0;
            *s = '_';
     }
     *s = 0;
+    _nc_SPRINTF(s, _nc_SLIMIT(need) fmt, type);
     return initializer;
 }
 
     return initializer;
 }
 
+static char *
+name_initializer(const char *type)
+{
+    return any_initializer("_%s_data", type);
+}
+
+static char *
+string_variable(const char *type)
+{
+    return any_initializer("_s_%s", type);
+}
+
 /* dump C initializers for the terminal type */
 static void
 /* dump C initializers for the terminal type */
 static void
-dump_initializers(TERMTYPE * term)
+dump_initializers(TERMTYPE2 *term)
 {
 {
-    int n;
+    unsigned n;
     const char *str = 0;
     const char *str = 0;
-    int size;
+
+    printf("\nstatic char %s[] = \"%s\";\n\n",
+          name_initializer("alias"), entries->tterm.term_names);
+
+    for_each_string(n, term) {
+       char buf[MAX_STRING], *sp, *tp;
+
+       if (VALID_STRING(term->Strings[n])) {
+           tp = buf;
+#define TP_LIMIT       ((MAX_STRING - 5) - (size_t)(tp - buf))
+           *tp++ = '"';
+           for (sp = term->Strings[n];
+                *sp != 0 && TP_LIMIT > 2;
+                sp++) {
+               if (isascii(UChar(*sp))
+                   && isprint(UChar(*sp))
+                   && *sp != '\\'
+                   && *sp != '"')
+                   *tp++ = *sp;
+               else {
+                   _nc_SPRINTF(tp, _nc_SLIMIT(TP_LIMIT) "\\%03o", UChar(*sp));
+                   tp += 4;
+               }
+           }
+           *tp++ = '"';
+           *tp = '\0';
+           (void) printf("static char %-20s[] = %s;\n",
+                         string_variable(ExtStrname(term, (int) n, strnames)),
+                         buf);
+       }
+    }
+    printf("\n");
 
     (void) printf("static char %s[] = %s\n", name_initializer("bool"), L_CURL);
 
 
     (void) printf("static char %s[] = %s\n", name_initializer("bool"), L_CURL);
 
@@ -984,8 +1351,8 @@ dump_initializers(TERMTYPE * term)
            str = "CANCELLED_BOOLEAN";
            break;
        }
            str = "CANCELLED_BOOLEAN";
            break;
        }
-       (void) printf("\t/* %3d: %-8s */\t%s,\n",
-           n, ExtBoolname(term, n, boolnames), str);
+       (void) printf("\t/* %3u: %-8s */\t%s,\n",
+                     n, ExtBoolname(term, (int) n, boolnames), str);
     }
     (void) printf("%s;\n", R_CURL);
 
     }
     (void) printf("%s;\n", R_CURL);
 
@@ -1001,65 +1368,59 @@ dump_initializers(TERMTYPE * term)
            str = "CANCELLED_NUMERIC";
            break;
        default:
            str = "CANCELLED_NUMERIC";
            break;
        default:
-           sprintf(buf, "%d", term->Numbers[n]);
+           _nc_SPRINTF(buf, _nc_SLIMIT(sizeof(buf)) "%d", term->Numbers[n]);
            str = buf;
            break;
        }
            str = buf;
            break;
        }
-       (void) printf("\t/* %3d: %-8s */\t%s,\n", n, ExtNumname(term, n,
-               numnames), str);
+       (void) printf("\t/* %3u: %-8s */\t%s,\n", n,
+                     ExtNumname(term, (int) n, numnames), str);
     }
     (void) printf("%s;\n", R_CURL);
 
     }
     (void) printf("%s;\n", R_CURL);
 
-    size = sizeof(TERMTYPE)
-       + (NUM_BOOLEANS(term) * sizeof(term->Booleans[0]))
-       + (NUM_NUMBERS(term) * sizeof(term->Numbers[0]));
-
     (void) printf("static char * %s[] = %s\n", name_initializer("string"), L_CURL);
 
     for_each_string(n, term) {
     (void) printf("static char * %s[] = %s\n", name_initializer("string"), L_CURL);
 
     for_each_string(n, term) {
-       char buf[MAX_STRING], *sp, *tp;
 
        if (term->Strings[n] == ABSENT_STRING)
            str = "ABSENT_STRING";
        else if (term->Strings[n] == CANCELLED_STRING)
            str = "CANCELLED_STRING";
        else {
 
        if (term->Strings[n] == ABSENT_STRING)
            str = "ABSENT_STRING";
        else if (term->Strings[n] == CANCELLED_STRING)
            str = "CANCELLED_STRING";
        else {
-           tp = buf;
-           *tp++ = '"';
-           for (sp = term->Strings[n];
-               *sp != 0 && (tp - buf) < MAX_STRING - 6;
-               sp++) {
-               if (isascii(*sp) && isprint(*sp) && *sp != '\\' && *sp != '"')
-                   *tp++ = *sp;
-               else {
-                   (void) sprintf(tp, "\\%03o", *sp & 0xff);
-                   tp += 4;
-               }
-           }
-           *tp++ = '"';
-           *tp = '\0';
-           size += (strlen(term->Strings[n]) + 1);
-           str = buf;
+           str = string_variable(ExtStrname(term, (int) n, strnames));
        }
        }
-#if NCURSES_XNAMES
-       if (n == STRCOUNT) {
-           (void) printf("%s;\n", R_CURL);
+       (void) printf("\t/* %3u: %-8s */\t%s,\n", n,
+                     ExtStrname(term, (int) n, strnames), str);
+    }
+    (void) printf("%s;\n", R_CURL);
 
 
-           (void) printf("static char * %s[] = %s\n",
-               name_initializer("string_ext"), L_CURL);
+#if NCURSES_XNAMES
+    if ((NUM_BOOLEANS(term) != BOOLCOUNT)
+       || (NUM_NUMBERS(term) != NUMCOUNT)
+       || (NUM_STRINGS(term) != STRCOUNT)) {
+       (void) printf("static char * %s[] = %s\n",
+                     name_initializer("string_ext"), L_CURL);
+       for (n = BOOLCOUNT; n < NUM_BOOLEANS(term); ++n) {
+           (void) printf("\t/* %3u: bool */\t\"%s\",\n",
+                         n, ExtBoolname(term, (int) n, boolnames));
        }
        }
-#endif
-       (void) printf("\t/* %3d: %-8s */\t%s,\n", n, ExtStrname(term, n,
-               strnames), str);
+       for (n = NUMCOUNT; n < NUM_NUMBERS(term); ++n) {
+           (void) printf("\t/* %3u: num */\t\"%s\",\n",
+                         n, ExtNumname(term, (int) n, numnames));
+       }
+       for (n = STRCOUNT; n < NUM_STRINGS(term); ++n) {
+           (void) printf("\t/* %3u: str */\t\"%s\",\n",
+                         n, ExtStrname(term, (int) n, strnames));
+       }
+       (void) printf("%s;\n", R_CURL);
     }
     }
-    (void) printf("%s;\n", R_CURL);
+#endif
 }
 
 /* dump C initializers for the terminal type */
 static void
 }
 
 /* dump C initializers for the terminal type */
 static void
-dump_termtype(TERMTYPE * term)
+dump_termtype(TERMTYPE2 *term)
 {
 {
-    (void) printf("\t%s\n\t\t\"%s\",\n", L_CURL, term->term_names);
+    (void) printf("\t%s\n\t\t%s,\n", L_CURL, name_initializer("alias"));
     (void) printf("\t\t(char *)0,\t/* pointer to string table */\n");
 
     (void) printf("\t\t%s,\n", name_initializer("bool"));
     (void) printf("\t\t(char *)0,\t/* pointer to string table */\n");
 
     (void) printf("\t\t%s,\n", name_initializer("bool"));
@@ -1071,83 +1432,188 @@ dump_termtype(TERMTYPE * term)
     (void) printf("#if NCURSES_XNAMES\n");
     (void) printf("\t\t(char *)0,\t/* pointer to extended string table */\n");
     (void) printf("\t\t%s,\t/* ...corresponding names */\n",
     (void) printf("#if NCURSES_XNAMES\n");
     (void) printf("\t\t(char *)0,\t/* pointer to extended string table */\n");
     (void) printf("\t\t%s,\t/* ...corresponding names */\n",
-       (NUM_STRINGS(term) != STRCOUNT)
-       ? name_initializer("string_ext")
-       : "(char **)0");
+                 ((NUM_BOOLEANS(term) != BOOLCOUNT)
+                  || (NUM_NUMBERS(term) != NUMCOUNT)
+                  || (NUM_STRINGS(term) != STRCOUNT))
+                 ? name_initializer("string_ext")
+                 : "(char **)0");
 
     (void) printf("\t\t%d,\t\t/* count total Booleans */\n", NUM_BOOLEANS(term));
     (void) printf("\t\t%d,\t\t/* count total Numbers */\n", NUM_NUMBERS(term));
     (void) printf("\t\t%d,\t\t/* count total Strings */\n", NUM_STRINGS(term));
 
     (void) printf("\t\t%d,\t\t/* count extensions to Booleans */\n",
 
     (void) printf("\t\t%d,\t\t/* count total Booleans */\n", NUM_BOOLEANS(term));
     (void) printf("\t\t%d,\t\t/* count total Numbers */\n", NUM_NUMBERS(term));
     (void) printf("\t\t%d,\t\t/* count total Strings */\n", NUM_STRINGS(term));
 
     (void) printf("\t\t%d,\t\t/* count extensions to Booleans */\n",
-       NUM_BOOLEANS(term) - BOOLCOUNT);
+                 NUM_BOOLEANS(term) - BOOLCOUNT);
     (void) printf("\t\t%d,\t\t/* count extensions to Numbers */\n",
     (void) printf("\t\t%d,\t\t/* count extensions to Numbers */\n",
-       NUM_NUMBERS(term) - NUMCOUNT);
+                 NUM_NUMBERS(term) - NUMCOUNT);
     (void) printf("\t\t%d,\t\t/* count extensions to Strings */\n",
     (void) printf("\t\t%d,\t\t/* count extensions to Strings */\n",
-       NUM_STRINGS(term) - STRCOUNT);
+                 NUM_STRINGS(term) - STRCOUNT);
 
     (void) printf("#endif /* NCURSES_XNAMES */\n");
 
     (void) printf("#endif /* NCURSES_XNAMES */\n");
+#else
+    (void) term;
 #endif /* NCURSES_XNAMES */
     (void) printf("\t%s\n", R_CURL);
 }
 
 #endif /* NCURSES_XNAMES */
     (void) printf("\t%s\n", R_CURL);
 }
 
+static int
+optarg_to_number(void)
+{
+    char *temp = 0;
+    long value = strtol(optarg, &temp, 0);
+
+    if (temp == 0 || temp == optarg || *temp != 0) {
+       fprintf(stderr, "Expected a number, not \"%s\"\n", optarg);
+       ExitProgram(EXIT_FAILURE);
+    }
+    return (int) value;
+}
+
+static char *
+terminal_env(void)
+{
+    char *terminal;
+
+    if ((terminal = getenv("TERM")) == 0) {
+       (void) fprintf(stderr,
+                      "%s: environment variable TERM not set\n",
+                      _nc_progname);
+       exit(EXIT_FAILURE);
+    }
+    return terminal;
+}
+
+/*
+ * Show the databases that infocmp knows about.  The location to which it writes is
+ */
+static void
+show_databases(void)
+{
+    DBDIRS state;
+    int offset;
+    const char *path2;
+
+    _nc_first_db(&state, &offset);
+    while ((path2 = _nc_next_db(&state, &offset)) != 0) {
+       printf("%s\n", path2);
+    }
+    _nc_last_db();
+}
+
 /***************************************************************************
  *
  * Main sequence
  *
  ***************************************************************************/
 
 /***************************************************************************
  *
  * Main sequence
  *
  ***************************************************************************/
 
+#if NO_LEAKS
+#define MAIN_LEAKS() \
+    free(myargv); \
+    free(tfile); \
+    free(tname)
+#else
+#define MAIN_LEAKS()           /* nothing */
+#endif
+
 int
 main(int argc, char *argv[])
 {
 int
 main(int argc, char *argv[])
 {
-    char *terminal, *firstdir, *restdir;
     /* Avoid "local data >32k" error with mwcc */
     /* Also avoid overflowing smaller stacks on systems like AmigaOS */
     /* Avoid "local data >32k" error with mwcc */
     /* Also avoid overflowing smaller stacks on systems like AmigaOS */
-    path *tfile = (path *) malloc(sizeof(path) * MAXTERMS);
+    path *tfile = 0;
+    char **tname = 0;
+    size_t maxterms;
+
+    char **myargv;
+
+    char *firstdir, *restdir;
     int c, i, len;
     bool formatted = FALSE;
     bool filecompare = FALSE;
     int initdump = 0;
     bool init_analyze = FALSE;
     int c, i, len;
     bool formatted = FALSE;
     bool filecompare = FALSE;
     int initdump = 0;
     bool init_analyze = FALSE;
-
-    if ((terminal = getenv("TERM")) == 0) {
-       (void) fprintf(stderr,
-           "infocmp: environment variable TERM not set\n");
-       return EXIT_FAILURE;
-    }
+    bool suppress_untranslatable = FALSE;
+    int quickdump = 0;
+    bool wrap_strings = FALSE;
 
     /* where is the terminfo database location going to default to? */
     restdir = firstdir = 0;
 
 
     /* where is the terminfo database location going to default to? */
     restdir = firstdir = 0;
 
-    while ((c = getopt(argc, argv, "adeEcCfFGgIinlLpqrR:s:uv:Vw:A:B:1T")) != EOF)
+#if NCURSES_XNAMES
+    use_extended_names(FALSE);
+#endif
+    _nc_strict_bsd = 0;
+
+    _nc_progname = _nc_rootname(argv[0]);
+
+    /* make sure we have enough space to add two terminal entries */
+    myargv = typeCalloc(char *, (size_t) (argc + 3));
+    if (myargv == 0)
+       failed("myargv");
+
+    memcpy(myargv, argv, (sizeof(char *) * (size_t) argc));
+    argv = myargv;
+
+    while ((c = getopt(argc,
+                      argv,
+                      "01A:aB:CcDdEeFfGgIiKLlnpQ:qR:rs:TtUuVv:Ww:x")) != -1) {
        switch (c) {
        switch (c) {
+       case '0':
+           mwidth = 65535;
+           mheight = 1;
+           break;
+
+       case '1':
+           mwidth = 0;
+           break;
+
+       case 'A':
+           firstdir = optarg;
+           break;
+
 #if NCURSES_XNAMES
        case 'a':
            _nc_disable_period = TRUE;
            use_extended_names(TRUE);
            break;
 #endif
 #if NCURSES_XNAMES
        case 'a':
            _nc_disable_period = TRUE;
            use_extended_names(TRUE);
            break;
 #endif
-       case 'd':
-           compare = C_DIFFERENCE;
+       case 'B':
+           restdir = optarg;
            break;
 
            break;
 
-       case 'e':
-           initdump |= 1;
+       case 'K':
+           _nc_strict_bsd = 1;
+           /* FALLTHRU */
+       case 'C':
+           outform = F_TERMCAP;
+           tversion = "BSD";
+           if (sortmode == S_DEFAULT)
+               sortmode = S_TERMCAP;
            break;
 
            break;
 
-       case 'E':
-           initdump |= 2;
+       case 'D':
+           show_databases();
+           ExitProgram(EXIT_SUCCESS);
            break;
 
        case 'c':
            compare = C_COMMON;
            break;
 
            break;
 
        case 'c':
            compare = C_COMMON;
            break;
 
-       case 'C':
-           outform = F_TERMCAP;
-           tversion = "BSD";
-           if (sortmode == S_DEFAULT)
-               sortmode = S_TERMCAP;
+       case 'd':
+           compare = C_DIFFERENCE;
+           break;
+
+       case 'E':
+           initdump |= 2;
+           break;
+
+       case 'e':
+           initdump |= 1;
+           break;
+
+       case 'F':
+           filecompare = TRUE;
            break;
 
        case 'f':
            break;
 
        case 'f':
@@ -1162,10 +1628,6 @@ main(int argc, char *argv[])
            numbers = -1;
            break;
 
            numbers = -1;
            break;
 
-       case 'F':
-           filecompare = TRUE;
-           break;
-
        case 'I':
            outform = F_TERMINFO;
            if (sortmode == S_DEFAULT)
        case 'I':
            outform = F_TERMINFO;
            if (sortmode == S_DEFAULT)
@@ -1177,16 +1639,16 @@ main(int argc, char *argv[])
            init_analyze = TRUE;
            break;
 
            init_analyze = TRUE;
            break;
 
-       case 'l':
-           outform = F_TERMINFO;
-           break;
-
        case 'L':
            outform = F_VARIABLE;
            if (sortmode == S_DEFAULT)
                sortmode = S_VARIABLE;
            break;
 
        case 'L':
            outform = F_VARIABLE;
            if (sortmode == S_DEFAULT)
                sortmode = S_VARIABLE;
            break;
 
+       case 'l':
+           outform = F_TERMINFO;
+           break;
+
        case 'n':
            compare = C_NAND;
            break;
        case 'n':
            compare = C_NAND;
            break;
@@ -1195,6 +1657,10 @@ main(int argc, char *argv[])
            ignorepads = TRUE;
            break;
 
            ignorepads = TRUE;
            break;
 
+       case 'Q':
+           quickdump = optarg_to_number();
+           break;
+
        case 'q':
            quiet = TRUE;
            s_absent = "-";
        case 'q':
            quiet = TRUE;
            s_absent = "-";
@@ -1202,15 +1668,14 @@ main(int argc, char *argv[])
            bool_sep = ", ";
            break;
 
            bool_sep = ", ";
            break;
 
-       case 'r':
-           tversion = 0;
-           limited = FALSE;
-           break;
-
        case 'R':
            tversion = optarg;
            break;
 
        case 'R':
            tversion = optarg;
            break;
 
+       case 'r':
+           tversion = 0;
+           break;
+
        case 's':
            if (*optarg == 'd')
                sortmode = S_NOSORT;
        case 's':
            if (*optarg == 'd')
                sortmode = S_NOSORT;
@@ -1222,113 +1687,167 @@ main(int argc, char *argv[])
                sortmode = S_TERMCAP;
            else {
                (void) fprintf(stderr,
                sortmode = S_TERMCAP;
            else {
                (void) fprintf(stderr,
-                   "infocmp: unknown sort mode\n");
-               return EXIT_FAILURE;
+                              "%s: unknown sort mode\n",
+                              _nc_progname);
+               ExitProgram(EXIT_FAILURE);
            }
            break;
 
            }
            break;
 
-       case 'u':
-           compare = C_USEALL;
+       case 'T':
+           limited = FALSE;
            break;
 
            break;
 
-       case 'v':
-           itrace = atoi(optarg);
-           set_trace_level(itrace);
+#if NCURSES_XNAMES
+       case 't':
+           _nc_disable_period = FALSE;
+           suppress_untranslatable = TRUE;
+           break;
+#endif
+
+       case 'U':
+           literal = TRUE;
+           break;
+
+       case 'u':
+           compare = C_USEALL;
            break;
 
        case 'V':
            break;
 
        case 'V':
-           (void) fputs(NCURSES_VERSION, stdout);
-           putchar('\n');
+           puts(curses_version());
            ExitProgram(EXIT_SUCCESS);
 
            ExitProgram(EXIT_SUCCESS);
 
-       case 'w':
-           mwidth = atoi(optarg);
+       case 'v':
+           itrace = (unsigned) optarg_to_number();
+           set_trace_level(itrace);
            break;
 
            break;
 
-       case 'A':
-           firstdir = optarg;
+       case 'W':
+           wrap_strings = TRUE;
            break;
 
            break;
 
-       case 'B':
-           restdir = optarg;
+       case 'w':
+           mwidth = optarg_to_number();
            break;
 
            break;
 
-       case '1':
-           mwidth = 0;
+#if NCURSES_XNAMES
+       case 'x':
+           use_extended_names(TRUE);
            break;
            break;
+#endif
 
 
-       case 'T':
-           limited = FALSE;
-           break;
        default:
            usage();
        }
        default:
            usage();
        }
+    }
+
+    maxterms = (size_t) (argc + 2 - optind);
+    if ((tfile = typeMalloc(path, maxterms)) == 0)
+       failed("tfile");
+    if ((tname = typeCalloc(char *, maxterms)) == 0)
+         failed("tname");
+    if ((entries = typeCalloc(ENTRY, maxterms)) == 0)
+       failed("entries");
+#if NO_LEAKS
+    if ((entered = typeCalloc(ENTERED, maxterms)) == 0)
+       failed("entered");
+#endif
+
+    if (tfile == 0
+       || tname == 0
+       || entries == 0) {
+       fprintf(stderr, "%s: not enough memory\n", _nc_progname);
+       ExitProgram(EXIT_FAILURE);
+    }
 
     /* by default, sort by terminfo name */
     if (sortmode == S_DEFAULT)
        sortmode = S_TERMINFO;
 
 
     /* by default, sort by terminfo name */
     if (sortmode == S_DEFAULT)
        sortmode = S_TERMINFO;
 
-    /* set up for display */
-    dump_init(tversion, outform, sortmode, mwidth, itrace, formatted);
-
     /* make sure we have at least one terminal name to work with */
     if (optind >= argc)
     /* make sure we have at least one terminal name to work with */
     if (optind >= argc)
-       argv[argc++] = terminal;
+       argv[argc++] = terminal_env();
 
     /* if user is after a comparison, make sure we have two entries */
     if (compare != C_DEFAULT && optind >= argc - 1)
 
     /* if user is after a comparison, make sure we have two entries */
     if (compare != C_DEFAULT && optind >= argc - 1)
-       argv[argc++] = terminal;
+       argv[argc++] = terminal_env();
 
 
+    /* exactly one terminal name with no options means display it */
     /* exactly two terminal names with no options means do -d */
     /* exactly two terminal names with no options means do -d */
-    if (argc - optind == 2 && compare == C_DEFAULT)
-       compare = C_DIFFERENCE;
+    if (compare == C_DEFAULT) {
+       switch (argc - optind) {
+       default:
+           fprintf(stderr, "%s: too many names to compare\n", _nc_progname);
+           ExitProgram(EXIT_FAILURE);
+       case 1:
+           break;
+       case 2:
+           compare = C_DIFFERENCE;
+           break;
+       }
+    }
+
+    /* set up for display */
+    dump_init(tversion, outform, sortmode,
+             wrap_strings, mwidth, mheight, itrace,
+             formatted, FALSE, quickdump);
 
     if (!filecompare) {
        /* grab the entries */
        termcount = 0;
        for (; optind < argc; optind++) {
 
     if (!filecompare) {
        /* grab the entries */
        termcount = 0;
        for (; optind < argc; optind++) {
-           if (termcount >= MAXTERMS) {
-               (void) fprintf(stderr,
-                   "infocmp: too many terminal type arguments\n");
-               return EXIT_FAILURE;
-           } else {
-               const char *directory = termcount ? restdir : firstdir;
-               int status;
-
-               tname[termcount] = argv[optind];
-
-               if (directory) {
-                   (void) sprintf(tfile[termcount], "%s/%c/%s",
-                       directory,
-                       *argv[optind], argv[optind]);
-                   if (itrace)
-                       (void) fprintf(stderr,
-                           "infocmp: reading entry %s from file %s\n",
-                           argv[optind], tfile[termcount]);
-
-                   status = _nc_read_file_entry(tfile[termcount],
-                       &entries[termcount].tterm);
-               } else {
-                   if (itrace)
-                       (void) fprintf(stderr,
-                           "infocmp: reading entry %s from system directories %s\n",
-                           argv[optind], tname[termcount]);
-
-                   status = _nc_read_entry(tname[termcount],
-                       tfile[termcount],
-                       &entries[termcount].tterm);
-                   directory = TERMINFO;       /* for error message */
-               }
+           const char *directory = termcount ? restdir : firstdir;
+           int status;
+
+           tname[termcount] = argv[optind];
 
 
-               if (status <= 0) {
+           if (directory) {
+#if NCURSES_USE_DATABASE
+#if MIXEDCASE_FILENAMES
+#define LEAF_FMT "%c"
+#else
+#define LEAF_FMT "%02x"
+#endif
+               _nc_SPRINTF(tfile[termcount],
+                           _nc_SLIMIT(sizeof(path))
+                           "%s/" LEAF_FMT "/%s",
+                           directory,
+                           UChar(*argv[optind]), argv[optind]);
+               if (itrace)
                    (void) fprintf(stderr,
                    (void) fprintf(stderr,
-                       "infocmp: couldn't open terminfo file %s.\n",
-                       tfile[termcount]);
-                   return EXIT_FAILURE;
-               }
-               repair_acsc(&entries[termcount].tterm);
-               termcount++;
+                                  "%s: reading entry %s from file %s\n",
+                                  _nc_progname,
+                                  argv[optind], tfile[termcount]);
+
+               status = _nc_read_file_entry(tfile[termcount],
+                                            &entries[termcount].tterm);
+#else
+               (void) fprintf(stderr, "%s: terminfo files not supported\n",
+                              _nc_progname);
+               MAIN_LEAKS();
+               ExitProgram(EXIT_FAILURE);
+#endif
+           } else {
+               if (itrace)
+                   (void) fprintf(stderr,
+                                  "%s: reading entry %s from database\n",
+                                  _nc_progname,
+                                  tname[termcount]);
+
+               status = _nc_read_entry2(tname[termcount],
+                                       tfile[termcount],
+                                       &entries[termcount].tterm);
+           }
+
+           if (status <= 0) {
+               (void) fprintf(stderr,
+                              "%s: couldn't open terminfo file %s.\n",
+                              _nc_progname,
+                              tfile[termcount]);
+               MAIN_LEAKS();
+               ExitProgram(EXIT_FAILURE);
            }
            }
+           repair_acsc(&entries[termcount].tterm);
+           termcount++;
        }
 
 #if NCURSES_XNAMES
        }
 
 #if NCURSES_XNAMES
@@ -1342,11 +1861,10 @@ main(int argc, char *argv[])
                dump_termtype(&entries[0].tterm);
            if (initdump & 2)
                dump_initializers(&entries[0].tterm);
                dump_termtype(&entries[0].tterm);
            if (initdump & 2)
                dump_initializers(&entries[0].tterm);
-           ExitProgram(EXIT_SUCCESS);
        }
 
        /* analyze the init strings */
        }
 
        /* analyze the init strings */
-       if (init_analyze) {
+       else if (init_analyze) {
 #undef CUR
 #define CUR    entries[0].tterm.
            analyze_string("is1", init_1string, &entries[0].tterm);
 #undef CUR
 #define CUR    entries[0].tterm.
            analyze_string("is1", init_1string, &entries[0].tterm);
@@ -1357,72 +1875,79 @@ main(int argc, char *argv[])
            analyze_string("rs3", reset_3string, &entries[0].tterm);
            analyze_string("smcup", enter_ca_mode, &entries[0].tterm);
            analyze_string("rmcup", exit_ca_mode, &entries[0].tterm);
            analyze_string("rs3", reset_3string, &entries[0].tterm);
            analyze_string("smcup", enter_ca_mode, &entries[0].tterm);
            analyze_string("rmcup", exit_ca_mode, &entries[0].tterm);
+           analyze_string("smkx", keypad_xmit, &entries[0].tterm);
+           analyze_string("rmkx", keypad_local, &entries[0].tterm);
 #undef CUR
 #undef CUR
-           ExitProgram(EXIT_SUCCESS);
-       }
+       } else {
 
 
-       /*
-        * Here's where the real work gets done
-        */
-       switch (compare) {
-       case C_DEFAULT:
-           if (itrace)
-               (void) fprintf(stderr,
-                   "infocmp: about to dump %s\n",
-                   tname[0]);
-           (void) printf("#\tReconstructed via infocmp from file: %s\n",
-               tfile[0]);
-           len = dump_entry(&entries[0].tterm, limited, numbers, NULL);
-           putchar('\n');
-           if (itrace)
-               (void) fprintf(stderr, "infocmp: length %d\n", len);
-           break;
+           /*
+            * Here's where the real work gets done
+            */
+           switch (compare) {
+           case C_DEFAULT:
+               if (itrace)
+                   (void) fprintf(stderr,
+                                  "%s: about to dump %s\n",
+                                  _nc_progname,
+                                  tname[0]);
+               if (!quiet)
+                   (void)
+                       printf("#\tReconstructed via infocmp from file: %s\n",
+                              tfile[0]);
+               dump_entry(&entries[0].tterm,
+                          suppress_untranslatable,
+                          limited,
+                          numbers,
+                          NULL);
+               len = show_entry();
+               if (itrace)
+                   (void) fprintf(stderr, "%s: length %d\n", _nc_progname, len);
+               break;
 
 
-       case C_DIFFERENCE:
-           if (itrace)
-               (void) fprintf(stderr, "infocmp: dumping differences\n");
-           (void) printf("comparing %s to %s.\n", tname[0], tname[1]);
-           compare_entry(compare_predicate, &entries->tterm, quiet);
-           break;
+           case C_DIFFERENCE:
+               show_comparing(tname);
+               compare_entry(compare_predicate, &entries->tterm, quiet);
+               break;
 
 
-       case C_COMMON:
-           if (itrace)
-               (void) fprintf(stderr,
-                   "infocmp: dumping common capabilities\n");
-           (void) printf("comparing %s to %s.\n", tname[0], tname[1]);
-           compare_entry(compare_predicate, &entries->tterm, quiet);
-           break;
+           case C_COMMON:
+               show_comparing(tname);
+               compare_entry(compare_predicate, &entries->tterm, quiet);
+               break;
 
 
-       case C_NAND:
-           if (itrace)
-               (void) fprintf(stderr,
-                   "infocmp: dumping differences\n");
-           (void) printf("comparing %s to %s.\n", tname[0], tname[1]);
-           compare_entry(compare_predicate, &entries->tterm, quiet);
-           break;
+           case C_NAND:
+               show_comparing(tname);
+               compare_entry(compare_predicate, &entries->tterm, quiet);
+               break;
 
 
-       case C_USEALL:
-           if (itrace)
-               (void) fprintf(stderr, "infocmp: dumping use entry\n");
-           len = dump_entry(&entries[0].tterm, limited, numbers, use_predicate);
-           for (i = 1; i < termcount; i++)
-               len += dump_uses(tname[i], !(outform == F_TERMCAP || outform
-                       == F_TCONVERR));
-           putchar('\n');
-           if (itrace)
-               (void) fprintf(stderr, "infocmp: length %d\n", len);
-           break;
+           case C_USEALL:
+               if (itrace)
+                   (void) fprintf(stderr, "%s: dumping use entry\n", _nc_progname);
+               dump_entry(&entries[0].tterm,
+                          suppress_untranslatable,
+                          limited,
+                          numbers,
+                          use_predicate);
+               for (i = 1; i < termcount; i++)
+                   dump_uses(tname[i], !(outform == F_TERMCAP
+                                         || outform == F_TCONVERR));
+               len = show_entry();
+               if (itrace)
+                   (void) fprintf(stderr, "%s: length %d\n", _nc_progname, len);
+               break;
+           }
        }
        }
-    } else if (compare == C_USEALL)
+    } else if (compare == C_USEALL) {
        (void) fprintf(stderr, "Sorry, -u doesn't work with -F\n");
        (void) fprintf(stderr, "Sorry, -u doesn't work with -F\n");
-    else if (compare == C_DEFAULT)
+    } else if (compare == C_DEFAULT) {
        (void) fprintf(stderr, "Use `tic -[CI] <file>' for this.\n");
        (void) fprintf(stderr, "Use `tic -[CI] <file>' for this.\n");
-    else if (argc - optind != 2)
+    } else if (argc - optind != 2) {
        (void) fprintf(stderr,
        (void) fprintf(stderr,
-           "File comparison needs exactly two file arguments.\n");
-    else
+                      "File comparison needs exactly two file arguments.\n");
+    } else {
        file_comparison(argc - optind, argv + optind);
        file_comparison(argc - optind, argv + optind);
+    }
 
 
+    MAIN_LEAKS();
     ExitProgram(EXIT_SUCCESS);
 }
 
     ExitProgram(EXIT_SUCCESS);
 }