ncurses 6.2 - patch 20210508
[ncurses.git] / ncurses / tinfo / MKcaptab.sh
1 #!/bin/sh
2 ##############################################################################
3 # Copyright 2019,2020 Thomas E. Dickey                                       #
4 # Copyright 2007-2010,2011 Free Software Foundation, Inc.                    #
5 #                                                                            #
6 # Permission is hereby granted, free of charge, to any person obtaining a    #
7 # copy of this software and associated documentation files (the "Software"), #
8 # to deal in the Software without restriction, including without limitation  #
9 # the rights to use, copy, modify, merge, publish, distribute, distribute    #
10 # with modifications, sublicense, and/or sell copies of the Software, and to #
11 # permit persons to whom the Software is furnished to do so, subject to the  #
12 # following conditions:                                                      #
13 #                                                                            #
14 # The above copyright notice and this permission notice shall be included in #
15 # all copies or substantial portions of the Software.                        #
16 #                                                                            #
17 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR #
18 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   #
19 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL    #
20 # THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER      #
21 # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING    #
22 # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER        #
23 # DEALINGS IN THE SOFTWARE.                                                  #
24 #                                                                            #
25 # Except as contained in this notice, the name(s) of the above copyright     #
26 # holders shall not be used in advertising or otherwise to promote the sale, #
27 # use or other dealings in this Software without prior written               #
28 # authorization.                                                             #
29 ##############################################################################
30 # $Id: MKcaptab.sh,v 1.19 2020/02/02 23:34:34 tom Exp $
31
32 if test $# != 0
33 then
34         AWK="$1"; shift 1
35 else
36         AWK=awk
37 fi
38
39 if test $# != 0
40 then
41         OPT1="$1"; shift 1
42 else
43         OPT1="-0"
44 fi
45
46 if test $# != 0
47 then
48         OPT2="$1"; shift 1
49 else
50         OPT2="tinfo/MKcaptab.awk"
51 fi
52
53 cat <<EOF
54 /*
55  * generated by $0
56  */
57
58 EOF
59
60 cat <<'EOF'
61 /*
62  *      comp_captab.c -- The names of the capabilities indexed via a hash
63  *                       table for the compiler.
64  *
65  */
66
67 #include <curses.priv.h>
68 #include <tic.h>
69 #include <hashsize.h>
70
71 /* *INDENT-OFF* */
72 EOF
73
74 cat "$@" |./make_hash 1 info $OPT1
75 cat "$@" |./make_hash 3 cap  $OPT1
76
77 cat "$@" |$AWK -f $OPT2 bigstrings=$OPT1 tablename=capalias
78
79 cat "$@" |$AWK -f $OPT2 bigstrings=$OPT1 tablename=infoalias
80
81 cat <<EOF
82 /* *INDENT-ON* */
83
84 #if $OPT1
85 static void
86 next_string(const char *strings, unsigned *offset)
87 {
88     *offset += (unsigned) strlen(strings + *offset) + 1;
89 }
90
91 static const struct name_table_entry *
92 _nc_build_names(struct name_table_entry **actual,
93                 const name_table_data * source,
94                 const char *strings)
95 {
96     if (*actual == 0) {
97         *actual = typeCalloc(struct name_table_entry, CAPTABSIZE);
98         if (*actual != 0) {
99             unsigned n;
100             unsigned len = 0;
101             for (n = 0; n < CAPTABSIZE; ++n) {
102                 (*actual)[n].nte_name = strings + len;
103                 (*actual)[n].nte_type = source[n].nte_type;
104                 (*actual)[n].nte_index = source[n].nte_index;
105                 (*actual)[n].nte_link = source[n].nte_link;
106                 next_string(strings, &len);
107             }
108         }
109     }
110     return *actual;
111 }
112
113 #define add_alias(field) \\
114         if (source[n].field >= 0) { \\
115                 (*actual)[n].field = strings + source[n].field; \\
116         }
117
118 static const struct alias *
119 _nc_build_alias(struct alias **actual,
120                 const alias_table_data * source,
121                 const char *strings,
122                 size_t tablesize)
123 {
124     if (*actual == 0) {
125         *actual = typeCalloc(struct alias, tablesize + 1);
126         if (*actual != 0) {
127             size_t n;
128             for (n = 0; n < tablesize; ++n) {
129                 add_alias(from);
130                 add_alias(to);
131                 add_alias(source);
132             }
133         }
134     }
135     return *actual;
136 }
137
138 #define build_names(root) _nc_build_names(&_nc_##root##_table, \\
139                                           root##_names_data, \\
140                                           root##_names_text)
141 #define build_alias(root) _nc_build_alias(&_nc_##root##alias_table, \\
142                                           root##alias_data, \\
143                                           root##alias_text, \\
144                                           SIZEOF(root##alias_data))
145 #else
146 #define build_names(root) _nc_ ## root ## _table
147 #define build_alias(root) _nc_ ## root ## alias_table
148 #endif
149
150 NCURSES_EXPORT(const struct name_table_entry *)
151 _nc_get_table(bool termcap)
152 {
153     return termcap ? build_names(cap) : build_names(info);
154 }
155
156 /* entrypoint used by tack 1.07 */
157 NCURSES_EXPORT(const HashValue *)
158 _nc_get_hash_table(bool termcap)
159 {
160     return termcap ? _nc_cap_hash_table : _nc_info_hash_table;
161 }
162
163 NCURSES_EXPORT(const struct alias *)
164 _nc_get_alias_table(bool termcap)
165 {
166     return termcap ? build_alias(cap) : build_alias(info);
167 }
168
169 static HashValue
170 info_hash(const char *string)
171 {
172     long sum = 0;
173
174     DEBUG(9, ("hashing %s", string));
175     while (*string) {
176         sum += (long) (UChar(*string) + (UChar(*(string + 1)) << 8));
177         string++;
178     }
179
180     DEBUG(9, ("sum is %ld", sum));
181     return (HashValue) (sum % HASHTABSIZE);
182 }
183
184 #define TCAP_LEN 2              /* only 1- or 2-character names are used */
185
186 static HashValue
187 tcap_hash(const char *string)
188 {
189     char temp[TCAP_LEN + 1];
190     int limit = 0;
191
192     while (*string) {
193         temp[limit++] = *string++;
194         if (limit >= TCAP_LEN)
195             break;
196     }
197     temp[limit] = '\0';
198     return info_hash(temp);
199 }
200
201 static int
202 compare_tcap_names(const char *a, const char *b)
203 {
204     return !strncmp(a, b, (size_t) TCAP_LEN);
205 }
206
207 static int
208 compare_info_names(const char *a, const char *b)
209 {
210     return !strcmp(a, b);
211 }
212
213 static const HashData hash_data[2] =
214 {
215     {HASHTABSIZE, _nc_info_hash_table, info_hash, compare_info_names},
216     {HASHTABSIZE, _nc_cap_hash_table, tcap_hash, compare_tcap_names}
217 };
218
219 NCURSES_EXPORT(const HashData *)
220 _nc_get_hash_info(bool termcap)
221 {
222     return &hash_data[(termcap != FALSE)];
223 }
224
225 #if NO_LEAKS
226 NCURSES_EXPORT(void)
227 _nc_comp_captab_leaks(void)
228 {
229 #if $OPT1
230     FreeIfNeeded(_nc_cap_table);
231     FreeIfNeeded(_nc_info_table);
232     FreeIfNeeded(_nc_capalias_table);
233     FreeIfNeeded(_nc_infoalias_table);
234 #endif
235 }
236 #endif /* NO_LEAKS */
237 EOF