]> ncurses.scripts.mit.edu Git - ncurses.git/blob - ncurses/tinfo/alloc_entry.c
ncurses 6.4 - patch 20230121
[ncurses.git] / ncurses / tinfo / alloc_entry.c
1 /****************************************************************************
2  * Copyright 2018-2021,2022 Thomas E. Dickey                                *
3  * Copyright 1998-2013,2017 Free Software Foundation, Inc.                  *
4  *                                                                          *
5  * Permission is hereby granted, free of charge, to any person obtaining a  *
6  * copy of this software and associated documentation files (the            *
7  * "Software"), to deal in the Software without restriction, including      *
8  * without limitation the rights to use, copy, modify, merge, publish,      *
9  * distribute, distribute with modifications, sublicense, and/or sell       *
10  * copies of the Software, and to permit persons to whom the Software is    *
11  * furnished to do so, subject to the following conditions:                 *
12  *                                                                          *
13  * The above copyright notice and this permission notice shall be included  *
14  * in all copies or substantial portions of the Software.                   *
15  *                                                                          *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
19  * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
20  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
21  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
22  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
23  *                                                                          *
24  * Except as contained in this notice, the name(s) of the above copyright   *
25  * holders shall not be used in advertising or otherwise to promote the     *
26  * sale, use or other dealings in this Software without prior written       *
27  * authorization.                                                           *
28  ****************************************************************************/
29
30 /****************************************************************************
31  *  Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995               *
32  *     and: Eric S. Raymond <esr@snark.thyrsus.com>                         *
33  *     and: Thomas E. Dickey                        1996-on                 *
34  ****************************************************************************/
35
36 /*
37  * alloc_entry.c -- allocation functions for terminfo entries
38  *
39  *      _nc_copy_entry()
40  *      _nc_init_entry()
41  *      _nc_merge_entry()
42  *      _nc_save_str()
43  *      _nc_wrap_entry()
44  *
45  */
46
47 #include <curses.priv.h>
48
49 #include <tic.h>
50
51 MODULE_ID("$Id: alloc_entry.c,v 1.77 2022/10/15 19:37:33 tom Exp $")
52
53 #define ABSENT_OFFSET    -1
54 #define CANCELLED_OFFSET -2
55
56 static char *stringbuf;         /* buffer for string capabilities */
57 static size_t next_free;        /* next free character in stringbuf */
58
59 NCURSES_EXPORT(void)
60 _nc_init_entry(ENTRY * const tp)
61 /* initialize a terminal type data block */
62 {
63     DEBUG(2, (T_CALLED("_nc_init_entry(tp=%p)"), (void *) tp));
64
65     if (tp == NULL) {
66 #if NO_LEAKS
67         if (stringbuf != NULL) {
68             FreeAndNull(stringbuf);
69         }
70         return;
71 #else
72         _nc_err_abort("_nc_init_entry called without initialization");
73 #endif
74     }
75
76     if (stringbuf == NULL)
77         TYPE_CALLOC(char, (size_t) MAX_ENTRY_SIZE, stringbuf);
78
79     next_free = 0;
80
81     _nc_init_termtype(&(tp->tterm));
82
83     DEBUG(2, (T_RETURN("")));
84 }
85
86 NCURSES_EXPORT(ENTRY *)
87 _nc_copy_entry(ENTRY * oldp)
88 {
89     ENTRY *newp;
90
91     DEBUG(2, (T_CALLED("_nc_copy_entry(oldp=%p)"), (void *) oldp));
92
93     newp = typeCalloc(ENTRY, 1);
94     if (newp != NULL) {
95         *newp = *oldp;
96         _nc_copy_termtype2(&(newp->tterm), &(oldp->tterm));
97     }
98
99     DEBUG(2, (T_RETURN("%p"), (void *) newp));
100     return (newp);
101 }
102
103 /* save a copy of string in the string buffer */
104 NCURSES_EXPORT(char *)
105 _nc_save_str(const char *string)
106 {
107     char *result = 0;
108     size_t old_next_free = next_free;
109
110     if (stringbuf != NULL) {
111         size_t len;
112
113         if (!VALID_STRING(string))
114             string = "";
115         len = strlen(string) + 1;
116
117         if (len == 1 && next_free != 0) {
118             /*
119              * Cheat a little by making an empty string point to the end of the
120              * previous string.
121              */
122             if (next_free < MAX_ENTRY_SIZE) {
123                 result = (stringbuf + next_free - 1);
124             }
125         } else if (next_free + len < MAX_ENTRY_SIZE) {
126             _nc_STRCPY(&stringbuf[next_free], string, MAX_ENTRY_SIZE);
127             DEBUG(7, ("Saved string %s", _nc_visbuf(string)));
128             DEBUG(7, ("at location %d", (int) next_free));
129             next_free += len;
130             result = (stringbuf + old_next_free);
131         } else {
132             _nc_warning("Too much data, some is lost: %s", string);
133         }
134     }
135     return result;
136 }
137
138 NCURSES_EXPORT(void)
139 _nc_wrap_entry(ENTRY * const ep, bool copy_strings)
140 /* copy the string parts to allocated storage, preserving pointers to it */
141 {
142     int offsets[MAX_ENTRY_SIZE / sizeof(short)];
143     int useoffsets[MAX_USES];
144     unsigned i, n;
145     unsigned nuses;
146     TERMTYPE2 *tp;
147
148     DEBUG(2, (T_CALLED("_nc_wrap_entry(ep=%p, copy_strings=%d)"), (void *)
149               ep, copy_strings));
150     if (ep == NULL || stringbuf == NULL)
151         _nc_err_abort("_nc_wrap_entry called without initialization");
152
153     nuses = ep->nuses;
154     tp = &(ep->tterm);
155     if (copy_strings) {
156         next_free = 0;          /* clear static storage */
157
158         /* copy term_names, Strings, uses */
159         tp->term_names = _nc_save_str(tp->term_names);
160         for_each_string(i, tp) {
161             if (tp->Strings[i] != ABSENT_STRING &&
162                 tp->Strings[i] != CANCELLED_STRING) {
163                 tp->Strings[i] = _nc_save_str(tp->Strings[i]);
164             }
165         }
166
167         for (i = 0; i < nuses; i++) {
168             if (ep->uses[i].name == 0) {
169                 ep->uses[i].name = _nc_save_str(ep->uses[i].name);
170             }
171         }
172
173         free(tp->str_table);
174     }
175
176     assert(tp->term_names >= stringbuf);
177     n = (unsigned) (tp->term_names - stringbuf);
178     for_each_string(i, &(ep->tterm)) {
179         if (i < SIZEOF(offsets)) {
180             if (tp->Strings[i] == ABSENT_STRING) {
181                 offsets[i] = ABSENT_OFFSET;
182             } else if (tp->Strings[i] == CANCELLED_STRING) {
183                 offsets[i] = CANCELLED_OFFSET;
184             } else {
185                 offsets[i] = (int) (tp->Strings[i] - stringbuf);
186             }
187         }
188     }
189
190     for (i = 0; i < nuses; i++) {
191         if (ep->uses[i].name == 0)
192             useoffsets[i] = ABSENT_OFFSET;
193         else
194             useoffsets[i] = (int) (ep->uses[i].name - stringbuf);
195     }
196
197     TYPE_MALLOC(char, next_free, tp->str_table);
198     (void) memcpy(tp->str_table, stringbuf, next_free);
199
200     tp->term_names = tp->str_table + n;
201     for_each_string(i, &(ep->tterm)) {
202         if (i < SIZEOF(offsets)) {
203             if (offsets[i] == ABSENT_OFFSET) {
204                 tp->Strings[i] = ABSENT_STRING;
205             } else if (offsets[i] == CANCELLED_OFFSET) {
206                 tp->Strings[i] = CANCELLED_STRING;
207             } else {
208                 tp->Strings[i] = tp->str_table + offsets[i];
209             }
210         }
211     }
212
213 #if NCURSES_XNAMES
214     if (!copy_strings) {
215         if ((n = (unsigned) NUM_EXT_NAMES(tp)) != 0) {
216             if (n < SIZEOF(offsets)) {
217                 size_t length = 0;
218                 size_t offset;
219                 for (i = 0; i < n; i++) {
220                     length += strlen(tp->ext_Names[i]) + 1;
221                     offsets[i] = (int) (tp->ext_Names[i] - stringbuf);
222                 }
223                 TYPE_MALLOC(char, length, tp->ext_str_table);
224                 for (i = 0, offset = 0; i < n; i++) {
225                     tp->ext_Names[i] = tp->ext_str_table + offset;
226                     _nc_STRCPY(tp->ext_Names[i],
227                                stringbuf + offsets[i],
228                                length - offset);
229                     offset += strlen(tp->ext_Names[i]) + 1;
230                 }
231             }
232         }
233     }
234 #endif
235
236     for (i = 0; i < nuses; i++) {
237         if (useoffsets[i] == ABSENT_OFFSET) {
238             ep->uses[i].name = 0;
239         } else {
240             ep->uses[i].name = strdup(tp->str_table + useoffsets[i]);
241         }
242     }
243     DEBUG(2, (T_RETURN("")));
244 }
245
246 NCURSES_EXPORT(void)
247 _nc_merge_entry(ENTRY * const target, ENTRY * const source)
248 /* merge capabilities from `from' entry into `to' entry */
249 {
250     TERMTYPE2 *to = &(target->tterm);
251     TERMTYPE2 *from = &(source->tterm);
252 #if NCURSES_XNAMES
253     TERMTYPE2 copy;
254     size_t str_size;
255     char *str_table;
256 #endif
257     unsigned i;
258
259     if (source == 0 || from == 0 || target == 0 || to == 0)
260         return;
261
262 #if NCURSES_XNAMES
263     _nc_copy_termtype2(&copy, from);
264     from = &copy;
265     _nc_align_termtype(to, from);
266     /*
267      * compute the maximum size of the string-table.
268      */
269     str_size = strlen(to->term_names) + 1;
270     for_each_string(i, from) {
271         if (VALID_STRING(from->Strings[i]))
272             str_size += strlen(from->Strings[i]) + 1;
273     }
274     for_each_string(i, to) {
275         if (VALID_STRING(to->Strings[i]))
276             str_size += strlen(to->Strings[i]) + 1;
277     }
278     /* allocate a string-table large enough for both source/target, and
279      * copy all of the strings into that table.  In the merge, we will
280      * select from the original source/target lists to construct a new
281      * target list.
282      */
283     if (str_size != 0) {
284         char *str_copied;
285         if ((str_table = malloc(str_size)) == NULL)
286             _nc_err_abort(MSG_NO_MEMORY);
287         str_copied = str_table;
288         strcpy(str_copied, to->term_names);
289         to->term_names = str_copied;
290         str_copied += strlen(str_copied) + 1;
291         for_each_string(i, from) {
292             if (VALID_STRING(from->Strings[i])) {
293                 strcpy(str_copied, from->Strings[i]);
294                 from->Strings[i] = str_copied;
295                 str_copied += strlen(str_copied) + 1;
296             }
297         }
298         for_each_string(i, to) {
299             if (VALID_STRING(to->Strings[i])) {
300                 strcpy(str_copied, to->Strings[i]);
301                 to->Strings[i] = str_copied;
302                 str_copied += strlen(str_copied) + 1;
303             }
304         }
305         free(to->str_table);
306         to->str_table = str_table;
307         free(from->str_table);
308     }
309     /*
310      * Do the same for the extended-strings (i.e., lists of capabilities).
311      */
312     str_size = 0;
313     for (i = 0; i < NUM_EXT_NAMES(from); ++i) {
314         if (VALID_STRING(from->ext_Names[i]))
315             str_size += strlen(from->ext_Names[i]) + 1;
316     }
317     for (i = 0; i < NUM_EXT_NAMES(to); ++i) {
318         if (VALID_STRING(to->ext_Names[i]))
319             str_size += strlen(to->ext_Names[i]) + 1;
320     }
321     /* allocate a string-table large enough for both source/target, and
322      * copy all of the strings into that table.  In the merge, we will
323      * select from the original source/target lists to construct a new
324      * target list.
325      */
326     if (str_size != 0) {
327         char *str_copied;
328         if ((str_table = malloc(str_size)) == NULL)
329             _nc_err_abort(MSG_NO_MEMORY);
330         str_copied = str_table;
331         for (i = 0; i < NUM_EXT_NAMES(from); ++i) {
332             if (VALID_STRING(from->ext_Names[i])) {
333                 strcpy(str_copied, from->ext_Names[i]);
334                 from->ext_Names[i] = str_copied;
335                 str_copied += strlen(str_copied) + 1;
336             }
337         }
338         for (i = 0; i < NUM_EXT_NAMES(to); ++i) {
339             if (VALID_STRING(to->ext_Names[i])) {
340                 strcpy(str_copied, to->ext_Names[i]);
341                 to->ext_Names[i] = str_copied;
342                 str_copied += strlen(str_copied) + 1;
343             }
344         }
345         free(to->ext_str_table);
346         to->ext_str_table = str_table;
347         free(from->ext_str_table);
348     }
349 #endif
350     for_each_boolean(i, from) {
351         if (to->Booleans[i] != (NCURSES_SBOOL) CANCELLED_BOOLEAN) {
352             int mergebool = from->Booleans[i];
353
354             if (mergebool == CANCELLED_BOOLEAN)
355                 to->Booleans[i] = FALSE;
356             else if (mergebool == TRUE)
357                 to->Booleans[i] = (NCURSES_SBOOL) mergebool;
358         }
359     }
360
361     for_each_number(i, from) {
362         if (to->Numbers[i] != CANCELLED_NUMERIC) {
363             int mergenum = from->Numbers[i];
364
365             if (mergenum == CANCELLED_NUMERIC)
366                 to->Numbers[i] = ABSENT_NUMERIC;
367             else if (mergenum != ABSENT_NUMERIC)
368                 to->Numbers[i] = (NCURSES_INT2) mergenum;
369         }
370     }
371
372     /*
373      * Note: the copies of strings this makes don't have their own
374      * storage.  This is OK right now, but will be a problem if we
375      * we ever want to deallocate entries.
376      */
377     for_each_string(i, from) {
378         if (to->Strings[i] != CANCELLED_STRING) {
379             char *mergestring = from->Strings[i];
380
381             if (mergestring == CANCELLED_STRING)
382                 to->Strings[i] = ABSENT_STRING;
383             else if (mergestring != ABSENT_STRING)
384                 to->Strings[i] = mergestring;
385         }
386     }
387 #if NCURSES_XNAMES
388     /* cleanup */
389     free(copy.Booleans);
390     free(copy.Numbers);
391     free(copy.Strings);
392     free(copy.ext_Names);
393 #endif
394 }
395
396 #if NO_LEAKS
397 NCURSES_EXPORT(void)
398 _nc_alloc_entry_leaks(void)
399 {
400     if (stringbuf != NULL) {
401         FreeAndNull(stringbuf);
402     }
403     next_free = 0;
404 }
405 #endif