Bug Summary

File:xkbconfig.c
Location:line 121, column 25
Description:Value stored to 'stop' is never read

Annotated Source Code

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
54static char _XkbCF_rtrn[XKBCF_MAX_STR_LEN100 + 1];
55
56static int
57ScanIdent(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
73static int
74ScanString(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
141static int
142ScanInteger(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
155int
156XkbCFScan(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
250static Boolint
251AddCtrlByName(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
287static Boolint
288AddAXTimeoutOptByName(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
323XkbConfigUnboundModPtr
324XkbCFAddModByName(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
376int
377XkbCFBindMods(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
411Boolint
412XkbCFApplyMods(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*/
446static Boolint
447DefaultParser(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
838static Boolint
839DefaultCleanUp(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
875static Boolint
876DefaultApplyNames(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
915static Boolint
916DefaultApplyControls(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*/
1041static Boolint
1042DefaultFinish(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
1068static 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
1121static 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
1131XkbConfigFieldsPtr XkbCFDflts = &_XkbCFDflts;
1132
1133/***====================================================================***/
1134
1135XkbConfigFieldsPtr
1136XkbCFDup(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
1163XkbConfigFieldsPtr
1164XkbCFFree(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
1184Boolint
1185XkbCFApplyRtrnValues(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
1200XkbConfigRtrnPrivPtr
1201XkbCFAddPrivate(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
1217void
1218XkbCFFreeRtrn(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
1238Boolint
1239XkbCFParse(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*/
1295void
1296XkbCFReportError(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}