version 1.1.2.9, 2001/12/03 06:14:26
|
version 1.17, 2008/02/22 19:20:02
|
|
|
#ifndef lint |
/* NOCHKSRC */ |
static char yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93"; |
/* A Bison parser, made by GNU Bison 2.3. */ |
#endif |
|
#define YYBYACC 1 |
/* Skeleton implementation for Bison's Yacc-like parsers in C |
#define YYMAJOR 1 |
|
#define YYMINOR 9 |
Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 |
#define yyclearin (yychar=(-1)) |
Free Software Foundation, Inc. |
#define yyerrok (yyerrflag=0) |
|
#define YYRECOVERING (yyerrflag!=0) |
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., 51 Franklin Street, Fifth Floor, |
|
Boston, MA 02110-1301, USA. */ |
|
|
|
/* As a special exception, you may create a larger work that contains |
|
part or all of the Bison parser skeleton and distribute that work |
|
under terms of your choice, so long as that work isn't itself a |
|
parser generator using the skeleton or a modified version thereof |
|
as a parser skeleton. Alternatively, if you modify or redistribute |
|
the parser skeleton itself, you may (at your option) remove this |
|
special exception, which will cause the skeleton and the resulting |
|
Bison output files to be licensed under the GNU General Public |
|
License without this special exception. |
|
|
|
This special exception was added by the Free Software Foundation in |
|
version 2.2 of Bison. */ |
|
|
|
/* C LALR(1) parser skeleton 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 |
|
|
|
/* Bison version. */ |
|
#define YYBISON_VERSION "2.3" |
|
|
|
/* Skeleton name. */ |
|
#define YYSKELETON_NAME "yacc.c" |
|
|
|
/* Pure parsers. */ |
|
#define YYPURE 0 |
|
|
|
/* Using locations. */ |
|
#define YYLSP_NEEDED 0 |
|
|
|
/* Substitute the variable and function 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 |
|
/* Tokens. */ |
|
#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 39 "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 |
|
|
|
/* Enabling the token table. */ |
|
#ifndef YYTOKEN_TABLE |
|
# define YYTOKEN_TABLE 0 |
|
#endif |
|
|
|
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED |
|
typedef union YYSTYPE |
|
#line 89 "WQL.y" |
{ | { |
int intValue; | int intValue; |
double doubleValue; | double doubleValue; |
char* strValue; | char* strValue; |
void* nodeValue; | void* nodeValue; |
} YYSTYPE; |
} |
#line 83 "y.tab.c" |
/* Line 193 of yacc.c. */ |
#define TOK_INTEGER 257 |
#line 202 "WQLtemp" |
#define TOK_DOUBLE 258 |
YYSTYPE; |
#define TOK_STRING 259 |
# define yystype YYSTYPE /* obsolescent; will be withdrawn */ |
#define TOK_TRUE 260 |
# define YYSTYPE_IS_DECLARED 1 |
#define TOK_FALSE 261 |
# define YYSTYPE_IS_TRIVIAL 1 |
#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 216 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 215 "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", |
#ifdef short |
"TOK_DOUBLE","TOK_STRING","TOK_TRUE","TOK_FALSE","TOK_NULL","TOK_EQ","TOK_NE", |
# undef short |
"TOK_LT","TOK_LE","TOK_GT","TOK_GE","TOK_NOT","TOK_OR","TOK_AND","TOK_IS", |
#endif |
"TOK_IDENTIFIER","TOK_SELECT","TOK_WHERE","TOK_FROM","TOK_UNEXPECTED_CHAR", |
|
}; |
#ifdef YYTYPE_UINT8 |
char *WQL_rule[] = { |
typedef YYTYPE_UINT8 yytype_uint8; |
"$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", |
|
}; |
|
#endif |
|
#ifdef YYSTACKSIZE |
|
#undef YYMAXDEPTH |
|
#define YYMAXDEPTH YYSTACKSIZE |
|
#else | #else |
#ifdef YYMAXDEPTH |
typedef unsigned char yytype_uint8; |
#define YYSTACKSIZE YYMAXDEPTH |
#endif |
|
|
|
#ifdef YYTYPE_INT8 |
|
typedef YYTYPE_INT8 yytype_int8; |
|
#elif (defined __STDC__ || defined __C99__FUNC__ \ |
|
|| defined __cplusplus || defined _MSC_VER) |
|
typedef signed char yytype_int8; |
#else | #else |
#define YYSTACKSIZE 500 |
typedef short int yytype_int8; |
#define YYMAXDEPTH 500 |
|
#endif | #endif |
|
|
|
#ifdef YYTYPE_UINT16 |
|
typedef YYTYPE_UINT16 yytype_uint16; |
|
#else |
|
typedef unsigned short int yytype_uint16; |
|
#endif |
|
|
|
#ifdef YYTYPE_INT16 |
|
typedef YYTYPE_INT16 yytype_int16; |
|
#else |
|
typedef short int yytype_int16; |
|
#endif |
|
|
|
#ifndef YYSIZE_T |
|
# ifdef __SIZE_TYPE__ |
|
# define YYSIZE_T __SIZE_TYPE__ |
|
# elif defined size_t |
|
# define YYSIZE_T size_t |
|
# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ |
|
|| defined __cplusplus || defined _MSC_VER) |
|
# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ |
|
# define YYSIZE_T size_t |
|
# else |
|
# define YYSIZE_T unsigned int |
|
# endif |
|
#endif |
|
|
|
#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) |
|
|
|
#ifndef YY_ |
|
# if YYENABLE_NLS |
|
# if ENABLE_NLS |
|
# include <libintl.h> /* INFRINGES ON USER NAME SPACE */ |
|
# define YY_(msgid) dgettext ("bison-runtime", msgid) |
|
# endif |
|
# endif |
|
# ifndef YY_ |
|
# define YY_(msgid) msgid |
|
# endif |
|
#endif |
|
|
|
/* Suppress unused-variable warnings by "using" E. */ |
|
#if ! defined lint || defined __GNUC__ |
|
# define YYUSE(e) ((void) (e)) |
|
#else |
|
# define YYUSE(e) /* empty */ |
|
#endif |
|
|
|
/* Identity function, used to suppress warnings about constant conditions. */ |
|
#ifndef lint |
|
# define YYID(n) (n) |
|
#else |
|
#if (defined __STDC__ || defined __C99__FUNC__ \ |
|
|| defined __cplusplus || defined _MSC_VER) |
|
static int |
|
YYID (int i) |
|
#else |
|
static int |
|
YYID (i) |
|
int i; |
#endif | #endif |
int yydebug; |
|
int yynerrs; |
|
int yyerrflag; |
|
int yychar; |
|
short *yyssp; |
|
YYSTYPE *yyvsp; |
|
YYSTYPE yyval; |
|
YYSTYPE yylval; |
|
short yyss[YYSTACKSIZE]; |
|
YYSTYPE yyvs[YYSTACKSIZE]; |
|
#define yystacksize YYSTACKSIZE |
|
#define YYABORT goto yyabort |
|
#define YYREJECT goto yyabort |
|
#define YYACCEPT goto yyaccept |
|
#define YYERROR goto yyerrlab |
|
int |
|
yyparse() |
|
{ | { |
register int yym, yyn, yystate; |
return i; |
|
} |
|
#endif |
|
|
|
#if ! defined yyoverflow || YYERROR_VERBOSE |
|
|
|
/* The parser invokes alloca or malloc; define the necessary symbols. */ |
|
|
|
# ifdef YYSTACK_USE_ALLOCA |
|
# if YYSTACK_USE_ALLOCA |
|
# ifdef __GNUC__ |
|
# define YYSTACK_ALLOC __builtin_alloca |
|
# elif defined __BUILTIN_VA_ARG_INCR |
|
# include <alloca.h> /* INFRINGES ON USER NAME SPACE */ |
|
# elif defined _AIX |
|
# define YYSTACK_ALLOC __alloca |
|
# elif defined _MSC_VER |
|
# include <malloc.h> /* INFRINGES ON USER NAME SPACE */ |
|
# define alloca _alloca |
|
# else |
|
# define YYSTACK_ALLOC alloca |
|
# if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ |
|
|| defined __cplusplus || defined _MSC_VER) |
|
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ |
|
# ifndef _STDLIB_H |
|
# define _STDLIB_H 1 |
|
# endif |
|
# endif |
|
# endif |
|
# endif |
|
# endif |
|
|
|
# ifdef YYSTACK_ALLOC |
|
/* Pacify GCC's `empty if-body' warning. */ |
|
# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0)) |
|
# ifndef YYSTACK_ALLOC_MAXIMUM |
|
/* The OS might guarantee only one guard page at the bottom of the stack, |
|
and a page size can be as small as 4096 bytes. So we cannot safely |
|
invoke alloca (N) if N exceeds 4096. Use a slightly smaller number |
|
to allow for a few compiler-allocated temporary stack slots. */ |
|
# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */ |
|
# endif |
|
# else |
|
# define YYSTACK_ALLOC YYMALLOC |
|
# define YYSTACK_FREE YYFREE |
|
# ifndef YYSTACK_ALLOC_MAXIMUM |
|
# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM |
|
# endif |
|
# if (defined __cplusplus && ! defined _STDLIB_H \ |
|
&& ! ((defined YYMALLOC || defined malloc) \ |
|
&& (defined YYFREE || defined free))) |
|
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ |
|
# ifndef _STDLIB_H |
|
# define _STDLIB_H 1 |
|
# endif |
|
# endif |
|
# ifndef YYMALLOC |
|
# define YYMALLOC malloc |
|
# if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ |
|
|| defined __cplusplus || defined _MSC_VER) |
|
void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */ |
|
# endif |
|
# endif |
|
# ifndef YYFREE |
|
# define YYFREE free |
|
# if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \ |
|
|| defined __cplusplus || defined _MSC_VER) |
|
void free (void *); /* INFRINGES ON USER NAME SPACE */ |
|
# endif |
|
# endif |
|
# endif |
|
#endif /* ! defined yyoverflow || YYERROR_VERBOSE */ |
|
|
|
|
|
#if (! defined yyoverflow \ |
|
&& (! defined __cplusplus \ |
|
|| (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))) |
|
|
|
/* A type that is properly aligned for any stack member. */ |
|
union yyalloc |
|
{ |
|
yytype_int16 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 (yytype_int16) + 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 \ |
|
{ \ |
|
YYSIZE_T yyi; \ |
|
for (yyi = 0; yyi < (Count); yyi++) \ |
|
(To)[yyi] = (From)[yyi]; \ |
|
} \ |
|
while (YYID (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 (YYID (0)) |
|
|
|
#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 yytype_uint8 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 yytype_uint8 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 yytype_int8 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 yytype_uint16 yyrline[] = |
|
{ |
|
0, 162, 162, 168, 174, 178, 184, 188, 194, 198, |
|
204, 211, 217, 222, 227, 233, 237, 241, 246, 255, |
|
259, 265, 270, 275, 280, 285, 290, 295, 305, 310, |
|
317, 321, 334, 339, 351, 358, 364, 369, 374, 379 |
|
}; |
#endif | #endif |
| |
yynerrs = 0; |
#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE |
yyerrflag = 0; |
/* YYTNAME[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 yytype_uint16 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 yytype_uint8 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 yytype_uint8 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 yytype_uint8 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 yytype_int8 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 yytype_int8 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 yytype_int8 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 yytype_uint8 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 yytype_int8 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 yytype_uint8 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 |
|
}; |
|
|
|
#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 (1); \ |
|
goto yybackup; \ |
|
} \ |
|
else \ |
|
{ \ |
|
yyerror (YY_("syntax error: cannot back up")); \ |
|
YYERROR; \ |
|
} \ |
|
while (YYID (0)) |
|
|
|
|
|
#define YYTERROR 1 |
|
#define YYERRCODE 256 |
|
|
|
|
|
/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N]. |
|
If N is 0, then set CURRENT to the empty location which ends |
|
the previous symbol: RHS[0] (always defined). */ |
|
|
|
#define YYRHSLOC(Rhs, K) ((Rhs)[K]) |
|
#ifndef YYLLOC_DEFAULT |
|
# define YYLLOC_DEFAULT(Current, Rhs, N) \ |
|
do \ |
|
if (YYID (N)) \ |
|
{ \ |
|
(Current).first_line = YYRHSLOC (Rhs, 1).first_line; \ |
|
(Current).first_column = YYRHSLOC (Rhs, 1).first_column; \ |
|
(Current).last_line = YYRHSLOC (Rhs, N).last_line; \ |
|
(Current).last_column = YYRHSLOC (Rhs, N).last_column; \ |
|
} \ |
|
else \ |
|
{ \ |
|
(Current).first_line = (Current).last_line = \ |
|
YYRHSLOC (Rhs, 0).last_line; \ |
|
(Current).first_column = (Current).last_column = \ |
|
YYRHSLOC (Rhs, 0).last_column; \ |
|
} \ |
|
while (YYID (0)) |
|
#endif |
|
|
|
|
|
/* YY_LOCATION_PRINT -- Print the location on the stream. |
|
This macro was not mandated originally: define only if we know |
|
we won't break user code: when these are the locations we know. */ |
|
|
|
#ifndef YY_LOCATION_PRINT |
|
# if YYLTYPE_IS_TRIVIAL |
|
# define YY_LOCATION_PRINT(File, Loc) \ |
|
fprintf (File, "%d.%d-%d.%d", \ |
|
(Loc).first_line, (Loc).first_column, \ |
|
(Loc).last_line, (Loc).last_column) |
|
# else |
|
# define YY_LOCATION_PRINT(File, Loc) ((void) 0) |
|
# endif |
|
#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 (YYID (0)) |
|
|
|
# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ |
|
do { \ |
|
if (yydebug) \ |
|
{ \ |
|
YYFPRINTF (stderr, "%s ", Title); \ |
|
yy_symbol_print (stderr, \ |
|
Type, Value); \ |
|
YYFPRINTF (stderr, "\n"); \ |
|
} \ |
|
} while (YYID (0)) |
|
|
|
|
|
/*--------------------------------. |
|
| Print this symbol on YYOUTPUT. | |
|
`--------------------------------*/ |
|
|
|
/*ARGSUSED*/ |
|
#if (defined __STDC__ || defined __C99__FUNC__ \ |
|
|| defined __cplusplus || defined _MSC_VER) |
|
static void |
|
yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) |
|
#else |
|
static void |
|
yy_symbol_value_print (yyoutput, yytype, yyvaluep) |
|
FILE *yyoutput; |
|
int yytype; |
|
YYSTYPE const * const yyvaluep; |
|
#endif |
|
{ |
|
if (!yyvaluep) |
|
return; |
|
# ifdef YYPRINT |
|
if (yytype < YYNTOKENS) |
|
YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); |
|
# else |
|
YYUSE (yyoutput); |
|
# endif |
|
switch (yytype) |
{ | { |
yys = 0; |
default: |
if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; |
break; |
if (!yys) yys = "illegal-symbol"; |
} |
printf("%sdebug: state %d, reading %d (%s)\n", |
|
YYPREFIX, yystate, yychar, yys); |
|
} | } |
|
|
|
|
|
/*--------------------------------. |
|
| Print this symbol on YYOUTPUT. | |
|
`--------------------------------*/ |
|
|
|
#if (defined __STDC__ || defined __C99__FUNC__ \ |
|
|| defined __cplusplus || defined _MSC_VER) |
|
static void |
|
yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) |
|
#else |
|
static void |
|
yy_symbol_print (yyoutput, yytype, yyvaluep) |
|
FILE *yyoutput; |
|
int yytype; |
|
YYSTYPE const * const yyvaluep; |
#endif | #endif |
|
{ |
|
if (yytype < YYNTOKENS) |
|
YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); |
|
else |
|
YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); |
|
|
|
yy_symbol_value_print (yyoutput, yytype, yyvaluep); |
|
YYFPRINTF (yyoutput, ")"); |
} | } |
if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 && |
|
yyn <= YYTABLESIZE && yycheck[yyn] == yychar) |
/*------------------------------------------------------------------. |
|
| yy_stack_print -- Print the state stack from its BOTTOM up to its | |
|
| TOP (included). | |
|
`------------------------------------------------------------------*/ |
|
|
|
#if (defined __STDC__ || defined __C99__FUNC__ \ |
|
|| defined __cplusplus || defined _MSC_VER) |
|
static void |
|
yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) |
|
#else |
|
static void |
|
yy_stack_print (bottom, top) |
|
yytype_int16 *bottom; |
|
yytype_int16 *top; |
|
#endif |
{ | { |
#if YYDEBUG |
YYFPRINTF (stderr, "Stack now"); |
if (yydebug) |
for (; bottom <= top; ++bottom) |
printf("%sdebug: state %d, shifting to state %d\n", |
YYFPRINTF (stderr, " %d", *bottom); |
YYPREFIX, yystate, yytable[yyn]); |
YYFPRINTF (stderr, "\n"); |
|
} |
|
|
|
# define YY_STACK_PRINT(Bottom, Top) \ |
|
do { \ |
|
if (yydebug) \ |
|
yy_stack_print ((Bottom), (Top)); \ |
|
} while (YYID (0)) |
|
|
|
|
|
/*------------------------------------------------. |
|
| Report that the YYRULE is going to be reduced. | |
|
`------------------------------------------------*/ |
|
|
|
#if (defined __STDC__ || defined __C99__FUNC__ \ |
|
|| defined __cplusplus || defined _MSC_VER) |
|
static void |
|
yy_reduce_print (YYSTYPE *yyvsp, int yyrule) |
|
#else |
|
static void |
|
yy_reduce_print (yyvsp, yyrule) |
|
YYSTYPE *yyvsp; |
|
int yyrule; |
#endif | #endif |
if (yyssp >= yyss + yystacksize - 1) |
|
{ | { |
goto yyoverflow; |
int yynrhs = yyr2[yyrule]; |
|
int yyi; |
|
unsigned long int yylno = yyrline[yyrule]; |
|
YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", |
|
yyrule - 1, yylno); |
|
/* The symbols being reduced. */ |
|
for (yyi = 0; yyi < yynrhs; yyi++) |
|
{ |
|
fprintf (stderr, " $%d = ", yyi + 1); |
|
yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], |
|
&(yyvsp[(yyi + 1) - (yynrhs)]) |
|
); |
|
fprintf (stderr, "\n"); |
} | } |
*++yyssp = yystate = yytable[yyn]; |
|
*++yyvsp = yylval; |
|
yychar = (-1); |
|
if (yyerrflag > 0) --yyerrflag; |
|
goto yyloop; |
|
} | } |
if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 && |
|
yyn <= YYTABLESIZE && yycheck[yyn] == yychar) |
# define YY_REDUCE_PRINT(Rule) \ |
|
do { \ |
|
if (yydebug) \ |
|
yy_reduce_print (yyvsp, Rule); \ |
|
} while (YYID (0)) |
|
|
|
/* Nonzero means print parse trace. It is left uninitialized so that |
|
multiple parsers can coexist. */ |
|
int yydebug; |
|
#else /* !YYDEBUG */ |
|
# define YYDPRINTF(Args) |
|
# define YY_SYMBOL_PRINT(Title, Type, 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 |
|
YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) |
|
evaluated with infinite-precision integer arithmetic. */ |
|
|
|
#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. */ |
|
#if (defined __STDC__ || defined __C99__FUNC__ \ |
|
|| defined __cplusplus || defined _MSC_VER) |
|
static YYSIZE_T |
|
yystrlen (const char *yystr) |
|
#else |
|
static YYSIZE_T |
|
yystrlen (yystr) |
|
const char *yystr; |
|
#endif |
{ | { |
yyn = yytable[yyn]; |
YYSIZE_T yylen; |
goto yyreduce; |
for (yylen = 0; yystr[yylen]; yylen++) |
|
continue; |
|
return yylen; |
} | } |
if (yyerrflag) goto yyinrecovery; |
|
#ifdef lint |
|
goto yynewerror; |
|
#endif |
|
yynewerror: |
|
yyerror("syntax error"); |
|
#ifdef lint |
|
goto yyerrlab; |
|
#endif | #endif |
yyerrlab: |
# endif |
++yynerrs; |
|
yyinrecovery: |
# ifndef yystpcpy |
if (yyerrflag < 3) |
# 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. */ |
|
#if (defined __STDC__ || defined __C99__FUNC__ \ |
|
|| defined __cplusplus || defined _MSC_VER) |
|
static char * |
|
yystpcpy (char *yydest, const char *yysrc) |
|
#else |
|
static char * |
|
yystpcpy (yydest, yysrc) |
|
char *yydest; |
|
const char *yysrc; |
|
#endif |
|
{ |
|
char *yyd = yydest; |
|
const char *yys = yysrc; |
|
|
|
while ((*yyd++ = *yys++) != '\0') |
|
continue; |
|
|
|
return yyd - 1; |
|
} |
|
# endif |
|
# endif |
|
|
|
# ifndef yytnamerr |
|
/* Copy to YYRES the contents of YYSTR after stripping away unnecessary |
|
quotes and backslashes, so that it's suitable for yyerror. The |
|
heuristic is that double-quoting is unnecessary unless the string |
|
contains an apostrophe, a comma, or backslash (other than |
|
backslash-backslash). YYSTR is taken from yytname. If YYRES is |
|
null, do not copy; instead, return the length of what the result |
|
would have been. */ |
|
static YYSIZE_T |
|
yytnamerr (char *yyres, const char *yystr) |
|
{ |
|
if (*yystr == '"') |
{ | { |
yyerrflag = 3; |
YYSIZE_T yyn = 0; |
|
char const *yyp = yystr; |
|
|
for (;;) | for (;;) |
|
switch (*++yyp) |
{ | { |
if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 && |
case '\'': |
yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE) |
case ',': |
|
goto do_not_strip_quotes; |
|
|
|
case '\\': |
|
if (*++yyp != '\\') |
|
goto do_not_strip_quotes; |
|
/* Fall through. */ |
|
default: |
|
if (yyres) |
|
yyres[yyn] = *yyp; |
|
yyn++; |
|
break; |
|
|
|
case '"': |
|
if (yyres) |
|
yyres[yyn] = '\0'; |
|
return yyn; |
|
} |
|
do_not_strip_quotes: ; |
|
} |
|
|
|
if (! yyres) |
|
return yystrlen (yystr); |
|
|
|
return yystpcpy (yyres, yystr) - yyres; |
|
} |
|
# endif |
|
|
|
/* Copy into YYRESULT an error message about the unexpected token |
|
YYCHAR while in state YYSTATE. Return the number of bytes copied, |
|
including the terminating null byte. If YYRESULT is null, do not |
|
copy anything; just return the number of bytes that would be |
|
copied. As a special case, return 0 if an ordinary "syntax error" |
|
message will do. Return YYSIZE_MAXIMUM if overflow occurs during |
|
size calculation. */ |
|
static YYSIZE_T |
|
yysyntax_error (char *yyresult, int yystate, int yychar) |
{ | { |
#if YYDEBUG |
int yyn = yypact[yystate]; |
if (yydebug) |
|
printf("%sdebug: state %d, error recovery shifting\ |
if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) |
to state %d\n", YYPREFIX, *yyssp, yytable[yyn]); |
return 0; |
|
else |
|
{ |
|
int yytype = YYTRANSLATE (yychar); |
|
YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]); |
|
YYSIZE_T yysize = yysize0; |
|
YYSIZE_T yysize1; |
|
int yysize_overflow = 0; |
|
enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 }; |
|
char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM]; |
|
int yyx; |
|
|
|
# if 0 |
|
/* This is so xgettext sees the translatable formats that are |
|
constructed on the fly. */ |
|
YY_("syntax error, unexpected %s"); |
|
YY_("syntax error, unexpected %s, expecting %s"); |
|
YY_("syntax error, unexpected %s, expecting %s or %s"); |
|
YY_("syntax error, unexpected %s, expecting %s or %s or %s"); |
|
YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"); |
#endif | #endif |
if (yyssp >= yyss + yystacksize - 1) |
char *yyfmt; |
|
char const *yyf; |
|
static char const yyunexpected[] = "syntax error, unexpected %s"; |
|
static char const yyexpecting[] = ", expecting %s"; |
|
static char const yyor[] = " or %s"; |
|
char yyformat[sizeof yyunexpected |
|
+ sizeof yyexpecting - 1 |
|
+ ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2) |
|
* (sizeof yyor - 1))]; |
|
char const *yyprefix = yyexpecting; |
|
|
|
/* 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 + 1; |
|
int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; |
|
int yycount = 1; |
|
|
|
yyarg[0] = yytname[yytype]; |
|
yyfmt = yystpcpy (yyformat, yyunexpected); |
|
|
|
for (yyx = yyxbegin; yyx < yyxend; ++yyx) |
|
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) |
|
{ |
|
if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM) |
|
{ |
|
yycount = 1; |
|
yysize = yysize0; |
|
yyformat[sizeof yyunexpected - 1] = '\0'; |
|
break; |
|
} |
|
yyarg[yycount++] = yytname[yyx]; |
|
yysize1 = yysize + yytnamerr (0, yytname[yyx]); |
|
yysize_overflow |= (yysize1 < yysize); |
|
yysize = yysize1; |
|
yyfmt = yystpcpy (yyfmt, yyprefix); |
|
yyprefix = yyor; |
|
} |
|
|
|
yyf = YY_(yyformat); |
|
yysize1 = yysize + yystrlen (yyf); |
|
yysize_overflow |= (yysize1 < yysize); |
|
yysize = yysize1; |
|
|
|
if (yysize_overflow) |
|
return YYSIZE_MAXIMUM; |
|
|
|
if (yyresult) |
|
{ |
|
/* Avoid sprintf, as that infringes on the user's name space. |
|
Don't have undefined behavior even if the translation |
|
produced a string with the wrong number of "%s"s. */ |
|
char *yyp = yyresult; |
|
int yyi = 0; |
|
while ((*yyp = *yyf) != '\0') |
{ | { |
goto yyoverflow; |
if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) |
} |
{ |
*++yyssp = yystate = yytable[yyn]; |
yyp += yytnamerr (yyp, yyarg[yyi++]); |
*++yyvsp = yylval; |
yyf += 2; |
goto yyloop; |
|
} | } |
else | else |
{ | { |
#if YYDEBUG |
yyp++; |
if (yydebug) |
yyf++; |
printf("%sdebug: error recovery discarding state %d\n", |
} |
YYPREFIX, *yyssp); |
} |
#endif |
} |
if (yyssp <= yyss) goto yyabort; |
return yysize; |
--yyssp; |
} |
--yyvsp; |
} |
} |
#endif /* YYERROR_VERBOSE */ |
|
|
|
|
|
/*-----------------------------------------------. |
|
| Release the memory associated to this symbol. | |
|
`-----------------------------------------------*/ |
|
|
|
/*ARGSUSED*/ |
|
#if (defined __STDC__ || defined __C99__FUNC__ \ |
|
|| defined __cplusplus || defined _MSC_VER) |
|
static void |
|
yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) |
|
#else |
|
static void |
|
yydestruct (yymsg, yytype, yyvaluep) |
|
const char *yymsg; |
|
int yytype; |
|
YYSTYPE *yyvaluep; |
|
#endif |
|
{ |
|
YYUSE (yyvaluep); |
|
|
|
if (!yymsg) |
|
yymsg = "Deleting"; |
|
YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); |
|
|
|
switch (yytype) |
|
{ |
|
|
|
default: |
|
break; |
|
} |
|
} |
|
|
|
|
|
/* 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 look-ahead symbol. */ |
|
int yychar; |
|
|
|
/* The semantic value of the look-ahead symbol. */ |
|
YYSTYPE yylval; |
|
|
|
/* Number of syntax errors so far. */ |
|
int yynerrs; |
|
|
|
|
|
|
|
/*----------. |
|
| yyparse. | |
|
`----------*/ |
|
|
|
#ifdef YYPARSE_PARAM |
|
#if (defined __STDC__ || defined __C99__FUNC__ \ |
|
|| defined __cplusplus || defined _MSC_VER) |
|
int |
|
yyparse (void *YYPARSE_PARAM) |
|
#else |
|
int |
|
yyparse (YYPARSE_PARAM) |
|
void *YYPARSE_PARAM; |
|
#endif |
|
#else /* ! YYPARSE_PARAM */ |
|
#if (defined __STDC__ || defined __C99__FUNC__ \ |
|
|| defined __cplusplus || defined _MSC_VER) |
|
int |
|
yyparse (void) |
|
#else |
|
int |
|
yyparse () |
|
|
|
#endif |
|
#endif |
|
{ |
|
|
|
int yystate; |
|
int yyn; |
|
int yyresult; |
|
/* Number of tokens to shift before error messages enabled. */ |
|
int yyerrstatus; |
|
/* Look-ahead token as an internal (translated) token number. */ |
|
int yytoken = 0; |
|
#if YYERROR_VERBOSE |
|
/* Buffer for error messages, and its allocated size. */ |
|
char yymsgbuf[128]; |
|
char *yymsg = yymsgbuf; |
|
YYSIZE_T yymsg_alloc = sizeof yymsgbuf; |
|
#endif |
|
|
|
/* 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. */ |
|
yytype_int16 yyssa[YYINITDEPTH]; |
|
yytype_int16 *yyss = yyssa; |
|
yytype_int16 *yyssp; |
|
|
|
/* The semantic value stack. */ |
|
YYSTYPE yyvsa[YYINITDEPTH]; |
|
YYSTYPE *yyvs = yyvsa; |
|
YYSTYPE *yyvsp; |
|
|
|
|
|
|
|
#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) |
|
|
|
YYSIZE_T yystacksize = YYINITDEPTH; |
|
|
|
/* The variables used to return semantic value and location from the |
|
action routines. */ |
|
YYSTYPE yyval; |
|
|
|
|
|
/* The number of symbols on the RHS of the reduced rule. |
|
Keep to zero when no symbol should be popped. */ |
|
int yylen = 0; |
|
|
|
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; |
|
yytype_int16 *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 (YY_("memory exhausted"), |
|
&yyss1, yysize * sizeof (*yyssp), |
|
&yyvs1, yysize * sizeof (*yyvsp), |
|
|
|
&yystacksize); |
|
|
|
yyss = yyss1; |
|
yyvs = yyvs1; |
|
} |
|
#else /* no yyoverflow */ |
|
# ifndef YYSTACK_RELOCATE |
|
goto yyexhaustedlab; |
|
# else |
|
/* Extend the stack our own way. */ |
|
if (YYMAXDEPTH <= yystacksize) |
|
goto yyexhaustedlab; |
|
yystacksize *= 2; |
|
if (YYMAXDEPTH < yystacksize) |
|
yystacksize = YYMAXDEPTH; |
|
|
|
{ |
|
yytype_int16 *yyss1 = yyss; |
|
union yyalloc *yyptr = |
|
(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); |
|
if (! yyptr) |
|
goto yyexhaustedlab; |
|
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 |
|
look-ahead token if we need one and don't already have one. */ |
|
|
|
/* First try to decide what to do without reference to look-ahead token. */ |
|
yyn = yypact[yystate]; |
|
if (yyn == YYPACT_NINF) |
|
goto yydefault; |
|
|
|
/* Not known => get a look-ahead token if don't already have one. */ |
|
|
|
/* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead 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 |
YY_SYMBOL_PRINT ("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; |
|
|
|
/* Count tokens shifted since error; after three, turn off error |
|
status. */ |
|
if (yyerrstatus) |
|
yyerrstatus--; |
|
|
|
/* Shift the look-ahead token. */ |
|
YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); |
|
|
|
/* Discard the shifted token unless it is eof. */ |
|
if (yychar != YYEOF) |
|
yychar = YYEMPTY; |
|
|
|
yystate = yyn; |
|
*++yyvsp = yylval; |
|
|
|
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 163 "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 169 "WQL.y" |
{ | { |
globalParserState->statement->appendPropertyName("*"); |
|
} |
;} |
break; | break; |
|
|
case 4: | case 4: |
#line 147 "WQL.y" |
#line 175 "WQL.y" |
{ | { |
|
globalParserState->statement->setAllProperties(true); |
} |
;} |
break; | break; |
|
|
case 5: | case 5: |
#line 153 "WQL.y" |
#line 179 "WQL.y" |
{ | { |
globalParserState->statement->appendPropertyName(yyvsp[0].strValue); |
|
} |
;} |
break; | break; |
|
|
case 6: | case 6: |
#line 157 "WQL.y" |
#line 185 "WQL.y" |
{ | { |
globalParserState->statement->appendPropertyName(yyvsp[0].strValue); |
globalParserState->statement->appendSelectPropertyName(CIMName((yyvsp[(1) - (1)].strValue))); |
} |
;} |
break; | break; |
|
|
case 7: | case 7: |
#line 163 "WQL.y" |
#line 189 "WQL.y" |
{ | { |
|
globalParserState->statement->appendSelectPropertyName(CIMName((yyvsp[(3) - (3)].strValue))); |
} |
;} |
break; | break; |
|
|
case 8: | case 8: |
#line 167 "WQL.y" |
#line 195 "WQL.y" |
{ | { |
| |
} |
;} |
break; | break; |
|
|
case 9: | case 9: |
#line 173 "WQL.y" |
#line 199 "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 205 "WQL.y" |
{ | { |
|
WQL_TRACE(("YACC: fromClause: TOK_FROM className(%s)\n", (yyvsp[(2) - (2)].strValue))); |
} |
globalParserState->statement->setClassName(CIMName((yyvsp[(2) - (2)].strValue))); |
|
;} |
break; | break; |
|
|
case 11: | case 11: |
#line 186 "WQL.y" |
#line 212 "WQL.y" |
|
{ |
|
|
|
;} |
|
break; |
|
|
|
case 12: |
|
#line 218 "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 223 "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 228 "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 234 "WQL.y" |
{ | { |
| |
} |
;} |
break; | break; |
|
|
case 16: | case 16: |
#line 210 "WQL.y" |
#line 238 "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 242 "WQL.y" |
{ | { |
WQLOperation op = yyvsp[0].intValue ? WQL_IS_NOT_TRUE : WQL_IS_NOT_FALSE; |
WQLOperation op = (yyvsp[(3) - (3)].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 247 "WQL.y" |
{ | { |
|
WQLOperation op = (yyvsp[(4) - (4)].intValue) ? WQL_IS_NOT_TRUE : WQL_IS_NOT_FALSE; |
} |
globalParserState->statement->appendOperation(op); |
|
;} |
break; | break; |
|
|
case 19: | case 19: |
#line 228 "WQL.y" |
#line 256 "WQL.y" |
{ | { |
| |
} |
;} |
break; | break; |
|
|
case 20: | case 20: |
#line 234 "WQL.y" |
#line 260 "WQL.y" |
|
{ |
|
|
|
;} |
|
break; |
|
|
|
case 21: |
|
#line 266 "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 271 "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 276 "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 281 "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 286 "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 291 "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; |
|
case 26: |
|
#line 266 "WQL.y" |
|
{ |
|
WQL_TRACE(("YACC: nullPredicate : comparisonTerm IS NULL\n")); |
|
globalParserState->statement->appendOperation(WQL_IS_NULL); |
|
} |
|
break; | break; |
|
|
case 27: | case 27: |
#line 271 "WQL.y" |
#line 296 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: nullPredicate : comparisonTerm IS NOT NULL\n")); |
WQL_TRACE(("YACC: TOK_ISA\n")); |
globalParserState->statement->appendOperation(WQL_IS_NOT_NULL); |
#ifndef PEGASUS_SNIA_EXTENSIONS |
} |
// If SNIA tests, allow the ISA but do not pass className |
|
yyerror("ISA Token Not Supported"); |
|
#endif |
|
;} |
break; | break; |
|
|
case 28: | case 28: |
#line 278 "WQL.y" |
#line 306 "WQL.y" |
{ | { |
yyval.intValue = 1; |
WQL_TRACE(("YACC: nullPredicate : comparisonTerm IS NULL\n")); |
} |
globalParserState->statement->appendOperation(WQL_IS_NULL); |
|
;} |
break; | break; |
|
|
case 29: | case 29: |
#line 282 "WQL.y" |
#line 311 "WQL.y" |
{ | { |
yyval.intValue = 0; |
WQL_TRACE(("YACC: nullPredicate : comparisonTerm IS NOT NULL\n")); |
} |
globalParserState->statement->appendOperation(WQL_IS_NOT_NULL); |
|
;} |
break; | break; |
|
|
case 30: | case 30: |
#line 288 "WQL.y" |
#line 318 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: propertyName : TOK_IDENTIFIER(%s)\n", yyvsp[0].strValue)); |
(yyval.intValue) = 1; |
yyval.strValue = yyvsp[0].strValue; |
;} |
} |
|
break; | break; |
|
|
case 31: | case 31: |
#line 294 "WQL.y" |
#line 322 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: TOK_IDENTIFIER %s\n", yyvsp[0].strValue)); |
(yyval.intValue) = 0; |
yyval.strValue = yyvsp[0].strValue; |
;} |
} |
|
break; | break; |
|
|
case 32: | case 32: |
#line 301 "WQL.y" |
#line 335 "WQL.y" |
{ | { |
globalParserState->statement->appendOperand( |
WQL_TRACE(("YACC: propertyName : TOK_IDENTIFIER(%s)\n", (yyvsp[(1) - (1)].strValue))); |
WQLOperand(yyvsp[0].strValue, WQLOperand::PROPERTY_NAME_TAG)); |
(yyval.strValue) = (yyvsp[(1) - (1)].strValue); |
} |
;} |
break; | break; |
|
|
case 33: | case 33: |
#line 306 "WQL.y" |
#line 340 "WQL.y" |
{ | { |
globalParserState->statement->appendOperand( |
WQL_TRACE(("YACC: propertyName : TOK_IDENTIFIER(%s.%s)\n", (yyvsp[(1) - (3)].strValue), (yyvsp[(3) - (3)].strValue))); |
WQLOperand(yyvsp[0].intValue, WQLOperand::INTEGER_VALUE_TAG)); |
#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; | break; |
|
|
case 34: | case 34: |
#line 311 "WQL.y" |
#line 352 "WQL.y" |
{ | { |
globalParserState->statement->appendOperand( |
WQL_TRACE(("YACC: TOK_IDENTIFIER %s\n", (yyvsp[(1) - (1)].strValue))); |
WQLOperand(yyvsp[0].doubleValue, WQLOperand::DOUBLE_VALUE_TAG)); |
(yyval.strValue) = (yyvsp[(1) - (1)].strValue); |
} |
;} |
break; | break; |
|
|
case 35: | case 35: |
#line 316 "WQL.y" |
#line 359 "WQL.y" |
{ | { |
globalParserState->statement->appendOperand( | globalParserState->statement->appendOperand( |
WQLOperand(yyvsp[0].strValue, WQLOperand::STRING_VALUE_TAG)); |
WQLOperand((yyvsp[(1) - (1)].strValue), WQL_PROPERTY_NAME_TAG)); |
} |
globalParserState->statement->appendWherePropertyName(CIMName((yyvsp[(1) - (1)].strValue))); |
|
;} |
break; | break; |
|
|
case 36: | case 36: |
#line 321 "WQL.y" |
#line 365 "WQL.y" |
{ | { |
globalParserState->statement->appendOperand( | globalParserState->statement->appendOperand( |
WQLOperand(yyvsp[0].intValue != 0, WQLOperand::BOOLEAN_VALUE_TAG)); |
WQLOperand((yyvsp[(1) - (1)].intValue), WQL_INTEGER_VALUE_TAG)); |
} |
;} |
break; | break; |
#line 669 "y.tab.c" |
|
} |
case 37: |
yyssp -= yym; |
#line 370 "WQL.y" |
yystate = *yyssp; |
|
yyvsp -= yym; |
|
yym = yylhs[yyn]; |
|
if (yystate == 0 && yym == 0) |
|
{ | { |
#if YYDEBUG |
globalParserState->statement->appendOperand( |
if (yydebug) |
WQLOperand((yyvsp[(1) - (1)].doubleValue), WQL_DOUBLE_VALUE_TAG)); |
printf("%sdebug: after reduction, shifting from state 0 to\ |
;} |
state %d\n", YYPREFIX, YYFINAL); |
break; |
#endif |
|
yystate = YYFINAL; |
case 38: |
*++yyssp = YYFINAL; |
#line 375 "WQL.y" |
|
{ |
|
globalParserState->statement->appendOperand( |
|
WQLOperand((yyvsp[(1) - (1)].strValue), WQL_STRING_VALUE_TAG)); |
|
;} |
|
break; |
|
|
|
case 39: |
|
#line 380 "WQL.y" |
|
{ |
|
globalParserState->statement->appendOperand( |
|
WQLOperand((yyvsp[(1) - (1)].intValue) != 0, WQL_BOOLEAN_VALUE_TAG)); |
|
;} |
|
break; |
|
|
|
|
|
/* Line 1267 of yacc.c. */ |
|
#line 1760 "WQLtemp" |
|
default: break; |
|
} |
|
YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); |
|
|
|
YYPOPSTACK (yylen); |
|
yylen = 0; |
|
YY_STACK_PRINT (yyss, yyssp); |
|
|
*++yyvsp = yyval; | *++yyvsp = yyval; |
if (yychar < 0) |
|
|
|
|
/* 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) |
{ | { |
if ((yychar = yylex()) < 0) yychar = 0; |
++yynerrs; |
#if YYDEBUG |
#if ! YYERROR_VERBOSE |
if (yydebug) |
yyerror (YY_("syntax error")); |
|
#else |
|
{ |
|
YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); |
|
if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) |
|
{ |
|
YYSIZE_T yyalloc = 2 * yysize; |
|
if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) |
|
yyalloc = YYSTACK_ALLOC_MAXIMUM; |
|
if (yymsg != yymsgbuf) |
|
YYSTACK_FREE (yymsg); |
|
yymsg = (char *) YYSTACK_ALLOC (yyalloc); |
|
if (yymsg) |
|
yymsg_alloc = yyalloc; |
|
else |
{ | { |
yys = 0; |
yymsg = yymsgbuf; |
if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; |
yymsg_alloc = sizeof yymsgbuf; |
if (!yys) yys = "illegal-symbol"; |
|
printf("%sdebug: state %d, reading %d (%s)\n", |
|
YYPREFIX, YYFINAL, yychar, yys); |
|
} | } |
#endif |
|
} | } |
if (yychar == 0) goto yyaccept; |
|
goto yyloop; |
if (0 < yysize && yysize <= yymsg_alloc) |
|
{ |
|
(void) yysyntax_error (yymsg, yystate, yychar); |
|
yyerror (yymsg); |
} | } |
if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 && |
|
yyn <= YYTABLESIZE && yycheck[yyn] == yystate) |
|
yystate = yytable[yyn]; |
|
else | else |
yystate = yydgoto[yym]; |
{ |
#if YYDEBUG |
yyerror (YY_("syntax error")); |
if (yydebug) |
if (yysize != 0) |
printf("%sdebug: after reduction, shifting from state %d \ |
goto yyexhaustedlab; |
to state %d\n", YYPREFIX, *yyssp, yystate); |
} |
|
} |
#endif | #endif |
if (yyssp >= yyss + yystacksize - 1) |
} |
|
|
|
|
|
|
|
if (yyerrstatus == 3) |
|
{ |
|
/* If just tried and failed to reuse look-ahead token after an |
|
error, discard it. */ |
|
|
|
if (yychar <= YYEOF) |
{ | { |
goto yyoverflow; |
/* Return failure if at end of input. */ |
|
if (yychar == YYEOF) |
|
YYABORT; |
} | } |
*++yyssp = yystate; |
else |
*++yyvsp = yyval; |
{ |
goto yyloop; |
yydestruct ("Error: discarding", |
yyoverflow: |
yytoken, &yylval); |
yyerror("yacc stack overflow"); |
yychar = YYEMPTY; |
yyabort: |
} |
return (1); |
} |
yyaccept: |
|
return (0); |
/* Else will try to reuse look-ahead token after shifting the error |
|
token. */ |
|
goto yyerrlab1; |
|
|
|
|
|
/*---------------------------------------------------. |
|
| yyerrorlab -- error raised explicitly by YYERROR. | |
|
`---------------------------------------------------*/ |
|
yyerrorlab: |
|
|
|
/* Pacify compilers like GCC when the user code never invokes |
|
YYERROR and the label yyerrorlab therefore never appears in user |
|
code. */ |
|
if (/*CONSTCOND*/ 0) |
|
goto yyerrorlab; |
|
|
|
/* Do not reclaim the symbols of the rule which action triggered |
|
this YYERROR. */ |
|
YYPOPSTACK (yylen); |
|
yylen = 0; |
|
YY_STACK_PRINT (yyss, yyssp); |
|
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) |
|
{ |
|
yyn += YYTERROR; |
|
if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) |
|
{ |
|
yyn = yytable[yyn]; |
|
if (0 < yyn) |
|
break; |
|
} |
|
} |
|
|
|
/* Pop the current state because it cannot handle the error token. */ |
|
if (yyssp == yyss) |
|
YYABORT; |
|
|
|
|
|
yydestruct ("Error: popping", |
|
yystos[yystate], yyvsp); |
|
YYPOPSTACK (1); |
|
yystate = *yyssp; |
|
YY_STACK_PRINT (yyss, yyssp); |
|
} |
|
|
|
if (yyn == YYFINAL) |
|
YYACCEPT; |
|
|
|
*++yyvsp = yylval; |
|
|
|
|
|
/* Shift the error token. */ |
|
YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); |
|
|
|
yystate = yyn; |
|
goto yynewstate; |
|
|
|
|
|
/*-------------------------------------. |
|
| yyacceptlab -- YYACCEPT comes here. | |
|
`-------------------------------------*/ |
|
yyacceptlab: |
|
yyresult = 0; |
|
goto yyreturn; |
|
|
|
/*-----------------------------------. |
|
| yyabortlab -- YYABORT comes here. | |
|
`-----------------------------------*/ |
|
yyabortlab: |
|
yyresult = 1; |
|
goto yyreturn; |
|
|
|
#ifndef yyoverflow |
|
/*-------------------------------------------------. |
|
| yyexhaustedlab -- memory exhaustion comes here. | |
|
`-------------------------------------------------*/ |
|
yyexhaustedlab: |
|
yyerror (YY_("memory exhausted")); |
|
yyresult = 2; |
|
/* Fall through. */ |
|
#endif |
|
|
|
yyreturn: |
|
if (yychar != YYEOF && yychar != YYEMPTY) |
|
yydestruct ("Cleanup: discarding lookahead", |
|
yytoken, &yylval); |
|
/* Do not reclaim the symbols of the rule which action triggered |
|
this YYABORT or YYACCEPT. */ |
|
YYPOPSTACK (yylen); |
|
YY_STACK_PRINT (yyss, yyssp); |
|
while (yyssp != yyss) |
|
{ |
|
yydestruct ("Cleanup: popping", |
|
yystos[*yyssp], yyvsp); |
|
YYPOPSTACK (1); |
|
} |
|
#ifndef yyoverflow |
|
if (yyss != yyssa) |
|
YYSTACK_FREE (yyss); |
|
#endif |
|
#if YYERROR_VERBOSE |
|
if (yymsg != yymsgbuf) |
|
YYSTACK_FREE (yymsg); |
|
#endif |
|
/* Make sure YYID is used. */ |
|
return YYID (yyresult); |
} | } |
|
|
|
|
|
#line 385 "WQL.y" |
|
|
|
|