| 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') |
| 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 | } |