version 1.4, 2003/02/12 17:18:39
|
version 1.16, 2006/01/30 16:18:36
|
|
|
|
//%2006//////////////////////////////////////////////////////////////////////// |
|
// |
|
// Copyright (c) 2000, 2001, 2002 BMC Software; Hewlett-Packard Development |
|
// Company, L.P.; IBM Corp.; The Open Group; Tivoli Systems. |
|
// Copyright (c) 2003 BMC Software; Hewlett-Packard Development Company, L.P.; |
|
// IBM Corp.; EMC Corporation, The Open Group. |
|
// Copyright (c) 2004 BMC Software; Hewlett-Packard Development Company, L.P.; |
|
// IBM Corp.; EMC Corporation; VERITAS Software Corporation; The Open Group. |
|
// Copyright (c) 2005 Hewlett-Packard Development Company, L.P.; IBM Corp.; |
|
// EMC Corporation; VERITAS Software Corporation; The Open Group. |
|
// Copyright (c) 2006 Hewlett-Packard Development Company, L.P.; IBM Corp.; |
|
// EMC Corporation; Symantec Corporation; The Open Group. |
|
// |
|
// Permission is hereby granted, free of charge, to any person obtaining a copy |
|
// of this software and associated documentation files (the "Software"), to |
|
// deal in the Software without restriction, including without limitation the |
|
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
|
// sell copies of the Software, and to permit persons to whom the Software is |
|
// furnished to do so, subject to the following conditions: |
|
// |
|
// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN |
|
// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED |
|
// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT |
|
// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR |
|
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT |
|
// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
|
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
|
// |
|
//============================================================================== |
|
/* A Bison parser, made by GNU Bison 1.875c. */ |
|
|
|
/* Skeleton parser for Yacc-like parsing with Bison, |
|
Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. |
|
|
|
This program is free software; you can redistribute it and/or modify |
|
it under the terms of the GNU General Public License as published by |
|
the Free Software Foundation; either version 2, or (at your option) |
|
any later version. |
|
|
|
This program is distributed in the hope that it will be useful, |
|
but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
GNU General Public License for more details. |
|
|
|
You should have received a copy of the GNU General Public License |
|
along with this program; if not, write to the Free Software |
|
Foundation, Inc., 59 Temple Place - Suite 330, |
|
Boston, MA 02111-1307, USA. */ |
|
|
|
/* As a special exception, when this file is copied by Bison into a |
|
Bison output file, you may use that output file without restriction. |
|
This special exception was added by the Free Software Foundation |
|
in version 1.24 of Bison. */ |
|
|
|
/* Written by Richard Stallman by simplifying the original so called |
|
``semantic'' parser. */ |
| |
/* A Bison parser, made from WQL.y |
/* All symbols defined below should begin with yy or YY, to avoid |
by GNU Bison version 1.28 */ |
infringing on user name space. This should be done even for local |
|
variables, as they might otherwise be expanded by user macros. |
|
There are some unavoidable exceptions within include files to |
|
define necessary library symbols; they are noted "INFRINGES ON |
|
USER NAME SPACE" below. */ |
|
|
|
/* Identify Bison output. */ |
|
#define YYBISON 1 |
|
|
|
/* Skeleton name. */ |
|
#define YYSKELETON_NAME "yacc.c" |
| |
#define YYBISON 1 /* Identify Bison output. */ |
/* Pure parsers. */ |
|
#define YYPURE 0 |
| |
|
/* Using locations. */ |
|
#define YYLSP_NEEDED 0 |
|
|
|
/* If NAME_PREFIX is specified substitute the variables and functions |
|
names. */ |
#define yyparse WQL_parse | #define yyparse WQL_parse |
#define yylex WQL_lex | #define yylex WQL_lex |
#define yyerror WQL_error | #define yyerror WQL_error |
|
|
#define yychar WQL_char | #define yychar WQL_char |
#define yydebug WQL_debug | #define yydebug WQL_debug |
#define yynerrs WQL_nerrs | #define yynerrs WQL_nerrs |
#define TOK_INTEGER 257 |
|
#define TOK_DOUBLE 258 |
|
#define TOK_STRING 259 |
|
#define TOK_TRUE 260 |
|
#define TOK_FALSE 261 |
|
#define TOK_NULL 262 |
|
#define TOK_EQ 263 |
|
#define TOK_NE 264 |
|
#define TOK_LT 265 |
|
#define TOK_LE 266 |
|
#define TOK_GT 267 |
|
#define TOK_GE 268 |
|
#define TOK_NOT 269 |
|
#define TOK_OR 270 |
|
#define TOK_AND 271 |
|
#define TOK_IS 272 |
|
#define TOK_IDENTIFIER 273 |
|
#define TOK_SELECT 274 |
|
#define TOK_WHERE 275 |
|
#define TOK_FROM 276 |
|
#define TOK_UNEXPECTED_CHAR 277 |
|
| |
#line 9 "WQL.y" |
|
|
/* 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 |
|
#define TOK_INTEGER 258 |
|
#define TOK_DOUBLE 259 |
|
#define TOK_STRING 260 |
|
#define TOK_TRUE 261 |
|
#define TOK_FALSE 262 |
|
#define TOK_NULL 263 |
|
#define TOK_ISA 264 |
|
#define TOK_DOT 265 |
|
#define TOK_EQ 266 |
|
#define TOK_NE 267 |
|
#define TOK_LT 268 |
|
#define TOK_LE 269 |
|
#define TOK_GT 270 |
|
#define TOK_GE 271 |
|
#define TOK_NOT 272 |
|
#define TOK_OR 273 |
|
#define TOK_AND 274 |
|
#define TOK_IS 275 |
|
#define TOK_IDENTIFIER 276 |
|
#define TOK_SELECT 277 |
|
#define TOK_WHERE 278 |
|
#define TOK_FROM 279 |
|
#define TOK_UNEXPECTED_CHAR 280 |
|
|
|
|
|
|
|
|
|
/* Copy the first part of user declarations. */ |
|
#line 37 "WQL.y" |
| |
| |
#include <Pegasus/Common/Config.h> | #include <Pegasus/Common/Config.h> |
|
|
PEGASUS_NAMESPACE_END | PEGASUS_NAMESPACE_END |
| |
| |
#line 58 "WQL.y" |
|
typedef union |
/* Enabling traces. */ |
{ |
#ifndef YYDEBUG |
|
# define YYDEBUG 0 |
|
#endif |
|
|
|
/* Enabling verbose error messages. */ |
|
#ifdef YYERROR_VERBOSE |
|
# undef YYERROR_VERBOSE |
|
# define YYERROR_VERBOSE 1 |
|
#else |
|
# define YYERROR_VERBOSE 0 |
|
#endif |
|
|
|
#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) |
|
#line 87 "WQL.y" |
|
typedef union YYSTYPE { |
int intValue; | int intValue; |
double doubleValue; | double doubleValue; |
char* strValue; | char* strValue; |
void* nodeValue; | void* nodeValue; |
} YYSTYPE; | } YYSTYPE; |
#include <stdio.h> |
/* Line 191 of yacc.c. */ |
|
#line 183 "WQLtemp" |
|
# define yystype YYSTYPE /* obsolescent; will be withdrawn */ |
|
# define YYSTYPE_IS_DECLARED 1 |
|
# define YYSTYPE_IS_TRIVIAL 1 |
|
#endif |
|
|
|
|
|
|
|
/* Copy the second part of user declarations. */ |
|
|
|
|
|
/* Line 214 of yacc.c. */ |
|
#line 195 "WQLtemp" |
| |
#ifndef __cplusplus |
#if ! defined (yyoverflow) || YYERROR_VERBOSE |
#ifndef __STDC__ |
|
#define const |
# ifndef YYFREE |
|
# define YYFREE free |
#endif | #endif |
|
# ifndef YYMALLOC |
|
# define YYMALLOC malloc |
#endif | #endif |
| |
|
/* The parser invokes alloca or malloc; define the necessary symbols. */ |
| |
|
# ifdef YYSTACK_USE_ALLOCA |
|
# if YYSTACK_USE_ALLOCA |
|
# define YYSTACK_ALLOC alloca |
|
# endif |
|
# else |
|
# if defined (alloca) || defined (_ALLOCA_H) |
|
# define YYSTACK_ALLOC alloca |
|
# else |
|
# ifdef __GNUC__ |
|
# define YYSTACK_ALLOC __builtin_alloca |
|
# endif |
|
# endif |
|
# endif |
|
|
|
# ifdef YYSTACK_ALLOC |
|
/* Pacify GCC's `empty if-body' warning. */ |
|
# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) |
|
# else |
|
# if defined (__STDC__) || defined (__cplusplus) |
|
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ |
|
# define YYSIZE_T size_t |
|
# endif |
|
# define YYSTACK_ALLOC YYMALLOC |
|
# define YYSTACK_FREE YYFREE |
|
# endif |
|
#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */ |
| |
#define YYFINAL 60 |
|
#define YYFLAG -32768 |
|
#define YYNTBASE 28 |
|
| |
#define YYTRANSLATE(x) ((unsigned)(x) <= 277 ? yytranslate[x] : 43) |
#if (! defined (yyoverflow) \ |
|
&& (! defined (__cplusplus) \ |
|
|| (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL))) |
| |
static const char yytranslate[] = { 0, |
/* A type that is properly aligned for any stack member. */ |
|
union yyalloc |
|
{ |
|
short yyss; |
|
YYSTYPE yyvs; |
|
}; |
|
|
|
/* The size of the maximum gap between one aligned stack and the next. */ |
|
# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) |
|
|
|
/* The size of an array large to enough to hold all stacks, each with |
|
N elements. */ |
|
# define YYSTACK_BYTES(N) \ |
|
((N) * (sizeof (short) + sizeof (YYSTYPE)) \ |
|
+ YYSTACK_GAP_MAXIMUM) |
|
|
|
/* Copy COUNT objects from FROM to TO. The source and destination do |
|
not overlap. */ |
|
# ifndef YYCOPY |
|
# if defined (__GNUC__) && 1 < __GNUC__ |
|
# define YYCOPY(To, From, Count) \ |
|
__builtin_memcpy (To, From, (Count) * sizeof (*(From))) |
|
# else |
|
# define YYCOPY(To, From, Count) \ |
|
do \ |
|
{ \ |
|
register YYSIZE_T yyi; \ |
|
for (yyi = 0; yyi < (Count); yyi++) \ |
|
(To)[yyi] = (From)[yyi]; \ |
|
} \ |
|
while (0) |
|
# endif |
|
# endif |
|
|
|
/* Relocate STACK from its old location to the new one. The |
|
local variables YYSIZE and YYSTACKSIZE give the old and new number of |
|
elements in the stack, and YYPTR gives the new location of the |
|
stack. Advance YYPTR to a properly aligned location for the next |
|
stack. */ |
|
# define YYSTACK_RELOCATE(Stack) \ |
|
do \ |
|
{ \ |
|
YYSIZE_T yynewbytes; \ |
|
YYCOPY (&yyptr->Stack, Stack, yysize); \ |
|
Stack = &yyptr->Stack; \ |
|
yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ |
|
yyptr += yynewbytes / sizeof (*yyptr); \ |
|
} \ |
|
while (0) |
|
|
|
#endif |
|
|
|
#if defined (__STDC__) || defined (__cplusplus) |
|
typedef signed char yysigned_char; |
|
#else |
|
typedef short yysigned_char; |
|
#endif |
|
|
|
/* YYFINAL -- State number of the termination state. */ |
|
#define YYFINAL 9 |
|
/* YYLAST -- Last index in YYTABLE. */ |
|
#define YYLAST 69 |
|
|
|
/* YYNTOKENS -- Number of terminals. */ |
|
#define YYNTOKENS 30 |
|
/* YYNNTS -- Number of nonterminals. */ |
|
#define YYNNTS 16 |
|
/* YYNRULES -- Number of rules. */ |
|
#define YYNRULES 39 |
|
/* YYNRULES -- Number of states. */ |
|
#define YYNSTATES 65 |
|
|
|
/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ |
|
#define YYUNDEFTOK 2 |
|
#define YYMAXUTOK 280 |
|
|
|
#define YYTRANSLATE(YYX) \ |
|
((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) |
|
|
|
/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ |
|
static const unsigned char yytranslate[] = |
|
{ |
|
0, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, | 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
2, 2, 2, 2, 2, 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, 3, 4, 5, 6, |
2, 2, 2, 2, 2, 2, 1, 2, 3, 4, |
7, 8, 9, 10, 11, 12, 13, 14, 15, 16, |
5, 6, 7, 8, 9, 10, 11, 12, 13, 14, |
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 unsigned char 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 yysigned_char 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 unsigned short yyrline[] = |
|
{ |
|
0, 160, 160, 166, 172, 176, 182, 186, 192, 196, |
|
202, 209, 215, 220, 225, 231, 235, 239, 244, 253, |
|
257, 263, 268, 273, 278, 283, 288, 293, 303, 308, |
|
315, 319, 332, 337, 349, 356, 362, 367, 372, 377 |
|
}; |
#endif | #endif |
| |
#if YYDEBUG != 0 |
#if YYDEBUG || YYERROR_VERBOSE |
static const short yyrline[] = { 0, |
/* YYTNME[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, 306, 311, 316, 321 |
"$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 | #endif |
| |
|
# ifdef YYPRINT |
#if YYDEBUG != 0 || defined (YYERROR_VERBOSE) |
/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to |
|
token YYLEX-NUM. */ |
static const char * const yytname[] = { "$","error","$undefined.","TOK_INTEGER", |
static const unsigned short yytoknum[] = |
"TOK_DOUBLE","TOK_STRING","TOK_TRUE","TOK_FALSE","TOK_NULL","TOK_EQ","TOK_NE", |
{ |
"TOK_LT","TOK_LE","TOK_GT","TOK_GE","TOK_NOT","TOK_OR","TOK_AND","TOK_IS","TOK_IDENTIFIER", |
0, 256, 257, 258, 259, 260, 261, 262, 263, 264, |
"TOK_SELECT","TOK_WHERE","TOK_FROM","TOK_UNEXPECTED_CHAR","'*'","','","'('", |
265, 266, 267, 268, 269, 270, 271, 272, 273, 274, |
"')'","start","selectStatement","selectList","propertyList","selectExpression", |
275, 276, 277, 278, 279, 280, 42, 44, 40, 41 |
"fromClause","whereClause","searchCondition","predicate","comparisonPredicate", |
|
"nullPredicate","truthValue","propertyName","className","comparisonTerm", NULL |
|
}; | }; |
#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 unsigned char 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 unsigned char 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 unsigned char 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 yysigned_char 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 yysigned_char 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 yysigned_char 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 unsigned char 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 yysigned_char 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, |
/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing |
Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc. |
symbol of state STATE-NUM. */ |
|
static const unsigned char yystos[] = |
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 |
0, 22, 31, 32, 21, 26, 33, 34, 43, 0, |
the Free Software Foundation; either version 2, or (at your option) |
10, 24, 35, 36, 27, 21, 21, 44, 23, 37, |
any later version. |
43, 3, 4, 5, 6, 7, 17, 28, 38, 39, |
|
40, 41, 42, 43, 45, 38, 38, 18, 19, 20, |
This program is distributed in the hope that it will be useful, |
9, 11, 12, 13, 14, 15, 16, 20, 29, 38, |
but WITHOUT ANY WARRANTY; without even the implied warranty of |
38, 17, 42, 44, 43, 45, 45, 45, 45, 45, |
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
45, 8, 17, 42, 8 |
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 |
#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) |
when the %semantic_parser declaration is not specified in the grammar. |
# define YYSIZE_T __SIZE_TYPE__ |
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 | #endif |
#else /* not MSDOS, or __TURBOC__ */ |
#if ! defined (YYSIZE_T) && defined (size_t) |
#if defined(_AIX) |
# define YYSIZE_T size_t |
/* I don't know what this was needed for, but it pollutes the namespace. |
#endif |
So I turned it off. rms, 2 May 1997. */ |
#if ! defined (YYSIZE_T) |
/* #include <malloc.h> */ |
# if defined (__STDC__) || defined (__cplusplus) |
#pragma alloca |
# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ |
#define YYSTACK_USE_ALLOCA |
# define YYSIZE_T size_t |
#else /* not MSDOS, or __TURBOC__, or _AIX */ |
# endif |
#if 0 |
#endif |
#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up, |
#if ! defined (YYSIZE_T) |
and on HPUX 10. Eventually we can turn this on. */ |
# define YYSIZE_T unsigned int |
#define YYSTACK_USE_ALLOCA |
|
#define alloca __builtin_alloca |
|
#endif /* __hpux */ |
|
#endif |
|
#endif /* not _AIX */ |
|
#endif /* not MSDOS, or __TURBOC__ */ |
|
#endif /* not sparc */ |
|
#endif /* not GNU C */ |
|
#endif /* alloca not defined */ |
|
#endif /* YYSTACK_USE_ALLOCA not defined */ |
|
|
|
#ifdef YYSTACK_USE_ALLOCA |
|
#define YYSTACK_ALLOC alloca |
|
#else |
|
#define YYSTACK_ALLOC malloc |
|
#endif | #endif |
|
|
/* Note: there must be only one dollar sign in this file. |
|
It is replaced by the list of actions, each action |
|
as one case of the switch. */ |
|
| |
#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); \ |
|
yylval = (Value); \ |
|
yytoken = YYTRANSLATE (yychar); \ |
YYPOPSTACK; \ | YYPOPSTACK; \ |
goto yybackup; \ | goto yybackup; \ |
} \ | } \ |
else \ | else \ |
{ yyerror ("syntax error: cannot back up"); YYERROR; } \ |
{ \ |
|
yyerror ("syntax error: cannot back up");\ |
|
YYERROR; \ |
|
} \ |
while (0) | while (0) |
| |
#define YYTERROR 1 | #define YYTERROR 1 |
#define YYERRCODE 256 | #define YYERRCODE 256 |
| |
#ifndef YYPURE |
/* YYLLOC_DEFAULT -- Compute the default location (before the actions |
#define YYLEX yylex() |
are run). */ |
#endif |
|
| |
#ifdef YYPURE |
#ifndef YYLLOC_DEFAULT |
#ifdef YYLSP_NEEDED |
# define YYLLOC_DEFAULT(Current, Rhs, N) \ |
#ifdef YYLEX_PARAM |
((Current).first_line = (Rhs)[1].first_line, \ |
#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM) |
(Current).first_column = (Rhs)[1].first_column, \ |
#else |
(Current).last_line = (Rhs)[N].last_line, \ |
#define YYLEX yylex(&yylval, &yylloc) |
(Current).last_column = (Rhs)[N].last_column) |
#endif | #endif |
#else /* not YYLSP_NEEDED */ |
|
|
/* 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 YYPURE |
# ifndef YYFPRINTF |
|
# include <stdio.h> /* INFRINGES ON USER NAME SPACE */ |
|
# define YYFPRINTF fprintf |
|
# endif |
|
|
|
# define YYDPRINTF(Args) \ |
|
do { \ |
|
if (yydebug) \ |
|
YYFPRINTF Args; \ |
|
} while (0) |
|
|
|
# define YYDSYMPRINT(Args) \ |
|
do { \ |
|
if (yydebug) \ |
|
yysymprint Args; \ |
|
} while (0) |
|
|
|
# define YYDSYMPRINTF(Title, Token, Value, Location) \ |
|
do { \ |
|
if (yydebug) \ |
|
{ \ |
|
YYFPRINTF (stderr, "%s ", Title); \ |
|
yysymprint (stderr, \ |
|
Token, Value); \ |
|
YYFPRINTF (stderr, "\n"); \ |
|
} \ |
|
} while (0) |
| |
int yychar; /* the lookahead symbol */ |
/*------------------------------------------------------------------. |
YYSTYPE yylval; /* the semantic value of the */ |
| yy_stack_print -- Print the state stack from its BOTTOM up to its | |
/* lookahead symbol */ |
| TOP (included). | |
|
`------------------------------------------------------------------*/ |
| |
#ifdef YYLSP_NEEDED |
#if defined (__STDC__) || defined (__cplusplus) |
YYLTYPE yylloc; /* location data for the lookahead */ |
static void |
/* symbol */ |
yy_stack_print (short *bottom, short *top) |
|
#else |
|
static void |
|
yy_stack_print (bottom, top) |
|
short *bottom; |
|
short *top; |
#endif | #endif |
|
{ |
|
YYFPRINTF (stderr, "Stack now"); |
|
for (/* Nothing. */; bottom <= top; ++bottom) |
|
YYFPRINTF (stderr, " %d", *bottom); |
|
YYFPRINTF (stderr, "\n"); |
|
} |
| |
int yynerrs; /* number of parse errors so far */ |
# define YY_STACK_PRINT(Bottom, Top) \ |
#endif /* not YYPURE */ |
do { \ |
|
if (yydebug) \ |
|
yy_stack_print ((Bottom), (Top)); \ |
|
} while (0) |
| |
#if YYDEBUG != 0 |
|
int yydebug; /* nonzero means print parse trace */ |
/*------------------------------------------------. |
/* Since this is uninitialized, it does not stop multiple parsers |
| Report that the YYRULE is going to be reduced. | |
from coexisting. */ |
`------------------------------------------------*/ |
|
|
|
#if defined (__STDC__) || defined (__cplusplus) |
|
static void |
|
yy_reduce_print (int yyrule) |
|
#else |
|
static void |
|
yy_reduce_print (yyrule) |
|
int yyrule; |
#endif | #endif |
|
{ |
|
int yyi; |
|
unsigned int yylno = yyrline[yyrule]; |
|
YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ", |
|
yyrule - 1, yylno); |
|
/* Print the symbols being reduced, and their result. */ |
|
for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++) |
|
YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]); |
|
YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]); |
|
} |
|
|
|
# define YY_REDUCE_PRINT(Rule) \ |
|
do { \ |
|
if (yydebug) \ |
|
yy_reduce_print (Rule); \ |
|
} while (0) |
|
|
|
/* Nonzero means print parse trace. It is left uninitialized so that |
|
multiple parsers can coexist. */ |
|
int yydebug; |
|
#else /* !YYDEBUG */ |
|
# define YYDPRINTF(Args) |
|
# define YYDSYMPRINT(Args) |
|
# define YYDSYMPRINTF(Title, Token, Value, Location) |
|
# define YY_STACK_PRINT(Bottom, Top) |
|
# define YY_REDUCE_PRINT(Rule) |
|
#endif /* !YYDEBUG */ |
| |
/* YYINITDEPTH indicates the initial size of the parser's stacks */ |
|
| |
|
/* 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). |
|
|
|
Do not make this value too large; the results are undefined if |
|
SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) |
|
evaluated with infinite-precision integer arithmetic. */ |
| |
#if YYMAXDEPTH == 0 |
#if defined (YYMAXDEPTH) && YYMAXDEPTH == 0 |
#undef YYMAXDEPTH | #undef YYMAXDEPTH |
#endif | #endif |
| |
|
|
#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 |
static void |
|
__yy_memcpy (to, from, count) |
# ifndef yystrlen |
char *to; |
# if defined (__GLIBC__) && defined (_STRING_H) |
char *from; |
# define yystrlen strlen |
unsigned int count; |
# else |
|
/* Return the length of YYSTR. */ |
|
static YYSIZE_T |
|
# if defined (__STDC__) || defined (__cplusplus) |
|
yystrlen (const char *yystr) |
|
# else |
|
yystrlen (yystr) |
|
const char *yystr; |
|
# endif |
{ | { |
register char *f = from; |
register const char *yys = yystr; |
register char *t = to; |
|
register int i = count; |
|
| |
while (i-- > 0) |
while (*yys++ != '\0') |
*t++ = *f++; |
continue; |
|
|
|
return yys - yystr - 1; |
} | } |
|
# 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. */ |
|
static char * |
|
# if defined (__STDC__) || defined (__cplusplus) |
|
yystpcpy (char *yydest, const char *yysrc) |
|
# else |
|
yystpcpy (yydest, yysrc) |
|
char *yydest; |
|
const char *yysrc; |
|
# endif |
|
{ |
|
register char *yyd = yydest; |
|
register const char *yys = yysrc; |
| |
#else /* __cplusplus */ |
while ((*yyd++ = *yys++) != '\0') |
|
continue; |
| |
/* This is the most reliable way to avoid incompatibilities |
return yyd - 1; |
in available built-in functions on various systems. */ |
} |
|
# endif |
|
# endif |
|
|
|
#endif /* !YYERROR_VERBOSE */ |
|
|
|
|
|
|
|
#if YYDEBUG |
|
/*--------------------------------. |
|
| Print this symbol on YYOUTPUT. | |
|
`--------------------------------*/ |
|
|
|
#if defined (__STDC__) || defined (__cplusplus) |
|
static void |
|
yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep) |
|
#else |
static void | static void |
__yy_memcpy (char *to, char *from, unsigned int count) |
yysymprint (yyoutput, yytype, yyvaluep) |
|
FILE *yyoutput; |
|
int yytype; |
|
YYSTYPE *yyvaluep; |
|
#endif |
{ | { |
register char *t = to; |
/* Pacify ``unused variable'' warnings. */ |
register char *f = from; |
(void) yyvaluep; |
register int i = count; |
|
| |
while (i-- > 0) |
if (yytype < YYNTOKENS) |
*t++ = *f++; |
{ |
|
YYFPRINTF (yyoutput, "token %s (", yytname[yytype]); |
|
# ifdef YYPRINT |
|
YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep); |
|
# endif |
} | } |
|
else |
|
YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]); |
| |
|
switch (yytype) |
|
{ |
|
default: |
|
break; |
|
} |
|
YYFPRINTF (yyoutput, ")"); |
|
} |
|
|
|
#endif /* ! YYDEBUG */ |
|
/*-----------------------------------------------. |
|
| Release the memory associated to this symbol. | |
|
`-----------------------------------------------*/ |
|
|
|
#if defined (__STDC__) || defined (__cplusplus) |
|
static void |
|
yydestruct (int yytype, YYSTYPE *yyvaluep) |
|
#else |
|
static void |
|
yydestruct (yytype, yyvaluep) |
|
int yytype; |
|
YYSTYPE *yyvaluep; |
#endif | #endif |
#endif |
{ |
|
/* Pacify ``unused variable'' warnings. */ |
|
(void) yyvaluep; |
| |
#line 217 "bison.simple" |
switch (yytype) |
|
{ |
| |
/* The user can define YYPARSE_PARAM as the name of an argument to be passed |
default: |
into yyparse. The argument should have type void *. |
break; |
It should actually point to an object. |
} |
Grammar actions can access the variable by casting it |
} |
to the proper pointer type. */ |
|
| |
#ifdef YYPARSE_PARAM |
|
#ifdef __cplusplus |
|
#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM |
|
#define YYPARSE_PARAM_DECL |
|
#else /* 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. */ |
/* Prevent warnings from -Wmissing-prototypes. */ |
#ifdef __GNUC__ |
|
#ifdef YYPARSE_PARAM | #ifdef YYPARSE_PARAM |
int yyparse (void *); |
# if defined (__STDC__) || defined (__cplusplus) |
|
int yyparse (void *YYPARSE_PARAM); |
#else | #else |
int yyparse (void); |
int yyparse (); |
#endif | #endif |
|
#else /* ! YYPARSE_PARAM */ |
|
#if defined (__STDC__) || defined (__cplusplus) |
|
int yyparse (void); |
|
#else |
|
int yyparse (); |
#endif | #endif |
|
#endif /* ! YYPARSE_PARAM */ |
|
|
|
|
|
|
|
/* The lookahead symbol. */ |
|
int yychar; |
|
|
|
/* The semantic value of the lookahead symbol. */ |
|
YYSTYPE yylval; |
| |
|
/* Number of syntax errors so far. */ |
|
int yynerrs; |
|
|
|
|
|
|
|
/*----------. |
|
| yyparse. | |
|
`----------*/ |
|
|
|
#ifdef YYPARSE_PARAM |
|
# if defined (__STDC__) || defined (__cplusplus) |
|
int yyparse (void *YYPARSE_PARAM) |
|
# else |
|
int yyparse (YYPARSE_PARAM) |
|
void *YYPARSE_PARAM; |
|
# endif |
|
#else /* ! YYPARSE_PARAM */ |
|
#if defined (__STDC__) || defined (__cplusplus) |
int | int |
yyparse(YYPARSE_PARAM_ARG) |
yyparse (void) |
YYPARSE_PARAM_DECL |
#else |
|
int |
|
yyparse () |
|
|
|
#endif |
|
#endif |
{ | { |
|
|
register int yystate; | register int yystate; |
register int yyn; | register int yyn; |
|
int yyresult; |
|
/* Number of tokens to shift before error messages enabled. */ |
|
int yyerrstatus; |
|
/* Lookahead token as an internal (translated) token number. */ |
|
int yytoken = 0; |
|
|
|
/* Three stacks and their tools: |
|
`yyss': related to states, |
|
`yyvs': related to semantic values, |
|
`yyls': related to locations. |
|
|
|
Refer to the stacks thru separate pointers, to allow yyoverflow |
|
to reallocate them elsewhere. */ |
|
|
|
/* The state stack. */ |
|
short yyssa[YYINITDEPTH]; |
|
short *yyss = yyssa; |
register short *yyssp; | 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 */ |
/* The semantic value stack. */ |
YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */ |
YYSTYPE yyvsa[YYINITDEPTH]; |
|
YYSTYPE *yyvs = yyvsa; |
|
register YYSTYPE *yyvsp; |
| |
short *yyss = yyssa; /* refer to the stacks thru separate pointers */ |
|
YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */ |
|
| |
#ifdef YYLSP_NEEDED |
|
YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */ |
|
YYLTYPE *yyls = yylsa; |
|
YYLTYPE *yylsp; |
|
| |
#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--) |
|
#else |
|
#define YYPOPSTACK (yyvsp--, yyssp--) | #define YYPOPSTACK (yyvsp--, yyssp--) |
#endif |
|
| |
int yystacksize = YYINITDEPTH; |
YYSIZE_T yystacksize = YYINITDEPTH; |
int yyfree_stacks = 0; |
|
| |
#ifdef YYPURE |
/* The variables used to return semantic value and location from the |
int yychar; |
action routines. */ |
YYSTYPE yylval; |
YYSTYPE yyval; |
int yynerrs; |
|
#ifdef YYLSP_NEEDED |
|
YYLTYPE yylloc; |
|
#endif |
|
#endif |
|
| |
YYSTYPE yyval; /* the variable used to return */ |
|
/* semantic values from the action */ |
|
/* routines */ |
|
| |
|
/* When reducing, the number of symbols on the RHS of the reduced |
|
rule. */ |
int yylen; | int yylen; |
| |
#if YYDEBUG != 0 |
YYDPRINTF ((stderr, "Starting parse\n")); |
if (yydebug) |
|
fprintf(stderr, "Starting parse\n"); |
|
#endif |
|
| |
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 */ |
/* Get the current used size of the three stacks, in elements. */ |
/* Use copies of these so that the &'s don't force the real ones into memory. */ |
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; | YYSTYPE *yyvs1 = yyvs; |
short *yyss1 = yyss; | short *yyss1 = yyss; |
#ifdef YYLSP_NEEDED |
|
YYLTYPE *yyls1 = yyls; |
|
#endif |
|
| |
/* Get the current used size of the three stacks, in elements. */ |
|
int size = yyssp - yyss + 1; |
|
| |
#ifdef yyoverflow |
/* Each stack pointer address is followed by the size of the |
/* Each stack pointer address is followed by the size of |
data in use in that stack, in bytes. This used to be a |
the data in use in that stack, in bytes. */ |
conditional around just the two extra args, but that might |
#ifdef YYLSP_NEEDED |
be undefined if yyoverflow is a macro. */ |
/* This used to be a conditional around just the two extra args, |
|
but that might be undefined if yyoverflow is a macro. */ |
|
yyoverflow("parser stack overflow", | yyoverflow("parser stack overflow", |
&yyss1, size * sizeof (*yyssp), |
&yyss1, yysize * sizeof (*yyssp), |
&yyvs1, size * sizeof (*yyvsp), |
&yyvs1, yysize * sizeof (*yyvsp), |
&yyls1, size * sizeof (*yylsp), |
|
&yystacksize); |
|
#else |
|
yyoverflow("parser stack overflow", |
|
&yyss1, size * sizeof (*yyssp), |
|
&yyvs1, size * 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 yyoverflowlab; |
|
# else |
/* Extend the stack our own way. */ | /* Extend the stack our own way. */ |
if (yystacksize >= YYMAXDEPTH) |
if (YYMAXDEPTH <= yystacksize) |
{ |
goto yyoverflowlab; |
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 |
short *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 yyoverflowlab; |
__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. | |
|
`-----------*/ |
yybackup: | yybackup: |
| |
/* Do appropriate processing given the current state. */ | /* Do appropriate processing given the current state. */ |
|
|
/* First try to decide what to do without reference to lookahead token. */ | /* First try to decide what to do without reference to lookahead 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 lookahead token if don't already have one. */ |
| |
/* yychar is either YYEMPTY or YYEOF |
/* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ |
or a valid token in external form. */ |
|
|
|
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); |
|
YYDSYMPRINTF ("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. */ | /* Shift the lookahead token. */ |
|
YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken])); |
#if YYDEBUG != 0 |
|
if (yydebug) |
|
fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]); |
|
#endif |
|
| |
/* Discard the token being shifted unless it is eof. */ | /* Discard the token being shifted unless it is eof. */ |
if (yychar != YYEOF) | if (yychar != YYEOF) |
yychar = YYEMPTY; | yychar = YYEMPTY; |
| |
*++yyvsp = yylval; | *++yyvsp = yylval; |
#ifdef YYLSP_NEEDED |
|
*++yylsp = yylloc; |
|
#endif |
|
| |
/* count tokens shifted since error; after three, turn off error status. */ |
|
if (yyerrstatus) yyerrstatus--; |
/* Count tokens shifted since error; after three, turn off error |
|
status. */ |
|
if (yyerrstatus) |
|
yyerrstatus--; |
| |
yystate = yyn; | 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 YYLEN is nonzero, implement the default value of the action: |
if (yydebug) |
`$$ = $1'. |
{ |
|
int i; |
|
| |
fprintf (stderr, "Reducing via rule %d (line %d), ", |
Otherwise, the following line sets YYVAL to garbage. |
yyn, yyrline[yyn]); |
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]; |
| |
/* 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 |
|
| |
|
YY_REDUCE_PRINT (yyn); |
switch (yyn) { |
switch (yyn) |
|
|
case 1: |
|
#line 131 "WQL.y" |
|
{ | { |
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->setAllProperties(true); |
|
; |
;} |
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->appendSelectPropertyName(CIMName(yyvsp[0].strValue)); |
|
; |
;} |
break;} |
break; |
|
|
case 6: | case 6: |
#line 157 "WQL.y" |
#line 183 "WQL.y" |
{ | { |
globalParserState->statement->appendSelectPropertyName(CIMName(yyvsp[0].strValue)); | globalParserState->statement->appendSelectPropertyName(CIMName(yyvsp[0].strValue)); |
; |
;} |
break;} |
break; |
|
|
case 7: | case 7: |
#line 163 "WQL.y" |
#line 187 "WQL.y" |
{ | { |
|
globalParserState->statement->appendSelectPropertyName(CIMName(yyvsp[0].strValue)); |
|
;} |
|
break; |
| |
; |
|
break;} |
|
case 8: | case 8: |
#line 167 "WQL.y" |
#line 193 "WQL.y" |
{ | { |
| |
; |
;} |
break;} |
break; |
|
|
case 9: | case 9: |
#line 173 "WQL.y" |
#line 197 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: fromClause: TOK_FROM className(%s)\n", yyvsp[0].strValue)); |
|
globalParserState->statement->setClassName(CIMName(yyvsp[0].strValue)); |
;} |
; |
break; |
break;} |
|
case 10: | case 10: |
#line 180 "WQL.y" |
#line 203 "WQL.y" |
{ | { |
|
WQL_TRACE(("YACC: fromClause: TOK_FROM className(%s)\n", yyvsp[0].strValue)); |
|
globalParserState->statement->setClassName(CIMName(yyvsp[0].strValue)); |
|
;} |
|
break; |
| |
; |
|
break;} |
|
case 11: | case 11: |
#line 186 "WQL.y" |
#line 210 "WQL.y" |
|
{ |
|
|
|
;} |
|
break; |
|
|
|
case 12: |
|
#line 216 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: TOK_OR\n")); | WQL_TRACE(("YACC: TOK_OR\n")); |
globalParserState->statement->appendOperation(WQL_OR); | globalParserState->statement->appendOperation(WQL_OR); |
; |
;} |
break;} |
break; |
case 12: |
|
#line 191 "WQL.y" |
case 13: |
|
#line 221 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: TOK_AND\n")); | WQL_TRACE(("YACC: TOK_AND\n")); |
globalParserState->statement->appendOperation(WQL_AND); | globalParserState->statement->appendOperation(WQL_AND); |
; |
;} |
break;} |
break; |
case 13: |
|
#line 196 "WQL.y" |
case 14: |
|
#line 226 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: TOK_NOT\n")); | WQL_TRACE(("YACC: TOK_NOT\n")); |
| |
globalParserState->statement->appendOperation(WQL_NOT); | globalParserState->statement->appendOperation(WQL_NOT); |
; |
;} |
break;} |
break; |
case 14: |
|
#line 202 "WQL.y" |
|
{ |
|
| |
; |
|
break;} |
|
case 15: | case 15: |
#line 206 "WQL.y" |
#line 232 "WQL.y" |
{ | { |
| |
; |
;} |
break;} |
break; |
|
|
case 16: | case 16: |
#line 210 "WQL.y" |
#line 236 "WQL.y" |
{ | { |
WQLOperation op = yyvsp[0].intValue ? WQL_IS_TRUE : WQL_IS_FALSE; |
|
globalParserState->statement->appendOperation(op); |
;} |
; |
break; |
break;} |
|
case 17: | case 17: |
#line 215 "WQL.y" |
#line 240 "WQL.y" |
{ | { |
WQLOperation op = yyvsp[0].intValue ? WQL_IS_NOT_TRUE : WQL_IS_NOT_FALSE; |
WQLOperation op = yyvsp[0].intValue ? WQL_IS_TRUE : WQL_IS_FALSE; |
globalParserState->statement->appendOperation(op); | globalParserState->statement->appendOperation(op); |
; |
;} |
break;} |
break; |
|
|
case 18: | case 18: |
#line 224 "WQL.y" |
#line 245 "WQL.y" |
{ | { |
|
WQLOperation op = yyvsp[0].intValue ? WQL_IS_NOT_TRUE : WQL_IS_NOT_FALSE; |
|
globalParserState->statement->appendOperation(op); |
|
;} |
|
break; |
| |
; |
|
break;} |
|
case 19: | case 19: |
#line 228 "WQL.y" |
#line 254 "WQL.y" |
{ | { |
| |
; |
;} |
break;} |
break; |
|
|
case 20: | case 20: |
#line 234 "WQL.y" |
#line 258 "WQL.y" |
|
{ |
|
|
|
;} |
|
break; |
|
|
|
case 21: |
|
#line 264 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: TOK_LT\n")); | WQL_TRACE(("YACC: TOK_LT\n")); |
globalParserState->statement->appendOperation(WQL_LT); | globalParserState->statement->appendOperation(WQL_LT); |
; |
;} |
break;} |
break; |
case 21: |
|
#line 239 "WQL.y" |
case 22: |
|
#line 269 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: TOK_GT\n")); | WQL_TRACE(("YACC: TOK_GT\n")); |
globalParserState->statement->appendOperation(WQL_GT); | globalParserState->statement->appendOperation(WQL_GT); |
; |
;} |
break;} |
break; |
case 22: |
|
#line 244 "WQL.y" |
case 23: |
|
#line 274 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: TOK_LE\n")); | WQL_TRACE(("YACC: TOK_LE\n")); |
globalParserState->statement->appendOperation(WQL_LE); | globalParserState->statement->appendOperation(WQL_LE); |
; |
;} |
break;} |
break; |
case 23: |
|
#line 249 "WQL.y" |
case 24: |
|
#line 279 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: TOK_GE\n")); | WQL_TRACE(("YACC: TOK_GE\n")); |
globalParserState->statement->appendOperation(WQL_GE); | globalParserState->statement->appendOperation(WQL_GE); |
; |
;} |
break;} |
break; |
case 24: |
|
#line 254 "WQL.y" |
case 25: |
|
#line 284 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: TOK_EQ\n")); | WQL_TRACE(("YACC: TOK_EQ\n")); |
globalParserState->statement->appendOperation(WQL_EQ); | globalParserState->statement->appendOperation(WQL_EQ); |
; |
;} |
break;} |
break; |
case 25: |
|
#line 259 "WQL.y" |
case 26: |
|
#line 289 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: TOK_NE\n")); | WQL_TRACE(("YACC: TOK_NE\n")); |
globalParserState->statement->appendOperation(WQL_NE); | globalParserState->statement->appendOperation(WQL_NE); |
; |
;} |
break;} |
break; |
case 26: |
|
#line 266 "WQL.y" |
case 27: |
|
#line 294 "WQL.y" |
|
{ |
|
WQL_TRACE(("YACC: TOK_ISA\n")); |
|
#ifndef PEGASUS_SNIA_EXTENSIONS |
|
// If SNIA tests, allow the ISA but do not pass className |
|
yyerror("ISA Token Not Supported"); |
|
#endif |
|
;} |
|
break; |
|
|
|
case 28: |
|
#line 304 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: nullPredicate : comparisonTerm IS NULL\n")); | WQL_TRACE(("YACC: nullPredicate : comparisonTerm IS NULL\n")); |
globalParserState->statement->appendOperation(WQL_IS_NULL); | globalParserState->statement->appendOperation(WQL_IS_NULL); |
; |
;} |
break;} |
break; |
case 27: |
|
#line 271 "WQL.y" |
case 29: |
|
#line 309 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: nullPredicate : comparisonTerm IS NOT NULL\n")); | WQL_TRACE(("YACC: nullPredicate : comparisonTerm IS NOT NULL\n")); |
globalParserState->statement->appendOperation(WQL_IS_NOT_NULL); | globalParserState->statement->appendOperation(WQL_IS_NOT_NULL); |
; |
;} |
break;} |
break; |
case 28: |
|
#line 278 "WQL.y" |
case 30: |
|
#line 316 "WQL.y" |
{ | { |
yyval.intValue = 1; | yyval.intValue = 1; |
; |
;} |
break;} |
break; |
case 29: |
|
#line 282 "WQL.y" |
case 31: |
|
#line 320 "WQL.y" |
{ | { |
yyval.intValue = 0; | yyval.intValue = 0; |
; |
;} |
break;} |
break; |
case 30: |
|
#line 288 "WQL.y" |
case 32: |
|
#line 333 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: propertyName : TOK_IDENTIFIER(%s)\n", yyvsp[0].strValue)); | WQL_TRACE(("YACC: propertyName : TOK_IDENTIFIER(%s)\n", yyvsp[0].strValue)); |
yyval.strValue = yyvsp[0].strValue; | yyval.strValue = yyvsp[0].strValue; |
; |
;} |
break;} |
break; |
case 31: |
|
#line 294 "WQL.y" |
case 33: |
|
#line 338 "WQL.y" |
|
{ |
|
WQL_TRACE(("YACC: propertyName : TOK_IDENTIFIER(%s.%s)\n", yyvsp[-2].strValue, yyvsp[0].strValue)); |
|
#ifdef PEGASUS_SNIA_EXTENSIONS |
|
// Pass anything as a property name to fool parser for SNIA testing |
|
yyval.strValue = strdup("dummy"); |
|
#else |
|
yyerror("Scoped (dotted) property names not supported"); |
|
#endif |
|
;} |
|
break; |
|
|
|
case 34: |
|
#line 350 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: TOK_IDENTIFIER %s\n", yyvsp[0].strValue)); | WQL_TRACE(("YACC: TOK_IDENTIFIER %s\n", yyvsp[0].strValue)); |
yyval.strValue = yyvsp[0].strValue; | yyval.strValue = yyvsp[0].strValue; |
; |
;} |
break;} |
break; |
case 32: |
|
#line 301 "WQL.y" |
case 35: |
|
#line 357 "WQL.y" |
{ | { |
globalParserState->statement->appendOperand( | globalParserState->statement->appendOperand( |
WQLOperand(yyvsp[0].strValue, WQL_PROPERTY_NAME_TAG)); | WQLOperand(yyvsp[0].strValue, WQL_PROPERTY_NAME_TAG)); |
globalParserState->statement->appendWherePropertyName(CIMName(yyvsp[0].strValue)); | globalParserState->statement->appendWherePropertyName(CIMName(yyvsp[0].strValue)); |
; |
;} |
break;} |
break; |
case 33: |
|
#line 307 "WQL.y" |
case 36: |
|
#line 363 "WQL.y" |
{ | { |
globalParserState->statement->appendOperand( | globalParserState->statement->appendOperand( |
WQLOperand(yyvsp[0].intValue, WQL_INTEGER_VALUE_TAG)); | WQLOperand(yyvsp[0].intValue, WQL_INTEGER_VALUE_TAG)); |
; |
;} |
break;} |
break; |
case 34: |
|
#line 312 "WQL.y" |
case 37: |
|
#line 368 "WQL.y" |
{ | { |
globalParserState->statement->appendOperand( | globalParserState->statement->appendOperand( |
WQLOperand(yyvsp[0].doubleValue, WQL_DOUBLE_VALUE_TAG)); | WQLOperand(yyvsp[0].doubleValue, WQL_DOUBLE_VALUE_TAG)); |
; |
;} |
break;} |
break; |
case 35: |
|
#line 317 "WQL.y" |
case 38: |
|
#line 373 "WQL.y" |
{ | { |
globalParserState->statement->appendOperand( | globalParserState->statement->appendOperand( |
WQLOperand(yyvsp[0].strValue, WQL_STRING_VALUE_TAG)); | WQLOperand(yyvsp[0].strValue, WQL_STRING_VALUE_TAG)); |
; |
;} |
break;} |
break; |
case 36: |
|
#line 322 "WQL.y" |
case 39: |
|
#line 378 "WQL.y" |
{ | { |
globalParserState->statement->appendOperand( | globalParserState->statement->appendOperand( |
WQLOperand(yyvsp[0].intValue != 0, WQL_BOOLEAN_VALUE_TAG)); | WQLOperand(yyvsp[0].intValue != 0, WQL_BOOLEAN_VALUE_TAG)); |
; |
;} |
break;} |
break; |
|
|
|
|
} | } |
/* the action file gets copied in in place of this dollarsign */ |
|
#line 543 "bison.simple" |
/* Line 1000 of yacc.c. */ |
|
#line 1429 "WQLtemp" |
| |
yyvsp -= yylen; | yyvsp -= yylen; |
yyssp -= yylen; | yyssp -= yylen; |
#ifdef YYLSP_NEEDED |
|
yylsp -= yylen; |
|
#endif |
|
| |
#if YYDEBUG != 0 |
|
if (yydebug) |
YY_STACK_PRINT (yyss, yyssp); |
{ |
|
short *ssp1 = yyss - 1; |
|
fprintf (stderr, "state stack now"); |
|
while (ssp1 != yyssp) |
|
fprintf (stderr, " %d", *++ssp1); |
|
fprintf (stderr, "\n"); |
|
} |
|
#endif |
|
| |
*++yyvsp = yyval; | *++yyvsp = yyval; |
| |
#ifdef YYLSP_NEEDED |
|
yylsp++; |
|
if (yylen == 0) |
|
{ |
|
yylsp->first_line = yylloc.first_line; |
|
yylsp->first_column = yylloc.first_column; |
|
yylsp->last_line = (yylsp-1)->last_line; |
|
yylsp->last_column = (yylsp-1)->last_column; |
|
yylsp->text = 0; |
|
} |
|
else |
|
{ |
|
yylsp->last_line = (yylsp+yylen-1)->last_line; |
|
yylsp->last_column = (yylsp+yylen-1)->last_column; |
|
} |
|
#endif |
|
| |
/* 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 |
|
yyn = yypact[yystate]; | yyn = yypact[yystate]; |
| |
if (yyn > YYFLAG && yyn < YYLAST) |
if (YYPACT_NINF < yyn && yyn < YYLAST) |
|
{ |
|
YYSIZE_T yysize = 0; |
|
int yytype = YYTRANSLATE (yychar); |
|
const char* yyprefix; |
|
char *yymsg; |
|
int yyx; |
|
|
|
/* Start YYX at -YYN if negative to avoid negative indexes in |
|
YYCHECK. */ |
|
int yyxbegin = yyn < 0 ? -yyn : 0; |
|
|
|
/* Stay within bounds of both yycheck and yytname. */ |
|
int yychecklim = YYLAST - yyn; |
|
int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; |
|
int yycount = 0; |
|
|
|
yyprefix = ", expecting "; |
|
for (yyx = yyxbegin; yyx < yyxend; ++yyx) |
|
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) |
|
{ |
|
yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]); |
|
yycount += 1; |
|
if (yycount == 5) |
|
{ |
|
yysize = 0; |
|
break; |
|
} |
|
} |
|
yysize += (sizeof ("syntax error, unexpected ") |
|
+ yystrlen (yytname[yytype])); |
|
yymsg = (char *) YYSTACK_ALLOC (yysize); |
|
if (yymsg != 0) |
|
{ |
|
char *yyp = yystpcpy (yymsg, "syntax error, unexpected "); |
|
yyp = yystpcpy (yyp, yytname[yytype]); |
|
|
|
if (yycount < 5) |
|
{ |
|
yyprefix = ", expecting "; |
|
for (yyx = yyxbegin; yyx < yyxend; ++yyx) |
|
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) |
{ | { |
int size = 0; |
yyp = yystpcpy (yyp, yyprefix); |
char *msg; |
yyp = yystpcpy (yyp, yytname[yyx]); |
int x, count; |
yyprefix = " or "; |
|
|
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); |
yyerror (yymsg); |
free(msg); |
YYSTACK_FREE (yymsg); |
} | } |
else | else |
yyerror ("parse error; also virtual memory exceeded"); |
yyerror ("syntax error; also virtual memory exhausted"); |
} | } |
else | else |
#endif /* YYERROR_VERBOSE */ | #endif /* YYERROR_VERBOSE */ |
yyerror("parse error"); |
yyerror ("syntax 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 lookahead token after an |
|
error, discard it. */ |
| |
/* return failure if at end of input */ |
if (yychar <= YYEOF) |
|
{ |
|
/* If at end of input, pop the error token, |
|
then the rest of the stack, then return failure. */ |
if (yychar == YYEOF) | if (yychar == YYEOF) |
|
for (;;) |
|
{ |
|
YYPOPSTACK; |
|
if (yyssp == yyss) |
YYABORT; | YYABORT; |
|
YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); |
#if YYDEBUG != 0 |
yydestruct (yystos[*yyssp], yyvsp); |
if (yydebug) |
|
fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]); |
|
#endif |
|
|
|
yychar = YYEMPTY; |
|
} | } |
|
} |
|
else |
|
{ |
|
YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc); |
|
yydestruct (yytoken, &yylval); |
|
yychar = YYEMPTY; |
| |
/* Else will try to reuse lookahead token |
} |
after shifting the error token. */ |
} |
| |
yyerrstatus = 3; /* Each real token shifted decrements this */ |
/* Else will try to reuse lookahead token after shifting the error |
|
token. */ |
|
goto yyerrlab1; |
| |
goto yyerrhandle; |
|
| |
yyerrdefault: /* current state does not do anything special for the error token. */ |
/*---------------------------------------------------. |
|
| yyerrorlab -- error raised explicitly by YYERROR. | |
|
`---------------------------------------------------*/ |
|
yyerrorlab: |
| |
#if 0 |
#ifdef __GNUC__ |
/* This is wrong; only states that explicitly want error tokens |
/* Pacify GCC when the user code never invokes YYERROR and the label |
should shift them. */ |
yyerrorlab therefore never appears in user code. */ |
yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ |
if (0) |
if (yyn) goto yydefault; |
goto yyerrorlab; |
#endif | #endif |
| |
yyerrpop: /* pop the current state because it cannot handle the error token */ |
yyvsp -= yylen; |
|
yyssp -= yylen; |
if (yyssp == yyss) YYABORT; |
yystate = *yyssp; |
yyvsp--; |
goto yyerrlab1; |
yystate = *--yyssp; |
|
#ifdef YYLSP_NEEDED |
|
yylsp--; |
|
#endif |
|
| |
#if YYDEBUG != 0 |
|
if (yydebug) |
|
{ |
|
short *ssp1 = yyss - 1; |
|
fprintf (stderr, "Error: state stack now"); |
|
while (ssp1 != yyssp) |
|
fprintf (stderr, " %d", *++ssp1); |
|
fprintf (stderr, "\n"); |
|
} |
|
#endif |
|
| |
yyerrhandle: |
/*-------------------------------------------------------------. |
|
| yyerrlab1 -- common code for both syntax error and YYERROR. | |
|
`-------------------------------------------------------------*/ |
|
yyerrlab1: |
|
yyerrstatus = 3; /* Each real token shifted decrements this. */ |
| |
|
for (;;) |
|
{ |
yyn = yypact[yystate]; | yyn = yypact[yystate]; |
if (yyn == YYFLAG) |
if (yyn != YYPACT_NINF) |
goto yyerrdefault; |
{ |
|
|
yyn += YYTERROR; | yyn += YYTERROR; |
if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) |
if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) |
goto yyerrdefault; |
|
|
|
yyn = yytable[yyn]; |
|
if (yyn < 0) |
|
{ | { |
if (yyn == YYFLAG) |
yyn = yytable[yyn]; |
goto yyerrpop; |
if (0 < yyn) |
yyn = -yyn; |
break; |
goto yyreduce; |
} |
|
} |
|
|
|
/* Pop the current state because it cannot handle the error token. */ |
|
if (yyssp == yyss) |
|
YYABORT; |
|
|
|
YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); |
|
yydestruct (yystos[yystate], yyvsp); |
|
YYPOPSTACK; |
|
yystate = *yyssp; |
|
YY_STACK_PRINT (yyss, yyssp); |
} | } |
else if (yyn == 0) |
|
goto yyerrpop; |
|
| |
if (yyn == YYFINAL) | if (yyn == YYFINAL) |
YYACCEPT; | YYACCEPT; |
| |
#if YYDEBUG != 0 |
YYDPRINTF ((stderr, "Shifting error token, ")); |
if (yydebug) |
|
fprintf(stderr, "Shifting error token, "); |
|
#endif |
|
| |
*++yyvsp = yylval; | *++yyvsp = yylval; |
#ifdef YYLSP_NEEDED |
|
*++yylsp = yylloc; |
|
#endif |
|
| |
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 |
| yyoverflowlab -- parser overflow comes here. | |
free (yyls); |
`----------------------------------------------*/ |
|
yyoverflowlab: |
|
yyerror ("parser stack overflow"); |
|
yyresult = 2; |
|
/* Fall through. */ |
#endif | #endif |
|
|
|
yyreturn: |
|
#ifndef yyoverflow |
|
if (yyss != yyssa) |
|
YYSTACK_FREE (yyss); |
|
#endif |
|
return yyresult; |
} | } |
return 1; |
|
} |
|
#line 327 "WQL.y" |
#line 383 "WQL.y" |
|
|
| |