commit 0be5573
hovercats
·
2024-10-09 07:00:41 +0000 UTC
parent af4f7a8
libxkbcommon: 1.7.0
6 files changed,
+3131,
-3059
+2,
-2
1@@ -3,8 +3,8 @@
2 ## config.h
3 Generated with
4
5- meson \
6- --prefix=/ \
7+ meson setup \
8+ -Dprefix=/ \
9 -Dxkb-config-root=/share/xkb \
10 -Dx-locale-root=/share/xlocale \
11 -Denable-x11=false \
+14,
-0
1@@ -1,3 +1,4 @@
2+#pragma once
3 #define DEFAULT_XKB_LAYOUT "us"
4 #define DEFAULT_XKB_MODEL "pc105"
5 #define DEFAULT_XKB_OPTIONS NULL
6@@ -9,12 +10,25 @@
7 #define HAVE_ASPRINTF 1
8 #define HAVE_EACCESS 1
9 #define HAVE_EUIDACCESS 1
10+#define HAVE_ICU 0
11 #define HAVE_MKOSTEMP 1
12 #define HAVE_MMAP 1
13 #define HAVE_POSIX_FALLOCATE 1
14 #define HAVE_SECURE_GETENV 1
15 #define HAVE_STRNDUP 1
16+#define HAVE_TOOLS 0
17 #define HAVE_UNISTD_H 1
18+#define HAVE_XKBCLI_COMPILE_COMPOSE 1
19+#define HAVE_XKBCLI_COMPILE_KEYMAP 1
20+#define HAVE_XKBCLI_HOW_TO_TYPE 1
21+#define HAVE_XKBCLI_INTERACTIVE_EVDEV 1
22+#define HAVE_XKBCLI_LIST 1
23 #define HAVE___BUILTIN_EXPECT 1
24+#define LIBXKBCOMMON_TOOL_PATH "/libexec/xkbcommon"
25+#define LIBXKBCOMMON_VERSION "1.7.0"
26+#define WIN32_LEAN_AND_MEAN 1
27 #define XLOCALEDIR "/share/xlocale"
28+#define _CRT_NONSTDC_NO_DEPRECATE 1
29+#define _CRT_NONSTDC_NO_WARNINGS 1
30+#define _CRT_SECURE_NO_WARNINGS 1
31 #define _GNU_SOURCE 1
+1,
-0
1@@ -2,6 +2,7 @@ cflags{
2 '-I $dir',
3 '-I $srcdir/include',
4 '-I $srcdir/src',
5+ '-I $srcdir/src/compose',
6 }
7
8 pkg.hdrs = copy('$outdir/include/xkbcommon', '$srcdir/include/xkbcommon', {
1@@ -1,106 +1,151 @@
2-From 9c7c0b8c9b850c15b519be769f81f7a53e6299d7 Mon Sep 17 00:00:00 2001
3+From dfdb147844ea6c6448a38ab7a69c514c34879fda Mon Sep 17 00:00:00 2001
4 From: Michael Forney <mforney@mforney.org>
5 Date: Sat, 26 Oct 2019 02:05:31 -0700
6 Subject: [PATCH] Track generated xkbcomp parser
7
8 Generated with
9
10- bison -o parser.c -H -p _xkbcommon_ parser.y
11+ yacc -H parser.h -o parser.c p _xkbcommon_ parser.y
12 ---
13- src/xkbcomp/parser.c | 3258 ++++++++++++++++++++++++++++++++++++++++++
14- src/xkbcomp/parser.h | 171 +++
15- 2 files changed, 3429 insertions(+)
16+ src/xkbcomp/parser.c | 3382 ++++++++++++++++++++++++++++++++++++++++++
17+ src/xkbcomp/parser.h | 104 ++
18+ 2 files changed, 3486 insertions(+)
19 create mode 100644 src/xkbcomp/parser.c
20 create mode 100644 src/xkbcomp/parser.h
21
22 diff --git a/src/xkbcomp/parser.c b/src/xkbcomp/parser.c
23 new file mode 100644
24-index 0000000..e9d5a8f
25+index 0000000..34e9ca8
26 --- /dev/null
27 +++ b/src/xkbcomp/parser.c
28-@@ -0,0 +1,3258 @@
29-+/* A Bison parser, made by GNU Bison 3.8.2. */
30+@@ -0,0 +1,3382 @@
31++/* original parser id follows */
32++/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
33++/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
34++
35++#define YYBYACC 1
36++#define YYMAJOR 2
37++#define YYMINOR 0
38++#define YYPATCH 20240109
39++
40++#define YYEMPTY (-1)
41++#define yyclearin (yychar = YYEMPTY)
42++#define yyerrok (yyerrflag = 0)
43++#define YYRECOVERING() (yyerrflag != 0)
44++#define YYENOMEM (-2)
45++#define YYEOF 0
46++#undef YYBTYACC
47++#define YYBTYACC 0
48++#define YYDEBUGSTR YYPREFIX "debug"
49 +
50-+/* Bison implementation for Yacc-like parsers in C
51++#ifndef yyparse
52++#define yyparse _xkbcommon_parse
53++#endif /* yyparse */
54 +
55-+ Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation,
56-+ Inc.
57++#ifndef yylex
58++#define yylex _xkbcommon_lex
59++#endif /* yylex */
60 +
61-+ This program is free software: you can redistribute it and/or modify
62-+ it under the terms of the GNU General Public License as published by
63-+ the Free Software Foundation, either version 3 of the License, or
64-+ (at your option) any later version.
65++#ifndef yyerror
66++#define yyerror _xkbcommon_error
67++#endif /* yyerror */
68 +
69-+ This program is distributed in the hope that it will be useful,
70-+ but WITHOUT ANY WARRANTY; without even the implied warranty of
71-+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
72-+ GNU General Public License for more details.
73++#ifndef yychar
74++#define yychar _xkbcommon_char
75++#endif /* yychar */
76 +
77-+ You should have received a copy of the GNU General Public License
78-+ along with this program. If not, see <https://www.gnu.org/licenses/>. */
79++#ifndef yyval
80++#define yyval _xkbcommon_val
81++#endif /* yyval */
82 +
83-+/* As a special exception, you may create a larger work that contains
84-+ part or all of the Bison parser skeleton and distribute that work
85-+ under terms of your choice, so long as that work isn't itself a
86-+ parser generator using the skeleton or a modified version thereof
87-+ as a parser skeleton. Alternatively, if you modify or redistribute
88-+ the parser skeleton itself, you may (at your option) remove this
89-+ special exception, which will cause the skeleton and the resulting
90-+ Bison output files to be licensed under the GNU General Public
91-+ License without this special exception.
92++#ifndef yylval
93++#define yylval _xkbcommon_lval
94++#endif /* yylval */
95 +
96-+ This special exception was added by the Free Software Foundation in
97-+ version 2.2 of Bison. */
98++#ifndef yydebug
99++#define yydebug _xkbcommon_debug
100++#endif /* yydebug */
101 +
102-+/* C LALR(1) parser skeleton written by Richard Stallman, by
103-+ simplifying the original so-called "semantic" parser. */
104++#ifndef yynerrs
105++#define yynerrs _xkbcommon_nerrs
106++#endif /* yynerrs */
107 +
108-+/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
109-+ especially those whose name start with YY_ or yy_. They are
110-+ private implementation details that can be changed or removed. */
111++#ifndef yyerrflag
112++#define yyerrflag _xkbcommon_errflag
113++#endif /* yyerrflag */
114 +
115-+/* All symbols defined below should begin with yy or YY, to avoid
116-+ infringing on user name space. This should be done even for local
117-+ variables, as they might otherwise be expanded by user macros.
118-+ There are some unavoidable exceptions within include files to
119-+ define necessary library symbols; they are noted "INFRINGES ON
120-+ USER NAME SPACE" below. */
121++#ifndef yylhs
122++#define yylhs _xkbcommon_lhs
123++#endif /* yylhs */
124 +
125-+/* Identify Bison output, and Bison version. */
126-+#define YYBISON 30802
127++#ifndef yylen
128++#define yylen _xkbcommon_len
129++#endif /* yylen */
130 +
131-+/* Bison version string. */
132-+#define YYBISON_VERSION "3.8.2"
133++#ifndef yydefred
134++#define yydefred _xkbcommon_defred
135++#endif /* yydefred */
136 +
137-+/* Skeleton name. */
138-+#define YYSKELETON_NAME "yacc.c"
139++#ifndef yystos
140++#define yystos _xkbcommon_stos
141++#endif /* yystos */
142 +
143-+/* Pure parsers. */
144-+#define YYPURE 1
145++#ifndef yydgoto
146++#define yydgoto _xkbcommon_dgoto
147++#endif /* yydgoto */
148++
149++#ifndef yysindex
150++#define yysindex _xkbcommon_sindex
151++#endif /* yysindex */
152++
153++#ifndef yyrindex
154++#define yyrindex _xkbcommon_rindex
155++#endif /* yyrindex */
156++
157++#ifndef yygindex
158++#define yygindex _xkbcommon_gindex
159++#endif /* yygindex */
160++
161++#ifndef yytable
162++#define yytable _xkbcommon_table
163++#endif /* yytable */
164++
165++#ifndef yycheck
166++#define yycheck _xkbcommon_check
167++#endif /* yycheck */
168++
169++#ifndef yyname
170++#define yyname _xkbcommon_name
171++#endif /* yyname */
172++
173++#ifndef yyrule
174++#define yyrule _xkbcommon_rule
175++#endif /* yyrule */
176 +
177-+/* Push parsers. */
178-+#define YYPUSH 0
179++#if YYBTYACC
180 +
181-+/* Pull parsers. */
182-+#define YYPULL 1
183++#ifndef yycindex
184++#define yycindex _xkbcommon_cindex
185++#endif /* yycindex */
186 +
187++#ifndef yyctable
188++#define yyctable _xkbcommon_ctable
189++#endif /* yyctable */
190 +
191-+/* Substitute the variable and function names. */
192-+#define yyparse _xkbcommon_parse
193-+#define yylex _xkbcommon_lex
194-+#define yyerror _xkbcommon_error
195-+#define yydebug _xkbcommon_debug
196-+#define yynerrs _xkbcommon_nerrs
197++#endif /* YYBTYACC */
198 +
199-+/* First part of user prologue. */
200-+#line 33 "parser.y"
201++#define YYPREFIX "_xkbcommon_"
202 +
203++#define YYPURE 1
204++
205++#line 34 "parser.y"
206 +#include "config.h"
207 +
208 +#include "xkbcomp/xkbcomp-priv.h"
209 +#include "xkbcomp/ast-build.h"
210 +#include "xkbcomp/parser-priv.h"
211 +#include "scanner-utils.h"
212++#include "keysym.h"
213 +
214 +struct parser_param {
215 + struct xkb_context *ctx;
216@@ -109,16 +154,16 @@ index 0000000..e9d5a8f
217 + bool more_maps;
218 +};
219 +
220-+#define parser_err(param, fmt, ...) \
221-+ scanner_err((param)->scanner, fmt, ##__VA_ARGS__)
222++#define parser_err(param, error_id, fmt, ...) \
223++ scanner_err_with_code((param)->scanner, error_id, fmt, ##__VA_ARGS__)
224 +
225-+#define parser_warn(param, fmt, ...) \
226-+ scanner_warn((param)->scanner, fmt, ##__VA_ARGS__)
227++#define parser_warn(param, warning_id, fmt, ...) \
228++ scanner_warn_with_code((param)->scanner, warning_id, fmt, ##__VA_ARGS__)
229 +
230 +static void
231 +_xkbcommon_error(struct parser_param *param, const char *msg)
232 +{
233-+ parser_err(param, "%s", msg);
234++ parser_err(param, XKB_ERROR_INVALID_SYNTAX, "%s", msg);
235 +}
236 +
237 +static bool
238@@ -146,3271 +191,3295 @@ index 0000000..e9d5a8f
239 +}
240 +
241 +#define param_scanner param->scanner
242-+
243-+#line 130 "parser.c"
244-+
245-+# ifndef YY_CAST
246-+# ifdef __cplusplus
247-+# define YY_CAST(Type, Val) static_cast<Type> (Val)
248-+# define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
249-+# else
250-+# define YY_CAST(Type, Val) ((Type) (Val))
251-+# define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
252-+# endif
253-+# endif
254-+# ifndef YY_NULLPTR
255-+# if defined __cplusplus
256-+# if 201103L <= __cplusplus
257-+# define YY_NULLPTR nullptr
258-+# else
259-+# define YY_NULLPTR 0
260-+# endif
261-+# else
262-+# define YY_NULLPTR ((void*)0)
263-+# endif
264-+# endif
265-+
266-+#include "parser.h"
267-+/* Symbol kind. */
268-+enum yysymbol_kind_t
269-+{
270-+ YYSYMBOL_YYEMPTY = -2,
271-+ YYSYMBOL_YYEOF = 0, /* END_OF_FILE */
272-+ YYSYMBOL_YYerror = 1, /* error */
273-+ YYSYMBOL_YYUNDEF = 2, /* "invalid token" */
274-+ YYSYMBOL_ERROR_TOK = 3, /* ERROR_TOK */
275-+ YYSYMBOL_XKB_KEYMAP = 4, /* XKB_KEYMAP */
276-+ YYSYMBOL_XKB_KEYCODES = 5, /* XKB_KEYCODES */
277-+ YYSYMBOL_XKB_TYPES = 6, /* XKB_TYPES */
278-+ YYSYMBOL_XKB_SYMBOLS = 7, /* XKB_SYMBOLS */
279-+ YYSYMBOL_XKB_COMPATMAP = 8, /* XKB_COMPATMAP */
280-+ YYSYMBOL_XKB_GEOMETRY = 9, /* XKB_GEOMETRY */
281-+ YYSYMBOL_XKB_SEMANTICS = 10, /* XKB_SEMANTICS */
282-+ YYSYMBOL_XKB_LAYOUT = 11, /* XKB_LAYOUT */
283-+ YYSYMBOL_INCLUDE = 12, /* INCLUDE */
284-+ YYSYMBOL_OVERRIDE = 13, /* OVERRIDE */
285-+ YYSYMBOL_AUGMENT = 14, /* AUGMENT */
286-+ YYSYMBOL_REPLACE = 15, /* REPLACE */
287-+ YYSYMBOL_ALTERNATE = 16, /* ALTERNATE */
288-+ YYSYMBOL_VIRTUAL_MODS = 17, /* VIRTUAL_MODS */
289-+ YYSYMBOL_TYPE = 18, /* TYPE */
290-+ YYSYMBOL_INTERPRET = 19, /* INTERPRET */
291-+ YYSYMBOL_ACTION_TOK = 20, /* ACTION_TOK */
292-+ YYSYMBOL_KEY = 21, /* KEY */
293-+ YYSYMBOL_ALIAS = 22, /* ALIAS */
294-+ YYSYMBOL_GROUP = 23, /* GROUP */
295-+ YYSYMBOL_MODIFIER_MAP = 24, /* MODIFIER_MAP */
296-+ YYSYMBOL_INDICATOR = 25, /* INDICATOR */
297-+ YYSYMBOL_SHAPE = 26, /* SHAPE */
298-+ YYSYMBOL_KEYS = 27, /* KEYS */
299-+ YYSYMBOL_ROW = 28, /* ROW */
300-+ YYSYMBOL_SECTION = 29, /* SECTION */
301-+ YYSYMBOL_OVERLAY = 30, /* OVERLAY */
302-+ YYSYMBOL_TEXT = 31, /* TEXT */
303-+ YYSYMBOL_OUTLINE = 32, /* OUTLINE */
304-+ YYSYMBOL_SOLID = 33, /* SOLID */
305-+ YYSYMBOL_LOGO = 34, /* LOGO */
306-+ YYSYMBOL_VIRTUAL = 35, /* VIRTUAL */
307-+ YYSYMBOL_EQUALS = 36, /* EQUALS */
308-+ YYSYMBOL_PLUS = 37, /* PLUS */
309-+ YYSYMBOL_MINUS = 38, /* MINUS */
310-+ YYSYMBOL_DIVIDE = 39, /* DIVIDE */
311-+ YYSYMBOL_TIMES = 40, /* TIMES */
312-+ YYSYMBOL_OBRACE = 41, /* OBRACE */
313-+ YYSYMBOL_CBRACE = 42, /* CBRACE */
314-+ YYSYMBOL_OPAREN = 43, /* OPAREN */
315-+ YYSYMBOL_CPAREN = 44, /* CPAREN */
316-+ YYSYMBOL_OBRACKET = 45, /* OBRACKET */
317-+ YYSYMBOL_CBRACKET = 46, /* CBRACKET */
318-+ YYSYMBOL_DOT = 47, /* DOT */
319-+ YYSYMBOL_COMMA = 48, /* COMMA */
320-+ YYSYMBOL_SEMI = 49, /* SEMI */
321-+ YYSYMBOL_EXCLAM = 50, /* EXCLAM */
322-+ YYSYMBOL_INVERT = 51, /* INVERT */
323-+ YYSYMBOL_STRING = 52, /* STRING */
324-+ YYSYMBOL_INTEGER = 53, /* INTEGER */
325-+ YYSYMBOL_FLOAT = 54, /* FLOAT */
326-+ YYSYMBOL_IDENT = 55, /* IDENT */
327-+ YYSYMBOL_KEYNAME = 56, /* KEYNAME */
328-+ YYSYMBOL_PARTIAL = 57, /* PARTIAL */
329-+ YYSYMBOL_DEFAULT = 58, /* DEFAULT */
330-+ YYSYMBOL_HIDDEN = 59, /* HIDDEN */
331-+ YYSYMBOL_ALPHANUMERIC_KEYS = 60, /* ALPHANUMERIC_KEYS */
332-+ YYSYMBOL_MODIFIER_KEYS = 61, /* MODIFIER_KEYS */
333-+ YYSYMBOL_KEYPAD_KEYS = 62, /* KEYPAD_KEYS */
334-+ YYSYMBOL_FUNCTION_KEYS = 63, /* FUNCTION_KEYS */
335-+ YYSYMBOL_ALTERNATE_GROUP = 64, /* ALTERNATE_GROUP */
336-+ YYSYMBOL_YYACCEPT = 65, /* $accept */
337-+ YYSYMBOL_XkbFile = 66, /* XkbFile */
338-+ YYSYMBOL_XkbCompositeMap = 67, /* XkbCompositeMap */
339-+ YYSYMBOL_XkbCompositeType = 68, /* XkbCompositeType */
340-+ YYSYMBOL_XkbMapConfigList = 69, /* XkbMapConfigList */
341-+ YYSYMBOL_XkbMapConfig = 70, /* XkbMapConfig */
342-+ YYSYMBOL_FileType = 71, /* FileType */
343-+ YYSYMBOL_OptFlags = 72, /* OptFlags */
344-+ YYSYMBOL_Flags = 73, /* Flags */
345-+ YYSYMBOL_Flag = 74, /* Flag */
346-+ YYSYMBOL_DeclList = 75, /* DeclList */
347-+ YYSYMBOL_Decl = 76, /* Decl */
348-+ YYSYMBOL_VarDecl = 77, /* VarDecl */
349-+ YYSYMBOL_KeyNameDecl = 78, /* KeyNameDecl */
350-+ YYSYMBOL_KeyAliasDecl = 79, /* KeyAliasDecl */
351-+ YYSYMBOL_VModDecl = 80, /* VModDecl */
352-+ YYSYMBOL_VModDefList = 81, /* VModDefList */
353-+ YYSYMBOL_VModDef = 82, /* VModDef */
354-+ YYSYMBOL_InterpretDecl = 83, /* InterpretDecl */
355-+ YYSYMBOL_InterpretMatch = 84, /* InterpretMatch */
356-+ YYSYMBOL_VarDeclList = 85, /* VarDeclList */
357-+ YYSYMBOL_KeyTypeDecl = 86, /* KeyTypeDecl */
358-+ YYSYMBOL_SymbolsDecl = 87, /* SymbolsDecl */
359-+ YYSYMBOL_SymbolsBody = 88, /* SymbolsBody */
360-+ YYSYMBOL_SymbolsVarDecl = 89, /* SymbolsVarDecl */
361-+ YYSYMBOL_ArrayInit = 90, /* ArrayInit */
362-+ YYSYMBOL_GroupCompatDecl = 91, /* GroupCompatDecl */
363-+ YYSYMBOL_ModMapDecl = 92, /* ModMapDecl */
364-+ YYSYMBOL_LedMapDecl = 93, /* LedMapDecl */
365-+ YYSYMBOL_LedNameDecl = 94, /* LedNameDecl */
366-+ YYSYMBOL_ShapeDecl = 95, /* ShapeDecl */
367-+ YYSYMBOL_SectionDecl = 96, /* SectionDecl */
368-+ YYSYMBOL_SectionBody = 97, /* SectionBody */
369-+ YYSYMBOL_SectionBodyItem = 98, /* SectionBodyItem */
370-+ YYSYMBOL_RowBody = 99, /* RowBody */
371-+ YYSYMBOL_RowBodyItem = 100, /* RowBodyItem */
372-+ YYSYMBOL_Keys = 101, /* Keys */
373-+ YYSYMBOL_Key = 102, /* Key */
374-+ YYSYMBOL_OverlayDecl = 103, /* OverlayDecl */
375-+ YYSYMBOL_OverlayKeyList = 104, /* OverlayKeyList */
376-+ YYSYMBOL_OverlayKey = 105, /* OverlayKey */
377-+ YYSYMBOL_OutlineList = 106, /* OutlineList */
378-+ YYSYMBOL_OutlineInList = 107, /* OutlineInList */
379-+ YYSYMBOL_CoordList = 108, /* CoordList */
380-+ YYSYMBOL_Coord = 109, /* Coord */
381-+ YYSYMBOL_DoodadDecl = 110, /* DoodadDecl */
382-+ YYSYMBOL_DoodadType = 111, /* DoodadType */
383-+ YYSYMBOL_FieldSpec = 112, /* FieldSpec */
384-+ YYSYMBOL_Element = 113, /* Element */
385-+ YYSYMBOL_OptMergeMode = 114, /* OptMergeMode */
386-+ YYSYMBOL_MergeMode = 115, /* MergeMode */
387-+ YYSYMBOL_OptExprList = 116, /* OptExprList */
388-+ YYSYMBOL_ExprList = 117, /* ExprList */
389-+ YYSYMBOL_Expr = 118, /* Expr */
390-+ YYSYMBOL_Term = 119, /* Term */
391-+ YYSYMBOL_ActionList = 120, /* ActionList */
392-+ YYSYMBOL_Action = 121, /* Action */
393-+ YYSYMBOL_Lhs = 122, /* Lhs */
394-+ YYSYMBOL_Terminal = 123, /* Terminal */
395-+ YYSYMBOL_OptKeySymList = 124, /* OptKeySymList */
396-+ YYSYMBOL_KeySymList = 125, /* KeySymList */
397-+ YYSYMBOL_KeySyms = 126, /* KeySyms */
398-+ YYSYMBOL_KeySym = 127, /* KeySym */
399-+ YYSYMBOL_SignedNumber = 128, /* SignedNumber */
400-+ YYSYMBOL_Number = 129, /* Number */
401-+ YYSYMBOL_Float = 130, /* Float */
402-+ YYSYMBOL_Integer = 131, /* Integer */
403-+ YYSYMBOL_KeyCode = 132, /* KeyCode */
404-+ YYSYMBOL_Ident = 133, /* Ident */
405-+ YYSYMBOL_String = 134, /* String */
406-+ YYSYMBOL_OptMapName = 135, /* OptMapName */
407-+ YYSYMBOL_MapName = 136 /* MapName */
408-+};
409-+typedef enum yysymbol_kind_t yysymbol_kind_t;
410-+
411-+
412-+
413-+
414-+#ifdef short
415-+# undef short
416++#ifdef YYSTYPE
417++#undef YYSTYPE_IS_DECLARED
418++#define YYSTYPE_IS_DECLARED 1
419 +#endif
420-+
421-+/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
422-+ <limits.h> and (if available) <stdint.h> are included
423-+ so that the code can choose integer types of a good width. */
424-+
425-+#ifndef __PTRDIFF_MAX__
426-+# include <limits.h> /* INFRINGES ON USER NAME SPACE */
427-+# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
428-+# include <stdint.h> /* INFRINGES ON USER NAME SPACE */
429-+# define YY_STDINT_H
430++#ifndef YYSTYPE_IS_DECLARED
431++#define YYSTYPE_IS_DECLARED 1
432++#line 165 "parser.y"
433++typedef union YYSTYPE {
434++ int64_t num;
435++ enum xkb_file_type file_type;
436++ char *str;
437++ xkb_atom_t atom;
438++ enum merge_mode merge;
439++ enum xkb_map_flags mapFlags;
440++ xkb_keysym_t keysym;
441++ ParseCommon *any;
442++ struct { ParseCommon *head; ParseCommon *last; } anyList;
443++ ExprDef *expr;
444++ struct { ExprDef *head; ExprDef *last; } exprList;
445++ VarDef *var;
446++ struct { VarDef *head; VarDef *last; } varList;
447++ VModDef *vmod;
448++ struct { VModDef *head; VModDef *last; } vmodList;
449++ InterpDef *interp;
450++ KeyTypeDef *keyType;
451++ SymbolsDef *syms;
452++ ModMapDef *modMask;
453++ GroupCompatDef *groupCompat;
454++ LedMapDef *ledMap;
455++ LedNameDef *ledName;
456++ KeycodeDef *keyCode;
457++ KeyAliasDef *keyAlias;
458++ void *geom;
459++ XkbFile *file;
460++ struct { XkbFile *head; XkbFile *last; } fileList;
461++} YYSTYPE;
462++#endif /* !YYSTYPE_IS_DECLARED */
463++#line 211 "parser.c"
464++
465++/* compatibility with bison */
466++#ifdef YYPARSE_PARAM
467++/* compatibility with FreeBSD */
468++# ifdef YYPARSE_PARAM_TYPE
469++# define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
470++# else
471++# define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
472 +# endif
473-+#endif
474-+
475-+/* Narrow types that promote to a signed type and that can represent a
476-+ signed or unsigned integer of at least N bits. In tables they can
477-+ save space and decrease cache pressure. Promoting to a signed type
478-+ helps avoid bugs in integer arithmetic. */
479-+
480-+#ifdef __INT_LEAST8_MAX__
481-+typedef __INT_LEAST8_TYPE__ yytype_int8;
482-+#elif defined YY_STDINT_H
483-+typedef int_least8_t yytype_int8;
484-+#else
485-+typedef signed char yytype_int8;
486-+#endif
487-+
488-+#ifdef __INT_LEAST16_MAX__
489-+typedef __INT_LEAST16_TYPE__ yytype_int16;
490-+#elif defined YY_STDINT_H
491-+typedef int_least16_t yytype_int16;
492-+#else
493-+typedef short yytype_int16;
494-+#endif
495-+
496-+/* Work around bug in HP-UX 11.23, which defines these macros
497-+ incorrectly for preprocessor constants. This workaround can likely
498-+ be removed in 2023, as HPE has promised support for HP-UX 11.23
499-+ (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of
500-+ <https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>. */
501-+#ifdef __hpux
502-+# undef UINT_LEAST8_MAX
503-+# undef UINT_LEAST16_MAX
504-+# define UINT_LEAST8_MAX 255
505-+# define UINT_LEAST16_MAX 65535
506-+#endif
507-+
508-+#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
509-+typedef __UINT_LEAST8_TYPE__ yytype_uint8;
510-+#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
511-+ && UINT_LEAST8_MAX <= INT_MAX)
512-+typedef uint_least8_t yytype_uint8;
513-+#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
514-+typedef unsigned char yytype_uint8;
515 +#else
516-+typedef short yytype_uint8;
517++# define YYPARSE_DECL() yyparse(struct parser_param *param)
518 +#endif
519 +
520-+#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
521-+typedef __UINT_LEAST16_TYPE__ yytype_uint16;
522-+#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
523-+ && UINT_LEAST16_MAX <= INT_MAX)
524-+typedef uint_least16_t yytype_uint16;
525-+#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
526-+typedef unsigned short yytype_uint16;
527-+#else
528-+typedef int yytype_uint16;
529-+#endif
530-+
531-+#ifndef YYPTRDIFF_T
532-+# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
533-+# define YYPTRDIFF_T __PTRDIFF_TYPE__
534-+# define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
535-+# elif defined PTRDIFF_MAX
536-+# ifndef ptrdiff_t
537-+# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
538-+# endif
539-+# define YYPTRDIFF_T ptrdiff_t
540-+# define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
541++/* Parameters sent to lex. */
542++#ifdef YYLEX_PARAM
543++# ifdef YYLEX_PARAM_TYPE
544++# define YYLEX_DECL() yylex(YYSTYPE *yylval, YYLEX_PARAM_TYPE YYLEX_PARAM)
545 +# else
546-+# define YYPTRDIFF_T long
547-+# define YYPTRDIFF_MAXIMUM LONG_MAX
548++# define YYLEX_DECL() yylex(YYSTYPE *yylval, void * YYLEX_PARAM)
549 +# endif
550++# define YYLEX yylex(&yylval, YYLEX_PARAM)
551++#else
552++# define YYLEX_DECL() yylex(YYSTYPE *yylval, struct scanner *param_scanner)
553++# define YYLEX yylex(&yylval, param_scanner)
554 +#endif
555 +
556-+#ifndef YYSIZE_T
557-+# ifdef __SIZE_TYPE__
558-+# define YYSIZE_T __SIZE_TYPE__
559-+# elif defined size_t
560-+# define YYSIZE_T size_t
561-+# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
562-+# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
563-+# define YYSIZE_T size_t
564-+# else
565-+# define YYSIZE_T unsigned
566-+# endif
567++/* Parameters sent to yyerror. */
568++#ifndef YYERROR_DECL
569++#define YYERROR_DECL() yyerror(struct parser_param *param, const char *s)
570 +#endif
571-+
572-+#define YYSIZE_MAXIMUM \
573-+ YY_CAST (YYPTRDIFF_T, \
574-+ (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
575-+ ? YYPTRDIFF_MAXIMUM \
576-+ : YY_CAST (YYSIZE_T, -1)))
577-+
578-+#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
579-+
580-+
581-+/* Stored state numbers (used for stacks). */
582-+typedef yytype_int16 yy_state_t;
583-+
584-+/* State numbers in computations. */
585-+typedef int yy_state_fast_t;
586-+
587-+#ifndef YY_
588-+# if defined YYENABLE_NLS && YYENABLE_NLS
589-+# if ENABLE_NLS
590-+# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
591-+# define YY_(Msgid) dgettext ("bison-runtime", Msgid)
592-+# endif
593-+# endif
594-+# ifndef YY_
595-+# define YY_(Msgid) Msgid
596-+# endif
597++#ifndef YYERROR_CALL
598++#define YYERROR_CALL(msg) yyerror(param, msg)
599 +#endif
600 +
601-+
602-+#ifndef YY_ATTRIBUTE_PURE
603-+# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
604-+# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
605-+# else
606-+# define YY_ATTRIBUTE_PURE
607-+# endif
608++#ifndef YYDESTRUCT_DECL
609++#define YYDESTRUCT_DECL() yydestruct(const char *msg, int psymb, YYSTYPE *val, struct parser_param *param)
610 +#endif
611-+
612-+#ifndef YY_ATTRIBUTE_UNUSED
613-+# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
614-+# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
615-+# else
616-+# define YY_ATTRIBUTE_UNUSED
617-+# endif
618++#ifndef YYDESTRUCT_CALL
619++#define YYDESTRUCT_CALL(msg, psymb, val) yydestruct(msg, psymb, val, param)
620 +#endif
621 +
622-+/* Suppress unused-variable warnings by "using" E. */
623-+#if ! defined lint || defined __GNUC__
624-+# define YY_USE(E) ((void) (E))
625-+#else
626-+# define YY_USE(E) /* empty */
627++extern int YYPARSE_DECL();
628++
629++#define END_OF_FILE 0
630++#define ERROR_TOK 255
631++#define XKB_KEYMAP 1
632++#define XKB_KEYCODES 2
633++#define XKB_TYPES 3
634++#define XKB_SYMBOLS 4
635++#define XKB_COMPATMAP 5
636++#define XKB_GEOMETRY 6
637++#define XKB_SEMANTICS 7
638++#define XKB_LAYOUT 8
639++#define INCLUDE 10
640++#define OVERRIDE 11
641++#define AUGMENT 12
642++#define REPLACE 13
643++#define ALTERNATE 14
644++#define VIRTUAL_MODS 20
645++#define TYPE 21
646++#define INTERPRET 22
647++#define ACTION_TOK 23
648++#define KEY 24
649++#define ALIAS 25
650++#define GROUP 26
651++#define MODIFIER_MAP 27
652++#define INDICATOR 28
653++#define SHAPE 29
654++#define KEYS 30
655++#define ROW 31
656++#define SECTION 32
657++#define OVERLAY 33
658++#define TEXT 34
659++#define OUTLINE 35
660++#define SOLID 36
661++#define LOGO 37
662++#define VIRTUAL 38
663++#define EQUALS 40
664++#define PLUS 41
665++#define MINUS 42
666++#define DIVIDE 43
667++#define TIMES 44
668++#define OBRACE 45
669++#define CBRACE 46
670++#define OPAREN 47
671++#define CPAREN 48
672++#define OBRACKET 49
673++#define CBRACKET 50
674++#define DOT 51
675++#define COMMA 52
676++#define SEMI 53
677++#define EXCLAM 54
678++#define INVERT 55
679++#define STRING 60
680++#define INTEGER 61
681++#define FLOAT 62
682++#define IDENT 63
683++#define KEYNAME 64
684++#define PARTIAL 70
685++#define DEFAULT 71
686++#define HIDDEN 72
687++#define ALPHANUMERIC_KEYS 73
688++#define MODIFIER_KEYS 74
689++#define KEYPAD_KEYS 75
690++#define FUNCTION_KEYS 76
691++#define ALTERNATE_GROUP 77
692++#define YYERRCODE 256
693++typedef int YYINT;
694++static const YYINT _xkbcommon_lhs[] = { -1,
695++ 0, 0, 0, 70, 9, 9, 9, 69, 69, 68,
696++ 10, 10, 10, 10, 10, 13, 13, 12, 12, 11,
697++ 11, 11, 11, 11, 11, 11, 11, 22, 22, 22,
698++ 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
699++ 21, 21, 21, 21, 37, 37, 37, 52, 53, 43,
700++ 42, 42, 41, 41, 44, 45, 45, 39, 39, 46,
701++ 47, 40, 40, 38, 38, 38, 38, 38, 27, 27,
702++ 49, 48, 50, 51, 51, 54, 54, 55, 56, 56,
703++ 57, 57, 57, 57, 57, 58, 58, 59, 59, 60,
704++ 60, 61, 61, 62, 63, 63, 64, 65, 65, 66,
705++ 66, 66, 33, 33, 32, 67, 6, 6, 6, 6,
706++ 16, 16, 18, 18, 18, 18, 18, 18, 18, 18,
707++ 18, 18, 18, 8, 8, 7, 7, 7, 7, 7,
708++ 34, 34, 35, 35, 23, 23, 23, 23, 23, 23,
709++ 24, 24, 24, 24, 24, 24, 24, 24, 36, 36,
710++ 31, 25, 25, 25, 25, 26, 26, 26, 26, 29,
711++ 29, 30, 30, 30, 30, 28, 20, 20, 20, 5,
712++ 5, 2, 2, 4, 3, 1, 17, 17, 19, 15,
713++ 15, 14,
714++};
715++static const YYINT _xkbcommon_len[] = { 2,
716++ 1, 1, 1, 7, 1, 1, 1, 2, 1, 7,
717++ 1, 1, 1, 1, 1, 1, 0, 2, 1, 1,
718++ 1, 1, 1, 1, 1, 1, 1, 2, 3, 0,
719++ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
720++ 2, 2, 2, 2, 4, 2, 3, 4, 5, 3,
721++ 3, 1, 1, 3, 6, 3, 1, 2, 1, 6,
722++ 6, 3, 1, 3, 3, 1, 2, 1, 3, 3,
723++ 5, 6, 6, 5, 6, 6, 6, 6, 2, 1,
724++ 5, 1, 1, 1, 1, 2, 1, 5, 1, 3,
725++ 1, 1, 3, 6, 3, 1, 3, 3, 1, 3,
726++ 5, 3, 3, 1, 5, 6, 1, 1, 1, 1,
727++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
728++ 1, 1, 1, 1, 0, 1, 1, 1, 1, 1,
729++ 1, 0, 3, 1, 3, 3, 3, 3, 3, 1,
730++ 2, 2, 2, 2, 1, 4, 1, 3, 3, 1,
731++ 4, 1, 3, 4, 6, 1, 1, 1, 1, 1,
732++ 0, 3, 3, 1, 1, 3, 1, 1, 1, 2,
733++ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
734++ 0, 1,
735++};
736++static const YYINT _xkbcommon_defred[] = { 0,
737++ 3, 20, 21, 22, 23, 24, 25, 26, 27, 0,
738++ 19, 0, 0, 2, 1, 18, 5, 11, 12, 14,
739++ 13, 15, 6, 7, 0, 0, 182, 180, 0, 0,
740++ 0, 30, 0, 9, 0, 0, 0, 8, 126, 128,
741++ 127, 129, 130, 0, 0, 0, 28, 4, 10, 44,
742++ 0, 0, 0, 113, 0, 0, 0, 0, 0, 0,
743++ 121, 0, 0, 108, 109, 110, 0, 0, 177, 0,
744++ 178, 0, 0, 0, 112, 0, 31, 29, 32, 35,
745++ 36, 37, 38, 39, 40, 33, 34, 41, 42, 43,
746++ 0, 52, 0, 179, 0, 168, 175, 167, 169, 0,
747++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
748++ 0, 0, 0, 0, 0, 46, 0, 0, 0, 50,
749++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
750++ 0, 0, 47, 176, 0, 0, 115, 114, 116, 117,
751++ 118, 119, 120, 122, 123, 0, 0, 0, 0, 0,
752++ 174, 159, 157, 158, 0, 111, 156, 0, 140, 0,
753++ 147, 0, 0, 0, 51, 59, 0, 0, 0, 0,
754++ 0, 0, 0, 68, 63, 0, 0, 0, 0, 0,
755++ 0, 0, 0, 0, 0, 104, 0, 0, 99, 0,
756++ 0, 0, 82, 84, 0, 80, 85, 83, 0, 48,
757++ 0, 142, 145, 141, 0, 143, 144, 0, 0, 0,
758++ 0, 0, 154, 0, 0, 45, 0, 58, 0, 0,
759++ 0, 0, 0, 164, 165, 0, 0, 150, 0, 67,
760++ 0, 0, 0, 49, 71, 0, 0, 74, 0, 0,
761++ 0, 173, 172, 171, 0, 0, 0, 0, 0, 0,
762++ 0, 0, 0, 79, 0, 0, 148, 0, 0, 0,
763++ 0, 135, 138, 0, 0, 60, 55, 0, 0, 69,
764++ 0, 70, 0, 0, 65, 61, 62, 72, 0, 73,
765++ 100, 170, 0, 0, 0, 77, 103, 76, 98, 0,
766++ 89, 0, 87, 0, 78, 75, 106, 146, 155, 166,
767++ 0, 162, 163, 149, 0, 0, 0, 0, 86, 0,
768++ 0, 96, 151, 105, 101, 0, 92, 0, 91, 81,
769++ 0, 0, 0, 0, 0, 0, 97, 94, 95, 93,
770++ 88, 90,
771++};
772++#if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING)
773++static const YYINT _xkbcommon_stos[] = { 0,
774++ 0, 70, 71, 72, 73, 74, 75, 76, 77, 258,
775++ 269, 270, 271, 326, 328, 269, 1, 2, 3, 4,
776++ 5, 6, 7, 8, 267, 268, 60, 272, 273, 273,
777++ 45, 45, 271, 326, 327, 280, 46, 326, 10, 11,
778++ 12, 13, 14, 46, 265, 266, 279, 53, 53, 60,
779++ 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
780++ 31, 32, 34, 35, 36, 37, 38, 54, 63, 64,
781++ 71, 264, 274, 275, 276, 283, 295, 301, 302, 304,
782++ 305, 306, 307, 308, 309, 310, 311, 312, 313, 325,
783++ 275, 299, 300, 60, 277, 32, 61, 63, 261, 278,
784++ 303, 64, 64, 261, 275, 261, 277, 277, 277, 28,
785++ 275, 40, 277, 49, 51, 53, 40, 40, 52, 53,
786++ 45, 41, 45, 45, 40, 40, 45, 40, 45, 45,
787++ 45, 261, 53, 61, 259, 45, 21, 22, 24, 26,
788++ 27, 28, 29, 32, 34, 41, 42, 47, 54, 55,
789++ 62, 64, 261, 262, 274, 275, 277, 281, 282, 283,
790++ 284, 274, 281, 281, 299, 295, 297, 281, 297, 49,
791++ 54, 275, 283, 285, 296, 298, 64, 281, 281, 293,
792++ 281, 297, 45, 49, 275, 290, 291, 323, 324, 28,
793++ 31, 33, 295, 308, 314, 315, 320, 325, 40, 53,
794++ 297, 282, 283, 282, 281, 282, 282, 47, 41, 42,
795++ 43, 44, 50, 40, 49, 53, 46, 295, 46, 32,
796++ 45, 63, 274, 278, 286, 287, 288, 289, 294, 275,
797++ 40, 46, 52, 53, 53, 46, 52, 53, 46, 291,
798++ 42, 61, 62, 260, 263, 40, 46, 52, 46, 52,
799++ 45, 277, 46, 315, 281, 46, 48, 292, 293, 281,
800++ 281, 281, 281, 281, 281, 53, 53, 288, 47, 50,
801++ 52, 50, 52, 281, 285, 53, 296, 53, 281, 53,
802++ 46, 260, 52, 45, 281, 53, 290, 53, 324, 30,
803++ 295, 316, 317, 45, 53, 53, 53, 48, 50, 46,
804++ 292, 278, 286, 289, 263, 291, 45, 46, 317, 64,
805++ 321, 322, 48, 50, 46, 45, 64, 318, 319, 53,
806++ 40, 46, 52, 293, 46, 52, 64, 53, 322, 46,
807++ 53, 319,
808++};
809++#endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */
810++static const YYINT _xkbcommon_dgoto[] = { 10,
811++ 135, 244, 153, 154, 245, 72, 45, 46, 25, 26,
812++ 11, 12, 33, 28, 29, 155, 156, 75, 157, 224,
813++ 47, 36, 179, 159, 160, 161, 174, 225, 226, 227,
814++ 228, 186, 187, 258, 259, 229, 166, 175, 167, 176,
815++ 92, 93, 78, 79, 101, 80, 81, 82, 83, 194,
816++ 85, 86, 87, 88, 89, 195, 196, 292, 293, 318,
817++ 319, 197, 311, 312, 188, 189, 198, 14, 35, 15,
818++};
819++static const YYINT _xkbcommon_sindex[] = { 164,
820++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
821++ 0, 499, 823, 0, 0, 0, 0, 0, 0, 0,
822++ 0, 0, 0, 0, -2, -2, 0, 0, -13, 26,
823++ 499, 0, 623, 0, 154, 15, -44, 0, 0, 0,
824++ 0, 0, 0, 23, 32, 16, 0, 0, 0, 0,
825++ -56, 40, 2, 0, 98, 108, 121, -56, 6, 40,
826++ 0, 40, 0, 0, 0, 0, 189, -56, 0, 192,
827++ 0, 40, 79, 202, 0, 227, 0, 0, 0, 0,
828++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
829++ 253, 0, 141, 0, 269, 0, 0, 0, 0, 257,
830++ 282, 283, 290, 302, 300, 315, 333, 337, 351, 121,
831++ 320, 348, 366, 422, 776, 0, 422, 422, -56, 0,
832++ 752, 422, 752, 570, 368, 422, 422, 422, 752, -14,
833++ 514, 385, 0, 0, 380, 752, 0, 0, 0, 0,
834++ 0, 0, 0, 0, 0, 422, 422, 422, 422, 422,
835++ 0, 0, 0, 0, 97, 0, 0, 66, 0, 401,
836++ 0, 393, 115, 201, 0, 0, 584, 201, 622, 638,
837++ -56, 0, 412, 0, 0, -36, 402, 133, 201, -22,
838++ 260, 684, 408, 56, 418, 0, 74, 81, 0, 40,
839++ 414, 40, 0, 0, 468, 0, 0, 0, 422, 0,
840++ 700, 0, 0, 0, 326, 0, 0, 422, 422, 422,
841++ 422, 422, 0, 422, 422, 0, 407, 0, 421, 0,
842++ 36, 0, 424, 0, 0, 417, 423, 0, 255, 0,
843++ 330, 425, 570, 0, 0, 426, 422, 0, 427, 119,
844++ 160, 0, 0, 0, 429, 376, 434, 408, 435, 1,
845++ 738, 453, 463, 0, 268, 465, 0, 458, 472, 276,
846++ 276, 0, 0, 201, 345, 0, 0, 143, 422, 0,
847++ 36, 0, 776, 201, 0, 0, 0, 0, 201, 0,
848++ 0, 0, 56, 408, 201, 0, 0, 0, 0, 484,
849++ 0, 532, 0, 470, 0, 0, 0, 0, 0, 0,
850++ 496, 0, 0, 0, 502, 217, 10, 504, 0, 525,
851++ 220, 0, 0, 0, 0, 422, 0, 277, 0, 0,
852++ 503, 526, 470, 360, 527, 10, 0, 0, 0, 0,
853++ 0, 0,
854++};
855++static const YYINT _xkbcommon_rindex[] = { 847,
856++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
857++ 0, 855, 0, 0, 0, 0, 0, 0, 0, 0,
858++ 0, 0, 0, 0, 537, 537, 0, 0, 0, 0,
859++ 692, 0, 0, 0, 692, 254, 0, 0, 0, 0,
860++ 0, 0, 0, 0, 312, 0, 0, 0, 0, 0,
861++ 0, 55, 73, 0, 91, 0, 112, 129, 157, 161,
862++ 0, 219, 42, 0, 0, 0, 0, 0, 0, 0,
863++ 0, 0, 544, 222, 0, 0, 0, 0, 0, 0,
864++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
865++ 328, 0, 0, 0, 0, 0, 0, 0, 0, 543,
866++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
867++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
868++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
869++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
870++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
871++ 0, 0, 0, 0, 208, 0, 0, 0, 0, 636,
872++ 0, 467, 0, 361, 0, 0, 0, 545, 0, 539,
873++ 0, 139, 0, 0, 0, 0, 0, 0, 475, 0,
874++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 157,
875++ 275, 0, 0, 0, 0, 0, 0, 0, 0, 0,
876++ 0, 0, 0, 0, 0, 0, 0, 552, 0, 0,
877++ 0, 0, 0, 0, 0, 0, 0, 0, 0, -33,
878++ 0, 313, 0, 0, 0, 0, 559, 0, 0, 0,
879++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
880++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
881++ 0, 0, 0, 0, 0, 0, 0, 0, 566, 374,
882++ 420, 0, 0, 480, 0, 0, 0, 0, 552, 0,
883++ 0, 0, 0, 382, 0, 0, 0, 0, 535, 0,
884++ 0, 0, 0, 0, 383, 0, 0, 0, 0, 0,
885++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
886++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
887++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
888++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
889++ 0, 0,
890++};
891++#if YYBTYACC
892++static const YYINT _xkbcommon_cindex[] = { 0,
893++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
894++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
895++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
896++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
897++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
898++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
899++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
900++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
901++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
902++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
903++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
904++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
905++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
906++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
907++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
908++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
909++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
910++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
911++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
912++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
913++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
914++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
915++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
916++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
917++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
918++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
919++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
920++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
921++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
922++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
923++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
924++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
925++ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
926++ 0, 0,
927++};
928 +#endif
929-+
930-+/* Suppress an incorrect diagnostic about yylval being uninitialized. */
931-+#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__
932-+# if __GNUC__ * 100 + __GNUC_MINOR__ < 407
933-+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
934-+ _Pragma ("GCC diagnostic push") \
935-+ _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")
936-+# else
937-+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
938-+ _Pragma ("GCC diagnostic push") \
939-+ _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
940-+ _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
941-+# endif
942-+# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
943-+ _Pragma ("GCC diagnostic pop")
944-+#else
945-+# define YY_INITIAL_VALUE(Value) Value
946-+#endif
947-+#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
948-+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
949-+# define YY_IGNORE_MAYBE_UNINITIALIZED_END
950-+#endif
951-+#ifndef YY_INITIAL_VALUE
952-+# define YY_INITIAL_VALUE(Value) /* Nothing. */
953-+#endif
954-+
955-+#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
956-+# define YY_IGNORE_USELESS_CAST_BEGIN \
957-+ _Pragma ("GCC diagnostic push") \
958-+ _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
959-+# define YY_IGNORE_USELESS_CAST_END \
960-+ _Pragma ("GCC diagnostic pop")
961-+#endif
962-+#ifndef YY_IGNORE_USELESS_CAST_BEGIN
963-+# define YY_IGNORE_USELESS_CAST_BEGIN
964-+# define YY_IGNORE_USELESS_CAST_END
965-+#endif
966-+
967-+
968-+#define YY_ASSERT(E) ((void) (0 && (E)))
969-+
970-+#if !defined yyoverflow
971-+
972-+/* The parser invokes alloca or malloc; define the necessary symbols. */
973-+
974-+# ifdef YYSTACK_USE_ALLOCA
975-+# if YYSTACK_USE_ALLOCA
976-+# ifdef __GNUC__
977-+# define YYSTACK_ALLOC __builtin_alloca
978-+# elif defined __BUILTIN_VA_ARG_INCR
979-+# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
980-+# elif defined _AIX
981-+# define YYSTACK_ALLOC __alloca
982-+# elif defined _MSC_VER
983-+# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
984-+# define alloca _alloca
985-+# else
986-+# define YYSTACK_ALLOC alloca
987-+# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
988-+# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
989-+ /* Use EXIT_SUCCESS as a witness for stdlib.h. */
990-+# ifndef EXIT_SUCCESS
991-+# define EXIT_SUCCESS 0
992-+# endif
993-+# endif
994-+# endif
995-+# endif
996-+# endif
997-+
998-+# ifdef YYSTACK_ALLOC
999-+ /* Pacify GCC's 'empty if-body' warning. */
1000-+# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
1001-+# ifndef YYSTACK_ALLOC_MAXIMUM
1002-+ /* The OS might guarantee only one guard page at the bottom of the stack,
1003-+ and a page size can be as small as 4096 bytes. So we cannot safely
1004-+ invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
1005-+ to allow for a few compiler-allocated temporary stack slots. */
1006-+# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
1007-+# endif
1008-+# else
1009-+# define YYSTACK_ALLOC YYMALLOC
1010-+# define YYSTACK_FREE YYFREE
1011-+# ifndef YYSTACK_ALLOC_MAXIMUM
1012-+# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
1013-+# endif
1014-+# if (defined __cplusplus && ! defined EXIT_SUCCESS \
1015-+ && ! ((defined YYMALLOC || defined malloc) \
1016-+ && (defined YYFREE || defined free)))
1017-+# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1018-+# ifndef EXIT_SUCCESS
1019-+# define EXIT_SUCCESS 0
1020-+# endif
1021-+# endif
1022-+# ifndef YYMALLOC
1023-+# define YYMALLOC malloc
1024-+# if ! defined malloc && ! defined EXIT_SUCCESS
1025-+void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
1026-+# endif
1027-+# endif
1028-+# ifndef YYFREE
1029-+# define YYFREE free
1030-+# if ! defined free && ! defined EXIT_SUCCESS
1031-+void free (void *); /* INFRINGES ON USER NAME SPACE */
1032-+# endif
1033-+# endif
1034-+# endif
1035-+#endif /* !defined yyoverflow */
1036-+
1037-+#if (! defined yyoverflow \
1038-+ && (! defined __cplusplus \
1039-+ || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
1040-+
1041-+/* A type that is properly aligned for any stack member. */
1042-+union yyalloc
1043-+{
1044-+ yy_state_t yyss_alloc;
1045-+ YYSTYPE yyvs_alloc;
1046++static const YYINT _xkbcommon_gindex[] = { 0,
1047++ 0, 379, -51, 0, 334, 0, 0, 0, 0, 0,
1048++ 609, 0, 637, 0, 596, 14, -46, 0, -39, -52,
1049++ 0, 0, 85, 485, -35, 0, 392, 365, 0, 419,
1050++ 369, 391, -179, 388, -124, 0, -28, 430, -67, 0,
1051++ 533, 0, 0, 0, 0, 0, 0, 0, 0, 612,
1052++ 0, 0, 0, 0, 0, 0, 476, 0, 381, 0,
1053++ 349, 0, 0, 364, 0, 440, 628, 183, 0, 0,
1054 +};
1055-+
1056-+/* The size of the maximum gap between one aligned stack and the next. */
1057-+# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
1058-+
1059-+/* The size of an array large to enough to hold all stacks, each with
1060-+ N elements. */
1061-+# define YYSTACK_BYTES(N) \
1062-+ ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
1063-+ + YYSTACK_GAP_MAXIMUM)
1064-+
1065-+# define YYCOPY_NEEDED 1
1066-+
1067-+/* Relocate STACK from its old location to the new one. The
1068-+ local variables YYSIZE and YYSTACKSIZE give the old and new number of
1069-+ elements in the stack, and YYPTR gives the new location of the
1070-+ stack. Advance YYPTR to a properly aligned location for the next
1071-+ stack. */
1072-+# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
1073-+ do \
1074-+ { \
1075-+ YYPTRDIFF_T yynewbytes; \
1076-+ YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
1077-+ Stack = &yyptr->Stack_alloc; \
1078-+ yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
1079-+ yyptr += yynewbytes / YYSIZEOF (*yyptr); \
1080-+ } \
1081-+ while (0)
1082-+
1083-+#endif
1084-+
1085-+#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
1086-+/* Copy COUNT objects from SRC to DST. The source and destination do
1087-+ not overlap. */
1088-+# ifndef YYCOPY
1089-+# if defined __GNUC__ && 1 < __GNUC__
1090-+# define YYCOPY(Dst, Src, Count) \
1091-+ __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
1092-+# else
1093-+# define YYCOPY(Dst, Src, Count) \
1094-+ do \
1095-+ { \
1096-+ YYPTRDIFF_T yyi; \
1097-+ for (yyi = 0; yyi < (Count); yyi++) \
1098-+ (Dst)[yyi] = (Src)[yyi]; \
1099-+ } \
1100-+ while (0)
1101-+# endif
1102-+# endif
1103-+#endif /* !YYCOPY_NEEDED */
1104-+
1105-+/* YYFINAL -- State number of the termination state. */
1106-+#define YYFINAL 16
1107-+/* YYLAST -- Last index in YYTABLE. */
1108-+#define YYLAST 735
1109-+
1110-+/* YYNTOKENS -- Number of terminals. */
1111-+#define YYNTOKENS 65
1112-+/* YYNNTS -- Number of nonterminals. */
1113-+#define YYNNTS 72
1114-+/* YYNRULES -- Number of rules. */
1115-+#define YYNRULES 184
1116-+/* YYNSTATES -- Number of states. */
1117-+#define YYNSTATES 334
1118-+
1119-+/* YYMAXUTOK -- Last valid token kind. */
1120-+#define YYMAXUTOK 257
1121-+
1122-+
1123-+/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
1124-+ as returned by yylex, with out-of-bounds checking. */
1125-+#define YYTRANSLATE(YYX) \
1126-+ (0 <= (YYX) && (YYX) <= YYMAXUTOK \
1127-+ ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \
1128-+ : YYSYMBOL_YYUNDEF)
1129-+
1130-+/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
1131-+ as returned by yylex. */
1132-+static const yytype_int8 yytranslate[] =
1133-+{
1134-+ 0, 4, 5, 6, 7, 8, 9, 10, 11, 2,
1135-+ 12, 13, 14, 15, 16, 2, 2, 2, 2, 2,
1136-+ 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
1137-+ 27, 28, 29, 30, 31, 32, 33, 34, 35, 2,
1138-+ 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
1139-+ 46, 47, 48, 49, 50, 51, 2, 2, 2, 2,
1140-+ 52, 53, 54, 55, 56, 2, 2, 2, 2, 2,
1141-+ 57, 58, 59, 60, 61, 62, 63, 64, 2, 2,
1142-+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1143-+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1144-+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1145-+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1146-+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1147-+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1148-+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1149-+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1150-+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1151-+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1152-+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1153-+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1154-+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1155-+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1156-+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1157-+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1158-+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1159-+ 2, 2, 2, 2, 2, 3, 1, 2
1160++#define YYTABLESIZE 863
1161++static const YYINT _xkbcommon_table[] = { 74,
1162++ 100, 99, 180, 240, 91, 104, 69, 106, 48, 232,
1163++ 76, 105, 95, 122, 71, 233, 168, 77, 168, 107,
1164++ 108, 111, 109, 236, 39, 40, 41, 42, 43, 237,
1165++ 183, 31, 113, 96, 184, 51, 52, 53, 54, 55,
1166++ 56, 57, 58, 59, 60, 183, 61, 62, 69, 63,
1167++ 64, 65, 66, 67, 316, 169, 71, 27, 132, 73,
1168++ 44, 182, 97, 69, 98, 94, 97, 96, 201, 68,
1169++ 32, 71, 91, 317, 74, 49, 74, 172, 69, 70,
1170++ 221, 123, 74, 185, 74, 76, 71, 76, 173, 74,
1171++ 123, 50, 123, 76, 115, 76, 97, 241, 98, 94,
1172++ 76, 107, 193, 115, 306, 115, 209, 210, 211, 212,
1173++ 203, 203, 114, 203, 203, 213, 242, 243, 99, 247,
1174++ 74, 114, 74, 114, 230, 248, 249, 114, 162, 115,
1175++ 116, 76, 250, 76, 73, 74, 73, 73, 218, 116,
1176++ 218, 116, 73, 208, 73, 114, 76, 115, 74, 73,
1177++ 107, 117, 252, 218, 74, 209, 210, 211, 212, 76,
1178++ 117, 102, 117, 1, 281, 76, 193, 216, 118, 99,
1179++ 248, 103, 218, 209, 210, 211, 212, 118, 111, 118,
1180++ 73, 97, 73, 223, 66, 235, 172, 111, 300, 111,
1181++ 66, 324, 119, 120, 271, 73, 119, 173, 158, 37,
1182++ 120, 163, 164, 185, 74, 119, 168, 119, 73, 120,
1183++ 178, 120, 181, 34, 73, 76, 110, 38, 302, 99,
1184++ 242, 243, 291, 2, 3, 4, 5, 6, 7, 8,
1185++ 9, 112, 205, 2, 3, 4, 5, 6, 7, 8,
1186++ 9, 209, 210, 211, 212, 74, 73, 152, 152, 152,
1187++ 152, 152, 152, 152, 116, 152, 76, 152, 122, 152,
1188++ 152, 111, 315, 291, 73, 322, 117, 122, 248, 122,
1189++ 111, 323, 111, 125, 125, 125, 125, 125, 125, 125,
1190++ 125, 125, 125, 255, 125, 125, 223, 125, 125, 125,
1191++ 125, 125, 118, 260, 261, 262, 263, 122, 264, 265,
1192++ 209, 210, 211, 212, 272, 73, 273, 125, 209, 210,
1193++ 211, 212, 238, 121, 121, 274, 125, 125, 211, 212,
1194++ 296, 279, 325, 121, 125, 121, 123, 124, 326, 125,
1195++ 285, 124, 124, 124, 124, 124, 124, 124, 124, 124,
1196++ 124, 126, 124, 124, 127, 124, 124, 124, 124, 124,
1197++ 137, 138, 54, 139, 128, 140, 141, 142, 143, 177,
1198++ 61, 144, 167, 145, 167, 124, 209, 210, 211, 212,
1199++ 146, 147, 133, 257, 124, 124, 148, 129, 170, 53,
1200++ 53, 130, 124, 149, 150, 209, 210, 211, 212, 94,
1201++ 97, 151, 69, 152, 299, 131, 137, 138, 54, 139,
1202++ 71, 140, 141, 142, 143, 330, 61, 144, 134, 145,
1203++ 136, 237, 54, 54, 136, 136, 146, 147, 136, 136,
1204++ 284, 136, 148, 136, 199, 136, 136, 64, 102, 149,
1205++ 150, 177, 200, 64, 102, 94, 97, 151, 69, 152,
1206++ 214, 215, 137, 138, 54, 139, 71, 140, 141, 142,
1207++ 143, 231, 61, 144, 234, 145, 184, 246, 251, 266,
1208++ 137, 137, 146, 147, 137, 137, 270, 137, 148, 137,
1209++ 269, 137, 137, 267, 271, 149, 150, 276, 278, 280,
1210++ 283, 94, 97, 151, 69, 152, 286, 288, 137, 138,
1211++ 54, 139, 71, 140, 141, 190, 143, 294, 191, 144,
1212++ 192, 63, 64, 65, 66, 298, 153, 153, 153, 153,
1213++ 153, 153, 153, 253, 153, 295, 153, 297, 153, 153,
1214++ 134, 68, 134, 237, 139, 139, 134, 139, 307, 139,
1215++ 69, 139, 139, 310, 137, 138, 54, 139, 71, 140,
1216++ 141, 190, 143, 313, 191, 144, 192, 63, 64, 65,
1217++ 66, 314, 137, 138, 54, 139, 320, 140, 141, 142,
1218++ 143, 290, 61, 144, 321, 145, 327, 68, 2, 3,
1219++ 4, 5, 6, 7, 8, 9, 69, 308, 328, 331,
1220++ 133, 181, 133, 152, 71, 68, 133, 57, 161, 56,
1221++ 137, 138, 54, 139, 69, 140, 141, 142, 143, 132,
1222++ 61, 144, 71, 145, 137, 138, 54, 139, 160, 140,
1223++ 141, 142, 143, 131, 61, 144, 305, 145, 170, 282,
1224++ 16, 30, 275, 171, 18, 19, 20, 21, 22, 217,
1225++ 202, 204, 69, 206, 207, 303, 13, 68, 287, 268,
1226++ 71, 304, 137, 138, 54, 139, 69, 140, 141, 142,
1227++ 143, 165, 61, 144, 71, 145, 301, 84, 137, 138,
1228++ 54, 139, 277, 140, 141, 142, 143, 219, 61, 220,
1229++ 254, 145, 309, 90, 332, 68, 145, 145, 145, 145,
1230++ 145, 145, 221, 145, 69, 145, 329, 145, 145, 289,
1231++ 0, 0, 71, 17, 17, 17, 17, 17, 97, 0,
1232++ 222, 0, 0, 0, 137, 138, 54, 139, 71, 140,
1233++ 141, 142, 143, 0, 61, 144, 0, 145, 0, 0,
1234++ 137, 138, 54, 139, 0, 140, 141, 142, 143, 239,
1235++ 61, 144, 0, 145, 0, 0, 0, 68, 0, 0,
1236++ 0, 0, 0, 0, 0, 256, 69, 0, 0, 0,
1237++ 0, 0, 0, 68, 71, 0, 0, 0, 137, 138,
1238++ 54, 139, 69, 140, 141, 142, 143, 290, 61, 144,
1239++ 71, 145, 137, 138, 54, 139, 0, 140, 141, 142,
1240++ 143, 0, 61, 144, 0, 145, 0, 0, 0, 0,
1241++ 0, 68, 0, 0, 0, 0, 137, 138, 54, 139,
1242++ 69, 140, 141, 142, 143, 68, 61, 144, 71, 145,
1243++ 0, 0, 0, 0, 69, 0, 0, 0, 0, 0,
1244++ 0, 0, 71, 17, 18, 19, 20, 21, 22, 23,
1245++ 24, 0, 0, 0, 0, 0, 0, 0, 69, 0,
1246++ 0, 0, 0, 0, 0, 0, 71, 17, 17, 17,
1247++ 17, 17, 17, 17, 17, 16, 16, 16, 16, 16,
1248++ 16, 16, 16,
1249 +};
1250-+
1251-+#if YYDEBUG
1252-+/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
1253-+static const yytype_int16 yyrline[] =
1254-+{
1255-+ 0, 254, 254, 256, 258, 262, 268, 269, 270, 273,
1256-+ 275, 279, 287, 288, 289, 290, 291, 294, 295, 298,
1257-+ 299, 302, 303, 304, 305, 306, 307, 308, 309, 312,
1258-+ 327, 337, 340, 346, 351, 356, 361, 366, 371, 376,
1259-+ 381, 386, 391, 392, 393, 394, 401, 403, 405, 409,
1260-+ 413, 417, 421, 423, 427, 429, 433, 439, 441, 445,
1261-+ 447, 451, 457, 463, 465, 467, 470, 471, 472, 473,
1262-+ 474, 477, 479, 483, 487, 491, 495, 497, 501, 503,
1263-+ 507, 511, 512, 515, 517, 519, 521, 523, 527, 528,
1264-+ 531, 532, 536, 537, 540, 542, 546, 550, 551, 554,
1265-+ 557, 559, 563, 565, 567, 571, 573, 577, 581, 585,
1266-+ 586, 587, 588, 591, 592, 595, 597, 599, 601, 603,
1267-+ 605, 607, 609, 611, 613, 615, 619, 620, 623, 624,
1268-+ 625, 626, 627, 637, 638, 641, 643, 647, 649, 651,
1269-+ 653, 655, 657, 661, 663, 665, 667, 669, 671, 673,
1270-+ 675, 679, 681, 685, 689, 691, 693, 695, 699, 701,
1271-+ 703, 705, 709, 710, 713, 715, 717, 719, 723, 727,
1272-+ 735, 736, 756, 757, 760, 761, 764, 767, 770, 773,
1273-+ 774, 777, 780, 781, 784
1274++static const YYINT _xkbcommon_check[] = { 46,
1275++ 53, 53, 127, 183, 51, 57, 63, 59, 53, 46,
1276++ 46, 58, 52, 47, 71, 52, 50, 46, 52, 59,
1277++ 60, 68, 62, 46, 10, 11, 12, 13, 14, 52,
1278++ 45, 45, 72, 32, 49, 20, 21, 22, 23, 24,
1279++ 25, 26, 27, 28, 29, 45, 31, 32, 63, 34,
1280++ 35, 36, 37, 38, 45, 123, 71, 60, 110, 46,
1281++ 46, 129, 61, 63, 63, 60, 61, 32, 136, 54,
1282++ 45, 71, 119, 64, 121, 53, 123, 124, 63, 64,
1283++ 45, 40, 129, 130, 131, 121, 71, 123, 124, 136,
1284++ 49, 60, 51, 129, 40, 131, 61, 42, 63, 60,
1285++ 136, 60, 131, 49, 284, 51, 41, 42, 43, 44,
1286++ 146, 147, 40, 149, 150, 50, 61, 62, 170, 46,
1287++ 167, 49, 169, 51, 171, 52, 46, 49, 115, 51,
1288++ 40, 167, 52, 169, 121, 182, 123, 124, 167, 49,
1289++ 169, 51, 129, 47, 131, 49, 182, 51, 195, 136,
1290++ 190, 40, 192, 182, 201, 41, 42, 43, 44, 195,
1291++ 49, 64, 51, 0, 46, 201, 195, 53, 40, 221,
1292++ 52, 64, 201, 41, 42, 43, 44, 49, 40, 51,
1293++ 167, 61, 169, 170, 46, 53, 233, 49, 46, 51,
1294++ 52, 316, 52, 53, 52, 182, 40, 233, 114, 46,
1295++ 40, 117, 118, 250, 251, 49, 122, 51, 195, 49,
1296++ 126, 51, 128, 31, 201, 251, 28, 35, 271, 271,
1297++ 61, 62, 251, 70, 71, 72, 73, 74, 75, 76,
1298++ 77, 40, 148, 70, 71, 72, 73, 74, 75, 76,
1299++ 77, 41, 42, 43, 44, 292, 233, 40, 41, 42,
1300++ 43, 44, 45, 46, 53, 48, 292, 50, 40, 52,
1301++ 53, 40, 46, 292, 251, 46, 40, 49, 52, 51,
1302++ 49, 52, 51, 20, 21, 22, 23, 24, 25, 26,
1303++ 27, 28, 29, 199, 31, 32, 273, 34, 35, 36,
1304++ 37, 38, 40, 209, 210, 211, 212, 41, 214, 215,
1305++ 41, 42, 43, 44, 50, 292, 52, 54, 41, 42,
1306++ 43, 44, 53, 45, 40, 231, 63, 64, 43, 44,
1307++ 53, 237, 46, 49, 71, 51, 45, 45, 52, 40,
1308++ 246, 20, 21, 22, 23, 24, 25, 26, 27, 28,
1309++ 29, 40, 31, 32, 45, 34, 35, 36, 37, 38,
1310++ 21, 22, 23, 24, 40, 26, 27, 28, 29, 47,
1311++ 31, 32, 50, 34, 52, 54, 41, 42, 43, 44,
1312++ 41, 42, 53, 48, 63, 64, 47, 45, 49, 52,
1313++ 53, 45, 71, 54, 55, 41, 42, 43, 44, 60,
1314++ 61, 62, 63, 64, 50, 45, 21, 22, 23, 24,
1315++ 71, 26, 27, 28, 29, 46, 31, 32, 61, 34,
1316++ 45, 52, 52, 53, 41, 42, 41, 42, 45, 46,
1317++ 45, 48, 47, 50, 40, 52, 53, 46, 46, 54,
1318++ 55, 64, 53, 52, 52, 60, 61, 62, 63, 64,
1319++ 40, 49, 21, 22, 23, 24, 71, 26, 27, 28,
1320++ 29, 40, 31, 32, 53, 34, 49, 40, 45, 53,
1321++ 41, 42, 41, 42, 45, 46, 50, 48, 47, 50,
1322++ 47, 52, 53, 53, 52, 54, 55, 53, 53, 53,
1323++ 52, 60, 61, 62, 63, 64, 53, 53, 21, 22,
1324++ 23, 24, 71, 26, 27, 28, 29, 45, 31, 32,
1325++ 33, 34, 35, 36, 37, 48, 40, 41, 42, 43,
1326++ 44, 45, 46, 46, 48, 53, 50, 53, 52, 53,
1327++ 46, 54, 48, 52, 45, 46, 52, 48, 45, 50,
1328++ 63, 52, 53, 64, 21, 22, 23, 24, 71, 26,
1329++ 27, 28, 29, 48, 31, 32, 33, 34, 35, 36,
1330++ 37, 50, 21, 22, 23, 24, 53, 26, 27, 28,
1331++ 29, 30, 31, 32, 40, 34, 64, 54, 70, 71,
1332++ 72, 73, 74, 75, 76, 77, 63, 46, 53, 53,
1333++ 46, 45, 48, 40, 71, 54, 52, 45, 50, 45,
1334++ 21, 22, 23, 24, 63, 26, 27, 28, 29, 48,
1335++ 31, 32, 71, 34, 21, 22, 23, 24, 50, 26,
1336++ 27, 28, 29, 48, 31, 32, 283, 34, 49, 241,
1337++ 12, 26, 231, 54, 2, 3, 4, 5, 6, 46,
1338++ 146, 147, 63, 149, 150, 271, 0, 54, 248, 221,
1339++ 71, 273, 21, 22, 23, 24, 63, 26, 27, 28,
1340++ 29, 119, 31, 32, 71, 34, 269, 46, 21, 22,
1341++ 23, 24, 233, 26, 27, 28, 29, 46, 31, 32,
1342++ 195, 34, 292, 46, 326, 54, 41, 42, 43, 44,
1343++ 45, 46, 45, 48, 63, 50, 323, 52, 53, 250,
1344++ -1, -1, 71, 2, 3, 4, 5, 6, 61, -1,
1345++ 63, -1, -1, -1, 21, 22, 23, 24, 71, 26,
1346++ 27, 28, 29, -1, 31, 32, -1, 34, -1, -1,
1347++ 21, 22, 23, 24, -1, 26, 27, 28, 29, 46,
1348++ 31, 32, -1, 34, -1, -1, -1, 54, -1, -1,
1349++ -1, -1, -1, -1, -1, 46, 63, -1, -1, -1,
1350++ -1, -1, -1, 54, 71, -1, -1, -1, 21, 22,
1351++ 23, 24, 63, 26, 27, 28, 29, 30, 31, 32,
1352++ 71, 34, 21, 22, 23, 24, -1, 26, 27, 28,
1353++ 29, -1, 31, 32, -1, 34, -1, -1, -1, -1,
1354++ -1, 54, -1, -1, -1, -1, 21, 22, 23, 24,
1355++ 63, 26, 27, 28, 29, 54, 31, 32, 71, 34,
1356++ -1, -1, -1, -1, 63, -1, -1, -1, -1, -1,
1357++ -1, -1, 71, 1, 2, 3, 4, 5, 6, 7,
1358++ 8, -1, -1, -1, -1, -1, -1, -1, 63, -1,
1359++ -1, -1, -1, -1, -1, -1, 71, 1, 2, 3,
1360++ 4, 5, 6, 7, 8, 1, 2, 3, 4, 5,
1361++ 6, 7, 8,
1362++};
1363++#if YYBTYACC
1364++static const YYINT _xkbcommon_ctable[] = { -1,
1365++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1366++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1367++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1368++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1369++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1370++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1371++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1372++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1373++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1374++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1375++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1376++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1377++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1378++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1379++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1380++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1381++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1382++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1383++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1384++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1385++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1386++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1387++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1388++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1389++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1390++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1391++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1392++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1393++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1394++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1395++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1396++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1397++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1398++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1399++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1400++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1401++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1402++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1403++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1404++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1405++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1406++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1407++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1408++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1409++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1410++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1411++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1412++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1413++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1414++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1415++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1416++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1417++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1418++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1419++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1420++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1421++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1422++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1423++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1424++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1425++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1426++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1427++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1428++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1429++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1430++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1431++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1432++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1433++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1434++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1435++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1436++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1437++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1438++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1439++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1440++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1441++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1442++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1443++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1444++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1445++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1446++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1447++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1448++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1449++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1450++ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1451++ -1, -1,
1452 +};
1453 +#endif
1454++#define YYFINAL 10
1455++#ifndef YYDEBUG
1456++#define YYDEBUG 0
1457++#endif
1458++#define YYMAXTOKEN 256
1459++#define YYUNDFTOKEN 329
1460++#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
1461++#if YYDEBUG
1462++static const char *const _xkbcommon_name[] = {
1463++
1464++"$end","XKB_KEYMAP","XKB_KEYCODES","XKB_TYPES","XKB_SYMBOLS","XKB_COMPATMAP",
1465++"XKB_GEOMETRY","XKB_SEMANTICS","XKB_LAYOUT",0,"INCLUDE","OVERRIDE","AUGMENT",
1466++"REPLACE","ALTERNATE",0,0,0,0,0,"VIRTUAL_MODS","TYPE","INTERPRET","ACTION_TOK",
1467++"KEY","ALIAS","GROUP","MODIFIER_MAP","INDICATOR","SHAPE","KEYS","ROW","SECTION",
1468++"OVERLAY","TEXT","OUTLINE","SOLID","LOGO","VIRTUAL",0,"EQUALS","PLUS","MINUS",
1469++"DIVIDE","TIMES","OBRACE","CBRACE","OPAREN","CPAREN","OBRACKET","CBRACKET",
1470++"DOT","COMMA","SEMI","EXCLAM","INVERT",0,0,0,0,"STRING","INTEGER","FLOAT",
1471++"IDENT","KEYNAME",0,0,0,0,0,"PARTIAL","DEFAULT","HIDDEN","ALPHANUMERIC_KEYS",
1472++"MODIFIER_KEYS","KEYPAD_KEYS","FUNCTION_KEYS","ALTERNATE_GROUP",0,0,0,0,0,0,0,0,
1473++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,
1474++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,
1475++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,
1476++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,
1477++0,0,0,0,0,0,0,0,0,"ERROR_TOK","error","$accept","XkbFile","KeyCode","Number",
1478++"Integer","Float","SignedNumber","DoodadType","MergeMode","OptMergeMode",
1479++"XkbCompositeType","FileType","Flag","Flags","OptFlags","MapName","OptMapName",
1480++"FieldSpec","Ident","Element","String","KeySym","Decl","DeclList","Expr","Term",
1481++"Lhs","Terminal","ArrayInit","KeySyms","OptKeySymList","KeySymList","Action",
1482++"Coord","CoordList","OptExprList","ExprList","ActionList","VarDecl",
1483++"SymbolsVarDecl","VarDeclList","SymbolsBody","VModDef","VModDefList","VModDecl",
1484++"InterpretDecl","InterpretMatch","KeyTypeDecl","SymbolsDecl","ModMapDecl",
1485++"GroupCompatDecl","LedMapDecl","LedNameDecl","KeyNameDecl","KeyAliasDecl",
1486++"ShapeDecl","SectionDecl","SectionBody","SectionBodyItem","RowBody",
1487++"RowBodyItem","Keys","Key","OverlayDecl","OverlayKeyList","OverlayKey",
1488++"OutlineList","OutlineInList","DoodadDecl","XkbMapConfig","XkbMapConfigList",
1489++"XkbCompositeMap","illegal-symbol",
1490++};
1491++static const char *const _xkbcommon_rule[] = {
1492++"$accept : XkbFile",
1493++"XkbFile : XkbCompositeMap",
1494++"XkbFile : XkbMapConfig",
1495++"XkbFile : END_OF_FILE",
1496++"XkbCompositeMap : OptFlags XkbCompositeType OptMapName OBRACE XkbMapConfigList CBRACE SEMI",
1497++"XkbCompositeType : XKB_KEYMAP",
1498++"XkbCompositeType : XKB_SEMANTICS",
1499++"XkbCompositeType : XKB_LAYOUT",
1500++"XkbMapConfigList : XkbMapConfigList XkbMapConfig",
1501++"XkbMapConfigList : XkbMapConfig",
1502++"XkbMapConfig : OptFlags FileType OptMapName OBRACE DeclList CBRACE SEMI",
1503++"FileType : XKB_KEYCODES",
1504++"FileType : XKB_TYPES",
1505++"FileType : XKB_COMPATMAP",
1506++"FileType : XKB_SYMBOLS",
1507++"FileType : XKB_GEOMETRY",
1508++"OptFlags : Flags",
1509++"OptFlags :",
1510++"Flags : Flags Flag",
1511++"Flags : Flag",
1512++"Flag : PARTIAL",
1513++"Flag : DEFAULT",
1514++"Flag : HIDDEN",
1515++"Flag : ALPHANUMERIC_KEYS",
1516++"Flag : MODIFIER_KEYS",
1517++"Flag : KEYPAD_KEYS",
1518++"Flag : FUNCTION_KEYS",
1519++"Flag : ALTERNATE_GROUP",
1520++"DeclList : DeclList Decl",
1521++"DeclList : DeclList OptMergeMode VModDecl",
1522++"DeclList :",
1523++"Decl : OptMergeMode VarDecl",
1524++"Decl : OptMergeMode InterpretDecl",
1525++"Decl : OptMergeMode KeyNameDecl",
1526++"Decl : OptMergeMode KeyAliasDecl",
1527++"Decl : OptMergeMode KeyTypeDecl",
1528++"Decl : OptMergeMode SymbolsDecl",
1529++"Decl : OptMergeMode ModMapDecl",
1530++"Decl : OptMergeMode GroupCompatDecl",
1531++"Decl : OptMergeMode LedMapDecl",
1532++"Decl : OptMergeMode LedNameDecl",
1533++"Decl : OptMergeMode ShapeDecl",
1534++"Decl : OptMergeMode SectionDecl",
1535++"Decl : OptMergeMode DoodadDecl",
1536++"Decl : MergeMode STRING",
1537++"VarDecl : Lhs EQUALS Expr SEMI",
1538++"VarDecl : Ident SEMI",
1539++"VarDecl : EXCLAM Ident SEMI",
1540++"KeyNameDecl : KEYNAME EQUALS KeyCode SEMI",
1541++"KeyAliasDecl : ALIAS KEYNAME EQUALS KEYNAME SEMI",
1542++"VModDecl : VIRTUAL_MODS VModDefList SEMI",
1543++"VModDefList : VModDefList COMMA VModDef",
1544++"VModDefList : VModDef",
1545++"VModDef : Ident",
1546++"VModDef : Ident EQUALS Expr",
1547++"InterpretDecl : INTERPRET InterpretMatch OBRACE VarDeclList CBRACE SEMI",
1548++"InterpretMatch : KeySym PLUS Expr",
1549++"InterpretMatch : KeySym",
1550++"VarDeclList : VarDeclList VarDecl",
1551++"VarDeclList : VarDecl",
1552++"KeyTypeDecl : TYPE String OBRACE VarDeclList CBRACE SEMI",
1553++"SymbolsDecl : KEY KEYNAME OBRACE SymbolsBody CBRACE SEMI",
1554++"SymbolsBody : SymbolsBody COMMA SymbolsVarDecl",
1555++"SymbolsBody : SymbolsVarDecl",
1556++"SymbolsVarDecl : Lhs EQUALS Expr",
1557++"SymbolsVarDecl : Lhs EQUALS ArrayInit",
1558++"SymbolsVarDecl : Ident",
1559++"SymbolsVarDecl : EXCLAM Ident",
1560++"SymbolsVarDecl : ArrayInit",
1561++"ArrayInit : OBRACKET OptKeySymList CBRACKET",
1562++"ArrayInit : OBRACKET ActionList CBRACKET",
1563++"GroupCompatDecl : GROUP Integer EQUALS Expr SEMI",
1564++"ModMapDecl : MODIFIER_MAP Ident OBRACE ExprList CBRACE SEMI",
1565++"LedMapDecl : INDICATOR String OBRACE VarDeclList CBRACE SEMI",
1566++"LedNameDecl : INDICATOR Integer EQUALS Expr SEMI",
1567++"LedNameDecl : VIRTUAL INDICATOR Integer EQUALS Expr SEMI",
1568++"ShapeDecl : SHAPE String OBRACE OutlineList CBRACE SEMI",
1569++"ShapeDecl : SHAPE String OBRACE CoordList CBRACE SEMI",
1570++"SectionDecl : SECTION String OBRACE SectionBody CBRACE SEMI",
1571++"SectionBody : SectionBody SectionBodyItem",
1572++"SectionBody : SectionBodyItem",
1573++"SectionBodyItem : ROW OBRACE RowBody CBRACE SEMI",
1574++"SectionBodyItem : VarDecl",
1575++"SectionBodyItem : DoodadDecl",
1576++"SectionBodyItem : LedMapDecl",
1577++"SectionBodyItem : OverlayDecl",
1578++"RowBody : RowBody RowBodyItem",
1579++"RowBody : RowBodyItem",
1580++"RowBodyItem : KEYS OBRACE Keys CBRACE SEMI",
1581++"RowBodyItem : VarDecl",
1582++"Keys : Keys COMMA Key",
1583++"Keys : Key",
1584++"Key : KEYNAME",
1585++"Key : OBRACE ExprList CBRACE",
1586++"OverlayDecl : OVERLAY String OBRACE OverlayKeyList CBRACE SEMI",
1587++"OverlayKeyList : OverlayKeyList COMMA OverlayKey",
1588++"OverlayKeyList : OverlayKey",
1589++"OverlayKey : KEYNAME EQUALS KEYNAME",
1590++"OutlineList : OutlineList COMMA OutlineInList",
1591++"OutlineList : OutlineInList",
1592++"OutlineInList : OBRACE CoordList CBRACE",
1593++"OutlineInList : Ident EQUALS OBRACE CoordList CBRACE",
1594++"OutlineInList : Ident EQUALS Expr",
1595++"CoordList : CoordList COMMA Coord",
1596++"CoordList : Coord",
1597++"Coord : OBRACKET SignedNumber COMMA SignedNumber CBRACKET",
1598++"DoodadDecl : DoodadType String OBRACE VarDeclList CBRACE SEMI",
1599++"DoodadType : TEXT",
1600++"DoodadType : OUTLINE",
1601++"DoodadType : SOLID",
1602++"DoodadType : LOGO",
1603++"FieldSpec : Ident",
1604++"FieldSpec : Element",
1605++"Element : ACTION_TOK",
1606++"Element : INTERPRET",
1607++"Element : TYPE",
1608++"Element : KEY",
1609++"Element : GROUP",
1610++"Element : MODIFIER_MAP",
1611++"Element : INDICATOR",
1612++"Element : SHAPE",
1613++"Element : ROW",
1614++"Element : SECTION",
1615++"Element : TEXT",
1616++"OptMergeMode : MergeMode",
1617++"OptMergeMode :",
1618++"MergeMode : INCLUDE",
1619++"MergeMode : AUGMENT",
1620++"MergeMode : OVERRIDE",
1621++"MergeMode : REPLACE",
1622++"MergeMode : ALTERNATE",
1623++"OptExprList : ExprList",
1624++"OptExprList :",
1625++"ExprList : ExprList COMMA Expr",
1626++"ExprList : Expr",
1627++"Expr : Expr DIVIDE Expr",
1628++"Expr : Expr PLUS Expr",
1629++"Expr : Expr MINUS Expr",
1630++"Expr : Expr TIMES Expr",
1631++"Expr : Lhs EQUALS Expr",
1632++"Expr : Term",
1633++"Term : MINUS Term",
1634++"Term : PLUS Term",
1635++"Term : EXCLAM Term",
1636++"Term : INVERT Term",
1637++"Term : Lhs",
1638++"Term : FieldSpec OPAREN OptExprList CPAREN",
1639++"Term : Terminal",
1640++"Term : OPAREN Expr CPAREN",
1641++"ActionList : ActionList COMMA Action",
1642++"ActionList : Action",
1643++"Action : FieldSpec OPAREN OptExprList CPAREN",
1644++"Lhs : FieldSpec",
1645++"Lhs : FieldSpec DOT FieldSpec",
1646++"Lhs : FieldSpec OBRACKET Expr CBRACKET",
1647++"Lhs : FieldSpec DOT FieldSpec OBRACKET Expr CBRACKET",
1648++"Terminal : String",
1649++"Terminal : Integer",
1650++"Terminal : Float",
1651++"Terminal : KEYNAME",
1652++"OptKeySymList : KeySymList",
1653++"OptKeySymList :",
1654++"KeySymList : KeySymList COMMA KeySym",
1655++"KeySymList : KeySymList COMMA KeySyms",
1656++"KeySymList : KeySym",
1657++"KeySymList : KeySyms",
1658++"KeySyms : OBRACE KeySymList CBRACE",
1659++"KeySym : IDENT",
1660++"KeySym : SECTION",
1661++"KeySym : Integer",
1662++"SignedNumber : MINUS Number",
1663++"SignedNumber : Number",
1664++"Number : FLOAT",
1665++"Number : INTEGER",
1666++"Float : FLOAT",
1667++"Integer : INTEGER",
1668++"KeyCode : INTEGER",
1669++"Ident : IDENT",
1670++"Ident : DEFAULT",
1671++"String : STRING",
1672++"OptMapName : MapName",
1673++"OptMapName :",
1674++"MapName : STRING",
1675 +
1676-+/** Accessing symbol of state STATE. */
1677-+#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
1678-+
1679-+#if YYDEBUG || 0
1680-+/* The user-facing name of the symbol whose (internal) number is
1681-+ YYSYMBOL. No bounds checking. */
1682-+static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED;
1683-+
1684-+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1685-+ First, the terminals, then, starting at YYNTOKENS, nonterminals. */
1686-+static const char *const yytname[] =
1687-+{
1688-+ "END_OF_FILE", "error", "\"invalid token\"", "ERROR_TOK", "XKB_KEYMAP",
1689-+ "XKB_KEYCODES", "XKB_TYPES", "XKB_SYMBOLS", "XKB_COMPATMAP",
1690-+ "XKB_GEOMETRY", "XKB_SEMANTICS", "XKB_LAYOUT", "INCLUDE", "OVERRIDE",
1691-+ "AUGMENT", "REPLACE", "ALTERNATE", "VIRTUAL_MODS", "TYPE", "INTERPRET",
1692-+ "ACTION_TOK", "KEY", "ALIAS", "GROUP", "MODIFIER_MAP", "INDICATOR",
1693-+ "SHAPE", "KEYS", "ROW", "SECTION", "OVERLAY", "TEXT", "OUTLINE", "SOLID",
1694-+ "LOGO", "VIRTUAL", "EQUALS", "PLUS", "MINUS", "DIVIDE", "TIMES",
1695-+ "OBRACE", "CBRACE", "OPAREN", "CPAREN", "OBRACKET", "CBRACKET", "DOT",
1696-+ "COMMA", "SEMI", "EXCLAM", "INVERT", "STRING", "INTEGER", "FLOAT",
1697-+ "IDENT", "KEYNAME", "PARTIAL", "DEFAULT", "HIDDEN", "ALPHANUMERIC_KEYS",
1698-+ "MODIFIER_KEYS", "KEYPAD_KEYS", "FUNCTION_KEYS", "ALTERNATE_GROUP",
1699-+ "$accept", "XkbFile", "XkbCompositeMap", "XkbCompositeType",
1700-+ "XkbMapConfigList", "XkbMapConfig", "FileType", "OptFlags", "Flags",
1701-+ "Flag", "DeclList", "Decl", "VarDecl", "KeyNameDecl", "KeyAliasDecl",
1702-+ "VModDecl", "VModDefList", "VModDef", "InterpretDecl", "InterpretMatch",
1703-+ "VarDeclList", "KeyTypeDecl", "SymbolsDecl", "SymbolsBody",
1704-+ "SymbolsVarDecl", "ArrayInit", "GroupCompatDecl", "ModMapDecl",
1705-+ "LedMapDecl", "LedNameDecl", "ShapeDecl", "SectionDecl", "SectionBody",
1706-+ "SectionBodyItem", "RowBody", "RowBodyItem", "Keys", "Key",
1707-+ "OverlayDecl", "OverlayKeyList", "OverlayKey", "OutlineList",
1708-+ "OutlineInList", "CoordList", "Coord", "DoodadDecl", "DoodadType",
1709-+ "FieldSpec", "Element", "OptMergeMode", "MergeMode", "OptExprList",
1710-+ "ExprList", "Expr", "Term", "ActionList", "Action", "Lhs", "Terminal",
1711-+ "OptKeySymList", "KeySymList", "KeySyms", "KeySym", "SignedNumber",
1712-+ "Number", "Float", "Integer", "KeyCode", "Ident", "String", "OptMapName",
1713-+ "MapName", YY_NULLPTR
1714 +};
1715++#endif
1716 +
1717-+static const char *
1718-+yysymbol_name (yysymbol_kind_t yysymbol)
1719-+{
1720-+ return yytname[yysymbol];
1721-+}
1722++#if YYDEBUG
1723++int yydebug;
1724 +#endif
1725 +
1726-+#define YYPACT_NINF (-182)
1727++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1728++#ifndef YYLLOC_DEFAULT
1729++#define YYLLOC_DEFAULT(loc, rhs, n) \
1730++do \
1731++{ \
1732++ if (n == 0) \
1733++ { \
1734++ (loc).first_line = YYRHSLOC(rhs, 0).last_line; \
1735++ (loc).first_column = YYRHSLOC(rhs, 0).last_column; \
1736++ (loc).last_line = YYRHSLOC(rhs, 0).last_line; \
1737++ (loc).last_column = YYRHSLOC(rhs, 0).last_column; \
1738++ } \
1739++ else \
1740++ { \
1741++ (loc).first_line = YYRHSLOC(rhs, 1).first_line; \
1742++ (loc).first_column = YYRHSLOC(rhs, 1).first_column; \
1743++ (loc).last_line = YYRHSLOC(rhs, n).last_line; \
1744++ (loc).last_column = YYRHSLOC(rhs, n).last_column; \
1745++ } \
1746++} while (0)
1747++#endif /* YYLLOC_DEFAULT */
1748++#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1749++#if YYBTYACC
1750 +
1751-+#define yypact_value_is_default(Yyn) \
1752-+ ((Yyn) == YYPACT_NINF)
1753++#ifndef YYLVQUEUEGROWTH
1754++#define YYLVQUEUEGROWTH 32
1755++#endif
1756++#endif /* YYBTYACC */
1757 +
1758-+#define YYTABLE_NINF (-180)
1759++/* define the initial stack-sizes */
1760++#ifdef YYSTACKSIZE
1761++#undef YYMAXDEPTH
1762++#define YYMAXDEPTH YYSTACKSIZE
1763++#else
1764++#ifdef YYMAXDEPTH
1765++#define YYSTACKSIZE YYMAXDEPTH
1766++#else
1767++#define YYSTACKSIZE 10000
1768++#define YYMAXDEPTH 10000
1769++#endif
1770++#endif
1771 +
1772-+#define yytable_value_is_error(Yyn) \
1773-+ 0
1774++#ifndef YYINITSTACKSIZE
1775++#define YYINITSTACKSIZE 200
1776++#endif
1777 +
1778-+/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1779-+ STATE-NUM. */
1780-+static const yytype_int16 yypact[] =
1781-+{
1782-+ 176, -182, -182, -182, -182, -182, -182, -182, -182, -182,
1783-+ 6, -182, -182, 271, 227, -182, -182, -182, -182, -182,
1784-+ -182, -182, -182, -182, -182, -38, -38, -182, -182, -24,
1785-+ -182, 33, 227, -182, 210, -182, 353, 44, 5, -182,
1786-+ -182, -182, -182, -182, -182, 32, -182, 13, 41, -182,
1787-+ -182, -48, 55, 11, -182, 79, 87, 58, -48, -2,
1788-+ 55, -182, 55, 72, -182, -182, -182, 107, -48, -182,
1789-+ 110, -182, -182, -182, -182, -182, -182, -182, -182, -182,
1790-+ -182, -182, -182, -182, -182, -182, 55, -18, -182, 127,
1791-+ 121, -182, 66, -182, 138, -182, 136, -182, -182, -182,
1792-+ 144, 147, -182, 152, 180, 182, 178, 184, 187, 188,
1793-+ 190, 58, 198, 201, 214, 367, 677, 367, -182, -48,
1794-+ -182, 367, 663, 663, 367, 494, 200, 367, 367, 367,
1795-+ 663, 68, 449, 223, -182, -182, 212, 663, -182, -182,
1796-+ -182, -182, -182, -182, -182, -182, -182, 367, 367, 367,
1797-+ 367, 367, -182, -182, 57, 157, -182, 224, -182, -182,
1798-+ -182, -182, -182, 218, 91, -182, 333, -182, 509, 537,
1799-+ 333, 552, -48, 1, -182, -182, 228, 40, 216, 143,
1800-+ 70, 333, 150, 593, 247, -30, 97, -182, 105, -182,
1801-+ 261, 55, 259, 55, -182, -182, 408, -182, -182, -182,
1802-+ 367, -182, 608, -182, -182, -182, 287, -182, -182, 367,
1803-+ 367, 367, 367, 367, -182, 367, 367, -182, 252, -182,
1804-+ 253, 264, 24, 269, 272, 163, -182, 273, 270, -182,
1805-+ -182, -182, 280, 494, 285, -182, -182, 283, 367, -182,
1806-+ 284, 112, 8, -182, -182, 294, -182, 299, -36, 304,
1807-+ 247, 326, 649, 279, 307, -182, 204, 316, -182, 322,
1808-+ 320, 111, 111, -182, -182, 333, 211, -182, -182, 116,
1809-+ 367, -182, 677, -182, 24, -182, -182, -182, 333, -182,
1810-+ 333, -182, -182, -182, -30, -182, -182, -182, -182, 247,
1811-+ 333, 334, -182, 466, -182, 318, -182, -182, -182, -182,
1812-+ -182, -182, 339, -182, -182, -182, 343, 120, 14, 345,
1813-+ -182, 361, 124, -182, -182, -182, -182, 367, -182, 131,
1814-+ -182, -182, 344, 350, 318, 166, 352, 14, -182, -182,
1815-+ -182, -182, -182, -182
1816-+};
1817++typedef struct {
1818++ unsigned stacksize;
1819++ YYINT *s_base;
1820++ YYINT *s_mark;
1821++ YYINT *s_last;
1822++ YYSTYPE *l_base;
1823++ YYSTYPE *l_mark;
1824++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1825++ YYLTYPE *p_base;
1826++ YYLTYPE *p_mark;
1827++#endif
1828++} YYSTACKDATA;
1829++#if YYBTYACC
1830 +
1831-+/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
1832-+ Performed when YYTABLE does not specify something else to do. Zero
1833-+ means the default is an error. */
1834-+static const yytype_uint8 yydefact[] =
1835++struct YYParseState_s
1836 +{
1837-+ 18, 4, 21, 22, 23, 24, 25, 26, 27, 28,
1838-+ 0, 2, 3, 0, 17, 20, 1, 6, 12, 13,
1839-+ 15, 14, 16, 7, 8, 183, 183, 19, 184, 0,
1840-+ 182, 0, 18, 31, 18, 10, 0, 127, 0, 9,
1841-+ 128, 130, 129, 131, 132, 0, 29, 0, 126, 5,
1842-+ 11, 0, 117, 116, 115, 118, 0, 119, 120, 121,
1843-+ 122, 123, 124, 125, 110, 111, 112, 0, 0, 179,
1844-+ 0, 180, 32, 34, 35, 30, 33, 36, 37, 39,
1845-+ 38, 40, 41, 42, 43, 44, 0, 154, 114, 0,
1846-+ 113, 45, 0, 53, 54, 181, 0, 170, 177, 169,
1847-+ 0, 58, 171, 0, 0, 0, 0, 0, 0, 0,
1848-+ 0, 0, 0, 0, 0, 0, 0, 0, 47, 0,
1849-+ 51, 0, 0, 0, 0, 65, 0, 0, 0, 0,
1850-+ 0, 0, 0, 0, 48, 178, 0, 0, 117, 116,
1851-+ 118, 119, 120, 121, 122, 124, 125, 0, 0, 0,
1852-+ 0, 0, 176, 161, 154, 0, 142, 147, 149, 160,
1853-+ 159, 113, 158, 155, 0, 52, 55, 60, 0, 0,
1854-+ 57, 163, 0, 0, 64, 70, 0, 113, 0, 0,
1855-+ 0, 136, 0, 0, 0, 0, 0, 101, 0, 106,
1856-+ 0, 121, 123, 0, 84, 86, 0, 82, 87, 85,
1857-+ 0, 49, 0, 144, 147, 143, 0, 145, 146, 134,
1858-+ 0, 0, 0, 0, 156, 0, 0, 46, 0, 59,
1859-+ 0, 170, 0, 169, 0, 0, 152, 0, 162, 167,
1860-+ 166, 69, 0, 0, 0, 50, 73, 0, 0, 76,
1861-+ 0, 0, 0, 175, 174, 0, 173, 0, 0, 0,
1862-+ 0, 0, 0, 0, 0, 81, 0, 0, 150, 0,
1863-+ 133, 138, 139, 137, 140, 141, 0, 61, 56, 0,
1864-+ 134, 72, 0, 71, 0, 62, 63, 67, 66, 74,
1865-+ 135, 75, 102, 172, 0, 78, 100, 79, 105, 0,
1866-+ 104, 0, 91, 0, 89, 0, 80, 77, 108, 148,
1867-+ 157, 168, 0, 151, 165, 164, 0, 0, 0, 0,
1868-+ 88, 0, 0, 98, 153, 107, 103, 0, 94, 0,
1869-+ 93, 83, 0, 0, 0, 0, 0, 0, 99, 96,
1870-+ 97, 95, 90, 92
1871++ struct YYParseState_s *save; /* Previously saved parser state */
1872++ YYSTACKDATA yystack; /* saved parser stack */
1873++ int state; /* saved parser state */
1874++ int errflag; /* saved error recovery status */
1875++ int lexeme; /* saved index of the conflict lexeme in the lexical queue */
1876++ YYINT ctry; /* saved index in yyctable[] for this conflict */
1877 +};
1878++typedef struct YYParseState_s YYParseState;
1879++#endif /* YYBTYACC */
1880++#line 808 "parser.y"
1881 +
1882-+/* YYPGOTO[NTERM-NUM]. */
1883-+static const yytype_int16 yypgoto[] =
1884++XkbFile *
1885++parse(struct xkb_context *ctx, struct scanner *scanner, const char *map)
1886 +{
1887-+ -182, -182, -182, -182, -182, 181, -182, 402, -182, 389,
1888-+ -182, -182, -35, -182, -182, -182, -182, 288, -182, -182,
1889-+ -50, -182, -182, -182, 173, 174, -182, -182, 362, -182,
1890-+ -182, -182, -182, 215, -182, 119, -182, 86, -182, -182,
1891-+ 90, -182, 167, -181, 185, 369, -182, -27, -182, -182,
1892-+ -182, 154, -126, 83, 76, -182, 158, -31, -182, -182,
1893-+ 221, 170, -52, 161, 205, -182, -44, -182, -47, -34,
1894-+ 420, -182
1895-+};
1896++ int ret;
1897++ XkbFile *first = NULL;
1898++ struct parser_param param = {
1899++ .scanner = scanner,
1900++ .ctx = ctx,
1901++ .rtrn = NULL,
1902++ .more_maps = false,
1903++ };
1904 +
1905-+/* YYDEFGOTO[NTERM-NUM]. */
1906-+static const yytype_int16 yydefgoto[] =
1907-+{
1908-+ 0, 10, 11, 25, 34, 12, 26, 36, 14, 15,
1909-+ 37, 46, 167, 73, 74, 75, 92, 93, 76, 100,
1910-+ 168, 77, 78, 173, 174, 175, 79, 80, 195, 82,
1911-+ 83, 84, 196, 197, 293, 294, 319, 320, 198, 312,
1912-+ 313, 186, 187, 188, 189, 199, 86, 154, 88, 47,
1913-+ 48, 259, 260, 181, 156, 225, 226, 157, 158, 227,
1914-+ 228, 229, 230, 245, 246, 159, 160, 136, 161, 162,
1915-+ 29, 30
1916-+};
1917++ /*
1918++ * If we got a specific map, we look for it exclusively and return
1919++ * immediately upon finding it. Otherwise, we need to get the
1920++ * default map. If we find a map marked as default, we return it
1921++ * immediately. If there are no maps marked as default, we return
1922++ * the first map in the file.
1923++ */
1924 +
1925-+/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
1926-+ positive, shift that token. If negative, reduce the rule whose
1927-+ number is the opposite. If YYTABLE_NINF, syntax error. */
1928-+static const yytype_int16 yytable[] =
1929-+{
1930-+ 90, 101, 180, 241, 94, 184, 16, 69, 242, 102,
1931-+ 71, 106, 72, 105, 28, 107, 89, 32, 96, 69,
1932-+ 87, 112, 71, 243, 244, 108, 109, 115, 110, 116,
1933-+ 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
1934-+ 97, 61, 62, 232, 63, 64, 65, 66, 67, 233,
1935-+ 95, 98, 114, 97, 49, 317, 40, 41, 42, 43,
1936-+ 44, 243, 244, 68, 98, 222, 99, 133, 69, 70,
1937-+ 318, 71, 94, 169, 33, 90, 90, 98, 177, 99,
1938-+ 183, 50, -68, 90, 190, 90, 45, 202, -68, 163,
1939-+ 90, 89, 89, 91, 176, 87, 87, 194, 87, 89,
1940-+ 209, 89, 115, 87, 116, 87, 89, 95, 307, 184,
1941-+ 87, 98, 237, 185, 119, 120, 204, 204, 238, 204,
1942-+ 204, 90, 90, 69, -109, 231, 71, 102, 210, 211,
1943-+ 212, 213, 111, 219, 219, 103, 90, 89, 89, 247,
1944-+ 217, 87, 87, 104, 224, 248, 113, 249, 219, 90,
1945-+ 212, 213, 89, 250, 282, 90, 87, 108, 301, 253,
1946-+ 250, 194, 316, 117, 274, 89, 323, 219, 250, 87,
1947-+ 118, 89, 324, 326, 121, 87, 1, 122, 102, 327,
1948-+ 210, 211, 212, 213, 124, 123, 177, 210, 211, 212,
1949-+ 213, 325, 236, 125, 210, 211, 212, 213, 155, 239,
1950-+ 164, 190, 176, 214, 166, 90, 87, 170, 331, 271,
1951-+ 179, 272, 182, 35, 238, 39, 126, 292, 127, 128,
1952-+ 129, 89, 305, 203, 205, 87, 207, 208, 130, 131,
1953-+ 102, 132, 206, 2, 3, 4, 5, 6, 7, 8,
1954-+ 9, 210, 211, 212, 213, 224, 90, 134, 210, 211,
1955-+ 212, 213, 38, 297, 135, 137, 178, 300, 292, 200,
1956-+ 215, 201, 89, 216, 234, 235, 87, 2, 3, 4,
1957-+ 5, 6, 7, 8, 9, 17, 18, 19, 20, 21,
1958-+ 22, 23, 24, 256, 2, 3, 4, 5, 6, 7,
1959-+ 8, 9, 185, 261, 262, 263, 264, 251, 265, 266,
1960-+ 252, 267, 268, 138, 139, 54, 140, -124, 141, 142,
1961-+ 143, 144, -179, 61, 145, 270, 146, 278, 274, 273,
1962-+ 295, 280, 147, 148, 210, 211, 212, 213, 149, 275,
1963-+ 171, 258, 279, 281, 290, 150, 151, 95, 98, 152,
1964-+ 69, 153, 284, 71, 138, 139, 54, 140, 285, 141,
1965-+ 142, 143, 144, 287, 61, 145, 296, 146, 18, 19,
1966-+ 20, 21, 22, 147, 148, 298, 299, 289, 238, 149,
1967-+ 210, 211, 212, 213, 311, 308, 150, 151, 95, 98,
1968-+ 152, 69, 153, 314, 71, 138, 139, 54, 140, 315,
1969-+ 141, 142, 143, 144, 321, 61, 145, 322, 146, 329,
1970-+ 328, 332, 13, 27, 147, 148, 276, 165, 277, 81,
1971-+ 149, 255, 310, 333, 330, 286, 85, 150, 151, 95,
1972-+ 98, 152, 69, 153, 302, 71, 138, 139, 54, 140,
1973-+ 303, 141, 142, 191, 144, 288, 192, 145, 193, 63,
1974-+ 64, 65, 66, 269, 304, 306, 31, 283, 0, 0,
1975-+ 254, 0, 0, 0, 0, 0, 0, 0, 68, 0,
1976-+ 0, 0, 0, 69, 0, 0, 71, 138, 139, 54,
1977-+ 140, 0, 141, 142, 191, 144, 0, 192, 145, 193,
1978-+ 63, 64, 65, 66, 138, 139, 54, 140, 0, 141,
1979-+ 142, 143, 144, 291, 61, 145, 0, 146, 0, 68,
1980-+ 0, 0, 0, 0, 69, 0, 0, 71, 309, 0,
1981-+ 0, 0, 138, 139, 54, 140, 68, 141, 142, 143,
1982-+ 144, 69, 61, 145, 71, 146, 0, 138, 139, 54,
1983-+ 140, 0, 141, 142, 143, 144, 0, 61, 145, 171,
1984-+ 146, 0, 0, 0, 172, 0, 0, 0, 0, 69,
1985-+ 0, 218, 71, 0, 0, 138, 139, 54, 140, 68,
1986-+ 141, 142, 143, 144, 69, 61, 145, 71, 146, 0,
1987-+ 138, 139, 54, 140, 0, 141, 142, 143, 144, 220,
1988-+ 61, 221, 0, 146, 0, 0, 0, 68, 0, 0,
1989-+ 0, 0, 69, 222, 0, 71, 0, 0, 0, 0,
1990-+ 0, 0, 0, 0, 0, 98, 0, 223, 0, 0,
1991-+ 71, 138, 139, 54, 140, 0, 141, 142, 143, 144,
1992-+ 0, 61, 145, 0, 146, 0, 138, 139, 54, 140,
1993-+ 0, 141, 142, 143, 144, 240, 61, 145, 0, 146,
1994-+ 0, 0, 0, 68, 0, 0, 0, 0, 69, 0,
1995-+ 257, 71, 0, 0, 0, 0, 0, 0, 68, 0,
1996-+ 0, 0, 0, 69, 0, 0, 71, 138, 139, 54,
1997-+ 140, 0, 141, 142, 143, 144, 291, 61, 145, 0,
1998-+ 146, 138, 139, 54, 140, 0, 141, 142, 143, 144,
1999-+ 0, 61, 145, 0, 146, 138, 139, 54, 140, 68,
2000-+ 141, 142, 143, 144, 69, 61, 145, 71, 146, 0,
2001-+ 0, 0, 0, 68, 0, 0, 0, 0, 69, 0,
2002-+ 0, 71, 0, 0, 0, 0, 0, 0, 0, 0,
2003-+ 0, 0, 69, 0, 0, 71
2004-+};
2005++ while ((ret = yyparse(¶m)) == 0 && param.more_maps) {
2006++ if (map) {
2007++ if (streq_not_null(map, param.rtrn->name))
2008++ return param.rtrn;
2009++ else
2010++ FreeXkbFile(param.rtrn);
2011++ }
2012++ else {
2013++ if (param.rtrn->flags & MAP_IS_DEFAULT) {
2014++ FreeXkbFile(first);
2015++ return param.rtrn;
2016++ }
2017++ else if (!first) {
2018++ first = param.rtrn;
2019++ }
2020++ else {
2021++ FreeXkbFile(param.rtrn);
2022++ }
2023++ }
2024++ param.rtrn = NULL;
2025++ }
2026 +
2027-+static const yytype_int16 yycheck[] =
2028-+{
2029-+ 47, 53, 128, 184, 51, 41, 0, 55, 38, 53,
2030-+ 58, 58, 47, 57, 52, 59, 47, 41, 52, 55,
2031-+ 47, 68, 58, 53, 54, 59, 60, 45, 62, 47,
2032-+ 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
2033-+ 29, 28, 29, 42, 31, 32, 33, 34, 35, 48,
2034-+ 52, 53, 86, 29, 49, 41, 12, 13, 14, 15,
2035-+ 16, 53, 54, 50, 53, 41, 55, 111, 55, 56,
2036-+ 56, 58, 119, 123, 41, 122, 123, 53, 125, 55,
2037-+ 130, 49, 42, 130, 131, 132, 42, 137, 48, 116,
2038-+ 137, 122, 123, 52, 125, 122, 123, 132, 125, 130,
2039-+ 43, 132, 45, 130, 47, 132, 137, 52, 289, 41,
2040-+ 137, 53, 42, 45, 48, 49, 147, 148, 48, 150,
2041-+ 151, 168, 169, 55, 52, 172, 58, 171, 37, 38,
2042-+ 39, 40, 25, 168, 169, 56, 183, 168, 169, 42,
2043-+ 49, 168, 169, 56, 171, 48, 36, 42, 183, 196,
2044-+ 39, 40, 183, 48, 42, 202, 183, 191, 42, 193,
2045-+ 48, 196, 42, 36, 48, 196, 42, 202, 48, 196,
2046-+ 49, 202, 48, 42, 36, 202, 0, 41, 222, 48,
2047-+ 37, 38, 39, 40, 37, 41, 233, 37, 38, 39,
2048-+ 40, 317, 49, 41, 37, 38, 39, 40, 115, 49,
2049-+ 117, 248, 233, 46, 121, 252, 233, 124, 42, 46,
2050-+ 127, 48, 129, 32, 48, 34, 36, 252, 36, 41,
2051-+ 36, 252, 274, 147, 148, 252, 150, 151, 41, 41,
2052-+ 274, 41, 149, 57, 58, 59, 60, 61, 62, 63,
2053-+ 64, 37, 38, 39, 40, 272, 293, 49, 37, 38,
2054-+ 39, 40, 42, 49, 53, 41, 56, 46, 293, 36,
2055-+ 36, 49, 293, 45, 36, 49, 293, 57, 58, 59,
2056-+ 60, 61, 62, 63, 64, 4, 5, 6, 7, 8,
2057-+ 9, 10, 11, 200, 57, 58, 59, 60, 61, 62,
2058-+ 63, 64, 45, 210, 211, 212, 213, 36, 215, 216,
2059-+ 41, 49, 49, 18, 19, 20, 21, 43, 23, 24,
2060-+ 25, 26, 43, 28, 29, 43, 31, 234, 48, 46,
2061-+ 41, 238, 37, 38, 37, 38, 39, 40, 43, 49,
2062-+ 45, 44, 49, 49, 251, 50, 51, 52, 53, 54,
2063-+ 55, 56, 48, 58, 18, 19, 20, 21, 49, 23,
2064-+ 24, 25, 26, 49, 28, 29, 49, 31, 5, 6,
2065-+ 7, 8, 9, 37, 38, 49, 44, 41, 48, 43,
2066-+ 37, 38, 39, 40, 56, 41, 50, 51, 52, 53,
2067-+ 54, 55, 56, 44, 58, 18, 19, 20, 21, 46,
2068-+ 23, 24, 25, 26, 49, 28, 29, 36, 31, 49,
2069-+ 56, 49, 0, 14, 37, 38, 233, 119, 234, 47,
2070-+ 43, 196, 293, 327, 324, 248, 47, 50, 51, 52,
2071-+ 53, 54, 55, 56, 270, 58, 18, 19, 20, 21,
2072-+ 272, 23, 24, 25, 26, 250, 28, 29, 30, 31,
2073-+ 32, 33, 34, 222, 274, 284, 26, 242, -1, -1,
2074-+ 42, -1, -1, -1, -1, -1, -1, -1, 50, -1,
2075-+ -1, -1, -1, 55, -1, -1, 58, 18, 19, 20,
2076-+ 21, -1, 23, 24, 25, 26, -1, 28, 29, 30,
2077-+ 31, 32, 33, 34, 18, 19, 20, 21, -1, 23,
2078-+ 24, 25, 26, 27, 28, 29, -1, 31, -1, 50,
2079-+ -1, -1, -1, -1, 55, -1, -1, 58, 42, -1,
2080-+ -1, -1, 18, 19, 20, 21, 50, 23, 24, 25,
2081-+ 26, 55, 28, 29, 58, 31, -1, 18, 19, 20,
2082-+ 21, -1, 23, 24, 25, 26, -1, 28, 29, 45,
2083-+ 31, -1, -1, -1, 50, -1, -1, -1, -1, 55,
2084-+ -1, 42, 58, -1, -1, 18, 19, 20, 21, 50,
2085-+ 23, 24, 25, 26, 55, 28, 29, 58, 31, -1,
2086-+ 18, 19, 20, 21, -1, 23, 24, 25, 26, 42,
2087-+ 28, 29, -1, 31, -1, -1, -1, 50, -1, -1,
2088-+ -1, -1, 55, 41, -1, 58, -1, -1, -1, -1,
2089-+ -1, -1, -1, -1, -1, 53, -1, 55, -1, -1,
2090-+ 58, 18, 19, 20, 21, -1, 23, 24, 25, 26,
2091-+ -1, 28, 29, -1, 31, -1, 18, 19, 20, 21,
2092-+ -1, 23, 24, 25, 26, 42, 28, 29, -1, 31,
2093-+ -1, -1, -1, 50, -1, -1, -1, -1, 55, -1,
2094-+ 42, 58, -1, -1, -1, -1, -1, -1, 50, -1,
2095-+ -1, -1, -1, 55, -1, -1, 58, 18, 19, 20,
2096-+ 21, -1, 23, 24, 25, 26, 27, 28, 29, -1,
2097-+ 31, 18, 19, 20, 21, -1, 23, 24, 25, 26,
2098-+ -1, 28, 29, -1, 31, 18, 19, 20, 21, 50,
2099-+ 23, 24, 25, 26, 55, 28, 29, 58, 31, -1,
2100-+ -1, -1, -1, 50, -1, -1, -1, -1, 55, -1,
2101-+ -1, 58, -1, -1, -1, -1, -1, -1, -1, -1,
2102-+ -1, -1, 55, -1, -1, 58
2103-+};
2104++ if (ret != 0) {
2105++ FreeXkbFile(first);
2106++ return NULL;
2107++ }
2108 +
2109-+/* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of
2110-+ state STATE-NUM. */
2111-+static const yytype_uint8 yystos[] =
2112-+{
2113-+ 0, 0, 57, 58, 59, 60, 61, 62, 63, 64,
2114-+ 66, 67, 70, 72, 73, 74, 0, 4, 5, 6,
2115-+ 7, 8, 9, 10, 11, 68, 71, 74, 52, 135,
2116-+ 136, 135, 41, 41, 69, 70, 72, 75, 42, 70,
2117-+ 12, 13, 14, 15, 16, 42, 76, 114, 115, 49,
2118-+ 49, 17, 18, 19, 20, 21, 22, 23, 24, 25,
2119-+ 26, 28, 29, 31, 32, 33, 34, 35, 50, 55,
2120-+ 56, 58, 77, 78, 79, 80, 83, 86, 87, 91,
2121-+ 92, 93, 94, 95, 96, 110, 111, 112, 113, 122,
2122-+ 133, 52, 81, 82, 133, 52, 134, 29, 53, 55,
2123-+ 84, 127, 131, 56, 56, 131, 133, 131, 134, 134,
2124-+ 134, 25, 133, 36, 134, 45, 47, 36, 49, 48,
2125-+ 49, 36, 41, 41, 37, 41, 36, 36, 41, 36,
2126-+ 41, 41, 41, 131, 49, 53, 132, 41, 18, 19,
2127-+ 21, 23, 24, 25, 26, 29, 31, 37, 38, 43,
2128-+ 50, 51, 54, 56, 112, 118, 119, 122, 123, 130,
2129-+ 131, 133, 134, 112, 118, 82, 118, 77, 85, 85,
2130-+ 118, 45, 50, 88, 89, 90, 122, 133, 56, 118,
2131-+ 117, 118, 118, 85, 41, 45, 106, 107, 108, 109,
2132-+ 133, 25, 28, 30, 77, 93, 97, 98, 103, 110,
2133-+ 36, 49, 85, 119, 122, 119, 118, 119, 119, 43,
2134-+ 37, 38, 39, 40, 46, 36, 45, 49, 42, 77,
2135-+ 42, 29, 41, 55, 112, 120, 121, 124, 125, 126,
2136-+ 127, 133, 42, 48, 36, 49, 49, 42, 48, 49,
2137-+ 42, 108, 38, 53, 54, 128, 129, 42, 48, 42,
2138-+ 48, 36, 41, 134, 42, 98, 118, 42, 44, 116,
2139-+ 117, 118, 118, 118, 118, 118, 118, 49, 49, 125,
2140-+ 43, 46, 48, 46, 48, 49, 89, 90, 118, 49,
2141-+ 118, 49, 42, 129, 48, 49, 107, 49, 109, 41,
2142-+ 118, 27, 77, 99, 100, 41, 49, 49, 49, 44,
2143-+ 46, 42, 116, 121, 126, 127, 128, 108, 41, 42,
2144-+ 100, 56, 104, 105, 44, 46, 42, 41, 56, 101,
2145-+ 102, 49, 36, 42, 48, 117, 42, 48, 56, 49,
2146-+ 105, 42, 49, 102
2147-+};
2148++ if (first)
2149++ log_vrb(ctx, 5,
2150++ XKB_WARNING_MISSING_DEFAULT_SECTION,
2151++ "No map in include statement, but \"%s\" contains several; "
2152++ "Using first defined map, \"%s\"\n",
2153++ scanner->file_name, first->name);
2154 +
2155-+/* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */
2156-+static const yytype_uint8 yyr1[] =
2157-+{
2158-+ 0, 65, 66, 66, 66, 67, 68, 68, 68, 69,
2159-+ 69, 70, 71, 71, 71, 71, 71, 72, 72, 73,
2160-+ 73, 74, 74, 74, 74, 74, 74, 74, 74, 75,
2161-+ 75, 75, 76, 76, 76, 76, 76, 76, 76, 76,
2162-+ 76, 76, 76, 76, 76, 76, 77, 77, 77, 78,
2163-+ 79, 80, 81, 81, 82, 82, 83, 84, 84, 85,
2164-+ 85, 86, 87, 88, 88, 88, 89, 89, 89, 89,
2165-+ 89, 90, 90, 91, 92, 93, 94, 94, 95, 95,
2166-+ 96, 97, 97, 98, 98, 98, 98, 98, 99, 99,
2167-+ 100, 100, 101, 101, 102, 102, 103, 104, 104, 105,
2168-+ 106, 106, 107, 107, 107, 108, 108, 109, 110, 111,
2169-+ 111, 111, 111, 112, 112, 113, 113, 113, 113, 113,
2170-+ 113, 113, 113, 113, 113, 113, 114, 114, 115, 115,
2171-+ 115, 115, 115, 116, 116, 117, 117, 118, 118, 118,
2172-+ 118, 118, 118, 119, 119, 119, 119, 119, 119, 119,
2173-+ 119, 120, 120, 121, 122, 122, 122, 122, 123, 123,
2174-+ 123, 123, 124, 124, 125, 125, 125, 125, 126, 127,
2175-+ 127, 127, 128, 128, 129, 129, 130, 131, 132, 133,
2176-+ 133, 134, 135, 135, 136
2177-+};
2178++ return first;
2179++}
2180++#line 1192 "parser.c"
2181 +
2182-+/* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */
2183-+static const yytype_int8 yyr2[] =
2184++/* Release memory associated with symbol. */
2185++#if ! defined YYDESTRUCT_IS_DECLARED
2186++static void
2187++YYDESTRUCT_DECL()
2188 +{
2189-+ 0, 2, 1, 1, 1, 7, 1, 1, 1, 2,
2190-+ 1, 7, 1, 1, 1, 1, 1, 1, 0, 2,
2191-+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 2,
2192-+ 3, 0, 2, 2, 2, 2, 2, 2, 2, 2,
2193-+ 2, 2, 2, 2, 2, 2, 4, 2, 3, 4,
2194-+ 5, 3, 3, 1, 1, 3, 6, 3, 1, 2,
2195-+ 1, 6, 6, 3, 1, 0, 3, 3, 1, 2,
2196-+ 1, 3, 3, 5, 6, 6, 5, 6, 6, 6,
2197-+ 6, 2, 1, 5, 1, 1, 1, 1, 2, 1,
2198-+ 5, 1, 3, 1, 1, 3, 6, 3, 1, 3,
2199-+ 3, 1, 3, 5, 3, 3, 1, 5, 6, 1,
2200-+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2201-+ 1, 1, 1, 1, 1, 1, 1, 0, 1, 1,
2202-+ 1, 1, 1, 1, 0, 3, 1, 3, 3, 3,
2203-+ 3, 3, 1, 2, 2, 2, 2, 1, 4, 1,
2204-+ 3, 3, 1, 4, 1, 3, 4, 6, 1, 1,
2205-+ 1, 1, 1, 0, 3, 3, 1, 1, 3, 1,
2206-+ 1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
2207-+ 1, 1, 1, 0, 1
2208-+};
2209-+
2210-+
2211-+enum { YYENOMEM = -2 };
2212-+
2213-+#define yyerrok (yyerrstatus = 0)
2214-+#define yyclearin (yychar = YYEMPTY)
2215-+
2216-+#define YYACCEPT goto yyacceptlab
2217-+#define YYABORT goto yyabortlab
2218-+#define YYERROR goto yyerrorlab
2219-+#define YYNOMEM goto yyexhaustedlab
2220-+
2221-+
2222-+#define YYRECOVERING() (!!yyerrstatus)
2223-+
2224-+#define YYBACKUP(Token, Value) \
2225-+ do \
2226-+ if (yychar == YYEMPTY) \
2227-+ { \
2228-+ yychar = (Token); \
2229-+ yylval = (Value); \
2230-+ YYPOPSTACK (yylen); \
2231-+ yystate = *yyssp; \
2232-+ goto yybackup; \
2233-+ } \
2234-+ else \
2235-+ { \
2236-+ yyerror (param, YY_("syntax error: cannot back up")); \
2237-+ YYERROR; \
2238-+ } \
2239-+ while (0)
2240-+
2241-+/* Backward compatibility with an undocumented macro.
2242-+ Use YYerror or YYUNDEF. */
2243-+#define YYERRCODE YYUNDEF
2244++ switch (psymb)
2245++ {
2246++ case 60:
2247++#line 239 "parser.y"
2248++ { free((*val).str); }
2249++#line 1204 "parser.c"
2250++ break;
2251++ case 63:
2252++#line 239 "parser.y"
2253++ { free((*val).str); }
2254++#line 1209 "parser.c"
2255++ break;
2256++ case 258:
2257++#line 237 "parser.y"
2258++ { if (!param->rtrn) FreeXkbFile((*val).file); }
2259++#line 1214 "parser.c"
2260++ break;
2261++ case 272:
2262++#line 239 "parser.y"
2263++ { free((*val).str); }
2264++#line 1219 "parser.c"
2265++ break;
2266++ case 273:
2267++#line 239 "parser.y"
2268++ { free((*val).str); }
2269++#line 1224 "parser.c"
2270++ break;
2271++ case 279:
2272++#line 230 "parser.y"
2273++ { FreeStmt((ParseCommon *) (*val).any); }
2274++#line 1229 "parser.c"
2275++ break;
2276++ case 280:
2277++#line 233 "parser.y"
2278++ { FreeStmt((ParseCommon *) (*val).anyList.head); }
2279++#line 1234 "parser.c"
2280++ break;
2281++ case 281:
2282++#line 230 "parser.y"
2283++ { FreeStmt((ParseCommon *) (*val).expr); }
2284++#line 1239 "parser.c"
2285++ break;
2286++ case 282:
2287++#line 230 "parser.y"
2288++ { FreeStmt((ParseCommon *) (*val).expr); }
2289++#line 1244 "parser.c"
2290++ break;
2291++ case 283:
2292++#line 230 "parser.y"
2293++ { FreeStmt((ParseCommon *) (*val).expr); }
2294++#line 1249 "parser.c"
2295++ break;
2296++ case 284:
2297++#line 230 "parser.y"
2298++ { FreeStmt((ParseCommon *) (*val).expr); }
2299++#line 1254 "parser.c"
2300++ break;
2301++ case 285:
2302++#line 230 "parser.y"
2303++ { FreeStmt((ParseCommon *) (*val).expr); }
2304++#line 1259 "parser.c"
2305++ break;
2306++ case 286:
2307++#line 230 "parser.y"
2308++ { FreeStmt((ParseCommon *) (*val).expr); }
2309++#line 1264 "parser.c"
2310++ break;
2311++ case 287:
2312++#line 230 "parser.y"
2313++ { FreeStmt((ParseCommon *) (*val).expr); }
2314++#line 1269 "parser.c"
2315++ break;
2316++ case 288:
2317++#line 230 "parser.y"
2318++ { FreeStmt((ParseCommon *) (*val).expr); }
2319++#line 1274 "parser.c"
2320++ break;
2321++ case 289:
2322++#line 230 "parser.y"
2323++ { FreeStmt((ParseCommon *) (*val).expr); }
2324++#line 1279 "parser.c"
2325++ break;
2326++ case 290:
2327++#line 230 "parser.y"
2328++ { FreeStmt((ParseCommon *) (*val).expr); }
2329++#line 1284 "parser.c"
2330++ break;
2331++ case 291:
2332++#line 230 "parser.y"
2333++ { FreeStmt((ParseCommon *) (*val).expr); }
2334++#line 1289 "parser.c"
2335++ break;
2336++ case 292:
2337++#line 233 "parser.y"
2338++ { FreeStmt((ParseCommon *) (*val).exprList.head); }
2339++#line 1294 "parser.c"
2340++ break;
2341++ case 293:
2342++#line 233 "parser.y"
2343++ { FreeStmt((ParseCommon *) (*val).exprList.head); }
2344++#line 1299 "parser.c"
2345++ break;
2346++ case 294:
2347++#line 233 "parser.y"
2348++ { FreeStmt((ParseCommon *) (*val).exprList.head); }
2349++#line 1304 "parser.c"
2350++ break;
2351++ case 295:
2352++#line 230 "parser.y"
2353++ { FreeStmt((ParseCommon *) (*val).var); }
2354++#line 1309 "parser.c"
2355++ break;
2356++ case 296:
2357++#line 230 "parser.y"
2358++ { FreeStmt((ParseCommon *) (*val).var); }
2359++#line 1314 "parser.c"
2360++ break;
2361++ case 297:
2362++#line 233 "parser.y"
2363++ { FreeStmt((ParseCommon *) (*val).varList.head); }
2364++#line 1319 "parser.c"
2365++ break;
2366++ case 298:
2367++#line 233 "parser.y"
2368++ { FreeStmt((ParseCommon *) (*val).varList.head); }
2369++#line 1324 "parser.c"
2370++ break;
2371++ case 299:
2372++#line 230 "parser.y"
2373++ { FreeStmt((ParseCommon *) (*val).vmod); }
2374++#line 1329 "parser.c"
2375++ break;
2376++ case 300:
2377++#line 233 "parser.y"
2378++ { FreeStmt((ParseCommon *) (*val).vmodList.head); }
2379++#line 1334 "parser.c"
2380++ break;
2381++ case 301:
2382++#line 233 "parser.y"
2383++ { FreeStmt((ParseCommon *) (*val).vmodList.head); }
2384++#line 1339 "parser.c"
2385++ break;
2386++ case 302:
2387++#line 230 "parser.y"
2388++ { FreeStmt((ParseCommon *) (*val).interp); }
2389++#line 1344 "parser.c"
2390++ break;
2391++ case 303:
2392++#line 230 "parser.y"
2393++ { FreeStmt((ParseCommon *) (*val).interp); }
2394++#line 1349 "parser.c"
2395++ break;
2396++ case 304:
2397++#line 230 "parser.y"
2398++ { FreeStmt((ParseCommon *) (*val).keyType); }
2399++#line 1354 "parser.c"
2400++ break;
2401++ case 305:
2402++#line 230 "parser.y"
2403++ { FreeStmt((ParseCommon *) (*val).syms); }
2404++#line 1359 "parser.c"
2405++ break;
2406++ case 306:
2407++#line 230 "parser.y"
2408++ { FreeStmt((ParseCommon *) (*val).modMask); }
2409++#line 1364 "parser.c"
2410++ break;
2411++ case 307:
2412++#line 230 "parser.y"
2413++ { FreeStmt((ParseCommon *) (*val).groupCompat); }
2414++#line 1369 "parser.c"
2415++ break;
2416++ case 308:
2417++#line 230 "parser.y"
2418++ { FreeStmt((ParseCommon *) (*val).ledMap); }
2419++#line 1374 "parser.c"
2420++ break;
2421++ case 309:
2422++#line 230 "parser.y"
2423++ { FreeStmt((ParseCommon *) (*val).ledName); }
2424++#line 1379 "parser.c"
2425++ break;
2426++ case 310:
2427++#line 230 "parser.y"
2428++ { FreeStmt((ParseCommon *) (*val).keyCode); }
2429++#line 1384 "parser.c"
2430++ break;
2431++ case 311:
2432++#line 230 "parser.y"
2433++ { FreeStmt((ParseCommon *) (*val).keyAlias); }
2434++#line 1389 "parser.c"
2435++ break;
2436++ case 326:
2437++#line 237 "parser.y"
2438++ { if (!param->rtrn) FreeXkbFile((*val).file); }
2439++#line 1394 "parser.c"
2440++ break;
2441++ case 327:
2442++#line 238 "parser.y"
2443++ { FreeXkbFile((*val).fileList.head); }
2444++#line 1399 "parser.c"
2445++ break;
2446++ case 328:
2447++#line 237 "parser.y"
2448++ { if (!param->rtrn) FreeXkbFile((*val).file); }
2449++#line 1404 "parser.c"
2450++ break;
2451++ }
2452++}
2453++#define YYDESTRUCT_IS_DECLARED 1
2454++#endif
2455 +
2456++/* For use in generated program */
2457++#define yydepth (int)(yystack.s_mark - yystack.s_base)
2458++#if YYBTYACC
2459++#define yytrial (yyps->save)
2460++#endif /* YYBTYACC */
2461 +
2462-+/* Enable debugging if requested. */
2463 +#if YYDEBUG
2464++#include <stdio.h> /* needed for printf */
2465++#endif
2466 +
2467-+# ifndef YYFPRINTF
2468-+# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
2469-+# define YYFPRINTF fprintf
2470-+# endif
2471++#include <stdlib.h> /* needed for malloc, etc */
2472++#include <string.h> /* needed for memset */
2473 +
2474-+# define YYDPRINTF(Args) \
2475-+do { \
2476-+ if (yydebug) \
2477-+ YYFPRINTF Args; \
2478-+} while (0)
2479++/* allocate initial stack or double stack size, up to YYMAXDEPTH */
2480++static int yygrowstack(YYSTACKDATA *data)
2481++{
2482++ int i;
2483++ unsigned newsize;
2484++ YYINT *newss;
2485++ YYSTYPE *newvs;
2486++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2487++ YYLTYPE *newps;
2488++#endif
2489 +
2490++ if ((newsize = data->stacksize) == 0)
2491++ newsize = YYINITSTACKSIZE;
2492++ else if (newsize >= YYMAXDEPTH)
2493++ return YYENOMEM;
2494++ else if ((newsize *= 2) > YYMAXDEPTH)
2495++ newsize = YYMAXDEPTH;
2496 +
2497++ i = (int) (data->s_mark - data->s_base);
2498++ newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
2499++ if (newss == 0)
2500++ return YYENOMEM;
2501 +
2502++ data->s_base = newss;
2503++ data->s_mark = newss + i;
2504 +
2505-+# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \
2506-+do { \
2507-+ if (yydebug) \
2508-+ { \
2509-+ YYFPRINTF (stderr, "%s ", Title); \
2510-+ yy_symbol_print (stderr, \
2511-+ Kind, Value, param); \
2512-+ YYFPRINTF (stderr, "\n"); \
2513-+ } \
2514-+} while (0)
2515++ newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
2516++ if (newvs == 0)
2517++ return YYENOMEM;
2518 +
2519++ data->l_base = newvs;
2520++ data->l_mark = newvs + i;
2521 +
2522-+/*-----------------------------------.
2523-+| Print this symbol's value on YYO. |
2524-+`-----------------------------------*/
2525++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2526++ newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
2527++ if (newps == 0)
2528++ return YYENOMEM;
2529 +
2530-+static void
2531-+yy_symbol_value_print (FILE *yyo,
2532-+ yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, struct parser_param *param)
2533-+{
2534-+ FILE *yyoutput = yyo;
2535-+ YY_USE (yyoutput);
2536-+ YY_USE (param);
2537-+ if (!yyvaluep)
2538-+ return;
2539-+ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2540-+ YY_USE (yykind);
2541-+ YY_IGNORE_MAYBE_UNINITIALIZED_END
2542-+}
2543++ data->p_base = newps;
2544++ data->p_mark = newps + i;
2545++#endif
2546 +
2547++ data->stacksize = newsize;
2548++ data->s_last = data->s_base + newsize - 1;
2549 +
2550-+/*---------------------------.
2551-+| Print this symbol on YYO. |
2552-+`---------------------------*/
2553++#if YYDEBUG
2554++ if (yydebug)
2555++ fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
2556++#endif
2557++ return 0;
2558++}
2559 +
2560-+static void
2561-+yy_symbol_print (FILE *yyo,
2562-+ yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, struct parser_param *param)
2563++#if YYPURE || defined(YY_NO_LEAKS)
2564++static void yyfreestack(YYSTACKDATA *data)
2565 +{
2566-+ YYFPRINTF (yyo, "%s %s (",
2567-+ yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));
2568-+
2569-+ yy_symbol_value_print (yyo, yykind, yyvaluep, param);
2570-+ YYFPRINTF (yyo, ")");
2571++ free(data->s_base);
2572++ free(data->l_base);
2573++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2574++ free(data->p_base);
2575++#endif
2576++ memset(data, 0, sizeof(*data));
2577 +}
2578++#else
2579++#define yyfreestack(data) /* nothing */
2580++#endif /* YYPURE || defined(YY_NO_LEAKS) */
2581++#if YYBTYACC
2582 +
2583-+/*------------------------------------------------------------------.
2584-+| yy_stack_print -- Print the state stack from its BOTTOM up to its |
2585-+| TOP (included). |
2586-+`------------------------------------------------------------------*/
2587-+
2588-+static void
2589-+yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
2590++static YYParseState *
2591++yyNewState(unsigned size)
2592 +{
2593-+ YYFPRINTF (stderr, "Stack now");
2594-+ for (; yybottom <= yytop; yybottom++)
2595++ YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
2596++ if (p == NULL) return NULL;
2597++
2598++ p->yystack.stacksize = size;
2599++ if (size == 0)
2600 + {
2601-+ int yybot = *yybottom;
2602-+ YYFPRINTF (stderr, " %d", yybot);
2603++ p->yystack.s_base = NULL;
2604++ p->yystack.l_base = NULL;
2605++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2606++ p->yystack.p_base = NULL;
2607++#endif
2608++ return p;
2609 + }
2610-+ YYFPRINTF (stderr, "\n");
2611-+}
2612-+
2613-+# define YY_STACK_PRINT(Bottom, Top) \
2614-+do { \
2615-+ if (yydebug) \
2616-+ yy_stack_print ((Bottom), (Top)); \
2617-+} while (0)
2618-+
2619++ p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT));
2620++ if (p->yystack.s_base == NULL) return NULL;
2621++ p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
2622++ if (p->yystack.l_base == NULL) return NULL;
2623++ memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
2624++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2625++ p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
2626++ if (p->yystack.p_base == NULL) return NULL;
2627++ memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
2628++#endif
2629 +
2630-+/*------------------------------------------------.
2631-+| Report that the YYRULE is going to be reduced. |
2632-+`------------------------------------------------*/
2633++ return p;
2634++}
2635 +
2636 +static void
2637-+yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp,
2638-+ int yyrule, struct parser_param *param)
2639++yyFreeState(YYParseState *p)
2640 +{
2641-+ int yylno = yyrline[yyrule];
2642-+ int yynrhs = yyr2[yyrule];
2643-+ int yyi;
2644-+ YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
2645-+ yyrule - 1, yylno);
2646-+ /* The symbols being reduced. */
2647-+ for (yyi = 0; yyi < yynrhs; yyi++)
2648-+ {
2649-+ YYFPRINTF (stderr, " $%d = ", yyi + 1);
2650-+ yy_symbol_print (stderr,
2651-+ YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
2652-+ &yyvsp[(yyi + 1) - (yynrhs)], param);
2653-+ YYFPRINTF (stderr, "\n");
2654-+ }
2655++ yyfreestack(&p->yystack);
2656++ free(p);
2657 +}
2658++#endif /* YYBTYACC */
2659++
2660++#define YYABORT goto yyabort
2661++#define YYREJECT goto yyabort
2662++#define YYACCEPT goto yyaccept
2663++#define YYERROR goto yyerrlab
2664++#if YYBTYACC
2665++#define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
2666++#define YYVALID_NESTED do { if (yyps->save && \
2667++ yyps->save->save == 0) goto yyvalid; } while(0)
2668++#endif /* YYBTYACC */
2669 +
2670-+# define YY_REDUCE_PRINT(Rule) \
2671-+do { \
2672-+ if (yydebug) \
2673-+ yy_reduce_print (yyssp, yyvsp, Rule, param); \
2674-+} while (0)
2675++int
2676++YYPARSE_DECL()
2677++{
2678++ int yyerrflag;
2679++ int yychar;
2680++ YYSTYPE yyval;
2681++ YYSTYPE yylval;
2682++ int yynerrs;
2683++
2684++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2685++ YYLTYPE yyloc; /* position returned by actions */
2686++ YYLTYPE yylloc; /* position from the lexer */
2687++#endif
2688 +
2689-+/* Nonzero means print parse trace. It is left uninitialized so that
2690-+ multiple parsers can coexist. */
2691-+int yydebug;
2692-+#else /* !YYDEBUG */
2693-+# define YYDPRINTF(Args) ((void) 0)
2694-+# define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
2695-+# define YY_STACK_PRINT(Bottom, Top)
2696-+# define YY_REDUCE_PRINT(Rule)
2697-+#endif /* !YYDEBUG */
2698++ /* variables for the parser stack */
2699++ YYSTACKDATA yystack;
2700++#if YYBTYACC
2701 +
2702++ /* Current parser state */
2703++ static YYParseState *yyps = 0;
2704 +
2705-+/* YYINITDEPTH -- initial size of the parser's stacks. */
2706-+#ifndef YYINITDEPTH
2707-+# define YYINITDEPTH 200
2708-+#endif
2709++ /* yypath != NULL: do the full parse, starting at *yypath parser state. */
2710++ static YYParseState *yypath = 0;
2711 +
2712-+/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
2713-+ if the built-in stack extension method is used).
2714++ /* Base of the lexical value queue */
2715++ static YYSTYPE *yylvals = 0;
2716 +
2717-+ Do not make this value too large; the results are undefined if
2718-+ YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
2719-+ evaluated with infinite-precision integer arithmetic. */
2720++ /* Current position at lexical value queue */
2721++ static YYSTYPE *yylvp = 0;
2722 +
2723-+#ifndef YYMAXDEPTH
2724-+# define YYMAXDEPTH 10000
2725-+#endif
2726++ /* End position of lexical value queue */
2727++ static YYSTYPE *yylve = 0;
2728 +
2729++ /* The last allocated position at the lexical value queue */
2730++ static YYSTYPE *yylvlim = 0;
2731 +
2732++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2733++ /* Base of the lexical position queue */
2734++ static YYLTYPE *yylpsns = 0;
2735 +
2736++ /* Current position at lexical position queue */
2737++ static YYLTYPE *yylpp = 0;
2738 +
2739++ /* End position of lexical position queue */
2740++ static YYLTYPE *yylpe = 0;
2741 +
2742++ /* The last allocated position at the lexical position queue */
2743++ static YYLTYPE *yylplim = 0;
2744++#endif
2745 +
2746-+/*-----------------------------------------------.
2747-+| Release the memory associated to this symbol. |
2748-+`-----------------------------------------------*/
2749++ /* Current position at lexical token queue */
2750++ static YYINT *yylexp = 0;
2751++
2752++ static YYINT *yylexemes = 0;
2753++#endif /* YYBTYACC */
2754++ int yym, yyn, yystate, yyresult;
2755++#if YYBTYACC
2756++ int yynewerrflag;
2757++ YYParseState *yyerrctx = NULL;
2758++#endif /* YYBTYACC */
2759++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2760++ YYLTYPE yyerror_loc_range[3]; /* position of error start/end (0 unused) */
2761++#endif
2762++#if YYDEBUG
2763++ const char *yys;
2764 +
2765-+static void
2766-+yydestruct (const char *yymsg,
2767-+ yysymbol_kind_t yykind, YYSTYPE *yyvaluep, struct parser_param *param)
2768-+{
2769-+ YY_USE (yyvaluep);
2770-+ YY_USE (param);
2771-+ if (!yymsg)
2772-+ yymsg = "Deleting";
2773-+ YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
2774-+
2775-+ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2776-+ switch (yykind)
2777++ if ((yys = getenv("YYDEBUG")) != 0)
2778 + {
2779-+ case YYSYMBOL_STRING: /* STRING */
2780-+#line 238 "parser.y"
2781-+ { free(((*yyvaluep).str)); }
2782-+#line 1318 "parser.c"
2783-+ break;
2784++ yyn = *yys;
2785++ if (yyn >= '0' && yyn <= '9')
2786++ yydebug = yyn - '0';
2787++ }
2788++ if (yydebug)
2789++ fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
2790++#endif
2791++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2792++ memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range));
2793++#endif
2794 +
2795-+ case YYSYMBOL_IDENT: /* IDENT */
2796-+#line 238 "parser.y"
2797-+ { free(((*yyvaluep).str)); }
2798-+#line 1324 "parser.c"
2799-+ break;
2800++ yyerrflag = 0;
2801++ yychar = 0;
2802++ memset(&yyval, 0, sizeof(yyval));
2803++ memset(&yylval, 0, sizeof(yylval));
2804++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
2805++ memset(&yyloc, 0, sizeof(yyloc));
2806++ memset(&yylloc, 0, sizeof(yylloc));
2807++#endif
2808 +
2809-+ case YYSYMBOL_XkbFile: /* XkbFile */
2810-+#line 236 "parser.y"
2811-+ { if (!param->rtrn) FreeXkbFile(((*yyvaluep).file)); }
2812-+#line 1330 "parser.c"
2813-+ break;
2814++#if YYBTYACC
2815++ yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
2816++ yyps->save = 0;
2817++#endif /* YYBTYACC */
2818++ yym = 0;
2819++ /* yyn is set below */
2820++ yynerrs = 0;
2821++ yyerrflag = 0;
2822++ yychar = YYEMPTY;
2823++ yystate = 0;
2824++
2825++#if YYPURE
2826++ memset(&yystack, 0, sizeof(yystack));
2827++#endif
2828 +
2829-+ case YYSYMBOL_XkbCompositeMap: /* XkbCompositeMap */
2830-+#line 236 "parser.y"
2831-+ { if (!param->rtrn) FreeXkbFile(((*yyvaluep).file)); }
2832-+#line 1336 "parser.c"
2833-+ break;
2834-+
2835-+ case YYSYMBOL_XkbMapConfigList: /* XkbMapConfigList */
2836-+#line 237 "parser.y"
2837-+ { FreeXkbFile(((*yyvaluep).fileList).head); }
2838-+#line 1342 "parser.c"
2839-+ break;
2840-+
2841-+ case YYSYMBOL_XkbMapConfig: /* XkbMapConfig */
2842-+#line 236 "parser.y"
2843-+ { if (!param->rtrn) FreeXkbFile(((*yyvaluep).file)); }
2844-+#line 1348 "parser.c"
2845-+ break;
2846-+
2847-+ case YYSYMBOL_DeclList: /* DeclList */
2848-+#line 232 "parser.y"
2849-+ { FreeStmt((ParseCommon *) ((*yyvaluep).anyList).head); }
2850-+#line 1354 "parser.c"
2851-+ break;
2852-+
2853-+ case YYSYMBOL_Decl: /* Decl */
2854-+#line 229 "parser.y"
2855-+ { FreeStmt((ParseCommon *) ((*yyvaluep).any)); }
2856-+#line 1360 "parser.c"
2857-+ break;
2858-+
2859-+ case YYSYMBOL_VarDecl: /* VarDecl */
2860-+#line 229 "parser.y"
2861-+ { FreeStmt((ParseCommon *) ((*yyvaluep).var)); }
2862-+#line 1366 "parser.c"
2863-+ break;
2864-+
2865-+ case YYSYMBOL_KeyNameDecl: /* KeyNameDecl */
2866-+#line 229 "parser.y"
2867-+ { FreeStmt((ParseCommon *) ((*yyvaluep).keyCode)); }
2868-+#line 1372 "parser.c"
2869-+ break;
2870-+
2871-+ case YYSYMBOL_KeyAliasDecl: /* KeyAliasDecl */
2872-+#line 229 "parser.y"
2873-+ { FreeStmt((ParseCommon *) ((*yyvaluep).keyAlias)); }
2874-+#line 1378 "parser.c"
2875-+ break;
2876-+
2877-+ case YYSYMBOL_VModDecl: /* VModDecl */
2878-+#line 232 "parser.y"
2879-+ { FreeStmt((ParseCommon *) ((*yyvaluep).vmodList).head); }
2880-+#line 1384 "parser.c"
2881-+ break;
2882-+
2883-+ case YYSYMBOL_VModDefList: /* VModDefList */
2884-+#line 232 "parser.y"
2885-+ { FreeStmt((ParseCommon *) ((*yyvaluep).vmodList).head); }
2886-+#line 1390 "parser.c"
2887-+ break;
2888-+
2889-+ case YYSYMBOL_VModDef: /* VModDef */
2890-+#line 229 "parser.y"
2891-+ { FreeStmt((ParseCommon *) ((*yyvaluep).vmod)); }
2892-+#line 1396 "parser.c"
2893-+ break;
2894-+
2895-+ case YYSYMBOL_InterpretDecl: /* InterpretDecl */
2896-+#line 229 "parser.y"
2897-+ { FreeStmt((ParseCommon *) ((*yyvaluep).interp)); }
2898-+#line 1402 "parser.c"
2899-+ break;
2900-+
2901-+ case YYSYMBOL_InterpretMatch: /* InterpretMatch */
2902-+#line 229 "parser.y"
2903-+ { FreeStmt((ParseCommon *) ((*yyvaluep).interp)); }
2904-+#line 1408 "parser.c"
2905-+ break;
2906-+
2907-+ case YYSYMBOL_VarDeclList: /* VarDeclList */
2908-+#line 232 "parser.y"
2909-+ { FreeStmt((ParseCommon *) ((*yyvaluep).varList).head); }
2910-+#line 1414 "parser.c"
2911-+ break;
2912-+
2913-+ case YYSYMBOL_KeyTypeDecl: /* KeyTypeDecl */
2914-+#line 229 "parser.y"
2915-+ { FreeStmt((ParseCommon *) ((*yyvaluep).keyType)); }
2916-+#line 1420 "parser.c"
2917-+ break;
2918-+
2919-+ case YYSYMBOL_SymbolsDecl: /* SymbolsDecl */
2920-+#line 229 "parser.y"
2921-+ { FreeStmt((ParseCommon *) ((*yyvaluep).syms)); }
2922-+#line 1426 "parser.c"
2923-+ break;
2924-+
2925-+ case YYSYMBOL_SymbolsBody: /* SymbolsBody */
2926-+#line 232 "parser.y"
2927-+ { FreeStmt((ParseCommon *) ((*yyvaluep).varList).head); }
2928-+#line 1432 "parser.c"
2929-+ break;
2930-+
2931-+ case YYSYMBOL_SymbolsVarDecl: /* SymbolsVarDecl */
2932-+#line 229 "parser.y"
2933-+ { FreeStmt((ParseCommon *) ((*yyvaluep).var)); }
2934-+#line 1438 "parser.c"
2935-+ break;
2936-+
2937-+ case YYSYMBOL_ArrayInit: /* ArrayInit */
2938-+#line 229 "parser.y"
2939-+ { FreeStmt((ParseCommon *) ((*yyvaluep).expr)); }
2940-+#line 1444 "parser.c"
2941-+ break;
2942-+
2943-+ case YYSYMBOL_GroupCompatDecl: /* GroupCompatDecl */
2944-+#line 229 "parser.y"
2945-+ { FreeStmt((ParseCommon *) ((*yyvaluep).groupCompat)); }
2946-+#line 1450 "parser.c"
2947-+ break;
2948-+
2949-+ case YYSYMBOL_ModMapDecl: /* ModMapDecl */
2950-+#line 229 "parser.y"
2951-+ { FreeStmt((ParseCommon *) ((*yyvaluep).modMask)); }
2952-+#line 1456 "parser.c"
2953-+ break;
2954-+
2955-+ case YYSYMBOL_LedMapDecl: /* LedMapDecl */
2956-+#line 229 "parser.y"
2957-+ { FreeStmt((ParseCommon *) ((*yyvaluep).ledMap)); }
2958-+#line 1462 "parser.c"
2959-+ break;
2960-+
2961-+ case YYSYMBOL_LedNameDecl: /* LedNameDecl */
2962-+#line 229 "parser.y"
2963-+ { FreeStmt((ParseCommon *) ((*yyvaluep).ledName)); }
2964-+#line 1468 "parser.c"
2965-+ break;
2966-+
2967-+ case YYSYMBOL_CoordList: /* CoordList */
2968-+#line 229 "parser.y"
2969-+ { FreeStmt((ParseCommon *) ((*yyvaluep).expr)); }
2970-+#line 1474 "parser.c"
2971-+ break;
2972-+
2973-+ case YYSYMBOL_Coord: /* Coord */
2974-+#line 229 "parser.y"
2975-+ { FreeStmt((ParseCommon *) ((*yyvaluep).expr)); }
2976-+#line 1480 "parser.c"
2977-+ break;
2978-+
2979-+ case YYSYMBOL_OptExprList: /* OptExprList */
2980-+#line 232 "parser.y"
2981-+ { FreeStmt((ParseCommon *) ((*yyvaluep).exprList).head); }
2982-+#line 1486 "parser.c"
2983-+ break;
2984-+
2985-+ case YYSYMBOL_ExprList: /* ExprList */
2986-+#line 232 "parser.y"
2987-+ { FreeStmt((ParseCommon *) ((*yyvaluep).exprList).head); }
2988-+#line 1492 "parser.c"
2989-+ break;
2990-+
2991-+ case YYSYMBOL_Expr: /* Expr */
2992-+#line 229 "parser.y"
2993-+ { FreeStmt((ParseCommon *) ((*yyvaluep).expr)); }
2994-+#line 1498 "parser.c"
2995-+ break;
2996-+
2997-+ case YYSYMBOL_Term: /* Term */
2998-+#line 229 "parser.y"
2999-+ { FreeStmt((ParseCommon *) ((*yyvaluep).expr)); }
3000-+#line 1504 "parser.c"
3001-+ break;
3002-+
3003-+ case YYSYMBOL_ActionList: /* ActionList */
3004-+#line 232 "parser.y"
3005-+ { FreeStmt((ParseCommon *) ((*yyvaluep).exprList).head); }
3006-+#line 1510 "parser.c"
3007-+ break;
3008-+
3009-+ case YYSYMBOL_Action: /* Action */
3010-+#line 229 "parser.y"
3011-+ { FreeStmt((ParseCommon *) ((*yyvaluep).expr)); }
3012-+#line 1516 "parser.c"
3013-+ break;
3014-+
3015-+ case YYSYMBOL_Lhs: /* Lhs */
3016-+#line 229 "parser.y"
3017-+ { FreeStmt((ParseCommon *) ((*yyvaluep).expr)); }
3018-+#line 1522 "parser.c"
3019-+ break;
3020-+
3021-+ case YYSYMBOL_Terminal: /* Terminal */
3022-+#line 229 "parser.y"
3023-+ { FreeStmt((ParseCommon *) ((*yyvaluep).expr)); }
3024-+#line 1528 "parser.c"
3025-+ break;
3026-+
3027-+ case YYSYMBOL_OptKeySymList: /* OptKeySymList */
3028-+#line 229 "parser.y"
3029-+ { FreeStmt((ParseCommon *) ((*yyvaluep).expr)); }
3030-+#line 1534 "parser.c"
3031-+ break;
3032-+
3033-+ case YYSYMBOL_KeySymList: /* KeySymList */
3034-+#line 229 "parser.y"
3035-+ { FreeStmt((ParseCommon *) ((*yyvaluep).expr)); }
3036-+#line 1540 "parser.c"
3037-+ break;
3038-+
3039-+ case YYSYMBOL_KeySyms: /* KeySyms */
3040-+#line 229 "parser.y"
3041-+ { FreeStmt((ParseCommon *) ((*yyvaluep).expr)); }
3042-+#line 1546 "parser.c"
3043-+ break;
3044-+
3045-+ case YYSYMBOL_OptMapName: /* OptMapName */
3046-+#line 238 "parser.y"
3047-+ { free(((*yyvaluep).str)); }
3048-+#line 1552 "parser.c"
3049-+ break;
3050-+
3051-+ case YYSYMBOL_MapName: /* MapName */
3052-+#line 238 "parser.y"
3053-+ { free(((*yyvaluep).str)); }
3054-+#line 1558 "parser.c"
3055-+ break;
3056++ if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
3057++ yystack.s_mark = yystack.s_base;
3058++ yystack.l_mark = yystack.l_base;
3059++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3060++ yystack.p_mark = yystack.p_base;
3061++#endif
3062++ yystate = 0;
3063++ *yystack.s_mark = 0;
3064 +
3065-+ default:
3066-+ break;
3067++yyloop:
3068++ if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
3069++ if (yychar < 0)
3070++ {
3071++#if YYBTYACC
3072++ do {
3073++ if (yylvp < yylve)
3074++ {
3075++ /* we're currently re-reading tokens */
3076++ yylval = *yylvp++;
3077++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3078++ yylloc = *yylpp++;
3079++#endif
3080++ yychar = *yylexp++;
3081++ break;
3082++ }
3083++ if (yyps->save)
3084++ {
3085++ /* in trial mode; save scanner results for future parse attempts */
3086++ if (yylvp == yylvlim)
3087++ { /* Enlarge lexical value queue */
3088++ size_t p = (size_t) (yylvp - yylvals);
3089++ size_t s = (size_t) (yylvlim - yylvals);
3090++
3091++ s += YYLVQUEUEGROWTH;
3092++ if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;
3093++ if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
3094++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3095++ if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
3096++#endif
3097++ yylvp = yylve = yylvals + p;
3098++ yylvlim = yylvals + s;
3099++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3100++ yylpp = yylpe = yylpsns + p;
3101++ yylplim = yylpsns + s;
3102++#endif
3103++ yylexp = yylexemes + p;
3104++ }
3105++ *yylexp = (YYINT) YYLEX;
3106++ *yylvp++ = yylval;
3107++ yylve++;
3108++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3109++ *yylpp++ = yylloc;
3110++ yylpe++;
3111++#endif
3112++ yychar = *yylexp++;
3113++ break;
3114++ }
3115++ /* normal operation, no conflict encountered */
3116++#endif /* YYBTYACC */
3117++ yychar = YYLEX;
3118++#if YYBTYACC
3119++ } while (0);
3120++#endif /* YYBTYACC */
3121++ if (yychar < 0) yychar = YYEOF;
3122++#if YYDEBUG
3123++ if (yydebug)
3124++ {
3125++ if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
3126++ fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
3127++ YYDEBUGSTR, yydepth, yystate, yychar, yys);
3128++#ifdef YYSTYPE_TOSTRING
3129++#if YYBTYACC
3130++ if (!yytrial)
3131++#endif /* YYBTYACC */
3132++ fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
3133++#endif
3134++ fputc('\n', stderr);
3135++ }
3136++#endif
3137 + }
3138-+ YY_IGNORE_MAYBE_UNINITIALIZED_END
3139-+}
3140-+
3141-+
3142-+
3143-+
3144-+
3145-+
3146-+/*----------.
3147-+| yyparse. |
3148-+`----------*/
3149-+
3150-+int
3151-+yyparse (struct parser_param *param)
3152-+{
3153-+/* Lookahead token kind. */
3154-+int yychar;
3155-+
3156-+
3157-+/* The semantic value of the lookahead symbol. */
3158-+/* Default value used for initialization, for pacifying older GCCs
3159-+ or non-GCC compilers. */
3160-+YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
3161-+YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
3162-+
3163-+ /* Number of syntax errors so far. */
3164-+ int yynerrs = 0;
3165-+
3166-+ yy_state_fast_t yystate = 0;
3167-+ /* Number of tokens to shift before error messages enabled. */
3168-+ int yyerrstatus = 0;
3169-+
3170-+ /* Refer to the stacks through separate pointers, to allow yyoverflow
3171-+ to reallocate them elsewhere. */
3172-+
3173-+ /* Their size. */
3174-+ YYPTRDIFF_T yystacksize = YYINITDEPTH;
3175-+
3176-+ /* The state stack: array, bottom, top. */
3177-+ yy_state_t yyssa[YYINITDEPTH];
3178-+ yy_state_t *yyss = yyssa;
3179-+ yy_state_t *yyssp = yyss;
3180++#if YYBTYACC
3181 +
3182-+ /* The semantic value stack: array, bottom, top. */
3183-+ YYSTYPE yyvsa[YYINITDEPTH];
3184-+ YYSTYPE *yyvs = yyvsa;
3185-+ YYSTYPE *yyvsp = yyvs;
3186-+
3187-+ int yyn;
3188-+ /* The return value of yyparse. */
3189-+ int yyresult;
3190-+ /* Lookahead symbol kind. */
3191-+ yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY;
3192-+ /* The variables used to return semantic value and location from the
3193-+ action routines. */
3194-+ YYSTYPE yyval;
3195-+
3196-+
3197-+
3198-+#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
3199-+
3200-+ /* The number of symbols on the RHS of the reduced rule.
3201-+ Keep to zero when no symbol should be popped. */
3202-+ int yylen = 0;
3203-+
3204-+ YYDPRINTF ((stderr, "Starting parse\n"));
3205-+
3206-+ yychar = YYEMPTY; /* Cause a token to be read. */
3207-+
3208-+ goto yysetstate;
3209-+
3210-+
3211-+/*------------------------------------------------------------.
3212-+| yynewstate -- push a new state, which is found in yystate. |
3213-+`------------------------------------------------------------*/
3214-+yynewstate:
3215-+ /* In all cases, when you get here, the value and location stacks
3216-+ have just been pushed. So pushing a state here evens the stacks. */
3217-+ yyssp++;
3218-+
3219-+
3220-+/*--------------------------------------------------------------------.
3221-+| yysetstate -- set current state (the top of the stack) to yystate. |
3222-+`--------------------------------------------------------------------*/
3223-+yysetstate:
3224-+ YYDPRINTF ((stderr, "Entering state %d\n", yystate));
3225-+ YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
3226-+ YY_IGNORE_USELESS_CAST_BEGIN
3227-+ *yyssp = YY_CAST (yy_state_t, yystate);
3228-+ YY_IGNORE_USELESS_CAST_END
3229-+ YY_STACK_PRINT (yyss, yyssp);
3230-+
3231-+ if (yyss + yystacksize - 1 <= yyssp)
3232-+#if !defined yyoverflow && !defined YYSTACK_RELOCATE
3233-+ YYNOMEM;
3234-+#else
3235++ /* Do we have a conflict? */
3236++ if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
3237++ yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
3238 + {
3239-+ /* Get the current used size of the three stacks, in elements. */
3240-+ YYPTRDIFF_T yysize = yyssp - yyss + 1;
3241-+
3242-+# if defined yyoverflow
3243-+ {
3244-+ /* Give user a chance to reallocate the stack. Use copies of
3245-+ these so that the &'s don't force the real ones into
3246-+ memory. */
3247-+ yy_state_t *yyss1 = yyss;
3248-+ YYSTYPE *yyvs1 = yyvs;
3249-+
3250-+ /* Each stack pointer address is followed by the size of the
3251-+ data in use in that stack, in bytes. This used to be a
3252-+ conditional around just the two extra args, but that might
3253-+ be undefined if yyoverflow is a macro. */
3254-+ yyoverflow (YY_("memory exhausted"),
3255-+ &yyss1, yysize * YYSIZEOF (*yyssp),
3256-+ &yyvs1, yysize * YYSIZEOF (*yyvsp),
3257-+ &yystacksize);
3258-+ yyss = yyss1;
3259-+ yyvs = yyvs1;
3260-+ }
3261-+# else /* defined YYSTACK_RELOCATE */
3262-+ /* Extend the stack our own way. */
3263-+ if (YYMAXDEPTH <= yystacksize)
3264-+ YYNOMEM;
3265-+ yystacksize *= 2;
3266-+ if (YYMAXDEPTH < yystacksize)
3267-+ yystacksize = YYMAXDEPTH;
3268-+
3269-+ {
3270-+ yy_state_t *yyss1 = yyss;
3271-+ union yyalloc *yyptr =
3272-+ YY_CAST (union yyalloc *,
3273-+ YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
3274-+ if (! yyptr)
3275-+ YYNOMEM;
3276-+ YYSTACK_RELOCATE (yyss_alloc, yyss);
3277-+ YYSTACK_RELOCATE (yyvs_alloc, yyvs);
3278-+# undef YYSTACK_RELOCATE
3279-+ if (yyss1 != yyssa)
3280-+ YYSTACK_FREE (yyss1);
3281-+ }
3282-+# endif
3283++ YYINT ctry;
3284 +
3285-+ yyssp = yyss + yysize - 1;
3286-+ yyvsp = yyvs + yysize - 1;
3287++ if (yypath)
3288++ {
3289++ YYParseState *save;
3290++#if YYDEBUG
3291++ if (yydebug)
3292++ fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
3293++ YYDEBUGSTR, yydepth, yystate);
3294++#endif
3295++ /* Switch to the next conflict context */
3296++ save = yypath;
3297++ yypath = save->save;
3298++ save->save = NULL;
3299++ ctry = save->ctry;
3300++ if (save->state != yystate) YYABORT;
3301++ yyFreeState(save);
3302 +
3303-+ YY_IGNORE_USELESS_CAST_BEGIN
3304-+ YYDPRINTF ((stderr, "Stack size increased to %ld\n",
3305-+ YY_CAST (long, yystacksize)));
3306-+ YY_IGNORE_USELESS_CAST_END
3307++ }
3308++ else
3309++ {
3310 +
3311-+ if (yyss + yystacksize - 1 <= yyssp)
3312-+ YYABORT;
3313++ /* Unresolved conflict - start/continue trial parse */
3314++ YYParseState *save;
3315++#if YYDEBUG
3316++ if (yydebug)
3317++ {
3318++ fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
3319++ if (yyps->save)
3320++ fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
3321++ else
3322++ fputs("Starting trial parse.\n", stderr);
3323++ }
3324++#endif
3325++ save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
3326++ if (save == NULL) goto yyenomem;
3327++ save->save = yyps->save;
3328++ save->state = yystate;
3329++ save->errflag = yyerrflag;
3330++ save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
3331++ memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
3332++ save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
3333++ memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
3334++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3335++ save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
3336++ memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
3337++#endif
3338++ ctry = yytable[yyn];
3339++ if (yyctable[ctry] == -1)
3340++ {
3341++#if YYDEBUG
3342++ if (yydebug && yychar >= YYEOF)
3343++ fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
3344++#endif
3345++ ctry++;
3346++ }
3347++ save->ctry = ctry;
3348++ if (yyps->save == NULL)
3349++ {
3350++ /* If this is a first conflict in the stack, start saving lexemes */
3351++ if (!yylexemes)
3352++ {
3353++ yylexemes = (YYINT *) malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));
3354++ if (yylexemes == NULL) goto yyenomem;
3355++ yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
3356++ if (yylvals == NULL) goto yyenomem;
3357++ yylvlim = yylvals + YYLVQUEUEGROWTH;
3358++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3359++ yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
3360++ if (yylpsns == NULL) goto yyenomem;
3361++ yylplim = yylpsns + YYLVQUEUEGROWTH;
3362++#endif
3363++ }
3364++ if (yylvp == yylve)
3365++ {
3366++ yylvp = yylve = yylvals;
3367++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3368++ yylpp = yylpe = yylpsns;
3369++#endif
3370++ yylexp = yylexemes;
3371++ if (yychar >= YYEOF)
3372++ {
3373++ *yylve++ = yylval;
3374++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3375++ *yylpe++ = yylloc;
3376++#endif
3377++ *yylexp = (YYINT) yychar;
3378++ yychar = YYEMPTY;
3379++ }
3380++ }
3381++ }
3382++ if (yychar >= YYEOF)
3383++ {
3384++ yylvp--;
3385++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3386++ yylpp--;
3387++#endif
3388++ yylexp--;
3389++ yychar = YYEMPTY;
3390++ }
3391++ save->lexeme = (int) (yylvp - yylvals);
3392++ yyps->save = save;
3393++ }
3394++ if (yytable[yyn] == ctry)
3395++ {
3396++#if YYDEBUG
3397++ if (yydebug)
3398++ fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
3399++ YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
3400++#endif
3401++ if (yychar < 0)
3402++ {
3403++ yylvp++;
3404++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3405++ yylpp++;
3406++#endif
3407++ yylexp++;
3408++ }
3409++ if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
3410++ goto yyoverflow;
3411++ yystate = yyctable[ctry];
3412++ *++yystack.s_mark = (YYINT) yystate;
3413++ *++yystack.l_mark = yylval;
3414++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3415++ *++yystack.p_mark = yylloc;
3416++#endif
3417++ yychar = YYEMPTY;
3418++ if (yyerrflag > 0) --yyerrflag;
3419++ goto yyloop;
3420++ }
3421++ else
3422++ {
3423++ yyn = yyctable[ctry];
3424++ goto yyreduce;
3425++ }
3426++ } /* End of code dealing with conflicts */
3427++#endif /* YYBTYACC */
3428++ if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
3429++ yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
3430++ {
3431++#if YYDEBUG
3432++ if (yydebug)
3433++ fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
3434++ YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
3435++#endif
3436++ if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
3437++ yystate = yytable[yyn];
3438++ *++yystack.s_mark = yytable[yyn];
3439++ *++yystack.l_mark = yylval;
3440++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3441++ *++yystack.p_mark = yylloc;
3442++#endif
3443++ yychar = YYEMPTY;
3444++ if (yyerrflag > 0) --yyerrflag;
3445++ goto yyloop;
3446 + }
3447-+#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
3448-+
3449-+
3450-+ if (yystate == YYFINAL)
3451-+ YYACCEPT;
3452-+
3453-+ goto yybackup;
3454-+
3455-+
3456-+/*-----------.
3457-+| yybackup. |
3458-+`-----------*/
3459-+yybackup:
3460-+ /* Do appropriate processing given the current state. Read a
3461-+ lookahead token if we need one and don't already have one. */
3462++ if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
3463++ yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
3464++ {
3465++ yyn = yytable[yyn];
3466++ goto yyreduce;
3467++ }
3468++ if (yyerrflag != 0) goto yyinrecovery;
3469++#if YYBTYACC
3470 +
3471-+ /* First try to decide what to do without reference to lookahead token. */
3472-+ yyn = yypact[yystate];
3473-+ if (yypact_value_is_default (yyn))
3474-+ goto yydefault;
3475++ yynewerrflag = 1;
3476++ goto yyerrhandler;
3477++ goto yyerrlab; /* redundant goto avoids 'unused label' warning */
3478 +
3479-+ /* Not known => get a lookahead token if don't already have one. */
3480++yyerrlab:
3481++ /* explicit YYERROR from an action -- pop the rhs of the rule reduced
3482++ * before looking for error recovery */
3483++ yystack.s_mark -= yym;
3484++ yystate = *yystack.s_mark;
3485++ yystack.l_mark -= yym;
3486++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3487++ yystack.p_mark -= yym;
3488++#endif
3489 +
3490-+ /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */
3491-+ if (yychar == YYEMPTY)
3492++ yynewerrflag = 0;
3493++yyerrhandler:
3494++ while (yyps->save)
3495 + {
3496-+ YYDPRINTF ((stderr, "Reading a token\n"));
3497-+ yychar = yylex (&yylval, param_scanner);
3498++ int ctry;
3499++ YYParseState *save = yyps->save;
3500++#if YYDEBUG
3501++ if (yydebug)
3502++ fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
3503++ YYDEBUGSTR, yydepth, yystate, yyps->save->state,
3504++ (int)(yylvp - yylvals - yyps->save->lexeme));
3505++#endif
3506++ /* Memorize most forward-looking error state in case it's really an error. */
3507++ if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
3508++ {
3509++ /* Free old saved error context state */
3510++ if (yyerrctx) yyFreeState(yyerrctx);
3511++ /* Create and fill out new saved error context state */
3512++ yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
3513++ if (yyerrctx == NULL) goto yyenomem;
3514++ yyerrctx->save = yyps->save;
3515++ yyerrctx->state = yystate;
3516++ yyerrctx->errflag = yyerrflag;
3517++ yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
3518++ memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
3519++ yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
3520++ memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
3521++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3522++ yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
3523++ memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
3524++#endif
3525++ yyerrctx->lexeme = (int) (yylvp - yylvals);
3526++ }
3527++ yylvp = yylvals + save->lexeme;
3528++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3529++ yylpp = yylpsns + save->lexeme;
3530++#endif
3531++ yylexp = yylexemes + save->lexeme;
3532++ yychar = YYEMPTY;
3533++ yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
3534++ memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
3535++ yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
3536++ memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
3537++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3538++ yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
3539++ memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
3540++#endif
3541++ ctry = ++save->ctry;
3542++ yystate = save->state;
3543++ /* We tried shift, try reduce now */
3544++ if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
3545++ yyps->save = save->save;
3546++ save->save = NULL;
3547++ yyFreeState(save);
3548++
3549++ /* Nothing left on the stack -- error */
3550++ if (!yyps->save)
3551++ {
3552++#if YYDEBUG
3553++ if (yydebug)
3554++ fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
3555++ YYPREFIX, yydepth);
3556++#endif
3557++ /* Restore state as it was in the most forward-advanced error */
3558++ yylvp = yylvals + yyerrctx->lexeme;
3559++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3560++ yylpp = yylpsns + yyerrctx->lexeme;
3561++#endif
3562++ yylexp = yylexemes + yyerrctx->lexeme;
3563++ yychar = yylexp[-1];
3564++ yylval = yylvp[-1];
3565++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3566++ yylloc = yylpp[-1];
3567++#endif
3568++ yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
3569++ memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
3570++ yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
3571++ memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
3572++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3573++ yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
3574++ memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
3575++#endif
3576++ yystate = yyerrctx->state;
3577++ yyFreeState(yyerrctx);
3578++ yyerrctx = NULL;
3579++ }
3580++ yynewerrflag = 1;
3581 + }
3582++ if (yynewerrflag == 0) goto yyinrecovery;
3583++#endif /* YYBTYACC */
3584++
3585++ YYERROR_CALL("syntax error");
3586++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3587++ yyerror_loc_range[1] = yylloc; /* lookahead position is error start position */
3588++#endif
3589 +
3590-+ if (yychar <= END_OF_FILE)
3591++#if !YYBTYACC
3592++ goto yyerrlab; /* redundant goto avoids 'unused label' warning */
3593++yyerrlab:
3594++#endif
3595++ ++yynerrs;
3596++
3597++yyinrecovery:
3598++ if (yyerrflag < 3)
3599 + {
3600-+ yychar = END_OF_FILE;
3601-+ yytoken = YYSYMBOL_YYEOF;
3602-+ YYDPRINTF ((stderr, "Now at end of input.\n"));
3603++ yyerrflag = 3;
3604++ for (;;)
3605++ {
3606++ if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
3607++ yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
3608++ {
3609++#if YYDEBUG
3610++ if (yydebug)
3611++ fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
3612++ YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
3613++#endif
3614++ if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
3615++ yystate = yytable[yyn];
3616++ *++yystack.s_mark = yytable[yyn];
3617++ *++yystack.l_mark = yylval;
3618++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3619++ /* lookahead position is error end position */
3620++ yyerror_loc_range[2] = yylloc;
3621++ YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
3622++ *++yystack.p_mark = yyloc;
3623++#endif
3624++ goto yyloop;
3625++ }
3626++ else
3627++ {
3628++#if YYDEBUG
3629++ if (yydebug)
3630++ fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
3631++ YYDEBUGSTR, yydepth, *yystack.s_mark);
3632++#endif
3633++ if (yystack.s_mark <= yystack.s_base) goto yyabort;
3634++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3635++ /* the current TOS position is the error start position */
3636++ yyerror_loc_range[1] = *yystack.p_mark;
3637++#endif
3638++#if defined(YYDESTRUCT_CALL)
3639++#if YYBTYACC
3640++ if (!yytrial)
3641++#endif /* YYBTYACC */
3642++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3643++ YYDESTRUCT_CALL("error: discarding state",
3644++ yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
3645++#else
3646++ YYDESTRUCT_CALL("error: discarding state",
3647++ yystos[*yystack.s_mark], yystack.l_mark);
3648++#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
3649++#endif /* defined(YYDESTRUCT_CALL) */
3650++ --yystack.s_mark;
3651++ --yystack.l_mark;
3652++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3653++ --yystack.p_mark;
3654++#endif
3655++ }
3656++ }
3657 + }
3658-+ else if (yychar == YYerror)
3659++ else
3660 + {
3661-+ /* The scanner already issued an error message, process directly
3662-+ to error recovery. But do not keep the error token as
3663-+ lookahead, it is too special and may lead us to an endless
3664-+ loop in error recovery. */
3665-+ yychar = YYUNDEF;
3666-+ yytoken = YYSYMBOL_YYerror;
3667-+ goto yyerrlab1;
3668++ if (yychar == YYEOF) goto yyabort;
3669++#if YYDEBUG
3670++ if (yydebug)
3671++ {
3672++ if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
3673++ fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
3674++ YYDEBUGSTR, yydepth, yystate, yychar, yys);
3675++ }
3676++#endif
3677++#if defined(YYDESTRUCT_CALL)
3678++#if YYBTYACC
3679++ if (!yytrial)
3680++#endif /* YYBTYACC */
3681++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3682++ YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
3683++#else
3684++ YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
3685++#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
3686++#endif /* defined(YYDESTRUCT_CALL) */
3687++ yychar = YYEMPTY;
3688++ goto yyloop;
3689 + }
3690-+ else
3691++
3692++yyreduce:
3693++ yym = yylen[yyn];
3694++#if YYDEBUG
3695++ if (yydebug)
3696 + {
3697-+ yytoken = YYTRANSLATE (yychar);
3698-+ YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
3699++ fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
3700++ YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
3701++#ifdef YYSTYPE_TOSTRING
3702++#if YYBTYACC
3703++ if (!yytrial)
3704++#endif /* YYBTYACC */
3705++ if (yym > 0)
3706++ {
3707++ int i;
3708++ fputc('<', stderr);
3709++ for (i = yym; i > 0; i--)
3710++ {
3711++ if (i != yym) fputs(", ", stderr);
3712++ fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
3713++ yystack.l_mark[1-i]), stderr);
3714++ }
3715++ fputc('>', stderr);
3716++ }
3717++#endif
3718++ fputc('\n', stderr);
3719 + }
3720-+
3721-+ /* If the proper action on seeing token YYTOKEN is to reduce or to
3722-+ detect an error, take that action. */
3723-+ yyn += yytoken;
3724-+ if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
3725-+ goto yydefault;
3726-+ yyn = yytable[yyn];
3727-+ if (yyn <= 0)
3728++#endif
3729++ if (yym > 0)
3730++ yyval = yystack.l_mark[1-yym];
3731++ else
3732++ memset(&yyval, 0, sizeof yyval);
3733++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
3734++
3735++ /* Perform position reduction */
3736++ memset(&yyloc, 0, sizeof(yyloc));
3737++#if YYBTYACC
3738++ if (!yytrial)
3739++#endif /* YYBTYACC */
3740 + {
3741-+ if (yytable_value_is_error (yyn))
3742-+ goto yyerrlab;
3743-+ yyn = -yyn;
3744-+ goto yyreduce;
3745++ YYLLOC_DEFAULT(yyloc, &yystack.p_mark[-yym], yym);
3746++ /* just in case YYERROR is invoked within the action, save
3747++ the start of the rhs as the error start position */
3748++ yyerror_loc_range[1] = yystack.p_mark[1-yym];
3749 + }
3750++#endif
3751 +
3752-+ /* Count tokens shifted since error; after three, turn off error
3753-+ status. */
3754-+ if (yyerrstatus)
3755-+ yyerrstatus--;
3756-+
3757-+ /* Shift the lookahead token. */
3758-+ YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
3759-+ yystate = yyn;
3760-+ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
3761-+ *++yyvsp = yylval;
3762-+ YY_IGNORE_MAYBE_UNINITIALIZED_END
3763-+
3764-+ /* Discard the shifted token. */
3765-+ yychar = YYEMPTY;
3766-+ goto yynewstate;
3767-+
3768-+
3769-+/*-----------------------------------------------------------.
3770-+| yydefault -- do the default action for the current state. |
3771-+`-----------------------------------------------------------*/
3772-+yydefault:
3773-+ yyn = yydefact[yystate];
3774-+ if (yyn == 0)
3775-+ goto yyerrlab;
3776-+ goto yyreduce;
3777-+
3778-+
3779-+/*-----------------------------.
3780-+| yyreduce -- do a reduction. |
3781-+`-----------------------------*/
3782-+yyreduce:
3783-+ /* yyn is the number of a rule to reduce with. */
3784-+ yylen = yyr2[yyn];
3785-+
3786-+ /* If YYLEN is nonzero, implement the default value of the action:
3787-+ '$$ = $1'.
3788-+
3789-+ Otherwise, the following line sets YYVAL to garbage.
3790-+ This behavior is undocumented and Bison
3791-+ users should not rely upon it. Assigning to YYVAL
3792-+ unconditionally makes the parser a bit smaller, and it avoids a
3793-+ GCC warning that YYVAL may be used uninitialized. */
3794-+ yyval = yyvsp[1-yylen];
3795-+
3796-+
3797-+ YY_REDUCE_PRINT (yyn);
3798-+ switch (yyn)
3799++ switch (yyn)
3800 + {
3801-+ case 2: /* XkbFile: XkbCompositeMap */
3802-+#line 255 "parser.y"
3803-+ { (yyval.file) = param->rtrn = (yyvsp[0].file); param->more_maps = !!param->rtrn; }
3804-+#line 1834 "parser.c"
3805-+ break;
3806-+
3807-+ case 3: /* XkbFile: XkbMapConfig */
3808-+#line 257 "parser.y"
3809-+ { (yyval.file) = param->rtrn = (yyvsp[0].file); param->more_maps = !!param->rtrn; YYACCEPT; }
3810-+#line 1840 "parser.c"
3811-+ break;
3812-+
3813-+ case 4: /* XkbFile: END_OF_FILE */
3814-+#line 259 "parser.y"
3815-+ { (yyval.file) = param->rtrn = NULL; param->more_maps = false; }
3816-+#line 1846 "parser.c"
3817-+ break;
3818-+
3819-+ case 5: /* XkbCompositeMap: OptFlags XkbCompositeType OptMapName OBRACE XkbMapConfigList CBRACE SEMI */
3820-+#line 265 "parser.y"
3821-+ { (yyval.file) = XkbFileCreate((yyvsp[-5].file_type), (yyvsp[-4].str), (ParseCommon *) (yyvsp[-2].fileList).head, (yyvsp[-6].mapFlags)); }
3822-+#line 1852 "parser.c"
3823-+ break;
3824-+
3825-+ case 6: /* XkbCompositeType: XKB_KEYMAP */
3826-+#line 268 "parser.y"
3827-+ { (yyval.file_type) = FILE_TYPE_KEYMAP; }
3828-+#line 1858 "parser.c"
3829-+ break;
3830-+
3831-+ case 7: /* XkbCompositeType: XKB_SEMANTICS */
3832++case 1:
3833++#line 256 "parser.y"
3834++ { yyval.file = param->rtrn = yystack.l_mark[0].file; param->more_maps = !!param->rtrn; }
3835++#line 2143 "parser.c"
3836++break;
3837++case 2:
3838++#line 258 "parser.y"
3839++ { yyval.file = param->rtrn = yystack.l_mark[0].file; param->more_maps = !!param->rtrn; YYACCEPT; }
3840++#line 2148 "parser.c"
3841++break;
3842++case 3:
3843++#line 260 "parser.y"
3844++ { yyval.file = param->rtrn = NULL; param->more_maps = false; }
3845++#line 2153 "parser.c"
3846++break;
3847++case 4:
3848++#line 266 "parser.y"
3849++ { 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); }
3850++#line 2158 "parser.c"
3851++break;
3852++case 5:
3853 +#line 269 "parser.y"
3854-+ { (yyval.file_type) = FILE_TYPE_KEYMAP; }
3855-+#line 1864 "parser.c"
3856-+ break;
3857-+
3858-+ case 8: /* XkbCompositeType: XKB_LAYOUT */
3859++ { yyval.file_type = FILE_TYPE_KEYMAP; }
3860++#line 2163 "parser.c"
3861++break;
3862++case 6:
3863 +#line 270 "parser.y"
3864-+ { (yyval.file_type) = FILE_TYPE_KEYMAP; }
3865-+#line 1870 "parser.c"
3866-+ break;
3867-+
3868-+ case 9: /* XkbMapConfigList: XkbMapConfigList XkbMapConfig */
3869-+#line 274 "parser.y"
3870-+ { (yyval.fileList).head = (yyvsp[-1].fileList).head; (yyval.fileList).last->common.next = &(yyvsp[0].file)->common; (yyval.fileList).last = (yyvsp[0].file); }
3871-+#line 1876 "parser.c"
3872-+ break;
3873-+
3874-+ case 10: /* XkbMapConfigList: XkbMapConfig */
3875-+#line 276 "parser.y"
3876-+ { (yyval.fileList).head = (yyval.fileList).last = (yyvsp[0].file); }
3877-+#line 1882 "parser.c"
3878-+ break;
3879-+
3880-+ case 11: /* XkbMapConfig: OptFlags FileType OptMapName OBRACE DeclList CBRACE SEMI */
3881-+#line 282 "parser.y"
3882-+ {
3883-+ (yyval.file) = XkbFileCreate((yyvsp[-5].file_type), (yyvsp[-4].str), (yyvsp[-2].anyList).head, (yyvsp[-6].mapFlags));
3884++ { yyval.file_type = FILE_TYPE_KEYMAP; }
3885++#line 2168 "parser.c"
3886++break;
3887++case 7:
3888++#line 271 "parser.y"
3889++ { yyval.file_type = FILE_TYPE_KEYMAP; }
3890++#line 2173 "parser.c"
3891++break;
3892++case 8:
3893++#line 275 "parser.y"
3894++ { 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; }
3895++#line 2178 "parser.c"
3896++break;
3897++case 9:
3898++#line 277 "parser.y"
3899++ { yyval.fileList.head = yyval.fileList.last = yystack.l_mark[0].file; }
3900++#line 2183 "parser.c"
3901++break;
3902++case 10:
3903++#line 283 "parser.y"
3904++ {
3905++ 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);
3906 + }
3907-+#line 1890 "parser.c"
3908-+ break;
3909-+
3910-+ case 12: /* FileType: XKB_KEYCODES */
3911-+#line 287 "parser.y"
3912-+ { (yyval.file_type) = FILE_TYPE_KEYCODES; }
3913-+#line 1896 "parser.c"
3914-+ break;
3915-+
3916-+ case 13: /* FileType: XKB_TYPES */
3917++#line 2190 "parser.c"
3918++break;
3919++case 11:
3920 +#line 288 "parser.y"
3921-+ { (yyval.file_type) = FILE_TYPE_TYPES; }
3922-+#line 1902 "parser.c"
3923-+ break;
3924-+
3925-+ case 14: /* FileType: XKB_COMPATMAP */
3926++ { yyval.file_type = FILE_TYPE_KEYCODES; }
3927++#line 2195 "parser.c"
3928++break;
3929++case 12:
3930 +#line 289 "parser.y"
3931-+ { (yyval.file_type) = FILE_TYPE_COMPAT; }
3932-+#line 1908 "parser.c"
3933-+ break;
3934-+
3935-+ case 15: /* FileType: XKB_SYMBOLS */
3936++ { yyval.file_type = FILE_TYPE_TYPES; }
3937++#line 2200 "parser.c"
3938++break;
3939++case 13:
3940 +#line 290 "parser.y"
3941-+ { (yyval.file_type) = FILE_TYPE_SYMBOLS; }
3942-+#line 1914 "parser.c"
3943-+ break;
3944-+
3945-+ case 16: /* FileType: XKB_GEOMETRY */
3946++ { yyval.file_type = FILE_TYPE_COMPAT; }
3947++#line 2205 "parser.c"
3948++break;
3949++case 14:
3950 +#line 291 "parser.y"
3951-+ { (yyval.file_type) = FILE_TYPE_GEOMETRY; }
3952-+#line 1920 "parser.c"
3953-+ break;
3954-+
3955-+ case 17: /* OptFlags: Flags */
3956-+#line 294 "parser.y"
3957-+ { (yyval.mapFlags) = (yyvsp[0].mapFlags); }
3958-+#line 1926 "parser.c"
3959-+ break;
3960-+
3961-+ case 18: /* OptFlags: %empty */
3962++ { yyval.file_type = FILE_TYPE_SYMBOLS; }
3963++#line 2210 "parser.c"
3964++break;
3965++case 15:
3966++#line 292 "parser.y"
3967++ { yyval.file_type = FILE_TYPE_GEOMETRY; }
3968++#line 2215 "parser.c"
3969++break;
3970++case 16:
3971 +#line 295 "parser.y"
3972-+ { (yyval.mapFlags) = 0; }
3973-+#line 1932 "parser.c"
3974-+ break;
3975-+
3976-+ case 19: /* Flags: Flags Flag */
3977-+#line 298 "parser.y"
3978-+ { (yyval.mapFlags) = ((yyvsp[-1].mapFlags) | (yyvsp[0].mapFlags)); }
3979-+#line 1938 "parser.c"
3980-+ break;
3981-+
3982-+ case 20: /* Flags: Flag */
3983++ { yyval.mapFlags = yystack.l_mark[0].mapFlags; }
3984++#line 2220 "parser.c"
3985++break;
3986++case 17:
3987++#line 296 "parser.y"
3988++ { yyval.mapFlags = 0; }
3989++#line 2225 "parser.c"
3990++break;
3991++case 18:
3992 +#line 299 "parser.y"
3993-+ { (yyval.mapFlags) = (yyvsp[0].mapFlags); }
3994-+#line 1944 "parser.c"
3995-+ break;
3996-+
3997-+ case 21: /* Flag: PARTIAL */
3998-+#line 302 "parser.y"
3999-+ { (yyval.mapFlags) = MAP_IS_PARTIAL; }
4000-+#line 1950 "parser.c"
4001-+ break;
4002-+
4003-+ case 22: /* Flag: DEFAULT */
4004++ { yyval.mapFlags = (yystack.l_mark[-1].mapFlags | yystack.l_mark[0].mapFlags); }
4005++#line 2230 "parser.c"
4006++break;
4007++case 19:
4008++#line 300 "parser.y"
4009++ { yyval.mapFlags = yystack.l_mark[0].mapFlags; }
4010++#line 2235 "parser.c"
4011++break;
4012++case 20:
4013 +#line 303 "parser.y"
4014-+ { (yyval.mapFlags) = MAP_IS_DEFAULT; }
4015-+#line 1956 "parser.c"
4016-+ break;
4017-+
4018-+ case 23: /* Flag: HIDDEN */
4019++ { yyval.mapFlags = MAP_IS_PARTIAL; }
4020++#line 2240 "parser.c"
4021++break;
4022++case 21:
4023 +#line 304 "parser.y"
4024-+ { (yyval.mapFlags) = MAP_IS_HIDDEN; }
4025-+#line 1962 "parser.c"
4026-+ break;
4027-+
4028-+ case 24: /* Flag: ALPHANUMERIC_KEYS */
4029++ { yyval.mapFlags = MAP_IS_DEFAULT; }
4030++#line 2245 "parser.c"
4031++break;
4032++case 22:
4033 +#line 305 "parser.y"
4034-+ { (yyval.mapFlags) = MAP_HAS_ALPHANUMERIC; }
4035-+#line 1968 "parser.c"
4036-+ break;
4037-+
4038-+ case 25: /* Flag: MODIFIER_KEYS */
4039++ { yyval.mapFlags = MAP_IS_HIDDEN; }
4040++#line 2250 "parser.c"
4041++break;
4042++case 23:
4043 +#line 306 "parser.y"
4044-+ { (yyval.mapFlags) = MAP_HAS_MODIFIER; }
4045-+#line 1974 "parser.c"
4046-+ break;
4047-+
4048-+ case 26: /* Flag: KEYPAD_KEYS */
4049++ { yyval.mapFlags = MAP_HAS_ALPHANUMERIC; }
4050++#line 2255 "parser.c"
4051++break;
4052++case 24:
4053 +#line 307 "parser.y"
4054-+ { (yyval.mapFlags) = MAP_HAS_KEYPAD; }
4055-+#line 1980 "parser.c"
4056-+ break;
4057-+
4058-+ case 27: /* Flag: FUNCTION_KEYS */
4059++ { yyval.mapFlags = MAP_HAS_MODIFIER; }
4060++#line 2260 "parser.c"
4061++break;
4062++case 25:
4063 +#line 308 "parser.y"
4064-+ { (yyval.mapFlags) = MAP_HAS_FN; }
4065-+#line 1986 "parser.c"
4066-+ break;
4067-+
4068-+ case 28: /* Flag: ALTERNATE_GROUP */
4069++ { yyval.mapFlags = MAP_HAS_KEYPAD; }
4070++#line 2265 "parser.c"
4071++break;
4072++case 26:
4073 +#line 309 "parser.y"
4074-+ { (yyval.mapFlags) = MAP_IS_ALTGR; }
4075-+#line 1992 "parser.c"
4076-+ break;
4077-+
4078-+ case 29: /* DeclList: DeclList Decl */
4079-+#line 313 "parser.y"
4080-+ {
4081-+ if ((yyvsp[0].any)) {
4082-+ if ((yyvsp[-1].anyList).head) {
4083-+ (yyval.anyList).head = (yyvsp[-1].anyList).head; (yyvsp[-1].anyList).last->next = (yyvsp[0].any); (yyval.anyList).last = (yyvsp[0].any);
4084++ { yyval.mapFlags = MAP_HAS_FN; }
4085++#line 2270 "parser.c"
4086++break;
4087++case 27:
4088++#line 310 "parser.y"
4089++ { yyval.mapFlags = MAP_IS_ALTGR; }
4090++#line 2275 "parser.c"
4091++break;
4092++case 28:
4093++#line 314 "parser.y"
4094++ {
4095++ if (yystack.l_mark[0].any) {
4096++ if (yystack.l_mark[-1].anyList.head) {
4097++ 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;
4098 + } else {
4099-+ (yyval.anyList).head = (yyval.anyList).last = (yyvsp[0].any);
4100++ yyval.anyList.head = yyval.anyList.last = yystack.l_mark[0].any;
4101 + }
4102 + }
4103 + }
4104-+#line 2006 "parser.c"
4105-+ break;
4106-+
4107-+ case 30: /* DeclList: DeclList OptMergeMode VModDecl */
4108-+#line 328 "parser.y"
4109-+ {
4110-+ for (VModDef *vmod = (yyvsp[0].vmodList).head; vmod; vmod = (VModDef *) vmod->common.next)
4111-+ vmod->merge = (yyvsp[-1].merge);
4112-+ if ((yyvsp[-2].anyList).head) {
4113-+ (yyval.anyList).head = (yyvsp[-2].anyList).head; (yyvsp[-2].anyList).last->next = &(yyvsp[0].vmodList).head->common; (yyval.anyList).last = &(yyvsp[0].vmodList).last->common;
4114++#line 2288 "parser.c"
4115++break;
4116++case 29:
4117++#line 329 "parser.y"
4118++ {
4119++ for (VModDef *vmod = yystack.l_mark[0].vmodList.head; vmod; vmod = (VModDef *) vmod->common.next)
4120++ vmod->merge = yystack.l_mark[-1].merge;
4121++ if (yystack.l_mark[-2].anyList.head) {
4122++ 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;
4123 + } else {
4124-+ (yyval.anyList).head = &(yyvsp[0].vmodList).head->common; (yyval.anyList).last = &(yyvsp[0].vmodList).last->common;
4125++ yyval.anyList.head = &yystack.l_mark[0].vmodList.head->common; yyval.anyList.last = &yystack.l_mark[0].vmodList.last->common;
4126 + }
4127 + }
4128-+#line 2020 "parser.c"
4129-+ break;
4130-+
4131-+ case 31: /* DeclList: %empty */
4132-+#line 337 "parser.y"
4133-+ { (yyval.anyList).head = (yyval.anyList).last = NULL; }
4134-+#line 2026 "parser.c"
4135-+ break;
4136-+
4137-+ case 32: /* Decl: OptMergeMode VarDecl */
4138-+#line 341 "parser.y"
4139-+ {
4140-+ (yyvsp[0].var)->merge = (yyvsp[-1].merge);
4141-+ (yyval.any) = (ParseCommon *) (yyvsp[0].var);
4142++#line 2301 "parser.c"
4143++break;
4144++case 30:
4145++#line 338 "parser.y"
4146++ { yyval.anyList.head = yyval.anyList.last = NULL; }
4147++#line 2306 "parser.c"
4148++break;
4149++case 31:
4150++#line 342 "parser.y"
4151++ {
4152++ yystack.l_mark[0].var->merge = yystack.l_mark[-1].merge;
4153++ yyval.any = (ParseCommon *) yystack.l_mark[0].var;
4154 + }
4155-+#line 2035 "parser.c"
4156-+ break;
4157-+
4158-+ case 33: /* Decl: OptMergeMode InterpretDecl */
4159-+#line 347 "parser.y"
4160-+ {
4161-+ (yyvsp[0].interp)->merge = (yyvsp[-1].merge);
4162-+ (yyval.any) = (ParseCommon *) (yyvsp[0].interp);
4163++#line 2314 "parser.c"
4164++break;
4165++case 32:
4166++#line 348 "parser.y"
4167++ {
4168++ yystack.l_mark[0].interp->merge = yystack.l_mark[-1].merge;
4169++ yyval.any = (ParseCommon *) yystack.l_mark[0].interp;
4170 + }
4171-+#line 2044 "parser.c"
4172-+ break;
4173-+
4174-+ case 34: /* Decl: OptMergeMode KeyNameDecl */
4175-+#line 352 "parser.y"
4176-+ {
4177-+ (yyvsp[0].keyCode)->merge = (yyvsp[-1].merge);
4178-+ (yyval.any) = (ParseCommon *) (yyvsp[0].keyCode);
4179++#line 2322 "parser.c"
4180++break;
4181++case 33:
4182++#line 353 "parser.y"
4183++ {
4184++ yystack.l_mark[0].keyCode->merge = yystack.l_mark[-1].merge;
4185++ yyval.any = (ParseCommon *) yystack.l_mark[0].keyCode;
4186 + }
4187-+#line 2053 "parser.c"
4188-+ break;
4189-+
4190-+ case 35: /* Decl: OptMergeMode KeyAliasDecl */
4191-+#line 357 "parser.y"
4192-+ {
4193-+ (yyvsp[0].keyAlias)->merge = (yyvsp[-1].merge);
4194-+ (yyval.any) = (ParseCommon *) (yyvsp[0].keyAlias);
4195++#line 2330 "parser.c"
4196++break;
4197++case 34:
4198++#line 358 "parser.y"
4199++ {
4200++ yystack.l_mark[0].keyAlias->merge = yystack.l_mark[-1].merge;
4201++ yyval.any = (ParseCommon *) yystack.l_mark[0].keyAlias;
4202 + }
4203-+#line 2062 "parser.c"
4204-+ break;
4205-+
4206-+ case 36: /* Decl: OptMergeMode KeyTypeDecl */
4207-+#line 362 "parser.y"
4208-+ {
4209-+ (yyvsp[0].keyType)->merge = (yyvsp[-1].merge);
4210-+ (yyval.any) = (ParseCommon *) (yyvsp[0].keyType);
4211++#line 2338 "parser.c"
4212++break;
4213++case 35:
4214++#line 363 "parser.y"
4215++ {
4216++ yystack.l_mark[0].keyType->merge = yystack.l_mark[-1].merge;
4217++ yyval.any = (ParseCommon *) yystack.l_mark[0].keyType;
4218 + }
4219-+#line 2071 "parser.c"
4220-+ break;
4221-+
4222-+ case 37: /* Decl: OptMergeMode SymbolsDecl */
4223-+#line 367 "parser.y"
4224-+ {
4225-+ (yyvsp[0].syms)->merge = (yyvsp[-1].merge);
4226-+ (yyval.any) = (ParseCommon *) (yyvsp[0].syms);
4227++#line 2346 "parser.c"
4228++break;
4229++case 36:
4230++#line 368 "parser.y"
4231++ {
4232++ yystack.l_mark[0].syms->merge = yystack.l_mark[-1].merge;
4233++ yyval.any = (ParseCommon *) yystack.l_mark[0].syms;
4234 + }
4235-+#line 2080 "parser.c"
4236-+ break;
4237-+
4238-+ case 38: /* Decl: OptMergeMode ModMapDecl */
4239-+#line 372 "parser.y"
4240-+ {
4241-+ (yyvsp[0].modMask)->merge = (yyvsp[-1].merge);
4242-+ (yyval.any) = (ParseCommon *) (yyvsp[0].modMask);
4243++#line 2354 "parser.c"
4244++break;
4245++case 37:
4246++#line 373 "parser.y"
4247++ {
4248++ yystack.l_mark[0].modMask->merge = yystack.l_mark[-1].merge;
4249++ yyval.any = (ParseCommon *) yystack.l_mark[0].modMask;
4250 + }
4251-+#line 2089 "parser.c"
4252-+ break;
4253-+
4254-+ case 39: /* Decl: OptMergeMode GroupCompatDecl */
4255-+#line 377 "parser.y"
4256-+ {
4257-+ (yyvsp[0].groupCompat)->merge = (yyvsp[-1].merge);
4258-+ (yyval.any) = (ParseCommon *) (yyvsp[0].groupCompat);
4259++#line 2362 "parser.c"
4260++break;
4261++case 38:
4262++#line 378 "parser.y"
4263++ {
4264++ yystack.l_mark[0].groupCompat->merge = yystack.l_mark[-1].merge;
4265++ yyval.any = (ParseCommon *) yystack.l_mark[0].groupCompat;
4266 + }
4267-+#line 2098 "parser.c"
4268-+ break;
4269-+
4270-+ case 40: /* Decl: OptMergeMode LedMapDecl */
4271-+#line 382 "parser.y"
4272-+ {
4273-+ (yyvsp[0].ledMap)->merge = (yyvsp[-1].merge);
4274-+ (yyval.any) = (ParseCommon *) (yyvsp[0].ledMap);
4275++#line 2370 "parser.c"
4276++break;
4277++case 39:
4278++#line 383 "parser.y"
4279++ {
4280++ yystack.l_mark[0].ledMap->merge = yystack.l_mark[-1].merge;
4281++ yyval.any = (ParseCommon *) yystack.l_mark[0].ledMap;
4282 + }
4283-+#line 2107 "parser.c"
4284-+ break;
4285-+
4286-+ case 41: /* Decl: OptMergeMode LedNameDecl */
4287-+#line 387 "parser.y"
4288-+ {
4289-+ (yyvsp[0].ledName)->merge = (yyvsp[-1].merge);
4290-+ (yyval.any) = (ParseCommon *) (yyvsp[0].ledName);
4291++#line 2378 "parser.c"
4292++break;
4293++case 40:
4294++#line 388 "parser.y"
4295++ {
4296++ yystack.l_mark[0].ledName->merge = yystack.l_mark[-1].merge;
4297++ yyval.any = (ParseCommon *) yystack.l_mark[0].ledName;
4298 + }
4299-+#line 2116 "parser.c"
4300-+ break;
4301-+
4302-+ case 42: /* Decl: OptMergeMode ShapeDecl */
4303-+#line 391 "parser.y"
4304-+ { (yyval.any) = NULL; }
4305-+#line 2122 "parser.c"
4306-+ break;
4307-+
4308-+ case 43: /* Decl: OptMergeMode SectionDecl */
4309++#line 2386 "parser.c"
4310++break;
4311++case 41:
4312 +#line 392 "parser.y"
4313-+ { (yyval.any) = NULL; }
4314-+#line 2128 "parser.c"
4315-+ break;
4316-+
4317-+ case 44: /* Decl: OptMergeMode DoodadDecl */
4318++ { yyval.any = NULL; }
4319++#line 2391 "parser.c"
4320++break;
4321++case 42:
4322 +#line 393 "parser.y"
4323-+ { (yyval.any) = NULL; }
4324-+#line 2134 "parser.c"
4325-+ break;
4326-+
4327-+ case 45: /* Decl: MergeMode STRING */
4328-+#line 395 "parser.y"
4329-+ {
4330-+ (yyval.any) = (ParseCommon *) IncludeCreate(param->ctx, (yyvsp[0].str), (yyvsp[-1].merge));
4331-+ free((yyvsp[0].str));
4332++ { yyval.any = NULL; }
4333++#line 2396 "parser.c"
4334++break;
4335++case 43:
4336++#line 394 "parser.y"
4337++ { yyval.any = NULL; }
4338++#line 2401 "parser.c"
4339++break;
4340++case 44:
4341++#line 396 "parser.y"
4342++ {
4343++ yyval.any = (ParseCommon *) IncludeCreate(param->ctx, yystack.l_mark[0].str, yystack.l_mark[-1].merge);
4344++ free(yystack.l_mark[0].str);
4345 + }
4346-+#line 2143 "parser.c"
4347-+ break;
4348-+
4349-+ case 46: /* VarDecl: Lhs EQUALS Expr SEMI */
4350-+#line 402 "parser.y"
4351-+ { (yyval.var) = VarCreate((yyvsp[-3].expr), (yyvsp[-1].expr)); }
4352-+#line 2149 "parser.c"
4353-+ break;
4354-+
4355-+ case 47: /* VarDecl: Ident SEMI */
4356-+#line 404 "parser.y"
4357-+ { (yyval.var) = BoolVarCreate((yyvsp[-1].atom), true); }
4358-+#line 2155 "parser.c"
4359-+ break;
4360-+
4361-+ case 48: /* VarDecl: EXCLAM Ident SEMI */
4362-+#line 406 "parser.y"
4363-+ { (yyval.var) = BoolVarCreate((yyvsp[-1].atom), false); }
4364-+#line 2161 "parser.c"
4365-+ break;
4366-+
4367-+ case 49: /* KeyNameDecl: KEYNAME EQUALS KeyCode SEMI */
4368-+#line 410 "parser.y"
4369-+ { (yyval.keyCode) = KeycodeCreate((yyvsp[-3].atom), (yyvsp[-1].num)); }
4370-+#line 2167 "parser.c"
4371-+ break;
4372-+
4373-+ case 50: /* KeyAliasDecl: ALIAS KEYNAME EQUALS KEYNAME SEMI */
4374-+#line 414 "parser.y"
4375-+ { (yyval.keyAlias) = KeyAliasCreate((yyvsp[-3].atom), (yyvsp[-1].atom)); }
4376-+#line 2173 "parser.c"
4377-+ break;
4378-+
4379-+ case 51: /* VModDecl: VIRTUAL_MODS VModDefList SEMI */
4380-+#line 418 "parser.y"
4381-+ { (yyval.vmodList) = (yyvsp[-1].vmodList); }
4382-+#line 2179 "parser.c"
4383-+ break;
4384-+
4385-+ case 52: /* VModDefList: VModDefList COMMA VModDef */
4386-+#line 422 "parser.y"
4387-+ { (yyval.vmodList).head = (yyvsp[-2].vmodList).head; (yyval.vmodList).last->common.next = &(yyvsp[0].vmod)->common; (yyval.vmodList).last = (yyvsp[0].vmod); }
4388-+#line 2185 "parser.c"
4389-+ break;
4390-+
4391-+ case 53: /* VModDefList: VModDef */
4392-+#line 424 "parser.y"
4393-+ { (yyval.vmodList).head = (yyval.vmodList).last = (yyvsp[0].vmod); }
4394-+#line 2191 "parser.c"
4395-+ break;
4396-+
4397-+ case 54: /* VModDef: Ident */
4398-+#line 428 "parser.y"
4399-+ { (yyval.vmod) = VModCreate((yyvsp[0].atom), NULL); }
4400-+#line 2197 "parser.c"
4401-+ break;
4402-+
4403-+ case 55: /* VModDef: Ident EQUALS Expr */
4404-+#line 430 "parser.y"
4405-+ { (yyval.vmod) = VModCreate((yyvsp[-2].atom), (yyvsp[0].expr)); }
4406-+#line 2203 "parser.c"
4407-+ break;
4408-+
4409-+ case 56: /* InterpretDecl: INTERPRET InterpretMatch OBRACE VarDeclList CBRACE SEMI */
4410-+#line 436 "parser.y"
4411-+ { (yyvsp[-4].interp)->def = (yyvsp[-2].varList).head; (yyval.interp) = (yyvsp[-4].interp); }
4412-+#line 2209 "parser.c"
4413-+ break;
4414-+
4415-+ case 57: /* InterpretMatch: KeySym PLUS Expr */
4416-+#line 440 "parser.y"
4417-+ { (yyval.interp) = InterpCreate((yyvsp[-2].keysym), (yyvsp[0].expr)); }
4418-+#line 2215 "parser.c"
4419-+ break;
4420-+
4421-+ case 58: /* InterpretMatch: KeySym */
4422-+#line 442 "parser.y"
4423-+ { (yyval.interp) = InterpCreate((yyvsp[0].keysym), NULL); }
4424-+#line 2221 "parser.c"
4425-+ break;
4426-+
4427-+ case 59: /* VarDeclList: VarDeclList VarDecl */
4428-+#line 446 "parser.y"
4429-+ { (yyval.varList).head = (yyvsp[-1].varList).head; (yyval.varList).last->common.next = &(yyvsp[0].var)->common; (yyval.varList).last = (yyvsp[0].var); }
4430-+#line 2227 "parser.c"
4431-+ break;
4432-+
4433-+ case 60: /* VarDeclList: VarDecl */
4434-+#line 448 "parser.y"
4435-+ { (yyval.varList).head = (yyval.varList).last = (yyvsp[0].var); }
4436-+#line 2233 "parser.c"
4437-+ break;
4438-+
4439-+ case 61: /* KeyTypeDecl: TYPE String OBRACE VarDeclList CBRACE SEMI */
4440-+#line 454 "parser.y"
4441-+ { (yyval.keyType) = KeyTypeCreate((yyvsp[-4].atom), (yyvsp[-2].varList).head); }
4442-+#line 2239 "parser.c"
4443-+ break;
4444-+
4445-+ case 62: /* SymbolsDecl: KEY KEYNAME OBRACE SymbolsBody CBRACE SEMI */
4446-+#line 460 "parser.y"
4447-+ { (yyval.syms) = SymbolsCreate((yyvsp[-4].atom), (yyvsp[-2].varList).head); }
4448-+#line 2245 "parser.c"
4449-+ break;
4450-+
4451-+ case 63: /* SymbolsBody: SymbolsBody COMMA SymbolsVarDecl */
4452-+#line 464 "parser.y"
4453-+ { (yyval.varList).head = (yyvsp[-2].varList).head; (yyval.varList).last->common.next = &(yyvsp[0].var)->common; (yyval.varList).last = (yyvsp[0].var); }
4454-+#line 2251 "parser.c"
4455-+ break;
4456-+
4457-+ case 64: /* SymbolsBody: SymbolsVarDecl */
4458-+#line 466 "parser.y"
4459-+ { (yyval.varList).head = (yyval.varList).last = (yyvsp[0].var); }
4460-+#line 2257 "parser.c"
4461-+ break;
4462-+
4463-+ case 65: /* SymbolsBody: %empty */
4464++#line 2409 "parser.c"
4465++break;
4466++case 45:
4467++#line 403 "parser.y"
4468++ { yyval.var = VarCreate(yystack.l_mark[-3].expr, yystack.l_mark[-1].expr); }
4469++#line 2414 "parser.c"
4470++break;
4471++case 46:
4472++#line 405 "parser.y"
4473++ { yyval.var = BoolVarCreate(yystack.l_mark[-1].atom, true); }
4474++#line 2419 "parser.c"
4475++break;
4476++case 47:
4477++#line 407 "parser.y"
4478++ { yyval.var = BoolVarCreate(yystack.l_mark[-1].atom, false); }
4479++#line 2424 "parser.c"
4480++break;
4481++case 48:
4482++#line 411 "parser.y"
4483++ { yyval.keyCode = KeycodeCreate(yystack.l_mark[-3].atom, yystack.l_mark[-1].num); }
4484++#line 2429 "parser.c"
4485++break;
4486++case 49:
4487++#line 415 "parser.y"
4488++ { yyval.keyAlias = KeyAliasCreate(yystack.l_mark[-3].atom, yystack.l_mark[-1].atom); }
4489++#line 2434 "parser.c"
4490++break;
4491++case 50:
4492++#line 419 "parser.y"
4493++ { yyval.vmodList = yystack.l_mark[-1].vmodList; }
4494++#line 2439 "parser.c"
4495++break;
4496++case 51:
4497++#line 423 "parser.y"
4498++ { 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; }
4499++#line 2444 "parser.c"
4500++break;
4501++case 52:
4502++#line 425 "parser.y"
4503++ { yyval.vmodList.head = yyval.vmodList.last = yystack.l_mark[0].vmod; }
4504++#line 2449 "parser.c"
4505++break;
4506++case 53:
4507++#line 429 "parser.y"
4508++ { yyval.vmod = VModCreate(yystack.l_mark[0].atom, NULL); }
4509++#line 2454 "parser.c"
4510++break;
4511++case 54:
4512++#line 431 "parser.y"
4513++ { yyval.vmod = VModCreate(yystack.l_mark[-2].atom, yystack.l_mark[0].expr); }
4514++#line 2459 "parser.c"
4515++break;
4516++case 55:
4517++#line 437 "parser.y"
4518++ { yystack.l_mark[-4].interp->def = yystack.l_mark[-2].varList.head; yyval.interp = yystack.l_mark[-4].interp; }
4519++#line 2464 "parser.c"
4520++break;
4521++case 56:
4522++#line 441 "parser.y"
4523++ { yyval.interp = InterpCreate(yystack.l_mark[-2].keysym, yystack.l_mark[0].expr); }
4524++#line 2469 "parser.c"
4525++break;
4526++case 57:
4527++#line 443 "parser.y"
4528++ { yyval.interp = InterpCreate(yystack.l_mark[0].keysym, NULL); }
4529++#line 2474 "parser.c"
4530++break;
4531++case 58:
4532++#line 447 "parser.y"
4533++ { 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; }
4534++#line 2479 "parser.c"
4535++break;
4536++case 59:
4537++#line 449 "parser.y"
4538++ { yyval.varList.head = yyval.varList.last = yystack.l_mark[0].var; }
4539++#line 2484 "parser.c"
4540++break;
4541++case 60:
4542++#line 455 "parser.y"
4543++ { yyval.keyType = KeyTypeCreate(yystack.l_mark[-4].atom, yystack.l_mark[-2].varList.head); }
4544++#line 2489 "parser.c"
4545++break;
4546++case 61:
4547++#line 461 "parser.y"
4548++ { yyval.syms = SymbolsCreate(yystack.l_mark[-4].atom, yystack.l_mark[-2].varList.head); }
4549++#line 2494 "parser.c"
4550++break;
4551++case 62:
4552++#line 465 "parser.y"
4553++ { 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; }
4554++#line 2499 "parser.c"
4555++break;
4556++case 63:
4557 +#line 467 "parser.y"
4558-+ { (yyval.varList).head = (yyval.varList).last = NULL; }
4559-+#line 2263 "parser.c"
4560-+ break;
4561-+
4562-+ case 66: /* SymbolsVarDecl: Lhs EQUALS Expr */
4563++ { yyval.varList.head = yyval.varList.last = yystack.l_mark[0].var; }
4564++#line 2504 "parser.c"
4565++break;
4566++case 64:
4567 +#line 470 "parser.y"
4568-+ { (yyval.var) = VarCreate((yyvsp[-2].expr), (yyvsp[0].expr)); }
4569-+#line 2269 "parser.c"
4570-+ break;
4571-+
4572-+ case 67: /* SymbolsVarDecl: Lhs EQUALS ArrayInit */
4573++ { yyval.var = VarCreate(yystack.l_mark[-2].expr, yystack.l_mark[0].expr); }
4574++#line 2509 "parser.c"
4575++break;
4576++case 65:
4577 +#line 471 "parser.y"
4578-+ { (yyval.var) = VarCreate((yyvsp[-2].expr), (yyvsp[0].expr)); }
4579-+#line 2275 "parser.c"
4580-+ break;
4581-+
4582-+ case 68: /* SymbolsVarDecl: Ident */
4583++ { yyval.var = VarCreate(yystack.l_mark[-2].expr, yystack.l_mark[0].expr); }
4584++#line 2514 "parser.c"
4585++break;
4586++case 66:
4587 +#line 472 "parser.y"
4588-+ { (yyval.var) = BoolVarCreate((yyvsp[0].atom), true); }
4589-+#line 2281 "parser.c"
4590-+ break;
4591-+
4592-+ case 69: /* SymbolsVarDecl: EXCLAM Ident */
4593++ { yyval.var = BoolVarCreate(yystack.l_mark[0].atom, true); }
4594++#line 2519 "parser.c"
4595++break;
4596++case 67:
4597 +#line 473 "parser.y"
4598-+ { (yyval.var) = BoolVarCreate((yyvsp[0].atom), false); }
4599-+#line 2287 "parser.c"
4600-+ break;
4601-+
4602-+ case 70: /* SymbolsVarDecl: ArrayInit */
4603++ { yyval.var = BoolVarCreate(yystack.l_mark[0].atom, false); }
4604++#line 2524 "parser.c"
4605++break;
4606++case 68:
4607 +#line 474 "parser.y"
4608-+ { (yyval.var) = VarCreate(NULL, (yyvsp[0].expr)); }
4609-+#line 2293 "parser.c"
4610-+ break;
4611-+
4612-+ case 71: /* ArrayInit: OBRACKET OptKeySymList CBRACKET */
4613++ { yyval.var = VarCreate(NULL, yystack.l_mark[0].expr); }
4614++#line 2529 "parser.c"
4615++break;
4616++case 69:
4617 +#line 478 "parser.y"
4618-+ { (yyval.expr) = (yyvsp[-1].expr); }
4619-+#line 2299 "parser.c"
4620-+ break;
4621-+
4622-+ case 72: /* ArrayInit: OBRACKET ActionList CBRACKET */
4623++ { yyval.expr = yystack.l_mark[-1].expr; }
4624++#line 2534 "parser.c"
4625++break;
4626++case 70:
4627 +#line 480 "parser.y"
4628-+ { (yyval.expr) = ExprCreateActionList((yyvsp[-1].exprList).head); }
4629-+#line 2305 "parser.c"
4630-+ break;
4631-+
4632-+ case 73: /* GroupCompatDecl: GROUP Integer EQUALS Expr SEMI */
4633++ { yyval.expr = ExprCreateActionList(yystack.l_mark[-1].exprList.head); }
4634++#line 2539 "parser.c"
4635++break;
4636++case 71:
4637 +#line 484 "parser.y"
4638-+ { (yyval.groupCompat) = GroupCompatCreate((yyvsp[-3].num), (yyvsp[-1].expr)); }
4639-+#line 2311 "parser.c"
4640-+ break;
4641-+
4642-+ case 74: /* ModMapDecl: MODIFIER_MAP Ident OBRACE ExprList CBRACE SEMI */
4643++ { yyval.groupCompat = GroupCompatCreate(yystack.l_mark[-3].num, yystack.l_mark[-1].expr); }
4644++#line 2544 "parser.c"
4645++break;
4646++case 72:
4647 +#line 488 "parser.y"
4648-+ { (yyval.modMask) = ModMapCreate((yyvsp[-4].atom), (yyvsp[-2].exprList).head); }
4649-+#line 2317 "parser.c"
4650-+ break;
4651-+
4652-+ case 75: /* LedMapDecl: INDICATOR String OBRACE VarDeclList CBRACE SEMI */
4653++ { yyval.modMask = ModMapCreate(yystack.l_mark[-4].atom, yystack.l_mark[-2].exprList.head); }
4654++#line 2549 "parser.c"
4655++break;
4656++case 73:
4657 +#line 492 "parser.y"
4658-+ { (yyval.ledMap) = LedMapCreate((yyvsp[-4].atom), (yyvsp[-2].varList).head); }
4659-+#line 2323 "parser.c"
4660-+ break;
4661-+
4662-+ case 76: /* LedNameDecl: INDICATOR Integer EQUALS Expr SEMI */
4663++ { yyval.ledMap = LedMapCreate(yystack.l_mark[-4].atom, yystack.l_mark[-2].varList.head); }
4664++#line 2554 "parser.c"
4665++break;
4666++case 74:
4667 +#line 496 "parser.y"
4668-+ { (yyval.ledName) = LedNameCreate((yyvsp[-3].num), (yyvsp[-1].expr), false); }
4669-+#line 2329 "parser.c"
4670-+ break;
4671-+
4672-+ case 77: /* LedNameDecl: VIRTUAL INDICATOR Integer EQUALS Expr SEMI */
4673++ { yyval.ledName = LedNameCreate(yystack.l_mark[-3].num, yystack.l_mark[-1].expr, false); }
4674++#line 2559 "parser.c"
4675++break;
4676++case 75:
4677 +#line 498 "parser.y"
4678-+ { (yyval.ledName) = LedNameCreate((yyvsp[-3].num), (yyvsp[-1].expr), true); }
4679-+#line 2335 "parser.c"
4680-+ break;
4681-+
4682-+ case 78: /* ShapeDecl: SHAPE String OBRACE OutlineList CBRACE SEMI */
4683++ { yyval.ledName = LedNameCreate(yystack.l_mark[-3].num, yystack.l_mark[-1].expr, true); }
4684++#line 2564 "parser.c"
4685++break;
4686++case 76:
4687 +#line 502 "parser.y"
4688-+ { (yyval.geom) = NULL; }
4689-+#line 2341 "parser.c"
4690-+ break;
4691-+
4692-+ case 79: /* ShapeDecl: SHAPE String OBRACE CoordList CBRACE SEMI */
4693++ { yyval.geom = NULL; }
4694++#line 2569 "parser.c"
4695++break;
4696++case 77:
4697 +#line 504 "parser.y"
4698-+ { (void) (yyvsp[-2].expr); (yyval.geom) = NULL; }
4699-+#line 2347 "parser.c"
4700-+ break;
4701-+
4702-+ case 80: /* SectionDecl: SECTION String OBRACE SectionBody CBRACE SEMI */
4703++ { (void) yystack.l_mark[-2].expr; yyval.geom = NULL; }
4704++#line 2574 "parser.c"
4705++break;
4706++case 78:
4707 +#line 508 "parser.y"
4708-+ { (yyval.geom) = NULL; }
4709-+#line 2353 "parser.c"
4710-+ break;
4711-+
4712-+ case 81: /* SectionBody: SectionBody SectionBodyItem */
4713++ { yyval.geom = NULL; }
4714++#line 2579 "parser.c"
4715++break;
4716++case 79:
4717 +#line 511 "parser.y"
4718-+ { (yyval.geom) = NULL;}
4719-+#line 2359 "parser.c"
4720-+ break;
4721-+
4722-+ case 82: /* SectionBody: SectionBodyItem */
4723++ { yyval.geom = NULL;}
4724++#line 2584 "parser.c"
4725++break;
4726++case 80:
4727 +#line 512 "parser.y"
4728-+ { (yyval.geom) = NULL; }
4729-+#line 2365 "parser.c"
4730-+ break;
4731-+
4732-+ case 83: /* SectionBodyItem: ROW OBRACE RowBody CBRACE SEMI */
4733++ { yyval.geom = NULL; }
4734++#line 2589 "parser.c"
4735++break;
4736++case 81:
4737 +#line 516 "parser.y"
4738-+ { (yyval.geom) = NULL; }
4739-+#line 2371 "parser.c"
4740-+ break;
4741-+
4742-+ case 84: /* SectionBodyItem: VarDecl */
4743++ { yyval.geom = NULL; }
4744++#line 2594 "parser.c"
4745++break;
4746++case 82:
4747 +#line 518 "parser.y"
4748-+ { FreeStmt((ParseCommon *) (yyvsp[0].var)); (yyval.geom) = NULL; }
4749-+#line 2377 "parser.c"
4750-+ break;
4751-+
4752-+ case 85: /* SectionBodyItem: DoodadDecl */
4753++ { FreeStmt((ParseCommon *) yystack.l_mark[0].var); yyval.geom = NULL; }
4754++#line 2599 "parser.c"
4755++break;
4756++case 83:
4757 +#line 520 "parser.y"
4758-+ { (yyval.geom) = NULL; }
4759-+#line 2383 "parser.c"
4760-+ break;
4761-+
4762-+ case 86: /* SectionBodyItem: LedMapDecl */
4763++ { yyval.geom = NULL; }
4764++#line 2604 "parser.c"
4765++break;
4766++case 84:
4767 +#line 522 "parser.y"
4768-+ { FreeStmt((ParseCommon *) (yyvsp[0].ledMap)); (yyval.geom) = NULL; }
4769-+#line 2389 "parser.c"
4770-+ break;
4771-+
4772-+ case 87: /* SectionBodyItem: OverlayDecl */
4773++ { FreeStmt((ParseCommon *) yystack.l_mark[0].ledMap); yyval.geom = NULL; }
4774++#line 2609 "parser.c"
4775++break;
4776++case 85:
4777 +#line 524 "parser.y"
4778-+ { (yyval.geom) = NULL; }
4779-+#line 2395 "parser.c"
4780-+ break;
4781-+
4782-+ case 88: /* RowBody: RowBody RowBodyItem */
4783++ { yyval.geom = NULL; }
4784++#line 2614 "parser.c"
4785++break;
4786++case 86:
4787 +#line 527 "parser.y"
4788-+ { (yyval.geom) = NULL;}
4789-+#line 2401 "parser.c"
4790-+ break;
4791-+
4792-+ case 89: /* RowBody: RowBodyItem */
4793++ { yyval.geom = NULL;}
4794++#line 2619 "parser.c"
4795++break;
4796++case 87:
4797 +#line 528 "parser.y"
4798-+ { (yyval.geom) = NULL; }
4799-+#line 2407 "parser.c"
4800-+ break;
4801-+
4802-+ case 90: /* RowBodyItem: KEYS OBRACE Keys CBRACE SEMI */
4803++ { yyval.geom = NULL; }
4804++#line 2624 "parser.c"
4805++break;
4806++case 88:
4807 +#line 531 "parser.y"
4808-+ { (yyval.geom) = NULL; }
4809-+#line 2413 "parser.c"
4810-+ break;
4811-+
4812-+ case 91: /* RowBodyItem: VarDecl */
4813++ { yyval.geom = NULL; }
4814++#line 2629 "parser.c"
4815++break;
4816++case 89:
4817 +#line 533 "parser.y"
4818-+ { FreeStmt((ParseCommon *) (yyvsp[0].var)); (yyval.geom) = NULL; }
4819-+#line 2419 "parser.c"
4820-+ break;
4821-+
4822-+ case 92: /* Keys: Keys COMMA Key */
4823++ { FreeStmt((ParseCommon *) yystack.l_mark[0].var); yyval.geom = NULL; }
4824++#line 2634 "parser.c"
4825++break;
4826++case 90:
4827 +#line 536 "parser.y"
4828-+ { (yyval.geom) = NULL; }
4829-+#line 2425 "parser.c"
4830-+ break;
4831-+
4832-+ case 93: /* Keys: Key */
4833++ { yyval.geom = NULL; }
4834++#line 2639 "parser.c"
4835++break;
4836++case 91:
4837 +#line 537 "parser.y"
4838-+ { (yyval.geom) = NULL; }
4839-+#line 2431 "parser.c"
4840-+ break;
4841-+
4842-+ case 94: /* Key: KEYNAME */
4843++ { yyval.geom = NULL; }
4844++#line 2644 "parser.c"
4845++break;
4846++case 92:
4847 +#line 541 "parser.y"
4848-+ { (yyval.geom) = NULL; }
4849-+#line 2437 "parser.c"
4850-+ break;
4851-+
4852-+ case 95: /* Key: OBRACE ExprList CBRACE */
4853++ { yyval.geom = NULL; }
4854++#line 2649 "parser.c"
4855++break;
4856++case 93:
4857 +#line 543 "parser.y"
4858-+ { FreeStmt((ParseCommon *) (yyvsp[-1].exprList).head); (yyval.geom) = NULL; }
4859-+#line 2443 "parser.c"
4860-+ break;
4861-+
4862-+ case 96: /* OverlayDecl: OVERLAY String OBRACE OverlayKeyList CBRACE SEMI */
4863++ { FreeStmt((ParseCommon *) yystack.l_mark[-1].exprList.head); yyval.geom = NULL; }
4864++#line 2654 "parser.c"
4865++break;
4866++case 94:
4867 +#line 547 "parser.y"
4868-+ { (yyval.geom) = NULL; }
4869-+#line 2449 "parser.c"
4870-+ break;
4871-+
4872-+ case 97: /* OverlayKeyList: OverlayKeyList COMMA OverlayKey */
4873++ { yyval.geom = NULL; }
4874++#line 2659 "parser.c"
4875++break;
4876++case 95:
4877 +#line 550 "parser.y"
4878-+ { (yyval.geom) = NULL; }
4879-+#line 2455 "parser.c"
4880-+ break;
4881-+
4882-+ case 98: /* OverlayKeyList: OverlayKey */
4883++ { yyval.geom = NULL; }
4884++#line 2664 "parser.c"
4885++break;
4886++case 96:
4887 +#line 551 "parser.y"
4888-+ { (yyval.geom) = NULL; }
4889-+#line 2461 "parser.c"
4890-+ break;
4891-+
4892-+ case 99: /* OverlayKey: KEYNAME EQUALS KEYNAME */
4893++ { yyval.geom = NULL; }
4894++#line 2669 "parser.c"
4895++break;
4896++case 97:
4897 +#line 554 "parser.y"
4898-+ { (yyval.geom) = NULL; }
4899-+#line 2467 "parser.c"
4900-+ break;
4901-+
4902-+ case 100: /* OutlineList: OutlineList COMMA OutlineInList */
4903++ { yyval.geom = NULL; }
4904++#line 2674 "parser.c"
4905++break;
4906++case 98:
4907 +#line 558 "parser.y"
4908-+ { (yyval.geom) = NULL;}
4909-+#line 2473 "parser.c"
4910-+ break;
4911-+
4912-+ case 101: /* OutlineList: OutlineInList */
4913++ { yyval.geom = NULL;}
4914++#line 2679 "parser.c"
4915++break;
4916++case 99:
4917 +#line 560 "parser.y"
4918-+ { (yyval.geom) = NULL; }
4919-+#line 2479 "parser.c"
4920-+ break;
4921-+
4922-+ case 102: /* OutlineInList: OBRACE CoordList CBRACE */
4923++ { yyval.geom = NULL; }
4924++#line 2684 "parser.c"
4925++break;
4926++case 100:
4927 +#line 564 "parser.y"
4928-+ { (void) (yyvsp[-1].expr); (yyval.geom) = NULL; }
4929-+#line 2485 "parser.c"
4930-+ break;
4931-+
4932-+ case 103: /* OutlineInList: Ident EQUALS OBRACE CoordList CBRACE */
4933++ { (void) yystack.l_mark[-1].expr; yyval.geom = NULL; }
4934++#line 2689 "parser.c"
4935++break;
4936++case 101:
4937 +#line 566 "parser.y"
4938-+ { (void) (yyvsp[-1].expr); (yyval.geom) = NULL; }
4939-+#line 2491 "parser.c"
4940-+ break;
4941-+
4942-+ case 104: /* OutlineInList: Ident EQUALS Expr */
4943++ { (void) yystack.l_mark[-1].expr; yyval.geom = NULL; }
4944++#line 2694 "parser.c"
4945++break;
4946++case 102:
4947 +#line 568 "parser.y"
4948-+ { FreeStmt((ParseCommon *) (yyvsp[0].expr)); (yyval.geom) = NULL; }
4949-+#line 2497 "parser.c"
4950-+ break;
4951-+
4952-+ case 105: /* CoordList: CoordList COMMA Coord */
4953++ { FreeStmt((ParseCommon *) yystack.l_mark[0].expr); yyval.geom = NULL; }
4954++#line 2699 "parser.c"
4955++break;
4956++case 103:
4957 +#line 572 "parser.y"
4958-+ { (void) (yyvsp[-2].expr); (void) (yyvsp[0].expr); (yyval.expr) = NULL; }
4959-+#line 2503 "parser.c"
4960-+ break;
4961-+
4962-+ case 106: /* CoordList: Coord */
4963++ { (void) yystack.l_mark[-2].expr; (void) yystack.l_mark[0].expr; yyval.expr = NULL; }
4964++#line 2704 "parser.c"
4965++break;
4966++case 104:
4967 +#line 574 "parser.y"
4968-+ { (void) (yyvsp[0].expr); (yyval.expr) = NULL; }
4969-+#line 2509 "parser.c"
4970-+ break;
4971-+
4972-+ case 107: /* Coord: OBRACKET SignedNumber COMMA SignedNumber CBRACKET */
4973++ { (void) yystack.l_mark[0].expr; yyval.expr = NULL; }
4974++#line 2709 "parser.c"
4975++break;
4976++case 105:
4977 +#line 578 "parser.y"
4978-+ { (yyval.expr) = NULL; }
4979-+#line 2515 "parser.c"
4980-+ break;
4981-+
4982-+ case 108: /* DoodadDecl: DoodadType String OBRACE VarDeclList CBRACE SEMI */
4983++ { yyval.expr = NULL; }
4984++#line 2714 "parser.c"
4985++break;
4986++case 106:
4987 +#line 582 "parser.y"
4988-+ { FreeStmt((ParseCommon *) (yyvsp[-2].varList).head); (yyval.geom) = NULL; }
4989-+#line 2521 "parser.c"
4990-+ break;
4991-+
4992-+ case 109: /* DoodadType: TEXT */
4993++ { FreeStmt((ParseCommon *) yystack.l_mark[-2].varList.head); yyval.geom = NULL; }
4994++#line 2719 "parser.c"
4995++break;
4996++case 107:
4997 +#line 585 "parser.y"
4998-+ { (yyval.num) = 0; }
4999-+#line 2527 "parser.c"
5000-+ break;
5001-+
5002-+ case 110: /* DoodadType: OUTLINE */
5003++ { yyval.num = 0; }
5004++#line 2724 "parser.c"
5005++break;
5006++case 108:
5007 +#line 586 "parser.y"
5008-+ { (yyval.num) = 0; }
5009-+#line 2533 "parser.c"
5010-+ break;
5011-+
5012-+ case 111: /* DoodadType: SOLID */
5013++ { yyval.num = 0; }
5014++#line 2729 "parser.c"
5015++break;
5016++case 109:
5017 +#line 587 "parser.y"
5018-+ { (yyval.num) = 0; }
5019-+#line 2539 "parser.c"
5020-+ break;
5021-+
5022-+ case 112: /* DoodadType: LOGO */
5023++ { yyval.num = 0; }
5024++#line 2734 "parser.c"
5025++break;
5026++case 110:
5027 +#line 588 "parser.y"
5028-+ { (yyval.num) = 0; }
5029-+#line 2545 "parser.c"
5030-+ break;
5031-+
5032-+ case 113: /* FieldSpec: Ident */
5033++ { yyval.num = 0; }
5034++#line 2739 "parser.c"
5035++break;
5036++case 111:
5037 +#line 591 "parser.y"
5038-+ { (yyval.atom) = (yyvsp[0].atom); }
5039-+#line 2551 "parser.c"
5040-+ break;
5041-+
5042-+ case 114: /* FieldSpec: Element */
5043++ { yyval.atom = yystack.l_mark[0].atom; }
5044++#line 2744 "parser.c"
5045++break;
5046++case 112:
5047 +#line 592 "parser.y"
5048-+ { (yyval.atom) = (yyvsp[0].atom); }
5049-+#line 2557 "parser.c"
5050-+ break;
5051-+
5052-+ case 115: /* Element: ACTION_TOK */
5053++ { yyval.atom = yystack.l_mark[0].atom; }
5054++#line 2749 "parser.c"
5055++break;
5056++case 113:
5057 +#line 596 "parser.y"
5058-+ { (yyval.atom) = xkb_atom_intern_literal(param->ctx, "action"); }
5059-+#line 2563 "parser.c"
5060-+ break;
5061-+
5062-+ case 116: /* Element: INTERPRET */
5063++ { yyval.atom = xkb_atom_intern_literal(param->ctx, "action"); }
5064++#line 2754 "parser.c"
5065++break;
5066++case 114:
5067 +#line 598 "parser.y"
5068-+ { (yyval.atom) = xkb_atom_intern_literal(param->ctx, "interpret"); }
5069-+#line 2569 "parser.c"
5070-+ break;
5071-+
5072-+ case 117: /* Element: TYPE */
5073++ { yyval.atom = xkb_atom_intern_literal(param->ctx, "interpret"); }
5074++#line 2759 "parser.c"
5075++break;
5076++case 115:
5077 +#line 600 "parser.y"
5078-+ { (yyval.atom) = xkb_atom_intern_literal(param->ctx, "type"); }
5079-+#line 2575 "parser.c"
5080-+ break;
5081-+
5082-+ case 118: /* Element: KEY */
5083++ { yyval.atom = xkb_atom_intern_literal(param->ctx, "type"); }
5084++#line 2764 "parser.c"
5085++break;
5086++case 116:
5087 +#line 602 "parser.y"
5088-+ { (yyval.atom) = xkb_atom_intern_literal(param->ctx, "key"); }
5089-+#line 2581 "parser.c"
5090-+ break;
5091-+
5092-+ case 119: /* Element: GROUP */
5093++ { yyval.atom = xkb_atom_intern_literal(param->ctx, "key"); }
5094++#line 2769 "parser.c"
5095++break;
5096++case 117:
5097 +#line 604 "parser.y"
5098-+ { (yyval.atom) = xkb_atom_intern_literal(param->ctx, "group"); }
5099-+#line 2587 "parser.c"
5100-+ break;
5101-+
5102-+ case 120: /* Element: MODIFIER_MAP */
5103++ { yyval.atom = xkb_atom_intern_literal(param->ctx, "group"); }
5104++#line 2774 "parser.c"
5105++break;
5106++case 118:
5107 +#line 606 "parser.y"
5108-+ {(yyval.atom) = xkb_atom_intern_literal(param->ctx, "modifier_map");}
5109-+#line 2593 "parser.c"
5110-+ break;
5111-+
5112-+ case 121: /* Element: INDICATOR */
5113++ {yyval.atom = xkb_atom_intern_literal(param->ctx, "modifier_map");}
5114++#line 2779 "parser.c"
5115++break;
5116++case 119:
5117 +#line 608 "parser.y"
5118-+ { (yyval.atom) = xkb_atom_intern_literal(param->ctx, "indicator"); }
5119-+#line 2599 "parser.c"
5120-+ break;
5121-+
5122-+ case 122: /* Element: SHAPE */
5123++ { yyval.atom = xkb_atom_intern_literal(param->ctx, "indicator"); }
5124++#line 2784 "parser.c"
5125++break;
5126++case 120:
5127 +#line 610 "parser.y"
5128-+ { (yyval.atom) = xkb_atom_intern_literal(param->ctx, "shape"); }
5129-+#line 2605 "parser.c"
5130-+ break;
5131-+
5132-+ case 123: /* Element: ROW */
5133++ { yyval.atom = xkb_atom_intern_literal(param->ctx, "shape"); }
5134++#line 2789 "parser.c"
5135++break;
5136++case 121:
5137 +#line 612 "parser.y"
5138-+ { (yyval.atom) = xkb_atom_intern_literal(param->ctx, "row"); }
5139-+#line 2611 "parser.c"
5140-+ break;
5141-+
5142-+ case 124: /* Element: SECTION */
5143++ { yyval.atom = xkb_atom_intern_literal(param->ctx, "row"); }
5144++#line 2794 "parser.c"
5145++break;
5146++case 122:
5147 +#line 614 "parser.y"
5148-+ { (yyval.atom) = xkb_atom_intern_literal(param->ctx, "section"); }
5149-+#line 2617 "parser.c"
5150-+ break;
5151-+
5152-+ case 125: /* Element: TEXT */
5153++ { yyval.atom = xkb_atom_intern_literal(param->ctx, "section"); }
5154++#line 2799 "parser.c"
5155++break;
5156++case 123:
5157 +#line 616 "parser.y"
5158-+ { (yyval.atom) = xkb_atom_intern_literal(param->ctx, "text"); }
5159-+#line 2623 "parser.c"
5160-+ break;
5161-+
5162-+ case 126: /* OptMergeMode: MergeMode */
5163++ { yyval.atom = xkb_atom_intern_literal(param->ctx, "text"); }
5164++#line 2804 "parser.c"
5165++break;
5166++case 124:
5167 +#line 619 "parser.y"
5168-+ { (yyval.merge) = (yyvsp[0].merge); }
5169-+#line 2629 "parser.c"
5170-+ break;
5171-+
5172-+ case 127: /* OptMergeMode: %empty */
5173++ { yyval.merge = yystack.l_mark[0].merge; }
5174++#line 2809 "parser.c"
5175++break;
5176++case 125:
5177 +#line 620 "parser.y"
5178-+ { (yyval.merge) = MERGE_DEFAULT; }
5179-+#line 2635 "parser.c"
5180-+ break;
5181-+
5182-+ case 128: /* MergeMode: INCLUDE */
5183++ { yyval.merge = MERGE_DEFAULT; }
5184++#line 2814 "parser.c"
5185++break;
5186++case 126:
5187 +#line 623 "parser.y"
5188-+ { (yyval.merge) = MERGE_DEFAULT; }
5189-+#line 2641 "parser.c"
5190-+ break;
5191-+
5192-+ case 129: /* MergeMode: AUGMENT */
5193++ { yyval.merge = MERGE_DEFAULT; }
5194++#line 2819 "parser.c"
5195++break;
5196++case 127:
5197 +#line 624 "parser.y"
5198-+ { (yyval.merge) = MERGE_AUGMENT; }
5199-+#line 2647 "parser.c"
5200-+ break;
5201-+
5202-+ case 130: /* MergeMode: OVERRIDE */
5203++ { yyval.merge = MERGE_AUGMENT; }
5204++#line 2824 "parser.c"
5205++break;
5206++case 128:
5207 +#line 625 "parser.y"
5208-+ { (yyval.merge) = MERGE_OVERRIDE; }
5209-+#line 2653 "parser.c"
5210-+ break;
5211-+
5212-+ case 131: /* MergeMode: REPLACE */
5213++ { yyval.merge = MERGE_OVERRIDE; }
5214++#line 2829 "parser.c"
5215++break;
5216++case 129:
5217 +#line 626 "parser.y"
5218-+ { (yyval.merge) = MERGE_REPLACE; }
5219-+#line 2659 "parser.c"
5220-+ break;
5221-+
5222-+ case 132: /* MergeMode: ALTERNATE */
5223++ { yyval.merge = MERGE_REPLACE; }
5224++#line 2834 "parser.c"
5225++break;
5226++case 130:
5227 +#line 628 "parser.y"
5228-+ {
5229++ {
5230 + /*
5231 + * This used to be MERGE_ALT_FORM. This functionality was
5232 + * unused and has been removed.
5233 + */
5234-+ (yyval.merge) = MERGE_DEFAULT;
5235++ yyval.merge = MERGE_DEFAULT;
5236 + }
5237-+#line 2671 "parser.c"
5238-+ break;
5239-+
5240-+ case 133: /* OptExprList: ExprList */
5241++#line 2845 "parser.c"
5242++break;
5243++case 131:
5244 +#line 637 "parser.y"
5245-+ { (yyval.exprList) = (yyvsp[0].exprList); }
5246-+#line 2677 "parser.c"
5247-+ break;
5248-+
5249-+ case 134: /* OptExprList: %empty */
5250++ { yyval.exprList = yystack.l_mark[0].exprList; }
5251++#line 2850 "parser.c"
5252++break;
5253++case 132:
5254 +#line 638 "parser.y"
5255-+ { (yyval.exprList).head = (yyval.exprList).last = NULL; }
5256-+#line 2683 "parser.c"
5257-+ break;
5258-+
5259-+ case 135: /* ExprList: ExprList COMMA Expr */
5260++ { yyval.exprList.head = yyval.exprList.last = NULL; }
5261++#line 2855 "parser.c"
5262++break;
5263++case 133:
5264 +#line 642 "parser.y"
5265-+ { (yyval.exprList).head = (yyvsp[-2].exprList).head; (yyval.exprList).last->common.next = &(yyvsp[0].expr)->common; (yyval.exprList).last = (yyvsp[0].expr); }
5266-+#line 2689 "parser.c"
5267-+ break;
5268-+
5269-+ case 136: /* ExprList: Expr */
5270++ { 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; }
5271++#line 2860 "parser.c"
5272++break;
5273++case 134:
5274 +#line 644 "parser.y"
5275-+ { (yyval.exprList).head = (yyval.exprList).last = (yyvsp[0].expr); }
5276-+#line 2695 "parser.c"
5277-+ break;
5278-+
5279-+ case 137: /* Expr: Expr DIVIDE Expr */
5280++ { yyval.exprList.head = yyval.exprList.last = yystack.l_mark[0].expr; }
5281++#line 2865 "parser.c"
5282++break;
5283++case 135:
5284 +#line 648 "parser.y"
5285-+ { (yyval.expr) = ExprCreateBinary(EXPR_DIVIDE, (yyvsp[-2].expr), (yyvsp[0].expr)); }
5286-+#line 2701 "parser.c"
5287-+ break;
5288-+
5289-+ case 138: /* Expr: Expr PLUS Expr */
5290++ { yyval.expr = ExprCreateBinary(EXPR_DIVIDE, yystack.l_mark[-2].expr, yystack.l_mark[0].expr); }
5291++#line 2870 "parser.c"
5292++break;
5293++case 136:
5294 +#line 650 "parser.y"
5295-+ { (yyval.expr) = ExprCreateBinary(EXPR_ADD, (yyvsp[-2].expr), (yyvsp[0].expr)); }
5296-+#line 2707 "parser.c"
5297-+ break;
5298-+
5299-+ case 139: /* Expr: Expr MINUS Expr */
5300++ { yyval.expr = ExprCreateBinary(EXPR_ADD, yystack.l_mark[-2].expr, yystack.l_mark[0].expr); }
5301++#line 2875 "parser.c"
5302++break;
5303++case 137:
5304 +#line 652 "parser.y"
5305-+ { (yyval.expr) = ExprCreateBinary(EXPR_SUBTRACT, (yyvsp[-2].expr), (yyvsp[0].expr)); }
5306-+#line 2713 "parser.c"
5307-+ break;
5308-+
5309-+ case 140: /* Expr: Expr TIMES Expr */
5310++ { yyval.expr = ExprCreateBinary(EXPR_SUBTRACT, yystack.l_mark[-2].expr, yystack.l_mark[0].expr); }
5311++#line 2880 "parser.c"
5312++break;
5313++case 138:
5314 +#line 654 "parser.y"
5315-+ { (yyval.expr) = ExprCreateBinary(EXPR_MULTIPLY, (yyvsp[-2].expr), (yyvsp[0].expr)); }
5316-+#line 2719 "parser.c"
5317-+ break;
5318-+
5319-+ case 141: /* Expr: Lhs EQUALS Expr */
5320++ { yyval.expr = ExprCreateBinary(EXPR_MULTIPLY, yystack.l_mark[-2].expr, yystack.l_mark[0].expr); }
5321++#line 2885 "parser.c"
5322++break;
5323++case 139:
5324 +#line 656 "parser.y"
5325-+ { (yyval.expr) = ExprCreateBinary(EXPR_ASSIGN, (yyvsp[-2].expr), (yyvsp[0].expr)); }
5326-+#line 2725 "parser.c"
5327-+ break;
5328-+
5329-+ case 142: /* Expr: Term */
5330++ { yyval.expr = ExprCreateBinary(EXPR_ASSIGN, yystack.l_mark[-2].expr, yystack.l_mark[0].expr); }
5331++#line 2890 "parser.c"
5332++break;
5333++case 140:
5334 +#line 658 "parser.y"
5335-+ { (yyval.expr) = (yyvsp[0].expr); }
5336-+#line 2731 "parser.c"
5337-+ break;
5338-+
5339-+ case 143: /* Term: MINUS Term */
5340++ { yyval.expr = yystack.l_mark[0].expr; }
5341++#line 2895 "parser.c"
5342++break;
5343++case 141:
5344 +#line 662 "parser.y"
5345-+ { (yyval.expr) = ExprCreateUnary(EXPR_NEGATE, (yyvsp[0].expr)->expr.value_type, (yyvsp[0].expr)); }
5346-+#line 2737 "parser.c"
5347-+ break;
5348-+
5349-+ case 144: /* Term: PLUS Term */
5350++ { yyval.expr = ExprCreateUnary(EXPR_NEGATE, yystack.l_mark[0].expr->expr.value_type, yystack.l_mark[0].expr); }
5351++#line 2900 "parser.c"
5352++break;
5353++case 142:
5354 +#line 664 "parser.y"
5355-+ { (yyval.expr) = ExprCreateUnary(EXPR_UNARY_PLUS, (yyvsp[0].expr)->expr.value_type, (yyvsp[0].expr)); }
5356-+#line 2743 "parser.c"
5357-+ break;
5358-+
5359-+ case 145: /* Term: EXCLAM Term */
5360++ { yyval.expr = ExprCreateUnary(EXPR_UNARY_PLUS, yystack.l_mark[0].expr->expr.value_type, yystack.l_mark[0].expr); }
5361++#line 2905 "parser.c"
5362++break;
5363++case 143:
5364 +#line 666 "parser.y"
5365-+ { (yyval.expr) = ExprCreateUnary(EXPR_NOT, EXPR_TYPE_BOOLEAN, (yyvsp[0].expr)); }
5366-+#line 2749 "parser.c"
5367-+ break;
5368-+
5369-+ case 146: /* Term: INVERT Term */
5370++ { yyval.expr = ExprCreateUnary(EXPR_NOT, EXPR_TYPE_BOOLEAN, yystack.l_mark[0].expr); }
5371++#line 2910 "parser.c"
5372++break;
5373++case 144:
5374 +#line 668 "parser.y"
5375-+ { (yyval.expr) = ExprCreateUnary(EXPR_INVERT, (yyvsp[0].expr)->expr.value_type, (yyvsp[0].expr)); }
5376-+#line 2755 "parser.c"
5377-+ break;
5378-+
5379-+ case 147: /* Term: Lhs */
5380++ { yyval.expr = ExprCreateUnary(EXPR_INVERT, yystack.l_mark[0].expr->expr.value_type, yystack.l_mark[0].expr); }
5381++#line 2915 "parser.c"
5382++break;
5383++case 145:
5384 +#line 670 "parser.y"
5385-+ { (yyval.expr) = (yyvsp[0].expr); }
5386-+#line 2761 "parser.c"
5387-+ break;
5388-+
5389-+ case 148: /* Term: FieldSpec OPAREN OptExprList CPAREN */
5390++ { yyval.expr = yystack.l_mark[0].expr; }
5391++#line 2920 "parser.c"
5392++break;
5393++case 146:
5394 +#line 672 "parser.y"
5395-+ { (yyval.expr) = ExprCreateAction((yyvsp[-3].atom), (yyvsp[-1].exprList).head); }
5396-+#line 2767 "parser.c"
5397-+ break;
5398-+
5399-+ case 149: /* Term: Terminal */
5400++ { yyval.expr = ExprCreateAction(yystack.l_mark[-3].atom, yystack.l_mark[-1].exprList.head); }
5401++#line 2925 "parser.c"
5402++break;
5403++case 147:
5404 +#line 674 "parser.y"
5405-+ { (yyval.expr) = (yyvsp[0].expr); }
5406-+#line 2773 "parser.c"
5407-+ break;
5408-+
5409-+ case 150: /* Term: OPAREN Expr CPAREN */
5410++ { yyval.expr = yystack.l_mark[0].expr; }
5411++#line 2930 "parser.c"
5412++break;
5413++case 148:
5414 +#line 676 "parser.y"
5415-+ { (yyval.expr) = (yyvsp[-1].expr); }
5416-+#line 2779 "parser.c"
5417-+ break;
5418-+
5419-+ case 151: /* ActionList: ActionList COMMA Action */
5420++ { yyval.expr = yystack.l_mark[-1].expr; }
5421++#line 2935 "parser.c"
5422++break;
5423++case 149:
5424 +#line 680 "parser.y"
5425-+ { (yyval.exprList).head = (yyvsp[-2].exprList).head; (yyval.exprList).last->common.next = &(yyvsp[0].expr)->common; (yyval.exprList).last = (yyvsp[0].expr); }
5426-+#line 2785 "parser.c"
5427-+ break;
5428-+
5429-+ case 152: /* ActionList: Action */
5430++ { 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; }
5431++#line 2940 "parser.c"
5432++break;
5433++case 150:
5434 +#line 682 "parser.y"
5435-+ { (yyval.exprList).head = (yyval.exprList).last = (yyvsp[0].expr); }
5436-+#line 2791 "parser.c"
5437-+ break;
5438-+
5439-+ case 153: /* Action: FieldSpec OPAREN OptExprList CPAREN */
5440++ { yyval.exprList.head = yyval.exprList.last = yystack.l_mark[0].expr; }
5441++#line 2945 "parser.c"
5442++break;
5443++case 151:
5444 +#line 686 "parser.y"
5445-+ { (yyval.expr) = ExprCreateAction((yyvsp[-3].atom), (yyvsp[-1].exprList).head); }
5446-+#line 2797 "parser.c"
5447-+ break;
5448-+
5449-+ case 154: /* Lhs: FieldSpec */
5450++ { yyval.expr = ExprCreateAction(yystack.l_mark[-3].atom, yystack.l_mark[-1].exprList.head); }
5451++#line 2950 "parser.c"
5452++break;
5453++case 152:
5454 +#line 690 "parser.y"
5455-+ { (yyval.expr) = ExprCreateIdent((yyvsp[0].atom)); }
5456-+#line 2803 "parser.c"
5457-+ break;
5458-+
5459-+ case 155: /* Lhs: FieldSpec DOT FieldSpec */
5460++ { yyval.expr = ExprCreateIdent(yystack.l_mark[0].atom); }
5461++#line 2955 "parser.c"
5462++break;
5463++case 153:
5464 +#line 692 "parser.y"
5465-+ { (yyval.expr) = ExprCreateFieldRef((yyvsp[-2].atom), (yyvsp[0].atom)); }
5466-+#line 2809 "parser.c"
5467-+ break;
5468-+
5469-+ case 156: /* Lhs: FieldSpec OBRACKET Expr CBRACKET */
5470++ { yyval.expr = ExprCreateFieldRef(yystack.l_mark[-2].atom, yystack.l_mark[0].atom); }
5471++#line 2960 "parser.c"
5472++break;
5473++case 154:
5474 +#line 694 "parser.y"
5475-+ { (yyval.expr) = ExprCreateArrayRef(XKB_ATOM_NONE, (yyvsp[-3].atom), (yyvsp[-1].expr)); }
5476-+#line 2815 "parser.c"
5477-+ break;
5478-+
5479-+ case 157: /* Lhs: FieldSpec DOT FieldSpec OBRACKET Expr CBRACKET */
5480++ { yyval.expr = ExprCreateArrayRef(XKB_ATOM_NONE, yystack.l_mark[-3].atom, yystack.l_mark[-1].expr); }
5481++#line 2965 "parser.c"
5482++break;
5483++case 155:
5484 +#line 696 "parser.y"
5485-+ { (yyval.expr) = ExprCreateArrayRef((yyvsp[-5].atom), (yyvsp[-3].atom), (yyvsp[-1].expr)); }
5486-+#line 2821 "parser.c"
5487-+ break;
5488-+
5489-+ case 158: /* Terminal: String */
5490++ { yyval.expr = ExprCreateArrayRef(yystack.l_mark[-5].atom, yystack.l_mark[-3].atom, yystack.l_mark[-1].expr); }
5491++#line 2970 "parser.c"
5492++break;
5493++case 156:
5494 +#line 700 "parser.y"
5495-+ { (yyval.expr) = ExprCreateString((yyvsp[0].atom)); }
5496-+#line 2827 "parser.c"
5497-+ break;
5498-+
5499-+ case 159: /* Terminal: Integer */
5500++ { yyval.expr = ExprCreateString(yystack.l_mark[0].atom); }
5501++#line 2975 "parser.c"
5502++break;
5503++case 157:
5504 +#line 702 "parser.y"
5505-+ { (yyval.expr) = ExprCreateInteger((yyvsp[0].num)); }
5506-+#line 2833 "parser.c"
5507-+ break;
5508-+
5509-+ case 160: /* Terminal: Float */
5510++ { yyval.expr = ExprCreateInteger(yystack.l_mark[0].num); }
5511++#line 2980 "parser.c"
5512++break;
5513++case 158:
5514 +#line 704 "parser.y"
5515-+ { (yyval.expr) = ExprCreateFloat(/* Discard $1 */); }
5516-+#line 2839 "parser.c"
5517-+ break;
5518-+
5519-+ case 161: /* Terminal: KEYNAME */
5520++ { yyval.expr = ExprCreateFloat(/* Discard $1 */); }
5521++#line 2985 "parser.c"
5522++break;
5523++case 159:
5524 +#line 706 "parser.y"
5525-+ { (yyval.expr) = ExprCreateKeyName((yyvsp[0].atom)); }
5526-+#line 2845 "parser.c"
5527-+ break;
5528-+
5529-+ case 162: /* OptKeySymList: KeySymList */
5530++ { yyval.expr = ExprCreateKeyName(yystack.l_mark[0].atom); }
5531++#line 2990 "parser.c"
5532++break;
5533++case 160:
5534 +#line 709 "parser.y"
5535-+ { (yyval.expr) = (yyvsp[0].expr); }
5536-+#line 2851 "parser.c"
5537-+ break;
5538-+
5539-+ case 163: /* OptKeySymList: %empty */
5540++ { yyval.expr = yystack.l_mark[0].expr; }
5541++#line 2995 "parser.c"
5542++break;
5543++case 161:
5544 +#line 710 "parser.y"
5545-+ { (yyval.expr) = NULL; }
5546-+#line 2857 "parser.c"
5547-+ break;
5548-+
5549-+ case 164: /* KeySymList: KeySymList COMMA KeySym */
5550++ { yyval.expr = NULL; }
5551++#line 3000 "parser.c"
5552++break;
5553++case 162:
5554 +#line 714 "parser.y"
5555-+ { (yyval.expr) = ExprAppendKeysymList((yyvsp[-2].expr), (yyvsp[0].keysym)); }
5556-+#line 2863 "parser.c"
5557-+ break;
5558-+
5559-+ case 165: /* KeySymList: KeySymList COMMA KeySyms */
5560++ { yyval.expr = ExprAppendKeysymList(yystack.l_mark[-2].expr, yystack.l_mark[0].keysym); }
5561++#line 3005 "parser.c"
5562++break;
5563++case 163:
5564 +#line 716 "parser.y"
5565-+ { (yyval.expr) = ExprAppendMultiKeysymList((yyvsp[-2].expr), (yyvsp[0].expr)); }
5566-+#line 2869 "parser.c"
5567-+ break;
5568-+
5569-+ case 166: /* KeySymList: KeySym */
5570++ { yyval.expr = ExprAppendMultiKeysymList(yystack.l_mark[-2].expr, yystack.l_mark[0].expr); }
5571++#line 3010 "parser.c"
5572++break;
5573++case 164:
5574 +#line 718 "parser.y"
5575-+ { (yyval.expr) = ExprCreateKeysymList((yyvsp[0].keysym)); }
5576-+#line 2875 "parser.c"
5577-+ break;
5578-+
5579-+ case 167: /* KeySymList: KeySyms */
5580++ { yyval.expr = ExprCreateKeysymList(yystack.l_mark[0].keysym); }
5581++#line 3015 "parser.c"
5582++break;
5583++case 165:
5584 +#line 720 "parser.y"
5585-+ { (yyval.expr) = ExprCreateMultiKeysymList((yyvsp[0].expr)); }
5586-+#line 2881 "parser.c"
5587-+ break;
5588-+
5589-+ case 168: /* KeySyms: OBRACE KeySymList CBRACE */
5590++ { yyval.expr = ExprCreateMultiKeysymList(yystack.l_mark[0].expr); }
5591++#line 3020 "parser.c"
5592++break;
5593++case 166:
5594 +#line 724 "parser.y"
5595-+ { (yyval.expr) = (yyvsp[-1].expr); }
5596-+#line 2887 "parser.c"
5597-+ break;
5598-+
5599-+ case 169: /* KeySym: IDENT */
5600++ { yyval.expr = yystack.l_mark[-1].expr; }
5601++#line 3025 "parser.c"
5602++break;
5603++case 167:
5604 +#line 728 "parser.y"
5605-+ {
5606-+ if (!resolve_keysym((yyvsp[0].str), &(yyval.keysym))) {
5607-+ parser_warn(param, "unrecognized keysym \"%s\"", (yyvsp[0].str));
5608-+ (yyval.keysym) = XKB_KEY_NoSymbol;
5609++ {
5610++ if (!resolve_keysym(yystack.l_mark[0].str, &yyval.keysym)) {
5611++ parser_warn(
5612++ param,
5613++ XKB_WARNING_UNRECOGNIZED_KEYSYM,
5614++ "unrecognized keysym \"%s\"",
5615++ yystack.l_mark[0].str
5616++ );
5617++ yyval.keysym = XKB_KEY_NoSymbol;
5618 + }
5619-+ free((yyvsp[0].str));
5620++ free(yystack.l_mark[0].str);
5621 + }
5622-+#line 2899 "parser.c"
5623-+ break;
5624-+
5625-+ case 170: /* KeySym: SECTION */
5626-+#line 735 "parser.y"
5627-+ { (yyval.keysym) = XKB_KEY_section; }
5628-+#line 2905 "parser.c"
5629-+ break;
5630-+
5631-+ case 171: /* KeySym: Integer */
5632-+#line 737 "parser.y"
5633-+ {
5634-+ if ((yyvsp[0].num) < 0) {
5635-+ parser_warn(param, "unrecognized keysym \"%"PRId64"\"", (yyvsp[0].num));
5636-+ (yyval.keysym) = XKB_KEY_NoSymbol;
5637++#line 3041 "parser.c"
5638++break;
5639++case 168:
5640++#line 740 "parser.y"
5641++ { yyval.keysym = XKB_KEY_section; }
5642++#line 3046 "parser.c"
5643++break;
5644++case 169:
5645++#line 742 "parser.y"
5646++ {
5647++ if (yystack.l_mark[0].num < XKB_KEYSYM_MIN) {
5648++ parser_warn(
5649++ param,
5650++ XKB_WARNING_UNRECOGNIZED_KEYSYM,
5651++ "unrecognized keysym \"%"PRId64"\"",
5652++ yystack.l_mark[0].num
5653++ );
5654++ yyval.keysym = XKB_KEY_NoSymbol;
5655 + }
5656-+ else if ((yyvsp[0].num) < 10) { /* XKB_KEY_0 .. XKB_KEY_9 */
5657-+ (yyval.keysym) = XKB_KEY_0 + (xkb_keysym_t) (yyvsp[0].num);
5658++ /* Special case for digits 0..9 */
5659++ else if (yystack.l_mark[0].num < 10) { /* XKB_KEY_0 .. XKB_KEY_9 */
5660++ yyval.keysym = XKB_KEY_0 + (xkb_keysym_t) yystack.l_mark[0].num;
5661 + }
5662 + else {
5663-+ char buf[32];
5664-+ snprintf(buf, sizeof(buf), "0x%"PRIx64, (yyvsp[0].num));
5665-+ if (!resolve_keysym(buf, &(yyval.keysym))) {
5666-+ parser_warn(param, "unrecognized keysym \"%s\"", buf);
5667-+ (yyval.keysym) = XKB_KEY_NoSymbol;
5668++ if (yystack.l_mark[0].num <= XKB_KEYSYM_MAX) {
5669++ yyval.keysym = (xkb_keysym_t) yystack.l_mark[0].num;
5670++ } else {
5671++ parser_warn(
5672++ param, XKB_WARNING_UNRECOGNIZED_KEYSYM,
5673++ "unrecognized keysym \"0x%"PRIx64"\" "
5674++ "(%"PRId64")", yystack.l_mark[0].num, yystack.l_mark[0].num
5675++ );
5676++ yyval.keysym = XKB_KEY_NoSymbol;
5677 + }
5678++ parser_warn(
5679++ param, XKB_WARNING_NUMERIC_KEYSYM,
5680++ "numeric keysym \"0x%"PRIx64"\" (%"PRId64")",
5681++ yystack.l_mark[0].num, yystack.l_mark[0].num
5682++ );
5683 + }
5684 + }
5685-+#line 2927 "parser.c"
5686-+ break;
5687-+
5688-+ case 172: /* SignedNumber: MINUS Number */
5689-+#line 756 "parser.y"
5690-+ { (yyval.num) = -(yyvsp[0].num); }
5691-+#line 2933 "parser.c"
5692-+ break;
5693-+
5694-+ case 173: /* SignedNumber: Number */
5695-+#line 757 "parser.y"
5696-+ { (yyval.num) = (yyvsp[0].num); }
5697-+#line 2939 "parser.c"
5698-+ break;
5699-+
5700-+ case 174: /* Number: FLOAT */
5701-+#line 760 "parser.y"
5702-+ { (yyval.num) = (yyvsp[0].num); }
5703-+#line 2945 "parser.c"
5704-+ break;
5705-+
5706-+ case 175: /* Number: INTEGER */
5707-+#line 761 "parser.y"
5708-+ { (yyval.num) = (yyvsp[0].num); }
5709-+#line 2951 "parser.c"
5710-+ break;
5711-+
5712-+ case 176: /* Float: FLOAT */
5713-+#line 764 "parser.y"
5714-+ { (yyval.num) = 0; }
5715-+#line 2957 "parser.c"
5716-+ break;
5717-+
5718-+ case 177: /* Integer: INTEGER */
5719-+#line 767 "parser.y"
5720-+ { (yyval.num) = (yyvsp[0].num); }
5721-+#line 2963 "parser.c"
5722-+ break;
5723-+
5724-+ case 178: /* KeyCode: INTEGER */
5725-+#line 770 "parser.y"
5726-+ { (yyval.num) = (yyvsp[0].num); }
5727-+#line 2969 "parser.c"
5728-+ break;
5729-+
5730-+ case 179: /* Ident: IDENT */
5731-+#line 773 "parser.y"
5732-+ { (yyval.atom) = xkb_atom_intern(param->ctx, (yyvsp[0].str), strlen((yyvsp[0].str))); free((yyvsp[0].str)); }
5733-+#line 2975 "parser.c"
5734-+ break;
5735-+
5736-+ case 180: /* Ident: DEFAULT */
5737-+#line 774 "parser.y"
5738-+ { (yyval.atom) = xkb_atom_intern_literal(param->ctx, "default"); }
5739-+#line 2981 "parser.c"
5740-+ break;
5741-+
5742-+ case 181: /* String: STRING */
5743++#line 3082 "parser.c"
5744++break;
5745++case 170:
5746++#line 776 "parser.y"
5747++ { yyval.num = -yystack.l_mark[0].num; }
5748++#line 3087 "parser.c"
5749++break;
5750++case 171:
5751 +#line 777 "parser.y"
5752-+ { (yyval.atom) = xkb_atom_intern(param->ctx, (yyvsp[0].str), strlen((yyvsp[0].str))); free((yyvsp[0].str)); }
5753-+#line 2987 "parser.c"
5754-+ break;
5755-+
5756-+ case 182: /* OptMapName: MapName */
5757++ { yyval.num = yystack.l_mark[0].num; }
5758++#line 3092 "parser.c"
5759++break;
5760++case 172:
5761 +#line 780 "parser.y"
5762-+ { (yyval.str) = (yyvsp[0].str); }
5763-+#line 2993 "parser.c"
5764-+ break;
5765-+
5766-+ case 183: /* OptMapName: %empty */
5767++ { yyval.num = yystack.l_mark[0].num; }
5768++#line 3097 "parser.c"
5769++break;
5770++case 173:
5771 +#line 781 "parser.y"
5772-+ { (yyval.str) = NULL; }
5773-+#line 2999 "parser.c"
5774-+ break;
5775-+
5776-+ case 184: /* MapName: STRING */
5777++ { yyval.num = yystack.l_mark[0].num; }
5778++#line 3102 "parser.c"
5779++break;
5780++case 174:
5781 +#line 784 "parser.y"
5782-+ { (yyval.str) = (yyvsp[0].str); }
5783-+#line 3005 "parser.c"
5784-+ break;
5785-+
5786-+
5787-+#line 3009 "parser.c"
5788-+
5789-+ default: break;
5790-+ }
5791-+ /* User semantic actions sometimes alter yychar, and that requires
5792-+ that yytoken be updated with the new translation. We take the
5793-+ approach of translating immediately before every use of yytoken.
5794-+ One alternative is translating here after every semantic action,
5795-+ but that translation would be missed if the semantic action invokes
5796-+ YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
5797-+ if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
5798-+ incorrect destructor might then be invoked immediately. In the
5799-+ case of YYERROR or YYBACKUP, subsequent parser actions might lead
5800-+ to an incorrect destructor call or verbose syntax error message
5801-+ before the lookahead is translated. */
5802-+ YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc);
5803-+
5804-+ YYPOPSTACK (yylen);
5805-+ yylen = 0;
5806-+
5807-+ *++yyvsp = yyval;
5808-+
5809-+ /* Now 'shift' the result of the reduction. Determine what state
5810-+ that goes to, based on the state we popped back to and the rule
5811-+ number reduced by. */
5812-+ {
5813-+ const int yylhs = yyr1[yyn] - YYNTOKENS;
5814-+ const int yyi = yypgoto[yylhs] + *yyssp;
5815-+ yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
5816-+ ? yytable[yyi]
5817-+ : yydefgoto[yylhs]);
5818-+ }
5819-+
5820-+ goto yynewstate;
5821-+
5822-+
5823-+/*--------------------------------------.
5824-+| yyerrlab -- here on detecting error. |
5825-+`--------------------------------------*/
5826-+yyerrlab:
5827-+ /* Make sure we have latest lookahead translation. See comments at
5828-+ user semantic actions for why this is necessary. */
5829-+ yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar);
5830-+ /* If not already recovering from an error, report this error. */
5831-+ if (!yyerrstatus)
5832-+ {
5833-+ ++yynerrs;
5834-+ yyerror (param, YY_("syntax error"));
5835++ { yyval.num = 0; }
5836++#line 3107 "parser.c"
5837++break;
5838++case 175:
5839++#line 787 "parser.y"
5840++ { yyval.num = yystack.l_mark[0].num; }
5841++#line 3112 "parser.c"
5842++break;
5843++case 176:
5844++#line 790 "parser.y"
5845++ { yyval.num = yystack.l_mark[0].num; }
5846++#line 3117 "parser.c"
5847++break;
5848++case 177:
5849++#line 793 "parser.y"
5850++ { yyval.atom = xkb_atom_intern(param->ctx, yystack.l_mark[0].str, strlen(yystack.l_mark[0].str)); free(yystack.l_mark[0].str); }
5851++#line 3122 "parser.c"
5852++break;
5853++case 178:
5854++#line 794 "parser.y"
5855++ { yyval.atom = xkb_atom_intern_literal(param->ctx, "default"); }
5856++#line 3127 "parser.c"
5857++break;
5858++case 179:
5859++#line 797 "parser.y"
5860++ { yyval.atom = xkb_atom_intern(param->ctx, yystack.l_mark[0].str, strlen(yystack.l_mark[0].str)); free(yystack.l_mark[0].str); }
5861++#line 3132 "parser.c"
5862++break;
5863++case 180:
5864++#line 800 "parser.y"
5865++ { yyval.str = yystack.l_mark[0].str; }
5866++#line 3137 "parser.c"
5867++break;
5868++case 181:
5869++#line 801 "parser.y"
5870++ { yyval.str = NULL; }
5871++#line 3142 "parser.c"
5872++break;
5873++case 182:
5874++#line 804 "parser.y"
5875++ { yyval.str = yystack.l_mark[0].str; }
5876++#line 3147 "parser.c"
5877++break;
5878++#line 3149 "parser.c"
5879++ default:
5880++ break;
5881 + }
5882-+
5883-+ if (yyerrstatus == 3)
5884++ yystack.s_mark -= yym;
5885++ yystate = *yystack.s_mark;
5886++ yystack.l_mark -= yym;
5887++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
5888++ yystack.p_mark -= yym;
5889++#endif
5890++ yym = yylhs[yyn];
5891++ if (yystate == 0 && yym == 0)
5892 + {
5893-+ /* If just tried and failed to reuse lookahead token after an
5894-+ error, discard it. */
5895-+
5896-+ if (yychar <= END_OF_FILE)
5897-+ {
5898-+ /* Return failure if at end of input. */
5899-+ if (yychar == END_OF_FILE)
5900-+ YYABORT;
5901-+ }
5902-+ else
5903++#if YYDEBUG
5904++ if (yydebug)
5905 + {
5906-+ yydestruct ("Error: discarding",
5907-+ yytoken, &yylval, param);
5908-+ yychar = YYEMPTY;
5909++ fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
5910++#ifdef YYSTYPE_TOSTRING
5911++#if YYBTYACC
5912++ if (!yytrial)
5913++#endif /* YYBTYACC */
5914++ fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
5915++#endif
5916++ fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
5917 + }
5918-+ }
5919-+
5920-+ /* Else will try to reuse lookahead token after shifting the error
5921-+ token. */
5922-+ goto yyerrlab1;
5923-+
5924-+
5925-+/*---------------------------------------------------.
5926-+| yyerrorlab -- error raised explicitly by YYERROR. |
5927-+`---------------------------------------------------*/
5928-+yyerrorlab:
5929-+ /* Pacify compilers when the user code never invokes YYERROR and the
5930-+ label yyerrorlab therefore never appears in user code. */
5931-+ if (0)
5932-+ YYERROR;
5933-+ ++yynerrs;
5934-+
5935-+ /* Do not reclaim the symbols of the rule whose action triggered
5936-+ this YYERROR. */
5937-+ YYPOPSTACK (yylen);
5938-+ yylen = 0;
5939-+ YY_STACK_PRINT (yyss, yyssp);
5940-+ yystate = *yyssp;
5941-+ goto yyerrlab1;
5942-+
5943-+
5944-+/*-------------------------------------------------------------.
5945-+| yyerrlab1 -- common code for both syntax error and YYERROR. |
5946-+`-------------------------------------------------------------*/
5947-+yyerrlab1:
5948-+ yyerrstatus = 3; /* Each real token shifted decrements this. */
5949-+
5950-+ /* Pop stack until we find a state that shifts the error token. */
5951-+ for (;;)
5952-+ {
5953-+ yyn = yypact[yystate];
5954-+ if (!yypact_value_is_default (yyn))
5955++#endif
5956++ yystate = YYFINAL;
5957++ *++yystack.s_mark = YYFINAL;
5958++ *++yystack.l_mark = yyval;
5959++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
5960++ *++yystack.p_mark = yyloc;
5961++#endif
5962++ if (yychar < 0)
5963 + {
5964-+ yyn += YYSYMBOL_YYerror;
5965-+ if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
5966++#if YYBTYACC
5967++ do {
5968++ if (yylvp < yylve)
5969++ {
5970++ /* we're currently re-reading tokens */
5971++ yylval = *yylvp++;
5972++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
5973++ yylloc = *yylpp++;
5974++#endif
5975++ yychar = *yylexp++;
5976++ break;
5977++ }
5978++ if (yyps->save)
5979 + {
5980-+ yyn = yytable[yyn];
5981-+ if (0 < yyn)
5982++ /* in trial mode; save scanner results for future parse attempts */
5983++ if (yylvp == yylvlim)
5984++ { /* Enlarge lexical value queue */
5985++ size_t p = (size_t) (yylvp - yylvals);
5986++ size_t s = (size_t) (yylvlim - yylvals);
5987++
5988++ s += YYLVQUEUEGROWTH;
5989++ if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL)
5990++ goto yyenomem;
5991++ if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
5992++ goto yyenomem;
5993++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
5994++ if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
5995++ goto yyenomem;
5996++#endif
5997++ yylvp = yylve = yylvals + p;
5998++ yylvlim = yylvals + s;
5999++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
6000++ yylpp = yylpe = yylpsns + p;
6001++ yylplim = yylpsns + s;
6002++#endif
6003++ yylexp = yylexemes + p;
6004++ }
6005++ *yylexp = (YYINT) YYLEX;
6006++ *yylvp++ = yylval;
6007++ yylve++;
6008++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
6009++ *yylpp++ = yylloc;
6010++ yylpe++;
6011++#endif
6012++ yychar = *yylexp++;
6013 + break;
6014 + }
6015++ /* normal operation, no conflict encountered */
6016++#endif /* YYBTYACC */
6017++ yychar = YYLEX;
6018++#if YYBTYACC
6019++ } while (0);
6020++#endif /* YYBTYACC */
6021++ if (yychar < 0) yychar = YYEOF;
6022++#if YYDEBUG
6023++ if (yydebug)
6024++ {
6025++ if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
6026++ fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
6027++ YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
6028++ }
6029++#endif
6030 + }
6031-+
6032-+ /* Pop the current state because it cannot handle the error token. */
6033-+ if (yyssp == yyss)
6034-+ YYABORT;
6035-+
6036-+
6037-+ yydestruct ("Error: popping",
6038-+ YY_ACCESSING_SYMBOL (yystate), yyvsp, param);
6039-+ YYPOPSTACK (1);
6040-+ yystate = *yyssp;
6041-+ YY_STACK_PRINT (yyss, yyssp);
6042++ if (yychar == YYEOF) goto yyaccept;
6043++ goto yyloop;
6044 + }
6045++ if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
6046++ yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
6047++ yystate = yytable[yyn];
6048++ else
6049++ yystate = yydgoto[yym];
6050++#if YYDEBUG
6051++ if (yydebug)
6052++ {
6053++ fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
6054++#ifdef YYSTYPE_TOSTRING
6055++#if YYBTYACC
6056++ if (!yytrial)
6057++#endif /* YYBTYACC */
6058++ fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
6059++#endif
6060++ fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
6061++ }
6062++#endif
6063++ if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
6064++ *++yystack.s_mark = (YYINT) yystate;
6065++ *++yystack.l_mark = yyval;
6066++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
6067++ *++yystack.p_mark = yyloc;
6068++#endif
6069++ goto yyloop;
6070++#if YYBTYACC
6071 +
6072-+ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
6073-+ *++yyvsp = yylval;
6074-+ YY_IGNORE_MAYBE_UNINITIALIZED_END
6075-+
6076-+
6077-+ /* Shift the error token. */
6078-+ YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp);
6079-+
6080-+ yystate = yyn;
6081-+ goto yynewstate;
6082-+
6083-+
6084-+/*-------------------------------------.
6085-+| yyacceptlab -- YYACCEPT comes here. |
6086-+`-------------------------------------*/
6087-+yyacceptlab:
6088-+ yyresult = 0;
6089-+ goto yyreturnlab;
6090-+
6091-+
6092-+/*-----------------------------------.
6093-+| yyabortlab -- YYABORT comes here. |
6094-+`-----------------------------------*/
6095-+yyabortlab:
6096-+ yyresult = 1;
6097-+ goto yyreturnlab;
6098-+
6099-+
6100-+/*-----------------------------------------------------------.
6101-+| yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. |
6102-+`-----------------------------------------------------------*/
6103-+yyexhaustedlab:
6104-+ yyerror (param, YY_("memory exhausted"));
6105-+ yyresult = 2;
6106-+ goto yyreturnlab;
6107-+
6108-+
6109-+/*----------------------------------------------------------.
6110-+| yyreturnlab -- parsing is finished, clean up and return. |
6111-+`----------------------------------------------------------*/
6112-+yyreturnlab:
6113-+ if (yychar != YYEMPTY)
6114++ /* Reduction declares that this path is valid. Set yypath and do a full parse */
6115++yyvalid:
6116++ if (yypath) YYABORT;
6117++ while (yyps->save)
6118 + {
6119-+ /* Make sure we have latest lookahead translation. See comments at
6120-+ user semantic actions for why this is necessary. */
6121-+ yytoken = YYTRANSLATE (yychar);
6122-+ yydestruct ("Cleanup: discarding lookahead",
6123-+ yytoken, &yylval, param);
6124++ YYParseState *save = yyps->save;
6125++ yyps->save = save->save;
6126++ save->save = yypath;
6127++ yypath = save;
6128 + }
6129-+ /* Do not reclaim the symbols of the rule whose action triggered
6130-+ this YYABORT or YYACCEPT. */
6131-+ YYPOPSTACK (yylen);
6132-+ YY_STACK_PRINT (yyss, yyssp);
6133-+ while (yyssp != yyss)
6134++#if YYDEBUG
6135++ if (yydebug)
6136++ fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
6137++ YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
6138++#endif
6139++ if (yyerrctx)
6140 + {
6141-+ yydestruct ("Cleanup: popping",
6142-+ YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, param);
6143-+ YYPOPSTACK (1);
6144++ yyFreeState(yyerrctx);
6145++ yyerrctx = NULL;
6146 + }
6147-+#ifndef yyoverflow
6148-+ if (yyss != yyssa)
6149-+ YYSTACK_FREE (yyss);
6150++ yylvp = yylvals + yypath->lexeme;
6151++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
6152++ yylpp = yylpsns + yypath->lexeme;
6153 +#endif
6154++ yylexp = yylexemes + yypath->lexeme;
6155++ yychar = YYEMPTY;
6156++ yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
6157++ memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
6158++ yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
6159++ memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
6160++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
6161++ yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
6162++ memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
6163++#endif
6164++ yystate = yypath->state;
6165++ goto yyloop;
6166++#endif /* YYBTYACC */
6167++
6168++yyoverflow:
6169++ YYERROR_CALL("yacc stack overflow");
6170++#if YYBTYACC
6171++ goto yyabort_nomem;
6172++yyenomem:
6173++ YYERROR_CALL("memory exhausted");
6174++yyabort_nomem:
6175++#endif /* YYBTYACC */
6176++ yyresult = 2;
6177++ goto yyreturn;
6178++
6179++yyabort:
6180++ yyresult = 1;
6181++ goto yyreturn;
6182++
6183++yyaccept:
6184++#if YYBTYACC
6185++ if (yyps->save) goto yyvalid;
6186++#endif /* YYBTYACC */
6187++ yyresult = 0;
6188++
6189++yyreturn:
6190++#if defined(YYDESTRUCT_CALL)
6191++ if (yychar != YYEOF && yychar != YYEMPTY)
6192++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
6193++ YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
6194++#else
6195++ YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
6196++#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
6197 +
6198-+ return yyresult;
6199-+}
6200-+
6201-+#line 787 "parser.y"
6202-+
6203-+
6204-+XkbFile *
6205-+parse(struct xkb_context *ctx, struct scanner *scanner, const char *map)
6206-+{
6207-+ int ret;
6208-+ XkbFile *first = NULL;
6209-+ struct parser_param param = {
6210-+ .scanner = scanner,
6211-+ .ctx = ctx,
6212-+ .rtrn = NULL,
6213-+ .more_maps = false,
6214-+ };
6215-+
6216-+ /*
6217-+ * If we got a specific map, we look for it exclusively and return
6218-+ * immediately upon finding it. Otherwise, we need to get the
6219-+ * default map. If we find a map marked as default, we return it
6220-+ * immediately. If there are no maps marked as default, we return
6221-+ * the first map in the file.
6222-+ */
6223++ {
6224++ YYSTYPE *pv;
6225++#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
6226++ YYLTYPE *pp;
6227 +
6228-+ while ((ret = yyparse(¶m)) == 0 && param.more_maps) {
6229-+ if (map) {
6230-+ if (streq_not_null(map, param.rtrn->name))
6231-+ return param.rtrn;
6232-+ else
6233-+ FreeXkbFile(param.rtrn);
6234-+ }
6235-+ else {
6236-+ if (param.rtrn->flags & MAP_IS_DEFAULT) {
6237-+ FreeXkbFile(first);
6238-+ return param.rtrn;
6239-+ }
6240-+ else if (!first) {
6241-+ first = param.rtrn;
6242-+ }
6243-+ else {
6244-+ FreeXkbFile(param.rtrn);
6245-+ }
6246-+ }
6247-+ param.rtrn = NULL;
6248++ for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
6249++ YYDESTRUCT_CALL("cleanup: discarding state",
6250++ yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
6251++#else
6252++ for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
6253++ YYDESTRUCT_CALL("cleanup: discarding state",
6254++ yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
6255++#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
6256 + }
6257++#endif /* defined(YYDESTRUCT_CALL) */
6258 +
6259-+ if (ret != 0) {
6260-+ FreeXkbFile(first);
6261-+ return NULL;
6262++#if YYBTYACC
6263++ if (yyerrctx)
6264++ {
6265++ yyFreeState(yyerrctx);
6266++ yyerrctx = NULL;
6267 + }
6268-+
6269-+ if (first)
6270-+ log_vrb(ctx, 5,
6271-+ "No map in include statement, but \"%s\" contains several; "
6272-+ "Using first defined map, \"%s\"\n",
6273-+ scanner->file_name, first->name);
6274-+
6275-+ return first;
6276++ while (yyps)
6277++ {
6278++ YYParseState *save = yyps;
6279++ yyps = save->save;
6280++ save->save = NULL;
6281++ yyFreeState(save);
6282++ }
6283++ while (yypath)
6284++ {
6285++ YYParseState *save = yypath;
6286++ yypath = save->save;
6287++ save->save = NULL;
6288++ yyFreeState(save);
6289++ }
6290++#endif /* YYBTYACC */
6291++ yyfreestack(&yystack);
6292++ return (yyresult);
6293 +}
6294 diff --git a/src/xkbcomp/parser.h b/src/xkbcomp/parser.h
6295 new file mode 100644
6296-index 0000000..f788bdc
6297+index 0000000..86f7a92
6298 --- /dev/null
6299 +++ b/src/xkbcomp/parser.h
6300-@@ -0,0 +1,171 @@
6301-+/* A Bison parser, made by GNU Bison 3.8.2. */
6302-+
6303-+/* Bison interface for Yacc-like parsers in C
6304-+
6305-+ Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation,
6306-+ Inc.
6307-+
6308-+ This program is free software: you can redistribute it and/or modify
6309-+ it under the terms of the GNU General Public License as published by
6310-+ the Free Software Foundation, either version 3 of the License, or
6311-+ (at your option) any later version.
6312-+
6313-+ This program is distributed in the hope that it will be useful,
6314-+ but WITHOUT ANY WARRANTY; without even the implied warranty of
6315-+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
6316-+ GNU General Public License for more details.
6317-+
6318-+ You should have received a copy of the GNU General Public License
6319-+ along with this program. If not, see <https://www.gnu.org/licenses/>. */
6320-+
6321-+/* As a special exception, you may create a larger work that contains
6322-+ part or all of the Bison parser skeleton and distribute that work
6323-+ under terms of your choice, so long as that work isn't itself a
6324-+ parser generator using the skeleton or a modified version thereof
6325-+ as a parser skeleton. Alternatively, if you modify or redistribute
6326-+ the parser skeleton itself, you may (at your option) remove this
6327-+ special exception, which will cause the skeleton and the resulting
6328-+ Bison output files to be licensed under the GNU General Public
6329-+ License without this special exception.
6330-+
6331-+ This special exception was added by the Free Software Foundation in
6332-+ version 2.2 of Bison. */
6333-+
6334-+/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
6335-+ especially those whose name start with YY_ or yy_. They are
6336-+ private implementation details that can be changed or removed. */
6337-+
6338-+#ifndef YY__XKBCOMMON_PARSER_H_INCLUDED
6339-+# define YY__XKBCOMMON_PARSER_H_INCLUDED
6340-+/* Debug traces. */
6341-+#ifndef YYDEBUG
6342-+# define YYDEBUG 0
6343+@@ -0,0 +1,104 @@
6344++#ifndef __xkbcommon__defines_h_
6345++#define __xkbcommon__defines_h_
6346++
6347++#define END_OF_FILE 0
6348++#define ERROR_TOK 255
6349++#define XKB_KEYMAP 1
6350++#define XKB_KEYCODES 2
6351++#define XKB_TYPES 3
6352++#define XKB_SYMBOLS 4
6353++#define XKB_COMPATMAP 5
6354++#define XKB_GEOMETRY 6
6355++#define XKB_SEMANTICS 7
6356++#define XKB_LAYOUT 8
6357++#define INCLUDE 10
6358++#define OVERRIDE 11
6359++#define AUGMENT 12
6360++#define REPLACE 13
6361++#define ALTERNATE 14
6362++#define VIRTUAL_MODS 20
6363++#define TYPE 21
6364++#define INTERPRET 22
6365++#define ACTION_TOK 23
6366++#define KEY 24
6367++#define ALIAS 25
6368++#define GROUP 26
6369++#define MODIFIER_MAP 27
6370++#define INDICATOR 28
6371++#define SHAPE 29
6372++#define KEYS 30
6373++#define ROW 31
6374++#define SECTION 32
6375++#define OVERLAY 33
6376++#define TEXT 34
6377++#define OUTLINE 35
6378++#define SOLID 36
6379++#define LOGO 37
6380++#define VIRTUAL 38
6381++#define EQUALS 40
6382++#define PLUS 41
6383++#define MINUS 42
6384++#define DIVIDE 43
6385++#define TIMES 44
6386++#define OBRACE 45
6387++#define CBRACE 46
6388++#define OPAREN 47
6389++#define CPAREN 48
6390++#define OBRACKET 49
6391++#define CBRACKET 50
6392++#define DOT 51
6393++#define COMMA 52
6394++#define SEMI 53
6395++#define EXCLAM 54
6396++#define INVERT 55
6397++#define STRING 60
6398++#define INTEGER 61
6399++#define FLOAT 62
6400++#define IDENT 63
6401++#define KEYNAME 64
6402++#define PARTIAL 70
6403++#define DEFAULT 71
6404++#define HIDDEN 72
6405++#define ALPHANUMERIC_KEYS 73
6406++#define MODIFIER_KEYS 74
6407++#define KEYPAD_KEYS 75
6408++#define FUNCTION_KEYS 76
6409++#define ALTERNATE_GROUP 77
6410++#ifdef YYSTYPE
6411++#undef YYSTYPE_IS_DECLARED
6412++#define YYSTYPE_IS_DECLARED 1
6413 +#endif
6414-+#if YYDEBUG
6415-+extern int _xkbcommon_debug;
6416-+#endif
6417-+
6418-+/* Token kinds. */
6419-+#ifndef YYTOKENTYPE
6420-+# define YYTOKENTYPE
6421-+ enum yytokentype
6422-+ {
6423-+ YYEMPTY = -2,
6424-+ END_OF_FILE = 0, /* END_OF_FILE */
6425-+ YYerror = 256, /* error */
6426-+ YYUNDEF = 257, /* "invalid token" */
6427-+ ERROR_TOK = 255, /* ERROR_TOK */
6428-+ XKB_KEYMAP = 1, /* XKB_KEYMAP */
6429-+ XKB_KEYCODES = 2, /* XKB_KEYCODES */
6430-+ XKB_TYPES = 3, /* XKB_TYPES */
6431-+ XKB_SYMBOLS = 4, /* XKB_SYMBOLS */
6432-+ XKB_COMPATMAP = 5, /* XKB_COMPATMAP */
6433-+ XKB_GEOMETRY = 6, /* XKB_GEOMETRY */
6434-+ XKB_SEMANTICS = 7, /* XKB_SEMANTICS */
6435-+ XKB_LAYOUT = 8, /* XKB_LAYOUT */
6436-+ INCLUDE = 10, /* INCLUDE */
6437-+ OVERRIDE = 11, /* OVERRIDE */
6438-+ AUGMENT = 12, /* AUGMENT */
6439-+ REPLACE = 13, /* REPLACE */
6440-+ ALTERNATE = 14, /* ALTERNATE */
6441-+ VIRTUAL_MODS = 20, /* VIRTUAL_MODS */
6442-+ TYPE = 21, /* TYPE */
6443-+ INTERPRET = 22, /* INTERPRET */
6444-+ ACTION_TOK = 23, /* ACTION_TOK */
6445-+ KEY = 24, /* KEY */
6446-+ ALIAS = 25, /* ALIAS */
6447-+ GROUP = 26, /* GROUP */
6448-+ MODIFIER_MAP = 27, /* MODIFIER_MAP */
6449-+ INDICATOR = 28, /* INDICATOR */
6450-+ SHAPE = 29, /* SHAPE */
6451-+ KEYS = 30, /* KEYS */
6452-+ ROW = 31, /* ROW */
6453-+ SECTION = 32, /* SECTION */
6454-+ OVERLAY = 33, /* OVERLAY */
6455-+ TEXT = 34, /* TEXT */
6456-+ OUTLINE = 35, /* OUTLINE */
6457-+ SOLID = 36, /* SOLID */
6458-+ LOGO = 37, /* LOGO */
6459-+ VIRTUAL = 38, /* VIRTUAL */
6460-+ EQUALS = 40, /* EQUALS */
6461-+ PLUS = 41, /* PLUS */
6462-+ MINUS = 42, /* MINUS */
6463-+ DIVIDE = 43, /* DIVIDE */
6464-+ TIMES = 44, /* TIMES */
6465-+ OBRACE = 45, /* OBRACE */
6466-+ CBRACE = 46, /* CBRACE */
6467-+ OPAREN = 47, /* OPAREN */
6468-+ CPAREN = 48, /* CPAREN */
6469-+ OBRACKET = 49, /* OBRACKET */
6470-+ CBRACKET = 50, /* CBRACKET */
6471-+ DOT = 51, /* DOT */
6472-+ COMMA = 52, /* COMMA */
6473-+ SEMI = 53, /* SEMI */
6474-+ EXCLAM = 54, /* EXCLAM */
6475-+ INVERT = 55, /* INVERT */
6476-+ STRING = 60, /* STRING */
6477-+ INTEGER = 61, /* INTEGER */
6478-+ FLOAT = 62, /* FLOAT */
6479-+ IDENT = 63, /* IDENT */
6480-+ KEYNAME = 64, /* KEYNAME */
6481-+ PARTIAL = 70, /* PARTIAL */
6482-+ DEFAULT = 71, /* DEFAULT */
6483-+ HIDDEN = 72, /* HIDDEN */
6484-+ ALPHANUMERIC_KEYS = 73, /* ALPHANUMERIC_KEYS */
6485-+ MODIFIER_KEYS = 74, /* MODIFIER_KEYS */
6486-+ KEYPAD_KEYS = 75, /* KEYPAD_KEYS */
6487-+ FUNCTION_KEYS = 76, /* FUNCTION_KEYS */
6488-+ ALTERNATE_GROUP = 77 /* ALTERNATE_GROUP */
6489-+ };
6490-+ typedef enum yytokentype yytoken_kind_t;
6491-+#endif
6492-+
6493-+/* Value type. */
6494-+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
6495-+union YYSTYPE
6496-+{
6497-+#line 164 "parser.y"
6498-+
6499++#ifndef YYSTYPE_IS_DECLARED
6500++#define YYSTYPE_IS_DECLARED 1
6501++typedef union YYSTYPE {
6502 + int64_t num;
6503 + enum xkb_file_type file_type;
6504 + char *str;
6505@@ -3438,22 +3507,10 @@ index 0000000..f788bdc
6506 + void *geom;
6507 + XkbFile *file;
6508 + struct { XkbFile *head; XkbFile *last; } fileList;
6509++} YYSTYPE;
6510++#endif /* !YYSTYPE_IS_DECLARED */
6511 +
6512-+#line 158 "parser.h"
6513-+
6514-+};
6515-+typedef union YYSTYPE YYSTYPE;
6516-+# define YYSTYPE_IS_TRIVIAL 1
6517-+# define YYSTYPE_IS_DECLARED 1
6518-+#endif
6519-+
6520-+
6521-+
6522-+
6523-+int _xkbcommon_parse (struct parser_param *param);
6524-+
6525-+
6526-+#endif /* !YY__XKBCOMMON_PARSER_H_INCLUDED */
6527++#endif /* __xkbcommon__defines_h_ */
6528 --
6529-2.34.0
6530+2.45.1
6531
+1,
-1
1@@ -1 +1 @@
2-Subproject commit 88222c8d40543c29af781f7d7e25d202ff40e4b7
3+Subproject commit 7a31e3585edf78be281559377e26d15f8c4bc655
+1,
-1
1@@ -1 +1 @@
2-1.3.1 r0
3+1.7.0 r0