| File: | xkb/xkbUtils.c |
| Location: | line 1290, column 13 |
| Description: | Null pointer argument in call to memory copy function |
| 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 | ||||||
| 28 | Copyright © 2008 Red Hat Inc. | |||||
| 29 | ||||||
| 30 | Permission is hereby granted, free of charge, to any person obtaining a | |||||
| 31 | copy of this software and associated documentation files (the "Software"), | |||||
| 32 | to deal in the Software without restriction, including without limitation | |||||
| 33 | the rights to use, copy, modify, merge, publish, distribute, sublicense, | |||||
| 34 | and/or sell copies of the Software, and to permit persons to whom the | |||||
| 35 | Software is furnished to do so, subject to the following conditions: | |||||
| 36 | ||||||
| 37 | The above copyright notice and this permission notice (including the next | |||||
| 38 | paragraph) shall be included in all copies or substantial portions of the | |||||
| 39 | Software. | |||||
| 40 | ||||||
| 41 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |||||
| 42 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |||||
| 43 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL | |||||
| 44 | THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |||||
| 45 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING | |||||
| 46 | FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER | |||||
| 47 | DEALINGS IN THE SOFTWARE. | |||||
| 48 | ||||||
| 49 | */ | |||||
| 50 | ||||||
| 51 | #ifdef HAVE_DIX_CONFIG_H1 | |||||
| 52 | #include <dix-config.h> | |||||
| 53 | #endif | |||||
| 54 | ||||||
| 55 | #include "os.h" | |||||
| 56 | #include <stdio.h> | |||||
| 57 | #include <ctype.h> | |||||
| 58 | #include <math.h> | |||||
| 59 | #include <X11/X.h> | |||||
| 60 | #include <X11/Xproto.h> | |||||
| 61 | #define XK_CYRILLIC | |||||
| 62 | #include <X11/keysym.h> | |||||
| 63 | #include "misc.h" | |||||
| 64 | #include "inputstr.h" | |||||
| 65 | #include "eventstr.h" | |||||
| 66 | ||||||
| 67 | #define XKBSRV_NEED_FILE_FUNCS | |||||
| 68 | #include <xkbsrv.h> | |||||
| 69 | #include "xkbgeom.h" | |||||
| 70 | #include "xkb.h" | |||||
| 71 | ||||||
| 72 | /***====================================================================***/ | |||||
| 73 | ||||||
| 74 | int | |||||
| 75 | _XkbLookupAnyDevice(DeviceIntPtr *pDev, int id, ClientPtr client, | |||||
| 76 | Mask access_mode, int *xkb_err) | |||||
| 77 | { | |||||
| 78 | int rc = XkbKeyboardErrorCode; | |||||
| 79 | ||||||
| 80 | if (id == XkbUseCoreKbd0x0100) | |||||
| 81 | id = PickKeyboard(client)->id; | |||||
| 82 | else if (id == XkbUseCorePtr0x0200) | |||||
| 83 | id = PickPointer(client)->id; | |||||
| 84 | ||||||
| 85 | rc = dixLookupDevice(pDev, id, client, access_mode); | |||||
| 86 | if (rc != Success0) | |||||
| 87 | *xkb_err = XkbErr_BadDevice0xff; | |||||
| 88 | ||||||
| 89 | return rc; | |||||
| 90 | } | |||||
| 91 | ||||||
| 92 | int | |||||
| 93 | _XkbLookupKeyboard(DeviceIntPtr *pDev, int id, ClientPtr client, | |||||
| 94 | Mask access_mode, int *xkb_err) | |||||
| 95 | { | |||||
| 96 | DeviceIntPtr dev; | |||||
| 97 | int rc; | |||||
| 98 | ||||||
| 99 | if (id == XkbDfltXIId0x0400) | |||||
| 100 | id = XkbUseCoreKbd0x0100; | |||||
| 101 | ||||||
| 102 | rc = _XkbLookupAnyDevice(pDev, id, client, access_mode, xkb_err); | |||||
| 103 | if (rc != Success0) | |||||
| 104 | return rc; | |||||
| 105 | ||||||
| 106 | dev = *pDev; | |||||
| 107 | if (!dev->key || !dev->key->xkbInfo) { | |||||
| 108 | *pDev = NULL((void*)0); | |||||
| 109 | *xkb_err = XkbErr_BadClass0xfe; | |||||
| 110 | return XkbKeyboardErrorCode; | |||||
| 111 | } | |||||
| 112 | return Success0; | |||||
| 113 | } | |||||
| 114 | ||||||
| 115 | int | |||||
| 116 | _XkbLookupBellDevice(DeviceIntPtr *pDev, int id, ClientPtr client, | |||||
| 117 | Mask access_mode, int *xkb_err) | |||||
| 118 | { | |||||
| 119 | DeviceIntPtr dev; | |||||
| 120 | int rc; | |||||
| 121 | ||||||
| 122 | rc = _XkbLookupAnyDevice(pDev, id, client, access_mode, xkb_err); | |||||
| 123 | if (rc != Success0) | |||||
| 124 | return rc; | |||||
| 125 | ||||||
| 126 | dev = *pDev; | |||||
| 127 | if (!dev->kbdfeed && !dev->bell) { | |||||
| 128 | *pDev = NULL((void*)0); | |||||
| 129 | *xkb_err = XkbErr_BadClass0xfe; | |||||
| 130 | return XkbKeyboardErrorCode; | |||||
| 131 | } | |||||
| 132 | return Success0; | |||||
| 133 | } | |||||
| 134 | ||||||
| 135 | int | |||||
| 136 | _XkbLookupLedDevice(DeviceIntPtr *pDev, int id, ClientPtr client, | |||||
| 137 | Mask access_mode, int *xkb_err) | |||||
| 138 | { | |||||
| 139 | DeviceIntPtr dev; | |||||
| 140 | int rc; | |||||
| 141 | ||||||
| 142 | if (id == XkbDfltXIId0x0400) | |||||
| 143 | id = XkbUseCorePtr0x0200; | |||||
| 144 | ||||||
| 145 | rc = _XkbLookupAnyDevice(pDev, id, client, access_mode, xkb_err); | |||||
| 146 | if (rc != Success0) | |||||
| 147 | return rc; | |||||
| 148 | ||||||
| 149 | dev = *pDev; | |||||
| 150 | if (!dev->kbdfeed && !dev->leds) { | |||||
| 151 | *pDev = NULL((void*)0); | |||||
| 152 | *xkb_err = XkbErr_BadClass0xfe; | |||||
| 153 | return XkbKeyboardErrorCode; | |||||
| 154 | } | |||||
| 155 | return Success0; | |||||
| 156 | } | |||||
| 157 | ||||||
| 158 | int | |||||
| 159 | _XkbLookupButtonDevice(DeviceIntPtr *pDev, int id, ClientPtr client, | |||||
| 160 | Mask access_mode, int *xkb_err) | |||||
| 161 | { | |||||
| 162 | DeviceIntPtr dev; | |||||
| 163 | int rc; | |||||
| 164 | ||||||
| 165 | rc = _XkbLookupAnyDevice(pDev, id, client, access_mode, xkb_err); | |||||
| 166 | if (rc != Success0) | |||||
| 167 | return rc; | |||||
| 168 | ||||||
| 169 | dev = *pDev; | |||||
| 170 | if (!dev->button) { | |||||
| 171 | *pDev = NULL((void*)0); | |||||
| 172 | *xkb_err = XkbErr_BadClass0xfe; | |||||
| 173 | return XkbKeyboardErrorCode; | |||||
| 174 | } | |||||
| 175 | return Success0; | |||||
| 176 | } | |||||
| 177 | ||||||
| 178 | void | |||||
| 179 | XkbSetActionKeyMods(XkbDescPtr xkb, XkbAction *act, unsigned mods) | |||||
| 180 | { | |||||
| 181 | register unsigned tmp; | |||||
| 182 | ||||||
| 183 | switch (act->type) { | |||||
| 184 | case XkbSA_SetMods0x01: | |||||
| 185 | case XkbSA_LatchMods0x02: | |||||
| 186 | case XkbSA_LockMods0x03: | |||||
| 187 | if (act->mods.flags & XkbSA_UseModMapMods(1L << 2)) | |||||
| 188 | act->mods.real_mods = act->mods.mask = mods; | |||||
| 189 | if ((tmp = XkbModActionVMods(&act->mods)((short) (((&act->mods)->vmods1 << 8) | (& act->mods)->vmods2))) != 0) | |||||
| 190 | act->mods.mask |= XkbMaskForVMask(xkb, tmp); | |||||
| 191 | break; | |||||
| 192 | case XkbSA_ISOLock0x0b: | |||||
| 193 | if (act->iso.flags & XkbSA_UseModMapMods(1L << 2)) | |||||
| 194 | act->iso.real_mods = act->iso.mask = mods; | |||||
| 195 | if ((tmp = XkbModActionVMods(&act->iso)((short) (((&act->iso)->vmods1 << 8) | (& act->iso)->vmods2))) != 0) | |||||
| 196 | act->iso.mask |= XkbMaskForVMask(xkb, tmp); | |||||
| 197 | break; | |||||
| 198 | } | |||||
| 199 | return; | |||||
| 200 | } | |||||
| 201 | ||||||
| 202 | unsigned | |||||
| 203 | XkbMaskForVMask(XkbDescPtr xkb, unsigned vmask) | |||||
| 204 | { | |||||
| 205 | register int i, bit; | |||||
| 206 | register unsigned mask; | |||||
| 207 | ||||||
| 208 | for (mask = i = 0, bit = 1; i < XkbNumVirtualMods16; i++, bit <<= 1) { | |||||
| 209 | if (vmask & bit) | |||||
| 210 | mask |= xkb->server->vmods[i]; | |||||
| 211 | } | |||||
| 212 | return mask; | |||||
| 213 | } | |||||
| 214 | ||||||
| 215 | /***====================================================================***/ | |||||
| 216 | ||||||
| 217 | void | |||||
| 218 | XkbUpdateKeyTypesFromCore(DeviceIntPtr pXDev, | |||||
| 219 | KeySymsPtr pCore, | |||||
| 220 | KeyCode first, CARD8 num, XkbChangesPtr changes) | |||||
| 221 | { | |||||
| 222 | XkbDescPtr xkb; | |||||
| 223 | unsigned key, nG, explicit; | |||||
| 224 | int types[XkbNumKbdGroups4]; | |||||
| 225 | KeySym tsyms[XkbMaxSymsPerKey(63*4)], *syms; | |||||
| 226 | XkbMapChangesPtr mc; | |||||
| 227 | ||||||
| 228 | xkb = pXDev->key->xkbInfo->desc; | |||||
| 229 | if (first + num - 1 > xkb->max_key_code) { | |||||
| 230 | /* 1/12/95 (ef) -- XXX! should allow XKB structures to grow */ | |||||
| 231 | num = xkb->max_key_code - first + 1; | |||||
| 232 | } | |||||
| 233 | ||||||
| 234 | mc = (changes ? (&changes->map) : NULL((void*)0)); | |||||
| 235 | ||||||
| 236 | syms = &pCore->map[(first - pCore->minKeyCode) * pCore->mapWidth]; | |||||
| 237 | for (key = first; key < (first + num); key++, syms += pCore->mapWidth) { | |||||
| 238 | explicit = xkb->server->explicit[key] & XkbExplicitKeyTypesMask(0x0f); | |||||
| 239 | types[XkbGroup1Index0] = XkbKeyKeyTypeIndex(xkb, key, XkbGroup1Index)((((xkb)->map)->key_sym_map[((key))].kt_index[((0)) & 0x3])); | |||||
| 240 | types[XkbGroup2Index1] = XkbKeyKeyTypeIndex(xkb, key, XkbGroup2Index)((((xkb)->map)->key_sym_map[((key))].kt_index[((1)) & 0x3])); | |||||
| 241 | types[XkbGroup3Index2] = XkbKeyKeyTypeIndex(xkb, key, XkbGroup3Index)((((xkb)->map)->key_sym_map[((key))].kt_index[((2)) & 0x3])); | |||||
| 242 | types[XkbGroup4Index3] = XkbKeyKeyTypeIndex(xkb, key, XkbGroup4Index)((((xkb)->map)->key_sym_map[((key))].kt_index[((3)) & 0x3])); | |||||
| 243 | nG = XkbKeyTypesForCoreSymbolsSrvXkbKeyTypesForCoreSymbols(xkb, pCore->mapWidth, syms, explicit, | |||||
| 244 | types, tsyms); | |||||
| 245 | XkbChangeTypesOfKeySrvXkbChangeTypesOfKey(xkb, key, nG, XkbAllGroupsMask(0xf), types, mc); | |||||
| 246 | memcpy((char *) XkbKeySymsPtr(xkb, key), (char *) tsyms,__builtin___memcpy_chk ((char *) ((&((xkb)->map)->syms [((((xkb)->map))->key_sym_map[(((key)))].offset)])), (char *) tsyms, ((((((xkb)->map))->key_sym_map[(((key)))].width ) * ((((((xkb)->map))->key_sym_map[(((key)))].group_info )&0x0f)))) * sizeof(KeySym), __builtin_object_size ((char *) ((&((xkb)->map)->syms[((((xkb)->map))->key_sym_map [(((key)))].offset)])), 0)) | |||||
| 247 | XkbKeyNumSyms(xkb, key) * sizeof(KeySym))__builtin___memcpy_chk ((char *) ((&((xkb)->map)->syms [((((xkb)->map))->key_sym_map[(((key)))].offset)])), (char *) tsyms, ((((((xkb)->map))->key_sym_map[(((key)))].width ) * ((((((xkb)->map))->key_sym_map[(((key)))].group_info )&0x0f)))) * sizeof(KeySym), __builtin_object_size ((char *) ((&((xkb)->map)->syms[((((xkb)->map))->key_sym_map [(((key)))].offset)])), 0)); | |||||
| 248 | } | |||||
| 249 | if (changes->map.changed & XkbKeySymsMask(1<<1)) { | |||||
| 250 | CARD8 oldLast, newLast; | |||||
| 251 | ||||||
| 252 | oldLast = changes->map.first_key_sym + changes->map.num_key_syms - 1; | |||||
| 253 | newLast = first + num - 1; | |||||
| 254 | ||||||
| 255 | if (first < changes->map.first_key_sym) | |||||
| 256 | changes->map.first_key_sym = first; | |||||
| 257 | if (oldLast > newLast) | |||||
| 258 | newLast = oldLast; | |||||
| 259 | changes->map.num_key_syms = newLast - changes->map.first_key_sym + 1; | |||||
| 260 | } | |||||
| 261 | else { | |||||
| 262 | changes->map.changed |= XkbKeySymsMask(1<<1); | |||||
| 263 | changes->map.first_key_sym = first; | |||||
| 264 | changes->map.num_key_syms = num; | |||||
| 265 | } | |||||
| 266 | return; | |||||
| 267 | } | |||||
| 268 | ||||||
| 269 | void | |||||
| 270 | XkbUpdateDescActions(XkbDescPtr xkb, | |||||
| 271 | KeyCode first, CARD8 num, XkbChangesPtr changes) | |||||
| 272 | { | |||||
| 273 | register unsigned key; | |||||
| 274 | ||||||
| 275 | for (key = first; key < (first + num); key++) { | |||||
| 276 | XkbApplyCompatMapToKeySrvXkbApplyCompatMapToKey(xkb, key, changes); | |||||
| 277 | } | |||||
| 278 | ||||||
| 279 | if (changes->map.changed & (XkbVirtualModMapMask(1<<7) | XkbModifierMapMask(1<<2))) { | |||||
| 280 | unsigned char newVMods[XkbNumVirtualMods16]; | |||||
| 281 | register unsigned bit, i; | |||||
| 282 | unsigned present; | |||||
| 283 | ||||||
| 284 | memset(newVMods, 0, XkbNumVirtualMods)__builtin___memset_chk (newVMods, 0, 16, __builtin_object_size (newVMods, 0)); | |||||
| 285 | present = 0; | |||||
| 286 | for (key = xkb->min_key_code; key <= xkb->max_key_code; key++) { | |||||
| 287 | if (xkb->server->vmodmap[key] == 0) | |||||
| 288 | continue; | |||||
| 289 | for (i = 0, bit = 1; i < XkbNumVirtualMods16; i++, bit <<= 1) { | |||||
| 290 | if (bit & xkb->server->vmodmap[key]) { | |||||
| 291 | present |= bit; | |||||
| 292 | newVMods[i] |= xkb->map->modmap[key]; | |||||
| 293 | } | |||||
| 294 | } | |||||
| 295 | } | |||||
| 296 | for (i = 0, bit = 1; i < XkbNumVirtualMods16; i++, bit <<= 1) { | |||||
| 297 | if ((bit & present) && (newVMods[i] != xkb->server->vmods[i])) { | |||||
| 298 | changes->map.changed |= XkbVirtualModsMask(1<<6); | |||||
| 299 | changes->map.vmods |= bit; | |||||
| 300 | xkb->server->vmods[i] = newVMods[i]; | |||||
| 301 | } | |||||
| 302 | } | |||||
| 303 | } | |||||
| 304 | if (changes->map.changed & XkbVirtualModsMask(1<<6)) | |||||
| 305 | XkbApplyVirtualModChangesSrvXkbApplyVirtualModChanges(xkb, changes->map.vmods, changes); | |||||
| 306 | ||||||
| 307 | if (changes->map.changed & XkbKeyActionsMask(1<<4)) { | |||||
| 308 | CARD8 oldLast, newLast; | |||||
| 309 | ||||||
| 310 | oldLast = changes->map.first_key_act + changes->map.num_key_acts - 1; | |||||
| 311 | newLast = first + num - 1; | |||||
| 312 | ||||||
| 313 | if (first < changes->map.first_key_act) | |||||
| 314 | changes->map.first_key_act = first; | |||||
| 315 | if (newLast > oldLast) | |||||
| 316 | newLast = oldLast; | |||||
| 317 | changes->map.num_key_acts = newLast - changes->map.first_key_act + 1; | |||||
| 318 | } | |||||
| 319 | else { | |||||
| 320 | changes->map.changed |= XkbKeyActionsMask(1<<4); | |||||
| 321 | changes->map.first_key_act = first; | |||||
| 322 | changes->map.num_key_acts = num; | |||||
| 323 | } | |||||
| 324 | return; | |||||
| 325 | } | |||||
| 326 | ||||||
| 327 | void | |||||
| 328 | XkbUpdateActions(DeviceIntPtr pXDev, | |||||
| 329 | KeyCode first, | |||||
| 330 | CARD8 num, | |||||
| 331 | XkbChangesPtr changes, | |||||
| 332 | unsigned *needChecksRtrn, XkbEventCausePtr cause) | |||||
| 333 | { | |||||
| 334 | XkbSrvInfoPtr xkbi; | |||||
| 335 | XkbDescPtr xkb; | |||||
| 336 | CARD8 *repeat; | |||||
| 337 | ||||||
| 338 | if (needChecksRtrn) | |||||
| 339 | *needChecksRtrn = 0; | |||||
| 340 | xkbi = pXDev->key->xkbInfo; | |||||
| 341 | xkb = xkbi->desc; | |||||
| 342 | repeat = xkb->ctrls->per_key_repeat; | |||||
| 343 | ||||||
| 344 | /* before letting XKB do any changes, copy the current core values */ | |||||
| 345 | if (pXDev->kbdfeed) | |||||
| 346 | memcpy(repeat, pXDev->kbdfeed->ctrl.autoRepeats, XkbPerKeyBitArraySize)__builtin___memcpy_chk (repeat, pXDev->kbdfeed->ctrl.autoRepeats , ((255 +1)/8), __builtin_object_size (repeat, 0)); | |||||
| 347 | ||||||
| 348 | XkbUpdateDescActions(xkb, first, num, changes); | |||||
| 349 | ||||||
| 350 | if ((pXDev->kbdfeed) && | |||||
| 351 | (changes->ctrls.changed_ctrls & XkbPerKeyRepeatMask(1L << 30))) { | |||||
| 352 | /* now copy the modified changes back to core */ | |||||
| 353 | memcpy(pXDev->kbdfeed->ctrl.autoRepeats, repeat, XkbPerKeyBitArraySize)__builtin___memcpy_chk (pXDev->kbdfeed->ctrl.autoRepeats , repeat, ((255 +1)/8), __builtin_object_size (pXDev->kbdfeed ->ctrl.autoRepeats, 0)); | |||||
| 354 | if (pXDev->kbdfeed->CtrlProc) | |||||
| 355 | (*pXDev->kbdfeed->CtrlProc) (pXDev, &pXDev->kbdfeed->ctrl); | |||||
| 356 | } | |||||
| 357 | return; | |||||
| 358 | } | |||||
| 359 | ||||||
| 360 | KeySymsPtr | |||||
| 361 | XkbGetCoreMap(DeviceIntPtr keybd) | |||||
| 362 | { | |||||
| 363 | register int key, tmp; | |||||
| 364 | int maxSymsPerKey, maxGroup1Width; | |||||
| 365 | XkbDescPtr xkb; | |||||
| 366 | KeySymsPtr syms; | |||||
| 367 | int maxNumberOfGroups; | |||||
| 368 | ||||||
| 369 | if (!keybd || !keybd->key || !keybd->key->xkbInfo) | |||||
| 370 | return NULL((void*)0); | |||||
| 371 | ||||||
| 372 | xkb = keybd->key->xkbInfo->desc; | |||||
| 373 | maxSymsPerKey = maxGroup1Width = 0; | |||||
| 374 | maxNumberOfGroups = 0; | |||||
| 375 | ||||||
| 376 | /* determine sizes */ | |||||
| 377 | for (key = xkb->min_key_code; key <= xkb->max_key_code; key++) { | |||||
| 378 | if (XkbKeycodeInRange(xkb, key)((key) >= (xkb)->min_key_code && (key) <= (xkb )->max_key_code)) { | |||||
| 379 | int nGroups; | |||||
| 380 | int w; | |||||
| 381 | ||||||
| 382 | nGroups = XkbKeyNumGroups(xkb, key)((((((xkb)->map)->key_sym_map[((key))].group_info)& 0x0f))); | |||||
| 383 | tmp = 0; | |||||
| 384 | if (nGroups > 0) { | |||||
| 385 | if ((w = XkbKeyGroupWidth(xkb, key, XkbGroup1Index)(((&(((xkb)->map))->types[(((((xkb)->map)))-> key_sym_map[((((key))))].kt_index[((((0)))) & 0x3])])-> num_levels))) <= 2) | |||||
| 386 | tmp += 2; | |||||
| 387 | else | |||||
| 388 | tmp += w + 2; | |||||
| 389 | /* remember highest G1 width */ | |||||
| 390 | if (w > maxGroup1Width) | |||||
| 391 | maxGroup1Width = w; | |||||
| 392 | } | |||||
| 393 | if (nGroups > 1) { | |||||
| 394 | if (tmp <= 2) { | |||||
| 395 | if ((w = XkbKeyGroupWidth(xkb, key, XkbGroup2Index)(((&(((xkb)->map))->types[(((((xkb)->map)))-> key_sym_map[((((key))))].kt_index[((((1)))) & 0x3])])-> num_levels))) < 2) | |||||
| 396 | tmp += 2; | |||||
| 397 | else | |||||
| 398 | tmp += w; | |||||
| 399 | } | |||||
| 400 | else { | |||||
| 401 | if ((w = XkbKeyGroupWidth(xkb, key, XkbGroup2Index)(((&(((xkb)->map))->types[(((((xkb)->map)))-> key_sym_map[((((key))))].kt_index[((((1)))) & 0x3])])-> num_levels))) > 2) | |||||
| 402 | tmp += w - 2; | |||||
| 403 | } | |||||
| 404 | } | |||||
| 405 | if (nGroups > 2) | |||||
| 406 | tmp += XkbKeyGroupWidth(xkb, key, XkbGroup3Index)(((&(((xkb)->map))->types[(((((xkb)->map)))-> key_sym_map[((((key))))].kt_index[((((2)))) & 0x3])])-> num_levels)); | |||||
| 407 | if (nGroups > 3) | |||||
| 408 | tmp += XkbKeyGroupWidth(xkb, key, XkbGroup4Index)(((&(((xkb)->map))->types[(((((xkb)->map)))-> key_sym_map[((((key))))].kt_index[((((3)))) & 0x3])])-> num_levels)); | |||||
| 409 | if (tmp > maxSymsPerKey) | |||||
| 410 | maxSymsPerKey = tmp; | |||||
| 411 | if (nGroups > maxNumberOfGroups) | |||||
| 412 | maxNumberOfGroups = nGroups; | |||||
| 413 | } | |||||
| 414 | } | |||||
| 415 | ||||||
| 416 | if (maxSymsPerKey <= 0) | |||||
| 417 | return NULL((void*)0); | |||||
| 418 | ||||||
| 419 | syms = calloc(1, sizeof(*syms)); | |||||
| 420 | if (!syms) | |||||
| 421 | return NULL((void*)0); | |||||
| 422 | ||||||
| 423 | /* See Section 12.4 of the XKB Protocol spec. Because of the | |||||
| 424 | * single-group distribution for multi-group keyboards, we have to | |||||
| 425 | * have enough symbols for the largest group 1 to replicate across the | |||||
| 426 | * number of groups on the keyboard. e.g. a single-group key with 4 | |||||
| 427 | * symbols on a keyboard that has 3 groups -> 12 syms per key */ | |||||
| 428 | if (maxSymsPerKey < maxNumberOfGroups * maxGroup1Width) | |||||
| 429 | maxSymsPerKey = maxNumberOfGroups * maxGroup1Width; | |||||
| 430 | ||||||
| 431 | syms->mapWidth = maxSymsPerKey; | |||||
| 432 | syms->minKeyCode = xkb->min_key_code; | |||||
| 433 | syms->maxKeyCode = xkb->max_key_code; | |||||
| 434 | ||||||
| 435 | tmp = syms->mapWidth * (xkb->max_key_code - xkb->min_key_code + 1); | |||||
| 436 | syms->map = calloc(tmp, sizeof(*syms->map)); | |||||
| 437 | if (!syms->map) { | |||||
| 438 | free(syms); | |||||
| 439 | return NULL((void*)0); | |||||
| 440 | } | |||||
| 441 | ||||||
| 442 | for (key = xkb->min_key_code; key <= xkb->max_key_code; key++) { | |||||
| 443 | KeySym *pCore, *pXKB; | |||||
| 444 | unsigned nGroups, groupWidth, n, nOut; | |||||
| 445 | ||||||
| 446 | nGroups = XkbKeyNumGroups(xkb, key)((((((xkb)->map)->key_sym_map[((key))].group_info)& 0x0f))); | |||||
| 447 | n = (key - xkb->min_key_code) * syms->mapWidth; | |||||
| 448 | pCore = &syms->map[n]; | |||||
| 449 | pXKB = XkbKeySymsPtr(xkb, key)((&((xkb)->map)->syms[((((xkb)->map))->key_sym_map [(((key)))].offset)])); | |||||
| 450 | nOut = 2; | |||||
| 451 | if (nGroups > 0) { | |||||
| 452 | groupWidth = XkbKeyGroupWidth(xkb, key, XkbGroup1Index)(((&(((xkb)->map))->types[(((((xkb)->map)))-> key_sym_map[((((key))))].kt_index[((((0)))) & 0x3])])-> num_levels)); | |||||
| 453 | if (groupWidth > 0) | |||||
| 454 | pCore[0] = pXKB[0]; | |||||
| 455 | if (groupWidth > 1) | |||||
| 456 | pCore[1] = pXKB[1]; | |||||
| 457 | for (n = 2; n < groupWidth; n++) | |||||
| 458 | pCore[2 + n] = pXKB[n]; | |||||
| 459 | if (groupWidth > 2) | |||||
| 460 | nOut = groupWidth; | |||||
| 461 | } | |||||
| 462 | ||||||
| 463 | /* See XKB Protocol Sec, Section 12.4. | |||||
| 464 | A 1-group key with ABCDE on a 2 group keyboard must be | |||||
| 465 | duplicated across all groups as ABABCDECDE. | |||||
| 466 | */ | |||||
| 467 | if (nGroups == 1) { | |||||
| 468 | int idx, j; | |||||
| 469 | ||||||
| 470 | groupWidth = XkbKeyGroupWidth(xkb, key, XkbGroup1Index)(((&(((xkb)->map))->types[(((((xkb)->map)))-> key_sym_map[((((key))))].kt_index[((((0)))) & 0x3])])-> num_levels)); | |||||
| 471 | ||||||
| 472 | /* AB..CDE... -> ABABCDE... */ | |||||
| 473 | if (groupWidth > 0 && syms->mapWidth >= 3) | |||||
| 474 | pCore[2] = pCore[0]; | |||||
| 475 | if (groupWidth > 1 && syms->mapWidth >= 4) | |||||
| 476 | pCore[3] = pCore[1]; | |||||
| 477 | ||||||
| 478 | /* ABABCDE... -> ABABCDECDE */ | |||||
| 479 | idx = 2 + groupWidth; | |||||
| 480 | while (groupWidth > 2 && idx < syms->mapWidth && | |||||
| 481 | idx < groupWidth * 2) { | |||||
| 482 | pCore[idx] = pCore[idx - groupWidth + 2]; | |||||
| 483 | idx++; | |||||
| 484 | } | |||||
| 485 | idx = 2 * groupWidth; | |||||
| 486 | if (idx < 4) | |||||
| 487 | idx = 4; | |||||
| 488 | /* 3 or more groups: ABABCDECDEABCDEABCDE */ | |||||
| 489 | for (j = 3; j <= maxNumberOfGroups; j++) | |||||
| 490 | for (n = 0; n < groupWidth && idx < maxSymsPerKey; n++) | |||||
| 491 | pCore[idx++] = pXKB[n]; | |||||
| 492 | } | |||||
| 493 | ||||||
| 494 | pXKB += XkbKeyGroupsWidth(xkb, key)((((xkb)->map)->key_sym_map[((key))].width)); | |||||
| 495 | nOut += 2; | |||||
| 496 | if (nGroups > 1) { | |||||
| 497 | groupWidth = XkbKeyGroupWidth(xkb, key, XkbGroup2Index)(((&(((xkb)->map))->types[(((((xkb)->map)))-> key_sym_map[((((key))))].kt_index[((((1)))) & 0x3])])-> num_levels)); | |||||
| 498 | if (groupWidth > 0) | |||||
| 499 | pCore[2] = pXKB[0]; | |||||
| 500 | if (groupWidth > 1) | |||||
| 501 | pCore[3] = pXKB[1]; | |||||
| 502 | for (n = 2; n < groupWidth; n++) { | |||||
| 503 | pCore[nOut + (n - 2)] = pXKB[n]; | |||||
| 504 | } | |||||
| 505 | if (groupWidth > 2) | |||||
| 506 | nOut += (groupWidth - 2); | |||||
| 507 | } | |||||
| 508 | pXKB += XkbKeyGroupsWidth(xkb, key)((((xkb)->map)->key_sym_map[((key))].width)); | |||||
| 509 | for (n = XkbGroup3Index2; n < nGroups; n++) { | |||||
| 510 | register int s; | |||||
| 511 | ||||||
| 512 | groupWidth = XkbKeyGroupWidth(xkb, key, n)(((&(((xkb)->map))->types[(((((xkb)->map)))-> key_sym_map[((((key))))].kt_index[((((n)))) & 0x3])])-> num_levels)); | |||||
| 513 | for (s = 0; s < groupWidth; s++) { | |||||
| 514 | pCore[nOut++] = pXKB[s]; | |||||
| 515 | } | |||||
| 516 | pXKB += XkbKeyGroupsWidth(xkb, key)((((xkb)->map)->key_sym_map[((key))].width)); | |||||
| 517 | } | |||||
| 518 | } | |||||
| 519 | ||||||
| 520 | return syms; | |||||
| 521 | } | |||||
| 522 | ||||||
| 523 | void | |||||
| 524 | XkbSetRepeatKeys(DeviceIntPtr pXDev, int key, int onoff) | |||||
| 525 | { | |||||
| 526 | if (pXDev && pXDev->key && pXDev->key->xkbInfo) { | |||||
| 527 | xkbControlsNotify cn; | |||||
| 528 | XkbControlsPtr ctrls = pXDev->key->xkbInfo->desc->ctrls; | |||||
| 529 | XkbControlsRec old; | |||||
| 530 | ||||||
| 531 | old = *ctrls; | |||||
| 532 | ||||||
| 533 | if (key == -1) { /* global autorepeat setting changed */ | |||||
| 534 | if (onoff) | |||||
| 535 | ctrls->enabled_ctrls |= XkbRepeatKeysMask(1L << 0); | |||||
| 536 | else | |||||
| 537 | ctrls->enabled_ctrls &= ~XkbRepeatKeysMask(1L << 0); | |||||
| 538 | } | |||||
| 539 | else if (pXDev->kbdfeed) { | |||||
| 540 | ctrls->per_key_repeat[key / 8] = | |||||
| 541 | pXDev->kbdfeed->ctrl.autoRepeats[key / 8]; | |||||
| 542 | } | |||||
| 543 | ||||||
| 544 | if (XkbComputeControlsNotify(pXDev, &old, ctrls, &cn, TRUE1)) | |||||
| 545 | XkbSendControlsNotify(pXDev, &cn); | |||||
| 546 | } | |||||
| 547 | return; | |||||
| 548 | } | |||||
| 549 | ||||||
| 550 | /* Applies a change to a single device, does not traverse the device tree. */ | |||||
| 551 | void | |||||
| 552 | XkbApplyMappingChange(DeviceIntPtr kbd, KeySymsPtr map, KeyCode first_key, | |||||
| 553 | CARD8 num_keys, CARD8 *modmap, ClientPtr client) | |||||
| 554 | { | |||||
| 555 | XkbDescPtr xkb = kbd->key->xkbInfo->desc; | |||||
| 556 | XkbEventCauseRec cause; | |||||
| 557 | XkbChangesRec changes; | |||||
| 558 | unsigned int check; | |||||
| 559 | ||||||
| 560 | memset(&changes, 0, sizeof(changes))__builtin___memset_chk (&changes, 0, sizeof(changes), __builtin_object_size (&changes, 0)); | |||||
| 561 | memset(&cause, 0, sizeof(cause))__builtin___memset_chk (&cause, 0, sizeof(cause), __builtin_object_size (&cause, 0)); | |||||
| 562 | ||||||
| 563 | if (map && first_key && num_keys) { | |||||
| 564 | check = 0; | |||||
| 565 | XkbSetCauseCoreReq(&cause, X_ChangeKeyboardMapping, client){ (&cause)->kc= (&cause)->event= 0, (&cause )->mjr= (100),(&cause)->mnr= (0); (&cause)-> client= (client); }; | |||||
| 566 | ||||||
| 567 | XkbUpdateKeyTypesFromCore(kbd, map, first_key, num_keys, &changes); | |||||
| 568 | XkbUpdateActions(kbd, first_key, num_keys, &changes, &check, &cause); | |||||
| 569 | ||||||
| 570 | if (check) | |||||
| 571 | XkbCheckSecondaryEffects(kbd->key->xkbInfo, 1, &changes, &cause); | |||||
| 572 | } | |||||
| 573 | ||||||
| 574 | if (modmap) { | |||||
| 575 | /* A keymap change can imply a modmap change, se we prefer the | |||||
| 576 | * former. */ | |||||
| 577 | if (!cause.mjr) | |||||
| 578 | XkbSetCauseCoreReq(&cause, X_SetModifierMapping, client){ (&cause)->kc= (&cause)->event= 0, (&cause )->mjr= (118),(&cause)->mnr= (0); (&cause)-> client= (client); }; | |||||
| 579 | ||||||
| 580 | check = 0; | |||||
| 581 | num_keys = xkb->max_key_code - xkb->min_key_code + 1; | |||||
| 582 | changes.map.changed |= XkbModifierMapMask(1<<2); | |||||
| 583 | changes.map.first_modmap_key = xkb->min_key_code; | |||||
| 584 | changes.map.num_modmap_keys = num_keys; | |||||
| 585 | memcpy(kbd->key->xkbInfo->desc->map->modmap, modmap, MAP_LENGTH)__builtin___memcpy_chk (kbd->key->xkbInfo->desc-> map->modmap, modmap, 256, __builtin_object_size (kbd->key ->xkbInfo->desc->map->modmap, 0)); | |||||
| 586 | XkbUpdateActions(kbd, xkb->min_key_code, num_keys, &changes, &check, | |||||
| 587 | &cause); | |||||
| 588 | ||||||
| 589 | if (check) | |||||
| 590 | XkbCheckSecondaryEffects(kbd->key->xkbInfo, 1, &changes, &cause); | |||||
| 591 | } | |||||
| 592 | ||||||
| 593 | XkbSendNotification(kbd, &changes, &cause); | |||||
| 594 | } | |||||
| 595 | ||||||
| 596 | void | |||||
| 597 | XkbDisableComputedAutoRepeats(DeviceIntPtr dev, unsigned key) | |||||
| 598 | { | |||||
| 599 | XkbSrvInfoPtr xkbi = dev->key->xkbInfo; | |||||
| 600 | xkbMapNotify mn; | |||||
| 601 | ||||||
| 602 | xkbi->desc->server->explicit[key] |= XkbExplicitAutoRepeatMask(1<<5); | |||||
| 603 | memset(&mn, 0, sizeof(mn))__builtin___memset_chk (&mn, 0, sizeof(mn), __builtin_object_size (&mn, 0)); | |||||
| 604 | mn.changed = XkbExplicitComponentsMask(1<<3); | |||||
| 605 | mn.firstKeyExplicit = key; | |||||
| 606 | mn.nKeyExplicit = 1; | |||||
| 607 | XkbSendMapNotify(dev, &mn); | |||||
| 608 | return; | |||||
| 609 | } | |||||
| 610 | ||||||
| 611 | unsigned | |||||
| 612 | XkbStateChangedFlags(XkbStatePtr old, XkbStatePtr new) | |||||
| 613 | { | |||||
| 614 | int changed; | |||||
| 615 | ||||||
| 616 | changed = (old->group != new->group ? XkbGroupStateMask(1L << 4) : 0); | |||||
| 617 | changed |= (old->base_group != new->base_group ? XkbGroupBaseMask(1L << 5) : 0); | |||||
| 618 | changed |= | |||||
| 619 | (old->latched_group != new->latched_group ? XkbGroupLatchMask(1L << 6) : 0); | |||||
| 620 | changed |= (old->locked_group != new->locked_group ? XkbGroupLockMask(1L << 7) : 0); | |||||
| 621 | changed |= (old->mods != new->mods ? XkbModifierStateMask(1L << 0) : 0); | |||||
| 622 | changed |= (old->base_mods != new->base_mods ? XkbModifierBaseMask(1L << 1) : 0); | |||||
| 623 | changed |= | |||||
| 624 | (old->latched_mods != new->latched_mods ? XkbModifierLatchMask(1L << 2) : 0); | |||||
| 625 | changed |= (old->locked_mods != new->locked_mods ? XkbModifierLockMask(1L << 3) : 0); | |||||
| 626 | changed |= | |||||
| 627 | (old->compat_state != new->compat_state ? XkbCompatStateMask(1L << 8) : 0); | |||||
| 628 | changed |= (old->grab_mods != new->grab_mods ? XkbGrabModsMask(1L << 9) : 0); | |||||
| 629 | if (old->compat_grab_mods != new->compat_grab_mods) | |||||
| 630 | changed |= XkbCompatGrabModsMask(1L << 10); | |||||
| 631 | changed |= (old->lookup_mods != new->lookup_mods ? XkbLookupModsMask(1L << 11) : 0); | |||||
| 632 | if (old->compat_lookup_mods != new->compat_lookup_mods) | |||||
| 633 | changed |= XkbCompatLookupModsMask(1L << 12); | |||||
| 634 | changed |= | |||||
| 635 | (old->ptr_buttons != new->ptr_buttons ? XkbPointerButtonMask(1L << 13) : 0); | |||||
| 636 | return changed; | |||||
| 637 | } | |||||
| 638 | ||||||
| 639 | static void | |||||
| 640 | XkbComputeCompatState(XkbSrvInfoPtr xkbi) | |||||
| 641 | { | |||||
| 642 | CARD16 grp_mask; | |||||
| 643 | XkbStatePtr state = &xkbi->state; | |||||
| 644 | XkbCompatMapPtr map; | |||||
| 645 | XkbControlsPtr ctrls; | |||||
| 646 | ||||||
| 647 | if (!state || !xkbi->desc || !xkbi->desc->ctrls || !xkbi->desc->compat) | |||||
| 648 | return; | |||||
| 649 | ||||||
| 650 | map = xkbi->desc->compat; | |||||
| 651 | grp_mask = map->groups[state->group].mask; | |||||
| 652 | state->compat_state = state->mods | grp_mask; | |||||
| 653 | state->compat_lookup_mods = state->lookup_mods | grp_mask; | |||||
| 654 | ctrls= xkbi->desc->ctrls; | |||||
| 655 | ||||||
| 656 | if (ctrls->enabled_ctrls & XkbIgnoreGroupLockMask(1L << 12)) { | |||||
| 657 | unsigned char grp = state->base_group+state->latched_group; | |||||
| 658 | if (grp >= ctrls->num_groups) | |||||
| 659 | grp = XkbAdjustGroup(XkbCharToInt(grp)((int) ((grp) & 0x80 ? ((grp) | (~0xff)) : ((grp) & 0x7f ))), ctrls); | |||||
| 660 | grp_mask = map->groups[grp].mask; | |||||
| 661 | } | |||||
| 662 | state->compat_grab_mods = state->grab_mods | grp_mask; | |||||
| 663 | return; | |||||
| 664 | } | |||||
| 665 | ||||||
| 666 | unsigned | |||||
| 667 | XkbAdjustGroup(int group, XkbControlsPtr ctrls) | |||||
| 668 | { | |||||
| 669 | unsigned act; | |||||
| 670 | ||||||
| 671 | act = XkbOutOfRangeGroupAction(ctrls->groups_wrap)((ctrls->groups_wrap)&0xc0); | |||||
| 672 | if (group < 0) { | |||||
| 673 | while (group < 0) { | |||||
| 674 | if (act == XkbClampIntoRange(0x40)) { | |||||
| 675 | group = XkbGroup1Index0; | |||||
| 676 | } | |||||
| 677 | else if (act == XkbRedirectIntoRange(0x80)) { | |||||
| 678 | int newGroup; | |||||
| 679 | ||||||
| 680 | newGroup = XkbOutOfRangeGroupNumber(ctrls->groups_wrap)(((ctrls->groups_wrap)&0x30)>>4); | |||||
| 681 | if (newGroup >= ctrls->num_groups) | |||||
| 682 | group = XkbGroup1Index0; | |||||
| 683 | else | |||||
| 684 | group = newGroup; | |||||
| 685 | } | |||||
| 686 | else { | |||||
| 687 | group += ctrls->num_groups; | |||||
| 688 | } | |||||
| 689 | } | |||||
| 690 | } | |||||
| 691 | else if (group >= ctrls->num_groups) { | |||||
| 692 | if (act == XkbClampIntoRange(0x40)) { | |||||
| 693 | group = ctrls->num_groups - 1; | |||||
| 694 | } | |||||
| 695 | else if (act == XkbRedirectIntoRange(0x80)) { | |||||
| 696 | int newGroup; | |||||
| 697 | ||||||
| 698 | newGroup = XkbOutOfRangeGroupNumber(ctrls->groups_wrap)(((ctrls->groups_wrap)&0x30)>>4); | |||||
| 699 | if (newGroup >= ctrls->num_groups) | |||||
| 700 | group = XkbGroup1Index0; | |||||
| 701 | else | |||||
| 702 | group = newGroup; | |||||
| 703 | } | |||||
| 704 | else { | |||||
| 705 | group %= ctrls->num_groups; | |||||
| 706 | } | |||||
| 707 | } | |||||
| 708 | return group; | |||||
| 709 | } | |||||
| 710 | ||||||
| 711 | void | |||||
| 712 | XkbComputeDerivedState(XkbSrvInfoPtr xkbi) | |||||
| 713 | { | |||||
| 714 | XkbStatePtr state = &xkbi->state; | |||||
| 715 | XkbControlsPtr ctrls = xkbi->desc->ctrls; | |||||
| 716 | unsigned char grp; | |||||
| 717 | ||||||
| 718 | if (!state || !ctrls) | |||||
| 719 | return; | |||||
| 720 | ||||||
| 721 | state->mods = (state->base_mods | state->latched_mods | state->locked_mods); | |||||
| 722 | state->lookup_mods = state->mods & (~ctrls->internal.mask); | |||||
| 723 | state->grab_mods = state->lookup_mods & (~ctrls->ignore_lock.mask); | |||||
| 724 | state->grab_mods |= | |||||
| 725 | ((state->base_mods | state->latched_mods) & ctrls->ignore_lock.mask); | |||||
| 726 | ||||||
| 727 | grp = state->locked_group; | |||||
| 728 | if (grp >= ctrls->num_groups) | |||||
| 729 | state->locked_group = XkbAdjustGroup(XkbCharToInt(grp)((int) ((grp) & 0x80 ? ((grp) | (~0xff)) : ((grp) & 0x7f ))), ctrls); | |||||
| 730 | ||||||
| 731 | grp = state->locked_group + state->base_group + state->latched_group; | |||||
| 732 | if (grp >= ctrls->num_groups) | |||||
| 733 | state->group = XkbAdjustGroup(XkbCharToInt(grp)((int) ((grp) & 0x80 ? ((grp) | (~0xff)) : ((grp) & 0x7f ))), ctrls); | |||||
| 734 | else | |||||
| 735 | state->group = grp; | |||||
| 736 | XkbComputeCompatState(xkbi); | |||||
| 737 | return; | |||||
| 738 | } | |||||
| 739 | ||||||
| 740 | /***====================================================================***/ | |||||
| 741 | ||||||
| 742 | void | |||||
| 743 | XkbCheckSecondaryEffects(XkbSrvInfoPtr xkbi, | |||||
| 744 | unsigned which, | |||||
| 745 | XkbChangesPtr changes, XkbEventCausePtr cause) | |||||
| 746 | { | |||||
| 747 | if (which & XkbStateNotifyMask(1L << 2)) { | |||||
| 748 | XkbStateRec old; | |||||
| 749 | ||||||
| 750 | old = xkbi->state; | |||||
| 751 | changes->state_changes |= XkbStateChangedFlags(&old, &xkbi->state); | |||||
| 752 | XkbComputeDerivedState(xkbi); | |||||
| 753 | } | |||||
| 754 | if (which & XkbIndicatorStateNotifyMask(1L << 4)) | |||||
| 755 | XkbUpdateIndicators(xkbi->device, XkbAllIndicatorsMask(0xffffffff), TRUE1, changes, | |||||
| 756 | cause); | |||||
| 757 | return; | |||||
| 758 | } | |||||
| 759 | ||||||
| 760 | /***====================================================================***/ | |||||
| 761 | ||||||
| 762 | Bool | |||||
| 763 | XkbEnableDisableControls(XkbSrvInfoPtr xkbi, | |||||
| 764 | unsigned long change, | |||||
| 765 | unsigned long newValues, | |||||
| 766 | XkbChangesPtr changes, XkbEventCausePtr cause) | |||||
| 767 | { | |||||
| 768 | XkbControlsPtr ctrls; | |||||
| 769 | unsigned old; | |||||
| 770 | XkbSrvLedInfoPtr sli; | |||||
| 771 | ||||||
| 772 | ctrls = xkbi->desc->ctrls; | |||||
| 773 | old = ctrls->enabled_ctrls; | |||||
| 774 | ctrls->enabled_ctrls &= ~change; | |||||
| 775 | ctrls->enabled_ctrls |= (change & newValues); | |||||
| 776 | if (old == ctrls->enabled_ctrls) | |||||
| 777 | return FALSE0; | |||||
| 778 | if (cause != NULL((void*)0)) { | |||||
| 779 | xkbControlsNotify cn; | |||||
| 780 | ||||||
| 781 | cn.numGroups = ctrls->num_groups; | |||||
| 782 | cn.changedControls = XkbControlsEnabledMask(1L << 31); | |||||
| 783 | cn.enabledControls = ctrls->enabled_ctrls; | |||||
| 784 | cn.enabledControlChanges = (ctrls->enabled_ctrls ^ old); | |||||
| 785 | cn.keycode = cause->kc; | |||||
| 786 | cn.eventType = cause->event; | |||||
| 787 | cn.requestMajor = cause->mjr; | |||||
| 788 | cn.requestMinor = cause->mnr; | |||||
| 789 | XkbSendControlsNotify(xkbi->device, &cn); | |||||
| 790 | } | |||||
| 791 | else { | |||||
| 792 | /* Yes, this really should be an XOR. If ctrls->enabled_ctrls_changes */ | |||||
| 793 | /* is non-zero, the controls in question changed already in "this" */ | |||||
| 794 | /* request and this change merely undoes the previous one. By the */ | |||||
| 795 | /* same token, we have to figure out whether or not ControlsEnabled */ | |||||
| 796 | /* should be set or not in the changes structure */ | |||||
| 797 | changes->ctrls.enabled_ctrls_changes ^= (ctrls->enabled_ctrls ^ old); | |||||
| 798 | if (changes->ctrls.enabled_ctrls_changes) | |||||
| 799 | changes->ctrls.changed_ctrls |= XkbControlsEnabledMask(1L << 31); | |||||
| 800 | else | |||||
| 801 | changes->ctrls.changed_ctrls &= ~XkbControlsEnabledMask(1L << 31); | |||||
| 802 | } | |||||
| 803 | sli = XkbFindSrvLedInfo(xkbi->device, XkbDfltXIClass0x0300, XkbDfltXIId0x0400, 0); | |||||
| 804 | XkbUpdateIndicators(xkbi->device, sli->usesControls, TRUE1, changes, cause); | |||||
| 805 | return TRUE1; | |||||
| 806 | } | |||||
| 807 | ||||||
| 808 | /***====================================================================***/ | |||||
| 809 | ||||||
| 810 | #define MAX_TOC16 16 | |||||
| 811 | ||||||
| 812 | XkbGeometryPtr | |||||
| 813 | XkbLookupNamedGeometry(DeviceIntPtr dev, Atom name, Bool *shouldFree) | |||||
| 814 | { | |||||
| 815 | XkbSrvInfoPtr xkbi = dev->key->xkbInfo; | |||||
| 816 | XkbDescPtr xkb = xkbi->desc; | |||||
| 817 | ||||||
| 818 | *shouldFree = 0; | |||||
| 819 | if (name == None0L) { | |||||
| 820 | if (xkb->geom != NULL((void*)0)) | |||||
| 821 | return xkb->geom; | |||||
| 822 | name = xkb->names->geometry; | |||||
| 823 | } | |||||
| 824 | if ((xkb->geom != NULL((void*)0)) && (xkb->geom->name == name)) | |||||
| 825 | return xkb->geom; | |||||
| 826 | *shouldFree = 1; | |||||
| 827 | return NULL((void*)0); | |||||
| 828 | } | |||||
| 829 | ||||||
| 830 | void | |||||
| 831 | XkbConvertCase(register KeySym sym, KeySym * lower, KeySym * upper) | |||||
| 832 | { | |||||
| 833 | *lower = sym; | |||||
| 834 | *upper = sym; | |||||
| 835 | switch (sym >> 8) { | |||||
| 836 | case 0: /* Latin 1 */ | |||||
| 837 | if ((sym >= XK_A0x0041) && (sym <= XK_Z0x005a)) | |||||
| 838 | *lower += (XK_a0x0061 - XK_A0x0041); | |||||
| 839 | else if ((sym >= XK_a0x0061) && (sym <= XK_z0x007a)) | |||||
| 840 | *upper -= (XK_a0x0061 - XK_A0x0041); | |||||
| 841 | else if ((sym >= XK_Agrave0x00c0) && (sym <= XK_Odiaeresis0x00d6)) | |||||
| 842 | *lower += (XK_agrave0x00e0 - XK_Agrave0x00c0); | |||||
| 843 | else if ((sym >= XK_agrave0x00e0) && (sym <= XK_odiaeresis0x00f6)) | |||||
| 844 | *upper -= (XK_agrave0x00e0 - XK_Agrave0x00c0); | |||||
| 845 | else if ((sym >= XK_Ooblique0x00d8) && (sym <= XK_Thorn0x00de)) | |||||
| 846 | *lower += (XK_oslash0x00f8 - XK_Ooblique0x00d8); | |||||
| 847 | else if ((sym >= XK_oslash0x00f8) && (sym <= XK_thorn0x00fe)) | |||||
| 848 | *upper -= (XK_oslash0x00f8 - XK_Ooblique0x00d8); | |||||
| 849 | break; | |||||
| 850 | case 1: /* Latin 2 */ | |||||
| 851 | /* Assume the KeySym is a legal value (ignore discontinuities) */ | |||||
| 852 | if (sym == XK_Aogonek0x01a1) | |||||
| 853 | *lower = XK_aogonek0x01b1; | |||||
| 854 | else if (sym >= XK_Lstroke0x01a3 && sym <= XK_Sacute0x01a6) | |||||
| 855 | *lower += (XK_lstroke0x01b3 - XK_Lstroke0x01a3); | |||||
| 856 | else if (sym >= XK_Scaron0x01a9 && sym <= XK_Zacute0x01ac) | |||||
| 857 | *lower += (XK_scaron0x01b9 - XK_Scaron0x01a9); | |||||
| 858 | else if (sym >= XK_Zcaron0x01ae && sym <= XK_Zabovedot0x01af) | |||||
| 859 | *lower += (XK_zcaron0x01be - XK_Zcaron0x01ae); | |||||
| 860 | else if (sym == XK_aogonek0x01b1) | |||||
| 861 | *upper = XK_Aogonek0x01a1; | |||||
| 862 | else if (sym >= XK_lstroke0x01b3 && sym <= XK_sacute0x01b6) | |||||
| 863 | *upper -= (XK_lstroke0x01b3 - XK_Lstroke0x01a3); | |||||
| 864 | else if (sym >= XK_scaron0x01b9 && sym <= XK_zacute0x01bc) | |||||
| 865 | *upper -= (XK_scaron0x01b9 - XK_Scaron0x01a9); | |||||
| 866 | else if (sym >= XK_zcaron0x01be && sym <= XK_zabovedot0x01bf) | |||||
| 867 | *upper -= (XK_zcaron0x01be - XK_Zcaron0x01ae); | |||||
| 868 | else if (sym >= XK_Racute0x01c0 && sym <= XK_Tcedilla0x01de) | |||||
| 869 | *lower += (XK_racute0x01e0 - XK_Racute0x01c0); | |||||
| 870 | else if (sym >= XK_racute0x01e0 && sym <= XK_tcedilla0x01fe) | |||||
| 871 | *upper -= (XK_racute0x01e0 - XK_Racute0x01c0); | |||||
| 872 | break; | |||||
| 873 | case 2: /* Latin 3 */ | |||||
| 874 | /* Assume the KeySym is a legal value (ignore discontinuities) */ | |||||
| 875 | if (sym >= XK_Hstroke0x02a1 && sym <= XK_Hcircumflex0x02a6) | |||||
| 876 | *lower += (XK_hstroke0x02b1 - XK_Hstroke0x02a1); | |||||
| 877 | else if (sym >= XK_Gbreve0x02ab && sym <= XK_Jcircumflex0x02ac) | |||||
| 878 | *lower += (XK_gbreve0x02bb - XK_Gbreve0x02ab); | |||||
| 879 | else if (sym >= XK_hstroke0x02b1 && sym <= XK_hcircumflex0x02b6) | |||||
| 880 | *upper -= (XK_hstroke0x02b1 - XK_Hstroke0x02a1); | |||||
| 881 | else if (sym >= XK_gbreve0x02bb && sym <= XK_jcircumflex0x02bc) | |||||
| 882 | *upper -= (XK_gbreve0x02bb - XK_Gbreve0x02ab); | |||||
| 883 | else if (sym >= XK_Cabovedot0x02c5 && sym <= XK_Scircumflex0x02de) | |||||
| 884 | *lower += (XK_cabovedot0x02e5 - XK_Cabovedot0x02c5); | |||||
| 885 | else if (sym >= XK_cabovedot0x02e5 && sym <= XK_scircumflex0x02fe) | |||||
| 886 | *upper -= (XK_cabovedot0x02e5 - XK_Cabovedot0x02c5); | |||||
| 887 | break; | |||||
| 888 | case 3: /* Latin 4 */ | |||||
| 889 | /* Assume the KeySym is a legal value (ignore discontinuities) */ | |||||
| 890 | if (sym >= XK_Rcedilla0x03a3 && sym <= XK_Tslash0x03ac) | |||||
| 891 | *lower += (XK_rcedilla0x03b3 - XK_Rcedilla0x03a3); | |||||
| 892 | else if (sym >= XK_rcedilla0x03b3 && sym <= XK_tslash0x03bc) | |||||
| 893 | *upper -= (XK_rcedilla0x03b3 - XK_Rcedilla0x03a3); | |||||
| 894 | else if (sym == XK_ENG0x03bd) | |||||
| 895 | *lower = XK_eng0x03bf; | |||||
| 896 | else if (sym == XK_eng0x03bf) | |||||
| 897 | *upper = XK_ENG0x03bd; | |||||
| 898 | else if (sym >= XK_Amacron0x03c0 && sym <= XK_Umacron0x03de) | |||||
| 899 | *lower += (XK_amacron0x03e0 - XK_Amacron0x03c0); | |||||
| 900 | else if (sym >= XK_amacron0x03e0 && sym <= XK_umacron0x03fe) | |||||
| 901 | *upper -= (XK_amacron0x03e0 - XK_Amacron0x03c0); | |||||
| 902 | break; | |||||
| 903 | case 6: /* Cyrillic */ | |||||
| 904 | /* Assume the KeySym is a legal value (ignore discontinuities) */ | |||||
| 905 | if (sym >= XK_Serbian_DJE0x06b1 && sym <= XK_Serbian_DZE0x06bf) | |||||
| 906 | *lower -= (XK_Serbian_DJE0x06b1 - XK_Serbian_dje0x06a1); | |||||
| 907 | else if (sym >= XK_Serbian_dje0x06a1 && sym <= XK_Serbian_dze0x06af) | |||||
| 908 | *upper += (XK_Serbian_DJE0x06b1 - XK_Serbian_dje0x06a1); | |||||
| 909 | else if (sym >= XK_Cyrillic_YU0x06e0 && sym <= XK_Cyrillic_HARDSIGN0x06ff) | |||||
| 910 | *lower -= (XK_Cyrillic_YU0x06e0 - XK_Cyrillic_yu0x06c0); | |||||
| 911 | else if (sym >= XK_Cyrillic_yu0x06c0 && sym <= XK_Cyrillic_hardsign0x06df) | |||||
| 912 | *upper += (XK_Cyrillic_YU0x06e0 - XK_Cyrillic_yu0x06c0); | |||||
| 913 | break; | |||||
| 914 | case 7: /* Greek */ | |||||
| 915 | /* Assume the KeySym is a legal value (ignore discontinuities) */ | |||||
| 916 | if (sym >= XK_Greek_ALPHAaccent0x07a1 && sym <= XK_Greek_OMEGAaccent0x07ab) | |||||
| 917 | *lower += (XK_Greek_alphaaccent0x07b1 - XK_Greek_ALPHAaccent0x07a1); | |||||
| 918 | else if (sym >= XK_Greek_alphaaccent0x07b1 && sym <= XK_Greek_omegaaccent0x07bb && | |||||
| 919 | sym != XK_Greek_iotaaccentdieresis0x07b6 && | |||||
| 920 | sym != XK_Greek_upsilonaccentdieresis0x07ba) | |||||
| 921 | *upper -= (XK_Greek_alphaaccent0x07b1 - XK_Greek_ALPHAaccent0x07a1); | |||||
| 922 | else if (sym >= XK_Greek_ALPHA0x07c1 && sym <= XK_Greek_OMEGA0x07d9) | |||||
| 923 | *lower += (XK_Greek_alpha0x07e1 - XK_Greek_ALPHA0x07c1); | |||||
| 924 | else if (sym >= XK_Greek_alpha0x07e1 && sym <= XK_Greek_omega0x07f9 && | |||||
| 925 | sym != XK_Greek_finalsmallsigma0x07f3) | |||||
| 926 | *upper -= (XK_Greek_alpha0x07e1 - XK_Greek_ALPHA0x07c1); | |||||
| 927 | break; | |||||
| 928 | } | |||||
| 929 | } | |||||
| 930 | ||||||
| 931 | static Bool | |||||
| 932 | _XkbCopyClientMap(XkbDescPtr src, XkbDescPtr dst) | |||||
| 933 | { | |||||
| 934 | void *tmp = NULL((void*)0); | |||||
| 935 | int i; | |||||
| 936 | XkbKeyTypePtr stype = NULL((void*)0), dtype = NULL((void*)0); | |||||
| 937 | ||||||
| 938 | /* client map */ | |||||
| 939 | if (src->map) { | |||||
| 940 | if (!dst->map) { | |||||
| 941 | tmp = calloc(1, sizeof(XkbClientMapRec)); | |||||
| 942 | if (!tmp) | |||||
| 943 | return FALSE0; | |||||
| 944 | dst->map = tmp; | |||||
| 945 | } | |||||
| 946 | ||||||
| 947 | if (src->map->syms) { | |||||
| 948 | if (src->map->size_syms != dst->map->size_syms) { | |||||
| 949 | tmp = realloc(dst->map->syms, | |||||
| 950 | src->map->size_syms * sizeof(KeySym)); | |||||
| 951 | if (!tmp) | |||||
| 952 | return FALSE0; | |||||
| 953 | dst->map->syms = tmp; | |||||
| 954 | ||||||
| 955 | } | |||||
| 956 | memcpy(dst->map->syms, src->map->syms,__builtin___memcpy_chk (dst->map->syms, src->map-> syms, src->map->size_syms * sizeof(KeySym), __builtin_object_size (dst->map->syms, 0)) | |||||
| 957 | src->map->size_syms * sizeof(KeySym))__builtin___memcpy_chk (dst->map->syms, src->map-> syms, src->map->size_syms * sizeof(KeySym), __builtin_object_size (dst->map->syms, 0)); | |||||
| 958 | } | |||||
| 959 | else { | |||||
| 960 | free(dst->map->syms); | |||||
| 961 | dst->map->syms = NULL((void*)0); | |||||
| 962 | } | |||||
| 963 | dst->map->num_syms = src->map->num_syms; | |||||
| 964 | dst->map->size_syms = src->map->size_syms; | |||||
| 965 | ||||||
| 966 | if (src->map->key_sym_map) { | |||||
| 967 | if (src->max_key_code != dst->max_key_code) { | |||||
| 968 | tmp = realloc(dst->map->key_sym_map, | |||||
| 969 | (src->max_key_code + 1) * sizeof(XkbSymMapRec)); | |||||
| 970 | if (!tmp) | |||||
| 971 | return FALSE0; | |||||
| 972 | dst->map->key_sym_map = tmp; | |||||
| 973 | } | |||||
| 974 | memcpy(dst->map->key_sym_map, src->map->key_sym_map,__builtin___memcpy_chk (dst->map->key_sym_map, src-> map->key_sym_map, (src->max_key_code + 1) * sizeof(XkbSymMapRec ), __builtin_object_size (dst->map->key_sym_map, 0)) | |||||
| 975 | (src->max_key_code + 1) * sizeof(XkbSymMapRec))__builtin___memcpy_chk (dst->map->key_sym_map, src-> map->key_sym_map, (src->max_key_code + 1) * sizeof(XkbSymMapRec ), __builtin_object_size (dst->map->key_sym_map, 0)); | |||||
| 976 | } | |||||
| 977 | else { | |||||
| 978 | free(dst->map->key_sym_map); | |||||
| 979 | dst->map->key_sym_map = NULL((void*)0); | |||||
| 980 | } | |||||
| 981 | ||||||
| 982 | if (src->map->types && src->map->num_types) { | |||||
| 983 | if (src->map->num_types > dst->map->size_types || | |||||
| 984 | !dst->map->types || !dst->map->size_types) { | |||||
| 985 | if (dst->map->types && dst->map->size_types) { | |||||
| 986 | tmp = realloc(dst->map->types, | |||||
| 987 | src->map->num_types * sizeof(XkbKeyTypeRec)); | |||||
| 988 | if (!tmp) | |||||
| 989 | return FALSE0; | |||||
| 990 | dst->map->types = tmp; | |||||
| 991 | memset(dst->map->types + dst->map->num_types, 0,__builtin___memset_chk (dst->map->types + dst->map-> num_types, 0, (src->map->num_types - dst->map->num_types ) * sizeof(XkbKeyTypeRec), __builtin_object_size (dst->map ->types + dst->map->num_types, 0)) | |||||
| 992 | (src->map->num_types - dst->map->num_types) *__builtin___memset_chk (dst->map->types + dst->map-> num_types, 0, (src->map->num_types - dst->map->num_types ) * sizeof(XkbKeyTypeRec), __builtin_object_size (dst->map ->types + dst->map->num_types, 0)) | |||||
| 993 | sizeof(XkbKeyTypeRec))__builtin___memset_chk (dst->map->types + dst->map-> num_types, 0, (src->map->num_types - dst->map->num_types ) * sizeof(XkbKeyTypeRec), __builtin_object_size (dst->map ->types + dst->map->num_types, 0)); | |||||
| 994 | } | |||||
| 995 | else { | |||||
| 996 | tmp = calloc(src->map->num_types, sizeof(XkbKeyTypeRec)); | |||||
| 997 | if (!tmp) | |||||
| 998 | return FALSE0; | |||||
| 999 | dst->map->types = tmp; | |||||
| 1000 | } | |||||
| 1001 | } | |||||
| 1002 | else if (src->map->num_types < dst->map->num_types && | |||||
| 1003 | dst->map->types) { | |||||
| 1004 | for (i = src->map->num_types, dtype = (dst->map->types + i); | |||||
| 1005 | i < dst->map->num_types; i++, dtype++) { | |||||
| 1006 | free(dtype->level_names); | |||||
| 1007 | dtype->level_names = NULL((void*)0); | |||||
| 1008 | dtype->num_levels = 0; | |||||
| 1009 | if (dtype->map_count) { | |||||
| 1010 | free(dtype->map); | |||||
| 1011 | free(dtype->preserve); | |||||
| 1012 | } | |||||
| 1013 | } | |||||
| 1014 | } | |||||
| 1015 | ||||||
| 1016 | stype = src->map->types; | |||||
| 1017 | dtype = dst->map->types; | |||||
| 1018 | for (i = 0; i < src->map->num_types; i++, dtype++, stype++) { | |||||
| 1019 | if (stype->num_levels && stype->level_names) { | |||||
| 1020 | if (stype->num_levels != dtype->num_levels && | |||||
| 1021 | dtype->num_levels && dtype->level_names && | |||||
| 1022 | i < dst->map->num_types) { | |||||
| 1023 | tmp = realloc(dtype->level_names, | |||||
| 1024 | stype->num_levels * sizeof(Atom)); | |||||
| 1025 | if (!tmp) | |||||
| 1026 | continue; | |||||
| 1027 | dtype->level_names = tmp; | |||||
| 1028 | } | |||||
| 1029 | else if (!dtype->num_levels || !dtype->level_names || | |||||
| 1030 | i >= dst->map->num_types) { | |||||
| 1031 | tmp = malloc(stype->num_levels * sizeof(Atom)); | |||||
| 1032 | if (!tmp) | |||||
| 1033 | continue; | |||||
| 1034 | dtype->level_names = tmp; | |||||
| 1035 | } | |||||
| 1036 | dtype->num_levels = stype->num_levels; | |||||
| 1037 | memcpy(dtype->level_names, stype->level_names,__builtin___memcpy_chk (dtype->level_names, stype->level_names , stype->num_levels * sizeof(Atom), __builtin_object_size ( dtype->level_names, 0)) | |||||
| 1038 | stype->num_levels * sizeof(Atom))__builtin___memcpy_chk (dtype->level_names, stype->level_names , stype->num_levels * sizeof(Atom), __builtin_object_size ( dtype->level_names, 0)); | |||||
| 1039 | } | |||||
| 1040 | else { | |||||
| 1041 | if (dtype->num_levels && dtype->level_names && | |||||
| 1042 | i < dst->map->num_types) | |||||
| 1043 | free(dtype->level_names); | |||||
| 1044 | dtype->num_levels = 0; | |||||
| 1045 | dtype->level_names = NULL((void*)0); | |||||
| 1046 | } | |||||
| 1047 | ||||||
| 1048 | dtype->name = stype->name; | |||||
| 1049 | memcpy(&dtype->mods, &stype->mods, sizeof(XkbModsRec))__builtin___memcpy_chk (&dtype->mods, &stype->mods , sizeof(XkbModsRec), __builtin_object_size (&dtype->mods , 0)); | |||||
| 1050 | ||||||
| 1051 | if (stype->map_count) { | |||||
| 1052 | if (stype->map) { | |||||
| 1053 | if (stype->map_count != dtype->map_count && | |||||
| 1054 | dtype->map_count && dtype->map && | |||||
| 1055 | i < dst->map->num_types) { | |||||
| 1056 | tmp = realloc(dtype->map, | |||||
| 1057 | stype->map_count * | |||||
| 1058 | sizeof(XkbKTMapEntryRec)); | |||||
| 1059 | if (!tmp) | |||||
| 1060 | return FALSE0; | |||||
| 1061 | dtype->map = tmp; | |||||
| 1062 | } | |||||
| 1063 | else if (!dtype->map_count || !dtype->map || | |||||
| 1064 | i >= dst->map->num_types) { | |||||
| 1065 | tmp = malloc(stype->map_count * | |||||
| 1066 | sizeof(XkbKTMapEntryRec)); | |||||
| 1067 | if (!tmp) | |||||
| 1068 | return FALSE0; | |||||
| 1069 | dtype->map = tmp; | |||||
| 1070 | } | |||||
| 1071 | ||||||
| 1072 | memcpy(dtype->map, stype->map,__builtin___memcpy_chk (dtype->map, stype->map, stype-> map_count * sizeof(XkbKTMapEntryRec), __builtin_object_size ( dtype->map, 0)) | |||||
| 1073 | stype->map_count * sizeof(XkbKTMapEntryRec))__builtin___memcpy_chk (dtype->map, stype->map, stype-> map_count * sizeof(XkbKTMapEntryRec), __builtin_object_size ( dtype->map, 0)); | |||||
| 1074 | } | |||||
| 1075 | else { | |||||
| 1076 | if (dtype->map && i < dst->map->num_types) | |||||
| 1077 | free(dtype->map); | |||||
| 1078 | dtype->map = NULL((void*)0); | |||||
| 1079 | } | |||||
| 1080 | ||||||
| 1081 | if (stype->preserve) { | |||||
| 1082 | if (stype->map_count != dtype->map_count && | |||||
| 1083 | dtype->map_count && dtype->preserve && | |||||
| 1084 | i < dst->map->num_types) { | |||||
| 1085 | tmp = realloc(dtype->preserve, | |||||
| 1086 | stype->map_count * | |||||
| 1087 | sizeof(XkbModsRec)); | |||||
| 1088 | if (!tmp) | |||||
| 1089 | return FALSE0; | |||||
| 1090 | dtype->preserve = tmp; | |||||
| 1091 | } | |||||
| 1092 | else if (!dtype->preserve || !dtype->map_count || | |||||
| 1093 | i >= dst->map->num_types) { | |||||
| 1094 | tmp = malloc(stype->map_count * sizeof(XkbModsRec)); | |||||
| 1095 | if (!tmp) | |||||
| 1096 | return FALSE0; | |||||
| 1097 | dtype->preserve = tmp; | |||||
| 1098 | } | |||||
| 1099 | ||||||
| 1100 | memcpy(dtype->preserve, stype->preserve,__builtin___memcpy_chk (dtype->preserve, stype->preserve , stype->map_count * sizeof(XkbModsRec), __builtin_object_size (dtype->preserve, 0)) | |||||
| 1101 | stype->map_count * sizeof(XkbModsRec))__builtin___memcpy_chk (dtype->preserve, stype->preserve , stype->map_count * sizeof(XkbModsRec), __builtin_object_size (dtype->preserve, 0)); | |||||
| 1102 | } | |||||
| 1103 | else { | |||||
| 1104 | if (dtype->preserve && i < dst->map->num_types) | |||||
| 1105 | free(dtype->preserve); | |||||
| 1106 | dtype->preserve = NULL((void*)0); | |||||
| 1107 | } | |||||
| 1108 | ||||||
| 1109 | dtype->map_count = stype->map_count; | |||||
| 1110 | } | |||||
| 1111 | else { | |||||
| 1112 | if (dtype->map_count && i < dst->map->num_types) { | |||||
| 1113 | free(dtype->map); | |||||
| 1114 | free(dtype->preserve); | |||||
| 1115 | } | |||||
| 1116 | dtype->map_count = 0; | |||||
| 1117 | dtype->map = NULL((void*)0); | |||||
| 1118 | dtype->preserve = NULL((void*)0); | |||||
| 1119 | } | |||||
| 1120 | } | |||||
| 1121 | ||||||
| 1122 | dst->map->size_types = src->map->num_types; | |||||
| 1123 | dst->map->num_types = src->map->num_types; | |||||
| 1124 | } | |||||
| 1125 | else { | |||||
| 1126 | if (dst->map->types) { | |||||
| 1127 | for (i = 0, dtype = dst->map->types; i < dst->map->num_types; | |||||
| 1128 | i++, dtype++) { | |||||
| 1129 | free(dtype->level_names); | |||||
| 1130 | if (dtype->map && dtype->map_count) | |||||
| 1131 | free(dtype->map); | |||||
| 1132 | if (dtype->preserve && dtype->map_count) | |||||
| 1133 | free(dtype->preserve); | |||||
| 1134 | } | |||||
| 1135 | } | |||||
| 1136 | free(dst->map->types); | |||||
| 1137 | dst->map->types = NULL((void*)0); | |||||
| 1138 | dst->map->num_types = 0; | |||||
| 1139 | dst->map->size_types = 0; | |||||
| 1140 | } | |||||
| 1141 | ||||||
| 1142 | if (src->map->modmap) { | |||||
| 1143 | if (src->max_key_code != dst->max_key_code) { | |||||
| 1144 | tmp = realloc(dst->map->modmap, src->max_key_code + 1); | |||||
| 1145 | if (!tmp) | |||||
| 1146 | return FALSE0; | |||||
| 1147 | dst->map->modmap = tmp; | |||||
| 1148 | } | |||||
| 1149 | memcpy(dst->map->modmap, src->map->modmap, src->max_key_code + 1)__builtin___memcpy_chk (dst->map->modmap, src->map-> modmap, src->max_key_code + 1, __builtin_object_size (dst-> map->modmap, 0)); | |||||
| 1150 | } | |||||
| 1151 | else { | |||||
| 1152 | free(dst->map->modmap); | |||||
| 1153 | dst->map->modmap = NULL((void*)0); | |||||
| 1154 | } | |||||
| 1155 | } | |||||
| 1156 | else { | |||||
| 1157 | if (dst->map) | |||||
| 1158 | XkbFreeClientMapSrvXkbFreeClientMap(dst, XkbAllClientInfoMask((1<<0)|(1<<1)|(1<<2)), TRUE1); | |||||
| 1159 | } | |||||
| 1160 | ||||||
| 1161 | return TRUE1; | |||||
| 1162 | } | |||||
| 1163 | ||||||
| 1164 | static Bool | |||||
| 1165 | _XkbCopyServerMap(XkbDescPtr src, XkbDescPtr dst) | |||||
| 1166 | { | |||||
| 1167 | void *tmp = NULL((void*)0); | |||||
| 1168 | ||||||
| 1169 | /* server map */ | |||||
| 1170 | if (src->server) { | |||||
| 1171 | if (!dst->server) { | |||||
| 1172 | tmp = calloc(1, sizeof(XkbServerMapRec)); | |||||
| 1173 | if (!tmp) | |||||
| 1174 | return FALSE0; | |||||
| 1175 | dst->server = tmp; | |||||
| 1176 | } | |||||
| 1177 | ||||||
| 1178 | if (src->server->explicit) { | |||||
| 1179 | if (src->max_key_code != dst->max_key_code) { | |||||
| 1180 | tmp = realloc(dst->server->explicit, src->max_key_code + 1); | |||||
| 1181 | if (!tmp) | |||||
| 1182 | return FALSE0; | |||||
| 1183 | dst->server->explicit = tmp; | |||||
| 1184 | } | |||||
| 1185 | memcpy(dst->server->explicit, src->server->explicit,__builtin___memcpy_chk (dst->server->explicit, src-> server->explicit, src->max_key_code + 1, __builtin_object_size (dst->server->explicit, 0)) | |||||
| 1186 | src->max_key_code + 1)__builtin___memcpy_chk (dst->server->explicit, src-> server->explicit, src->max_key_code + 1, __builtin_object_size (dst->server->explicit, 0)); | |||||
| 1187 | } | |||||
| 1188 | else { | |||||
| 1189 | free(dst->server->explicit); | |||||
| 1190 | dst->server->explicit = NULL((void*)0); | |||||
| 1191 | } | |||||
| 1192 | ||||||
| 1193 | if (src->server->acts) { | |||||
| 1194 | if (src->server->size_acts != dst->server->size_acts) { | |||||
| 1195 | tmp = realloc(dst->server->acts, | |||||
| 1196 | src->server->size_acts * sizeof(XkbAction)); | |||||
| 1197 | if (!tmp) | |||||
| 1198 | return FALSE0; | |||||
| 1199 | dst->server->acts = tmp; | |||||
| 1200 | } | |||||
| 1201 | memcpy(dst->server->acts, src->server->acts,__builtin___memcpy_chk (dst->server->acts, src->server ->acts, src->server->size_acts * sizeof(XkbAction), __builtin_object_size (dst->server->acts, 0)) | |||||
| 1202 | src->server->size_acts * sizeof(XkbAction))__builtin___memcpy_chk (dst->server->acts, src->server ->acts, src->server->size_acts * sizeof(XkbAction), __builtin_object_size (dst->server->acts, 0)); | |||||
| 1203 | } | |||||
| 1204 | else { | |||||
| 1205 | free(dst->server->acts); | |||||
| 1206 | dst->server->acts = NULL((void*)0); | |||||
| 1207 | } | |||||
| 1208 | dst->server->size_acts = src->server->size_acts; | |||||
| 1209 | dst->server->num_acts = src->server->num_acts; | |||||
| 1210 | ||||||
| 1211 | if (src->server->key_acts) { | |||||
| 1212 | if (src->max_key_code != dst->max_key_code) { | |||||
| 1213 | tmp = realloc(dst->server->key_acts, | |||||
| 1214 | (src->max_key_code + 1) * sizeof(unsigned short)); | |||||
| 1215 | if (!tmp) | |||||
| 1216 | return FALSE0; | |||||
| 1217 | dst->server->key_acts = tmp; | |||||
| 1218 | } | |||||
| 1219 | memcpy(dst->server->key_acts, src->server->key_acts,__builtin___memcpy_chk (dst->server->key_acts, src-> server->key_acts, (src->max_key_code + 1) * sizeof(unsigned short), __builtin_object_size (dst->server->key_acts, 0 )) | |||||
| 1220 | (src->max_key_code + 1) * sizeof(unsigned short))__builtin___memcpy_chk (dst->server->key_acts, src-> server->key_acts, (src->max_key_code + 1) * sizeof(unsigned short), __builtin_object_size (dst->server->key_acts, 0 )); | |||||
| 1221 | } | |||||
| 1222 | else { | |||||
| 1223 | free(dst->server->key_acts); | |||||
| 1224 | dst->server->key_acts = NULL((void*)0); | |||||
| 1225 | } | |||||
| 1226 | ||||||
| 1227 | if (src->server->behaviors) { | |||||
| 1228 | if (src->max_key_code != dst->max_key_code) { | |||||
| 1229 | tmp = realloc(dst->server->behaviors, | |||||
| 1230 | (src->max_key_code + 1) * sizeof(XkbBehavior)); | |||||
| 1231 | if (!tmp) | |||||
| 1232 | return FALSE0; | |||||
| 1233 | dst->server->behaviors = tmp; | |||||
| 1234 | } | |||||
| 1235 | memcpy(dst->server->behaviors, src->server->behaviors,__builtin___memcpy_chk (dst->server->behaviors, src-> server->behaviors, (src->max_key_code + 1) * sizeof(XkbBehavior ), __builtin_object_size (dst->server->behaviors, 0)) | |||||
| 1236 | (src->max_key_code + 1) * sizeof(XkbBehavior))__builtin___memcpy_chk (dst->server->behaviors, src-> server->behaviors, (src->max_key_code + 1) * sizeof(XkbBehavior ), __builtin_object_size (dst->server->behaviors, 0)); | |||||
| 1237 | } | |||||
| 1238 | else { | |||||
| 1239 | free(dst->server->behaviors); | |||||
| 1240 | dst->server->behaviors = NULL((void*)0); | |||||
| 1241 | } | |||||
| 1242 | ||||||
| 1243 | memcpy(dst->server->vmods, src->server->vmods, XkbNumVirtualMods)__builtin___memcpy_chk (dst->server->vmods, src->server ->vmods, 16, __builtin_object_size (dst->server->vmods , 0)); | |||||
| 1244 | ||||||
| 1245 | if (src->server->vmodmap) { | |||||
| 1246 | if (src->max_key_code != dst->max_key_code) { | |||||
| 1247 | tmp = realloc(dst->server->vmodmap, | |||||
| 1248 | (src->max_key_code + 1) * sizeof(unsigned short)); | |||||
| 1249 | if (!tmp) | |||||
| 1250 | return FALSE0; | |||||
| 1251 | dst->server->vmodmap = tmp; | |||||
| 1252 | } | |||||
| 1253 | memcpy(dst->server->vmodmap, src->server->vmodmap,__builtin___memcpy_chk (dst->server->vmodmap, src->server ->vmodmap, (src->max_key_code + 1) * sizeof(unsigned short ), __builtin_object_size (dst->server->vmodmap, 0)) | |||||
| 1254 | (src->max_key_code + 1) * sizeof(unsigned short))__builtin___memcpy_chk (dst->server->vmodmap, src->server ->vmodmap, (src->max_key_code + 1) * sizeof(unsigned short ), __builtin_object_size (dst->server->vmodmap, 0)); | |||||
| 1255 | } | |||||
| 1256 | else { | |||||
| 1257 | free(dst->server->vmodmap); | |||||
| 1258 | dst->server->vmodmap = NULL((void*)0); | |||||
| 1259 | } | |||||
| 1260 | } | |||||
| 1261 | else { | |||||
| 1262 | if (dst->server) | |||||
| 1263 | XkbFreeServerMapSrvXkbFreeServerMap(dst, XkbAllServerInfoMask((1<<3)|(1<<4)|(1<<5)|(1<<6)|(1<< 7)), TRUE1); | |||||
| 1264 | } | |||||
| 1265 | ||||||
| 1266 | return TRUE1; | |||||
| 1267 | } | |||||
| 1268 | ||||||
| 1269 | static Bool | |||||
| 1270 | _XkbCopyNames(XkbDescPtr src, XkbDescPtr dst) | |||||
| 1271 | { | |||||
| 1272 | void *tmp = NULL((void*)0); | |||||
| 1273 | ||||||
| 1274 | /* names */ | |||||
| 1275 | if (src->names) { | |||||
| 1276 | if (!dst->names) { | |||||
| 1277 | dst->names = calloc(1, sizeof(XkbNamesRec)); | |||||
| 1278 | if (!dst->names) | |||||
| 1279 | return FALSE0; | |||||
| 1280 | } | |||||
| 1281 | ||||||
| 1282 | if (src->names->keys) { | |||||
| 1283 | if (src->max_key_code != dst->max_key_code) { | |||||
| 1284 | tmp = realloc(dst->names->keys, | |||||
| 1285 | (src->max_key_code + 1) * sizeof(XkbKeyNameRec)); | |||||
| 1286 | if (!tmp) | |||||
| 1287 | return FALSE0; | |||||
| 1288 | dst->names->keys = tmp; | |||||
| 1289 | } | |||||
| 1290 | memcpy(dst->names->keys, src->names->keys,__builtin___memcpy_chk (dst->names->keys, src->names ->keys, (src->max_key_code + 1) * sizeof(XkbKeyNameRec) , __builtin_object_size (dst->names->keys, 0)) | |||||
| ||||||
| 1291 | (src->max_key_code + 1) * sizeof(XkbKeyNameRec))__builtin___memcpy_chk (dst->names->keys, src->names ->keys, (src->max_key_code + 1) * sizeof(XkbKeyNameRec) , __builtin_object_size (dst->names->keys, 0)); | |||||
| 1292 | } | |||||
| 1293 | else { | |||||
| 1294 | free(dst->names->keys); | |||||
| 1295 | dst->names->keys = NULL((void*)0); | |||||
| 1296 | } | |||||
| 1297 | ||||||
| 1298 | if (src->names->num_key_aliases) { | |||||
| 1299 | if (src->names->num_key_aliases != dst->names->num_key_aliases) { | |||||
| 1300 | tmp = realloc(dst->names->key_aliases, | |||||
| 1301 | src->names->num_key_aliases * | |||||
| 1302 | sizeof(XkbKeyAliasRec)); | |||||
| 1303 | if (!tmp) | |||||
| 1304 | return FALSE0; | |||||
| 1305 | dst->names->key_aliases = tmp; | |||||
| 1306 | } | |||||
| 1307 | memcpy(dst->names->key_aliases, src->names->key_aliases,__builtin___memcpy_chk (dst->names->key_aliases, src-> names->key_aliases, src->names->num_key_aliases * sizeof (XkbKeyAliasRec), __builtin_object_size (dst->names->key_aliases , 0)) | |||||
| 1308 | src->names->num_key_aliases * sizeof(XkbKeyAliasRec))__builtin___memcpy_chk (dst->names->key_aliases, src-> names->key_aliases, src->names->num_key_aliases * sizeof (XkbKeyAliasRec), __builtin_object_size (dst->names->key_aliases , 0)); | |||||
| 1309 | } | |||||
| 1310 | else { | |||||
| 1311 | free(dst->names->key_aliases); | |||||
| 1312 | dst->names->key_aliases = NULL((void*)0); | |||||
| 1313 | } | |||||
| 1314 | dst->names->num_key_aliases = src->names->num_key_aliases; | |||||
| 1315 | ||||||
| 1316 | if (src->names->num_rg) { | |||||
| 1317 | if (src->names->num_rg != dst->names->num_rg) { | |||||
| 1318 | tmp = realloc(dst->names->radio_groups, | |||||
| 1319 | src->names->num_rg * sizeof(Atom)); | |||||
| 1320 | if (!tmp) | |||||
| 1321 | return FALSE0; | |||||
| 1322 | dst->names->radio_groups = tmp; | |||||
| 1323 | } | |||||
| 1324 | memcpy(dst->names->radio_groups, src->names->radio_groups,__builtin___memcpy_chk (dst->names->radio_groups, src-> names->radio_groups, src->names->num_rg * sizeof(Atom ), __builtin_object_size (dst->names->radio_groups, 0)) | |||||
| 1325 | src->names->num_rg * sizeof(Atom))__builtin___memcpy_chk (dst->names->radio_groups, src-> names->radio_groups, src->names->num_rg * sizeof(Atom ), __builtin_object_size (dst->names->radio_groups, 0)); | |||||
| 1326 | } | |||||
| 1327 | else { | |||||
| 1328 | free(dst->names->radio_groups); | |||||
| 1329 | } | |||||
| 1330 | dst->names->num_rg = src->names->num_rg; | |||||
| 1331 | ||||||
| 1332 | dst->names->keycodes = src->names->keycodes; | |||||
| 1333 | dst->names->geometry = src->names->geometry; | |||||
| 1334 | dst->names->symbols = src->names->symbols; | |||||
| 1335 | dst->names->types = src->names->types; | |||||
| 1336 | dst->names->compat = src->names->compat; | |||||
| 1337 | dst->names->phys_symbols = src->names->phys_symbols; | |||||
| 1338 | ||||||
| 1339 | memcpy(dst->names->vmods, src->names->vmods,__builtin___memcpy_chk (dst->names->vmods, src->names ->vmods, 16 * sizeof(Atom), __builtin_object_size (dst-> names->vmods, 0)) | |||||
| 1340 | XkbNumVirtualMods * sizeof(Atom))__builtin___memcpy_chk (dst->names->vmods, src->names ->vmods, 16 * sizeof(Atom), __builtin_object_size (dst-> names->vmods, 0)); | |||||
| 1341 | memcpy(dst->names->indicators, src->names->indicators,__builtin___memcpy_chk (dst->names->indicators, src-> names->indicators, 32 * sizeof(Atom), __builtin_object_size (dst->names->indicators, 0)) | |||||
| 1342 | XkbNumIndicators * sizeof(Atom))__builtin___memcpy_chk (dst->names->indicators, src-> names->indicators, 32 * sizeof(Atom), __builtin_object_size (dst->names->indicators, 0)); | |||||
| 1343 | memcpy(dst->names->groups, src->names->groups,__builtin___memcpy_chk (dst->names->groups, src->names ->groups, 4 * sizeof(Atom), __builtin_object_size (dst-> names->groups, 0)) | |||||
| 1344 | XkbNumKbdGroups * sizeof(Atom))__builtin___memcpy_chk (dst->names->groups, src->names ->groups, 4 * sizeof(Atom), __builtin_object_size (dst-> names->groups, 0)); | |||||
| 1345 | } | |||||
| 1346 | else { | |||||
| 1347 | if (dst->names) | |||||
| 1348 | XkbFreeNamesSrvXkbFreeNames(dst, XkbAllNamesMask(0x3fff), TRUE1); | |||||
| 1349 | } | |||||
| 1350 | ||||||
| 1351 | return TRUE1; | |||||
| 1352 | } | |||||
| 1353 | ||||||
| 1354 | static Bool | |||||
| 1355 | _XkbCopyCompat(XkbDescPtr src, XkbDescPtr dst) | |||||
| 1356 | { | |||||
| 1357 | void *tmp = NULL((void*)0); | |||||
| 1358 | ||||||
| 1359 | /* compat */ | |||||
| 1360 | if (src->compat) { | |||||
| 1361 | if (!dst->compat) { | |||||
| 1362 | dst->compat = calloc(1, sizeof(XkbCompatMapRec)); | |||||
| 1363 | if (!dst->compat) | |||||
| 1364 | return FALSE0; | |||||
| 1365 | } | |||||
| 1366 | ||||||
| 1367 | if (src->compat->sym_interpret && src->compat->num_si) { | |||||
| 1368 | if (src->compat->num_si != dst->compat->size_si) { | |||||
| 1369 | tmp = realloc(dst->compat->sym_interpret, | |||||
| 1370 | src->compat->num_si * sizeof(XkbSymInterpretRec)); | |||||
| 1371 | if (!tmp) | |||||
| 1372 | return FALSE0; | |||||
| 1373 | dst->compat->sym_interpret = tmp; | |||||
| 1374 | } | |||||
| 1375 | memcpy(dst->compat->sym_interpret, src->compat->sym_interpret,__builtin___memcpy_chk (dst->compat->sym_interpret, src ->compat->sym_interpret, src->compat->num_si * sizeof (XkbSymInterpretRec), __builtin_object_size (dst->compat-> sym_interpret, 0)) | |||||
| 1376 | src->compat->num_si * sizeof(XkbSymInterpretRec))__builtin___memcpy_chk (dst->compat->sym_interpret, src ->compat->sym_interpret, src->compat->num_si * sizeof (XkbSymInterpretRec), __builtin_object_size (dst->compat-> sym_interpret, 0)); | |||||
| 1377 | ||||||
| 1378 | dst->compat->num_si = src->compat->num_si; | |||||
| 1379 | dst->compat->size_si = src->compat->num_si; | |||||
| 1380 | } | |||||
| 1381 | else { | |||||
| 1382 | if (dst->compat->sym_interpret && dst->compat->size_si) | |||||
| 1383 | free(dst->compat->sym_interpret); | |||||
| 1384 | ||||||
| 1385 | dst->compat->sym_interpret = NULL((void*)0); | |||||
| 1386 | dst->compat->num_si = 0; | |||||
| 1387 | dst->compat->size_si = 0; | |||||
| 1388 | } | |||||
| 1389 | ||||||
| 1390 | memcpy(dst->compat->groups, src->compat->groups,__builtin___memcpy_chk (dst->compat->groups, src->compat ->groups, 4 * sizeof(XkbModsRec), __builtin_object_size (dst ->compat->groups, 0)) | |||||
| 1391 | XkbNumKbdGroups * sizeof(XkbModsRec))__builtin___memcpy_chk (dst->compat->groups, src->compat ->groups, 4 * sizeof(XkbModsRec), __builtin_object_size (dst ->compat->groups, 0)); | |||||
| 1392 | } | |||||
| 1393 | else { | |||||
| 1394 | if (dst->compat) | |||||
| 1395 | XkbFreeCompatMapSrvXkbFreeCompatMap(dst, XkbAllCompatMask(0x3), TRUE1); | |||||
| 1396 | } | |||||
| 1397 | ||||||
| 1398 | return TRUE1; | |||||
| 1399 | } | |||||
| 1400 | ||||||
| 1401 | static Bool | |||||
| 1402 | _XkbCopyGeom(XkbDescPtr src, XkbDescPtr dst) | |||||
| 1403 | { | |||||
| 1404 | void *tmp = NULL((void*)0); | |||||
| 1405 | int i = 0, j = 0, k = 0; | |||||
| 1406 | XkbColorPtr scolor = NULL((void*)0), dcolor = NULL((void*)0); | |||||
| 1407 | XkbDoodadPtr sdoodad = NULL((void*)0), ddoodad = NULL((void*)0); | |||||
| 1408 | XkbOutlinePtr soutline = NULL((void*)0), doutline = NULL((void*)0); | |||||
| 1409 | XkbPropertyPtr sprop = NULL((void*)0), dprop = NULL((void*)0); | |||||
| 1410 | XkbRowPtr srow = NULL((void*)0), drow = NULL((void*)0); | |||||
| 1411 | XkbSectionPtr ssection = NULL((void*)0), dsection = NULL((void*)0); | |||||
| 1412 | XkbShapePtr sshape = NULL((void*)0), dshape = NULL((void*)0); | |||||
| 1413 | ||||||
| 1414 | /* geometry */ | |||||
| 1415 | if (src->geom) { | |||||
| 1416 | if (!dst->geom) { | |||||
| 1417 | dst->geom = calloc(sizeof(XkbGeometryRec), 1); | |||||
| 1418 | if (!dst->geom) | |||||
| 1419 | return FALSE0; | |||||
| 1420 | } | |||||
| 1421 | ||||||
| 1422 | /* properties */ | |||||
| 1423 | if (src->geom->num_properties) { | |||||
| 1424 | /* If we've got more properties in the destination than | |||||
| 1425 | * the source, run through and free all the excess ones | |||||
| 1426 | * first. */ | |||||
| 1427 | if (src->geom->num_properties < dst->geom->sz_properties) { | |||||
| 1428 | for (i = src->geom->num_properties, dprop = | |||||
| 1429 | dst->geom->properties + i; i < dst->geom->num_properties; | |||||
| 1430 | i++, dprop++) { | |||||
| 1431 | free(dprop->name); | |||||
| 1432 | free(dprop->value); | |||||
| 1433 | } | |||||
| 1434 | } | |||||
| 1435 | ||||||
| 1436 | /* Reallocate and clear all new items if the buffer grows. */ | |||||
| 1437 | if (!XkbGeomRealloc | |||||
| 1438 | ((void **) &dst->geom->properties, dst->geom->sz_properties, | |||||
| 1439 | src->geom->num_properties, sizeof(XkbPropertyRec), | |||||
| 1440 | XKB_GEOM_CLEAR_EXCESS)) | |||||
| 1441 | return FALSE0; | |||||
| 1442 | /* We don't set num_properties as we need it to try and avoid | |||||
| 1443 | * too much reallocing. */ | |||||
| 1444 | dst->geom->sz_properties = src->geom->num_properties; | |||||
| 1445 | ||||||
| 1446 | for (i = 0, | |||||
| 1447 | sprop = src->geom->properties, | |||||
| 1448 | dprop = dst->geom->properties; | |||||
| 1449 | i < src->geom->num_properties; i++, sprop++, dprop++) { | |||||
| 1450 | if (i < dst->geom->num_properties) { | |||||
| 1451 | if (strlen(sprop->name) != strlen(dprop->name)) { | |||||
| 1452 | tmp = realloc(dprop->name, strlen(sprop->name) + 1); | |||||
| 1453 | if (!tmp) | |||||
| 1454 | return FALSE0; | |||||
| 1455 | dprop->name = tmp; | |||||
| 1456 | } | |||||
| 1457 | if (strlen(sprop->value) != strlen(dprop->value)) { | |||||
| 1458 | tmp = realloc(dprop->value, strlen(sprop->value) + 1); | |||||
| 1459 | if (!tmp) | |||||
| 1460 | return FALSE0; | |||||
| 1461 | dprop->value = tmp; | |||||
| 1462 | } | |||||
| 1463 | strcpy(dprop->name, sprop->name)__builtin___strcpy_chk (dprop->name, sprop->name, __builtin_object_size (dprop->name, 2 > 1 ? 1 : 0)); | |||||
| 1464 | strcpy(dprop->value, sprop->value)__builtin___strcpy_chk (dprop->value, sprop->value, __builtin_object_size (dprop->value, 2 > 1 ? 1 : 0)); | |||||
| 1465 | } | |||||
| 1466 | else { | |||||
| 1467 | dprop->name = xstrdup(sprop->name)Xstrdup(sprop->name); | |||||
| 1468 | dprop->value = xstrdup(sprop->value)Xstrdup(sprop->value); | |||||
| 1469 | } | |||||
| 1470 | } | |||||
| 1471 | ||||||
| 1472 | /* ... which is already src->geom->num_properties. */ | |||||
| 1473 | dst->geom->num_properties = dst->geom->sz_properties; | |||||
| 1474 | } | |||||
| 1475 | else { | |||||
| 1476 | if (dst->geom->sz_properties) { | |||||
| 1477 | for (i = 0, dprop = dst->geom->properties; | |||||
| 1478 | i < dst->geom->num_properties; i++, dprop++) { | |||||
| 1479 | free(dprop->name); | |||||
| 1480 | free(dprop->value); | |||||
| 1481 | } | |||||
| 1482 | free(dst->geom->properties); | |||||
| 1483 | dst->geom->properties = NULL((void*)0); | |||||
| 1484 | } | |||||
| 1485 | ||||||
| 1486 | dst->geom->num_properties = 0; | |||||
| 1487 | dst->geom->sz_properties = 0; | |||||
| 1488 | } | |||||
| 1489 | ||||||
| 1490 | /* colors */ | |||||
| 1491 | if (src->geom->num_colors) { | |||||
| 1492 | if (src->geom->num_colors < dst->geom->sz_colors) { | |||||
| 1493 | for (i = src->geom->num_colors, dcolor = dst->geom->colors + i; | |||||
| 1494 | i < dst->geom->num_colors; i++, dcolor++) { | |||||
| 1495 | free(dcolor->spec); | |||||
| 1496 | } | |||||
| 1497 | } | |||||
| 1498 | ||||||
| 1499 | /* Reallocate and clear all new items if the buffer grows. */ | |||||
| 1500 | if (!XkbGeomRealloc | |||||
| 1501 | ((void **) &dst->geom->colors, dst->geom->sz_colors, | |||||
| 1502 | src->geom->num_colors, sizeof(XkbColorRec), | |||||
| 1503 | XKB_GEOM_CLEAR_EXCESS)) | |||||
| 1504 | return FALSE0; | |||||
| 1505 | dst->geom->sz_colors = src->geom->num_colors; | |||||
| 1506 | ||||||
| 1507 | for (i = 0, | |||||
| 1508 | scolor = src->geom->colors, | |||||
| 1509 | dcolor = dst->geom->colors; | |||||
| 1510 | i < src->geom->num_colors; i++, scolor++, dcolor++) { | |||||
| 1511 | if (i < dst->geom->num_colors) { | |||||
| 1512 | if (strlen(scolor->spec) != strlen(dcolor->spec)) { | |||||
| 1513 | tmp = realloc(dcolor->spec, strlen(scolor->spec) + 1); | |||||
| 1514 | if (!tmp) | |||||
| 1515 | return FALSE0; | |||||
| 1516 | dcolor->spec = tmp; | |||||
| 1517 | } | |||||
| 1518 | strcpy(dcolor->spec, scolor->spec)__builtin___strcpy_chk (dcolor->spec, scolor->spec, __builtin_object_size (dcolor->spec, 2 > 1 ? 1 : 0)); | |||||
| 1519 | } | |||||
| 1520 | else { | |||||
| 1521 | dcolor->spec = xstrdup(scolor->spec)Xstrdup(scolor->spec); | |||||
| 1522 | } | |||||
| 1523 | dcolor->pixel = scolor->pixel; | |||||
| 1524 | } | |||||
| 1525 | ||||||
| 1526 | dst->geom->num_colors = dst->geom->sz_colors; | |||||
| 1527 | } | |||||
| 1528 | else { | |||||
| 1529 | if (dst->geom->sz_colors) { | |||||
| 1530 | for (i = 0, dcolor = dst->geom->colors; | |||||
| 1531 | i < dst->geom->num_colors; i++, dcolor++) { | |||||
| 1532 | free(dcolor->spec); | |||||
| 1533 | } | |||||
| 1534 | free(dst->geom->colors); | |||||
| 1535 | dst->geom->colors = NULL((void*)0); | |||||
| 1536 | } | |||||
| 1537 | ||||||
| 1538 | dst->geom->num_colors = 0; | |||||
| 1539 | dst->geom->sz_colors = 0; | |||||
| 1540 | } | |||||
| 1541 | ||||||
| 1542 | /* shapes */ | |||||
| 1543 | /* shapes break down into outlines, which break down into points. */ | |||||
| 1544 | if (dst->geom->num_shapes) { | |||||
| 1545 | for (i = 0, dshape = dst->geom->shapes; | |||||
| 1546 | i < dst->geom->num_shapes; i++, dshape++) { | |||||
| 1547 | for (j = 0, doutline = dshape->outlines; | |||||
| 1548 | j < dshape->num_outlines; j++, doutline++) { | |||||
| 1549 | if (doutline->sz_points) | |||||
| 1550 | free(doutline->points); | |||||
| 1551 | } | |||||
| 1552 | ||||||
| 1553 | if (dshape->sz_outlines) { | |||||
| 1554 | free(dshape->outlines); | |||||
| 1555 | dshape->outlines = NULL((void*)0); | |||||
| 1556 | } | |||||
| 1557 | ||||||
| 1558 | dshape->num_outlines = 0; | |||||
| 1559 | dshape->sz_outlines = 0; | |||||
| 1560 | } | |||||
| 1561 | } | |||||
| 1562 | ||||||
| 1563 | if (src->geom->num_shapes) { | |||||
| 1564 | /* Reallocate and clear all items. */ | |||||
| 1565 | if (!XkbGeomRealloc | |||||
| 1566 | ((void **) &dst->geom->shapes, dst->geom->sz_shapes, | |||||
| 1567 | src->geom->num_shapes, sizeof(XkbShapeRec), | |||||
| 1568 | XKB_GEOM_CLEAR_ALL)) | |||||
| 1569 | return FALSE0; | |||||
| 1570 | ||||||
| 1571 | for (i = 0, sshape = src->geom->shapes, dshape = dst->geom->shapes; | |||||
| 1572 | i < src->geom->num_shapes; i++, sshape++, dshape++) { | |||||
| 1573 | if (sshape->num_outlines) { | |||||
| 1574 | tmp = calloc(sshape->num_outlines, sizeof(XkbOutlineRec)); | |||||
| 1575 | if (!tmp) | |||||
| 1576 | return FALSE0; | |||||
| 1577 | dshape->outlines = tmp; | |||||
| 1578 | ||||||
| 1579 | for (j = 0, | |||||
| 1580 | soutline = sshape->outlines, | |||||
| 1581 | doutline = dshape->outlines; | |||||
| 1582 | j < sshape->num_outlines; | |||||
| 1583 | j++, soutline++, doutline++) { | |||||
| 1584 | if (soutline->num_points) { | |||||
| 1585 | tmp = malloc(soutline->num_points * | |||||
| 1586 | sizeof(XkbPointRec)); | |||||
| 1587 | if (!tmp) | |||||
| 1588 | return FALSE0; | |||||
| 1589 | doutline->points = tmp; | |||||
| 1590 | ||||||
| 1591 | memcpy(doutline->points, soutline->points,__builtin___memcpy_chk (doutline->points, soutline->points , soutline->num_points * sizeof(XkbPointRec), __builtin_object_size (doutline->points, 0)) | |||||
| 1592 | soutline->num_points * sizeof(XkbPointRec))__builtin___memcpy_chk (doutline->points, soutline->points , soutline->num_points * sizeof(XkbPointRec), __builtin_object_size (doutline->points, 0)); | |||||
| 1593 | ||||||
| 1594 | doutline->corner_radius = soutline->corner_radius; | |||||
| 1595 | } | |||||
| 1596 | ||||||
| 1597 | doutline->num_points = soutline->num_points; | |||||
| 1598 | doutline->sz_points = soutline->num_points; | |||||
| 1599 | } | |||||
| 1600 | } | |||||
| 1601 | ||||||
| 1602 | dshape->num_outlines = sshape->num_outlines; | |||||
| 1603 | dshape->sz_outlines = sshape->num_outlines; | |||||
| 1604 | dshape->name = sshape->name; | |||||
| 1605 | dshape->bounds = sshape->bounds; | |||||
| 1606 | ||||||
| 1607 | dshape->approx = NULL((void*)0); | |||||
| 1608 | if (sshape->approx && sshape->num_outlines > 0) { | |||||
| 1609 | ||||||
| 1610 | const ptrdiff_t approx_idx = | |||||
| 1611 | sshape->approx - sshape->outlines; | |||||
| 1612 | ||||||
| 1613 | if (approx_idx < dshape->num_outlines) { | |||||
| 1614 | dshape->approx = dshape->outlines + approx_idx; | |||||
| 1615 | } | |||||
| 1616 | else { | |||||
| 1617 | LogMessage(X_WARNING, "XKB: approx outline " | |||||
| 1618 | "index is out of range\n"); | |||||
| 1619 | } | |||||
| 1620 | } | |||||
| 1621 | ||||||
| 1622 | dshape->primary = NULL((void*)0); | |||||
| 1623 | if (sshape->primary && sshape->num_outlines > 0) { | |||||
| 1624 | ||||||
| 1625 | const ptrdiff_t primary_idx = | |||||
| 1626 | sshape->primary - sshape->outlines; | |||||
| 1627 | ||||||
| 1628 | if (primary_idx < dshape->num_outlines) { | |||||
| 1629 | dshape->primary = dshape->outlines + primary_idx; | |||||
| 1630 | } | |||||
| 1631 | else { | |||||
| 1632 | LogMessage(X_WARNING, "XKB: primary outline " | |||||
| 1633 | "index is out of range\n"); | |||||
| 1634 | } | |||||
| 1635 | } | |||||
| 1636 | } | |||||
| 1637 | ||||||
| 1638 | dst->geom->num_shapes = src->geom->num_shapes; | |||||
| 1639 | dst->geom->sz_shapes = src->geom->num_shapes; | |||||
| 1640 | } | |||||
| 1641 | else { | |||||
| 1642 | if (dst->geom->sz_shapes) { | |||||
| 1643 | free(dst->geom->shapes); | |||||
| 1644 | } | |||||
| 1645 | dst->geom->shapes = NULL((void*)0); | |||||
| 1646 | dst->geom->num_shapes = 0; | |||||
| 1647 | dst->geom->sz_shapes = 0; | |||||
| 1648 | } | |||||
| 1649 | ||||||
| 1650 | /* sections */ | |||||
| 1651 | /* sections break down into doodads, and also into rows, which break | |||||
| 1652 | * down into keys. */ | |||||
| 1653 | if (dst->geom->num_sections) { | |||||
| 1654 | for (i = 0, dsection = dst->geom->sections; | |||||
| 1655 | i < dst->geom->num_sections; i++, dsection++) { | |||||
| 1656 | for (j = 0, drow = dsection->rows; | |||||
| 1657 | j < dsection->num_rows; j++, drow++) { | |||||
| 1658 | if (drow->num_keys) | |||||
| 1659 | free(drow->keys); | |||||
| 1660 | } | |||||
| 1661 | ||||||
| 1662 | if (dsection->num_rows) | |||||
| 1663 | free(dsection->rows); | |||||
| 1664 | ||||||
| 1665 | /* cut and waste from geom/doodad below. */ | |||||
| 1666 | for (j = 0, ddoodad = dsection->doodads; | |||||
| 1667 | j < dsection->num_doodads; j++, ddoodad++) { | |||||
| 1668 | if (ddoodad->any.type == XkbTextDoodad3) { | |||||
| 1669 | free(ddoodad->text.text); | |||||
| 1670 | ddoodad->text.text = NULL((void*)0); | |||||
| 1671 | free(ddoodad->text.font); | |||||
| 1672 | ddoodad->text.font = NULL((void*)0); | |||||
| 1673 | } | |||||
| 1674 | else if (ddoodad->any.type == XkbLogoDoodad5) { | |||||
| 1675 | free(ddoodad->logo.logo_name); | |||||
| 1676 | ddoodad->logo.logo_name = NULL((void*)0); | |||||
| 1677 | } | |||||
| 1678 | } | |||||
| 1679 | ||||||
| 1680 | free(dsection->doodads); | |||||
| 1681 | } | |||||
| 1682 | ||||||
| 1683 | dst->geom->num_sections = 0; | |||||
| 1684 | } | |||||
| 1685 | ||||||
| 1686 | if (src->geom->num_sections) { | |||||
| 1687 | /* Reallocate and clear all items. */ | |||||
| 1688 | if (!XkbGeomRealloc | |||||
| 1689 | ((void **) &dst->geom->sections, dst->geom->sz_sections, | |||||
| 1690 | src->geom->num_sections, sizeof(XkbSectionRec), | |||||
| 1691 | XKB_GEOM_CLEAR_ALL)) | |||||
| 1692 | return FALSE0; | |||||
| 1693 | dst->geom->num_sections = src->geom->num_sections; | |||||
| 1694 | dst->geom->sz_sections = src->geom->num_sections; | |||||
| 1695 | ||||||
| 1696 | for (i = 0, | |||||
| 1697 | ssection = src->geom->sections, | |||||
| 1698 | dsection = dst->geom->sections; | |||||
| 1699 | i < src->geom->num_sections; i++, ssection++, dsection++) { | |||||
| 1700 | *dsection = *ssection; | |||||
| 1701 | if (ssection->num_rows) { | |||||
| 1702 | tmp = calloc(ssection->num_rows, sizeof(XkbRowRec)); | |||||
| 1703 | if (!tmp) | |||||
| 1704 | return FALSE0; | |||||
| 1705 | dsection->rows = tmp; | |||||
| 1706 | } | |||||
| 1707 | dsection->num_rows = ssection->num_rows; | |||||
| 1708 | dsection->sz_rows = ssection->num_rows; | |||||
| 1709 | ||||||
| 1710 | for (j = 0, srow = ssection->rows, drow = dsection->rows; | |||||
| 1711 | j < ssection->num_rows; j++, srow++, drow++) { | |||||
| 1712 | if (srow->num_keys) { | |||||
| 1713 | tmp = malloc(srow->num_keys * sizeof(XkbKeyRec)); | |||||
| 1714 | if (!tmp) | |||||
| 1715 | return FALSE0; | |||||
| 1716 | drow->keys = tmp; | |||||
| 1717 | memcpy(drow->keys, srow->keys,__builtin___memcpy_chk (drow->keys, srow->keys, srow-> num_keys * sizeof(XkbKeyRec), __builtin_object_size (drow-> keys, 0)) | |||||
| 1718 | srow->num_keys * sizeof(XkbKeyRec))__builtin___memcpy_chk (drow->keys, srow->keys, srow-> num_keys * sizeof(XkbKeyRec), __builtin_object_size (drow-> keys, 0)); | |||||
| 1719 | } | |||||
| 1720 | drow->num_keys = srow->num_keys; | |||||
| 1721 | drow->sz_keys = srow->num_keys; | |||||
| 1722 | drow->top = srow->top; | |||||
| 1723 | drow->left = srow->left; | |||||
| 1724 | drow->vertical = srow->vertical; | |||||
| 1725 | drow->bounds = srow->bounds; | |||||
| 1726 | } | |||||
| 1727 | ||||||
| 1728 | if (ssection->num_doodads) { | |||||
| 1729 | tmp = calloc(ssection->num_doodads, sizeof(XkbDoodadRec)); | |||||
| 1730 | if (!tmp) | |||||
| 1731 | return FALSE0; | |||||
| 1732 | dsection->doodads = tmp; | |||||
| 1733 | } | |||||
| 1734 | else { | |||||
| 1735 | dsection->doodads = NULL((void*)0); | |||||
| 1736 | } | |||||
| 1737 | ||||||
| 1738 | dsection->sz_doodads = ssection->num_doodads; | |||||
| 1739 | for (k = 0, | |||||
| 1740 | sdoodad = ssection->doodads, | |||||
| 1741 | ddoodad = dsection->doodads; | |||||
| 1742 | k < ssection->num_doodads; k++, sdoodad++, ddoodad++) { | |||||
| 1743 | memcpy(ddoodad, sdoodad, sizeof(XkbDoodadRec))__builtin___memcpy_chk (ddoodad, sdoodad, sizeof(XkbDoodadRec ), __builtin_object_size (ddoodad, 0)); | |||||
| 1744 | if (sdoodad->any.type == XkbTextDoodad3) { | |||||
| 1745 | if (sdoodad->text.text) | |||||
| 1746 | ddoodad->text.text = strdup(sdoodad->text.text); | |||||
| 1747 | if (sdoodad->text.font) | |||||
| 1748 | ddoodad->text.font = strdup(sdoodad->text.font); | |||||
| 1749 | } | |||||
| 1750 | else if (sdoodad->any.type == XkbLogoDoodad5) { | |||||
| 1751 | if (sdoodad->logo.logo_name) | |||||
| 1752 | ddoodad->logo.logo_name = | |||||
| 1753 | strdup(sdoodad->logo.logo_name); | |||||
| 1754 | } | |||||
| 1755 | } | |||||
| 1756 | dsection->overlays = NULL((void*)0); | |||||
| 1757 | dsection->sz_overlays = 0; | |||||
| 1758 | dsection->num_overlays = 0; | |||||
| 1759 | } | |||||
| 1760 | } | |||||
| 1761 | else { | |||||
| 1762 | if (dst->geom->sz_sections) { | |||||
| 1763 | free(dst->geom->sections); | |||||
| 1764 | } | |||||
| 1765 | ||||||
| 1766 | dst->geom->sections = NULL((void*)0); | |||||
| 1767 | dst->geom->num_sections = 0; | |||||
| 1768 | dst->geom->sz_sections = 0; | |||||
| 1769 | } | |||||
| 1770 | ||||||
| 1771 | /* doodads */ | |||||
| 1772 | if (dst->geom->num_doodads) { | |||||
| 1773 | for (i = src->geom->num_doodads, | |||||
| 1774 | ddoodad = dst->geom->doodads + | |||||
| 1775 | src->geom->num_doodads; | |||||
| 1776 | i < dst->geom->num_doodads; i++, ddoodad++) { | |||||
| 1777 | if (ddoodad->any.type == XkbTextDoodad3) { | |||||
| 1778 | free(ddoodad->text.text); | |||||
| 1779 | ddoodad->text.text = NULL((void*)0); | |||||
| 1780 | free(ddoodad->text.font); | |||||
| 1781 | ddoodad->text.font = NULL((void*)0); | |||||
| 1782 | } | |||||
| 1783 | else if (ddoodad->any.type == XkbLogoDoodad5) { | |||||
| 1784 | free(ddoodad->logo.logo_name); | |||||
| 1785 | ddoodad->logo.logo_name = NULL((void*)0); | |||||
| 1786 | } | |||||
| 1787 | } | |||||
| 1788 | dst->geom->num_doodads = 0; | |||||
| 1789 | } | |||||
| 1790 | ||||||
| 1791 | if (src->geom->num_doodads) { | |||||
| 1792 | /* Reallocate and clear all items. */ | |||||
| 1793 | if (!XkbGeomRealloc | |||||
| 1794 | ((void **) &dst->geom->doodads, dst->geom->sz_doodads, | |||||
| 1795 | src->geom->num_doodads, sizeof(XkbDoodadRec), | |||||
| 1796 | XKB_GEOM_CLEAR_ALL)) | |||||
| 1797 | return FALSE0; | |||||
| 1798 | ||||||
| 1799 | dst->geom->sz_doodads = src->geom->num_doodads; | |||||
| 1800 | ||||||
| 1801 | for (i = 0, | |||||
| 1802 | sdoodad = src->geom->doodads, | |||||
| 1803 | ddoodad = dst->geom->doodads; | |||||
| 1804 | i < src->geom->num_doodads; i++, sdoodad++, ddoodad++) { | |||||
| 1805 | memcpy(ddoodad, sdoodad, sizeof(XkbDoodadRec))__builtin___memcpy_chk (ddoodad, sdoodad, sizeof(XkbDoodadRec ), __builtin_object_size (ddoodad, 0)); | |||||
| 1806 | if (sdoodad->any.type == XkbTextDoodad3) { | |||||
| 1807 | if (sdoodad->text.text) | |||||
| 1808 | ddoodad->text.text = strdup(sdoodad->text.text); | |||||
| 1809 | if (sdoodad->text.font) | |||||
| 1810 | ddoodad->text.font = strdup(sdoodad->text.font); | |||||
| 1811 | } | |||||
| 1812 | else if (sdoodad->any.type == XkbLogoDoodad5) { | |||||
| 1813 | if (sdoodad->logo.logo_name) | |||||
| 1814 | ddoodad->logo.logo_name = | |||||
| 1815 | strdup(sdoodad->logo.logo_name); | |||||
| 1816 | } | |||||
| 1817 | } | |||||
| 1818 | ||||||
| 1819 | dst->geom->num_doodads = dst->geom->sz_doodads; | |||||
| 1820 | } | |||||
| 1821 | else { | |||||
| 1822 | if (dst->geom->sz_doodads) { | |||||
| 1823 | free(dst->geom->doodads); | |||||
| 1824 | } | |||||
| 1825 | ||||||
| 1826 | dst->geom->doodads = NULL((void*)0); | |||||
| 1827 | dst->geom->num_doodads = 0; | |||||
| 1828 | dst->geom->sz_doodads = 0; | |||||
| 1829 | } | |||||
| 1830 | ||||||
| 1831 | /* key aliases */ | |||||
| 1832 | if (src->geom->num_key_aliases) { | |||||
| 1833 | /* Reallocate but don't clear any items. There is no need | |||||
| 1834 | * to clear anything because data is immediately copied | |||||
| 1835 | * over the whole memory area with memcpy. */ | |||||
| 1836 | if (!XkbGeomRealloc | |||||
| 1837 | ((void **) &dst->geom->key_aliases, dst->geom->sz_key_aliases, | |||||
| 1838 | src->geom->num_key_aliases, 2 * XkbKeyNameLength4, | |||||
| 1839 | XKB_GEOM_CLEAR_NONE)) | |||||
| 1840 | return FALSE0; | |||||
| 1841 | ||||||
| 1842 | dst->geom->sz_key_aliases = src->geom->num_key_aliases; | |||||
| 1843 | ||||||
| 1844 | memcpy(dst->geom->key_aliases, src->geom->key_aliases,__builtin___memcpy_chk (dst->geom->key_aliases, src-> geom->key_aliases, src->geom->num_key_aliases * 2 * 4 , __builtin_object_size (dst->geom->key_aliases, 0)) | |||||
| 1845 | src->geom->num_key_aliases * 2 * XkbKeyNameLength)__builtin___memcpy_chk (dst->geom->key_aliases, src-> geom->key_aliases, src->geom->num_key_aliases * 2 * 4 , __builtin_object_size (dst->geom->key_aliases, 0)); | |||||
| 1846 | ||||||
| 1847 | dst->geom->num_key_aliases = dst->geom->sz_key_aliases; | |||||
| 1848 | } | |||||
| 1849 | else { | |||||
| 1850 | free(dst->geom->key_aliases); | |||||
| 1851 | dst->geom->key_aliases = NULL((void*)0); | |||||
| 1852 | dst->geom->num_key_aliases = 0; | |||||
| 1853 | dst->geom->sz_key_aliases = 0; | |||||
| 1854 | } | |||||
| 1855 | ||||||
| 1856 | /* font */ | |||||
| 1857 | if (src->geom->label_font) { | |||||
| 1858 | if (!dst->geom->label_font) { | |||||
| 1859 | tmp = malloc(strlen(src->geom->label_font) + 1); | |||||
| 1860 | if (!tmp) | |||||
| 1861 | return FALSE0; | |||||
| 1862 | dst->geom->label_font = tmp; | |||||
| 1863 | } | |||||
| 1864 | else if (strlen(src->geom->label_font) != | |||||
| 1865 | strlen(dst->geom->label_font)) { | |||||
| 1866 | tmp = realloc(dst->geom->label_font, | |||||
| 1867 | strlen(src->geom->label_font) + 1); | |||||
| 1868 | if (!tmp) | |||||
| 1869 | return FALSE0; | |||||
| 1870 | dst->geom->label_font = tmp; | |||||
| 1871 | } | |||||
| 1872 | ||||||
| 1873 | strcpy(dst->geom->label_font, src->geom->label_font)__builtin___strcpy_chk (dst->geom->label_font, src-> geom->label_font, __builtin_object_size (dst->geom-> label_font, 2 > 1 ? 1 : 0)); | |||||
| 1874 | i = XkbGeomColorIndex(src->geom, src->geom->label_color)((int)((src->geom->label_color)-&(src->geom)-> colors[0])); | |||||
| 1875 | dst->geom->label_color = &(dst->geom->colors[i]); | |||||
| 1876 | i = XkbGeomColorIndex(src->geom, src->geom->base_color)((int)((src->geom->base_color)-&(src->geom)-> colors[0])); | |||||
| 1877 | dst->geom->base_color = &(dst->geom->colors[i]); | |||||
| 1878 | } | |||||
| 1879 | else { | |||||
| 1880 | free(dst->geom->label_font); | |||||
| 1881 | dst->geom->label_font = NULL((void*)0); | |||||
| 1882 | dst->geom->label_color = NULL((void*)0); | |||||
| 1883 | dst->geom->base_color = NULL((void*)0); | |||||
| 1884 | } | |||||
| 1885 | ||||||
| 1886 | dst->geom->name = src->geom->name; | |||||
| 1887 | dst->geom->width_mm = src->geom->width_mm; | |||||
| 1888 | dst->geom->height_mm = src->geom->height_mm; | |||||
| 1889 | } | |||||
| 1890 | else { | |||||
| 1891 | if (dst->geom) { | |||||
| 1892 | /* I LOVE THE DIFFERENT CALL SIGNATURE. REALLY, I DO. */ | |||||
| 1893 | XkbFreeGeometrySrvXkbFreeGeometry(dst->geom, XkbGeomAllMask(0x3f), TRUE1); | |||||
| 1894 | dst->geom = NULL((void*)0); | |||||
| 1895 | } | |||||
| 1896 | } | |||||
| 1897 | ||||||
| 1898 | return TRUE1; | |||||
| 1899 | } | |||||
| 1900 | ||||||
| 1901 | static Bool | |||||
| 1902 | _XkbCopyIndicators(XkbDescPtr src, XkbDescPtr dst) | |||||
| 1903 | { | |||||
| 1904 | /* indicators */ | |||||
| 1905 | if (src->indicators) { | |||||
| 1906 | if (!dst->indicators) { | |||||
| 1907 | dst->indicators = malloc(sizeof(XkbIndicatorRec)); | |||||
| 1908 | if (!dst->indicators) | |||||
| 1909 | return FALSE0; | |||||
| 1910 | } | |||||
| 1911 | memcpy(dst->indicators, src->indicators, sizeof(XkbIndicatorRec))__builtin___memcpy_chk (dst->indicators, src->indicators , sizeof(XkbIndicatorRec), __builtin_object_size (dst->indicators , 0)); | |||||
| 1912 | } | |||||
| 1913 | else { | |||||
| 1914 | free(dst->indicators); | |||||
| 1915 | dst->indicators = NULL((void*)0); | |||||
| 1916 | } | |||||
| 1917 | return TRUE1; | |||||
| 1918 | } | |||||
| 1919 | ||||||
| 1920 | static Bool | |||||
| 1921 | _XkbCopyControls(XkbDescPtr src, XkbDescPtr dst) | |||||
| 1922 | { | |||||
| 1923 | /* controls */ | |||||
| 1924 | if (src->ctrls) { | |||||
| 1925 | if (!dst->ctrls) { | |||||
| 1926 | dst->ctrls = malloc(sizeof(XkbControlsRec)); | |||||
| 1927 | if (!dst->ctrls) | |||||
| 1928 | return FALSE0; | |||||
| 1929 | } | |||||
| 1930 | memcpy(dst->ctrls, src->ctrls, sizeof(XkbControlsRec))__builtin___memcpy_chk (dst->ctrls, src->ctrls, sizeof( XkbControlsRec), __builtin_object_size (dst->ctrls, 0)); | |||||
| 1931 | } | |||||
| 1932 | else { | |||||
| 1933 | free(dst->ctrls); | |||||
| 1934 | dst->ctrls = NULL((void*)0); | |||||
| 1935 | } | |||||
| 1936 | return TRUE1; | |||||
| 1937 | } | |||||
| 1938 | ||||||
| 1939 | /** | |||||
| 1940 | * Copy an XKB map from src to dst, reallocating when necessary: if some | |||||
| 1941 | * map components are present in one, but not in the other, the destination | |||||
| 1942 | * components will be allocated or freed as necessary. | |||||
| 1943 | * | |||||
| 1944 | * Basic map consistency is assumed on both sides, so maps with random | |||||
| 1945 | * uninitialised data (e.g. names->radio_grous == NULL, names->num_rg == 19) | |||||
| 1946 | * _will_ cause failures. You've been warned. | |||||
| 1947 | * | |||||
| 1948 | * Returns TRUE on success, or FALSE on failure. If this function fails, | |||||
| 1949 | * dst may be in an inconsistent state: all its pointers are guaranteed | |||||
| 1950 | * to remain valid, but part of the map may be from src and part from dst. | |||||
| 1951 | * | |||||
| 1952 | */ | |||||
| 1953 | ||||||
| 1954 | Bool | |||||
| 1955 | XkbCopyKeymap(XkbDescPtr dst, XkbDescPtr src) | |||||
| 1956 | { | |||||
| 1957 | ||||||
| 1958 | if (!src || !dst) { | |||||
| 1959 | DebugF("XkbCopyKeymap: src (%p) or dst (%p) is NULL\n", src, dst); | |||||
| 1960 | return FALSE0; | |||||
| 1961 | } | |||||
| 1962 | ||||||
| 1963 | if (src == dst) | |||||
| 1964 | return TRUE1; | |||||
| 1965 | ||||||
| 1966 | if (!_XkbCopyClientMap(src, dst)) { | |||||
| 1967 | DebugF("XkbCopyKeymap: failed to copy client map\n"); | |||||
| 1968 | return FALSE0; | |||||
| 1969 | } | |||||
| 1970 | if (!_XkbCopyServerMap(src, dst)) { | |||||
| 1971 | DebugF("XkbCopyKeymap: failed to copy server map\n"); | |||||
| 1972 | return FALSE0; | |||||
| 1973 | } | |||||
| 1974 | if (!_XkbCopyIndicators(src, dst)) { | |||||
| 1975 | DebugF("XkbCopyKeymap: failed to copy indicators\n"); | |||||
| 1976 | return FALSE0; | |||||
| 1977 | } | |||||
| 1978 | if (!_XkbCopyControls(src, dst)) { | |||||
| 1979 | DebugF("XkbCopyKeymap: failed to copy controls\n"); | |||||
| 1980 | return FALSE0; | |||||
| 1981 | } | |||||
| 1982 | if (!_XkbCopyNames(src, dst)) { | |||||
| 1983 | DebugF("XkbCopyKeymap: failed to copy names\n"); | |||||
| 1984 | return FALSE0; | |||||
| 1985 | } | |||||
| 1986 | if (!_XkbCopyCompat(src, dst)) { | |||||
| 1987 | DebugF("XkbCopyKeymap: failed to copy compat map\n"); | |||||
| 1988 | return FALSE0; | |||||
| 1989 | } | |||||
| 1990 | if (!_XkbCopyGeom(src, dst)) { | |||||
| 1991 | DebugF("XkbCopyKeymap: failed to copy geometry\n"); | |||||
| 1992 | return FALSE0; | |||||
| 1993 | } | |||||
| 1994 | ||||||
| 1995 | dst->min_key_code = src->min_key_code; | |||||
| 1996 | dst->max_key_code = src->max_key_code; | |||||
| 1997 | ||||||
| 1998 | return TRUE1; | |||||
| 1999 | } | |||||
| 2000 | ||||||
| 2001 | Bool | |||||
| 2002 | XkbDeviceApplyKeymap(DeviceIntPtr dst, XkbDescPtr desc) | |||||
| 2003 | { | |||||
| 2004 | xkbNewKeyboardNotify nkn; | |||||
| 2005 | Bool ret; | |||||
| 2006 | ||||||
| 2007 | if (!dst->key || !desc) | |||||
| 2008 | return FALSE0; | |||||
| 2009 | ||||||
| 2010 | memset(&nkn, 0, sizeof(xkbNewKeyboardNotify))__builtin___memset_chk (&nkn, 0, sizeof(xkbNewKeyboardNotify ), __builtin_object_size (&nkn, 0)); | |||||
| 2011 | nkn.oldMinKeyCode = dst->key->xkbInfo->desc->min_key_code; | |||||
| 2012 | nkn.oldMaxKeyCode = dst->key->xkbInfo->desc->max_key_code; | |||||
| 2013 | nkn.deviceID = dst->id; | |||||
| 2014 | nkn.oldDeviceID = dst->id; | |||||
| 2015 | nkn.minKeyCode = desc->min_key_code; | |||||
| 2016 | nkn.maxKeyCode = desc->max_key_code; | |||||
| 2017 | nkn.requestMajor = XkbReqCode; | |||||
| 2018 | nkn.requestMinor = X_kbSetMap9; /* Near enough's good enough. */ | |||||
| 2019 | nkn.changed = XkbNKN_KeycodesMask(1L << 0); | |||||
| 2020 | if (desc->geom) | |||||
| 2021 | nkn.changed |= XkbNKN_GeometryMask(1L << 1); | |||||
| 2022 | ||||||
| 2023 | ret = XkbCopyKeymap(dst->key->xkbInfo->desc, desc); | |||||
| 2024 | if (ret) | |||||
| 2025 | XkbSendNewKeyboardNotify(dst, &nkn); | |||||
| 2026 | ||||||
| 2027 | return ret; | |||||
| 2028 | } | |||||
| 2029 | ||||||
| 2030 | Bool | |||||
| 2031 | XkbCopyDeviceKeymap(DeviceIntPtr dst, DeviceIntPtr src) | |||||
| 2032 | { | |||||
| 2033 | return XkbDeviceApplyKeymap(dst, src->key->xkbInfo->desc); | |||||
| ||||||
| 2034 | } | |||||
| 2035 | ||||||
| 2036 | int | |||||
| 2037 | XkbGetEffectiveGroup(XkbSrvInfoPtr xkbi, XkbStatePtr xkbState, CARD8 keycode) | |||||
| 2038 | { | |||||
| 2039 | XkbDescPtr xkb = xkbi->desc; | |||||
| 2040 | int effectiveGroup = xkbState->group; | |||||
| 2041 | ||||||
| 2042 | if (!XkbKeycodeInRange(xkb, keycode)((keycode) >= (xkb)->min_key_code && (keycode) <= (xkb)->max_key_code)) | |||||
| 2043 | return -1; | |||||
| 2044 | ||||||
| 2045 | if (effectiveGroup == XkbGroup1Index0) | |||||
| 2046 | return effectiveGroup; | |||||
| 2047 | ||||||
| 2048 | if (XkbKeyNumGroups(xkb, keycode)((((((xkb)->map)->key_sym_map[((keycode))].group_info)& 0x0f))) > 1U) { | |||||
| 2049 | if (effectiveGroup >= XkbKeyNumGroups(xkb, keycode)((((((xkb)->map)->key_sym_map[((keycode))].group_info)& 0x0f)))) { | |||||
| 2050 | unsigned int gi = XkbKeyGroupInfo(xkb, keycode)((((xkb)->map)->key_sym_map[((keycode))].group_info)); | |||||
| 2051 | ||||||
| 2052 | switch (XkbOutOfRangeGroupAction(gi)((gi)&0xc0)) { | |||||
| 2053 | default: | |||||
| 2054 | case XkbWrapIntoRange(0x00): | |||||
| 2055 | effectiveGroup %= XkbKeyNumGroups(xkb, keycode)((((((xkb)->map)->key_sym_map[((keycode))].group_info)& 0x0f))); | |||||
| 2056 | break; | |||||
| 2057 | case XkbClampIntoRange(0x40): | |||||
| 2058 | effectiveGroup = XkbKeyNumGroups(xkb, keycode)((((((xkb)->map)->key_sym_map[((keycode))].group_info)& 0x0f))) - 1; | |||||
| 2059 | break; | |||||
| 2060 | case XkbRedirectIntoRange(0x80): | |||||
| 2061 | effectiveGroup = XkbOutOfRangeGroupInfo(gi)((gi)&0xf0); | |||||
| 2062 | if (effectiveGroup >= XkbKeyNumGroups(xkb, keycode)((((((xkb)->map)->key_sym_map[((keycode))].group_info)& 0x0f)))) | |||||
| 2063 | effectiveGroup = 0; | |||||
| 2064 | break; | |||||
| 2065 | } | |||||
| 2066 | } | |||||
| 2067 | } | |||||
| 2068 | else | |||||
| 2069 | effectiveGroup = XkbGroup1Index0; | |||||
| 2070 | ||||||
| 2071 | return effectiveGroup; | |||||
| 2072 | } | |||||
| 2073 | ||||||
| 2074 | /* Merge the lockedPtrButtons from all attached SDs for the given master | |||||
| 2075 | * device into the MD's state. | |||||
| 2076 | */ | |||||
| 2077 | void | |||||
| 2078 | XkbMergeLockedPtrBtns(DeviceIntPtr master) | |||||
| 2079 | { | |||||
| 2080 | DeviceIntPtr d = inputInfo.devices; | |||||
| 2081 | XkbSrvInfoPtr xkbi = NULL((void*)0); | |||||
| 2082 | ||||||
| 2083 | if (!IsMaster(master)) | |||||
| 2084 | return; | |||||
| 2085 | ||||||
| 2086 | if (!master->key) | |||||
| 2087 | return; | |||||
| 2088 | ||||||
| 2089 | xkbi = master->key->xkbInfo; | |||||
| 2090 | xkbi->lockedPtrButtons = 0; | |||||
| 2091 | ||||||
| 2092 | for (; d; d = d->next) { | |||||
| 2093 | if (IsMaster(d) || GetMaster(d, MASTER_KEYBOARD2) != master || !d->key) | |||||
| 2094 | continue; | |||||
| 2095 | ||||||
| 2096 | xkbi->lockedPtrButtons |= d->key->xkbInfo->lockedPtrButtons; | |||||
| 2097 | } | |||||
| 2098 | } | |||||
| 2099 | ||||||
| 2100 | void | |||||
| 2101 | XkbCopyControls(XkbDescPtr dst, XkbDescPtr src) | |||||
| 2102 | { | |||||
| 2103 | int i, nG, nTG; | |||||
| 2104 | ||||||
| 2105 | if (!dst || !src) | |||||
| 2106 | return; | |||||
| 2107 | ||||||
| 2108 | *dst->ctrls = *src->ctrls; | |||||
| 2109 | ||||||
| 2110 | for (nG = nTG = 0, i = dst->min_key_code; i <= dst->max_key_code; i++) { | |||||
| 2111 | nG = XkbKeyNumGroups(dst, i)((((((dst)->map)->key_sym_map[((i))].group_info)&0x0f ))); | |||||
| 2112 | if (nG >= XkbNumKbdGroups4) { | |||||
| 2113 | nTG = XkbNumKbdGroups4; | |||||
| 2114 | break; | |||||
| 2115 | } | |||||
| 2116 | if (nG > nTG) { | |||||
| 2117 | nTG = nG; | |||||
| 2118 | } | |||||
| 2119 | } | |||||
| 2120 | dst->ctrls->num_groups = nTG; | |||||
| 2121 | } |