/* This file is automatically generated by Lemon from input grammar

** source file "ua_eventfilter_grammar.y".

*/

/*

** 2000-05-29

**

** The author disclaims copyright to this source code.  In place of

** a legal notice, here is a blessing:

**

**    May you do good and not evil.

**    May you find forgiveness for yourself and forgive others.

**    May you share freely, never taking more than you give.

**

*************************************************************************

** Driver template for the LEMON parser generator.

**

** The "lemon" program processes an LALR(1) input grammar file, then uses

** this template to construct a parser.  The "lemon" program inserts text

** at each "%%" line.  Also, any "P-a-r-s-e" identifer prefix (without the

** interstitial "-" characters) contained in this template is changed into

** the value of the %name directive from the grammar.  Otherwise, the content

** of this template is copied straight through into the generate parser

** source file.

**

** The following is the concatenation of all %include directives from the

** input grammar file:

*/

/************ Begin %include sections from the grammar ************************/

#include <open62541/util.h>

#include "ua_eventfilter_parser.h"

#define UA_EventFilterParse_ENGINEALWAYSONSTACK 1

#define NDEBUG 1

/* Declare methods to prevent errors due to missing "static" keyword */

static void UA_EventFilterParseInit(void *);

static void UA_EventFilterParseFinalize(void *p);

int UA_EventFilterParseFallback(int iToken);

static void UA_EventFilterParse(void *yyp, int yymajor, Operand *token, EFParseContext *ctx);

/**************** End of %include directives **********************************/

/* These constants specify the various numeric values for terminal symbols.

***************** Begin token definitions *************************************/

#ifndef EF_TOK_AND

#define EF_TOK_AND                             1

#define EF_TOK_OR                              2

#define EF_TOK_BINARY_OP                       3

#define EF_TOK_BETWEEN                         4

#define EF_TOK_INLIST                          5

#define EF_TOK_UNARY_OP                        6

#define EF_TOK_SELECT                          7

#define EF_TOK_COMMA                           8

#define EF_TOK_WHERE                           9

#define EF_TOK_LPAREN                         10

#define EF_TOK_RPAREN                         11

#define EF_TOK_LITERAL                        12

#define EF_TOK_SAO                            13

#define EF_TOK_NAMEDOPERAND                   14

#define EF_TOK_LBRACKET                       15

#define EF_TOK_RBRACKET                       16

#define EF_TOK_FOR                            17

#define EF_TOK_COLONEQUAL                     18

#endif

/**************** End token definitions ***************************************/

/* The next sections is a series of control #defines.

** various aspects of the generated parser.

**    YYCODETYPE         is the data type used to store the integer codes

**                       that represent terminal and non-terminal symbols.

**                       "unsigned char" is used if there are fewer than

**                       256 symbols.  Larger types otherwise.

**    YYNOCODE           is a number of type YYCODETYPE that is not used for

**                       any terminal or nonterminal symbol.

**    YYFALLBACK         If defined, this indicates that one or more tokens

**                       (also known as: "terminal symbols") have fall-back

**                       values which should be used if the original symbol

**                       would not parse.  This permits keywords to sometimes

**                       be used as identifiers, for example.

**    YYACTIONTYPE       is the data type used for "action codes" - numbers

**                       that indicate what to do in response to the next

**                       token.

**    UA_EventFilterParseTOKENTYPE     is the data type used for minor type for terminal

**                       symbols.  Background: A "minor type" is a semantic

**                       value associated with a terminal or non-terminal

**                       symbols.  For example, for an "ID" terminal symbol,

**                       the minor type might be the name of the identifier.

**                       Each non-terminal can have a different minor type.

**                       Terminal symbols all have the same minor type, though.

**                       This macros defines the minor type for terminal 

**                       symbols.

**    YYMINORTYPE        is the data type used for all minor types.

**                       This is typically a union of many types, one of

**                       which is UA_EventFilterParseTOKENTYPE.  The entry in the union

**                       for terminal symbols is called "yy0".

**    YYSTACKDEPTH       is the maximum depth of the parser's stack.  If

**                       zero the stack is dynamically sized using realloc()

**    UA_EventFilterParseARG_SDECL     A static variable declaration for the %extra_argument

**    UA_EventFilterParseARG_PDECL     A parameter declaration for the %extra_argument

**    UA_EventFilterParseARG_PARAM     Code to pass %extra_argument as a subroutine parameter

**    UA_EventFilterParseARG_STORE     Code to store %extra_argument into yypParser

**    UA_EventFilterParseARG_FETCH     Code to extract %extra_argument from yypParser

**    UA_EventFilterParseCTX_*         As UA_EventFilterParseARG_ except for %extra_context

**    YYERRORSYMBOL      is the code number of the error symbol.  If not

**                       defined, then do no error processing.

**    YYNSTATE           the combined number of states.

**    YYNRULE            the number of rules in the grammar

**    YYNTOKEN           Number of terminal symbols

**    YY_MAX_SHIFT       Maximum value for shift actions

**    YY_MIN_SHIFTREDUCE Minimum value for shift-reduce actions

**    YY_MAX_SHIFTREDUCE Maximum value for shift-reduce actions

**    YY_ERROR_ACTION    The yy_action[] code for syntax error

**    YY_ACCEPT_ACTION   The yy_action[] code for accept

**    YY_NO_ACTION       The yy_action[] code for no-op

**    YY_MIN_REDUCE      Minimum value for reduce actions

**    YY_MAX_REDUCE      Maximum value for reduce actions

*/

#ifndef INTERFACE

# define INTERFACE 1

#endif

/************* Begin control #defines *****************************************/

#define YYCODETYPE unsigned char

#define YYNOCODE 29

#define YYACTIONTYPE unsigned char

#define UA_EventFilterParseTOKENTYPE  Operand * 

typedef union {

  int yyinit;

  UA_EventFilterParseTOKENTYPE yy0;

} YYMINORTYPE;

#ifndef YYSTACKDEPTH

#define YYSTACKDEPTH 100

#endif

#define UA_EventFilterParseARG_SDECL  EFParseContext *ctx ;

#define UA_EventFilterParseARG_PDECL , EFParseContext *ctx 

#define UA_EventFilterParseARG_PARAM ,ctx 

#define UA_EventFilterParseARG_FETCH  EFParseContext *ctx =yypParser->ctx ;

#define UA_EventFilterParseARG_STORE yypParser->ctx =ctx ;

#define UA_EventFilterParseCTX_SDECL

#define UA_EventFilterParseCTX_PDECL

#define UA_EventFilterParseCTX_PARAM

#define UA_EventFilterParseCTX_FETCH

#define UA_EventFilterParseCTX_STORE

#define YYNSTATE             34

#define YYNRULE              25

#define YYNRULE_WITH_ACTION  17

#define YYNTOKEN             19

#define YY_MAX_SHIFT         33

#define YY_MIN_SHIFTREDUCE   48

#define YY_MAX_SHIFTREDUCE   72

#define YY_ERROR_ACTION      73

#define YY_ACCEPT_ACTION     74

#define YY_NO_ACTION         75

#define YY_MIN_REDUCE        76

#define YY_MAX_REDUCE        100

/************* End control #defines *******************************************/

#define YY_NLOOKAHEAD ((int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])))

/* Define the yytestcase() macro to be a no-op if is not already defined

** otherwise.

**

** Applications can choose to define yytestcase() in the %include section

** to a macro that can assist in verifying code coverage.  For production

** code the yytestcase() macro should be turned off.  But it is useful

** for testing.

*/

#ifndef yytestcase

# define yytestcase(X)

#endif

/* Next are the tables used to determine what action to take based on the

** current state and lookahead token.  These tables are used to implement

** functions that take a state number and lookahead value and return an

** action integer.  

**

** Suppose the action integer is N.  Then the action is determined as

** follows

**

**   0 <= N <= YY_MAX_SHIFT             Shift N.  That is, push the lookahead

**                                      token onto the stack and goto state N.

**

**   N between YY_MIN_SHIFTREDUCE       Shift to an arbitrary state then

**     and YY_MAX_SHIFTREDUCE           reduce by rule N-YY_MIN_SHIFTREDUCE.

**

**   N == YY_ERROR_ACTION               A syntax error has occurred.

**

**   N == YY_ACCEPT_ACTION              The parser accepts its input.

**

**   N == YY_NO_ACTION                  No such action.  Denotes unused

**                                      slots in the yy_action[] table.

**

**   N between YY_MIN_REDUCE            Reduce by rule N-YY_MIN_REDUCE

**     and YY_MAX_REDUCE

**

** The action table is constructed as a single large table named yy_action[].

** Given state S and lookahead X, the action is computed as either:

**

**    (A)   N = yy_action[ yy_shift_ofst[S] + X ]

**    (B)   N = yy_default[S]

**

** The (A) formula is preferred.  The B formula is used instead if

** yy_lookahead[yy_shift_ofst[S]+X] is not equal to X.

**

** The formulas above are for computing the action when the lookahead is

** a terminal symbol.  If the lookahead is a non-terminal (as occurs after

** a reduce action) then the yy_reduce_ofst[] array is used in place of

** the yy_shift_ofst[] array.

**

** The following are the tables generated in this section:

**

**  yy_action[]        A single table containing all actions.

**  yy_lookahead[]     A table containing the lookahead for each entry in

**                     yy_action.  Used to detect hash collisions.

**  yy_shift_ofst[]    For each state, the offset into yy_action for

**                     shifting terminals.

**  yy_reduce_ofst[]   For each state, the offset into yy_action for

**                     shifting non-terminals after a reduce.

**  yy_default[]       Default action for each state.

**

*********** Begin parsing tables **********************************************/

#define YY_ACTTAB_COUNT (76)

static const YYACTIONTYPE yy_action[] = {

 /*     0 */   100,   11,    9,    8,   30,   29,   11,    9,    8,   30,

 /*    10 */    29,   74,   17,    6,   22,   80,   60,    1,   11,    9,

 /*    20 */     8,   30,   29,   23,   80,   10,   18,   80,   51,   12,

 /*    30 */    31,   53,   54,   55,   11,    9,    8,   30,   29,   19,

 /*    40 */    80,   32,   32,   26,   21,   80,   25,   28,   91,   33,

 /*    50 */    25,   28,   27,   87,   80,    5,   86,   80,   84,   80,

 /*    60 */    85,   80,   20,   80,   24,   80,   14,    4,   16,   61,

 /*    70 */     2,    3,    7,   13,   15,   93,

};

static const YYCODETYPE yy_lookahead[] = {

 /*     0 */    28,    1,    2,    3,    4,    5,    1,    2,    3,    4,

 /*    10 */     5,   19,   20,    8,   24,   25,   16,    7,    1,    2,

 /*    20 */     3,    4,    5,   24,   25,    6,   24,   25,   11,   10,

 /*    30 */    14,   12,   13,   14,    1,    2,    3,    4,    5,   24,

 /*    40 */    25,   27,   28,   23,   24,   25,   24,   25,   26,   22,

 /*    50 */    24,   25,   26,   24,   25,    9,   24,   25,   24,   25,

 /*    60 */    24,   25,   24,   25,   24,   25,   17,    8,   21,   16,

 /*    70 */     8,   15,   15,   18,    8,    0,   29,   29,   29,   29,

 /*    80 */    29,   29,   29,   29,   29,   29,   29,   29,   29,   29,

 /*    90 */    29,   29,   29,   29,   29,

};

#define YY_SHIFT_COUNT    (33)

#define YY_SHIFT_MIN      (0)

#define YY_SHIFT_MAX      (75)

static const unsigned char yy_shift_ofst[] = {

 /*     0 */    10,   19,   19,   19,   19,   19,   19,   19,   19,   19,

 /*    10 */    19,   19,   19,   19,   16,   16,   49,   46,    0,    5,

 /*    20 */    17,   33,   33,   33,   33,   33,   59,   53,   62,   56,

 /*    30 */    57,   55,   66,   75,

};

#define YY_REDUCE_COUNT (17)

#define YY_REDUCE_MIN   (-28)

#define YY_REDUCE_MAX   (47)

static const signed char yy_reduce_ofst[] = {

 /*     0 */    -8,   20,   22,   26,  -10,   -1,    2,   15,   29,   32,

 /*    10 */    34,   36,   38,   40,   14,  -28,   27,   47,

};

static const YYACTIONTYPE yy_default[] = {

 /*     0 */    94,   73,   73,   73,   73,   73,   73,   73,   73,   73,

 /*    10 */    73,   73,   73,   73,   73,   73,   97,   96,   73,   73,

 /*    20 */    73,   76,   77,   78,   92,   90,   95,   73,   80,   73,

 /*    30 */    73,   73,   98,   73,

};

/********** End of lemon-generated parsing tables *****************************/

/* The next table maps tokens (terminal symbols) into fallback tokens.  

** If a construct like the following:

** 

**      %fallback ID X Y Z.

**

** appears in the grammar, then ID becomes a fallback token for X, Y,

** and Z.  Whenever one of the tokens X, Y, or Z is input to the parser

** but it does not parse, the type of the token is changed to ID and

** the parse is retried before an error is thrown.

**

** This feature can be used, for example, to cause some keywords in a language

** to revert to identifiers if they keyword does not apply in the context where

** it appears.

*/

#ifdef YYFALLBACK

static const YYCODETYPE yyFallback[] = {

};

#endif /* YYFALLBACK */

/* The following structure represents a single element of the

** parser's stack.  Information stored includes:

**

**   +  The state number for the parser at this level of the stack.

**

**   +  The value of the token stored at this level of the stack.

**      (In other words, the "major" token.)

**

**   +  The semantic value stored at this level of the stack.  This is

**      the information used by the action routines in the grammar.

**      It is sometimes called the "minor" token.

**

** After the "shift" half of a SHIFTREDUCE action, the stateno field

** actually contains the reduce action for the second half of the

** SHIFTREDUCE.

*/

struct yyStackEntry {

  YYACTIONTYPE stateno;  /* The state-number, or reduce action in SHIFTREDUCE */

  YYCODETYPE major;      /* The major token value.  This is the code

                         ** number for the token at this stack level */

  YYMINORTYPE minor;     /* The user-supplied minor token value.  This

                         ** is the value of the token  */

};

typedef struct yyStackEntry yyStackEntry;

/* The state of the parser is completely contained in an instance of

** the following structure */

struct yyParser {

  yyStackEntry *yytos;          /* Pointer to top element of the stack */

#ifdef YYTRACKMAXSTACKDEPTH

  int yyhwm;                    /* High-water mark of the stack */

#endif

#ifndef YYNOERRORRECOVERY

  int yyerrcnt;                 /* Shifts left before out of the error */

#endif

  UA_EventFilterParseARG_SDECL                /* A place to hold %extra_argument */

  UA_EventFilterParseCTX_SDECL                /* A place to hold %extra_context */

#if YYSTACKDEPTH<=0

  int yystksz;                  /* Current side of the stack */

  yyStackEntry *yystack;        /* The parser's stack */

  yyStackEntry yystk0;          /* First stack entry */

#else

  yyStackEntry yystack[YYSTACKDEPTH];  /* The parser's stack */

  yyStackEntry *yystackEnd;            /* Last entry in the stack */

#endif

};

typedef struct yyParser yyParser;

#include <assert.h>

#ifndef NDEBUG

#include <stdio.h>

static FILE *yyTraceFILE = 0;

static char *yyTracePrompt = 0;

#endif /* NDEBUG */

#ifndef NDEBUG

/* 

** Turn parser tracing on by giving a stream to which to write the trace

** and a prompt to preface each trace message.  Tracing is turned off

** by making either argument NULL 

**

** Inputs:

** <ul>

** <li> A FILE* to which trace output should be written.

**      If NULL, then tracing is turned off.

** <li> A prefix string written at the beginning of every

**      line of trace output.  If NULL, then tracing is

**      turned off.

** </ul>

**

** Outputs:

** None.

*/

void UA_EventFilterParseTrace(FILE *TraceFILE, char *zTracePrompt){

  yyTraceFILE = TraceFILE;

  yyTracePrompt = zTracePrompt;

  if( yyTraceFILE==0 ) yyTracePrompt = 0;

  else if( yyTracePrompt==0 ) yyTraceFILE = 0;

}

#endif /* NDEBUG */

#if defined(YYCOVERAGE) || !defined(NDEBUG)

/* For tracing shifts, the names of all terminals and nonterminals

** are required.  The following table supplies these names */

static const char *const yyTokenName[] = { 

  /*    0 */ "$",

  /*    1 */ "AND",

  /*    2 */ "OR",

  /*    3 */ "BINARY_OP",

  /*    4 */ "BETWEEN",

  /*    5 */ "INLIST",

  /*    6 */ "UNARY_OP",

  /*    7 */ "SELECT",

  /*    8 */ "COMMA",

  /*    9 */ "WHERE",

  /*   10 */ "LPAREN",

  /*   11 */ "RPAREN",

  /*   12 */ "LITERAL",

  /*   13 */ "SAO",

  /*   14 */ "NAMEDOPERAND",

  /*   15 */ "LBRACKET",

  /*   16 */ "RBRACKET",

  /*   17 */ "FOR",

  /*   18 */ "COLONEQUAL",

  /*   19 */ "eventFilter",

  /*   20 */ "selectClause",

  /*   21 */ "whereClause",

  /*   22 */ "forClause",

  /*   23 */ "selectClauseList",

  /*   24 */ "operand",

  /*   25 */ "operator",

  /*   26 */ "operandList",

  /*   27 */ "namedOperandAssignmentList",

  /*   28 */ "namedOperandAssignment",

};

#endif /* defined(YYCOVERAGE) || !defined(NDEBUG) */

#ifndef NDEBUG

/* For tracing reduce actions, the names of all rules are required.

*/

static const char *const yyRuleName[] = {

 /*   0 */ "selectClauseList ::= operand",

 /*   1 */ "selectClauseList ::= selectClauseList COMMA operand",

 /*   2 */ "whereClause ::= WHERE operand",

 /*   3 */ "operand ::= LPAREN operand RPAREN",

 /*   4 */ "operand ::= operator",

 /*   5 */ "operand ::= LITERAL",

 /*   6 */ "operand ::= SAO",

 /*   7 */ "operand ::= NAMEDOPERAND",

 /*   8 */ "operator ::= UNARY_OP operand",

 /*   9 */ "operator ::= operand AND operand",

 /*  10 */ "operator ::= operand OR operand",

 /*  11 */ "operator ::= operand BINARY_OP operand",

 /*  12 */ "operator ::= operand BETWEEN LBRACKET operand COMMA operand RBRACKET",

 /*  13 */ "operator ::= operand INLIST LBRACKET operandList RBRACKET",

 /*  14 */ "operandList ::= operand",

 /*  15 */ "operandList ::= operator COMMA operandList",

 /*  16 */ "namedOperandAssignment ::= NAMEDOPERAND COLONEQUAL operand",

 /*  17 */ "eventFilter ::= selectClause whereClause forClause",

 /*  18 */ "selectClause ::=",

 /*  19 */ "selectClause ::= SELECT selectClauseList",

 /*  20 */ "whereClause ::=",

 /*  21 */ "forClause ::=",

 /*  22 */ "forClause ::= FOR namedOperandAssignmentList",

 /*  23 */ "namedOperandAssignmentList ::= namedOperandAssignment",

 /*  24 */ "namedOperandAssignmentList ::= namedOperandAssignmentList COMMA namedOperandAssignment",

};

#endif /* NDEBUG */

#if YYSTACKDEPTH<=0

/*

** Try to increase the size of the parser stack.  Return the number

** of errors.  Return 0 on success.

*/

static int yyGrowStack(yyParser *p){

  int newSize;

  int idx;

  yyStackEntry *pNew;

  newSize = p->yystksz*2 + 100;

  idx = p->yytos ? (int)(p->yytos - p->yystack) : 0;

  if( p->yystack==&p->yystk0 ){

    pNew = malloc(newSize*sizeof(pNew[0]));

    if( pNew ) pNew[0] = p->yystk0;

  }else{

    pNew = realloc(p->yystack, newSize*sizeof(pNew[0]));

  }

  if( pNew ){

    p->yystack = pNew;

    p->yytos = &p->yystack[idx];

#ifndef NDEBUG

    if( yyTraceFILE ){

      fprintf(yyTraceFILE,"%sStack grows from %d to %d entries.\n",

              yyTracePrompt, p->yystksz, newSize);

    }

#endif

    p->yystksz = newSize;

  }

  return pNew==0; 

}

#endif

/* Datatype of the argument to the memory allocated passed as the

** second argument to UA_EventFilterParseAlloc() below.  This can be changed by

** putting an appropriate #define in the %include section of the input

** grammar.

*/

#ifndef YYMALLOCARGTYPE

# define YYMALLOCARGTYPE size_t

#endif

/* Initialize a new parser that has already been allocated.

*/

void UA_EventFilterParseInit(void *yypRawParser UA_EventFilterParseCTX_PDECL){

  yyParser *yypParser = (yyParser*)yypRawParser;

  UA_EventFilterParseCTX_STORE

#ifdef YYTRACKMAXSTACKDEPTH

  yypParser->yyhwm = 0;

#endif

#if YYSTACKDEPTH<=0

  yypParser->yytos = NULL;

  yypParser->yystack = NULL;

  yypParser->yystksz = 0;

  if( yyGrowStack(yypParser) ){

    yypParser->yystack = &yypParser->yystk0;

    yypParser->yystksz = 1;

  }

#endif

#ifndef YYNOERRORRECOVERY

  yypParser->yyerrcnt = -1;

#endif

  yypParser->yytos = yypParser->yystack;

  yypParser->yystack[0].stateno = 0;

  yypParser->yystack[0].major = 0;

#if YYSTACKDEPTH>0

  yypParser->yystackEnd = &yypParser->yystack[YYSTACKDEPTH-1];

#endif

}

#ifndef UA_EventFilterParse_ENGINEALWAYSONSTACK

/* 

** This function allocates a new parser.

** The only argument is a pointer to a function which works like

** malloc.

**

** Inputs:

** A pointer to the function used to allocate memory.

**

** Outputs:

** A pointer to a parser.  This pointer is used in subsequent calls

** to UA_EventFilterParse and UA_EventFilterParseFree.

*/

void *UA_EventFilterParseAlloc(void *(*mallocProc)(YYMALLOCARGTYPE) UA_EventFilterParseCTX_PDECL){

  yyParser *yypParser;

  yypParser = (yyParser*)(*mallocProc)( (YYMALLOCARGTYPE)sizeof(yyParser) );

  if( yypParser ){

    UA_EventFilterParseCTX_STORE

    UA_EventFilterParseInit(yypParser UA_EventFilterParseCTX_PARAM);

  }

  return (void*)yypParser;

}

#endif /* UA_EventFilterParse_ENGINEALWAYSONSTACK */

/* The following function deletes the "minor type" or semantic value

** associated with a symbol.  The symbol can be either a terminal

** or nonterminal. "yymajor" is the symbol code, and "yypminor" is

** a pointer to the value to be deleted.  The code used to do the 

** deletions is derived from the %destructor and/or %token_destructor

** directives of the input grammar.

*/

static void yy_destructor(

  yyParser *yypParser,    /* The parser */

  YYCODETYPE yymajor,     /* Type code for object to destroy */

  YYMINORTYPE *yypminor   /* The object to be destroyed */

){

  UA_EventFilterParseARG_FETCH

  UA_EventFilterParseCTX_FETCH

  switch( yymajor ){

    /* Here is inserted the actions which take place when a

    ** terminal or non-terminal is destroyed.  This can happen

    ** when the symbol is popped from the stack during a

    ** reduce or during error processing or when a parser is 

    ** being destroyed before it is finished parsing.

    **

    ** Note: during a reduce, the only symbols destroyed are those

    ** which appear on the RHS of the rule, but which are *not* used

    ** inside the C code.

    */

/********* Begin destructor definitions ***************************************/

      /* TERMINAL Destructor */

    case 1: /* AND */

    case 2: /* OR */

    case 3: /* BINARY_OP */

    case 4: /* BETWEEN */

    case 5: /* INLIST */

    case 6: /* UNARY_OP */

    case 7: /* SELECT */

    case 8: /* COMMA */

    case 9: /* WHERE */

    case 10: /* LPAREN */

    case 11: /* RPAREN */

    case 12: /* LITERAL */

    case 13: /* SAO */

    case 14: /* NAMEDOPERAND */

    case 15: /* LBRACKET */

    case 16: /* RBRACKET */

    case 17: /* FOR */

    case 18: /* COLONEQUAL */

{

 (void)ctx; 

}

      break;

/********* End destructor definitions *****************************************/

    default:  break;   /* If no destructor action specified: do nothing */

  }

}

/*

** Pop the parser's stack once.

**

** If there is a destructor routine associated with the token which

** is popped from the stack, then call it.

*/

static void yy_pop_parser_stack(yyParser *pParser){

  yyStackEntry *yytos;

  assert( pParser->yytos!=0 );

  assert( pParser->yytos > pParser->yystack );

  yytos = pParser->yytos--;

#ifndef NDEBUG

  if( yyTraceFILE ){

    fprintf(yyTraceFILE,"%sPopping %s\n",

      yyTracePrompt,

      yyTokenName[yytos->major]);

  }

#endif

  yy_destructor(pParser, yytos->major, &yytos->minor);

}

/*

** Clear all secondary memory allocations from the parser

*/

void UA_EventFilterParseFinalize(void *p){

  yyParser *pParser = (yyParser*)p;

  while( pParser->yytos>pParser->yystack ) yy_pop_parser_stack(pParser);

#if YYSTACKDEPTH<=0

  if( pParser->yystack!=&pParser->yystk0 ) free(pParser->yystack);

#endif

}

#ifndef UA_EventFilterParse_ENGINEALWAYSONSTACK

/* 

** Deallocate and destroy a parser.  Destructors are called for

** all stack elements before shutting the parser down.

**

** If the YYPARSEFREENEVERNULL macro exists (for example because it

** is defined in a %include section of the input grammar) then it is

** assumed that the input pointer is never NULL.

*/

void UA_EventFilterParseFree(

  void *p,                    /* The parser to be deleted */

  void (*freeProc)(void*)     /* Function used to reclaim memory */

){

#ifndef YYPARSEFREENEVERNULL

  if( p==0 ) return;

#endif

  UA_EventFilterParseFinalize(p);

  (*freeProc)(p);

}

#endif /* UA_EventFilterParse_ENGINEALWAYSONSTACK */

/*

** Return the peak depth of the stack for a parser.

*/

#ifdef YYTRACKMAXSTACKDEPTH

int UA_EventFilterParseStackPeak(void *p){

  yyParser *pParser = (yyParser*)p;

  return pParser->yyhwm;

}

#endif

/* This array of booleans keeps track of the parser statement

** coverage.  The element yycoverage[X][Y] is set when the parser

** is in state X and has a lookahead token Y.  In a well-tested

** systems, every element of this matrix should end up being set.

*/

#if defined(YYCOVERAGE)

static unsigned char yycoverage[YYNSTATE][YYNTOKEN];

#endif

/*

** Write into out a description of every state/lookahead combination that

**

**   (1)  has not been used by the parser, and

**   (2)  is not a syntax error.

**

** Return the number of missed state/lookahead combinations.

*/

#if defined(YYCOVERAGE)

int UA_EventFilterParseCoverage(FILE *out){

  int stateno, iLookAhead, i;

  int nMissed = 0;

  for(stateno=0; stateno<YYNSTATE; stateno++){

    i = yy_shift_ofst[stateno];

    for(iLookAhead=0; iLookAhead<YYNTOKEN; iLookAhead++){

      if( yy_lookahead[i+iLookAhead]!=iLookAhead ) continue;

      if( yycoverage[stateno][iLookAhead]==0 ) nMissed++;

      if( out ){

        fprintf(out,"State %d lookahead %s %s\n", stateno,

                yyTokenName[iLookAhead],

                yycoverage[stateno][iLookAhead] ? "ok" : "missed");

      }

    }

  }

  return nMissed;

}

#endif

/*

** Find the appropriate action for a parser given the terminal

** look-ahead token iLookAhead.

*/

static YYACTIONTYPE yy_find_shift_action(

  YYCODETYPE iLookAhead,    /* The look-ahead token */

  YYACTIONTYPE stateno      /* Current state number */

){

  int i;

  if( stateno>YY_MAX_SHIFT ) return stateno;

  assert( stateno <= YY_SHIFT_COUNT );

#if defined(YYCOVERAGE)

  yycoverage[stateno][iLookAhead] = 1;

#endif

  do{

    i = yy_shift_ofst[stateno];

    assert( i>=0 );

    assert( i<=YY_ACTTAB_COUNT );

    assert( i+YYNTOKEN<=(int)YY_NLOOKAHEAD );

    assert( iLookAhead!=YYNOCODE );

    assert( iLookAhead < YYNTOKEN );

    i += iLookAhead;

    assert( i<(int)YY_NLOOKAHEAD );

    if( yy_lookahead[i]!=iLookAhead ){

#ifdef YYFALLBACK

      YYCODETYPE iFallback;            /* Fallback token */

      assert( iLookAhead<sizeof(yyFallback)/sizeof(yyFallback[0]) );

      iFallback = yyFallback[iLookAhead];

      if( iFallback!=0 ){

#ifndef NDEBUG

        if( yyTraceFILE ){

          fprintf(yyTraceFILE, "%sFALLBACK %s => %s\n",

             yyTracePrompt, yyTokenName[iLookAhead], yyTokenName[iFallback]);

        }

#endif

        assert( yyFallback[iFallback]==0 ); /* Fallback loop must terminate */

        iLookAhead = iFallback;

        continue;

      }

#endif

#ifdef YYWILDCARD

      {

        int j = i - iLookAhead + YYWILDCARD;

        assert( j<(int)(sizeof(yy_lookahead)/sizeof(yy_lookahead[0])) );

        if( yy_lookahead[j]==YYWILDCARD && iLookAhead>0 ){

#ifndef NDEBUG

          if( yyTraceFILE ){

            fprintf(yyTraceFILE, "%sWILDCARD %s => %s\n",

               yyTracePrompt, yyTokenName[iLookAhead],

               yyTokenName[YYWILDCARD]);

          }

#endif /* NDEBUG */

          return yy_action[j];

        }

      }

#endif /* YYWILDCARD */

      return yy_default[stateno];

    }else{

      assert( i>=0 && i<(int)(sizeof(yy_action)/sizeof(yy_action[0])) );

      return yy_action[i];

    }

  }while(1);

}

/*

** Find the appropriate action for a parser given the non-terminal

** look-ahead token iLookAhead.

*/

static YYACTIONTYPE yy_find_reduce_action(

  YYACTIONTYPE stateno,     /* Current state number */

  YYCODETYPE iLookAhead     /* The look-ahead token */

){

  int i;

#ifdef YYERRORSYMBOL

  if( stateno>YY_REDUCE_COUNT ){

    return yy_default[stateno];

  }

#else

  assert( stateno<=YY_REDUCE_COUNT );

#endif

  i = yy_reduce_ofst[stateno];

  assert( iLookAhead!=YYNOCODE );

  i += iLookAhead;

#ifdef YYERRORSYMBOL

  if( i<0 || i>=YY_ACTTAB_COUNT || yy_lookahead[i]!=iLookAhead ){

    return yy_default[stateno];

  }

#else

  assert( i>=0 && i<YY_ACTTAB_COUNT );

  assert( yy_lookahead[i]==iLookAhead );

#endif

  return yy_action[i];

}

/*

** The following routine is called if the stack overflows.

*/

static void yyStackOverflow(yyParser *yypParser){

   UA_EventFilterParseARG_FETCH

   UA_EventFilterParseCTX_FETCH

#ifndef NDEBUG

   if( yyTraceFILE ){

     fprintf(yyTraceFILE,"%sStack Overflow!\n",yyTracePrompt);

   }

#endif

   while( yypParser->yytos>yypParser->yystack ) yy_pop_parser_stack(yypParser);

   /* Here code is inserted which will execute if the parser

   ** stack every overflows */

/******** Begin %stack_overflow code ******************************************/

/******** End %stack_overflow code ********************************************/

   UA_EventFilterParseARG_STORE /* Suppress warning about unused %extra_argument var */

   UA_EventFilterParseCTX_STORE

}

/*

** Print tracing information for a SHIFT action

*/

#ifndef NDEBUG

static void yyTraceShift(yyParser *yypParser, int yyNewState, const char *zTag){

  if( yyTraceFILE ){

    if( yyNewState<YYNSTATE ){

      fprintf(yyTraceFILE,"%s%s '%s', go to state %d\n",

         yyTracePrompt, zTag, yyTokenName[yypParser->yytos->major],

         yyNewState);

    }else{

      fprintf(yyTraceFILE,"%s%s '%s', pending reduce %d\n",

         yyTracePrompt, zTag, yyTokenName[yypParser->yytos->major],

         yyNewState - YY_MIN_REDUCE);

    }

  }

}

#else

# define yyTraceShift(X,Y,Z)

#endif

/*

** Perform a shift action.

*/

static void yy_shift(

  yyParser *yypParser,          /* The parser to be shifted */

  YYACTIONTYPE yyNewState,      /* The new state to shift in */

  YYCODETYPE yyMajor,           /* The major token to shift in */

  UA_EventFilterParseTOKENTYPE yyMinor        /* The minor token to shift in */

){

  yyStackEntry *yytos;

  yypParser->yytos++;

#ifdef YYTRACKMAXSTACKDEPTH

  if( (int)(yypParser->yytos - yypParser->yystack)>yypParser->yyhwm ){

    yypParser->yyhwm++;

    assert( yypParser->yyhwm == (int)(yypParser->yytos - yypParser->yystack) );

  }

#endif

#if YYSTACKDEPTH>0 

  if( yypParser->yytos>yypParser->yystackEnd ){

    yypParser->yytos--;

    yyStackOverflow(yypParser);

    return;

  }

#else

  if( yypParser->yytos>=&yypParser->yystack[yypParser->yystksz] ){

    if( yyGrowStack(yypParser) ){

      yypParser->yytos--;

      yyStackOverflow(yypParser);

      return;

    }

  }

#endif

  if( yyNewState > YY_MAX_SHIFT ){

    yyNewState += YY_MIN_REDUCE - YY_MIN_SHIFTREDUCE;

  }

  yytos = yypParser->yytos;

  yytos->stateno = yyNewState;

  yytos->major = yyMajor;

  yytos->minor.yy0 = yyMinor;

  yyTraceShift(yypParser, yyNewState, "Shift");

}

/* For rule J, yyRuleInfoLhs[J] contains the symbol on the left-hand side

** of that rule */

static const YYCODETYPE yyRuleInfoLhs[] = {

    23,  /* (0) selectClauseList ::= operand */

    23,  /* (1) selectClauseList ::= selectClauseList COMMA operand */

    21,  /* (2) whereClause ::= WHERE operand */

    24,  /* (3) operand ::= LPAREN operand RPAREN */

    24,  /* (4) operand ::= operator */

    24,  /* (5) operand ::= LITERAL */

    24,  /* (6) operand ::= SAO */

    24,  /* (7) operand ::= NAMEDOPERAND */

    25,  /* (8) operator ::= UNARY_OP operand */

    25,  /* (9) operator ::= operand AND operand */

    25,  /* (10) operator ::= operand OR operand */

    25,  /* (11) operator ::= operand BINARY_OP operand */

    25,  /* (12) operator ::= operand BETWEEN LBRACKET operand COMMA operand RBRACKET */

    25,  /* (13) operator ::= operand INLIST LBRACKET operandList RBRACKET */

    26,  /* (14) operandList ::= operand */

    26,  /* (15) operandList ::= operator COMMA operandList */

    28,  /* (16) namedOperandAssignment ::= NAMEDOPERAND COLONEQUAL operand */

    19,  /* (17) eventFilter ::= selectClause whereClause forClause */

    20,  /* (18) selectClause ::= */

    20,  /* (19) selectClause ::= SELECT selectClauseList */

    21,  /* (20) whereClause ::= */

    22,  /* (21) forClause ::= */

    22,  /* (22) forClause ::= FOR namedOperandAssignmentList */

    27,  /* (23) namedOperandAssignmentList ::= namedOperandAssignment */

    27,  /* (24) namedOperandAssignmentList ::= namedOperandAssignmentList COMMA namedOperandAssignment */

};

/* For rule J, yyRuleInfoNRhs[J] contains the negative of the number

** of symbols on the right-hand side of that rule. */

static const signed char yyRuleInfoNRhs[] = {

   -1,  /* (0) selectClauseList ::= operand */

   -3,  /* (1) selectClauseList ::= selectClauseList COMMA operand */

   -2,  /* (2) whereClause ::= WHERE operand */

   -3,  /* (3) operand ::= LPAREN operand RPAREN */

   -1,  /* (4) operand ::= operator */

   -1,  /* (5) operand ::= LITERAL */

   -1,  /* (6) operand ::= SAO */

   -1,  /* (7) operand ::= NAMEDOPERAND */

   -2,  /* (8) operator ::= UNARY_OP operand */

   -3,  /* (9) operator ::= operand AND operand */

   -3,  /* (10) operator ::= operand OR operand */

   -3,  /* (11) operator ::= operand BINARY_OP operand */

   -7,  /* (12) operator ::= operand BETWEEN LBRACKET operand COMMA operand RBRACKET */

   -5,  /* (13) operator ::= operand INLIST LBRACKET operandList RBRACKET */

   -1,  /* (14) operandList ::= operand */

   -3,  /* (15) operandList ::= operator COMMA operandList */

   -3,  /* (16) namedOperandAssignment ::= NAMEDOPERAND COLONEQUAL operand */

   -3,  /* (17) eventFilter ::= selectClause whereClause forClause */

    0,  /* (18) selectClause ::= */

   -2,  /* (19) selectClause ::= SELECT selectClauseList */

    0,  /* (20) whereClause ::= */

    0,  /* (21) forClause ::= */

   -2,  /* (22) forClause ::= FOR namedOperandAssignmentList */

   -1,  /* (23) namedOperandAssignmentList ::= namedOperandAssignment */

   -3,  /* (24) namedOperandAssignmentList ::= namedOperandAssignmentList COMMA namedOperandAssignment */

};

static void yy_accept(yyParser*);  /* Forward Declaration */

/*

** Perform a reduce action and the shift that must immediately

** follow the reduce.

**

** The yyLookahead and yyLookaheadToken parameters provide reduce actions

** access to the lookahead token (if any).  The yyLookahead will be YYNOCODE

** if the lookahead token has already been consumed.  As this procedure is

** only called from one place, optimizing compilers will in-line it, which

** means that the extra parameters have no performance impact.

*/

static YYACTIONTYPE yy_reduce(

  yyParser *yypParser,         /* The parser */

  unsigned int yyruleno,       /* Number of the rule by which to reduce */

  int yyLookahead,             /* Lookahead token, or YYNOCODE if none */

  UA_EventFilterParseTOKENTYPE yyLookaheadToken  /* Value of the lookahead token */

  UA_EventFilterParseCTX_PDECL                   /* %extra_context */

){

  int yygoto;                     /* The next state */

  YYACTIONTYPE yyact;             /* The next action */

  yyStackEntry *yymsp;            /* The top of the parser's stack */

  int yysize;                     /* Amount to pop the stack */

  UA_EventFilterParseARG_FETCH

  (void)yyLookahead;

  (void)yyLookaheadToken;

  yymsp = yypParser->yytos;

  switch( yyruleno ){

  /* Beginning here are the reduction cases.  A typical example

  ** follows:

  **   case 0:

  **  #line <lineno> <grammarfile>

  **     { ... }           // User supplied code

  **  #line <lineno> <thisfile>

  **     break;

  */

/********** Begin reduce actions **********************************************/

        YYMINORTYPE yylhsminor;

      case 0: /* selectClauseList ::= operand */

{ append_select(ctx, yymsp[0].minor.yy0); }

        break;

      case 1: /* selectClauseList ::= selectClauseList COMMA operand */

{ append_select(ctx, yymsp[0].minor.yy0); }

  yy_destructor(yypParser,8,&yymsp[-1].minor);

        break;

      case 2: /* whereClause ::= WHERE operand */

{  yy_destructor(yypParser,9,&yymsp[-1].minor);

{ ctx->top = yymsp[0].minor.yy0; }

}

        break;

      case 3: /* operand ::= LPAREN operand RPAREN */

{  yy_destructor(yypParser,10,&yymsp[-2].minor);

{ yymsp[-2].minor.yy0 = yymsp[-1].minor.yy0; }

  yy_destructor(yypParser,11,&yymsp[0].minor);

}

        break;

      case 4: /* operand ::= operator */

      case 5: /* operand ::= LITERAL */ yytestcase(yyruleno==5);

      case 6: /* operand ::= SAO */ yytestcase(yyruleno==6);

      case 7: /* operand ::= NAMEDOPERAND */ yytestcase(yyruleno==7);

      case 14: /* operandList ::= operand */ yytestcase(yyruleno==14);

{ yylhsminor.yy0 = yymsp[0].minor.yy0; }

  yymsp[0].minor.yy0 = yylhsminor.yy0;

        break;

      case 8: /* operator ::= UNARY_OP operand */

{ yylhsminor.yy0 = yymsp[-1].minor.yy0; append_operand(yylhsminor.yy0, yymsp[0].minor.yy0); }

  yymsp[-1].minor.yy0 = yylhsminor.yy0;

        break;

      case 9: /* operator ::= operand AND operand */

      case 10: /* operator ::= operand OR operand */ yytestcase(yyruleno==10);

      case 11: /* operator ::= operand BINARY_OP operand */ yytestcase(yyruleno==11);

{ yylhsminor.yy0 = yymsp[-1].minor.yy0; append_operand(yylhsminor.yy0, yymsp[-2].minor.yy0), append_operand(yylhsminor.yy0, yymsp[0].minor.yy0); }

  yymsp[-2].minor.yy0 = yylhsminor.yy0;

        break;

      case 12: /* operator ::= operand BETWEEN LBRACKET operand COMMA operand RBRACKET */

{ yylhsminor.yy0 = yymsp[-5].minor.yy0; append_operand(yylhsminor.yy0, yymsp[-6].minor.yy0); append_operand(yylhsminor.yy0, yymsp[-3].minor.yy0); append_operand(yylhsminor.yy0, yymsp[-1].minor.yy0); }

  yy_destructor(yypParser,15,&yymsp[-4].minor);

  yy_destructor(yypParser,8,&yymsp[-2].minor);

  yy_destructor(yypParser,16,&yymsp[0].minor);

  yymsp[-6].minor.yy0 = yylhsminor.yy0;

        break;

      case 13: /* operator ::= operand INLIST LBRACKET operandList RBRACKET */

{ yylhsminor.yy0 = yymsp[-3].minor.yy0; append_operand(yylhsminor.yy0, yymsp[-4].minor.yy0); while(yymsp[-1].minor.yy0) { append_operand(yylhsminor.yy0, yymsp[-1].minor.yy0); yymsp[-1].minor.yy0 = yymsp[-1].minor.yy0->next; } }

  yy_destructor(yypParser,15,&yymsp[-2].minor);

  yy_destructor(yypParser,16,&yymsp[0].minor);

  yymsp[-4].minor.yy0 = yylhsminor.yy0;

        break;

      case 15: /* operandList ::= operator COMMA operandList */

{ yylhsminor.yy0 = yymsp[-2].minor.yy0; yymsp[-2].minor.yy0->next = yymsp[0].minor.yy0; }

  yy_destructor(yypParser,8,&yymsp[-1].minor);

  yymsp[-2].minor.yy0 = yylhsminor.yy0;

        break;

      case 16: /* namedOperandAssignment ::= NAMEDOPERAND COLONEQUAL operand */

{ yymsp[0].minor.yy0->ref = save_string(yymsp[-2].minor.yy0->operand.ref); }

  yy_destructor(yypParser,18,&yymsp[-1].minor);

        break;

      case 19: /* selectClause ::= SELECT selectClauseList */

{  yy_destructor(yypParser,7,&yymsp[-1].minor);

{

}

}

        break;

      case 22: /* forClause ::= FOR namedOperandAssignmentList */

{  yy_destructor(yypParser,17,&yymsp[-1].minor);

{

}

}

        break;

      case 24: /* namedOperandAssignmentList ::= namedOperandAssignmentList COMMA namedOperandAssignment */

{

}

  yy_destructor(yypParser,8,&yymsp[-1].minor);

        break;

      default:

      /* (17) eventFilter ::= selectClause whereClause forClause */ yytestcase(yyruleno==17);

      /* (18) selectClause ::= */ yytestcase(yyruleno==18);

      /* (20) whereClause ::= */ yytestcase(yyruleno==20);

      /* (21) forClause ::= */ yytestcase(yyruleno==21);

      /* (23) namedOperandAssignmentList ::= namedOperandAssignment (OPTIMIZED OUT) */ assert(yyruleno!=23);

        break;

/********** End reduce actions ************************************************/

  };

  assert( yyruleno<sizeof(yyRuleInfoLhs)/sizeof(yyRuleInfoLhs[0]) );

  yygoto = yyRuleInfoLhs[yyruleno];

  yysize = yyRuleInfoNRhs[yyruleno];

  yyact = yy_find_reduce_action(yymsp[yysize].stateno,(YYCODETYPE)yygoto);

  /* There are no SHIFTREDUCE actions on nonterminals because the table

  ** generator has simplified them to pure REDUCE actions. */

  assert( !(yyact>YY_MAX_SHIFT && yyact<=YY_MAX_SHIFTREDUCE) );

  /* It is not possible for a REDUCE to be followed by an error */

  assert( yyact!=YY_ERROR_ACTION );

  yymsp += yysize+1;

  yypParser->yytos = yymsp;

  yymsp->stateno = (YYACTIONTYPE)yyact;

  yymsp->major = (YYCODETYPE)yygoto;