]> git.proxmox.com Git - ceph.git/blob - ceph/src/boost/tools/build/src/engine/jamgram.cpp
projects / ceph.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
update ceph source to reef 18.1.2
[ceph.git] / ceph / src / boost / tools / build / src / engine / jamgram.cpp
1 /* A Bison parser, made by GNU Bison 3.8.2. */
2
3 /* Bison implementation for Yacc-like parsers in C
4
5 Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation,
6 Inc.
7
8 This program is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <https://www.gnu.org/licenses/>. */
20
21 /* As a special exception, you may create a larger work that contains
22 part or all of the Bison parser skeleton and distribute that work
23 under terms of your choice, so long as that work isn't itself a
24 parser generator using the skeleton or a modified version thereof
25 as a parser skeleton. Alternatively, if you modify or redistribute
26 the parser skeleton itself, you may (at your option) remove this
27 special exception, which will cause the skeleton and the resulting
28 Bison output files to be licensed under the GNU General Public
29 License without this special exception.
30
31 This special exception was added by the Free Software Foundation in
32 version 2.2 of Bison. */
33
34 /* C LALR(1) parser skeleton written by Richard Stallman, by
35 simplifying the original so-called "semantic" parser. */
36
37 /* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
38 especially those whose name start with YY_ or yy_. They are
39 private implementation details that can be changed or removed. */
40
41 /* All symbols defined below should begin with yy or YY, to avoid
42 infringing on user name space. This should be done even for local
43 variables, as they might otherwise be expanded by user macros.
44 There are some unavoidable exceptions within include files to
45 define necessary library symbols; they are noted "INFRINGES ON
46 USER NAME SPACE" below. */
47
48 /* Identify Bison output, and Bison version. */
49 #define YYBISON 30802
50
51 /* Bison version string. */
52 #define YYBISON_VERSION "3.8.2"
53
54 /* Skeleton name. */
55 #define YYSKELETON_NAME "yacc.c"
56
57 /* Pure parsers. */
58 #define YYPURE 0
59
60 /* Push parsers. */
61 #define YYPUSH 0
62
63 /* Pull parsers. */
64 #define YYPULL 1
65
66
67
68
69 /* First part of user prologue. */
70 #line 98 "src/engine/jamgram.y"
71
72 #include "jam.h"
73
74 #include "lists.h"
75 #include "parse.h"
76 #include "scan.h"
77 #include "compile.h"
78 #include "object.h"
79 #include "rules.h"
80
81 # define YYINITDEPTH 5000 /* for C++ parsing */
82 # define YYMAXDEPTH 10000 /* for OSF and other less endowed yaccs */
83
84 # define F0 -1
85 # define P0 (PARSE *)0
86 # define S0 (OBJECT *)0
87
88 # define pappend( l,r ) parse_make( PARSE_APPEND,l,r,P0,S0,S0,0 )
89 # define peval( c,l,r ) parse_make( PARSE_EVAL,l,r,P0,S0,S0,c )
90 # define pfor( s,l,r,x ) parse_make( PARSE_FOREACH,l,r,P0,s,S0,x )
91 # define pif( l,r,t ) parse_make( PARSE_IF,l,r,t,S0,S0,0 )
92 # define pincl( l ) parse_make( PARSE_INCLUDE,l,P0,P0,S0,S0,0 )
93 # define plist( s ) parse_make( PARSE_LIST,P0,P0,P0,s,S0,0 )
94 # define plocal( l,r,t ) parse_make( PARSE_LOCAL,l,r,t,S0,S0,0 )
95 # define pmodule( l,r ) parse_make( PARSE_MODULE,l,r,P0,S0,S0,0 )
96 # define pclass( l,r ) parse_make( PARSE_CLASS,l,r,P0,S0,S0,0 )
97 # define pnull() parse_make( PARSE_NULL,P0,P0,P0,S0,S0,0 )
98 # define pon( l,r ) parse_make( PARSE_ON,l,r,P0,S0,S0,0 )
99 # define prule( s,p ) parse_make( PARSE_RULE,p,P0,P0,s,S0,0 )
100 # define prules( l,r ) parse_make( PARSE_RULES,l,r,P0,S0,S0,0 )
101 # define pset( l,r,a ) parse_make( PARSE_SET,l,r,P0,S0,S0,a )
102 # define pset1( l,r,t,a ) parse_make( PARSE_SETTINGS,l,r,t,S0,S0,a )
103 # define psetc( s,p,a,l ) parse_make( PARSE_SETCOMP,p,a,P0,s,S0,l )
104 # define psete( s,l,s1,f ) parse_make( PARSE_SETEXEC,l,P0,P0,s,s1,f )
105 # define pswitch( l,r ) parse_make( PARSE_SWITCH,l,r,P0,S0,S0,0 )
106 # define pwhile( l,r ) parse_make( PARSE_WHILE,l,r,P0,S0,S0,0 )
107 # define preturn( l ) parse_make( PARSE_RETURN,l,P0,P0,S0,S0,0 )
108 # define pbreak() parse_make( PARSE_BREAK,P0,P0,P0,S0,S0,0 )
109 # define pcontinue() parse_make( PARSE_CONTINUE,P0,P0,P0,S0,S0,0 )
110
111 # define pnode( l,r ) parse_make( F0,l,r,P0,S0,S0,0 )
112 # define psnode( s,l ) parse_make( F0,l,P0,P0,s,S0,0 )
113
114
115 #line 116 "src/engine/jamgram.cpp"
116
117 # ifndef YY_CAST
118 # ifdef __cplusplus
119 # define YY_CAST(Type, Val) static_cast<Type> (Val)
120 # define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
121 # else
122 # define YY_CAST(Type, Val) ((Type) (Val))
123 # define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
124 # endif
125 # endif
126 # ifndef YY_NULLPTR
127 # if defined __cplusplus
128 # if 201103L <= __cplusplus
129 # define YY_NULLPTR nullptr
130 # else
131 # define YY_NULLPTR 0
132 # endif
133 # else
134 # define YY_NULLPTR ((void*)0)
135 # endif
136 # endif
137
138 #include "jamgram.hpp"
139 /* Symbol kind. */
140 enum yysymbol_kind_t
141 {
142 YYSYMBOL_YYEMPTY = -2,
143 YYSYMBOL_YYEOF = 0, /* "end of file" */
144 YYSYMBOL_YYerror = 1, /* error */
145 YYSYMBOL_YYUNDEF = 2, /* "invalid token" */
146 YYSYMBOL__BANG_t = 3, /* _BANG_t */
147 YYSYMBOL__BANG_EQUALS_t = 4, /* _BANG_EQUALS_t */
148 YYSYMBOL__AMPER_t = 5, /* _AMPER_t */
149 YYSYMBOL__AMPERAMPER_t = 6, /* _AMPERAMPER_t */
150 YYSYMBOL__LPAREN_t = 7, /* _LPAREN_t */
151 YYSYMBOL__RPAREN_t = 8, /* _RPAREN_t */
152 YYSYMBOL__PLUS_EQUALS_t = 9, /* _PLUS_EQUALS_t */
153 YYSYMBOL__COLON_t = 10, /* _COLON_t */
154 YYSYMBOL__SEMIC_t = 11, /* _SEMIC_t */
155 YYSYMBOL__LANGLE_t = 12, /* _LANGLE_t */
156 YYSYMBOL__LANGLE_EQUALS_t = 13, /* _LANGLE_EQUALS_t */
157 YYSYMBOL__EQUALS_t = 14, /* _EQUALS_t */
158 YYSYMBOL__RANGLE_t = 15, /* _RANGLE_t */
159 YYSYMBOL__RANGLE_EQUALS_t = 16, /* _RANGLE_EQUALS_t */
160 YYSYMBOL__QUESTION_EQUALS_t = 17, /* _QUESTION_EQUALS_t */
161 YYSYMBOL__LBRACKET_t = 18, /* _LBRACKET_t */
162 YYSYMBOL__RBRACKET_t = 19, /* _RBRACKET_t */
163 YYSYMBOL_ACTIONS_t = 20, /* ACTIONS_t */
164 YYSYMBOL_BIND_t = 21, /* BIND_t */
165 YYSYMBOL_BREAK_t = 22, /* BREAK_t */
166 YYSYMBOL_CASE_t = 23, /* CASE_t */
167 YYSYMBOL_CLASS_t = 24, /* CLASS_t */
168 YYSYMBOL_CONTINUE_t = 25, /* CONTINUE_t */
169 YYSYMBOL_DEFAULT_t = 26, /* DEFAULT_t */
170 YYSYMBOL_ELSE_t = 27, /* ELSE_t */
171 YYSYMBOL_EXISTING_t = 28, /* EXISTING_t */
172 YYSYMBOL_FOR_t = 29, /* FOR_t */
173 YYSYMBOL_IF_t = 30, /* IF_t */
174 YYSYMBOL_IGNORE_t = 31, /* IGNORE_t */
175 YYSYMBOL_IN_t = 32, /* IN_t */
176 YYSYMBOL_INCLUDE_t = 33, /* INCLUDE_t */
177 YYSYMBOL_LOCAL_t = 34, /* LOCAL_t */
178 YYSYMBOL_MODULE_t = 35, /* MODULE_t */
179 YYSYMBOL_ON_t = 36, /* ON_t */
180 YYSYMBOL_PIECEMEAL_t = 37, /* PIECEMEAL_t */
181 YYSYMBOL_QUIETLY_t = 38, /* QUIETLY_t */
182 YYSYMBOL_RETURN_t = 39, /* RETURN_t */
183 YYSYMBOL_RULE_t = 40, /* RULE_t */
184 YYSYMBOL_SWITCH_t = 41, /* SWITCH_t */
185 YYSYMBOL_TOGETHER_t = 42, /* TOGETHER_t */
186 YYSYMBOL_UPDATED_t = 43, /* UPDATED_t */
187 YYSYMBOL_WHILE_t = 44, /* WHILE_t */
188 YYSYMBOL__LBRACE_t = 45, /* _LBRACE_t */
189 YYSYMBOL__BAR_t = 46, /* _BAR_t */
190 YYSYMBOL__BARBAR_t = 47, /* _BARBAR_t */
191 YYSYMBOL__RBRACE_t = 48, /* _RBRACE_t */
192 YYSYMBOL_ARG = 49, /* ARG */
193 YYSYMBOL_STRING = 50, /* STRING */
194 YYSYMBOL_YYACCEPT = 51, /* $accept */
195 YYSYMBOL_run = 52, /* run */
196 YYSYMBOL_block = 53, /* block */
197 YYSYMBOL_rules = 54, /* rules */
198 YYSYMBOL_55_1 = 55, /* $@1 */
199 YYSYMBOL_56_2 = 56, /* $@2 */
200 YYSYMBOL_null = 57, /* null */
201 YYSYMBOL_assign_list_opt = 58, /* assign_list_opt */
202 YYSYMBOL_59_3 = 59, /* $@3 */
203 YYSYMBOL_arglist_opt = 60, /* arglist_opt */
204 YYSYMBOL_local_opt = 61, /* local_opt */
205 YYSYMBOL_else_opt = 62, /* else_opt */
206 YYSYMBOL_rule = 63, /* rule */
207 YYSYMBOL_64_4 = 64, /* $@4 */
208 YYSYMBOL_65_5 = 65, /* $@5 */
209 YYSYMBOL_66_6 = 66, /* $@6 */
210 YYSYMBOL_67_7 = 67, /* $@7 */
211 YYSYMBOL_68_8 = 68, /* $@8 */
212 YYSYMBOL_69_9 = 69, /* $@9 */
213 YYSYMBOL_70_10 = 70, /* $@10 */
214 YYSYMBOL_71_11 = 71, /* $@11 */
215 YYSYMBOL_72_12 = 72, /* $@12 */
216 YYSYMBOL_73_13 = 73, /* $@13 */
217 YYSYMBOL_74_14 = 74, /* $@14 */
218 YYSYMBOL_75_15 = 75, /* $@15 */
219 YYSYMBOL_76_16 = 76, /* $@16 */
220 YYSYMBOL_77_17 = 77, /* $@17 */
221 YYSYMBOL_78_18 = 78, /* $@18 */
222 YYSYMBOL_79_19 = 79, /* $@19 */
223 YYSYMBOL_80_20 = 80, /* $@20 */
224 YYSYMBOL_81_21 = 81, /* $@21 */
225 YYSYMBOL_82_22 = 82, /* $@22 */
226 YYSYMBOL_83_23 = 83, /* $@23 */
227 YYSYMBOL_84_24 = 84, /* $@24 */
228 YYSYMBOL_85_25 = 85, /* $@25 */
229 YYSYMBOL_86_26 = 86, /* $@26 */
230 YYSYMBOL_assign = 87, /* assign */
231 YYSYMBOL_expr = 88, /* expr */
232 YYSYMBOL_89_27 = 89, /* $@27 */
233 YYSYMBOL_90_28 = 90, /* $@28 */
234 YYSYMBOL_91_29 = 91, /* $@29 */
235 YYSYMBOL_92_30 = 92, /* $@30 */
236 YYSYMBOL_93_31 = 93, /* $@31 */
237 YYSYMBOL_94_32 = 94, /* $@32 */
238 YYSYMBOL_95_33 = 95, /* $@33 */
239 YYSYMBOL_96_34 = 96, /* $@34 */
240 YYSYMBOL_97_35 = 97, /* $@35 */
241 YYSYMBOL_98_36 = 98, /* $@36 */
242 YYSYMBOL_99_37 = 99, /* $@37 */
243 YYSYMBOL_100_38 = 100, /* $@38 */
244 YYSYMBOL_101_39 = 101, /* $@39 */
245 YYSYMBOL_cases = 102, /* cases */
246 YYSYMBOL_case = 103, /* case */
247 YYSYMBOL_104_40 = 104, /* $@40 */
248 YYSYMBOL_105_41 = 105, /* $@41 */
249 YYSYMBOL_lol = 106, /* lol */
250 YYSYMBOL_list = 107, /* list */
251 YYSYMBOL_listp = 108, /* listp */
252 YYSYMBOL_arg = 109, /* arg */
253 YYSYMBOL_110_42 = 110, /* @42 */
254 YYSYMBOL_func = 111, /* func */
255 YYSYMBOL_112_43 = 112, /* $@43 */
256 YYSYMBOL_113_44 = 113, /* $@44 */
257 YYSYMBOL_114_45 = 114, /* $@45 */
258 YYSYMBOL_eflags = 115, /* eflags */
259 YYSYMBOL_eflag = 116, /* eflag */
260 YYSYMBOL_bindlist = 117, /* bindlist */
261 YYSYMBOL_118_46 = 118 /* $@46 */
262 };
263 typedef enum yysymbol_kind_t yysymbol_kind_t;
264
265
266
267
268 #ifdef short
269 # undef short
270 #endif
271
272 /* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
273 <limits.h> and (if available) <stdint.h> are included
274 so that the code can choose integer types of a good width. */
275
276 #ifndef __PTRDIFF_MAX__
277 # include <limits.h> /* INFRINGES ON USER NAME SPACE */
278 # if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
279 # include <stdint.h> /* INFRINGES ON USER NAME SPACE */
280 # define YY_STDINT_H
281 # endif
282 #endif
283
284 /* Narrow types that promote to a signed type and that can represent a
285 signed or unsigned integer of at least N bits. In tables they can
286 save space and decrease cache pressure. Promoting to a signed type
287 helps avoid bugs in integer arithmetic. */
288
289 #ifdef __INT_LEAST8_MAX__
290 typedef __INT_LEAST8_TYPE__ yytype_int8;
291 #elif defined YY_STDINT_H
292 typedef int_least8_t yytype_int8;
293 #else
294 typedef signed char yytype_int8;
295 #endif
296
297 #ifdef __INT_LEAST16_MAX__
298 typedef __INT_LEAST16_TYPE__ yytype_int16;
299 #elif defined YY_STDINT_H
300 typedef int_least16_t yytype_int16;
301 #else
302 typedef short yytype_int16;
303 #endif
304
305 /* Work around bug in HP-UX 11.23, which defines these macros
306 incorrectly for preprocessor constants. This workaround can likely
307 be removed in 2023, as HPE has promised support for HP-UX 11.23
308 (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of
309 <https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>. */
310 #ifdef __hpux
311 # undef UINT_LEAST8_MAX
312 # undef UINT_LEAST16_MAX
313 # define UINT_LEAST8_MAX 255
314 # define UINT_LEAST16_MAX 65535
315 #endif
316
317 #if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
318 typedef __UINT_LEAST8_TYPE__ yytype_uint8;
319 #elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
320 && UINT_LEAST8_MAX <= INT_MAX)
321 typedef uint_least8_t yytype_uint8;
322 #elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
323 typedef unsigned char yytype_uint8;
324 #else
325 typedef short yytype_uint8;
326 #endif
327
328 #if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
329 typedef __UINT_LEAST16_TYPE__ yytype_uint16;
330 #elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
331 && UINT_LEAST16_MAX <= INT_MAX)
332 typedef uint_least16_t yytype_uint16;
333 #elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
334 typedef unsigned short yytype_uint16;
335 #else
336 typedef int yytype_uint16;
337 #endif
338
339 #ifndef YYPTRDIFF_T
340 # if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
341 # define YYPTRDIFF_T __PTRDIFF_TYPE__
342 # define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
343 # elif defined PTRDIFF_MAX
344 # ifndef ptrdiff_t
345 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
346 # endif
347 # define YYPTRDIFF_T ptrdiff_t
348 # define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
349 # else
350 # define YYPTRDIFF_T long
351 # define YYPTRDIFF_MAXIMUM LONG_MAX
352 # endif
353 #endif
354
355 #ifndef YYSIZE_T
356 # ifdef __SIZE_TYPE__
357 # define YYSIZE_T __SIZE_TYPE__
358 # elif defined size_t
359 # define YYSIZE_T size_t
360 # elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
361 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
362 # define YYSIZE_T size_t
363 # else
364 # define YYSIZE_T unsigned
365 # endif
366 #endif
367
368 #define YYSIZE_MAXIMUM \
369 YY_CAST (YYPTRDIFF_T, \
370 (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
371 ? YYPTRDIFF_MAXIMUM \
372 : YY_CAST (YYSIZE_T, -1)))
373
374 #define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
375
376
377 /* Stored state numbers (used for stacks). */
378 typedef yytype_uint8 yy_state_t;
379
380 /* State numbers in computations. */
381 typedef int yy_state_fast_t;
382
383 #ifndef YY_
384 # if defined YYENABLE_NLS && YYENABLE_NLS
385 # if ENABLE_NLS
386 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
387 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
388 # endif
389 # endif
390 # ifndef YY_
391 # define YY_(Msgid) Msgid
392 # endif
393 #endif
394
395
396 #ifndef YY_ATTRIBUTE_PURE
397 # if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
398 # define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
399 # else
400 # define YY_ATTRIBUTE_PURE
401 # endif
402 #endif
403
404 #ifndef YY_ATTRIBUTE_UNUSED
405 # if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
406 # define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
407 # else
408 # define YY_ATTRIBUTE_UNUSED
409 # endif
410 #endif
411
412 /* Suppress unused-variable warnings by "using" E. */
413 #if ! defined lint || defined __GNUC__
414 # define YY_USE(E) ((void) (E))
415 #else
416 # define YY_USE(E) /* empty */
417 #endif
418
419 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
420 #if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__
421 # if __GNUC__ * 100 + __GNUC_MINOR__ < 407
422 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
423 _Pragma ("GCC diagnostic push") \
424 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")
425 # else
426 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
427 _Pragma ("GCC diagnostic push") \
428 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
429 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
430 # endif
431 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
432 _Pragma ("GCC diagnostic pop")
433 #else
434 # define YY_INITIAL_VALUE(Value) Value
435 #endif
436 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
437 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
438 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
439 #endif
440 #ifndef YY_INITIAL_VALUE
441 # define YY_INITIAL_VALUE(Value) /* Nothing. */
442 #endif
443
444 #if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
445 # define YY_IGNORE_USELESS_CAST_BEGIN \
446 _Pragma ("GCC diagnostic push") \
447 _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
448 # define YY_IGNORE_USELESS_CAST_END \
449 _Pragma ("GCC diagnostic pop")
450 #endif
451 #ifndef YY_IGNORE_USELESS_CAST_BEGIN
452 # define YY_IGNORE_USELESS_CAST_BEGIN
453 # define YY_IGNORE_USELESS_CAST_END
454 #endif
455
456
457 #define YY_ASSERT(E) ((void) (0 && (E)))
458
459 #if !defined yyoverflow
460
461 /* The parser invokes alloca or malloc; define the necessary symbols. */
462
463 # ifdef YYSTACK_USE_ALLOCA
464 # if YYSTACK_USE_ALLOCA
465 # ifdef __GNUC__
466 # define YYSTACK_ALLOC __builtin_alloca
467 # elif defined __BUILTIN_VA_ARG_INCR
468 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
469 # elif defined _AIX
470 # define YYSTACK_ALLOC __alloca
471 # elif defined _MSC_VER
472 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
473 # define alloca _alloca
474 # else
475 # define YYSTACK_ALLOC alloca
476 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
477 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
478 /* Use EXIT_SUCCESS as a witness for stdlib.h. */
479 # ifndef EXIT_SUCCESS
480 # define EXIT_SUCCESS 0
481 # endif
482 # endif
483 # endif
484 # endif
485 # endif
486
487 # ifdef YYSTACK_ALLOC
488 /* Pacify GCC's 'empty if-body' warning. */
489 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
490 # ifndef YYSTACK_ALLOC_MAXIMUM
491 /* The OS might guarantee only one guard page at the bottom of the stack,
492 and a page size can be as small as 4096 bytes. So we cannot safely
493 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
494 to allow for a few compiler-allocated temporary stack slots. */
495 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
496 # endif
497 # else
498 # define YYSTACK_ALLOC YYMALLOC
499 # define YYSTACK_FREE YYFREE
500 # ifndef YYSTACK_ALLOC_MAXIMUM
501 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
502 # endif
503 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
504 && ! ((defined YYMALLOC || defined malloc) \
505 && (defined YYFREE || defined free)))
506 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
507 # ifndef EXIT_SUCCESS
508 # define EXIT_SUCCESS 0
509 # endif
510 # endif
511 # ifndef YYMALLOC
512 # define YYMALLOC malloc
513 # if ! defined malloc && ! defined EXIT_SUCCESS
514 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
515 # endif
516 # endif
517 # ifndef YYFREE
518 # define YYFREE free
519 # if ! defined free && ! defined EXIT_SUCCESS
520 void free (void *); /* INFRINGES ON USER NAME SPACE */
521 # endif
522 # endif
523 # endif
524 #endif /* !defined yyoverflow */
525
526 #if (! defined yyoverflow \
527 && (! defined __cplusplus \
528 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
529
530 /* A type that is properly aligned for any stack member. */
531 union yyalloc
532 {
533 yy_state_t yyss_alloc;
534 YYSTYPE yyvs_alloc;
535 };
536
537 /* The size of the maximum gap between one aligned stack and the next. */
538 # define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
539
540 /* The size of an array large to enough to hold all stacks, each with
541 N elements. */
542 # define YYSTACK_BYTES(N) \
543 ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
544 + YYSTACK_GAP_MAXIMUM)
545
546 # define YYCOPY_NEEDED 1
547
548 /* Relocate STACK from its old location to the new one. The
549 local variables YYSIZE and YYSTACKSIZE give the old and new number of
550 elements in the stack, and YYPTR gives the new location of the
551 stack. Advance YYPTR to a properly aligned location for the next
552 stack. */
553 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
554 do \
555 { \
556 YYPTRDIFF_T yynewbytes; \
557 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
558 Stack = &yyptr->Stack_alloc; \
559 yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
560 yyptr += yynewbytes / YYSIZEOF (*yyptr); \
561 } \
562 while (0)
563
564 #endif
565
566 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
567 /* Copy COUNT objects from SRC to DST. The source and destination do
568 not overlap. */
569 # ifndef YYCOPY
570 # if defined __GNUC__ && 1 < __GNUC__
571 # define YYCOPY(Dst, Src, Count) \
572 __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
573 # else
574 # define YYCOPY(Dst, Src, Count) \
575 do \
576 { \
577 YYPTRDIFF_T yyi; \
578 for (yyi = 0; yyi < (Count); yyi++) \
579 (Dst)[yyi] = (Src)[yyi]; \
580 } \
581 while (0)
582 # endif
583 # endif
584 #endif /* !YYCOPY_NEEDED */
585
586 /* YYFINAL -- State number of the termination state. */
587 #define YYFINAL 42
588 /* YYLAST -- Last index in YYTABLE. */
589 #define YYLAST 242
590
591 /* YYNTOKENS -- Number of terminals. */
592 #define YYNTOKENS 51
593 /* YYNNTS -- Number of nonterminals. */
594 #define YYNNTS 68
595 /* YYNRULES -- Number of rules. */
596 #define YYNRULES 121
597 /* YYNSTATES -- Number of states. */
598 #define YYNSTATES 207
599
600 /* YYMAXUTOK -- Last valid token kind. */
601 #define YYMAXUTOK 305
602
603
604 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
605 as returned by yylex, with out-of-bounds checking. */
606 #define YYTRANSLATE(YYX) \
607 (0 <= (YYX) && (YYX) <= YYMAXUTOK \
608 ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \
609 : YYSYMBOL_YYUNDEF)
610
611 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
612 as returned by yylex. */
613 static const yytype_int8 yytranslate[] =
614 {
615 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
616 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
617 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
618 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
619 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
620 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
621 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
622 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
623 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
624 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
625 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
626 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
627 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
628 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
629 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
630 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
631 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
632 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
633 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
634 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
635 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
636 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
637 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
638 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
639 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
640 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
641 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
642 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
643 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
644 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
645 45, 46, 47, 48, 49, 50
646 };
647
648 #if YYDEBUG
649 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
650 static const yytype_int16 yyrline[] =
651 {
652 0, 145, 145, 147, 158, 160, 164, 166, 168, 168,
653 168, 173, 176, 176, 178, 182, 185, 188, 191, 194,
654 197, 199, 201, 201, 203, 203, 205, 205, 207, 207,
655 207, 209, 209, 211, 213, 215, 215, 215, 217, 217,
656 217, 219, 219, 219, 221, 221, 221, 223, 223, 223,
657 225, 225, 225, 227, 227, 227, 227, 229, 232, 234,
658 231, 243, 245, 247, 249, 256, 258, 258, 260, 260,
659 262, 262, 264, 264, 266, 266, 268, 268, 270, 270,
660 272, 272, 274, 274, 276, 276, 278, 278, 280, 280,
661 282, 282, 294, 295, 299, 299, 299, 308, 310, 320,
662 325, 326, 330, 332, 332, 341, 341, 343, 343, 345,
663 345, 356, 357, 361, 363, 365, 367, 369, 371, 381,
664 382, 382
665 };
666 #endif
667
668 /** Accessing symbol of state STATE. */
669 #define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
670
671 #if YYDEBUG || 0
672 /* The user-facing name of the symbol whose (internal) number is
673 YYSYMBOL. No bounds checking. */
674 static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED;
675
676 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
677 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
678 static const char *const yytname[] =
679 {
680 "\"end of file\"", "error", "\"invalid token\"", "_BANG_t",
681 "_BANG_EQUALS_t", "_AMPER_t", "_AMPERAMPER_t", "_LPAREN_t", "_RPAREN_t",
682 "_PLUS_EQUALS_t", "_COLON_t", "_SEMIC_t", "_LANGLE_t",
683 "_LANGLE_EQUALS_t", "_EQUALS_t", "_RANGLE_t", "_RANGLE_EQUALS_t",
684 "_QUESTION_EQUALS_t", "_LBRACKET_t", "_RBRACKET_t", "ACTIONS_t",
685 "BIND_t", "BREAK_t", "CASE_t", "CLASS_t", "CONTINUE_t", "DEFAULT_t",
686 "ELSE_t", "EXISTING_t", "FOR_t", "IF_t", "IGNORE_t", "IN_t", "INCLUDE_t",
687 "LOCAL_t", "MODULE_t", "ON_t", "PIECEMEAL_t", "QUIETLY_t", "RETURN_t",
688 "RULE_t", "SWITCH_t", "TOGETHER_t", "UPDATED_t", "WHILE_t", "_LBRACE_t",
689 "_BAR_t", "_BARBAR_t", "_RBRACE_t", "ARG", "STRING", "$accept", "run",
690 "block", "rules", "$@1", "$@2", "null", "assign_list_opt", "$@3",
691 "arglist_opt", "local_opt", "else_opt", "rule", "$@4", "$@5", "$@6",
692 "$@7", "$@8", "$@9", "$@10", "$@11", "$@12", "$@13", "$@14", "$@15",
693 "$@16", "$@17", "$@18", "$@19", "$@20", "$@21", "$@22", "$@23", "$@24",
694 "$@25", "$@26", "assign", "expr", "$@27", "$@28", "$@29", "$@30", "$@31",
695 "$@32", "$@33", "$@34", "$@35", "$@36", "$@37", "$@38", "$@39", "cases",
696 "case", "$@40", "$@41", "lol", "list", "listp", "arg", "@42", "func",
697 "$@43", "$@44", "$@45", "eflags", "eflag", "bindlist", "$@46", YY_NULLPTR
698 };
699
700 static const char *
701 yysymbol_name (yysymbol_kind_t yysymbol)
702 {
703 return yytname[yysymbol];
704 }
705 #endif
706
707 #define YYPACT_NINF (-119)
708
709 #define yypact_value_is_default(Yyn) \
710 ((Yyn) == YYPACT_NINF)
711
712 #define YYTABLE_NINF (-25)
713
714 #define yytable_value_is_error(Yyn) \
715 0
716
717 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
718 STATE-NUM. */
719 static const yytype_int16 yypact[] =
720 {
721 140, -119, -119, 1, -119, 2, -18, -119, -119, -23,
722 -119, -9, -119, -119, -119, 140, 12, 31, -119, 4,
723 140, 77, -17, 186, -119, -119, -119, -119, -7, 3,
724 -119, -119, -119, -119, 177, -119, -119, 3, -5, -119,
725 -119, -119, -119, -119, -119, -119, -119, -119, 33, -119,
726 -119, -9, -119, 29, -119, -119, -119, -119, -119, -119,
727 35, -119, 14, 50, -9, 34, -119, -119, 23, 39,
728 52, 53, 40, -119, 66, 45, 94, -119, 67, 30,
729 -119, -119, -119, 16, -119, -119, -119, 47, -119, -119,
730 -119, -119, 3, 3, -119, -119, -119, -119, -119, -119,
731 -119, -119, -119, -119, -119, -119, -119, -119, -119, 84,
732 -119, -119, -119, 51, -119, -119, 32, 105, -119, -119,
733 -119, -119, -119, 140, -119, -119, -119, 68, 3, 3,
734 3, 3, 3, 3, 3, 3, 140, 3, 3, -119,
735 -119, -119, 140, 95, 140, 110, -119, -119, -119, -119,
736 -119, 69, 73, 87, -119, 89, 139, 139, -119, -119,
737 89, -119, -119, 90, 226, 226, -119, -119, 140, 91,
738 -119, 97, 95, 98, -119, -119, -119, -119, -119, -119,
739 -119, -119, 108, -119, -119, 88, -119, -119, -119, 141,
740 177, 145, 102, 140, 177, -119, 149, -119, -119, -119,
741 -119, 115, -119, -119, -119, 140, -119
742 };
743
744 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
745 Performed when YYTABLE does not specify something else to do. Zero
746 means the default is an error. */
747 static const yytype_int8 yydefact[] =
748 {
749 2, 103, 111, 0, 47, 0, 18, 41, 22, 8,
750 44, 0, 31, 38, 50, 11, 102, 0, 3, 0,
751 6, 0, 0, 0, 33, 100, 34, 17, 0, 0,
752 100, 100, 100, 102, 18, 100, 100, 0, 0, 5,
753 4, 100, 1, 53, 7, 62, 61, 63, 0, 28,
754 26, 0, 105, 0, 118, 115, 117, 116, 114, 113,
755 119, 112, 0, 97, 99, 0, 88, 90, 0, 65,
756 0, 11, 0, 57, 0, 0, 51, 21, 0, 0,
757 64, 100, 100, 0, 100, 104, 120, 0, 48, 100,
758 101, 35, 0, 0, 68, 78, 80, 70, 72, 66,
759 74, 76, 42, 82, 84, 86, 23, 12, 14, 0,
760 45, 32, 39, 0, 25, 54, 0, 0, 109, 107,
761 106, 100, 58, 11, 98, 100, 89, 0, 0, 0,
762 0, 0, 0, 0, 0, 0, 11, 0, 0, 100,
763 100, 9, 11, 92, 11, 16, 29, 27, 100, 100,
764 121, 0, 0, 0, 91, 69, 79, 81, 71, 73,
765 67, 75, 77, 0, 83, 85, 87, 13, 11, 0,
766 94, 0, 92, 0, 100, 55, 100, 110, 108, 59,
767 49, 36, 20, 10, 46, 0, 40, 93, 52, 0,
768 18, 0, 0, 11, 18, 43, 0, 15, 56, 30,
769 60, 0, 19, 95, 37, 11, 96
770 };
771
772 /* YYPGOTO[NTERM-NUM]. */
773 static const yytype_int16 yypgoto[] =
774 {
775 -119, -119, -118, 25, -119, -119, 96, -119, -119, -119,
776 160, -119, -33, -119, -119, -119, -119, -119, -119, -119,
777 -119, -119, -119, -119, -119, -119, -119, -119, -119, -119,
778 -119, -119, -119, -119, -119, -119, 55, -4, -119, -119,
779 -119, -119, -119, -119, -119, -119, -119, -119, -119, -119,
780 -119, 5, -119, -119, -119, -27, -28, -119, 0, -119,
781 -119, -119, -119, -119, -119, -119, -119, -119
782 };
783
784 /* YYDEFGOTO[NTERM-NUM]. */
785 static const yytype_uint8 yydefgoto[] =
786 {
787 0, 17, 38, 39, 31, 168, 40, 109, 140, 175,
788 19, 195, 20, 30, 41, 82, 81, 176, 35, 125,
789 193, 36, 143, 29, 136, 32, 142, 25, 123, 37,
790 113, 79, 145, 190, 151, 192, 50, 68, 133, 128,
791 131, 132, 134, 135, 129, 130, 137, 138, 139, 92,
792 93, 171, 172, 185, 205, 62, 63, 64, 69, 22,
793 53, 84, 149, 148, 23, 61, 87, 121
794 };
795
796 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
797 positive, shift that token. If negative, reduce the rule whose
798 number is the opposite. If YYTABLE_NINF, syntax error. */
799 static const yytype_int16 yytable[] =
800 {
801 21, 73, 70, 71, 72, 152, 66, 74, 75, 1,
802 67, 34, 24, 26, 78, 21, 27, -17, 163, 51,
803 21, 1, -24, -24, 169, 18, 173, 94, 95, 96,
804 -24, 42, 52, 76, 21, 97, 98, 99, 100, 101,
805 33, 45, 65, 77, 43, 44, 46, 80, 85, 47,
806 183, 83, 33, 116, 117, 118, 86, 120, 48, 88,
807 89, -24, 124, 106, 90, 119, 91, 107, 102, 103,
808 104, 105, 94, 95, 96, 201, 154, 111, 114, 115,
809 97, 98, 99, 100, 101, 110, 45, 206, 126, 127,
810 112, 46, 122, 150, 47, 141, 144, 153, 94, 95,
811 96, 97, 98, 48, 100, 101, 97, 98, 99, 100,
812 101, 166, 167, 49, 103, 104, 147, 174, 170, 179,
813 177, 180, 178, 21, 155, 156, 157, 158, 159, 160,
814 161, 162, 181, 164, 165, 194, 21, 196, 182, 184,
815 103, 104, 21, 94, 21, 186, 188, 189, 191, 197,
816 200, 97, 98, 99, 100, 101, 199, 198, 1, 203,
817 2, 202, 3, 204, 4, 5, 28, 108, 21, 6,
818 7, 146, 0, 8, 9, 10, 11, 187, 0, 12,
819 -18, 13, 0, 0, 14, 15, 0, 0, 0, 16,
820 21, 0, 0, 21, 21, 1, 0, 2, 0, 3,
821 0, 4, 5, 0, 0, 21, 6, 7, 0, 0,
822 8, 27, 10, 11, 54, 0, 12, 55, 13, 0,
823 0, 14, 15, 56, 57, 0, 16, 0, 58, 59,
824 94, 95, 96, 0, 0, 60, 0, 0, 97, 98,
825 99, 100, 101
826 };
827
828 static const yytype_int16 yycheck[] =
829 {
830 0, 34, 30, 31, 32, 123, 3, 35, 36, 18,
831 7, 11, 11, 11, 41, 15, 34, 40, 136, 36,
832 20, 18, 10, 11, 142, 0, 144, 4, 5, 6,
833 18, 0, 49, 37, 34, 12, 13, 14, 15, 16,
834 49, 9, 49, 48, 40, 20, 14, 14, 19, 17,
835 168, 51, 49, 81, 82, 39, 21, 84, 26, 45,
836 10, 49, 89, 11, 64, 49, 32, 14, 45, 46,
837 47, 32, 4, 5, 6, 193, 8, 11, 11, 49,
838 12, 13, 14, 15, 16, 45, 9, 205, 92, 93,
839 45, 14, 45, 121, 17, 11, 45, 125, 4, 5,
840 6, 12, 13, 26, 15, 16, 12, 13, 14, 15,
841 16, 139, 140, 36, 46, 47, 11, 7, 23, 50,
842 148, 48, 149, 123, 128, 129, 130, 131, 132, 133,
843 134, 135, 45, 137, 138, 27, 136, 49, 48, 48,
844 46, 47, 142, 4, 144, 48, 48, 174, 176, 8,
845 48, 12, 13, 14, 15, 16, 11, 190, 18, 10,
846 20, 194, 22, 48, 24, 25, 6, 71, 168, 29,
847 30, 116, -1, 33, 34, 35, 36, 172, -1, 39,
848 40, 41, -1, -1, 44, 45, -1, -1, -1, 49,
849 190, -1, -1, 193, 194, 18, -1, 20, -1, 22,
850 -1, 24, 25, -1, -1, 205, 29, 30, -1, -1,
851 33, 34, 35, 36, 28, -1, 39, 31, 41, -1,
852 -1, 44, 45, 37, 38, -1, 49, -1, 42, 43,
853 4, 5, 6, -1, -1, 49, -1, -1, 12, 13,
854 14, 15, 16
855 };
856
857 /* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of
858 state STATE-NUM. */
859 static const yytype_int8 yystos[] =
860 {
861 0, 18, 20, 22, 24, 25, 29, 30, 33, 34,
862 35, 36, 39, 41, 44, 45, 49, 52, 54, 61,
863 63, 109, 110, 115, 11, 78, 11, 34, 61, 74,
864 64, 55, 76, 49, 109, 69, 72, 80, 53, 54,
865 57, 65, 0, 40, 54, 9, 14, 17, 26, 36,
866 87, 36, 49, 111, 28, 31, 37, 38, 42, 43,
867 49, 116, 106, 107, 108, 49, 3, 7, 88, 109,
868 107, 107, 107, 63, 107, 107, 88, 48, 106, 82,
869 14, 67, 66, 109, 112, 19, 21, 117, 45, 10,
870 109, 32, 100, 101, 4, 5, 6, 12, 13, 14,
871 15, 16, 45, 46, 47, 32, 11, 14, 57, 58,
872 45, 11, 45, 81, 11, 49, 107, 107, 39, 49,
873 106, 118, 45, 79, 106, 70, 88, 88, 90, 95,
874 96, 91, 92, 89, 93, 94, 75, 97, 98, 99,
875 59, 11, 77, 73, 45, 83, 87, 11, 114, 113,
876 107, 85, 53, 107, 8, 88, 88, 88, 88, 88,
877 88, 88, 88, 53, 88, 88, 107, 107, 56, 53,
878 23, 102, 103, 53, 7, 60, 68, 107, 106, 50,
879 48, 45, 48, 53, 48, 104, 48, 102, 48, 106,
880 84, 107, 86, 71, 27, 62, 49, 8, 63, 11,
881 48, 53, 63, 10, 48, 105, 53
882 };
883
884 /* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */
885 static const yytype_int8 yyr1[] =
886 {
887 0, 51, 52, 52, 53, 53, 54, 54, 55, 56,
888 54, 57, 59, 58, 58, 60, 60, 61, 61, 62,
889 62, 63, 64, 63, 65, 63, 66, 63, 67, 68,
890 63, 69, 63, 63, 63, 70, 71, 63, 72, 73,
891 63, 74, 75, 63, 76, 77, 63, 78, 79, 63,
892 80, 81, 63, 82, 83, 84, 63, 63, 85, 86,
893 63, 87, 87, 87, 87, 88, 89, 88, 90, 88,
894 91, 88, 92, 88, 93, 88, 94, 88, 95, 88,
895 96, 88, 97, 88, 98, 88, 99, 88, 100, 88,
896 101, 88, 102, 102, 104, 105, 103, 106, 106, 107,
897 108, 108, 109, 110, 109, 112, 111, 113, 111, 114,
898 111, 115, 115, 116, 116, 116, 116, 116, 116, 117,
899 118, 117
900 };
901
902 /* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */
903 static const yytype_int8 yyr2[] =
904 {
905 0, 2, 0, 1, 1, 1, 1, 2, 0, 0,
906 7, 0, 0, 3, 1, 3, 0, 1, 0, 2,
907 0, 3, 0, 4, 0, 4, 0, 5, 0, 0,
908 8, 0, 4, 2, 2, 0, 0, 10, 0, 0,
909 7, 0, 0, 8, 0, 0, 7, 0, 0, 7,
910 0, 0, 7, 0, 0, 0, 8, 3, 0, 0,
911 9, 1, 1, 1, 2, 1, 0, 4, 0, 4,
912 0, 4, 0, 4, 0, 4, 0, 4, 0, 4,
913 0, 4, 0, 4, 0, 4, 0, 4, 0, 3,
914 0, 4, 0, 2, 0, 0, 6, 1, 3, 1,
915 0, 2, 1, 0, 4, 0, 3, 0, 5, 0,
916 5, 0, 2, 1, 1, 1, 1, 1, 1, 0,
917 0, 3
918 };
919
920
921 enum { YYENOMEM = -2 };
922
923 #define yyerrok (yyerrstatus = 0)
924 #define yyclearin (yychar = YYEMPTY)
925
926 #define YYACCEPT goto yyacceptlab
927 #define YYABORT goto yyabortlab
928 #define YYERROR goto yyerrorlab
929 #define YYNOMEM goto yyexhaustedlab
930
931
932 #define YYRECOVERING() (!!yyerrstatus)
933
934 #define YYBACKUP(Token, Value) \
935 do \
936 if (yychar == YYEMPTY) \
937 { \
938 yychar = (Token); \
939 yylval = (Value); \
940 YYPOPSTACK (yylen); \
941 yystate = *yyssp; \
942 goto yybackup; \
943 } \
944 else \
945 { \
946 yyerror (YY_("syntax error: cannot back up")); \
947 YYERROR; \
948 } \
949 while (0)
950
951 /* Backward compatibility with an undocumented macro.
952 Use YYerror or YYUNDEF. */
953 #define YYERRCODE YYUNDEF
954
955
956 /* Enable debugging if requested. */
957 #if YYDEBUG
958
959 # ifndef YYFPRINTF
960 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
961 # define YYFPRINTF fprintf
962 # endif
963
964 # define YYDPRINTF(Args) \
965 do { \
966 if (yydebug) \
967 YYFPRINTF Args; \
968 } while (0)
969
970
971
972
973 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \
974 do { \
975 if (yydebug) \
976 { \
977 YYFPRINTF (stderr, "%s ", Title); \
978 yy_symbol_print (stderr, \
979 Kind, Value); \
980 YYFPRINTF (stderr, "\n"); \
981 } \
982 } while (0)
983
984
985 /*-----------------------------------.
986 | Print this symbol's value on YYO. |
987 `-----------------------------------*/
988
989 static void
990 yy_symbol_value_print (FILE *yyo,
991 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
992 {
993 FILE *yyoutput = yyo;
994 YY_USE (yyoutput);
995 if (!yyvaluep)
996 return;
997 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
998 YY_USE (yykind);
999 YY_IGNORE_MAYBE_UNINITIALIZED_END
1000 }
1001
1002
1003 /*---------------------------.
1004 | Print this symbol on YYO. |
1005 `---------------------------*/
1006
1007 static void
1008 yy_symbol_print (FILE *yyo,
1009 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
1010 {
1011 YYFPRINTF (yyo, "%s %s (",
1012 yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));
1013
1014 yy_symbol_value_print (yyo, yykind, yyvaluep);
1015 YYFPRINTF (yyo, ")");
1016 }
1017
1018 /*------------------------------------------------------------------.
1019 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1020 | TOP (included). |
1021 `------------------------------------------------------------------*/
1022
1023 static void
1024 yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
1025 {
1026 YYFPRINTF (stderr, "Stack now");
1027 for (; yybottom <= yytop; yybottom++)
1028 {
1029 int yybot = *yybottom;
1030 YYFPRINTF (stderr, " %d", yybot);
1031 }
1032 YYFPRINTF (stderr, "\n");
1033 }
1034
1035 # define YY_STACK_PRINT(Bottom, Top) \
1036 do { \
1037 if (yydebug) \
1038 yy_stack_print ((Bottom), (Top)); \
1039 } while (0)
1040
1041
1042 /*------------------------------------------------.
1043 | Report that the YYRULE is going to be reduced. |
1044 `------------------------------------------------*/
1045
1046 static void
1047 yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp,
1048 int yyrule)
1049 {
1050 int yylno = yyrline[yyrule];
1051 int yynrhs = yyr2[yyrule];
1052 int yyi;
1053 YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
1054 yyrule - 1, yylno);
1055 /* The symbols being reduced. */
1056 for (yyi = 0; yyi < yynrhs; yyi++)
1057 {
1058 YYFPRINTF (stderr, " $%d = ", yyi + 1);
1059 yy_symbol_print (stderr,
1060 YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
1061 &yyvsp[(yyi + 1) - (yynrhs)]);
1062 YYFPRINTF (stderr, "\n");
1063 }
1064 }
1065
1066 # define YY_REDUCE_PRINT(Rule) \
1067 do { \
1068 if (yydebug) \
1069 yy_reduce_print (yyssp, yyvsp, Rule); \
1070 } while (0)
1071
1072 /* Nonzero means print parse trace. It is left uninitialized so that
1073 multiple parsers can coexist. */
1074 int yydebug;
1075 #else /* !YYDEBUG */
1076 # define YYDPRINTF(Args) ((void) 0)
1077 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
1078 # define YY_STACK_PRINT(Bottom, Top)
1079 # define YY_REDUCE_PRINT(Rule)
1080 #endif /* !YYDEBUG */
1081
1082
1083 /* YYINITDEPTH -- initial size of the parser's stacks. */
1084 #ifndef YYINITDEPTH
1085 # define YYINITDEPTH 200
1086 #endif
1087
1088 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1089 if the built-in stack extension method is used).
1090
1091 Do not make this value too large; the results are undefined if
1092 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1093 evaluated with infinite-precision integer arithmetic. */
1094
1095 #ifndef YYMAXDEPTH
1096 # define YYMAXDEPTH 10000
1097 #endif
1098
1099
1100
1101
1102
1103
1104 /*-----------------------------------------------.
1105 | Release the memory associated to this symbol. |
1106 `-----------------------------------------------*/
1107
1108 static void
1109 yydestruct (const char *yymsg,
1110 yysymbol_kind_t yykind, YYSTYPE *yyvaluep)
1111 {
1112 YY_USE (yyvaluep);
1113 if (!yymsg)
1114 yymsg = "Deleting";
1115 YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
1116
1117 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1118 YY_USE (yykind);
1119 YY_IGNORE_MAYBE_UNINITIALIZED_END
1120 }
1121
1122
1123 /* Lookahead token kind. */
1124 int yychar;
1125
1126 /* The semantic value of the lookahead symbol. */
1127 YYSTYPE yylval;
1128 /* Number of syntax errors so far. */
1129 int yynerrs;
1130
1131
1132
1133
1134 /*----------.
1135 | yyparse. |
1136 `----------*/
1137
1138 int
1139 yyparse (void)
1140 {
1141 yy_state_fast_t yystate = 0;
1142 /* Number of tokens to shift before error messages enabled. */
1143 int yyerrstatus = 0;
1144
1145 /* Refer to the stacks through separate pointers, to allow yyoverflow
1146 to reallocate them elsewhere. */
1147
1148 /* Their size. */
1149 YYPTRDIFF_T yystacksize = YYINITDEPTH;
1150
1151 /* The state stack: array, bottom, top. */
1152 yy_state_t yyssa[YYINITDEPTH];
1153 yy_state_t *yyss = yyssa;
1154 yy_state_t *yyssp = yyss;
1155
1156 /* The semantic value stack: array, bottom, top. */
1157 YYSTYPE yyvsa[YYINITDEPTH];
1158 YYSTYPE *yyvs = yyvsa;
1159 YYSTYPE *yyvsp = yyvs;
1160
1161 int yyn;
1162 /* The return value of yyparse. */
1163 int yyresult;
1164 /* Lookahead symbol kind. */
1165 yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY;
1166 /* The variables used to return semantic value and location from the
1167 action routines. */
1168 YYSTYPE yyval;
1169
1170
1171
1172 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1173
1174 /* The number of symbols on the RHS of the reduced rule.
1175 Keep to zero when no symbol should be popped. */
1176 int yylen = 0;
1177
1178 YYDPRINTF ((stderr, "Starting parse\n"));
1179
1180 yychar = YYEMPTY; /* Cause a token to be read. */
1181
1182 goto yysetstate;
1183
1184
1185 /*------------------------------------------------------------.
1186 | yynewstate -- push a new state, which is found in yystate. |
1187 `------------------------------------------------------------*/
1188 yynewstate:
1189 /* In all cases, when you get here, the value and location stacks
1190 have just been pushed. So pushing a state here evens the stacks. */
1191 yyssp++;
1192
1193
1194 /*--------------------------------------------------------------------.
1195 | yysetstate -- set current state (the top of the stack) to yystate. |
1196 `--------------------------------------------------------------------*/
1197 yysetstate:
1198 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1199 YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
1200 YY_IGNORE_USELESS_CAST_BEGIN
1201 *yyssp = YY_CAST (yy_state_t, yystate);
1202 YY_IGNORE_USELESS_CAST_END
1203 YY_STACK_PRINT (yyss, yyssp);
1204
1205 if (yyss + yystacksize - 1 <= yyssp)
1206 #if !defined yyoverflow && !defined YYSTACK_RELOCATE
1207 YYNOMEM;
1208 #else
1209 {
1210 /* Get the current used size of the three stacks, in elements. */
1211 YYPTRDIFF_T yysize = yyssp - yyss + 1;
1212
1213 # if defined yyoverflow
1214 {
1215 /* Give user a chance to reallocate the stack. Use copies of
1216 these so that the &'s don't force the real ones into
1217 memory. */
1218 yy_state_t *yyss1 = yyss;
1219 YYSTYPE *yyvs1 = yyvs;
1220
1221 /* Each stack pointer address is followed by the size of the
1222 data in use in that stack, in bytes. This used to be a
1223 conditional around just the two extra args, but that might
1224 be undefined if yyoverflow is a macro. */
1225 yyoverflow (YY_("memory exhausted"),
1226 &yyss1, yysize * YYSIZEOF (*yyssp),
1227 &yyvs1, yysize * YYSIZEOF (*yyvsp),
1228 &yystacksize);
1229 yyss = yyss1;
1230 yyvs = yyvs1;
1231 }
1232 # else /* defined YYSTACK_RELOCATE */
1233 /* Extend the stack our own way. */
1234 if (YYMAXDEPTH <= yystacksize)
1235 YYNOMEM;
1236 yystacksize *= 2;
1237 if (YYMAXDEPTH < yystacksize)
1238 yystacksize = YYMAXDEPTH;
1239
1240 {
1241 yy_state_t *yyss1 = yyss;
1242 union yyalloc *yyptr =
1243 YY_CAST (union yyalloc *,
1244 YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
1245 if (! yyptr)
1246 YYNOMEM;
1247 YYSTACK_RELOCATE (yyss_alloc, yyss);
1248 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1249 # undef YYSTACK_RELOCATE
1250 if (yyss1 != yyssa)
1251 YYSTACK_FREE (yyss1);
1252 }
1253 # endif
1254
1255 yyssp = yyss + yysize - 1;
1256 yyvsp = yyvs + yysize - 1;
1257
1258 YY_IGNORE_USELESS_CAST_BEGIN
1259 YYDPRINTF ((stderr, "Stack size increased to %ld\n",
1260 YY_CAST (long, yystacksize)));
1261 YY_IGNORE_USELESS_CAST_END
1262
1263 if (yyss + yystacksize - 1 <= yyssp)
1264 YYABORT;
1265 }
1266 #endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
1267
1268
1269 if (yystate == YYFINAL)
1270 YYACCEPT;
1271
1272 goto yybackup;
1273
1274
1275 /*-----------.
1276 | yybackup. |
1277 `-----------*/
1278 yybackup:
1279 /* Do appropriate processing given the current state. Read a
1280 lookahead token if we need one and don't already have one. */
1281
1282 /* First try to decide what to do without reference to lookahead token. */
1283 yyn = yypact[yystate];
1284 if (yypact_value_is_default (yyn))
1285 goto yydefault;
1286
1287 /* Not known => get a lookahead token if don't already have one. */
1288
1289 /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */
1290 if (yychar == YYEMPTY)
1291 {
1292 YYDPRINTF ((stderr, "Reading a token\n"));
1293 yychar = yylex ();
1294 }
1295
1296 if (yychar <= YYEOF)
1297 {
1298 yychar = YYEOF;
1299 yytoken = YYSYMBOL_YYEOF;
1300 YYDPRINTF ((stderr, "Now at end of input.\n"));
1301 }
1302 else if (yychar == YYerror)
1303 {
1304 /* The scanner already issued an error message, process directly
1305 to error recovery. But do not keep the error token as
1306 lookahead, it is too special and may lead us to an endless
1307 loop in error recovery. */
1308 yychar = YYUNDEF;
1309 yytoken = YYSYMBOL_YYerror;
1310 goto yyerrlab1;
1311 }
1312 else
1313 {
1314 yytoken = YYTRANSLATE (yychar);
1315 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1316 }
1317
1318 /* If the proper action on seeing token YYTOKEN is to reduce or to
1319 detect an error, take that action. */
1320 yyn += yytoken;
1321 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1322 goto yydefault;
1323 yyn = yytable[yyn];
1324 if (yyn <= 0)
1325 {
1326 if (yytable_value_is_error (yyn))
1327 goto yyerrlab;
1328 yyn = -yyn;
1329 goto yyreduce;
1330 }
1331
1332 /* Count tokens shifted since error; after three, turn off error
1333 status. */
1334 if (yyerrstatus)
1335 yyerrstatus--;
1336
1337 /* Shift the lookahead token. */
1338 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1339 yystate = yyn;
1340 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1341 *++yyvsp = yylval;
1342 YY_IGNORE_MAYBE_UNINITIALIZED_END
1343
1344 /* Discard the shifted token. */
1345 yychar = YYEMPTY;
1346 goto yynewstate;
1347
1348
1349 /*-----------------------------------------------------------.
1350 | yydefault -- do the default action for the current state. |
1351 `-----------------------------------------------------------*/
1352 yydefault:
1353 yyn = yydefact[yystate];
1354 if (yyn == 0)
1355 goto yyerrlab;
1356 goto yyreduce;
1357
1358
1359 /*-----------------------------.
1360 | yyreduce -- do a reduction. |
1361 `-----------------------------*/
1362 yyreduce:
1363 /* yyn is the number of a rule to reduce with. */
1364 yylen = yyr2[yyn];
1365
1366 /* If YYLEN is nonzero, implement the default value of the action:
1367 '$$ = $1'.
1368
1369 Otherwise, the following line sets YYVAL to garbage.
1370 This behavior is undocumented and Bison
1371 users should not rely upon it. Assigning to YYVAL
1372 unconditionally makes the parser a bit smaller, and it avoids a
1373 GCC warning that YYVAL may be used uninitialized. */
1374 yyval = yyvsp[1-yylen];
1375
1376
1377 YY_REDUCE_PRINT (yyn);
1378 switch (yyn)
1379 {
1380 case 3: /* run: rules */
1381 #line 148 "src/engine/jamgram.y"
1382 { parse_save( yyvsp[0].parse ); }
1383 #line 1384 "src/engine/jamgram.cpp"
1384 break;
1385
1386 case 4: /* block: null */
1387 #line 159 "src/engine/jamgram.y"
1388 { yyval.parse = yyvsp[0].parse; }
1389 #line 1390 "src/engine/jamgram.cpp"
1390 break;
1391
1392 case 5: /* block: rules */
1393 #line 161 "src/engine/jamgram.y"
1394 { yyval.parse = yyvsp[0].parse; }
1395 #line 1396 "src/engine/jamgram.cpp"
1396 break;
1397
1398 case 6: /* rules: rule */
1399 #line 165 "src/engine/jamgram.y"
1400 { yyval.parse = yyvsp[0].parse; }
1401 #line 1402 "src/engine/jamgram.cpp"
1402 break;
1403
1404 case 7: /* rules: rule rules */
1405 #line 167 "src/engine/jamgram.y"
1406 { yyval.parse = prules( yyvsp[-1].parse, yyvsp[0].parse ); }
1407 #line 1408 "src/engine/jamgram.cpp"
1408 break;
1409
1410 case 8: /* $@1: %empty */
1411 #line 168 "src/engine/jamgram.y"
1412 { yymode( SCAN_ASSIGN ); }
1413 #line 1414 "src/engine/jamgram.cpp"
1414 break;
1415
1416 case 9: /* $@2: %empty */
1417 #line 168 "src/engine/jamgram.y"
1418 { yymode( SCAN_NORMAL ); }
1419 #line 1420 "src/engine/jamgram.cpp"
1420 break;
1421
1422 case 10: /* rules: LOCAL_t $@1 list assign_list_opt _SEMIC_t $@2 block */
1423 #line 169 "src/engine/jamgram.y"
1424 { yyval.parse = plocal( yyvsp[-4].parse, yyvsp[-3].parse, yyvsp[0].parse ); }
1425 #line 1426 "src/engine/jamgram.cpp"
1426 break;
1427
1428 case 11: /* null: %empty */
1429 #line 173 "src/engine/jamgram.y"
1430 { yyval.parse = pnull(); }
1431 #line 1432 "src/engine/jamgram.cpp"
1432 break;
1433
1434 case 12: /* $@3: %empty */
1435 #line 176 "src/engine/jamgram.y"
1436 { yymode( SCAN_PUNCT ); }
1437 #line 1438 "src/engine/jamgram.cpp"
1438 break;
1439
1440 case 13: /* assign_list_opt: _EQUALS_t $@3 list */
1441 #line 177 "src/engine/jamgram.y"
1442 { yyval.parse = yyvsp[0].parse; yyval.number = ASSIGN_SET; }
1443 #line 1444 "src/engine/jamgram.cpp"
1444 break;
1445
1446 case 14: /* assign_list_opt: null */
1447 #line 179 "src/engine/jamgram.y"
1448 { yyval.parse = yyvsp[0].parse; yyval.number = ASSIGN_APPEND; }
1449 #line 1450 "src/engine/jamgram.cpp"
1450 break;
1451
1452 case 15: /* arglist_opt: _LPAREN_t lol _RPAREN_t */
1453 #line 183 "src/engine/jamgram.y"
1454 { yyval.parse = yyvsp[-1].parse; }
1455 #line 1456 "src/engine/jamgram.cpp"
1456 break;
1457
1458 case 16: /* arglist_opt: %empty */
1459 #line 185 "src/engine/jamgram.y"
1460 { yyval.parse = P0; }
1461 #line 1462 "src/engine/jamgram.cpp"
1462 break;
1463
1464 case 17: /* local_opt: LOCAL_t */
1465 #line 189 "src/engine/jamgram.y"
1466 { yyval.number = 1; }
1467 #line 1468 "src/engine/jamgram.cpp"
1468 break;
1469
1470 case 18: /* local_opt: %empty */
1471 #line 191 "src/engine/jamgram.y"
1472 { yyval.number = 0; }
1473 #line 1474 "src/engine/jamgram.cpp"
1474 break;
1475
1476 case 19: /* else_opt: ELSE_t rule */
1477 #line 195 "src/engine/jamgram.y"
1478 { yyval.parse = yyvsp[0].parse; }
1479 #line 1480 "src/engine/jamgram.cpp"
1480 break;
1481
1482 case 20: /* else_opt: %empty */
1483 #line 197 "src/engine/jamgram.y"
1484 { yyval.parse = pnull(); }
1485 #line 1486 "src/engine/jamgram.cpp"
1486 break;
1487
1488 case 21: /* rule: _LBRACE_t block _RBRACE_t */
1489 #line 200 "src/engine/jamgram.y"
1490 { yyval.parse = yyvsp[-1].parse; }
1491 #line 1492 "src/engine/jamgram.cpp"
1492 break;
1493
1494 case 22: /* $@4: %empty */
1495 #line 201 "src/engine/jamgram.y"
1496 { yymode( SCAN_PUNCT ); }
1497 #line 1498 "src/engine/jamgram.cpp"
1498 break;
1499
1500 case 23: /* rule: INCLUDE_t $@4 list _SEMIC_t */
1501 #line 202 "src/engine/jamgram.y"
1502 { yyval.parse = pincl( yyvsp[-1].parse ); yymode( SCAN_NORMAL ); }
1503 #line 1504 "src/engine/jamgram.cpp"
1504 break;
1505
1506 case 24: /* $@5: %empty */
1507 #line 203 "src/engine/jamgram.y"
1508 { yymode( SCAN_PUNCT ); }
1509 #line 1510 "src/engine/jamgram.cpp"
1510 break;
1511
1512 case 25: /* rule: ARG $@5 lol _SEMIC_t */
1513 #line 204 "src/engine/jamgram.y"
1514 { yyval.parse = prule( yyvsp[-3].string, yyvsp[-1].parse ); yymode( SCAN_NORMAL ); }
1515 #line 1516 "src/engine/jamgram.cpp"
1516 break;
1517
1518 case 26: /* $@6: %empty */
1519 #line 205 "src/engine/jamgram.y"
1520 { yymode( SCAN_PUNCT ); }
1521 #line 1522 "src/engine/jamgram.cpp"
1522 break;
1523
1524 case 27: /* rule: arg assign $@6 list _SEMIC_t */
1525 #line 206 "src/engine/jamgram.y"
1526 { yyval.parse = pset( yyvsp[-4].parse, yyvsp[-1].parse, yyvsp[-3].number ); yymode( SCAN_NORMAL ); }
1527 #line 1528 "src/engine/jamgram.cpp"
1528 break;
1529
1530 case 28: /* $@7: %empty */
1531 #line 207 "src/engine/jamgram.y"
1532 { yymode( SCAN_ASSIGN ); }
1533 #line 1534 "src/engine/jamgram.cpp"
1534 break;
1535
1536 case 29: /* $@8: %empty */
1537 #line 207 "src/engine/jamgram.y"
1538 { yymode( SCAN_PUNCT ); }
1539 #line 1540 "src/engine/jamgram.cpp"
1540 break;
1541
1542 case 30: /* rule: arg ON_t $@7 list assign $@8 list _SEMIC_t */
1543 #line 208 "src/engine/jamgram.y"
1544 { yyval.parse = pset1( yyvsp[-7].parse, yyvsp[-4].parse, yyvsp[-1].parse, yyvsp[-3].number ); yymode( SCAN_NORMAL ); }
1545 #line 1546 "src/engine/jamgram.cpp"
1546 break;
1547
1548 case 31: /* $@9: %empty */
1549 #line 209 "src/engine/jamgram.y"
1550 { yymode( SCAN_PUNCT ); }
1551 #line 1552 "src/engine/jamgram.cpp"
1552 break;
1553
1554 case 32: /* rule: RETURN_t $@9 list _SEMIC_t */
1555 #line 210 "src/engine/jamgram.y"
1556 { yyval.parse = preturn( yyvsp[-1].parse ); yymode( SCAN_NORMAL ); }
1557 #line 1558 "src/engine/jamgram.cpp"
1558 break;
1559
1560 case 33: /* rule: BREAK_t _SEMIC_t */
1561 #line 212 "src/engine/jamgram.y"
1562 { yyval.parse = pbreak(); }
1563 #line 1564 "src/engine/jamgram.cpp"
1564 break;
1565
1566 case 34: /* rule: CONTINUE_t _SEMIC_t */
1567 #line 214 "src/engine/jamgram.y"
1568 { yyval.parse = pcontinue(); }
1569 #line 1570 "src/engine/jamgram.cpp"
1570 break;
1571
1572 case 35: /* $@10: %empty */
1573 #line 215 "src/engine/jamgram.y"
1574 { yymode( SCAN_PUNCT ); }
1575 #line 1576 "src/engine/jamgram.cpp"
1576 break;
1577
1578 case 36: /* $@11: %empty */
1579 #line 215 "src/engine/jamgram.y"
1580 { yymode( SCAN_NORMAL ); }
1581 #line 1582 "src/engine/jamgram.cpp"
1582 break;
1583
1584 case 37: /* rule: FOR_t local_opt ARG IN_t $@10 list _LBRACE_t $@11 block _RBRACE_t */
1585 #line 216 "src/engine/jamgram.y"
1586 { yyval.parse = pfor( yyvsp[-7].string, yyvsp[-4].parse, yyvsp[-1].parse, yyvsp[-8].number ); }
1587 #line 1588 "src/engine/jamgram.cpp"
1588 break;
1589
1590 case 38: /* $@12: %empty */
1591 #line 217 "src/engine/jamgram.y"
1592 { yymode( SCAN_PUNCT ); }
1593 #line 1594 "src/engine/jamgram.cpp"
1594 break;
1595
1596 case 39: /* $@13: %empty */
1597 #line 217 "src/engine/jamgram.y"
1598 { yymode( SCAN_NORMAL ); }
1599 #line 1600 "src/engine/jamgram.cpp"
1600 break;
1601
1602 case 40: /* rule: SWITCH_t $@12 list _LBRACE_t $@13 cases _RBRACE_t */
1603 #line 218 "src/engine/jamgram.y"
1604 { yyval.parse = pswitch( yyvsp[-4].parse, yyvsp[-1].parse ); }
1605 #line 1606 "src/engine/jamgram.cpp"
1606 break;
1607
1608 case 41: /* $@14: %empty */
1609 #line 219 "src/engine/jamgram.y"
1610 { yymode( SCAN_CONDB ); }
1611 #line 1612 "src/engine/jamgram.cpp"
1612 break;
1613
1614 case 42: /* $@15: %empty */
1615 #line 219 "src/engine/jamgram.y"
1616 { yymode( SCAN_NORMAL ); }
1617 #line 1618 "src/engine/jamgram.cpp"
1618 break;
1619
1620 case 43: /* rule: IF_t $@14 expr _LBRACE_t $@15 block _RBRACE_t else_opt */
1621 #line 220 "src/engine/jamgram.y"
1622 { yyval.parse = pif( yyvsp[-5].parse, yyvsp[-2].parse, yyvsp[0].parse ); }
1623 #line 1624 "src/engine/jamgram.cpp"
1624 break;
1625
1626 case 44: /* $@16: %empty */
1627 #line 221 "src/engine/jamgram.y"
1628 { yymode( SCAN_PUNCT ); }
1629 #line 1630 "src/engine/jamgram.cpp"
1630 break;
1631
1632 case 45: /* $@17: %empty */
1633 #line 221 "src/engine/jamgram.y"
1634 { yymode( SCAN_NORMAL ); }
1635 #line 1636 "src/engine/jamgram.cpp"
1636 break;
1637
1638 case 46: /* rule: MODULE_t $@16 list _LBRACE_t $@17 block _RBRACE_t */
1639 #line 222 "src/engine/jamgram.y"
1640 { yyval.parse = pmodule( yyvsp[-4].parse, yyvsp[-1].parse ); }
1641 #line 1642 "src/engine/jamgram.cpp"
1642 break;
1643
1644 case 47: /* $@18: %empty */
1645 #line 223 "src/engine/jamgram.y"
1646 { yymode( SCAN_PUNCT ); }
1647 #line 1648 "src/engine/jamgram.cpp"
1648 break;
1649
1650 case 48: /* $@19: %empty */
1651 #line 223 "src/engine/jamgram.y"
1652 { yymode( SCAN_NORMAL ); }
1653 #line 1654 "src/engine/jamgram.cpp"
1654 break;
1655
1656 case 49: /* rule: CLASS_t $@18 lol _LBRACE_t $@19 block _RBRACE_t */
1657 #line 224 "src/engine/jamgram.y"
1658 { yyval.parse = pclass( yyvsp[-4].parse, yyvsp[-1].parse ); }
1659 #line 1660 "src/engine/jamgram.cpp"
1660 break;
1661
1662 case 50: /* $@20: %empty */
1663 #line 225 "src/engine/jamgram.y"
1664 { yymode( SCAN_CONDB ); }
1665 #line 1666 "src/engine/jamgram.cpp"
1666 break;
1667
1668 case 51: /* $@21: %empty */
1669 #line 225 "src/engine/jamgram.y"
1670 { yymode( SCAN_NORMAL ); }
1671 #line 1672 "src/engine/jamgram.cpp"
1672 break;
1673
1674 case 52: /* rule: WHILE_t $@20 expr $@21 _LBRACE_t block _RBRACE_t */
1675 #line 226 "src/engine/jamgram.y"
1676 { yyval.parse = pwhile( yyvsp[-4].parse, yyvsp[-1].parse ); }
1677 #line 1678 "src/engine/jamgram.cpp"
1678 break;
1679
1680 case 53: /* $@22: %empty */
1681 #line 227 "src/engine/jamgram.y"
1682 { yymode( SCAN_PUNCT ); }
1683 #line 1684 "src/engine/jamgram.cpp"
1684 break;
1685
1686 case 54: /* $@23: %empty */
1687 #line 227 "src/engine/jamgram.y"
1688 { yymode( SCAN_PARAMS ); }
1689 #line 1690 "src/engine/jamgram.cpp"
1690 break;
1691
1692 case 55: /* $@24: %empty */
1693 #line 227 "src/engine/jamgram.y"
1694 { yymode( SCAN_NORMAL ); }
1695 #line 1696 "src/engine/jamgram.cpp"
1696 break;
1697
1698 case 56: /* rule: local_opt RULE_t $@22 ARG $@23 arglist_opt $@24 rule */
1699 #line 228 "src/engine/jamgram.y"
1700 { yyval.parse = psetc( yyvsp[-4].string, yyvsp[0].parse, yyvsp[-2].parse, yyvsp[-7].number ); }
1701 #line 1702 "src/engine/jamgram.cpp"
1702 break;
1703
1704 case 57: /* rule: ON_t arg rule */
1705 #line 230 "src/engine/jamgram.y"
1706 { yyval.parse = pon( yyvsp[-1].parse, yyvsp[0].parse ); }
1707 #line 1708 "src/engine/jamgram.cpp"
1708 break;
1709
1710 case 58: /* $@25: %empty */
1711 #line 232 "src/engine/jamgram.y"
1712 { yymode( SCAN_STRING ); }
1713 #line 1714 "src/engine/jamgram.cpp"
1714 break;
1715
1716 case 59: /* $@26: %empty */
1717 #line 234 "src/engine/jamgram.y"
1718 { yymode( SCAN_NORMAL ); }
1719 #line 1720 "src/engine/jamgram.cpp"
1720 break;
1721
1722 case 60: /* rule: ACTIONS_t eflags ARG bindlist _LBRACE_t $@25 STRING $@26 _RBRACE_t */
1723 #line 236 "src/engine/jamgram.y"
1724 { yyval.parse = psete( yyvsp[-6].string,yyvsp[-5].parse,yyvsp[-2].string,yyvsp[-7].number ); }
1725 #line 1726 "src/engine/jamgram.cpp"
1726 break;
1727
1728 case 61: /* assign: _EQUALS_t */
1729 #line 244 "src/engine/jamgram.y"
1730 { yyval.number = ASSIGN_SET; }
1731 #line 1732 "src/engine/jamgram.cpp"
1732 break;
1733
1734 case 62: /* assign: _PLUS_EQUALS_t */
1735 #line 246 "src/engine/jamgram.y"
1736 { yyval.number = ASSIGN_APPEND; }
1737 #line 1738 "src/engine/jamgram.cpp"
1738 break;
1739
1740 case 63: /* assign: _QUESTION_EQUALS_t */
1741 #line 248 "src/engine/jamgram.y"
1742 { yyval.number = ASSIGN_DEFAULT; }
1743 #line 1744 "src/engine/jamgram.cpp"
1744 break;
1745
1746 case 64: /* assign: DEFAULT_t _EQUALS_t */
1747 #line 250 "src/engine/jamgram.y"
1748 { yyval.number = ASSIGN_DEFAULT; }
1749 #line 1750 "src/engine/jamgram.cpp"
1750 break;
1751
1752 case 65: /* expr: arg */
1753 #line 257 "src/engine/jamgram.y"
1754 { yyval.parse = peval( EXPR_EXISTS, yyvsp[0].parse, pnull() ); yymode( SCAN_COND ); }
1755 #line 1756 "src/engine/jamgram.cpp"
1756 break;
1757
1758 case 66: /* $@27: %empty */
1759 #line 258 "src/engine/jamgram.y"
1760 { yymode( SCAN_CONDB ); }
1761 #line 1762 "src/engine/jamgram.cpp"
1762 break;
1763
1764 case 67: /* expr: expr _EQUALS_t $@27 expr */
1765 #line 259 "src/engine/jamgram.y"
1766 { yyval.parse = peval( EXPR_EQUALS, yyvsp[-3].parse, yyvsp[0].parse ); }
1767 #line 1768 "src/engine/jamgram.cpp"
1768 break;
1769
1770 case 68: /* $@28: %empty */
1771 #line 260 "src/engine/jamgram.y"
1772 { yymode( SCAN_CONDB ); }
1773 #line 1774 "src/engine/jamgram.cpp"
1774 break;
1775
1776 case 69: /* expr: expr _BANG_EQUALS_t $@28 expr */
1777 #line 261 "src/engine/jamgram.y"
1778 { yyval.parse = peval( EXPR_NOTEQ, yyvsp[-3].parse, yyvsp[0].parse ); }
1779 #line 1780 "src/engine/jamgram.cpp"
1780 break;
1781
1782 case 70: /* $@29: %empty */
1783 #line 262 "src/engine/jamgram.y"
1784 { yymode( SCAN_CONDB ); }
1785 #line 1786 "src/engine/jamgram.cpp"
1786 break;
1787
1788 case 71: /* expr: expr _LANGLE_t $@29 expr */
1789 #line 263 "src/engine/jamgram.y"
1790 { yyval.parse = peval( EXPR_LESS, yyvsp[-3].parse, yyvsp[0].parse ); }
1791 #line 1792 "src/engine/jamgram.cpp"
1792 break;
1793
1794 case 72: /* $@30: %empty */
1795 #line 264 "src/engine/jamgram.y"
1796 { yymode( SCAN_CONDB ); }
1797 #line 1798 "src/engine/jamgram.cpp"
1798 break;
1799
1800 case 73: /* expr: expr _LANGLE_EQUALS_t $@30 expr */
1801 #line 265 "src/engine/jamgram.y"
1802 { yyval.parse = peval( EXPR_LESSEQ, yyvsp[-3].parse, yyvsp[0].parse ); }
1803 #line 1804 "src/engine/jamgram.cpp"
1804 break;
1805
1806 case 74: /* $@31: %empty */
1807 #line 266 "src/engine/jamgram.y"
1808 { yymode( SCAN_CONDB ); }
1809 #line 1810 "src/engine/jamgram.cpp"
1810 break;
1811
1812 case 75: /* expr: expr _RANGLE_t $@31 expr */
1813 #line 267 "src/engine/jamgram.y"
1814 { yyval.parse = peval( EXPR_MORE, yyvsp[-3].parse, yyvsp[0].parse ); }
1815 #line 1816 "src/engine/jamgram.cpp"
1816 break;
1817
1818 case 76: /* $@32: %empty */
1819 #line 268 "src/engine/jamgram.y"
1820 { yymode( SCAN_CONDB ); }
1821 #line 1822 "src/engine/jamgram.cpp"
1822 break;
1823
1824 case 77: /* expr: expr _RANGLE_EQUALS_t $@32 expr */
1825 #line 269 "src/engine/jamgram.y"
1826 { yyval.parse = peval( EXPR_MOREEQ, yyvsp[-3].parse, yyvsp[0].parse ); }
1827 #line 1828 "src/engine/jamgram.cpp"
1828 break;
1829
1830 case 78: /* $@33: %empty */
1831 #line 270 "src/engine/jamgram.y"
1832 { yymode( SCAN_CONDB ); }
1833 #line 1834 "src/engine/jamgram.cpp"
1834 break;
1835
1836 case 79: /* expr: expr _AMPER_t $@33 expr */
1837 #line 271 "src/engine/jamgram.y"
1838 { yyval.parse = peval( EXPR_AND, yyvsp[-3].parse, yyvsp[0].parse ); }
1839 #line 1840 "src/engine/jamgram.cpp"
1840 break;
1841
1842 case 80: /* $@34: %empty */
1843 #line 272 "src/engine/jamgram.y"
1844 { yymode( SCAN_CONDB ); }
1845 #line 1846 "src/engine/jamgram.cpp"
1846 break;
1847
1848 case 81: /* expr: expr _AMPERAMPER_t $@34 expr */
1849 #line 273 "src/engine/jamgram.y"
1850 { yyval.parse = peval( EXPR_AND, yyvsp[-3].parse, yyvsp[0].parse ); }
1851 #line 1852 "src/engine/jamgram.cpp"
1852 break;
1853
1854 case 82: /* $@35: %empty */
1855 #line 274 "src/engine/jamgram.y"
1856 { yymode( SCAN_CONDB ); }
1857 #line 1858 "src/engine/jamgram.cpp"
1858 break;
1859
1860 case 83: /* expr: expr _BAR_t $@35 expr */
1861 #line 275 "src/engine/jamgram.y"
1862 { yyval.parse = peval( EXPR_OR, yyvsp[-3].parse, yyvsp[0].parse ); }
1863 #line 1864 "src/engine/jamgram.cpp"
1864 break;
1865
1866 case 84: /* $@36: %empty */
1867 #line 276 "src/engine/jamgram.y"
1868 { yymode( SCAN_CONDB ); }
1869 #line 1870 "src/engine/jamgram.cpp"
1870 break;
1871
1872 case 85: /* expr: expr _BARBAR_t $@36 expr */
1873 #line 277 "src/engine/jamgram.y"
1874 { yyval.parse = peval( EXPR_OR, yyvsp[-3].parse, yyvsp[0].parse ); }
1875 #line 1876 "src/engine/jamgram.cpp"
1876 break;
1877
1878 case 86: /* $@37: %empty */
1879 #line 278 "src/engine/jamgram.y"
1880 { yymode( SCAN_PUNCT ); }
1881 #line 1882 "src/engine/jamgram.cpp"
1882 break;
1883
1884 case 87: /* expr: arg IN_t $@37 list */
1885 #line 279 "src/engine/jamgram.y"
1886 { yyval.parse = peval( EXPR_IN, yyvsp[-3].parse, yyvsp[0].parse ); yymode( SCAN_COND ); }
1887 #line 1888 "src/engine/jamgram.cpp"
1888 break;
1889
1890 case 88: /* $@38: %empty */
1891 #line 280 "src/engine/jamgram.y"
1892 { yymode( SCAN_CONDB ); }
1893 #line 1894 "src/engine/jamgram.cpp"
1894 break;
1895
1896 case 89: /* expr: _BANG_t $@38 expr */
1897 #line 281 "src/engine/jamgram.y"
1898 { yyval.parse = peval( EXPR_NOT, yyvsp[0].parse, pnull() ); }
1899 #line 1900 "src/engine/jamgram.cpp"
1900 break;
1901
1902 case 90: /* $@39: %empty */
1903 #line 282 "src/engine/jamgram.y"
1904 { yymode( SCAN_CONDB ); }
1905 #line 1906 "src/engine/jamgram.cpp"
1906 break;
1907
1908 case 91: /* expr: _LPAREN_t $@39 expr _RPAREN_t */
1909 #line 283 "src/engine/jamgram.y"
1910 { yyval.parse = yyvsp[-1].parse; }
1911 #line 1912 "src/engine/jamgram.cpp"
1912 break;
1913
1914 case 92: /* cases: %empty */
1915 #line 294 "src/engine/jamgram.y"
1916 { yyval.parse = P0; }
1917 #line 1918 "src/engine/jamgram.cpp"
1918 break;
1919
1920 case 93: /* cases: case cases */
1921 #line 296 "src/engine/jamgram.y"
1922 { yyval.parse = pnode( yyvsp[-1].parse, yyvsp[0].parse ); }
1923 #line 1924 "src/engine/jamgram.cpp"
1924 break;
1925
1926 case 94: /* $@40: %empty */
1927 #line 299 "src/engine/jamgram.y"
1928 { yymode( SCAN_CASE ); }
1929 #line 1930 "src/engine/jamgram.cpp"
1930 break;
1931
1932 case 95: /* $@41: %empty */
1933 #line 299 "src/engine/jamgram.y"
1934 { yymode( SCAN_NORMAL ); }
1935 #line 1936 "src/engine/jamgram.cpp"
1936 break;
1937
1938 case 96: /* case: CASE_t $@40 ARG _COLON_t $@41 block */
1939 #line 300 "src/engine/jamgram.y"
1940 { yyval.parse = psnode( yyvsp[-3].string, yyvsp[0].parse ); }
1941 #line 1942 "src/engine/jamgram.cpp"
1942 break;
1943
1944 case 97: /* lol: list */
1945 #line 309 "src/engine/jamgram.y"
1946 { yyval.parse = pnode( P0, yyvsp[0].parse ); }
1947 #line 1948 "src/engine/jamgram.cpp"
1948 break;
1949
1950 case 98: /* lol: list _COLON_t lol */
1951 #line 311 "src/engine/jamgram.y"
1952 { yyval.parse = pnode( yyvsp[0].parse, yyvsp[-2].parse ); }
1953 #line 1954 "src/engine/jamgram.cpp"
1954 break;
1955
1956 case 99: /* list: listp */
1957 #line 321 "src/engine/jamgram.y"
1958 { yyval.parse = yyvsp[0].parse; }
1959 #line 1960 "src/engine/jamgram.cpp"
1960 break;
1961
1962 case 100: /* listp: %empty */
1963 #line 325 "src/engine/jamgram.y"
1964 { yyval.parse = pnull(); }
1965 #line 1966 "src/engine/jamgram.cpp"
1966 break;
1967
1968 case 101: /* listp: listp arg */
1969 #line 327 "src/engine/jamgram.y"
1970 { yyval.parse = pappend( yyvsp[-1].parse, yyvsp[0].parse ); }
1971 #line 1972 "src/engine/jamgram.cpp"
1972 break;
1973
1974 case 102: /* arg: ARG */
1975 #line 331 "src/engine/jamgram.y"
1976 { yyval.parse = plist( yyvsp[0].string ); }
1977 #line 1978 "src/engine/jamgram.cpp"
1978 break;
1979
1980 case 103: /* @42: %empty */
1981 #line 332 "src/engine/jamgram.y"
1982 { yyval.number = yymode( SCAN_CALL ); }
1983 #line 1984 "src/engine/jamgram.cpp"
1984 break;
1985
1986 case 104: /* arg: _LBRACKET_t @42 func _RBRACKET_t */
1987 #line 333 "src/engine/jamgram.y"
1988 { yyval.parse = yyvsp[-1].parse; yymode( yyvsp[-2].number ); }
1989 #line 1990 "src/engine/jamgram.cpp"
1990 break;
1991
1992 case 105: /* $@43: %empty */
1993 #line 341 "src/engine/jamgram.y"
1994 { yymode( SCAN_PUNCT ); }
1995 #line 1996 "src/engine/jamgram.cpp"
1996 break;
1997
1998 case 106: /* func: ARG $@43 lol */
1999 #line 342 "src/engine/jamgram.y"
2000 { yyval.parse = prule( yyvsp[-2].string, yyvsp[0].parse ); }
2001 #line 2002 "src/engine/jamgram.cpp"
2002 break;
2003
2004 case 107: /* $@44: %empty */
2005 #line 343 "src/engine/jamgram.y"
2006 { yymode( SCAN_PUNCT ); }
2007 #line 2008 "src/engine/jamgram.cpp"
2008 break;
2009
2010 case 108: /* func: ON_t arg ARG $@44 lol */
2011 #line 344 "src/engine/jamgram.y"
2012 { yyval.parse = pon( yyvsp[-3].parse, prule( yyvsp[-2].string, yyvsp[0].parse ) ); }
2013 #line 2014 "src/engine/jamgram.cpp"
2014 break;
2015
2016 case 109: /* $@45: %empty */
2017 #line 345 "src/engine/jamgram.y"
2018 { yymode( SCAN_PUNCT ); }
2019 #line 2020 "src/engine/jamgram.cpp"
2020 break;
2021
2022 case 110: /* func: ON_t arg RETURN_t $@45 list */
2023 #line 346 "src/engine/jamgram.y"
2024 { yyval.parse = pon( yyvsp[-3].parse, yyvsp[0].parse ); }
2025 #line 2026 "src/engine/jamgram.cpp"
2026 break;
2027
2028 case 111: /* eflags: %empty */
2029 #line 356 "src/engine/jamgram.y"
2030 { yyval.number = 0; }
2031 #line 2032 "src/engine/jamgram.cpp"
2032 break;
2033
2034 case 112: /* eflags: eflags eflag */
2035 #line 358 "src/engine/jamgram.y"
2036 { yyval.number = yyvsp[-1].number | yyvsp[0].number; }
2037 #line 2038 "src/engine/jamgram.cpp"
2038 break;
2039
2040 case 113: /* eflag: UPDATED_t */
2041 #line 362 "src/engine/jamgram.y"
2042 { yyval.number = EXEC_UPDATED; }
2043 #line 2044 "src/engine/jamgram.cpp"
2044 break;
2045
2046 case 114: /* eflag: TOGETHER_t */
2047 #line 364 "src/engine/jamgram.y"
2048 { yyval.number = EXEC_TOGETHER; }
2049 #line 2050 "src/engine/jamgram.cpp"
2050 break;
2051
2052 case 115: /* eflag: IGNORE_t */
2053 #line 366 "src/engine/jamgram.y"
2054 { yyval.number = EXEC_IGNORE; }
2055 #line 2056 "src/engine/jamgram.cpp"
2056 break;
2057
2058 case 116: /* eflag: QUIETLY_t */
2059 #line 368 "src/engine/jamgram.y"
2060 { yyval.number = EXEC_QUIETLY; }
2061 #line 2062 "src/engine/jamgram.cpp"
2062 break;
2063
2064 case 117: /* eflag: PIECEMEAL_t */
2065 #line 370 "src/engine/jamgram.y"
2066 { yyval.number = EXEC_PIECEMEAL; }
2067 #line 2068 "src/engine/jamgram.cpp"
2068 break;
2069
2070 case 118: /* eflag: EXISTING_t */
2071 #line 372 "src/engine/jamgram.y"
2072 { yyval.number = EXEC_EXISTING; }
2073 #line 2074 "src/engine/jamgram.cpp"
2074 break;
2075
2076 case 119: /* bindlist: %empty */
2077 #line 381 "src/engine/jamgram.y"
2078 { yyval.parse = pnull(); }
2079 #line 2080 "src/engine/jamgram.cpp"
2080 break;
2081
2082 case 120: /* $@46: %empty */
2083 #line 382 "src/engine/jamgram.y"
2084 { yymode( SCAN_PUNCT ); }
2085 #line 2086 "src/engine/jamgram.cpp"
2086 break;
2087
2088 case 121: /* bindlist: BIND_t $@46 list */
2089 #line 383 "src/engine/jamgram.y"
2090 { yyval.parse = yyvsp[0].parse; }
2091 #line 2092 "src/engine/jamgram.cpp"
2092 break;
2093
2094
2095 #line 2096 "src/engine/jamgram.cpp"
2096
2097 default: break;
2098 }
2099 /* User semantic actions sometimes alter yychar, and that requires
2100 that yytoken be updated with the new translation. We take the
2101 approach of translating immediately before every use of yytoken.
2102 One alternative is translating here after every semantic action,
2103 but that translation would be missed if the semantic action invokes
2104 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
2105 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
2106 incorrect destructor might then be invoked immediately. In the
2107 case of YYERROR or YYBACKUP, subsequent parser actions might lead
2108 to an incorrect destructor call or verbose syntax error message
2109 before the lookahead is translated. */
2110 YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc);
2111
2112 YYPOPSTACK (yylen);
2113 yylen = 0;
2114
2115 *++yyvsp = yyval;
2116
2117 /* Now 'shift' the result of the reduction. Determine what state
2118 that goes to, based on the state we popped back to and the rule
2119 number reduced by. */
2120 {
2121 const int yylhs = yyr1[yyn] - YYNTOKENS;
2122 const int yyi = yypgoto[yylhs] + *yyssp;
2123 yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
2124 ? yytable[yyi]
2125 : yydefgoto[yylhs]);
2126 }
2127
2128 goto yynewstate;
2129
2130
2131 /*--------------------------------------.
2132 | yyerrlab -- here on detecting error. |
2133 `--------------------------------------*/
2134 yyerrlab:
2135 /* Make sure we have latest lookahead translation. See comments at
2136 user semantic actions for why this is necessary. */
2137 yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar);
2138 /* If not already recovering from an error, report this error. */
2139 if (!yyerrstatus)
2140 {
2141 ++yynerrs;
2142 yyerror (YY_("syntax error"));
2143 }
2144
2145 if (yyerrstatus == 3)
2146 {
2147 /* If just tried and failed to reuse lookahead token after an
2148 error, discard it. */
2149
2150 if (yychar <= YYEOF)
2151 {
2152 /* Return failure if at end of input. */
2153 if (yychar == YYEOF)
2154 YYABORT;
2155 }
2156 else
2157 {
2158 yydestruct ("Error: discarding",
2159 yytoken, &yylval);
2160 yychar = YYEMPTY;
2161 }
2162 }
2163
2164 /* Else will try to reuse lookahead token after shifting the error
2165 token. */
2166 goto yyerrlab1;
2167
2168
2169 /*---------------------------------------------------.
2170 | yyerrorlab -- error raised explicitly by YYERROR. |
2171 `---------------------------------------------------*/
2172 yyerrorlab:
2173 /* Pacify compilers when the user code never invokes YYERROR and the
2174 label yyerrorlab therefore never appears in user code. */
2175 if (0)
2176 YYERROR;
2177 ++yynerrs;
2178
2179 /* Do not reclaim the symbols of the rule whose action triggered
2180 this YYERROR. */
2181 YYPOPSTACK (yylen);
2182 yylen = 0;
2183 YY_STACK_PRINT (yyss, yyssp);
2184 yystate = *yyssp;
2185 goto yyerrlab1;
2186
2187
2188 /*-------------------------------------------------------------.
2189 | yyerrlab1 -- common code for both syntax error and YYERROR. |
2190 `-------------------------------------------------------------*/
2191 yyerrlab1:
2192 yyerrstatus = 3; /* Each real token shifted decrements this. */
2193
2194 /* Pop stack until we find a state that shifts the error token. */
2195 for (;;)
2196 {
2197 yyn = yypact[yystate];
2198 if (!yypact_value_is_default (yyn))
2199 {
2200 yyn += YYSYMBOL_YYerror;
2201 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
2202 {
2203 yyn = yytable[yyn];
2204 if (0 < yyn)
2205 break;
2206 }
2207 }
2208
2209 /* Pop the current state because it cannot handle the error token. */
2210 if (yyssp == yyss)
2211 YYABORT;
2212
2213
2214 yydestruct ("Error: popping",
2215 YY_ACCESSING_SYMBOL (yystate), yyvsp);
2216 YYPOPSTACK (1);
2217 yystate = *yyssp;
2218 YY_STACK_PRINT (yyss, yyssp);
2219 }
2220
2221 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2222 *++yyvsp = yylval;
2223 YY_IGNORE_MAYBE_UNINITIALIZED_END
2224
2225
2226 /* Shift the error token. */
2227 YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp);
2228
2229 yystate = yyn;
2230 goto yynewstate;
2231
2232
2233 /*-------------------------------------.
2234 | yyacceptlab -- YYACCEPT comes here. |
2235 `-------------------------------------*/
2236 yyacceptlab:
2237 yyresult = 0;
2238 goto yyreturnlab;
2239
2240
2241 /*-----------------------------------.
2242 | yyabortlab -- YYABORT comes here. |
2243 `-----------------------------------*/
2244 yyabortlab:
2245 yyresult = 1;
2246 goto yyreturnlab;
2247
2248
2249 /*-----------------------------------------------------------.
2250 | yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. |
2251 `-----------------------------------------------------------*/
2252 yyexhaustedlab:
2253 yyerror (YY_("memory exhausted"));
2254 yyresult = 2;
2255 goto yyreturnlab;
2256
2257
2258 /*----------------------------------------------------------.
2259 | yyreturnlab -- parsing is finished, clean up and return. |
2260 `----------------------------------------------------------*/
2261 yyreturnlab:
2262 if (yychar != YYEMPTY)
2263 {
2264 /* Make sure we have latest lookahead translation. See comments at
2265 user semantic actions for why this is necessary. */
2266 yytoken = YYTRANSLATE (yychar);
2267 yydestruct ("Cleanup: discarding lookahead",
2268 yytoken, &yylval);
2269 }
2270 /* Do not reclaim the symbols of the rule whose action triggered
2271 this YYABORT or YYACCEPT. */
2272 YYPOPSTACK (yylen);
2273 YY_STACK_PRINT (yyss, yyssp);
2274 while (yyssp != yyss)
2275 {
2276 yydestruct ("Cleanup: popping",
2277 YY_ACCESSING_SYMBOL (+*yyssp), yyvsp);
2278 YYPOPSTACK (1);
2279 }
2280 #ifndef yyoverflow
2281 if (yyss != yyssa)
2282 YYSTACK_FREE (yyss);
2283 #endif
2284
2285 return yyresult;
2286 }
2287
Ceph