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.2 and 1.12

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

version 1.12, 2005/05/16 20:51:25

Line 1

#ifndef lint

static char const

/* A Bison parser, made from wql.y

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

by GNU Bison version 1.28 */

#endif

#include <stdlib.h>

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

#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 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_ISA 263

#define yydefred WQL_defred

#define TOK_EQ 264

#define yydgoto WQL_dgoto

#define TOK_NE 265

#define yysindex WQL_sindex

#define TOK_LT 266

#define yyrindex WQL_rindex

#define TOK_LE 267

#define yygindex WQL_gindex

#define TOK_GT 268

#define yytable WQL_table

#define TOK_GE 269

#define yycheck WQL_check

#define TOK_NOT 270

#define yyname WQL_name

#define TOK_OR 271

#define yyrule WQL_rule

#define TOK_AND 272

#define yysslim WQL_sslim

#define TOK_IS 273

#define yystacksize WQL_stacksize

#define TOK_IDENTIFIER 274

#define YYPREFIX "WQL_"

#define TOK_SELECT 275

#line 10 "WQL.y"

#define TOK_WHERE 276

#define TOK_FROM 277

#define TOK_UNEXPECTED_CHAR 278

#line 37 "wql.y"

#include <Pegasus/Common/Config.h>

#include <Pegasus/WQL/WQLOperation.h>

Line 66

Line 62

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 78

Line 74

PEGASUS_NAMESPACE_END

#line 58 "WQL.y"

#line 86 "wql.y"

typedef union

{

int intValue;

Line 86

Line 83

char* strValue;

void* nodeValue;

} YYSTYPE;

#line 90 "y.tab.c"

#include <stdio.h>

#define YYERRCODE 256

#define TOK_INTEGER 257

#ifndef __cplusplus

#define TOK_DOUBLE 258

#ifndef __STDC__

#define TOK_STRING 259

#define const

#define TOK_TRUE 260

#endif

#define TOK_FALSE 261

#endif

#define TOK_NULL 262

#define TOK_EQ 263

#define TOK_NE 264

#define TOK_LT 265

#define YYFINAL 63

#define TOK_LE 266

#define YYFLAG -32768

#define TOK_GT 267

#define YYNTBASE 29

#define TOK_GE 268

#define TOK_NOT 269

#define YYTRANSLATE(x) ((unsigned)(x) <= 278 ? yytranslate[x] : 44)

#define TOK_OR 270

#define TOK_AND 271

static const char yytranslate[] = { 0,

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

#define TOK_WHERE 275

2, 2, 2, 2, 2, 2, 2, 2, 2, 27,

#define TOK_FROM 276

28, 25, 2, 26, 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, 24

};

#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, 89, 94, 96,

98, 100, 102, 104, 106, 108, 110

};

static const short yyrhs[] = { 30,

0, 21, 31, 33, 0, 25, 0, 32, 0, 41,

0, 32, 26, 41, 0, 34, 35, 0, 34, 0,

23, 42, 0, 22, 36, 0, 36, 17, 36, 0,

36, 18, 36, 0, 16, 36, 0, 27, 36, 28,

0, 37, 0, 37, 19, 40, 0, 37, 19, 16,

40, 0, 38, 0, 39, 0, 43, 12, 43, 0,

43, 14, 43, 0, 43, 13, 43, 0, 43, 15,

43, 0, 43, 10, 43, 0, 43, 11, 43, 0,

41, 9, 42, 0, 43, 19, 8, 0, 43, 19,

16, 8, 0, 6, 0, 7, 0, 20, 0, 20,

0, 41, 0, 3, 0, 4, 0, 5, 0, 40,

};

#endif

#if YYDEBUG != 0

static const short yyrline[] = { 0,

159, 165, 171, 175, 181, 185, 191, 195, 201, 208,

214, 219, 224, 230, 234, 238, 243, 252, 256, 262,

267, 272, 277, 282, 287, 292, 301, 306, 313, 317,

323, 329, 336, 342, 347, 352, 357

};

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

29, 30, 31, 31, 32, 32, 33, 33, 34, 35,

36, 36, 36, 36, 36, 36, 36, 37, 37, 38,

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

41, 42, 43, 43, 43, 43, 43

};

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,

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

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

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

};

static const short yydefact[] = { 0,

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

0, 32, 9, 0, 7, 6, 34, 35, 36, 29,

30, 0, 0, 10, 15, 18, 19, 37, 33, 0,

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

0, 0, 0, 14, 11, 12, 0, 16, 26, 33,

24, 25, 20, 22, 21, 23, 27, 0, 17, 28,

0, 0, 0

};

static const short yydefgoto[] = { 61,

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

28, 50, 13, 30

};

static const short yypact[] = { -9,

32,-32768,-32768,-32768, -8, 5,-32768, 22,-32768, 37,

38,-32768,-32768, -2,-32768,-32768,-32768,-32768,-32768,-32768,

-32768, -2, -2, 36, 41,-32768,-32768,-32768, 52, 26,

-32768, -11, -2, -2, 28, 22, 23, 23, 23, 23,

23, 23, 8,-32768, 44,-32768, 49,-32768,-32768,-32768,

-32768,-32768,-32768,-32768,-32768,-32768,-32768, 55,-32768,-32768,

64, 65,-32768

};

const short WQL_defred[] = { 0,

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

static const short yypgoto[] = {-32768,

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

-32768,-32768,-32768,-32768,-32768,-32768, -14,-32768,-32768,-32768,

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

-24, -1, 30, 9

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

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

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

};

const short WQL_dgoto[] = { 2,

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

12, 15, 30, 31,

};

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,

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

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

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

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

};

const short WQL_rindex[] = { 0,

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,

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

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

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

};

const short WQL_gindex[] = { 0,

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

0, 0, -21, -23,

};

#define YYTABLESIZE 273

const short WQL_table[] = { 24,

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

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

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

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

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

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[] = {

"$accept : start",

"start : selectStatement",

"selectStatement : TOK_SELECT selectList selectExpression",

"selectList : '*'",

"selectList : propertyList",

"propertyList : propertyName",

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

};

#define YYLAST 66

static const short yytable[] = { 7,

17, 18, 19, 20, 21, 33, 34, 31, 32, 16,

48, 1, 29, 22, 8, 57, 44, 3, 45, 46,

29, 29, 59, 58, 23, 17, 18, 19, 20, 21,

11, 29, 29, 20, 21, 37, 38, 39, 40, 41,

42, 12, 3, 47, 43, 51, 52, 53, 54, 55,

56, 3, 33, 34, 20, 21, 4, 3, 14, 35,

36, 34, 60, 62, 63, 49

};

static const short yycheck[] = { 1,

3, 4, 5, 6, 7, 17, 18, 22, 23, 11,

35, 21, 14, 16, 23, 8, 28, 20, 33, 34,

22, 23, 47, 16, 27, 3, 4, 5, 6, 7,

26, 33, 34, 6, 7, 10, 11, 12, 13, 14,

15, 20, 20, 16, 19, 37, 38, 39, 40, 41,

42, 20, 17, 18, 6, 7, 25, 20, 22, 19,

9, 18, 8, 0, 0, 36

};

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

#if YYDEBUG

#else /* not MSDOS, or __TURBOC__ */

#include <stdio.h>

#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

#ifdef YYSTACKSIZE

#undef YYMAXDEPTH

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

#define YYMAXDEPTH YYSTACKSIZE

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 10000

#define YYLEX yylex(&yylval)

#define YYMAXDEPTH 10000

#endif

#endif /* not YYLSP_NEEDED */

#endif

#define YYINITSTACKSIZE 200

int yydebug;

/* If nonreentrant, generate the variables here */

int yynerrs;

int yyerrflag;

#ifndef YYPURE

int yychar;

short *yyssp;

int yychar; /* the lookahead symbol */

YYSTYPE *yyvsp;

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

YYSTYPE yyval;

/* lookahead symbol */

YYSTYPE yylval;

short *yyss;

#ifdef YYLSP_NEEDED

short *yysslim;

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

YYSTYPE *yyvs;

/* symbol */

int yystacksize;

#endif

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

static int yygrowstack()

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

{

#endif /* not YYPURE */

int newsize, i;

short *newss;

#if YYDEBUG != 0

YYSTYPE *newvs;

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

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

if ((newsize = yystacksize) == 0)

from coexisting. */

newsize = YYINITSTACKSIZE;

#endif

else if (newsize >= YYMAXDEPTH)

return -1;

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

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

newsize = YYMAXDEPTH;

#ifndef YYINITDEPTH

i = yyssp - yyss;

#define YYINITDEPTH 200

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

#endif

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

if (newss == NULL)

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

return -1;

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

yyss = newss;

yyssp = newss + i;

#if YYMAXDEPTH == 0

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

#undef YYMAXDEPTH

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

#endif

if (newvs == NULL)

return -1;

#ifndef YYMAXDEPTH

yyvs = newvs;

#define YYMAXDEPTH 10000

yyvsp = newvs + i;

#endif

yystacksize = newsize;

yysslim = yyss + newsize - 1;

/* Define __yy_memcpy. Note that the size argument

return 0;

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

}

#define YYABORT goto yyabort

#else /* __cplusplus */

#define YYREJECT goto yyabort

#define YYACCEPT goto yyaccept

/* This is the most reliable way to avoid incompatibilities

#define YYERROR goto yyerrlab

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

static void

#ifndef YYPARSE_PARAM

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

#if defined(__cplusplus) || __STDC__

{

#define YYPARSE_PARAM_ARG void

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 /* ! ANSI-C/C++ */

#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 /* ANSI-C/C++ */

#endif /* not YYPARSE_PARAM */

#else /* YYPARSE_PARAM */

#ifndef YYPARSE_PARAM_TYPE

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

#define YYPARSE_PARAM_TYPE void *

#ifdef __GNUC__

#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

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

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

{

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

yyn = *yys;

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

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

yydebug = yyn - '0';

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

}

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

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

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

yyssp = yyss - 1;

yyssp = yyss;

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

}

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

yyss = yyss1; yyvs = yyvs1;

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

#ifdef YYLSP_NEEDED

{

yyls = yyls1;

#if YYDEBUG

if (yydebug)

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

YYPREFIX, yystate, yytable[yyn]);

#endif

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

#else /* no yyoverflow */

/* Extend the stack our own way. */

if (yystacksize >= YYMAXDEPTH)

{

yyerror("parser stack overflow");

if (yyfree_stacks)

{

goto yyoverflow;

free (yyss);

free (yyvs);

#ifdef YYLSP_NEEDED

free (yyls);

#endif

}

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

return 2;

*++yyvsp = yylval;

yychar = (-1);

if (yyerrflag > 0) --yyerrflag;

goto yyloop;

}

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

yystacksize *= 2;

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

if (yystacksize > YYMAXDEPTH)

{

yystacksize = YYMAXDEPTH;

yyn = yytable[yyn];

#ifndef YYSTACK_USE_ALLOCA

goto yyreduce;

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)

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

#endif

if (yyssp >= yyss + yystacksize - 1)

YYABORT;

}

if (yyerrflag) goto yyinrecovery;

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

#if YYDEBUG != 0

goto yynewerror;

if (yydebug)

#endif

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

yynewerror:

yyerror("syntax error");

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

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 >= yysslim && yygrowstack())

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

yym = yylen[yyn];

yyval = yyvsp[1-yym];

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

switch (yyn)

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

#line 160 "wql.y"

{

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

}

;

break;

break;}

case 2:

#line 137 "WQL.y"

#line 166 "wql.y"

{

}

;

break;

break;}

case 3:

#line 143 "WQL.y"

#line 172 "wql.y"

{

globalParserState->statement->setAllProperties(true);

}

;

break;

break;}

case 4:

#line 147 "WQL.y"

#line 176 "wql.y"

{

}

;

break;

break;}

case 5:

#line 153 "WQL.y"

#line 182 "wql.y"

{

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

}

;

break;

break;}

case 6:

#line 157 "WQL.y"

#line 186 "wql.y"

{

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

}

;

break;

break;}

case 7:

#line 163 "WQL.y"

#line 192 "wql.y"

{

}

;

break;

break;}

case 8:

#line 167 "WQL.y"

#line 196 "wql.y"

{

}

;

break;

break;}

case 9:

#line 173 "WQL.y"

#line 202 "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 209 "wql.y"

{

}

;

break;

break;}

case 11:

#line 186 "WQL.y"

#line 215 "wql.y"

{

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

globalParserState->statement->appendOperation(WQL_OR);

}

;

break;

break;}

case 12:

#line 191 "WQL.y"

#line 220 "wql.y"

{

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

globalParserState->statement->appendOperation(WQL_AND);

}

;

break;

break;}

case 13:

#line 196 "WQL.y"

#line 225 "wql.y"

{

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

globalParserState->statement->appendOperation(WQL_NOT);

}

;

break;

break;}

case 14:

#line 202 "WQL.y"

#line 231 "wql.y"

{

}

;

break;

break;}

case 15:

#line 206 "WQL.y"

#line 235 "wql.y"

{

}

;

break;

break;}

case 16:

#line 210 "WQL.y"

#line 239 "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 244 "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 253 "wql.y"

{

}

;

break;

break;}

case 19:

#line 228 "WQL.y"

#line 257 "wql.y"

{

}

;

break;

break;}

case 20:

#line 234 "WQL.y"

#line 263 "wql.y"

{

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

globalParserState->statement->appendOperation(WQL_LT);

}

;

break;

break;}

case 21:

#line 239 "WQL.y"

#line 268 "wql.y"

{

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

globalParserState->statement->appendOperation(WQL_GT);

}

;

break;

break;}

case 22:

#line 244 "WQL.y"

#line 273 "wql.y"

{

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

globalParserState->statement->appendOperation(WQL_LE);

}

;

break;

break;}

case 23:

#line 249 "WQL.y"

#line 278 "wql.y"

{

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

globalParserState->statement->appendOperation(WQL_GE);

}

;

break;

break;}

case 24:

#line 254 "WQL.y"

#line 283 "wql.y"

{

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

globalParserState->statement->appendOperation(WQL_EQ);

}

;

break;

break;}

case 25:

#line 259 "WQL.y"

#line 288 "wql.y"

{

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

globalParserState->statement->appendOperation(WQL_NE);

}

;

break;

break;}

case 26:

#line 266 "WQL.y"

#line 293 "wql.y"

{

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

#ifndef PEGASUS_SNIA_EXTENSIONS

yyerror("ISA Token Not Supported");

#endif

;

break;}

case 27:

#line 302 "wql.y"

{

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

globalParserState->statement->appendOperation(WQL_IS_NULL);

}

;

break;

break;}

case 27:

case 28:

#line 271 "WQL.y"

#line 307 "wql.y"

{

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

globalParserState->statement->appendOperation(WQL_IS_NOT_NULL);

}

;

break;

break;}

case 28:

case 29:

#line 278 "WQL.y"

#line 314 "wql.y"

{

yyval.intValue = 1;

}

;

break;

break;}

case 29:

case 30:

#line 282 "WQL.y"

#line 318 "wql.y"

{

yyval.intValue = 0;

}

;

break;

break;}

case 30:

case 31:

#line 288 "WQL.y"

#line 324 "wql.y"

{

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

yyval.strValue = yyvsp[0].strValue;

}

;

break;

break;}

case 31:

case 32:

#line 294 "WQL.y"

#line 330 "wql.y"

{

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

yyval.strValue = yyvsp[0].strValue;

}

;

break;

break;}

case 32:

case 33:

#line 301 "WQL.y"

#line 337 "wql.y"

{

globalParserState->statement->appendOperand(

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

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

}

;

break;

break;}

case 33:

case 34:

#line 307 "WQL.y"

#line 343 "wql.y"

{

globalParserState->statement->appendOperand(

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

}

;

break;

break;}

case 34:

case 35:

#line 312 "WQL.y"

#line 348 "wql.y"

{

globalParserState->statement->appendOperand(

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

}

;

break;

break;}

case 35:

case 36:

#line 317 "WQL.y"

#line 353 "wql.y"

{

globalParserState->statement->appendOperand(

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

}

;

break;

break;}

case 36:

case 37:

#line 322 "WQL.y"

#line 358 "wql.y"

{

globalParserState->statement->appendOperand(

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

;

break;}

}

break;

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

#line 736 "y.tab.c"

#line 543 "bison.simple"

}

yyssp -= yym;

yyvsp -= yylen;

yystate = *yyssp;

yyssp -= yylen;

yyvsp -= yym;

#ifdef YYLSP_NEEDED

yym = yylhs[yyn];

yylsp -= yylen;

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

#endif

{

#if YYDEBUG

#if YYDEBUG != 0

if (yydebug)

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

{

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

short *ssp1 = yyss - 1;

fprintf (stderr, "state stack now");

while (ssp1 != yyssp)

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

fprintf (stderr, "\n");

}

#endif

yystate = YYFINAL;

*++yyssp = YYFINAL;

*++yyvsp = yyval;

if (yychar < 0)

{

#ifdef YYLSP_NEEDED

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

yylsp++;

#if YYDEBUG

if (yylen == 0)

if (yydebug)

{

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

{

yys = 0;

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

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

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

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

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

YYPREFIX, YYFINAL, yychar, yys);

}

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

}

if (yychar == 0) goto yyaccept;

yyerror(msg);

goto yyloop;

free(msg);

}

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

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

yystate = yytable[yyn];

else

yystate = yydgoto[yym];

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

#if YYDEBUG

}

else

#endif /* YYERROR_VERBOSE */

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

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

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

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 363 "wql.y"

Legend:

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

No CVS admin address has been configured