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