Return to wqlyaccinc.c CVS log

Up to [OMI] / omi / wql

Initial Import

/*
**==============================================================================
**
** Open Management Infrastructure (OMI)
**
** Copyright (c) Microsoft Corporation
** 
** Licensed under the Apache License, Version 2.0 (the "License"); you may not 
** use this file except in compliance with the License. You may obtain a copy 
** of the License at 
**
**     http://www.apache.org/licenses/LICENSE-2.0 
**
** THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
** KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED 
** WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, 
** MERCHANTABLITY OR NON-INFRINGEMENT. 
**
** See the Apache 2 License for the specific language governing permissions 
** and limitations under the License.
**
**==============================================================================
*/

#ifndef lint
static const char yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93";
#endif

#define YYBYACC 1
#define YYMAJOR 1
#define YYMINOR 9
#define YYPATCH 20110908

#define YYEMPTY        (-1)
#define yyclearin      (yychar = YYEMPTY)
#define yyerrok        (yyerrflag = 0)
#define YYRECOVERING() (yyerrflag != 0)


#ifndef yyparse
#define yyparse    wqlparse
#endif /* yyparse */

#ifndef yylex
#define yylex      wqllex
#endif /* yylex */

#ifndef yyerror
#define yyerror    wqlerror
#endif /* yyerror */

#ifndef yychar
#define yychar     wqlchar
#endif /* yychar */

#ifndef yyval
#define yyval      wqlval
#endif /* yyval */

#ifndef yylval
#define yylval     wqllval
#endif /* yylval */

#ifndef yydebug
#define yydebug    wqldebug
#endif /* yydebug */

#ifndef yynerrs
#define yynerrs    wqlnerrs
#endif /* yynerrs */

#ifndef yyerrflag
#define yyerrflag  wqlerrflag
#endif /* yyerrflag */

#ifndef yylhs
#define yylhs      wqllhs
#endif /* yylhs */

#ifndef yylen
#define yylen      wqllen
#endif /* yylen */

#ifndef yydefred
#define yydefred   wqldefred
#endif /* yydefred */

#ifndef yydgoto
#define yydgoto    wqldgoto
#endif /* yydgoto */

#ifndef yysindex
#define yysindex   wqlsindex
#endif /* yysindex */

#ifndef yyrindex
#define yyrindex   wqlrindex
#endif /* yyrindex */

#ifndef yygindex
#define yygindex   wqlgindex
#endif /* yygindex */

#ifndef yytable
#define yytable    wqltable
#endif /* yytable */

#ifndef yycheck
#define yycheck    wqlcheck
#endif /* yycheck */

#ifndef yyname
#define yyname     wqlname
#endif /* yyname */

#ifndef yyrule
#define yyrule     wqlrule
#endif /* yyrule */
#define YYPREFIX "wql"

#define YYPURE 0

#line 2 "wql.y"

#include <stdio.h>
#include "state.h"
#include "wql.h"

#if 0
# define YACCTRACE(MSG) \
    printf("WQL_TRACE: %s(%d): %s\n", __FILE__, __LINE__, #MSG)
#else
# define YACCTRACE(MSG)
#endif

extern int wqllex();
extern void wqlerror(const char* msg);

extern int yylex();
extern void yyerror(const char* msg);

extern void* wqlmalloc(size_t size);
extern MI_Char* wqlstrdup(const MI_Char* str);

#line 25 "wql.y"
#ifdef YYSTYPE
#undef  YYSTYPE_IS_DECLARED
#define YYSTYPE_IS_DECLARED 1
#endif
#ifndef YYSTYPE_IS_DECLARED
#define YYSTYPE_IS_DECLARED 1
typedef union
{
    WQL_Symbol symbol;
    MI_Char* string;
    long long integer;
    double real;
    unsigned char boolean;
} YYSTYPE;
#endif /* !YYSTYPE_IS_DECLARED */
#line 137 "y.tab.c"

/* compatibility with bison */
#ifdef YYPARSE_PARAM
/* compatibility with FreeBSD */
# ifdef YYPARSE_PARAM_TYPE
#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
# else
#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
# endif
#else
# define YYPARSE_DECL() yyparse(void)
#endif

/* Parameters sent to lex. */
#ifdef YYLEX_PARAM
# define YYLEX_DECL() yylex(void *YYLEX_PARAM)
# define YYLEX yylex(YYLEX_PARAM)
#else
# define YYLEX_DECL() yylex(void)
# define YYLEX yylex()
#endif

/* Parameters sent to yyerror. */
#define YYERROR_DECL() yyerror(const char *s)
#define YYERROR_CALL(msg) yyerror(msg)

extern int YYPARSE_DECL();

#define WQL_OR 257
#define WQL_AND 258
#define WQL_NOT 259
#define WQL_ERROR 260
#define WQL_LT 261
#define WQL_FROM 262
#define WQL_LE 263
#define WQL_WHERE 264
#define WQL_NE 265
#define WQL_GT 266
#define WQL_REAL 267
#define WQL_EQ 268
#define WQL_SELECT 269
#define WQL_GE 270
#define WQL_NULL 271
#define WQL_IDENTIFIER 272
#define WQL_BOOLEAN 273
#define WQL_INTEGER 274
#define WQL_STRING 275
#define YYERRCODE 256
static const short wqllhs[] = {                          -1,
    0,    0,    2,    2,    4,    4,    3,    3,    3,    3,
    3,    5,    5,    5,    5,    5,    5,    1,    1,    1,
    1,    1,    1,
};
static const short wqllen[] = {                           2,
    4,    6,    1,    1,    1,    3,    3,    2,    3,    3,
    1,    3,    3,    3,    3,    3,    3,    1,    1,    1,
    1,    1,    1,
};
static const short wqldefred[] = {                        0,
    0,    0,    5,    3,    0,    0,    0,    0,    0,    6,
    0,    0,   20,   23,   22,   18,   19,   21,    0,    0,
    0,   11,    8,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    7,   14,   15,   13,   16,   12,   17,    0,
    9,
};
static const short wqldgoto[] = {                         2,
   20,    5,   21,    6,   22,
};
static const short wqlsindex[] = {                     -249,
  -36,    0,    0,    0, -233,  -14, -241, -240, -231,    0,
  -40,  -40,    0,    0,    0,    0,    0,    0,  -40, -258,
 -244,    0,    0,  -37, -256, -256, -256, -256, -256, -256,
  -40,  -40,    0,    0,    0,    0,    0,    0,    0, -224,
    0,
};
static const short wqlrindex[] = {                        0,
    0,    0,    0,    0,    0, -227,    0,    0,   36,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
   37,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    1,
    0,
};
static const short wqlgindex[] = {                        0,
   -2,    0,  -10,    0,    0,
};
#define YYTABLESIZE 258
static const short wqltable[] = {                        19,
   10,   23,   25,   33,   26,    4,   27,   28,   24,   29,
   13,   30,   31,   32,   14,   15,   16,   17,   18,    1,
   40,   41,   34,   35,   36,   37,   38,   39,    7,    8,
    9,   10,   11,   32,    4,    1,    2,    0,    0,    0,
    0,   10,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,   12,   31,
   32,    0,    0,    0,    0,    0,   13,    0,    0,    0,
   14,   15,   16,   17,   18,    3,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
    0,    0,    0,    0,    0,    0,    0,   10,
};
static const short wqlcheck[] = {                        40,
    0,   12,  261,   41,  263,   42,  265,  266,   19,  268,
  267,  270,  257,  258,  271,  272,  273,  274,  275,  269,
   31,   32,   25,   26,   27,   28,   29,   30,  262,   44,
  272,  272,  264,  258,  262,    0,    0,   -1,   -1,   -1,
   -1,   41,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  259,  257,
  258,   -1,   -1,   -1,   -1,   -1,  267,   -1,   -1,   -1,
  271,  272,  273,  274,  275,  272,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   -1,   -1,   -1,   -1,   -1,   -1,   -1,  257,
};
#define YYFINAL 2
#ifndef YYDEBUG
#define YYDEBUG 0
#endif
#define YYMAXTOKEN 275
#if YYDEBUG
static const char *yyname[] = {

"end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,"'('","')'","'*'",0,"','",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"WQL_OR",
"WQL_AND","WQL_NOT","WQL_ERROR","WQL_LT","WQL_FROM","WQL_LE","WQL_WHERE",
"WQL_NE","WQL_GT","WQL_REAL","WQL_EQ","WQL_SELECT","WQL_GE","WQL_NULL",
"WQL_IDENTIFIER","WQL_BOOLEAN","WQL_INTEGER","WQL_STRING",
};
static const char *yyrule[] = {
"$accept : Start",
"Start : WQL_SELECT SelectList WQL_FROM WQL_IDENTIFIER",
"Start : WQL_SELECT SelectList WQL_FROM WQL_IDENTIFIER WQL_WHERE Condition",
"SelectList : '*'",
"SelectList : PropertyList",
"PropertyList : WQL_IDENTIFIER",
"PropertyList : PropertyList ',' WQL_IDENTIFIER",
"Condition : '(' Condition ')'",
"Condition : WQL_NOT Condition",
"Condition : Condition WQL_AND Condition",
"Condition : Condition WQL_OR Condition",
"Condition : Predicate",
"Predicate : Operand WQL_EQ Operand",
"Predicate : Operand WQL_NE Operand",
"Predicate : Operand WQL_LT Operand",
"Predicate : Operand WQL_LE Operand",
"Predicate : Operand WQL_GT Operand",
"Predicate : Operand WQL_GE Operand",
"Operand : WQL_BOOLEAN",
"Operand : WQL_INTEGER",
"Operand : WQL_REAL",
"Operand : WQL_STRING",
"Operand : WQL_IDENTIFIER",
"Operand : WQL_NULL",

};
#endif

int      yydebug;
int      yynerrs;

int      yyerrflag;
int      yychar;
YYSTYPE  yyval;
YYSTYPE  yylval;

/* define the initial stack-sizes */
#ifdef YYSTACKSIZE
#undef YYMAXDEPTH
#define YYMAXDEPTH  YYSTACKSIZE
#else
#ifdef YYMAXDEPTH
#define YYSTACKSIZE YYMAXDEPTH
#else
#define YYSTACKSIZE 500
#define YYMAXDEPTH  500
#endif
#endif

#define YYINITSTACKSIZE 500

typedef struct {
    unsigned stacksize;
    short    *s_base;
    short    *s_mark;
    short    *s_last;
    YYSTYPE  *l_base;
    YYSTYPE  *l_mark;
} YYSTACKDATA;
/* variables for the parser stack */
static YYSTACKDATA yystack;

#if YYDEBUG
#include <stdio.h>		/* needed for printf */
#endif

#include <stdlib.h>	/* needed for malloc, etc */
#include <string.h>	/* needed for memset */

/* allocate initial stack or double stack size, up to YYMAXDEPTH */
static int yygrowstack(YYSTACKDATA *data)
{
    int i;
    unsigned newsize;
    short *newss;
    YYSTYPE *newvs;

    if ((newsize = data->stacksize) == 0)
        newsize = YYINITSTACKSIZE;
    else if (newsize >= YYMAXDEPTH)
        return -1;
    else if ((newsize *= 2) > YYMAXDEPTH)
        newsize = YYMAXDEPTH;

    i = data->s_mark - data->s_base;
    newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
    if (newss == 0)
        return -1;

    data->s_base = newss;
    data->s_mark = newss + i;

    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
    if (newvs == 0)
        return -1;

    data->l_base = newvs;
    data->l_mark = newvs + i;

    data->stacksize = newsize;
    data->s_last = data->s_base + newsize - 1;
    return 0;
}

#if YYPURE || defined(YY_NO_LEAKS)
static void yyfreestack(YYSTACKDATA *data)
{
    free(data->s_base);
    free(data->l_base);
    memset(data, 0, sizeof(*data));
}
#else
#define yyfreestack(data) /* nothing */
#endif

#define YYABORT  goto yyabort
#define YYREJECT goto yyabort
#define YYACCEPT goto yyaccept
#define YYERROR  goto yyerrlab

int
YYPARSE_DECL()
{
    int yym, yyn, yystate;
#if YYDEBUG
    const char *yys;

    if ((yys = getenv("YYDEBUG")) != 0)
    {
        yyn = *yys;
        if (yyn >= '0' && yyn <= '9')
            yydebug = yyn - '0';
    }
#endif

    yynerrs = 0;
    yyerrflag = 0;
    yychar = YYEMPTY;
    yystate = 0;

#if YYPURE
    memset(&yystack, 0, sizeof(yystack));
#endif

    if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
    yystack.s_mark = yystack.s_base;
    yystack.l_mark = yystack.l_base;
    yystate = 0;
    *yystack.s_mark = 0;

yyloop:
    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
    if (yychar < 0)
    {
        if ((yychar = YYLEX) < 0) yychar = 0;
#if YYDEBUG
        if (yydebug)
        {
            yys = 0;
            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
            if (!yys) yys = "illegal-symbol";
            printf("%sdebug: state %d, reading %d (%s)\n",
                    YYPREFIX, yystate, yychar, yys);
        }
#endif
    }
    if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
    {
#if YYDEBUG
        if (yydebug)
            printf("%sdebug: state %d, shifting to state %d\n",
                    YYPREFIX, yystate, yytable[yyn]);
#endif
        if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
        {
            goto yyoverflow;
        }
        yystate = yytable[yyn];
        *++yystack.s_mark = yytable[yyn];
        *++yystack.l_mark = yylval;
        yychar = YYEMPTY;
        if (yyerrflag > 0)  --yyerrflag;
        goto yyloop;
    }
    if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
    {
        yyn = yytable[yyn];
        goto yyreduce;
    }
    if (yyerrflag) goto yyinrecovery;

    yyerror("syntax error");

    goto yyerrlab;

yyerrlab:
    ++yynerrs;

yyinrecovery:
    if (yyerrflag < 3)
    {
        yyerrflag = 3;
        for (;;)
        {
            if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
                    yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
            {
#if YYDEBUG
                if (yydebug)
                    printf("%sdebug: state %d, error recovery shifting\
 to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
#endif
                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
                {
                    goto yyoverflow;
                }
                yystate = yytable[yyn];
                *++yystack.s_mark = yytable[yyn];
                *++yystack.l_mark = yylval;
                goto yyloop;
            }
            else
            {
#if YYDEBUG
                if (yydebug)
                    printf("%sdebug: error recovery discarding state %d\n",
                            YYPREFIX, *yystack.s_mark);
#endif
                if (yystack.s_mark <= yystack.s_base) goto yyabort;
                --yystack.s_mark;
                --yystack.l_mark;
            }
        }
    }
    else
    {
        if (yychar == 0) goto yyabort;
#if YYDEBUG
        if (yydebug)
        {
            yys = 0;
            if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
            if (!yys) yys = "illegal-symbol";
            printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
                    YYPREFIX, yystate, yychar, yys);
        }
#endif
        yychar = YYEMPTY;
        goto yyloop;
    }

yyreduce:
#if YYDEBUG
    if (yydebug)
        printf("%sdebug: state %d, reducing by rule %d (%s)\n",
                YYPREFIX, yystate, yyn, yyrule[yyn]);
#endif
    yym = yylen[yyn];
    if (yym)
        yyval = yystack.l_mark[1-yym];
    else
        memset(&yyval, 0, sizeof yyval);
    switch (yyn)
    {
case 1:
#line 64 "wql.y"
	{
        YACCTRACE(Start1);
        wqlstate.wql->className = yystack.l_mark[0].string;
    }
break;
case 2:
#line 69 "wql.y"
	{
        YACCTRACE(Start2);
        wqlstate.wql->className = yystack.l_mark[-2].string;
    }
break;
case 3:
#line 76 "wql.y"
	{
        YACCTRACE(SelectList1);
    }
break;
case 4:
#line 80 "wql.y"
	{
        YACCTRACE(SelectList12);
    }
break;
case 5:
#line 86 "wql.y"
	{
        YACCTRACE(PropertyList1);

        if (wqlstate.wql->nproperties == WQL_MAX_PROPERTIES)
        {
            yyerror("property array overflow");
            YYABORT;
        }

        wqlstate.wql->properties[wqlstate.wql->nproperties++] = yystack.l_mark[0].string;
    }
break;
case 6:
#line 98 "wql.y"
	{
        YACCTRACE(PropertyList2);

        if (wqlstate.wql->nproperties == WQL_MAX_PROPERTIES)
        {
            yyerror("property array overflow");
            YYABORT;
        }

        wqlstate.wql->properties[wqlstate.wql->nproperties++] = yystack.l_mark[0].string;
    }
break;
case 7:
#line 112 "wql.y"
	{
        YACCTRACE(Condition1);
    }
break;
case 8:
#line 116 "wql.y"
	{
        WQL_Symbol operator;

        YACCTRACE(Condition2);

        if (wqlstate.wql->nsymbols == WQL_MAX_SYMBOLS)
        {
            yyerror("symbol array overflow");
            YYABORT;
        }

        memset(&operator, 0, sizeof(WQL_Symbol));
        operator.type = WQL_TYPE_NOT;
        wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;
    }
break;
case 9:
#line 132 "wql.y"
	{
        WQL_Symbol operator;

        YACCTRACE(Condition3);

        if (wqlstate.wql->nsymbols == WQL_MAX_SYMBOLS)
        {
            yyerror("symbol array overflow");
            YYABORT;
        }

        memset(&operator, 0, sizeof(WQL_Symbol));
        operator.type = WQL_TYPE_AND;
        wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;
    }
break;
case 10:
#line 148 "wql.y"
	{
        WQL_Symbol operator;

        YACCTRACE(Condition4);

        if (wqlstate.wql->nsymbols == WQL_MAX_SYMBOLS)
        {
            yyerror("symbol array overflow");
            YYABORT;
        }

        memset(&operator, 0, sizeof(WQL_Symbol));
        operator.type = WQL_TYPE_OR;
        wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;
    }
break;
case 11:
#line 164 "wql.y"
	{
        YACCTRACE(Condition5);
    }
break;
case 12:
#line 170 "wql.y"
	{
        WQL_Symbol operator;

        YACCTRACE(Predicate1);

        if (wqlstate.wql->nsymbols + 3 > WQL_MAX_SYMBOLS)
        {
            yyerror("symbol array overflow");
            YYABORT;
        }

        memset(&operator, 0, sizeof(WQL_Symbol));
        operator.type = WQL_TYPE_EQ;

        wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[-2].symbol;
        wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[0].symbol;
        wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;
    }
break;
case 13:
#line 189 "wql.y"
	{
        WQL_Symbol operator;

        YACCTRACE(Predicate2);

        if (wqlstate.wql->nsymbols + 3 > WQL_MAX_SYMBOLS)
        {
            yyerror("symbol array overflow");
            YYABORT;
        }

        memset(&operator, 0, sizeof(WQL_Symbol));
        operator.type = WQL_TYPE_NE;

        wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[-2].symbol;
        wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[0].symbol;
        wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;
    }
break;
case 14:
#line 208 "wql.y"
	{
        WQL_Symbol operator;

        YACCTRACE(Predicate3);

        if (wqlstate.wql->nsymbols + 3 > WQL_MAX_SYMBOLS)
        {
            yyerror("symbol array overflow");
            YYABORT;
        }

        memset(&operator, 0, sizeof(WQL_Symbol));
        operator.type = WQL_TYPE_LT;

        wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[-2].symbol;
        wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[0].symbol;
        wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;
    }
break;
case 15:
#line 227 "wql.y"
	{
        WQL_Symbol operator;

        YACCTRACE(Predicate4);

        if (wqlstate.wql->nsymbols + 3 > WQL_MAX_SYMBOLS)
        {
            yyerror("symbol array overflow");
            YYABORT;
        }

        memset(&operator, 0, sizeof(WQL_Symbol));
        operator.type = WQL_TYPE_LE;

        wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[-2].symbol;
        wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[0].symbol;
        wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;
    }
break;
case 16:
#line 246 "wql.y"
	{
        WQL_Symbol operator;

        YACCTRACE(Predicate5);

        if (wqlstate.wql->nsymbols + 3 > WQL_MAX_SYMBOLS)
        {
            yyerror("symbol array overflow");
            YYABORT;
        }

        memset(&operator, 0, sizeof(WQL_Symbol));
        operator.type = WQL_TYPE_GT;

        wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[-2].symbol;
        wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[0].symbol;
        wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;
    }
break;
case 17:
#line 265 "wql.y"
	{
        WQL_Symbol operator;

        YACCTRACE(Predicate6);

        if (wqlstate.wql->nsymbols + 3 > WQL_MAX_SYMBOLS)
        {
            yyerror("symbol array overflow");
            YYABORT;
        }

        memset(&operator, 0, sizeof(WQL_Symbol));
        operator.type = WQL_TYPE_GE;

        wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[-2].symbol;
        wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[0].symbol;
        wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;
    }
break;
case 18:
#line 286 "wql.y"
	{
        YACCTRACE(Operand1);
        yyval.symbol.value.boolean = yystack.l_mark[0].boolean;
        yyval.symbol.type = WQL_TYPE_BOOLEAN;
    }
break;
case 19:
#line 292 "wql.y"
	{
        YACCTRACE(Operand2);
        yyval.symbol.value.integer = yystack.l_mark[0].integer;
        yyval.symbol.type = WQL_TYPE_INTEGER;
    }
break;
case 20:
#line 298 "wql.y"
	{
        YACCTRACE(Operand3);
        yyval.symbol.value.real = yystack.l_mark[0].real;
        yyval.symbol.type = WQL_TYPE_REAL;
    }
break;
case 21:
#line 304 "wql.y"
	{
        YACCTRACE(Operand4);
        yyval.symbol.value.string = yystack.l_mark[0].string;
        yyval.symbol.type = WQL_TYPE_STRING;
    }
break;
case 22:
#line 310 "wql.y"
	{
        YACCTRACE(Operand5);
        yyval.symbol.value.string = yystack.l_mark[0].string;
        yyval.symbol.type = WQL_TYPE_IDENTIFIER;
    }
break;
case 23:
#line 316 "wql.y"
	{
        YACCTRACE(Operand6);
        yyval.symbol.value.integer = 0;
        yyval.symbol.type = WQL_TYPE_NULL;
    }
break;
#line 860 "y.tab.c"
    }
    yystack.s_mark -= yym;
    yystate = *yystack.s_mark;
    yystack.l_mark -= yym;
    yym = yylhs[yyn];
    if (yystate == 0 && yym == 0)
    {
#if YYDEBUG
        if (yydebug)
            printf("%sdebug: after reduction, shifting from state 0 to\
 state %d\n", YYPREFIX, YYFINAL);
#endif
        yystate = YYFINAL;
        *++yystack.s_mark = YYFINAL;
        *++yystack.l_mark = yyval;
        if (yychar < 0)
        {
            if ((yychar = YYLEX) < 0) yychar = 0;
#if YYDEBUG
            if (yydebug)
            {
                yys = 0;
                if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
                if (!yys) yys = "illegal-symbol";
                printf("%sdebug: state %d, reading %d (%s)\n",
                        YYPREFIX, YYFINAL, yychar, yys);
            }
#endif
        }
        if (yychar == 0) goto yyaccept;
        goto yyloop;
    }
    if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
            yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
        yystate = yytable[yyn];
    else
        yystate = yydgoto[yym];
#if YYDEBUG
    if (yydebug)
        printf("%sdebug: after reduction, shifting from state %d \
to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
#endif
    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
    {
        goto yyoverflow;
    }
    *++yystack.s_mark = (short) yystate;
    *++yystack.l_mark = yyval;
    goto yyloop;

yyoverflow:
    yyerror("yacc stack overflow");

yyabort:
    yyfreestack(&yystack);
    return (1);

yyaccept:
    yyfreestack(&yystack);
    return (0);
}