ncurses 6.1 - patch 20190810
[ncurses.git] / ncurses / tinfo / parse_entry.c
index 3fa2f254cb91dd650137efe1f3ed20e690f21adb..f8cca8b5747824f6a551c0b4d92a46b08757bf7c 100644 (file)
@@ -1,5 +1,5 @@
 /****************************************************************************
- * Copyright (c) 1998-2016,2017 Free Software Foundation, Inc.              *
+ * Copyright (c) 1998-2018,2019 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            *
@@ -47,7 +47,7 @@
 #include <ctype.h>
 #include <tic.h>
 
-MODULE_ID("$Id: parse_entry.c,v 1.86 2017/06/28 00:53:12 tom Exp $")
+MODULE_ID("$Id: parse_entry.c,v 1.97 2019/08/03 23:10:38 tom Exp $")
 
 #ifdef LINT
 static short const parametrized[] =
@@ -63,7 +63,7 @@ static struct name_table_entry const *lookup_fullname(const char *name);
 #if NCURSES_XNAMES
 
 static struct name_table_entry const *
-_nc_extend_names(ENTRY * entryp, char *name, int token_type)
+_nc_extend_names(ENTRY * entryp, const char *name, int token_type)
 {
     static struct name_table_entry temp;
     TERMTYPE2 *tp = &(entryp->tterm);
@@ -178,8 +178,55 @@ _nc_extend_names(ENTRY * entryp, char *name, int token_type)
 
     return &temp;
 }
+
+static const char *
+usertype2s(int mask)
+{
+    const char *result = "unknown";
+    if (mask & (1 << BOOLEAN)) {
+       result = "boolean";
+    } else if (mask & (1 << NUMBER)) {
+       result = "number";
+    } else if (mask & (1 << STRING)) {
+       result = "string";
+    }
+    return result;
+}
+
+static bool
+expected_type(const char *name, int token_type, bool silent)
+{
+    struct user_table_entry const *entry = _nc_find_user_entry(name);
+    bool result = TRUE;
+    if ((entry != 0) && (token_type != CANCEL)) {
+       int have_type = (1 << token_type);
+       if (!(entry->ute_type & have_type)) {
+           if (!silent)
+               _nc_warning("expected %s-type for %s, have %s",
+                           usertype2s(entry->ute_type),
+                           name,
+                           usertype2s(have_type));
+           result = FALSE;
+       }
+    }
+    return result;
+}
 #endif /* NCURSES_XNAMES */
 
+static bool
+valid_entryname(const char *name)
+{
+    bool result = TRUE;
+    int ch;
+    while ((ch = UChar(*name++)) != '\0') {
+       if (ch <= ' ' || ch > '~' || ch == '/') {
+           result = FALSE;
+           break;
+       }
+    }
+    return result;
+}
+
 /*
  *     int
  *     _nc_parse_entry(entry, literal, silent)
@@ -203,7 +250,7 @@ _nc_extend_names(ENTRY * entryp, char *name, int token_type)
        { bad_tc_usage = TRUE; \
         _nc_warning("Legacy termcap allows only a trailing tc= clause"); }
 
-#define MAX_NUMBER 0x7fff      /* positive shorts only */
+#define MAX_NUMBER MAX_OF_TYPE(NCURSES_INT2)
 
 NCURSES_EXPORT(int)
 _nc_parse_entry(ENTRY * entryp, int literal, bool silent)
@@ -211,6 +258,7 @@ _nc_parse_entry(ENTRY * entryp, int literal, bool silent)
     int token_type;
     struct name_table_entry const *entry_ptr;
     char *ptr, *base;
+    const char *name;
     bool bad_tc_usage = FALSE;
 
     token_type = _nc_get_token(silent);
@@ -261,7 +309,12 @@ _nc_parse_entry(ENTRY * entryp, int literal, bool silent)
      * results in the terminal type getting prematurely set to correspond
      * to that of the next entry.
      */
-    _nc_set_type(_nc_first_name(entryp->tterm.term_names));
+    name = _nc_first_name(entryp->tterm.term_names);
+    if (!valid_entryname(name)) {
+       _nc_warning("invalid entry name \"%s\"", name);
+       name = "invalid";
+    }
+    _nc_set_type(name);
 
     /* check for overly-long names and aliases */
     for (base = entryp->tterm.term_names; (ptr = strchr(base, '|')) != 0;
@@ -283,13 +336,24 @@ _nc_parse_entry(ENTRY * entryp, int literal, bool silent)
        bool is_use = (strcmp(_nc_curr_token.tk_name, "use") == 0);
        bool is_tc = !is_use && (strcmp(_nc_curr_token.tk_name, "tc") == 0);
        if (is_use || is_tc) {
+           if (!VALID_STRING(_nc_curr_token.tk_valstring)
+               || _nc_curr_token.tk_valstring[0] == '\0') {
+               _nc_warning("missing name for use-clause");
+               continue;
+           } else if (!valid_entryname(_nc_curr_token.tk_valstring)) {
+               _nc_warning("invalid name for use-clause \"%s\"",
+                           _nc_curr_token.tk_valstring);
+               continue;
+           } else if (entryp->nuses >= MAX_USES) {
+               _nc_warning("too many use-clauses, ignored \"%s\"",
+                           _nc_curr_token.tk_valstring);
+               continue;
+           }
            entryp->uses[entryp->nuses].name = _nc_save_str(_nc_curr_token.tk_valstring);
            entryp->uses[entryp->nuses].line = _nc_curr_line;
-           if (VALID_STRING(entryp->uses[entryp->nuses].name)) {
-               entryp->nuses++;
-               if (entryp->nuses > 1 && is_tc) {
-                   BAD_TC_USAGE
-               }
+           entryp->nuses++;
+           if (entryp->nuses > 1 && is_tc) {
+               BAD_TC_USAGE
            }
        } else {
            /* normal token lookup */
@@ -354,12 +418,20 @@ _nc_parse_entry(ENTRY * entryp, int literal, bool silent)
             * define a name based on its context.
             */
            if (entry_ptr == NOTFOUND
-               && _nc_user_definable
-               && (entry_ptr = _nc_extend_names(entryp,
-                                                _nc_curr_token.tk_name,
-                                                token_type)) != 0) {
-               if (_nc_tracing >= DEBUG_LEVEL(1))
-                   _nc_warning("extended capability '%s'", _nc_curr_token.tk_name);
+               && _nc_user_definable) {
+               if (expected_type(_nc_curr_token.tk_name, token_type, silent)) {
+                   if ((entry_ptr = _nc_extend_names(entryp,
+                                                     _nc_curr_token.tk_name,
+                                                     token_type)) != 0) {
+                       if (_nc_tracing >= DEBUG_LEVEL(1)) {
+                           _nc_warning("extended capability '%s'",
+                                       _nc_curr_token.tk_name);
+                       }
+                   }
+               } else {
+                   /* ignore it: we have already printed error message */
+                   continue;
+               }
            }
 #endif /* NCURSES_XNAMES */
 
@@ -458,11 +530,14 @@ _nc_parse_entry(ENTRY * entryp, int literal, bool silent)
                break;
 
            case NUMBER:
+#if !NCURSES_EXT_NUMBERS
                if (_nc_curr_token.tk_valnumber > MAX_NUMBER) {
                    entryp->tterm.Numbers[entry_ptr->nte_index] = MAX_NUMBER;
-               } else {
+               } else
+#endif
+               {
                    entryp->tterm.Numbers[entry_ptr->nte_index] =
-                       (short) _nc_curr_token.tk_valnumber;
+                       (NCURSES_INT2) _nc_curr_token.tk_valnumber;
                }
                break;
 
@@ -512,9 +587,11 @@ _nc_parse_entry(ENTRY * entryp, int literal, bool silent)
                 * Otherwise, look for a base entry that will already
                 * have picked up defaults via translation.
                 */
-               for (i = 0; i < entryp->nuses; i++)
-                   if (!strchr((char *) entryp->uses[i].name, '+'))
+               for (i = 0; i < entryp->nuses; i++) {
+                   if (entryp->uses[i].name != 0
+                       && !strchr(entryp->uses[i].name, '+'))
                        has_base_entry = TRUE;
+               }
            }
 
            postprocess_termcap(&entryp->tterm, has_base_entry);
@@ -640,13 +717,6 @@ static const char C_LF[] = "\n";
 static const char C_BS[] = "\b";
 static const char C_HT[] = "\t";
 
-/*
- * Note that WANTED and PRESENT are not simple inverses!  If a capability
- * has been explicitly cancelled, it's not considered WANTED.
- */
-#define WANTED(s)      ((s) == ABSENT_STRING)
-#define PRESENT(s)     (((s) != ABSENT_STRING) && ((s) != CANCELLED_STRING))
-
 /*
  * This bit of legerdemain turns all the terminfo variable names into
  * references to locations in the arrays Booleans, Numbers, and Strings ---
@@ -672,10 +742,10 @@ postprocess_termcap(TERMTYPE2 *tp, bool has_base)
 
     /* if there was a tc entry, assume we picked up defaults via that */
     if (!has_base) {
-       if (WANTED(init_3string) && termcap_init2)
+       if (WANTED(init_3string) && PRESENT(termcap_init2))
            init_3string = _nc_save_str(termcap_init2);
 
-       if (WANTED(reset_2string) && termcap_reset)
+       if (WANTED(reset_2string) && PRESENT(termcap_reset))
            reset_2string = _nc_save_str(termcap_reset);
 
        if (WANTED(carriage_return)) {
@@ -790,7 +860,7 @@ postprocess_termcap(TERMTYPE2 *tp, bool has_base)
        if (init_tabs != 8 && init_tabs != ABSENT_NUMERIC)
            _nc_warning("hardware tabs with a width other than 8: %d", init_tabs);
        else {
-           if (tab && _nc_capcmp(tab, C_HT))
+           if (PRESENT(tab) && _nc_capcmp(tab, C_HT))
                _nc_warning("hardware tabs with a non-^I tab string %s",
                            _nc_visbuf(tab));
            else {
@@ -867,17 +937,22 @@ postprocess_termcap(TERMTYPE2 *tp, bool has_base)
             * The magic moment -- copy the mapped key string over,
             * stripping out padding.
             */
-           for (dp = buf2, bp = tp->Strings[from_ptr->nte_index]; *bp; bp++) {
-               if (bp[0] == '$' && bp[1] == '<') {
-                   while (*bp && *bp != '>') {
-                       ++bp;
-                   }
-               } else
-                   *dp++ = *bp;
-           }
-           *dp = '\0';
+           bp = tp->Strings[from_ptr->nte_index];
+           if (VALID_STRING(bp)) {
+               for (dp = buf2; *bp; bp++) {
+                   if (bp[0] == '$' && bp[1] == '<') {
+                       while (*bp && *bp != '>') {
+                           ++bp;
+                       }
+                   } else
+                       *dp++ = *bp;
+               }
+               *dp = '\0';
 
-           tp->Strings[to_ptr->nte_index] = _nc_save_str(buf2);
+               tp->Strings[to_ptr->nte_index] = _nc_save_str(buf2);
+           } else {
+               tp->Strings[to_ptr->nte_index] = bp;
+           }
        }
 
        /*
@@ -886,7 +961,7 @@ postprocess_termcap(TERMTYPE2 *tp, bool has_base)
         * got mapped to kich1 and im to kIC to avoid a collision.
         * If the description has im but not ic, hack kIC back to kich1.
         */
-       if (foundim && WANTED(key_ic) && key_sic) {
+       if (foundim && WANTED(key_ic) && PRESENT(key_sic)) {
            key_ic = key_sic;
            key_sic = ABSENT_STRING;
        }
@@ -938,9 +1013,9 @@ postprocess_termcap(TERMTYPE2 *tp, bool has_base)
            acs_chars = _nc_save_str(buf2);
            _nc_warning("acsc string synthesized from XENIX capabilities");
        }
-    } else if (acs_chars == 0
-              && enter_alt_charset_mode != 0
-              && exit_alt_charset_mode != 0) {
+    } else if (acs_chars == ABSENT_STRING
+              && PRESENT(enter_alt_charset_mode)
+              && PRESENT(exit_alt_charset_mode)) {
        acs_chars = _nc_save_str(VT_ACSC);
     }
 }