Line data Source code
1 : /* A Bison parser, made by GNU Bison 3.0.4. */
2 :
3 : /* Bison implementation for Yacc-like parsers in C
4 :
5 : Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
6 :
7 : This program is free software: you can redistribute it and/or modify
8 : it under the terms of the GNU General Public License as published by
9 : the Free Software Foundation, either version 3 of the License, or
10 : (at your option) any later version.
11 :
12 : This program is distributed in the hope that it will be useful,
13 : but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 : GNU General Public License for more details.
16 :
17 : You should have received a copy of the GNU General Public License
18 : along with this program. If not, see <http://www.gnu.org/licenses/>. */
19 :
20 : /* As a special exception, you may create a larger work that contains
21 : part or all of the Bison parser skeleton and distribute that work
22 : under terms of your choice, so long as that work isn't itself a
23 : parser generator using the skeleton or a modified version thereof
24 : as a parser skeleton. Alternatively, if you modify or redistribute
25 : the parser skeleton itself, you may (at your option) remove this
26 : special exception, which will cause the skeleton and the resulting
27 : Bison output files to be licensed under the GNU General Public
28 : License without this special exception.
29 :
30 : This special exception was added by the Free Software Foundation in
31 : version 2.2 of Bison. */
32 :
33 : /* C LALR(1) parser skeleton written by Richard Stallman, by
34 : simplifying the original so-called "semantic" parser. */
35 :
36 : /* All symbols defined below should begin with yy or YY, to avoid
37 : infringing on user name space. This should be done even for local
38 : variables, as they might otherwise be expanded by user macros.
39 : There are some unavoidable exceptions within include files to
40 : define necessary library symbols; they are noted "INFRINGES ON
41 : USER NAME SPACE" below. */
42 :
43 : /* Identify Bison output. */
44 : #define YYBISON 1
45 :
46 : /* Bison version. */
47 : #define YYBISON_VERSION "3.0.4"
48 :
49 : /* Skeleton name. */
50 : #define YYSKELETON_NAME "yacc.c"
51 :
52 : /* Pure parsers. */
53 : #define YYPURE 1
54 :
55 : /* Push parsers. */
56 : #define YYPUSH 0
57 :
58 : /* Pull parsers. */
59 : #define YYPULL 1
60 :
61 :
62 : /* Substitute the variable and function names. */
63 : #define yyparse CalLibraryGramparse
64 : #define yylex CalLibraryGramlex
65 : #define yyerror CalLibraryGramerror
66 : #define yydebug CalLibraryGramdebug
67 : #define yynerrs CalLibraryGramnerrs
68 :
69 :
70 : /* Copy the first part of user declarations. */
71 : #line 28 "CalLibrary/CalLibraryGram.yy" /* yacc.c:339 */
72 :
73 : #include <errno.h>
74 : using namespace casacore;
75 : using namespace casa;
76 :
77 : #line 78 "/source/casa6/casatools/src/code/build/synthesis/CalLibraryGram.ycc" /* yacc.c:339 */
78 :
79 : # ifndef YY_NULLPTR
80 : # if defined __cplusplus && 201103L <= __cplusplus
81 : # define YY_NULLPTR nullptr
82 : # else
83 : # define YY_NULLPTR 0
84 : # endif
85 : # endif
86 :
87 : /* Enabling verbose error messages. */
88 : #ifdef YYERROR_VERBOSE
89 : # undef YYERROR_VERBOSE
90 : # define YYERROR_VERBOSE 1
91 : #else
92 : # define YYERROR_VERBOSE 0
93 : #endif
94 :
95 : /* In a future release of Bison, this section will be replaced
96 : by #include "CalLibraryGram.yhh". */
97 : #ifndef YY_CALLIBRARYGRAM_SOURCE_CASA6_CASATOOLS_SRC_CODE_BUILD_SYNTHESIS_CALLIBRARYGRAM_YHH_INCLUDED
98 : # define YY_CALLIBRARYGRAM_SOURCE_CASA6_CASATOOLS_SRC_CODE_BUILD_SYNTHESIS_CALLIBRARYGRAM_YHH_INCLUDED
99 : /* Debug traces. */
100 : #ifndef YYDEBUG
101 : # define YYDEBUG 0
102 : #endif
103 : #if YYDEBUG
104 : extern int CalLibraryGramdebug;
105 : #endif
106 :
107 : /* Token type. */
108 : #ifndef YYTOKENTYPE
109 : # define YYTOKENTYPE
110 : enum yytokentype
111 : {
112 : ENDL = 258,
113 : EQ = 259,
114 : INT = 260,
115 : FLOAT = 261,
116 : STRING = 262,
117 : BOOLEAN = 263,
118 : ARRAY_INT = 264,
119 : END_LIST = 265
120 : };
121 : #endif
122 : /* Tokens. */
123 : #define ENDL 258
124 : #define EQ 259
125 : #define INT 260
126 : #define FLOAT 261
127 : #define STRING 262
128 : #define BOOLEAN 263
129 : #define ARRAY_INT 264
130 : #define END_LIST 265
131 :
132 : /* Value type. */
133 : #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
134 :
135 : union YYSTYPE
136 : {
137 : #line 36 "CalLibrary/CalLibraryGram.yy" /* yacc.c:355 */
138 :
139 : Int ival;
140 : Float fval;
141 : Char *sval;
142 : Bool bval;
143 : Int idx_int;
144 : const Record* rec;
145 :
146 : #line 147 "/source/casa6/casatools/src/code/build/synthesis/CalLibraryGram.ycc" /* yacc.c:355 */
147 : };
148 :
149 : typedef union YYSTYPE YYSTYPE;
150 : # define YYSTYPE_IS_TRIVIAL 1
151 : # define YYSTYPE_IS_DECLARED 1
152 : #endif
153 :
154 :
155 :
156 : int CalLibraryGramparse (void);
157 :
158 : #endif /* !YY_CALLIBRARYGRAM_SOURCE_CASA6_CASATOOLS_SRC_CODE_BUILD_SYNTHESIS_CALLIBRARYGRAM_YHH_INCLUDED */
159 :
160 : /* Copy the second part of user declarations. */
161 : #line 57 "CalLibrary/CalLibraryGram.yy" /* yacc.c:358 */
162 :
163 : int CalLibraryGramlex (YYSTYPE*);
164 :
165 : #line 166 "/source/casa6/casatools/src/code/build/synthesis/CalLibraryGram.ycc" /* yacc.c:358 */
166 :
167 : #ifdef short
168 : # undef short
169 : #endif
170 :
171 : #ifdef YYTYPE_UINT8
172 : typedef YYTYPE_UINT8 yytype_uint8;
173 : #else
174 : typedef unsigned char yytype_uint8;
175 : #endif
176 :
177 : #ifdef YYTYPE_INT8
178 : typedef YYTYPE_INT8 yytype_int8;
179 : #else
180 : typedef signed char yytype_int8;
181 : #endif
182 :
183 : #ifdef YYTYPE_UINT16
184 : typedef YYTYPE_UINT16 yytype_uint16;
185 : #else
186 : typedef unsigned short int yytype_uint16;
187 : #endif
188 :
189 : #ifdef YYTYPE_INT16
190 : typedef YYTYPE_INT16 yytype_int16;
191 : #else
192 : typedef short int yytype_int16;
193 : #endif
194 :
195 : #ifndef YYSIZE_T
196 : # ifdef __SIZE_TYPE__
197 : # define YYSIZE_T __SIZE_TYPE__
198 : # elif defined size_t
199 : # define YYSIZE_T size_t
200 : # elif ! defined YYSIZE_T
201 : # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
202 : # define YYSIZE_T size_t
203 : # else
204 : # define YYSIZE_T unsigned int
205 : # endif
206 : #endif
207 :
208 : #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
209 :
210 : #ifndef YY_
211 : # if defined YYENABLE_NLS && YYENABLE_NLS
212 : # if ENABLE_NLS
213 : # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
214 : # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
215 : # endif
216 : # endif
217 : # ifndef YY_
218 : # define YY_(Msgid) Msgid
219 : # endif
220 : #endif
221 :
222 : #ifndef YY_ATTRIBUTE
223 : # if (defined __GNUC__ \
224 : && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
225 : || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
226 : # define YY_ATTRIBUTE(Spec) __attribute__(Spec)
227 : # else
228 : # define YY_ATTRIBUTE(Spec) /* empty */
229 : # endif
230 : #endif
231 :
232 : #ifndef YY_ATTRIBUTE_PURE
233 : # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
234 : #endif
235 :
236 : #ifndef YY_ATTRIBUTE_UNUSED
237 : # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
238 : #endif
239 :
240 : #if !defined _Noreturn \
241 : && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
242 : # if defined _MSC_VER && 1200 <= _MSC_VER
243 : # define _Noreturn __declspec (noreturn)
244 : # else
245 : # define _Noreturn YY_ATTRIBUTE ((__noreturn__))
246 : # endif
247 : #endif
248 :
249 : /* Suppress unused-variable warnings by "using" E. */
250 : #if ! defined lint || defined __GNUC__
251 : # define YYUSE(E) ((void) (E))
252 : #else
253 : # define YYUSE(E) /* empty */
254 : #endif
255 :
256 : #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
257 : /* Suppress an incorrect diagnostic about yylval being uninitialized. */
258 : # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
259 : _Pragma ("GCC diagnostic push") \
260 : _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
261 : _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
262 : # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
263 : _Pragma ("GCC diagnostic pop")
264 : #else
265 : # define YY_INITIAL_VALUE(Value) Value
266 : #endif
267 : #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
268 : # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
269 : # define YY_IGNORE_MAYBE_UNINITIALIZED_END
270 : #endif
271 : #ifndef YY_INITIAL_VALUE
272 : # define YY_INITIAL_VALUE(Value) /* Nothing. */
273 : #endif
274 :
275 :
276 : #if ! defined yyoverflow || YYERROR_VERBOSE
277 :
278 : /* The parser invokes alloca or malloc; define the necessary symbols. */
279 :
280 : # ifdef YYSTACK_USE_ALLOCA
281 : # if YYSTACK_USE_ALLOCA
282 : # ifdef __GNUC__
283 : # define YYSTACK_ALLOC __builtin_alloca
284 : # elif defined __BUILTIN_VA_ARG_INCR
285 : # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
286 : # elif defined _AIX
287 : # define YYSTACK_ALLOC __alloca
288 : # elif defined _MSC_VER
289 : # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
290 : # define alloca _alloca
291 : # else
292 : # define YYSTACK_ALLOC alloca
293 : # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
294 : # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
295 : /* Use EXIT_SUCCESS as a witness for stdlib.h. */
296 : # ifndef EXIT_SUCCESS
297 : # define EXIT_SUCCESS 0
298 : # endif
299 : # endif
300 : # endif
301 : # endif
302 : # endif
303 :
304 : # ifdef YYSTACK_ALLOC
305 : /* Pacify GCC's 'empty if-body' warning. */
306 : # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
307 : # ifndef YYSTACK_ALLOC_MAXIMUM
308 : /* The OS might guarantee only one guard page at the bottom of the stack,
309 : and a page size can be as small as 4096 bytes. So we cannot safely
310 : invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
311 : to allow for a few compiler-allocated temporary stack slots. */
312 : # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
313 : # endif
314 : # else
315 : # define YYSTACK_ALLOC YYMALLOC
316 : # define YYSTACK_FREE YYFREE
317 : # ifndef YYSTACK_ALLOC_MAXIMUM
318 : # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
319 : # endif
320 : # if (defined __cplusplus && ! defined EXIT_SUCCESS \
321 : && ! ((defined YYMALLOC || defined malloc) \
322 : && (defined YYFREE || defined free)))
323 : # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
324 : # ifndef EXIT_SUCCESS
325 : # define EXIT_SUCCESS 0
326 : # endif
327 : # endif
328 : # ifndef YYMALLOC
329 : # define YYMALLOC malloc
330 : # if ! defined malloc && ! defined EXIT_SUCCESS
331 : void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
332 : # endif
333 : # endif
334 : # ifndef YYFREE
335 : # define YYFREE free
336 : # if ! defined free && ! defined EXIT_SUCCESS
337 : void free (void *); /* INFRINGES ON USER NAME SPACE */
338 : # endif
339 : # endif
340 : # endif
341 : #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
342 :
343 :
344 : #if (! defined yyoverflow \
345 : && (! defined __cplusplus \
346 : || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
347 :
348 : /* A type that is properly aligned for any stack member. */
349 : union yyalloc
350 : {
351 : yytype_int16 yyss_alloc;
352 : YYSTYPE yyvs_alloc;
353 : };
354 :
355 : /* The size of the maximum gap between one aligned stack and the next. */
356 : # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
357 :
358 : /* The size of an array large to enough to hold all stacks, each with
359 : N elements. */
360 : # define YYSTACK_BYTES(N) \
361 : ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
362 : + YYSTACK_GAP_MAXIMUM)
363 :
364 : # define YYCOPY_NEEDED 1
365 :
366 : /* Relocate STACK from its old location to the new one. The
367 : local variables YYSIZE and YYSTACKSIZE give the old and new number of
368 : elements in the stack, and YYPTR gives the new location of the
369 : stack. Advance YYPTR to a properly aligned location for the next
370 : stack. */
371 : # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
372 : do \
373 : { \
374 : YYSIZE_T yynewbytes; \
375 : YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
376 : Stack = &yyptr->Stack_alloc; \
377 : yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
378 : yyptr += yynewbytes / sizeof (*yyptr); \
379 : } \
380 : while (0)
381 :
382 : #endif
383 :
384 : #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
385 : /* Copy COUNT objects from SRC to DST. The source and destination do
386 : not overlap. */
387 : # ifndef YYCOPY
388 : # if defined __GNUC__ && 1 < __GNUC__
389 : # define YYCOPY(Dst, Src, Count) \
390 : __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
391 : # else
392 : # define YYCOPY(Dst, Src, Count) \
393 : do \
394 : { \
395 : YYSIZE_T yyi; \
396 : for (yyi = 0; yyi < (Count); yyi++) \
397 : (Dst)[yyi] = (Src)[yyi]; \
398 : } \
399 : while (0)
400 : # endif
401 : # endif
402 : #endif /* !YYCOPY_NEEDED */
403 :
404 : /* YYFINAL -- State number of the termination state. */
405 : #define YYFINAL 10
406 : /* YYLAST -- Last index in YYTABLE. */
407 : #define YYLAST 11
408 :
409 : /* YYNTOKENS -- Number of terminals. */
410 : #define YYNTOKENS 11
411 : /* YYNNTS -- Number of nonterminals. */
412 : #define YYNNTS 5
413 : /* YYNRULES -- Number of rules. */
414 : #define YYNRULES 12
415 : /* YYNSTATES -- Number of states. */
416 : #define YYNSTATES 16
417 :
418 : /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
419 : by yylex, with out-of-bounds checking. */
420 : #define YYUNDEFTOK 2
421 : #define YYMAXUTOK 265
422 :
423 : #define YYTRANSLATE(YYX) \
424 : ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
425 :
426 : /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
427 : as returned by yylex, without out-of-bounds checking. */
428 : static const yytype_uint8 yytranslate[] =
429 : {
430 : 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
431 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
432 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
433 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
434 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
435 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
436 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
437 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
438 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
439 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
440 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
441 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
442 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
443 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
444 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
445 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
446 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
447 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
448 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
449 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
450 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
451 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
452 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
453 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
454 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
455 : 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
456 : 5, 6, 7, 8, 9, 10
457 : };
458 :
459 : #if YYDEBUG
460 : /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
461 : static const yytype_uint8 yyrline[] =
462 : {
463 : 0, 63, 63, 69, 70, 73, 74, 77, 80, 83,
464 : 86, 89, 92
465 : };
466 : #endif
467 :
468 : #if YYDEBUG || YYERROR_VERBOSE || 0
469 : /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
470 : First, the terminals, then, starting at YYNTOKENS, nonterminals. */
471 : static const char *const yytname[] =
472 : {
473 : "$end", "error", "$undefined", "ENDL", "EQ", "INT", "FLOAT", "STRING",
474 : "BOOLEAN", "ARRAY_INT", "END_LIST", "$accept", "callibrary",
475 : "calibration_lines", "calibration_line", "calibration_param", YY_NULLPTR
476 : };
477 : #endif
478 :
479 : # ifdef YYPRINT
480 : /* YYTOKNUM[NUM] -- (External) token number corresponding to the
481 : (internal) symbol number NUM (which must be that of a token). */
482 : static const yytype_uint16 yytoknum[] =
483 : {
484 : 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
485 : 265
486 : };
487 : # endif
488 :
489 : #define YYPACT_NINF -7
490 :
491 : #define yypact_value_is_default(Yystate) \
492 : (!!((Yystate) == (-7)))
493 :
494 : #define YYTABLE_NINF -1
495 :
496 : #define yytable_value_is_error(Yytable_value) \
497 : 0
498 :
499 : /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
500 : STATE-NUM. */
501 : static const yytype_int8 yypact[] =
502 : {
503 : -3, -7, -2, -7, -7, 3, -3, -3, -7, 1,
504 : -7, -3, -7, -7, -7, -7
505 : };
506 :
507 : /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
508 : Performed when YYTABLE does not specify something else to do. Zero
509 : means the default is an error. */
510 : static const yytype_uint8 yydefact[] =
511 : {
512 : 0, 12, 0, 10, 11, 0, 2, 4, 6, 0,
513 : 1, 3, 5, 7, 8, 9
514 : };
515 :
516 : /* YYPGOTO[NTERM-NUM]. */
517 : static const yytype_int8 yypgoto[] =
518 : {
519 : -7, -7, -7, 5, -6
520 : };
521 :
522 : /* YYDEFGOTO[NTERM-NUM]. */
523 : static const yytype_int8 yydefgoto[] =
524 : {
525 : -1, 5, 6, 7, 8
526 : };
527 :
528 : /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
529 : positive, shift that token. If negative, reduce the rule whose
530 : number is the opposite. If YYTABLE_NINF, syntax error. */
531 : static const yytype_uint8 yytable[] =
532 : {
533 : 1, 12, 9, 10, 2, 12, 3, 4, 13, 14,
534 : 15, 11
535 : };
536 :
537 : static const yytype_uint8 yycheck[] =
538 : {
539 : 3, 7, 4, 0, 7, 11, 9, 10, 7, 8,
540 : 9, 6
541 : };
542 :
543 : /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
544 : symbol of state STATE-NUM. */
545 : static const yytype_uint8 yystos[] =
546 : {
547 : 0, 3, 7, 9, 10, 12, 13, 14, 15, 4,
548 : 0, 14, 15, 7, 8, 9
549 : };
550 :
551 : /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
552 : static const yytype_uint8 yyr1[] =
553 : {
554 : 0, 11, 12, 13, 13, 14, 14, 15, 15, 15,
555 : 15, 15, 15
556 : };
557 :
558 : /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
559 : static const yytype_uint8 yyr2[] =
560 : {
561 : 0, 2, 1, 2, 1, 2, 1, 3, 3, 3,
562 : 1, 1, 1
563 : };
564 :
565 :
566 : #define yyerrok (yyerrstatus = 0)
567 : #define yyclearin (yychar = YYEMPTY)
568 : #define YYEMPTY (-2)
569 : #define YYEOF 0
570 :
571 : #define YYACCEPT goto yyacceptlab
572 : #define YYABORT goto yyabortlab
573 : #define YYERROR goto yyerrorlab
574 :
575 :
576 : #define YYRECOVERING() (!!yyerrstatus)
577 :
578 : #define YYBACKUP(Token, Value) \
579 : do \
580 : if (yychar == YYEMPTY) \
581 : { \
582 : yychar = (Token); \
583 : yylval = (Value); \
584 : YYPOPSTACK (yylen); \
585 : yystate = *yyssp; \
586 : goto yybackup; \
587 : } \
588 : else \
589 : { \
590 : yyerror (YY_("syntax error: cannot back up")); \
591 : YYERROR; \
592 : } \
593 : while (0)
594 :
595 : /* Error token number */
596 : #define YYTERROR 1
597 : #define YYERRCODE 256
598 :
599 :
600 :
601 : /* Enable debugging if requested. */
602 : #if YYDEBUG
603 :
604 : # ifndef YYFPRINTF
605 : # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
606 : # define YYFPRINTF fprintf
607 : # endif
608 :
609 : # define YYDPRINTF(Args) \
610 : do { \
611 : if (yydebug) \
612 : YYFPRINTF Args; \
613 : } while (0)
614 :
615 : /* This macro is provided for backward compatibility. */
616 : #ifndef YY_LOCATION_PRINT
617 : # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
618 : #endif
619 :
620 :
621 : # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
622 : do { \
623 : if (yydebug) \
624 : { \
625 : YYFPRINTF (stderr, "%s ", Title); \
626 : yy_symbol_print (stderr, \
627 : Type, Value); \
628 : YYFPRINTF (stderr, "\n"); \
629 : } \
630 : } while (0)
631 :
632 :
633 : /*----------------------------------------.
634 : | Print this symbol's value on YYOUTPUT. |
635 : `----------------------------------------*/
636 :
637 : static void
638 : yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
639 : {
640 : FILE *yyo = yyoutput;
641 : YYUSE (yyo);
642 : if (!yyvaluep)
643 : return;
644 : # ifdef YYPRINT
645 : if (yytype < YYNTOKENS)
646 : YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
647 : # endif
648 : YYUSE (yytype);
649 : }
650 :
651 :
652 : /*--------------------------------.
653 : | Print this symbol on YYOUTPUT. |
654 : `--------------------------------*/
655 :
656 : static void
657 : yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
658 : {
659 : YYFPRINTF (yyoutput, "%s %s (",
660 : yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
661 :
662 : yy_symbol_value_print (yyoutput, yytype, yyvaluep);
663 : YYFPRINTF (yyoutput, ")");
664 : }
665 :
666 : /*------------------------------------------------------------------.
667 : | yy_stack_print -- Print the state stack from its BOTTOM up to its |
668 : | TOP (included). |
669 : `------------------------------------------------------------------*/
670 :
671 : static void
672 : yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
673 : {
674 : YYFPRINTF (stderr, "Stack now");
675 : for (; yybottom <= yytop; yybottom++)
676 : {
677 : int yybot = *yybottom;
678 : YYFPRINTF (stderr, " %d", yybot);
679 : }
680 : YYFPRINTF (stderr, "\n");
681 : }
682 :
683 : # define YY_STACK_PRINT(Bottom, Top) \
684 : do { \
685 : if (yydebug) \
686 : yy_stack_print ((Bottom), (Top)); \
687 : } while (0)
688 :
689 :
690 : /*------------------------------------------------.
691 : | Report that the YYRULE is going to be reduced. |
692 : `------------------------------------------------*/
693 :
694 : static void
695 : yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule)
696 : {
697 : unsigned long int yylno = yyrline[yyrule];
698 : int yynrhs = yyr2[yyrule];
699 : int yyi;
700 : YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
701 : yyrule - 1, yylno);
702 : /* The symbols being reduced. */
703 : for (yyi = 0; yyi < yynrhs; yyi++)
704 : {
705 : YYFPRINTF (stderr, " $%d = ", yyi + 1);
706 : yy_symbol_print (stderr,
707 : yystos[yyssp[yyi + 1 - yynrhs]],
708 : &(yyvsp[(yyi + 1) - (yynrhs)])
709 : );
710 : YYFPRINTF (stderr, "\n");
711 : }
712 : }
713 :
714 : # define YY_REDUCE_PRINT(Rule) \
715 : do { \
716 : if (yydebug) \
717 : yy_reduce_print (yyssp, yyvsp, Rule); \
718 : } while (0)
719 :
720 : /* Nonzero means print parse trace. It is left uninitialized so that
721 : multiple parsers can coexist. */
722 : int yydebug;
723 : #else /* !YYDEBUG */
724 : # define YYDPRINTF(Args)
725 : # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
726 : # define YY_STACK_PRINT(Bottom, Top)
727 : # define YY_REDUCE_PRINT(Rule)
728 : #endif /* !YYDEBUG */
729 :
730 :
731 : /* YYINITDEPTH -- initial size of the parser's stacks. */
732 : #ifndef YYINITDEPTH
733 : # define YYINITDEPTH 200
734 : #endif
735 :
736 : /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
737 : if the built-in stack extension method is used).
738 :
739 : Do not make this value too large; the results are undefined if
740 : YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
741 : evaluated with infinite-precision integer arithmetic. */
742 :
743 : #ifndef YYMAXDEPTH
744 : # define YYMAXDEPTH 10000
745 : #endif
746 :
747 :
748 : #if YYERROR_VERBOSE
749 :
750 : # ifndef yystrlen
751 : # if defined __GLIBC__ && defined _STRING_H
752 : # define yystrlen strlen
753 : # else
754 : /* Return the length of YYSTR. */
755 : static YYSIZE_T
756 : yystrlen (const char *yystr)
757 : {
758 : YYSIZE_T yylen;
759 : for (yylen = 0; yystr[yylen]; yylen++)
760 : continue;
761 : return yylen;
762 : }
763 : # endif
764 : # endif
765 :
766 : # ifndef yystpcpy
767 : # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
768 : # define yystpcpy stpcpy
769 : # else
770 : /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
771 : YYDEST. */
772 : static char *
773 : yystpcpy (char *yydest, const char *yysrc)
774 : {
775 : char *yyd = yydest;
776 : const char *yys = yysrc;
777 :
778 : while ((*yyd++ = *yys++) != '\0')
779 : continue;
780 :
781 : return yyd - 1;
782 : }
783 : # endif
784 : # endif
785 :
786 : # ifndef yytnamerr
787 : /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
788 : quotes and backslashes, so that it's suitable for yyerror. The
789 : heuristic is that double-quoting is unnecessary unless the string
790 : contains an apostrophe, a comma, or backslash (other than
791 : backslash-backslash). YYSTR is taken from yytname. If YYRES is
792 : null, do not copy; instead, return the length of what the result
793 : would have been. */
794 : static YYSIZE_T
795 : yytnamerr (char *yyres, const char *yystr)
796 : {
797 : if (*yystr == '"')
798 : {
799 : YYSIZE_T yyn = 0;
800 : char const *yyp = yystr;
801 :
802 : for (;;)
803 : switch (*++yyp)
804 : {
805 : case '\'':
806 : case ',':
807 : goto do_not_strip_quotes;
808 :
809 : case '\\':
810 : if (*++yyp != '\\')
811 : goto do_not_strip_quotes;
812 : /* Fall through. */
813 : default:
814 : if (yyres)
815 : yyres[yyn] = *yyp;
816 : yyn++;
817 : break;
818 :
819 : case '"':
820 : if (yyres)
821 : yyres[yyn] = '\0';
822 : return yyn;
823 : }
824 : do_not_strip_quotes: ;
825 : }
826 :
827 : if (! yyres)
828 : return yystrlen (yystr);
829 :
830 : return yystpcpy (yyres, yystr) - yyres;
831 : }
832 : # endif
833 :
834 : /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
835 : about the unexpected token YYTOKEN for the state stack whose top is
836 : YYSSP.
837 :
838 : Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
839 : not large enough to hold the message. In that case, also set
840 : *YYMSG_ALLOC to the required number of bytes. Return 2 if the
841 : required number of bytes is too large to store. */
842 : static int
843 : yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
844 : yytype_int16 *yyssp, int yytoken)
845 : {
846 : YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
847 : YYSIZE_T yysize = yysize0;
848 : enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
849 : /* Internationalized format string. */
850 : const char *yyformat = YY_NULLPTR;
851 : /* Arguments of yyformat. */
852 : char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
853 : /* Number of reported tokens (one for the "unexpected", one per
854 : "expected"). */
855 : int yycount = 0;
856 :
857 : /* There are many possibilities here to consider:
858 : - If this state is a consistent state with a default action, then
859 : the only way this function was invoked is if the default action
860 : is an error action. In that case, don't check for expected
861 : tokens because there are none.
862 : - The only way there can be no lookahead present (in yychar) is if
863 : this state is a consistent state with a default action. Thus,
864 : detecting the absence of a lookahead is sufficient to determine
865 : that there is no unexpected or expected token to report. In that
866 : case, just report a simple "syntax error".
867 : - Don't assume there isn't a lookahead just because this state is a
868 : consistent state with a default action. There might have been a
869 : previous inconsistent state, consistent state with a non-default
870 : action, or user semantic action that manipulated yychar.
871 : - Of course, the expected token list depends on states to have
872 : correct lookahead information, and it depends on the parser not
873 : to perform extra reductions after fetching a lookahead from the
874 : scanner and before detecting a syntax error. Thus, state merging
875 : (from LALR or IELR) and default reductions corrupt the expected
876 : token list. However, the list is correct for canonical LR with
877 : one exception: it will still contain any token that will not be
878 : accepted due to an error action in a later state.
879 : */
880 : if (yytoken != YYEMPTY)
881 : {
882 : int yyn = yypact[*yyssp];
883 : yyarg[yycount++] = yytname[yytoken];
884 : if (!yypact_value_is_default (yyn))
885 : {
886 : /* Start YYX at -YYN if negative to avoid negative indexes in
887 : YYCHECK. In other words, skip the first -YYN actions for
888 : this state because they are default actions. */
889 : int yyxbegin = yyn < 0 ? -yyn : 0;
890 : /* Stay within bounds of both yycheck and yytname. */
891 : int yychecklim = YYLAST - yyn + 1;
892 : int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
893 : int yyx;
894 :
895 : for (yyx = yyxbegin; yyx < yyxend; ++yyx)
896 : if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
897 : && !yytable_value_is_error (yytable[yyx + yyn]))
898 : {
899 : if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
900 : {
901 : yycount = 1;
902 : yysize = yysize0;
903 : break;
904 : }
905 : yyarg[yycount++] = yytname[yyx];
906 : {
907 : YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
908 : if (! (yysize <= yysize1
909 : && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
910 : return 2;
911 : yysize = yysize1;
912 : }
913 : }
914 : }
915 : }
916 :
917 : switch (yycount)
918 : {
919 : # define YYCASE_(N, S) \
920 : case N: \
921 : yyformat = S; \
922 : break
923 : YYCASE_(0, YY_("syntax error"));
924 : YYCASE_(1, YY_("syntax error, unexpected %s"));
925 : YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
926 : YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
927 : YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
928 : YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
929 : # undef YYCASE_
930 : }
931 :
932 : {
933 : YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
934 : if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
935 : return 2;
936 : yysize = yysize1;
937 : }
938 :
939 : if (*yymsg_alloc < yysize)
940 : {
941 : *yymsg_alloc = 2 * yysize;
942 : if (! (yysize <= *yymsg_alloc
943 : && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
944 : *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
945 : return 1;
946 : }
947 :
948 : /* Avoid sprintf, as that infringes on the user's name space.
949 : Don't have undefined behavior even if the translation
950 : produced a string with the wrong number of "%s"s. */
951 : {
952 : char *yyp = *yymsg;
953 : int yyi = 0;
954 : while ((*yyp = *yyformat) != '\0')
955 : if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
956 : {
957 : yyp += yytnamerr (yyp, yyarg[yyi++]);
958 : yyformat += 2;
959 : }
960 : else
961 : {
962 : yyp++;
963 : yyformat++;
964 : }
965 : }
966 : return 0;
967 : }
968 : #endif /* YYERROR_VERBOSE */
969 :
970 : /*-----------------------------------------------.
971 : | Release the memory associated to this symbol. |
972 : `-----------------------------------------------*/
973 :
974 : static void
975 28 : yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
976 : {
977 : YYUSE (yyvaluep);
978 28 : if (!yymsg)
979 0 : yymsg = "Deleting";
980 : YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
981 :
982 : YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
983 : YYUSE (yytype);
984 : YY_IGNORE_MAYBE_UNINITIALIZED_END
985 28 : }
986 :
987 :
988 :
989 :
990 : /*----------.
991 : | yyparse. |
992 : `----------*/
993 :
994 : int
995 14 : yyparse (void)
996 : {
997 : /* The lookahead symbol. */
998 : int yychar;
999 :
1000 :
1001 : /* The semantic value of the lookahead symbol. */
1002 : /* Default value used for initialization, for pacifying older GCCs
1003 : or non-GCC compilers. */
1004 : YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
1005 : YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
1006 :
1007 : /* Number of syntax errors so far. */
1008 : int yynerrs;
1009 :
1010 : int yystate;
1011 : /* Number of tokens to shift before error messages enabled. */
1012 : int yyerrstatus;
1013 :
1014 : /* The stacks and their tools:
1015 : 'yyss': related to states.
1016 : 'yyvs': related to semantic values.
1017 :
1018 : Refer to the stacks through separate pointers, to allow yyoverflow
1019 : to reallocate them elsewhere. */
1020 :
1021 : /* The state stack. */
1022 : yytype_int16 yyssa[YYINITDEPTH];
1023 : yytype_int16 *yyss;
1024 : yytype_int16 *yyssp;
1025 :
1026 : /* The semantic value stack. */
1027 : YYSTYPE yyvsa[YYINITDEPTH];
1028 : YYSTYPE *yyvs;
1029 : YYSTYPE *yyvsp;
1030 :
1031 : YYSIZE_T yystacksize;
1032 :
1033 : int yyn;
1034 : int yyresult;
1035 : /* Lookahead token as an internal (translated) token number. */
1036 14 : int yytoken = 0;
1037 : /* The variables used to return semantic value and location from the
1038 : action routines. */
1039 : YYSTYPE yyval;
1040 :
1041 : #if YYERROR_VERBOSE
1042 : /* Buffer for error messages, and its allocated size. */
1043 : char yymsgbuf[128];
1044 : char *yymsg = yymsgbuf;
1045 : YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1046 : #endif
1047 :
1048 : #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1049 :
1050 : /* The number of symbols on the RHS of the reduced rule.
1051 : Keep to zero when no symbol should be popped. */
1052 14 : int yylen = 0;
1053 :
1054 14 : yyssp = yyss = yyssa;
1055 14 : yyvsp = yyvs = yyvsa;
1056 14 : yystacksize = YYINITDEPTH;
1057 :
1058 : YYDPRINTF ((stderr, "Starting parse\n"));
1059 :
1060 14 : yystate = 0;
1061 14 : yyerrstatus = 0;
1062 14 : yynerrs = 0;
1063 14 : yychar = YYEMPTY; /* Cause a token to be read. */
1064 14 : goto yysetstate;
1065 :
1066 : /*------------------------------------------------------------.
1067 : | yynewstate -- Push a new state, which is found in yystate. |
1068 : `------------------------------------------------------------*/
1069 500 : yynewstate:
1070 : /* In all cases, when you get here, the value and location stacks
1071 : have just been pushed. So pushing a state here evens the stacks. */
1072 500 : yyssp++;
1073 :
1074 514 : yysetstate:
1075 514 : *yyssp = yystate;
1076 :
1077 514 : if (yyss + yystacksize - 1 <= yyssp)
1078 : {
1079 : /* Get the current used size of the three stacks, in elements. */
1080 0 : YYSIZE_T yysize = yyssp - yyss + 1;
1081 :
1082 : #ifdef yyoverflow
1083 : {
1084 : /* Give user a chance to reallocate the stack. Use copies of
1085 : these so that the &'s don't force the real ones into
1086 : memory. */
1087 : YYSTYPE *yyvs1 = yyvs;
1088 : yytype_int16 *yyss1 = yyss;
1089 :
1090 : /* Each stack pointer address is followed by the size of the
1091 : data in use in that stack, in bytes. This used to be a
1092 : conditional around just the two extra args, but that might
1093 : be undefined if yyoverflow is a macro. */
1094 : yyoverflow (YY_("memory exhausted"),
1095 : &yyss1, yysize * sizeof (*yyssp),
1096 : &yyvs1, yysize * sizeof (*yyvsp),
1097 : &yystacksize);
1098 :
1099 : yyss = yyss1;
1100 : yyvs = yyvs1;
1101 : }
1102 : #else /* no yyoverflow */
1103 : # ifndef YYSTACK_RELOCATE
1104 : goto yyexhaustedlab;
1105 : # else
1106 : /* Extend the stack our own way. */
1107 0 : if (YYMAXDEPTH <= yystacksize)
1108 0 : goto yyexhaustedlab;
1109 0 : yystacksize *= 2;
1110 0 : if (YYMAXDEPTH < yystacksize)
1111 0 : yystacksize = YYMAXDEPTH;
1112 :
1113 : {
1114 0 : yytype_int16 *yyss1 = yyss;
1115 : union yyalloc *yyptr =
1116 0 : (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1117 0 : if (! yyptr)
1118 0 : goto yyexhaustedlab;
1119 0 : YYSTACK_RELOCATE (yyss_alloc, yyss);
1120 0 : YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1121 : # undef YYSTACK_RELOCATE
1122 0 : if (yyss1 != yyssa)
1123 0 : YYSTACK_FREE (yyss1);
1124 : }
1125 : # endif
1126 : #endif /* no yyoverflow */
1127 :
1128 0 : yyssp = yyss + yysize - 1;
1129 0 : yyvsp = yyvs + yysize - 1;
1130 :
1131 : YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1132 : (unsigned long int) yystacksize));
1133 :
1134 0 : if (yyss + yystacksize - 1 <= yyssp)
1135 0 : YYABORT;
1136 : }
1137 :
1138 : YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1139 :
1140 514 : if (yystate == YYFINAL)
1141 14 : YYACCEPT;
1142 :
1143 500 : goto yybackup;
1144 :
1145 : /*-----------.
1146 : | yybackup. |
1147 : `-----------*/
1148 500 : yybackup:
1149 :
1150 : /* Do appropriate processing given the current state. Read a
1151 : lookahead token if we need one and don't already have one. */
1152 :
1153 : /* First try to decide what to do without reference to lookahead token. */
1154 500 : yyn = yypact[yystate];
1155 500 : if (yypact_value_is_default (yyn))
1156 208 : goto yydefault;
1157 :
1158 : /* Not known => get a lookahead token if don't already have one. */
1159 :
1160 : /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1161 292 : if (yychar == YYEMPTY)
1162 : {
1163 : YYDPRINTF ((stderr, "Reading a token: "));
1164 264 : yychar = yylex (&yylval);
1165 : }
1166 :
1167 292 : if (yychar <= YYEOF)
1168 : {
1169 42 : yychar = yytoken = YYEOF;
1170 : YYDPRINTF ((stderr, "Now at end of input.\n"));
1171 : }
1172 : else
1173 : {
1174 250 : yytoken = YYTRANSLATE (yychar);
1175 : YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1176 : }
1177 :
1178 : /* If the proper action on seeing token YYTOKEN is to reduce or to
1179 : detect an error, take that action. */
1180 292 : yyn += yytoken;
1181 292 : if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1182 28 : goto yydefault;
1183 264 : yyn = yytable[yyn];
1184 264 : if (yyn <= 0)
1185 : {
1186 : if (yytable_value_is_error (yyn))
1187 : goto yyerrlab;
1188 0 : yyn = -yyn;
1189 0 : goto yyreduce;
1190 : }
1191 :
1192 : /* Count tokens shifted since error; after three, turn off error
1193 : status. */
1194 264 : if (yyerrstatus)
1195 0 : yyerrstatus--;
1196 :
1197 : /* Shift the lookahead token. */
1198 : YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1199 :
1200 : /* Discard the shifted token. */
1201 264 : yychar = YYEMPTY;
1202 :
1203 264 : yystate = yyn;
1204 : YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1205 264 : *++yyvsp = yylval;
1206 : YY_IGNORE_MAYBE_UNINITIALIZED_END
1207 :
1208 264 : goto yynewstate;
1209 :
1210 :
1211 : /*-----------------------------------------------------------.
1212 : | yydefault -- do the default action for the current state. |
1213 : `-----------------------------------------------------------*/
1214 236 : yydefault:
1215 236 : yyn = yydefact[yystate];
1216 236 : if (yyn == 0)
1217 0 : goto yyerrlab;
1218 236 : goto yyreduce;
1219 :
1220 :
1221 : /*-----------------------------.
1222 : | yyreduce -- Do a reduction. |
1223 : `-----------------------------*/
1224 236 : yyreduce:
1225 : /* yyn is the number of a rule to reduce with. */
1226 236 : yylen = yyr2[yyn];
1227 :
1228 : /* If YYLEN is nonzero, implement the default value of the action:
1229 : '$$ = $1'.
1230 :
1231 : Otherwise, the following line sets YYVAL to garbage.
1232 : This behavior is undocumented and Bison
1233 : users should not rely upon it. Assigning to YYVAL
1234 : unconditionally makes the parser a bit smaller, and it avoids a
1235 : GCC warning that YYVAL may be used uninitialized. */
1236 236 : yyval = yyvsp[1-yylen];
1237 :
1238 :
1239 : YY_REDUCE_PRINT (yyn);
1240 236 : switch (yyn)
1241 : {
1242 14 : case 2:
1243 : #line 64 "CalLibrary/CalLibraryGram.yy" /* yacc.c:1646 */
1244 : {
1245 : (yyval.rec) = CalLibraryParse().record();
1246 : }
1247 : #line 1248 "/source/casa6/casatools/src/code/build/synthesis/CalLibraryGram.ycc" /* yacc.c:1646 */
1248 14 : break;
1249 :
1250 51 : case 7:
1251 : #line 77 "CalLibrary/CalLibraryGram.yy" /* yacc.c:1646 */
1252 : {
1253 : CalLibraryParse::thisCalLibParser->addStringParam((yyvsp[-2].sval), (yyvsp[0].sval));
1254 : }
1255 : #line 1256 "/source/casa6/casatools/src/code/build/synthesis/CalLibraryGram.ycc" /* yacc.c:1646 */
1256 51 : break;
1257 :
1258 17 : case 8:
1259 : #line 80 "CalLibrary/CalLibraryGram.yy" /* yacc.c:1646 */
1260 : {
1261 : CalLibraryParse::thisCalLibParser->addBoolParam((yyvsp[-2].sval), (yyvsp[0].bval));
1262 : }
1263 : #line 1264 "/source/casa6/casatools/src/code/build/synthesis/CalLibraryGram.ycc" /* yacc.c:1646 */
1264 17 : break;
1265 :
1266 5 : case 9:
1267 : #line 83 "CalLibrary/CalLibraryGram.yy" /* yacc.c:1646 */
1268 : {
1269 : CalLibraryParse::thisCalLibParser->addMapParam((yyvsp[-2].sval), (yyvsp[0].idx_int));
1270 : }
1271 : #line 1272 "/source/casa6/casatools/src/code/build/synthesis/CalLibraryGram.ycc" /* yacc.c:1646 */
1272 5 : break;
1273 :
1274 5 : case 10:
1275 : #line 86 "CalLibrary/CalLibraryGram.yy" /* yacc.c:1646 */
1276 : {
1277 : CalLibraryParse::thisCalLibParser->addMapParam((yyvsp[0].idx_int));
1278 : }
1279 : #line 1280 "/source/casa6/casatools/src/code/build/synthesis/CalLibraryGram.ycc" /* yacc.c:1646 */
1280 5 : break;
1281 :
1282 5 : case 11:
1283 : #line 89 "CalLibrary/CalLibraryGram.yy" /* yacc.c:1646 */
1284 : {
1285 : CalLibraryParse::thisCalLibParser->addMap();
1286 : }
1287 : #line 1288 "/source/casa6/casatools/src/code/build/synthesis/CalLibraryGram.ycc" /* yacc.c:1646 */
1288 5 : break;
1289 :
1290 21 : case 12:
1291 : #line 92 "CalLibrary/CalLibraryGram.yy" /* yacc.c:1646 */
1292 : { // end of this caltable
1293 : CalLibraryParse::thisCalLibParser->addCaltable();
1294 : }
1295 : #line 1296 "/source/casa6/casatools/src/code/build/synthesis/CalLibraryGram.ycc" /* yacc.c:1646 */
1296 21 : break;
1297 :
1298 :
1299 : #line 1300 "/source/casa6/casatools/src/code/build/synthesis/CalLibraryGram.ycc" /* yacc.c:1646 */
1300 118 : default: break;
1301 : }
1302 : /* User semantic actions sometimes alter yychar, and that requires
1303 : that yytoken be updated with the new translation. We take the
1304 : approach of translating immediately before every use of yytoken.
1305 : One alternative is translating here after every semantic action,
1306 : but that translation would be missed if the semantic action invokes
1307 : YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1308 : if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
1309 : incorrect destructor might then be invoked immediately. In the
1310 : case of YYERROR or YYBACKUP, subsequent parser actions might lead
1311 : to an incorrect destructor call or verbose syntax error message
1312 : before the lookahead is translated. */
1313 : YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1314 :
1315 236 : YYPOPSTACK (yylen);
1316 236 : yylen = 0;
1317 : YY_STACK_PRINT (yyss, yyssp);
1318 :
1319 236 : *++yyvsp = yyval;
1320 :
1321 : /* Now 'shift' the result of the reduction. Determine what state
1322 : that goes to, based on the state we popped back to and the rule
1323 : number reduced by. */
1324 :
1325 236 : yyn = yyr1[yyn];
1326 :
1327 236 : yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1328 236 : if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1329 90 : yystate = yytable[yystate];
1330 : else
1331 146 : yystate = yydefgoto[yyn - YYNTOKENS];
1332 :
1333 236 : goto yynewstate;
1334 :
1335 :
1336 : /*--------------------------------------.
1337 : | yyerrlab -- here on detecting error. |
1338 : `--------------------------------------*/
1339 0 : yyerrlab:
1340 : /* Make sure we have latest lookahead translation. See comments at
1341 : user semantic actions for why this is necessary. */
1342 0 : yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
1343 :
1344 : /* If not already recovering from an error, report this error. */
1345 0 : if (!yyerrstatus)
1346 : {
1347 0 : ++yynerrs;
1348 : #if ! YYERROR_VERBOSE
1349 0 : yyerror (YY_("syntax error"));
1350 : #else
1351 : # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
1352 : yyssp, yytoken)
1353 : {
1354 : char const *yymsgp = YY_("syntax error");
1355 : int yysyntax_error_status;
1356 : yysyntax_error_status = YYSYNTAX_ERROR;
1357 : if (yysyntax_error_status == 0)
1358 : yymsgp = yymsg;
1359 : else if (yysyntax_error_status == 1)
1360 : {
1361 : if (yymsg != yymsgbuf)
1362 : YYSTACK_FREE (yymsg);
1363 : yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
1364 : if (!yymsg)
1365 : {
1366 : yymsg = yymsgbuf;
1367 : yymsg_alloc = sizeof yymsgbuf;
1368 : yysyntax_error_status = 2;
1369 : }
1370 : else
1371 : {
1372 : yysyntax_error_status = YYSYNTAX_ERROR;
1373 : yymsgp = yymsg;
1374 : }
1375 : }
1376 : yyerror (yymsgp);
1377 : if (yysyntax_error_status == 2)
1378 : goto yyexhaustedlab;
1379 : }
1380 : # undef YYSYNTAX_ERROR
1381 : #endif
1382 : }
1383 :
1384 :
1385 :
1386 0 : if (yyerrstatus == 3)
1387 : {
1388 : /* If just tried and failed to reuse lookahead token after an
1389 : error, discard it. */
1390 :
1391 0 : if (yychar <= YYEOF)
1392 : {
1393 : /* Return failure if at end of input. */
1394 0 : if (yychar == YYEOF)
1395 0 : YYABORT;
1396 : }
1397 : else
1398 : {
1399 0 : yydestruct ("Error: discarding",
1400 : yytoken, &yylval);
1401 0 : yychar = YYEMPTY;
1402 : }
1403 : }
1404 :
1405 : /* Else will try to reuse lookahead token after shifting the error
1406 : token. */
1407 0 : goto yyerrlab1;
1408 :
1409 :
1410 : /*---------------------------------------------------.
1411 : | yyerrorlab -- error raised explicitly by YYERROR. |
1412 : `---------------------------------------------------*/
1413 : yyerrorlab:
1414 :
1415 : /* Pacify compilers like GCC when the user code never invokes
1416 : YYERROR and the label yyerrorlab therefore never appears in user
1417 : code. */
1418 : if (/*CONSTCOND*/ 0)
1419 : goto yyerrorlab;
1420 :
1421 : /* Do not reclaim the symbols of the rule whose action triggered
1422 : this YYERROR. */
1423 : YYPOPSTACK (yylen);
1424 : yylen = 0;
1425 : YY_STACK_PRINT (yyss, yyssp);
1426 : yystate = *yyssp;
1427 : goto yyerrlab1;
1428 :
1429 :
1430 : /*-------------------------------------------------------------.
1431 : | yyerrlab1 -- common code for both syntax error and YYERROR. |
1432 : `-------------------------------------------------------------*/
1433 0 : yyerrlab1:
1434 0 : yyerrstatus = 3; /* Each real token shifted decrements this. */
1435 :
1436 : for (;;)
1437 : {
1438 0 : yyn = yypact[yystate];
1439 0 : if (!yypact_value_is_default (yyn))
1440 : {
1441 0 : yyn += YYTERROR;
1442 0 : if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1443 : {
1444 0 : yyn = yytable[yyn];
1445 0 : if (0 < yyn)
1446 0 : break;
1447 : }
1448 : }
1449 :
1450 : /* Pop the current state because it cannot handle the error token. */
1451 0 : if (yyssp == yyss)
1452 0 : YYABORT;
1453 :
1454 :
1455 0 : yydestruct ("Error: popping",
1456 0 : yystos[yystate], yyvsp);
1457 0 : YYPOPSTACK (1);
1458 0 : yystate = *yyssp;
1459 : YY_STACK_PRINT (yyss, yyssp);
1460 : }
1461 :
1462 : YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1463 0 : *++yyvsp = yylval;
1464 : YY_IGNORE_MAYBE_UNINITIALIZED_END
1465 :
1466 :
1467 : /* Shift the error token. */
1468 : YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1469 :
1470 0 : yystate = yyn;
1471 0 : goto yynewstate;
1472 :
1473 :
1474 : /*-------------------------------------.
1475 : | yyacceptlab -- YYACCEPT comes here. |
1476 : `-------------------------------------*/
1477 14 : yyacceptlab:
1478 14 : yyresult = 0;
1479 14 : goto yyreturn;
1480 :
1481 : /*-----------------------------------.
1482 : | yyabortlab -- YYABORT comes here. |
1483 : `-----------------------------------*/
1484 0 : yyabortlab:
1485 0 : yyresult = 1;
1486 0 : goto yyreturn;
1487 :
1488 : #if !defined yyoverflow || YYERROR_VERBOSE
1489 : /*-------------------------------------------------.
1490 : | yyexhaustedlab -- memory exhaustion comes here. |
1491 : `-------------------------------------------------*/
1492 0 : yyexhaustedlab:
1493 0 : yyerror (YY_("memory exhausted"));
1494 0 : yyresult = 2;
1495 : /* Fall through. */
1496 : #endif
1497 :
1498 14 : yyreturn:
1499 14 : if (yychar != YYEMPTY)
1500 : {
1501 : /* Make sure we have latest lookahead translation. See comments at
1502 : user semantic actions for why this is necessary. */
1503 0 : yytoken = YYTRANSLATE (yychar);
1504 0 : yydestruct ("Cleanup: discarding lookahead",
1505 : yytoken, &yylval);
1506 : }
1507 : /* Do not reclaim the symbols of the rule whose action triggered
1508 : this YYABORT or YYACCEPT. */
1509 14 : YYPOPSTACK (yylen);
1510 : YY_STACK_PRINT (yyss, yyssp);
1511 42 : while (yyssp != yyss)
1512 : {
1513 28 : yydestruct ("Cleanup: popping",
1514 28 : yystos[*yyssp], yyvsp);
1515 28 : YYPOPSTACK (1);
1516 : }
1517 : #ifndef yyoverflow
1518 14 : if (yyss != yyssa)
1519 0 : YYSTACK_FREE (yyss);
1520 : #endif
1521 : #if YYERROR_VERBOSE
1522 : if (yymsg != yymsgbuf)
1523 : YYSTACK_FREE (yymsg);
1524 : #endif
1525 14 : return yyresult;
1526 : }
1527 : #line 97 "CalLibrary/CalLibraryGram.yy" /* yacc.c:1906 */
1528 :
1529 :
1530 :
|
