File: | xkbconfig.c |
Location: | line 121, column 25 |
Description: | Value stored to 'stop' is never read |
1 | /************************************************************ |
2 | Copyright (c) 1995 by Silicon Graphics Computer Systems, Inc. |
3 | |
4 | Permission to use, copy, modify, and distribute this |
5 | software and its documentation for any purpose and without |
6 | fee is hereby granted, provided that the above copyright |
7 | notice appear in all copies and that both that copyright |
8 | notice and this permission notice appear in supporting |
9 | documentation, and that the name of Silicon Graphics not be |
10 | used in advertising or publicity pertaining to distribution |
11 | of the software without specific prior written permission. |
12 | Silicon Graphics makes no representation about the suitability |
13 | of this software for any purpose. It is provided "as is" |
14 | without any express or implied warranty. |
15 | |
16 | SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS |
17 | SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY |
18 | AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON |
19 | GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL |
20 | DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, |
21 | DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE |
22 | OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH |
23 | THE USE OR PERFORMANCE OF THIS SOFTWARE. |
24 | |
25 | ********************************************************/ |
26 | |
27 | #ifdef HAVE_DIX_CONFIG_H |
28 | #include <dix-config.h> |
29 | #elif defined(HAVE_CONFIG_H1) |
30 | #include <config.h> |
31 | #endif |
32 | |
33 | #include <stdio.h> |
34 | #include <ctype.h> |
35 | #include <stdlib.h> |
36 | |
37 | #include <X11/Xfuncs.h> |
38 | |
39 | #include <X11/Xfuncs.h> |
40 | |
41 | |
42 | #include <X11/Xos.h> |
43 | #include <X11/Xlib.h> |
44 | #include <X11/keysym.h> |
45 | #include <X11/XKBlib.h> |
46 | #include "XKBfileInt.h" |
47 | |
48 | |
49 | #include <X11/extensions/XKBconfig.h> |
50 | |
51 | /***====================================================================***/ |
52 | |
53 | #define XKBCF_MAX_STR_LEN100 100 |
54 | static char _XkbCF_rtrn[XKBCF_MAX_STR_LEN100 + 1]; |
55 | |
56 | static int |
57 | ScanIdent(FILE *file, int ch, XkbCFScanResultPtr val_rtrn) |
58 | { |
59 | register int i; |
60 | char *str; |
61 | |
62 | val_rtrn->str = str = _XkbCF_rtrn; |
63 | for (i = 0; (isalpha(ch) || isdigit(ch) || (ch == '_')); ch = getc(file)) { |
64 | if (i < XKBCF_MAX_STR_LEN100) |
65 | str[i++] = ch; |
66 | } |
67 | if ((ch != EOF(-1)) && (ch != ' ') && (ch != '\t')) |
68 | ungetc(ch, file); |
69 | str[i] = '\0'; |
70 | return XkbCF_Ident11; |
71 | } |
72 | |
73 | static int |
74 | ScanString(FILE *file, int quote, XkbCFScanResultPtr val_rtrn) |
75 | { |
76 | int ch, nInBuf; |
77 | |
78 | nInBuf = 0; |
79 | while (((ch = getc(file)) != EOF(-1)) && (ch != '\n') && (ch != quote)) { |
80 | if (ch == '\\') { |
81 | if ((ch = getc(file)) != EOF(-1)) { |
82 | if (ch == 'n') |
83 | ch = '\n'; |
84 | else if (ch == 't') |
85 | ch = '\t'; |
86 | else if (ch == 'v') |
87 | ch = '\v'; |
88 | else if (ch == 'b') |
89 | ch = '\b'; |
90 | else if (ch == 'r') |
91 | ch = '\r'; |
92 | else if (ch == 'f') |
93 | ch = '\f'; |
94 | else if (ch == 'e') |
95 | ch = '\033'; |
96 | else if (ch == '0') { |
97 | int tmp, stop; |
98 | |
99 | ch = stop = 0; |
100 | if (((tmp = getc(file)) != EOF(-1)) && (isdigit(tmp)) && |
101 | (tmp != '8') && (tmp != '9')) { |
102 | ch = (ch * 8) + (tmp - '0'); |
103 | } |
104 | else { |
105 | stop = 1; |
106 | ungetc(tmp, file); |
107 | } |
108 | if ((!stop) && ((tmp = getc(file)) != EOF(-1)) && (isdigit(tmp)) |
109 | && (tmp != '8') && (tmp != '9')) { |
110 | ch = (ch * 8) + (tmp - '0'); |
111 | } |
112 | else { |
113 | stop = 1; |
114 | ungetc(tmp, file); |
115 | } |
116 | if ((!stop) && ((tmp = getc(file)) != EOF(-1)) && (isdigit(tmp)) |
117 | && (tmp != '8') && (tmp != '9')) { |
118 | ch = (ch * 8) + (tmp - '0'); |
119 | } |
120 | else { |
121 | stop = 1; |
Value stored to 'stop' is never read | |
122 | ungetc(tmp, file); |
123 | } |
124 | } |
125 | } |
126 | else |
127 | return XkbCF_EOF-1; |
128 | } |
129 | |
130 | if (nInBuf < XKBCF_MAX_STR_LEN100 - 1) |
131 | _XkbCF_rtrn[nInBuf++] = ch; |
132 | } |
133 | if (ch == quote) { |
134 | _XkbCF_rtrn[nInBuf++] = '\0'; |
135 | val_rtrn->str = _XkbCF_rtrn; |
136 | return XkbCF_String10; |
137 | } |
138 | return XkbCF_UnterminatedString100; |
139 | } |
140 | |
141 | static int |
142 | ScanInteger(FILE *file, int ch, XkbCFScanResultPtr val_rtrn) |
143 | { |
144 | int i; |
145 | |
146 | if (isdigit(ch)) |
147 | ungetc(ch, file); |
148 | if (fscanf(file, "%i", &i) == 1) { |
149 | val_rtrn->ival = i; |
150 | return XkbCF_Integer12; |
151 | } |
152 | return XkbCF_Unknown0; |
153 | } |
154 | |
155 | int |
156 | XkbCFScan(FILE *file, XkbCFScanResultPtr val_rtrn, XkbConfigRtrnPtr rtrn) |
157 | { |
158 | int ch; |
159 | |
160 | do { |
161 | ch = getc(file); |
162 | } while ((ch == '\t') || (ch == ' ')); |
163 | if (isalpha(ch)) |
164 | return ScanIdent(file, ch, val_rtrn); |
165 | else if (isdigit(ch)) |
166 | return ScanInteger(file, ch, val_rtrn); |
167 | else if (ch == '"') |
168 | return ScanString(file, ch, val_rtrn); |
169 | else if (ch == '\n') { |
170 | rtrn->line++; |
171 | return XkbCF_EOL1; |
172 | } |
173 | else if (ch == ';') |
174 | return XkbCF_Semi2; |
175 | else if (ch == '=') |
176 | return XkbCF_Equals3; |
177 | else if (ch == '+') { |
178 | ch = getc(file); |
179 | if (ch == '=') |
180 | return XkbCF_PlusEquals4; |
181 | if ((ch != EOF(-1)) && (ch != ' ') && (ch != '\t')) |
182 | ungetc(ch, file); |
183 | return XkbCF_Plus6; |
184 | } |
185 | else if (ch == '-') { |
186 | ch = getc(file); |
187 | if (ch == '=') |
188 | return XkbCF_MinusEquals5; |
189 | if ((ch != EOF(-1)) && (ch != ' ') && (ch != '\t')) |
190 | ungetc(ch, file); |
191 | return XkbCF_Minus7; |
192 | } |
193 | else if (ch == EOF(-1)) |
194 | return XkbCF_EOF-1; |
195 | else if ((ch == '#') || ((ch == '/') && (getc(file) == '/'))) { |
196 | while ((ch != '\n') && (ch != EOF(-1))) |
197 | ch = getc(file); |
198 | rtrn->line++; |
199 | return XkbCF_EOL1; |
200 | } |
201 | return XkbCF_Unknown0; |
202 | } |
203 | |
204 | /***====================================================================***/ |
205 | |
206 | #define _XkbCF_Illegal0 0 |
207 | #define _XkbCF_Keymap1 1 |
208 | #define _XkbCF_Keycodes2 2 |
209 | #define _XkbCF_Geometry3 3 |
210 | #define _XkbCF_PhysSymbols4 4 |
211 | #define _XkbCF_Symbols5 5 |
212 | #define _XkbCF_Types6 6 |
213 | #define _XkbCF_CompatMap7 7 |
214 | |
215 | #define _XkbCF_RulesFile8 8 |
216 | #define _XkbCF_Model9 9 |
217 | #define _XkbCF_Layout10 10 |
218 | #define _XkbCF_Variant11 11 |
219 | #define _XkbCF_Options12 12 |
220 | |
221 | #define _XkbCF_InitialMods13 13 |
222 | #define _XkbCF_InitialCtrls14 14 |
223 | |
224 | #define _XkbCF_ClickVolume15 15 |
225 | #define _XkbCF_BellVolume16 16 |
226 | #define _XkbCF_BellPitch17 17 |
227 | #define _XkbCF_BellDuration18 18 |
228 | #define _XkbCF_RepeatDelay19 19 |
229 | #define _XkbCF_RepeatInterval20 20 |
230 | #define _XkbCF_SlowKeysDelay21 21 |
231 | #define _XkbCF_DebounceDelay22 22 |
232 | #define _XkbCF_MouseKeysDelay23 23 |
233 | #define _XkbCF_MouseKeysInterval24 24 |
234 | #define _XkbCF_MouseKeysTimeToMax25 25 |
235 | #define _XkbCF_MouseKeysMaxSpeed26 26 |
236 | #define _XkbCF_MouseKeysCurve27 27 |
237 | #define _XkbCF_AccessXTimeout28 28 |
238 | #define _XkbCF_AccessXTimeoutCtrlsOn29 29 |
239 | #define _XkbCF_AccessXTimeoutCtrlsOff30 30 |
240 | #define _XkbCF_AccessXTimeoutOptsOn31 31 |
241 | #define _XkbCF_AccessXTimeoutOptsOff32 32 |
242 | |
243 | #define _XkbCF_IgnoreLockMods33 33 |
244 | #define _XkbCF_IgnoreGroupLock34 34 |
245 | #define _XkbCF_InternalMods35 35 |
246 | |
247 | #define _XkbCF_GroupsWrap36 36 |
248 | #define _XkbCF_InitialFeedback37 37 |
249 | |
250 | static Boolint |
251 | AddCtrlByName(XkbConfigRtrnPtr rtrn, char *name, unsigned long *ctrls_rtrn) |
252 | { |
253 | if ((_XkbStrCaseCmpstrcasecmp(name, "repeat") == 0) || |
254 | (_XkbStrCaseCmpstrcasecmp(name, "repeatkeys") == 0)) |
255 | *ctrls_rtrn = XkbRepeatKeysMask(1L << 0); |
256 | else if (_XkbStrCaseCmpstrcasecmp(name, "slowkeys") == 0) |
257 | *ctrls_rtrn = XkbSlowKeysMask(1L << 1); |
258 | else if (_XkbStrCaseCmpstrcasecmp(name, "bouncekeys") == 0) |
259 | *ctrls_rtrn = XkbBounceKeysMask(1L << 2); |
260 | else if (_XkbStrCaseCmpstrcasecmp(name, "stickykeys") == 0) |
261 | *ctrls_rtrn = XkbStickyKeysMask(1L << 3); |
262 | else if (_XkbStrCaseCmpstrcasecmp(name, "mousekeys") == 0) |
263 | *ctrls_rtrn = XkbMouseKeysMask(1L << 4); |
264 | else if (_XkbStrCaseCmpstrcasecmp(name, "mousekeysaccel") == 0) |
265 | *ctrls_rtrn = XkbMouseKeysAccelMask(1L << 5); |
266 | else if (_XkbStrCaseCmpstrcasecmp(name, "accessxkeys") == 0) |
267 | *ctrls_rtrn = XkbAccessXKeysMask(1L << 6); |
268 | else if (_XkbStrCaseCmpstrcasecmp(name, "accessxtimeout") == 0) |
269 | *ctrls_rtrn = XkbAccessXTimeoutMask(1L << 7); |
270 | else if (_XkbStrCaseCmpstrcasecmp(name, "accessxfeedback") == 0) |
271 | *ctrls_rtrn = XkbAccessXFeedbackMask(1L << 8); |
272 | else if (_XkbStrCaseCmpstrcasecmp(name, "audiblebell") == 0) |
273 | *ctrls_rtrn = XkbAudibleBellMask(1L << 9); |
274 | else if (_XkbStrCaseCmpstrcasecmp(name, "overlay1") == 0) |
275 | *ctrls_rtrn = XkbOverlay1Mask(1L << 10); |
276 | else if (_XkbStrCaseCmpstrcasecmp(name, "overlay2") == 0) |
277 | *ctrls_rtrn = XkbOverlay2Mask(1L << 11); |
278 | else if (_XkbStrCaseCmpstrcasecmp(name, "ignoregrouplock") == 0) |
279 | *ctrls_rtrn = XkbIgnoreGroupLockMask(1L << 12); |
280 | else { |
281 | rtrn->error = XkbCF_ExpectedControl109; |
282 | return False0; |
283 | } |
284 | return True1; |
285 | } |
286 | |
287 | static Boolint |
288 | AddAXTimeoutOptByName(XkbConfigRtrnPtr rtrn, |
289 | char *name, |
290 | unsigned short *opts_rtrn) |
291 | { |
292 | if (_XkbStrCaseCmpstrcasecmp(name, "slowkeyspress") == 0) |
293 | *opts_rtrn = XkbAX_SKPressFBMask(1L << 0); |
294 | else if (_XkbStrCaseCmpstrcasecmp(name, "slowkeysaccept") == 0) |
295 | *opts_rtrn = XkbAX_SKAcceptFBMask(1L << 1); |
296 | else if (_XkbStrCaseCmpstrcasecmp(name, "feature") == 0) |
297 | *opts_rtrn = XkbAX_FeatureFBMask(1L << 2); |
298 | else if (_XkbStrCaseCmpstrcasecmp(name, "slowwarn") == 0) |
299 | *opts_rtrn = XkbAX_SlowWarnFBMask(1L << 3); |
300 | else if (_XkbStrCaseCmpstrcasecmp(name, "indicator") == 0) |
301 | *opts_rtrn = XkbAX_IndicatorFBMask(1L << 4); |
302 | else if (_XkbStrCaseCmpstrcasecmp(name, "stickykeys") == 0) |
303 | *opts_rtrn = XkbAX_StickyKeysFBMask(1L << 5); |
304 | else if (_XkbStrCaseCmpstrcasecmp(name, "twokeys") == 0) |
305 | *opts_rtrn = XkbAX_TwoKeysMask(1L << 6); |
306 | else if (_XkbStrCaseCmpstrcasecmp(name, "latchtolock") == 0) |
307 | *opts_rtrn = XkbAX_LatchToLockMask(1L << 7); |
308 | else if (_XkbStrCaseCmpstrcasecmp(name, "slowkeysrelease") == 0) |
309 | *opts_rtrn = XkbAX_SKReleaseFBMask(1L << 8); |
310 | else if (_XkbStrCaseCmpstrcasecmp(name, "slowkeysreject") == 0) |
311 | *opts_rtrn = XkbAX_SKRejectFBMask(1L << 9); |
312 | else if (_XkbStrCaseCmpstrcasecmp(name, "bouncekeysreject") == 0) |
313 | *opts_rtrn = XkbAX_BKRejectFBMask(1L << 10); |
314 | else if (_XkbStrCaseCmpstrcasecmp(name, "dumbbell") == 0) |
315 | *opts_rtrn = XkbAX_DumbBellFBMask(1L << 11); |
316 | else { |
317 | rtrn->error = XkbCF_ExpectedControl109; |
318 | return False0; |
319 | } |
320 | return True1; |
321 | } |
322 | |
323 | XkbConfigUnboundModPtr |
324 | XkbCFAddModByName(XkbConfigRtrnPtr rtrn, int what, char *name, Boolint merge, |
325 | XkbConfigUnboundModPtr last) |
326 | { |
327 | if (rtrn->num_unbound_mods >= rtrn->sz_unbound_mods) { |
328 | rtrn->sz_unbound_mods += 5; |
329 | rtrn->unbound_mods = _XkbTypedRealloc(rtrn->unbound_mods,((rtrn->unbound_mods)?(XkbConfigUnboundModRec *)realloc((rtrn ->unbound_mods),(rtrn->sz_unbound_mods)*sizeof(XkbConfigUnboundModRec )):((XkbConfigUnboundModRec *)calloc((rtrn->sz_unbound_mods ),sizeof(XkbConfigUnboundModRec)))) |
330 | rtrn->sz_unbound_mods,((rtrn->unbound_mods)?(XkbConfigUnboundModRec *)realloc((rtrn ->unbound_mods),(rtrn->sz_unbound_mods)*sizeof(XkbConfigUnboundModRec )):((XkbConfigUnboundModRec *)calloc((rtrn->sz_unbound_mods ),sizeof(XkbConfigUnboundModRec)))) |
331 | XkbConfigUnboundModRec)((rtrn->unbound_mods)?(XkbConfigUnboundModRec *)realloc((rtrn ->unbound_mods),(rtrn->sz_unbound_mods)*sizeof(XkbConfigUnboundModRec )):((XkbConfigUnboundModRec *)calloc((rtrn->sz_unbound_mods ),sizeof(XkbConfigUnboundModRec)))); |
332 | if (rtrn->unbound_mods == NULL((void*)0)) { |
333 | rtrn->error = XkbCF_BadAlloc101; |
334 | return NULL((void*)0); |
335 | } |
336 | } |
337 | if (last == NULL((void*)0)) { |
338 | last = &rtrn->unbound_mods[rtrn->num_unbound_mods++]; |
339 | last->what = what; |
340 | last->mods = 0; |
341 | last->vmods = 0; |
342 | last->merge = merge; |
343 | last->name = NULL((void*)0); |
344 | } |
345 | if (_XkbStrCaseCmpstrcasecmp(name, "shift") == 0) |
346 | last->mods |= ShiftMask(1<<0); |
347 | else if (_XkbStrCaseCmpstrcasecmp(name, "lock") == 0) |
348 | last->mods |= LockMask(1<<1); |
349 | else if ((_XkbStrCaseCmpstrcasecmp(name, "control") == 0) || |
350 | (_XkbStrCaseCmpstrcasecmp(name, "ctrl") == 0)) |
351 | last->mods |= ControlMask(1<<2); |
352 | else if (_XkbStrCaseCmpstrcasecmp(name, "mod1") == 0) |
353 | last->mods |= Mod1Mask(1<<3); |
354 | else if (_XkbStrCaseCmpstrcasecmp(name, "mod2") == 0) |
355 | last->mods |= Mod2Mask(1<<4); |
356 | else if (_XkbStrCaseCmpstrcasecmp(name, "mod3") == 0) |
357 | last->mods |= Mod3Mask(1<<5); |
358 | else if (_XkbStrCaseCmpstrcasecmp(name, "mod4") == 0) |
359 | last->mods |= Mod4Mask(1<<6); |
360 | else if (_XkbStrCaseCmpstrcasecmp(name, "mod5") == 0) |
361 | last->mods |= Mod5Mask(1<<7); |
362 | else { |
363 | if (last->name != NULL((void*)0)) { |
364 | last = &rtrn->unbound_mods[rtrn->num_unbound_mods++]; |
365 | last->what = what; |
366 | last->mods = 0; |
367 | last->vmods = 0; |
368 | last->merge = merge; |
369 | last->name = NULL((void*)0); |
370 | } |
371 | last->name = _XkbDupString(name); |
372 | } |
373 | return last; |
374 | } |
375 | |
376 | int |
377 | XkbCFBindMods(XkbConfigRtrnPtr rtrn, XkbDescPtr xkb) |
378 | { |
379 | register int n, v; |
380 | Atom name; |
381 | XkbConfigUnboundModPtr mod; |
382 | int missing; |
383 | |
384 | if (rtrn->num_unbound_mods < 1) |
385 | return 0; |
386 | if ((xkb == NULL((void*)0)) || (xkb->names == NULL((void*)0))) |
387 | return -1; |
388 | |
389 | missing = 0; |
390 | for (n = 0, mod = rtrn->unbound_mods; n < rtrn->num_unbound_mods; |
391 | n++, mod++) { |
392 | if (mod->name != NULL((void*)0)) { |
393 | name = XkbInternAtom(xkb->dpy, mod->name, True1); |
394 | if (name == None0L) |
395 | continue; |
396 | for (v = 0; v < XkbNumVirtualMods16; v++) { |
397 | if (xkb->names->vmods[v] == name) { |
398 | mod->vmods = (1 << v); |
399 | _XkbFree(mod->name)free(mod->name); |
400 | mod->name = NULL((void*)0); |
401 | break; |
402 | } |
403 | } |
404 | if (mod->name != NULL((void*)0)) |
405 | missing++; |
406 | } |
407 | } |
408 | return missing; |
409 | } |
410 | |
411 | Boolint |
412 | XkbCFApplyMods(XkbConfigRtrnPtr rtrn, int what, XkbConfigModInfoPtr info) |
413 | { |
414 | register int n; |
415 | XkbConfigUnboundModPtr mod; |
416 | |
417 | if (rtrn->num_unbound_mods < 1) |
418 | return True1; |
419 | |
420 | for (n = 0, mod = rtrn->unbound_mods; n < rtrn->num_unbound_mods; |
421 | n++, mod++) { |
422 | if (mod->what != what) |
423 | continue; |
424 | if (mod->merge == XkbCF_MergeRemove2) { |
425 | info->mods_clear |= mod->mods; |
426 | info->vmods_clear |= mod->vmods; |
427 | } |
428 | else { |
429 | if (mod->merge == XkbCF_MergeSet0) |
430 | info->replace = True1; |
431 | info->mods |= mod->mods; |
432 | info->vmods |= mod->vmods; |
433 | } |
434 | if (mod->name == NULL((void*)0)) { |
435 | mod->what = _XkbCF_Illegal0; |
436 | } |
437 | else { |
438 | mod->mods = 0; |
439 | mod->vmods = 0; |
440 | } |
441 | } |
442 | return True1; |
443 | } |
444 | |
445 | /*ARGSUSED*/ |
446 | static Boolint |
447 | DefaultParser(FILE * file, |
448 | XkbConfigFieldsPtr fields, |
449 | XkbConfigFieldPtr field, |
450 | XkbDescPtr xkb, |
451 | XkbConfigRtrnPtr rtrn) |
452 | { |
453 | int tok; |
454 | XkbCFScanResultRec val; |
455 | char **str; |
456 | int merge; |
457 | unsigned long *ctrls, ctrls_mask; |
458 | unsigned short *opts, opts_mask; |
459 | int *pival, sign; |
460 | int onoff; |
461 | XkbConfigUnboundModPtr last; |
462 | unsigned what; |
463 | |
464 | tok = XkbCFScan(file, &val, rtrn); |
465 | str = NULL((void*)0); |
466 | onoff = 0; |
467 | pival = NULL((void*)0); |
468 | switch (field->field_id) { |
469 | case _XkbCF_RulesFile8: if (!str) str = &rtrn->rules_file; |
470 | case _XkbCF_Model9: if (!str) str = &rtrn->model; |
471 | case _XkbCF_Layout10: if (!str) str = &rtrn->layout; |
472 | case _XkbCF_Variant11: if (!str) str = &rtrn->variant; |
473 | case _XkbCF_Options12: if (!str) str = &rtrn->options; |
474 | case _XkbCF_Keymap1: if (!str) str = &rtrn->keymap; |
475 | case _XkbCF_Keycodes2: if (!str) str = &rtrn->keycodes; |
476 | case _XkbCF_Geometry3: if (!str) str = &rtrn->geometry; |
477 | case _XkbCF_PhysSymbols4: if (!str) str = &rtrn->phys_symbols; |
478 | case _XkbCF_Symbols5: if (!str) str = &rtrn->symbols; |
479 | case _XkbCF_Types6: if (!str) str = &rtrn->types; |
480 | case _XkbCF_CompatMap7: if (!str) str = &rtrn->compat; |
481 | if (tok != XkbCF_Equals3) { |
482 | rtrn->error = XkbCF_MissingEquals103; |
483 | goto BAILOUT; |
484 | } |
485 | tok = XkbCFScan(file, &val, rtrn); |
486 | if ((tok != XkbCF_String10) && (tok != XkbCF_Ident11)) { |
487 | rtrn->error = XkbCF_ExpectedString107; |
488 | return False0; |
489 | } |
490 | tok = XkbCFScan(file, &val, rtrn); |
491 | if ((tok != XkbCF_EOL1) && (tok != XkbCF_Semi2) && (tok != XkbCF_EOF-1)) { |
492 | rtrn->error = XkbCF_ExpectedEOS104; |
493 | return False0; |
494 | } |
495 | if (*str != NULL((void*)0)) |
496 | _XkbFree(*str)free(*str); |
497 | *str = _XkbDupString(val.str); |
498 | break; |
499 | case _XkbCF_InitialMods13: |
500 | case _XkbCF_IgnoreLockMods33: |
501 | case _XkbCF_InternalMods35: |
502 | what = XkbCF_InitialMods(1L<<0); |
503 | if (field->field_id == _XkbCF_InitialMods13) |
504 | rtrn->defined |= (what = XkbCF_InitialMods(1L<<0)); |
505 | else if (field->field_id == _XkbCF_InternalMods35) |
506 | rtrn->defined |= (what = XkbCF_InternalMods(1L<<1)); |
507 | else if (field->field_id == _XkbCF_IgnoreLockMods33) |
508 | rtrn->defined |= (what = XkbCF_IgnoreLockMods(1L<<2)); |
509 | if (tok == XkbCF_Equals3) |
510 | merge = XkbCF_MergeSet0; |
511 | else if (tok == XkbCF_MinusEquals5) |
512 | merge = XkbCF_MergeRemove2; |
513 | else if (tok == XkbCF_PlusEquals4) |
514 | merge = XkbCF_MergeAdd1; |
515 | else { |
516 | rtrn->error = XkbCF_MissingEquals103; |
517 | goto BAILOUT; |
518 | } |
519 | tok = XkbCFScan(file, &val, rtrn); |
520 | if ((tok == XkbCF_EOL1) || (tok == XkbCF_Semi2) || (tok == XkbCF_EOF-1)) { |
521 | rtrn->error = XkbCF_ExpectedModifier108; |
522 | return False0; |
523 | } |
524 | last = NULL((void*)0); |
525 | while ((tok != XkbCF_EOL1) && (tok != XkbCF_Semi2) && (tok != XkbCF_EOF-1)) { |
526 | if ((tok != XkbCF_Ident11) && (tok != XkbCF_String10)) { |
527 | rtrn->error = XkbCF_ExpectedModifier108; |
528 | return False0; |
529 | } |
530 | last = XkbCFAddModByName(rtrn, what, val.str, merge, last); |
531 | if (last == NULL((void*)0)) |
532 | return False0; |
533 | if (merge == XkbCF_MergeSet0) |
534 | merge = XkbCF_MergeAdd1; |
535 | tok = XkbCFScan(file, &val, rtrn); |
536 | if ((tok != XkbCF_EOL1) && (tok != XkbCF_EOF-1) && (tok != XkbCF_Semi2)) { |
537 | if (tok != XkbCF_Plus6) { |
538 | rtrn->error = XkbCF_ExpectedOperator111; |
539 | return False0; |
540 | } |
541 | tok = XkbCFScan(file, &val, rtrn); |
542 | } |
543 | } |
544 | break; |
545 | case _XkbCF_InitialCtrls14: |
546 | rtrn->defined |= XkbCF_InitialCtrls(1L<<3); |
547 | ctrls = NULL((void*)0); |
548 | if (tok == XkbCF_PlusEquals4) |
549 | ctrls = &rtrn->initial_ctrls; |
550 | else if (tok == XkbCF_MinusEquals5) |
551 | ctrls = &rtrn->initial_ctrls_clear; |
552 | else if (tok == XkbCF_Equals3) { |
553 | ctrls = &rtrn->initial_ctrls; |
554 | rtrn->replace_initial_ctrls = True1; |
555 | *ctrls = 0; |
556 | } |
557 | else { |
558 | rtrn->error = XkbCF_MissingEquals103; |
559 | goto BAILOUT; |
560 | } |
561 | tok = XkbCFScan(file, &val, rtrn); |
562 | if ((tok == XkbCF_EOL1) || (tok == XkbCF_Semi2) || (tok == XkbCF_EOF-1)) { |
563 | rtrn->error = XkbCF_ExpectedControl109; |
564 | return False0; |
565 | } |
566 | while ((tok != XkbCF_EOL1) && (tok != XkbCF_Semi2) && (tok != XkbCF_EOF-1)) { |
567 | if ((tok != XkbCF_Ident11) && (tok != XkbCF_String10)) { |
568 | rtrn->error = XkbCF_ExpectedControl109; |
569 | return False0; |
570 | } |
571 | if (!AddCtrlByName(rtrn, val.str, &ctrls_mask)) { |
572 | return False0; |
573 | } |
574 | *ctrls |= ctrls_mask; |
575 | tok = XkbCFScan(file, &val, rtrn); |
576 | if ((tok != XkbCF_EOL1) && (tok != XkbCF_EOF-1) && (tok != XkbCF_Semi2)) { |
577 | if (tok != XkbCF_Plus6) { |
578 | rtrn->error = XkbCF_ExpectedOperator111; |
579 | return False0; |
580 | } |
581 | tok = XkbCFScan(file, &val, rtrn); |
582 | } |
583 | } |
584 | break; |
585 | case _XkbCF_AccessXTimeoutCtrlsOn29: |
586 | case _XkbCF_AccessXTimeoutCtrlsOff30: |
587 | opts = NULL((void*)0); |
588 | if (tok == XkbCF_MinusEquals5) { |
589 | ctrls = &rtrn->axt_ctrls_ignore; |
590 | opts = &rtrn->axt_opts_ignore; |
591 | } |
592 | else if ((tok == XkbCF_PlusEquals4) || (tok == XkbCF_Equals3)) { |
593 | if (field->field_id == _XkbCF_AccessXTimeoutCtrlsOff30) { |
594 | ctrls = &rtrn->axt_ctrls_off; |
595 | opts = &rtrn->axt_opts_off; |
596 | if (tok == XkbCF_Equals3) |
597 | rtrn->replace_axt_ctrls_off = True1; |
598 | } |
599 | else { |
600 | ctrls = &rtrn->axt_ctrls_on; |
601 | opts = &rtrn->axt_opts_on; |
602 | if (tok == XkbCF_Equals3) |
603 | rtrn->replace_axt_ctrls_on = True1; |
604 | } |
605 | *ctrls = 0; |
606 | } |
607 | else { |
608 | rtrn->error = XkbCF_MissingEquals103; |
609 | goto BAILOUT; |
610 | } |
611 | tok = XkbCFScan(file, &val, rtrn); |
612 | if ((tok == XkbCF_EOL1) || (tok == XkbCF_Semi2) || (tok == XkbCF_EOF-1)) { |
613 | rtrn->error = XkbCF_ExpectedControl109; |
614 | return False0; |
615 | } |
616 | while ((tok != XkbCF_EOL1) && (tok != XkbCF_Semi2) && (tok != XkbCF_EOF-1)) { |
617 | if ((tok != XkbCF_Ident11) && (tok != XkbCF_String10)) { |
618 | rtrn->error = XkbCF_ExpectedControl109; |
619 | return False0; |
620 | } |
621 | if (!AddCtrlByName(rtrn, val.str, &ctrls_mask)) { |
622 | if (!AddAXTimeoutOptByName(rtrn, val.str, &opts_mask)) |
623 | return False0; |
624 | *opts |= opts_mask; |
625 | if (field->field_id == _XkbCF_AccessXTimeoutCtrlsOff30) { |
626 | rtrn->defined |= XkbCF_AccessXTimeoutOptsOff(1L<<8); |
627 | if (rtrn->replace_axt_ctrls_off) |
628 | rtrn->replace_axt_opts_off = True1; |
629 | } |
630 | else { |
631 | rtrn->defined |= XkbCF_AccessXTimeoutOptsOn(1L<<7); |
632 | if (rtrn->replace_axt_ctrls_on) |
633 | rtrn->replace_axt_opts_on = True1; |
634 | } |
635 | } |
636 | else |
637 | *ctrls |= ctrls_mask; |
638 | tok = XkbCFScan(file, &val, rtrn); |
639 | if ((tok != XkbCF_EOL1) && (tok != XkbCF_EOF-1) && (tok != XkbCF_Semi2)) { |
640 | if (tok != XkbCF_Plus6) { |
641 | rtrn->error = XkbCF_ExpectedOperator111; |
642 | return False0; |
643 | } |
644 | tok = XkbCFScan(file, &val, rtrn); |
645 | } |
646 | } |
647 | break; |
648 | case _XkbCF_InitialFeedback37: |
649 | rtrn->defined |= XkbCF_InitialOpts(1L<<10); |
650 | opts = NULL((void*)0); |
651 | if (tok == XkbCF_PlusEquals4) |
652 | opts = &rtrn->initial_opts; |
653 | else if (tok == XkbCF_MinusEquals5) |
654 | opts = &rtrn->initial_opts_clear; |
655 | else if (tok == XkbCF_Equals3) { |
656 | opts = &rtrn->initial_opts; |
657 | rtrn->replace_initial_opts = True1; |
658 | *opts = 0; |
659 | } |
660 | else { |
661 | rtrn->error = XkbCF_MissingEquals103; |
662 | goto BAILOUT; |
663 | } |
664 | tok = XkbCFScan(file, &val, rtrn); |
665 | if ((tok == XkbCF_EOL1) || (tok == XkbCF_Semi2) || (tok == XkbCF_EOF-1)) { |
666 | rtrn->error = XkbCF_ExpectedAXOption110; |
667 | return False0; |
668 | } |
669 | while ((tok != XkbCF_EOL1) && (tok != XkbCF_Semi2) && (tok != XkbCF_EOF-1)) { |
670 | if ((tok != XkbCF_Ident11) && (tok != XkbCF_String10)) { |
671 | rtrn->error = XkbCF_ExpectedAXOption110; |
672 | return False0; |
673 | } |
674 | if (!AddAXTimeoutOptByName(rtrn, val.str, &opts_mask)) { |
675 | return False0; |
676 | } |
677 | *opts |= opts_mask; |
678 | tok = XkbCFScan(file, &val, rtrn); |
679 | if ((tok != XkbCF_EOL1) && (tok != XkbCF_EOF-1) && (tok != XkbCF_Semi2)) { |
680 | if (tok != XkbCF_Plus6) { |
681 | rtrn->error = XkbCF_ExpectedOperator111; |
682 | return False0; |
683 | } |
684 | tok = XkbCFScan(file, &val, rtrn); |
685 | } |
686 | } |
687 | break; |
688 | case _XkbCF_AccessXTimeoutOptsOff32: |
689 | case _XkbCF_AccessXTimeoutOptsOn31: |
690 | opts = NULL((void*)0); |
691 | if (tok == XkbCF_MinusEquals5) |
692 | opts = &rtrn->axt_opts_ignore; |
693 | else if ((tok == XkbCF_PlusEquals4) || (tok == XkbCF_Equals3)) { |
694 | if (field->field_id == _XkbCF_AccessXTimeoutOptsOff32) { |
695 | opts = &rtrn->axt_opts_off; |
696 | if (tok == XkbCF_Equals3) |
697 | rtrn->replace_axt_opts_off = True1; |
698 | } |
699 | else { |
700 | opts = &rtrn->axt_opts_on; |
701 | if (tok == XkbCF_Equals3) |
702 | rtrn->replace_axt_opts_on = True1; |
703 | } |
704 | *opts = 0; |
705 | } |
706 | else { |
707 | rtrn->error = XkbCF_MissingEquals103; |
708 | goto BAILOUT; |
709 | } |
710 | tok = XkbCFScan(file, &val, rtrn); |
711 | if ((tok == XkbCF_EOL1) || (tok == XkbCF_Semi2) || (tok == XkbCF_EOF-1)) { |
712 | rtrn->error = XkbCF_ExpectedControl109; |
713 | return False0; |
714 | } |
715 | while ((tok != XkbCF_EOL1) && (tok != XkbCF_Semi2) && (tok != XkbCF_EOF-1)) { |
716 | if ((tok != XkbCF_Ident11) && (tok != XkbCF_String10)) { |
717 | rtrn->error = XkbCF_ExpectedControl109; |
718 | return False0; |
719 | } |
720 | if (!AddAXTimeoutOptByName(rtrn, val.str, &opts_mask)) |
721 | return False0; |
722 | *opts |= opts_mask; |
723 | |
724 | tok = XkbCFScan(file, &val, rtrn); |
725 | if ((tok != XkbCF_EOL1) && (tok != XkbCF_EOF-1) && (tok != XkbCF_Semi2)) { |
726 | if (tok != XkbCF_Plus6) { |
727 | rtrn->error = XkbCF_ExpectedOperator111; |
728 | return False0; |
729 | } |
730 | tok = XkbCFScan(file, &val, rtrn); |
731 | } |
732 | } |
733 | break; |
734 | case _XkbCF_ClickVolume15: |
735 | if (!pival) { |
736 | pival = &rtrn->click_volume; |
737 | onoff = 100; |
738 | } |
739 | case _XkbCF_BellVolume16: |
740 | if (!pival) { |
741 | pival = &rtrn->bell_volume; |
742 | onoff = 100; |
743 | } |
744 | case _XkbCF_BellPitch17: if (!pival) pival = &rtrn->bell_pitch; |
745 | case _XkbCF_BellDuration18: if (!pival) pival = &rtrn->bell_duration; |
746 | case _XkbCF_RepeatDelay19: if (!pival) pival = &rtrn->repeat_delay; |
747 | case _XkbCF_RepeatInterval20: if (!pival) pival = &rtrn->repeat_interval; |
748 | case _XkbCF_SlowKeysDelay21: if (!pival) pival = &rtrn->slow_keys_delay; |
749 | case _XkbCF_DebounceDelay22: if (!pival) pival = &rtrn->debounce_delay; |
750 | case _XkbCF_MouseKeysDelay23: if (!pival) pival = &rtrn->mk_delay; |
751 | case _XkbCF_MouseKeysInterval24: if (!pival) pival = &rtrn->mk_interval; |
752 | case _XkbCF_MouseKeysTimeToMax25: if (!pival) pival = &rtrn->mk_time_to_max; |
753 | case _XkbCF_MouseKeysMaxSpeed26: if (!pival) pival = &rtrn->mk_max_speed; |
754 | case _XkbCF_MouseKeysCurve27: if (!pival) pival = &rtrn->mk_curve; |
755 | case _XkbCF_AccessXTimeout28: if (!pival) pival = &rtrn->ax_timeout; |
756 | if (tok != XkbCF_Equals3) { |
757 | rtrn->error = XkbCF_MissingEquals103; |
758 | goto BAILOUT; |
759 | } |
760 | tok = XkbCFScan(file, &val, rtrn); |
761 | if (tok == XkbCF_Minus7 && field->field_id == _XkbCF_MouseKeysCurve27) { |
762 | /* This can be a negative value */ |
763 | tok = XkbCFScan(file, &val, rtrn); |
764 | sign = -1; |
765 | } |
766 | else |
767 | sign = 1; |
768 | if (tok != XkbCF_Integer12) { |
769 | Boolint ok = False0; |
770 | |
771 | if ((onoff) && (tok == XkbCF_Ident11) && (val.str != NULL((void*)0))) { |
772 | if (_XkbStrCaseCmpstrcasecmp(val.str, "on")) { |
773 | val.ival = onoff; |
774 | ok = True1; |
775 | } |
776 | else if (_XkbStrCaseCmpstrcasecmp(val.str, "off")) { |
777 | val.ival = 0; |
778 | ok = True1; |
779 | } |
780 | } |
781 | if (!ok) { |
782 | rtrn->error = XkbCF_ExpectedInteger106; |
783 | goto BAILOUT; |
784 | } |
785 | } |
786 | *pival = val.ival * sign; |
787 | if (field->field_id == _XkbCF_AccessXTimeout28) |
788 | rtrn->defined |= XkbCF_AccessXTimeout(1L<<4); |
789 | tok = XkbCFScan(file, &val, rtrn); |
790 | if ((tok != XkbCF_EOL1) && (tok != XkbCF_Semi2) && (tok != XkbCF_EOF-1)) { |
791 | rtrn->error = XkbCF_ExpectedEOS104; |
792 | return False0; |
793 | } |
794 | break; |
795 | case _XkbCF_GroupsWrap36: |
796 | if (tok != XkbCF_Equals3) { |
797 | rtrn->error = XkbCF_MissingEquals103; |
798 | goto BAILOUT; |
799 | } |
800 | tok = XkbCFScan(file, &val, rtrn); |
801 | if (tok == XkbCF_Ident11) { |
802 | if (_XkbStrCaseCmpstrcasecmp(val.str, "wrap") == 0) { |
803 | rtrn->groups_wrap = XkbSetGroupInfo(0, XkbWrapIntoRange, 0)((((0x00))&0xc0)|(((0)&3)<<4)|((0)&0x0f)); |
804 | } |
805 | else if (_XkbStrCaseCmpstrcasecmp(val.str, "clamp") == 0) { |
806 | rtrn->groups_wrap = XkbSetGroupInfo(0, XkbClampIntoRange, 0)((((0x40))&0xc0)|(((0)&3)<<4)|((0)&0x0f)); |
807 | } |
808 | else { |
809 | rtrn->error = XkbCF_ExpectedOORGroupBehavior112; |
810 | return False0; |
811 | } |
812 | } |
813 | else if ((tok == XkbCF_Integer12) && (XkbIsLegalGroup(val.ival - 1)(((val.ival - 1)>=0)&&((val.ival - 1)<4)))) { |
814 | rtrn->groups_wrap = XkbSetGroupInfo(0, XkbRedirectIntoRange,((((0x80))&0xc0)|(((val.ival - 1)&3)<<4)|((0)& 0x0f)) |
815 | val.ival - 1)((((0x80))&0xc0)|(((val.ival - 1)&3)<<4)|((0)& 0x0f)); |
816 | } |
817 | else { |
818 | rtrn->error = XkbCF_ExpectedOORGroupBehavior112; |
819 | return False0; |
820 | } |
821 | rtrn->defined |= XkbCF_GroupsWrap(1L<<9); |
822 | tok = XkbCFScan(file, &val, rtrn); |
823 | if ((tok != XkbCF_EOL1) && (tok != XkbCF_Semi2) && (tok != XkbCF_EOF-1)) { |
824 | rtrn->error = XkbCF_ExpectedEOS104; |
825 | return False0; |
826 | } |
827 | break; |
828 | default: |
829 | rtrn->error = XkbCF_ExpectedInteger106; |
830 | goto BAILOUT; |
831 | |
832 | } |
833 | return True1; |
834 | BAILOUT: |
835 | return False0; |
836 | } |
837 | |
838 | static Boolint |
839 | DefaultCleanUp(XkbConfigRtrnPtr rtrn) |
840 | { |
841 | if (rtrn->keymap) |
842 | _XkbFree(rtrn->keymap)free(rtrn->keymap); |
843 | if (rtrn->keycodes) |
844 | _XkbFree(rtrn->keycodes)free(rtrn->keycodes); |
845 | if (rtrn->geometry) |
846 | _XkbFree(rtrn->geometry)free(rtrn->geometry); |
847 | if (rtrn->phys_symbols) |
848 | _XkbFree(rtrn->phys_symbols)free(rtrn->phys_symbols); |
849 | if (rtrn->symbols) |
850 | _XkbFree(rtrn->symbols)free(rtrn->symbols); |
851 | if (rtrn->types) |
852 | _XkbFree(rtrn->types)free(rtrn->types); |
853 | if (rtrn->compat) |
854 | _XkbFree(rtrn->compat)free(rtrn->compat); |
855 | rtrn->keycodes = rtrn->geometry = NULL((void*)0); |
856 | rtrn->symbols = rtrn->phys_symbols = NULL((void*)0); |
857 | rtrn->types = rtrn->compat = NULL((void*)0); |
858 | if ((rtrn->unbound_mods != NULL((void*)0)) && (rtrn->num_unbound_mods > 0)) { |
859 | register int i; |
860 | |
861 | for (i = 0; i < rtrn->num_unbound_mods; i++) { |
862 | if (rtrn->unbound_mods[i].name != NULL((void*)0)) { |
863 | _XkbFree(rtrn->unbound_mods[i].name)free(rtrn->unbound_mods[i].name); |
864 | rtrn->unbound_mods[i].name = NULL((void*)0); |
865 | } |
866 | } |
867 | _XkbFree(rtrn->unbound_mods)free(rtrn->unbound_mods); |
868 | rtrn->sz_unbound_mods = 0; |
869 | rtrn->num_unbound_mods = 0; |
870 | rtrn->unbound_mods = NULL((void*)0); |
871 | } |
872 | return True1; |
873 | } |
874 | |
875 | static Boolint |
876 | DefaultApplyNames(XkbConfigRtrnPtr rtrn, XkbDescPtr xkb) |
877 | { |
878 | char *str; |
879 | |
880 | if (XkbAllocNames(xkb, XkbComponentNamesMask(0x3f), 0, 0) != Success0) |
881 | return False0; |
882 | if ((str = rtrn->keycodes) != NULL((void*)0)) { |
883 | xkb->names->keycodes = XkbInternAtom(xkb->dpy, str, False0); |
884 | _XkbFree(str)free(str); |
885 | rtrn->keycodes = NULL((void*)0); |
886 | } |
887 | if ((str = rtrn->geometry) != NULL((void*)0)) { |
888 | xkb->names->geometry = XkbInternAtom(xkb->dpy, str, False0); |
889 | _XkbFree(str)free(str); |
890 | rtrn->geometry = NULL((void*)0); |
891 | } |
892 | if ((str = rtrn->symbols) != NULL((void*)0)) { |
893 | xkb->names->symbols = XkbInternAtom(xkb->dpy, str, False0); |
894 | _XkbFree(str)free(str); |
895 | rtrn->symbols = NULL((void*)0); |
896 | } |
897 | if ((str = rtrn->phys_symbols) != NULL((void*)0)) { |
898 | xkb->names->phys_symbols = XkbInternAtom(xkb->dpy, str, False0); |
899 | _XkbFree(str)free(str); |
900 | rtrn->phys_symbols = NULL((void*)0); |
901 | } |
902 | if ((str = rtrn->types) != NULL((void*)0)) { |
903 | xkb->names->types = XkbInternAtom(xkb->dpy, str, False0); |
904 | _XkbFree(str)free(str); |
905 | rtrn->types = NULL((void*)0); |
906 | } |
907 | if ((str = rtrn->compat) != NULL((void*)0)) { |
908 | xkb->names->compat = XkbInternAtom(xkb->dpy, str, False0); |
909 | _XkbFree(str)free(str); |
910 | rtrn->compat = NULL((void*)0); |
911 | } |
912 | return True1; |
913 | } |
914 | |
915 | static Boolint |
916 | DefaultApplyControls(XkbConfigRtrnPtr rtrn, XkbDescPtr xkb) |
917 | { |
918 | unsigned on, off; |
919 | XkbControlsPtr ctrls; |
920 | unsigned int mask; |
921 | |
922 | if (XkbAllocControls(xkb, XkbAllControlsMask(0xF8001FFF)) != Success0) |
923 | return False0; |
924 | ctrls = xkb->ctrls; |
925 | if (rtrn->replace_initial_ctrls) |
926 | ctrls->enabled_ctrls = rtrn->initial_ctrls; |
927 | else |
928 | ctrls->enabled_ctrls |= rtrn->initial_ctrls; |
929 | ctrls->enabled_ctrls &= ~rtrn->initial_ctrls_clear; |
930 | if (rtrn->internal_mods.replace) { |
931 | ctrls->internal.real_mods = rtrn->internal_mods.mods; |
932 | ctrls->internal.vmods = rtrn->internal_mods.vmods; |
933 | } |
934 | else { |
935 | ctrls->internal.real_mods &= ~rtrn->internal_mods.mods_clear; |
936 | ctrls->internal.vmods &= ~rtrn->internal_mods.vmods_clear; |
937 | ctrls->internal.real_mods |= rtrn->internal_mods.mods; |
938 | ctrls->internal.vmods |= rtrn->internal_mods.vmods; |
939 | } |
940 | mask = 0; |
941 | (void) XkbVirtualModsToReal(xkb, ctrls->internal.vmods, &mask); |
942 | ctrls->internal.mask = (ctrls->internal.real_mods | mask); |
943 | |
944 | if (rtrn->ignore_lock_mods.replace) { |
945 | ctrls->ignore_lock.real_mods = rtrn->ignore_lock_mods.mods; |
946 | ctrls->ignore_lock.vmods = rtrn->ignore_lock_mods.vmods; |
947 | } |
948 | else { |
949 | ctrls->ignore_lock.real_mods &= ~rtrn->ignore_lock_mods.mods_clear; |
950 | ctrls->ignore_lock.vmods &= ~rtrn->ignore_lock_mods.vmods_clear; |
951 | ctrls->ignore_lock.real_mods |= rtrn->ignore_lock_mods.mods; |
952 | ctrls->ignore_lock.vmods |= rtrn->ignore_lock_mods.vmods; |
953 | } |
954 | mask = 0; |
955 | (void) XkbVirtualModsToReal(xkb, ctrls->ignore_lock.vmods, &mask); |
956 | ctrls->ignore_lock.mask = (ctrls->ignore_lock.real_mods | mask); |
957 | |
958 | if (rtrn->repeat_delay > 0) |
959 | ctrls->repeat_delay = rtrn->repeat_delay; |
960 | if (rtrn->repeat_interval > 0) |
961 | ctrls->repeat_interval = rtrn->repeat_interval; |
962 | if (rtrn->slow_keys_delay > 0) |
963 | ctrls->slow_keys_delay = rtrn->slow_keys_delay; |
964 | if (rtrn->debounce_delay > 0) |
965 | ctrls->debounce_delay = rtrn->debounce_delay; |
966 | if (rtrn->mk_delay > 0) |
967 | ctrls->mk_delay = rtrn->mk_delay; |
968 | if (rtrn->mk_interval > 0) |
969 | ctrls->mk_interval = rtrn->mk_interval; |
970 | if (rtrn->mk_time_to_max > 0) |
971 | ctrls->mk_time_to_max = rtrn->mk_time_to_max; |
972 | if (rtrn->mk_max_speed > 0) |
973 | ctrls->mk_max_speed = rtrn->mk_max_speed; |
974 | if (rtrn->mk_curve > 0) |
975 | ctrls->mk_curve = rtrn->mk_curve; |
976 | if (rtrn->defined & XkbCF_AccessXTimeout(1L<<4) && rtrn->ax_timeout > 0) |
977 | ctrls->ax_timeout = rtrn->ax_timeout; |
978 | |
979 | /* any value set to both off and on is reset to ignore */ |
980 | if ((off = (rtrn->axt_ctrls_on & rtrn->axt_ctrls_off)) != 0) |
981 | rtrn->axt_ctrls_ignore |= off; |
982 | |
983 | /* ignore takes priority over on and off */ |
984 | rtrn->axt_ctrls_on &= ~rtrn->axt_ctrls_ignore; |
985 | rtrn->axt_ctrls_off &= ~rtrn->axt_ctrls_ignore; |
986 | |
987 | if (!rtrn->replace_axt_ctrls_off) { |
988 | off = (ctrls->axt_ctrls_mask & (~ctrls->axt_ctrls_values)); |
989 | off &= ~rtrn->axt_ctrls_on; |
990 | off |= rtrn->axt_ctrls_off; |
991 | } |
992 | else |
993 | off = rtrn->axt_ctrls_off; |
994 | if (!rtrn->replace_axt_ctrls_on) { |
995 | on = (ctrls->axt_ctrls_mask & ctrls->axt_ctrls_values); |
996 | on &= ~rtrn->axt_ctrls_off; |
997 | on |= rtrn->axt_ctrls_on; |
998 | } |
999 | else |
1000 | on = rtrn->axt_ctrls_on; |
1001 | ctrls->axt_ctrls_mask = (on | off) & ~rtrn->axt_ctrls_ignore; |
1002 | ctrls->axt_ctrls_values = on & ~rtrn->axt_ctrls_ignore; |
1003 | |
1004 | /* any value set to both off and on is reset to ignore */ |
1005 | if ((off = (rtrn->axt_opts_on & rtrn->axt_opts_off)) != 0) |
1006 | rtrn->axt_opts_ignore |= off; |
1007 | |
1008 | /* ignore takes priority over on and off */ |
1009 | rtrn->axt_opts_on &= ~rtrn->axt_opts_ignore; |
1010 | rtrn->axt_opts_off &= ~rtrn->axt_opts_ignore; |
1011 | |
1012 | if (rtrn->replace_axt_opts_off) { |
1013 | off = (ctrls->axt_opts_mask & (~ctrls->axt_opts_values)); |
1014 | off &= ~rtrn->axt_opts_on; |
1015 | off |= rtrn->axt_opts_off; |
1016 | } |
1017 | else |
1018 | off = rtrn->axt_opts_off; |
1019 | if (!rtrn->replace_axt_opts_on) { |
1020 | on = (ctrls->axt_opts_mask & ctrls->axt_opts_values); |
1021 | on &= ~rtrn->axt_opts_off; |
1022 | on |= rtrn->axt_opts_on; |
1023 | } |
1024 | else |
1025 | on = rtrn->axt_opts_on; |
1026 | ctrls->axt_opts_mask = |
1027 | (unsigned short) ((on | off) & ~rtrn->axt_ctrls_ignore); |
1028 | ctrls->axt_opts_values = (unsigned short) (on & ~rtrn->axt_ctrls_ignore); |
1029 | |
1030 | if (rtrn->defined & XkbCF_GroupsWrap(1L<<9)) { |
1031 | int n; |
1032 | |
1033 | n = XkbNumGroups(ctrls->groups_wrap)((ctrls->groups_wrap)&0x0f); |
1034 | rtrn->groups_wrap = XkbSetNumGroups(rtrn->groups_wrap, n)(((rtrn->groups_wrap)&0xf0)|((n)&0x0f)); |
1035 | ctrls->groups_wrap = rtrn->groups_wrap; |
1036 | } |
1037 | return True1; |
1038 | } |
1039 | |
1040 | /*ARGSUSED*/ |
1041 | static Boolint |
1042 | DefaultFinish(XkbConfigFieldsPtr fields, XkbDescPtr xkb, |
1043 | XkbConfigRtrnPtr rtrn, int what) |
1044 | { |
1045 | if ((what == XkbCF_Destroy3) || (what == XkbCF_CleanUp2)) |
1046 | return DefaultCleanUp(rtrn); |
1047 | if (what == XkbCF_Check0) { |
1048 | if ((rtrn->symbols == NULL((void*)0)) && (rtrn->phys_symbols != NULL((void*)0))) |
1049 | rtrn->symbols = _XkbDupString(rtrn->phys_symbols); |
1050 | } |
1051 | if ((what == XkbCF_Apply1) || (what == XkbCF_Check0)) { |
1052 | if (xkb && xkb->names && (rtrn->num_unbound_mods > 0)) |
1053 | XkbCFBindMods(rtrn, xkb); |
1054 | XkbCFApplyMods(rtrn, XkbCF_InitialMods(1L<<0), &rtrn->initial_mods); |
1055 | XkbCFApplyMods(rtrn, XkbCF_InternalMods(1L<<1), &rtrn->internal_mods); |
1056 | XkbCFApplyMods(rtrn, XkbCF_IgnoreLockMods(1L<<2), &rtrn->ignore_lock_mods); |
1057 | } |
1058 | if (what == XkbCF_Apply1) { |
1059 | if (xkb != NULL((void*)0)) { |
1060 | DefaultApplyNames(rtrn, xkb); |
1061 | DefaultApplyControls(rtrn, xkb); |
1062 | XkbCFBindMods(rtrn, xkb); |
1063 | } |
1064 | } |
1065 | return True1; |
1066 | } |
1067 | |
1068 | static XkbConfigFieldRec _XkbCFDfltFields[] = { |
1069 | {"rules", _XkbCF_RulesFile8}, |
1070 | {"model", _XkbCF_Model9}, |
1071 | {"layout", _XkbCF_Layout10}, |
1072 | {"variant", _XkbCF_Variant11}, |
1073 | {"options", _XkbCF_Options12}, |
1074 | {"keymap", _XkbCF_Keymap1}, |
1075 | {"keycodes", _XkbCF_Keycodes2}, |
1076 | {"geometry", _XkbCF_Geometry3}, |
1077 | {"realsymbols", _XkbCF_PhysSymbols4}, |
1078 | {"actualsymbols", _XkbCF_PhysSymbols4}, |
1079 | {"symbols", _XkbCF_Symbols5}, |
1080 | {"symbolstouse", _XkbCF_Symbols5}, |
1081 | {"types", _XkbCF_Types6}, |
1082 | {"compat", _XkbCF_CompatMap7}, |
1083 | {"modifiers", _XkbCF_InitialMods13}, |
1084 | {"controls", _XkbCF_InitialCtrls14}, |
1085 | {"click", _XkbCF_ClickVolume15}, |
1086 | {"clickvolume", _XkbCF_ClickVolume15}, |
1087 | {"bell", _XkbCF_BellVolume16}, |
1088 | {"bellvolume", _XkbCF_BellVolume16}, |
1089 | {"bellpitch", _XkbCF_BellPitch17}, |
1090 | {"bellduration", _XkbCF_BellDuration18}, |
1091 | {"repeatdelay", _XkbCF_RepeatDelay19}, |
1092 | {"repeatinterval", _XkbCF_RepeatInterval20}, |
1093 | {"slowkeysdelay", _XkbCF_SlowKeysDelay21}, |
1094 | {"debouncedelay", _XkbCF_DebounceDelay22}, |
1095 | {"mousekeysdelay", _XkbCF_MouseKeysDelay23}, |
1096 | {"mousekeysinterval", _XkbCF_MouseKeysInterval24}, |
1097 | {"mousekeystimetomax", _XkbCF_MouseKeysTimeToMax25}, |
1098 | {"mousekeysmaxspeed", _XkbCF_MouseKeysMaxSpeed26}, |
1099 | {"mousekeyscurve", _XkbCF_MouseKeysCurve27}, |
1100 | {"accessxtimeout", _XkbCF_AccessXTimeout28}, |
1101 | {"axtimeout", _XkbCF_AccessXTimeout28}, |
1102 | {"accessxtimeoutctrlson", _XkbCF_AccessXTimeoutCtrlsOn29}, |
1103 | {"axtctrlson", _XkbCF_AccessXTimeoutCtrlsOn29}, |
1104 | {"accessxtimeoutctrlsoff", _XkbCF_AccessXTimeoutCtrlsOff30}, |
1105 | {"axtctrlsoff", _XkbCF_AccessXTimeoutCtrlsOff30}, |
1106 | {"accessxtimeoutfeedbackon",_XkbCF_AccessXTimeoutOptsOn31}, |
1107 | {"axtfeedbackon", _XkbCF_AccessXTimeoutOptsOn31}, |
1108 | {"accessxtimeoutfeedbackoff",_XkbCF_AccessXTimeoutOptsOff32}, |
1109 | {"axtfeedbackoff", _XkbCF_AccessXTimeoutOptsOff32}, |
1110 | {"ignorelockmods", _XkbCF_IgnoreLockMods33}, |
1111 | {"ignorelockmodifiers", _XkbCF_IgnoreLockMods33}, |
1112 | {"ignoregrouplock", _XkbCF_IgnoreGroupLock34}, |
1113 | {"internalmods", _XkbCF_InternalMods35}, |
1114 | {"internalmodifiers", _XkbCF_InternalMods35}, |
1115 | {"outofrangegroups", _XkbCF_GroupsWrap36}, |
1116 | {"groups", _XkbCF_GroupsWrap36}, |
1117 | {"feedback", _XkbCF_InitialFeedback37}, |
1118 | }; |
1119 | #define _XkbCFNumDfltFields(sizeof(_XkbCFDfltFields)/sizeof(XkbConfigFieldRec)) (sizeof(_XkbCFDfltFields)/sizeof(XkbConfigFieldRec)) |
1120 | |
1121 | static XkbConfigFieldsRec _XkbCFDflts = { |
1122 | 0, /* cfg_id */ |
1123 | _XkbCFNumDfltFields(sizeof(_XkbCFDfltFields)/sizeof(XkbConfigFieldRec)), /* num_fields */ |
1124 | _XkbCFDfltFields, /* fields */ |
1125 | DefaultParser, /* parser */ |
1126 | DefaultFinish, /* finish */ |
1127 | NULL((void*)0), /* priv */ |
1128 | NULL((void*)0) /* next */ |
1129 | }; |
1130 | |
1131 | XkbConfigFieldsPtr XkbCFDflts = &_XkbCFDflts; |
1132 | |
1133 | /***====================================================================***/ |
1134 | |
1135 | XkbConfigFieldsPtr |
1136 | XkbCFDup(XkbConfigFieldsPtr fields) |
1137 | { |
1138 | XkbConfigFieldsPtr pNew; |
1139 | |
1140 | pNew = _XkbTypedAlloc(XkbConfigFieldsRec)((XkbConfigFieldsRec *)malloc(sizeof(XkbConfigFieldsRec))); |
1141 | if (pNew != NULL((void*)0)) { |
1142 | memcpy(pNew, fields, sizeof(XkbConfigFieldsRec))__builtin___memcpy_chk (pNew, fields, sizeof(XkbConfigFieldsRec ), __builtin_object_size (pNew, 0)); |
1143 | if ((pNew->fields != NULL((void*)0)) && (pNew->num_fields > 0)) { |
1144 | pNew->fields = _XkbTypedCalloc(pNew->num_fields, XkbConfigFieldRec)((XkbConfigFieldRec *)calloc((pNew->num_fields),sizeof(XkbConfigFieldRec ))); |
1145 | if (pNew->fields) { |
1146 | memcpy(fields->fields, pNew->fields,__builtin___memcpy_chk (fields->fields, pNew->fields, ( pNew->num_fields * sizeof(XkbConfigFieldRec)), __builtin_object_size (fields->fields, 0)) |
1147 | (pNew->num_fields * sizeof(XkbConfigFieldRec)))__builtin___memcpy_chk (fields->fields, pNew->fields, ( pNew->num_fields * sizeof(XkbConfigFieldRec)), __builtin_object_size (fields->fields, 0)); |
1148 | } |
1149 | else { |
1150 | _XkbFree(pNew)free(pNew); |
1151 | return NULL((void*)0); |
1152 | } |
1153 | } |
1154 | else { |
1155 | pNew->num_fields = 0; |
1156 | pNew->fields = NULL((void*)0); |
1157 | } |
1158 | pNew->next = NULL((void*)0); |
1159 | } |
1160 | return pNew; |
1161 | } |
1162 | |
1163 | XkbConfigFieldsPtr |
1164 | XkbCFFree(XkbConfigFieldsPtr fields, Boolint all) |
1165 | { |
1166 | XkbConfigFieldsPtr next; |
1167 | |
1168 | next = NULL((void*)0); |
1169 | while (fields != NULL((void*)0)) { |
1170 | next = fields->next; |
1171 | if (fields != XkbCFDflts) { |
1172 | if (fields->fields) { |
1173 | _XkbFree(fields->fields)free(fields->fields); |
1174 | fields->fields = NULL((void*)0); |
1175 | fields->num_fields = 0; |
1176 | } |
1177 | _XkbFree(fields)free(fields); |
1178 | } |
1179 | fields = (all ? next : NULL((void*)0)); |
1180 | } |
1181 | return next; |
1182 | } |
1183 | |
1184 | Boolint |
1185 | XkbCFApplyRtrnValues(XkbConfigRtrnPtr rtrn, |
1186 | XkbConfigFieldsPtr fields, |
1187 | XkbDescPtr xkb) |
1188 | { |
1189 | Boolint ok; |
1190 | |
1191 | if ((fields == NULL((void*)0)) || (rtrn == NULL((void*)0)) || (xkb == NULL((void*)0))) |
1192 | return False0; |
1193 | for (ok = True1; fields != NULL((void*)0); fields = fields->next) { |
1194 | if (fields->finish != NULL((void*)0)) |
1195 | ok = (*fields->finish) (fields, xkb, rtrn, XkbCF_Apply1) && ok; |
1196 | } |
1197 | return ok; |
1198 | } |
1199 | |
1200 | XkbConfigRtrnPrivPtr |
1201 | XkbCFAddPrivate(XkbConfigRtrnPtr rtrn, XkbConfigFieldsPtr fields, XPointer ptr) |
1202 | { |
1203 | XkbConfigRtrnPrivPtr priv; |
1204 | |
1205 | if ((rtrn == NULL((void*)0)) || (fields == NULL((void*)0))) |
1206 | return NULL((void*)0); |
1207 | priv = _XkbTypedAlloc(XkbConfigRtrnPrivRec)((XkbConfigRtrnPrivRec *)malloc(sizeof(XkbConfigRtrnPrivRec)) ); |
1208 | if (priv != NULL((void*)0)) { |
1209 | priv->cfg_id = fields->cfg_id; |
1210 | priv->priv = ptr; |
1211 | priv->next = rtrn->priv; |
1212 | rtrn->priv = priv; |
1213 | } |
1214 | return priv; |
1215 | } |
1216 | |
1217 | void |
1218 | XkbCFFreeRtrn(XkbConfigRtrnPtr rtrn, XkbConfigFieldsPtr fields, XkbDescPtr xkb) |
1219 | { |
1220 | XkbConfigRtrnPrivPtr tmp, next; |
1221 | |
1222 | if ((fields == NULL((void*)0)) || (rtrn == NULL((void*)0))) |
1223 | return; |
1224 | while (fields != NULL((void*)0)) { |
1225 | if (fields->finish != NULL((void*)0)) |
1226 | (*fields->finish) (fields, xkb, rtrn, XkbCF_Destroy3); |
1227 | fields = fields->next; |
1228 | } |
1229 | for (tmp = rtrn->priv; tmp != NULL((void*)0); tmp = next) { |
1230 | next = tmp->next; |
1231 | bzero((char *) tmp, sizeof(XkbConfigRtrnPrivRec))__builtin___memset_chk ((char *) tmp, 0, sizeof(XkbConfigRtrnPrivRec ), __builtin_object_size ((char *) tmp, 0)); |
1232 | _XkbFree(tmp)free(tmp); |
1233 | } |
1234 | bzero((char *) rtrn, sizeof(XkbConfigRtrnRec))__builtin___memset_chk ((char *) rtrn, 0, sizeof(XkbConfigRtrnRec ), __builtin_object_size ((char *) rtrn, 0)); |
1235 | return; |
1236 | } |
1237 | |
1238 | Boolint |
1239 | XkbCFParse(FILE *file, XkbConfigFieldsPtr fields, |
1240 | XkbDescPtr xkb, XkbConfigRtrnPtr rtrn) |
1241 | { |
1242 | int tok; |
1243 | XkbCFScanResultRec val; |
1244 | XkbConfigFieldsPtr tmp; |
1245 | |
1246 | if ((file == NULL((void*)0)) || (fields == NULL((void*)0)) || (rtrn == NULL((void*)0))) |
1247 | return False0; |
1248 | for (tok = 0, tmp = fields; tmp != NULL((void*)0); tmp = tmp->next, tok++) { |
1249 | fields->cfg_id = tok; |
1250 | } |
1251 | bzero((char *) rtrn, sizeof(XkbConfigRtrnRec))__builtin___memset_chk ((char *) rtrn, 0, sizeof(XkbConfigRtrnRec ), __builtin_object_size ((char *) rtrn, 0)); |
1252 | rtrn->line = 1; |
1253 | rtrn->click_volume = -1; |
1254 | rtrn->bell_volume = -1; |
1255 | while ((tok = XkbCFScan(file, &val, rtrn)) != XkbCF_EOF-1) { |
1256 | if (tok == XkbCF_Ident11) { |
1257 | Boolint done; |
1258 | |
1259 | for (tmp = fields, done = False0; (tmp != NULL((void*)0)) && (!done); |
1260 | tmp = tmp->next) { |
1261 | register int i; |
1262 | |
1263 | XkbConfigFieldPtr f; |
1264 | |
1265 | for (i = 0, f = tmp->fields; (i < tmp->num_fields) && (!done); |
1266 | i++, f++) { |
1267 | if (_XkbStrCaseCmpstrcasecmp(val.str, f->field) != 0) |
1268 | continue; |
1269 | if ((*tmp->parser) (file, tmp, f, xkb, rtrn)) |
1270 | done = True1; |
1271 | else |
1272 | goto BAILOUT; |
1273 | } |
1274 | } |
1275 | } |
1276 | else if ((tok != XkbCF_EOL1) && (tok != XkbCF_Semi2)) { |
1277 | rtrn->error = XkbCF_MissingIdent102; |
1278 | goto BAILOUT; |
1279 | } |
1280 | } |
1281 | for (tmp = fields; tmp != NULL((void*)0); tmp = tmp->next) { |
1282 | if ((tmp->finish) && (!(*tmp->finish) (tmp, xkb, rtrn, XkbCF_Check0))) |
1283 | goto BAILOUT; |
1284 | } |
1285 | return True1; |
1286 | BAILOUT: |
1287 | for (tmp = fields; tmp != NULL((void*)0); tmp = tmp->next) { |
1288 | if (tmp->finish) |
1289 | (*tmp->finish) (tmp, xkb, rtrn, XkbCF_CleanUp2); |
1290 | } |
1291 | return False0; |
1292 | } |
1293 | |
1294 | /*ARGSUSED*/ |
1295 | void |
1296 | XkbCFReportError(FILE *file, char *name, int error, int line) |
1297 | { |
1298 | const char *msg; |
1299 | |
1300 | switch (error) { |
1301 | case XkbCF_BadAlloc101: |
1302 | msg = "allocation failed\n"; |
1303 | break; |
1304 | case XkbCF_UnterminatedString100: |
1305 | msg = "unterminated string on line %d"; |
1306 | break; |
1307 | case XkbCF_MissingIdent102: |
1308 | msg = "expected identifier on line %d"; |
1309 | break; |
1310 | case XkbCF_MissingEquals103: |
1311 | msg = "expected '=' on line %d"; |
1312 | break; |
1313 | case XkbCF_ExpectedEOS104: |
1314 | msg = "expected ';' or newline on line %d"; |
1315 | break; |
1316 | case XkbCF_ExpectedBoolean105: |
1317 | msg = "expected a boolean value on line %d"; |
1318 | break; |
1319 | case XkbCF_ExpectedInteger106: |
1320 | msg = "expected a numeric value on line %d"; |
1321 | break; |
1322 | case XkbCF_ExpectedString107: |
1323 | msg = "expected a string on line %d"; |
1324 | break; |
1325 | case XkbCF_ExpectedModifier108: |
1326 | msg = "expected a modifier name on line %d"; |
1327 | break; |
1328 | case XkbCF_ExpectedControl109: |
1329 | msg = "expected a control name on line %d"; |
1330 | break; |
1331 | case XkbCF_ExpectedAXOption110: |
1332 | msg = "expected an AccessX option on line %d"; |
1333 | break; |
1334 | case XkbCF_ExpectedOperator111: |
1335 | msg = "expected '+' or '-' on line %d"; |
1336 | break; |
1337 | case XkbCF_ExpectedOORGroupBehavior112: |
1338 | msg = "expected wrap, clamp or group number on line %d"; |
1339 | break; |
1340 | default: |
1341 | msg = "unknown error on line %d"; |
1342 | break; |
1343 | } |
1344 | fprintf(file, msg, line); |
1345 | if (name) |
1346 | fprintf(file, " of %s\n", name); |
1347 | else |
1348 | fprintf(file, "\n"); |
1349 | return; |
1350 | } |