version 1.14, 2006/01/30 16:16:39
|
version 1.15, 2007/06/05 18:17:23
|
|
|
//%2006//////////////////////////////////////////////////////////////////////// |
/* A Bison parser, made by GNU Bison 2.3. */ |
// |
|
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development |
/* Skeleton implementation for Bison's Yacc-like parsers in C |
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems. |
|
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.; |
Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 |
// IBM Corp.; EMC Corporation, The Open Group. |
Free Software Foundation, Inc. |
// Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.; |
|
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. |
This program is free software; you can redistribute it and/or modify |
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; |
it under the terms of the GNU General Public License as published by |
// EMC Corporation; VERITAS Software Corporation; The Open Group. |
the Free Software Foundation; either version 2, or (at your option) |
// Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.; |
any later version. |
// EMC Corporation; Symantec Corporation; The Open Group. |
|
// |
This program is distributed in the hope that it will be useful, |
// Permission is hereby granted, free of charge, to any person obtaining a copy |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
// of this software and associated documentation files (the "Software"), to |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
// deal in the Software without restriction, including without limitation the |
GNU General Public License for more details. |
// 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 |
You should have received a copy of the GNU General Public License |
// furnished to do so, subject to the following conditions: |
along with this program; if not, write to the Free Software |
// |
Foundation, Inc., 51 Franklin Street, Fifth Floor, |
// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN |
Boston, MA 02110-1301, USA. */ |
// 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 |
/* As a special exception, you may create a larger work that contains |
// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR |
part or all of the Bison parser skeleton and distribute that work |
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT |
under terms of your choice, so long as that work isn't itself a |
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
parser generator using the skeleton or a modified version thereof |
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
as a parser skeleton. Alternatively, if you modify or redistribute |
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
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 |
#ifndef lint |
License without this special exception. |
static char const |
|
yyrcsid[] = "$FreeBSD: src/usr.bin/yacc/skeleton.c,v 1.28 2000/01/17 02:04:06 bde Exp $"; |
This special exception was added by the Free Software Foundation in |
#endif |
version 2.2 of Bison. */ |
#include <stdlib.h> |
|
#define YYBYACC 1 |
/* C LALR(1) parser skeleton written by Richard Stallman, by |
#define YYMAJOR 1 |
simplifying the original so-called "semantic" parser. */ |
#define YYMINOR 9 |
|
#define YYLEX yylex() |
/* All symbols defined below should begin with yy or YY, to avoid |
#define YYEMPTY -1 |
infringing on user name space. This should be done even for local |
#define yyclearin (yychar=(YYEMPTY)) |
variables, as they might otherwise be expanded by user macros. |
#define yyerrok (yyerrflag=0) |
There are some unavoidable exceptions within include files to |
#define YYRECOVERING() (yyerrflag!=0) |
define necessary library symbols; they are noted "INFRINGES ON |
static int yygrowstack(); |
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 CQL_parse | #define yyparse CQL_parse |
#define yylex CQL_lex | #define yylex CQL_lex |
#define yyerror CQL_error | #define yyerror CQL_error |
#define yychar CQL_char |
|
#define yyval CQL_val |
|
#define yylval CQL_lval | #define yylval CQL_lval |
|
#define yychar CQL_char |
#define yydebug CQL_debug | #define yydebug CQL_debug |
#define yynerrs CQL_nerrs | #define yynerrs CQL_nerrs |
#define yyerrflag CQL_errflag |
|
#define yyss CQL_ss |
|
#define yyssp CQL_ssp |
/* Tokens. */ |
#define yyvs CQL_vs |
#ifndef YYTOKENTYPE |
#define yyvsp CQL_vsp |
# define YYTOKENTYPE |
#define yylhs CQL_lhs |
/* Put the tokens into the symbol table, so that GDB and other debuggers |
#define yylen CQL_len |
know about them. */ |
#define yydefred CQL_defred |
enum yytokentype { |
#define yydgoto CQL_dgoto |
TOK_IDENTIFIER = 258, |
#define yysindex CQL_sindex |
TOK_STRING_LITERAL = 259, |
#define yyrindex CQL_rindex |
TOK_BINARY = 260, |
#define yygindex CQL_gindex |
TOK_NEGATIVE_BINARY = 261, |
#define yytable CQL_table |
TOK_HEXADECIMAL = 262, |
#define yycheck CQL_check |
TOK_NEGATIVE_HEXADECIMAL = 263, |
#define yyname CQL_name |
TOK_INTEGER = 264, |
#define yyrule CQL_rule |
TOK_NEGATIVE_INTEGER = 265, |
#define yysslim CQL_sslim |
TOK_REAL = 266, |
#define yystacksize CQL_stacksize |
TOK_NEGATIVE_REAL = 267, |
#define YYPREFIX "CQL_" |
TOK_TRUE = 268, |
#line 30 "CQL.y" |
TOK_FALSE = 269, |
|
TOK_SCOPED_PROPERTY = 270, |
|
TOK_LPAR = 271, |
|
TOK_RPAR = 272, |
|
TOK_HASH = 273, |
|
TOK_DOT = 274, |
|
TOK_LBRKT = 275, |
|
TOK_RBRKT = 276, |
|
TOK_UNDERSCORE = 277, |
|
TOK_COMMA = 278, |
|
TOK_CONCAT = 279, |
|
TOK_DBL_PIPE = 280, |
|
TOK_PLUS = 281, |
|
TOK_MINUS = 282, |
|
TOK_TIMES = 283, |
|
TOK_DIV = 284, |
|
TOK_IS = 285, |
|
TOK_NULL = 286, |
|
TOK_EQ = 287, |
|
TOK_NE = 288, |
|
TOK_GT = 289, |
|
TOK_LT = 290, |
|
TOK_GE = 291, |
|
TOK_LE = 292, |
|
TOK_ISA = 293, |
|
TOK_LIKE = 294, |
|
TOK_NOT = 295, |
|
TOK_AND = 296, |
|
TOK_OR = 297, |
|
TOK_SCOPE = 298, |
|
TOK_ANY = 299, |
|
TOK_EVERY = 300, |
|
TOK_IN = 301, |
|
TOK_SATISFIES = 302, |
|
TOK_STAR = 303, |
|
TOK_DOTDOT = 304, |
|
TOK_SHARP = 305, |
|
TOK_DISTINCT = 306, |
|
TOK_SELECT = 307, |
|
TOK_FIRST = 308, |
|
TOK_FROM = 309, |
|
TOK_WHERE = 310, |
|
TOK_ORDER = 311, |
|
TOK_BY = 312, |
|
TOK_ASC = 313, |
|
TOK_DESC = 314, |
|
TOK_AS = 315, |
|
TOK_UNEXPECTED_CHAR = 316 |
|
}; |
|
#endif |
|
/* Tokens. */ |
|
#define TOK_IDENTIFIER 258 |
|
#define TOK_STRING_LITERAL 259 |
|
#define TOK_BINARY 260 |
|
#define TOK_NEGATIVE_BINARY 261 |
|
#define TOK_HEXADECIMAL 262 |
|
#define TOK_NEGATIVE_HEXADECIMAL 263 |
|
#define TOK_INTEGER 264 |
|
#define TOK_NEGATIVE_INTEGER 265 |
|
#define TOK_REAL 266 |
|
#define TOK_NEGATIVE_REAL 267 |
|
#define TOK_TRUE 268 |
|
#define TOK_FALSE 269 |
|
#define TOK_SCOPED_PROPERTY 270 |
|
#define TOK_LPAR 271 |
|
#define TOK_RPAR 272 |
|
#define TOK_HASH 273 |
|
#define TOK_DOT 274 |
|
#define TOK_LBRKT 275 |
|
#define TOK_RBRKT 276 |
|
#define TOK_UNDERSCORE 277 |
|
#define TOK_COMMA 278 |
|
#define TOK_CONCAT 279 |
|
#define TOK_DBL_PIPE 280 |
|
#define TOK_PLUS 281 |
|
#define TOK_MINUS 282 |
|
#define TOK_TIMES 283 |
|
#define TOK_DIV 284 |
|
#define TOK_IS 285 |
|
#define TOK_NULL 286 |
|
#define TOK_EQ 287 |
|
#define TOK_NE 288 |
|
#define TOK_GT 289 |
|
#define TOK_LT 290 |
|
#define TOK_GE 291 |
|
#define TOK_LE 292 |
|
#define TOK_ISA 293 |
|
#define TOK_LIKE 294 |
|
#define TOK_NOT 295 |
|
#define TOK_AND 296 |
|
#define TOK_OR 297 |
|
#define TOK_SCOPE 298 |
|
#define TOK_ANY 299 |
|
#define TOK_EVERY 300 |
|
#define TOK_IN 301 |
|
#define TOK_SATISFIES 302 |
|
#define TOK_STAR 303 |
|
#define TOK_DOTDOT 304 |
|
#define TOK_SHARP 305 |
|
#define TOK_DISTINCT 306 |
|
#define TOK_SELECT 307 |
|
#define TOK_FIRST 308 |
|
#define TOK_FROM 309 |
|
#define TOK_WHERE 310 |
|
#define TOK_ORDER 311 |
|
#define TOK_BY 312 |
|
#define TOK_ASC 313 |
|
#define TOK_DESC 314 |
|
#define TOK_AS 315 |
|
#define TOK_UNEXPECTED_CHAR 316 |
|
|
|
|
|
|
|
|
|
/* Copy the first part of user declarations. */ |
|
#line 31 "CQL.y" |
|
|
#include <Pegasus/Common/Config.h> | #include <Pegasus/Common/Config.h> |
#include <Pegasus/Common/String.h> | #include <Pegasus/Common/String.h> |
#include <Pegasus/Common/CommonUTF.h> | #include <Pegasus/Common/CommonUTF.h> |
|
|
#define CQLFUNCTION 3 | #define CQLFUNCTION 3 |
#define CQLCHAINEDIDENTIFIER 4 | #define CQLCHAINEDIDENTIFIER 4 |
| |
|
//#define CQL_DEBUG_GRAMMAR |
|
|
#ifdef CQL_DEBUG_GRAMMAR | #ifdef CQL_DEBUG_GRAMMAR |
#define DEBUG_GRAMMAR 1 | #define DEBUG_GRAMMAR 1 |
#else | #else |
|
|
#endif | #endif |
| |
int yylex(); | int yylex(); |
static char msg[100]; |
static char msg[200]; |
void printf_(char * msg){ |
void printf_(const char * msg) |
|
{ |
if(DEBUG_GRAMMAR == 1) | if(DEBUG_GRAMMAR == 1) |
printf("%s\n",msg); | printf("%s\n",msg); |
} | } |
|
|
|
|
|
#define CQL_DEBUG_GRAMMAR |
|
|
|
#ifdef CQL_DEBUG_GRAMMAR |
|
#define CQLTRACE(X){ \ |
|
CQL_globalParserState->currentRule = X; \ |
|
sprintf(msg,"BISON::%s", X ); \ |
|
printf_(msg); \ |
|
} |
|
#else |
|
#define CQLTRACE(X) |
|
#endif |
|
|
|
#ifdef CQL_DEBUG_GRAMMAR |
|
#define CQLTRACE2( X, Y ){ \ |
|
CQL_globalParserState->currentRule = X; \ |
|
sprintf(msg,msg,"BISON::%s = %s\n", X, Y ); \ |
|
printf_(msg); \ |
|
} |
|
#else |
|
#define CQLTRACE2( X,Y ) |
|
#endif |
|
|
|
#define CQLTRACEMSG(X, Y) { \ |
|
sprintf(msg,"BISON::%s-> %s\n", X, Y); \ |
|
printf_(msg); \ |
|
} |
|
|
|
#define CQLTRACEDECIMAL(X, Y) { \ |
|
CQL_globalParserState->currentRule = X; \ |
|
sprintf(msg,"BISON::chain-> X : Y = %d\n",Y); \ |
|
} |
|
|
|
|
extern char * yytext; | extern char * yytext; |
int chain_state; | int chain_state; |
CQLFactory _factory = CQLFactory(); | CQLFactory _factory = CQLFactory(); |
|
|
Array<CQLObjPtr> _ptrs; | Array<CQLObjPtr> _ptrs; |
CQLOBJPTR _ObjPtr; | CQLOBJPTR _ObjPtr; |
| |
|
PEGASUS_NAMESPACE_BEGIN |
|
|
|
extern CQLParserState* CQL_globalParserState; |
|
Array<CQLPredicate> _arglist; |
|
|
|
|
|
PEGASUS_NAMESPACE_END |
|
|
| |
void CQL_Bison_Cleanup(){ | void CQL_Bison_Cleanup(){ |
for(Uint32 i = 0; i < _ptrs.size(); i++){ |
for(Uint32 i = 0; i < _ptrs.size(); i++) |
if(_ptrs[i]._ptr){ |
{ |
switch(_ptrs[i].type){ |
if(_ptrs[i]._ptr) |
|
{ |
|
switch(_ptrs[i].type) |
|
{ |
case Id: | case Id: |
delete (CQLIdentifier*)_ptrs[i]._ptr; | delete (CQLIdentifier*)_ptrs[i]._ptr; |
break; | break; |
|
|
_factory = CQLFactory(); | _factory = CQLFactory(); |
} | } |
| |
PEGASUS_NAMESPACE_BEGIN |
|
| |
extern CQLParserState* CQL_globalParserState; |
|
Array<CQLPredicate> _arglist; |
|
| |
| |
PEGASUS_NAMESPACE_END |
|
| |
| |
#line 125 "CQL.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 171 "CQL.y" |
|
{ |
char * strValue; | char * strValue; |
String * _string; | String * _string; |
CQLValue * _value; | CQLValue * _value; |
|
|
CQLPredicate * _predicate; | CQLPredicate * _predicate; |
ExpressionOpType _opType; | ExpressionOpType _opType; |
void * _node; | void * _node; |
} YYSTYPE; |
} |
#line 149 "y.tab.c" |
/* Line 187 of yacc.c. */ |
#define YYERRCODE 256 |
#line 378 "CQLtemp" |
#define IDENTIFIER 257 |
YYSTYPE; |
#define STRING_LITERAL 258 |
# define yystype YYSTYPE /* obsolescent; will be withdrawn */ |
#define BINARY 259 |
# define YYSTYPE_IS_DECLARED 1 |
#define NEGATIVE_BINARY 260 |
# define YYSTYPE_IS_TRIVIAL 1 |
#define HEXADECIMAL 261 |
#endif |
#define NEGATIVE_HEXADECIMAL 262 |
|
#define INTEGER 263 |
|
#define NEGATIVE_INTEGER 264 |
|
#define REAL 265 |
/* Copy the second part of user declarations. */ |
#define NEGATIVE_REAL 266 |
|
#define _TRUE 267 |
|
#define _FALSE 268 |
/* Line 216 of yacc.c. */ |
#define SCOPED_PROPERTY 269 |
#line 391 "CQLtemp" |
#define LPAR 270 |
|
#define RPAR 271 |
#ifdef short |
#define HASH 272 |
# undef short |
#define DOT 273 |
#endif |
#define LBRKT 274 |
|
#define RBRKT 275 |
#ifdef YYTYPE_UINT8 |
#define UNDERSCORE 276 |
typedef YYTYPE_UINT8 yytype_uint8; |
#define COMMA 277 |
#else |
#define CONCAT 278 |
typedef unsigned char yytype_uint8; |
#define DBL_PIPE 279 |
#endif |
#define PLUS 280 |
|
#define MINUS 281 |
#ifdef YYTYPE_INT8 |
#define TIMES 282 |
typedef YYTYPE_INT8 yytype_int8; |
#define DIV 283 |
#elif (defined __STDC__ || defined __C99__FUNC__ \ |
#define IS 284 |
|| defined __cplusplus || defined _MSC_VER) |
#define _NULL 285 |
typedef signed char yytype_int8; |
#define _EQ 286 |
#else |
#define _NE 287 |
typedef short int yytype_int8; |
#define _GT 288 |
#endif |
#define _LT 289 |
|
#define _GE 290 |
#ifdef YYTYPE_UINT16 |
#define _LE 291 |
typedef YYTYPE_UINT16 yytype_uint16; |
#define _ISA 292 |
#else |
#define _LIKE 293 |
typedef unsigned short int yytype_uint16; |
#define NOT 294 |
#endif |
#define _AND 295 |
|
#define _OR 296 |
#ifdef YYTYPE_INT16 |
#define SCOPE 297 |
typedef YYTYPE_INT16 yytype_int16; |
#define ANY 298 |
#else |
#define EVERY 299 |
typedef short int yytype_int16; |
#define IN 300 |
#endif |
#define SATISFIES 301 |
|
#define STAR 302 |
#ifndef YYSIZE_T |
#define DOTDOT 303 |
# ifdef __SIZE_TYPE__ |
#define SHARP 304 |
# define YYSIZE_T __SIZE_TYPE__ |
#define DISTINCT 305 |
# elif defined size_t |
#define SELECT 306 |
# define YYSIZE_T size_t |
#define FIRST 307 |
# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ |
#define FROM 308 |
|| defined __cplusplus || defined _MSC_VER) |
#define WHERE 309 |
# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ |
#define ORDER 310 |
# define YYSIZE_T size_t |
#define BY 311 |
# else |
#define ASC 312 |
# define YYSIZE_T unsigned int |
#define DESC 313 |
# endif |
#define AS 314 |
#endif |
#define UNEXPECTED_CHAR 315 |
|
const short CQL_lhs[] = { -1, |
#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) |
1, 2, 3, 4, 5, 6, 6, 7, 7, 8, |
|
8, 9, 9, 10, 10, 10, 10, 10, 10, 10, |
#ifndef YY_ |
11, 12, 13, 13, 13, 13, 13, 13, 13, 13, |
# if YYENABLE_NLS |
13, 13, 14, 14, 15, 16, 17, 18, 19, 19, |
# if ENABLE_NLS |
20, 20, 20, 20, 20, 20, 21, 21, 21, 21, |
# include <libintl.h> /* INFRINGES ON USER NAME SPACE */ |
21, 21, 21, 22, 22, 23, 23, 24, 24, 25, |
# define YY_(msgid) dgettext ("bison-runtime", msgid) |
25, 26, 26, 26, 27, 28, 28, 29, 29, 30, |
# endif |
31, 31, 32, 33, 33, 0, |
# 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 |
|
{ |
|
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; |
}; | }; |
const short CQL_len[] = { 2, |
|
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
/* 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 41 |
|
/* YYLAST -- Last index in YYTABLE. */ |
|
#define YYLAST 140 |
|
|
|
/* YYNTOKENS -- Number of terminals. */ |
|
#define YYNTOKENS 62 |
|
/* YYNNTS -- Number of nonterminals. */ |
|
#define YYNNTS 35 |
|
/* YYNRULES -- Number of rules. */ |
|
#define YYNRULES 77 |
|
/* YYNRULES -- Number of states. */ |
|
#define YYNSTATES 108 |
|
|
|
/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ |
|
#define YYUNDEFTOK 2 |
|
#define YYMAXUTOK 316 |
|
|
|
#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, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 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, 26, 27, 28, 29, 30, 31, 32, 33, 34, |
|
35, 36, 37, 38, 39, 40, 41, 42, 43, 44, |
|
45, 46, 47, 48, 49, 50, 51, 52, 53, 54, |
|
55, 56, 57, 58, 59, 60, 61 |
|
}; |
|
|
|
#if YYDEBUG |
|
/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in |
|
YYRHS. */ |
|
static const yytype_uint8 yyprhs[] = |
|
{ |
|
0, 0, 3, 5, 7, 9, 11, 13, 15, 17, |
|
19, 21, 23, 25, 27, 29, 31, 33, 35, 37, |
|
39, 41, 43, 45, 47, 49, 53, 55, 59, 61, |
|
66, 70, 74, 80, 85, 87, 91, 93, 95, 97, |
|
100, 102, 104, 106, 108, 110, 112, 114, 116, 118, |
|
123, 127, 131, 135, 139, 143, 145, 148, 150, 154, |
|
156, 160, 161, 163, 165, 169, 172, 174, 176, 180, |
|
182, 184, 187, 188, 192, 194, 195, 198 |
|
}; |
|
|
|
/* YYRHS -- A `-1'-separated list of the rules' RHS. */ |
|
static const yytype_int8 yyrhs[] = |
|
{ |
|
96, 0, -1, 3, -1, 63, -1, 64, -1, 15, |
|
-1, 4, -1, 5, -1, 6, -1, 7, -1, 8, |
|
-1, 9, -1, 10, -1, 11, -1, 12, -1, 67, |
|
-1, 70, -1, 68, -1, 69, -1, 71, -1, 13, |
|
-1, 14, -1, 86, -1, 73, -1, 72, -1, 16, |
|
86, 17, -1, 63, -1, 63, 18, 67, -1, 66, |
|
-1, 63, 16, 87, 17, -1, 75, 19, 66, -1, |
|
75, 19, 63, -1, 75, 19, 63, 18, 67, -1, |
|
75, 20, 74, 21, -1, 75, -1, 76, 25, 67, |
|
-1, 76, -1, 77, -1, 78, -1, 18, 67, -1, |
|
79, -1, 80, -1, 32, -1, 33, -1, 34, -1, |
|
35, -1, 36, -1, 37, -1, 79, -1, 79, 30, |
|
40, 31, -1, 79, 30, 31, -1, 79, 82, 81, |
|
-1, 80, 82, 79, -1, 79, 38, 63, -1, 79, |
|
39, 67, -1, 83, -1, 40, 83, -1, 84, -1, |
|
85, 41, 84, -1, 85, -1, 86, 42, 85, -1, |
|
-1, 86, -1, 65, -1, 65, 60, 63, -1, 65, |
|
63, -1, 88, -1, 48, -1, 75, 19, 48, -1, |
|
86, -1, 90, -1, 91, 93, -1, -1, 23, 91, |
|
93, -1, 86, -1, -1, 55, 94, -1, 52, 92, |
|
54, 89, 95, -1 |
|
}; |
|
|
|
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ |
|
static const yytype_uint16 yyrline[] = |
|
{ |
|
0, 295, 295, 323, 331, 348, 382, 412, 421, 435, |
|
444, 456, 465, 477, 486, 498, 505, 509, 513, 517, |
|
521, 530, 542, 555, 564, 571, 577, 584, 594, 601, |
|
610, 648, 684, 727, 781, 787, 871, 901, 933, 967, |
|
981, 987, 997, 1003, 1008, 1014, 1019, 1024, 1031, 1037, |
|
1047, 1056, 1085, 1114, 1130, 1144, 1150, 1159, 1165, 1178, |
|
1184, 1197, 1215, 1275, 1281, 1291, 1302, 1308, 1315, 1331, |
|
1353, 1361, 1367, 1368, 1374, 1382, 1383, 1391 |
|
}; |
|
#endif |
|
|
|
#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE |
|
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. |
|
First, the terminals, then, starting at YYNTOKENS, nonterminals. */ |
|
static const char *const yytname[] = |
|
{ |
|
"$end", "error", "$undefined", "TOK_IDENTIFIER", "TOK_STRING_LITERAL", |
|
"TOK_BINARY", "TOK_NEGATIVE_BINARY", "TOK_HEXADECIMAL", |
|
"TOK_NEGATIVE_HEXADECIMAL", "TOK_INTEGER", "TOK_NEGATIVE_INTEGER", |
|
"TOK_REAL", "TOK_NEGATIVE_REAL", "TOK_TRUE", "TOK_FALSE", |
|
"TOK_SCOPED_PROPERTY", "TOK_LPAR", "TOK_RPAR", "TOK_HASH", "TOK_DOT", |
|
"TOK_LBRKT", "TOK_RBRKT", "TOK_UNDERSCORE", "TOK_COMMA", "TOK_CONCAT", |
|
"TOK_DBL_PIPE", "TOK_PLUS", "TOK_MINUS", "TOK_TIMES", "TOK_DIV", |
|
"TOK_IS", "TOK_NULL", "TOK_EQ", "TOK_NE", "TOK_GT", "TOK_LT", "TOK_GE", |
|
"TOK_LE", "TOK_ISA", "TOK_LIKE", "TOK_NOT", "TOK_AND", "TOK_OR", |
|
"TOK_SCOPE", "TOK_ANY", "TOK_EVERY", "TOK_IN", "TOK_SATISFIES", |
|
"TOK_STAR", "TOK_DOTDOT", "TOK_SHARP", "TOK_DISTINCT", "TOK_SELECT", |
|
"TOK_FIRST", "TOK_FROM", "TOK_WHERE", "TOK_ORDER", "TOK_BY", "TOK_ASC", |
|
"TOK_DESC", "TOK_AS", "TOK_UNEXPECTED_CHAR", "$accept", "identifier", |
|
"class_name", "class_path", "scoped_property", "literal_string", |
|
"binary_value", "hex_value", "decimal_value", "real_value", "literal", |
|
"array_index", "array_index_list", "chain", "concat", "factor", "term", |
|
"arith", "value_symbol", "arith_or_value_symbol", "comp_op", "comp", |
|
"expr_factor", "expr_term", "expr", "arg_list", "from_specifier", |
|
"from_criteria", "star_expr", "selected_entry", "select_list", |
|
"select_list_tail", "search_condition", "optional_where", |
|
"select_statement", 0 |
|
}; |
|
#endif |
|
|
|
# ifdef YYPRINT |
|
/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to |
|
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, 281, 282, 283, 284, |
|
285, 286, 287, 288, 289, 290, 291, 292, 293, 294, |
|
295, 296, 297, 298, 299, 300, 301, 302, 303, 304, |
|
305, 306, 307, 308, 309, 310, 311, 312, 313, 314, |
|
315, 316 |
|
}; |
|
# endif |
|
|
|
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ |
|
static const yytype_uint8 yyr1[] = |
|
{ |
|
0, 62, 63, 64, 65, 66, 67, 68, 68, 69, |
|
69, 70, 70, 71, 71, 72, 72, 72, 72, 72, |
|
72, 72, 73, 74, 75, 75, 75, 75, 75, 75, |
|
75, 75, 75, 75, 76, 76, 77, 78, 79, 80, |
|
81, 81, 82, 82, 82, 82, 82, 82, 83, 83, |
|
83, 83, 83, 83, 83, 84, 84, 85, 85, 86, |
|
86, 87, 87, 88, 88, 88, 89, 90, 90, 91, |
|
91, 92, 93, 93, 94, 95, 95, 96 |
|
}; |
|
|
|
/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ |
|
static const yytype_uint8 yyr2[] = |
|
{ |
|
0, 2, 1, 1, 1, 1, 1, 1, 1, 1, |
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, | 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, |
1, 1, 1, 3, 1, 3, 1, 4, 3, 3, |
1, 1, 1, 1, 1, 3, 1, 3, 1, 4, |
5, 4, 1, 3, 1, 1, 1, 2, 1, 1, |
3, 3, 5, 4, 1, 3, 1, 1, 1, 2, |
1, 1, 1, 1, 1, 1, 1, 4, 3, 3, |
1, 1, 1, 1, 1, 1, 1, 1, 1, 4, |
3, 3, 3, 1, 2, 1, 3, 1, 3, 0, |
3, 3, 3, 3, 3, 1, 2, 1, 3, 1, |
1, 1, 3, 2, 1, 1, 3, 1, 1, 2, |
3, 0, 1, 1, 3, 2, 1, 1, 3, 1, |
0, 3, 1, 0, 2, 5, |
1, 2, 0, 3, 1, 0, 2, 5 |
}; | }; |
const short CQL_defred[] = { 0, |
|
0, 0, 1, 5, 6, 7, 8, 9, 10, 11, |
/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state |
12, 13, 19, 20, 4, 0, 0, 0, 66, 0, |
STATE-NUM when YYTABLE doesn't specify something else to do. Zero |
27, 14, 16, 17, 15, 18, 23, 0, 0, 36, |
means the default is an error. */ |
37, 0, 0, 54, 56, 0, 0, 69, 0, 0, |
static const yytype_uint8 yydefact[] = |
0, 0, 38, 55, 0, 0, 0, 0, 0, 0, |
{ |
41, 42, 43, 44, 45, 46, 0, 0, 0, 0, |
0, 0, 0, 2, 6, 7, 8, 9, 10, 11, |
0, 0, 0, 70, 0, 0, 24, 0, 0, 26, |
12, 13, 14, 20, 21, 5, 0, 0, 0, 67, |
67, 0, 29, 22, 0, 0, 34, 49, 0, 52, |
26, 28, 15, 17, 18, 16, 19, 24, 34, 36, |
53, 39, 40, 50, 51, 57, 0, 0, 2, 3, |
37, 38, 48, 0, 55, 57, 59, 69, 70, 72, |
0, 65, 0, 28, 0, 32, 48, 72, 0, 64, |
0, 1, 34, 0, 39, 56, 61, 0, 0, 0, |
0, 76, 31, 63, 0, 75, |
0, 0, 42, 43, 44, 45, 46, 47, 0, 0, |
|
0, 0, 0, 0, 0, 71, 0, 0, 25, 62, |
|
0, 27, 68, 31, 30, 23, 0, 22, 35, 50, |
|
0, 53, 54, 40, 41, 51, 52, 58, 60, 72, |
|
3, 4, 63, 66, 75, 29, 0, 33, 49, 73, |
|
0, 65, 0, 77, 32, 64, 74, 76 |
}; | }; |
const short CQL_dgoto[] = { 2, |
|
20, 90, 91, 21, 22, 23, 24, 25, 26, 27, |
/* YYDEFGOTO[NTERM-NUM]. */ |
74, 75, 41, 29, 30, 31, 32, 33, 84, 59, |
static const yytype_int8 yydefgoto[] = |
34, 35, 36, 37, 69, 92, 93, 38, 39, 40, |
{ |
64, 106, 102, |
-1, 20, 91, 92, 21, 22, 23, 24, 25, 26, |
|
27, 75, 76, 42, 29, 30, 31, 32, 33, 85, |
|
60, 34, 35, 36, 37, 70, 93, 94, 38, 39, |
|
40, 65, 107, 103, 2 |
}; | }; |
const short CQL_sindex[] = { -295, |
|
-152, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing |
0, 0, 0, 0, 0, -136, -241, -98, 0, -256, |
STATE-NUM. */ |
0, 0, 0, 0, 0, 0, 0, -255, -257, 0, |
#define YYPACT_NINF -46 |
0, -196, -247, 0, 0, -265, -264, 0, -240, -260, |
static const yytype_int8 yypact[] = |
-227, -261, 0, 0, -136, -241, -249, -136, -241, -273, |
{ |
0, 0, 0, 0, 0, 0, -207, -241, -98, -82, |
-36, 62, 11, -46, -46, -46, -46, -46, -46, -46, |
-136, -136, -152, 0, -207, -244, 0, -264, -220, 0, |
-46, -46, -46, -46, -46, -46, 85, 15, 108, -46, |
0, -218, 0, 0, -216, -264, 0, 0, -230, 0, |
-6, -46, -46, -46, -46, -46, -46, -46, -5, 20, |
0, 0, 0, 0, 0, 0, -265, -240, 0, 0, |
-46, -46, 4, 72, -46, -46, -12, -17, -46, 23, |
-251, 0, -253, 0, -241, 0, 0, 0, -207, 0, |
-3, -46, 8, -11, -46, -46, 85, 15, 2, 85, |
-136, 0, 0, 0, -264, 0, |
15, -22, -46, -46, -46, -46, -46, -46, 45, 15, |
|
108, 124, 85, 85, 62, -46, 45, 5, -46, -17, |
|
32, -46, -46, 34, -46, -46, 33, -17, -46, -46, |
|
22, -46, -46, -46, -46, -46, -46, -46, -12, 23, |
|
-46, -46, 1, -46, 3, -46, 15, -46, -46, -46, |
|
45, -46, 85, -46, -46, -46, -17, -46 |
}; | }; |
const short CQL_rindex[] = { 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
/* YYPGOTO[NTERM-NUM]. */ |
0, 0, 0, 0, 0, 0, 0, 0, 0, 3, |
static const yytype_int8 yypgoto[] = |
0, 0, 0, 0, 0, 0, 0, -219, 75, 0, |
{ |
0, 78, 0, 0, 0, 101, -270, 0, -242, 0, |
-46, -45, -46, -46, -41, -15, -46, -46, -46, -46, |
52, 0, 0, 0, -210, 0, 0, 0, 0, 0, |
-46, -46, -46, 0, -46, -46, -46, -37, -4, -46, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
24, 41, -2, -1, -16, -46, -46, -46, -46, 18, |
0, 0, 0, 0, 0, 0, 0, -192, 0, 0, |
-46, -26, -46, -46, -46 |
0, 29, 0, 0, 0, -211, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 104, -242, 0, 0, |
|
1, 0, 80, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 81, 0, |
|
}; | }; |
const short CQL_gindex[] = { 0, |
|
-42, 0, 0, -38, -13, 0, 0, 0, 0, 0, |
/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If |
0, 0, -1, 0, 0, 0, -33, 24, 0, 51, |
positive, shift that token. If negative, reduce the rule which |
67, 25, 36, -14, 0, 0, 0, 0, 37, 0, |
number is the opposite. If zero, do what YYDEFACT says. |
11, 0, 0, |
If YYTABLE_NINF, syntax error. */ |
|
#define YYTABLE_NINF -1 |
|
static const yytype_uint8 yytable[] = |
|
{ |
|
43, 28, 44, 73, 3, 3, 68, 74, 3, 79, |
|
46, 41, 47, 81, 48, 49, 1, 15, 80, 4, |
|
15, 90, 73, 83, 86, 63, 74, 67, 49, 62, |
|
69, 63, 71, 77, 51, 78, 52, 53, 54, 55, |
|
56, 57, 58, 59, 82, 50, 64, 101, 3, 95, |
|
72, 66, 96, 98, 97, 105, 84, 61, 102, 45, |
|
87, 100, 88, 99, 28, 3, 4, 5, 6, 7, |
|
8, 9, 10, 11, 12, 13, 14, 15, 16, 0, |
|
17, 104, 89, 0, 0, 0, 106, 0, 3, 4, |
|
5, 6, 7, 8, 9, 10, 11, 12, 13, 14, |
|
15, 16, 18, 17, 52, 53, 54, 55, 56, 57, |
|
19, 3, 4, 5, 6, 7, 8, 9, 10, 11, |
|
12, 13, 14, 15, 16, 18, 17, 3, 4, 5, |
|
6, 7, 8, 9, 10, 11, 12, 13, 14, 15, |
|
16 |
}; | }; |
#define YYTABLESIZE 412 |
|
const short CQL_table[] = { 28, |
static const yytype_int8 yycheck[] = |
62, 42, 25, 43, 72, 3, 68, 3, 73, 67, |
{ |
1, 78, 3, 45, 80, 46, 4, 47, 48, 15, |
16, 1, 17, 48, 3, 3, 17, 48, 3, 31, |
79, 49, 89, 72, 15, 82, 85, 73, 30, 61, |
16, 0, 18, 58, 19, 20, 52, 15, 40, 4, |
68, 62, 70, 76, 62, 77, 63, 68, 51, 52, |
15, 66, 67, 60, 61, 42, 67, 19, 20, 41, |
53, 54, 55, 56, 81, 66, 48, 65, 100, 3, |
46, 42, 47, 49, 30, 50, 32, 33, 34, 35, |
94, 33, 71, 95, 97, 101, 104, 33, 96, 33, |
36, 37, 38, 39, 59, 25, 23, 92, 3, 17, |
60, 28, 99, 21, 33, 71, 33, 33, 33, 33, |
48, 54, 18, 31, 21, 100, 60, 33, 55, 18, |
33, 33, 33, 33, 35, 33, 33, 47, 61, 74, |
62, 60, 63, 89, 64, 3, 4, 5, 6, 7, |
73, 103, 83, 60, 44, 86, 105, 50, 33, 51, |
8, 9, 10, 11, 12, 13, 14, 15, 16, -1, |
52, 53, 54, 55, 56, 57, 58, 87, 98, 88, |
18, 96, 64, -1, -1, -1, 102, -1, 3, 4, |
58, 0, 0, 59, 3, 4, 5, 6, 7, 8, |
|
9, 10, 11, 12, 13, 14, 15, 16, 0, 17, |
|
3, 4, 5, 6, 7, 8, 9, 10, 11, 12, |
|
13, 14, 15, 16, 0, 17, 0, 0, 0, 0, |
|
0, 18, 0, 0, 0, 0, 0, 0, 0, 19, |
|
0, 0, 0, 0, 0, 0, 0, 18, 3, 4, |
|
5, 6, 7, 8, 9, 10, 11, 12, 13, 14, | 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, |
15, 16, 0, 17, 3, 4, 5, 6, 7, 8, |
15, 16, 40, 18, 32, 33, 34, 35, 36, 37, |
9, 10, 11, 12, 13, 14, 15, 16, 0, 0, |
48, 3, 4, 5, 6, 7, 8, 9, 10, 11, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
12, 13, 14, 15, 16, 40, 18, 3, 4, 5, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
6, 7, 8, 9, 10, 11, 12, 13, 14, 15, |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
16 |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 25, 0, 25, 25, 25, 0, 25, |
|
0, 25, 0, 0, 0, 0, 25, 0, 25, 25, |
|
25, 25, 25, 25, 25, 25, 0, 25, 25, 30, |
|
0, 30, 30, 30, 0, 30, 0, 30, 0, 62, |
|
25, 0, 30, 0, 30, 30, 30, 30, 30, 30, |
|
30, 30, 33, 30, 30, 0, 33, 0, 33, 0, |
|
33, 0, 0, 0, 0, 33, 30, 33, 33, 33, |
|
33, 33, 33, 33, 33, 35, 33, 33, 47, 35, |
|
0, 35, 47, 0, 47, 0, 0, 0, 35, 33, |
|
35, 35, 35, 35, 35, 35, 35, 35, 0, 35, |
|
35, 58, 47, 47, 59, 58, 0, 58, 59, 0, |
|
59, 0, 35, 0, 0, 47, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 58, 0, 0, 59, |
|
0, 0, 0, 0, 0, 0, 0, 0, 58, 0, |
|
0, 59, |
|
}; | }; |
const short CQL_check[] = { 1, |
|
0, 16, 0, 17, 47, 257, 277, 257, 47, 271, |
/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing |
306, 285, 257, 270, 57, 272, 258, 273, 274, 269, |
symbol of state STATE-NUM. */ |
294, 279, 65, 66, 269, 59, 60, 66, 0, 295, |
static const yytype_uint8 yystos[] = |
45, 296, 46, 48, 296, 49, 277, 308, 286, 287, |
{ |
288, 289, 290, 291, 58, 273, 274, 308, 91, 257, |
0, 52, 96, 3, 4, 5, 6, 7, 8, 9, |
271, 0, 302, 272, 285, 309, 99, 277, 275, 279, |
10, 11, 12, 13, 14, 15, 16, 18, 40, 48, |
271, 63, 314, 275, 284, 308, 286, 287, 288, 289, |
63, 66, 67, 68, 69, 70, 71, 72, 75, 76, |
290, 291, 292, 293, 0, 295, 296, 0, 271, 0, |
77, 78, 79, 80, 83, 84, 85, 86, 90, 91, |
0, 95, 59, 33, 18, 61, 101, 284, 308, 286, |
92, 0, 75, 86, 67, 83, 16, 18, 19, 20, |
287, 288, 289, 290, 291, 292, 293, 62, 88, 63, |
25, 30, 32, 33, 34, 35, 36, 37, 38, 39, |
0, -1, -1, 0, 257, 258, 259, 260, 261, 262, |
82, 82, 41, 42, 23, 93, 54, 19, 17, 86, |
263, 264, 265, 266, 267, 268, 269, 270, -1, 272, |
87, 67, 48, 63, 66, 73, 74, 86, 67, 31, |
257, 258, 259, 260, 261, 262, 263, 264, 265, 266, |
40, 63, 67, 79, 80, 81, 79, 84, 85, 91, |
267, 268, 269, 270, -1, 272, -1, -1, -1, -1, |
63, 64, 65, 88, 89, 17, 18, 21, 31, 93, |
-1, 294, -1, -1, -1, -1, -1, -1, -1, 302, |
60, 63, 55, 95, 67, 63, 86, 94 |
-1, -1, -1, -1, -1, -1, -1, 294, 257, 258, |
|
259, 260, 261, 262, 263, 264, 265, 266, 267, 268, |
|
269, 270, -1, 272, 257, 258, 259, 260, 261, 262, |
|
263, 264, 265, 266, 267, 268, 269, 270, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, 271, -1, 273, 274, 275, -1, 277, |
|
-1, 279, -1, -1, -1, -1, 284, -1, 286, 287, |
|
288, 289, 290, 291, 292, 293, -1, 295, 296, 271, |
|
-1, 273, 274, 275, -1, 277, -1, 279, -1, 309, |
|
308, -1, 284, -1, 286, 287, 288, 289, 290, 291, |
|
292, 293, 271, 295, 296, -1, 275, -1, 277, -1, |
|
279, -1, -1, -1, -1, 284, 308, 286, 287, 288, |
|
289, 290, 291, 292, 293, 271, 295, 296, 271, 275, |
|
-1, 277, 275, -1, 277, -1, -1, -1, 284, 308, |
|
286, 287, 288, 289, 290, 291, 292, 293, -1, 295, |
|
296, 271, 295, 296, 271, 275, -1, 277, 275, -1, |
|
277, -1, 308, -1, -1, 308, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, 296, -1, -1, 296, |
|
-1, -1, -1, -1, -1, -1, -1, -1, 308, -1, |
|
-1, 308, |
|
}; | }; |
#define YYFINAL 2 |
|
#ifndef YYDEBUG |
#define yyerrok (yyerrstatus = 0) |
#define YYDEBUG 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 |
#define YYMAXTOKEN 315 |
|
#if YYDEBUG |
|
const char * const CQL_name[] = { |
|
"end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"IDENTIFIER","STRING_LITERAL", |
|
"BINARY","NEGATIVE_BINARY","HEXADECIMAL","NEGATIVE_HEXADECIMAL","INTEGER", |
|
"NEGATIVE_INTEGER","REAL","NEGATIVE_REAL","_TRUE","_FALSE","SCOPED_PROPERTY", |
|
"LPAR","RPAR","HASH","DOT","LBRKT","RBRKT","UNDERSCORE","COMMA","CONCAT", |
|
"DBL_PIPE","PLUS","MINUS","TIMES","DIV","IS","_NULL","_EQ","_NE","_GT","_LT", |
|
"_GE","_LE","_ISA","_LIKE","NOT","_AND","_OR","SCOPE","ANY","EVERY","IN", |
|
"SATISFIES","STAR","DOTDOT","SHARP","DISTINCT","SELECT","FIRST","FROM","WHERE", |
|
"ORDER","BY","ASC","DESC","AS","UNEXPECTED_CHAR", |
|
}; |
|
const char * const CQL_rule[] = { |
|
"$accept : select_statement", |
|
"identifier : IDENTIFIER", |
|
"class_name : identifier", |
|
"class_path : class_name", |
|
"scoped_property : SCOPED_PROPERTY", |
|
"literal_string : STRING_LITERAL", |
|
"binary_value : BINARY", |
|
"binary_value : NEGATIVE_BINARY", |
|
"hex_value : HEXADECIMAL", |
|
"hex_value : NEGATIVE_HEXADECIMAL", |
|
"decimal_value : INTEGER", |
|
"decimal_value : NEGATIVE_INTEGER", |
|
"real_value : REAL", |
|
"real_value : NEGATIVE_REAL", |
|
"literal : literal_string", |
|
"literal : decimal_value", |
|
"literal : binary_value", |
|
"literal : hex_value", |
|
"literal : real_value", |
|
"literal : _TRUE", |
|
"literal : _FALSE", |
|
"array_index : expr", |
|
"array_index_list : array_index", |
|
"chain : literal", |
|
"chain : LPAR expr RPAR", |
|
"chain : identifier", |
|
"chain : identifier HASH literal_string", |
|
"chain : scoped_property", |
|
"chain : identifier LPAR arg_list RPAR", |
|
"chain : chain DOT scoped_property", |
|
"chain : chain DOT identifier", |
|
"chain : chain DOT identifier HASH literal_string", |
|
"chain : chain LBRKT array_index_list RBRKT", |
|
"concat : chain", |
|
"concat : concat DBL_PIPE literal_string", |
|
"factor : concat", |
|
"term : factor", |
|
"arith : term", |
|
"value_symbol : HASH literal_string", |
|
"arith_or_value_symbol : arith", |
|
"arith_or_value_symbol : value_symbol", |
|
"comp_op : _EQ", |
|
"comp_op : _NE", |
|
"comp_op : _GT", |
|
"comp_op : _LT", |
|
"comp_op : _GE", |
|
"comp_op : _LE", |
|
"comp : arith", |
|
"comp : arith IS NOT _NULL", |
|
"comp : arith IS _NULL", |
|
"comp : arith comp_op arith_or_value_symbol", |
|
"comp : value_symbol comp_op arith", |
|
"comp : arith _ISA identifier", |
|
"comp : arith _LIKE literal_string", |
|
"expr_factor : comp", |
|
"expr_factor : NOT comp", |
|
"expr_term : expr_factor", |
|
"expr_term : expr_term _AND expr_factor", |
|
"expr : expr_term", |
|
"expr : expr _OR expr_term", |
|
"arg_list :", |
|
"arg_list : expr", |
|
"from_specifier : class_path", |
|
"from_specifier : class_path AS identifier", |
|
"from_specifier : class_path identifier", |
|
"from_criteria : from_specifier", |
|
"star_expr : STAR", |
|
"star_expr : chain DOT STAR", |
|
"selected_entry : expr", |
|
"selected_entry : star_expr", |
|
"select_list : selected_entry select_list_tail", |
|
"select_list_tail :", |
|
"select_list_tail : COMMA selected_entry select_list_tail", |
|
"search_condition : expr", |
|
"optional_where :", |
|
"optional_where : WHERE search_condition", |
|
"select_statement : SELECT select_list FROM from_criteria optional_where", |
|
}; |
|
#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 |
#include <stdio.h> |
|
|
# ifndef YYFPRINTF |
|
# include <stdio.h> /* INFRINGES ON USER NAME SPACE */ |
|
# define YYFPRINTF fprintf |
#endif | #endif |
#ifdef YYSTACKSIZE |
|
#undef YYMAXDEPTH |
# define YYDPRINTF(Args) \ |
#define YYMAXDEPTH YYSTACKSIZE |
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 | #else |
#ifdef YYMAXDEPTH |
static void |
#define YYSTACKSIZE YYMAXDEPTH |
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 | #else |
#define YYSTACKSIZE 10000 |
YYUSE (yyoutput); |
#define YYMAXDEPTH 10000 |
|
#endif | #endif |
|
switch (yytype) |
|
{ |
|
default: |
|
break; |
|
} |
|
} |
|
|
|
|
|
/*--------------------------------. |
|
| 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 |
#define YYINITSTACKSIZE 200 |
{ |
int yydebug; |
if (yytype < YYNTOKENS) |
int yynerrs; |
YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); |
int yyerrflag; |
else |
int yychar; |
YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); |
short *yyssp; |
|
YYSTYPE *yyvsp; |
|
YYSTYPE yyval; |
|
YYSTYPE yylval; |
|
short *yyss; |
|
short *yysslim; |
|
YYSTYPE *yyvs; |
|
int yystacksize; |
|
#line 1372 "CQL.y" |
|
| |
/*int yyerror(char * err){yyclearin; yyerrok;throw Exception(String(err));return 1;}*/ |
yy_symbol_value_print (yyoutput, yytype, yyvaluep); |
#line 502 "y.tab.c" |
YYFPRINTF (yyoutput, ")"); |
/* allocate initial stack or double stack size, up to YYMAXDEPTH */ |
|
static int yygrowstack() |
|
{ |
|
int newsize, i; |
|
short *newss; |
|
YYSTYPE *newvs; |
|
|
|
if ((newsize = yystacksize) == 0) |
|
newsize = YYINITSTACKSIZE; |
|
else if (newsize >= YYMAXDEPTH) |
|
return -1; |
|
else if ((newsize *= 2) > YYMAXDEPTH) |
|
newsize = YYMAXDEPTH; |
|
i = yyssp - yyss; |
|
newss = yyss ? (short *)realloc(yyss, newsize * sizeof *newss) : |
|
(short *)malloc(newsize * sizeof *newss); |
|
if (newss == NULL) |
|
return -1; |
|
yyss = newss; |
|
yyssp = newss + i; |
|
newvs = yyvs ? (YYSTYPE *)realloc(yyvs, newsize * sizeof *newvs) : |
|
(YYSTYPE *)malloc(newsize * sizeof *newvs); |
|
if (newvs == NULL) |
|
return -1; |
|
yyvs = newvs; |
|
yyvsp = newvs + i; |
|
yystacksize = newsize; |
|
yysslim = yyss + newsize - 1; |
|
return 0; |
|
} | } |
| |
#define YYABORT goto yyabort |
/*------------------------------------------------------------------. |
#define YYREJECT goto yyabort |
| yy_stack_print -- Print the state stack from its BOTTOM up to its | |
#define YYACCEPT goto yyaccept |
| TOP (included). | |
#define YYERROR goto yyerrlab |
`------------------------------------------------------------------*/ |
|
|
#ifndef YYPARSE_PARAM |
|
#if defined(__cplusplus) || __STDC__ |
|
#define YYPARSE_PARAM_ARG void |
|
#define YYPARSE_PARAM_DECL |
|
#else /* ! ANSI-C/C++ */ |
|
#define YYPARSE_PARAM_ARG |
|
#define YYPARSE_PARAM_DECL |
|
#endif /* ANSI-C/C++ */ |
|
#else /* YYPARSE_PARAM */ |
|
#ifndef YYPARSE_PARAM_TYPE |
|
#define YYPARSE_PARAM_TYPE void * |
|
#endif |
|
#if defined(__cplusplus) || __STDC__ |
|
#define YYPARSE_PARAM_ARG YYPARSE_PARAM_TYPE YYPARSE_PARAM |
|
#define YYPARSE_PARAM_DECL |
|
#else /* ! ANSI-C/C++ */ |
|
#define YYPARSE_PARAM_ARG YYPARSE_PARAM |
|
#define YYPARSE_PARAM_DECL YYPARSE_PARAM_TYPE YYPARSE_PARAM; |
|
#endif /* ANSI-C/C++ */ |
|
#endif /* ! YYPARSE_PARAM */ |
|
| |
int |
#if (defined __STDC__ || defined __C99__FUNC__ \ |
yyparse (YYPARSE_PARAM_ARG) |
|| defined __cplusplus || defined _MSC_VER) |
YYPARSE_PARAM_DECL |
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 |
{ | { |
register int yym, yyn, yystate; |
YYFPRINTF (stderr, "Stack now"); |
#if YYDEBUG |
for (; bottom <= top; ++bottom) |
register const char *yys; |
YYFPRINTF (stderr, " %d", *bottom); |
|
YYFPRINTF (stderr, "\n"); |
if ((yys = getenv("YYDEBUG"))) |
} |
|
|
|
# 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 |
{ | { |
yyn = *yys; |
int yynrhs = yyr2[yyrule]; |
if (yyn >= '0' && yyn <= '9') |
int yyi; |
yydebug = yyn - '0'; |
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"); |
} | } |
|
} |
|
|
|
# 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 | #endif |
| |
yynerrs = 0; |
/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only |
yyerrflag = 0; |
if the built-in stack extension method is used). |
yychar = (-1); |
|
|
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 (yyss == NULL && yygrowstack()) goto yyoverflow; |
|
yyssp = yyss; |
|
yyvsp = yyvs; |
|
*yyssp = yystate = 0; |
|
| |
yyloop: |
|
if ((yyn = yydefred[yystate])) goto yyreduce; |
#if YYERROR_VERBOSE |
if (yychar < 0) |
|
|
# 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 |
{ | { |
if ((yychar = yylex()) < 0) yychar = 0; |
YYSIZE_T yylen; |
#if YYDEBUG |
for (yylen = 0; yystr[yylen]; yylen++) |
if (yydebug) |
continue; |
|
return yylen; |
|
} |
|
# endif |
|
# 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. */ |
|
#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 |
{ | { |
yys = 0; |
char *yyd = yydest; |
if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; |
const char *yys = yysrc; |
if (!yys) yys = "illegal-symbol"; |
|
printf("%sdebug: state %d, reading %d (%s)\n", |
while ((*yyd++ = *yys++) != '\0') |
YYPREFIX, yystate, yychar, yys); |
continue; |
|
|
|
return yyd - 1; |
} | } |
#endif | #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 == '"') |
|
{ |
|
YYSIZE_T yyn = 0; |
|
char const *yyp = yystr; |
|
|
|
for (;;) |
|
switch (*++yyp) |
|
{ |
|
case '\'': |
|
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 ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 && |
|
yyn <= YYTABLESIZE && yycheck[yyn] == yychar) |
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, shifting to state %d\n", |
if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) |
YYPREFIX, yystate, 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 >= yysslim && yygrowstack()) |
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; |
yychar = (-1); |
|
if (yyerrflag > 0) --yyerrflag; |
|
goto yyloop; |
|
} | } |
if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 && |
else |
yyn <= YYTABLESIZE && yycheck[yyn] == yychar) |
|
{ | { |
yyn = yytable[yyn]; |
yyp++; |
goto yyreduce; |
yyf++; |
} | } |
if (yyerrflag) goto yyinrecovery; |
} |
#if defined(lint) || defined(__GNUC__) |
} |
goto yynewerror; |
return yysize; |
#endif |
} |
yynewerror: |
} |
yyerror("syntax error"); |
#endif /* YYERROR_VERBOSE */ |
#if defined(lint) || defined(__GNUC__) |
|
goto yyerrlab; |
|
|
/*-----------------------------------------------. |
|
| 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 | #endif |
yyerrlab: |
|
++yynerrs; |
|
yyinrecovery: |
|
if (yyerrflag < 3) |
|
{ | { |
yyerrflag = 3; |
YYUSE (yyvaluep); |
for (;;) |
|
|
if (!yymsg) |
|
yymsg = "Deleting"; |
|
YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); |
|
|
|
switch (yytype) |
{ | { |
if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 && |
|
yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE) |
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 |
{ | { |
#if YYDEBUG |
|
if (yydebug) |
int yystate; |
printf("%sdebug: state %d, error recovery shifting\ |
int yyn; |
to state %d\n", YYPREFIX, *yyssp, yytable[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 | #endif |
if (yyssp >= yysslim && yygrowstack()) |
|
|
/* 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) |
{ | { |
goto yyoverflow; |
/* 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; |
} | } |
*++yyssp = yystate = yytable[yyn]; |
#else /* no yyoverflow */ |
*++yyvsp = yylval; |
# ifndef YYSTACK_RELOCATE |
goto yyloop; |
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); |
} | } |
else |
# endif |
{ |
#endif /* no yyoverflow */ |
#if YYDEBUG |
|
if (yydebug) |
yyssp = yyss + yysize - 1; |
printf("%sdebug: error recovery discarding state %d\n", |
yyvsp = yyvs + yysize - 1; |
YYPREFIX, *yyssp); |
|
#endif |
|
if (yyssp <= yyss) goto yyabort; |
YYDPRINTF ((stderr, "Stack size increased to %lu\n", |
--yyssp; |
(unsigned long int) yystacksize)); |
--yyvsp; |
|
|
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 247 "CQL.y" |
#line 296 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "identifier"; |
CQLTRACE("identifier"); |
sprintf(msg,"BISON::identifier\n"); |
|
printf_(msg); |
|
if(isUTF8Str(CQL_lval.strValue)){ |
if(isUTF8Str(CQL_lval.strValue)) |
yyval._identifier = new CQLIdentifier(String(CQL_lval.strValue)); |
{ |
_ObjPtr._ptr = yyval._identifier; |
(yyval._identifier) = new CQLIdentifier(String(CQL_lval.strValue)); |
|
_ObjPtr._ptr = (yyval._identifier); |
_ObjPtr.type = Id; | _ObjPtr.type = Id; |
_ptrs.append(_ObjPtr); | _ptrs.append(_ObjPtr); |
}else{ |
|
sprintf(msg,"BISON::identifier-> BAD UTF\n"); |
|
printf_(msg); |
|
throw CQLSyntaxErrorException( |
|
MessageLoaderParms(String("CQL.CQL_y.BAD_UTF8"), |
|
String("Bad UTF8 encountered parsing rule $0 in position $1."), |
|
String("identifier"), |
|
CQL_globalParserState->currentTokenPos) |
|
); |
|
} | } |
} |
else |
break; |
|
case 2: |
|
#line 270 "CQL.y" |
|
{ | { |
CQL_globalParserState->currentRule = "class_name"; |
sprintf(msg,"BISON::identifier-> BAD UTF\n"); |
sprintf(msg,"BISON::class_name = %s\n", (const char *)(yyvsp[0]._identifier->getName().getString().getCString())); |
|
printf_(msg); | printf_(msg); |
yyval._identifier = yyvsp[0]._identifier; |
CQLTRACEMSG("identifier", "BAD UTF"); |
|
|
|
throw CQLSyntaxErrorException( |
|
MessageLoaderParms("CQL.CQL_y.BAD_UTF8", |
|
"Bad UTF8 encountered parsing rule $0" |
|
" in position $1.", |
|
"identifier", |
|
CQL_globalParserState->currentTokenPos) ); |
} | } |
|
;} |
break; | break; |
|
|
case 3: | case 3: |
#line 279 "CQL.y" |
#line 324 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "class_path"; |
|
sprintf(msg,"BISON::class_path\n"); |
CQLTRACE2("class_name",(const char *)((yyvsp[(1) - (1)]._identifier)->getName().getString().getCString()) ); |
printf_(msg); |
(yyval._identifier) = (yyvsp[(1) - (1)]._identifier); |
yyval._identifier = yyvsp[0]._identifier; |
;} |
} |
|
break; | break; |
|
|
case 4: | case 4: |
#line 298 "CQL.y" |
#line 332 "CQL.y" |
|
{ |
|
CQLTRACE("class_path"); |
|
|
|
(yyval._identifier) = (yyvsp[(1) - (1)]._identifier); |
|
;} |
|
break; |
|
|
|
case 5: |
|
#line 349 "CQL.y" |
{ | { |
/* | /* |
SCOPED_PROPERTY can be: |
TOK_SCOPED_PROPERTY can be: |
- "A::prop" | - "A::prop" |
- "A::class.prop" | - "A::class.prop" |
- "A::class.prop#'OK' | - "A::class.prop#'OK' |
- "A::class.prop[4]" | - "A::class.prop[4]" |
*/ | */ |
CQL_globalParserState->currentRule = "scoped_property"; |
CQLTRACE2("scoped_property",CQL_lval.strValue ); |
sprintf(msg,"BISON::scoped_property = %s\n",CQL_lval.strValue); |
|
printf_(msg); |
if(isUTF8Str(CQL_lval.strValue)) |
if(isUTF8Str(CQL_lval.strValue)){ |
{ |
String tmp(CQL_lval.strValue); | String tmp(CQL_lval.strValue); |
yyval._identifier = new CQLIdentifier(tmp); |
(yyval._identifier) = new CQLIdentifier(tmp); |
_ObjPtr._ptr = yyval._identifier; |
_ObjPtr._ptr = (yyval._identifier); |
_ObjPtr.type = Id; | _ObjPtr.type = Id; |
_ptrs.append(_ObjPtr); | _ptrs.append(_ObjPtr); |
| |
}else{ |
} |
|
else |
|
{ |
sprintf(msg,"BISON::scoped_property-> BAD UTF\n"); | sprintf(msg,"BISON::scoped_property-> BAD UTF\n"); |
printf_(msg); | printf_(msg); |
throw CQLSyntaxErrorException( | throw CQLSyntaxErrorException( |
MessageLoaderParms(String("CQL.CQL_y.BAD_UTF8"), |
MessageLoaderParms("CQL.CQL_y.BAD_UTF8", |
String("Bad UTF8 encountered parsing rule $0 in position $1."), |
"Bad UTF8 encountered parsing rule $0 in position $1.", |
String("scoped_property"), |
"scoped_property", |
CQL_globalParserState->currentTokenPos) |
CQL_globalParserState->currentTokenPos) ); |
); |
|
} |
|
} | } |
|
;} |
break; | break; |
case 5: |
|
#line 331 "CQL.y" |
case 6: |
|
#line 383 "CQL.y" |
{ | { |
/* | /* |
We make sure the literal is valid UTF8, then make a String | We make sure the literal is valid UTF8, then make a String |
*/ | */ |
CQL_globalParserState->currentRule = "literal_string"; |
CQLTRACE2("literal_string",CQL_lval.strValue ); |
sprintf(msg,"BISON::literal_string-> %s\n",CQL_lval.strValue); |
|
printf_(msg); |
|
| |
if(isUTF8Str(CQL_lval.strValue)){ |
if(isUTF8Str(CQL_lval.strValue)) |
yyval._string = new String(CQL_lval.strValue); |
{ |
_ObjPtr._ptr = yyval._string; |
(yyval._string) = new String(CQL_lval.strValue); |
|
_ObjPtr._ptr = (yyval._string); |
_ObjPtr.type = Str; | _ObjPtr.type = Str; |
_ptrs.append(_ObjPtr); | _ptrs.append(_ObjPtr); |
}else{ |
|
sprintf(msg,"BISON::literal_string-> BAD UTF\n"); |
|
printf_(msg); |
|
throw CQLSyntaxErrorException( |
|
MessageLoaderParms(String("CQL.CQL_y.BAD_UTF8"), |
|
String("Bad UTF8 encountered parsing rule $0 in position $1."), |
|
String("literal_string"), |
|
CQL_globalParserState->currentTokenPos) |
|
); |
|
} | } |
} |
else |
break; |
|
case 6: |
|
#line 359 "CQL.y" |
|
{ | { |
CQL_globalParserState->currentRule = "binary_value->BINARY"; |
sprintf(msg,"BISON::literal_string-> BAD UTF\n"); |
sprintf(msg,"BISON::binary_value-> %s\n",CQL_lval.strValue); |
|
printf_(msg); | printf_(msg); |
|
CQLTRACEMSG("literal_string", "BAD UTF"); |
| |
yyval._value = new CQLValue(CQL_lval.strValue, CQLValue::Binary); |
throw CQLSyntaxErrorException( |
_ObjPtr._ptr = yyval._value; |
MessageLoaderParms("CQL.CQL_y.BAD_UTF8", |
_ObjPtr.type = Val; |
"Bad UTF8 encountered parsing rule $0 in position $1.", |
_ptrs.append(_ObjPtr); |
"literal_string", |
|
CQL_globalParserState->currentTokenPos)); |
} | } |
|
;} |
break; | break; |
|
|
case 7: | case 7: |
#line 370 "CQL.y" |
#line 413 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "binary_value->NEGATIVE_BINARY"; |
CQLTRACE2("binary_value->TOK_BINARY", CQL_lval.strValue); |
sprintf(msg,"BISON::binary_value-> %s\n",CQL_lval.strValue); |
|
printf_(msg); |
|
| |
yyval._value = new CQLValue(CQL_lval.strValue, CQLValue::Binary, false); |
(yyval._value) = new CQLValue(CQL_lval.strValue, CQLValue::Binary); |
_ObjPtr._ptr = yyval._value; |
_ObjPtr._ptr = (yyval._value); |
_ObjPtr.type = Val; | _ObjPtr.type = Val; |
_ptrs.append(_ObjPtr); | _ptrs.append(_ObjPtr); |
} |
;} |
break; | break; |
|
|
case 8: | case 8: |
#line 384 "CQL.y" |
#line 422 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "hex_value->HEXADECIMAL"; |
|
sprintf(msg,"BISON::hex_value-> %s\n",CQL_lval.strValue); |
|
printf_(msg); | printf_(msg); |
| |
yyval._value = new CQLValue(CQL_lval.strValue, CQLValue::Hex); |
CQLTRACE2("binary_value->TOK_NEGATIVE_BINARY", CQL_lval.strValue); |
_ObjPtr._ptr = yyval._value; |
|
|
(yyval._value) = new CQLValue(CQL_lval.strValue, CQLValue::Binary, false); |
|
_ObjPtr._ptr = (yyval._value); |
_ObjPtr.type = Val; | _ObjPtr.type = Val; |
_ptrs.append(_ObjPtr); | _ptrs.append(_ObjPtr); |
} |
;} |
break; | break; |
|
|
case 9: | case 9: |
#line 395 "CQL.y" |
#line 436 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "hex_value->NEGATIVE_HEXADECIMAL"; |
CQLTRACE2("hex_value->TOK_HEXADECIMAL", CQL_lval.strValue); |
sprintf(msg,"BISON::hex_value-> %s\n",CQL_lval.strValue); |
|
printf_(msg); |
|
| |
yyval._value = new CQLValue(CQL_lval.strValue, CQLValue::Hex, false); |
(yyval._value) = new CQLValue(CQL_lval.strValue, CQLValue::Hex); |
_ObjPtr._ptr = yyval._value; |
_ObjPtr._ptr = (yyval._value); |
_ObjPtr.type = Val; | _ObjPtr.type = Val; |
_ptrs.append(_ObjPtr); | _ptrs.append(_ObjPtr); |
} |
;} |
break; | break; |
|
|
case 10: | case 10: |
#line 409 "CQL.y" |
#line 445 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "decimal_value->INTEGER"; |
CQLTRACE2("hex_value->TOK_NEGATIVE_HEXADECIMAL", CQL_lval.strValue); |
sprintf(msg,"BISON::decimal_value-> %s\n",CQL_lval.strValue); |
|
printf_(msg); |
|
| |
yyval._value = new CQLValue(CQL_lval.strValue, CQLValue::Decimal); |
(yyval._value) = new CQLValue(CQL_lval.strValue, CQLValue::Hex, false); |
_ObjPtr._ptr = yyval._value; |
_ObjPtr._ptr = (yyval._value); |
_ObjPtr.type = Val; | _ObjPtr.type = Val; |
_ptrs.append(_ObjPtr); | _ptrs.append(_ObjPtr); |
} |
;} |
break; | break; |
|
|
case 11: | case 11: |
#line 420 "CQL.y" |
#line 457 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "decimal_value->NEGATIVE_INTEGER"; |
CQLTRACE2("decimal_value->TOK_INTEGER", CQL_lval.strValue); |
sprintf(msg,"BISON::decimal_value-> %s\n",CQL_lval.strValue); |
|
printf_(msg); |
|
| |
yyval._value = new CQLValue(CQL_lval.strValue, CQLValue::Decimal, false); |
(yyval._value) = new CQLValue(CQL_lval.strValue, CQLValue::Decimal); |
_ObjPtr._ptr = yyval._value; |
_ObjPtr._ptr = (yyval._value); |
_ObjPtr.type = Val; | _ObjPtr.type = Val; |
_ptrs.append(_ObjPtr); | _ptrs.append(_ObjPtr); |
} |
;} |
break; | break; |
|
|
case 12: | case 12: |
#line 434 "CQL.y" |
#line 466 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "real_value->REAL"; |
CQLTRACE2("decimal_value->TOK_NEGATIVE_INTEGER", CQL_lval.strValue); |
sprintf(msg,"BISON::real_value-> %s\n",CQL_lval.strValue); |
|
printf_(msg); |
(yyval._value) = new CQLValue(CQL_lval.strValue, CQLValue::Decimal, false); |
yyval._value = new CQLValue(CQL_lval.strValue, CQLValue::Real); |
_ObjPtr._ptr = (yyval._value); |
_ObjPtr._ptr = yyval._value; |
|
_ObjPtr.type = Val; | _ObjPtr.type = Val; |
_ptrs.append(_ObjPtr); | _ptrs.append(_ObjPtr); |
} |
;} |
break; | break; |
|
|
case 13: | case 13: |
#line 444 "CQL.y" |
#line 478 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "real_value->NEGATIVE_REAL"; |
CQLTRACE2("real_value->TOK_REAL", CQL_lval.strValue); |
sprintf(msg,"BISON::real_value-> %s\n",CQL_lval.strValue); |
|
printf_(msg); |
(yyval._value) = new CQLValue(CQL_lval.strValue, CQLValue::Real); |
yyval._value = new CQLValue(CQL_lval.strValue, CQLValue::Real, false); |
_ObjPtr._ptr = (yyval._value); |
_ObjPtr._ptr = yyval._value; |
|
_ObjPtr.type = Val; | _ObjPtr.type = Val; |
_ptrs.append(_ObjPtr); | _ptrs.append(_ObjPtr); |
} |
;} |
break; | break; |
|
|
case 14: | case 14: |
#line 457 "CQL.y" |
#line 487 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "literal->literal_string"; |
CQLTRACE2("real_value->TOK_NEGATIVE_REAL", CQL_lval.strValue); |
sprintf(msg,"BISON::literal->literal_string\n"); |
|
printf_(msg); |
(yyval._value) = new CQLValue(CQL_lval.strValue, CQLValue::Real, false); |
yyval._value = new CQLValue(*yyvsp[0]._string); |
_ObjPtr._ptr = (yyval._value); |
_ObjPtr._ptr = yyval._value; |
|
_ObjPtr.type = Val; | _ObjPtr.type = Val; |
_ptrs.append(_ObjPtr); | _ptrs.append(_ObjPtr); |
} |
;} |
break; | break; |
|
|
case 15: | case 15: |
#line 467 "CQL.y" |
#line 499 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "literal->decimal_value"; |
(yyval._value) = new CQLValue(*(yyvsp[(1) - (1)]._string)); |
sprintf(msg,"BISON::literal->decimal_value\n"); |
_ObjPtr._ptr = (yyval._value); |
printf_(msg); |
_ObjPtr.type = Val; |
|
_ptrs.append(_ObjPtr); |
} |
;} |
break; | break; |
|
|
case 16: | case 16: |
#line 474 "CQL.y" |
#line 506 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "literal->binary_value"; |
CQLTRACE("literal->decimal_value"); |
sprintf(msg,"BISON::literal->binary_value\n"); |
;} |
printf_(msg); |
|
|
|
} |
|
break; | break; |
|
|
case 17: | case 17: |
#line 481 "CQL.y" |
#line 510 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "literal->hex_value"; |
CQLTRACE("literal->binary_value"); |
sprintf(msg,"BISON::literal->hex_value\n"); |
;} |
printf_(msg); |
|
|
|
} |
|
break; | break; |
|
|
case 18: | case 18: |
#line 488 "CQL.y" |
#line 514 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "literal->real_value"; |
CQLTRACE("literal->hex_value"); |
sprintf(msg,"BISON::literal->real_value\n"); |
;} |
printf_(msg); |
|
|
|
} |
|
break; | break; |
|
|
case 19: | case 19: |
#line 495 "CQL.y" |
#line 518 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "literal->_TRUE"; |
CQLTRACE("literal->real_value"); |
sprintf(msg,"BISON::literal->_TRUE\n"); |
;} |
printf_(msg); |
|
|
|
yyval._value = new CQLValue(Boolean(true)); |
|
_ObjPtr._ptr = yyval._value; |
|
_ObjPtr.type = Val; |
|
_ptrs.append(_ObjPtr); |
|
} |
|
break; | break; |
|
|
case 20: | case 20: |
#line 506 "CQL.y" |
#line 522 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "literal->_FALSE"; |
CQLTRACE("literal->TOK_TRUE"); |
sprintf(msg,"BISON::literal->_FALSE\n"); |
|
printf_(msg); |
|
| |
yyval._value = new CQLValue(Boolean(false)); |
(yyval._value) = new CQLValue(Boolean(true)); |
_ObjPtr._ptr = yyval._value; |
_ObjPtr._ptr = (yyval._value); |
_ObjPtr.type = Val; | _ObjPtr.type = Val; |
_ptrs.append(_ObjPtr); | _ptrs.append(_ObjPtr); |
} |
;} |
break; | break; |
|
|
case 21: | case 21: |
#line 520 "CQL.y" |
#line 531 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "array_index->expr"; |
CQLTRACE("literal->TOK_FALSE"); |
sprintf(msg,"BISON::array_index->expr\n"); |
|
printf_(msg); |
|
| |
CQLValue* _val = (CQLValue*)_factory.getObject(yyvsp[0]._predicate,Predicate,Value); |
(yyval._value) = new CQLValue(Boolean(false)); |
yyval._string = new String(_val->toString()); |
_ObjPtr._ptr = (yyval._value); |
_ObjPtr._ptr = yyval._string; |
_ObjPtr.type = Val; |
_ObjPtr.type = Str; |
|
_ptrs.append(_ObjPtr); | _ptrs.append(_ObjPtr); |
} |
;} |
break; | break; |
|
|
case 22: | case 22: |
#line 535 "CQL.y" |
#line 543 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "array_index_list->array_index"; |
CQLTRACE("array_index->expr"); |
sprintf(msg,"BISON::array_index_list->array_index\n"); |
|
printf_(msg); |
CQLValue* _val = (CQLValue*)_factory.getObject((yyvsp[(1) - (1)]._predicate),Predicate,Value); |
yyval._string = yyvsp[0]._string; |
(yyval._string) = new String(_val->toString()); |
} |
_ObjPtr._ptr = (yyval._string); |
|
_ObjPtr.type = Str; |
|
_ptrs.append(_ObjPtr); |
|
;} |
break; | break; |
|
|
case 23: | case 23: |
#line 545 "CQL.y" |
#line 556 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "chain->literal"; |
CQLTRACE("array_index_list->array_index"); |
sprintf(msg,"BISON::chain->literal\n"); |
|
printf_(msg); |
|
| |
chain_state = CQLVALUE; |
(yyval._string) = (yyvsp[(1) - (1)]._string); |
yyval._node = _factory.makeObject(yyvsp[0]._value,Predicate); |
;} |
} |
|
break; | break; |
|
|
case 24: | case 24: |
#line 554 "CQL.y" |
#line 565 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "chain-> ( expr )"; |
CQLTRACE("chain->literal"); |
sprintf(msg,"BISON::chain-> ( expr )\n"); |
|
printf_(msg); |
|
| |
chain_state = CQLPREDICATE; |
chain_state = CQLVALUE; |
yyval._node = yyvsp[-1]._predicate; |
(yyval._node) = _factory.makeObject((yyvsp[(1) - (1)]._value),Predicate); |
} |
;} |
break; | break; |
|
|
case 25: | case 25: |
#line 563 "CQL.y" |
#line 572 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "chain->identifier"; |
CQLTRACE("chain-> ( expr )"); |
sprintf(msg,"BISON::chain->identifier\n"); |
chain_state = CQLPREDICATE; |
printf_(msg); |
(yyval._node) = (yyvsp[(2) - (3)]._predicate); |
|
;} |
chain_state = CQLIDENTIFIER; |
|
yyval._node = _factory.makeObject(yyvsp[0]._identifier,Predicate); |
|
} |
|
break; | break; |
|
|
case 26: | case 26: |
#line 572 "CQL.y" |
#line 578 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "chain->identifier#literal_string"; |
CQLTRACE("chain->identifier"); |
sprintf(msg,"BISON::chain->identifier#literal_string\n"); |
|
printf_(msg); |
|
| |
String tmp = yyvsp[-2]._identifier->getName().getString(); |
|
tmp.append("#").append(*yyvsp[0]._string); |
|
CQLIdentifier _id(tmp); |
|
yyval._node = _factory.makeObject(&_id,Predicate); |
|
chain_state = CQLIDENTIFIER; | chain_state = CQLIDENTIFIER; |
} |
(yyval._node) = _factory.makeObject((yyvsp[(1) - (1)]._identifier),Predicate); |
|
;} |
break; | break; |
|
|
case 27: | case 27: |
#line 584 "CQL.y" |
#line 585 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "chain->scoped_property"; |
CQLTRACE("chain->identifier#literal_string"); |
sprintf(msg,"BISON::chain-> scoped_property\n"); |
|
printf_(msg); |
|
| |
|
String tmp = (yyvsp[(1) - (3)]._identifier)->getName().getString(); |
|
tmp.append("#").append(*(yyvsp[(3) - (3)]._string)); |
|
CQLIdentifier _id(tmp); |
|
(yyval._node) = _factory.makeObject(&_id,Predicate); |
chain_state = CQLIDENTIFIER; | chain_state = CQLIDENTIFIER; |
yyval._node = _factory.makeObject(yyvsp[0]._identifier,Predicate); |
;} |
} |
|
break; | break; |
|
|
case 28: | case 28: |
#line 593 "CQL.y" |
#line 595 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "chain->identifier( arg_list )"; |
CQLTRACE("chain->scoped_property"); |
sprintf(msg,"BISON::chain-> identifier( arg_list )\n"); |
|
printf_(msg); |
chain_state = CQLIDENTIFIER; |
|
(yyval._node) = _factory.makeObject((yyvsp[(1) - (1)]._identifier),Predicate); |
|
;} |
|
break; |
|
|
|
case 29: |
|
#line 602 "CQL.y" |
|
{ |
|
CQLTRACE("chain->identifier( arg_list )"); |
|
|
chain_state = CQLFUNCTION; | chain_state = CQLFUNCTION; |
CQLFunction _func(*yyvsp[-3]._identifier,_arglist); |
CQLFunction _func(*(yyvsp[(1) - (4)]._identifier),_arglist); |
yyval._node = (CQLPredicate*)(_factory.makeObject(&_func,Predicate)); |
(yyval._node) = (CQLPredicate*)(_factory.makeObject(&_func,Predicate)); |
_arglist.clear(); | _arglist.clear(); |
} |
;} |
break; | break; |
case 29: |
|
#line 603 "CQL.y" |
case 30: |
|
#line 611 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "chain->chain.scoped_property"; |
CQLTRACEDECIMAL("chain TOK_DOT scoped_property", chain_state); |
sprintf(msg,"BISON::chain-> chain DOT scoped_property : chain_state = %d\n",chain_state); |
|
printf_(msg); |
|
| |
CQLIdentifier *_id; | CQLIdentifier *_id; |
if(chain_state == CQLIDENTIFIER){ |
if(chain_state == CQLIDENTIFIER) |
_id = ((CQLIdentifier*)(_factory.getObject(yyvsp[-2]._node,Predicate,Identifier))); |
{ |
|
_id = ((CQLIdentifier*)(_factory.getObject( |
|
(yyvsp[(1) - (3)]._node),Predicate,Identifier))); |
CQLChainedIdentifier _cid(*_id); | CQLChainedIdentifier _cid(*_id); |
_cid.append(*yyvsp[0]._identifier); |
_cid.append(*(yyvsp[(3) - (3)]._identifier)); |
yyval._node = _factory.makeObject(&_cid,Predicate); |
(yyval._node) = _factory.makeObject(&_cid,Predicate); |
}else if(chain_state == CQLCHAINEDIDENTIFIER){ |
} |
|
else if(chain_state == CQLCHAINEDIDENTIFIER) |
|
{ |
CQLChainedIdentifier *_cid; | CQLChainedIdentifier *_cid; |
_cid = ((CQLChainedIdentifier*)(_factory.getObject(yyvsp[-2]._node,Predicate,ChainedIdentifier))); |
_cid = ((CQLChainedIdentifier*)(_factory.getObject( |
_cid->append(*yyvsp[0]._identifier); |
(yyvsp[(1) - (3)]._node),Predicate,ChainedIdentifier))); |
_factory.setObject(((CQLPredicate*)yyvsp[-2]._node),_cid,ChainedIdentifier); |
_cid->append(*(yyvsp[(3) - (3)]._identifier)); |
yyval._node = yyvsp[-2]._node; |
_factory.setObject(((CQLPredicate*)(yyvsp[(1) - (3)]._node)),_cid,ChainedIdentifier); |
}else{ |
(yyval._node) = (yyvsp[(1) - (3)]._node); |
|
} |
|
else |
|
{ |
/* error */ | /* error */ |
String _msg("chain-> chain DOT scoped_property : chain state not CQLIDENTIFIER or CQLCHAINEDIDENTIFIER"); |
String _msg("chain-> chain TOK_DOT scoped_property :" |
|
" chain state not CQLIDENTIFIER or CQLCHAINEDIDENTIFIER"); |
throw CQLSyntaxErrorException( | throw CQLSyntaxErrorException( |
MessageLoaderParms(String("CQL.CQL_y.NOT_CHAINID_OR_IDENTIFIER"), |
MessageLoaderParms("CQL.CQL_y.NOT_CHAINID_OR_IDENTIFIER", |
String("Chain state not a CQLIdentifier or a CQLChainedIdentifier while parsing rule $0 in position $1."), |
"Chain state not a CQLIdentifier or a" |
String("chain.scoped_property"), |
" CQLChainedIdentifier while parsing rule $0 in" |
CQL_globalParserState->currentTokenPos) |
" position $1.", |
); |
"chain.scoped_property", |
|
CQL_globalParserState->currentTokenPos)); |
} | } |
| |
chain_state = CQLCHAINEDIDENTIFIER; | chain_state = CQLCHAINEDIDENTIFIER; |
} |
;} |
break; | break; |
case 30: |
|
#line 634 "CQL.y" |
case 31: |
|
#line 649 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "chain->chain.identifier"; |
CQLTRACEDECIMAL("chain->chain.identifier", chain_state); |
sprintf(msg,"BISON::chain->chain.identifier : chain_state = %d\n",chain_state); |
|
printf_(msg); |
|
| |
if(chain_state == CQLIDENTIFIER){ |
if(chain_state == CQLIDENTIFIER) |
CQLIdentifier *_id = ((CQLIdentifier*)(_factory.getObject(yyvsp[-2]._node,Predicate,Identifier))); |
{ |
|
CQLIdentifier *_id = ((CQLIdentifier*)(_factory.getObject( |
|
(yyvsp[(1) - (3)]._node),Predicate,Identifier))); |
CQLChainedIdentifier _cid(*_id); | CQLChainedIdentifier _cid(*_id); |
_cid.append(*yyvsp[0]._identifier); |
_cid.append(*(yyvsp[(3) - (3)]._identifier)); |
yyval._node = _factory.makeObject(&_cid,Predicate); |
(yyval._node) = _factory.makeObject(&_cid,Predicate); |
}else if(chain_state == CQLCHAINEDIDENTIFIER){ |
} |
CQLChainedIdentifier *_cid = ((CQLChainedIdentifier*)(_factory.getObject(yyvsp[-2]._node,Predicate,ChainedIdentifier))); |
else if(chain_state == CQLCHAINEDIDENTIFIER) |
_cid->append(*yyvsp[0]._identifier); |
{ |
_factory.setObject(((CQLPredicate*)yyvsp[-2]._node),_cid,ChainedIdentifier); |
CQLChainedIdentifier *_cid = |
yyval._node = yyvsp[-2]._node; |
((CQLChainedIdentifier*)(_factory.getObject( |
}else{ |
(yyvsp[(1) - (3)]._node),Predicate,ChainedIdentifier))); |
|
_cid->append(*(yyvsp[(3) - (3)]._identifier)); |
|
_factory.setObject(((CQLPredicate*)(yyvsp[(1) - (3)]._node)),_cid,ChainedIdentifier); |
|
(yyval._node) = (yyvsp[(1) - (3)]._node); |
|
} |
|
else |
|
{ |
/* error */ | /* error */ |
String _msg("chain-> chain DOT identifier : chain state not CQLIDENTIFIER or CQLCHAINEDIDENTIFIER"); |
String _msg("chain-> chain TOK_DOT identifier : chain state not" |
|
" CQLIDENTIFIER or CQLCHAINEDIDENTIFIER"); |
throw CQLSyntaxErrorException( | throw CQLSyntaxErrorException( |
MessageLoaderParms(String("CQL.CQL_y.NOT_CHAINID_OR_IDENTIFIER"), |
MessageLoaderParms("CQL.CQL_y.NOT_CHAINID_OR_IDENTIFIER", |
String("Chain state not a CQLIdentifier or a CQLChainedIdentifier while parsing rule $0 in position $1."), |
"Chain state not a CQLIdentifier or a CQLChainedId" |
String("chain.identifier"), |
"Identifier while parsing rule $0 in position $1.", |
CQL_globalParserState->currentTokenPos) |
"chain.identifier", |
); |
CQL_globalParserState->currentTokenPos)); |
} | } |
chain_state = CQLCHAINEDIDENTIFIER; | chain_state = CQLCHAINEDIDENTIFIER; |
| |
} |
;} |
break; | break; |
case 31: |
|
#line 663 "CQL.y" |
case 32: |
|
#line 685 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "chain->chain.identifier#literal_string"; |
CQLTRACEDECIMAL("chain->chain.identifier#literal_string", chain_state); |
sprintf(msg,"BISON::chain->chain.identifier#literal_string : chain_state = %d\n",chain_state); |
|
printf_(msg); |
|
| |
if(chain_state == CQLIDENTIFIER){ |
if(chain_state == CQLIDENTIFIER) |
CQLIdentifier *_id = ((CQLIdentifier*)(_factory.getObject(yyvsp[-4]._node,Predicate,Identifier))); |
{ |
|
CQLIdentifier *_id = ((CQLIdentifier*)(_factory.getObject( |
|
(yyvsp[(1) - (5)]._node),Predicate,Identifier))); |
CQLChainedIdentifier _cid(*_id); | CQLChainedIdentifier _cid(*_id); |
String tmp(yyvsp[-2]._identifier->getName().getString()); |
String tmp((yyvsp[(3) - (5)]._identifier)->getName().getString()); |
tmp.append("#").append(*yyvsp[0]._string); |
tmp.append("#").append(*(yyvsp[(5) - (5)]._string)); |
CQLIdentifier _id1(tmp); | CQLIdentifier _id1(tmp); |
_cid.append(_id1); | _cid.append(_id1); |
_factory.setObject(((CQLPredicate*)yyvsp[-4]._node),&_cid,ChainedIdentifier); |
_factory.setObject(((CQLPredicate*)(yyvsp[(1) - (5)]._node)),&_cid,ChainedIdentifier); |
yyval._node = yyvsp[-4]._node; |
(yyval._node) = (yyvsp[(1) - (5)]._node); |
}else if(chain_state == CQLCHAINEDIDENTIFIER){ |
} |
CQLChainedIdentifier *_cid = ((CQLChainedIdentifier*)(_factory.getObject(yyvsp[-4]._node,Predicate,ChainedIdentifier))); |
else if(chain_state == CQLCHAINEDIDENTIFIER) |
String tmp(yyvsp[-2]._identifier->getName().getString()); |
{ |
tmp.append("#").append(*yyvsp[0]._string); |
CQLChainedIdentifier *_cid = ((CQLChainedIdentifier*)( |
|
_factory.getObject((yyvsp[(1) - (5)]._node),Predicate,ChainedIdentifier))); |
|
String tmp((yyvsp[(3) - (5)]._identifier)->getName().getString()); |
|
tmp.append("#").append(*(yyvsp[(5) - (5)]._string)); |
CQLIdentifier _id1(tmp); | CQLIdentifier _id1(tmp); |
_cid->append(_id1); | _cid->append(_id1); |
_factory.setObject(((CQLPredicate*)yyvsp[-4]._node),_cid,ChainedIdentifier); |
_factory.setObject(((CQLPredicate*)(yyvsp[(1) - (5)]._node)),_cid,ChainedIdentifier); |
yyval._node = yyvsp[-4]._node; |
(yyval._node) = (yyvsp[(1) - (5)]._node); |
}else{ |
} |
|
else |
|
{ |
/* error */ | /* error */ |
String _msg("chain->chain.identifier#literal_string : chain state not CQLIDENTIFIER or CQLCHAINEDIDENTIFIER"); |
String _msg("chain->chain.identifier#literal_string : chain" |
|
" state not CQLIDENTIFIER or CQLCHAINEDIDENTIFIER"); |
throw CQLSyntaxErrorException( | throw CQLSyntaxErrorException( |
MessageLoaderParms(String("CQL.CQL_y.NOT_CHAINID_OR_IDENTIFIER"), |
MessageLoaderParms("CQL.CQL_y.NOT_CHAINID_OR_IDENTIFIER", |
String("Chain state not a CQLIdentifier or a CQLChainedIdentifier while parsing rule $0 in position $1."), |
"Chain state not a CQLIdentifier or a CQLChained" |
String("chain.identifier#literal_string"), |
"Identifier while parsing rule $0 in position $1.", |
CQL_globalParserState->currentTokenPos) |
"chain.identifier#literal_string", |
); |
CQL_globalParserState->currentTokenPos) ); |
} | } |
| |
chain_state = CQLCHAINEDIDENTIFIER; | chain_state = CQLCHAINEDIDENTIFIER; |
| |
} |
;} |
break; | break; |
case 32: |
|
#line 700 "CQL.y" |
case 33: |
|
#line 728 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "chain->chain[ array_index_list ]"; |
CQLTRACEDECIMAL("chain->chain[ array_index_list ]", chain_state); |
sprintf(msg,"BISON::chain->chain[ array_index_list ] : chain_state = %d\n",chain_state); |
|
printf_(msg); |
|
| |
if(chain_state == CQLIDENTIFIER){ |
if(chain_state == CQLIDENTIFIER) |
CQLIdentifier *_id = ((CQLIdentifier*)(_factory.getObject(yyvsp[-3]._node,Predicate,Identifier))); |
{ |
|
CQLIdentifier *_id = ((CQLIdentifier*) |
|
(_factory.getObject((yyvsp[(1) - (4)]._node),Predicate,Identifier))); |
String tmp = _id->getName().getString(); | String tmp = _id->getName().getString(); |
tmp.append("[").append(*yyvsp[-1]._string).append("]"); |
tmp.append("[").append(*(yyvsp[(3) - (4)]._string)).append("]"); |
CQLIdentifier _id1(tmp); | CQLIdentifier _id1(tmp); |
CQLChainedIdentifier _cid(_id1); | CQLChainedIdentifier _cid(_id1); |
_factory.setObject(((CQLPredicate*)yyvsp[-3]._node),&_cid,ChainedIdentifier); |
_factory.setObject(((CQLPredicate*)(yyvsp[(1) - (4)]._node)),&_cid,ChainedIdentifier); |
yyval._node = yyvsp[-3]._node; |
(yyval._node) = (yyvsp[(1) - (4)]._node); |
}else if(chain_state == CQLCHAINEDIDENTIFIER || chain_state == CQLVALUE){ |
} |
CQLPredicate* _pred = (CQLPredicate*)yyvsp[-3]._node; |
else if(chain_state == CQLCHAINEDIDENTIFIER || chain_state == CQLVALUE) |
CQLChainedIdentifier *_cid = ((CQLChainedIdentifier*)(_factory.getObject(yyvsp[-3]._node,Predicate,ChainedIdentifier))); |
{ |
|
CQLPredicate* _pred = (CQLPredicate*)(yyvsp[(1) - (4)]._node); |
|
CQLChainedIdentifier *_cid = ((CQLChainedIdentifier*) |
|
(_factory.getObject |
|
((yyvsp[(1) - (4)]._node),Predicate,ChainedIdentifier))); |
CQLIdentifier tmpid = _cid->getLastIdentifier(); | CQLIdentifier tmpid = _cid->getLastIdentifier(); |
String tmp = tmpid.getName().getString(); | String tmp = tmpid.getName().getString(); |
tmp.append("[").append(*yyvsp[-1]._string).append("]"); |
tmp.append("[").append(*(yyvsp[(3) - (4)]._string)).append("]"); |
CQLIdentifier _id1(tmp); | CQLIdentifier _id1(tmp); |
CQLChainedIdentifier _tmpcid(_id1); | CQLChainedIdentifier _tmpcid(_id1); |
if(_cid->size() == 1){ |
if(_cid->size() == 1) |
|
{ |
_cid = &_tmpcid; | _cid = &_tmpcid; |
}else{ |
} |
|
else |
|
{ |
_cid->append(_id1); | _cid->append(_id1); |
} | } |
_factory.setObject(((CQLPredicate*)yyvsp[-3]._node),_cid,ChainedIdentifier); |
_factory.setObject(((CQLPredicate*)(yyvsp[(1) - (4)]._node)),_cid,ChainedIdentifier); |
yyval._node = yyvsp[-3]._node; |
(yyval._node) = (yyvsp[(1) - (4)]._node); |
}else{ |
} |
|
else |
|
{ |
/* error */ | /* error */ |
String _msg("chain->chain[ array_index_list ] : chain state not CQLIDENTIFIER or CQLCHAINEDIDENTIFIER or CQLVALUE"); |
String _msg("chain->chain[ array_index_list ] : chain state not" |
|
" CQLIDENTIFIER or CQLCHAINEDIDENTIFIER or CQLVALUE"); |
throw CQLSyntaxErrorException( | throw CQLSyntaxErrorException( |
MessageLoaderParms(String("CQL.CQL_y.NOT_CHAINID_OR_IDENTIFIER_OR_VALUE"), |
MessageLoaderParms( |
String("Chain state not a CQLIdentifier or a CQLChainedIdentifier or a CQLValue while parsing rule $0 in position $1."), |
"CQL.CQL_y.NOT_CHAINID_OR_IDENTIFIER_OR_VALUE", |
String("chain->chain[ array_index_list ]"), |
"Chain state not a CQLIdentifier or a " |
CQL_globalParserState->currentTokenPos) |
"CQLChainedIdentifier or a CQLValue while parsing rule" |
); |
" $0 in position $1.", |
} |
"chain->chain[ array_index_list ]", |
|
CQL_globalParserState->currentTokenPos) ); |
} | } |
|
;} |
break; | break; |
case 33: |
|
#line 742 "CQL.y" |
case 34: |
|
#line 782 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "concat->chain"; |
CQLTRACE("concat->chain"); |
sprintf(msg,"BISON::concat->chain\n"); |
|
printf_(msg); |
|
| |
yyval._predicate = ((CQLPredicate*)yyvsp[0]._node); |
(yyval._predicate) = ((CQLPredicate*)(yyvsp[(1) - (1)]._node)); |
} |
;} |
break; | break; |
case 34: |
|
#line 750 "CQL.y" |
case 35: |
|
#line 788 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "concat->concat || literal_string"; |
CQLTRACE("concat->concat || literal_string"); |
sprintf(msg,"BISON::concat||literal_string\n"); |
|
printf_(msg); |
|
| |
CQLValue* tmpval = new CQLValue(*yyvsp[0]._string); |
CQLValue* tmpval = new CQLValue(*(yyvsp[(3) - (3)]._string)); |
_ObjPtr._ptr = tmpval; | _ObjPtr._ptr = tmpval; |
_ObjPtr.type = Val; | _ObjPtr.type = Val; |
_ptrs.append(_ObjPtr); | _ptrs.append(_ObjPtr); |
| |
if((CQLPredicate*)yyvsp[-2]._predicate->isSimple()) |
if((CQLPredicate*)(yyvsp[(1) - (3)]._predicate)->isSimple()) |
{ | { |
CQLSimplePredicate sp = ((CQLPredicate*)yyvsp[-2]._predicate)->getSimplePredicate(); |
CQLSimplePredicate sp = ((CQLPredicate*)(yyvsp[(1) - (3)]._predicate))->getSimplePredicate(); |
if(sp.isSimple()) | if(sp.isSimple()) |
{ | { |
CQLExpression exp = sp.getLeftExpression(); | CQLExpression exp = sp.getLeftExpression(); |
if(exp.isSimple()) | if(exp.isSimple()) |
{ | { |
CQLTerm* _term = ((CQLTerm*)(_factory.getObject(yyvsp[-2]._predicate, Predicate, Term))); |
CQLTerm* _term = ((CQLTerm*) |
/* check for simple literal values*/ |
(_factory.getObject((yyvsp[(1) - (3)]._predicate), Predicate, Term))); |
|
// check for simple literal values |
Array<CQLFactor> factors = _term->getFactors(); | Array<CQLFactor> factors = _term->getFactors(); |
for(Uint32 i = 0; i < factors.size(); i++){ |
for(Uint32 i = 0; i < factors.size(); i++) |
if(!factors[i].isSimpleValue()){ |
{ |
MessageLoaderParms mparms("CQL.CQL_y.CONCAT_PRODUCTION_FACTORS_NOT_SIMPLE", |
if(!factors[i].isSimpleValue()) |
"The CQLFactors are not simple while processing rule $0.", |
{ |
|
MessageLoaderParms mparms( |
|
"CQL.CQL_y.CONCAT_PRODUCTION_FACTORS_NOT" |
|
"_SIMPLE", |
|
"The CQLFactors are not simple while" |
|
" processing rule $0.", |
CQL_globalParserState->currentRule); | CQL_globalParserState->currentRule); |
throw CQLSyntaxErrorException(mparms); | throw CQLSyntaxErrorException(mparms); |
}else{ |
} |
|
else /* !factors[i].isSimpleValue() */ |
|
{ |
CQLValue val = factors[i].getValue(); | CQLValue val = factors[i].getValue(); |
if(val.getValueType() != CQLValue::String_type){ |
if(val.getValueType() != CQLValue::String_type) |
MessageLoaderParms mparms("CQL.CQL_y.CONCAT_PRODUCTION_VALUE_NOT_LITERAL", |
{ |
|
MessageLoaderParms mparms( |
|
"CQL.CQL_y.CONCAT_PRODUCTION_VALUE_NOT_LITERAL", |
"The CQLValue is not a string literal while processing rule $0.", | "The CQLValue is not a string literal while processing rule $0.", |
CQL_globalParserState->currentRule); | CQL_globalParserState->currentRule); |
throw CQLSyntaxErrorException(mparms); | throw CQLSyntaxErrorException(mparms); |
} | } |
} | } |
} | } |
CQLFactor* _fctr2 = ((CQLFactor*)(_factory.makeObject(tmpval, Factor))); |
CQLFactor* _fctr2 = ((CQLFactor*) |
|
(_factory.makeObject(tmpval, Factor))); |
_term->appendOperation(concat,*_fctr2); | _term->appendOperation(concat,*_fctr2); |
yyval._predicate = (CQLPredicate*)(_factory.makeObject(_term,Predicate)); |
(yyval._predicate) = (CQLPredicate*)(_factory.makeObject |
|
(_term,Predicate)); |
} | } |
else |
else /* exp.isSimple() */ |
{ | { |
MessageLoaderParms mparms("CQL.CQL_y.CONCAT_PRODUCTION_NOT_SIMPLE", |
MessageLoaderParms mparms( |
|
"CQL.CQL_y.CONCAT_PRODUCTION_NOT_SIMPLE", |
"The $0 is not simple while processing rule $1.", | "The $0 is not simple while processing rule $1.", |
String("CQLExpression"), |
"CQLExpression", |
CQL_globalParserState->currentRule); | CQL_globalParserState->currentRule); |
throw CQLSyntaxErrorException(mparms); | throw CQLSyntaxErrorException(mparms); |
} | } |
} | } |
else |
else /*sp.isSimple() */ |
{ | { |
MessageLoaderParms mparms("CQL.CQL_y.CONCAT_PRODUCTION_NOT_SIMPLE", |
MessageLoaderParms mparms( |
|
"CQL.CQL_y.CONCAT_PRODUCTION_NOT_SIMPLE", |
"The $0 is not simple while processing rule $1.", | "The $0 is not simple while processing rule $1.", |
String("CQLSimplePredicate"), |
"CQLSimplePredicate", |
CQL_globalParserState->currentRule); | CQL_globalParserState->currentRule); |
throw CQLSyntaxErrorException(mparms); | throw CQLSyntaxErrorException(mparms); |
} | } |
} | } |
else |
else /* end if((CQLPredicate*)$1->isSimple()) */ |
{ | { |
MessageLoaderParms mparms("CQL.CQL_y.CONCAT_PRODUCTION_NOT_SIMPLE", |
MessageLoaderParms mparms( |
|
"CQL.CQL_y.CONCAT_PRODUCTION_NOT_SIMPLE", |
"The $0 is not simple while processing rule $1.", | "The $0 is not simple while processing rule $1.", |
String("CQLPredicate"), |
"CQLPredicate", |
CQL_globalParserState->currentRule); | CQL_globalParserState->currentRule); |
throw CQLSyntaxErrorException(mparms); | throw CQLSyntaxErrorException(mparms); |
} | } |
} |
;} |
break; | break; |
case 35: |
|
#line 821 "CQL.y" |
case 36: |
|
#line 872 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "factor->concat"; |
CQLTRACE("factor->concat"); |
sprintf(msg,"BISON::factor->concat\n"); |
|
printf_(msg); |
|
| |
yyval._predicate = yyvsp[0]._predicate; |
(yyval._predicate) = (yyvsp[(1) - (1)]._predicate); |
} |
;} |
break; | break; |
case 36: |
|
#line 848 "CQL.y" |
case 37: |
|
#line 902 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "term->factor"; | CQL_globalParserState->currentRule = "term->factor"; |
sprintf(msg,"BISON::term->factor\n"); | sprintf(msg,"BISON::term->factor\n"); |
printf_(msg); | printf_(msg); |
| |
yyval._predicate = yyvsp[0]._predicate; |
CQLTRACE("term->factor"); |
} |
|
|
(yyval._predicate) = (yyvsp[(1) - (1)]._predicate); |
|
;} |
break; | break; |
case 37: |
|
#line 874 "CQL.y" |
case 38: |
|
#line 934 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "arith->term"; | CQL_globalParserState->currentRule = "arith->term"; |
sprintf(msg,"BISON::arith->term\n"); | sprintf(msg,"BISON::arith->term\n"); |
printf_(msg); | printf_(msg); |
| |
/*CQLPredicate* _pred = new CQLPredicate(*$1);*/ |
CQLTRACE("arith->term"); |
/* _factory._predicates.append(_pred);*/ |
|
yyval._predicate = yyvsp[0]._predicate; |
//CQLPredicate* _pred = new CQLPredicate(*$1); |
} |
// _factory._predicates.append(_pred); |
|
(yyval._predicate) = (yyvsp[(1) - (1)]._predicate); |
|
;} |
break; | break; |
case 38: |
|
#line 902 "CQL.y" |
case 39: |
|
#line 968 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "value_symbol->#literal_string"; |
CQLTRACE("value_symbol->#literal_string"); |
sprintf(msg,"BISON::value_symbol->#literal_string\n"); |
|
printf_(msg); |
|
| |
String tmp("#"); | String tmp("#"); |
tmp.append(*yyvsp[0]._string); |
tmp.append(*(yyvsp[(2) - (2)]._string)); |
CQLIdentifier tmpid(tmp); | CQLIdentifier tmpid(tmp); |
yyval._value = new CQLValue(tmpid); |
(yyval._value) = new CQLValue(tmpid); |
_ObjPtr._ptr = yyval._value; |
_ObjPtr._ptr = (yyval._value); |
_ObjPtr.type = Val; | _ObjPtr.type = Val; |
_ptrs.append(_ObjPtr); | _ptrs.append(_ObjPtr); |
} |
;} |
break; | break; |
case 39: |
|
#line 918 "CQL.y" |
|
{ |
|
CQL_globalParserState->currentRule = "arith_or_value_symbol->arith"; |
|
sprintf(msg,"BISON::arith_or_value_symbol->arith\n"); |
|
printf_(msg); |
|
| |
yyval._predicate = yyvsp[0]._predicate; |
|
} |
|
break; |
|
case 40: | case 40: |
#line 926 "CQL.y" |
#line 982 "CQL.y" |
{ | { |
/* make into predicate */ |
CQLTRACE("arith_or_value_symbol->arith"); |
CQL_globalParserState->currentRule = "arith_or_value_symbol->value_symbol"; |
|
sprintf(msg,"BISON::arith_or_value_symbol->value_symbol\n"); |
|
printf_(msg); |
|
| |
CQLFactor _fctr(*yyvsp[0]._value); |
(yyval._predicate) = (yyvsp[(1) - (1)]._predicate); |
yyval._predicate = (CQLPredicate*)(_factory.makeObject(&_fctr, Predicate)); |
;} |
} |
|
break; | break; |
|
|
case 41: | case 41: |
#line 938 "CQL.y" |
#line 988 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "comp_op->_EQ"; |
/* make into predicate */ |
sprintf(msg,"BISON::comp_op->_EQ\n"); |
CQLTRACE("arith_or_value_symbol->value_symbol"); |
printf_(msg); |
|
yyval._opType = EQ; |
CQLFactor _fctr(*(yyvsp[(1) - (1)]._value)); |
} |
(yyval._predicate) = (CQLPredicate*)(_factory.makeObject(&_fctr, Predicate)); |
|
;} |
break; | break; |
|
|
case 42: | case 42: |
#line 945 "CQL.y" |
#line 998 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "comp_op->_NE"; |
CQLTRACE("comp_op->TOK_EQ"); |
sprintf(msg,"BISON::comp_op->_NE\n"); |
|
printf_(msg); |
(yyval._opType) = EQ; |
yyval._opType = NE; |
;} |
} |
|
break; | break; |
|
|
case 43: | case 43: |
#line 952 "CQL.y" |
#line 1004 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "comp_op->_GT"; |
CQLTRACE("comp_op->TOK_NE"); |
sprintf(msg,"BISON::comp_op->_GT\n"); |
(yyval._opType) = NE; |
printf_(msg); |
;} |
yyval._opType = GT; |
|
} |
|
break; | break; |
|
|
case 44: | case 44: |
#line 959 "CQL.y" |
#line 1009 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "comp_op->_LT"; |
CQLTRACE("comp_op->TOK_GT"); |
sprintf(msg,"BISON::comp_op->_LT\n"); |
|
printf_(msg); |
(yyval._opType) = GT; |
yyval._opType = LT; |
;} |
} |
|
break; | break; |
|
|
case 45: | case 45: |
#line 966 "CQL.y" |
#line 1015 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "comp_op->_GE"; |
CQLTRACE("comp_op->TOK_LT"); |
sprintf(msg,"BISON::comp_op->_GE\n"); |
(yyval._opType) = LT; |
printf_(msg); |
;} |
yyval._opType = GE; |
|
} |
|
break; | break; |
|
|
case 46: | case 46: |
#line 973 "CQL.y" |
#line 1020 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "comp_op->_LE"; |
CQLTRACE("comp_op->TOK_GE"); |
sprintf(msg,"BISON::comp_op->_LE\n"); |
(yyval._opType) = GE; |
printf_(msg); |
;} |
yyval._opType = LE; |
|
} |
|
break; | break; |
|
|
case 47: | case 47: |
#line 982 "CQL.y" |
#line 1025 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "comp->arith"; |
CQLTRACE("comp_op->TOK_LE"); |
sprintf(msg,"BISON::comp->arith\n"); |
(yyval._opType) = LE; |
printf_(msg); |
;} |
|
|
yyval._predicate = yyvsp[0]._predicate; |
|
} |
|
break; | break; |
|
|
case 48: | case 48: |
#line 990 "CQL.y" |
#line 1032 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "comp->arith IS NOT _NULL"; |
CQLTRACE("comp->arith"); |
sprintf(msg,"BISON::comp->arith IS NOT _NULL\n"); |
|
printf_(msg); |
|
| |
CQLExpression *_expr = (CQLExpression*)(_factory.getObject(yyvsp[-3]._predicate,Expression)); |
(yyval._predicate) = (yyvsp[(1) - (1)]._predicate); |
CQLSimplePredicate _sp(*_expr, IS_NOT_NULL); |
;} |
_factory.setObject(yyvsp[-3]._predicate,&_sp,SimplePredicate); |
|
yyval._predicate = yyvsp[-3]._predicate; |
|
} |
|
break; | break; |
|
|
case 49: | case 49: |
#line 1001 "CQL.y" |
#line 1038 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "comp->arith IS _NULL"; |
CQLTRACE("comp->arith TOK_IS TOK_NOT TOK_NULL"); |
sprintf(msg,"BISON::comp->arith IS _NULL\n"); |
|
printf_(msg); |
|
| |
CQLExpression *_expr = (CQLExpression*)(_factory.getObject(yyvsp[-2]._predicate,Expression)); |
CQLExpression *_expr = |
CQLSimplePredicate _sp(*_expr, IS_NULL); |
(CQLExpression*)(_factory.getObject((yyvsp[(1) - (4)]._predicate),Expression)); |
_factory.setObject(yyvsp[-2]._predicate,&_sp,SimplePredicate); |
CQLSimplePredicate _sp(*_expr, IS_NOT_NULL); |
yyval._predicate = yyvsp[-2]._predicate; |
_factory.setObject((yyvsp[(1) - (4)]._predicate),&_sp,SimplePredicate); |
} |
(yyval._predicate) = (yyvsp[(1) - (4)]._predicate); |
|
;} |
break; | break; |
|
|
case 50: | case 50: |
#line 1012 "CQL.y" |
#line 1048 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "comp->arith comp_op arith_or_value_symbol"; |
CQLTRACE("comp->arith TOK_IS TOK_NULL"); |
sprintf(msg,"BISON::comp->arith comp_op arith_or_value_symbol\n"); |
|
printf_(msg); |
CQLExpression *_expr = (CQLExpression*)(_factory.getObject((yyvsp[(1) - (3)]._predicate),Expression)); |
if(yyvsp[-2]._predicate->isSimple() && yyvsp[0]._predicate->isSimple()){ |
CQLSimplePredicate _sp(*_expr, IS_NULL); |
CQLExpression* _exp1 = (CQLExpression*)(_factory.getObject(yyvsp[-2]._predicate,Predicate,Expression)); |
_factory.setObject((yyvsp[(1) - (3)]._predicate),&_sp,SimplePredicate); |
CQLExpression* _exp2 = (CQLExpression*)(_factory.getObject(yyvsp[0]._predicate,Predicate,Expression)); |
(yyval._predicate) = (yyvsp[(1) - (3)]._predicate); |
CQLSimplePredicate _sp(*_exp1, *_exp2, yyvsp[-1]._opType); |
;} |
yyval._predicate = new CQLPredicate(_sp); |
break; |
_ObjPtr._ptr = yyval._predicate; |
|
|
case 51: |
|
#line 1057 "CQL.y" |
|
{ |
|
CQLTRACE("comp->arith comp_op arith_or_value_symbol"); |
|
|
|
if((yyvsp[(1) - (3)]._predicate)->isSimple() && (yyvsp[(3) - (3)]._predicate)->isSimple()) |
|
{ |
|
CQLExpression* _exp1 = (CQLExpression*) |
|
(_factory.getObject((yyvsp[(1) - (3)]._predicate),Predicate,Expression)); |
|
CQLExpression* _exp2 = (CQLExpression*) |
|
(_factory.getObject((yyvsp[(3) - (3)]._predicate),Predicate,Expression)); |
|
CQLSimplePredicate _sp(*_exp1, *_exp2, (yyvsp[(2) - (3)]._opType)); |
|
(yyval._predicate) = new CQLPredicate(_sp); |
|
_ObjPtr._ptr = (yyval._predicate); |
_ObjPtr.type = Pred; | _ObjPtr.type = Pred; |
_ptrs.append(_ObjPtr); | _ptrs.append(_ObjPtr); |
}else{ |
} |
|
else |
|
{ |
/* error */ | /* error */ |
String _msg("comp->arith comp_op arith_or_value_symbol : $1 is not simple OR $3 is not simple"); |
String _msg("comp->arith comp_op arith_or_value_symbol : $1 is " |
|
"not simple OR $3 is not simple"); |
throw CQLSyntaxErrorException( | throw CQLSyntaxErrorException( |
MessageLoaderParms(String("CQL.CQL_y.NOT_SIMPLE"), |
MessageLoaderParms("CQL.CQL_y.NOT_SIMPLE", |
String("The CQLSimplePredicate is not simple while parsing rule $0 in position $1."), |
"The CQLSimplePredicate is not simple while parsing " |
String("comp->arith comp_op arith_or_value_symbol"), |
"rule $0 in position $1.", |
CQL_globalParserState->currentTokenPos) |
"comp->arith comp_op arith_or_value_symbol", |
); |
CQL_globalParserState->currentTokenPos) ); |
} |
|
} | } |
|
;} |
break; | break; |
case 51: |
|
#line 1036 "CQL.y" |
case 52: |
|
#line 1086 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "comp->value_symbol comp_op arith"; |
CQLTRACE("comp->value_symbol comp_op arith"); |
sprintf(msg,"BISON::comp->value_symbol comp_op arith\n"); |
|
printf_(msg); |
|
| |
if(yyvsp[0]._predicate->isSimple()){ |
if((yyvsp[(3) - (3)]._predicate)->isSimple()) |
CQLExpression* _exp1 = (CQLExpression*)(_factory.makeObject(yyvsp[-2]._value, Expression)); |
{ |
CQLExpression* _exp2 = (CQLExpression*)(_factory.getObject(yyvsp[0]._predicate,Predicate,Expression)); |
CQLExpression* _exp1 = (CQLExpression*) |
CQLSimplePredicate _sp(*_exp1, *_exp2, yyvsp[-1]._opType); |
(_factory.makeObject((yyvsp[(1) - (3)]._value), Expression)); |
yyval._predicate = new CQLPredicate(_sp); |
CQLExpression* _exp2 = (CQLExpression*) |
_ObjPtr._ptr = yyval._predicate; |
(_factory.getObject((yyvsp[(3) - (3)]._predicate),Predicate,Expression)); |
|
CQLSimplePredicate _sp(*_exp1, *_exp2, (yyvsp[(2) - (3)]._opType)); |
|
(yyval._predicate) = new CQLPredicate(_sp); |
|
_ObjPtr._ptr = (yyval._predicate); |
_ObjPtr.type = Pred; | _ObjPtr.type = Pred; |
_ptrs.append(_ObjPtr); | _ptrs.append(_ObjPtr); |
}else{ |
} |
|
else |
|
{ |
/* error */ | /* error */ |
String _msg("comp->value_symbol comp_op arith : $3 is not simple"); | String _msg("comp->value_symbol comp_op arith : $3 is not simple"); |
throw CQLSyntaxErrorException( | throw CQLSyntaxErrorException( |
MessageLoaderParms(String("CQL.CQL_y.NOT_SIMPLE"), |
MessageLoaderParms("CQL.CQL_y.NOT_SIMPLE", |
String("The CQLSimplePredicate is not simple while parsing rule $0 in position $1."), |
"The CQLSimplePredicate is not simple while parsing" |
String("comp->value_symbol comp_op arith"), |
" rule $0 in position $1.", |
CQL_globalParserState->currentTokenPos) |
"comp->value_symbol comp_op arith", |
); |
CQL_globalParserState->currentTokenPos) ); |
| |
} | } |
} |
;} |
break; | break; |
case 52: |
|
#line 1062 "CQL.y" |
|
{ |
|
CQL_globalParserState->currentRule = "comp->arith _ISA identifier"; |
|
/* make sure $1 isSimple(), get its expression, make simplepred->predicate */ |
|
sprintf(msg,"BISON::comp->arith _ISA identifier\n"); |
|
printf_(msg); |
|
| |
CQLExpression *_expr1 = (CQLExpression*)(_factory.getObject(yyvsp[-2]._predicate,Predicate,Expression)); |
|
CQLChainedIdentifier _cid(*yyvsp[0]._identifier); |
|
CQLExpression *_expr2 = (CQLExpression*)(_factory.makeObject(&_cid,Expression)); |
|
CQLSimplePredicate _sp(*_expr1, *_expr2, ISA); |
|
_factory.setObject(yyvsp[-2]._predicate,&_sp,SimplePredicate); |
|
yyval._predicate = yyvsp[-2]._predicate; |
|
} |
|
break; |
|
case 53: | case 53: |
#line 1076 "CQL.y" |
#line 1115 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "comp->arith _LIKE literal_string"; |
/* make sure $1 isSimple(), get its expression, make |
sprintf(msg,"BISON::comp->arith _LIKE literal_string\n"); |
simplepred->predicate |
printf_(msg); |
*/ |
|
CQLTRACE("comp->arith _TOK_ISA identifier"); |
| |
CQLExpression *_expr1 = (CQLExpression*)(_factory.getObject(yyvsp[-2]._predicate,Predicate,Expression)); |
CQLExpression *_expr1 = (CQLExpression*) |
CQLValue _val(*yyvsp[0]._string); |
(_factory.getObject((yyvsp[(1) - (3)]._predicate),Predicate,Expression)); |
CQLExpression *_expr2 = (CQLExpression*)(_factory.makeObject(&_val,Expression)); |
CQLChainedIdentifier _cid(*(yyvsp[(3) - (3)]._identifier)); |
CQLSimplePredicate _sp(*_expr1, *_expr2, LIKE); |
CQLExpression *_expr2 = (CQLExpression*) |
_factory.setObject(yyvsp[-2]._predicate,&_sp,SimplePredicate); |
(_factory.makeObject(&_cid,Expression)); |
yyval._predicate = yyvsp[-2]._predicate; |
CQLSimplePredicate _sp(*_expr1, *_expr2, ISA); |
} |
_factory.setObject((yyvsp[(1) - (3)]._predicate),&_sp,SimplePredicate); |
|
(yyval._predicate) = (yyvsp[(1) - (3)]._predicate); |
|
;} |
break; | break; |
|
|
case 54: | case 54: |
#line 1090 "CQL.y" |
#line 1131 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "expr_factor->comp"; |
CQLTRACE("comp->arith TOK_LIKE literal_string"); |
sprintf(msg,"BISON::expr_factor->comp\n"); |
|
printf_(msg); |
|
| |
yyval._predicate = yyvsp[0]._predicate; |
CQLExpression *_expr1 = (CQLExpression*) |
} |
(_factory.getObject((yyvsp[(1) - (3)]._predicate),Predicate,Expression)); |
|
CQLValue _val(*(yyvsp[(3) - (3)]._string)); |
|
CQLExpression *_expr2 = (CQLExpression*) |
|
(_factory.makeObject(&_val,Expression)); |
|
CQLSimplePredicate _sp(*_expr1, *_expr2, LIKE); |
|
_factory.setObject((yyvsp[(1) - (3)]._predicate),&_sp,SimplePredicate); |
|
(yyval._predicate) = (yyvsp[(1) - (3)]._predicate); |
|
;} |
break; | break; |
|
|
case 55: | case 55: |
#line 1098 "CQL.y" |
#line 1145 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "expr_factor->NOT comp"; |
CQLTRACE("expr_factor->comp"); |
sprintf(msg,"BISON::expr_factor->NOT comp\n"); |
|
printf_(msg); |
|
| |
yyvsp[0]._predicate->setInverted(!(yyvsp[0]._predicate->getInverted())); |
(yyval._predicate) = (yyvsp[(1) - (1)]._predicate); |
yyval._predicate = yyvsp[0]._predicate; |
;} |
} |
|
break; | break; |
|
|
case 56: | case 56: |
#line 1109 "CQL.y" |
#line 1151 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "expr_term->expr_factor"; |
CQLTRACE("expr_factor->TOK_NOT comp"); |
sprintf(msg,"BISON::expr_term->expr_factor\n"); |
|
printf_(msg); |
|
| |
yyval._predicate = yyvsp[0]._predicate; |
(yyvsp[(2) - (2)]._predicate)->setInverted(!((yyvsp[(2) - (2)]._predicate)->getInverted())); |
} |
(yyval._predicate) = (yyvsp[(2) - (2)]._predicate); |
|
;} |
break; | break; |
|
|
case 57: | case 57: |
#line 1117 "CQL.y" |
#line 1160 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "expr_term->expr_term AND expr_factor"; |
CQLTRACE("expr_term->expr_factor"); |
sprintf(msg,"BISON::expr_term->expr_term AND expr_factor\n"); |
|
printf_(msg); |
|
| |
yyval._predicate = new CQLPredicate(); |
(yyval._predicate) = (yyvsp[(1) - (1)]._predicate); |
yyval._predicate->appendPredicate(*yyvsp[-2]._predicate); |
;} |
yyval._predicate->appendPredicate(*yyvsp[0]._predicate, AND); |
|
_ObjPtr._ptr = yyval._predicate; |
|
_ObjPtr.type = Pred; |
|
_ptrs.append(_ObjPtr); |
|
} |
|
break; | break; |
|
|
case 58: | case 58: |
#line 1132 "CQL.y" |
#line 1166 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "expr->expr_term"; |
CQLTRACE("expr_term->expr_term AND expr_factor"); |
sprintf(msg,"BISON::expr->expr_term\n"); |
|
printf_(msg); |
|
| |
yyval._predicate = yyvsp[0]._predicate; |
(yyval._predicate) = new CQLPredicate(); |
} |
(yyval._predicate)->appendPredicate(*(yyvsp[(1) - (3)]._predicate)); |
|
(yyval._predicate)->appendPredicate(*(yyvsp[(3) - (3)]._predicate), AND); |
|
_ObjPtr._ptr = (yyval._predicate); |
|
_ObjPtr.type = Pred; |
|
_ptrs.append(_ObjPtr); |
|
;} |
break; | break; |
|
|
case 59: | case 59: |
#line 1140 "CQL.y" |
#line 1179 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "expr->expr OR expr_term"; |
CQLTRACE("expr->expr_term"); |
sprintf(msg,"BISON::expr->expr OR expr_term\n"); |
|
printf_(msg); |
(yyval._predicate) = (yyvsp[(1) - (1)]._predicate); |
yyval._predicate = new CQLPredicate(); |
;} |
yyval._predicate->appendPredicate(*yyvsp[-2]._predicate); |
|
yyval._predicate->appendPredicate(*yyvsp[0]._predicate, OR); |
|
_ObjPtr._ptr = yyval._predicate; |
|
_ObjPtr.type = Pred; |
|
_ptrs.append(_ObjPtr); |
|
} |
|
break; | break; |
|
|
case 60: | case 60: |
#line 1153 "CQL.y" |
#line 1185 "CQL.y" |
{;} |
{ |
|
CQLTRACE("expr->expr OR expr_term"); |
|
|
|
(yyval._predicate) = new CQLPredicate(); |
|
(yyval._predicate)->appendPredicate(*(yyvsp[(1) - (3)]._predicate)); |
|
(yyval._predicate)->appendPredicate(*(yyvsp[(3) - (3)]._predicate), OR); |
|
_ObjPtr._ptr = (yyval._predicate); |
|
_ObjPtr.type = Pred; |
|
_ptrs.append(_ObjPtr); |
|
;} |
break; | break; |
|
|
case 61: | case 61: |
#line 1171 "CQL.y" |
#line 1197 "CQL.y" |
|
{;;} |
|
break; |
|
|
|
case 62: |
|
#line 1216 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "arg_list->arg_list_sub->expr"; |
CQLTRACE("arg_list->arg_list_sub->expr"); |
sprintf(msg,"BISON::arg_list_sub->expr\n"); |
|
printf_(msg); |
|
| |
_arglist.append(*yyvsp[0]._predicate);/* |
_arglist.append(*(yyvsp[(1) - (1)]._predicate)); |
|
/* |
since arg_list can loop back on itself, | since arg_list can loop back on itself, |
we need to store away previous solutions | we need to store away previous solutions |
production. We keep track of previous productions | production. We keep track of previous productions |
in the _arglist array and later pass that to CQLFunction | in the _arglist array and later pass that to CQLFunction |
as part of chain: identifier LPAR arg_list RPAR |
as part of chain: identifier TOK_LPAR arg_list TOK_RPAR |
*/ | */ |
} |
;} |
break; | break; |
case 62: |
|
#line 1232 "CQL.y" |
|
{ |
|
CQL_globalParserState->currentRule = "from_specifier->class_path"; |
|
sprintf(msg,"BISON::from_specifier->class_path\n"); |
|
printf_(msg); |
|
| |
CQL_globalParserState->statement->appendClassPath(*yyvsp[0]._identifier); |
|
} |
|
break; |
|
case 63: | case 63: |
#line 1241 "CQL.y" |
#line 1276 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "from_specifier->class_path AS identifier"; |
CQLTRACE("from_specifier->class_path"); |
sprintf(msg,"BISON::from_specifier->class_path AS identifier\n"); |
|
printf_(msg); |
|
| |
CQLIdentifier _class(*yyvsp[-2]._identifier); |
CQL_globalParserState->statement->appendClassPath(*(yyvsp[(1) - (1)]._identifier)); |
String _alias(yyvsp[0]._identifier->getName().getString()); |
;} |
CQL_globalParserState->statement->insertClassPathAlias(_class,_alias); |
|
CQL_globalParserState->statement->appendClassPath(_class); |
|
} |
|
break; | break; |
|
|
case 64: | case 64: |
#line 1252 "CQL.y" |
#line 1282 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "from_specifier->class_path identifier"; |
CQL_globalParserState->currentRule = "from_specifier->class_path TOK_AS identifier"; |
sprintf(msg,"BISON::from_specifier->class_path identifier\n"); |
CQLTRACE("from_specifier->class_path TOK_AS identifier"); |
printf_(msg); |
|
| |
CQLIdentifier _class(*yyvsp[-1]._identifier); |
CQLIdentifier _class(*(yyvsp[(1) - (3)]._identifier)); |
String _alias(yyvsp[0]._identifier->getName().getString()); |
String _alias((yyvsp[(3) - (3)]._identifier)->getName().getString()); |
CQL_globalParserState->statement->insertClassPathAlias(_class,_alias); | CQL_globalParserState->statement->insertClassPathAlias(_class,_alias); |
CQL_globalParserState->statement->appendClassPath(_class); | CQL_globalParserState->statement->appendClassPath(_class); |
} |
;} |
break; | break; |
|
|
case 65: | case 65: |
#line 1265 "CQL.y" |
#line 1292 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "from_criteria->from_specifier"; |
CQLTRACE("from_specifier->class_path identifier"); |
sprintf(msg,"BISON::from_criteria->from_specifier\n"); |
|
printf_(msg); |
CQLIdentifier _class(*(yyvsp[(1) - (2)]._identifier)); |
} |
String _alias((yyvsp[(2) - (2)]._identifier)->getName().getString()); |
|
CQL_globalParserState->statement->insertClassPathAlias(_class,_alias); |
|
CQL_globalParserState->statement->appendClassPath(_class); |
|
;} |
break; | break; |
|
|
case 66: | case 66: |
#line 1273 "CQL.y" |
#line 1303 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "star_expr->STAR"; |
CQLTRACE("from_criteria->from_specifier"); |
sprintf(msg,"BISON::star_expr->STAR\n"); |
;} |
printf_(msg); |
break; |
|
|
|
case 67: |
|
#line 1309 "CQL.y" |
|
{ |
|
CQLTRACE("star_expr->TOK_STAR"); |
| |
CQLIdentifier _id("*"); | CQLIdentifier _id("*"); |
yyval._chainedIdentifier = (CQLChainedIdentifier*)(_factory.makeObject(&_id,ChainedIdentifier)); |
(yyval._chainedIdentifier) = (CQLChainedIdentifier*)(_factory.makeObject(&_id,ChainedIdentifier)); |
} |
;} |
break; | break; |
case 67: |
|
#line 1282 "CQL.y" |
case 68: |
|
#line 1316 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "star_expr->chain.*"; |
CQLTRACE("star_expr->chain.*"); |
sprintf(msg,"BISON::star_expr->chain.*\n"); |
|
printf_(msg); |
CQLChainedIdentifier* _tmp = (CQLChainedIdentifier*) |
CQLChainedIdentifier* _tmp = (CQLChainedIdentifier*)(_factory.getObject(yyvsp[-2]._node,Predicate,ChainedIdentifier)); |
(_factory.getObject((yyvsp[(1) - (3)]._node),Predicate,ChainedIdentifier)); |
CQLChainedIdentifier* _cid = new CQLChainedIdentifier(*_tmp); | CQLChainedIdentifier* _cid = new CQLChainedIdentifier(*_tmp); |
CQLIdentifier _id("*"); | CQLIdentifier _id("*"); |
_cid->append(_id); | _cid->append(_id); |
yyval._chainedIdentifier = _cid; |
(yyval._chainedIdentifier) = _cid; |
_ObjPtr._ptr = yyval._chainedIdentifier; |
_ObjPtr._ptr = (yyval._chainedIdentifier); |
_ObjPtr.type = CId; | _ObjPtr.type = CId; |
_ptrs.append(_ObjPtr); | _ptrs.append(_ObjPtr); |
} |
;} |
break; | break; |
case 68: |
|
#line 1298 "CQL.y" |
case 69: |
|
#line 1332 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "selected_entry->expr"; |
CQLTRACE("selected_entry->expr"); |
sprintf(msg,"BISON::selected_entry->expr\n"); |
|
printf_(msg); |
if((yyvsp[(1) - (1)]._predicate)->isSimpleValue()) |
if(yyvsp[0]._predicate->isSimpleValue()){ |
{ |
CQLChainedIdentifier *_cid = (CQLChainedIdentifier*)(_factory.getObject(yyvsp[0]._predicate,Predicate,ChainedIdentifier)); |
CQLChainedIdentifier *_cid = (CQLChainedIdentifier*) |
|
(_factory.getObject((yyvsp[(1) - (1)]._predicate),Predicate,ChainedIdentifier)); |
CQL_globalParserState->statement->appendSelectIdentifier(*_cid); | CQL_globalParserState->statement->appendSelectIdentifier(*_cid); |
}else{ |
} |
|
else |
|
{ |
/* error */ | /* error */ |
String _msg("selected_entry->expr : $1 is not a simple value"); | String _msg("selected_entry->expr : $1 is not a simple value"); |
throw CQLSyntaxErrorException( | throw CQLSyntaxErrorException( |
MessageLoaderParms(String("CQL.CQL_y.NOT_SIMPLE_VALUE"), |
MessageLoaderParms("CQL.CQL_y.NOT_SIMPLE_VALUE", |
String("The CQLPredicate is not a simple value while parsing rule $0 in position $1."), |
"The CQLPredicate is not a simple value while " |
String("selected_entry->expr"), |
"parsing rule $0 in position $1.", |
CQL_globalParserState->currentTokenPos) |
"selected_entry->expr", |
); |
CQL_globalParserState->currentTokenPos) ); |
} |
|
} |
|
break; |
|
case 69: |
|
#line 1317 "CQL.y" |
|
{ |
|
CQL_globalParserState->currentRule = "selected_entry->star_expr"; |
|
sprintf(msg,"BISON::selected_entry->star_expr\n"); |
|
printf_(msg); |
|
CQL_globalParserState->statement->appendSelectIdentifier(*yyvsp[0]._chainedIdentifier); |
|
} | } |
|
;} |
break; | break; |
|
|
case 70: | case 70: |
#line 1326 "CQL.y" |
#line 1354 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "select_list->selected_entry select_list_tail"; |
CQLTRACE("selected_entry->star_expr"); |
sprintf(msg,"BISON::select_list->selected_entry select_list_tail\n"); |
|
printf_(msg); |
CQL_globalParserState->statement->appendSelectIdentifier(*(yyvsp[(1) - (1)]._chainedIdentifier)); |
} |
;} |
break; | break; |
|
|
case 71: | case 71: |
#line 1333 "CQL.y" |
#line 1362 "CQL.y" |
{;} |
{ |
|
CQLTRACE("select_list->selected_entry select_list_tail"); |
|
;} |
break; | break; |
|
|
case 72: | case 72: |
#line 1335 "CQL.y" |
#line 1367 "CQL.y" |
{ |
{;;} |
CQL_globalParserState->currentRule = "select_list_tail->COMMA selected_entry select_list_tail"; |
|
sprintf(msg,"BISON::select_list_tail->COMMA selected_entry select_list_tail\n"); |
|
printf_(msg); |
|
} |
|
break; | break; |
|
|
case 73: | case 73: |
#line 1343 "CQL.y" |
#line 1369 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "search_condition->expr"; |
CQLTRACE("select_list_tail->TOK_COMMA selected_entry select_list_tail"); |
sprintf(msg,"BISON::search_condition->expr\n"); |
;} |
printf_(msg); |
|
CQL_globalParserState->statement->setPredicate(*yyvsp[0]._predicate); |
|
} |
|
break; | break; |
|
|
case 74: | case 74: |
#line 1351 "CQL.y" |
#line 1375 "CQL.y" |
{} |
{ |
|
CQLTRACE("search_condition->expr"); |
|
|
|
CQL_globalParserState->statement->setPredicate(*(yyvsp[(1) - (1)]._predicate)); |
|
;} |
break; | break; |
|
|
case 75: | case 75: |
#line 1353 "CQL.y" |
#line 1382 "CQL.y" |
|
{;} |
|
break; |
|
|
|
case 76: |
|
#line 1384 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "optional_where->WHERE search_condition"; |
CQLTRACE( "optional_where->TOK_WHERE search_condition"); |
sprintf(msg,"BISON::optional_where->WHERE search_condition\n"); |
|
printf_(msg); |
|
CQL_globalParserState->statement->setHasWhereClause(); | CQL_globalParserState->statement->setHasWhereClause(); |
} |
;} |
break; | break; |
case 76: |
|
#line 1362 "CQL.y" |
case 77: |
|
#line 1392 "CQL.y" |
{ | { |
CQL_globalParserState->currentRule = "select_statement"; |
CQLTRACE("select_statement"); |
sprintf(msg,"select_statement\n\n"); |
|
printf_(msg); |
|
CQL_Bison_Cleanup(); | CQL_Bison_Cleanup(); |
} |
;} |
break; | break; |
#line 1779 "y.tab.c" |
|
|
|
|
/* Line 1267 of yacc.c. */ |
|
#line 2839 "CQLtemp" |
|
default: break; |
} | } |
yyssp -= yym; |
YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); |
yystate = *yyssp; |
|
yyvsp -= yym; |
YYPOPSTACK (yylen); |
yym = yylhs[yyn]; |
yylen = 0; |
if (yystate == 0 && yym == 0) |
YY_STACK_PRINT (yyss, yyssp); |
{ |
|
#if YYDEBUG |
|
if (yydebug) |
|
printf("%sdebug: after reduction, shifting from state 0 to\ |
|
state %d\n", YYPREFIX, YYFINAL); |
|
#endif |
|
yystate = YYFINAL; |
|
*++yyssp = YYFINAL; |
|
*++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) |
{ | { |
yys = 0; |
YYSIZE_T yyalloc = 2 * yysize; |
if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; |
if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) |
if (!yys) yys = "illegal-symbol"; |
yyalloc = YYSTACK_ALLOC_MAXIMUM; |
printf("%sdebug: state %d, reading %d (%s)\n", |
if (yymsg != yymsgbuf) |
YYPREFIX, YYFINAL, yychar, yys); |
YYSTACK_FREE (yymsg); |
|
yymsg = (char *) YYSTACK_ALLOC (yyalloc); |
|
if (yymsg) |
|
yymsg_alloc = yyalloc; |
|
else |
|
{ |
|
yymsg = yymsgbuf; |
|
yymsg_alloc = sizeof yymsgbuf; |
} | } |
#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 >= yysslim && yygrowstack()) |
} |
|
|
|
|
|
|
|
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 1400 "CQL.y" |
|
|
|
|
|
/*int yyerror(char * err){yyclearin; yyerrok;throw Exception(String(err));return 1;}*/ |
|
|