File: | src/xkb/XKBMAlloc.c |
Location: | line 322, column 21 |
Description: | Dereference of null pointer |
1 | /************************************************************ | |||
2 | Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc. | |||
3 | ||||
4 | Permission to use, copy, modify, and distribute this | |||
5 | software and its documentation for any purpose and without | |||
6 | fee is hereby granted, provided that the above copyright | |||
7 | notice appear in all copies and that both that copyright | |||
8 | notice and this permission notice appear in supporting | |||
9 | documentation, and that the name of Silicon Graphics not be | |||
10 | used in advertising or publicity pertaining to distribution | |||
11 | of the software without specific prior written permission. | |||
12 | Silicon Graphics makes no representation about the suitability | |||
13 | of this software for any purpose. It is provided "as is" | |||
14 | without any express or implied warranty. | |||
15 | ||||
16 | SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS | |||
17 | SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY | |||
18 | AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON | |||
19 | GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL | |||
20 | DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, | |||
21 | DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE | |||
22 | OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH | |||
23 | THE USE OR PERFORMANCE OF THIS SOFTWARE. | |||
24 | ||||
25 | ********************************************************/ | |||
26 | ||||
27 | #ifdef HAVE_CONFIG_H1 | |||
28 | #include <config.h> | |||
29 | #endif | |||
30 | ||||
31 | ||||
32 | #include <stdio.h> | |||
33 | #include "Xlibint.h" | |||
34 | #include <X11/extensions/XKBproto.h> | |||
35 | #include <X11/keysym.h> | |||
36 | #include "XKBlibint.h" | |||
37 | ||||
38 | ||||
39 | /***====================================================================***/ | |||
40 | ||||
41 | Statusint | |||
42 | XkbAllocClientMap(XkbDescPtr xkb, unsigned which, unsigned nTotalTypes) | |||
43 | { | |||
44 | register int i; | |||
45 | XkbClientMapPtr map; | |||
46 | ||||
47 | if ((xkb == NULL((void*)0)) || | |||
48 | ((nTotalTypes > 0) && (nTotalTypes < XkbNumRequiredTypes(3 +1)))) | |||
49 | return BadValue2; | |||
50 | if ((which & XkbKeySymsMask(1<<1)) && | |||
51 | ((!XkbIsLegalKeycode(xkb->min_key_code)((xkb->min_key_code)>=8)) || | |||
52 | (!XkbIsLegalKeycode(xkb->max_key_code)((xkb->max_key_code)>=8)) || | |||
53 | (xkb->max_key_code < xkb->min_key_code))) { | |||
54 | #ifdef DEBUG | |||
55 | fprintf(stderr__stderrp, "bad keycode (%d,%d) in XkbAllocClientMap\n", | |||
56 | xkb->min_key_code, xkb->max_key_code); | |||
57 | #endif | |||
58 | return BadValue2; | |||
59 | } | |||
60 | ||||
61 | if (xkb->map == NULL((void*)0)) { | |||
62 | map = _XkbTypedCalloc(1, XkbClientMapRec)((XkbClientMapRec *)calloc((((1)) == 0 ? 1 : ((1))), (sizeof( XkbClientMapRec)))); | |||
63 | if (map == NULL((void*)0)) | |||
64 | return BadAlloc11; | |||
65 | xkb->map = map; | |||
66 | } | |||
67 | else | |||
68 | map = xkb->map; | |||
69 | ||||
70 | if ((which & XkbKeyTypesMask(1<<0)) && (nTotalTypes > 0)) { | |||
71 | if (map->types == NULL((void*)0)) { | |||
72 | map->types = _XkbTypedCalloc(nTotalTypes, XkbKeyTypeRec)((XkbKeyTypeRec *)calloc((((nTotalTypes)) == 0 ? 1 : ((nTotalTypes ))), (sizeof(XkbKeyTypeRec)))); | |||
73 | if (map->types == NULL((void*)0)) | |||
74 | return BadAlloc11; | |||
75 | map->num_types = 0; | |||
76 | map->size_types = nTotalTypes; | |||
77 | } | |||
78 | else if (map->size_types < nTotalTypes) { | |||
79 | XkbKeyTypeRec *prev_types = map->types; | |||
80 | ||||
81 | map->types = | |||
82 | _XkbTypedRealloc(map->types, nTotalTypes, XkbKeyTypeRec)((map->types) ? (XkbKeyTypeRec *)realloc(((map->types)) , (((nTotalTypes)*sizeof(XkbKeyTypeRec)) == 0 ? 1 : ((nTotalTypes )*sizeof(XkbKeyTypeRec)))) : ((XkbKeyTypeRec *)calloc((((nTotalTypes )) == 0 ? 1 : ((nTotalTypes))), (sizeof(XkbKeyTypeRec))))); | |||
83 | if (map->types == NULL((void*)0)) { | |||
84 | _XkbFree(prev_types)free((prev_types)); | |||
85 | map->num_types = map->size_types = 0; | |||
86 | return BadAlloc11; | |||
87 | } | |||
88 | map->size_types = nTotalTypes; | |||
89 | bzero(&map->types[map->num_types],__builtin___memset_chk (&map->types[map->num_types] , 0, ((map->size_types - map->num_types) * sizeof(XkbKeyTypeRec )), __builtin_object_size (&map->types[map->num_types ], 0)) | |||
90 | ((map->size_types - map->num_types) * sizeof(XkbKeyTypeRec)))__builtin___memset_chk (&map->types[map->num_types] , 0, ((map->size_types - map->num_types) * sizeof(XkbKeyTypeRec )), __builtin_object_size (&map->types[map->num_types ], 0)); | |||
91 | } | |||
92 | } | |||
93 | if (which & XkbKeySymsMask(1<<1)) { | |||
94 | int nKeys = XkbNumKeys(xkb)((xkb)->max_key_code-(xkb)->min_key_code+1); | |||
95 | ||||
96 | if (map->syms == NULL((void*)0)) { | |||
97 | map->size_syms = (nKeys * 15) / 10; | |||
98 | map->syms = _XkbTypedCalloc(map->size_syms, KeySym)((KeySym *)calloc((((map->size_syms)) == 0 ? 1 : ((map-> size_syms))), (sizeof(KeySym)))); | |||
99 | if (!map->syms) { | |||
100 | map->size_syms = 0; | |||
101 | return BadAlloc11; | |||
102 | } | |||
103 | map->num_syms = 1; | |||
104 | map->syms[0] = NoSymbol0L; | |||
105 | } | |||
106 | if (map->key_sym_map == NULL((void*)0)) { | |||
107 | i = xkb->max_key_code + 1; | |||
108 | map->key_sym_map = _XkbTypedCalloc(i, XkbSymMapRec)((XkbSymMapRec *)calloc((((i)) == 0 ? 1 : ((i))), (sizeof(XkbSymMapRec )))); | |||
109 | if (map->key_sym_map == NULL((void*)0)) | |||
110 | return BadAlloc11; | |||
111 | } | |||
112 | } | |||
113 | if (which & XkbModifierMapMask(1<<2)) { | |||
114 | if ((!XkbIsLegalKeycode(xkb->min_key_code)((xkb->min_key_code)>=8)) || | |||
115 | (!XkbIsLegalKeycode(xkb->max_key_code)((xkb->max_key_code)>=8)) || | |||
116 | (xkb->max_key_code < xkb->min_key_code)) | |||
117 | return BadMatch8; | |||
118 | if (map->modmap == NULL((void*)0)) { | |||
119 | i = xkb->max_key_code + 1; | |||
120 | map->modmap = _XkbTypedCalloc(i, unsigned char)((unsigned char *)calloc((((i)) == 0 ? 1 : ((i))), (sizeof(unsigned char)))); | |||
121 | if (map->modmap == NULL((void*)0)) | |||
122 | return BadAlloc11; | |||
123 | } | |||
124 | } | |||
125 | return Success0; | |||
126 | } | |||
127 | ||||
128 | Statusint | |||
129 | XkbAllocServerMap(XkbDescPtr xkb, unsigned which, unsigned nNewActions) | |||
130 | { | |||
131 | register int i; | |||
132 | XkbServerMapPtr map; | |||
133 | ||||
134 | if (xkb == NULL((void*)0)) | |||
135 | return BadMatch8; | |||
136 | if (xkb->server == NULL((void*)0)) { | |||
137 | map = _XkbTypedCalloc(1, XkbServerMapRec)((XkbServerMapRec *)calloc((((1)) == 0 ? 1 : ((1))), (sizeof( XkbServerMapRec)))); | |||
138 | if (map == NULL((void*)0)) | |||
139 | return BadAlloc11; | |||
140 | for (i = 0; i < XkbNumVirtualMods16; i++) { | |||
141 | map->vmods[i] = XkbNoModifierMask0; | |||
142 | } | |||
143 | xkb->server = map; | |||
144 | } | |||
145 | else | |||
146 | map = xkb->server; | |||
147 | if (which & XkbExplicitComponentsMask(1<<3)) { | |||
148 | if ((!XkbIsLegalKeycode(xkb->min_key_code)((xkb->min_key_code)>=8)) || | |||
149 | (!XkbIsLegalKeycode(xkb->max_key_code)((xkb->max_key_code)>=8)) || | |||
150 | (xkb->max_key_code < xkb->min_key_code)) | |||
151 | return BadMatch8; | |||
152 | if (map->explicit == NULL((void*)0)) { | |||
153 | i = xkb->max_key_code + 1; | |||
154 | map->explicit = _XkbTypedCalloc(i, unsigned char)((unsigned char *)calloc((((i)) == 0 ? 1 : ((i))), (sizeof(unsigned char)))); | |||
155 | if (map->explicit == NULL((void*)0)) | |||
156 | return BadAlloc11; | |||
157 | } | |||
158 | } | |||
159 | if (which & XkbKeyActionsMask(1<<4)) { | |||
160 | if ((!XkbIsLegalKeycode(xkb->min_key_code)((xkb->min_key_code)>=8)) || | |||
161 | (!XkbIsLegalKeycode(xkb->max_key_code)((xkb->max_key_code)>=8)) || | |||
162 | (xkb->max_key_code < xkb->min_key_code)) | |||
163 | return BadMatch8; | |||
164 | if (nNewActions < 1) | |||
165 | nNewActions = 1; | |||
166 | if (map->acts == NULL((void*)0)) { | |||
167 | map->acts = _XkbTypedCalloc((nNewActions + 1), XkbAction)((XkbAction *)calloc(((((nNewActions + 1))) == 0 ? 1 : (((nNewActions + 1)))), (sizeof(XkbAction)))); | |||
168 | if (map->acts == NULL((void*)0)) | |||
169 | return BadAlloc11; | |||
170 | map->num_acts = 1; | |||
171 | map->size_acts = nNewActions + 1; | |||
172 | } | |||
173 | else if ((map->size_acts - map->num_acts) < nNewActions) { | |||
174 | unsigned need; | |||
175 | XkbAction *prev_acts = map->acts; | |||
176 | ||||
177 | need = map->num_acts + nNewActions; | |||
178 | map->acts = _XkbTypedRealloc(map->acts, need, XkbAction)((map->acts) ? (XkbAction *)realloc(((map->acts)), (((need )*sizeof(XkbAction)) == 0 ? 1 : ((need)*sizeof(XkbAction)))) : ((XkbAction *)calloc((((need)) == 0 ? 1 : ((need))), (sizeof (XkbAction))))); | |||
179 | if (map->acts == NULL((void*)0)) { | |||
180 | _XkbFree(prev_acts)free((prev_acts)); | |||
181 | map->num_acts = map->size_acts = 0; | |||
182 | return BadAlloc11; | |||
183 | } | |||
184 | map->size_acts = need; | |||
185 | bzero(&map->acts[map->num_acts],__builtin___memset_chk (&map->acts[map->num_acts], 0 , ((map->size_acts - map->num_acts) * sizeof(XkbAction) ), __builtin_object_size (&map->acts[map->num_acts] , 0)) | |||
186 | ((map->size_acts - map->num_acts) * sizeof(XkbAction)))__builtin___memset_chk (&map->acts[map->num_acts], 0 , ((map->size_acts - map->num_acts) * sizeof(XkbAction) ), __builtin_object_size (&map->acts[map->num_acts] , 0)); | |||
187 | } | |||
188 | if (map->key_acts == NULL((void*)0)) { | |||
189 | i = xkb->max_key_code + 1; | |||
190 | map->key_acts = _XkbTypedCalloc(i, unsigned short)((unsigned short *)calloc((((i)) == 0 ? 1 : ((i))), (sizeof(unsigned short)))); | |||
191 | if (map->key_acts == NULL((void*)0)) | |||
192 | return BadAlloc11; | |||
193 | } | |||
194 | } | |||
195 | if (which & XkbKeyBehaviorsMask(1<<5)) { | |||
196 | if ((!XkbIsLegalKeycode(xkb->min_key_code)((xkb->min_key_code)>=8)) || | |||
197 | (!XkbIsLegalKeycode(xkb->max_key_code)((xkb->max_key_code)>=8)) || | |||
198 | (xkb->max_key_code < xkb->min_key_code)) | |||
199 | return BadMatch8; | |||
200 | if (map->behaviors == NULL((void*)0)) { | |||
201 | i = xkb->max_key_code + 1; | |||
202 | map->behaviors = _XkbTypedCalloc(i, XkbBehavior)((XkbBehavior *)calloc((((i)) == 0 ? 1 : ((i))), (sizeof(XkbBehavior )))); | |||
203 | if (map->behaviors == NULL((void*)0)) | |||
204 | return BadAlloc11; | |||
205 | } | |||
206 | } | |||
207 | if (which & XkbVirtualModMapMask(1<<7)) { | |||
208 | if ((!XkbIsLegalKeycode(xkb->min_key_code)((xkb->min_key_code)>=8)) || | |||
209 | (!XkbIsLegalKeycode(xkb->max_key_code)((xkb->max_key_code)>=8)) || | |||
210 | (xkb->max_key_code < xkb->min_key_code)) | |||
211 | return BadMatch8; | |||
212 | if (map->vmodmap == NULL((void*)0)) { | |||
213 | i = xkb->max_key_code + 1; | |||
214 | map->vmodmap = _XkbTypedCalloc(i, unsigned short)((unsigned short *)calloc((((i)) == 0 ? 1 : ((i))), (sizeof(unsigned short)))); | |||
215 | if (map->vmodmap == NULL((void*)0)) | |||
216 | return BadAlloc11; | |||
217 | } | |||
218 | } | |||
219 | return Success0; | |||
220 | } | |||
221 | ||||
222 | /***====================================================================***/ | |||
223 | ||||
224 | Statusint | |||
225 | XkbCopyKeyType(XkbKeyTypePtr from, XkbKeyTypePtr into) | |||
226 | { | |||
227 | if ((!from) || (!into)) | |||
228 | return BadMatch8; | |||
229 | ||||
230 | _XkbFree(into->map)free((into->map)); | |||
231 | into->map = NULL((void*)0); | |||
232 | ||||
233 | _XkbFree(into->preserve)free((into->preserve)); | |||
234 | into->preserve = NULL((void*)0); | |||
235 | ||||
236 | _XkbFree(into->level_names)free((into->level_names)); | |||
237 | into->level_names = NULL((void*)0); | |||
238 | ||||
239 | *into = *from; | |||
240 | if ((from->map) && (into->map_count > 0)) { | |||
241 | into->map = _XkbTypedCalloc(into->map_count, XkbKTMapEntryRec)((XkbKTMapEntryRec *)calloc((((into->map_count)) == 0 ? 1 : ((into->map_count))), (sizeof(XkbKTMapEntryRec)))); | |||
242 | if (!into->map) | |||
243 | return BadAlloc11; | |||
244 | memcpy(into->map, from->map,__builtin___memcpy_chk (into->map, from->map, into-> map_count * sizeof(XkbKTMapEntryRec), __builtin_object_size ( into->map, 0)) | |||
245 | into->map_count * sizeof(XkbKTMapEntryRec))__builtin___memcpy_chk (into->map, from->map, into-> map_count * sizeof(XkbKTMapEntryRec), __builtin_object_size ( into->map, 0)); | |||
246 | } | |||
247 | if ((from->preserve) && (into->map_count > 0)) { | |||
248 | into->preserve = _XkbTypedCalloc(into->map_count, XkbModsRec)((XkbModsRec *)calloc((((into->map_count)) == 0 ? 1 : ((into ->map_count))), (sizeof(XkbModsRec)))); | |||
249 | if (!into->preserve) | |||
250 | return BadAlloc11; | |||
251 | memcpy(into->preserve, from->preserve,__builtin___memcpy_chk (into->preserve, from->preserve, into->map_count * sizeof(XkbModsRec), __builtin_object_size (into->preserve, 0)) | |||
252 | into->map_count * sizeof(XkbModsRec))__builtin___memcpy_chk (into->preserve, from->preserve, into->map_count * sizeof(XkbModsRec), __builtin_object_size (into->preserve, 0)); | |||
253 | } | |||
254 | if ((from->level_names) && (into->num_levels > 0)) { | |||
255 | into->level_names = _XkbTypedCalloc(into->num_levels, Atom)((Atom *)calloc((((into->num_levels)) == 0 ? 1 : ((into-> num_levels))), (sizeof(Atom)))); | |||
256 | if (!into->level_names) | |||
257 | return BadAlloc11; | |||
258 | memcpy(into->level_names, from->level_names,__builtin___memcpy_chk (into->level_names, from->level_names , into->num_levels * sizeof(Atom), __builtin_object_size ( into->level_names, 0)) | |||
259 | into->num_levels * sizeof(Atom))__builtin___memcpy_chk (into->level_names, from->level_names , into->num_levels * sizeof(Atom), __builtin_object_size ( into->level_names, 0)); | |||
260 | } | |||
261 | return Success0; | |||
262 | } | |||
263 | ||||
264 | Statusint | |||
265 | XkbCopyKeyTypes(XkbKeyTypePtr from, XkbKeyTypePtr into, int num_types) | |||
266 | { | |||
267 | register int i, rtrn; | |||
268 | ||||
269 | if ((!from) || (!into) || (num_types < 0)) | |||
270 | return BadMatch8; | |||
271 | for (i = 0; i < num_types; i++) { | |||
272 | if ((rtrn = XkbCopyKeyType(from++, into++)) != Success0) | |||
273 | return rtrn; | |||
274 | } | |||
275 | return Success0; | |||
276 | } | |||
277 | ||||
278 | XkbKeyTypePtr | |||
279 | XkbAddKeyType(XkbDescPtr xkb, | |||
280 | Atom name, | |||
281 | int map_count, | |||
282 | Boolint want_preserve, | |||
283 | int num_lvls) | |||
284 | { | |||
285 | register int i; | |||
286 | unsigned tmp; | |||
287 | XkbKeyTypePtr type; | |||
288 | XkbClientMapPtr map; | |||
289 | ||||
290 | if ((!xkb) || (num_lvls < 1)) | |||
| ||||
291 | return NULL((void*)0); | |||
292 | map = xkb->map; | |||
293 | if ((map) && (map->types)) { | |||
294 | for (i = 0; i < map->num_types; i++) { | |||
295 | if (map->types[i].name == name) { | |||
296 | Statusint status = | |||
297 | XkbResizeKeyType(xkb, i, map_count, want_preserve, | |||
298 | num_lvls); | |||
299 | return (status == Success0 ? &map->types[i] : NULL((void*)0)); | |||
300 | } | |||
301 | } | |||
302 | } | |||
303 | if ((!map) || (!map->types) || (map->num_types < XkbNumRequiredTypes(3 +1))) { | |||
304 | tmp = XkbNumRequiredTypes(3 +1) + 1; | |||
305 | if (XkbAllocClientMap(xkb, XkbKeyTypesMask(1<<0), tmp) != Success0) | |||
306 | return NULL((void*)0); | |||
307 | if (!map) | |||
308 | map = xkb->map; | |||
309 | tmp = 0; | |||
310 | if (map->num_types <= XkbKeypadIndex3) | |||
311 | tmp |= XkbKeypadMask(1<<3); | |||
312 | if (map->num_types <= XkbAlphabeticIndex2) | |||
313 | tmp |= XkbAlphabeticMask(1<<2); | |||
314 | if (map->num_types <= XkbTwoLevelIndex1) | |||
315 | tmp |= XkbTwoLevelMask(1<<1); | |||
316 | if (map->num_types <= XkbOneLevelIndex0) | |||
317 | tmp |= XkbOneLevelMask(1<<0); | |||
318 | if (XkbInitCanonicalKeyTypes(xkb, tmp, XkbNoModifier0xff) == Success0) { | |||
319 | for (i = 0; i < map->num_types; i++) { | |||
320 | Statusint status; | |||
321 | ||||
322 | if (map->types[i].name != name) | |||
| ||||
323 | continue; | |||
324 | status = XkbResizeKeyType(xkb, i, map_count, want_preserve, | |||
325 | num_lvls); | |||
326 | return (status == Success0 ? &map->types[i] : NULL((void*)0)); | |||
327 | } | |||
328 | } | |||
329 | } | |||
330 | if ((map->num_types <= map->size_types) && | |||
331 | (XkbAllocClientMap(xkb, XkbKeyTypesMask(1<<0), map->num_types + 1) != | |||
332 | Success0)) { | |||
333 | return NULL((void*)0); | |||
334 | } | |||
335 | type = &map->types[map->num_types]; | |||
336 | map->num_types++; | |||
337 | bzero((char *) type, sizeof(XkbKeyTypeRec))__builtin___memset_chk ((char *) type, 0, sizeof(XkbKeyTypeRec ), __builtin_object_size ((char *) type, 0)); | |||
338 | type->num_levels = num_lvls; | |||
339 | type->map_count = map_count; | |||
340 | type->name = name; | |||
341 | if (map_count > 0) { | |||
342 | type->map = _XkbTypedCalloc(map_count, XkbKTMapEntryRec)((XkbKTMapEntryRec *)calloc((((map_count)) == 0 ? 1 : ((map_count ))), (sizeof(XkbKTMapEntryRec)))); | |||
343 | if (!type->map) { | |||
344 | map->num_types--; | |||
345 | return NULL((void*)0); | |||
346 | } | |||
347 | if (want_preserve) { | |||
348 | type->preserve = _XkbTypedCalloc(map_count, XkbModsRec)((XkbModsRec *)calloc((((map_count)) == 0 ? 1 : ((map_count)) ), (sizeof(XkbModsRec)))); | |||
349 | if (!type->preserve) { | |||
350 | _XkbFree(type->map)free((type->map)); | |||
351 | map->num_types--; | |||
352 | return NULL((void*)0); | |||
353 | } | |||
354 | } | |||
355 | } | |||
356 | return type; | |||
357 | } | |||
358 | ||||
359 | Statusint | |||
360 | XkbResizeKeyType(XkbDescPtr xkb, | |||
361 | int type_ndx, | |||
362 | int map_count, | |||
363 | Boolint want_preserve, | |||
364 | int new_num_lvls) | |||
365 | { | |||
366 | XkbKeyTypePtr type; | |||
367 | KeyCode matchingKeys[XkbMaxKeyCount(255 -8 +1)], nMatchingKeys; | |||
368 | ||||
369 | if ((type_ndx < 0) || (type_ndx >= xkb->map->num_types) || (map_count < 0) | |||
370 | || (new_num_lvls < 1)) | |||
371 | return BadValue2; | |||
372 | switch (type_ndx) { | |||
373 | case XkbOneLevelIndex0: | |||
374 | if (new_num_lvls != 1) | |||
375 | return BadMatch8; | |||
376 | break; | |||
377 | case XkbTwoLevelIndex1: | |||
378 | case XkbAlphabeticIndex2: | |||
379 | case XkbKeypadIndex3: | |||
380 | if (new_num_lvls != 2) | |||
381 | return BadMatch8; | |||
382 | break; | |||
383 | } | |||
384 | type = &xkb->map->types[type_ndx]; | |||
385 | if (map_count == 0) { | |||
386 | _XkbFree(type->map)free((type->map)); | |||
387 | type->map = NULL((void*)0); | |||
388 | _XkbFree(type->preserve)free((type->preserve)); | |||
389 | type->preserve = NULL((void*)0); | |||
390 | type->map_count = 0; | |||
391 | } | |||
392 | else { | |||
393 | XkbKTMapEntryRec *prev_map = type->map; | |||
394 | ||||
395 | if ((map_count > type->map_count) || (type->map == NULL((void*)0))) | |||
396 | type->map = | |||
397 | _XkbTypedRealloc(type->map, map_count, XkbKTMapEntryRec)((type->map) ? (XkbKTMapEntryRec *)realloc(((type->map) ), (((map_count)*sizeof(XkbKTMapEntryRec)) == 0 ? 1 : ((map_count )*sizeof(XkbKTMapEntryRec)))) : ((XkbKTMapEntryRec *)calloc(( ((map_count)) == 0 ? 1 : ((map_count))), (sizeof(XkbKTMapEntryRec ))))); | |||
398 | if (!type->map) { | |||
399 | _XkbFree(prev_map)free((prev_map)); | |||
400 | return BadAlloc11; | |||
401 | } | |||
402 | if (want_preserve) { | |||
403 | XkbModsRec *prev_preserve = type->preserve; | |||
404 | ||||
405 | if ((map_count > type->map_count) || (type->preserve == NULL((void*)0))) { | |||
406 | type->preserve = _XkbTypedRealloc(type->preserve, map_count,((type->preserve) ? (XkbModsRec *)realloc(((type->preserve )), (((map_count)*sizeof(XkbModsRec)) == 0 ? 1 : ((map_count) *sizeof(XkbModsRec)))) : ((XkbModsRec *)calloc((((map_count)) == 0 ? 1 : ((map_count))), (sizeof(XkbModsRec))))) | |||
407 | XkbModsRec)((type->preserve) ? (XkbModsRec *)realloc(((type->preserve )), (((map_count)*sizeof(XkbModsRec)) == 0 ? 1 : ((map_count) *sizeof(XkbModsRec)))) : ((XkbModsRec *)calloc((((map_count)) == 0 ? 1 : ((map_count))), (sizeof(XkbModsRec))))); | |||
408 | } | |||
409 | if (!type->preserve) { | |||
410 | _XkbFree(prev_preserve)free((prev_preserve)); | |||
411 | return BadAlloc11; | |||
412 | } | |||
413 | } | |||
414 | else { | |||
415 | _XkbFree(type->preserve)free((type->preserve)); | |||
416 | type->preserve = NULL((void*)0); | |||
417 | } | |||
418 | type->map_count = map_count; | |||
419 | } | |||
420 | ||||
421 | if ((new_num_lvls > type->num_levels) || (type->level_names == NULL((void*)0))) { | |||
422 | Atom *prev_level_names = type->level_names; | |||
423 | ||||
424 | type->level_names = | |||
425 | _XkbTypedRealloc(type->level_names, new_num_lvls, Atom)((type->level_names) ? (Atom *)realloc(((type->level_names )), (((new_num_lvls)*sizeof(Atom)) == 0 ? 1 : ((new_num_lvls) *sizeof(Atom)))) : ((Atom *)calloc((((new_num_lvls)) == 0 ? 1 : ((new_num_lvls))), (sizeof(Atom))))); | |||
426 | if (!type->level_names) { | |||
427 | _XkbFree(prev_level_names)free((prev_level_names)); | |||
428 | return BadAlloc11; | |||
429 | } | |||
430 | } | |||
431 | /* | |||
432 | * Here's the theory: | |||
433 | * If the width of the type changed, we might have to resize the symbol | |||
434 | * maps for any keys that use the type for one or more groups. This is | |||
435 | * expensive, so we'll try to cull out any keys that are obviously okay: | |||
436 | * In any case: | |||
437 | * - keys that have a group width <= the old width are okay (because | |||
438 | * they could not possibly have been associated with the old type) | |||
439 | * If the key type increased in size: | |||
440 | * - keys that already have a group width >= to the new width are okay | |||
441 | * + keys that have a group width >= the old width but < the new width | |||
442 | * might have to be enlarged. | |||
443 | * If the key type decreased in size: | |||
444 | * - keys that have a group width > the old width don't have to be | |||
445 | * resized (because they must have some other wider type associated | |||
446 | * with some group). | |||
447 | * + keys that have a group width == the old width might have to be | |||
448 | * shrunk. | |||
449 | * The possibilities marked with '+' require us to examine the key types | |||
450 | * associated with each group for the key. | |||
451 | */ | |||
452 | bzero(matchingKeys, XkbMaxKeyCount * sizeof(KeyCode))__builtin___memset_chk (matchingKeys, 0, (255 -8 +1) * sizeof (KeyCode), __builtin_object_size (matchingKeys, 0)); | |||
453 | nMatchingKeys = 0; | |||
454 | if (new_num_lvls > type->num_levels) { | |||
455 | int nTotal; | |||
456 | KeySym *newSyms; | |||
457 | int width, match, nResize; | |||
458 | register int i, g, nSyms; | |||
459 | ||||
460 | nResize = 0; | |||
461 | for (nTotal = 1, i = xkb->min_key_code; i <= xkb->max_key_code; i++) { | |||
462 | width = XkbKeyGroupsWidth(xkb, i)((((xkb)->map)->key_sym_map[i].width)); | |||
463 | if (width < type->num_levels) | |||
464 | continue; | |||
465 | for (match = 0, g = XkbKeyNumGroups(xkb, i)((((((xkb)->map)->key_sym_map[(i)].group_info)&0x0f ))) - 1; | |||
466 | (g >= 0) && (!match); g--) { | |||
467 | if (XkbKeyKeyTypeIndex(xkb, i, g)((((xkb)->map)->key_sym_map[i].kt_index[g&0x3])) == type_ndx) { | |||
468 | matchingKeys[nMatchingKeys++] = i; | |||
469 | match = 1; | |||
470 | } | |||
471 | } | |||
472 | if ((!match) || (width >= new_num_lvls)) | |||
473 | nTotal += XkbKeyNumSyms(xkb, i)(((((xkb)->map)->key_sym_map[(i)].width)*(((((xkb)-> map)->key_sym_map[(i)].group_info)&0x0f)))); | |||
474 | else { | |||
475 | nTotal += XkbKeyNumGroups(xkb, i)((((((xkb)->map)->key_sym_map[(i)].group_info)&0x0f ))) * new_num_lvls; | |||
476 | nResize++; | |||
477 | } | |||
478 | } | |||
479 | if (nResize > 0) { | |||
480 | int nextMatch; | |||
481 | ||||
482 | xkb->map->size_syms = (nTotal * 12) / 10; | |||
483 | newSyms = _XkbTypedCalloc(xkb->map->size_syms, KeySym)((KeySym *)calloc((((xkb->map->size_syms)) == 0 ? 1 : ( (xkb->map->size_syms))), (sizeof(KeySym)))); | |||
484 | if (newSyms == NULL((void*)0)) | |||
485 | return BadAlloc11; | |||
486 | nextMatch = 0; | |||
487 | nSyms = 1; | |||
488 | for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) { | |||
489 | if (matchingKeys[nextMatch] == i) { | |||
490 | KeySym *pOld; | |||
491 | ||||
492 | nextMatch++; | |||
493 | width = XkbKeyGroupsWidth(xkb, i)((((xkb)->map)->key_sym_map[i].width)); | |||
494 | pOld = XkbKeySymsPtr(xkb, i)((&((xkb)->map)->syms[(((xkb)->map)->key_sym_map [(i)].offset)])); | |||
495 | for (g = XkbKeyNumGroups(xkb, i)((((((xkb)->map)->key_sym_map[(i)].group_info)&0x0f ))) - 1; g >= 0; g--) { | |||
496 | memcpy(&newSyms[nSyms + (new_num_lvls * g)],__builtin___memcpy_chk (&newSyms[nSyms + (new_num_lvls * g )], &pOld[width * g], width * sizeof(KeySym), __builtin_object_size (&newSyms[nSyms + (new_num_lvls * g)], 0)) | |||
497 | &pOld[width * g], width * sizeof(KeySym))__builtin___memcpy_chk (&newSyms[nSyms + (new_num_lvls * g )], &pOld[width * g], width * sizeof(KeySym), __builtin_object_size (&newSyms[nSyms + (new_num_lvls * g)], 0)); | |||
498 | } | |||
499 | xkb->map->key_sym_map[i].offset = nSyms; | |||
500 | nSyms += XkbKeyNumGroups(xkb, i)((((((xkb)->map)->key_sym_map[(i)].group_info)&0x0f ))) * new_num_lvls; | |||
501 | } | |||
502 | else { | |||
503 | memcpy(&newSyms[nSyms], XkbKeySymsPtr(xkb, i),__builtin___memcpy_chk (&newSyms[nSyms], ((&((xkb)-> map)->syms[(((xkb)->map)->key_sym_map[(i)].offset)]) ), (((((xkb)->map)->key_sym_map[(i)].width)*(((((xkb)-> map)->key_sym_map[(i)].group_info)&0x0f)))) * sizeof(KeySym ), __builtin_object_size (&newSyms[nSyms], 0)) | |||
504 | XkbKeyNumSyms(xkb, i) * sizeof(KeySym))__builtin___memcpy_chk (&newSyms[nSyms], ((&((xkb)-> map)->syms[(((xkb)->map)->key_sym_map[(i)].offset)]) ), (((((xkb)->map)->key_sym_map[(i)].width)*(((((xkb)-> map)->key_sym_map[(i)].group_info)&0x0f)))) * sizeof(KeySym ), __builtin_object_size (&newSyms[nSyms], 0)); | |||
505 | xkb->map->key_sym_map[i].offset = nSyms; | |||
506 | nSyms += XkbKeyNumSyms(xkb, i)(((((xkb)->map)->key_sym_map[(i)].width)*(((((xkb)-> map)->key_sym_map[(i)].group_info)&0x0f)))); | |||
507 | } | |||
508 | } | |||
509 | type->num_levels = new_num_lvls; | |||
510 | _XkbFree(xkb->map->syms)free((xkb->map->syms)); | |||
511 | xkb->map->syms = newSyms; | |||
512 | xkb->map->num_syms = nSyms; | |||
513 | return Success0; | |||
514 | } | |||
515 | } | |||
516 | else if (new_num_lvls < type->num_levels) { | |||
517 | int width, match; | |||
518 | register int g, i; | |||
519 | ||||
520 | for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) { | |||
521 | width = XkbKeyGroupsWidth(xkb, i)((((xkb)->map)->key_sym_map[i].width)); | |||
522 | if (width < type->num_levels) | |||
523 | continue; | |||
524 | for (match = 0, g = XkbKeyNumGroups(xkb, i)((((((xkb)->map)->key_sym_map[(i)].group_info)&0x0f ))) - 1; | |||
525 | (g >= 0) && (!match); g--) { | |||
526 | if (XkbKeyKeyTypeIndex(xkb, i, g)((((xkb)->map)->key_sym_map[i].kt_index[g&0x3])) == type_ndx) { | |||
527 | matchingKeys[nMatchingKeys++] = i; | |||
528 | match = 1; | |||
529 | } | |||
530 | } | |||
531 | } | |||
532 | } | |||
533 | if (nMatchingKeys > 0) { | |||
534 | int key, firstClear; | |||
535 | register int i, g; | |||
536 | ||||
537 | if (new_num_lvls > type->num_levels) | |||
538 | firstClear = type->num_levels; | |||
539 | else | |||
540 | firstClear = new_num_lvls; | |||
541 | for (i = 0; i < nMatchingKeys; i++) { | |||
542 | KeySym *pSyms; | |||
543 | int width, nClear; | |||
544 | ||||
545 | key = matchingKeys[i]; | |||
546 | width = XkbKeyGroupsWidth(xkb, key)((((xkb)->map)->key_sym_map[key].width)); | |||
547 | nClear = width - firstClear; | |||
548 | pSyms = XkbKeySymsPtr(xkb, key)((&((xkb)->map)->syms[(((xkb)->map)->key_sym_map [(key)].offset)])); | |||
549 | for (g = XkbKeyNumGroups(xkb, key)((((((xkb)->map)->key_sym_map[(key)].group_info)&0x0f ))) - 1; g >= 0; g--) { | |||
550 | if (XkbKeyKeyTypeIndex(xkb, key, g)((((xkb)->map)->key_sym_map[key].kt_index[g&0x3])) == type_ndx) { | |||
551 | if (nClear > 0) | |||
552 | bzero(&pSyms[g * width + firstClear],__builtin___memset_chk (&pSyms[g * width + firstClear], 0 , nClear * sizeof(KeySym), __builtin_object_size (&pSyms[ g * width + firstClear], 0)) | |||
553 | nClear * sizeof(KeySym))__builtin___memset_chk (&pSyms[g * width + firstClear], 0 , nClear * sizeof(KeySym), __builtin_object_size (&pSyms[ g * width + firstClear], 0)); | |||
554 | } | |||
555 | } | |||
556 | } | |||
557 | } | |||
558 | type->num_levels = new_num_lvls; | |||
559 | return Success0; | |||
560 | } | |||
561 | ||||
562 | KeySym * | |||
563 | XkbResizeKeySyms(XkbDescPtr xkb, int key, int needed) | |||
564 | { | |||
565 | register int i, nSyms, nKeySyms; | |||
566 | unsigned nOldSyms; | |||
567 | KeySym *newSyms; | |||
568 | ||||
569 | if (needed == 0) { | |||
570 | xkb->map->key_sym_map[key].offset = 0; | |||
571 | return xkb->map->syms; | |||
572 | } | |||
573 | nOldSyms = XkbKeyNumSyms(xkb, key)(((((xkb)->map)->key_sym_map[(key)].width)*(((((xkb)-> map)->key_sym_map[(key)].group_info)&0x0f)))); | |||
574 | if (nOldSyms >= (unsigned) needed) { | |||
575 | return XkbKeySymsPtr(xkb, key)((&((xkb)->map)->syms[(((xkb)->map)->key_sym_map [(key)].offset)])); | |||
576 | } | |||
577 | if (xkb->map->size_syms - xkb->map->num_syms >= (unsigned) needed) { | |||
578 | if (nOldSyms > 0) { | |||
579 | memcpy(&xkb->map->syms[xkb->map->num_syms], XkbKeySymsPtr(xkb, key),__builtin___memcpy_chk (&xkb->map->syms[xkb->map ->num_syms], ((&((xkb)->map)->syms[(((xkb)->map )->key_sym_map[(key)].offset)])), nOldSyms * sizeof(KeySym ), __builtin_object_size (&xkb->map->syms[xkb->map ->num_syms], 0)) | |||
580 | nOldSyms * sizeof(KeySym))__builtin___memcpy_chk (&xkb->map->syms[xkb->map ->num_syms], ((&((xkb)->map)->syms[(((xkb)->map )->key_sym_map[(key)].offset)])), nOldSyms * sizeof(KeySym ), __builtin_object_size (&xkb->map->syms[xkb->map ->num_syms], 0)); | |||
581 | } | |||
582 | if ((needed - nOldSyms) > 0) { | |||
583 | bzero(&xkb->map->syms[xkb->map->num_syms + XkbKeyNumSyms(xkb, key)],__builtin___memset_chk (&xkb->map->syms[xkb->map ->num_syms + (((((xkb)->map)->key_sym_map[(key)].width )*(((((xkb)->map)->key_sym_map[(key)].group_info)&0x0f ))))], 0, (needed - nOldSyms) * sizeof(KeySym), __builtin_object_size (&xkb->map->syms[xkb->map->num_syms + (((((xkb )->map)->key_sym_map[(key)].width)*(((((xkb)->map)-> key_sym_map[(key)].group_info)&0x0f))))], 0)) | |||
584 | (needed - nOldSyms) * sizeof(KeySym))__builtin___memset_chk (&xkb->map->syms[xkb->map ->num_syms + (((((xkb)->map)->key_sym_map[(key)].width )*(((((xkb)->map)->key_sym_map[(key)].group_info)&0x0f ))))], 0, (needed - nOldSyms) * sizeof(KeySym), __builtin_object_size (&xkb->map->syms[xkb->map->num_syms + (((((xkb )->map)->key_sym_map[(key)].width)*(((((xkb)->map)-> key_sym_map[(key)].group_info)&0x0f))))], 0)); | |||
585 | } | |||
586 | xkb->map->key_sym_map[key].offset = xkb->map->num_syms; | |||
587 | xkb->map->num_syms += needed; | |||
588 | return &xkb->map->syms[xkb->map->key_sym_map[key].offset]; | |||
589 | } | |||
590 | xkb->map->size_syms += (needed > 32 ? needed : 32); | |||
591 | newSyms = _XkbTypedCalloc(xkb->map->size_syms, KeySym)((KeySym *)calloc((((xkb->map->size_syms)) == 0 ? 1 : ( (xkb->map->size_syms))), (sizeof(KeySym)))); | |||
592 | if (newSyms == NULL((void*)0)) | |||
593 | return NULL((void*)0); | |||
594 | newSyms[0] = NoSymbol0L; | |||
595 | nSyms = 1; | |||
596 | for (i = xkb->min_key_code; i <= (int) xkb->max_key_code; i++) { | |||
597 | int nCopy; | |||
598 | ||||
599 | nCopy = nKeySyms = XkbKeyNumSyms(xkb, i)(((((xkb)->map)->key_sym_map[(i)].width)*(((((xkb)-> map)->key_sym_map[(i)].group_info)&0x0f)))); | |||
600 | if ((nKeySyms == 0) && (i != key)) | |||
601 | continue; | |||
602 | if (i == key) | |||
603 | nKeySyms = needed; | |||
604 | if (nCopy != 0) | |||
605 | memcpy(&newSyms[nSyms], XkbKeySymsPtr(xkb, i),__builtin___memcpy_chk (&newSyms[nSyms], ((&((xkb)-> map)->syms[(((xkb)->map)->key_sym_map[(i)].offset)]) ), nCopy * sizeof(KeySym), __builtin_object_size (&newSyms [nSyms], 0)) | |||
606 | nCopy * sizeof(KeySym))__builtin___memcpy_chk (&newSyms[nSyms], ((&((xkb)-> map)->syms[(((xkb)->map)->key_sym_map[(i)].offset)]) ), nCopy * sizeof(KeySym), __builtin_object_size (&newSyms [nSyms], 0)); | |||
607 | if (nKeySyms > nCopy) | |||
608 | bzero(&newSyms[nSyms + nCopy], (nKeySyms - nCopy) * sizeof(KeySym))__builtin___memset_chk (&newSyms[nSyms + nCopy], 0, (nKeySyms - nCopy) * sizeof(KeySym), __builtin_object_size (&newSyms [nSyms + nCopy], 0)); | |||
609 | xkb->map->key_sym_map[i].offset = nSyms; | |||
610 | nSyms += nKeySyms; | |||
611 | } | |||
612 | _XkbFree(xkb->map->syms)free((xkb->map->syms)); | |||
613 | xkb->map->syms = newSyms; | |||
614 | xkb->map->num_syms = nSyms; | |||
615 | return &xkb->map->syms[xkb->map->key_sym_map[key].offset]; | |||
616 | } | |||
617 | ||||
618 | static unsigned | |||
619 | _ExtendRange(unsigned int old_flags, | |||
620 | unsigned int flag, | |||
621 | KeyCode newKC, | |||
622 | KeyCode *old_min, | |||
623 | unsigned char *old_num) | |||
624 | { | |||
625 | if ((old_flags & flag) == 0) { | |||
626 | old_flags |= flag; | |||
627 | *old_min = newKC; | |||
628 | *old_num = 1; | |||
629 | } | |||
630 | else { | |||
631 | int last = (*old_min) + (*old_num) - 1; | |||
632 | ||||
633 | if (newKC < *old_min) { | |||
634 | *old_min = newKC; | |||
635 | *old_num = (last - newKC) + 1; | |||
636 | } | |||
637 | else if (newKC > last) { | |||
638 | *old_num = (newKC - (*old_min)) + 1; | |||
639 | } | |||
640 | } | |||
641 | return old_flags; | |||
642 | } | |||
643 | ||||
644 | Statusint | |||
645 | XkbChangeKeycodeRange(XkbDescPtr xkb, | |||
646 | int minKC, | |||
647 | int maxKC, | |||
648 | XkbChangesPtr changes) | |||
649 | { | |||
650 | int tmp; | |||
651 | ||||
652 | if ((!xkb) || (minKC < XkbMinLegalKeyCode8) || (maxKC > XkbMaxLegalKeyCode255)) | |||
653 | return BadValue2; | |||
654 | if (minKC > maxKC) | |||
655 | return BadMatch8; | |||
656 | if (minKC < xkb->min_key_code) { | |||
657 | if (changes) | |||
658 | changes->map.min_key_code = minKC; | |||
659 | tmp = xkb->min_key_code - minKC; | |||
660 | if (xkb->map) { | |||
661 | if (xkb->map->key_sym_map) { | |||
662 | bzero((char *) &xkb->map->key_sym_map[minKC],__builtin___memset_chk ((char *) &xkb->map->key_sym_map [minKC], 0, tmp * sizeof(XkbSymMapRec), __builtin_object_size ((char *) &xkb->map->key_sym_map[minKC], 0)) | |||
663 | tmp * sizeof(XkbSymMapRec))__builtin___memset_chk ((char *) &xkb->map->key_sym_map [minKC], 0, tmp * sizeof(XkbSymMapRec), __builtin_object_size ((char *) &xkb->map->key_sym_map[minKC], 0)); | |||
664 | if (changes) { | |||
665 | changes->map.changed = _ExtendRange(changes->map.changed, | |||
666 | XkbKeySymsMask(1<<1), minKC, | |||
667 | &changes->map.first_key_sym, | |||
668 | &changes->map.num_key_syms); | |||
669 | } | |||
670 | } | |||
671 | if (xkb->map->modmap) { | |||
672 | bzero((char *) &xkb->map->modmap[minKC], tmp)__builtin___memset_chk ((char *) &xkb->map->modmap[ minKC], 0, tmp, __builtin_object_size ((char *) &xkb-> map->modmap[minKC], 0)); | |||
673 | if (changes) { | |||
674 | changes->map.changed = _ExtendRange(changes->map.changed, | |||
675 | XkbModifierMapMask(1<<2), minKC, | |||
676 | &changes->map.first_modmap_key, | |||
677 | &changes->map.num_modmap_keys); | |||
678 | } | |||
679 | } | |||
680 | } | |||
681 | if (xkb->server) { | |||
682 | if (xkb->server->behaviors) { | |||
683 | bzero((char *) &xkb->server->behaviors[minKC],__builtin___memset_chk ((char *) &xkb->server->behaviors [minKC], 0, tmp * sizeof(XkbBehavior), __builtin_object_size ( (char *) &xkb->server->behaviors[minKC], 0)) | |||
684 | tmp * sizeof(XkbBehavior))__builtin___memset_chk ((char *) &xkb->server->behaviors [minKC], 0, tmp * sizeof(XkbBehavior), __builtin_object_size ( (char *) &xkb->server->behaviors[minKC], 0)); | |||
685 | if (changes) { | |||
686 | changes->map.changed = _ExtendRange(changes->map.changed, | |||
687 | XkbKeyBehaviorsMask(1<<5), minKC, | |||
688 | &changes->map.first_key_behavior, | |||
689 | &changes->map.num_key_behaviors); | |||
690 | } | |||
691 | } | |||
692 | if (xkb->server->key_acts) { | |||
693 | bzero((char *) &xkb->server->key_acts[minKC],__builtin___memset_chk ((char *) &xkb->server->key_acts [minKC], 0, tmp * sizeof(unsigned short), __builtin_object_size ((char *) &xkb->server->key_acts[minKC], 0)) | |||
694 | tmp * sizeof(unsigned short))__builtin___memset_chk ((char *) &xkb->server->key_acts [minKC], 0, tmp * sizeof(unsigned short), __builtin_object_size ((char *) &xkb->server->key_acts[minKC], 0)); | |||
695 | if (changes) { | |||
696 | changes->map.changed = _ExtendRange(changes->map.changed, | |||
697 | XkbKeyActionsMask(1<<4), minKC, | |||
698 | &changes->map.first_key_act, | |||
699 | &changes->map.num_key_acts); | |||
700 | } | |||
701 | } | |||
702 | if (xkb->server->vmodmap) { | |||
703 | bzero((char *) &xkb->server->vmodmap[minKC],__builtin___memset_chk ((char *) &xkb->server->vmodmap [minKC], 0, tmp * sizeof(unsigned short), __builtin_object_size ((char *) &xkb->server->vmodmap[minKC], 0)) | |||
704 | tmp * sizeof(unsigned short))__builtin___memset_chk ((char *) &xkb->server->vmodmap [minKC], 0, tmp * sizeof(unsigned short), __builtin_object_size ((char *) &xkb->server->vmodmap[minKC], 0)); | |||
705 | if (changes) { | |||
706 | changes->map.changed = _ExtendRange(changes->map.changed, | |||
707 | XkbVirtualModMapMask(1<<7), minKC, | |||
708 | &changes->map.first_modmap_key, | |||
709 | &changes->map.num_vmodmap_keys); | |||
710 | } | |||
711 | } | |||
712 | } | |||
713 | if ((xkb->names) && (xkb->names->keys)) { | |||
714 | bzero((char *) &xkb->names->keys[minKC],__builtin___memset_chk ((char *) &xkb->names->keys[ minKC], 0, tmp * sizeof(XkbKeyNameRec), __builtin_object_size ((char *) &xkb->names->keys[minKC], 0)) | |||
715 | tmp * sizeof(XkbKeyNameRec))__builtin___memset_chk ((char *) &xkb->names->keys[ minKC], 0, tmp * sizeof(XkbKeyNameRec), __builtin_object_size ((char *) &xkb->names->keys[minKC], 0)); | |||
716 | if (changes) { | |||
717 | changes->names.changed = _ExtendRange(changes->names.changed, | |||
718 | XkbKeyNamesMask(1<<9), minKC, | |||
719 | &changes->names.first_key, | |||
720 | &changes->names.num_keys); | |||
721 | } | |||
722 | } | |||
723 | xkb->min_key_code = minKC; | |||
724 | } | |||
725 | if (maxKC > xkb->max_key_code) { | |||
726 | if (changes) | |||
727 | changes->map.max_key_code = maxKC; | |||
728 | tmp = maxKC - xkb->max_key_code; | |||
729 | if (xkb->map) { | |||
730 | if (xkb->map->key_sym_map) { | |||
731 | XkbSymMapRec *prev_key_sym_map = xkb->map->key_sym_map; | |||
732 | ||||
733 | xkb->map->key_sym_map = _XkbTypedRealloc(xkb->map->key_sym_map,((xkb->map->key_sym_map) ? (XkbSymMapRec *)realloc(((xkb ->map->key_sym_map)), ((((maxKC + 1))*sizeof(XkbSymMapRec )) == 0 ? 1 : (((maxKC + 1))*sizeof(XkbSymMapRec)))) : ((XkbSymMapRec *)calloc(((((maxKC + 1))) == 0 ? 1 : (((maxKC + 1)))), (sizeof (XkbSymMapRec))))) | |||
734 | (maxKC + 1), XkbSymMapRec)((xkb->map->key_sym_map) ? (XkbSymMapRec *)realloc(((xkb ->map->key_sym_map)), ((((maxKC + 1))*sizeof(XkbSymMapRec )) == 0 ? 1 : (((maxKC + 1))*sizeof(XkbSymMapRec)))) : ((XkbSymMapRec *)calloc(((((maxKC + 1))) == 0 ? 1 : (((maxKC + 1)))), (sizeof (XkbSymMapRec))))); | |||
735 | if (!xkb->map->key_sym_map) { | |||
736 | _XkbFree(prev_key_sym_map)free((prev_key_sym_map)); | |||
737 | return BadAlloc11; | |||
738 | } | |||
739 | bzero((char *) &xkb->map->key_sym_map[xkb->max_key_code],__builtin___memset_chk ((char *) &xkb->map->key_sym_map [xkb->max_key_code], 0, tmp * sizeof(XkbSymMapRec), __builtin_object_size ((char *) &xkb->map->key_sym_map[xkb->max_key_code ], 0)) | |||
740 | tmp * sizeof(XkbSymMapRec))__builtin___memset_chk ((char *) &xkb->map->key_sym_map [xkb->max_key_code], 0, tmp * sizeof(XkbSymMapRec), __builtin_object_size ((char *) &xkb->map->key_sym_map[xkb->max_key_code ], 0)); | |||
741 | if (changes) { | |||
742 | changes->map.changed = _ExtendRange(changes->map.changed, | |||
743 | XkbKeySymsMask(1<<1), maxKC, | |||
744 | &changes->map.first_key_sym, | |||
745 | &changes->map.num_key_syms); | |||
746 | } | |||
747 | } | |||
748 | if (xkb->map->modmap) { | |||
749 | unsigned char *prev_modmap = xkb->map->modmap; | |||
750 | ||||
751 | xkb->map->modmap = _XkbTypedRealloc(xkb->map->modmap,((xkb->map->modmap) ? (unsigned char *)realloc(((xkb-> map->modmap)), ((((maxKC + 1))*sizeof(unsigned char)) == 0 ? 1 : (((maxKC + 1))*sizeof(unsigned char)))) : ((unsigned char *)calloc(((((maxKC + 1))) == 0 ? 1 : (((maxKC + 1)))), (sizeof (unsigned char))))) | |||
752 | (maxKC + 1), unsigned char)((xkb->map->modmap) ? (unsigned char *)realloc(((xkb-> map->modmap)), ((((maxKC + 1))*sizeof(unsigned char)) == 0 ? 1 : (((maxKC + 1))*sizeof(unsigned char)))) : ((unsigned char *)calloc(((((maxKC + 1))) == 0 ? 1 : (((maxKC + 1)))), (sizeof (unsigned char))))); | |||
753 | if (!xkb->map->modmap) { | |||
754 | _XkbFree(prev_modmap)free((prev_modmap)); | |||
755 | return BadAlloc11; | |||
756 | } | |||
757 | bzero((char *) &xkb->map->modmap[xkb->max_key_code], tmp)__builtin___memset_chk ((char *) &xkb->map->modmap[ xkb->max_key_code], 0, tmp, __builtin_object_size ((char * ) &xkb->map->modmap[xkb->max_key_code], 0)); | |||
758 | if (changes) { | |||
759 | changes->map.changed = _ExtendRange(changes->map.changed, | |||
760 | XkbModifierMapMask(1<<2), maxKC, | |||
761 | &changes->map.first_modmap_key, | |||
762 | &changes->map.num_modmap_keys); | |||
763 | } | |||
764 | } | |||
765 | } | |||
766 | if (xkb->server) { | |||
767 | if (xkb->server->behaviors) { | |||
768 | XkbBehavior *prev_behaviors = xkb->server->behaviors; | |||
769 | ||||
770 | xkb->server->behaviors = | |||
771 | _XkbTypedRealloc(xkb->server->behaviors, (maxKC + 1),((xkb->server->behaviors) ? (XkbBehavior *)realloc(((xkb ->server->behaviors)), ((((maxKC + 1))*sizeof(XkbBehavior )) == 0 ? 1 : (((maxKC + 1))*sizeof(XkbBehavior)))) : ((XkbBehavior *)calloc(((((maxKC + 1))) == 0 ? 1 : (((maxKC + 1)))), (sizeof (XkbBehavior))))) | |||
772 | XkbBehavior)((xkb->server->behaviors) ? (XkbBehavior *)realloc(((xkb ->server->behaviors)), ((((maxKC + 1))*sizeof(XkbBehavior )) == 0 ? 1 : (((maxKC + 1))*sizeof(XkbBehavior)))) : ((XkbBehavior *)calloc(((((maxKC + 1))) == 0 ? 1 : (((maxKC + 1)))), (sizeof (XkbBehavior))))); | |||
773 | if (!xkb->server->behaviors) { | |||
774 | _XkbFree(prev_behaviors)free((prev_behaviors)); | |||
775 | return BadAlloc11; | |||
776 | } | |||
777 | bzero((char *) &xkb->server->behaviors[xkb->max_key_code],__builtin___memset_chk ((char *) &xkb->server->behaviors [xkb->max_key_code], 0, tmp * sizeof(XkbBehavior), __builtin_object_size ((char *) &xkb->server->behaviors[xkb->max_key_code ], 0)) | |||
778 | tmp * sizeof(XkbBehavior))__builtin___memset_chk ((char *) &xkb->server->behaviors [xkb->max_key_code], 0, tmp * sizeof(XkbBehavior), __builtin_object_size ((char *) &xkb->server->behaviors[xkb->max_key_code ], 0)); | |||
779 | if (changes) { | |||
780 | changes->map.changed = _ExtendRange(changes->map.changed, | |||
781 | XkbKeyBehaviorsMask(1<<5), maxKC, | |||
782 | &changes->map.first_key_behavior, | |||
783 | &changes->map.num_key_behaviors); | |||
784 | } | |||
785 | } | |||
786 | if (xkb->server->key_acts) { | |||
787 | unsigned short *prev_key_acts = xkb->server->key_acts; | |||
788 | ||||
789 | xkb->server->key_acts = _XkbTypedRealloc(xkb->server->key_acts,((xkb->server->key_acts) ? (unsigned short *)realloc((( xkb->server->key_acts)), ((((maxKC + 1))*sizeof(unsigned short)) == 0 ? 1 : (((maxKC + 1))*sizeof(unsigned short)))) : ((unsigned short *)calloc(((((maxKC + 1))) == 0 ? 1 : (((maxKC + 1)))), (sizeof(unsigned short))))) | |||
790 | (maxKC + 1), unsigned short)((xkb->server->key_acts) ? (unsigned short *)realloc((( xkb->server->key_acts)), ((((maxKC + 1))*sizeof(unsigned short)) == 0 ? 1 : (((maxKC + 1))*sizeof(unsigned short)))) : ((unsigned short *)calloc(((((maxKC + 1))) == 0 ? 1 : (((maxKC + 1)))), (sizeof(unsigned short))))); | |||
791 | if (!xkb->server->key_acts) { | |||
792 | _XkbFree(prev_key_acts)free((prev_key_acts)); | |||
793 | return BadAlloc11; | |||
794 | } | |||
795 | bzero((char *) &xkb->server->key_acts[xkb->max_key_code],__builtin___memset_chk ((char *) &xkb->server->key_acts [xkb->max_key_code], 0, tmp * sizeof(unsigned short), __builtin_object_size ((char *) &xkb->server->key_acts[xkb->max_key_code ], 0)) | |||
796 | tmp * sizeof(unsigned short))__builtin___memset_chk ((char *) &xkb->server->key_acts [xkb->max_key_code], 0, tmp * sizeof(unsigned short), __builtin_object_size ((char *) &xkb->server->key_acts[xkb->max_key_code ], 0)); | |||
797 | if (changes) { | |||
798 | changes->map.changed = _ExtendRange(changes->map.changed, | |||
799 | XkbKeyActionsMask(1<<4), maxKC, | |||
800 | &changes->map.first_key_act, | |||
801 | &changes->map.num_key_acts); | |||
802 | } | |||
803 | } | |||
804 | if (xkb->server->vmodmap) { | |||
805 | unsigned short *prev_vmodmap = xkb->server->vmodmap; | |||
806 | ||||
807 | xkb->server->vmodmap = _XkbTypedRealloc(xkb->server->vmodmap,((xkb->server->vmodmap) ? (unsigned short *)realloc(((xkb ->server->vmodmap)), ((((maxKC + 1))*sizeof(unsigned short )) == 0 ? 1 : (((maxKC + 1))*sizeof(unsigned short)))) : ((unsigned short *)calloc(((((maxKC + 1))) == 0 ? 1 : (((maxKC + 1)))), (sizeof(unsigned short))))) | |||
808 | (maxKC + 1), unsigned short)((xkb->server->vmodmap) ? (unsigned short *)realloc(((xkb ->server->vmodmap)), ((((maxKC + 1))*sizeof(unsigned short )) == 0 ? 1 : (((maxKC + 1))*sizeof(unsigned short)))) : ((unsigned short *)calloc(((((maxKC + 1))) == 0 ? 1 : (((maxKC + 1)))), (sizeof(unsigned short))))); | |||
809 | if (!xkb->server->vmodmap) { | |||
810 | _XkbFree(prev_vmodmap)free((prev_vmodmap)); | |||
811 | return BadAlloc11; | |||
812 | } | |||
813 | bzero((char *) &xkb->server->vmodmap[xkb->max_key_code],__builtin___memset_chk ((char *) &xkb->server->vmodmap [xkb->max_key_code], 0, tmp * sizeof(unsigned short), __builtin_object_size ((char *) &xkb->server->vmodmap[xkb->max_key_code ], 0)) | |||
814 | tmp * sizeof(unsigned short))__builtin___memset_chk ((char *) &xkb->server->vmodmap [xkb->max_key_code], 0, tmp * sizeof(unsigned short), __builtin_object_size ((char *) &xkb->server->vmodmap[xkb->max_key_code ], 0)); | |||
815 | if (changes) { | |||
816 | changes->map.changed = _ExtendRange(changes->map.changed, | |||
817 | XkbVirtualModMapMask(1<<7), maxKC, | |||
818 | &changes->map.first_modmap_key, | |||
819 | &changes->map.num_vmodmap_keys); | |||
820 | } | |||
821 | } | |||
822 | } | |||
823 | if ((xkb->names) && (xkb->names->keys)) { | |||
824 | XkbKeyNameRec *prev_keys = xkb->names->keys; | |||
825 | ||||
826 | xkb->names->keys = _XkbTypedRealloc(xkb->names->keys,((xkb->names->keys) ? (XkbKeyNameRec *)realloc(((xkb-> names->keys)), ((((maxKC + 1))*sizeof(XkbKeyNameRec)) == 0 ? 1 : (((maxKC + 1))*sizeof(XkbKeyNameRec)))) : ((XkbKeyNameRec *)calloc(((((maxKC + 1))) == 0 ? 1 : (((maxKC + 1)))), (sizeof (XkbKeyNameRec))))) | |||
827 | (maxKC + 1), XkbKeyNameRec)((xkb->names->keys) ? (XkbKeyNameRec *)realloc(((xkb-> names->keys)), ((((maxKC + 1))*sizeof(XkbKeyNameRec)) == 0 ? 1 : (((maxKC + 1))*sizeof(XkbKeyNameRec)))) : ((XkbKeyNameRec *)calloc(((((maxKC + 1))) == 0 ? 1 : (((maxKC + 1)))), (sizeof (XkbKeyNameRec))))); | |||
828 | if (!xkb->names->keys) { | |||
829 | _XkbFree(prev_keys)free((prev_keys)); | |||
830 | return BadAlloc11; | |||
831 | } | |||
832 | bzero((char *) &xkb->names->keys[xkb->max_key_code],__builtin___memset_chk ((char *) &xkb->names->keys[ xkb->max_key_code], 0, tmp * sizeof(XkbKeyNameRec), __builtin_object_size ((char *) &xkb->names->keys[xkb->max_key_code], 0)) | |||
833 | tmp * sizeof(XkbKeyNameRec))__builtin___memset_chk ((char *) &xkb->names->keys[ xkb->max_key_code], 0, tmp * sizeof(XkbKeyNameRec), __builtin_object_size ((char *) &xkb->names->keys[xkb->max_key_code], 0)); | |||
834 | if (changes) { | |||
835 | changes->names.changed = _ExtendRange(changes->names.changed, | |||
836 | XkbKeyNamesMask(1<<9), maxKC, | |||
837 | &changes->names.first_key, | |||
838 | &changes->names.num_keys); | |||
839 | } | |||
840 | } | |||
841 | xkb->max_key_code = maxKC; | |||
842 | } | |||
843 | return Success0; | |||
844 | } | |||
845 | ||||
846 | XkbAction * | |||
847 | XkbResizeKeyActions(XkbDescPtr xkb, int key, int needed) | |||
848 | { | |||
849 | register int i, nActs; | |||
850 | XkbAction *newActs; | |||
851 | ||||
852 | if (needed == 0) { | |||
853 | xkb->server->key_acts[key] = 0; | |||
854 | return NULL((void*)0); | |||
855 | } | |||
856 | if (XkbKeyHasActions(xkb, key)((xkb)->server->key_acts[key]!=0) && | |||
857 | (XkbKeyNumSyms(xkb, key)(((((xkb)->map)->key_sym_map[(key)].width)*(((((xkb)-> map)->key_sym_map[(key)].group_info)&0x0f)))) >= (unsigned) needed)) | |||
858 | return XkbKeyActionsPtr(xkb, key)((&((xkb)->server)->acts[((xkb)->server)->key_acts [key]])); | |||
859 | if (xkb->server->size_acts - xkb->server->num_acts >= (unsigned) needed) { | |||
860 | xkb->server->key_acts[key] = xkb->server->num_acts; | |||
861 | xkb->server->num_acts += needed; | |||
862 | return &xkb->server->acts[xkb->server->key_acts[key]]; | |||
863 | } | |||
864 | xkb->server->size_acts = xkb->server->num_acts + needed + 8; | |||
865 | newActs = _XkbTypedCalloc(xkb->server->size_acts, XkbAction)((XkbAction *)calloc((((xkb->server->size_acts)) == 0 ? 1 : ((xkb->server->size_acts))), (sizeof(XkbAction)))); | |||
866 | if (newActs == NULL((void*)0)) | |||
867 | return NULL((void*)0); | |||
868 | newActs[0].type = XkbSA_NoAction0x00; | |||
869 | nActs = 1; | |||
870 | for (i = xkb->min_key_code; i <= (int) xkb->max_key_code; i++) { | |||
871 | int nKeyActs, nCopy; | |||
872 | ||||
873 | if ((xkb->server->key_acts[i] == 0) && (i != key)) | |||
874 | continue; | |||
875 | ||||
876 | nCopy = nKeyActs = XkbKeyNumActions(xkb, i)(((xkb)->server->key_acts[i]!=0)?(((((xkb)->map)-> key_sym_map[(i)].width)*(((((xkb)->map)->key_sym_map[(i )].group_info)&0x0f)))):1); | |||
877 | if (i == key) { | |||
878 | nKeyActs = needed; | |||
879 | if (needed < nCopy) | |||
880 | nCopy = needed; | |||
881 | } | |||
882 | ||||
883 | if (nCopy > 0) | |||
884 | memcpy(&newActs[nActs], XkbKeyActionsPtr(xkb, i),__builtin___memcpy_chk (&newActs[nActs], ((&((xkb)-> server)->acts[((xkb)->server)->key_acts[i]])), nCopy * sizeof(XkbAction), __builtin_object_size (&newActs[nActs ], 0)) | |||
885 | nCopy * sizeof(XkbAction))__builtin___memcpy_chk (&newActs[nActs], ((&((xkb)-> server)->acts[((xkb)->server)->key_acts[i]])), nCopy * sizeof(XkbAction), __builtin_object_size (&newActs[nActs ], 0)); | |||
886 | if (nCopy < nKeyActs) | |||
887 | bzero(&newActs[nActs + nCopy],__builtin___memset_chk (&newActs[nActs + nCopy], 0, (nKeyActs - nCopy) * sizeof(XkbAction), __builtin_object_size (&newActs [nActs + nCopy], 0)) | |||
888 | (nKeyActs - nCopy) * sizeof(XkbAction))__builtin___memset_chk (&newActs[nActs + nCopy], 0, (nKeyActs - nCopy) * sizeof(XkbAction), __builtin_object_size (&newActs [nActs + nCopy], 0)); | |||
889 | xkb->server->key_acts[i] = nActs; | |||
890 | nActs += nKeyActs; | |||
891 | } | |||
892 | _XkbFree(xkb->server->acts)free((xkb->server->acts)); | |||
893 | xkb->server->acts = newActs; | |||
894 | xkb->server->num_acts = nActs; | |||
895 | return &xkb->server->acts[xkb->server->key_acts[key]]; | |||
896 | } | |||
897 | ||||
898 | void | |||
899 | XkbFreeClientMap(XkbDescPtr xkb, unsigned what, Boolint freeMap) | |||
900 | { | |||
901 | XkbClientMapPtr map; | |||
902 | ||||
903 | if ((xkb == NULL((void*)0)) || (xkb->map == NULL((void*)0))) | |||
904 | return; | |||
905 | if (freeMap) | |||
906 | what = XkbAllClientInfoMask((1<<0)|(1<<1)|(1<<2)); | |||
907 | map = xkb->map; | |||
908 | if (what & XkbKeyTypesMask(1<<0)) { | |||
909 | if (map->types != NULL((void*)0)) { | |||
910 | if (map->num_types > 0) { | |||
911 | register int i; | |||
912 | XkbKeyTypePtr type; | |||
913 | ||||
914 | for (i = 0, type = map->types; i < map->num_types; i++, type++) { | |||
915 | _XkbFree(type->map)free((type->map)); | |||
916 | type->map = NULL((void*)0); | |||
917 | ||||
918 | _XkbFree(type->preserve)free((type->preserve)); | |||
919 | type->preserve = NULL((void*)0); | |||
920 | ||||
921 | type->map_count = 0; | |||
922 | ||||
923 | _XkbFree(type->level_names)free((type->level_names)); | |||
924 | type->level_names = NULL((void*)0); | |||
925 | } | |||
926 | } | |||
927 | _XkbFree(map->types)free((map->types)); | |||
928 | map->num_types = map->size_types = 0; | |||
929 | map->types = NULL((void*)0); | |||
930 | } | |||
931 | } | |||
932 | if (what & XkbKeySymsMask(1<<1)) { | |||
933 | _XkbFree(map->key_sym_map)free((map->key_sym_map)); | |||
934 | map->key_sym_map = NULL((void*)0); | |||
935 | ||||
936 | _XkbFree(map->syms)free((map->syms)); | |||
937 | map->size_syms = map->num_syms = 0; | |||
938 | map->syms = NULL((void*)0); | |||
939 | } | |||
940 | if (what & XkbModifierMapMask(1<<2)) { | |||
941 | _XkbFree(map->modmap)free((map->modmap)); | |||
942 | map->modmap = NULL((void*)0); | |||
943 | } | |||
944 | if (freeMap) { | |||
945 | _XkbFree(xkb->map)free((xkb->map)); | |||
946 | xkb->map = NULL((void*)0); | |||
947 | } | |||
948 | return; | |||
949 | } | |||
950 | ||||
951 | void | |||
952 | XkbFreeServerMap(XkbDescPtr xkb, unsigned what, Boolint freeMap) | |||
953 | { | |||
954 | XkbServerMapPtr map; | |||
955 | ||||
956 | if ((xkb == NULL((void*)0)) || (xkb->server == NULL((void*)0))) | |||
957 | return; | |||
958 | if (freeMap) | |||
959 | what = XkbAllServerInfoMask((1<<3)|(1<<4)|(1<<5)|(1<<6)|(1<< 7)); | |||
960 | map = xkb->server; | |||
961 | if (what & XkbExplicitComponentsMask(1<<3)) { | |||
962 | _XkbFree(map->explicit)free((map->explicit)); | |||
963 | map->explicit = NULL((void*)0); | |||
964 | } | |||
965 | if (what & XkbKeyActionsMask(1<<4)) { | |||
966 | _XkbFree(map->key_acts)free((map->key_acts)); | |||
967 | map->key_acts = NULL((void*)0); | |||
968 | ||||
969 | _XkbFree(map->acts)free((map->acts)); | |||
970 | map->num_acts = map->size_acts = 0; | |||
971 | map->acts = NULL((void*)0); | |||
972 | } | |||
973 | if (what & XkbKeyBehaviorsMask(1<<5)) { | |||
974 | _XkbFree(map->behaviors)free((map->behaviors)); | |||
975 | map->behaviors = NULL((void*)0); | |||
976 | } | |||
977 | if (what & XkbVirtualModMapMask(1<<7)) { | |||
978 | _XkbFree(map->vmodmap)free((map->vmodmap)); | |||
979 | map->vmodmap = NULL((void*)0); | |||
980 | } | |||
981 | ||||
982 | if (freeMap) { | |||
983 | _XkbFree(xkb->server)free((xkb->server)); | |||
984 | xkb->server = NULL((void*)0); | |||
985 | } | |||
986 | return; | |||
987 | } |