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