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 1
59
60 /* Push parsers. */
61 #define YYPUSH 0
62
63 /* Pull parsers. */
64 #define YYPULL 1
65
66 /* "%code top" blocks. */
67 #line 5 "parser.y"
68
69 #include <errno.h>
70 #include "lang.h"
71 #include "lexer.h"
72
73 static int yyerror(struct lgfs2_lang_state *state, yyscan_t lexer, const char *errorstr)
74 {
75 fprintf(stderr, "%d:%d: %s\n", state->ls_linenum, state->ls_colnum, errorstr);
76 return 1;
77 }
78
79
80 #line 81 "parser.c"
81
82
83
84
85 # ifndef YY_CAST
86 # ifdef __cplusplus
87 # define YY_CAST(Type, Val) static_cast<Type> (Val)
88 # define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
89 # else
90 # define YY_CAST(Type, Val) ((Type) (Val))
91 # define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
92 # endif
93 # endif
94 # ifndef YY_NULLPTR
95 # if defined __cplusplus
96 # if 201103L <= __cplusplus
97 # define YY_NULLPTR nullptr
98 # else
99 # define YY_NULLPTR 0
100 # endif
101 # else
102 # define YY_NULLPTR ((void*)0)
103 # endif
104 # endif
105
106 /* Use api.header.include to #include this header
107 instead of duplicating it here. */
108 #ifndef YY_YY_PARSER_H_INCLUDED
109 # define YY_YY_PARSER_H_INCLUDED
110 /* Debug traces. */
111 #ifndef YYDEBUG
112 # define YYDEBUG 1
113 #endif
114 #if YYDEBUG
115 extern int yydebug;
116 #endif
117 /* "%code requires" blocks. */
118 #line 1 "parser.y"
119
120 /* Required to break a circular dependency introduced with bison 2.6 */
121 typedef void* yyscan_t;
122
123 #line 124 "parser.c"
124
125 /* Token kinds. */
126 #ifndef YYTOKENTYPE
127 # define YYTOKENTYPE
128 enum yytokentype
129 {
130 YYEMPTY = -2,
131 YYEOF = 0, /* "end of file" */
132 YYerror = 256, /* error */
133 YYUNDEF = 257, /* "invalid token" */
134 TOK_COLON = 258, /* TOK_COLON */
135 TOK_COMMA = 259, /* TOK_COMMA */
136 TOK_ID = 260, /* TOK_ID */
137 TOK_LBRACE = 261, /* TOK_LBRACE */
138 TOK_LBRACKET = 262, /* TOK_LBRACKET */
139 TOK_NUMBER = 263, /* TOK_NUMBER */
140 TOK_OFFSET = 264, /* TOK_OFFSET */
141 TOK_RBRACE = 265, /* TOK_RBRACE */
142 TOK_RBRACKET = 266, /* TOK_RBRACKET */
143 TOK_SEMI = 267, /* TOK_SEMI */
144 TOK_SET = 268, /* TOK_SET */
145 TOK_GET = 269, /* TOK_GET */
146 TOK_STATE = 270, /* TOK_STATE */
147 TOK_STRING = 271, /* TOK_STRING */
148 TOK_PATH = 272 /* TOK_PATH */
149 };
150 typedef enum yytokentype yytoken_kind_t;
151 #endif
152 /* Token kinds. */
153 #define YYEMPTY -2
154 #define YYEOF 0
155 #define YYerror 256
156 #define YYUNDEF 257
157 #define TOK_COLON 258
158 #define TOK_COMMA 259
159 #define TOK_ID 260
160 #define TOK_LBRACE 261
161 #define TOK_LBRACKET 262
162 #define TOK_NUMBER 263
163 #define TOK_OFFSET 264
164 #define TOK_RBRACE 265
165 #define TOK_RBRACKET 266
166 #define TOK_SEMI 267
167 #define TOK_SET 268
168 #define TOK_GET 269
169 #define TOK_STATE 270
170 #define TOK_STRING 271
171 #define TOK_PATH 272
172
173 /* Value type. */
174 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
175 typedef int YYSTYPE;
176 # define YYSTYPE_IS_TRIVIAL 1
177 # define YYSTYPE_IS_DECLARED 1
178 #endif
179
180
181
182
183 int yyparse (struct lgfs2_lang_state *state, yyscan_t lexer);
184
185
186 #endif /* !YY_YY_PARSER_H_INCLUDED */
187 /* Symbol kind. */
188 enum yysymbol_kind_t
189 {
190 YYSYMBOL_YYEMPTY = -2,
191 YYSYMBOL_YYEOF = 0, /* "end of file" */
192 YYSYMBOL_YYerror = 1, /* error */
193 YYSYMBOL_YYUNDEF = 2, /* "invalid token" */
194 YYSYMBOL_TOK_COLON = 3, /* TOK_COLON */
195 YYSYMBOL_TOK_COMMA = 4, /* TOK_COMMA */
196 YYSYMBOL_TOK_ID = 5, /* TOK_ID */
197 YYSYMBOL_TOK_LBRACE = 6, /* TOK_LBRACE */
198 YYSYMBOL_TOK_LBRACKET = 7, /* TOK_LBRACKET */
199 YYSYMBOL_TOK_NUMBER = 8, /* TOK_NUMBER */
200 YYSYMBOL_TOK_OFFSET = 9, /* TOK_OFFSET */
201 YYSYMBOL_TOK_RBRACE = 10, /* TOK_RBRACE */
202 YYSYMBOL_TOK_RBRACKET = 11, /* TOK_RBRACKET */
203 YYSYMBOL_TOK_SEMI = 12, /* TOK_SEMI */
204 YYSYMBOL_TOK_SET = 13, /* TOK_SET */
205 YYSYMBOL_TOK_GET = 14, /* TOK_GET */
206 YYSYMBOL_TOK_STATE = 15, /* TOK_STATE */
207 YYSYMBOL_TOK_STRING = 16, /* TOK_STRING */
208 YYSYMBOL_TOK_PATH = 17, /* TOK_PATH */
209 YYSYMBOL_YYACCEPT = 18, /* $accept */
210 YYSYMBOL_script = 19, /* script */
211 YYSYMBOL_statements = 20, /* statements */
212 YYSYMBOL_statement = 21, /* statement */
213 YYSYMBOL_set_stmt = 22, /* set_stmt */
214 YYSYMBOL_get_stmt = 23, /* get_stmt */
215 YYSYMBOL_blockspec = 24, /* blockspec */
216 YYSYMBOL_offset = 25, /* offset */
217 YYSYMBOL_typespec = 26, /* typespec */
218 YYSYMBOL_block_literal = 27, /* block_literal */
219 YYSYMBOL_subscript = 28, /* subscript */
220 YYSYMBOL_index = 29, /* index */
221 YYSYMBOL_address = 30, /* address */
222 YYSYMBOL_structspec = 31, /* structspec */
223 YYSYMBOL_fieldspecs = 32, /* fieldspecs */
224 YYSYMBOL_fieldspec = 33, /* fieldspec */
225 YYSYMBOL_fieldvalue = 34, /* fieldvalue */
226 YYSYMBOL_number = 35, /* number */
227 YYSYMBOL_string = 36, /* string */
228 YYSYMBOL_identifier = 37, /* identifier */
229 YYSYMBOL_path = 38 /* path */
230 };
231 typedef enum yysymbol_kind_t yysymbol_kind_t;
232
233
234
235
236 #ifdef short
237 # undef short
238 #endif
239
240 /* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
241 <limits.h> and (if available) <stdint.h> are included
242 so that the code can choose integer types of a good width. */
243
244 #ifndef __PTRDIFF_MAX__
245 # include <limits.h> /* INFRINGES ON USER NAME SPACE */
246 # if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
247 # include <stdint.h> /* INFRINGES ON USER NAME SPACE */
248 # define YY_STDINT_H
249 # endif
250 #endif
251
252 /* Narrow types that promote to a signed type and that can represent a
253 signed or unsigned integer of at least N bits. In tables they can
254 save space and decrease cache pressure. Promoting to a signed type
255 helps avoid bugs in integer arithmetic. */
256
257 #ifdef __INT_LEAST8_MAX__
258 typedef __INT_LEAST8_TYPE__ yytype_int8;
259 #elif defined YY_STDINT_H
260 typedef int_least8_t yytype_int8;
261 #else
262 typedef signed char yytype_int8;
263 #endif
264
265 #ifdef __INT_LEAST16_MAX__
266 typedef __INT_LEAST16_TYPE__ yytype_int16;
267 #elif defined YY_STDINT_H
268 typedef int_least16_t yytype_int16;
269 #else
270 typedef short yytype_int16;
271 #endif
272
273 /* Work around bug in HP-UX 11.23, which defines these macros
274 incorrectly for preprocessor constants. This workaround can likely
275 be removed in 2023, as HPE has promised support for HP-UX 11.23
276 (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of
277 <https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>. */
278 #ifdef __hpux
279 # undef UINT_LEAST8_MAX
280 # undef UINT_LEAST16_MAX
281 # define UINT_LEAST8_MAX 255
282 # define UINT_LEAST16_MAX 65535
283 #endif
284
285 #if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
286 typedef __UINT_LEAST8_TYPE__ yytype_uint8;
287 #elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
288 && UINT_LEAST8_MAX <= INT_MAX)
289 typedef uint_least8_t yytype_uint8;
290 #elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
291 typedef unsigned char yytype_uint8;
292 #else
293 typedef short yytype_uint8;
294 #endif
295
296 #if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
297 typedef __UINT_LEAST16_TYPE__ yytype_uint16;
298 #elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
299 && UINT_LEAST16_MAX <= INT_MAX)
300 typedef uint_least16_t yytype_uint16;
301 #elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
302 typedef unsigned short yytype_uint16;
303 #else
304 typedef int yytype_uint16;
305 #endif
306
307 #ifndef YYPTRDIFF_T
308 # if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
309 # define YYPTRDIFF_T __PTRDIFF_TYPE__
310 # define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
311 # elif defined PTRDIFF_MAX
312 # ifndef ptrdiff_t
313 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
314 # endif
315 # define YYPTRDIFF_T ptrdiff_t
316 # define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
317 # else
318 # define YYPTRDIFF_T long
319 # define YYPTRDIFF_MAXIMUM LONG_MAX
320 # endif
321 #endif
322
323 #ifndef YYSIZE_T
324 # ifdef __SIZE_TYPE__
325 # define YYSIZE_T __SIZE_TYPE__
326 # elif defined size_t
327 # define YYSIZE_T size_t
328 # elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
329 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
330 # define YYSIZE_T size_t
331 # else
332 # define YYSIZE_T unsigned
333 # endif
334 #endif
335
336 #define YYSIZE_MAXIMUM \
337 YY_CAST (YYPTRDIFF_T, \
338 (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
339 ? YYPTRDIFF_MAXIMUM \
340 : YY_CAST (YYSIZE_T, -1)))
341
342 #define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
343
344
345 /* Stored state numbers (used for stacks). */
346 typedef yytype_int8 yy_state_t;
347
348 /* State numbers in computations. */
349 typedef int yy_state_fast_t;
350
351 #ifndef YY_
352 # if defined YYENABLE_NLS && YYENABLE_NLS
353 # if ENABLE_NLS
354 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
355 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
356 # endif
357 # endif
358 # ifndef YY_
359 # define YY_(Msgid) Msgid
360 # endif
361 #endif
362
363
364 #ifndef YY_ATTRIBUTE_PURE
365 # if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
366 # define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
367 # else
368 # define YY_ATTRIBUTE_PURE
369 # endif
370 #endif
371
372 #ifndef YY_ATTRIBUTE_UNUSED
373 # if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
374 # define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
375 # else
376 # define YY_ATTRIBUTE_UNUSED
377 # endif
378 #endif
379
380 /* Suppress unused-variable warnings by "using" E. */
381 #if ! defined lint || defined __GNUC__
382 # define YY_USE(E) ((void) (E))
383 #else
384 # define YY_USE(E) /* empty */
385 #endif
386
387 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
388 #if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__
389 # if __GNUC__ * 100 + __GNUC_MINOR__ < 407
390 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
391 _Pragma ("GCC diagnostic push") \
392 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")
393 # else
394 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
395 _Pragma ("GCC diagnostic push") \
396 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
397 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
398 # endif
399 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
400 _Pragma ("GCC diagnostic pop")
401 #else
402 # define YY_INITIAL_VALUE(Value) Value
403 #endif
404 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
405 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
406 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
407 #endif
408 #ifndef YY_INITIAL_VALUE
409 # define YY_INITIAL_VALUE(Value) /* Nothing. */
410 #endif
411
412 #if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
413 # define YY_IGNORE_USELESS_CAST_BEGIN \
414 _Pragma ("GCC diagnostic push") \
415 _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
416 # define YY_IGNORE_USELESS_CAST_END \
417 _Pragma ("GCC diagnostic pop")
418 #endif
419 #ifndef YY_IGNORE_USELESS_CAST_BEGIN
420 # define YY_IGNORE_USELESS_CAST_BEGIN
421 # define YY_IGNORE_USELESS_CAST_END
422 #endif
423
424
425 #define YY_ASSERT(E) ((void) (0 && (E)))
426
427 #if !defined yyoverflow
428
429 /* The parser invokes alloca or malloc; define the necessary symbols. */
430
431 # ifdef YYSTACK_USE_ALLOCA
432 # if YYSTACK_USE_ALLOCA
433 # ifdef __GNUC__
434 # define YYSTACK_ALLOC __builtin_alloca
435 # elif defined __BUILTIN_VA_ARG_INCR
436 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
437 # elif defined _AIX
438 # define YYSTACK_ALLOC __alloca
439 # elif defined _MSC_VER
440 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
441 # define alloca _alloca
442 # else
443 # define YYSTACK_ALLOC alloca
444 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
445 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
446 /* Use EXIT_SUCCESS as a witness for stdlib.h. */
447 # ifndef EXIT_SUCCESS
448 # define EXIT_SUCCESS 0
449 # endif
450 # endif
451 # endif
452 # endif
453 # endif
454
455 # ifdef YYSTACK_ALLOC
456 /* Pacify GCC's 'empty if-body' warning. */
457 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
458 # ifndef YYSTACK_ALLOC_MAXIMUM
459 /* The OS might guarantee only one guard page at the bottom of the stack,
460 and a page size can be as small as 4096 bytes. So we cannot safely
461 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
462 to allow for a few compiler-allocated temporary stack slots. */
463 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
464 # endif
465 # else
466 # define YYSTACK_ALLOC YYMALLOC
467 # define YYSTACK_FREE YYFREE
468 # ifndef YYSTACK_ALLOC_MAXIMUM
469 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
470 # endif
471 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
472 && ! ((defined YYMALLOC || defined malloc) \
473 && (defined YYFREE || defined free)))
474 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
475 # ifndef EXIT_SUCCESS
476 # define EXIT_SUCCESS 0
477 # endif
478 # endif
479 # ifndef YYMALLOC
480 # define YYMALLOC malloc
481 # if ! defined malloc && ! defined EXIT_SUCCESS
482 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
483 # endif
484 # endif
485 # ifndef YYFREE
486 # define YYFREE free
487 # if ! defined free && ! defined EXIT_SUCCESS
488 void free (void *); /* INFRINGES ON USER NAME SPACE */
489 # endif
490 # endif
491 # endif
492 #endif /* !defined yyoverflow */
493
494 #if (! defined yyoverflow \
495 && (! defined __cplusplus \
496 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
497
498 /* A type that is properly aligned for any stack member. */
499 union yyalloc
500 {
501 yy_state_t yyss_alloc;
502 YYSTYPE yyvs_alloc;
503 };
504
505 /* The size of the maximum gap between one aligned stack and the next. */
506 # define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
507
508 /* The size of an array large to enough to hold all stacks, each with
509 N elements. */
510 # define YYSTACK_BYTES(N) \
511 ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
512 + YYSTACK_GAP_MAXIMUM)
513
514 # define YYCOPY_NEEDED 1
515
516 /* Relocate STACK from its old location to the new one. The
517 local variables YYSIZE and YYSTACKSIZE give the old and new number of
518 elements in the stack, and YYPTR gives the new location of the
519 stack. Advance YYPTR to a properly aligned location for the next
520 stack. */
521 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
522 do \
523 { \
524 YYPTRDIFF_T yynewbytes; \
525 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
526 Stack = &yyptr->Stack_alloc; \
527 yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
528 yyptr += yynewbytes / YYSIZEOF (*yyptr); \
529 } \
530 while (0)
531
532 #endif
533
534 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
535 /* Copy COUNT objects from SRC to DST. The source and destination do
536 not overlap. */
537 # ifndef YYCOPY
538 # if defined __GNUC__ && 1 < __GNUC__
539 # define YYCOPY(Dst, Src, Count) \
540 __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
541 # else
542 # define YYCOPY(Dst, Src, Count) \
543 do \
544 { \
545 YYPTRDIFF_T yyi; \
546 for (yyi = 0; yyi < (Count); yyi++) \
547 (Dst)[yyi] = (Src)[yyi]; \
548 } \
549 while (0)
550 # endif
551 # endif
552 #endif /* !YYCOPY_NEEDED */
553
554 /* YYFINAL -- State number of the termination state. */
555 #define YYFINAL 20
556 /* YYLAST -- Last index in YYTABLE. */
557 #define YYLAST 35
558
559 /* YYNTOKENS -- Number of terminals. */
560 #define YYNTOKENS 18
561 /* YYNNTS -- Number of nonterminals. */
562 #define YYNNTS 21
563 /* YYNRULES -- Number of rules. */
564 #define YYNRULES 34
565 /* YYNSTATES -- Number of states. */
566 #define YYNSTATES 47
567
568 /* YYMAXUTOK -- Last valid token kind. */
569 #define YYMAXUTOK 272
570
571
572 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
573 as returned by yylex, with out-of-bounds checking. */
574 #define YYTRANSLATE(YYX) \
575 (0 <= (YYX) && (YYX) <= YYMAXUTOK \
576 ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \
577 : YYSYMBOL_YYUNDEF)
578
579 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
580 as returned by yylex. */
581 static const yytype_int8 yytranslate[] =
582 {
583 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
584 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
585 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
586 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
587 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
588 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
589 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
590 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
591 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
592 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
593 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
594 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
595 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
596 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
597 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
598 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
599 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
600 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
601 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
602 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
603 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
604 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
605 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
606 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
607 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
608 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
609 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
610 15, 16, 17
611 };
612
613 #if YYDEBUG
614 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
615 static const yytype_uint8 yyrline[] =
616 {
617 0, 40, 40, 44, 49, 54, 60, 61, 63, 68,
618 75, 78, 84, 85, 86, 87, 88, 90, 95, 100,
619 102, 108, 109, 111, 116, 117, 119, 123, 125, 131,
620 132, 134, 135, 136, 137
621 };
622 #endif
623
624 /** Accessing symbol of state STATE. */
625 #define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
626
627 #if YYDEBUG || 0
628 /* The user-facing name of the symbol whose (internal) number is
629 YYSYMBOL. No bounds checking. */
630 static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED;
631
632 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
633 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
634 static const char *const yytname[] =
635 {
636 "\"end of file\"", "error", "\"invalid token\"", "TOK_COLON",
637 "TOK_COMMA", "TOK_ID", "TOK_LBRACE", "TOK_LBRACKET", "TOK_NUMBER",
638 "TOK_OFFSET", "TOK_RBRACE", "TOK_RBRACKET", "TOK_SEMI", "TOK_SET",
639 "TOK_GET", "TOK_STATE", "TOK_STRING", "TOK_PATH", "$accept", "script",
640 "statements", "statement", "set_stmt", "get_stmt", "blockspec", "offset",
641 "typespec", "block_literal", "subscript", "index", "address",
642 "structspec", "fieldspecs", "fieldspec", "fieldvalue", "number",
643 "string", "identifier", "path", YY_NULLPTR
644 };
645
646 static const char *
647 yysymbol_name (yysymbol_kind_t yysymbol)
648 {
649 return yytname[yysymbol];
650 }
651 #endif
652
653 #define YYPACT_NINF (-27)
654
655 #define yypact_value_is_default(Yyn) \
656 ((Yyn) == YYPACT_NINF)
657
658 #define YYTABLE_NINF (-1)
659
660 #define yytable_value_is_error(Yyn) \
661 0
662
663 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
664 STATE-NUM. */
665 static const yytype_int8 yypact[] =
666 {
667 12, -2, -2, 7, 5, -27, -27, -27, -27, -27,
668 -27, 15, -27, 16, -27, -27, -27, -27, -27, 3,
669 -27, 12, -1, -27, 22, -27, -27, 0, -27, -27,
670 -27, 9, -27, 19, -27, 18, -27, -27, 25, -27,
671 -6, -27, -27, -27, -27, -27, -27
672 };
673
674 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
675 Performed when YYTABLE does not specify something else to do. Zero
676 means the default is an error. */
677 static const yytype_int8 yydefact[] =
678 {
679 0, 0, 0, 0, 2, 5, 6, 7, 33, 31,
680 34, 0, 12, 15, 16, 13, 23, 19, 14, 10,
681 1, 3, 0, 17, 0, 8, 18, 0, 11, 4,
682 25, 0, 27, 0, 9, 0, 21, 22, 0, 24,
683 0, 20, 26, 32, 28, 29, 30
684 };
685
686 /* YYPGOTO[NTERM-NUM]. */
687 static const yytype_int8 yypgoto[] =
688 {
689 -27, -27, -27, 10, -27, -27, 30, -27, -27, -27,
690 -27, -27, -27, 11, -27, -5, -27, -26, -27, -11,
691 -27
692 };
693
694 /* YYDEFGOTO[NTERM-NUM]. */
695 static const yytype_int8 yydefgoto[] =
696 {
697 0, 3, 4, 5, 6, 7, 11, 12, 24, 13,
698 14, 35, 15, 25, 31, 32, 44, 16, 46, 17,
699 18
700 };
701
702 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
703 positive, shift that token. If negative, reduce the rule whose
704 number is the opposite. If YYTABLE_NINF, syntax error. */
705 static const yytype_int8 yytable[] =
706 {
707 26, 36, 9, 8, 8, 8, 9, 20, 9, 30,
708 43, 33, 23, 38, 45, 10, 37, 21, 28, 39,
709 8, 22, 40, 27, 23, 1, 2, 33, 22, 41,
710 8, 29, 19, 42, 0, 34
711 };
712
713 static const yytype_int8 yycheck[] =
714 {
715 11, 27, 8, 5, 5, 5, 8, 0, 8, 10,
716 16, 22, 9, 4, 40, 17, 27, 12, 15, 10,
717 5, 6, 3, 7, 9, 13, 14, 38, 6, 11,
718 5, 21, 2, 38, -1, 24
719 };
720
721 /* YYSTOS[STATE-NUM] -- The symbol kind of the accessing symbol of
722 state STATE-NUM. */
723 static const yytype_int8 yystos[] =
724 {
725 0, 13, 14, 19, 20, 21, 22, 23, 5, 8,
726 17, 24, 25, 27, 28, 30, 35, 37, 38, 24,
727 0, 12, 6, 9, 26, 31, 37, 7, 15, 21,
728 10, 32, 33, 37, 31, 29, 35, 37, 4, 10,
729 3, 11, 33, 16, 34, 35, 36
730 };
731
732 /* YYR1[RULE-NUM] -- Symbol kind of the left-hand side of rule RULE-NUM. */
733 static const yytype_int8 yyr1[] =
734 {
735 0, 18, 19, 19, 20, 20, 21, 21, 22, 22,
736 23, 23, 24, 24, 24, 24, 24, 25, 26, 27,
737 28, 29, 29, 30, 31, 31, 32, 32, 33, 34,
738 34, 35, 36, 37, 38
739 };
740
741 /* YYR2[RULE-NUM] -- Number of symbols on the right-hand side of rule RULE-NUM. */
742 static const yytype_int8 yyr2[] =
743 {
744 0, 2, 1, 2, 3, 1, 1, 1, 3, 4,
745 2, 3, 1, 1, 1, 1, 1, 2, 1, 1,
746 4, 1, 1, 1, 3, 2, 3, 1, 3, 1,
747 1, 1, 1, 1, 1
748 };
749
750
751 enum { YYENOMEM = -2 };
752
753 #define yyerrok (yyerrstatus = 0)
754 #define yyclearin (yychar = YYEMPTY)
755
756 #define YYACCEPT goto yyacceptlab
757 #define YYABORT goto yyabortlab
758 #define YYERROR goto yyerrorlab
759 #define YYNOMEM goto yyexhaustedlab
760
761
762 #define YYRECOVERING() (!!yyerrstatus)
763
764 #define YYBACKUP(Token, Value) \
765 do \
766 if (yychar == YYEMPTY) \
767 { \
768 yychar = (Token); \
769 yylval = (Value); \
770 YYPOPSTACK (yylen); \
771 yystate = *yyssp; \
772 goto yybackup; \
773 } \
774 else \
775 { \
776 yyerror (state, lexer, YY_("syntax error: cannot back up")); \
777 YYERROR; \
778 } \
779 while (0)
780
781 /* Backward compatibility with an undocumented macro.
782 Use YYerror or YYUNDEF. */
783 #define YYERRCODE YYUNDEF
784
785
786 /* Enable debugging if requested. */
787 #if YYDEBUG
788
789 # ifndef YYFPRINTF
790 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
791 # define YYFPRINTF fprintf
792 # endif
793
794 # define YYDPRINTF(Args) \
795 do { \
796 if (yydebug) \
797 YYFPRINTF Args; \
798 } while (0)
799
800
801
802
803 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \
804 do { \
805 if (yydebug) \
806 { \
807 YYFPRINTF (stderr, "%s ", Title); \
808 yy_symbol_print (stderr, \
809 Kind, Value, state, lexer); \
810 YYFPRINTF (stderr, "\n"); \
811 } \
812 } while (0)
813
814
815 /*-----------------------------------.
816 | Print this symbol's value on YYO. |
817 `-----------------------------------*/
818
819 static void
820 yy_symbol_value_print (FILE *yyo,
821 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, struct lgfs2_lang_state *state, yyscan_t lexer)
822 {
823 FILE *yyoutput = yyo;
824 YY_USE (yyoutput);
825 YY_USE (state);
826 YY_USE (lexer);
827 if (!yyvaluep)
828 return;
829 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
830 YY_USE (yykind);
831 YY_IGNORE_MAYBE_UNINITIALIZED_END
832 }
833
834
835 /*---------------------------.
836 | Print this symbol on YYO. |
837 `---------------------------*/
838
839 static void
840 yy_symbol_print (FILE *yyo,
841 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, struct lgfs2_lang_state *state, yyscan_t lexer)
842 {
843 YYFPRINTF (yyo, "%s %s (",
844 yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));
845
846 yy_symbol_value_print (yyo, yykind, yyvaluep, state, lexer);
847 YYFPRINTF (yyo, ")");
848 }
849
850 /*------------------------------------------------------------------.
851 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
852 | TOP (included). |
853 `------------------------------------------------------------------*/
854
855 static void
856 yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
857 {
858 YYFPRINTF (stderr, "Stack now");
859 for (; yybottom <= yytop; yybottom++)
860 {
861 int yybot = *yybottom;
862 YYFPRINTF (stderr, " %d", yybot);
863 }
864 YYFPRINTF (stderr, "\n");
865 }
866
867 # define YY_STACK_PRINT(Bottom, Top) \
868 do { \
869 if (yydebug) \
870 yy_stack_print ((Bottom), (Top)); \
871 } while (0)
872
873
874 /*------------------------------------------------.
875 | Report that the YYRULE is going to be reduced. |
876 `------------------------------------------------*/
877
878 static void
879 yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp,
880 int yyrule, struct lgfs2_lang_state *state, yyscan_t lexer)
881 {
882 int yylno = yyrline[yyrule];
883 int yynrhs = yyr2[yyrule];
884 int yyi;
885 YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
886 yyrule - 1, yylno);
887 /* The symbols being reduced. */
888 for (yyi = 0; yyi < yynrhs; yyi++)
889 {
890 YYFPRINTF (stderr, " $%d = ", yyi + 1);
891 yy_symbol_print (stderr,
892 YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
893 &yyvsp[(yyi + 1) - (yynrhs)], state, lexer);
894 YYFPRINTF (stderr, "\n");
895 }
896 }
897
898 # define YY_REDUCE_PRINT(Rule) \
899 do { \
900 if (yydebug) \
901 yy_reduce_print (yyssp, yyvsp, Rule, state, lexer); \
902 } while (0)
903
904 /* Nonzero means print parse trace. It is left uninitialized so that
905 multiple parsers can coexist. */
906 int yydebug;
907 #else /* !YYDEBUG */
908 # define YYDPRINTF(Args) ((void) 0)
909 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
910 # define YY_STACK_PRINT(Bottom, Top)
911 # define YY_REDUCE_PRINT(Rule)
912 #endif /* !YYDEBUG */
913
914
915 /* YYINITDEPTH -- initial size of the parser's stacks. */
916 #ifndef YYINITDEPTH
917 # define YYINITDEPTH 200
918 #endif
919
920 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
921 if the built-in stack extension method is used).
922
923 Do not make this value too large; the results are undefined if
924 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
925 evaluated with infinite-precision integer arithmetic. */
926
927 #ifndef YYMAXDEPTH
928 # define YYMAXDEPTH 10000
929 #endif
930
931
932
933
934
935
936 /*-----------------------------------------------.
937 | Release the memory associated to this symbol. |
938 `-----------------------------------------------*/
939
940 static void
941 yydestruct (const char *yymsg,
942 yysymbol_kind_t yykind, YYSTYPE *yyvaluep, struct lgfs2_lang_state *state, yyscan_t lexer)
943 {
944 YY_USE (yyvaluep);
945 YY_USE (state);
946 YY_USE (lexer);
947 if (!yymsg)
948 yymsg = "Deleting";
949 YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
950
951 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
952 YY_USE (yykind);
953 YY_IGNORE_MAYBE_UNINITIALIZED_END
954 }
955
956
957
958
959
960
961 /*----------.
962 | yyparse. |
963 `----------*/
964
965 int
966 yyparse (struct lgfs2_lang_state *state, yyscan_t lexer)
967 {
968 /* Lookahead token kind. */
969 int yychar;
970
971
972 /* The semantic value of the lookahead symbol. */
973 /* Default value used for initialization, for pacifying older GCCs
974 or non-GCC compilers. */
975 YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
|
(1) Event var_decl: |
Declaring variable "yylval" without initializer. |
| Also see events: |
[uninit_use] |
976 YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
977
978 /* Number of syntax errors so far. */
979 int yynerrs = 0;
980
981 yy_state_fast_t yystate = 0;
982 /* Number of tokens to shift before error messages enabled. */
983 int yyerrstatus = 0;
984
985 /* Refer to the stacks through separate pointers, to allow yyoverflow
986 to reallocate them elsewhere. */
987
988 /* Their size. */
989 YYPTRDIFF_T yystacksize = YYINITDEPTH;
990
991 /* The state stack: array, bottom, top. */
992 yy_state_t yyssa[YYINITDEPTH];
993 yy_state_t *yyss = yyssa;
994 yy_state_t *yyssp = yyss;
995
996 /* The semantic value stack: array, bottom, top. */
997 YYSTYPE yyvsa[YYINITDEPTH];
998 YYSTYPE *yyvs = yyvsa;
999 YYSTYPE *yyvsp = yyvs;
1000
1001 int yyn;
1002 /* The return value of yyparse. */
1003 int yyresult;
1004 /* Lookahead symbol kind. */
1005 yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY;
1006 /* The variables used to return semantic value and location from the
1007 action routines. */
1008 YYSTYPE yyval;
1009
1010
1011
1012 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1013
1014 /* The number of symbols on the RHS of the reduced rule.
1015 Keep to zero when no symbol should be popped. */
1016 int yylen = 0;
1017
|
(2) Event cond_true: |
Condition "yydebug", taking true branch. |
1018 YYDPRINTF ((stderr, "Starting parse\n"));
1019
1020 yychar = YYEMPTY; /* Cause a token to be read. */
1021
|
(3) Event goto: |
Jumping to label "yysetstate". |
1022 goto yysetstate;
1023
1024
1025 /*------------------------------------------------------------.
1026 | yynewstate -- push a new state, which is found in yystate. |
1027 `------------------------------------------------------------*/
1028 yynewstate:
1029 /* In all cases, when you get here, the value and location stacks
1030 have just been pushed. So pushing a state here evens the stacks. */
1031 yyssp++;
1032
1033
1034 /*--------------------------------------------------------------------.
1035 | yysetstate -- set current state (the top of the stack) to yystate. |
1036 `--------------------------------------------------------------------*/
|
(4) Event label: |
Reached label "yysetstate". |
1037 yysetstate:
|
(5) Event cond_true: |
Condition "yydebug", taking true branch. |
1038 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
|
(6) Event cond_false: |
Condition "0", taking false branch. |
1039 YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
1040 YY_IGNORE_USELESS_CAST_BEGIN
1041 *yyssp = YY_CAST (yy_state_t, yystate);
1042 YY_IGNORE_USELESS_CAST_END
|
(7) Event cond_true: |
Condition "yydebug", taking true branch. |
1043 YY_STACK_PRINT (yyss, yyssp);
1044
|
(8) Event cond_true: |
Condition "yyss + yystacksize - 1 <= yyssp", taking true branch. |
1045 if (yyss + yystacksize - 1 <= yyssp)
1046 #if !defined yyoverflow && !defined YYSTACK_RELOCATE
1047 YYNOMEM;
1048 #else
1049 {
1050 /* Get the current used size of the three stacks, in elements. */
1051 YYPTRDIFF_T yysize = yyssp - yyss + 1;
1052
1053 # if defined yyoverflow
1054 {
1055 /* Give user a chance to reallocate the stack. Use copies of
1056 these so that the &'s don't force the real ones into
1057 memory. */
1058 yy_state_t *yyss1 = yyss;
1059 YYSTYPE *yyvs1 = yyvs;
1060
1061 /* Each stack pointer address is followed by the size of the
1062 data in use in that stack, in bytes. This used to be a
1063 conditional around just the two extra args, but that might
1064 be undefined if yyoverflow is a macro. */
1065 yyoverflow (YY_("memory exhausted"),
1066 &yyss1, yysize * YYSIZEOF (*yyssp),
1067 &yyvs1, yysize * YYSIZEOF (*yyvsp),
1068 &yystacksize);
1069 yyss = yyss1;
1070 yyvs = yyvs1;
1071 }
1072 # else /* defined YYSTACK_RELOCATE */
1073 /* Extend the stack our own way. */
|
(9) Event cond_false: |
Condition "10000 <= yystacksize", taking false branch. |
1074 if (YYMAXDEPTH <= yystacksize)
|
(10) Event if_end: |
End of if statement. |
1075 YYNOMEM;
1076 yystacksize *= 2;
|
(11) Event cond_false: |
Condition "10000 < yystacksize", taking false branch. |
1077 if (YYMAXDEPTH < yystacksize)
|
(12) Event if_end: |
End of if statement. |
1078 yystacksize = YYMAXDEPTH;
1079
1080 {
1081 yy_state_t *yyss1 = yyss;
1082 union yyalloc *yyptr =
1083 YY_CAST (union yyalloc *,
1084 YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
|
(13) Event cond_false: |
Condition "!yyptr", taking false branch. |
1085 if (! yyptr)
|
(14) Event if_end: |
End of if statement. |
1086 YYNOMEM;
1087 YYSTACK_RELOCATE (yyss_alloc, yyss);
1088 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1089 # undef YYSTACK_RELOCATE
|
(15) Event cond_true: |
Condition "yyss1 != yyssa", taking true branch. |
1090 if (yyss1 != yyssa)
1091 YYSTACK_FREE (yyss1);
1092 }
1093 # endif
1094
1095 yyssp = yyss + yysize - 1;
1096 yyvsp = yyvs + yysize - 1;
1097
1098 YY_IGNORE_USELESS_CAST_BEGIN
|
(16) Event cond_true: |
Condition "yydebug", taking true branch. |
1099 YYDPRINTF ((stderr, "Stack size increased to %ld\n",
1100 YY_CAST (long, yystacksize)));
1101 YY_IGNORE_USELESS_CAST_END
1102
|
(17) Event cond_false: |
Condition "yyss + yystacksize - 1 <= yyssp", taking false branch. |
1103 if (yyss + yystacksize - 1 <= yyssp)
|
(18) Event if_end: |
End of if statement. |
1104 YYABORT;
1105 }
1106 #endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
1107
1108
|
(19) Event cond_false: |
Condition "yystate == 20", taking false branch. |
1109 if (yystate == YYFINAL)
|
(20) Event if_end: |
End of if statement. |
1110 YYACCEPT;
1111
|
(21) Event goto: |
Jumping to label "yybackup". |
1112 goto yybackup;
1113
1114
1115 /*-----------.
1116 | yybackup. |
1117 `-----------*/
|
(22) Event label: |
Reached label "yybackup". |
1118 yybackup:
1119 /* Do appropriate processing given the current state. Read a
1120 lookahead token if we need one and don't already have one. */
1121
1122 /* First try to decide what to do without reference to lookahead token. */
1123 yyn = yypact[yystate];
|
(23) Event cond_true: |
Condition "yyn == -27", taking true branch. |
1124 if (yypact_value_is_default (yyn))
|
(24) Event goto: |
Jumping to label "yydefault". |
1125 goto yydefault;
1126
1127 /* Not known => get a lookahead token if don't already have one. */
1128
1129 /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */
1130 if (yychar == YYEMPTY)
1131 {
1132 YYDPRINTF ((stderr, "Reading a token\n"));
1133 yychar = yylex (&yylval, lexer);
1134 }
1135
1136 if (yychar <= YYEOF)
1137 {
1138 yychar = YYEOF;
1139 yytoken = YYSYMBOL_YYEOF;
1140 YYDPRINTF ((stderr, "Now at end of input.\n"));
1141 }
1142 else if (yychar == YYerror)
1143 {
1144 /* The scanner already issued an error message, process directly
1145 to error recovery. But do not keep the error token as
1146 lookahead, it is too special and may lead us to an endless
1147 loop in error recovery. */
1148 yychar = YYUNDEF;
1149 yytoken = YYSYMBOL_YYerror;
1150 goto yyerrlab1;
1151 }
1152 else
1153 {
1154 yytoken = YYTRANSLATE (yychar);
1155 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1156 }
1157
1158 /* If the proper action on seeing token YYTOKEN is to reduce or to
1159 detect an error, take that action. */
1160 yyn += yytoken;
1161 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1162 goto yydefault;
1163 yyn = yytable[yyn];
1164 if (yyn <= 0)
1165 {
1166 if (yytable_value_is_error (yyn))
1167 goto yyerrlab;
1168 yyn = -yyn;
1169 goto yyreduce;
1170 }
1171
1172 /* Count tokens shifted since error; after three, turn off error
1173 status. */
1174 if (yyerrstatus)
1175 yyerrstatus--;
1176
1177 /* Shift the lookahead token. */
1178 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1179 yystate = yyn;
1180 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1181 *++yyvsp = yylval;
1182 YY_IGNORE_MAYBE_UNINITIALIZED_END
1183
1184 /* Discard the shifted token. */
1185 yychar = YYEMPTY;
1186 goto yynewstate;
1187
1188
1189 /*-----------------------------------------------------------.
1190 | yydefault -- do the default action for the current state. |
1191 `-----------------------------------------------------------*/
|
(25) Event label: |
Reached label "yydefault". |
1192 yydefault:
1193 yyn = yydefact[yystate];
|
(26) Event cond_true: |
Condition "yyn == 0", taking true branch. |
1194 if (yyn == 0)
|
(27) Event goto: |
Jumping to label "yyerrlab". |
1195 goto yyerrlab;
1196 goto yyreduce;
1197
1198
1199 /*-----------------------------.
1200 | yyreduce -- do a reduction. |
1201 `-----------------------------*/
1202 yyreduce:
1203 /* yyn is the number of a rule to reduce with. */
1204 yylen = yyr2[yyn];
1205
1206 /* If YYLEN is nonzero, implement the default value of the action:
1207 '$$ = $1'.
1208
1209 Otherwise, the following line sets YYVAL to garbage.
1210 This behavior is undocumented and Bison
1211 users should not rely upon it. Assigning to YYVAL
1212 unconditionally makes the parser a bit smaller, and it avoids a
1213 GCC warning that YYVAL may be used uninitialized. */
1214 yyval = yyvsp[1-yylen];
1215
1216
1217 YY_REDUCE_PRINT (yyn);
1218 switch (yyn)
1219 {
1220 case 2: /* script: statements */
1221 #line 40 "parser.y"
1222 {
1223 state->ls_ast_root = yyvsp[0];
1224 state->ls_interp_curr = yyvsp[0];
1225 }
1226 #line 1227 "parser.c"
1227 break;
1228
1229 case 3: /* script: statements TOK_SEMI */
1230 #line 44 "parser.y"
1231 {
1232 state->ls_ast_root = yyvsp[-1];
1233 state->ls_interp_curr = yyvsp[-1];
1234 }
1235 #line 1236 "parser.c"
1236 break;
1237
1238 case 4: /* statements: statements TOK_SEMI statement */
1239 #line 49 "parser.y"
1240 {
1241 state->ls_ast_tail->ast_left = yyvsp[0];
1242 state->ls_ast_tail = yyvsp[0];
1243 yyval = yyvsp[-2];
1244 }
1245 #line 1246 "parser.c"
1246 break;
1247
1248 case 5: /* statements: statement */
1249 #line 54 "parser.y"
1250 {
1251 if (state->ls_ast_tail == NULL)
1252 state->ls_ast_tail = yyvsp[0];
1253 yyval = yyvsp[0];
1254 }
1255 #line 1256 "parser.c"
1256 break;
1257
1258 case 6: /* statement: set_stmt */
1259 #line 60 "parser.y"
1260 { yyval = yyvsp[0];}
1261 #line 1262 "parser.c"
1262 break;
1263
1264 case 7: /* statement: get_stmt */
1265 #line 61 "parser.y"
1266 { yyval = yyvsp[0]; }
1267 #line 1268 "parser.c"
1268 break;
1269
1270 case 8: /* set_stmt: TOK_SET blockspec structspec */
1271 #line 63 "parser.y"
1272 {
1273 yyvsp[-2]->ast_right = yyvsp[-1];
1274 yyvsp[-1]->ast_right = yyvsp[0];
1275 yyval = yyvsp[-2];
1276 }
1277 #line 1278 "parser.c"
1278 break;
1279
1280 case 9: /* set_stmt: TOK_SET blockspec typespec structspec */
1281 #line 68 "parser.y"
1282 {
1283 yyvsp[-3]->ast_right = yyvsp[-2];
1284 yyvsp[-2]->ast_right = yyvsp[-1];
1285 yyvsp[-1]->ast_right = yyvsp[0];
1286 yyval = yyvsp[-3];
1287 }
1288 #line 1289 "parser.c"
1289 break;
1290
1291 case 10: /* get_stmt: TOK_GET blockspec */
1292 #line 75 "parser.y"
1293 {
1294 yyvsp[-1]->ast_right = yyvsp[0]; yyval = yyvsp[-1];
1295 }
1296 #line 1297 "parser.c"
1297 break;
1298
1299 case 11: /* get_stmt: TOK_GET blockspec TOK_STATE */
1300 #line 78 "parser.y"
1301 {
1302 yyvsp[-2]->ast_right = yyvsp[-1];
1303 yyvsp[-1]->ast_right = yyvsp[0];
1304 yyval = yyvsp[-2];
1305 }
1306 #line 1307 "parser.c"
1307 break;
1308
1309 case 12: /* blockspec: offset */
1310 #line 84 "parser.y"
1311 { yyval = yyvsp[0]; }
1312 #line 1313 "parser.c"
1313 break;
1314
1315 case 13: /* blockspec: address */
1316 #line 85 "parser.y"
1317 { yyval = yyvsp[0]; }
1318 #line 1319 "parser.c"
1319 break;
1320
1321 case 14: /* blockspec: path */
1322 #line 86 "parser.y"
1323 { yyval = yyvsp[0]; }
1324 #line 1325 "parser.c"
1325 break;
1326
1327 case 15: /* blockspec: block_literal */
1328 #line 87 "parser.y"
1329 { yyval = yyvsp[0]; }
1330 #line 1331 "parser.c"
1331 break;
1332
1333 case 16: /* blockspec: subscript */
1334 #line 88 "parser.y"
1335 { yyval = yyvsp[0]; }
1336 #line 1337 "parser.c"
1337 break;
1338
1339 case 17: /* offset: blockspec TOK_OFFSET */
1340 #line 90 "parser.y"
1341 {
1342 yyvsp[0]->ast_left = yyvsp[-1];
1343 yyval = yyvsp[0];
1344 }
1345 #line 1346 "parser.c"
1346 break;
1347
1348 case 18: /* typespec: identifier */
1349 #line 95 "parser.y"
1350 {
1351 yyvsp[0]->ast_type = AST_EX_TYPESPEC;
1352 yyval = yyvsp[0];
1353 }
1354 #line 1355 "parser.c"
1355 break;
1356
1357 case 19: /* block_literal: identifier */
1358 #line 100 "parser.y"
1359 { yyval = yyvsp[0]; }
1360 #line 1361 "parser.c"
1361 break;
1362
1363 case 20: /* subscript: block_literal TOK_LBRACKET index TOK_RBRACKET */
1364 #line 102 "parser.y"
1365 {
1366 yyvsp[0]->ast_left = yyvsp[-3];
1367 yyvsp[-3]->ast_left = yyvsp[-1];
1368 yyval = yyvsp[0];
1369 }
1370 #line 1371 "parser.c"
1371 break;
1372
1373 case 21: /* index: number */
1374 #line 108 "parser.y"
1375 { yyval = yyvsp[0]; }
1376 #line 1377 "parser.c"
1377 break;
1378
1379 case 22: /* index: identifier */
1380 #line 109 "parser.y"
1381 { yyval = yyvsp[0]; }
1382 #line 1383 "parser.c"
1383 break;
1384
1385 case 23: /* address: number */
1386 #line 111 "parser.y"
1387 {
1388 yyvsp[0]->ast_type = AST_EX_ADDRESS;
1389 yyval = yyvsp[0];
1390 }
1391 #line 1392 "parser.c"
1392 break;
1393
1394 case 24: /* structspec: TOK_LBRACE fieldspecs TOK_RBRACE */
1395 #line 116 "parser.y"
1396 { yyval = yyvsp[-1]; }
1397 #line 1398 "parser.c"
1398 break;
1399
1400 case 25: /* structspec: TOK_LBRACE TOK_RBRACE */
1401 #line 117 "parser.y"
1402 { yyval = NULL; }
1403 #line 1404 "parser.c"
1404 break;
1405
1406 case 26: /* fieldspecs: fieldspecs TOK_COMMA fieldspec */
1407 #line 119 "parser.y"
1408 {
1409 yyvsp[-2]->ast_left = yyvsp[0];
1410 yyval = yyvsp[-2];
1411 }
1412 #line 1413 "parser.c"
1413 break;
1414
1415 case 27: /* fieldspecs: fieldspec */
1416 #line 123 "parser.y"
1417 { yyval = yyvsp[0]; }
1418 #line 1419 "parser.c"
1419 break;
1420
1421 case 28: /* fieldspec: identifier TOK_COLON fieldvalue */
1422 #line 125 "parser.y"
1423 {
1424 yyvsp[-1]->ast_right = yyvsp[-2];
1425 yyvsp[-2]->ast_right = yyvsp[0];
1426 yyval = yyvsp[-1];
1427 }
1428 #line 1429 "parser.c"
1429 break;
1430
1431 case 29: /* fieldvalue: number */
1432 #line 131 "parser.y"
1433 { yyval = yyvsp[0]; }
1434 #line 1435 "parser.c"
1435 break;
1436
1437 case 30: /* fieldvalue: string */
1438 #line 132 "parser.y"
1439 { yyval = yyvsp[0]; }
1440 #line 1441 "parser.c"
1441 break;
1442
1443 case 31: /* number: TOK_NUMBER */
1444 #line 134 "parser.y"
1445 { yyval = yyvsp[0]; }
1446 #line 1447 "parser.c"
1447 break;
1448
1449 case 32: /* string: TOK_STRING */
1450 #line 135 "parser.y"
1451 { yyval = yyvsp[0]; }
1452 #line 1453 "parser.c"
1453 break;
1454
1455 case 33: /* identifier: TOK_ID */
1456 #line 136 "parser.y"
1457 { yyval = yyvsp[0]; }
1458 #line 1459 "parser.c"
1459 break;
1460
1461 case 34: /* path: TOK_PATH */
1462 #line 137 "parser.y"
1463 { yyval = yyvsp[0]; }
1464 #line 1465 "parser.c"
1465 break;
1466
1467
1468 #line 1469 "parser.c"
1469
1470 default: break;
1471 }
1472 /* User semantic actions sometimes alter yychar, and that requires
1473 that yytoken be updated with the new translation. We take the
1474 approach of translating immediately before every use of yytoken.
1475 One alternative is translating here after every semantic action,
1476 but that translation would be missed if the semantic action invokes
1477 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1478 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
1479 incorrect destructor might then be invoked immediately. In the
1480 case of YYERROR or YYBACKUP, subsequent parser actions might lead
1481 to an incorrect destructor call or verbose syntax error message
1482 before the lookahead is translated. */
1483 YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc);
1484
1485 YYPOPSTACK (yylen);
1486 yylen = 0;
1487
1488 *++yyvsp = yyval;
1489
1490 /* Now 'shift' the result of the reduction. Determine what state
1491 that goes to, based on the state we popped back to and the rule
1492 number reduced by. */
1493 {
1494 const int yylhs = yyr1[yyn] - YYNTOKENS;
1495 const int yyi = yypgoto[yylhs] + *yyssp;
1496 yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
1497 ? yytable[yyi]
1498 : yydefgoto[yylhs]);
1499 }
1500
1501 goto yynewstate;
1502
1503
1504 /*--------------------------------------.
1505 | yyerrlab -- here on detecting error. |
1506 `--------------------------------------*/
|
(28) Event label: |
Reached label "yyerrlab". |
1507 yyerrlab:
1508 /* Make sure we have latest lookahead translation. See comments at
1509 user semantic actions for why this is necessary. */
|
(29) Event cond_true: |
Condition "yychar == -2", taking true branch. |
1510 yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar);
1511 /* If not already recovering from an error, report this error. */
|
(30) Event cond_true: |
Condition "!yyerrstatus", taking true branch. |
1512 if (!yyerrstatus)
1513 {
1514 ++yynerrs;
1515 yyerror (state, lexer, YY_("syntax error"));
1516 }
1517
|
(31) Event cond_false: |
Condition "yyerrstatus == 3", taking false branch. |
1518 if (yyerrstatus == 3)
1519 {
1520 /* If just tried and failed to reuse lookahead token after an
1521 error, discard it. */
1522
1523 if (yychar <= YYEOF)
1524 {
1525 /* Return failure if at end of input. */
1526 if (yychar == YYEOF)
1527 YYABORT;
1528 }
1529 else
1530 {
1531 yydestruct ("Error: discarding",
1532 yytoken, &yylval, state, lexer);
1533 yychar = YYEMPTY;
1534 }
|
(32) Event if_end: |
End of if statement. |
1535 }
1536
1537 /* Else will try to reuse lookahead token after shifting the error
1538 token. */
|
(33) Event goto: |
Jumping to label "yyerrlab1". |
1539 goto yyerrlab1;
1540
1541
1542 /*---------------------------------------------------.
1543 | yyerrorlab -- error raised explicitly by YYERROR. |
1544 `---------------------------------------------------*/
1545 yyerrorlab:
1546 /* Pacify compilers when the user code never invokes YYERROR and the
1547 label yyerrorlab therefore never appears in user code. */
1548 if (0)
1549 YYERROR;
1550 ++yynerrs;
1551
1552 /* Do not reclaim the symbols of the rule whose action triggered
1553 this YYERROR. */
1554 YYPOPSTACK (yylen);
1555 yylen = 0;
1556 YY_STACK_PRINT (yyss, yyssp);
1557 yystate = *yyssp;
1558 goto yyerrlab1;
1559
1560
1561 /*-------------------------------------------------------------.
1562 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1563 `-------------------------------------------------------------*/
|
(34) Event label: |
Reached label "yyerrlab1". |
1564 yyerrlab1:
1565 yyerrstatus = 3; /* Each real token shifted decrements this. */
1566
1567 /* Pop stack until we find a state that shifts the error token. */
1568 for (;;)
1569 {
1570 yyn = yypact[yystate];
|
(35) Event cond_true: |
Condition "!(yyn == -27)", taking true branch. |
1571 if (!yypact_value_is_default (yyn))
1572 {
1573 yyn += YYSYMBOL_YYerror;
|
(36) Event cond_true: |
Condition "0 <= yyn", taking true branch. |
|
(37) Event cond_true: |
Condition "yyn <= 35", taking true branch. |
|
(38) Event cond_true: |
Condition "yycheck[yyn] == YYSYMBOL_YYerror", taking true branch. |
1574 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
1575 {
1576 yyn = yytable[yyn];
|
(39) Event cond_true: |
Condition "0 < yyn", taking true branch. |
1577 if (0 < yyn)
|
(40) Event break: |
Breaking from loop. |
1578 break;
1579 }
1580 }
1581
1582 /* Pop the current state because it cannot handle the error token. */
1583 if (yyssp == yyss)
1584 YYABORT;
1585
1586
1587 yydestruct ("Error: popping",
1588 YY_ACCESSING_SYMBOL (yystate), yyvsp, state, lexer);
1589 YYPOPSTACK (1);
1590 yystate = *yyssp;
1591 YY_STACK_PRINT (yyss, yyssp);
|
(41) Event loop_end: |
Reached end of loop. |
1592 }
1593
1594 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
|
(42) Event uninit_use: |
Using uninitialized value "yylval". |
| Also see events: |
[var_decl] |
1595 *++yyvsp = yylval;
1596 YY_IGNORE_MAYBE_UNINITIALIZED_END
1597
1598
1599 /* Shift the error token. */
1600 YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp);
1601
1602 yystate = yyn;
1603 goto yynewstate;
1604
1605
1606 /*-------------------------------------.
1607 | yyacceptlab -- YYACCEPT comes here. |
1608 `-------------------------------------*/
1609 yyacceptlab:
1610 yyresult = 0;
1611 goto yyreturnlab;
1612
1613
1614 /*-----------------------------------.
1615 | yyabortlab -- YYABORT comes here. |
1616 `-----------------------------------*/
1617 yyabortlab:
1618 yyresult = 1;
1619 goto yyreturnlab;
1620
1621
1622 /*-----------------------------------------------------------.
1623 | yyexhaustedlab -- YYNOMEM (memory exhaustion) comes here. |
1624 `-----------------------------------------------------------*/
1625 yyexhaustedlab:
1626 yyerror (state, lexer, YY_("memory exhausted"));
1627 yyresult = 2;
1628 goto yyreturnlab;
1629
1630
1631 /*----------------------------------------------------------.
1632 | yyreturnlab -- parsing is finished, clean up and return. |
1633 `----------------------------------------------------------*/
1634 yyreturnlab:
1635 if (yychar != YYEMPTY)
1636 {
1637 /* Make sure we have latest lookahead translation. See comments at
1638 user semantic actions for why this is necessary. */
1639 yytoken = YYTRANSLATE (yychar);
1640 yydestruct ("Cleanup: discarding lookahead",
1641 yytoken, &yylval, state, lexer);
1642 }
1643 /* Do not reclaim the symbols of the rule whose action triggered
1644 this YYABORT or YYACCEPT. */
1645 YYPOPSTACK (yylen);
1646 YY_STACK_PRINT (yyss, yyssp);
1647 while (yyssp != yyss)
1648 {
1649 yydestruct ("Cleanup: popping",
1650 YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, state, lexer);
1651 YYPOPSTACK (1);
1652 }
1653 #ifndef yyoverflow
1654 if (yyss != yyssa)
1655 YYSTACK_FREE (yyss);
1656 #endif
1657
1658 return yyresult;
1659 }
1660
1661 #line 138 "parser.y"
1662
1663
1664 /**
1665 * Allocate and initialize a new parse state structure. The caller must free the
1666 * memory returned by this function.
1667 */
1668 struct lgfs2_lang_state *lgfs2_lang_init(void)
1669 {
1670 struct lgfs2_lang_state *state;
1671 state = calloc(1, sizeof(struct lgfs2_lang_state));
1672 if (state == NULL) {
1673 return NULL;
1674 }
1675 state->ls_linenum = 1;
1676 return state;
1677 }
1678
1679 void lgfs2_lang_free(struct lgfs2_lang_state **state)
1680 {
1681 ast_destroy(&(*state)->ls_ast_root);
1682 free(*state);
1683 *state = NULL;
1684 }
1685
1686 int lgfs2_lang_parsef(struct lgfs2_lang_state *state, FILE *src)
1687 {
1688 int ret = 0;
1689 yyscan_t lexer;
1690
1691 ret = yylex_init_extra(state, &lexer);
1692 if (ret != 0) {
1693 fprintf(stderr, "Failed to initialize lexer.\n");
1694 return ret;
1695 }
1696
1697 yyset_in(src, lexer);
1698 ret = yyparse(state, lexer);
1699 yylex_destroy(lexer);
1700 return ret;
1701 }
1702
1703 int lgfs2_lang_parses(struct lgfs2_lang_state *state, const char *cstr)
1704 {
1705 int ret;
1706 FILE *src;
1707 char *str = strdup(cstr);
1708
1709 if (str == NULL) {
1710 perror("Failed to duplicate source string");
1711 return 1;
1712 }
1713 /* coverity[alloc_strlen:SUPPRESS] False positive */
1714 src = fmemopen(str, strlen(str), "r");
1715 if (src == NULL) {
1716 perror("Failed to open string as source file");
1717 free(str);
1718 return 1;
1719 }
1720 ret = lgfs2_lang_parsef(state, src);
1721 fclose(src);
1722 free(str);
1723 if (ret != 0 || state->ls_errnum != 0) {
1724 return 1;
1725 }
1726 return 0;
1727 }
1728