projects / occt.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
0022048: Visualization, AIS_InteractiveContext - single object selection should alway...
[occt.git] / src / ExprIntrp / ExprIntrp.tab.c
CommitLineData
42cf5bc1 1/* A Bison parser, made by GNU Bison 2.7. */
2
3/* Bison implementation for Yacc-like parsers in C
4
5 Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation, Inc.
6
7 This program is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20/* As a special exception, you may create a larger work that contains
21 part or all of the Bison parser skeleton and distribute that work
22 under terms of your choice, so long as that work isn't itself a
23 parser generator using the skeleton or a modified version thereof
24 as a parser skeleton. Alternatively, if you modify or redistribute
25 the parser skeleton itself, you may (at your option) remove this
26 special exception, which will cause the skeleton and the resulting
27 Bison output files to be licensed under the GNU General Public
28 License without this special exception.
29
30 This special exception was added by the Free Software Foundation in
31 version 2.2 of Bison. */
32
33/* C LALR(1) parser skeleton written by Richard Stallman, by
34 simplifying the original so-called "semantic" parser. */
35
36/* All symbols defined below should begin with yy or YY, to avoid
37 infringing on user name space. This should be done even for local
38 variables, as they might otherwise be expanded by user macros.
39 There are some unavoidable exceptions within include files to
40 define necessary library symbols; they are noted "INFRINGES ON
41 USER NAME SPACE" below. */
42
43/* Identify Bison output. */
44#define YYBISON 1
45
46/* Bison version. */
47#define YYBISON_VERSION "2.7"
48
49/* Skeleton name. */
50#define YYSKELETON_NAME "yacc.c"
51
52/* Pure parsers. */
53#define YYPURE 0
54
55/* Push parsers. */
56#define YYPUSH 0
57
58/* Pull parsers. */
59#define YYPULL 1
60
61
62/* Substitute the variable and function names. */
63#define yyparse ExprIntrpparse
64#define yylex ExprIntrplex
65#define yyerror ExprIntrperror
66#define yylval ExprIntrplval
67#define yychar ExprIntrpchar
68#define yydebug ExprIntrpdebug
69#define yynerrs ExprIntrpnerrs
70
71/* Copy the first part of user declarations. */
72/* Line 371 of yacc.c */
73#line 17 "D:/ABV/OCCT/occt7/src/ExprIntrp/ExprIntrp.yacc"
74
75#include <ExprIntrp_yaccintrf.hxx>
76
77extern void ExprIntrp_EndOfFuncDef();
78extern void ExprIntrp_EndOfRelation();
79extern void ExprIntrp_AssignVariable();
80extern void ExprIntrp_EndOfAssign();
81extern void ExprIntrp_Deassign();
82extern void ExprIntrp_SumOperator();
83extern void ExprIntrp_MinusOperator();
84extern void ExprIntrp_ProductOperator();
85extern void ExprIntrp_DivideOperator();
86extern void ExprIntrp_ExpOperator();
87extern void ExprIntrp_UnaryMinusOperator();
88extern void ExprIntrp_UnaryPlusOperator();
89extern void ExprIntrp_VariableIdentifier();
90extern void ExprIntrp_NumValue();
91extern void ExprIntrp_EndFunction();
92extern void ExprIntrp_EndDerFunction();
93extern void ExprIntrp_EndDifferential();
94extern void ExprIntrp_EndDiffFunction();
95extern void ExprIntrp_EndFuncArg();
96extern void ExprIntrp_NextFuncArg();
97extern void ExprIntrp_StartFunction();
98extern void ExprIntrp_DefineFunction();
99extern void ExprIntrp_StartDerivate();
100extern void ExprIntrp_EndDerivate();
101extern void ExprIntrp_DiffVar();
102extern void ExprIntrp_DiffDegree();
103extern void ExprIntrp_VerDiffDegree();
104extern void ExprIntrp_DiffDegreeVar();
105extern void ExprIntrp_StartDifferential();
106extern void ExprIntrp_StartFunction();
107extern void ExprIntrp_EndFuncArg();
108extern void ExprIntrp_NextFuncArg();
109extern void ExprIntrp_VariableIdentifier();
110extern void ExprIntrp_Derivation();
111extern void ExprIntrp_EndDerivation();
112extern void ExprIntrp_DerivationValue();
113extern void ExprIntrp_ConstantIdentifier();
114extern void ExprIntrp_ConstantDefinition();
115extern void ExprIntrp_VariableIdentifier();
116extern void ExprIntrp_NumValue();
117extern void ExprIntrp_Sumator();
118extern void ExprIntrp_VariableIdentifier();
119extern void ExprIntrp_Productor();
120extern 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
159extern 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
195typedef 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
201extern YYSTYPE ExprIntrplval;
202
203#ifdef YYPARSE_PARAM
204#if defined __STDC__ || defined __cplusplus
205int ExprIntrpparse (void *YYPARSE_PARAM);
206#else
207int ExprIntrpparse ();
208#endif
209#else /* ! YYPARSE_PARAM */
210#if defined __STDC__ || defined __cplusplus
211int ExprIntrpparse (void);
212#else
213int 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
229typedef YYTYPE_UINT8 yytype_uint8;
230#else
231typedef unsigned char yytype_uint8;
232#endif
233
234#ifdef YYTYPE_INT8
235typedef YYTYPE_INT8 yytype_int8;
236#elif (defined __STDC__ || defined __C99__FUNC__ \
237 || defined __cplusplus || defined _MSC_VER)
238typedef signed char yytype_int8;
239#else
240typedef short int yytype_int8;
241#endif
242
243#ifdef YYTYPE_UINT16
244typedef YYTYPE_UINT16 yytype_uint16;
245#else
246typedef unsigned short int yytype_uint16;
247#endif
248
249#ifdef YYTYPE_INT16
250typedef YYTYPE_INT16 yytype_int16;
251#else
252typedef 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)
296static int
297YYID (int yyi)
298#else
299static int
300YYID (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)
365void *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)
372void 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. */
384union 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. */
461static 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. */
496static 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. */
509static 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. */
538static 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. */
554static 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. */
574static 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. */
583static 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. */
596static 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. */
611static 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]. */
631static 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
643static 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]. */
663static 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
676static 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
705static 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. */
730static 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) \
777do \
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 } \
791while (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) \
820do { \
821 if (yydebug) \
822 YYFPRINTF Args; \
823} while (YYID (0))
824
825# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
826do { \
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)
844static void
845yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
846#else
847static void
848yy_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)
878static void
879yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
880#else
881static void
882yy_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)
904static void
905yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
906#else
907static void
908yy_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) \
923do { \
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)
935static void
936yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
937#else
938static void
939yy_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) \
961do { \
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. */
968int 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)
1003static YYSIZE_T
1004yystrlen (const char *yystr)
1005#else
1006static YYSIZE_T
1007yystrlen (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)
1027static char *
1028yystpcpy (char *yydest, const char *yysrc)
1029#else
1030static char *
1031yystpcpy (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. */
1055static YYSIZE_T
1056yytnamerr (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. */
1103static int
1104yysyntax_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)
1242static void
1243yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1244#else
1245static void
1246yydestruct (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. */
1270int 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. */
1282YYSTYPE yylval YY_INITIAL_VALUE(yyval_default);
1283
1284/* Number of syntax errors so far. */
1285int 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)
1295int
1296yyparse (void *YYPARSE_PARAM)
1297#else
1298int
1299yyparse (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)
1305int
1306yyparse (void)
1307#else
1308int
1309yyparse ()
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`-----------*/
1452yybackup:
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`-----------------------------------------------------------*/
1518yydefault:
1519 yyn = yydefact[yystate];
1520 if (yyn == 0)
1521 goto yyerrlab;
1522 goto yyreduce;
1523
1524
1525/*-----------------------------.
1526| yyreduce -- Do a reduction. |
1527`-----------------------------*/
1528yyreduce:
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`------------------------------------*/
1870yyerrlab:
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`---------------------------------------------------*/
1944yyerrorlab:
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`-------------------------------------------------------------*/
1964yyerrlab1:
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`-------------------------------------*/
2008yyacceptlab:
2009 yyresult = 0;
2010 goto yyreturn;
2011
2012/*-----------------------------------.
2013| yyabortlab -- YYABORT comes here. |
2014`-----------------------------------*/
2015yyabortlab:
2016 yyresult = 1;
2017 goto yyreturn;
2018
2019#if !defined yyoverflow || YYERROR_VERBOSE
2020/*-------------------------------------------------.
2021| yyexhaustedlab -- memory exhaustion comes here. |
2022`-------------------------------------------------*/
2023yyexhaustedlab:
2024 yyerror (YY_("memory exhausted"));
2025 yyresult = 2;
2026 /* Fall through. */
2027#endif
2028
2029yyreturn:
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
Open CASCADE Technology repository