| File: | xkb/xkbUtils.c |
| Location: | line 2110, column 10 |
| Description: | Value stored to 'nG' is never read |
| 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++) { |
Value stored to 'nG' is never read | |
| 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 | } |