(file) Return to wqlyaccinc.c CVS log (file) (dir) Up to [OMI] / omi / wql

Diff for /omi/wql/wqlyaccinc.c between version 1.2 and 1.3

version 1.2, 2015/04/20 18:10:35 version 1.3, 2015/04/20 18:20:37
Line 1 
Line 1 
 /*  
 **==============================================================================  
 **  
 ** Open Management Infrastructure (OMI)  
 **  
 ** Copyright (c) Microsoft Corporation  
 **  
 ** Licensed under the Apache License, Version 2.0 (the "License"); you may not  
 ** use this file except in compliance with the License. You may obtain a copy  
 ** of the License at  
 **  
 **     http://www.apache.org/licenses/LICENSE-2.0  
 **  
 ** THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY  
 ** KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED  
 ** WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,  
 ** MERCHANTABLITY OR NON-INFRINGEMENT.  
 **  
 ** See the Apache 2 License for the specific language governing permissions  
 ** and limitations under the License.  
 **  
 **==============================================================================  
 */  
   
 #ifndef lint #ifndef lint
 static const char yysccsid[] = "@(#)yaccpar     1.9 (Berkeley) 02/21/93"; static const char yysccsid[] = "@(#)yaccpar     1.9 (Berkeley) 02/21/93";
 #endif #endif
  
   #include <stdlib.h>
   #include <string.h>
   
 #define YYBYACC 1 #define YYBYACC 1
 #define YYMAJOR 1 #define YYMAJOR 1
 #define YYMINOR 9 #define YYMINOR 9
 #define YYPATCH 20110908  #define YYPATCH 20070509
  
 #define YYEMPTY        (-1) #define YYEMPTY        (-1)
 #define yyclearin      (yychar = YYEMPTY) #define yyclearin      (yychar = YYEMPTY)
 #define yyerrok        (yyerrflag = 0) #define yyerrok        (yyerrflag = 0)
 #define YYRECOVERING() (yyerrflag != 0)  #define YYRECOVERING (yyerrflag != 0)
  
   extern int yyparse(void);
  
 #ifndef yyparse  static int yygrowstack(void);
 #define yyparse    wqlparse #define yyparse    wqlparse
 #endif /* yyparse */  
   
 #ifndef yylex  
 #define yylex      wqllex #define yylex      wqllex
 #endif /* yylex */  
   
 #ifndef yyerror  
 #define yyerror    wqlerror #define yyerror    wqlerror
 #endif /* yyerror */  
   
 #ifndef yychar  
 #define yychar     wqlchar #define yychar     wqlchar
 #endif /* yychar */  
   
 #ifndef yyval  
 #define yyval      wqlval #define yyval      wqlval
 #endif /* yyval */  
   
 #ifndef yylval  
 #define yylval     wqllval #define yylval     wqllval
 #endif /* yylval */  
   
 #ifndef yydebug  
 #define yydebug    wqldebug #define yydebug    wqldebug
 #endif /* yydebug */  
   
 #ifndef yynerrs  
 #define yynerrs    wqlnerrs #define yynerrs    wqlnerrs
 #endif /* yynerrs */  
   
 #ifndef yyerrflag  
 #define yyerrflag  wqlerrflag #define yyerrflag  wqlerrflag
 #endif /* yyerrflag */  #define yyss wqlss
   #define yyssp wqlssp
 #ifndef yylhs  #define yyvs wqlvs
   #define yyvsp wqlvsp
 #define yylhs      wqllhs #define yylhs      wqllhs
 #endif /* yylhs */  
   
 #ifndef yylen  
 #define yylen      wqllen #define yylen      wqllen
 #endif /* yylen */  
   
 #ifndef yydefred  
 #define yydefred   wqldefred #define yydefred   wqldefred
 #endif /* yydefred */  
   
 #ifndef yydgoto  
 #define yydgoto    wqldgoto #define yydgoto    wqldgoto
 #endif /* yydgoto */  
   
 #ifndef yysindex  
 #define yysindex   wqlsindex #define yysindex   wqlsindex
 #endif /* yysindex */  
   
 #ifndef yyrindex  
 #define yyrindex   wqlrindex #define yyrindex   wqlrindex
 #endif /* yyrindex */  
   
 #ifndef yygindex  
 #define yygindex   wqlgindex #define yygindex   wqlgindex
 #endif /* yygindex */  
   
 #ifndef yytable  
 #define yytable    wqltable #define yytable    wqltable
 #endif /* yytable */  
   
 #ifndef yycheck  
 #define yycheck    wqlcheck #define yycheck    wqlcheck
 #endif /* yycheck */  
   
 #ifndef yyname  
 #define yyname     wqlname #define yyname     wqlname
 #endif /* yyname */  
   
 #ifndef yyrule  
 #define yyrule     wqlrule #define yyrule     wqlrule
 #endif /* yyrule */  
 #define YYPREFIX "wql" #define YYPREFIX "wql"
   #line 1 "wql.y"
  
 #define YYPURE 0  
   
 #line 2 "wql.y"  
  
 #include <stdio.h> #include <stdio.h>
 #include "state.h" #include "state.h"
Line 143 
Line 67 
 extern MI_Char* wqlstrdup(const MI_Char* str); extern MI_Char* wqlstrdup(const MI_Char* str);
  
 #line 25 "wql.y" #line 25 "wql.y"
 #ifdef YYSTYPE  
 #undef  YYSTYPE_IS_DECLARED  
 #define YYSTYPE_IS_DECLARED 1  
 #endif  
 #ifndef YYSTYPE_IS_DECLARED  
 #define YYSTYPE_IS_DECLARED 1  
 typedef union typedef union
 { {
     WQL_Symbol symbol;     WQL_Symbol symbol;
Line 157 
Line 75 
     double real;     double real;
     unsigned char boolean;     unsigned char boolean;
 } YYSTYPE; } YYSTYPE;
 #endif /* !YYSTYPE_IS_DECLARED */  #line 79 "y.tab.c"
 #line 137 "y.tab.c"  #define WQL_DOT 257
   #define WQL_COLON 258
 /* compatibility with bison */  #define WQL_OR 259
 #ifdef YYPARSE_PARAM  #define WQL_AND 260
 /* compatibility with FreeBSD */  #define WQL_NOT 261
 # ifdef YYPARSE_PARAM_TYPE  #define WQL_ERROR 262
 #  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)  #define WQL_LT 263
 # else  #define WQL_FROM 264
 #  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)  #define WQL_LE 265
 # endif  #define WQL_WHERE 266
 #else  #define WQL_NE 267
 # define YYPARSE_DECL() yyparse(void)  #define WQL_GT 268
 #endif  #define WQL_EQ 269
   #define WQL_SELECT 270
 /* Parameters sent to lex. */  #define WQL_GE 271
 #ifdef YYLEX_PARAM  #define WQL_NULL 272
 # define YYLEX_DECL() yylex(void *YYLEX_PARAM)  #define WQL_LIKE 273
 # define YYLEX yylex(YYLEX_PARAM)  #define WQL_ISA 274
 #else  #define WQL_IDENTIFIER 275
 # define YYLEX_DECL() yylex(void)  #define WQL_BOOLEAN 276
 # define YYLEX yylex()  #define WQL_INTEGER 277
 #endif  #define WQL_REAL 278
   #define WQL_STRING 279
 /* Parameters sent to yyerror. */  
 #define YYERROR_DECL() yyerror(const char *s)  
 #define YYERROR_CALL(msg) yyerror(msg)  
   
 extern int YYPARSE_DECL();  
   
 #define WQL_OR 257  
 #define WQL_AND 258  
 #define WQL_NOT 259  
 #define WQL_ERROR 260  
 #define WQL_LT 261  
 #define WQL_FROM 262  
 #define WQL_LE 263  
 #define WQL_WHERE 264  
 #define WQL_NE 265  
 #define WQL_GT 266  
 #define WQL_REAL 267  
 #define WQL_EQ 268  
 #define WQL_SELECT 269  
 #define WQL_GE 270  
 #define WQL_NULL 271  
 #define WQL_IDENTIFIER 272  
 #define WQL_BOOLEAN 273  
 #define WQL_INTEGER 274  
 #define WQL_STRING 275  
 #define YYERRCODE 256 #define YYERRCODE 256
 static const short wqllhs[] = {                          -1,  short wqllhs[] = {                                        -1,
     0,    0,    2,    2,    4,    4,    3,    3,    3,    3,      0,    0,    3,    3,    5,    5,    4,    4,    4,    4,
     3,    5,    5,    5,    5,    5,    5,    1,    1,    1,      4,    6,    6,    6,    6,    6,    6,    6,    6,    1,
     1,    1,    1,      1,    1,    1,    1,    1,    2,    2,    2,
 }; };
 static const short wqllen[] = {                           2,  short wqllen[] = {                                         2,
     4,    6,    1,    1,    1,    3,    3,    2,    3,    3,     4,    6,    1,    1,    1,    3,    3,    2,    3,    3,
     1,    3,    3,    3,    3,    3,    3,    1,    1,    1,      1,    3,    3,    3,    3,    3,    3,    3,    3,    1,
     1,    1,    1,      1,    1,    1,    1,    1,    1,    3,    6,
 }; };
 static const short wqldefred[] = {                        0,  short wqldefred[] = {                                      0,
     0,    0,    5,    3,    0,    0,    0,    0,    0,    6,     0,    0,    5,    3,    0,    0,    0,    0,    0,    6,
     0,    0,   20,   23,   22,   18,   19,   21,    0,    0,      0,    0,   24,    0,   20,   21,   22,   23,    0,    0,
     0,   11,    8,    0,    0,    0,    0,    0,    0,    0,     25,    0,   11,    8,    0,    0,    0,    0,    0,    0,
     0,    0,    7,   14,   15,   13,   16,   12,   17,    0,      0,    0,    0,    0,    0,    0,    0,   19,    7,    0,
     9,     14,   15,   13,   16,   12,   17,   18,    0,    9,    0,
       0,   28,
 }; };
 static const short wqldgoto[] = {                         2,  short wqldgoto[] = {                                       2,
    20,    5,   21,    6,   22,     20,   21,    5,   22,    6,   23,
 }; };
 static const short wqlsindex[] = {                     -249,  short wqlsindex[] = {                                   -259,
   -36,    0,    0,    0, -233,  -14, -241, -240, -231,    0,    -35,    0,    0,    0, -249,  -27, -254, -251, -243,    0,
   -40,  -40,    0,    0,    0,    0,    0,    0,  -40, -258,    -40,  -40,    0, -252,    0,    0,    0,    0,  -40, -255,
  -244,    0,    0,  -37, -256, -256, -256, -256, -256, -256,      0, -240,    0,    0, -247, -245,  -37, -227, -227, -227,
   -40,  -40,    0,    0,    0,    0,    0,    0,    0, -224,   -227, -227, -227, -227,  -40,  -40, -224,    0,    0, -221,
     0,      0,    0,    0,    0,    0,    0,    0, -222,    0, -219,
    -235,    0,
 }; };
 static const short wqlrindex[] = {                        0,  short wqlrindex[] = {                                      0,
     0,    0,    0,    0,    0, -227,    0,    0,   36,    0,      0,    0,    0,    0,    0, -223,    0,    0,   43,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,      0,    0,    0, -236,    0,    0,    0,    0,    0,    0,
    37,    0,    0,    0,    0,    0,    0,    0,    0,    0,      0,   46,    0,    0,    0,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    1,      0,    0,    0,    0,    0,    0,    1,    0,    0,    3,
     0,      0,    0,    0,    0,    0,    0,    0,    6,    0,    0,
       0,    0,
 }; };
 static const short wqlgindex[] = {                        0,  short wqlgindex[] = {                                      0,
    -2,    0,  -10,    0,    0,     25,    0,    0,  -10,    0,    0,
 }; };
 #define YYTABLESIZE 258  #define YYTABLESIZE 274
 static const short wqltable[] = {                        19,  short wqltable[] = {                                      19,
    10,   23,   25,   33,   26,    4,   27,   28,   24,   29,     27,   24,   26,   39,   25,   10,    4,   28,   27,   29,
    13,   30,   31,   32,   14,   15,   16,   17,   18,    1,      1,   30,   31,   32,    7,   33,    8,   34,   35,   36,
    40,   41,   34,   35,   36,   37,   38,   39,    7,    8,      9,   26,   11,   10,   48,   49,   26,   37,   26,   38,
     9,   10,   11,   32,    4,    1,    2,    0,    0,    0,     26,   26,   26,   50,   26,   25,   26,   36,   51,   52,
     0,   10,    0,    0,    0,    0,    0,    0,    0,    0,      4,   27,    1,   26,   13,    2,   10,   40,   15,   16,
      17,   18,   41,   42,   43,   44,   45,   46,   47,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
Line 267 
Line 164 
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,    0,   12,   31,     12,   35,   36,    0,    0,    0,    0,    0,    0,    0,
    32,    0,    0,    0,    0,    0,   13,    0,    0,    0,      0,   13,    0,    0,   14,   15,   16,   17,   18,    3,
    14,   15,   16,   17,   18,    3,    0,    0,    0,    0,  
     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,     0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
     0,    0,    0,    0,    0,    0,    0,   10,      0,    0,    0,    0,    0,    0,    0,    0,    0,   27,
      27,   26,   26,   27,   10,   27,    0,   27,   27,   27,
       0,   27,    0,   27,
 }; };
 static const short wqlcheck[] = {                        40,  short wqlcheck[] = {                                      40,
     0,   12,  261,   41,  263,   42,  265,  266,   19,  268,      0,   12,    0,   41,  257,    0,   42,  263,   19,  265,
   267,  270,  257,  258,  271,  272,  273,  274,  275,  269,    270,  267,  268,  269,  264,  271,   44,  273,  259,  260,
    31,   32,   25,   26,   27,   28,   29,   30,  262,   44,    275,  274,  266,  275,   35,   36,  263,  275,  265,  275,
   272,  272,  264,  258,  262,    0,    0,   -1,   -1,   -1,    267,  268,  269,  258,  271,  257,  273,  260,  258,  275,
    -1,   41,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,    264,   41,    0,   41,  272,    0,   41,  275,  276,  277,
     278,  279,   28,   29,   30,   31,   32,   33,   34,   -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,
Line 295 
Line 194 
    -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,  259,  257,    261,  259,  260,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
   258,   -1,   -1,   -1,   -1,   -1,  267,   -1,   -1,   -1,     -1,  272,   -1,   -1,  275,  276,  277,  278,  279,  275,
   271,  272,  273,  274,  275,  272,   -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,     -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,  259,
     260,  259,  260,  263,  259,  265,   -1,  267,  268,  269,
      -1,  271,   -1,  273,
 }; };
 #define YYFINAL 2 #define YYFINAL 2
 #ifndef YYDEBUG #ifndef YYDEBUG
 #define YYDEBUG 0 #define YYDEBUG 0
 #endif #endif
 #define YYMAXTOKEN 275  #define YYMAXTOKEN 279
 #if YYDEBUG #if YYDEBUG
 static const char *yyname[] = {  char *wqlname[] = {
   
 "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, "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,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 0,0,0,0,0,0,0,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",  0,0,0,0,0,0,0,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_DOT",
 "WQL_AND","WQL_NOT","WQL_ERROR","WQL_LT","WQL_FROM","WQL_LE","WQL_WHERE",  "WQL_COLON","WQL_OR","WQL_AND","WQL_NOT","WQL_ERROR","WQL_LT","WQL_FROM",
 "WQL_NE","WQL_GT","WQL_REAL","WQL_EQ","WQL_SELECT","WQL_GE","WQL_NULL",  "WQL_LE","WQL_WHERE","WQL_NE","WQL_GT","WQL_EQ","WQL_SELECT","WQL_GE",
 "WQL_IDENTIFIER","WQL_BOOLEAN","WQL_INTEGER","WQL_STRING",  "WQL_NULL","WQL_LIKE","WQL_ISA","WQL_IDENTIFIER","WQL_BOOLEAN","WQL_INTEGER",
   "WQL_REAL","WQL_STRING",
 }; };
 static const char *yyrule[] = {  char *wqlrule[] = {
 "$accept : Start", "$accept : Start",
 "Start : WQL_SELECT SelectList WQL_FROM WQL_IDENTIFIER", "Start : WQL_SELECT SelectList WQL_FROM WQL_IDENTIFIER",
 "Start : WQL_SELECT SelectList WQL_FROM WQL_IDENTIFIER WQL_WHERE Condition", "Start : WQL_SELECT SelectList WQL_FROM WQL_IDENTIFIER WQL_WHERE Condition",
Line 339 
Line 239 
 "Predicate : Operand WQL_LE Operand", "Predicate : Operand WQL_LE Operand",
 "Predicate : Operand WQL_GT Operand", "Predicate : Operand WQL_GT Operand",
 "Predicate : Operand WQL_GE Operand", "Predicate : Operand WQL_GE Operand",
   "Predicate : Operand WQL_LIKE Operand",
   "Predicate : WQL_IDENTIFIER WQL_ISA WQL_IDENTIFIER",
 "Operand : WQL_BOOLEAN", "Operand : WQL_BOOLEAN",
 "Operand : WQL_INTEGER", "Operand : WQL_INTEGER",
 "Operand : WQL_REAL", "Operand : WQL_REAL",
 "Operand : WQL_STRING", "Operand : WQL_STRING",
 "Operand : WQL_IDENTIFIER",  
 "Operand : WQL_NULL", "Operand : WQL_NULL",
   "Operand : Property",
   "Property : WQL_IDENTIFIER",
   "Property : WQL_IDENTIFIER WQL_DOT WQL_IDENTIFIER",
   "Property : WQL_IDENTIFIER WQL_DOT WQL_IDENTIFIER WQL_COLON WQL_COLON WQL_IDENTIFIER",
 }; };
 #endif #endif
   #if YYDEBUG
 int      yydebug;  #include <stdio.h>
 int      yynerrs;  #endif
   
 int      yyerrflag;  
 int      yychar;  
 YYSTYPE  yyval;  
 YYSTYPE  yylval;  
  
 /* define the initial stack-sizes */ /* define the initial stack-sizes */
 #ifdef YYSTACKSIZE #ifdef YYSTACKSIZE
Line 365 
Line 264 
 #ifdef YYMAXDEPTH #ifdef YYMAXDEPTH
 #define YYSTACKSIZE YYMAXDEPTH #define YYSTACKSIZE YYMAXDEPTH
 #else #else
 #define YYSTACKSIZE 500  #define YYSTACKSIZE 10000
 #define YYMAXDEPTH  500  #define YYMAXDEPTH  10000
 #endif #endif
 #endif #endif
  
 #define YYINITSTACKSIZE 500 #define YYINITSTACKSIZE 500
  
 typedef struct {  int      yydebug;
     unsigned stacksize;  int      yynerrs;
     short    *s_base;  int      yyerrflag;
     short    *s_mark;  int      yychar;
     short    *s_last;  short   *yyssp;
     YYSTYPE  *l_base;  YYSTYPE *yyvsp;
     YYSTYPE  *l_mark;  YYSTYPE  yyval;
 } YYSTACKDATA;  YYSTYPE  yylval;
 /* variables for the parser stack */  
 static YYSTACKDATA yystack;  
   
 #if YYDEBUG  
 #include <stdio.h>              /* needed for printf */  
 #endif  
   
 #include <stdlib.h>     /* needed for malloc, etc */  
 #include <string.h>     /* needed for memset */  
  
   /* variables for the parser stack */
   static short   *yyss;
   static short   *yysslim;
   static YYSTYPE *yyvs;
   static int      yystacksize;
 /* allocate initial stack or double stack size, up to YYMAXDEPTH */ /* allocate initial stack or double stack size, up to YYMAXDEPTH */
 static int yygrowstack(YYSTACKDATA *data)  static int yygrowstack(void)
 { {
     int i;      int newsize, i;
     unsigned newsize;  
     short *newss;     short *newss;
     YYSTYPE *newvs;     YYSTYPE *newvs;
  
     if ((newsize = data->stacksize) == 0)      if ((newsize = yystacksize) == 0)
         newsize = YYINITSTACKSIZE;         newsize = YYINITSTACKSIZE;
     else if (newsize >= YYMAXDEPTH)     else if (newsize >= YYMAXDEPTH)
         return -1;         return -1;
     else if ((newsize *= 2) > YYMAXDEPTH)     else if ((newsize *= 2) > YYMAXDEPTH)
         newsize = YYMAXDEPTH;         newsize = YYMAXDEPTH;
  
     i = data->s_mark - data->s_base;      i = yyssp - yyss;
     newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));      newss = (yyss != 0)
             ? (short *)PAL_Realloc(yyss, newsize * sizeof(*newss))
             : (short *)PAL_Malloc(newsize * sizeof(*newss));
     if (newss == 0)     if (newss == 0)
         return -1;         return -1;
  
     data->s_base = newss;      yyss  = newss;
     data->s_mark = newss + i;      yyssp = newss + i;
       newvs = (yyvs != 0)
     newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));            ? (YYSTYPE *)PAL_Realloc(yyvs, newsize * sizeof(*newvs))
             : (YYSTYPE *)PAL_Malloc(newsize * sizeof(*newvs));
     if (newvs == 0)     if (newvs == 0)
         return -1;         return -1;
  
     data->l_base = newvs;      yyvs = newvs;
     data->l_mark = newvs + i;      yyvsp = newvs + i;
       yystacksize = newsize;
     data->stacksize = newsize;      yysslim = yyss + newsize - 1;
     data->s_last = data->s_base + newsize - 1;  
     return 0;     return 0;
 } }
  
 #if YYPURE || defined(YY_NO_LEAKS)  
 static void yyfreestack(YYSTACKDATA *data)  
 {  
     free(data->s_base);  
     free(data->l_base);  
     memset(data, 0, sizeof(*data));  
 }  
 #else  
 #define yyfreestack(data) /* nothing */  
 #endif  
   
 #define YYABORT  goto yyabort #define YYABORT  goto yyabort
 #define YYREJECT goto yyabort #define YYREJECT goto yyabort
 #define YYACCEPT goto yyaccept #define YYACCEPT goto yyaccept
 #define YYERROR  goto yyerrlab #define YYERROR  goto yyerrlab
   
 int int
 YYPARSE_DECL()  yyparse(void)
 { {
     int yym, yyn, yystate;      register int yym, yyn, yystate;
 #if YYDEBUG #if YYDEBUG
     const char *yys;      register const char *yys;
  
     if ((yys = getenv("YYDEBUG")) != 0)     if ((yys = getenv("YYDEBUG")) != 0)
     {     {
Line 459 
Line 343 
     yynerrs = 0;     yynerrs = 0;
     yyerrflag = 0;     yyerrflag = 0;
     yychar = YYEMPTY;     yychar = YYEMPTY;
     yystate = 0;  
   
 #if YYPURE  
     memset(&yystack, 0, sizeof(yystack));  
 #endif  
  
     if (yystack.s_base == NULL && yygrowstack(&yystack)) goto yyoverflow;      if (yyss == NULL && yygrowstack()) goto yyoverflow;
     yystack.s_mark = yystack.s_base;      yyssp = yyss;
     yystack.l_mark = yystack.l_base;      yyvsp = yyvs;
     yystate = 0;      *yyssp = yystate = 0;
     *yystack.s_mark = 0;  
  
 yyloop: yyloop:
     if ((yyn = yydefred[yystate]) != 0) goto yyreduce;     if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
     if (yychar < 0)     if (yychar < 0)
     {     {
         if ((yychar = YYLEX) < 0) yychar = 0;          if ((yychar = yylex()) < 0) yychar = 0;
 #if YYDEBUG #if YYDEBUG
         if (yydebug)         if (yydebug)
         {         {
Line 495 
Line 373 
             printf("%sdebug: state %d, shifting to state %d\n",             printf("%sdebug: state %d, shifting to state %d\n",
                     YYPREFIX, yystate, yytable[yyn]);                     YYPREFIX, yystate, yytable[yyn]);
 #endif #endif
         if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))          if (yyssp >= yysslim && yygrowstack())
         {         {
             goto yyoverflow;             goto yyoverflow;
         }         }
         yystate = yytable[yyn];          *++yyssp = yystate = yytable[yyn];
         *++yystack.s_mark = yytable[yyn];          *++yyvsp = yylval;
         *++yystack.l_mark = yylval;  
         yychar = YYEMPTY;         yychar = YYEMPTY;
         if (yyerrflag > 0)  --yyerrflag;         if (yyerrflag > 0)  --yyerrflag;
         goto yyloop;         goto yyloop;
Line 516 
Line 393 
  
     yyerror("syntax error");     yyerror("syntax error");
  
   #ifdef lint
     goto yyerrlab;     goto yyerrlab;
   #endif
  
 yyerrlab: yyerrlab:
     ++yynerrs;     ++yynerrs;
Line 527 
Line 406 
         yyerrflag = 3;         yyerrflag = 3;
         for (;;)         for (;;)
         {         {
             if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&              if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)                     yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
             {             {
 #if YYDEBUG #if YYDEBUG
                 if (yydebug)                 if (yydebug)
                     printf("%sdebug: state %d, error recovery shifting\                     printf("%sdebug: state %d, error recovery shifting\
  to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);   to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
 #endif #endif
                 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))                  if (yyssp >= yysslim && yygrowstack())
                 {                 {
                     goto yyoverflow;                     goto yyoverflow;
                 }                 }
                 yystate = yytable[yyn];                  *++yyssp = yystate = yytable[yyn];
                 *++yystack.s_mark = yytable[yyn];                  *++yyvsp = yylval;
                 *++yystack.l_mark = yylval;  
                 goto yyloop;                 goto yyloop;
             }             }
             else             else
Line 549 
Line 427 
 #if YYDEBUG #if YYDEBUG
                 if (yydebug)                 if (yydebug)
                     printf("%sdebug: error recovery discarding state %d\n",                     printf("%sdebug: error recovery discarding state %d\n",
                             YYPREFIX, *yystack.s_mark);                              YYPREFIX, *yyssp);
 #endif #endif
                 if (yystack.s_mark <= yystack.s_base) goto yyabort;                  if (yyssp <= yyss) goto yyabort;
                 --yystack.s_mark;                  --yyssp;
                 --yystack.l_mark;                  --yyvsp;
             }             }
         }         }
     }     }
Line 582 
Line 460 
 #endif #endif
     yym = yylen[yyn];     yym = yylen[yyn];
     if (yym)     if (yym)
         yyval = yystack.l_mark[1-yym];          yyval = yyvsp[1-yym];
     else     else
         memset(&yyval, 0, sizeof yyval);         memset(&yyval, 0, sizeof yyval);
     switch (yyn)     switch (yyn)
     {     {
 case 1: case 1:
 #line 64 "wql.y"  #line 70 "wql.y"
         {         {
         YACCTRACE(Start1);         YACCTRACE(Start1);
         wqlstate.wql->className = yystack.l_mark[0].string;          wqlstate.wql->className = yyvsp[0].string;
     }     }
 break; break;
 case 2: case 2:
 #line 69 "wql.y"  #line 75 "wql.y"
         {         {
         YACCTRACE(Start2);         YACCTRACE(Start2);
         wqlstate.wql->className = yystack.l_mark[-2].string;          wqlstate.wql->className = yyvsp[-2].string;
     }     }
 break; break;
 case 3: case 3:
 #line 76 "wql.y"  #line 82 "wql.y"
         {         {
         YACCTRACE(SelectList1);         YACCTRACE(SelectList1);
     }     }
 break; break;
 case 4: case 4:
 #line 80 "wql.y"  #line 86 "wql.y"
         {         {
         YACCTRACE(SelectList12);          YACCTRACE(SelectList2);
     }     }
 break; break;
 case 5: case 5:
 #line 86 "wql.y"  #line 92 "wql.y"
         {         {
         YACCTRACE(PropertyList1);         YACCTRACE(PropertyList1);
  
Line 624 
Line 502 
             YYABORT;             YYABORT;
         }         }
  
         wqlstate.wql->properties[wqlstate.wql->nproperties++] = yystack.l_mark[0].string;          wqlstate.wql->properties[wqlstate.wql->nproperties++] = yyvsp[0].string;
     }     }
 break; break;
 case 6: case 6:
 #line 98 "wql.y"  #line 104 "wql.y"
         {         {
         YACCTRACE(PropertyList2);         YACCTRACE(PropertyList2);
  
Line 638 
Line 516 
             YYABORT;             YYABORT;
         }         }
  
         wqlstate.wql->properties[wqlstate.wql->nproperties++] = yystack.l_mark[0].string;          wqlstate.wql->properties[wqlstate.wql->nproperties++] = yyvsp[0].string;
     }     }
 break; break;
 case 7: case 7:
 #line 112 "wql.y"  #line 118 "wql.y"
         {         {
         YACCTRACE(Condition1);         YACCTRACE(Condition1);
     }     }
 break; break;
 case 8: case 8:
 #line 116 "wql.y"  #line 122 "wql.y"
         {         {
         WQL_Symbol operator;         WQL_Symbol operator;
  
Line 666 
Line 544 
     }     }
 break; break;
 case 9: case 9:
 #line 132 "wql.y"  #line 138 "wql.y"
         {         {
         WQL_Symbol operator;         WQL_Symbol operator;
  
Line 684 
Line 562 
     }     }
 break; break;
 case 10: case 10:
 #line 148 "wql.y"  #line 154 "wql.y"
         {         {
         WQL_Symbol operator;         WQL_Symbol operator;
  
Line 702 
Line 580 
     }     }
 break; break;
 case 11: case 11:
 #line 164 "wql.y"  #line 170 "wql.y"
         {         {
         YACCTRACE(Condition5);         YACCTRACE(Condition5);
     }     }
 break; break;
 case 12: case 12:
 #line 170 "wql.y"  #line 176 "wql.y"
         {         {
         WQL_Symbol operator;         WQL_Symbol operator;
  
Line 723 
Line 601 
         memset(&operator, 0, sizeof(WQL_Symbol));         memset(&operator, 0, sizeof(WQL_Symbol));
         operator.type = WQL_TYPE_EQ;         operator.type = WQL_TYPE_EQ;
  
         wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[-2].symbol;          wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yyvsp[-2].symbol;
         wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[0].symbol;          wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yyvsp[0].symbol;
         wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;         wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;
     }     }
 break; break;
 case 13: case 13:
 #line 189 "wql.y"  #line 195 "wql.y"
         {         {
         WQL_Symbol operator;         WQL_Symbol operator;
  
Line 744 
Line 622 
         memset(&operator, 0, sizeof(WQL_Symbol));         memset(&operator, 0, sizeof(WQL_Symbol));
         operator.type = WQL_TYPE_NE;         operator.type = WQL_TYPE_NE;
  
         wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[-2].symbol;          wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yyvsp[-2].symbol;
         wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[0].symbol;          wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yyvsp[0].symbol;
         wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;         wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;
     }     }
 break; break;
 case 14: case 14:
 #line 208 "wql.y"  #line 214 "wql.y"
         {         {
         WQL_Symbol operator;         WQL_Symbol operator;
  
Line 765 
Line 643 
         memset(&operator, 0, sizeof(WQL_Symbol));         memset(&operator, 0, sizeof(WQL_Symbol));
         operator.type = WQL_TYPE_LT;         operator.type = WQL_TYPE_LT;
  
         wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[-2].symbol;          wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yyvsp[-2].symbol;
         wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[0].symbol;          wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yyvsp[0].symbol;
         wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;         wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;
     }     }
 break; break;
 case 15: case 15:
 #line 227 "wql.y"  #line 233 "wql.y"
         {         {
         WQL_Symbol operator;         WQL_Symbol operator;
  
Line 786 
Line 664 
         memset(&operator, 0, sizeof(WQL_Symbol));         memset(&operator, 0, sizeof(WQL_Symbol));
         operator.type = WQL_TYPE_LE;         operator.type = WQL_TYPE_LE;
  
         wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[-2].symbol;          wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yyvsp[-2].symbol;
         wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[0].symbol;          wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yyvsp[0].symbol;
         wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;         wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;
     }     }
 break; break;
 case 16: case 16:
 #line 246 "wql.y"  #line 252 "wql.y"
         {         {
         WQL_Symbol operator;         WQL_Symbol operator;
  
Line 807 
Line 685 
         memset(&operator, 0, sizeof(WQL_Symbol));         memset(&operator, 0, sizeof(WQL_Symbol));
         operator.type = WQL_TYPE_GT;         operator.type = WQL_TYPE_GT;
  
         wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[-2].symbol;          wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yyvsp[-2].symbol;
         wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[0].symbol;          wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yyvsp[0].symbol;
         wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;         wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;
     }     }
 break; break;
 case 17: case 17:
 #line 265 "wql.y"  #line 271 "wql.y"
         {         {
         WQL_Symbol operator;         WQL_Symbol operator;
  
Line 828 
Line 706 
         memset(&operator, 0, sizeof(WQL_Symbol));         memset(&operator, 0, sizeof(WQL_Symbol));
         operator.type = WQL_TYPE_GE;         operator.type = WQL_TYPE_GE;
  
         wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[-2].symbol;          wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yyvsp[-2].symbol;
         wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yystack.l_mark[0].symbol;          wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yyvsp[0].symbol;
         wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;         wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;
     }     }
 break; break;
 case 18: case 18:
 #line 286 "wql.y"  #line 290 "wql.y"
   {
           WQL_Symbol operator;
   
           YACCTRACE(Predicate6);
   
           /* Only WQL LIKE is supported */
           if (wqlstate.wql->dialect != WQL_DIALECT_WQL)
           {
               yyerror("CQL LIKE not supported");
               YYABORT;
           }
   
           if (wqlstate.wql->nsymbols + 3 > WQL_MAX_SYMBOLS)
           {
               yyerror("symbol array overflow");
               YYABORT;
           }
   
           memset(&operator, 0, sizeof(WQL_Symbol));
           operator.type = WQL_TYPE_LIKE;
   
           wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yyvsp[-2].symbol;
           wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = yyvsp[0].symbol;
           wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;
       }
   break;
   case 19:
   #line 316 "wql.y"
   {
           WQL_Symbol lhs;
           WQL_Symbol rhs;
           WQL_Symbol operator;
   
           YACCTRACE(Predicate7);
   
           /* Check for symbol stack overflow */
           if (wqlstate.wql->nsymbols + 3 > WQL_MAX_SYMBOLS)
           {
               yyerror("symbol array overflow");
               YYABORT;
           }
   
           /* Left-hand-side (embedded property name) */
           memset(&lhs, 0, sizeof(WQL_Symbol));
           lhs.value.string = yyvsp[-2].string;
           lhs.type = WQL_TYPE_STRING;
   
           /* Right-hand-side (embedded class name) */
           memset(&rhs, 0, sizeof(WQL_Symbol));
           rhs.value.string = yyvsp[0].string;
           rhs.type = WQL_TYPE_STRING;
   
           /* Operator */
           memset(&operator, 0, sizeof(WQL_Symbol));
           operator.type = WQL_TYPE_ISA;
   
           wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = lhs;
           wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = rhs;
           wqlstate.wql->symbols[wqlstate.wql->nsymbols++] = operator;
       }
   break;
   case 20:
   #line 351 "wql.y"
         {         {
         YACCTRACE(Operand1);         YACCTRACE(Operand1);
         yyval.symbol.value.boolean = yystack.l_mark[0].boolean;          yyval.symbol.value.boolean = yyvsp[0].boolean;
         yyval.symbol.type = WQL_TYPE_BOOLEAN;         yyval.symbol.type = WQL_TYPE_BOOLEAN;
     }     }
 break; break;
 case 19:  case 21:
 #line 292 "wql.y"  #line 357 "wql.y"
         {         {
         YACCTRACE(Operand2);         YACCTRACE(Operand2);
         yyval.symbol.value.integer = yystack.l_mark[0].integer;          yyval.symbol.value.integer = yyvsp[0].integer;
         yyval.symbol.type = WQL_TYPE_INTEGER;         yyval.symbol.type = WQL_TYPE_INTEGER;
     }     }
 break; break;
 case 20:  case 22:
 #line 298 "wql.y"  #line 363 "wql.y"
         {         {
         YACCTRACE(Operand3);         YACCTRACE(Operand3);
         yyval.symbol.value.real = yystack.l_mark[0].real;          yyval.symbol.value.real = yyvsp[0].real;
         yyval.symbol.type = WQL_TYPE_REAL;         yyval.symbol.type = WQL_TYPE_REAL;
     }     }
 break; break;
 case 21:  case 23:
 #line 304 "wql.y"  #line 369 "wql.y"
         {         {
         YACCTRACE(Operand4);         YACCTRACE(Operand4);
         yyval.symbol.value.string = yystack.l_mark[0].string;          yyval.symbol.value.string = yyvsp[0].string;
         yyval.symbol.type = WQL_TYPE_STRING;         yyval.symbol.type = WQL_TYPE_STRING;
     }     }
 break; break;
 case 22:  case 24:
 #line 310 "wql.y"  #line 375 "wql.y"
         {         {
         YACCTRACE(Operand5);          YACCTRACE(Operand6);
         yyval.symbol.value.string = yystack.l_mark[0].string;          yyval.symbol.value.integer = 0;
           yyval.symbol.type = WQL_TYPE_NULL;
       }
   break;
   case 25:
   #line 381 "wql.y"
   {
           YACCTRACE(Operand7);
           yyval.symbol = yyvsp[0].symbol;
       }
   break;
   case 26:
   #line 388 "wql.y"
   {
           YACCTRACE(Property1);
           yyval.symbol.value.string = yyvsp[0].string;
           yyval.symbol.value.embeddedClassName = NULL;
           yyval.symbol.value.embeddedPropertyName = NULL;
         yyval.symbol.type = WQL_TYPE_IDENTIFIER;         yyval.symbol.type = WQL_TYPE_IDENTIFIER;
     }     }
 break; break;
 case 23:  case 27:
 #line 316 "wql.y"  #line 396 "wql.y"
         {         {
         YACCTRACE(Operand6);          MI_Char* str;
         yyval.symbol.value.integer = 0;          YACCTRACE(Property2);
         yyval.symbol.type = WQL_TYPE_NULL;  
           yyval.symbol.value.string = yyvsp[-2].string;
           yyval.symbol.value.embeddedClassName = NULL;
           yyval.symbol.value.embeddedPropertyName = yyvsp[0].string;
           yyval.symbol.type = WQL_TYPE_IDENTIFIER;
       }
   break;
   case 28:
   #line 406 "wql.y"
   {
           MI_Char* str;
           YACCTRACE(Property2);
   
           yyval.symbol.value.string = yyvsp[-5].string;
           yyval.symbol.value.embeddedClassName = yyvsp[-3].string;
           yyval.symbol.value.embeddedPropertyName = yyvsp[0].string;
           yyval.symbol.type = WQL_TYPE_IDENTIFIER;
     }     }
 break; break;
 #line 860 "y.tab.c"  #line 859 "y.tab.c"
     }     }
     yystack.s_mark -= yym;      yyssp -= yym;
     yystate = *yystack.s_mark;      yystate = *yyssp;
     yystack.l_mark -= yym;      yyvsp -= yym;
     yym = yylhs[yyn];     yym = yylhs[yyn];
     if (yystate == 0 && yym == 0)     if (yystate == 0 && yym == 0)
     {     {
Line 895 
Line 869 
  state %d\n", YYPREFIX, YYFINAL);  state %d\n", YYPREFIX, YYFINAL);
 #endif #endif
         yystate = YYFINAL;         yystate = YYFINAL;
         *++yystack.s_mark = YYFINAL;          *++yyssp = YYFINAL;
         *++yystack.l_mark = yyval;          *++yyvsp = yyval;
         if (yychar < 0)         if (yychar < 0)
         {         {
             if ((yychar = YYLEX) < 0) yychar = 0;              if ((yychar = yylex()) < 0) yychar = 0;
 #if YYDEBUG #if YYDEBUG
             if (yydebug)             if (yydebug)
             {             {
Line 922 
Line 896 
 #if YYDEBUG #if YYDEBUG
     if (yydebug)     if (yydebug)
         printf("%sdebug: after reduction, shifting from state %d \         printf("%sdebug: after reduction, shifting from state %d \
 to state %d\n", YYPREFIX, *yystack.s_mark, yystate);  to state %d\n", YYPREFIX, *yyssp, yystate);
 #endif #endif
     if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack))      if (yyssp >= yysslim && yygrowstack())
     {     {
         goto yyoverflow;         goto yyoverflow;
     }     }
     *++yystack.s_mark = (short) yystate;      *++yyssp = yystate;
     *++yystack.l_mark = yyval;      *++yyvsp = yyval;
     goto yyloop;     goto yyloop;
  
 yyoverflow: yyoverflow:
     yyerror("yacc stack overflow");     yyerror("yacc stack overflow");
  
 yyabort: yyabort:
     yyfreestack(&yystack);  
     return (1);     return (1);
  
 yyaccept: yyaccept:
     yyfreestack(&yystack);  
     return (0);     return (0);
 } }

Legend:
Removed from v.1.2  
changed lines
  Added in v.1.3
ViewCVS 0.9.2