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