version 1.1.2.9, 2001/12/03 06:14:26
|
version 1.3, 2002/08/27 18:47:11
|
|
|
#ifndef lint |
|
static char yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93"; |
/* A Bison parser, made from WQL.y |
#endif |
by GNU Bison version 1.28 */ |
#define YYBYACC 1 |
|
#define YYMAJOR 1 |
#define YYBISON 1 /* Identify Bison output. */ |
#define YYMINOR 9 |
|
#define yyclearin (yychar=(-1)) |
|
#define yyerrok (yyerrflag=0) |
|
#define YYRECOVERING (yyerrflag!=0) |
|
#define yyparse WQL_parse | #define yyparse WQL_parse |
#define yylex WQL_lex | #define yylex WQL_lex |
#define yyerror WQL_error | #define yyerror WQL_error |
#define yychar WQL_char |
|
#define yyval WQL_val |
|
#define yylval WQL_lval | #define yylval WQL_lval |
|
#define yychar WQL_char |
#define yydebug WQL_debug | #define yydebug WQL_debug |
#define yynerrs WQL_nerrs | #define yynerrs WQL_nerrs |
#define yyerrflag WQL_errflag |
#define TOK_INTEGER 257 |
#define yyss WQL_ss |
#define TOK_DOUBLE 258 |
#define yyssp WQL_ssp |
#define TOK_STRING 259 |
#define yyvs WQL_vs |
#define TOK_TRUE 260 |
#define yyvsp WQL_vsp |
#define TOK_FALSE 261 |
#define yylhs WQL_lhs |
#define TOK_NULL 262 |
#define yylen WQL_len |
#define TOK_EQ 263 |
#define yydefred WQL_defred |
#define TOK_NE 264 |
#define yydgoto WQL_dgoto |
#define TOK_LT 265 |
#define yysindex WQL_sindex |
#define TOK_LE 266 |
#define yyrindex WQL_rindex |
#define TOK_GT 267 |
#define yygindex WQL_gindex |
#define TOK_GE 268 |
#define yytable WQL_table |
#define TOK_NOT 269 |
#define yycheck WQL_check |
#define TOK_OR 270 |
#define yyname WQL_name |
#define TOK_AND 271 |
#define yyrule WQL_rule |
#define TOK_IS 272 |
#define YYPREFIX "WQL_" |
#define TOK_IDENTIFIER 273 |
#line 10 "WQL.y" |
#define TOK_SELECT 274 |
|
#define TOK_WHERE 275 |
|
#define TOK_FROM 276 |
|
#define TOK_UNEXPECTED_CHAR 277 |
|
|
|
#line 9 "WQL.y" |
|
|
| |
#include <Pegasus/Common/Config.h> | #include <Pegasus/Common/Config.h> |
#include <Pegasus/WQL/WQLOperation.h> | #include <Pegasus/WQL/WQLOperation.h> |
|
|
#endif | #endif |
| |
extern int WQL_lex(); | extern int WQL_lex(); |
extern int WQL_error(char*); |
extern int WQL_error(const char*); |
| |
/**/ |
// |
/* Define the global parser state object:*/ |
// Define the global parser state object: |
/**/ |
// |
| |
PEGASUS_USING_PEGASUS; | PEGASUS_USING_PEGASUS; |
| |
|
|
| |
PEGASUS_NAMESPACE_END | PEGASUS_NAMESPACE_END |
| |
|
|
#line 58 "WQL.y" | #line 58 "WQL.y" |
typedef union | typedef union |
{ | { |
|
|
char* strValue; | char* strValue; |
void* nodeValue; | void* nodeValue; |
} YYSTYPE; | } YYSTYPE; |
#line 83 "y.tab.c" |
#include <stdio.h> |
#define TOK_INTEGER 257 |
|
#define TOK_DOUBLE 258 |
#ifndef __cplusplus |
#define TOK_STRING 259 |
#ifndef __STDC__ |
#define TOK_TRUE 260 |
#define const |
#define TOK_FALSE 261 |
#endif |
#define TOK_NULL 262 |
#endif |
#define TOK_EQ 263 |
|
#define TOK_NE 264 |
|
#define TOK_LT 265 |
|
#define TOK_LE 266 |
#define YYFINAL 60 |
#define TOK_GT 267 |
#define YYFLAG -32768 |
#define TOK_GE 268 |
#define YYNTBASE 28 |
#define TOK_NOT 269 |
|
#define TOK_OR 270 |
#define YYTRANSLATE(x) ((unsigned)(x) <= 277 ? yytranslate[x] : 43) |
#define TOK_AND 271 |
|
#define TOK_IS 272 |
static const char yytranslate[] = { 0, |
#define TOK_IDENTIFIER 273 |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
#define TOK_SELECT 274 |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
#define TOK_WHERE 275 |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
#define TOK_FROM 276 |
2, 2, 2, 2, 2, 2, 2, 2, 2, 26, |
#define TOK_UNEXPECTED_CHAR 277 |
27, 24, 2, 25, 2, 2, 2, 2, 2, 2, |
#define YYERRCODE 256 |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
short WQL_lhs[] = { -1, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
0, 9, 10, 10, 2, 2, 11, 11, 7, 8, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
6, 6, 6, 6, 6, 6, 6, 3, 3, 4, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
4, 4, 4, 4, 4, 5, 5, 13, 13, 1, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
12, 14, 14, 14, 14, 14, |
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, |
|
2, 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, |
|
7, 8, 9, 10, 11, 12, 13, 14, 15, 16, |
|
17, 18, 19, 20, 21, 22, 23 |
|
}; |
|
|
|
#if YYDEBUG != 0 |
|
static const short yyprhs[] = { 0, |
|
0, 2, 6, 8, 10, 12, 16, 19, 21, 24, |
|
27, 31, 35, 38, 42, 44, 48, 53, 55, 57, |
|
61, 65, 69, 73, 77, 81, 85, 90, 92, 94, |
|
96, 98, 100, 102, 104, 106 |
|
}; |
|
|
|
static const short yyrhs[] = { 29, |
|
0, 20, 30, 32, 0, 24, 0, 31, 0, 40, |
|
0, 31, 25, 40, 0, 33, 34, 0, 33, 0, |
|
22, 41, 0, 21, 35, 0, 35, 16, 35, 0, |
|
35, 17, 35, 0, 15, 35, 0, 26, 35, 27, |
|
0, 36, 0, 36, 18, 39, 0, 36, 18, 15, |
|
39, 0, 37, 0, 38, 0, 42, 11, 42, 0, |
|
42, 13, 42, 0, 42, 12, 42, 0, 42, 14, |
|
42, 0, 42, 9, 42, 0, 42, 10, 42, 0, |
|
42, 18, 8, 0, 42, 18, 15, 8, 0, 6, |
|
0, 7, 0, 19, 0, 19, 0, 40, 0, 3, |
|
0, 4, 0, 5, 0, 39, 0 |
|
}; |
|
|
|
#endif |
|
|
|
#if YYDEBUG != 0 |
|
static const short yyrline[] = { 0, |
|
130, 136, 142, 146, 152, 156, 162, 166, 172, 179, |
|
185, 190, 195, 201, 205, 209, 214, 223, 227, 233, |
|
238, 243, 248, 253, 258, 265, 270, 277, 281, 287, |
|
293, 300, 306, 311, 316, 321 |
}; | }; |
short WQL_len[] = { 2, |
#endif |
|
|
|
|
|
#if YYDEBUG != 0 || defined (YYERROR_VERBOSE) |
|
|
|
static const char * const yytname[] = { "$","error","$undefined.","TOK_INTEGER", |
|
"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", |
|
"TOK_SELECT","TOK_WHERE","TOK_FROM","TOK_UNEXPECTED_CHAR","'*'","','","'('", |
|
"')'","start","selectStatement","selectList","propertyList","selectExpression", |
|
"fromClause","whereClause","searchCondition","predicate","comparisonPredicate", |
|
"nullPredicate","truthValue","propertyName","className","comparisonTerm", NULL |
|
}; |
|
#endif |
|
|
|
static const short yyr1[] = { 0, |
|
28, 29, 30, 30, 31, 31, 32, 32, 33, 34, |
|
35, 35, 35, 35, 35, 35, 35, 36, 36, 37, |
|
37, 37, 37, 37, 37, 38, 38, 39, 39, 40, |
|
41, 42, 42, 42, 42, 42 |
|
}; |
|
|
|
static const short yyr2[] = { 0, |
1, 3, 1, 1, 1, 3, 2, 1, 2, 2, | 1, 3, 1, 1, 1, 3, 2, 1, 2, 2, |
3, 3, 2, 3, 1, 3, 4, 1, 1, 3, | 3, 3, 2, 3, 1, 3, 4, 1, 1, 3, |
3, 3, 3, 3, 3, 3, 4, 1, 1, 1, | 3, 3, 3, 3, 3, 3, 4, 1, 1, 1, |
1, 1, 1, 1, 1, 1, |
1, 1, 1, 1, 1, 1 |
}; | }; |
short WQL_defred[] = { 0, |
|
0, 0, 1, 30, 3, 5, 0, 0, 0, 0, |
static const short yydefact[] = { 0, |
0, 2, 6, 31, 9, 0, 7, 33, 34, 35, |
0, 1, 30, 3, 0, 4, 5, 0, 2, 8, |
28, 29, 0, 0, 32, 0, 18, 19, 0, 36, |
0, 31, 9, 0, 7, 6, 33, 34, 35, 28, |
0, 13, 0, 0, 0, 0, 0, 0, 0, 0, |
29, 0, 0, 10, 15, 18, 19, 36, 32, 0, |
0, 0, 0, 14, 0, 16, 0, 12, 24, 25, |
13, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
20, 22, 21, 23, 26, 0, 17, 27, |
0, 0, 14, 11, 12, 0, 16, 24, 25, 20, |
}; |
22, 21, 23, 26, 0, 17, 27, 0, 0, 0 |
short WQL_dgoto[] = { 2, |
}; |
25, 7, 26, 27, 28, 29, 11, 17, 3, 8, |
|
12, 15, 30, 31, |
static const short yydefgoto[] = { 58, |
}; |
2, 5, 6, 9, 10, 15, 24, 25, 26, 27, |
short WQL_sindex[] = { -241, |
28, 29, 13, 30 |
-38, 0, 0, 0, 0, 0, -9, -237, -232, -225, |
}; |
-228, 0, 0, 0, 0, -40, 0, 0, 0, 0, |
|
0, 0, -40, -40, 0, -223, 0, 0, -233, 0, |
static const short yypact[] = { -5, |
-238, 0, -39, -229, -40, -40, -252, -252, -252, -252, |
18,-32768,-32768,-32768, 5, 16,-32768, 24,-32768, 33, |
-252, -252, -226, 0, -215, 0, -221, 0, 0, 0, |
26,-32768,-32768, -3,-32768,-32768,-32768,-32768,-32768,-32768, |
0, 0, 0, 0, 0, -211, 0, 0, |
-32768, -3, -3, 23, 37,-32768,-32768,-32768,-32768, 20, |
}; |
-32768, 1, -3, -3, 29, 2, 2, 2, 2, 2, |
short WQL_rindex[] = { 0, |
2, 11,-32768, 39,-32768, 46,-32768,-32768,-32768,-32768, |
0, 0, 0, 0, 0, 0, -224, 0, 0, 0, |
-32768,-32768,-32768,-32768, 49,-32768,-32768, 58, 59,-32768 |
53, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
}; |
0, 0, 0, 0, 0, 1, 0, 0, 54, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
static const short yypgoto[] = {-32768, |
0, 0, 0, 0, 0, 0, 3, 0, 0, 0, |
-32768,-32768,-32768,-32768,-32768,-32768, -9,-32768,-32768,-32768, |
0, 0, 0, 0, 0, 0, 0, 0, |
-24, 9,-32768, 10 |
}; |
}; |
short WQL_gindex[] = { 0, |
|
11, 0, 0, 0, 0, -13, 0, 0, 0, 0, |
|
0, 0, -21, -23, |
#define YYLAST 59 |
}; |
|
#define YYTABLESIZE 273 |
|
short WQL_table[] = { 24, |
static const short yytable[] = { 17, |
15, 44, 11, 5, 18, 19, 20, 21, 22, 32, |
18, 19, 20, 21, 17, 18, 19, 20, 21, 7, |
33, 6, 46, 49, 50, 51, 52, 53, 54, 13, |
47, 22, 31, 32, 1, 3, 33, 34, 54, 16, |
4, 47, 48, 57, 37, 38, 39, 40, 41, 42, |
3, 56, 23, 44, 45, 55, 8, 43, 36, 37, |
21, 22, 1, 43, 9, 55, 35, 36, 10, 45, |
38, 39, 40, 41, 20, 21, 3, 42, 33, 34, |
4, 15, 56, 11, 21, 22, 16, 14, 34, 36, |
11, 4, 12, 46, 3, 48, 49, 50, 51, 52, |
58, 4, 8, 10, 0, 0, 0, 0, 0, 0, |
53, 20, 21, 14, 35, 34, 57, 59, 60 |
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 18, 19, 20, 21, |
|
22, 0, 0, 0, 0, 0, 0, 0, 23, 0, |
|
35, 36, 4, 0, 4, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
|
15, 15, 11, |
|
}; |
|
short WQL_check[] = { 40, |
|
0, 41, 0, 42, 257, 258, 259, 260, 261, 23, |
|
24, 1, 34, 37, 38, 39, 40, 41, 42, 9, |
|
273, 35, 36, 45, 263, 264, 265, 266, 267, 268, |
|
260, 261, 274, 272, 44, 262, 270, 271, 276, 269, |
|
273, 41, 269, 41, 260, 261, 275, 273, 272, 271, |
|
262, 276, 0, 0, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, 257, 258, 259, 260, |
|
261, -1, -1, -1, -1, -1, -1, -1, 269, -1, |
|
270, 271, 273, -1, 273, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, |
|
270, 271, 270, |
|
}; |
|
#define YYFINAL 2 |
|
#ifndef YYDEBUG |
|
#define YYDEBUG 0 |
|
#endif |
|
#define YYMAXTOKEN 277 |
|
#if YYDEBUG |
|
char *WQL_name[] = { |
|
"end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
|
0,0,0,0,0,0,"'('","')'","'*'",0,"','",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"TOK_INTEGER", |
|
"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","TOK_SELECT","TOK_WHERE","TOK_FROM","TOK_UNEXPECTED_CHAR", |
|
}; | }; |
char *WQL_rule[] = { |
|
"$accept : start", |
static const short yycheck[] = { 3, |
"start : selectStatement", |
4, 5, 6, 7, 3, 4, 5, 6, 7, 1, |
"selectStatement : TOK_SELECT selectList selectExpression", |
35, 15, 22, 23, 20, 19, 16, 17, 8, 11, |
"selectList : '*'", |
19, 46, 26, 33, 34, 15, 22, 27, 9, 10, |
"selectList : propertyList", |
11, 12, 13, 14, 6, 7, 19, 18, 16, 17, |
"propertyList : propertyName", |
25, 24, 19, 15, 19, 36, 37, 38, 39, 40, |
"propertyList : propertyList ',' propertyName", |
41, 6, 7, 21, 18, 17, 8, 0, 0 |
"selectExpression : fromClause whereClause", |
|
"selectExpression : fromClause", |
|
"fromClause : TOK_FROM className", |
|
"whereClause : TOK_WHERE searchCondition", |
|
"searchCondition : searchCondition TOK_OR searchCondition", |
|
"searchCondition : searchCondition TOK_AND searchCondition", |
|
"searchCondition : TOK_NOT searchCondition", |
|
"searchCondition : '(' searchCondition ')'", |
|
"searchCondition : predicate", |
|
"searchCondition : predicate TOK_IS truthValue", |
|
"searchCondition : predicate TOK_IS TOK_NOT truthValue", |
|
"predicate : comparisonPredicate", |
|
"predicate : nullPredicate", |
|
"comparisonPredicate : comparisonTerm TOK_LT comparisonTerm", |
|
"comparisonPredicate : comparisonTerm TOK_GT comparisonTerm", |
|
"comparisonPredicate : comparisonTerm TOK_LE comparisonTerm", |
|
"comparisonPredicate : comparisonTerm TOK_GE comparisonTerm", |
|
"comparisonPredicate : comparisonTerm TOK_EQ comparisonTerm", |
|
"comparisonPredicate : comparisonTerm TOK_NE comparisonTerm", |
|
"nullPredicate : comparisonTerm TOK_IS TOK_NULL", |
|
"nullPredicate : comparisonTerm TOK_IS TOK_NOT TOK_NULL", |
|
"truthValue : TOK_TRUE", |
|
"truthValue : TOK_FALSE", |
|
"propertyName : TOK_IDENTIFIER", |
|
"className : TOK_IDENTIFIER", |
|
"comparisonTerm : propertyName", |
|
"comparisonTerm : TOK_INTEGER", |
|
"comparisonTerm : TOK_DOUBLE", |
|
"comparisonTerm : TOK_STRING", |
|
"comparisonTerm : truthValue", |
|
}; | }; |
|
/* -*-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 | #endif |
#ifdef YYSTACKSIZE |
#else /* not MSDOS, or __TURBOC__ */ |
#undef YYMAXDEPTH |
#if defined(_AIX) |
#define YYMAXDEPTH YYSTACKSIZE |
/* 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 |
|
#define YYSTACK_ALLOC alloca |
|
#else |
|
#define YYSTACK_ALLOC malloc |
|
#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 yyclearin (yychar = YYEMPTY) |
|
#define YYEMPTY -2 |
|
#define YYEOF 0 |
|
#define YYACCEPT goto yyacceptlab |
|
#define YYABORT goto yyabortlab |
|
#define YYERROR goto yyerrlab1 |
|
/* Like YYERROR except do call yyerror. |
|
This remains here temporarily to ease the |
|
transition to the new meaning of YYERROR, for GCC. |
|
Once GCC version 2 has supplanted version 1, this can go. */ |
|
#define YYFAIL goto yyerrlab |
|
#define YYRECOVERING() (!!yyerrstatus) |
|
#define YYBACKUP(token, value) \ |
|
do \ |
|
if (yychar == YYEMPTY && yylen == 1) \ |
|
{ yychar = (token), yylval = (value); \ |
|
yychar1 = YYTRANSLATE (yychar); \ |
|
YYPOPSTACK; \ |
|
goto yybackup; \ |
|
} \ |
|
else \ |
|
{ yyerror ("syntax error: cannot back up"); YYERROR; } \ |
|
while (0) |
|
|
|
#define YYTERROR 1 |
|
#define YYERRCODE 256 |
|
|
|
#ifndef YYPURE |
|
#define YYLEX yylex() |
|
#endif |
|
|
|
#ifdef YYPURE |
|
#ifdef YYLSP_NEEDED |
|
#ifdef YYLEX_PARAM |
|
#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM) |
#else | #else |
#ifdef YYMAXDEPTH |
#define YYLEX yylex(&yylval, &yylloc) |
#define YYSTACKSIZE YYMAXDEPTH |
#endif |
|
#else /* not YYLSP_NEEDED */ |
|
#ifdef YYLEX_PARAM |
|
#define YYLEX yylex(&yylval, YYLEX_PARAM) |
#else | #else |
#define YYSTACKSIZE 500 |
#define YYLEX yylex(&yylval) |
#define YYMAXDEPTH 500 |
|
#endif | #endif |
|
#endif /* not YYLSP_NEEDED */ |
#endif | #endif |
int yydebug; |
|
int yynerrs; |
/* If nonreentrant, generate the variables here */ |
int yyerrflag; |
|
int yychar; |
#ifndef YYPURE |
short *yyssp; |
|
YYSTYPE *yyvsp; |
int yychar; /* the lookahead symbol */ |
YYSTYPE yyval; |
YYSTYPE yylval; /* the semantic value of the */ |
YYSTYPE yylval; |
/* lookahead symbol */ |
short yyss[YYSTACKSIZE]; |
|
YYSTYPE yyvs[YYSTACKSIZE]; |
#ifdef YYLSP_NEEDED |
#define yystacksize YYSTACKSIZE |
YYLTYPE yylloc; /* location data for the lookahead */ |
#define YYABORT goto yyabort |
/* symbol */ |
#define YYREJECT goto yyabort |
#endif |
#define YYACCEPT goto yyaccept |
|
#define YYERROR goto yyerrlab |
int yynerrs; /* number of parse errors so far */ |
|
#endif /* not YYPURE */ |
|
|
|
#if YYDEBUG != 0 |
|
int yydebug; /* nonzero means print parse trace */ |
|
/* Since this is uninitialized, it does not stop multiple parsers |
|
from coexisting. */ |
|
#endif |
|
|
|
/* YYINITDEPTH indicates the initial size of the parser's stacks */ |
|
|
|
#ifndef YYINITDEPTH |
|
#define YYINITDEPTH 200 |
|
#endif |
|
|
|
/* YYMAXDEPTH is the maximum size the stacks can grow to |
|
(effective only if the built-in stack extension method is used). */ |
|
|
|
#if YYMAXDEPTH == 0 |
|
#undef YYMAXDEPTH |
|
#endif |
|
|
|
#ifndef YYMAXDEPTH |
|
#define YYMAXDEPTH 10000 |
|
#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. */ |
|
static void |
|
__yy_memcpy (to, from, count) |
|
char *to; |
|
char *from; |
|
unsigned int count; |
|
{ |
|
register char *f = from; |
|
register char *t = to; |
|
register int i = count; |
|
|
|
while (i-- > 0) |
|
*t++ = *f++; |
|
} |
|
|
|
#else /* __cplusplus */ |
|
|
|
/* This is the most reliable way to avoid incompatibilities |
|
in available built-in functions on various systems. */ |
|
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) |
|
*t++ = *f++; |
|
} |
|
|
|
#endif |
|
#endif |
|
|
|
#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 |
|
#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 |
|
int yyparse (void *); |
|
#else |
|
int yyparse (void); |
|
#endif |
|
#endif |
|
|
int | int |
yyparse() |
yyparse(YYPARSE_PARAM_ARG) |
|
YYPARSE_PARAM_DECL |
{ | { |
register int yym, yyn, yystate; |
register int yystate; |
#if YYDEBUG |
register int yyn; |
register char *yys; |
register short *yyssp; |
extern char *getenv(); |
register YYSTYPE *yyvsp; |
|
int yyerrstatus; /* number of tokens to shift before error messages enabled */ |
if (yys = getenv("YYDEBUG")) |
int yychar1 = 0; /* lookahead token as an internal (translated) token number */ |
{ |
|
yyn = *yys; |
short yyssa[YYINITDEPTH]; /* the state stack */ |
if (yyn >= '0' && yyn <= '9') |
YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */ |
yydebug = yyn - '0'; |
|
} |
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--) |
|
#endif |
|
|
|
int yystacksize = YYINITDEPTH; |
|
int yyfree_stacks = 0; |
|
|
|
#ifdef YYPURE |
|
int yychar; |
|
YYSTYPE yylval; |
|
int yynerrs; |
|
#ifdef YYLSP_NEEDED |
|
YYLTYPE yylloc; |
#endif | #endif |
|
#endif |
|
|
|
YYSTYPE yyval; /* the variable used to return */ |
|
/* semantic values from the action */ |
|
/* routines */ |
|
|
|
int yylen; |
| |
|
#if YYDEBUG != 0 |
|
if (yydebug) |
|
fprintf(stderr, "Starting parse\n"); |
|
#endif |
|
|
|
yystate = 0; |
|
yyerrstatus = 0; |
yynerrs = 0; | yynerrs = 0; |
yyerrflag = 0; |
yychar = YYEMPTY; /* Cause a token to be read. */ |
yychar = (-1); |
|
| |
yyssp = yyss; |
/* Initialize stack pointers. |
|
Waste one element of value and location stack |
|
so that they stay on the same level as the state stack. |
|
The wasted elements are never initialized. */ |
|
|
|
yyssp = yyss - 1; |
yyvsp = yyvs; | yyvsp = yyvs; |
*yyssp = yystate = 0; |
#ifdef YYLSP_NEEDED |
|
yylsp = yyls; |
|
#endif |
| |
yyloop: |
/* Push a new state, which is found in yystate . */ |
if (yyn = yydefred[yystate]) goto yyreduce; |
/* In all cases, when you get here, the value and location stacks |
if (yychar < 0) |
have just been pushed. so pushing a state here evens the stacks. */ |
{ |
yynewstate: |
if ((yychar = yylex()) < 0) yychar = 0; |
|
#if YYDEBUG |
*++yyssp = yystate; |
if (yydebug) |
|
|
if (yyssp >= yyss + yystacksize - 1) |
{ | { |
yys = 0; |
/* Give user a chance to reallocate the stack */ |
if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; |
/* Use copies of these so that the &'s don't force the real ones into memory. */ |
if (!yys) yys = "illegal-symbol"; |
YYSTYPE *yyvs1 = yyvs; |
printf("%sdebug: state %d, reading %d (%s)\n", |
short *yyss1 = yyss; |
YYPREFIX, yystate, yychar, yys); |
#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 data in use in that stack, in bytes. */ |
|
#ifdef YYLSP_NEEDED |
|
/* This used to be a conditional around just the two extra args, |
|
but that might be undefined if yyoverflow is a macro. */ |
|
yyoverflow("parser stack overflow", |
|
&yyss1, size * sizeof (*yyssp), |
|
&yyvs1, size * sizeof (*yyvsp), |
|
&yyls1, size * sizeof (*yylsp), |
|
&yystacksize); |
|
#else |
|
yyoverflow("parser stack overflow", |
|
&yyss1, size * sizeof (*yyssp), |
|
&yyvs1, size * sizeof (*yyvsp), |
|
&yystacksize); |
|
#endif |
|
|
|
yyss = yyss1; yyvs = yyvs1; |
|
#ifdef YYLSP_NEEDED |
|
yyls = yyls1; |
|
#endif |
|
#else /* no yyoverflow */ |
|
/* Extend the stack our own way. */ |
|
if (yystacksize >= YYMAXDEPTH) |
|
{ |
|
yyerror("parser stack overflow"); |
|
if (yyfree_stacks) |
|
{ |
|
free (yyss); |
|
free (yyvs); |
|
#ifdef YYLSP_NEEDED |
|
free (yyls); |
#endif | #endif |
} | } |
if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 && |
return 2; |
yyn <= YYTABLESIZE && yycheck[yyn] == yychar) |
} |
{ |
yystacksize *= 2; |
#if YYDEBUG |
if (yystacksize > YYMAXDEPTH) |
|
yystacksize = YYMAXDEPTH; |
|
#ifndef YYSTACK_USE_ALLOCA |
|
yyfree_stacks = 1; |
|
#endif |
|
yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp)); |
|
__yy_memcpy ((char *)yyss, (char *)yyss1, |
|
size * (unsigned int) sizeof (*yyssp)); |
|
yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp)); |
|
__yy_memcpy ((char *)yyvs, (char *)yyvs1, |
|
size * (unsigned int) sizeof (*yyvsp)); |
|
#ifdef YYLSP_NEEDED |
|
yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp)); |
|
__yy_memcpy ((char *)yyls, (char *)yyls1, |
|
size * (unsigned int) sizeof (*yylsp)); |
|
#endif |
|
#endif /* no yyoverflow */ |
|
|
|
yyssp = yyss + size - 1; |
|
yyvsp = yyvs + size - 1; |
|
#ifdef YYLSP_NEEDED |
|
yylsp = yyls + size - 1; |
|
#endif |
|
|
|
#if YYDEBUG != 0 |
if (yydebug) | if (yydebug) |
printf("%sdebug: state %d, shifting to state %d\n", |
fprintf(stderr, "Stack size increased to %d\n", yystacksize); |
YYPREFIX, yystate, yytable[yyn]); |
|
#endif | #endif |
|
|
if (yyssp >= yyss + yystacksize - 1) | if (yyssp >= yyss + yystacksize - 1) |
{ |
YYABORT; |
goto yyoverflow; |
|
} |
|
*++yyssp = yystate = yytable[yyn]; |
|
*++yyvsp = yylval; |
|
yychar = (-1); |
|
if (yyerrflag > 0) --yyerrflag; |
|
goto yyloop; |
|
} | } |
if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 && |
|
yyn <= YYTABLESIZE && yycheck[yyn] == yychar) |
#if YYDEBUG != 0 |
{ |
if (yydebug) |
yyn = yytable[yyn]; |
fprintf(stderr, "Entering state %d\n", yystate); |
goto yyreduce; |
|
} |
|
if (yyerrflag) goto yyinrecovery; |
|
#ifdef lint |
|
goto yynewerror; |
|
#endif |
|
yynewerror: |
|
yyerror("syntax error"); |
|
#ifdef lint |
|
goto yyerrlab; |
|
#endif | #endif |
yyerrlab: |
|
++yynerrs; |
goto yybackup; |
yyinrecovery: |
yybackup: |
if (yyerrflag < 3) |
|
{ |
/* Do appropriate processing given the current state. */ |
yyerrflag = 3; |
/* Read a lookahead token if we need one and don't already have one. */ |
for (;;) |
/* yyresume: */ |
{ |
|
if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 && |
/* First try to decide what to do without reference to lookahead token. */ |
yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE) |
|
|
yyn = yypact[yystate]; |
|
if (yyn == YYFLAG) |
|
goto yydefault; |
|
|
|
/* Not known => get a lookahead token if don't already have one. */ |
|
|
|
/* yychar is either YYEMPTY or YYEOF |
|
or a valid token in external form. */ |
|
|
|
if (yychar == YYEMPTY) |
{ | { |
#if YYDEBUG |
#if YYDEBUG != 0 |
if (yydebug) | if (yydebug) |
printf("%sdebug: state %d, error recovery shifting\ |
fprintf(stderr, "Reading a token: "); |
to state %d\n", YYPREFIX, *yyssp, yytable[yyn]); |
|
#endif | #endif |
if (yyssp >= yyss + yystacksize - 1) |
yychar = YYLEX; |
{ |
|
goto yyoverflow; |
|
} | } |
*++yyssp = yystate = yytable[yyn]; |
|
*++yyvsp = yylval; |
/* Convert token to internal form (in yychar1) for indexing tables with */ |
goto yyloop; |
|
} |
if (yychar <= 0) /* This means end of input. */ |
else |
|
{ | { |
#if YYDEBUG |
yychar1 = 0; |
|
yychar = YYEOF; /* Don't call YYLEX any more */ |
|
|
|
#if YYDEBUG != 0 |
if (yydebug) | if (yydebug) |
printf("%sdebug: error recovery discarding state %d\n", |
fprintf(stderr, "Now at end of input.\n"); |
YYPREFIX, *yyssp); |
|
#endif | #endif |
if (yyssp <= yyss) goto yyabort; |
|
--yyssp; |
|
--yyvsp; |
|
} |
|
} |
|
} | } |
else | else |
{ | { |
if (yychar == 0) goto yyabort; |
yychar1 = YYTRANSLATE(yychar); |
#if YYDEBUG |
|
|
#if YYDEBUG != 0 |
if (yydebug) | if (yydebug) |
{ | { |
yys = 0; |
fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]); |
if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; |
/* Give the individual parser a way to print the precise meaning |
if (!yys) yys = "illegal-symbol"; |
of a token, for further debugging info. */ |
printf("%sdebug: state %d, error recovery discards token %d (%s)\n", |
#ifdef YYPRINT |
YYPREFIX, yystate, yychar, yys); |
YYPRINT (stderr, yychar, yylval); |
|
#endif |
|
fprintf (stderr, ")\n"); |
} | } |
#endif | #endif |
yychar = (-1); |
|
goto yyloop; |
|
} | } |
yyreduce: |
|
#if YYDEBUG |
yyn += yychar1; |
|
if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) |
|
goto yydefault; |
|
|
|
yyn = yytable[yyn]; |
|
|
|
/* 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) |
|
goto yyerrlab; |
|
yyn = -yyn; |
|
goto yyreduce; |
|
} |
|
else if (yyn == 0) |
|
goto yyerrlab; |
|
|
|
if (yyn == YYFINAL) |
|
YYACCEPT; |
|
|
|
/* Shift the lookahead token. */ |
|
|
|
#if YYDEBUG != 0 |
if (yydebug) | if (yydebug) |
printf("%sdebug: state %d, reducing by rule %d (%s)\n", |
fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]); |
YYPREFIX, yystate, yyn, yyrule[yyn]); |
#endif |
|
|
|
/* Discard the token being shifted unless it is eof. */ |
|
if (yychar != YYEOF) |
|
yychar = YYEMPTY; |
|
|
|
*++yyvsp = yylval; |
|
#ifdef YYLSP_NEEDED |
|
*++yylsp = yylloc; |
#endif | #endif |
yym = yylen[yyn]; |
|
yyval = yyvsp[1-yym]; |
/* count tokens shifted since error; after three, turn off error status. */ |
switch (yyn) |
if (yyerrstatus) yyerrstatus--; |
|
|
|
yystate = yyn; |
|
goto yynewstate; |
|
|
|
/* Do the default action for the current state. */ |
|
yydefault: |
|
|
|
yyn = yydefact[yystate]; |
|
if (yyn == 0) |
|
goto yyerrlab; |
|
|
|
/* Do a reduction. yyn is the number of a rule to reduce with. */ |
|
yyreduce: |
|
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), ", |
|
yyn, yyrline[yyn]); |
|
|
|
/* 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 |
|
|
|
|
|
switch (yyn) { |
|
|
case 1: | case 1: |
#line 131 "WQL.y" | #line 131 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: start\n")); | WQL_TRACE(("YACC: start\n")); |
} |
; |
break; |
break;} |
case 2: | case 2: |
#line 137 "WQL.y" | #line 137 "WQL.y" |
{ | { |
| |
} |
; |
break; |
break;} |
case 3: | case 3: |
#line 143 "WQL.y" | #line 143 "WQL.y" |
{ | { |
globalParserState->statement->appendPropertyName("*"); |
globalParserState->statement->appendSelectPropertyName("*"); |
} |
; |
break; |
break;} |
case 4: | case 4: |
#line 147 "WQL.y" | #line 147 "WQL.y" |
{ | { |
| |
} |
; |
break; |
break;} |
case 5: | case 5: |
#line 153 "WQL.y" | #line 153 "WQL.y" |
{ | { |
globalParserState->statement->appendPropertyName(yyvsp[0].strValue); |
globalParserState->statement->appendSelectPropertyName(yyvsp[0].strValue); |
} |
; |
break; |
break;} |
case 6: | case 6: |
#line 157 "WQL.y" | #line 157 "WQL.y" |
{ | { |
globalParserState->statement->appendPropertyName(yyvsp[0].strValue); |
globalParserState->statement->appendSelectPropertyName(yyvsp[0].strValue); |
} |
; |
break; |
break;} |
case 7: | case 7: |
#line 163 "WQL.y" | #line 163 "WQL.y" |
{ | { |
| |
} |
; |
break; |
break;} |
case 8: | case 8: |
#line 167 "WQL.y" | #line 167 "WQL.y" |
{ | { |
| |
} |
; |
break; |
break;} |
case 9: | case 9: |
#line 173 "WQL.y" | #line 173 "WQL.y" |
{ | { |
WQL_TRACE(("YACC: fromClause: TOK_FROM className(%s)\n", yyvsp[0].strValue)); | WQL_TRACE(("YACC: fromClause: TOK_FROM className(%s)\n", yyvsp[0].strValue)); |
globalParserState->statement->setClassName(yyvsp[0].strValue); | globalParserState->statement->setClassName(yyvsp[0].strValue); |
} |
; |
break; |
break;} |
case 10: | case 10: |
#line 180 "WQL.y" | #line 180 "WQL.y" |
{ | { |
| |
} |
; |
break; |
break;} |
case 11: | case 11: |
#line 186 "WQL.y" | #line 186 "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: | case 12: |
#line 191 "WQL.y" | #line 191 "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: | case 13: |
#line 196 "WQL.y" | #line 196 "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: | case 14: |
#line 202 "WQL.y" | #line 202 "WQL.y" |
{ | { |
| |
} |
; |
break; |
break;} |
case 15: | case 15: |
#line 206 "WQL.y" | #line 206 "WQL.y" |
{ | { |
| |
} |
; |
break; |
break;} |
case 16: | case 16: |
#line 210 "WQL.y" | #line 210 "WQL.y" |
{ | { |
WQLOperation op = yyvsp[0].intValue ? WQL_IS_TRUE : WQL_IS_FALSE; | WQLOperation op = yyvsp[0].intValue ? WQL_IS_TRUE : WQL_IS_FALSE; |
globalParserState->statement->appendOperation(op); | globalParserState->statement->appendOperation(op); |
} |
; |
break; |
break;} |
case 17: | case 17: |
#line 215 "WQL.y" | #line 215 "WQL.y" |
{ | { |
WQLOperation op = yyvsp[0].intValue ? WQL_IS_NOT_TRUE : WQL_IS_NOT_FALSE; | WQLOperation op = yyvsp[0].intValue ? WQL_IS_NOT_TRUE : WQL_IS_NOT_FALSE; |
globalParserState->statement->appendOperation(op); | globalParserState->statement->appendOperation(op); |
} |
; |
break; |
break;} |
case 18: | case 18: |
#line 224 "WQL.y" | #line 224 "WQL.y" |
{ | { |
| |
} |
; |
break; |
break;} |
case 19: | case 19: |
#line 228 "WQL.y" | #line 228 "WQL.y" |
{ | { |
| |
} |
; |
break; |
break;} |
case 20: | case 20: |
#line 234 "WQL.y" | #line 234 "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: | case 21: |
#line 239 "WQL.y" | #line 239 "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: | case 22: |
#line 244 "WQL.y" | #line 244 "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: | case 23: |
#line 249 "WQL.y" | #line 249 "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: | case 24: |
#line 254 "WQL.y" | #line 254 "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: | case 25: |
#line 259 "WQL.y" | #line 259 "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: | case 26: |
#line 266 "WQL.y" | #line 266 "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: | case 27: |
#line 271 "WQL.y" | #line 271 "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: | case 28: |
#line 278 "WQL.y" | #line 278 "WQL.y" |
{ | { |
yyval.intValue = 1; | yyval.intValue = 1; |
} |
; |
break; |
break;} |
case 29: | case 29: |
#line 282 "WQL.y" | #line 282 "WQL.y" |
{ | { |
yyval.intValue = 0; | yyval.intValue = 0; |
} |
; |
break; |
break;} |
case 30: | case 30: |
#line 288 "WQL.y" | #line 288 "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: | case 31: |
#line 294 "WQL.y" | #line 294 "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: | case 32: |
#line 301 "WQL.y" | #line 301 "WQL.y" |
{ | { |
globalParserState->statement->appendOperand( | globalParserState->statement->appendOperand( |
WQLOperand(yyvsp[0].strValue, WQLOperand::PROPERTY_NAME_TAG)); |
WQLOperand(yyvsp[0].strValue, WQL_PROPERTY_NAME_TAG)); |
} |
globalParserState->statement->appendWherePropertyName(yyvsp[0].strValue); |
break; |
; |
|
break;} |
case 33: | case 33: |
#line 306 "WQL.y" |
#line 307 "WQL.y" |
{ | { |
globalParserState->statement->appendOperand( | globalParserState->statement->appendOperand( |
WQLOperand(yyvsp[0].intValue, WQLOperand::INTEGER_VALUE_TAG)); |
WQLOperand(yyvsp[0].intValue, WQL_INTEGER_VALUE_TAG)); |
} |
; |
break; |
break;} |
case 34: | case 34: |
#line 311 "WQL.y" |
#line 312 "WQL.y" |
{ | { |
globalParserState->statement->appendOperand( | globalParserState->statement->appendOperand( |
WQLOperand(yyvsp[0].doubleValue, WQLOperand::DOUBLE_VALUE_TAG)); |
WQLOperand(yyvsp[0].doubleValue, WQL_DOUBLE_VALUE_TAG)); |
} |
; |
break; |
break;} |
case 35: | case 35: |
#line 316 "WQL.y" |
#line 317 "WQL.y" |
{ | { |
globalParserState->statement->appendOperand( | globalParserState->statement->appendOperand( |
WQLOperand(yyvsp[0].strValue, WQLOperand::STRING_VALUE_TAG)); |
WQLOperand(yyvsp[0].strValue, WQL_STRING_VALUE_TAG)); |
} |
; |
break; |
break;} |
case 36: | case 36: |
#line 321 "WQL.y" |
#line 322 "WQL.y" |
{ | { |
globalParserState->statement->appendOperand( | globalParserState->statement->appendOperand( |
WQLOperand(yyvsp[0].intValue != 0, WQLOperand::BOOLEAN_VALUE_TAG)); |
WQLOperand(yyvsp[0].intValue != 0, WQL_BOOLEAN_VALUE_TAG)); |
|
; |
|
break;} |
|
} |
|
/* 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"); |
} | } |
break; |
#endif |
#line 669 "y.tab.c" |
|
|
*++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; |
} | } |
yyssp -= yym; |
else |
yystate = *yyssp; |
|
yyvsp -= yym; |
|
yym = yylhs[yyn]; |
|
if (yystate == 0 && yym == 0) |
|
{ | { |
#if YYDEBUG |
yylsp->last_line = (yylsp+yylen-1)->last_line; |
if (yydebug) |
yylsp->last_column = (yylsp+yylen-1)->last_column; |
printf("%sdebug: after reduction, shifting from state 0 to\ |
} |
state %d\n", YYPREFIX, YYFINAL); |
|
#endif | #endif |
yystate = YYFINAL; |
|
*++yyssp = YYFINAL; |
/* Now "shift" the result of the reduction. |
*++yyvsp = yyval; |
Determine what state that goes to, |
if (yychar < 0) |
based on the state we popped back to |
|
and the rule number reduced by. */ |
|
|
|
yyn = yyr1[yyn]; |
|
|
|
yystate = yypgoto[yyn - YYNTBASE] + *yyssp; |
|
if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) |
|
yystate = yytable[yystate]; |
|
else |
|
yystate = yydefgoto[yyn - YYNTBASE]; |
|
|
|
goto yynewstate; |
|
|
|
yyerrlab: /* here on detecting error */ |
|
|
|
if (! yyerrstatus) |
|
/* If not already recovering from an error, report this error. */ |
{ | { |
if ((yychar = yylex()) < 0) yychar = 0; |
++yynerrs; |
#if YYDEBUG |
|
if (yydebug) |
#ifdef YYERROR_VERBOSE |
|
yyn = yypact[yystate]; |
|
|
|
if (yyn > YYFLAG && yyn < YYLAST) |
|
{ |
|
int size = 0; |
|
char *msg; |
|
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) |
{ | { |
yys = 0; |
strcat(msg, count == 0 ? ", expecting `" : " or `"); |
if (yychar <= YYMAXTOKEN) yys = yyname[yychar]; |
strcat(msg, yytname[x]); |
if (!yys) yys = "illegal-symbol"; |
strcat(msg, "'"); |
printf("%sdebug: state %d, reading %d (%s)\n", |
count++; |
YYPREFIX, YYFINAL, yychar, yys); |
|
} | } |
#endif |
|
} | } |
if (yychar == 0) goto yyaccept; |
yyerror(msg); |
goto yyloop; |
free(msg); |
|
} |
|
else |
|
yyerror ("parse error; also virtual memory exceeded"); |
} | } |
if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 && |
|
yyn <= YYTABLESIZE && yycheck[yyn] == yystate) |
|
yystate = yytable[yyn]; |
|
else | else |
yystate = yydgoto[yym]; |
#endif /* YYERROR_VERBOSE */ |
#if YYDEBUG |
yyerror("parse error"); |
|
} |
|
|
|
goto yyerrlab1; |
|
yyerrlab1: /* here on error raised explicitly by an action */ |
|
|
|
if (yyerrstatus == 3) |
|
{ |
|
/* if just tried and failed to reuse lookahead token after an error, discard it. */ |
|
|
|
/* return failure if at end of input */ |
|
if (yychar == YYEOF) |
|
YYABORT; |
|
|
|
#if YYDEBUG != 0 |
if (yydebug) | if (yydebug) |
printf("%sdebug: after reduction, shifting from state %d \ |
fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]); |
to state %d\n", YYPREFIX, *yyssp, yystate); |
|
#endif | #endif |
if (yyssp >= yyss + yystacksize - 1) |
|
|
yychar = YYEMPTY; |
|
} |
|
|
|
/* Else will try to reuse lookahead token |
|
after shifting the error token. */ |
|
|
|
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 |
|
should shift them. */ |
|
yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ |
|
if (yyn) goto yydefault; |
|
#endif |
|
|
|
yyerrpop: /* pop the current state because it cannot handle the error token */ |
|
|
|
if (yyssp == yyss) YYABORT; |
|
yyvsp--; |
|
yystate = *--yyssp; |
|
#ifdef YYLSP_NEEDED |
|
yylsp--; |
|
#endif |
|
|
|
#if YYDEBUG != 0 |
|
if (yydebug) |
{ | { |
goto yyoverflow; |
short *ssp1 = yyss - 1; |
|
fprintf (stderr, "Error: state stack now"); |
|
while (ssp1 != yyssp) |
|
fprintf (stderr, " %d", *++ssp1); |
|
fprintf (stderr, "\n"); |
} | } |
*++yyssp = yystate; |
#endif |
*++yyvsp = yyval; |
|
goto yyloop; |
yyerrhandle: |
yyoverflow: |
|
yyerror("yacc stack overflow"); |
yyn = yypact[yystate]; |
yyabort: |
if (yyn == YYFLAG) |
return (1); |
goto yyerrdefault; |
yyaccept: |
|
return (0); |
yyn += YYTERROR; |
|
if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) |
|
goto yyerrdefault; |
|
|
|
yyn = yytable[yyn]; |
|
if (yyn < 0) |
|
{ |
|
if (yyn == YYFLAG) |
|
goto yyerrpop; |
|
yyn = -yyn; |
|
goto yyreduce; |
|
} |
|
else if (yyn == 0) |
|
goto yyerrpop; |
|
|
|
if (yyn == YYFINAL) |
|
YYACCEPT; |
|
|
|
#if YYDEBUG != 0 |
|
if (yydebug) |
|
fprintf(stderr, "Shifting error token, "); |
|
#endif |
|
|
|
*++yyvsp = yylval; |
|
#ifdef YYLSP_NEEDED |
|
*++yylsp = yylloc; |
|
#endif |
|
|
|
yystate = yyn; |
|
goto yynewstate; |
|
|
|
yyacceptlab: |
|
/* YYACCEPT comes here. */ |
|
if (yyfree_stacks) |
|
{ |
|
free (yyss); |
|
free (yyvs); |
|
#ifdef YYLSP_NEEDED |
|
free (yyls); |
|
#endif |
} | } |
|
return 0; |
|
|
|
yyabortlab: |
|
/* YYABORT comes here. */ |
|
if (yyfree_stacks) |
|
{ |
|
free (yyss); |
|
free (yyvs); |
|
#ifdef YYLSP_NEEDED |
|
free (yyls); |
|
#endif |
|
} |
|
return 1; |
|
} |
|
#line 327 "WQL.y" |
|
|