ncurses 6.4 - patch 20240420

[ncurses.git] / ncurses / tinfo / alloc_entry.c

diff --git a/ncurses/tinfo/alloc_entry.c b/ncurses/tinfo/alloc_entry.c
index 48df0fd66dee6f6b1e11853f632c411ba0794f77..6280ad4a2b2ff8f4382cfaca2d9374e5a933dfc5 100644 (file)
--- a/ncurses/tinfo/alloc_entry.c
+++ b/ncurses/tinfo/alloc_entry.c
@@ -1,5 +1,5 @@
 /****************************************************************************
 /****************************************************************************

- * Copyright 2018-2021,2022 Thomas E. Dickey                                *
+ * Copyright 2018-2022,2023 Thomas E. Dickey                                *

  * Copyright 1998-2013,2017 Free Software Foundation, Inc.                  *
  *                                                                          *
  * Permission is hereby granted, free of charge, to any person obtaining a  *
  * Copyright 1998-2013,2017 Free Software Foundation, Inc.                  *
  *                                                                          *
  * Permission is hereby granted, free of charge, to any person obtaining a  *


@@ -48,7 +48,7 @@
 
 #include <tic.h>
 
 
 #include <tic.h>
 

-MODULE_ID("$Id: alloc_entry.c,v 1.71 2022/04/30 18:36:01 tom Exp $")
+MODULE_ID("$Id: alloc_entry.c,v 1.79 2023/09/15 08:16:12 tom Exp $")

 
 #define ABSENT_OFFSET    -1
 #define CANCELLED_OFFSET -2
 
 #define ABSENT_OFFSET    -1
 #define CANCELLED_OFFSET -2


@@ -60,7 +60,7 @@ NCURSES_EXPORT(void)
 _nc_init_entry(ENTRY * const tp)
 /* initialize a terminal type data block */
 {
 _nc_init_entry(ENTRY * const tp)
 /* initialize a terminal type data block */
 {

-    DEBUG(2, (T_CALLED("_nc_init_entry(tp=%p)"), tp));
+    DEBUG(2, (T_CALLED("_nc_init_entry(tp=%p)"), (void *) tp));

 
     if (tp == NULL) {
 #if NO_LEAKS
 
     if (tp == NULL) {
 #if NO_LEAKS


@@ -88,7 +88,7 @@ _nc_copy_entry(ENTRY * oldp)
 {
     ENTRY *newp;
 
 {
     ENTRY *newp;
 

-    DEBUG(2, (T_CALLED("_nc_copy_entry(oldp=%p)"), oldp));
+    DEBUG(2, (T_CALLED("_nc_copy_entry(oldp=%p)"), (void *) oldp));

 
     newp = typeCalloc(ENTRY, 1);
     if (newp != NULL) {
 
     newp = typeCalloc(ENTRY, 1);
     if (newp != NULL) {


@@ -96,7 +96,7 @@ _nc_copy_entry(ENTRY * oldp)
        _nc_copy_termtype2(&(newp->tterm), &(oldp->tterm));
     }
 
        _nc_copy_termtype2(&(newp->tterm), &(oldp->tterm));
     }
 

-    DEBUG(2, (T_RETURN("%p"), newp));
+    DEBUG(2, (T_RETURN("%p"), (void *) newp));

     return (newp);
 }
 
     return (newp);
 }
 


@@ -106,9 +106,10 @@ _nc_save_str(const char *string)
 {
     char *result = 0;
     size_t old_next_free = next_free;
 {
     char *result = 0;
     size_t old_next_free = next_free;

-    size_t len;

 
     if (stringbuf != NULL) {
 
     if (stringbuf != NULL) {

+       size_t len;
+

        if (!VALID_STRING(string))
            string = "";
        len = strlen(string) + 1;
        if (!VALID_STRING(string))
            string = "";
        len = strlen(string) + 1;


@@ -144,6 +145,8 @@ _nc_wrap_entry(ENTRY * const ep, bool copy_strings)
     unsigned nuses;
     TERMTYPE2 *tp;
 
     unsigned nuses;
     TERMTYPE2 *tp;
 

+    DEBUG(2, (T_CALLED("_nc_wrap_entry(ep=%p, copy_strings=%d)"), (void *)
+             ep, copy_strings));

     if (ep == NULL || stringbuf == NULL)
        _nc_err_abort("_nc_wrap_entry called without initialization");
 
     if (ep == NULL || stringbuf == NULL)
        _nc_err_abort("_nc_wrap_entry called without initialization");
 


@@ -155,8 +158,7 @@ _nc_wrap_entry(ENTRY * const ep, bool copy_strings)
        /* copy term_names, Strings, uses */
        tp->term_names = _nc_save_str(tp->term_names);
        for_each_string(i, tp) {
        /* copy term_names, Strings, uses */
        tp->term_names = _nc_save_str(tp->term_names);
        for_each_string(i, tp) {

-           if (tp->Strings[i] != ABSENT_STRING &&
-               tp->Strings[i] != CANCELLED_STRING) {
+           if (VALID_STRING(tp->Strings[i])) {

                tp->Strings[i] = _nc_save_str(tp->Strings[i]);
            }
        }
                tp->Strings[i] = _nc_save_str(tp->Strings[i]);
            }
        }


@@ -231,11 +233,13 @@ _nc_wrap_entry(ENTRY * const ep, bool copy_strings)
 #endif
 
     for (i = 0; i < nuses; i++) {
 #endif
 
     for (i = 0; i < nuses; i++) {

-       if (useoffsets[i] == ABSENT_OFFSET)
+       if (useoffsets[i] == ABSENT_OFFSET) {

            ep->uses[i].name = 0;
            ep->uses[i].name = 0;

-       else
-           ep->uses[i].name = (tp->str_table + useoffsets[i]);
+       } else {
+           ep->uses[i].name = strdup(tp->str_table + useoffsets[i]);
+       }

     }
     }

+    DEBUG(2, (T_RETURN("")));

 }
 
 NCURSES_EXPORT(void)
 }
 
 NCURSES_EXPORT(void)


@@ -246,6 +250,8 @@ _nc_merge_entry(ENTRY * const target, ENTRY * const source)
     TERMTYPE2 *from = &(source->tterm);
 #if NCURSES_XNAMES
     TERMTYPE2 copy;
     TERMTYPE2 *from = &(source->tterm);
 #if NCURSES_XNAMES
     TERMTYPE2 copy;

+    size_t str_size, copy_size;
+    char *str_table;

 #endif
     unsigned i;
 
 #endif
     unsigned i;
 


@@ -256,6 +262,99 @@ _nc_merge_entry(ENTRY * const target, ENTRY * const source)
     _nc_copy_termtype2(&copy, from);
     from = &copy;
     _nc_align_termtype(to, from);
     _nc_copy_termtype2(&copy, from);
     from = &copy;
     _nc_align_termtype(to, from);

+    /*
+     * compute the maximum size of the string-table.
+     */
+    str_size = strlen(to->term_names) + 1;
+    for_each_string(i, from) {
+       if (VALID_STRING(from->Strings[i]))
+           str_size += strlen(from->Strings[i]) + 1;
+    }
+    for_each_string(i, to) {
+       if (VALID_STRING(to->Strings[i]))
+           str_size += strlen(to->Strings[i]) + 1;
+    }
+    /* allocate a string-table large enough for both source/target, and
+     * copy all of the strings into that table.  In the merge, we will
+     * select from the original source/target lists to construct a new
+     * target list.
+     */
+    if (str_size != 0) {
+       char *str_copied;
+       if ((str_table = malloc(str_size)) == NULL)
+           _nc_err_abort(MSG_NO_MEMORY);
+       str_copied = str_table;
+       _nc_STRCPY(str_copied, to->term_names, str_size);
+       to->term_names = str_copied;
+       copy_size = strlen(str_copied) + 1;
+       str_copied += copy_size;
+       str_size -= copy_size;
+       for_each_string(i, from) {
+           if (VALID_STRING(from->Strings[i])) {
+               _nc_STRCPY(str_copied, from->Strings[i], str_size);
+               from->Strings[i] = str_copied;
+               copy_size = strlen(str_copied) + 1;
+               str_copied += copy_size;
+               str_size -= copy_size;
+           }
+       }
+       for_each_string(i, to) {
+           if (VALID_STRING(to->Strings[i])) {
+               _nc_STRCPY(str_copied, to->Strings[i], str_size);
+               to->Strings[i] = str_copied;
+               copy_size = strlen(str_copied) + 1;
+               str_copied += copy_size;
+               str_size -= copy_size;
+           }
+       }
+       free(to->str_table);
+       to->str_table = str_table;
+       free(from->str_table);
+    }
+    /*
+     * Do the same for the extended-strings (i.e., lists of capabilities).
+     */
+    str_size = 0;
+    for (i = 0; i < NUM_EXT_NAMES(from); ++i) {
+       if (VALID_STRING(from->ext_Names[i]))
+           str_size += strlen(from->ext_Names[i]) + 1;
+    }
+    for (i = 0; i < NUM_EXT_NAMES(to); ++i) {
+       if (VALID_STRING(to->ext_Names[i]))
+           str_size += strlen(to->ext_Names[i]) + 1;
+    }
+    /* allocate a string-table large enough for both source/target, and
+     * copy all of the strings into that table.  In the merge, we will
+     * select from the original source/target lists to construct a new
+     * target list.
+     */
+    if (str_size != 0) {
+       char *str_copied;
+       if ((str_table = malloc(str_size)) == NULL)
+           _nc_err_abort(MSG_NO_MEMORY);
+       str_copied = str_table;
+       for (i = 0; i < NUM_EXT_NAMES(from); ++i) {
+           if (VALID_STRING(from->ext_Names[i])) {
+               _nc_STRCPY(str_copied, from->ext_Names[i], str_size);
+               from->ext_Names[i] = str_copied;
+               copy_size = strlen(str_copied) + 1;
+               str_copied += copy_size;
+               str_size -= copy_size;
+           }
+       }
+       for (i = 0; i < NUM_EXT_NAMES(to); ++i) {
+           if (VALID_STRING(to->ext_Names[i])) {
+               _nc_STRCPY(str_copied, to->ext_Names[i], str_size);
+               to->ext_Names[i] = str_copied;
+               copy_size = strlen(str_copied) + 1;
+               str_copied += copy_size;
+               str_size -= copy_size;
+           }
+       }
+       free(to->ext_str_table);
+       to->ext_str_table = str_table;
+       free(from->ext_str_table);
+    }

 #endif
     for_each_boolean(i, from) {
        if (to->Booleans[i] != (NCURSES_SBOOL) CANCELLED_BOOLEAN) {
 #endif
     for_each_boolean(i, from) {
        if (to->Booleans[i] != (NCURSES_SBOOL) CANCELLED_BOOLEAN) {


@@ -295,10 +394,7 @@ _nc_merge_entry(ENTRY * const target, ENTRY * const source)
        }
     }
 #if NCURSES_XNAMES
        }
     }
 #if NCURSES_XNAMES

-    /* Discard the data allocated in _nc_copy_termtype2, but do not use
-     * _nc_free_termtype2 because that frees the string-table (which is
-     * not allocated by _nc_copy_termtype2).
-     */
+    /* cleanup */

     free(copy.Booleans);
     free(copy.Numbers);
     free(copy.Strings);
     free(copy.Booleans);
     free(copy.Numbers);
     free(copy.Strings);