1 mike  1.2 

   2 kumpf 1.3 /*  A Bison parser, made from WQL.y
   3               by GNU Bison version 1.28  */

   4 mike  1.2 
   5           #define YYBISON 1  /* Identify Bison output.  */
   6           
   7           #define yyparse WQL_parse
   8           #define yylex WQL_lex
   9           #define yyerror WQL_error
  10           #define yylval WQL_lval
  11           #define yychar WQL_char
  12           #define yydebug WQL_debug
  13           #define yynerrs WQL_nerrs

  14 kumpf 1.3 #define	TOK_INTEGER	257
  15           #define	TOK_DOUBLE	258
  16           #define	TOK_STRING	259
  17           #define	TOK_TRUE	260
  18           #define	TOK_FALSE	261
  19           #define	TOK_NULL	262
  20           #define	TOK_EQ	263
  21           #define	TOK_NE	264
  22           #define	TOK_LT	265
  23           #define	TOK_LE	266
  24           #define	TOK_GT	267
  25           #define	TOK_GE	268
  26           #define	TOK_NOT	269
  27           #define	TOK_OR	270
  28           #define	TOK_AND	271
  29           #define	TOK_IS	272
  30           #define	TOK_IDENTIFIER	273
  31           #define	TOK_SELECT	274
  32           #define	TOK_WHERE	275
  33           #define	TOK_FROM	276
  34           #define	TOK_UNEXPECTED_CHAR	277

  35 mike  1.2 

  36 kumpf 1.3 #line 9 "WQL.y"

  37 mike  1.2 
  38           
  39           #include <Pegasus/Common/Config.h>
  40           #include <Pegasus/WQL/WQLOperation.h>
  41           #include <Pegasus/WQL/WQLOperand.h>
  42           #include <Pegasus/WQL/WQLParserState.h>
  43           #include <Pegasus/WQL/WQLSelectStatement.h>
  44           #include <string.h>
  45           #include <stdlib.h>
  46           
  47           #ifdef PEGASUS_OS_TYPE_WINDOWS
  48           # include <malloc.h>
  49           #endif
  50           
  51           #if defined(PEGASUS_COMPILER_ACC) && defined(PEGASUS_OS_HPUX)
  52           # include <alloca.h>
  53           #endif
  54           
  55           #if 0
  56           # define WQL_TRACE(X) printf X
  57           #else
  58 mike  1.2 # define WQL_TRACE(X)
  59           #endif
  60           
  61           extern int WQL_lex();

  62 kumpf 1.3 extern int WQL_error(const char*);

  63 mike  1.2 
  64           //
  65           // Define the global parser state object:
  66           //
  67           
  68           PEGASUS_USING_PEGASUS;
  69           
  70           PEGASUS_NAMESPACE_BEGIN
  71           
  72           extern WQLParserState* globalParserState;
  73           
  74           PEGASUS_NAMESPACE_END
  75           
  76           

  77 kumpf 1.3 #line 58 "WQL.y"

  78 mike  1.2 typedef union 
  79           {
  80              int intValue;
  81              double doubleValue;
  82              char* strValue;
  83              void* nodeValue;
  84           } YYSTYPE;
  85           #include <stdio.h>
  86           
  87           #ifndef __cplusplus
  88           #ifndef __STDC__
  89           #define const
  90           #endif
  91           #endif
  92           
  93           
  94           
  95           #define	YYFINAL		60
  96           #define	YYFLAG		-32768
  97           #define	YYNTBASE	28
  98           

  99 kumpf 1.3 #define YYTRANSLATE(x) ((unsigned)(x) <= 277 ? yytranslate[x] : 43)

 100 mike  1.2 
 101           static const char yytranslate[] = {     0,
 102                2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 103                2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 104                2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 105                2,     2,     2,     2,     2,     2,     2,     2,     2,    26,
 106               27,    24,     2,    25,     2,     2,     2,     2,     2,     2,
 107                2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 108                2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 109                2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 110                2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 111                2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 112                2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 113                2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 114                2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 115                2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 116                2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 117                2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 118                2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 119                2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 120                2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 121 mike  1.2      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 122                2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 123                2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 124                2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 125                2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
 126                2,     2,     2,     2,     2,     2,     2,     2,     2,     2,

 127 kumpf 1.3      2,     2,     2,     2,     2,     1,     3,     4,     5,     6,
 128                7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
 129               17,    18,    19,    20,    21,    22,    23

 130 mike  1.2 };
 131           
 132           #if YYDEBUG != 0
 133           static const short yyprhs[] = {     0,
 134                0,     2,     6,     8,    10,    12,    16,    19,    21,    24,
 135               27,    31,    35,    38,    42,    44,    48,    53,    55,    57,
 136               61,    65,    69,    73,    77,    81,    85,    90,    92,    94,
 137               96,    98,   100,   102,   104,   106
 138           };
 139           
 140           static const short yyrhs[] = {    29,
 141                0,    20,    30,    32,     0,    24,     0,    31,     0,    40,
 142                0,    31,    25,    40,     0,    33,    34,     0,    33,     0,
 143               22,    41,     0,    21,    35,     0,    35,    16,    35,     0,
 144               35,    17,    35,     0,    15,    35,     0,    26,    35,    27,
 145                0,    36,     0,    36,    18,    39,     0,    36,    18,    15,
 146               39,     0,    37,     0,    38,     0,    42,    11,    42,     0,
 147               42,    13,    42,     0,    42,    12,    42,     0,    42,    14,
 148               42,     0,    42,     9,    42,     0,    42,    10,    42,     0,
 149               42,    18,     8,     0,    42,    18,    15,     8,     0,     6,
 150                0,     7,     0,    19,     0,    19,     0,    40,     0,     3,
 151 mike  1.2      0,     4,     0,     5,     0,    39,     0
 152           };
 153           
 154           #endif
 155           
 156           #if YYDEBUG != 0
 157           static const short yyrline[] = { 0,
 158              130,   136,   142,   146,   152,   156,   162,   166,   172,   179,
 159              185,   190,   195,   201,   205,   209,   214,   223,   227,   233,
 160              238,   243,   248,   253,   258,   265,   270,   277,   281,   287,
 161              293,   300,   306,   311,   316,   321
 162           };

 163 kumpf 1.3 #endif
 164           
 165           
 166           #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)

 167 mike  1.2 
 168           static const char * const yytname[] = {   "$","error","$undefined.","TOK_INTEGER",
 169           "TOK_DOUBLE","TOK_STRING","TOK_TRUE","TOK_FALSE","TOK_NULL","TOK_EQ","TOK_NE",
 170           "TOK_LT","TOK_LE","TOK_GT","TOK_GE","TOK_NOT","TOK_OR","TOK_AND","TOK_IS","TOK_IDENTIFIER",
 171           "TOK_SELECT","TOK_WHERE","TOK_FROM","TOK_UNEXPECTED_CHAR","'*'","','","'('",
 172           "')'","start","selectStatement","selectList","propertyList","selectExpression",
 173           "fromClause","whereClause","searchCondition","predicate","comparisonPredicate",

 174 kumpf 1.3 "nullPredicate","truthValue","propertyName","className","comparisonTerm", NULL

 175 mike  1.2 };
 176           #endif
 177           
 178           static const short yyr1[] = {     0,
 179               28,    29,    30,    30,    31,    31,    32,    32,    33,    34,
 180               35,    35,    35,    35,    35,    35,    35,    36,    36,    37,
 181               37,    37,    37,    37,    37,    38,    38,    39,    39,    40,
 182               41,    42,    42,    42,    42,    42
 183           };
 184           
 185           static const short yyr2[] = {     0,
 186                1,     3,     1,     1,     1,     3,     2,     1,     2,     2,
 187                3,     3,     2,     3,     1,     3,     4,     1,     1,     3,
 188                3,     3,     3,     3,     3,     3,     4,     1,     1,     1,
 189                1,     1,     1,     1,     1,     1
 190           };
 191           
 192           static const short yydefact[] = {     0,
 193                0,     1,    30,     3,     0,     4,     5,     0,     2,     8,
 194                0,    31,     9,     0,     7,     6,    33,    34,    35,    28,
 195               29,     0,     0,    10,    15,    18,    19,    36,    32,     0,
 196 mike  1.2     13,     0,     0,     0,     0,     0,     0,     0,     0,     0,
 197                0,     0,    14,    11,    12,     0,    16,    24,    25,    20,
 198               22,    21,    23,    26,     0,    17,    27,     0,     0,     0
 199           };
 200           
 201           static const short yydefgoto[] = {    58,
 202                2,     5,     6,     9,    10,    15,    24,    25,    26,    27,
 203               28,    29,    13,    30
 204           };
 205           
 206           static const short yypact[] = {    -5,
 207               18,-32768,-32768,-32768,     5,    16,-32768,    24,-32768,    33,
 208               26,-32768,-32768,    -3,-32768,-32768,-32768,-32768,-32768,-32768,
 209           -32768,    -3,    -3,    23,    37,-32768,-32768,-32768,-32768,    20,
 210           -32768,     1,    -3,    -3,    29,     2,     2,     2,     2,     2,
 211                2,    11,-32768,    39,-32768,    46,-32768,-32768,-32768,-32768,
 212           -32768,-32768,-32768,-32768,    49,-32768,-32768,    58,    59,-32768
 213           };
 214           
 215           static const short yypgoto[] = {-32768,
 216           -32768,-32768,-32768,-32768,-32768,-32768,    -9,-32768,-32768,-32768,
 217 mike  1.2    -24,     9,-32768,    10
 218           };
 219           
 220           
 221           #define	YYLAST		59
 222           
 223           
 224           static const short yytable[] = {    17,
 225               18,    19,    20,    21,    17,    18,    19,    20,    21,     7,
 226               47,    22,    31,    32,     1,     3,    33,    34,    54,    16,
 227                3,    56,    23,    44,    45,    55,     8,    43,    36,    37,
 228               38,    39,    40,    41,    20,    21,     3,    42,    33,    34,
 229               11,     4,    12,    46,     3,    48,    49,    50,    51,    52,
 230               53,    20,    21,    14,    35,    34,    57,    59,    60
 231           };
 232           
 233           static const short yycheck[] = {     3,
 234                4,     5,     6,     7,     3,     4,     5,     6,     7,     1,
 235               35,    15,    22,    23,    20,    19,    16,    17,     8,    11,
 236               19,    46,    26,    33,    34,    15,    22,    27,     9,    10,
 237               11,    12,    13,    14,     6,     7,    19,    18,    16,    17,
 238 mike  1.2     25,    24,    19,    15,    19,    36,    37,    38,    39,    40,
 239               41,     6,     7,    21,    18,    17,     8,     0,     0
 240           };
 241           /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
 242           #line 3 "bison.simple"
 243           /* This file comes from bison-@bison_version@.  */
 244           
 245           /* Skeleton output parser for bison,
 246              Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
 247           
 248              This program is free software; you can redistribute it and/or modify
 249              it under the terms of the GNU General Public License as published by
 250              the Free Software Foundation; either version 2, or (at your option)
 251              any later version.
 252           
 253              This program is distributed in the hope that it will be useful,
 254              but WITHOUT ANY WARRANTY; without even the implied warranty of
 255              MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 256              GNU General Public License for more details.
 257           
 258              You should have received a copy of the GNU General Public License
 259 mike  1.2    along with this program; if not, write to the Free Software
 260              Foundation, Inc., 59 Temple Place - Suite 330,
 261              Boston, MA 02111-1307, USA.  */
 262           
 263           /* As a special exception, when this file is copied by Bison into a
 264              Bison output file, you may use that output file without restriction.
 265              This special exception was added by the Free Software Foundation
 266              in version 1.24 of Bison.  */
 267           
 268           /* This is the parser code that is written into each bison parser
 269             when the %semantic_parser declaration is not specified in the grammar.
 270             It was written by Richard Stallman by simplifying the hairy parser
 271             used when %semantic_parser is specified.  */
 272           
 273           #ifndef YYSTACK_USE_ALLOCA
 274           #ifdef alloca
 275           #define YYSTACK_USE_ALLOCA
 276           #else /* alloca not defined */
 277           #ifdef __GNUC__
 278           #define YYSTACK_USE_ALLOCA
 279           #define alloca __builtin_alloca
 280 mike  1.2 #else /* not GNU C.  */
 281           #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
 282           #define YYSTACK_USE_ALLOCA
 283           #include <alloca.h>
 284           #else /* not sparc */
 285           /* We think this test detects Watcom and Microsoft C.  */
 286           /* This used to test MSDOS, but that is a bad idea
 287              since that symbol is in the user namespace.  */
 288           #if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
 289           #if 0 /* No need for malloc.h, which pollutes the namespace;
 290           	 instead, just don't use alloca.  */
 291           #include <malloc.h>
 292           #endif
 293           #else /* not MSDOS, or __TURBOC__ */
 294           #if defined(_AIX)
 295           /* I don't know what this was needed for, but it pollutes the namespace.
 296              So I turned it off.   rms, 2 May 1997.  */
 297           /* #include <malloc.h>  */
 298            #pragma alloca
 299           #define YYSTACK_USE_ALLOCA
 300           #else /* not MSDOS, or __TURBOC__, or _AIX */
 301 mike  1.2 #if 0
 302           #ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
 303           		 and on HPUX 10.  Eventually we can turn this on.  */
 304           #define YYSTACK_USE_ALLOCA
 305           #define alloca __builtin_alloca
 306           #endif /* __hpux */
 307           #endif
 308           #endif /* not _AIX */
 309           #endif /* not MSDOS, or __TURBOC__ */
 310           #endif /* not sparc */
 311           #endif /* not GNU C */
 312           #endif /* alloca not defined */
 313           #endif /* YYSTACK_USE_ALLOCA not defined */
 314           
 315           #ifdef YYSTACK_USE_ALLOCA
 316           #define YYSTACK_ALLOC alloca
 317           #else
 318           #define YYSTACK_ALLOC malloc
 319           #endif
 320           
 321           /* Note: there must be only one dollar sign in this file.
 322 mike  1.2    It is replaced by the list of actions, each action
 323              as one case of the switch.  */
 324           
 325           #define yyerrok		(yyerrstatus = 0)
 326           #define yyclearin	(yychar = YYEMPTY)
 327           #define YYEMPTY		-2
 328           #define YYEOF		0
 329           #define YYACCEPT	goto yyacceptlab
 330           #define YYABORT 	goto yyabortlab
 331           #define YYERROR		goto yyerrlab1
 332           /* Like YYERROR except do call yyerror.
 333              This remains here temporarily to ease the
 334              transition to the new meaning of YYERROR, for GCC.
 335              Once GCC version 2 has supplanted version 1, this can go.  */
 336           #define YYFAIL		goto yyerrlab
 337           #define YYRECOVERING()  (!!yyerrstatus)
 338           #define YYBACKUP(token, value) \
 339           do								\
 340             if (yychar == YYEMPTY && yylen == 1)				\
 341               { yychar = (token), yylval = (value);			\
 342                 yychar1 = YYTRANSLATE (yychar);				\
 343 mike  1.2       YYPOPSTACK;						\
 344                 goto yybackup;						\
 345               }								\
 346             else								\
 347               { yyerror ("syntax error: cannot back up"); YYERROR; }	\
 348           while (0)
 349           
 350           #define YYTERROR	1
 351           #define YYERRCODE	256
 352           
 353           #ifndef YYPURE
 354           #define YYLEX		yylex()
 355           #endif
 356           
 357           #ifdef YYPURE
 358           #ifdef YYLSP_NEEDED
 359           #ifdef YYLEX_PARAM
 360           #define YYLEX		yylex(&yylval, &yylloc, YYLEX_PARAM)
 361           #else
 362           #define YYLEX		yylex(&yylval, &yylloc)
 363           #endif
 364 mike  1.2 #else /* not YYLSP_NEEDED */
 365           #ifdef YYLEX_PARAM
 366           #define YYLEX		yylex(&yylval, YYLEX_PARAM)
 367           #else
 368           #define YYLEX		yylex(&yylval)
 369           #endif
 370           #endif /* not YYLSP_NEEDED */
 371           #endif
 372           
 373           /* If nonreentrant, generate the variables here */
 374           
 375           #ifndef YYPURE
 376           
 377           int	yychar;			/*  the lookahead symbol		*/
 378           YYSTYPE	yylval;			/*  the semantic value of the		*/
 379           				/*  lookahead symbol			*/
 380           
 381           #ifdef YYLSP_NEEDED
 382           YYLTYPE yylloc;			/*  location data for the lookahead	*/
 383           				/*  symbol				*/
 384           #endif
 385 mike  1.2 
 386           int yynerrs;			/*  number of parse errors so far       */
 387           #endif  /* not YYPURE */
 388           
 389           #if YYDEBUG != 0
 390           int yydebug;			/*  nonzero means print parse trace	*/
 391           /* Since this is uninitialized, it does not stop multiple parsers
 392              from coexisting.  */
 393           #endif
 394           
 395           /*  YYINITDEPTH indicates the initial size of the parser's stacks	*/
 396           
 397           #ifndef	YYINITDEPTH
 398           #define YYINITDEPTH 200
 399           #endif
 400           
 401           /*  YYMAXDEPTH is the maximum size the stacks can grow to
 402               (effective only if the built-in stack extension method is used).  */
 403           
 404           #if YYMAXDEPTH == 0
 405           #undef YYMAXDEPTH
 406 mike  1.2 #endif
 407           
 408           #ifndef YYMAXDEPTH
 409           #define YYMAXDEPTH 10000
 410           #endif
 411           
 412           /* Define __yy_memcpy.  Note that the size argument
 413              should be passed with type unsigned int, because that is what the non-GCC
 414              definitions require.  With GCC, __builtin_memcpy takes an arg
 415              of type size_t, but it can handle unsigned int.  */
 416           
 417           #if __GNUC__ > 1		/* GNU C and GNU C++ define this.  */
 418           #define __yy_memcpy(TO,FROM,COUNT)	__builtin_memcpy(TO,FROM,COUNT)
 419           #else				/* not GNU C or C++ */
 420           #ifndef __cplusplus
 421           
 422           /* This is the most reliable way to avoid incompatibilities
 423              in available built-in functions on various systems.  */
 424           static void
 425           __yy_memcpy (to, from, count)
 426                char *to;
 427 mike  1.2      char *from;
 428                unsigned int count;
 429           {
 430             register char *f = from;
 431             register char *t = to;
 432             register int i = count;
 433           
 434             while (i-- > 0)
 435               *t++ = *f++;
 436           }
 437           
 438           #else /* __cplusplus */
 439           
 440           /* This is the most reliable way to avoid incompatibilities
 441              in available built-in functions on various systems.  */
 442           static void
 443           __yy_memcpy (char *to, char *from, unsigned int count)
 444           {
 445             register char *t = to;
 446             register char *f = from;
 447             register int i = count;
 448 mike  1.2 
 449             while (i-- > 0)
 450               *t++ = *f++;
 451           }
 452           
 453           #endif
 454           #endif
 455           
 456           #line 217 "bison.simple"
 457           
 458           /* The user can define YYPARSE_PARAM as the name of an argument to be passed
 459              into yyparse.  The argument should have type void *.
 460              It should actually point to an object.
 461              Grammar actions can access the variable by casting it
 462              to the proper pointer type.  */
 463           
 464           #ifdef YYPARSE_PARAM
 465           #ifdef __cplusplus
 466           #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
 467           #define YYPARSE_PARAM_DECL
 468           #else /* not __cplusplus */
 469 mike  1.2 #define YYPARSE_PARAM_ARG YYPARSE_PARAM
 470           #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
 471           #endif /* not __cplusplus */
 472           #else /* not YYPARSE_PARAM */
 473           #define YYPARSE_PARAM_ARG
 474           #define YYPARSE_PARAM_DECL
 475           #endif /* not YYPARSE_PARAM */
 476           
 477           /* Prevent warning if -Wstrict-prototypes.  */
 478           #ifdef __GNUC__
 479           #ifdef YYPARSE_PARAM
 480           int yyparse (void *);
 481           #else
 482           int yyparse (void);
 483           #endif
 484           #endif
 485           
 486           int
 487           yyparse(YYPARSE_PARAM_ARG)
 488                YYPARSE_PARAM_DECL
 489           {
 490 mike  1.2   register int yystate;
 491             register int yyn;
 492             register short *yyssp;
 493             register YYSTYPE *yyvsp;
 494             int yyerrstatus;	/*  number of tokens to shift before error messages enabled */
 495             int yychar1 = 0;		/*  lookahead token as an internal (translated) token number */
 496           
 497             short	yyssa[YYINITDEPTH];	/*  the state stack			*/
 498             YYSTYPE yyvsa[YYINITDEPTH];	/*  the semantic value stack		*/
 499           
 500             short *yyss = yyssa;		/*  refer to the stacks thru separate pointers */
 501             YYSTYPE *yyvs = yyvsa;	/*  to allow yyoverflow to reallocate them elsewhere */
 502           
 503           #ifdef YYLSP_NEEDED
 504             YYLTYPE yylsa[YYINITDEPTH];	/*  the location stack			*/
 505             YYLTYPE *yyls = yylsa;
 506             YYLTYPE *yylsp;
 507           
 508           #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
 509           #else
 510           #define YYPOPSTACK   (yyvsp--, yyssp--)
 511 mike  1.2 #endif
 512           
 513             int yystacksize = YYINITDEPTH;
 514             int yyfree_stacks = 0;
 515           
 516           #ifdef YYPURE
 517             int yychar;
 518             YYSTYPE yylval;
 519             int yynerrs;
 520           #ifdef YYLSP_NEEDED
 521             YYLTYPE yylloc;
 522           #endif
 523           #endif
 524           
 525             YYSTYPE yyval;		/*  the variable used to return		*/
 526           				/*  semantic values from the action	*/
 527           				/*  routines				*/
 528           
 529             int yylen;
 530           
 531           #if YYDEBUG != 0
 532 mike  1.2   if (yydebug)
 533               fprintf(stderr, "Starting parse\n");
 534           #endif
 535           
 536             yystate = 0;
 537             yyerrstatus = 0;
 538             yynerrs = 0;
 539             yychar = YYEMPTY;		/* Cause a token to be read.  */
 540           
 541             /* Initialize stack pointers.
 542                Waste one element of value and location stack
 543                so that they stay on the same level as the state stack.
 544                The wasted elements are never initialized.  */
 545           
 546             yyssp = yyss - 1;
 547             yyvsp = yyvs;
 548           #ifdef YYLSP_NEEDED
 549             yylsp = yyls;
 550           #endif
 551           
 552           /* Push a new state, which is found in  yystate  .  */
 553 mike  1.2 /* In all cases, when you get here, the value and location stacks
 554              have just been pushed. so pushing a state here evens the stacks.  */
 555           yynewstate:
 556           
 557             *++yyssp = yystate;
 558           
 559             if (yyssp >= yyss + yystacksize - 1)
 560               {
 561                 /* Give user a chance to reallocate the stack */
 562                 /* Use copies of these so that the &'s don't force the real ones into memory. */
 563                 YYSTYPE *yyvs1 = yyvs;
 564                 short *yyss1 = yyss;
 565           #ifdef YYLSP_NEEDED
 566                 YYLTYPE *yyls1 = yyls;
 567           #endif
 568           
 569                 /* Get the current used size of the three stacks, in elements.  */
 570                 int size = yyssp - yyss + 1;
 571           
 572           #ifdef yyoverflow
 573                 /* Each stack pointer address is followed by the size of
 574 mike  1.2 	 the data in use in that stack, in bytes.  */
 575           #ifdef YYLSP_NEEDED
 576                 /* This used to be a conditional around just the two extra args,
 577           	 but that might be undefined if yyoverflow is a macro.  */
 578                 yyoverflow("parser stack overflow",
 579           		 &yyss1, size * sizeof (*yyssp),
 580           		 &yyvs1, size * sizeof (*yyvsp),
 581           		 &yyls1, size * sizeof (*yylsp),
 582           		 &yystacksize);
 583           #else
 584                 yyoverflow("parser stack overflow",
 585           		 &yyss1, size * sizeof (*yyssp),
 586           		 &yyvs1, size * sizeof (*yyvsp),
 587           		 &yystacksize);
 588           #endif
 589           
 590                 yyss = yyss1; yyvs = yyvs1;
 591           #ifdef YYLSP_NEEDED
 592                 yyls = yyls1;
 593           #endif
 594           #else /* no yyoverflow */
 595 mike  1.2       /* Extend the stack our own way.  */
 596                 if (yystacksize >= YYMAXDEPTH)
 597           	{
 598           	  yyerror("parser stack overflow");
 599           	  if (yyfree_stacks)
 600           	    {
 601           	      free (yyss);
 602           	      free (yyvs);
 603           #ifdef YYLSP_NEEDED
 604           	      free (yyls);
 605           #endif
 606           	    }
 607           	  return 2;
 608           	}
 609                 yystacksize *= 2;
 610                 if (yystacksize > YYMAXDEPTH)
 611           	yystacksize = YYMAXDEPTH;
 612           #ifndef YYSTACK_USE_ALLOCA
 613                 yyfree_stacks = 1;
 614           #endif
 615                 yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
 616 mike  1.2       __yy_memcpy ((char *)yyss, (char *)yyss1,
 617           		   size * (unsigned int) sizeof (*yyssp));
 618                 yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
 619                 __yy_memcpy ((char *)yyvs, (char *)yyvs1,
 620           		   size * (unsigned int) sizeof (*yyvsp));
 621           #ifdef YYLSP_NEEDED
 622                 yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
 623                 __yy_memcpy ((char *)yyls, (char *)yyls1,
 624           		   size * (unsigned int) sizeof (*yylsp));
 625           #endif
 626           #endif /* no yyoverflow */
 627           
 628                 yyssp = yyss + size - 1;
 629                 yyvsp = yyvs + size - 1;
 630           #ifdef YYLSP_NEEDED
 631                 yylsp = yyls + size - 1;
 632           #endif
 633           
 634           #if YYDEBUG != 0
 635                 if (yydebug)
 636           	fprintf(stderr, "Stack size increased to %d\n", yystacksize);
 637 mike  1.2 #endif
 638           
 639                 if (yyssp >= yyss + yystacksize - 1)
 640           	YYABORT;
 641               }
 642           
 643           #if YYDEBUG != 0
 644             if (yydebug)
 645               fprintf(stderr, "Entering state %d\n", yystate);
 646           #endif
 647           
 648             goto yybackup;
 649            yybackup:
 650           
 651           /* Do appropriate processing given the current state.  */
 652           /* Read a lookahead token if we need one and don't already have one.  */
 653           /* yyresume: */
 654           
 655             /* First try to decide what to do without reference to lookahead token.  */
 656           
 657             yyn = yypact[yystate];
 658 mike  1.2   if (yyn == YYFLAG)
 659               goto yydefault;
 660           
 661             /* Not known => get a lookahead token if don't already have one.  */
 662           
 663             /* yychar is either YYEMPTY or YYEOF
 664                or a valid token in external form.  */
 665           
 666             if (yychar == YYEMPTY)
 667               {
 668           #if YYDEBUG != 0
 669                 if (yydebug)
 670           	fprintf(stderr, "Reading a token: ");
 671           #endif
 672                 yychar = YYLEX;
 673               }
 674           
 675             /* Convert token to internal form (in yychar1) for indexing tables with */
 676           
 677             if (yychar <= 0)		/* This means end of input. */
 678               {
 679 mike  1.2       yychar1 = 0;
 680                 yychar = YYEOF;		/* Don't call YYLEX any more */
 681           
 682           #if YYDEBUG != 0
 683                 if (yydebug)
 684           	fprintf(stderr, "Now at end of input.\n");
 685           #endif
 686               }
 687             else
 688               {
 689                 yychar1 = YYTRANSLATE(yychar);
 690           
 691           #if YYDEBUG != 0
 692                 if (yydebug)
 693           	{
 694           	  fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
 695           	  /* Give the individual parser a way to print the precise meaning
 696           	     of a token, for further debugging info.  */
 697           #ifdef YYPRINT
 698           	  YYPRINT (stderr, yychar, yylval);
 699           #endif
 700 mike  1.2 	  fprintf (stderr, ")\n");
 701           	}
 702           #endif
 703               }
 704           
 705             yyn += yychar1;
 706             if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
 707               goto yydefault;
 708           
 709             yyn = yytable[yyn];
 710           
 711             /* yyn is what to do for this token type in this state.
 712                Negative => reduce, -yyn is rule number.
 713                Positive => shift, yyn is new state.
 714                  New state is final state => don't bother to shift,
 715                  just return success.
 716                0, or most negative number => error.  */
 717           
 718             if (yyn < 0)
 719               {
 720                 if (yyn == YYFLAG)
 721 mike  1.2 	goto yyerrlab;
 722                 yyn = -yyn;
 723                 goto yyreduce;
 724               }
 725             else if (yyn == 0)
 726               goto yyerrlab;
 727           
 728             if (yyn == YYFINAL)
 729               YYACCEPT;
 730           
 731             /* Shift the lookahead token.  */
 732           
 733           #if YYDEBUG != 0
 734             if (yydebug)
 735               fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
 736           #endif
 737           
 738             /* Discard the token being shifted unless it is eof.  */
 739             if (yychar != YYEOF)
 740               yychar = YYEMPTY;
 741           
 742 mike  1.2   *++yyvsp = yylval;
 743           #ifdef YYLSP_NEEDED
 744             *++yylsp = yylloc;
 745           #endif
 746           
 747             /* count tokens shifted since error; after three, turn off error status.  */
 748             if (yyerrstatus) yyerrstatus--;
 749           
 750             yystate = yyn;
 751             goto yynewstate;
 752           
 753           /* Do the default action for the current state.  */
 754           yydefault:
 755           
 756             yyn = yydefact[yystate];
 757             if (yyn == 0)
 758               goto yyerrlab;
 759           
 760           /* Do a reduction.  yyn is the number of a rule to reduce with.  */
 761           yyreduce:
 762             yylen = yyr2[yyn];
 763 mike  1.2   if (yylen > 0)
 764               yyval = yyvsp[1-yylen]; /* implement default value of the action */
 765           
 766           #if YYDEBUG != 0
 767             if (yydebug)
 768               {
 769                 int i;
 770           
 771                 fprintf (stderr, "Reducing via rule %d (line %d), ",
 772           	       yyn, yyrline[yyn]);
 773           
 774                 /* Print the symbols being reduced, and their result.  */
 775                 for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
 776           	fprintf (stderr, "%s ", yytname[yyrhs[i]]);
 777                 fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
 778               }
 779           #endif
 780           
 781           
 782             switch (yyn) {
 783           
 784 mike  1.2 case 1:

 785 kumpf 1.3 #line 131 "WQL.y"

 786 mike  1.2 {
 787           	WQL_TRACE(("YACC: start\n"));
 788               ;
 789               break;}
 790           case 2:

 791 kumpf 1.3 #line 137 "WQL.y"

 792 mike  1.2 {
 793           
 794               ;
 795               break;}
 796           case 3:

 797 kumpf 1.3 #line 143 "WQL.y"

 798 mike  1.2 {
 799           	globalParserState->statement->appendSelectPropertyName("*");
 800               ;
 801               break;}
 802           case 4:

 803 kumpf 1.3 #line 147 "WQL.y"

 804 mike  1.2 {
 805           
 806               ;
 807               break;}
 808           case 5:

 809 kumpf 1.3 #line 153 "WQL.y"

 810 mike  1.2 {
 811           	globalParserState->statement->appendSelectPropertyName(yyvsp[0].strValue);
 812               ;
 813               break;}
 814           case 6:

 815 kumpf 1.3 #line 157 "WQL.y"

 816 mike  1.2 {
 817           	globalParserState->statement->appendSelectPropertyName(yyvsp[0].strValue);
 818               ;
 819               break;}
 820           case 7:

 821 kumpf 1.3 #line 163 "WQL.y"

 822 mike  1.2 {
 823           
 824               ;
 825               break;}
 826           case 8:

 827 kumpf 1.3 #line 167 "WQL.y"

 828 mike  1.2 {
 829           
 830               ;
 831               break;}
 832           case 9:

 833 kumpf 1.3 #line 173 "WQL.y"

 834 mike  1.2 {
 835           	WQL_TRACE(("YACC: fromClause: TOK_FROM className(%s)\n", yyvsp[0].strValue));
 836           	globalParserState->statement->setClassName(yyvsp[0].strValue);
 837               ;
 838               break;}
 839           case 10:

 840 kumpf 1.3 #line 180 "WQL.y"

 841 mike  1.2 {
 842           
 843               ;
 844               break;}
 845           case 11:

 846 kumpf 1.3 #line 186 "WQL.y"

 847 mike  1.2 {
 848           	WQL_TRACE(("YACC: TOK_OR\n"));
 849           	globalParserState->statement->appendOperation(WQL_OR);
 850               ;
 851               break;}
 852           case 12:

 853 kumpf 1.3 #line 191 "WQL.y"

 854 mike  1.2 {
 855           	WQL_TRACE(("YACC: TOK_AND\n"));
 856           	globalParserState->statement->appendOperation(WQL_AND);
 857               ;
 858               break;}
 859           case 13:

 860 kumpf 1.3 #line 196 "WQL.y"

 861 mike  1.2 {
 862           	WQL_TRACE(("YACC: TOK_NOT\n"));
 863           
 864           	globalParserState->statement->appendOperation(WQL_NOT);
 865               ;
 866               break;}
 867           case 14:

 868 kumpf 1.3 #line 202 "WQL.y"

 869 mike  1.2 {
 870           
 871               ;
 872               break;}
 873           case 15:

 874 kumpf 1.3 #line 206 "WQL.y"

 875 mike  1.2 {
 876           
 877               ;
 878               break;}
 879           case 16:

 880 kumpf 1.3 #line 210 "WQL.y"

 881 mike  1.2 {
 882           	WQLOperation op = yyvsp[0].intValue ? WQL_IS_TRUE : WQL_IS_FALSE;
 883           	globalParserState->statement->appendOperation(op);
 884               ;
 885               break;}
 886           case 17:

 887 kumpf 1.3 #line 215 "WQL.y"

 888 mike  1.2 {
 889           	WQLOperation op = yyvsp[0].intValue ? WQL_IS_NOT_TRUE : WQL_IS_NOT_FALSE;
 890           	globalParserState->statement->appendOperation(op);
 891               ;
 892               break;}
 893           case 18:

 894 kumpf 1.3 #line 224 "WQL.y"

 895 mike  1.2 {
 896           
 897               ;
 898               break;}
 899           case 19:

 900 kumpf 1.3 #line 228 "WQL.y"

 901 mike  1.2 {
 902           
 903               ;
 904               break;}
 905           case 20:

 906 kumpf 1.3 #line 234 "WQL.y"

 907 mike  1.2 {
 908           	WQL_TRACE(("YACC: TOK_LT\n"));
 909           	globalParserState->statement->appendOperation(WQL_LT);
 910               ;
 911               break;}
 912           case 21:

 913 kumpf 1.3 #line 239 "WQL.y"

 914 mike  1.2 {
 915           	WQL_TRACE(("YACC: TOK_GT\n"));
 916           	globalParserState->statement->appendOperation(WQL_GT);
 917               ;
 918               break;}
 919           case 22:

 920 kumpf 1.3 #line 244 "WQL.y"

 921 mike  1.2 {
 922           	WQL_TRACE(("YACC: TOK_LE\n"));
 923           	globalParserState->statement->appendOperation(WQL_LE);
 924               ;
 925               break;}
 926           case 23:

 927 kumpf 1.3 #line 249 "WQL.y"

 928 mike  1.2 {
 929           	WQL_TRACE(("YACC: TOK_GE\n"));
 930           	globalParserState->statement->appendOperation(WQL_GE);
 931               ;
 932               break;}
 933           case 24:

 934 kumpf 1.3 #line 254 "WQL.y"

 935 mike  1.2 {
 936           	WQL_TRACE(("YACC: TOK_EQ\n"));
 937           	globalParserState->statement->appendOperation(WQL_EQ);
 938               ;
 939               break;}
 940           case 25:

 941 kumpf 1.3 #line 259 "WQL.y"

 942 mike  1.2 {
 943           	WQL_TRACE(("YACC: TOK_NE\n"));
 944           	globalParserState->statement->appendOperation(WQL_NE);
 945               ;
 946               break;}
 947           case 26:

 948 kumpf 1.3 #line 266 "WQL.y"

 949 mike  1.2 {
 950           	WQL_TRACE(("YACC: nullPredicate : comparisonTerm IS NULL\n"));
 951           	globalParserState->statement->appendOperation(WQL_IS_NULL);
 952               ;
 953               break;}
 954           case 27:

 955 kumpf 1.3 #line 271 "WQL.y"

 956 mike  1.2 {
 957           	WQL_TRACE(("YACC: nullPredicate : comparisonTerm IS NOT NULL\n"));
 958           	globalParserState->statement->appendOperation(WQL_IS_NOT_NULL);
 959               ;
 960               break;}
 961           case 28:

 962 kumpf 1.3 #line 278 "WQL.y"

 963 mike  1.2 {
 964           	yyval.intValue = 1;
 965               ;
 966               break;}
 967           case 29:

 968 kumpf 1.3 #line 282 "WQL.y"

 969 mike  1.2 {
 970           	yyval.intValue = 0;
 971               ;
 972               break;}
 973           case 30:

 974 kumpf 1.3 #line 288 "WQL.y"

 975 mike  1.2 {
 976           	WQL_TRACE(("YACC: propertyName : TOK_IDENTIFIER(%s)\n", yyvsp[0].strValue));
 977           	yyval.strValue = yyvsp[0].strValue;
 978               ;
 979               break;}
 980           case 31:

 981 kumpf 1.3 #line 294 "WQL.y"

 982 mike  1.2 {
 983           	WQL_TRACE(("YACC: TOK_IDENTIFIER %s\n", yyvsp[0].strValue));
 984           	yyval.strValue = yyvsp[0].strValue;
 985               ;
 986               break;}
 987           case 32:

 988 kumpf 1.3 #line 301 "WQL.y"

 989 mike  1.2 {
 990           	globalParserState->statement->appendOperand(
 991           	    WQLOperand(yyvsp[0].strValue, WQL_PROPERTY_NAME_TAG));
 992           	globalParserState->statement->appendWherePropertyName(yyvsp[0].strValue);
 993               ;
 994               break;}
 995           case 33:

 996 kumpf 1.3 #line 307 "WQL.y"

 997 mike  1.2 {
 998           	globalParserState->statement->appendOperand(
 999           	    WQLOperand(yyvsp[0].intValue, WQL_INTEGER_VALUE_TAG));
1000               ;
1001               break;}
1002           case 34:

1003 kumpf 1.3 #line 312 "WQL.y"

1004 mike  1.2 {
1005           	globalParserState->statement->appendOperand(
1006           	    WQLOperand(yyvsp[0].doubleValue, WQL_DOUBLE_VALUE_TAG));
1007               ;
1008               break;}
1009           case 35:

1010 kumpf 1.3 #line 317 "WQL.y"

1011 mike  1.2 {
1012           	globalParserState->statement->appendOperand(
1013           	    WQLOperand(yyvsp[0].strValue, WQL_STRING_VALUE_TAG));
1014               ;
1015               break;}
1016           case 36:

1017 kumpf 1.3 #line 322 "WQL.y"

1018 mike  1.2 {
1019           	globalParserState->statement->appendOperand(
1020           	    WQLOperand(yyvsp[0].intValue != 0, WQL_BOOLEAN_VALUE_TAG));
1021               ;
1022               break;}
1023           }
1024              /* the action file gets copied in in place of this dollarsign */
1025           #line 543 "bison.simple"
1026           
1027             yyvsp -= yylen;
1028             yyssp -= yylen;
1029           #ifdef YYLSP_NEEDED
1030             yylsp -= yylen;
1031           #endif
1032           
1033           #if YYDEBUG != 0
1034             if (yydebug)
1035               {
1036                 short *ssp1 = yyss - 1;
1037                 fprintf (stderr, "state stack now");
1038                 while (ssp1 != yyssp)
1039 mike  1.2 	fprintf (stderr, " %d", *++ssp1);
1040                 fprintf (stderr, "\n");
1041               }
1042           #endif
1043           
1044             *++yyvsp = yyval;
1045           
1046           #ifdef YYLSP_NEEDED
1047             yylsp++;
1048             if (yylen == 0)
1049               {
1050                 yylsp->first_line = yylloc.first_line;
1051                 yylsp->first_column = yylloc.first_column;
1052                 yylsp->last_line = (yylsp-1)->last_line;
1053                 yylsp->last_column = (yylsp-1)->last_column;
1054                 yylsp->text = 0;
1055               }
1056             else
1057               {
1058                 yylsp->last_line = (yylsp+yylen-1)->last_line;
1059                 yylsp->last_column = (yylsp+yylen-1)->last_column;
1060 mike  1.2     }
1061           #endif
1062           
1063             /* Now "shift" the result of the reduction.
1064                Determine what state that goes to,
1065                based on the state we popped back to
1066                and the rule number reduced by.  */
1067           
1068             yyn = yyr1[yyn];
1069           
1070             yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
1071             if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1072               yystate = yytable[yystate];
1073             else
1074               yystate = yydefgoto[yyn - YYNTBASE];
1075           
1076             goto yynewstate;
1077           
1078           yyerrlab:   /* here on detecting error */
1079           
1080             if (! yyerrstatus)
1081 mike  1.2     /* If not already recovering from an error, report this error.  */
1082               {
1083                 ++yynerrs;
1084           
1085           #ifdef YYERROR_VERBOSE
1086                 yyn = yypact[yystate];
1087           
1088                 if (yyn > YYFLAG && yyn < YYLAST)
1089           	{
1090           	  int size = 0;
1091           	  char *msg;
1092           	  int x, count;
1093           
1094           	  count = 0;
1095           	  /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
1096           	  for (x = (yyn < 0 ? -yyn : 0);
1097           	       x < (sizeof(yytname) / sizeof(char *)); x++)
1098           	    if (yycheck[x + yyn] == x)
1099           	      size += strlen(yytname[x]) + 15, count++;
1100           	  msg = (char *) malloc(size + 15);
1101           	  if (msg != 0)
1102 mike  1.2 	    {
1103           	      strcpy(msg, "parse error");
1104           
1105           	      if (count < 5)
1106           		{
1107           		  count = 0;
1108           		  for (x = (yyn < 0 ? -yyn : 0);
1109           		       x < (sizeof(yytname) / sizeof(char *)); x++)
1110           		    if (yycheck[x + yyn] == x)
1111           		      {
1112           			strcat(msg, count == 0 ? ", expecting `" : " or `");
1113           			strcat(msg, yytname[x]);
1114           			strcat(msg, "'");
1115           			count++;
1116           		      }
1117           		}
1118           	      yyerror(msg);
1119           	      free(msg);
1120           	    }
1121           	  else
1122           	    yyerror ("parse error; also virtual memory exceeded");
1123 mike  1.2 	}
1124                 else
1125           #endif /* YYERROR_VERBOSE */
1126           	yyerror("parse error");
1127               }
1128           
1129             goto yyerrlab1;
1130           yyerrlab1:   /* here on error raised explicitly by an action */
1131           
1132             if (yyerrstatus == 3)
1133               {
1134                 /* if just tried and failed to reuse lookahead token after an error, discard it.  */
1135           
1136                 /* return failure if at end of input */
1137                 if (yychar == YYEOF)
1138           	YYABORT;
1139           
1140           #if YYDEBUG != 0
1141                 if (yydebug)
1142           	fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
1143           #endif
1144 mike  1.2 
1145                 yychar = YYEMPTY;
1146               }
1147           
1148             /* Else will try to reuse lookahead token
1149                after shifting the error token.  */
1150           
1151             yyerrstatus = 3;		/* Each real token shifted decrements this */
1152           
1153             goto yyerrhandle;
1154           
1155           yyerrdefault:  /* current state does not do anything special for the error token. */
1156           
1157           #if 0
1158             /* This is wrong; only states that explicitly want error tokens
1159                should shift them.  */
1160             yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
1161             if (yyn) goto yydefault;
1162           #endif
1163           
1164           yyerrpop:   /* pop the current state because it cannot handle the error token */
1165 mike  1.2 
1166             if (yyssp == yyss) YYABORT;
1167             yyvsp--;
1168             yystate = *--yyssp;
1169           #ifdef YYLSP_NEEDED
1170             yylsp--;
1171           #endif
1172           
1173           #if YYDEBUG != 0
1174             if (yydebug)
1175               {
1176                 short *ssp1 = yyss - 1;
1177                 fprintf (stderr, "Error: state stack now");
1178                 while (ssp1 != yyssp)
1179           	fprintf (stderr, " %d", *++ssp1);
1180                 fprintf (stderr, "\n");
1181               }
1182           #endif
1183           
1184           yyerrhandle:
1185           
1186 mike  1.2   yyn = yypact[yystate];
1187             if (yyn == YYFLAG)
1188               goto yyerrdefault;
1189           
1190             yyn += YYTERROR;
1191             if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
1192               goto yyerrdefault;
1193           
1194             yyn = yytable[yyn];
1195             if (yyn < 0)
1196               {
1197                 if (yyn == YYFLAG)
1198           	goto yyerrpop;
1199                 yyn = -yyn;
1200                 goto yyreduce;
1201               }
1202             else if (yyn == 0)
1203               goto yyerrpop;
1204           
1205             if (yyn == YYFINAL)
1206               YYACCEPT;
1207 mike  1.2 
1208           #if YYDEBUG != 0
1209             if (yydebug)
1210               fprintf(stderr, "Shifting error token, ");
1211           #endif
1212           
1213             *++yyvsp = yylval;
1214           #ifdef YYLSP_NEEDED
1215             *++yylsp = yylloc;
1216           #endif
1217           
1218             yystate = yyn;
1219             goto yynewstate;
1220           
1221            yyacceptlab:
1222             /* YYACCEPT comes here.  */
1223             if (yyfree_stacks)
1224               {
1225                 free (yyss);
1226                 free (yyvs);
1227           #ifdef YYLSP_NEEDED
1228 mike  1.2       free (yyls);
1229           #endif
1230               }
1231             return 0;
1232           
1233            yyabortlab:
1234             /* YYABORT comes here.  */
1235             if (yyfree_stacks)
1236               {
1237                 free (yyss);
1238                 free (yyvs);
1239           #ifdef YYLSP_NEEDED
1240                 free (yyls);
1241           #endif
1242               }
1243             return 1;
1244           }

1245 kumpf 1.3 #line 327 "WQL.y"

1246 mike  1.2