1 mike 1.1 /*
2 **==============================================================================
3 **
4 ** Open Management Infrastructure (OMI)
5 **
6 ** Copyright (c) Microsoft Corporation
7 **
8 ** Licensed under the Apache License, Version 2.0 (the "License"); you may not
9 ** use this file except in compliance with the License. You may obtain a copy
10 ** of the License at
11 **
12 ** http://www.apache.org/licenses/LICENSE-2.0
13 **
14 ** THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15 ** KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
16 ** WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
17 ** MERCHANTABLITY OR NON-INFRINGEMENT.
18 **
19 ** See the Apache 2 License for the specific language governing permissions
20 ** and limitations under the License.
21 **
22 mike 1.1 **==============================================================================
23 */
24
25 #ifndef lint
26 static const char yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93";
27 #endif
28
29 #define YYBYACC 1
30 #define YYMAJOR 1
31 #define YYMINOR 9
32 #define YYPATCH 20110908
33
34 #define YYEMPTY (-1)
35 #define yyclearin (yychar = YYEMPTY)
36 #define yyerrok (yyerrflag = 0)
37 #define YYRECOVERING() (yyerrflag != 0)
38
39
40 #ifndef yyparse
41 #define yyparse wqlparse
42 #endif /* yyparse */
43 mike 1.1
44 #ifndef yylex
45 #define yylex wqllex
46 #endif /* yylex */
47
48 #ifndef yyerror
49 #define yyerror wqlerror
50 #endif /* yyerror */
51
52 #ifndef yychar
53 #define yychar wqlchar
54 #endif /* yychar */
55
56 #ifndef yyval
57 #define yyval wqlval
58 #endif /* yyval */
59
60 #ifndef yylval
61 #define yylval wqllval
62 #endif /* yylval */
63
64 mike 1.1 #ifndef yydebug
65 #define yydebug wqldebug
66 #endif /* yydebug */
67
68 #ifndef yynerrs
69 #define yynerrs wqlnerrs
70 #endif /* yynerrs */
71
72 #ifndef yyerrflag
73 #define yyerrflag wqlerrflag
74 #endif /* yyerrflag */
75
76 #ifndef yylhs
77 #define yylhs wqllhs
78 #endif /* yylhs */
79
80 #ifndef yylen
81 #define yylen wqllen
82 #endif /* yylen */
83
84 #ifndef yydefred
85 mike 1.1 #define yydefred wqldefred
86 #endif /* yydefred */
87
88 #ifndef yydgoto
89 #define yydgoto wqldgoto
90 #endif /* yydgoto */
91
92 #ifndef yysindex
93 #define yysindex wqlsindex
94 #endif /* yysindex */
95
96 #ifndef yyrindex
97 #define yyrindex wqlrindex
98 #endif /* yyrindex */
99
100 #ifndef yygindex
101 #define yygindex wqlgindex
102 #endif /* yygindex */
103
104 #ifndef yytable
105 #define yytable wqltable
106 mike 1.1 #endif /* yytable */
107
108 #ifndef yycheck
109 #define yycheck wqlcheck
110 #endif /* yycheck */
111
112 #ifndef yyname
113 #define yyname wqlname
114 #endif /* yyname */
115
116 #ifndef yyrule
117 #define yyrule wqlrule
118 #endif /* yyrule */
119 #define YYPREFIX "wql"
120
121 #define YYPURE 0
122
123 #line 2 "wql.y"
124
125 #include <stdio.h>
126 #include "state.h"
127 mike 1.1 #include "wql.h"
128
129 #if 0
130 # define YACCTRACE(MSG) \
131 printf("WQL_TRACE: %s(%d): %s\n", __FILE__, __LINE__, #MSG)
132 #else
133 # define YACCTRACE(MSG)
134 #endif
135
136 extern int wqllex();
137 extern void wqlerror(const char* msg);
138
139 extern int yylex();
140 extern void yyerror(const char* msg);
141
142 extern void* wqlmalloc(size_t size);
143 extern MI_Char* wqlstrdup(const MI_Char* str);
144
145 #line 25 "wql.y"
146 #ifdef YYSTYPE
147 #undef YYSTYPE_IS_DECLARED
148 mike 1.1 #define YYSTYPE_IS_DECLARED 1
149 #endif
150 #ifndef YYSTYPE_IS_DECLARED
151 #define YYSTYPE_IS_DECLARED 1
152 typedef union
153 {
154 WQL_Symbol symbol;
155 MI_Char* string;
156 long long integer;
157 double real;
158 unsigned char boolean;
159 } YYSTYPE;
160 #endif /* !YYSTYPE_IS_DECLARED */
161 #line 137 "y.tab.c"
162
163 /* compatibility with bison */
164 #ifdef YYPARSE_PARAM
165 /* compatibility with FreeBSD */
166 # ifdef YYPARSE_PARAM_TYPE
167 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
168 # else
169 mike 1.1 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
170 # endif
171 #else
172 # define YYPARSE_DECL() yyparse(void)
173 #endif
174
175 /* Parameters sent to lex. */
176 #ifdef YYLEX_PARAM
177 # define YYLEX_DECL() yylex(void *YYLEX_PARAM)
178 # define YYLEX yylex(YYLEX_PARAM)
179 #else
180 # define YYLEX_DECL() yylex(void)
181 # define YYLEX yylex()
182 #endif
183
184 /* Parameters sent to yyerror. */
185 #define YYERROR_DECL() yyerror(const char *s)
186 #define YYERROR_CALL(msg) yyerror(msg)
187
188 extern int YYPARSE_DECL();
189
190 mike 1.1 #define WQL_OR 257
191 #define WQL_AND 258
192 #define WQL_NOT 259
193 #define WQL_ERROR 260
194 #define WQL_LT 261
195 #define WQL_FROM 262
196 #define WQL_LE 263
197 #define WQL_WHERE 264
198 #define WQL_NE 265
199 #define WQL_GT 266
200 #define WQL_REAL 267
201 #define WQL_EQ 268
202 #define WQL_SELECT 269
203 #define WQL_GE 270
204 #define WQL_NULL 271
205 #define WQL_IDENTIFIER 272
206 #define WQL_BOOLEAN 273
207 #define WQL_INTEGER 274
208 #define WQL_STRING 275
209 #define YYERRCODE 256
210 static const short wqllhs[] = { -1,
211 mike 1.1 0, 0, 2, 2, 4, 4, 3, 3, 3, 3,
212 3, 5, 5, 5, 5, 5, 5, 1, 1, 1,
213 1, 1, 1,
214 };
215 static const short wqllen[] = { 2,
216 4, 6, 1, 1, 1, 3, 3, 2, 3, 3,
217 1, 3, 3, 3, 3, 3, 3, 1, 1, 1,
218 1, 1, 1,
219 };
220 static const short wqldefred[] = { 0,
221 0, 0, 5, 3, 0, 0, 0, 0, 0, 6,
222 0, 0, 20, 23, 22, 18, 19, 21, 0, 0,
223 0, 11, 8, 0, 0, 0, 0, 0, 0, 0,
224 0, 0, 7, 14, 15, 13, 16, 12, 17, 0,
225 9,
226 };
227 static const short wqldgoto[] = { 2,
228 20, 5, 21, 6, 22,
229 };
230 static const short wqlsindex[] = { -249,
231 -36, 0, 0, 0, -233, -14, -241, -240, -231, 0,
232 mike 1.1 -40, -40, 0, 0, 0, 0, 0, 0, -40, -258,
233 -244, 0, 0, -37, -256, -256, -256, -256, -256, -256,
234 -40, -40, 0, 0, 0, 0, 0, 0, 0, -224,
235 0,
236 };
237 static const short wqlrindex[] = { 0,
238 0, 0, 0, 0, 0, -227, 0, 0, 36, 0,
239 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
240 37, 0, 0, 0, 0, 0, 0, 0, 0, 0,
241 0, 0, 0, 0, 0, 0, 0, 0, 0, 1,
242 0,
243 };
244 static const short wqlgindex[] = { 0,
245 -2, 0, -10, 0, 0,
246 };
247 #define YYTABLESIZE 258
248 static const short wqltable[] = { 19,
249 10, 23, 25, 33, 26, 4, 27, 28, 24, 29,
250 13, 30, 31, 32, 14, 15, 16, 17, 18, 1,
251 40, 41, 34, 35, 36, 37, 38, 39, 7, 8,
252 9, 10, 11, 32, 4, 1, 2, 0, 0, 0,
253 mike 1.1 0, 10, 0, 0, 0, 0, 0, 0, 0, 0,
254 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
255 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
256 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
257 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
258 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
259 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
260 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
261 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
262 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
263 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
264 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
265 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
266 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
267 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
268 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
269 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
270 0, 0, 0, 0, 0, 0, 0, 0, 12, 31,
271 32, 0, 0, 0, 0, 0, 13, 0, 0, 0,
272 14, 15, 16, 17, 18, 3, 0, 0, 0, 0,
273 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
274 mike 1.1 0, 0, 0, 0, 0, 0, 0, 10,
275 };
276 static const short wqlcheck[] = { 40,
277 0, 12, 261, 41, 263, 42, 265, 266, 19, 268,
278 267, 270, 257, 258, 271, 272, 273, 274, 275, 269,
279 31, 32, 25, 26, 27, 28, 29, 30, 262, 44,
280 272, 272, 264, 258, 262, 0, 0, -1, -1, -1,
281 -1, 41, -1, -1, -1, -1, -1, -1, -1, -1,
282 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
283 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
284 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
285 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
286 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
287 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
288 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
289 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
290 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
291 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
292 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
293 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
294 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
295 mike 1.1 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
296 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
297 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
298 -1, -1, -1, -1, -1, -1, -1, -1, 259, 257,
299 258, -1, -1, -1, -1, -1, 267, -1, -1, -1,
300 271, 272, 273, 274, 275, 272, -1, -1, -1, -1,
301 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
302 -1, -1, -1, -1, -1, -1, -1, 257,
303 };
304 #define YYFINAL 2
305 #ifndef YYDEBUG
306 #define YYDEBUG 0
307 #endif
308 #define YYMAXTOKEN 275
309 #if YYDEBUG
310 static const char *yyname[] = {
311
312 "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,
313 0,0,0,0,0,0,"'('","')'","'*'",0,"','",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
314 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
315 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
316 mike 1.1 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
317 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
318 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"WQL_OR",
319 "WQL_AND","WQL_NOT","WQL_ERROR","WQL_LT","WQL_FROM","WQL_LE","WQL_WHERE",
320 "WQL_NE","WQL_GT","WQL_REAL","WQL_EQ","WQL_SELECT","WQL_GE","WQL_NULL",
321 "WQL_IDENTIFIER","WQL_BOOLEAN","WQL_INTEGER","WQL_STRING",
322 };
323 static const char *yyrule[] = {
324 "$accept : Start",
325 "Start : WQL_SELECT SelectList WQL_FROM WQL_IDENTIFIER",
326 "Start : WQL_SELECT SelectList WQL_FROM WQL_IDENTIFIER WQL_WHERE Condition",
327 "SelectList : '*'",
328 "SelectList : PropertyList",
329 "PropertyList : WQL_IDENTIFIER",
330 "PropertyList : PropertyList ',' WQL_IDENTIFIER",
331 "Condition : '(' Condition ')'",
332 "Condition : WQL_NOT Condition",
333 "Condition : Condition WQL_AND Condition",
334 "Condition : Condition WQL_OR Condition",
335 "Condition : Predicate",
336 "Predicate : Operand WQL_EQ Operand",
337 mike 1.1 "Predicate : Operand WQL_NE Operand",
338 "Predicate : Operand WQL_LT Operand",
339 "Predicate : Operand WQL_LE Operand",
340 "Predicate : Operand WQL_GT Operand",
341 "Predicate : Operand WQL_GE Operand",
342 "Operand : WQL_BOOLEAN",
343 "Operand : WQL_INTEGER",
344 "Operand : WQL_REAL",
345 "Operand : WQL_STRING",
346 "Operand : WQL_IDENTIFIER",
347 "Operand : WQL_NULL",
348
349 };
350 #endif
351
352 int yydebug;
353 int yynerrs;
354
355 int yyerrflag;
356 int yychar;
357 YYSTYPE yyval;
358 mike 1.1 YYSTYPE yylval;
359
360 /* define the initial stack-sizes */
361 #ifdef YYSTACKSIZE
362 #undef YYMAXDEPTH
363 #define YYMAXDEPTH YYSTACKSIZE
364 #else
365 #ifdef YYMAXDEPTH
366 #define YYSTACKSIZE YYMAXDEPTH
367 #else
368 #define YYSTACKSIZE 500
369 #define YYMAXDEPTH 500
370 #endif
371 #endif
372
373 #define YYINITSTACKSIZE 500
374
375 typedef struct {
376 unsigned stacksize;
377 short *s_base;
378 short *s_mark;
379 mike 1.1 short *s_last;
380 YYSTYPE *l_base;
381 YYSTYPE *l_mark;
382 } YYSTACKDATA;
383 /* variables for the parser stack */
384 static YYSTACKDATA yystack;
385
386 #if YYDEBUG
387 #include <stdio.h> /* needed for printf */
388 #endif
389
390 #include <stdlib.h> /* needed for malloc, etc */
391 #include <string.h> /* needed for memset */
392
393 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
394 static int yygrowstack(YYSTACKDATA *data)
395 {
396 int i;
397 unsigned newsize;
398 short *newss;
399 YYSTYPE *newvs;
400 mike 1.1
401 if ((newsize = data->stacksize) == 0)
402 newsize = YYINITSTACKSIZE;
403 else if (newsize >= YYMAXDEPTH)
404 return -1;
405 else if ((newsize *= 2) > YYMAXDEPTH)
406 newsize = YYMAXDEPTH;
407
408 i = data->s_mark - data->s_base;
409 newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
410 if (newss == 0)
411 return -1;
412
413 data->s_base = newss;
414 data->s_mark = newss + i;
415
416 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
417 if (newvs == 0)
418 return -1;
419
420 data->l_base = newvs;
421 mike 1.1 data->l_mark = newvs + i;
422
423 data->stacksize = newsize;
424 data->s_last = data->s_base + newsize - 1;
425 return 0;
426 }
427
428 #if YYPURE || defined(YY_NO_LEAKS)
429 static void yyfreestack(YYSTACKDATA *data)
430 {
431 free(data->s_base);
432 free(data->l_base);
433 memset(data, 0, sizeof(*data));
434 }
435 #else
436 #define yyfreestack(data) /* nothing */
437 #endif
438
439 #define YYABORT goto yyabort
440 #define YYREJECT goto yyabort
441 #define YYACCEPT goto yyaccept
442 mike 1.1 #define YYERROR goto yyerrlab
443
444 int
445 YYPARSE_DECL()
446 {
447 int yym, yyn, yystate;
448 #if YYDEBUG
449 const char *yys;
450
451 if ((yys = getenv("YYDEBUG")) != 0)
452 {
453 yyn = *yys;
454 if (yyn >= '0' && yyn <= '9')
455 yydebug = yyn - '0';
456 }
457 #endif
458
459 yynerrs = 0;
460 yyerrflag = 0;
461 yychar = YYEMPTY;
462 yystate = 0;
463 mike 1.1
464 #if YYPURE
465 memset(&yystack, 0, sizeof(yystack));
466 #endif
467
468 if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;
469 yystack.s_mark = yystack.s_base;
470 yystack.l_mark = yystack.l_base;
471 yystate = 0;
472 *yystack.s_mark = 0;
473
474 yyloop:
475 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
476 if (yychar < 0)
477 {
478 if ((yychar = YYLEX) < 0) yychar = 0;
479 #if YYDEBUG
480 if (yydebug)
481 {
482 yys = 0;
483 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
484 mike 1.1 if (!yys) yys = "illegal-symbol";
485 printf("%sdebug: state %d, reading %d (%s)\n",
486 YYPREFIX, yystate, yychar, yys);
487 }
488 #endif
489 }
490 if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
491 yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
492 {
493 #if YYDEBUG
494 if (yydebug)
495 printf("%sdebug: state %d, shifting to state %d\n",
496 YYPREFIX, yystate, yytable[yyn]);
497 #endif
498 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
499 {
500 goto yyoverflow;
501 }
502 yystate = yytable[yyn];
503 *++yystack.s_mark = yytable[yyn];
504 *++yystack.l_mark = yylval;
505 mike 1.1 yychar = YYEMPTY;
506 if (yyerrflag > 0) --yyerrflag;
507 goto yyloop;
508 }
509 if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
510 yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
511 {
512 yyn = yytable[yyn];
513 goto yyreduce;
514 }
515 if (yyerrflag) goto yyinrecovery;
516
517 yyerror("syntax error");
518
519 goto yyerrlab;
520
521 yyerrlab:
522 ++yynerrs;
523
524 yyinrecovery:
525 if (yyerrflag < 3)
526 mike 1.1 {
527 yyerrflag = 3;
528 for (;;)
529 {
530 if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
531 yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
532 {
533 #if YYDEBUG
534 if (yydebug)
535 printf("%sdebug: state %d, error recovery shifting\
536 to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
537 #endif
538 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
539 {
540 goto yyoverflow;
541 }
542 yystate = yytable[yyn];
543 *++yystack.s_mark = yytable[yyn];
544 *++yystack.l_mark = yylval;
545 goto yyloop;
546 }
547 mike 1.1 else
548 {
549 #if YYDEBUG
550 if (yydebug)
551 printf("%sdebug: error recovery discarding state %d\n",
552 YYPREFIX, *yystack.s_mark);
553 #endif
554 if (yystack.s_mark <= yystack.s_base) goto yyabort;
555 --yystack.s_mark;
556 --yystack.l_mark;
557 }
558 }
559 }
560 else
561 {
562 if (yychar == 0) goto yyabort;
563 #if YYDEBUG
564 if (yydebug)
565 {
566 yys = 0;
567 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
568 mike 1.1 if (!yys) yys = "illegal-symbol";
569 printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
570 YYPREFIX, yystate, yychar, yys);
571 }
572 #endif
573 yychar = YYEMPTY;
574 goto yyloop;
575 }
576
577 yyreduce:
578 #if YYDEBUG
579 if (yydebug)
580 printf("%sdebug: state %d, reducing by rule %d (%s)\n",
581 YYPREFIX, yystate, yyn, yyrule[yyn]);
582 #endif
583 yym = yylen[yyn];
584 if (yym)
585 yyval = yystack.l_mark[1-yym];
586 else
587 memset(&yyval, 0, sizeof yyval);
588 switch (yyn)
589 mike 1.1 {
590 case 1:
591 #line 64 "wql.y"
592 {
593 YACCTRACE(Start1);
594 wqlstate.wql->className = yystack.l_mark[0].string;
595 }
596 break;
597 case 2:
598 #line 69 "wql.y"
599 {
600 YACCTRACE(Start2);
601 wqlstate.wql->className = yystack.l_mark[-2].string;
602 }
603 break;
604 case 3:
605 #line 76 "wql.y"
606 {
607 YACCTRACE(SelectList1);
608 }
609 break;
610 mike 1.1 case 4:
611 #line 80 "wql.y"
612 {
613 YACCTRACE(SelectList12);
614 }
615 break;
616 case 5:
617 #line 86 "wql.y"
618 {
619 YACCTRACE(PropertyList1);
620
621 if (wqlstate.wql->nproperties == WQL_MAX_PROPERTIES)
622 {
623 yyerror("property array overflow");
624 YYABORT;
625 }
626
627 wqlstate.wql->properties[wqlstate.wql->nproperties++] = yystack.l_mark[0].string;
628 }
629 break;
630 case 6:
631 mike 1.1 #line 98 "wql.y"
632 {
633 YACCTRACE(PropertyList2);
634
635 if (wqlstate.wql->nproperties == WQL_MAX_PROPERTIES)
636 {
637 yyerror("property array overflow");
638 YYABORT;
639 }
640
641 wqlstate.wql->properties[wqlstate.wql->nproperties++] = yystack.l_mark[0].string;
642 }
643 break;
644 case 7:
645 #line 112 "wql.y"
646 {
647 YACCTRACE(Condition1);
648 }
649 break;
650 case 8:
651 #line 116 "wql.y"
652 mike 1.1 {
653 WQL_Symbol operator;
654
655 YACCTRACE(Condition2);
656
657 if (wqlstate.wql->nsymbols == WQL_MAX_SYMBOLS)
658 {
659 yyerror("symbol array overflow");
660 YYABORT;
661 }
662
663 memset(&operator, 0, sizeof(WQL_Symbol));
664 operator.type = WQL_TYPE_NOT;
665 wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;
666 }
667 break;
668 case 9:
669 #line 132 "wql.y"
670 {
671 WQL_Symbol operator;
672
673 mike 1.1 YACCTRACE(Condition3);
674
675 if (wqlstate.wql->nsymbols == WQL_MAX_SYMBOLS)
676 {
677 yyerror("symbol array overflow");
678 YYABORT;
679 }
680
681 memset(&operator, 0, sizeof(WQL_Symbol));
682 operator.type = WQL_TYPE_AND;
683 wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;
684 }
685 break;
686 case 10:
687 #line 148 "wql.y"
688 {
689 WQL_Symbol operator;
690
691 YACCTRACE(Condition4);
692
693 if (wqlstate.wql->nsymbols == WQL_MAX_SYMBOLS)
694 mike 1.1 {
695 yyerror("symbol array overflow");
696 YYABORT;
697 }
698
699 memset(&operator, 0, sizeof(WQL_Symbol));
700 operator.type = WQL_TYPE_OR;
701 wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;
702 }
703 break;
704 case 11:
705 #line 164 "wql.y"
706 {
707 YACCTRACE(Condition5);
708 }
709 break;
710 case 12:
711 #line 170 "wql.y"
712 {
713 WQL_Symbol operator;
714
715 mike 1.1 YACCTRACE(Predicate1);
716
717 if (wqlstate.wql->nsymbols + 3 > WQL_MAX_SYMBOLS)
718 {
719 yyerror("symbol array overflow");
720 YYABORT;
721 }
722
723 memset(&operator, 0, sizeof(WQL_Symbol));
724 operator.type = WQL_TYPE_EQ;
725
726 wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[-2].symbol;
727 wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[0].symbol;
728 wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;
729 }
730 break;
731 case 13:
732 #line 189 "wql.y"
733 {
734 WQL_Symbol operator;
735
736 mike 1.1 YACCTRACE(Predicate2);
737
738 if (wqlstate.wql->nsymbols + 3 > WQL_MAX_SYMBOLS)
739 {
740 yyerror("symbol array overflow");
741 YYABORT;
742 }
743
744 memset(&operator, 0, sizeof(WQL_Symbol));
745 operator.type = WQL_TYPE_NE;
746
747 wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[-2].symbol;
748 wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[0].symbol;
749 wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;
750 }
751 break;
752 case 14:
753 #line 208 "wql.y"
754 {
755 WQL_Symbol operator;
756
757 mike 1.1 YACCTRACE(Predicate3);
758
759 if (wqlstate.wql->nsymbols + 3 > WQL_MAX_SYMBOLS)
760 {
761 yyerror("symbol array overflow");
762 YYABORT;
763 }
764
765 memset(&operator, 0, sizeof(WQL_Symbol));
766 operator.type = WQL_TYPE_LT;
767
768 wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[-2].symbol;
769 wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[0].symbol;
770 wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;
771 }
772 break;
773 case 15:
774 #line 227 "wql.y"
775 {
776 WQL_Symbol operator;
777
778 mike 1.1 YACCTRACE(Predicate4);
779
780 if (wqlstate.wql->nsymbols + 3 > WQL_MAX_SYMBOLS)
781 {
782 yyerror("symbol array overflow");
783 YYABORT;
784 }
785
786 memset(&operator, 0, sizeof(WQL_Symbol));
787 operator.type = WQL_TYPE_LE;
788
789 wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[-2].symbol;
790 wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[0].symbol;
791 wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;
792 }
793 break;
794 case 16:
795 #line 246 "wql.y"
796 {
797 WQL_Symbol operator;
798
799 mike 1.1 YACCTRACE(Predicate5);
800
801 if (wqlstate.wql->nsymbols + 3 > WQL_MAX_SYMBOLS)
802 {
803 yyerror("symbol array overflow");
804 YYABORT;
805 }
806
807 memset(&operator, 0, sizeof(WQL_Symbol));
808 operator.type = WQL_TYPE_GT;
809
810 wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[-2].symbol;
811 wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[0].symbol;
812 wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;
813 }
814 break;
815 case 17:
816 #line 265 "wql.y"
817 {
818 WQL_Symbol operator;
819
820 mike 1.1 YACCTRACE(Predicate6);
821
822 if (wqlstate.wql->nsymbols + 3 > WQL_MAX_SYMBOLS)
823 {
824 yyerror("symbol array overflow");
825 YYABORT;
826 }
827
828 memset(&operator, 0, sizeof(WQL_Symbol));
829 operator.type = WQL_TYPE_GE;
830
831 wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[-2].symbol;
832 wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[0].symbol;
833 wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;
834 }
835 break;
836 case 18:
837 #line 286 "wql.y"
838 {
839 YACCTRACE(Operand1);
840 yyval.symbol.value.boolean = yystack.l_mark[0].boolean;
841 mike 1.1 yyval.symbol.type = WQL_TYPE_BOOLEAN;
842 }
843 break;
844 case 19:
845 #line 292 "wql.y"
846 {
847 YACCTRACE(Operand2);
848 yyval.symbol.value.integer = yystack.l_mark[0].integer;
849 yyval.symbol.type = WQL_TYPE_INTEGER;
850 }
851 break;
852 case 20:
853 #line 298 "wql.y"
854 {
855 YACCTRACE(Operand3);
856 yyval.symbol.value.real = yystack.l_mark[0].real;
857 yyval.symbol.type = WQL_TYPE_REAL;
858 }
859 break;
860 case 21:
861 #line 304 "wql.y"
862 mike 1.1 {
863 YACCTRACE(Operand4);
864 yyval.symbol.value.string = yystack.l_mark[0].string;
865 yyval.symbol.type = WQL_TYPE_STRING;
866 }
867 break;
868 case 22:
869 #line 310 "wql.y"
870 {
871 YACCTRACE(Operand5);
872 yyval.symbol.value.string = yystack.l_mark[0].string;
873 yyval.symbol.type = WQL_TYPE_IDENTIFIER;
874 }
875 break;
876 case 23:
877 #line 316 "wql.y"
878 {
879 YACCTRACE(Operand6);
880 yyval.symbol.value.integer = 0;
881 yyval.symbol.type = WQL_TYPE_NULL;
882 }
883 mike 1.1 break;
884 #line 860 "y.tab.c"
885 }
886 yystack.s_mark -= yym;
887 yystate = *yystack.s_mark;
888 yystack.l_mark -= yym;
889 yym = yylhs[yyn];
890 if (yystate == 0 && yym == 0)
891 {
892 #if YYDEBUG
893 if (yydebug)
894 printf("%sdebug: after reduction, shifting from state 0 to\
895 state %d\n", YYPREFIX, YYFINAL);
896 #endif
897 yystate = YYFINAL;
898 *++yystack.s_mark = YYFINAL;
899 *++yystack.l_mark = yyval;
900 if (yychar < 0)
901 {
902 if ((yychar = YYLEX) < 0) yychar = 0;
903 #if YYDEBUG
904 mike 1.1 if (yydebug)
905 {
906 yys = 0;
907 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
908 if (!yys) yys = "illegal-symbol";
909 printf("%sdebug: state %d, reading %d (%s)\n",
910 YYPREFIX, YYFINAL, yychar, yys);
911 }
912 #endif
913 }
914 if (yychar == 0) goto yyaccept;
915 goto yyloop;
916 }
917 if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
918 yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
919 yystate = yytable[yyn];
920 else
921 yystate = yydgoto[yym];
922 #if YYDEBUG
923 if (yydebug)
924 printf("%sdebug: after reduction, shifting from state %d \
925 mike 1.1 to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
926 #endif
927 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))
928 {
929 goto yyoverflow;
930 }
931 *++yystack.s_mark = (short) yystate;
932 *++yystack.l_mark = yyval;
933 goto yyloop;
934
935 yyoverflow:
936 yyerror("yacc stack overflow");
937
938 yyabort:
939 yyfreestack(&yystack);
940 return (1);
941
942 yyaccept:
943 yyfreestack(&yystack);
944 return (0);
945 }
|
Return to
wqlyaccinc.c
CVS log
Up to [OMI] / omi / wql