1	/* A Bison parser, made by GNU Bison 2.7.12-4996. */
2
3	/* Bison implementation for Yacc-like parsers in C
4
5	Copyright (C) 1984, 1989-1990, 2000-2013 Free Software Foundation, Inc.
6
7	This program is free software: you can redistribute it and/or modify
8	it under the terms of the GNU General Public License as published by
9	the Free Software Foundation, either version 3 of the License, or
10	(at your option) any later version.
11
12	This program is distributed in the hope that it will be useful,
13	but WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	GNU General Public License for more details.
16
17	You should have received a copy of the GNU General Public License
18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20	/* As a special exception, you may create a larger work that contains
21	part or all of the Bison parser skeleton and distribute that work
22	under terms of your choice, so long as that work isn't itself a
23	parser generator using the skeleton or a modified version thereof
24	as a parser skeleton. Alternatively, if you modify or redistribute
25	the parser skeleton itself, you may (at your option) remove this
26	special exception, which will cause the skeleton and the resulting
27	Bison output files to be licensed under the GNU General Public
28	License without this special exception.
29
30	This special exception was added by the Free Software Foundation in
31	version 2.2 of Bison. */
32
33	/* C LALR(1) parser skeleton written by Richard Stallman, by
34	simplifying the original so-called "semantic" parser. */
35
36	/* All symbols defined below should begin with yy or YY, to avoid
37	infringing on user name space. This should be done even for local
38	variables, as they might otherwise be expanded by user macros.
39	There are some unavoidable exceptions within include files to
40	define necessary library symbols; they are noted "INFRINGES ON
41	USER NAME SPACE" below. */
42
43	/* Identify Bison output. */
44	#define YYBISON 1
45
46	/* Bison version. */
47	#define YYBISON_VERSION "2.7.12-4996"
48
49	/* Skeleton name. */
50	#define YYSKELETON_NAME "yacc.c"
51
52	/* Pure parsers. */
53	#define YYPURE 0
54
55	/* Push parsers. */
56	#define YYPUSH 0
57
58	/* Pull parsers. */
59	#define YYPULL 1
60
61
62	/* Substitute the variable and function names. */
63	#define yyparse kjsyyparse
64	#define yylex kjsyylex
65	#define yyerror kjsyyerror
66	#define yylval kjsyylval
67	#define yychar kjsyychar
68	#define yydebug kjsyydebug
69	#define yynerrs kjsyynerrs
70	#define yylloc kjsyylloc
71
72	/* Copy the first part of user declarations. */
73	/* Line 371 of yacc.c */
74	#line 1 "grammar.y"
75
76
77	/*
78	* This file is part of the KDE libraries
79	* Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
80	* Copyright (C) 2006, 2007 Apple Inc. All rights reserved.
81	*
82	* This library is free software; you can redistribute it and/or
83	* modify it under the terms of the GNU Lesser General Public
84	* License as published by the Free Software Foundation; either
85	* version 2 of the License, or (at your option) any later version.
86	*
87	* This library is distributed in the hope that it will be useful,
88	* but WITHOUT ANY WARRANTY; without even the implied warranty of
89	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
90	* Lesser General Public License for more details.
91	*
92	* You should have received a copy of the GNU Lesser General Public
93	* License along with this library; if not, write to the Free Software
94	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
95	*
96	*/
97
98	#include <config-kjs.h>
99
100	#include <string.h>
101	#include <stdlib.h>
102	#include <stdio.h>
103	#include "value.h"
104	#include "object.h"
105	#include "types.h"
106	#include "interpreter.h"
107	#include "nodes.h"
108	#include "makenodes.h"
109	#include "lexer.h"
110	#include "internal.h"
111
112	// Not sure why, but yacc doesn't add this define along with the others.
113	#define yylloc kjsyylloc
114
115	/* default values for bison */
116	#define YYDEBUG 0 // Set to 1 to debug a parse error.
117	#define kjsyydebug 0 // Set to 1 to debug a parse error.
118	#if !PLATFORM(DARWIN)
119	// avoid triggering warnings in older bison
120	#define YYERROR_VERBOSE
121	#endif
122
123	extern int kjsyylex();
124	int kjsyyerror(const char *);
125	static bool allowAutomaticSemicolon();
126
127	#define AUTO_SEMICOLON do { if (!allowAutomaticSemicolon()) YYABORT; } while (0)
128	#define DBG(l, s, e) (l)->setLoc((s).first_line, (e).last_line)
129
130	#ifndef __GNUC__
131	# define __attribute__(x)
132	#endif
133
134	using namespace KJS;
135
136
137	/* Line 371 of yacc.c */
138	#line 139 "grammar.tab.c"
139
140	# ifndef YY_NULL
141	# if defined __cplusplus && 201103L <= __cplusplus
142	# define YY_NULL nullptr
143	# else
144	# define YY_NULL 0
145	# endif
146	# endif
147
148	/* Enabling verbose error messages. */
149	#ifdef YYERROR_VERBOSE
150	# undef YYERROR_VERBOSE
151	# define YYERROR_VERBOSE 1
152	#else
153	# define YYERROR_VERBOSE 0
154	#endif
155
156	/* In a future release of Bison, this section will be replaced
157	by #include "grammar.tab.h". */
158	#ifndef YY_KJSYY_GRAMMAR_TAB_H_INCLUDED
159	# define YY_KJSYY_GRAMMAR_TAB_H_INCLUDED
160	/* Enabling traces. */
161	#ifndef YYDEBUG
162	# define YYDEBUG 0
163	#endif
164	#if YYDEBUG
165	extern int kjsyydebug;
166	#endif
167
168	/* Tokens. */
169	#ifndef YYTOKENTYPE
170	# define YYTOKENTYPE
171	/* Put the tokens into the symbol table, so that GDB and other debuggers
172	know about them. */
173	enum yytokentype {
174	NULLTOKEN = 258,
175	TRUETOKEN = 259,
176	FALSETOKEN = 260,
177	BREAK = 261,
178	CASE = 262,
179	DEFAULT = 263,
180	FOR = 264,
181	NEW = 265,
182	VAR = 266,
183	CONSTTOKEN = 267,
184	CONTINUE = 268,
185	FUNCTION = 269,
186	RETURN = 270,
187	VOIDTOKEN = 271,
188	DELETETOKEN = 272,
189	IF = 273,
190	THISTOKEN = 274,
191	DO = 275,
192	WHILE = 276,
193	INTOKEN = 277,
194	INSTANCEOF = 278,
195	TYPEOF = 279,
196	SWITCH = 280,
197	WITH = 281,
198	RESERVED = 282,
199	THROW = 283,
200	TRY = 284,
201	CATCH = 285,
202	FINALLY = 286,
203	DEBUGGER = 287,
204	IMPORT = 288,
205	IF_WITHOUT_ELSE = 289,
206	ELSE = 290,
207	EQEQ = 291,
208	NE = 292,
209	STREQ = 293,
210	STRNEQ = 294,
211	LE = 295,
212	GE = 296,
213	OR = 297,
214	AND = 298,
215	PLUSPLUS = 299,
216	MINUSMINUS = 300,
217	LSHIFT = 301,
218	RSHIFT = 302,
219	URSHIFT = 303,
220	PLUSEQUAL = 304,
221	MINUSEQUAL = 305,
222	MULTEQUAL = 306,
223	DIVEQUAL = 307,
224	LSHIFTEQUAL = 308,
225	RSHIFTEQUAL = 309,
226	URSHIFTEQUAL = 310,
227	ANDEQUAL = 311,
228	MODEQUAL = 312,
229	XOREQUAL = 313,
230	OREQUAL = 314,
231	NUMBER = 315,
232	STRING = 316,
233	IDENT = 317,
234	AUTOPLUSPLUS = 318,
235	AUTOMINUSMINUS = 319
236	};
237	#endif
238
239
240	#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
241	typedef union YYSTYPE
242	{
243	/* Line 387 of yacc.c */
244	#line 64 "grammar.y"
245
246	int ival;
247	double dval;
248	UString *ustr;
249	Identifier *ident;
250	Node *node;
251	StatementNode *stat;
252	ParameterNode *param;
253	FunctionBodyNode *body;
254	FuncDeclNode *func;
255	FuncExprNode *funcExpr;
256	ProgramNode *prog;
257	AssignExprNode *init;
258	SourceElementsNode *srcs;
259	ArgumentsNode *args;
260	ArgumentListNode *alist;
261	VarDeclNode *decl;
262	VarDeclListNode *vlist;
263	CaseBlockNode *cblk;
264	ClauseListNode *clist;
265	CaseClauseNode *ccl;
266	ElementNode *elm;
267	Operator op;
268	PropertyListNode *plist;
269	PropertyNode *pnode;
270	PropertyNameNode *pname;
271	PackageNameNode *pkgn;
272
273
274	/* Line 387 of yacc.c */
275	#line 276 "grammar.tab.c"
276	} YYSTYPE;
277	# define YYSTYPE_IS_TRIVIAL 1
278	# define yystype YYSTYPE /* obsolescent; will be withdrawn */
279	# define YYSTYPE_IS_DECLARED 1
280	#endif
281
282	#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
283	typedef struct YYLTYPE
284	{
285	int first_line;
286	int first_column;
287	int last_line;
288	int last_column;
289	} YYLTYPE;
290	# define yyltype YYLTYPE /* obsolescent; will be withdrawn */
291	# define YYLTYPE_IS_DECLARED 1
292	# define YYLTYPE_IS_TRIVIAL 1
293	#endif
294
295	extern YYSTYPE kjsyylval;
296	extern YYLTYPE kjsyylloc;
297	#ifdef YYPARSE_PARAM
298	#if defined __STDC__ || defined __cplusplus
299	int kjsyyparse (void *YYPARSE_PARAM);
300	#else
301	int kjsyyparse ();
302	#endif
303	#else /* ! YYPARSE_PARAM */
304	#if defined __STDC__ || defined __cplusplus
305	int kjsyyparse (void);
306	#else
307	int kjsyyparse ();
308	#endif
309	#endif /* ! YYPARSE_PARAM */
310
311	#endif /* !YY_KJSYY_GRAMMAR_TAB_H_INCLUDED */
312
313	/* Copy the second part of user declarations. */
314
315	/* Line 390 of yacc.c */
316	#line 317 "grammar.tab.c"
317
318	#ifdef short
319	# undef short
320	#endif
321
322	#ifdef YYTYPE_UINT8
323	typedef YYTYPE_UINT8 yytype_uint8;
324	#else
325	typedef unsigned char yytype_uint8;
326	#endif
327
328	#ifdef YYTYPE_INT8
329	typedef YYTYPE_INT8 yytype_int8;
330	#elif (defined __STDC__ || defined __C99__FUNC__ \
331	|| defined __cplusplus || defined _MSC_VER)
332	typedef signed char yytype_int8;
333	#else
334	typedef short int yytype_int8;
335	#endif
336
337	#ifdef YYTYPE_UINT16
338	typedef YYTYPE_UINT16 yytype_uint16;
339	#else
340	typedef unsigned short int yytype_uint16;
341	#endif
342
343	#ifdef YYTYPE_INT16
344	typedef YYTYPE_INT16 yytype_int16;
345	#else
346	typedef short int yytype_int16;
347	#endif
348
349	#ifndef YYSIZE_T
350	# ifdef __SIZE_TYPE__
351	# define YYSIZE_T __SIZE_TYPE__
352	# elif defined size_t
353	# define YYSIZE_T size_t
354	# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
355	|| defined __cplusplus || defined _MSC_VER)
356	# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
357	# define YYSIZE_T size_t
358	# else
359	# define YYSIZE_T unsigned int
360	# endif
361	#endif
362
363	#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
364
365	#ifndef YY_
366	# if defined YYENABLE_NLS && YYENABLE_NLS
367	# if ENABLE_NLS
368	# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
369	# define YY_(Msgid) dgettext ("bison-runtime", Msgid)
370	# endif
371	# endif
372	# ifndef YY_
373	# define YY_(Msgid) Msgid
374	# endif
375	#endif
376
377	#ifndef __attribute__
378	/* This feature is available in gcc versions 2.5 and later. */
379	# if (! defined __GNUC__ || __GNUC__ < 2 \
380	|| (__GNUC__ == 2 && __GNUC_MINOR__ < 5))
381	# define __attribute__(Spec) /* empty */
382	# endif
383	#endif
384
385	/* Suppress unused-variable warnings by "using" E. */
386	#if ! defined lint || defined __GNUC__
387	# define YYUSE(E) ((void) (E))
388	#else
389	# define YYUSE(E) /* empty */
390	#endif
391
392
393	/* Identity function, used to suppress warnings about constant conditions. */
394	#ifndef lint
395	# define YYID(N) (N)
396	#else
397	#if (defined __STDC__ || defined __C99__FUNC__ \
398	|| defined __cplusplus || defined _MSC_VER)
399	static int
400	YYID (int yyi)
401	#else
402	static int
403	YYID (yyi)
404	int yyi;
405	#endif
406	{
407	return yyi;
408	}
409	#endif
410
411	#if ! defined yyoverflow || YYERROR_VERBOSE
412
413	/* The parser invokes alloca or malloc; define the necessary symbols. */
414
415	# ifdef YYSTACK_USE_ALLOCA
416	# if YYSTACK_USE_ALLOCA
417	# ifdef __GNUC__
418	# define YYSTACK_ALLOC __builtin_alloca
419	# elif defined __BUILTIN_VA_ARG_INCR
420	# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
421	# elif defined _AIX
422	# define YYSTACK_ALLOC __alloca
423	# elif defined _MSC_VER
424	# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
425	# define alloca _alloca
426	# else
427	# define YYSTACK_ALLOC alloca
428	# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
429	|| defined __cplusplus || defined _MSC_VER)
430	# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
431	/* Use EXIT_SUCCESS as a witness for stdlib.h. */
432	# ifndef EXIT_SUCCESS
433	# define EXIT_SUCCESS 0
434	# endif
435	# endif
436	# endif
437	# endif
438	# endif
439
440	# ifdef YYSTACK_ALLOC
441	/* Pacify GCC's `empty if-body' warning. */
442	# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
443	# ifndef YYSTACK_ALLOC_MAXIMUM
444	/* The OS might guarantee only one guard page at the bottom of the stack,
445	and a page size can be as small as 4096 bytes. So we cannot safely
446	invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
447	to allow for a few compiler-allocated temporary stack slots. */
448	# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
449	# endif
450	# else
451	# define YYSTACK_ALLOC YYMALLOC
452	# define YYSTACK_FREE YYFREE
453	# ifndef YYSTACK_ALLOC_MAXIMUM
454	# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
455	# endif
456	# if (defined __cplusplus && ! defined EXIT_SUCCESS \
457	&& ! ((defined YYMALLOC || defined malloc) \
458	&& (defined YYFREE || defined free)))
459	# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
460	# ifndef EXIT_SUCCESS
461	# define EXIT_SUCCESS 0
462	# endif
463	# endif
464	# ifndef YYMALLOC
465	# define YYMALLOC malloc
466	# if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
467	|| defined __cplusplus || defined _MSC_VER)
468	void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
469	# endif
470	# endif
471	# ifndef YYFREE
472	# define YYFREE free
473	# if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
474	|| defined __cplusplus || defined _MSC_VER)
475	void free (void *); /* INFRINGES ON USER NAME SPACE */
476	# endif
477	# endif
478	# endif
479	#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
480
481
482	#if (! defined yyoverflow \
483	&& (! defined __cplusplus \
484	|| (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
485	&& defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
486
487	/* A type that is properly aligned for any stack member. */
488	union yyalloc
489	{
490	yytype_int16 yyss_alloc;
491	YYSTYPE yyvs_alloc;
492	YYLTYPE yyls_alloc;
493	};
494
495	/* The size of the maximum gap between one aligned stack and the next. */
496	# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
497
498	/* The size of an array large to enough to hold all stacks, each with
499	N elements. */
500	# define YYSTACK_BYTES(N) \
501	((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
502	+ 2 * YYSTACK_GAP_MAXIMUM)
503
504	# define YYCOPY_NEEDED 1
505
506	/* Relocate STACK from its old location to the new one. The
507	local variables YYSIZE and YYSTACKSIZE give the old and new number of
508	elements in the stack, and YYPTR gives the new location of the
509	stack. Advance YYPTR to a properly aligned location for the next
510	stack. */
511	# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
512	do \
513	{ \
514	YYSIZE_T yynewbytes; \
515	YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
516	Stack = &yyptr->Stack_alloc; \
517	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
518	yyptr += yynewbytes / sizeof (*yyptr); \
519	} \
520	while (YYID (0))
521
522	#endif
523
524	#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
525	/* Copy COUNT objects from SRC to DST. The source and destination do
526	not overlap. */
527	# ifndef YYCOPY
528	# if defined __GNUC__ && 1 < __GNUC__
529	# define YYCOPY(Dst, Src, Count) \
530	__builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
531	# else
532	# define YYCOPY(Dst, Src, Count) \
533	do \
534	{ \
535	YYSIZE_T yyi; \
536	for (yyi = 0; yyi < (Count); yyi++) \
537	(Dst)[yyi] = (Src)[yyi]; \
538	} \
539	while (YYID (0))
540	# endif
541	# endif
542	#endif /* !YYCOPY_NEEDED */
543
544	/* YYFINAL -- State number of the termination state. */
545	#define YYFINAL 212
546	/* YYLAST -- Last index in YYTABLE. */
547	#define YYLAST 1718
548
549	/* YYNTOKENS -- Number of terminals. */
550	#define YYNTOKENS 89
551	/* YYNNTS -- Number of nonterminals. */
552	#define YYNNTS 114
553	/* YYNRULES -- Number of rules. */
554	#define YYNRULES 352
555	/* YYNRULES -- Number of states. */
556	#define YYNSTATES 589
557
558	/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
559	#define YYUNDEFTOK 2
560	#define YYMAXUTOK 319
561
562	#define YYTRANSLATE(YYX) \
563	((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
564
565	/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
566	static const yytype_uint8 yytranslate[] =
567	{
568	0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
569	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
570	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
571	2, 2, 2, 78, 2, 2, 2, 80, 83, 2,
572	67, 68, 79, 75, 69, 76, 74, 65, 2, 2,
573	2, 2, 2, 2, 2, 2, 2, 2, 66, 88,
574	81, 87, 82, 86, 2, 2, 2, 2, 2, 2,
575	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
576	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
577	2, 72, 2, 73, 84, 2, 2, 2, 2, 2,
578	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
579	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
580	2, 2, 2, 70, 85, 71, 77, 2, 2, 2,
581	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
582	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
583	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
584	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
585	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
586	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
587	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
588	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
589	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
590	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
591	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
592	2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
593	2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
594	5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
595	15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
596	25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
597	35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
598	45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
599	55, 56, 57, 58, 59, 60, 61, 62, 63, 64
600	};
601
602	#if YYDEBUG
603	/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
604	YYRHS. */
605	static const yytype_uint16 yyprhs[] =
606	{
607	0, 0, 3, 5, 7, 9, 11, 13, 15, 17,
608	19, 21, 23, 25, 27, 29, 31, 33, 35, 37,
609	39, 41, 43, 45, 47, 49, 51, 53, 55, 57,
610	59, 61, 63, 65, 67, 69, 71, 73, 75, 77,
611	79, 81, 83, 85, 87, 89, 93, 94, 101, 102,
612	110, 112, 116, 118, 121, 125, 130, 132, 134, 136,
613	138, 142, 146, 150, 156, 159, 164, 165, 167, 169,
614	172, 174, 176, 181, 185, 189, 191, 196, 200, 204,
615	206, 209, 211, 214, 217, 220, 225, 229, 232, 235,
616	240, 244, 247, 251, 253, 257, 259, 261, 263, 265,
617	267, 270, 273, 275, 278, 281, 284, 287, 290, 293,
618	296, 299, 302, 305, 308, 311, 314, 316, 318, 320,
619	322, 324, 328, 332, 336, 338, 342, 346, 350, 352,
620	356, 360, 362, 366, 370, 372, 376, 380, 384, 386,
621	390, 394, 398, 400, 404, 408, 412, 416, 420, 424,
622	426, 430, 434, 438, 442, 446, 448, 452, 456, 460,
623	464, 468, 472, 474, 478, 482, 486, 490, 492, 496,
624	500, 504, 508, 510, 514, 518, 522, 526, 528, 532,
625	534, 538, 540, 544, 546, 550, 552, 556, 558, 562,
626	564, 568, 570, 574, 576, 580, 582, 586, 588, 592,
627	594, 598, 600, 604, 606, 610, 612, 616, 618, 624,
628	626, 632, 634, 640, 642, 646, 648, 652, 654, 658,
629	660, 662, 664, 666, 668, 670, 672, 674, 676, 678,
630	680, 682, 684, 688, 690, 694, 696, 700, 702, 704,
631	706, 708, 710, 712, 714, 716, 718, 720, 722, 724,
632	726, 728, 730, 732, 734, 737, 741, 745, 749, 751,
633	755, 757, 761, 763, 766, 768, 771, 775, 779, 781,
634	785, 787, 790, 793, 796, 798, 801, 804, 810, 818,
635	826, 834, 840, 850, 861, 869, 878, 888, 889, 891,
636	892, 894, 897, 900, 904, 908, 911, 914, 918, 922,
637	925, 928, 932, 936, 942, 948, 952, 958, 959, 961,
638	963, 966, 970, 975, 978, 982, 986, 990, 994, 999,
639	1007, 1017, 1020, 1023, 1025, 1029, 1035, 1041, 1045, 1049,
640	1055, 1061, 1062, 1069, 1070, 1078, 1079, 1085, 1086, 1093,
641	1094, 1101, 1102, 1110, 1112, 1116, 1119, 1123, 1124, 1126,
642	1128, 1131, 1133
643	};
644
645	/* YYRHS -- A `-1'-separated list of the rules' RHS. */
646	static const yytype_int16 yyrhs[] =
647	{
648	200, 0, -1, 6, -1, 7, -1, 8, -1, 9,
649	-1, 10, -1, 11, -1, 12, -1, 13, -1, 14,
650	-1, 15, -1, 16, -1, 17, -1, 18, -1, 19,
651	-1, 20, -1, 21, -1, 22, -1, 23, -1, 24,
652	-1, 25, -1, 26, -1, 28, -1, 29, -1, 30,
653	-1, 31, -1, 32, -1, 33, -1, 3, -1, 4,
654	-1, 5, -1, 35, -1, 62, -1, 90, -1, 3,
655	-1, 4, -1, 5, -1, 60, -1, 61, -1, 65,
656	-1, 52, -1, 91, -1, 61, -1, 60, -1, 93,
657	66, 149, -1, -1, 62, 91, 67, 68, 95, 199,
658	-1, -1, 62, 91, 67, 198, 68, 96, 199, -1,
659	94, -1, 97, 69, 94, -1, 99, -1, 70, 71,
660	-1, 70, 97, 71, -1, 70, 97, 69, 71, -1,
661	19, -1, 92, -1, 100, -1, 62, -1, 67, 153,
662	68, -1, 72, 102, 73, -1, 72, 101, 73, -1,
663	72, 101, 69, 102, 73, -1, 102, 149, -1, 101,
664	69, 102, 149, -1, -1, 103, -1, 69, -1, 103,
665	69, -1, 98, -1, 193, -1, 104, 72, 153, 73,
666	-1, 104, 74, 91, -1, 10, 104, 110, -1, 99,
667	-1, 105, 72, 153, 73, -1, 105, 74, 91, -1,
668	10, 104, 110, -1, 104, -1, 10, 106, -1, 105,
669	-1, 10, 106, -1, 104, 110, -1, 108, 110, -1,
670	108, 72, 153, 73, -1, 108, 74, 91, -1, 105,
671	110, -1, 109, 110, -1, 109, 72, 153, 73, -1,
672	109, 74, 91, -1, 67, 68, -1, 67, 111, 68,
673	-1, 149, -1, 111, 69, 149, -1, 106, -1, 108,
674	-1, 107, -1, 109, -1, 112, -1, 112, 44, -1,
675	112, 45, -1, 113, -1, 113, 44, -1, 113, 45,
676	-1, 17, 117, -1, 16, 117, -1, 24, 117, -1,
677	44, 117, -1, 63, 117, -1, 45, 117, -1, 64,
678	117, -1, 75, 117, -1, 76, 117, -1, 77, 117,
679	-1, 78, 117, -1, 114, -1, 116, -1, 115, -1,
680	116, -1, 117, -1, 119, 79, 117, -1, 119, 65,
681	117, -1, 119, 80, 117, -1, 118, -1, 120, 79,
682	117, -1, 120, 65, 117, -1, 120, 80, 117, -1,
683	119, -1, 121, 75, 119, -1, 121, 76, 119, -1,
684	120, -1, 122, 75, 119, -1, 122, 76, 119, -1,
685	121, -1, 123, 46, 121, -1, 123, 47, 121, -1,
686	123, 48, 121, -1, 122, -1, 124, 46, 121, -1,
687	124, 47, 121, -1, 124, 48, 121, -1, 123, -1,
688	125, 81, 123, -1, 125, 82, 123, -1, 125, 40,
689	123, -1, 125, 41, 123, -1, 125, 23, 123, -1,
690	125, 22, 123, -1, 123, -1, 126, 81, 123, -1,
691	126, 82, 123, -1, 126, 40, 123, -1, 126, 41,
692	123, -1, 126, 23, 123, -1, 124, -1, 127, 81,
693	123, -1, 127, 82, 123, -1, 127, 40, 123, -1,
694	127, 41, 123, -1, 127, 23, 123, -1, 127, 22,
695	123, -1, 125, -1, 128, 36, 125, -1, 128, 37,
696	125, -1, 128, 38, 125, -1, 128, 39, 125, -1,
697	126, -1, 129, 36, 126, -1, 129, 37, 126, -1,
698	129, 38, 126, -1, 129, 39, 126, -1, 127, -1,
699	130, 36, 125, -1, 130, 37, 125, -1, 130, 38,
700	125, -1, 130, 39, 125, -1, 128, -1, 131, 83,
701	128, -1, 129, -1, 132, 83, 129, -1, 130, -1,
702	133, 83, 128, -1, 131, -1, 134, 84, 131, -1,
703	132, -1, 135, 84, 132, -1, 133, -1, 136, 84,
704	131, -1, 134, -1, 137, 85, 134, -1, 135, -1,
705	138, 85, 135, -1, 136, -1, 139, 85, 134, -1,
706	137, -1, 140, 43, 137, -1, 138, -1, 141, 43,
707	138, -1, 139, -1, 142, 43, 137, -1, 140, -1,
708	143, 42, 140, -1, 141, -1, 144, 42, 141, -1,
709	142, -1, 145, 42, 140, -1, 143, -1, 143, 86,
710	149, 66, 149, -1, 144, -1, 144, 86, 150, 66,
711	150, -1, 145, -1, 145, 86, 149, 66, 149, -1,
712	146, -1, 112, 152, 149, -1, 147, -1, 112, 152,
713	150, -1, 148, -1, 113, 152, 149, -1, 87, -1,
714	49, -1, 50, -1, 51, -1, 52, -1, 53, -1,
715	54, -1, 55, -1, 56, -1, 58, -1, 59, -1,
716	57, -1, 149, -1, 153, 69, 149, -1, 150, -1,
717	154, 69, 150, -1, 151, -1, 155, 69, 149, -1,
718	157, -1, 158, -1, 163, -1, 168, -1, 169, -1,
719	170, -1, 171, -1, 174, -1, 175, -1, 176, -1,
720	177, -1, 178, -1, 184, -1, 185, -1, 186, -1,
721	187, -1, 189, -1, 70, 71, -1, 70, 201, 71,
722	-1, 11, 159, 88, -1, 11, 159, 1, -1, 161,
723	-1, 159, 69, 161, -1, 162, -1, 160, 69, 162,
724	-1, 62, -1, 62, 166, -1, 62, -1, 62, 167,
725	-1, 12, 164, 88, -1, 12, 164, 1, -1, 165,
726	-1, 164, 69, 165, -1, 62, -1, 62, 166, -1,
727	87, 149, -1, 87, 150, -1, 88, -1, 155, 88,
728	-1, 155, 1, -1, 18, 67, 153, 68, 156, -1,
729	18, 67, 153, 68, 156, 35, 156, -1, 20, 156,
730	21, 67, 153, 68, 88, -1, 20, 156, 21, 67,
731	153, 68, 1, -1, 21, 67, 153, 68, 156, -1,
732	9, 67, 173, 88, 172, 88, 172, 68, 156, -1,
733	9, 67, 11, 160, 88, 172, 88, 172, 68, 156,
734	-1, 9, 67, 112, 22, 153, 68, 156, -1, 9,
735	67, 11, 62, 22, 153, 68, 156, -1, 9, 67,
736	11, 62, 167, 22, 153, 68, 156, -1, -1, 153,
737	-1, -1, 154, -1, 13, 88, -1, 13, 1, -1,
738	13, 62, 88, -1, 13, 62, 1, -1, 6, 88,
739	-1, 6, 1, -1, 6, 62, 88, -1, 6, 62,
740	1, -1, 15, 88, -1, 15, 1, -1, 15, 153,
741	88, -1, 15, 153, 1, -1, 26, 67, 153, 68,
742	156, -1, 25, 67, 153, 68, 179, -1, 70, 180,
743	71, -1, 70, 180, 183, 180, 71, -1, -1, 181,
744	-1, 182, -1, 181, 182, -1, 7, 153, 66, -1,
745	7, 153, 66, 201, -1, 8, 66, -1, 8, 66,
746	201, -1, 62, 66, 156, -1, 28, 153, 88, -1,
747	28, 153, 1, -1, 29, 157, 31, 157, -1, 29,
748	157, 30, 67, 62, 68, 157, -1, 29, 157, 30,
749	67, 62, 68, 157, 31, 157, -1, 32, 88, -1,
750	32, 1, -1, 62, -1, 188, 74, 62, -1, 33,
751	188, 74, 79, 88, -1, 33, 188, 74, 79, 1,
752	-1, 33, 188, 88, -1, 33, 188, 1, -1, 33,
753	62, 87, 188, 88, -1, 33, 62, 87, 188, 1,
754	-1, -1, 14, 62, 67, 68, 191, 199, -1, -1,
755	14, 62, 67, 198, 68, 192, 199, -1, -1, 14,
756	67, 68, 194, 199, -1, -1, 14, 67, 198, 68,
757	195, 199, -1, -1, 14, 62, 67, 68, 196, 199,
758	-1, -1, 14, 62, 67, 198, 68, 197, 199, -1,
759	62, -1, 198, 69, 62, -1, 70, 71, -1, 70,
760	201, 71, -1, -1, 201, -1, 202, -1, 201, 202,
761	-1, 190, -1, 156, -1
762	};
763
764	/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
765	static const yytype_uint16 yyrline[] =
766	{
767	0, 192, 192, 193, 194, 195, 196, 197, 198, 199,
768	200, 201, 202, 203, 204, 205, 206, 207, 208, 209,
769	210, 211, 212, 213, 214, 215, 216, 217, 218, 219,
770	220, 221, 222, 226, 227, 231, 232, 233, 234, 235,
771	236, 242, 251, 252, 253, 257, 258, 258, 262, 262,
772	269, 270, 274, 275, 276, 278, 282, 283, 284, 285,
773	286, 291, 292, 293, 297, 298, 303, 304, 308, 309,
774	313, 314, 315, 316, 317, 321, 322, 323, 324, 328,
775	329, 333, 334, 338, 339, 340, 341, 345, 346, 347,
776	348, 352, 353, 357, 358, 362, 363, 367, 368, 372,
777	373, 374, 378, 379, 380, 384, 385, 386, 387, 388,
778	389, 390, 391, 392, 393, 394, 397, 398, 402, 403,
779	407, 408, 409, 410, 414, 415, 417, 419, 424, 425,
780	426, 430, 431, 433, 438, 439, 440, 441, 445, 446,
781	447, 448, 452, 453, 454, 455, 456, 457, 458, 462,
782	463, 464, 465, 466, 467, 472, 473, 474, 475, 476,
783	477, 479, 483, 484, 485, 486, 487, 491, 492, 494,
784	496, 498, 503, 504, 506, 507, 509, 514, 515, 519,
785	520, 525, 526, 530, 531, 535, 536, 541, 542, 547,
786	548, 552, 553, 558, 559, 564, 565, 569, 570, 575,
787	576, 581, 582, 586, 587, 592, 593, 597, 598, 603,
788	604, 609, 610, 615, 616, 621, 622, 627, 628, 633,
789	634, 635, 636, 637, 638, 639, 640, 641, 642, 643,
790	644, 648, 649, 653, 654, 658, 659, 663, 664, 665,
791	666, 667, 668, 669, 670, 671, 672, 673, 674, 675,
792	676, 677, 678, 679, 683, 684, 688, 689, 693, 694,
793	699, 700, 705, 706, 710, 711, 715, 716, 721, 722,
794	727, 728, 732, 736, 740, 744, 745, 749, 751, 756,
795	757, 758, 759, 761, 763, 771, 773, 778, 779, 783,
796	784, 788, 789, 790, 791, 795, 796, 797, 798, 802,
797	803, 804, 805, 809, 813, 817, 818, 823, 824, 828,
798	829, 833, 834, 838, 839, 843, 847, 848, 852, 853,
799	854, 859, 860, 864, 865, 869, 871, 873, 875, 877,
800	879, 884, 884, 885, 885, 890, 890, 893, 893, 896,
801	896, 897, 897, 903, 904, 908, 909, 913, 914, 918,
802	919, 923, 924
803	};
804	#endif
805
806	#if YYDEBUG || YYERROR_VERBOSE || 0
807	/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
808	First, the terminals, then, starting at YYNTOKENS, nonterminals. */
809	static const char *const yytname[] =
810	{
811	"$end", "error", "$undefined", "NULLTOKEN", "TRUETOKEN", "FALSETOKEN",
812	"BREAK", "CASE", "DEFAULT", "FOR", "NEW", "VAR", "CONSTTOKEN",
813	"CONTINUE", "FUNCTION", "RETURN", "VOIDTOKEN", "DELETETOKEN", "IF",
814	"THISTOKEN", "DO", "WHILE", "INTOKEN", "INSTANCEOF", "TYPEOF", "SWITCH",
815	"WITH", "RESERVED", "THROW", "TRY", "CATCH", "FINALLY", "DEBUGGER",
816	"IMPORT", "IF_WITHOUT_ELSE", "ELSE", "EQEQ", "NE", "STREQ", "STRNEQ",
817	"LE", "GE", "OR", "AND", "PLUSPLUS", "MINUSMINUS", "LSHIFT", "RSHIFT",
818	"URSHIFT", "PLUSEQUAL", "MINUSEQUAL", "MULTEQUAL", "DIVEQUAL",
819	"LSHIFTEQUAL", "RSHIFTEQUAL", "URSHIFTEQUAL", "ANDEQUAL", "MODEQUAL",
820	"XOREQUAL", "OREQUAL", "NUMBER", "STRING", "IDENT", "AUTOPLUSPLUS",
821	"AUTOMINUSMINUS", "'/'", "':'", "'('", "')'", "','", "'{'", "'}'", "'['",
822	"']'", "'.'", "'+'", "'-'", "'~'", "'!'", "'*'", "'%'", "'<'", "'>'",
823	"'&'", "'^'", "'|'", "'?'", "'='", "';'", "$accept", "Keywords",
824	"IdentifierName", "Literal", "PropertyName", "Property", "$@1", "$@2",
825	"PropertyList", "PrimaryExpr", "PrimaryExprNoBrace", "ArrayLiteral",
826	"ElementList", "ElisionOpt", "Elision", "MemberExpr", "MemberExprNoBF",
827	"NewExpr", "NewExprNoBF", "CallExpr", "CallExprNoBF", "Arguments",
828	"ArgumentList", "LeftHandSideExpr", "LeftHandSideExprNoBF",
829	"PostfixExpr", "PostfixExprNoBF", "UnaryExprCommon", "UnaryExpr",
830	"UnaryExprNoBF", "MultiplicativeExpr", "MultiplicativeExprNoBF",
831	"AdditiveExpr", "AdditiveExprNoBF", "ShiftExpr", "ShiftExprNoBF",
832	"RelationalExpr", "RelationalExprNoIn", "RelationalExprNoBF",
833	"EqualityExpr", "EqualityExprNoIn", "EqualityExprNoBF", "BitwiseANDExpr",
834	"BitwiseANDExprNoIn", "BitwiseANDExprNoBF", "BitwiseXORExpr",
835	"BitwiseXORExprNoIn", "BitwiseXORExprNoBF", "BitwiseORExpr",
836	"BitwiseORExprNoIn", "BitwiseORExprNoBF", "LogicalANDExpr",
837	"LogicalANDExprNoIn", "LogicalANDExprNoBF", "LogicalORExpr",
838	"LogicalORExprNoIn", "LogicalORExprNoBF", "ConditionalExpr",
839	"ConditionalExprNoIn", "ConditionalExprNoBF", "AssignmentExpr",
840	"AssignmentExprNoIn", "AssignmentExprNoBF", "AssignmentOperator", "Expr",
841	"ExprNoIn", "ExprNoBF", "Statement", "Block", "VariableStatement",
842	"VariableDeclarationList", "VariableDeclarationListNoIn",
843	"VariableDeclaration", "VariableDeclarationNoIn", "ConstStatement",
844	"ConstDeclarationList", "ConstDeclaration", "Initializer",
845	"InitializerNoIn", "EmptyStatement", "ExprStatement", "IfStatement",
846	"IterationStatement", "ExprOpt", "ExprNoInOpt", "ContinueStatement",
847	"BreakStatement", "ReturnStatement", "WithStatement", "SwitchStatement",
848	"CaseBlock", "CaseClausesOpt", "CaseClauses", "CaseClause",
849	"DefaultClause", "LabelledStatement", "ThrowStatement", "TryStatement",
850	"DebuggerStatement", "PackageName", "ImportStatement",
851	"FunctionDeclaration", "$@3", "$@4", "FunctionExpr", "$@5", "$@6", "$@7",
852	"$@8", "FormalParameterList", "FunctionBody", "Program",
853	"SourceElements", "SourceElement", YY_NULL
854	};
855	#endif
856
857	# ifdef YYPRINT
858	/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
859	token YYLEX-NUM. */
860	static const yytype_uint16 yytoknum[] =
861	{
862	0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
863	265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
864	275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
865	285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
866	295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
867	305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
868	315, 316, 317, 318, 319, 47, 58, 40, 41, 44,
869	123, 125, 91, 93, 46, 43, 45, 126, 33, 42,
870	37, 60, 62, 38, 94, 124, 63, 61, 59
871	};
872	# endif
873
874	/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
875	static const yytype_uint8 yyr1[] =
876	{
877	0, 89, 90, 90, 90, 90, 90, 90, 90, 90,
878	90, 90, 90, 90, 90, 90, 90, 90, 90, 90,
879	90, 90, 90, 90, 90, 90, 90, 90, 90, 90,
880	90, 90, 90, 91, 91, 92, 92, 92, 92, 92,
881	92, 92, 93, 93, 93, 94, 95, 94, 96, 94,
882	97, 97, 98, 98, 98, 98, 99, 99, 99, 99,
883	99, 100, 100, 100, 101, 101, 102, 102, 103, 103,
884	104, 104, 104, 104, 104, 105, 105, 105, 105, 106,
885	106, 107, 107, 108, 108, 108, 108, 109, 109, 109,
886	109, 110, 110, 111, 111, 112, 112, 113, 113, 114,
887	114, 114, 115, 115, 115, 116, 116, 116, 116, 116,
888	116, 116, 116, 116, 116, 116, 117, 117, 118, 118,
889	119, 119, 119, 119, 120, 120, 120, 120, 121, 121,
890	121, 122, 122, 122, 123, 123, 123, 123, 124, 124,
891	124, 124, 125, 125, 125, 125, 125, 125, 125, 126,
892	126, 126, 126, 126, 126, 127, 127, 127, 127, 127,
893	127, 127, 128, 128, 128, 128, 128, 129, 129, 129,
894	129, 129, 130, 130, 130, 130, 130, 131, 131, 132,
895	132, 133, 133, 134, 134, 135, 135, 136, 136, 137,
896	137, 138, 138, 139, 139, 140, 140, 141, 141, 142,
897	142, 143, 143, 144, 144, 145, 145, 146, 146, 147,
898	147, 148, 148, 149, 149, 150, 150, 151, 151, 152,
899	152, 152, 152, 152, 152, 152, 152, 152, 152, 152,
900	152, 153, 153, 154, 154, 155, 155, 156, 156, 156,
901	156, 156, 156, 156, 156, 156, 156, 156, 156, 156,
902	156, 156, 156, 156, 157, 157, 158, 158, 159, 159,
903	160, 160, 161, 161, 162, 162, 163, 163, 164, 164,
904	165, 165, 166, 167, 168, 169, 169, 170, 170, 171,
905	171, 171, 171, 171, 171, 171, 171, 172, 172, 173,
906	173, 174, 174, 174, 174, 175, 175, 175, 175, 176,
907	176, 176, 176, 177, 178, 179, 179, 180, 180, 181,
908	181, 182, 182, 183, 183, 184, 185, 185, 186, 186,
909	186, 187, 187, 188, 188, 189, 189, 189, 189, 189,
910	189, 191, 190, 192, 190, 194, 193, 195, 193, 196,
911	193, 197, 193, 198, 198, 199, 199, 200, 200, 201,
912	201, 202, 202
913	};
914
915	/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
916	static const yytype_uint8 yyr2[] =
917	{
918	0, 2, 1, 1, 1, 1, 1, 1, 1, 1,
919	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
920	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
921	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
922	1, 1, 1, 1, 1, 3, 0, 6, 0, 7,
923	1, 3, 1, 2, 3, 4, 1, 1, 1, 1,
924	3, 3, 3, 5, 2, 4, 0, 1, 1, 2,
925	1, 1, 4, 3, 3, 1, 4, 3, 3, 1,
926	2, 1, 2, 2, 2, 4, 3, 2, 2, 4,
927	3, 2, 3, 1, 3, 1, 1, 1, 1, 1,
928	2, 2, 1, 2, 2, 2, 2, 2, 2, 2,
929	2, 2, 2, 2, 2, 2, 1, 1, 1, 1,
930	1, 3, 3, 3, 1, 3, 3, 3, 1, 3,
931	3, 1, 3, 3, 1, 3, 3, 3, 1, 3,
932	3, 3, 1, 3, 3, 3, 3, 3, 3, 1,
933	3, 3, 3, 3, 3, 1, 3, 3, 3, 3,
934	3, 3, 1, 3, 3, 3, 3, 1, 3, 3,
935	3, 3, 1, 3, 3, 3, 3, 1, 3, 1,
936	3, 1, 3, 1, 3, 1, 3, 1, 3, 1,
937	3, 1, 3, 1, 3, 1, 3, 1, 3, 1,
938	3, 1, 3, 1, 3, 1, 3, 1, 5, 1,
939	5, 1, 5, 1, 3, 1, 3, 1, 3, 1,
940	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
941	1, 1, 3, 1, 3, 1, 3, 1, 1, 1,
942	1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
943	1, 1, 1, 1, 2, 3, 3, 3, 1, 3,
944	1, 3, 1, 2, 1, 2, 3, 3, 1, 3,
945	1, 2, 2, 2, 1, 2, 2, 5, 7, 7,
946	7, 5, 9, 10, 7, 8, 9, 0, 1, 0,
947	1, 2, 2, 3, 3, 2, 2, 3, 3, 2,
948	2, 3, 3, 5, 5, 3, 5, 0, 1, 1,
949	2, 3, 4, 2, 3, 3, 3, 3, 4, 7,
950	9, 2, 2, 1, 3, 5, 5, 3, 3, 5,
951	5, 0, 6, 0, 7, 0, 5, 0, 6, 0,
952	6, 0, 7, 1, 3, 2, 3, 0, 1, 1,
953	2, 1, 1
954	};
955
956	/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
957	Performed when YYTABLE doesn't specify something else to do. Zero
958	means the default is an error. */
959	static const yytype_uint16 yydefact[] =
960	{
961	347, 35, 36, 37, 0, 0, 0, 0, 0, 0,
962	0, 0, 0, 0, 0, 56, 0, 0, 0, 0,
963	0, 0, 0, 0, 0, 0, 0, 41, 38, 39,
964	59, 0, 0, 40, 0, 0, 66, 0, 0, 0,
965	0, 274, 57, 75, 58, 81, 97, 98, 102, 118,
966	119, 124, 131, 138, 155, 172, 181, 187, 193, 199,
967	205, 211, 217, 235, 0, 352, 237, 238, 239, 240,
968	241, 242, 243, 244, 245, 246, 247, 248, 249, 250,
969	251, 252, 253, 351, 0, 348, 349, 296, 0, 295,
970	289, 0, 0, 59, 0, 70, 52, 79, 82, 71,
971	262, 0, 258, 270, 0, 268, 292, 0, 291, 0,
972	300, 299, 79, 95, 96, 99, 116, 117, 120, 128,
973	134, 142, 162, 177, 183, 189, 195, 201, 207, 213,
974	231, 0, 99, 106, 105, 0, 0, 0, 107, 0,
975	0, 0, 0, 322, 321, 323, 0, 108, 110, 0,
976	109, 111, 0, 254, 0, 68, 0, 0, 67, 112,
977	113, 114, 115, 0, 0, 0, 87, 0, 0, 88,
978	103, 104, 220, 221, 222, 223, 224, 225, 226, 227,
979	230, 228, 229, 219, 0, 0, 0, 0, 0, 0,
980	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
981	0, 0, 0, 0, 0, 0, 0, 0, 0, 276,
982	0, 275, 1, 350, 298, 297, 0, 99, 149, 167,
983	179, 185, 191, 197, 203, 209, 215, 233, 290, 0,
984	79, 80, 0, 0, 29, 30, 31, 2, 3, 4,
985	5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
986	15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
987	25, 26, 27, 28, 32, 44, 43, 33, 53, 34,
988	42, 0, 50, 0, 0, 0, 78, 0, 263, 257,
989	0, 256, 271, 267, 0, 266, 294, 293, 0, 83,
990	0, 0, 84, 100, 101, 0, 0, 0, 0, 0,
991	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
992	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
993	302, 0, 301, 0, 0, 0, 0, 0, 317, 316,
994	0, 0, 0, 328, 0, 327, 315, 60, 255, 66,
995	62, 61, 64, 69, 91, 0, 93, 0, 33, 77,
996	0, 90, 218, 126, 125, 127, 132, 133, 139, 140,
997	141, 161, 160, 158, 159, 156, 157, 173, 174, 175,
998	176, 182, 188, 194, 200, 206, 0, 236, 264, 0,
999	260, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1000	0, 0, 0, 0, 0, 0, 0, 0, 0, 287,
1001	74, 0, 343, 335, 0, 0, 0, 0, 54, 0,
1002	73, 272, 259, 269, 331, 0, 0, 86, 214, 122,
1003	121, 123, 129, 130, 135, 136, 137, 148, 147, 145,
1004	146, 143, 144, 163, 164, 165, 166, 178, 184, 190,
1005	196, 202, 0, 232, 0, 0, 0, 0, 0, 0,
1006	318, 323, 0, 324, 0, 0, 92, 0, 76, 89,
1007	0, 0, 0, 265, 0, 287, 0, 99, 216, 154,
1008	152, 153, 150, 151, 168, 169, 170, 171, 180, 186,
1009	192, 198, 204, 0, 234, 288, 0, 339, 0, 0,
1010	337, 0, 0, 45, 55, 51, 72, 0, 333, 85,
1011	0, 277, 0, 281, 307, 304, 303, 0, 330, 0,
1012	329, 326, 325, 63, 65, 94, 212, 0, 273, 0,
1013	264, 261, 0, 0, 0, 287, 0, 341, 0, 336,
1014	0, 344, 46, 0, 332, 0, 208, 0, 0, 0,
1015	0, 308, 309, 0, 0, 0, 265, 287, 284, 210,
1016	0, 340, 0, 345, 0, 338, 0, 48, 334, 278,
1017	280, 279, 0, 0, 305, 307, 310, 319, 285, 0,
1018	0, 0, 342, 346, 47, 0, 311, 313, 0, 0,
1019	286, 0, 282, 49, 312, 314, 306, 320, 283
1020	};
1021
1022	/* YYDEFGOTO[NTERM-NUM]. */
1023	static const yytype_int16 yydefgoto[] =
1024	{
1025	-1, 269, 270, 42, 271, 272, 556, 575, 273, 95,
1026	96, 44, 156, 157, 158, 112, 45, 113, 46, 114,
1027	47, 166, 345, 132, 48, 116, 49, 117, 118, 51,
1028	119, 52, 120, 53, 121, 54, 122, 219, 55, 123,
1029	220, 56, 124, 221, 57, 125, 222, 58, 126, 223,
1030	59, 127, 224, 60, 128, 225, 61, 129, 226, 62,
1031	130, 227, 63, 382, 485, 228, 64, 65, 66, 67,
1032	101, 379, 102, 380, 68, 104, 105, 278, 463, 69,
1033	70, 71, 72, 486, 229, 73, 74, 75, 76, 77,
1034	505, 540, 541, 542, 565, 78, 79, 80, 81, 146,
1035	82, 83, 497, 535, 99, 489, 530, 526, 552, 404,
1036	529, 84, 85, 86
1037	};
1038
1039	/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1040	STATE-NUM. */
1041	#define YYPACT_NINF -424
1042	static const yytype_int16 yypact[] =
1043	{
1044	1118, -424, -424, -424, 7, 15, 320, 17, 44, 25,
1045	58, 718, 1502, 1502, 37, -424, 1198, 64, 1502, 116,
1046	137, 1502, 152, 67, 145, 1502, 1502, -424, -424, -424,
1047	175, 1502, 1502, -424, 1502, 798, 189, 1502, 1502, 1502,
1048	1502, -424, -424, -424, -424, 40, -424, 117, 555, -424,
1049	-424, -424, 115, 71, 46, 165, 217, 161, 193, 209,
1050	242, 5, -424, -424, 39, -424, -424, -424, -424, -424,
1051	-424, -424, -424, -424, -424, -424, -424, -424, -424, -424,
1052	-424, -424, -424, -424, 295, 1118, -424, -424, 74, -424,
1053	226, 320, -4, -424, 1578, -424, -424, 149, -424, -424,
1054	210, 63, -424, 210, 69, -424, -424, 75, -424, 232,
1055	-424, -424, 149, -424, 153, 699, -424, -424, -424, 135,
1056	157, 233, 170, 228, 224, 216, 241, 268, 13, -424,
1057	-424, 87, 204, -424, -424, 1502, 301, 1502, -424, 1502,
1058	1502, 89, 231, -424, -424, 246, 27, -424, -424, 1198,
1059	-424, -424, 200, -424, 878, -424, 36, 1274, 259, -424,
1060	-424, -424, -424, 1350, 1502, 656, -424, 1502, 656, -424,
1061	-424, -424, -424, -424, -424, -424, -424, -424, -424, -424,
1062	-424, -424, -424, -424, 1502, 1502, 1502, 1502, 1502, 1502,
1063	1502, 1502, 1502, 1502, 1502, 1502, 1502, 1502, 1502, 1502,
1064	1502, 1502, 1502, 1502, 1502, 1502, 1502, 1502, 1502, -424,
1065	1502, -424, -424, -424, -424, -424, 286, 362, 233, 178,
1066	236, 271, 280, 273, 322, 14, -424, -424, 297, 279,
1067	149, -424, 302, 16, -424, -424, -424, -424, -424, -424,
1068	-424, -424, -424, -424, -424, -424, -424, -424, -424, -424,
1069	-424, -424, -424, -424, -424, -424, -424, -424, -424, -424,
1070	-424, -424, -424, -424, -424, -424, -424, 656, -424, -424,
1071	-424, 304, -424, 90, 1502, 656, -424, 1502, -424, -424,
1072	17, -424, -424, -424, 44, -424, -424, -424, 35, -424,
1073	1502, 656, -424, -424, -424, 1502, 1502, 1502, 1502, 1502,
1074	1502, 1502, 1502, 1502, 1502, 1502, 1502, 1502, 1502, 1502,
1075	1502, 1502, 1502, 1502, 1502, 1502, 1502, 1502, 1502, 1502,
1076	-424, 1502, -424, 215, 306, 237, 247, 267, -424, -424,
1077	307, 152, 309, -424, 4, -424, -424, -424, -424, 189,
1078	-424, -424, -424, -424, -424, 269, -424, 112, -424, -424,
1079	113, -424, -424, -424, -424, -424, 135, 135, 157, 157,
1080	157, 233, 233, 233, 233, 233, 233, 170, 170, 170,
1081	170, 228, 224, 216, 241, 268, 312, -424, 23, -15,
1082	-424, 1502, 1502, 1502, 1502, 1502, 1502, 1502, 1502, 1502,
1083	1502, 1502, 1502, 1502, 1502, 1502, 1502, 1502, 1502, 1502,
1084	-424, 55, -424, -424, 272, 308, 1502, 1647, -424, 155,
1085	-424, -424, -424, -424, -424, 274, 166, -424, -424, -424,
1086	-424, -424, 135, 135, 157, 157, 157, 233, 233, 233,
1087	233, 233, 233, 170, 170, 170, 170, 228, 224, 216,
1088	241, 268, 313, -424, 1198, 1502, 1198, 298, 1198, 315,
1089	-424, -424, 79, -424, 76, 1426, -424, 1502, -424, -424,
1090	1502, 1502, 1502, 364, 326, 1502, 276, 699, -424, 233,
1091	233, 233, 233, 233, 178, 178, 178, 178, 236, 271,
1092	280, 273, 322, 323, -424, 324, 303, -424, 278, 325,
1093	-424, 332, 134, -424, -424, -424, -424, 325, -424, -424,
1094	1502, 361, 282, -424, 390, -424, -424, 330, -424, 337,
1095	-424, -424, -424, -424, -424, -424, -424, 284, -424, 1502,
1096	316, -424, 317, 1198, 1502, 1502, 325, -424, 958, -424,
1097	325, -424, -424, 292, -424, 325, -424, 1198, 80, 1502,
1098	45, 390, -424, 152, 1198, 294, -424, 1502, -424, -424,
1099	336, -424, 325, -424, 1038, -424, 325, -424, -424, -424,
1100	-424, -424, 56, 342, -424, 390, -424, 378, -424, 1198,
1101	354, 1198, -424, -424, -424, 325, 1118, 1118, 339, 152,
1102	-424, 1198, -424, -424, 1118, 1118, -424, -424, -424
1103	};
1104
1105	/* YYPGOTO[NTERM-NUM]. */
1106	static const yytype_int16 yypgoto[] =
1107	{
1108	-424, -424, -156, -424, -424, 18, -424, -424, -424, -424,
1109	0, -424, -424, 84, -424, 42, -424, 83, -424, -424,
1110	-424, -40, -424, 192, -424, -424, -424, 11, 12, -424,
1111	-155, -424, -173, -424, 311, -424, -140, -70, -424, -193,
1112	32, -424, -189, 33, -424, -176, 34, -424, -174, 41,
1113	-424, -168, 31, -424, -424, -424, -424, -424, -424, -424,
1114	-143, -376, -424, -17, 2, -424, -424, -13, -18, -424,
1115	-424, -424, 150, -35, -424, -424, 148, 331, -82, -424,
1116	-424, -424, -424, -423, -424, -424, -424, -424, -424, -424,
1117	-424, -128, -424, -102, -424, -424, -424, -424, -424, 108,
1118	-424, -424, -424, -424, -424, -424, -424, -424, -424, -283,
1119	-318, -424, -34, -83
1120	};
1121
1122	/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
1123	positive, shift that token. If negative, reduce the rule which
1124	number is the opposite. If YYTABLE_NINF, syntax error. */
1125	#define YYTABLE_NINF -1
1126	static const yytype_uint16 yytable[] =
1127	{
1128	43, 154, 213, 136, 142, 415, 468, 169, 87, 349,
1129	371, 50, 351, 131, 342, 372, 43, 358, 359, 360,
1130	346, 483, 484, 141, 133, 134, 106, 50, 333, 373,
1131	138, 184, 374, 356, 357, 43, 152, 147, 148, 375,
1132	209, 352, 522, 150, 151, 461, 50, 207, 97, 159,
1133	160, 161, 162, 563, 464, 318, 396, 276, 232, 367,
1134	368, 369, 370, 233, 279, 376, 453, 377, 143, 88,
1135	283, 213, 289, 465, 292, 214, 286, 511, 402, 100,
1136	508, 560, 90, 454, 403, 43, 518, 107, 320, 98,
1137	328, 208, 190, 191, 192, 89, 50, 402, 295, 319,
1138	397, 334, 550, 414, 135, 339, 103, 163, 210, 340,
1139	462, 405, 164, 108, 165, 335, 564, 402, 488, 410,
1140	109, 437, 576, 487, 570, 321, 438, 211, 424, 425,
1141	426, 137, 280, 230, 411, 417, 336, 323, 284, 325,
1142	439, 326, 327, 440, 422, 423, 188, 189, 549, 43,
1143	441, 281, 418, 509, 43, 144, 321, 285, 321, 407,
1144	50, 408, 215, 287, 512, 50, 347, 510, 561, 350,
1145	433, 434, 435, 436, 231, 322, 442, 329, 443, 534,
1146	185, 321, 321, 139, 163, 458, 459, 193, 194, 167,
1147	400, 168, 304, 305, 186, 187, 402, 353, 354, 355,
1148	296, 383, 532, 115, 140, 195, 196, 145, 551, 533,
1149	306, 307, 555, 115, 297, 298, 163, 558, 384, 385,
1150	163, 274, 35, 275, 321, 290, 115, 291, 496, 1,
1151	2, 3, 299, 300, 572, 321, 91, 216, 574, 499,
1152	92, 149, 12, 13, 203, 15, 197, 198, 293, 294,
1153	18, 308, 309, 199, 200, 201, 202, 583, 155, 386,
1154	387, 330, 331, 493, 310, 311, 312, 313, 337, 321,
1155	25, 26, 388, 389, 390, 391, 409, 204, 27, 301,
1156	302, 303, 217, 444, 321, 206, 28, 29, 93, 31,
1157	32, 33, 416, 34, 205, 212, 94, 277, 36, 288,
1158	315, 37, 38, 39, 40, 446, 321, 314, 419, 420,
1159	421, 317, 514, 450, 515, 447, 321, 516, 474, 475,
1160	476, 477, 324, 1, 2, 3, 316, 115, 343, 115,
1161	91, 115, 115, 332, 92, 448, 321, 456, 457, 15,
1162	490, 491, 498, 491, 523, 321, 527, 491, 378, 115,
1163	538, 321, 544, 321, 392, 115, 115, 536, 394, 115,
1164	557, 491, 569, 321, 393, 395, 398, 399, 504, 401,
1165	406, 451, 27, 445, 449, 492, 115, 507, 460, 500,
1166	28, 29, 93, 466, 381, 33, 519, 34, 520, 524,
1167	94, 525, 36, 321, 531, 528, 537, 539, 543, 453,
1168	115, 218, 115, 462, 571, 547, 293, 294, 577, 579,
1169	586, 172, 173, 174, 175, 176, 177, 178, 179, 180,
1170	181, 182, 581, 455, 478, 495, 479, 482, 480, 521,
1171	412, 501, 413, 503, 282, 506, 481, 578, 546, 566,
1172	452, 0, 0, 0, 43, 0, 43, 502, 43, 183,
1173	0, 0, 0, 0, 0, 50, 0, 50, 0, 50,
1174	0, 0, 0, 517, 0, 0, 115, 0, 0, 115,
1175	0, 213, 0, 0, 0, 0, 0, 0, 0, 0,
1176	0, 0, 115, 0, 0, 0, 0, 115, 0, 0,
1177	0, 0, 0, 0, 554, 0, 0, 0, 0, 0,
1178	0, 213, 213, 0, 361, 362, 363, 364, 365, 366,
1179	548, 115, 0, 115, 0, 0, 0, 0, 0, 0,
1180	0, 545, 0, 43, 559, 567, 0, 0, 43, 0,
1181	0, 568, 0, 0, 50, 0, 0, 43, 0, 50,
1182	0, 562, 584, 585, 43, 0, 0, 0, 50, 0,
1183	0, 0, 0, 0, 43, 50, 580, 0, 582, 0,
1184	0, 587, 0, 0, 0, 50, 0, 0, 588, 43,
1185	0, 43, 0, 115, 467, 0, 43, 43, 0, 0,
1186	50, 43, 50, 0, 43, 43, 0, 50, 50, 467,
1187	467, 115, 50, 0, 0, 50, 50, 0, 115, 170,
1188	171, 0, 0, 0, 172, 173, 174, 175, 176, 177,
1189	178, 179, 180, 181, 182, 427, 428, 429, 430, 431,
1190	432, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1191	0, 0, 0, 0, 0, 0, 0, 115, 0, 0,
1192	0, 0, 183, 0, 0, 0, 0, 115, 0, 115,
1193	0, 0, 115, 115, 467, 0, 0, 115, 0, 234,
1194	235, 236, 237, 238, 239, 240, 241, 242, 243, 244,
1195	245, 246, 247, 248, 249, 250, 251, 252, 253, 254,
1196	255, 256, 257, 0, 258, 259, 260, 261, 262, 263,
1197	0, 264, 115, 218, 469, 470, 471, 472, 473, 218,
1198	218, 218, 218, 218, 218, 218, 218, 218, 218, 218,
1199	0, 115, 0, 0, 0, 0, 467, 115, 348, 110,
1200	0, 1, 2, 3, 0, 0, 0, 0, 91, 0,
1201	0, 115, 92, 0, 12, 13, 0, 15, 0, 115,
1202	0, 0, 18, 293, 294, 0, 0, 0, 172, 173,
1203	174, 175, 176, 177, 178, 179, 180, 181, 182, 0,
1204	0, 0, 25, 26, 0, 0, 0, 0, 0, 0,
1205	27, 0, 0, 218, 0, 0, 0, 0, 28, 29,
1206	93, 31, 32, 33, 0, 34, 183, 0, 94, 0,
1207	36, 0, 0, 37, 38, 39, 40, 0, 0, 0,
1208	0, 1, 2, 3, 4, 0, 111, 5, 6, 7,
1209	8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
1210	0, 0, 18, 19, 20, 0, 21, 22, 0, 0,
1211	23, 24, 0, 0, 0, 218, 0, 0, 0, 0,
1212	0, 0, 25, 26, 0, 0, 0, 0, 0, 0,
1213	27, 0, 0, 0, 0, 0, 0, 0, 28, 29,
1214	30, 31, 32, 33, 0, 34, 0, 0, 35, 153,
1215	36, 0, 0, 37, 38, 39, 40, 0, 0, 0,
1216	0, 1, 2, 3, 4, 0, 41, 5, 6, 7,
1217	8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
1218	0, 0, 18, 19, 20, 0, 21, 22, 0, 0,
1219	23, 24, 0, 0, 0, 0, 0, 0, 0, 0,
1220	0, 0, 25, 26, 0, 0, 0, 0, 0, 0,
1221	27, 0, 0, 0, 0, 0, 0, 0, 28, 29,
1222	30, 31, 32, 33, 0, 34, 0, 0, 35, 338,
1223	36, 0, 0, 37, 38, 39, 40, 0, 0, 0,
1224	0, 1, 2, 3, 4, 0, 41, 5, 6, 7,
1225	8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
1226	0, 0, 18, 19, 20, 0, 21, 22, 0, 0,
1227	23, 24, 0, 0, 0, 0, 0, 0, 0, 0,
1228	0, 0, 25, 26, 0, 0, 0, 0, 0, 0,
1229	27, 0, 0, 0, 0, 0, 0, 0, 28, 29,
1230	30, 31, 32, 33, 0, 34, 0, 0, 35, 553,
1231	36, 0, 0, 37, 38, 39, 40, 0, 0, 0,
1232	0, 1, 2, 3, 4, 0, 41, 5, 6, 7,
1233	8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
1234	0, 0, 18, 19, 20, 0, 21, 22, 0, 0,
1235	23, 24, 0, 0, 0, 0, 0, 0, 0, 0,
1236	0, 0, 25, 26, 0, 0, 0, 0, 0, 0,
1237	27, 0, 0, 0, 0, 0, 0, 0, 28, 29,
1238	30, 31, 32, 33, 0, 34, 0, 0, 35, 573,
1239	36, 0, 0, 37, 38, 39, 40, 0, 0, 0,
1240	0, 1, 2, 3, 4, 0, 41, 5, 6, 7,
1241	8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
1242	0, 0, 18, 19, 20, 0, 21, 22, 0, 0,
1243	23, 24, 0, 0, 0, 0, 0, 0, 0, 0,
1244	0, 0, 25, 26, 0, 0, 0, 0, 0, 0,
1245	27, 0, 0, 0, 0, 0, 0, 0, 28, 29,
1246	30, 31, 32, 33, 0, 34, 0, 0, 35, 0,
1247	36, 0, 0, 37, 38, 39, 40, 0, 0, 0,
1248	0, 1, 2, 3, 4, 0, 41, 5, 6, 7,
1249	8, 9, 0, 11, 12, 13, 14, 15, 16, 17,
1250	0, 0, 18, 19, 20, 0, 21, 22, 0, 0,
1251	23, 24, 0, 0, 0, 0, 0, 0, 0, 0,
1252	0, 0, 25, 26, 0, 0, 0, 0, 0, 0,
1253	27, 0, 0, 0, 0, 0, 0, 0, 28, 29,
1254	30, 31, 32, 33, 0, 34, 0, 0, 35, 0,
1255	36, 0, 0, 37, 38, 39, 40, 1, 2, 3,
1256	0, 0, 0, 0, 91, 0, 41, 0, 92, 0,
1257	12, 13, 0, 15, 0, 0, 0, 0, 18, 0,
1258	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1259	0, 0, 0, 0, 0, 0, 0, 0, 25, 26,
1260	0, 0, 0, 0, 0, 0, 27, 0, 0, 0,
1261	0, 0, 0, 0, 28, 29, 93, 31, 32, 33,
1262	0, 34, 0, 0, 94, 0, 36, 341, 0, 37,
1263	38, 39, 40, 1, 2, 3, 0, 0, 0, 0,
1264	91, 0, 0, 0, 92, 0, 12, 13, 0, 15,
1265	0, 0, 0, 0, 18, 0, 0, 0, 0, 0,
1266	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1267	0, 0, 0, 0, 25, 26, 0, 0, 0, 0,
1268	0, 0, 27, 0, 0, 0, 0, 0, 0, 0,
1269	28, 29, 93, 31, 32, 33, 0, 34, 344, 0,
1270	94, 0, 36, 0, 0, 37, 38, 39, 40, 1,
1271	2, 3, 0, 0, 0, 0, 91, 0, 0, 0,
1272	92, 0, 12, 13, 0, 15, 0, 0, 0, 0,
1273	18, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1274	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1275	25, 26, 0, 0, 0, 0, 0, 0, 27, 0,
1276	0, 0, 0, 0, 0, 0, 28, 29, 93, 31,
1277	32, 33, 0, 34, 0, 0, 94, 0, 36, 513,
1278	0, 37, 38, 39, 40, 1, 2, 3, 0, 0,
1279	0, 0, 91, 0, 0, 0, 92, 0, 12, 13,
1280	0, 15, 0, 0, 0, 0, 18, 0, 0, 0,
1281	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1282	0, 0, 0, 0, 0, 0, 25, 26, 0, 0,
1283	0, 0, 0, 0, 27, 0, 0, 0, 0, 0,
1284	0, 0, 28, 29, 93, 31, 32, 33, 0, 34,
1285	0, 0, 94, 0, 36, 0, 0, 37, 38, 39,
1286	40, 234, 235, 236, 237, 238, 239, 240, 241, 242,
1287	243, 244, 245, 246, 247, 248, 249, 250, 251, 252,
1288	253, 254, 255, 256, 257, 0, 258, 259, 260, 261,
1289	262, 263, 0, 264, 0, 0, 0, 0, 0, 0,
1290	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1291	0, 0, 0, 0, 0, 0, 0, 0, 265, 266,
1292	267, 0, 0, 0, 0, 0, 0, 0, 0, 268,
1293	234, 235, 236, 237, 238, 239, 240, 241, 242, 243,
1294	244, 245, 246, 247, 248, 249, 250, 251, 252, 253,
1295	254, 255, 256, 257, 0, 258, 259, 260, 261, 262,
1296	263, 0, 264, 0, 0, 0, 0, 0, 0, 0,
1297	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1298	0, 0, 0, 0, 0, 0, 0, 265, 266, 267,
1299	0, 0, 0, 0, 0, 0, 0, 0, 494
1300	};
1301
1302	#define yypact_value_is_default(Yystate) \
1303	(!!((Yystate) == (-424)))
1304
1305	#define yytable_value_is_error(Yytable_value) \
1306	YYID (0)
1307
1308	static const yytype_int16 yycheck[] =
1309	{
1310	0, 35, 85, 16, 22, 288, 382, 47, 1, 165,
1311	203, 0, 168, 11, 157, 204, 16, 190, 191, 192,
1312	163, 397, 398, 21, 12, 13, 1, 16, 1, 205,
1313	18, 48, 206, 188, 189, 35, 34, 25, 26, 207,
1314	1, 184, 465, 31, 32, 22, 35, 42, 6, 37,
1315	38, 39, 40, 8, 69, 42, 42, 97, 62, 199,
1316	200, 201, 202, 67, 1, 208, 62, 210, 1, 62,
1317	1, 154, 112, 88, 114, 1, 1, 1, 62, 62,
1318	1, 1, 67, 79, 68, 85, 462, 62, 1, 6,
1319	1, 86, 46, 47, 48, 88, 85, 62, 115, 86,
1320	86, 74, 525, 68, 67, 69, 62, 67, 69, 73,
1321	87, 267, 72, 88, 74, 88, 71, 62, 401, 275,
1322	62, 314, 66, 68, 547, 69, 315, 88, 301, 302,
1323	303, 67, 69, 91, 277, 291, 149, 135, 69, 137,
1324	316, 139, 140, 317, 299, 300, 75, 76, 524, 149,
1325	318, 88, 295, 74, 154, 88, 69, 88, 69, 69,
1326	149, 71, 88, 88, 88, 154, 164, 88, 88, 167,
1327	310, 311, 312, 313, 91, 88, 319, 88, 321, 497,
1328	65, 69, 69, 67, 67, 73, 73, 22, 23, 72,
1329	230, 74, 22, 23, 79, 80, 62, 185, 186, 187,
1330	65, 23, 68, 11, 67, 40, 41, 62, 526, 492,
1331	40, 41, 530, 21, 79, 80, 67, 535, 40, 41,
1332	67, 72, 70, 74, 69, 72, 34, 74, 73, 3,
1333	4, 5, 75, 76, 552, 69, 10, 11, 556, 73,
1334	14, 66, 16, 17, 83, 19, 81, 82, 44, 45,
1335	24, 81, 82, 36, 37, 38, 39, 575, 69, 81,
1336	82, 30, 31, 406, 36, 37, 38, 39, 68, 69,
1337	44, 45, 36, 37, 38, 39, 274, 84, 52, 46,
1338	47, 48, 90, 68, 69, 43, 60, 61, 62, 63,
1339	64, 65, 290, 67, 85, 0, 70, 87, 72, 67,
1340	84, 75, 76, 77, 78, 68, 69, 83, 296, 297,
1341	298, 43, 455, 331, 457, 68, 69, 460, 388, 389,
1342	390, 391, 21, 3, 4, 5, 85, 135, 69, 137,
1343	10, 139, 140, 87, 14, 68, 69, 68, 69, 19,
1344	68, 69, 68, 69, 68, 69, 68, 69, 62, 157,
1345	68, 69, 68, 69, 83, 163, 164, 500, 85, 167,
1346	68, 69, 68, 69, 84, 43, 69, 88, 70, 67,
1347	66, 62, 52, 67, 67, 67, 184, 62, 66, 66,
1348	60, 61, 62, 381, 22, 65, 22, 67, 62, 66,
1349	70, 88, 72, 69, 62, 70, 35, 7, 68, 62,
1350	208, 90, 210, 87, 68, 88, 44, 45, 66, 31,
1351	71, 49, 50, 51, 52, 53, 54, 55, 56, 57,
1352	58, 59, 68, 339, 392, 407, 393, 396, 394, 464,
1353	280, 444, 284, 446, 103, 448, 395, 565, 520, 541,
1354	332, -1, -1, -1, 444, -1, 446, 445, 448, 87,
1355	-1, -1, -1, -1, -1, 444, -1, 446, -1, 448,
1356	-1, -1, -1, 461, -1, -1, 274, -1, -1, 277,
1357	-1, 554, -1, -1, -1, -1, -1, -1, -1, -1,
1358	-1, -1, 290, -1, -1, -1, -1, 295, -1, -1,
1359	-1, -1, -1, -1, 528, -1, -1, -1, -1, -1,
1360	-1, 584, 585, -1, 193, 194, 195, 196, 197, 198,
1361	523, 319, -1, 321, -1, -1, -1, -1, -1, -1,
1362	-1, 519, -1, 523, 537, 543, -1, -1, 528, -1,
1363	-1, 544, -1, -1, 523, -1, -1, 537, -1, 528,
1364	-1, 539, 576, 577, 544, -1, -1, -1, 537, -1,
1365	-1, -1, -1, -1, 554, 544, 569, -1, 571, -1,
1366	-1, 579, -1, -1, -1, 554, -1, -1, 581, 569,
1367	-1, 571, -1, 381, 382, -1, 576, 577, -1, -1,
1368	569, 581, 571, -1, 584, 585, -1, 576, 577, 397,
1369	398, 399, 581, -1, -1, 584, 585, -1, 406, 44,
1370	45, -1, -1, -1, 49, 50, 51, 52, 53, 54,
1371	55, 56, 57, 58, 59, 304, 305, 306, 307, 308,
1372	309, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1373	-1, -1, -1, -1, -1, -1, -1, 445, -1, -1,
1374	-1, -1, 87, -1, -1, -1, -1, 455, -1, 457,
1375	-1, -1, 460, 461, 462, -1, -1, 465, -1, 3,
1376	4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
1377	14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
1378	24, 25, 26, -1, 28, 29, 30, 31, 32, 33,
1379	-1, 35, 500, 382, 383, 384, 385, 386, 387, 388,
1380	389, 390, 391, 392, 393, 394, 395, 396, 397, 398,
1381	-1, 519, -1, -1, -1, -1, 524, 525, 62, 1,
1382	-1, 3, 4, 5, -1, -1, -1, -1, 10, -1,
1383	-1, 539, 14, -1, 16, 17, -1, 19, -1, 547,
1384	-1, -1, 24, 44, 45, -1, -1, -1, 49, 50,
1385	51, 52, 53, 54, 55, 56, 57, 58, 59, -1,
1386	-1, -1, 44, 45, -1, -1, -1, -1, -1, -1,
1387	52, -1, -1, 462, -1, -1, -1, -1, 60, 61,
1388	62, 63, 64, 65, -1, 67, 87, -1, 70, -1,
1389	72, -1, -1, 75, 76, 77, 78, -1, -1, -1,
1390	-1, 3, 4, 5, 6, -1, 88, 9, 10, 11,
1391	12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
1392	-1, -1, 24, 25, 26, -1, 28, 29, -1, -1,
1393	32, 33, -1, -1, -1, 524, -1, -1, -1, -1,
1394	-1, -1, 44, 45, -1, -1, -1, -1, -1, -1,
1395	52, -1, -1, -1, -1, -1, -1, -1, 60, 61,
1396	62, 63, 64, 65, -1, 67, -1, -1, 70, 71,
1397	72, -1, -1, 75, 76, 77, 78, -1, -1, -1,
1398	-1, 3, 4, 5, 6, -1, 88, 9, 10, 11,
1399	12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
1400	-1, -1, 24, 25, 26, -1, 28, 29, -1, -1,
1401	32, 33, -1, -1, -1, -1, -1, -1, -1, -1,
1402	-1, -1, 44, 45, -1, -1, -1, -1, -1, -1,
1403	52, -1, -1, -1, -1, -1, -1, -1, 60, 61,
1404	62, 63, 64, 65, -1, 67, -1, -1, 70, 71,
1405	72, -1, -1, 75, 76, 77, 78, -1, -1, -1,
1406	-1, 3, 4, 5, 6, -1, 88, 9, 10, 11,
1407	12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
1408	-1, -1, 24, 25, 26, -1, 28, 29, -1, -1,
1409	32, 33, -1, -1, -1, -1, -1, -1, -1, -1,
1410	-1, -1, 44, 45, -1, -1, -1, -1, -1, -1,
1411	52, -1, -1, -1, -1, -1, -1, -1, 60, 61,
1412	62, 63, 64, 65, -1, 67, -1, -1, 70, 71,
1413	72, -1, -1, 75, 76, 77, 78, -1, -1, -1,
1414	-1, 3, 4, 5, 6, -1, 88, 9, 10, 11,
1415	12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
1416	-1, -1, 24, 25, 26, -1, 28, 29, -1, -1,
1417	32, 33, -1, -1, -1, -1, -1, -1, -1, -1,
1418	-1, -1, 44, 45, -1, -1, -1, -1, -1, -1,
1419	52, -1, -1, -1, -1, -1, -1, -1, 60, 61,
1420	62, 63, 64, 65, -1, 67, -1, -1, 70, 71,
1421	72, -1, -1, 75, 76, 77, 78, -1, -1, -1,
1422	-1, 3, 4, 5, 6, -1, 88, 9, 10, 11,
1423	12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
1424	-1, -1, 24, 25, 26, -1, 28, 29, -1, -1,
1425	32, 33, -1, -1, -1, -1, -1, -1, -1, -1,
1426	-1, -1, 44, 45, -1, -1, -1, -1, -1, -1,
1427	52, -1, -1, -1, -1, -1, -1, -1, 60, 61,
1428	62, 63, 64, 65, -1, 67, -1, -1, 70, -1,
1429	72, -1, -1, 75, 76, 77, 78, -1, -1, -1,
1430	-1, 3, 4, 5, 6, -1, 88, 9, 10, 11,
1431	12, 13, -1, 15, 16, 17, 18, 19, 20, 21,
1432	-1, -1, 24, 25, 26, -1, 28, 29, -1, -1,
1433	32, 33, -1, -1, -1, -1, -1, -1, -1, -1,
1434	-1, -1, 44, 45, -1, -1, -1, -1, -1, -1,
1435	52, -1, -1, -1, -1, -1, -1, -1, 60, 61,
1436	62, 63, 64, 65, -1, 67, -1, -1, 70, -1,
1437	72, -1, -1, 75, 76, 77, 78, 3, 4, 5,
1438	-1, -1, -1, -1, 10, -1, 88, -1, 14, -1,
1439	16, 17, -1, 19, -1, -1, -1, -1, 24, -1,
1440	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1441	-1, -1, -1, -1, -1, -1, -1, -1, 44, 45,
1442	-1, -1, -1, -1, -1, -1, 52, -1, -1, -1,
1443	-1, -1, -1, -1, 60, 61, 62, 63, 64, 65,
1444	-1, 67, -1, -1, 70, -1, 72, 73, -1, 75,
1445	76, 77, 78, 3, 4, 5, -1, -1, -1, -1,
1446	10, -1, -1, -1, 14, -1, 16, 17, -1, 19,
1447	-1, -1, -1, -1, 24, -1, -1, -1, -1, -1,
1448	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1449	-1, -1, -1, -1, 44, 45, -1, -1, -1, -1,
1450	-1, -1, 52, -1, -1, -1, -1, -1, -1, -1,
1451	60, 61, 62, 63, 64, 65, -1, 67, 68, -1,
1452	70, -1, 72, -1, -1, 75, 76, 77, 78, 3,
1453	4, 5, -1, -1, -1, -1, 10, -1, -1, -1,
1454	14, -1, 16, 17, -1, 19, -1, -1, -1, -1,
1455	24, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1456	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1457	44, 45, -1, -1, -1, -1, -1, -1, 52, -1,
1458	-1, -1, -1, -1, -1, -1, 60, 61, 62, 63,
1459	64, 65, -1, 67, -1, -1, 70, -1, 72, 73,
1460	-1, 75, 76, 77, 78, 3, 4, 5, -1, -1,
1461	-1, -1, 10, -1, -1, -1, 14, -1, 16, 17,
1462	-1, 19, -1, -1, -1, -1, 24, -1, -1, -1,
1463	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1464	-1, -1, -1, -1, -1, -1, 44, 45, -1, -1,
1465	-1, -1, -1, -1, 52, -1, -1, -1, -1, -1,
1466	-1, -1, 60, 61, 62, 63, 64, 65, -1, 67,
1467	-1, -1, 70, -1, 72, -1, -1, 75, 76, 77,
1468	78, 3, 4, 5, 6, 7, 8, 9, 10, 11,
1469	12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
1470	22, 23, 24, 25, 26, -1, 28, 29, 30, 31,
1471	32, 33, -1, 35, -1, -1, -1, -1, -1, -1,
1472	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1473	-1, -1, -1, -1, -1, -1, -1, -1, 60, 61,
1474	62, -1, -1, -1, -1, -1, -1, -1, -1, 71,
1475	3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
1476	13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
1477	23, 24, 25, 26, -1, 28, 29, 30, 31, 32,
1478	33, -1, 35, -1, -1, -1, -1, -1, -1, -1,
1479	-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1480	-1, -1, -1, -1, -1, -1, -1, 60, 61, 62,
1481	-1, -1, -1, -1, -1, -1, -1, -1, 71
1482	};
1483
1484	/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1485	symbol of state STATE-NUM. */
1486	static const yytype_uint8 yystos[] =
1487	{
1488	0, 3, 4, 5, 6, 9, 10, 11, 12, 13,
1489	14, 15, 16, 17, 18, 19, 20, 21, 24, 25,
1490	26, 28, 29, 32, 33, 44, 45, 52, 60, 61,
1491	62, 63, 64, 65, 67, 70, 72, 75, 76, 77,
1492	78, 88, 92, 99, 100, 105, 107, 109, 113, 115,
1493	116, 118, 120, 122, 124, 127, 130, 133, 136, 139,
1494	142, 145, 148, 151, 155, 156, 157, 158, 163, 168,
1495	169, 170, 171, 174, 175, 176, 177, 178, 184, 185,
1496	186, 187, 189, 190, 200, 201, 202, 1, 62, 88,
1497	67, 10, 14, 62, 70, 98, 99, 104, 106, 193,
1498	62, 159, 161, 62, 164, 165, 1, 62, 88, 62,
1499	1, 88, 104, 106, 108, 112, 114, 116, 117, 119,
1500	121, 123, 125, 128, 131, 134, 137, 140, 143, 146,
1501	149, 153, 112, 117, 117, 67, 156, 67, 117, 67,
1502	67, 153, 157, 1, 88, 62, 188, 117, 117, 66,
1503	117, 117, 153, 71, 201, 69, 101, 102, 103, 117,
1504	117, 117, 117, 67, 72, 74, 110, 72, 74, 110,
1505	44, 45, 49, 50, 51, 52, 53, 54, 55, 56,
1506	57, 58, 59, 87, 152, 65, 79, 80, 75, 76,
1507	46, 47, 48, 22, 23, 40, 41, 81, 82, 36,
1508	37, 38, 39, 83, 84, 85, 43, 42, 86, 1,
1509	69, 88, 0, 202, 1, 88, 11, 112, 123, 126,
1510	129, 132, 135, 138, 141, 144, 147, 150, 154, 173,
1511	104, 106, 62, 67, 3, 4, 5, 6, 7, 8,
1512	9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
1513	19, 20, 21, 22, 23, 24, 25, 26, 28, 29,
1514	30, 31, 32, 33, 35, 60, 61, 62, 71, 90,
1515	91, 93, 94, 97, 72, 74, 110, 87, 166, 1,
1516	69, 88, 166, 1, 69, 88, 1, 88, 67, 110,
1517	72, 74, 110, 44, 45, 152, 65, 79, 80, 75,
1518	76, 46, 47, 48, 22, 23, 40, 41, 81, 82,
1519	36, 37, 38, 39, 83, 84, 85, 43, 42, 86,
1520	1, 69, 88, 153, 21, 153, 153, 153, 1, 88,
1521	30, 31, 87, 1, 74, 88, 156, 68, 71, 69,
1522	73, 73, 149, 69, 68, 111, 149, 153, 62, 91,
1523	153, 91, 149, 117, 117, 117, 119, 119, 121, 121,
1524	121, 123, 123, 123, 123, 123, 123, 125, 125, 125,
1525	125, 128, 131, 134, 137, 140, 149, 149, 62, 160,
1526	162, 22, 152, 23, 40, 41, 81, 82, 36, 37,
1527	38, 39, 83, 84, 85, 43, 42, 86, 69, 88,
1528	110, 67, 62, 68, 198, 91, 66, 69, 71, 153,
1529	91, 149, 161, 165, 68, 198, 153, 91, 149, 117,
1530	117, 117, 119, 119, 121, 121, 121, 123, 123, 123,
1531	123, 123, 123, 125, 125, 125, 125, 128, 131, 134,
1532	137, 140, 149, 149, 68, 67, 68, 68, 68, 67,
1533	157, 62, 188, 62, 79, 102, 68, 69, 73, 73,
1534	66, 22, 87, 167, 69, 88, 153, 112, 150, 123,
1535	123, 123, 123, 123, 126, 126, 126, 126, 129, 132,
1536	135, 138, 141, 150, 150, 153, 172, 68, 198, 194,
1537	68, 69, 67, 149, 71, 94, 73, 191, 68, 73,
1538	66, 156, 153, 156, 70, 179, 156, 62, 1, 74,
1539	88, 1, 88, 73, 149, 149, 149, 153, 150, 22,
1540	62, 162, 172, 68, 66, 88, 196, 68, 70, 199,
1541	195, 62, 68, 198, 199, 192, 149, 35, 68, 7,
1542	180, 181, 182, 68, 68, 153, 167, 88, 156, 150,
1543	172, 199, 197, 71, 201, 199, 95, 68, 199, 156,
1544	1, 88, 153, 8, 71, 183, 182, 157, 156, 68,
1545	172, 68, 199, 71, 199, 96, 66, 66, 180, 31,
1546	156, 68, 156, 199, 201, 201, 71, 157, 156
1547	};
1548
1549	#define yyerrok (yyerrstatus = 0)
1550	#define yyclearin (yychar = YYEMPTY)
1551	#define YYEMPTY (-2)
1552	#define YYEOF 0
1553
1554	#define YYACCEPT goto yyacceptlab
1555	#define YYABORT goto yyabortlab
1556	#define YYERROR goto yyerrorlab
1557
1558
1559	/* Like YYERROR except do call yyerror. This remains here temporarily
1560	to ease the transition to the new meaning of YYERROR, for GCC.
1561	Once GCC version 2 has supplanted version 1, this can go. However,
1562	YYFAIL appears to be in use. Nevertheless, it is formally deprecated
1563	in Bison 2.4.2's NEWS entry, where a plan to phase it out is
1564	discussed. */
1565
1566	#define YYFAIL goto yyerrlab
1567	#if defined YYFAIL
1568	/* This is here to suppress warnings from the GCC cpp's
1569	-Wunused-macros. Normally we don't worry about that warning, but
1570	some users do, and we want to make it easy for users to remove
1571	YYFAIL uses, which will produce warnings from Bison 2.5. */
1572	#endif
1573
1574	#define YYRECOVERING() (!!yyerrstatus)
1575
1576	#define YYBACKUP(Token, Value) \
1577	do \
1578	if (yychar == YYEMPTY) \
1579	{ \
1580	yychar = (Token); \
1581	yylval = (Value); \
1582	YYPOPSTACK (yylen); \
1583	yystate = *yyssp; \
1584	goto yybackup; \
1585	} \
1586	else \
1587	{ \
1588	yyerror (YY_("syntax error: cannot back up")); \
1589	YYERROR; \
1590	} \
1591	while (YYID (0))
1592
1593	/* Error token number */
1594	#define YYTERROR 1
1595	#define YYERRCODE 256
1596
1597
1598	/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
1599	If N is 0, then set CURRENT to the empty location which ends
1600	the previous symbol: RHS[0] (always defined). */
1601
1602	#ifndef YYLLOC_DEFAULT
1603	# define YYLLOC_DEFAULT(Current, Rhs, N) \
1604	do \
1605	if (YYID (N)) \
1606	{ \
1607	(Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
1608	(Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
1609	(Current).last_line = YYRHSLOC (Rhs, N).last_line; \
1610	(Current).last_column = YYRHSLOC (Rhs, N).last_column; \
1611	} \
1612	else \
1613	{ \
1614	(Current).first_line = (Current).last_line = \
1615	YYRHSLOC (Rhs, 0).last_line; \
1616	(Current).first_column = (Current).last_column = \
1617	YYRHSLOC (Rhs, 0).last_column; \
1618	} \
1619	while (YYID (0))
1620	#endif
1621
1622	#define YYRHSLOC(Rhs, K) ((Rhs)[K])
1623
1624
1625	/* YY_LOCATION_PRINT -- Print the location on the stream.
1626	This macro was not mandated originally: define only if we know
1627	we won't break user code: when these are the locations we know. */
1628
1629	#ifndef YY_LOCATION_PRINT
1630	# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1631
1632	/* Print *YYLOCP on YYO. Private, do not rely on its existence. */
1633
1634	__attribute__((__unused__))
1635	#if (defined __STDC__ || defined __C99__FUNC__ \
1636	|| defined __cplusplus || defined _MSC_VER)
1637	static unsigned
1638	yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp)
1639	#else
1640	static unsigned
1641	yy_location_print_ (yyo, yylocp)
1642	FILE *yyo;
1643	YYLTYPE const * const yylocp;
1644	#endif
1645	{
1646	unsigned res = 0;
1647	int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;
1648	if (0 <= yylocp->first_line)
1649	{
1650	res += fprintf (yyo, "%d", yylocp->first_line);
1651	if (0 <= yylocp->first_column)
1652	res += fprintf (yyo, ".%d", yylocp->first_column);
1653	}
1654	if (0 <= yylocp->last_line)
1655	{
1656	if (yylocp->first_line < yylocp->last_line)
1657	{
1658	res += fprintf (yyo, "-%d", yylocp->last_line);
1659	if (0 <= end_col)
1660	res += fprintf (yyo, ".%d", end_col);
1661	}
1662	else if (0 <= end_col && yylocp->first_column < end_col)
1663	res += fprintf (yyo, "-%d", end_col);
1664	}
1665	return res;
1666	}
1667
1668	# define YY_LOCATION_PRINT(File, Loc) \
1669	yy_location_print_ (File, &(Loc))
1670
1671	# else
1672	# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1673	# endif
1674	#endif
1675
1676
1677	/* YYLEX -- calling `yylex' with the right arguments. */
1678	#ifdef YYLEX_PARAM
1679	# define YYLEX yylex (YYLEX_PARAM)
1680	#else
1681	# define YYLEX yylex ()
1682	#endif
1683
1684	/* Enable debugging if requested. */
1685	#if YYDEBUG
1686
1687	# ifndef YYFPRINTF
1688	# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1689	# define YYFPRINTF fprintf
1690	# endif
1691
1692	# define YYDPRINTF(Args) \
1693	do { \
1694	if (yydebug) \
1695	YYFPRINTF Args; \
1696	} while (YYID (0))
1697
1698	# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1699	do { \
1700	if (yydebug) \
1701	{ \
1702	YYFPRINTF (stderr, "%s ", Title); \
1703	yy_symbol_print (stderr, \
1704	Type, Value, Location); \
1705	YYFPRINTF (stderr, "\n"); \
1706	} \
1707	} while (YYID (0))
1708
1709
1710	/*--------------------------------.
1711	| Print this symbol on YYOUTPUT. |
1712	`--------------------------------*/
1713
1714	/*ARGSUSED*/
1715	#if (defined __STDC__ || defined __C99__FUNC__ \
1716	|| defined __cplusplus || defined _MSC_VER)
1717	static void
1718	yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp)
1719	#else
1720	static void
1721	yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp)
1722	FILE *yyoutput;
1723	int yytype;
1724	YYSTYPE const * const yyvaluep;
1725	YYLTYPE const * const yylocationp;
1726	#endif
1727	{
1728	FILE *yyo = yyoutput;
1729	YYUSE (yyo);
1730	if (!yyvaluep)
1731	return;
1732	YYUSE (yylocationp);
1733	# ifdef YYPRINT
1734	if (yytype < YYNTOKENS)
1735	YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1736	# else
1737	YYUSE (yyoutput);
1738	# endif
1739	YYUSE (yytype);
1740	}
1741
1742
1743	/*--------------------------------.
1744	| Print this symbol on YYOUTPUT. |
1745	`--------------------------------*/
1746
1747	#if (defined __STDC__ || defined __C99__FUNC__ \
1748	|| defined __cplusplus || defined _MSC_VER)
1749	static void
1750	yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp)
1751	#else
1752	static void
1753	yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp)
1754	FILE *yyoutput;
1755	int yytype;
1756	YYSTYPE const * const yyvaluep;
1757	YYLTYPE const * const yylocationp;
1758	#endif
1759	{
1760	if (yytype < YYNTOKENS)
1761	YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1762	else
1763	YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1764
1765	YY_LOCATION_PRINT (yyoutput, *yylocationp);
1766	YYFPRINTF (yyoutput, ": ");
1767	yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp);
1768	YYFPRINTF (yyoutput, ")");
1769	}
1770
1771	/*------------------------------------------------------------------.
1772	| yy_stack_print -- Print the state stack from its BOTTOM up to its |
1773	| TOP (included). |
1774	`------------------------------------------------------------------*/
1775
1776	#if (defined __STDC__ || defined __C99__FUNC__ \
1777	|| defined __cplusplus || defined _MSC_VER)
1778	static void
1779	yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1780	#else
1781	static void
1782	yy_stack_print (yybottom, yytop)
1783	yytype_int16 *yybottom;
1784	yytype_int16 *yytop;
1785	#endif
1786	{
1787	YYFPRINTF (stderr, "Stack now");
1788	for (; yybottom <= yytop; yybottom++)
1789	{
1790	int yybot = *yybottom;
1791	YYFPRINTF (stderr, " %d", yybot);
1792	}
1793	YYFPRINTF (stderr, "\n");
1794	}
1795
1796	# define YY_STACK_PRINT(Bottom, Top) \
1797	do { \
1798	if (yydebug) \
1799	yy_stack_print ((Bottom), (Top)); \
1800	} while (YYID (0))
1801
1802
1803	/*------------------------------------------------.
1804	| Report that the YYRULE is going to be reduced. |
1805	`------------------------------------------------*/
1806
1807	#if (defined __STDC__ || defined __C99__FUNC__ \
1808	|| defined __cplusplus || defined _MSC_VER)
1809	static void
1810	yy_reduce_print (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule)
1811	#else
1812	static void
1813	yy_reduce_print (yyvsp, yylsp, yyrule)
1814	YYSTYPE *yyvsp;
1815	YYLTYPE *yylsp;
1816	int yyrule;
1817	#endif
1818	{
1819	int yynrhs = yyr2[yyrule];
1820	int yyi;
1821	unsigned long int yylno = yyrline[yyrule];
1822	YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1823	yyrule - 1, yylno);
1824	/* The symbols being reduced. */
1825	for (yyi = 0; yyi < yynrhs; yyi++)
1826	{
1827	YYFPRINTF (stderr, " $%d = ", yyi + 1);
1828	yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1829	&(yyvsp[(yyi + 1) - (yynrhs)])
1830	, &(yylsp[(yyi + 1) - (yynrhs)]) );
1831	YYFPRINTF (stderr, "\n");
1832	}
1833	}
1834
1835	# define YY_REDUCE_PRINT(Rule) \
1836	do { \
1837	if (yydebug) \
1838	yy_reduce_print (yyvsp, yylsp, Rule); \
1839	} while (YYID (0))
1840
1841	/* Nonzero means print parse trace. It is left uninitialized so that
1842	multiple parsers can coexist. */
1843	int yydebug;
1844	#else /* !YYDEBUG */
1845	# define YYDPRINTF(Args)
1846	# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1847	# define YY_STACK_PRINT(Bottom, Top)
1848	# define YY_REDUCE_PRINT(Rule)
1849	#endif /* !YYDEBUG */
1850
1851
1852	/* YYINITDEPTH -- initial size of the parser's stacks. */
1853	#ifndef YYINITDEPTH
1854	# define YYINITDEPTH 200
1855	#endif
1856
1857	/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1858	if the built-in stack extension method is used).
1859
1860	Do not make this value too large; the results are undefined if
1861	YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1862	evaluated with infinite-precision integer arithmetic. */
1863
1864	#ifndef YYMAXDEPTH
1865	# define YYMAXDEPTH 10000
1866	#endif
1867
1868
1869	#if YYERROR_VERBOSE
1870
1871	# ifndef yystrlen
1872	# if defined __GLIBC__ && defined _STRING_H
1873	# define yystrlen strlen
1874	# else
1875	/* Return the length of YYSTR. */
1876	#if (defined __STDC__ || defined __C99__FUNC__ \
1877	|| defined __cplusplus || defined _MSC_VER)
1878	static YYSIZE_T
1879	yystrlen (const char *yystr)
1880	#else
1881	static YYSIZE_T
1882	yystrlen (yystr)
1883	const char *yystr;
1884	#endif
1885	{
1886	YYSIZE_T yylen;
1887	for (yylen = 0; yystr[yylen]; yylen++)
1888	continue;
1889	return yylen;
1890	}
1891	# endif
1892	# endif
1893
1894	# ifndef yystpcpy
1895	# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1896	# define yystpcpy stpcpy
1897	# else
1898	/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1899	YYDEST. */
1900	#if (defined __STDC__ || defined __C99__FUNC__ \
1901	|| defined __cplusplus || defined _MSC_VER)
1902	static char *
1903	yystpcpy (char *yydest, const char *yysrc)
1904	#else
1905	static char *
1906	yystpcpy (yydest, yysrc)
1907	char *yydest;
1908	const char *yysrc;
1909	#endif
1910	{
1911	char *yyd = yydest;
1912	const char *yys = yysrc;
1913
1914	while ((*yyd++ = *yys++) != '\0')
1915	continue;
1916
1917	return yyd - 1;
1918	}
1919	# endif
1920	# endif
1921
1922	# ifndef yytnamerr
1923	/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1924	quotes and backslashes, so that it's suitable for yyerror. The
1925	heuristic is that double-quoting is unnecessary unless the string
1926	contains an apostrophe, a comma, or backslash (other than
1927	backslash-backslash). YYSTR is taken from yytname. If YYRES is
1928	null, do not copy; instead, return the length of what the result
1929	would have been. */
1930	static YYSIZE_T
1931	yytnamerr (char *yyres, const char *yystr)
1932	{
1933	if (*yystr == '"')
1934	{
1935	YYSIZE_T yyn = 0;
1936	char const *yyp = yystr;
1937
1938	for (;;)
1939	switch (*++yyp)
1940	{
1941	case '\'':
1942	case ',':
1943	goto do_not_strip_quotes;
1944
1945	case '\\':
1946	if (*++yyp != '\\')
1947	goto do_not_strip_quotes;
1948	/* Fall through. */
1949	default:
1950	if (yyres)
1951	yyres[yyn] = *yyp;
1952	yyn++;
1953	break;
1954
1955	case '"':
1956	if (yyres)
1957	yyres[yyn] = '\0';
1958	return yyn;
1959	}
1960	do_not_strip_quotes: ;
1961	}
1962
1963	if (! yyres)
1964	return yystrlen (yystr);
1965
1966	return yystpcpy (yyres, yystr) - yyres;
1967	}
1968	# endif
1969
1970	/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1971	about the unexpected token YYTOKEN for the state stack whose top is
1972	YYSSP.
1973
1974	Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
1975	not large enough to hold the message. In that case, also set
1976	*YYMSG_ALLOC to the required number of bytes. Return 2 if the
1977	required number of bytes is too large to store. */
1978	static int
1979	yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1980	yytype_int16 *yyssp, int yytoken)
1981	{
1982	YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]);
1983	YYSIZE_T yysize = yysize0;
1984	enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1985	/* Internationalized format string. */
1986	const char *yyformat = YY_NULL;
1987	/* Arguments of yyformat. */
1988	char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1989	/* Number of reported tokens (one for the "unexpected", one per
1990	"expected"). */
1991	int yycount = 0;
1992
1993	/* There are many possibilities here to consider:
1994	- Assume YYFAIL is not used. It's too flawed to consider. See
1995	<http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
1996	for details. YYERROR is fine as it does not invoke this
1997	function.
1998	- If this state is a consistent state with a default action, then
1999	the only way this function was invoked is if the default action
2000	is an error action. In that case, don't check for expected
2001	tokens because there are none.
2002	- The only way there can be no lookahead present (in yychar) is if
2003	this state is a consistent state with a default action. Thus,
2004	detecting the absence of a lookahead is sufficient to determine
2005	that there is no unexpected or expected token to report. In that
2006	case, just report a simple "syntax error".
2007	- Don't assume there isn't a lookahead just because this state is a
2008	consistent state with a default action. There might have been a
2009	previous inconsistent state, consistent state with a non-default
2010	action, or user semantic action that manipulated yychar.
2011	- Of course, the expected token list depends on states to have
2012	correct lookahead information, and it depends on the parser not
2013	to perform extra reductions after fetching a lookahead from the
2014	scanner and before detecting a syntax error. Thus, state merging
2015	(from LALR or IELR) and default reductions corrupt the expected
2016	token list. However, the list is correct for canonical LR with
2017	one exception: it will still contain any token that will not be
2018	accepted due to an error action in a later state.
2019	*/
2020	if (yytoken != YYEMPTY)
2021	{
2022	int yyn = yypact[*yyssp];
2023	yyarg[yycount++] = yytname[yytoken];
2024	if (!yypact_value_is_default (yyn))
2025	{
2026	/* Start YYX at -YYN if negative to avoid negative indexes in
2027	YYCHECK. In other words, skip the first -YYN actions for
2028	this state because they are default actions. */
2029	int yyxbegin = yyn < 0 ? -yyn : 0;
2030	/* Stay within bounds of both yycheck and yytname. */
2031	int yychecklim = YYLAST - yyn + 1;
2032	int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
2033	int yyx;
2034
2035	for (yyx = yyxbegin; yyx < yyxend; ++yyx)
2036	if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
2037	&& !yytable_value_is_error (yytable[yyx + yyn]))
2038	{
2039	if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
2040	{
2041	yycount = 1;
2042	yysize = yysize0;
2043	break;
2044	}
2045	yyarg[yycount++] = yytname[yyx];
2046	{
2047	YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]);
2048	if (! (yysize <= yysize1
2049	&& yysize1 <= YYSTACK_ALLOC_MAXIMUM))
2050	return 2;
2051	yysize = yysize1;
2052	}
2053	}
2054	}
2055	}
2056
2057	switch (yycount)
2058	{
2059	# define YYCASE_(N, S) \
2060	case N: \
2061	yyformat = S; \
2062	break
2063	YYCASE_(0, YY_("syntax error"));
2064	YYCASE_(1, YY_("syntax error, unexpected %s"));
2065	YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
2066	YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
2067	YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
2068	YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
2069	# undef YYCASE_
2070	}
2071
2072	{
2073	YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
2074	if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
2075	return 2;
2076	yysize = yysize1;
2077	}
2078
2079	if (*yymsg_alloc < yysize)
2080	{
2081	*yymsg_alloc = 2 * yysize;
2082	if (! (yysize <= *yymsg_alloc
2083	&& *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
2084	*yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
2085	return 1;
2086	}
2087
2088	/* Avoid sprintf, as that infringes on the user's name space.
2089	Don't have undefined behavior even if the translation
2090	produced a string with the wrong number of "%s"s. */
2091	{
2092	char *yyp = *yymsg;
2093	int yyi = 0;
2094	while ((*yyp = *yyformat) != '\0')
2095	if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
2096	{
2097	yyp += yytnamerr (yyp, yyarg[yyi++]);
2098	yyformat += 2;
2099	}
2100	else
2101	{
2102	yyp++;
2103	yyformat++;
2104	}
2105	}
2106	return 0;
2107	}
2108	#endif /* YYERROR_VERBOSE */
2109
2110	/*-----------------------------------------------.
2111	| Release the memory associated to this symbol. |
2112	`-----------------------------------------------*/
2113
2114	/*ARGSUSED*/
2115	#if (defined __STDC__ || defined __C99__FUNC__ \
2116	|| defined __cplusplus || defined _MSC_VER)
2117	static void
2118	yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp)
2119	#else
2120	static void
2121	yydestruct (yymsg, yytype, yyvaluep, yylocationp)
2122	const char *yymsg;
2123	int yytype;
2124	YYSTYPE *yyvaluep;
2125	YYLTYPE *yylocationp;
2126	#endif
2127	{
2128	YYUSE (yyvaluep);
2129	YYUSE (yylocationp);
2130
2131	if (!yymsg)
2132	yymsg = "Deleting";
2133	YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
2134
2135	YYUSE (yytype);
2136	}
2137
2138
2139
2140
2141	/* The lookahead symbol. */
2142	int yychar;
2143
2144
2145	#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2146	# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2147	# define YY_IGNORE_MAYBE_UNINITIALIZED_END
2148	#endif
2149	#ifndef YY_INITIAL_VALUE
2150	# define YY_INITIAL_VALUE(Value) /* Nothing. */
2151	#endif
2152
2153	/* The semantic value of the lookahead symbol. */
2154	YYSTYPE yylval YY_INITIAL_VALUE(yyval_default);
2155
2156	/* Location data for the lookahead symbol. */
2157	YYLTYPE yylloc
2158	# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
2159	= { 1, 1, 1, 1 }
2160	# endif
2161	;
2162
2163
2164	/* Number of syntax errors so far. */
2165	int yynerrs;
2166
2167
2168	/*----------.
2169	| yyparse. |
2170	`----------*/
2171
2172	#ifdef YYPARSE_PARAM
2173	#if (defined __STDC__ || defined __C99__FUNC__ \
2174	|| defined __cplusplus || defined _MSC_VER)
2175	int
2176	yyparse (void *YYPARSE_PARAM)
2177	#else
2178	int
2179	yyparse (YYPARSE_PARAM)
2180	void *YYPARSE_PARAM;
2181	#endif
2182	#else /* ! YYPARSE_PARAM */
2183	#if (defined __STDC__ || defined __C99__FUNC__ \
2184	|| defined __cplusplus || defined _MSC_VER)
2185	int
2186	yyparse (void)
2187	#else
2188	int
2189	yyparse ()
2190
2191	#endif
2192	#endif
2193	{
2194	int yystate;
2195	/* Number of tokens to shift before error messages enabled. */
2196	int yyerrstatus;
2197
2198	/* The stacks and their tools:
2199	`yyss': related to states.
2200	`yyvs': related to semantic values.
2201	`yyls': related to locations.
2202
2203	Refer to the stacks through separate pointers, to allow yyoverflow
2204	to reallocate them elsewhere. */
2205
2206	/* The state stack. */
2207	yytype_int16 yyssa[YYINITDEPTH];
2208	yytype_int16 *yyss;
2209	yytype_int16 *yyssp;
2210
2211	/* The semantic value stack. */
2212	YYSTYPE yyvsa[YYINITDEPTH];
2213	YYSTYPE *yyvs;
2214	YYSTYPE *yyvsp;
2215
2216	/* The location stack. */
2217	YYLTYPE yylsa[YYINITDEPTH];
2218	YYLTYPE *yyls;
2219	YYLTYPE *yylsp;
2220
2221	/* The locations where the error started and ended. */
2222	YYLTYPE yyerror_range[3];
2223
2224	YYSIZE_T yystacksize;
2225
2226	int yyn;
2227	int yyresult;
2228	/* Lookahead token as an internal (translated) token number. */
2229	int yytoken = 0;
2230	/* The variables used to return semantic value and location from the
2231	action routines. */
2232	YYSTYPE yyval;
2233	YYLTYPE yyloc;
2234
2235	#if YYERROR_VERBOSE
2236	/* Buffer for error messages, and its allocated size. */
2237	char yymsgbuf[128];
2238	char *yymsg = yymsgbuf;
2239	YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
2240	#endif
2241
2242	#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
2243
2244	/* The number of symbols on the RHS of the reduced rule.
2245	Keep to zero when no symbol should be popped. */
2246	int yylen = 0;
2247
2248	yyssp = yyss = yyssa;
2249	yyvsp = yyvs = yyvsa;
2250	yylsp = yyls = yylsa;
2251	yystacksize = YYINITDEPTH;
2252
2253	YYDPRINTF ((stderr, "Starting parse\n"));
2254
2255	yystate = 0;
2256	yyerrstatus = 0;
2257	yynerrs = 0;
2258	yychar = YYEMPTY; /* Cause a token to be read. */
2259	yylsp[0] = yylloc;
2260	goto yysetstate;
2261
2262	/*------------------------------------------------------------.
2263	| yynewstate -- Push a new state, which is found in yystate. |
2264	`------------------------------------------------------------*/
2265	yynewstate:
2266	/* In all cases, when you get here, the value and location stacks
2267	have just been pushed. So pushing a state here evens the stacks. */
2268	yyssp++;
2269
2270	yysetstate:
2271	*yyssp = yystate;
2272
2273	if (yyss + yystacksize - 1 <= yyssp)
2274	{
2275	/* Get the current used size of the three stacks, in elements. */
2276	YYSIZE_T yysize = yyssp - yyss + 1;
2277
2278	#ifdef yyoverflow
2279	{
2280	/* Give user a chance to reallocate the stack. Use copies of
2281	these so that the &'s don't force the real ones into
2282	memory. */
2283	YYSTYPE *yyvs1 = yyvs;
2284	yytype_int16 *yyss1 = yyss;
2285	YYLTYPE *yyls1 = yyls;
2286
2287	/* Each stack pointer address is followed by the size of the
2288	data in use in that stack, in bytes. This used to be a
2289	conditional around just the two extra args, but that might
2290	be undefined if yyoverflow is a macro. */
2291	yyoverflow (YY_("memory exhausted"),
2292	&yyss1, yysize * sizeof (*yyssp),
2293	&yyvs1, yysize * sizeof (*yyvsp),
2294	&yyls1, yysize * sizeof (*yylsp),
2295	&yystacksize);
2296
2297	yyls = yyls1;
2298	yyss = yyss1;
2299	yyvs = yyvs1;
2300	}
2301	#else /* no yyoverflow */
2302	# ifndef YYSTACK_RELOCATE
2303	goto yyexhaustedlab;
2304	# else
2305	/* Extend the stack our own way. */
2306	if (YYMAXDEPTH <= yystacksize)
2307	goto yyexhaustedlab;
2308	yystacksize *= 2;
2309	if (YYMAXDEPTH < yystacksize)
2310	yystacksize = YYMAXDEPTH;
2311
2312	{
2313	yytype_int16 *yyss1 = yyss;
2314	union yyalloc *yyptr =
2315	(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
2316	if (! yyptr)
2317	goto yyexhaustedlab;
2318	YYSTACK_RELOCATE (yyss_alloc, yyss);
2319	YYSTACK_RELOCATE (yyvs_alloc, yyvs);
2320	YYSTACK_RELOCATE (yyls_alloc, yyls);
2321	# undef YYSTACK_RELOCATE
2322	if (yyss1 != yyssa)
2323	YYSTACK_FREE (yyss1);
2324	}
2325	# endif
2326	#endif /* no yyoverflow */
2327
2328	yyssp = yyss + yysize - 1;
2329	yyvsp = yyvs + yysize - 1;
2330	yylsp = yyls + yysize - 1;
2331
2332	YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2333	(unsigned long int) yystacksize));
2334
2335	if (yyss + yystacksize - 1 <= yyssp)
2336	YYABORT;
2337	}
2338
2339	YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2340
2341	if (yystate == YYFINAL)
2342	YYACCEPT;
2343
2344	goto yybackup;
2345
2346	/*-----------.
2347	| yybackup. |
2348	`-----------*/
2349	yybackup:
2350
2351	/* Do appropriate processing given the current state. Read a
2352	lookahead token if we need one and don't already have one. */
2353
2354	/* First try to decide what to do without reference to lookahead token. */
2355	yyn = yypact[yystate];
2356	if (yypact_value_is_default (yyn))
2357	goto yydefault;
2358
2359	/* Not known => get a lookahead token if don't already have one. */
2360
2361	/* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
2362	if (yychar == YYEMPTY)
2363	{
2364	YYDPRINTF ((stderr, "Reading a token: "));
2365	yychar = YYLEX;
2366	}
2367
2368	if (yychar <= YYEOF)
2369	{
2370	yychar = yytoken = YYEOF;
2371	YYDPRINTF ((stderr, "Now at end of input.\n"));
2372	}
2373	else
2374	{
2375	yytoken = YYTRANSLATE (yychar);
2376	YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2377	}
2378
2379	/* If the proper action on seeing token YYTOKEN is to reduce or to
2380	detect an error, take that action. */
2381	yyn += yytoken;
2382	if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2383	goto yydefault;
2384	yyn = yytable[yyn];
2385	if (yyn <= 0)
2386	{
2387	if (yytable_value_is_error (yyn))
2388	goto yyerrlab;
2389	yyn = -yyn;
2390	goto yyreduce;
2391	}
2392
2393	/* Count tokens shifted since error; after three, turn off error
2394	status. */
2395	if (yyerrstatus)
2396	yyerrstatus--;
2397
2398	/* Shift the lookahead token. */
2399	YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2400
2401	/* Discard the shifted token. */
2402	yychar = YYEMPTY;
2403
2404	yystate = yyn;
2405	YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2406	*++yyvsp = yylval;
2407	YY_IGNORE_MAYBE_UNINITIALIZED_END
2408	*++yylsp = yylloc;
2409	goto yynewstate;
2410
2411
2412	/*-----------------------------------------------------------.
2413	| yydefault -- do the default action for the current state. |
2414	`-----------------------------------------------------------*/
2415	yydefault:
2416	yyn = yydefact[yystate];
2417	if (yyn == 0)
2418	goto yyerrlab;
2419	goto yyreduce;
2420
2421
2422	/*-----------------------------.
2423	| yyreduce -- Do a reduction. |
2424	`-----------------------------*/
2425	yyreduce:
2426	/* yyn is the number of a rule to reduce with. */
2427	yylen = yyr2[yyn];
2428
2429	/* If YYLEN is nonzero, implement the default value of the action:
2430	`$$ = $1'.
2431
2432	Otherwise, the following line sets YYVAL to garbage.
2433	This behavior is undocumented and Bison
2434	users should not rely upon it. Assigning to YYVAL
2435	unconditionally makes the parser a bit smaller, and it avoids a
2436	GCC warning that YYVAL may be used uninitialized. */
2437	yyval = yyvsp[1-yylen];
2438
2439	/* Default location. */
2440	YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
2441	YY_REDUCE_PRINT (yyn);
2442	switch (yyn)
2443	{
2444	case 2:
2445	/* Line 1787 of yacc.c */
2446	#line 192 "grammar.y"
2447	{ (yyval.ident) = new Identifier("break"); }
2448	break;
2449
2450	case 3:
2451	/* Line 1787 of yacc.c */
2452	#line 193 "grammar.y"
2453	{ (yyval.ident) = new Identifier("case"); }
2454	break;
2455
2456	case 4:
2457	/* Line 1787 of yacc.c */
2458	#line 194 "grammar.y"
2459	{ (yyval.ident) = new Identifier("default"); }
2460	break;
2461
2462	case 5:
2463	/* Line 1787 of yacc.c */
2464	#line 195 "grammar.y"
2465	{ (yyval.ident) = new Identifier("for"); }
2466	break;
2467
2468	case 6:
2469	/* Line 1787 of yacc.c */
2470	#line 196 "grammar.y"
2471	{ (yyval.ident) = new Identifier("new"); }
2472	break;
2473
2474	case 7:
2475	/* Line 1787 of yacc.c */
2476	#line 197 "grammar.y"
2477	{ (yyval.ident) = new Identifier("var"); }
2478	break;
2479
2480	case 8:
2481	/* Line 1787 of yacc.c */
2482	#line 198 "grammar.y"
2483	{ (yyval.ident) = new Identifier("const"); }
2484	break;
2485
2486	case 9:
2487	/* Line 1787 of yacc.c */
2488	#line 199 "grammar.y"
2489	{ (yyval.ident) = new Identifier("continue"); }
2490	break;
2491
2492	case 10:
2493	/* Line 1787 of yacc.c */
2494	#line 200 "grammar.y"
2495	{ (yyval.ident) = new Identifier("function"); }
2496	break;
2497
2498	case 11:
2499	/* Line 1787 of yacc.c */
2500	#line 201 "grammar.y"
2501	{ (yyval.ident) = new Identifier("return"); }
2502	break;
2503
2504	case 12:
2505	/* Line 1787 of yacc.c */
2506	#line 202 "grammar.y"
2507	{ (yyval.ident) = new Identifier("void"); }
2508	break;
2509
2510	case 13:
2511	/* Line 1787 of yacc.c */
2512	#line 203 "grammar.y"
2513	{ (yyval.ident) = new Identifier("delete"); }
2514	break;
2515
2516	case 14:
2517	/* Line 1787 of yacc.c */
2518	#line 204 "grammar.y"
2519	{ (yyval.ident) = new Identifier("if"); }
2520	break;
2521
2522	case 15:
2523	/* Line 1787 of yacc.c */
2524	#line 205 "grammar.y"
2525	{ (yyval.ident) = new Identifier("this"); }
2526	break;
2527
2528	case 16:
2529	/* Line 1787 of yacc.c */
2530	#line 206 "grammar.y"
2531	{ (yyval.ident) = new Identifier("do"); }
2532	break;
2533
2534	case 17:
2535	/* Line 1787 of yacc.c */
2536	#line 207 "grammar.y"
2537	{ (yyval.ident) = new Identifier("while"); }
2538	break;
2539
2540	case 18:
2541	/* Line 1787 of yacc.c */
2542	#line 208 "grammar.y"
2543	{ (yyval.ident) = new Identifier("in"); }
2544	break;
2545
2546	case 19:
2547	/* Line 1787 of yacc.c */
2548	#line 209 "grammar.y"
2549	{ (yyval.ident) = new Identifier("instanceof"); }
2550	break;
2551
2552	case 20:
2553	/* Line 1787 of yacc.c */
2554	#line 210 "grammar.y"
2555	{ (yyval.ident) = new Identifier("typeof"); }
2556	break;
2557
2558	case 21:
2559	/* Line 1787 of yacc.c */
2560	#line 211 "grammar.y"
2561	{ (yyval.ident) = new Identifier("switch"); }
2562	break;
2563
2564	case 22:
2565	/* Line 1787 of yacc.c */
2566	#line 212 "grammar.y"
2567	{ (yyval.ident) = new Identifier("with"); }
2568	break;
2569
2570	case 23:
2571	/* Line 1787 of yacc.c */
2572	#line 213 "grammar.y"
2573	{ (yyval.ident) = new Identifier("throw"); }
2574	break;
2575
2576	case 24:
2577	/* Line 1787 of yacc.c */
2578	#line 214 "grammar.y"
2579	{ (yyval.ident) = new Identifier("try"); }
2580	break;
2581
2582	case 25:
2583	/* Line 1787 of yacc.c */
2584	#line 215 "grammar.y"
2585	{ (yyval.ident) = new Identifier("catch"); }
2586	break;
2587
2588	case 26:
2589	/* Line 1787 of yacc.c */
2590	#line 216 "grammar.y"
2591	{ (yyval.ident) = new Identifier("finally"); }
2592	break;
2593
2594	case 27:
2595	/* Line 1787 of yacc.c */
2596	#line 217 "grammar.y"
2597	{ (yyval.ident) = new Identifier("debugger"); }
2598	break;
2599
2600	case 28:
2601	/* Line 1787 of yacc.c */
2602	#line 218 "grammar.y"
2603	{ (yyval.ident) = new Identifier("import"); }
2604	break;
2605
2606	case 29:
2607	/* Line 1787 of yacc.c */
2608	#line 219 "grammar.y"
2609	{ (yyval.ident) = new Identifier("null"); }
2610	break;
2611
2612	case 30:
2613	/* Line 1787 of yacc.c */
2614	#line 220 "grammar.y"
2615	{ (yyval.ident) = new Identifier("true"); }
2616	break;
2617
2618	case 31:
2619	/* Line 1787 of yacc.c */
2620	#line 221 "grammar.y"
2621	{ (yyval.ident) = new Identifier("false"); }
2622	break;
2623
2624	case 32:
2625	/* Line 1787 of yacc.c */
2626	#line 222 "grammar.y"
2627	{ (yyval.ident) = new Identifier("else"); }
2628	break;
2629
2630	case 33:
2631	/* Line 1787 of yacc.c */
2632	#line 226 "grammar.y"
2633	{ (yyval.ident) = (yyvsp[(1) - (1)].ident); }
2634	break;
2635
2636	case 34:
2637	/* Line 1787 of yacc.c */
2638	#line 227 "grammar.y"
2639	{ (yyval.ident) = (yyvsp[(1) - (1)].ident); }
2640	break;
2641
2642	case 35:
2643	/* Line 1787 of yacc.c */
2644	#line 231 "grammar.y"
2645	{ (yyval.node) = new NullNode(); }
2646	break;
2647
2648	case 36:
2649	/* Line 1787 of yacc.c */
2650	#line 232 "grammar.y"
2651	{ (yyval.node) = new BooleanNode(true); }
2652	break;
2653
2654	case 37:
2655	/* Line 1787 of yacc.c */
2656	#line 233 "grammar.y"
2657	{ (yyval.node) = new BooleanNode(false); }
2658	break;
2659
2660	case 38:
2661	/* Line 1787 of yacc.c */
2662	#line 234 "grammar.y"
2663	{ (yyval.node) = new NumberNode((yyvsp[(1) - (1)].dval)); }
2664	break;
2665
2666	case 39:
2667	/* Line 1787 of yacc.c */
2668	#line 235 "grammar.y"
2669	{ (yyval.node) = new StringNode((yyvsp[(1) - (1)].ustr)); }
2670	break;
2671
2672	case 40:
2673	/* Line 1787 of yacc.c */
2674	#line 236 "grammar.y"
2675	{
2676	Lexer& l = lexer();
2677	if (!l.scanRegExp())
2678	YYABORT;
2679	(yyval.node) = new RegExpNode(l.pattern(), l.flags());
2680	}
2681	break;
2682
2683	case 41:
2684	/* Line 1787 of yacc.c */
2685	#line 242 "grammar.y"
2686	{
2687	Lexer& l = lexer();
2688	if (!l.scanRegExp())
2689	YYABORT;
2690	(yyval.node) = new RegExpNode("=" + l.pattern(), l.flags());
2691	}
2692	break;
2693
2694	case 42:
2695	/* Line 1787 of yacc.c */
2696	#line 251 "grammar.y"
2697	{ (yyval.pname) = new PropertyNameNode(*(yyvsp[(1) - (1)].ident)); }
2698	break;
2699
2700	case 43:
2701	/* Line 1787 of yacc.c */
2702	#line 252 "grammar.y"
2703	{ (yyval.pname) = new PropertyNameNode(Identifier(*(yyvsp[(1) - (1)].ustr))); }
2704	break;
2705
2706	case 44:
2707	/* Line 1787 of yacc.c */
2708	#line 253 "grammar.y"
2709	{ (yyval.pname) = new PropertyNameNode(Identifier(UString::from((yyvsp[(1) - (1)].dval)))); }
2710	break;
2711
2712	case 45:
2713	/* Line 1787 of yacc.c */
2714	#line 257 "grammar.y"
2715	{ (yyval.pnode) = new PropertyNode((yyvsp[(1) - (3)].pname), (yyvsp[(3) - (3)].node), PropertyNode::Constant); }
2716	break;
2717
2718	case 46:
2719	/* Line 1787 of yacc.c */
2720	#line 258 "grammar.y"
2721	{inFuncExpr();}
2722	break;
2723
2724	case 47:
2725	/* Line 1787 of yacc.c */
2726	#line 258 "grammar.y"
2727	{
2728	if (!makeGetterOrSetterPropertyNode((yyval.pnode), *(yyvsp[(1) - (6)].ident), *(yyvsp[(2) - (6)].ident), 0, (yyvsp[(6) - (6)].body)))
2729	YYABORT;
2730	}
2731	break;
2732
2733	case 48:
2734	/* Line 1787 of yacc.c */
2735	#line 262 "grammar.y"
2736	{inFuncExpr();}
2737	break;
2738
2739	case 49:
2740	/* Line 1787 of yacc.c */
2741	#line 262 "grammar.y"
2742	{
2743	if (!makeGetterOrSetterPropertyNode((yyval.pnode), *(yyvsp[(1) - (7)].ident), *(yyvsp[(2) - (7)].ident), (yyvsp[(4) - (7)].param), (yyvsp[(7) - (7)].body)))
2744	YYABORT;
2745	}
2746	break;
2747
2748	case 50:
2749	/* Line 1787 of yacc.c */
2750	#line 269 "grammar.y"
2751	{ (yyval.plist) = new PropertyListNode((yyvsp[(1) - (1)].pnode)); }
2752	break;
2753
2754	case 51:
2755	/* Line 1787 of yacc.c */
2756	#line 270 "grammar.y"
2757	{ (yyval.plist) = new PropertyListNode((yyvsp[(3) - (3)].pnode), (yyvsp[(1) - (3)].plist)); }
2758	break;
2759
2760	case 53:
2761	/* Line 1787 of yacc.c */
2762	#line 275 "grammar.y"
2763	{ (yyval.node) = new ObjectLiteralNode(); }
2764	break;
2765
2766	case 54:
2767	/* Line 1787 of yacc.c */
2768	#line 276 "grammar.y"
2769	{ (yyval.node) = new ObjectLiteralNode((yyvsp[(2) - (3)].plist)); }
2770	break;
2771
2772	case 55:
2773	/* Line 1787 of yacc.c */
2774	#line 278 "grammar.y"
2775	{ (yyval.node) = new ObjectLiteralNode((yyvsp[(2) - (4)].plist)); }
2776	break;
2777
2778	case 56:
2779	/* Line 1787 of yacc.c */
2780	#line 282 "grammar.y"
2781	{ (yyval.node) = new ThisNode(); }
2782	break;
2783
2784	case 59:
2785	/* Line 1787 of yacc.c */
2786	#line 285 "grammar.y"
2787	{ (yyval.node) = new VarAccessNode(*(yyvsp[(1) - (1)].ident)); }
2788	break;
2789
2790	case 60:
2791	/* Line 1787 of yacc.c */
2792	#line 286 "grammar.y"
2793	{ (yyval.node) = makeGroupNode((yyvsp[(2) - (3)].node)); }
2794	break;
2795
2796	case 61:
2797	/* Line 1787 of yacc.c */
2798	#line 291 "grammar.y"
2799	{ (yyval.node) = new ArrayNode((yyvsp[(2) - (3)].ival)); }
2800	break;
2801
2802	case 62:
2803	/* Line 1787 of yacc.c */
2804	#line 292 "grammar.y"
2805	{ (yyval.node) = new ArrayNode((yyvsp[(2) - (3)].elm)); }
2806	break;
2807
2808	case 63:
2809	/* Line 1787 of yacc.c */
2810	#line 293 "grammar.y"
2811	{ (yyval.node) = new ArrayNode((yyvsp[(4) - (5)].ival), (yyvsp[(2) - (5)].elm)); }
2812	break;
2813
2814	case 64:
2815	/* Line 1787 of yacc.c */
2816	#line 297 "grammar.y"
2817	{ (yyval.elm) = new ElementNode((yyvsp[(1) - (2)].ival), (yyvsp[(2) - (2)].node)); }
2818	break;
2819
2820	case 65:
2821	/* Line 1787 of yacc.c */
2822	#line 299 "grammar.y"
2823	{ (yyval.elm) = new ElementNode((yyvsp[(1) - (4)].elm), (yyvsp[(3) - (4)].ival), (yyvsp[(4) - (4)].node)); }
2824	break;
2825
2826	case 66:
2827	/* Line 1787 of yacc.c */
2828	#line 303 "grammar.y"
2829	{ (yyval.ival) = 0; }
2830	break;
2831
2832	case 68:
2833	/* Line 1787 of yacc.c */
2834	#line 308 "grammar.y"
2835	{ (yyval.ival) = 1; }
2836	break;
2837
2838	case 69:
2839	/* Line 1787 of yacc.c */
2840	#line 309 "grammar.y"
2841	{ (yyval.ival) = (yyvsp[(1) - (2)].ival) + 1; }
2842	break;
2843
2844	case 71:
2845	/* Line 1787 of yacc.c */
2846	#line 314 "grammar.y"
2847	{ (yyval.node) = (yyvsp[(1) - (1)].funcExpr); }
2848	break;
2849
2850	case 72:
2851	/* Line 1787 of yacc.c */
2852	#line 315 "grammar.y"
2853	{ (yyval.node) = new BracketAccessorNode((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node)); }
2854	break;
2855
2856	case 73:
2857	/* Line 1787 of yacc.c */
2858	#line 316 "grammar.y"
2859	{ (yyval.node) = new DotAccessorNode((yyvsp[(1) - (3)].node), *(yyvsp[(3) - (3)].ident)); }
2860	break;
2861
2862	case 74:
2863	/* Line 1787 of yacc.c */
2864	#line 317 "grammar.y"
2865	{ (yyval.node) = new NewExprNode((yyvsp[(2) - (3)].node), (yyvsp[(3) - (3)].args)); }
2866	break;
2867
2868	case 76:
2869	/* Line 1787 of yacc.c */
2870	#line 322 "grammar.y"
2871	{ (yyval.node) = new BracketAccessorNode((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node)); }
2872	break;
2873
2874	case 77:
2875	/* Line 1787 of yacc.c */
2876	#line 323 "grammar.y"
2877	{ (yyval.node) = new DotAccessorNode((yyvsp[(1) - (3)].node), *(yyvsp[(3) - (3)].ident)); }
2878	break;
2879
2880	case 78:
2881	/* Line 1787 of yacc.c */
2882	#line 324 "grammar.y"
2883	{ (yyval.node) = new NewExprNode((yyvsp[(2) - (3)].node), (yyvsp[(3) - (3)].args)); }
2884	break;
2885
2886	case 80:
2887	/* Line 1787 of yacc.c */
2888	#line 329 "grammar.y"
2889	{ (yyval.node) = new NewExprNode((yyvsp[(2) - (2)].node)); }
2890	break;
2891
2892	case 82:
2893	/* Line 1787 of yacc.c */
2894	#line 334 "grammar.y"
2895	{ (yyval.node) = new NewExprNode((yyvsp[(2) - (2)].node)); }
2896	break;
2897
2898	case 83:
2899	/* Line 1787 of yacc.c */
2900	#line 338 "grammar.y"
2901	{ (yyval.node) = makeFunctionCallNode((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].args)); }
2902	break;
2903
2904	case 84:
2905	/* Line 1787 of yacc.c */
2906	#line 339 "grammar.y"
2907	{ (yyval.node) = makeFunctionCallNode((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].args)); }
2908	break;
2909
2910	case 85:
2911	/* Line 1787 of yacc.c */
2912	#line 340 "grammar.y"
2913	{ (yyval.node) = new BracketAccessorNode((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node)); }
2914	break;
2915
2916	case 86:
2917	/* Line 1787 of yacc.c */
2918	#line 341 "grammar.y"
2919	{ (yyval.node) = new DotAccessorNode((yyvsp[(1) - (3)].node), *(yyvsp[(3) - (3)].ident)); }
2920	break;
2921
2922	case 87:
2923	/* Line 1787 of yacc.c */
2924	#line 345 "grammar.y"
2925	{ (yyval.node) = makeFunctionCallNode((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].args)); }
2926	break;
2927
2928	case 88:
2929	/* Line 1787 of yacc.c */
2930	#line 346 "grammar.y"
2931	{ (yyval.node) = makeFunctionCallNode((yyvsp[(1) - (2)].node), (yyvsp[(2) - (2)].args)); }
2932	break;
2933
2934	case 89:
2935	/* Line 1787 of yacc.c */
2936	#line 347 "grammar.y"
2937	{ (yyval.node) = new BracketAccessorNode((yyvsp[(1) - (4)].node), (yyvsp[(3) - (4)].node)); }
2938	break;
2939
2940	case 90:
2941	/* Line 1787 of yacc.c */
2942	#line 348 "grammar.y"
2943	{ (yyval.node) = new DotAccessorNode((yyvsp[(1) - (3)].node), *(yyvsp[(3) - (3)].ident)); }
2944	break;
2945
2946	case 91:
2947	/* Line 1787 of yacc.c */
2948	#line 352 "grammar.y"
2949	{ (yyval.args) = new ArgumentsNode(); }
2950	break;
2951
2952	case 92:
2953	/* Line 1787 of yacc.c */
2954	#line 353 "grammar.y"
2955	{ (yyval.args) = new ArgumentsNode((yyvsp[(2) - (3)].alist)); }
2956	break;
2957
2958	case 93:
2959	/* Line 1787 of yacc.c */
2960	#line 357 "grammar.y"
2961	{ (yyval.alist) = new ArgumentListNode((yyvsp[(1) - (1)].node)); }
2962	break;
2963
2964	case 94:
2965	/* Line 1787 of yacc.c */
2966	#line 358 "grammar.y"
2967	{ (yyval.alist) = new ArgumentListNode((yyvsp[(1) - (3)].alist), (yyvsp[(3) - (3)].node)); }
2968	break;
2969
2970	case 100:
2971	/* Line 1787 of yacc.c */
2972	#line 373 "grammar.y"
2973	{ (yyval.node) = makePostfixNode((yyvsp[(1) - (2)].node), OpPlusPlus); }
2974	break;
2975
2976	case 101:
2977	/* Line 1787 of yacc.c */
2978	#line 374 "grammar.y"
2979	{ (yyval.node) = makePostfixNode((yyvsp[(1) - (2)].node), OpMinusMinus); }
2980	break;
2981
2982	case 103:
2983	/* Line 1787 of yacc.c */
2984	#line 379 "grammar.y"
2985	{ (yyval.node) = makePostfixNode((yyvsp[(1) - (2)].node), OpPlusPlus); }
2986	break;
2987
2988	case 104:
2989	/* Line 1787 of yacc.c */
2990	#line 380 "grammar.y"
2991	{ (yyval.node) = makePostfixNode((yyvsp[(1) - (2)].node), OpMinusMinus); }
2992	break;
2993
2994	case 105:
2995	/* Line 1787 of yacc.c */
2996	#line 384 "grammar.y"
2997	{ (yyval.node) = makeDeleteNode((yyvsp[(2) - (2)].node)); }
2998	break;
2999
3000	case 106:
3001	/* Line 1787 of yacc.c */
3002	#line 385 "grammar.y"
3003	{ (yyval.node) = new VoidNode((yyvsp[(2) - (2)].node)); }
3004	break;
3005
3006	case 107:
3007	/* Line 1787 of yacc.c */
3008	#line 386 "grammar.y"
3009	{ (yyval.node) = makeTypeOfNode((yyvsp[(2) - (2)].node)); }
3010	break;
3011
3012	case 108:
3013	/* Line 1787 of yacc.c */
3014	#line 387 "grammar.y"
3015	{ (yyval.node) = makePrefixNode((yyvsp[(2) - (2)].node), OpPlusPlus); }
3016	break;
3017
3018	case 109:
3019	/* Line 1787 of yacc.c */
3020	#line 388 "grammar.y"
3021	{ (yyval.node) = makePrefixNode((yyvsp[(2) - (2)].node), OpPlusPlus); }
3022	break;
3023
3024	case 110:
3025	/* Line 1787 of yacc.c */
3026	#line 389 "grammar.y"
3027	{ (yyval.node) = makePrefixNode((yyvsp[(2) - (2)].node), OpMinusMinus); }
3028	break;
3029
3030	case 111:
3031	/* Line 1787 of yacc.c */
3032	#line 390 "grammar.y"
3033	{ (yyval.node) = makePrefixNode((yyvsp[(2) - (2)].node), OpMinusMinus); }
3034	break;
3035
3036	case 112:
3037	/* Line 1787 of yacc.c */
3038	#line 391 "grammar.y"
3039	{ (yyval.node) = makeUnaryPlusNode((yyvsp[(2) - (2)].node)); }
3040	break;
3041
3042	case 113:
3043	/* Line 1787 of yacc.c */
3044	#line 392 "grammar.y"
3045	{ (yyval.node) = makeNegateNode((yyvsp[(2) - (2)].node)); }
3046	break;
3047
3048	case 114:
3049	/* Line 1787 of yacc.c */
3050	#line 393 "grammar.y"
3051	{ (yyval.node) = makeBitwiseNotNode((yyvsp[(2) - (2)].node)); }
3052	break;
3053
3054	case 115:
3055	/* Line 1787 of yacc.c */
3056	#line 394 "grammar.y"
3057	{ (yyval.node) = makeLogicalNotNode((yyvsp[(2) - (2)].node)); }
3058	break;
3059
3060	case 121:
3061	/* Line 1787 of yacc.c */
3062	#line 408 "grammar.y"
3063	{ (yyval.node) = makeMultNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpMult); }
3064	break;
3065
3066	case 122:
3067	/* Line 1787 of yacc.c */
3068	#line 409 "grammar.y"
3069	{ (yyval.node) = makeMultNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpDiv); }
3070	break;
3071
3072	case 123:
3073	/* Line 1787 of yacc.c */
3074	#line 410 "grammar.y"
3075	{ (yyval.node) = makeMultNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpMod); }
3076	break;
3077
3078	case 125:
3079	/* Line 1787 of yacc.c */
3080	#line 416 "grammar.y"
3081	{ (yyval.node) = makeMultNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpMult); }
3082	break;
3083
3084	case 126:
3085	/* Line 1787 of yacc.c */
3086	#line 418 "grammar.y"
3087	{ (yyval.node) = makeMultNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpDiv); }
3088	break;
3089
3090	case 127:
3091	/* Line 1787 of yacc.c */
3092	#line 420 "grammar.y"
3093	{ (yyval.node) = makeMultNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpMod); }
3094	break;
3095
3096	case 129:
3097	/* Line 1787 of yacc.c */
3098	#line 425 "grammar.y"
3099	{ (yyval.node) = makeAddNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpPlus); }
3100	break;
3101
3102	case 130:
3103	/* Line 1787 of yacc.c */
3104	#line 426 "grammar.y"
3105	{ (yyval.node) = makeAddNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpMinus); }
3106	break;
3107
3108	case 132:
3109	/* Line 1787 of yacc.c */
3110	#line 432 "grammar.y"
3111	{ (yyval.node) = makeAddNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpPlus); }
3112	break;
3113
3114	case 133:
3115	/* Line 1787 of yacc.c */
3116	#line 434 "grammar.y"
3117	{ (yyval.node) = makeAddNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpMinus); }
3118	break;
3119
3120	case 135:
3121	/* Line 1787 of yacc.c */
3122	#line 439 "grammar.y"
3123	{ (yyval.node) = makeShiftNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpLShift); }
3124	break;
3125
3126	case 136:
3127	/* Line 1787 of yacc.c */
3128	#line 440 "grammar.y"
3129	{ (yyval.node) = makeShiftNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpRShift); }
3130	break;
3131
3132	case 137:
3133	/* Line 1787 of yacc.c */
3134	#line 441 "grammar.y"
3135	{ (yyval.node) = makeShiftNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpURShift); }
3136	break;
3137
3138	case 139:
3139	/* Line 1787 of yacc.c */
3140	#line 446 "grammar.y"
3141	{ (yyval.node) = makeShiftNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpLShift); }
3142	break;
3143
3144	case 140:
3145	/* Line 1787 of yacc.c */
3146	#line 447 "grammar.y"
3147	{ (yyval.node) = makeShiftNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpRShift); }
3148	break;
3149
3150	case 141:
3151	/* Line 1787 of yacc.c */
3152	#line 448 "grammar.y"
3153	{ (yyval.node) = makeShiftNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node), OpURShift); }
3154	break;
3155
3156	case 143:
3157	/* Line 1787 of yacc.c */
3158	#line 453 "grammar.y"
3159	{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpLess, (yyvsp[(3) - (3)].node)); }
3160	break;
3161
3162	case 144:
3163	/* Line 1787 of yacc.c */
3164	#line 454 "grammar.y"
3165	{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpGreater, (yyvsp[(3) - (3)].node)); }
3166	break;
3167
3168	case 145:
3169	/* Line 1787 of yacc.c */
3170	#line 455 "grammar.y"
3171	{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpLessEq, (yyvsp[(3) - (3)].node)); }
3172	break;
3173
3174	case 146:
3175	/* Line 1787 of yacc.c */
3176	#line 456 "grammar.y"
3177	{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpGreaterEq, (yyvsp[(3) - (3)].node)); }
3178	break;
3179
3180	case 147:
3181	/* Line 1787 of yacc.c */
3182	#line 457 "grammar.y"
3183	{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpInstanceOf, (yyvsp[(3) - (3)].node)); }
3184	break;
3185
3186	case 148:
3187	/* Line 1787 of yacc.c */
3188	#line 458 "grammar.y"
3189	{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpIn, (yyvsp[(3) - (3)].node)); }
3190	break;
3191
3192	case 150:
3193	/* Line 1787 of yacc.c */
3194	#line 463 "grammar.y"
3195	{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpLess, (yyvsp[(3) - (3)].node)); }
3196	break;
3197
3198	case 151:
3199	/* Line 1787 of yacc.c */
3200	#line 464 "grammar.y"
3201	{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpGreater, (yyvsp[(3) - (3)].node)); }
3202	break;
3203
3204	case 152:
3205	/* Line 1787 of yacc.c */
3206	#line 465 "grammar.y"
3207	{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpLessEq, (yyvsp[(3) - (3)].node)); }
3208	break;
3209
3210	case 153:
3211	/* Line 1787 of yacc.c */
3212	#line 466 "grammar.y"
3213	{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpGreaterEq, (yyvsp[(3) - (3)].node)); }
3214	break;
3215
3216	case 154:
3217	/* Line 1787 of yacc.c */
3218	#line 468 "grammar.y"
3219	{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpInstanceOf, (yyvsp[(3) - (3)].node)); }
3220	break;
3221
3222	case 156:
3223	/* Line 1787 of yacc.c */
3224	#line 473 "grammar.y"
3225	{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpLess, (yyvsp[(3) - (3)].node)); }
3226	break;
3227
3228	case 157:
3229	/* Line 1787 of yacc.c */
3230	#line 474 "grammar.y"
3231	{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpGreater, (yyvsp[(3) - (3)].node)); }
3232	break;
3233
3234	case 158:
3235	/* Line 1787 of yacc.c */
3236	#line 475 "grammar.y"
3237	{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpLessEq, (yyvsp[(3) - (3)].node)); }
3238	break;
3239
3240	case 159:
3241	/* Line 1787 of yacc.c */
3242	#line 476 "grammar.y"
3243	{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpGreaterEq, (yyvsp[(3) - (3)].node)); }
3244	break;
3245
3246	case 160:
3247	/* Line 1787 of yacc.c */
3248	#line 478 "grammar.y"
3249	{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpInstanceOf, (yyvsp[(3) - (3)].node)); }
3250	break;
3251
3252	case 161:
3253	/* Line 1787 of yacc.c */
3254	#line 479 "grammar.y"
3255	{ (yyval.node) = makeRelationalNode((yyvsp[(1) - (3)].node), OpIn, (yyvsp[(3) - (3)].node)); }
3256	break;
3257
3258	case 163:
3259	/* Line 1787 of yacc.c */
3260	#line 484 "grammar.y"
3261	{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpEqEq, (yyvsp[(3) - (3)].node)); }
3262	break;
3263
3264	case 164:
3265	/* Line 1787 of yacc.c */
3266	#line 485 "grammar.y"
3267	{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpNotEq, (yyvsp[(3) - (3)].node)); }
3268	break;
3269
3270	case 165:
3271	/* Line 1787 of yacc.c */
3272	#line 486 "grammar.y"
3273	{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpStrEq, (yyvsp[(3) - (3)].node)); }
3274	break;
3275
3276	case 166:
3277	/* Line 1787 of yacc.c */
3278	#line 487 "grammar.y"
3279	{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpStrNEq, (yyvsp[(3) - (3)].node));}
3280	break;
3281
3282	case 168:
3283	/* Line 1787 of yacc.c */
3284	#line 493 "grammar.y"
3285	{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpEqEq, (yyvsp[(3) - (3)].node)); }
3286	break;
3287
3288	case 169:
3289	/* Line 1787 of yacc.c */
3290	#line 495 "grammar.y"
3291	{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpNotEq, (yyvsp[(3) - (3)].node)); }
3292	break;
3293
3294	case 170:
3295	/* Line 1787 of yacc.c */
3296	#line 497 "grammar.y"
3297	{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpStrEq, (yyvsp[(3) - (3)].node)); }
3298	break;
3299
3300	case 171:
3301	/* Line 1787 of yacc.c */
3302	#line 499 "grammar.y"
3303	{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpStrNEq, (yyvsp[(3) - (3)].node));}
3304	break;
3305
3306	case 173:
3307	/* Line 1787 of yacc.c */
3308	#line 505 "grammar.y"
3309	{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpEqEq, (yyvsp[(3) - (3)].node)); }
3310	break;
3311
3312	case 174:
3313	/* Line 1787 of yacc.c */
3314	#line 506 "grammar.y"
3315	{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpNotEq, (yyvsp[(3) - (3)].node)); }
3316	break;
3317
3318	case 175:
3319	/* Line 1787 of yacc.c */
3320	#line 508 "grammar.y"
3321	{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpStrEq, (yyvsp[(3) - (3)].node)); }
3322	break;
3323
3324	case 176:
3325	/* Line 1787 of yacc.c */
3326	#line 510 "grammar.y"
3327	{ (yyval.node) = makeEqualNode((yyvsp[(1) - (3)].node), OpStrNEq, (yyvsp[(3) - (3)].node));}
3328	break;
3329
3330	case 178:
3331	/* Line 1787 of yacc.c */
3332	#line 515 "grammar.y"
3333	{ (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitAnd, (yyvsp[(3) - (3)].node)); }
3334	break;
3335
3336	case 180:
3337	/* Line 1787 of yacc.c */
3338	#line 521 "grammar.y"
3339	{ (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitAnd, (yyvsp[(3) - (3)].node)); }
3340	break;
3341
3342	case 182:
3343	/* Line 1787 of yacc.c */
3344	#line 526 "grammar.y"
3345	{ (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitAnd, (yyvsp[(3) - (3)].node)); }
3346	break;
3347
3348	case 184:
3349	/* Line 1787 of yacc.c */
3350	#line 531 "grammar.y"
3351	{ (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitXOr, (yyvsp[(3) - (3)].node)); }
3352	break;
3353
3354	case 186:
3355	/* Line 1787 of yacc.c */
3356	#line 537 "grammar.y"
3357	{ (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitXOr, (yyvsp[(3) - (3)].node)); }
3358	break;
3359
3360	case 188:
3361	/* Line 1787 of yacc.c */
3362	#line 543 "grammar.y"
3363	{ (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitXOr, (yyvsp[(3) - (3)].node)); }
3364	break;
3365
3366	case 190:
3367	/* Line 1787 of yacc.c */
3368	#line 548 "grammar.y"
3369	{ (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitOr, (yyvsp[(3) - (3)].node)); }
3370	break;
3371
3372	case 192:
3373	/* Line 1787 of yacc.c */
3374	#line 554 "grammar.y"
3375	{ (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitOr, (yyvsp[(3) - (3)].node)); }
3376	break;
3377
3378	case 194:
3379	/* Line 1787 of yacc.c */
3380	#line 560 "grammar.y"
3381	{ (yyval.node) = makeBitOperNode((yyvsp[(1) - (3)].node), OpBitOr, (yyvsp[(3) - (3)].node)); }
3382	break;
3383
3384	case 196:
3385	/* Line 1787 of yacc.c */
3386	#line 565 "grammar.y"
3387	{ (yyval.node) = makeBinaryLogicalNode((yyvsp[(1) - (3)].node), OpAnd, (yyvsp[(3) - (3)].node)); }
3388	break;
3389
3390	case 198:
3391	/* Line 1787 of yacc.c */
3392	#line 571 "grammar.y"
3393	{ (yyval.node) = makeBinaryLogicalNode((yyvsp[(1) - (3)].node), OpAnd, (yyvsp[(3) - (3)].node)); }
3394	break;
3395
3396	case 200:
3397	/* Line 1787 of yacc.c */
3398	#line 577 "grammar.y"
3399	{ (yyval.node) = makeBinaryLogicalNode((yyvsp[(1) - (3)].node), OpAnd, (yyvsp[(3) - (3)].node)); }
3400	break;
3401
3402	case 202:
3403	/* Line 1787 of yacc.c */
3404	#line 582 "grammar.y"
3405	{ (yyval.node) = makeBinaryLogicalNode((yyvsp[(1) - (3)].node), OpOr, (yyvsp[(3) - (3)].node)); }
3406	break;
3407
3408	case 204:
3409	/* Line 1787 of yacc.c */
3410	#line 588 "grammar.y"
3411	{ (yyval.node) = makeBinaryLogicalNode((yyvsp[(1) - (3)].node), OpOr, (yyvsp[(3) - (3)].node)); }
3412	break;
3413
3414	case 206:
3415	/* Line 1787 of yacc.c */
3416	#line 593 "grammar.y"
3417	{ (yyval.node) = makeBinaryLogicalNode((yyvsp[(1) - (3)].node), OpOr, (yyvsp[(3) - (3)].node)); }
3418	break;
3419
3420	case 208:
3421	/* Line 1787 of yacc.c */
3422	#line 599 "grammar.y"
3423	{ (yyval.node) = makeConditionalNode((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node)); }
3424	break;
3425
3426	case 210:
3427	/* Line 1787 of yacc.c */
3428	#line 605 "grammar.y"
3429	{ (yyval.node) = makeConditionalNode((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node)); }
3430	break;
3431
3432	case 212:
3433	/* Line 1787 of yacc.c */
3434	#line 611 "grammar.y"
3435	{ (yyval.node) = makeConditionalNode((yyvsp[(1) - (5)].node), (yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].node)); }
3436	break;
3437
3438	case 214:
3439	/* Line 1787 of yacc.c */
3440	#line 617 "grammar.y"
3441	{ (yyval.node) = makeAssignNode((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].op), (yyvsp[(3) - (3)].node)); }
3442	break;
3443
3444	case 216:
3445	/* Line 1787 of yacc.c */
3446	#line 623 "grammar.y"
3447	{ (yyval.node) = makeAssignNode((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].op), (yyvsp[(3) - (3)].node)); }
3448	break;
3449
3450	case 218:
3451	/* Line 1787 of yacc.c */
3452	#line 629 "grammar.y"
3453	{ (yyval.node) = makeAssignNode((yyvsp[(1) - (3)].node), (yyvsp[(2) - (3)].op), (yyvsp[(3) - (3)].node)); }
3454	break;
3455
3456	case 219:
3457	/* Line 1787 of yacc.c */
3458	#line 633 "grammar.y"
3459	{ (yyval.op) = OpEqual; }
3460	break;
3461
3462	case 220:
3463	/* Line 1787 of yacc.c */
3464	#line 634 "grammar.y"
3465	{ (yyval.op) = OpPlusEq; }
3466	break;
3467
3468	case 221:
3469	/* Line 1787 of yacc.c */
3470	#line 635 "grammar.y"
3471	{ (yyval.op) = OpMinusEq; }
3472	break;
3473
3474	case 222:
3475	/* Line 1787 of yacc.c */
3476	#line 636 "grammar.y"
3477	{ (yyval.op) = OpMultEq; }
3478	break;
3479
3480	case 223:
3481	/* Line 1787 of yacc.c */
3482	#line 637 "grammar.y"
3483	{ (yyval.op) = OpDivEq; }
3484	break;
3485
3486	case 224:
3487	/* Line 1787 of yacc.c */
3488	#line 638 "grammar.y"
3489	{ (yyval.op) = OpLShift; }
3490	break;
3491
3492	case 225:
3493	/* Line 1787 of yacc.c */
3494	#line 639 "grammar.y"
3495	{ (yyval.op) = OpRShift; }
3496	break;
3497
3498	case 226:
3499	/* Line 1787 of yacc.c */
3500	#line 640 "grammar.y"
3501	{ (yyval.op) = OpURShift; }
3502	break;
3503
3504	case 227:
3505	/* Line 1787 of yacc.c */
3506	#line 641 "grammar.y"
3507	{ (yyval.op) = OpAndEq; }
3508	break;
3509
3510	case 228:
3511	/* Line 1787 of yacc.c */
3512	#line 642 "grammar.y"
3513	{ (yyval.op) = OpXOrEq; }
3514	break;
3515
3516	case 229:
3517	/* Line 1787 of yacc.c */
3518	#line 643 "grammar.y"
3519	{ (yyval.op) = OpOrEq; }
3520	break;
3521
3522	case 230:
3523	/* Line 1787 of yacc.c */
3524	#line 644 "grammar.y"
3525	{ (yyval.op) = OpModEq; }
3526	break;
3527
3528	case 232:
3529	/* Line 1787 of yacc.c */
3530	#line 649 "grammar.y"
3531	{ (yyval.node) = new CommaNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); }
3532	break;
3533
3534	case 234:
3535	/* Line 1787 of yacc.c */
3536	#line 654 "grammar.y"
3537	{ (yyval.node) = new CommaNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); }
3538	break;
3539
3540	case 236:
3541	/* Line 1787 of yacc.c */
3542	#line 659 "grammar.y"
3543	{ (yyval.node) = new CommaNode((yyvsp[(1) - (3)].node), (yyvsp[(3) - (3)].node)); }
3544	break;
3545
3546	case 254:
3547	/* Line 1787 of yacc.c */
3548	#line 683 "grammar.y"
3549	{ (yyval.stat) = new BlockNode(0); DBG((yyval.stat), (yylsp[(2) - (2)]), (yylsp[(2) - (2)])); }
3550	break;
3551
3552	case 255:
3553	/* Line 1787 of yacc.c */
3554	#line 684 "grammar.y"
3555	{ (yyval.stat) = new BlockNode((yyvsp[(2) - (3)].srcs)); DBG((yyval.stat), (yylsp[(3) - (3)]), (yylsp[(3) - (3)])); }
3556	break;
3557
3558	case 256:
3559	/* Line 1787 of yacc.c */
3560	#line 688 "grammar.y"
3561	{ (yyval.stat) = new VarStatementNode((yyvsp[(2) - (3)].vlist)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); }
3562	break;
3563
3564	case 257:
3565	/* Line 1787 of yacc.c */
3566	#line 689 "grammar.y"
3567	{ (yyval.stat) = new VarStatementNode((yyvsp[(2) - (3)].vlist)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(2) - (3)])); AUTO_SEMICOLON; }
3568	break;
3569
3570	case 258:
3571	/* Line 1787 of yacc.c */
3572	#line 693 "grammar.y"
3573	{ (yyval.vlist) = new VarDeclListNode((yyvsp[(1) - (1)].decl)); }
3574	break;
3575
3576	case 259:
3577	/* Line 1787 of yacc.c */
3578	#line 695 "grammar.y"
3579	{ (yyval.vlist) = new VarDeclListNode((yyvsp[(1) - (3)].vlist), (yyvsp[(3) - (3)].decl)); }
3580	break;
3581
3582	case 260:
3583	/* Line 1787 of yacc.c */
3584	#line 699 "grammar.y"
3585	{ (yyval.vlist) = new VarDeclListNode((yyvsp[(1) - (1)].decl)); }
3586	break;
3587
3588	case 261:
3589	/* Line 1787 of yacc.c */
3590	#line 701 "grammar.y"
3591	{ (yyval.vlist) = new VarDeclListNode((yyvsp[(1) - (3)].vlist), (yyvsp[(3) - (3)].decl)); }
3592	break;
3593
3594	case 262:
3595	/* Line 1787 of yacc.c */
3596	#line 705 "grammar.y"
3597	{ (yyval.decl) = new VarDeclNode(*(yyvsp[(1) - (1)].ident), 0, VarDeclNode::Variable); }
3598	break;
3599
3600	case 263:
3601	/* Line 1787 of yacc.c */
3602	#line 706 "grammar.y"
3603	{ (yyval.decl) = new VarDeclNode(*(yyvsp[(1) - (2)].ident), (yyvsp[(2) - (2)].init), VarDeclNode::Variable); }
3604	break;
3605
3606	case 264:
3607	/* Line 1787 of yacc.c */
3608	#line 710 "grammar.y"
3609	{ (yyval.decl) = new VarDeclNode(*(yyvsp[(1) - (1)].ident), 0, VarDeclNode::Variable); }
3610	break;
3611
3612	case 265:
3613	/* Line 1787 of yacc.c */
3614	#line 711 "grammar.y"
3615	{ (yyval.decl) = new VarDeclNode(*(yyvsp[(1) - (2)].ident), (yyvsp[(2) - (2)].init), VarDeclNode::Variable); }
3616	break;
3617
3618	case 266:
3619	/* Line 1787 of yacc.c */
3620	#line 715 "grammar.y"
3621	{ (yyval.stat) = new VarStatementNode((yyvsp[(2) - (3)].vlist)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); }
3622	break;
3623
3624	case 267:
3625	/* Line 1787 of yacc.c */
3626	#line 717 "grammar.y"
3627	{ (yyval.stat) = new VarStatementNode((yyvsp[(2) - (3)].vlist)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(2) - (3)])); AUTO_SEMICOLON; }
3628	break;
3629
3630	case 268:
3631	/* Line 1787 of yacc.c */
3632	#line 721 "grammar.y"
3633	{ (yyval.vlist) = new VarDeclListNode((yyvsp[(1) - (1)].decl)); }
3634	break;
3635
3636	case 269:
3637	/* Line 1787 of yacc.c */
3638	#line 723 "grammar.y"
3639	{ (yyval.vlist) = new VarDeclListNode((yyvsp[(1) - (3)].vlist), (yyvsp[(3) - (3)].decl)); }
3640	break;
3641
3642	case 270:
3643	/* Line 1787 of yacc.c */
3644	#line 727 "grammar.y"
3645	{ (yyval.decl) = new VarDeclNode(*(yyvsp[(1) - (1)].ident), 0, VarDeclNode::Constant); }
3646	break;
3647
3648	case 271:
3649	/* Line 1787 of yacc.c */
3650	#line 728 "grammar.y"
3651	{ (yyval.decl) = new VarDeclNode(*(yyvsp[(1) - (2)].ident), (yyvsp[(2) - (2)].init), VarDeclNode::Constant); }
3652	break;
3653
3654	case 272:
3655	/* Line 1787 of yacc.c */
3656	#line 732 "grammar.y"
3657	{ (yyval.init) = new AssignExprNode((yyvsp[(2) - (2)].node)); }
3658	break;
3659
3660	case 273:
3661	/* Line 1787 of yacc.c */
3662	#line 736 "grammar.y"
3663	{ (yyval.init) = new AssignExprNode((yyvsp[(2) - (2)].node)); }
3664	break;
3665
3666	case 274:
3667	/* Line 1787 of yacc.c */
3668	#line 740 "grammar.y"
3669	{ (yyval.stat) = new EmptyStatementNode(); }
3670	break;
3671
3672	case 275:
3673	/* Line 1787 of yacc.c */
3674	#line 744 "grammar.y"
3675	{ (yyval.stat) = new ExprStatementNode((yyvsp[(1) - (2)].node)); DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(2) - (2)])); }
3676	break;
3677
3678	case 276:
3679	/* Line 1787 of yacc.c */
3680	#line 745 "grammar.y"
3681	{ (yyval.stat) = new ExprStatementNode((yyvsp[(1) - (2)].node)); DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(1) - (2)])); AUTO_SEMICOLON; }
3682	break;
3683
3684	case 277:
3685	/* Line 1787 of yacc.c */
3686	#line 750 "grammar.y"
3687	{ (yyval.stat) = makeIfNode((yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].stat), 0); DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(4) - (5)])); }
3688	break;
3689
3690	case 278:
3691	/* Line 1787 of yacc.c */
3692	#line 752 "grammar.y"
3693	{ (yyval.stat) = makeIfNode((yyvsp[(3) - (7)].node), (yyvsp[(5) - (7)].stat), (yyvsp[(7) - (7)].stat)); DBG((yyval.stat), (yylsp[(1) - (7)]), (yylsp[(4) - (7)])); }
3694	break;
3695
3696	case 279:
3697	/* Line 1787 of yacc.c */
3698	#line 756 "grammar.y"
3699	{ (yyval.stat) = new DoWhileNode((yyvsp[(2) - (7)].stat), (yyvsp[(5) - (7)].node)); DBG((yyval.stat), (yylsp[(1) - (7)]), (yylsp[(3) - (7)]));}
3700	break;
3701
3702	case 280:
3703	/* Line 1787 of yacc.c */
3704	#line 757 "grammar.y"
3705	{ (yyval.stat) = new DoWhileNode((yyvsp[(2) - (7)].stat), (yyvsp[(5) - (7)].node)); DBG((yyval.stat), (yylsp[(1) - (7)]), (yylsp[(3) - (7)])); AUTO_SEMICOLON; }
3706	break;
3707
3708	case 281:
3709	/* Line 1787 of yacc.c */
3710	#line 758 "grammar.y"
3711	{ (yyval.stat) = new WhileNode((yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].stat)); DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(4) - (5)])); }
3712	break;
3713
3714	case 282:
3715	/* Line 1787 of yacc.c */
3716	#line 760 "grammar.y"
3717	{ (yyval.stat) = new ForNode((yyvsp[(3) - (9)].node), (yyvsp[(5) - (9)].node), (yyvsp[(7) - (9)].node), (yyvsp[(9) - (9)].stat)); DBG((yyval.stat), (yylsp[(1) - (9)]), (yylsp[(8) - (9)])); }
3718	break;
3719
3720	case 283:
3721	/* Line 1787 of yacc.c */
3722	#line 762 "grammar.y"
3723	{ (yyval.stat) = new ForNode((yyvsp[(4) - (10)].vlist), (yyvsp[(6) - (10)].node), (yyvsp[(8) - (10)].node), (yyvsp[(10) - (10)].stat)); DBG((yyval.stat), (yylsp[(1) - (10)]), (yylsp[(9) - (10)])); }
3724	break;
3725
3726	case 284:
3727	/* Line 1787 of yacc.c */
3728	#line 764 "grammar.y"
3729	{
3730	Node *n = (yyvsp[(3) - (7)].node)->nodeInsideAllParens();
3731	if (!n->isLocation())
3732	YYABORT;
3733	(yyval.stat) = new ForInNode(n, (yyvsp[(5) - (7)].node), (yyvsp[(7) - (7)].stat));
3734	DBG((yyval.stat), (yylsp[(1) - (7)]), (yylsp[(6) - (7)]));
3735	}
3736	break;
3737
3738	case 285:
3739	/* Line 1787 of yacc.c */
3740	#line 772 "grammar.y"
3741	{ (yyval.stat) = new ForInNode(*(yyvsp[(4) - (8)].ident), 0, (yyvsp[(6) - (8)].node), (yyvsp[(8) - (8)].stat)); DBG((yyval.stat), (yylsp[(1) - (8)]), (yylsp[(7) - (8)])); }
3742	break;
3743
3744	case 286:
3745	/* Line 1787 of yacc.c */
3746	#line 774 "grammar.y"
3747	{ (yyval.stat) = new ForInNode(*(yyvsp[(4) - (9)].ident), (yyvsp[(5) - (9)].init), (yyvsp[(7) - (9)].node), (yyvsp[(9) - (9)].stat)); DBG((yyval.stat), (yylsp[(1) - (9)]), (yylsp[(8) - (9)])); }
3748	break;
3749
3750	case 287:
3751	/* Line 1787 of yacc.c */
3752	#line 778 "grammar.y"
3753	{ (yyval.node) = 0; }
3754	break;
3755
3756	case 289:
3757	/* Line 1787 of yacc.c */
3758	#line 783 "grammar.y"
3759	{ (yyval.node) = 0; }
3760	break;
3761
3762	case 291:
3763	/* Line 1787 of yacc.c */
3764	#line 788 "grammar.y"
3765	{ (yyval.stat) = new ContinueNode(); DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(2) - (2)])); }
3766	break;
3767
3768	case 292:
3769	/* Line 1787 of yacc.c */
3770	#line 789 "grammar.y"
3771	{ (yyval.stat) = new ContinueNode(); DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(1) - (2)])); AUTO_SEMICOLON; }
3772	break;
3773
3774	case 293:
3775	/* Line 1787 of yacc.c */
3776	#line 790 "grammar.y"
3777	{ (yyval.stat) = new ContinueNode(*(yyvsp[(2) - (3)].ident)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); }
3778	break;
3779
3780	case 294:
3781	/* Line 1787 of yacc.c */
3782	#line 791 "grammar.y"
3783	{ (yyval.stat) = new ContinueNode(*(yyvsp[(2) - (3)].ident)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(2) - (3)])); AUTO_SEMICOLON; }
3784	break;
3785
3786	case 295:
3787	/* Line 1787 of yacc.c */
3788	#line 795 "grammar.y"
3789	{ (yyval.stat) = new BreakNode(); DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(2) - (2)])); }
3790	break;
3791
3792	case 296:
3793	/* Line 1787 of yacc.c */
3794	#line 796 "grammar.y"
3795	{ (yyval.stat) = new BreakNode(); DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(1) - (2)])); AUTO_SEMICOLON; }
3796	break;
3797
3798	case 297:
3799	/* Line 1787 of yacc.c */
3800	#line 797 "grammar.y"
3801	{ (yyval.stat) = new BreakNode(*(yyvsp[(2) - (3)].ident)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); }
3802	break;
3803
3804	case 298:
3805	/* Line 1787 of yacc.c */
3806	#line 798 "grammar.y"
3807	{ (yyval.stat) = new BreakNode(*(yyvsp[(2) - (3)].ident)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(2) - (3)])); AUTO_SEMICOLON; }
3808	break;
3809
3810	case 299:
3811	/* Line 1787 of yacc.c */
3812	#line 802 "grammar.y"
3813	{ (yyval.stat) = new ReturnNode(0); DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(2) - (2)])); }
3814	break;
3815
3816	case 300:
3817	/* Line 1787 of yacc.c */
3818	#line 803 "grammar.y"
3819	{ (yyval.stat) = new ReturnNode(0); DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(1) - (2)])); AUTO_SEMICOLON; }
3820	break;
3821
3822	case 301:
3823	/* Line 1787 of yacc.c */
3824	#line 804 "grammar.y"
3825	{ (yyval.stat) = new ReturnNode((yyvsp[(2) - (3)].node)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); }
3826	break;
3827
3828	case 302:
3829	/* Line 1787 of yacc.c */
3830	#line 805 "grammar.y"
3831	{ (yyval.stat) = new ReturnNode((yyvsp[(2) - (3)].node)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(2) - (3)])); AUTO_SEMICOLON; }
3832	break;
3833
3834	case 303:
3835	/* Line 1787 of yacc.c */
3836	#line 809 "grammar.y"
3837	{ (yyval.stat) = new WithNode((yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].stat)); DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(4) - (5)])); }
3838	break;
3839
3840	case 304:
3841	/* Line 1787 of yacc.c */
3842	#line 813 "grammar.y"
3843	{ (yyval.stat) = new SwitchNode((yyvsp[(3) - (5)].node), (yyvsp[(5) - (5)].cblk)); DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(4) - (5)])); }
3844	break;
3845
3846	case 305:
3847	/* Line 1787 of yacc.c */
3848	#line 817 "grammar.y"
3849	{ (yyval.cblk) = new CaseBlockNode((yyvsp[(2) - (3)].clist), 0, 0); }
3850	break;
3851
3852	case 306:
3853	/* Line 1787 of yacc.c */
3854	#line 819 "grammar.y"
3855	{ (yyval.cblk) = new CaseBlockNode((yyvsp[(2) - (5)].clist), (yyvsp[(3) - (5)].ccl), (yyvsp[(4) - (5)].clist)); }
3856	break;
3857
3858	case 307:
3859	/* Line 1787 of yacc.c */
3860	#line 823 "grammar.y"
3861	{ (yyval.clist) = 0; }
3862	break;
3863
3864	case 309:
3865	/* Line 1787 of yacc.c */
3866	#line 828 "grammar.y"
3867	{ (yyval.clist) = new ClauseListNode((yyvsp[(1) - (1)].ccl)); }
3868	break;
3869
3870	case 310:
3871	/* Line 1787 of yacc.c */
3872	#line 829 "grammar.y"
3873	{ (yyval.clist) = new ClauseListNode((yyvsp[(1) - (2)].clist), (yyvsp[(2) - (2)].ccl)); }
3874	break;
3875
3876	case 311:
3877	/* Line 1787 of yacc.c */
3878	#line 833 "grammar.y"
3879	{ (yyval.ccl) = new CaseClauseNode((yyvsp[(2) - (3)].node)); }
3880	break;
3881
3882	case 312:
3883	/* Line 1787 of yacc.c */
3884	#line 834 "grammar.y"
3885	{ (yyval.ccl) = new CaseClauseNode((yyvsp[(2) - (4)].node), (yyvsp[(4) - (4)].srcs)); }
3886	break;
3887
3888	case 313:
3889	/* Line 1787 of yacc.c */
3890	#line 838 "grammar.y"
3891	{ (yyval.ccl) = new CaseClauseNode(0); }
3892	break;
3893
3894	case 314:
3895	/* Line 1787 of yacc.c */
3896	#line 839 "grammar.y"
3897	{ (yyval.ccl) = new CaseClauseNode(0, (yyvsp[(3) - (3)].srcs)); }
3898	break;
3899
3900	case 315:
3901	/* Line 1787 of yacc.c */
3902	#line 843 "grammar.y"
3903	{ (yyval.stat) = makeLabelNode(*(yyvsp[(1) - (3)].ident), (yyvsp[(3) - (3)].stat)); }
3904	break;
3905
3906	case 316:
3907	/* Line 1787 of yacc.c */
3908	#line 847 "grammar.y"
3909	{ (yyval.stat) = new ThrowNode((yyvsp[(2) - (3)].node)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); }
3910	break;
3911
3912	case 317:
3913	/* Line 1787 of yacc.c */
3914	#line 848 "grammar.y"
3915	{ (yyval.stat) = new ThrowNode((yyvsp[(2) - (3)].node)); DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(2) - (3)])); AUTO_SEMICOLON; }
3916	break;
3917
3918	case 318:
3919	/* Line 1787 of yacc.c */
3920	#line 852 "grammar.y"
3921	{ (yyval.stat) = new TryNode((yyvsp[(2) - (4)].stat), CommonIdentifiers::shared()->nullIdentifier, 0, (yyvsp[(4) - (4)].stat)); DBG((yyval.stat), (yylsp[(1) - (4)]), (yylsp[(2) - (4)])); }
3922	break;
3923
3924	case 319:
3925	/* Line 1787 of yacc.c */
3926	#line 853 "grammar.y"
3927	{ (yyval.stat) = new TryNode((yyvsp[(2) - (7)].stat), *(yyvsp[(5) - (7)].ident), (yyvsp[(7) - (7)].stat), 0); DBG((yyval.stat), (yylsp[(1) - (7)]), (yylsp[(2) - (7)])); }
3928	break;
3929
3930	case 320:
3931	/* Line 1787 of yacc.c */
3932	#line 855 "grammar.y"
3933	{ (yyval.stat) = new TryNode((yyvsp[(2) - (9)].stat), *(yyvsp[(5) - (9)].ident), (yyvsp[(7) - (9)].stat), (yyvsp[(9) - (9)].stat)); DBG((yyval.stat), (yylsp[(1) - (9)]), (yylsp[(2) - (9)])); }
3934	break;
3935
3936	case 321:
3937	/* Line 1787 of yacc.c */
3938	#line 859 "grammar.y"
3939	{ (yyval.stat) = new EmptyStatementNode(); DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(2) - (2)])); }
3940	break;
3941
3942	case 322:
3943	/* Line 1787 of yacc.c */
3944	#line 860 "grammar.y"
3945	{ (yyval.stat) = new EmptyStatementNode(); DBG((yyval.stat), (yylsp[(1) - (2)]), (yylsp[(1) - (2)])); AUTO_SEMICOLON; }
3946	break;
3947
3948	case 323:
3949	/* Line 1787 of yacc.c */
3950	#line 864 "grammar.y"
3951	{ (yyval.pkgn) = new PackageNameNode(*(yyvsp[(1) - (1)].ident)); }
3952	break;
3953
3954	case 324:
3955	/* Line 1787 of yacc.c */
3956	#line 865 "grammar.y"
3957	{ (yyval.pkgn) = new PackageNameNode((yyvsp[(1) - (3)].pkgn), *(yyvsp[(3) - (3)].ident)); }
3958	break;
3959
3960	case 325:
3961	/* Line 1787 of yacc.c */
3962	#line 869 "grammar.y"
3963	{ (yyval.stat) = makeImportNode((yyvsp[(2) - (5)].pkgn), true, 0);
3964	DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(5) - (5)])); }
3965	break;
3966
3967	case 326:
3968	/* Line 1787 of yacc.c */
3969	#line 871 "grammar.y"
3970	{ (yyval.stat) = makeImportNode((yyvsp[(2) - (5)].pkgn), true, 0);
3971	DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(5) - (5)])); AUTO_SEMICOLON; }
3972	break;
3973
3974	case 327:
3975	/* Line 1787 of yacc.c */
3976	#line 873 "grammar.y"
3977	{ (yyval.stat) = makeImportNode((yyvsp[(2) - (3)].pkgn), false, 0);
3978	DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); }
3979	break;
3980
3981	case 328:
3982	/* Line 1787 of yacc.c */
3983	#line 875 "grammar.y"
3984	{ (yyval.stat) = makeImportNode((yyvsp[(2) - (3)].pkgn), false, 0);
3985	DBG((yyval.stat), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); AUTO_SEMICOLON; }
3986	break;
3987
3988	case 329:
3989	/* Line 1787 of yacc.c */
3990	#line 877 "grammar.y"
3991	{ (yyval.stat) = makeImportNode((yyvsp[(4) - (5)].pkgn), false, *(yyvsp[(2) - (5)].ident));
3992	DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(5) - (5)])); }
3993	break;
3994
3995	case 330:
3996	/* Line 1787 of yacc.c */
3997	#line 879 "grammar.y"
3998	{ (yyval.stat) = makeImportNode((yyvsp[(4) - (5)].pkgn), false, *(yyvsp[(2) - (5)].ident));
3999	DBG((yyval.stat), (yylsp[(1) - (5)]), (yylsp[(5) - (5)])); AUTO_SEMICOLON; }
4000	break;
4001
4002	case 331:
4003	/* Line 1787 of yacc.c */
4004	#line 884 "grammar.y"
4005	{inFuncDecl();}
4006	break;
4007
4008	case 332:
4009	/* Line 1787 of yacc.c */
4010	#line 884 "grammar.y"
4011	{ (yyval.func) = new FuncDeclNode(*(yyvsp[(2) - (6)].ident), (yyvsp[(6) - (6)].body)); }
4012	break;
4013
4014	case 333:
4015	/* Line 1787 of yacc.c */
4016	#line 885 "grammar.y"
4017	{inFuncDecl();}
4018	break;
4019
4020	case 334:
4021	/* Line 1787 of yacc.c */
4022	#line 886 "grammar.y"
4023	{ (yyval.func) = new FuncDeclNode(*(yyvsp[(2) - (7)].ident), (yyvsp[(4) - (7)].param), (yyvsp[(7) - (7)].body)); }
4024	break;
4025
4026	case 335:
4027	/* Line 1787 of yacc.c */
4028	#line 890 "grammar.y"
4029	{inFuncExpr();}
4030	break;
4031
4032	case 336:
4033	/* Line 1787 of yacc.c */
4034	#line 890 "grammar.y"
4035	{
4036	(yyval.funcExpr) = new FuncExprNode(CommonIdentifiers::shared()->nullIdentifier, (yyvsp[(5) - (5)].body));
4037	}
4038	break;
4039
4040	case 337:
4041	/* Line 1787 of yacc.c */
4042	#line 893 "grammar.y"
4043	{inFuncExpr();}
4044	break;
4045
4046	case 338:
4047	/* Line 1787 of yacc.c */
4048	#line 893 "grammar.y"
4049	{
4050	(yyval.funcExpr) = new FuncExprNode(CommonIdentifiers::shared()->nullIdentifier, (yyvsp[(6) - (6)].body), (yyvsp[(3) - (6)].param));
4051	}
4052	break;
4053
4054	case 339:
4055	/* Line 1787 of yacc.c */
4056	#line 896 "grammar.y"
4057	{inFuncExpr();}
4058	break;
4059
4060	case 340:
4061	/* Line 1787 of yacc.c */
4062	#line 896 "grammar.y"
4063	{ (yyval.funcExpr) = new FuncExprNode(*(yyvsp[(2) - (6)].ident), (yyvsp[(6) - (6)].body)); }
4064	break;
4065
4066	case 341:
4067	/* Line 1787 of yacc.c */
4068	#line 897 "grammar.y"
4069	{inFuncExpr();}
4070	break;
4071
4072	case 342:
4073	/* Line 1787 of yacc.c */
4074	#line 897 "grammar.y"
4075	{
4076	(yyval.funcExpr) = new FuncExprNode(*(yyvsp[(2) - (7)].ident), (yyvsp[(7) - (7)].body), (yyvsp[(4) - (7)].param));
4077	}
4078	break;
4079
4080	case 343:
4081	/* Line 1787 of yacc.c */
4082	#line 903 "grammar.y"
4083	{ (yyval.param) = new ParameterNode(*(yyvsp[(1) - (1)].ident)); }
4084	break;
4085
4086	case 344:
4087	/* Line 1787 of yacc.c */
4088	#line 904 "grammar.y"
4089	{ (yyval.param) = new ParameterNode((yyvsp[(1) - (3)].param), *(yyvsp[(3) - (3)].ident)); }
4090	break;
4091
4092	case 345:
4093	/* Line 1787 of yacc.c */
4094	#line 908 "grammar.y"
4095	{ (yyval.body) = new FunctionBodyNode(0); DBG((yyval.body), (yylsp[(1) - (2)]), (yylsp[(2) - (2)])); }
4096	break;
4097
4098	case 346:
4099	/* Line 1787 of yacc.c */
4100	#line 909 "grammar.y"
4101	{ (yyval.body) = new FunctionBodyNode((yyvsp[(2) - (3)].srcs)); DBG((yyval.body), (yylsp[(1) - (3)]), (yylsp[(3) - (3)])); }
4102	break;
4103
4104	case 347:
4105	/* Line 1787 of yacc.c */
4106	#line 913 "grammar.y"
4107	{ parser().didFinishParsing(new ProgramNode(0)); }
4108	break;
4109
4110	case 348:
4111	/* Line 1787 of yacc.c */
4112	#line 914 "grammar.y"
4113	{ parser().didFinishParsing(new ProgramNode((yyvsp[(1) - (1)].srcs))); }
4114	break;
4115
4116	case 349:
4117	/* Line 1787 of yacc.c */
4118	#line 918 "grammar.y"
4119	{ (yyval.srcs) = new SourceElementsNode((yyvsp[(1) - (1)].stat)); }
4120	break;
4121
4122	case 350:
4123	/* Line 1787 of yacc.c */
4124	#line 919 "grammar.y"
4125	{ (yyval.srcs) = new SourceElementsNode((yyvsp[(1) - (2)].srcs), (yyvsp[(2) - (2)].stat)); }
4126	break;
4127
4128	case 351:
4129	/* Line 1787 of yacc.c */
4130	#line 923 "grammar.y"
4131	{ (yyval.stat) = (yyvsp[(1) - (1)].func); }
4132	break;
4133
4134	case 352:
4135	/* Line 1787 of yacc.c */
4136	#line 924 "grammar.y"
4137	{ (yyval.stat) = (yyvsp[(1) - (1)].stat); }
4138	break;
4139
4140
4141	/* Line 1787 of yacc.c */
4142	#line 4143 "grammar.tab.c"
4143	default: break;
4144	}
4145	/* User semantic actions sometimes alter yychar, and that requires
4146	that yytoken be updated with the new translation. We take the
4147	approach of translating immediately before every use of yytoken.
4148	One alternative is translating here after every semantic action,
4149	but that translation would be missed if the semantic action invokes
4150	YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
4151	if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
4152	incorrect destructor might then be invoked immediately. In the
4153	case of YYERROR or YYBACKUP, subsequent parser actions might lead
4154	to an incorrect destructor call or verbose syntax error message
4155	before the lookahead is translated. */
4156	YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
4157
4158	YYPOPSTACK (yylen);
4159	yylen = 0;
4160	YY_STACK_PRINT (yyss, yyssp);
4161
4162	*++yyvsp = yyval;
4163	*++yylsp = yyloc;
4164
4165	/* Now `shift' the result of the reduction. Determine what state
4166	that goes to, based on the state we popped back to and the rule
4167	number reduced by. */
4168
4169	yyn = yyr1[yyn];
4170
4171	yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
4172	if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
4173	yystate = yytable[yystate];
4174	else
4175	yystate = yydefgoto[yyn - YYNTOKENS];
4176
4177	goto yynewstate;
4178
4179
4180	/*------------------------------------.
4181	| yyerrlab -- here on detecting error |
4182	`------------------------------------*/
4183	yyerrlab:
4184	/* Make sure we have latest lookahead translation. See comments at
4185	user semantic actions for why this is necessary. */
4186	yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
4187
4188	/* If not already recovering from an error, report this error. */
4189	if (!yyerrstatus)
4190	{
4191	++yynerrs;
4192	#if ! YYERROR_VERBOSE
4193	yyerror (YY_("syntax error"));
4194	#else
4195	# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
4196	yyssp, yytoken)
4197	{
4198	char const *yymsgp = YY_("syntax error");
4199	int yysyntax_error_status;
4200	yysyntax_error_status = YYSYNTAX_ERROR;
4201	if (yysyntax_error_status == 0)
4202	yymsgp = yymsg;
4203	else if (yysyntax_error_status == 1)
4204	{
4205	if (yymsg != yymsgbuf)
4206	YYSTACK_FREE (yymsg);
4207	yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
4208	if (!yymsg)
4209	{
4210	yymsg = yymsgbuf;
4211	yymsg_alloc = sizeof yymsgbuf;
4212	yysyntax_error_status = 2;
4213	}
4214	else
4215	{
4216	yysyntax_error_status = YYSYNTAX_ERROR;
4217	yymsgp = yymsg;
4218	}
4219	}
4220	yyerror (yymsgp);
4221	if (yysyntax_error_status == 2)
4222	goto yyexhaustedlab;
4223	}
4224	# undef YYSYNTAX_ERROR
4225	#endif
4226	}
4227
4228	yyerror_range[1] = yylloc;
4229
4230	if (yyerrstatus == 3)
4231	{
4232	/* If just tried and failed to reuse lookahead token after an
4233	error, discard it. */
4234
4235	if (yychar <= YYEOF)
4236	{
4237	/* Return failure if at end of input. */
4238	if (yychar == YYEOF)
4239	YYABORT;
4240	}
4241	else
4242	{
4243	yydestruct ("Error: discarding",
4244	yytoken, &yylval, &yylloc);
4245	yychar = YYEMPTY;
4246	}
4247	}
4248
4249	/* Else will try to reuse lookahead token after shifting the error
4250	token. */
4251	goto yyerrlab1;
4252
4253
4254	/*---------------------------------------------------.
4255	| yyerrorlab -- error raised explicitly by YYERROR. |
4256	`---------------------------------------------------*/
4257	yyerrorlab:
4258
4259	/* Pacify compilers like GCC when the user code never invokes
4260	YYERROR and the label yyerrorlab therefore never appears in user
4261	code. */
4262	if (/*CONSTCOND*/ 0)
4263	goto yyerrorlab;
4264
4265	yyerror_range[1] = yylsp[1-yylen];
4266	/* Do not reclaim the symbols of the rule which action triggered
4267	this YYERROR. */
4268	YYPOPSTACK (yylen);
4269	yylen = 0;
4270	YY_STACK_PRINT (yyss, yyssp);
4271	yystate = *yyssp;
4272	goto yyerrlab1;
4273
4274
4275	/*-------------------------------------------------------------.
4276	| yyerrlab1 -- common code for both syntax error and YYERROR. |
4277	`-------------------------------------------------------------*/
4278	yyerrlab1:
4279	yyerrstatus = 3; /* Each real token shifted decrements this. */
4280
4281	for (;;)
4282	{
4283	yyn = yypact[yystate];
4284	if (!yypact_value_is_default (yyn))
4285	{
4286	yyn += YYTERROR;
4287	if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
4288	{
4289	yyn = yytable[yyn];
4290	if (0 < yyn)
4291	break;
4292	}
4293	}
4294
4295	/* Pop the current state because it cannot handle the error token. */
4296	if (yyssp == yyss)
4297	YYABORT;
4298
4299	yyerror_range[1] = *yylsp;
4300	yydestruct ("Error: popping",
4301	yystos[yystate], yyvsp, yylsp);
4302	YYPOPSTACK (1);
4303	yystate = *yyssp;
4304	YY_STACK_PRINT (yyss, yyssp);
4305	}
4306
4307	YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
4308	*++yyvsp = yylval;
4309	YY_IGNORE_MAYBE_UNINITIALIZED_END
4310
4311	yyerror_range[2] = yylloc;
4312	/* Using YYLLOC is tempting, but would change the location of
4313	the lookahead. YYLOC is available though. */
4314	YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
4315	*++yylsp = yyloc;
4316
4317	/* Shift the error token. */
4318	YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
4319
4320	yystate = yyn;
4321	goto yynewstate;
4322
4323
4324	/*-------------------------------------.
4325	| yyacceptlab -- YYACCEPT comes here. |
4326	`-------------------------------------*/
4327	yyacceptlab:
4328	yyresult = 0;
4329	goto yyreturn;
4330
4331	/*-----------------------------------.
4332	| yyabortlab -- YYABORT comes here. |
4333	`-----------------------------------*/
4334	yyabortlab:
4335	yyresult = 1;
4336	goto yyreturn;
4337
4338	#if !defined yyoverflow || YYERROR_VERBOSE
4339	/*-------------------------------------------------.
4340	| yyexhaustedlab -- memory exhaustion comes here. |
4341	`-------------------------------------------------*/
4342	yyexhaustedlab:
4343	yyerror (YY_("memory exhausted"));
4344	yyresult = 2;
4345	/* Fall through. */
4346	#endif
4347
4348	yyreturn:
4349	if (yychar != YYEMPTY)
4350	{
4351	/* Make sure we have latest lookahead translation. See comments at
4352	user semantic actions for why this is necessary. */
4353	yytoken = YYTRANSLATE (yychar);
4354	yydestruct ("Cleanup: discarding lookahead",
4355	yytoken, &yylval, &yylloc);
4356	}
4357	/* Do not reclaim the symbols of the rule which action triggered
4358	this YYABORT or YYACCEPT. */
4359	YYPOPSTACK (yylen);
4360	YY_STACK_PRINT (yyss, yyssp);
4361	while (yyssp != yyss)
4362	{
4363	yydestruct ("Cleanup: popping",
4364	yystos[*yyssp], yyvsp, yylsp);
4365	YYPOPSTACK (1);
4366	}
4367	#ifndef yyoverflow
4368	if (yyss != yyssa)
4369	YYSTACK_FREE (yyss);
4370	#endif
4371	#if YYERROR_VERBOSE
4372	if (yymsg != yymsgbuf)
4373	YYSTACK_FREE (yymsg);
4374	#endif
4375	/* Make sure YYID is used. */
4376	return YYID (yyresult);
4377	}
4378
4379
4380	/* Line 2050 of yacc.c */
4381	#line 927 "grammar.y"
4382
4383
4384	/* called by yyparse on error */
4385	int yyerror(const char *)
4386	{
4387	// fprintf(stderr, "ERROR: %s at line %d\n", s, KJS::Lexer::curr()->lineNo());
4388	return 1;
4389	}
4390
4391	/* may we automatically insert a semicolon ? */
4392	static bool allowAutomaticSemicolon()
4393	{
4394	return yychar == '}' || yychar == 0 || lexer().prevTerminator();
4395	}
4396
4397	// kate: indent-width 2; replace-tabs on; tab-width 4; space-indent on;
4398
4399

---

Generated on 2014-Aug-04 from project kdelibs revision v4.13.97
Powered by Code Browser 1.7