Bug Summary

File:src/xkb/XKBMAlloc.c
Location:line 338, column 22
Description:Access to field 'num_levels' results in a dereference of a null pointer (loaded from variable 'type')

Annotated Source Code

1/************************************************************
2Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
3
4Permission to use, copy, modify, and distribute this
5software and its documentation for any purpose and without
6fee is hereby granted, provided that the above copyright
7notice appear in all copies and that both that copyright
8notice and this permission notice appear in supporting
9documentation, and that the name of Silicon Graphics not be
10used in advertising or publicity pertaining to distribution
11of the software without specific prior written permission.
12Silicon Graphics makes no representation about the suitability
13of this software for any purpose. It is provided "as is"
14without any express or implied warranty.
15
16SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
17SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
18AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
19GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
20DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
21DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
22OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH
23THE 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
41Statusint
42XkbAllocClientMap(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
128Statusint
129XkbAllocServerMap(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
224Statusint
225XkbCopyKeyType(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
264Statusint
265XkbCopyKeyTypes(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
278XkbKeyTypePtr
279XkbAddKeyType(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))
1
Assuming 'xkb' is non-null
2
Assuming 'num_lvls' is >= 1
3
Taking false branch
291 return NULL((void*)0);
292 map = xkb->map;
293 if ((map) && (map->types)) {
4
Taking false branch
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)
5
Taking false branch
306 return NULL((void*)0);
307 if (!map)
6
Taking false branch
308 map = xkb->map;
309 tmp = 0;
310 if (map->num_types <= XkbKeypadIndex3)
7
Taking false branch
311 tmp |= XkbKeypadMask(1<<3);
312 if (map->num_types <= XkbAlphabeticIndex2)
8
Taking false branch
313 tmp |= XkbAlphabeticMask(1<<2);
314 if (map->num_types <= XkbTwoLevelIndex1)
9
Taking false branch
315 tmp |= XkbTwoLevelMask(1<<1);
316 if (map->num_types <= XkbOneLevelIndex0)
10
Taking false branch
317 tmp |= XkbOneLevelMask(1<<0);
318 if (XkbInitCanonicalKeyTypes(xkb, tmp, XkbNoModifier0xff) == Success0) {
11
Taking false branch
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];
12
Null pointer value stored to 'type'
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;
13
Access to field 'num_levels' results in a dereference of a null pointer (loaded from variable 'type')
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
359Statusint
360XkbResizeKeyType(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
562KeySym *
563XkbResizeKeySyms(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
618static 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
644Statusint
645XkbChangeKeycodeRange(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
846XkbAction *
847XkbResizeKeyActions(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
898void
899XkbFreeClientMap(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
951void
952XkbFreeServerMap(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}