]> ncurses.scripts.mit.edu Git - ncurses.git/blobdiff - progs/infocmp.c
ncurses 5.9 - patch 20120526
[ncurses.git] / progs / infocmp.c
index e034a58596fc9fd4a90f02be7a80a08992590557..d57fa857f9879998dd5f49025ee7b97a00c7b04d 100644 (file)
@@ -1,5 +1,5 @@
 /****************************************************************************
- * Copyright (c) 1998-2010,2011 Free Software Foundation, Inc.              *
+ * Copyright (c) 1998-2011,2012 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            *
@@ -42,7 +42,7 @@
 
 #include <dump_entry.h>
 
-MODULE_ID("$Id: infocmp.c,v 1.106 2011/05/14 22:51:04 tom Exp $")
+MODULE_ID("$Id: infocmp.c,v 1.118 2012/05/26 21:11:32 tom Exp $")
 
 #define L_CURL "{"
 #define R_CURL "}"
@@ -72,6 +72,7 @@ static const char *s_cancel = "NULL";
 static const char *tversion;   /* terminfo version selected */
 static unsigned itrace;                /* trace flag for debugging */
 static int mwidth = 60;
+static int mheight = 65535;
 static int numbers = 0;                /* format "%'char'" to/from "%{number}" */
 static int outform = F_TERMINFO;       /* output format */
 static int sortmode;           /* sort_mode */
@@ -106,7 +107,7 @@ canonical_name(char *ptr, char *buf)
 {
     char *bp;
 
-    (void) strcpy(buf, ptr);
+    _nc_STRCPY(buf, ptr, NAMESIZE);
     if ((bp = strchr(buf, '|')) != 0)
        *bp = '\0';
 
@@ -307,13 +308,13 @@ dump_numeric(int val, char *buf)
 {
     switch (val) {
     case ABSENT_NUMERIC:
-       strcpy(buf, s_absent);
+       _nc_STRCPY(buf, s_absent, MAX_STRING);
        break;
     case CANCELLED_NUMERIC:
-       strcpy(buf, s_cancel);
+       _nc_STRCPY(buf, s_cancel, MAX_STRING);
        break;
     default:
-       sprintf(buf, "%d", val);
+       _nc_SPRINTF(buf, _nc_SLIMIT(MAX_STRING) "%d", val);
        break;
     }
 }
@@ -323,31 +324,90 @@ dump_string(char *val, char *buf)
 /* 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)
-       strcpy(buf, s_cancel);
+       _nc_STRCPY(buf, s_cancel, MAX_STRING);
     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.
+ */
+#define check_user_definable(n,limit) if (!_nc_user_definable && (n) > (limit)) break
+
+/*
+ * 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
 compare_predicate(PredType type, PredIdx idx, const char *name)
 /* 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;
+    bool found;
+    int extra = 1;
 
     switch (type) {
     case CMP_BOOLEAN:
+       check_user_definable(idx, BOOLWRITE);
        b1 = e1->tterm.Booleans[idx];
-       b2 = e2->tterm.Booleans[idx];
        switch (compare) {
        case C_DIFFERENCE:
+           b2 = next_entry->Booleans[idx];
            if (!(b1 == ABSENT_BOOLEAN && b2 == ABSENT_BOOLEAN) && b1 != b2)
                (void) printf("\t%s: %s%s%s.\n",
                              name,
@@ -357,45 +417,93 @@ compare_predicate(PredType type, PredIdx idx, const char *name)
            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:
-           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:
+       check_user_definable(idx, NUMWRITE);
        n1 = e1->tterm.Numbers[idx];
-       n2 = e2->tterm.Numbers[idx];
-       dump_numeric(n1, buf1);
-       dump_numeric(n2, buf2);
        switch (compare) {
        case C_DIFFERENCE:
-           if (!((n1 == ABSENT_NUMERIC && n2 == ABSENT_NUMERIC)) && n1 != n2)
+           n2 = next_entry->Numbers[idx];
+           if (!((n1 == ABSENT_NUMERIC && n2 == ABSENT_NUMERIC)) && n1 != n2) {
+               dump_numeric(n1, buf1);
+               dump_numeric(n2, buf2);
                (void) printf("\t%s: %s, %s.\n", name, buf1, buf2);
+           }
            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:
-           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:
+       check_user_definable(idx, STRWRITE);
        s1 = e1->tterm.Strings[idx];
-       s2 = e2->tterm.Strings[idx];
        switch (compare) {
        case C_DIFFERENCE:
+           s2 = next_entry->Strings[idx];
            if (capcmp(idx, s1, s2)) {
                dump_string(s1, buf1);
                dump_string(s2, buf2);
@@ -405,13 +513,35 @@ compare_predicate(PredType type, PredIdx idx, const char *name)
            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:
-           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;
@@ -430,16 +560,36 @@ compare_predicate(PredType type, PredIdx idx, const char *name)
            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:
-           if (!e1->nuses && !e2->nuses)
-               (void) printf("\t!use.\n");
+           if (!e1->nuses) {
+               for_each_entry() {
+                   e2 = &entries[extra++];
+                   if (e2->nuses != e1->nuses) {
+                       found = FALSE;
+                       break;
+                   }
+               }
+               if (found) {
+                   (void) printf("\t!use.\n");
+               }
+           }
            break;
        }
     }
@@ -581,15 +731,15 @@ lookup_params(const assoc * table, char *dst, char *src)
                size_t tlen = strlen(ap->from);
 
                if (same_param(ap->from, ep, tlen)) {
-                   (void) strcat(dst, ap->to);
+                   _nc_STRCAT(dst, ap->to, MAX_TERMINFO_LENGTH);
                    found = TRUE;
                    break;
                }
            }
 
            if (!found)
-               (void) strcat(dst, ep);
-           (void) strcat(dst, ";");
+               _nc_STRCAT(dst, ep, MAX_TERMINFO_LENGTH);
+           _nc_STRCAT(dst, ";", MAX_TERMINFO_LENGTH);
        } while
            ((ep = strtok((char *) 0, ";")));
 
@@ -682,7 +832,11 @@ analyze_string(const char *name, const char *cap, TERMTYPE *tp)
            && (next = (size_t) csi + len)
            && ((sp[next] == 'h') || (sp[next] == 'l'))) {
 
-           (void) strcpy(buf2, (sp[next] == 'h') ? "ECMA+" : "ECMA-");
+           _nc_STRCPY(buf2,
+                      ((sp[next] == 'h')
+                       ? "ECMA+"
+                       : "ECMA-"),
+                      sizeof(buf2));
            (void) strncpy(buf3, sp + csi, len);
            buf3[len] = '\0';
            len += (size_t) csi + 1;
@@ -699,7 +853,11 @@ analyze_string(const char *name, const char *cap, TERMTYPE *tp)
            && (next = (size_t) csi + 1 + len)
            && ((sp[next] == 'h') || (sp[next] == 'l'))) {
 
-           (void) strcpy(buf2, (sp[next] == 'h') ? "DEC+" : "DEC-");
+           _nc_STRCPY(buf2,
+                      ((sp[next] == 'h')
+                       ? "DEC+"
+                       : "DEC-"),
+                      sizeof(buf2));
            (void) strncpy(buf3, sp + csi + 1, len);
            buf3[len] = '\0';
            len += (size_t) csi + 2;
@@ -715,7 +873,7 @@ analyze_string(const char *name, const char *cap, TERMTYPE *tp)
            && (next = (size_t) csi + len)
            && sp[next] == 'm') {
 
-           (void) strcpy(buf2, "SGR:");
+           _nc_STRCPY(buf2, "SGR:", sizeof(buf2));
            (void) strncpy(buf3, sp + csi, len);
            buf3[len] = '\0';
            len += (size_t) csi + 1;
@@ -727,8 +885,8 @@ analyze_string(const char *name, const char *cap, TERMTYPE *tp)
            && (csi = skip_csi(sp)) != 0
            && sp[csi] == 'm') {
            len = (size_t) csi + 1;
-           (void) strcpy(buf2, "SGR:");
-           strcat(buf2, ecma_highlights[0].to);
+           _nc_STRCPY(buf2, "SGR:", sizeof(buf2));
+           _nc_STRCAT(buf2, ecma_highlights[0].to, sizeof(buf2));
            expansion = buf2;
        }
 
@@ -739,7 +897,7 @@ analyze_string(const char *name, const char *cap, TERMTYPE *tp)
                expansion = "RSR";
                len = 1;
            } else {
-               (void) sprintf(buf2, "1;%dr", tp_lines);
+               _nc_SPRINTF(buf2, _nc_SLIMIT(sizeof(buf2)) "1;%dr", tp_lines);
                len = strlen(buf2);
                if (strncmp(buf2, sp + csi, len) == 0)
                    expansion = "RSR";
@@ -750,12 +908,12 @@ analyze_string(const char *name, const char *cap, TERMTYPE *tp)
        /* now check for home-down */
        if (!expansion
            && (csi = skip_csi(sp)) != 0) {
-           (void) sprintf(buf2, "%d;1H", tp_lines);
+           _nc_SPRINTF(buf2, _nc_SLIMIT(sizeof(buf2)) "%d;1H", tp_lines);
            len = strlen(buf2);
            if (strncmp(buf2, sp + csi, len) == 0) {
                expansion = "LL";
            } else {
-               (void) sprintf(buf2, "%dH", tp_lines);
+               _nc_SPRINTF(buf2, _nc_SLIMIT(sizeof(buf2)) "%dH", tp_lines);
                len = strlen(buf2);
                if (strncmp(buf2, sp + csi, len) == 0) {
                    expansion = "LL";
@@ -795,7 +953,7 @@ file_comparison(int argc, char *argv[])
     int i, n;
 
     memset(heads, 0, sizeof(heads));
-    dump_init((char *) 0, F_LITERAL, S_TERMINFO, 0, itrace, FALSE);
+    dump_init((char *) 0, F_LITERAL, S_TERMINFO, 0, 65535, itrace, FALSE);
 
     for (n = 0; n < argc && n < MAXCOMPARE; n++) {
        if (freopen(argv[n], "r", stdin) == 0)
@@ -925,6 +1083,11 @@ file_comparison(int argc, char *argv[])
 #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;
@@ -934,29 +1097,17 @@ file_comparison(int argc, char *argv[])
 
                switch (compare) {
                case C_DIFFERENCE:
-                   if (itrace)
-                       (void) fprintf(stderr,
-                                      "%s: dumping differences\n",
-                                      _nc_progname);
-                   (void) printf("comparing %s to %s.\n", name1, name2);
+                   show_comparing(names);
                    compare_entry(compare_predicate, &entries->tterm, quiet);
                    break;
 
                case C_COMMON:
-                   if (itrace)
-                       (void) fprintf(stderr,
-                                      "%s: dumping common capabilities\n",
-                                      _nc_progname);
-                   (void) printf("comparing %s to %s.\n", name1, name2);
+                   show_comparing(names);
                    compare_entry(compare_predicate, &entries->tterm, quiet);
                    break;
 
                case C_NAND:
-                   if (itrace)
-                       (void) fprintf(stderr,
-                                      "%s: dumping differences\n",
-                                      _nc_progname);
-                   (void) printf("comparing %s to %s.\n", name1, name2);
+                   show_comparing(names);
                    compare_entry(compare_predicate, &entries->tterm, quiet);
                    break;
 
@@ -974,7 +1125,9 @@ usage(void)
        "Usage: infocmp [options] [-A directory] [-B directory] [termname...]"
        ,""
        ,"Options:"
+       ,"  -0    print single-row"
        ,"  -1    print single-column"
+       ,"  -K    use termcap-names and BSD syntax"
        ,"  -C    use termcap-names"
        ,"  -F    compare terminfo-files"
        ,"  -I    use terminfo-names"
@@ -1030,19 +1183,23 @@ static char *
 any_initializer(const char *fmt, const char *type)
 {
     static char *initializer;
+    static size_t need;
     char *s;
 
-    if (initializer == 0)
-       initializer = (char *) malloc(strlen(entries->tterm.term_names) +
-                                     strlen(type) + strlen(fmt));
+    if (initializer == 0) {
+       need = (strlen(entries->tterm.term_names)
+               + strlen(type)
+               + strlen(fmt));
+       initializer = (char *) malloc(need);
+    }
 
-    (void) strcpy(initializer, entries->tterm.term_names);
+    _nc_STRCPY(initializer, entries->tterm.term_names, need);
     for (s = initializer; *s != 0 && *s != '|'; s++) {
        if (!isalnum(UChar(*s)))
            *s = '_';
     }
     *s = 0;
-    (void) sprintf(s, fmt, type);
+    _nc_SPRINTF(s, _nc_SLIMIT(need) fmt, type);
     return initializer;
 }
 
@@ -1073,9 +1230,10 @@ dump_initializers(TERMTYPE *term)
 
        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 - buf) < MAX_STRING - 6;
+                *sp != 0 && TP_LIMIT > 2;
                 sp++) {
                if (isascii(UChar(*sp))
                    && isprint(UChar(*sp))
@@ -1083,7 +1241,7 @@ dump_initializers(TERMTYPE *term)
                    && *sp != '"')
                    *tp++ = *sp;
                else {
-                   (void) sprintf(tp, "\\%03o", UChar(*sp));
+                   _nc_SPRINTF(tp, _nc_SLIMIT(TP_LIMIT) "\\%03o", UChar(*sp));
                    tp += 4;
                }
            }
@@ -1133,7 +1291,7 @@ dump_initializers(TERMTYPE *term)
            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;
        }
@@ -1248,6 +1406,23 @@ terminal_env(void)
     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
@@ -1288,6 +1463,7 @@ main(int argc, char *argv[])
 #if NCURSES_XNAMES
     use_extended_names(FALSE);
 #endif
+    _nc_strict_bsd = 0;
 
     _nc_progname = _nc_rootname(argv[0]);
 
@@ -1298,8 +1474,13 @@ main(int argc, char *argv[])
 
     while ((c = getopt(argc,
                       argv,
-                      "1A:aB:CcdEeFfGgIiLlnpqR:rs:TtUuVv:w:x")) != -1) {
+                      "01A:aB:CcDdEeFfGgIiKLlnpqR:rs:TtUuVv:w:x")) != -1) {
        switch (c) {
+       case '0':
+           mwidth = 65535;
+           mheight = 1;
+           break;
+
        case '1':
            mwidth = 0;
            break;
@@ -1318,6 +1499,9 @@ main(int argc, char *argv[])
            restdir = optarg;
            break;
 
+       case 'K':
+           _nc_strict_bsd = 1;
+           /* FALLTHRU */
        case 'C':
            outform = F_TERMCAP;
            tversion = "BSD";
@@ -1325,6 +1509,11 @@ main(int argc, char *argv[])
                sortmode = S_TERMCAP;
            break;
 
+       case 'D':
+           show_databases();
+           ExitProgram(EXIT_SUCCESS);
+           break;
+
        case 'c':
            compare = C_COMMON;
            break;
@@ -1477,9 +1666,6 @@ main(int argc, char *argv[])
     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)
        argv[argc++] = terminal_env();
@@ -1488,9 +1674,23 @@ main(int argc, char *argv[])
     if (compare != C_DEFAULT && optind >= argc - 1)
        argv[argc++] = terminal_env();
 
+    /* exactly one terminal name with no options means display it */
     /* 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, mwidth, mheight, itrace, formatted);
 
     if (!filecompare) {
        /* grab the entries */
@@ -1508,9 +1708,11 @@ main(int argc, char *argv[])
 #else
 #define LEAF_FMT "%02x"
 #endif
-               (void) sprintf(tfile[termcount], "%s/" LEAF_FMT "/%s",
-                              directory,
-                              UChar(*argv[optind]), argv[optind]);
+               _nc_SPRINTF(tfile[termcount],
+                           _nc_SLIMIT(sizeof(path))
+                           "%s/" LEAF_FMT "/%s",
+                           directory,
+                           UChar(*argv[optind]), argv[optind]);
                if (itrace)
                    (void) fprintf(stderr,
                                   "%s: reading entry %s from file %s\n",
@@ -1600,27 +1802,17 @@ main(int argc, char *argv[])
                break;
 
            case C_DIFFERENCE:
-               if (itrace)
-                   (void) fprintf(stderr, "%s: dumping differences\n", _nc_progname);
-               (void) printf("comparing %s to %s.\n", tname[0], tname[1]);
+               show_comparing(tname);
                compare_entry(compare_predicate, &entries->tterm, quiet);
                break;
 
            case C_COMMON:
-               if (itrace)
-                   (void) fprintf(stderr,
-                                  "%s: dumping common capabilities\n",
-                                  _nc_progname);
-               (void) printf("comparing %s to %s.\n", tname[0], tname[1]);
+               show_comparing(tname);
                compare_entry(compare_predicate, &entries->tterm, quiet);
                break;
 
            case C_NAND:
-               if (itrace)
-                   (void) fprintf(stderr,
-                                  "%s: dumping differences\n",
-                                  _nc_progname);
-               (void) printf("comparing %s to %s.\n", tname[0], tname[1]);
+               show_comparing(tname);
                compare_entry(compare_predicate, &entries->tterm, quiet);
                break;
 
@@ -1641,15 +1833,16 @@ main(int argc, char *argv[])
                break;
            }
        }
-    } else if (compare == C_USEALL)
+    } else if (compare == C_USEALL) {
        (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");
-    else if (argc - optind != 2)
+    } else if (argc - optind != 2) {
        (void) fprintf(stderr,
                       "File comparison needs exactly two file arguments.\n");
-    else
+    } else {
        file_comparison(argc - optind, argv + optind);
+    }
 
     MAIN_LEAKS();
     ExitProgram(EXIT_SUCCESS);