ncurses 6.0 - patch 20150711

[ncurses.git] / progs / dump_entry.c

diff --git a/progs/dump_entry.c b/progs/dump_entry.c
index 95f5323d5af89f68eb7e11587ef6e94d60c005af..d59a925d55110a41c4df66c8fe5de65ba8e3b369 100644 (file)
--- a/progs/dump_entry.c
+++ b/progs/dump_entry.c
@@ -1,5 +1,5 @@
 /****************************************************************************
- * Copyright (c) 1998-2012,2013 Free Software Foundation, Inc.              *
+ * Copyright (c) 1998-2014,2015 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            *
@@ -39,7 +39,7 @@
 #include "termsort.c"          /* this C file is generated */
 #include <parametrized.h>      /* so is this */
 
-MODULE_ID("$Id: dump_entry.c,v 1.107 2013/03/17 00:27:15 tom Exp $")
+MODULE_ID("$Id: dump_entry.c,v 1.118 2015/07/07 08:06:39 Werner.Fink Exp $")
 
 #define INDENT                 8
 #define DISCARD(string) string = ABSENT_STRING
@@ -61,6 +61,7 @@ static int height = 65535;    /* max number of lines for listings */
 static int column;             /* current column, limited by 'width' */
 static int oldcol;             /* last value of column before wrap */
 static bool pretty;            /* true if we format if-then-else strings */
+static bool checking;          /* true if we are checking for tic */
 
 static char *save_sgr;
 
@@ -73,7 +74,7 @@ static NCURSES_CONST char *const *bool_names;
 static NCURSES_CONST char *const *num_names;
 static NCURSES_CONST char *const *str_names;
 
-static const char *separator, *trailer;
+static const char *separator = "", *trailer = "";
 
 /* cover various ports and variants of terminfo */
 #define V_ALLCAPS      0       /* all capabilities (SVr4, XSI, ncurses) */
@@ -155,17 +156,17 @@ _nc_leaks_dump_entry(void)
 #endif
 
 #define NameTrans(check,result) \
-           if (OkIndex(np->nte_index, check) \
+           if ((np->nte_index <= OK_ ## check) \
                && check[np->nte_index]) \
                return (result[np->nte_index])
 
 NCURSES_CONST char *
 nametrans(const char *name)
-/* translate a capability name from termcap to terminfo */
+/* translate a capability name to termcap from terminfo */
 {
     const struct name_table_entry *np;
 
-    if ((np = _nc_find_entry(name, _nc_get_hash_table(0))) != 0)
+    if ((np = _nc_find_entry(name, _nc_get_hash_table(0))) != 0) {
        switch (np->nte_type) {
        case BOOLEAN:
            NameTrans(bool_from_termcap, boolcodes);
@@ -179,6 +180,7 @@ nametrans(const char *name)
            NameTrans(str_from_termcap, strcodes);
            break;
        }
+    }
 
     return (0);
 }
@@ -190,12 +192,14 @@ dump_init(const char *version,
          int twidth,
          int theight,
          unsigned traceval,
-         bool formatted)
+         bool formatted,
+         bool check)
 /* set up for entry display */
 {
     width = twidth;
     height = theight;
     pretty = formatted;
+    checking = check;
 
     /* versions */
     if (version == 0)
@@ -309,7 +313,11 @@ dump_predicate(PredType type, PredIdx idx)
 static void set_obsolete_termcaps(TERMTYPE *tp);
 
 /* is this the index of a function key string? */
-#define FNKEY(i)       (((i)<= 65 && (i)>= 75) || ((i)<= 216 && (i)>= 268))
+#define FNKEY(i) \
+    (((i) >= STR_IDX(key_f0) && \
+      (i) <= STR_IDX(key_f9)) || \
+     ((i) >= STR_IDX(key_f11) && \
+      (i) <= STR_IDX(key_f63)))
 
 /*
  * If we configure with a different Caps file, the offsets into the arrays
@@ -463,10 +471,10 @@ indent_DYN(DYNBUF * buffer, int level)
     int n;
 
     for (n = 0; n < level; n++)
-       strncpy_DYN(buffer, "\t", 1);
+       strncpy_DYN(buffer, "\t", (size_t) 1);
 }
 
-static bool
+bool
 has_params(const char *src)
 {
     bool result = FALSE;
@@ -476,9 +484,9 @@ has_params(const char *src)
     bool params = FALSE;
 
     for (n = 0; n < len - 1; ++n) {
-       if (!strncmp(src + n, "%p", 2)) {
+       if (!strncmp(src + n, "%p", (size_t) 2)) {
            params = TRUE;
-       } else if (!strncmp(src + n, "%;", 2)) {
+       } else if (!strncmp(src + n, "%;", (size_t) 2)) {
            ifthen = TRUE;
            result = params;
            break;
@@ -500,7 +508,7 @@ fmt_complex(TERMTYPE *tterm, const char *capability, char *src, int level)
        switch (*src) {
        case '\\':
            percent = FALSE;
-           strncpy_DYN(&tmpbuf, src++, 1);
+           strncpy_DYN(&tmpbuf, src++, (size_t) 1);
            break;
        case '%':
            percent = TRUE;
@@ -514,28 +522,29 @@ fmt_complex(TERMTYPE *tterm, const char *capability, char *src, int level)
                /* treat a "%e" as else-if, on the same level */
                if (*src == 'e') {
                    indent_DYN(&tmpbuf, level);
-                   strncpy_DYN(&tmpbuf, "%", 1);
-                   strncpy_DYN(&tmpbuf, src, 1);
+                   strncpy_DYN(&tmpbuf, "%", (size_t) 1);
+                   strncpy_DYN(&tmpbuf, src, (size_t) 1);
                    src++;
                    params = has_params(src);
                    if (!params && *src != '\0' && *src != '%') {
-                       strncpy_DYN(&tmpbuf, "\n", 1);
+                       strncpy_DYN(&tmpbuf, "\n", (size_t) 1);
                        indent_DYN(&tmpbuf, level + 1);
                    }
                } else {
                    indent_DYN(&tmpbuf, level + 1);
-                   strncpy_DYN(&tmpbuf, "%", 1);
-                   strncpy_DYN(&tmpbuf, src, 1);
+                   strncpy_DYN(&tmpbuf, "%", (size_t) 1);
+                   strncpy_DYN(&tmpbuf, src, (size_t) 1);
                    if (*src++ == '?') {
                        src = fmt_complex(tterm, capability, src, level + 1);
                        if (*src != '\0' && *src != '%') {
-                           strncpy_DYN(&tmpbuf, "\n", 1);
+                           strncpy_DYN(&tmpbuf, "\n", (size_t) 1);
                            indent_DYN(&tmpbuf, level + 1);
                        }
                    } else if (level == 1) {
-                       _nc_warning("%s: %%%c without %%? in %s",
-                                   _nc_first_name(tterm->term_names),
-                                   *src, capability);
+                       if (checking)
+                           _nc_warning("%s: %%%c without %%? in %s",
+                                       _nc_first_name(tterm->term_names),
+                                       *src, capability);
                    }
                }
                continue;
@@ -547,8 +556,8 @@ fmt_complex(TERMTYPE *tterm, const char *capability, char *src, int level)
                if (level > 1) {
                    tmpbuf.text[tmpbuf.used - 1] = '\n';
                    indent_DYN(&tmpbuf, level);
-                   strncpy_DYN(&tmpbuf, "%", 1);
-                   strncpy_DYN(&tmpbuf, src++, 1);
+                   strncpy_DYN(&tmpbuf, "%", (size_t) 1);
+                   strncpy_DYN(&tmpbuf, src++, (size_t) 1);
                    if (src[0] == '%'
                        && src[1] != '\0'
                        && (strchr("?e;", src[1])) == 0) {
@@ -557,29 +566,30 @@ fmt_complex(TERMTYPE *tterm, const char *capability, char *src, int level)
                    }
                    return src;
                }
-               _nc_warning("%s: %%; without %%? in %s",
-                           _nc_first_name(tterm->term_names),
-                           capability);
+               if (checking)
+                   _nc_warning("%s: %%; without %%? in %s",
+                               _nc_first_name(tterm->term_names),
+                               capability);
            }
            break;
        case 'p':
            if (percent && params) {
                tmpbuf.text[tmpbuf.used - 1] = '\n';
                indent_DYN(&tmpbuf, level + 1);
-               strncpy_DYN(&tmpbuf, "%", 1);
+               strncpy_DYN(&tmpbuf, "%", (size_t) 1);
            }
            params = FALSE;
            percent = FALSE;
            break;
        case ' ':
-           strncpy_DYN(&tmpbuf, "\\s", 2);
+           strncpy_DYN(&tmpbuf, "\\s", (size_t) 2);
            ++src;
            continue;
        default:
            percent = FALSE;
            break;
        }
-       strncpy_DYN(&tmpbuf, src++, 1);
+       strncpy_DYN(&tmpbuf, src++, (size_t) 1);
     }
     return src;
 }
@@ -590,9 +600,9 @@ fmt_complex(TERMTYPE *tterm, const char *capability, char *src, int level)
 int
 fmt_entry(TERMTYPE *tterm,
          PredFunc pred,
-         bool content_only,
-         bool suppress_untranslatable,
-         bool infodump,
+         int content_only,
+         int suppress_untranslatable,
+         int infodump,
          int numbers)
 {
     PredIdx i, j;
@@ -768,6 +778,10 @@ fmt_entry(TERMTYPE *tterm,
                    trimmed_sgr0 = _nc_trim_sgr0(tterm);
                    if (strcmp(capability, trimmed_sgr0))
                        capability = trimmed_sgr0;
+                   else {
+                       if (trimmed_sgr0 != exit_attribute_mode)
+                           free(trimmed_sgr0);
+                   }
 
                    set_attributes = my_sgr;
                }
@@ -787,10 +801,13 @@ fmt_entry(TERMTYPE *tterm,
                            "%s@", name);
                WRAP_CONCAT;
            } else if (outform == F_TERMCAP || outform == F_TCONVERR) {
-               int params = ((i < (int) SIZEOF(parametrized))
-                             ? parametrized[i]
-                             : 0);
                char *srccap = _nc_tic_expand(capability, TRUE, numbers);
+               int params = (((i < (int) SIZEOF(parametrized)) &&
+                              (i < STRCOUNT))
+                             ? parametrized[i]
+                             : ((*srccap == 'k')
+                                ? 0
+                                : has_params(srccap)));
                char *cv = _nc_infotocap(name, srccap, params);
 
                if (cv == 0) {
@@ -872,7 +889,7 @@ fmt_entry(TERMTYPE *tterm,
 
            tp = boxchars;
            for (cp = acstrans; *cp; cp++) {
-               sp = strchr(acs_chars, *cp);
+               sp = (strchr) (acs_chars, *cp);
                if (sp)
                    *tp++ = sp[1];
                else {
@@ -1100,8 +1117,8 @@ purged_acs(TERMTYPE *tterm)
  */
 void
 dump_entry(TERMTYPE *tterm,
-          bool suppress_untranslatable,
-          bool limited,
+          int suppress_untranslatable,
+          int limited,
           int numbers,
           PredFunc pred)
 {