regen parser for win32

Jack Atherton committed 8 years ago

Commit 52b166a1 parent 015380b3 files · +3590 −3580Browse files

Unified · Split

3 files

src/core/chuck_win32.c +3526 −3534
src/core/chuck_win32.h +47 −46
src/makefile +17 −0

@@ -2,43 +2,43 @@ · 1 unmodified line
2	2
3	3	/* Bison implementation for Yacc-like parsers in C
4	4
5		−Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
	5	+ Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
6	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.
	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	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.
	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	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/>. */
	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	19
20	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. */
	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	32
33	33	/* C LALR(1) parser skeleton written by Richard Stallman, by
34		−simplifying the original so-called "semantic" parser. */
	34	+ simplifying the original so-called "semantic" parser. */
35	35
36	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. */
	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	42
43	43	/* Identify Bison output. */
44	44	#define YYBISON 1
@@ -66,27 +66,27 @@ USER NAME SPACE" below. */ · 21 unmodified lines
66	66
67	67
68	68	/*----------------------------------------------------------------------------
69		−ChucK Concurrent, On-the-fly Audio Programming Language
70		−Compiler and Virtual Machine
71		−
72		−Copyright (c) 2004 Ge Wang and Perry R. Cook. All rights reserved.
73		−http://chuck.cs.princeton.edu/
74		−http://soundlab.cs.princeton.edu/
75		−
76		−This program is free software; you can redistribute it and/or modify
77		−it under the terms of the GNU General Public License as published by
78		−the Free Software Foundation; either version 2 of the License, or
79		−(at your option) any later version.
80		−
81		−This program is distributed in the hope that it will be useful,
82		−but WITHOUT ANY WARRANTY; without even the implied warranty of
83		−MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
84		−GNU General Public License for more details.
85		−
86		−You should have received a copy of the GNU General Public License
87		−along with this program; if not, write to the Free Software
88		−Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
89		−U.S.A.
	69	+ ChucK Concurrent, On-the-fly Audio Programming Language
	70	+ Compiler and Virtual Machine
	71	+
	72	+ Copyright (c) 2004 Ge Wang and Perry R. Cook. All rights reserved.
	73	+ http://chuck.cs.princeton.edu/
	74	+ http://soundlab.cs.princeton.edu/
	75	+
	76	+ This program is free software; you can redistribute it and/or modify
	77	+ it under the terms of the GNU General Public License as published by
	78	+ the Free Software Foundation; either version 2 of the License, or
	79	+ (at your option) any later version.
	80	+
	81	+ This program is distributed in the hope that it will be useful,
	82	+ but WITHOUT ANY WARRANTY; without even the implied warranty of
	83	+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	84	+ GNU General Public License for more details.
	85	+
	86	+ You should have received a copy of the GNU General Public License
	87	+ along with this program; if not, write to the Free Software
	88	+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
	89	+ U.S.A.
90	90	-----------------------------------------------------------------------------*/
91	91
92	92	//-----------------------------------------------------------------------------
@@ -137,7 +137,7 @@ a_Program g_program = NULL; · 44 unmodified lines
137	137	#endif
138	138
139	139	/* In a future release of Bison, this section will be replaced
140		−by #include "chuck.tab.h". */
	140	+ by #include "chuck.tab.h". */
141	141	#ifndef YY_YY_CHUCK_TAB_H_INCLUDED
142	142	# define YY_YY_CHUCK_TAB_H_INCLUDED
143	143	/* Debug traces. */
@@ -151,8 +151,8 @@ extern int yydebug; · 7 unmodified lines
151	151	/* Token type. */
152	152	#ifndef YYTOKENTYPE
153	153	# define YYTOKENTYPE
154		−enum yytokentype
155		−{
	154	+ enum yytokentype
	155	+ {
156	156	ID = 258,
157	157	STRING_LIT = 259,
158	158	CHAR_LIT = 260,
@@ -216,52 +216,53 @@ enum yytokentype · 57 unmodified lines
216	216	NEXT = 318,
217	217	UNTIL = 319,
218	218	EXTERNAL = 320,
219		− EVERY = 321,
220		− BEFORE = 322,
221		− AFTER = 323,
222		− AT = 324,
223		− AT_SYM = 325,
224		− ATAT_SYM = 326,
225		− NEW = 327,
226		− SIZEOF = 328,
227		− TYPEOF = 329,
228		− SAME = 330,
229		− PLUS_CHUCK = 331,
230		− MINUS_CHUCK = 332,
231		− TIMES_CHUCK = 333,
232		− DIVIDE_CHUCK = 334,
233		− S_AND_CHUCK = 335,
234		− S_OR_CHUCK = 336,
235		− S_XOR_CHUCK = 337,
236		− SHIFT_RIGHT_CHUCK = 338,
237		− SHIFT_LEFT_CHUCK = 339,
238		− PERCENT_CHUCK = 340,
239		− SHIFT_RIGHT = 341,
240		− SHIFT_LEFT = 342,
241		− TILDA = 343,
242		− CHUCK = 344,
243		− COLONCOLON = 345,
244		− S_CHUCK = 346,
245		− AT_CHUCK = 347,
246		− LEFT_S_CHUCK = 348,
247		− UNCHUCK = 349,
248		− UPCHUCK = 350,
249		− CLASS = 351,
250		− INTERFACE = 352,
251		− EXTENDS = 353,
252		− IMPLEMENTS = 354,
253		− PUBLIC = 355,
254		− PROTECTED = 356,
255		− PRIVATE = 357,
256		− STATIC = 358,
257		− ABSTRACT = 359,
258		− CONST = 360,
259		− SPORK = 361,
260		− ARROW_RIGHT = 362,
261		− ARROW_LEFT = 363,
262		− L_HACK = 364,
263		− R_HACK = 365
264		−};
	219	+ GLOBAL = 321,
	220	+ EVERY = 322,
	221	+ BEFORE = 323,
	222	+ AFTER = 324,
	223	+ AT = 325,
	224	+ AT_SYM = 326,
	225	+ ATAT_SYM = 327,
	226	+ NEW = 328,
	227	+ SIZEOF = 329,
	228	+ TYPEOF = 330,
	229	+ SAME = 331,
	230	+ PLUS_CHUCK = 332,
	231	+ MINUS_CHUCK = 333,
	232	+ TIMES_CHUCK = 334,
	233	+ DIVIDE_CHUCK = 335,
	234	+ S_AND_CHUCK = 336,
	235	+ S_OR_CHUCK = 337,
	236	+ S_XOR_CHUCK = 338,
	237	+ SHIFT_RIGHT_CHUCK = 339,
	238	+ SHIFT_LEFT_CHUCK = 340,
	239	+ PERCENT_CHUCK = 341,
	240	+ SHIFT_RIGHT = 342,
	241	+ SHIFT_LEFT = 343,
	242	+ TILDA = 344,
	243	+ CHUCK = 345,
	244	+ COLONCOLON = 346,
	245	+ S_CHUCK = 347,
	246	+ AT_CHUCK = 348,
	247	+ LEFT_S_CHUCK = 349,
	248	+ UNCHUCK = 350,
	249	+ UPCHUCK = 351,
	250	+ CLASS = 352,
	251	+ INTERFACE = 353,
	252	+ EXTENDS = 354,
	253	+ IMPLEMENTS = 355,
	254	+ PUBLIC = 356,
	255	+ PROTECTED = 357,
	256	+ PRIVATE = 358,
	257	+ STATIC = 359,
	258	+ ABSTRACT = 360,
	259	+ CONST = 361,
	260	+ SPORK = 362,
	261	+ ARROW_RIGHT = 363,
	262	+ ARROW_LEFT = 364,
	263	+ L_HACK = 365,
	264	+ R_HACK = 366
	265	+ };
265	266	#endif
266	267
267	268	/* Value type. */
@@ -275,7 +276,7 @@ union YYSTYPE · 7 unmodified lines
275	276	int ival;
276	277	double fval;
277	278	c_str sval;
278		−
	279	+
279	280	a_Program program;
280	281	a_Section program_section;
281	282	a_Stmt_List stmt_list;
@@ -295,7 +296,7 @@ union YYSTYPE · 13 unmodified lines
295	296	a_Polar polar_exp;
296	297	a_Vec vec_exp; // ge: added 1.3.5.3
297	298
298		−#line 299 "chuck.tab.c" /* yacc.c:355 */
	299	+#line 300 "chuck.tab.c" /* yacc.c:355 */
299	300	};
300	301
301	302	typedef union YYSTYPE YYSTYPE;
@@ -312,7 +313,7 @@ int yyparse (void); · 10 unmodified lines
312	313
313	314	/* Copy the second part of user declarations. */
314	315
315		−#line 316 "chuck.tab.c" /* yacc.c:358 */
	316	+#line 317 "chuck.tab.c" /* yacc.c:358 */
316	317
317	318	#ifdef short
318	319	# undef short
@@ -442,7 +443,7 @@ typedef short int yytype_int16; · 123 unmodified lines
442	443	# define YYSTACK_ALLOC alloca
443	444	# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
444	445	# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
445		−/* Use EXIT_SUCCESS as a witness for stdlib.h. */
	446	+ /* Use EXIT_SUCCESS as a witness for stdlib.h. */
446	447	# ifndef EXIT_SUCCESS
447	448	# define EXIT_SUCCESS 0
448	449	# endif
@@ -452,13 +453,13 @@ typedef short int yytype_int16; · 3 unmodified lines
452	453	# endif
453	454
454	455	# ifdef YYSTACK_ALLOC
455		−/* Pacify GCC's 'empty if-body' warning. */
	456	+ /* Pacify GCC's 'empty if-body' warning. */
456	457	# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
457	458	# ifndef YYSTACK_ALLOC_MAXIMUM
458		−/* The OS might guarantee only one guard page at the bottom of the stack,
459		−and a page size can be as small as 4096 bytes. So we cannot safely
460		−invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
461		−to allow for a few compiler-allocated temporary stack slots. */
	459	+ /* The OS might guarantee only one guard page at the bottom of the stack,
	460	+ and a page size can be as small as 4096 bytes. So we cannot safely
	461	+ invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
	462	+ to allow for a few compiler-allocated temporary stack slots. */
462	463	# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
463	464	# endif
464	465	# else
@@ -495,18 +496,18 @@ void free (void ); / INFRINGES ON USER NAME SPACE */ · 30 unmodified lines
495	496	&& (! defined __cplusplus \
496	497	\|\| (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
497	498
498		− /* A type that is properly aligned for any stack member. */
	499	+/* A type that is properly aligned for any stack member. */
499	500	union yyalloc
500	501	{
501		− yytype_int16 yyss_alloc;
502		− YYSTYPE yyvs_alloc;
	502	+ yytype_int16 yyss_alloc;
	503	+ YYSTYPE yyvs_alloc;
503	504	};
504	505
505	506	/* The size of the maximum gap between one aligned stack and the next. */
506	507	# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
507	508
508	509	/* The size of an array large to enough to hold all stacks, each with
509		−N elements. */
	510	+ N elements. */
510	511	# define YYSTACK_BYTES(N) \
511	512	((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
512	513	+ YYSTACK_GAP_MAXIMUM)
@@ -514,10 +515,10 @@ N elements. */ · 1 unmodified line
514	515	# define YYCOPY_NEEDED 1
515	516
516	517	/* Relocate STACK from its old location to the new one. The
517		−local variables YYSIZE and YYSTACKSIZE give the old and new number of
518		−elements in the stack, and YYPTR gives the new location of the
519		−stack. Advance YYPTR to a properly aligned location for the next
520		−stack. */
	518	+ local variables YYSIZE and YYSTACKSIZE give the old and new number of
	519	+ elements in the stack, and YYPTR gives the new location of the
	520	+ stack. Advance YYPTR to a properly aligned location for the next
	521	+ stack. */
521	522	# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
522	523	do \
523	524	{ \
@@ -533,7 +534,7 @@ stack. */ · 9 unmodified lines
533	534
534	535	#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
535	536	/* Copy COUNT objects from SRC to DST. The source and destination do
536		−not overlap. */
	537	+ not overlap. */
537	538	# ifndef YYCOPY
538	539	# if defined __GNUC__ && 1 < __GNUC__
539	540	# define YYCOPY(Dst, Src, Count) \
@@ -552,603 +553,599 @@ not overlap. */ · 12 unmodified lines
552	553	#endif /* !YYCOPY_NEEDED */
553	554
554	555	/* YYFINAL -- State number of the termination state. */
555		−#define YYFINAL 120
	556	+#define YYFINAL 122
556	557	/* YYLAST -- Last index in YYTABLE. */
557		−#define YYLAST 1202
	558	+#define YYLAST 1181
558	559
559	560	/* YYNTOKENS -- Number of terminals. */
560		−#define YYNTOKENS 111
	561	+#define YYNTOKENS 112
561	562	/* YYNNTS -- Number of nonterminals. */
562	563	#define YYNNTS 58
563	564	/* YYNRULES -- Number of rules. */
564		−#define YYNRULES 183
	565	+#define YYNRULES 184
565	566	/* YYNSTATES -- Number of states. */
566		−#define YYNSTATES 316
	567	+#define YYNSTATES 319
567	568
568	569	/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
569		−by yylex, with out-of-bounds checking. */
	570	+ by yylex, with out-of-bounds checking. */
570	571	#define YYUNDEFTOK 2
571		−#define YYMAXUTOK 365
	572	+#define YYMAXUTOK 366
572	573
573	574	#define YYTRANSLATE(YYX) \
574	575	((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
575	576
576	577	/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
577		−as returned by yylex, without out-of-bounds checking. */
	578	+ as returned by yylex, without out-of-bounds checking. */
578	579	static const yytype_uint8 yytranslate[] =
579	580	{
580		− 0, 2, 2, 2, 2, 2, 2, 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, 2, 2, 2, 2,
594		− 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
595		− 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
596		− 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
597		− 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
598		− 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
599		− 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
600		− 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
601		− 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
602		− 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
603		− 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
604		− 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
605		− 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
606		− 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
607		− 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
608		− 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
609		− 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
610		− 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
611		− 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
612		− 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
613		− 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
614		− 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
615		− 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
616		− 105, 106, 107, 108, 109, 110
	581	+ 0, 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, 2, 2, 2, 2,
	594	+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
	595	+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
	596	+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
	597	+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
	598	+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
	599	+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
	600	+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
	601	+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
	602	+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
	603	+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
	604	+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
	605	+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
	606	+ 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
	607	+ 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
	608	+ 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
	609	+ 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
	610	+ 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
	611	+ 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
	612	+ 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
	613	+ 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
	614	+ 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
	615	+ 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
	616	+ 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
	617	+ 105, 106, 107, 108, 109, 110, 111
617	618	};
618	619
619	620	#if YYDEBUG
620		−/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
	621	+ /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
621	622	static const yytype_uint16 yyrline[] =
622	623	{
623		− 0, 182, 182, 183, 187, 188, 189, 193, 195, 197,
624		− 199, 204, 205, 206, 207, 211, 212, 216, 217, 222,
625		− 223, 224, 228, 232, 233, 237, 238, 242, 244, 246,
626		− 248, 253, 254, 255, 259, 260, 261, 262, 266, 267,
627		− 268, 272, 273, 277, 278, 287, 288, 293, 294, 298,
628		− 299, 303, 304, 308, 309, 310, 311, 313, 317, 318,
629		− 319, 320, 324, 326, 331, 333, 335, 337, 339, 341,
630		− 343, 348, 349, 353, 354, 358, 359, 363, 364, 369,
631		− 370, 375, 376, 381, 382, 386, 387, 388, 389, 390,
632		− 391, 395, 396, 400, 401, 402, 406, 411, 416, 421,
633		− 422, 423, 424, 425, 426, 427, 428, 429, 430, 431,
634		− 432, 433, 434, 438, 439, 443, 444, 449, 450, 455,
635		− 456, 461, 462, 467, 468, 473, 474, 479, 480, 482,
636		− 487, 488, 490, 492, 494, 499, 500, 502, 507, 508,
637		− 510, 515, 516, 518, 520, 525, 526, 531, 532, 537,
638		− 538, 540, 542, 544, 546, 548, 550, 557, 558, 559,
639		− 560, 561, 562, 567, 568, 573, 574, 576, 578, 580,
640		− 582, 584, 590, 591, 592, 593, 594, 595, 596, 597,
641		− 598, 599, 600, 601
	624	+ 0, 183, 183, 184, 188, 189, 190, 194, 196, 198,
	625	+ 200, 205, 206, 207, 208, 212, 213, 217, 218, 223,
	626	+ 224, 225, 229, 233, 234, 238, 239, 243, 245, 247,
	627	+ 249, 254, 255, 256, 260, 261, 262, 263, 267, 268,
	628	+ 269, 273, 274, 278, 279, 288, 289, 294, 295, 299,
	629	+ 300, 304, 305, 309, 310, 311, 312, 314, 318, 319,
	630	+ 320, 321, 325, 327, 332, 334, 336, 338, 340, 342,
	631	+ 344, 349, 350, 354, 355, 359, 360, 364, 365, 370,
	632	+ 371, 376, 377, 382, 383, 387, 388, 389, 390, 391,
	633	+ 392, 393, 397, 398, 402, 403, 404, 408, 413, 418,
	634	+ 423, 424, 425, 426, 427, 428, 429, 430, 431, 432,
	635	+ 433, 434, 435, 436, 440, 441, 445, 446, 451, 452,
	636	+ 457, 458, 463, 464, 469, 470, 475, 476, 481, 482,
	637	+ 484, 489, 490, 492, 494, 496, 501, 502, 504, 509,
	638	+ 510, 512, 517, 518, 520, 522, 527, 528, 533, 534,
	639	+ 539, 540, 542, 544, 546, 548, 550, 552, 559, 560,
	640	+ 561, 562, 563, 564, 569, 570, 575, 576, 578, 580,
	641	+ 582, 584, 586, 592, 593, 594, 595, 596, 597, 598,
	642	+ 599, 600, 601, 602, 603
642	643	};
643	644	#endif
644	645
645	646	#if YYDEBUG \|\| YYERROR_VERBOSE \|\| 0
646	647	/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
647		−First, the terminals, then, starting at YYNTOKENS, nonterminals. */
	648	+ First, the terminals, then, starting at YYNTOKENS, nonterminals. */
648	649	static const char *const yytname[] =
649	650	{
650		− "$end", "error", "$undefined", "ID", "STRING_LIT", "CHAR_LIT", "NUM",
651		− "FLOAT", "POUND", "COMMA", "COLON", "SEMICOLON", "LPAREN", "RPAREN",
652		− "LBRACK", "RBRACK", "LBRACE", "RBRACE", "DOT", "PLUS", "MINUS", "TIMES",
653		− "DIVIDE", "PERCENT", "EQ", "NEQ", "LT", "LE", "GT", "GE", "AND", "OR",
654		− "ASSIGN", "IF", "THEN", "ELSE", "WHILE", "FOR", "DO", "LOOP", "BREAK",
655		− "CONTINUE", "NULL_TOK", "FUNCTION", "RETURN", "QUESTION", "EXCLAMATION",
656		− "S_OR", "S_AND", "S_XOR", "PLUSPLUS", "MINUSMINUS", "DOLLAR",
657		− "POUNDPAREN", "PERCENTPAREN", "ATPAREN", "SIMULT", "PATTERN", "CODE",
658		− "TRANSPORT", "HOST", "TIME", "WHENEVER", "NEXT", "UNTIL", "EXTERNAL",
659		− "EVERY", "BEFORE", "AFTER", "AT", "AT_SYM", "ATAT_SYM", "NEW", "SIZEOF",
660		− "TYPEOF", "SAME", "PLUS_CHUCK", "MINUS_CHUCK", "TIMES_CHUCK",
661		− "DIVIDE_CHUCK", "S_AND_CHUCK", "S_OR_CHUCK", "S_XOR_CHUCK",
662		− "SHIFT_RIGHT_CHUCK", "SHIFT_LEFT_CHUCK", "PERCENT_CHUCK", "SHIFT_RIGHT",
663		− "SHIFT_LEFT", "TILDA", "CHUCK", "COLONCOLON", "S_CHUCK", "AT_CHUCK",
664		− "LEFT_S_CHUCK", "UNCHUCK", "UPCHUCK", "CLASS", "INTERFACE", "EXTENDS",
665		− "IMPLEMENTS", "PUBLIC", "PROTECTED", "PRIVATE", "STATIC", "ABSTRACT",
666		− "CONST", "SPORK", "ARROW_RIGHT", "ARROW_LEFT", "L_HACK", "R_HACK",
667		− "$accept", "program", "program_section", "class_definition", "class_ext",
668		− "class_body", "class_body2", "class_section", "iface_ext", "id_list",
669		− "id_dot", "function_definition", "class_decl", "function_decl",
670		− "static_decl", "type_decl_a", "type_decl_b", "type_decl", "type_decl2",
671		− "arg_list", "statement_list", "statement", "jump_statement",
672		− "selection_statement", "loop_statement", "code_segment",
673		− "expression_statement", "expression", "chuck_expression",
674		− "arrow_expression", "array_exp", "array_empty", "decl_expression",
675		− "var_decl_list", "var_decl", "complex_exp", "polar_exp", "vec_exp",
676		− "chuck_operator", "arrow_operator", "conditional_expression",
677		− "logical_or_expression", "logical_and_expression",
678		− "inclusive_or_expression", "exclusive_or_expression", "and_expression",
679		− "equality_expression", "relational_expression", "shift_expression",
680		− "additive_expression", "multiplicative_expression", "tilda_expression",
681		− "cast_expression", "unary_expression", "unary_operator",
682		− "dur_expression", "postfix_expression", "primary_expression", YY_NULLPTR
	651	+ "$end", "error", "$undefined", "ID", "STRING_LIT", "CHAR_LIT", "NUM",
	652	+ "FLOAT", "POUND", "COMMA", "COLON", "SEMICOLON", "LPAREN", "RPAREN",
	653	+ "LBRACK", "RBRACK", "LBRACE", "RBRACE", "DOT", "PLUS", "MINUS", "TIMES",
	654	+ "DIVIDE", "PERCENT", "EQ", "NEQ", "LT", "LE", "GT", "GE", "AND", "OR",
	655	+ "ASSIGN", "IF", "THEN", "ELSE", "WHILE", "FOR", "DO", "LOOP", "BREAK",
	656	+ "CONTINUE", "NULL_TOK", "FUNCTION", "RETURN", "QUESTION", "EXCLAMATION",
	657	+ "S_OR", "S_AND", "S_XOR", "PLUSPLUS", "MINUSMINUS", "DOLLAR",
	658	+ "POUNDPAREN", "PERCENTPAREN", "ATPAREN", "SIMULT", "PATTERN", "CODE",
	659	+ "TRANSPORT", "HOST", "TIME", "WHENEVER", "NEXT", "UNTIL", "EXTERNAL",
	660	+ "GLOBAL", "EVERY", "BEFORE", "AFTER", "AT", "AT_SYM", "ATAT_SYM", "NEW",
	661	+ "SIZEOF", "TYPEOF", "SAME", "PLUS_CHUCK", "MINUS_CHUCK", "TIMES_CHUCK",
	662	+ "DIVIDE_CHUCK", "S_AND_CHUCK", "S_OR_CHUCK", "S_XOR_CHUCK",
	663	+ "SHIFT_RIGHT_CHUCK", "SHIFT_LEFT_CHUCK", "PERCENT_CHUCK", "SHIFT_RIGHT",
	664	+ "SHIFT_LEFT", "TILDA", "CHUCK", "COLONCOLON", "S_CHUCK", "AT_CHUCK",
	665	+ "LEFT_S_CHUCK", "UNCHUCK", "UPCHUCK", "CLASS", "INTERFACE", "EXTENDS",
	666	+ "IMPLEMENTS", "PUBLIC", "PROTECTED", "PRIVATE", "STATIC", "ABSTRACT",
	667	+ "CONST", "SPORK", "ARROW_RIGHT", "ARROW_LEFT", "L_HACK", "R_HACK",
	668	+ "$accept", "program", "program_section", "class_definition", "class_ext",
	669	+ "class_body", "class_body2", "class_section", "iface_ext", "id_list",
	670	+ "id_dot", "function_definition", "class_decl", "function_decl",
	671	+ "static_decl", "type_decl_a", "type_decl_b", "type_decl", "type_decl2",
	672	+ "arg_list", "statement_list", "statement", "jump_statement",
	673	+ "selection_statement", "loop_statement", "code_segment",
	674	+ "expression_statement", "expression", "chuck_expression",
	675	+ "arrow_expression", "array_exp", "array_empty", "decl_expression",
	676	+ "var_decl_list", "var_decl", "complex_exp", "polar_exp", "vec_exp",
	677	+ "chuck_operator", "arrow_operator", "conditional_expression",
	678	+ "logical_or_expression", "logical_and_expression",
	679	+ "inclusive_or_expression", "exclusive_or_expression", "and_expression",
	680	+ "equality_expression", "relational_expression", "shift_expression",
	681	+ "additive_expression", "multiplicative_expression", "tilda_expression",
	682	+ "cast_expression", "unary_expression", "unary_operator",
	683	+ "dur_expression", "postfix_expression", "primary_expression", YY_NULLPTR
683	684	};
684	685	#endif
685	686
686	687	# ifdef YYPRINT
687	688	/* YYTOKNUM[NUM] -- (External) token number corresponding to the
688		−(internal) symbol number NUM (which must be that of a token). */
	689	+ (internal) symbol number NUM (which must be that of a token). */
689	690	static const yytype_uint16 yytoknum[] =
690	691	{
691		− 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
692		− 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
693		− 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
694		− 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
695		− 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
696		− 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
697		− 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
698		− 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
699		− 335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
700		− 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
701		− 355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
702		− 365
	692	+ 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
	693	+ 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
	694	+ 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
	695	+ 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
	696	+ 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
	697	+ 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
	698	+ 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
	699	+ 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
	700	+ 335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
	701	+ 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
	702	+ 355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
	703	+ 365, 366
703	704	};
704	705	# endif
705	706
706		−#define YYPACT_NINF -265
	707	+#define YYPACT_NINF -246
707	708
708	709	#define yypact_value_is_default(Yystate) \
709		− (!!((Yystate) == (-265)))
	710	+ (!!((Yystate) == (-246)))
710	711
711	712	#define YYTABLE_NINF -42
712	713
713	714	#define yytable_value_is_error(Yytable_value) \
714	715	0
715	716
716		−/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
717		−STATE-NUM. */
	717	+ /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
	718	+ STATE-NUM. */
718	719	static const yytype_int16 yypact[] =
719	720	{
720		− 474, 14, -265, -265, -265, -265, -265, 691, 1093, 552,
721		− -265, -265, -265, 43, 70, 73, 113, 627, 146, 96,
722		− 148, -265, 764, -265, 7, 7, 1093, 1093, 1093, 149,
723		− 26, 26, 7, 7, 157, -265, -42, -265, -3, 22,
724		− 74, 1093, 163, 240, -265, -265, 35, 11, -265, -265,
725		− 157, -265, 627, -265, -265, -265, -265, -265, 153, 100,
726		− -7, -265, -265, -265, -265, -265, -265, 18, 135, 119,
727		− 120, 122, 86, 95, 48, 118, 106, 79, 123, -265,
728		− 7, 81, 94, -265, -265, -265, 159, 171, -265, 170,
729		− 172, 160, 1093, 1093, 837, 2, 1093, -265, -265, -265,
730		− 182, -265, -265, -265, 183, 184, 185, 1093, 129, 157,
731		− 186, -265, -265, 187, -265, 193, 157, 157, -265, 93,
732		− -265, -265, 201, 201, -265, -265, 26, -265, -265, -265,
733		− 1093, -265, -265, -265, -265, -265, -265, -265, -265, -265,
734		− -265, -265, -265, -265, -265, 1093, -265, -265, 1093, 7,
735		− 1093, 7, 7, 7, 7, 7, 7, 7, 7, 7,
736		− 7, 7, 7, 7, 7, 7, 7, 7, 7, 26,
737		− -265, 64, 901, 202, -265, -265, -265, -265, 186, -265,
738		− 43, 136, 194, 195, 837, 197, 198, 199, -265, -265,
739		− -265, -265, 200, -265, -265, 965, -265, 203, 157, -265,
740		− -265, -265, 205, 0, 4, 204, 208, -265, -7, -265,
741		− 135, 206, 119, 120, 122, 86, 95, 95, 48, 48,
742		− 48, 48, 118, 118, 106, 106, 79, 79, 79, 123,
743		− -265, 94, -265, 207, -265, -265, -265, -265, 627, 627,
744		− 1029, 1093, 1093, 627, 627, -265, 210, -265, 201, 318,
745		− 43, 201, 211, 318, 201, 214, 216, 203, 209, 7,
746		− -265, 180, -265, 627, 213, 219, 220, -265, -265, -265,
747		− -265, -265, 217, -265, 396, -265, -265, 140, 121, 318,
748		− 218, -265, 318, 38, -265, 627, -265, 627, 230, 231,
749		− -265, -265, 201, 43, 232, -265, 233, 34, 157, 242,
750		− -265, -265, -265, -265, -265, -265, -265, -265, -265, -265,
751		− 248, 75, 26, -265, -265, -265
	721	+ 419, 15, -246, -246, -246, -246, -246, 639, 1047, 498,
	722	+ -246, -246, -246, 43, 36, 90, 132, 574, 133, 135,
	723	+ 137, -246, 713, -246, 8, 8, 1047, 1047, 1047, 143,
	724	+ 27, 27, 27, 8, 8, 153, -246, -33, -246, -13,
	725	+ 23, 73, 1047, 164, 147, -246, -246, -2, 9, -246,
	726	+ -246, 153, -246, 574, -246, -246, -246, -246, -246, 154,
	727	+ 1060, 19, -246, -246, -246, -246, -246, -246, 6, 139,
	728	+ 123, 125, 124, 106, 83, 29, 114, 50, 86, 126,
	729	+ -246, 8, 88, 38, -246, -246, -246, 168, 162, -246,
	730	+ 165, 171, 166, 1047, 1047, 787, 4, 1047, -246, -246,
	731	+ -246, 181, -246, -246, -246, 183, 186, 190, 1047, 134,
	732	+ 153, 153, 192, -246, -246, 193, -246, 195, 153, 153,
	733	+ -246, 97, -246, -246, 206, 206, -246, -246, 27, -246,
	734	+ -246, -246, 1047, -246, -246, -246, -246, -246, -246, -246,
	735	+ -246, -246, -246, -246, -246, -246, -246, 1047, -246, -246,
	736	+ 1047, 8, 1047, 8, 8, 8, 8, 8, 8, 8,
	737	+ 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
	738	+ 8, 27, -246, 1071, 852, 207, -246, -246, -246, -246,
	739	+ 192, -246, 43, 144, 201, 203, 787, 205, 212, 213,
	740	+ -246, -246, -246, -246, 216, -246, -246, -246, 917, -246,
	741	+ 204, 153, -246, -246, -246, 210, 1, 5, 211, 227,
	742	+ -246, 19, -246, 139, 221, 123, 125, 124, 106, 83,
	743	+ 83, 29, 29, 29, 29, 114, 114, 50, 50, 86,
	744	+ 86, 86, 126, -246, 38, -246, 222, -246, -246, -246,
	745	+ -246, 574, 574, 982, 1047, 1047, 574, 574, -246, 219,
	746	+ -246, 206, 261, 43, 206, 223, 261, 206, 228, 230,
	747	+ 204, 225, 8, -246, 208, -246, 574, 233, 234, 240,
	748	+ -246, -246, -246, -246, -246, 238, -246, 340, -246, -246,
	749	+ 138, 159, 261, 242, -246, 261, 67, -246, 574, -246,
	750	+ 574, 249, 250, -246, -246, 206, 43, 245, -246, 246,
	751	+ 31, 153, 256, -246, -246, -246, -246, -246, -246, -246,
	752	+ -246, -246, -246, 262, 92, 27, -246, -246, -246
752	753	};
753	754
754		−/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
755		−Performed when YYTABLE does not specify something else to do. Zero
756		−means the default is an error. */
	755	+ /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
	756	+ Performed when YYTABLE does not specify something else to do. Zero
	757	+ means the default is an error. */
757	758	static const yytype_uint8 yydefact[] =
758	759	{
759		− 33, 172, 175, 176, 173, 174, 73, 0, 0, 0,
760		− 157, 158, 161, 0, 0, 0, 0, 0, 0, 0,
761		− 0, 34, 0, 160, 0, 0, 0, 0, 0, 0,
762		− 0, 0, 0, 0, 0, 159, 35, 36, 37, 0,
763		− 0, 0, 0, 33, 6, 5, 0, 40, 45, 46,
764		− 0, 4, 51, 56, 55, 54, 57, 53, 0, 75,
765		− 77, 177, 79, 178, 179, 180, 85, 115, 117, 119,
766		− 121, 123, 125, 127, 130, 135, 138, 141, 145, 147,
767		− 0, 149, 163, 165, 42, 183, 0, 0, 71, 0,
768		− 25, 0, 0, 0, 0, 0, 0, 60, 61, 58,
769		− 0, 172, 150, 151, 0, 0, 0, 0, 41, 0,
770		− 155, 154, 153, 93, 89, 91, 0, 0, 162, 0,
771		− 1, 3, 0, 0, 38, 39, 0, 86, 52, 74,
772		− 0, 101, 102, 103, 104, 110, 111, 112, 105, 106,
773		− 107, 99, 100, 108, 109, 0, 114, 113, 0, 0,
774		− 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
775		− 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
776		− 152, 0, 0, 0, 170, 171, 166, 182, 81, 72,
777		− 0, 43, 0, 0, 0, 0, 0, 0, 59, 96,
778		− 97, 98, 0, 87, 156, 0, 94, 95, 0, 90,
779		− 88, 181, 23, 0, 0, 47, 0, 76, 78, 80,
780		− 118, 0, 120, 122, 124, 126, 128, 129, 131, 133,
781		− 132, 134, 137, 136, 139, 140, 142, 143, 144, 146,
782		− 148, 164, 167, 0, 169, 82, 26, 44, 0, 0,
783		− 0, 0, 0, 0, 0, 83, 0, 92, 0, 33,
784		− 0, 0, 0, 33, 0, 0, 0, 48, 0, 0,
785		− 168, 62, 64, 0, 0, 0, 0, 70, 68, 84,
786		− 24, 21, 0, 15, 33, 20, 19, 13, 11, 33,
787		− 0, 22, 33, 0, 116, 0, 66, 0, 0, 0,
788		− 7, 18, 0, 0, 0, 9, 0, 0, 0, 0,
789		− 63, 67, 65, 69, 14, 12, 8, 10, 30, 28,
790		− 49, 0, 0, 29, 27, 50
	760	+ 33, 173, 176, 177, 174, 175, 73, 0, 0, 0,
	761	+ 158, 159, 162, 0, 0, 0, 0, 0, 0, 0,
	762	+ 0, 34, 0, 161, 0, 0, 0, 0, 0, 0,
	763	+ 0, 0, 0, 0, 0, 0, 160, 35, 36, 37,
	764	+ 0, 0, 0, 0, 33, 6, 5, 0, 40, 45,
	765	+ 46, 0, 4, 51, 56, 55, 54, 57, 53, 0,
	766	+ 75, 77, 178, 79, 179, 180, 181, 85, 116, 118,
	767	+ 120, 122, 124, 126, 128, 131, 136, 139, 142, 146,
	768	+ 148, 0, 150, 164, 166, 42, 184, 0, 0, 71,
	769	+ 0, 25, 0, 0, 0, 0, 0, 0, 60, 61,
	770	+ 58, 0, 173, 151, 152, 0, 0, 0, 0, 41,
	771	+ 0, 0, 156, 155, 154, 94, 90, 92, 0, 0,
	772	+ 163, 0, 1, 3, 0, 0, 38, 39, 0, 86,
	773	+ 52, 74, 0, 102, 103, 104, 105, 111, 112, 113,
	774	+ 106, 107, 108, 100, 101, 109, 110, 0, 115, 114,
	775	+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	776	+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	777	+ 0, 0, 153, 0, 0, 0, 171, 172, 167, 183,
	778	+ 81, 72, 0, 43, 0, 0, 0, 0, 0, 0,
	779	+ 59, 97, 98, 99, 0, 87, 88, 157, 0, 95,
	780	+ 96, 0, 91, 89, 182, 23, 0, 0, 47, 0,
	781	+ 76, 78, 80, 119, 0, 121, 123, 125, 127, 129,
	782	+ 130, 132, 134, 133, 135, 138, 137, 140, 141, 143,
	783	+ 144, 145, 147, 149, 165, 168, 0, 170, 82, 26,
	784	+ 44, 0, 0, 0, 0, 0, 0, 0, 83, 0,
	785	+ 93, 0, 33, 0, 0, 0, 33, 0, 0, 0,
	786	+ 48, 0, 0, 169, 62, 64, 0, 0, 0, 0,
	787	+ 70, 68, 84, 24, 21, 0, 15, 33, 20, 19,
	788	+ 13, 11, 33, 0, 22, 33, 0, 117, 0, 66,
	789	+ 0, 0, 0, 7, 18, 0, 0, 0, 9, 0,
	790	+ 0, 0, 0, 63, 67, 65, 69, 14, 12, 8,
	791	+ 10, 30, 28, 49, 0, 0, 29, 27, 50
791	792	};
792	793
793		−/* YYPGOTO[NTERM-NUM]. */
	794	+ /* YYPGOTO[NTERM-NUM]. */
794	795	static const yytype_int16 yypgoto[] =
795	796	{
796		− -265, 179, -265, 32, -265, -223, -16, -265, -265, -118,
797		− -173, 44, -265, -265, -265, -265, -265, -30, -265, -50,
798		− 31, -15, -265, -265, -265, -264, -79, -4, -265, 124,
799		− -74, 58, 116, -44, -33, -265, -265, -265, -265, -265,
800		− 8, -265, 125, 117, 133, 134, 138, -5, -17, -9,
801		− -8, -18, 103, 10, -265, -265, 104, -265
	797	+ -246, 226, -246, 32, -246, -225, 2, -246, -246, -119,
	798	+ -174, 33, -246, -246, -246, -246, -246, -30, -246, -32,
	799	+ 34, -14, -246, -246, -246, -245, -79, -3, -246, 141,
	800	+ -74, 76, 136, -44, -12, -246, -246, -246, -246, -246,
	801	+ 28, -246, 140, 142, 149, 151, 152, -21, -36, -24,
	802	+ -23, -48, 122, 11, -246, -246, 120, -246
802	803	};
803	804
804		−/* YYDEFGOTO[NTERM-NUM]. */
	805	+ /* YYDEFGOTO[NTERM-NUM]. */
805	806	static const yytype_int16 yydefgoto[] =
806	807	{
807		− -1, 42, 43, 271, 252, 272, 273, 274, 255, 203,
808		− 91, 275, 46, 47, 126, 48, 49, 50, 206, 299,
809		− 276, 52, 53, 54, 55, 56, 57, 58, 59, 60,
810		− 61, 197, 62, 114, 115, 63, 64, 65, 145, 148,
811		− 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
812		− 76, 77, 78, 79, 80, 81, 82, 83
	808	+ -1, 43, 44, 274, 255, 275, 276, 277, 258, 206,
	809	+ 92, 278, 47, 48, 128, 49, 50, 51, 209, 302,
	810	+ 279, 53, 54, 55, 56, 57, 58, 59, 60, 61,
	811	+ 62, 200, 63, 116, 117, 64, 65, 66, 147, 150,
	812	+ 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
	813	+ 77, 78, 79, 80, 81, 82, 83, 84
813	814	};
814	815
815		−/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
816		−positive, shift that token. If negative, reduce the rule whose
817		−number is the opposite. If YYTABLE_NINF, syntax error. */
	816	+ /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
	817	+ positive, shift that token. If negative, reduce the rule whose
	818	+ number is the opposite. If YYTABLE_NINF, syntax error. */
818	819	static const yytype_int16 yytable[] =
819	820	{
820		− 109, 110, 95, 86, 87, 204, 127, 236, 176, 117,
821		− 101, 2, 3, 4, 5, 184, 249, -41, 100, 7,
822		− 253, 8, 104, 105, 106, 108, 10, 11, 12, 108,
823		− 280, 51, 44, 309, 102, 103, 194, 119, 185, 196,
824		− 89, 108, 111, 112, 45, 308, 90, 314, 13, 149,
825		− 9, 297, 13, 23, -31, -31, 294, 24, 25, 296,
826		− 26, 27, 28, 150, 13, 193, 186, 101, 2, 3,
827		− 4, 5, 199, 200, 51, 44, 7, 277, 8, 31,
828		− 32, 33, 92, 128, 84, 93, 313, 45, 182, 183,
829		− 170, 9, 187, -32, -32, 35, 205, 116, 250, 251,
830		− 146, 147, 254, 192, 235, 240, 172, 97, 8, 130,
831		− 155, 156, 173, 40, 124, 125, 41, 26, 27, 28,
832		− 305, 157, 158, 159, 160, 94, 207, 165, 166, 167,
833		− 270, 122, 123, 278, 161, 162, 281, 163, 164, 230,
834		− 218, 219, 220, 221, 174, 175, 211, 226, 227, 228,
835		− 216, 217, 222, 223, 247, 224, 225, 176, 96, 98,
836		− 113, 107, 118, 120, 129, 151, 152, 168, 233, 153,
837		− 154, 171, 177, 41, 304, 169, 131, 132, 133, 134,
838		− 135, 136, 137, 138, 139, 140, 178, 179, 181, 141,
839		− 180, 87, 142, 188, 143, 144, 189, 190, 191, 84,
840		− 8, 195, 198, 201, 202, 234, 237, 238, 239, 241,
841		− 242, 258, 243, 244, 248, 285, 259, 246, 256, 293,
842		− 260, 283, 121, 261, 262, 269, 287, 279, 267, 268,
843		− 282, 245, 288, 289, 290, 295, 264, 265, 266, 292,
844		− -2, 302, 303, 1, 2, 3, 4, 5, 286, 306,
845		− 307, 6, 7, 298, 8, 311, 9, 312, 291, 10,
846		− 11, 12, 315, 257, 209, 310, 13, 284, 212, 208,
847		− 300, 229, 301, 14, 210, 231, 15, 16, 17, 18,
848		− 19, 20, 298, 21, 22, 213, 23, 214, 0, 0,
849		− 24, 25, 215, 26, 27, 28, 0, 0, 0, 0,
850		− 0, 0, 0, 0, 29, 30, 0, 0, 0, 0,
851		− 0, 0, 31, 32, 33, 34, 0, 0, 0, 0,
852		− 0, 1, 2, 3, 4, 5, 0, 0, 35, 6,
853		− 7, 0, 8, 0, 9, -16, 0, 10, 11, 12,
854		− 36, 37, 38, 39, 13, 0, 40, 0, 0, 41,
855		− 0, 14, 0, 0, 15, 16, 17, 18, 19, 20,
856		− 0, 21, 22, 0, 23, 0, 0, 0, 24, 25,
857		− 0, 26, 27, 28, 0, 0, 0, 0, 0, 0,
858		− 0, 0, 29, 30, 0, 0, 0, 0, 0, 0,
859		− 31, 32, 33, 34, 0, 0, 0, 0, 0, 1,
860		− 2, 3, 4, 5, 0, 0, 35, 6, 7, 0,
861		− 8, 0, 9, -17, 0, 10, 11, 12, 36, 37,
862		− 38, 39, 13, 0, 40, 0, 0, 41, 0, 14,
863		− 0, 0, 15, 16, 17, 18, 19, 20, 0, 21,
864		− 22, 0, 23, 0, 0, 0, 24, 25, 0, 26,
865		− 27, 28, 0, 0, 0, 0, 0, 0, 0, 0,
866		− 29, 30, 0, 0, 0, 0, 0, 0, 31, 32,
867		− 33, 34, 0, 0, 0, 0, 0, 1, 2, 3,
868		− 4, 5, 0, 0, 35, 6, 7, 0, 8, 0,
869		− 9, 0, 0, 10, 11, 12, 36, 37, 38, 39,
870		− 13, 0, 40, 0, 0, 41, 0, 14, 0, 0,
871		− 15, 16, 17, 18, 19, 20, 0, 21, 22, 0,
872		− 23, 0, 0, 0, 24, 25, 0, 26, 27, 28,
873		− 0, 0, 0, 0, 0, 0, 0, 0, 29, 30,
874		− 0, 0, 0, 0, 0, 0, 31, 32, 33, 34,
875		− 0, 0, 0, 0, 0, 1, 2, 3, 4, 5,
876		− 0, 0, 35, 6, 7, 0, 8, 0, 9, 88,
877		− 0, 10, 11, 12, 36, 37, 38, 39, 13, 0,
878		− 40, 0, 0, 41, 0, 14, 0, 0, 15, 16,
879		− 17, 18, 19, 20, 0, 0, 22, 0, 23, 0,
880		− 0, 0, 24, 25, 0, 26, 27, 28, 0, 0,
881		− 0, 0, 0, 0, 0, 0, 29, 30, 0, 0,
882		− 0, 0, 0, 0, 31, 32, 33, 34, 0, 0,
883		− 1, 2, 3, 4, 5, 0, 0, 0, 6, 7,
884		− 35, 8, 0, 9, 0, 0, 10, 11, 12, 0,
885		− 0, 0, 0, 13, 0, 39, 0, 0, 40, 0,
886		− 14, 41, 0, 15, 16, 17, 18, 19, 20, 0,
887		− 0, 22, 0, 23, 0, 0, 0, 24, 25, 0,
888		− 26, 27, 28, 0, 0, 0, 0, 0, 0, 0,
889		− 0, 29, 30, 0, 1, 2, 3, 4, 5, 31,
890		− 32, 33, 34, 7, 85, 8, 0, 0, 0, 0,
891		− 10, 11, 12, 0, 0, 35, 0, 13, 0, 0,
892		− 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
893		− 39, 0, 0, 40, 0, 0, 41, 23, 0, 0,
894		− 0, 24, 25, 0, 26, 27, 28, 0, 0, 0,
895		− 0, 0, 0, 0, 0, 0, 30, 0, 0, 0,
896		− 0, 0, 0, 31, 32, 33, 34, 1, 2, 3,
897		− 4, 5, 0, 0, 0, 99, 7, 0, 8, 35,
898		− 0, 0, 0, 10, 11, 12, 0, 0, 0, 0,
899		− 13, 0, 0, 0, 39, 0, 0, 40, 0, 0,
900		− 41, 0, 0, 0, 0, 0, 0, 0, 0, 0,
901		− 23, 0, 0, 0, 24, 25, 0, 26, 27, 28,
902		− 0, 0, 0, 0, 0, 0, 0, 0, 0, 30,
903		− 0, 0, 0, 0, 0, 0, 31, 32, 33, 34,
904		− 1, 2, 3, 4, 5, 0, 0, 0, 6, 7,
905		− 0, 8, 35, 0, 0, 0, 10, 11, 12, 0,
906		− 0, 0, 0, 13, 0, 0, 0, 39, 0, 0,
907		− 40, 0, 0, 41, 0, 0, 0, 0, 0, 0,
908		− 0, 0, 0, 23, 0, 0, 0, 24, 25, 0,
909		− 26, 27, 28, 0, 0, 0, 0, 0, 0, 0,
910		− 0, 0, 30, 0, 1, 2, 3, 4, 5, 31,
911		− 32, 33, 34, 7, 232, 8, 0, 0, 0, 0,
912		− 10, 11, 12, 0, 0, 35, 0, 13, 0, 0,
913		− 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
914		− 39, 0, 0, 40, 0, 0, 41, 23, 0, 0,
915		− 0, 24, 25, 0, 26, 27, 28, 0, 0, 0,
916		− 0, 0, 0, 0, 0, 0, 30, 0, 1, 2,
917		− 3, 4, 5, 31, 32, 33, 34, 7, 0, 8,
918		− 245, 0, 0, 0, 10, 11, 12, 0, 0, 35,
919		− 0, 13, 0, 0, 0, 0, 0, 0, 0, 0,
920		− 0, 0, 0, 0, 39, 0, 0, 40, 0, 0,
921		− 41, 23, 0, 0, 0, 24, 25, 0, 26, 27,
922		− 28, 0, 0, 0, 0, 0, 0, 0, 0, 0,
923		− 30, 0, 1, 2, 3, 4, 5, 31, 32, 33,
924		− 34, 7, 263, 8, 0, 0, 0, 0, 10, 11,
925		− 12, 0, 0, 35, 0, 13, 0, 0, 0, 0,
926		− 0, 0, 0, 0, 0, 0, 0, 0, 39, 0,
927		− 0, 40, 0, 0, 41, 23, 0, 0, 0, 24,
928		− 25, 0, 26, 27, 28, 0, 0, 0, 0, 0,
929		− 0, 0, 0, 0, 30, 0, 1, 2, 3, 4,
930		− 5, 31, 32, 33, 34, 7, 0, 8, 0, 0,
931		− 0, 0, 10, 11, 12, 0, 0, 35, 0, 13,
932		− 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
933		− 0, 0, 39, 0, 0, 40, 0, 0, 41, 23,
934		− 0, 0, 0, 24, 25, 0, 26, 27, 28, 0,
935		− 0, 0, 0, 0, 0, 0, 0, 0, 30, 0,
936		− 0, 0, 0, 0, 0, 31, 32, 33, 34, 0,
937		− 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
938		− 0, 35, 0, 0, 0, 0, 0, 0, 0, 0,
939		− 0, 0, 0, 0, 0, 0, 39, 0, 0, 40,
940		− 0, 0, 41
	821	+ 110, 111, 112, 96, 87, 88, 207, 129, 239, 178,
	822	+ 119, 102, 2, 3, 4, 5, 186, 252, -41, 101,
	823	+ 7, 256, 8, 105, 106, 107, 109, 10, 11, 12,
	824	+ 109, 283, 45, 46, 52, 103, 104, 151, 197, 121,
	825	+ 187, 199, 311, 90, 113, 114, 91, 9, 93, 13,
	826	+ 174, 152, 8, 13, 23, 312, 175, 297, 24, 25,
	827	+ 299, 26, 27, 28, -31, -31, 195, 196, 188, 317,
	828	+ 109, 167, 168, 169, 202, 203, 45, 46, 52, 280,
	829	+ 300, 32, 33, 34, -32, -32, 85, 130, 176, 177,
	830	+ 184, 185, 172, 13, 189, 124, 125, 36, 208, 118,
	831	+ 253, 254, 94, 316, 257, 194, 238, 243, 9, 159,
	832	+ 160, 161, 162, 126, 127, 41, 163, 164, 42, 229,
	833	+ 230, 231, 308, 221, 222, 223, 224, 148, 149, 210,
	834	+ 157, 158, 273, 165, 166, 281, 219, 220, 284, 225,
	835	+ 226, 233, 227, 228, 95, 97, 98, -2, 99, 214,
	836	+ 1, 2, 3, 4, 5, 108, 115, 250, 6, 7,
	837	+ 178, 8, 120, 9, 122, 131, 10, 11, 12, 153,
	838	+ 154, 236, 156, 13, 155, 170, 307, 180, 171, 173,
	839	+ 14, 179, 181, 15, 16, 17, 18, 19, 20, 182,
	840	+ 21, 22, 190, 23, 183, 88, 191, 24, 25, 192,
	841	+ 26, 27, 28, 193, 201, 85, 8, 198, 204, 205,
	842	+ 237, 29, 30, 31, 241, 240, 242, 244, 249, 251,
	843	+ 32, 33, 34, 35, 245, 259, 246, 264, 265, 247,
	844	+ 261, 262, 270, 271, 272, 263, 36, 286, 295, 282,
	845	+ 267, 268, 269, 288, 285, 248, 290, 291, 37, 38,
	846	+ 39, 40, 289, 292, 41, 293, 301, 42, 296, 298,
	847	+ 305, 306, 309, 310, 1, 2, 3, 4, 5, 314,
	848	+ 123, 315, 6, 7, 303, 8, 304, 9, -16, 294,
	849	+ 10, 11, 12, 318, 260, 301, 212, 13, 211, 313,
	850	+ 287, 213, 232, 234, 14, 215, 0, 15, 16, 17,
	851	+ 18, 19, 20, 216, 21, 22, 217, 23, 218, 0,
	852	+ 0, 24, 25, 0, 26, 27, 28, 0, 0, 0,
	853	+ 0, 0, 0, 0, 0, 29, 30, 31, 0, 0,
	854	+ 0, 0, 0, 0, 32, 33, 34, 35, 0, 0,
	855	+ 0, 0, 0, 1, 2, 3, 4, 5, 0, 0,
	856	+ 36, 6, 7, 0, 8, 0, 9, -17, 0, 10,
	857	+ 11, 12, 37, 38, 39, 40, 13, 0, 41, 0,
	858	+ 0, 42, 0, 14, 0, 0, 15, 16, 17, 18,
	859	+ 19, 20, 0, 21, 22, 0, 23, 0, 0, 0,
	860	+ 24, 25, 0, 26, 27, 28, 0, 0, 0, 0,
	861	+ 0, 0, 0, 0, 29, 30, 31, 0, 0, 0,
	862	+ 0, 0, 0, 32, 33, 34, 35, 0, 0, 0,
	863	+ 0, 0, 1, 2, 3, 4, 5, 0, 0, 36,
	864	+ 6, 7, 0, 8, 0, 9, 0, 0, 10, 11,
	865	+ 12, 37, 38, 39, 40, 13, 0, 41, 0, 0,
	866	+ 42, 0, 14, 0, 0, 15, 16, 17, 18, 19,
	867	+ 20, 0, 21, 22, 0, 23, 0, 0, 0, 24,
	868	+ 25, 0, 26, 27, 28, 0, 0, 0, 0, 0,
	869	+ 0, 0, 0, 29, 30, 31, 0, 0, 0, 0,
	870	+ 0, 0, 32, 33, 34, 35, 0, 0, 0, 0,
	871	+ 0, 1, 2, 3, 4, 5, 0, 0, 36, 6,
	872	+ 7, 0, 8, 0, 9, 89, 0, 10, 11, 12,
	873	+ 37, 38, 39, 40, 13, 0, 41, 0, 0, 42,
	874	+ 0, 14, 0, 0, 15, 16, 17, 18, 19, 20,
	875	+ 0, 0, 22, 0, 23, 0, 0, 0, 24, 25,
	876	+ 0, 26, 27, 28, 0, 0, 0, 0, 0, 0,
	877	+ 0, 0, 29, 30, 31, 0, 0, 0, 0, 0,
	878	+ 0, 32, 33, 34, 35, 0, 0, 1, 2, 3,
	879	+ 4, 5, 0, 0, 0, 6, 7, 36, 8, 0,
	880	+ 9, 0, 0, 10, 11, 12, 0, 0, 0, 0,
	881	+ 13, 0, 40, 0, 0, 41, 0, 14, 42, 0,
	882	+ 15, 16, 17, 18, 19, 20, 0, 0, 22, 0,
	883	+ 23, 0, 0, 0, 24, 25, 0, 26, 27, 28,
	884	+ 0, 0, 0, 0, 0, 0, 0, 0, 29, 30,
	885	+ 31, 0, 1, 2, 3, 4, 5, 32, 33, 34,
	886	+ 35, 7, 86, 8, 0, 0, 0, 0, 10, 11,
	887	+ 12, 0, 0, 36, 0, 13, 0, 0, 0, 0,
	888	+ 0, 0, 0, 0, 0, 0, 0, 0, 40, 0,
	889	+ 0, 41, 0, 0, 42, 23, 0, 0, 0, 24,
	890	+ 25, 0, 26, 27, 28, 0, 0, 0, 0, 0,
	891	+ 0, 0, 0, 0, 30, 31, 0, 0, 0, 0,
	892	+ 0, 0, 32, 33, 34, 35, 1, 2, 3, 4,
	893	+ 5, 0, 0, 0, 100, 7, 0, 8, 36, 0,
	894	+ 0, 0, 10, 11, 12, 0, 0, 0, 0, 13,
	895	+ 0, 0, 0, 40, 0, 0, 41, 0, 0, 42,
	896	+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 23,
	897	+ 0, 0, 0, 24, 25, 0, 26, 27, 28, 0,
	898	+ 0, 0, 0, 0, 0, 0, 0, 0, 30, 31,
	899	+ 0, 0, 0, 0, 0, 0, 32, 33, 34, 35,
	900	+ 1, 2, 3, 4, 5, 0, 0, 0, 6, 7,
	901	+ 0, 8, 36, 0, 0, 0, 10, 11, 12, 0,
	902	+ 0, 0, 0, 13, 0, 0, 0, 40, 0, 0,
	903	+ 41, 0, 0, 42, 0, 0, 0, 0, 0, 0,
	904	+ 0, 0, 0, 23, 0, 0, 0, 24, 25, 0,
	905	+ 26, 27, 28, 0, 0, 0, 0, 0, 0, 0,
	906	+ 0, 0, 30, 31, 0, 1, 2, 3, 4, 5,
	907	+ 32, 33, 34, 35, 7, 235, 8, 0, 0, 0,
	908	+ 0, 10, 11, 12, 0, 0, 36, 0, 13, 0,
	909	+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	910	+ 0, 40, 0, 0, 41, 0, 0, 42, 23, 0,
	911	+ 0, 0, 24, 25, 0, 26, 27, 28, 0, 0,
	912	+ 0, 0, 0, 0, 0, 0, 0, 30, 31, 0,
	913	+ 1, 2, 3, 4, 5, 32, 33, 34, 35, 7,
	914	+ 0, 8, 248, 0, 0, 0, 10, 11, 12, 0,
	915	+ 0, 36, 0, 13, 0, 0, 0, 0, 0, 0,
	916	+ 0, 0, 0, 0, 0, 0, 40, 0, 0, 41,
	917	+ 0, 0, 42, 23, 0, 0, 0, 24, 25, 0,
	918	+ 26, 27, 28, 0, 0, 0, 0, 0, 0, 0,
	919	+ 0, 0, 30, 31, 0, 1, 2, 3, 4, 5,
	920	+ 32, 33, 34, 35, 7, 266, 8, 0, 0, 0,
	921	+ 0, 10, 11, 12, 0, 0, 36, 0, 13, 0,
	922	+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	923	+ 0, 40, 0, 0, 41, 0, 0, 42, 23, 0,
	924	+ 0, 0, 24, 25, 0, 26, 27, 28, 0, 0,
	925	+ 0, 0, 0, 0, 0, 0, 0, 30, 31, 0,
	926	+ 1, 2, 3, 4, 5, 32, 33, 34, 35, 7,
	927	+ 0, 8, 0, 0, 0, 0, 10, 11, 12, 132,
	928	+ 0, 36, 0, 13, 102, 2, 3, 4, 5, 0,
	929	+ 0, 0, 0, 7, 0, 8, 40, 0, 0, 41,
	930	+ 0, 0, 42, 23, 0, 0, 0, 24, 25, 0,
	931	+ 26, 27, 28, 0, 0, 0, 0, 0, 0, 0,
	932	+ 0, 0, 30, 31, 0, 0, 0, 0, 0, 0,
	933	+ 32, 33, 34, 35, 26, 27, 28, 0, 0, 0,
	934	+ 0, 0, 0, 0, 0, 0, 36, 133, 134, 135,
	935	+ 136, 137, 138, 139, 140, 141, 142, 0, 0, 0,
	936	+ 143, 40, 0, 144, 41, 145, 146, 42, 0, 0,
	937	+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	938	+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	939	+ 0, 42
941	940	};
942	941
943	942	static const yytype_int16 yycheck[] =
944	943	{
945		− 30, 31, 17, 7, 8, 123, 50, 180, 82, 39,
946		− 3, 4, 5, 6, 7, 94, 16, 3, 22, 12,
947		− 16, 14, 26, 27, 28, 3, 19, 20, 21, 3,
948		− 253, 0, 0, 297, 24, 25, 110, 41, 36, 113,
949		− 9, 3, 32, 33, 0, 11, 3, 311, 26, 31,
950		− 16, 13, 26, 46, 96, 97, 279, 50, 51, 282,
951		− 53, 54, 55, 45, 26, 109, 64, 3, 4, 5,
952		− 6, 7, 116, 117, 43, 43, 12, 250, 14, 72,
953		− 73, 74, 12, 52, 70, 12, 11, 43, 92, 93,
954		− 80, 16, 96, 96, 97, 88, 126, 75, 98, 99,
955		− 107, 108, 98, 107, 178, 184, 12, 11, 14, 9,
956		− 24, 25, 18, 106, 103, 104, 109, 53, 54, 55,
957		− 293, 26, 27, 28, 29, 12, 130, 21, 22, 23,
958		− 248, 96, 97, 251, 86, 87, 254, 19, 20, 169,
959		− 157, 158, 159, 160, 50, 51, 150, 165, 166, 167,
960		− 155, 156, 161, 162, 198, 163, 164, 231, 12, 11,
961		− 3, 12, 88, 0, 11, 30, 47, 88, 172, 49,
962		− 48, 90, 13, 109, 292, 52, 76, 77, 78, 79,
963		− 80, 81, 82, 83, 84, 85, 15, 17, 28, 89,
964		− 18, 195, 92, 11, 94, 95, 13, 13, 13, 70,
965		− 14, 14, 9, 110, 3, 3, 70, 13, 13, 12,
966		− 12, 3, 13, 13, 9, 35, 10, 14, 14, 98,
967		− 13, 12, 43, 238, 239, 15, 13, 16, 243, 244,
968		− 16, 15, 13, 13, 17, 17, 240, 241, 242, 99,
969		− 0, 11, 11, 3, 4, 5, 6, 7, 263, 17,
970		− 17, 11, 12, 283, 14, 13, 16, 9, 274, 19,
971		− 20, 21, 312, 205, 148, 298, 26, 259, 151, 145,
972		− 285, 168, 287, 33, 149, 171, 36, 37, 38, 39,
973		− 40, 41, 312, 43, 44, 152, 46, 153, -1, -1,
974		− 50, 51, 154, 53, 54, 55, -1, -1, -1, -1,
975		− -1, -1, -1, -1, 64, 65, -1, -1, -1, -1,
976		− -1, -1, 72, 73, 74, 75, -1, -1, -1, -1,
977		− -1, 3, 4, 5, 6, 7, -1, -1, 88, 11,
978		− 12, -1, 14, -1, 16, 17, -1, 19, 20, 21,
979		− 100, 101, 102, 103, 26, -1, 106, -1, -1, 109,
980		− -1, 33, -1, -1, 36, 37, 38, 39, 40, 41,
981		− -1, 43, 44, -1, 46, -1, -1, -1, 50, 51,
982		− -1, 53, 54, 55, -1, -1, -1, -1, -1, -1,
983		− -1, -1, 64, 65, -1, -1, -1, -1, -1, -1,
984		− 72, 73, 74, 75, -1, -1, -1, -1, -1, 3,
985		− 4, 5, 6, 7, -1, -1, 88, 11, 12, -1,
986		− 14, -1, 16, 17, -1, 19, 20, 21, 100, 101,
987		− 102, 103, 26, -1, 106, -1, -1, 109, -1, 33,
988		− -1, -1, 36, 37, 38, 39, 40, 41, -1, 43,
989		− 44, -1, 46, -1, -1, -1, 50, 51, -1, 53,
990		− 54, 55, -1, -1, -1, -1, -1, -1, -1, -1,
991		− 64, 65, -1, -1, -1, -1, -1, -1, 72, 73,
992		− 74, 75, -1, -1, -1, -1, -1, 3, 4, 5,
993		− 6, 7, -1, -1, 88, 11, 12, -1, 14, -1,
994		− 16, -1, -1, 19, 20, 21, 100, 101, 102, 103,
995		− 26, -1, 106, -1, -1, 109, -1, 33, -1, -1,
996		− 36, 37, 38, 39, 40, 41, -1, 43, 44, -1,
997		− 46, -1, -1, -1, 50, 51, -1, 53, 54, 55,
998		− -1, -1, -1, -1, -1, -1, -1, -1, 64, 65,
999		− -1, -1, -1, -1, -1, -1, 72, 73, 74, 75,
1000		− -1, -1, -1, -1, -1, 3, 4, 5, 6, 7,
1001		− -1, -1, 88, 11, 12, -1, 14, -1, 16, 17,
1002		− -1, 19, 20, 21, 100, 101, 102, 103, 26, -1,
1003		− 106, -1, -1, 109, -1, 33, -1, -1, 36, 37,
1004		− 38, 39, 40, 41, -1, -1, 44, -1, 46, -1,
1005		− -1, -1, 50, 51, -1, 53, 54, 55, -1, -1,
1006		− -1, -1, -1, -1, -1, -1, 64, 65, -1, -1,
1007		− -1, -1, -1, -1, 72, 73, 74, 75, -1, -1,
1008		− 3, 4, 5, 6, 7, -1, -1, -1, 11, 12,
1009		− 88, 14, -1, 16, -1, -1, 19, 20, 21, -1,
1010		− -1, -1, -1, 26, -1, 103, -1, -1, 106, -1,
1011		− 33, 109, -1, 36, 37, 38, 39, 40, 41, -1,
1012		− -1, 44, -1, 46, -1, -1, -1, 50, 51, -1,
1013		− 53, 54, 55, -1, -1, -1, -1, -1, -1, -1,
1014		− -1, 64, 65, -1, 3, 4, 5, 6, 7, 72,
1015		− 73, 74, 75, 12, 13, 14, -1, -1, -1, -1,
1016		− 19, 20, 21, -1, -1, 88, -1, 26, -1, -1,
1017		− -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1018		− 103, -1, -1, 106, -1, -1, 109, 46, -1, -1,
1019		− -1, 50, 51, -1, 53, 54, 55, -1, -1, -1,
1020		− -1, -1, -1, -1, -1, -1, 65, -1, -1, -1,
1021		− -1, -1, -1, 72, 73, 74, 75, 3, 4, 5,
1022		− 6, 7, -1, -1, -1, 11, 12, -1, 14, 88,
1023		− -1, -1, -1, 19, 20, 21, -1, -1, -1, -1,
1024		− 26, -1, -1, -1, 103, -1, -1, 106, -1, -1,
1025		− 109, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1026		− 46, -1, -1, -1, 50, 51, -1, 53, 54, 55,
1027		− -1, -1, -1, -1, -1, -1, -1, -1, -1, 65,
1028		− -1, -1, -1, -1, -1, -1, 72, 73, 74, 75,
1029		− 3, 4, 5, 6, 7, -1, -1, -1, 11, 12,
1030		− -1, 14, 88, -1, -1, -1, 19, 20, 21, -1,
1031		− -1, -1, -1, 26, -1, -1, -1, 103, -1, -1,
1032		− 106, -1, -1, 109, -1, -1, -1, -1, -1, -1,
1033		− -1, -1, -1, 46, -1, -1, -1, 50, 51, -1,
1034		− 53, 54, 55, -1, -1, -1, -1, -1, -1, -1,
1035		− -1, -1, 65, -1, 3, 4, 5, 6, 7, 72,
1036		− 73, 74, 75, 12, 13, 14, -1, -1, -1, -1,
1037		− 19, 20, 21, -1, -1, 88, -1, 26, -1, -1,
1038		− -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1039		− 103, -1, -1, 106, -1, -1, 109, 46, -1, -1,
1040		− -1, 50, 51, -1, 53, 54, 55, -1, -1, -1,
1041		− -1, -1, -1, -1, -1, -1, 65, -1, 3, 4,
1042		− 5, 6, 7, 72, 73, 74, 75, 12, -1, 14,
1043		− 15, -1, -1, -1, 19, 20, 21, -1, -1, 88,
1044		− -1, 26, -1, -1, -1, -1, -1, -1, -1, -1,
1045		− -1, -1, -1, -1, 103, -1, -1, 106, -1, -1,
1046		− 109, 46, -1, -1, -1, 50, 51, -1, 53, 54,
1047		− 55, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1048		− 65, -1, 3, 4, 5, 6, 7, 72, 73, 74,
1049		− 75, 12, 13, 14, -1, -1, -1, -1, 19, 20,
1050		− 21, -1, -1, 88, -1, 26, -1, -1, -1, -1,
1051		− -1, -1, -1, -1, -1, -1, -1, -1, 103, -1,
1052		− -1, 106, -1, -1, 109, 46, -1, -1, -1, 50,
1053		− 51, -1, 53, 54, 55, -1, -1, -1, -1, -1,
1054		− -1, -1, -1, -1, 65, -1, 3, 4, 5, 6,
1055		− 7, 72, 73, 74, 75, 12, -1, 14, -1, -1,
1056		− -1, -1, 19, 20, 21, -1, -1, 88, -1, 26,
1057		− -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1058		− -1, -1, 103, -1, -1, 106, -1, -1, 109, 46,
1059		− -1, -1, -1, 50, 51, -1, 53, 54, 55, -1,
1060		− -1, -1, -1, -1, -1, -1, -1, -1, 65, -1,
1061		− -1, -1, -1, -1, -1, 72, 73, 74, 75, -1,
1062		− -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1063		− -1, 88, -1, -1, -1, -1, -1, -1, -1, -1,
1064		− -1, -1, -1, -1, -1, -1, 103, -1, -1, 106,
1065		− -1, -1, 109
	944	+ 30, 31, 32, 17, 7, 8, 125, 51, 182, 83,
	945	+ 40, 3, 4, 5, 6, 7, 95, 16, 3, 22,
	946	+ 12, 16, 14, 26, 27, 28, 3, 19, 20, 21,
	947	+ 3, 256, 0, 0, 0, 24, 25, 31, 112, 42,
	948	+ 36, 115, 11, 9, 33, 34, 3, 16, 12, 26,
	949	+ 12, 45, 14, 26, 46, 300, 18, 282, 50, 51,
	950	+ 285, 53, 54, 55, 97, 98, 110, 111, 64, 314,
	951	+ 3, 21, 22, 23, 118, 119, 44, 44, 44, 253,
	952	+ 13, 73, 74, 75, 97, 98, 71, 53, 50, 51,
	953	+ 93, 94, 81, 26, 97, 97, 98, 89, 128, 76,
	954	+ 99, 100, 12, 11, 99, 108, 180, 186, 16, 26,
	955	+ 27, 28, 29, 104, 105, 107, 87, 88, 110, 167,
	956	+ 168, 169, 296, 159, 160, 161, 162, 108, 109, 132,
	957	+ 24, 25, 251, 19, 20, 254, 157, 158, 257, 163,
	958	+ 164, 171, 165, 166, 12, 12, 11, 0, 11, 152,
	959	+ 3, 4, 5, 6, 7, 12, 3, 201, 11, 12,
	960	+ 234, 14, 89, 16, 0, 11, 19, 20, 21, 30,
	961	+ 47, 174, 48, 26, 49, 89, 295, 15, 52, 91,
	962	+ 33, 13, 17, 36, 37, 38, 39, 40, 41, 18,
	963	+ 43, 44, 11, 46, 28, 198, 13, 50, 51, 13,
	964	+ 53, 54, 55, 13, 9, 71, 14, 14, 111, 3,
	965	+ 3, 64, 65, 66, 13, 71, 13, 12, 14, 9,
	966	+ 73, 74, 75, 76, 12, 14, 13, 241, 242, 13,
	967	+ 3, 10, 246, 247, 15, 13, 89, 12, 100, 16,
	968	+ 243, 244, 245, 35, 16, 15, 13, 13, 101, 102,
	969	+ 103, 104, 266, 13, 107, 17, 286, 110, 99, 17,
	970	+ 11, 11, 17, 17, 3, 4, 5, 6, 7, 13,
	971	+ 44, 9, 11, 12, 288, 14, 290, 16, 17, 277,
	972	+ 19, 20, 21, 315, 208, 315, 150, 26, 147, 301,
	973	+ 262, 151, 170, 173, 33, 153, -1, 36, 37, 38,
	974	+ 39, 40, 41, 154, 43, 44, 155, 46, 156, -1,
	975	+ -1, 50, 51, -1, 53, 54, 55, -1, -1, -1,
	976	+ -1, -1, -1, -1, -1, 64, 65, 66, -1, -1,
	977	+ -1, -1, -1, -1, 73, 74, 75, 76, -1, -1,
	978	+ -1, -1, -1, 3, 4, 5, 6, 7, -1, -1,
	979	+ 89, 11, 12, -1, 14, -1, 16, 17, -1, 19,
	980	+ 20, 21, 101, 102, 103, 104, 26, -1, 107, -1,
	981	+ -1, 110, -1, 33, -1, -1, 36, 37, 38, 39,
	982	+ 40, 41, -1, 43, 44, -1, 46, -1, -1, -1,
	983	+ 50, 51, -1, 53, 54, 55, -1, -1, -1, -1,
	984	+ -1, -1, -1, -1, 64, 65, 66, -1, -1, -1,
	985	+ -1, -1, -1, 73, 74, 75, 76, -1, -1, -1,
	986	+ -1, -1, 3, 4, 5, 6, 7, -1, -1, 89,
	987	+ 11, 12, -1, 14, -1, 16, -1, -1, 19, 20,
	988	+ 21, 101, 102, 103, 104, 26, -1, 107, -1, -1,
	989	+ 110, -1, 33, -1, -1, 36, 37, 38, 39, 40,
	990	+ 41, -1, 43, 44, -1, 46, -1, -1, -1, 50,
	991	+ 51, -1, 53, 54, 55, -1, -1, -1, -1, -1,
	992	+ -1, -1, -1, 64, 65, 66, -1, -1, -1, -1,
	993	+ -1, -1, 73, 74, 75, 76, -1, -1, -1, -1,
	994	+ -1, 3, 4, 5, 6, 7, -1, -1, 89, 11,
	995	+ 12, -1, 14, -1, 16, 17, -1, 19, 20, 21,
	996	+ 101, 102, 103, 104, 26, -1, 107, -1, -1, 110,
	997	+ -1, 33, -1, -1, 36, 37, 38, 39, 40, 41,
	998	+ -1, -1, 44, -1, 46, -1, -1, -1, 50, 51,
	999	+ -1, 53, 54, 55, -1, -1, -1, -1, -1, -1,
	1000	+ -1, -1, 64, 65, 66, -1, -1, -1, -1, -1,
	1001	+ -1, 73, 74, 75, 76, -1, -1, 3, 4, 5,
	1002	+ 6, 7, -1, -1, -1, 11, 12, 89, 14, -1,
	1003	+ 16, -1, -1, 19, 20, 21, -1, -1, -1, -1,
	1004	+ 26, -1, 104, -1, -1, 107, -1, 33, 110, -1,
	1005	+ 36, 37, 38, 39, 40, 41, -1, -1, 44, -1,
	1006	+ 46, -1, -1, -1, 50, 51, -1, 53, 54, 55,
	1007	+ -1, -1, -1, -1, -1, -1, -1, -1, 64, 65,
	1008	+ 66, -1, 3, 4, 5, 6, 7, 73, 74, 75,
	1009	+ 76, 12, 13, 14, -1, -1, -1, -1, 19, 20,
	1010	+ 21, -1, -1, 89, -1, 26, -1, -1, -1, -1,
	1011	+ -1, -1, -1, -1, -1, -1, -1, -1, 104, -1,
	1012	+ -1, 107, -1, -1, 110, 46, -1, -1, -1, 50,
	1013	+ 51, -1, 53, 54, 55, -1, -1, -1, -1, -1,
	1014	+ -1, -1, -1, -1, 65, 66, -1, -1, -1, -1,
	1015	+ -1, -1, 73, 74, 75, 76, 3, 4, 5, 6,
	1016	+ 7, -1, -1, -1, 11, 12, -1, 14, 89, -1,
	1017	+ -1, -1, 19, 20, 21, -1, -1, -1, -1, 26,
	1018	+ -1, -1, -1, 104, -1, -1, 107, -1, -1, 110,
	1019	+ -1, -1, -1, -1, -1, -1, -1, -1, -1, 46,
	1020	+ -1, -1, -1, 50, 51, -1, 53, 54, 55, -1,
	1021	+ -1, -1, -1, -1, -1, -1, -1, -1, 65, 66,
	1022	+ -1, -1, -1, -1, -1, -1, 73, 74, 75, 76,
	1023	+ 3, 4, 5, 6, 7, -1, -1, -1, 11, 12,
	1024	+ -1, 14, 89, -1, -1, -1, 19, 20, 21, -1,
	1025	+ -1, -1, -1, 26, -1, -1, -1, 104, -1, -1,
	1026	+ 107, -1, -1, 110, -1, -1, -1, -1, -1, -1,
	1027	+ -1, -1, -1, 46, -1, -1, -1, 50, 51, -1,
	1028	+ 53, 54, 55, -1, -1, -1, -1, -1, -1, -1,
	1029	+ -1, -1, 65, 66, -1, 3, 4, 5, 6, 7,
	1030	+ 73, 74, 75, 76, 12, 13, 14, -1, -1, -1,
	1031	+ -1, 19, 20, 21, -1, -1, 89, -1, 26, -1,
	1032	+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	1033	+ -1, 104, -1, -1, 107, -1, -1, 110, 46, -1,
	1034	+ -1, -1, 50, 51, -1, 53, 54, 55, -1, -1,
	1035	+ -1, -1, -1, -1, -1, -1, -1, 65, 66, -1,
	1036	+ 3, 4, 5, 6, 7, 73, 74, 75, 76, 12,
	1037	+ -1, 14, 15, -1, -1, -1, 19, 20, 21, -1,
	1038	+ -1, 89, -1, 26, -1, -1, -1, -1, -1, -1,
	1039	+ -1, -1, -1, -1, -1, -1, 104, -1, -1, 107,
	1040	+ -1, -1, 110, 46, -1, -1, -1, 50, 51, -1,
	1041	+ 53, 54, 55, -1, -1, -1, -1, -1, -1, -1,
	1042	+ -1, -1, 65, 66, -1, 3, 4, 5, 6, 7,
	1043	+ 73, 74, 75, 76, 12, 13, 14, -1, -1, -1,
	1044	+ -1, 19, 20, 21, -1, -1, 89, -1, 26, -1,
	1045	+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	1046	+ -1, 104, -1, -1, 107, -1, -1, 110, 46, -1,
	1047	+ -1, -1, 50, 51, -1, 53, 54, 55, -1, -1,
	1048	+ -1, -1, -1, -1, -1, -1, -1, 65, 66, -1,
	1049	+ 3, 4, 5, 6, 7, 73, 74, 75, 76, 12,
	1050	+ -1, 14, -1, -1, -1, -1, 19, 20, 21, 9,
	1051	+ -1, 89, -1, 26, 3, 4, 5, 6, 7, -1,
	1052	+ -1, -1, -1, 12, -1, 14, 104, -1, -1, 107,
	1053	+ -1, -1, 110, 46, -1, -1, -1, 50, 51, -1,
	1054	+ 53, 54, 55, -1, -1, -1, -1, -1, -1, -1,
	1055	+ -1, -1, 65, 66, -1, -1, -1, -1, -1, -1,
	1056	+ 73, 74, 75, 76, 53, 54, 55, -1, -1, -1,
	1057	+ -1, -1, -1, -1, -1, -1, 89, 77, 78, 79,
	1058	+ 80, 81, 82, 83, 84, 85, 86, -1, -1, -1,
	1059	+ 90, 104, -1, 93, 107, 95, 96, 110, -1, -1,
	1060	+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	1061	+ -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
	1062	+ -1, 110
1066	1063	};
1067	1064
1068		−/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1069		−symbol of state STATE-NUM. */
	1065	+ /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
	1066	+ symbol of state STATE-NUM. */
1070	1067	static const yytype_uint8 yystos[] =
1071	1068	{
1072		− 0, 3, 4, 5, 6, 7, 11, 12, 14, 16,
1073		− 19, 20, 21, 26, 33, 36, 37, 38, 39, 40,
1074		− 41, 43, 44, 46, 50, 51, 53, 54, 55, 64,
1075		− 65, 72, 73, 74, 75, 88, 100, 101, 102, 103,
1076		− 106, 109, 112, 113, 114, 122, 123, 124, 126, 127,
1077		− 128, 131, 132, 133, 134, 135, 136, 137, 138, 139,
1078		− 140, 141, 143, 146, 147, 148, 151, 152, 153, 154,
1079		− 155, 156, 157, 158, 159, 160, 161, 162, 163, 164,
1080		− 165, 166, 167, 168, 70, 13, 138, 138, 17, 131,
1081		− 3, 121, 12, 12, 12, 132, 12, 11, 11, 11,
1082		− 138, 3, 164, 164, 138, 138, 138, 12, 3, 128,
1083		− 128, 164, 164, 3, 144, 145, 75, 128, 88, 138,
1084		− 0, 112, 96, 97, 103, 104, 125, 144, 131, 11,
1085		− 9, 76, 77, 78, 79, 80, 81, 82, 83, 84,
1086		− 85, 89, 92, 94, 95, 149, 107, 108, 150, 31,
1087		− 45, 30, 47, 49, 48, 24, 25, 26, 27, 28,
1088		− 29, 86, 87, 19, 20, 21, 22, 23, 88, 52,
1089		− 164, 90, 12, 18, 50, 51, 141, 13, 15, 17,
1090		− 18, 28, 138, 138, 137, 36, 64, 138, 11, 13,
1091		− 13, 13, 138, 144, 141, 14, 141, 142, 9, 144,
1092		− 144, 110, 3, 120, 120, 128, 129, 138, 140, 143,
1093		− 153, 138, 154, 155, 156, 157, 158, 158, 159, 159,
1094		− 159, 159, 160, 160, 161, 161, 162, 162, 162, 163,
1095		− 128, 167, 13, 138, 3, 141, 121, 70, 13, 13,
1096		− 137, 12, 12, 13, 13, 15, 14, 144, 9, 16,
1097		− 98, 99, 115, 16, 98, 119, 14, 142, 3, 10,
1098		− 13, 132, 132, 13, 138, 138, 138, 132, 132, 15,
1099		− 120, 114, 116, 117, 118, 122, 131, 121, 120, 16,
1100		− 116, 120, 16, 12, 151, 35, 132, 13, 13, 13,
1101		− 17, 117, 99, 98, 116, 17, 116, 13, 128, 130,
1102		− 132, 132, 11, 11, 120, 121, 17, 17, 11, 136,
1103		− 145, 13, 9, 11, 136, 130
	1069	+ 0, 3, 4, 5, 6, 7, 11, 12, 14, 16,
	1070	+ 19, 20, 21, 26, 33, 36, 37, 38, 39, 40,
	1071	+ 41, 43, 44, 46, 50, 51, 53, 54, 55, 64,
	1072	+ 65, 66, 73, 74, 75, 76, 89, 101, 102, 103,
	1073	+ 104, 107, 110, 113, 114, 115, 123, 124, 125, 127,
	1074	+ 128, 129, 132, 133, 134, 135, 136, 137, 138, 139,
	1075	+ 140, 141, 142, 144, 147, 148, 149, 152, 153, 154,
	1076	+ 155, 156, 157, 158, 159, 160, 161, 162, 163, 164,
	1077	+ 165, 166, 167, 168, 169, 71, 13, 139, 139, 17,
	1078	+ 132, 3, 122, 12, 12, 12, 133, 12, 11, 11,
	1079	+ 11, 139, 3, 165, 165, 139, 139, 139, 12, 3,
	1080	+ 129, 129, 129, 165, 165, 3, 145, 146, 76, 129,
	1081	+ 89, 139, 0, 113, 97, 98, 104, 105, 126, 145,
	1082	+ 132, 11, 9, 77, 78, 79, 80, 81, 82, 83,
	1083	+ 84, 85, 86, 90, 93, 95, 96, 150, 108, 109,
	1084	+ 151, 31, 45, 30, 47, 49, 48, 24, 25, 26,
	1085	+ 27, 28, 29, 87, 88, 19, 20, 21, 22, 23,
	1086	+ 89, 52, 165, 91, 12, 18, 50, 51, 142, 13,
	1087	+ 15, 17, 18, 28, 139, 139, 138, 36, 64, 139,
	1088	+ 11, 13, 13, 13, 139, 145, 145, 142, 14, 142,
	1089	+ 143, 9, 145, 145, 111, 3, 121, 121, 129, 130,
	1090	+ 139, 141, 144, 154, 139, 155, 156, 157, 158, 159,
	1091	+ 159, 160, 160, 160, 160, 161, 161, 162, 162, 163,
	1092	+ 163, 163, 164, 129, 168, 13, 139, 3, 142, 122,
	1093	+ 71, 13, 13, 138, 12, 12, 13, 13, 15, 14,
	1094	+ 145, 9, 16, 99, 100, 116, 16, 99, 120, 14,
	1095	+ 143, 3, 10, 13, 133, 133, 13, 139, 139, 139,
	1096	+ 133, 133, 15, 121, 115, 117, 118, 119, 123, 132,
	1097	+ 122, 121, 16, 117, 121, 16, 12, 152, 35, 133,
	1098	+ 13, 13, 13, 17, 118, 100, 99, 117, 17, 117,
	1099	+ 13, 129, 131, 133, 133, 11, 11, 121, 122, 17,
	1100	+ 17, 11, 137, 146, 13, 9, 11, 137, 131
1104	1101	};
1105	1102
1106		−/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
	1103	+ /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1107	1104	static const yytype_uint8 yyr1[] =
1108	1105	{
1109		− 0, 111, 112, 112, 113, 113, 113, 114, 114, 114,
1110		− 114, 115, 115, 115, 115, 116, 116, 117, 117, 118,
1111		− 118, 118, 119, 120, 120, 121, 121, 122, 122, 122,
1112		− 122, 123, 123, 123, 124, 124, 124, 124, 125, 125,
1113		− 125, 126, 126, 127, 127, 128, 128, 129, 129, 130,
1114		− 130, 131, 131, 132, 132, 132, 132, 132, 133, 133,
1115		− 133, 133, 134, 134, 135, 135, 135, 135, 135, 135,
1116		− 135, 136, 136, 137, 137, 138, 138, 139, 139, 140,
1117		− 140, 141, 141, 142, 142, 143, 143, 143, 143, 143,
1118		− 143, 144, 144, 145, 145, 145, 146, 147, 148, 149,
1119		− 149, 149, 149, 149, 149, 149, 149, 149, 149, 149,
1120		− 149, 149, 149, 150, 150, 151, 151, 152, 152, 153,
1121		− 153, 154, 154, 155, 155, 156, 156, 157, 157, 157,
1122		− 158, 158, 158, 158, 158, 159, 159, 159, 160, 160,
1123		− 160, 161, 161, 161, 161, 162, 162, 163, 163, 164,
1124		− 164, 164, 164, 164, 164, 164, 164, 165, 165, 165,
1125		− 165, 165, 165, 166, 166, 167, 167, 167, 167, 167,
1126		− 167, 167, 168, 168, 168, 168, 168, 168, 168, 168,
1127		− 168, 168, 168, 168
	1106	+ 0, 112, 113, 113, 114, 114, 114, 115, 115, 115,
	1107	+ 115, 116, 116, 116, 116, 117, 117, 118, 118, 119,
	1108	+ 119, 119, 120, 121, 121, 122, 122, 123, 123, 123,
	1109	+ 123, 124, 124, 124, 125, 125, 125, 125, 126, 126,
	1110	+ 126, 127, 127, 128, 128, 129, 129, 130, 130, 131,
	1111	+ 131, 132, 132, 133, 133, 133, 133, 133, 134, 134,
	1112	+ 134, 134, 135, 135, 136, 136, 136, 136, 136, 136,
	1113	+ 136, 137, 137, 138, 138, 139, 139, 140, 140, 141,
	1114	+ 141, 142, 142, 143, 143, 144, 144, 144, 144, 144,
	1115	+ 144, 144, 145, 145, 146, 146, 146, 147, 148, 149,
	1116	+ 150, 150, 150, 150, 150, 150, 150, 150, 150, 150,
	1117	+ 150, 150, 150, 150, 151, 151, 152, 152, 153, 153,
	1118	+ 154, 154, 155, 155, 156, 156, 157, 157, 158, 158,
	1119	+ 158, 159, 159, 159, 159, 159, 160, 160, 160, 161,
	1120	+ 161, 161, 162, 162, 162, 162, 163, 163, 164, 164,
	1121	+ 165, 165, 165, 165, 165, 165, 165, 165, 166, 166,
	1122	+ 166, 166, 166, 166, 167, 167, 168, 168, 168, 168,
	1123	+ 168, 168, 168, 169, 169, 169, 169, 169, 169, 169,
	1124	+ 169, 169, 169, 169, 169
1128	1125	};
1129	1126
1130		−/* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
	1127	+ /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
1131	1128	static const yytype_uint8 yyr2[] =
1132	1129	{
1133		− 0, 2, 1, 2, 1, 1, 1, 6, 7, 6,
1134		− 7, 2, 4, 2, 4, 1, 0, 1, 2, 1,
1135		− 1, 1, 2, 1, 3, 1, 3, 8, 7, 8,
1136		− 7, 1, 1, 0, 1, 1, 1, 1, 1, 1,
1137		− 0, 1, 2, 3, 4, 1, 1, 1, 2, 2,
1138		− 4, 1, 2, 1, 1, 1, 1, 1, 2, 3,
1139		− 2, 2, 5, 7, 5, 7, 6, 7, 5, 7,
1140		− 5, 2, 3, 1, 2, 1, 3, 1, 3, 1,
1141		− 3, 3, 4, 2, 3, 1, 2, 3, 3, 2,
1142		− 3, 1, 3, 1, 2, 2, 3, 3, 3, 1,
1143		− 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1144		− 1, 1, 1, 1, 1, 1, 5, 1, 3, 1,
1145		− 3, 1, 3, 1, 3, 1, 3, 1, 3, 3,
1146		− 1, 3, 3, 3, 3, 1, 3, 3, 1, 3,
1147		− 3, 1, 3, 3, 3, 1, 3, 1, 3, 1,
1148		− 2, 2, 2, 2, 2, 2, 3, 1, 1, 1,
1149		− 1, 1, 2, 1, 3, 1, 2, 3, 4, 3,
1150		− 2, 2, 1, 1, 1, 1, 1, 1, 1, 1,
1151		− 1, 3, 3, 2
	1130	+ 0, 2, 1, 2, 1, 1, 1, 6, 7, 6,
	1131	+ 7, 2, 4, 2, 4, 1, 0, 1, 2, 1,
	1132	+ 1, 1, 2, 1, 3, 1, 3, 8, 7, 8,
	1133	+ 7, 1, 1, 0, 1, 1, 1, 1, 1, 1,
	1134	+ 0, 1, 2, 3, 4, 1, 1, 1, 2, 2,
	1135	+ 4, 1, 2, 1, 1, 1, 1, 1, 2, 3,
	1136	+ 2, 2, 5, 7, 5, 7, 6, 7, 5, 7,
	1137	+ 5, 2, 3, 1, 2, 1, 3, 1, 3, 1,
	1138	+ 3, 3, 4, 2, 3, 1, 2, 3, 3, 3,
	1139	+ 2, 3, 1, 3, 1, 2, 2, 3, 3, 3,
	1140	+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
	1141	+ 1, 1, 1, 1, 1, 1, 1, 5, 1, 3,
	1142	+ 1, 3, 1, 3, 1, 3, 1, 3, 1, 3,
	1143	+ 3, 1, 3, 3, 3, 3, 1, 3, 3, 1,
	1144	+ 3, 3, 1, 3, 3, 3, 1, 3, 1, 3,
	1145	+ 1, 2, 2, 2, 2, 2, 2, 3, 1, 1,
	1146	+ 1, 1, 1, 2, 1, 3, 1, 2, 3, 4,
	1147	+ 3, 2, 2, 1, 1, 1, 1, 1, 1, 1,
	1148	+ 1, 1, 3, 3, 2
1152	1149	};
1153	1150
1154	1151
@@ -1226,15 +1223,15 @@ do { \ · 71 unmodified lines
1226	1223	static void
1227	1224	yy_symbol_value_print (FILE yyoutput, int yytype, YYSTYPE const const yyvaluep)
1228	1225	{
1229		− FILE *yyo = yyoutput;
1230		− YYUSE (yyo);
1231		− if (!yyvaluep)
1232		− return;
	1226	+ FILE *yyo = yyoutput;
	1227	+ YYUSE (yyo);
	1228	+ if (!yyvaluep)
	1229	+ return;
1233	1230	# ifdef YYPRINT
1234		− if (yytype < YYNTOKENS)
1235		− YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
	1231	+ if (yytype < YYNTOKENS)
	1232	+ YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1236	1233	# endif
1237		− YYUSE (yytype);
	1234	+ YYUSE (yytype);
1238	1235	}
1239	1236
1240	1237
@@ -1245,11 +1242,11 @@ yy_symbol_value_print (FILE yyoutput, int yytype, YYSTYPE const const yyvalue · 4 unmodified lines
1245	1242	static void
1246	1243	yy_symbol_print (FILE yyoutput, int yytype, YYSTYPE const const yyvaluep)
1247	1244	{
1248		− YYFPRINTF (yyoutput, "%s %s (",
1249		− yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
	1245	+ YYFPRINTF (yyoutput, "%s %s (",
	1246	+ yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
1250	1247
1251		− yy_symbol_value_print (yyoutput, yytype, yyvaluep);
1252		− YYFPRINTF (yyoutput, ")");
	1248	+ yy_symbol_value_print (yyoutput, yytype, yyvaluep);
	1249	+ YYFPRINTF (yyoutput, ")");
1253	1250	}
1254	1251
1255	1252	/*------------------------------------------------------------------.
@@ -1260,13 +1257,13 @@ yy_symbol_print (FILE yyoutput, int yytype, YYSTYPE const const yyvaluep) · 4 unmodified lines
1260	1257	static void
1261	1258	yy_stack_print (yytype_int16 yybottom, yytype_int16 yytop)
1262	1259	{
1263		− YYFPRINTF (stderr, "Stack now");
1264		− for (; yybottom <= yytop; yybottom++)
	1260	+ YYFPRINTF (stderr, "Stack now");
	1261	+ for (; yybottom <= yytop; yybottom++)
1265	1262	{
1266		− int yybot = *yybottom;
1267		− YYFPRINTF (stderr, " %d", yybot);
	1263	+ int yybot = *yybottom;
	1264	+ YYFPRINTF (stderr, " %d", yybot);
1268	1265	}
1269		− YYFPRINTF (stderr, "\n");
	1266	+ YYFPRINTF (stderr, "\n");
1270	1267	}
1271	1268
1272	1269	# define YY_STACK_PRINT(Bottom, Top) \
@@ -1283,20 +1280,20 @@ do { \ · 10 unmodified lines
1283	1280	static void
1284	1281	yy_reduce_print (yytype_int16 yyssp, YYSTYPE yyvsp, int yyrule)
1285	1282	{
1286		− unsigned long int yylno = yyrline[yyrule];
1287		− int yynrhs = yyr2[yyrule];
1288		− int yyi;
1289		− YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1290		− yyrule - 1, yylno);
1291		− /* The symbols being reduced. */
1292		− for (yyi = 0; yyi < yynrhs; yyi++)
	1283	+ unsigned long int yylno = yyrline[yyrule];
	1284	+ int yynrhs = yyr2[yyrule];
	1285	+ int yyi;
	1286	+ YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
	1287	+ yyrule - 1, yylno);
	1288	+ /* The symbols being reduced. */
	1289	+ for (yyi = 0; yyi < yynrhs; yyi++)
1293	1290	{
1294		− YYFPRINTF (stderr, " $%d = ", yyi + 1);
1295		− yy_symbol_print (stderr,
1296		− yystos[yyssp[yyi + 1 - yynrhs]],
1297		− &(yyvsp[(yyi + 1) - (yynrhs)])
1298		− );
1299		− YYFPRINTF (stderr, "\n");
	1291	+ YYFPRINTF (stderr, " $%d = ", yyi + 1);
	1292	+ yy_symbol_print (stderr,
	1293	+ yystos[yyssp[yyi + 1 - yynrhs]],
	1294	+ &(yyvsp[(yyi + 1) - (yynrhs)])
	1295	+ );
	1296	+ YYFPRINTF (stderr, "\n");
1300	1297	}
1301	1298	}
1302	1299
@@ -1307,7 +1304,7 @@ do { \ · 4 unmodified lines
1307	1304	} while (0)
1308	1305
1309	1306	/* Nonzero means print parse trace. It is left uninitialized so that
1310		−multiple parsers can coexist. */
	1307	+ multiple parsers can coexist. */
1311	1308	int yydebug;
1312	1309	#else /* !YYDEBUG */
1313	1310	# define YYDPRINTF(Args)
@@ -1323,11 +1320,11 @@ int yydebug; · 9 unmodified lines
1323	1320	#endif
1324	1321
1325	1322	/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1326		−if the built-in stack extension method is used).
	1323	+ if the built-in stack extension method is used).
1327	1324
1328		−Do not make this value too large; the results are undefined if
1329		−YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1330		−evaluated with infinite-precision integer arithmetic. */
	1325	+ Do not make this value too large; the results are undefined if
	1326	+ YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
	1327	+ evaluated with infinite-precision integer arithmetic. */
1331	1328
1332	1329	#ifndef YYMAXDEPTH
1333	1330	# define YYMAXDEPTH 10000
@@ -1344,10 +1341,10 @@ evaluated with infinite-precision integer arithmetic. */ · 10 unmodified lines
1344	1341	static YYSIZE_T
1345	1342	yystrlen (const char *yystr)
1346	1343	{
1347		− YYSIZE_T yylen;
1348		− for (yylen = 0; yystr[yylen]; yylen++)
1349		− continue;
1350		− return yylen;
	1344	+ YYSIZE_T yylen;
	1345	+ for (yylen = 0; yystr[yylen]; yylen++)
	1346	+ continue;
	1347	+ return yylen;
1351	1348	}
1352	1349	# endif
1353	1350	# endif
@@ -1357,202 +1354,202 @@ yystrlen (const char *yystr) · 3 unmodified lines
1357	1354	# define yystpcpy stpcpy
1358	1355	# else
1359	1356	/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1360		−YYDEST. */
	1357	+ YYDEST. */
1361	1358	static char *
1362	1359	yystpcpy (char yydest, const char yysrc)
1363	1360	{
1364		− char *yyd = yydest;
1365		− const char *yys = yysrc;
	1361	+ char *yyd = yydest;
	1362	+ const char *yys = yysrc;
1366	1363
1367		− while ((yyd++ = yys++) != '\0')
1368		− continue;
	1364	+ while ((yyd++ = yys++) != '\0')
	1365	+ continue;
1369	1366
1370		− return yyd - 1;
	1367	+ return yyd - 1;
1371	1368	}
1372	1369	# endif
1373	1370	# endif
1374	1371
1375	1372	# ifndef yytnamerr
1376	1373	/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1377		−quotes and backslashes, so that it's suitable for yyerror. The
1378		−heuristic is that double-quoting is unnecessary unless the string
1379		−contains an apostrophe, a comma, or backslash (other than
1380		−backslash-backslash). YYSTR is taken from yytname. If YYRES is
1381		−null, do not copy; instead, return the length of what the result
1382		−would have been. */
	1374	+ quotes and backslashes, so that it's suitable for yyerror. The
	1375	+ heuristic is that double-quoting is unnecessary unless the string
	1376	+ contains an apostrophe, a comma, or backslash (other than
	1377	+ backslash-backslash). YYSTR is taken from yytname. If YYRES is
	1378	+ null, do not copy; instead, return the length of what the result
	1379	+ would have been. */
1383	1380	static YYSIZE_T
1384	1381	yytnamerr (char yyres, const char yystr)
1385	1382	{
1386		− if (*yystr == '"')
	1383	+ if (*yystr == '"')
1387	1384	{
1388		− YYSIZE_T yyn = 0;
1389		− char const *yyp = yystr;
1390		−
1391		− for (;;)
1392		− switch (*++yyp)
1393		− {
1394		− case '\'':
1395		− case ',':
1396		− goto do_not_strip_quotes;
1397		−
1398		− case '\\':
1399		− if (*++yyp != '\\')
1400		− goto do_not_strip_quotes;
1401		− /* Fall through. */
1402		− default:
1403		− if (yyres)
1404		− yyres[yyn] = *yyp;
1405		− yyn++;
1406		− break;
	1385	+ YYSIZE_T yyn = 0;
	1386	+ char const *yyp = yystr;
	1387	+
	1388	+ for (;;)
	1389	+ switch (*++yyp)
	1390	+ {
	1391	+ case '\'':
	1392	+ case ',':
	1393	+ goto do_not_strip_quotes;
	1394	+
	1395	+ case '\\':
	1396	+ if (*++yyp != '\\')
	1397	+ goto do_not_strip_quotes;
	1398	+ /* Fall through. */
	1399	+ default:
	1400	+ if (yyres)
	1401	+ yyres[yyn] = *yyp;
	1402	+ yyn++;
	1403	+ break;
1407	1404
1408		− case '"':
1409		− if (yyres)
1410		− yyres[yyn] = '\0';
1411		− return yyn;
1412		− }
	1405	+ case '"':
	1406	+ if (yyres)
	1407	+ yyres[yyn] = '\0';
	1408	+ return yyn;
	1409	+ }
1413	1410	do_not_strip_quotes: ;
1414	1411	}
1415	1412
1416		− if (! yyres)
1417		− return yystrlen (yystr);
	1413	+ if (! yyres)
	1414	+ return yystrlen (yystr);
1418	1415
1419		− return yystpcpy (yyres, yystr) - yyres;
	1416	+ return yystpcpy (yyres, yystr) - yyres;
1420	1417	}
1421	1418	# endif
1422	1419
1423	1420	/* Copy into YYMSG, which is of size YYMSG_ALLOC, an error message
1424		−about the unexpected token YYTOKEN for the state stack whose top is
1425		−YYSSP.
	1421	+ about the unexpected token YYTOKEN for the state stack whose top is
	1422	+ YYSSP.
1426	1423
1427		−Return 0 if YYMSG was successfully written. Return 1 if YYMSG is
1428		−not large enough to hold the message. In that case, also set
1429		−*YYMSG_ALLOC to the required number of bytes. Return 2 if the
1430		−required number of bytes is too large to store. */
	1424	+ Return 0 if YYMSG was successfully written. Return 1 if YYMSG is
	1425	+ not large enough to hold the message. In that case, also set
	1426	+ *YYMSG_ALLOC to the required number of bytes. Return 2 if the
	1427	+ required number of bytes is too large to store. */
1431	1428	static int
1432	1429	yysyntax_error (YYSIZE_T yymsg_alloc, char *yymsg,
1433		− yytype_int16 *yyssp, int yytoken)
	1430	+ yytype_int16 *yyssp, int yytoken)
1434	1431	{
1435		− YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
1436		− YYSIZE_T yysize = yysize0;
1437		− enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1438		− /* Internationalized format string. */
1439		− const char *yyformat = YY_NULLPTR;
1440		− /* Arguments of yyformat. */
1441		− char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1442		− /* Number of reported tokens (one for the "unexpected", one per
1443		− "expected"). */
1444		− int yycount = 0;
1445		−
1446		− /* There are many possibilities here to consider:
1447		− - If this state is a consistent state with a default action, then
1448		− the only way this function was invoked is if the default action
1449		− is an error action. In that case, don't check for expected
1450		− tokens because there are none.
1451		− - The only way there can be no lookahead present (in yychar) is if
1452		− this state is a consistent state with a default action. Thus,
1453		− detecting the absence of a lookahead is sufficient to determine
1454		− that there is no unexpected or expected token to report. In that
1455		− case, just report a simple "syntax error".
1456		− - Don't assume there isn't a lookahead just because this state is a
1457		− consistent state with a default action. There might have been a
1458		− previous inconsistent state, consistent state with a non-default
1459		− action, or user semantic action that manipulated yychar.
1460		− - Of course, the expected token list depends on states to have
1461		− correct lookahead information, and it depends on the parser not
1462		− to perform extra reductions after fetching a lookahead from the
1463		− scanner and before detecting a syntax error. Thus, state merging
1464		− (from LALR or IELR) and default reductions corrupt the expected
1465		− token list. However, the list is correct for canonical LR with
1466		− one exception: it will still contain any token that will not be
1467		− accepted due to an error action in a later state.
1468		− */
1469		− if (yytoken != YYEMPTY)
	1432	+ YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
	1433	+ YYSIZE_T yysize = yysize0;
	1434	+ enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
	1435	+ /* Internationalized format string. */
	1436	+ const char *yyformat = YY_NULLPTR;
	1437	+ /* Arguments of yyformat. */
	1438	+ char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
	1439	+ /* Number of reported tokens (one for the "unexpected", one per
	1440	+ "expected"). */
	1441	+ int yycount = 0;
	1442	+
	1443	+ /* There are many possibilities here to consider:
	1444	+ - If this state is a consistent state with a default action, then
	1445	+ the only way this function was invoked is if the default action
	1446	+ is an error action. In that case, don't check for expected
	1447	+ tokens because there are none.
	1448	+ - The only way there can be no lookahead present (in yychar) is if
	1449	+ this state is a consistent state with a default action. Thus,
	1450	+ detecting the absence of a lookahead is sufficient to determine
	1451	+ that there is no unexpected or expected token to report. In that
	1452	+ case, just report a simple "syntax error".
	1453	+ - Don't assume there isn't a lookahead just because this state is a
	1454	+ consistent state with a default action. There might have been a
	1455	+ previous inconsistent state, consistent state with a non-default
	1456	+ action, or user semantic action that manipulated yychar.
	1457	+ - Of course, the expected token list depends on states to have
	1458	+ correct lookahead information, and it depends on the parser not
	1459	+ to perform extra reductions after fetching a lookahead from the
	1460	+ scanner and before detecting a syntax error. Thus, state merging
	1461	+ (from LALR or IELR) and default reductions corrupt the expected
	1462	+ token list. However, the list is correct for canonical LR with
	1463	+ one exception: it will still contain any token that will not be
	1464	+ accepted due to an error action in a later state.
	1465	+ */
	1466	+ if (yytoken != YYEMPTY)
1470	1467	{
1471		− int yyn = yypact[*yyssp];
1472		− yyarg[yycount++] = yytname[yytoken];
1473		− if (!yypact_value_is_default (yyn))
	1468	+ int yyn = yypact[*yyssp];
	1469	+ yyarg[yycount++] = yytname[yytoken];
	1470	+ if (!yypact_value_is_default (yyn))
1474	1471	{
1475		− /* Start YYX at -YYN if negative to avoid negative indexes in
1476		− YYCHECK. In other words, skip the first -YYN actions for
1477		− this state because they are default actions. */
1478		− int yyxbegin = yyn < 0 ? -yyn : 0;
1479		− /* Stay within bounds of both yycheck and yytname. */
1480		− int yychecklim = YYLAST - yyn + 1;
1481		− int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1482		− int yyx;
1483		−
1484		− for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1485		− if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1486		− && !yytable_value_is_error (yytable[yyx + yyn]))
	1472	+ /* Start YYX at -YYN if negative to avoid negative indexes in
	1473	+ YYCHECK. In other words, skip the first -YYN actions for
	1474	+ this state because they are default actions. */
	1475	+ int yyxbegin = yyn < 0 ? -yyn : 0;
	1476	+ /* Stay within bounds of both yycheck and yytname. */
	1477	+ int yychecklim = YYLAST - yyn + 1;
	1478	+ int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
	1479	+ int yyx;
	1480	+
	1481	+ for (yyx = yyxbegin; yyx < yyxend; ++yyx)
	1482	+ if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
	1483	+ && !yytable_value_is_error (yytable[yyx + yyn]))
	1484	+ {
	1485	+ if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
	1486	+ {
	1487	+ yycount = 1;
	1488	+ yysize = yysize0;
	1489	+ break;
	1490	+ }
	1491	+ yyarg[yycount++] = yytname[yyx];
1487	1492	{
1488		− if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1489		− {
1490		− yycount = 1;
1491		− yysize = yysize0;
1492		− break;
1493		− }
1494		− yyarg[yycount++] = yytname[yyx];
1495		− {
1496		− YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
1497		− if (! (yysize <= yysize1
1498		− && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1499		− return 2;
1500		− yysize = yysize1;
1501		− }
	1493	+ YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
	1494	+ if (! (yysize <= yysize1
	1495	+ && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
	1496	+ return 2;
	1497	+ yysize = yysize1;
1502	1498	}
	1499	+ }
1503	1500	}
1504	1501	}
1505	1502
1506		− switch (yycount)
	1503	+ switch (yycount)
1507	1504	{
1508	1505	# define YYCASE_(N, S) \
1509	1506	case N: \
1510	1507	yyformat = S; \
1511	1508	break
1512		− YYCASE_(0, YY_("syntax error"));
1513		− YYCASE_(1, YY_("syntax error, unexpected %s"));
1514		− YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1515		− YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1516		− YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1517		− YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
	1509	+ YYCASE_(0, YY_("syntax error"));
	1510	+ YYCASE_(1, YY_("syntax error, unexpected %s"));
	1511	+ YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
	1512	+ YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
	1513	+ YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
	1514	+ YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1518	1515	# undef YYCASE_
1519	1516	}
1520	1517
1521		− {
1522		− YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
1523		− if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1524		− return 2;
1525		− yysize = yysize1;
1526		− }
	1518	+ {
	1519	+ YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
	1520	+ if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
	1521	+ return 2;
	1522	+ yysize = yysize1;
	1523	+ }
1527	1524
1528		− if (*yymsg_alloc < yysize)
	1525	+ if (*yymsg_alloc < yysize)
1529	1526	{
1530		− yymsg_alloc = 2 yysize;
1531		− if (! (yysize <= *yymsg_alloc
1532		− && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1533		− *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1534		− return 1;
	1527	+ yymsg_alloc = 2 yysize;
	1528	+ if (! (yysize <= *yymsg_alloc
	1529	+ && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
	1530	+ *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
	1531	+ return 1;
1535	1532	}
1536	1533
1537		− /* Avoid sprintf, as that infringes on the user's name space.
1538		− Don't have undefined behavior even if the translation
1539		− produced a string with the wrong number of "%s"s. */
1540		− {
1541		− char yyp = yymsg;
1542		− int yyi = 0;
1543		− while ((yyp = yyformat) != '\0')
1544		− if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1545		− {
1546		− yyp += yytnamerr (yyp, yyarg[yyi++]);
1547		− yyformat += 2;
1548		− }
1549		− else
1550		− {
1551		− yyp++;
1552		− yyformat++;
1553		− }
1554		− }
1555		− return 0;
	1534	+ /* Avoid sprintf, as that infringes on the user's name space.
	1535	+ Don't have undefined behavior even if the translation
	1536	+ produced a string with the wrong number of "%s"s. */
	1537	+ {
	1538	+ char yyp = yymsg;
	1539	+ int yyi = 0;
	1540	+ while ((yyp = yyformat) != '\0')
	1541	+ if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
	1542	+ {
	1543	+ yyp += yytnamerr (yyp, yyarg[yyi++]);
	1544	+ yyformat += 2;
	1545	+ }
	1546	+ else
	1547	+ {
	1548	+ yyp++;
	1549	+ yyformat++;
	1550	+ }
	1551	+ }
	1552	+ return 0;
1556	1553	}
1557	1554	#endif /* YYERROR_VERBOSE */
1558	1555
@@ -1563,14 +1560,14 @@ yysyntax_error (YYSIZE_T yymsg_alloc, char *yymsg, · 4 unmodified lines
1563	1560	static void
1564	1561	yydestruct (const char yymsg, int yytype, YYSTYPE yyvaluep)
1565	1562	{
1566		− YYUSE (yyvaluep);
1567		− if (!yymsg)
1568		− yymsg = "Deleting";
1569		− YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1570		−
1571		− YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1572		− YYUSE (yytype);
1573		− YY_IGNORE_MAYBE_UNINITIALIZED_END
	1563	+ YYUSE (yyvaluep);
	1564	+ if (!yymsg)
	1565	+ yymsg = "Deleting";
	1566	+ YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
	1567	+
	1568	+ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
	1569	+ YYUSE (yytype);
	1570	+ YY_IGNORE_MAYBE_UNINITIALIZED_END
1574	1571	}
1575	1572
1576	1573
@@ -1597,11 +1594,11 @@ yyparse (void) · 20 unmodified lines
1597	1594	int yyerrstatus;
1598	1595
1599	1596	/* The stacks and their tools:
1600		− 'yyss': related to states.
1601		− 'yyvs': related to semantic values.
	1597	+ 'yyss': related to states.
	1598	+ 'yyvs': related to semantic values.
1602	1599
1603		− Refer to the stacks through separate pointers, to allow yyoverflow
1604		− to reallocate them elsewhere. */
	1600	+ Refer to the stacks through separate pointers, to allow yyoverflow
	1601	+ to reallocate them elsewhere. */
1605	1602
1606	1603	/* The state stack. */
1607	1604	yytype_int16 yyssa[YYINITDEPTH];
@@ -1615,1533 +1612,1539 @@ yyparse (void) · 7 unmodified lines
1615	1612
1616	1613	YYSIZE_T yystacksize;
1617	1614
1618		− int yyn;
1619		− int yyresult;
1620		− /* Lookahead token as an internal (translated) token number. */
1621		− int yytoken = 0;
1622		− /* The variables used to return semantic value and location from the
1623		− action routines. */
1624		− YYSTYPE yyval;
	1615	+ int yyn;
	1616	+ int yyresult;
	1617	+ /* Lookahead token as an internal (translated) token number. */
	1618	+ int yytoken = 0;
	1619	+ /* The variables used to return semantic value and location from the
	1620	+ action routines. */
	1621	+ YYSTYPE yyval;
1625	1622
1626	1623	#if YYERROR_VERBOSE
1627		− /* Buffer for error messages, and its allocated size. */
1628		− char yymsgbuf[128];
1629		− char *yymsg = yymsgbuf;
1630		− YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
	1624	+ /* Buffer for error messages, and its allocated size. */
	1625	+ char yymsgbuf[128];
	1626	+ char *yymsg = yymsgbuf;
	1627	+ YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1631	1628	#endif
1632	1629
1633	1630	#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1634	1631
1635		− /* The number of symbols on the RHS of the reduced rule.
1636		− Keep to zero when no symbol should be popped. */
1637		− int yylen = 0;
	1632	+ /* The number of symbols on the RHS of the reduced rule.
	1633	+ Keep to zero when no symbol should be popped. */
	1634	+ int yylen = 0;
1638	1635
1639		− yyssp = yyss = yyssa;
1640		− yyvsp = yyvs = yyvsa;
1641		− yystacksize = YYINITDEPTH;
	1636	+ yyssp = yyss = yyssa;
	1637	+ yyvsp = yyvs = yyvsa;
	1638	+ yystacksize = YYINITDEPTH;
1642	1639
1643		− YYDPRINTF ((stderr, "Starting parse\n"));
	1640	+ YYDPRINTF ((stderr, "Starting parse\n"));
1644	1641
1645		− yystate = 0;
1646		− yyerrstatus = 0;
1647		− yynerrs = 0;
1648		− yychar = YYEMPTY; /* Cause a token to be read. */
1649		− goto yysetstate;
	1642	+ yystate = 0;
	1643	+ yyerrstatus = 0;
	1644	+ yynerrs = 0;
	1645	+ yychar = YYEMPTY; /* Cause a token to be read. */
	1646	+ goto yysetstate;
1650	1647
1651		− /*------------------------------------------------------------.
1652		− \| yynewstate -- Push a new state, which is found in yystate. \|
1653		− `------------------------------------------------------------*/
1654		−yynewstate:
1655		− /* In all cases, when you get here, the value and location stacks
1656		− have just been pushed. So pushing a state here evens the stacks. */
1657		− yyssp++;
	1648	+/*------------------------------------------------------------.
	1649	+\| yynewstate -- Push a new state, which is found in yystate. \|
	1650	+`------------------------------------------------------------*/
	1651	+ yynewstate:
	1652	+ /* In all cases, when you get here, the value and location stacks
	1653	+ have just been pushed. So pushing a state here evens the stacks. */
	1654	+ yyssp++;
1658	1655
1659		−yysetstate:
1660		− *yyssp = yystate;
	1656	+ yysetstate:
	1657	+ *yyssp = yystate;
1661	1658
1662		− if (yyss + yystacksize - 1 <= yyssp)
	1659	+ if (yyss + yystacksize - 1 <= yyssp)
1663	1660	{
1664		− /* Get the current used size of the three stacks, in elements. */
1665		− YYSIZE_T yysize = yyssp - yyss + 1;
	1661	+ /* Get the current used size of the three stacks, in elements. */
	1662	+ YYSIZE_T yysize = yyssp - yyss + 1;
1666	1663
1667	1664	#ifdef yyoverflow
1668		− {
1669		− /* Give user a chance to reallocate the stack. Use copies of
1670		− these so that the &'s don't force the real ones into
1671		− memory. */
1672		− YYSTYPE *yyvs1 = yyvs;
1673		− yytype_int16 *yyss1 = yyss;
1674		−
1675		− /* Each stack pointer address is followed by the size of the
1676		− data in use in that stack, in bytes. This used to be a
1677		− conditional around just the two extra args, but that might
1678		− be undefined if yyoverflow is a macro. */
1679		− yyoverflow (YY_("memory exhausted"),
1680		− &yyss1, yysize * sizeof (*yyssp),
1681		− &yyvs1, yysize * sizeof (*yyvsp),
1682		− &yystacksize);
1683		−
1684		− yyss = yyss1;
1685		− yyvs = yyvs1;
1686		− }
	1665	+ {
	1666	+ /* Give user a chance to reallocate the stack. Use copies of
	1667	+ these so that the &'s don't force the real ones into
	1668	+ memory. */
	1669	+ YYSTYPE *yyvs1 = yyvs;
	1670	+ yytype_int16 *yyss1 = yyss;
	1671	+
	1672	+ /* Each stack pointer address is followed by the size of the
	1673	+ data in use in that stack, in bytes. This used to be a
	1674	+ conditional around just the two extra args, but that might
	1675	+ be undefined if yyoverflow is a macro. */
	1676	+ yyoverflow (YY_("memory exhausted"),
	1677	+ &yyss1, yysize * sizeof (*yyssp),
	1678	+ &yyvs1, yysize * sizeof (*yyvsp),
	1679	+ &yystacksize);
	1680	+
	1681	+ yyss = yyss1;
	1682	+ yyvs = yyvs1;
	1683	+ }
1687	1684	#else /* no yyoverflow */
1688	1685	# ifndef YYSTACK_RELOCATE
1689		− goto yyexhaustedlab;
	1686	+ goto yyexhaustedlab;
1690	1687	# else
1691		− /* Extend the stack our own way. */
1692		− if (YYMAXDEPTH <= yystacksize)
1693		− goto yyexhaustedlab;
1694		− yystacksize *= 2;
1695		− if (YYMAXDEPTH < yystacksize)
1696		− yystacksize = YYMAXDEPTH;
1697		−
1698		− {
1699		− yytype_int16 *yyss1 = yyss;
1700		− union yyalloc *yyptr =
1701		− (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1702		− if (! yyptr)
1703		− goto yyexhaustedlab;
1704		− YYSTACK_RELOCATE (yyss_alloc, yyss);
1705		− YYSTACK_RELOCATE (yyvs_alloc, yyvs);
	1688	+ /* Extend the stack our own way. */
	1689	+ if (YYMAXDEPTH <= yystacksize)
	1690	+ goto yyexhaustedlab;
	1691	+ yystacksize *= 2;
	1692	+ if (YYMAXDEPTH < yystacksize)
	1693	+ yystacksize = YYMAXDEPTH;
	1694	+
	1695	+ {
	1696	+ yytype_int16 *yyss1 = yyss;
	1697	+ union yyalloc *yyptr =
	1698	+ (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
	1699	+ if (! yyptr)
	1700	+ goto yyexhaustedlab;
	1701	+ YYSTACK_RELOCATE (yyss_alloc, yyss);
	1702	+ YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1706	1703	# undef YYSTACK_RELOCATE
1707		− if (yyss1 != yyssa)
1708		− YYSTACK_FREE (yyss1);
1709		− }
	1704	+ if (yyss1 != yyssa)
	1705	+ YYSTACK_FREE (yyss1);
	1706	+ }
1710	1707	# endif
1711	1708	#endif /* no yyoverflow */
1712	1709
1713		− yyssp = yyss + yysize - 1;
1714		− yyvsp = yyvs + yysize - 1;
	1710	+ yyssp = yyss + yysize - 1;
	1711	+ yyvsp = yyvs + yysize - 1;
1715	1712
1716		− YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1717		− (unsigned long int) yystacksize));
	1713	+ YYDPRINTF ((stderr, "Stack size increased to %lu\n",
	1714	+ (unsigned long int) yystacksize));
1718	1715
1719		− if (yyss + yystacksize - 1 <= yyssp)
1720		− YYABORT;
	1716	+ if (yyss + yystacksize - 1 <= yyssp)
	1717	+ YYABORT;
1721	1718	}
1722	1719
1723		− YYDPRINTF ((stderr, "Entering state %d\n", yystate));
	1720	+ YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1724	1721
1725		− if (yystate == YYFINAL)
1726		− YYACCEPT;
	1722	+ if (yystate == YYFINAL)
	1723	+ YYACCEPT;
1727	1724
1728		− goto yybackup;
	1725	+ goto yybackup;
1729	1726
1730		− /*-----------.
1731		− \| yybackup. \|
1732		− `-----------*/
	1727	+/*-----------.
	1728	+\| yybackup. \|
	1729	+`-----------*/
1733	1730	yybackup:
1734	1731
1735		− /* Do appropriate processing given the current state. Read a
1736		− lookahead token if we need one and don't already have one. */
	1732	+ /* Do appropriate processing given the current state. Read a
	1733	+ lookahead token if we need one and don't already have one. */
1737	1734
1738		− /* First try to decide what to do without reference to lookahead token. */
1739		− yyn = yypact[yystate];
1740		− if (yypact_value_is_default (yyn))
1741		− goto yydefault;
	1735	+ /* First try to decide what to do without reference to lookahead token. */
	1736	+ yyn = yypact[yystate];
	1737	+ if (yypact_value_is_default (yyn))
	1738	+ goto yydefault;
1742	1739
1743		− /* Not known => get a lookahead token if don't already have one. */
	1740	+ /* Not known => get a lookahead token if don't already have one. */
1744	1741
1745		− /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1746		− if (yychar == YYEMPTY)
	1742	+ /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
	1743	+ if (yychar == YYEMPTY)
1747	1744	{
1748		− YYDPRINTF ((stderr, "Reading a token: "));
1749		− yychar = yylex ();
	1745	+ YYDPRINTF ((stderr, "Reading a token: "));
	1746	+ yychar = yylex ();
1750	1747	}
1751	1748
1752		− if (yychar <= YYEOF)
	1749	+ if (yychar <= YYEOF)
1753	1750	{
1754		− yychar = yytoken = YYEOF;
1755		− YYDPRINTF ((stderr, "Now at end of input.\n"));
	1751	+ yychar = yytoken = YYEOF;
	1752	+ YYDPRINTF ((stderr, "Now at end of input.\n"));
1756	1753	}
1757		− else
	1754	+ else
1758	1755	{
1759		− yytoken = YYTRANSLATE (yychar);
1760		− YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
	1756	+ yytoken = YYTRANSLATE (yychar);
	1757	+ YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1761	1758	}
1762	1759
1763		− /* If the proper action on seeing token YYTOKEN is to reduce or to
1764		− detect an error, take that action. */
1765		− yyn += yytoken;
1766		− if (yyn < 0 \|\| YYLAST < yyn \|\| yycheck[yyn] != yytoken)
1767		− goto yydefault;
1768		− yyn = yytable[yyn];
1769		− if (yyn <= 0)
	1760	+ /* If the proper action on seeing token YYTOKEN is to reduce or to
	1761	+ detect an error, take that action. */
	1762	+ yyn += yytoken;
	1763	+ if (yyn < 0 \|\| YYLAST < yyn \|\| yycheck[yyn] != yytoken)
	1764	+ goto yydefault;
	1765	+ yyn = yytable[yyn];
	1766	+ if (yyn <= 0)
1770	1767	{
1771		− if (yytable_value_is_error (yyn))
1772		− goto yyerrlab;
1773		− yyn = -yyn;
1774		− goto yyreduce;
	1768	+ if (yytable_value_is_error (yyn))
	1769	+ goto yyerrlab;
	1770	+ yyn = -yyn;
	1771	+ goto yyreduce;
1775	1772	}
1776	1773
1777		− /* Count tokens shifted since error; after three, turn off error
1778		− status. */
1779		− if (yyerrstatus)
1780		− yyerrstatus--;
	1774	+ /* Count tokens shifted since error; after three, turn off error
	1775	+ status. */
	1776	+ if (yyerrstatus)
	1777	+ yyerrstatus--;
1781	1778
1782		− /* Shift the lookahead token. */
1783		− YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
	1779	+ /* Shift the lookahead token. */
	1780	+ YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1784	1781
1785		− /* Discard the shifted token. */
1786		− yychar = YYEMPTY;
	1782	+ /* Discard the shifted token. */
	1783	+ yychar = YYEMPTY;
1787	1784
1788		− yystate = yyn;
1789		− YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1790		− *++yyvsp = yylval;
1791		− YY_IGNORE_MAYBE_UNINITIALIZED_END
	1785	+ yystate = yyn;
	1786	+ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
	1787	+ *++yyvsp = yylval;
	1788	+ YY_IGNORE_MAYBE_UNINITIALIZED_END
1792	1789
1793		− goto yynewstate;
	1790	+ goto yynewstate;
1794	1791
1795	1792
1796		− /*-----------------------------------------------------------.
1797		− \| yydefault -- do the default action for the current state. \|
1798		− `-----------------------------------------------------------*/
	1793	+/*-----------------------------------------------------------.
	1794	+\| yydefault -- do the default action for the current state. \|
	1795	+`-----------------------------------------------------------*/
1799	1796	yydefault:
1800		− yyn = yydefact[yystate];
1801		− if (yyn == 0)
1802		− goto yyerrlab;
1803		− goto yyreduce;
	1797	+ yyn = yydefact[yystate];
	1798	+ if (yyn == 0)
	1799	+ goto yyerrlab;
	1800	+ goto yyreduce;
1804	1801
1805	1802
1806		− /*-----------------------------.
1807		− \| yyreduce -- Do a reduction. \|
1808		− `-----------------------------*/
	1803	+/*-----------------------------.
	1804	+\| yyreduce -- Do a reduction. \|
	1805	+`-----------------------------*/
1809	1806	yyreduce:
1810		− /* yyn is the number of a rule to reduce with. */
1811		− yylen = yyr2[yyn];
	1807	+ /* yyn is the number of a rule to reduce with. */
	1808	+ yylen = yyr2[yyn];
1812	1809
1813		− /* If YYLEN is nonzero, implement the default value of the action:
1814		− '$$ = $1'.
	1810	+ /* If YYLEN is nonzero, implement the default value of the action:
	1811	+ '$$ = $1'.
1815	1812
1816		− Otherwise, the following line sets YYVAL to garbage.
1817		− This behavior is undocumented and Bison
1818		− users should not rely upon it. Assigning to YYVAL
1819		− unconditionally makes the parser a bit smaller, and it avoids a
1820		− GCC warning that YYVAL may be used uninitialized. */
1821		− yyval = yyvsp[1-yylen];
	1813	+ Otherwise, the following line sets YYVAL to garbage.
	1814	+ This behavior is undocumented and Bison
	1815	+ users should not rely upon it. Assigning to YYVAL
	1816	+ unconditionally makes the parser a bit smaller, and it avoids a
	1817	+ GCC warning that YYVAL may be used uninitialized. */
	1818	+ yyval = yyvsp[1-yylen];
1822	1819
1823	1820
1824		− YY_REDUCE_PRINT (yyn);
1825		− switch (yyn)
	1821	+ YY_REDUCE_PRINT (yyn);
	1822	+ switch (yyn)
1826	1823	{
1827		− case 2:
1828		−#line 182 "chuck.y" /* yacc.c:1646 */
	1824	+ case 2:
	1825	+#line 183 "chuck.y" /* yacc.c:1646 */
1829	1826	{ (yyval.program) = g_program = new_program( (yyvsp[0].program_section), EM_lineNum ); }
1830		−#line 1831 "chuck.tab.c" /* yacc.c:1646 */
	1827	+#line 1828 "chuck.tab.c" /* yacc.c:1646 */
1831	1828	break;
1832	1829
1833		− case 3:
1834		−#line 183 "chuck.y" /* yacc.c:1646 */
	1830	+ case 3:
	1831	+#line 184 "chuck.y" /* yacc.c:1646 */
1835	1832	{ (yyval.program) = g_program = prepend_program( (yyvsp[-1].program_section), (yyvsp[0].program), EM_lineNum ); }
1836		−#line 1837 "chuck.tab.c" /* yacc.c:1646 */
	1833	+#line 1834 "chuck.tab.c" /* yacc.c:1646 */
1837	1834	break;
1838	1835
1839		− case 4:
1840		−#line 187 "chuck.y" /* yacc.c:1646 */
	1836	+ case 4:
	1837	+#line 188 "chuck.y" /* yacc.c:1646 */
1841	1838	{ (yyval.program_section) = new_section_stmt( (yyvsp[0].stmt_list), EM_lineNum ); }
1842		−#line 1843 "chuck.tab.c" /* yacc.c:1646 */
	1839	+#line 1840 "chuck.tab.c" /* yacc.c:1646 */
1843	1840	break;
1844	1841
1845		− case 5:
1846		−#line 188 "chuck.y" /* yacc.c:1646 */
	1842	+ case 5:
	1843	+#line 189 "chuck.y" /* yacc.c:1646 */
1847	1844	{ (yyval.program_section) = new_section_func_def( (yyvsp[0].func_def), EM_lineNum ); }
1848		−#line 1849 "chuck.tab.c" /* yacc.c:1646 */
	1845	+#line 1846 "chuck.tab.c" /* yacc.c:1646 */
1849	1846	break;
1850	1847
1851		− case 6:
1852		−#line 189 "chuck.y" /* yacc.c:1646 */
	1848	+ case 6:
	1849	+#line 190 "chuck.y" /* yacc.c:1646 */
1853	1850	{ (yyval.program_section) = new_section_class_def( (yyvsp[0].class_def), EM_lineNum ); }
1854		−#line 1855 "chuck.tab.c" /* yacc.c:1646 */
	1851	+#line 1852 "chuck.tab.c" /* yacc.c:1646 */
1855	1852	break;
1856	1853
1857		− case 7:
1858		−#line 194 "chuck.y" /* yacc.c:1646 */
	1854	+ case 7:
	1855	+#line 195 "chuck.y" /* yacc.c:1646 */
1859	1856	{ (yyval.class_def) = new_class_def( (yyvsp[-5].ival), (yyvsp[-3].id_list), NULL, (yyvsp[-1].class_body), EM_lineNum ); }
1860		−#line 1861 "chuck.tab.c" /* yacc.c:1646 */
	1857	+#line 1858 "chuck.tab.c" /* yacc.c:1646 */
1861	1858	break;
1862	1859
1863		− case 8:
1864		−#line 196 "chuck.y" /* yacc.c:1646 */
	1860	+ case 8:
	1861	+#line 197 "chuck.y" /* yacc.c:1646 */
1865	1862	{ (yyval.class_def) = new_class_def( (yyvsp[-6].ival), (yyvsp[-4].id_list), (yyvsp[-3].class_ext), (yyvsp[-1].class_body), EM_lineNum ); }
1866		−#line 1867 "chuck.tab.c" /* yacc.c:1646 */
	1863	+#line 1864 "chuck.tab.c" /* yacc.c:1646 */
1867	1864	break;
1868	1865
1869		− case 9:
1870		−#line 198 "chuck.y" /* yacc.c:1646 */
	1866	+ case 9:
	1867	+#line 199 "chuck.y" /* yacc.c:1646 */
1871	1868	{ (yyval.class_def) = new_iface_def( (yyvsp[-5].ival), (yyvsp[-3].id_list), NULL, (yyvsp[-1].class_body), EM_lineNum ); }
1872		−#line 1873 "chuck.tab.c" /* yacc.c:1646 */
	1869	+#line 1870 "chuck.tab.c" /* yacc.c:1646 */
1873	1870	break;
1874	1871
1875		− case 10:
1876		−#line 200 "chuck.y" /* yacc.c:1646 */
	1872	+ case 10:
	1873	+#line 201 "chuck.y" /* yacc.c:1646 */
1877	1874	{ (yyval.class_def) = new_iface_def( (yyvsp[-6].ival), (yyvsp[-4].id_list), (yyvsp[-3].class_ext), (yyvsp[-1].class_body), EM_lineNum ); }
1878		−#line 1879 "chuck.tab.c" /* yacc.c:1646 */
	1875	+#line 1876 "chuck.tab.c" /* yacc.c:1646 */
1879	1876	break;
1880	1877
1881		− case 11:
1882		−#line 204 "chuck.y" /* yacc.c:1646 */
	1878	+ case 11:
	1879	+#line 205 "chuck.y" /* yacc.c:1646 */
1883	1880	{ (yyval.class_ext) = new_class_ext( NULL, (yyvsp[0].id_list), EM_lineNum ); }
1884		−#line 1885 "chuck.tab.c" /* yacc.c:1646 */
	1881	+#line 1882 "chuck.tab.c" /* yacc.c:1646 */
1885	1882	break;
1886	1883
1887		− case 12:
1888		−#line 205 "chuck.y" /* yacc.c:1646 */
	1884	+ case 12:
	1885	+#line 206 "chuck.y" /* yacc.c:1646 */
1889	1886	{ (yyval.class_ext) = new_class_ext( (yyvsp[0].id_list), (yyvsp[-2].id_list), EM_lineNum ); }
1890		−#line 1891 "chuck.tab.c" /* yacc.c:1646 */
	1887	+#line 1888 "chuck.tab.c" /* yacc.c:1646 */
1891	1888	break;
1892	1889
1893		− case 13:
1894		−#line 206 "chuck.y" /* yacc.c:1646 */
	1890	+ case 13:
	1891	+#line 207 "chuck.y" /* yacc.c:1646 */
1895	1892	{ (yyval.class_ext) = new_class_ext( (yyvsp[0].id_list), NULL, EM_lineNum ); }
1896		−#line 1897 "chuck.tab.c" /* yacc.c:1646 */
	1893	+#line 1894 "chuck.tab.c" /* yacc.c:1646 */
1897	1894	break;
1898	1895
1899		− case 14:
1900		−#line 207 "chuck.y" /* yacc.c:1646 */
	1896	+ case 14:
	1897	+#line 208 "chuck.y" /* yacc.c:1646 */
1901	1898	{ (yyval.class_ext) = new_class_ext( (yyvsp[-2].id_list), (yyvsp[0].id_list), EM_lineNum ); }
1902		−#line 1903 "chuck.tab.c" /* yacc.c:1646 */
	1899	+#line 1900 "chuck.tab.c" /* yacc.c:1646 */
1903	1900	break;
1904	1901
1905		− case 15:
1906		−#line 211 "chuck.y" /* yacc.c:1646 */
	1902	+ case 15:
	1903	+#line 212 "chuck.y" /* yacc.c:1646 */
1907	1904	{ (yyval.class_body) = (yyvsp[0].class_body); }
1908		−#line 1909 "chuck.tab.c" /* yacc.c:1646 */
	1905	+#line 1906 "chuck.tab.c" /* yacc.c:1646 */
1909	1906	break;
1910	1907
1911		− case 16:
1912		−#line 212 "chuck.y" /* yacc.c:1646 */
	1908	+ case 16:
	1909	+#line 213 "chuck.y" /* yacc.c:1646 */
1913	1910	{ (yyval.class_body) = NULL; }
1914		−#line 1915 "chuck.tab.c" /* yacc.c:1646 */
	1911	+#line 1912 "chuck.tab.c" /* yacc.c:1646 */
1915	1912	break;
1916	1913
1917		− case 17:
1918		−#line 216 "chuck.y" /* yacc.c:1646 */
	1914	+ case 17:
	1915	+#line 217 "chuck.y" /* yacc.c:1646 */
1919	1916	{ (yyval.class_body) = new_class_body( (yyvsp[0].program_section), EM_lineNum ); }
1920		−#line 1921 "chuck.tab.c" /* yacc.c:1646 */
	1917	+#line 1918 "chuck.tab.c" /* yacc.c:1646 */
1921	1918	break;
1922	1919
1923		− case 18:
1924		−#line 217 "chuck.y" /* yacc.c:1646 */
	1920	+ case 18:
	1921	+#line 218 "chuck.y" /* yacc.c:1646 */
1925	1922	{ (yyval.class_body) = prepend_class_body( (yyvsp[-1].program_section), (yyvsp[0].class_body), EM_lineNum ); }
1926		−#line 1927 "chuck.tab.c" /* yacc.c:1646 */
	1923	+#line 1924 "chuck.tab.c" /* yacc.c:1646 */
1927	1924	break;
1928	1925
1929		− case 19:
1930		−#line 222 "chuck.y" /* yacc.c:1646 */
	1926	+ case 19:
	1927	+#line 223 "chuck.y" /* yacc.c:1646 */
1931	1928	{ (yyval.program_section) = new_section_stmt( (yyvsp[0].stmt_list), EM_lineNum ); }
1932		−#line 1933 "chuck.tab.c" /* yacc.c:1646 */
	1929	+#line 1930 "chuck.tab.c" /* yacc.c:1646 */
1933	1930	break;
1934	1931
1935		− case 20:
1936		−#line 223 "chuck.y" /* yacc.c:1646 */
	1932	+ case 20:
	1933	+#line 224 "chuck.y" /* yacc.c:1646 */
1937	1934	{ (yyval.program_section) = new_section_func_def( (yyvsp[0].func_def), EM_lineNum ); }
1938		−#line 1939 "chuck.tab.c" /* yacc.c:1646 */
	1935	+#line 1936 "chuck.tab.c" /* yacc.c:1646 */
1939	1936	break;
1940	1937
1941		− case 21:
1942		−#line 224 "chuck.y" /* yacc.c:1646 */
	1938	+ case 21:
	1939	+#line 225 "chuck.y" /* yacc.c:1646 */
1943	1940	{ (yyval.program_section) = new_section_class_def( (yyvsp[0].class_def), EM_lineNum ); }
1944		−#line 1945 "chuck.tab.c" /* yacc.c:1646 */
	1941	+#line 1942 "chuck.tab.c" /* yacc.c:1646 */
1945	1942	break;
1946	1943
1947		− case 22:
1948		−#line 228 "chuck.y" /* yacc.c:1646 */
	1944	+ case 22:
	1945	+#line 229 "chuck.y" /* yacc.c:1646 */
1949	1946	{ (yyval.class_ext) = new_class_ext( NULL, (yyvsp[0].id_list), EM_lineNum ); }
1950		−#line 1951 "chuck.tab.c" /* yacc.c:1646 */
	1947	+#line 1948 "chuck.tab.c" /* yacc.c:1646 */
1951	1948	break;
1952	1949
1953		− case 23:
1954		−#line 232 "chuck.y" /* yacc.c:1646 */
	1950	+ case 23:
	1951	+#line 233 "chuck.y" /* yacc.c:1646 */
1955	1952	{ (yyval.id_list) = new_id_list( (yyvsp[0].sval), EM_lineNum ); }
1956		−#line 1957 "chuck.tab.c" /* yacc.c:1646 */
	1953	+#line 1954 "chuck.tab.c" /* yacc.c:1646 */
1957	1954	break;
1958	1955
1959		− case 24:
1960		−#line 233 "chuck.y" /* yacc.c:1646 */
	1956	+ case 24:
	1957	+#line 234 "chuck.y" /* yacc.c:1646 */
1961	1958	{ (yyval.id_list) = prepend_id_list( (yyvsp[-2].sval), (yyvsp[0].id_list), EM_lineNum ); }
1962		−#line 1963 "chuck.tab.c" /* yacc.c:1646 */
	1959	+#line 1960 "chuck.tab.c" /* yacc.c:1646 */
1963	1960	break;
1964	1961
1965		− case 25:
1966		−#line 237 "chuck.y" /* yacc.c:1646 */
	1962	+ case 25:
	1963	+#line 238 "chuck.y" /* yacc.c:1646 */
1967	1964	{ (yyval.id_list) = new_id_list( (yyvsp[0].sval), EM_lineNum ); }
1968		−#line 1969 "chuck.tab.c" /* yacc.c:1646 */
	1965	+#line 1966 "chuck.tab.c" /* yacc.c:1646 */
1969	1966	break;
1970	1967
1971		− case 26:
1972		−#line 238 "chuck.y" /* yacc.c:1646 */
	1968	+ case 26:
	1969	+#line 239 "chuck.y" /* yacc.c:1646 */
1973	1970	{ (yyval.id_list) = prepend_id_list( (yyvsp[-2].sval), (yyvsp[0].id_list), EM_lineNum ); }
1974		−#line 1975 "chuck.tab.c" /* yacc.c:1646 */
	1971	+#line 1972 "chuck.tab.c" /* yacc.c:1646 */
1975	1972	break;
1976	1973
1977		− case 27:
1978		−#line 243 "chuck.y" /* yacc.c:1646 */
	1974	+ case 27:
	1975	+#line 244 "chuck.y" /* yacc.c:1646 */
1979	1976	{ (yyval.func_def) = new_func_def( (yyvsp[-7].ival), (yyvsp[-6].ival), (yyvsp[-5].type_decl), (yyvsp[-4].sval), (yyvsp[-2].arg_list), (yyvsp[0].stmt), EM_lineNum ); }
1980		−#line 1981 "chuck.tab.c" /* yacc.c:1646 */
	1977	+#line 1978 "chuck.tab.c" /* yacc.c:1646 */
1981	1978	break;
1982	1979
1983		− case 28:
1984		−#line 245 "chuck.y" /* yacc.c:1646 */
	1980	+ case 28:
	1981	+#line 246 "chuck.y" /* yacc.c:1646 */
1985	1982	{ (yyval.func_def) = new_func_def( (yyvsp[-6].ival), (yyvsp[-5].ival), (yyvsp[-4].type_decl), (yyvsp[-3].sval), NULL, (yyvsp[0].stmt), EM_lineNum ); }
1986		−#line 1987 "chuck.tab.c" /* yacc.c:1646 */
	1983	+#line 1984 "chuck.tab.c" /* yacc.c:1646 */
1987	1984	break;
1988	1985
1989		− case 29:
1990		−#line 247 "chuck.y" /* yacc.c:1646 */
	1986	+ case 29:
	1987	+#line 248 "chuck.y" /* yacc.c:1646 */
1991	1988	{ (yyval.func_def) = new_func_def( (yyvsp[-7].ival), (yyvsp[-6].ival), (yyvsp[-5].type_decl), (yyvsp[-4].sval), (yyvsp[-2].arg_list), NULL, EM_lineNum ); }
1992		−#line 1993 "chuck.tab.c" /* yacc.c:1646 */
	1989	+#line 1990 "chuck.tab.c" /* yacc.c:1646 */
1993	1990	break;
1994	1991
1995		− case 30:
1996		−#line 249 "chuck.y" /* yacc.c:1646 */
	1992	+ case 30:
	1993	+#line 250 "chuck.y" /* yacc.c:1646 */
1997	1994	{ (yyval.func_def) = new_func_def( (yyvsp[-6].ival), (yyvsp[-5].ival), (yyvsp[-4].type_decl), (yyvsp[-3].sval), NULL, NULL, EM_lineNum ); }
1998		−#line 1999 "chuck.tab.c" /* yacc.c:1646 */
	1995	+#line 1996 "chuck.tab.c" /* yacc.c:1646 */
1999	1996	break;
2000	1997
2001		− case 31:
2002		−#line 253 "chuck.y" /* yacc.c:1646 */
	1998	+ case 31:
	1999	+#line 254 "chuck.y" /* yacc.c:1646 */
2003	2000	{ (yyval.ival) = ae_key_public; }
2004		−#line 2005 "chuck.tab.c" /* yacc.c:1646 */
	2001	+#line 2002 "chuck.tab.c" /* yacc.c:1646 */
2005	2002	break;
2006	2003
2007		− case 32:
2008		−#line 254 "chuck.y" /* yacc.c:1646 */
	2004	+ case 32:
	2005	+#line 255 "chuck.y" /* yacc.c:1646 */
2009	2006	{ (yyval.ival) = ae_key_private; }
2010		−#line 2011 "chuck.tab.c" /* yacc.c:1646 */
	2007	+#line 2008 "chuck.tab.c" /* yacc.c:1646 */
2011	2008	break;
2012	2009
2013		− case 33:
2014		−#line 255 "chuck.y" /* yacc.c:1646 */
	2010	+ case 33:
	2011	+#line 256 "chuck.y" /* yacc.c:1646 */
2015	2012	{ (yyval.ival) = ae_key_private; }
2016		−#line 2017 "chuck.tab.c" /* yacc.c:1646 */
	2013	+#line 2014 "chuck.tab.c" /* yacc.c:1646 */
2017	2014	break;
2018	2015
2019		− case 34:
2020		−#line 259 "chuck.y" /* yacc.c:1646 */
	2016	+ case 34:
	2017	+#line 260 "chuck.y" /* yacc.c:1646 */
2021	2018	{ (yyval.ival) = ae_key_func; }
2022		−#line 2023 "chuck.tab.c" /* yacc.c:1646 */
	2019	+#line 2020 "chuck.tab.c" /* yacc.c:1646 */
2023	2020	break;
2024	2021
2025		− case 35:
2026		−#line 260 "chuck.y" /* yacc.c:1646 */
	2022	+ case 35:
	2023	+#line 261 "chuck.y" /* yacc.c:1646 */
2027	2024	{ (yyval.ival) = ae_key_public; }
2028		−#line 2029 "chuck.tab.c" /* yacc.c:1646 */
	2025	+#line 2026 "chuck.tab.c" /* yacc.c:1646 */
2029	2026	break;
2030	2027
2031		− case 36:
2032		−#line 261 "chuck.y" /* yacc.c:1646 */
	2028	+ case 36:
	2029	+#line 262 "chuck.y" /* yacc.c:1646 */
2033	2030	{ (yyval.ival) = ae_key_protected; }
2034		−#line 2035 "chuck.tab.c" /* yacc.c:1646 */
	2031	+#line 2032 "chuck.tab.c" /* yacc.c:1646 */
2035	2032	break;
2036	2033
2037		− case 37:
2038		−#line 262 "chuck.y" /* yacc.c:1646 */
	2034	+ case 37:
	2035	+#line 263 "chuck.y" /* yacc.c:1646 */
2039	2036	{ (yyval.ival) = ae_key_private; }
2040		−#line 2041 "chuck.tab.c" /* yacc.c:1646 */
	2037	+#line 2038 "chuck.tab.c" /* yacc.c:1646 */
2041	2038	break;
2042	2039
2043		− case 38:
2044		−#line 266 "chuck.y" /* yacc.c:1646 */
	2040	+ case 38:
	2041	+#line 267 "chuck.y" /* yacc.c:1646 */
2045	2042	{ (yyval.ival) = ae_key_static; }
2046		−#line 2047 "chuck.tab.c" /* yacc.c:1646 */
	2043	+#line 2044 "chuck.tab.c" /* yacc.c:1646 */
2047	2044	break;
2048	2045
2049		− case 39:
2050		−#line 267 "chuck.y" /* yacc.c:1646 */
	2046	+ case 39:
	2047	+#line 268 "chuck.y" /* yacc.c:1646 */
2051	2048	{ (yyval.ival) = ae_key_abstract; }
2052		−#line 2053 "chuck.tab.c" /* yacc.c:1646 */
	2049	+#line 2050 "chuck.tab.c" /* yacc.c:1646 */
2053	2050	break;
2054	2051
2055		− case 40:
2056		−#line 268 "chuck.y" /* yacc.c:1646 */
	2052	+ case 40:
	2053	+#line 269 "chuck.y" /* yacc.c:1646 */
2057	2054	{ (yyval.ival) = ae_key_instance; }
2058		−#line 2059 "chuck.tab.c" /* yacc.c:1646 */
	2055	+#line 2056 "chuck.tab.c" /* yacc.c:1646 */
2059	2056	break;
2060	2057
2061		− case 41:
2062		−#line 272 "chuck.y" /* yacc.c:1646 */
	2058	+ case 41:
	2059	+#line 273 "chuck.y" /* yacc.c:1646 */
2063	2060	{ (yyval.type_decl) = new_type_decl( new_id_list( (yyvsp[0].sval), EM_lineNum ), 0, EM_lineNum ); }
2064		−#line 2065 "chuck.tab.c" /* yacc.c:1646 */
	2061	+#line 2062 "chuck.tab.c" /* yacc.c:1646 */
2065	2062	break;
2066	2063
2067		− case 42:
2068		−#line 273 "chuck.y" /* yacc.c:1646 */
	2064	+ case 42:
	2065	+#line 274 "chuck.y" /* yacc.c:1646 */
2069	2066	{ (yyval.type_decl) = new_type_decl( new_id_list( (yyvsp[-1].sval), EM_lineNum ), 1, EM_lineNum ); }
2070		−#line 2071 "chuck.tab.c" /* yacc.c:1646 */
	2067	+#line 2068 "chuck.tab.c" /* yacc.c:1646 */
2071	2068	break;
2072	2069
2073		− case 43:
2074		−#line 277 "chuck.y" /* yacc.c:1646 */
	2070	+ case 43:
	2071	+#line 278 "chuck.y" /* yacc.c:1646 */
2075	2072	{ (yyval.type_decl) = new_type_decl( (yyvsp[-1].id_list), 0, EM_lineNum ); }
2076		−#line 2077 "chuck.tab.c" /* yacc.c:1646 */
	2073	+#line 2074 "chuck.tab.c" /* yacc.c:1646 */
2077	2074	break;
2078	2075
2079		− case 44:
2080		−#line 278 "chuck.y" /* yacc.c:1646 */
	2076	+ case 44:
	2077	+#line 279 "chuck.y" /* yacc.c:1646 */
2081	2078	{ (yyval.type_decl) = new_type_decl( (yyvsp[-2].id_list), 1, EM_lineNum ); }
2082		−#line 2083 "chuck.tab.c" /* yacc.c:1646 */
	2079	+#line 2080 "chuck.tab.c" /* yacc.c:1646 */
2083	2080	break;
2084	2081
2085		− case 45:
2086		−#line 287 "chuck.y" /* yacc.c:1646 */
	2082	+ case 45:
	2083	+#line 288 "chuck.y" /* yacc.c:1646 */
2087	2084	{ (yyval.type_decl) = (yyvsp[0].type_decl); }
2088		−#line 2089 "chuck.tab.c" /* yacc.c:1646 */
	2085	+#line 2086 "chuck.tab.c" /* yacc.c:1646 */
2089	2086	break;
2090	2087
2091		− case 46:
2092		−#line 288 "chuck.y" /* yacc.c:1646 */
	2088	+ case 46:
	2089	+#line 289 "chuck.y" /* yacc.c:1646 */
2093	2090	{ (yyval.type_decl) = (yyvsp[0].type_decl); }
2094		−#line 2095 "chuck.tab.c" /* yacc.c:1646 */
	2091	+#line 2092 "chuck.tab.c" /* yacc.c:1646 */
2095	2092	break;
2096	2093
2097		− case 47:
2098		−#line 293 "chuck.y" /* yacc.c:1646 */
	2094	+ case 47:
	2095	+#line 294 "chuck.y" /* yacc.c:1646 */
2099	2096	{ (yyval.type_decl) = (yyvsp[0].type_decl); }
2100		−#line 2101 "chuck.tab.c" /* yacc.c:1646 */
	2097	+#line 2098 "chuck.tab.c" /* yacc.c:1646 */
2101	2098	break;
2102	2099
2103		− case 48:
2104		−#line 294 "chuck.y" /* yacc.c:1646 */
	2100	+ case 48:
	2101	+#line 295 "chuck.y" /* yacc.c:1646 */
2105	2102	{ (yyval.type_decl) = add_type_decl_array( (yyvsp[-1].type_decl), (yyvsp[0].array_sub), EM_lineNum ); }
2106		−#line 2107 "chuck.tab.c" /* yacc.c:1646 */
	2103	+#line 2104 "chuck.tab.c" /* yacc.c:1646 */
2107	2104	break;
2108	2105
2109		− case 49:
2110		−#line 298 "chuck.y" /* yacc.c:1646 */
	2106	+ case 49:
	2107	+#line 299 "chuck.y" /* yacc.c:1646 */
2111	2108	{ (yyval.arg_list) = new_arg_list( (yyvsp[-1].type_decl), (yyvsp[0].var_decl), EM_lineNum ); }
2112		−#line 2113 "chuck.tab.c" /* yacc.c:1646 */
	2109	+#line 2110 "chuck.tab.c" /* yacc.c:1646 */
2113	2110	break;
2114	2111
2115		− case 50:
2116		−#line 299 "chuck.y" /* yacc.c:1646 */
	2112	+ case 50:
	2113	+#line 300 "chuck.y" /* yacc.c:1646 */
2117	2114	{ (yyval.arg_list) = prepend_arg_list( (yyvsp[-3].type_decl), (yyvsp[-2].var_decl), (yyvsp[0].arg_list), EM_lineNum ); }
2118		−#line 2119 "chuck.tab.c" /* yacc.c:1646 */
	2115	+#line 2116 "chuck.tab.c" /* yacc.c:1646 */
2119	2116	break;
2120	2117
2121		− case 51:
2122		−#line 303 "chuck.y" /* yacc.c:1646 */
	2118	+ case 51:
	2119	+#line 304 "chuck.y" /* yacc.c:1646 */
2123	2120	{ (yyval.stmt_list) = new_stmt_list( (yyvsp[0].stmt), EM_lineNum ); }
2124		−#line 2125 "chuck.tab.c" /* yacc.c:1646 */
	2121	+#line 2122 "chuck.tab.c" /* yacc.c:1646 */
2125	2122	break;
2126	2123
2127		− case 52:
2128		−#line 304 "chuck.y" /* yacc.c:1646 */
	2124	+ case 52:
	2125	+#line 305 "chuck.y" /* yacc.c:1646 */
2129	2126	{ (yyval.stmt_list) = prepend_stmt_list( (yyvsp[-1].stmt), (yyvsp[0].stmt_list), EM_lineNum ); }
2130		−#line 2131 "chuck.tab.c" /* yacc.c:1646 */
	2127	+#line 2128 "chuck.tab.c" /* yacc.c:1646 */
2131	2128	break;
2132	2129
2133		− case 53:
2134		−#line 308 "chuck.y" /* yacc.c:1646 */
2135		− { (yyval.stmt) = (yyvsp[0].stmt); }
2136		−#line 2137 "chuck.tab.c" /* yacc.c:1646 */
2137		− break;
2138		−
2139		− case 54:
	2130	+ case 53:
2140	2131	#line 309 "chuck.y" /* yacc.c:1646 */
2141	2132	{ (yyval.stmt) = (yyvsp[0].stmt); }
2142		−#line 2143 "chuck.tab.c" /* yacc.c:1646 */
	2133	+#line 2134 "chuck.tab.c" /* yacc.c:1646 */
2143	2134	break;
2144	2135
2145		− case 55:
	2136	+ case 54:
2146	2137	#line 310 "chuck.y" /* yacc.c:1646 */
2147	2138	{ (yyval.stmt) = (yyvsp[0].stmt); }
2148		−#line 2149 "chuck.tab.c" /* yacc.c:1646 */
	2139	+#line 2140 "chuck.tab.c" /* yacc.c:1646 */
2149	2140	break;
2150	2141
2151		− case 56:
	2142	+ case 55:
2152	2143	#line 311 "chuck.y" /* yacc.c:1646 */
2153	2144	{ (yyval.stmt) = (yyvsp[0].stmt); }
2154		−#line 2155 "chuck.tab.c" /* yacc.c:1646 */
	2145	+#line 2146 "chuck.tab.c" /* yacc.c:1646 */
2155	2146	break;
2156	2147
2157		− case 57:
2158		−#line 313 "chuck.y" /* yacc.c:1646 */
	2148	+ case 56:
	2149	+#line 312 "chuck.y" /* yacc.c:1646 */
2159	2150	{ (yyval.stmt) = (yyvsp[0].stmt); }
2160		−#line 2161 "chuck.tab.c" /* yacc.c:1646 */
	2151	+#line 2152 "chuck.tab.c" /* yacc.c:1646 */
2161	2152	break;
2162	2153
2163		− case 58:
2164		−#line 317 "chuck.y" /* yacc.c:1646 */
2165		− { (yyval.stmt) = new_stmt_from_return( NULL, EM_lineNum ); }
2166		−#line 2167 "chuck.tab.c" /* yacc.c:1646 */
	2154	+ case 57:
	2155	+#line 314 "chuck.y" /* yacc.c:1646 */
	2156	+ { (yyval.stmt) = (yyvsp[0].stmt); }
	2157	+#line 2158 "chuck.tab.c" /* yacc.c:1646 */
2167	2158	break;
2168	2159
2169		− case 59:
	2160	+ case 58:
2170	2161	#line 318 "chuck.y" /* yacc.c:1646 */
2171		− { (yyval.stmt) = new_stmt_from_return( (yyvsp[-1].exp), EM_lineNum ); }
2172		−#line 2173 "chuck.tab.c" /* yacc.c:1646 */
	2162	+ { (yyval.stmt) = new_stmt_from_return( NULL, EM_lineNum ); }
	2163	+#line 2164 "chuck.tab.c" /* yacc.c:1646 */
2173	2164	break;
2174	2165
2175		− case 60:
	2166	+ case 59:
2176	2167	#line 319 "chuck.y" /* yacc.c:1646 */
2177		− { (yyval.stmt) = new_stmt_from_break( EM_lineNum ); }
2178		−#line 2179 "chuck.tab.c" /* yacc.c:1646 */
	2168	+ { (yyval.stmt) = new_stmt_from_return( (yyvsp[-1].exp), EM_lineNum ); }
	2169	+#line 2170 "chuck.tab.c" /* yacc.c:1646 */
2179	2170	break;
2180	2171
2181		− case 61:
	2172	+ case 60:
2182	2173	#line 320 "chuck.y" /* yacc.c:1646 */
	2174	+ { (yyval.stmt) = new_stmt_from_break( EM_lineNum ); }
	2175	+#line 2176 "chuck.tab.c" /* yacc.c:1646 */
	2176	+ break;
	2177	+
	2178	+ case 61:
	2179	+#line 321 "chuck.y" /* yacc.c:1646 */
2183	2180	{ (yyval.stmt) = new_stmt_from_continue( EM_lineNum ); }
2184		−#line 2185 "chuck.tab.c" /* yacc.c:1646 */
	2181	+#line 2182 "chuck.tab.c" /* yacc.c:1646 */
2185	2182	break;
2186	2183
2187		− case 62:
2188		−#line 325 "chuck.y" /* yacc.c:1646 */
	2184	+ case 62:
	2185	+#line 326 "chuck.y" /* yacc.c:1646 */
2189	2186	{ (yyval.stmt) = new_stmt_from_if( (yyvsp[-2].exp), (yyvsp[0].stmt), NULL, EM_lineNum ); }
2190		−#line 2191 "chuck.tab.c" /* yacc.c:1646 */
	2187	+#line 2188 "chuck.tab.c" /* yacc.c:1646 */
2191	2188	break;
2192	2189
2193		− case 63:
2194		−#line 327 "chuck.y" /* yacc.c:1646 */
	2190	+ case 63:
	2191	+#line 328 "chuck.y" /* yacc.c:1646 */
2195	2192	{ (yyval.stmt) = new_stmt_from_if( (yyvsp[-4].exp), (yyvsp[-2].stmt), (yyvsp[0].stmt), EM_lineNum ); }
2196		−#line 2197 "chuck.tab.c" /* yacc.c:1646 */
	2193	+#line 2194 "chuck.tab.c" /* yacc.c:1646 */
2197	2194	break;
2198	2195
2199		− case 64:
2200		−#line 332 "chuck.y" /* yacc.c:1646 */
	2196	+ case 64:
	2197	+#line 333 "chuck.y" /* yacc.c:1646 */
2201	2198	{ (yyval.stmt) = new_stmt_from_while( (yyvsp[-2].exp), (yyvsp[0].stmt), EM_lineNum ); }
2202		−#line 2203 "chuck.tab.c" /* yacc.c:1646 */
	2199	+#line 2200 "chuck.tab.c" /* yacc.c:1646 */
2203	2200	break;
2204	2201
2205		− case 65:
2206		−#line 334 "chuck.y" /* yacc.c:1646 */
	2202	+ case 65:
	2203	+#line 335 "chuck.y" /* yacc.c:1646 */
2207	2204	{ (yyval.stmt) = new_stmt_from_do_while( (yyvsp[-2].exp), (yyvsp[-5].stmt), EM_lineNum ); }
2208		−#line 2209 "chuck.tab.c" /* yacc.c:1646 */
	2205	+#line 2206 "chuck.tab.c" /* yacc.c:1646 */
2209	2206	break;
2210	2207
2211		− case 66:
2212		−#line 336 "chuck.y" /* yacc.c:1646 */
	2208	+ case 66:
	2209	+#line 337 "chuck.y" /* yacc.c:1646 */
2213	2210	{ (yyval.stmt) = new_stmt_from_for( (yyvsp[-3].stmt), (yyvsp[-2].stmt), NULL, (yyvsp[0].stmt), EM_lineNum ); }
2214		−#line 2215 "chuck.tab.c" /* yacc.c:1646 */
	2211	+#line 2212 "chuck.tab.c" /* yacc.c:1646 */
2215	2212	break;
2216	2213
2217		− case 67:
2218		−#line 338 "chuck.y" /* yacc.c:1646 */
	2214	+ case 67:
	2215	+#line 339 "chuck.y" /* yacc.c:1646 */
2219	2216	{ (yyval.stmt) = new_stmt_from_for( (yyvsp[-4].stmt), (yyvsp[-3].stmt), (yyvsp[-2].exp), (yyvsp[0].stmt), EM_lineNum ); }
2220		−#line 2221 "chuck.tab.c" /* yacc.c:1646 */
	2217	+#line 2218 "chuck.tab.c" /* yacc.c:1646 */
2221	2218	break;
2222	2219
2223		− case 68:
2224		−#line 340 "chuck.y" /* yacc.c:1646 */
	2220	+ case 68:
	2221	+#line 341 "chuck.y" /* yacc.c:1646 */
2225	2222	{ (yyval.stmt) = new_stmt_from_until( (yyvsp[-2].exp), (yyvsp[0].stmt), EM_lineNum ); }
2226		−#line 2227 "chuck.tab.c" /* yacc.c:1646 */
	2223	+#line 2224 "chuck.tab.c" /* yacc.c:1646 */
2227	2224	break;
2228	2225
2229		− case 69:
2230		−#line 342 "chuck.y" /* yacc.c:1646 */
	2226	+ case 69:
	2227	+#line 343 "chuck.y" /* yacc.c:1646 */
2231	2228	{ (yyval.stmt) = new_stmt_from_do_until( (yyvsp[-2].exp), (yyvsp[-5].stmt), EM_lineNum ); }
2232		−#line 2233 "chuck.tab.c" /* yacc.c:1646 */
	2229	+#line 2230 "chuck.tab.c" /* yacc.c:1646 */
2233	2230	break;
2234	2231
2235		− case 70:
2236		−#line 344 "chuck.y" /* yacc.c:1646 */
	2232	+ case 70:
	2233	+#line 345 "chuck.y" /* yacc.c:1646 */
2237	2234	{ (yyval.stmt) = new_stmt_from_loop( (yyvsp[-2].exp), (yyvsp[0].stmt), EM_lineNum ); }
2238		−#line 2239 "chuck.tab.c" /* yacc.c:1646 */
	2235	+#line 2236 "chuck.tab.c" /* yacc.c:1646 */
2239	2236	break;
2240	2237
2241		− case 71:
2242		−#line 348 "chuck.y" /* yacc.c:1646 */
	2238	+ case 71:
	2239	+#line 349 "chuck.y" /* yacc.c:1646 */
2243	2240	{ (yyval.stmt) = new_stmt_from_code( NULL, EM_lineNum ); }
2244		−#line 2245 "chuck.tab.c" /* yacc.c:1646 */
	2241	+#line 2242 "chuck.tab.c" /* yacc.c:1646 */
2245	2242	break;
2246	2243
2247		− case 72:
2248		−#line 349 "chuck.y" /* yacc.c:1646 */
	2244	+ case 72:
	2245	+#line 350 "chuck.y" /* yacc.c:1646 */
2249	2246	{ (yyval.stmt) = new_stmt_from_code( (yyvsp[-1].stmt_list), EM_lineNum ); }
2250		−#line 2251 "chuck.tab.c" /* yacc.c:1646 */
	2247	+#line 2248 "chuck.tab.c" /* yacc.c:1646 */
2251	2248	break;
2252	2249
2253		− case 73:
2254		−#line 353 "chuck.y" /* yacc.c:1646 */
	2250	+ case 73:
	2251	+#line 354 "chuck.y" /* yacc.c:1646 */
2255	2252	{ (yyval.stmt) = NULL; }
2256		−#line 2257 "chuck.tab.c" /* yacc.c:1646 */
	2253	+#line 2254 "chuck.tab.c" /* yacc.c:1646 */
2257	2254	break;
2258	2255
2259		− case 74:
2260		−#line 354 "chuck.y" /* yacc.c:1646 */
	2256	+ case 74:
	2257	+#line 355 "chuck.y" /* yacc.c:1646 */
2261	2258	{ (yyval.stmt) = new_stmt_from_expression( (yyvsp[-1].exp), EM_lineNum ); }
2262		−#line 2263 "chuck.tab.c" /* yacc.c:1646 */
	2259	+#line 2260 "chuck.tab.c" /* yacc.c:1646 */
2263	2260	break;
2264	2261
2265		− case 75:
2266		−#line 358 "chuck.y" /* yacc.c:1646 */
	2262	+ case 75:
	2263	+#line 359 "chuck.y" /* yacc.c:1646 */
2267	2264	{ (yyval.exp) = (yyvsp[0].exp); }
2268		−#line 2269 "chuck.tab.c" /* yacc.c:1646 */
	2265	+#line 2266 "chuck.tab.c" /* yacc.c:1646 */
2269	2266	break;
2270	2267
2271		− case 76:
2272		−#line 359 "chuck.y" /* yacc.c:1646 */
	2268	+ case 76:
	2269	+#line 360 "chuck.y" /* yacc.c:1646 */
2273	2270	{ (yyval.exp) = prepend_expression( (yyvsp[-2].exp), (yyvsp[0].exp), EM_lineNum ); }
2274		−#line 2275 "chuck.tab.c" /* yacc.c:1646 */
	2271	+#line 2272 "chuck.tab.c" /* yacc.c:1646 */
2275	2272	break;
2276	2273
2277		− case 77:
2278		−#line 363 "chuck.y" /* yacc.c:1646 */
	2274	+ case 77:
	2275	+#line 364 "chuck.y" /* yacc.c:1646 */
2279	2276	{ (yyval.exp) = (yyvsp[0].exp); }
2280		−#line 2281 "chuck.tab.c" /* yacc.c:1646 */
	2277	+#line 2278 "chuck.tab.c" /* yacc.c:1646 */
2281	2278	break;
2282	2279
2283		− case 78:
2284		−#line 365 "chuck.y" /* yacc.c:1646 */
	2280	+ case 78:
	2281	+#line 366 "chuck.y" /* yacc.c:1646 */
2285	2282	{ (yyval.exp) = new_exp_from_binary( (yyvsp[-2].exp), (yyvsp[-1].ival), (yyvsp[0].exp), EM_lineNum ); }
2286		−#line 2287 "chuck.tab.c" /* yacc.c:1646 */
	2283	+#line 2284 "chuck.tab.c" /* yacc.c:1646 */
2287	2284	break;
2288	2285
2289		− case 79:
2290		−#line 369 "chuck.y" /* yacc.c:1646 */
	2286	+ case 79:
	2287	+#line 370 "chuck.y" /* yacc.c:1646 */
2291	2288	{ (yyval.exp) = (yyvsp[0].exp); }
2292		−#line 2293 "chuck.tab.c" /* yacc.c:1646 */
	2289	+#line 2290 "chuck.tab.c" /* yacc.c:1646 */
2293	2290	break;
2294	2291
2295		− case 80:
2296		−#line 371 "chuck.y" /* yacc.c:1646 */
	2292	+ case 80:
	2293	+#line 372 "chuck.y" /* yacc.c:1646 */
2297	2294	{ (yyval.exp) = new_exp_from_binary( (yyvsp[-2].exp), (yyvsp[-1].ival), (yyvsp[0].exp), EM_lineNum ); }
2298		−#line 2299 "chuck.tab.c" /* yacc.c:1646 */
	2295	+#line 2296 "chuck.tab.c" /* yacc.c:1646 */
2299	2296	break;
2300	2297
2301		− case 81:
2302		−#line 375 "chuck.y" /* yacc.c:1646 */
	2298	+ case 81:
	2299	+#line 376 "chuck.y" /* yacc.c:1646 */
2303	2300	{ (yyval.array_sub) = new_array_sub( (yyvsp[-1].exp), EM_lineNum ); }
2304		−#line 2305 "chuck.tab.c" /* yacc.c:1646 */
	2301	+#line 2302 "chuck.tab.c" /* yacc.c:1646 */
2305	2302	break;
2306	2303
2307		− case 82:
2308		−#line 377 "chuck.y" /* yacc.c:1646 */
	2304	+ case 82:
	2305	+#line 378 "chuck.y" /* yacc.c:1646 */
2309	2306	{ (yyval.array_sub) = prepend_array_sub( (yyvsp[0].array_sub), (yyvsp[-2].exp), EM_lineNum ); }
2310		−#line 2311 "chuck.tab.c" /* yacc.c:1646 */
	2307	+#line 2308 "chuck.tab.c" /* yacc.c:1646 */
2311	2308	break;
2312	2309
2313		− case 83:
2314		−#line 381 "chuck.y" /* yacc.c:1646 */
	2310	+ case 83:
	2311	+#line 382 "chuck.y" /* yacc.c:1646 */
2315	2312	{ (yyval.array_sub) = new_array_sub( NULL, EM_lineNum ); }
2316		−#line 2317 "chuck.tab.c" /* yacc.c:1646 */
	2313	+#line 2314 "chuck.tab.c" /* yacc.c:1646 */
2317	2314	break;
2318	2315
2319		− case 84:
2320		−#line 382 "chuck.y" /* yacc.c:1646 */
	2316	+ case 84:
	2317	+#line 383 "chuck.y" /* yacc.c:1646 */
2321	2318	{ (yyval.array_sub) = prepend_array_sub( (yyvsp[-2].array_sub), NULL, EM_lineNum ); }
2322		−#line 2323 "chuck.tab.c" /* yacc.c:1646 */
	2319	+#line 2320 "chuck.tab.c" /* yacc.c:1646 */
2323	2320	break;
2324	2321
2325		− case 85:
2326		−#line 386 "chuck.y" /* yacc.c:1646 */
	2322	+ case 85:
	2323	+#line 387 "chuck.y" /* yacc.c:1646 */
2327	2324	{ (yyval.exp) = (yyvsp[0].exp); }
2328		−#line 2329 "chuck.tab.c" /* yacc.c:1646 */
	2325	+#line 2326 "chuck.tab.c" /* yacc.c:1646 */
2329	2326	break;
2330	2327
2331		− case 86:
2332		−#line 387 "chuck.y" /* yacc.c:1646 */
	2328	+ case 86:
	2329	+#line 388 "chuck.y" /* yacc.c:1646 */
2333	2330	{ (yyval.exp) = new_exp_decl( (yyvsp[-1].type_decl), (yyvsp[0].var_decl_list), 0, EM_lineNum ); }
2334		−#line 2335 "chuck.tab.c" /* yacc.c:1646 */
	2331	+#line 2332 "chuck.tab.c" /* yacc.c:1646 */
2335	2332	break;
2336	2333
2337		− case 87:
2338		−#line 388 "chuck.y" /* yacc.c:1646 */
	2334	+ case 87:
	2335	+#line 389 "chuck.y" /* yacc.c:1646 */
2339	2336	{ (yyval.exp) = new_exp_decl_external( (yyvsp[-1].type_decl), (yyvsp[0].var_decl_list), 0, EM_lineNum ); }
2340		−#line 2341 "chuck.tab.c" /* yacc.c:1646 */
	2337	+#line 2338 "chuck.tab.c" /* yacc.c:1646 */
2341	2338	break;
2342	2339
2343		− case 88:
2344		−#line 389 "chuck.y" /* yacc.c:1646 */
	2340	+ case 88:
	2341	+#line 390 "chuck.y" /* yacc.c:1646 */
	2342	+ { (yyval.exp) = new_exp_decl_global( (yyvsp[-1].type_decl), (yyvsp[0].var_decl_list), 0, EM_lineNum ); }
	2343	+#line 2344 "chuck.tab.c" /* yacc.c:1646 */
	2344	+ break;
	2345	+
	2346	+ case 89:
	2347	+#line 391 "chuck.y" /* yacc.c:1646 */
2345	2348	{ (yyval.exp) = new_exp_decl( (yyvsp[-1].type_decl), (yyvsp[0].var_decl_list), 1, EM_lineNum ); }
2346		−#line 2347 "chuck.tab.c" /* yacc.c:1646 */
	2349	+#line 2350 "chuck.tab.c" /* yacc.c:1646 */
2347	2350	break;
2348	2351
2349		− case 89:
2350		−#line 390 "chuck.y" /* yacc.c:1646 */
	2352	+ case 90:
	2353	+#line 392 "chuck.y" /* yacc.c:1646 */
2351	2354	{ (yyval.exp) = new_exp_decl( NULL, (yyvsp[0].var_decl_list), 0, EM_lineNum ); }
2352		−#line 2353 "chuck.tab.c" /* yacc.c:1646 */
	2355	+#line 2356 "chuck.tab.c" /* yacc.c:1646 */
2353	2356	break;
2354	2357
2355		− case 90:
2356		−#line 391 "chuck.y" /* yacc.c:1646 */
	2358	+ case 91:
	2359	+#line 393 "chuck.y" /* yacc.c:1646 */
2357	2360	{ (yyval.exp) = new_exp_decl( NULL, (yyvsp[0].var_decl_list), 1, EM_lineNum ); }
2358		−#line 2359 "chuck.tab.c" /* yacc.c:1646 */
	2361	+#line 2362 "chuck.tab.c" /* yacc.c:1646 */
2359	2362	break;
2360	2363
2361		− case 91:
2362		−#line 395 "chuck.y" /* yacc.c:1646 */
	2364	+ case 92:
	2365	+#line 397 "chuck.y" /* yacc.c:1646 */
2363	2366	{ (yyval.var_decl_list) = new_var_decl_list( (yyvsp[0].var_decl), EM_lineNum ); }
2364		−#line 2365 "chuck.tab.c" /* yacc.c:1646 */
	2367	+#line 2368 "chuck.tab.c" /* yacc.c:1646 */
2365	2368	break;
2366	2369
2367		− case 92:
2368		−#line 396 "chuck.y" /* yacc.c:1646 */
	2370	+ case 93:
	2371	+#line 398 "chuck.y" /* yacc.c:1646 */
2369	2372	{ (yyval.var_decl_list) = prepend_var_decl_list( (yyvsp[-2].var_decl), (yyvsp[0].var_decl_list), EM_lineNum ); }
2370		−#line 2371 "chuck.tab.c" /* yacc.c:1646 */
	2373	+#line 2374 "chuck.tab.c" /* yacc.c:1646 */
2371	2374	break;
2372	2375
2373		− case 93:
2374		−#line 400 "chuck.y" /* yacc.c:1646 */
	2376	+ case 94:
	2377	+#line 402 "chuck.y" /* yacc.c:1646 */
2375	2378	{ (yyval.var_decl) = new_var_decl( (yyvsp[0].sval), NULL, EM_lineNum ); }
2376		−#line 2377 "chuck.tab.c" /* yacc.c:1646 */
	2379	+#line 2380 "chuck.tab.c" /* yacc.c:1646 */
2377	2380	break;
2378	2381
2379		− case 94:
2380		−#line 401 "chuck.y" /* yacc.c:1646 */
	2382	+ case 95:
	2383	+#line 403 "chuck.y" /* yacc.c:1646 */
2381	2384	{ (yyval.var_decl) = new_var_decl( (yyvsp[-1].sval), (yyvsp[0].array_sub), EM_lineNum ); }
2382		−#line 2383 "chuck.tab.c" /* yacc.c:1646 */
	2385	+#line 2386 "chuck.tab.c" /* yacc.c:1646 */
2383	2386	break;
2384	2387
2385		− case 95:
2386		−#line 402 "chuck.y" /* yacc.c:1646 */
	2388	+ case 96:
	2389	+#line 404 "chuck.y" /* yacc.c:1646 */
2387	2390	{ (yyval.var_decl) = new_var_decl( (yyvsp[-1].sval), (yyvsp[0].array_sub), EM_lineNum ); }
2388		−#line 2389 "chuck.tab.c" /* yacc.c:1646 */
	2391	+#line 2392 "chuck.tab.c" /* yacc.c:1646 */
2389	2392	break;
2390	2393
2391		− case 96:
2392		−#line 407 "chuck.y" /* yacc.c:1646 */
	2394	+ case 97:
	2395	+#line 409 "chuck.y" /* yacc.c:1646 */
2393	2396	{ (yyval.complex_exp) = new_complex( (yyvsp[-1].exp), EM_lineNum ); }
2394		−#line 2395 "chuck.tab.c" /* yacc.c:1646 */
	2397	+#line 2398 "chuck.tab.c" /* yacc.c:1646 */
2395	2398	break;
2396	2399
2397		− case 97:
2398		−#line 412 "chuck.y" /* yacc.c:1646 */
	2400	+ case 98:
	2401	+#line 414 "chuck.y" /* yacc.c:1646 */
2399	2402	{ (yyval.polar_exp) = new_polar( (yyvsp[-1].exp), EM_lineNum ); }
2400		−#line 2401 "chuck.tab.c" /* yacc.c:1646 */
	2403	+#line 2404 "chuck.tab.c" /* yacc.c:1646 */
2401	2404	break;
2402	2405
2403		− case 98:
2404		−#line 417 "chuck.y" /* yacc.c:1646 */
	2406	+ case 99:
	2407	+#line 419 "chuck.y" /* yacc.c:1646 */
2405	2408	{ (yyval.vec_exp) = new_vec( (yyvsp[-1].exp), EM_lineNum ); }
2406		−#line 2407 "chuck.tab.c" /* yacc.c:1646 */
	2409	+#line 2410 "chuck.tab.c" /* yacc.c:1646 */
2407	2410	break;
2408	2411
2409		− case 99:
2410		−#line 421 "chuck.y" /* yacc.c:1646 */
	2412	+ case 100:
	2413	+#line 423 "chuck.y" /* yacc.c:1646 */
2411	2414	{ (yyval.ival) = ae_op_chuck; }
2412		−#line 2413 "chuck.tab.c" /* yacc.c:1646 */
	2415	+#line 2416 "chuck.tab.c" /* yacc.c:1646 */
2413	2416	break;
2414	2417
2415		− case 100:
2416		−#line 422 "chuck.y" /* yacc.c:1646 */
	2418	+ case 101:
	2419	+#line 424 "chuck.y" /* yacc.c:1646 */
2417	2420	{ (yyval.ival) = ae_op_at_chuck; }
2418		−#line 2419 "chuck.tab.c" /* yacc.c:1646 */
	2421	+#line 2422 "chuck.tab.c" /* yacc.c:1646 */
2419	2422	break;
2420	2423
2421		− case 101:
2422		−#line 423 "chuck.y" /* yacc.c:1646 */
	2424	+ case 102:
	2425	+#line 425 "chuck.y" /* yacc.c:1646 */
2423	2426	{ (yyval.ival) = ae_op_plus_chuck; }
2424		−#line 2425 "chuck.tab.c" /* yacc.c:1646 */
	2427	+#line 2428 "chuck.tab.c" /* yacc.c:1646 */
2425	2428	break;
2426	2429
2427		− case 102:
2428		−#line 424 "chuck.y" /* yacc.c:1646 */
	2430	+ case 103:
	2431	+#line 426 "chuck.y" /* yacc.c:1646 */
2429	2432	{ (yyval.ival) = ae_op_minus_chuck; }
2430		−#line 2431 "chuck.tab.c" /* yacc.c:1646 */
	2433	+#line 2434 "chuck.tab.c" /* yacc.c:1646 */
2431	2434	break;
2432	2435
2433		− case 103:
2434		−#line 425 "chuck.y" /* yacc.c:1646 */
	2436	+ case 104:
	2437	+#line 427 "chuck.y" /* yacc.c:1646 */
2435	2438	{ (yyval.ival) = ae_op_times_chuck; }
2436		−#line 2437 "chuck.tab.c" /* yacc.c:1646 */
	2439	+#line 2440 "chuck.tab.c" /* yacc.c:1646 */
2437	2440	break;
2438	2441
2439		− case 104:
2440		−#line 426 "chuck.y" /* yacc.c:1646 */
	2442	+ case 105:
	2443	+#line 428 "chuck.y" /* yacc.c:1646 */
2441	2444	{ (yyval.ival) = ae_op_divide_chuck; }
2442		−#line 2443 "chuck.tab.c" /* yacc.c:1646 */
	2445	+#line 2446 "chuck.tab.c" /* yacc.c:1646 */
2443	2446	break;
2444	2447
2445		− case 105:
2446		−#line 427 "chuck.y" /* yacc.c:1646 */
	2448	+ case 106:
	2449	+#line 429 "chuck.y" /* yacc.c:1646 */
2447	2450	{ (yyval.ival) = ae_op_shift_right_chuck; }
2448		−#line 2449 "chuck.tab.c" /* yacc.c:1646 */
	2451	+#line 2452 "chuck.tab.c" /* yacc.c:1646 */
2449	2452	break;
2450	2453
2451		− case 106:
2452		−#line 428 "chuck.y" /* yacc.c:1646 */
	2454	+ case 107:
	2455	+#line 430 "chuck.y" /* yacc.c:1646 */
2453	2456	{ (yyval.ival) = ae_op_shift_left_chuck; }
2454		−#line 2455 "chuck.tab.c" /* yacc.c:1646 */
	2457	+#line 2458 "chuck.tab.c" /* yacc.c:1646 */
2455	2458	break;
2456	2459
2457		− case 107:
2458		−#line 429 "chuck.y" /* yacc.c:1646 */
	2460	+ case 108:
	2461	+#line 431 "chuck.y" /* yacc.c:1646 */
2459	2462	{ (yyval.ival) = ae_op_percent_chuck; }
2460		−#line 2461 "chuck.tab.c" /* yacc.c:1646 */
	2463	+#line 2464 "chuck.tab.c" /* yacc.c:1646 */
2461	2464	break;
2462	2465
2463		− case 108:
2464		−#line 430 "chuck.y" /* yacc.c:1646 */
	2466	+ case 109:
	2467	+#line 432 "chuck.y" /* yacc.c:1646 */
2465	2468	{ (yyval.ival) = ae_op_unchuck; }
2466		−#line 2467 "chuck.tab.c" /* yacc.c:1646 */
	2469	+#line 2470 "chuck.tab.c" /* yacc.c:1646 */
2467	2470	break;
2468	2471
2469		− case 109:
2470		−#line 431 "chuck.y" /* yacc.c:1646 */
	2472	+ case 110:
	2473	+#line 433 "chuck.y" /* yacc.c:1646 */
2471	2474	{ (yyval.ival) = ae_op_upchuck; }
2472		−#line 2473 "chuck.tab.c" /* yacc.c:1646 */
	2475	+#line 2476 "chuck.tab.c" /* yacc.c:1646 */
2473	2476	break;
2474	2477
2475		− case 110:
2476		−#line 432 "chuck.y" /* yacc.c:1646 */
	2478	+ case 111:
	2479	+#line 434 "chuck.y" /* yacc.c:1646 */
2477	2480	{ (yyval.ival) = ae_op_s_and_chuck; }
2478		−#line 2479 "chuck.tab.c" /* yacc.c:1646 */
	2481	+#line 2482 "chuck.tab.c" /* yacc.c:1646 */
2479	2482	break;
2480	2483
2481		− case 111:
2482		−#line 433 "chuck.y" /* yacc.c:1646 */
	2484	+ case 112:
	2485	+#line 435 "chuck.y" /* yacc.c:1646 */
2483	2486	{ (yyval.ival) = ae_op_s_or_chuck; }
2484		−#line 2485 "chuck.tab.c" /* yacc.c:1646 */
	2487	+#line 2488 "chuck.tab.c" /* yacc.c:1646 */
2485	2488	break;
2486	2489
2487		− case 112:
2488		−#line 434 "chuck.y" /* yacc.c:1646 */
	2490	+ case 113:
	2491	+#line 436 "chuck.y" /* yacc.c:1646 */
2489	2492	{ (yyval.ival) = ae_op_s_xor_chuck; }
2490		−#line 2491 "chuck.tab.c" /* yacc.c:1646 */
	2493	+#line 2494 "chuck.tab.c" /* yacc.c:1646 */
2491	2494	break;
2492	2495
2493		− case 113:
2494		−#line 438 "chuck.y" /* yacc.c:1646 */
	2496	+ case 114:
	2497	+#line 440 "chuck.y" /* yacc.c:1646 */
2495	2498	{ (yyval.ival) = ae_op_arrow_left; }
2496		−#line 2497 "chuck.tab.c" /* yacc.c:1646 */
	2499	+#line 2500 "chuck.tab.c" /* yacc.c:1646 */
2497	2500	break;
2498	2501
2499		− case 114:
2500		−#line 439 "chuck.y" /* yacc.c:1646 */
	2502	+ case 115:
	2503	+#line 441 "chuck.y" /* yacc.c:1646 */
2501	2504	{ (yyval.ival) = ae_op_arrow_right; }
2502		−#line 2503 "chuck.tab.c" /* yacc.c:1646 */
	2505	+#line 2506 "chuck.tab.c" /* yacc.c:1646 */
2503	2506	break;
2504	2507
2505		− case 115:
2506		−#line 443 "chuck.y" /* yacc.c:1646 */
	2508	+ case 116:
	2509	+#line 445 "chuck.y" /* yacc.c:1646 */
2507	2510	{ (yyval.exp) = (yyvsp[0].exp); }
2508		−#line 2509 "chuck.tab.c" /* yacc.c:1646 */
	2511	+#line 2512 "chuck.tab.c" /* yacc.c:1646 */
2509	2512	break;
2510	2513
2511		− case 116:
2512		−#line 445 "chuck.y" /* yacc.c:1646 */
	2514	+ case 117:
	2515	+#line 447 "chuck.y" /* yacc.c:1646 */
2513	2516	{ (yyval.exp) = new_exp_from_if( (yyvsp[-4].exp), (yyvsp[-2].exp), (yyvsp[0].exp), EM_lineNum ); }
2514		−#line 2515 "chuck.tab.c" /* yacc.c:1646 */
	2517	+#line 2518 "chuck.tab.c" /* yacc.c:1646 */
2515	2518	break;
2516	2519
2517		− case 117:
2518		−#line 449 "chuck.y" /* yacc.c:1646 */
	2520	+ case 118:
	2521	+#line 451 "chuck.y" /* yacc.c:1646 */
2519	2522	{ (yyval.exp) = (yyvsp[0].exp); }
2520		−#line 2521 "chuck.tab.c" /* yacc.c:1646 */
	2523	+#line 2524 "chuck.tab.c" /* yacc.c:1646 */
2521	2524	break;
2522	2525
2523		− case 118:
2524		−#line 451 "chuck.y" /* yacc.c:1646 */
	2526	+ case 119:
	2527	+#line 453 "chuck.y" /* yacc.c:1646 */
2525	2528	{ (yyval.exp) = new_exp_from_binary( (yyvsp[-2].exp), ae_op_or, (yyvsp[0].exp), EM_lineNum ); }
2526		−#line 2527 "chuck.tab.c" /* yacc.c:1646 */
	2529	+#line 2530 "chuck.tab.c" /* yacc.c:1646 */
2527	2530	break;
2528	2531
2529		− case 119:
2530		−#line 455 "chuck.y" /* yacc.c:1646 */
	2532	+ case 120:
	2533	+#line 457 "chuck.y" /* yacc.c:1646 */
2531	2534	{ (yyval.exp) = (yyvsp[0].exp); }
2532		−#line 2533 "chuck.tab.c" /* yacc.c:1646 */
	2535	+#line 2536 "chuck.tab.c" /* yacc.c:1646 */
2533	2536	break;
2534	2537
2535		− case 120:
2536		−#line 457 "chuck.y" /* yacc.c:1646 */
	2538	+ case 121:
	2539	+#line 459 "chuck.y" /* yacc.c:1646 */
2537	2540	{ (yyval.exp) = new_exp_from_binary( (yyvsp[-2].exp), ae_op_and, (yyvsp[0].exp), EM_lineNum ); }
2538		−#line 2539 "chuck.tab.c" /* yacc.c:1646 */
	2541	+#line 2542 "chuck.tab.c" /* yacc.c:1646 */
2539	2542	break;
2540	2543
2541		− case 121:
2542		−#line 461 "chuck.y" /* yacc.c:1646 */
	2544	+ case 122:
	2545	+#line 463 "chuck.y" /* yacc.c:1646 */
2543	2546	{ (yyval.exp) = (yyvsp[0].exp); }
2544		−#line 2545 "chuck.tab.c" /* yacc.c:1646 */
	2547	+#line 2548 "chuck.tab.c" /* yacc.c:1646 */
2545	2548	break;
2546	2549
2547		− case 122:
2548		−#line 463 "chuck.y" /* yacc.c:1646 */
	2550	+ case 123:
	2551	+#line 465 "chuck.y" /* yacc.c:1646 */
2549	2552	{ (yyval.exp) = new_exp_from_binary( (yyvsp[-2].exp), ae_op_s_or, (yyvsp[0].exp), EM_lineNum ); }
2550		−#line 2551 "chuck.tab.c" /* yacc.c:1646 */
	2553	+#line 2554 "chuck.tab.c" /* yacc.c:1646 */
2551	2554	break;
2552	2555
2553		− case 123:
2554		−#line 467 "chuck.y" /* yacc.c:1646 */
	2556	+ case 124:
	2557	+#line 469 "chuck.y" /* yacc.c:1646 */
2555	2558	{ (yyval.exp) = (yyvsp[0].exp); }
2556		−#line 2557 "chuck.tab.c" /* yacc.c:1646 */
	2559	+#line 2560 "chuck.tab.c" /* yacc.c:1646 */
2557	2560	break;
2558	2561
2559		− case 124:
2560		−#line 469 "chuck.y" /* yacc.c:1646 */
	2562	+ case 125:
	2563	+#line 471 "chuck.y" /* yacc.c:1646 */
2561	2564	{ (yyval.exp) = new_exp_from_binary( (yyvsp[-2].exp), ae_op_s_xor, (yyvsp[0].exp), EM_lineNum ); }
2562		−#line 2563 "chuck.tab.c" /* yacc.c:1646 */
	2565	+#line 2566 "chuck.tab.c" /* yacc.c:1646 */
2563	2566	break;
2564	2567
2565		− case 125:
2566		−#line 473 "chuck.y" /* yacc.c:1646 */
	2568	+ case 126:
	2569	+#line 475 "chuck.y" /* yacc.c:1646 */
2567	2570	{ (yyval.exp) = (yyvsp[0].exp); }
2568		−#line 2569 "chuck.tab.c" /* yacc.c:1646 */
	2571	+#line 2572 "chuck.tab.c" /* yacc.c:1646 */
2569	2572	break;
2570	2573
2571		− case 126:
2572		−#line 475 "chuck.y" /* yacc.c:1646 */
	2574	+ case 127:
	2575	+#line 477 "chuck.y" /* yacc.c:1646 */
2573	2576	{ (yyval.exp) = new_exp_from_binary( (yyvsp[-2].exp), ae_op_s_and, (yyvsp[0].exp), EM_lineNum ); }
2574		−#line 2575 "chuck.tab.c" /* yacc.c:1646 */
	2577	+#line 2578 "chuck.tab.c" /* yacc.c:1646 */
2575	2578	break;
2576	2579
2577		− case 127:
2578		−#line 479 "chuck.y" /* yacc.c:1646 */
	2580	+ case 128:
	2581	+#line 481 "chuck.y" /* yacc.c:1646 */
2579	2582	{ (yyval.exp) = (yyvsp[0].exp); }
2580		−#line 2581 "chuck.tab.c" /* yacc.c:1646 */
	2583	+#line 2584 "chuck.tab.c" /* yacc.c:1646 */
2581	2584	break;
2582	2585
2583		− case 128:
2584		−#line 481 "chuck.y" /* yacc.c:1646 */
	2586	+ case 129:
	2587	+#line 483 "chuck.y" /* yacc.c:1646 */
2585	2588	{ (yyval.exp) = new_exp_from_binary( (yyvsp[-2].exp), ae_op_eq, (yyvsp[0].exp), EM_lineNum ); }
2586		−#line 2587 "chuck.tab.c" /* yacc.c:1646 */
	2589	+#line 2590 "chuck.tab.c" /* yacc.c:1646 */
2587	2590	break;
2588	2591
2589		− case 129:
2590		−#line 483 "chuck.y" /* yacc.c:1646 */
	2592	+ case 130:
	2593	+#line 485 "chuck.y" /* yacc.c:1646 */
2591	2594	{ (yyval.exp) = new_exp_from_binary( (yyvsp[-2].exp), ae_op_neq, (yyvsp[0].exp), EM_lineNum ); }
2592		−#line 2593 "chuck.tab.c" /* yacc.c:1646 */
	2595	+#line 2596 "chuck.tab.c" /* yacc.c:1646 */
2593	2596	break;
2594	2597
2595		− case 130:
2596		−#line 487 "chuck.y" /* yacc.c:1646 */
	2598	+ case 131:
	2599	+#line 489 "chuck.y" /* yacc.c:1646 */
2597	2600	{ (yyval.exp) = (yyvsp[0].exp); }
2598		−#line 2599 "chuck.tab.c" /* yacc.c:1646 */
	2601	+#line 2602 "chuck.tab.c" /* yacc.c:1646 */
2599	2602	break;
2600	2603
2601		− case 131:
2602		−#line 489 "chuck.y" /* yacc.c:1646 */
	2604	+ case 132:
	2605	+#line 491 "chuck.y" /* yacc.c:1646 */
2603	2606	{ (yyval.exp) = new_exp_from_binary( (yyvsp[-2].exp), ae_op_lt, (yyvsp[0].exp), EM_lineNum ); }
2604		−#line 2605 "chuck.tab.c" /* yacc.c:1646 */
	2607	+#line 2608 "chuck.tab.c" /* yacc.c:1646 */
2605	2608	break;
2606	2609
2607		− case 132:
2608		−#line 491 "chuck.y" /* yacc.c:1646 */
	2610	+ case 133:
	2611	+#line 493 "chuck.y" /* yacc.c:1646 */
2609	2612	{ (yyval.exp) = new_exp_from_binary( (yyvsp[-2].exp), ae_op_gt, (yyvsp[0].exp), EM_lineNum ); }
2610		−#line 2611 "chuck.tab.c" /* yacc.c:1646 */
	2613	+#line 2614 "chuck.tab.c" /* yacc.c:1646 */
2611	2614	break;
2612	2615
2613		− case 133:
2614		−#line 493 "chuck.y" /* yacc.c:1646 */
	2616	+ case 134:
	2617	+#line 495 "chuck.y" /* yacc.c:1646 */
2615	2618	{ (yyval.exp) = new_exp_from_binary( (yyvsp[-2].exp), ae_op_le, (yyvsp[0].exp), EM_lineNum ); }
2616		−#line 2617 "chuck.tab.c" /* yacc.c:1646 */
	2619	+#line 2620 "chuck.tab.c" /* yacc.c:1646 */
2617	2620	break;
2618	2621
2619		− case 134:
2620		−#line 495 "chuck.y" /* yacc.c:1646 */
	2622	+ case 135:
	2623	+#line 497 "chuck.y" /* yacc.c:1646 */
2621	2624	{ (yyval.exp) = new_exp_from_binary( (yyvsp[-2].exp), ae_op_ge, (yyvsp[0].exp), EM_lineNum ); }
2622		−#line 2623 "chuck.tab.c" /* yacc.c:1646 */
	2625	+#line 2626 "chuck.tab.c" /* yacc.c:1646 */
2623	2626	break;
2624	2627
2625		− case 135:
2626		−#line 499 "chuck.y" /* yacc.c:1646 */
	2628	+ case 136:
	2629	+#line 501 "chuck.y" /* yacc.c:1646 */
2627	2630	{ (yyval.exp) = (yyvsp[0].exp); }
2628		−#line 2629 "chuck.tab.c" /* yacc.c:1646 */
	2631	+#line 2632 "chuck.tab.c" /* yacc.c:1646 */
2629	2632	break;
2630	2633
2631		− case 136:
2632		−#line 501 "chuck.y" /* yacc.c:1646 */
	2634	+ case 137:
	2635	+#line 503 "chuck.y" /* yacc.c:1646 */
2633	2636	{ (yyval.exp) = new_exp_from_binary( (yyvsp[-2].exp), ae_op_shift_left, (yyvsp[0].exp), EM_lineNum ); }
2634		−#line 2635 "chuck.tab.c" /* yacc.c:1646 */
	2637	+#line 2638 "chuck.tab.c" /* yacc.c:1646 */
2635	2638	break;
2636	2639
2637		− case 137:
2638		−#line 503 "chuck.y" /* yacc.c:1646 */
	2640	+ case 138:
	2641	+#line 505 "chuck.y" /* yacc.c:1646 */
2639	2642	{ (yyval.exp) = new_exp_from_binary( (yyvsp[-2].exp), ae_op_shift_right, (yyvsp[0].exp), EM_lineNum ); }
2640		−#line 2641 "chuck.tab.c" /* yacc.c:1646 */
	2643	+#line 2644 "chuck.tab.c" /* yacc.c:1646 */
2641	2644	break;
2642	2645
2643		− case 138:
2644		−#line 507 "chuck.y" /* yacc.c:1646 */
	2646	+ case 139:
	2647	+#line 509 "chuck.y" /* yacc.c:1646 */
2645	2648	{ (yyval.exp) = (yyvsp[0].exp); }
2646		−#line 2647 "chuck.tab.c" /* yacc.c:1646 */
	2649	+#line 2650 "chuck.tab.c" /* yacc.c:1646 */
2647	2650	break;
2648	2651
2649		− case 139:
2650		−#line 509 "chuck.y" /* yacc.c:1646 */
	2652	+ case 140:
	2653	+#line 511 "chuck.y" /* yacc.c:1646 */
2651	2654	{ (yyval.exp) = new_exp_from_binary( (yyvsp[-2].exp), ae_op_plus, (yyvsp[0].exp), EM_lineNum ); }
2652		−#line 2653 "chuck.tab.c" /* yacc.c:1646 */
	2655	+#line 2656 "chuck.tab.c" /* yacc.c:1646 */
2653	2656	break;
2654	2657
2655		− case 140:
2656		−#line 511 "chuck.y" /* yacc.c:1646 */
	2658	+ case 141:
	2659	+#line 513 "chuck.y" /* yacc.c:1646 */
2657	2660	{ (yyval.exp) = new_exp_from_binary( (yyvsp[-2].exp), ae_op_minus, (yyvsp[0].exp), EM_lineNum ); }
2658		−#line 2659 "chuck.tab.c" /* yacc.c:1646 */
	2661	+#line 2662 "chuck.tab.c" /* yacc.c:1646 */
2659	2662	break;
2660	2663
2661		− case 141:
2662		−#line 515 "chuck.y" /* yacc.c:1646 */
	2664	+ case 142:
	2665	+#line 517 "chuck.y" /* yacc.c:1646 */
2663	2666	{ (yyval.exp) = (yyvsp[0].exp); }
2664		−#line 2665 "chuck.tab.c" /* yacc.c:1646 */
	2667	+#line 2668 "chuck.tab.c" /* yacc.c:1646 */
2665	2668	break;
2666	2669
2667		− case 142:
2668		−#line 517 "chuck.y" /* yacc.c:1646 */
	2670	+ case 143:
	2671	+#line 519 "chuck.y" /* yacc.c:1646 */
2669	2672	{ (yyval.exp) = new_exp_from_binary( (yyvsp[-2].exp), ae_op_times, (yyvsp[0].exp), EM_lineNum ); }
2670		−#line 2671 "chuck.tab.c" /* yacc.c:1646 */
	2673	+#line 2674 "chuck.tab.c" /* yacc.c:1646 */
2671	2674	break;
2672	2675
2673		− case 143:
2674		−#line 519 "chuck.y" /* yacc.c:1646 */
	2676	+ case 144:
	2677	+#line 521 "chuck.y" /* yacc.c:1646 */
2675	2678	{ (yyval.exp) = new_exp_from_binary( (yyvsp[-2].exp), ae_op_divide, (yyvsp[0].exp), EM_lineNum ); }
2676		−#line 2677 "chuck.tab.c" /* yacc.c:1646 */
	2679	+#line 2680 "chuck.tab.c" /* yacc.c:1646 */
2677	2680	break;
2678	2681
2679		− case 144:
2680		−#line 521 "chuck.y" /* yacc.c:1646 */
	2682	+ case 145:
	2683	+#line 523 "chuck.y" /* yacc.c:1646 */
2681	2684	{ (yyval.exp) = new_exp_from_binary( (yyvsp[-2].exp), ae_op_percent, (yyvsp[0].exp), EM_lineNum ); }
2682		−#line 2683 "chuck.tab.c" /* yacc.c:1646 */
	2685	+#line 2686 "chuck.tab.c" /* yacc.c:1646 */
2683	2686	break;
2684	2687
2685		− case 145:
2686		−#line 525 "chuck.y" /* yacc.c:1646 */
	2688	+ case 146:
	2689	+#line 527 "chuck.y" /* yacc.c:1646 */
2687	2690	{ (yyval.exp) = (yyvsp[0].exp); }
2688		−#line 2689 "chuck.tab.c" /* yacc.c:1646 */
	2691	+#line 2692 "chuck.tab.c" /* yacc.c:1646 */
2689	2692	break;
2690	2693
2691		− case 146:
2692		−#line 527 "chuck.y" /* yacc.c:1646 */
	2694	+ case 147:
	2695	+#line 529 "chuck.y" /* yacc.c:1646 */
2693	2696	{ (yyval.exp) = new_exp_from_binary( (yyvsp[-2].exp), ae_op_tilda, (yyvsp[0].exp), EM_lineNum ); }
2694		−#line 2695 "chuck.tab.c" /* yacc.c:1646 */
	2697	+#line 2698 "chuck.tab.c" /* yacc.c:1646 */
2695	2698	break;
2696	2699
2697		− case 147:
2698		−#line 531 "chuck.y" /* yacc.c:1646 */
	2700	+ case 148:
	2701	+#line 533 "chuck.y" /* yacc.c:1646 */
2699	2702	{ (yyval.exp) = (yyvsp[0].exp); }
2700		−#line 2701 "chuck.tab.c" /* yacc.c:1646 */
	2703	+#line 2704 "chuck.tab.c" /* yacc.c:1646 */
2701	2704	break;
2702	2705
2703		− case 148:
2704		−#line 533 "chuck.y" /* yacc.c:1646 */
	2706	+ case 149:
	2707	+#line 535 "chuck.y" /* yacc.c:1646 */
2705	2708	{ (yyval.exp) = new_exp_from_cast( (yyvsp[0].type_decl), (yyvsp[-2].exp), EM_lineNum ); }
2706		−#line 2707 "chuck.tab.c" /* yacc.c:1646 */
	2709	+#line 2710 "chuck.tab.c" /* yacc.c:1646 */
2707	2710	break;
2708	2711
2709		− case 149:
2710		−#line 537 "chuck.y" /* yacc.c:1646 */
	2712	+ case 150:
	2713	+#line 539 "chuck.y" /* yacc.c:1646 */
2711	2714	{ (yyval.exp) = (yyvsp[0].exp); }
2712		−#line 2713 "chuck.tab.c" /* yacc.c:1646 */
	2715	+#line 2716 "chuck.tab.c" /* yacc.c:1646 */
2713	2716	break;
2714	2717
2715		− case 150:
2716		−#line 539 "chuck.y" /* yacc.c:1646 */
	2718	+ case 151:
	2719	+#line 541 "chuck.y" /* yacc.c:1646 */
2717	2720	{ (yyval.exp) = new_exp_from_unary( ae_op_plusplus, (yyvsp[0].exp), EM_lineNum ); }
2718		−#line 2719 "chuck.tab.c" /* yacc.c:1646 */
	2721	+#line 2722 "chuck.tab.c" /* yacc.c:1646 */
2719	2722	break;
2720	2723
2721		− case 151:
2722		−#line 541 "chuck.y" /* yacc.c:1646 */
	2724	+ case 152:
	2725	+#line 543 "chuck.y" /* yacc.c:1646 */
2723	2726	{ (yyval.exp) = new_exp_from_unary( ae_op_minusminus, (yyvsp[0].exp), EM_lineNum ); }
2724		−#line 2725 "chuck.tab.c" /* yacc.c:1646 */
	2727	+#line 2728 "chuck.tab.c" /* yacc.c:1646 */
2725	2728	break;
2726	2729
2727		− case 152:
2728		−#line 543 "chuck.y" /* yacc.c:1646 */
	2730	+ case 153:
	2731	+#line 545 "chuck.y" /* yacc.c:1646 */
2729	2732	{ (yyval.exp) = new_exp_from_unary( (yyvsp[-1].ival), (yyvsp[0].exp), EM_lineNum ); }
2730		−#line 2731 "chuck.tab.c" /* yacc.c:1646 */
	2733	+#line 2734 "chuck.tab.c" /* yacc.c:1646 */
2731	2734	break;
2732	2735
2733		− case 153:
2734		−#line 545 "chuck.y" /* yacc.c:1646 */
	2736	+ case 154:
	2737	+#line 547 "chuck.y" /* yacc.c:1646 */
2735	2738	{ (yyval.exp) = new_exp_from_unary( ae_op_typeof, (yyvsp[0].exp), EM_lineNum ); }
2736		−#line 2737 "chuck.tab.c" /* yacc.c:1646 */
	2739	+#line 2740 "chuck.tab.c" /* yacc.c:1646 */
2737	2740	break;
2738	2741
2739		− case 154:
2740		−#line 547 "chuck.y" /* yacc.c:1646 */
	2742	+ case 155:
	2743	+#line 549 "chuck.y" /* yacc.c:1646 */
2741	2744	{ (yyval.exp) = new_exp_from_unary( ae_op_sizeof, (yyvsp[0].exp), EM_lineNum ); }
2742		−#line 2743 "chuck.tab.c" /* yacc.c:1646 */
	2745	+#line 2746 "chuck.tab.c" /* yacc.c:1646 */
2743	2746	break;
2744	2747
2745		− case 155:
2746		−#line 549 "chuck.y" /* yacc.c:1646 */
	2748	+ case 156:
	2749	+#line 551 "chuck.y" /* yacc.c:1646 */
2747	2750	{ (yyval.exp) = new_exp_from_unary2( ae_op_new, (yyvsp[0].type_decl), NULL, EM_lineNum ); }
2748		−#line 2749 "chuck.tab.c" /* yacc.c:1646 */
	2751	+#line 2752 "chuck.tab.c" /* yacc.c:1646 */
2749	2752	break;
2750	2753
2751		− case 156:
2752		−#line 551 "chuck.y" /* yacc.c:1646 */
	2754	+ case 157:
	2755	+#line 553 "chuck.y" /* yacc.c:1646 */
2753	2756	{ (yyval.exp) = new_exp_from_unary2( ae_op_new, (yyvsp[-1].type_decl), (yyvsp[0].array_sub), EM_lineNum ); }
2754		−#line 2755 "chuck.tab.c" /* yacc.c:1646 */
	2757	+#line 2758 "chuck.tab.c" /* yacc.c:1646 */
2755	2758	break;
2756	2759
2757		− case 157:
2758		−#line 557 "chuck.y" /* yacc.c:1646 */
	2760	+ case 158:
	2761	+#line 559 "chuck.y" /* yacc.c:1646 */
2759	2762	{ (yyval.ival) = ae_op_plus; }
2760		−#line 2761 "chuck.tab.c" /* yacc.c:1646 */
	2763	+#line 2764 "chuck.tab.c" /* yacc.c:1646 */
2761	2764	break;
2762	2765
2763		− case 158:
2764		−#line 558 "chuck.y" /* yacc.c:1646 */
	2766	+ case 159:
	2767	+#line 560 "chuck.y" /* yacc.c:1646 */
2765	2768	{ (yyval.ival) = ae_op_minus; }
2766		−#line 2767 "chuck.tab.c" /* yacc.c:1646 */
	2769	+#line 2770 "chuck.tab.c" /* yacc.c:1646 */
2767	2770	break;
2768	2771
2769		− case 159:
2770		−#line 559 "chuck.y" /* yacc.c:1646 */
	2772	+ case 160:
	2773	+#line 561 "chuck.y" /* yacc.c:1646 */
2771	2774	{ (yyval.ival) = ae_op_tilda; }
2772		−#line 2773 "chuck.tab.c" /* yacc.c:1646 */
	2775	+#line 2776 "chuck.tab.c" /* yacc.c:1646 */
2773	2776	break;
2774	2777
2775		− case 160:
2776		−#line 560 "chuck.y" /* yacc.c:1646 */
	2778	+ case 161:
	2779	+#line 562 "chuck.y" /* yacc.c:1646 */
2777	2780	{ (yyval.ival) = ae_op_exclamation; }
2778		−#line 2779 "chuck.tab.c" /* yacc.c:1646 */
	2781	+#line 2782 "chuck.tab.c" /* yacc.c:1646 */
2779	2782	break;
2780	2783
2781		− case 161:
2782		−#line 561 "chuck.y" /* yacc.c:1646 */
	2784	+ case 162:
	2785	+#line 563 "chuck.y" /* yacc.c:1646 */
2783	2786	{ (yyval.ival) = ae_op_times; }
2784		−#line 2785 "chuck.tab.c" /* yacc.c:1646 */
	2787	+#line 2788 "chuck.tab.c" /* yacc.c:1646 */
2785	2788	break;
2786	2789
2787		− case 162:
2788		−#line 562 "chuck.y" /* yacc.c:1646 */
	2790	+ case 163:
	2791	+#line 564 "chuck.y" /* yacc.c:1646 */
2789	2792	{ (yyval.ival) = ae_op_spork; }
2790		−#line 2791 "chuck.tab.c" /* yacc.c:1646 */
	2793	+#line 2794 "chuck.tab.c" /* yacc.c:1646 */
2791	2794	break;
2792	2795
2793		− case 164:
2794		−#line 569 "chuck.y" /* yacc.c:1646 */
	2796	+ case 165:
	2797	+#line 571 "chuck.y" /* yacc.c:1646 */
2795	2798	{ (yyval.exp) = new_exp_from_dur( (yyvsp[-2].exp), (yyvsp[0].exp), EM_lineNum ); }
2796		−#line 2797 "chuck.tab.c" /* yacc.c:1646 */
	2799	+#line 2800 "chuck.tab.c" /* yacc.c:1646 */
2797	2800	break;
2798	2801
2799		− case 165:
2800		−#line 573 "chuck.y" /* yacc.c:1646 */
	2802	+ case 166:
	2803	+#line 575 "chuck.y" /* yacc.c:1646 */
2801	2804	{ (yyval.exp) = (yyvsp[0].exp); }
2802		−#line 2803 "chuck.tab.c" /* yacc.c:1646 */
	2805	+#line 2806 "chuck.tab.c" /* yacc.c:1646 */
2803	2806	break;
2804	2807
2805		− case 166:
2806		−#line 575 "chuck.y" /* yacc.c:1646 */
	2808	+ case 167:
	2809	+#line 577 "chuck.y" /* yacc.c:1646 */
2807	2810	{ (yyval.exp) = new_exp_from_array( (yyvsp[-1].exp), (yyvsp[0].array_sub), EM_lineNum ); }
2808		−#line 2809 "chuck.tab.c" /* yacc.c:1646 */
	2811	+#line 2812 "chuck.tab.c" /* yacc.c:1646 */
2809	2812	break;
2810	2813
2811		− case 167:
2812		−#line 577 "chuck.y" /* yacc.c:1646 */
	2814	+ case 168:
	2815	+#line 579 "chuck.y" /* yacc.c:1646 */
2813	2816	{ (yyval.exp) = new_exp_from_func_call( (yyvsp[-2].exp), NULL, EM_lineNum ); }
2814		−#line 2815 "chuck.tab.c" /* yacc.c:1646 */
	2817	+#line 2818 "chuck.tab.c" /* yacc.c:1646 */
2815	2818	break;
2816	2819
2817		− case 168:
2818		−#line 579 "chuck.y" /* yacc.c:1646 */
	2820	+ case 169:
	2821	+#line 581 "chuck.y" /* yacc.c:1646 */
2819	2822	{ (yyval.exp) = new_exp_from_func_call( (yyvsp[-3].exp), (yyvsp[-1].exp), EM_lineNum ); }
2820		−#line 2821 "chuck.tab.c" /* yacc.c:1646 */
	2823	+#line 2824 "chuck.tab.c" /* yacc.c:1646 */
2821	2824	break;
2822	2825
2823		− case 169:
2824		−#line 581 "chuck.y" /* yacc.c:1646 */
	2826	+ case 170:
	2827	+#line 583 "chuck.y" /* yacc.c:1646 */
2825	2828	{ (yyval.exp) = new_exp_from_member_dot( (yyvsp[-2].exp), (yyvsp[0].sval), EM_lineNum ); }
2826		−#line 2827 "chuck.tab.c" /* yacc.c:1646 */
	2829	+#line 2830 "chuck.tab.c" /* yacc.c:1646 */
2827	2830	break;
2828	2831
2829		− case 170:
2830		−#line 583 "chuck.y" /* yacc.c:1646 */
	2832	+ case 171:
	2833	+#line 585 "chuck.y" /* yacc.c:1646 */
2831	2834	{ (yyval.exp) = new_exp_from_postfix( (yyvsp[-1].exp), ae_op_plusplus, EM_lineNum ); }
2832		−#line 2833 "chuck.tab.c" /* yacc.c:1646 */
	2835	+#line 2836 "chuck.tab.c" /* yacc.c:1646 */
2833	2836	break;
2834	2837
2835		− case 171:
2836		−#line 585 "chuck.y" /* yacc.c:1646 */
	2838	+ case 172:
	2839	+#line 587 "chuck.y" /* yacc.c:1646 */
2837	2840	{ (yyval.exp) = new_exp_from_postfix( (yyvsp[-1].exp), ae_op_minusminus, EM_lineNum ); }
2838		−#line 2839 "chuck.tab.c" /* yacc.c:1646 */
	2841	+#line 2842 "chuck.tab.c" /* yacc.c:1646 */
2839	2842	break;
2840	2843
2841		− case 172:
2842		−#line 590 "chuck.y" /* yacc.c:1646 */
	2844	+ case 173:
	2845	+#line 592 "chuck.y" /* yacc.c:1646 */
2843	2846	{ (yyval.exp) = new_exp_from_id( (yyvsp[0].sval), EM_lineNum ); }
2844		−#line 2845 "chuck.tab.c" /* yacc.c:1646 */
	2847	+#line 2848 "chuck.tab.c" /* yacc.c:1646 */
2845	2848	break;
2846	2849
2847		− case 173:
2848		−#line 591 "chuck.y" /* yacc.c:1646 */
	2850	+ case 174:
	2851	+#line 593 "chuck.y" /* yacc.c:1646 */
2849	2852	{ (yyval.exp) = new_exp_from_int( (yyvsp[0].ival), EM_lineNum ); }
2850		−#line 2851 "chuck.tab.c" /* yacc.c:1646 */
	2853	+#line 2854 "chuck.tab.c" /* yacc.c:1646 */
2851	2854	break;
2852	2855
2853		− case 174:
2854		−#line 592 "chuck.y" /* yacc.c:1646 */
	2856	+ case 175:
	2857	+#line 594 "chuck.y" /* yacc.c:1646 */
2855	2858	{ (yyval.exp) = new_exp_from_float( (yyvsp[0].fval), EM_lineNum ); }
2856		−#line 2857 "chuck.tab.c" /* yacc.c:1646 */
	2859	+#line 2860 "chuck.tab.c" /* yacc.c:1646 */
2857	2860	break;
2858	2861
2859		− case 175:
2860		−#line 593 "chuck.y" /* yacc.c:1646 */
	2862	+ case 176:
	2863	+#line 595 "chuck.y" /* yacc.c:1646 */
2861	2864	{ (yyval.exp) = new_exp_from_str( (yyvsp[0].sval), EM_lineNum ); }
2862		−#line 2863 "chuck.tab.c" /* yacc.c:1646 */
	2865	+#line 2866 "chuck.tab.c" /* yacc.c:1646 */
2863	2866	break;
2864	2867
2865		− case 176:
2866		−#line 594 "chuck.y" /* yacc.c:1646 */
	2868	+ case 177:
	2869	+#line 596 "chuck.y" /* yacc.c:1646 */
2867	2870	{ (yyval.exp) = new_exp_from_char( (yyvsp[0].sval), EM_lineNum ); }
2868		−#line 2869 "chuck.tab.c" /* yacc.c:1646 */
	2871	+#line 2872 "chuck.tab.c" /* yacc.c:1646 */
2869	2872	break;
2870	2873
2871		− case 177:
2872		−#line 595 "chuck.y" /* yacc.c:1646 */
	2874	+ case 178:
	2875	+#line 597 "chuck.y" /* yacc.c:1646 */
2873	2876	{ (yyval.exp) = new_exp_from_array_lit( (yyvsp[0].array_sub), EM_lineNum ); }
2874		−#line 2875 "chuck.tab.c" /* yacc.c:1646 */
	2877	+#line 2878 "chuck.tab.c" /* yacc.c:1646 */
2875	2878	break;
2876	2879
2877		− case 178:
2878		−#line 596 "chuck.y" /* yacc.c:1646 */
	2880	+ case 179:
	2881	+#line 598 "chuck.y" /* yacc.c:1646 */
2879	2882	{ (yyval.exp) = new_exp_from_complex( (yyvsp[0].complex_exp), EM_lineNum ); }
2880		−#line 2881 "chuck.tab.c" /* yacc.c:1646 */
	2883	+#line 2884 "chuck.tab.c" /* yacc.c:1646 */
2881	2884	break;
2882	2885
2883		− case 179:
2884		−#line 597 "chuck.y" /* yacc.c:1646 */
	2886	+ case 180:
	2887	+#line 599 "chuck.y" /* yacc.c:1646 */
2885	2888	{ (yyval.exp) = new_exp_from_polar( (yyvsp[0].polar_exp), EM_lineNum ); }
2886		−#line 2887 "chuck.tab.c" /* yacc.c:1646 */
	2889	+#line 2890 "chuck.tab.c" /* yacc.c:1646 */
2887	2890	break;
2888	2891
2889		− case 180:
2890		−#line 598 "chuck.y" /* yacc.c:1646 */
	2892	+ case 181:
	2893	+#line 600 "chuck.y" /* yacc.c:1646 */
2891	2894	{ (yyval.exp) = new_exp_from_vec( (yyvsp[0].vec_exp), EM_lineNum ); }
2892		−#line 2893 "chuck.tab.c" /* yacc.c:1646 */
	2895	+#line 2896 "chuck.tab.c" /* yacc.c:1646 */
2893	2896	break;
2894	2897
2895		− case 181:
2896		−#line 599 "chuck.y" /* yacc.c:1646 */
	2898	+ case 182:
	2899	+#line 601 "chuck.y" /* yacc.c:1646 */
2897	2900	{ (yyval.exp) = new_exp_from_hack( (yyvsp[-1].exp), EM_lineNum ); }
2898		−#line 2899 "chuck.tab.c" /* yacc.c:1646 */
	2901	+#line 2902 "chuck.tab.c" /* yacc.c:1646 */
2899	2902	break;
2900	2903
2901		− case 182:
2902		−#line 600 "chuck.y" /* yacc.c:1646 */
	2904	+ case 183:
	2905	+#line 602 "chuck.y" /* yacc.c:1646 */
2903	2906	{ (yyval.exp) = (yyvsp[-1].exp); }
2904		−#line 2905 "chuck.tab.c" /* yacc.c:1646 */
	2907	+#line 2908 "chuck.tab.c" /* yacc.c:1646 */
2905	2908	break;
2906	2909
2907		− case 183:
2908		−#line 601 "chuck.y" /* yacc.c:1646 */
	2910	+ case 184:
	2911	+#line 603 "chuck.y" /* yacc.c:1646 */
2909	2912	{ (yyval.exp) = new_exp_from_nil( EM_lineNum ); }
2910		−#line 2911 "chuck.tab.c" /* yacc.c:1646 */
	2913	+#line 2914 "chuck.tab.c" /* yacc.c:1646 */
2911	2914	break;
2912	2915
2913	2916
2914		−#line 2915 "chuck.tab.c" /* yacc.c:1646 */
2915		− default: break;
	2917	+#line 2918 "chuck.tab.c" /* yacc.c:1646 */
	2918	+ default: break;
2916	2919	}
2917		− /* User semantic actions sometimes alter yychar, and that requires
2918		− that yytoken be updated with the new translation. We take the
2919		− approach of translating immediately before every use of yytoken.
2920		− One alternative is translating here after every semantic action,
2921		− but that translation would be missed if the semantic action invokes
2922		− YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
2923		− if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
2924		− incorrect destructor might then be invoked immediately. In the
2925		− case of YYERROR or YYBACKUP, subsequent parser actions might lead
2926		− to an incorrect destructor call or verbose syntax error message
2927		− before the lookahead is translated. */
2928		− YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
2929		−
2930		− YYPOPSTACK (yylen);
2931		− yylen = 0;
2932		− YY_STACK_PRINT (yyss, yyssp);
2933		−
2934		− *++yyvsp = yyval;
2935		−
2936		− /* Now 'shift' the result of the reduction. Determine what state
2937		− that goes to, based on the state we popped back to and the rule
2938		− number reduced by. */
2939		−
2940		− yyn = yyr1[yyn];
2941		−
2942		− yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
2943		− if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2944		− yystate = yytable[yystate];
2945		− else
2946		− yystate = yydefgoto[yyn - YYNTOKENS];
2947		−
2948		− goto yynewstate;
2949		−
2950		−
2951		− /*--------------------------------------.
2952		− \| yyerrlab -- here on detecting error. \|
2953		− `--------------------------------------*/
	2920	+ /* User semantic actions sometimes alter yychar, and that requires
	2921	+ that yytoken be updated with the new translation. We take the
	2922	+ approach of translating immediately before every use of yytoken.
	2923	+ One alternative is translating here after every semantic action,
	2924	+ but that translation would be missed if the semantic action invokes
	2925	+ YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
	2926	+ if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
	2927	+ incorrect destructor might then be invoked immediately. In the
	2928	+ case of YYERROR or YYBACKUP, subsequent parser actions might lead
	2929	+ to an incorrect destructor call or verbose syntax error message
	2930	+ before the lookahead is translated. */
	2931	+ YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
	2932	+
	2933	+ YYPOPSTACK (yylen);
	2934	+ yylen = 0;
	2935	+ YY_STACK_PRINT (yyss, yyssp);
	2936	+
	2937	+ *++yyvsp = yyval;
	2938	+
	2939	+ /* Now 'shift' the result of the reduction. Determine what state
	2940	+ that goes to, based on the state we popped back to and the rule
	2941	+ number reduced by. */
	2942	+
	2943	+ yyn = yyr1[yyn];
	2944	+
	2945	+ yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
	2946	+ if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
	2947	+ yystate = yytable[yystate];
	2948	+ else
	2949	+ yystate = yydefgoto[yyn - YYNTOKENS];
	2950	+
	2951	+ goto yynewstate;
	2952	+
	2953	+
	2954	+/*--------------------------------------.
	2955	+\| yyerrlab -- here on detecting error. \|
	2956	+`--------------------------------------*/
2954	2957	yyerrlab:
2955		− /* Make sure we have latest lookahead translation. See comments at
2956		− user semantic actions for why this is necessary. */
2957		− yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
	2958	+ /* Make sure we have latest lookahead translation. See comments at
	2959	+ user semantic actions for why this is necessary. */
	2960	+ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
2958	2961
2959		− /* If not already recovering from an error, report this error. */
2960		− if (!yyerrstatus)
	2962	+ /* If not already recovering from an error, report this error. */
	2963	+ if (!yyerrstatus)
2961	2964	{
2962		− ++yynerrs;
	2965	+ ++yynerrs;
2963	2966	#if ! YYERROR_VERBOSE
2964		− yyerror (YY_("syntax error"));
	2967	+ yyerror (YY_("syntax error"));
2965	2968	#else
2966	2969	# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
2967	2970	yyssp, yytoken)
2968		− {
2969		− char const *yymsgp = YY_("syntax error");
2970		− int yysyntax_error_status;
2971		− yysyntax_error_status = YYSYNTAX_ERROR;
2972		− if (yysyntax_error_status == 0)
	2971	+ {
	2972	+ char const *yymsgp = YY_("syntax error");
	2973	+ int yysyntax_error_status;
	2974	+ yysyntax_error_status = YYSYNTAX_ERROR;
	2975	+ if (yysyntax_error_status == 0)
	2976	+ yymsgp = yymsg;
	2977	+ else if (yysyntax_error_status == 1)
	2978	+ {
	2979	+ if (yymsg != yymsgbuf)
	2980	+ YYSTACK_FREE (yymsg);
	2981	+ yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
	2982	+ if (!yymsg)
	2983	+ {
	2984	+ yymsg = yymsgbuf;
	2985	+ yymsg_alloc = sizeof yymsgbuf;
	2986	+ yysyntax_error_status = 2;
	2987	+ }
	2988	+ else
	2989	+ {
	2990	+ yysyntax_error_status = YYSYNTAX_ERROR;
2973	2991	yymsgp = yymsg;
2974		− else if (yysyntax_error_status == 1)
2975		− {
2976		− if (yymsg != yymsgbuf)
2977		− YYSTACK_FREE (yymsg);
2978		− yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
2979		− if (!yymsg)
2980		− {
2981		− yymsg = yymsgbuf;
2982		− yymsg_alloc = sizeof yymsgbuf;
2983		− yysyntax_error_status = 2;
2984		− }
2985		− else
2986		− {
2987		− yysyntax_error_status = YYSYNTAX_ERROR;
2988		− yymsgp = yymsg;
2989		− }
2990		− }
2991		− yyerror (yymsgp);
2992		− if (yysyntax_error_status == 2)
2993		− goto yyexhaustedlab;
2994		− }
	2992	+ }
	2993	+ }
	2994	+ yyerror (yymsgp);
	2995	+ if (yysyntax_error_status == 2)
	2996	+ goto yyexhaustedlab;
	2997	+ }
2995	2998	# undef YYSYNTAX_ERROR
2996	2999	#endif
2997	3000	}
2998	3001
2999	3002
3000	3003
3001		− if (yyerrstatus == 3)
	3004	+ if (yyerrstatus == 3)
3002	3005	{
3003		− /* If just tried and failed to reuse lookahead token after an
3004		− error, discard it. */
	3006	+ /* If just tried and failed to reuse lookahead token after an
	3007	+ error, discard it. */
3005	3008
3006		− if (yychar <= YYEOF)
	3009	+ if (yychar <= YYEOF)
3007	3010	{
3008		− /* Return failure if at end of input. */
3009		− if (yychar == YYEOF)
3010		− YYABORT;
	3011	+ /* Return failure if at end of input. */
	3012	+ if (yychar == YYEOF)
	3013	+ YYABORT;
3011	3014	}
3012		− else
	3015	+ else
3013	3016	{
3014		− yydestruct ("Error: discarding",
3015		− yytoken, &yylval);
3016		− yychar = YYEMPTY;
	3017	+ yydestruct ("Error: discarding",
	3018	+ yytoken, &yylval);
	3019	+ yychar = YYEMPTY;
3017	3020	}
3018	3021	}
3019	3022
3020		− /* Else will try to reuse lookahead token after shifting the error
3021		− token. */
3022		− goto yyerrlab1;
	3023	+ /* Else will try to reuse lookahead token after shifting the error
	3024	+ token. */
	3025	+ goto yyerrlab1;
3023	3026
3024	3027
3025		− /*---------------------------------------------------.
3026		− \| yyerrorlab -- error raised explicitly by YYERROR. \|
3027		− `---------------------------------------------------*/
	3028	+/*---------------------------------------------------.
	3029	+\| yyerrorlab -- error raised explicitly by YYERROR. \|
	3030	+`---------------------------------------------------*/
3028	3031	yyerrorlab:
3029	3032
3030		− /* Pacify compilers like GCC when the user code never invokes
3031		− YYERROR and the label yyerrorlab therefore never appears in user
3032		− code. */
3033		− if (/CONSTCOND/ 0)
3034		− goto yyerrorlab;
	3033	+ /* Pacify compilers like GCC when the user code never invokes
	3034	+ YYERROR and the label yyerrorlab therefore never appears in user
	3035	+ code. */
	3036	+ if (/CONSTCOND/ 0)
	3037	+ goto yyerrorlab;
3035	3038
3036		− /* Do not reclaim the symbols of the rule whose action triggered
3037		− this YYERROR. */
3038		− YYPOPSTACK (yylen);
3039		− yylen = 0;
3040		− YY_STACK_PRINT (yyss, yyssp);
3041		− yystate = *yyssp;
3042		− goto yyerrlab1;
	3039	+ /* Do not reclaim the symbols of the rule whose action triggered
	3040	+ this YYERROR. */
	3041	+ YYPOPSTACK (yylen);
	3042	+ yylen = 0;
	3043	+ YY_STACK_PRINT (yyss, yyssp);
	3044	+ yystate = *yyssp;
	3045	+ goto yyerrlab1;
3043	3046
3044	3047
3045		− /*-------------------------------------------------------------.
3046		− \| yyerrlab1 -- common code for both syntax error and YYERROR. \|
3047		− `-------------------------------------------------------------*/
	3048	+/*-------------------------------------------------------------.
	3049	+\| yyerrlab1 -- common code for both syntax error and YYERROR. \|
	3050	+`-------------------------------------------------------------*/
3048	3051	yyerrlab1:
3049		− yyerrstatus = 3; /* Each real token shifted decrements this. */
	3052	+ yyerrstatus = 3; /* Each real token shifted decrements this. */
3050	3053
3051		− for (;;)
	3054	+ for (;;)
3052	3055	{
3053		− yyn = yypact[yystate];
3054		− if (!yypact_value_is_default (yyn))
	3056	+ yyn = yypact[yystate];
	3057	+ if (!yypact_value_is_default (yyn))
3055	3058	{
3056		− yyn += YYTERROR;
3057		− if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
	3059	+ yyn += YYTERROR;
	3060	+ if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
3058	3061	{
3059		− yyn = yytable[yyn];
3060		− if (0 < yyn)
3061		− break;
	3062	+ yyn = yytable[yyn];
	3063	+ if (0 < yyn)
	3064	+ break;
3062	3065	}
3063	3066	}
3064	3067
3065		− /* Pop the current state because it cannot handle the error token. */
3066		− if (yyssp == yyss)
3067		− YYABORT;
	3068	+ /* Pop the current state because it cannot handle the error token. */
	3069	+ if (yyssp == yyss)
	3070	+ YYABORT;
3068	3071
3069	3072
3070		− yydestruct ("Error: popping",
3071		− yystos[yystate], yyvsp);
3072		− YYPOPSTACK (1);
3073		− yystate = *yyssp;
3074		− YY_STACK_PRINT (yyss, yyssp);
	3073	+ yydestruct ("Error: popping",
	3074	+ yystos[yystate], yyvsp);
	3075	+ YYPOPSTACK (1);
	3076	+ yystate = *yyssp;
	3077	+ YY_STACK_PRINT (yyss, yyssp);
3075	3078	}
3076	3079
3077		− YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
3078		− *++yyvsp = yylval;
3079		− YY_IGNORE_MAYBE_UNINITIALIZED_END
	3080	+ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
	3081	+ *++yyvsp = yylval;
	3082	+ YY_IGNORE_MAYBE_UNINITIALIZED_END
3080	3083
3081	3084
3082		− /* Shift the error token. */
3083		− YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
	3085	+ /* Shift the error token. */
	3086	+ YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
3084	3087
3085		− yystate = yyn;
3086		− goto yynewstate;
	3088	+ yystate = yyn;
	3089	+ goto yynewstate;
3087	3090
3088	3091
3089		− /*-------------------------------------.
3090		− \| yyacceptlab -- YYACCEPT comes here. \|
3091		− `-------------------------------------*/
	3092	+/*-------------------------------------.
	3093	+\| yyacceptlab -- YYACCEPT comes here. \|
	3094	+`-------------------------------------*/
3092	3095	yyacceptlab:
3093		− yyresult = 0;
3094		− goto yyreturn;
	3096	+ yyresult = 0;
	3097	+ goto yyreturn;
3095	3098
3096		− /*-----------------------------------.
3097		− \| yyabortlab -- YYABORT comes here. \|
3098		− `-----------------------------------*/
	3099	+/*-----------------------------------.
	3100	+\| yyabortlab -- YYABORT comes here. \|
	3101	+`-----------------------------------*/
3099	3102	yyabortlab:
3100		− yyresult = 1;
3101		− goto yyreturn;
	3103	+ yyresult = 1;
	3104	+ goto yyreturn;
3102	3105
3103	3106	#if !defined yyoverflow \|\| YYERROR_VERBOSE
3104		− /*-------------------------------------------------.
3105		− \| yyexhaustedlab -- memory exhaustion comes here. \|
3106		− `-------------------------------------------------*/
3107		− yyexhaustedlab:
3108		− yyerror (YY_("memory exhausted"));
3109		− yyresult = 2;
3110		− /* Fall through. */
	3107	+/*-------------------------------------------------.
	3108	+\| yyexhaustedlab -- memory exhaustion comes here. \|
	3109	+`-------------------------------------------------*/
	3110	+yyexhaustedlab:
	3111	+ yyerror (YY_("memory exhausted"));
	3112	+ yyresult = 2;
	3113	+ /* Fall through. */
3111	3114	#endif
3112	3115
3113		− yyreturn:
3114		− if (yychar != YYEMPTY)
3115		− {
3116		− /* Make sure we have latest lookahead translation. See comments at
3117		− user semantic actions for why this is necessary. */
3118		− yytoken = YYTRANSLATE (yychar);
3119		− yydestruct ("Cleanup: discarding lookahead",
3120		− yytoken, &yylval);
3121		− }
3122		− /* Do not reclaim the symbols of the rule whose action triggered
3123		− this YYABORT or YYACCEPT. */
3124		− YYPOPSTACK (yylen);
3125		− YY_STACK_PRINT (yyss, yyssp);
3126		− while (yyssp != yyss)
3127		− {
3128		− yydestruct ("Cleanup: popping",
3129		− yystos[*yyssp], yyvsp);
3130		− YYPOPSTACK (1);
3131		− }
	3116	+yyreturn:
	3117	+ if (yychar != YYEMPTY)
	3118	+ {
	3119	+ /* Make sure we have latest lookahead translation. See comments at
	3120	+ user semantic actions for why this is necessary. */
	3121	+ yytoken = YYTRANSLATE (yychar);
	3122	+ yydestruct ("Cleanup: discarding lookahead",
	3123	+ yytoken, &yylval);
	3124	+ }
	3125	+ /* Do not reclaim the symbols of the rule whose action triggered
	3126	+ this YYABORT or YYACCEPT. */
	3127	+ YYPOPSTACK (yylen);
	3128	+ YY_STACK_PRINT (yyss, yyssp);
	3129	+ while (yyssp != yyss)
	3130	+ {
	3131	+ yydestruct ("Cleanup: popping",
	3132	+ yystos[*yyssp], yyvsp);
	3133	+ YYPOPSTACK (1);
	3134	+ }
3132	3135	#ifndef yyoverflow
3133		− if (yyss != yyssa)
3134		− YYSTACK_FREE (yyss);
	3136	+ if (yyss != yyssa)
	3137	+ YYSTACK_FREE (yyss);
3135	3138	#endif
3136	3139	#if YYERROR_VERBOSE
3137		− if (yymsg != yymsgbuf)
3138		− YYSTACK_FREE (yymsg);
	3140	+ if (yymsg != yymsgbuf)
	3141	+ YYSTACK_FREE (yymsg);
3139	3142	#endif
3140		− return yyresult;
	3143	+ return yyresult;
3141	3144	}
3142		−#line 2 "chuck.yy.c"
	3145	+#line 1 "core/chuck.yy.c"
3143	3146
3144		−#line 4 "chuck.yy.c"
	3147	+#line 3 "core/chuck.yy.c"
3145	3148
3146	3149	#define YY_INT_ALIGNED short int
3147	3150
@@ -3150,7 +3153,7 @@ yyabortlab: · 2 unmodified lines
3150	3153	#define FLEX_SCANNER
3151	3154	#define YY_FLEX_MAJOR_VERSION 2
3152	3155	#define YY_FLEX_MINOR_VERSION 6
3153		−#define YY_FLEX_SUBMINOR_VERSION 0
	3156	+#define YY_FLEX_SUBMINOR_VERSION 4
3154	3157	#if YY_FLEX_SUBMINOR_VERSION > 0
3155	3158	#define FLEX_BETA
3156	3159	#endif
@@ -3175,8 +3178,8 @@ yyabortlab: · 18 unmodified lines
3175	3178	#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
3176	3179
3177	3180	/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
3178		−* if you want the limit (max/min) macros for int types.
3179		−*/
	3181	+ * if you want the limit (max/min) macros for int types.
	3182	+ */
3180	3183	#ifndef __STDC_LIMIT_MACROS
3181	3184	#define __STDC_LIMIT_MACROS 1
3182	3185	#endif
@@ -3225,69 +3228,57 @@ typedef unsigned int flex_uint32_t; · 42 unmodified lines
3225	3228	#define UINT32_MAX (4294967295U)
3226	3229	#endif
3227	3230
	3231	+#ifndef SIZE_MAX
	3232	+#define SIZE_MAX (~(size_t)0)
	3233	+#endif
	3234	+
3228	3235	#endif /* ! C99 */
3229	3236
3230	3237	#endif /* ! FLEXINT_H */
3231	3238
3232		−#ifdef __cplusplus
3233		−
3234		−/* The "const" storage-class-modifier is valid. */
3235		−#define YY_USE_CONST
3236		−
3237		−#else /* ! __cplusplus */
3238		−
3239		−/* C99 requires __STDC__ to be defined as 1. */
3240		−#if defined (__STDC__)
	3239	+/* begin standard C++ headers. */
3241	3240
3242		−#define YY_USE_CONST
3243		−
3244		−#endif /* defined (__STDC__) */
3245		−#endif /* ! __cplusplus */
3246		−
3247		−#ifdef YY_USE_CONST
	3241	+/* TODO: this is always defined, so inline it */
3248	3242	#define yyconst const
	3243	+
	3244	+#if defined(__GNUC__) && __GNUC__ >= 3
	3245	+#define yynoreturn __attribute__((__noreturn__))
3249	3246	#else
3250		−#define yyconst
	3247	+#define yynoreturn
3251	3248	#endif
3252	3249
3253	3250	/* Returned upon end-of-file. */
3254	3251	#define YY_NULL 0
3255	3252
3256		−/* Promotes a possibly negative, possibly signed char to an unsigned
3257		−* integer for use as an array index. If the signed char is negative,
3258		−* we want to instead treat it as an 8-bit unsigned char, hence the
3259		−* double cast.
3260		−*/
3261		−#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
	3253	+/* Promotes a possibly negative, possibly signed char to an
	3254	+ * integer in range [0..255] for use as an array index.
	3255	+ */
	3256	+#define YY_SC_TO_UI(c) ((YY_CHAR) (c))
3262	3257
3263	3258	/* Enter a start condition. This macro really ought to take a parameter,
3264		−* but we do it the disgusting crufty way forced on us by the ()-less
3265		−* definition of BEGIN.
3266		−*/
	3259	+ * but we do it the disgusting crufty way forced on us by the ()-less
	3260	+ * definition of BEGIN.
	3261	+ */
3267	3262	#define BEGIN (yy_start) = 1 + 2 *
3268		−
3269	3263	/* Translate the current start state into a value that can be later handed
3270		−* to BEGIN to return to the state. The YYSTATE alias is for lex
3271		−* compatibility.
3272		−*/
	3264	+ * to BEGIN to return to the state. The YYSTATE alias is for lex
	3265	+ * compatibility.
	3266	+ */
3273	3267	#define YY_START (((yy_start) - 1) / 2)
3274	3268	#define YYSTATE YY_START
3275		−
3276	3269	/* Action number for EOF rule of a given start state. */
3277	3270	#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
3278		−
3279	3271	/* Special action meaning "start processing a new file". */
3280		−#define YY_NEW_FILE yyrestart(yyin )
3281		−
	3272	+#define YY_NEW_FILE yyrestart( yyin )
3282	3273	#define YY_END_OF_BUFFER_CHAR 0
3283	3274
3284	3275	/* Size of default input buffer. */
3285	3276	#ifndef YY_BUF_SIZE
3286	3277	#ifdef __ia64__
3287	3278	/* On IA-64, the buffer size is 16k, not 8k.
3288		−* Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
3289		−* Ditto for the __ia64__ case accordingly.
3290		−*/
	3279	+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
	3280	+ * Ditto for the __ia64__ case accordingly.
	3281	+ */
3291	3282	#define YY_BUF_SIZE 32768
3292	3283	#else
3293	3284	#define YY_BUF_SIZE 16384
@@ -3295,7 +3286,7 @@ typedef unsigned int flex_uint32_t; · 1 unmodified line
3295	3286	#endif
3296	3287
3297	3288	/* The state buf must be large enough to hold one state per character in the main buffer.
3298		−*/
	3289	+ */
3299	3290	#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
3300	3291
3301	3292	#ifndef YY_TYPEDEF_YY_BUFFER_STATE
@@ -3308,17 +3299,17 @@ typedef struct yy_buffer_state *YY_BUFFER_STATE; · 6 unmodified lines
3308	3299	typedef size_t yy_size_t;
3309	3300	#endif
3310	3301
3311		−extern yy_size_t yyleng;
	3302	+extern int yyleng;
3312	3303
3313	3304	extern FILE yyin, yyout;
3314	3305
3315	3306	#define EOB_ACT_CONTINUE_SCAN 0
3316	3307	#define EOB_ACT_END_OF_FILE 1
3317	3308	#define EOB_ACT_LAST_MATCH 2
3318		−
3319		−#define YY_LESS_LINENO(n)
3320		−#define YY_LINENO_REWIND_TO(ptr)
3321		−
	3309	+
	3310	+ #define YY_LESS_LINENO(n)
	3311	+ #define YY_LINENO_REWIND_TO(ptr)
	3312	+
3322	3313	/* Return all but the first "n" matched characters back to the input stream. */
3323	3314	#define yyless(n) \
3324	3315	do \
@@ -3332,165 +3323,157 @@ extern FILE yyin, yyout; · 7 unmodified lines
3332	3323	YY_DO_BEFORE_ACTION; /* set up yytext again */ \
3333	3324	} \
3334	3325	while ( 0 )
3335		−
3336	3326	#define unput(c) yyunput( c, (yytext_ptr) )
3337	3327
3338	3328	#ifndef YY_STRUCT_YY_BUFFER_STATE
3339	3329	#define YY_STRUCT_YY_BUFFER_STATE
3340	3330	struct yy_buffer_state
3341		−{
3342		− FILE *yy_input_file;
3343		−
3344		− char yy_ch_buf; / input buffer */
3345		− char yy_buf_pos; / current position in input buffer */
3346		−
3347		− /* Size of input buffer in bytes, not including room for EOB
3348		− * characters.
3349		− */
3350		− yy_size_t yy_buf_size;
3351		−
3352		− /* Number of characters read into yy_ch_buf, not including EOB
3353		− * characters.
3354		− */
3355		− yy_size_t yy_n_chars;
3356		−
3357		− /* Whether we "own" the buffer - i.e., we know we created it,
3358		− * and can realloc() it to grow it, and should free() it to
3359		− * delete it.
3360		− */
3361		− int yy_is_our_buffer;
3362		−
3363		− /* Whether this is an "interactive" input source; if so, and
3364		− * if we're using stdio for input, then we want to use getc()
3365		− * instead of fread(), to make sure we stop fetching input after
3366		− * each newline.
3367		− */
3368		− int yy_is_interactive;
3369		−
3370		− /* Whether we're considered to be at the beginning of a line.
3371		− * If so, '^' rules will be active on the next match, otherwise
3372		− * not.
3373		− */
3374		− int yy_at_bol;
	3331	+ {
	3332	+ FILE *yy_input_file;
	3333	+
	3334	+ char yy_ch_buf; / input buffer */
	3335	+ char yy_buf_pos; / current position in input buffer */
	3336	+
	3337	+ /* Size of input buffer in bytes, not including room for EOB
	3338	+ * characters.
	3339	+ */
	3340	+ int yy_buf_size;
	3341	+
	3342	+ /* Number of characters read into yy_ch_buf, not including EOB
	3343	+ * characters.
	3344	+ */
	3345	+ int yy_n_chars;
	3346	+
	3347	+ /* Whether we "own" the buffer - i.e., we know we created it,
	3348	+ * and can realloc() it to grow it, and should free() it to
	3349	+ * delete it.
	3350	+ */
	3351	+ int yy_is_our_buffer;
	3352	+
	3353	+ /* Whether this is an "interactive" input source; if so, and
	3354	+ * if we're using stdio for input, then we want to use getc()
	3355	+ * instead of fread(), to make sure we stop fetching input after
	3356	+ * each newline.
	3357	+ */
	3358	+ int yy_is_interactive;
	3359	+
	3360	+ /* Whether we're considered to be at the beginning of a line.
	3361	+ * If so, '^' rules will be active on the next match, otherwise
	3362	+ * not.
	3363	+ */
	3364	+ int yy_at_bol;
3375	3365
3376	3366	int yy_bs_lineno; /*< The line count. /
3377	3367	int yy_bs_column; /*< The column count. /
3378	3368
3379		− /* Whether to try to fill the input buffer when we reach the
3380		− * end of it.
3381		− */
3382		− int yy_fill_buffer;
	3369	+ /* Whether to try to fill the input buffer when we reach the
	3370	+ * end of it.
	3371	+ */
	3372	+ int yy_fill_buffer;
3383	3373
3384		− int yy_buffer_status;
	3374	+ int yy_buffer_status;
3385	3375
3386	3376	#define YY_BUFFER_NEW 0
3387	3377	#define YY_BUFFER_NORMAL 1
3388		− /* When an EOF's been seen but there's still some text to process
3389		− * then we mark the buffer as YY_EOF_PENDING, to indicate that we
3390		− * shouldn't try reading from the input source any more. We might
3391		− * still have a bunch of tokens to match, though, because of
3392		− * possible backing-up.
3393		− *
3394		− * When we actually see the EOF, we change the status to "new"
3395		− * (via yyrestart()), so that the user can continue scanning by
3396		− * just pointing yyin at a new input file.
3397		− */
	3378	+ /* When an EOF's been seen but there's still some text to process
	3379	+ * then we mark the buffer as YY_EOF_PENDING, to indicate that we
	3380	+ * shouldn't try reading from the input source any more. We might
	3381	+ * still have a bunch of tokens to match, though, because of
	3382	+ * possible backing-up.
	3383	+ *
	3384	+ * When we actually see the EOF, we change the status to "new"
	3385	+ * (via yyrestart()), so that the user can continue scanning by
	3386	+ * just pointing yyin at a new input file.
	3387	+ */
3398	3388	#define YY_BUFFER_EOF_PENDING 2
3399	3389
3400		−};
	3390	+ };
3401	3391	#endif /* !YY_STRUCT_YY_BUFFER_STATE */
3402	3392
3403	3393	/* Stack of input buffers. */
3404	3394	static size_t yy_buffer_stack_top = 0; /*< index of top of stack. /
3405	3395	static size_t yy_buffer_stack_max = 0; /*< capacity of stack. /
3406		−static YY_BUFFER_STATE * yy_buffer_stack = 0; /*< Stack as an array. /
3407		−
3408		− /* We provide macros for accessing buffer states in case in the
3409		− * future we want to put the buffer states in a more general
3410		− * "scanner state".
3411		− *
3412		− * Returns the top of the stack, or NULL.
3413		− */
	3396	+static YY_BUFFER_STATE * yy_buffer_stack = NULL; /*< Stack as an array. /
	3397	+
	3398	+/* We provide macros for accessing buffer states in case in the
	3399	+ * future we want to put the buffer states in a more general
	3400	+ * "scanner state".
	3401	+ *
	3402	+ * Returns the top of the stack, or NULL.
	3403	+ */
3414	3404	#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
3415	3405	? (yy_buffer_stack)[(yy_buffer_stack_top)] \
3416	3406	: NULL)
3417		−
3418		− /* Same as previous macro, but useful when we know that the buffer stack is not
3419		− * NULL or when we need an lvalue. For internal use only.
3420		− */
	3407	+/* Same as previous macro, but useful when we know that the buffer stack is not
	3408	+ * NULL or when we need an lvalue. For internal use only.
	3409	+ */
3421	3410	#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
3422	3411
3423		− /* yy_hold_char holds the character lost when yytext is formed. */
	3412	+/* yy_hold_char holds the character lost when yytext is formed. */
3424	3413	static char yy_hold_char;
3425		−static yy_size_t yy_n_chars; /* number of characters read into yy_ch_buf */
3426		−yy_size_t yyleng;
	3414	+static int yy_n_chars; /* number of characters read into yy_ch_buf */
	3415	+int yyleng;
3427	3416
3428	3417	/* Points to current character in buffer. */
3429		−static char yy_c_buf_p = (char ) 0;
	3418	+static char *yy_c_buf_p = NULL;
3430	3419	static int yy_init = 0; /* whether we need to initialize */
3431	3420	static int yy_start = 0; /* start state number */
3432	3421
3433		− /* Flag which is used to allow yywrap()'s to do buffer switches
3434		− * instead of setting up a fresh yyin. A bit of a hack ...
3435		− */
	3422	+/* Flag which is used to allow yywrap()'s to do buffer switches
	3423	+ * instead of setting up a fresh yyin. A bit of a hack ...
	3424	+ */
3436	3425	static int yy_did_buffer_switch_on_eof;
3437	3426
3438		−void yyrestart (FILE *input_file );
3439		−void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer );
3440		−YY_BUFFER_STATE yy_create_buffer (FILE *file,int size );
3441		−void yy_delete_buffer (YY_BUFFER_STATE b );
3442		−void yy_flush_buffer (YY_BUFFER_STATE b );
3443		−void yypush_buffer_state (YY_BUFFER_STATE new_buffer );
3444		−void yypop_buffer_state (void );
	3427	+void yyrestart ( FILE *input_file );
	3428	+void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer );
	3429	+YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size );
	3430	+void yy_delete_buffer ( YY_BUFFER_STATE b );
	3431	+void yy_flush_buffer ( YY_BUFFER_STATE b );
	3432	+void yypush_buffer_state ( YY_BUFFER_STATE new_buffer );
	3433	+void yypop_buffer_state ( void );
3445	3434
3446		−static void yyensure_buffer_stack (void );
3447		−static void yy_load_buffer_state (void );
3448		−static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file );
	3435	+static void yyensure_buffer_stack ( void );
	3436	+static void yy_load_buffer_state ( void );
	3437	+static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file );
	3438	+#define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER )
3449	3439
3450		−#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
	3440	+YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size );
	3441	+YY_BUFFER_STATE yy_scan_string ( const char *yy_str );
	3442	+YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len );
3451	3443
3452		−YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size );
3453		−YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str );
3454		−YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,yy_size_t len );
3455		−
3456		−void *yyalloc (yy_size_t );
3457		−void yyrealloc (void ,yy_size_t );
3458		−void yyfree (void * );
	3444	+void *yyalloc ( yy_size_t );
	3445	+void yyrealloc ( void , yy_size_t );
	3446	+void yyfree ( void * );
3459	3447
3460	3448	#define yy_new_buffer yy_create_buffer
3461		−
3462	3449	#define yy_set_interactive(is_interactive) \
3463	3450	{ \
3464	3451	if ( ! YY_CURRENT_BUFFER ){ \
3465	3452	yyensure_buffer_stack (); \
3466	3453	YY_CURRENT_BUFFER_LVALUE = \
3467		− yy_create_buffer(yyin,YY_BUF_SIZE ); \
	3454	+ yy_create_buffer( yyin, YY_BUF_SIZE ); \
3468	3455	} \
3469	3456	YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
3470	3457	}
3471		−
3472	3458	#define yy_set_bol(at_bol) \
3473	3459	{ \
3474	3460	if ( ! YY_CURRENT_BUFFER ){\
3475	3461	yyensure_buffer_stack (); \
3476	3462	YY_CURRENT_BUFFER_LVALUE = \
3477		− yy_create_buffer(yyin,YY_BUF_SIZE ); \
	3463	+ yy_create_buffer( yyin, YY_BUF_SIZE ); \
3478	3464	} \
3479	3465	YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
3480	3466	}
3481		−
3482	3467	#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
3483	3468
3484	3469	/* Begin user sect3 */
	3470	+typedef flex_uint8_t YY_CHAR;
3485	3471
3486		−typedef unsigned char YY_CHAR;
3487		−
3488		−FILE yyin = (FILE ) 0, yyout = (FILE ) 0;
	3472	+FILE yyin = NULL, yyout = NULL;
3489	3473
3490	3474	typedef int yy_state_type;
3491	3475
3492	3476	extern int yylineno;
3493		−
3494	3477	int yylineno = 1;
3495	3478
3496	3479	extern char *yytext;
@@ -3499,259 +3482,260 @@ extern char *yytext; · 2 unmodified lines
3499	3482	#endif
3500	3483	#define yytext_ptr yytext
3501	3484
3502		−static yy_state_type yy_get_previous_state (void );
3503		−static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
3504		−static int yy_get_next_buffer (void );
3505		−#if defined(__GNUC__) && __GNUC__ >= 3
3506		−__attribute__((__noreturn__))
3507		−#endif
3508		−static void yy_fatal_error (yyconst char msg[] );
	3485	+static yy_state_type yy_get_previous_state ( void );
	3486	+static yy_state_type yy_try_NUL_trans ( yy_state_type current_state );
	3487	+static int yy_get_next_buffer ( void );
	3488	+static void yynoreturn yy_fatal_error ( const char* msg );
3509	3489
3510	3490	/* Done after the current pattern has been matched and before the
3511		−* corresponding action - sets up yytext.
3512		−*/
	3491	+ * corresponding action - sets up yytext.
	3492	+ */
3513	3493	#define YY_DO_BEFORE_ACTION \
3514	3494	(yytext_ptr) = yy_bp; \
3515		− yyleng = (size_t) (yy_cp - yy_bp); \
	3495	+ yyleng = (int) (yy_cp - yy_bp); \
3516	3496	(yy_hold_char) = *yy_cp; \
3517	3497	*yy_cp = '\0'; \
3518	3498	(yy_c_buf_p) = yy_cp;
3519		−
3520		−#define YY_NUM_RULES 104
3521		−#define YY_END_OF_BUFFER 105
	3499	+#define YY_NUM_RULES 105
	3500	+#define YY_END_OF_BUFFER 106
3522	3501	/* This struct is not used in this scanner,
3523		−but its presence is necessary. */
	3502	+ but its presence is necessary. */
3524	3503	struct yy_trans_info
3525		−{
3526		− flex_int32_t yy_verify;
3527		− flex_int32_t yy_nxt;
3528		−};
3529		−static yyconst flex_int16_t yy_accept[237] =
3530		−{ 0,
3531		−0, 0, 105, 103, 5, 7, 103, 4, 46, 103,
3532		−21, 22, 20, 32, 103, 38, 39, 18, 16, 13,
3533		−17, 15, 19, 97, 97, 14, 44, 26, 37, 27,
3534		−45, 91, 99, 40, 41, 34, 103, 99, 99, 99,
3535		−99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
3536		−42, 33, 43, 47, 6, 25, 0, 100, 0, 10,
3537		−11, 0, 30, 0, 0, 0, 0, 8, 0, 9,
3538		−0, 93, 98, 3, 1, 0, 98, 97, 0, 97,
3539		−0, 23, 94, 36, 28, 77, 24, 76, 79, 29,
3540		−35, 12, 0, 92, 99, 0, 0, 0, 101, 99,
3541		−
3542		−99, 99, 56, 99, 99, 99, 99, 54, 99, 99,
3543		−99, 99, 99, 99, 99, 99, 99, 99, 99, 0,
3544		−31, 78, 90, 85, 102, 83, 81, 82, 84, 98,
3545		−96, 95, 2, 57, 0, 0, 58, 80, 87, 99,
3546		−99, 99, 99, 99, 48, 61, 99, 99, 62, 99,
3547		−99, 99, 99, 99, 99, 99, 99, 99, 99, 99,
3548		−86, 96, 95, 89, 88, 99, 99, 99, 99, 55,
3549		−99, 99, 99, 99, 99, 99, 99, 71, 99, 99,
3550		−99, 99, 99, 99, 99, 53, 63, 72, 99, 99,
3551		−99, 99, 99, 99, 99, 99, 99, 99, 99, 73,
3552		−
3553		−99, 99, 50, 49, 99, 99, 99, 99, 99, 99,
3554		−99, 99, 67, 51, 59, 70, 74, 99, 65, 99,
3555		−99, 99, 99, 69, 99, 52, 75, 60, 99, 99,
3556		−99, 99, 64, 68, 66, 0
3557		−} ;
3558		−
3559		−static yyconst YY_CHAR yy_ec[256] =
3560		−{ 0,
3561		−1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
3562		−1, 1, 4, 1, 1, 1, 1, 1, 1, 1,
3563		−1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3564		−1, 5, 6, 7, 8, 9, 10, 11, 12, 13,
3565		−14, 15, 16, 17, 18, 19, 20, 21, 22, 22,
3566		−22, 22, 22, 22, 22, 23, 23, 24, 25, 26,
3567		−27, 28, 29, 30, 31, 31, 32, 31, 31, 31,
3568		−33, 33, 33, 33, 33, 34, 33, 33, 33, 33,
3569		−33, 33, 33, 33, 35, 33, 33, 36, 33, 33,
3570		−37, 38, 39, 40, 33, 41, 42, 43, 44, 45,
3571		−
3572		−46, 47, 33, 48, 49, 33, 50, 51, 52, 53,
3573		−54, 55, 33, 56, 57, 58, 59, 60, 61, 62,
3574		−63, 33, 64, 65, 66, 67, 1, 1, 1, 1,
3575		−1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3576		−1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3577		−1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3578		−1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3579		−1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3580		−1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3581		−1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3582		−
3583		−1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3584		−1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3585		−1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3586		−1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3587		−1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3588		−1, 1, 1, 1, 1
3589		−} ;
3590		−
3591		−static yyconst YY_CHAR yy_meta[68] =
3592		−{ 0,
3593		−1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
3594		−1, 2, 1, 1, 1, 1, 1, 1, 1, 1,
3595		−3, 3, 3, 1, 1, 1, 1, 1, 1, 1,
3596		−3, 3, 4, 4, 4, 4, 1, 1, 1, 1,
3597		−1, 3, 3, 3, 3, 3, 3, 4, 4, 4,
3598		−4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
3599		−4, 4, 4, 1, 1, 1, 1
3600		−} ;
3601		−
3602		−static yyconst flex_uint16_t yy_base[242] =
3603		−{ 0,
3604		−0, 0, 320, 321, 321, 321, 316, 321, 291, 61,
3605		−304, 321, 56, 59, 278, 321, 321, 288, 55, 321,
3606		−57, 51, 61, 81, 71, 290, 321, 69, 51, 70,
3607		−321, 94, 0, 321, 321, 286, 70, 256, 58, 257,
3608		−67, 60, 81, 264, 64, 263, 80, 245, 254, 258,
3609		−321, 62, 321, 321, 321, 277, 103, 321, 301, 321,
3610		−321, 275, 321, 274, 289, 133, 272, 321, 271, 321,
3611		−270, 321, 125, 321, 321, 269, 128, 133, 136, 126,
3612		−0, 321, 278, 136, 321, 321, 321, 321, 321, 321,
3613		−137, 321, 267, 321, 0, 266, 101, 290, 321, 246,
3614		−
3615		−249, 237, 0, 232, 230, 231, 233, 0, 230, 226,
3616		−222, 77, 110, 114, 228, 239, 225, 221, 229, 249,
3617		−321, 321, 321, 321, 321, 321, 321, 321, 321, 152,
3618		−159, 136, 321, 321, 248, 247, 321, 321, 321, 232,
3619		−216, 121, 226, 225, 0, 226, 218, 222, 0, 207,
3620		−208, 214, 218, 217, 203, 205, 202, 213, 209, 206,
3621		−321, 148, 154, 321, 321, 206, 198, 196, 204, 0,
3622		−144, 194, 205, 194, 207, 202, 198, 0, 204, 189,
3623		−194, 194, 188, 190, 194, 0, 0, 0, 186, 193,
3624		−184, 187, 183, 187, 175, 180, 173, 158, 162, 0,
3625		−
3626		−170, 165, 0, 0, 152, 152, 166, 152, 158, 161,
3627		−156, 143, 0, 0, 0, 0, 0, 152, 0, 145,
3628		−138, 137, 142, 0, 130, 0, 0, 0, 101, 98,
3629		−92, 44, 0, 0, 0, 321, 218, 222, 224, 228,
3630		−77
3631		−} ;
3632		−
3633		−static yyconst flex_int16_t yy_def[242] =
3634		−{ 0,
3635		−236, 1, 236, 236, 236, 236, 236, 236, 236, 237,
3636		−236, 236, 236, 236, 238, 236, 236, 236, 236, 236,
3637		−236, 236, 236, 236, 236, 236, 236, 236, 236, 236,
3638		−236, 236, 239, 236, 236, 236, 240, 239, 239, 239,
3639		−239, 239, 239, 239, 239, 239, 239, 239, 239, 239,
3640		−236, 236, 236, 236, 236, 236, 237, 236, 237, 236,
3641		−236, 236, 236, 236, 236, 238, 236, 236, 236, 236,
3642		−236, 236, 236, 236, 236, 236, 236, 236, 236, 236,
3643		−241, 236, 236, 236, 236, 236, 236, 236, 236, 236,
3644		−236, 236, 236, 236, 239, 236, 240, 240, 236, 239,
3645		−
3646		−239, 239, 239, 239, 239, 239, 239, 239, 239, 239,
3647		−239, 239, 239, 239, 239, 239, 239, 239, 239, 236,
3648		−236, 236, 236, 236, 236, 236, 236, 236, 236, 236,
3649		−236, 241, 236, 236, 236, 236, 236, 236, 236, 239,
3650		−239, 239, 239, 239, 239, 239, 239, 239, 239, 239,
3651		−239, 239, 239, 239, 239, 239, 239, 239, 239, 239,
3652		−236, 236, 236, 236, 236, 239, 239, 239, 239, 239,
3653		−239, 239, 239, 239, 239, 239, 239, 239, 239, 239,
3654		−239, 239, 239, 239, 239, 239, 239, 239, 239, 239,
3655		−239, 239, 239, 239, 239, 239, 239, 239, 239, 239,
3656		−
3657		−239, 239, 239, 239, 239, 239, 239, 239, 239, 239,
3658		−239, 239, 239, 239, 239, 239, 239, 239, 239, 239,
3659		−239, 239, 239, 239, 239, 239, 239, 239, 239, 239,
3660		−239, 239, 239, 239, 239, 0, 236, 236, 236, 236,
3661		−236
3662		−} ;
3663		−
3664		−static yyconst flex_uint16_t yy_nxt[389] =
3665		−{ 0,
3666		−4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
3667		−14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
3668		−24, 25, 25, 26, 27, 28, 29, 30, 31, 32,
3669		−33, 33, 33, 33, 33, 33, 34, 4, 35, 36,
3670		−37, 33, 38, 39, 40, 41, 42, 33, 43, 33,
3671		−33, 33, 44, 33, 45, 46, 47, 48, 49, 33,
3672		−50, 33, 33, 51, 52, 53, 54, 58, 61, 63,
3673		−68, 73, 73, 73, 70, 74, 86, 87, 88, 132,
3674		−75, 69, 62, 71, 72, 64, 83, 76, 120, 77,
3675		−89, 78, 78, 78, 84, 85, 90, 91, 59, 77,
3676		−
3677		−235, 78, 78, 78, 80, 80, 92, 98, 101, 58,
3678		−99, 102, 79, 106, 80, 80, 81, 104, 107, 112,
3679		−93, 80, 113, 94, 79, 150, 121, 108, 105, 80,
3680		−151, 80, 109, 110, 115, 236, 234, 116, 98, 80,
3681		−59, 99, 81, 233, 65, 73, 73, 73, 130, 130,
3682		−130, 77, 152, 78, 78, 78, 131, 131, 232, 80,
3683		−80, 134, 135, 136, 137, 153, 80, 80, 154, 163,
3684		−163, 155, 130, 130, 130, 231, 80, 168, 169, 131,
3685		−131, 162, 162, 80, 80, 230, 163, 163, 163, 229,
3686		−228, 80, 162, 162, 163, 227, 190, 226, 162, 191,
3687		−
3688		−225, 224, 223, 222, 163, 221, 162, 220, 219, 162,
3689		−218, 217, 163, 216, 215, 214, 213, 162, 57, 57,
3690		−57, 57, 65, 212, 65, 65, 95, 95, 97, 97,
3691		−97, 97, 211, 210, 209, 208, 207, 206, 205, 204,
3692		−203, 202, 201, 200, 199, 198, 197, 196, 195, 194,
3693		−193, 192, 189, 188, 187, 186, 185, 184, 183, 182,
3694		−181, 180, 179, 178, 177, 176, 175, 174, 173, 172,
3695		−171, 170, 167, 166, 165, 164, 161, 160, 159, 158,
3696		−157, 156, 149, 148, 147, 146, 145, 144, 143, 142,
3697		−141, 140, 236, 139, 138, 133, 129, 128, 127, 126,
3698		−
3699		−125, 124, 123, 236, 122, 119, 118, 117, 114, 111,
3700		−103, 100, 96, 82, 67, 66, 60, 56, 55, 236,
3701		−3, 236, 236, 236, 236, 236, 236, 236, 236, 236,

3621 more lines aren’t shown here.

src/core/chuck_win32.h+47−46

@@ -108,51 +108,52 @@ extern int yydebug; · 107 unmodified lines
108	108	NEXT = 318,
109	109	UNTIL = 319,
110	110	EXTERNAL = 320,
111		− EVERY = 321,
112		− BEFORE = 322,
113		− AFTER = 323,
114		− AT = 324,
115		− AT_SYM = 325,
116		− ATAT_SYM = 326,
117		− NEW = 327,
118		− SIZEOF = 328,
119		− TYPEOF = 329,
120		− SAME = 330,
121		− PLUS_CHUCK = 331,
122		− MINUS_CHUCK = 332,
123		− TIMES_CHUCK = 333,
124		− DIVIDE_CHUCK = 334,
125		− S_AND_CHUCK = 335,
126		− S_OR_CHUCK = 336,
127		− S_XOR_CHUCK = 337,
128		− SHIFT_RIGHT_CHUCK = 338,
129		− SHIFT_LEFT_CHUCK = 339,
130		− PERCENT_CHUCK = 340,
131		− SHIFT_RIGHT = 341,
132		− SHIFT_LEFT = 342,
133		− TILDA = 343,
134		− CHUCK = 344,
135		− COLONCOLON = 345,
136		− S_CHUCK = 346,
137		− AT_CHUCK = 347,
138		− LEFT_S_CHUCK = 348,
139		− UNCHUCK = 349,
140		− UPCHUCK = 350,
141		− CLASS = 351,
142		− INTERFACE = 352,
143		− EXTENDS = 353,
144		− IMPLEMENTS = 354,
145		− PUBLIC = 355,
146		− PROTECTED = 356,
147		− PRIVATE = 357,
148		− STATIC = 358,
149		− ABSTRACT = 359,
150		− CONST = 360,
151		− SPORK = 361,
152		− ARROW_RIGHT = 362,
153		− ARROW_LEFT = 363,
154		− L_HACK = 364,
155		− R_HACK = 365
	111	+ GLOBAL = 321,
	112	+ EVERY = 322,
	113	+ BEFORE = 323,
	114	+ AFTER = 324,
	115	+ AT = 325,
	116	+ AT_SYM = 326,
	117	+ ATAT_SYM = 327,
	118	+ NEW = 328,
	119	+ SIZEOF = 329,
	120	+ TYPEOF = 330,
	121	+ SAME = 331,
	122	+ PLUS_CHUCK = 332,
	123	+ MINUS_CHUCK = 333,
	124	+ TIMES_CHUCK = 334,
	125	+ DIVIDE_CHUCK = 335,
	126	+ S_AND_CHUCK = 336,
	127	+ S_OR_CHUCK = 337,
	128	+ S_XOR_CHUCK = 338,
	129	+ SHIFT_RIGHT_CHUCK = 339,
	130	+ SHIFT_LEFT_CHUCK = 340,
	131	+ PERCENT_CHUCK = 341,
	132	+ SHIFT_RIGHT = 342,
	133	+ SHIFT_LEFT = 343,
	134	+ TILDA = 344,
	135	+ CHUCK = 345,
	136	+ COLONCOLON = 346,
	137	+ S_CHUCK = 347,
	138	+ AT_CHUCK = 348,
	139	+ LEFT_S_CHUCK = 349,
	140	+ UNCHUCK = 350,
	141	+ UPCHUCK = 351,
	142	+ CLASS = 352,
	143	+ INTERFACE = 353,
	144	+ EXTENDS = 354,
	145	+ IMPLEMENTS = 355,
	146	+ PUBLIC = 356,
	147	+ PROTECTED = 357,
	148	+ PRIVATE = 358,
	149	+ STATIC = 359,
	150	+ ABSTRACT = 360,
	151	+ CONST = 361,
	152	+ SPORK = 362,
	153	+ ARROW_RIGHT = 363,
	154	+ ARROW_LEFT = 364,
	155	+ L_HACK = 365,
	156	+ R_HACK = 366
156	157	};
157	158	#endif
158	159
@@ -187,7 +188,7 @@ union YYSTYPE · 28 unmodified lines
187	188	a_Polar polar_exp;
188	189	a_Vec vec_exp; // ge: added 1.3.5.3
189	190
190		−#line 191 "chuck.tab.h" /* yacc.c:1909 */
	191	+#line 192 "chuck.tab.h" /* yacc.c:1909 */
191	192	};
192	193
193	194	typedef union YYSTYPE YYSTYPE;

src/makefile+17−0

@@ -166,6 +166,23 @@ chuck-core: · 165 unmodified lines
166	166	chuck: chuck-core $(COBJS_HOST) $(CXXOBJS_HOST)
167	167	$(LD) -o chuck $(OBJS) $(LDFLAGS) $(ARCHOPTS)
168	168
	169	+
	170	+######### subsection for generating the parser for windows #########
	171	+core/chuck.tab.c core/chuck.tab.h: core/chuck.y
	172	+ $(YACC) -dv -b chuck core/chuck.y
	173	+
	174	+core/chuck.yy.c: core/chuck.lex
	175	+ $(LEX) -ocore/chuck.yy.c core/chuck.lex
	176	+
	177	+core/chuck_win32.c: core/chuck.yy.c
	178	+ $(LEX) --nounistd -ocore/chuck.yy.c core/chuck.lex
	179	+ cat core/chuck.tab.c core/chuck.yy.c > $@
	180	+
	181	+core/chuck_win32.h: core/chuck.tab.h
	182	+ cat core/chuck.tab.h > $@
	183	+######## end subsection ###########
	184	+
	185	+
169	186	$(COBJS_HOST): %.o: %.c
170	187	$(CC) $(CFLAGS) $(ARCHOPTS) -c $< -o $@
171	188	@$(CC) -MM -MQ "$@" $(CFLAGSDEPEND) $< > $*.d

regen parser for win32

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code