ncurses 6.2 - patch 20201024
[ncurses.git] / progs / dump_entry.c
index e21e05e03516227b3beb4b383b7a73185a865500..e084e0f0f541a507cba7aa71d75c36e059d18915 100644 (file)
@@ -1,5 +1,6 @@
 /****************************************************************************
- * Copyright (c) 1998-2016,2017 Free Software Foundation, Inc.              *
+ * Copyright 2018-2019,2020 Thomas E. Dickey                                *
+ * Copyright 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            *
@@ -39,7 +40,7 @@
 #include "termsort.c"          /* this C file is generated */
 #include <parametrized.h>      /* so is this */
 
-MODULE_ID("$Id: dump_entry.c,v 1.155 2017/07/08 18:34:53 tom Exp $")
+MODULE_ID("$Id: dump_entry.c,v 1.179 2020/07/08 21:21:11 tom Exp $")
 
 #define DISCARD(string) string = ABSENT_STRING
 #define PRINTF (void) printf
@@ -94,7 +95,7 @@ static int indent = 8;
 #define OBSOLETE(n) (n[0] == 'O' && n[1] == 'T')
 #endif
 
-#define isObsolete(f,n) ((f == F_TERMINFO || f == F_VARIABLE) && OBSOLETE(n))
+#define isObsolete(f,n) ((f == F_TERMINFO || f == F_VARIABLE) && (sortmode != S_VARIABLE) && OBSOLETE(n))
 
 #if NCURSES_XNAMES
 #define BoolIndirect(j) ((j >= BOOLCOUNT) ? (j) : ((sortmode == S_NOSORT) ? j : bool_indirect[j]))
@@ -499,8 +500,9 @@ find_split(const char *src, int step, int size)
                int ch = UChar(src[step + n]);
                if (ch == '%') {
                    int need = op_length(src, step + n);
-                   if ((n + need) > size)
+                   if ((n + need) > size) {
                        mark = n;
+                   }
                    break;
                }
            }
@@ -529,7 +531,7 @@ fill_spaces(const char *src)
        for (s = d = 0; src[s] != '\0'; ++s) {
            if (src[s] == ' ') {
                if (pass) {
-                   strcpy(&result[d], fill);
+                   _nc_STRCPY(&result[d], fill, need + 1 - d);
                    d += (int) size;
                } else {
                    need += size;
@@ -553,22 +555,34 @@ fill_spaces(const char *src)
     return result;
 }
 
+typedef enum {
+    wOFF = 0
+    ,w1ST = 1
+    ,w2ND = 2
+    ,wEND = 4
+    ,wERR = 8
+} WRAPMODE;
+
+#define wrap_1ST(mode) ((mode)&w1ST)
+#define wrap_END(mode) ((mode)&wEND)
+#define wrap_ERR(mode) ((mode)&wERR)
+
 static void
-wrap_concat(const char *src)
+wrap_concat(const char *src, int need, unsigned mode)
 {
-    int need = (int) strlen(src);
     int gaps = (int) strlen(separator);
     int want = gaps + need;
 
     did_wrap = (width <= 0);
-    if (column > indent
+    if (wrap_1ST(mode)
+       && column > indent
        && column + want > width) {
        force_wrap();
     }
-    if (wrapped &&
+    if ((wrap_END(mode) && !wrap_ERR(mode)) &&
+       wrapped &&
        (width >= 0) &&
-       (column + want) > width &&
-       (!TcOutput() || strncmp(src, "..", 2))) {
+       (column + want) > width) {
        int step = 0;
        int used = width > WRAPPED ? width : WRAPPED;
        int size;
@@ -583,18 +597,29 @@ wrap_concat(const char *src)
        if (TcOutput())
            trailer = "\\\n\t ";
 
-       if ((p = strchr(fill, '=')) != 0) {
+       if (!TcOutput() && (p = strchr(fill, '=')) != 0) {
            base = (int) (p + 1 - fill);
            if (base > 8)
                base = 8;
            _nc_SPRINTF(align, _nc_SLIMIT(align) "%*s", base, " ");
+       } else if (column > 8) {
+           base = column - 8;
+           if (base > 8)
+               base = 8;
+           _nc_SPRINTF(align, _nc_SLIMIT(align) "%*s", base, " ");
        } else {
            align[base] = '\0';
        }
        /* "pretty" overrides wrapping if it already split the line */
        if (!pretty || strchr(fill, '\n') == 0) {
+           int tag = 0;
+
+           if (TcOutput() && outbuf.used && !wrap_1ST(mode)) {
+               tag = 3;
+           }
+
            while ((column + (need + gaps)) > used) {
-               size = used;
+               size = used - tag;
                if (step) {
                    strcpy_DYN(&outbuf, align);
                    size -= base;
@@ -609,6 +634,7 @@ wrap_concat(const char *src)
                if (need > 0) {
                    force_wrap();
                    did_wrap = TRUE;
+                   tag = 0;
                }
            }
        }
@@ -617,18 +643,39 @@ wrap_concat(const char *src)
                strcpy_DYN(&outbuf, align);
            strcpy_DYN(&outbuf, fill + step);
        }
-       strcpy_DYN(&outbuf, separator);
+       if (wrap_END(mode))
+           strcpy_DYN(&outbuf, separator);
        trailer = my_t;
        force_wrap();
 
        free(fill);
     } else {
        strcpy_DYN(&outbuf, src);
-       strcpy_DYN(&outbuf, separator);
-       column += need;
+       if (wrap_END(mode))
+           strcpy_DYN(&outbuf, separator);
+       column += (int) strlen(src);
     }
 }
 
+static void
+wrap_concat1(const char *src)
+{
+    int need = (int) strlen(src);
+    wrap_concat(src, need, w1ST | wEND);
+}
+
+static void
+wrap_concat3(const char *name, const char *eqls, const char *value)
+{
+    int nlen = (int) strlen(name);
+    int elen = (int) strlen(eqls);
+    int vlen = (int) strlen(value);
+
+    wrap_concat(name, nlen + elen + vlen, w1ST);
+    wrap_concat(eqls, elen + vlen, w2ND);
+    wrap_concat(value, vlen, wEND);
+}
+
 #define IGNORE_SEP_TRAIL(first,last,sep_trail) \
        if ((size_t)(last - first) > sizeof(sep_trail)-1 \
         && !strncmp(first, sep_trail, sizeof(sep_trail)-1)) \
@@ -672,6 +719,33 @@ indent_DYN(DYNBUF * buffer, int level)
        strncpy_DYN(buffer, "\t", (size_t) 1);
 }
 
+/*
+ * Check if the current line which was begun consists only of a tab and the
+ * given leading text.
+ */
+static bool
+leading_DYN(DYNBUF * buffer, const char *leading)
+{
+    bool result = FALSE;
+    size_t need = strlen(leading);
+    if (buffer->used > need) {
+       need = buffer->used - need;
+       if (!strcmp(buffer->text + need, leading)) {
+           result = TRUE;
+           while (--need != 0) {
+               if (buffer->text[need] == '\n') {
+                   break;
+               }
+               if (buffer->text[need] != '\t') {
+                   result = FALSE;
+                   break;
+               }
+           }
+       }
+    }
+    return result;
+}
+
 bool
 has_params(const char *src)
 {
@@ -775,7 +849,7 @@ fmt_complex(TERMTYPE2 *tterm, const char *capability, char *src, int level)
            }
            break;
        case 'p':
-           if (percent && params) {
+           if (percent && params && !leading_DYN(&tmpbuf, "%")) {
                tmpbuf.text[tmpbuf.used - 1] = '\n';
                indent_DYN(&tmpbuf, level + 1);
                strncpy_DYN(&tmpbuf, "%", (size_t) 1);
@@ -841,9 +915,7 @@ fmt_entry(TERMTYPE2 *tterm,
     PredIdx num_strings = 0;
     bool outcount = 0;
 
-#define WRAP_CONCAT1(s)                wrap_concat(s); outcount = TRUE
-#define WRAP_CONCAT2(a,b)      wrap_concat(a); WRAP_CONCAT1(b)
-#define WRAP_CONCAT3(a,b,c)    wrap_concat(a); WRAP_CONCAT2(b,c)
+#define WRAP_CONCAT1(s)                wrap_concat1(s); outcount = TRUE
 #define WRAP_CONCAT            WRAP_CONCAT1(buffer)
 
     len = 12;                  /* terminfo file-header */
@@ -943,12 +1015,12 @@ fmt_entry(TERMTYPE2 *tterm,
 #undef CUR
 #define CUR tterm->
     if (outform == F_TERMCAP) {
-       if (termcap_reset != ABSENT_STRING) {
-           if (init_3string != ABSENT_STRING
+       if (VALID_STRING(termcap_reset)) {
+           if (VALID_STRING(init_3string)
                && !strcmp(init_3string, termcap_reset))
                DISCARD(init_3string);
 
-           if (reset_2string != ABSENT_STRING
+           if (VALID_STRING(reset_2string)
                && !strcmp(reset_2string, termcap_reset))
                DISCARD(reset_2string);
        }
@@ -1024,7 +1096,7 @@ fmt_entry(TERMTYPE2 *tterm,
        buffer[0] = '\0';
 
        if (predval != FAIL) {
-           if (capability != ABSENT_STRING
+           if (VALID_STRING(capability)
                && i + 1 > num_strings)
                num_strings = i + 1;
 
@@ -1034,8 +1106,7 @@ fmt_entry(TERMTYPE2 *tterm,
                WRAP_CONCAT;
            } else if (TcOutput()) {
                char *srccap = _nc_tic_expand(capability, TRUE, numbers);
-               int params = (((i < (int) SIZEOF(parametrized)) &&
-                              (i < STRCOUNT))
+               int params = ((i < (int) SIZEOF(parametrized))
                              ? parametrized[i]
                              : ((*srccap == 'k')
                                 ? 0
@@ -1052,9 +1123,9 @@ fmt_entry(TERMTYPE2 *tterm,
                        continue;
                    } else {
                        char *s = srccap, *d = buffer;
-                       WRAP_CONCAT3("..", name, "=");
+                       int need = 3 + (int) strlen(name);
                        while ((*d = *s++) != 0) {
-                           if ((d - buffer + 1) >= (int) sizeof(buffer)) {
+                           if ((d - buffer + 2) >= (int) sizeof(buffer)) {
                                fprintf(stderr,
                                        "%s: value for %s is too long\n",
                                        _nc_progname,
@@ -1066,14 +1137,24 @@ fmt_entry(TERMTYPE2 *tterm,
                                *d++ = '\\';
                                *d = ':';
                            } else if (*d == '\\') {
-                               *++d = *s++;
+                               if ((*++d = *s++) == '\0')
+                                   break;
                            }
                            d++;
+                           *d = '\0';
                        }
-                       WRAP_CONCAT;
+                       need += (int) (d - buffer);
+                       wrap_concat("..", need, w1ST | wERR);
+                       need -= 2;
+                       wrap_concat(name, need, wOFF | wERR);
+                       need -= (int) strlen(name);
+                       wrap_concat("=", need, w2ND | wERR);
+                       need -= 1;
+                       wrap_concat(buffer, need, wEND | wERR);
+                       outcount = TRUE;
                    }
                } else {
-                   WRAP_CONCAT3(name, "=", cv);
+                   wrap_concat3(name, "=", cv);
                }
                len += (int) strlen(capability) + 1;
            } else {
@@ -1095,8 +1176,7 @@ fmt_entry(TERMTYPE2 *tterm,
            }
        }
        /* e.g., trimmed_sgr0 */
-       if (capability != ABSENT_STRING &&
-           capability != CANCELLED_STRING &&
+       if (VALID_STRING(capability) &&
            capability != tterm->Strings[i])
            free(capability);
     }
@@ -1267,7 +1347,8 @@ kill_labels(TERMTYPE2 *tterm, int target)
 
     for (n = 0; n <= 10; ++n) {
        _nc_SPRINTF(name, _nc_SLIMIT(sizeof(name)) "lf%d", n);
-       if ((cap = find_string(tterm, name)) != ABSENT_STRING
+       cap = find_string(tterm, name);
+       if (VALID_STRING(cap)
            && kill_string(tterm, cap)) {
            target -= (int) (strlen(cap) + 5);
            ++result;
@@ -1292,7 +1373,8 @@ kill_fkeys(TERMTYPE2 *tterm, int target)
 
     for (n = 60; n >= 0; --n) {
        _nc_SPRINTF(name, _nc_SLIMIT(sizeof(name)) "kf%d", n);
-       if ((cap = find_string(tterm, name)) != ABSENT_STRING
+       cap = find_string(tterm, name);
+       if (VALID_STRING(cap)
            && kill_string(tterm, cap)) {
            target -= (int) (strlen(cap) + 5);
            ++result;
@@ -1314,9 +1396,9 @@ one_one_mapping(const char *mapping)
 {
     bool result = TRUE;
 
-    if (mapping != ABSENT_STRING) {
+    if (VALID_STRING(mapping)) {
        int n = 0;
-       while (mapping[n] != '\0') {
+       while (mapping[n] != '\0' && mapping[n + 1] != '\0') {
            if (isLine(mapping[n]) &&
                mapping[n] != mapping[n + 1]) {
                result = FALSE;
@@ -1406,12 +1488,12 @@ dump_entry(TERMTYPE2 *tterm,
            char numbuf[80];
            if (quickdump & 1) {
                if (outbuf.used)
-                   wrap_concat("\n");
-               wrap_concat("hex:");
+                   wrap_concat1("\n");
+               wrap_concat1("hex:");
                for (n = 0; n < offset; ++n) {
                    _nc_SPRINTF(numbuf, _nc_SLIMIT(sizeof(numbuf))
                                "%02X", UChar(bigbuf[n]));
-                   wrap_concat(numbuf);
+                   wrap_concat1(numbuf);
                }
            }
            if (quickdump & 2) {
@@ -1419,24 +1501,24 @@ dump_entry(TERMTYPE2 *tterm,
                {0, 0};
                int value = 0;
                if (outbuf.used)
-                   wrap_concat("\n");
-               wrap_concat("b64:");
+                   wrap_concat1("\n");
+               wrap_concat1("b64:");
                for (n = 0; n < offset; ++n) {
                    encode_b64(numbuf, bigbuf, n, &value);
-                   wrap_concat(numbuf);
+                   wrap_concat1(numbuf);
                }
                switch (n % 3) {
                case 0:
                    break;
                case 1:
                    encode_b64(numbuf, padding, 1, &value);
-                   wrap_concat(numbuf);
-                   wrap_concat("==");
+                   wrap_concat1(numbuf);
+                   wrap_concat1("==");
                    break;
                case 2:
                    encode_b64(numbuf, padding, 1, &value);
-                   wrap_concat(numbuf);
-                   wrap_concat("=");
+                   wrap_concat1(numbuf);
+                   wrap_concat1("=");
                    break;
                }
            }
@@ -1564,7 +1646,7 @@ dump_uses(const char *name, bool infodump)
        trim_trailing();
     _nc_SPRINTF(buffer, _nc_SLIMIT(sizeof(buffer))
                "%s%s", infodump ? "use=" : "tc=", name);
-    wrap_concat(buffer);
+    wrap_concat1(buffer);
 }
 
 int