version 1.1.2.9, 2001/12/03 06:14:26
|
version 1.16, 2006/01/30 16:18:36
|
|
|
#ifndef lint |
//%2006//////////////////////////////////////////////////////////////////////// |
static char yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93"; |
// |
#endif |
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development |
#define YYBYACC 1 |
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems. |
#define YYMAJOR 1 |
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.; |
#define YYMINOR 9 |
// IBM Corp.; EMC Corporation, The Open Group. |
#define yyclearin (yychar=(-1)) |
// Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.; |
#define yyerrok (yyerrflag=0) |
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. |
#define YYRECOVERING (yyerrflag!=0) |
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; |
|
// EMC Corporation; VERITAS Software Corporation; The Open Group. |
|
// Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.; |
|
// EMC Corporation; Symantec Corporation; The Open Group. |
|
// |
|
// Permission is hereby granted, free of charge, to any person obtaining a copy |
|
// 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 by GNU Bison 1.875c. */ |
|
|
|
/* Skeleton parser for Yacc-like parsing with Bison, |
|
Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. |
|
|
|
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. */ |
|
|
|
/* Written by Richard Stallman by simplifying the original so called |
|
``semantic'' parser. */ |
|
|
|
/* All symbols defined below should begin with yy or YY, to avoid |
|
infringing on user name space. This should be done even for local |
|
variables, as they might otherwise be expanded by user macros. |
|
There are some unavoidable exceptions within include files to |
|
define necessary library symbols; they are noted "INFRINGES ON |
|
USER NAME SPACE" below. */ |
|
|
|
/* Identify Bison output. */ |
|
#define YYBISON 1 |
|
|
|
/* Skeleton name. */ |
|
#define YYSKELETON_NAME "yacc.c" |
|
|
|
/* Pure parsers. */ |
|
#define YYPURE 0 |
|
|
|
/* Using locations. */ |
|
#define YYLSP_NEEDED 0 |
|
|
|
/* If NAME_PREFIX is specified substitute the variables and functions |
|
names. */ |
#define yyparse WQL_parse | #define yyparse WQL_parse |
#define yylex WQL_lex | #define yylex WQL_lex |
#define yyerror WQL_error | #define yyerror WQL_error |
#define yychar WQL_char |
|
#define yyval WQL_val |
|
#define yylval WQL_lval | #define yylval WQL_lval |
|
#define yychar WQL_char |
#define yydebug WQL_debug | #define yydebug WQL_debug |
#define yynerrs WQL_nerrs | #define yynerrs WQL_nerrs |
#define yyerrflag WQL_errflag |
|
#define yyss WQL_ss |
|
#define yyssp WQL_ssp |
/* Tokens. */ |
#define yyvs WQL_vs |
#ifndef YYTOKENTYPE |
#define yyvsp WQL_vsp |
# define YYTOKENTYPE |
#define yylhs WQL_lhs |
/* Put the tokens into the symbol table, so that GDB and other debuggers |
#define yylen WQL_len |
know about them. */ |
#define yydefred WQL_defred |
enum yytokentype { |
#define yydgoto WQL_dgoto |
TOK_INTEGER = 258, |
#define yysindex WQL_sindex |
TOK_DOUBLE = 259, |
#define yyrindex WQL_rindex |
TOK_STRING = 260, |
#define yygindex WQL_gindex |
TOK_TRUE = 261, |
#define yytable WQL_table |
TOK_FALSE = 262, |
#define yycheck WQL_check |
TOK_NULL = 263, |
#define yyname WQL_name |
TOK_ISA = 264, |
#define yyrule WQL_rule |
TOK_DOT = 265, |
#define YYPREFIX "WQL_" |
TOK_EQ = 266, |
#line 10 "WQL.y" |
TOK_NE = 267, |
|
TOK_LT = 268, |
|
TOK_LE = 269, |
|
TOK_GT = 270, |
|
TOK_GE = 271, |
|
TOK_NOT = 272, |
|
TOK_OR = 273, |
|
TOK_AND = 274, |
|
TOK_IS = 275, |
|
TOK_IDENTIFIER = 276, |
|
TOK_SELECT = 277, |
|
TOK_WHERE = 278, |
|
TOK_FROM = 279, |
|
TOK_UNEXPECTED_CHAR = 280 |
|
}; |
|
#endif |
|
#define TOK_INTEGER 258 |
|
#define TOK_DOUBLE 259 |
|
#define TOK_STRING 260 |
|
#define TOK_TRUE 261 |
|
#define TOK_FALSE 262 |
|
#define TOK_NULL 263 |
|
#define TOK_ISA 264 |
|
#define TOK_DOT 265 |
|
#define TOK_EQ 266 |
|
#define TOK_NE 267 |
|
#define TOK_LT 268 |
|
#define TOK_LE 269 |
|
#define TOK_GT 270 |
|
#define TOK_GE 271 |
|
#define TOK_NOT 272 |
|
#define TOK_OR 273 |
|
#define TOK_AND 274 |
|
#define TOK_IS 275 |
|
#define TOK_IDENTIFIER 276 |
|
#define TOK_SELECT 277 |
|
#define TOK_WHERE 278 |
|
#define TOK_FROM 279 |
|
#define TOK_UNEXPECTED_CHAR 280 |
|
|
|
|
|
|
|
|
|
/* Copy the first part of user declarations. */ |
|
#line 37 "WQL.y" |
|
|
| |
#include <Pegasus/Common/Config.h> | #include <Pegasus/Common/Config.h> |
#include <Pegasus/WQL/WQLOperation.h> | #include <Pegasus/WQL/WQLOperation.h> |
|
|
#endif | #endif |
| |
extern int WQL_lex(); | 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; | PEGASUS_USING_PEGASUS; |
| |
|
|
| |
PEGASUS_NAMESPACE_END | PEGASUS_NAMESPACE_END |
| |
#line 58 "WQL.y" |
|
typedef union |
|
{ |
/* Enabling traces. */ |
|
#ifndef YYDEBUG |
|
# define YYDEBUG 0 |
|
#endif |
|
|
|
/* Enabling verbose error messages. */ |
|
#ifdef YYERROR_VERBOSE |
|
# undef YYERROR_VERBOSE |
|
# define YYERROR_VERBOSE 1 |
|
#else |
|
# define YYERROR_VERBOSE 0 |
|
#endif |
|
|
|
#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) |
|
#line 87 "WQL.y" |
|
typedef union YYSTYPE { |
int intValue; | int intValue; |
double doubleValue; | double doubleValue; |
char* strValue; | char* strValue; |
void* nodeValue; | void* nodeValue; |
} YYSTYPE; | } YYSTYPE; |
#line 83 "y.tab.c" |
/* Line 191 of yacc.c. */ |
#define TOK_INTEGER 257 |
#line 183 "WQLtemp" |
#define TOK_DOUBLE 258 |
# define yystype YYSTYPE /* obsolescent; will be withdrawn */ |
#define TOK_STRING 259 |
# define YYSTYPE_IS_DECLARED 1 |
#define TOK_TRUE 260 |
# define YYSTYPE_IS_TRIVIAL 1 |
#define TOK_FALSE 261 |
|
#define TOK_NULL 262 |
|
#define TOK_EQ 263 |
|
#define TOK_NE 264 |
|
#define TOK_LT 265 |
|
#define TOK_LE 266 |
|
#define TOK_GT 267 |
|
#define TOK_GE 268 |
|
#define TOK_NOT 269 |
|
#define TOK_OR 270 |
|
#define TOK_AND 271 |
|
#define TOK_IS 272 |
|
#define TOK_IDENTIFIER 273 |
|
#define TOK_SELECT 274 |
|
#define TOK_WHERE 275 |
|
#define TOK_FROM 276 |
|
#define TOK_UNEXPECTED_CHAR 277 |
|
#define YYERRCODE 256 |
|
short WQL_lhs[] = { -1, |
|
0, 9, 10, 10, 2, 2, 11, 11, 7, 8, |
|
6, 6, 6, 6, 6, 6, 6, 3, 3, 4, |
|
4, 4, 4, 4, 4, 5, 5, 13, 13, 1, |
|
12, 14, 14, 14, 14, 14, |
|
}; |
|
short WQL_len[] = { 2, |
|
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, |
|
}; |
|
short WQL_defred[] = { 0, |
|
0, 0, 1, 30, 3, 5, 0, 0, 0, 0, |
|
0, 2, 6, 31, 9, 0, 7, 33, 34, 35, |
|
28, 29, 0, 0, 32, 0, 18, 19, 0, 36, |
|
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, |
|
}; |
|
short WQL_dgoto[] = { 2, |
|
25, 7, 26, 27, 28, 29, 11, 17, 3, 8, |
|
12, 15, 30, 31, |
|
}; |
|
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, |
|
}; |
|
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, |
|
}; |
|
short WQL_gindex[] = { 0, |
|
11, 0, 0, 0, 0, -13, 0, 0, 0, 0, |
|
0, 0, -21, -23, |
|
}; |
|
#define YYTABLESIZE 273 |
|
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, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 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, |
|
0, 0, 0, 0, 0, 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, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, 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, |
|
-1, -1, -1, -1, -1, -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 | #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, |
/* Copy the second part of user declarations. */ |
0,0,0,0,0,0,"'('","')'","'*'",0,"','",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
/* Line 214 of yacc.c. */ |
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
#line 195 "WQLtemp" |
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
|
0,0,0,0,0,0,0,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", |
#if ! defined (yyoverflow) || YYERROR_VERBOSE |
"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", |
# ifndef YYFREE |
"TOK_IDENTIFIER","TOK_SELECT","TOK_WHERE","TOK_FROM","TOK_UNEXPECTED_CHAR", |
# define YYFREE free |
}; |
# endif |
char *WQL_rule[] = { |
# ifndef YYMALLOC |
"$accept : start", |
# define YYMALLOC malloc |
"start : selectStatement", |
# endif |
"selectStatement : TOK_SELECT selectList selectExpression", |
|
"selectList : '*'", |
/* The parser invokes alloca or malloc; define the necessary symbols. */ |
"selectList : propertyList", |
|
"propertyList : propertyName", |
# ifdef YYSTACK_USE_ALLOCA |
"propertyList : propertyList ',' propertyName", |
# if YYSTACK_USE_ALLOCA |
"selectExpression : fromClause whereClause", |
# define YYSTACK_ALLOC alloca |
"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", |
|
}; |
|
#endif | #endif |
#ifdef YYSTACKSIZE |
|
#undef YYMAXDEPTH |
|
#define YYMAXDEPTH YYSTACKSIZE |
|
#else | #else |
#ifdef YYMAXDEPTH |
# if defined (alloca) || defined (_ALLOCA_H) |
#define YYSTACKSIZE YYMAXDEPTH |
# define YYSTACK_ALLOC alloca |
#else | #else |
#define YYSTACKSIZE 500 |
# ifdef __GNUC__ |
#define YYMAXDEPTH 500 |
# define YYSTACK_ALLOC __builtin_alloca |
#endif | #endif |
#endif | #endif |
int yydebug; |
# endif |
int yynerrs; |
|
int yyerrflag; |
# ifdef YYSTACK_ALLOC |
int yychar; |
/* Pacify GCC's `empty if-body' warning. */ |
short *yyssp; |
# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) |
YYSTYPE *yyvsp; |
# else |
YYSTYPE yyval; |
# if defined (__STDC__) || defined (__cplusplus) |
YYSTYPE yylval; |
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ |
short yyss[YYSTACKSIZE]; |
# define YYSIZE_T size_t |
YYSTYPE yyvs[YYSTACKSIZE]; |
# endif |
#define yystacksize YYSTACKSIZE |
# define YYSTACK_ALLOC YYMALLOC |
#define YYABORT goto yyabort |
# define YYSTACK_FREE YYFREE |
#define YYREJECT goto yyabort |
# endif |
#define YYACCEPT goto yyaccept |
#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */ |
#define YYERROR goto yyerrlab |
|
int |
|
yyparse() |
#if (! defined (yyoverflow) \ |
|
&& (! defined (__cplusplus) \ |
|
|| (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL))) |
|
|
|
/* A type that is properly aligned for any stack member. */ |
|
union yyalloc |
{ | { |
register int yym, yyn, yystate; |
short yyss; |
|
YYSTYPE yyvs; |
|
}; |
|
|
|
/* The size of the maximum gap between one aligned stack and the next. */ |
|
# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) |
|
|
|
/* The size of an array large to enough to hold all stacks, each with |
|
N elements. */ |
|
# define YYSTACK_BYTES(N) \ |
|
((N) * (sizeof (short) + sizeof (YYSTYPE)) \ |
|
+ YYSTACK_GAP_MAXIMUM) |
|
|
|
/* Copy COUNT objects from FROM to TO. The source and destination do |
|
not overlap. */ |
|
# ifndef YYCOPY |
|
# if defined (__GNUC__) && 1 < __GNUC__ |
|
# define YYCOPY(To, From, Count) \ |
|
__builtin_memcpy (To, From, (Count) * sizeof (*(From))) |
|
# else |
|
# define YYCOPY(To, From, Count) \ |
|
do \ |
|
{ \ |
|
register YYSIZE_T yyi; \ |
|
for (yyi = 0; yyi < (Count); yyi++) \ |
|
(To)[yyi] = (From)[yyi]; \ |
|
} \ |
|
while (0) |
|
# endif |
|
# endif |
|
|
|
/* Relocate STACK from its old location to the new one. The |
|
local variables YYSIZE and YYSTACKSIZE give the old and new number of |
|
elements in the stack, and YYPTR gives the new location of the |
|
stack. Advance YYPTR to a properly aligned location for the next |
|
stack. */ |
|
# define YYSTACK_RELOCATE(Stack) \ |
|
do \ |
|
{ \ |
|
YYSIZE_T yynewbytes; \ |
|
YYCOPY (&yyptr->Stack, Stack, yysize); \ |
|
Stack = &yyptr->Stack; \ |
|
yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ |
|
yyptr += yynewbytes / sizeof (*yyptr); \ |
|
} \ |
|
while (0) |
|
|
|
#endif |
|
|
|
#if defined (__STDC__) || defined (__cplusplus) |
|
typedef signed char yysigned_char; |
|
#else |
|
typedef short yysigned_char; |
|
#endif |
|
|
|
/* YYFINAL -- State number of the termination state. */ |
|
#define YYFINAL 9 |
|
/* YYLAST -- Last index in YYTABLE. */ |
|
#define YYLAST 69 |
|
|
|
/* YYNTOKENS -- Number of terminals. */ |
|
#define YYNTOKENS 30 |
|
/* YYNNTS -- Number of nonterminals. */ |
|
#define YYNNTS 16 |
|
/* YYNRULES -- Number of rules. */ |
|
#define YYNRULES 39 |
|
/* YYNRULES -- Number of states. */ |
|
#define YYNSTATES 65 |
|
|
|
/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ |
|
#define YYUNDEFTOK 2 |
|
#define YYMAXUTOK 280 |
|
|
|
#define YYTRANSLATE(YYX) \ |
|
((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) |
|
|
|
/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ |
|
static const unsigned char yytranslate[] = |
|
{ |
|
0, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
28, 29, 26, 2, 27, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 1, 2, 3, 4, |
|
5, 6, 7, 8, 9, 10, 11, 12, 13, 14, |
|
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, |
|
25 |
|
}; |
|
|
#if YYDEBUG | #if YYDEBUG |
register char *yys; |
/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in |
extern char *getenv(); |
YYRHS. */ |
|
static const unsigned char yyprhs[] = |
|
{ |
|
0, 0, 3, 5, 9, 11, 13, 15, 19, 22, |
|
24, 27, 30, 34, 38, 41, 45, 47, 51, 56, |
|
58, 60, 64, 68, 72, 76, 80, 84, 88, 92, |
|
97, 99, 101, 103, 107, 109, 111, 113, 115, 117 |
|
}; |
| |
if (yys = getenv("YYDEBUG")) |
/* YYRHS -- A `-1'-separated list of the rules' RHS. */ |
|
static const yysigned_char yyrhs[] = |
{ | { |
yyn = *yys; |
31, 0, -1, 32, -1, 22, 33, 35, -1, 26, |
if (yyn >= '0' && yyn <= '9') |
-1, 34, -1, 43, -1, 34, 27, 43, -1, 36, |
yydebug = yyn - '0'; |
37, -1, 36, -1, 24, 44, -1, 23, 38, -1, |
} |
38, 18, 38, -1, 38, 19, 38, -1, 17, 38, |
|
-1, 28, 38, 29, -1, 39, -1, 39, 20, 42, |
|
-1, 39, 20, 17, 42, -1, 40, -1, 41, -1, |
|
45, 13, 45, -1, 45, 15, 45, -1, 45, 14, |
|
45, -1, 45, 16, 45, -1, 45, 11, 45, -1, |
|
45, 12, 45, -1, 43, 9, 44, -1, 45, 20, |
|
8, -1, 45, 20, 17, 8, -1, 6, -1, 7, |
|
-1, 21, -1, 21, 10, 21, -1, 21, -1, 43, |
|
-1, 3, -1, 4, -1, 5, -1, 42, -1 |
|
}; |
|
|
|
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ |
|
static const unsigned short yyrline[] = |
|
{ |
|
0, 160, 160, 166, 172, 176, 182, 186, 192, 196, |
|
202, 209, 215, 220, 225, 231, 235, 239, 244, 253, |
|
257, 263, 268, 273, 278, 283, 288, 293, 303, 308, |
|
315, 319, 332, 337, 349, 356, 362, 367, 372, 377 |
|
}; |
#endif | #endif |
| |
yynerrs = 0; |
#if YYDEBUG || YYERROR_VERBOSE |
yyerrflag = 0; |
/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. |
yychar = (-1); |
First, the terminals, then, starting at YYNTOKENS, nonterminals. */ |
|
static const char *const yytname[] = |
|
{ |
|
"$end", "error", "$undefined", "TOK_INTEGER", "TOK_DOUBLE", |
|
"TOK_STRING", "TOK_TRUE", "TOK_FALSE", "TOK_NULL", "TOK_ISA", "TOK_DOT", |
|
"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", "'*'", "','", "'('", |
|
"')'", "$accept", "start", "selectStatement", "selectList", |
|
"propertyList", "selectExpression", "fromClause", "whereClause", |
|
"searchCondition", "predicate", "comparisonPredicate", "nullPredicate", |
|
"truthValue", "propertyName", "className", "comparisonTerm", 0 |
|
}; |
|
#endif |
| |
yyssp = yyss; |
# ifdef YYPRINT |
yyvsp = yyvs; |
/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to |
*yyssp = yystate = 0; |
token YYLEX-NUM. */ |
|
static const unsigned short yytoknum[] = |
|
{ |
|
0, 256, 257, 258, 259, 260, 261, 262, 263, 264, |
|
265, 266, 267, 268, 269, 270, 271, 272, 273, 274, |
|
275, 276, 277, 278, 279, 280, 42, 44, 40, 41 |
|
}; |
|
# endif |
| |
yyloop: |
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ |
if (yyn = yydefred[yystate]) goto yyreduce; |
static const unsigned char yyr1[] = |
if (yychar < 0) |
|
{ | { |
if ((yychar = yylex()) < 0) yychar = 0; |
0, 30, 31, 32, 33, 33, 34, 34, 35, 35, |
|
36, 37, 38, 38, 38, 38, 38, 38, 38, 39, |
|
39, 40, 40, 40, 40, 40, 40, 40, 41, 41, |
|
42, 42, 43, 43, 44, 45, 45, 45, 45, 45 |
|
}; |
|
|
|
/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ |
|
static const unsigned char yyr2[] = |
|
{ |
|
0, 2, 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, 3, 4, |
|
1, 1, 1, 3, 1, 1, 1, 1, 1, 1 |
|
}; |
|
|
|
/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state |
|
STATE-NUM when YYTABLE doesn't specify something else to do. Zero |
|
means the default is an error. */ |
|
static const unsigned char yydefact[] = |
|
{ |
|
0, 0, 0, 2, 32, 4, 0, 5, 6, 1, |
|
0, 0, 3, 9, 0, 33, 34, 10, 0, 8, |
|
7, 36, 37, 38, 30, 31, 0, 0, 11, 16, |
|
19, 20, 39, 35, 0, 14, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 15, 12, |
|
13, 0, 17, 27, 35, 25, 26, 21, 23, 22, |
|
24, 28, 0, 18, 29 |
|
}; |
|
|
|
/* YYDEFGOTO[NTERM-NUM]. */ |
|
static const yysigned_char yydefgoto[] = |
|
{ |
|
-1, 2, 3, 6, 7, 12, 13, 19, 28, 29, |
|
30, 31, 32, 54, 17, 34 |
|
}; |
|
|
|
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing |
|
STATE-NUM. */ |
|
#define YYPACT_NINF -38 |
|
static const yysigned_char yypact[] = |
|
{ |
|
-21, -10, 15, -38, 25, -38, 17, -8, -38, -38, |
|
28, 39, -38, 38, 41, -38, -38, -38, 1, -38, |
|
-38, -38, -38, -38, -38, -38, 1, 1, 5, 43, |
|
-38, -38, -38, 55, 31, -38, 9, 1, 1, 33, |
|
39, 27, 27, 27, 27, 27, 27, -5, -38, 46, |
|
-38, 52, -38, -38, -38, -38, -38, -38, -38, -38, |
|
-38, -38, 58, -38, -38 |
|
}; |
|
|
|
/* YYPGOTO[NTERM-NUM]. */ |
|
static const yysigned_char yypgoto[] = |
|
{ |
|
-38, -38, -38, -38, -38, -38, -38, -38, -17, -38, |
|
-38, -38, -37, -1, 29, 11 |
|
}; |
|
|
|
/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If |
|
positive, shift that token. If negative, reduce the rule which |
|
number is the opposite. If zero, do what YYDEFACT says. |
|
If YYTABLE_NINF, syntax error. */ |
|
#define YYTABLE_NINF -1 |
|
static const unsigned char yytable[] = |
|
{ |
|
8, 1, 52, 61, 21, 22, 23, 24, 25, 35, |
|
36, 4, 62, 20, 63, 9, 5, 33, 26, 14, |
|
49, 50, 4, 37, 38, 33, 33, 37, 38, 27, |
|
21, 22, 23, 24, 25, 10, 33, 33, 48, 24, |
|
25, 11, 41, 42, 43, 44, 45, 46, 4, 15, |
|
51, 47, 55, 56, 57, 58, 59, 60, 24, 25, |
|
16, 18, 4, 39, 40, 38, 64, 0, 0, 53 |
|
}; |
|
|
|
static const yysigned_char yycheck[] = |
|
{ |
|
1, 22, 39, 8, 3, 4, 5, 6, 7, 26, |
|
27, 21, 17, 14, 51, 0, 26, 18, 17, 27, |
|
37, 38, 21, 18, 19, 26, 27, 18, 19, 28, |
|
3, 4, 5, 6, 7, 10, 37, 38, 29, 6, |
|
7, 24, 11, 12, 13, 14, 15, 16, 21, 21, |
|
17, 20, 41, 42, 43, 44, 45, 46, 6, 7, |
|
21, 23, 21, 20, 9, 19, 8, -1, -1, 40 |
|
}; |
|
|
|
/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing |
|
symbol of state STATE-NUM. */ |
|
static const unsigned char yystos[] = |
|
{ |
|
0, 22, 31, 32, 21, 26, 33, 34, 43, 0, |
|
10, 24, 35, 36, 27, 21, 21, 44, 23, 37, |
|
43, 3, 4, 5, 6, 7, 17, 28, 38, 39, |
|
40, 41, 42, 43, 45, 38, 38, 18, 19, 20, |
|
9, 11, 12, 13, 14, 15, 16, 20, 29, 38, |
|
38, 17, 42, 44, 43, 45, 45, 45, 45, 45, |
|
45, 8, 17, 42, 8 |
|
}; |
|
|
|
#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) |
|
# define YYSIZE_T __SIZE_TYPE__ |
|
#endif |
|
#if ! defined (YYSIZE_T) && defined (size_t) |
|
# define YYSIZE_T size_t |
|
#endif |
|
#if ! defined (YYSIZE_T) |
|
# if defined (__STDC__) || defined (__cplusplus) |
|
# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ |
|
# define YYSIZE_T size_t |
|
# endif |
|
#endif |
|
#if ! defined (YYSIZE_T) |
|
# define YYSIZE_T unsigned int |
|
#endif |
|
|
|
#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 yyerrorlab |
|
|
|
|
|
/* 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); \ |
|
yytoken = YYTRANSLATE (yychar); \ |
|
YYPOPSTACK; \ |
|
goto yybackup; \ |
|
} \ |
|
else \ |
|
{ \ |
|
yyerror ("syntax error: cannot back up");\ |
|
YYERROR; \ |
|
} \ |
|
while (0) |
|
|
|
#define YYTERROR 1 |
|
#define YYERRCODE 256 |
|
|
|
/* YYLLOC_DEFAULT -- Compute the default location (before the actions |
|
are run). */ |
|
|
|
#ifndef YYLLOC_DEFAULT |
|
# define YYLLOC_DEFAULT(Current, Rhs, N) \ |
|
((Current).first_line = (Rhs)[1].first_line, \ |
|
(Current).first_column = (Rhs)[1].first_column, \ |
|
(Current).last_line = (Rhs)[N].last_line, \ |
|
(Current).last_column = (Rhs)[N].last_column) |
|
#endif |
|
|
|
/* YYLEX -- calling `yylex' with the right arguments. */ |
|
|
|
#ifdef YYLEX_PARAM |
|
# define YYLEX yylex (YYLEX_PARAM) |
|
#else |
|
# define YYLEX yylex () |
|
#endif |
|
|
|
/* Enable debugging if requested. */ |
#if YYDEBUG | #if YYDEBUG |
if (yydebug) |
|
|
# ifndef YYFPRINTF |
|
# include <stdio.h> /* INFRINGES ON USER NAME SPACE */ |
|
# define YYFPRINTF fprintf |
|
# endif |
|
|
|
# define YYDPRINTF(Args) \ |
|
do { \ |
|
if (yydebug) \ |
|
YYFPRINTF Args; \ |
|
} while (0) |
|
|
|
# define YYDSYMPRINT(Args) \ |
|
do { \ |
|
if (yydebug) \ |
|
yysymprint Args; \ |
|
} while (0) |
|
|
|
# define YYDSYMPRINTF(Title, Token, Value, Location) \ |
|
do { \ |
|
if (yydebug) \ |
|
{ \ |
|
YYFPRINTF (stderr, "%s ", Title); \ |
|
yysymprint (stderr, \ |
|
Token, Value); \ |
|
YYFPRINTF (stderr, "\n"); \ |
|
} \ |
|
} while (0) |
|
|
|
/*------------------------------------------------------------------. |
|
| yy_stack_print -- Print the state stack from its BOTTOM up to its | |
|
| TOP (included). | |
|
`------------------------------------------------------------------*/ |
|
|
|
#if defined (__STDC__) || defined (__cplusplus) |
|
static void |
|
yy_stack_print (short *bottom, short *top) |
|
#else |
|
static void |
|
yy_stack_print (bottom, top) |
|
short *bottom; |
|
short *top; |
|
#endif |
{ | { |
yys = 0; |
YYFPRINTF (stderr, "Stack now"); |
if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; |
for (/* Nothing. */; bottom <= top; ++bottom) |
if (!yys) yys = "illegal-symbol"; |
YYFPRINTF (stderr, " %d", *bottom); |
printf("%sdebug: state %d, reading %d (%s)\n", |
YYFPRINTF (stderr, "\n"); |
YYPREFIX, yystate, yychar, yys); |
} |
} |
|
|
# define YY_STACK_PRINT(Bottom, Top) \ |
|
do { \ |
|
if (yydebug) \ |
|
yy_stack_print ((Bottom), (Top)); \ |
|
} while (0) |
|
|
|
|
|
/*------------------------------------------------. |
|
| Report that the YYRULE is going to be reduced. | |
|
`------------------------------------------------*/ |
|
|
|
#if defined (__STDC__) || defined (__cplusplus) |
|
static void |
|
yy_reduce_print (int yyrule) |
|
#else |
|
static void |
|
yy_reduce_print (yyrule) |
|
int yyrule; |
#endif | #endif |
} |
|
if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 && |
|
yyn <= YYTABLESIZE && yycheck[yyn] == yychar) |
|
{ | { |
#if YYDEBUG |
int yyi; |
if (yydebug) |
unsigned int yylno = yyrline[yyrule]; |
printf("%sdebug: state %d, shifting to state %d\n", |
YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ", |
YYPREFIX, yystate, yytable[yyn]); |
yyrule - 1, yylno); |
|
/* Print the symbols being reduced, and their result. */ |
|
for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++) |
|
YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]); |
|
YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]); |
|
} |
|
|
|
# define YY_REDUCE_PRINT(Rule) \ |
|
do { \ |
|
if (yydebug) \ |
|
yy_reduce_print (Rule); \ |
|
} while (0) |
|
|
|
/* Nonzero means print parse trace. It is left uninitialized so that |
|
multiple parsers can coexist. */ |
|
int yydebug; |
|
#else /* !YYDEBUG */ |
|
# define YYDPRINTF(Args) |
|
# define YYDSYMPRINT(Args) |
|
# define YYDSYMPRINTF(Title, Token, Value, Location) |
|
# define YY_STACK_PRINT(Bottom, Top) |
|
# define YY_REDUCE_PRINT(Rule) |
|
#endif /* !YYDEBUG */ |
|
|
|
|
|
/* YYINITDEPTH -- initial size of the parser's stacks. */ |
|
#ifndef YYINITDEPTH |
|
# define YYINITDEPTH 200 |
|
#endif |
|
|
|
/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only |
|
if the built-in stack extension method is used). |
|
|
|
Do not make this value too large; the results are undefined if |
|
SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) |
|
evaluated with infinite-precision integer arithmetic. */ |
|
|
|
#if defined (YYMAXDEPTH) && YYMAXDEPTH == 0 |
|
# undef YYMAXDEPTH |
|
#endif |
|
|
|
#ifndef YYMAXDEPTH |
|
# define YYMAXDEPTH 10000 |
|
#endif |
|
|
|
|
|
|
|
#if YYERROR_VERBOSE |
|
|
|
# ifndef yystrlen |
|
# if defined (__GLIBC__) && defined (_STRING_H) |
|
# define yystrlen strlen |
|
# else |
|
/* Return the length of YYSTR. */ |
|
static YYSIZE_T |
|
# if defined (__STDC__) || defined (__cplusplus) |
|
yystrlen (const char *yystr) |
|
# else |
|
yystrlen (yystr) |
|
const char *yystr; |
#endif | #endif |
if (yyssp >= yyss + yystacksize - 1) |
|
{ | { |
goto yyoverflow; |
register const char *yys = yystr; |
} |
|
*++yyssp = yystate = yytable[yyn]; |
while (*yys++ != '\0') |
*++yyvsp = yylval; |
continue; |
yychar = (-1); |
|
if (yyerrflag > 0) --yyerrflag; |
return yys - yystr - 1; |
goto yyloop; |
|
} | } |
if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 && |
# endif |
yyn <= YYTABLESIZE && yycheck[yyn] == yychar) |
# endif |
|
|
|
# ifndef yystpcpy |
|
# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) |
|
# define yystpcpy stpcpy |
|
# else |
|
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in |
|
YYDEST. */ |
|
static char * |
|
# if defined (__STDC__) || defined (__cplusplus) |
|
yystpcpy (char *yydest, const char *yysrc) |
|
# else |
|
yystpcpy (yydest, yysrc) |
|
char *yydest; |
|
const char *yysrc; |
|
# endif |
{ | { |
yyn = yytable[yyn]; |
register char *yyd = yydest; |
goto yyreduce; |
register const char *yys = yysrc; |
|
|
|
while ((*yyd++ = *yys++) != '\0') |
|
continue; |
|
|
|
return yyd - 1; |
} | } |
if (yyerrflag) goto yyinrecovery; |
|
#ifdef lint |
|
goto yynewerror; |
|
#endif | #endif |
yynewerror: |
|
yyerror("syntax error"); |
|
#ifdef lint |
|
goto yyerrlab; |
|
#endif | #endif |
yyerrlab: |
|
++yynerrs; |
#endif /* !YYERROR_VERBOSE */ |
yyinrecovery: |
|
if (yyerrflag < 3) |
|
|
|
|
#if YYDEBUG |
|
/*--------------------------------. |
|
| Print this symbol on YYOUTPUT. | |
|
`--------------------------------*/ |
|
|
|
#if defined (__STDC__) || defined (__cplusplus) |
|
static void |
|
yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep) |
|
#else |
|
static void |
|
yysymprint (yyoutput, yytype, yyvaluep) |
|
FILE *yyoutput; |
|
int yytype; |
|
YYSTYPE *yyvaluep; |
|
#endif |
{ | { |
yyerrflag = 3; |
/* Pacify ``unused variable'' warnings. */ |
for (;;) |
(void) yyvaluep; |
|
|
|
if (yytype < YYNTOKENS) |
{ | { |
if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 && |
YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); |
yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE) |
# ifdef YYPRINT |
|
YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); |
|
# endif |
|
} |
|
else |
|
YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); |
|
|
|
switch (yytype) |
{ | { |
#if YYDEBUG |
default: |
if (yydebug) |
break; |
printf("%sdebug: state %d, error recovery shifting\ |
} |
to state %d\n", YYPREFIX, *yyssp, yytable[yyn]); |
YYFPRINTF (yyoutput, ")"); |
|
} |
|
|
|
#endif /* ! YYDEBUG */ |
|
/*-----------------------------------------------. |
|
| Release the memory associated to this symbol. | |
|
`-----------------------------------------------*/ |
|
|
|
#if defined (__STDC__) || defined (__cplusplus) |
|
static void |
|
yydestruct (int yytype, YYSTYPE *yyvaluep) |
|
#else |
|
static void |
|
yydestruct (yytype, yyvaluep) |
|
int yytype; |
|
YYSTYPE *yyvaluep; |
#endif | #endif |
if (yyssp >= yyss + yystacksize - 1) |
|
{ | { |
goto yyoverflow; |
/* Pacify ``unused variable'' warnings. */ |
|
(void) yyvaluep; |
|
|
|
switch (yytype) |
|
{ |
|
|
|
default: |
|
break; |
} | } |
*++yyssp = yystate = yytable[yyn]; |
|
*++yyvsp = yylval; |
|
goto yyloop; |
|
} | } |
else |
|
|
|
|
/* Prevent warnings from -Wmissing-prototypes. */ |
|
|
|
#ifdef YYPARSE_PARAM |
|
# if defined (__STDC__) || defined (__cplusplus) |
|
int yyparse (void *YYPARSE_PARAM); |
|
# else |
|
int yyparse (); |
|
# endif |
|
#else /* ! YYPARSE_PARAM */ |
|
#if defined (__STDC__) || defined (__cplusplus) |
|
int yyparse (void); |
|
#else |
|
int yyparse (); |
|
#endif |
|
#endif /* ! YYPARSE_PARAM */ |
|
|
|
|
|
|
|
/* The lookahead symbol. */ |
|
int yychar; |
|
|
|
/* The semantic value of the lookahead symbol. */ |
|
YYSTYPE yylval; |
|
|
|
/* Number of syntax errors so far. */ |
|
int yynerrs; |
|
|
|
|
|
|
|
/*----------. |
|
| yyparse. | |
|
`----------*/ |
|
|
|
#ifdef YYPARSE_PARAM |
|
# if defined (__STDC__) || defined (__cplusplus) |
|
int yyparse (void *YYPARSE_PARAM) |
|
# else |
|
int yyparse (YYPARSE_PARAM) |
|
void *YYPARSE_PARAM; |
|
# endif |
|
#else /* ! YYPARSE_PARAM */ |
|
#if defined (__STDC__) || defined (__cplusplus) |
|
int |
|
yyparse (void) |
|
#else |
|
int |
|
yyparse () |
|
|
|
#endif |
|
#endif |
{ | { |
#if YYDEBUG |
|
if (yydebug) |
register int yystate; |
printf("%sdebug: error recovery discarding state %d\n", |
register int yyn; |
YYPREFIX, *yyssp); |
int yyresult; |
#endif |
/* Number of tokens to shift before error messages enabled. */ |
if (yyssp <= yyss) goto yyabort; |
int yyerrstatus; |
--yyssp; |
/* Lookahead token as an internal (translated) token number. */ |
--yyvsp; |
int yytoken = 0; |
|
|
|
/* Three stacks and their tools: |
|
`yyss': related to states, |
|
`yyvs': related to semantic values, |
|
`yyls': related to locations. |
|
|
|
Refer to the stacks thru separate pointers, to allow yyoverflow |
|
to reallocate them elsewhere. */ |
|
|
|
/* The state stack. */ |
|
short yyssa[YYINITDEPTH]; |
|
short *yyss = yyssa; |
|
register short *yyssp; |
|
|
|
/* The semantic value stack. */ |
|
YYSTYPE yyvsa[YYINITDEPTH]; |
|
YYSTYPE *yyvs = yyvsa; |
|
register YYSTYPE *yyvsp; |
|
|
|
|
|
|
|
#define YYPOPSTACK (yyvsp--, yyssp--) |
|
|
|
YYSIZE_T yystacksize = YYINITDEPTH; |
|
|
|
/* The variables used to return semantic value and location from the |
|
action routines. */ |
|
YYSTYPE yyval; |
|
|
|
|
|
/* When reducing, the number of symbols on the RHS of the reduced |
|
rule. */ |
|
int yylen; |
|
|
|
YYDPRINTF ((stderr, "Starting parse\n")); |
|
|
|
yystate = 0; |
|
yyerrstatus = 0; |
|
yynerrs = 0; |
|
yychar = YYEMPTY; /* Cause a token to be read. */ |
|
|
|
/* 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; |
|
yyvsp = yyvs; |
|
|
|
goto yysetstate; |
|
|
|
/*------------------------------------------------------------. |
|
| yynewstate -- Push a new state, which is found in yystate. | |
|
`------------------------------------------------------------*/ |
|
yynewstate: |
|
/* In all cases, when you get here, the value and location stacks |
|
have just been pushed. so pushing a state here evens the stacks. |
|
*/ |
|
yyssp++; |
|
|
|
yysetstate: |
|
*yyssp = yystate; |
|
|
|
if (yyss + yystacksize - 1 <= yyssp) |
|
{ |
|
/* Get the current used size of the three stacks, in elements. */ |
|
YYSIZE_T yysize = yyssp - yyss + 1; |
|
|
|
#ifdef yyoverflow |
|
{ |
|
/* Give user a chance to reallocate the stack. Use copies of |
|
these so that the &'s don't force the real ones into |
|
memory. */ |
|
YYSTYPE *yyvs1 = yyvs; |
|
short *yyss1 = yyss; |
|
|
|
|
|
/* Each stack pointer address is followed by the size of the |
|
data in use in that stack, in bytes. 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, yysize * sizeof (*yyssp), |
|
&yyvs1, yysize * sizeof (*yyvsp), |
|
|
|
&yystacksize); |
|
|
|
yyss = yyss1; |
|
yyvs = yyvs1; |
|
} |
|
#else /* no yyoverflow */ |
|
# ifndef YYSTACK_RELOCATE |
|
goto yyoverflowlab; |
|
# else |
|
/* Extend the stack our own way. */ |
|
if (YYMAXDEPTH <= yystacksize) |
|
goto yyoverflowlab; |
|
yystacksize *= 2; |
|
if (YYMAXDEPTH < yystacksize) |
|
yystacksize = YYMAXDEPTH; |
|
|
|
{ |
|
short *yyss1 = yyss; |
|
union yyalloc *yyptr = |
|
(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); |
|
if (! yyptr) |
|
goto yyoverflowlab; |
|
YYSTACK_RELOCATE (yyss); |
|
YYSTACK_RELOCATE (yyvs); |
|
|
|
# undef YYSTACK_RELOCATE |
|
if (yyss1 != yyssa) |
|
YYSTACK_FREE (yyss1); |
|
} |
|
# endif |
|
#endif /* no yyoverflow */ |
|
|
|
yyssp = yyss + yysize - 1; |
|
yyvsp = yyvs + yysize - 1; |
|
|
|
|
|
YYDPRINTF ((stderr, "Stack size increased to %lu\n", |
|
(unsigned long int) yystacksize)); |
|
|
|
if (yyss + yystacksize - 1 <= yyssp) |
|
YYABORT; |
} | } |
|
|
|
YYDPRINTF ((stderr, "Entering state %d\n", yystate)); |
|
|
|
goto yybackup; |
|
|
|
/*-----------. |
|
| yybackup. | |
|
`-----------*/ |
|
yybackup: |
|
|
|
/* Do appropriate processing given the current state. */ |
|
/* Read a lookahead token if we need one and don't already have one. */ |
|
/* yyresume: */ |
|
|
|
/* First try to decide what to do without reference to lookahead token. */ |
|
|
|
yyn = yypact[yystate]; |
|
if (yyn == YYPACT_NINF) |
|
goto yydefault; |
|
|
|
/* Not known => get a lookahead token if don't already have one. */ |
|
|
|
/* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ |
|
if (yychar == YYEMPTY) |
|
{ |
|
YYDPRINTF ((stderr, "Reading a token: ")); |
|
yychar = YYLEX; |
} | } |
|
|
|
if (yychar <= YYEOF) |
|
{ |
|
yychar = yytoken = YYEOF; |
|
YYDPRINTF ((stderr, "Now at end of input.\n")); |
} | } |
else | else |
{ | { |
if (yychar == 0) goto yyabort; |
yytoken = YYTRANSLATE (yychar); |
#if YYDEBUG |
YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc); |
if (yydebug) |
|
{ |
|
yys = 0; |
|
if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; |
|
if (!yys) yys = "illegal-symbol"; |
|
printf("%sdebug: state %d, error recovery discards token %d (%s)\n", |
|
YYPREFIX, yystate, yychar, yys); |
|
} | } |
#endif |
|
yychar = (-1); |
/* If the proper action on seeing token YYTOKEN is to reduce or to |
goto yyloop; |
detect an error, take that action. */ |
|
yyn += yytoken; |
|
if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) |
|
goto yydefault; |
|
yyn = yytable[yyn]; |
|
if (yyn <= 0) |
|
{ |
|
if (yyn == 0 || yyn == YYTABLE_NINF) |
|
goto yyerrlab; |
|
yyn = -yyn; |
|
goto yyreduce; |
} | } |
|
|
|
if (yyn == YYFINAL) |
|
YYACCEPT; |
|
|
|
/* Shift the lookahead token. */ |
|
YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken])); |
|
|
|
/* Discard the token being shifted unless it is eof. */ |
|
if (yychar != YYEOF) |
|
yychar = YYEMPTY; |
|
|
|
*++yyvsp = yylval; |
|
|
|
|
|
/* Count tokens shifted since error; after three, turn off error |
|
status. */ |
|
if (yyerrstatus) |
|
yyerrstatus--; |
|
|
|
yystate = yyn; |
|
goto yynewstate; |
|
|
|
|
|
/*-----------------------------------------------------------. |
|
| yydefault -- do the default action for the current state. | |
|
`-----------------------------------------------------------*/ |
|
yydefault: |
|
yyn = yydefact[yystate]; |
|
if (yyn == 0) |
|
goto yyerrlab; |
|
goto yyreduce; |
|
|
|
|
|
/*-----------------------------. |
|
| yyreduce -- Do a reduction. | |
|
`-----------------------------*/ |
yyreduce: | yyreduce: |
#if YYDEBUG |
/* yyn is the number of a rule to reduce with. */ |
if (yydebug) |
yylen = yyr2[yyn]; |
printf("%sdebug: state %d, reducing by rule %d (%s)\n", |
|
YYPREFIX, yystate, yyn, yyrule[yyn]); |
/* If YYLEN is nonzero, implement the default value of the action: |
#endif |
`$$ = $1'. |
yym = yylen[yyn]; |
|
yyval = yyvsp[1-yym]; |
Otherwise, the following line sets YYVAL to garbage. |
|
This behavior is undocumented and Bison |
|
users should not rely upon it. Assigning to YYVAL |
|
unconditionally makes the parser a bit smaller, and it avoids a |
|
GCC warning that YYVAL may be used uninitialized. */ |
|
yyval = yyvsp[1-yylen]; |
|
|
|
|
|
YY_REDUCE_PRINT (yyn); |
switch (yyn) | switch (yyn) |
{ | { |
case 1: |
case 2: |
#line 131 "WQL.y" |
#line 161 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: start\n")); | WQL_TRACE(("YACC: start\n")); |
} |
;} |
break; | break; |
case 2: |
|
#line 137 "WQL.y" |
|
{ |
|
| |
} |
|
break; |
|
case 3: | case 3: |
#line 143 "WQL.y" |
#line 167 "WQL.y" |
{ | { |
globalParserState->statement->appendPropertyName("*"); |
|
} |
;} |
break; | break; |
|
|
case 4: | case 4: |
#line 147 "WQL.y" |
#line 173 "WQL.y" |
{ | { |
|
globalParserState->statement->setAllProperties(true); |
} |
;} |
break; | break; |
|
|
case 5: | case 5: |
#line 153 "WQL.y" |
#line 177 "WQL.y" |
{ | { |
globalParserState->statement->appendPropertyName(yyvsp[0].strValue); |
|
} |
;} |
break; | break; |
|
|
case 6: | case 6: |
#line 157 "WQL.y" |
#line 183 "WQL.y" |
{ | { |
globalParserState->statement->appendPropertyName(yyvsp[0].strValue); |
globalParserState->statement->appendSelectPropertyName(CIMName(yyvsp[0].strValue)); |
} |
;} |
break; | break; |
|
|
case 7: | case 7: |
#line 163 "WQL.y" |
#line 187 "WQL.y" |
{ | { |
|
globalParserState->statement->appendSelectPropertyName(CIMName(yyvsp[0].strValue)); |
} |
;} |
break; | break; |
|
|
case 8: | case 8: |
#line 167 "WQL.y" |
#line 193 "WQL.y" |
{ | { |
| |
} |
;} |
break; | break; |
|
|
case 9: | case 9: |
#line 173 "WQL.y" |
#line 197 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: fromClause: TOK_FROM className(%s)\n", yyvsp[0].strValue)); |
|
globalParserState->statement->setClassName(yyvsp[0].strValue); |
;} |
} |
|
break; | break; |
|
|
case 10: | case 10: |
#line 180 "WQL.y" |
#line 203 "WQL.y" |
{ | { |
|
WQL_TRACE(("YACC: fromClause: TOK_FROM className(%s)\n", yyvsp[0].strValue)); |
} |
globalParserState->statement->setClassName(CIMName(yyvsp[0].strValue)); |
|
;} |
break; | break; |
|
|
case 11: | case 11: |
#line 186 "WQL.y" |
#line 210 "WQL.y" |
|
{ |
|
|
|
;} |
|
break; |
|
|
|
case 12: |
|
#line 216 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: TOK_OR\n")); | WQL_TRACE(("YACC: TOK_OR\n")); |
globalParserState->statement->appendOperation(WQL_OR); | globalParserState->statement->appendOperation(WQL_OR); |
} |
;} |
break; | break; |
case 12: |
|
#line 191 "WQL.y" |
case 13: |
|
#line 221 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: TOK_AND\n")); | WQL_TRACE(("YACC: TOK_AND\n")); |
globalParserState->statement->appendOperation(WQL_AND); | globalParserState->statement->appendOperation(WQL_AND); |
} |
;} |
break; | break; |
case 13: |
|
#line 196 "WQL.y" |
case 14: |
|
#line 226 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: TOK_NOT\n")); | WQL_TRACE(("YACC: TOK_NOT\n")); |
| |
globalParserState->statement->appendOperation(WQL_NOT); | globalParserState->statement->appendOperation(WQL_NOT); |
} |
;} |
break; | break; |
case 14: |
|
#line 202 "WQL.y" |
|
{ |
|
| |
} |
|
break; |
|
case 15: | case 15: |
#line 206 "WQL.y" |
#line 232 "WQL.y" |
{ | { |
| |
} |
;} |
break; | break; |
|
|
case 16: | case 16: |
#line 210 "WQL.y" |
#line 236 "WQL.y" |
{ | { |
WQLOperation op = yyvsp[0].intValue ? WQL_IS_TRUE : WQL_IS_FALSE; |
|
globalParserState->statement->appendOperation(op); |
;} |
} |
|
break; | break; |
|
|
case 17: | case 17: |
#line 215 "WQL.y" |
#line 240 "WQL.y" |
{ | { |
WQLOperation op = yyvsp[0].intValue ? WQL_IS_NOT_TRUE : WQL_IS_NOT_FALSE; |
WQLOperation op = yyvsp[0].intValue ? WQL_IS_TRUE : WQL_IS_FALSE; |
globalParserState->statement->appendOperation(op); | globalParserState->statement->appendOperation(op); |
} |
;} |
break; | break; |
|
|
case 18: | case 18: |
#line 224 "WQL.y" |
#line 245 "WQL.y" |
{ | { |
|
WQLOperation op = yyvsp[0].intValue ? WQL_IS_NOT_TRUE : WQL_IS_NOT_FALSE; |
} |
globalParserState->statement->appendOperation(op); |
|
;} |
break; | break; |
|
|
case 19: | case 19: |
#line 228 "WQL.y" |
#line 254 "WQL.y" |
{ | { |
| |
} |
;} |
break; | break; |
|
|
case 20: | case 20: |
#line 234 "WQL.y" |
#line 258 "WQL.y" |
|
{ |
|
|
|
;} |
|
break; |
|
|
|
case 21: |
|
#line 264 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: TOK_LT\n")); | WQL_TRACE(("YACC: TOK_LT\n")); |
globalParserState->statement->appendOperation(WQL_LT); | globalParserState->statement->appendOperation(WQL_LT); |
} |
;} |
break; | break; |
case 21: |
|
#line 239 "WQL.y" |
case 22: |
|
#line 269 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: TOK_GT\n")); | WQL_TRACE(("YACC: TOK_GT\n")); |
globalParserState->statement->appendOperation(WQL_GT); | globalParserState->statement->appendOperation(WQL_GT); |
} |
;} |
break; | break; |
case 22: |
|
#line 244 "WQL.y" |
case 23: |
|
#line 274 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: TOK_LE\n")); | WQL_TRACE(("YACC: TOK_LE\n")); |
globalParserState->statement->appendOperation(WQL_LE); | globalParserState->statement->appendOperation(WQL_LE); |
} |
;} |
break; | break; |
case 23: |
|
#line 249 "WQL.y" |
case 24: |
|
#line 279 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: TOK_GE\n")); | WQL_TRACE(("YACC: TOK_GE\n")); |
globalParserState->statement->appendOperation(WQL_GE); | globalParserState->statement->appendOperation(WQL_GE); |
} |
;} |
break; | break; |
case 24: |
|
#line 254 "WQL.y" |
case 25: |
|
#line 284 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: TOK_EQ\n")); | WQL_TRACE(("YACC: TOK_EQ\n")); |
globalParserState->statement->appendOperation(WQL_EQ); | globalParserState->statement->appendOperation(WQL_EQ); |
} |
;} |
break; | break; |
case 25: |
|
#line 259 "WQL.y" |
case 26: |
|
#line 289 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: TOK_NE\n")); | WQL_TRACE(("YACC: TOK_NE\n")); |
globalParserState->statement->appendOperation(WQL_NE); | globalParserState->statement->appendOperation(WQL_NE); |
} |
;} |
break; | break; |
case 26: |
|
#line 266 "WQL.y" |
case 27: |
|
#line 294 "WQL.y" |
|
{ |
|
WQL_TRACE(("YACC: TOK_ISA\n")); |
|
#ifndef PEGASUS_SNIA_EXTENSIONS |
|
// If SNIA tests, allow the ISA but do not pass className |
|
yyerror("ISA Token Not Supported"); |
|
#endif |
|
;} |
|
break; |
|
|
|
case 28: |
|
#line 304 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: nullPredicate : comparisonTerm IS NULL\n")); | WQL_TRACE(("YACC: nullPredicate : comparisonTerm IS NULL\n")); |
globalParserState->statement->appendOperation(WQL_IS_NULL); | globalParserState->statement->appendOperation(WQL_IS_NULL); |
} |
;} |
break; | break; |
case 27: |
|
#line 271 "WQL.y" |
case 29: |
|
#line 309 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: nullPredicate : comparisonTerm IS NOT NULL\n")); | WQL_TRACE(("YACC: nullPredicate : comparisonTerm IS NOT NULL\n")); |
globalParserState->statement->appendOperation(WQL_IS_NOT_NULL); | globalParserState->statement->appendOperation(WQL_IS_NOT_NULL); |
} |
;} |
break; | break; |
case 28: |
|
#line 278 "WQL.y" |
case 30: |
|
#line 316 "WQL.y" |
{ | { |
yyval.intValue = 1; | yyval.intValue = 1; |
} |
;} |
break; | break; |
case 29: |
|
#line 282 "WQL.y" |
case 31: |
|
#line 320 "WQL.y" |
{ | { |
yyval.intValue = 0; | yyval.intValue = 0; |
} |
;} |
break; | break; |
case 30: |
|
#line 288 "WQL.y" |
case 32: |
|
#line 333 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: propertyName : TOK_IDENTIFIER(%s)\n", yyvsp[0].strValue)); | WQL_TRACE(("YACC: propertyName : TOK_IDENTIFIER(%s)\n", yyvsp[0].strValue)); |
yyval.strValue = yyvsp[0].strValue; | yyval.strValue = yyvsp[0].strValue; |
} |
;} |
break; | break; |
case 31: |
|
#line 294 "WQL.y" |
case 33: |
|
#line 338 "WQL.y" |
|
{ |
|
WQL_TRACE(("YACC: propertyName : TOK_IDENTIFIER(%s.%s)\n", yyvsp[-2].strValue, yyvsp[0].strValue)); |
|
#ifdef PEGASUS_SNIA_EXTENSIONS |
|
// Pass anything as a property name to fool parser for SNIA testing |
|
yyval.strValue = strdup("dummy"); |
|
#else |
|
yyerror("Scoped (dotted) property names not supported"); |
|
#endif |
|
;} |
|
break; |
|
|
|
case 34: |
|
#line 350 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: TOK_IDENTIFIER %s\n", yyvsp[0].strValue)); | WQL_TRACE(("YACC: TOK_IDENTIFIER %s\n", yyvsp[0].strValue)); |
yyval.strValue = yyvsp[0].strValue; | yyval.strValue = yyvsp[0].strValue; |
} |
;} |
break; | break; |
case 32: |
|
#line 301 "WQL.y" |
case 35: |
|
#line 357 "WQL.y" |
{ | { |
globalParserState->statement->appendOperand( | 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" |
case 36: |
|
#line 363 "WQL.y" |
{ | { |
globalParserState->statement->appendOperand( | 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" |
case 37: |
|
#line 368 "WQL.y" |
{ | { |
globalParserState->statement->appendOperand( | 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" |
case 38: |
|
#line 373 "WQL.y" |
{ | { |
globalParserState->statement->appendOperand( | 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" |
case 39: |
|
#line 378 "WQL.y" |
{ | { |
globalParserState->statement->appendOperand( | globalParserState->statement->appendOperand( |
WQLOperand(yyvsp[0].intValue != 0, WQLOperand::BOOLEAN_VALUE_TAG)); |
WQLOperand(yyvsp[0].intValue != 0, WQL_BOOLEAN_VALUE_TAG)); |
|
;} |
|
break; |
|
|
|
|
} | } |
|
|
|
/* Line 1000 of yacc.c. */ |
|
#line 1429 "WQLtemp" |
|
|
|
yyvsp -= yylen; |
|
yyssp -= yylen; |
|
|
|
|
|
YY_STACK_PRINT (yyss, yyssp); |
|
|
|
*++yyvsp = yyval; |
|
|
|
|
|
/* 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 - YYNTOKENS] + *yyssp; |
|
if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) |
|
yystate = yytable[yystate]; |
|
else |
|
yystate = yydefgoto[yyn - YYNTOKENS]; |
|
|
|
goto yynewstate; |
|
|
|
|
|
/*------------------------------------. |
|
| yyerrlab -- here on detecting error | |
|
`------------------------------------*/ |
|
yyerrlab: |
|
/* If not already recovering from an error, report this error. */ |
|
if (!yyerrstatus) |
|
{ |
|
++yynerrs; |
|
#if YYERROR_VERBOSE |
|
yyn = yypact[yystate]; |
|
|
|
if (YYPACT_NINF < yyn && yyn < YYLAST) |
|
{ |
|
YYSIZE_T yysize = 0; |
|
int yytype = YYTRANSLATE (yychar); |
|
const char* yyprefix; |
|
char *yymsg; |
|
int yyx; |
|
|
|
/* Start YYX at -YYN if negative to avoid negative indexes in |
|
YYCHECK. */ |
|
int yyxbegin = yyn < 0 ? -yyn : 0; |
|
|
|
/* Stay within bounds of both yycheck and yytname. */ |
|
int yychecklim = YYLAST - yyn; |
|
int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; |
|
int yycount = 0; |
|
|
|
yyprefix = ", expecting "; |
|
for (yyx = yyxbegin; yyx < yyxend; ++yyx) |
|
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) |
|
{ |
|
yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]); |
|
yycount += 1; |
|
if (yycount == 5) |
|
{ |
|
yysize = 0; |
break; | break; |
#line 669 "y.tab.c" |
|
} | } |
yyssp -= yym; |
} |
yystate = *yyssp; |
yysize += (sizeof ("syntax error, unexpected ") |
yyvsp -= yym; |
+ yystrlen (yytname[yytype])); |
yym = yylhs[yyn]; |
yymsg = (char *) YYSTACK_ALLOC (yysize); |
if (yystate == 0 && yym == 0) |
if (yymsg != 0) |
{ | { |
#if YYDEBUG |
char *yyp = yystpcpy (yymsg, "syntax error, unexpected "); |
if (yydebug) |
yyp = yystpcpy (yyp, yytname[yytype]); |
printf("%sdebug: after reduction, shifting from state 0 to\ |
|
state %d\n", YYPREFIX, YYFINAL); |
if (yycount < 5) |
#endif |
|
yystate = YYFINAL; |
|
*++yyssp = YYFINAL; |
|
*++yyvsp = yyval; |
|
if (yychar < 0) |
|
{ | { |
if ((yychar = yylex()) < 0) yychar = 0; |
yyprefix = ", expecting "; |
#if YYDEBUG |
for (yyx = yyxbegin; yyx < yyxend; ++yyx) |
if (yydebug) |
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) |
{ | { |
yys = 0; |
yyp = yystpcpy (yyp, yyprefix); |
if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; |
yyp = yystpcpy (yyp, yytname[yyx]); |
if (!yys) yys = "illegal-symbol"; |
yyprefix = " or "; |
printf("%sdebug: state %d, reading %d (%s)\n", |
|
YYPREFIX, YYFINAL, yychar, yys); |
|
} | } |
#endif |
|
} | } |
if (yychar == 0) goto yyaccept; |
yyerror (yymsg); |
goto yyloop; |
YYSTACK_FREE (yymsg); |
} | } |
if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 && |
|
yyn <= YYTABLESIZE && yycheck[yyn] == yystate) |
|
yystate = yytable[yyn]; |
|
else | else |
yystate = yydgoto[yym]; |
yyerror ("syntax error; also virtual memory exhausted"); |
#if YYDEBUG |
} |
if (yydebug) |
else |
printf("%sdebug: after reduction, shifting from state %d \ |
#endif /* YYERROR_VERBOSE */ |
to state %d\n", YYPREFIX, *yyssp, yystate); |
yyerror ("syntax error"); |
|
} |
|
|
|
|
|
|
|
if (yyerrstatus == 3) |
|
{ |
|
/* If just tried and failed to reuse lookahead token after an |
|
error, discard it. */ |
|
|
|
if (yychar <= YYEOF) |
|
{ |
|
/* If at end of input, pop the error token, |
|
then the rest of the stack, then return failure. */ |
|
if (yychar == YYEOF) |
|
for (;;) |
|
{ |
|
YYPOPSTACK; |
|
if (yyssp == yyss) |
|
YYABORT; |
|
YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); |
|
yydestruct (yystos[*yyssp], yyvsp); |
|
} |
|
} |
|
else |
|
{ |
|
YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc); |
|
yydestruct (yytoken, &yylval); |
|
yychar = YYEMPTY; |
|
|
|
} |
|
} |
|
|
|
/* Else will try to reuse lookahead token after shifting the error |
|
token. */ |
|
goto yyerrlab1; |
|
|
|
|
|
/*---------------------------------------------------. |
|
| yyerrorlab -- error raised explicitly by YYERROR. | |
|
`---------------------------------------------------*/ |
|
yyerrorlab: |
|
|
|
#ifdef __GNUC__ |
|
/* Pacify GCC when the user code never invokes YYERROR and the label |
|
yyerrorlab therefore never appears in user code. */ |
|
if (0) |
|
goto yyerrorlab; |
#endif | #endif |
if (yyssp >= yyss + yystacksize - 1) |
|
|
yyvsp -= yylen; |
|
yyssp -= yylen; |
|
yystate = *yyssp; |
|
goto yyerrlab1; |
|
|
|
|
|
/*-------------------------------------------------------------. |
|
| yyerrlab1 -- common code for both syntax error and YYERROR. | |
|
`-------------------------------------------------------------*/ |
|
yyerrlab1: |
|
yyerrstatus = 3; /* Each real token shifted decrements this. */ |
|
|
|
for (;;) |
|
{ |
|
yyn = yypact[yystate]; |
|
if (yyn != YYPACT_NINF) |
{ | { |
goto yyoverflow; |
yyn += YYTERROR; |
|
if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) |
|
{ |
|
yyn = yytable[yyn]; |
|
if (0 < yyn) |
|
break; |
} | } |
*++yyssp = yystate; |
|
*++yyvsp = yyval; |
|
goto yyloop; |
|
yyoverflow: |
|
yyerror("yacc stack overflow"); |
|
yyabort: |
|
return (1); |
|
yyaccept: |
|
return (0); |
|
} | } |
|
|
|
/* Pop the current state because it cannot handle the error token. */ |
|
if (yyssp == yyss) |
|
YYABORT; |
|
|
|
YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); |
|
yydestruct (yystos[yystate], yyvsp); |
|
YYPOPSTACK; |
|
yystate = *yyssp; |
|
YY_STACK_PRINT (yyss, yyssp); |
|
} |
|
|
|
if (yyn == YYFINAL) |
|
YYACCEPT; |
|
|
|
YYDPRINTF ((stderr, "Shifting error token, ")); |
|
|
|
*++yyvsp = yylval; |
|
|
|
|
|
yystate = yyn; |
|
goto yynewstate; |
|
|
|
|
|
/*-------------------------------------. |
|
| yyacceptlab -- YYACCEPT comes here. | |
|
`-------------------------------------*/ |
|
yyacceptlab: |
|
yyresult = 0; |
|
goto yyreturn; |
|
|
|
/*-----------------------------------. |
|
| yyabortlab -- YYABORT comes here. | |
|
`-----------------------------------*/ |
|
yyabortlab: |
|
yyresult = 1; |
|
goto yyreturn; |
|
|
|
#ifndef yyoverflow |
|
/*----------------------------------------------. |
|
| yyoverflowlab -- parser overflow comes here. | |
|
`----------------------------------------------*/ |
|
yyoverflowlab: |
|
yyerror ("parser stack overflow"); |
|
yyresult = 2; |
|
/* Fall through. */ |
|
#endif |
|
|
|
yyreturn: |
|
#ifndef yyoverflow |
|
if (yyss != yyssa) |
|
YYSTACK_FREE (yyss); |
|
#endif |
|
return yyresult; |
|
} |
|
|
|
|
|
#line 383 "WQL.y" |
|
|
|
|