xkbparse.c

Bug Summary

File:	xkbparse.c
Location:	line 1584, column 5
Description:	Value stored to 'yymsg' is never read

Annotated Source Code

1	/* A Bison parser, made by GNU Bison 2.4.3. */
2
3	/* Skeleton implementation for Bison's Yacc-like parsers in C
4
5	Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
6	2009, 2010 Free Software Foundation, Inc.
7
8	This program is free software: you can redistribute it and/or modify
9	it under the terms of the GNU General Public License as published by
10	the Free Software Foundation, either version 3 of the License, or
11	(at your option) any later version.
12
13	This program is distributed in the hope that it will be useful,
14	but WITHOUT ANY WARRANTY; without even the implied warranty of
15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	GNU General Public License for more details.
17
18	You should have received a copy of the GNU General Public License
19	along with this program. If not, see <http://www.gnu.org/licenses/>. */
20
21	/* As a special exception, you may create a larger work that contains
22	part or all of the Bison parser skeleton and distribute that work
23	under terms of your choice, so long as that work isn't itself a
24	parser generator using the skeleton or a modified version thereof
25	as a parser skeleton. Alternatively, if you modify or redistribute
26	the parser skeleton itself, you may (at your option) remove this
27	special exception, which will cause the skeleton and the resulting
28	Bison output files to be licensed under the GNU General Public
29	License without this special exception.
30
31	This special exception was added by the Free Software Foundation in
32	version 2.2 of Bison. */
33
34	/* C LALR(1) parser skeleton written by Richard Stallman, by
35	simplifying the original so-called "semantic" parser. */
36
37	/* All symbols defined below should begin with yy or YY, to avoid
38	infringing on user name space. This should be done even for local
39	variables, as they might otherwise be expanded by user macros.
40	There are some unavoidable exceptions within include files to
41	define necessary library symbols; they are noted "INFRINGES ON
42	USER NAME SPACE" below. */
43
44	/* Identify Bison output. */
45	#define YYBISON1 1
46
47	/* Bison version. */
48	#define YYBISON_VERSION"2.4.3" "2.4.3"
49
50	/* Skeleton name. */
51	#define YYSKELETON_NAME"yacc.c" "yacc.c"
52
53	/* Pure parsers. */
54	#define YYPURE0 0
55
56	/* Push parsers. */
57	#define YYPUSH0 0
58
59	/* Pull parsers. */
60	#define YYPULL1 1
61
62	/* Using locations. */
63	#define YYLSP_NEEDED0 0
64
65
66
67	/* Copy the first part of user declarations. */
68
69	/* Line 189 of yacc.c */
70	#line 91 "xkbparse.y"
71
72	#ifdef DEBUG
73	#define YYDEBUG0 1
74	#endif
75	#define DEBUG_VARparseDebug parseDebug
76	#include "parseutils.h"
77	#include <X11/keysym.h>
78	#include <X11/extensions/XKBgeom.h>
79	#include <stdlib.h>
80
81	unsigned int parseDebug;
82
83
84
85	/* Line 189 of yacc.c */
86	#line 87 "xkbparse.c"
87
88	/* Enabling traces. */
89	#ifndef YYDEBUG0
90	# define YYDEBUG0 0
91	#endif
92
93	/* Enabling verbose error messages. */
94	#ifdef YYERROR_VERBOSE0
95	# undef YYERROR_VERBOSE0
96	# define YYERROR_VERBOSE0 1
97	#else
98	# define YYERROR_VERBOSE0 0
99	#endif
100
101	/* Enabling the token table. */
102	#ifndef YYTOKEN_TABLE0
103	# define YYTOKEN_TABLE0 0
104	#endif
105
106
107	/* Tokens. */
108	#ifndef YYTOKENTYPE
109	# define YYTOKENTYPE
110	/* Put the tokens into the symbol table, so that GDB and other debuggers
111	know about them. */
112	enum yytokentype {
113	END_OF_FILE0 = 0,
114	ERROR_TOK255 = 255,
115	XKB_KEYMAP1 = 1,
116	XKB_KEYCODES2 = 2,
117	XKB_TYPES3 = 3,
118	XKB_SYMBOLS4 = 4,
119	XKB_COMPATMAP5 = 5,
120	XKB_GEOMETRY6 = 6,
121	XKB_SEMANTICS7 = 7,
122	XKB_LAYOUT8 = 8,
123	INCLUDE10 = 10,
124	OVERRIDE11 = 11,
125	AUGMENT12 = 12,
126	REPLACE13 = 13,
127	ALTERNATE14 = 14,
128	VIRTUAL_MODS20 = 20,
129	TYPE21 = 21,
130	INTERPRET22 = 22,
131	ACTION_TOK23 = 23,
132	KEY24 = 24,
133	ALIAS25 = 25,
134	GROUP26 = 26,
135	MODIFIER_MAP27 = 27,
136	INDICATOR28 = 28,
137	SHAPE29 = 29,
138	KEYS30 = 30,
139	ROW31 = 31,
140	SECTION32 = 32,
141	OVERLAY33 = 33,
142	TEXT34 = 34,
143	OUTLINE35 = 35,
144	SOLID36 = 36,
145	LOGO37 = 37,
146	VIRTUAL38 = 38,
147	EQUALS40 = 40,
148	PLUS41 = 41,
149	MINUS42 = 42,
150	DIVIDE43 = 43,
151	TIMES44 = 44,
152	OBRACE45 = 45,
153	CBRACE46 = 46,
154	OPAREN47 = 47,
155	CPAREN48 = 48,
156	OBRACKET49 = 49,
157	CBRACKET50 = 50,
158	DOT51 = 51,
159	COMMA52 = 52,
160	SEMI53 = 53,
161	EXCLAM54 = 54,
162	INVERT55 = 55,
163	STRING60 = 60,
164	INTEGER61 = 61,
165	FLOAT62 = 62,
166	IDENT63 = 63,
167	KEYNAME64 = 64,
168	PARTIAL70 = 70,
169	DEFAULT71 = 71,
170	HIDDEN72 = 72,
171	ALPHANUMERIC_KEYS73 = 73,
172	MODIFIER_KEYS74 = 74,
173	KEYPAD_KEYS75 = 75,
174	FUNCTION_KEYS76 = 76,
175	ALTERNATE_GROUP77 = 77
176	};
177	#endif
178	/* Tokens. */
179	#define END_OF_FILE0 0
180	#define ERROR_TOK255 255
181	#define XKB_KEYMAP1 1
182	#define XKB_KEYCODES2 2
183	#define XKB_TYPES3 3
184	#define XKB_SYMBOLS4 4
185	#define XKB_COMPATMAP5 5
186	#define XKB_GEOMETRY6 6
187	#define XKB_SEMANTICS7 7
188	#define XKB_LAYOUT8 8
189	#define INCLUDE10 10
190	#define OVERRIDE11 11
191	#define AUGMENT12 12
192	#define REPLACE13 13
193	#define ALTERNATE14 14
194	#define VIRTUAL_MODS20 20
195	#define TYPE21 21
196	#define INTERPRET22 22
197	#define ACTION_TOK23 23
198	#define KEY24 24
199	#define ALIAS25 25
200	#define GROUP26 26
201	#define MODIFIER_MAP27 27
202	#define INDICATOR28 28
203	#define SHAPE29 29
204	#define KEYS30 30
205	#define ROW31 31
206	#define SECTION32 32
207	#define OVERLAY33 33
208	#define TEXT34 34
209	#define OUTLINE35 35
210	#define SOLID36 36
211	#define LOGO37 37
212	#define VIRTUAL38 38
213	#define EQUALS40 40
214	#define PLUS41 41
215	#define MINUS42 42
216	#define DIVIDE43 43
217	#define TIMES44 44
218	#define OBRACE45 45
219	#define CBRACE46 46
220	#define OPAREN47 47
221	#define CPAREN48 48
222	#define OBRACKET49 49
223	#define CBRACKET50 50
224	#define DOT51 51
225	#define COMMA52 52
226	#define SEMI53 53
227	#define EXCLAM54 54
228	#define INVERT55 55
229	#define STRING60 60
230	#define INTEGER61 61
231	#define FLOAT62 62
232	#define IDENT63 63
233	#define KEYNAME64 64
234	#define PARTIAL70 70
235	#define DEFAULT71 71
236	#define HIDDEN72 72
237	#define ALPHANUMERIC_KEYS73 73
238	#define MODIFIER_KEYS74 74
239	#define KEYPAD_KEYS75 75
240	#define FUNCTION_KEYS76 76
241	#define ALTERNATE_GROUP77 77
242
243
244
245
246	#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED1
247	typedef union YYSTYPE
248	{
249
250	/* Line 214 of yacc.c */
251	#line 110 "xkbparse.y"
252
253	int ival;
254	unsigned uval;
255	char *str;
256	Atom sval;
257	ParseCommon *any;
258	ExprDef *expr;
259	VarDef *var;
260	VModDef *vmod;
261	InterpDef *interp;
262	KeyTypeDef *keyType;
263	SymbolsDef *syms;
264	ModMapDef *modMask;
265	GroupCompatDef *groupCompat;
266	IndicatorMapDefDoodadDef *ledMap;
267	IndicatorNameDef *ledName;
268	KeycodeDef *keyName;
269	KeyAliasDef *keyAlias;
270	ShapeDef *shape;
271	SectionDef *section;
272	RowDef *row;
273	KeyDef *key;
274	OverlayDef *overlay;
275	OverlayKeyDef *olKey;
276	OutlineDef *outline;
277	DoodadDef *doodad;
278	XkbFile *file;
279
280
281
282	/* Line 214 of yacc.c */
283	#line 284 "xkbparse.c"
284	} YYSTYPE;
285	# define YYSTYPE_IS_TRIVIAL1 1
286	# define yystypeYYSTYPE YYSTYPE /* obsolescent; will be withdrawn */
287	# define YYSTYPE_IS_DECLARED1 1
288	#endif
289
290
291	/* Copy the second part of user declarations. */
292
293
294	/* Line 264 of yacc.c */
295	#line 296 "xkbparse.c"
296
297	#ifdef short
298	# undef short
299	#endif
300
301	#ifdef YYTYPE_UINT8
302	typedef YYTYPE_UINT8 yytype_uint8;
303	#else
304	typedef unsigned char yytype_uint8;
305	#endif
306
307	#ifdef YYTYPE_INT8
308	typedef YYTYPE_INT8 yytype_int8;
309	#elif (defined __STDC__1 \|\| defined __C99__FUNC__ \
310	\|\| defined __cplusplus \|\| defined _MSC_VER)
311	typedef signed char yytype_int8;
312	#else
313	typedef short int yytype_int8;
314	#endif
315
316	#ifdef YYTYPE_UINT16
317	typedef YYTYPE_UINT16 yytype_uint16;
318	#else
319	typedef unsigned short int yytype_uint16;
320	#endif
321
322	#ifdef YYTYPE_INT16
323	typedef YYTYPE_INT16 yytype_int16;
324	#else
325	typedef short int yytype_int16;
326	#endif
327
328	#ifndef YYSIZE_Tlong unsigned int
329	# ifdef __SIZE_TYPE__long unsigned int
330	# define YYSIZE_Tlong unsigned int __SIZE_TYPE__long unsigned int
331	# elif defined size_t
332	# define YYSIZE_Tlong unsigned int size_t
333	# elif ! defined YYSIZE_Tlong unsigned int && (defined __STDC__1 \|\| defined __C99__FUNC__ \
334	\|\| defined __cplusplus \|\| defined _MSC_VER)
335	# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
336	# define YYSIZE_Tlong unsigned int size_t
337	# else
338	# define YYSIZE_Tlong unsigned int unsigned int
339	# endif
340	#endif
341
342	#define YYSIZE_MAXIMUM((long unsigned int) -1) ((YYSIZE_Tlong unsigned int) -1)
343
344	#ifndef YY_
345	# if defined YYENABLE_NLS && YYENABLE_NLS
346	# if ENABLE_NLS
347	# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
348	# define YY_(msgid)msgid dgettext ("bison-runtime", msgid)
349	# endif
350	# endif
351	# ifndef YY_
352	# define YY_(msgid)msgid msgid
353	# endif
354	#endif
355
356	/* Suppress unused-variable warnings by "using" E. */
357	#if ! defined lint \|\| defined __GNUC__4
358	# define YYUSE(e)((void) (e)) ((void) (e))
359	#else
360	# define YYUSE(e)((void) (e)) /* empty */
361	#endif
362
363	/* Identity function, used to suppress warnings about constant conditions. */
364	#ifndef lint
365	# define YYID(n)(n) (n)
366	#else
367	#if (defined __STDC__1 \|\| defined __C99__FUNC__ \
368	\|\| defined __cplusplus \|\| defined _MSC_VER)
369	static int
370	YYID (int yyi)(int yyi)
371	#else
372	static int
373	YYID (yyi)(yyi)
374	int yyi;
375	#endif
376	{
377	return yyi;
378	}
379	#endif
380
381	#if ! defined yyoverflow \|\| YYERROR_VERBOSE0
382
383	/* The parser invokes alloca or malloc; define the necessary symbols. */
384
385	# ifdef YYSTACK_USE_ALLOCA
386	# if YYSTACK_USE_ALLOCA
387	# ifdef __GNUC__4
388	# define YYSTACK_ALLOCmalloc __builtin_alloca
389	# elif defined __BUILTIN_VA_ARG_INCR
390	# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
391	# elif defined _AIX
392	# define YYSTACK_ALLOCmalloc __alloca
393	# elif defined _MSC_VER
394	# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
395	# define alloca _alloca
396	# else
397	# define YYSTACK_ALLOCmalloc alloca
398	# if ! defined _ALLOCA_H1 && ! defined _STDLIB_H1 && (defined __STDC__1 \|\| defined __C99__FUNC__ \
399	\|\| defined __cplusplus \|\| defined _MSC_VER)
400	# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
401	# ifndef _STDLIB_H1
402	# define _STDLIB_H1 1
403	# endif
404	# endif
405	# endif
406	# endif
407	# endif
408
409	# ifdef YYSTACK_ALLOCmalloc
410	/* Pacify GCC's `empty if-body' warning. */
411	# define YYSTACK_FREEfree(Ptr) do { /* empty */; } while (YYID (0)(0))
412	# ifndef YYSTACK_ALLOC_MAXIMUM((long unsigned int) -1)
413	/* The OS might guarantee only one guard page at the bottom of the stack,
414	and a page size can be as small as 4096 bytes. So we cannot safely
415	invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
416	to allow for a few compiler-allocated temporary stack slots. */
417	# define YYSTACK_ALLOC_MAXIMUM((long unsigned int) -1) 4032 /* reasonable circa 2006 */
418	# endif
419	# else
420	# define YYSTACK_ALLOCmalloc YYMALLOCmalloc
421	# define YYSTACK_FREEfree YYFREEfree
422	# ifndef YYSTACK_ALLOC_MAXIMUM((long unsigned int) -1)
423	# define YYSTACK_ALLOC_MAXIMUM((long unsigned int) -1) YYSIZE_MAXIMUM((long unsigned int) -1)
424	# endif
425	# if (defined __cplusplus && ! defined _STDLIB_H1 \
426	&& ! ((defined YYMALLOCmalloc \|\| defined malloc) \
427	&& (defined YYFREEfree \|\| defined free)))
428	# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
429	# ifndef _STDLIB_H1
430	# define _STDLIB_H1 1
431	# endif
432	# endif
433	# ifndef YYMALLOCmalloc
434	# define YYMALLOCmalloc malloc
435	# if ! defined malloc && ! defined _STDLIB_H1 && (defined __STDC__1 \|\| defined __C99__FUNC__ \
436	\|\| defined __cplusplus \|\| defined _MSC_VER)
437	void malloc (YYSIZE_Tlong unsigned int); / INFRINGES ON USER NAME SPACE */
438	# endif
439	# endif
440	# ifndef YYFREEfree
441	# define YYFREEfree free
442	# if ! defined free && ! defined _STDLIB_H1 && (defined __STDC__1 \|\| defined __C99__FUNC__ \
443	\|\| defined __cplusplus \|\| defined _MSC_VER)
444	void free (void ); / INFRINGES ON USER NAME SPACE */
445	# endif
446	# endif
447	# endif
448	#endif /* ! defined yyoverflow \|\| YYERROR_VERBOSE */
449
450
451	#if (! defined yyoverflow \
452	&& (! defined __cplusplus \
453	\|\| (defined YYSTYPE_IS_TRIVIAL1 && YYSTYPE_IS_TRIVIAL1)))
454
455	/* A type that is properly aligned for any stack member. */
456	union yyalloc
457	{
458	yytype_int16 yyss_alloc;
459	YYSTYPE yyvs_alloc;
460	};
461
462	/* The size of the maximum gap between one aligned stack and the next. */
463	# define YYSTACK_GAP_MAXIMUM(sizeof (union yyalloc) - 1) (sizeof (union yyalloc) - 1)
464
465	/* The size of an array large to enough to hold all stacks, each with
466	N elements. */
467	# define YYSTACK_BYTES(N)((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) + (sizeof ( union yyalloc) - 1)) \
468	((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
469	+ YYSTACK_GAP_MAXIMUM(sizeof (union yyalloc) - 1))
470
471	/* Copy COUNT objects from FROM to TO. The source and destination do
472	not overlap. */
473	# ifndef YYCOPY
474	# if defined __GNUC__4 && 1 < __GNUC__4
475	# define YYCOPY(To, From, Count)__builtin_memcpy (To, From, (Count) * sizeof (*(From))) \
476	__builtin_memcpy (To, From, (Count) * sizeof (*(From)))
477	# else
478	# define YYCOPY(To, From, Count)__builtin_memcpy (To, From, (Count) * sizeof (*(From))) \
479	do \
480	{ \
481	YYSIZE_Tlong unsigned int yyi; \
482	for (yyi = 0; yyi < (Count); yyi++) \
483	(To)[yyi] = (From)[yyi]; \
484	} \
485	while (YYID (0)(0))
486	# endif
487	# endif
488
489	/* Relocate STACK from its old location to the new one. The
490	local variables YYSIZE and YYSTACKSIZE give the old and new number of
491	elements in the stack, and YYPTR gives the new location of the
492	stack. Advance YYPTR to a properly aligned location for the next
493	stack. */
494	# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
495	do \
496	{ \
497	YYSIZE_Tlong unsigned int yynewbytes; \
498	YYCOPY (&yyptr->Stack_alloc, Stack, yysize)__builtin_memcpy (&yyptr->Stack_alloc, Stack, (yysize) * sizeof (*(Stack))); \
499	Stack = &yyptr->Stack_alloc; \
500	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM(sizeof (union yyalloc) - 1); \
501	yyptr += yynewbytes / sizeof (*yyptr); \
502	} \
503	while (YYID (0)(0))
504
505	#endif
506
507	/* YYFINAL -- State number of the termination state. */
508	#define YYFINAL18 18
509	/* YYLAST -- Last index in YYTABLE. */
510	#define YYLAST706 706
511
512	/* YYNTOKENS -- Number of terminals. */
513	#define YYNTOKENS65 65
514	/* YYNNTS -- Number of nonterminals. */
515	#define YYNNTS73 73
516	/* YYNRULES -- Number of rules. */
517	#define YYNRULES184 184
518	/* YYNRULES -- Number of states. */
519	#define YYNSTATES335 335
520
521	/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
522	#define YYUNDEFTOK2 2
523	#define YYMAXUTOK257 257
524
525	#define YYTRANSLATE(YYX)((unsigned int) (YYX) <= 257 ? yytranslate[YYX] : 2) \
526	((unsigned int) (YYX) <= YYMAXUTOK257 ? yytranslate[YYX] : YYUNDEFTOK2)
527
528	/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
529	static const yytype_uint8 yytranslate[] =
530	{
531	0, 4, 5, 6, 7, 8, 9, 10, 11, 2,
532	12, 13, 14, 15, 16, 2, 2, 2, 2, 2,
533	17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
534	27, 28, 29, 30, 31, 32, 33, 34, 35, 2,
535	36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
536	46, 47, 48, 49, 50, 51, 2, 2, 2, 2,
537	52, 53, 54, 55, 56, 2, 2, 2, 2, 2,
538	57, 58, 59, 60, 61, 62, 63, 64, 2, 2,
539	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
540	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
541	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
542	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
543	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
544	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
545	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
546	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
547	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
548	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
549	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
550	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
551	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
552	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
553	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
554	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
555	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
556	2, 2, 2, 2, 2, 3, 1, 2
557	};
558
559	#if YYDEBUG0
560	/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
561	YYRHS. */
562	static const yytype_uint16 yyprhs[] =
563	{
564	0, 0, 3, 5, 7, 9, 12, 14, 22, 24,
565	26, 28, 31, 33, 41, 46, 48, 50, 52, 54,
566	56, 58, 59, 62, 64, 66, 68, 70, 72, 74,
567	76, 78, 80, 83, 84, 87, 90, 93, 96, 99,
568	102, 105, 108, 111, 114, 117, 120, 123, 126, 129,
569	134, 137, 141, 146, 152, 156, 160, 162, 164, 168,
570	175, 179, 181, 184, 186, 193, 200, 204, 206, 207,
571	211, 215, 217, 220, 222, 226, 230, 236, 243, 250,
572	256, 263, 270, 277, 284, 287, 289, 295, 297, 299,
573	301, 303, 306, 308, 314, 316, 320, 322, 324, 328,
574	335, 339, 341, 345, 349, 351, 355, 361, 365, 369,
575	371, 377, 384, 386, 388, 390, 392, 394, 396, 398,
576	400, 402, 404, 406, 408, 410, 412, 414, 416, 418,
577	420, 421, 423, 425, 427, 429, 431, 433, 434, 438,
578	440, 444, 448, 452, 456, 460, 462, 465, 468, 471,
579	474, 476, 481, 483, 487, 491, 493, 498, 500, 504,
580	509, 516, 518, 520, 522, 524, 526, 527, 531, 533,
581	535, 537, 539, 542, 544, 546, 548, 550, 552, 554,
582	556, 558, 560, 562, 563
583	};
584
585	/* YYRHS -- A `-1'-separated list of the rules' RHS. */
586	static const yytype_int16 yyrhs[] =
587	{
588	66, 0, -1, 67, -1, 70, -1, 72, -1, 67,
589	68, -1, 68, -1, 74, 69, 136, 41, 70, 42,
590	49, -1, 4, -1, 10, -1, 11, -1, 70, 71,
591	-1, 71, -1, 74, 73, 136, 41, 77, 42, 49,
592	-1, 74, 73, 136, 77, -1, 5, -1, 6, -1,
593	8, -1, 7, -1, 9, -1, 75, -1, -1, 75,
594	76, -1, 76, -1, 57, -1, 58, -1, 59, -1,
595	60, -1, 61, -1, 62, -1, 63, -1, 64, -1,
596	77, 78, -1, -1, 116, 79, -1, 116, 82, -1,
597	116, 85, -1, 116, 80, -1, 116, 81, -1, 116,
598	88, -1, 116, 89, -1, 116, 94, -1, 116, 93,
599	-1, 116, 95, -1, 116, 96, -1, 116, 97, -1,
600	116, 98, -1, 116, 112, -1, 117, 52, -1, 124,
601	36, 120, 49, -1, 134, 49, -1, 50, 134, 49,
602	-1, 133, 36, 120, 49, -1, 22, 133, 36, 133,
603	49, -1, 17, 83, 49, -1, 83, 48, 84, -1,
604	84, -1, 134, -1, 134, 36, 120, -1, 19, 86,
605	41, 87, 42, 49, -1, 128, 37, 120, -1, 128,
606	-1, 87, 79, -1, 79, -1, 18, 135, 41, 87,
607	42, 49, -1, 21, 133, 41, 90, 42, 49, -1,
608	90, 48, 91, -1, 91, -1, -1, 124, 36, 120,
609	-1, 124, 36, 92, -1, 134, -1, 50, 134, -1,
610	92, -1, 45, 126, 46, -1, 45, 122, 46, -1,
611	23, 132, 36, 120, 49, -1, 24, 134, 41, 119,
612	42, 49, -1, 25, 135, 41, 87, 42, 49, -1,
613	25, 132, 36, 120, 49, -1, 35, 25, 132, 36,
614	120, 49, -1, 26, 135, 41, 108, 42, 49, -1,
615	26, 135, 41, 110, 42, 49, -1, 29, 135, 41,
616	99, 42, 49, -1, 99, 100, -1, 100, -1, 28,
617	41, 101, 42, 49, -1, 79, -1, 112, -1, 95,
618	-1, 105, -1, 101, 102, -1, 102, -1, 27, 41,
619	103, 42, 49, -1, 79, -1, 103, 48, 104, -1,
620	104, -1, 133, -1, 41, 119, 42, -1, 30, 135,
621	41, 106, 42, 49, -1, 106, 48, 107, -1, 107,
622	-1, 133, 36, 133, -1, 108, 48, 109, -1, 109,
623	-1, 41, 110, 42, -1, 134, 36, 41, 110, 42,
624	-1, 134, 36, 120, -1, 110, 48, 111, -1, 111,
625	-1, 45, 129, 48, 129, 46, -1, 113, 135, 41,
626	87, 42, 49, -1, 31, -1, 32, -1, 33, -1,
627	34, -1, 134, -1, 115, -1, 20, -1, 19, -1,
628	18, -1, 21, -1, 23, -1, 24, -1, 25, -1,
629	26, -1, 28, -1, 29, -1, 31, -1, 117, -1,
630	-1, 12, -1, 14, -1, 13, -1, 15, -1, 16,
631	-1, 119, -1, -1, 119, 48, 120, -1, 120, -1,
632	120, 39, 120, -1, 120, 37, 120, -1, 120, 38,
633	120, -1, 120, 40, 120, -1, 124, 36, 120, -1,
634	121, -1, 38, 121, -1, 37, 121, -1, 50, 121,
635	-1, 51, 121, -1, 124, -1, 114, 43, 118, 44,
636	-1, 125, -1, 43, 120, 44, -1, 122, 48, 123,
637	-1, 123, -1, 114, 43, 118, 44, -1, 114, -1,
638	114, 47, 114, -1, 114, 45, 120, 46, -1, 114,
639	47, 114, 45, 120, 46, -1, 135, -1, 132, -1,
640	131, -1, 133, -1, 127, -1, -1, 127, 48, 128,
641	-1, 128, -1, 55, -1, 29, -1, 132, -1, 38,
642	130, -1, 130, -1, 54, -1, 53, -1, 54, -1,
643	53, -1, 56, -1, 55, -1, 58, -1, 52, -1,
644	137, -1, -1, 52, -1
645	};
646
647	/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
648	static const yytype_uint16 yyrline[] =
649	{
650	0, 168, 168, 170, 172, 176, 178, 182, 188, 189,
651	190, 193, 195, 199, 205, 210, 211, 212, 213, 214,
652	217, 218, 221, 222, 225, 226, 227, 228, 229, 230,
653	231, 232, 235, 237, 240, 245, 250, 255, 260, 265,
654	270, 275, 280, 285, 290, 295, 300, 305, 310, 322,
655	324, 326, 330, 341, 351, 355, 357, 361, 363, 367,
656	376, 378, 382, 384, 388, 394, 400, 402, 404, 407,
657	409, 411, 413, 415, 419, 421, 425, 429, 433, 437,
658	439, 443, 445, 453, 457, 459, 463, 465, 467, 469,
659	471, 475, 477, 481, 483, 487, 489, 493, 495, 499,
660	503, 508, 512, 516, 518, 522, 524, 526, 530, 532,
661	536, 546, 550, 551, 552, 553, 556, 557, 560, 562,
662	564, 566, 568, 570, 572, 574, 576, 578, 580, 584,
663	585, 588, 589, 590, 591, 592, 595, 596, 599, 601,
664	605, 607, 609, 611, 613, 615, 619, 621, 623, 625,
665	627, 629, 631, 633, 637, 639, 643, 647, 654, 662,
666	671, 682, 689, 696, 703, 714, 715, 718, 720, 724,
667	725, 726, 733, 734, 737, 738, 741, 744, 747, 750,
668	751, 754, 757, 758, 761
669	};
670	#endif
671
672	#if YYDEBUG0 \|\| YYERROR_VERBOSE0 \|\| YYTOKEN_TABLE0
673	/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
674	First, the terminals, then, starting at YYNTOKENS, nonterminals. */
675	static const char *const yytname[] =
676	{
677	"END_OF_FILE", "error", "$undefined", "ERROR_TOK", "XKB_KEYMAP",
678	"XKB_KEYCODES", "XKB_TYPES", "XKB_SYMBOLS", "XKB_COMPATMAP",
679	"XKB_GEOMETRY", "XKB_SEMANTICS", "XKB_LAYOUT", "INCLUDE", "OVERRIDE",
680	"AUGMENT", "REPLACE", "ALTERNATE", "VIRTUAL_MODS", "TYPE", "INTERPRET",
681	"ACTION_TOK", "KEY", "ALIAS", "GROUP", "MODIFIER_MAP", "INDICATOR",
682	"SHAPE", "KEYS", "ROW", "SECTION", "OVERLAY", "TEXT", "OUTLINE", "SOLID",
683	"LOGO", "VIRTUAL", "EQUALS", "PLUS", "MINUS", "DIVIDE", "TIMES",
684	"OBRACE", "CBRACE", "OPAREN", "CPAREN", "OBRACKET", "CBRACKET", "DOT",
685	"COMMA", "SEMI", "EXCLAM", "INVERT", "STRING", "INTEGER", "FLOAT",
686	"IDENT", "KEYNAME", "PARTIAL", "DEFAULT", "HIDDEN", "ALPHANUMERIC_KEYS",
687	"MODIFIER_KEYS", "KEYPAD_KEYS", "FUNCTION_KEYS", "ALTERNATE_GROUP",
688	"$accept", "XkbFile", "XkbCompMapList", "XkbCompositeMap",
689	"XkbCompositeType", "XkbMapConfigList", "XkbMapConfig", "XkbConfig",
690	"FileType", "OptFlags", "Flags", "Flag", "DeclList", "Decl", "VarDecl",
691	"KeyNameDecl", "KeyAliasDecl", "VModDecl", "VModDefList", "VModDef",
692	"InterpretDecl", "InterpretMatch", "VarDeclList", "KeyTypeDecl",
693	"SymbolsDecl", "SymbolsBody", "SymbolsVarDecl", "ArrayInit",
694	"GroupCompatDecl", "ModMapDecl", "IndicatorMapDecl", "IndicatorNameDecl",
695	"ShapeDecl", "SectionDecl", "SectionBody", "SectionBodyItem", "RowBody",
696	"RowBodyItem", "Keys", "Key", "OverlayDecl", "OverlayKeyList",
697	"OverlayKey", "OutlineList", "OutlineInList", "CoordList", "Coord",
698	"DoodadDecl", "DoodadType", "FieldSpec", "Element", "OptMergeMode",
699	"MergeMode", "OptExprList", "ExprList", "Expr", "Term", "ActionList",
700	"Action", "Lhs", "Terminal", "OptKeySymList", "KeySymList", "KeySym",
701	"SignedNumber", "Number", "Float", "Integer", "KeyName", "Ident",
702	"String", "OptMapName", "MapName", 0
703	};
704	#endif
705
706	# ifdef YYPRINT
707	/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
708	token YYLEX-NUM. */
709	static const yytype_uint16 yytoknum[] =
710	{
711	0, 256, 257, 255, 1, 2, 3, 4, 5, 6,
712	7, 8, 10, 11, 12, 13, 14, 20, 21, 22,
713	23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
714	33, 34, 35, 36, 37, 38, 40, 41, 42, 43,
715	44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
716	54, 55, 60, 61, 62, 63, 64, 70, 71, 72,
717	73, 74, 75, 76, 77
718	};
719	# endif
720
721	/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
722	static const yytype_uint8 yyr1[] =
723	{
724	0, 65, 66, 66, 66, 67, 67, 68, 69, 69,
725	69, 70, 70, 71, 72, 73, 73, 73, 73, 73,
726	74, 74, 75, 75, 76, 76, 76, 76, 76, 76,
727	76, 76, 77, 77, 78, 78, 78, 78, 78, 78,
728	78, 78, 78, 78, 78, 78, 78, 78, 78, 79,
729	79, 79, 80, 81, 82, 83, 83, 84, 84, 85,
730	86, 86, 87, 87, 88, 89, 90, 90, 90, 91,
731	91, 91, 91, 91, 92, 92, 93, 94, 95, 96,
732	96, 97, 97, 98, 99, 99, 100, 100, 100, 100,
733	100, 101, 101, 102, 102, 103, 103, 104, 104, 105,
734	106, 106, 107, 108, 108, 109, 109, 109, 110, 110,
735	111, 112, 113, 113, 113, 113, 114, 114, 115, 115,
736	115, 115, 115, 115, 115, 115, 115, 115, 115, 116,
737	116, 117, 117, 117, 117, 117, 118, 118, 119, 119,
738	120, 120, 120, 120, 120, 120, 121, 121, 121, 121,
739	121, 121, 121, 121, 122, 122, 123, 124, 124, 124,
740	124, 125, 125, 125, 125, 126, 126, 127, 127, 128,
741	128, 128, 129, 129, 130, 130, 131, 132, 133, 134,
742	134, 135, 136, 136, 137
743	};
744
745	/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
746	static const yytype_uint8 yyr2[] =
747	{
748	0, 2, 1, 1, 1, 2, 1, 7, 1, 1,
749	1, 2, 1, 7, 4, 1, 1, 1, 1, 1,
750	1, 0, 2, 1, 1, 1, 1, 1, 1, 1,
751	1, 1, 2, 0, 2, 2, 2, 2, 2, 2,
752	2, 2, 2, 2, 2, 2, 2, 2, 2, 4,
753	2, 3, 4, 5, 3, 3, 1, 1, 3, 6,
754	3, 1, 2, 1, 6, 6, 3, 1, 0, 3,
755	3, 1, 2, 1, 3, 3, 5, 6, 6, 5,
756	6, 6, 6, 6, 2, 1, 5, 1, 1, 1,
757	1, 2, 1, 5, 1, 3, 1, 1, 3, 6,
758	3, 1, 3, 3, 1, 3, 5, 3, 3, 1,
759	5, 6, 1, 1, 1, 1, 1, 1, 1, 1,
760	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
761	0, 1, 1, 1, 1, 1, 1, 0, 3, 1,
762	3, 3, 3, 3, 3, 1, 2, 2, 2, 2,
763	1, 4, 1, 3, 3, 1, 4, 1, 3, 4,
764	6, 1, 1, 1, 1, 1, 0, 3, 1, 1,
765	1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
766	1, 1, 1, 0, 1
767	};
768
769	/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
770	STATE-NUM when YYTABLE doesn't specify something else to do. Zero
771	means the default is an error. */
772	static const yytype_uint8 yydefact[] =
773	{
774	21, 24, 25, 26, 27, 28, 29, 30, 31, 0,
775	21, 6, 21, 12, 4, 0, 20, 23, 1, 5,
776	0, 11, 0, 8, 15, 16, 18, 17, 19, 9,
777	10, 183, 183, 22, 183, 184, 0, 182, 33, 0,
778	21, 33, 130, 21, 130, 131, 133, 132, 134, 135,
779	32, 0, 129, 0, 0, 0, 120, 119, 118, 121,
780	0, 122, 123, 124, 125, 126, 127, 128, 113, 114,
781	115, 0, 0, 179, 178, 180, 34, 37, 38, 35,
782	36, 39, 40, 42, 41, 43, 44, 45, 46, 47,
783	0, 157, 117, 0, 0, 116, 48, 7, 13, 0,
784	56, 57, 181, 0, 170, 177, 169, 0, 61, 171,
785	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
786	0, 0, 0, 0, 0, 50, 0, 54, 0, 0,
787	0, 0, 68, 0, 0, 0, 0, 0, 0, 0,
788	0, 51, 0, 120, 119, 121, 122, 123, 124, 125,
789	127, 128, 0, 0, 0, 0, 0, 176, 157, 0,
790	145, 150, 152, 163, 162, 164, 116, 161, 158, 0,
791	0, 55, 58, 63, 0, 0, 60, 166, 0, 0,
792	67, 73, 0, 116, 0, 0, 0, 139, 0, 0,
793	0, 0, 0, 104, 0, 109, 0, 124, 126, 0,
794	87, 89, 0, 85, 90, 88, 0, 0, 147, 150,
795	146, 0, 148, 149, 137, 0, 0, 0, 0, 159,
796	0, 0, 49, 52, 0, 62, 0, 170, 169, 0,
797	0, 155, 0, 165, 168, 72, 0, 0, 0, 53,
798	76, 0, 0, 79, 0, 0, 0, 175, 174, 0,
799	173, 0, 0, 0, 0, 0, 0, 0, 0, 84,
800	0, 0, 153, 0, 136, 141, 142, 140, 143, 144,
801	0, 64, 59, 137, 75, 0, 74, 0, 65, 66,
802	70, 69, 77, 138, 78, 105, 172, 0, 81, 103,
803	82, 108, 0, 107, 0, 94, 0, 92, 0, 83,
804	80, 111, 151, 160, 0, 154, 167, 0, 0, 0,
805	0, 91, 0, 101, 0, 156, 110, 106, 0, 0,
806	96, 97, 86, 0, 0, 0, 0, 0, 0, 99,
807	100, 102, 98, 93, 95
808	};
809
810	/* YYDEFGOTO[NTERM-NUM]. */
811	static const yytype_int16 yydefgoto[] =
812	{
813	-1, 9, 10, 11, 31, 12, 13, 14, 32, 22,
814	16, 17, 42, 50, 173, 77, 78, 79, 99, 100,
815	80, 107, 174, 81, 82, 179, 180, 181, 83, 84,
816	201, 86, 87, 88, 202, 203, 296, 297, 319, 320,
817	204, 312, 313, 192, 193, 194, 195, 205, 90, 158,
818	92, 51, 52, 263, 264, 187, 160, 230, 231, 161,
819	162, 232, 233, 108, 249, 250, 163, 164, 165, 166,
820	167, 36, 37
821	};
822
823	/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
824	STATE-NUM. */
825	#define YYPACT_NINF-188 -188
826	static const yytype_int16 yypact[] =
827	{
828	628, -188, -188, -188, -188, -188, -188, -188, -188, 12,
829	4, -188, 58, -188, -188, 695, 628, -188, -188, -188,
830	121, -188, 408, -188, -188, -188, -188, -188, -188, -188,
831	-188, -9, -9, -188, -9, -188, 19, -188, 45, 45,
832	628, -188, 174, 620, 137, -188, -188, -188, -188, -188,
833	-188, 317, 39, -15, 50, 1, 59, -18, -188, 72,
834	72, 106, 1, -27, 59, -188, 59, 62, -188, -188,
835	-188, 117, 1, -188, -188, -188, -188, -188, -188, -188,
836	-188, -188, -188, -188, -188, -188, -188, -188, -188, -188,
837	59, 51, -188, 125, 146, 134, -188, -188, -188, 132,
838	-188, 163, -188, 168, -188, -188, -188, 173, 179, -188,
839	178, 186, 190, 194, 206, 204, 208, 221, 106, 216,
840	225, 265, 640, 265, 265, -188, 1, -188, 265, 599,
841	599, 265, 470, 72, 265, 265, 265, 599, -26, 21,
842	239, -188, 599, -188, -188, -188, -188, -188, -188, -188,
843	-188, -188, 265, 265, 265, 265, 265, -188, 159, 232,
844	-188, 240, -188, -188, -188, -188, -188, -188, 223, 98,
845	156, -188, 260, -188, 485, 513, 260, 617, 1, 30,
846	-188, -188, 243, 32, 231, 192, 64, 260, 199, 528,
847	236, 35, 127, -188, 128, -188, 251, 59, 270, 59,
848	-188, -188, 422, -188, -188, -188, 265, 556, -188, -188,
849	-188, 342, -188, -188, 265, 265, 265, 265, 265, -188,
850	265, 265, -188, -188, 263, -188, 264, 249, 271, 281,
851	61, -188, 279, 278, -188, -188, 280, 470, 340, -188,
852	-188, 283, 265, -188, 284, 129, 16, -188, -188, 282,
853	-188, 298, -34, 308, 236, 381, 576, 287, 321, -188,
854	215, 325, -188, 332, 336, 158, 158, -188, -188, 260,
855	316, -188, -188, 265, -188, 640, -188, -18, -188, -188,
856	-188, 260, -188, 260, -188, -188, -188, 35, -188, -188,
857	-188, -188, 236, 260, 346, -188, 442, -188, 72, -188,
858	-188, -188, -188, -188, 344, -188, -188, 343, 143, -28,
859	348, -188, 176, -188, 367, -188, -188, -188, 265, 198,
860	-188, -188, -188, 359, 72, 72, 202, 362, -28, -188,
861	-188, -188, -188, -188, -188
862	};
863
864	/* YYPGOTO[NTERM-NUM]. */
865	static const yytype_int16 yypgoto[] =
866	{
867	-188, -188, -188, 410, -188, 383, -7, -188, 399, 38,
868	-188, 409, 385, -188, -35, -188, -188, -188, -188, 301,
869	-188, -188, -47, -188, -188, -188, 191, 200, -188, -188,
870	378, -188, -188, -188, -188, 228, -188, 148, -188, 130,
871	-188, -188, 133, -188, 197, -187, 205, 423, -188, 26,
872	-188, -188, -188, 203, -134, 89, 104, -188, 207, -29,
873	-188, -188, -188, -175, 188, 233, -188, -43, -51, -45,
874	-33, 109, -188
875	};
876
877	/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
878	positive, shift that token. If negative, reduce the rule which
879	number is the opposite. If zero, do what YYDEFACT says.
880	If YYTABLE_NINF, syntax error. */
881	#define YYTABLE_NINF-180 -180
882	static const yytype_int16 yytable[] =
883	{
884	94, 186, 234, 245, -2, 21, 95, 190, 110, 111,
885	101, 104, 18, 318, 109, 190, 76, 113, 112, 191,
886	114, 73, 93, 103, 75, 102, 105, 119, 74, 73,
887	115, 116, 75, 117, 97, 105, 21, 106, 15, 143,
888	144, 58, 145, 35, 146, 147, 197, 149, 20, 198,
889	150, 199, 67, 68, 69, 70, 73, 120, -3, 75,
890	40, 1, 2, 3, 4, 5, 6, 7, 8, 247,
891	248, 72, 236, 246, -71, 140, 73, 91, 237, 75,
892	-71, 101, 184, 175, 95, 95, 41, 183, 247, 248,
893	189, 96, 95, 196, 95, 207, 121, 95, 122, 98,
894	93, 93, 306, 182, 200, 308, 241, 274, 93, 275,
895	93, 102, 242, 93, -112, 1, 2, 3, 4, 5,
896	6, 7, 8, 209, 209, 23, 209, 209, 74, 95,
897	95, 29, 30, 235, 109, 215, 216, 217, 218, 225,
898	225, 38, 118, 39, 95, 93, 93, 222, 168, 45,
899	46, 47, 48, 49, 225, 91, 91, 95, 91, 105,
900	93, 123, 95, 91, 115, 91, 257, 200, 91, 251,
901	253, 285, 225, 93, -14, 252, 254, 254, 93, 54,
902	126, 127, 124, 125, 326, 317, 45, 46, 47, 48,
903	49, 254, 183, 215, 216, 217, 218, 217, 218, 128,
904	91, 91, 214, 229, 121, 223, 122, 196, 182, 129,
905	159, 95, 169, 170, 130, 91, 131, 172, 323, 132,
906	176, 295, 133, 185, 324, 188, 134, 93, 91, 215,
907	216, 217, 218, 91, 109, 135, 215, 216, 217, 218,
908	327, 240, 136, 211, 332, 137, 328, 314, 243, 138,
909	242, 95, 215, 216, 217, 218, 208, 210, 321, 212,
910	213, 295, 139, 91, 300, 141, 142, 93, 221, 215,
911	216, 217, 218, 314, 331, 206, 220, 321, 219, 238,
912	239, 191, 91, 143, 144, 58, 145, 255, 146, 147,
913	148, 149, -127, 65, 150, 260, 151, 215, 216, 217,
914	218, 229, 152, 153, 265, 266, 267, 268, 154, 269,
915	270, 256, 271, 272, -179, 155, 156, 102, 105, 157,
916	73, 74, 91, 75, 273, 276, 277, 281, 298, 278,
917	287, 283, 282, 284, 55, 56, 57, 58, 59, 60,
918	61, 62, 63, 64, 293, 65, 66, 288, 67, 68,
919	69, 70, 71, 215, 216, 217, 218, 290, 143, 144,
920	58, 145, 303, 146, 147, 148, 149, 72, 65, 150,
921	299, 151, 73, 74, 301, 75, 302, 152, 153, 215,
922	216, 217, 218, 154, 242, 177, 262, 309, 315, 316,
923	155, 156, 102, 105, 157, 73, 74, 322, 75, 143,
924	144, 58, 145, 325, 146, 147, 148, 149, 329, 65,
925	150, 333, 151, 24, 25, 26, 27, 28, 152, 153,
926	19, 34, 292, 43, 154, 33, 44, 171, 279, 85,
927	259, 155, 156, 102, 105, 157, 73, 74, 280, 75,
928	143, 144, 58, 145, 311, 146, 147, 197, 149, 289,
929	198, 150, 199, 67, 68, 69, 70, 330, 334, 291,
930	143, 144, 58, 145, 258, 146, 147, 148, 149, 294,
931	65, 150, 72, 151, 89, 307, 304, 73, 0, 286,
932	75, 0, 305, 0, 310, 0, 0, 0, 143, 144,
933	58, 145, 72, 146, 147, 148, 149, 73, 65, 150,
934	75, 151, 0, 143, 144, 58, 145, 0, 146, 147,
935	148, 149, 0, 65, 150, 177, 151, 0, 0, 0,
936	178, 0, 0, 0, 0, 73, 0, 224, 75, 0,
937	0, 143, 144, 58, 145, 72, 146, 147, 148, 149,
938	73, 65, 150, 75, 151, 0, 143, 144, 58, 145,
939	0, 146, 147, 148, 149, 226, 65, 150, 0, 151,
940	0, 0, 0, 72, 0, 0, 0, 0, 73, 0,
941	244, 75, 0, 0, 143, 144, 58, 145, 72, 146,
942	147, 148, 149, 73, 65, 150, 75, 151, 0, 0,
943	0, 0, 0, 0, 143, 144, 58, 145, 261, 146,
944	147, 148, 149, 294, 65, 150, 72, 151, 0, 0,
945	0, 73, 0, 0, 75, 0, 0, 143, 144, 58,
946	145, 0, 146, 147, 148, 149, 72, 65, 150, 0,
947	151, 73, 0, 0, 75, 143, 144, 58, 145, 0,
948	146, 147, 148, 149, 0, 65, 227, 0, 151, 72,
949	0, 0, 0, 0, 73, 0, 0, 75, 143, 144,
950	58, 145, 53, 146, 147, 148, 149, 0, 65, 150,
951	105, 151, 228, 0, 0, 75, 0, 1, 2, 3,
952	4, 5, 6, 7, 8, 1, 2, 3, 4, 5,
953	6, 7, 8, 0, 0, 73, 0, 0, 75, 23,
954	24, 25, 26, 27, 28, 29, 30
955	};
956
957	static const yytype_int16 yycheck[] =
958	{
959	51, 135, 177, 190, 0, 12, 51, 41, 59, 60,
960	55, 29, 0, 41, 57, 41, 51, 62, 61, 45,
961	63, 55, 51, 56, 58, 52, 53, 72, 56, 55,
962	63, 64, 58, 66, 49, 53, 43, 55, 0, 18,
963	19, 20, 21, 52, 23, 24, 25, 26, 10, 28,
964	29, 30, 31, 32, 33, 34, 55, 90, 0, 58,
965	41, 57, 58, 59, 60, 61, 62, 63, 64, 53,
966	54, 50, 42, 38, 42, 118, 55, 51, 48, 58,
967	48, 126, 133, 130, 129, 130, 41, 132, 53, 54,
968	137, 52, 137, 138, 139, 142, 45, 142, 47, 49,
969	129, 130, 277, 132, 139, 292, 42, 46, 137, 48,
970	139, 52, 48, 142, 52, 57, 58, 59, 60, 61,
971	62, 63, 64, 152, 153, 4, 155, 156, 56, 174,
972	175, 10, 11, 178, 177, 37, 38, 39, 40, 174,
973	175, 32, 25, 34, 189, 174, 175, 49, 122, 12,
974	13, 14, 15, 16, 189, 129, 130, 202, 132, 53,
975	189, 36, 207, 137, 197, 139, 199, 202, 142, 42,
976	42, 42, 207, 202, 0, 48, 48, 48, 207, 42,
977	48, 49, 36, 49, 318, 42, 12, 13, 14, 15,
978	16, 48, 237, 37, 38, 39, 40, 39, 40, 36,
979	174, 175, 43, 177, 45, 49, 47, 252, 237, 41,
980	121, 256, 123, 124, 41, 189, 37, 128, 42, 41,
981	131, 256, 36, 134, 48, 136, 36, 256, 202, 37,
982	38, 39, 40, 207, 277, 41, 37, 38, 39, 40,
983	42, 49, 36, 154, 42, 41, 48, 298, 49, 41,
984	48, 296, 37, 38, 39, 40, 152, 153, 309, 155,
985	156, 296, 41, 237, 49, 49, 41, 296, 45, 37,
986	38, 39, 40, 324, 325, 36, 36, 328, 46, 36,
987	49, 45, 256, 18, 19, 20, 21, 36, 23, 24,
988	25, 26, 43, 28, 29, 206, 31, 37, 38, 39,
989	40, 275, 37, 38, 215, 216, 217, 218, 43, 220,
990	221, 41, 49, 49, 43, 50, 51, 52, 53, 54,
991	55, 56, 296, 58, 43, 46, 48, 238, 41, 49,
992	48, 242, 49, 49, 17, 18, 19, 20, 21, 22,
993	23, 24, 25, 26, 255, 28, 29, 49, 31, 32,
994	33, 34, 35, 37, 38, 39, 40, 49, 18, 19,
995	20, 21, 46, 23, 24, 25, 26, 50, 28, 29,
996	49, 31, 55, 56, 49, 58, 44, 37, 38, 37,
997	38, 39, 40, 43, 48, 45, 44, 41, 44, 46,
998	50, 51, 52, 53, 54, 55, 56, 49, 58, 18,
999	19, 20, 21, 36, 23, 24, 25, 26, 49, 28,
1000	29, 49, 31, 5, 6, 7, 8, 9, 37, 38,
1001	10, 22, 41, 40, 43, 16, 41, 126, 237, 51,
1002	202, 50, 51, 52, 53, 54, 55, 56, 238, 58,
1003	18, 19, 20, 21, 296, 23, 24, 25, 26, 252,
1004	28, 29, 30, 31, 32, 33, 34, 324, 328, 254,
1005	18, 19, 20, 21, 42, 23, 24, 25, 26, 27,
1006	28, 29, 50, 31, 51, 287, 273, 55, -1, 246,
1007	58, -1, 275, -1, 42, -1, -1, -1, 18, 19,
1008	20, 21, 50, 23, 24, 25, 26, 55, 28, 29,
1009	58, 31, -1, 18, 19, 20, 21, -1, 23, 24,
1010	25, 26, -1, 28, 29, 45, 31, -1, -1, -1,
1011	50, -1, -1, -1, -1, 55, -1, 42, 58, -1,
1012	-1, 18, 19, 20, 21, 50, 23, 24, 25, 26,
1013	55, 28, 29, 58, 31, -1, 18, 19, 20, 21,
1014	-1, 23, 24, 25, 26, 42, 28, 29, -1, 31,
1015	-1, -1, -1, 50, -1, -1, -1, -1, 55, -1,
1016	42, 58, -1, -1, 18, 19, 20, 21, 50, 23,
1017	24, 25, 26, 55, 28, 29, 58, 31, -1, -1,
1018	-1, -1, -1, -1, 18, 19, 20, 21, 42, 23,
1019	24, 25, 26, 27, 28, 29, 50, 31, -1, -1,
1020	-1, 55, -1, -1, 58, -1, -1, 18, 19, 20,
1021	21, -1, 23, 24, 25, 26, 50, 28, 29, -1,
1022	31, 55, -1, -1, 58, 18, 19, 20, 21, -1,
1023	23, 24, 25, 26, -1, 28, 29, -1, 31, 50,
1024	-1, -1, -1, -1, 55, -1, -1, 58, 18, 19,
1025	20, 21, 42, 23, 24, 25, 26, -1, 28, 29,
1026	53, 31, 55, -1, -1, 58, -1, 57, 58, 59,
1027	60, 61, 62, 63, 64, 57, 58, 59, 60, 61,
1028	62, 63, 64, -1, -1, 55, -1, -1, 58, 4,
1029	5, 6, 7, 8, 9, 10, 11
1030	};
1031
1032	/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1033	symbol of state STATE-NUM. */
1034	static const yytype_uint8 yystos[] =
1035	{
1036	0, 57, 58, 59, 60, 61, 62, 63, 64, 66,
1037	67, 68, 70, 71, 72, 74, 75, 76, 0, 68,
1038	74, 71, 74, 4, 5, 6, 7, 8, 9, 10,
1039	11, 69, 73, 76, 73, 52, 136, 137, 136, 136,
1040	41, 41, 77, 70, 77, 12, 13, 14, 15, 16,
1041	78, 116, 117, 42, 42, 17, 18, 19, 20, 21,
1042	22, 23, 24, 25, 26, 28, 29, 31, 32, 33,
1043	34, 35, 50, 55, 56, 58, 79, 80, 81, 82,
1044	85, 88, 89, 93, 94, 95, 96, 97, 98, 112,
1045	113, 114, 115, 124, 133, 134, 52, 49, 49, 83,
1046	84, 134, 52, 135, 29, 53, 55, 86, 128, 132,
1047	133, 133, 132, 134, 132, 135, 135, 135, 25, 134,
1048	135, 45, 47, 36, 36, 49, 48, 49, 36, 41,
1049	41, 37, 41, 36, 36, 41, 36, 41, 41, 41,
1050	132, 49, 41, 18, 19, 21, 23, 24, 25, 26,
1051	29, 31, 37, 38, 43, 50, 51, 54, 114, 120,
1052	121, 124, 125, 131, 132, 133, 134, 135, 114, 120,
1053	120, 84, 120, 79, 87, 87, 120, 45, 50, 90,
1054	91, 92, 124, 134, 133, 120, 119, 120, 120, 87,
1055	41, 45, 108, 109, 110, 111, 134, 25, 28, 30,
1056	79, 95, 99, 100, 105, 112, 36, 87, 121, 124,
1057	121, 120, 121, 121, 43, 37, 38, 39, 40, 46,
1058	36, 45, 49, 49, 42, 79, 42, 29, 55, 114,
1059	122, 123, 126, 127, 128, 134, 42, 48, 36, 49,
1060	49, 42, 48, 49, 42, 110, 38, 53, 54, 129,
1061	130, 42, 48, 42, 48, 36, 41, 135, 42, 100,
1062	120, 42, 44, 118, 119, 120, 120, 120, 120, 120,
1063	120, 49, 49, 43, 46, 48, 46, 48, 49, 91,
1064	92, 120, 49, 120, 49, 42, 130, 48, 49, 109,
1065	49, 111, 41, 120, 27, 79, 101, 102, 41, 49,
1066	49, 49, 44, 46, 118, 123, 128, 129, 110, 41,
1067	42, 102, 106, 107, 133, 44, 46, 42, 41, 103,
1068	104, 133, 49, 42, 48, 36, 119, 42, 48, 49,
1069	107, 133, 42, 49, 104
1070	};
1071
1072	#define yyerrok(yyerrstatus = 0) (yyerrstatus = 0)
1073	#define yyclearin(yychar = (-2)) (yychar = YYEMPTY(-2))
1074	#define YYEMPTY(-2) (-2)
1075	#define YYEOF0 0
1076
1077	#define YYACCEPTgoto yyacceptlab goto yyacceptlab
1078	#define YYABORTgoto yyabortlab goto yyabortlab
1079	#define YYERRORgoto yyerrorlab goto yyerrorlab
1080
1081
1082	/* Like YYERROR except do call yyerror. This remains here temporarily
1083	to ease the transition to the new meaning of YYERROR, for GCC.
1084	Once GCC version 2 has supplanted version 1, this can go. However,
1085	YYFAIL appears to be in use. Nevertheless, it is formally deprecated
1086	in Bison 2.4.2's NEWS entry, where a plan to phase it out is
1087	discussed. */
1088
1089	#define YYFAILgoto yyerrlab goto yyerrlab
1090	#if defined YYFAILgoto yyerrlab
1091	/* This is here to suppress warnings from the GCC cpp's
1092	-Wunused-macros. Normally we don't worry about that warning, but
1093	some users do, and we want to make it easy for users to remove
1094	YYFAIL uses, which will produce warnings from Bison 2.5. */
1095	#endif
1096
1097	#define YYRECOVERING()(!!yyerrstatus) (!!yyerrstatus)
1098
1099	#define YYBACKUP(Token, Value)do if (yychar == (-2) && yylen == 1) { yychar = (Token ); yylval = (Value); yytoken = ((unsigned int) (yychar) <= 257 ? yytranslate[yychar] : 2); (yyvsp -= (1), yyssp -= (1)) ; goto yybackup; } else { yyerror ("syntax error: cannot back up" ); goto yyerrorlab; } while ((0)) \
1100	do \
1101	if (yychar == YYEMPTY(-2) && yylen == 1) \
1102	{ \
1103	yychar = (Token); \
1104	yylval = (Value); \
1105	yytoken = YYTRANSLATE (yychar)((unsigned int) (yychar) <= 257 ? yytranslate[yychar] : 2); \
1106	YYPOPSTACK (1)(yyvsp -= (1), yyssp -= (1)); \
1107	goto yybackup; \
1108	} \
1109	else \
1110	{ \
1111	yyerror (YY_("syntax error: cannot back up")"syntax error: cannot back up"); \
1112	YYERRORgoto yyerrorlab; \
1113	} \
1114	while (YYID (0)(0))
1115
1116
1117	#define YYTERROR1 1
1118	#define YYERRCODE256 256
1119
1120
1121	/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
1122	If N is 0, then set CURRENT to the empty location which ends
1123	the previous symbol: RHS[0] (always defined). */
1124
1125	#define YYRHSLOC(Rhs, K)((Rhs)[K]) ((Rhs)[K])
1126	#ifndef YYLLOC_DEFAULT
1127	# define YYLLOC_DEFAULT(Current, Rhs, N)do if ((N)) { (Current).first_line = ((Rhs)[1]).first_line; ( Current).first_column = ((Rhs)[1]).first_column; (Current).last_line = ((Rhs)[N]).last_line; (Current).last_column = ((Rhs)[N]).last_column ; } else { (Current).first_line = (Current).last_line = ((Rhs )[0]).last_line; (Current).first_column = (Current).last_column = ((Rhs)[0]).last_column; } while ((0)) \
1128	do \
1129	if (YYID (N)(N)) \
1130	{ \
1131	(Current).first_line = YYRHSLOC (Rhs, 1)((Rhs)[1]).first_line; \
1132	(Current).first_column = YYRHSLOC (Rhs, 1)((Rhs)[1]).first_column; \
1133	(Current).last_line = YYRHSLOC (Rhs, N)((Rhs)[N]).last_line; \
1134	(Current).last_column = YYRHSLOC (Rhs, N)((Rhs)[N]).last_column; \
1135	} \
1136	else \
1137	{ \
1138	(Current).first_line = (Current).last_line = \
1139	YYRHSLOC (Rhs, 0)((Rhs)[0]).last_line; \
1140	(Current).first_column = (Current).last_column = \
1141	YYRHSLOC (Rhs, 0)((Rhs)[0]).last_column; \
1142	} \
1143	while (YYID (0)(0))
1144	#endif
1145
1146
1147	/* YY_LOCATION_PRINT -- Print the location on the stream.
1148	This macro was not mandated originally: define only if we know
1149	we won't break user code: when these are the locations we know. */
1150
1151	#ifndef YY_LOCATION_PRINT
1152	# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1153	# define YY_LOCATION_PRINT(File, Loc)((void) 0) \
1154	fprintf (File, "%d.%d-%d.%d", \
1155	(Loc).first_line, (Loc).first_column, \
1156	(Loc).last_line, (Loc).last_column)
1157	# else
1158	# define YY_LOCATION_PRINT(File, Loc)((void) 0) ((void) 0)
1159	# endif
1160	#endif
1161
1162
1163	/* YYLEX -- calling `yylex' with the right arguments. */
1164
1165	#ifdef YYLEX_PARAM
1166	# define YYLEXyylex () yylex (YYLEX_PARAM)
1167	#else
1168	# define YYLEXyylex () yylex ()
1169	#endif
1170
1171	/* Enable debugging if requested. */
1172	#if YYDEBUG0
1173
1174	# ifndef YYFPRINTF
1175	# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1176	# define YYFPRINTF fprintf
1177	# endif
1178
1179	# define YYDPRINTF(Args) \
1180	do { \
1181	if (yydebug) \
1182	YYFPRINTF Args; \
1183	} while (YYID (0)(0))
1184
1185	# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1186	do { \
1187	if (yydebug) \
1188	{ \
1189	YYFPRINTF (stderrstderr, "%s ", Title); \
1190	yy_symbol_print (stderrstderr, \
1191	Type, Value); \
1192	YYFPRINTF (stderrstderr, "\n"); \
1193	} \
1194	} while (YYID (0)(0))
1195
1196
1197	/*--------------------------------.
1198	\| Print this symbol on YYOUTPUT. \|
1199	`--------------------------------*/
1200
1201	/ARGSUSED/
1202	#if (defined __STDC__1 \|\| defined __C99__FUNC__ \
1203	\|\| defined __cplusplus \|\| defined _MSC_VER)
1204	static void
1205	yy_symbol_value_print (FILE yyoutput, int yytype, YYSTYPE const const yyvaluep)
1206	#else
1207	static void
1208	yy_symbol_value_print (yyoutput, yytype, yyvaluep)
1209	FILE *yyoutput;
1210	int yytype;
1211	YYSTYPE const * const yyvaluep;
1212	#endif
1213	{
1214	if (!yyvaluep)
1215	return;
1216	# ifdef YYPRINT
1217	if (yytype < YYNTOKENS65)
1218	YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1219	# else
1220	YYUSE (yyoutput)((void) (yyoutput));
1221	# endif
1222	switch (yytype)
1223	{
1224	default:
1225	break;
1226	}
1227	}
1228
1229
1230	/*--------------------------------.
1231	\| Print this symbol on YYOUTPUT. \|
1232	`--------------------------------*/
1233
1234	#if (defined __STDC__1 \|\| defined __C99__FUNC__ \
1235	\|\| defined __cplusplus \|\| defined _MSC_VER)
1236	static void
1237	yy_symbol_print (FILE yyoutput, int yytype, YYSTYPE const const yyvaluep)
1238	#else
1239	static void
1240	yy_symbol_print (yyoutput, yytype, yyvaluep)
1241	FILE *yyoutput;
1242	int yytype;
1243	YYSTYPE const * const yyvaluep;
1244	#endif
1245	{
1246	if (yytype < YYNTOKENS65)
1247	YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1248	else
1249	YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1250
1251	yy_symbol_value_print (yyoutput, yytype, yyvaluep);
1252	YYFPRINTF (yyoutput, ")");
1253	}
1254
1255	/*------------------------------------------------------------------.
1256	\| yy_stack_print -- Print the state stack from its BOTTOM up to its \|
1257	\| TOP (included). \|
1258	`------------------------------------------------------------------*/
1259
1260	#if (defined __STDC__1 \|\| defined __C99__FUNC__ \
1261	\|\| defined __cplusplus \|\| defined _MSC_VER)
1262	static void
1263	yy_stack_print (yytype_int16 yybottom, yytype_int16 yytop)
1264	#else
1265	static void
1266	yy_stack_print (yybottom, yytop)
1267	yytype_int16 *yybottom;
1268	yytype_int16 *yytop;
1269	#endif
1270	{
1271	YYFPRINTF (stderrstderr, "Stack now");
1272	for (; yybottom <= yytop; yybottom++)
1273	{
1274	int yybot = *yybottom;
1275	YYFPRINTF (stderrstderr, " %d", yybot);
1276	}
1277	YYFPRINTF (stderrstderr, "\n");
1278	}
1279
1280	# define YY_STACK_PRINT(Bottom, Top) \
1281	do { \
1282	if (yydebug) \
1283	yy_stack_print ((Bottom), (Top)); \
1284	} while (YYID (0)(0))
1285
1286
1287	/*------------------------------------------------.
1288	\| Report that the YYRULE is going to be reduced. \|
1289	`------------------------------------------------*/
1290
1291	#if (defined __STDC__1 \|\| defined __C99__FUNC__ \
1292	\|\| defined __cplusplus \|\| defined _MSC_VER)
1293	static void
1294	yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1295	#else
1296	static void
1297	yy_reduce_print (yyvsp, yyrule)
1298	YYSTYPE *yyvsp;
1299	int yyrule;
1300	#endif
1301	{
1302	int yynrhs = yyr2[yyrule];
1303	int yyi;
1304	unsigned long int yylno = yyrline[yyrule];
1305	YYFPRINTF (stderrstderr, "Reducing stack by rule %d (line %lu):\n",
1306	yyrule - 1, yylno);
1307	/* The symbols being reduced. */
1308	for (yyi = 0; yyi < yynrhs; yyi++)
1309	{
1310	YYFPRINTF (stderrstderr, " $%d = ", yyi + 1);
1311	yy_symbol_print (stderrstderr, yyrhs[yyprhs[yyrule] + yyi],
1312	&(yyvsp[(yyi + 1) - (yynrhs)])
1313	);
1314	YYFPRINTF (stderrstderr, "\n");
1315	}
1316	}
1317
1318	# define YY_REDUCE_PRINT(Rule) \
1319	do { \
1320	if (yydebug) \
1321	yy_reduce_print (yyvsp, Rule); \
1322	} while (YYID (0)(0))
1323
1324	/* Nonzero means print parse trace. It is left uninitialized so that
1325	multiple parsers can coexist. */
1326	int yydebug;
1327	#else /* !YYDEBUG */
1328	# define YYDPRINTF(Args)
1329	# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1330	# define YY_STACK_PRINT(Bottom, Top)
1331	# define YY_REDUCE_PRINT(Rule)
1332	#endif /* !YYDEBUG */
1333
1334
1335	/* YYINITDEPTH -- initial size of the parser's stacks. */
1336	#ifndef YYINITDEPTH200
1337	# define YYINITDEPTH200 200
1338	#endif
1339
1340	/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1341	if the built-in stack extension method is used).
1342
1343	Do not make this value too large; the results are undefined if
1344	YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1345	evaluated with infinite-precision integer arithmetic. */
1346
1347	#ifndef YYMAXDEPTH10000
1348	# define YYMAXDEPTH10000 10000
1349	#endif
1350
1351
1352
1353	#if YYERROR_VERBOSE0
1354
1355	# ifndef yystrlen
1356	# if defined __GLIBC__2 && defined _STRING_H1
1357	# define yystrlen strlen
1358	# else
1359	/* Return the length of YYSTR. */
1360	#if (defined __STDC__1 \|\| defined __C99__FUNC__ \
1361	\|\| defined __cplusplus \|\| defined _MSC_VER)
1362	static YYSIZE_Tlong unsigned int
1363	yystrlen (const char *yystr)
1364	#else
1365	static YYSIZE_Tlong unsigned int
1366	yystrlen (yystr)
1367	const char *yystr;
1368	#endif
1369	{
1370	YYSIZE_Tlong unsigned int yylen;
1371	for (yylen = 0; yystr[yylen]; yylen++)
1372	continue;
1373	return yylen;
1374	}
1375	# endif
1376	# endif
1377
1378	# ifndef yystpcpy
1379	# if defined __GLIBC__2 && defined _STRING_H1 && defined _GNU_SOURCE
1380	# define yystpcpy stpcpy
1381	# else
1382	/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1383	YYDEST. */
1384	#if (defined __STDC__1 \|\| defined __C99__FUNC__ \
1385	\|\| defined __cplusplus \|\| defined _MSC_VER)
1386	static char *
1387	yystpcpy (char yydest, const char yysrc)
1388	#else
1389	static char *
1390	yystpcpy (yydest, yysrc)
1391	char *yydest;
1392	const char *yysrc;
1393	#endif
1394	{
1395	char *yyd = yydest;
1396	const char *yys = yysrc;
1397
1398	while ((yyd++ = yys++) != '\0')
1399	continue;
1400
1401	return yyd - 1;
1402	}
1403	# endif
1404	# endif
1405
1406	# ifndef yytnamerr
1407	/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1408	quotes and backslashes, so that it's suitable for yyerror. The
1409	heuristic is that double-quoting is unnecessary unless the string
1410	contains an apostrophe, a comma, or backslash (other than
1411	backslash-backslash). YYSTR is taken from yytname. If YYRES is
1412	null, do not copy; instead, return the length of what the result
1413	would have been. */
1414	static YYSIZE_Tlong unsigned int
1415	yytnamerr (char yyres, const char yystr)
1416	{
1417	if (*yystr == '"')
1418	{
1419	YYSIZE_Tlong unsigned int yyn = 0;
1420	char const *yyp = yystr;
1421
1422	for (;;)
1423	switch (*++yyp)
1424	{
1425	case '\'':
1426	case ',':
1427	goto do_not_strip_quotes;
1428
1429	case '\\':
1430	if (*++yyp != '\\')
1431	goto do_not_strip_quotes;
1432	/* Fall through. */
1433	default:
1434	if (yyres)
1435	yyres[yyn] = *yyp;
1436	yyn++;
1437	break;
1438
1439	case '"':
1440	if (yyres)
1441	yyres[yyn] = '\0';
1442	return yyn;
1443	}
1444	do_not_strip_quotes: ;
1445	}
1446
1447	if (! yyres)
1448	return yystrlen (yystr);
1449
1450	return yystpcpy (yyres, yystr) - yyres;
1451	}
1452	# endif
1453
1454	/* Copy into YYRESULT an error message about the unexpected token
1455	YYCHAR while in state YYSTATE. Return the number of bytes copied,
1456	including the terminating null byte. If YYRESULT is null, do not
1457	copy anything; just return the number of bytes that would be
1458	copied. As a special case, return 0 if an ordinary "syntax error"
1459	message will do. Return YYSIZE_MAXIMUM if overflow occurs during
1460	size calculation. */
1461	static YYSIZE_Tlong unsigned int
1462	yysyntax_error (char *yyresult, int yystate, int yychar)
1463	{
1464	int yyn = yypact[yystate];
1465
1466	if (! (YYPACT_NINF-188 < yyn && yyn <= YYLAST706))
1467	return 0;
1468	else
1469	{
1470	int yytype = YYTRANSLATE (yychar)((unsigned int) (yychar) <= 257 ? yytranslate[yychar] : 2);
1471	YYSIZE_Tlong unsigned int yysize0 = yytnamerr (0, yytname[yytype]);
1472	YYSIZE_Tlong unsigned int yysize = yysize0;
1473	YYSIZE_Tlong unsigned int yysize1;
1474	int yysize_overflow = 0;
1475	enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1476	char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1477	int yyx;
1478
1479	# if 0
1480	/* This is so xgettext sees the translatable formats that are
1481	constructed on the fly. */
1482	YY_("syntax error, unexpected %s")"syntax error, unexpected %s";
1483	YY_("syntax error, unexpected %s, expecting %s")"syntax error, unexpected %s, expecting %s";
1484	YY_("syntax error, unexpected %s, expecting %s or %s")"syntax error, unexpected %s, expecting %s or %s";
1485	YY_("syntax error, unexpected %s, expecting %s or %s or %s")"syntax error, unexpected %s, expecting %s or %s or %s";
1486	YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s")"syntax error, unexpected %s, expecting %s or %s or %s or %s";
1487	# endif
1488	char *yyfmt;
1489	char const *yyf;
1490	static char const yyunexpected[] = "syntax error, unexpected %s";
1491	static char const yyexpecting[] = ", expecting %s";
1492	static char const yyor[] = " or %s";
1493	char yyformat[sizeof yyunexpected
1494	+ sizeof yyexpecting - 1
1495	+ ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
1496	* (sizeof yyor - 1))];
1497	char const *yyprefix = yyexpecting;
1498
1499	/* Start YYX at -YYN if negative to avoid negative indexes in
1500	YYCHECK. */
1501	int yyxbegin = yyn < 0 ? -yyn : 0;
1502
1503	/* Stay within bounds of both yycheck and yytname. */
1504	int yychecklim = YYLAST706 - yyn + 1;
1505	int yyxend = yychecklim < YYNTOKENS65 ? yychecklim : YYNTOKENS65;
1506	int yycount = 1;
1507
1508	yyarg[0] = yytname[yytype];
1509	yyfmt = yystpcpy (yyformat, yyunexpected);
1510
1511	for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1512	if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR1)
1513	{
1514	if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1515	{
1516	yycount = 1;
1517	yysize = yysize0;
1518	yyformat[sizeof yyunexpected - 1] = '\0';
1519	break;
1520	}
1521	yyarg[yycount++] = yytname[yyx];
1522	yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1523	yysize_overflow \|= (yysize1 < yysize);
1524	yysize = yysize1;
1525	yyfmt = yystpcpy (yyfmt, yyprefix);
1526	yyprefix = yyor;
1527	}
1528
1529	yyf = YY_(yyformat)yyformat;
1530	yysize1 = yysize + yystrlen (yyf);
1531	yysize_overflow \|= (yysize1 < yysize);
1532	yysize = yysize1;
1533
1534	if (yysize_overflow)
1535	return YYSIZE_MAXIMUM((long unsigned int) -1);
1536
1537	if (yyresult)
1538	{
1539	/* Avoid sprintf, as that infringes on the user's name space.
1540	Don't have undefined behavior even if the translation
1541	produced a string with the wrong number of "%s"s. */
1542	char *yyp = yyresult;
1543	int yyi = 0;
1544	while ((yyp = yyf) != '\0')
1545	{
1546	if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
1547	{
1548	yyp += yytnamerr (yyp, yyarg[yyi++]);
1549	yyf += 2;
1550	}
1551	else
1552	{
1553	yyp++;
1554	yyf++;
1555	}
1556	}
1557	}
1558	return yysize;
1559	}
1560	}
1561	#endif /* YYERROR_VERBOSE */
1562
1563
1564	/*-----------------------------------------------.
1565	\| Release the memory associated to this symbol. \|
1566	`-----------------------------------------------*/
1567
1568	/ARGSUSED/
1569	#if (defined __STDC__1 \|\| defined __C99__FUNC__ \
1570	\|\| defined __cplusplus \|\| defined _MSC_VER)
1571	static void
1572	yydestruct (const char yymsg, int yytype, YYSTYPE yyvaluep)
1573	#else
1574	static void
1575	yydestruct (yymsg, yytype, yyvaluep)
1576	const char *yymsg;
1577	int yytype;
1578	YYSTYPE *yyvaluep;
1579	#endif
1580	{
1581	YYUSE (yyvaluep)((void) (yyvaluep));
1582
1583	if (!yymsg)
1584	yymsg = "Deleting";
	Value stored to 'yymsg' is never read
1585	YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1586
1587	switch (yytype)
1588	{
1589
1590	default:
1591	break;
1592	}
1593	}
1594
1595	/* Prevent warnings from -Wmissing-prototypes. */
1596	#ifdef YYPARSE_PARAM
1597	#if defined __STDC__1 \|\| defined __cplusplus
1598	int yyparse (void *YYPARSE_PARAM);
1599	#else
1600	int yyparse ();
1601	#endif
1602	#else /* ! YYPARSE_PARAM */
1603	#if defined __STDC__1 \|\| defined __cplusplus
1604	int yyparse (void);
1605	#else
1606	int yyparse ();
1607	#endif
1608	#endif /* ! YYPARSE_PARAM */
1609
1610
1611	/* The lookahead symbol. */
1612	int yychar;
1613
1614	/* The semantic value of the lookahead symbol. */
1615	YYSTYPE yylval;
1616
1617	/* Number of syntax errors so far. */
1618	int yynerrs;
1619
1620
1621
1622	/*-------------------------.
1623	\| yyparse or yypush_parse. \|
1624	`-------------------------*/
1625
1626	#ifdef YYPARSE_PARAM
1627	#if (defined __STDC__1 \|\| defined __C99__FUNC__ \
1628	\|\| defined __cplusplus \|\| defined _MSC_VER)
1629	int
1630	yyparse (void *YYPARSE_PARAM)
1631	#else
1632	int
1633	yyparse (YYPARSE_PARAM)
1634	void *YYPARSE_PARAM;
1635	#endif
1636	#else /* ! YYPARSE_PARAM */
1637	#if (defined __STDC__1 \|\| defined __C99__FUNC__ \
1638	\|\| defined __cplusplus \|\| defined _MSC_VER)
1639	int
1640	yyparse (void)
1641	#else
1642	int
1643	yyparse ()
1644
1645	#endif
1646	#endif
1647	{
1648
1649
1650	int yystate;
1651	/* Number of tokens to shift before error messages enabled. */
1652	int yyerrstatus;
1653
1654	/* The stacks and their tools:
1655	`yyss': related to states.
1656	`yyvs': related to semantic values.
1657
1658	Refer to the stacks thru separate pointers, to allow yyoverflow
1659	to reallocate them elsewhere. */
1660
1661	/* The state stack. */
1662	yytype_int16 yyssa[YYINITDEPTH200];
1663	yytype_int16 *yyss;
1664	yytype_int16 *yyssp;
1665
1666	/* The semantic value stack. */
1667	YYSTYPE yyvsa[YYINITDEPTH200];
1668	YYSTYPE *yyvs;
1669	YYSTYPE *yyvsp;
1670
1671	YYSIZE_Tlong unsigned int yystacksize;
1672
1673	int yyn;
1674	int yyresult;
1675	/* Lookahead token as an internal (translated) token number. */
1676	int yytoken;
1677	/* The variables used to return semantic value and location from the
1678	action routines. */
1679	YYSTYPE yyval;
1680
1681	#if YYERROR_VERBOSE0
1682	/* Buffer for error messages, and its allocated size. */
1683	char yymsgbuf[128];
1684	char *yymsg = yymsgbuf;
1685	YYSIZE_Tlong unsigned int yymsg_alloc = sizeof yymsgbuf;
1686	#endif
1687
1688	#define YYPOPSTACK(N)(yyvsp -= (N), yyssp -= (N)) (yyvsp -= (N), yyssp -= (N))
1689
1690	/* The number of symbols on the RHS of the reduced rule.
1691	Keep to zero when no symbol should be popped. */
1692	int yylen = 0;
1693
1694	yytoken = 0;
1695	yyss = yyssa;
1696	yyvs = yyvsa;
1697	yystacksize = YYINITDEPTH200;
1698
1699	YYDPRINTF ((stderr, "Starting parse\n"));
1700
1701	yystate = 0;
1702	yyerrstatus = 0;
1703	yynerrs = 0;
1704	yychar = YYEMPTY(-2); /* Cause a token to be read. */
1705
1706	/* Initialize stack pointers.
1707	Waste one element of value and location stack
1708	so that they stay on the same level as the state stack.
1709	The wasted elements are never initialized. */
1710	yyssp = yyss;
1711	yyvsp = yyvs;
1712
1713	goto yysetstate;
1714
1715	/*------------------------------------------------------------.
1716	\| yynewstate -- Push a new state, which is found in yystate. \|
1717	`------------------------------------------------------------*/
1718	yynewstate:
1719	/* In all cases, when you get here, the value and location stacks
1720	have just been pushed. So pushing a state here evens the stacks. */
1721	yyssp++;
1722
1723	yysetstate:
1724	*yyssp = yystate;
1725
1726	if (yyss + yystacksize - 1 <= yyssp)
1727	{
1728	/* Get the current used size of the three stacks, in elements. */
1729	YYSIZE_Tlong unsigned int yysize = yyssp - yyss + 1;
1730
1731	#ifdef yyoverflow
1732	{
1733	/* Give user a chance to reallocate the stack. Use copies of
1734	these so that the &'s don't force the real ones into
1735	memory. */
1736	YYSTYPE *yyvs1 = yyvs;
1737	yytype_int16 *yyss1 = yyss;
1738
1739	/* Each stack pointer address is followed by the size of the
1740	data in use in that stack, in bytes. This used to be a
1741	conditional around just the two extra args, but that might
1742	be undefined if yyoverflow is a macro. */
1743	yyoverflow (YY_("memory exhausted")"memory exhausted",
1744	&yyss1, yysize * sizeof (*yyssp),
1745	&yyvs1, yysize * sizeof (*yyvsp),
1746	&yystacksize);
1747
1748	yyss = yyss1;
1749	yyvs = yyvs1;
1750	}
1751	#else /* no yyoverflow */
1752	# ifndef YYSTACK_RELOCATE
1753	goto yyexhaustedlab;
1754	# else
1755	/* Extend the stack our own way. */
1756	if (YYMAXDEPTH10000 <= yystacksize)
1757	goto yyexhaustedlab;
1758	yystacksize *= 2;
1759	if (YYMAXDEPTH10000 < yystacksize)
1760	yystacksize = YYMAXDEPTH10000;
1761
1762	{
1763	yytype_int16 *yyss1 = yyss;
1764	union yyalloc *yyptr =
1765	(union yyalloc ) YYSTACK_ALLOCmalloc (YYSTACK_BYTES (yystacksize)((yystacksize) (sizeof (yytype_int16) + sizeof (YYSTYPE)) + (sizeof (union yyalloc) - 1)));
1766	if (! yyptr)
1767	goto yyexhaustedlab;
1768	YYSTACK_RELOCATE (yyss_alloc, yyss);
1769	YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1770	# undef YYSTACK_RELOCATE
1771	if (yyss1 != yyssa)
1772	YYSTACK_FREEfree (yyss1);
1773	}
1774	# endif
1775	#endif /* no yyoverflow */
1776
1777	yyssp = yyss + yysize - 1;
1778	yyvsp = yyvs + yysize - 1;
1779
1780	YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1781	(unsigned long int) yystacksize));
1782
1783	if (yyss + yystacksize - 1 <= yyssp)
1784	YYABORTgoto yyabortlab;
1785	}
1786
1787	YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1788
1789	if (yystate == YYFINAL18)
1790	YYACCEPTgoto yyacceptlab;
1791
1792	goto yybackup;
1793
1794	/*-----------.
1795	\| yybackup. \|
1796	`-----------*/
1797	yybackup:
1798
1799	/* Do appropriate processing given the current state. Read a
1800	lookahead token if we need one and don't already have one. */
1801
1802	/* First try to decide what to do without reference to lookahead token. */
1803	yyn = yypact[yystate];
1804	if (yyn == YYPACT_NINF-188)
1805	goto yydefault;
1806
1807	/* Not known => get a lookahead token if don't already have one. */
1808
1809	/* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1810	if (yychar == YYEMPTY(-2))
1811	{
1812	YYDPRINTF ((stderr, "Reading a token: "));
1813	yychar = YYLEXyylex ();
1814	}
1815
1816	if (yychar <= YYEOF0)
1817	{
1818	yychar = yytoken = YYEOF0;
1819	YYDPRINTF ((stderr, "Now at end of input.\n"));
1820	}
1821	else
1822	{
1823	yytoken = YYTRANSLATE (yychar)((unsigned int) (yychar) <= 257 ? yytranslate[yychar] : 2);
1824	YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1825	}
1826
1827	/* If the proper action on seeing token YYTOKEN is to reduce or to
1828	detect an error, take that action. */
1829	yyn += yytoken;
1830	if (yyn < 0 \|\| YYLAST706 < yyn \|\| yycheck[yyn] != yytoken)
1831	goto yydefault;
1832	yyn = yytable[yyn];
1833	if (yyn <= 0)
1834	{
1835	if (yyn == 0 \|\| yyn == YYTABLE_NINF-180)
1836	goto yyerrlab;
1837	yyn = -yyn;
1838	goto yyreduce;
1839	}
1840
1841	/* Count tokens shifted since error; after three, turn off error
1842	status. */
1843	if (yyerrstatus)
1844	yyerrstatus--;
1845
1846	/* Shift the lookahead token. */
1847	YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1848
1849	/* Discard the shifted token. */
1850	yychar = YYEMPTY(-2);
1851
1852	yystate = yyn;
1853	*++yyvsp = yylval;
1854
1855	goto yynewstate;
1856
1857
1858	/*-----------------------------------------------------------.
1859	\| yydefault -- do the default action for the current state. \|
1860	`-----------------------------------------------------------*/
1861	yydefault:
1862	yyn = yydefact[yystate];
1863	if (yyn == 0)
1864	goto yyerrlab;
1865	goto yyreduce;
1866
1867
1868	/*-----------------------------.
1869	\| yyreduce -- Do a reduction. \|
1870	`-----------------------------*/
1871	yyreduce:
1872	/* yyn is the number of a rule to reduce with. */
1873	yylen = yyr2[yyn];
1874
1875	/* If YYLEN is nonzero, implement the default value of the action:
1876	`$$ = $1'.
1877
1878	Otherwise, the following line sets YYVAL to garbage.
1879	This behavior is undocumented and Bison
1880	users should not rely upon it. Assigning to YYVAL
1881	unconditionally makes the parser a bit smaller, and it avoids a
1882	GCC warning that YYVAL may be used uninitialized. */
1883	yyval = yyvsp[1-yylen];
1884
1885
1886	YY_REDUCE_PRINT (yyn);
1887	switch (yyn)
1888	{
1889	case 2:
1890
1891	/* Line 1464 of yacc.c */
1892	#line 169 "xkbparse.y"
1893	{ (yyval.file)= rtrnValue= (yyvsp[(1) - (1)].file); }
1894	break;
1895
1896	case 3:
1897
1898	/* Line 1464 of yacc.c */
1899	#line 171 "xkbparse.y"
1900	{ (yyval.file)= rtrnValue= (yyvsp[(1) - (1)].file); }
1901	break;
1902
1903	case 4:
1904
1905	/* Line 1464 of yacc.c */
1906	#line 173 "xkbparse.y"
1907	{ (yyval.file)= rtrnValue= (yyvsp[(1) - (1)].file); }
1908	break;
1909
1910	case 5:
1911
1912	/* Line 1464 of yacc.c */
1913	#line 177 "xkbparse.y"
1914	{ (yyval.file)= (XkbFile *)AppendStmt(&(yyvsp[(1) - (2)].file)->common,&(yyvsp[(2) - (2)].file)->common); }
1915	break;
1916
1917	case 6:
1918
1919	/* Line 1464 of yacc.c */
1920	#line 179 "xkbparse.y"
1921	{ (yyval.file)= (yyvsp[(1) - (1)].file); }
1922	break;
1923
1924	case 7:
1925
1926	/* Line 1464 of yacc.c */
1927	#line 185 "xkbparse.y"
1928	{ (yyval.file)= CreateXKBFile((yyvsp[(2) - (7)].uval),(yyvsp[(3) - (7)].str),&(yyvsp[(5) - (7)].file)->common,(yyvsp[(1) - (7)].uval)); }
1929	break;
1930
1931	case 8:
1932
1933	/* Line 1464 of yacc.c */
1934	#line 188 "xkbparse.y"
1935	{ (yyval.uval)= XkmKeymapFile22; }
1936	break;
1937
1938	case 9:
1939
1940	/* Line 1464 of yacc.c */
1941	#line 189 "xkbparse.y"
1942	{ (yyval.uval)= XkmSemanticsFile20; }
1943	break;
1944
1945	case 10:
1946
1947	/* Line 1464 of yacc.c */
1948	#line 190 "xkbparse.y"
1949	{ (yyval.uval)= XkmLayoutFile21; }
1950	break;
1951
1952	case 11:
1953
1954	/* Line 1464 of yacc.c */
1955	#line 194 "xkbparse.y"
1956	{ (yyval.file)= (XkbFile *)AppendStmt(&(yyvsp[(1) - (2)].file)->common,&(yyvsp[(2) - (2)].file)->common); }
1957	break;
1958
1959	case 12:
1960
1961	/* Line 1464 of yacc.c */
1962	#line 196 "xkbparse.y"
1963	{ (yyval.file)= (yyvsp[(1) - (1)].file); }
1964	break;
1965
1966	case 13:
1967
1968	/* Line 1464 of yacc.c */
1969	#line 202 "xkbparse.y"
1970	{ (yyval.file)= CreateXKBFile((yyvsp[(2) - (7)].uval),(yyvsp[(3) - (7)].str),(yyvsp[(5) - (7)].any),(yyvsp[(1) - (7)].uval)); }
1971	break;
1972
1973	case 14:
1974
1975	/* Line 1464 of yacc.c */
1976	#line 206 "xkbparse.y"
1977	{ (yyval.file)= CreateXKBFile((yyvsp[(2) - (4)].uval),(yyvsp[(3) - (4)].str),(yyvsp[(4) - (4)].any),(yyvsp[(1) - (4)].uval)); }
1978	break;
1979
1980	case 15:
1981
1982	/* Line 1464 of yacc.c */
1983	#line 210 "xkbparse.y"
1984	{ (yyval.uval)= XkmKeyNamesIndex4; }
1985	break;
1986
1987	case 16:
1988
1989	/* Line 1464 of yacc.c */
1990	#line 211 "xkbparse.y"
1991	{ (yyval.uval)= XkmTypesIndex0; }
1992	break;
1993
1994	case 17:
1995
1996	/* Line 1464 of yacc.c */
1997	#line 212 "xkbparse.y"
1998	{ (yyval.uval)= XkmCompatMapIndex1; }
1999	break;
2000
2001	case 18:
2002
2003	/* Line 1464 of yacc.c */
2004	#line 213 "xkbparse.y"
2005	{ (yyval.uval)= XkmSymbolsIndex2; }
2006	break;
2007
2008	case 19:
2009
2010	/* Line 1464 of yacc.c */
2011	#line 214 "xkbparse.y"
2012	{ (yyval.uval)= XkmGeometryIndex5; }
2013	break;
2014
2015	case 20:
2016
2017	/* Line 1464 of yacc.c */
2018	#line 217 "xkbparse.y"
2019	{ (yyval.uval)= (yyvsp[(1) - (1)].uval); }
2020	break;
2021
2022	case 21:
2023
2024	/* Line 1464 of yacc.c */
2025	#line 218 "xkbparse.y"
2026	{ (yyval.uval)= 0; }
2027	break;
2028
2029	case 22:
2030
2031	/* Line 1464 of yacc.c */
2032	#line 221 "xkbparse.y"
2033	{ (yyval.uval)= (((yyvsp[(1) - (2)].uval))\|((yyvsp[(2) - (2)].uval))); }
2034	break;
2035
2036	case 23:
2037
2038	/* Line 1464 of yacc.c */
2039	#line 222 "xkbparse.y"
2040	{ (yyval.uval)= (yyvsp[(1) - (1)].uval); }
2041	break;
2042
2043	case 24:
2044
2045	/* Line 1464 of yacc.c */
2046	#line 225 "xkbparse.y"
2047	{ (yyval.uval)= XkbLC_Partial(1L << 2); }
2048	break;
2049
2050	case 25:
2051
2052	/* Line 1464 of yacc.c */
2053	#line 226 "xkbparse.y"
2054	{ (yyval.uval)= XkbLC_Default(1L << 1); }
2055	break;
2056
2057	case 26:
2058
2059	/* Line 1464 of yacc.c */
2060	#line 227 "xkbparse.y"
2061	{ (yyval.uval)= XkbLC_Hidden(1L << 0); }
2062	break;
2063
2064	case 27:
2065
2066	/* Line 1464 of yacc.c */
2067	#line 228 "xkbparse.y"
2068	{ (yyval.uval)= XkbLC_AlphanumericKeys(1L << 8); }
2069	break;
2070
2071	case 28:
2072
2073	/* Line 1464 of yacc.c */
2074	#line 229 "xkbparse.y"
2075	{ (yyval.uval)= XkbLC_ModifierKeys(1L << 9); }
2076	break;
2077
2078	case 29:
2079
2080	/* Line 1464 of yacc.c */
2081	#line 230 "xkbparse.y"
2082	{ (yyval.uval)= XkbLC_KeypadKeys(1L << 10); }
2083	break;
2084
2085	case 30:
2086
2087	/* Line 1464 of yacc.c */
2088	#line 231 "xkbparse.y"
2089	{ (yyval.uval)= XkbLC_FunctionKeys(1L << 11); }
2090	break;
2091
2092	case 31:
2093
2094	/* Line 1464 of yacc.c */
2095	#line 232 "xkbparse.y"
2096	{ (yyval.uval)= XkbLC_AlternateGroup(1L << 12); }
2097	break;
2098
2099	case 32:
2100
2101	/* Line 1464 of yacc.c */
2102	#line 236 "xkbparse.y"
2103	{ (yyval.any)= AppendStmt((yyvsp[(1) - (2)].any),(yyvsp[(2) - (2)].any)); }
2104	break;
2105
2106	case 33:
2107
2108	/* Line 1464 of yacc.c */
2109	#line 237 "xkbparse.y"
2110	{ (yyval.any)= NULL((void*)0); }
2111	break;
2112
2113	case 34:
2114
2115	/* Line 1464 of yacc.c */
2116	#line 241 "xkbparse.y"
2117	{
2118	(yyvsp[(2) - (2)].var)->merge= StmtSetMerge(&(yyvsp[(2) - (2)].var)->common,(yyvsp[(1) - (2)].uval));
2119	(yyval.any)= &(yyvsp[(2) - (2)].var)->common;
2120	}
2121	break;
2122
2123	case 35:
2124
2125	/* Line 1464 of yacc.c */
2126	#line 246 "xkbparse.y"
2127	{
2128	(yyvsp[(2) - (2)].vmod)->merge= StmtSetMerge(&(yyvsp[(2) - (2)].vmod)->common,(yyvsp[(1) - (2)].uval));
2129	(yyval.any)= &(yyvsp[(2) - (2)].vmod)->common;
2130	}
2131	break;
2132
2133	case 36:
2134
2135	/* Line 1464 of yacc.c */
2136	#line 251 "xkbparse.y"
2137	{
2138	(yyvsp[(2) - (2)].interp)->merge= StmtSetMerge(&(yyvsp[(2) - (2)].interp)->common,(yyvsp[(1) - (2)].uval));
2139	(yyval.any)= &(yyvsp[(2) - (2)].interp)->common;
2140	}
2141	break;
2142
2143	case 37:
2144
2145	/* Line 1464 of yacc.c */
2146	#line 256 "xkbparse.y"
2147	{
2148	(yyvsp[(2) - (2)].keyName)->merge= StmtSetMerge(&(yyvsp[(2) - (2)].keyName)->common,(yyvsp[(1) - (2)].uval));
2149	(yyval.any)= &(yyvsp[(2) - (2)].keyName)->common;
2150	}
2151	break;
2152
2153	case 38:
2154
2155	/* Line 1464 of yacc.c */
2156	#line 261 "xkbparse.y"
2157	{
2158	(yyvsp[(2) - (2)].keyAlias)->merge= StmtSetMerge(&(yyvsp[(2) - (2)].keyAlias)->common,(yyvsp[(1) - (2)].uval));
2159	(yyval.any)= &(yyvsp[(2) - (2)].keyAlias)->common;
2160	}
2161	break;
2162
2163	case 39:
2164
2165	/* Line 1464 of yacc.c */
2166	#line 266 "xkbparse.y"
2167	{
2168	(yyvsp[(2) - (2)].keyType)->merge= StmtSetMerge(&(yyvsp[(2) - (2)].keyType)->common,(yyvsp[(1) - (2)].uval));
2169	(yyval.any)= &(yyvsp[(2) - (2)].keyType)->common;
2170	}
2171	break;
2172
2173	case 40:
2174
2175	/* Line 1464 of yacc.c */
2176	#line 271 "xkbparse.y"
2177	{
2178	(yyvsp[(2) - (2)].syms)->merge= StmtSetMerge(&(yyvsp[(2) - (2)].syms)->common,(yyvsp[(1) - (2)].uval));
2179	(yyval.any)= &(yyvsp[(2) - (2)].syms)->common;
2180	}
2181	break;
2182
2183	case 41:
2184
2185	/* Line 1464 of yacc.c */
2186	#line 276 "xkbparse.y"
2187	{
2188	(yyvsp[(2) - (2)].modMask)->merge= StmtSetMerge(&(yyvsp[(2) - (2)].modMask)->common,(yyvsp[(1) - (2)].uval));
2189	(yyval.any)= &(yyvsp[(2) - (2)].modMask)->common;
2190	}
2191	break;
2192
2193	case 42:
2194
2195	/* Line 1464 of yacc.c */
2196	#line 281 "xkbparse.y"
2197	{
2198	(yyvsp[(2) - (2)].groupCompat)->merge= StmtSetMerge(&(yyvsp[(2) - (2)].groupCompat)->common,(yyvsp[(1) - (2)].uval));
2199	(yyval.any)= &(yyvsp[(2) - (2)].groupCompat)->common;
2200	}
2201	break;
2202
2203	case 43:
2204
2205	/* Line 1464 of yacc.c */
2206	#line 286 "xkbparse.y"
2207	{
2208	(yyvsp[(2) - (2)].ledMap)->merge= StmtSetMerge(&(yyvsp[(2) - (2)].ledMap)->common,(yyvsp[(1) - (2)].uval));
2209	(yyval.any)= &(yyvsp[(2) - (2)].ledMap)->common;
2210	}
2211	break;
2212
2213	case 44:
2214
2215	/* Line 1464 of yacc.c */
2216	#line 291 "xkbparse.y"
2217	{
2218	(yyvsp[(2) - (2)].ledName)->merge= StmtSetMerge(&(yyvsp[(2) - (2)].ledName)->common,(yyvsp[(1) - (2)].uval));
2219	(yyval.any)= &(yyvsp[(2) - (2)].ledName)->common;
2220	}
2221	break;
2222
2223	case 45:
2224
2225	/* Line 1464 of yacc.c */
2226	#line 296 "xkbparse.y"
2227	{
2228	(yyvsp[(2) - (2)].shape)->merge= StmtSetMerge(&(yyvsp[(2) - (2)].shape)->common,(yyvsp[(1) - (2)].uval));
2229	(yyval.any)= &(yyvsp[(2) - (2)].shape)->common;
2230	}
2231	break;
2232
2233	case 46:
2234
2235	/* Line 1464 of yacc.c */
2236	#line 301 "xkbparse.y"
2237	{
2238	(yyvsp[(2) - (2)].section)->merge= StmtSetMerge(&(yyvsp[(2) - (2)].section)->common,(yyvsp[(1) - (2)].uval));
2239	(yyval.any)= &(yyvsp[(2) - (2)].section)->common;
2240	}
2241	break;
2242
2243	case 47:
2244
2245	/* Line 1464 of yacc.c */
2246	#line 306 "xkbparse.y"
2247	{
2248	(yyvsp[(2) - (2)].doodad)->merge= StmtSetMerge(&(yyvsp[(2) - (2)].doodad)->common,(yyvsp[(1) - (2)].uval));
2249	(yyval.any)= &(yyvsp[(2) - (2)].doodad)->common;
2250	}
2251	break;
2252
2253	case 48:
2254
2255	/* Line 1464 of yacc.c */
2256	#line 311 "xkbparse.y"
2257	{
2258	if ((yyvsp[(1) - (2)].uval)==MergeAltForm4) {
2259	yyerror("cannot use 'alternate' to include other maps");
2260	(yyval.any)= &IncludeCreate(scanBuf,MergeDefault0)->common;
2261	}
2262	else {
2263	(yyval.any)= &IncludeCreate(scanBuf,(yyvsp[(1) - (2)].uval))->common;
2264	}
2265	}
2266	break;
2267
2268	case 49:
2269
2270	/* Line 1464 of yacc.c */
2271	#line 323 "xkbparse.y"
2272	{ (yyval.var)= VarCreate((yyvsp[(1) - (4)].expr),(yyvsp[(3) - (4)].expr)); }
2273	break;
2274
2275	case 50:
2276
2277	/* Line 1464 of yacc.c */
2278	#line 325 "xkbparse.y"
2279	{ (yyval.var)= BoolVarCreate((yyvsp[(1) - (2)].sval),1); }
2280	break;
2281
2282	case 51:
2283
2284	/* Line 1464 of yacc.c */
2285	#line 327 "xkbparse.y"
2286	{ (yyval.var)= BoolVarCreate((yyvsp[(2) - (3)].sval),0); }
2287	break;
2288
2289	case 52:
2290
2291	/* Line 1464 of yacc.c */
2292	#line 331 "xkbparse.y"
2293	{
2294	KeycodeDef *def;
2295
2296	def= KeycodeCreate((yyvsp[(1) - (4)].str),(yyvsp[(3) - (4)].expr));
2297	if ((yyvsp[(1) - (4)].str))
2298	free((yyvsp[(1) - (4)].str));
2299	(yyval.keyName)= def;
2300	}
2301	break;
2302
2303	case 53:
2304
2305	/* Line 1464 of yacc.c */
2306	#line 342 "xkbparse.y"
2307	{
2308	KeyAliasDef *def;
2309	def= KeyAliasCreate((yyvsp[(2) - (5)].str),(yyvsp[(4) - (5)].str));
2310	if ((yyvsp[(2) - (5)].str)) free((yyvsp[(2) - (5)].str));
2311	if ((yyvsp[(4) - (5)].str)) free((yyvsp[(4) - (5)].str));
2312	(yyval.keyAlias)= def;
2313	}
2314	break;
2315
2316	case 54:
2317
2318	/* Line 1464 of yacc.c */
2319	#line 352 "xkbparse.y"
2320	{ (yyval.vmod)= (yyvsp[(2) - (3)].vmod); }
2321	break;
2322
2323	case 55:
2324
2325	/* Line 1464 of yacc.c */
2326	#line 356 "xkbparse.y"
2327	{ (yyval.vmod)= (VModDef *)AppendStmt(&(yyvsp[(1) - (3)].vmod)->common,&(yyvsp[(3) - (3)].vmod)->common); }
2328	break;
2329
2330	case 56:
2331
2332	/* Line 1464 of yacc.c */
2333	#line 358 "xkbparse.y"
2334	{ (yyval.vmod)= (yyvsp[(1) - (1)].vmod); }
2335	break;
2336
2337	case 57:
2338
2339	/* Line 1464 of yacc.c */
2340	#line 362 "xkbparse.y"
2341	{ (yyval.vmod)= VModCreate((yyvsp[(1) - (1)].sval),NULL((void*)0)); }
2342	break;
2343
2344	case 58:
2345
2346	/* Line 1464 of yacc.c */
2347	#line 364 "xkbparse.y"
2348	{ (yyval.vmod)= VModCreate((yyvsp[(1) - (3)].sval),(yyvsp[(3) - (3)].expr)); }
2349	break;
2350
2351	case 59:
2352
2353	/* Line 1464 of yacc.c */
2354	#line 370 "xkbparse.y"
2355	{
2356	(yyvsp[(2) - (6)].interp)->def= (yyvsp[(4) - (6)].var);
2357	(yyval.interp)= (yyvsp[(2) - (6)].interp);
2358	}
2359	break;
2360
2361	case 60:
2362
2363	/* Line 1464 of yacc.c */
2364	#line 377 "xkbparse.y"
2365	{ (yyval.interp)= InterpCreate((yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].expr)); }
2366	break;
2367
2368	case 61:
2369
2370	/* Line 1464 of yacc.c */
2371	#line 379 "xkbparse.y"
2372	{ (yyval.interp)= InterpCreate((yyvsp[(1) - (1)].str), NULL((void*)0)); }
2373	break;
2374
2375	case 62:
2376
2377	/* Line 1464 of yacc.c */
2378	#line 383 "xkbparse.y"
2379	{ (yyval.var)= (VarDef *)AppendStmt(&(yyvsp[(1) - (2)].var)->common,&(yyvsp[(2) - (2)].var)->common); }
2380	break;
2381
2382	case 63:
2383
2384	/* Line 1464 of yacc.c */
2385	#line 385 "xkbparse.y"
2386	{ (yyval.var)= (yyvsp[(1) - (1)].var); }
2387	break;
2388
2389	case 64:
2390
2391	/* Line 1464 of yacc.c */
2392	#line 391 "xkbparse.y"
2393	{ (yyval.keyType)= KeyTypeCreate((yyvsp[(2) - (6)].sval),(yyvsp[(4) - (6)].var)); }
2394	break;
2395
2396	case 65:
2397
2398	/* Line 1464 of yacc.c */
2399	#line 397 "xkbparse.y"
2400	{ (yyval.syms)= SymbolsCreate((yyvsp[(2) - (6)].str),(ExprDef *)(yyvsp[(4) - (6)].var)); }
2401	break;
2402
2403	case 66:
2404
2405	/* Line 1464 of yacc.c */
2406	#line 401 "xkbparse.y"
2407	{ (yyval.var)= (VarDef *)AppendStmt(&(yyvsp[(1) - (3)].var)->common,&(yyvsp[(3) - (3)].var)->common); }
2408	break;
2409
2410	case 67:
2411
2412	/* Line 1464 of yacc.c */
2413	#line 403 "xkbparse.y"
2414	{ (yyval.var)= (yyvsp[(1) - (1)].var); }
2415	break;
2416
2417	case 68:
2418
2419	/* Line 1464 of yacc.c */
2420	#line 404 "xkbparse.y"
2421	{ (yyval.var)= NULL((void*)0); }
2422	break;
2423
2424	case 69:
2425
2426	/* Line 1464 of yacc.c */
2427	#line 408 "xkbparse.y"
2428	{ (yyval.var)= VarCreate((yyvsp[(1) - (3)].expr),(yyvsp[(3) - (3)].expr)); }
2429	break;
2430
2431	case 70:
2432
2433	/* Line 1464 of yacc.c */
2434	#line 410 "xkbparse.y"
2435	{ (yyval.var)= VarCreate((yyvsp[(1) - (3)].expr),(yyvsp[(3) - (3)].expr)); }
2436	break;
2437
2438	case 71:
2439
2440	/* Line 1464 of yacc.c */
2441	#line 412 "xkbparse.y"
2442	{ (yyval.var)= BoolVarCreate((yyvsp[(1) - (1)].sval),1); }
2443	break;
2444
2445	case 72:
2446
2447	/* Line 1464 of yacc.c */
2448	#line 414 "xkbparse.y"
2449	{ (yyval.var)= BoolVarCreate((yyvsp[(2) - (2)].sval),0); }
2450	break;
2451
2452	case 73:
2453
2454	/* Line 1464 of yacc.c */
2455	#line 416 "xkbparse.y"
2456	{ (yyval.var)= VarCreate(NULL((void*)0),(yyvsp[(1) - (1)].expr)); }
2457	break;
2458
2459	case 74:
2460
2461	/* Line 1464 of yacc.c */
2462	#line 420 "xkbparse.y"
2463	{ (yyval.expr)= (yyvsp[(2) - (3)].expr); }
2464	break;
2465
2466	case 75:
2467
2468	/* Line 1464 of yacc.c */
2469	#line 422 "xkbparse.y"
2470	{ (yyval.expr)= ExprCreateUnary(ExprActionList6,TypeAction5,(yyvsp[(2) - (3)].expr)); }
2471	break;
2472
2473	case 76:
2474
2475	/* Line 1464 of yacc.c */
2476	#line 426 "xkbparse.y"
2477	{ (yyval.groupCompat)= GroupCompatCreate((yyvsp[(2) - (5)].ival),(yyvsp[(4) - (5)].expr)); }
2478	break;
2479
2480	case 77:
2481
2482	/* Line 1464 of yacc.c */
2483	#line 430 "xkbparse.y"
2484	{ (yyval.modMask)= ModMapCreate((yyvsp[(2) - (6)].sval),(yyvsp[(4) - (6)].expr)); }
2485	break;
2486
2487	case 78:
2488
2489	/* Line 1464 of yacc.c */
2490	#line 434 "xkbparse.y"
2491	{ (yyval.ledMap)= IndicatorMapCreate((yyvsp[(2) - (6)].sval),(yyvsp[(4) - (6)].var)); }
2492	break;
2493
2494	case 79:
2495
2496	/* Line 1464 of yacc.c */
2497	#line 438 "xkbparse.y"
2498	{ (yyval.ledName)= IndicatorNameCreate((yyvsp[(2) - (5)].ival),(yyvsp[(4) - (5)].expr),False0); }
2499	break;
2500
2501	case 80:
2502
2503	/* Line 1464 of yacc.c */
2504	#line 440 "xkbparse.y"
2505	{ (yyval.ledName)= IndicatorNameCreate((yyvsp[(3) - (6)].ival),(yyvsp[(5) - (6)].expr),True1); }
2506	break;
2507
2508	case 81:
2509
2510	/* Line 1464 of yacc.c */
2511	#line 444 "xkbparse.y"
2512	{ (yyval.shape)= ShapeDeclCreate((yyvsp[(2) - (6)].sval),(OutlineDef *)&(yyvsp[(4) - (6)].outline)->common); }
2513	break;
2514
2515	case 82:
2516
2517	/* Line 1464 of yacc.c */
2518	#line 446 "xkbparse.y"
2519	{
2520	OutlineDef *outlines;
2521	outlines= OutlineCreate(None0L,(yyvsp[(4) - (6)].expr));
2522	(yyval.shape)= ShapeDeclCreate((yyvsp[(2) - (6)].sval),outlines);
2523	}
2524	break;
2525
2526	case 83:
2527
2528	/* Line 1464 of yacc.c */
2529	#line 454 "xkbparse.y"
2530	{ (yyval.section)= SectionDeclCreate((yyvsp[(2) - (6)].sval),(yyvsp[(4) - (6)].row)); }
2531	break;
2532
2533	case 84:
2534
2535	/* Line 1464 of yacc.c */
2536	#line 458 "xkbparse.y"
2537	{ (yyval.row)=(RowDef *)AppendStmt(&(yyvsp[(1) - (2)].row)->common,&(yyvsp[(2) - (2)].row)->common);}
2538	break;
2539
2540	case 85:
2541
2542	/* Line 1464 of yacc.c */
2543	#line 460 "xkbparse.y"
2544	{ (yyval.row)= (yyvsp[(1) - (1)].row); }
2545	break;
2546
2547	case 86:
2548
2549	/* Line 1464 of yacc.c */
2550	#line 464 "xkbparse.y"
2551	{ (yyval.row)= RowDeclCreate((yyvsp[(3) - (5)].key)); }
2552	break;
2553
2554	case 87:
2555
2556	/* Line 1464 of yacc.c */
2557	#line 466 "xkbparse.y"
2558	{ (yyval.row)= (RowDef *)(yyvsp[(1) - (1)].var); }
2559	break;
2560
2561	case 88:
2562
2563	/* Line 1464 of yacc.c */
2564	#line 468 "xkbparse.y"
2565	{ (yyval.row)= (RowDef *)(yyvsp[(1) - (1)].doodad); }
2566	break;
2567
2568	case 89:
2569
2570	/* Line 1464 of yacc.c */
2571	#line 470 "xkbparse.y"
2572	{ (yyval.row)= (RowDef *)(yyvsp[(1) - (1)].ledMap); }
2573	break;
2574
2575	case 90:
2576
2577	/* Line 1464 of yacc.c */
2578	#line 472 "xkbparse.y"
2579	{ (yyval.row)= (RowDef *)(yyvsp[(1) - (1)].overlay); }
2580	break;
2581
2582	case 91:
2583
2584	/* Line 1464 of yacc.c */
2585	#line 476 "xkbparse.y"
2586	{ (yyval.key)=(KeyDef *)AppendStmt(&(yyvsp[(1) - (2)].key)->common,&(yyvsp[(2) - (2)].key)->common);}
2587	break;
2588
2589	case 92:
2590
2591	/* Line 1464 of yacc.c */
2592	#line 478 "xkbparse.y"
2593	{ (yyval.key)= (yyvsp[(1) - (1)].key); }
2594	break;
2595
2596	case 93:
2597
2598	/* Line 1464 of yacc.c */
2599	#line 482 "xkbparse.y"
2600	{ (yyval.key)= (yyvsp[(3) - (5)].key); }
2601	break;
2602
2603	case 94:
2604
2605	/* Line 1464 of yacc.c */
2606	#line 484 "xkbparse.y"
2607	{ (yyval.key)= (KeyDef *)(yyvsp[(1) - (1)].var); }
2608	break;
2609
2610	case 95:
2611
2612	/* Line 1464 of yacc.c */
2613	#line 488 "xkbparse.y"
2614	{ (yyval.key)=(KeyDef *)AppendStmt(&(yyvsp[(1) - (3)].key)->common,&(yyvsp[(3) - (3)].key)->common);}
2615	break;
2616
2617	case 96:
2618
2619	/* Line 1464 of yacc.c */
2620	#line 490 "xkbparse.y"
2621	{ (yyval.key)= (yyvsp[(1) - (1)].key); }
2622	break;
2623
2624	case 97:
2625
2626	/* Line 1464 of yacc.c */
2627	#line 494 "xkbparse.y"
2628	{ (yyval.key)= KeyDeclCreate((yyvsp[(1) - (1)].str),NULL((void*)0)); }
2629	break;
2630
2631	case 98:
2632
2633	/* Line 1464 of yacc.c */
2634	#line 496 "xkbparse.y"
2635	{ (yyval.key)= KeyDeclCreate(NULL((void*)0),(yyvsp[(2) - (3)].expr)); }
2636	break;
2637
2638	case 99:
2639
2640	/* Line 1464 of yacc.c */
2641	#line 500 "xkbparse.y"
2642	{ (yyval.overlay)= OverlayDeclCreate((yyvsp[(2) - (6)].sval),(yyvsp[(4) - (6)].olKey)); }
2643	break;
2644
2645	case 100:
2646
2647	/* Line 1464 of yacc.c */
2648	#line 504 "xkbparse.y"
2649	{
2650	(yyval.olKey)= (OverlayKeyDef *)
2651	AppendStmt(&(yyvsp[(1) - (3)].olKey)->common,&(yyvsp[(3) - (3)].olKey)->common);
2652	}
2653	break;
2654
2655	case 101:
2656
2657	/* Line 1464 of yacc.c */
2658	#line 509 "xkbparse.y"
2659	{ (yyval.olKey)= (yyvsp[(1) - (1)].olKey); }
2660	break;
2661
2662	case 102:
2663
2664	/* Line 1464 of yacc.c */
2665	#line 513 "xkbparse.y"
2666	{ (yyval.olKey)= OverlayKeyCreate((yyvsp[(1) - (3)].str),(yyvsp[(3) - (3)].str)); }
2667	break;
2668
2669	case 103:
2670
2671	/* Line 1464 of yacc.c */
2672	#line 517 "xkbparse.y"
2673	{ (yyval.outline)=(OutlineDef *)AppendStmt(&(yyvsp[(1) - (3)].outline)->common,&(yyvsp[(3) - (3)].outline)->common);}
2674	break;
2675
2676	case 104:
2677
2678	/* Line 1464 of yacc.c */
2679	#line 519 "xkbparse.y"
2680	{ (yyval.outline)= (yyvsp[(1) - (1)].outline); }
2681	break;
2682
2683	case 105:
2684
2685	/* Line 1464 of yacc.c */
2686	#line 523 "xkbparse.y"
2687	{ (yyval.outline)= OutlineCreate(None0L,(yyvsp[(2) - (3)].expr)); }
2688	break;
2689
2690	case 106:
2691
2692	/* Line 1464 of yacc.c */
2693	#line 525 "xkbparse.y"
2694	{ (yyval.outline)= OutlineCreate((yyvsp[(1) - (5)].sval),(yyvsp[(4) - (5)].expr)); }
2695	break;
2696
2697	case 107:
2698
2699	/* Line 1464 of yacc.c */
2700	#line 527 "xkbparse.y"
2701	{ (yyval.outline)= OutlineCreate((yyvsp[(1) - (3)].sval),(yyvsp[(3) - (3)].expr)); }
2702	break;
2703
2704	case 108:
2705
2706	/* Line 1464 of yacc.c */
2707	#line 531 "xkbparse.y"
2708	{ (yyval.expr)= (ExprDef *)AppendStmt(&(yyvsp[(1) - (3)].expr)->common,&(yyvsp[(3) - (3)].expr)->common); }
2709	break;
2710
2711	case 109:
2712
2713	/* Line 1464 of yacc.c */
2714	#line 533 "xkbparse.y"
2715	{ (yyval.expr)= (yyvsp[(1) - (1)].expr); }
2716	break;
2717
2718	case 110:
2719
2720	/* Line 1464 of yacc.c */
2721	#line 537 "xkbparse.y"
2722	{
2723	ExprDef *expr;
2724	expr= ExprCreate(ExprCoord7,TypeUnknown0);
2725	expr->value.coord.x= (yyvsp[(2) - (5)].ival);
2726	expr->value.coord.y= (yyvsp[(4) - (5)].ival);
2727	(yyval.expr)= expr;
2728	}
2729	break;
2730
2731	case 111:
2732
2733	/* Line 1464 of yacc.c */
2734	#line 547 "xkbparse.y"
2735	{ (yyval.doodad)= DoodadCreate((yyvsp[(1) - (6)].uval),(yyvsp[(2) - (6)].sval),(yyvsp[(4) - (6)].var)); }
2736	break;
2737
2738	case 112:
2739
2740	/* Line 1464 of yacc.c */
2741	#line 550 "xkbparse.y"
2742	{ (yyval.uval)= XkbTextDoodad3; }
2743	break;
2744
2745	case 113:
2746
2747	/* Line 1464 of yacc.c */
2748	#line 551 "xkbparse.y"
2749	{ (yyval.uval)= XkbOutlineDoodad1; }
2750	break;
2751
2752	case 114:
2753
2754	/* Line 1464 of yacc.c */
2755	#line 552 "xkbparse.y"
2756	{ (yyval.uval)= XkbSolidDoodad2; }
2757	break;
2758
2759	case 115:
2760
2761	/* Line 1464 of yacc.c */
2762	#line 553 "xkbparse.y"
2763	{ (yyval.uval)= XkbLogoDoodad5; }
2764	break;
2765
2766	case 116:
2767
2768	/* Line 1464 of yacc.c */
2769	#line 556 "xkbparse.y"
2770	{ (yyval.sval)= (yyvsp[(1) - (1)].sval); }
2771	break;
2772
2773	case 117:
2774
2775	/* Line 1464 of yacc.c */
2776	#line 557 "xkbparse.y"
2777	{ (yyval.sval)= (yyvsp[(1) - (1)].sval); }
2778	break;
2779
2780	case 118:
2781
2782	/* Line 1464 of yacc.c */
2783	#line 561 "xkbparse.y"
2784	{ (yyval.sval)= XkbInternAtom(NULL((void*)0),"action",False0); }
2785	break;
2786
2787	case 119:
2788
2789	/* Line 1464 of yacc.c */
2790	#line 563 "xkbparse.y"
2791	{ (yyval.sval)= XkbInternAtom(NULL((void*)0),"interpret",False0); }
2792	break;
2793
2794	case 120:
2795
2796	/* Line 1464 of yacc.c */
2797	#line 565 "xkbparse.y"
2798	{ (yyval.sval)= XkbInternAtom(NULL((void*)0),"type",False0); }
2799	break;
2800
2801	case 121:
2802
2803	/* Line 1464 of yacc.c */
2804	#line 567 "xkbparse.y"
2805	{ (yyval.sval)= XkbInternAtom(NULL((void*)0),"key",False0); }
2806	break;
2807
2808	case 122:
2809
2810	/* Line 1464 of yacc.c */
2811	#line 569 "xkbparse.y"
2812	{ (yyval.sval)= XkbInternAtom(NULL((void*)0),"group",False0); }
2813	break;
2814
2815	case 123:
2816
2817	/* Line 1464 of yacc.c */
2818	#line 571 "xkbparse.y"
2819	{(yyval.sval)=XkbInternAtom(NULL((void*)0),"modifier_map",False0);}
2820	break;
2821
2822	case 124:
2823
2824	/* Line 1464 of yacc.c */
2825	#line 573 "xkbparse.y"
2826	{ (yyval.sval)= XkbInternAtom(NULL((void*)0),"indicator",False0); }
2827	break;
2828
2829	case 125:
2830
2831	/* Line 1464 of yacc.c */
2832	#line 575 "xkbparse.y"
2833	{ (yyval.sval)= XkbInternAtom(NULL((void*)0),"shape",False0); }
2834	break;
2835
2836	case 126:
2837
2838	/* Line 1464 of yacc.c */
2839	#line 577 "xkbparse.y"
2840	{ (yyval.sval)= XkbInternAtom(NULL((void*)0),"row",False0); }
2841	break;
2842
2843	case 127:
2844
2845	/* Line 1464 of yacc.c */
2846	#line 579 "xkbparse.y"
2847	{ (yyval.sval)= XkbInternAtom(NULL((void*)0),"section",False0); }
2848	break;
2849
2850	case 128:
2851
2852	/* Line 1464 of yacc.c */
2853	#line 581 "xkbparse.y"
2854	{ (yyval.sval)= XkbInternAtom(NULL((void*)0),"text",False0); }
2855	break;
2856
2857	case 129:
2858
2859	/* Line 1464 of yacc.c */
2860	#line 584 "xkbparse.y"
2861	{ (yyval.uval)= (yyvsp[(1) - (1)].uval); }
2862	break;
2863
2864	case 130:
2865
2866	/* Line 1464 of yacc.c */
2867	#line 585 "xkbparse.y"
2868	{ (yyval.uval)= MergeDefault0; }
2869	break;
2870
2871	case 131:
2872
2873	/* Line 1464 of yacc.c */
2874	#line 588 "xkbparse.y"
2875	{ (yyval.uval)= MergeDefault0; }
2876	break;
2877
2878	case 132:
2879
2880	/* Line 1464 of yacc.c */
2881	#line 589 "xkbparse.y"
2882	{ (yyval.uval)= MergeAugment1; }
2883	break;
2884
2885	case 133:
2886
2887	/* Line 1464 of yacc.c */
2888	#line 590 "xkbparse.y"
2889	{ (yyval.uval)= MergeOverride2; }
2890	break;
2891
2892	case 134:
2893
2894	/* Line 1464 of yacc.c */
2895	#line 591 "xkbparse.y"
2896	{ (yyval.uval)= MergeReplace3; }
2897	break;
2898
2899	case 135:
2900
2901	/* Line 1464 of yacc.c */
2902	#line 592 "xkbparse.y"
2903	{ (yyval.uval)= MergeAltForm4; }
2904	break;
2905
2906	case 136:
2907
2908	/* Line 1464 of yacc.c */
2909	#line 595 "xkbparse.y"
2910	{ (yyval.expr)= (yyvsp[(1) - (1)].expr); }
2911	break;
2912
2913	case 137:
2914
2915	/* Line 1464 of yacc.c */
2916	#line 596 "xkbparse.y"
2917	{ (yyval.expr)= NULL((void*)0); }
2918	break;
2919
2920	case 138:
2921
2922	/* Line 1464 of yacc.c */
2923	#line 600 "xkbparse.y"
2924	{ (yyval.expr)= (ExprDef *)AppendStmt(&(yyvsp[(1) - (3)].expr)->common,&(yyvsp[(3) - (3)].expr)->common); }
2925	break;
2926
2927	case 139:
2928
2929	/* Line 1464 of yacc.c */
2930	#line 602 "xkbparse.y"
2931	{ (yyval.expr)= (yyvsp[(1) - (1)].expr); }
2932	break;
2933
2934	case 140:
2935
2936	/* Line 1464 of yacc.c */
2937	#line 606 "xkbparse.y"
2938	{ (yyval.expr)= ExprCreateBinary(OpDivide23,(yyvsp[(1) - (3)].expr),(yyvsp[(3) - (3)].expr)); }
2939	break;
2940
2941	case 141:
2942
2943	/* Line 1464 of yacc.c */
2944	#line 608 "xkbparse.y"
2945	{ (yyval.expr)= ExprCreateBinary(OpAdd20,(yyvsp[(1) - (3)].expr),(yyvsp[(3) - (3)].expr)); }
2946	break;
2947
2948	case 142:
2949
2950	/* Line 1464 of yacc.c */
2951	#line 610 "xkbparse.y"
2952	{ (yyval.expr)= ExprCreateBinary(OpSubtract21,(yyvsp[(1) - (3)].expr),(yyvsp[(3) - (3)].expr)); }
2953	break;
2954
2955	case 143:
2956
2957	/* Line 1464 of yacc.c */
2958	#line 612 "xkbparse.y"
2959	{ (yyval.expr)= ExprCreateBinary(OpMultiply22,(yyvsp[(1) - (3)].expr),(yyvsp[(3) - (3)].expr)); }
2960	break;
2961
2962	case 144:
2963
2964	/* Line 1464 of yacc.c */
2965	#line 614 "xkbparse.y"
2966	{ (yyval.expr)= ExprCreateBinary(OpAssign24,(yyvsp[(1) - (3)].expr),(yyvsp[(3) - (3)].expr)); }
2967	break;
2968
2969	case 145:
2970
2971	/* Line 1464 of yacc.c */
2972	#line 616 "xkbparse.y"
2973	{ (yyval.expr)= (yyvsp[(1) - (1)].expr); }
2974	break;
2975
2976	case 146:
2977
2978	/* Line 1464 of yacc.c */
2979	#line 620 "xkbparse.y"
2980	{ (yyval.expr)= ExprCreateUnary(OpNegate26,(yyvsp[(2) - (2)].expr)->type,(yyvsp[(2) - (2)].expr)); }
2981	break;
2982
2983	case 147:
2984
2985	/* Line 1464 of yacc.c */
2986	#line 622 "xkbparse.y"
2987	{ (yyval.expr)= ExprCreateUnary(OpUnaryPlus28,(yyvsp[(2) - (2)].expr)->type,(yyvsp[(2) - (2)].expr)); }
2988	break;
2989
2990	case 148:
2991
2992	/* Line 1464 of yacc.c */
2993	#line 624 "xkbparse.y"
2994	{ (yyval.expr)= ExprCreateUnary(OpNot25,TypeBoolean1,(yyvsp[(2) - (2)].expr)); }
2995	break;
2996
2997	case 149:
2998
2999	/* Line 1464 of yacc.c */
3000	#line 626 "xkbparse.y"
3001	{ (yyval.expr)= ExprCreateUnary(OpInvert27,(yyvsp[(2) - (2)].expr)->type,(yyvsp[(2) - (2)].expr)); }
3002	break;
3003
3004	case 150:
3005
3006	/* Line 1464 of yacc.c */
3007	#line 628 "xkbparse.y"
3008	{ (yyval.expr)= (yyvsp[(1) - (1)].expr); }
3009	break;
3010
3011	case 151:
3012
3013	/* Line 1464 of yacc.c */
3014	#line 630 "xkbparse.y"
3015	{ (yyval.expr)= ActionCreate((yyvsp[(1) - (4)].sval),(yyvsp[(3) - (4)].expr)); }
3016	break;
3017
3018	case 152:
3019
3020	/* Line 1464 of yacc.c */
3021	#line 632 "xkbparse.y"
3022	{ (yyval.expr)= (yyvsp[(1) - (1)].expr); }
3023	break;
3024
3025	case 153:
3026
3027	/* Line 1464 of yacc.c */
3028	#line 634 "xkbparse.y"
3029	{ (yyval.expr)= (yyvsp[(2) - (3)].expr); }
3030	break;
3031
3032	case 154:
3033
3034	/* Line 1464 of yacc.c */
3035	#line 638 "xkbparse.y"
3036	{ (yyval.expr)= (ExprDef *)AppendStmt(&(yyvsp[(1) - (3)].expr)->common,&(yyvsp[(3) - (3)].expr)->common); }
3037	break;
3038
3039	case 155:
3040
3041	/* Line 1464 of yacc.c */
3042	#line 640 "xkbparse.y"
3043	{ (yyval.expr)= (yyvsp[(1) - (1)].expr); }
3044	break;
3045
3046	case 156:
3047
3048	/* Line 1464 of yacc.c */
3049	#line 644 "xkbparse.y"
3050	{ (yyval.expr)= ActionCreate((yyvsp[(1) - (4)].sval),(yyvsp[(3) - (4)].expr)); }
3051	break;
3052
3053	case 157:
3054
3055	/* Line 1464 of yacc.c */
3056	#line 648 "xkbparse.y"
3057	{
3058	ExprDef *expr;
3059	expr= ExprCreate(ExprIdent1,TypeUnknown0);
3060	expr->value.str= (yyvsp[(1) - (1)].sval);
3061	(yyval.expr)= expr;
3062	}
3063	break;
3064
3065	case 158:
3066
3067	/* Line 1464 of yacc.c */
3068	#line 655 "xkbparse.y"
3069	{
3070	ExprDef *expr;
3071	expr= ExprCreate(ExprFieldRef3,TypeUnknown0);
3072	expr->value.field.element= (yyvsp[(1) - (3)].sval);
3073	expr->value.field.field= (yyvsp[(3) - (3)].sval);
3074	(yyval.expr)= expr;
3075	}
3076	break;
3077
3078	case 159:
3079
3080	/* Line 1464 of yacc.c */
3081	#line 663 "xkbparse.y"
3082	{
3083	ExprDef *expr;
3084	expr= ExprCreate(ExprArrayRef4,TypeUnknown0);
3085	expr->value.array.element= None0L;
3086	expr->value.array.field= (yyvsp[(1) - (4)].sval);
3087	expr->value.array.entry= (yyvsp[(3) - (4)].expr);
3088	(yyval.expr)= expr;
3089	}
3090	break;
3091
3092	case 160:
3093
3094	/* Line 1464 of yacc.c */
3095	#line 672 "xkbparse.y"
3096	{
3097	ExprDef *expr;
3098	expr= ExprCreate(ExprArrayRef4,TypeUnknown0);
3099	expr->value.array.element= (yyvsp[(1) - (6)].sval);
3100	expr->value.array.field= (yyvsp[(3) - (6)].sval);
3101	expr->value.array.entry= (yyvsp[(5) - (6)].expr);
3102	(yyval.expr)= expr;
3103	}
3104	break;
3105
3106	case 161:
3107
3108	/* Line 1464 of yacc.c */
3109	#line 683 "xkbparse.y"
3110	{
3111	ExprDef *expr;
3112	expr= ExprCreate(ExprValue0,TypeString4);
3113	expr->value.str= (yyvsp[(1) - (1)].sval);
3114	(yyval.expr)= expr;
3115	}
3116	break;
3117
3118	case 162:
3119
3120	/* Line 1464 of yacc.c */
3121	#line 690 "xkbparse.y"
3122	{
3123	ExprDef *expr;
3124	expr= ExprCreate(ExprValue0,TypeInt2);
3125	expr->value.ival= (yyvsp[(1) - (1)].ival);
3126	(yyval.expr)= expr;
3127	}
3128	break;
3129
3130	case 163:
3131
3132	/* Line 1464 of yacc.c */
3133	#line 697 "xkbparse.y"
3134	{
3135	ExprDef *expr;
3136	expr= ExprCreate(ExprValue0,TypeFloat3);
3137	expr->value.ival= (yyvsp[(1) - (1)].ival);
3138	(yyval.expr)= expr;
3139	}
3140	break;
3141
3142	case 164:
3143
3144	/* Line 1464 of yacc.c */
3145	#line 704 "xkbparse.y"
3146	{
3147	ExprDef *expr;
3148	expr= ExprCreate(ExprValue0,TypeKeyName6);
3149	memset(expr->value.keyName,0,5);
3150	strncpy(expr->value.keyName,(yyvsp[(1) - (1)].str),4);
3151	free((yyvsp[(1) - (1)].str));
3152	(yyval.expr)= expr;
3153	}
3154	break;
3155
3156	case 165:
3157
3158	/* Line 1464 of yacc.c */
3159	#line 714 "xkbparse.y"
3160	{ (yyval.expr)= (yyvsp[(1) - (1)].expr); }
3161	break;
3162
3163	case 166:
3164
3165	/* Line 1464 of yacc.c */
3166	#line 715 "xkbparse.y"
3167	{ (yyval.expr)= NULL((void*)0); }
3168	break;
3169
3170	case 167:
3171
3172	/* Line 1464 of yacc.c */
3173	#line 719 "xkbparse.y"
3174	{ (yyval.expr)= AppendKeysymList((yyvsp[(1) - (3)].expr),(yyvsp[(3) - (3)].str)); }
3175	break;
3176
3177	case 168:
3178
3179	/* Line 1464 of yacc.c */
3180	#line 721 "xkbparse.y"
3181	{ (yyval.expr)= CreateKeysymList((yyvsp[(1) - (1)].str)); }
3182	break;
3183
3184	case 169:
3185
3186	/* Line 1464 of yacc.c */
3187	#line 724 "xkbparse.y"
3188	{ (yyval.str)= strdup(scanBuf); }
3189	break;
3190
3191	case 170:
3192
3193	/* Line 1464 of yacc.c */
3194	#line 725 "xkbparse.y"
3195	{ (yyval.str)= strdup("section"); }
3196	break;
3197
3198	case 171:
3199
3200	/* Line 1464 of yacc.c */
3201	#line 727 "xkbparse.y"
3202	{
3203	if ((yyvsp[(1) - (1)].ival)<10) { (yyval.str)= malloc(2); (yyval.str)[0]= '0' + (yyvsp[(1) - (1)].ival); (yyval.str)[1]= '\0'; }
3204	else { (yyval.str)= malloc(19); snprintf((yyval.str), 19, "0x%x", (yyvsp[(1) - (1)].ival)); }
3205	}
3206	break;
3207
3208	case 172:
3209
3210	/* Line 1464 of yacc.c */
3211	#line 733 "xkbparse.y"
3212	{ (yyval.ival)= -(yyvsp[(2) - (2)].ival); }
3213	break;
3214
3215	case 173:
3216
3217	/* Line 1464 of yacc.c */
3218	#line 734 "xkbparse.y"
3219	{ (yyval.ival)= (yyvsp[(1) - (1)].ival); }
3220	break;
3221
3222	case 174:
3223
3224	/* Line 1464 of yacc.c */
3225	#line 737 "xkbparse.y"
3226	{ (yyval.ival)= scanInt; }
3227	break;
3228
3229	case 175:
3230
3231	/* Line 1464 of yacc.c */
3232	#line 738 "xkbparse.y"
3233	{ (yyval.ival)= scanInt*XkbGeomPtsPerMM10; }
3234	break;
3235
3236	case 176:
3237
3238	/* Line 1464 of yacc.c */
3239	#line 741 "xkbparse.y"
3240	{ (yyval.ival)= scanInt; }
3241	break;
3242
3243	case 177:
3244
3245	/* Line 1464 of yacc.c */
3246	#line 744 "xkbparse.y"
3247	{ (yyval.ival)= scanInt; }
3248	break;
3249
3250	case 178:
3251
3252	/* Line 1464 of yacc.c */
3253	#line 747 "xkbparse.y"
3254	{ (yyval.str)= strdup(scanBuf); }
3255	break;
3256
3257	case 179:
3258
3259	/* Line 1464 of yacc.c */
3260	#line 750 "xkbparse.y"
3261	{ (yyval.sval)= XkbInternAtom(NULL((void*)0),scanBuf,False0); }
3262	break;
3263
3264	case 180:
3265
3266	/* Line 1464 of yacc.c */
3267	#line 751 "xkbparse.y"
3268	{ (yyval.sval)= XkbInternAtom(NULL((void*)0),"default",False0); }
3269	break;
3270
3271	case 181:
3272
3273	/* Line 1464 of yacc.c */
3274	#line 754 "xkbparse.y"
3275	{ (yyval.sval)= XkbInternAtom(NULL((void*)0),scanBuf,False0); }
3276	break;
3277
3278	case 182:
3279
3280	/* Line 1464 of yacc.c */
3281	#line 757 "xkbparse.y"
3282	{ (yyval.str)= (yyvsp[(1) - (1)].str); }
3283	break;
3284
3285	case 183:
3286
3287	/* Line 1464 of yacc.c */
3288	#line 758 "xkbparse.y"
3289	{ (yyval.str)= NULL((void*)0); }
3290	break;
3291
3292	case 184:
3293
3294	/* Line 1464 of yacc.c */
3295	#line 761 "xkbparse.y"
3296	{ (yyval.str)= strdup(scanBuf); }
3297	break;
3298
3299
3300
3301	/* Line 1464 of yacc.c */
3302	#line 3303 "xkbparse.c"
3303	default: break;
3304	}
3305	YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
3306
3307	YYPOPSTACK (yylen)(yyvsp -= (yylen), yyssp -= (yylen));
3308	yylen = 0;
3309	YY_STACK_PRINT (yyss, yyssp);
3310
3311	*++yyvsp = yyval;
3312
3313	/* Now `shift' the result of the reduction. Determine what state
3314	that goes to, based on the state we popped back to and the rule
3315	number reduced by. */
3316
3317	yyn = yyr1[yyn];
3318
3319	yystate = yypgoto[yyn - YYNTOKENS65] + *yyssp;
3320	if (0 <= yystate && yystate <= YYLAST706 && yycheck[yystate] == *yyssp)
3321	yystate = yytable[yystate];
3322	else
3323	yystate = yydefgoto[yyn - YYNTOKENS65];
3324
3325	goto yynewstate;
3326
3327
3328	/*------------------------------------.
3329	\| yyerrlab -- here on detecting error \|
3330	`------------------------------------*/
3331	yyerrlab:
3332	/* If not already recovering from an error, report this error. */
3333	if (!yyerrstatus)
3334	{
3335	++yynerrs;
3336	#if ! YYERROR_VERBOSE0
3337	yyerror (YY_("syntax error")"syntax error");
3338	#else
3339	{
3340	YYSIZE_Tlong unsigned int yysize = yysyntax_error (0, yystate, yychar);
3341	if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM((long unsigned int) -1))
3342	{
3343	YYSIZE_Tlong unsigned int yyalloc = 2 * yysize;
3344	if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM((long unsigned int) -1)))
3345	yyalloc = YYSTACK_ALLOC_MAXIMUM((long unsigned int) -1);
3346	if (yymsg != yymsgbuf)
3347	YYSTACK_FREEfree (yymsg);
3348	yymsg = (char *) YYSTACK_ALLOCmalloc (yyalloc);
3349	if (yymsg)
3350	yymsg_alloc = yyalloc;
3351	else
3352	{
3353	yymsg = yymsgbuf;
3354	yymsg_alloc = sizeof yymsgbuf;
3355	}
3356	}
3357
3358	if (0 < yysize && yysize <= yymsg_alloc)
3359	{
3360	(void) yysyntax_error (yymsg, yystate, yychar);
3361	yyerror (yymsg);
3362	}
3363	else
3364	{
3365	yyerror (YY_("syntax error")"syntax error");
3366	if (yysize != 0)
3367	goto yyexhaustedlab;
3368	}
3369	}
3370	#endif
3371	}
3372
3373
3374
3375	if (yyerrstatus == 3)
3376	{
3377	/* If just tried and failed to reuse lookahead token after an
3378	error, discard it. */
3379
3380	if (yychar <= YYEOF0)
3381	{
3382	/* Return failure if at end of input. */
3383	if (yychar == YYEOF0)
3384	YYABORTgoto yyabortlab;
3385	}
3386	else
3387	{
3388	yydestruct ("Error: discarding",
3389	yytoken, &yylval);
3390	yychar = YYEMPTY(-2);
3391	}
3392	}
3393
3394	/* Else will try to reuse lookahead token after shifting the error
3395	token. */
3396	goto yyerrlab1;
3397
3398
3399	/*---------------------------------------------------.
3400	\| yyerrorlab -- error raised explicitly by YYERROR. \|
3401	`---------------------------------------------------*/
3402	yyerrorlab:
3403
3404	/* Pacify compilers like GCC when the user code never invokes
3405	YYERROR and the label yyerrorlab therefore never appears in user
3406	code. */
3407	if (/CONSTCOND/ 0)
3408	goto yyerrorlab;
3409
3410	/* Do not reclaim the symbols of the rule which action triggered
3411	this YYERROR. */
3412	YYPOPSTACK (yylen)(yyvsp -= (yylen), yyssp -= (yylen));
3413	yylen = 0;
3414	YY_STACK_PRINT (yyss, yyssp);
3415	yystate = *yyssp;
3416	goto yyerrlab1;
3417
3418
3419	/*-------------------------------------------------------------.
3420	\| yyerrlab1 -- common code for both syntax error and YYERROR. \|
3421	`-------------------------------------------------------------*/
3422	yyerrlab1:
3423	yyerrstatus = 3; /* Each real token shifted decrements this. */
3424
3425	for (;;)
3426	{
3427	yyn = yypact[yystate];
3428	if (yyn != YYPACT_NINF-188)
3429	{
3430	yyn += YYTERROR1;
3431	if (0 <= yyn && yyn <= YYLAST706 && yycheck[yyn] == YYTERROR1)
3432	{
3433	yyn = yytable[yyn];
3434	if (0 < yyn)
3435	break;
3436	}
3437	}
3438
3439	/* Pop the current state because it cannot handle the error token. */
3440	if (yyssp == yyss)
3441	YYABORTgoto yyabortlab;
3442
3443
3444	yydestruct ("Error: popping",
3445	yystos[yystate], yyvsp);
3446	YYPOPSTACK (1)(yyvsp -= (1), yyssp -= (1));
3447	yystate = *yyssp;
3448	YY_STACK_PRINT (yyss, yyssp);
3449	}
3450
3451	*++yyvsp = yylval;
3452
3453
3454	/* Shift the error token. */
3455	YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
3456
3457	yystate = yyn;
3458	goto yynewstate;
3459
3460
3461	/*-------------------------------------.
3462	\| yyacceptlab -- YYACCEPT comes here. \|
3463	`-------------------------------------*/
3464	yyacceptlab:
3465	yyresult = 0;
3466	goto yyreturn;
3467
3468	/*-----------------------------------.
3469	\| yyabortlab -- YYABORT comes here. \|
3470	`-----------------------------------*/
3471	yyabortlab:
3472	yyresult = 1;
3473	goto yyreturn;
3474
3475	#if !defined(yyoverflow) \|\| YYERROR_VERBOSE0
3476	/*-------------------------------------------------.
3477	\| yyexhaustedlab -- memory exhaustion comes here. \|
3478	`-------------------------------------------------*/
3479	yyexhaustedlab:
3480	yyerror (YY_("memory exhausted")"memory exhausted");
3481	yyresult = 2;
3482	/* Fall through. */
3483	#endif
3484
3485	yyreturn:
3486	if (yychar != YYEMPTY(-2))
3487	yydestruct ("Cleanup: discarding lookahead",
3488	yytoken, &yylval);
3489	/* Do not reclaim the symbols of the rule which action triggered
3490	this YYABORT or YYACCEPT. */
3491	YYPOPSTACK (yylen)(yyvsp -= (yylen), yyssp -= (yylen));
3492	YY_STACK_PRINT (yyss, yyssp);
3493	while (yyssp != yyss)
3494	{
3495	yydestruct ("Cleanup: popping",
3496	yystos[*yyssp], yyvsp);
3497	YYPOPSTACK (1)(yyvsp -= (1), yyssp -= (1));
3498	}
3499	#ifndef yyoverflow
3500	if (yyss != yyssa)
3501	YYSTACK_FREEfree (yyss);
3502	#endif
3503	#if YYERROR_VERBOSE0
3504	if (yymsg != yymsgbuf)
3505	YYSTACK_FREEfree (yymsg);
3506	#endif
3507	/* Make sure YYID is used. */
3508	return YYID (yyresult)(yyresult);
3509	}
3510
3511
3512
3513	/* Line 1684 of yacc.c */
3514	#line 763 "xkbparse.y"
3515
3516	void
3517	yyerror(const char *s)
3518	{
3519	if (warningLevel>0) {
3520	(void)fprintf(stderrstderr,"%s: line %d of %s\n",s,lineNum,
3521	(scanFile?scanFile:"(unknown)"));
3522	if ((warningLevel>3))
3523	(void)fprintf(stderrstderr,"last scanned symbol is: %s\n",scanBuf);
3524	}
3525	return;
3526	}
3527
3528
3529	int
3530	yywrap(void)
3531	{
3532	return 1;
3533	}
3534
3535