ncurses 6.2 - patch 20200404
[ncurses.git] / ncurses / tinfo / comp_parse.c
index 9a0ce487b167b38c6e8e31e46c5f8420bb117c23..2a89a866c3744a2af67bbe97b38e403fac511675 100644 (file)
@@ -1,5 +1,6 @@
 /****************************************************************************
- * Copyright (c) 1998-2013,2016 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            *
 
 #include <tic.h>
 
-MODULE_ID("$Id: comp_parse.c,v 1.92 2016/09/10 20:08:32 tom Exp $")
+MODULE_ID("$Id: comp_parse.c,v 1.110 2020/02/29 15:46:00 anonymous.maarten Exp $")
 
-static void sanity_check2(TERMTYPE *, bool);
-NCURSES_IMPEXP void NCURSES_API(*_nc_check_termtype2) (TERMTYPE *, bool) = sanity_check2;
+static void sanity_check2(TERMTYPE2 *, bool);
+NCURSES_IMPEXP void (NCURSES_API *_nc_check_termtype2) (TERMTYPE2 *, bool) = sanity_check2;
 
-/* obsolete: 20040705 */
-static void sanity_check(TERMTYPE *);
-NCURSES_IMPEXP void NCURSES_API(*_nc_check_termtype) (TERMTYPE *) = sanity_check;
-
-static void fixup_acsc(TERMTYPE *, int);
+static void fixup_acsc(TERMTYPE2 *, int);
 
 static void
 enqueue(ENTRY * ep)
@@ -84,7 +81,7 @@ force_bar(char *dst, char *src)
        size_t len = strlen(src);
        if (len > MAX_NAME_SIZE)
            len = MAX_NAME_SIZE;
-       _nc_STRNCPY(dst, src, len);
+       _nc_STRNCPY(dst, src, MAX_NAME_SIZE);
        _nc_STRCPY(dst + len, "|", NAMEBUFFER_SIZE - len);
        src = dst;
     }
@@ -184,11 +181,11 @@ remove_collision(char *n1, char *n2)
                        ++qend;
                    while ((*qstart++ = *qend++) != '\0') ;
                    fprintf(stderr, "...now\t%s\n", p2);
+                   removed = TRUE;
                } else {
                    fprintf(stderr, "Cannot remove alias '%.*s'\n",
                            (int) (qend - qstart), qstart);
                }
-               removed = TRUE;
                break;
            }
        }
@@ -269,6 +266,126 @@ _nc_read_entry_source(FILE *fp, char *buf,
     _nc_suppress_warnings = oldsuppress;
 }
 
+#if NCURSES_XNAMES
+static unsigned
+find_capname(TERMTYPE2 *p, const char *name)
+{
+    unsigned num_names = NUM_EXT_NAMES(p);
+    unsigned n;
+    if (name != 0) {
+       for (n = 0; n < num_names; ++n) {
+           if (!strcmp(p->ext_Names[n], name))
+               break;
+       }
+    } else {
+       n = num_names + 1;
+    }
+    return n;
+}
+
+static int
+extended_captype(TERMTYPE2 *p, unsigned which)
+{
+    int result = UNDEF;
+    unsigned limit = 0;
+    limit += p->ext_Booleans;
+    if (limit != 0 && which < limit) {
+       result = BOOLEAN;
+    } else {
+       limit += p->ext_Numbers;
+       if (limit != 0 && which < limit) {
+           result = NUMBER;
+       } else {
+           limit += p->ext_Strings;
+           if (limit != 0 && which < limit) {
+               result = STRING;
+           } else if (which >= limit) {
+               result = CANCEL;
+           }
+       }
+    }
+    return result;
+}
+
+static const char *
+name_of_captype(int which)
+{
+    const char *result = "?";
+    switch (which) {
+    case BOOLEAN:
+       result = "boolean";
+       break;
+    case NUMBER:
+       result = "number";
+       break;
+    case STRING:
+       result = "string";
+       break;
+    }
+    return result;
+}
+
+#define valid_TERMTYPE2(p) \
+       ((p) != 0 && \
+        (p)->term_names != 0 && \
+        (p)->ext_Names != 0)
+
+/*
+ * Disallow changing the type of an extended capability when doing a "use"
+ * if one or the other is a string.
+ */
+static int
+invalid_merge(TERMTYPE2 *to, TERMTYPE2 *from)
+{
+    int rc = FALSE;
+    if (valid_TERMTYPE2(to)
+       && valid_TERMTYPE2(from)) {
+       char *to_name = _nc_first_name(to->term_names);
+       char *from_name = strdup(_nc_first_name(from->term_names));
+       unsigned num_names = NUM_EXT_NAMES(from);
+       unsigned n;
+
+       for (n = 0; n < num_names; ++n) {
+           const char *capname = from->ext_Names[n];
+           int tt = extended_captype(to, find_capname(to, capname));
+           int tf = extended_captype(from, n);
+
+           if (tt <= STRING
+               && tf <= STRING
+               && (tt == STRING) != (tf == STRING)) {
+               if (from_name != 0 && strcmp(to_name, from_name)) {
+                   DEBUG(2,
+                         ("merge of %s to %s changes type of %s from %s to %s",
+                          from_name,
+                          to_name,
+                          from->ext_Names[n],
+                          name_of_captype(tf),
+                          name_of_captype(tt)));
+               } else {
+                   DEBUG(2, ("merge of %s changes type of %s from %s to %s",
+                             to_name,
+                             from->ext_Names[n],
+                             name_of_captype(tf),
+                             name_of_captype(tt)));
+               }
+               _nc_warning("merge changes type of %s from %s to %s",
+                           from->ext_Names[n],
+                           name_of_captype(tf),
+                           name_of_captype(tt));
+               rc = TRUE;
+           }
+       }
+       free(from_name);
+    }
+    return rc;
+}
+#define validate_merge(p, q) \
+       if (invalid_merge(&((p)->tterm), &((q)->tterm))) \
+               return FALSE
+#else
+#define validate_merge(p, q)   /* nothing */
+#endif
+
 NCURSES_EXPORT(int)
 _nc_resolve_uses2(bool fullresolve, bool literal)
 /* try to resolve all use capabilities */
@@ -321,6 +438,9 @@ _nc_resolve_uses2(bool fullresolve, bool literal)
            char *lookfor = qp->uses[i].name;
            long lookline = qp->uses[i].line;
 
+           if (lookfor == 0)
+               continue;
+
            foundit = FALSE;
 
            _nc_set_type(child);
@@ -339,11 +459,11 @@ _nc_resolve_uses2(bool fullresolve, bool literal)
 
            /* if that didn't work, try to merge in a compiled entry */
            if (!foundit) {
-               TERMTYPE thisterm;
+               TERMTYPE2 thisterm;
                char filename[PATH_MAX];
 
                memset(&thisterm, 0, sizeof(thisterm));
-               if (_nc_read_entry(lookfor, filename, &thisterm) == 1) {
+               if (_nc_read_entry2(lookfor, filename, &thisterm) == 1) {
                    DEBUG(2, ("%s: resolving use=%s (compiled)",
                              child, lookfor));
 
@@ -384,7 +504,7 @@ _nc_resolve_uses2(bool fullresolve, bool literal)
      */
     if (fullresolve) {
        do {
-           TERMTYPE merged;
+           ENTRY merged;
 
            keepgoing = FALSE;
 
@@ -398,7 +518,8 @@ _nc_resolve_uses2(bool fullresolve, bool literal)
                     * subsequent pass.
                     */
                    for (i = 0; i < qp->nuses; i++)
-                       if (qp->uses[i].link->nuses) {
+                       if (qp->uses[i].link
+                           && qp->uses[i].link->nuses) {
                            DEBUG(2, ("%s: use entry %d unresolved",
                                      _nc_first_name(qp->tterm.term_names), i));
                            goto incomplete;
@@ -410,20 +531,24 @@ _nc_resolve_uses2(bool fullresolve, bool literal)
                     * the merged entry the name field and string
                     * table pointer.
                     */
-                   _nc_copy_termtype(&merged, &(qp->tterm));
+                   _nc_copy_termtype2(&(merged.tterm), &(qp->tterm));
 
                    /*
                     * Now merge in each use entry in the proper
                     * (reverse) order.
                     */
-                   for (; qp->nuses; qp->nuses--)
+                   for (; qp->nuses; qp->nuses--) {
+                       validate_merge(&merged,
+                                      qp->uses[qp->nuses - 1].link);
                        _nc_merge_entry(&merged,
-                                       &qp->uses[qp->nuses - 1].link->tterm);
+                                       qp->uses[qp->nuses - 1].link);
+                   }
 
                    /*
                     * Now merge in the original entry.
                     */
-                   _nc_merge_entry(&merged, &qp->tterm);
+                   validate_merge(&merged, qp);
+                   _nc_merge_entry(&merged, qp);
 
                    /*
                     * Replace the original entry with the merged one.
@@ -434,7 +559,7 @@ _nc_resolve_uses2(bool fullresolve, bool literal)
 #if NCURSES_XNAMES
                    FreeIfNeeded(qp->tterm.ext_Names);
 #endif
-                   qp->tterm = merged;
+                   qp->tterm = merged.tterm;
                    _nc_wrap_entry(qp, TRUE);
 
                    /*
@@ -461,54 +586,46 @@ _nc_resolve_uses2(bool fullresolve, bool literal)
 
     DEBUG(2, ("RESOLUTION FINISHED"));
 
-    if (fullresolve)
-       if (_nc_check_termtype != 0) {
-           _nc_curr_col = -1;
-           for_entry_list(qp) {
-               _nc_curr_line = (int) qp->startline;
-               _nc_set_type(_nc_first_name(qp->tterm.term_names));
+    if (fullresolve) {
+       _nc_curr_col = -1;
+       for_entry_list(qp) {
+           _nc_curr_line = (int) qp->startline;
+           _nc_set_type(_nc_first_name(qp->tterm.term_names));
+           /*
+            * tic overrides this function pointer to provide more verbose
+            * checking.
+            */
+           if (_nc_check_termtype2 != sanity_check2) {
+               SCREEN *save_SP = SP;
+               SCREEN fake_sp;
+               TERMINAL fake_tm;
+               TERMINAL *save_tm = cur_term;
+
                /*
-                * tic overrides this function pointer to provide more verbose
-                * checking.
+                * Setup so that tic can use ordinary terminfo interface to
+                * obtain capability information.
                 */
-               if (_nc_check_termtype2 != sanity_check2) {
-                   SCREEN *save_SP = SP;
-                   SCREEN fake_sp;
-                   TERMINAL fake_tm;
-                   TERMINAL *save_tm = cur_term;
-
-                   /*
-                    * Setup so that tic can use ordinary terminfo interface
-                    * to obtain capability information.
-                    */
-                   memset(&fake_sp, 0, sizeof(fake_sp));
-                   memset(&fake_tm, 0, sizeof(fake_tm));
-                   fake_sp._term = &fake_tm;
-                   fake_tm.type = qp->tterm;
-                   _nc_set_screen(&fake_sp);
-                   set_curterm(&fake_tm);
-
-                   _nc_check_termtype2(&qp->tterm, literal);
-
-                   _nc_set_screen(save_SP);
-                   set_curterm(save_tm);
-               } else {
-                   fixup_acsc(&qp->tterm, literal);
-               }
+               memset(&fake_sp, 0, sizeof(fake_sp));
+               memset(&fake_tm, 0, sizeof(fake_tm));
+               fake_sp._term = &fake_tm;
+               TerminalType(&fake_tm) = qp->tterm;
+               _nc_set_screen(&fake_sp);
+               set_curterm(&fake_tm);
+
+               _nc_check_termtype2(&qp->tterm, literal);
+
+               _nc_set_screen(save_SP);
+               set_curterm(save_tm);
+           } else {
+               fixup_acsc(&qp->tterm, literal);
            }
-           DEBUG(2, ("SANITY CHECK FINISHED"));
        }
+       DEBUG(2, ("SANITY CHECK FINISHED"));
+    }
 
     return (TRUE);
 }
 
-/* obsolete: 20040705 */
-NCURSES_EXPORT(int)
-_nc_resolve_uses(bool fullresolve)
-{
-    return _nc_resolve_uses2(fullresolve, FALSE);
-}
-
 /*
  * This bit of legerdemain turns all the terminfo variable names into
  * references to locations in the arrays Booleans, Numbers, and Strings ---
@@ -519,18 +636,18 @@ _nc_resolve_uses(bool fullresolve)
 #define CUR tp->
 
 static void
-fixup_acsc(TERMTYPE *tp, int literal)
+fixup_acsc(TERMTYPE2 *tp, int literal)
 {
     if (!literal) {
-       if (acs_chars == 0
-           && enter_alt_charset_mode != 0
-           && exit_alt_charset_mode != 0)
+       if (acs_chars == ABSENT_STRING
+           && PRESENT(enter_alt_charset_mode)
+           && PRESENT(exit_alt_charset_mode))
            acs_chars = strdup(VT_ACSC);
     }
 }
 
 static void
-sanity_check2(TERMTYPE *tp, bool literal)
+sanity_check2(TERMTYPE2 *tp, bool literal)
 {
     if (!PRESENT(exit_attribute_mode)) {
 #ifdef __UNUSED__              /* this casts too wide a net */
@@ -549,7 +666,9 @@ sanity_check2(TERMTYPE *tp, bool literal)
 #endif /* __UNUSED__ */
        PAIRED(enter_standout_mode, exit_standout_mode);
        PAIRED(enter_underline_mode, exit_underline_mode);
+#if defined(enter_italics_mode) && defined(exit_italics_mode)
        PAIRED(enter_italics_mode, exit_italics_mode);
+#endif
     }
 
     /* we do this check/fix in postprocess_termcap(), but some packagers
@@ -580,23 +699,18 @@ sanity_check2(TERMTYPE *tp, bool literal)
     PAIRED(enter_xon_mode, exit_xon_mode);
     PAIRED(enter_am_mode, exit_am_mode);
     ANDMISSING(label_off, label_on);
-#ifdef remove_clock
+#if defined(display_clock) && defined(remove_clock)
     PAIRED(display_clock, remove_clock);
 #endif
     ANDMISSING(set_color_pair, initialize_pair);
 }
 
-/* obsolete: 20040705 */
-static void
-sanity_check(TERMTYPE *tp)
-{
-    sanity_check2(tp, FALSE);
-}
-
 #if NO_LEAKS
 NCURSES_EXPORT(void)
 _nc_leaks_tic(void)
 {
+    T((T_CALLED("_nc_free_tic()")));
+    _nc_globals.leak_checking = TRUE;
     _nc_alloc_entry_leaks();
     _nc_captoinfo_leaks();
     _nc_comp_scan_leaks();
@@ -611,6 +725,6 @@ NCURSES_EXPORT(void)
 _nc_free_tic(int code)
 {
     _nc_leaks_tic();
-    _nc_free_tinfo(code);
+    exit_terminfo(code);
 }
 #endif