pegasus/src/Pegasus/WQL/WQLYACC.cpp - diff

Return to WQLYACC.cpp CVS log

Up to [Pegasus] / pegasus / src / Pegasus / WQL

Diff for /pegasus/src/Pegasus/WQL/WQLYACC.cpp between version 1.6.2.1 and 1.6.2.2

version 1.6.2.1, 2005/04/04 15:57:22

version 1.6.2.2, 2005/04/05 16:51:04

Line 1

#ifndef lint

/* A Bison parser, made from wql.y

static char const

by GNU Bison version 1.28 */

yyrcsid[] = "$FreeBSD: src/usr.bin/yacc/skeleton.c,v 1.28 2000/01/17 02:04:06 bde Exp $";

#endif

#define YYBISON 1 /* Identify Bison output. */

#include <stdlib.h>

#define YYBYACC 1

#define YYMAJOR 1

#define YYMINOR 9

#define YYLEX yylex()

#define YYEMPTY -1

#define yyclearin (yychar=(YYEMPTY))

#define yyerrok (yyerrflag=0)

#define YYRECOVERING() (yyerrflag!=0)

static int yygrowstack();

#define yyparse WQL_parse

#define yylex WQL_lex

#define yyerror WQL_error

#define yylval WQL_lval

#define yychar WQL_char

#define yyval WQL_val

#define yylval WQL_lval

#define yydebug WQL_debug

#define yynerrs WQL_nerrs

#define TOK_INTEGER 257

#define yyerrflag WQL_errflag

#define TOK_DOUBLE 258

#define yyss WQL_ss

#define TOK_STRING 259

#define yyssp WQL_ssp

#define TOK_TRUE 260

#define yyvs WQL_vs

#define TOK_FALSE 261

#define yyvsp WQL_vsp

#define TOK_NULL 262

#define yylhs WQL_lhs

#define TOK_EQ 263

#define yylen WQL_len

#define TOK_NE 264

#define yydefred WQL_defred

#define TOK_LT 265

#define yydgoto WQL_dgoto

#define TOK_LE 266

#define yysindex WQL_sindex

#define TOK_GT 267

#define yyrindex WQL_rindex

#define TOK_GE 268

#define yygindex WQL_gindex

#define TOK_NOT 269

#define yytable WQL_table

#define TOK_OR 270

#define yycheck WQL_check

#define TOK_AND 271

#define yyname WQL_name

#define TOK_IS 272

#define yyrule WQL_rule

#define TOK_IDENTIFIER 273

#define yysslim WQL_sslim

#define TOK_SELECT 274

#define yystacksize WQL_stacksize

#define TOK_WHERE 275

#define YYPREFIX "WQL_"

#define TOK_FROM 276

#line 10 "WQL.y"

#define TOK_UNEXPECTED_CHAR 277

#line 9 "wql.y"

#include <Pegasus/Common/Config.h>

#include <Pegasus/WQL/WQLOperation.h>

Line 61

Line 66

extern int WQL_lex();

extern int WQL_error(const char*);

/**/

// Define the global parser state object:

/* Define the global parser state object:*/

/**/

PEGASUS_USING_PEGASUS;

Line 73

Line 78

PEGASUS_NAMESPACE_END

#line 58 "WQL.y"

#line 58 "wql.y"

typedef union

{

int intValue;

Line 82

Line 86

char* strValue;

void* nodeValue;

} YYSTYPE;

#include <stdio.h>

#line 90 "y.tab.c"

#define YYERRCODE 256

#ifndef __cplusplus

#define TOK_INTEGER 257

#ifndef __STDC__

#define TOK_DOUBLE 258

#define const

#define TOK_STRING 259

#endif

#define TOK_TRUE 260

#endif

#define TOK_FALSE 261

#define TOK_NULL 262

#define TOK_EQ 263

#define TOK_NE 264

#define YYFINAL 60

#define TOK_LT 265

#define YYFLAG -32768

#define TOK_LE 266

#define YYNTBASE 28

#define TOK_GT 267

#define TOK_GE 268

#define YYTRANSLATE(x) ((unsigned)(x) <= 277 ? yytranslate[x] : 43)

#define TOK_NOT 269

#define TOK_OR 270

static const char yytranslate[] = { 0,

#define TOK_AND 271

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

#define TOK_IS 272

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

#define TOK_IDENTIFIER 273

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

#define TOK_SELECT 274

2, 2, 2, 2, 2, 2, 2, 2, 2, 26,

#define TOK_WHERE 275

27, 24, 2, 25, 2, 2, 2, 2, 2, 2,

#define TOK_FROM 276

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

#define TOK_UNEXPECTED_CHAR 277

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

const short WQL_lhs[] = { -1,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

0, 9, 10, 10, 2, 2, 11, 11, 7, 8,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

6, 6, 6, 6, 6, 6, 6, 3, 3, 4,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

4, 4, 4, 4, 4, 5, 5, 13, 13, 1,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

12, 14, 14, 14, 14, 14,

2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

2, 2, 2, 2, 2, 1, 3, 4, 5, 6,

7, 8, 9, 10, 11, 12, 13, 14, 15, 16,

17, 18, 19, 20, 21, 22, 23

};

#if YYDEBUG != 0

static const short yyprhs[] = { 0,

0, 2, 6, 8, 10, 12, 16, 19, 21, 24,

27, 31, 35, 38, 42, 44, 48, 53, 55, 57,

61, 65, 69, 73, 77, 81, 85, 90, 92, 94,

96, 98, 100, 102, 104, 106

};

static const short yyrhs[] = { 29,

0, 20, 30, 32, 0, 24, 0, 31, 0, 40,

0, 31, 25, 40, 0, 33, 34, 0, 33, 0,

22, 41, 0, 21, 35, 0, 35, 16, 35, 0,

35, 17, 35, 0, 15, 35, 0, 26, 35, 27,

0, 36, 0, 36, 18, 39, 0, 36, 18, 15,

39, 0, 37, 0, 38, 0, 42, 11, 42, 0,

42, 13, 42, 0, 42, 12, 42, 0, 42, 14,

42, 0, 42, 9, 42, 0, 42, 10, 42, 0,

42, 18, 8, 0, 42, 18, 15, 8, 0, 6,

0, 7, 0, 19, 0, 19, 0, 40, 0, 3,

0, 4, 0, 5, 0, 39, 0

};

#endif

#if YYDEBUG != 0

static const short yyrline[] = { 0,

130, 136, 142, 146, 152, 156, 162, 166, 172, 179,

185, 190, 195, 201, 205, 209, 214, 223, 227, 233,

238, 243, 248, 253, 258, 265, 270, 277, 281, 287,

293, 300, 306, 311, 316, 321

};

#endif

#if YYDEBUG != 0 || defined (YYERROR_VERBOSE)

static const char * const yytname[] = { "$","error","$undefined.","TOK_INTEGER",

"TOK_DOUBLE","TOK_STRING","TOK_TRUE","TOK_FALSE","TOK_NULL","TOK_EQ","TOK_NE",

"TOK_LT","TOK_LE","TOK_GT","TOK_GE","TOK_NOT","TOK_OR","TOK_AND","TOK_IS","TOK_IDENTIFIER",

"TOK_SELECT","TOK_WHERE","TOK_FROM","TOK_UNEXPECTED_CHAR","'*'","','","'('",

"')'","start","selectStatement","selectList","propertyList","selectExpression",

"fromClause","whereClause","searchCondition","predicate","comparisonPredicate",

"nullPredicate","truthValue","propertyName","className","comparisonTerm", NULL

};

#endif

static const short yyr1[] = { 0,

28, 29, 30, 30, 31, 31, 32, 32, 33, 34,

35, 35, 35, 35, 35, 35, 35, 36, 36, 37,

37, 37, 37, 37, 37, 38, 38, 39, 39, 40,

41, 42, 42, 42, 42, 42

};

const short WQL_len[] = { 2,

static const short yyr2[] = { 0,

1, 3, 1, 1, 1, 3, 2, 1, 2, 2,

3, 3, 2, 3, 1, 3, 4, 1, 1, 3,

3, 3, 3, 3, 3, 3, 4, 1, 1, 1,

1, 1, 1, 1, 1, 1

1, 1, 1, 1, 1, 1,

};

const short WQL_defred[] = { 0,

static const short yydefact[] = { 0,

0, 0, 1, 30, 3, 5, 0, 0, 0, 0,

0, 1, 30, 3, 0, 4, 5, 0, 2, 8,

0, 2, 6, 31, 9, 0, 7, 33, 34, 35,

0, 31, 9, 0, 7, 6, 33, 34, 35, 28,

28, 29, 0, 0, 32, 0, 18, 19, 0, 36,

29, 0, 0, 10, 15, 18, 19, 36, 32, 0,

0, 13, 0, 0, 0, 0, 0, 0, 0, 0,

13, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 14, 0, 16, 0, 12, 24, 25,

0, 0, 14, 11, 12, 0, 16, 24, 25, 20,

20, 22, 21, 23, 26, 0, 17, 27,

22, 21, 23, 26, 0, 17, 27, 0, 0, 0

};

const short WQL_dgoto[] = { 2,

25, 7, 26, 27, 28, 29, 11, 17, 3, 8,

static const short yydefgoto[] = { 58,

12, 15, 30, 31,

2, 5, 6, 9, 10, 15, 24, 25, 26, 27,

};

28, 29, 13, 30

const short WQL_sindex[] = { -241,

};

-38, 0, 0, 0, 0, 0, -9, -237, -232, -225,

-228, 0, 0, 0, 0, -40, 0, 0, 0, 0,

static const short yypact[] = { -5,

0, 0, -40, -40, 0, -223, 0, 0, -233, 0,

18,-32768,-32768,-32768, 5, 16,-32768, 24,-32768, 33,

-238, 0, -39, -229, -40, -40, -252, -252, -252, -252,

26,-32768,-32768, -3,-32768,-32768,-32768,-32768,-32768,-32768,

-252, -252, -226, 0, -215, 0, -221, 0, 0, 0,

-32768, -3, -3, 23, 37,-32768,-32768,-32768,-32768, 20,

0, 0, 0, 0, 0, -211, 0, 0,

-32768, 1, -3, -3, 29, 2, 2, 2, 2, 2,

};

2, 11,-32768, 39,-32768, 46,-32768,-32768,-32768,-32768,

const short WQL_rindex[] = { 0,

-32768,-32768,-32768,-32768, 49,-32768,-32768, 58, 59,-32768

0, 0, 0, 0, 0, 0, -224, 0, 0, 0,

};

53, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 1, 0, 0, 54, 0,

static const short yypgoto[] = {-32768,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

-32768,-32768,-32768,-32768,-32768,-32768, -9,-32768,-32768,-32768,

0, 0, 0, 0, 0, 0, 3, 0, 0, 0,

-24, 9,-32768, 10

0, 0, 0, 0, 0, 0, 0, 0,

};

const short WQL_gindex[] = { 0,

11, 0, 0, 0, 0, -13, 0, 0, 0, 0,

#define YYLAST 59

0, 0, -21, -23,

};

#define YYTABLESIZE 273

static const short yytable[] = { 17,

const short WQL_table[] = { 24,

18, 19, 20, 21, 17, 18, 19, 20, 21, 7,

15, 44, 11, 5, 18, 19, 20, 21, 22, 32,

47, 22, 31, 32, 1, 3, 33, 34, 54, 16,

33, 6, 46, 49, 50, 51, 52, 53, 54, 13,

3, 56, 23, 44, 45, 55, 8, 43, 36, 37,

4, 47, 48, 57, 37, 38, 39, 40, 41, 42,

38, 39, 40, 41, 20, 21, 3, 42, 33, 34,

21, 22, 1, 43, 9, 55, 35, 36, 10, 45,

11, 4, 12, 46, 3, 48, 49, 50, 51, 52,

4, 15, 56, 11, 21, 22, 16, 14, 34, 36,

53, 20, 21, 14, 35, 34, 57, 59, 60

58, 4, 8, 10, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 18, 19, 20, 21,

22, 0, 0, 0, 0, 0, 0, 0, 23, 0,

35, 36, 4, 0, 4, 0, 0, 0, 0, 0,

0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

15, 15, 11,

};

const short WQL_check[] = { 40,

0, 41, 0, 42, 257, 258, 259, 260, 261, 23,

24, 1, 34, 37, 38, 39, 40, 41, 42, 9,

273, 35, 36, 45, 263, 264, 265, 266, 267, 268,

260, 261, 274, 272, 44, 262, 270, 271, 276, 269,

273, 41, 269, 41, 260, 261, 275, 273, 272, 271,

262, 276, 0, 0, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, 257, 258, 259, 260,

261, -1, -1, -1, -1, -1, -1, -1, 269, -1,

270, 271, 273, -1, 273, -1, -1, -1, -1, -1,

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

270, 271, 270,

};

#define YYFINAL 2

#ifndef YYDEBUG

#define YYDEBUG 0

#endif

#define YYMAXTOKEN 277

#if YYDEBUG

const char * const WQL_name[] = {

"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,"TOK_INTEGER",

"TOK_DOUBLE","TOK_STRING","TOK_TRUE","TOK_FALSE","TOK_NULL","TOK_EQ","TOK_NE",

"TOK_LT","TOK_LE","TOK_GT","TOK_GE","TOK_NOT","TOK_OR","TOK_AND","TOK_IS",

"TOK_IDENTIFIER","TOK_SELECT","TOK_WHERE","TOK_FROM","TOK_UNEXPECTED_CHAR",

};

const char * const WQL_rule[] = {

static const short yycheck[] = { 3,

"$accept : start",

4, 5, 6, 7, 3, 4, 5, 6, 7, 1,

"start : selectStatement",

35, 15, 22, 23, 20, 19, 16, 17, 8, 11,

"selectStatement : TOK_SELECT selectList selectExpression",

19, 46, 26, 33, 34, 15, 22, 27, 9, 10,

"selectList : '*'",

11, 12, 13, 14, 6, 7, 19, 18, 16, 17,

"selectList : propertyList",

25, 24, 19, 15, 19, 36, 37, 38, 39, 40,

"propertyList : propertyName",

41, 6, 7, 21, 18, 17, 8, 0, 0

"propertyList : propertyList ',' propertyName",

"selectExpression : fromClause whereClause",

"selectExpression : fromClause",

"fromClause : TOK_FROM className",

"whereClause : TOK_WHERE searchCondition",

"searchCondition : searchCondition TOK_OR searchCondition",

"searchCondition : searchCondition TOK_AND searchCondition",

"searchCondition : TOK_NOT searchCondition",

"searchCondition : '(' searchCondition ')'",

"searchCondition : predicate",

"searchCondition : predicate TOK_IS truthValue",

"searchCondition : predicate TOK_IS TOK_NOT truthValue",

"predicate : comparisonPredicate",

"predicate : nullPredicate",

"comparisonPredicate : comparisonTerm TOK_LT comparisonTerm",

"comparisonPredicate : comparisonTerm TOK_GT comparisonTerm",

"comparisonPredicate : comparisonTerm TOK_LE comparisonTerm",

"comparisonPredicate : comparisonTerm TOK_GE comparisonTerm",

"comparisonPredicate : comparisonTerm TOK_EQ comparisonTerm",

"comparisonPredicate : comparisonTerm TOK_NE comparisonTerm",

"nullPredicate : comparisonTerm TOK_IS TOK_NULL",

"nullPredicate : comparisonTerm TOK_IS TOK_NOT TOK_NULL",

"truthValue : TOK_TRUE",

"truthValue : TOK_FALSE",

"propertyName : TOK_IDENTIFIER",

"className : TOK_IDENTIFIER",

"comparisonTerm : propertyName",

"comparisonTerm : TOK_INTEGER",

"comparisonTerm : TOK_DOUBLE",

"comparisonTerm : TOK_STRING",

"comparisonTerm : truthValue",

};

/* -*-C-*- Note some compilers choke on comments on `#line' lines. */

#line 3 "bison.simple"

/* This file comes from bison-@bison_version@. */

/* Skeleton output parser for bison,

This program is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation; either version 2, or (at your option)

any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program; if not, write to the Free Software

Foundation, Inc., 59 Temple Place - Suite 330,

Boston, MA 02111-1307, USA. */

/* As a special exception, when this file is copied by Bison into a

Bison output file, you may use that output file without restriction.

This special exception was added by the Free Software Foundation

in version 1.24 of Bison. */

/* This is the parser code that is written into each bison parser

when the %semantic_parser declaration is not specified in the grammar.

It was written by Richard Stallman by simplifying the hairy parser

used when %semantic_parser is specified. */

#ifndef YYSTACK_USE_ALLOCA

#ifdef alloca

#define YYSTACK_USE_ALLOCA

#else /* alloca not defined */

#ifdef __GNUC__

#define YYSTACK_USE_ALLOCA

#define alloca __builtin_alloca

#else /* not GNU C. */

#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))

#define YYSTACK_USE_ALLOCA

#include <alloca.h>

#else /* not sparc */

/* We think this test detects Watcom and Microsoft C. */

/* This used to test MSDOS, but that is a bad idea

since that symbol is in the user namespace. */

#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)

#if 0 /* No need for malloc.h, which pollutes the namespace;

instead, just don't use alloca. */

#include <malloc.h>

#endif

#else /* not MSDOS, or __TURBOC__ */

#if defined(_AIX)

/* I don't know what this was needed for, but it pollutes the namespace.

So I turned it off. rms, 2 May 1997. */

/* #include <malloc.h> */

#pragma alloca

#define YYSTACK_USE_ALLOCA

#else /* not MSDOS, or __TURBOC__, or _AIX */

#if 0

#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,

and on HPUX 10. Eventually we can turn this on. */

#define YYSTACK_USE_ALLOCA

#define alloca __builtin_alloca

#endif /* __hpux */

#endif

#endif /* not _AIX */

#endif /* not MSDOS, or __TURBOC__ */

#endif /* not sparc */

#endif /* not GNU C */

#endif /* alloca not defined */

#endif /* YYSTACK_USE_ALLOCA not defined */

#ifdef YYSTACK_USE_ALLOCA

#define YYSTACK_ALLOC alloca

#else

#define YYSTACK_ALLOC malloc

#endif

#if YYDEBUG

/* Note: there must be only one dollar sign in this file.

#include <stdio.h>

It is replaced by the list of actions, each action

as one case of the switch. */

#define yyerrok (yyerrstatus = 0)

#define yyclearin (yychar = YYEMPTY)

#define YYEMPTY -2

#define YYEOF 0

#define YYACCEPT goto yyacceptlab

#define YYABORT goto yyabortlab

#define YYERROR goto yyerrlab1

/* Like YYERROR except do call yyerror.

This remains here temporarily to ease the

transition to the new meaning of YYERROR, for GCC.

Once GCC version 2 has supplanted version 1, this can go. */

#define YYFAIL goto yyerrlab

#define YYRECOVERING() (!!yyerrstatus)

#define YYBACKUP(token, value) \

do \

if (yychar == YYEMPTY && yylen == 1) \

{ yychar = (token), yylval = (value); \

yychar1 = YYTRANSLATE (yychar); \

YYPOPSTACK; \

goto yybackup; \

} \

else \

{ yyerror ("syntax error: cannot back up"); YYERROR; } \

while (0)

#define YYTERROR 1

#define YYERRCODE 256

#ifndef YYPURE

#define YYLEX yylex()

#endif

#ifdef YYSTACKSIZE

#ifdef YYPURE

#undef YYMAXDEPTH

#ifdef YYLSP_NEEDED

#define YYMAXDEPTH YYSTACKSIZE

#ifdef YYLEX_PARAM

#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM)

#else

#define YYLEX yylex(&yylval, &yylloc)

#ifdef YYMAXDEPTH

#endif

#define YYSTACKSIZE YYMAXDEPTH

#else /* not YYLSP_NEEDED */

#ifdef YYLEX_PARAM

#define YYLEX yylex(&yylval, YYLEX_PARAM)

#else

#define YYLEX yylex(&yylval)

#define YYSTACKSIZE 10000

#endif

#endif /* not YYLSP_NEEDED */

#endif

/* If nonreentrant, generate the variables here */

#ifndef YYPURE

int yychar; /* the lookahead symbol */

YYSTYPE yylval; /* the semantic value of the */

/* lookahead symbol */

#ifdef YYLSP_NEEDED

YYLTYPE yylloc; /* location data for the lookahead */

/* symbol */

#endif

int yynerrs; /* number of parse errors so far */

#endif /* not YYPURE */

#if YYDEBUG != 0

int yydebug; /* nonzero means print parse trace */

/* Since this is uninitialized, it does not stop multiple parsers

from coexisting. */

#endif

/* YYINITDEPTH indicates the initial size of the parser's stacks */

#ifndef YYINITDEPTH

#define YYINITDEPTH 200

#endif

/* YYMAXDEPTH is the maximum size the stacks can grow to

(effective only if the built-in stack extension method is used). */

#if YYMAXDEPTH == 0

#undef YYMAXDEPTH

#endif

#ifndef YYMAXDEPTH

#define YYMAXDEPTH 10000

#endif

/* Define __yy_memcpy. Note that the size argument

should be passed with type unsigned int, because that is what the non-GCC

definitions require. With GCC, __builtin_memcpy takes an arg

of type size_t, but it can handle unsigned int. */

#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */

#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT)

#else /* not GNU C or C++ */

#ifndef __cplusplus

/* This is the most reliable way to avoid incompatibilities

in available built-in functions on various systems. */

static void

__yy_memcpy (to, from, count)

char *to;

char *from;

unsigned int count;

{

while (i-- > 0)

*t++ = *f++;

}

#else /* __cplusplus */

/* This is the most reliable way to avoid incompatibilities

in available built-in functions on various systems. */

static void

__yy_memcpy (char *to, char *from, unsigned int count)

{

while (i-- > 0)

*t++ = *f++;

}

#endif

#define YYINITSTACKSIZE 200

int yydebug;

int yynerrs;

int yyerrflag;

int yychar;

short *yyssp;

YYSTYPE *yyvsp;

YYSTYPE yyval;

YYSTYPE yylval;

short *yyss;

short *yysslim;

YYSTYPE *yyvs;

int yystacksize;

/* allocate initial stack or double stack size, up to YYMAXDEPTH */

static int yygrowstack()

{

int newsize, i;

short *newss;

YYSTYPE *newvs;

if ((newsize = yystacksize) == 0)

newsize = YYINITSTACKSIZE;

else if (newsize >= YYMAXDEPTH)

return -1;

else if ((newsize *= 2) > YYMAXDEPTH)

newsize = YYMAXDEPTH;

i = yyssp - yyss;

newss = yyss ? (short *)realloc(yyss, newsize * sizeof *newss) :

(short *)malloc(newsize * sizeof *newss);

if (newss == NULL)

return -1;

yyss = newss;

yyssp = newss + i;

newvs = yyvs ? (YYSTYPE *)realloc(yyvs, newsize * sizeof *newvs) :

(YYSTYPE *)malloc(newsize * sizeof *newvs);

if (newvs == NULL)

return -1;

yyvs = newvs;

yyvsp = newvs + i;

yystacksize = newsize;

yysslim = yyss + newsize - 1;

return 0;

}

#line 217 "bison.simple"

#define YYABORT goto yyabort

#define YYREJECT goto yyabort

/* The user can define YYPARSE_PARAM as the name of an argument to be passed

#define YYACCEPT goto yyaccept

into yyparse. The argument should have type void *.

#define YYERROR goto yyerrlab

It should actually point to an object.

Grammar actions can access the variable by casting it

#ifndef YYPARSE_PARAM

to the proper pointer type. */

#if defined(__cplusplus) || __STDC__

#define YYPARSE_PARAM_ARG void

#ifdef YYPARSE_PARAM

#ifdef __cplusplus

#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM

#define YYPARSE_PARAM_DECL

#else /* not __cplusplus */

#else /* ! ANSI-C/C++ */

#define YYPARSE_PARAM_ARG YYPARSE_PARAM

#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;

#endif /* not __cplusplus */

#else /* not YYPARSE_PARAM */

#define YYPARSE_PARAM_ARG

#define YYPARSE_PARAM_DECL

#endif /* not YYPARSE_PARAM */

#endif /* ANSI-C/C++ */

#else /* YYPARSE_PARAM */

/* Prevent warning if -Wstrict-prototypes. */

#ifndef YYPARSE_PARAM_TYPE

#ifdef __GNUC__

#define YYPARSE_PARAM_TYPE void *

#ifdef YYPARSE_PARAM

int yyparse (void *);

#else

int yyparse (void);

#endif

#if defined(__cplusplus) || __STDC__

#define YYPARSE_PARAM_ARG YYPARSE_PARAM_TYPE YYPARSE_PARAM

#define YYPARSE_PARAM_DECL

#else /* ! ANSI-C/C++ */

#define YYPARSE_PARAM_ARG YYPARSE_PARAM

#define YYPARSE_PARAM_DECL YYPARSE_PARAM_TYPE YYPARSE_PARAM;

#endif /* ANSI-C/C++ */

#endif /* ! YYPARSE_PARAM */

int

yyparse(YYPARSE_PARAM_ARG)

YYPARSE_PARAM_DECL

{

#if YYDEBUG

int yyerrstatus; /* number of tokens to shift before error messages enabled */

if ((yys = getenv("YYDEBUG")))

int yychar1 = 0; /* lookahead token as an internal (translated) token number */

{

yyn = *yys;

short yyssa[YYINITDEPTH]; /* the state stack */

if (yyn >= '0' && yyn <= '9')

YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */

yydebug = yyn - '0';

}

short *yyss = yyssa; /* refer to the stacks thru separate pointers */

YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */

#ifdef YYLSP_NEEDED

YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */

YYLTYPE *yyls = yylsa;

YYLTYPE *yylsp;

#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)

#else

#define YYPOPSTACK (yyvsp--, yyssp--)

#endif

int yystacksize = YYINITDEPTH;

int yyfree_stacks = 0;

#ifdef YYPURE

int yychar;

YYSTYPE yylval;

int yynerrs;

#ifdef YYLSP_NEEDED

YYLTYPE yylloc;

#endif

YYSTYPE yyval; /* the variable used to return */

/* semantic values from the action */

/* routines */

int yylen;

#if YYDEBUG != 0

if (yydebug)

fprintf(stderr, "Starting parse\n");

#endif

yystate = 0;

yyerrstatus = 0;

yynerrs = 0;

yychar = YYEMPTY; /* Cause a token to be read. */

yyerrflag = 0;

yychar = (-1);

/* Initialize stack pointers.

Waste one element of value and location stack

so that they stay on the same level as the state stack.

The wasted elements are never initialized. */

yyssp = yyss - 1;

if (yyss == NULL && yygrowstack()) goto yyoverflow;

yyssp = yyss;

yyvsp = yyvs;

#ifdef YYLSP_NEEDED

*yyssp = yystate = 0;

yylsp = yyls;

#endif

/* Push a new state, which is found in yystate . */

/* In all cases, when you get here, the value and location stacks

have just been pushed. so pushing a state here evens the stacks. */

yynewstate:

*++yyssp = yystate;

if (yyssp >= yyss + yystacksize - 1)

yyloop:

if ((yyn = yydefred[yystate])) goto yyreduce;

if (yychar < 0)

{

/* Give user a chance to reallocate the stack */

if ((yychar = yylex()) < 0) yychar = 0;

/* Use copies of these so that the &'s don't force the real ones into memory. */

#if YYDEBUG

YYSTYPE *yyvs1 = yyvs;

if (yydebug)

short *yyss1 = yyss;

#ifdef YYLSP_NEEDED

YYLTYPE *yyls1 = yyls;

#endif

/* Get the current used size of the three stacks, in elements. */

int size = yyssp - yyss + 1;

#ifdef yyoverflow

/* Each stack pointer address is followed by the size of

the data in use in that stack, in bytes. */

#ifdef YYLSP_NEEDED

/* This used to be a conditional around just the two extra args,

but that might be undefined if yyoverflow is a macro. */

yyoverflow("parser stack overflow",

&yyss1, size * sizeof (*yyssp),

&yyvs1, size * sizeof (*yyvsp),

&yyls1, size * sizeof (*yylsp),

&yystacksize);

#else

yyoverflow("parser stack overflow",

&yyss1, size * sizeof (*yyssp),

&yyvs1, size * sizeof (*yyvsp),

&yystacksize);

#endif

yyss = yyss1; yyvs = yyvs1;

#ifdef YYLSP_NEEDED

yyls = yyls1;

#endif

#else /* no yyoverflow */

/* Extend the stack our own way. */

if (yystacksize >= YYMAXDEPTH)

{

yyerror("parser stack overflow");

if (yyfree_stacks)

{

free (yyss);

yys = 0;

free (yyvs);

if (yychar <= YYMAXTOKEN) yys = yyname[yychar];

#ifdef YYLSP_NEEDED

if (!yys) yys = "illegal-symbol";

free (yyls);

printf("%sdebug: state %d, reading %d (%s)\n",

#endif

YYPREFIX, yystate, yychar, yys);

}

return 2;

}

yystacksize *= 2;

if (yystacksize > YYMAXDEPTH)

yystacksize = YYMAXDEPTH;

#ifndef YYSTACK_USE_ALLOCA

yyfree_stacks = 1;

#endif

yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));

}

__yy_memcpy ((char *)yyss, (char *)yyss1,

if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&

size * (unsigned int) sizeof (*yyssp));

yyn <= YYTABLESIZE && yycheck[yyn] == yychar)

yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));

{

__yy_memcpy ((char *)yyvs, (char *)yyvs1,

#if YYDEBUG

size * (unsigned int) sizeof (*yyvsp));

#ifdef YYLSP_NEEDED

yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));

__yy_memcpy ((char *)yyls, (char *)yyls1,

size * (unsigned int) sizeof (*yylsp));

#endif

#endif /* no yyoverflow */

yyssp = yyss + size - 1;

yyvsp = yyvs + size - 1;

#ifdef YYLSP_NEEDED

yylsp = yyls + size - 1;

#endif

#if YYDEBUG != 0

if (yydebug)

fprintf(stderr, "Stack size increased to %d\n", yystacksize);

printf("%sdebug: state %d, shifting to state %d\n",

YYPREFIX, yystate, yytable[yyn]);

#endif

if (yyssp >= yysslim && yygrowstack())

if (yyssp >= yyss + yystacksize - 1)

{

YYABORT;

goto yyoverflow;

}

*++yyssp = yystate = yytable[yyn];

#if YYDEBUG != 0

*++yyvsp = yylval;

if (yydebug)

yychar = (-1);

fprintf(stderr, "Entering state %d\n", yystate);

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;

#if defined(lint) || defined(__GNUC__)

goto yynewerror;

#endif

yynewerror:

yyerror("syntax error");

#if defined(lint) || defined(__GNUC__)

goto yyerrlab;

#endif

yyerrlab:

goto yybackup;

++yynerrs;

yybackup:

yyinrecovery:

if (yyerrflag < 3)

/* Do appropriate processing given the current state. */

{

/* Read a lookahead token if we need one and don't already have one. */

yyerrflag = 3;

/* yyresume: */

for (;;)

/* First try to decide what to do without reference to lookahead token. */

yyn = yypact[yystate];

if (yyn == YYFLAG)

goto yydefault;

/* Not known => get a lookahead token if don't already have one. */

/* yychar is either YYEMPTY or YYEOF

or a valid token in external form. */

if (yychar == YYEMPTY)

{

#if YYDEBUG != 0

if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&

yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)

{

#if YYDEBUG

if (yydebug)

fprintf(stderr, "Reading a token: ");

printf("%sdebug: state %d, error recovery shifting\

to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);

#endif

yychar = YYLEX;

if (yyssp >= yysslim && yygrowstack())

{

goto yyoverflow;

}

*++yyssp = yystate = yytable[yyn];

/* Convert token to internal form (in yychar1) for indexing tables with */

*++yyvsp = yylval;

goto yyloop;

if (yychar <= 0) /* This means end of input. */

}

else

{

yychar1 = 0;

#if YYDEBUG

yychar = YYEOF; /* Don't call YYLEX any more */

#if YYDEBUG != 0

if (yydebug)

fprintf(stderr, "Now at end of input.\n");

printf("%sdebug: error recovery discarding state %d\n",

YYPREFIX, *yyssp);

#endif

if (yyssp <= yyss) goto yyabort;

--yyssp;

--yyvsp;

}

else

{

yychar1 = YYTRANSLATE(yychar);

if (yychar == 0) goto yyabort;

#if YYDEBUG

#if YYDEBUG != 0

if (yydebug)

{

fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);

yys = 0;

/* Give the individual parser a way to print the precise meaning

if (yychar <= YYMAXTOKEN) yys = yyname[yychar];

of a token, for further debugging info. */

if (!yys) yys = "illegal-symbol";

#ifdef YYPRINT

printf("%sdebug: state %d, error recovery discards token %d (%s)\n",

YYPRINT (stderr, yychar, yylval);

YYPREFIX, yystate, yychar, yys);

#endif

fprintf (stderr, ")\n");

}

#endif

yychar = (-1);

goto yyloop;

}

yyn += yychar1;

if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)

goto yydefault;

yyn = yytable[yyn];

/* yyn is what to do for this token type in this state.

Negative => reduce, -yyn is rule number.

Positive => shift, yyn is new state.

New state is final state => don't bother to shift,

just return success.

0, or most negative number => error. */

if (yyn < 0)

{

if (yyn == YYFLAG)

goto yyerrlab;

yyn = -yyn;

goto yyreduce;

}

else if (yyn == 0)

goto yyerrlab;

if (yyn == YYFINAL)

YYACCEPT;

/* Shift the lookahead token. */

#if YYDEBUG != 0

if (yydebug)

fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);

#endif

/* Discard the token being shifted unless it is eof. */

if (yychar != YYEOF)

yychar = YYEMPTY;

*++yyvsp = yylval;

#ifdef YYLSP_NEEDED

*++yylsp = yylloc;

#endif

/* count tokens shifted since error; after three, turn off error status. */

if (yyerrstatus) yyerrstatus--;

yystate = yyn;

goto yynewstate;

/* Do the default action for the current state. */

yydefault:

yyn = yydefact[yystate];

if (yyn == 0)

goto yyerrlab;

/* Do a reduction. yyn is the number of a rule to reduce with. */

yyreduce:

yylen = yyr2[yyn];

#if YYDEBUG

if (yylen > 0)

yyval = yyvsp[1-yylen]; /* implement default value of the action */

#if YYDEBUG != 0

if (yydebug)

{

printf("%sdebug: state %d, reducing by rule %d (%s)\n",

int i;

YYPREFIX, yystate, yyn, yyrule[yyn]);

fprintf (stderr, "Reducing via rule %d (line %d), ",

yyn, yyrline[yyn]);

/* Print the symbols being reduced, and their result. */

for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)

fprintf (stderr, "%s ", yytname[yyrhs[i]]);

fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);

}

#endif

yym = yylen[yyn];

yyval = yyvsp[1-yym];

switch (yyn) {

switch (yyn)

{

case 1:

#line 131 "wql.y"

#line 131 "WQL.y"

{

WQL_TRACE(("YACC: start\n"));

;

}

break;}

break;

case 2:

#line 137 "wql.y"

#line 137 "WQL.y"

{

;

}

break;}

break;

case 3:

#line 143 "wql.y"

#line 143 "WQL.y"

{

globalParserState->statement->setAllProperties(true);

;

}

break;}

break;

case 4:

#line 147 "wql.y"

#line 147 "WQL.y"

{

;

}

break;}

break;

case 5:

#line 153 "wql.y"

#line 153 "WQL.y"

{

globalParserState->statement->appendSelectPropertyName(CIMName(yyvsp[0].strValue));

;

}

break;}

break;

case 6:

#line 157 "wql.y"

#line 157 "WQL.y"

{

globalParserState->statement->appendSelectPropertyName(CIMName(yyvsp[0].strValue));

;

}

break;}

break;

case 7:

#line 163 "wql.y"

#line 163 "WQL.y"

{

;

}

break;}

break;

case 8:

#line 167 "wql.y"

#line 167 "WQL.y"

{

;

}

break;}

break;

case 9:

#line 173 "wql.y"

#line 173 "WQL.y"

{

WQL_TRACE(("YACC: fromClause: TOK_FROM className(%s)\n", yyvsp[0].strValue));

globalParserState->statement->setClassName(CIMName(yyvsp[0].strValue));

;

}

break;}

break;

case 10:

#line 180 "wql.y"

#line 180 "WQL.y"

{

;

}

break;}

break;

case 11:

#line 186 "wql.y"

#line 186 "WQL.y"

{

WQL_TRACE(("YACC: TOK_OR\n"));

globalParserState->statement->appendOperation(WQL_OR);

;

}

break;}

break;

case 12:

#line 191 "wql.y"

#line 191 "WQL.y"

{

WQL_TRACE(("YACC: TOK_AND\n"));

globalParserState->statement->appendOperation(WQL_AND);

;

}

break;}

break;

case 13:

#line 196 "wql.y"

#line 196 "WQL.y"

{

WQL_TRACE(("YACC: TOK_NOT\n"));

globalParserState->statement->appendOperation(WQL_NOT);

;

}

break;}

break;

case 14:

#line 202 "wql.y"

#line 202 "WQL.y"

{

;

}

break;}

break;

case 15:

#line 206 "wql.y"

#line 206 "WQL.y"

{

;

}

break;}

break;

case 16:

#line 210 "wql.y"

#line 210 "WQL.y"

{

WQLOperation op = yyvsp[0].intValue ? WQL_IS_TRUE : WQL_IS_FALSE;

globalParserState->statement->appendOperation(op);

;

}

break;}

break;

case 17:

#line 215 "wql.y"

#line 215 "WQL.y"

{

WQLOperation op = yyvsp[0].intValue ? WQL_IS_NOT_TRUE : WQL_IS_NOT_FALSE;

globalParserState->statement->appendOperation(op);

;

}

break;}

break;

case 18:

#line 224 "wql.y"

#line 224 "WQL.y"

{

;

}

break;}

break;

case 19:

#line 228 "wql.y"

#line 228 "WQL.y"

{

;

}

break;}

break;

case 20:

#line 234 "wql.y"

#line 234 "WQL.y"

{

WQL_TRACE(("YACC: TOK_LT\n"));

globalParserState->statement->appendOperation(WQL_LT);

;

}

break;}

break;

case 21:

#line 239 "wql.y"

#line 239 "WQL.y"

{

WQL_TRACE(("YACC: TOK_GT\n"));

globalParserState->statement->appendOperation(WQL_GT);

;

}

break;}

break;

case 22:

#line 244 "wql.y"

#line 244 "WQL.y"

{

WQL_TRACE(("YACC: TOK_LE\n"));

globalParserState->statement->appendOperation(WQL_LE);

;

}

break;}

break;

case 23:

#line 249 "wql.y"

#line 249 "WQL.y"

{

WQL_TRACE(("YACC: TOK_GE\n"));

globalParserState->statement->appendOperation(WQL_GE);

;

}

break;}

break;

case 24:

#line 254 "wql.y"

#line 254 "WQL.y"

{

WQL_TRACE(("YACC: TOK_EQ\n"));

globalParserState->statement->appendOperation(WQL_EQ);

;

}

break;}

break;

case 25:

#line 259 "wql.y"

#line 259 "WQL.y"

{

WQL_TRACE(("YACC: TOK_NE\n"));

globalParserState->statement->appendOperation(WQL_NE);

;

}

break;}

break;

case 26:

#line 266 "wql.y"

#line 266 "WQL.y"

{

WQL_TRACE(("YACC: nullPredicate : comparisonTerm IS NULL\n"));

globalParserState->statement->appendOperation(WQL_IS_NULL);

;

}

break;}

break;

case 27:

#line 271 "wql.y"

#line 271 "WQL.y"

{

WQL_TRACE(("YACC: nullPredicate : comparisonTerm IS NOT NULL\n"));

globalParserState->statement->appendOperation(WQL_IS_NOT_NULL);

;

}

break;}

break;

case 28:

#line 278 "wql.y"

#line 278 "WQL.y"

{

yyval.intValue = 1;

;

}

break;}

break;

case 29:

#line 282 "wql.y"

#line 282 "WQL.y"

{

yyval.intValue = 0;

;

}

break;}

break;

case 30:

#line 288 "wql.y"

#line 288 "WQL.y"

{

WQL_TRACE(("YACC: propertyName : TOK_IDENTIFIER(%s)\n", yyvsp[0].strValue));

yyval.strValue = yyvsp[0].strValue;

;

}

break;}

break;

case 31:

#line 294 "wql.y"

#line 294 "WQL.y"

{

WQL_TRACE(("YACC: TOK_IDENTIFIER %s\n", yyvsp[0].strValue));

yyval.strValue = yyvsp[0].strValue;

;

}

break;}

break;

case 32:

#line 301 "wql.y"

#line 301 "WQL.y"

{

globalParserState->statement->appendOperand(

WQLOperand(yyvsp[0].strValue, WQL_PROPERTY_NAME_TAG));

globalParserState->statement->appendWherePropertyName(CIMName(yyvsp[0].strValue));

;

}

break;}

break;

case 33:

#line 307 "wql.y"

#line 307 "WQL.y"

{

globalParserState->statement->appendOperand(

WQLOperand(yyvsp[0].intValue, WQL_INTEGER_VALUE_TAG));

;

}

break;}

break;

case 34:

#line 312 "wql.y"

#line 312 "WQL.y"

{

globalParserState->statement->appendOperand(

WQLOperand(yyvsp[0].doubleValue, WQL_DOUBLE_VALUE_TAG));

;

}

break;}

break;

case 35:

#line 317 "wql.y"

#line 317 "WQL.y"

{

globalParserState->statement->appendOperand(

WQLOperand(yyvsp[0].strValue, WQL_STRING_VALUE_TAG));

;

}

break;}

break;

case 36:

#line 322 "wql.y"

#line 322 "WQL.y"

{

globalParserState->statement->appendOperand(

WQLOperand(yyvsp[0].intValue != 0, WQL_BOOLEAN_VALUE_TAG));

;

break;}

}

/* the action file gets copied in in place of this dollarsign */

#line 543 "bison.simple"

yyvsp -= yylen;

yyssp -= yylen;

#ifdef YYLSP_NEEDED

yylsp -= yylen;

#endif

#if YYDEBUG != 0

if (yydebug)

{

short *ssp1 = yyss - 1;

fprintf (stderr, "state stack now");

while (ssp1 != yyssp)

fprintf (stderr, " %d", *++ssp1);

fprintf (stderr, "\n");

}

#endif

*++yyvsp = yyval;

#ifdef YYLSP_NEEDED

yylsp++;

if (yylen == 0)

{

yylsp->first_line = yylloc.first_line;

yylsp->first_column = yylloc.first_column;

yylsp->last_line = (yylsp-1)->last_line;

yylsp->last_column = (yylsp-1)->last_column;

yylsp->text = 0;

}

else

{

yylsp->last_line = (yylsp+yylen-1)->last_line;

yylsp->last_column = (yylsp+yylen-1)->last_column;

}

#endif

/* Now "shift" the result of the reduction.

Determine what state that goes to,

based on the state we popped back to

and the rule number reduced by. */

yyn = yyr1[yyn];

yystate = yypgoto[yyn - YYNTBASE] + *yyssp;

if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)

yystate = yytable[yystate];

else

yystate = yydefgoto[yyn - YYNTBASE];

goto yynewstate;

yyerrlab: /* here on detecting error */

if (! yyerrstatus)

/* If not already recovering from an error, report this error. */

{

++yynerrs;

#ifdef YYERROR_VERBOSE

yyn = yypact[yystate];

if (yyn > YYFLAG && yyn < YYLAST)

{

int size = 0;

char *msg;

int x, count;

count = 0;

/* Start X at -yyn if nec to avoid negative indexes in yycheck. */

for (x = (yyn < 0 ? -yyn : 0);

x < (sizeof(yytname) / sizeof(char *)); x++)

if (yycheck[x + yyn] == x)

size += strlen(yytname[x]) + 15, count++;

msg = (char *) malloc(size + 15);

if (msg != 0)

{

strcpy(msg, "parse error");

if (count < 5)

{

count = 0;

for (x = (yyn < 0 ? -yyn : 0);

x < (sizeof(yytname) / sizeof(char *)); x++)

if (yycheck[x + yyn] == x)

{

strcat(msg, count == 0 ? ", expecting `" : " or `");

strcat(msg, yytname[x]);

strcat(msg, "'");

count++;

}

yyerror(msg);

free(msg);

}

else

yyerror ("parse error; also virtual memory exceeded");

}

else

break;

#endif /* YYERROR_VERBOSE */

#line 736 "y.tab.c"

yyerror("parse error");

}

yyssp -= yym;

goto yyerrlab1;

yystate = *yyssp;

yyerrlab1: /* here on error raised explicitly by an action */

yyvsp -= yym;

yym = yylhs[yyn];

if (yyerrstatus == 3)

if (yystate == 0 && yym == 0)

{

/* if just tried and failed to reuse lookahead token after an error, discard it. */

#if YYDEBUG

/* return failure if at end of input */

if (yychar == YYEOF)

YYABORT;

#if YYDEBUG != 0

if (yydebug)

fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);

printf("%sdebug: after reduction, shifting from state 0 to\

state %d\n", YYPREFIX, YYFINAL);

#endif

yystate = YYFINAL;

yychar = YYEMPTY;

*++yyssp = YYFINAL;

}

*++yyvsp = yyval;

if (yychar < 0)

/* Else will try to reuse lookahead token

{

after shifting the error token. */

if ((yychar = yylex()) < 0) yychar = 0;

#if YYDEBUG

yyerrstatus = 3; /* Each real token shifted decrements this */

goto yyerrhandle;

yyerrdefault: /* current state does not do anything special for the error token. */

#if 0

/* This is wrong; only states that explicitly want error tokens

should shift them. */

yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/

if (yyn) goto yydefault;

#endif

yyerrpop: /* pop the current state because it cannot handle the error token */

if (yyssp == yyss) YYABORT;

yyvsp--;

yystate = *--yyssp;

#ifdef YYLSP_NEEDED

yylsp--;

#endif

#if YYDEBUG != 0

if (yydebug)

{

short *ssp1 = yyss - 1;

yys = 0;

fprintf (stderr, "Error: state stack now");

if (yychar <= YYMAXTOKEN) yys = yyname[yychar];

while (ssp1 != yyssp)

if (!yys) yys = "illegal-symbol";

fprintf (stderr, " %d", *++ssp1);

printf("%sdebug: state %d, reading %d (%s)\n",

fprintf (stderr, "\n");

YYPREFIX, YYFINAL, yychar, yys);

}

#endif

yyerrhandle:

yyn = yypact[yystate];

if (yyn == YYFLAG)

goto yyerrdefault;

yyn += YYTERROR;

if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)

goto yyerrdefault;

yyn = yytable[yyn];

if (yyn < 0)

{

if (yyn == YYFLAG)

goto yyerrpop;

yyn = -yyn;

goto yyreduce;

}

else if (yyn == 0)

if (yychar == 0) goto yyaccept;

goto yyerrpop;

goto yyloop;

}

if (yyn == YYFINAL)

if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&

YYACCEPT;

yyn <= YYTABLESIZE && yycheck[yyn] == yystate)

yystate = yytable[yyn];

#if YYDEBUG != 0

else

yystate = yydgoto[yym];

#if YYDEBUG

if (yydebug)

fprintf(stderr, "Shifting error token, ");

printf("%sdebug: after reduction, shifting from state %d \

#endif

to state %d\n", YYPREFIX, *yyssp, yystate);

*++yyvsp = yylval;

#ifdef YYLSP_NEEDED

*++yylsp = yylloc;

#endif

if (yyssp >= yysslim && yygrowstack())

yystate = yyn;

goto yynewstate;

yyacceptlab:

/* YYACCEPT comes here. */

if (yyfree_stacks)

{

free (yyss);

goto yyoverflow;

free (yyvs);

#ifdef YYLSP_NEEDED

free (yyls);

#endif

}

return 0;

*++yyssp = yystate;

*++yyvsp = yyval;

yyabortlab:

goto yyloop;

/* YYABORT comes here. */

yyoverflow:

if (yyfree_stacks)

yyerror("yacc stack overflow");

{

yyabort:

free (yyss);

return (1);

free (yyvs);

yyaccept:

#ifdef YYLSP_NEEDED

return (0);

free (yyls);

#endif

}

return 1;

}

#line 327 "wql.y"

Legend:

Removed from v.1.6.2.1
changed lines
	Added in v.1.6.2.2

No CVS admin address has been configured