File: | xkb/xkbUtils.c |
Location: | line 78, column 9 |
Description: | Value stored to 'rc' during its initialization 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; |
Value stored to 'rc' during its initialization is never read | |
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 | } |