version 1.1.2.10, 2001/12/07 00:37:56
|
version 1.19.8.1, 2013/06/03 22:36:41
|
|
|
|
/* To be inserted in other files to bypass the chksrc tests */ |
|
/* NOCHKSRC */ |
| |
/* A Bison parser, made from wql.y with Bison version GNU Bison version 1.24 |
/* A Bison parser, made by GNU Bison 2.3. */ |
*/ |
|
| |
#define YYBISON 1 /* Identify Bison output. */ |
/* Skeleton implementation for Bison's Yacc-like parsers in C |
| |
|
Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006 |
|
Free Software Foundation, Inc. |
|
|
|
This program is free software; you can redistribute it and/or modify |
|
it under the terms of the GNU General Public License as published by |
|
the Free Software Foundation; either version 2, or (at your option) |
|
any later version. |
|
|
|
This program is distributed in the hope that it will be useful, |
|
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
GNU General Public License for more details. |
|
|
|
You should have received a copy of the GNU General Public License |
|
along with this program; if not, write to the Free Software |
|
Foundation, Inc., 51 Franklin Street, Fifth Floor, |
|
Boston, MA 02110-1301, USA. */ |
|
|
|
/* As a special exception, you may create a larger work that contains |
|
part or all of the Bison parser skeleton and distribute that work |
|
under terms of your choice, so long as that work isn't itself a |
|
parser generator using the skeleton or a modified version thereof |
|
as a parser skeleton. Alternatively, if you modify or redistribute |
|
the parser skeleton itself, you may (at your option) remove this |
|
special exception, which will cause the skeleton and the resulting |
|
Bison output files to be licensed under the GNU General Public |
|
License without this special exception. |
|
|
|
This special exception was added by the Free Software Foundation in |
|
version 2.2 of Bison. */ |
|
|
|
/* C LALR(1) parser skeleton written by Richard Stallman, by |
|
simplifying the original so-called "semantic" parser. */ |
|
|
|
/* All symbols defined below should begin with yy or YY, to avoid |
|
infringing on user name space. This should be done even for local |
|
variables, as they might otherwise be expanded by user macros. |
|
There are some unavoidable exceptions within include files to |
|
define necessary library symbols; they are noted "INFRINGES ON |
|
USER NAME SPACE" below. */ |
|
|
|
/* Identify Bison output. */ |
|
#define YYBISON 1 |
|
|
|
/* Bison version. */ |
|
#define YYBISON_VERSION "2.3" |
|
|
|
/* Skeleton name. */ |
|
#define YYSKELETON_NAME "yacc.c" |
|
|
|
/* Pure parsers. */ |
|
#define YYPURE 0 |
|
|
|
/* Using locations. */ |
|
#define YYLSP_NEEDED 0 |
|
|
|
/* Substitute the variable and function names. */ |
#define yyparse WQL_parse | #define yyparse WQL_parse |
#define yylex WQL_lex | #define yylex WQL_lex |
#define yyerror WQL_error | #define yyerror WQL_error |
|
|
#define yychar WQL_char | #define yychar WQL_char |
#define yydebug WQL_debug | #define yydebug WQL_debug |
#define yynerrs WQL_nerrs | #define yynerrs WQL_nerrs |
|
|
|
|
|
/* Tokens. */ |
|
#ifndef YYTOKENTYPE |
|
# define YYTOKENTYPE |
|
/* Put the tokens into the symbol table, so that GDB and other debuggers |
|
know about them. */ |
|
enum yytokentype { |
|
TOK_INTEGER = 258, |
|
TOK_DOUBLE = 259, |
|
TOK_STRING = 260, |
|
TOK_TRUE = 261, |
|
TOK_FALSE = 262, |
|
TOK_NULL = 263, |
|
TOK_ISA = 264, |
|
TOK_DOT = 265, |
|
TOK_EQ = 266, |
|
TOK_NE = 267, |
|
TOK_LT = 268, |
|
TOK_LE = 269, |
|
TOK_GT = 270, |
|
TOK_GE = 271, |
|
TOK_NOT = 272, |
|
TOK_OR = 273, |
|
TOK_AND = 274, |
|
TOK_IS = 275, |
|
TOK_IDENTIFIER = 276, |
|
TOK_SELECT = 277, |
|
TOK_WHERE = 278, |
|
TOK_FROM = 279, |
|
TOK_UNEXPECTED_CHAR = 280 |
|
}; |
|
#endif |
|
/* Tokens. */ |
#define TOK_INTEGER 258 | #define TOK_INTEGER 258 |
#define TOK_DOUBLE 259 | #define TOK_DOUBLE 259 |
#define TOK_STRING 260 | #define TOK_STRING 260 |
#define TOK_TRUE 261 | #define TOK_TRUE 261 |
#define TOK_FALSE 262 | #define TOK_FALSE 262 |
#define TOK_NULL 263 | #define TOK_NULL 263 |
#define TOK_EQ 264 |
#define TOK_ISA 264 |
#define TOK_NE 265 |
#define TOK_DOT 265 |
#define TOK_LT 266 |
#define TOK_EQ 266 |
#define TOK_LE 267 |
#define TOK_NE 267 |
#define TOK_GT 268 |
#define TOK_LT 268 |
#define TOK_GE 269 |
#define TOK_LE 269 |
#define TOK_NOT 270 |
#define TOK_GT 270 |
#define TOK_OR 271 |
#define TOK_GE 271 |
#define TOK_AND 272 |
#define TOK_NOT 272 |
#define TOK_IS 273 |
#define TOK_OR 273 |
#define TOK_IDENTIFIER 274 |
#define TOK_AND 274 |
#define TOK_SELECT 275 |
#define TOK_IS 275 |
#define TOK_WHERE 276 |
#define TOK_IDENTIFIER 276 |
#define TOK_FROM 277 |
#define TOK_SELECT 277 |
#define TOK_UNEXPECTED_CHAR 278 |
#define TOK_WHERE 278 |
|
#define TOK_FROM 279 |
|
#define TOK_UNEXPECTED_CHAR 280 |
|
|
|
|
| |
#line 9 "wql.y" |
|
|
/* Copy the first part of user declarations. */ |
|
#line 37 "WQL.y" |
| |
| |
#include <Pegasus/Common/Config.h> | #include <Pegasus/Common/Config.h> |
|
|
#endif | #endif |
| |
extern int WQL_lex(); | extern int WQL_lex(); |
extern int WQL_error(char*); |
extern int WQL_error(const char*); |
| |
// | // |
// Define the global parser state object: | // Define the global parser state object: |
|
|
PEGASUS_NAMESPACE_END | PEGASUS_NAMESPACE_END |
| |
| |
#line 58 "wql.y" |
|
typedef union |
/* Enabling traces. */ |
|
#ifndef YYDEBUG |
|
# define YYDEBUG 0 |
|
#endif |
|
|
|
/* Enabling verbose error messages. */ |
|
#ifdef YYERROR_VERBOSE |
|
# undef YYERROR_VERBOSE |
|
# define YYERROR_VERBOSE 1 |
|
#else |
|
# define YYERROR_VERBOSE 0 |
|
#endif |
|
|
|
/* Enabling the token table. */ |
|
#ifndef YYTOKEN_TABLE |
|
# define YYTOKEN_TABLE 0 |
|
#endif |
|
|
|
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED |
|
typedef union YYSTYPE |
|
#line 87 "WQL.y" |
{ | { |
int intValue; | int intValue; |
double doubleValue; | double doubleValue; |
char* strValue; | char* strValue; |
void* nodeValue; | void* nodeValue; |
} YYSTYPE; |
} |
|
/* Line 187 of yacc.c. */ |
|
#line 202 "WQLtemp" |
|
YYSTYPE; |
|
# define yystype YYSTYPE /* obsolescent; will be withdrawn */ |
|
# define YYSTYPE_IS_DECLARED 1 |
|
# define YYSTYPE_IS_TRIVIAL 1 |
|
#endif |
| |
#ifndef YYLTYPE |
|
typedef |
|
struct yyltype |
/* Copy the second part of user declarations. */ |
|
|
|
|
|
/* Line 216 of yacc.c. */ |
|
#line 215 "WQLtemp" |
|
|
|
#ifdef short |
|
# undef short |
|
#endif |
|
|
|
#ifdef YYTYPE_UINT8 |
|
typedef YYTYPE_UINT8 yytype_uint8; |
|
#else |
|
typedef unsigned char yytype_uint8; |
|
#endif |
|
|
|
#ifdef YYTYPE_INT8 |
|
typedef YYTYPE_INT8 yytype_int8; |
|
#elif (defined __STDC__ || defined __C99__FUNC__ \ |
|
|| defined __cplusplus || defined _MSC_VER) |
|
typedef signed char yytype_int8; |
|
#else |
|
typedef short int yytype_int8; |
|
#endif |
|
|
|
#ifdef YYTYPE_UINT16 |
|
typedef YYTYPE_UINT16 yytype_uint16; |
|
#else |
|
typedef unsigned short int yytype_uint16; |
|
#endif |
|
|
|
#ifdef YYTYPE_INT16 |
|
typedef YYTYPE_INT16 yytype_int16; |
|
#else |
|
typedef short int yytype_int16; |
|
#endif |
|
|
|
#ifndef YYSIZE_T |
|
# ifdef __SIZE_TYPE__ |
|
# define YYSIZE_T __SIZE_TYPE__ |
|
# elif defined size_t |
|
# define YYSIZE_T size_t |
|
# elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \ |
|
|| defined __cplusplus || defined _MSC_VER) |
|
# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ |
|
# define YYSIZE_T size_t |
|
# else |
|
# define YYSIZE_T unsigned int |
|
# endif |
|
#endif |
|
|
|
#define YYSIZE_MAXIMUM ((YYSIZE_T) -1) |
|
|
|
#ifndef YY_ |
|
# if YYENABLE_NLS |
|
# if ENABLE_NLS |
|
# include <libintl.h> /* INFRINGES ON USER NAME SPACE */ |
|
# define YY_(msgid) dgettext ("bison-runtime", msgid) |
|
# endif |
|
# endif |
|
# ifndef YY_ |
|
# define YY_(msgid) msgid |
|
# endif |
|
#endif |
|
|
|
/* Suppress unused-variable warnings by "using" E. */ |
|
#if ! defined lint || defined __GNUC__ |
|
# define YYUSE(e) ((void) (e)) |
|
#else |
|
# define YYUSE(e) /* empty */ |
|
#endif |
|
|
|
/* Identity function, used to suppress warnings about constant conditions. */ |
|
#ifndef lint |
|
# define YYID(n) (n) |
|
#else |
|
#if (defined __STDC__ || defined __C99__FUNC__ \ |
|
|| defined __cplusplus || defined _MSC_VER) |
|
static int |
|
YYID (int i) |
|
#else |
|
static int |
|
YYID (i) |
|
int i; |
|
#endif |
{ | { |
int timestamp; |
return i; |
int first_line; |
|
int first_column; |
|
int last_line; |
|
int last_column; |
|
char *text; |
|
} | } |
yyltype; |
#endif |
|
|
|
#if ! defined yyoverflow || YYERROR_VERBOSE |
| |
#define YYLTYPE yyltype |
/* 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 | #endif |
| |
#include <stdio.h> |
# 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; |
|
}; |
| |
#ifndef __cplusplus |
/* The size of the maximum gap between one aligned stack and the next. */ |
#ifndef __STDC__ |
# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) |
#define const |
|
|
/* 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 |
#endif | #endif |
| |
|
/* Relocate STACK from its old location to the new one. The |
|
local variables YYSIZE and YYSTACKSIZE give the old and new number of |
|
elements in the stack, and YYPTR gives the new location of the |
|
stack. Advance YYPTR to a properly aligned location for the next |
|
stack. */ |
|
# define YYSTACK_RELOCATE(Stack) \ |
|
do \ |
|
{ \ |
|
YYSIZE_T yynewbytes; \ |
|
YYCOPY (&yyptr->Stack, Stack, yysize); \ |
|
Stack = &yyptr->Stack; \ |
|
yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ |
|
yyptr += yynewbytes / sizeof (*yyptr); \ |
|
} \ |
|
while (YYID (0)) |
|
|
|
#endif |
|
|
|
/* YYFINAL -- State number of the termination state. */ |
|
#define YYFINAL 9 |
|
/* YYLAST -- Last index in YYTABLE. */ |
|
#define YYLAST 69 |
| |
|
/* YYNTOKENS -- Number of terminals. */ |
|
#define YYNTOKENS 30 |
|
/* YYNNTS -- Number of nonterminals. */ |
|
#define YYNNTS 16 |
|
/* YYNRULES -- Number of rules. */ |
|
#define YYNRULES 39 |
|
/* YYNRULES -- Number of states. */ |
|
#define YYNSTATES 65 |
| |
#define YYFINAL 60 |
/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ |
#define YYFLAG -32768 |
#define YYUNDEFTOK 2 |
#define YYNTBASE 28 |
#define YYMAXUTOK 280 |
| |
#define YYTRANSLATE(x) ((unsigned)(x) <= 278 ? yytranslate[x] : 43) |
#define YYTRANSLATE(YYX) \ |
|
((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) |
| |
static const char yytranslate[] = { 0, |
/* 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, 26, |
28, 29, 26, 2, 27, 2, 2, 2, 2, 2, |
27, 24, 2, 25, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
2, 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, |
2, 2, 2, 2, 2, 2, 1, 2, 3, 4, |
6, 7, 8, 9, 10, 11, 12, 13, 14, 15, |
5, 6, 7, 8, 9, 10, 11, 12, 13, 14, |
16, 17, 18, 19, 20, 21, 22, 23 |
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, |
|
25 |
}; | }; |
| |
#if YYDEBUG != 0 |
#if YYDEBUG |
static const short yyprhs[] = { 0, |
/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in |
0, 2, 6, 8, 10, 12, 16, 19, 21, 24, |
YYRHS. */ |
27, 31, 35, 38, 42, 44, 48, 53, 55, 57, |
static const yytype_uint8 yyprhs[] = |
61, 65, 69, 73, 77, 81, 85, 90, 92, 94, |
{ |
96, 98, 100, 102, 104, 106 |
0, 0, 3, 5, 9, 11, 13, 15, 19, 22, |
|
24, 27, 30, 34, 38, 41, 45, 47, 51, 56, |
|
58, 60, 64, 68, 72, 76, 80, 84, 88, 92, |
|
97, 99, 101, 103, 107, 109, 111, 113, 115, 117 |
}; | }; |
| |
static const short yyrhs[] = { 29, |
/* YYRHS -- A `-1'-separated list of the rules' RHS. */ |
0, 20, 30, 32, 0, 24, 0, 31, 0, 40, |
static const yytype_int8 yyrhs[] = |
0, 31, 25, 40, 0, 33, 34, 0, 33, 0, |
{ |
22, 41, 0, 21, 35, 0, 35, 16, 35, 0, |
31, 0, -1, 32, -1, 22, 33, 35, -1, 26, |
35, 17, 35, 0, 15, 35, 0, 26, 35, 27, |
-1, 34, -1, 43, -1, 34, 27, 43, -1, 36, |
0, 36, 0, 36, 18, 39, 0, 36, 18, 15, |
37, -1, 36, -1, 24, 44, -1, 23, 38, -1, |
39, 0, 37, 0, 38, 0, 42, 11, 42, 0, |
38, 18, 38, -1, 38, 19, 38, -1, 17, 38, |
42, 13, 42, 0, 42, 12, 42, 0, 42, 14, |
-1, 28, 38, 29, -1, 39, -1, 39, 20, 42, |
42, 0, 42, 9, 42, 0, 42, 10, 42, 0, |
-1, 39, 20, 17, 42, -1, 40, -1, 41, -1, |
42, 18, 8, 0, 42, 18, 15, 8, 0, 6, |
45, 13, 45, -1, 45, 15, 45, -1, 45, 14, |
0, 7, 0, 19, 0, 19, 0, 40, 0, 3, |
45, -1, 45, 16, 45, -1, 45, 11, 45, -1, |
0, 4, 0, 5, 0, 39, 0 |
45, 12, 45, -1, 43, 9, 44, -1, 45, 20, |
|
8, -1, 45, 20, 17, 8, -1, 6, -1, 7, |
|
-1, 21, -1, 21, 10, 21, -1, 21, -1, 43, |
|
-1, 3, -1, 4, -1, 5, -1, 42, -1 |
}; | }; |
| |
|
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ |
|
static const yytype_uint16 yyrline[] = |
|
{ |
|
0, 160, 160, 166, 172, 176, 182, 186, 192, 196, |
|
202, 209, 215, 220, 225, 231, 235, 239, 244, 253, |
|
257, 263, 268, 273, 278, 283, 288, 293, 303, 308, |
|
315, 319, 332, 337, 349, 356, 362, 367, 372, 377 |
|
}; |
#endif | #endif |
| |
#if YYDEBUG != 0 |
#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE |
static const short yyrline[] = { 0, |
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. |
130, 136, 142, 146, 152, 156, 162, 166, 172, 179, |
First, the terminals, then, starting at YYNTOKENS, nonterminals. */ |
185, 190, 195, 201, 205, 209, 214, 223, 227, 233, |
static const char *const yytname[] = |
238, 243, 248, 253, 258, 265, 270, 277, 281, 287, |
{ |
293, 300, 305, 310, 315, 320 |
"$end", "error", "$undefined", "TOK_INTEGER", "TOK_DOUBLE", |
|
"TOK_STRING", "TOK_TRUE", "TOK_FALSE", "TOK_NULL", "TOK_ISA", "TOK_DOT", |
|
"TOK_EQ", "TOK_NE", "TOK_LT", "TOK_LE", "TOK_GT", "TOK_GE", "TOK_NOT", |
|
"TOK_OR", "TOK_AND", "TOK_IS", "TOK_IDENTIFIER", "TOK_SELECT", |
|
"TOK_WHERE", "TOK_FROM", "TOK_UNEXPECTED_CHAR", "'*'", "','", "'('", |
|
"')'", "$accept", "start", "selectStatement", "selectList", |
|
"propertyList", "selectExpression", "fromClause", "whereClause", |
|
"searchCondition", "predicate", "comparisonPredicate", "nullPredicate", |
|
"truthValue", "propertyName", "className", "comparisonTerm", 0 |
}; | }; |
|
#endif |
| |
static const char * const yytname[] = { "$","error","$undefined.","TOK_INTEGER", |
# ifdef YYPRINT |
"TOK_DOUBLE","TOK_STRING","TOK_TRUE","TOK_FALSE","TOK_NULL","TOK_EQ","TOK_NE", |
/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to |
"TOK_LT","TOK_LE","TOK_GT","TOK_GE","TOK_NOT","TOK_OR","TOK_AND","TOK_IS","TOK_IDENTIFIER", |
token YYLEX-NUM. */ |
"TOK_SELECT","TOK_WHERE","TOK_FROM","TOK_UNEXPECTED_CHAR","'*'","','","'('", |
static const yytype_uint16 yytoknum[] = |
"')'","start","selectStatement","selectList","propertyList","selectExpression", |
{ |
"fromClause","whereClause","searchCondition","predicate","comparisonPredicate", |
0, 256, 257, 258, 259, 260, 261, 262, 263, 264, |
"nullPredicate","truthValue","propertyName","className","comparisonTerm","" |
265, 266, 267, 268, 269, 270, 271, 272, 273, 274, |
|
275, 276, 277, 278, 279, 280, 42, 44, 40, 41 |
}; | }; |
#endif | #endif |
| |
static const short yyr1[] = { 0, |
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ |
28, 29, 30, 30, 31, 31, 32, 32, 33, 34, |
static const yytype_uint8 yyr1[] = |
35, 35, 35, 35, 35, 35, 35, 36, 36, 37, |
{ |
37, 37, 37, 37, 37, 38, 38, 39, 39, 40, |
0, 30, 31, 32, 33, 33, 34, 34, 35, 35, |
41, 42, 42, 42, 42, 42 |
36, 37, 38, 38, 38, 38, 38, 38, 38, 39, |
|
39, 40, 40, 40, 40, 40, 40, 40, 41, 41, |
|
42, 42, 43, 43, 44, 45, 45, 45, 45, 45 |
}; | }; |
| |
static const short yyr2[] = { 0, |
/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ |
1, 3, 1, 1, 1, 3, 2, 1, 2, 2, |
static const yytype_uint8 yyr2[] = |
3, 3, 2, 3, 1, 3, 4, 1, 1, 3, |
{ |
3, 3, 3, 3, 3, 3, 4, 1, 1, 1, |
0, 2, 1, 3, 1, 1, 1, 3, 2, 1, |
1, 1, 1, 1, 1, 1 |
2, 2, 3, 3, 2, 3, 1, 3, 4, 1, |
|
1, 3, 3, 3, 3, 3, 3, 3, 3, 4, |
|
1, 1, 1, 3, 1, 1, 1, 1, 1, 1 |
}; | }; |
| |
static const short yydefact[] = { 0, |
/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state |
0, 1, 30, 3, 0, 4, 5, 0, 2, 8, |
STATE-NUM when YYTABLE doesn't specify something else to do. Zero |
0, 31, 9, 0, 7, 6, 33, 34, 35, 28, |
means the default is an error. */ |
29, 0, 0, 10, 15, 18, 19, 36, 32, 0, |
static const yytype_uint8 yydefact[] = |
13, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
{ |
0, 0, 14, 11, 12, 0, 16, 24, 25, 20, |
0, 0, 0, 2, 32, 4, 0, 5, 6, 1, |
22, 21, 23, 26, 0, 17, 27, 0, 0, 0 |
0, 0, 3, 9, 0, 33, 34, 10, 0, 8, |
|
7, 36, 37, 38, 30, 31, 0, 0, 11, 16, |
|
19, 20, 39, 35, 0, 14, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 15, 12, |
|
13, 0, 17, 27, 35, 25, 26, 21, 23, 22, |
|
24, 28, 0, 18, 29 |
}; | }; |
| |
static const short yydefgoto[] = { 58, |
/* YYDEFGOTO[NTERM-NUM]. */ |
2, 5, 6, 9, 10, 15, 24, 25, 26, 27, |
static const yytype_int8 yydefgoto[] = |
28, 29, 13, 30 |
{ |
|
-1, 2, 3, 6, 7, 12, 13, 19, 28, 29, |
|
30, 31, 32, 54, 17, 34 |
}; | }; |
| |
static const short yypact[] = { -5, |
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing |
18,-32768,-32768,-32768, 5, 16,-32768, 24,-32768, 33, |
STATE-NUM. */ |
26,-32768,-32768, -3,-32768,-32768,-32768,-32768,-32768,-32768, |
#define YYPACT_NINF -38 |
-32768, -3, -3, 23, 37,-32768,-32768,-32768,-32768, 20, |
static const yytype_int8 yypact[] = |
-32768, 1, -3, -3, 29, 2, 2, 2, 2, 2, |
{ |
2, 11,-32768, 39,-32768, 46,-32768,-32768,-32768,-32768, |
-21, -10, 15, -38, 25, -38, 17, -8, -38, -38, |
-32768,-32768,-32768,-32768, 49,-32768,-32768, 58, 59,-32768 |
28, 39, -38, 38, 41, -38, -38, -38, 1, -38, |
|
-38, -38, -38, -38, -38, -38, 1, 1, 5, 43, |
|
-38, -38, -38, 55, 31, -38, 9, 1, 1, 33, |
|
39, 27, 27, 27, 27, 27, 27, -5, -38, 46, |
|
-38, 52, -38, -38, -38, -38, -38, -38, -38, -38, |
|
-38, -38, 58, -38, -38 |
}; | }; |
| |
static const short yypgoto[] = {-32768, |
/* YYPGOTO[NTERM-NUM]. */ |
-32768,-32768,-32768,-32768,-32768,-32768, -9,-32768,-32768,-32768, |
static const yytype_int8 yypgoto[] = |
-24, 9,-32768, 10 |
{ |
|
-38, -38, -38, -38, -38, -38, -38, -38, -17, -38, |
|
-38, -38, -37, -1, 29, 11 |
}; | }; |
| |
|
/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If |
#define YYLAST 59 |
positive, shift that token. If negative, reduce the rule which |
|
number is the opposite. If zero, do what YYDEFACT says. |
|
If YYTABLE_NINF, syntax error. */ |
static const short yytable[] = { 17, |
#define YYTABLE_NINF -1 |
18, 19, 20, 21, 17, 18, 19, 20, 21, 7, |
static const yytype_uint8 yytable[] = |
47, 22, 31, 32, 1, 3, 33, 34, 54, 16, |
{ |
3, 56, 23, 44, 45, 55, 8, 43, 36, 37, |
8, 1, 52, 61, 21, 22, 23, 24, 25, 35, |
38, 39, 40, 41, 20, 21, 3, 42, 33, 34, |
36, 4, 62, 20, 63, 9, 5, 33, 26, 14, |
11, 4, 12, 46, 3, 48, 49, 50, 51, 52, |
49, 50, 4, 37, 38, 33, 33, 37, 38, 27, |
53, 20, 21, 14, 35, 34, 57, 59, 60 |
21, 22, 23, 24, 25, 10, 33, 33, 48, 24, |
|
25, 11, 41, 42, 43, 44, 45, 46, 4, 15, |
|
51, 47, 55, 56, 57, 58, 59, 60, 24, 25, |
|
16, 18, 4, 39, 40, 38, 64, 0, 0, 53 |
}; | }; |
| |
static const short yycheck[] = { 3, |
static const yytype_int8 yycheck[] = |
4, 5, 6, 7, 3, 4, 5, 6, 7, 1, |
{ |
35, 15, 22, 23, 20, 19, 16, 17, 8, 11, |
1, 22, 39, 8, 3, 4, 5, 6, 7, 26, |
19, 46, 26, 33, 34, 15, 22, 27, 9, 10, |
27, 21, 17, 14, 51, 0, 26, 18, 17, 27, |
11, 12, 13, 14, 6, 7, 19, 18, 16, 17, |
37, 38, 21, 18, 19, 26, 27, 18, 19, 28, |
25, 24, 19, 15, 19, 36, 37, 38, 39, 40, |
3, 4, 5, 6, 7, 10, 37, 38, 29, 6, |
41, 6, 7, 21, 18, 17, 8, 0, 0 |
7, 24, 11, 12, 13, 14, 15, 16, 21, 21, |
|
17, 20, 41, 42, 43, 44, 45, 46, 6, 7, |
|
21, 23, 21, 20, 9, 19, 8, -1, -1, 40 |
}; | }; |
/* -*-C-*- Note some compilers choke on comments on `#line' lines. */ |
|
#line 3 "bison.simple" |
|
/* This file comes from bison-@bison_version@. */ |
|
|
|
/* Skeleton output parser for bison, |
|
Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc. |
|
|
|
This program is free software; you can redistribute it and/or modify |
|
it under the terms of the GNU General Public License as published by |
|
the Free Software Foundation; either version 2, or (at your option) |
|
any later version. |
|
|
|
This program is distributed in the hope that it will be useful, |
|
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
GNU General Public License for more details. |
|
|
|
You should have received a copy of the GNU General Public License |
|
along with this program; if not, write to the Free Software |
|
Foundation, Inc., 59 Temple Place - Suite 330, |
|
Boston, MA 02111-1307, USA. */ |
|
|
|
/* As a special exception, when this file is copied by Bison into a |
|
Bison output file, you may use that output file without restriction. |
|
This special exception was added by the Free Software Foundation |
|
in version 1.24 of Bison. */ |
|
|
|
/* This is the parser code that is written into each bison parser |
|
when the %semantic_parser declaration is not specified in the grammar. |
|
It was written by Richard Stallman by simplifying the hairy parser |
|
used when %semantic_parser is specified. */ |
|
|
|
#ifndef YYSTACK_USE_ALLOCA |
|
#ifdef alloca |
|
#define YYSTACK_USE_ALLOCA |
|
#else /* alloca not defined */ |
|
#ifdef __GNUC__ |
|
#define YYSTACK_USE_ALLOCA |
|
#define alloca __builtin_alloca |
|
#else /* not GNU C. */ |
|
#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386)) |
|
#define YYSTACK_USE_ALLOCA |
|
#include <alloca.h> |
|
#else /* not sparc */ |
|
/* We think this test detects Watcom and Microsoft C. */ |
|
/* This used to test MSDOS, but that is a bad idea |
|
since that symbol is in the user namespace. */ |
|
#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__) |
|
#if 0 /* No need for malloc.h, which pollutes the namespace; |
|
instead, just don't use alloca. */ |
|
#include <malloc.h> |
|
#endif |
|
#else /* not MSDOS, or __TURBOC__ */ |
|
#if defined(_AIX) |
|
/* I don't know what this was needed for, but it pollutes the namespace. |
|
So I turned it off. rms, 2 May 1997. */ |
|
/* #include <malloc.h> */ |
|
#pragma alloca |
|
#define YYSTACK_USE_ALLOCA |
|
#else /* not MSDOS, or __TURBOC__, or _AIX */ |
|
#if 0 |
|
#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up, |
|
and on HPUX 10. Eventually we can turn this on. */ |
|
#define YYSTACK_USE_ALLOCA |
|
#define alloca __builtin_alloca |
|
#endif /* __hpux */ |
|
#endif |
|
#endif /* not _AIX */ |
|
#endif /* not MSDOS, or __TURBOC__ */ |
|
#endif /* not sparc */ |
|
#endif /* not GNU C */ |
|
#endif /* alloca not defined */ |
|
#endif /* YYSTACK_USE_ALLOCA not defined */ |
|
| |
#ifdef YYSTACK_USE_ALLOCA |
/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing |
#define YYSTACK_ALLOC alloca |
symbol of state STATE-NUM. */ |
#else |
static const yytype_uint8 yystos[] = |
#define YYSTACK_ALLOC malloc |
{ |
#endif |
0, 22, 31, 32, 21, 26, 33, 34, 43, 0, |
|
10, 24, 35, 36, 27, 21, 21, 44, 23, 37, |
/* Note: there must be only one dollar sign in this file. |
43, 3, 4, 5, 6, 7, 17, 28, 38, 39, |
It is replaced by the list of actions, each action |
40, 41, 42, 43, 45, 38, 38, 18, 19, 20, |
as one case of the switch. */ |
9, 11, 12, 13, 14, 15, 16, 20, 29, 38, |
|
38, 17, 42, 44, 43, 45, 45, 45, 45, 45, |
|
45, 8, 17, 42, 8 |
|
}; |
| |
#define yyerrok (yyerrstatus = 0) | #define yyerrok (yyerrstatus = 0) |
#define yyclearin (yychar = YYEMPTY) | #define yyclearin (yychar = YYEMPTY) |
#define YYEMPTY -2 |
#define YYEMPTY (-2) |
#define YYEOF 0 | #define YYEOF 0 |
|
|
#define YYACCEPT goto yyacceptlab | #define YYACCEPT goto yyacceptlab |
#define YYABORT goto yyabortlab | #define YYABORT goto yyabortlab |
#define YYERROR goto yyerrlab1 |
#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. |
/* 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. */ | Once GCC version 2 has supplanted version 1, this can go. */ |
|
|
#define YYFAIL goto yyerrlab | #define YYFAIL goto yyerrlab |
|
|
#define YYRECOVERING() (!!yyerrstatus) | #define YYRECOVERING() (!!yyerrstatus) |
#define YYBACKUP(token, value) \ |
|
|
#define YYBACKUP(Token, Value) \ |
do \ | do \ |
if (yychar == YYEMPTY && yylen == 1) \ | if (yychar == YYEMPTY && yylen == 1) \ |
{ yychar = (token), yylval = (value); \ |
{ \ |
yychar1 = YYTRANSLATE (yychar); \ |
yychar = (Token); \ |
YYPOPSTACK; \ |
yylval = (Value); \ |
|
yytoken = YYTRANSLATE (yychar); \ |
|
YYPOPSTACK (1); \ |
goto yybackup; \ | goto yybackup; \ |
} \ | } \ |
else \ | else \ |
{ yyerror ("syntax error: cannot back up"); YYERROR; } \ |
{ \ |
while (0) |
yyerror (YY_("syntax error: cannot back up")); \ |
|
YYERROR; \ |
|
} \ |
|
while (YYID (0)) |
|
|
| |
#define YYTERROR 1 | #define YYTERROR 1 |
#define YYERRCODE 256 | #define YYERRCODE 256 |
| |
#ifndef YYPURE |
|
#define YYLEX yylex() |
/* 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 | #endif |
| |
#ifdef YYPURE |
|
#ifdef YYLSP_NEEDED |
/* YY_LOCATION_PRINT -- Print the location on the stream. |
#ifdef YYLEX_PARAM |
This macro was not mandated originally: define only if we know |
#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM) |
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 | #else |
#define YYLEX yylex(&yylval, &yylloc) |
# define YY_LOCATION_PRINT(File, Loc) ((void) 0) |
#endif | #endif |
#else /* not YYLSP_NEEDED */ |
#endif |
|
|
|
|
|
/* YYLEX -- calling `yylex' with the right arguments. */ |
|
|
#ifdef YYLEX_PARAM | #ifdef YYLEX_PARAM |
#define YYLEX yylex(&yylval, YYLEX_PARAM) |
# define YYLEX yylex (YYLEX_PARAM) |
#else | #else |
#define YYLEX yylex(&yylval) |
# define YYLEX yylex () |
#endif |
|
#endif /* not YYLSP_NEEDED */ |
|
#endif | #endif |
| |
/* If nonreentrant, generate the variables here */ |
/* Enable debugging if requested. */ |
|
#if YYDEBUG |
|
|
|
# ifndef YYFPRINTF |
|
# include <stdio.h> /* INFRINGES ON USER NAME SPACE */ |
|
# define YYFPRINTF fprintf |
|
# endif |
|
|
|
# define YYDPRINTF(Args) \ |
|
do { \ |
|
if (yydebug) \ |
|
YYFPRINTF Args; \ |
|
} while (YYID (0)) |
|
|
|
# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \ |
|
do { \ |
|
if (yydebug) \ |
|
{ \ |
|
YYFPRINTF (stderr, "%s ", Title); \ |
|
yy_symbol_print (stderr, \ |
|
Type, Value); \ |
|
YYFPRINTF (stderr, "\n"); \ |
|
} \ |
|
} while (YYID (0)) |
|
|
|
|
|
/*--------------------------------. |
|
| Print this symbol on YYOUTPUT. | |
|
`--------------------------------*/ |
|
|
|
/*ARGSUSED*/ |
|
#if (defined __STDC__ || defined __C99__FUNC__ \ |
|
|| defined __cplusplus || defined _MSC_VER) |
|
static void |
|
yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) |
|
#else |
|
static void |
|
yy_symbol_value_print (yyoutput, yytype, yyvaluep) |
|
FILE *yyoutput; |
|
int yytype; |
|
YYSTYPE const * const yyvaluep; |
|
#endif |
|
{ |
|
if (!yyvaluep) |
|
return; |
|
# ifdef YYPRINT |
|
if (yytype < YYNTOKENS) |
|
YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); |
|
# else |
|
YYUSE (yyoutput); |
|
# endif |
|
switch (yytype) |
|
{ |
|
default: |
|
break; |
|
} |
|
} |
| |
#ifndef YYPURE |
|
| |
int yychar; /* the lookahead symbol */ |
/*--------------------------------. |
YYSTYPE yylval; /* the semantic value of the */ |
| Print this symbol on YYOUTPUT. | |
/* lookahead symbol */ |
`--------------------------------*/ |
| |
#ifdef YYLSP_NEEDED |
#if (defined __STDC__ || defined __C99__FUNC__ \ |
YYLTYPE yylloc; /* location data for the lookahead */ |
|| defined __cplusplus || defined _MSC_VER) |
/* symbol */ |
static void |
|
yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep) |
|
#else |
|
static void |
|
yy_symbol_print (yyoutput, yytype, yyvaluep) |
|
FILE *yyoutput; |
|
int yytype; |
|
YYSTYPE const * const yyvaluep; |
#endif | #endif |
|
{ |
|
if (yytype < YYNTOKENS) |
|
YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); |
|
else |
|
YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); |
|
|
|
yy_symbol_value_print (yyoutput, yytype, yyvaluep); |
|
YYFPRINTF (yyoutput, ")"); |
|
} |
| |
int yynerrs; /* number of parse errors so far */ |
/*------------------------------------------------------------------. |
#endif /* not YYPURE */ |
| yy_stack_print -- Print the state stack from its BOTTOM up to its | |
|
| TOP (included). | |
|
`------------------------------------------------------------------*/ |
| |
#if YYDEBUG != 0 |
#if (defined __STDC__ || defined __C99__FUNC__ \ |
int yydebug; /* nonzero means print parse trace */ |
|| defined __cplusplus || defined _MSC_VER) |
/* Since this is uninitialized, it does not stop multiple parsers |
static void |
from coexisting. */ |
yy_stack_print (yytype_int16 *bottom, yytype_int16 *top) |
|
#else |
|
static void |
|
yy_stack_print (bottom, top) |
|
yytype_int16 *bottom; |
|
yytype_int16 *top; |
#endif | #endif |
|
{ |
|
YYFPRINTF (stderr, "Stack now"); |
|
for (; bottom <= top; ++bottom) |
|
YYFPRINTF (stderr, " %d", *bottom); |
|
YYFPRINTF (stderr, "\n"); |
|
} |
|
|
|
# define YY_STACK_PRINT(Bottom, Top) \ |
|
do { \ |
|
if (yydebug) \ |
|
yy_stack_print ((Bottom), (Top)); \ |
|
} while (YYID (0)) |
| |
/* YYINITDEPTH indicates the initial size of the parser's stacks */ |
|
| |
|
/*------------------------------------------------. |
|
| 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 |
|
{ |
|
int yynrhs = yyr2[yyrule]; |
|
int yyi; |
|
unsigned long int yylno = yyrline[yyrule]; |
|
YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n", |
|
yyrule - 1, yylno); |
|
/* The symbols being reduced. */ |
|
for (yyi = 0; yyi < yynrhs; yyi++) |
|
{ |
|
fprintf (stderr, " $%d = ", yyi + 1); |
|
yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi], |
|
&(yyvsp[(yyi + 1) - (yynrhs)]) |
|
); |
|
fprintf (stderr, "\n"); |
|
} |
|
} |
|
|
|
# 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 | #ifndef YYINITDEPTH |
#define YYINITDEPTH 200 | #define YYINITDEPTH 200 |
#endif | #endif |
| |
/* YYMAXDEPTH is the maximum size the stacks can grow to |
/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only |
(effective only if the built-in stack extension method is used). */ |
if the built-in stack extension method is used). |
| |
#if YYMAXDEPTH == 0 |
Do not make this value too large; the results are undefined if |
#undef YYMAXDEPTH |
YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) |
#endif |
evaluated with infinite-precision integer arithmetic. */ |
| |
#ifndef YYMAXDEPTH | #ifndef YYMAXDEPTH |
#define YYMAXDEPTH 10000 | #define YYMAXDEPTH 10000 |
#endif | #endif |
| |
/* Define __yy_memcpy. Note that the size argument |
|
should be passed with type unsigned int, because that is what the non-GCC |
|
definitions require. With GCC, __builtin_memcpy takes an arg |
|
of type size_t, but it can handle unsigned int. */ |
|
|
|
#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */ |
|
#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT) |
|
#else /* not GNU C or C++ */ |
|
#ifndef __cplusplus |
|
| |
/* This is the most reliable way to avoid incompatibilities |
|
in available built-in functions on various systems. */ |
#if YYERROR_VERBOSE |
|
|
|
# ifndef yystrlen |
|
# if defined __GLIBC__ && defined _STRING_H |
|
# define yystrlen strlen |
|
# else |
|
/* Return the length of YYSTR. */ |
|
#if (defined __STDC__ || defined __C99__FUNC__ \ |
|
|| defined __cplusplus || defined _MSC_VER) |
|
static YYSIZE_T |
|
yystrlen (const char *yystr) |
|
#else |
|
static YYSIZE_T |
|
yystrlen (yystr) |
|
const char *yystr; |
|
#endif |
|
{ |
|
YYSIZE_T yylen; |
|
for (yylen = 0; yystr[yylen]; yylen++) |
|
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 |
|
{ |
|
char *yyd = yydest; |
|
const char *yys = yysrc; |
|
|
|
while ((*yyd++ = *yys++) != '\0') |
|
continue; |
|
|
|
return yyd - 1; |
|
} |
|
# endif |
|
# endif |
|
|
|
# ifndef yytnamerr |
|
/* Copy to YYRES the contents of YYSTR after stripping away unnecessary |
|
quotes and backslashes, so that it's suitable for yyerror. The |
|
heuristic is that double-quoting is unnecessary unless the string |
|
contains an apostrophe, a comma, or backslash (other than |
|
backslash-backslash). YYSTR is taken from yytname. If YYRES is |
|
null, do not copy; instead, return the length of what the result |
|
would have been. */ |
|
static YYSIZE_T |
|
yytnamerr (char *yyres, const char *yystr) |
|
{ |
|
if (*yystr == '"') |
|
{ |
|
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 (! 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) |
|
{ |
|
int yyn = yypact[yystate]; |
|
|
|
if (! (YYPACT_NINF < yyn && yyn <= YYLAST)) |
|
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 |
|
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') |
|
{ |
|
if (*yyp == '%' && yyf[1] == 's' && yyi < yycount) |
|
{ |
|
yyp += yytnamerr (yyp, yyarg[yyi++]); |
|
yyf += 2; |
|
} |
|
else |
|
{ |
|
yyp++; |
|
yyf++; |
|
} |
|
} |
|
} |
|
return yysize; |
|
} |
|
} |
|
#endif /* YYERROR_VERBOSE */ |
|
|
|
|
|
/*-----------------------------------------------. |
|
| Release the memory associated to this symbol. | |
|
`-----------------------------------------------*/ |
|
|
|
/*ARGSUSED*/ |
|
#if (defined __STDC__ || defined __C99__FUNC__ \ |
|
|| defined __cplusplus || defined _MSC_VER) |
static void | static void |
__yy_memcpy (to, from, count) |
yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep) |
char *to; |
#else |
char *from; |
static void |
unsigned int count; |
yydestruct (yymsg, yytype, yyvaluep) |
|
const char *yymsg; |
|
int yytype; |
|
YYSTYPE *yyvaluep; |
|
#endif |
|
{ |
|
YYUSE (yyvaluep); |
|
|
|
if (!yymsg) |
|
yymsg = "Deleting"; |
|
YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp); |
|
|
|
switch (yytype) |
{ | { |
register char *f = from; |
|
register char *t = to; |
|
register int i = count; |
|
| |
while (i-- > 0) |
default: |
*t++ = *f++; |
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 */ |
|
|
| |
#else /* __cplusplus */ |
|
| |
/* This is the most reliable way to avoid incompatibilities |
/* The look-ahead symbol. */ |
in available built-in functions on various systems. */ |
int yychar; |
static void |
|
__yy_memcpy (char *to, char *from, unsigned int count) |
|
{ |
|
register char *t = to; |
|
register char *f = from; |
|
register int i = count; |
|
| |
while (i-- > 0) |
/* The semantic value of the look-ahead symbol. */ |
*t++ = *f++; |
YYSTYPE yylval; |
} |
|
| |
#endif |
/* Number of syntax errors so far. */ |
#endif |
int yynerrs; |
| |
#line 217 "bison.simple" |
|
| |
/* The user can define YYPARSE_PARAM as the name of an argument to be passed |
|
into yyparse. The argument should have type void *. |
|
It should actually point to an object. |
|
Grammar actions can access the variable by casting it |
|
to the proper pointer type. */ |
|
| |
#ifdef YYPARSE_PARAM |
/*----------. |
#ifdef __cplusplus |
| yyparse. | |
#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM |
`----------*/ |
#define YYPARSE_PARAM_DECL |
|
#else /* not __cplusplus */ |
|
#define YYPARSE_PARAM_ARG YYPARSE_PARAM |
|
#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM; |
|
#endif /* not __cplusplus */ |
|
#else /* not YYPARSE_PARAM */ |
|
#define YYPARSE_PARAM_ARG |
|
#define YYPARSE_PARAM_DECL |
|
#endif /* not YYPARSE_PARAM */ |
|
| |
/* Prevent warning if -Wstrict-prototypes. */ |
|
#ifdef __GNUC__ |
|
#ifdef YYPARSE_PARAM | #ifdef YYPARSE_PARAM |
int yyparse (void *); |
#if (defined __STDC__ || defined __C99__FUNC__ \ |
|
|| defined __cplusplus || defined _MSC_VER) |
|
int |
|
yyparse (void *YYPARSE_PARAM) |
#else | #else |
int yyparse (void); |
int |
#endif |
yyparse (YYPARSE_PARAM) |
|
void *YYPARSE_PARAM; |
#endif | #endif |
|
#else /* ! YYPARSE_PARAM */ |
|
#if (defined __STDC__ || defined __C99__FUNC__ \ |
|
|| defined __cplusplus || defined _MSC_VER) |
int | int |
yyparse(YYPARSE_PARAM_ARG) |
yyparse (void) |
YYPARSE_PARAM_DECL |
#else |
|
int |
|
yyparse () |
|
|
|
#endif |
|
#endif |
{ | { |
register int yystate; |
|
register int yyn; |
|
register short *yyssp; |
|
register YYSTYPE *yyvsp; |
|
int yyerrstatus; /* number of tokens to shift before error messages enabled */ |
|
int yychar1 = 0; /* lookahead token as an internal (translated) token number */ |
|
| |
short yyssa[YYINITDEPTH]; /* the state stack */ |
int yystate; |
YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */ |
int yyn; |
|
int yyresult; |
|
/* Number of tokens to shift before error messages enabled. */ |
|
int yyerrstatus; |
|
/* Look-ahead token as an internal (translated) token number. */ |
|
int yytoken = 0; |
|
#if YYERROR_VERBOSE |
|
/* Buffer for error messages, and its allocated size. */ |
|
char yymsgbuf[128]; |
|
char *yymsg = yymsgbuf; |
|
YYSIZE_T yymsg_alloc = sizeof yymsgbuf; |
|
#endif |
| |
short *yyss = yyssa; /* refer to the stacks thru separate pointers */ |
/* Three stacks and their tools: |
YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */ |
`yyss': related to states, |
|
`yyvs': related to semantic values, |
|
`yyls': related to locations. |
| |
#ifdef YYLSP_NEEDED |
Refer to the stacks thru separate pointers, to allow yyoverflow |
YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */ |
to reallocate them elsewhere. */ |
YYLTYPE *yyls = yylsa; |
|
YYLTYPE *yylsp; |
|
| |
#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) |
/* The state stack. */ |
#else |
yytype_int16 yyssa[YYINITDEPTH]; |
#define YYPOPSTACK (yyvsp--, yyssp--) |
yytype_int16 *yyss = yyssa; |
#endif |
yytype_int16 *yyssp; |
| |
int yystacksize = YYINITDEPTH; |
/* The semantic value stack. */ |
int yyfree_stacks = 0; |
YYSTYPE yyvsa[YYINITDEPTH]; |
|
YYSTYPE *yyvs = yyvsa; |
|
YYSTYPE *yyvsp; |
| |
#ifdef YYPURE |
|
int yychar; |
|
YYSTYPE yylval; |
|
int yynerrs; |
|
#ifdef YYLSP_NEEDED |
|
YYLTYPE yylloc; |
|
#endif |
|
#endif |
|
| |
YYSTYPE yyval; /* the variable used to return */ |
|
/* semantic values from the action */ |
|
/* routines */ |
|
| |
int yylen; |
#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; |
| |
#if YYDEBUG != 0 |
|
if (yydebug) |
/* The number of symbols on the RHS of the reduced rule. |
fprintf(stderr, "Starting parse\n"); |
Keep to zero when no symbol should be popped. */ |
#endif |
int yylen = 0; |
|
|
|
YYDPRINTF ((stderr, "Starting parse\n")); |
| |
yystate = 0; | yystate = 0; |
yyerrstatus = 0; | yyerrstatus = 0; |
|
|
so that they stay on the same level as the state stack. | so that they stay on the same level as the state stack. |
The wasted elements are never initialized. */ | The wasted elements are never initialized. */ |
| |
yyssp = yyss - 1; |
yyssp = yyss; |
yyvsp = yyvs; | yyvsp = yyvs; |
#ifdef YYLSP_NEEDED |
|
yylsp = yyls; |
|
#endif |
|
| |
/* Push a new state, which is found in yystate . */ |
goto yysetstate; |
/* In all cases, when you get here, the value and location stacks |
|
have just been pushed. so pushing a state here evens the stacks. */ |
/*------------------------------------------------------------. |
|
| yynewstate -- Push a new state, which is found in yystate. | |
|
`------------------------------------------------------------*/ |
yynewstate: | 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++; |
| |
*++yyssp = yystate; |
yysetstate: |
|
*yyssp = yystate; |
| |
if (yyssp >= yyss + yystacksize - 1) |
if (yyss + yystacksize - 1 <= yyssp) |
{ | { |
/* Give user a chance to reallocate the stack */ |
|
/* Use copies of these so that the &'s don't force the real ones into memory. */ |
|
YYSTYPE *yyvs1 = yyvs; |
|
short *yyss1 = yyss; |
|
#ifdef YYLSP_NEEDED |
|
YYLTYPE *yyls1 = yyls; |
|
#endif |
|
|
|
/* Get the current used size of the three stacks, in elements. */ | /* Get the current used size of the three stacks, in elements. */ |
int size = yyssp - yyss + 1; |
YYSIZE_T yysize = yyssp - yyss + 1; |
| |
#ifdef yyoverflow | #ifdef yyoverflow |
/* Each stack pointer address is followed by the size of |
{ |
the data in use in that stack, in bytes. */ |
/* Give user a chance to reallocate the stack. Use copies of |
#ifdef YYLSP_NEEDED |
these so that the &'s don't force the real ones into |
/* This used to be a conditional around just the two extra args, |
memory. */ |
but that might be undefined if yyoverflow is a macro. */ |
YYSTYPE *yyvs1 = yyvs; |
yyoverflow("parser stack overflow", |
yytype_int16 *yyss1 = yyss; |
&yyss1, size * sizeof (*yyssp), |
|
&yyvs1, size * sizeof (*yyvsp), |
|
&yyls1, size * sizeof (*yylsp), |
/* Each stack pointer address is followed by the size of the |
&yystacksize); |
data in use in that stack, in bytes. This used to be a |
#else |
conditional around just the two extra args, but that might |
yyoverflow("parser stack overflow", |
be undefined if yyoverflow is a macro. */ |
&yyss1, size * sizeof (*yyssp), |
yyoverflow (YY_("memory exhausted"), |
&yyvs1, size * sizeof (*yyvsp), |
&yyss1, yysize * sizeof (*yyssp), |
|
&yyvs1, yysize * sizeof (*yyvsp), |
|
|
&yystacksize); | &yystacksize); |
#endif |
|
| |
yyss = yyss1; yyvs = yyvs1; |
yyss = yyss1; |
#ifdef YYLSP_NEEDED |
yyvs = yyvs1; |
yyls = yyls1; |
} |
#endif |
|
#else /* no yyoverflow */ | #else /* no yyoverflow */ |
|
# ifndef YYSTACK_RELOCATE |
|
goto yyexhaustedlab; |
|
# else |
/* Extend the stack our own way. */ | /* Extend the stack our own way. */ |
if (yystacksize >= YYMAXDEPTH) |
if (YYMAXDEPTH <= yystacksize) |
{ |
goto yyexhaustedlab; |
yyerror("parser stack overflow"); |
|
if (yyfree_stacks) |
|
{ |
|
free (yyss); |
|
free (yyvs); |
|
#ifdef YYLSP_NEEDED |
|
free (yyls); |
|
#endif |
|
} |
|
return 2; |
|
} |
|
yystacksize *= 2; | yystacksize *= 2; |
if (yystacksize > YYMAXDEPTH) |
if (YYMAXDEPTH < yystacksize) |
yystacksize = YYMAXDEPTH; | yystacksize = YYMAXDEPTH; |
#ifndef YYSTACK_USE_ALLOCA |
|
yyfree_stacks = 1; |
{ |
#endif |
yytype_int16 *yyss1 = yyss; |
yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp)); |
union yyalloc *yyptr = |
__yy_memcpy ((char *)yyss, (char *)yyss1, |
(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); |
size * (unsigned int) sizeof (*yyssp)); |
if (! yyptr) |
yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp)); |
goto yyexhaustedlab; |
__yy_memcpy ((char *)yyvs, (char *)yyvs1, |
YYSTACK_RELOCATE (yyss); |
size * (unsigned int) sizeof (*yyvsp)); |
YYSTACK_RELOCATE (yyvs); |
#ifdef YYLSP_NEEDED |
|
yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp)); |
# undef YYSTACK_RELOCATE |
__yy_memcpy ((char *)yyls, (char *)yyls1, |
if (yyss1 != yyssa) |
size * (unsigned int) sizeof (*yylsp)); |
YYSTACK_FREE (yyss1); |
|
} |
#endif | #endif |
#endif /* no yyoverflow */ | #endif /* no yyoverflow */ |
| |
yyssp = yyss + size - 1; |
yyssp = yyss + yysize - 1; |
yyvsp = yyvs + size - 1; |
yyvsp = yyvs + yysize - 1; |
#ifdef YYLSP_NEEDED |
|
yylsp = yyls + size - 1; |
|
#endif |
|
| |
#if YYDEBUG != 0 |
|
if (yydebug) |
|
fprintf(stderr, "Stack size increased to %d\n", yystacksize); |
|
#endif |
|
| |
if (yyssp >= yyss + yystacksize - 1) |
YYDPRINTF ((stderr, "Stack size increased to %lu\n", |
|
(unsigned long int) yystacksize)); |
|
|
|
if (yyss + yystacksize - 1 <= yyssp) |
YYABORT; | YYABORT; |
} | } |
| |
#if YYDEBUG != 0 |
YYDPRINTF ((stderr, "Entering state %d\n", yystate)); |
if (yydebug) |
|
fprintf(stderr, "Entering state %d\n", yystate); |
|
#endif |
|
| |
goto yybackup; | goto yybackup; |
yybackup: |
|
| |
/* Do appropriate processing given the current state. */ |
/*-----------. |
/* Read a lookahead token if we need one and don't already have one. */ |
| yybackup. | |
/* yyresume: */ |
`-----------*/ |
|
yybackup: |
| |
/* First try to decide what to do without reference to lookahead token. */ |
/* 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]; | yyn = yypact[yystate]; |
if (yyn == YYFLAG) |
if (yyn == YYPACT_NINF) |
goto yydefault; | goto yydefault; |
| |
/* Not known => get a lookahead token if don't already have one. */ |
/* Not known => get a look-ahead token if don't already have one. */ |
|
|
/* yychar is either YYEMPTY or YYEOF |
|
or a valid token in external form. */ |
|
| |
|
/* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */ |
if (yychar == YYEMPTY) | if (yychar == YYEMPTY) |
{ | { |
#if YYDEBUG != 0 |
YYDPRINTF ((stderr, "Reading a token: ")); |
if (yydebug) |
|
fprintf(stderr, "Reading a token: "); |
|
#endif |
|
yychar = YYLEX; | yychar = YYLEX; |
} | } |
| |
/* Convert token to internal form (in yychar1) for indexing tables with */ |
if (yychar <= YYEOF) |
|
|
if (yychar <= 0) /* This means end of input. */ |
|
{ | { |
yychar1 = 0; |
yychar = yytoken = YYEOF; |
yychar = YYEOF; /* Don't call YYLEX any more */ |
YYDPRINTF ((stderr, "Now at end of input.\n")); |
|
|
#if YYDEBUG != 0 |
|
if (yydebug) |
|
fprintf(stderr, "Now at end of input.\n"); |
|
#endif |
|
} | } |
else | else |
{ | { |
yychar1 = YYTRANSLATE(yychar); |
yytoken = YYTRANSLATE (yychar); |
|
YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc); |
#if YYDEBUG != 0 |
|
if (yydebug) |
|
{ |
|
fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]); |
|
/* Give the individual parser a way to print the precise meaning |
|
of a token, for further debugging info. */ |
|
#ifdef YYPRINT |
|
YYPRINT (stderr, yychar, yylval); |
|
#endif |
|
fprintf (stderr, ")\n"); |
|
} |
|
#endif |
|
} | } |
| |
yyn += yychar1; |
/* If the proper action on seeing token YYTOKEN is to reduce or to |
if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) |
detect an error, take that action. */ |
|
yyn += yytoken; |
|
if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) |
goto yydefault; | goto yydefault; |
|
|
yyn = yytable[yyn]; | yyn = yytable[yyn]; |
|
if (yyn <= 0) |
/* yyn is what to do for this token type in this state. |
|
Negative => reduce, -yyn is rule number. |
|
Positive => shift, yyn is new state. |
|
New state is final state => don't bother to shift, |
|
just return success. |
|
0, or most negative number => error. */ |
|
|
|
if (yyn < 0) |
|
{ | { |
if (yyn == YYFLAG) |
if (yyn == 0 || yyn == YYTABLE_NINF) |
goto yyerrlab; | goto yyerrlab; |
yyn = -yyn; | yyn = -yyn; |
goto yyreduce; | goto yyreduce; |
} | } |
else if (yyn == 0) |
|
goto yyerrlab; |
|
| |
if (yyn == YYFINAL) | if (yyn == YYFINAL) |
YYACCEPT; | YYACCEPT; |
| |
/* Shift the lookahead token. */ |
/* Count tokens shifted since error; after three, turn off error |
|
status. */ |
|
if (yyerrstatus) |
|
yyerrstatus--; |
| |
#if YYDEBUG != 0 |
/* Shift the look-ahead token. */ |
if (yydebug) |
YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc); |
fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]); |
|
#endif |
|
| |
/* Discard the token being shifted unless it is eof. */ |
/* Discard the shifted token unless it is eof. */ |
if (yychar != YYEOF) | if (yychar != YYEOF) |
yychar = YYEMPTY; | yychar = YYEMPTY; |
| |
|
yystate = yyn; |
*++yyvsp = yylval; | *++yyvsp = yylval; |
#ifdef YYLSP_NEEDED |
|
*++yylsp = yylloc; |
|
#endif |
|
|
|
/* count tokens shifted since error; after three, turn off error status. */ |
|
if (yyerrstatus) yyerrstatus--; |
|
| |
yystate = yyn; |
|
goto yynewstate; | goto yynewstate; |
| |
/* Do the default action for the current state. */ |
|
yydefault: |
|
| |
|
/*-----------------------------------------------------------. |
|
| yydefault -- do the default action for the current state. | |
|
`-----------------------------------------------------------*/ |
|
yydefault: |
yyn = yydefact[yystate]; | yyn = yydefact[yystate]; |
if (yyn == 0) | if (yyn == 0) |
goto yyerrlab; | goto yyerrlab; |
|
goto yyreduce; |
| |
/* Do a reduction. yyn is the number of a rule to reduce with. */ |
|
|
/*-----------------------------. |
|
| yyreduce -- Do a reduction. | |
|
`-----------------------------*/ |
yyreduce: | yyreduce: |
|
/* yyn is the number of a rule to reduce with. */ |
yylen = yyr2[yyn]; | yylen = yyr2[yyn]; |
if (yylen > 0) |
|
yyval = yyvsp[1-yylen]; /* implement default value of the action */ |
|
|
|
#if YYDEBUG != 0 |
|
if (yydebug) |
|
{ |
|
int i; |
|
| |
fprintf (stderr, "Reducing via rule %d (line %d), ", |
/* If YYLEN is nonzero, implement the default value of the action: |
yyn, yyrline[yyn]); |
`$$ = $1'. |
|
|
/* Print the symbols being reduced, and their result. */ |
|
for (i = yyprhs[yyn]; yyrhs[i] > 0; i++) |
|
fprintf (stderr, "%s ", yytname[yyrhs[i]]); |
|
fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]); |
|
} |
|
#endif |
|
| |
|
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]; |
| |
switch (yyn) { |
|
| |
case 1: |
YY_REDUCE_PRINT (yyn); |
#line 131 "wql.y" |
switch (yyn) |
{ | { |
WQL_TRACE(("YACC: start\n")); |
|
; |
|
break;} |
|
case 2: | case 2: |
#line 137 "wql.y" |
#line 161 "WQL.y" |
{ | { |
|
WQL_TRACE(("YACC: start\n")); |
|
;} |
|
break; |
| |
; |
|
break;} |
|
case 3: | case 3: |
#line 143 "wql.y" |
#line 167 "WQL.y" |
{ | { |
globalParserState->statement->appendPropertyName("*"); |
|
; |
;} |
break;} |
break; |
|
|
case 4: | case 4: |
#line 147 "wql.y" |
#line 173 "WQL.y" |
{ | { |
|
globalParserState->statement->setAllProperties(true); |
|
;} |
|
break; |
| |
; |
|
break;} |
|
case 5: | case 5: |
#line 153 "wql.y" |
#line 177 "WQL.y" |
{ | { |
globalParserState->statement->appendPropertyName(yyvsp[0].strValue); |
|
; |
;} |
break;} |
break; |
|
|
case 6: | case 6: |
#line 157 "wql.y" |
#line 183 "WQL.y" |
{ | { |
globalParserState->statement->appendPropertyName(yyvsp[0].strValue); |
globalParserState->statement->appendSelectPropertyName(CIMName((yyvsp[(1) - (1)].strValue))); |
; |
;} |
break;} |
break; |
|
|
case 7: | case 7: |
#line 163 "wql.y" |
#line 187 "WQL.y" |
{ | { |
|
globalParserState->statement->appendSelectPropertyName(CIMName((yyvsp[(3) - (3)].strValue))); |
|
;} |
|
break; |
| |
; |
|
break;} |
|
case 8: | case 8: |
#line 167 "wql.y" |
#line 193 "WQL.y" |
{ | { |
| |
; |
;} |
break;} |
break; |
|
|
case 9: | case 9: |
#line 173 "wql.y" |
#line 197 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: fromClause: TOK_FROM className(%s)\n", yyvsp[0].strValue)); |
|
globalParserState->statement->setClassName(yyvsp[0].strValue); |
;} |
; |
break; |
break;} |
|
case 10: | case 10: |
#line 180 "wql.y" |
#line 203 "WQL.y" |
{ | { |
|
WQL_TRACE(("YACC: fromClause: TOK_FROM className(%s)\n", (yyvsp[(2) - (2)].strValue))); |
|
globalParserState->statement->setClassName(CIMName((yyvsp[(2) - (2)].strValue))); |
|
;} |
|
break; |
| |
; |
|
break;} |
|
case 11: | case 11: |
#line 186 "wql.y" |
#line 210 "WQL.y" |
|
{ |
|
|
|
;} |
|
break; |
|
|
|
case 12: |
|
#line 216 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: TOK_OR\n")); | WQL_TRACE(("YACC: TOK_OR\n")); |
globalParserState->statement->appendOperation(WQL_OR); | globalParserState->statement->appendOperation(WQL_OR); |
; |
;} |
break;} |
break; |
case 12: |
|
#line 191 "wql.y" |
case 13: |
|
#line 221 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: TOK_AND\n")); | WQL_TRACE(("YACC: TOK_AND\n")); |
globalParserState->statement->appendOperation(WQL_AND); | globalParserState->statement->appendOperation(WQL_AND); |
; |
;} |
break;} |
break; |
case 13: |
|
#line 196 "wql.y" |
case 14: |
|
#line 226 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: TOK_NOT\n")); | WQL_TRACE(("YACC: TOK_NOT\n")); |
| |
globalParserState->statement->appendOperation(WQL_NOT); | globalParserState->statement->appendOperation(WQL_NOT); |
; |
;} |
break;} |
break; |
case 14: |
|
#line 202 "wql.y" |
|
{ |
|
| |
; |
|
break;} |
|
case 15: | case 15: |
#line 206 "wql.y" |
#line 232 "WQL.y" |
{ | { |
| |
; |
;} |
break;} |
break; |
|
|
case 16: | case 16: |
#line 210 "wql.y" |
#line 236 "WQL.y" |
{ | { |
WQLOperation op = yyvsp[0].intValue ? WQL_IS_TRUE : WQL_IS_FALSE; |
|
globalParserState->statement->appendOperation(op); |
;} |
; |
break; |
break;} |
|
case 17: | case 17: |
#line 215 "wql.y" |
#line 240 "WQL.y" |
{ | { |
WQLOperation op = yyvsp[0].intValue ? WQL_IS_NOT_TRUE : WQL_IS_NOT_FALSE; |
WQLOperation op = (yyvsp[(3) - (3)].intValue) ? WQL_IS_TRUE : WQL_IS_FALSE; |
globalParserState->statement->appendOperation(op); | globalParserState->statement->appendOperation(op); |
; |
;} |
break;} |
break; |
|
|
case 18: | case 18: |
#line 224 "wql.y" |
#line 245 "WQL.y" |
{ | { |
|
WQLOperation op = (yyvsp[(4) - (4)].intValue) ? WQL_IS_NOT_TRUE : WQL_IS_NOT_FALSE; |
|
globalParserState->statement->appendOperation(op); |
|
;} |
|
break; |
| |
; |
|
break;} |
|
case 19: | case 19: |
#line 228 "wql.y" |
#line 254 "WQL.y" |
{ | { |
| |
; |
;} |
break;} |
break; |
|
|
case 20: | case 20: |
#line 234 "wql.y" |
#line 258 "WQL.y" |
|
{ |
|
|
|
;} |
|
break; |
|
|
|
case 21: |
|
#line 264 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: TOK_LT\n")); | WQL_TRACE(("YACC: TOK_LT\n")); |
globalParserState->statement->appendOperation(WQL_LT); | globalParserState->statement->appendOperation(WQL_LT); |
; |
;} |
break;} |
break; |
case 21: |
|
#line 239 "wql.y" |
case 22: |
|
#line 269 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: TOK_GT\n")); | WQL_TRACE(("YACC: TOK_GT\n")); |
globalParserState->statement->appendOperation(WQL_GT); | globalParserState->statement->appendOperation(WQL_GT); |
; |
;} |
break;} |
break; |
case 22: |
|
#line 244 "wql.y" |
case 23: |
|
#line 274 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: TOK_LE\n")); | WQL_TRACE(("YACC: TOK_LE\n")); |
globalParserState->statement->appendOperation(WQL_LE); | globalParserState->statement->appendOperation(WQL_LE); |
; |
;} |
break;} |
break; |
case 23: |
|
#line 249 "wql.y" |
case 24: |
|
#line 279 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: TOK_GE\n")); | WQL_TRACE(("YACC: TOK_GE\n")); |
globalParserState->statement->appendOperation(WQL_GE); | globalParserState->statement->appendOperation(WQL_GE); |
; |
;} |
break;} |
break; |
case 24: |
|
#line 254 "wql.y" |
case 25: |
|
#line 284 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: TOK_EQ\n")); | WQL_TRACE(("YACC: TOK_EQ\n")); |
globalParserState->statement->appendOperation(WQL_EQ); | globalParserState->statement->appendOperation(WQL_EQ); |
; |
;} |
break;} |
break; |
case 25: |
|
#line 259 "wql.y" |
case 26: |
|
#line 289 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: TOK_NE\n")); | WQL_TRACE(("YACC: TOK_NE\n")); |
globalParserState->statement->appendOperation(WQL_NE); | globalParserState->statement->appendOperation(WQL_NE); |
; |
;} |
break;} |
break; |
case 26: |
|
#line 266 "wql.y" |
|
{ |
|
WQL_TRACE(("YACC: nullPredicate : comparisonTerm IS NULL\n")); |
|
globalParserState->statement->appendOperation(WQL_IS_NULL); |
|
; |
|
break;} |
|
case 27: | case 27: |
#line 271 "wql.y" |
#line 294 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: nullPredicate : comparisonTerm IS NOT NULL\n")); |
WQL_TRACE(("YACC: TOK_ISA\n")); |
globalParserState->statement->appendOperation(WQL_IS_NOT_NULL); |
#ifndef PEGASUS_SNIA_EXTENSIONS |
; |
// If SNIA tests, allow the ISA but do not pass className |
break;} |
yyerror("ISA Token Not Supported"); |
|
#endif |
|
;} |
|
break; |
|
|
case 28: | case 28: |
#line 278 "wql.y" |
#line 304 "WQL.y" |
{ | { |
yyval.intValue = 1; |
WQL_TRACE(("YACC: nullPredicate : comparisonTerm IS NULL\n")); |
; |
globalParserState->statement->appendOperation(WQL_IS_NULL); |
break;} |
;} |
|
break; |
|
|
case 29: | case 29: |
#line 282 "wql.y" |
#line 309 "WQL.y" |
{ | { |
yyval.intValue = 0; |
WQL_TRACE(("YACC: nullPredicate : comparisonTerm IS NOT NULL\n")); |
; |
globalParserState->statement->appendOperation(WQL_IS_NOT_NULL); |
break;} |
;} |
|
break; |
|
|
case 30: | case 30: |
#line 288 "wql.y" |
#line 316 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: propertyName : TOK_IDENTIFIER(%s)\n", yyvsp[0].strValue)); |
(yyval.intValue) = 1; |
yyval.strValue = yyvsp[0].strValue; |
;} |
; |
break; |
break;} |
|
case 31: | case 31: |
#line 294 "wql.y" |
#line 320 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: TOK_IDENTIFIER %s\n", yyvsp[0].strValue)); |
(yyval.intValue) = 0; |
yyval.strValue = yyvsp[0].strValue; |
;} |
; |
break; |
break;} |
|
case 32: | case 32: |
#line 301 "wql.y" |
#line 333 "WQL.y" |
{ | { |
globalParserState->statement->appendOperand( |
WQL_TRACE(("YACC: propertyName : TOK_IDENTIFIER(%s)\n", (yyvsp[(1) - (1)].strValue))); |
WQLOperand(yyvsp[0].strValue, WQLOperand::PROPERTY_NAME_TAG)); |
(yyval.strValue) = (yyvsp[(1) - (1)].strValue); |
; |
;} |
break;} |
break; |
|
|
case 33: | case 33: |
#line 306 "wql.y" |
#line 338 "WQL.y" |
{ | { |
globalParserState->statement->appendOperand( |
WQL_TRACE(("YACC: propertyName : TOK_IDENTIFIER(%s.%s)\n", (yyvsp[(1) - (3)].strValue), (yyvsp[(3) - (3)].strValue))); |
WQLOperand(yyvsp[0].intValue, WQLOperand::INTEGER_VALUE_TAG)); |
#ifdef PEGASUS_SNIA_EXTENSIONS |
; |
// Pass anything as a property name to fool parser for SNIA testing |
break;} |
(yyval.strValue) = strdup("dummy"); |
|
#else |
|
yyerror("Scoped (dotted) property names not supported"); |
|
#endif |
|
;} |
|
break; |
|
|
case 34: | case 34: |
#line 311 "wql.y" |
#line 350 "WQL.y" |
{ | { |
globalParserState->statement->appendOperand( |
WQL_TRACE(("YACC: TOK_IDENTIFIER %s\n", (yyvsp[(1) - (1)].strValue))); |
WQLOperand(yyvsp[0].doubleValue, WQLOperand::DOUBLE_VALUE_TAG)); |
(yyval.strValue) = (yyvsp[(1) - (1)].strValue); |
; |
;} |
break;} |
break; |
|
|
case 35: | case 35: |
#line 316 "wql.y" |
#line 357 "WQL.y" |
{ | { |
globalParserState->statement->appendOperand( | globalParserState->statement->appendOperand( |
WQLOperand(yyvsp[0].strValue, WQLOperand::STRING_VALUE_TAG)); |
WQLOperand((yyvsp[(1) - (1)].strValue), WQL_PROPERTY_NAME_TAG)); |
; |
globalParserState->statement->appendWherePropertyName(CIMName((yyvsp[(1) - (1)].strValue))); |
break;} |
;} |
|
break; |
|
|
case 36: | case 36: |
#line 321 "wql.y" |
#line 363 "WQL.y" |
{ | { |
globalParserState->statement->appendOperand( | globalParserState->statement->appendOperand( |
WQLOperand(yyvsp[0].intValue != 0, WQLOperand::BOOLEAN_VALUE_TAG)); |
WQLOperand((yyvsp[(1) - (1)].intValue), WQL_INTEGER_VALUE_TAG)); |
; |
;} |
break;} |
break; |
} |
|
/* the action file gets copied in in place of this dollarsign */ |
|
#line 543 "bison.simple" |
|
|
|
yyvsp -= yylen; |
|
yyssp -= yylen; |
|
#ifdef YYLSP_NEEDED |
|
yylsp -= yylen; |
|
#endif |
|
|
|
#if YYDEBUG != 0 |
|
if (yydebug) |
|
{ |
|
short *ssp1 = yyss - 1; |
|
fprintf (stderr, "state stack now"); |
|
while (ssp1 != yyssp) |
|
fprintf (stderr, " %d", *++ssp1); |
|
fprintf (stderr, "\n"); |
|
} |
|
#endif |
|
| |
*++yyvsp = yyval; |
case 37: |
|
#line 368 "WQL.y" |
|
{ |
|
globalParserState->statement->appendOperand( |
|
WQLOperand((yyvsp[(1) - (1)].doubleValue), WQL_DOUBLE_VALUE_TAG)); |
|
;} |
|
break; |
| |
#ifdef YYLSP_NEEDED |
case 38: |
yylsp++; |
#line 373 "WQL.y" |
if (yylen == 0) |
{ |
{ |
globalParserState->statement->appendOperand( |
yylsp->first_line = yylloc.first_line; |
WQLOperand((yyvsp[(1) - (1)].strValue), WQL_STRING_VALUE_TAG)); |
yylsp->first_column = yylloc.first_column; |
;} |
yylsp->last_line = (yylsp-1)->last_line; |
break; |
yylsp->last_column = (yylsp-1)->last_column; |
|
yylsp->text = 0; |
case 39: |
} |
#line 378 "WQL.y" |
else |
|
{ | { |
yylsp->last_line = (yylsp+yylen-1)->last_line; |
globalParserState->statement->appendOperand( |
yylsp->last_column = (yylsp+yylen-1)->last_column; |
WQLOperand((yyvsp[(1) - (1)].intValue) != 0, WQL_BOOLEAN_VALUE_TAG)); |
|
;} |
|
break; |
|
|
|
|
|
/* Line 1267 of yacc.c. */ |
|
#line 1760 "WQLtemp" |
|
default: break; |
} | } |
#endif |
YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc); |
|
|
|
YYPOPSTACK (yylen); |
|
yylen = 0; |
|
YY_STACK_PRINT (yyss, yyssp); |
|
|
|
*++yyvsp = yyval; |
|
|
| |
/* Now "shift" the result of the reduction. |
/* Now `shift' the result of the reduction. Determine what state |
Determine what state that goes to, |
that goes to, based on the state we popped back to and the rule |
based on the state we popped back to |
number reduced by. */ |
and the rule number reduced by. */ |
|
| |
yyn = yyr1[yyn]; | yyn = yyr1[yyn]; |
| |
yystate = yypgoto[yyn - YYNTBASE] + *yyssp; |
yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; |
if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) |
if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) |
yystate = yytable[yystate]; | yystate = yytable[yystate]; |
else | else |
yystate = yydefgoto[yyn - YYNTBASE]; |
yystate = yydefgoto[yyn - YYNTOKENS]; |
| |
goto yynewstate; | goto yynewstate; |
| |
yyerrlab: /* here on detecting error */ |
|
| |
if (! yyerrstatus) |
/*------------------------------------. |
|
| yyerrlab -- here on detecting error | |
|
`------------------------------------*/ |
|
yyerrlab: |
/* If not already recovering from an error, report this error. */ | /* If not already recovering from an error, report this error. */ |
|
if (!yyerrstatus) |
{ | { |
++yynerrs; | ++yynerrs; |
|
#if ! YYERROR_VERBOSE |
#ifdef YYERROR_VERBOSE |
yyerror (YY_("syntax error")); |
yyn = yypact[yystate]; |
#else |
|
{ |
if (yyn > YYFLAG && yyn < YYLAST) |
YYSIZE_T yysize = yysyntax_error (0, yystate, yychar); |
|
if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM) |
|
{ |
|
YYSIZE_T yyalloc = 2 * yysize; |
|
if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM)) |
|
yyalloc = YYSTACK_ALLOC_MAXIMUM; |
|
if (yymsg != yymsgbuf) |
|
YYSTACK_FREE (yymsg); |
|
yymsg = (char *) YYSTACK_ALLOC (yyalloc); |
|
if (yymsg) |
|
yymsg_alloc = yyalloc; |
|
else |
{ | { |
int size = 0; |
yymsg = yymsgbuf; |
char *msg; |
yymsg_alloc = sizeof yymsgbuf; |
int x, count; |
|
|
|
count = 0; |
|
/* Start X at -yyn if nec to avoid negative indexes in yycheck. */ |
|
for (x = (yyn < 0 ? -yyn : 0); |
|
x < (sizeof(yytname) / sizeof(char *)); x++) |
|
if (yycheck[x + yyn] == x) |
|
size += strlen(yytname[x]) + 15, count++; |
|
msg = (char *) malloc(size + 15); |
|
if (msg != 0) |
|
{ |
|
strcpy(msg, "parse error"); |
|
|
|
if (count < 5) |
|
{ |
|
count = 0; |
|
for (x = (yyn < 0 ? -yyn : 0); |
|
x < (sizeof(yytname) / sizeof(char *)); x++) |
|
if (yycheck[x + yyn] == x) |
|
{ |
|
strcat(msg, count == 0 ? ", expecting `" : " or `"); |
|
strcat(msg, yytname[x]); |
|
strcat(msg, "'"); |
|
count++; |
|
} | } |
} | } |
yyerror(msg); |
|
free(msg); |
if (0 < yysize && yysize <= yymsg_alloc) |
|
{ |
|
(void) yysyntax_error (yymsg, yystate, yychar); |
|
yyerror (yymsg); |
} | } |
else | else |
yyerror ("parse error; also virtual memory exceeded"); |
{ |
|
yyerror (YY_("syntax error")); |
|
if (yysize != 0) |
|
goto yyexhaustedlab; |
} | } |
else |
} |
#endif /* YYERROR_VERBOSE */ |
#endif |
yyerror("parse error"); |
|
} | } |
| |
goto yyerrlab1; |
|
yyerrlab1: /* here on error raised explicitly by an action */ |
|
| |
if (yyerrstatus == 3) | if (yyerrstatus == 3) |
{ | { |
/* if just tried and failed to reuse lookahead token after an error, discard it. */ |
/* If just tried and failed to reuse look-ahead token after an |
|
error, discard it. */ |
| |
/* return failure if at end of input */ |
if (yychar <= YYEOF) |
|
{ |
|
/* Return failure if at end of input. */ |
if (yychar == YYEOF) | if (yychar == YYEOF) |
YYABORT; | YYABORT; |
|
} |
#if YYDEBUG != 0 |
else |
if (yydebug) |
{ |
fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]); |
yydestruct ("Error: discarding", |
#endif |
yytoken, &yylval); |
|
|
yychar = YYEMPTY; | yychar = YYEMPTY; |
} | } |
|
} |
| |
/* Else will try to reuse lookahead token |
/* Else will try to reuse look-ahead token after shifting the error |
after shifting the error token. */ |
token. */ |
|
goto yyerrlab1; |
yyerrstatus = 3; /* Each real token shifted decrements this */ |
|
|
|
goto yyerrhandle; |
|
| |
yyerrdefault: /* current state does not do anything special for the error token. */ |
|
| |
#if 0 |
/*---------------------------------------------------. |
/* This is wrong; only states that explicitly want error tokens |
| yyerrorlab -- error raised explicitly by YYERROR. | |
should shift them. */ |
`---------------------------------------------------*/ |
yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ |
yyerrorlab: |
if (yyn) goto yydefault; |
|
#endif |
/* 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; |
| |
yyerrpop: /* pop the current state because it cannot handle the error token */ |
|
| |
if (yyssp == yyss) YYABORT; |
/*-------------------------------------------------------------. |
yyvsp--; |
| yyerrlab1 -- common code for both syntax error and YYERROR. | |
yystate = *--yyssp; |
`-------------------------------------------------------------*/ |
#ifdef YYLSP_NEEDED |
yyerrlab1: |
yylsp--; |
yyerrstatus = 3; /* Each real token shifted decrements this. */ |
#endif |
|
| |
#if YYDEBUG != 0 |
for (;;) |
if (yydebug) |
|
{ | { |
short *ssp1 = yyss - 1; |
yyn = yypact[yystate]; |
fprintf (stderr, "Error: state stack now"); |
if (yyn != YYPACT_NINF) |
while (ssp1 != yyssp) |
{ |
fprintf (stderr, " %d", *++ssp1); |
yyn += YYTERROR; |
fprintf (stderr, "\n"); |
if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) |
|
{ |
|
yyn = yytable[yyn]; |
|
if (0 < yyn) |
|
break; |
|
} |
} | } |
#endif |
|
|
|
yyerrhandle: |
|
| |
yyn = yypact[yystate]; |
/* Pop the current state because it cannot handle the error token. */ |
if (yyn == YYFLAG) |
if (yyssp == yyss) |
goto yyerrdefault; |
YYABORT; |
| |
yyn += YYTERROR; |
|
if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) |
|
goto yyerrdefault; |
|
| |
yyn = yytable[yyn]; |
yydestruct ("Error: popping", |
if (yyn < 0) |
yystos[yystate], yyvsp); |
{ |
YYPOPSTACK (1); |
if (yyn == YYFLAG) |
yystate = *yyssp; |
goto yyerrpop; |
YY_STACK_PRINT (yyss, yyssp); |
yyn = -yyn; |
|
goto yyreduce; |
|
} | } |
else if (yyn == 0) |
|
goto yyerrpop; |
|
| |
if (yyn == YYFINAL) | if (yyn == YYFINAL) |
YYACCEPT; | YYACCEPT; |
| |
#if YYDEBUG != 0 |
|
if (yydebug) |
|
fprintf(stderr, "Shifting error token, "); |
|
#endif |
|
|
|
*++yyvsp = yylval; | *++yyvsp = yylval; |
#ifdef YYLSP_NEEDED |
|
*++yylsp = yylloc; |
|
#endif |
/* Shift the error token. */ |
|
YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp); |
| |
yystate = yyn; | yystate = yyn; |
goto yynewstate; | goto yynewstate; |
| |
|
|
|
/*-------------------------------------. |
|
| yyacceptlab -- YYACCEPT comes here. | |
|
`-------------------------------------*/ |
yyacceptlab: | yyacceptlab: |
/* YYACCEPT comes here. */ |
yyresult = 0; |
if (yyfree_stacks) |
goto yyreturn; |
{ |
|
free (yyss); |
|
free (yyvs); |
|
#ifdef YYLSP_NEEDED |
|
free (yyls); |
|
#endif |
|
} |
|
return 0; |
|
| |
|
/*-----------------------------------. |
|
| yyabortlab -- YYABORT comes here. | |
|
`-----------------------------------*/ |
yyabortlab: | yyabortlab: |
/* YYABORT comes here. */ |
yyresult = 1; |
if (yyfree_stacks) |
goto yyreturn; |
{ |
|
free (yyss); |
#ifndef yyoverflow |
free (yyvs); |
/*-------------------------------------------------. |
#ifdef YYLSP_NEEDED |
| yyexhaustedlab -- memory exhaustion comes here. | |
free (yyls); |
`-------------------------------------------------*/ |
|
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 | #endif |
|
/* Make sure YYID is used. */ |
|
return YYID (yyresult); |
} | } |
return 1; |
|
} |
|
#line 326 "wql.y" |
#line 383 "WQL.y" |
|
|
| |