1 /* A Bison parser, made by GNU Bison 3.7.4. */
2
3 /* Bison implementation for Yacc-like parsers in C
4
5 Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation,
6 Inc.
7
8 This program is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20
21 /* As a special exception, you may create a larger work that contains
22 part or all of the Bison parser skeleton and distribute that work
23 under terms of your choice, so long as that work isn't itself a
24 parser generator using the skeleton or a modified version thereof
25 as a parser skeleton. Alternatively, if you modify or redistribute
26 the parser skeleton itself, you may (at your option) remove this
27 special exception, which will cause the skeleton and the resulting
28 Bison output files to be licensed under the GNU General Public
29 License without this special exception.
30
31 This special exception was added by the Free Software Foundation in
32 version 2.2 of Bison. */
33
34 /* C LALR(1) parser skeleton written by Richard Stallman, by
35 simplifying the original so-called "semantic" parser. */
36
37 /* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
38 especially those whose name start with YY_ or yy_. They are
39 private implementation details that can be changed or removed. */
40
41 /* All symbols defined below should begin with yy or YY, to avoid
42 infringing on user name space. This should be done even for local
43 variables, as they might otherwise be expanded by user macros.
44 There are some unavoidable exceptions within include files to
45 define necessary library symbols; they are noted "INFRINGES ON
46 USER NAME SPACE" below. */
47
48 /* Identify Bison output, and Bison version. */
49 #define YYBISON 30704
50
51 /* Bison version string. */
52 #define YYBISON_VERSION "3.7.4"
53
54 /* Skeleton name. */
55 #define YYSKELETON_NAME "yacc.c"
56
57 /* Pure parsers. */
58 #define YYPURE 0
59
60 /* Push parsers. */
61 #define YYPUSH 0
62
63 /* Pull parsers. */
64 #define YYPULL 1
65
66
67 /* Substitute the variable and function names. */
68 #define yyparse ExprIntrpparse
69 #define yylex ExprIntrplex
70 #define yyerror ExprIntrperror
71 #define yydebug ExprIntrpdebug
72 #define yynerrs ExprIntrpnerrs
73 #define yylval ExprIntrplval
74 #define yychar ExprIntrpchar
75
76 /* First part of user prologue. */
77
78 #include <ExprIntrp_yaccintrf.hxx>
79
80 extern void ExprIntrp_EndOfFuncDef();
81 extern void ExprIntrp_EndOfRelation();
82 extern void ExprIntrp_AssignVariable();
83 extern void ExprIntrp_EndOfAssign();
84 extern void ExprIntrp_Deassign();
85 extern void ExprIntrp_SumOperator();
86 extern void ExprIntrp_MinusOperator();
87 extern void ExprIntrp_ProductOperator();
88 extern void ExprIntrp_DivideOperator();
89 extern void ExprIntrp_ExpOperator();
90 extern void ExprIntrp_UnaryMinusOperator();
91 extern void ExprIntrp_UnaryPlusOperator();
92 extern void ExprIntrp_VariableIdentifier();
93 extern void ExprIntrp_NumValue();
94 extern void ExprIntrp_EndFunction();
95 extern void ExprIntrp_EndDerFunction();
96 extern void ExprIntrp_EndDifferential();
97 extern void ExprIntrp_EndDiffFunction();
98 extern void ExprIntrp_EndFuncArg();
99 extern void ExprIntrp_NextFuncArg();
100 extern void ExprIntrp_StartFunction();
101 extern void ExprIntrp_DefineFunction();
102 extern void ExprIntrp_StartDerivate();
103 extern void ExprIntrp_EndDerivate();
104 extern void ExprIntrp_DiffVar();
105 extern void ExprIntrp_DiffDegree();
106 extern void ExprIntrp_VerDiffDegree();
107 extern void ExprIntrp_DiffDegreeVar();
108 extern void ExprIntrp_StartDifferential();
109 extern void ExprIntrp_StartFunction();
110 extern void ExprIntrp_EndFuncArg();
111 extern void ExprIntrp_NextFuncArg();
112 extern void ExprIntrp_VariableIdentifier();
113 extern void ExprIntrp_Derivation();
114 extern void ExprIntrp_EndDerivation();
115 extern void ExprIntrp_DerivationValue();
116 extern void ExprIntrp_ConstantIdentifier();
117 extern void ExprIntrp_ConstantDefinition();
118 extern void ExprIntrp_VariableIdentifier();
119 extern void ExprIntrp_NumValue();
120 extern void ExprIntrp_Sumator();
121 extern void ExprIntrp_VariableIdentifier();
122 extern void ExprIntrp_Productor();
123 extern void ExprIntrp_EndOfEqual();
124
125 // disable MSVC warnings in bison code
126 #ifdef _MSC_VER
127 #pragma warning(disable:4131 4244 4127 4702)
128 #endif
129
130
131
132
133 # ifndef YY_CAST
134 # ifdef __cplusplus
135 # define YY_CAST(Type, Val) static_cast<Type> (Val)
136 # define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
137 # else
138 # define YY_CAST(Type, Val) ((Type) (Val))
139 # define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
140 # endif
141 # endif
142 # ifndef YY_NULLPTR
143 # if defined __cplusplus
144 # if 201103L <= __cplusplus
145 # define YY_NULLPTR nullptr
146 # else
147 # define YY_NULLPTR 0
148 # endif
149 # else
150 # define YY_NULLPTR ((void*)0)
151 # endif
152 # endif
153
154 #include "ExprIntrp.tab.h"
155 /* Symbol kind. */
156 enum yysymbol_kind_t
157 {
158 YYSYMBOL_YYEMPTY = -2,
159 YYSYMBOL_YYEOF = 0, /* "end of file" */
160 YYSYMBOL_YYerror = 1, /* error */
161 YYSYMBOL_YYUNDEF = 2, /* "invalid token" */
162 YYSYMBOL_SUMOP = 3, /* SUMOP */
163 YYSYMBOL_MINUSOP = 4, /* MINUSOP */
164 YYSYMBOL_DIVIDEOP = 5, /* DIVIDEOP */
165 YYSYMBOL_EXPOP = 6, /* EXPOP */
166 YYSYMBOL_MULTOP = 7, /* MULTOP */
167 YYSYMBOL_PARENTHESIS = 8, /* PARENTHESIS */
168 YYSYMBOL_BRACKET = 9, /* BRACKET */
169 YYSYMBOL_ENDPARENTHESIS = 10, /* ENDPARENTHESIS */
170 YYSYMBOL_ENDBRACKET = 11, /* ENDBRACKET */
171 YYSYMBOL_VALUE = 12, /* VALUE */
172 YYSYMBOL_IDENTIFIER = 13, /* IDENTIFIER */
173 YYSYMBOL_COMMA = 14, /* COMMA */
174 YYSYMBOL_DIFFERENTIAL = 15, /* DIFFERENTIAL */
175 YYSYMBOL_DERIVATE = 16, /* DERIVATE */
176 YYSYMBOL_DERIVKEY = 17, /* DERIVKEY */
177 YYSYMBOL_ASSIGNOP = 18, /* ASSIGNOP */
178 YYSYMBOL_DEASSIGNKEY = 19, /* DEASSIGNKEY */
179 YYSYMBOL_EQUALOP = 20, /* EQUALOP */
180 YYSYMBOL_RELSEPARATOR = 21, /* RELSEPARATOR */
181 YYSYMBOL_CONSTKEY = 22, /* CONSTKEY */
182 YYSYMBOL_SUMKEY = 23, /* SUMKEY */
183 YYSYMBOL_PRODKEY = 24, /* PRODKEY */
184 YYSYMBOL_25_n_ = 25, /* '\n' */
185 YYSYMBOL_YYACCEPT = 26, /* $accept */
186 YYSYMBOL_exprentry = 27, /* exprentry */
187 YYSYMBOL_Assignment = 28, /* Assignment */
188 YYSYMBOL_29_1 = 29, /* $@1 */
189 YYSYMBOL_Deassignment = 30, /* Deassignment */
190 YYSYMBOL_31_2 = 31, /* $@2 */
191 YYSYMBOL_GenExpr = 32, /* GenExpr */
192 YYSYMBOL_SingleExpr = 33, /* SingleExpr */
193 YYSYMBOL_Single = 34, /* Single */
194 YYSYMBOL_Function = 35, /* Function */
195 YYSYMBOL_36_3 = 36, /* $@3 */
196 YYSYMBOL_ListGenExpr = 37, /* ListGenExpr */
197 YYSYMBOL_38_4 = 38, /* $@4 */
198 YYSYMBOL_funcident = 39, /* funcident */
199 YYSYMBOL_FunctionDefinition = 40, /* FunctionDefinition */
200 YYSYMBOL_41_5 = 41, /* $@5 */
201 YYSYMBOL_DerFunctionId = 42, /* DerFunctionId */
202 YYSYMBOL_43_6 = 43, /* $@6 */
203 YYSYMBOL_DiffFuncId = 44, /* DiffFuncId */
204 YYSYMBOL_45_7 = 45, /* $@7 */
205 YYSYMBOL_46_8 = 46, /* $@8 */
206 YYSYMBOL_DiffId = 47, /* DiffId */
207 YYSYMBOL_FunctionDef = 48, /* FunctionDef */
208 YYSYMBOL_49_9 = 49, /* $@9 */
209 YYSYMBOL_ListArg = 50, /* ListArg */
210 YYSYMBOL_51_10 = 51, /* $@10 */
211 YYSYMBOL_unarg = 52, /* unarg */
212 YYSYMBOL_Derivation = 53, /* Derivation */
213 YYSYMBOL_54_11 = 54, /* $@11 */
214 YYSYMBOL_55_12 = 55, /* $@12 */
215 YYSYMBOL_56_13 = 56, /* $@13 */
216 YYSYMBOL_ConstantDefinition = 57, /* ConstantDefinition */
217 YYSYMBOL_58_14 = 58, /* $@14 */
218 YYSYMBOL_59_15 = 59, /* $@15 */
219 YYSYMBOL_Sumator = 60, /* Sumator */
220 YYSYMBOL_61_16 = 61, /* $@16 */
221 YYSYMBOL_62_17 = 62, /* $@17 */
222 YYSYMBOL_Productor = 63, /* Productor */
223 YYSYMBOL_64_18 = 64, /* $@18 */
224 YYSYMBOL_65_19 = 65, /* $@19 */
225 YYSYMBOL_RelationList = 66, /* RelationList */
226 YYSYMBOL_SingleRelation = 67 /* SingleRelation */
227 };
228 typedef enum yysymbol_kind_t yysymbol_kind_t;
229
230
231
232
233 #ifdef short
234 # undef short
235 #endif
236
237 /* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
238 <limits.h> and (if available) <stdint.h> are included
239 so that the code can choose integer types of a good width. */
240
241 #ifndef __PTRDIFF_MAX__
242 # include <limits.h> /* INFRINGES ON USER NAME SPACE */
243 # if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
244 # include <stdint.h> /* INFRINGES ON USER NAME SPACE */
245 # define YY_STDINT_H
246 # endif
247 #endif
248
249 /* Narrow types that promote to a signed type and that can represent a
250 signed or unsigned integer of at least N bits. In tables they can
251 save space and decrease cache pressure. Promoting to a signed type
252 helps avoid bugs in integer arithmetic. */
253
254 #ifdef __INT_LEAST8_MAX__
255 typedef __INT_LEAST8_TYPE__ yytype_int8;
256 #elif defined YY_STDINT_H
257 typedef int_least8_t yytype_int8;
258 #else
259 typedef signed char yytype_int8;
260 #endif
261
262 #ifdef __INT_LEAST16_MAX__
263 typedef __INT_LEAST16_TYPE__ yytype_int16;
264 #elif defined YY_STDINT_H
265 typedef int_least16_t yytype_int16;
266 #else
267 typedef short yytype_int16;
268 #endif
269
270 #if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
271 typedef __UINT_LEAST8_TYPE__ yytype_uint8;
272 #elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
273 && UINT_LEAST8_MAX <= INT_MAX)
274 typedef uint_least8_t yytype_uint8;
275 #elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
276 typedef unsigned char yytype_uint8;
277 #else
278 typedef short yytype_uint8;
279 #endif
280
281 #if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
282 typedef __UINT_LEAST16_TYPE__ yytype_uint16;
283 #elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
284 && UINT_LEAST16_MAX <= INT_MAX)
285 typedef uint_least16_t yytype_uint16;
286 #elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
287 typedef unsigned short yytype_uint16;
288 #else
289 typedef int yytype_uint16;
290 #endif
291
292 #ifndef YYPTRDIFF_T
293 # if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
294 # define YYPTRDIFF_T __PTRDIFF_TYPE__
295 # define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
296 # elif defined PTRDIFF_MAX
297 # ifndef ptrdiff_t
298 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
299 # endif
300 # define YYPTRDIFF_T ptrdiff_t
301 # define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
302 # else
303 # define YYPTRDIFF_T long
304 # define YYPTRDIFF_MAXIMUM LONG_MAX
305 # endif
306 #endif
307
308 #ifndef YYSIZE_T
309 # ifdef __SIZE_TYPE__
310 # define YYSIZE_T __SIZE_TYPE__
311 # elif defined size_t
312 # define YYSIZE_T size_t
313 # elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
314 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
315 # define YYSIZE_T size_t
316 # else
317 # define YYSIZE_T unsigned
318 # endif
319 #endif
320
321 #define YYSIZE_MAXIMUM \
322 YY_CAST (YYPTRDIFF_T, \
323 (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
324 ? YYPTRDIFF_MAXIMUM \
325 : YY_CAST (YYSIZE_T, -1)))
326
327 #define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
328
329
330 /* Stored state numbers (used for stacks). */
331 typedef yytype_uint8 yy_state_t;
332
333 /* State numbers in computations. */
334 typedef int yy_state_fast_t;
335
336 #ifndef YY_
337 # if defined YYENABLE_NLS && YYENABLE_NLS
338 # if ENABLE_NLS
339 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
340 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
341 # endif
342 # endif
343 # ifndef YY_
344 # define YY_(Msgid) Msgid
345 # endif
346 #endif
347
348
349 #ifndef YY_ATTRIBUTE_PURE
350 # if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
351 # define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
352 # else
353 # define YY_ATTRIBUTE_PURE
354 # endif
355 #endif
356
357 #ifndef YY_ATTRIBUTE_UNUSED
358 # if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
359 # define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
360 # else
361 # define YY_ATTRIBUTE_UNUSED
362 # endif
363 #endif
364
365 /* Suppress unused-variable warnings by "using" E. */
366 #if ! defined lint || defined __GNUC__
367 # define YYUSE(E) ((void) (E))
368 #else
369 # define YYUSE(E) /* empty */
370 #endif
371
372 #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
373 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
374 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
375 _Pragma ("GCC diagnostic push") \
376 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
377 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
378 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
379 _Pragma ("GCC diagnostic pop")
380 #else
381 # define YY_INITIAL_VALUE(Value) Value
382 #endif
383 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
384 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
385 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
386 #endif
387 #ifndef YY_INITIAL_VALUE
388 # define YY_INITIAL_VALUE(Value) /* Nothing. */
389 #endif
390
391 #if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
392 # define YY_IGNORE_USELESS_CAST_BEGIN \
393 _Pragma ("GCC diagnostic push") \
394 _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
395 # define YY_IGNORE_USELESS_CAST_END \
396 _Pragma ("GCC diagnostic pop")
397 #endif
398 #ifndef YY_IGNORE_USELESS_CAST_BEGIN
399 # define YY_IGNORE_USELESS_CAST_BEGIN
400 # define YY_IGNORE_USELESS_CAST_END
401 #endif
402
403
404 #define YY_ASSERT(E) ((void) (0 && (E)))
405
406 #if !defined yyoverflow
407
408 /* The parser invokes alloca or malloc; define the necessary symbols. */
409
410 # ifdef YYSTACK_USE_ALLOCA
411 # if YYSTACK_USE_ALLOCA
412 # ifdef __GNUC__
413 # define YYSTACK_ALLOC __builtin_alloca
414 # elif defined __BUILTIN_VA_ARG_INCR
415 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
416 # elif defined _AIX
417 # define YYSTACK_ALLOC __alloca
418 # elif defined _MSC_VER
419 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
420 # define alloca _alloca
421 # else
422 # define YYSTACK_ALLOC alloca
423 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
424 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
425 /* Use EXIT_SUCCESS as a witness for stdlib.h. */
426 # ifndef EXIT_SUCCESS
427 # define EXIT_SUCCESS 0
428 # endif
429 # endif
430 # endif
431 # endif
432 # endif
433
434 # ifdef YYSTACK_ALLOC
435 /* Pacify GCC's 'empty if-body' warning. */
436 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
437 # ifndef YYSTACK_ALLOC_MAXIMUM
438 /* The OS might guarantee only one guard page at the bottom of the stack,
439 and a page size can be as small as 4096 bytes. So we cannot safely
440 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
441 to allow for a few compiler-allocated temporary stack slots. */
442 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
443 # endif
444 # else
445 # define YYSTACK_ALLOC YYMALLOC
446 # define YYSTACK_FREE YYFREE
447 # ifndef YYSTACK_ALLOC_MAXIMUM
448 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
449 # endif
450 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
451 && ! ((defined YYMALLOC || defined malloc) \
452 && (defined YYFREE || defined free)))
453 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
454 # ifndef EXIT_SUCCESS
455 # define EXIT_SUCCESS 0
456 # endif
457 # endif
458 # ifndef YYMALLOC
459 # define YYMALLOC malloc
460 # if ! defined malloc && ! defined EXIT_SUCCESS
461 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
462 # endif
463 # endif
464 # ifndef YYFREE
465 # define YYFREE free
466 # if ! defined free && ! defined EXIT_SUCCESS
467 void free (void *); /* INFRINGES ON USER NAME SPACE */
468 # endif
469 # endif
470 # endif
471 #endif /* !defined yyoverflow */
472
473 #if (! defined yyoverflow \
474 && (! defined __cplusplus \
475 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
476
477 /* A type that is properly aligned for any stack member. */
478 union yyalloc
479 {
480 yy_state_t yyss_alloc;
481 YYSTYPE yyvs_alloc;
482 };
483
484 /* The size of the maximum gap between one aligned stack and the next. */
485 # define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
486
487 /* The size of an array large to enough to hold all stacks, each with
488 N elements. */
489 # define YYSTACK_BYTES(N) \
490 ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
491 + YYSTACK_GAP_MAXIMUM)
492
493 # define YYCOPY_NEEDED 1
494
495 /* Relocate STACK from its old location to the new one. The
496 local variables YYSIZE and YYSTACKSIZE give the old and new number of
497 elements in the stack, and YYPTR gives the new location of the
498 stack. Advance YYPTR to a properly aligned location for the next
499 stack. */
500 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
501 do \
502 { \
503 YYPTRDIFF_T yynewbytes; \
504 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
505 Stack = &yyptr->Stack_alloc; \
506 yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
507 yyptr += yynewbytes / YYSIZEOF (*yyptr); \
508 } \
509 while (0)
510
511 #endif
512
513 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
514 /* Copy COUNT objects from SRC to DST. The source and destination do
515 not overlap. */
516 # ifndef YYCOPY
517 # if defined __GNUC__ && 1 < __GNUC__
518 # define YYCOPY(Dst, Src, Count) \
519 __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
520 # else
521 # define YYCOPY(Dst, Src, Count) \
522 do \
523 { \
524 YYPTRDIFF_T yyi; \
525 for (yyi = 0; yyi < (Count); yyi++) \
526 (Dst)[yyi] = (Src)[yyi]; \
527 } \
528 while (0)
529 # endif
530 # endif
531 #endif /* !YYCOPY_NEEDED */
532
533 /* YYFINAL -- State number of the termination state. */
534 #define YYFINAL 48
535 /* YYLAST -- Last index in YYTABLE. */
536 #define YYLAST 189
537
538 /* YYNTOKENS -- Number of terminals. */
539 #define YYNTOKENS 26
540 /* YYNNTS -- Number of nonterminals. */
541 #define YYNNTS 42
542 /* YYNRULES -- Number of rules. */
543 #define YYNRULES 70
544 /* YYNSTATES -- Number of states. */
545 #define YYNSTATES 149
546
547 /* YYMAXUTOK -- Last valid token kind. */
548 #define YYMAXUTOK 279
549
550
551 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
552 as returned by yylex, with out-of-bounds checking. */
553 #define YYTRANSLATE(YYX) \
554 (0 <= (YYX) && (YYX) <= YYMAXUTOK \
555 ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \
556 : YYSYMBOL_YYUNDEF)
557
558 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
559 as returned by yylex. */
560 static const yytype_int8 yytranslate[] =
561 {
562 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
563 25, 2, 2, 2, 2, 2, 2, 2, 2, 2,
564 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
565 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
566 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
567 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
568 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
569 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
570 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
571 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
572 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
573 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
574 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
575 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
576 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
577 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
578 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
579 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
580 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
581 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
582 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
583 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
584 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
585 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
586 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
587 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
588 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
589 15, 16, 17, 18, 19, 20, 21, 22, 23, 24
590 };
591
592 #if YYDEBUG
593 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
594 static const yytype_uint8 yyrline[] =
595 {
596 0, 80, 80, 81, 82, 83, 84, 87, 87, 90,
597 90, 93, 94, 95, 96, 97, 98, 99, 100, 101,
598 102, 103, 104, 105, 106, 109, 110, 114, 115, 118,
599 119, 120, 120, 123, 124, 124, 127, 130, 130, 133,
600 133, 136, 137, 137, 137, 140, 141, 144, 144, 147,
601 148, 148, 151, 154, 154, 155, 155, 155, 158, 158,
602 158, 161, 161, 161, 164, 164, 164, 167, 168, 169,
603 172
604 };
605 #endif
606
607 /** Accessing symbol of state STATE. */
608 #define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
609
610 #if YYDEBUG || 0
611 /* The user-facing name of the symbol whose (internal) number is
612 YYSYMBOL. No bounds checking. */
613 static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED;
614
615 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
616 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
617 static const char *const yytname[] =
618 {
619 "\"end of file\"", "error", "\"invalid token\"", "SUMOP", "MINUSOP",
620 "DIVIDEOP", "EXPOP", "MULTOP", "PARENTHESIS", "BRACKET",
621 "ENDPARENTHESIS", "ENDBRACKET", "VALUE", "IDENTIFIER", "COMMA",
622 "DIFFERENTIAL", "DERIVATE", "DERIVKEY", "ASSIGNOP", "DEASSIGNKEY",
623 "EQUALOP", "RELSEPARATOR", "CONSTKEY", "SUMKEY", "PRODKEY", "'\\n'",
624 "$accept", "exprentry", "Assignment", "$@1", "Deassignment", "$@2",
625 "GenExpr", "SingleExpr", "Single", "Function", "$@3", "ListGenExpr",
626 "$@4", "funcident", "FunctionDefinition", "$@5", "DerFunctionId", "$@6",
627 "DiffFuncId", "$@7", "$@8", "DiffId", "FunctionDef", "$@9", "ListArg",
628 "$@10", "unarg", "Derivation", "$@11", "$@12", "$@13",
629 "ConstantDefinition", "$@14", "$@15", "Sumator", "$@16", "$@17",
630 "Productor", "$@18", "$@19", "RelationList", "SingleRelation", YY_NULLPTR
631 };
632
633 static const char *
yysymbol_name(yysymbol_kind_t yysymbol)634 yysymbol_name (yysymbol_kind_t yysymbol)
635 {
636 return yytname[yysymbol];
637 }
638 #endif
639
640 #ifdef YYPRINT
641 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
642 (internal) symbol number NUM (which must be that of a token). */
643 static const yytype_int16 yytoknum[] =
644 {
645 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
646 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
647 275, 276, 277, 278, 279, 10
648 };
649 #endif
650
651 #define YYPACT_NINF (-51)
652
653 #define yypact_value_is_default(Yyn) \
654 ((Yyn) == YYPACT_NINF)
655
656 #define YYTABLE_NINF (-56)
657
658 #define yytable_value_is_error(Yyn) \
659 0
660
661 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
662 STATE-NUM. */
663 static const yytype_int16 yypact[] =
664 {
665 4, 62, 62, 62, 62, -51, 2, 87, 39, 58,
666 59, 60, 63, 9, -51, -51, 35, -51, -51, -51,
667 7, -51, 37, -51, -51, -51, -51, -51, -51, -51,
668 36, 6, 24, 24, 161, 152, 55, 64, 67, -51,
669 -51, -51, 73, 62, 68, 69, 62, 62, -51, 62,
670 62, 62, 62, 62, 62, 62, 62, 93, 79, 62,
671 62, -51, -51, 62, -51, 103, 43, 99, 30, -51,
672 -51, 84, 89, 24, 24, 111, -51, 111, 169, 101,
673 108, 109, 62, 62, 35, -51, -51, 169, -51, 115,
674 116, 124, 120, 121, 137, 117, 122, 138, -51, -51,
675 -51, 142, 169, -51, -51, 145, -51, 136, -51, 141,
676 -51, -51, 62, -51, 103, 149, 151, 155, -51, 156,
677 163, -51, -51, -51, -51, 166, 168, 62, 62, 167,
678 -51, -51, 106, 118, -51, 170, 62, 62, -51, 135,
679 140, 171, 172, -51, -51, 174, 175, -51, -51
680 };
681
682 /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
683 Performed when YYTABLE does not specify something else to do. Zero
684 means the default is an error. */
685 static const yytype_int8 yydefact[] =
686 {
687 0, 0, 0, 0, 0, 28, 27, 0, 0, 0,
688 0, 0, 0, 0, 3, 4, 2, 20, 25, 26,
689 0, 5, 0, 31, 37, 21, 22, 23, 24, 6,
690 67, 27, 19, 18, 0, 0, 0, 0, 0, 42,
691 45, 46, 0, 0, 0, 0, 0, 0, 1, 0,
692 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
693 0, 16, 17, 0, 40, 0, 0, 0, 0, 9,
694 58, 0, 0, 11, 12, 14, 15, 13, 70, 33,
695 0, 0, 0, 0, 0, 68, 69, 8, 52, 0,
696 49, 0, 0, 0, 0, 0, 0, 0, 34, 29,
697 30, 0, 38, 48, 50, 0, 41, 53, 10, 0,
698 61, 64, 0, 32, 0, 0, 0, 0, 59, 0,
699 0, 35, 51, 43, 54, 0, 0, 0, 0, 0,
700 56, 60, 0, 0, 44, 0, 0, 0, 57, 0,
701 0, 0, 0, 62, 65, 0, 0, 63, 66
702 };
703
704 /* YYPGOTO[NTERM-NUM]. */
705 static const yytype_int8 yypgoto[] =
706 {
707 -51, -51, -51, -51, -51, -51, 0, -51, -51, -51,
708 -51, -50, -51, -51, -51, -51, -51, -51, -2, -51,
709 -51, 123, -51, -51, 74, -51, -51, -51, -51, -51,
710 -51, -51, -51, -51, -51, -51, -51, -51, -51, -51,
711 -35, -51
712 };
713
714 /* YYDEFGOTO[NTERM-NUM]. */
715 static const yytype_int16 yydefgoto[] =
716 {
717 -1, 13, 14, 36, 15, 94, 79, 17, 18, 19,
718 57, 80, 112, 20, 21, 58, 22, 37, 23, 66,
719 129, 42, 24, 38, 89, 114, 90, 25, 116, 117,
720 135, 26, 95, 126, 27, 119, 145, 28, 120, 146,
721 29, 30
722 };
723
724 /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
725 positive, shift that token. If negative, reduce the rule whose
726 number is the opposite. If YYTABLE_NINF, syntax error. */
727 static const yytype_int16 yytable[] =
728 {
729 16, 32, 33, 34, 35, 41, 81, 1, 2, 48,
730 -36, -47, 3, 4, -36, 55, 5, 6, -39, 7,
731 -7, 8, -39, 9, 85, 86, 10, 11, 12, 51,
732 52, 53, 101, 49, 50, 51, 52, 53, 49, 50,
733 51, 52, 53, 68, 93, 56, 71, 72, 43, 73,
734 74, 75, 76, 77, 78, 54, 40, 59, 7, 84,
735 84, 60, 121, 87, 41, 1, 2, 44, 45, 46,
736 3, 4, 47, 63, 5, 31, 65, 7, 67, 8,
737 64, 69, 70, 102, 10, 11, 12, 49, 50, 51,
738 52, 53, 49, 50, 51, 52, 53, 83, 96, 39,
739 40, 82, 7, 97, 49, 50, 51, 52, 53, 49,
740 50, 51, 52, 53, 92, 98, 88, 52, 99, 100,
741 136, 49, 50, 51, 52, 53, 103, 132, 133, 105,
742 104, 109, 137, 106, 107, 110, 139, 140, 49, 50,
743 51, 52, 53, 49, 50, 51, 52, 53, 108, 141,
744 -55, 111, 113, 118, 142, 49, 50, 51, 52, 53,
745 115, 123, 124, 62, 49, 50, 51, 52, 53, 125,
746 127, 61, 49, 50, 51, 52, 53, 128, 130, 131,
747 134, 138, 0, 143, 144, 147, 148, 0, 122, 91
748 };
749
750 static const yytype_int16 yycheck[] =
751 {
752 0, 1, 2, 3, 4, 7, 56, 3, 4, 0,
753 8, 9, 8, 9, 8, 8, 12, 13, 16, 15,
754 18, 17, 16, 19, 59, 60, 22, 23, 24, 5,
755 6, 7, 82, 3, 4, 5, 6, 7, 3, 4,
756 5, 6, 7, 43, 14, 8, 46, 47, 9, 49,
757 50, 51, 52, 53, 54, 20, 13, 21, 15, 59,
758 60, 25, 112, 63, 66, 3, 4, 9, 9, 9,
759 8, 9, 9, 18, 12, 13, 9, 15, 5, 17,
760 16, 13, 13, 83, 22, 23, 24, 3, 4, 5,
761 6, 7, 3, 4, 5, 6, 7, 18, 14, 12,
762 13, 8, 15, 14, 3, 4, 5, 6, 7, 3,
763 4, 5, 6, 7, 15, 14, 13, 6, 10, 10,
764 14, 3, 4, 5, 6, 7, 11, 127, 128, 5,
765 14, 14, 14, 13, 13, 13, 136, 137, 3, 4,
766 5, 6, 7, 3, 4, 5, 6, 7, 11, 14,
767 14, 13, 10, 12, 14, 3, 4, 5, 6, 7,
768 15, 12, 11, 11, 3, 4, 5, 6, 7, 14,
769 14, 10, 3, 4, 5, 6, 7, 14, 12, 11,
770 13, 11, -1, 12, 12, 11, 11, -1, 114, 66
771 };
772
773 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
774 symbol of state STATE-NUM. */
775 static const yytype_int8 yystos[] =
776 {
777 0, 3, 4, 8, 9, 12, 13, 15, 17, 19,
778 22, 23, 24, 27, 28, 30, 32, 33, 34, 35,
779 39, 40, 42, 44, 48, 53, 57, 60, 63, 66,
780 67, 13, 32, 32, 32, 32, 29, 43, 49, 12,
781 13, 44, 47, 9, 9, 9, 9, 9, 0, 3,
782 4, 5, 6, 7, 20, 8, 8, 36, 41, 21,
783 25, 10, 11, 18, 16, 9, 45, 5, 32, 13,
784 13, 32, 32, 32, 32, 32, 32, 32, 32, 32,
785 37, 37, 8, 18, 32, 66, 66, 32, 13, 50,
786 52, 47, 15, 14, 31, 58, 14, 14, 14, 10,
787 10, 37, 32, 11, 14, 5, 13, 13, 11, 14,
788 13, 13, 38, 10, 51, 15, 54, 55, 12, 61,
789 64, 37, 50, 12, 11, 14, 59, 14, 14, 46,
790 12, 11, 32, 32, 13, 56, 14, 14, 11, 32,
791 32, 14, 14, 12, 12, 62, 65, 11, 11
792 };
793
794 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
795 static const yytype_int8 yyr1[] =
796 {
797 0, 26, 27, 27, 27, 27, 27, 29, 28, 31,
798 30, 32, 32, 32, 32, 32, 32, 32, 32, 32,
799 32, 32, 32, 32, 32, 33, 33, 34, 34, 35,
800 35, 36, 35, 37, 38, 37, 39, 41, 40, 43,
801 42, 44, 45, 46, 44, 47, 47, 49, 48, 50,
802 51, 50, 52, 54, 53, 55, 56, 53, 58, 59,
803 57, 61, 62, 60, 64, 65, 63, 66, 66, 66,
804 67
805 };
806
807 /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
808 static const yytype_int8 yyr2[] =
809 {
810 0, 2, 1, 1, 1, 1, 1, 0, 4, 0,
811 5, 3, 3, 3, 3, 3, 3, 3, 2, 2,
812 1, 1, 1, 1, 1, 1, 1, 1, 1, 4,
813 4, 0, 5, 1, 0, 4, 1, 0, 4, 0,
814 3, 5, 0, 0, 9, 1, 1, 0, 5, 1,
815 0, 4, 1, 0, 7, 0, 0, 10, 0, 0,
816 8, 0, 0, 14, 0, 0, 14, 1, 3, 3,
817 3
818 };
819
820
821 enum { YYENOMEM = -2 };
822
823 #define yyerrok (yyerrstatus = 0)
824 #define yyclearin (yychar = YYEMPTY)
825
826 #define YYACCEPT goto yyacceptlab
827 #define YYABORT goto yyabortlab
828 #define YYERROR goto yyerrorlab
829
830
831 #define YYRECOVERING() (!!yyerrstatus)
832
833 #define YYBACKUP(Token, Value) \
834 do \
835 if (yychar == YYEMPTY) \
836 { \
837 yychar = (Token); \
838 yylval = (Value); \
839 YYPOPSTACK (yylen); \
840 yystate = *yyssp; \
841 goto yybackup; \
842 } \
843 else \
844 { \
845 yyerror (YY_("syntax error: cannot back up")); \
846 YYERROR; \
847 } \
848 while (0)
849
850 /* Backward compatibility with an undocumented macro.
851 Use YYerror or YYUNDEF. */
852 #define YYERRCODE YYUNDEF
853
854
855 /* Enable debugging if requested. */
856 #if YYDEBUG
857
858 # ifndef YYFPRINTF
859 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
860 # define YYFPRINTF fprintf
861 # endif
862
863 # define YYDPRINTF(Args) \
864 do { \
865 if (yydebug) \
866 YYFPRINTF Args; \
867 } while (0)
868
869 /* This macro is provided for backward compatibility. */
870 # ifndef YY_LOCATION_PRINT
871 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
872 # endif
873
874
875 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \
876 do { \
877 if (yydebug) \
878 { \
879 YYFPRINTF (stderr, "%s ", Title); \
880 yy_symbol_print (stderr, \
881 Kind, Value); \
882 YYFPRINTF (stderr, "\n"); \
883 } \
884 } while (0)
885
886
887 /*-----------------------------------.
888 | Print this symbol's value on YYO. |
889 `-----------------------------------*/
890
891 static void
yy_symbol_value_print(FILE * yyo,yysymbol_kind_t yykind,YYSTYPE const * const yyvaluep)892 yy_symbol_value_print (FILE *yyo,
893 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
894 {
895 FILE *yyoutput = yyo;
896 YYUSE (yyoutput);
897 if (!yyvaluep)
898 return;
899 # ifdef YYPRINT
900 if (yykind < YYNTOKENS)
901 YYPRINT (yyo, yytoknum[yykind], *yyvaluep);
902 # endif
903 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
904 YYUSE (yykind);
905 YY_IGNORE_MAYBE_UNINITIALIZED_END
906 }
907
908
909 /*---------------------------.
910 | Print this symbol on YYO. |
911 `---------------------------*/
912
913 static void
yy_symbol_print(FILE * yyo,yysymbol_kind_t yykind,YYSTYPE const * const yyvaluep)914 yy_symbol_print (FILE *yyo,
915 yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep)
916 {
917 YYFPRINTF (yyo, "%s %s (",
918 yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));
919
920 yy_symbol_value_print (yyo, yykind, yyvaluep);
921 YYFPRINTF (yyo, ")");
922 }
923
924 /*------------------------------------------------------------------.
925 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
926 | TOP (included). |
927 `------------------------------------------------------------------*/
928
929 static void
yy_stack_print(yy_state_t * yybottom,yy_state_t * yytop)930 yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
931 {
932 YYFPRINTF (stderr, "Stack now");
933 for (; yybottom <= yytop; yybottom++)
934 {
935 int yybot = *yybottom;
936 YYFPRINTF (stderr, " %d", yybot);
937 }
938 YYFPRINTF (stderr, "\n");
939 }
940
941 # define YY_STACK_PRINT(Bottom, Top) \
942 do { \
943 if (yydebug) \
944 yy_stack_print ((Bottom), (Top)); \
945 } while (0)
946
947
948 /*------------------------------------------------.
949 | Report that the YYRULE is going to be reduced. |
950 `------------------------------------------------*/
951
952 static void
yy_reduce_print(yy_state_t * yyssp,YYSTYPE * yyvsp,int yyrule)953 yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp,
954 int yyrule)
955 {
956 int yylno = yyrline[yyrule];
957 int yynrhs = yyr2[yyrule];
958 int yyi;
959 YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
960 yyrule - 1, yylno);
961 /* The symbols being reduced. */
962 for (yyi = 0; yyi < yynrhs; yyi++)
963 {
964 YYFPRINTF (stderr, " $%d = ", yyi + 1);
965 yy_symbol_print (stderr,
966 YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
967 &yyvsp[(yyi + 1) - (yynrhs)]);
968 YYFPRINTF (stderr, "\n");
969 }
970 }
971
972 # define YY_REDUCE_PRINT(Rule) \
973 do { \
974 if (yydebug) \
975 yy_reduce_print (yyssp, yyvsp, Rule); \
976 } while (0)
977
978 /* Nonzero means print parse trace. It is left uninitialized so that
979 multiple parsers can coexist. */
980 int yydebug;
981 #else /* !YYDEBUG */
982 # define YYDPRINTF(Args) ((void) 0)
983 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
984 # define YY_STACK_PRINT(Bottom, Top)
985 # define YY_REDUCE_PRINT(Rule)
986 #endif /* !YYDEBUG */
987
988
989 /* YYINITDEPTH -- initial size of the parser's stacks. */
990 #ifndef YYINITDEPTH
991 # define YYINITDEPTH 200
992 #endif
993
994 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
995 if the built-in stack extension method is used).
996
997 Do not make this value too large; the results are undefined if
998 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
999 evaluated with infinite-precision integer arithmetic. */
1000
1001 #ifndef YYMAXDEPTH
1002 # define YYMAXDEPTH 10000
1003 #endif
1004
1005
1006
1007
1008
1009
1010 /*-----------------------------------------------.
1011 | Release the memory associated to this symbol. |
1012 `-----------------------------------------------*/
1013
1014 static void
yydestruct(const char * yymsg,yysymbol_kind_t yykind,YYSTYPE * yyvaluep)1015 yydestruct (const char *yymsg,
1016 yysymbol_kind_t yykind, YYSTYPE *yyvaluep)
1017 {
1018 YYUSE (yyvaluep);
1019 if (!yymsg)
1020 yymsg = "Deleting";
1021 YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
1022
1023 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1024 YYUSE (yykind);
1025 YY_IGNORE_MAYBE_UNINITIALIZED_END
1026 }
1027
1028
1029 /* Lookahead token kind. */
1030 int yychar;
1031
1032 /* The semantic value of the lookahead symbol. */
1033 YYSTYPE yylval;
1034 /* Number of syntax errors so far. */
1035 int yynerrs;
1036
1037
1038
1039
1040 /*----------.
1041 | yyparse. |
1042 `----------*/
1043
1044 int
yyparse(void)1045 yyparse (void)
1046 {
1047 yy_state_fast_t yystate = 0;
1048 /* Number of tokens to shift before error messages enabled. */
1049 int yyerrstatus = 0;
1050
1051 /* Refer to the stacks through separate pointers, to allow yyoverflow
1052 to reallocate them elsewhere. */
1053
1054 /* Their size. */
1055 YYPTRDIFF_T yystacksize = YYINITDEPTH;
1056
1057 /* The state stack: array, bottom, top. */
1058 yy_state_t yyssa[YYINITDEPTH];
1059 yy_state_t *yyss = yyssa;
1060 yy_state_t *yyssp = yyss;
1061
1062 /* The semantic value stack: array, bottom, top. */
1063 YYSTYPE yyvsa[YYINITDEPTH];
1064 YYSTYPE *yyvs = yyvsa;
1065 YYSTYPE *yyvsp = yyvs;
1066
1067 int yyn;
1068 /* The return value of yyparse. */
1069 int yyresult;
1070 /* Lookahead symbol kind. */
1071 yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY;
1072 /* The variables used to return semantic value and location from the
1073 action routines. */
1074 YYSTYPE yyval;
1075
1076
1077
1078 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1079
1080 /* The number of symbols on the RHS of the reduced rule.
1081 Keep to zero when no symbol should be popped. */
1082 int yylen = 0;
1083
1084 YYDPRINTF ((stderr, "Starting parse\n"));
1085
1086 yychar = YYEMPTY; /* Cause a token to be read. */
1087 goto yysetstate;
1088
1089
1090 /*------------------------------------------------------------.
1091 | yynewstate -- push a new state, which is found in yystate. |
1092 `------------------------------------------------------------*/
1093 yynewstate:
1094 /* In all cases, when you get here, the value and location stacks
1095 have just been pushed. So pushing a state here evens the stacks. */
1096 yyssp++;
1097
1098
1099 /*--------------------------------------------------------------------.
1100 | yysetstate -- set current state (the top of the stack) to yystate. |
1101 `--------------------------------------------------------------------*/
1102 yysetstate:
1103 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1104 YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
1105 YY_IGNORE_USELESS_CAST_BEGIN
1106 *yyssp = YY_CAST (yy_state_t, yystate);
1107 YY_IGNORE_USELESS_CAST_END
1108 YY_STACK_PRINT (yyss, yyssp);
1109
1110 if (yyss + yystacksize - 1 <= yyssp)
1111 #if !defined yyoverflow && !defined YYSTACK_RELOCATE
1112 goto yyexhaustedlab;
1113 #else
1114 {
1115 /* Get the current used size of the three stacks, in elements. */
1116 YYPTRDIFF_T yysize = yyssp - yyss + 1;
1117
1118 # if defined yyoverflow
1119 {
1120 /* Give user a chance to reallocate the stack. Use copies of
1121 these so that the &'s don't force the real ones into
1122 memory. */
1123 yy_state_t *yyss1 = yyss;
1124 YYSTYPE *yyvs1 = yyvs;
1125
1126 /* Each stack pointer address is followed by the size of the
1127 data in use in that stack, in bytes. This used to be a
1128 conditional around just the two extra args, but that might
1129 be undefined if yyoverflow is a macro. */
1130 yyoverflow (YY_("memory exhausted"),
1131 &yyss1, yysize * YYSIZEOF (*yyssp),
1132 &yyvs1, yysize * YYSIZEOF (*yyvsp),
1133 &yystacksize);
1134 yyss = yyss1;
1135 yyvs = yyvs1;
1136 }
1137 # else /* defined YYSTACK_RELOCATE */
1138 /* Extend the stack our own way. */
1139 if (YYMAXDEPTH <= yystacksize)
1140 goto yyexhaustedlab;
1141 yystacksize *= 2;
1142 if (YYMAXDEPTH < yystacksize)
1143 yystacksize = YYMAXDEPTH;
1144
1145 {
1146 yy_state_t *yyss1 = yyss;
1147 union yyalloc *yyptr =
1148 YY_CAST (union yyalloc *,
1149 YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
1150 if (! yyptr)
1151 goto yyexhaustedlab;
1152 YYSTACK_RELOCATE (yyss_alloc, yyss);
1153 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1154 # undef YYSTACK_RELOCATE
1155 if (yyss1 != yyssa)
1156 YYSTACK_FREE (yyss1);
1157 }
1158 # endif
1159
1160 yyssp = yyss + yysize - 1;
1161 yyvsp = yyvs + yysize - 1;
1162
1163 YY_IGNORE_USELESS_CAST_BEGIN
1164 YYDPRINTF ((stderr, "Stack size increased to %ld\n",
1165 YY_CAST (long, yystacksize)));
1166 YY_IGNORE_USELESS_CAST_END
1167
1168 if (yyss + yystacksize - 1 <= yyssp)
1169 YYABORT;
1170 }
1171 #endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
1172
1173 if (yystate == YYFINAL)
1174 YYACCEPT;
1175
1176 goto yybackup;
1177
1178
1179 /*-----------.
1180 | yybackup. |
1181 `-----------*/
1182 yybackup:
1183 /* Do appropriate processing given the current state. Read a
1184 lookahead token if we need one and don't already have one. */
1185
1186 /* First try to decide what to do without reference to lookahead token. */
1187 yyn = yypact[yystate];
1188 if (yypact_value_is_default (yyn))
1189 goto yydefault;
1190
1191 /* Not known => get a lookahead token if don't already have one. */
1192
1193 /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */
1194 if (yychar == YYEMPTY)
1195 {
1196 YYDPRINTF ((stderr, "Reading a token\n"));
1197 yychar = yylex ();
1198 }
1199
1200 if (yychar <= YYEOF)
1201 {
1202 yychar = YYEOF;
1203 yytoken = YYSYMBOL_YYEOF;
1204 YYDPRINTF ((stderr, "Now at end of input.\n"));
1205 }
1206 else if (yychar == YYerror)
1207 {
1208 /* The scanner already issued an error message, process directly
1209 to error recovery. But do not keep the error token as
1210 lookahead, it is too special and may lead us to an endless
1211 loop in error recovery. */
1212 yychar = YYUNDEF;
1213 yytoken = YYSYMBOL_YYerror;
1214 goto yyerrlab1;
1215 }
1216 else
1217 {
1218 yytoken = YYTRANSLATE (yychar);
1219 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1220 }
1221
1222 /* If the proper action on seeing token YYTOKEN is to reduce or to
1223 detect an error, take that action. */
1224 yyn += yytoken;
1225 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1226 goto yydefault;
1227 yyn = yytable[yyn];
1228 if (yyn <= 0)
1229 {
1230 if (yytable_value_is_error (yyn))
1231 goto yyerrlab;
1232 yyn = -yyn;
1233 goto yyreduce;
1234 }
1235
1236 /* Count tokens shifted since error; after three, turn off error
1237 status. */
1238 if (yyerrstatus)
1239 yyerrstatus--;
1240
1241 /* Shift the lookahead token. */
1242 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1243 yystate = yyn;
1244 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1245 *++yyvsp = yylval;
1246 YY_IGNORE_MAYBE_UNINITIALIZED_END
1247
1248 /* Discard the shifted token. */
1249 yychar = YYEMPTY;
1250 goto yynewstate;
1251
1252
1253 /*-----------------------------------------------------------.
1254 | yydefault -- do the default action for the current state. |
1255 `-----------------------------------------------------------*/
1256 yydefault:
1257 yyn = yydefact[yystate];
1258 if (yyn == 0)
1259 goto yyerrlab;
1260 goto yyreduce;
1261
1262
1263 /*-----------------------------.
1264 | yyreduce -- do a reduction. |
1265 `-----------------------------*/
1266 yyreduce:
1267 /* yyn is the number of a rule to reduce with. */
1268 yylen = yyr2[yyn];
1269
1270 /* If YYLEN is nonzero, implement the default value of the action:
1271 '$$ = $1'.
1272
1273 Otherwise, the following line sets YYVAL to garbage.
1274 This behavior is undocumented and Bison
1275 users should not rely upon it. Assigning to YYVAL
1276 unconditionally makes the parser a bit smaller, and it avoids a
1277 GCC warning that YYVAL may be used uninitialized. */
1278 yyval = yyvsp[1-yylen];
1279
1280
1281 YY_REDUCE_PRINT (yyn);
1282 switch (yyn)
1283 {
1284 case 5: /* exprentry: FunctionDefinition */
1285 {ExprIntrp_EndOfFuncDef();}
1286 break;
1287
1288 case 6: /* exprentry: RelationList */
1289 {ExprIntrp_EndOfRelation();}
1290 break;
1291
1292 case 7: /* $@1: %empty */
1293 {ExprIntrp_AssignVariable();}
1294 break;
1295
1296 case 8: /* Assignment: IDENTIFIER $@1 ASSIGNOP GenExpr */
1297 {ExprIntrp_EndOfAssign();}
1298 break;
1299
1300 case 9: /* $@2: %empty */
1301 {ExprIntrp_Deassign();}
1302 break;
1303
1304 case 11: /* GenExpr: GenExpr SUMOP GenExpr */
1305 {ExprIntrp_SumOperator();}
1306 break;
1307
1308 case 12: /* GenExpr: GenExpr MINUSOP GenExpr */
1309 {ExprIntrp_MinusOperator();}
1310 break;
1311
1312 case 13: /* GenExpr: GenExpr MULTOP GenExpr */
1313 {ExprIntrp_ProductOperator();}
1314 break;
1315
1316 case 14: /* GenExpr: GenExpr DIVIDEOP GenExpr */
1317 {ExprIntrp_DivideOperator();}
1318 break;
1319
1320 case 15: /* GenExpr: GenExpr EXPOP GenExpr */
1321 {ExprIntrp_ExpOperator();}
1322 break;
1323
1324 case 18: /* GenExpr: MINUSOP GenExpr */
1325 {ExprIntrp_UnaryMinusOperator();}
1326 break;
1327
1328 case 19: /* GenExpr: SUMOP GenExpr */
1329 {ExprIntrp_UnaryPlusOperator();}
1330 break;
1331
1332 case 27: /* Single: IDENTIFIER */
1333 {ExprIntrp_VariableIdentifier();}
1334 break;
1335
1336 case 28: /* Single: VALUE */
1337 {ExprIntrp_NumValue();}
1338 break;
1339
1340 case 29: /* Function: funcident PARENTHESIS ListGenExpr ENDPARENTHESIS */
1341 {ExprIntrp_EndFunction();}
1342 break;
1343
1344 case 30: /* Function: DerFunctionId PARENTHESIS ListGenExpr ENDPARENTHESIS */
1345 {ExprIntrp_EndDerFunction();}
1346 break;
1347
1348 case 31: /* $@3: %empty */
1349 {ExprIntrp_EndDifferential();}
1350 break;
1351
1352 case 32: /* Function: DiffFuncId $@3 PARENTHESIS ListGenExpr ENDPARENTHESIS */
1353 {ExprIntrp_EndDiffFunction();}
1354 break;
1355
1356 case 33: /* ListGenExpr: GenExpr */
1357 {ExprIntrp_EndFuncArg();}
1358 break;
1359
1360 case 34: /* $@4: %empty */
1361 {ExprIntrp_NextFuncArg();}
1362 break;
1363
1364 case 36: /* funcident: IDENTIFIER */
1365 {ExprIntrp_StartFunction();}
1366 break;
1367
1368 case 37: /* $@5: %empty */
1369 {ExprIntrp_DefineFunction();}
1370 break;
1371
1372 case 39: /* $@6: %empty */
1373 {ExprIntrp_StartDerivate();}
1374 break;
1375
1376 case 40: /* DerFunctionId: IDENTIFIER $@6 DERIVATE */
1377 {ExprIntrp_EndDerivate();}
1378 break;
1379
1380 case 41: /* DiffFuncId: DIFFERENTIAL DiffId DIVIDEOP DIFFERENTIAL IDENTIFIER */
1381 {ExprIntrp_DiffVar();}
1382 break;
1383
1384 case 42: /* $@7: %empty */
1385 {ExprIntrp_DiffDegree();}
1386 break;
1387
1388 case 43: /* $@8: %empty */
1389 {ExprIntrp_VerDiffDegree();}
1390 break;
1391
1392 case 44: /* DiffFuncId: DIFFERENTIAL VALUE $@7 DiffId DIVIDEOP DIFFERENTIAL VALUE $@8 IDENTIFIER */
1393 {ExprIntrp_DiffDegreeVar();}
1394 break;
1395
1396 case 45: /* DiffId: IDENTIFIER */
1397 {ExprIntrp_StartDifferential();}
1398 break;
1399
1400 case 47: /* $@9: %empty */
1401 {ExprIntrp_StartFunction();}
1402 break;
1403
1404 case 49: /* ListArg: unarg */
1405 {ExprIntrp_EndFuncArg();}
1406 break;
1407
1408 case 50: /* $@10: %empty */
1409 {ExprIntrp_NextFuncArg();}
1410 break;
1411
1412 case 52: /* unarg: IDENTIFIER */
1413 {ExprIntrp_VariableIdentifier();}
1414 break;
1415
1416 case 53: /* $@11: %empty */
1417 {ExprIntrp_Derivation();}
1418 break;
1419
1420 case 54: /* Derivation: DERIVKEY BRACKET GenExpr COMMA IDENTIFIER $@11 ENDBRACKET */
1421 {ExprIntrp_EndDerivation();}
1422 break;
1423
1424 case 55: /* $@12: %empty */
1425 {ExprIntrp_Derivation();}
1426 break;
1427
1428 case 56: /* $@13: %empty */
1429 {ExprIntrp_DerivationValue();}
1430 break;
1431
1432 case 57: /* Derivation: DERIVKEY BRACKET GenExpr COMMA IDENTIFIER $@12 COMMA VALUE $@13 ENDBRACKET */
1433 {ExprIntrp_EndDerivation();}
1434 break;
1435
1436 case 58: /* $@14: %empty */
1437 {ExprIntrp_ConstantIdentifier();}
1438 break;
1439
1440 case 59: /* $@15: %empty */
1441 {ExprIntrp_ConstantDefinition();}
1442 break;
1443
1444 case 61: /* $@16: %empty */
1445 {ExprIntrp_VariableIdentifier();}
1446 break;
1447
1448 case 62: /* $@17: %empty */
1449 {ExprIntrp_NumValue();}
1450 break;
1451
1452 case 63: /* Sumator: SUMKEY BRACKET GenExpr COMMA IDENTIFIER $@16 COMMA GenExpr COMMA GenExpr COMMA VALUE $@17 ENDBRACKET */
1453 {ExprIntrp_Sumator();}
1454 break;
1455
1456 case 64: /* $@18: %empty */
1457 {ExprIntrp_VariableIdentifier();}
1458 break;
1459
1460 case 65: /* $@19: %empty */
1461 {ExprIntrp_NumValue();}
1462 break;
1463
1464 case 66: /* Productor: PRODKEY BRACKET GenExpr COMMA IDENTIFIER $@18 COMMA GenExpr COMMA GenExpr COMMA VALUE $@19 ENDBRACKET */
1465 {ExprIntrp_Productor();}
1466 break;
1467
1468 case 70: /* SingleRelation: GenExpr EQUALOP GenExpr */
1469 {ExprIntrp_EndOfEqual();}
1470 break;
1471
1472
1473
1474 default: break;
1475 }
1476 /* User semantic actions sometimes alter yychar, and that requires
1477 that yytoken be updated with the new translation. We take the
1478 approach of translating immediately before every use of yytoken.
1479 One alternative is translating here after every semantic action,
1480 but that translation would be missed if the semantic action invokes
1481 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1482 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
1483 incorrect destructor might then be invoked immediately. In the
1484 case of YYERROR or YYBACKUP, subsequent parser actions might lead
1485 to an incorrect destructor call or verbose syntax error message
1486 before the lookahead is translated. */
1487 YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc);
1488
1489 YYPOPSTACK (yylen);
1490 yylen = 0;
1491
1492 *++yyvsp = yyval;
1493
1494 /* Now 'shift' the result of the reduction. Determine what state
1495 that goes to, based on the state we popped back to and the rule
1496 number reduced by. */
1497 {
1498 const int yylhs = yyr1[yyn] - YYNTOKENS;
1499 const int yyi = yypgoto[yylhs] + *yyssp;
1500 yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
1501 ? yytable[yyi]
1502 : yydefgoto[yylhs]);
1503 }
1504
1505 goto yynewstate;
1506
1507
1508 /*--------------------------------------.
1509 | yyerrlab -- here on detecting error. |
1510 `--------------------------------------*/
1511 yyerrlab:
1512 /* Make sure we have latest lookahead translation. See comments at
1513 user semantic actions for why this is necessary. */
1514 yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar);
1515 /* If not already recovering from an error, report this error. */
1516 if (!yyerrstatus)
1517 {
1518 ++yynerrs;
1519 yyerror (YY_("syntax error"));
1520 }
1521
1522 if (yyerrstatus == 3)
1523 {
1524 /* If just tried and failed to reuse lookahead token after an
1525 error, discard it. */
1526
1527 if (yychar <= YYEOF)
1528 {
1529 /* Return failure if at end of input. */
1530 if (yychar == YYEOF)
1531 YYABORT;
1532 }
1533 else
1534 {
1535 yydestruct ("Error: discarding",
1536 yytoken, &yylval);
1537 yychar = YYEMPTY;
1538 }
1539 }
1540
1541 /* Else will try to reuse lookahead token after shifting the error
1542 token. */
1543 goto yyerrlab1;
1544
1545
1546 /*---------------------------------------------------.
1547 | yyerrorlab -- error raised explicitly by YYERROR. |
1548 `---------------------------------------------------*/
1549 yyerrorlab:
1550 /* Pacify compilers when the user code never invokes YYERROR and the
1551 label yyerrorlab therefore never appears in user code. */
1552 if (0)
1553 YYERROR;
1554
1555 /* Do not reclaim the symbols of the rule whose action triggered
1556 this YYERROR. */
1557 YYPOPSTACK (yylen);
1558 yylen = 0;
1559 YY_STACK_PRINT (yyss, yyssp);
1560 yystate = *yyssp;
1561 goto yyerrlab1;
1562
1563
1564 /*-------------------------------------------------------------.
1565 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1566 `-------------------------------------------------------------*/
1567 yyerrlab1:
1568 yyerrstatus = 3; /* Each real token shifted decrements this. */
1569
1570 /* Pop stack until we find a state that shifts the error token. */
1571 for (;;)
1572 {
1573 yyn = yypact[yystate];
1574 if (!yypact_value_is_default (yyn))
1575 {
1576 yyn += YYSYMBOL_YYerror;
1577 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
1578 {
1579 yyn = yytable[yyn];
1580 if (0 < yyn)
1581 break;
1582 }
1583 }
1584
1585 /* Pop the current state because it cannot handle the error token. */
1586 if (yyssp == yyss)
1587 YYABORT;
1588
1589
1590 yydestruct ("Error: popping",
1591 YY_ACCESSING_SYMBOL (yystate), yyvsp);
1592 YYPOPSTACK (1);
1593 yystate = *yyssp;
1594 YY_STACK_PRINT (yyss, yyssp);
1595 }
1596
1597 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1598 *++yyvsp = yylval;
1599 YY_IGNORE_MAYBE_UNINITIALIZED_END
1600
1601
1602 /* Shift the error token. */
1603 YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp);
1604
1605 yystate = yyn;
1606 goto yynewstate;
1607
1608
1609 /*-------------------------------------.
1610 | yyacceptlab -- YYACCEPT comes here. |
1611 `-------------------------------------*/
1612 yyacceptlab:
1613 yyresult = 0;
1614 goto yyreturn;
1615
1616
1617 /*-----------------------------------.
1618 | yyabortlab -- YYABORT comes here. |
1619 `-----------------------------------*/
1620 yyabortlab:
1621 yyresult = 1;
1622 goto yyreturn;
1623
1624
1625 #if !defined yyoverflow
1626 /*-------------------------------------------------.
1627 | yyexhaustedlab -- memory exhaustion comes here. |
1628 `-------------------------------------------------*/
1629 yyexhaustedlab:
1630 yyerror (YY_("memory exhausted"));
1631 yyresult = 2;
1632 goto yyreturn;
1633 #endif
1634
1635
1636 /*-------------------------------------------------------.
1637 | yyreturn -- parsing is finished, clean up and return. |
1638 `-------------------------------------------------------*/
1639 yyreturn:
1640 if (yychar != YYEMPTY)
1641 {
1642 /* Make sure we have latest lookahead translation. See comments at
1643 user semantic actions for why this is necessary. */
1644 yytoken = YYTRANSLATE (yychar);
1645 yydestruct ("Cleanup: discarding lookahead",
1646 yytoken, &yylval);
1647 }
1648 /* Do not reclaim the symbols of the rule whose action triggered
1649 this YYABORT or YYACCEPT. */
1650 YYPOPSTACK (yylen);
1651 YY_STACK_PRINT (yyss, yyssp);
1652 while (yyssp != yyss)
1653 {
1654 yydestruct ("Cleanup: popping",
1655 YY_ACCESSING_SYMBOL (+*yyssp), yyvsp);
1656 YYPOPSTACK (1);
1657 }
1658 #ifndef yyoverflow
1659 if (yyss != yyssa)
1660 YYSTACK_FREE (yyss);
1661 #endif
1662
1663 return yyresult;
1664 }
1665
1666