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