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.1.2.9 and 1.5

version 1.1.2.9, 2001/12/03 06:14:26

version 1.5, 2003/10/22 14:26:14

Line 1

#ifndef lint

//%2003////////////////////////////////////////////////////////////////////////

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

#endif

#define YYBYACC 1

// Company, L. P., IBM Corp., The Open Group, Tivoli Systems.

#define YYMAJOR 1

#define YYMINOR 9

// IBM Corp.; EMC Corporation, The Open Group.

#define yyclearin (yychar=(-1))

#define yyerrok (yyerrflag=0)

// Permission is hereby granted, free of charge, to any person obtaining a copy

#define YYRECOVERING (yyerrflag!=0)

// of this software and associated documentation files (the "Software"), to

// deal in the Software without restriction, including without limitation the

// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

// sell copies of the Software, and to permit persons to whom the Software is

// furnished to do so, subject to the following conditions:

// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN

// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED

// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT

// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR

// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

//==============================================================================

/* A Bison parser, made from WQL.y

by GNU Bison version 1.28 */

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

#define yyparse WQL_parse

#define yylex WQL_lex

#define yyerror WQL_error

#define yychar WQL_char

#define yyval WQL_val

#define yylval WQL_lval

#define yychar WQL_char

#define yydebug WQL_debug

#define yynerrs WQL_nerrs

#define yyerrflag WQL_errflag

#define TOK_INTEGER 257

#define yyss WQL_ss

#define TOK_DOUBLE 258

#define yyssp WQL_ssp

#define TOK_STRING 259

#define yyvs WQL_vs

#define TOK_TRUE 260

#define yyvsp WQL_vsp

#define TOK_FALSE 261

#define yylhs WQL_lhs

#define TOK_NULL 262

#define yylen WQL_len

#define TOK_EQ 263

#define yydefred WQL_defred

#define TOK_NE 264

#define yydgoto WQL_dgoto

#define TOK_LT 265

#define yysindex WQL_sindex

#define TOK_LE 266

#define yyrindex WQL_rindex

#define TOK_GT 267

#define yygindex WQL_gindex

#define TOK_GE 268

#define yytable WQL_table

#define TOK_NOT 269

#define yycheck WQL_check

#define TOK_OR 270

#define yyname WQL_name

#define TOK_AND 271

#define yyrule WQL_rule

#define TOK_IS 272

#define YYPREFIX "WQL_"

#define TOK_IDENTIFIER 273

#line 10 "WQL.y"

#define TOK_SELECT 274

#define TOK_WHERE 275

#define TOK_FROM 276

#define TOK_UNEXPECTED_CHAR 277

#line 9 "WQL.y"

#include <Pegasus/Common/Config.h>

#include <Pegasus/WQL/WQLOperation.h>

Line 57

Line 83

#endif

extern int WQL_lex();

extern int WQL_error(char*);

extern int WQL_error(const char*);

/**/

/* Define the global parser state object:*/

// Define the global parser state object:

/**/

PEGASUS_USING_PEGASUS;

Line 71

Line 97

PEGASUS_NAMESPACE_END

#line 58 "WQL.y"

typedef union

{

Line 79

Line 106

char* strValue;

void* nodeValue;

} YYSTYPE;

#line 83 "y.tab.c"

#include <stdio.h>

#define TOK_INTEGER 257

#define TOK_DOUBLE 258

#ifndef __cplusplus

#define TOK_STRING 259

#ifndef __STDC__

#define TOK_TRUE 260

#define const

#define TOK_FALSE 261

#endif

#define TOK_NULL 262

#endif

#define TOK_EQ 263

#define TOK_NE 264

#define TOK_LT 265

#define TOK_LE 266

#define YYFINAL 60

#define TOK_GT 267

#define YYFLAG -32768

#define TOK_GE 268

#define YYNTBASE 28

#define TOK_NOT 269

#define TOK_OR 270

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

#define TOK_AND 271

#define TOK_IS 272

static const char yytranslate[] = { 0,

#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, 2,

#define TOK_WHERE 275

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

#define TOK_FROM 276

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

#define TOK_UNEXPECTED_CHAR 277

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

#define YYERRCODE 256

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

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

};

short WQL_len[] = { 2,

#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

};

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

};

short WQL_defred[] = { 0,

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

static const short yydefact[] = { 0,

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

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

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

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

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

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

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

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

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

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

};

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

short WQL_dgoto[] = { 2,

};

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

12, 15, 30, 31,

static const short yydefgoto[] = { 58,

};

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

short WQL_sindex[] = { -241,

28, 29, 13, 30

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

};

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

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

static const short yypact[] = { -5,

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

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

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

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

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

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

};

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

short WQL_rindex[] = { 0,

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

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

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

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

};

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

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

static const short yypgoto[] = {-32768,

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

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

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

-24, 9,-32768, 10

};

short WQL_gindex[] = { 0,

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

0, 0, -21, -23,

#define YYLAST 59

};

#define YYTABLESIZE 273

short WQL_table[] = { 24,

static const short yytable[] = { 17,

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

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

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

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

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

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

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

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

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

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

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

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

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,

};

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

char *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",

};

char *WQL_rule[] = {

"$accept : start",

static const short yycheck[] = { 3,

"start : selectStatement",

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

"selectStatement : TOK_SELECT selectList selectExpression",

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

"selectList : '*'",

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

"selectList : propertyList",

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

"propertyList : propertyName",

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

"propertyList : propertyList ',' propertyName",

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

"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

#ifdef YYSTACKSIZE

#else /* not MSDOS, or __TURBOC__ */

#undef YYMAXDEPTH

#if defined(_AIX)

#define YYMAXDEPTH YYSTACKSIZE

/* 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

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

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 YYPURE

#ifdef YYLSP_NEEDED

#ifdef YYLEX_PARAM

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

#else

#ifdef YYMAXDEPTH

#define YYLEX yylex(&yylval, &yylloc)

#define YYSTACKSIZE YYMAXDEPTH

#endif

#else /* not YYLSP_NEEDED */

#ifdef YYLEX_PARAM

#define YYLEX yylex(&yylval, YYLEX_PARAM)

#else

#define YYSTACKSIZE 500

#define YYLEX yylex(&yylval)

#define YYMAXDEPTH 500

#endif

#endif /* not YYLSP_NEEDED */

#endif

int yydebug;

int yynerrs;

/* If nonreentrant, generate the variables here */

int yyerrflag;

int yychar;

#ifndef YYPURE

short *yyssp;

YYSTYPE *yyvsp;

int yychar; /* the lookahead symbol */

YYSTYPE yyval;

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

YYSTYPE yylval;

/* lookahead symbol */

short yyss[YYSTACKSIZE];

YYSTYPE yyvs[YYSTACKSIZE];

#ifdef YYLSP_NEEDED

#define yystacksize YYSTACKSIZE

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

#define YYABORT goto yyabort

/* symbol */

#define YYREJECT goto yyabort

#endif

#define YYACCEPT goto yyaccept

#define YYERROR goto yyerrlab

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

#line 217 "bison.simple"

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

into yyparse. The argument should have type void *.

It should actually point to an object.

Grammar actions can access the variable by casting it

to the proper pointer type. */

#ifdef YYPARSE_PARAM

#ifdef __cplusplus

#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM

#define YYPARSE_PARAM_DECL

#else /* not __cplusplus */

#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 */

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

#ifdef __GNUC__

#ifdef YYPARSE_PARAM

int yyparse (void *);

#else

int yyparse (void);

#endif

int

yyparse()

yyparse(YYPARSE_PARAM_ARG)

YYPARSE_PARAM_DECL

{

#if YYDEBUG

extern char *getenv();

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;

yyerrflag = 0;

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

yychar = (-1);

yyssp = yyss;

/* 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;

yyvsp = yyvs;

*yyssp = yystate = 0;

#ifdef YYLSP_NEEDED

yylsp = yyls;

#endif

yyloop:

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

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

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

if (yychar < 0)

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

{

yynewstate:

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

#if YYDEBUG

*++yyssp = yystate;

if (yydebug)

if (yyssp >= yyss + yystacksize - 1)

{

yys = 0;

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

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

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

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

YYSTYPE *yyvs1 = yyvs;

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

short *yyss1 = yyss;

YYPREFIX, yystate, yychar, yys);

#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);

free (yyvs);

#ifdef YYLSP_NEEDED

free (yyls);

#endif

}

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

return 2;

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

}

{

yystacksize *= 2;

#if YYDEBUG

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,

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

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

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

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)

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

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

YYPREFIX, yystate, yytable[yyn]);

#endif

if (yyssp >= yyss + yystacksize - 1)

{

YYABORT;

goto yyoverflow;

}

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

*++yyvsp = yylval;

yychar = (-1);

if (yyerrflag > 0) --yyerrflag;

goto yyloop;

}

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

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

#if YYDEBUG != 0

{

if (yydebug)

yyn = yytable[yyn];

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

goto yyreduce;

}

if (yyerrflag) goto yyinrecovery;

#ifdef lint

goto yynewerror;

#endif

yynewerror:

yyerror("syntax error");

#ifdef lint

goto yyerrlab;

#endif

yyerrlab:

++yynerrs;

goto yybackup;

yyinrecovery:

yybackup:

if (yyerrflag < 3)

{

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

yyerrflag = 3;

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

for (;;)

/* yyresume: */

{

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

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

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

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

#if YYDEBUG != 0

if (yydebug)

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

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

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

#endif

if (yyssp >= yyss + yystacksize - 1)

yychar = YYLEX;

{

goto yyoverflow;

}

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

*++yyvsp = yylval;

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

goto yyloop;

}

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

else

{

#if YYDEBUG

yychar1 = 0;

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

#if YYDEBUG != 0

if (yydebug)

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

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

YYPREFIX, *yyssp);

#endif

if (yyssp <= yyss) goto yyabort;

--yyssp;

--yyvsp;

}

else

{

if (yychar == 0) goto yyabort;

yychar1 = YYTRANSLATE(yychar);

#if YYDEBUG

#if YYDEBUG != 0

if (yydebug)

{

yys = 0;

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

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

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

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

of a token, for further debugging info. */

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

#ifdef YYPRINT

YYPREFIX, yystate, yychar, yys);

YYPRINT (stderr, yychar, yylval);

#endif

fprintf (stderr, ")\n");

}

#endif

yychar = (-1);

goto yyloop;

}

yyreduce:

#if YYDEBUG

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)

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

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

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

#endif

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

if (yychar != YYEOF)

yychar = YYEMPTY;

*++yyvsp = yylval;

#ifdef YYLSP_NEEDED

*++yylsp = yylloc;

#endif

yym = yylen[yyn];

yyval = yyvsp[1-yym];

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

switch (yyn)

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 (yylen > 0)

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

#if YYDEBUG != 0

if (yydebug)

{

int i;

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

switch (yyn) {

case 1:

#line 131 "WQL.y"

{

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

}

;

break;

break;}

case 2:

#line 137 "WQL.y"

{

}

;

break;

break;}

case 3:

#line 143 "WQL.y"

{

globalParserState->statement->appendPropertyName("*");

globalParserState->statement->setAllProperties(true);

}

;

break;

break;}

case 4:

#line 147 "WQL.y"

{

}

;

break;

break;}

case 5:

#line 153 "WQL.y"

{

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

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

}

;

break;

break;}

case 6:

#line 157 "WQL.y"

{

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

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

}

;

break;

break;}

case 7:

#line 163 "WQL.y"

{

}

;

break;

break;}

case 8:

#line 167 "WQL.y"

{

}

;

break;

break;}

case 9:

#line 173 "WQL.y"

{

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

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

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

}

;

break;

break;}

case 10:

#line 180 "WQL.y"

{

}

;

break;

break;}

case 11:

#line 186 "WQL.y"

{

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

globalParserState->statement->appendOperation(WQL_OR);

}

;

break;

break;}

case 12:

#line 191 "WQL.y"

{

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

globalParserState->statement->appendOperation(WQL_AND);

}

;

break;

break;}

case 13:

#line 196 "WQL.y"

{

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

globalParserState->statement->appendOperation(WQL_NOT);

}

;

break;

break;}

case 14:

#line 202 "WQL.y"

{

}

;

break;

break;}

case 15:

#line 206 "WQL.y"

{

}

;

break;

break;}

case 16:

#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"

{

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"

{

}

;

break;

break;}

case 19:

#line 228 "WQL.y"

{

}

;

break;

break;}

case 20:

#line 234 "WQL.y"

{

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

globalParserState->statement->appendOperation(WQL_LT);

}

;

break;

break;}

case 21:

#line 239 "WQL.y"

{

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

globalParserState->statement->appendOperation(WQL_GT);

}

;

break;

break;}

case 22:

#line 244 "WQL.y"

{

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

globalParserState->statement->appendOperation(WQL_LE);

}

;

break;

break;}

case 23:

#line 249 "WQL.y"

{

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

globalParserState->statement->appendOperation(WQL_GE);

}

;

break;

break;}

case 24:

#line 254 "WQL.y"

{

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

globalParserState->statement->appendOperation(WQL_EQ);

}

;

break;

break;}

case 25:

#line 259 "WQL.y"

{

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

globalParserState->statement->appendOperation(WQL_NE);

}

;

break;

break;}

case 26:

#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"

{

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

globalParserState->statement->appendOperation(WQL_IS_NOT_NULL);

}

;

break;

break;}

case 28:

#line 278 "WQL.y"

{

yyval.intValue = 1;

}

;

break;

break;}

case 29:

#line 282 "WQL.y"

{

yyval.intValue = 0;

}

;

break;

break;}

case 30:

#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"

{

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

yyval.strValue = yyvsp[0].strValue;

}

;

break;

break;}

case 32:

#line 301 "WQL.y"

{

globalParserState->statement->appendOperand(

WQLOperand(yyvsp[0].strValue, WQLOperand::PROPERTY_NAME_TAG));

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

}

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

break;

;

break;}

case 33:

#line 306 "WQL.y"

#line 307 "WQL.y"

{

globalParserState->statement->appendOperand(

WQLOperand(yyvsp[0].intValue, WQLOperand::INTEGER_VALUE_TAG));

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

}

;

break;

break;}

case 34:

#line 311 "WQL.y"

#line 312 "WQL.y"

{

globalParserState->statement->appendOperand(

WQLOperand(yyvsp[0].doubleValue, WQLOperand::DOUBLE_VALUE_TAG));

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

}

;

break;

break;}

case 35:

#line 316 "WQL.y"

#line 317 "WQL.y"

{

globalParserState->statement->appendOperand(

WQLOperand(yyvsp[0].strValue, WQLOperand::STRING_VALUE_TAG));

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

}

;

break;

break;}

case 36:

#line 321 "WQL.y"

#line 322 "WQL.y"

{

globalParserState->statement->appendOperand(

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

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");

}

break;

#endif

#line 669 "y.tab.c"

*++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;

}

yyssp -= yym;

else

yystate = *yyssp;

yyvsp -= yym;

yym = yylhs[yyn];

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

{

#if YYDEBUG

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

if (yydebug)

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

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

}

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

#endif

yystate = YYFINAL;

*++yyssp = YYFINAL;

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

*++yyvsp = yyval;

Determine what state that goes to,

if (yychar < 0)

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. */

{

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

++yynerrs;

#if YYDEBUG

if (yydebug)

#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)

{

yys = 0;

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

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

strcat(msg, yytname[x]);

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

strcat(msg, "'");

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

count++;

YYPREFIX, YYFINAL, yychar, yys);

}

#endif

}

if (yychar == 0) goto yyaccept;

yyerror(msg);

goto yyloop;

free(msg);

}

else

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

}

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

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

yystate = yytable[yyn];

else

yystate = yydgoto[yym];

#endif /* YYERROR_VERBOSE */

#if YYDEBUG

yyerror("parse error");

}

goto yyerrlab1;

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

if (yyerrstatus == 3)

{

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

/* return failure if at end of input */

if (yychar == YYEOF)

YYABORT;

#if YYDEBUG != 0

if (yydebug)

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

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

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

#endif

if (yyssp >= yyss + yystacksize - 1)

yychar = YYEMPTY;

}

/* Else will try to reuse lookahead token

after shifting the error token. */

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)

{

goto yyoverflow;

short *ssp1 = yyss - 1;

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

while (ssp1 != yyssp)

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

fprintf (stderr, "\n");

}

*++yyssp = yystate;

#endif

*++yyvsp = yyval;

goto yyloop;

yyerrhandle:

yyoverflow:

yyerror("yacc stack overflow");

yyn = yypact[yystate];

yyabort:

if (yyn == YYFLAG)

return (1);

goto yyerrdefault;

yyaccept:

return (0);

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)

goto yyerrpop;

if (yyn == YYFINAL)

YYACCEPT;

#if YYDEBUG != 0

if (yydebug)

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

#endif

*++yyvsp = yylval;

#ifdef YYLSP_NEEDED

*++yylsp = yylloc;

#endif

yystate = yyn;

goto yynewstate;

yyacceptlab:

/* YYACCEPT comes here. */

if (yyfree_stacks)

{

free (yyss);

free (yyvs);

#ifdef YYLSP_NEEDED

free (yyls);

#endif

}

return 0;

yyabortlab:

/* YYABORT comes here. */

if (yyfree_stacks)

{

free (yyss);

free (yyvs);

#ifdef YYLSP_NEEDED

free (yyls);

#endif

}

return 1;

}

#line 327 "WQL.y"

Legend:

Removed from v.1.1.2.9
changed lines
	Added in v.1.5

No CVS admin address has been configured