1From dfdb147844ea6c6448a38ab7a69c514c34879fda Mon Sep 17 00:00:00 2001
2From: Michael Forney <mforney@mforney.org>
3Date: Sat, 26 Oct 2019 02:05:31 -0700
4Subject: [PATCH] Track generated xkbcomp parser
5
6Generated with
7
8 yacc -H parser.h -o parser.c p _xkbcommon_ parser.y
9---
10 src/xkbcomp/parser.c | 3382 ++++++++++++++++++++++++++++++++++++++++++
11 src/xkbcomp/parser.h | 104 ++
12 2 files changed, 3486 insertions(+)
13 create mode 100644 src/xkbcomp/parser.c
14 create mode 100644 src/xkbcomp/parser.h
15
16diff --git a/src/xkbcomp/parser.c b/src/xkbcomp/parser.c
17new file mode 100644
18index 0000000..34e9ca8
19--- /dev/null
20+++ b/src/xkbcomp/parser.c
21@@ -0,0 +1,3382 @@
22+/* original parser id follows */
23+/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
24+/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
25+
26+#define YYBYACC 1
27+#define YYMAJOR 2
28+#define YYMINOR 0
29+#define YYPATCH 20240109
30+
31+#define YYEMPTY (-1)
32+#define yyclearin (yychar = YYEMPTY)
33+#define yyerrok (yyerrflag = 0)
34+#define YYRECOVERING() (yyerrflag != 0)
35+#define YYENOMEM (-2)
36+#define YYEOF 0
37+#undef YYBTYACC
38+#define YYBTYACC 0
39+#define YYDEBUGSTR YYPREFIX "debug"
40+
41+#ifndef yyparse
42+#define yyparse _xkbcommon_parse
43+#endif /* yyparse */
44+
45+#ifndef yylex
46+#define yylex _xkbcommon_lex
47+#endif /* yylex */
48+
49+#ifndef yyerror
50+#define yyerror _xkbcommon_error
51+#endif /* yyerror */
52+
53+#ifndef yychar
54+#define yychar _xkbcommon_char
55+#endif /* yychar */
56+
57+#ifndef yyval
58+#define yyval _xkbcommon_val
59+#endif /* yyval */
60+
61+#ifndef yylval
62+#define yylval _xkbcommon_lval
63+#endif /* yylval */
64+
65+#ifndef yydebug
66+#define yydebug _xkbcommon_debug
67+#endif /* yydebug */
68+
69+#ifndef yynerrs
70+#define yynerrs _xkbcommon_nerrs
71+#endif /* yynerrs */
72+
73+#ifndef yyerrflag
74+#define yyerrflag _xkbcommon_errflag
75+#endif /* yyerrflag */
76+
77+#ifndef yylhs
78+#define yylhs _xkbcommon_lhs
79+#endif /* yylhs */
80+
81+#ifndef yylen
82+#define yylen _xkbcommon_len
83+#endif /* yylen */
84+
85+#ifndef yydefred
86+#define yydefred _xkbcommon_defred
87+#endif /* yydefred */
88+
89+#ifndef yystos
90+#define yystos _xkbcommon_stos
91+#endif /* yystos */
92+
93+#ifndef yydgoto
94+#define yydgoto _xkbcommon_dgoto
95+#endif /* yydgoto */
96+
97+#ifndef yysindex
98+#define yysindex _xkbcommon_sindex
99+#endif /* yysindex */
100+
101+#ifndef yyrindex
102+#define yyrindex _xkbcommon_rindex
103+#endif /* yyrindex */
104+
105+#ifndef yygindex
106+#define yygindex _xkbcommon_gindex
107+#endif /* yygindex */
108+
109+#ifndef yytable
110+#define yytable _xkbcommon_table
111+#endif /* yytable */
112+
113+#ifndef yycheck
114+#define yycheck _xkbcommon_check
115+#endif /* yycheck */
116+
117+#ifndef yyname
118+#define yyname _xkbcommon_name
119+#endif /* yyname */
120+
121+#ifndef yyrule
122+#define yyrule _xkbcommon_rule
123+#endif /* yyrule */
124+
125+#if YYBTYACC
126+
127+#ifndef yycindex
128+#define yycindex _xkbcommon_cindex
129+#endif /* yycindex */
130+
131+#ifndef yyctable
132+#define yyctable _xkbcommon_ctable
133+#endif /* yyctable */
134+
135+#endif /* YYBTYACC */
136+
137+#define YYPREFIX "_xkbcommon_"
138+
139+#define YYPURE 1
140+
141+#line 34 "parser.y"
142+#include "config.h"
143+
144+#include "xkbcomp/xkbcomp-priv.h"
145+#include "xkbcomp/ast-build.h"
146+#include "xkbcomp/parser-priv.h"
147+#include "scanner-utils.h"
148+#include "keysym.h"
149+
150+struct parser_param {
151+ struct xkb_context *ctx;
152+ struct scanner *scanner;
153+ XkbFile *rtrn;
154+ bool more_maps;
155+};
156+
157+#define parser_err(param, error_id, fmt, ...) \
158+ scanner_err_with_code((param)->scanner, error_id, fmt, ##__VA_ARGS__)
159+
160+#define parser_warn(param, warning_id, fmt, ...) \
161+ scanner_warn_with_code((param)->scanner, warning_id, fmt, ##__VA_ARGS__)
162+
163+static void
164+_xkbcommon_error(struct parser_param *param, const char *msg)
165+{
166+ parser_err(param, XKB_ERROR_INVALID_SYNTAX, "%s", msg);
167+}
168+
169+static bool
170+resolve_keysym(const char *name, xkb_keysym_t *sym_rtrn)
171+{
172+ xkb_keysym_t sym;
173+
174+ if (!name || istreq(name, "any") || istreq(name, "nosymbol")) {
175+ *sym_rtrn = XKB_KEY_NoSymbol;
176+ return true;
177+ }
178+
179+ if (istreq(name, "none") || istreq(name, "voidsymbol")) {
180+ *sym_rtrn = XKB_KEY_VoidSymbol;
181+ return true;
182+ }
183+
184+ sym = xkb_keysym_from_name(name, XKB_KEYSYM_NO_FLAGS);
185+ if (sym != XKB_KEY_NoSymbol) {
186+ *sym_rtrn = sym;
187+ return true;
188+ }
189+
190+ return false;
191+}
192+
193+#define param_scanner param->scanner
194+#ifdef YYSTYPE
195+#undef YYSTYPE_IS_DECLARED
196+#define YYSTYPE_IS_DECLARED 1
197+#endif
198+#ifndef YYSTYPE_IS_DECLARED
199+#define YYSTYPE_IS_DECLARED 1
200+#line 165 "parser.y"
201+typedef union YYSTYPE {
202+ int64_t num;
203+ enum xkb_file_type file_type;
204+ char *str;
205+ xkb_atom_t atom;
206+ enum merge_mode merge;
207+ enum xkb_map_flags mapFlags;
208+ xkb_keysym_t keysym;
209+ ParseCommon *any;
210+ struct { ParseCommon *head; ParseCommon *last; } anyList;
211+ ExprDef *expr;
212+ struct { ExprDef *head; ExprDef *last; } exprList;
213+ VarDef *var;
214+ struct { VarDef *head; VarDef *last; } varList;
215+ VModDef *vmod;
216+ struct { VModDef *head; VModDef *last; } vmodList;
217+ InterpDef *interp;
218+ KeyTypeDef *keyType;
219+ SymbolsDef *syms;
220+ ModMapDef *modMask;
221+ GroupCompatDef *groupCompat;
222+ LedMapDef *ledMap;
223+ LedNameDef *ledName;
224+ KeycodeDef *keyCode;
225+ KeyAliasDef *keyAlias;
226+ void *geom;
227+ XkbFile *file;
228+ struct { XkbFile *head; XkbFile *last; } fileList;
229+} YYSTYPE;
230+#endif /* !YYSTYPE_IS_DECLARED */
231+#line 211 "parser.c"
232+
233+/* compatibility with bison */
234+#ifdef YYPARSE_PARAM
235+/* compatibility with FreeBSD */
236+# ifdef YYPARSE_PARAM_TYPE
237+# define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
238+# else
239+# define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
240+# endif
241+#else
242+# define YYPARSE_DECL() yyparse(struct parser_param *param)
243+#endif
244+
245+/* Parameters sent to lex. */
246+#ifdef YYLEX_PARAM
247+# ifdef YYLEX_PARAM_TYPE
248+# define YYLEX_DECL() yylex(YYSTYPE *yylval, YYLEX_PARAM_TYPE YYLEX_PARAM)
249+# else
250+# define YYLEX_DECL() yylex(YYSTYPE *yylval, void * YYLEX_PARAM)
251+# endif
252+# define YYLEX yylex(&yylval, YYLEX_PARAM)
253+#else
254+# define YYLEX_DECL() yylex(YYSTYPE *yylval, struct scanner *param_scanner)
255+# define YYLEX yylex(&yylval, param_scanner)
256+#endif
257+
258+/* Parameters sent to yyerror. */
259+#ifndef YYERROR_DECL
260+#define YYERROR_DECL() yyerror(struct parser_param *param, const char *s)
261+#endif
262+#ifndef YYERROR_CALL
263+#define YYERROR_CALL(msg) yyerror(param, msg)
264+#endif
265+
266+#ifndef YYDESTRUCT_DECL
267+#define YYDESTRUCT_DECL() yydestruct(const char *msg, int psymb, YYSTYPE *val, struct parser_param *param)
268+#endif
269+#ifndef YYDESTRUCT_CALL
270+#define YYDESTRUCT_CALL(msg, psymb, val) yydestruct(msg, psymb, val, param)
271+#endif
272+
273+extern int YYPARSE_DECL();
274+
275+#define END_OF_FILE 0
276+#define ERROR_TOK 255
277+#define XKB_KEYMAP 1
278+#define XKB_KEYCODES 2
279+#define XKB_TYPES 3
280+#define XKB_SYMBOLS 4
281+#define XKB_COMPATMAP 5
282+#define XKB_GEOMETRY 6
283+#define XKB_SEMANTICS 7
284+#define XKB_LAYOUT 8
285+#define INCLUDE 10
286+#define OVERRIDE 11
287+#define AUGMENT 12
288+#define REPLACE 13
289+#define ALTERNATE 14
290+#define VIRTUAL_MODS 20
291+#define TYPE 21
292+#define INTERPRET 22
293+#define ACTION_TOK 23
294+#define KEY 24
295+#define ALIAS 25
296+#define GROUP 26
297+#define MODIFIER_MAP 27
298+#define INDICATOR 28
299+#define SHAPE 29
300+#define KEYS 30
301+#define ROW 31
302+#define SECTION 32
303+#define OVERLAY 33
304+#define TEXT 34
305+#define OUTLINE 35
306+#define SOLID 36
307+#define LOGO 37
308+#define VIRTUAL 38
309+#define EQUALS 40
310+#define PLUS 41
311+#define MINUS 42
312+#define DIVIDE 43
313+#define TIMES 44
314+#define OBRACE 45
315+#define CBRACE 46
316+#define OPAREN 47
317+#define CPAREN 48
318+#define OBRACKET 49
319+#define CBRACKET 50
320+#define DOT 51
321+#define COMMA 52
322+#define SEMI 53
323+#define EXCLAM 54
324+#define INVERT 55
325+#define STRING 60
326+#define INTEGER 61
327+#define FLOAT 62
328+#define IDENT 63
329+#define KEYNAME 64
330+#define PARTIAL 70
331+#define DEFAULT 71
332+#define HIDDEN 72
333+#define ALPHANUMERIC_KEYS 73
334+#define MODIFIER_KEYS 74
335+#define KEYPAD_KEYS 75
336+#define FUNCTION_KEYS 76
337+#define ALTERNATE_GROUP 77
338+#define YYERRCODE 256
339+typedef int YYINT;
340+static const YYINT _xkbcommon_lhs[] = { -1,
341+ 0, 0, 0, 70, 9, 9, 9, 69, 69, 68,
342+ 10, 10, 10, 10, 10, 13, 13, 12, 12, 11,
343+ 11, 11, 11, 11, 11, 11, 11, 22, 22, 22,
344+ 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
345+ 21, 21, 21, 21, 37, 37, 37, 52, 53, 43,
346+ 42, 42, 41, 41, 44, 45, 45, 39, 39, 46,
347+ 47, 40, 40, 38, 38, 38, 38, 38, 27, 27,
348+ 49, 48, 50, 51, 51, 54, 54, 55, 56, 56,
349+ 57, 57, 57, 57, 57, 58, 58, 59, 59, 60,
350+ 60, 61, 61, 62, 63, 63, 64, 65, 65, 66,
351+ 66, 66, 33, 33, 32, 67, 6, 6, 6, 6,
352+ 16, 16, 18, 18, 18, 18, 18, 18, 18, 18,
353+ 18, 18, 18, 8, 8, 7, 7, 7, 7, 7,
354+ 34, 34, 35, 35, 23, 23, 23, 23, 23, 23,
355+ 24, 24, 24, 24, 24, 24, 24, 24, 36, 36,
356+ 31, 25, 25, 25, 25, 26, 26, 26, 26, 29,
357+ 29, 30, 30, 30, 30, 28, 20, 20, 20, 5,
358+ 5, 2, 2, 4, 3, 1, 17, 17, 19, 15,
359+ 15, 14,
360+};
361+static const YYINT _xkbcommon_len[] = { 2,
362+ 1, 1, 1, 7, 1, 1, 1, 2, 1, 7,
363+ 1, 1, 1, 1, 1, 1, 0, 2, 1, 1,
364+ 1, 1, 1, 1, 1, 1, 1, 2, 3, 0,
365+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
366+ 2, 2, 2, 2, 4, 2, 3, 4, 5, 3,
367+ 3, 1, 1, 3, 6, 3, 1, 2, 1, 6,
368+ 6, 3, 1, 3, 3, 1, 2, 1, 3, 3,
369+ 5, 6, 6, 5, 6, 6, 6, 6, 2, 1,
370+ 5, 1, 1, 1, 1, 2, 1, 5, 1, 3,
371+ 1, 1, 3, 6, 3, 1, 3, 3, 1, 3,
372+ 5, 3, 3, 1, 5, 6, 1, 1, 1, 1,
373+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
374+ 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,
375+ 1, 0, 3, 1, 3, 3, 3, 3, 3, 1,
376+ 2, 2, 2, 2, 1, 4, 1, 3, 3, 1,
377+ 4, 1, 3, 4, 6, 1, 1, 1, 1, 1,
378+ 0, 3, 3, 1, 1, 3, 1, 1, 1, 2,
379+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
380+ 0, 1,
381+};
382+static const YYINT _xkbcommon_defred[] = { 0,
383+ 3, 20, 21, 22, 23, 24, 25, 26, 27, 0,
384+ 19, 0, 0, 2, 1, 18, 5, 11, 12, 14,
385+ 13, 15, 6, 7, 0, 0, 182, 180, 0, 0,
386+ 0, 30, 0, 9, 0, 0, 0, 8, 126, 128,
387+ 127, 129, 130, 0, 0, 0, 28, 4, 10, 44,
388+ 0, 0, 0, 113, 0, 0, 0, 0, 0, 0,
389+ 121, 0, 0, 108, 109, 110, 0, 0, 177, 0,
390+ 178, 0, 0, 0, 112, 0, 31, 29, 32, 35,
391+ 36, 37, 38, 39, 40, 33, 34, 41, 42, 43,
392+ 0, 52, 0, 179, 0, 168, 175, 167, 169, 0,
393+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
394+ 0, 0, 0, 0, 0, 46, 0, 0, 0, 50,
395+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
396+ 0, 0, 47, 176, 0, 0, 115, 114, 116, 117,
397+ 118, 119, 120, 122, 123, 0, 0, 0, 0, 0,
398+ 174, 159, 157, 158, 0, 111, 156, 0, 140, 0,
399+ 147, 0, 0, 0, 51, 59, 0, 0, 0, 0,
400+ 0, 0, 0, 68, 63, 0, 0, 0, 0, 0,
401+ 0, 0, 0, 0, 0, 104, 0, 0, 99, 0,
402+ 0, 0, 82, 84, 0, 80, 85, 83, 0, 48,
403+ 0, 142, 145, 141, 0, 143, 144, 0, 0, 0,
404+ 0, 0, 154, 0, 0, 45, 0, 58, 0, 0,
405+ 0, 0, 0, 164, 165, 0, 0, 150, 0, 67,
406+ 0, 0, 0, 49, 71, 0, 0, 74, 0, 0,
407+ 0, 173, 172, 171, 0, 0, 0, 0, 0, 0,
408+ 0, 0, 0, 79, 0, 0, 148, 0, 0, 0,
409+ 0, 135, 138, 0, 0, 60, 55, 0, 0, 69,
410+ 0, 70, 0, 0, 65, 61, 62, 72, 0, 73,
411+ 100, 170, 0, 0, 0, 77, 103, 76, 98, 0,
412+ 89, 0, 87, 0, 78, 75, 106, 146, 155, 166,
413+ 0, 162, 163, 149, 0, 0, 0, 0, 86, 0,
414+ 0, 96, 151, 105, 101, 0, 92, 0, 91, 81,
415+ 0, 0, 0, 0, 0, 0, 97, 94, 95, 93,
416+ 88, 90,
417+};
418+#if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING)
419+static const YYINT _xkbcommon_stos[] = { 0,
420+ 0, 70, 71, 72, 73, 74, 75, 76, 77, 258,
421+ 269, 270, 271, 326, 328, 269, 1, 2, 3, 4,
422+ 5, 6, 7, 8, 267, 268, 60, 272, 273, 273,
423+ 45, 45, 271, 326, 327, 280, 46, 326, 10, 11,
424+ 12, 13, 14, 46, 265, 266, 279, 53, 53, 60,
425+ 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
426+ 31, 32, 34, 35, 36, 37, 38, 54, 63, 64,
427+ 71, 264, 274, 275, 276, 283, 295, 301, 302, 304,
428+ 305, 306, 307, 308, 309, 310, 311, 312, 313, 325,
429+ 275, 299, 300, 60, 277, 32, 61, 63, 261, 278,
430+ 303, 64, 64, 261, 275, 261, 277, 277, 277, 28,
431+ 275, 40, 277, 49, 51, 53, 40, 40, 52, 53,
432+ 45, 41, 45, 45, 40, 40, 45, 40, 45, 45,
433+ 45, 261, 53, 61, 259, 45, 21, 22, 24, 26,
434+ 27, 28, 29, 32, 34, 41, 42, 47, 54, 55,
435+ 62, 64, 261, 262, 274, 275, 277, 281, 282, 283,
436+ 284, 274, 281, 281, 299, 295, 297, 281, 297, 49,
437+ 54, 275, 283, 285, 296, 298, 64, 281, 281, 293,
438+ 281, 297, 45, 49, 275, 290, 291, 323, 324, 28,
439+ 31, 33, 295, 308, 314, 315, 320, 325, 40, 53,
440+ 297, 282, 283, 282, 281, 282, 282, 47, 41, 42,
441+ 43, 44, 50, 40, 49, 53, 46, 295, 46, 32,
442+ 45, 63, 274, 278, 286, 287, 288, 289, 294, 275,
443+ 40, 46, 52, 53, 53, 46, 52, 53, 46, 291,
444+ 42, 61, 62, 260, 263, 40, 46, 52, 46, 52,
445+ 45, 277, 46, 315, 281, 46, 48, 292, 293, 281,
446+ 281, 281, 281, 281, 281, 53, 53, 288, 47, 50,
447+ 52, 50, 52, 281, 285, 53, 296, 53, 281, 53,
448+ 46, 260, 52, 45, 281, 53, 290, 53, 324, 30,
449+ 295, 316, 317, 45, 53, 53, 53, 48, 50, 46,
450+ 292, 278, 286, 289, 263, 291, 45, 46, 317, 64,
451+ 321, 322, 48, 50, 46, 45, 64, 318, 319, 53,
452+ 40, 46, 52, 293, 46, 52, 64, 53, 322, 46,
453+ 53, 319,
454+};
455+#endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */
456+static const YYINT _xkbcommon_dgoto[] = { 10,
457+ 135, 244, 153, 154, 245, 72, 45, 46, 25, 26,
458+ 11, 12, 33, 28, 29, 155, 156, 75, 157, 224,
459+ 47, 36, 179, 159, 160, 161, 174, 225, 226, 227,
460+ 228, 186, 187, 258, 259, 229, 166, 175, 167, 176,
461+ 92, 93, 78, 79, 101, 80, 81, 82, 83, 194,
462+ 85, 86, 87, 88, 89, 195, 196, 292, 293, 318,
463+ 319, 197, 311, 312, 188, 189, 198, 14, 35, 15,
464+};
465+static const YYINT _xkbcommon_sindex[] = { 164,
466+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
467+ 0, 499, 823, 0, 0, 0, 0, 0, 0, 0,
468+ 0, 0, 0, 0, -2, -2, 0, 0, -13, 26,
469+ 499, 0, 623, 0, 154, 15, -44, 0, 0, 0,
470+ 0, 0, 0, 23, 32, 16, 0, 0, 0, 0,
471+ -56, 40, 2, 0, 98, 108, 121, -56, 6, 40,
472+ 0, 40, 0, 0, 0, 0, 189, -56, 0, 192,
473+ 0, 40, 79, 202, 0, 227, 0, 0, 0, 0,
474+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
475+ 253, 0, 141, 0, 269, 0, 0, 0, 0, 257,
476+ 282, 283, 290, 302, 300, 315, 333, 337, 351, 121,
477+ 320, 348, 366, 422, 776, 0, 422, 422, -56, 0,
478+ 752, 422, 752, 570, 368, 422, 422, 422, 752, -14,
479+ 514, 385, 0, 0, 380, 752, 0, 0, 0, 0,
480+ 0, 0, 0, 0, 0, 422, 422, 422, 422, 422,
481+ 0, 0, 0, 0, 97, 0, 0, 66, 0, 401,
482+ 0, 393, 115, 201, 0, 0, 584, 201, 622, 638,
483+ -56, 0, 412, 0, 0, -36, 402, 133, 201, -22,
484+ 260, 684, 408, 56, 418, 0, 74, 81, 0, 40,
485+ 414, 40, 0, 0, 468, 0, 0, 0, 422, 0,
486+ 700, 0, 0, 0, 326, 0, 0, 422, 422, 422,
487+ 422, 422, 0, 422, 422, 0, 407, 0, 421, 0,
488+ 36, 0, 424, 0, 0, 417, 423, 0, 255, 0,
489+ 330, 425, 570, 0, 0, 426, 422, 0, 427, 119,
490+ 160, 0, 0, 0, 429, 376, 434, 408, 435, 1,
491+ 738, 453, 463, 0, 268, 465, 0, 458, 472, 276,
492+ 276, 0, 0, 201, 345, 0, 0, 143, 422, 0,
493+ 36, 0, 776, 201, 0, 0, 0, 0, 201, 0,
494+ 0, 0, 56, 408, 201, 0, 0, 0, 0, 484,
495+ 0, 532, 0, 470, 0, 0, 0, 0, 0, 0,
496+ 496, 0, 0, 0, 502, 217, 10, 504, 0, 525,
497+ 220, 0, 0, 0, 0, 422, 0, 277, 0, 0,
498+ 503, 526, 470, 360, 527, 10, 0, 0, 0, 0,
499+ 0, 0,
500+};
501+static const YYINT _xkbcommon_rindex[] = { 847,
502+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
503+ 0, 855, 0, 0, 0, 0, 0, 0, 0, 0,
504+ 0, 0, 0, 0, 537, 537, 0, 0, 0, 0,
505+ 692, 0, 0, 0, 692, 254, 0, 0, 0, 0,
506+ 0, 0, 0, 0, 312, 0, 0, 0, 0, 0,
507+ 0, 55, 73, 0, 91, 0, 112, 129, 157, 161,
508+ 0, 219, 42, 0, 0, 0, 0, 0, 0, 0,
509+ 0, 0, 544, 222, 0, 0, 0, 0, 0, 0,
510+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
511+ 328, 0, 0, 0, 0, 0, 0, 0, 0, 543,
512+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
513+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
514+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
515+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
516+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
517+ 0, 0, 0, 0, 208, 0, 0, 0, 0, 636,
518+ 0, 467, 0, 361, 0, 0, 0, 545, 0, 539,
519+ 0, 139, 0, 0, 0, 0, 0, 0, 475, 0,
520+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 157,
521+ 275, 0, 0, 0, 0, 0, 0, 0, 0, 0,
522+ 0, 0, 0, 0, 0, 0, 0, 552, 0, 0,
523+ 0, 0, 0, 0, 0, 0, 0, 0, 0, -33,
524+ 0, 313, 0, 0, 0, 0, 559, 0, 0, 0,
525+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
526+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
527+ 0, 0, 0, 0, 0, 0, 0, 0, 566, 374,
528+ 420, 0, 0, 480, 0, 0, 0, 0, 552, 0,
529+ 0, 0, 0, 382, 0, 0, 0, 0, 535, 0,
530+ 0, 0, 0, 0, 383, 0, 0, 0, 0, 0,
531+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
532+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
533+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
534+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
535+ 0, 0,
536+};
537+#if YYBTYACC
538+static const YYINT _xkbcommon_cindex[] = { 0,
539+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
540+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
541+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
542+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
543+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
544+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
545+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
546+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
547+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
548+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
549+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
550+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
551+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
552+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
553+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
554+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
555+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
556+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
557+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
558+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
559+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
560+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
561+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
562+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
563+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
564+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
565+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
566+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
567+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
568+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
569+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
570+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
571+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
572+ 0, 0,
573+};
574+#endif
575+static const YYINT _xkbcommon_gindex[] = { 0,
576+ 0, 379, -51, 0, 334, 0, 0, 0, 0, 0,
577+ 609, 0, 637, 0, 596, 14, -46, 0, -39, -52,
578+ 0, 0, 85, 485, -35, 0, 392, 365, 0, 419,
579+ 369, 391, -179, 388, -124, 0, -28, 430, -67, 0,
580+ 533, 0, 0, 0, 0, 0, 0, 0, 0, 612,
581+ 0, 0, 0, 0, 0, 0, 476, 0, 381, 0,
582+ 349, 0, 0, 364, 0, 440, 628, 183, 0, 0,
583+};
584+#define YYTABLESIZE 863
585+static const YYINT _xkbcommon_table[] = { 74,
586+ 100, 99, 180, 240, 91, 104, 69, 106, 48, 232,
587+ 76, 105, 95, 122, 71, 233, 168, 77, 168, 107,
588+ 108, 111, 109, 236, 39, 40, 41, 42, 43, 237,
589+ 183, 31, 113, 96, 184, 51, 52, 53, 54, 55,
590+ 56, 57, 58, 59, 60, 183, 61, 62, 69, 63,
591+ 64, 65, 66, 67, 316, 169, 71, 27, 132, 73,
592+ 44, 182, 97, 69, 98, 94, 97, 96, 201, 68,
593+ 32, 71, 91, 317, 74, 49, 74, 172, 69, 70,
594+ 221, 123, 74, 185, 74, 76, 71, 76, 173, 74,
595+ 123, 50, 123, 76, 115, 76, 97, 241, 98, 94,
596+ 76, 107, 193, 115, 306, 115, 209, 210, 211, 212,
597+ 203, 203, 114, 203, 203, 213, 242, 243, 99, 247,
598+ 74, 114, 74, 114, 230, 248, 249, 114, 162, 115,
599+ 116, 76, 250, 76, 73, 74, 73, 73, 218, 116,
600+ 218, 116, 73, 208, 73, 114, 76, 115, 74, 73,
601+ 107, 117, 252, 218, 74, 209, 210, 211, 212, 76,
602+ 117, 102, 117, 1, 281, 76, 193, 216, 118, 99,
603+ 248, 103, 218, 209, 210, 211, 212, 118, 111, 118,
604+ 73, 97, 73, 223, 66, 235, 172, 111, 300, 111,
605+ 66, 324, 119, 120, 271, 73, 119, 173, 158, 37,
606+ 120, 163, 164, 185, 74, 119, 168, 119, 73, 120,
607+ 178, 120, 181, 34, 73, 76, 110, 38, 302, 99,
608+ 242, 243, 291, 2, 3, 4, 5, 6, 7, 8,
609+ 9, 112, 205, 2, 3, 4, 5, 6, 7, 8,
610+ 9, 209, 210, 211, 212, 74, 73, 152, 152, 152,
611+ 152, 152, 152, 152, 116, 152, 76, 152, 122, 152,
612+ 152, 111, 315, 291, 73, 322, 117, 122, 248, 122,
613+ 111, 323, 111, 125, 125, 125, 125, 125, 125, 125,
614+ 125, 125, 125, 255, 125, 125, 223, 125, 125, 125,
615+ 125, 125, 118, 260, 261, 262, 263, 122, 264, 265,
616+ 209, 210, 211, 212, 272, 73, 273, 125, 209, 210,
617+ 211, 212, 238, 121, 121, 274, 125, 125, 211, 212,
618+ 296, 279, 325, 121, 125, 121, 123, 124, 326, 125,
619+ 285, 124, 124, 124, 124, 124, 124, 124, 124, 124,
620+ 124, 126, 124, 124, 127, 124, 124, 124, 124, 124,
621+ 137, 138, 54, 139, 128, 140, 141, 142, 143, 177,
622+ 61, 144, 167, 145, 167, 124, 209, 210, 211, 212,
623+ 146, 147, 133, 257, 124, 124, 148, 129, 170, 53,
624+ 53, 130, 124, 149, 150, 209, 210, 211, 212, 94,
625+ 97, 151, 69, 152, 299, 131, 137, 138, 54, 139,
626+ 71, 140, 141, 142, 143, 330, 61, 144, 134, 145,
627+ 136, 237, 54, 54, 136, 136, 146, 147, 136, 136,
628+ 284, 136, 148, 136, 199, 136, 136, 64, 102, 149,
629+ 150, 177, 200, 64, 102, 94, 97, 151, 69, 152,
630+ 214, 215, 137, 138, 54, 139, 71, 140, 141, 142,
631+ 143, 231, 61, 144, 234, 145, 184, 246, 251, 266,
632+ 137, 137, 146, 147, 137, 137, 270, 137, 148, 137,
633+ 269, 137, 137, 267, 271, 149, 150, 276, 278, 280,
634+ 283, 94, 97, 151, 69, 152, 286, 288, 137, 138,
635+ 54, 139, 71, 140, 141, 190, 143, 294, 191, 144,
636+ 192, 63, 64, 65, 66, 298, 153, 153, 153, 153,
637+ 153, 153, 153, 253, 153, 295, 153, 297, 153, 153,
638+ 134, 68, 134, 237, 139, 139, 134, 139, 307, 139,
639+ 69, 139, 139, 310, 137, 138, 54, 139, 71, 140,
640+ 141, 190, 143, 313, 191, 144, 192, 63, 64, 65,
641+ 66, 314, 137, 138, 54, 139, 320, 140, 141, 142,
642+ 143, 290, 61, 144, 321, 145, 327, 68, 2, 3,
643+ 4, 5, 6, 7, 8, 9, 69, 308, 328, 331,
644+ 133, 181, 133, 152, 71, 68, 133, 57, 161, 56,
645+ 137, 138, 54, 139, 69, 140, 141, 142, 143, 132,
646+ 61, 144, 71, 145, 137, 138, 54, 139, 160, 140,
647+ 141, 142, 143, 131, 61, 144, 305, 145, 170, 282,
648+ 16, 30, 275, 171, 18, 19, 20, 21, 22, 217,
649+ 202, 204, 69, 206, 207, 303, 13, 68, 287, 268,
650+ 71, 304, 137, 138, 54, 139, 69, 140, 141, 142,
651+ 143, 165, 61, 144, 71, 145, 301, 84, 137, 138,
652+ 54, 139, 277, 140, 141, 142, 143, 219, 61, 220,
653+ 254, 145, 309, 90, 332, 68, 145, 145, 145, 145,
654+ 145, 145, 221, 145, 69, 145, 329, 145, 145, 289,
655+ 0, 0, 71, 17, 17, 17, 17, 17, 97, 0,
656+ 222, 0, 0, 0, 137, 138, 54, 139, 71, 140,
657+ 141, 142, 143, 0, 61, 144, 0, 145, 0, 0,
658+ 137, 138, 54, 139, 0, 140, 141, 142, 143, 239,
659+ 61, 144, 0, 145, 0, 0, 0, 68, 0, 0,
660+ 0, 0, 0, 0, 0, 256, 69, 0, 0, 0,
661+ 0, 0, 0, 68, 71, 0, 0, 0, 137, 138,
662+ 54, 139, 69, 140, 141, 142, 143, 290, 61, 144,
663+ 71, 145, 137, 138, 54, 139, 0, 140, 141, 142,
664+ 143, 0, 61, 144, 0, 145, 0, 0, 0, 0,
665+ 0, 68, 0, 0, 0, 0, 137, 138, 54, 139,
666+ 69, 140, 141, 142, 143, 68, 61, 144, 71, 145,
667+ 0, 0, 0, 0, 69, 0, 0, 0, 0, 0,
668+ 0, 0, 71, 17, 18, 19, 20, 21, 22, 23,
669+ 24, 0, 0, 0, 0, 0, 0, 0, 69, 0,
670+ 0, 0, 0, 0, 0, 0, 71, 17, 17, 17,
671+ 17, 17, 17, 17, 17, 16, 16, 16, 16, 16,
672+ 16, 16, 16,
673+};
674+static const YYINT _xkbcommon_check[] = { 46,
675+ 53, 53, 127, 183, 51, 57, 63, 59, 53, 46,
676+ 46, 58, 52, 47, 71, 52, 50, 46, 52, 59,
677+ 60, 68, 62, 46, 10, 11, 12, 13, 14, 52,
678+ 45, 45, 72, 32, 49, 20, 21, 22, 23, 24,
679+ 25, 26, 27, 28, 29, 45, 31, 32, 63, 34,
680+ 35, 36, 37, 38, 45, 123, 71, 60, 110, 46,
681+ 46, 129, 61, 63, 63, 60, 61, 32, 136, 54,
682+ 45, 71, 119, 64, 121, 53, 123, 124, 63, 64,
683+ 45, 40, 129, 130, 131, 121, 71, 123, 124, 136,
684+ 49, 60, 51, 129, 40, 131, 61, 42, 63, 60,
685+ 136, 60, 131, 49, 284, 51, 41, 42, 43, 44,
686+ 146, 147, 40, 149, 150, 50, 61, 62, 170, 46,
687+ 167, 49, 169, 51, 171, 52, 46, 49, 115, 51,
688+ 40, 167, 52, 169, 121, 182, 123, 124, 167, 49,
689+ 169, 51, 129, 47, 131, 49, 182, 51, 195, 136,
690+ 190, 40, 192, 182, 201, 41, 42, 43, 44, 195,
691+ 49, 64, 51, 0, 46, 201, 195, 53, 40, 221,
692+ 52, 64, 201, 41, 42, 43, 44, 49, 40, 51,
693+ 167, 61, 169, 170, 46, 53, 233, 49, 46, 51,
694+ 52, 316, 52, 53, 52, 182, 40, 233, 114, 46,
695+ 40, 117, 118, 250, 251, 49, 122, 51, 195, 49,
696+ 126, 51, 128, 31, 201, 251, 28, 35, 271, 271,
697+ 61, 62, 251, 70, 71, 72, 73, 74, 75, 76,
698+ 77, 40, 148, 70, 71, 72, 73, 74, 75, 76,
699+ 77, 41, 42, 43, 44, 292, 233, 40, 41, 42,
700+ 43, 44, 45, 46, 53, 48, 292, 50, 40, 52,
701+ 53, 40, 46, 292, 251, 46, 40, 49, 52, 51,
702+ 49, 52, 51, 20, 21, 22, 23, 24, 25, 26,
703+ 27, 28, 29, 199, 31, 32, 273, 34, 35, 36,
704+ 37, 38, 40, 209, 210, 211, 212, 41, 214, 215,
705+ 41, 42, 43, 44, 50, 292, 52, 54, 41, 42,
706+ 43, 44, 53, 45, 40, 231, 63, 64, 43, 44,
707+ 53, 237, 46, 49, 71, 51, 45, 45, 52, 40,
708+ 246, 20, 21, 22, 23, 24, 25, 26, 27, 28,
709+ 29, 40, 31, 32, 45, 34, 35, 36, 37, 38,
710+ 21, 22, 23, 24, 40, 26, 27, 28, 29, 47,
711+ 31, 32, 50, 34, 52, 54, 41, 42, 43, 44,
712+ 41, 42, 53, 48, 63, 64, 47, 45, 49, 52,
713+ 53, 45, 71, 54, 55, 41, 42, 43, 44, 60,
714+ 61, 62, 63, 64, 50, 45, 21, 22, 23, 24,
715+ 71, 26, 27, 28, 29, 46, 31, 32, 61, 34,
716+ 45, 52, 52, 53, 41, 42, 41, 42, 45, 46,
717+ 45, 48, 47, 50, 40, 52, 53, 46, 46, 54,
718+ 55, 64, 53, 52, 52, 60, 61, 62, 63, 64,
719+ 40, 49, 21, 22, 23, 24, 71, 26, 27, 28,
720+ 29, 40, 31, 32, 53, 34, 49, 40, 45, 53,
721+ 41, 42, 41, 42, 45, 46, 50, 48, 47, 50,
722+ 47, 52, 53, 53, 52, 54, 55, 53, 53, 53,
723+ 52, 60, 61, 62, 63, 64, 53, 53, 21, 22,
724+ 23, 24, 71, 26, 27, 28, 29, 45, 31, 32,
725+ 33, 34, 35, 36, 37, 48, 40, 41, 42, 43,
726+ 44, 45, 46, 46, 48, 53, 50, 53, 52, 53,
727+ 46, 54, 48, 52, 45, 46, 52, 48, 45, 50,
728+ 63, 52, 53, 64, 21, 22, 23, 24, 71, 26,
729+ 27, 28, 29, 48, 31, 32, 33, 34, 35, 36,
730+ 37, 50, 21, 22, 23, 24, 53, 26, 27, 28,
731+ 29, 30, 31, 32, 40, 34, 64, 54, 70, 71,
732+ 72, 73, 74, 75, 76, 77, 63, 46, 53, 53,
733+ 46, 45, 48, 40, 71, 54, 52, 45, 50, 45,
734+ 21, 22, 23, 24, 63, 26, 27, 28, 29, 48,
735+ 31, 32, 71, 34, 21, 22, 23, 24, 50, 26,
736+ 27, 28, 29, 48, 31, 32, 283, 34, 49, 241,
737+ 12, 26, 231, 54, 2, 3, 4, 5, 6, 46,
738+ 146, 147, 63, 149, 150, 271, 0, 54, 248, 221,
739+ 71, 273, 21, 22, 23, 24, 63, 26, 27, 28,
740+ 29, 119, 31, 32, 71, 34, 269, 46, 21, 22,
741+ 23, 24, 233, 26, 27, 28, 29, 46, 31, 32,
742+ 195, 34, 292, 46, 326, 54, 41, 42, 43, 44,
743+ 45, 46, 45, 48, 63, 50, 323, 52, 53, 250,
744+ -1, -1, 71, 2, 3, 4, 5, 6, 61, -1,
745+ 63, -1, -1, -1, 21, 22, 23, 24, 71, 26,
746+ 27, 28, 29, -1, 31, 32, -1, 34, -1, -1,
747+ 21, 22, 23, 24, -1, 26, 27, 28, 29, 46,
748+ 31, 32, -1, 34, -1, -1, -1, 54, -1, -1,
749+ -1, -1, -1, -1, -1, 46, 63, -1, -1, -1,
750+ -1, -1, -1, 54, 71, -1, -1, -1, 21, 22,
751+ 23, 24, 63, 26, 27, 28, 29, 30, 31, 32,
752+ 71, 34, 21, 22, 23, 24, -1, 26, 27, 28,
753+ 29, -1, 31, 32, -1, 34, -1, -1, -1, -1,
754+ -1, 54, -1, -1, -1, -1, 21, 22, 23, 24,
755+ 63, 26, 27, 28, 29, 54, 31, 32, 71, 34,
756+ -1, -1, -1, -1, 63, -1, -1, -1, -1, -1,
757+ -1, -1, 71, 1, 2, 3, 4, 5, 6, 7,
758+ 8, -1, -1, -1, -1, -1, -1, -1, 63, -1,
759+ -1, -1, -1, -1, -1, -1, 71, 1, 2, 3,
760+ 4, 5, 6, 7, 8, 1, 2, 3, 4, 5,
761+ 6, 7, 8,
762+};
763+#if YYBTYACC
764+static const YYINT _xkbcommon_ctable[] = { -1,
765+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
766+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
767+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
768+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
769+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
770+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
771+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
772+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
773+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
774+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
775+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
776+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
777+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
778+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
779+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
780+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
781+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
782+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
783+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
784+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
785+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
786+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
787+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
788+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
789+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
790+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
791+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
792+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
793+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
794+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
795+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
796+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
797+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
798+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
799+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
800+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
801+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
802+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
803+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
804+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
805+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
806+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
807+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
808+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
809+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
810+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
811+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
812+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
813+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
814+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
815+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
816+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
817+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
818+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
819+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
820+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
821+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
822+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
823+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
824+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
825+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
826+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
827+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
828+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
829+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
830+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
831+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
832+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
833+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
834+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
835+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
836+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
837+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
838+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
839+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
840+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
841+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
842+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
843+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
844+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
845+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
846+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
847+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
848+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
849+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
850+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
851+ -1, -1,
852+};
853+#endif
854+#define YYFINAL 10
855+#ifndef YYDEBUG
856+#define YYDEBUG 0
857+#endif
858+#define YYMAXTOKEN 256
859+#define YYUNDFTOKEN 329
860+#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
861+#if YYDEBUG
862+static const char *const _xkbcommon_name[] = {
863+
864+"$end","XKB_KEYMAP","XKB_KEYCODES","XKB_TYPES","XKB_SYMBOLS","XKB_COMPATMAP",
865+"XKB_GEOMETRY","XKB_SEMANTICS","XKB_LAYOUT",0,"INCLUDE","OVERRIDE","AUGMENT",
866+"REPLACE","ALTERNATE",0,0,0,0,0,"VIRTUAL_MODS","TYPE","INTERPRET","ACTION_TOK",
867+"KEY","ALIAS","GROUP","MODIFIER_MAP","INDICATOR","SHAPE","KEYS","ROW","SECTION",
868+"OVERLAY","TEXT","OUTLINE","SOLID","LOGO","VIRTUAL",0,"EQUALS","PLUS","MINUS",
869+"DIVIDE","TIMES","OBRACE","CBRACE","OPAREN","CPAREN","OBRACKET","CBRACKET",
870+"DOT","COMMA","SEMI","EXCLAM","INVERT",0,0,0,0,"STRING","INTEGER","FLOAT",
871+"IDENT","KEYNAME",0,0,0,0,0,"PARTIAL","DEFAULT","HIDDEN","ALPHANUMERIC_KEYS",
872+"MODIFIER_KEYS","KEYPAD_KEYS","FUNCTION_KEYS","ALTERNATE_GROUP",0,0,0,0,0,0,0,0,
873+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
874+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
875+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
876+0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
877+0,0,0,0,0,0,0,0,0,"ERROR_TOK","error","$accept","XkbFile","KeyCode","Number",
878+"Integer","Float","SignedNumber","DoodadType","MergeMode","OptMergeMode",
879+"XkbCompositeType","FileType","Flag","Flags","OptFlags","MapName","OptMapName",
880+"FieldSpec","Ident","Element","String","KeySym","Decl","DeclList","Expr","Term",
881+"Lhs","Terminal","ArrayInit","KeySyms","OptKeySymList","KeySymList","Action",
882+"Coord","CoordList","OptExprList","ExprList","ActionList","VarDecl",
883+"SymbolsVarDecl","VarDeclList","SymbolsBody","VModDef","VModDefList","VModDecl",
884+"InterpretDecl","InterpretMatch","KeyTypeDecl","SymbolsDecl","ModMapDecl",
885+"GroupCompatDecl","LedMapDecl","LedNameDecl","KeyNameDecl","KeyAliasDecl",
886+"ShapeDecl","SectionDecl","SectionBody","SectionBodyItem","RowBody",
887+"RowBodyItem","Keys","Key","OverlayDecl","OverlayKeyList","OverlayKey",
888+"OutlineList","OutlineInList","DoodadDecl","XkbMapConfig","XkbMapConfigList",
889+"XkbCompositeMap","illegal-symbol",
890+};
891+static const char *const _xkbcommon_rule[] = {
892+"$accept : XkbFile",
893+"XkbFile : XkbCompositeMap",
894+"XkbFile : XkbMapConfig",
895+"XkbFile : END_OF_FILE",
896+"XkbCompositeMap : OptFlags XkbCompositeType OptMapName OBRACE XkbMapConfigList CBRACE SEMI",
897+"XkbCompositeType : XKB_KEYMAP",
898+"XkbCompositeType : XKB_SEMANTICS",
899+"XkbCompositeType : XKB_LAYOUT",
900+"XkbMapConfigList : XkbMapConfigList XkbMapConfig",
901+"XkbMapConfigList : XkbMapConfig",
902+"XkbMapConfig : OptFlags FileType OptMapName OBRACE DeclList CBRACE SEMI",
903+"FileType : XKB_KEYCODES",
904+"FileType : XKB_TYPES",
905+"FileType : XKB_COMPATMAP",
906+"FileType : XKB_SYMBOLS",
907+"FileType : XKB_GEOMETRY",
908+"OptFlags : Flags",
909+"OptFlags :",
910+"Flags : Flags Flag",
911+"Flags : Flag",
912+"Flag : PARTIAL",
913+"Flag : DEFAULT",
914+"Flag : HIDDEN",
915+"Flag : ALPHANUMERIC_KEYS",
916+"Flag : MODIFIER_KEYS",
917+"Flag : KEYPAD_KEYS",
918+"Flag : FUNCTION_KEYS",
919+"Flag : ALTERNATE_GROUP",
920+"DeclList : DeclList Decl",
921+"DeclList : DeclList OptMergeMode VModDecl",
922+"DeclList :",
923+"Decl : OptMergeMode VarDecl",
924+"Decl : OptMergeMode InterpretDecl",
925+"Decl : OptMergeMode KeyNameDecl",
926+"Decl : OptMergeMode KeyAliasDecl",
927+"Decl : OptMergeMode KeyTypeDecl",
928+"Decl : OptMergeMode SymbolsDecl",
929+"Decl : OptMergeMode ModMapDecl",
930+"Decl : OptMergeMode GroupCompatDecl",
931+"Decl : OptMergeMode LedMapDecl",
932+"Decl : OptMergeMode LedNameDecl",
933+"Decl : OptMergeMode ShapeDecl",
934+"Decl : OptMergeMode SectionDecl",
935+"Decl : OptMergeMode DoodadDecl",
936+"Decl : MergeMode STRING",
937+"VarDecl : Lhs EQUALS Expr SEMI",
938+"VarDecl : Ident SEMI",
939+"VarDecl : EXCLAM Ident SEMI",
940+"KeyNameDecl : KEYNAME EQUALS KeyCode SEMI",
941+"KeyAliasDecl : ALIAS KEYNAME EQUALS KEYNAME SEMI",
942+"VModDecl : VIRTUAL_MODS VModDefList SEMI",
943+"VModDefList : VModDefList COMMA VModDef",
944+"VModDefList : VModDef",
945+"VModDef : Ident",
946+"VModDef : Ident EQUALS Expr",
947+"InterpretDecl : INTERPRET InterpretMatch OBRACE VarDeclList CBRACE SEMI",
948+"InterpretMatch : KeySym PLUS Expr",
949+"InterpretMatch : KeySym",
950+"VarDeclList : VarDeclList VarDecl",
951+"VarDeclList : VarDecl",
952+"KeyTypeDecl : TYPE String OBRACE VarDeclList CBRACE SEMI",
953+"SymbolsDecl : KEY KEYNAME OBRACE SymbolsBody CBRACE SEMI",
954+"SymbolsBody : SymbolsBody COMMA SymbolsVarDecl",
955+"SymbolsBody : SymbolsVarDecl",
956+"SymbolsVarDecl : Lhs EQUALS Expr",
957+"SymbolsVarDecl : Lhs EQUALS ArrayInit",
958+"SymbolsVarDecl : Ident",
959+"SymbolsVarDecl : EXCLAM Ident",
960+"SymbolsVarDecl : ArrayInit",
961+"ArrayInit : OBRACKET OptKeySymList CBRACKET",
962+"ArrayInit : OBRACKET ActionList CBRACKET",
963+"GroupCompatDecl : GROUP Integer EQUALS Expr SEMI",
964+"ModMapDecl : MODIFIER_MAP Ident OBRACE ExprList CBRACE SEMI",
965+"LedMapDecl : INDICATOR String OBRACE VarDeclList CBRACE SEMI",
966+"LedNameDecl : INDICATOR Integer EQUALS Expr SEMI",
967+"LedNameDecl : VIRTUAL INDICATOR Integer EQUALS Expr SEMI",
968+"ShapeDecl : SHAPE String OBRACE OutlineList CBRACE SEMI",
969+"ShapeDecl : SHAPE String OBRACE CoordList CBRACE SEMI",
970+"SectionDecl : SECTION String OBRACE SectionBody CBRACE SEMI",
971+"SectionBody : SectionBody SectionBodyItem",
972+"SectionBody : SectionBodyItem",
973+"SectionBodyItem : ROW OBRACE RowBody CBRACE SEMI",
974+"SectionBodyItem : VarDecl",
975+"SectionBodyItem : DoodadDecl",
976+"SectionBodyItem : LedMapDecl",
977+"SectionBodyItem : OverlayDecl",
978+"RowBody : RowBody RowBodyItem",
979+"RowBody : RowBodyItem",
980+"RowBodyItem : KEYS OBRACE Keys CBRACE SEMI",
981+"RowBodyItem : VarDecl",
982+"Keys : Keys COMMA Key",
983+"Keys : Key",
984+"Key : KEYNAME",
985+"Key : OBRACE ExprList CBRACE",
986+"OverlayDecl : OVERLAY String OBRACE OverlayKeyList CBRACE SEMI",
987+"OverlayKeyList : OverlayKeyList COMMA OverlayKey",
988+"OverlayKeyList : OverlayKey",
989+"OverlayKey : KEYNAME EQUALS KEYNAME",
990+"OutlineList : OutlineList COMMA OutlineInList",
991+"OutlineList : OutlineInList",
992+"OutlineInList : OBRACE CoordList CBRACE",
993+"OutlineInList : Ident EQUALS OBRACE CoordList CBRACE",
994+"OutlineInList : Ident EQUALS Expr",
995+"CoordList : CoordList COMMA Coord",
996+"CoordList : Coord",
997+"Coord : OBRACKET SignedNumber COMMA SignedNumber CBRACKET",
998+"DoodadDecl : DoodadType String OBRACE VarDeclList CBRACE SEMI",
999+"DoodadType : TEXT",
1000+"DoodadType : OUTLINE",
1001+"DoodadType : SOLID",
1002+"DoodadType : LOGO",
1003+"FieldSpec : Ident",
1004+"FieldSpec : Element",
1005+"Element : ACTION_TOK",
1006+"Element : INTERPRET",
1007+"Element : TYPE",
1008+"Element : KEY",
1009+"Element : GROUP",
1010+"Element : MODIFIER_MAP",
1011+"Element : INDICATOR",
1012+"Element : SHAPE",
1013+"Element : ROW",
1014+"Element : SECTION",
1015+"Element : TEXT",
1016+"OptMergeMode : MergeMode",
1017+"OptMergeMode :",
1018+"MergeMode : INCLUDE",
1019+"MergeMode : AUGMENT",
1020+"MergeMode : OVERRIDE",
1021+"MergeMode : REPLACE",
1022+"MergeMode : ALTERNATE",
1023+"OptExprList : ExprList",
1024+"OptExprList :",
1025+"ExprList : ExprList COMMA Expr",
1026+"ExprList : Expr",
1027+"Expr : Expr DIVIDE Expr",
1028+"Expr : Expr PLUS Expr",
1029+"Expr : Expr MINUS Expr",
1030+"Expr : Expr TIMES Expr",
1031+"Expr : Lhs EQUALS Expr",
1032+"Expr : Term",
1033+"Term : MINUS Term",
1034+"Term : PLUS Term",
1035+"Term : EXCLAM Term",
1036+"Term : INVERT Term",
1037+"Term : Lhs",
1038+"Term : FieldSpec OPAREN OptExprList CPAREN",
1039+"Term : Terminal",
1040+"Term : OPAREN Expr CPAREN",
1041+"ActionList : ActionList COMMA Action",
1042+"ActionList : Action",
1043+"Action : FieldSpec OPAREN OptExprList CPAREN",
1044+"Lhs : FieldSpec",
1045+"Lhs : FieldSpec DOT FieldSpec",
1046+"Lhs : FieldSpec OBRACKET Expr CBRACKET",
1047+"Lhs : FieldSpec DOT FieldSpec OBRACKET Expr CBRACKET",
1048+"Terminal : String",
1049+"Terminal : Integer",
1050+"Terminal : Float",
1051+"Terminal : KEYNAME",
1052+"OptKeySymList : KeySymList",
1053+"OptKeySymList :",
1054+"KeySymList : KeySymList COMMA KeySym",
1055+"KeySymList : KeySymList COMMA KeySyms",
1056+"KeySymList : KeySym",
1057+"KeySymList : KeySyms",
1058+"KeySyms : OBRACE KeySymList CBRACE",
1059+"KeySym : IDENT",
1060+"KeySym : SECTION",
1061+"KeySym : Integer",
1062+"SignedNumber : MINUS Number",
1063+"SignedNumber : Number",
1064+"Number : FLOAT",
1065+"Number : INTEGER",
1066+"Float : FLOAT",
1067+"Integer : INTEGER",
1068+"KeyCode : INTEGER",
1069+"Ident : IDENT",
1070+"Ident : DEFAULT",
1071+"String : STRING",
1072+"OptMapName : MapName",
1073+"OptMapName :",
1074+"MapName : STRING",
1075+
1076+};
1077+#endif
1078+
1079+#if YYDEBUG
1080+int yydebug;
1081+#endif
1082+
1083+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1084+#ifndef YYLLOC_DEFAULT
1085+#define YYLLOC_DEFAULT(loc, rhs, n) \
1086+do \
1087+{ \
1088+ if (n == 0) \
1089+ { \
1090+ (loc).first_line = YYRHSLOC(rhs, 0).last_line; \
1091+ (loc).first_column = YYRHSLOC(rhs, 0).last_column; \
1092+ (loc).last_line = YYRHSLOC(rhs, 0).last_line; \
1093+ (loc).last_column = YYRHSLOC(rhs, 0).last_column; \
1094+ } \
1095+ else \
1096+ { \
1097+ (loc).first_line = YYRHSLOC(rhs, 1).first_line; \
1098+ (loc).first_column = YYRHSLOC(rhs, 1).first_column; \
1099+ (loc).last_line = YYRHSLOC(rhs, n).last_line; \
1100+ (loc).last_column = YYRHSLOC(rhs, n).last_column; \
1101+ } \
1102+} while (0)
1103+#endif /* YYLLOC_DEFAULT */
1104+#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1105+#if YYBTYACC
1106+
1107+#ifndef YYLVQUEUEGROWTH
1108+#define YYLVQUEUEGROWTH 32
1109+#endif
1110+#endif /* YYBTYACC */
1111+
1112+/* define the initial stack-sizes */
1113+#ifdef YYSTACKSIZE
1114+#undef YYMAXDEPTH
1115+#define YYMAXDEPTH YYSTACKSIZE
1116+#else
1117+#ifdef YYMAXDEPTH
1118+#define YYSTACKSIZE YYMAXDEPTH
1119+#else
1120+#define YYSTACKSIZE 10000
1121+#define YYMAXDEPTH 10000
1122+#endif
1123+#endif
1124+
1125+#ifndef YYINITSTACKSIZE
1126+#define YYINITSTACKSIZE 200
1127+#endif
1128+
1129+typedef struct {
1130+ unsigned stacksize;
1131+ YYINT *s_base;
1132+ YYINT *s_mark;
1133+ YYINT *s_last;
1134+ YYSTYPE *l_base;
1135+ YYSTYPE *l_mark;
1136+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1137+ YYLTYPE *p_base;
1138+ YYLTYPE *p_mark;
1139+#endif
1140+} YYSTACKDATA;
1141+#if YYBTYACC
1142+
1143+struct YYParseState_s
1144+{
1145+ struct YYParseState_s *save; /* Previously saved parser state */
1146+ YYSTACKDATA yystack; /* saved parser stack */
1147+ int state; /* saved parser state */
1148+ int errflag; /* saved error recovery status */
1149+ int lexeme; /* saved index of the conflict lexeme in the lexical queue */
1150+ YYINT ctry; /* saved index in yyctable[] for this conflict */
1151+};
1152+typedef struct YYParseState_s YYParseState;
1153+#endif /* YYBTYACC */
1154+#line 808 "parser.y"
1155+
1156+XkbFile *
1157+parse(struct xkb_context *ctx, struct scanner *scanner, const char *map)
1158+{
1159+ int ret;
1160+ XkbFile *first = NULL;
1161+ struct parser_param param = {
1162+ .scanner = scanner,
1163+ .ctx = ctx,
1164+ .rtrn = NULL,
1165+ .more_maps = false,
1166+ };
1167+
1168+ /*
1169+ * If we got a specific map, we look for it exclusively and return
1170+ * immediately upon finding it. Otherwise, we need to get the
1171+ * default map. If we find a map marked as default, we return it
1172+ * immediately. If there are no maps marked as default, we return
1173+ * the first map in the file.
1174+ */
1175+
1176+ while ((ret = yyparse(¶m)) == 0 && param.more_maps) {
1177+ if (map) {
1178+ if (streq_not_null(map, param.rtrn->name))
1179+ return param.rtrn;
1180+ else
1181+ FreeXkbFile(param.rtrn);
1182+ }
1183+ else {
1184+ if (param.rtrn->flags & MAP_IS_DEFAULT) {
1185+ FreeXkbFile(first);
1186+ return param.rtrn;
1187+ }
1188+ else if (!first) {
1189+ first = param.rtrn;
1190+ }
1191+ else {
1192+ FreeXkbFile(param.rtrn);
1193+ }
1194+ }
1195+ param.rtrn = NULL;
1196+ }
1197+
1198+ if (ret != 0) {
1199+ FreeXkbFile(first);
1200+ return NULL;
1201+ }
1202+
1203+ if (first)
1204+ log_vrb(ctx, 5,
1205+ XKB_WARNING_MISSING_DEFAULT_SECTION,
1206+ "No map in include statement, but \"%s\" contains several; "
1207+ "Using first defined map, \"%s\"\n",
1208+ scanner->file_name, first->name);
1209+
1210+ return first;
1211+}
1212+#line 1192 "parser.c"
1213+
1214+/* Release memory associated with symbol. */
1215+#if ! defined YYDESTRUCT_IS_DECLARED
1216+static void
1217+YYDESTRUCT_DECL()
1218+{
1219+ switch (psymb)
1220+ {
1221+ case 60:
1222+#line 239 "parser.y"
1223+ { free((*val).str); }
1224+#line 1204 "parser.c"
1225+ break;
1226+ case 63:
1227+#line 239 "parser.y"
1228+ { free((*val).str); }
1229+#line 1209 "parser.c"
1230+ break;
1231+ case 258:
1232+#line 237 "parser.y"
1233+ { if (!param->rtrn) FreeXkbFile((*val).file); }
1234+#line 1214 "parser.c"
1235+ break;
1236+ case 272:
1237+#line 239 "parser.y"
1238+ { free((*val).str); }
1239+#line 1219 "parser.c"
1240+ break;
1241+ case 273:
1242+#line 239 "parser.y"
1243+ { free((*val).str); }
1244+#line 1224 "parser.c"
1245+ break;
1246+ case 279:
1247+#line 230 "parser.y"
1248+ { FreeStmt((ParseCommon *) (*val).any); }
1249+#line 1229 "parser.c"
1250+ break;
1251+ case 280:
1252+#line 233 "parser.y"
1253+ { FreeStmt((ParseCommon *) (*val).anyList.head); }
1254+#line 1234 "parser.c"
1255+ break;
1256+ case 281:
1257+#line 230 "parser.y"
1258+ { FreeStmt((ParseCommon *) (*val).expr); }
1259+#line 1239 "parser.c"
1260+ break;
1261+ case 282:
1262+#line 230 "parser.y"
1263+ { FreeStmt((ParseCommon *) (*val).expr); }
1264+#line 1244 "parser.c"
1265+ break;
1266+ case 283:
1267+#line 230 "parser.y"
1268+ { FreeStmt((ParseCommon *) (*val).expr); }
1269+#line 1249 "parser.c"
1270+ break;
1271+ case 284:
1272+#line 230 "parser.y"
1273+ { FreeStmt((ParseCommon *) (*val).expr); }
1274+#line 1254 "parser.c"
1275+ break;
1276+ case 285:
1277+#line 230 "parser.y"
1278+ { FreeStmt((ParseCommon *) (*val).expr); }
1279+#line 1259 "parser.c"
1280+ break;
1281+ case 286:
1282+#line 230 "parser.y"
1283+ { FreeStmt((ParseCommon *) (*val).expr); }
1284+#line 1264 "parser.c"
1285+ break;
1286+ case 287:
1287+#line 230 "parser.y"
1288+ { FreeStmt((ParseCommon *) (*val).expr); }
1289+#line 1269 "parser.c"
1290+ break;
1291+ case 288:
1292+#line 230 "parser.y"
1293+ { FreeStmt((ParseCommon *) (*val).expr); }
1294+#line 1274 "parser.c"
1295+ break;
1296+ case 289:
1297+#line 230 "parser.y"
1298+ { FreeStmt((ParseCommon *) (*val).expr); }
1299+#line 1279 "parser.c"
1300+ break;
1301+ case 290:
1302+#line 230 "parser.y"
1303+ { FreeStmt((ParseCommon *) (*val).expr); }
1304+#line 1284 "parser.c"
1305+ break;
1306+ case 291:
1307+#line 230 "parser.y"
1308+ { FreeStmt((ParseCommon *) (*val).expr); }
1309+#line 1289 "parser.c"
1310+ break;
1311+ case 292:
1312+#line 233 "parser.y"
1313+ { FreeStmt((ParseCommon *) (*val).exprList.head); }
1314+#line 1294 "parser.c"
1315+ break;
1316+ case 293:
1317+#line 233 "parser.y"
1318+ { FreeStmt((ParseCommon *) (*val).exprList.head); }
1319+#line 1299 "parser.c"
1320+ break;
1321+ case 294:
1322+#line 233 "parser.y"
1323+ { FreeStmt((ParseCommon *) (*val).exprList.head); }
1324+#line 1304 "parser.c"
1325+ break;
1326+ case 295:
1327+#line 230 "parser.y"
1328+ { FreeStmt((ParseCommon *) (*val).var); }
1329+#line 1309 "parser.c"
1330+ break;
1331+ case 296:
1332+#line 230 "parser.y"
1333+ { FreeStmt((ParseCommon *) (*val).var); }
1334+#line 1314 "parser.c"
1335+ break;
1336+ case 297:
1337+#line 233 "parser.y"
1338+ { FreeStmt((ParseCommon *) (*val).varList.head); }
1339+#line 1319 "parser.c"
1340+ break;
1341+ case 298:
1342+#line 233 "parser.y"
1343+ { FreeStmt((ParseCommon *) (*val).varList.head); }
1344+#line 1324 "parser.c"
1345+ break;
1346+ case 299:
1347+#line 230 "parser.y"
1348+ { FreeStmt((ParseCommon *) (*val).vmod); }
1349+#line 1329 "parser.c"
1350+ break;
1351+ case 300:
1352+#line 233 "parser.y"
1353+ { FreeStmt((ParseCommon *) (*val).vmodList.head); }
1354+#line 1334 "parser.c"
1355+ break;
1356+ case 301:
1357+#line 233 "parser.y"
1358+ { FreeStmt((ParseCommon *) (*val).vmodList.head); }
1359+#line 1339 "parser.c"
1360+ break;
1361+ case 302:
1362+#line 230 "parser.y"
1363+ { FreeStmt((ParseCommon *) (*val).interp); }
1364+#line 1344 "parser.c"
1365+ break;
1366+ case 303:
1367+#line 230 "parser.y"
1368+ { FreeStmt((ParseCommon *) (*val).interp); }
1369+#line 1349 "parser.c"
1370+ break;
1371+ case 304:
1372+#line 230 "parser.y"
1373+ { FreeStmt((ParseCommon *) (*val).keyType); }
1374+#line 1354 "parser.c"
1375+ break;
1376+ case 305:
1377+#line 230 "parser.y"
1378+ { FreeStmt((ParseCommon *) (*val).syms); }
1379+#line 1359 "parser.c"
1380+ break;
1381+ case 306:
1382+#line 230 "parser.y"
1383+ { FreeStmt((ParseCommon *) (*val).modMask); }
1384+#line 1364 "parser.c"
1385+ break;
1386+ case 307:
1387+#line 230 "parser.y"
1388+ { FreeStmt((ParseCommon *) (*val).groupCompat); }
1389+#line 1369 "parser.c"
1390+ break;
1391+ case 308:
1392+#line 230 "parser.y"
1393+ { FreeStmt((ParseCommon *) (*val).ledMap); }
1394+#line 1374 "parser.c"
1395+ break;
1396+ case 309:
1397+#line 230 "parser.y"
1398+ { FreeStmt((ParseCommon *) (*val).ledName); }
1399+#line 1379 "parser.c"
1400+ break;
1401+ case 310:
1402+#line 230 "parser.y"
1403+ { FreeStmt((ParseCommon *) (*val).keyCode); }
1404+#line 1384 "parser.c"
1405+ break;
1406+ case 311:
1407+#line 230 "parser.y"
1408+ { FreeStmt((ParseCommon *) (*val).keyAlias); }
1409+#line 1389 "parser.c"
1410+ break;
1411+ case 326:
1412+#line 237 "parser.y"
1413+ { if (!param->rtrn) FreeXkbFile((*val).file); }
1414+#line 1394 "parser.c"
1415+ break;
1416+ case 327:
1417+#line 238 "parser.y"
1418+ { FreeXkbFile((*val).fileList.head); }
1419+#line 1399 "parser.c"
1420+ break;
1421+ case 328:
1422+#line 237 "parser.y"
1423+ { if (!param->rtrn) FreeXkbFile((*val).file); }
1424+#line 1404 "parser.c"
1425+ break;
1426+ }
1427+}
1428+#define YYDESTRUCT_IS_DECLARED 1
1429+#endif
1430+
1431+/* For use in generated program */
1432+#define yydepth (int)(yystack.s_mark - yystack.s_base)
1433+#if YYBTYACC
1434+#define yytrial (yyps->save)
1435+#endif /* YYBTYACC */
1436+
1437+#if YYDEBUG
1438+#include <stdio.h> /* needed for printf */
1439+#endif
1440+
1441+#include <stdlib.h> /* needed for malloc, etc */
1442+#include <string.h> /* needed for memset */
1443+
1444+/* allocate initial stack or double stack size, up to YYMAXDEPTH */
1445+static int yygrowstack(YYSTACKDATA *data)
1446+{
1447+ int i;
1448+ unsigned newsize;
1449+ YYINT *newss;
1450+ YYSTYPE *newvs;
1451+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1452+ YYLTYPE *newps;
1453+#endif
1454+
1455+ if ((newsize = data->stacksize) == 0)
1456+ newsize = YYINITSTACKSIZE;
1457+ else if (newsize >= YYMAXDEPTH)
1458+ return YYENOMEM;
1459+ else if ((newsize *= 2) > YYMAXDEPTH)
1460+ newsize = YYMAXDEPTH;
1461+
1462+ i = (int) (data->s_mark - data->s_base);
1463+ newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
1464+ if (newss == 0)
1465+ return YYENOMEM;
1466+
1467+ data->s_base = newss;
1468+ data->s_mark = newss + i;
1469+
1470+ newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
1471+ if (newvs == 0)
1472+ return YYENOMEM;
1473+
1474+ data->l_base = newvs;
1475+ data->l_mark = newvs + i;
1476+
1477+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1478+ newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
1479+ if (newps == 0)
1480+ return YYENOMEM;
1481+
1482+ data->p_base = newps;
1483+ data->p_mark = newps + i;
1484+#endif
1485+
1486+ data->stacksize = newsize;
1487+ data->s_last = data->s_base + newsize - 1;
1488+
1489+#if YYDEBUG
1490+ if (yydebug)
1491+ fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
1492+#endif
1493+ return 0;
1494+}
1495+
1496+#if YYPURE || defined(YY_NO_LEAKS)
1497+static void yyfreestack(YYSTACKDATA *data)
1498+{
1499+ free(data->s_base);
1500+ free(data->l_base);
1501+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1502+ free(data->p_base);
1503+#endif
1504+ memset(data, 0, sizeof(*data));
1505+}
1506+#else
1507+#define yyfreestack(data) /* nothing */
1508+#endif /* YYPURE || defined(YY_NO_LEAKS) */
1509+#if YYBTYACC
1510+
1511+static YYParseState *
1512+yyNewState(unsigned size)
1513+{
1514+ YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
1515+ if (p == NULL) return NULL;
1516+
1517+ p->yystack.stacksize = size;
1518+ if (size == 0)
1519+ {
1520+ p->yystack.s_base = NULL;
1521+ p->yystack.l_base = NULL;
1522+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1523+ p->yystack.p_base = NULL;
1524+#endif
1525+ return p;
1526+ }
1527+ p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT));
1528+ if (p->yystack.s_base == NULL) return NULL;
1529+ p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
1530+ if (p->yystack.l_base == NULL) return NULL;
1531+ memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
1532+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1533+ p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
1534+ if (p->yystack.p_base == NULL) return NULL;
1535+ memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
1536+#endif
1537+
1538+ return p;
1539+}
1540+
1541+static void
1542+yyFreeState(YYParseState *p)
1543+{
1544+ yyfreestack(&p->yystack);
1545+ free(p);
1546+}
1547+#endif /* YYBTYACC */
1548+
1549+#define YYABORT goto yyabort
1550+#define YYREJECT goto yyabort
1551+#define YYACCEPT goto yyaccept
1552+#define YYERROR goto yyerrlab
1553+#if YYBTYACC
1554+#define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
1555+#define YYVALID_NESTED do { if (yyps->save && \
1556+ yyps->save->save == 0) goto yyvalid; } while(0)
1557+#endif /* YYBTYACC */
1558+
1559+int
1560+YYPARSE_DECL()
1561+{
1562+ int yyerrflag;
1563+ int yychar;
1564+ YYSTYPE yyval;
1565+ YYSTYPE yylval;
1566+ int yynerrs;
1567+
1568+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1569+ YYLTYPE yyloc; /* position returned by actions */
1570+ YYLTYPE yylloc; /* position from the lexer */
1571+#endif
1572+
1573+ /* variables for the parser stack */
1574+ YYSTACKDATA yystack;
1575+#if YYBTYACC
1576+
1577+ /* Current parser state */
1578+ static YYParseState *yyps = 0;
1579+
1580+ /* yypath != NULL: do the full parse, starting at *yypath parser state. */
1581+ static YYParseState *yypath = 0;
1582+
1583+ /* Base of the lexical value queue */
1584+ static YYSTYPE *yylvals = 0;
1585+
1586+ /* Current position at lexical value queue */
1587+ static YYSTYPE *yylvp = 0;
1588+
1589+ /* End position of lexical value queue */
1590+ static YYSTYPE *yylve = 0;
1591+
1592+ /* The last allocated position at the lexical value queue */
1593+ static YYSTYPE *yylvlim = 0;
1594+
1595+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1596+ /* Base of the lexical position queue */
1597+ static YYLTYPE *yylpsns = 0;
1598+
1599+ /* Current position at lexical position queue */
1600+ static YYLTYPE *yylpp = 0;
1601+
1602+ /* End position of lexical position queue */
1603+ static YYLTYPE *yylpe = 0;
1604+
1605+ /* The last allocated position at the lexical position queue */
1606+ static YYLTYPE *yylplim = 0;
1607+#endif
1608+
1609+ /* Current position at lexical token queue */
1610+ static YYINT *yylexp = 0;
1611+
1612+ static YYINT *yylexemes = 0;
1613+#endif /* YYBTYACC */
1614+ int yym, yyn, yystate, yyresult;
1615+#if YYBTYACC
1616+ int yynewerrflag;
1617+ YYParseState *yyerrctx = NULL;
1618+#endif /* YYBTYACC */
1619+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1620+ YYLTYPE yyerror_loc_range[3]; /* position of error start/end (0 unused) */
1621+#endif
1622+#if YYDEBUG
1623+ const char *yys;
1624+
1625+ if ((yys = getenv("YYDEBUG")) != 0)
1626+ {
1627+ yyn = *yys;
1628+ if (yyn >= '0' && yyn <= '9')
1629+ yydebug = yyn - '0';
1630+ }
1631+ if (yydebug)
1632+ fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
1633+#endif
1634+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1635+ memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range));
1636+#endif
1637+
1638+ yyerrflag = 0;
1639+ yychar = 0;
1640+ memset(&yyval, 0, sizeof(yyval));
1641+ memset(&yylval, 0, sizeof(yylval));
1642+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1643+ memset(&yyloc, 0, sizeof(yyloc));
1644+ memset(&yylloc, 0, sizeof(yylloc));
1645+#endif
1646+
1647+#if YYBTYACC
1648+ yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
1649+ yyps->save = 0;
1650+#endif /* YYBTYACC */
1651+ yym = 0;
1652+ /* yyn is set below */
1653+ yynerrs = 0;
1654+ yyerrflag = 0;
1655+ yychar = YYEMPTY;
1656+ yystate = 0;
1657+
1658+#if YYPURE
1659+ memset(&yystack, 0, sizeof(yystack));
1660+#endif
1661+
1662+ if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1663+ yystack.s_mark = yystack.s_base;
1664+ yystack.l_mark = yystack.l_base;
1665+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1666+ yystack.p_mark = yystack.p_base;
1667+#endif
1668+ yystate = 0;
1669+ *yystack.s_mark = 0;
1670+
1671+yyloop:
1672+ if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
1673+ if (yychar < 0)
1674+ {
1675+#if YYBTYACC
1676+ do {
1677+ if (yylvp < yylve)
1678+ {
1679+ /* we're currently re-reading tokens */
1680+ yylval = *yylvp++;
1681+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1682+ yylloc = *yylpp++;
1683+#endif
1684+ yychar = *yylexp++;
1685+ break;
1686+ }
1687+ if (yyps->save)
1688+ {
1689+ /* in trial mode; save scanner results for future parse attempts */
1690+ if (yylvp == yylvlim)
1691+ { /* Enlarge lexical value queue */
1692+ size_t p = (size_t) (yylvp - yylvals);
1693+ size_t s = (size_t) (yylvlim - yylvals);
1694+
1695+ s += YYLVQUEUEGROWTH;
1696+ if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;
1697+ if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
1698+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1699+ if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
1700+#endif
1701+ yylvp = yylve = yylvals + p;
1702+ yylvlim = yylvals + s;
1703+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1704+ yylpp = yylpe = yylpsns + p;
1705+ yylplim = yylpsns + s;
1706+#endif
1707+ yylexp = yylexemes + p;
1708+ }
1709+ *yylexp = (YYINT) YYLEX;
1710+ *yylvp++ = yylval;
1711+ yylve++;
1712+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1713+ *yylpp++ = yylloc;
1714+ yylpe++;
1715+#endif
1716+ yychar = *yylexp++;
1717+ break;
1718+ }
1719+ /* normal operation, no conflict encountered */
1720+#endif /* YYBTYACC */
1721+ yychar = YYLEX;
1722+#if YYBTYACC
1723+ } while (0);
1724+#endif /* YYBTYACC */
1725+ if (yychar < 0) yychar = YYEOF;
1726+#if YYDEBUG
1727+ if (yydebug)
1728+ {
1729+ if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1730+ fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
1731+ YYDEBUGSTR, yydepth, yystate, yychar, yys);
1732+#ifdef YYSTYPE_TOSTRING
1733+#if YYBTYACC
1734+ if (!yytrial)
1735+#endif /* YYBTYACC */
1736+ fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
1737+#endif
1738+ fputc('\n', stderr);
1739+ }
1740+#endif
1741+ }
1742+#if YYBTYACC
1743+
1744+ /* Do we have a conflict? */
1745+ if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
1746+ yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
1747+ {
1748+ YYINT ctry;
1749+
1750+ if (yypath)
1751+ {
1752+ YYParseState *save;
1753+#if YYDEBUG
1754+ if (yydebug)
1755+ fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
1756+ YYDEBUGSTR, yydepth, yystate);
1757+#endif
1758+ /* Switch to the next conflict context */
1759+ save = yypath;
1760+ yypath = save->save;
1761+ save->save = NULL;
1762+ ctry = save->ctry;
1763+ if (save->state != yystate) YYABORT;
1764+ yyFreeState(save);
1765+
1766+ }
1767+ else
1768+ {
1769+
1770+ /* Unresolved conflict - start/continue trial parse */
1771+ YYParseState *save;
1772+#if YYDEBUG
1773+ if (yydebug)
1774+ {
1775+ fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
1776+ if (yyps->save)
1777+ fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
1778+ else
1779+ fputs("Starting trial parse.\n", stderr);
1780+ }
1781+#endif
1782+ save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
1783+ if (save == NULL) goto yyenomem;
1784+ save->save = yyps->save;
1785+ save->state = yystate;
1786+ save->errflag = yyerrflag;
1787+ save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
1788+ memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1789+ save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
1790+ memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1791+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1792+ save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
1793+ memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1794+#endif
1795+ ctry = yytable[yyn];
1796+ if (yyctable[ctry] == -1)
1797+ {
1798+#if YYDEBUG
1799+ if (yydebug && yychar >= YYEOF)
1800+ fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
1801+#endif
1802+ ctry++;
1803+ }
1804+ save->ctry = ctry;
1805+ if (yyps->save == NULL)
1806+ {
1807+ /* If this is a first conflict in the stack, start saving lexemes */
1808+ if (!yylexemes)
1809+ {
1810+ yylexemes = (YYINT *) malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));
1811+ if (yylexemes == NULL) goto yyenomem;
1812+ yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
1813+ if (yylvals == NULL) goto yyenomem;
1814+ yylvlim = yylvals + YYLVQUEUEGROWTH;
1815+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1816+ yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
1817+ if (yylpsns == NULL) goto yyenomem;
1818+ yylplim = yylpsns + YYLVQUEUEGROWTH;
1819+#endif
1820+ }
1821+ if (yylvp == yylve)
1822+ {
1823+ yylvp = yylve = yylvals;
1824+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1825+ yylpp = yylpe = yylpsns;
1826+#endif
1827+ yylexp = yylexemes;
1828+ if (yychar >= YYEOF)
1829+ {
1830+ *yylve++ = yylval;
1831+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1832+ *yylpe++ = yylloc;
1833+#endif
1834+ *yylexp = (YYINT) yychar;
1835+ yychar = YYEMPTY;
1836+ }
1837+ }
1838+ }
1839+ if (yychar >= YYEOF)
1840+ {
1841+ yylvp--;
1842+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1843+ yylpp--;
1844+#endif
1845+ yylexp--;
1846+ yychar = YYEMPTY;
1847+ }
1848+ save->lexeme = (int) (yylvp - yylvals);
1849+ yyps->save = save;
1850+ }
1851+ if (yytable[yyn] == ctry)
1852+ {
1853+#if YYDEBUG
1854+ if (yydebug)
1855+ fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
1856+ YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
1857+#endif
1858+ if (yychar < 0)
1859+ {
1860+ yylvp++;
1861+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1862+ yylpp++;
1863+#endif
1864+ yylexp++;
1865+ }
1866+ if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
1867+ goto yyoverflow;
1868+ yystate = yyctable[ctry];
1869+ *++yystack.s_mark = (YYINT) yystate;
1870+ *++yystack.l_mark = yylval;
1871+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1872+ *++yystack.p_mark = yylloc;
1873+#endif
1874+ yychar = YYEMPTY;
1875+ if (yyerrflag > 0) --yyerrflag;
1876+ goto yyloop;
1877+ }
1878+ else
1879+ {
1880+ yyn = yyctable[ctry];
1881+ goto yyreduce;
1882+ }
1883+ } /* End of code dealing with conflicts */
1884+#endif /* YYBTYACC */
1885+ if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
1886+ yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
1887+ {
1888+#if YYDEBUG
1889+ if (yydebug)
1890+ fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
1891+ YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
1892+#endif
1893+ if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1894+ yystate = yytable[yyn];
1895+ *++yystack.s_mark = yytable[yyn];
1896+ *++yystack.l_mark = yylval;
1897+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1898+ *++yystack.p_mark = yylloc;
1899+#endif
1900+ yychar = YYEMPTY;
1901+ if (yyerrflag > 0) --yyerrflag;
1902+ goto yyloop;
1903+ }
1904+ if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
1905+ yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
1906+ {
1907+ yyn = yytable[yyn];
1908+ goto yyreduce;
1909+ }
1910+ if (yyerrflag != 0) goto yyinrecovery;
1911+#if YYBTYACC
1912+
1913+ yynewerrflag = 1;
1914+ goto yyerrhandler;
1915+ goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1916+
1917+yyerrlab:
1918+ /* explicit YYERROR from an action -- pop the rhs of the rule reduced
1919+ * before looking for error recovery */
1920+ yystack.s_mark -= yym;
1921+ yystate = *yystack.s_mark;
1922+ yystack.l_mark -= yym;
1923+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1924+ yystack.p_mark -= yym;
1925+#endif
1926+
1927+ yynewerrflag = 0;
1928+yyerrhandler:
1929+ while (yyps->save)
1930+ {
1931+ int ctry;
1932+ YYParseState *save = yyps->save;
1933+#if YYDEBUG
1934+ if (yydebug)
1935+ fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
1936+ YYDEBUGSTR, yydepth, yystate, yyps->save->state,
1937+ (int)(yylvp - yylvals - yyps->save->lexeme));
1938+#endif
1939+ /* Memorize most forward-looking error state in case it's really an error. */
1940+ if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
1941+ {
1942+ /* Free old saved error context state */
1943+ if (yyerrctx) yyFreeState(yyerrctx);
1944+ /* Create and fill out new saved error context state */
1945+ yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
1946+ if (yyerrctx == NULL) goto yyenomem;
1947+ yyerrctx->save = yyps->save;
1948+ yyerrctx->state = yystate;
1949+ yyerrctx->errflag = yyerrflag;
1950+ yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
1951+ memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1952+ yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
1953+ memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1954+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1955+ yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
1956+ memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1957+#endif
1958+ yyerrctx->lexeme = (int) (yylvp - yylvals);
1959+ }
1960+ yylvp = yylvals + save->lexeme;
1961+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1962+ yylpp = yylpsns + save->lexeme;
1963+#endif
1964+ yylexp = yylexemes + save->lexeme;
1965+ yychar = YYEMPTY;
1966+ yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
1967+ memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1968+ yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
1969+ memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1970+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1971+ yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
1972+ memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1973+#endif
1974+ ctry = ++save->ctry;
1975+ yystate = save->state;
1976+ /* We tried shift, try reduce now */
1977+ if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
1978+ yyps->save = save->save;
1979+ save->save = NULL;
1980+ yyFreeState(save);
1981+
1982+ /* Nothing left on the stack -- error */
1983+ if (!yyps->save)
1984+ {
1985+#if YYDEBUG
1986+ if (yydebug)
1987+ fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1988+ YYPREFIX, yydepth);
1989+#endif
1990+ /* Restore state as it was in the most forward-advanced error */
1991+ yylvp = yylvals + yyerrctx->lexeme;
1992+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1993+ yylpp = yylpsns + yyerrctx->lexeme;
1994+#endif
1995+ yylexp = yylexemes + yyerrctx->lexeme;
1996+ yychar = yylexp[-1];
1997+ yylval = yylvp[-1];
1998+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1999+ yylloc = yylpp[-1];
2000+#endif
2001+ yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
2002+ memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
2003+ yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
2004+ memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
2005+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2006+ yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
2007+ memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
2008+#endif
2009+ yystate = yyerrctx->state;
2010+ yyFreeState(yyerrctx);
2011+ yyerrctx = NULL;
2012+ }
2013+ yynewerrflag = 1;
2014+ }
2015+ if (yynewerrflag == 0) goto yyinrecovery;
2016+#endif /* YYBTYACC */
2017+
2018+ YYERROR_CALL("syntax error");
2019+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2020+ yyerror_loc_range[1] = yylloc; /* lookahead position is error start position */
2021+#endif
2022+
2023+#if !YYBTYACC
2024+ goto yyerrlab; /* redundant goto avoids 'unused label' warning */
2025+yyerrlab:
2026+#endif
2027+ ++yynerrs;
2028+
2029+yyinrecovery:
2030+ if (yyerrflag < 3)
2031+ {
2032+ yyerrflag = 3;
2033+ for (;;)
2034+ {
2035+ if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
2036+ yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
2037+ {
2038+#if YYDEBUG
2039+ if (yydebug)
2040+ fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
2041+ YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
2042+#endif
2043+ if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
2044+ yystate = yytable[yyn];
2045+ *++yystack.s_mark = yytable[yyn];
2046+ *++yystack.l_mark = yylval;
2047+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2048+ /* lookahead position is error end position */
2049+ yyerror_loc_range[2] = yylloc;
2050+ YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
2051+ *++yystack.p_mark = yyloc;
2052+#endif
2053+ goto yyloop;
2054+ }
2055+ else
2056+ {
2057+#if YYDEBUG
2058+ if (yydebug)
2059+ fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
2060+ YYDEBUGSTR, yydepth, *yystack.s_mark);
2061+#endif
2062+ if (yystack.s_mark <= yystack.s_base) goto yyabort;
2063+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2064+ /* the current TOS position is the error start position */
2065+ yyerror_loc_range[1] = *yystack.p_mark;
2066+#endif
2067+#if defined(YYDESTRUCT_CALL)
2068+#if YYBTYACC
2069+ if (!yytrial)
2070+#endif /* YYBTYACC */
2071+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2072+ YYDESTRUCT_CALL("error: discarding state",
2073+ yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
2074+#else
2075+ YYDESTRUCT_CALL("error: discarding state",
2076+ yystos[*yystack.s_mark], yystack.l_mark);
2077+#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
2078+#endif /* defined(YYDESTRUCT_CALL) */
2079+ --yystack.s_mark;
2080+ --yystack.l_mark;
2081+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2082+ --yystack.p_mark;
2083+#endif
2084+ }
2085+ }
2086+ }
2087+ else
2088+ {
2089+ if (yychar == YYEOF) goto yyabort;
2090+#if YYDEBUG
2091+ if (yydebug)
2092+ {
2093+ if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
2094+ fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
2095+ YYDEBUGSTR, yydepth, yystate, yychar, yys);
2096+ }
2097+#endif
2098+#if defined(YYDESTRUCT_CALL)
2099+#if YYBTYACC
2100+ if (!yytrial)
2101+#endif /* YYBTYACC */
2102+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2103+ YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
2104+#else
2105+ YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
2106+#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
2107+#endif /* defined(YYDESTRUCT_CALL) */
2108+ yychar = YYEMPTY;
2109+ goto yyloop;
2110+ }
2111+
2112+yyreduce:
2113+ yym = yylen[yyn];
2114+#if YYDEBUG
2115+ if (yydebug)
2116+ {
2117+ fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
2118+ YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
2119+#ifdef YYSTYPE_TOSTRING
2120+#if YYBTYACC
2121+ if (!yytrial)
2122+#endif /* YYBTYACC */
2123+ if (yym > 0)
2124+ {
2125+ int i;
2126+ fputc('<', stderr);
2127+ for (i = yym; i > 0; i--)
2128+ {
2129+ if (i != yym) fputs(", ", stderr);
2130+ fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
2131+ yystack.l_mark[1-i]), stderr);
2132+ }
2133+ fputc('>', stderr);
2134+ }
2135+#endif
2136+ fputc('\n', stderr);
2137+ }
2138+#endif
2139+ if (yym > 0)
2140+ yyval = yystack.l_mark[1-yym];
2141+ else
2142+ memset(&yyval, 0, sizeof yyval);
2143+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2144+
2145+ /* Perform position reduction */
2146+ memset(&yyloc, 0, sizeof(yyloc));
2147+#if YYBTYACC
2148+ if (!yytrial)
2149+#endif /* YYBTYACC */
2150+ {
2151+ YYLLOC_DEFAULT(yyloc, &yystack.p_mark[-yym], yym);
2152+ /* just in case YYERROR is invoked within the action, save
2153+ the start of the rhs as the error start position */
2154+ yyerror_loc_range[1] = yystack.p_mark[1-yym];
2155+ }
2156+#endif
2157+
2158+ switch (yyn)
2159+ {
2160+case 1:
2161+#line 256 "parser.y"
2162+ { yyval.file = param->rtrn = yystack.l_mark[0].file; param->more_maps = !!param->rtrn; }
2163+#line 2143 "parser.c"
2164+break;
2165+case 2:
2166+#line 258 "parser.y"
2167+ { yyval.file = param->rtrn = yystack.l_mark[0].file; param->more_maps = !!param->rtrn; YYACCEPT; }
2168+#line 2148 "parser.c"
2169+break;
2170+case 3:
2171+#line 260 "parser.y"
2172+ { yyval.file = param->rtrn = NULL; param->more_maps = false; }
2173+#line 2153 "parser.c"
2174+break;
2175+case 4:
2176+#line 266 "parser.y"
2177+ { yyval.file = XkbFileCreate(yystack.l_mark[-5].file_type, yystack.l_mark[-4].str, (ParseCommon *) yystack.l_mark[-2].fileList.head, yystack.l_mark[-6].mapFlags); }
2178+#line 2158 "parser.c"
2179+break;
2180+case 5:
2181+#line 269 "parser.y"
2182+ { yyval.file_type = FILE_TYPE_KEYMAP; }
2183+#line 2163 "parser.c"
2184+break;
2185+case 6:
2186+#line 270 "parser.y"
2187+ { yyval.file_type = FILE_TYPE_KEYMAP; }
2188+#line 2168 "parser.c"
2189+break;
2190+case 7:
2191+#line 271 "parser.y"
2192+ { yyval.file_type = FILE_TYPE_KEYMAP; }
2193+#line 2173 "parser.c"
2194+break;
2195+case 8:
2196+#line 275 "parser.y"
2197+ { yyval.fileList.head = yystack.l_mark[-1].fileList.head; yyval.fileList.last->common.next = &yystack.l_mark[0].file->common; yyval.fileList.last = yystack.l_mark[0].file; }
2198+#line 2178 "parser.c"
2199+break;
2200+case 9:
2201+#line 277 "parser.y"
2202+ { yyval.fileList.head = yyval.fileList.last = yystack.l_mark[0].file; }
2203+#line 2183 "parser.c"
2204+break;
2205+case 10:
2206+#line 283 "parser.y"
2207+ {
2208+ yyval.file = XkbFileCreate(yystack.l_mark[-5].file_type, yystack.l_mark[-4].str, yystack.l_mark[-2].anyList.head, yystack.l_mark[-6].mapFlags);
2209+ }
2210+#line 2190 "parser.c"
2211+break;
2212+case 11:
2213+#line 288 "parser.y"
2214+ { yyval.file_type = FILE_TYPE_KEYCODES; }
2215+#line 2195 "parser.c"
2216+break;
2217+case 12:
2218+#line 289 "parser.y"
2219+ { yyval.file_type = FILE_TYPE_TYPES; }
2220+#line 2200 "parser.c"
2221+break;
2222+case 13:
2223+#line 290 "parser.y"
2224+ { yyval.file_type = FILE_TYPE_COMPAT; }
2225+#line 2205 "parser.c"
2226+break;
2227+case 14:
2228+#line 291 "parser.y"
2229+ { yyval.file_type = FILE_TYPE_SYMBOLS; }
2230+#line 2210 "parser.c"
2231+break;
2232+case 15:
2233+#line 292 "parser.y"
2234+ { yyval.file_type = FILE_TYPE_GEOMETRY; }
2235+#line 2215 "parser.c"
2236+break;
2237+case 16:
2238+#line 295 "parser.y"
2239+ { yyval.mapFlags = yystack.l_mark[0].mapFlags; }
2240+#line 2220 "parser.c"
2241+break;
2242+case 17:
2243+#line 296 "parser.y"
2244+ { yyval.mapFlags = 0; }
2245+#line 2225 "parser.c"
2246+break;
2247+case 18:
2248+#line 299 "parser.y"
2249+ { yyval.mapFlags = (yystack.l_mark[-1].mapFlags | yystack.l_mark[0].mapFlags); }
2250+#line 2230 "parser.c"
2251+break;
2252+case 19:
2253+#line 300 "parser.y"
2254+ { yyval.mapFlags = yystack.l_mark[0].mapFlags; }
2255+#line 2235 "parser.c"
2256+break;
2257+case 20:
2258+#line 303 "parser.y"
2259+ { yyval.mapFlags = MAP_IS_PARTIAL; }
2260+#line 2240 "parser.c"
2261+break;
2262+case 21:
2263+#line 304 "parser.y"
2264+ { yyval.mapFlags = MAP_IS_DEFAULT; }
2265+#line 2245 "parser.c"
2266+break;
2267+case 22:
2268+#line 305 "parser.y"
2269+ { yyval.mapFlags = MAP_IS_HIDDEN; }
2270+#line 2250 "parser.c"
2271+break;
2272+case 23:
2273+#line 306 "parser.y"
2274+ { yyval.mapFlags = MAP_HAS_ALPHANUMERIC; }
2275+#line 2255 "parser.c"
2276+break;
2277+case 24:
2278+#line 307 "parser.y"
2279+ { yyval.mapFlags = MAP_HAS_MODIFIER; }
2280+#line 2260 "parser.c"
2281+break;
2282+case 25:
2283+#line 308 "parser.y"
2284+ { yyval.mapFlags = MAP_HAS_KEYPAD; }
2285+#line 2265 "parser.c"
2286+break;
2287+case 26:
2288+#line 309 "parser.y"
2289+ { yyval.mapFlags = MAP_HAS_FN; }
2290+#line 2270 "parser.c"
2291+break;
2292+case 27:
2293+#line 310 "parser.y"
2294+ { yyval.mapFlags = MAP_IS_ALTGR; }
2295+#line 2275 "parser.c"
2296+break;
2297+case 28:
2298+#line 314 "parser.y"
2299+ {
2300+ if (yystack.l_mark[0].any) {
2301+ if (yystack.l_mark[-1].anyList.head) {
2302+ yyval.anyList.head = yystack.l_mark[-1].anyList.head; yystack.l_mark[-1].anyList.last->next = yystack.l_mark[0].any; yyval.anyList.last = yystack.l_mark[0].any;
2303+ } else {
2304+ yyval.anyList.head = yyval.anyList.last = yystack.l_mark[0].any;
2305+ }
2306+ }
2307+ }
2308+#line 2288 "parser.c"
2309+break;
2310+case 29:
2311+#line 329 "parser.y"
2312+ {
2313+ for (VModDef *vmod = yystack.l_mark[0].vmodList.head; vmod; vmod = (VModDef *) vmod->common.next)
2314+ vmod->merge = yystack.l_mark[-1].merge;
2315+ if (yystack.l_mark[-2].anyList.head) {
2316+ yyval.anyList.head = yystack.l_mark[-2].anyList.head; yystack.l_mark[-2].anyList.last->next = &yystack.l_mark[0].vmodList.head->common; yyval.anyList.last = &yystack.l_mark[0].vmodList.last->common;
2317+ } else {
2318+ yyval.anyList.head = &yystack.l_mark[0].vmodList.head->common; yyval.anyList.last = &yystack.l_mark[0].vmodList.last->common;
2319+ }
2320+ }
2321+#line 2301 "parser.c"
2322+break;
2323+case 30:
2324+#line 338 "parser.y"
2325+ { yyval.anyList.head = yyval.anyList.last = NULL; }
2326+#line 2306 "parser.c"
2327+break;
2328+case 31:
2329+#line 342 "parser.y"
2330+ {
2331+ yystack.l_mark[0].var->merge = yystack.l_mark[-1].merge;
2332+ yyval.any = (ParseCommon *) yystack.l_mark[0].var;
2333+ }
2334+#line 2314 "parser.c"
2335+break;
2336+case 32:
2337+#line 348 "parser.y"
2338+ {
2339+ yystack.l_mark[0].interp->merge = yystack.l_mark[-1].merge;
2340+ yyval.any = (ParseCommon *) yystack.l_mark[0].interp;
2341+ }
2342+#line 2322 "parser.c"
2343+break;
2344+case 33:
2345+#line 353 "parser.y"
2346+ {
2347+ yystack.l_mark[0].keyCode->merge = yystack.l_mark[-1].merge;
2348+ yyval.any = (ParseCommon *) yystack.l_mark[0].keyCode;
2349+ }
2350+#line 2330 "parser.c"
2351+break;
2352+case 34:
2353+#line 358 "parser.y"
2354+ {
2355+ yystack.l_mark[0].keyAlias->merge = yystack.l_mark[-1].merge;
2356+ yyval.any = (ParseCommon *) yystack.l_mark[0].keyAlias;
2357+ }
2358+#line 2338 "parser.c"
2359+break;
2360+case 35:
2361+#line 363 "parser.y"
2362+ {
2363+ yystack.l_mark[0].keyType->merge = yystack.l_mark[-1].merge;
2364+ yyval.any = (ParseCommon *) yystack.l_mark[0].keyType;
2365+ }
2366+#line 2346 "parser.c"
2367+break;
2368+case 36:
2369+#line 368 "parser.y"
2370+ {
2371+ yystack.l_mark[0].syms->merge = yystack.l_mark[-1].merge;
2372+ yyval.any = (ParseCommon *) yystack.l_mark[0].syms;
2373+ }
2374+#line 2354 "parser.c"
2375+break;
2376+case 37:
2377+#line 373 "parser.y"
2378+ {
2379+ yystack.l_mark[0].modMask->merge = yystack.l_mark[-1].merge;
2380+ yyval.any = (ParseCommon *) yystack.l_mark[0].modMask;
2381+ }
2382+#line 2362 "parser.c"
2383+break;
2384+case 38:
2385+#line 378 "parser.y"
2386+ {
2387+ yystack.l_mark[0].groupCompat->merge = yystack.l_mark[-1].merge;
2388+ yyval.any = (ParseCommon *) yystack.l_mark[0].groupCompat;
2389+ }
2390+#line 2370 "parser.c"
2391+break;
2392+case 39:
2393+#line 383 "parser.y"
2394+ {
2395+ yystack.l_mark[0].ledMap->merge = yystack.l_mark[-1].merge;
2396+ yyval.any = (ParseCommon *) yystack.l_mark[0].ledMap;
2397+ }
2398+#line 2378 "parser.c"
2399+break;
2400+case 40:
2401+#line 388 "parser.y"
2402+ {
2403+ yystack.l_mark[0].ledName->merge = yystack.l_mark[-1].merge;
2404+ yyval.any = (ParseCommon *) yystack.l_mark[0].ledName;
2405+ }
2406+#line 2386 "parser.c"
2407+break;
2408+case 41:
2409+#line 392 "parser.y"
2410+ { yyval.any = NULL; }
2411+#line 2391 "parser.c"
2412+break;
2413+case 42:
2414+#line 393 "parser.y"
2415+ { yyval.any = NULL; }
2416+#line 2396 "parser.c"
2417+break;
2418+case 43:
2419+#line 394 "parser.y"
2420+ { yyval.any = NULL; }
2421+#line 2401 "parser.c"
2422+break;
2423+case 44:
2424+#line 396 "parser.y"
2425+ {
2426+ yyval.any = (ParseCommon *) IncludeCreate(param->ctx, yystack.l_mark[0].str, yystack.l_mark[-1].merge);
2427+ free(yystack.l_mark[0].str);
2428+ }
2429+#line 2409 "parser.c"
2430+break;
2431+case 45:
2432+#line 403 "parser.y"
2433+ { yyval.var = VarCreate(yystack.l_mark[-3].expr, yystack.l_mark[-1].expr); }
2434+#line 2414 "parser.c"
2435+break;
2436+case 46:
2437+#line 405 "parser.y"
2438+ { yyval.var = BoolVarCreate(yystack.l_mark[-1].atom, true); }
2439+#line 2419 "parser.c"
2440+break;
2441+case 47:
2442+#line 407 "parser.y"
2443+ { yyval.var = BoolVarCreate(yystack.l_mark[-1].atom, false); }
2444+#line 2424 "parser.c"
2445+break;
2446+case 48:
2447+#line 411 "parser.y"
2448+ { yyval.keyCode = KeycodeCreate(yystack.l_mark[-3].atom, yystack.l_mark[-1].num); }
2449+#line 2429 "parser.c"
2450+break;
2451+case 49:
2452+#line 415 "parser.y"
2453+ { yyval.keyAlias = KeyAliasCreate(yystack.l_mark[-3].atom, yystack.l_mark[-1].atom); }
2454+#line 2434 "parser.c"
2455+break;
2456+case 50:
2457+#line 419 "parser.y"
2458+ { yyval.vmodList = yystack.l_mark[-1].vmodList; }
2459+#line 2439 "parser.c"
2460+break;
2461+case 51:
2462+#line 423 "parser.y"
2463+ { yyval.vmodList.head = yystack.l_mark[-2].vmodList.head; yyval.vmodList.last->common.next = &yystack.l_mark[0].vmod->common; yyval.vmodList.last = yystack.l_mark[0].vmod; }
2464+#line 2444 "parser.c"
2465+break;
2466+case 52:
2467+#line 425 "parser.y"
2468+ { yyval.vmodList.head = yyval.vmodList.last = yystack.l_mark[0].vmod; }
2469+#line 2449 "parser.c"
2470+break;
2471+case 53:
2472+#line 429 "parser.y"
2473+ { yyval.vmod = VModCreate(yystack.l_mark[0].atom, NULL); }
2474+#line 2454 "parser.c"
2475+break;
2476+case 54:
2477+#line 431 "parser.y"
2478+ { yyval.vmod = VModCreate(yystack.l_mark[-2].atom, yystack.l_mark[0].expr); }
2479+#line 2459 "parser.c"
2480+break;
2481+case 55:
2482+#line 437 "parser.y"
2483+ { yystack.l_mark[-4].interp->def = yystack.l_mark[-2].varList.head; yyval.interp = yystack.l_mark[-4].interp; }
2484+#line 2464 "parser.c"
2485+break;
2486+case 56:
2487+#line 441 "parser.y"
2488+ { yyval.interp = InterpCreate(yystack.l_mark[-2].keysym, yystack.l_mark[0].expr); }
2489+#line 2469 "parser.c"
2490+break;
2491+case 57:
2492+#line 443 "parser.y"
2493+ { yyval.interp = InterpCreate(yystack.l_mark[0].keysym, NULL); }
2494+#line 2474 "parser.c"
2495+break;
2496+case 58:
2497+#line 447 "parser.y"
2498+ { yyval.varList.head = yystack.l_mark[-1].varList.head; yyval.varList.last->common.next = &yystack.l_mark[0].var->common; yyval.varList.last = yystack.l_mark[0].var; }
2499+#line 2479 "parser.c"
2500+break;
2501+case 59:
2502+#line 449 "parser.y"
2503+ { yyval.varList.head = yyval.varList.last = yystack.l_mark[0].var; }
2504+#line 2484 "parser.c"
2505+break;
2506+case 60:
2507+#line 455 "parser.y"
2508+ { yyval.keyType = KeyTypeCreate(yystack.l_mark[-4].atom, yystack.l_mark[-2].varList.head); }
2509+#line 2489 "parser.c"
2510+break;
2511+case 61:
2512+#line 461 "parser.y"
2513+ { yyval.syms = SymbolsCreate(yystack.l_mark[-4].atom, yystack.l_mark[-2].varList.head); }
2514+#line 2494 "parser.c"
2515+break;
2516+case 62:
2517+#line 465 "parser.y"
2518+ { yyval.varList.head = yystack.l_mark[-2].varList.head; yyval.varList.last->common.next = &yystack.l_mark[0].var->common; yyval.varList.last = yystack.l_mark[0].var; }
2519+#line 2499 "parser.c"
2520+break;
2521+case 63:
2522+#line 467 "parser.y"
2523+ { yyval.varList.head = yyval.varList.last = yystack.l_mark[0].var; }
2524+#line 2504 "parser.c"
2525+break;
2526+case 64:
2527+#line 470 "parser.y"
2528+ { yyval.var = VarCreate(yystack.l_mark[-2].expr, yystack.l_mark[0].expr); }
2529+#line 2509 "parser.c"
2530+break;
2531+case 65:
2532+#line 471 "parser.y"
2533+ { yyval.var = VarCreate(yystack.l_mark[-2].expr, yystack.l_mark[0].expr); }
2534+#line 2514 "parser.c"
2535+break;
2536+case 66:
2537+#line 472 "parser.y"
2538+ { yyval.var = BoolVarCreate(yystack.l_mark[0].atom, true); }
2539+#line 2519 "parser.c"
2540+break;
2541+case 67:
2542+#line 473 "parser.y"
2543+ { yyval.var = BoolVarCreate(yystack.l_mark[0].atom, false); }
2544+#line 2524 "parser.c"
2545+break;
2546+case 68:
2547+#line 474 "parser.y"
2548+ { yyval.var = VarCreate(NULL, yystack.l_mark[0].expr); }
2549+#line 2529 "parser.c"
2550+break;
2551+case 69:
2552+#line 478 "parser.y"
2553+ { yyval.expr = yystack.l_mark[-1].expr; }
2554+#line 2534 "parser.c"
2555+break;
2556+case 70:
2557+#line 480 "parser.y"
2558+ { yyval.expr = ExprCreateActionList(yystack.l_mark[-1].exprList.head); }
2559+#line 2539 "parser.c"
2560+break;
2561+case 71:
2562+#line 484 "parser.y"
2563+ { yyval.groupCompat = GroupCompatCreate(yystack.l_mark[-3].num, yystack.l_mark[-1].expr); }
2564+#line 2544 "parser.c"
2565+break;
2566+case 72:
2567+#line 488 "parser.y"
2568+ { yyval.modMask = ModMapCreate(yystack.l_mark[-4].atom, yystack.l_mark[-2].exprList.head); }
2569+#line 2549 "parser.c"
2570+break;
2571+case 73:
2572+#line 492 "parser.y"
2573+ { yyval.ledMap = LedMapCreate(yystack.l_mark[-4].atom, yystack.l_mark[-2].varList.head); }
2574+#line 2554 "parser.c"
2575+break;
2576+case 74:
2577+#line 496 "parser.y"
2578+ { yyval.ledName = LedNameCreate(yystack.l_mark[-3].num, yystack.l_mark[-1].expr, false); }
2579+#line 2559 "parser.c"
2580+break;
2581+case 75:
2582+#line 498 "parser.y"
2583+ { yyval.ledName = LedNameCreate(yystack.l_mark[-3].num, yystack.l_mark[-1].expr, true); }
2584+#line 2564 "parser.c"
2585+break;
2586+case 76:
2587+#line 502 "parser.y"
2588+ { yyval.geom = NULL; }
2589+#line 2569 "parser.c"
2590+break;
2591+case 77:
2592+#line 504 "parser.y"
2593+ { (void) yystack.l_mark[-2].expr; yyval.geom = NULL; }
2594+#line 2574 "parser.c"
2595+break;
2596+case 78:
2597+#line 508 "parser.y"
2598+ { yyval.geom = NULL; }
2599+#line 2579 "parser.c"
2600+break;
2601+case 79:
2602+#line 511 "parser.y"
2603+ { yyval.geom = NULL;}
2604+#line 2584 "parser.c"
2605+break;
2606+case 80:
2607+#line 512 "parser.y"
2608+ { yyval.geom = NULL; }
2609+#line 2589 "parser.c"
2610+break;
2611+case 81:
2612+#line 516 "parser.y"
2613+ { yyval.geom = NULL; }
2614+#line 2594 "parser.c"
2615+break;
2616+case 82:
2617+#line 518 "parser.y"
2618+ { FreeStmt((ParseCommon *) yystack.l_mark[0].var); yyval.geom = NULL; }
2619+#line 2599 "parser.c"
2620+break;
2621+case 83:
2622+#line 520 "parser.y"
2623+ { yyval.geom = NULL; }
2624+#line 2604 "parser.c"
2625+break;
2626+case 84:
2627+#line 522 "parser.y"
2628+ { FreeStmt((ParseCommon *) yystack.l_mark[0].ledMap); yyval.geom = NULL; }
2629+#line 2609 "parser.c"
2630+break;
2631+case 85:
2632+#line 524 "parser.y"
2633+ { yyval.geom = NULL; }
2634+#line 2614 "parser.c"
2635+break;
2636+case 86:
2637+#line 527 "parser.y"
2638+ { yyval.geom = NULL;}
2639+#line 2619 "parser.c"
2640+break;
2641+case 87:
2642+#line 528 "parser.y"
2643+ { yyval.geom = NULL; }
2644+#line 2624 "parser.c"
2645+break;
2646+case 88:
2647+#line 531 "parser.y"
2648+ { yyval.geom = NULL; }
2649+#line 2629 "parser.c"
2650+break;
2651+case 89:
2652+#line 533 "parser.y"
2653+ { FreeStmt((ParseCommon *) yystack.l_mark[0].var); yyval.geom = NULL; }
2654+#line 2634 "parser.c"
2655+break;
2656+case 90:
2657+#line 536 "parser.y"
2658+ { yyval.geom = NULL; }
2659+#line 2639 "parser.c"
2660+break;
2661+case 91:
2662+#line 537 "parser.y"
2663+ { yyval.geom = NULL; }
2664+#line 2644 "parser.c"
2665+break;
2666+case 92:
2667+#line 541 "parser.y"
2668+ { yyval.geom = NULL; }
2669+#line 2649 "parser.c"
2670+break;
2671+case 93:
2672+#line 543 "parser.y"
2673+ { FreeStmt((ParseCommon *) yystack.l_mark[-1].exprList.head); yyval.geom = NULL; }
2674+#line 2654 "parser.c"
2675+break;
2676+case 94:
2677+#line 547 "parser.y"
2678+ { yyval.geom = NULL; }
2679+#line 2659 "parser.c"
2680+break;
2681+case 95:
2682+#line 550 "parser.y"
2683+ { yyval.geom = NULL; }
2684+#line 2664 "parser.c"
2685+break;
2686+case 96:
2687+#line 551 "parser.y"
2688+ { yyval.geom = NULL; }
2689+#line 2669 "parser.c"
2690+break;
2691+case 97:
2692+#line 554 "parser.y"
2693+ { yyval.geom = NULL; }
2694+#line 2674 "parser.c"
2695+break;
2696+case 98:
2697+#line 558 "parser.y"
2698+ { yyval.geom = NULL;}
2699+#line 2679 "parser.c"
2700+break;
2701+case 99:
2702+#line 560 "parser.y"
2703+ { yyval.geom = NULL; }
2704+#line 2684 "parser.c"
2705+break;
2706+case 100:
2707+#line 564 "parser.y"
2708+ { (void) yystack.l_mark[-1].expr; yyval.geom = NULL; }
2709+#line 2689 "parser.c"
2710+break;
2711+case 101:
2712+#line 566 "parser.y"
2713+ { (void) yystack.l_mark[-1].expr; yyval.geom = NULL; }
2714+#line 2694 "parser.c"
2715+break;
2716+case 102:
2717+#line 568 "parser.y"
2718+ { FreeStmt((ParseCommon *) yystack.l_mark[0].expr); yyval.geom = NULL; }
2719+#line 2699 "parser.c"
2720+break;
2721+case 103:
2722+#line 572 "parser.y"
2723+ { (void) yystack.l_mark[-2].expr; (void) yystack.l_mark[0].expr; yyval.expr = NULL; }
2724+#line 2704 "parser.c"
2725+break;
2726+case 104:
2727+#line 574 "parser.y"
2728+ { (void) yystack.l_mark[0].expr; yyval.expr = NULL; }
2729+#line 2709 "parser.c"
2730+break;
2731+case 105:
2732+#line 578 "parser.y"
2733+ { yyval.expr = NULL; }
2734+#line 2714 "parser.c"
2735+break;
2736+case 106:
2737+#line 582 "parser.y"
2738+ { FreeStmt((ParseCommon *) yystack.l_mark[-2].varList.head); yyval.geom = NULL; }
2739+#line 2719 "parser.c"
2740+break;
2741+case 107:
2742+#line 585 "parser.y"
2743+ { yyval.num = 0; }
2744+#line 2724 "parser.c"
2745+break;
2746+case 108:
2747+#line 586 "parser.y"
2748+ { yyval.num = 0; }
2749+#line 2729 "parser.c"
2750+break;
2751+case 109:
2752+#line 587 "parser.y"
2753+ { yyval.num = 0; }
2754+#line 2734 "parser.c"
2755+break;
2756+case 110:
2757+#line 588 "parser.y"
2758+ { yyval.num = 0; }
2759+#line 2739 "parser.c"
2760+break;
2761+case 111:
2762+#line 591 "parser.y"
2763+ { yyval.atom = yystack.l_mark[0].atom; }
2764+#line 2744 "parser.c"
2765+break;
2766+case 112:
2767+#line 592 "parser.y"
2768+ { yyval.atom = yystack.l_mark[0].atom; }
2769+#line 2749 "parser.c"
2770+break;
2771+case 113:
2772+#line 596 "parser.y"
2773+ { yyval.atom = xkb_atom_intern_literal(param->ctx, "action"); }
2774+#line 2754 "parser.c"
2775+break;
2776+case 114:
2777+#line 598 "parser.y"
2778+ { yyval.atom = xkb_atom_intern_literal(param->ctx, "interpret"); }
2779+#line 2759 "parser.c"
2780+break;
2781+case 115:
2782+#line 600 "parser.y"
2783+ { yyval.atom = xkb_atom_intern_literal(param->ctx, "type"); }
2784+#line 2764 "parser.c"
2785+break;
2786+case 116:
2787+#line 602 "parser.y"
2788+ { yyval.atom = xkb_atom_intern_literal(param->ctx, "key"); }
2789+#line 2769 "parser.c"
2790+break;
2791+case 117:
2792+#line 604 "parser.y"
2793+ { yyval.atom = xkb_atom_intern_literal(param->ctx, "group"); }
2794+#line 2774 "parser.c"
2795+break;
2796+case 118:
2797+#line 606 "parser.y"
2798+ {yyval.atom = xkb_atom_intern_literal(param->ctx, "modifier_map");}
2799+#line 2779 "parser.c"
2800+break;
2801+case 119:
2802+#line 608 "parser.y"
2803+ { yyval.atom = xkb_atom_intern_literal(param->ctx, "indicator"); }
2804+#line 2784 "parser.c"
2805+break;
2806+case 120:
2807+#line 610 "parser.y"
2808+ { yyval.atom = xkb_atom_intern_literal(param->ctx, "shape"); }
2809+#line 2789 "parser.c"
2810+break;
2811+case 121:
2812+#line 612 "parser.y"
2813+ { yyval.atom = xkb_atom_intern_literal(param->ctx, "row"); }
2814+#line 2794 "parser.c"
2815+break;
2816+case 122:
2817+#line 614 "parser.y"
2818+ { yyval.atom = xkb_atom_intern_literal(param->ctx, "section"); }
2819+#line 2799 "parser.c"
2820+break;
2821+case 123:
2822+#line 616 "parser.y"
2823+ { yyval.atom = xkb_atom_intern_literal(param->ctx, "text"); }
2824+#line 2804 "parser.c"
2825+break;
2826+case 124:
2827+#line 619 "parser.y"
2828+ { yyval.merge = yystack.l_mark[0].merge; }
2829+#line 2809 "parser.c"
2830+break;
2831+case 125:
2832+#line 620 "parser.y"
2833+ { yyval.merge = MERGE_DEFAULT; }
2834+#line 2814 "parser.c"
2835+break;
2836+case 126:
2837+#line 623 "parser.y"
2838+ { yyval.merge = MERGE_DEFAULT; }
2839+#line 2819 "parser.c"
2840+break;
2841+case 127:
2842+#line 624 "parser.y"
2843+ { yyval.merge = MERGE_AUGMENT; }
2844+#line 2824 "parser.c"
2845+break;
2846+case 128:
2847+#line 625 "parser.y"
2848+ { yyval.merge = MERGE_OVERRIDE; }
2849+#line 2829 "parser.c"
2850+break;
2851+case 129:
2852+#line 626 "parser.y"
2853+ { yyval.merge = MERGE_REPLACE; }
2854+#line 2834 "parser.c"
2855+break;
2856+case 130:
2857+#line 628 "parser.y"
2858+ {
2859+ /*
2860+ * This used to be MERGE_ALT_FORM. This functionality was
2861+ * unused and has been removed.
2862+ */
2863+ yyval.merge = MERGE_DEFAULT;
2864+ }
2865+#line 2845 "parser.c"
2866+break;
2867+case 131:
2868+#line 637 "parser.y"
2869+ { yyval.exprList = yystack.l_mark[0].exprList; }
2870+#line 2850 "parser.c"
2871+break;
2872+case 132:
2873+#line 638 "parser.y"
2874+ { yyval.exprList.head = yyval.exprList.last = NULL; }
2875+#line 2855 "parser.c"
2876+break;
2877+case 133:
2878+#line 642 "parser.y"
2879+ { yyval.exprList.head = yystack.l_mark[-2].exprList.head; yyval.exprList.last->common.next = &yystack.l_mark[0].expr->common; yyval.exprList.last = yystack.l_mark[0].expr; }
2880+#line 2860 "parser.c"
2881+break;
2882+case 134:
2883+#line 644 "parser.y"
2884+ { yyval.exprList.head = yyval.exprList.last = yystack.l_mark[0].expr; }
2885+#line 2865 "parser.c"
2886+break;
2887+case 135:
2888+#line 648 "parser.y"
2889+ { yyval.expr = ExprCreateBinary(EXPR_DIVIDE, yystack.l_mark[-2].expr, yystack.l_mark[0].expr); }
2890+#line 2870 "parser.c"
2891+break;
2892+case 136:
2893+#line 650 "parser.y"
2894+ { yyval.expr = ExprCreateBinary(EXPR_ADD, yystack.l_mark[-2].expr, yystack.l_mark[0].expr); }
2895+#line 2875 "parser.c"
2896+break;
2897+case 137:
2898+#line 652 "parser.y"
2899+ { yyval.expr = ExprCreateBinary(EXPR_SUBTRACT, yystack.l_mark[-2].expr, yystack.l_mark[0].expr); }
2900+#line 2880 "parser.c"
2901+break;
2902+case 138:
2903+#line 654 "parser.y"
2904+ { yyval.expr = ExprCreateBinary(EXPR_MULTIPLY, yystack.l_mark[-2].expr, yystack.l_mark[0].expr); }
2905+#line 2885 "parser.c"
2906+break;
2907+case 139:
2908+#line 656 "parser.y"
2909+ { yyval.expr = ExprCreateBinary(EXPR_ASSIGN, yystack.l_mark[-2].expr, yystack.l_mark[0].expr); }
2910+#line 2890 "parser.c"
2911+break;
2912+case 140:
2913+#line 658 "parser.y"
2914+ { yyval.expr = yystack.l_mark[0].expr; }
2915+#line 2895 "parser.c"
2916+break;
2917+case 141:
2918+#line 662 "parser.y"
2919+ { yyval.expr = ExprCreateUnary(EXPR_NEGATE, yystack.l_mark[0].expr->expr.value_type, yystack.l_mark[0].expr); }
2920+#line 2900 "parser.c"
2921+break;
2922+case 142:
2923+#line 664 "parser.y"
2924+ { yyval.expr = ExprCreateUnary(EXPR_UNARY_PLUS, yystack.l_mark[0].expr->expr.value_type, yystack.l_mark[0].expr); }
2925+#line 2905 "parser.c"
2926+break;
2927+case 143:
2928+#line 666 "parser.y"
2929+ { yyval.expr = ExprCreateUnary(EXPR_NOT, EXPR_TYPE_BOOLEAN, yystack.l_mark[0].expr); }
2930+#line 2910 "parser.c"
2931+break;
2932+case 144:
2933+#line 668 "parser.y"
2934+ { yyval.expr = ExprCreateUnary(EXPR_INVERT, yystack.l_mark[0].expr->expr.value_type, yystack.l_mark[0].expr); }
2935+#line 2915 "parser.c"
2936+break;
2937+case 145:
2938+#line 670 "parser.y"
2939+ { yyval.expr = yystack.l_mark[0].expr; }
2940+#line 2920 "parser.c"
2941+break;
2942+case 146:
2943+#line 672 "parser.y"
2944+ { yyval.expr = ExprCreateAction(yystack.l_mark[-3].atom, yystack.l_mark[-1].exprList.head); }
2945+#line 2925 "parser.c"
2946+break;
2947+case 147:
2948+#line 674 "parser.y"
2949+ { yyval.expr = yystack.l_mark[0].expr; }
2950+#line 2930 "parser.c"
2951+break;
2952+case 148:
2953+#line 676 "parser.y"
2954+ { yyval.expr = yystack.l_mark[-1].expr; }
2955+#line 2935 "parser.c"
2956+break;
2957+case 149:
2958+#line 680 "parser.y"
2959+ { yyval.exprList.head = yystack.l_mark[-2].exprList.head; yyval.exprList.last->common.next = &yystack.l_mark[0].expr->common; yyval.exprList.last = yystack.l_mark[0].expr; }
2960+#line 2940 "parser.c"
2961+break;
2962+case 150:
2963+#line 682 "parser.y"
2964+ { yyval.exprList.head = yyval.exprList.last = yystack.l_mark[0].expr; }
2965+#line 2945 "parser.c"
2966+break;
2967+case 151:
2968+#line 686 "parser.y"
2969+ { yyval.expr = ExprCreateAction(yystack.l_mark[-3].atom, yystack.l_mark[-1].exprList.head); }
2970+#line 2950 "parser.c"
2971+break;
2972+case 152:
2973+#line 690 "parser.y"
2974+ { yyval.expr = ExprCreateIdent(yystack.l_mark[0].atom); }
2975+#line 2955 "parser.c"
2976+break;
2977+case 153:
2978+#line 692 "parser.y"
2979+ { yyval.expr = ExprCreateFieldRef(yystack.l_mark[-2].atom, yystack.l_mark[0].atom); }
2980+#line 2960 "parser.c"
2981+break;
2982+case 154:
2983+#line 694 "parser.y"
2984+ { yyval.expr = ExprCreateArrayRef(XKB_ATOM_NONE, yystack.l_mark[-3].atom, yystack.l_mark[-1].expr); }
2985+#line 2965 "parser.c"
2986+break;
2987+case 155:
2988+#line 696 "parser.y"
2989+ { yyval.expr = ExprCreateArrayRef(yystack.l_mark[-5].atom, yystack.l_mark[-3].atom, yystack.l_mark[-1].expr); }
2990+#line 2970 "parser.c"
2991+break;
2992+case 156:
2993+#line 700 "parser.y"
2994+ { yyval.expr = ExprCreateString(yystack.l_mark[0].atom); }
2995+#line 2975 "parser.c"
2996+break;
2997+case 157:
2998+#line 702 "parser.y"
2999+ { yyval.expr = ExprCreateInteger(yystack.l_mark[0].num); }
3000+#line 2980 "parser.c"
3001+break;
3002+case 158:
3003+#line 704 "parser.y"
3004+ { yyval.expr = ExprCreateFloat(/* Discard $1 */); }
3005+#line 2985 "parser.c"
3006+break;
3007+case 159:
3008+#line 706 "parser.y"
3009+ { yyval.expr = ExprCreateKeyName(yystack.l_mark[0].atom); }
3010+#line 2990 "parser.c"
3011+break;
3012+case 160:
3013+#line 709 "parser.y"
3014+ { yyval.expr = yystack.l_mark[0].expr; }
3015+#line 2995 "parser.c"
3016+break;
3017+case 161:
3018+#line 710 "parser.y"
3019+ { yyval.expr = NULL; }
3020+#line 3000 "parser.c"
3021+break;
3022+case 162:
3023+#line 714 "parser.y"
3024+ { yyval.expr = ExprAppendKeysymList(yystack.l_mark[-2].expr, yystack.l_mark[0].keysym); }
3025+#line 3005 "parser.c"
3026+break;
3027+case 163:
3028+#line 716 "parser.y"
3029+ { yyval.expr = ExprAppendMultiKeysymList(yystack.l_mark[-2].expr, yystack.l_mark[0].expr); }
3030+#line 3010 "parser.c"
3031+break;
3032+case 164:
3033+#line 718 "parser.y"
3034+ { yyval.expr = ExprCreateKeysymList(yystack.l_mark[0].keysym); }
3035+#line 3015 "parser.c"
3036+break;
3037+case 165:
3038+#line 720 "parser.y"
3039+ { yyval.expr = ExprCreateMultiKeysymList(yystack.l_mark[0].expr); }
3040+#line 3020 "parser.c"
3041+break;
3042+case 166:
3043+#line 724 "parser.y"
3044+ { yyval.expr = yystack.l_mark[-1].expr; }
3045+#line 3025 "parser.c"
3046+break;
3047+case 167:
3048+#line 728 "parser.y"
3049+ {
3050+ if (!resolve_keysym(yystack.l_mark[0].str, &yyval.keysym)) {
3051+ parser_warn(
3052+ param,
3053+ XKB_WARNING_UNRECOGNIZED_KEYSYM,
3054+ "unrecognized keysym \"%s\"",
3055+ yystack.l_mark[0].str
3056+ );
3057+ yyval.keysym = XKB_KEY_NoSymbol;
3058+ }
3059+ free(yystack.l_mark[0].str);
3060+ }
3061+#line 3041 "parser.c"
3062+break;
3063+case 168:
3064+#line 740 "parser.y"
3065+ { yyval.keysym = XKB_KEY_section; }
3066+#line 3046 "parser.c"
3067+break;
3068+case 169:
3069+#line 742 "parser.y"
3070+ {
3071+ if (yystack.l_mark[0].num < XKB_KEYSYM_MIN) {
3072+ parser_warn(
3073+ param,
3074+ XKB_WARNING_UNRECOGNIZED_KEYSYM,
3075+ "unrecognized keysym \"%"PRId64"\"",
3076+ yystack.l_mark[0].num
3077+ );
3078+ yyval.keysym = XKB_KEY_NoSymbol;
3079+ }
3080+ /* Special case for digits 0..9 */
3081+ else if (yystack.l_mark[0].num < 10) { /* XKB_KEY_0 .. XKB_KEY_9 */
3082+ yyval.keysym = XKB_KEY_0 + (xkb_keysym_t) yystack.l_mark[0].num;
3083+ }
3084+ else {
3085+ if (yystack.l_mark[0].num <= XKB_KEYSYM_MAX) {
3086+ yyval.keysym = (xkb_keysym_t) yystack.l_mark[0].num;
3087+ } else {
3088+ parser_warn(
3089+ param, XKB_WARNING_UNRECOGNIZED_KEYSYM,
3090+ "unrecognized keysym \"0x%"PRIx64"\" "
3091+ "(%"PRId64")", yystack.l_mark[0].num, yystack.l_mark[0].num
3092+ );
3093+ yyval.keysym = XKB_KEY_NoSymbol;
3094+ }
3095+ parser_warn(
3096+ param, XKB_WARNING_NUMERIC_KEYSYM,
3097+ "numeric keysym \"0x%"PRIx64"\" (%"PRId64")",
3098+ yystack.l_mark[0].num, yystack.l_mark[0].num
3099+ );
3100+ }
3101+ }
3102+#line 3082 "parser.c"
3103+break;
3104+case 170:
3105+#line 776 "parser.y"
3106+ { yyval.num = -yystack.l_mark[0].num; }
3107+#line 3087 "parser.c"
3108+break;
3109+case 171:
3110+#line 777 "parser.y"
3111+ { yyval.num = yystack.l_mark[0].num; }
3112+#line 3092 "parser.c"
3113+break;
3114+case 172:
3115+#line 780 "parser.y"
3116+ { yyval.num = yystack.l_mark[0].num; }
3117+#line 3097 "parser.c"
3118+break;
3119+case 173:
3120+#line 781 "parser.y"
3121+ { yyval.num = yystack.l_mark[0].num; }
3122+#line 3102 "parser.c"
3123+break;
3124+case 174:
3125+#line 784 "parser.y"
3126+ { yyval.num = 0; }
3127+#line 3107 "parser.c"
3128+break;
3129+case 175:
3130+#line 787 "parser.y"
3131+ { yyval.num = yystack.l_mark[0].num; }
3132+#line 3112 "parser.c"
3133+break;
3134+case 176:
3135+#line 790 "parser.y"
3136+ { yyval.num = yystack.l_mark[0].num; }
3137+#line 3117 "parser.c"
3138+break;
3139+case 177:
3140+#line 793 "parser.y"
3141+ { yyval.atom = xkb_atom_intern(param->ctx, yystack.l_mark[0].str, strlen(yystack.l_mark[0].str)); free(yystack.l_mark[0].str); }
3142+#line 3122 "parser.c"
3143+break;
3144+case 178:
3145+#line 794 "parser.y"
3146+ { yyval.atom = xkb_atom_intern_literal(param->ctx, "default"); }
3147+#line 3127 "parser.c"
3148+break;
3149+case 179:
3150+#line 797 "parser.y"
3151+ { yyval.atom = xkb_atom_intern(param->ctx, yystack.l_mark[0].str, strlen(yystack.l_mark[0].str)); free(yystack.l_mark[0].str); }
3152+#line 3132 "parser.c"
3153+break;
3154+case 180:
3155+#line 800 "parser.y"
3156+ { yyval.str = yystack.l_mark[0].str; }
3157+#line 3137 "parser.c"
3158+break;
3159+case 181:
3160+#line 801 "parser.y"
3161+ { yyval.str = NULL; }
3162+#line 3142 "parser.c"
3163+break;
3164+case 182:
3165+#line 804 "parser.y"
3166+ { yyval.str = yystack.l_mark[0].str; }
3167+#line 3147 "parser.c"
3168+break;
3169+#line 3149 "parser.c"
3170+ default:
3171+ break;
3172+ }
3173+ yystack.s_mark -= yym;
3174+ yystate = *yystack.s_mark;
3175+ yystack.l_mark -= yym;
3176+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3177+ yystack.p_mark -= yym;
3178+#endif
3179+ yym = yylhs[yyn];
3180+ if (yystate == 0 && yym == 0)
3181+ {
3182+#if YYDEBUG
3183+ if (yydebug)
3184+ {
3185+ fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
3186+#ifdef YYSTYPE_TOSTRING
3187+#if YYBTYACC
3188+ if (!yytrial)
3189+#endif /* YYBTYACC */
3190+ fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
3191+#endif
3192+ fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
3193+ }
3194+#endif
3195+ yystate = YYFINAL;
3196+ *++yystack.s_mark = YYFINAL;
3197+ *++yystack.l_mark = yyval;
3198+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3199+ *++yystack.p_mark = yyloc;
3200+#endif
3201+ if (yychar < 0)
3202+ {
3203+#if YYBTYACC
3204+ do {
3205+ if (yylvp < yylve)
3206+ {
3207+ /* we're currently re-reading tokens */
3208+ yylval = *yylvp++;
3209+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3210+ yylloc = *yylpp++;
3211+#endif
3212+ yychar = *yylexp++;
3213+ break;
3214+ }
3215+ if (yyps->save)
3216+ {
3217+ /* in trial mode; save scanner results for future parse attempts */
3218+ if (yylvp == yylvlim)
3219+ { /* Enlarge lexical value queue */
3220+ size_t p = (size_t) (yylvp - yylvals);
3221+ size_t s = (size_t) (yylvlim - yylvals);
3222+
3223+ s += YYLVQUEUEGROWTH;
3224+ if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL)
3225+ goto yyenomem;
3226+ if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
3227+ goto yyenomem;
3228+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3229+ if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
3230+ goto yyenomem;
3231+#endif
3232+ yylvp = yylve = yylvals + p;
3233+ yylvlim = yylvals + s;
3234+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3235+ yylpp = yylpe = yylpsns + p;
3236+ yylplim = yylpsns + s;
3237+#endif
3238+ yylexp = yylexemes + p;
3239+ }
3240+ *yylexp = (YYINT) YYLEX;
3241+ *yylvp++ = yylval;
3242+ yylve++;
3243+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3244+ *yylpp++ = yylloc;
3245+ yylpe++;
3246+#endif
3247+ yychar = *yylexp++;
3248+ break;
3249+ }
3250+ /* normal operation, no conflict encountered */
3251+#endif /* YYBTYACC */
3252+ yychar = YYLEX;
3253+#if YYBTYACC
3254+ } while (0);
3255+#endif /* YYBTYACC */
3256+ if (yychar < 0) yychar = YYEOF;
3257+#if YYDEBUG
3258+ if (yydebug)
3259+ {
3260+ if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
3261+ fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
3262+ YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
3263+ }
3264+#endif
3265+ }
3266+ if (yychar == YYEOF) goto yyaccept;
3267+ goto yyloop;
3268+ }
3269+ if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
3270+ yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
3271+ yystate = yytable[yyn];
3272+ else
3273+ yystate = yydgoto[yym];
3274+#if YYDEBUG
3275+ if (yydebug)
3276+ {
3277+ fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
3278+#ifdef YYSTYPE_TOSTRING
3279+#if YYBTYACC
3280+ if (!yytrial)
3281+#endif /* YYBTYACC */
3282+ fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
3283+#endif
3284+ fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
3285+ }
3286+#endif
3287+ if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
3288+ *++yystack.s_mark = (YYINT) yystate;
3289+ *++yystack.l_mark = yyval;
3290+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3291+ *++yystack.p_mark = yyloc;
3292+#endif
3293+ goto yyloop;
3294+#if YYBTYACC
3295+
3296+ /* Reduction declares that this path is valid. Set yypath and do a full parse */
3297+yyvalid:
3298+ if (yypath) YYABORT;
3299+ while (yyps->save)
3300+ {
3301+ YYParseState *save = yyps->save;
3302+ yyps->save = save->save;
3303+ save->save = yypath;
3304+ yypath = save;
3305+ }
3306+#if YYDEBUG
3307+ if (yydebug)
3308+ fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
3309+ YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
3310+#endif
3311+ if (yyerrctx)
3312+ {
3313+ yyFreeState(yyerrctx);
3314+ yyerrctx = NULL;
3315+ }
3316+ yylvp = yylvals + yypath->lexeme;
3317+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3318+ yylpp = yylpsns + yypath->lexeme;
3319+#endif
3320+ yylexp = yylexemes + yypath->lexeme;
3321+ yychar = YYEMPTY;
3322+ yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
3323+ memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
3324+ yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
3325+ memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
3326+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3327+ yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
3328+ memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
3329+#endif
3330+ yystate = yypath->state;
3331+ goto yyloop;
3332+#endif /* YYBTYACC */
3333+
3334+yyoverflow:
3335+ YYERROR_CALL("yacc stack overflow");
3336+#if YYBTYACC
3337+ goto yyabort_nomem;
3338+yyenomem:
3339+ YYERROR_CALL("memory exhausted");
3340+yyabort_nomem:
3341+#endif /* YYBTYACC */
3342+ yyresult = 2;
3343+ goto yyreturn;
3344+
3345+yyabort:
3346+ yyresult = 1;
3347+ goto yyreturn;
3348+
3349+yyaccept:
3350+#if YYBTYACC
3351+ if (yyps->save) goto yyvalid;
3352+#endif /* YYBTYACC */
3353+ yyresult = 0;
3354+
3355+yyreturn:
3356+#if defined(YYDESTRUCT_CALL)
3357+ if (yychar != YYEOF && yychar != YYEMPTY)
3358+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3359+ YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
3360+#else
3361+ YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
3362+#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
3363+
3364+ {
3365+ YYSTYPE *pv;
3366+#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3367+ YYLTYPE *pp;
3368+
3369+ for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
3370+ YYDESTRUCT_CALL("cleanup: discarding state",
3371+ yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
3372+#else
3373+ for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
3374+ YYDESTRUCT_CALL("cleanup: discarding state",
3375+ yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
3376+#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
3377+ }
3378+#endif /* defined(YYDESTRUCT_CALL) */
3379+
3380+#if YYBTYACC
3381+ if (yyerrctx)
3382+ {
3383+ yyFreeState(yyerrctx);
3384+ yyerrctx = NULL;
3385+ }
3386+ while (yyps)
3387+ {
3388+ YYParseState *save = yyps;
3389+ yyps = save->save;
3390+ save->save = NULL;
3391+ yyFreeState(save);
3392+ }
3393+ while (yypath)
3394+ {
3395+ YYParseState *save = yypath;
3396+ yypath = save->save;
3397+ save->save = NULL;
3398+ yyFreeState(save);
3399+ }
3400+#endif /* YYBTYACC */
3401+ yyfreestack(&yystack);
3402+ return (yyresult);
3403+}
3404diff --git a/src/xkbcomp/parser.h b/src/xkbcomp/parser.h
3405new file mode 100644
3406index 0000000..86f7a92
3407--- /dev/null
3408+++ b/src/xkbcomp/parser.h
3409@@ -0,0 +1,104 @@
3410+#ifndef __xkbcommon__defines_h_
3411+#define __xkbcommon__defines_h_
3412+
3413+#define END_OF_FILE 0
3414+#define ERROR_TOK 255
3415+#define XKB_KEYMAP 1
3416+#define XKB_KEYCODES 2
3417+#define XKB_TYPES 3
3418+#define XKB_SYMBOLS 4
3419+#define XKB_COMPATMAP 5
3420+#define XKB_GEOMETRY 6
3421+#define XKB_SEMANTICS 7
3422+#define XKB_LAYOUT 8
3423+#define INCLUDE 10
3424+#define OVERRIDE 11
3425+#define AUGMENT 12
3426+#define REPLACE 13
3427+#define ALTERNATE 14
3428+#define VIRTUAL_MODS 20
3429+#define TYPE 21
3430+#define INTERPRET 22
3431+#define ACTION_TOK 23
3432+#define KEY 24
3433+#define ALIAS 25
3434+#define GROUP 26
3435+#define MODIFIER_MAP 27
3436+#define INDICATOR 28
3437+#define SHAPE 29
3438+#define KEYS 30
3439+#define ROW 31
3440+#define SECTION 32
3441+#define OVERLAY 33
3442+#define TEXT 34
3443+#define OUTLINE 35
3444+#define SOLID 36
3445+#define LOGO 37
3446+#define VIRTUAL 38
3447+#define EQUALS 40
3448+#define PLUS 41
3449+#define MINUS 42
3450+#define DIVIDE 43
3451+#define TIMES 44
3452+#define OBRACE 45
3453+#define CBRACE 46
3454+#define OPAREN 47
3455+#define CPAREN 48
3456+#define OBRACKET 49
3457+#define CBRACKET 50
3458+#define DOT 51
3459+#define COMMA 52
3460+#define SEMI 53
3461+#define EXCLAM 54
3462+#define INVERT 55
3463+#define STRING 60
3464+#define INTEGER 61
3465+#define FLOAT 62
3466+#define IDENT 63
3467+#define KEYNAME 64
3468+#define PARTIAL 70
3469+#define DEFAULT 71
3470+#define HIDDEN 72
3471+#define ALPHANUMERIC_KEYS 73
3472+#define MODIFIER_KEYS 74
3473+#define KEYPAD_KEYS 75
3474+#define FUNCTION_KEYS 76
3475+#define ALTERNATE_GROUP 77
3476+#ifdef YYSTYPE
3477+#undef YYSTYPE_IS_DECLARED
3478+#define YYSTYPE_IS_DECLARED 1
3479+#endif
3480+#ifndef YYSTYPE_IS_DECLARED
3481+#define YYSTYPE_IS_DECLARED 1
3482+typedef union YYSTYPE {
3483+ int64_t num;
3484+ enum xkb_file_type file_type;
3485+ char *str;
3486+ xkb_atom_t atom;
3487+ enum merge_mode merge;
3488+ enum xkb_map_flags mapFlags;
3489+ xkb_keysym_t keysym;
3490+ ParseCommon *any;
3491+ struct { ParseCommon *head; ParseCommon *last; } anyList;
3492+ ExprDef *expr;
3493+ struct { ExprDef *head; ExprDef *last; } exprList;
3494+ VarDef *var;
3495+ struct { VarDef *head; VarDef *last; } varList;
3496+ VModDef *vmod;
3497+ struct { VModDef *head; VModDef *last; } vmodList;
3498+ InterpDef *interp;
3499+ KeyTypeDef *keyType;
3500+ SymbolsDef *syms;
3501+ ModMapDef *modMask;
3502+ GroupCompatDef *groupCompat;
3503+ LedMapDef *ledMap;
3504+ LedNameDef *ledName;
3505+ KeycodeDef *keyCode;
3506+ KeyAliasDef *keyAlias;
3507+ void *geom;
3508+ XkbFile *file;
3509+ struct { XkbFile *head; XkbFile *last; } fileList;
3510+} YYSTYPE;
3511+#endif /* !YYSTYPE_IS_DECLARED */
3512+
3513+#endif /* __xkbcommon__defines_h_ */
3514--
35152.45.1
3516
