parser.c · cryptotaxi247/netdata-1

Code Commits Issues Pulls Sessions CI/CD

master

c 1,575 lines 55.1 KB

Raw

1	/* This file is automatically generated by Lemon from input grammar
2	** source file "parser.y".
3	*/
4	/*
5	** 2000-05-29
6	**
7	** The author disclaims copyright to this source code. In place of
8	** a legal notice, here is a blessing:
9	**
10	** May you do good and not evil.
11	** May you find forgiveness for yourself and forgive others.
12	** May you share freely, never taking more than you give.
13	**
14	*************************************************************************
15	** Driver template for the LEMON parser generator.
16	**
17	** The "lemon" program processes an LALR(1) input grammar file, then uses
18	** this template to construct a parser. The "lemon" program inserts text
19	** at each "%%" line. Also, any "P-a-r-s-e" identifier prefix (without the
20	** interstitial "-" characters) contained in this template is changed into
21	** the value of the %name directive from the grammar. Otherwise, the content
22	** of this template is copied straight through into the generate parser
23	** source file.
24	**
25	** The following is the concatenation of all %include directives from the
26	** input grammar file:
27	*/
28	/********** Begin %include sections from the grammar **********************/
29	#include "../eval-internal.h"
30	#include "parser_internal.h"
31	#include <assert.h>
32	#line 33 "parser.c"
33	/************** End of %include directives ********************************/
34	/* These constants specify the various numeric values for terminal symbols.
35	*************** Begin token definitions ***********************************/
36	#ifndef TOK_NUMBER
37	#define TOK_NUMBER 1
38	#define TOK_VARIABLE 2
39	#define TOK_LPAREN 3
40	#define TOK_RPAREN 4
41	#define TOK_PLUS 5
42	#define TOK_UPLUS 6
43	#define TOK_MINUS 7
44	#define TOK_UMINUS 8
45	#define TOK_NOT 9
46	#define TOK_FUNCTION_ABS 10
47	#define TOK_MULTIPLY 11
48	#define TOK_DIVIDE 12
49	#define TOK_MODULO 13
50	#define TOK_AND 14
51	#define TOK_OR 15
52	#define TOK_EQ 16
53	#define TOK_NE 17
54	#define TOK_LT 18
55	#define TOK_LE 19
56	#define TOK_GT 20
57	#define TOK_GE 21
58	#define TOK_QMARK 22
59	#define TOK_COLON 23
60	#endif
61	/************** End token definitions *************************************/
62
63	/* The next sections is a series of control #defines.
64	** various aspects of the generated parser.
65	** YYCODETYPE is the data type used to store the integer codes
66	** that represent terminal and non-terminal symbols.
67	** "unsigned char" is used if there are fewer than
68	** 256 symbols. Larger types otherwise.
69	** YYNOCODE is a number of type YYCODETYPE that is not used for
70	** any terminal or nonterminal symbol.
71	** YYFALLBACK If defined, this indicates that one or more tokens
72	** (also known as: "terminal symbols") have fall-back
73	** values which should be used if the original symbol
74	** would not parse. This permits keywords to sometimes
75	** be used as identifiers, for example.
76	** YYACTIONTYPE is the data type used for "action codes" - numbers
77	** that indicate what to do in response to the next
78	** token.
79	** ParseTOKENTYPE is the data type used for minor type for terminal
80	** symbols. Background: A "minor type" is a semantic
81	** value associated with a terminal or non-terminal
82	** symbols. For example, for an "ID" terminal symbol,
83	** the minor type might be the name of the identifier.
84	** Each non-terminal can have a different minor type.
85	** Terminal symbols all have the same minor type, though.
86	** This macros defines the minor type for terminal
87	** symbols.
88	** YYMINORTYPE is the data type used for all minor types.
89	** This is typically a union of many types, one of
90	** which is ParseTOKENTYPE. The entry in the union
91	** for terminal symbols is called "yy0".
92	** YYSTACKDEPTH is the maximum depth of the parser's stack. If
93	** zero the stack is dynamically sized using realloc()
94	** ParseARG_SDECL A static variable declaration for the %extra_argument
95	** ParseARG_PDECL A parameter declaration for the %extra_argument
96	** ParseARG_PARAM Code to pass %extra_argument as a subroutine parameter
97	** ParseARG_STORE Code to store %extra_argument into yypParser
98	** ParseARG_FETCH Code to extract %extra_argument from yypParser
99	** ParseCTX_* As ParseARG_ except for %extra_context
100	** YYREALLOC Name of the realloc() function to use
101	** YYFREE Name of the free() function to use
102	** YYDYNSTACK True if stack space should be extended on heap
103	** YYERRORSYMBOL is the code number of the error symbol. If not
104	** defined, then do no error processing.
105	** YYNSTATE the combined number of states.
106	** YYNRULE the number of rules in the grammar
107	** YYNTOKEN Number of terminal symbols
108	** YY_MAX_SHIFT Maximum value for shift actions
109	** YY_MIN_SHIFTREDUCE Minimum value for shift-reduce actions
110	** YY_MAX_SHIFTREDUCE Maximum value for shift-reduce actions
111	** YY_ERROR_ACTION The yy_action[] code for syntax error
112	** YY_ACCEPT_ACTION The yy_action[] code for accept
113	** YY_NO_ACTION The yy_action[] code for no-op
114	** YY_MIN_REDUCE Minimum value for reduce actions
115	** YY_MAX_REDUCE Maximum value for reduce actions
116	** YY_MIN_DSTRCTR Minimum symbol value that has a destructor
117	** YY_MAX_DSTRCTR Maximum symbol value that has a destructor
118	*/
119	#ifndef INTERFACE
120	# define INTERFACE 1
121	#endif
122	/*********** Begin control #defines ***************************************/
123	#define YYCODETYPE unsigned char
124	#define YYNOCODE 26
125	#define YYACTIONTYPE unsigned char
126	#define ParseTOKENTYPE YYSTYPE
127	typedef union {
128	int yyinit;
129	ParseTOKENTYPE yy0;
130	EVAL_NODE* yy48;
131	} YYMINORTYPE;
132	#ifndef YYSTACKDEPTH
133	#define YYSTACKDEPTH 100
134	#endif
135	#define ParseARG_SDECL EVAL_NODE **result;
136	#define ParseARG_PDECL ,EVAL_NODE **result
137	#define ParseARG_PARAM ,result
138	#define ParseARG_FETCH EVAL_NODE **result=yypParser->result;
139	#define ParseARG_STORE yypParser->result=result;
140	#define YYREALLOC realloc
141	#define YYFREE free
142	#define YYDYNSTACK 0
143	#define ParseCTX_SDECL
144	#define ParseCTX_PDECL
145	#define ParseCTX_PARAM
146	#define ParseCTX_FETCH
147	#define ParseCTX_STORE
148	#define YYNSTATE 37
149	#define YYNRULE 22
150	#define YYNRULE_WITH_ACTION 22
151	#define YYNTOKEN 24
152	#define YY_MAX_SHIFT 36
153	#define YY_MIN_SHIFTREDUCE 47
154	#define YY_MAX_SHIFTREDUCE 68
155	#define YY_ERROR_ACTION 69
156	#define YY_ACCEPT_ACTION 70
157	#define YY_NO_ACTION 71
158	#define YY_MIN_REDUCE 72
159	#define YY_MAX_REDUCE 93
160	#define YY_MIN_DSTRCTR 24
161	#define YY_MAX_DSTRCTR 24
162	/*********** End control #defines *****************************************/
163	#define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])))
164
165	/* Define the yytestcase() macro to be a no-op if is not already defined
166	** otherwise.
167	**
168	** Applications can choose to define yytestcase() in the %include section
169	** to a macro that can assist in verifying code coverage. For production
170	** code the yytestcase() macro should be turned off. But it is useful
171	** for testing.
172	*/
173	#ifndef yytestcase
174	# define yytestcase(X)
175	#endif
176
177	/* Macro to determine if stack space has the ability to grow using
178	** heap memory.
179	*/
180	#if YYSTACKDEPTH<=0 \|\| YYDYNSTACK
181	# define YYGROWABLESTACK 1
182	#else
183	# define YYGROWABLESTACK 0
184	#endif
185
186	/* Guarantee a minimum number of initial stack slots.
187	*/
188	#if YYSTACKDEPTH<=0
189	# undef YYSTACKDEPTH
190	# define YYSTACKDEPTH 2 /* Need a minimum stack size */
191	#endif
192
193
194	/* Next are the tables used to determine what action to take based on the
195	** current state and lookahead token. These tables are used to implement
196	** functions that take a state number and lookahead value and return an
197	** action integer.
198	**
199	** Suppose the action integer is N. Then the action is determined as
200	** follows
201	**
202	** 0 <= N <= YY_MAX_SHIFT Shift N. That is, push the lookahead
203	** token onto the stack and goto state N.
204	**
205	** N between YY_MIN_SHIFTREDUCE Shift to an arbitrary state then
206	** and YY_MAX_SHIFTREDUCE reduce by rule N-YY_MIN_SHIFTREDUCE.
207	**
208	** N == YY_ERROR_ACTION A syntax error has occurred.
209	**
210	** N == YY_ACCEPT_ACTION The parser accepts its input.
211	**
212	** N == YY_NO_ACTION No such action. Denotes unused
213	** slots in the yy_action[] table.
214	**
215	** N between YY_MIN_REDUCE Reduce by rule N-YY_MIN_REDUCE
216	** and YY_MAX_REDUCE
217	**
218	** The action table is constructed as a single large table named yy_action[].
219	** Given state S and lookahead X, the action is computed as either:
220	**
221	** (A) N = yy_action[ yy_shift_ofst[S] + X ]
222	** (B) N = yy_default[S]
223	**
224	** The (A) formula is preferred. The B formula is used instead if
225	** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X.
226	**
227	** The formulas above are for computing the action when the lookahead is
228	** a terminal symbol. If the lookahead is a non-terminal (as occurs after
229	** a reduce action) then the yy_reduce_ofst[] array is used in place of
230	** the yy_shift_ofst[] array.
231	**
232	** The following are the tables generated in this section:
233	**
234	** yy_action[] A single table containing all actions.
235	** yy_lookahead[] A table containing the lookahead for each entry in
236	** yy_action. Used to detect hash collisions.
237	** yy_shift_ofst[] For each state, the offset into yy_action for
238	** shifting terminals.
239	** yy_reduce_ofst[] For each state, the offset into yy_action for
240	** shifting non-terminals after a reduce.
241	** yy_default[] Default action for each state.
242	**
243	********* Begin parsing tables ********************************************/
244	#define YY_ACTTAB_COUNT (147)
245	static const YYACTIONTYPE yy_action[] = {
246	/* 0 */ 24, 70, 25, 21, 30, 20, 31, 18, 32, 33,
247	/* 10 */ 28, 16, 14, 12, 10, 9, 8, 7, 6, 5,
248	/* 20 */ 4, 3, 2, 1, 54, 20, 29, 18, 16, 14,
249	/* 30 */ 12, 16, 14, 12, 10, 9, 8, 7, 6, 5,
250	/* 40 */ 4, 3, 2, 50, 20, 26, 18, 27, 22, 84,
251	/* 50 */ 16, 14, 12, 10, 9, 8, 7, 6, 5, 4,
252	/* 60 */ 3, 2, 72, 11, 20, 78, 18, 20, 83, 18,
253	/* 70 */ 16, 14, 12, 16, 14, 12, 10, 9, 8, 7,
254	/* 80 */ 6, 5, 4, 3, 2, 20, 71, 18, 71, 77,
255	/* 90 */ 82, 16, 14, 12, 10, 9, 8, 7, 6, 5,
256	/* 100 */ 4, 3, 2, 20, 71, 18, 76, 35, 23, 16,
257	/* 110 */ 14, 12, 34, 71, 8, 7, 6, 5, 4, 3,
258	/* 120 */ 20, 71, 18, 71, 71, 71, 16, 14, 12, 71,
259	/* 130 */ 71, 71, 71, 6, 5, 4, 3, 48, 49, 19,
260	/* 140 */ 71, 17, 71, 15, 71, 13, 36,
261	};
262	static const YYCODETYPE yy_lookahead[] = {
263	/* 0 */ 24, 25, 24, 24, 24, 5, 24, 7, 24, 24,
264	/* 10 */ 24, 11, 12, 13, 14, 15, 16, 17, 18, 19,
265	/* 20 */ 20, 21, 22, 23, 4, 5, 24, 7, 11, 12,
266	/* 30 */ 13, 11, 12, 13, 14, 15, 16, 17, 18, 19,
267	/* 40 */ 20, 21, 22, 4, 5, 24, 7, 24, 24, 24,
268	/* 50 */ 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
269	/* 60 */ 21, 22, 0, 3, 5, 24, 7, 5, 24, 7,
270	/* 70 */ 11, 12, 13, 11, 12, 13, 14, 15, 16, 17,
271	/* 80 */ 18, 19, 20, 21, 22, 5, 26, 7, 26, 24,
272	/* 90 */ 24, 11, 12, 13, 14, 15, 16, 17, 18, 19,
273	/* 100 */ 20, 21, 22, 5, 26, 7, 24, 24, 24, 11,
274	/* 110 */ 12, 13, 24, 26, 16, 17, 18, 19, 20, 21,
275	/* 120 */ 5, 26, 7, 26, 26, 26, 11, 12, 13, 26,
276	/* 130 */ 26, 26, 26, 18, 19, 20, 21, 1, 2, 3,
277	/* 140 */ 26, 5, 26, 7, 26, 9, 10, 26, 26, 26,
278	/* 150 */ 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
279	/* 160 */ 26, 26, 24, 24, 24, 24, 24, 24, 24, 24,
280	/* 170 */ 24,
281	};
282	#define YY_SHIFT_COUNT (36)
283	#define YY_SHIFT_MIN (0)
284	#define YY_SHIFT_MAX (136)
285	static const unsigned char yy_shift_ofst[] = {
286	/* 0 */ 136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
287	/* 10 */ 136, 136, 136, 136, 136, 136, 136, 136, 136, 136,
288	/* 20 */ 136, 0, 20, 39, 62, 80, 98, 98, 115, 115,
289	/* 30 */ 59, 59, 59, 59, 17, 17, 60,
290	};
291	#define YY_REDUCE_COUNT (20)
292	#define YY_REDUCE_MIN (-24)
293	#define YY_REDUCE_MAX (88)
294	static const signed char yy_reduce_ofst[] = {
295	/* 0 */ -24, -22, -21, -20, -18, -16, -15, -14, 2, 21,
296	/* 10 */ 23, 24, 25, 41, 44, 65, 66, 82, 83, 84,
297	/* 20 */ 88,
298	};
299	static const YYACTIONTYPE yy_default[] = {
300	/* 0 */ 69, 69, 69, 69, 69, 69, 69, 69, 69, 69,
301	/* 10 */ 69, 69, 69, 69, 69, 69, 69, 69, 69, 69,
302	/* 20 */ 69, 69, 69, 69, 69, 93, 86, 85, 88, 87,
303	/* 30 */ 92, 91, 90, 89, 80, 81, 69,
304	};
305	/******** End of lemon-generated parsing tables ***************************/
306
307	/* The next table maps tokens (terminal symbols) into fallback tokens.
308	** If a construct like the following:
309	**
310	** %fallback ID X Y Z.
311	**
312	** appears in the grammar, then ID becomes a fallback token for X, Y,
313	** and Z. Whenever one of the tokens X, Y, or Z is input to the parser
314	** but it does not parse, the type of the token is changed to ID and
315	** the parse is retried before an error is thrown.
316	**
317	** This feature can be used, for example, to cause some keywords in a language
318	** to revert to identifiers if they keyword does not apply in the context where
319	** it appears.
320	*/
321	#ifdef YYFALLBACK
322	static const YYCODETYPE yyFallback[] = {
323	};
324	#endif /* YYFALLBACK */
325
326	/* The following structure represents a single element of the
327	** parser's stack. Information stored includes:
328	**
329	** + The state number for the parser at this level of the stack.
330	**
331	** + The value of the token stored at this level of the stack.
332	** (In other words, the "major" token.)
333	**
334	** + The semantic value stored at this level of the stack. This is
335	** the information used by the action routines in the grammar.
336	** It is sometimes called the "minor" token.
337	**
338	** After the "shift" half of a SHIFTREDUCE action, the stateno field
339	** actually contains the reduce action for the second half of the
340	** SHIFTREDUCE.
341	*/
342	struct yyStackEntry {
343	YYACTIONTYPE stateno; /* The state-number, or reduce action in SHIFTREDUCE */
344	YYCODETYPE major; /* The major token value. This is the code
345	** number for the token at this stack level */
346	YYMINORTYPE minor; /* The user-supplied minor token value. This
347	** is the value of the token */
348	};
349	typedef struct yyStackEntry yyStackEntry;
350
351	/* The state of the parser is completely contained in an instance of
352	** the following structure */
353	struct yyParser {
354	yyStackEntry yytos; / Pointer to top element of the stack */
355	#ifdef YYTRACKMAXSTACKDEPTH
356	int yyhwm; /* High-water mark of the stack */
357	#endif
358	#ifndef YYNOERRORRECOVERY
359	int yyerrcnt; /* Shifts left before out of the error */
360	#endif
361	ParseARG_SDECL /* A place to hold %extra_argument */
362	ParseCTX_SDECL /* A place to hold %extra_context */
363	yyStackEntry yystackEnd; / Last entry in the stack */
364	yyStackEntry yystack; / The parser stack */
365	yyStackEntry yystk0[YYSTACKDEPTH]; /* Initial stack space */
366	};
367	typedef struct yyParser yyParser;
368
369	#include <assert.h>
370	#ifndef NDEBUG
371	#include <stdio.h>
372	static FILE *yyTraceFILE = 0;
373	static char *yyTracePrompt = 0;
374	#endif /* NDEBUG */
375
376	#ifndef NDEBUG
377	/*
378	** Turn parser tracing on by giving a stream to which to write the trace
379	** and a prompt to preface each trace message. Tracing is turned off
380	** by making either argument NULL
381	**
382	** Inputs:
383	** <ul>
384	** <li> A FILE* to which trace output should be written.
385	** If NULL, then tracing is turned off.
386	** <li> A prefix string written at the beginning of every
387	** line of trace output. If NULL, then tracing is
388	** turned off.
389	** </ul>
390	**
391	** Outputs:
392	** None.
393	*/
394	void ParseTrace(FILE TraceFILE, char zTracePrompt){
395	yyTraceFILE = TraceFILE;
396	yyTracePrompt = zTracePrompt;
397	if( yyTraceFILE==0 ) yyTracePrompt = 0;
398	else if( yyTracePrompt==0 ) yyTraceFILE = 0;
399	}
400	#endif /* NDEBUG */
401
402	#if defined(YYCOVERAGE) \|\| !defined(NDEBUG)
403	/* For tracing shifts, the names of all terminals and nonterminals
404	** are required. The following table supplies these names */
405	static const char *const yyTokenName[] = {
406	/* 0 */ "$",
407	/* 1 */ "NUMBER",
408	/* 2 */ "VARIABLE",
409	/* 3 */ "LPAREN",
410	/* 4 */ "RPAREN",
411	/* 5 */ "PLUS",
412	/* 6 */ "UPLUS",
413	/* 7 */ "MINUS",
414	/* 8 */ "UMINUS",
415	/* 9 */ "NOT",
416	/* 10 */ "FUNCTION_ABS",
417	/* 11 */ "MULTIPLY",
418	/* 12 */ "DIVIDE",
419	/* 13 */ "MODULO",
420	/* 14 */ "AND",
421	/* 15 */ "OR",
422	/* 16 */ "EQ",
423	/* 17 */ "NE",
424	/* 18 */ "LT",
425	/* 19 */ "LE",
426	/* 20 */ "GT",
427	/* 21 */ "GE",
428	/* 22 */ "QMARK",
429	/* 23 */ "COLON",
430	/* 24 */ "expr",
431	/* 25 */ "program",
432	};
433	#endif /* defined(YYCOVERAGE) \|\| !defined(NDEBUG) */
434
435	#ifndef NDEBUG
436	/* For tracing reduce actions, the names of all rules are required.
437	*/
438	static const char *const yyRuleName[] = {
439	/* 0 */ "program ::= expr",
440	/* 1 */ "expr ::= NUMBER",
441	/* 2 */ "expr ::= VARIABLE",
442	/* 3 */ "expr ::= LPAREN expr RPAREN",
443	/* 4 */ "expr ::= PLUS expr",
444	/* 5 */ "expr ::= MINUS expr",
445	/* 6 */ "expr ::= NOT expr",
446	/* 7 */ "expr ::= FUNCTION_ABS LPAREN expr RPAREN",
447	/* 8 */ "expr ::= expr PLUS expr",
448	/* 9 */ "expr ::= expr MINUS expr",
449	/* 10 */ "expr ::= expr MULTIPLY expr",
450	/* 11 */ "expr ::= expr DIVIDE expr",
451	/* 12 */ "expr ::= expr MODULO expr",
452	/* 13 */ "expr ::= expr AND expr",
453	/* 14 */ "expr ::= expr OR expr",
454	/* 15 */ "expr ::= expr EQ expr",
455	/* 16 */ "expr ::= expr NE expr",
456	/* 17 */ "expr ::= expr LT expr",
457	/* 18 */ "expr ::= expr LE expr",
458	/* 19 */ "expr ::= expr GT expr",
459	/* 20 */ "expr ::= expr GE expr",
460	/* 21 */ "expr ::= expr QMARK expr COLON expr",
461	};
462	#endif /* NDEBUG */
463
464
465	#if YYGROWABLESTACK
466	/*
467	** Try to increase the size of the parser stack. Return the number
468	** of errors. Return 0 on success.
469	*/
470	static int yyGrowStack(yyParser *p){
471	int oldSize = 1 + (int)(p->yystackEnd - p->yystack);
472	int newSize;
473	int idx;
474	yyStackEntry *pNew;
475
476	newSize = oldSize*2 + 100;
477	idx = (int)(p->yytos - p->yystack);
478	if( p->yystack==p->yystk0 ){
479	pNew = YYREALLOC(0, newSize*sizeof(pNew[0]));
480	if( pNew==0 ) return 1;
481	memcpy(pNew, p->yystack, oldSize*sizeof(pNew[0]));
482	}else{
483	pNew = YYREALLOC(p->yystack, newSize*sizeof(pNew[0]));
484	if( pNew==0 ) return 1;
485	}
486	p->yystack = pNew;
487	p->yytos = &p->yystack[idx];
488	#ifndef NDEBUG
489	if( yyTraceFILE ){
490	fprintf(yyTraceFILE,"%sStack grows from %d to %d entries.\n",
491	yyTracePrompt, oldSize, newSize);
492	}
493	#endif
494	p->yystackEnd = &p->yystack[newSize-1];
495	return 0;
496	}
497	#endif /* YYGROWABLESTACK */
498
499	#if !YYGROWABLESTACK
500	/* For builds that do no have a growable stack, yyGrowStack always
501	** returns an error.
502	*/
503	# define yyGrowStack(X) 1
504	#endif
505
506	/* Datatype of the argument to the memory allocated passed as the
507	** second argument to ParseAlloc() below. This can be changed by
508	** putting an appropriate #define in the %include section of the input
509	** grammar.
510	*/
511	#ifndef YYMALLOCARGTYPE
512	# define YYMALLOCARGTYPE size_t
513	#endif
514
515	/* Initialize a new parser that has already been allocated.
516	*/
517	void ParseInit(void *yypRawParser ParseCTX_PDECL){
518	yyParser yypParser = (yyParser)yypRawParser;
519	ParseCTX_STORE
520	#ifdef YYTRACKMAXSTACKDEPTH
521	yypParser->yyhwm = 0;
522	#endif
523	yypParser->yystack = yypParser->yystk0;
524	yypParser->yystackEnd = &yypParser->yystack[YYSTACKDEPTH-1];
525	#ifndef YYNOERRORRECOVERY
526	yypParser->yyerrcnt = -1;
527	#endif
528	yypParser->yytos = yypParser->yystack;
529	yypParser->yystack[0].stateno = 0;
530	yypParser->yystack[0].major = 0;
531	}
532
533	#ifndef Parse_ENGINEALWAYSONSTACK
534	/*
535	** This function allocates a new parser.
536	** The only argument is a pointer to a function which works like
537	** malloc.
538	**
539	** Inputs:
540	** A pointer to the function used to allocate memory.
541	**
542	** Outputs:
543	** A pointer to a parser. This pointer is used in subsequent calls
544	** to Parse and ParseFree.
545	*/
546	void ParseAlloc(void (*mallocProc)(YYMALLOCARGTYPE) ParseCTX_PDECL){
547	yyParser *yypParser;
548	yypParser = (yyParser)(mallocProc)( (YYMALLOCARGTYPE)sizeof(yyParser) );
549	if( yypParser ){
550	ParseCTX_STORE
551	ParseInit(yypParser ParseCTX_PARAM);
552	}
553	return (void*)yypParser;
554	}
555	#endif /* Parse_ENGINEALWAYSONSTACK */
556
557
558	/* The following function deletes the "minor type" or semantic value
559	** associated with a symbol. The symbol can be either a terminal
560	** or nonterminal. "yymajor" is the symbol code, and "yypminor" is
561	** a pointer to the value to be deleted. The code used to do the
562	** deletions is derived from the %destructor and/or %token_destructor
563	** directives of the input grammar.
564	*/
565	static void yy_destructor(
566	yyParser yypParser, / The parser */
567	YYCODETYPE yymajor, /* Type code for object to destroy */
568	YYMINORTYPE yypminor / The object to be destroyed */
569	){
570	ParseARG_FETCH
571	ParseCTX_FETCH
572	switch( yymajor ){
573	/* Here is inserted the actions which take place when a
574	** terminal or non-terminal is destroyed. This can happen
575	** when the symbol is popped from the stack during a
576	** reduce or during error processing or when a parser is
577	** being destroyed before it is finished parsing.
578	**
579	** Note: during a reduce, the only symbols destroyed are those
580	** which appear on the RHS of the rule, but which are not used
581	** inside the C code.
582	*/
583	/******* Begin destructor definitions *************************************/
584	case 24: /* expr */
585	{
586	#line 34 "parser.y"
587
588	if ((yypminor->yy48)) {
589	eval_node_free((yypminor->yy48));
590	}
591
592	#line 592 "parser.c"
593	}
594	break;
595	/******* End destructor definitions ***************************************/
596	default: break; /* If no destructor action specified: do nothing */
597	}
598	}
599
600	/*
601	** Pop the parser's stack once.
602	**
603	** If there is a destructor routine associated with the token which
604	** is popped from the stack, then call it.
605	*/
606	static void yy_pop_parser_stack(yyParser *pParser){
607	yyStackEntry *yytos;
608	assert( pParser->yytos!=0 );
609	assert( pParser->yytos > pParser->yystack );
610	yytos = pParser->yytos--;
611	#ifndef NDEBUG
612	if( yyTraceFILE ){
613	fprintf(yyTraceFILE,"%sPopping %s\n",
614	yyTracePrompt,
615	yyTokenName[yytos->major]);
616	}
617	#endif
618	yy_destructor(pParser, yytos->major, &yytos->minor);
619	}
620
621	/*
622	** Clear all secondary memory allocations from the parser
623	*/
624	void ParseFinalize(void *p){
625	yyParser pParser = (yyParser)p;
626
627	/* In-lined version of calling yy_pop_parser_stack() for each
628	** element left in the stack */
629	yyStackEntry *yytos = pParser->yytos;
630	while( yytos>pParser->yystack ){
631	#ifndef NDEBUG
632	if( yyTraceFILE ){
633	fprintf(yyTraceFILE,"%sPopping %s\n",
634	yyTracePrompt,
635	yyTokenName[yytos->major]);
636	}
637	#endif
638	if( yytos->major>=YY_MIN_DSTRCTR ){
639	yy_destructor(pParser, yytos->major, &yytos->minor);
640	}
641	yytos--;
642	}
643
644	#if YYGROWABLESTACK
645	if( pParser->yystack!=pParser->yystk0 ) YYFREE(pParser->yystack);
646	#endif
647	}
648
649	#ifndef Parse_ENGINEALWAYSONSTACK
650	/*
651	** Deallocate and destroy a parser. Destructors are called for
652	** all stack elements before shutting the parser down.
653	**
654	** If the YYPARSEFREENEVERNULL macro exists (for example because it
655	** is defined in a %include section of the input grammar) then it is
656	** assumed that the input pointer is never NULL.
657	*/
658	void ParseFree(
659	void p, / The parser to be deleted */
660	void (freeProc)(void) /* Function used to reclaim memory */
661	){
662	#ifndef YYPARSEFREENEVERNULL
663	if( p==0 ) return;
664	#endif
665	ParseFinalize(p);
666	(*freeProc)(p);
667	}
668	#endif /* Parse_ENGINEALWAYSONSTACK */
669
670	/*
671	** Return the peak depth of the stack for a parser.
672	*/
673	#ifdef YYTRACKMAXSTACKDEPTH
674	int ParseStackPeak(void *p){
675	yyParser pParser = (yyParser)p;
676	return pParser->yyhwm;
677	}
678	#endif
679
680	/* This array of booleans keeps track of the parser statement
681	** coverage. The element yycoverage[X][Y] is set when the parser
682	** is in state X and has a lookahead token Y. In a well-tested
683	** systems, every element of this matrix should end up being set.
684	*/
685	#if defined(YYCOVERAGE)
686	static unsigned char yycoverage[YYNSTATE][YYNTOKEN];
687	#endif
688
689	/*
690	** Write into out a description of every state/lookahead combination that
691	**
692	** (1) has not been used by the parser, and
693	** (2) is not a syntax error.
694	**
695	** Return the number of missed state/lookahead combinations.
696	*/
697	#if defined(YYCOVERAGE)
698	int ParseCoverage(FILE *out){
699	int stateno, iLookAhead, i;
700	int nMissed = 0;
701	for(stateno=0; stateno<YYNSTATE; stateno++){
702	i = yy_shift_ofst[stateno];
703	for(iLookAhead=0; iLookAhead<YYNTOKEN; iLookAhead++){
704	if( yy_lookahead[i+iLookAhead]!=iLookAhead ) continue;
705	if( yycoverage[stateno][iLookAhead]==0 ) nMissed++;
706	if( out ){
707	fprintf(out,"State %d lookahead %s %s\n", stateno,
708	yyTokenName[iLookAhead],
709	yycoverage[stateno][iLookAhead] ? "ok" : "missed");
710	}
711	}
712	}
713	return nMissed;
714	}
715	#endif
716
717	/*
718	** Find the appropriate action for a parser given the terminal
719	** look-ahead token iLookAhead.
720	*/
721	static YYACTIONTYPE yy_find_shift_action(
722	YYCODETYPE iLookAhead, /* The look-ahead token */
723	YYACTIONTYPE stateno /* Current state number */
724	){
725	int i;
726
727	if( stateno>YY_MAX_SHIFT ) return stateno;
728	assert( stateno <= YY_SHIFT_COUNT );
729	#if defined(YYCOVERAGE)
730	yycoverage[stateno][iLookAhead] = 1;
731	#endif
732	do{
733	i = yy_shift_ofst[stateno];
734	assert( i>=0 );
735	assert( i<=YY_ACTTAB_COUNT );
736	assert( i+YYNTOKEN<=(int)YY_NLOOKAHEAD );
737	assert( iLookAhead!=YYNOCODE );
738	assert( iLookAhead < YYNTOKEN );
739	i += iLookAhead;
740	assert( i<(int)YY_NLOOKAHEAD );
741	if( yy_lookahead[i]!=iLookAhead ){
742	#ifdef YYFALLBACK
743	YYCODETYPE iFallback; /* Fallback token */
744	assert( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0]) );
745	iFallback = yyFallback[iLookAhead];
746	if( iFallback!=0 ){
747	#ifndef NDEBUG
748	if( yyTraceFILE ){
749	fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n",
750	yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]);
751	}
752	#endif
753	assert( yyFallback[iFallback]==0 ); /* Fallback loop must terminate */
754	iLookAhead = iFallback;
755	continue;
756	}
757	#endif
758	#ifdef YYWILDCARD
759	{
760	int j = i - iLookAhead + YYWILDCARD;
761	assert( j<(int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])) );
762	if( yy_lookahead[j]==YYWILDCARD && iLookAhead>0 ){
763	#ifndef NDEBUG
764	if( yyTraceFILE ){
765	fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n",
766	yyTracePrompt, yyTokenName[iLookAhead],
767	yyTokenName[YYWILDCARD]);
768	}
769	#endif /* NDEBUG */
770	return yy_action[j];
771	}
772	}
773	#endif /* YYWILDCARD */
774	return yy_default[stateno];
775	}else{
776	assert( i>=0 && i<(int)(sizeof(yy_action)/sizeof(yy_action[0])) );
777	return yy_action[i];
778	}
779	}while(1);
780	}
781
782	/*
783	** Find the appropriate action for a parser given the non-terminal
784	** look-ahead token iLookAhead.
785	*/
786	static YYACTIONTYPE yy_find_reduce_action(
787	YYACTIONTYPE stateno, /* Current state number */
788	YYCODETYPE iLookAhead /* The look-ahead token */
789	){
790	int i;
791	#ifdef YYERRORSYMBOL
792	if( stateno>YY_REDUCE_COUNT ){
793	return yy_default[stateno];
794	}
795	#else
796	assert( stateno<=YY_REDUCE_COUNT );
797	#endif
798	i = yy_reduce_ofst[stateno];
799	assert( iLookAhead!=YYNOCODE );
800	i += iLookAhead;
801	#ifdef YYERRORSYMBOL
802	if( i<0 \|\| i>=YY_ACTTAB_COUNT \|\| yy_lookahead[i]!=iLookAhead ){
803	return yy_default[stateno];
804	}
805	#else
806	assert( i>=0 && i<YY_ACTTAB_COUNT );
807	assert( yy_lookahead[i]==iLookAhead );
808	#endif
809	return yy_action[i];
810	}
811
812	/*
813	** The following routine is called if the stack overflows.
814	*/
815	static void yyStackOverflow(yyParser *yypParser){
816	ParseARG_FETCH
817	ParseCTX_FETCH
818	#ifndef NDEBUG
819	if( yyTraceFILE ){
820	fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);
821	}
822	#endif
823	while( yypParser->yytos>yypParser->yystack ) yy_pop_parser_stack(yypParser);
824	/* Here code is inserted which will execute if the parser
825	** stack every overflows */
826	/****** Begin %stack_overflow code ****************************************/
827	/****** End %stack_overflow code ******************************************/
828	ParseARG_STORE /* Suppress warning about unused %extra_argument var */
829	ParseCTX_STORE
830	}
831
832	/*
833	** Print tracing information for a SHIFT action
834	*/
835	#ifndef NDEBUG
836	static void yyTraceShift(yyParser yypParser, int yyNewState, const char zTag){
837	if( yyTraceFILE ){
838	if( yyNewState<YYNSTATE ){
839	fprintf(yyTraceFILE,"%s%s '%s', go to state %d\n",
840	yyTracePrompt, zTag, yyTokenName[yypParser->yytos->major],
841	yyNewState);
842	}else{
843	fprintf(yyTraceFILE,"%s%s '%s', pending reduce %d\n",
844	yyTracePrompt, zTag, yyTokenName[yypParser->yytos->major],
845	yyNewState - YY_MIN_REDUCE);
846	}
847	}
848	}
849	#else
850	# define yyTraceShift(X,Y,Z)
851	#endif
852
853	/*
854	** Perform a shift action.
855	*/
856	static void yy_shift(
857	yyParser yypParser, / The parser to be shifted */
858	YYACTIONTYPE yyNewState, /* The new state to shift in */
859	YYCODETYPE yyMajor, /* The major token to shift in */
860	ParseTOKENTYPE yyMinor /* The minor token to shift in */
861	){
862	yyStackEntry *yytos;
863	yypParser->yytos++;
864	#ifdef YYTRACKMAXSTACKDEPTH
865	if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){
866	yypParser->yyhwm++;
867	assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack) );
868	}
869	#endif
870	yytos = yypParser->yytos;
871	if( yytos>yypParser->yystackEnd ){
872	if( yyGrowStack(yypParser) ){
873	yypParser->yytos--;
874	yyStackOverflow(yypParser);
875	return;
876	}
877	yytos = yypParser->yytos;
878	assert( yytos <= yypParser->yystackEnd );
879	}
880	if( yyNewState > YY_MAX_SHIFT ){
881	yyNewState += YY_MIN_REDUCE - YY_MIN_SHIFTREDUCE;
882	}
883	yytos->stateno = yyNewState;
884	yytos->major = yyMajor;
885	yytos->minor.yy0 = yyMinor;
886	yyTraceShift(yypParser, yyNewState, "Shift");
887	}
888
889	/* For rule J, yyRuleInfoLhs[J] contains the symbol on the left-hand side
890	** of that rule */
891	static const YYCODETYPE yyRuleInfoLhs[] = {
892	25, /* (0) program ::= expr */
893	24, /* (1) expr ::= NUMBER */
894	24, /* (2) expr ::= VARIABLE */
895	24, /* (3) expr ::= LPAREN expr RPAREN */
896	24, /* (4) expr ::= PLUS expr */
897	24, /* (5) expr ::= MINUS expr */
898	24, /* (6) expr ::= NOT expr */
899	24, /* (7) expr ::= FUNCTION_ABS LPAREN expr RPAREN */
900	24, /* (8) expr ::= expr PLUS expr */
901	24, /* (9) expr ::= expr MINUS expr */
902	24, /* (10) expr ::= expr MULTIPLY expr */
903	24, /* (11) expr ::= expr DIVIDE expr */
904	24, /* (12) expr ::= expr MODULO expr */
905	24, /* (13) expr ::= expr AND expr */
906	24, /* (14) expr ::= expr OR expr */
907	24, /* (15) expr ::= expr EQ expr */
908	24, /* (16) expr ::= expr NE expr */
909	24, /* (17) expr ::= expr LT expr */
910	24, /* (18) expr ::= expr LE expr */
911	24, /* (19) expr ::= expr GT expr */
912	24, /* (20) expr ::= expr GE expr */
913	24, /* (21) expr ::= expr QMARK expr COLON expr */
914	};
915
916	/* For rule J, yyRuleInfoNRhs[J] contains the negative of the number
917	** of symbols on the right-hand side of that rule. */
918	static const signed char yyRuleInfoNRhs[] = {
919	-1, /* (0) program ::= expr */
920	-1, /* (1) expr ::= NUMBER */
921	-1, /* (2) expr ::= VARIABLE */
922	-3, /* (3) expr ::= LPAREN expr RPAREN */
923	-2, /* (4) expr ::= PLUS expr */
924	-2, /* (5) expr ::= MINUS expr */
925	-2, /* (6) expr ::= NOT expr */
926	-4, /* (7) expr ::= FUNCTION_ABS LPAREN expr RPAREN */
927	-3, /* (8) expr ::= expr PLUS expr */
928	-3, /* (9) expr ::= expr MINUS expr */
929	-3, /* (10) expr ::= expr MULTIPLY expr */
930	-3, /* (11) expr ::= expr DIVIDE expr */
931	-3, /* (12) expr ::= expr MODULO expr */
932	-3, /* (13) expr ::= expr AND expr */
933	-3, /* (14) expr ::= expr OR expr */
934	-3, /* (15) expr ::= expr EQ expr */
935	-3, /* (16) expr ::= expr NE expr */
936	-3, /* (17) expr ::= expr LT expr */
937	-3, /* (18) expr ::= expr LE expr */
938	-3, /* (19) expr ::= expr GT expr */
939	-3, /* (20) expr ::= expr GE expr */
940	-5, /* (21) expr ::= expr QMARK expr COLON expr */
941	};
942
943	static void yy_accept(yyParser); / Forward Declaration */
944
945	/*
946	** Perform a reduce action and the shift that must immediately
947	** follow the reduce.
948	**
949	** The yyLookahead and yyLookaheadToken parameters provide reduce actions
950	** access to the lookahead token (if any). The yyLookahead will be YYNOCODE
951	** if the lookahead token has already been consumed. As this procedure is
952	** only called from one place, optimizing compilers will in-line it, which
953	** means that the extra parameters have no performance impact.
954	*/
955	static YYACTIONTYPE yy_reduce(
956	yyParser yypParser, / The parser */
957	unsigned int yyruleno, /* Number of the rule by which to reduce */
958	int yyLookahead, /* Lookahead token, or YYNOCODE if none */
959	ParseTOKENTYPE yyLookaheadToken /* Value of the lookahead token */
960	ParseCTX_PDECL /* %extra_context */
961	){
962	int yygoto; /* The next state */
963	YYACTIONTYPE yyact; /* The next action */
964	yyStackEntry yymsp; / The top of the parser's stack */
965	int yysize; /* Amount to pop the stack */
966	ParseARG_FETCH
967	(void)yyLookahead;
968	(void)yyLookaheadToken;
969	yymsp = yypParser->yytos;
970
971	switch( yyruleno ){
972	/* Beginning here are the reduction cases. A typical example
973	** follows:
974	** case 0:
975	** #line <lineno> <grammarfile>
976	** { ... } // User supplied code
977	** #line <lineno> <thisfile>
978	** break;
979	*/
980	/******** Begin reduce actions ********************************************/
981	YYMINORTYPE yylhsminor;
982	case 0: /* program ::= expr */
983	#line 41 "parser.y"
984	{
985	*result = yymsp[0].minor.yy48;
986	}
987	#line 987 "parser.c"
988	break;
989	case 1: /* expr ::= NUMBER */
990	#line 46 "parser.y"
991	{
992	yylhsminor.yy48 = eval_node_alloc(1);
993	yylhsminor.yy48->operator = EVAL_OPERATOR_NOP;
994	eval_node_set_value_to_constant(yylhsminor.yy48, 0, yymsp[0].minor.yy0.dval);
995	}
996	#line 996 "parser.c"
997	yymsp[0].minor.yy48 = yylhsminor.yy48;
998	break;
999	case 2: /* expr ::= VARIABLE */
1000	#line 52 "parser.y"
1001	{
1002	yylhsminor.yy48 = eval_node_alloc(1);
1003	yylhsminor.yy48->operator = EVAL_OPERATOR_NOP;
1004	eval_node_set_value_to_variable(yylhsminor.yy48, 0, yymsp[0].minor.yy0.strval);
1005	freez(yymsp[0].minor.yy0.strval); // Free the strdup'd string
1006	}
1007	#line 1007 "parser.c"
1008	yymsp[0].minor.yy48 = yylhsminor.yy48;
1009	break;
1010	case 3: /* expr ::= LPAREN expr RPAREN */
1011	#line 60 "parser.y"
1012	{
1013	yymsp[-2].minor.yy48 = eval_node_alloc(1);
1014	yymsp[-2].minor.yy48->operator = EVAL_OPERATOR_EXPRESSION_OPEN;
1015	yymsp[-2].minor.yy48->precedence = eval_precedence(EVAL_OPERATOR_EXPRESSION_OPEN);
1016	eval_node_set_value_to_node(yymsp[-2].minor.yy48, 0, yymsp[-1].minor.yy48);
1017	}
1018	#line 1018 "parser.c"
1019	break;
1020	case 4: /* expr ::= PLUS expr */
1021	#line 68 "parser.y"
1022	{
1023	yymsp[-1].minor.yy48 = eval_node_alloc(1);
1024	yymsp[-1].minor.yy48->operator = EVAL_OPERATOR_SIGN_PLUS;
1025	yymsp[-1].minor.yy48->precedence = eval_precedence(EVAL_OPERATOR_SIGN_PLUS);
1026	eval_node_set_value_to_node(yymsp[-1].minor.yy48, 0, yymsp[0].minor.yy48);
1027	}
1028	#line 1028 "parser.c"
1029	break;
1030	case 5: /* expr ::= MINUS expr */
1031	#line 75 "parser.y"
1032	{
1033	yymsp[-1].minor.yy48 = eval_node_alloc(1);
1034	yymsp[-1].minor.yy48->operator = EVAL_OPERATOR_SIGN_MINUS;
1035	yymsp[-1].minor.yy48->precedence = eval_precedence(EVAL_OPERATOR_SIGN_MINUS);
1036	eval_node_set_value_to_node(yymsp[-1].minor.yy48, 0, yymsp[0].minor.yy48);
1037	}
1038	#line 1038 "parser.c"
1039	break;
1040	case 6: /* expr ::= NOT expr */
1041	#line 82 "parser.y"
1042	{
1043	yymsp[-1].minor.yy48 = eval_node_alloc(1);
1044	yymsp[-1].minor.yy48->operator = EVAL_OPERATOR_NOT;
1045	yymsp[-1].minor.yy48->precedence = eval_precedence(EVAL_OPERATOR_NOT);
1046	eval_node_set_value_to_node(yymsp[-1].minor.yy48, 0, yymsp[0].minor.yy48);
1047	}
1048	#line 1048 "parser.c"
1049	break;
1050	case 7: /* expr ::= FUNCTION_ABS LPAREN expr RPAREN */
1051	#line 90 "parser.y"
1052	{
1053	yymsp[-3].minor.yy48 = eval_node_alloc(1);
1054	yymsp[-3].minor.yy48->operator = EVAL_OPERATOR_ABS;
1055	yymsp[-3].minor.yy48->precedence = eval_precedence(EVAL_OPERATOR_ABS);
1056	eval_node_set_value_to_node(yymsp[-3].minor.yy48, 0, yymsp[-1].minor.yy48);
1057	}
1058	#line 1058 "parser.c"
1059	break;
1060	case 8: /* expr ::= expr PLUS expr */
1061	#line 98 "parser.y"
1062	{
1063	yylhsminor.yy48 = eval_node_alloc(2);
1064	yylhsminor.yy48->operator = EVAL_OPERATOR_PLUS;
1065	yylhsminor.yy48->precedence = eval_precedence(EVAL_OPERATOR_PLUS);
1066	eval_node_set_value_to_node(yylhsminor.yy48, 0, yymsp[-2].minor.yy48);
1067	eval_node_set_value_to_node(yylhsminor.yy48, 1, yymsp[0].minor.yy48);
1068	}
1069	#line 1069 "parser.c"
1070	yymsp[-2].minor.yy48 = yylhsminor.yy48;
1071	break;
1072	case 9: /* expr ::= expr MINUS expr */
1073	#line 106 "parser.y"
1074	{
1075	yylhsminor.yy48 = eval_node_alloc(2);
1076	yylhsminor.yy48->operator = EVAL_OPERATOR_MINUS;
1077	yylhsminor.yy48->precedence = eval_precedence(EVAL_OPERATOR_MINUS);
1078	eval_node_set_value_to_node(yylhsminor.yy48, 0, yymsp[-2].minor.yy48);
1079	eval_node_set_value_to_node(yylhsminor.yy48, 1, yymsp[0].minor.yy48);
1080	}
1081	#line 1081 "parser.c"
1082	yymsp[-2].minor.yy48 = yylhsminor.yy48;
1083	break;
1084	case 10: /* expr ::= expr MULTIPLY expr */
1085	#line 114 "parser.y"
1086	{
1087	yylhsminor.yy48 = eval_node_alloc(2);
1088	yylhsminor.yy48->operator = EVAL_OPERATOR_MULTIPLY;
1089	yylhsminor.yy48->precedence = eval_precedence(EVAL_OPERATOR_MULTIPLY);
1090	eval_node_set_value_to_node(yylhsminor.yy48, 0, yymsp[-2].minor.yy48);
1091	eval_node_set_value_to_node(yylhsminor.yy48, 1, yymsp[0].minor.yy48);
1092	}
1093	#line 1093 "parser.c"
1094	yymsp[-2].minor.yy48 = yylhsminor.yy48;
1095	break;
1096	case 11: /* expr ::= expr DIVIDE expr */
1097	#line 122 "parser.y"
1098	{
1099	yylhsminor.yy48 = eval_node_alloc(2);
1100	yylhsminor.yy48->operator = EVAL_OPERATOR_DIVIDE;
1101	yylhsminor.yy48->precedence = eval_precedence(EVAL_OPERATOR_DIVIDE);
1102	eval_node_set_value_to_node(yylhsminor.yy48, 0, yymsp[-2].minor.yy48);
1103	eval_node_set_value_to_node(yylhsminor.yy48, 1, yymsp[0].minor.yy48);
1104	}
1105	#line 1105 "parser.c"
1106	yymsp[-2].minor.yy48 = yylhsminor.yy48;
1107	break;
1108	case 12: /* expr ::= expr MODULO expr */
1109	#line 130 "parser.y"
1110	{
1111	yylhsminor.yy48 = eval_node_alloc(2);
1112	yylhsminor.yy48->operator = EVAL_OPERATOR_MODULO;
1113	yylhsminor.yy48->precedence = eval_precedence(EVAL_OPERATOR_MODULO);
1114	eval_node_set_value_to_node(yylhsminor.yy48, 0, yymsp[-2].minor.yy48);
1115	eval_node_set_value_to_node(yylhsminor.yy48, 1, yymsp[0].minor.yy48);
1116	}
1117	#line 1117 "parser.c"
1118	yymsp[-2].minor.yy48 = yylhsminor.yy48;
1119	break;
1120	case 13: /* expr ::= expr AND expr */
1121	#line 138 "parser.y"
1122	{
1123	yylhsminor.yy48 = eval_node_alloc(2);
1124	yylhsminor.yy48->operator = EVAL_OPERATOR_AND;
1125	yylhsminor.yy48->precedence = eval_precedence(EVAL_OPERATOR_AND);
1126	eval_node_set_value_to_node(yylhsminor.yy48, 0, yymsp[-2].minor.yy48);
1127	eval_node_set_value_to_node(yylhsminor.yy48, 1, yymsp[0].minor.yy48);
1128	}
1129	#line 1129 "parser.c"
1130	yymsp[-2].minor.yy48 = yylhsminor.yy48;
1131	break;
1132	case 14: /* expr ::= expr OR expr */
1133	#line 146 "parser.y"
1134	{
1135	yylhsminor.yy48 = eval_node_alloc(2);
1136	yylhsminor.yy48->operator = EVAL_OPERATOR_OR;
1137	yylhsminor.yy48->precedence = eval_precedence(EVAL_OPERATOR_OR);
1138	eval_node_set_value_to_node(yylhsminor.yy48, 0, yymsp[-2].minor.yy48);
1139	eval_node_set_value_to_node(yylhsminor.yy48, 1, yymsp[0].minor.yy48);
1140	}
1141	#line 1141 "parser.c"
1142	yymsp[-2].minor.yy48 = yylhsminor.yy48;
1143	break;
1144	case 15: /* expr ::= expr EQ expr */
1145	#line 154 "parser.y"
1146	{
1147	yylhsminor.yy48 = eval_node_alloc(2);
1148	yylhsminor.yy48->operator = EVAL_OPERATOR_EQUAL;
1149	yylhsminor.yy48->precedence = eval_precedence(EVAL_OPERATOR_EQUAL);
1150	eval_node_set_value_to_node(yylhsminor.yy48, 0, yymsp[-2].minor.yy48);
1151	eval_node_set_value_to_node(yylhsminor.yy48, 1, yymsp[0].minor.yy48);
1152	}
1153	#line 1153 "parser.c"
1154	yymsp[-2].minor.yy48 = yylhsminor.yy48;
1155	break;
1156	case 16: /* expr ::= expr NE expr */
1157	#line 162 "parser.y"
1158	{
1159	yylhsminor.yy48 = eval_node_alloc(2);
1160	yylhsminor.yy48->operator = EVAL_OPERATOR_NOT_EQUAL;
1161	yylhsminor.yy48->precedence = eval_precedence(EVAL_OPERATOR_NOT_EQUAL);
1162	eval_node_set_value_to_node(yylhsminor.yy48, 0, yymsp[-2].minor.yy48);
1163	eval_node_set_value_to_node(yylhsminor.yy48, 1, yymsp[0].minor.yy48);
1164	}
1165	#line 1165 "parser.c"
1166	yymsp[-2].minor.yy48 = yylhsminor.yy48;
1167	break;
1168	case 17: /* expr ::= expr LT expr */
1169	#line 170 "parser.y"
1170	{
1171	yylhsminor.yy48 = eval_node_alloc(2);
1172	yylhsminor.yy48->operator = EVAL_OPERATOR_LESS;
1173	yylhsminor.yy48->precedence = eval_precedence(EVAL_OPERATOR_LESS);
1174	eval_node_set_value_to_node(yylhsminor.yy48, 0, yymsp[-2].minor.yy48);
1175	eval_node_set_value_to_node(yylhsminor.yy48, 1, yymsp[0].minor.yy48);
1176	}
1177	#line 1177 "parser.c"
1178	yymsp[-2].minor.yy48 = yylhsminor.yy48;
1179	break;
1180	case 18: /* expr ::= expr LE expr */
1181	#line 178 "parser.y"
1182	{
1183	yylhsminor.yy48 = eval_node_alloc(2);
1184	yylhsminor.yy48->operator = EVAL_OPERATOR_LESS_THAN_OR_EQUAL;
1185	yylhsminor.yy48->precedence = eval_precedence(EVAL_OPERATOR_LESS_THAN_OR_EQUAL);
1186	eval_node_set_value_to_node(yylhsminor.yy48, 0, yymsp[-2].minor.yy48);
1187	eval_node_set_value_to_node(yylhsminor.yy48, 1, yymsp[0].minor.yy48);
1188	}
1189	#line 1189 "parser.c"
1190	yymsp[-2].minor.yy48 = yylhsminor.yy48;
1191	break;
1192	case 19: /* expr ::= expr GT expr */
1193	#line 186 "parser.y"
1194	{
1195	yylhsminor.yy48 = eval_node_alloc(2);
1196	yylhsminor.yy48->operator = EVAL_OPERATOR_GREATER;
1197	yylhsminor.yy48->precedence = eval_precedence(EVAL_OPERATOR_GREATER);
1198	eval_node_set_value_to_node(yylhsminor.yy48, 0, yymsp[-2].minor.yy48);
1199	eval_node_set_value_to_node(yylhsminor.yy48, 1, yymsp[0].minor.yy48);
1200	}
1201	#line 1201 "parser.c"
1202	yymsp[-2].minor.yy48 = yylhsminor.yy48;
1203	break;
1204	case 20: /* expr ::= expr GE expr */
1205	#line 194 "parser.y"
1206	{
1207	yylhsminor.yy48 = eval_node_alloc(2);
1208	yylhsminor.yy48->operator = EVAL_OPERATOR_GREATER_THAN_OR_EQUAL;
1209	yylhsminor.yy48->precedence = eval_precedence(EVAL_OPERATOR_GREATER_THAN_OR_EQUAL);
1210	eval_node_set_value_to_node(yylhsminor.yy48, 0, yymsp[-2].minor.yy48);
1211	eval_node_set_value_to_node(yylhsminor.yy48, 1, yymsp[0].minor.yy48);
1212	}
1213	#line 1213 "parser.c"
1214	yymsp[-2].minor.yy48 = yylhsminor.yy48;
1215	break;
1216	case 21: /* expr ::= expr QMARK expr COLON expr */
1217	#line 205 "parser.y"
1218	{
1219	yylhsminor.yy48 = eval_node_alloc(3);
1220	yylhsminor.yy48->operator = EVAL_OPERATOR_IF_THEN_ELSE;
1221	yylhsminor.yy48->precedence = eval_precedence(EVAL_OPERATOR_IF_THEN_ELSE);
1222	eval_node_set_value_to_node(yylhsminor.yy48, 0, yymsp[-4].minor.yy48);
1223	eval_node_set_value_to_node(yylhsminor.yy48, 1, yymsp[-2].minor.yy48);
1224	eval_node_set_value_to_node(yylhsminor.yy48, 2, yymsp[0].minor.yy48);
1225	}
1226	#line 1226 "parser.c"
1227	yymsp[-4].minor.yy48 = yylhsminor.yy48;
1228	break;
1229	default:
1230	break;
1231	/******** End reduce actions **********************************************/
1232	};
1233	assert( yyruleno<sizeof(yyRuleInfoLhs)/sizeof(yyRuleInfoLhs[0]) );
1234	yygoto = yyRuleInfoLhs[yyruleno];
1235	yysize = yyRuleInfoNRhs[yyruleno];
1236	yyact = yy_find_reduce_action(yymsp[yysize].stateno,(YYCODETYPE)yygoto);
1237
1238	/* There are no SHIFTREDUCE actions on nonterminals because the table
1239	** generator has simplified them to pure REDUCE actions. */
1240	assert( !(yyact>YY_MAX_SHIFT && yyact<=YY_MAX_SHIFTREDUCE) );
1241
1242	/* It is not possible for a REDUCE to be followed by an error */
1243	assert( yyact!=YY_ERROR_ACTION );
1244
1245	yymsp += yysize+1;
1246	yypParser->yytos = yymsp;
1247	yymsp->stateno = (YYACTIONTYPE)yyact;
1248	yymsp->major = (YYCODETYPE)yygoto;
1249	yyTraceShift(yypParser, yyact, "... then shift");
1250	return yyact;
1251	}
1252
1253	/*
1254	** The following code executes when the parse fails
1255	*/
1256	#ifndef YYNOERRORRECOVERY
1257	static void yy_parse_failed(
1258	yyParser yypParser / The parser */
1259	){
1260	ParseARG_FETCH
1261	ParseCTX_FETCH
1262	#ifndef NDEBUG
1263	if( yyTraceFILE ){
1264	fprintf(yyTraceFILE,"%sFail!\n",yyTracePrompt);
1265	}
1266	#endif
1267	while( yypParser->yytos>yypParser->yystack ) yy_pop_parser_stack(yypParser);
1268	/* Here code is inserted which will be executed whenever the
1269	** parser fails */
1270	/********** Begin %parse_failure code *************************************/
1271	#line 24 "parser.y"
1272
1273	// Failed to parse the expression
1274	if (*result) {
1275	eval_node_free(*result);
1276	*result = NULL;
1277	}
1278	#line 1278 "parser.c"
1279	/********** End %parse_failure code ***************************************/
1280	ParseARG_STORE /* Suppress warning about unused %extra_argument variable */
1281	ParseCTX_STORE
1282	}
1283	#endif /* YYNOERRORRECOVERY */
1284
1285	/*
1286	** The following code executes when a syntax error first occurs.
1287	*/
1288	static void yy_syntax_error(
1289	yyParser yypParser, / The parser */
1290	int yymajor, /* The major type of the error token */
1291	ParseTOKENTYPE yyminor /* The minor type of the error token */
1292	){
1293	ParseARG_FETCH
1294	ParseCTX_FETCH
1295	#define TOKEN yyminor
1296	/********** Begin %syntax_error code **************************************/
1297	#line 13 "parser.y"
1298
1299	// Create a NOP node with count=0 as an error marker
1300	EVAL_NODE *error_node = eval_node_alloc(0);
1301	error_node->operator = EVAL_OPERATOR_NOP;
1302	*result = error_node;
1303	#line 1303 "parser.c"
1304	/********** End %syntax_error code ****************************************/
1305	ParseARG_STORE /* Suppress warning about unused %extra_argument variable */
1306	ParseCTX_STORE
1307	}
1308
1309	/*
1310	** The following is executed when the parser accepts
1311	*/
1312	static void yy_accept(
1313	yyParser yypParser / The parser */
1314	){
1315	ParseARG_FETCH
1316	ParseCTX_FETCH
1317	#ifndef NDEBUG
1318	if( yyTraceFILE ){
1319	fprintf(yyTraceFILE,"%sAccept!\n",yyTracePrompt);
1320	}
1321	#endif
1322	#ifndef YYNOERRORRECOVERY
1323	yypParser->yyerrcnt = -1;
1324	#endif
1325	assert( yypParser->yytos==yypParser->yystack );
1326	/* Here code is inserted which will be executed whenever the
1327	** parser accepts */
1328	/********* Begin %parse_accept code ***************************************/
1329	#line 20 "parser.y"
1330
1331	// Successfully parsed the expression
1332	#line 1332 "parser.c"
1333	/********* End %parse_accept code *****************************************/
1334	ParseARG_STORE /* Suppress warning about unused %extra_argument variable */
1335	ParseCTX_STORE
1336	}
1337
1338	/* The main parser program.
1339	** The first argument is a pointer to a structure obtained from
1340	** "ParseAlloc" which describes the current state of the parser.
1341	** The second argument is the major token number. The third is
1342	** the minor token. The fourth optional argument is whatever the
1343	** user wants (and specified in the grammar) and is available for
1344	** use by the action routines.
1345	**
1346	** Inputs:
1347	** <ul>
1348	** <li> A pointer to the parser (an opaque structure.)
1349	** <li> The major token number.
1350	** <li> The minor token number.
1351	** <li> An option argument of a grammar-specified type.
1352	** </ul>
1353	**
1354	** Outputs:
1355	** None.
1356	*/
1357	void Parse(
1358	void yyp, / The parser */
1359	int yymajor, /* The major token code number */
1360	ParseTOKENTYPE yyminor /* The value for the token */
1361	ParseARG_PDECL /* Optional %extra_argument parameter */
1362	){
1363	YYMINORTYPE yyminorunion;
1364	YYACTIONTYPE yyact; /* The parser action. */
1365	#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
1366	int yyendofinput; /* True if we are at the end of input */
1367	#endif
1368	#ifdef YYERRORSYMBOL
1369	int yyerrorhit = 0; /* True if yymajor has invoked an error */
1370	#endif
1371	yyParser yypParser = (yyParser)yyp; /* The parser */
1372	ParseCTX_FETCH
1373	ParseARG_STORE
1374
1375	assert( yypParser->yytos!=0 );
1376	#if !defined(YYERRORSYMBOL) && !defined(YYNOERRORRECOVERY)
1377	yyendofinput = (yymajor==0);
1378	#endif
1379
1380	yyact = yypParser->yytos->stateno;
1381	#ifndef NDEBUG
1382	if( yyTraceFILE ){
1383	if( yyact < YY_MIN_REDUCE ){
1384	fprintf(yyTraceFILE,"%sInput '%s' in state %d\n",
1385	yyTracePrompt,yyTokenName[yymajor],yyact);
1386	}else{
1387	fprintf(yyTraceFILE,"%sInput '%s' with pending reduce %d\n",
1388	yyTracePrompt,yyTokenName[yymajor],yyact-YY_MIN_REDUCE);
1389	}
1390	}
1391	#endif
1392
1393	while(1){ /* Exit by "break" */
1394	assert( yypParser->yytos>=yypParser->yystack );
1395	assert( yyact==yypParser->yytos->stateno );
1396	yyact = yy_find_shift_action((YYCODETYPE)yymajor,yyact);
1397	if( yyact >= YY_MIN_REDUCE ){
1398	unsigned int yyruleno = yyact - YY_MIN_REDUCE; /* Reduce by this rule */
1399	#ifndef NDEBUG
1400	assert( yyruleno<(int)(sizeof(yyRuleName)/sizeof(yyRuleName[0])) );
1401	if( yyTraceFILE ){
1402	int yysize = yyRuleInfoNRhs[yyruleno];
1403	if( yysize ){
1404	fprintf(yyTraceFILE, "%sReduce %d [%s]%s, pop back to state %d.\n",
1405	yyTracePrompt,
1406	yyruleno, yyRuleName[yyruleno],
1407	yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action",
1408	yypParser->yytos[yysize].stateno);
1409	}else{
1410	fprintf(yyTraceFILE, "%sReduce %d [%s]%s.\n",
1411	yyTracePrompt, yyruleno, yyRuleName[yyruleno],
1412	yyruleno<YYNRULE_WITH_ACTION ? "" : " without external action");
1413	}
1414	}
1415	#endif /* NDEBUG */
1416
1417	/* Check that the stack is large enough to grow by a single entry
1418	** if the RHS of the rule is empty. This ensures that there is room
1419	** enough on the stack to push the LHS value */
1420	if( yyRuleInfoNRhs[yyruleno]==0 ){
1421	#ifdef YYTRACKMAXSTACKDEPTH
1422	if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){
1423	yypParser->yyhwm++;
1424	assert( yypParser->yyhwm ==
1425	(int)(yypParser->yytos - yypParser->yystack));
1426	}
1427	#endif
1428	if( yypParser->yytos>=yypParser->yystackEnd ){
1429	if( yyGrowStack(yypParser) ){
1430	yyStackOverflow(yypParser);
1431	break;
1432	}
1433	}
1434	}
1435	yyact = yy_reduce(yypParser,yyruleno,yymajor,yyminor ParseCTX_PARAM);
1436	}else if( yyact <= YY_MAX_SHIFTREDUCE ){
1437	yy_shift(yypParser,yyact,(YYCODETYPE)yymajor,yyminor);
1438	#ifndef YYNOERRORRECOVERY
1439	yypParser->yyerrcnt--;
1440	#endif
1441	break;
1442	}else if( yyact==YY_ACCEPT_ACTION ){
1443	yypParser->yytos--;
1444	yy_accept(yypParser);
1445	return;
1446	}else{
1447	assert( yyact == YY_ERROR_ACTION );
1448	yyminorunion.yy0 = yyminor;
1449	#ifdef YYERRORSYMBOL
1450	int yymx;
1451	#endif
1452	#ifndef NDEBUG
1453	if( yyTraceFILE ){
1454	fprintf(yyTraceFILE,"%sSyntax Error!\n",yyTracePrompt);
1455	}
1456	#endif
1457	#ifdef YYERRORSYMBOL
1458	/* A syntax error has occurred.
1459	** The response to an error depends upon whether or not the
1460	** grammar defines an error token "ERROR".
1461	**
1462	** This is what we do if the grammar does define ERROR:
1463	**
1464	** * Call the %syntax_error function.
1465	**
1466	** * Begin popping the stack until we enter a state where
1467	** it is legal to shift the error symbol, then shift
1468	** the error symbol.
1469	**
1470	** * Set the error count to three.
1471	**
1472	** * Begin accepting and shifting new tokens. No new error
1473	** processing will occur until three tokens have been
1474	** shifted successfully.
1475	**
1476	*/
1477	if( yypParser->yyerrcnt<0 ){
1478	yy_syntax_error(yypParser,yymajor,yyminor);
1479	}
1480	yymx = yypParser->yytos->major;
1481	if( yymx==YYERRORSYMBOL \|\| yyerrorhit ){
1482	#ifndef NDEBUG
1483	if( yyTraceFILE ){
1484	fprintf(yyTraceFILE,"%sDiscard input token %s\n",
1485	yyTracePrompt,yyTokenName[yymajor]);
1486	}
1487	#endif
1488	yy_destructor(yypParser, (YYCODETYPE)yymajor, &yyminorunion);
1489	yymajor = YYNOCODE;
1490	}else{
1491	while( yypParser->yytos > yypParser->yystack ){
1492	yyact = yy_find_reduce_action(yypParser->yytos->stateno,
1493	YYERRORSYMBOL);
1494	if( yyact<=YY_MAX_SHIFTREDUCE ) break;
1495	yy_pop_parser_stack(yypParser);
1496	}
1497	if( yypParser->yytos <= yypParser->yystack \|\| yymajor==0 ){
1498	yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
1499	yy_parse_failed(yypParser);
1500	#ifndef YYNOERRORRECOVERY
1501	yypParser->yyerrcnt = -1;
1502	#endif
1503	yymajor = YYNOCODE;
1504	}else if( yymx!=YYERRORSYMBOL ){
1505	yy_shift(yypParser,yyact,YYERRORSYMBOL,yyminor);
1506	}
1507	}
1508	yypParser->yyerrcnt = 3;
1509	yyerrorhit = 1;
1510	if( yymajor==YYNOCODE ) break;
1511	yyact = yypParser->yytos->stateno;
1512	#elif defined(YYNOERRORRECOVERY)
1513	/* If the YYNOERRORRECOVERY macro is defined, then do not attempt to
1514	** do any kind of error recovery. Instead, simply invoke the syntax
1515	** error routine and continue going as if nothing had happened.
1516	**
1517	** Applications can set this macro (for example inside %include) if
1518	** they intend to abandon the parse upon the first syntax error seen.
1519	*/
1520	yy_syntax_error(yypParser,yymajor, yyminor);
1521	yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
1522	break;
1523	#else /* YYERRORSYMBOL is not defined */
1524	/* This is what we do if the grammar does not define ERROR:
1525	**
1526	** * Report an error message, and throw away the input token.
1527	**
1528	** * If the input token is $, then fail the parse.
1529	**
1530	** As before, subsequent error messages are suppressed until
1531	** three input tokens have been successfully shifted.
1532	*/
1533	if( yypParser->yyerrcnt<=0 ){
1534	yy_syntax_error(yypParser,yymajor, yyminor);
1535	}
1536	yypParser->yyerrcnt = 3;
1537	yy_destructor(yypParser,(YYCODETYPE)yymajor,&yyminorunion);
1538	if( yyendofinput ){
1539	yy_parse_failed(yypParser);
1540	#ifndef YYNOERRORRECOVERY
1541	yypParser->yyerrcnt = -1;
1542	#endif
1543	}
1544	break;
1545	#endif
1546	}
1547	}
1548	#ifndef NDEBUG
1549	if( yyTraceFILE ){
1550	yyStackEntry *i;
1551	char cDiv = '[';
1552	fprintf(yyTraceFILE,"%sReturn. Stack=",yyTracePrompt);
1553	for(i=&yypParser->yystack[1]; i<=yypParser->yytos; i++){
1554	fprintf(yyTraceFILE,"%c%s", cDiv, yyTokenName[i->major]);
1555	cDiv = ' ';
1556	}
1557	fprintf(yyTraceFILE,"]\n");
1558	}
1559	#endif
1560	return;
1561	}
1562
1563	/*
1564	** Return the fallback token corresponding to canonical token iToken, or
1565	** 0 if iToken has no fallback.
1566	*/
1567	int ParseFallback(int iToken){
1568	#ifdef YYFALLBACK
1569	assert( iToken<(int)(sizeof(yyFallback)/sizeof(yyFallback[0])) );
1570	return yyFallback[iToken];
1571	#else
1572	(void)iToken;
1573	return 0;
1574	#endif
1575	}