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