c453b6ec95859d3b02a24c320f6deef77d54f9e1
[occt.git] / src / ExprIntrp / ExprIntrp.tab.c
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.  */
72
73
74 #include <ExprIntrp_yaccintrf.hxx>
75
76 extern void ExprIntrp_EndOfFuncDef();
77 extern void ExprIntrp_EndOfRelation();
78 extern void ExprIntrp_AssignVariable();
79 extern void ExprIntrp_EndOfAssign();
80 extern void ExprIntrp_Deassign();
81 extern void ExprIntrp_SumOperator();
82 extern void ExprIntrp_MinusOperator();
83 extern void ExprIntrp_ProductOperator();
84 extern void ExprIntrp_DivideOperator();
85 extern void ExprIntrp_ExpOperator();
86 extern void ExprIntrp_UnaryMinusOperator();
87 extern void ExprIntrp_UnaryPlusOperator();
88 extern void ExprIntrp_VariableIdentifier();
89 extern void ExprIntrp_NumValue();
90 extern void ExprIntrp_EndFunction();
91 extern void ExprIntrp_EndDerFunction();
92 extern void ExprIntrp_EndDifferential();
93 extern void ExprIntrp_EndDiffFunction();
94 extern void ExprIntrp_EndFuncArg();
95 extern void ExprIntrp_NextFuncArg();
96 extern void ExprIntrp_StartFunction();
97 extern void ExprIntrp_DefineFunction();
98 extern void ExprIntrp_StartDerivate();
99 extern void ExprIntrp_EndDerivate();
100 extern void ExprIntrp_DiffVar();
101 extern void ExprIntrp_DiffDegree();
102 extern void ExprIntrp_VerDiffDegree();
103 extern void ExprIntrp_DiffDegreeVar();
104 extern void ExprIntrp_StartDifferential();
105 extern void ExprIntrp_StartFunction();
106 extern void ExprIntrp_EndFuncArg();
107 extern void ExprIntrp_NextFuncArg();
108 extern void ExprIntrp_VariableIdentifier();
109 extern void ExprIntrp_Derivation();
110 extern void ExprIntrp_EndDerivation();
111 extern void ExprIntrp_DerivationValue();
112 extern void ExprIntrp_ConstantIdentifier();
113 extern void ExprIntrp_ConstantDefinition();
114 extern void ExprIntrp_VariableIdentifier();
115 extern void ExprIntrp_NumValue();
116 extern void ExprIntrp_Sumator();
117 extern void ExprIntrp_VariableIdentifier();
118 extern void ExprIntrp_Productor();
119 extern 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
126
127
128
129
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".  */
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
151 /* Enabling traces.  */
152 #ifndef YYDEBUG
153 # define YYDEBUG 0
154 #endif
155 #if YYDEBUG
156 extern 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
192 typedef 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
198 extern YYSTYPE ExprIntrplval;
199
200 #ifdef YYPARSE_PARAM
201 #if defined __STDC__ || defined __cplusplus
202 int ExprIntrpparse (void *YYPARSE_PARAM);
203 #else
204 int ExprIntrpparse ();
205 #endif
206 #else /* ! YYPARSE_PARAM */
207 #if defined __STDC__ || defined __cplusplus
208 int ExprIntrpparse (void);
209 #else
210 int ExprIntrpparse ();
211 #endif
212 #endif /* ! YYPARSE_PARAM */
213
214 #endif /* !YY_EXPRINTRP_D_ABV_OCCT_OCCT_SRC_EXPRINTRP_EXPRINTRP_TAB_H_INCLUDED  */
215
216 /* Copy the second part of user declarations.  */
217
218
219
220 #ifdef short
221 # undef short
222 #endif
223
224 #ifdef YYTYPE_UINT8
225 typedef YYTYPE_UINT8 yytype_uint8;
226 #else
227 typedef unsigned char yytype_uint8;
228 #endif
229
230 #ifdef YYTYPE_INT8
231 typedef YYTYPE_INT8 yytype_int8;
232 #elif (defined __STDC__ || defined __C99__FUNC__ \
233      || defined __cplusplus || defined _MSC_VER)
234 typedef signed char yytype_int8;
235 #else
236 typedef short int yytype_int8;
237 #endif
238
239 #ifdef YYTYPE_UINT16
240 typedef YYTYPE_UINT16 yytype_uint16;
241 #else
242 typedef unsigned short int yytype_uint16;
243 #endif
244
245 #ifdef YYTYPE_INT16
246 typedef YYTYPE_INT16 yytype_int16;
247 #else
248 typedef 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)
292 static int
293 YYID (int yyi)
294 #else
295 static int
296 YYID (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)
361 void *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)
368 void 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.  */
380 union 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.  */
457 static 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.  */
492 static 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.  */
505 static 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.  */
534 static 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.  */
550 static 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.  */
570 static 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.  */
579 static 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.  */
592 static 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.  */
607 static 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].  */
627 static 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
639 static 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].  */
659 static 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
672 static 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
701 static 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.  */
726 static 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)                                  \
773 do                                                              \
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     }                                                           \
787 while (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)                        \
816 do {                                            \
817   if (yydebug)                                  \
818     YYFPRINTF Args;                             \
819 } while (YYID (0))
820
821 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
822 do {                                                                      \
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)
840 static void
841 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
842 #else
843 static void
844 yy_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)
874 static void
875 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
876 #else
877 static void
878 yy_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)
900 static void
901 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
902 #else
903 static void
904 yy_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)                            \
919 do {                                                            \
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)
931 static void
932 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
933 #else
934 static void
935 yy_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)          \
957 do {                                    \
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.  */
964 int 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)
999 static YYSIZE_T
1000 yystrlen (const char *yystr)
1001 #else
1002 static YYSIZE_T
1003 yystrlen (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)
1023 static char *
1024 yystpcpy (char *yydest, const char *yysrc)
1025 #else
1026 static char *
1027 yystpcpy (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.  */
1051 static YYSIZE_T
1052 yytnamerr (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.  */
1099 static int
1100 yysyntax_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)
1238 static void
1239 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1240 #else
1241 static void
1242 yydestruct (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.  */
1266 int 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.  */
1278 YYSTYPE yylval YY_INITIAL_VALUE(yyval_default);
1279
1280 /* Number of syntax errors so far.  */
1281 int 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)
1291 int
1292 yyparse (void *YYPARSE_PARAM)
1293 #else
1294 int
1295 yyparse (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)
1301 int
1302 yyparse (void)
1303 #else
1304 int
1305 yyparse ()
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 `-----------*/
1448 yybackup:
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 `-----------------------------------------------------------*/
1514 yydefault:
1515   yyn = yydefact[yystate];
1516   if (yyn == 0)
1517     goto yyerrlab;
1518   goto yyreduce;
1519
1520
1521 /*-----------------------------.
1522 | yyreduce -- Do a reduction.  |
1523 `-----------------------------*/
1524 yyreduce:
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:
1543
1544     {ExprIntrp_EndOfFuncDef();}
1545     break;
1546
1547   case 6:
1548
1549     {ExprIntrp_EndOfRelation();}
1550     break;
1551
1552   case 7:
1553
1554     {ExprIntrp_AssignVariable();}
1555     break;
1556
1557   case 8:
1558
1559     {ExprIntrp_EndOfAssign();}
1560     break;
1561
1562   case 9:
1563
1564     {ExprIntrp_Deassign();}
1565     break;
1566
1567   case 11:
1568
1569     {ExprIntrp_SumOperator();}
1570     break;
1571
1572   case 12:
1573
1574     {ExprIntrp_MinusOperator();}
1575     break;
1576
1577   case 13:
1578
1579     {ExprIntrp_ProductOperator();}
1580     break;
1581
1582   case 14:
1583
1584     {ExprIntrp_DivideOperator();}
1585     break;
1586
1587   case 15:
1588
1589     {ExprIntrp_ExpOperator();}
1590     break;
1591
1592   case 18:
1593
1594     {ExprIntrp_UnaryMinusOperator();}
1595     break;
1596
1597   case 19:
1598
1599     {ExprIntrp_UnaryPlusOperator();}
1600     break;
1601
1602   case 27:
1603
1604     {ExprIntrp_VariableIdentifier();}
1605     break;
1606
1607   case 28:
1608
1609     {ExprIntrp_NumValue();}
1610     break;
1611
1612   case 29:
1613
1614     {ExprIntrp_EndFunction();}
1615     break;
1616
1617   case 30:
1618
1619     {ExprIntrp_EndDerFunction();}
1620     break;
1621
1622   case 31:
1623
1624     {ExprIntrp_EndDifferential();}
1625     break;
1626
1627   case 32:
1628
1629     {ExprIntrp_EndDiffFunction();}
1630     break;
1631
1632   case 33:
1633
1634     {ExprIntrp_EndFuncArg();}
1635     break;
1636
1637   case 34:
1638
1639     {ExprIntrp_NextFuncArg();}
1640     break;
1641
1642   case 36:
1643
1644     {ExprIntrp_StartFunction();}
1645     break;
1646
1647   case 37:
1648
1649     {ExprIntrp_DefineFunction();}
1650     break;
1651
1652   case 39:
1653
1654     {ExprIntrp_StartDerivate();}
1655     break;
1656
1657   case 40:
1658
1659     {ExprIntrp_EndDerivate();}
1660     break;
1661
1662   case 41:
1663
1664     {ExprIntrp_DiffVar();}
1665     break;
1666
1667   case 42:
1668
1669     {ExprIntrp_DiffDegree();}
1670     break;
1671
1672   case 43:
1673
1674     {ExprIntrp_VerDiffDegree();}
1675     break;
1676
1677   case 44:
1678
1679     {ExprIntrp_DiffDegreeVar();}
1680     break;
1681
1682   case 45:
1683
1684     {ExprIntrp_StartDifferential();}
1685     break;
1686
1687   case 47:
1688
1689     {ExprIntrp_StartFunction();}
1690     break;
1691
1692   case 49:
1693
1694     {ExprIntrp_EndFuncArg();}
1695     break;
1696
1697   case 50:
1698
1699     {ExprIntrp_NextFuncArg();}
1700     break;
1701
1702   case 52:
1703
1704     {ExprIntrp_VariableIdentifier();}
1705     break;
1706
1707   case 53:
1708
1709     {ExprIntrp_Derivation();}
1710     break;
1711
1712   case 54:
1713
1714     {ExprIntrp_EndDerivation();}
1715     break;
1716
1717   case 55:
1718
1719     {ExprIntrp_Derivation();}
1720     break;
1721
1722   case 56:
1723
1724     {ExprIntrp_DerivationValue();}
1725     break;
1726
1727   case 57:
1728
1729     {ExprIntrp_EndDerivation();}
1730     break;
1731
1732   case 58:
1733
1734     {ExprIntrp_ConstantIdentifier();}
1735     break;
1736
1737   case 59:
1738
1739     {ExprIntrp_ConstantDefinition();}
1740     break;
1741
1742   case 61:
1743
1744     {ExprIntrp_VariableIdentifier();}
1745     break;
1746
1747   case 62:
1748
1749     {ExprIntrp_NumValue();}
1750     break;
1751
1752   case 63:
1753
1754     {ExprIntrp_Sumator();}
1755     break;
1756
1757   case 64:
1758
1759     {ExprIntrp_VariableIdentifier();}
1760     break;
1761
1762   case 65:
1763
1764     {ExprIntrp_NumValue();}
1765     break;
1766
1767   case 66:
1768
1769     {ExprIntrp_Productor();}
1770     break;
1771
1772   case 70:
1773
1774     {ExprIntrp_EndOfEqual();}
1775     break;
1776
1777
1778
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 `------------------------------------*/
1818 yyerrlab:
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 `---------------------------------------------------*/
1892 yyerrorlab:
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 `-------------------------------------------------------------*/
1912 yyerrlab1:
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 `-------------------------------------*/
1956 yyacceptlab:
1957   yyresult = 0;
1958   goto yyreturn;
1959
1960 /*-----------------------------------.
1961 | yyabortlab -- YYABORT comes here.  |
1962 `-----------------------------------*/
1963 yyabortlab:
1964   yyresult = 1;
1965   goto yyreturn;
1966
1967 #if !defined yyoverflow || YYERROR_VERBOSE
1968 /*-------------------------------------------------.
1969 | yyexhaustedlab -- memory exhaustion comes here.  |
1970 `-------------------------------------------------*/
1971 yyexhaustedlab:
1972   yyerror (YY_("memory exhausted"));
1973   yyresult = 2;
1974   /* Fall through.  */
1975 #endif
1976
1977 yyreturn:
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